The FreeRADIUS server $Id: 15bac2a4c627c01d1aa2047687b3418955ac7f00 $
Loading...
Searching...
No Matches
tmpl_eval.c
Go to the documentation of this file.
1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
15 */
16
17/**
18 * $Id: a370b09ca66d3216c065972f7a1db8cf7140e9b4 $
19 *
20 * @brief #fr_pair_t template functions
21 * @file src/lib/server/tmpl_eval.c
22 *
23 * @ingroup AVP
24 *
25 * @copyright 2014-2020 The FreeRADIUS server project
26 */
27RCSID("$Id: a370b09ca66d3216c065972f7a1db8cf7140e9b4 $")
28
29#define _TMPL_PRIVATE 1
30
31#include <freeradius-devel/server/exec.h>
32#include <freeradius-devel/server/exec_legacy.h>
33#include <freeradius-devel/server/tmpl.h>
34#include <freeradius-devel/server/tmpl_dcursor.h>
35#include <freeradius-devel/server/client.h>
36#include <freeradius-devel/unlang/call.h>
37
38#include <freeradius-devel/util/atexit.h>
39#include <freeradius-devel/util/edit.h>
40
41
43static fr_dict_t const *dict_radius;
44
47 { .out = &dict_freeradius, .proto = "freeradius" },
48 { .out = &dict_radius, .proto = "radius" }, /* @todo - remove RADIUS from the server core... */
49 { NULL }
50};
51
52/** Placeholder attribute for uses of unspecified attribute references
53 */
56
57
58/** Resolve attribute #fr_pair_list_t value to an attribute list.
59 *
60 * The value returned is a pointer to the pointer of the HEAD of a #fr_pair_t list in the
61 * #request_t. If the head of the list changes, the pointer will still be valid.
62 *
63 * @param[in] request containing the target lists.
64 * @param[in] list #fr_pair_list_t value to resolve to #fr_pair_t list. Will be NULL if list
65 * name couldn't be resolved.
66 * @return a pointer to the HEAD of a list in the #request_t.
67 *
68 * @see tmpl_dcursor_init
69 */
71{
72 if (!request) return NULL;
73
74 if (list == request_attr_request) {
75 if (!request->packet) return NULL;
76 return &request->request_pairs;
77 }
78
79 if (list == request_attr_reply) {
80 if (!request->reply) return NULL;
81 return &request->reply_pairs;
82 }
83
84 if (list == request_attr_control) return &request->control_pairs;
85
86 if (list == request_attr_state) return &request->session_state_pairs;
87
88 if (list == request_attr_local) return &request->local_pairs;
89
90 RWDEBUG2("List \"%s\" is not available", tmpl_list_name(list, "<INVALID>"));
91
92 return NULL;
93}
94
95/** Return the correct TALLOC_CTX to alloc #fr_pair_t in, for a list
96 *
97 * Allocating new #fr_pair_t in the context of a #request_t is usually wrong.
98 * #fr_pair_t should be allocated in the context of a #fr_packet_t, so that if the
99 * #fr_packet_t is freed before the #request_t, the associated #fr_pair_t lists are
100 * freed too.
101 *
102 * @param[in] request containing the target lists.
103 * @param[in] list #fr_pair_list_t value to resolve to TALLOC_CTX.
104 * @return
105 * - TALLOC_CTX on success.
106 * - NULL on failure.
107 *
108 * @see tmpl_pair_list
109 */
110TALLOC_CTX *tmpl_list_ctx(request_t *request, fr_dict_attr_t const *list)
111{
112 if (!request) return NULL;
113
114 if (list == request_attr_request) return request->request_ctx;
115
116 if (list == request_attr_reply) return request->reply_ctx;
117
118 if (list == request_attr_control) return request->control_ctx;
119
120 if (list == request_attr_state) return request->session_state_ctx;
121
122 if (list == request_attr_local) return request->local_ctx;
123
124 return NULL;
125}
126
127/** Resolve a list to the #fr_packet_t holding the HEAD pointer for a #fr_pair_t list
128 *
129 * Returns a pointer to the #fr_packet_t that holds the HEAD pointer of a given list,
130 * for the current #request_t.
131 *
132 * @param[in] request To resolve list in.
133 * @param[in] list #fr_pair_list_t value to resolve to #fr_packet_t.
134 * @return
135 * - #fr_packet_t on success.
136 * - NULL on failure.
137 *
138 * @see tmpl_pair_list
139 */
141{
142 if (list == request_attr_request) return request->packet;
143
144 if (list == request_attr_reply) return request->reply;
145
146 return NULL;
147}
148
149/** Resolve a #tmpl_request_ref_t to a #request_t.
150 *
151 * Sometimes #request_t structs may be chained to each other, as is the case
152 * when internally proxying EAP. This function resolves a #tmpl_request_ref_t
153 * to a #request_t higher in the chain than the current #request_t.
154 *
155 * @see tmpl_pair_list
156 * @param[in,out] context #request_t to start resolving from, and where to write
157 * a pointer to the resolved #request_t back to.
158 * @param[in] rql list of request qualifiers to follow.
159 * @return
160 * - 0 if request is valid in this context.
161 * - -1 if request is not valid in this context.
162 */
163int tmpl_request_ptr(request_t **context, FR_DLIST_HEAD(tmpl_request_list) const *rql)
164{
165 tmpl_request_t *rr = NULL;
166 request_t *request = *context;
167
168 while ((rr = tmpl_request_list_next(rql, rr))) {
169 switch (rr->request) {
170 case REQUEST_CURRENT:
171 continue; /* noop */
172
173 case REQUEST_PARENT: /* Navigate up one level */
174 if (!request->parent) return -1;
175 request = request->parent;
176 break;
177
178 case REQUEST_OUTER: /* Navigate to the outermost request */
179 if (!request->parent) return -1;
180 while (request->parent) request = request->parent;
181 break;
182
183 case REQUEST_UNKNOWN:
184 default:
185 fr_assert(0);
186 return -1;
187 }
188 }
189
190 *context = request;
191
192 return 0;
193}
194
195/** Return the native data type of the expression
196 *
197 * @param[in] vpt to determine the type of.
198 * @return
199 * - FR_TYPE_NULL if the type of the #tmpl_t can't be determined.
200 * - The data type we'd expect the #tmpl_t to produce at runtime
201 * when expanded.
202 */
204{
205 /*
206 * Regexes can't be expanded
207 */
209
210 /*
211 * Casts take precedence over everything.
212 */
214
215 /*
216 * Anything that's not a bare word will
217 * be a string unless there's a casting
218 * operator.
219 */
220 if (vpt->quote != T_BARE_WORD) return FR_TYPE_STRING;
221
222 switch (vpt->type) {
223 case TMPL_TYPE_ATTR:
224 return tmpl_attr_tail_da(vpt)->type;
225
226 case TMPL_TYPE_DATA:
227 return tmpl_value_type(vpt);
228
229 case TMPL_TYPE_XLAT:
230 case TMPL_TYPE_EXEC:
231 return FR_TYPE_STRING;
232
233 default:
234 break;
235 }
236
237 return FR_TYPE_NULL;
238}
239
240/** Expand a #tmpl_t to a string writing the result to a buffer
241 *
242 * The intended use of #tmpl_expand and #tmpl_aexpand is for modules to easily convert a #tmpl_t
243 * provided by the conf parser, into a usable value.
244 * The value returned should be raw and undoctored for #FR_TYPE_STRING and #FR_TYPE_OCTETS types,
245 * and the printable (string) version of the data for all others.
246 *
247 * Depending what arguments are passed, either copies the value to buff, or writes a pointer
248 * to a string buffer to out. This allows the most efficient access to the value resolved by
249 * the #tmpl_t, avoiding unnecessary string copies.
250 *
251 * @note This function is used where raw string values are needed, which may mean the string
252 * returned may be binary data or contain unprintable chars. #fr_snprint or #fr_asprint
253 * should be used before using these values in debug statements. #is_printable can be used to
254 * check if the string only contains printable chars.
255 *
256 * @param[out] out Where to write a pointer to the string buffer. On return may
257 * point to buff if buff was used to store the value. Otherwise will
258 * point to a #fr_value_box_t buffer, or the name of the template.
259 * Must not be NULL.
260 * @param[out] buff Expansion buffer, may be NULL except for the following types:
261 * - #TMPL_TYPE_EXEC
262 * - #TMPL_TYPE_XLAT
263 * - input type non-string, output type string
264 * @param[in] bufflen Length of expansion buffer. Must be >= 2.
265 * @param[in] request Current request.
266 * @param[in] vpt to expand. Must be one of the following types:
267 * - #TMPL_TYPE_EXEC
268 * - #TMPL_TYPE_XLAT
269 * - #TMPL_TYPE_ATTR
270 * - #TMPL_TYPE_DATA
271 * @param dst_type FR_TYPE_* matching out pointer. @see tmpl_expand.
272 * @return
273 * - -1 on failure.
274 * - The length of data written out.
275 */
277 uint8_t *buff, size_t bufflen,
278 request_t *request,
279 tmpl_t const *vpt,
280 fr_type_t dst_type)
281{
282 fr_value_box_t value_to_cast = FR_VALUE_BOX_INITIALISER_NULL(value_to_cast);
283 fr_value_box_t value_from_cast = FR_VALUE_BOX_INITIALISER_NULL(value_from_cast);
284 fr_value_box_t const *to_cast = NULL;
285 fr_value_box_t const *from_cast = NULL;
286
287 fr_pair_t *vp = NULL;
288
289 ssize_t slen = -1; /* quiet compiler */
290
292
295
296 fr_assert(!buff || (bufflen >= 2));
297
298 switch (vpt->type) {
299 case TMPL_TYPE_EXEC:
300 RDEBUG4("EXPAND TMPL EXEC");
301 if (!buff) {
302 REDEBUG("Missing expansion buffer for exec");
303 return -1;
304 }
305
306 if (radius_exec_program_legacy((char *) buff, bufflen, request, vpt->name, NULL,
307 true, false, fr_time_delta_from_sec(EXEC_TIMEOUT)) != 0) return -1;
308
309 fr_value_box_strdup_shallow(&value_to_cast, NULL, (char *) buff, true);
310 to_cast = &value_to_cast;
311 break;
312
313 case TMPL_TYPE_XLAT:
314 RDEBUG4("EXPAND TMPL XLAT PARSED");
315
316 /* No EXPAND <xlat> here as the xlat code does it */
317
318 if (!buff) {
319 REDEBUG("Missing expansion buffer for dynamic expansion");
320 return -1;
321 }
322
323 /* Error in expansion, this is distinct from zero length expansion */
324 slen = xlat_eval_compiled((char *) buff, bufflen, request, tmpl_xlat(vpt), NULL, NULL);
325 if (slen < 0) return slen;
326
327 fr_value_box_bstrndup_shallow(&value_to_cast, NULL, (char *) buff, slen, true);
328 to_cast = &value_to_cast;
329 break;
330
331 case TMPL_TYPE_ATTR:
332 RDEBUG4("EXPAND TMPL ATTR");
333 if (tmpl_find_vp(&vp, request, vpt) < 0) {
334 REDEBUG("Failed to find attribute %s", vpt->name);
335 return -2;
336 }
337
338 to_cast = &vp->data;
339 break;
340
341 case TMPL_TYPE_DATA:
342 RDEBUG4("EXPAND TMPL DATA");
343 to_cast = tmpl_value(vpt);
344 break;
345
346 /*
347 * We should never be expanding these.
348 */
354 case TMPL_TYPE_REGEX:
358 case TMPL_TYPE_MAX:
359 fr_assert(0);
360 return -1;
361 }
362
363 /*
364 * Same type, just copy the value.
365 *
366 * If the input is exec/xlat, then we can just copy the output ptr to the caller, as it's already
367 * pointing to "buff".
368 */
369 if (to_cast->type == dst_type) {
370 from_cast = to_cast;
371 goto do_copy;
372 }
373
374 /*
375 * We need a buffer to hold ouput data which can be returned to the caller.
376 */
377 if (fr_type_is_variable_size(dst_type) && !buff) {
378 REDEBUG("Missing expansion buffer for %s -> %s cast", fr_type_to_str(to_cast->type), fr_type_to_str(dst_type));
379 return -1;
380 }
381
382 /*
383 * Convert to the correct data type.
384 */
385 if (fr_value_box_cast(request, &value_from_cast, dst_type, NULL, to_cast)) {
386 RPEDEBUG("Failed casting input %pV to data type %s", to_cast, fr_type_to_str(dst_type));
387 return -1;
388 }
389
390 from_cast = &value_from_cast;
391
392 /*
393 * If the output is a talloc'd buffer, then we have to copy it to "buff", so that we can return
394 * the pointer to the caller.
395 */
396 if (fr_type_is_variable_size(dst_type)) {
397 size_t len = from_cast->vb_length + (dst_type == FR_TYPE_STRING);
398
399 if (bufflen < len) {
400 REDEBUG("Expansion buffer is too small. Buffer is %zu bytes, and we need %zu bytes",
401 bufflen, len);
402 }
403
404 /*
405 * Copy the data to the buffer, and clear the alloc'd pointer.
406 */
407 memcpy(buff, to_cast->vb_octets, len);
408 fr_value_box_clear(&value_from_cast);
409
410 /*
411 * "out" is a pointer to a char* or uint8_t*
412 */
413 *(uint8_t **) out = buff;
414
415 return from_cast->vb_length;
416 }
417
418do_copy:
419 RDEBUG4("Copying %zu bytes to %p from offset %zu",
421
422 fr_value_box_memcpy_out(out, from_cast);
423
424 return from_cast->vb_length;
425}
426
427/** Expand a template to a string, allocing a new buffer to hold the string
428 *
429 * The intended use of #tmpl_expand and #tmpl_aexpand is for modules to easily convert a #tmpl_t
430 * provided by the conf parser, into a usable value.
431 * The value returned should be raw and undoctored for #FR_TYPE_STRING and #FR_TYPE_OCTETS types,
432 * and the printable (string) version of the data for all others.
433 *
434 * This function will always duplicate values, whereas #tmpl_expand may return a pointer to an
435 * existing buffer.
436 *
437 * @note This function is used where raw string values are needed, which may mean the string
438 * returned may be binary data or contain unprintable chars. #fr_snprint or #fr_asprint should
439 * be used before using these values in debug statements. #is_printable can be used to check
440 * if the string only contains printable chars.
441 *
442 * @note The type (char or uint8_t) can be obtained with talloc_get_type, and may be used as a
443 * hint as to how to process or print the data.
444 *
445 * @param ctx to allocate new buffer in.
446 * @param out Where to write pointer to the new buffer.
447 * @param request Current request.
448 * @param vpt to expand. Must be one of the following types:
449 * - #TMPL_TYPE_DATA_UNRESOLVED
450 * - #TMPL_TYPE_EXEC
451 * - #TMPL_TYPE_XLAT
452 * - #TMPL_TYPE_ATTR
453 * - #TMPL_TYPE_DATA
454 * @param escape xlat escape function (only used for TMPL_TYPE_XLAT_UNRESOLVED_* types).
455 * @param escape_ctx xlat escape function data (only used for TMPL_TYPE_XLAT_UNRESOLVED_* types).
456 * @param dst_type FR_TYPE_* matching out pointer. @see tmpl_aexpand.
457 * @return
458 * - -1 on failure.
459 * - The length of data written to buff, or pointed to by out.
460 */
461ssize_t _tmpl_to_atype(TALLOC_CTX *ctx, void *out,
462 request_t *request,
463 tmpl_t const *vpt,
464 xlat_escape_legacy_t escape, void const *escape_ctx,
465 fr_type_t dst_type)
466{
467 fr_value_box_t *vb_out, *vb_in = NULL;
469
470 fr_pair_t *vp = NULL;
471 bool needs_dup = false;
472
473 ssize_t slen = -1;
474 int ret;
475
476 TALLOC_CTX *tmp_ctx = NULL;
477 char *str = NULL;
478
480
483
484 switch (vpt->type) {
485 case TMPL_TYPE_EXEC:
486 RDEBUG4("EXPAND TMPL EXEC");
487
488 MEM(tmp_ctx = talloc_new(ctx));
489
490 MEM(fr_value_box_bstr_alloc(tmp_ctx, &str, &value, NULL, 1024, true));
491 if (radius_exec_program_legacy(str, 1024, request, vpt->name, NULL,
492 true, false, fr_time_delta_from_sec(EXEC_TIMEOUT)) != 0) {
493 error:
494 talloc_free(tmp_ctx);
495 return slen;
496 }
497
498 fr_value_box_strtrim(tmp_ctx, &value);
499 vb_in = &value;
500 break;
501
502 case TMPL_TYPE_XLAT:
504 RDEBUG4("EXPAND TMPL XLAT STRUCT");
505
506 MEM(tmp_ctx = talloc_new(ctx));
507
508 /*
509 * An error in expansion is distinct from zero
510 * length expansion. Zero-length strings are
511 * permitted.
512 */
513 slen = xlat_aeval_compiled(tmp_ctx, &str, request, tmpl_xlat(vpt), escape, escape_ctx);
514 if (slen < 0) {
515 RPEDEBUG("Failed expanding %s", vpt->name);
516 goto error;
517 }
518
519 /*
520 * The output is a string which might get cast to something later.
521 */
522 fr_value_box_bstrndup_shallow(&value, NULL, str, (size_t) slen, false);
523 vb_in = &value;
524 break;
525
526 case TMPL_TYPE_ATTR:
527 RDEBUG4("EXPAND TMPL ATTR");
528
529 ret = tmpl_find_vp(&vp, request, vpt);
530 if (ret < 0) {
531 RDEBUG("Failed finding attribute %s", vpt->name);
532 talloc_free(tmp_ctx);
533 return -2;
534 }
535
536 fr_assert(vp);
537
538 needs_dup = true;
539 vb_in = &vp->data;
540 break;
541
542 case TMPL_TYPE_DATA:
543 RDEBUG4("EXPAND TMPL DATA");
544
545 needs_dup = true;
547 break;
548
549 /*
550 * We should never be expanding these.
551 */
554 case TMPL_TYPE_REGEX:
560 case TMPL_TYPE_MAX:
561 fr_assert(0);
562 goto error;
563 }
564
565 fr_assert(vb_in != NULL);
566 VALUE_BOX_VERIFY(vb_in);
567
568 /*
569 * If the output is a value-box, we might cast it using the tmpl cast. When done, we just copy
570 * the value-box.
571 */
572 if (dst_type == FR_TYPE_VALUE_BOX) {
573 fr_type_t cast_type;
574
575 MEM(vb_out = fr_value_box_alloc_null(ctx));
576 cast_type = tmpl_rules_cast(vpt);
577
578 if (cast_type == FR_TYPE_NULL) {
579 if (needs_dup) {
580 if (unlikely(fr_value_box_copy(vb_out, vb_out, vb_in) < 0)) {
581 talloc_free(vb_out);
582 goto failed_cast;
583 }
584 } else {
585 fr_value_box_steal(vb_out, vb_out, vb_in);
586 }
587 talloc_free(tmp_ctx);
588
589 } else {
590 ret = fr_value_box_cast(vb_out, vb_out, cast_type, NULL, vb_in);
591 talloc_free(tmp_ctx);
592
593 if (ret < 0) {
594 talloc_free(vb_out);
595 dst_type = cast_type;
596
597 failed_cast:
598 RPEDEBUG("Failed casting input %pV to data type %s", vb_in, fr_type_to_str(dst_type));
599 goto error;
600 }
601 }
602
603 VALUE_BOX_VERIFY(vb_out);
604 *(fr_value_box_t **) out = vb_out;
605 return 0;
606 }
607
608 /*
609 * Cast the data to the correct type. Which also allocates any variable sized buffers from the
610 * output ctx.
611 */
612 if (dst_type != vb_in->type) {
613 if (vb_in == &value) {
614 fr_assert(tmp_ctx != NULL);
615 fr_assert(str != NULL);
616 fr_assert(dst_type != FR_TYPE_STRING); /* exec / xlat returned string in 'str' */
617
618 slen = fr_value_box_from_str(ctx, &value, dst_type, NULL, str, (size_t) slen, NULL);
619 if (slen < 0) {
620 fr_value_box_bstrndup_shallow(&value, NULL, str, (size_t) slen, false);
621 goto failed_cast;
622 }
623
624 } else {
625 ret = fr_value_box_cast(ctx, &value, dst_type, NULL, vb_in);
626 if (ret < 0) goto failed_cast;
627 }
628
629 /*
630 * The input data has been converted, and placed into value.
631 */
632 vb_in = &value;
633
634 } else if (fr_type_is_variable_size(dst_type)) {
635 /*
636 * The output type is the same, but variable sized types need to be either duplicated, or
637 * reparented.
638 */
639 if (needs_dup) {
640 fr_assert(vb_in != &value);
641
642 if (unlikely(fr_value_box_copy(ctx, &value, vb_in) < 0)) goto failed_cast;
643 vb_in = &value;
644 } else {
645 fr_assert(dst_type == FR_TYPE_STRING);
646 fr_assert(str != NULL);
647
648 (void) talloc_steal(ctx, str); /* ensure it's parented from the right context */
649 fr_assert(vb_in == &value);
650 }
651 } /* else the output type is a leaf, and is the same data type as the input */
652
653 RDEBUG4("Copying %zu bytes to %p from offset %zu",
655
657
658 /*
659 * Frees any memory allocated for temporary buffers
660 * in this function.
661 */
662 talloc_free(tmp_ctx);
663
664 return vb_in->vb_length;
665}
666
667/** Copy pairs matching a #tmpl_t in the current #request_t
668 *
669 * @param ctx to allocate new #fr_pair_t in.
670 * @param out Where to write the copied #fr_pair_t (s).
671 * @param request The current #request_t.
672 * @param vpt specifying the #fr_pair_t type or list to copy.
673 * Must be one of the following types:
674 * - #TMPL_TYPE_ATTR
675 * @return
676 * - -1 if no matching #fr_pair_t could be found.
677 * - -2 if list could not be found (doesn't exist in current #request_t).
678 * - -3 if context could not be found (no parent #request_t available).
679 * - -4 on memory allocation error.
680 */
681int tmpl_copy_pairs(TALLOC_CTX *ctx, fr_pair_list_t *out, request_t *request, tmpl_t const *vpt)
682{
683 fr_pair_t *vp;
684 fr_dcursor_t from;
686 int err;
687
689
691
692 for (vp = tmpl_dcursor_init(&err, NULL, &cc, &from, request, vpt);
693 vp;
694 vp = fr_dcursor_next(&from)) {
695 vp = fr_pair_copy(ctx, vp);
696 if (!vp) {
698 fr_strerror_const("Out of memory");
699 err = -4;
700 break;
701 }
703 }
705
706 return err;
707}
708
709
710/** Copy children of pairs matching a #tmpl_t in the current #request_t
711 *
712 * @param ctx to allocate new #fr_pair_t in.
713 * @param out Where to write the copied #fr_pair_t (s).
714 * @param request The current #request_t.
715 * @param vpt specifying the #fr_pair_t type or list to copy.
716 * Must be one of the following types:
717 * - #TMPL_TYPE_ATTR
718 * @return
719 * - -1 if no matching #fr_pair_t could be found.
720 * - -2 if list could not be found (doesn't exist in current #request_t).
721 * - -3 if context could not be found (no parent #request_t available).
722 * - -4 on memory allocation error.
723 */
724int tmpl_copy_pair_children(TALLOC_CTX *ctx, fr_pair_list_t *out, request_t *request, tmpl_t const *vpt)
725{
726 fr_pair_t *vp;
727 fr_dcursor_t from;
729 int err;
730
732
734
736
737 for (vp = tmpl_dcursor_init(&err, NULL, &cc, &from, request, vpt);
738 vp;
739 vp = fr_dcursor_next(&from)) {
740 switch (vp->vp_type) {
742 if (fr_pair_list_copy(ctx, out, &vp->vp_group) < 0) {
743 err = -4;
744 goto done;
745 }
746 break;
747
748 default:
749 continue;
750 }
751 }
752done:
754
755 return err;
756}
757
758
759/** Returns the first VP matching a #tmpl_t
760 *
761 * @param[out] out where to write the retrieved vp.
762 * @param[in] request The current #request_t.
763 * @param[in] vpt specifying the #fr_pair_t type to find.
764 * Must be one of the following types:
765 * - #TMPL_TYPE_ATTR
766 * @return
767 * - 0 on success (found matching #fr_pair_t).
768 * - -1 if no matching #fr_pair_t could be found.
769 * - -2 if list could not be found (doesn't exist in current #request_t).
770 * - -3 if context could not be found (no parent #request_t available).
771 */
773{
774 fr_dcursor_t cursor;
776 fr_pair_t *vp;
777 int err;
778
780
781 vp = tmpl_dcursor_init(&err, request, &cc, &cursor, request, vpt);
783
784 if (out) *out = vp;
785
786 return err;
787}
788
789/** Returns the first VP matching a #tmpl_t, or if no VPs match, creates a new one.
790 *
791 * @param[out] out where to write the retrieved or created vp.
792 * @param[in] request The current #request_t.
793 * @param[in] vpt specifying the #fr_pair_t type to retrieve or create. Must be #TMPL_TYPE_ATTR.
794 * @return
795 * - 1 on success a pair was created.
796 * - 0 on success a pair was found.
797 * - -1 if a new #fr_pair_t couldn't be found or created.
798 * - -2 if list could not be found (doesn't exist in current #request_t).
799 * - -3 if context could not be found (no parent #request_t available).
800 */
802{
803 fr_dcursor_t cursor;
805 fr_pair_t *vp;
806 int err;
807
810
811 *out = NULL;
812
813 vp = tmpl_dcursor_init(&err, NULL, &cc, &cursor, request, vpt);
815
816 switch (err) {
817 case 0:
818 *out = vp;
819 return 0;
820
821 case -1:
822 {
823 TALLOC_CTX *ctx;
825
826 tmpl_pair_list_and_ctx(ctx, head, request, tmpl_request(vpt), tmpl_list(vpt));
827 if (!head) return -1;
828
829 if (pair_append_by_tmpl_parent(ctx, &vp, head, vpt, true) < 0) return -1;
830
831 *out = vp;
832 }
833 return 1;
834
835 default:
836 return err;
837 }
838}
839
840/** Allocate and insert a leaf vp from a tmpl_t, building the parent vps if needed.
841 *
842 * This is the simple case - just add a vp at the first place where
843 * the parents exist, or create the parents, with no attempt to handle filters.
844 *
845 * It is functionally equivalent to fr_pair_append_by_da_parent() but
846 * uses a tmpl_t to build the nested structure rather than a fr_dict_attr_t.
847 *
848 * @param[in] ctx to allocate new pair(s) in
849 * @param[out] out Leaf pair we allocated.
850 * @param[in] list to insert into.
851 * @param[in] vpt tmpl representing the attribute to add.
852 * @param[in] skip_list skip list attr ref at the head of the tmpl.
853 * @return
854 * - 0 on success.
855 * - -1 on failure.
856 */
857int pair_append_by_tmpl_parent(TALLOC_CTX *ctx, fr_pair_t **out, fr_pair_list_t *list, tmpl_t const *vpt, bool skip_list)
858{
859 fr_pair_t *vp = NULL;
860 TALLOC_CTX *pair_ctx = ctx;
861 tmpl_attr_t *ar, *leaf;
862 tmpl_attr_list_head_t const *ar_list = &vpt->data.attribute.ar;
863
864 if (!tmpl_is_attr(vpt)) {
865 error:
866 *out = NULL;
867 return -1;
868 }
869
870 leaf = tmpl_attr_list_tail(ar_list);
871 ar = tmpl_attr_list_head(ar_list);
872 if (!ar) goto error;
873 if (skip_list && tmpl_attr_is_list_attr(ar)) ar = tmpl_attr_list_next(ar_list, ar);
874
875 /*
876 * Walk down the tmpl ar stack looking for candidate parent
877 * attributes and then allocating the leaf.
878 */
879 while (true) {
880 if (unlikely(!ar)) goto error;
881 /*
882 * We're not at the leaf, look for a potential parent
883 */
884 if (ar != leaf) {
885 vp = fr_pair_find_by_da(list, NULL, ar->da);
886 /*
887 * HACK - Pretend we didn't see this stupid key field
888 *
889 * If we don't have this, the code creates a key pair
890 * and then horribly mangles its data by adding children
891 * to it.
892 *
893 * We just skip one level down an don't create or update
894 * the key pair.
895 *
896 * @todo - remove after migration_union_key is deleted
897 */
898 if (vp && fr_dict_attr_is_key_field(ar->da) && fr_type_is_leaf(vp->data.type)) {
899 ar = tmpl_attr_list_next(ar_list, ar);
900 continue;
901 }
902 }
903 /*
904 * Nothing found, create the pair
905 */
906 if (!vp) {
907 if (fr_pair_append_by_da(pair_ctx, &vp, list, ar->da) < 0) goto error;
908 }
909
910 /*
911 * We're at the leaf, return
912 */
913 if (ar == leaf) {
914 *out = vp;
915 return 0;
916 }
917
918 /*
919 * Prepare for next level
920 */
921 list = &vp->vp_group;
922 pair_ctx = vp;
923 vp = NULL;
924 ar = tmpl_attr_list_next(ar_list, ar);
925 }
926}
927
928/** Insert a value-box to a list, with casting.
929 *
930 * @param list to append to
931 * @param box box to cast / append
932 * @param vpt tmpl with cast.
933 * @return
934 * - <0 for "cast failed"
935 * - 0 for success
936 */
937int tmpl_value_list_insert_tail(fr_value_box_list_t *list, fr_value_box_t *box, tmpl_t const *vpt)
938{
940 (box->type == tmpl_rules_cast(vpt))) {
941 fr_value_box_list_insert_tail(list, box);
942 return 0;
943 }
944
945 if (fr_value_box_cast_in_place(box, box, tmpl_rules_cast(vpt), tmpl_rules_enumv(vpt)) < 0) return -1;
946
947 fr_value_box_list_insert_tail(list, box);
949 return 0;
950}
951
952/** Gets the value of a real or virtual attribute
953 *
954 * @param[in] ctx to allocate boxed value, and buffers in.
955 * @param[out] out Where to write the boxed value.
956 * @param[in] request The current request.
957 * @param[in] vpt Representing the attribute.
958 * @return
959 * - <0 we failed getting a value for the attribute.
960 * - 0 we successfully evaluated the tmpl
961 */
962int tmpl_eval_pair(TALLOC_CTX *ctx, fr_value_box_list_t *out, request_t *request, tmpl_t const *vpt)
963{
964 fr_pair_t *vp = NULL;
966
967 fr_dcursor_t cursor;
969
970 int ret = 0;
971 fr_value_box_list_t list;
972
974
975 fr_value_box_list_init(&list);
976
977 /*
978 * See if we're dealing with an attribute in the request
979 *
980 * This allows users to manipulate virtual attributes as if
981 * they were real ones.
982 */
983 vp = tmpl_dcursor_init(NULL, NULL, &cc, &cursor, request, vpt);
984
985 /*
986 * We didn't find the VP in a list, check to see if it's
987 * virtual. This allows the caller to "realize" the
988 * attribute, and we then prefer the realized version to
989 * the virtual one.
990 */
991 if (!vp) {
992 /*
993 * Zero count.
994 */
997 if (!value) {
998 oom:
999 fr_strerror_const("Out of memory");
1000 ret = -1;
1001 goto fail;
1002 }
1003 value->datum.int32 = 0;
1004 fr_value_box_list_insert_tail(&list, value);
1005 } /* Fall through to being done */
1006
1007 goto done;
1008 }
1009
1010 switch (tmpl_attr_tail_num(vpt)) {
1011 /*
1012 * Return a count of the VPs.
1013 */
1014 case NUM_COUNT:
1015 {
1016 uint32_t count = 0;
1017
1018 while (vp != NULL) {
1019 count++;
1020 vp = fr_dcursor_next(&cursor);
1021 }
1022
1024 if (!value) goto oom;
1025 value->datum.uint32 = count;
1026 fr_value_box_list_insert_tail(&list, value);
1027 break;
1028 }
1029
1030 /*
1031 * Output multiple #value_box_t, one per attribute.
1032 */
1033 case NUM_ALL:
1034 /*
1035 * Loop over all matching #fr_value_pair
1036 * shallow copying buffers.
1037 */
1038 while (vp != NULL) {
1039 if (fr_type_is_structural(vp->vp_type)) {
1041 if (!value) goto oom;
1042
1043 if (fr_pair_list_copy_to_box(value, &vp->vp_group) < 0) {
1045 goto oom;
1046 }
1047
1048 } else {
1049 value = fr_value_box_alloc(ctx, vp->data.type, vp->da);
1050 if (!value) goto oom;
1051 if(unlikely(fr_value_box_copy(value, value, &vp->data) < 0)) {
1053 goto fail;
1054 }
1055 }
1056
1057 fr_value_box_list_insert_tail(&list, value);
1058 vp = fr_dcursor_next(&cursor);
1059 }
1060 break;
1061
1062 default:
1063 if (!fr_type_is_leaf(vp->vp_type)) {
1064 fr_strerror_const("Invalid data type for evaluation");
1065 goto fail;
1066 }
1067
1068 value = fr_value_box_alloc(ctx, vp->data.type, vp->da);
1069 if (!value) goto oom;
1070
1071 if (unlikely(fr_value_box_copy(value, value, &vp->data) < 0)) goto fail;
1072 fr_value_box_list_insert_tail(&list, value);
1073 break;
1074 }
1075
1076done:
1077 /*
1078 * Evaluate casts if necessary.
1079 */
1080 if (ret == 0) {
1081 if (tmpl_eval_cast_in_place(&list, request, vpt) < 0) {
1082 fr_value_box_list_talloc_free(&list);
1083 ret = -1;
1084 goto fail;
1085 }
1086
1087 fr_value_box_list_move(out, &list);
1088 }
1089
1090fail:
1091 tmpl_dcursor_clear(&cc);
1093 return ret;
1094}
1095
1096
1097/** Gets the value of a tmpl
1098 *
1099 * The result is returned "raw". The caller must do any escaping it desires.
1100 *
1101 * @param[in] ctx to allocate boxed value, and buffers in.
1102 * @param[out] out Where to write the boxed value.
1103 * @param[in] request The current request.
1104 * @param[in] vpt Representing the tmpl
1105 * @return
1106 * - <0 we failed getting a value for the tmpl
1107 * - 0 we successfully evaluated the tmpl
1108 */
1109int tmpl_eval(TALLOC_CTX *ctx, fr_value_box_list_t *out, request_t *request, tmpl_t const *vpt)
1110{
1111 char *p;
1113 fr_value_box_list_t list;
1114
1116 fr_strerror_const("Cannot evaluate unresolved tmpl");
1117 return -1;
1118 }
1119
1120 if (tmpl_async_required(vpt)) {
1121 fr_strerror_const("Cannot statically evaluate asynchronous expansions");
1122 return -1;
1123 }
1124
1125 if (tmpl_contains_regex(vpt)) {
1126 fr_strerror_const("Cannot statically evaluate regular expression");
1127 return -1;
1128 }
1129
1130 if (tmpl_is_attr(vpt)) {
1131 return tmpl_eval_pair(ctx, out, request, vpt);
1132 }
1133
1134 if (tmpl_is_data(vpt)) {
1136
1139 return -1; /* Also dups taint */
1140 }
1141 goto done;
1142 }
1143
1145
1146 /*
1147 * @todo - respect escaping functions. But the sync
1148 * escaping uses a different method than the async ones.
1149 * And we then also need to escape the output of
1150 * tmpl_eval_pair(), too.
1151 */
1153 if (tmpl_aexpand(value, &p, request, vpt, NULL, NULL) < 0) {
1155 return -1;
1156 }
1157 fr_value_box_bstrndup_shallow(value, NULL, p, talloc_array_length(p) - 1, true);
1158
1159 /*
1160 * Cast the results if necessary.
1161 */
1162done:
1163 fr_value_box_list_init(&list);
1164 fr_value_box_list_insert_tail(&list, value);
1165
1166 if (tmpl_eval_cast_in_place(&list, request, vpt) < 0) {
1167 fr_value_box_list_talloc_free(&list);
1168 return -1;
1169 }
1170
1171 fr_value_box_list_move(out, &list);
1173
1174 return 0;
1175}
1176
1177/** Allocate a uctx for an escaping function
1178 *
1179 * @param[in] request The current request.
1180 * @param[in] escape Describing how to escape tmpl data.
1181 *
1182 * @return the uctx to pass to the escape function.
1183 */
1184static inline void *tmpl_eval_escape_uctx_alloc(request_t *request, tmpl_escape_t const *escape)
1185{
1186 switch (escape->uctx.type) {
1188 return UNCONST(void *, escape->uctx.ptr);
1189
1191 {
1192 void *uctx;
1193
1194 fr_assert_msg(escape->uctx.size > 0, "TMPL_ESCAPE_UCTX_ALLOC must specify uctx.size > 0");
1195 MEM(uctx = talloc_zero_array(NULL, uint8_t, escape->uctx.size));
1196 if (escape->uctx.talloc_type) talloc_set_type(uctx, escape->uctx.talloc_type);
1197 return uctx;
1198 }
1199
1201 fr_assert_msg(escape->uctx.func.alloc, "TMPL_ESCAPE_UCTX_ALLOC_FUNC must specify a non-null alloc.func");
1202 return escape->uctx.func.alloc(request, escape->uctx.func.uctx);
1203
1204 default:
1205 fr_assert_msg(0, "Unknown escape uctx type %u", escape->uctx.type);
1206 return NULL;
1207 }
1208}
1209
1210/** Free a uctx for an escaping function
1211 *
1212 * @param[in] escape Describing how to escape tmpl data.
1213 * @param[in] uctx The uctx to free.
1214 */
1215static inline void tmpl_eval_escape_uctx_free(tmpl_escape_t const *escape, void *uctx)
1216{
1217 switch (escape->uctx.type) {
1219 return;
1220
1222 talloc_free(uctx);
1223 return;
1224
1226 if (escape->uctx.func.free) escape->uctx.func.free(uctx);
1227 return;
1228 }
1229}
1230
1231/** Casts a value or list of values according to the tmpl
1232 *
1233 * @param[in,out] list Where to write the boxed value.
1234 * @param[in] request The current request.
1235 * @param[in] vpt Representing the attribute.
1236 * @return
1237 * - <0 the cast failed
1238 * - 0 we successfully evaluated the tmpl
1239 */
1240int tmpl_eval_cast_in_place(fr_value_box_list_t *list, request_t *request, tmpl_t const *vpt)
1241{
1243 bool did_concat = false;
1244 void *uctx = NULL;
1245
1246 if (fr_type_is_structural(cast)) {
1247 fr_strerror_printf("Cannot cast to structural type '%s'", fr_type_to_str(cast));
1248 return -1;
1249 }
1250
1251 /*
1252 * Quoting around the tmpl means everything
1253 * needs to be concatenated, either as a string
1254 * or octets string.
1255 */
1256 switch (vpt->quote) {
1261 {
1262 ssize_t slen;
1263 fr_value_box_t *vb;
1264
1265 vb = fr_value_box_list_head(list);
1266 if (!vb) return 0;
1267
1269 uctx = tmpl_eval_escape_uctx_alloc(request, &vpt->rules.escape);
1270 /*
1271 * Sets escaped values, so boxes don't get re-escaped
1272 */
1273 if (unlikely(fr_value_box_list_escape_in_place(list, &vpt->rules.escape.box_escape, uctx) < 0)) {
1274 error:
1275 tmpl_eval_escape_uctx_free(&vpt->rules.escape, uctx);
1276 return -1;
1277 }
1278 }
1279
1281 FR_VALUE_BOX_LIST_FREE_BOX, true, SIZE_MAX);
1282 if (slen < 0) goto error;
1284
1285 /*
1286 * If there's no cast, or it's a cast to
1287 * a string, we're done!
1288 *
1289 * Otherwise we now need to re-cast the
1290 * result.
1291 */
1292 if (fr_type_is_null(cast) || fr_type_is_string(cast)) {
1293 success:
1294 tmpl_eval_escape_uctx_free(&vpt->rules.escape, uctx);
1295 return 0;
1296 }
1297
1298 did_concat = true;
1299 }
1300 break;
1301
1302 default:
1303 break;
1304 }
1305
1306 if (fr_type_is_null(cast)) goto success;
1307
1308 /*
1309 * Quoting above handled all concatenation,
1310 * we now need to handle potentially
1311 * multivalued lists.
1312 */
1314 if (fr_value_box_cast_in_place(vb, vb, cast, NULL) < 0) goto error;
1315 }}
1316
1317 /*
1318 * ...and finally, apply the escape function
1319 * if necessary. This is done last so that
1320 * the escape function gets boxes of the type
1321 * it expects.
1322 */
1324 uctx = tmpl_eval_escape_uctx_alloc(request, &vpt->rules.escape);
1325 if (unlikely(fr_value_box_list_escape_in_place(list, &vpt->rules.escape.box_escape, uctx) < 0)) goto error;
1326 }
1327
1328 /*
1329 * If there's no escape function, but there is
1330 * a safe_for value, mark all the boxes up with
1331 * this value.
1332 *
1333 * This is mostly useful for call_env usage in
1334 * modules where certain values are implicitly safe
1335 * for consumption, like SQL statements in the SQL
1336 * module.
1337 */
1338 if (!vpt->rules.escape.box_escape.func && vpt->rules.escape.box_escape.safe_for) {
1339 fr_value_box_list_mark_safe_for(list, vpt->rules.escape.box_escape.safe_for);
1340 }
1341
1343
1345}
1346
1348{
1350
1351 if (vpt->quote != T_BARE_WORD) return FR_TYPE_STRING;
1352
1353 if (tmpl_is_data(vpt)) return tmpl_value_type(vpt);
1354
1355 if (tmpl_is_attr(vpt)) return tmpl_attr_tail_da(vpt)->type;
1356
1358
1359 return FR_TYPE_NULL; /* can't determine it */
1360}
1361
1362
1363static int _tmpl_global_free(UNUSED void *uctx)
1364{
1366
1367 return 0;
1368}
1369
1370static int _tmpl_global_init(UNUSED void *uctx)
1371{
1372 fr_dict_attr_t *da;
1373
1374 if (fr_dict_autoload(tmpl_dict) < 0) {
1375 PERROR("%s", __FUNCTION__);
1376 return -1;
1377 }
1378
1380 fr_assert(da != NULL);
1381
1382 da->type = FR_TYPE_NULL;
1383 tmpl_attr_unspec = da;
1384
1385 return 0;
1386}
1387
1389{
1390 int ret;
1391
1392 fr_atexit_global_once_ret(&ret, _tmpl_global_init, _tmpl_global_free, NULL);
1393
1394 return 0;
1395}
static int context
Definition radmin.c:71
#define UNCONST(_type, _ptr)
Remove const qualification from a pointer.
Definition build.h:167
#define RCSID(id)
Definition build.h:485
#define unlikely(_x)
Definition build.h:383
#define UNUSED
Definition build.h:317
static void * fr_dcursor_next(fr_dcursor_t *cursor)
Advanced the cursor to the next item.
Definition dcursor.h:290
#define fr_assert_msg(_x, _msg,...)
Calls panic_action ifndef NDEBUG, else logs error and causes the server to exit immediately with code...
Definition debug.h:202
#define MEM(x)
Definition debug.h:36
#define fr_dict_autofree(_to_free)
Definition dict.h:892
static fr_slen_t err
Definition dict.h:861
static fr_dict_attr_t * fr_dict_attr_unknown_raw_afrom_num(TALLOC_CTX *ctx, fr_dict_attr_t const *parent, unsigned int attr)
Definition dict.h:605
fr_dict_attr_t const * fr_dict_root(fr_dict_t const *dict)
Return the root attribute of a dictionary.
Definition dict_util.c:2496
fr_dict_t const ** out
Where to write a pointer to the loaded/resolved fr_dict_t.
Definition dict.h:300
#define fr_dict_autoload(_to_load)
Definition dict.h:889
#define fr_dict_attr_is_key_field(_da)
Definition dict.h:169
Specifies a dictionary which must be loaded/loadable for the module to function.
Definition dict.h:299
Test enumeration values.
Definition dict_test.h:92
#define FR_DLIST_HEAD(_name)
Expands to the type name used for the head wrapper structure.
Definition dlist.h:1122
#define EXEC_TIMEOUT
Default wait time for exec calls (in seconds).
Definition exec.h:32
int radius_exec_program_legacy(char *out, size_t outlen, request_t *request, char const *cmd, fr_pair_list_t *input_pairs, bool exec_wait, bool shell_escape, fr_time_delta_t timeout)
Execute a program.
#define PERROR(_fmt,...)
Definition log.h:228
#define RWDEBUG2(fmt,...)
Definition log.h:362
#define RPEDEBUG(fmt,...)
Definition log.h:376
#define RDEBUG4(fmt,...)
Definition log.h:344
talloc_free(reap)
size_t(* xlat_escape_legacy_t)(request_t *request, char *out, size_t outlen, char const *in, void *arg)
fr_type_t
@ FR_TYPE_STRING
String of printable characters.
@ FR_TYPE_NULL
Invalid (uninitialised) attribute type.
@ FR_TYPE_VALUE_BOX
A boxed value.
@ FR_TYPE_UINT32
32 Bit unsigned integer.
@ FR_TYPE_GROUP
A grouping of other attributes.
unsigned int uint32_t
long int ssize_t
unsigned char uint8_t
int fr_pair_append_by_da(TALLOC_CTX *ctx, fr_pair_t **out, fr_pair_list_t *list, fr_dict_attr_t const *da)
Alloc a new fr_pair_t (and append)
Definition pair.c:1464
int fr_pair_list_copy(TALLOC_CTX *ctx, fr_pair_list_t *to, fr_pair_list_t const *from)
Duplicate a list of pairs.
Definition pair.c:2321
fr_pair_t * fr_pair_find_by_da(fr_pair_list_t const *list, fr_pair_t const *prev, fr_dict_attr_t const *da)
Find the first pair with a matching da.
Definition pair.c:700
int fr_pair_append(fr_pair_list_t *list, fr_pair_t *to_add)
Add a VP to the end of the list.
Definition pair.c:1345
fr_pair_t * fr_pair_copy(TALLOC_CTX *ctx, fr_pair_t const *vp)
Copy a single valuepair.
Definition pair.c:495
int fr_pair_list_copy_to_box(fr_value_box_t *dst, fr_pair_list_t *from)
Copy the contents of a pair list to a set of value-boxes.
Definition pair.c:2356
#define fr_assert(_expr)
Definition rad_assert.h:38
static bool done
Definition radclient.c:81
#define REDEBUG(fmt,...)
Definition radclient.h:52
#define RDEBUG(fmt,...)
Definition radclient.h:53
fr_dict_attr_t const * request_attr_request
Definition request.c:43
fr_dict_attr_t const * request_attr_control
Definition request.c:45
fr_dict_attr_t const * request_attr_local
Definition request.c:47
fr_dict_attr_t const * request_attr_state
Definition request.c:46
fr_dict_attr_t const * request_attr_reply
Definition request.c:44
static int16_t tmpl_attr_tail_num(tmpl_t const *vpt)
Return the last attribute reference's attribute number.
Definition tmpl.h:885
#define TMPL_VERIFY(_vpt)
Definition tmpl.h:961
#define tmpl_is_xlat(vpt)
Definition tmpl.h:210
#define tmpl_rules_enumv(_tmpl)
Definition tmpl.h:943
#define tmpl_value(_tmpl)
Definition tmpl.h:937
#define tmpl_contains_regex(vpt)
Definition tmpl.h:226
#define tmpl_is_attr(vpt)
Definition tmpl.h:208
#define NUM_ALL
Definition tmpl.h:391
bool tmpl_async_required(tmpl_t const *vpt)
Return whether or not async is required for this tmpl.
#define tmpl_xlat(_tmpl)
Definition tmpl.h:930
static fr_dict_attr_t const * tmpl_list(tmpl_t const *vpt)
Definition tmpl.h:904
static bool tmpl_attr_is_list_attr(tmpl_attr_t const *ar)
Return true if the tmpl_attr is one of the list types.
Definition tmpl.h:679
#define tmpl_rules_cast(_tmpl)
Definition tmpl.h:942
@ TMPL_TYPE_REGEX_UNCOMPILED
Regex where compilation is possible but hasn't been performed yet.
Definition tmpl.h:158
@ TMPL_TYPE_MAX
Marker for the last tmpl type.
Definition tmpl.h:199
@ TMPL_TYPE_ATTR_UNRESOLVED
An attribute reference that we couldn't resolve but looked valid.
Definition tmpl.h:185
@ TMPL_TYPE_ATTR
Reference to one or more attributes.
Definition tmpl.h:142
@ TMPL_TYPE_XLAT
Pre-parsed xlat expansion.
Definition tmpl.h:146
@ TMPL_TYPE_EXEC
Callout to an external script or program.
Definition tmpl.h:150
@ TMPL_TYPE_REGEX_XLAT_UNRESOLVED
A regular expression with unresolved xlat functions or attribute references.
Definition tmpl.h:197
@ TMPL_TYPE_DATA
Value in native boxed format.
Definition tmpl.h:138
@ TMPL_TYPE_REGEX
Compiled (and possibly JIT'd) regular expression.
Definition tmpl.h:154
@ TMPL_TYPE_DATA_UNRESOLVED
Unparsed literal string.
Definition tmpl.h:179
@ TMPL_TYPE_XLAT_UNRESOLVED
A xlat expansion with unresolved xlat functions or attribute references.
Definition tmpl.h:193
@ TMPL_TYPE_REGEX_XLAT
A regex containing xlat expansions.
Definition tmpl.h:162
@ TMPL_TYPE_EXEC_UNRESOLVED
An exec with unresolved xlat function or attribute references.
Definition tmpl.h:189
@ TMPL_TYPE_UNINITIALISED
Uninitialised.
Definition tmpl.h:134
#define NUM_COUNT
Definition tmpl.h:392
#define tmpl_pair_list_and_ctx(_ctx, _head, _request, _ref, _list)
Determine the correct context and list head.
Definition tmpl.h:993
#define tmpl_is_data(vpt)
Definition tmpl.h:206
static fr_slen_t vpt
Definition tmpl.h:1269
#define tmpl_value_type(_tmpl)
Definition tmpl.h:939
static fr_dict_attr_t const * tmpl_attr_tail_da(tmpl_t const *vpt)
Return the last attribute reference da.
Definition tmpl.h:801
static char const * tmpl_list_name(fr_dict_attr_t const *list, char const *def)
Return the name of a tmpl list or def if list not provided.
Definition tmpl.h:915
@ REQUEST_OUTER
request_t containing the outer layer of the EAP conversation.
Definition tmpl.h:92
@ REQUEST_PARENT
Parent (whatever it is).
Definition tmpl.h:96
@ REQUEST_UNKNOWN
Unknown request.
Definition tmpl.h:97
@ REQUEST_CURRENT
The current request (default).
Definition tmpl.h:91
#define tmpl_aexpand(_ctx, _out, _request, _vpt, _escape, _escape_ctx)
Expand a tmpl to a C type, allocing a new buffer to hold the string.
Definition tmpl.h:1062
#define tmpl_needs_resolving(vpt)
Definition tmpl.h:223
static char buff[sizeof("18446744073709551615")+3]
Definition size_tests.c:41
return count
Definition module.c:155
fr_pair_t * vp
An element in a list of nested attribute references.
Definition tmpl.h:430
fr_dict_attr_t const *_CONST da
Resolved dictionary attribute.
Definition tmpl.h:434
Define manipulation functions for the attribute reference list.
Definition tmpl.h:471
tmpl_request_ref_t _CONST request
Definition tmpl.h:475
Stores an attribute, a value and various bits of other data.
Definition pair.h:68
fr_dict_attr_t const *_CONST da
Dictionary attribute defines the attribute number, vendor and type of the pair.
Definition pair.h:69
static fr_time_delta_t fr_time_delta_from_sec(int64_t sec)
Definition time.h:590
void tmpl_dcursor_clear(tmpl_dcursor_ctx_t *cc)
Clear any temporary state allocations.
#define tmpl_dcursor_init(_err, _ctx, _cc, _cursor, _request, _vpt)
Maintains state between cursor calls.
#define tmpl_escape_post_concat(_tmpl)
See if we should perform output escaping after concatenation.
#define tmpl_escape_pre_concat(_tmpl)
See if we should perform output escaping before concatenation.
@ TMPL_ESCAPE_UCTX_ALLOC
A new uctx of the specified size and type is allocated and freed when escaping is complete.
Definition tmpl_escape.h:33
@ TMPL_ESCAPE_UCTX_STATIC
A static (to us) is provided by whatever is initialising the tmpl_escape_t.
Definition tmpl_escape.h:31
@ TMPL_ESCAPE_UCTX_ALLOC_FUNC
A new uctx of the specified size and type is allocated and pre-populated by memcpying uctx....
Definition tmpl_escape.h:35
struct tmpl_escape_t::@75 uctx
Escaping rules for tmpls.
Definition tmpl_escape.h:80
int tmpl_find_vp(fr_pair_t **out, request_t *request, tmpl_t const *vpt)
Returns the first VP matching a tmpl_t.
Definition tmpl_eval.c:772
fr_packet_t * tmpl_packet_ptr(request_t *request, fr_dict_attr_t const *list)
Resolve a list to the fr_packet_t holding the HEAD pointer for a fr_pair_t list.
Definition tmpl_eval.c:140
int tmpl_value_list_insert_tail(fr_value_box_list_t *list, fr_value_box_t *box, tmpl_t const *vpt)
Insert a value-box to a list, with casting.
Definition tmpl_eval.c:937
fr_dict_attr_t const * tmpl_attr_unspec
Placeholder attribute for uses of unspecified attribute references.
Definition tmpl_eval.c:55
static int _tmpl_global_free(UNUSED void *uctx)
Definition tmpl_eval.c:1363
static fr_dict_t const * dict_freeradius
Definition tmpl_eval.c:42
static fr_dict_t const * dict_radius
Definition tmpl_eval.c:43
int tmpl_request_ptr(request_t **context, FR_DLIST_HEAD(tmpl_request_list) const *rql)
Resolve a tmpl_request_ref_t to a request_t.
Definition tmpl_eval.c:163
int tmpl_eval(TALLOC_CTX *ctx, fr_value_box_list_t *out, request_t *request, tmpl_t const *vpt)
Gets the value of a tmpl.
Definition tmpl_eval.c:1109
int tmpl_eval_cast_in_place(fr_value_box_list_t *list, request_t *request, tmpl_t const *vpt)
Casts a value or list of values according to the tmpl.
Definition tmpl_eval.c:1240
fr_pair_list_t * tmpl_list_head(request_t *request, fr_dict_attr_t const *list)
Resolve attribute fr_pair_list_t value to an attribute list.
Definition tmpl_eval.c:70
TALLOC_CTX * tmpl_list_ctx(request_t *request, fr_dict_attr_t const *list)
Return the correct TALLOC_CTX to alloc fr_pair_t in, for a list.
Definition tmpl_eval.c:110
ssize_t _tmpl_to_atype(TALLOC_CTX *ctx, void *out, request_t *request, tmpl_t const *vpt, xlat_escape_legacy_t escape, void const *escape_ctx, fr_type_t dst_type)
Expand a template to a string, allocing a new buffer to hold the string.
Definition tmpl_eval.c:461
fr_type_t tmpl_data_type(tmpl_t const *vpt)
Definition tmpl_eval.c:1347
int tmpl_global_init(void)
Definition tmpl_eval.c:1388
int tmpl_eval_pair(TALLOC_CTX *ctx, fr_value_box_list_t *out, request_t *request, tmpl_t const *vpt)
Gets the value of a real or virtual attribute.
Definition tmpl_eval.c:962
goto success
Definition tmpl_eval.c:1344
int tmpl_copy_pair_children(TALLOC_CTX *ctx, fr_pair_list_t *out, request_t *request, tmpl_t const *vpt)
Copy children of pairs matching a tmpl_t in the current request_t.
Definition tmpl_eval.c:724
ssize_t _tmpl_to_type(void *out, uint8_t *buff, size_t bufflen, request_t *request, tmpl_t const *vpt, fr_type_t dst_type)
Expand a tmpl_t to a string writing the result to a buffer.
Definition tmpl_eval.c:276
int tmpl_copy_pairs(TALLOC_CTX *ctx, fr_pair_list_t *out, request_t *request, tmpl_t const *vpt)
Copy pairs matching a tmpl_t in the current request_t.
Definition tmpl_eval.c:681
static void tmpl_eval_escape_uctx_free(tmpl_escape_t const *escape, void *uctx)
Free a uctx for an escaping function.
Definition tmpl_eval.c:1215
int tmpl_find_or_add_vp(fr_pair_t **out, request_t *request, tmpl_t const *vpt)
Returns the first VP matching a tmpl_t, or if no VPs match, creates a new one.
Definition tmpl_eval.c:801
static int _tmpl_global_init(UNUSED void *uctx)
Definition tmpl_eval.c:1370
fr_dict_autoload_t tmpl_dict[]
Definition tmpl_eval.c:46
static void * tmpl_eval_escape_uctx_alloc(request_t *request, tmpl_escape_t const *escape)
Allocate a uctx for an escaping function.
Definition tmpl_eval.c:1184
fr_type_t tmpl_expanded_type(tmpl_t const *vpt)
Return the native data type of the expression.
Definition tmpl_eval.c:203
int pair_append_by_tmpl_parent(TALLOC_CTX *ctx, fr_pair_t **out, fr_pair_list_t *list, tmpl_t const *vpt, bool skip_list)
Allocate and insert a leaf vp from a tmpl_t, building the parent vps if needed.
Definition tmpl_eval.c:857
@ T_SINGLE_QUOTED_STRING
Definition token.h:122
@ T_BARE_WORD
Definition token.h:120
@ T_BACK_QUOTED_STRING
Definition token.h:123
@ T_DOUBLE_QUOTED_STRING
Definition token.h:121
@ T_SOLIDUS_QUOTED_STRING
Definition token.h:124
ssize_t xlat_eval_compiled(char *out, size_t outlen, request_t *request, xlat_exp_head_t const *head, xlat_escape_legacy_t escape, void const *escape_ctx))
Definition xlat_eval.c:1806
static fr_slen_t head
Definition xlat.h:420
ssize_t xlat_aeval_compiled(TALLOC_CTX *ctx, char **out, request_t *request, xlat_exp_head_t const *head, xlat_escape_legacy_t escape, void const *escape_ctx))
Definition xlat_eval.c:1823
fr_type_t xlat_data_type(xlat_exp_head_t const *head)
void fr_pair_list_free(fr_pair_list_t *list)
Free memory used by a valuepair list.
#define fr_strerror_printf(_fmt,...)
Log to thread local error buffer.
Definition strerror.h:64
#define fr_strerror_const(_msg)
Definition strerror.h:223
#define fr_type_is_variable_size(_x)
Definition types.h:389
#define fr_type_is_structural(_x)
Definition types.h:393
#define fr_type_is_string(_x)
Definition types.h:349
#define FR_TYPE_STRUCTURAL
Definition types.h:317
#define fr_type_is_null(_x)
Definition types.h:348
#define fr_type_is_leaf(_x)
Definition types.h:394
static char const * fr_type_to_str(fr_type_t type)
Return a static string containing the type name.
Definition types.h:455
size_t const fr_value_box_field_sizes[]
How many bytes wide each of the value data fields are.
Definition value.c:152
int fr_value_box_strtrim(TALLOC_CTX *ctx, fr_value_box_t *vb)
Trim the length of the string buffer to match the length of the C string.
Definition value.c:4394
int fr_value_box_cast(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, fr_value_box_t const *src)
Convert one type of fr_value_box_t to another.
Definition value.c:3730
size_t const fr_value_box_offsets[]
Where the value starts in the fr_value_box_t.
Definition value.c:194
int fr_value_box_copy(TALLOC_CTX *ctx, fr_value_box_t *dst, const fr_value_box_t *src)
Copy value data verbatim duplicating any buffers.
Definition value.c:4148
int fr_value_box_list_escape_in_place(fr_value_box_list_t *list, fr_value_box_escape_t const *escape, void *uctx)
Escape a list of value boxes in place.
Definition value.c:6491
int fr_value_box_cast_in_place(TALLOC_CTX *ctx, fr_value_box_t *vb, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv)
Convert one type of fr_value_box_t to another in place.
Definition value.c:3976
ssize_t fr_value_box_from_str(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, char const *in, size_t inlen, fr_sbuff_unescape_rules_t const *erules)
Definition value.c:5747
void fr_value_box_list_mark_safe_for(fr_value_box_list_t *list, fr_value_box_safe_for_t safe_for)
Set the escaped flag for all value boxes in a list.
Definition value.c:6847
void fr_value_box_strdup_shallow(fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, bool tainted)
Assign a buffer containing a nul terminated string to a box, but don't copy it.
Definition value.c:4477
int fr_value_box_bstr_alloc(TALLOC_CTX *ctx, char **out, fr_value_box_t *dst, fr_dict_attr_t const *enumv, size_t len, bool tainted)
Alloc and assign an empty \0 terminated string to a fr_value_box_t.
Definition value.c:4512
int fr_value_box_steal(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_value_box_t *src)
Copy value data verbatim moving any buffers to the specified context.
Definition value.c:4301
void fr_value_box_clear(fr_value_box_t *data)
Clear/free any existing value and metadata.
Definition value.c:4131
void fr_value_box_bstrndup_shallow(fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, size_t len, bool tainted)
Assign a string to to a fr_value_box_t.
Definition value.c:4673
int fr_value_box_list_concat_in_place(TALLOC_CTX *ctx, fr_value_box_t *out, fr_value_box_list_t *list, fr_type_t type, fr_value_box_list_action_t proc_action, bool flatten, size_t max_size)
Concatenate a list of value boxes.
Definition value.c:6267
@ FR_VALUE_BOX_LIST_FREE_BOX
Free each processed box.
Definition value.h:236
#define fr_value_box_list_foreach_safe(_list_head, _iter)
Definition value.h:225
#define fr_value_box_alloc(_ctx, _type, _enumv)
Allocate a value box of a specific type.
Definition value.h:643
static int fr_value_box_memcpy_out(void *out, fr_value_box_t const *vb)
Copy the value of a value box to a field in a C struct.
Definition value.h:790
#define FR_VALUE_BOX_INITIALISER_NULL(_vb)
A static initialiser for stack/globally allocated boxes.
Definition value.h:510
#define VALUE_BOX_VERIFY(_x)
Definition value.h:1321
#define VALUE_BOX_LIST_VERIFY(_x)
Definition value.h:1322
#define fr_value_box_alloc_null(_ctx)
Allocate a value box for later use with a value assignment function.
Definition value.h:654
static size_t char ** out
Definition value.h:1023