The FreeRADIUS server $Id: 15bac2a4c627c01d1aa2047687b3418955ac7f00 $
Loading...
Searching...
No Matches
xlat_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: 720e6cab355e08eacb5ef2340c43d6119bd11ecb $
19 *
20 * @file xlat_eval.c
21 * @brief String expansion ("translation"). Evaluation of pre-parsed xlat expansions.
22 *
23 * @copyright 2018-2021 Arran Cudbard-Bell (a.cudbardb@freeradius.org)
24 * @copyright 2000,2006 The FreeRADIUS server project
25 * @copyright 2000 Alan DeKok (aland@freeradius.org)
26 */
27RCSID("$Id: 720e6cab355e08eacb5ef2340c43d6119bd11ecb $")
28
29#include <freeradius-devel/server/base.h>
30#include <freeradius-devel/server/tmpl_dcursor.h>
31#include <freeradius-devel/server/rcode.h>
32#include <freeradius-devel/unlang/mod_action.h>
33#include <freeradius-devel/unlang/xlat_priv.h>
34
35static int instance_count = 0;
36
38
40 { .out = &dict_freeradius, .proto = "freeradius" },
41 { NULL }
42};
43
44fr_dict_attr_t const *attr_expr_bool_enum; /* xlat_expr.c */
45fr_dict_attr_t const *attr_cast_base; /* xlat_expr.c */
46
58
60 { .out = &attr_expr_bool_enum, .name = "Expr-Bool-Enum", .type = FR_TYPE_BOOL, .dict = &dict_freeradius },
61 { .out = &attr_cast_base, .name = "Cast-Base", .type = FR_TYPE_UINT8, .dict = &dict_freeradius },
62
63 { .out = &attr_cast_time_res_sec, .name = "Cast-Time-Res-Sec", .type = FR_TYPE_TIME_DELTA, .dict = &dict_freeradius },
64 { .out = &attr_cast_time_res_min, .name = "Cast-Time-Res-Min", .type = FR_TYPE_TIME_DELTA, .dict = &dict_freeradius },
65 { .out = &attr_cast_time_res_hour, .name = "Cast-Time-Res-Hour", .type = FR_TYPE_TIME_DELTA, .dict = &dict_freeradius },
66 { .out = &attr_cast_time_res_day, .name = "Cast-Time-Res-Day", .type = FR_TYPE_TIME_DELTA, .dict = &dict_freeradius },
67 { .out = &attr_cast_time_res_week, .name = "Cast-Time-Res-Week", .type = FR_TYPE_TIME_DELTA, .dict = &dict_freeradius },
68 { .out = &attr_cast_time_res_month, .name = "Cast-Time-Res-Month", .type = FR_TYPE_TIME_DELTA, .dict = &dict_freeradius },
69 { .out = &attr_cast_time_res_year, .name = "Cast-Time-Res-Year", .type = FR_TYPE_TIME_DELTA, .dict = &dict_freeradius },
70 { .out = &attr_cast_time_res_csec, .name = "Cast-Time-Res-Centi-Sec", .type = FR_TYPE_TIME_DELTA, .dict = &dict_freeradius },
71 { .out = &attr_cast_time_res_msec, .name = "Cast-Time-Res-Milli-Sec", .type = FR_TYPE_TIME_DELTA, .dict = &dict_freeradius },
72 { .out = &attr_cast_time_res_usec, .name = "Cast-Time-Res-Micro-Sec", .type = FR_TYPE_TIME_DELTA, .dict = &dict_freeradius },
73 { .out = &attr_cast_time_res_nsec, .name = "Cast-Time-Res-Nano-Sec", .type = FR_TYPE_TIME_DELTA, .dict = &dict_freeradius },
74
75 { NULL }
76};
77
79 { L("done"), XLAT_ACTION_DONE },
80 { L("fail"), XLAT_ACTION_FAIL },
81 { L("push-child"), XLAT_ACTION_PUSH_CHILD },
82 { L("yield"), XLAT_ACTION_YIELD }
83};
85
86/*
87 * This should be updated if fr_time_precision_table[] adds more time resolutions.
88 */
90 { L("microseconds"), &attr_cast_time_res_usec },
91 { L("us"), &attr_cast_time_res_usec },
92
93 { L("nanoseconds"), &attr_cast_time_res_nsec },
94 { L("ns"), &attr_cast_time_res_nsec },
95
96 { L("milliseconds"), &attr_cast_time_res_msec },
97 { L("ms"), &attr_cast_time_res_msec },
98
99 { L("centiseconds"), &attr_cast_time_res_csec },
100 { L("cs"), &attr_cast_time_res_csec },
101
102 { L("seconds"), &attr_cast_time_res_sec },
103 { L("s"), &attr_cast_time_res_sec },
104
105 { L("minutes"), &attr_cast_time_res_min },
106 { L("m"), &attr_cast_time_res_min },
107
108 { L("hours"), &attr_cast_time_res_hour },
109 { L("h"), &attr_cast_time_res_hour },
110
111 { L("days"), &attr_cast_time_res_day },
112 { L("d"), &attr_cast_time_res_day },
113
114 { L("weeks"), &attr_cast_time_res_week },
115 { L("w"), &attr_cast_time_res_week },
116
117 /*
118 * These use special values FR_TIME_DUR_MONTH and FR_TIME_DUR_YEAR
119 */
120 { L("months"), &attr_cast_time_res_month },
121 { L("M"), &attr_cast_time_res_month },
122
123 { L("years"), &attr_cast_time_res_year },
124 { L("y"), &attr_cast_time_res_year },
125
126};
128
129fr_dict_attr_t const *xlat_time_res_attr(char const *res)
130{
131 fr_dict_attr_t const **da_p;
132
134 if (!da_p) return NULL;
135
136 return *da_p;
137}
138
139static ssize_t xlat_eval_sync(TALLOC_CTX *ctx, char **out, request_t *request, xlat_exp_head_t const * const head,
140 xlat_escape_legacy_t escape, void const *escape_ctx);
141
142/** Reconstruct the original expansion string from an xlat tree
143 *
144 * @param[in] out sbuff to print result in.
145 * @param[in] node in the tree to start printing.
146 * @return
147 * - The original expansion string on success.
148 * - NULL on error.
149 */
151{
152 switch (node->type) {
153 case XLAT_BOX:
154 case XLAT_GROUP:
155 fr_assert(node->fmt != NULL);
156 return fr_sbuff_in_sprintf(out, "%pV", fr_box_strvalue_buffer(node->fmt));
157
158 case XLAT_ONE_LETTER:
159 fr_assert(node->fmt != NULL);
160 return fr_sbuff_in_sprintf(out, "%%%s", node->fmt);
161
162 case XLAT_TMPL:
163 fr_assert(node->fmt != NULL);
164 if (tmpl_is_attr(node->vpt) && (node->fmt[0] == '&')) {
165 return fr_sbuff_in_strcpy(out, node->fmt);
166 } else {
167 return fr_sbuff_in_sprintf(out, "%%{%pV}", fr_box_strvalue_buffer(node->fmt));
168 }
169
170#ifdef HAVE_REGEX
171 case XLAT_REGEX:
172 return fr_sbuff_in_sprintf(out, "%%{%u}", node->regex_index);
173#endif
174
175 case XLAT_FUNC:
176 {
177 bool first_done = false;
178 fr_sbuff_t our_out;
179 fr_slen_t slen;
180
181 /*
182 * No arguments, just print an empty function.
183 */
184 if (!xlat_exp_head(node->call.args)) return fr_sbuff_in_sprintf(out, "%%%s()", node->call.func->name);
185
186 our_out = FR_SBUFF(out);
187 FR_SBUFF_IN_SPRINTF_RETURN(&our_out, "%%%s(", node->call.func->name);
188
189 if (node->call.args) {
190 xlat_exp_foreach(node->call.args, arg) {
191 if (first_done && (node->call.func->args)) {
192 FR_SBUFF_IN_CHAR_RETURN(&our_out, ',');
193 }
194
195 slen = xlat_fmt_print(&our_out, arg);
196 if (slen < 0) return slen - fr_sbuff_used(&our_out);
197
198 first_done = true;
199 }
200 }
201
202 FR_SBUFF_IN_CHAR_RETURN(&our_out, ')');
203 return fr_sbuff_set(out, &our_out);
204 }
205
206 default:
207 return 0;
208 }
209}
210
211/** Output what we're currently expanding
212 *
213 * @param[in] request The current request.
214 * @param[in] node Being processed.
215 * @param[in] args from previous expansion.
216 * @param[in] line Unused
217 */
218static inline void xlat_debug_log_expansion(request_t *request, xlat_exp_t const *node, fr_value_box_list_t const *args, UNUSED int line)
219{
220 if (node->flags.constant) return;
221
222 if (!RDEBUG_ENABLED2) return;
223
224 /*
225 * Because it's difficult to keep track of what
226 * the function was actually called with,
227 * we print the concatenated arguments list as
228 * well as the original fmt string.
229 */
230 if ((node->type == XLAT_FUNC) && !xlat_is_literal(node->call.args)) {
231 fr_token_t token = node->call.func->token;
232
233 if ((token == T_INVALID) || (!fr_comparison_op[token] && !fr_binary_op[token])) {
234 RDEBUG2("| %%%s(%pM)", node->call.func->name, args);
235 } else {
236 fr_value_box_t *a, *b;
237
238 a = fr_value_box_list_head(args);
239 b = fr_value_box_list_next(args, a);
240
241 RDEBUG2("| (%pV %s %pV)", a, fr_tokens[node->call.func->token], b);
242
243#ifndef NDEBUG
244 if (a && b) {
245 a = fr_value_box_list_next(args, b);
246 if (a) {
247 RDEBUG2("| ... ??? %pV", a);
248 fr_assert(0);
249 }
250 }
251#endif
252
253 }
254 } else {
255 fr_sbuff_t *agg;
256
257 FR_SBUFF_TALLOC_THREAD_LOCAL(&agg, 1024, SIZE_MAX);
258
259 if (xlat_fmt_print(agg, node) < 0) {
260 RERROR("Failed printing expansion");
261 return;
262 }
263 RDEBUG2("| %s", fr_sbuff_start(agg)); /* print line number here for debugging */
264 }
265}
266
267/** Output the list result of an expansion
268 *
269 * @param[in] request The current request.
270 * @param[in] node which was expanded.
271 * @param[in] result of the expansion.
272 */
273static inline void xlat_debug_log_list_result(request_t *request, xlat_exp_t const *node, fr_value_box_list_t const *result)
274{
275 if (node->flags.constant) return;
276
277 if (!RDEBUG_ENABLED2) return;
278
279 RDEBUG2("| --> %pM", result);
280}
281
282/** Output the result of an expansion
283 *
284 * @param[in] request The current request.
285 * @param[in] node which was expanded.
286 * @param[in] result of the expansion.
287 */
288static inline void xlat_debug_log_result(request_t *request, xlat_exp_t const *node, fr_value_box_t const *result)
289{
290 if (node->flags.constant) return;
291
292 if (!RDEBUG_ENABLED2) return;
293
294 RDEBUG2("| --> %pV", result);
295}
296
297static int xlat_arg_stringify(request_t *request, xlat_arg_parser_t const *arg, xlat_exp_t const *node, fr_value_box_t *vb)
298{
299 int rcode;
300
301 if (vb->type == FR_TYPE_GROUP) {
302 fr_value_box_list_foreach(&vb->vb_group, child) {
303 if (xlat_arg_stringify(request, arg, NULL, child) < 0) return -1;
304 }
305
306 if (!node || (node->quote == T_BARE_WORD)) return 0;
307
308 fr_assert(node->type == XLAT_GROUP);
309
310 /*
311 * Empty lists are empty strings.
312 */
313 if (!fr_value_box_list_head(&vb->vb_group)) {
314 fr_value_box_entry_t entry;
315
316 entry = vb->entry;
317 fr_value_box_init(vb, FR_TYPE_STRING, NULL, false);
318 fr_value_box_strdup(vb, vb, NULL, "", false);
319 vb->entry = entry;
320
322 return 0;
323 }
324
325 /*
326 * Mash all of the child value-box to a string.
327 */
328 if (fr_value_box_list_concat_in_place(vb, vb, &vb->vb_group, FR_TYPE_STRING, FR_VALUE_BOX_LIST_FREE, true, SIZE_MAX) < 0) {
329 return -1;
330 }
331
332 /*
333 * Do NOT mark this as safe for anything. The inputs could have come from anywhere.
334 *
335 * The arg->safe_for value is set ONLY after the data has been escaped.
336 */
337 return 0;
338 }
339
340 if (fr_value_box_is_safe_for(vb, arg->safe_for) && !arg->always_escape) return 0;
341
342 rcode = arg->func(request, vb, arg->uctx);
343 if (rcode != 0) return rcode;
344
346 return 0;
347}
348
349/** Process an individual xlat argument value box group
350 *
351 * @param[in] ctx to allocate any additional buffers in
352 * @param[in,out] list of value boxes representing one argument
353 * @param[in] request currently being processed
354 * @param[in] name of the function being called
355 * @param[in] arg specification of current argument
356 * @param[in] node expansion for the current argument
357 * @param[in] arg_num number of current argument in the argument specifications
358 * @return
359 * - XLAT_ACTION_DONE on success.
360 * - XLAT_ACTION_FAIL on failure.
361 */
362static xlat_action_t xlat_process_arg_list(TALLOC_CTX *ctx, fr_value_box_list_t *list, request_t *request,
363 char const *name, xlat_arg_parser_t const *arg, xlat_exp_t const *node, unsigned int arg_num)
364{
365 fr_value_box_t *vb;
366 bool concat = false;
367 bool quoted = false;
369
370 /*
371 * The function does it's own escaping and concatenation.
372 */
373 if (arg->will_escape) {
375 return XLAT_ACTION_DONE;
376 }
377
378 /*
379 * See if we have to concatenate multiple value-boxes into one output string / whatever.
380 *
381 * If the input xlat is more complicated expression, it's going to be a function, e.g.
382 *
383 * 1+2 --> %op_add(1,2).
384 *
385 * And then we can't do escaping. Note that this is also the case for
386 *
387 * "foo" + User-Name --> %op_add("foo", User-Name)
388 *
389 * Arguably, we DO want to escape User-Name, but not Foo. Because "+" here is a special case. :(
390 */
391 if ((fr_dlist_num_elements(&node->group->dlist) == 1) && (xlat_exp_head(node->group)->quote != T_BARE_WORD)) {
392 quoted = concat = true;
394
395 } else {
396 concat = arg->concat;
397 type = arg->type;
398 }
399
400 /*
401 * No data - nothing to do.
402 */
403 if (fr_value_box_list_empty(list)) {
404 /*
405 * The expansion resulted in no data, BUT the admin wants a string. So we create an
406 * empty string.
407 *
408 * i.e. If attribute 'foo' doesn't exist, then we have:
409 *
410 * %{foo} --> nothing, because 'foo' doesn't exist
411 * "%{foo}" --> "", because we want a string, therefore the contents of the string are nothing.
412 *
413 * Also note that an empty string satisfies a required argument.
414 */
415 if (quoted) {
416 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_STRING, NULL));
417 fr_value_box_strdup(vb, vb, NULL, "", false);
418 fr_value_box_list_insert_tail(list, vb);
419
420 return XLAT_ACTION_DONE;
421 }
422
423 if (arg->required) {
424 REDEBUG("Function \"%s\" is missing required argument %u", name, arg_num);
425 return XLAT_ACTION_FAIL;
426 }
427
428 return XLAT_ACTION_DONE;
429 }
430
431 /*
432 * The function may be URI or SQL, which have different sub-types. So we call the function if it
433 * is NOT marked as "globally safe for SQL", but the called function may check the more specific
434 * flag "safe for MySQL". And then things which aren't safe for MySQL are escaped, and then
435 * marked as "safe for MySQL".
436 *
437 * If the escape function returns "0", then we set the safe_for value. If the escape function
438 * returns "1", then it has set the safe_for value.
439 */
440 if (arg->func) {
441 for (vb = fr_value_box_list_head(list);
442 vb != NULL;
443 vb = fr_value_box_list_next(list, vb)) {
444 if (xlat_arg_stringify(request, arg, node, vb) < 0) {
445 RPEDEBUG("Function \"%s\" failed escaping argument %u", name, arg_num);
446 return XLAT_ACTION_FAIL;
447 }
448 }
449 }
450
451 vb = fr_value_box_list_head(list);
452 fr_assert(node->type == XLAT_GROUP);
453
454 /*
455 * Concatenate child boxes, then cast to the desired type.
456 */
457 if (concat) {
458 if (fr_value_box_list_concat_in_place(ctx, vb, list, type, FR_VALUE_BOX_LIST_FREE, true, SIZE_MAX) < 0) {
459 RPEDEBUG("Function \"%s\" failed concatenating arguments to type %s", name, fr_type_to_str(type));
460 return XLAT_ACTION_FAIL;
461 }
462 fr_assert(fr_value_box_list_num_elements(list) == 1);
463
464 goto check_types;
465 }
466
467 /*
468 * Only a single child box is valid here. Check there is
469 * just one, cast to the correct type
470 */
471 if (arg->single) {
472 if (fr_value_box_list_num_elements(list) > 1) {
473 RPEDEBUG("Function \"%s\" was provided an incorrect number of values at argument %u, "
474 "expected %s got %u",
475 name, arg_num,
476 arg->required ? "0-1" : "1",
477 fr_value_box_list_num_elements(list));
478 return XLAT_ACTION_FAIL;
479 }
480
481 check_types:
482 if (!fr_type_is_leaf(arg->type)) goto check_non_leaf;
483
484 /*
485 * Cast to the correct type if necessary.
486 */
487 if (vb->type != arg->type) {
488 if (fr_value_box_cast_in_place(ctx, vb, arg->type, NULL) < 0) {
489 cast_error:
490 RPEDEBUG("Function \"%s\" failed to cast argument %u to type %s", name, arg_num, fr_type_to_str(arg->type));
491 return XLAT_ACTION_FAIL;
492 }
493 }
494
495 return XLAT_ACTION_DONE;
496 }
497
498 /*
499 * We're neither concatenating nor do we only expect a single value,
500 * cast all child values to the required type.
501 */
502 if (fr_type_is_leaf(arg->type)) {
503 do {
504 if (vb->type == arg->type) continue;
505 if (fr_value_box_cast_in_place(ctx, vb,
506 arg->type, NULL) < 0) goto cast_error;
507 } while ((vb = fr_value_box_list_next(list, vb)));
508
509 return XLAT_ACTION_DONE;
510 }
511
512check_non_leaf:
513 if (arg->type == FR_TYPE_VOID) return XLAT_ACTION_DONE;
514
515 /*
516 * We already have a pair cursor, the argument was an attribute reference.
517 */
518 if (vb->type == FR_TYPE_PAIR_CURSOR) return XLAT_ACTION_DONE;
519
520 /*
521 * If the argument is a pair
522 */
523 fr_assert(vb->type != FR_TYPE_PAIR_CURSOR);
524
525 {
526 int err;
527 tmpl_t *vpt;
528
529 /*
530 * Cursor names have to be strings, which are completely safe.
531 */
532 if (vb->type != FR_TYPE_STRING) {
533 REDEBUG("Expected attribute reference as string, not %s", fr_type_to_str(vb->type));
534 return XLAT_ACTION_FAIL;
535 }
536
539 REDEBUG("Refusing to reference attribute from unsafe data");
540 return XLAT_ACTION_FAIL;
541 }
542
543 if (tmpl_afrom_attr_str(ctx, NULL, &vpt, vb->vb_strvalue,
544 &(tmpl_rules_t){
545 .attr = {
546 .dict_def = request->proto_dict, /* we can't encode local attributes */
547 .list_def = request_attr_request,
548 .allow_wildcard = arg->allow_wildcard,
549 }
550 }) <= 0) {
551 RPEDEBUG("Failed parsing attribute reference");
552 return XLAT_ACTION_FAIL;
553 }
554
556
557 /*
558 * The cursor can return something, nothing (-1), or no list (-2) or no context (-3). Of
559 * these, only the last two are actually errors.
560 *
561 * "no matching pair" returns _no_ cursor, and not an empty cursor.
562 */
563 (void) tmpl_dcursor_value_box_init(&err, vb, vb, request, vpt);
564 if (err < 0) return XLAT_ACTION_FAIL;
565 }
566
567#undef ESCAPE
568
569 return XLAT_ACTION_DONE;
570}
571
572
573/** Process list of boxed values provided as input to an xlat
574 *
575 * Ensures that the value boxes passed to an xlat function match the
576 * requirements listed in its "args", and escapes any tainted boxes
577 * using the specified escaping routine.
578 *
579 * @param[in] ctx in which to allocate any buffers.
580 * @param[in,out] list value boxes provided as input.
581 * List will be modified in accordance to rules
582 * provided in the args array.
583 * @param[in] request being processed.
584 * @param[in] node which is a function
585 */
586static inline CC_HINT(always_inline)
587xlat_action_t xlat_process_args(TALLOC_CTX *ctx, fr_value_box_list_t *list,
588 request_t *request, xlat_exp_t const *node)
589{
590 xlat_t const *func = node->call.func;
591 xlat_arg_parser_t const *arg_p = func->args;
592 xlat_exp_t *arg, *arg_next;
593 xlat_action_t xa;
594 fr_value_box_t *vb, *vb_next;
595
596 /*
597 * No args registered for this xlat
598 */
599 if (!func->args) return XLAT_ACTION_DONE;
600
601 /*
602 * Manage the arguments.
603 */
604 vb = fr_value_box_list_head(list);
605 arg = xlat_exp_head(node->call.args);
606
607 while (arg_p->type != FR_TYPE_NULL) {
608 /*
609 * Separate check to see if the group
610 * box is there. Check in
611 * xlat_process_arg_list verifies it
612 * has a value.
613 */
614 if (!vb) {
615 if (arg_p->required) {
616 missing:
617 REDEBUG("Function \"%s\" is missing required argument %u",
618 func->name, (unsigned int)((arg_p - func->args) + 1));
619 return XLAT_ACTION_FAIL;
620 }
621
622 /*
623 * The argument isn't required. Just omit it. xlat_func_args_set() enforces
624 * that optional arguments are at the end of the argument list.
625 */
626 return XLAT_ACTION_DONE;
627 }
628
629 /*
630 * Everything in the top level list should be
631 * groups
632 */
633 if (!fr_cond_assert(vb->type == FR_TYPE_GROUP)) return XLAT_ACTION_FAIL;
634
635 /*
636 * pre-advance, in case the vb is replaced
637 * during processing.
638 */
639 vb_next = fr_value_box_list_next(list, vb);
640 arg_next = xlat_exp_next(node->call.args, arg);
641
642 xa = xlat_process_arg_list(ctx, &vb->vb_group, request, func->name, arg_p, arg,
643 (unsigned int)((arg_p - func->args) + 1));
644 if (xa != XLAT_ACTION_DONE) return xa;
645
646 /*
647 * This argument doesn't exist. That might be OK, or it may be a fatal error.
648 */
649 if (fr_value_box_list_empty(&vb->vb_group)) {
650 /*
651 * Variadic rules deal with empty boxes differently...
652 */
653 switch (arg_p->variadic) {
655 fr_value_box_list_talloc_free_head(list);
656 goto do_next;
657
659 goto empty_ok;
660
662 break;
663 }
664
665 /*
666 * Empty groups for optional arguments are OK, we can just stop processing the list.
667 */
668 if (!arg_p->required) {
669 /*
670 * If the caller doesn't care about the type, then we leave the
671 * empty group there.
672 */
673 if (arg_p->type == FR_TYPE_VOID) goto do_next;
674
675 /*
676 * The caller does care about the type, and we don't have any
677 * matching data. Omit this argument, and all arguments after it.
678 *
679 * i.e. if the caller has 3 optional arguments, all
680 * FR_TYPE_UINT8, and the first one is missing, then we MUST
681 * either supply boxes all of FR_TYPE_UINT8, OR we supply nothing.
682 *
683 * We can't supply a box of any other type, because the caller
684 * has declared that it wants FR_TYPE_UINT8, and is naively
685 * accessing the box as vb_uint8, hoping that it's being passed
686 * the right thing.
687 */
688 fr_value_box_list_talloc_free_head(list);
689 break;
690 }
691
692 /*
693 * If the caller is expecting a particular type, then getting nothing is
694 * an error.
695 *
696 * If the caller manually checks the input type, then we can leave it as
697 * an empty group.
698 */
699 if (arg_p->type != FR_TYPE_VOID) goto missing;
700 }
701
702 empty_ok:
703 /*
704 * In some cases we replace the current argument with the head of the group.
705 *
706 * xlat_process_arg_list() has already done concatenations for us.
707 */
708 if (arg_p->single || arg_p->concat) {
709 fr_value_box_t *head = fr_value_box_list_pop_head(&vb->vb_group);
710
711 /*
712 * If we're meant to be smashing the argument
713 * to a single box, but the group was empty,
714 * add a null box instead so ordering is maintained
715 * for subsequent boxes.
716 */
717 if (!head) head = fr_value_box_alloc_null(ctx);
718 fr_value_box_list_replace(list, vb, head);
719 talloc_free(vb);
720 }
721
722 do_next:
723 if (arg_p->variadic) {
724 if (!vb_next) break;
725 } else {
726 arg_p++;
727 arg = arg_next;
728 }
729 vb = vb_next;
730 }
731
732 return XLAT_ACTION_DONE;
733}
734
735/** Validate that the return values from an xlat function match what it registered
736 *
737 * @param[in] request The current request.
738 * @param[in] func that was called.
739 * @param[in] returned the output list of the function.
740 * @param[in] pos current position in the output list.
741 * @return
742 * - true - If return values were correct.
743 * - false - If the return values were incorrect.
744 */
745static inline CC_HINT(nonnull(1,2,3))
746bool xlat_process_return(request_t *request, xlat_t const *func, fr_value_box_list_t const *returned, fr_value_box_t *pos)
747{
748 unsigned int count = 0;
749
750 /*
751 * Nothing to validate. We don't yet enforce that functions
752 * must return at least one instance of their type.
753 */
754 if (!pos || fr_type_is_void(func->return_type)) return true;
755
756 if (fr_type_is_null(func->return_type)) {
757 /* Dynamic expansion to get the right name */
758 REDEBUG("%s return type registered as %s, but %s expansion produced data",
759 func->name, func->name, fr_type_to_str(func->return_type));
760
761 /* We are not forgiving for debug builds */
762 fr_assert_fail("Treating invalid return type as fatal");
763
764 return false;
765 }
766
767 do {
768 if (pos->type != func->return_type) {
769 REDEBUG("%s returned invalid result type at index %u. Expected type %s, got type %s",
770 func->name, count, fr_type_to_str(func->return_type), fr_type_to_str(pos->type));
771
772 /* We are not forgiving for debug builds */
773 fr_assert_fail("Treating invalid return type as fatal");
774 }
775 fr_value_box_mark_safe_for(pos, func->return_safe_for); /* Always set this */
776 count++;
777 } while ((pos = fr_value_box_list_next(returned, pos)));
778
779 return true;
780}
781
782/** One letter expansions
783 *
784 * @param[in] ctx to allocate boxed value, and buffers in.
785 * @param[out] out Where to write the boxed value.
786 * @param[in] request The current request.
787 * @param[in] letter to expand.
788 * @return
789 * - #XLAT_ACTION_FAIL on memory allocation errors.
790 * - #XLAT_ACTION_DONE if we're done processing this node.
791 *
792 */
793static inline CC_HINT(always_inline)
794xlat_action_t xlat_eval_one_letter(TALLOC_CTX *ctx, fr_value_box_list_t *out,
795 request_t *request, char letter)
796{
797
798 char buffer[64];
799 struct tm ts;
800 time_t now;
802
803 now = fr_time_to_sec(request->packet->timestamp);
804
805 switch (letter) {
806 case '%':
808 if (fr_value_box_strdup(value, value, NULL, "%", false) < 0) return XLAT_ACTION_FAIL;
809 break;
810
811 /*
812 * RADIUS request values
813 */
814
815 case 'I': /* Request ID */
817 value->datum.uint32 = request->packet->id;
818 break;
819
820 case 'n': /* Request number */
822 value->datum.uint64 = request->number;
823 break;
824
825 case 's': /* First request in this sequence */
827 value->datum.uint64 = request->seq_start;
828 break;
829
830 /*
831 * Current time
832 */
833
834 case 'c': /* Current epoch time seconds */
835 /*
836 * @todo - leave this as FR_TYPE_DATE, but add an enumv which changes the scale to
837 * seconds?
838 */
840 value->datum.uint64 = (uint64_t)fr_time_to_sec(fr_time());
841 break;
842
843 case 'C': /* Current epoch time microsecond component */
844 /*
845 * @todo - we probably should remove this now that we have FR_TYPE_DATE with scaling.
846 */
848 value->datum.uint64 = (uint64_t)fr_time_to_usec(fr_time()) % 1000000;
849 break;
850
851 /*
852 * Time of the current request
853 */
854
855 case 'd': /* Request day */
856 if (!localtime_r(&now, &ts)) {
857 error:
858 REDEBUG("Failed converting packet timestamp to localtime: %s", fr_syserror(errno));
859 return XLAT_ACTION_FAIL;
860 }
861
863 value->datum.uint8 = ts.tm_mday;
864 break;
865
866 case 'D': /* Request date */
867 if (!localtime_r(&now, &ts)) goto error;
868
869 strftime(buffer, sizeof(buffer), "%Y%m%d", &ts);
870
872 if (fr_value_box_strdup(value, value, NULL, buffer, false) < 0) goto error;
873 break;
874
875 case 'e': /* Request second */
876 if (!localtime_r(&now, &ts)) goto error;
877
879 value->datum.uint8 = ts.tm_sec;
880 break;
881
882 case 'G': /* Request minute */
883 if (!localtime_r(&now, &ts)) goto error;
884
886 value->datum.uint8 = ts.tm_min;
887 break;
888
889 case 'H': /* Request hour */
890 if (!localtime_r(&now, &ts)) goto error;
891
893 value->datum.uint8 = ts.tm_hour;
894 break;
895
896 case 'l': /* Request timestamp as seconds since the epoch */
897 /*
898 * @todo - leave this as FR_TYPE_DATE, but add an enumv which changes the scale to
899 * seconds?
900 */
902 value->datum.uint64 = (uint64_t ) now;
903 break;
904
905 case 'm': /* Request month */
906 if (!localtime_r(&now, &ts)) goto error;
907
909 value->datum.uint8 = ts.tm_mon + 1;
910 break;
911
912 case 'M': /* Request time microsecond component */
913 /*
914 * @todo - we probably should remove this now that we have FR_TYPE_DATE with scaling.
915 */
917 value->datum.uint64 = (uint64_t)fr_time_to_usec(request->packet->timestamp) % 1000000;
918 break;
919
920 case 'S': /* Request timestamp in SQL format */
921 if (!localtime_r(&now, &ts)) goto error;
922
923 strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &ts);
924
926 if (fr_value_box_strdup(value, value, NULL, buffer, false) < 0) goto error;
927 break;
928
929 case 't': /* Request timestamp in CTIME format */
930 {
931 char *p;
932
933 CTIME_R(&now, buffer, sizeof(buffer));
934 p = strchr(buffer, '\n');
935 if (p) *p = '\0';
936
938 if (fr_value_box_strdup(value, value, NULL, buffer, false) < 0) goto error;
939 }
940 break;
941
942 case 'T': /* Request timestamp in ISO format */
943 {
944 int len = 0;
945
946 if (!gmtime_r(&now, &ts)) goto error;
947
948 if (!(len = strftime(buffer, sizeof(buffer) - 1, "%Y-%m-%dT%H:%M:%S", &ts))) {
949 REDEBUG("Failed converting packet timestamp to gmtime: Buffer full");
950 return XLAT_ACTION_FAIL;
951 }
952 strcat(buffer, ".");
953 len++;
954 snprintf(buffer + len, sizeof(buffer) - len, "%03i",
955 (int) fr_time_to_msec(request->packet->timestamp) % 1000);
956
958 if (fr_value_box_strdup(value, value, NULL, buffer, false) < 0) goto error;
959 }
960 break;
961
962 case 'Y': /* Request year */
963 if (!localtime_r(&now, &ts)) goto error;
964
966
967 value->datum.int16 = ts.tm_year + 1900;
968 break;
969
970 default:
971 fr_assert_fail("%%%c is not a valid one letter expansion", letter);
972 return XLAT_ACTION_FAIL;
973 }
974
975 fr_value_box_list_insert_tail(out, value);
976
977 return XLAT_ACTION_DONE;
978}
979
980typedef struct {
982 fr_value_box_list_t list;
984
986 xlat_ctx_t const *xctx,
987 UNUSED request_t *request, UNUSED fr_value_box_list_t *in)
988{
989 xlat_exec_rctx_t *rctx = talloc_get_type_abort(xctx->rctx, xlat_exec_rctx_t);
990
991 if (rctx->status != 0) {
992 fr_strerror_printf("Program failed with status %d", rctx->status);
993 return XLAT_ACTION_FAIL;
994 }
995
996 fr_value_box_list_move((fr_value_box_list_t *)out->dlist, &rctx->list);
997
998 return XLAT_ACTION_DONE;
999}
1000
1001
1002/** Signal an xlat function
1003 *
1004 * @param[in] signal function to call.
1005 * @param[in] exp Xlat node that previously yielded.
1006 * @param[in] request The current request.
1007 * @param[in] rctx Opaque (to us), resume ctx provided by the xlat function
1008 * when it yielded.
1009 * @param[in] action What the request should do (the type of signal).
1010 */
1012 request_t *request, void *rctx, fr_signal_t action)
1013{
1015
1016 signal(XLAT_CTX(exp->call.inst, t->data, exp, t->mctx, NULL, rctx), request, action);
1017}
1018
1020 UNUSED xlat_ctx_t const *xctx,
1021 UNUSED request_t *request, UNUSED fr_value_box_list_t *in)
1022{
1023 return XLAT_ACTION_DONE;
1024}
1025
1026/** Call an xlat's resumption method
1027 *
1028 * @param[in] ctx to allocate value boxes in.
1029 * @param[out] out a list of #fr_value_box_t to append to.
1030 * @param[out] child to evaluate. If a child needs to be evaluated
1031 * by the caller, we return XLAT_ACTION_PUSH_CHILD
1032 * and place the child to be evaluated here.
1033 * Once evaluation is complete, the caller
1034 * should call us with the same #xlat_exp_t and the
1035 * result of the nested evaluation in result.
1036 * @param[in] request the current request.
1037 * @param[in] head of the list to evaluate
1038 * @param[in,out] in xlat node to evaluate. Advanced as we process
1039 * additional #xlat_exp_t.
1040 * @param[in] result Previously expanded arguments to this xlat function.
1041 * @param[in] resume function to call.
1042 * @param[in] rctx Opaque (to us), resume ctx provided by xlat function
1043 * when it yielded.
1044 */
1046 xlat_exp_head_t const **child,
1047 request_t *request, xlat_exp_head_t const *head, xlat_exp_t const **in,
1048 fr_value_box_list_t *result, xlat_func_t resume, void *rctx)
1049{
1050 xlat_action_t xa;
1051 xlat_exp_t const *node = *in;
1052
1053 /*
1054 * It's important that callbacks leave the result list
1055 * in a valid state, as it leads to all kinds of hard
1056 * to debug problems if they free or change elements
1057 * and don't remove them from the list.
1058 */
1059 VALUE_BOX_LIST_VERIFY(result);
1060
1061 if (node->type != XLAT_FUNC) {
1062 xa = resume(ctx, out, XLAT_CTX(NULL, NULL, NULL, NULL, NULL, rctx), request, result);
1063 } else {
1065 t = xlat_thread_instance_find(node);
1066 xa = resume(ctx, out, XLAT_CTX(node->call.inst->data, t->data, node, t->mctx, NULL, rctx), request, result);
1067 VALUE_BOX_LIST_VERIFY(result);
1068
1069 RDEBUG2("| %%%s(...)", node->call.func->name);
1070 }
1071
1072 switch (xa) {
1073 case XLAT_ACTION_YIELD:
1074 RDEBUG2("| (YIELD)");
1075 return xa;
1076
1077 case XLAT_ACTION_DONE:
1078 if (unlang_xlat_yield(request, xlat_null_resume, NULL, 0, NULL) != XLAT_ACTION_YIELD) return XLAT_ACTION_FAIL;
1079
1080 fr_dcursor_next(out); /* Wind to the start of this functions output */
1081 if (node->call.func) {
1082 RDEBUG2("| --> %pV", fr_dcursor_current(out));
1083 if (!xlat_process_return(request, node->call.func, (fr_value_box_list_t *)out->dlist,
1085 }
1086
1087 /*
1088 * It's easier if we get xlat_frame_eval to continue evaluating the frame.
1089 */
1090 *in = xlat_exp_next(head, *in); /* advance */
1091 return xlat_frame_eval(ctx, out, child, request, head, in);
1092
1095 case XLAT_ACTION_FAIL:
1096 break;
1097 }
1098
1099 return xa;
1100}
1101
1102/** Process the result of a previous nested expansion
1103 *
1104 * @param[in] ctx to allocate value boxes in.
1105 * @param[out] out a list of #fr_value_box_t to append to.
1106 * @param[out] child to evaluate. If a child needs to be evaluated
1107 * by the caller, we return XLAT_ACTION_PUSH_CHILD
1108 * and place the child to be evaluated here.
1109 * Once evaluation is complete, the caller
1110 * should call us with the same #xlat_exp_t and the
1111 * result of the nested evaluation in result.
1112 * @param[in] request the current request.
1113 * @param[in] head of the list to evaluate
1114 * @param[in,out] in xlat node to evaluate. Advanced as we process
1115 * additional #xlat_exp_t.
1116 * @param[in] env_data Expanded call env.
1117 * @param[in] result of a previous nested evaluation.
1118 */
1120 xlat_exp_head_t const **child,
1121 request_t *request, xlat_exp_head_t const *head, xlat_exp_t const **in,
1122 void *env_data, fr_value_box_list_t *result)
1123{
1124 xlat_exp_t const *node = *in;
1125
1126 fr_dcursor_tail(out); /* Needed for reentrant behaviour and debugging */
1127
1128 switch (node->type) {
1129 case XLAT_FUNC:
1130 {
1131 xlat_action_t xa;
1133 fr_value_box_list_t result_copy;
1134
1135 t = xlat_thread_instance_find(node);
1136 fr_assert(t);
1137
1138 XLAT_DEBUG("** [%i] %s(func-async) - %%%s(%pM)",
1139 unlang_interpret_stack_depth(request), __FUNCTION__,
1140 node->fmt, result);
1141
1142 VALUE_BOX_LIST_VERIFY(result);
1143
1144 /*
1145 * Always need to init and free the
1146 * copy list as debug level could change
1147 * when the xlat function executes.
1148 */
1149 fr_value_box_list_init(&result_copy);
1150
1151 /*
1152 * Need to copy the input list in case
1153 * the async function mucks with it.
1154 */
1156 xa = xlat_process_args(ctx, result, request, node);
1157 if (xa == XLAT_ACTION_FAIL) {
1158 fr_value_box_list_talloc_free(&result_copy);
1159 return xa;
1160 }
1161
1162 VALUE_BOX_LIST_VERIFY(result);
1163 xa = node->call.func->func(ctx, out,
1164 XLAT_CTX(node->call.inst->data, t->data, node, t->mctx, env_data, NULL),
1165 request, result);
1166 VALUE_BOX_LIST_VERIFY(result);
1167
1168 if (RDEBUG_ENABLED2) {
1169 REXDENT();
1170 xlat_debug_log_expansion(request, *in, &result_copy, __LINE__);
1171 RINDENT();
1172 }
1173 fr_value_box_list_talloc_free(&result_copy);
1174
1175 switch (xa) {
1176 case XLAT_ACTION_FAIL:
1177 return xa;
1178
1180 RDEBUG3("| -- CHILD");
1181 return xa;
1182
1184 RDEBUG3("| -- UNLANG");
1185 return xa;
1186
1187 case XLAT_ACTION_YIELD:
1188 RDEBUG3("| -- YIELD");
1189 return xa;
1190
1191 case XLAT_ACTION_DONE: /* Process the result */
1193
1194 REXDENT();
1196 if (!xlat_process_return(request, node->call.func,
1197 (fr_value_box_list_t *)out->dlist,
1199 RINDENT();
1200 return XLAT_ACTION_FAIL;
1201 }
1202 RINDENT();
1203 break;
1204 }
1205 }
1206 break;
1207
1208 case XLAT_GROUP:
1209 {
1210 fr_value_box_t *arg;
1211
1212 /*
1213 * We'd like to do indent / exdent for groups, but that also involves fixing all of the
1214 * error paths. Which we won't do right now.
1215 */
1216 XLAT_DEBUG("** [%i] %s(child) - continuing %%{%s ...}", unlang_interpret_stack_depth(request), __FUNCTION__,
1217 node->fmt);
1218
1219 /*
1220 * Hoist %{...} to its results.
1221 *
1222 * There may be zero or more results.
1223 */
1224 if (node->hoist) {
1225 /*
1226 * Mash quoted strings, UNLESS they're in a function argument. In which case the argument parser
1227 * will do escaping.
1228 *
1229 * @todo - when pushing the xlat for expansion, also push the escaping rules. In which case we can do escaping here.
1230 */
1231 if ((node->quote != T_BARE_WORD) && !head->is_argv) {
1232 if (!fr_value_box_list_head(result)) {
1233 MEM(arg = fr_value_box_alloc(ctx, FR_TYPE_STRING, NULL));
1234 fr_value_box_strdup(arg, arg, NULL, "", false);
1235 fr_dcursor_insert(out, arg);
1236 break;
1237 }
1238
1239 /*
1240 * Mash all of the child value-box to a string.
1241 */
1242 arg = fr_value_box_list_head(result);
1243 fr_assert(arg != NULL);
1244
1245 if (fr_value_box_list_concat_in_place(arg, arg, result, FR_TYPE_STRING, FR_VALUE_BOX_LIST_FREE, true, SIZE_MAX) < 0) {
1246 return -1;
1247 }
1248 }
1249
1250 while ((arg = fr_value_box_list_pop_head(result)) != NULL) {
1251 talloc_steal(ctx, arg);
1252 fr_dcursor_insert(out, arg);
1253 }
1254 break;
1255 }
1256
1257 MEM(arg = fr_value_box_alloc(ctx, FR_TYPE_GROUP, NULL));
1258
1259 if (!fr_value_box_list_empty(result)) {
1260 VALUE_BOX_LIST_VERIFY(result);
1261 fr_value_box_list_move(&arg->vb_group, result);
1262 }
1263
1264 VALUE_BOX_VERIFY(arg);
1265
1266 fr_dcursor_insert(out, arg);
1267 }
1268 break;
1269
1270 case XLAT_TMPL:
1271 fr_assert(tmpl_is_exec(node->vpt));
1272
1273 if (tmpl_eval_cast_in_place(result, request, node->vpt) < 0) {
1274 fr_value_box_list_talloc_free(result);
1275 return XLAT_ACTION_FAIL;
1276 }
1277
1278 /*
1279 * First entry is the command to run. Subsequent entries are the options to pass to the
1280 * command.
1281 */
1282 fr_value_box_list_move((fr_value_box_list_t *)out->dlist, result);
1283 break;
1284
1285 default:
1286 fr_assert(0);
1287 return XLAT_ACTION_FAIL;
1288 }
1289
1290 /*
1291 * It's easier if we get xlat_frame_eval to continue evaluating the frame.
1292 */
1293 *in = xlat_exp_next(head, *in); /* advance */
1294 return xlat_frame_eval(ctx, out, child, request, head, in);
1295}
1296
1297/** Converts xlat nodes to value boxes
1298 *
1299 * Evaluates a single level of expansions.
1300 *
1301 * @param[in] ctx to allocate value boxes in.
1302 * @param[out] out a list of #fr_value_box_t to append to.
1303 * @param[out] child to evaluate. If a child needs to be evaluated
1304 * by the caller, we return XLAT_ACTION_PUSH_CHILD
1305 * and place the child to be evaluated here.
1306 * Once evaluation is complete, the caller
1307 * should call us with the same #xlat_exp_t and the
1308 * result of the nested evaluation in result.
1309 * @param[in] request the current request.
1310 * @param[in] head of the list to evaluate
1311 * @param[in,out] in xlat node to evaluate. Advanced as we process
1312 * additional #xlat_exp_t.
1313 * @return
1314 * - XLAT_ACTION_PUSH_CHILD if we need to evaluate a deeper level of nested.
1315 * child will be filled with the node that needs to be evaluated.
1316 * call #xlat_frame_eval_repeat on this node, once there are results
1317 * from the nested expansion.
1318 * - XLAT_ACTION_YIELD a resumption frame was pushed onto the stack by an
1319 * xlat function and we need to wait for the request to be resumed
1320 * before continuing.
1321 * - XLAT_ACTION_DONE we're done, pop the frame.
1322 * - XLAT_ACTION_FAIL an xlat module failed.
1323 */
1325 request_t *request, xlat_exp_head_t const *head, xlat_exp_t const **in)
1326{
1328 xlat_exp_t const *node;
1329 fr_value_box_list_t result; /* tmp list so debug works correctly */
1331
1332 fr_value_box_list_init(&result);
1333
1334 *child = NULL;
1335
1336 if (!*in) return XLAT_ACTION_DONE;
1337
1338 /*
1339 * An attribute reference which is a cursor just gets a
1340 * value-box of cursor returned. That is filled in
1341 * later.
1342 */
1343 if (unlikely(head && head->cursor)) {
1344 int err;
1345
1346 fr_assert((*in)->type == XLAT_TMPL);
1347
1349
1350 (void) tmpl_dcursor_value_box_init(&err, value, value, request, (*in)->vpt);
1351 if (err < -1) return XLAT_ACTION_FAIL;
1352
1354 goto finish;
1355 }
1356
1357 XLAT_DEBUG("** [%i] %s >> entered", unlang_interpret_stack_depth(request), __FUNCTION__);
1358
1359 for (node = *in; node; node = xlat_exp_next(head, node)) {
1360 *in = node; /* Update node in our caller */
1361 fr_dcursor_tail(out); /* Needed for debugging */
1362 VALUE_BOX_LIST_VERIFY((fr_value_box_list_t *)out->dlist);
1363
1364 fr_assert(fr_value_box_list_num_elements(&result) == 0); /* Should all have been moved */
1365
1366 switch (node->type) {
1367 case XLAT_BOX:
1368 XLAT_DEBUG("** [%i] %s(value_box) - %s", unlang_interpret_stack_depth(request), __FUNCTION__, node->fmt);
1369
1370 /*
1371 * Empty boxes are only allowed if
1372 * they're the only node in the expansion.
1373 *
1374 * If they're found anywhere else the xlat
1375 * parser has an error.
1376 */
1377 fr_assert(((node == *in) && !xlat_exp_next(head, node)) || (talloc_array_length(node->fmt) > 1));
1378
1379 /*
1380 * We unfortunately need to dup the buffer
1381 * because references aren't threadsafe.
1382 */
1384 if (fr_value_box_copy(value, value, &node->data) < 0) goto fail;
1386 continue;
1387
1388 case XLAT_ONE_LETTER:
1389 XLAT_DEBUG("** [%i] %s(one-letter) - %%%s", unlang_interpret_stack_depth(request), __FUNCTION__,
1390 node->fmt);
1391
1392 xlat_debug_log_expansion(request, node, NULL, __LINE__);
1393 if (xlat_eval_one_letter(ctx, &result, request, node->fmt[0]) == XLAT_ACTION_FAIL) {
1394 fail:
1395 fr_value_box_list_talloc_free(&result);
1396 xa = XLAT_ACTION_FAIL;
1397 goto finish;
1398 }
1399 xlat_debug_log_list_result(request, *in, &result);
1400 fr_value_box_list_move((fr_value_box_list_t *)out->dlist, &result);
1401 continue;
1402
1403 case XLAT_TMPL:
1404 /*
1405 * Everything should have been resolved.
1406 */
1407 fr_assert(!tmpl_needs_resolving(node->vpt));
1408
1409 if (tmpl_is_data(node->vpt)) {
1410 XLAT_DEBUG("** [%i] %s(value) - %s", unlang_interpret_stack_depth(request), __FUNCTION__,
1411 node->vpt->name);
1412
1413 MEM(value = fr_value_box_alloc(ctx, tmpl_value_type(node->vpt), NULL));
1414
1415 fr_value_box_copy(value, value, tmpl_value(node->vpt)); /* Also dups taint */
1416 fr_value_box_list_insert_tail(&result, value);
1417
1418 /*
1419 * Cast the results if necessary.
1420 */
1421 if (tmpl_eval_cast_in_place(&result, request, node->vpt) < 0) goto fail;
1422
1423 fr_value_box_list_move((fr_value_box_list_t *)out->dlist, &result);
1424 continue;
1425
1426 } else if (tmpl_is_attr(node->vpt)) {
1427 if (node->fmt[0] == '&') {
1428 XLAT_DEBUG("** [%i] %s(attribute) - %s", unlang_interpret_stack_depth(request), __FUNCTION__,
1429 node->fmt);
1430 } else {
1431 XLAT_DEBUG("** [%i] %s(attribute) - %%{%s}", unlang_interpret_stack_depth(request), __FUNCTION__,
1432 node->fmt);
1433 }
1434 xlat_debug_log_expansion(request, node, NULL, __LINE__);
1435
1436 if (tmpl_eval_pair(ctx, &result, request, node->vpt) < 0) goto fail;
1437
1438 } else if (tmpl_is_exec(node->vpt) || tmpl_is_xlat(node->vpt)) {
1439 xlat_exec_rctx_t *rctx;
1440
1441 /*
1442 * Allocate and initialize the output context, with value-boxes, exec status, etc.
1443 */
1444 MEM(rctx = talloc_zero(unlang_interpret_frame_talloc_ctx(request), xlat_exec_rctx_t));
1445 fr_value_box_list_init(&rctx->list);
1446
1447 xlat_debug_log_expansion(request, node, NULL, __LINE__);
1448
1449 if (unlang_xlat_yield(request, xlat_exec_resume, NULL, 0, rctx) != XLAT_ACTION_YIELD) goto fail;
1450
1451 if (unlang_tmpl_push(ctx, &rctx->list, request, node->vpt,
1453 false, &rctx->status)) < 0) goto fail;
1454
1456 goto finish;
1457
1458 } else {
1459#ifdef NDEBUG
1460 xa = XLAT_ACTION_FAIL;
1461 goto finish;
1462#endif
1463
1464 /*
1465 * Either this should have been handled previously, or we need to write
1466 * code to deal with this case.
1467 */
1468 fr_assert(0);
1469 }
1470
1471 xlat_debug_log_list_result(request, node, &result);
1472 fr_value_box_list_move((fr_value_box_list_t *)out->dlist, &result);
1473 continue;
1474
1475 case XLAT_FUNC:
1476 XLAT_DEBUG("** [%i] %s(func) - %%%s(...)", unlang_interpret_stack_depth(request), __FUNCTION__,
1477 node->fmt);
1478
1479 /*
1480 * Hand back the child node to the caller
1481 * for evaluation.
1482 */
1483 if (xlat_exp_head(node->call.args)) {
1484 *child = node->call.args;
1486 goto finish;
1487 }
1488
1489 /*
1490 * If there's no children we can just
1491 * call the function directly.
1492 */
1493 xa = xlat_frame_eval_repeat(ctx, out, child, request, head, in, NULL, &result);
1494 if (xa != XLAT_ACTION_DONE || (!*in)) goto finish;
1495 continue;
1496
1497#ifdef HAVE_REGEX
1498 case XLAT_REGEX:
1499 XLAT_DEBUG("** [%i] %s(regex) - %%{%s}", unlang_interpret_stack_depth(request), __FUNCTION__,
1500 node->fmt);
1501
1502 xlat_debug_log_expansion(request, node, NULL, __LINE__);
1504 if (regex_request_to_sub(value, value, request, node->regex_index) < 0) {
1506 continue;
1507 }
1508
1509 xlat_debug_log_result(request, node, value);
1511 continue;
1512#endif
1513
1514 case XLAT_GROUP:
1515 XLAT_DEBUG("** [%i] %s(child) - %%{%s ...}", unlang_interpret_stack_depth(request), __FUNCTION__,
1516 node->fmt);
1517 if (!node->group) return XLAT_ACTION_DONE;
1518
1519 /*
1520 * Hand back the child node to the caller
1521 * for evaluation.
1522 */
1523 *child = node->group;
1525 goto finish;
1526
1527 /*
1528 * Should have been fixed up during pass2
1529 */
1530 case XLAT_INVALID:
1532 fr_assert(0);
1533 return XLAT_ACTION_FAIL;
1534 }
1535 }
1536
1537finish:
1538 VALUE_BOX_LIST_VERIFY((fr_value_box_list_t *)out->dlist);
1539 XLAT_DEBUG("** [%i] %s << %s", unlang_interpret_stack_depth(request),
1540 __FUNCTION__, fr_table_str_by_value(xlat_action_table, xa, "<INVALID>"));
1541
1542 return xa;
1543}
1544
1545static int xlat_sync_stringify(TALLOC_CTX *ctx, request_t *request, xlat_exp_head_t const *head, fr_value_box_list_t *list,
1546 xlat_escape_legacy_t escape, void const *escape_ctx)
1547{
1548 fr_value_box_t *vb, *box;
1549 xlat_exp_t *node;
1550 fr_value_box_safe_for_t safe_for_expected = escape ? (fr_value_box_safe_for_t) escape : FR_VALUE_BOX_SAFE_FOR_ANY;
1552
1553 vb = fr_value_box_list_head(list);
1554 if (!vb) return 0;
1555
1556 node = xlat_exp_head(head);
1557 fr_assert(node != NULL);
1558
1559 do {
1560 size_t len, real_len;
1561 char *escaped;
1562
1563 /*
1564 * Groups commonly are because of quoted strings.
1565 *
1566 * However, we sometimes have a group because of %{...}, in which case the result is just
1567 * a leaf value.
1568 */
1569 if ((node->type == XLAT_GROUP) && (vb->type == FR_TYPE_GROUP)) {
1570 fr_assert(node->quote != T_BARE_WORD);
1571
1572 if (xlat_sync_stringify(vb, request, node->group, &vb->vb_group, escape, escape_ctx) < 0) return -1;
1573
1574 /*
1575 * Replace the group wuth a fixed string.
1576 */
1577 MEM(box = fr_value_box_alloc_null(ctx));
1578
1579 if (fr_value_box_cast(box, box, FR_TYPE_STRING, NULL, vb) < 0) return -1;
1580
1581 /*
1582 * Remove the group, and replace it with the string.
1583 */
1584 fr_value_box_list_insert_before(list, vb, box);
1585 fr_value_box_list_remove(list, vb);
1586 talloc_free(vb);
1587 vb = box;
1588
1589 /*
1590 * It's now safe, so we don't need to do anything else.
1591 */
1592 fr_value_box_mark_safe_for(vb, safe_for_mark);
1593 goto next;
1594 }
1595
1596 if (!escape) goto next;
1597
1598 if (fr_value_box_is_safe_for(vb, safe_for_expected)) goto next;
1599
1600 /*
1601 * We cast EVERYTHING to a string and also escape everything.
1602 */
1603 if (fr_value_box_cast_in_place(vb, vb, FR_TYPE_STRING, NULL) < 0) {
1604 return -1;
1605 }
1606
1607 len = vb->vb_length * 3;
1608 MEM(escaped = talloc_array(vb, char, len));
1609 real_len = escape(request, escaped, len, vb->vb_strvalue, UNCONST(void *, escape_ctx));
1610
1611 fr_value_box_strdup_shallow_replace(vb, escaped, real_len);
1612 fr_value_box_mark_safe_for(vb, safe_for_mark);
1613
1614 next:
1615 vb = fr_value_box_list_next(list, vb);
1616 node = xlat_exp_next(head, node);
1617
1618 } while (node && vb);
1619
1620 return 0;
1621}
1622
1623static ssize_t xlat_eval_sync(TALLOC_CTX *ctx, char **out, request_t *request, xlat_exp_head_t const * const head,
1624 xlat_escape_legacy_t escape, void const *escape_ctx)
1625{
1626 fr_value_box_list_t result;
1627 unlang_result_t unlang_result = { .rcode = RLM_MODULE_NOT_SET, .priority = MOD_ACTION_NOT_SET };
1628 TALLOC_CTX *pool = talloc_new(NULL);
1629 rlm_rcode_t rcode;
1630 char *str;
1631
1632 XLAT_DEBUG("xlat_eval_sync");
1633
1634 *out = NULL;
1635
1636 fr_value_box_list_init(&result);
1637
1638 /*
1639 * Use the unlang stack to evaluate the xlat.
1640 */
1641 if (unlang_xlat_push(pool, &unlang_result, &result, request, head, UNLANG_TOP_FRAME) < 0) {
1642 fail:
1643 talloc_free(pool);
1644 return -1;
1645 }
1646
1647 /*
1648 * Pure functions don't yield, and can therefore be
1649 * expanded in place. This check saves an expensive
1650 * bounce through a new synchronous interpreter.
1651 */
1652 if (!xlat_impure_func(head) && unlang_interpret_get(request)) {
1653 rcode = unlang_interpret(request, UNLANG_REQUEST_RUNNING);
1654 } else {
1656 }
1657
1658 switch (rcode) {
1659 default:
1660 if (!XLAT_RESULT_SUCCESS(&unlang_result)) goto fail;
1661 break;
1662
1663 case RLM_MODULE_REJECT:
1664 case RLM_MODULE_FAIL:
1665 goto fail;
1666 }
1667
1668 if (!fr_value_box_list_empty(&result)) {
1669 /*
1670 * Walk over the data recursively, escaping it, and converting quoted groups to strings.
1671 */
1672 if (xlat_sync_stringify(pool, request, head, &result, escape, escape_ctx) < 0) {
1673 goto fail;
1674 }
1675
1676 str = fr_value_box_list_aprint(ctx, &result, NULL, NULL);
1677 if (!str) goto fail;
1678 } else {
1679 str = talloc_typed_strdup(ctx, "");
1680 }
1681 talloc_free(pool); /* Memory should be in new ctx */
1682
1683 *out = str;
1684
1685 return talloc_array_length(str) - 1;
1686}
1687
1688/** Replace %whatever in a string.
1689 *
1690 * See 'doc/unlang/xlat.adoc' for more information.
1691 *
1692 * @param[in] ctx to allocate expansion buffers in.
1693 * @param[out] out Where to write pointer to output buffer.
1694 * @param[in] outlen Size of out.
1695 * @param[in] request current request.
1696 * @param[in] head the xlat structure to expand
1697 * @param[in] escape function to escape final value e.g. SQL quoting.
1698 * @param[in] escape_ctx pointer to pass to escape function.
1699 * @return length of string written @bug should really have -1 for failure.
1700 */
1701static ssize_t _xlat_eval_compiled(TALLOC_CTX *ctx, char **out, size_t outlen, request_t *request,
1702 xlat_exp_head_t const *head, xlat_escape_legacy_t escape, void const *escape_ctx)
1703{
1704 char *buff;
1705 ssize_t slen;
1706
1707 fr_assert(head != NULL);
1708
1709 slen = xlat_eval_sync(ctx, &buff, request, head, escape, escape_ctx);
1710 if (slen < 0) {
1711 fr_assert(buff == NULL);
1712 if (*out) **out = '\0';
1713 return slen;
1714 }
1715
1716 /*
1717 * If out doesn't point to an existing buffer
1718 * copy the pointer to our buffer over.
1719 */
1720 if (!*out) {
1721 *out = buff;
1722 return slen;
1723 }
1724
1725 if ((size_t)slen >= outlen) {
1726 fr_strerror_const("Insufficient output buffer space");
1727 return -1;
1728 }
1729
1730 /*
1731 * Otherwise copy the talloced buffer to the fixed one.
1732 */
1733 memcpy(*out, buff, slen);
1734 (*out)[slen] = '\0';
1736
1737 return slen;
1738}
1739
1740/** Replace %whatever in a string.
1741 *
1742 * See 'doc/unlang/xlat.adoc' for more information.
1743 *
1744 * @param[in] ctx to allocate expansion buffers in.
1745 * @param[out] out Where to write pointer to output buffer.
1746 * @param[in] outlen Size of out.
1747 * @param[in] request current request.
1748 * @param[in] fmt string to expand.
1749 * @param[in] escape function to escape final value e.g. SQL quoting.
1750 * @param[in] escape_ctx pointer to pass to escape function.
1751 * @return length of string written @bug should really have -1 for failure.
1752 */
1753static CC_HINT(nonnull (2, 4, 5))
1754ssize_t _xlat_eval(TALLOC_CTX *ctx, char **out, size_t outlen, request_t *request, char const *fmt,
1755 xlat_escape_legacy_t escape, void const *escape_ctx)
1756{
1757 ssize_t len;
1759
1760 RINDENT();
1761
1762 /*
1763 * Give better errors than the old code.
1764 */
1765 len = xlat_tokenize(ctx, &head,
1766 &FR_SBUFF_IN(fmt, strlen(fmt)),
1767 NULL,
1768 &(tmpl_rules_t){
1769 .attr = {
1770 .dict_def = request->local_dict,
1771 .list_def = request_attr_request,
1772 },
1773 .xlat = {
1774 .runtime_el = unlang_interpret_event_list(request),
1775 },
1776 .at_runtime = true,
1777 });
1778 if (len == 0) {
1779 if (*out) {
1780 **out = '\0';
1781 } else {
1782 *out = talloc_zero_array(ctx, char, 1);
1783 }
1784 REXDENT();
1785 return 0;
1786 }
1787
1788 if (len < 0) {
1789 REMARKER(fmt, -(len), "%s", fr_strerror());
1790 if (*out) **out = '\0';
1791 REXDENT();
1792 return -1;
1793 }
1794
1795 len = _xlat_eval_compiled(ctx, out, outlen, request, head, escape, escape_ctx);
1797
1798 REXDENT();
1799
1800 return len;
1801}
1802
1803ssize_t xlat_eval(char *out, size_t outlen, request_t *request,
1804 char const *fmt, xlat_escape_legacy_t escape, void const *escape_ctx)
1805{
1807
1808 return _xlat_eval(request, &out, outlen, request, fmt, escape, escape_ctx);
1809}
1810
1811ssize_t xlat_eval_compiled(char *out, size_t outlen, request_t *request,
1812 xlat_exp_head_t const *xlat, xlat_escape_legacy_t escape, void const *escape_ctx)
1813{
1815
1816 return _xlat_eval_compiled(request, &out, outlen, request, xlat, escape, escape_ctx);
1817}
1818
1819ssize_t xlat_aeval(TALLOC_CTX *ctx, char **out, request_t *request, char const *fmt,
1820 xlat_escape_legacy_t escape, void const *escape_ctx)
1821{
1823
1824 *out = NULL;
1825 return _xlat_eval(ctx, out, 0, request, fmt, escape, escape_ctx);
1826}
1827
1828ssize_t xlat_aeval_compiled(TALLOC_CTX *ctx, char **out, request_t *request,
1829 xlat_exp_head_t const *xlat, xlat_escape_legacy_t escape, void const *escape_ctx)
1830{
1832
1833 *out = NULL;
1834 return _xlat_eval_compiled(ctx, out, 0, request, xlat, escape, escape_ctx);
1835}
1836
1837
1838/** Turn am xlat list into an argv[] array, and nuke the input list.
1839 *
1840 * This is mostly for async use.
1841 */
1843{
1844 int i;
1845 xlat_exp_head_t **my_argv;
1846 size_t count;
1847
1848 if (head->flags.needs_resolving) {
1849 fr_strerror_printf("Cannot flatten expression with unresolved functions");
1850 return -1;
1851 }
1852
1853 count = 0;
1854 xlat_exp_foreach(head, node) {
1855 count++;
1856 }
1857
1858 MEM(my_argv = talloc_zero_array(ctx, xlat_exp_head_t *, count + 1));
1859 *argv = my_argv;
1860
1862
1863 i = 0;
1864 xlat_exp_foreach(head, node) {
1865 fr_assert(node->type == XLAT_GROUP);
1866 my_argv[i++] = talloc_steal(my_argv, node->group);
1867 }
1868
1869 fr_value_box_list_talloc_free((fr_value_box_list_t *)&head->dlist);
1870
1871 return count;
1872}
1873
1874/** Walk over all xlat nodes (depth first) in a xlat expansion, calling a callback
1875 *
1876 * @param[in] head to evaluate.
1877 * @param[in] walker callback to pass nodes to.
1878 * @param[in] type if > 0 a mask of types to call walker for.
1879 * @param[in] uctx to pass to walker.
1880 * @return
1881 * - 0 on success (walker always returned 0).
1882 * - <0 if walker returned <0.
1883 */
1885{
1886 int ret;
1887
1888 /*
1889 * Iterate over nodes at the same depth
1890 */
1891 xlat_exp_foreach(head, node) {
1892 switch (node->type){
1893 case XLAT_FUNC:
1894 /*
1895 * Evaluate the function's arguments
1896 * first, as they may get moved around
1897 * when the function is instantiated.
1898 */
1899 if (xlat_exp_head(node->call.args)) {
1900 ret = xlat_eval_walk(node->call.args, walker, type, uctx);
1901 if (ret < 0) return ret;
1902 }
1903
1904 if (!type || (type & XLAT_FUNC)) {
1905 ret = walker(node, uctx);
1906 if (ret < 0) return ret;
1907 }
1908 break;
1909
1911 if (xlat_exp_head(node->call.args)) {
1912 ret = xlat_eval_walk(node->call.args, walker, type, uctx);
1913 if (ret < 0) return ret;
1914 }
1915
1916 if (!type || (type & XLAT_FUNC_UNRESOLVED)) {
1917 ret = walker(node, uctx);
1918 if (ret < 0) return ret;
1919 }
1920 break;
1921
1922 case XLAT_GROUP:
1923 if (!type || (type & XLAT_GROUP)) {
1924 ret = walker(node, uctx);
1925 if (ret < 0) return ret;
1926 if (ret > 0) continue;
1927 }
1928
1929 /*
1930 * Evaluate the child.
1931 */
1932 ret = xlat_eval_walk(node->group, walker, type, uctx);
1933 if (ret < 0) return ret;
1934 break;
1935
1936 default:
1937 if (!type || (type & node->type)) {
1938 ret = walker(node, uctx);
1939 if (ret < 0) return ret;
1940 }
1941 break;
1942 }
1943 }
1944
1945 return 0;
1946}
1947
1949{
1951
1952 if (instance_count > 0) {
1954 return 0;
1955 }
1956
1958
1960 PERROR("%s", __FUNCTION__);
1961 return -1;
1962 }
1963
1965 PERROR("%s", __FUNCTION__);
1967 return -1;
1968 }
1969
1970 return 0;
1971}
1972
1974{
1976
1977 if (--instance_count > 0) return;
1978
1980}
static int const char char buffer[256]
Definition acutest.h:576
va_list args
Definition acutest.h:770
static int const char * fmt
Definition acutest.h:573
int const char int line
Definition acutest.h:702
#define UNCONST(_type, _ptr)
Remove const qualification from a pointer.
Definition build.h:167
#define RCSID(id)
Definition build.h:485
#define L(_str)
Helper for initialising arrays of string literals.
Definition build.h:209
#define unlikely(_x)
Definition build.h:383
#define UNUSED
Definition build.h:317
#define NUM_ELEMENTS(_t)
Definition build.h:339
static void * fr_dcursor_next(fr_dcursor_t *cursor)
Advanced the cursor to the next item.
Definition dcursor.h:290
static int fr_dcursor_append(fr_dcursor_t *cursor, void *v)
Insert a single item at the end of the list.
Definition dcursor.h:408
static void * fr_dcursor_tail(fr_dcursor_t *cursor)
Wind cursor to the tail item in the list.
Definition dcursor.h:260
static int fr_dcursor_insert(fr_dcursor_t *cursor, void *v)
Insert directly after the current item.
Definition dcursor.h:437
static void * fr_dcursor_current(fr_dcursor_t *cursor)
Return the item the cursor current points to.
Definition dcursor.h:339
#define fr_cond_assert(_x)
Calls panic_action ifndef NDEBUG, else logs error and evaluates to value of _x.
Definition debug.h:139
#define fr_assert_fail(_msg,...)
Calls panic_action ifndef NDEBUG, else logs error.
Definition debug.h:216
#define MEM(x)
Definition debug.h:36
#define fr_dict_autofree(_to_free)
Definition dict.h:870
static fr_slen_t err
Definition dict.h:841
fr_dict_attr_t const ** out
Where to write a pointer to the resolved fr_dict_attr_t.
Definition dict.h:274
fr_dict_t const ** out
Where to write a pointer to the loaded/resolved fr_dict_t.
Definition dict.h:287
int fr_dict_attr_autoload(fr_dict_attr_autoload_t const *to_load)
Process a dict_attr_autoload element to load/verify a dictionary attribute.
Definition dict_util.c:4134
#define fr_dict_autoload(_to_load)
Definition dict.h:867
static fr_slen_t in
Definition dict.h:841
Specifies an attribute which must be present for the module to function.
Definition dict.h:273
Specifies a dictionary which must be loaded/loadable for the module to function.
Definition dict.h:286
Test enumeration values.
Definition dict_test.h:92
static unsigned int fr_dlist_num_elements(fr_dlist_head_t const *head)
Return the number of elements in the dlist.
Definition dlist.h:939
#define EXEC_TIMEOUT
Default wait time for exec calls (in seconds).
Definition exec.h:32
rlm_rcode_t unlang_interpret(request_t *request, bool running)
Run the interpreter for a current request.
Definition interpret.c:941
unlang_interpret_t * unlang_interpret_get(request_t *request)
Get the interpreter set for a request.
Definition interpret.c:2003
int unlang_interpret_stack_depth(request_t *request)
Return the depth of the request's stack.
Definition interpret.c:1529
TALLOC_CTX * unlang_interpret_frame_talloc_ctx(request_t *request)
Get a talloc_ctx which is valid only for this frame.
Definition interpret.c:1661
fr_event_list_t * unlang_interpret_event_list(request_t *request)
Get the event list for the current interpreter.
Definition interpret.c:2013
rlm_rcode_t rcode
The current rcode, from executing the instruction or merging the result from a frame.
Definition interpret.h:134
#define UNLANG_TOP_FRAME
Definition interpret.h:36
#define UNLANG_REQUEST_RUNNING
Definition interpret.h:42
rlm_rcode_t unlang_interpret_synchronous(fr_event_list_t *el, request_t *request)
Execute an unlang section synchronously.
#define PERROR(_fmt,...)
Definition log.h:228
#define REXDENT()
Exdent (unindent) R* messages by one level.
Definition log.h:443
#define RDEBUG3(fmt,...)
Definition log.h:343
#define RERROR(fmt,...)
Definition log.h:298
#define REMARKER(_str, _marker_idx, _marker,...)
Output string with error marker, showing where format error occurred.
Definition log.h:498
#define RPEDEBUG(fmt,...)
Definition log.h:376
#define RINDENT()
Indent R* messages by one level.
Definition log.h:430
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_TIME_DELTA
A period of time measured in nanoseconds.
@ FR_TYPE_STRING
String of printable characters.
@ FR_TYPE_NULL
Invalid (uninitialised) attribute type.
@ FR_TYPE_UINT16
16 Bit unsigned integer.
@ FR_TYPE_UINT8
8 Bit unsigned integer.
@ FR_TYPE_UINT32
32 Bit unsigned integer.
@ FR_TYPE_UINT64
64 Bit unsigned integer.
@ FR_TYPE_VOID
User data.
@ FR_TYPE_BOOL
A truth value.
@ FR_TYPE_GROUP
A grouping of other attributes.
long int ssize_t
unsigned char bool
ssize_t fr_slen_t
struct tm * gmtime_r(time_t const *l_clock, struct tm *result)
Definition missing.c:201
struct tm * localtime_r(time_t const *l_clock, struct tm *result)
Definition missing.c:163
@ MOD_ACTION_NOT_SET
Definition mod_action.h:40
#define fr_assert(_expr)
Definition rad_assert.h:38
#define REDEBUG(fmt,...)
Definition radclient.h:52
#define RDEBUG_ENABLED2()
Definition radclient.h:50
#define RDEBUG2(fmt,...)
Definition radclient.h:54
rlm_rcode_t
Return codes indicating the result of the module call.
Definition rcode.h:40
@ RLM_MODULE_FAIL
Module failed, don't reply.
Definition rcode.h:42
@ RLM_MODULE_REJECT
Immediately reject the request.
Definition rcode.h:41
@ RLM_MODULE_NOT_SET
Error resolving rcode (should not be returned by modules).
Definition rcode.h:52
fr_dict_attr_t const * request_attr_request
Definition request.c:43
static char const * name
ssize_t fr_sbuff_in_strcpy(fr_sbuff_t *sbuff, char const *str)
Copy bytes into the sbuff up to the first \0.
Definition sbuff.c:1456
ssize_t fr_sbuff_in_sprintf(fr_sbuff_t *sbuff, char const *fmt,...)
Print using a fmt string to an sbuff.
Definition sbuff.c:1597
#define fr_sbuff_start(_sbuff_or_marker)
#define FR_SBUFF_IN_CHAR_RETURN(_sbuff,...)
#define fr_sbuff_set(_dst, _src)
#define FR_SBUFF_IN(_start, _len_or_end)
#define FR_SBUFF_IN_SPRINTF_RETURN(...)
#define FR_SBUFF(_sbuff_or_marker)
#define fr_sbuff_used(_sbuff_or_marker)
#define FR_SBUFF_TALLOC_THREAD_LOCAL(_out, _init, _max)
#define tmpl_is_xlat(vpt)
Definition tmpl.h:210
#define tmpl_value(_tmpl)
Definition tmpl.h:937
#define tmpl_is_attr(vpt)
Definition tmpl.h:208
#define tmpl_is_exec(vpt)
Definition tmpl.h:211
ssize_t tmpl_afrom_attr_str(TALLOC_CTX *ctx, tmpl_attr_error_t *err, tmpl_t **out, char const *name, tmpl_rules_t const *rules))
Parse a string into a TMPL_TYPE_ATTR_* type tmpl_t.
int tmpl_eval_cast_in_place(fr_value_box_list_t *out, request_t *request, tmpl_t const *vpt)
Casts a value or list of values according to the tmpl.
Definition tmpl_eval.c:1228
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:956
#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
#define tmpl_needs_resolving(vpt)
Definition tmpl.h:223
Optional arguments passed to vp_tmpl functions.
Definition tmpl.h:332
fr_signal_t
Signals that can be generated/processed by request signal handlers.
Definition signal.h:38
static char buff[sizeof("18446744073709551615")+3]
Definition size_tests.c:41
PUBLIC int snprintf(char *string, size_t length, char *format, va_alist)
Definition snprintf.c:689
return count
Definition module.c:155
fr_aka_sim_id_type_t type
#define fr_time()
Allow us to arbitrarily manipulate time.
Definition state_test.c:8
char const * fr_syserror(int num)
Guaranteed to be thread-safe version of strerror.
Definition syserror.c:243
#define fr_table_value_by_str(_table, _name, _def)
Convert a string to a value using a sorted or ordered table.
Definition table.h:653
#define fr_table_str_by_value(_table, _number, _def)
Convert an integer to a string.
Definition table.h:772
An element in a lexicographically sorted array of name to num mappings.
Definition table.h:49
An element in an arbitrarily ordered array of name to ptr mappings.
Definition table.h:73
char * talloc_typed_strdup(TALLOC_CTX *ctx, char const *p)
Call talloc_strdup, setting the type on the new chunk correctly.
Definition talloc.c:467
static int64_t fr_time_to_sec(fr_time_t when)
Convert an fr_time_t (internal time) to number of sec since the unix epoch (wallclock time)
Definition time.h:731
static int64_t fr_time_to_msec(fr_time_t when)
Convert an fr_time_t (internal time) to number of msec since the unix epoch (wallclock time)
Definition time.h:711
static fr_time_delta_t fr_time_delta_from_sec(int64_t sec)
Definition time.h:590
static int64_t fr_time_to_usec(fr_time_t when)
Convert an fr_time_t (internal time) to number of usec since the unix epoch (wallclock time)
Definition time.h:701
int unlang_tmpl_push(TALLOC_CTX *ctx, fr_value_box_list_t *out, request_t *request, tmpl_t const *tmpl, unlang_tmpl_args_t *args)
Push a tmpl onto the stack for evaluation.
Definition tmpl.c:254
fr_pair_t * tmpl_dcursor_value_box_init(int *err, TALLOC_CTX *ctx, fr_value_box_t *vb, request_t *request, tmpl_t const *vpt)
Initialize a #tmpl_dcursor_t into a fr_value_box_t.
char const * fr_tokens[T_TOKEN_LAST]
Definition token.c:79
const bool fr_comparison_op[T_TOKEN_LAST]
Definition token.c:199
const bool fr_binary_op[T_TOKEN_LAST]
Definition token.c:217
enum fr_token fr_token_t
@ T_INVALID
Definition token.h:39
@ T_BARE_WORD
Definition token.h:120
#define TMPL_ARGS_EXEC(_env, _timeout, _stdout_on_error, _status_out)
Create a temporary argument structure for evaluating an exec type tmpl.
Definition tmpl.h:76
xlat_action_t unlang_xlat_yield(request_t *request, xlat_func_t resume, xlat_func_signal_t signal, fr_signal_t sigmask, void *rctx)
Yield a request back to the interpreter from within a module.
Definition xlat.c:560
int unlang_xlat_push(TALLOC_CTX *ctx, unlang_result_t *p_result, fr_value_box_list_t *out, request_t *request, xlat_exp_head_t const *xlat, bool top_frame)
Push a pre-compiled xlat onto the stack for evaluation.
Definition xlat.c:282
fr_type_t type
Type to cast argument to.
Definition xlat.h:155
uint8_t single
Argument must only contain a single box.
Definition xlat.h:148
void * data
Thread specific instance data.
Definition xlat.h:94
xlat_thread_inst_t * xlat_thread_instance_find(xlat_exp_t const *node)
Retrieve xlat/thread specific instance data.
Definition xlat_inst.c:405
bool xlat_is_literal(xlat_exp_head_t const *head)
Check to see if the expansion consists entirely of value-box elements.
void * uctx
Argument to pass to escape callback.
Definition xlat.h:159
bool xlat_impure_func(xlat_exp_head_t const *head)
xlat_escape_func_t func
Function to handle tainted values.
Definition xlat.h:156
fr_slen_t xlat_tokenize(TALLOC_CTX *ctx, xlat_exp_head_t **head, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules)
Tokenize an xlat expansion.
uint8_t always_escape
Pass all arguments to escape function not just tainted ones.
Definition xlat.h:151
@ XLAT_ARG_VARIADIC_EMPTY_KEEP
Empty argument groups are left alone, and either passed through as empty groups or null boxes.
Definition xlat.h:137
@ XLAT_ARG_VARIADIC_EMPTY_SQUASH
Empty argument groups are removed.
Definition xlat.h:136
@ XLAT_ARG_VARIADIC_DISABLED
Definition xlat.h:135
static fr_slen_t head
Definition xlat.h:420
xlat_arg_parser_variadic_t variadic
All additional boxes should be processed using this definition.
Definition xlat.h:153
#define XLAT_RESULT_SUCCESS(_p_result)
Definition xlat.h:503
void(* xlat_func_signal_t)(xlat_ctx_t const *xctx, request_t *request, fr_signal_t action)
A callback when the request gets a fr_signal_t.
Definition xlat.h:243
uint8_t will_escape
the function will do escaping and concatenation.
Definition xlat.h:150
fr_value_box_safe_for_t safe_for
Escaped value to set for boxes processed by this escape function.
Definition xlat.h:157
uint8_t required
Argument must be present, and non-empty.
Definition xlat.h:146
xlat_action_t(* xlat_func_t)(TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *in)
xlat callback function
Definition xlat.h:232
uint8_t concat
Concat boxes together.
Definition xlat.h:147
xlat_action_t
Definition xlat.h:37
@ XLAT_ACTION_FAIL
An xlat function failed.
Definition xlat.h:44
@ XLAT_ACTION_YIELD
An xlat function pushed a resume frame onto the stack.
Definition xlat.h:42
@ XLAT_ACTION_PUSH_UNLANG
An xlat function pushed an unlang frame onto the unlang stack.
Definition xlat.h:39
@ XLAT_ACTION_PUSH_CHILD
A deeper level of nesting needs to be evaluated.
Definition xlat.h:38
@ XLAT_ACTION_DONE
We're done evaluating this level of nesting.
Definition xlat.h:43
uint8_t constant
xlat is just tmpl_attr_tail_data, or XLAT_BOX
Definition xlat.h:114
module_ctx_t const * mctx
A synthesised module calling ctx containing module global and thread instance data.
Definition xlat.h:96
Definition for a single argument consumend by an xlat function.
Definition xlat.h:145
Thread specific instance data for xlat expansion node.
Definition xlat.h:85
char const * fr_strerror(void)
Get the last library error.
Definition strerror.c:553
#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_void(_x)
Definition types.h:374
@ FR_TYPE_PAIR_CURSOR
cursor over a fr_pair_t
Definition types.h:89
#define fr_type_is_null(_x)
Definition types.h:343
#define fr_type_is_leaf(_x)
Definition types.h:389
static char const * fr_type_to_str(fr_type_t type)
Return a static string containing the type name.
Definition types.h:450
void fr_value_box_debug(fr_value_box_t const *vb)
Print the value of a box as info messages.
Definition value.c:6684
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:3574
char * fr_value_box_list_aprint(TALLOC_CTX *ctx, fr_value_box_list_t const *list, char const *delim, fr_sbuff_escape_rules_t const *e_rules)
Concatenate the string representations of a list of value boxes together.
Definition value.c:6213
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:3962
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:3790
void fr_value_box_clear_value(fr_value_box_t *data)
Clear/free any existing value.
Definition value.c:3899
int fr_value_box_strdup(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, bool tainted)
Copy a nul terminated string to a fr_value_box_t.
Definition value.c:4158
void fr_value_box_strdup_shallow_replace(fr_value_box_t *vb, char const *src, ssize_t len)
Free the existing buffer (if talloced) associated with the valuebox, and replace it with a new one.
Definition value.c:4283
int fr_value_box_list_acopy(TALLOC_CTX *ctx, fr_value_box_list_t *out, fr_value_box_list_t const *in)
Do a full copy of a list of value boxes.
Definition value.c:6343
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:5949
@ FR_VALUE_BOX_LIST_FREE
Definition value.h:237
#define fr_value_box_alloc(_ctx, _type, _enumv)
Allocate a value box of a specific type.
Definition value.h:640
#define fr_value_box_mark_safe_for(_box, _safe_for)
Definition value.h:1071
#define fr_box_strvalue_buffer(_val)
Definition value.h:308
#define fr_value_box_is_safe_for(_box, _safe_for)
Definition value.h:1078
#define FR_VALUE_BOX_SAFE_FOR_NONE
Definition value.h:170
uintptr_t fr_value_box_safe_for_t
Escaping that's been applied to a value box.
Definition value.h:160
#define VALUE_BOX_VERIFY(_x)
Definition value.h:1318
#define VALUE_BOX_LIST_VERIFY(_x)
Definition value.h:1319
int nonnull(2, 5))
#define fr_value_box_alloc_null(_ctx)
Allocate a value box for later use with a value assignment function.
Definition value.h:651
#define fr_value_box_init(_vb, _type, _enumv, _tainted)
Initialise a fr_value_box_t.
Definition value.h:606
#define fr_value_box_list_foreach(_list_head, _iter)
Definition value.h:222
static size_t char ** out
Definition value.h:1020
#define FR_VALUE_BOX_SAFE_FOR_ANY
Definition value.h:171
void * rctx
Resume context.
Definition xlat_ctx.h:54
#define XLAT_CTX(_inst, _thread, _ex, _mctx, _env_data, _rctx)
Wrapper to create a xlat_ctx_t as a compound literal.
Definition xlat_ctx.h:95
An xlat calling ctx.
Definition xlat_ctx.h:49
ssize_t xlat_eval_compiled(char *out, size_t outlen, request_t *request, xlat_exp_head_t const *xlat, xlat_escape_legacy_t escape, void const *escape_ctx)
Definition xlat_eval.c:1811
static size_t xlat_time_precision_table_len
Definition xlat_eval.c:127
static fr_dict_attr_t const * attr_cast_time_res_week
Definition xlat_eval.c:51
static fr_table_ptr_ordered_t const xlat_time_precision_table[]
Definition xlat_eval.c:89
static fr_slen_t xlat_fmt_print(fr_sbuff_t *out, xlat_exp_t const *node)
Reconstruct the original expansion string from an xlat tree.
Definition xlat_eval.c:150
static void xlat_debug_log_expansion(request_t *request, xlat_exp_t const *node, fr_value_box_list_t const *args, UNUSED int line)
Output what we're currently expanding.
Definition xlat_eval.c:218
xlat_action_t xlat_frame_eval_repeat(TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_exp_head_t const **child, request_t *request, xlat_exp_head_t const *head, xlat_exp_t const **in, void *env_data, fr_value_box_list_t *result)
Process the result of a previous nested expansion.
Definition xlat_eval.c:1119
void xlat_signal(xlat_func_signal_t signal, xlat_exp_t const *exp, request_t *request, void *rctx, fr_signal_t action)
Signal an xlat function.
Definition xlat_eval.c:1011
fr_dict_attr_t const * xlat_time_res_attr(char const *res)
Definition xlat_eval.c:129
static void xlat_debug_log_result(request_t *request, xlat_exp_t const *node, fr_value_box_t const *result)
Output the result of an expansion.
Definition xlat_eval.c:288
int xlat_eval_init(void)
Definition xlat_eval.c:1948
fr_table_num_sorted_t const xlat_action_table[]
Definition xlat_eval.c:78
xlat_action_t xlat_frame_eval_resume(TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_exp_head_t const **child, request_t *request, xlat_exp_head_t const *head, xlat_exp_t const **in, fr_value_box_list_t *result, xlat_func_t resume, void *rctx)
Call an xlat's resumption method.
Definition xlat_eval.c:1045
static fr_dict_attr_t const * attr_cast_time_res_year
Definition xlat_eval.c:53
static fr_dict_t const * dict_freeradius
Definition xlat_eval.c:37
static fr_dict_attr_t const * attr_cast_time_res_nsec
Definition xlat_eval.c:57
static xlat_action_t xlat_eval_one_letter(TALLOC_CTX *ctx, fr_value_box_list_t *out, request_t *request, char letter)
One letter expansions.
Definition xlat_eval.c:794
static fr_dict_attr_t const * attr_cast_time_res_month
Definition xlat_eval.c:52
static fr_dict_attr_t const * attr_cast_time_res_usec
Definition xlat_eval.c:56
fr_dict_attr_t const * attr_expr_bool_enum
Definition xlat_eval.c:44
static fr_dict_attr_t const * attr_cast_time_res_csec
Definition xlat_eval.c:54
size_t xlat_action_table_len
Definition xlat_eval.c:84
static ssize_t _xlat_eval(TALLOC_CTX *ctx, char **out, size_t outlen, request_t *request, char const *fmt, xlat_escape_legacy_t escape, void const *escape_ctx)
Replace whatever in a string.
Definition xlat_eval.c:1754
static xlat_action_t xlat_process_arg_list(TALLOC_CTX *ctx, fr_value_box_list_t *list, request_t *request, char const *name, xlat_arg_parser_t const *arg, xlat_exp_t const *node, unsigned int arg_num)
Process an individual xlat argument value box group.
Definition xlat_eval.c:362
static fr_dict_autoload_t xlat_eval_dict[]
Definition xlat_eval.c:39
static fr_dict_attr_t const * attr_cast_time_res_msec
Definition xlat_eval.c:55
fr_dict_attr_t const * attr_cast_base
Definition xlat_eval.c:45
fr_value_box_list_t list
Definition xlat_eval.c:982
ssize_t xlat_eval(char *out, size_t outlen, request_t *request, char const *fmt, xlat_escape_legacy_t escape, void const *escape_ctx)
Definition xlat_eval.c:1803
xlat_action_t xlat_frame_eval(TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_exp_head_t const **child, request_t *request, xlat_exp_head_t const *head, xlat_exp_t const **in)
Converts xlat nodes to value boxes.
Definition xlat_eval.c:1324
int xlat_flatten_to_argv(TALLOC_CTX *ctx, xlat_exp_head_t ***argv, xlat_exp_head_t *head)
Turn am xlat list into an argv[] array, and nuke the input list.
Definition xlat_eval.c:1842
static fr_dict_attr_autoload_t xlat_eval_dict_attr[]
Definition xlat_eval.c:59
static xlat_action_t xlat_process_args(TALLOC_CTX *ctx, fr_value_box_list_t *list, request_t *request, xlat_exp_t const *node)
Process list of boxed values provided as input to an xlat.
Definition xlat_eval.c:587
static bool xlat_process_return(request_t *request, xlat_t const *func, fr_value_box_list_t const *returned, fr_value_box_t *pos)
Validate that the return values from an xlat function match what it registered.
Definition xlat_eval.c:746
void xlat_eval_free(void)
Definition xlat_eval.c:1973
static int xlat_arg_stringify(request_t *request, xlat_arg_parser_t const *arg, xlat_exp_t const *node, fr_value_box_t *vb)
Definition xlat_eval.c:297
int xlat_eval_walk(xlat_exp_head_t *head, xlat_walker_t walker, xlat_type_t type, void *uctx)
Walk over all xlat nodes (depth first) in a xlat expansion, calling a callback.
Definition xlat_eval.c:1884
static fr_dict_attr_t const * attr_cast_time_res_sec
Definition xlat_eval.c:47
static xlat_action_t xlat_null_resume(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, UNUSED fr_value_box_list_t *in)
Definition xlat_eval.c:1019
ssize_t xlat_aeval(TALLOC_CTX *ctx, char **out, request_t *request, char const *fmt, xlat_escape_legacy_t escape, void const *escape_ctx)
Definition xlat_eval.c:1819
static fr_dict_attr_t const * attr_cast_time_res_day
Definition xlat_eval.c:50
static ssize_t _xlat_eval_compiled(TALLOC_CTX *ctx, char **out, size_t outlen, request_t *request, xlat_exp_head_t const *head, xlat_escape_legacy_t escape, void const *escape_ctx)
Replace whatever in a string.
Definition xlat_eval.c:1701
ssize_t xlat_aeval_compiled(TALLOC_CTX *ctx, char **out, request_t *request, xlat_exp_head_t const *xlat, xlat_escape_legacy_t escape, void const *escape_ctx)
Definition xlat_eval.c:1828
static int xlat_sync_stringify(TALLOC_CTX *ctx, request_t *request, xlat_exp_head_t const *head, fr_value_box_list_t *list, xlat_escape_legacy_t escape, void const *escape_ctx)
Definition xlat_eval.c:1545
static void xlat_debug_log_list_result(request_t *request, xlat_exp_t const *node, fr_value_box_list_t const *result)
Output the list result of an expansion.
Definition xlat_eval.c:273
static fr_dict_attr_t const * attr_cast_time_res_min
Definition xlat_eval.c:48
static ssize_t xlat_eval_sync(TALLOC_CTX *ctx, char **out, request_t *request, xlat_exp_head_t const *const head, xlat_escape_legacy_t escape, void const *escape_ctx)
Definition xlat_eval.c:1623
static xlat_action_t xlat_exec_resume(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_ctx_t const *xctx, UNUSED request_t *request, UNUSED fr_value_box_list_t *in)
Definition xlat_eval.c:985
static fr_dict_attr_t const * attr_cast_time_res_hour
Definition xlat_eval.c:49
static int instance_count
Definition xlat_eval.c:35
#define XLAT_DEBUG(...)
Definition xlat_expr.c:38
char const * name
Name of xlat function.
Definition xlat_priv.h:64
xlat_flags_t flags
Flags that control resolution and evaluation.
Definition xlat_priv.h:154
fr_type_t return_type
Function is guaranteed to return one or more boxes of this type.
Definition xlat_priv.h:101
static xlat_exp_t * xlat_exp_next(xlat_exp_head_t const *head, xlat_exp_t const *node)
Definition xlat_priv.h:246
xlat_func_t func
async xlat function (async unsafe).
Definition xlat_priv.h:65
int(* xlat_walker_t)(xlat_exp_t *exp, void *uctx)
Walker callback for xlat_walk()
Definition xlat_priv.h:267
fr_token_t quote
Type of quoting around XLAT_GROUP types.
Definition xlat_priv.h:152
xlat_type_t
Definition xlat_priv.h:106
@ XLAT_ONE_LETTER
Special "one-letter" expansion.
Definition xlat_priv.h:109
@ XLAT_BOX
fr_value_box_t
Definition xlat_priv.h:108
@ XLAT_TMPL
xlat attribute
Definition xlat_priv.h:112
@ XLAT_FUNC
xlat module
Definition xlat_priv.h:110
@ XLAT_GROUP
encapsulated string of xlats
Definition xlat_priv.h:116
@ XLAT_FUNC_UNRESOLVED
func needs resolution during pass2.
Definition xlat_priv.h:111
@ XLAT_INVALID
Bad expansion.
Definition xlat_priv.h:107
xlat_arg_parser_t const * args
Definition of args consumed.
Definition xlat_priv.h:94
char const *_CONST fmt
The original format string (a talloced buffer).
Definition xlat_priv.h:151
xlat_type_t _CONST type
type of this expansion.
Definition xlat_priv.h:155
fr_value_box_safe_for_t return_safe_for
Escaped value to set in output boxes.
Definition xlat_priv.h:100
#define xlat_exp_foreach(_list_head, _iter)
Iterate over the contents of a list, only one level.
Definition xlat_priv.h:222
static xlat_exp_t * xlat_exp_head(xlat_exp_head_t const *head)
Definition xlat_priv.h:209
An xlat expansion node.
Definition xlat_priv.h:148