The FreeRADIUS server $Id: 15bac2a4c627c01d1aa2047687b3418955ac7f00 $
Loading...
Searching...
No Matches
xlat_expr.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: a9c70ea5e710c115ba57d1730a6eee1e9a47ef9c $
19 *
20 * @file xlat_expr.c
21 * @brief Tokenizers and support functions for xlat expressions
22 *
23 * @copyright 2021 The FreeRADIUS server project
24 * @copyright 2021 Network RADIUS SAS (legal@networkradius.com)
25 */
26
27RCSID("$Id: a9c70ea5e710c115ba57d1730a6eee1e9a47ef9c $")
28
29#include <freeradius-devel/server/base.h>
30#include <freeradius-devel/unlang/xlat_priv.h>
31#include <freeradius-devel/util/calc.h>
32#include <freeradius-devel/server/tmpl_dcursor.h>
33
34#undef XLAT_DEBUG
35#ifdef DEBUG_XLAT
36# define XLAT_DEBUG(_fmt, ...) DEBUG3("%s[%i] "_fmt, __FILE__, __LINE__, ##__VA_ARGS__)
37#else
38# define XLAT_DEBUG(...)
39#endif
40
41/*
42 * The new tokenizer accepts most things which are accepted by the old one. Many of the errors will be
43 * different, though.
44 *
45 * @todo - add a "output" fr_type_t to xlat_t, which is mainly used by the comparison functions. Right
46 * now it will happily parse things like:
47 *
48 * (1 < 2) < 3
49 *
50 * though the result of (1 < 2) is a boolean, so the result is always true. We probably want to have
51 * that as a compile-time error / check. This can probably just be done with xlat_purify() ? which
52 * doesn't need to interpret the LHS, but just knows its limits. We perhaps want a "range compare"
53 * function, which just checks ranges on one side against values on the right.
54 *
55 * Even worse, when we do "((bool) 1) < 3", the RHS is cast to the type of the LHS by
56 * tmpl_afrom_substr(). This is because we pass the LHS data type recursively down, which works most of
57 * the time, but not all of the time. There are currently hacks in the "upcast" code here to fix this,
58 * but it's a hack.
59 *
60 * @todo - add instantiation routines for assignment operations. This lets us do things
61 * like:
62 * if ((&foo += 4) > 6) ...
63 *
64 * However, this would also require us adding an edit list pointer to the xlat evaluation functions,
65 * which is not trivial. Or, maybe we attach it to the request somehow?
66 */
67
68static xlat_exp_t *xlat_exists_alloc(TALLOC_CTX *ctx, xlat_exp_t *child);
69
70static void xlat_func_append_arg(xlat_exp_t *head, xlat_exp_t *node, bool exists)
71{
72 xlat_exp_t *group;
73
74 fr_assert(head->type == XLAT_FUNC);
75
76 /*
77 * Wrap existence checks for attribute reference.
78 */
79 if (exists && (node->type == XLAT_TMPL) && tmpl_contains_attr(node->vpt)) {
80 node = xlat_exists_alloc(head, node);
81 }
82
83 if (!head->call.args) {
84 MEM(head->call.args = xlat_exp_head_alloc(head));
85 head->call.args->is_argv = true;
86 }
87
88 /*
89 * Wrap it in a group.
90 */
91 group = xlat_exp_alloc(head->call.args, XLAT_GROUP, NULL, 0);
92 group->quote = T_BARE_WORD;
93
94 xlat_exp_set_name_shallow(group, node->fmt); /* not entirely correct, but good enough for now */
95 group->flags = node->flags;
96
97 talloc_steal(group->group, node);
98 xlat_exp_insert_tail(group->group, node);
99
100 xlat_exp_insert_tail(head->call.args, group);
101
102 xlat_flags_merge(&head->flags, &head->call.args->flags);
103}
104
105
106/** Allocate a specific cast node.
107 *
108 * With the first argument being a UINT8 of the data type.
109 * See xlat_func_cast() for the implementation.
110 *
111 */
112static xlat_exp_t *xlat_exists_alloc(TALLOC_CTX *ctx, xlat_exp_t *child)
113{
114 xlat_exp_t *node;
115
116 fr_assert(child->type == XLAT_TMPL);
117 fr_assert(tmpl_contains_attr(child->vpt));
118
119 /*
120 * Create an "exists" node.
121 */
122 MEM(node = xlat_exp_alloc(ctx, XLAT_FUNC, "exists", 6));
123 xlat_exp_set_name_shallow(node, child->vpt->name);
124
125 MEM(node->call.func = xlat_func_find("exists", 6));
126 fr_assert(node->call.func != NULL);
127
128 /*
129 * The attribute may need resolving, in which case we have to set the flag as appropriate.
130 */
131 node->flags = (xlat_flags_t) { .needs_resolving = tmpl_needs_resolving(child->vpt)};
132
133 if (!node->flags.needs_resolving) node->call.dict = tmpl_attr_tail_da(child->vpt)->dict;
134
135 xlat_func_append_arg(node, child, false);
136
137 return node;
138}
139
140
141static fr_slen_t xlat_expr_print_unary(fr_sbuff_t *out, xlat_exp_t const *node, UNUSED void *inst, fr_sbuff_escape_rules_t const *e_rules)
142{
143 size_t at_in = fr_sbuff_used_total(out);
144
145 FR_SBUFF_IN_STRCPY_RETURN(out, fr_tokens[node->call.func->token]);
146 xlat_print_node(out, node->call.args, xlat_exp_head(node->call.args), e_rules, 0);
147
148 return fr_sbuff_used_total(out) - at_in;
149}
150
151static fr_slen_t xlat_expr_print_binary(fr_sbuff_t *out, xlat_exp_t const *node, UNUSED void *inst, fr_sbuff_escape_rules_t const *e_rules)
152{
153 size_t at_in = fr_sbuff_used_total(out);
154 xlat_exp_t *child = xlat_exp_head(node->call.args);
155
156 fr_assert(child != NULL);
157
158 FR_SBUFF_IN_CHAR_RETURN(out, '(');
159 xlat_print_node(out, node->call.args, child, e_rules, 0); /* prints a space after the first argument */
160
161 FR_SBUFF_IN_STRCPY_RETURN(out, fr_tokens[node->call.func->token]);
162 FR_SBUFF_IN_CHAR_RETURN(out, ' ');
163
164 child = xlat_exp_next(node->call.args, child);
165 fr_assert(child != NULL);
166
167 xlat_print_node(out, node->call.args, child, e_rules, 0);
168
169 FR_SBUFF_IN_CHAR_RETURN(out, ')');
170
171 return fr_sbuff_used_total(out) - at_in;
172}
173
174static int xlat_expr_resolve_binary(xlat_exp_t *node, UNUSED void *inst, xlat_res_rules_t const *xr_rules)
175{
176 xlat_exp_t *arg1, *arg2;
177 xlat_exp_t *a, *b;
178 tmpl_res_rules_t my_tr_rules;
179
180 XLAT_DEBUG("RESOLVE %s\n", node->fmt);
181
182 arg1 = xlat_exp_head(node->call.args);
183 fr_assert(arg1);
184 fr_assert(arg1->type == XLAT_GROUP);
185
186 arg2 = xlat_exp_next(node->call.args, arg1);
187 fr_assert(arg2);
188 fr_assert(arg2->type == XLAT_GROUP);
189
190 a = xlat_exp_head(arg1->group);
191 b = xlat_exp_head(arg2->group);
192
193 /*
194 * We have many things here, just call resolve recursively.
195 */
196 if (xlat_exp_next(arg1->group, a) || (xlat_exp_next(arg2->group, b))) goto resolve;
197
198 /*
199 * Anything else must get resolved at run time.
200 */
201 if ((a->type != XLAT_TMPL) || (b->type != XLAT_TMPL)) goto resolve;
202
203 /*
204 * The tr_rules should always contain dict_def
205 */
206 fr_assert(xr_rules); /* always set by xlat_resolve() */
207 if (xr_rules->tr_rules) {
208 my_tr_rules = *xr_rules->tr_rules;
209 } else {
210 my_tr_rules = (tmpl_res_rules_t) { };
211 }
212
213 /*
214 * The LHS attribute dictates the enumv for the RHS one.
215 */
216 if (tmpl_contains_attr(a->vpt)) {
217 XLAT_DEBUG("\ta - %s %s\n", a->fmt, b->fmt);
218
219 if (a->flags.needs_resolving) {
220 XLAT_DEBUG("\tresolve attr a\n");
221 if (tmpl_resolve(a->vpt, &my_tr_rules) < 0) return -1;
222 a->flags.needs_resolving = false;
223 }
224
225 my_tr_rules.enumv = tmpl_attr_tail_da(a->vpt);
226
227 XLAT_DEBUG("\tresolve other b\n");
228 if (tmpl_resolve(b->vpt, &my_tr_rules) < 0) return -1;
229
230 b->flags.needs_resolving = false;
231 b->flags.pure = tmpl_is_data(b->vpt);
232 b->flags.constant = b->flags.pure;
233 goto flags;
234 }
235
236 if (tmpl_contains_attr(b->vpt)) {
237 XLAT_DEBUG("\tb - %s %s\n", a->fmt, b->fmt);
238
239 if (b->flags.needs_resolving) {
240 XLAT_DEBUG("\tresolve attr b\n");
241 if (tmpl_resolve(b->vpt, &my_tr_rules) < 0) return -1;
242
243 b->flags.needs_resolving = false;
244 }
245
246 my_tr_rules.enumv = tmpl_attr_tail_da(b->vpt);
247
248 XLAT_DEBUG("\tresolve other a\n");
249 if (tmpl_resolve(a->vpt, &my_tr_rules) < 0) return -1;
250
251 a->flags.needs_resolving = false;
252 a->flags.pure = tmpl_is_data(a->vpt);
253 a->flags.constant = a->flags.pure;
254 goto flags;
255 }
256
257resolve:
258 /*
259 * This call will fix everything recursively.
260 */
261 return xlat_resolve(node->call.args, xr_rules);
262
263flags:
264 arg1->flags = arg1->group->flags = a->flags;
265 arg2->flags = arg2->group->flags = b->flags;
266 xlat_flags_merge(&node->call.args->flags, &arg2->flags);
267
268 fr_assert(!a->flags.needs_resolving);
269 fr_assert(!b->flags.needs_resolving);
270
271 fr_assert(!arg1->flags.needs_resolving);
272 fr_assert(!arg2->flags.needs_resolving);
273
274 node->call.args->flags.needs_resolving = false;
275
276 return 0;
277}
278
279static void fr_value_box_init_zero(fr_value_box_t *vb, fr_type_t type)
280{
281 switch (type) {
282 case FR_TYPE_STRING:
283 fr_value_box_strdup_shallow(vb, NULL, "", false);
284 break;
285
286 case FR_TYPE_OCTETS:
287 fr_value_box_memdup_shallow(vb, NULL, (void const *) "", 0, false);
288 break;
289
290 default:
291 fr_value_box_init(vb, type, NULL, false);
292 break;
293 }
294}
295
296static xlat_arg_parser_t const binary_op_xlat_args[] = {
297 { .required = false, .type = FR_TYPE_VOID },
298 { .required = false, .type = FR_TYPE_VOID },
299 XLAT_ARG_PARSER_TERMINATOR
300};
301
302static xlat_action_t xlat_binary_op(TALLOC_CTX *ctx, fr_dcursor_t *out,
303 UNUSED xlat_ctx_t const *xctx,
304 request_t *request, fr_value_box_list_t *in,
305 fr_token_t op,
306 fr_type_t default_type, fr_dict_attr_t const *enumv)
307{
308 int rcode;
309 fr_value_box_t *dst, *a, *b;
310 fr_value_box_t one, two;
311
312 MEM(dst = fr_value_box_alloc_null(ctx));
313
314 /*
315 * Each argument is a FR_TYPE_GROUP, with one or more elements in a list.
316 */
317 a = fr_value_box_list_head(in);
318 if (!a) {
319 REDEBUG("Left argument to %s is missing", fr_tokens[op]);
320 return XLAT_ACTION_FAIL;
321 }
322
323 b = fr_value_box_list_next(in, a);
324 if (!b) {
325 REDEBUG("Right argument to %s is missing", fr_tokens[op]);
326 return XLAT_ACTION_FAIL;
327 }
328
329 fr_assert(!fr_comparison_op[op]);
330
331 if (fr_value_box_list_num_elements(&a->vb_group) > 1) {
332 REDEBUG("Expected one value as the first argument, got %u",
333 fr_value_box_list_num_elements(&a->vb_group));
334 return XLAT_ACTION_FAIL;
335 }
336 a = fr_value_box_list_head(&a->vb_group);
337
338 if (fr_value_box_list_num_elements(&b->vb_group) > 1) {
339 REDEBUG("Expected one value as the second argument, got %u",
340 fr_value_box_list_num_elements(&b->vb_group));
341 return XLAT_ACTION_FAIL;
342 }
343 b = fr_value_box_list_head(&b->vb_group);
344
345 if (!a) {
346 a = &one;
347 fr_value_box_init_zero(a, b->type);
348 }
349
350 if (!b) {
351 b = &two;
352 fr_value_box_init_zero(b, a->type);
353 }
354
355 rcode = fr_value_calc_binary_op(dst, dst, default_type, a, op, b);
356 if (rcode < 0) {
357 RPEDEBUG("Failed calculating '%pV %s %pV'", a, fr_tokens[op], b);
358 talloc_free(dst);
359 return XLAT_ACTION_FAIL;
360 }
361
362 /*
363 * Over-write, but only if it's present. Otherwise leave
364 * any existing enum alone.
365 */
366 if (enumv) dst->enumv = enumv;
367 fr_dcursor_append(out, dst);
368
369 VALUE_BOX_LIST_VERIFY((fr_value_box_list_t *)out->dlist);
370 return XLAT_ACTION_DONE;
371}
372
373#define XLAT_BINARY_FUNC(_name, _op) \
374static xlat_action_t xlat_func_ ## _name(TALLOC_CTX *ctx, fr_dcursor_t *out, \
375 xlat_ctx_t const *xctx, \
376 request_t *request, fr_value_box_list_t *in) \
377{ \
378 return xlat_binary_op(ctx, out, xctx, request, in, _op, FR_TYPE_NULL, NULL); \
379}
380
381XLAT_BINARY_FUNC(op_add, T_ADD)
382XLAT_BINARY_FUNC(op_sub, T_SUB)
383XLAT_BINARY_FUNC(op_mul, T_MUL)
384XLAT_BINARY_FUNC(op_div, T_DIV)
385XLAT_BINARY_FUNC(op_mod, T_MOD)
386XLAT_BINARY_FUNC(op_and, T_AND)
387XLAT_BINARY_FUNC(op_or, T_OR)
388XLAT_BINARY_FUNC(op_xor, T_XOR)
389XLAT_BINARY_FUNC(op_rshift, T_RSHIFT)
390XLAT_BINARY_FUNC(op_lshift, T_LSHIFT)
391
392static xlat_arg_parser_t const binary_cmp_xlat_args[] = {
393 { .required = false, .type = FR_TYPE_VOID },
394 { .required = false, .type = FR_TYPE_VOID },
395 XLAT_ARG_PARSER_TERMINATOR
396};
397
398/*
399 * @todo - arguably this function should process its own arguments, like logical_or.
400 *
401 * That way it can return XLAT_ACTION_FAIL if either argument fails to be found,
402 * or if the comparison matches, it returns the RHS value. This behavior will
403 * let us to multiple comparisons, like:
404 *
405 * if (0 < x < 5) ...
406 *
407 * Which is then syntactic sugar for
408 *
409 * if ((0 < x) < 5) ...
410 *
411 * That means the comparisons no longer return "bool", so if we
412 * want to do this, the change has to be made before v4 is
413 * released.
414 *
415 * Other operators like "+=" would return their LHS value. But in order to do that, we would have to
416 * update the expression parser to allow in-place edits, and that may be a fair bit of work.
417 *
418 * It also lets us do more interesting selectors, such as:
419 *
420 * foo || (0 < x)
421 *
422 * which if "foo" doesn't exist, evaluates the RHS, and then returns "x" only if x is greater than zero.
423 * This short-hand can remove a lot of complex / nested "if" conditions.
424 *
425 * It could also allow us to do better attribute filtering:
426 *
427 * foo := (0 < foo < 5)
428 *
429 * Which ensures that "foo" has value only 1..4.
430 *
431 * It would be nice to have a syntax for "self", so we could instead do:
432 *
433 * foo := (0 < $$ < 5)
434 *
435 * Which could then also be used inside of attribute selectors:
436 *
437 * foreach foo (Vendor-Specific.Cisco.AVPair[$$ =~ /^x/]) { ...
438 *
439 * and now that we have pair cursors as value-boxes, this becomes a lot easier.
440 * "$$" then becomes syntactic sugar for "the pair at the current cursor".
441 *
442 * It also means tracking somehow the value of $$ in the interpreter? Maybe as a short-hand, just update
443 * the #request_t to add a #fr_pair_t of the current cursor value. This is a horrible hack, but would be
444 * easy to do. It doesn't allow nested cursors, but whatever. The syntax for that would be hard to get
445 * right.
446 */
447static xlat_action_t xlat_cmp_op(TALLOC_CTX *ctx, fr_dcursor_t *out,
448 UNUSED xlat_ctx_t const *xctx,
449 UNUSED request_t *request, fr_value_box_list_t *in,
450 fr_token_t op)
451{
452 int rcode;
453 fr_value_box_t *dst, *a, *b;
454
455 /*
456 * Each argument is a FR_TYPE_GROUP, with one or more elements in a list.
457 */
458 a = fr_value_box_list_head(in);
459 if (!a) {
460 REDEBUG("Left argument to %s is missing", fr_tokens[op]);
461 return XLAT_ACTION_FAIL;
462 }
463
464 b = fr_value_box_list_next(in, a);
465 if (!b) {
466 REDEBUG("Right argument to %s is missing", fr_tokens[op]);
467 return XLAT_ACTION_FAIL;
468 }
469
470 fr_assert(a->type == FR_TYPE_GROUP);
471 fr_assert(b->type == FR_TYPE_GROUP);
472
473 fr_assert(fr_comparison_op[op]);
474
475 MEM(dst = fr_value_box_alloc(ctx, FR_TYPE_BOOL, attr_expr_bool_enum));
476
477 rcode = fr_value_calc_list_cmp(dst, dst, &a->vb_group, op, &b->vb_group);
478 if (rcode < 0) {
479 talloc_free(dst);
480 return XLAT_ACTION_FAIL;
481 }
482
483 fr_assert(dst->type == FR_TYPE_BOOL);
484 dst->enumv = attr_expr_bool_enum;
485
486 fr_dcursor_append(out, dst);
487 VALUE_BOX_LIST_VERIFY((fr_value_box_list_t *)out->dlist);
488 return XLAT_ACTION_DONE;
489}
490
491
492#define XLAT_CMP_FUNC(_name, _op) \
493static xlat_action_t xlat_func_ ## _name(TALLOC_CTX *ctx, fr_dcursor_t *out, \
494 xlat_ctx_t const *xctx, \
495 request_t *request, fr_value_box_list_t *in) \
496{ \
497 return xlat_cmp_op(ctx, out, xctx, request, in, _op); \
498}
499
500XLAT_CMP_FUNC(cmp_eq, T_OP_CMP_EQ)
501XLAT_CMP_FUNC(cmp_ne, T_OP_NE)
502XLAT_CMP_FUNC(cmp_lt, T_OP_LT)
503XLAT_CMP_FUNC(cmp_le, T_OP_LE)
504XLAT_CMP_FUNC(cmp_gt, T_OP_GT)
505XLAT_CMP_FUNC(cmp_ge, T_OP_GE)
506XLAT_CMP_FUNC(cmp_eq_type, T_OP_CMP_EQ_TYPE)
507XLAT_CMP_FUNC(cmp_ne_type, T_OP_CMP_NE_TYPE)
508
509typedef struct {
510 fr_token_t op;
511 regex_t *regex; //!< precompiled regex
512 xlat_exp_t *xlat; //!< to expand
513 fr_regex_flags_t *regex_flags;
514} xlat_regex_inst_t;
515
516typedef struct {
517 unlang_result_t last_result;
518 fr_value_box_list_t list;
519} xlat_regex_rctx_t;
520
521static fr_slen_t xlat_expr_print_regex(fr_sbuff_t *out, xlat_exp_t const *node, void *instance, fr_sbuff_escape_rules_t const *e_rules)
522{
523 size_t at_in = fr_sbuff_used_total(out);
524 xlat_exp_t *child = xlat_exp_head(node->call.args);
525 xlat_regex_inst_t *inst = instance;
526
527 fr_assert(child != NULL);
528
529 FR_SBUFF_IN_CHAR_RETURN(out, '(');
530 xlat_print_node(out, node->call.args, child, e_rules, 0);
531
532 /*
533 * A space is printed after the first argument only if
534 * there's a second one. So add one if we "ate" the second argument.
535 */
536 if (inst->xlat) FR_SBUFF_IN_CHAR_RETURN(out, ' ');
537
538 FR_SBUFF_IN_STRCPY_RETURN(out, fr_tokens[node->call.func->token]);
539 FR_SBUFF_IN_CHAR_RETURN(out, ' ');
540
541 /*
542 * Regexes which aren't instantiated: only for unit tests.
543 */
544 if (!inst->xlat) {
545 child = xlat_exp_next(node->call.args, child);
546
547 fr_assert(child != NULL);
548 fr_assert(!xlat_exp_next(node->call.args, child));
549 fr_assert(child->type == XLAT_GROUP);
550
551 FR_SBUFF_IN_CHAR_RETURN(out, '/');
552 FR_SBUFF_IN_STRCPY_RETURN(out, child->fmt);
553 FR_SBUFF_IN_CHAR_RETURN(out, '/');
554
555 child = xlat_exp_head(child->group);
556 fr_assert(child->type == XLAT_TMPL);
557
558 /*
559 * The RHS may be a group
560 */
561 FR_SBUFF_RETURN(regex_flags_print, out, tmpl_regex_flags(child->vpt));
562 goto done;
563 }
564
565 fr_assert(tmpl_contains_regex(inst->xlat->vpt));
566
567 if (inst->xlat->quote == T_SINGLE_QUOTED_STRING) FR_SBUFF_IN_CHAR_RETURN(out, 'm');
568 FR_SBUFF_IN_CHAR_RETURN(out, fr_token_quote[inst->xlat->quote]);
569 FR_SBUFF_IN_STRCPY_RETURN(out, inst->xlat->vpt->name);
570 FR_SBUFF_IN_CHAR_RETURN(out, fr_token_quote[inst->xlat->quote]);
571
572 FR_SBUFF_RETURN(regex_flags_print, out, inst->regex_flags);
573
574done:
575 FR_SBUFF_IN_CHAR_RETURN(out, ')');
576
577 return fr_sbuff_used_total(out) - at_in;
578}
579
580
581/*
582 * Each argument is it's own head, because we do NOT always want
583 * to go to the next argument.
584 */
585static int xlat_instantiate_regex(xlat_inst_ctx_t const *xctx)
586{
587 xlat_regex_inst_t *inst = talloc_get_type_abort(xctx->inst, xlat_regex_inst_t);
588 xlat_exp_t *lhs, *rhs, *regex;
589
590 lhs = xlat_exp_head(xctx->ex->call.args);
591 rhs = xlat_exp_next(xctx->ex->call.args, lhs);
592
593 (void) fr_dlist_remove(&xctx->ex->call.args->dlist, rhs);
594
595 fr_assert(rhs);
596 fr_assert(rhs->type == XLAT_GROUP);
597 regex = xlat_exp_head(rhs->group);
598 fr_assert(tmpl_contains_regex(regex->vpt));
599
600 inst->op = xctx->ex->call.func->token;
601 inst->regex_flags = tmpl_regex_flags(regex->vpt);
602
603 inst->xlat = talloc_steal(inst, regex);
604 talloc_free(rhs); /* group wrapper is no longer needed */
605
606 /*
607 * The RHS is more then just one regex node, it has to be dynamically expanded.
608 */
609 if (tmpl_contains_xlat(regex->vpt)) {
610 return 0;
611 }
612
613 if (tmpl_is_data_unresolved(regex->vpt)) {
614 fr_strerror_const("Regex must be resolved before instantiation");
615 return -1;
616 }
617
618 /*
619 * Must have been caught in the parse phase.
620 */
621 fr_assert(tmpl_is_regex(regex->vpt));
622
623 inst->regex = tmpl_regex(regex->vpt);
624
625 return 0;
626}
627
628
629static xlat_arg_parser_t const regex_op_xlat_args[] = {
630 { .required = true, .type = FR_TYPE_STRING },
631 { .concat = true, .type = FR_TYPE_STRING },
632 XLAT_ARG_PARSER_TERMINATOR
633};
634
635static xlat_arg_parser_t const regex_search_xlat_args[] = {
636 { .required = true, .concat = true, .type = FR_TYPE_STRING }, /* regex string */
637 { .required = true, .concat = false, .type = FR_TYPE_STRING }, /* broken out things to match */
638 { .required = false, .concat = true, .type = FR_TYPE_STRING }, /* flags */
639 XLAT_ARG_PARSER_TERMINATOR
640};
641
642
643/** Perform a regular expressions comparison between two operands
644 *
645 * @param[in] ctx to allocate resulting box in.
646 * @param[in] request The current request.
647 * @param[in] in list of item or items
648 * @param[in,out] preg Pointer to pre-compiled or runtime-compiled
649 * regular expression. In the case of runtime-compiled
650 * the pattern may be stolen by the `regex_sub_to_request`
651 * function as the original pattern is needed to resolve
652 * capture groups.
653 * The caller should only free the `regex_t *` if it
654 * compiled it, and the pointer has not been set to NULL
655 * when this function returns.
656 * @param[out] out Where result is written.
657 * @param[in] op the operation to perform.
658 * @return
659 * - -1 on failure.
660 * - 0 for "no match".
661 * - 1 for "match".
662 */
663static xlat_action_t xlat_regex_do_op(TALLOC_CTX *ctx, request_t *request, fr_value_box_list_t *in, regex_t **preg,
664 fr_dcursor_t *out, fr_token_t op)
665{
666 uint32_t subcaptures;
667 int ret = 0;
668
669 fr_regmatch_t *regmatch;
670 fr_value_box_t *dst;
671 fr_value_box_t *arg, *vb;
672 fr_sbuff_t *agg;
673 char const *subject;
674 size_t len;
675 fr_value_box_t safety = {};
676
677 FR_SBUFF_TALLOC_THREAD_LOCAL(&agg, 256, 8192);
678
679 arg = fr_value_box_list_head(in);
680 fr_assert(arg != NULL);
681 fr_assert(arg->type == FR_TYPE_GROUP);
682
683 subcaptures = regex_subcapture_count(*preg);
684 if (!subcaptures) subcaptures = REQUEST_MAX_REGEX + 1; /* +1 for %{0} (whole match) capture group */
685 MEM(regmatch = regex_match_data_alloc(NULL, subcaptures));
686
687 while ((vb = fr_value_box_list_pop_head(&arg->vb_group)) != NULL) {
688 if (vb->type == FR_TYPE_STRING) {
689 subject = vb->vb_strvalue;
690 len = vb->vb_length;
691 fr_value_box_safety_copy(&safety, vb);
692
693 } else {
694 fr_value_box_list_t list;
695
696 fr_value_box_list_init(&list);
697 fr_value_box_list_insert_head(&list, vb);
698 fr_value_box_mark_safe_for(&safety, FR_VALUE_BOX_SAFE_FOR_ANY);
699
700 vb = NULL;
701
702 /*
703 * Concatenate everything, and escape untrusted inputs.
704 */
705 if (fr_value_box_list_concat_as_string(&safety, agg, &list, NULL, 0, &regex_escape_rules,
706 FR_VALUE_BOX_LIST_FREE_BOX, FR_REGEX_SAFE_FOR, true) < 0) {
707 RPEDEBUG("Failed concatenating regular expression string");
708 talloc_free(regmatch);
709 return XLAT_ACTION_FAIL;
710 }
711
712 subject = fr_sbuff_start(agg);
713 len = fr_sbuff_used(agg);
714 }
715
716 /*
717 * Evaluate the expression
718 */
719 ret = regex_exec(*preg, subject, len, regmatch);
720 switch (ret) {
721 default:
722 RPEDEBUG("REGEX failed");
723 talloc_free(vb);
724 talloc_free(regmatch);
725 return XLAT_ACTION_FAIL;
726
727 case 0:
728 regex_sub_to_request(request, NULL, NULL, NULL); /* clear out old entries */
729 continue;
730
731 case 1:
732 regex_sub_to_request(request, preg, &regmatch, &safety);
733 talloc_free(vb);
734 goto done;
735
736 }
737
738 talloc_free(vb);
739 }
740
741done:
742 talloc_free(regmatch); /* free if not consumed */
743
744 MEM(dst = fr_value_box_alloc(ctx, FR_TYPE_BOOL, attr_expr_bool_enum));
745 dst->vb_bool = (ret == (op == T_OP_REG_EQ));
746
747 fr_dcursor_append(out, dst);
748
749 return XLAT_ACTION_DONE;
750}
751
752static xlat_action_t xlat_regex_resume(TALLOC_CTX *ctx, fr_dcursor_t *out,
753 xlat_ctx_t const *xctx,
754 request_t *request, fr_value_box_list_t *in)
755{
756 xlat_regex_inst_t const *inst = talloc_get_type_abort_const(xctx->inst, xlat_regex_inst_t);
757 xlat_regex_rctx_t *rctx = talloc_get_type_abort(xctx->rctx, xlat_regex_rctx_t);
758 ssize_t slen;
759 regex_t *preg = NULL;
760 fr_sbuff_t *agg;
761
762 FR_SBUFF_TALLOC_THREAD_LOCAL(&agg, 256, 8192);
763
764 /*
765 * If the expansions fails, then we fail the entire thing.
766 */
767 if (!XLAT_RESULT_SUCCESS(&rctx->last_result)) {
768 talloc_free(rctx);
769 return XLAT_ACTION_FAIL;
770 }
771
772 /*
773 * Because we expanded the RHS ourselves, the "concat"
774 * flag to the RHS argument is ignored. So we just
775 * concatenate it here. We escape the various untrusted inputs.
776 */
777 if (fr_value_box_list_concat_as_string(NULL, agg, &rctx->list, NULL, 0, &regex_escape_rules,
778 FR_VALUE_BOX_LIST_FREE_BOX, FR_REGEX_SAFE_FOR, true) < 0) {
779 RPEDEBUG("Failed concatenating regular expression string");
780 return XLAT_ACTION_FAIL;
781 }
782
783 fr_assert(inst->regex == NULL);
784
785 slen = regex_compile(rctx, &preg, fr_sbuff_start(agg), fr_sbuff_used(agg),
786 tmpl_regex_flags(inst->xlat->vpt), true, true); /* flags, allow subcaptures, at runtime */
787 if (slen <= 0) return XLAT_ACTION_FAIL;
788
789 return xlat_regex_do_op(ctx, request, in, &preg, out, inst->op);
790}
791
792static xlat_action_t xlat_regex_op(TALLOC_CTX *ctx, fr_dcursor_t *out,
793 xlat_ctx_t const *xctx,
794 request_t *request, fr_value_box_list_t *in,
795 fr_token_t op)
796{
797 xlat_regex_inst_t const *inst = talloc_get_type_abort_const(xctx->inst, xlat_regex_inst_t);
798 xlat_regex_rctx_t *rctx;
799 regex_t *preg;
800
801 /*
802 * Just run precompiled regexes.
803 */
804 if (inst->regex) {
805 preg = tmpl_regex(inst->xlat->vpt);
806
807 return xlat_regex_do_op(ctx, request, in, &preg, out, op);
808 }
809
810 MEM(rctx = talloc_zero(unlang_interpret_frame_talloc_ctx(request), xlat_regex_rctx_t));
811 fr_value_box_list_init(&rctx->list);
812
813 if (unlang_xlat_yield(request, xlat_regex_resume, NULL, 0, rctx) != XLAT_ACTION_YIELD) {
814 fail:
815 talloc_free(rctx);
816 return XLAT_ACTION_FAIL;
817 }
818
819 if (unlang_xlat_push(ctx, &rctx->last_result, &rctx->list,
820 request, tmpl_xlat(inst->xlat->vpt), UNLANG_SUB_FRAME) < 0) goto fail;
821
822 return XLAT_ACTION_PUSH_UNLANG;
823}
824
825#define XLAT_REGEX_FUNC(_name, _op) \
826static xlat_action_t xlat_func_ ## _name(TALLOC_CTX *ctx, fr_dcursor_t *out, \
827 xlat_ctx_t const *xctx, \
828 request_t *request, fr_value_box_list_t *in) \
829{ \
830 return xlat_regex_op(ctx, out, xctx, request, in, _op); \
831}
832
833XLAT_REGEX_FUNC(reg_eq, T_OP_REG_EQ)
834XLAT_REGEX_FUNC(reg_ne, T_OP_REG_NE)
835
836static xlat_action_t xlat_func_regex_search(TALLOC_CTX *ctx, fr_dcursor_t *out,
837 UNUSED xlat_ctx_t const *xctx,
838 request_t *request, fr_value_box_list_t *in)
839{
840 ssize_t slen;
841 regex_t *preg;
842 fr_value_box_t *regex;
843 xlat_action_t action;
844
845 RDEBUG("IN IS %pM", in);
846
847 regex = fr_value_box_list_pop_head(in);
848 fr_assert(regex);
849 fr_assert(regex->type == FR_TYPE_STRING);
850
851 slen = regex_compile(ctx, &preg, regex->vb_strvalue, regex->vb_length,
852 NULL, true, true); /* flags, allow subcaptures, at runtime */
853 if (slen <= 0) {
854 RPEDEBUG("Failed parsing regular expression %pV", regex);
855 talloc_free(regex);
856 return XLAT_ACTION_FAIL;
857 }
858
859 action = xlat_regex_do_op(ctx, request, in, &preg, out, T_OP_REG_EQ);
860 talloc_free(regex);
861 talloc_free(preg);
862 return action;
863}
864
871
872typedef struct {
873 TALLOC_CTX *ctx;
874 unlang_result_t last_result;
875 fr_value_box_t *box; //!< output value-box
876 int current;
877 fr_value_box_list_t list;
878} xlat_logical_rctx_t;
879
880static fr_slen_t xlat_expr_print_nary(fr_sbuff_t *out, xlat_exp_t const *node, void *instance, fr_sbuff_escape_rules_t const *e_rules)
881{
882 size_t at_in = fr_sbuff_used_total(out);
883 xlat_logical_inst_t *inst = instance;
884 xlat_exp_head_t *head;
885
886 FR_SBUFF_IN_CHAR_RETURN(out, '(');
887
888 /*
889 * We might get called before the node is instantiated.
890 */
891 if (!inst->argv) {
892 head = node->call.args;
893
894 fr_assert(head != NULL);
895
896 xlat_exp_foreach(head, child) {
897 xlat_print_node(out, head, child, e_rules, 0);
898
899 if (!xlat_exp_next(head, child)) break;
900
901 FR_SBUFF_IN_STRCPY_RETURN(out, fr_tokens[node->call.func->token]);
902 FR_SBUFF_IN_CHAR_RETURN(out, ' ');
903 }
904 } else {
905 int i;
906
907 for (i = 0; i < inst->argc; i++) {
908 xlat_print(out, inst->argv[i], e_rules);
909 if (i == (inst->argc - 1)) break;
910
911 FR_SBUFF_IN_CHAR_RETURN(out, ' ');
912 FR_SBUFF_IN_STRCPY_RETURN(out, fr_tokens[node->call.func->token]);
913 if ((i + 1) < inst->argc) FR_SBUFF_IN_CHAR_RETURN(out, ' ');
914 }
915 }
916
917 FR_SBUFF_IN_CHAR_RETURN(out, ')');
918
919 return fr_sbuff_used_total(out) - at_in;
920}
921
922/*
923 * This returns "false" for "ignore this argument"
924 *
925 * result is "false" for "delete this argument"
926 * result is "true" for "return this argument".
927 */
928static bool xlat_node_matches_bool(bool *result, xlat_exp_t *parent, xlat_exp_head_t *head, bool sense)
929{
930 fr_value_box_t *box;
931 xlat_exp_t *node;
932
933 if (!head->flags.pure) return false;
934
935 node = xlat_exp_head(head);
936 if (!node || xlat_exp_next(head, node)) {
937 return false;
938 }
939
940 if (node->type == XLAT_BOX) {
941 box = &node->data;
942 goto check;
943 }
944
945 if (node->type != XLAT_TMPL) {
946 return false;
947 }
948
949 if (!tmpl_is_data(node->vpt)) {
950 return false;
951 }
952
953 box = tmpl_value(node->vpt);
954
955check:
956 /*
957 * On "true", replace the entire logical operation with the value-box.
958 *
959 * On "false", omit this argument, and go to the next one.
960 */
961 *result = (fr_value_box_is_truthy(box) == sense);
962
963 if (!*result) return true;
964
965 xlat_instance_unregister_func(parent);
966
967 xlat_exp_set_type(parent, XLAT_BOX);
968 fr_value_box_copy(parent, &parent->data, box);
969
970 return true;
971}
972
973/** Undo work which shouldn't have been done. :(
974 *
975 */
976static void xlat_ungroup(xlat_exp_head_t *head)
977{
978 xlat_exp_t *group, *node;
979
980 group = xlat_exp_head(head);
981 if (!group || xlat_exp_next(head, group)) return;
982
983 if (group->type != XLAT_GROUP) return;
984
985 node = xlat_exp_head(group->group);
986 if (!node || xlat_exp_next(group->group, node)) return;
987
988 (void) fr_dlist_remove(&head->dlist, group);
989 (void) fr_dlist_remove(&group->group->dlist, node);
990 (void) talloc_steal(head, node);
991
992 talloc_free(group);
993
994 fr_dlist_insert_tail(&head->dlist, node);
995 head->flags = node->flags;
996}
997
998/** If any argument resolves to inst->stop_on_match, the entire thing is a bool of inst->stop_on_match.
999 *
1000 * If any argument resolves to !inst->stop_on_match, it is removed.
1001 */
1002static int xlat_expr_logical_purify(xlat_exp_t *node, void *instance, request_t *request)
1003{
1004 int i, j;
1005 int deleted = 0;
1006 bool result;
1007 xlat_logical_inst_t *inst = talloc_get_type_abort(instance, xlat_logical_inst_t);
1008 xlat_exp_head_t *group;
1009
1010 fr_assert(node->type == XLAT_FUNC);
1011
1012 /*
1013 * Don't check the last argument. If everything else gets deleted,
1014 * then we just return the last argument.
1015 */
1016 for (i = 0; i < inst->argc; i++) {
1017 /*
1018 * The argument is pure, so we purify it before
1019 * doing any other checks.
1020 */
1021 if (inst->argv[i]->flags.can_purify) {
1022 if (xlat_purify_list(inst->argv[i], request) < 0) return -1;
1023
1024 /*
1025 * xlat_purify_list expects that its outputs will be arguments to functions, so
1026 * they're grouped. We con't need that, so we ungroup them here.
1027 */
1028 xlat_ungroup(inst->argv[i]);
1029 }
1030
1031 /*
1032 * This returns "false" for "ignore".
1033 *
1034 * result is "false" for "delete this argument"
1035 * result is "true" for "return this argument".
1036 */
1037 if (!xlat_node_matches_bool(&result, node, inst->argv[i], inst->stop_on_match)) continue;
1038
1039 /*
1040 * 0 && EXPR --> 0.
1041 * 1 || EXPR --> 1
1042 *
1043 * Parent is now an XLAT_BOX, so we're done.
1044 */
1045 if (result) return 0;
1046
1047 /*
1048 * We're at the last argument. If we've deleted everything else, then just leave the
1049 * last argument alone. Otherwise some arguments remain, so we can delete the last one.
1050 */
1051 if (((i + 1) == inst->argc) && (deleted == i)) break;
1052
1053 TALLOC_FREE(inst->argv[i]);
1054 deleted++;
1055 }
1056
1057 if (!deleted) return 0;
1058
1059 /*
1060 * Pack the array. We insert at i, and read from j. We don't need to read the deleted entries,
1061 * as they all MUST be NULL.
1062 */
1063 i = 0;
1064 j = -1;
1065 while (i < (inst->argc - deleted)) {
1066 if (inst->argv[i]) {
1067 i++;
1068 continue;
1069 }
1070
1071 /*
1072 * Start searching from the next entry, OR start searching from where we left off before.
1073 */
1074 if (j < 0) j = i + 1;
1075
1076 /*
1077 * Find the first non-NULL entry, and insert it in argv[i]. We search here until the end
1078 * of the array, because we may have deleted entries from the start of the array.
1079 */
1080 while (j < inst->argc) {
1081 if (inst->argv[j]) break;
1082 j++;
1083 }
1084
1085 /*
1086 * Move the entry down, and clear out the tail end of the array.
1087 */
1088 inst->argv[i++] = inst->argv[j];
1089 inst->argv[j++] = NULL;
1090 }
1091
1092 inst->argc -= deleted;
1093
1094 if (inst->argc > 1) return 0;
1095
1096 /*
1097 * Only one argument left. We can hoist the child into ourselves, and omit the logical operation.
1098 */
1099 group = inst->argv[0];
1100 fr_assert(group != NULL);
1101 talloc_steal(node, group);
1102
1103 xlat_instance_unregister_func(node);
1104 xlat_exp_set_type(node, XLAT_GROUP);
1105
1106 /* re-print, with purified nodes removed */
1107 {
1108 char *name;
1109
1110 MEM(xlat_aprint(node, &name, group, NULL) >= 0);
1111 xlat_exp_set_name_shallow(node, name);
1112 }
1113
1114 talloc_free(node->group);
1115 node->group = group;
1116 node->flags = group->flags;
1117
1118 return 0;
1119}
1120
1121/** Process one argument of a logical operation.
1122 *
1123 * If we see a list in a truthy context, then we DON'T expand the list. Instead, we return a bool which
1124 * indicates if the list was empty (or not). This prevents us from returning a whole mess of value-boxes
1125 * when the user just wanted to see if the list existed.
1126 *
1127 * Otherwise, we expand the xlat, and continue.
1128 */
1129static xlat_action_t xlat_logical_process_arg(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
1130 xlat_ctx_t const *xctx,
1131 request_t *request, UNUSED fr_value_box_list_t *in)
1132{
1133 xlat_logical_inst_t const *inst = talloc_get_type_abort_const(xctx->inst, xlat_logical_inst_t);
1134 xlat_logical_rctx_t *rctx = talloc_get_type_abort(xctx->rctx, xlat_logical_rctx_t);
1135
1136 /*
1137 * Push the xlat onto the stack for expansion.
1138 */
1139 if (unlang_xlat_yield(request, inst->callback, NULL, 0, rctx) != XLAT_ACTION_YIELD) {
1140 fail:
1141 talloc_free(rctx->box);
1142 talloc_free(rctx);
1143 return XLAT_ACTION_FAIL;
1144 }
1145
1146 if (unlang_xlat_push(rctx, &rctx->last_result, &rctx->list,
1147 request, inst->argv[rctx->current], UNLANG_SUB_FRAME) < 0) goto fail;
1148
1149 return XLAT_ACTION_PUSH_UNLANG;
1150}
1151
1152/** See if the input is truthy or not.
1153 *
1154 * @param[in] rctx our ctx
1155 * @param[in] in list of value-boxes to check
1156 * @return
1157 * - false if there are no truthy values. The last box is copied to the rctx.
1158 * This is to allow us to return default values which may not be truthy,
1159 * e.g. %{&Counter || 0} or %{&Framed-IP-Address || 0.0.0.0}.
1160 * If we don't copy the last box to the rctx, the expression just returns NULL
1161 * which is never useful...
1162 * - true if we find a truthy value. The first truthy box is copied to the rctx.
1163 *
1164 * Empty lists are not truthy.
1165 */
1166static bool xlat_logical_or(xlat_logical_rctx_t *rctx, fr_value_box_list_t const *in)
1167{
1168 fr_value_box_t *last = NULL;
1169 bool ret = false;
1170
1171 /*
1172 * Empty lists are !truthy.
1173 */
1174 if (!fr_value_box_list_num_elements(in)) return false;
1175
1176 /*
1177 * Loop over the input list. We CANNOT do groups.
1178 */
1179 fr_value_box_list_foreach(in, box) {
1180 fr_assert(fr_type_is_leaf(box->type) || fr_type_is_null(box->type));
1181
1182 last = box;
1183
1184 /*
1185 * Remember the last box we found.
1186 *
1187 * If it's truthy, then we stop immediately.
1188 */
1189 if (fr_value_box_is_truthy(box)) {
1190 ret = true;
1191 break;
1192 }
1193 }
1194
1195 if (!rctx->box) {
1196 MEM(rctx->box = fr_value_box_alloc_null(rctx->ctx));
1197 } else {
1198 fr_value_box_clear(rctx->box);
1199 }
1200 if (last) fr_value_box_copy(rctx->box, rctx->box, last);
1201
1202 return ret;
1203}
1204
1205/*
1206 * We've evaluated an expression. Let's see if we need to continue with ||
1207 */
1208static xlat_action_t xlat_logical_or_resume(TALLOC_CTX *ctx, fr_dcursor_t *out,
1209 xlat_ctx_t const *xctx,
1210 request_t *request, fr_value_box_list_t *in)
1211{
1212 xlat_logical_inst_t const *inst = talloc_get_type_abort_const(xctx->inst, xlat_logical_inst_t);
1213 xlat_logical_rctx_t *rctx = talloc_get_type_abort(xctx->rctx, xlat_logical_rctx_t);
1214 bool match;
1215
1216 /*
1217 * If the expansions fails, then we fail the entire thing.
1218 */
1219 if (!XLAT_RESULT_SUCCESS(&rctx->last_result)) {
1220 talloc_free(rctx->box);
1221 talloc_free(rctx);
1222 return XLAT_ACTION_FAIL;
1223 }
1224
1225 /*
1226 * Recursively check groups. i.e. we effectively flatten each list.
1227 *
1228 * (a, b, c) || (d, e, f) == a || b || c || d || e || f
1229 */
1230 match = xlat_logical_or(rctx, &rctx->list);
1231 if (match) goto done;
1232
1233 fr_value_box_list_talloc_free(&rctx->list);
1234
1235 rctx->current++;
1236
1237 /*
1238 * Nothing to expand, return the final value we saw.
1239 */
1240 if (rctx->current >= inst->argc) {
1241 done:
1242 /*
1243 * Otherwise we stop on failure, with the boolean
1244 * we just updated.
1245 */
1246 if (rctx->box) fr_dcursor_append(out, rctx->box);
1247
1248 talloc_free(rctx);
1249 return XLAT_ACTION_DONE;
1250 }
1251
1252 return xlat_logical_process_arg(ctx, out, xctx, request, in);
1253}
1254
1255/** See if the input is truthy or not.
1256 *
1257 * @param[in] rctx our ctx
1258 * @param[in] in list of value-boxes to check
1259 * @return
1260 * - false on failure
1261 * - true for match, with dst updated to contain the relevant box.
1262 *
1263 * Empty lists are not truthy.
1264 */
1265static bool xlat_logical_and(xlat_logical_rctx_t *rctx, fr_value_box_list_t const *in)
1266{
1267 fr_value_box_t *found = NULL;
1268
1269 /*
1270 * Empty lists are !truthy.
1271 */
1272 if (!fr_value_box_list_num_elements(in)) return false;
1273
1274 /*
1275 * Loop over the input list. We CANNOT do groups.
1276 */
1277 fr_value_box_list_foreach(in, box) {
1278 fr_assert(fr_type_is_leaf(box->type));
1279
1280 /*
1281 * Remember the last box we found.
1282 *
1283 * If it's truthy, then we keep going either
1284 * until the end, or until we get a "false".
1285 */
1286 if (fr_value_box_is_truthy(box)) {
1287 found = box;
1288 continue;
1289 }
1290
1291 /*
1292 * Stop on the first "false"
1293 */
1294 return false;
1295 }
1296
1297 if (!found) return false;
1298
1299 if (!rctx->box) {
1300 MEM(rctx->box = fr_value_box_alloc_null(rctx));
1301 } else {
1302 fr_value_box_clear(rctx->box);
1303 }
1304 fr_value_box_copy(rctx->box, rctx->box, found);
1305
1306 return true;
1307}
1308
1309/*
1310 * We've evaluated an expression. Let's see if we need to continue with &&
1311 */
1312static xlat_action_t xlat_logical_and_resume(TALLOC_CTX *ctx, fr_dcursor_t *out,
1313 xlat_ctx_t const *xctx,
1314 request_t *request, fr_value_box_list_t *in)
1315{
1316 xlat_logical_inst_t const *inst = talloc_get_type_abort_const(xctx->inst, xlat_logical_inst_t);
1317 xlat_logical_rctx_t *rctx = talloc_get_type_abort(xctx->rctx, xlat_logical_rctx_t);
1318 bool match;
1319
1320 /*
1321 * If the expansions fails, then we fail the entire thing.
1322 */
1323 if (!XLAT_RESULT_SUCCESS(&rctx->last_result)) {
1324 talloc_free(rctx->box);
1325 talloc_free(rctx);
1326 return XLAT_ACTION_FAIL;
1327 }
1328
1329 /*
1330 * Recursively check groups. i.e. we effectively flatten each list.
1331 *
1332 * (a, b, c) && (d, e, f) == a && b && c && d && e && f
1333 */
1334 match = xlat_logical_and(rctx, &rctx->list);
1335 if (!match) return XLAT_ACTION_DONE;
1336
1337 fr_value_box_list_talloc_free(&rctx->list);
1338
1339 rctx->current++;
1340
1341 /*
1342 * Nothing to expand, return the final value we saw.
1343 */
1344 if (rctx->current >= inst->argc) {
1345 /*
1346 * Otherwise we stop on failure, with the boolean
1347 * we just updated.
1348 */
1349 fr_assert(rctx->box != NULL);
1350 fr_dcursor_append(out, rctx->box);
1351
1352 talloc_free(rctx);
1353 return XLAT_ACTION_DONE;
1354 }
1355
1356 return xlat_logical_process_arg(ctx, out, xctx, request, in);
1357}
1358
1359/*
1360 * Each argument is it's own head, because we do NOT always want
1361 * to go to the next argument.
1362 */
1363static int xlat_instantiate_logical(xlat_inst_ctx_t const *xctx)
1364{
1365 xlat_logical_inst_t *inst = talloc_get_type_abort(xctx->inst, xlat_logical_inst_t);
1366
1367 inst->argc = xlat_flatten_to_argv(inst, &inst->argv, xctx->ex->call.args);
1368 if (xctx->ex->call.func->token == T_LOR) {
1369 inst->callback = xlat_logical_or_resume;
1370 inst->stop_on_match = true;
1371 } else {
1372 inst->callback = xlat_logical_and_resume;
1373 inst->stop_on_match = false;
1374 }
1375
1376 return 0;
1377}
1378
1379
1380/** Process logical &&, ||
1381 *
1382 */
1383static xlat_action_t xlat_func_logical(TALLOC_CTX *ctx, fr_dcursor_t *out,
1384 xlat_ctx_t const *xctx,
1385 request_t *request, fr_value_box_list_t *in)
1386{
1387 xlat_logical_rctx_t *rctx;
1388 xlat_logical_inst_t const *inst = talloc_get_type_abort_const(xctx->inst, xlat_logical_inst_t);
1389
1390 MEM(rctx = talloc_zero(unlang_interpret_frame_talloc_ctx(request), xlat_logical_rctx_t));
1391 rctx->ctx = ctx;
1392 rctx->current = 0;
1393
1394 if (inst->stop_on_match) {
1395 rctx->box = NULL;
1396 } else {
1397 MEM(rctx->box = fr_value_box_alloc(ctx, FR_TYPE_BOOL, attr_expr_bool_enum));
1398 rctx->box->vb_bool = true;
1399 }
1400 fr_value_box_list_init(&rctx->list);
1401
1402 (UNCONST(xlat_ctx_t *, xctx))->rctx = rctx; /* ensure it's there before a resume! */
1403
1404 return xlat_logical_process_arg(ctx, out, xctx, request, in);
1405}
1406
1407
1408static xlat_arg_parser_t const unary_op_xlat_args[] = {
1409 { .required = true, .single = true, .concat = true },
1410 XLAT_ARG_PARSER_TERMINATOR
1411};
1412
1413static xlat_action_t xlat_func_unary_op(TALLOC_CTX *ctx, fr_dcursor_t *out,
1414 UNUSED xlat_ctx_t const *xctx,
1415 request_t *request, fr_value_box_list_t *in, fr_token_t op)
1416{
1417 int rcode;
1418 fr_value_box_t *dst, *group, *vb;
1419
1420 /*
1421 * We do some basic type checks here.
1422 */
1423 group = fr_value_box_list_head(in);
1424 vb = fr_value_box_list_head(&group->vb_group);
1425
1426 /*
1427 * -NULL is an error
1428 * ~NULL is an error
1429 * !NULL is handled by xlat_func_unary_not
1430 */
1431 if (!vb) {
1432 fr_strerror_printf("Input is empty");
1433 return XLAT_ACTION_FAIL;
1434 }
1435
1436 if (!fr_type_is_leaf(vb->type) || fr_type_is_variable_size(vb->type)) {
1437 REDEBUG("Cannot perform operation on data type %s", fr_type_to_str(vb->type));
1438 return XLAT_ACTION_FAIL;
1439 }
1440
1441 MEM(dst = fr_value_box_alloc_null(ctx));
1442
1443 /*
1444 * We rely on this function to do the remainder of the type checking.
1445 */
1446 rcode = fr_value_calc_unary_op(dst, dst, op, vb);
1447 if ((rcode < 0) || fr_type_is_null(dst->type)) {
1448 talloc_free(dst);
1449 return XLAT_ACTION_FAIL;
1450 }
1451
1452 fr_dcursor_append(out, dst);
1453 return XLAT_ACTION_DONE;
1454}
1455
1456
1457static xlat_action_t xlat_func_unary_not(TALLOC_CTX *ctx, fr_dcursor_t *out,
1458 UNUSED xlat_ctx_t const *xctx,
1459 UNUSED request_t *request, fr_value_box_list_t *in)
1460{
1461 fr_value_box_t *dst, *group, *vb;
1462
1463 group = fr_value_box_list_head(in);
1464 vb = fr_value_box_list_head(&group->vb_group);
1465
1466 /*
1467 * Don't call calc_unary_op(), because we want the enum names.
1468 */
1469 MEM(dst = fr_value_box_alloc(ctx, FR_TYPE_BOOL, attr_expr_bool_enum));
1470
1471 /*
1472 * !NULL = true
1473 */
1474 if (!vb) {
1475 dst->vb_bool = true;
1476 } else {
1477 dst->vb_bool = !fr_value_box_is_truthy(vb);
1478 }
1479
1480 fr_dcursor_append(out, dst);
1481 return XLAT_ACTION_DONE;
1482}
1483
1484static xlat_action_t xlat_func_unary_minus(TALLOC_CTX *ctx, fr_dcursor_t *out,
1485 xlat_ctx_t const *xctx,
1486 request_t *request, fr_value_box_list_t *in)
1487{
1488 return xlat_func_unary_op(ctx, out, xctx, request, in, T_SUB);
1489}
1490
1491static xlat_action_t xlat_func_unary_complement(TALLOC_CTX *ctx, fr_dcursor_t *out,
1492 xlat_ctx_t const *xctx,
1493 request_t *request, fr_value_box_list_t *in)
1494{
1495 return xlat_func_unary_op(ctx, out, xctx, request, in, T_COMPLEMENT);
1496}
1497
1498static xlat_arg_parser_t const xlat_func_expr_rcode_arg[] = {
1499 { .concat = true, .type = FR_TYPE_STRING },
1500 XLAT_ARG_PARSER_TERMINATOR
1501};
1502
1503/** Holds the result of pre-parsing the rcode on startup
1504 */
1505typedef struct {
1506 rlm_rcode_t rcode; //!< The preparsed rcode.
1507} xlat_rcode_inst_t;
1508
1509/** Convert static expr_rcode arguments into rcodes
1510 *
1511 * This saves doing the lookup at runtime, which given how frequently this xlat is used
1512 * could get quite expensive.
1513 */
1514static int xlat_instantiate_expr_rcode(xlat_inst_ctx_t const *xctx)
1515{
1516 xlat_rcode_inst_t *inst = talloc_get_type_abort(xctx->inst, xlat_rcode_inst_t);
1517 xlat_exp_t *arg;
1518 xlat_exp_t *rcode_arg;
1519 fr_value_box_t *rcode;
1520
1521 /*
1522 * If it's literal data, then we can pre-resolve it to
1523 * a rcode now, and skip that at runtime.
1524 */
1525 arg = xlat_exp_head(xctx->ex->call.args);
1526 fr_assert(arg->type == XLAT_GROUP);
1527
1528 /*
1529 * We can only pre-parse if this if the value is
1530 * in a single box...
1531 */
1532 if (fr_dlist_num_elements(&arg->group->dlist) != 1) return 0;
1533 rcode_arg = xlat_exp_head(arg->group);
1534
1535 /*
1536 * We can only pre-parse is this is a static value.
1537 */
1538 if (rcode_arg->type != XLAT_BOX) return 0;
1539
1540 rcode = &rcode_arg->data;
1541
1542 switch (rcode->type) {
1543 case FR_TYPE_STRING:
1544 inst->rcode = fr_table_value_by_str(rcode_table, rcode->vb_strvalue, RLM_MODULE_NOT_SET);
1545 if (inst->rcode == RLM_MODULE_NOT_SET) {
1546 unknown:
1547 ERROR("Unknown rcode '%pV'", rcode);
1548 return -1;
1549 }
1550 break;
1551
1552 case FR_TYPE_INT8:
1553 case FR_TYPE_INT16:
1554 case FR_TYPE_INT32:
1555 case FR_TYPE_INT64:
1556 case FR_TYPE_UINT16:
1557 case FR_TYPE_UINT32:
1558 case FR_TYPE_UINT64:
1559 case FR_TYPE_SIZE:
1560 if (fr_value_box_cast_in_place(rcode_arg, rcode, FR_TYPE_UINT8, NULL) < 0) {
1561 invalid:
1562 ERROR("Invalid value for rcode '%pV'", rcode);
1563 return -1;
1564 }
1565 FALL_THROUGH;
1566
1567 case FR_TYPE_UINT8:
1568 if (rcode->vb_uint8 >= RLM_MODULE_NUMCODES) goto invalid;
1569 inst->rcode = rcode->vb_uint8;
1570 break;
1571
1572 default:
1573 goto unknown;
1574 }
1575
1576 /*
1577 * No point in creating useless boxes at runtime,
1578 * nuke the argument now.
1579 */
1580 (void) fr_dlist_remove(&xctx->ex->call.args->dlist, arg);
1581 talloc_free(arg);
1582
1583 return 0;
1584}
1585
1586static fr_slen_t xlat_expr_print_rcode(fr_sbuff_t *out, xlat_exp_t const *node, void *instance, UNUSED fr_sbuff_escape_rules_t const *e_rules)
1587{
1588 size_t at_in = fr_sbuff_used_total(out);
1589 xlat_rcode_inst_t *inst = instance;
1590
1591 FR_SBUFF_IN_STRCPY_LITERAL_RETURN(out, "%expr.rcode('");
1592 if (xlat_exp_head(node->call.args)) {
1593 ssize_t slen;
1594
1595 xlat_exp_foreach(node->call.args, child) {
1596 slen = xlat_print_node(out, node->call.args, child, NULL, 0);
1597 if (slen < 0) return slen;
1598 }
1599 } else {
1600 FR_SBUFF_IN_STRCPY_RETURN(out, fr_table_str_by_value(rcode_table, inst->rcode, "<INVALID>"));
1601 }
1602 FR_SBUFF_IN_STRCPY_LITERAL_RETURN(out, "')");
1603
1604 return fr_sbuff_used_total(out) - at_in;
1605}
1606
1607/** Match the passed rcode against request->rcode
1608 *
1609 * Example:
1610@verbatim
1611%expr.rcode('handled') == true
1612
1613# ...or how it's used normally used
1614if (handled) {
1615 ...
1616}
1617@endverbatim
1618 *
1619 * @ingroup xlat_functions
1620 */
1621static xlat_action_t xlat_func_expr_rcode(TALLOC_CTX *ctx, fr_dcursor_t *out,
1622 xlat_ctx_t const *xctx,
1623 request_t *request, fr_value_box_list_t *args)
1624{
1625 xlat_rcode_inst_t const *inst = talloc_get_type_abort_const(xctx->inst, xlat_rcode_inst_t);
1626 fr_value_box_t *arg_rcode;
1627 rlm_rcode_t rcode;
1628 fr_value_box_t *vb;
1629
1630 /*
1631 * If we have zero args, it's because the instantiation
1632 * function consumed them. om nom nom.
1633 */
1634 if (fr_value_box_list_num_elements(args) == 0) {
1635 fr_assert(inst->rcode != RLM_MODULE_NOT_SET);
1636 rcode = inst->rcode;
1637 } else {
1638 XLAT_ARGS(args, &arg_rcode);
1639 rcode = fr_table_value_by_str(rcode_table, arg_rcode->vb_strvalue, RLM_MODULE_NOT_SET);
1640 if (rcode == RLM_MODULE_NOT_SET) {
1641 REDEBUG("Invalid rcode '%pV'", arg_rcode);
1642 return XLAT_ACTION_FAIL;
1643 }
1644 }
1645
1646 RDEBUG3("Request rcode is '%s'",
1647 fr_table_str_by_value(rcode_table, request->rcode, "<INVALID>"));
1648
1649 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_BOOL, attr_expr_bool_enum));
1650 fr_dcursor_append(out, vb);
1651 vb->vb_bool = (request->rcode == rcode);
1652
1653 return XLAT_ACTION_DONE;
1654}
1655
1656/** Takes no arguments
1657 */
1658static xlat_arg_parser_t const xlat_func_rcode_arg[] = {
1659 XLAT_ARG_PARSER_TERMINATOR, /* Coverity gets tripped up by only having a single entry here */
1660 XLAT_ARG_PARSER_TERMINATOR
1661};
1662
1663/** Return the current rcode as a string
1664 *
1665 * Example:
1666@verbatim
1667"%rcode()" == "handled"
1668@endverbatim
1669 *
1670 * @ingroup xlat_functions
1671 */
1672static xlat_action_t xlat_func_rcode(TALLOC_CTX *ctx, fr_dcursor_t *out,
1673 UNUSED xlat_ctx_t const *xctx,
1674 request_t *request, UNUSED fr_value_box_list_t *args)
1675{
1676 fr_value_box_t *vb;
1677
1678 /*
1679 * FIXME - This should really be an enum
1680 */
1681 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_STRING, NULL));
1682 if (fr_value_box_strdup(vb, vb, NULL, fr_table_str_by_value(rcode_table, request->rcode, "<INVALID>"), false) < 0) {
1683 talloc_free(vb);
1684 return XLAT_ACTION_FAIL;
1685 }
1686 fr_dcursor_append(out, vb);
1687
1688 return XLAT_ACTION_DONE;
1689}
1690
1691typedef struct {
1692 tmpl_t const *vpt; //!< the attribute reference
1693} xlat_exists_inst_t;
1694
1699
1700/*
1701 * We just print the node as-is.
1702 */
1703static fr_slen_t xlat_expr_print_exists(fr_sbuff_t *out, xlat_exp_t const *node, void *instance, fr_sbuff_escape_rules_t const *e_rules)
1704{
1705 size_t at_in = fr_sbuff_used_total(out);
1706 xlat_exists_inst_t *inst = instance;
1707
1708 if (inst->vpt) {
1709 FR_SBUFF_IN_STRCPY_RETURN(out, inst->vpt->name);
1710 } else {
1711 xlat_print_node(out, node->call.args, xlat_exp_head(node->call.args), e_rules, 0);
1712 }
1713
1714 return fr_sbuff_used_total(out) - at_in;
1715}
1716
1717/*
1718 * Don't expand the argument if it's already an attribute reference.
1719 */
1720static int xlat_instantiate_exists(xlat_inst_ctx_t const *xctx)
1721{
1722 xlat_exists_inst_t *inst = talloc_get_type_abort(xctx->inst, xlat_exists_inst_t);
1723 xlat_exp_t *arg, *node;
1724
1725 arg = xlat_exp_head(xctx->ex->call.args);
1726
1727 fr_assert(arg->type == XLAT_GROUP);
1728 node = xlat_exp_head(arg->group);
1729
1730 /*
1731 * @todo - add an escape callback to this xlat
1732 * registration, so that it can take untrusted inputs.
1733 */
1734 if ((node->type != XLAT_TMPL) || !tmpl_contains_attr(node->vpt)) {
1735 fr_strerror_const("The %exists() function can only be used internally");
1736 return -1;
1737 }
1738
1739 inst->vpt = talloc_steal(inst, node->vpt);
1740
1741 /*
1742 * Free the input arguments so that they don't get expanded.
1743 */
1744 while ((arg = fr_dlist_pop_head(&xctx->ex->call.args->dlist)) != NULL) {
1745 talloc_free(arg);
1746 }
1747
1748 return 0;
1749}
1750
1751static xlat_action_t xlat_attr_exists(TALLOC_CTX *ctx, fr_dcursor_t *out,
1752 request_t *request, tmpl_t const *vpt, bool do_free)
1753{
1754 fr_pair_t *vp;
1755 fr_value_box_t *dst;
1756 fr_dcursor_t cursor;
1757 tmpl_dcursor_ctx_t cc;
1758
1759 MEM(dst = fr_value_box_alloc(ctx, FR_TYPE_BOOL, attr_expr_bool_enum));
1760
1761 vp = tmpl_dcursor_init(NULL, NULL, &cc, &cursor, request, vpt);
1762 dst->vb_bool = (vp != NULL);
1763
1764 if (do_free) talloc_const_free(vpt);
1765 tmpl_dcursor_clear(&cc);
1766 fr_dcursor_append(out, dst);
1767 return XLAT_ACTION_DONE;
1768}
1769
1770/** See if a named attribute exists
1771 *
1772 * Example:
1773@verbatim
1774"%{exists:&Foo}" == true
1775@endverbatim
1776 *
1777 * @ingroup xlat_functions
1778 */
1779static xlat_action_t xlat_func_exists(TALLOC_CTX *ctx, fr_dcursor_t *out,
1780 xlat_ctx_t const *xctx,
1781 request_t *request, UNUSED fr_value_box_list_t *in)
1782{
1783 xlat_exists_inst_t const *inst = talloc_get_type_abort_const(xctx->inst, xlat_exists_inst_t);
1784
1785 /*
1786 * We return "true" if the attribute exists. Otherwise we return "false".
1787 */
1788 fr_assert(inst->vpt);
1789
1790 return xlat_attr_exists(ctx, out, request, inst->vpt, false);
1791}
1792
1793#undef XLAT_REGISTER_BINARY_OP
1794#define XLAT_REGISTER_BINARY_OP(_op, _name) \
1795do { \
1796 if (unlikely((xlat = xlat_func_register(NULL, "op_" STRINGIFY(_name), xlat_func_op_ ## _name, FR_TYPE_VOID)) == NULL)) return -1; \
1797 xlat_func_args_set(xlat, binary_op_xlat_args); \
1798 xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE | XLAT_FUNC_FLAG_INTERNAL); \
1799 xlat_func_print_set(xlat, xlat_expr_print_binary); \
1800 xlat->token = _op; \
1801} while (0)
1802
1803#undef XLAT_REGISTER_BINARY_CMP
1804#define XLAT_REGISTER_BINARY_CMP(_op, _name) \
1805do { \
1806 if (unlikely((xlat = xlat_func_register(NULL, "cmp_" STRINGIFY(_name), xlat_func_cmp_ ## _name, FR_TYPE_BOOL)) == NULL)) return -1; \
1807 xlat_func_args_set(xlat, binary_cmp_xlat_args); \
1808 xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE | XLAT_FUNC_FLAG_INTERNAL); \
1809 xlat_func_print_set(xlat, xlat_expr_print_binary); \
1810 xlat_func_resolve_set(xlat, xlat_expr_resolve_binary); \
1811 xlat->token = _op; \
1812} while (0)
1813
1814#undef XLAT_REGISTER_NARY_OP
1815#define XLAT_REGISTER_NARY_OP(_op, _name, _func_name) \
1816do { \
1817 if (unlikely((xlat = xlat_func_register(NULL, STRINGIFY(_name), xlat_func_ ## _func_name, FR_TYPE_VOID)) == NULL)) return -1; \
1818 xlat_func_instantiate_set(xlat, xlat_instantiate_ ## _func_name, xlat_ ## _func_name ## _inst_t, NULL, NULL); \
1819 xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE | XLAT_FUNC_FLAG_INTERNAL); \
1820 xlat_func_print_set(xlat, xlat_expr_print_nary); \
1821 xlat_purify_func_set(xlat, xlat_expr_logical_purify); \
1822 xlat->token = _op; \
1823} while (0)
1824
1825#undef XLAT_REGISTER_REGEX_OP
1826#define XLAT_REGISTER_REGEX_OP(_op, _name) \
1827do { \
1828 if (unlikely((xlat = xlat_func_register(NULL, STRINGIFY(_name), xlat_func_ ## _name, FR_TYPE_BOOL)) == NULL)) return -1; \
1829 xlat_func_args_set(xlat, regex_op_xlat_args); \
1830 xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE | XLAT_FUNC_FLAG_INTERNAL); \
1831 xlat_func_instantiate_set(xlat, xlat_instantiate_regex, xlat_regex_inst_t, NULL, NULL); \
1832 xlat_func_print_set(xlat, xlat_expr_print_regex); \
1833 xlat->token = _op; \
1834} while (0)
1835
1836#define XLAT_REGISTER_BOOL(_xlat, _func, _arg, _ret_type) \
1837do { \
1838 if (unlikely((xlat = xlat_func_register(NULL, _xlat, _func, _ret_type)) == NULL)) return -1; \
1839 xlat_func_args_set(xlat, _arg); \
1840 xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_INTERNAL); \
1841} while (0)
1842
1843#define XLAT_REGISTER_UNARY(_op, _xlat, _func) \
1844do { \
1845 if (unlikely((xlat = xlat_func_register(NULL, _xlat, _func, FR_TYPE_VOID)) == NULL)) return -1; \
1846 xlat_func_args_set(xlat, unary_op_xlat_args); \
1847 xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE | XLAT_FUNC_FLAG_INTERNAL); \
1848 xlat_func_print_set(xlat, xlat_expr_print_unary); \
1849 xlat->token = _op; \
1850} while (0)
1851
1852int xlat_register_expressions(void)
1853{
1854 xlat_t *xlat;
1855
1856 XLAT_REGISTER_BINARY_OP(T_ADD, add);
1857 XLAT_REGISTER_BINARY_OP(T_SUB, sub);
1858 XLAT_REGISTER_BINARY_OP(T_MUL, mul);
1859 XLAT_REGISTER_BINARY_OP(T_DIV, div);
1860 XLAT_REGISTER_BINARY_OP(T_MOD, mod);
1861 XLAT_REGISTER_BINARY_OP(T_AND, and);
1862 XLAT_REGISTER_BINARY_OP(T_OR, or);
1863 XLAT_REGISTER_BINARY_OP(T_XOR, xor);
1864 XLAT_REGISTER_BINARY_OP(T_RSHIFT, rshift);
1865 XLAT_REGISTER_BINARY_OP(T_LSHIFT, lshift);
1866
1867 XLAT_REGISTER_BINARY_CMP(T_OP_CMP_EQ, eq);
1868 XLAT_REGISTER_BINARY_CMP(T_OP_NE, ne);
1869 XLAT_REGISTER_BINARY_CMP(T_OP_LT, lt);
1870 XLAT_REGISTER_BINARY_CMP(T_OP_LE, le);
1871 XLAT_REGISTER_BINARY_CMP(T_OP_GT, gt);
1872 XLAT_REGISTER_BINARY_CMP(T_OP_GE, ge);
1873 XLAT_REGISTER_BINARY_CMP(T_OP_CMP_EQ_TYPE, eq_type);
1874 XLAT_REGISTER_BINARY_CMP(T_OP_CMP_NE_TYPE, ne_type);
1875
1876 XLAT_REGISTER_REGEX_OP(T_OP_REG_EQ, reg_eq);
1877 XLAT_REGISTER_REGEX_OP(T_OP_REG_NE, reg_ne);
1878
1879 if (unlikely((xlat = xlat_func_register(NULL, "regex.search", xlat_func_regex_search, FR_TYPE_BOOL)) == NULL)) return -1;
1880 xlat_func_args_set(xlat, regex_search_xlat_args);
1881 xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE);
1882
1883 /*
1884 * &&, ||
1885 *
1886 * @todo - remove tmpl_resolve() from tokenize_field(), and add xlat_resolve_logical_or() / xlat_resolve_logical_and()
1887 * functions which do partial resolution.
1888 */
1889 XLAT_REGISTER_NARY_OP(T_LAND, logical_and, logical);
1890 XLAT_REGISTER_NARY_OP(T_LOR, logical_or, logical);
1891
1892 XLAT_REGISTER_BOOL("expr.rcode", xlat_func_expr_rcode, xlat_func_expr_rcode_arg, FR_TYPE_BOOL);
1893 xlat_func_instantiate_set(xlat, xlat_instantiate_expr_rcode, xlat_rcode_inst_t, NULL, NULL);
1894 xlat_func_print_set(xlat, xlat_expr_print_rcode);
1895
1896 XLAT_REGISTER_BOOL("exists", xlat_func_exists, xlat_func_exists_arg, FR_TYPE_BOOL);
1897 xlat_func_instantiate_set(xlat, xlat_instantiate_exists, xlat_exists_inst_t, NULL, NULL);
1898 xlat_func_print_set(xlat, xlat_expr_print_exists);
1899 xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_INTERNAL);
1900
1901 if (unlikely((xlat = xlat_func_register(NULL, "rcode", xlat_func_rcode, FR_TYPE_STRING)) == NULL)) return -1;
1902 xlat_func_args_set(xlat, xlat_func_rcode_arg);
1903 xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_INTERNAL);
1904
1905 /*
1906 * -EXPR
1907 * ~EXPR
1908 * !EXPR
1909 */
1910 XLAT_REGISTER_UNARY(T_SUB, "unary_minus", xlat_func_unary_minus);
1911 XLAT_REGISTER_UNARY(T_COMPLEMENT, "unary_complement", xlat_func_unary_complement);
1912 XLAT_REGISTER_UNARY(T_NOT, "unary_not", xlat_func_unary_not);
1913
1914 return 0;
1915}
1916
1917/*
1918 * Must use the same names as above.
1919 */
1920static const fr_sbuff_term_elem_t binary_ops[T_TOKEN_LAST] = {
1921 [ T_ADD ] = L("op_add"),
1922 [ T_SUB ] = L("op_sub"),
1923 [ T_MUL ] = L("op_mul"),
1924 [ T_DIV ] = L("op_div"),
1925 [ T_MOD ] = L("op_mod"),
1926 [ T_AND ] = L("op_and"),
1927 [ T_OR ] = L("op_or"),
1928 [ T_XOR ] = L("op_xor"),
1929 [ T_RSHIFT ] = L("op_rshift"),
1930 [ T_LSHIFT ] = L("op_lshift"),
1931
1932 [ T_LAND ] = L("logical_and"),
1933 [ T_LOR ] = L("logical_or"),
1934
1935 [ T_OP_CMP_EQ ] = L("cmp_eq"),
1936 [ T_OP_NE ] = L("cmp_ne"),
1937 [ T_OP_LT ] = L("cmp_lt"),
1938 [ T_OP_LE ] = L("cmp_le"),
1939 [ T_OP_GT ] = L("cmp_gt"),
1940 [ T_OP_GE ] = L("cmp_ge"),
1941
1942 [ T_OP_CMP_EQ_TYPE ] = L("cmp_eq_type"),
1943 [ T_OP_CMP_NE_TYPE ] = L("cmp_ne_type"),
1944
1945 [ T_OP_REG_EQ ] = L("reg_eq"),
1946 [ T_OP_REG_NE ] = L("reg_ne"),
1947};
1948
1949/*
1950 * Which are logical operations
1951 */
1952static const bool logical_ops[T_TOKEN_LAST] = {
1953 [T_LAND] = true,
1954 [T_LOR] = true,
1955};
1956
1957/*
1958 * These operators can take multiple arguments.
1959 *
1960 * @todo - include T_ADD, T_SUB, T_MUL, T_AND, T_OR, T_XOR, here too.
1961 *
1962 * This array should contain a function pointer to the code which either appends the results, or does
1963 * peephole optimizations to merge the arguments together. This merging will reduce run-time effort.
1964 */
1965static const bool multivalue_ops[T_TOKEN_LAST] = {
1966 [T_LAND] = true,
1967 [T_LOR] = true,
1968};
1969
1970/*
1971 * Allow for BEDMAS ordering. Gross ordering is first number,
1972 * fine ordering is second number. Unused operators are assigned as zero.
1973 *
1974 * Larger numbers are higher precedence.
1975 */
1976#define P(_x, _y) (((_x) << 4) | (_y))
1977
1978static const int precedence[T_TOKEN_LAST] = {
1979 [T_INVALID] = 0,
1980
1981 /*
1982 * Assignment operators go here as P(1,n)
1983 *
1984 * += -= *= /= %= <<= >>= &= ^= |=
1985 *
1986 * We want the output of the assignment operators to be the result of the assignment. This means
1987 * that the assignments can really only be done for simple attributes, and not tmpls with filters
1988 * which select multiple attributes.
1989 *
1990 * Which (for now) means that we likely want to disallow assignments in expressions. That's
1991 * fine, as this isn't C, and we're not sure that it makes sense to do something like:
1992 *
1993 * if ((&foo += 5) > 60) ...
1994 *
1995 * Or maybe it does. Who knows?
1996 */
1997
1998 [T_LOR] = P(2,0),
1999 [T_LAND] = P(2,1),
2000
2001 [T_OR] = P(3,0),
2002 [T_XOR] = P(3,1),
2003 [T_AND] = P(3,2),
2004
2005 [T_OP_REG_EQ] = P(4,0),
2006 [T_OP_REG_NE] = P(4,0),
2007
2008 [T_OP_CMP_EQ] = P(4,1),
2009 [T_OP_NE] = P(4,1),
2010
2011 [T_OP_CMP_EQ_TYPE] = P(4,1),
2012 [T_OP_CMP_NE_TYPE] = P(4,1),
2013
2014 [T_OP_LT] = P(5,0),
2015 [T_OP_LE] = P(5,0),
2016 [T_OP_GT] = P(5,0),
2017 [T_OP_GE] = P(5,0),
2018
2019 [T_RSHIFT] = P(6,0),
2020 [T_LSHIFT] = P(6,0),
2021
2022 [T_SUB] = P(7,0),
2023 [T_ADD] = P(7,1),
2024
2025 [T_MOD] = P(8,0),
2026 [T_MUL] = P(8,1),
2027 [T_DIV] = P(8,2),
2028
2029 [T_LBRACE] = P(10,0),
2030};
2031
2032#define fr_sbuff_skip_whitespace(_x) \
2033 do { \
2034 while (isspace((uint8_t) fr_sbuff_char(_x, '\0'))) fr_sbuff_advance(_x, 1); \
2035 } while (0)
2036
2037static ssize_t tokenize_expression(xlat_exp_head_t *head, xlat_exp_t **out, fr_sbuff_t *in,
2038 fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules,
2039 fr_token_t prev, fr_sbuff_parse_rules_t const *bracket_rules,
2040 fr_sbuff_parse_rules_t const *input_rules, bool cond) CC_HINT(nonnull(1,2,3,4,5));
2041
2042static ssize_t tokenize_field(xlat_exp_head_t *head, xlat_exp_t **out, fr_sbuff_t *in,
2043 fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules,
2044 fr_sbuff_parse_rules_t const *bracket_rules, char *out_c, bool cond) CC_HINT(nonnull(1,2,3,4,5));
2045
2046static fr_slen_t tokenize_unary(xlat_exp_head_t *head, xlat_exp_t **out, fr_sbuff_t *in,
2047 fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules,
2048 fr_sbuff_parse_rules_t const *bracket_rules, char *out_c, bool cond) CC_HINT(nonnull(1,2,3,4,5));
2049
2050static fr_table_num_sorted_t const expr_quote_table[] = {
2051 { L("\""), T_DOUBLE_QUOTED_STRING }, /* Don't re-order, backslash throws off ordering */
2052 { L("'"), T_SINGLE_QUOTED_STRING },
2053 { L("/"), T_SOLIDUS_QUOTED_STRING },
2054 { L("`"), T_BACK_QUOTED_STRING }
2055};
2056static size_t expr_quote_table_len = NUM_ELEMENTS(expr_quote_table);
2057
2058
2059/*
2060 * Look for prefix operators
2061 *
2062 * + = ignore
2063 * - = unary_minus(next)
2064 * ! = unary_not(next)
2065 * ~ = unary_xor(0, next)
2066 * (expr) = recurse, and parse expr
2067 *
2068 * as a special case, <type> is a cast. Which lets us know how
2069 * to parse the next thing we get. Otherwise, parse the thing as
2070 * int64_t.
2071 */
2072static fr_slen_t tokenize_unary(xlat_exp_head_t *head, xlat_exp_t **out, fr_sbuff_t *in,
2073 fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules,
2074 fr_sbuff_parse_rules_t const *bracket_rules, char *out_c, bool cond)
2075{
2076 xlat_exp_t *node = NULL, *unary = NULL;
2077 xlat_t *func = NULL;
2078 fr_sbuff_t our_in = FR_SBUFF(in);
2079 char c = '\0';
2080
2081 XLAT_DEBUG("UNARY <-- %pV", fr_box_strvalue_len(fr_sbuff_current(in), fr_sbuff_remaining(in)));
2082
2083 /*
2084 * Handle !-~ by adding a unary function to the xlat
2085 * node, with the first argument being the _next_ thing
2086 * we allocate.
2087 */
2088 if (fr_sbuff_next_if_char(&our_in, '!')) { /* unary not */
2089 func = xlat_func_find("unary_not", 9);
2090 fr_assert(func != NULL);
2091 c = '!';
2092 goto check_for_double;
2093
2094 }
2095 else if (fr_sbuff_next_if_char(&our_in, '-')) { /* unary minus */
2096 fr_sbuff_skip_whitespace(&our_in);
2097
2098 /*
2099 * -4 is a number, not minus(4).
2100 */
2101 if (fr_sbuff_is_digit(&our_in)) goto field;
2102
2103 func = xlat_func_find("unary_minus", 11);
2104 fr_assert(func != NULL);
2105 c = '-';
2106 goto check_for_double;
2107
2108 }
2109 else if (fr_sbuff_next_if_char(&our_in, '~')) { /* unary complement */
2110 func = xlat_func_find("unary_complement", 16);
2111 fr_assert(func != NULL);
2112 c = '~';
2113 goto check_for_double;
2114
2115 }
2116 else if (fr_sbuff_next_if_char(&our_in, '+')) { /* ignore unary + */
2117 c = '+';
2118
2119 check_for_double:
2120 fr_sbuff_skip_whitespace(&our_in);
2121 fr_sbuff_skip_whitespace(&our_in);
2122 if (fr_sbuff_is_char(&our_in, c)) {
2123 fr_strerror_const("Double operator is invalid");
2124 FR_SBUFF_ERROR_RETURN(&our_in);
2125 }
2126 }
2127
2128 /*
2129 * Maybe we have a unary not / etc. If so, make sure
2130 * that we return that, and not the child node
2131 */
2132 if (!func) {
2133 field:
2134 return tokenize_field(head, out, in, p_rules, t_rules, bracket_rules, out_c, cond);
2135 }
2136
2137 /*
2138 * Tokenize_field may reset this if the operation is wrapped inside of another expression.
2139 */
2140 *out_c = c;
2141
2142 MEM(unary = xlat_exp_alloc(head, XLAT_FUNC, fr_tokens[func->token], strlen(fr_tokens[func->token])));
2143 xlat_exp_set_func(unary, func, t_rules->attr.dict_def);
2144 MEM(unary->call.args = xlat_exp_head_alloc(unary));
2145 unary->call.args->is_argv = true;
2146
2147 if (tokenize_field(unary->call.args, &node, &our_in, p_rules, t_rules, bracket_rules, out_c, (c == '!')) <= 0) {
2148 talloc_free(unary);
2149 FR_SBUFF_ERROR_RETURN(&our_in);
2150 }
2151
2152 if (!node) {
2153 fr_strerror_const("Empty expressions are invalid");
2154 FR_SBUFF_ERROR_RETURN(&our_in);
2155 }
2156
2157 xlat_func_append_arg(unary, node, (c == '!'));
2158 unary->flags.can_purify = (unary->call.func->flags.pure && unary->call.args->flags.pure) | unary->call.args->flags.can_purify;
2159
2160 /*
2161 * Don't add it to head->flags, that will be done when it's actually inserted.
2162 */
2163
2164 *out = unary;
2165
2166 FR_SBUFF_SET_RETURN(in, &our_in);
2167}
2168
2169/** Allocate a specific cast node.
2170 *
2171 * With the first argument being a UINT8 of the data type.
2172 * See xlat_func_cast() for the implementation.
2173 *
2174 */
2175static xlat_exp_t *expr_cast_alloc(TALLOC_CTX *ctx, fr_type_t type, xlat_exp_t *child)
2176{
2177 xlat_exp_t *cast, *node;
2178 char const *str;
2179
2180 /*
2181 * Create a "cast" node. The first argument is a UINT8 value-box of the cast type. The RHS is
2182 * whatever "node" comes next.
2183 */
2184 MEM(cast = xlat_exp_alloc(ctx, XLAT_FUNC, "cast", 4));
2185 MEM(cast->call.func = xlat_func_find("cast", 4));
2186 // no need to set dict here
2187 fr_assert(cast->call.func != NULL);
2188 cast->flags = cast->call.func->flags;
2189
2190 /*
2191 * Create argv[0] UINT8, with "Cast-Base" as
2192 * the "da". This allows the printing routines
2193 * to print the name of the type, and not the
2194 * number.
2195 */
2196 str = fr_type_to_str(type);
2197 fr_assert(str != NULL);
2198
2199 MEM(node = xlat_exp_alloc(cast, XLAT_BOX, NULL, 0));
2200 xlat_exp_set_name(node, str, strlen(str));
2201
2202 fr_value_box_init(&node->data, FR_TYPE_UINT8, attr_cast_base, false);
2203 node->data.vb_uint8 = type;
2204
2205 xlat_func_append_arg(cast, node, false);
2206 (void) talloc_steal(cast, child);
2207 xlat_func_append_arg(cast, child, false);
2208
2209 return cast;
2210}
2211
2212static fr_slen_t expr_cast_from_substr(fr_type_t *cast, fr_sbuff_t *in)
2213{
2214 fr_sbuff_t our_in = FR_SBUFF(in);
2215 fr_sbuff_marker_t m;
2216 ssize_t slen;
2217
2218 if (!fr_sbuff_next_if_char(&our_in, '(')) {
2219 no_cast:
2220 *cast = FR_TYPE_NULL;
2221 return 0;
2222 }
2223
2224 fr_sbuff_marker(&m, &our_in);
2225 fr_sbuff_out_by_longest_prefix(&slen, cast, fr_type_table, &our_in, FR_TYPE_NULL);
2226
2227 /*
2228 * We didn't read anything, there's no cast.
2229 */
2230 if (fr_sbuff_diff(&our_in, &m) == 0) goto no_cast;
2231
2232 if (!fr_sbuff_next_if_char(&our_in, ')')) goto no_cast;
2233
2234 if (fr_type_is_null(*cast)) {
2235 fr_strerror_printf("Invalid data type in cast");
2236 FR_SBUFF_ERROR_RETURN(&m);
2237 }
2238
2239 if (!fr_type_is_leaf(*cast)) {
2240 fr_strerror_printf("Invalid data type '%s' in cast", fr_type_to_str(*cast));
2241 FR_SBUFF_ERROR_RETURN(&our_in);
2242 }
2243
2244 fr_sbuff_adv_past_whitespace(&our_in, SIZE_MAX, NULL);
2245
2246 FR_SBUFF_SET_RETURN(in, &our_in);
2247}
2248
2249/*
2250 * Tokenize the RHS of a regular expression.
2251 */
2252static fr_slen_t tokenize_regex_rhs(xlat_exp_head_t *head, xlat_exp_t **out, fr_sbuff_t *in,
2253 tmpl_rules_t const *t_rules,
2254 fr_sbuff_parse_rules_t const *bracket_rules)
2255{
2256 ssize_t slen;
2257 xlat_exp_t *node = NULL;
2258 fr_sbuff_t our_in = FR_SBUFF(in);
2259 fr_sbuff_marker_t opand_m, flag;
2260 tmpl_t *vpt;
2261 fr_token_t quote = T_SOLIDUS_QUOTED_STRING;
2262
2263 XLAT_DEBUG("REGEX_RHS <-- %pV", fr_box_strvalue_len(fr_sbuff_current(in), fr_sbuff_remaining(in)));
2264
2265 fr_sbuff_skip_whitespace(&our_in);
2266
2267 /*
2268 * Record where the operand begins for better error offsets later
2269 */
2270 fr_sbuff_marker(&opand_m, &our_in);
2271
2272 /*
2273 * Regexes cannot have casts or sub-expressions.
2274 */
2275 if (!fr_sbuff_next_if_char(&our_in, '/')) {
2276 /*
2277 * Allow for m'...' ala Perl
2278 */
2279 if (!fr_sbuff_is_str(&our_in, "m'", 2)) {
2280 fr_strerror_const("Expected regular expression");
2281 goto error;
2282 }
2283
2284 fr_sbuff_advance(&our_in, 2);
2285 quote = T_SINGLE_QUOTED_STRING;
2286 }
2287
2288 /*
2289 * Allocate the xlat node now so the talloc hierarchy is correct
2290 */
2291 MEM(node = xlat_exp_alloc(head, XLAT_TMPL, NULL, 0));
2292
2293 /*
2294 * tmpl_afrom_substr does pretty much all the work of parsing the operand. Note that we pass '/'
2295 * as the quote, so that the tmpl gets parsed as a regex.
2296 */
2297 (void) tmpl_afrom_substr(node, &vpt, &our_in, T_SOLIDUS_QUOTED_STRING, value_parse_rules_quoted[quote], t_rules);
2298 if (!vpt) {
2299 error:
2300 talloc_free(node);
2301 FR_SBUFF_ERROR_RETURN(&our_in);
2302 }
2303
2304 /*
2305 * @todo - allow for the RHS to be an attribute, too?
2306 */
2307
2308 /*
2309 * It would be nice if tmpl_afrom_substr() did this :(
2310 */
2311 if (!fr_sbuff_next_if_char(&our_in, fr_token_quote[quote])) {
2312 fr_strerror_const("Unterminated regular expression");
2313 goto error;
2314 }
2315
2316 /*
2317 * Remember where the flags start
2318 */
2319 fr_sbuff_marker(&flag, &our_in);
2320 if (tmpl_regex_flags_substr(vpt, &our_in, bracket_rules->terminals) < 0) {
2321 talloc_free(node);
2322 FR_SBUFF_ERROR_RETURN(&our_in);
2323 }
2324
2325 fr_sbuff_skip_whitespace(&our_in);
2326
2327 /*
2328 * Try to compile regular expressions, but only if
2329 * they're not being dynamically expanded.
2330 */
2331 if (!tmpl_contains_xlat(vpt)) {
2332 slen = tmpl_regex_compile(vpt, true);
2333 if (slen <= 0) goto error;
2334 }
2335
2336 node->quote = quote;
2337 xlat_exp_set_vpt(node, vpt);
2338
2339 XLAT_VERIFY(node);
2340 *out = node;
2341
2342 FR_SBUFF_SET_RETURN(in, &our_in);
2343}
2344
2345
2346static ssize_t tokenize_rcode(xlat_exp_head_t *head, xlat_exp_t **out, fr_sbuff_t *in, fr_sbuff_term_t const *terminals)
2347{
2348 rlm_rcode_t rcode;
2349 ssize_t slen;
2350 xlat_t *func;
2351 xlat_exp_t *node, *arg;
2352 fr_sbuff_t our_in = FR_SBUFF(in);
2353
2354 fr_sbuff_out_by_longest_prefix(&slen, &rcode, rcode_table, &our_in, T_BARE_WORD);
2355 if (slen <= 0) return 0;
2356
2357 if (!fr_sbuff_is_terminal(&our_in, terminals)) {
2358 if (!fr_dict_attr_allowed_chars[fr_sbuff_char(&our_in, '\0')]) {
2359 fr_strerror_const("Unexpected text after return code");
2360 FR_SBUFF_ERROR_RETURN(&our_in);
2361 }
2362 return 0;
2363 }
2364
2365 /*
2366 * @todo - allow for attributes to have the name "ok-foo" ???
2367 */
2368 func = xlat_func_find("expr.rcode", -1);
2369 fr_assert(func != NULL);
2370
2371 MEM(node = xlat_exp_alloc(head, XLAT_FUNC, fr_sbuff_start(&our_in), slen));
2372 node->call.func = func;
2373 // no need to set dict here
2374 node->flags = func->flags; /* rcode is impure, but can be calculated statically */
2375
2376 MEM(arg = xlat_exp_alloc(node, XLAT_BOX, fr_sbuff_start(&our_in), slen));
2377
2378 /*
2379 * We need a string for unit tests, but this should really be just a number.
2380 */
2381 fr_value_box_init(&arg->data, FR_TYPE_STRING, NULL, false);
2382 (void) fr_value_box_bstrndup(arg, &arg->data, NULL, fr_sbuff_start(&our_in), slen, false);
2383
2384 xlat_func_append_arg(node, arg, false);
2385
2386 *out = node;
2387
2388 FR_SBUFF_SET_RETURN(in, &our_in);
2389}
2390
2391
2392/*
2393 * Tokenize a field without unary operators.
2394 */
2395static fr_slen_t tokenize_field(xlat_exp_head_t *head, xlat_exp_t **out, fr_sbuff_t *in,
2396 fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules,
2397 fr_sbuff_parse_rules_t const *bracket_rules, char *out_c, bool cond)
2398{
2399 ssize_t slen;
2400 xlat_exp_t *node = NULL;
2401 fr_sbuff_t our_in = FR_SBUFF(in);
2402 fr_sbuff_marker_t opand_m;
2403 tmpl_rules_t our_t_rules;
2404 tmpl_t *vpt = NULL;
2405 fr_token_t quote;
2406 fr_type_t cast_type;
2407 fr_dict_attr_t const *enumv;
2408
2409 XLAT_DEBUG("FIELD <-- %pV", fr_box_strvalue_len(fr_sbuff_current(in), fr_sbuff_remaining(in)));
2410
2411 /*
2412 * Allow for explicit casts. Non-leaf types are forbidden.
2413 */
2414 if (expr_cast_from_substr(&cast_type, &our_in) < 0) return -1;
2415
2416 /*
2417 * Do NOT pass the cast down to the next set of parsing routines. Instead, let the next data be
2418 * parsed as whatever, and then add a cast, or cast in place as necessary.
2419 */
2420 our_t_rules = *t_rules;
2421 if (cast_type == FR_TYPE_NULL) {
2422 cast_type = our_t_rules.cast;
2423 enumv = our_t_rules.enumv;
2424 } else {
2425 enumv = NULL;
2426 }
2427
2428 our_t_rules.cast = FR_TYPE_NULL;
2429// our_t_rules.enumv = NULL;
2430
2431 /*
2432 * As a special case, we allow
2433 *
2434 * &reply = "foo = bar"
2435 *
2436 * and then we don't parse the RHS as any enum.
2437 */
2438 if ( our_t_rules.enumv && !fr_type_is_leaf(our_t_rules.enumv->type)) {
2439 our_t_rules.enumv = enumv = NULL;
2440 }
2441
2442 /*
2443 * If we still have '(', then recurse for other expressions
2444 *
2445 * Tokenize the sub-expression, ensuring that we stop at ')'.
2446 *
2447 * Note that if we have a sub-expression, then we don't use the hinting for "type".
2448 * That's because we're parsing a complete expression here (EXPR). So the intermediate
2449 * nodes in the expression can be almost anything. And we only cast it to the final
2450 * value when we get the output of the expression.
2451 */
2452 if (fr_sbuff_next_if_char(&our_in, '(')) {
2453 our_t_rules.cast = FR_TYPE_NULL;
2454 our_t_rules.enumv = NULL;
2455
2456 fr_sbuff_skip_whitespace(&our_in);
2457 if (fr_sbuff_is_char(&our_in, ')')) {
2458 fr_strerror_printf("Empty expressions are invalid");
2459 FR_SBUFF_ERROR_RETURN(&our_in);
2460 }
2461
2462 /*
2463 * No input rules means "ignore external terminal sequences, as we're expecting a ')' as
2464 * our terminal sequence.
2465 */
2466 if (tokenize_expression(head, &node, &our_in, bracket_rules, &our_t_rules, T_INVALID, bracket_rules, NULL, cond) <= 0) {
2467 FR_SBUFF_ERROR_RETURN(&our_in);
2468 }
2469
2470 if (!fr_sbuff_next_if_char(&our_in, ')')) {
2471 fr_strerror_printf("Failed to find trailing ')'");
2472 FR_SBUFF_ERROR_RETURN(&our_in);
2473 }
2474
2475 /*
2476 * We've parsed one "thing", so we stop. The next thing should be an operator, not
2477 * another value.
2478 *
2479 * The nested call to tokenize_expression() can return >=0 if there are spaces followed by a
2480 * terminal character. So "node" may be NULL;
2481 */
2482 if (!node) {
2483 fr_strerror_const("Empty expressions are invalid");
2484 FR_SBUFF_ERROR_RETURN(&our_in);
2485 }
2486
2487 *out_c = '\0';
2488 goto done;
2489 }
2490
2491 /*
2492 * Record where the operand begins for better error offsets later
2493 */
2494 fr_sbuff_skip_whitespace(&our_in);
2495 fr_sbuff_marker(&opand_m, &our_in);
2496
2497 fr_sbuff_out_by_longest_prefix(&slen, &quote, expr_quote_table, &our_in, T_BARE_WORD);
2498
2499 switch (quote) {
2500 case T_BARE_WORD:
2501 p_rules = bracket_rules;
2502
2503 /*
2504 * Peek for rcodes.
2505 */
2506 slen = tokenize_rcode(head, &node, &our_in, p_rules->terminals);
2507 if (slen < 0) FR_SBUFF_ERROR_RETURN(&our_in);
2508
2509 if (slen > 0) {
2510 fr_assert(node != NULL);
2511 goto done;
2512 }
2513 FALL_THROUGH;
2514
2515 default:
2516 slen = xlat_tokenize_word(head, &node, &our_in, quote, p_rules, &our_t_rules);
2517 if (slen <= 0) FR_SBUFF_ERROR_RETURN(&our_in);
2518
2519 fr_assert(node != NULL);
2520 break;
2521 }
2522
2523 /*
2524 * Cast value-box.
2525 */
2526 if (node->type == XLAT_BOX) {
2527 if (cast_type != FR_TYPE_NULL) {
2528 if (node->data.type != cast_type) {
2529 if (fr_value_box_cast_in_place(node, &node->data, cast_type, NULL) < 0) goto error;
2530 }
2531
2532 cast_type = FR_TYPE_NULL;
2533 }
2534 }
2535
2536 /*
2537 * Something other than a tmpl, we can just return.
2538 */
2539 if (node->type != XLAT_TMPL) {
2540 xlat_exp_set_name(node, fr_sbuff_current(&opand_m), fr_sbuff_behind(&opand_m));
2541 goto done;
2542 }
2543
2544 vpt = node->vpt;
2545
2546 /*
2547 * The tmpl has a cast, and it's the same as the explicit cast we were given, we can sometimes
2548 * discard the explicit cast.
2549 */
2550 if (cast_type != FR_TYPE_NULL) {
2551 if (tmpl_rules_cast(vpt) == cast_type) {
2552 fr_assert(0);
2553 cast_type = FR_TYPE_NULL;
2554
2555 } else if (tmpl_is_attr(vpt)) {
2556 fr_dict_attr_t const *da;
2557
2558 fr_assert(!tmpl_is_attr_unresolved(vpt));
2559
2560 da = tmpl_attr_tail_da(vpt); /* could be a list! */
2561
2562 /*
2563 * Set the cast for attributes. Note that tmpl_cast_set() will take care of
2564 * suppressing redundant casts. But it still allows (uint32)&Service-Type,
2565 * which means "return the raw value", and not "return enum name".
2566 */
2567 if (da) {
2568 if (tmpl_cast_set(vpt, cast_type) < 0) {
2569 error:
2570 fr_sbuff_set(&our_in, &opand_m);
2571 talloc_free(node);
2572 FR_SBUFF_ERROR_RETURN(&our_in);
2573 }
2574
2575 cast_type = FR_TYPE_NULL;
2576
2577 } else { /* it's something like &reply. */
2578 fr_assert(0);
2579 }
2580
2581 } else if (tmpl_is_data(vpt)) {
2582 fr_assert(!tmpl_is_data_unresolved(vpt));
2583
2584 /*
2585 * Omit our cast type if the data is already of the right type.
2586 *
2587 * Otherwise if we have a cast, then convert the data now, and then reset the
2588 * cast_type to nothing. This work allows for better errors at startup, and
2589 * minimizes run-time work.
2590 */
2591 if (tmpl_value_type(vpt) == cast_type) {
2592 cast_type = FR_TYPE_NULL;
2593
2594 } else if (tmpl_cast_in_place(vpt, cast_type, enumv) < 0) {
2595 fr_sbuff_set(&our_in, &opand_m);
2596 goto error;
2597
2598 } else {
2599 /*
2600 * We've parsed the data as the new data type, so we don't need any more
2601 * casting.
2602 */
2603 cast_type = FR_TYPE_NULL;
2604 }
2605
2606 } else if (tmpl_contains_xlat(vpt)) {
2607 /*
2608 * (string) "foo %{...}" is redundant. Drop the cast.
2609 */
2610 if ((cast_type == FR_TYPE_STRING) && (vpt->quote != T_BARE_WORD)) {
2611 tmpl_cast_set(vpt, FR_TYPE_NULL);
2612 cast_type = FR_TYPE_NULL;
2613
2614 } else {
2615 /*
2616 * Push the cast to the tmpl.
2617 */
2618 tmpl_cast_set(vpt, cast_type);
2619 cast_type = FR_TYPE_NULL;
2620 }
2621
2622 } else if (tmpl_is_attr_unresolved(vpt)) {
2623 fr_assert(t_rules->attr.allow_unresolved);
2624
2625 } else if (tmpl_is_data_unresolved(vpt)) {
2626 fr_assert(0);
2627
2628 fr_assert(quote == T_BARE_WORD);
2629 fr_strerror_const("Failed parsing input");
2630 fr_sbuff_set(&our_in, &opand_m);
2631 goto error;
2632
2633 } else {
2634 /*
2635 * Regex? Or something else weird?
2636 */
2637 tmpl_debug(vpt);
2638 fr_assert(0);
2639 }
2640 }
2641
2642 fr_assert(!tmpl_contains_regex(vpt));
2643
2644done:
2645 /*
2646 * If there is a cast, then reparent the node with a cast wrapper.
2647 */
2648 if (cast_type != FR_TYPE_NULL) {
2649 xlat_exp_t *cast;
2650
2651 MEM(cast = expr_cast_alloc(head, cast_type, node));
2652 node = cast;
2653 }
2654
2655 *out = node;
2656
2657 fr_sbuff_skip_whitespace(&our_in);
2658 FR_SBUFF_SET_RETURN(in, &our_in);
2659}
2660
2661/*
2662 * A mapping of operators to tokens.
2663 */
2664static fr_table_num_ordered_t const expr_assignment_op_table[] = {
2665 { L("!="), T_OP_NE },
2666 { L("!=="), T_OP_CMP_NE_TYPE },
2667
2668 { L("&"), T_AND },
2669 { L("&&"), T_LAND },
2670 { L("*"), T_MUL },
2671 { L("+"), T_ADD },
2672 { L("-"), T_SUB },
2673 { L("/"), T_DIV },
2674 { L("%"), T_MOD },
2675 { L("^"), T_XOR },
2676
2677 { L("|"), T_OR },
2678 { L("||"), T_LOR },
2679
2680 { L("<"), T_OP_LT },
2681 { L("<<"), T_LSHIFT },
2682 { L("<="), T_OP_LE },
2683
2684 { L("="), T_OP_EQ },
2685 { L("=="), T_OP_CMP_EQ },
2686 { L("==="), T_OP_CMP_EQ_TYPE },
2687
2688 { L("=~"), T_OP_REG_EQ },
2689 { L("!~"), T_OP_REG_NE },
2690
2691 { L(">"), T_OP_GT },
2692 { L(">="), T_OP_GE },
2693 { L(">>"), T_RSHIFT },
2694
2695};
2696static size_t const expr_assignment_op_table_len = NUM_ELEMENTS(expr_assignment_op_table);
2697
2698static bool valid_type(xlat_exp_t *node)
2699{
2700 fr_dict_attr_t const *da;
2701
2702#ifdef STATIC_ANALYZER
2703 if (!node) return false;
2704#endif
2705
2706 if (node->type != XLAT_TMPL) return true;
2707
2708 if (tmpl_is_list(node->vpt)) {
2709 list:
2710 fr_strerror_const("Cannot use list references in condition");
2711 return false;
2712 }
2713
2714 if (!tmpl_is_attr(node->vpt)) return true;
2715
2716 da = tmpl_attr_tail_da(node->vpt);
2717 if (fr_type_is_structural(da->type)) {
2718 if (da->dict == fr_dict_internal()) goto list;
2719
2720 fr_strerror_const("Cannot use structural types in condition");
2721 return false;
2722 }
2723
2724 return true;
2725}
2726
2727
2728/** Tokenize a mathematical operation.
2729 *
2730 * (EXPR)
2731 * !EXPR
2732 * A OP B
2733 *
2734 * If "out" is NULL then the expression is added to "head".
2735 * Otherwise, it's returned to the caller.
2736 */
2737static fr_slen_t tokenize_expression(xlat_exp_head_t *head, xlat_exp_t **out, fr_sbuff_t *in,
2738 fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules,
2739 fr_token_t prev, fr_sbuff_parse_rules_t const *bracket_rules,
2740 fr_sbuff_parse_rules_t const *input_rules, bool cond)
2741{
2742 xlat_exp_t *lhs = NULL, *rhs, *node;
2743 xlat_t *func = NULL;
2744 fr_token_t op;
2745 ssize_t slen;
2746 fr_sbuff_marker_t m_lhs, m_op, m_rhs;
2747 fr_sbuff_t our_in = FR_SBUFF(in);
2748 char c = '\0';
2749
2750 XLAT_DEBUG("EXPRESSION <-- %pV", fr_box_strvalue_len(fr_sbuff_current(in), fr_sbuff_remaining(in)));
2751
2752 fr_sbuff_skip_whitespace(&our_in);
2753
2754 fr_sbuff_marker(&m_lhs, &our_in);
2755
2756 /*
2757 * Get the LHS of the operation.
2758 */
2759 slen = tokenize_unary(head, &lhs, &our_in, p_rules, t_rules, bracket_rules, &c, cond);
2760 if (slen <= 0) FR_SBUFF_ERROR_RETURN(&our_in);
2761
2762 if (slen == 0) {
2763 fr_assert(lhs == NULL);
2764 *out = NULL;
2765 FR_SBUFF_SET_RETURN(in, &our_in);
2766 }
2767
2768redo:
2769 rhs = NULL;
2770
2771 fr_sbuff_skip_whitespace(&our_in);
2772
2773 /*
2774 * No more input, we're done.
2775 */
2776 if (fr_sbuff_extend(&our_in) == 0) {
2777 done:
2778 /*
2779 * LHS may be NULL if the expression has spaces followed by a terminal character.
2780 */
2781 *out = lhs;
2782 FR_SBUFF_SET_RETURN(in, &our_in);
2783 }
2784
2785 /*
2786 * ')' is a terminal, even if we didn't expect it.
2787 * Because if we didn't expect it, then it's an error.
2788 *
2789 * If we did expect it, then we return whatever we found,
2790 * and let the caller eat the ')'.
2791 */
2792 if (fr_sbuff_is_char(&our_in, ')')) {
2793 if (!bracket_rules) {
2794 fr_strerror_printf("Unexpected ')'");
2795 FR_SBUFF_ERROR_RETURN(&our_in);
2796 }
2797
2798 goto done;
2799 }
2800 fr_sbuff_skip_whitespace(&our_in);
2801
2802 /*
2803 * We hit a terminal sequence, stop.
2804 */
2805 if (input_rules && fr_sbuff_is_terminal(&our_in, input_rules->terminals)) goto done;
2806
2807 /*
2808 * Remember where we were after parsing the LHS.
2809 */
2810 fr_sbuff_marker(&m_op, &our_in);
2811
2812 /*
2813 * Get the operator.
2814 */
2815 XLAT_DEBUG(" operator <-- %pV", fr_box_strvalue_len(fr_sbuff_current(&our_in), fr_sbuff_remaining(&our_in)));
2816 fr_sbuff_out_by_longest_prefix(&slen, &op, expr_assignment_op_table, &our_in, T_INVALID);
2817 if ((op == T_INVALID) || !binary_ops[op].str) {
2818 fr_strerror_const("Invalid operator");
2819 fr_sbuff_set(&our_in, &m_op);
2820 talloc_free(lhs);
2821 FR_SBUFF_ERROR_RETURN(&our_in);
2822 }
2823
2824 /*
2825 * We can't (yet) do &list1 = &list2 + &list3
2826 */
2827 if (fr_binary_op[op] && t_rules->enumv && fr_type_is_structural(t_rules->enumv->type)) {
2828 fr_strerror_const("Invalid operator for structural attribute");
2829 fr_sbuff_set(&our_in, &m_op);
2830 talloc_free(lhs);
2831 FR_SBUFF_ERROR_RETURN(&our_in);
2832 }
2833
2834 fr_assert(precedence[op] != 0);
2835
2836 /*
2837 * a * b + c ... = (a * b) + c ...
2838 *
2839 * Feed the current expression to the caller, who will
2840 * take care of continuing.
2841 */
2842 if (precedence[op] <= precedence[prev]) {
2843 fr_sbuff_set(&our_in, &m_op);
2844 goto done;
2845 }
2846
2847 /*
2848 * &Foo and !&Foo are permitted as the LHS of || and &&
2849 */
2850 if (((c == '!') || (c == '~')) && (op != T_LAND) && (op != T_LOR)) {
2851 fr_strerror_printf("Operator '%c' is only applied to the left hand side of the '%s' operation, add (..) to evaluate the operation first", c, fr_tokens[op]);
2852 fail_lhs:
2853 fr_sbuff_set(&our_in, &m_lhs);
2854 FR_SBUFF_ERROR_RETURN(&our_in);
2855 }
2856
2857 fr_sbuff_skip_whitespace(&our_in);
2858 fr_sbuff_marker(&m_rhs, &our_in);
2859
2860 /*
2861 * We now parse the RHS, allowing a (perhaps different) cast on the RHS.
2862 */
2863 XLAT_DEBUG(" recurse RHS <-- %pV", fr_box_strvalue_len(fr_sbuff_current(&our_in), fr_sbuff_remaining(&our_in)));
2864 if ((op == T_OP_REG_EQ) || (op == T_OP_REG_NE)) {
2865 fr_type_t type;
2866
2867 /*
2868 * @todo - LHS shouldn't be anything else.
2869 */
2870 switch (lhs->type) {
2871 case XLAT_TMPL:
2872 type = tmpl_cast_get(lhs->vpt);
2873 if ((type != FR_TYPE_NULL) && (type != FR_TYPE_STRING)) {
2874 fr_strerror_const("Casts cannot be used with regular expressions");
2875 fr_sbuff_set(&our_in, &m_lhs);
2876 FR_SBUFF_ERROR_RETURN(&our_in);
2877 }
2878
2879 /*
2880 * Cast the LHS to a string, if it's not already one!
2881 */
2882 if (lhs->vpt->quote == T_BARE_WORD) tmpl_cast_set(lhs->vpt, FR_TYPE_STRING);
2883 break;
2884
2885 case XLAT_BOX:
2886 /*
2887 * 192.168.0.1 =~ /foo/
2888 *
2889 * Gets the LHS automatically converted to a string.
2890 */
2891 if (lhs->data.type != FR_TYPE_STRING) {
2892 if (fr_value_box_cast_in_place(lhs, &lhs->data, FR_TYPE_STRING, NULL) < 0) {
2893 fr_sbuff_set(&our_in, &m_lhs);
2894 FR_SBUFF_ERROR_RETURN(&our_in);
2895 }
2896 }
2897 break;
2898
2899 default:
2900 /*
2901 * @todo - if we hoist the LHS to a function instead of an xlat->tmpl->xlat, then
2902 * we can't cast the LHS to a string. OR, we have to manually add a lHS cast to
2903 * a string. Maybe we need to delay the LHS hoisting until such time as we know
2904 * it's safe.
2905 *
2906 * Also, hoisting a double-quoted xlat string to a _list_ of xlats is hard,
2907 * because we expect the LHS here to be one node. So perhaps the hoisting has to
2908 * be from an XLAT_TMPL to an XLAT_GROUP, which is still perhaps a bit of an
2909 * improvement.
2910 */
2911 break;
2912
2913 }
2914
2915 slen = tokenize_regex_rhs(head, &rhs, &our_in, t_rules, bracket_rules);
2916 } else {
2917 tmpl_rules_t our_t_rules = *t_rules;
2918
2919 /*
2920 * Pass the enumv down ONLY if the RHS name begins with "::".
2921 *
2922 * Otherwise, the terminal rules for expressions includes "-" and "+", both of which are
2923 * allowed in enum names. If we pass the enumv down to the next function, it will see
2924 * "Access-Accept", and then only parse "Access". Which is wrong.
2925 */
2926 if ((lhs->type == XLAT_TMPL) && tmpl_is_attr(lhs->vpt) &&
2927 fr_sbuff_is_str_literal(&our_in, "::")) {
2928 our_t_rules.enumv = tmpl_attr_tail_da(lhs->vpt);
2929 }
2930
2931 slen = tokenize_expression(head, &rhs, &our_in, p_rules, &our_t_rules, op, bracket_rules, input_rules, cond);
2932 }
2933 if (slen <= 0) {
2934 talloc_free(lhs);
2935 FR_SBUFF_ERROR_RETURN(&our_in);
2936 }
2937
2938 /*
2939 * The nested call to tokenize_expression() can return >=0 if there are spaces followed by a
2940 * terminal character.
2941 */
2942 if (!rhs) goto done;
2943
2944 func = xlat_func_find(binary_ops[op].str, binary_ops[op].len);
2945 fr_assert(func != NULL);
2946
2947 if (multivalue_ops[op]) {
2948 if ((lhs->type == XLAT_FUNC) && (lhs->call.func->token == op)) {
2949 xlat_func_append_arg(lhs, rhs, cond);
2950
2951 lhs->call.args->flags.can_purify |= rhs->flags.can_purify | rhs->flags.pure;
2952 lhs->flags.can_purify = lhs->call.args->flags.can_purify;
2953 goto redo;
2954 }
2955 goto purify;
2956 }
2957
2958 /*
2959 * Complain on comparisons between invalid data types.
2960 *
2961 * @todo - allow
2962 *
2963 * &structural == {}
2964 * &structural != {}
2965 *
2966 * as special cases, so we can check lists for emptiness.
2967 */
2968 if (fr_comparison_op[op]) {
2969 if (!valid_type(lhs)) goto fail_lhs;
2970 if (!valid_type(rhs)) {
2971 fr_sbuff_set(&our_in, &m_rhs);
2972 FR_SBUFF_ERROR_RETURN(&our_in);
2973 }
2974
2975 /*
2976 * Peephole optimization. If both LHS
2977 * and RHS are static values, then just call the
2978 * relevant condition code to get the result.
2979 */
2980 if (cond) {
2981 int rcode;
2982
2983 purify:
2984 rcode = xlat_purify_op(head, &node, lhs, op, rhs);
2985 if (rcode < 0) goto fail_lhs;
2986
2987 if (rcode) {
2988 lhs = node;
2989 goto redo;
2990 }
2991 }
2992 }
2993
2994 /*
2995 * Create the function node, with the LHS / RHS arguments.
2996 */
2997 MEM(node = xlat_exp_alloc(head, XLAT_FUNC, fr_tokens[op], strlen(fr_tokens[op])));
2998 xlat_exp_set_func(node, func, t_rules->attr.dict_def);
2999
3000 xlat_func_append_arg(node, lhs, logical_ops[op] && cond);
3001 xlat_func_append_arg(node, rhs, logical_ops[op] && cond);
3002
3003 fr_assert(xlat_exp_head(node->call.args) != NULL);
3004
3005 /*
3006 * Logical operations can be purified if ANY of their arguments can be purified.
3007 */
3008 if (logical_ops[op]) {
3009 xlat_exp_foreach(node->call.args, arg) {
3010 node->call.args->flags.can_purify |= arg->flags.can_purify | arg->flags.pure;
3011 if (node->call.args->flags.can_purify) break;
3012 }
3013 node->flags.can_purify = node->call.args->flags.can_purify;
3014
3015 } else {
3016 node->flags.can_purify = (node->call.func->flags.pure && node->call.args->flags.pure) | node->call.args->flags.can_purify;
3017 }
3018
3019 lhs = node;
3020 goto redo;
3021}
3022
3023static const fr_sbuff_term_t bracket_terms = FR_SBUFF_TERMS(
3024 L(""),
3025 L(")"),
3026);
3027
3028static const fr_sbuff_term_t operator_terms = FR_SBUFF_TERMS(
3029 L("\t"),
3030 L("\n"),
3031 L("\r"),
3032 L(" "),
3033 L("!"),
3034 L("%"),
3035 L("&"),
3036 L("*"),
3037 L("+"),
3038 L("-"),
3039 L("/"),
3040 L("<"),
3041 L("="),
3042 L(">"),
3043 L("^"),
3044 L("|"),
3045 L("~"),
3046);
3047
3048static fr_slen_t xlat_tokenize_expression_internal(TALLOC_CTX *ctx, xlat_exp_head_t **out, fr_sbuff_t *in,
3049 fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules, bool cond)
3050{
3051 fr_slen_t slen;
3052 fr_sbuff_parse_rules_t *bracket_rules = NULL;
3053 fr_sbuff_parse_rules_t *terminal_rules = NULL;
3054 tmpl_rules_t my_rules = { };
3055 xlat_exp_head_t *head;
3056 xlat_exp_t *node = NULL;
3057
3058 /*
3059 * Whatever the caller passes, ensure that we have a
3060 * terminal rule which ends on operators, and a terminal
3061 * rule which ends on ')'.
3062 */
3063 MEM(bracket_rules = talloc_zero(ctx, fr_sbuff_parse_rules_t));
3064 MEM(terminal_rules = talloc_zero(ctx, fr_sbuff_parse_rules_t));
3065 if (p_rules) {
3066 *bracket_rules = *p_rules;
3067 *terminal_rules = *p_rules;
3068
3069 if (p_rules->terminals) {
3070 MEM(terminal_rules->terminals = fr_sbuff_terminals_amerge(terminal_rules,
3071 p_rules->terminals,
3072 &operator_terms));
3073 } else {
3074 terminal_rules->terminals = &operator_terms;
3075 }
3076 } else {
3077 terminal_rules->terminals = &operator_terms;
3078 }
3079 MEM(bracket_rules->terminals = fr_sbuff_terminals_amerge(bracket_rules,
3080 terminal_rules->terminals,
3081 &bracket_terms));
3082
3083 MEM(head = xlat_exp_head_alloc(ctx));
3084 if (!t_rules) t_rules = &my_rules;
3085
3086 slen = tokenize_expression(head, &node, in, terminal_rules, t_rules, T_INVALID, bracket_rules, p_rules, cond);
3087 talloc_free(bracket_rules);
3088 talloc_free(terminal_rules);
3089
3090 if (slen <= 0) {
3091 talloc_free(head);
3092 return slen;
3093 }
3094
3095 if (!node) {
3096 *out = head;
3097 return slen;
3098 }
3099
3100 /*
3101 * If the tmpl is not resolved, then it refers to an attribute which doesn't exist. That's an
3102 * error.
3103 */
3104 if (node->type == XLAT_TMPL) {
3105 if (tmpl_is_data_unresolved(node->vpt)) {
3106 fr_strerror_const("Unknown attribute");
3107 return -1;
3108 }
3109
3110 /*
3111 * Convert raw existence checks to existence functions.
3112 */
3113 if (tmpl_contains_attr(node->vpt)) {
3114 if (cond) MEM(node = xlat_exists_alloc(head, node));
3115 }
3116 }
3117
3118 xlat_exp_insert_tail(head, node);
3119
3120 *out = head;
3121 return slen;
3122}
3123
3124fr_slen_t xlat_tokenize_expression(TALLOC_CTX *ctx, xlat_exp_head_t **out, fr_sbuff_t *in,
3125 fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules)
3126{
3127 fr_slen_t slen;
3128
3129 slen = xlat_tokenize_expression_internal(ctx, out, in, p_rules, t_rules, false);
3130 if (slen < 0) return slen;
3131
3132#ifdef STATIC_ANALYZER
3133 /*
3134 * Coverity doesn't realise that out will be set by this point
3135 * by a successful call to xlat_tokenize_expression_internal.
3136 */
3137 if (!out) return -1;
3138#endif
3139 if (!*out) {
3140 fr_strerror_const("Empty expressions are invalid");
3141 return -1;
3142 }
3143
3144 if (xlat_finalize(*out, t_rules->xlat.runtime_el) < 0) {
3145 TALLOC_FREE(*out);
3146 return -1;
3147 }
3148
3149 return slen;
3150}
3151
3152fr_slen_t xlat_tokenize_condition(TALLOC_CTX *ctx, xlat_exp_head_t **out, fr_sbuff_t *in,
3153 fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules)
3154{
3155 fr_slen_t slen;
3156
3157 slen = xlat_tokenize_expression_internal(ctx, out, in, p_rules, t_rules, true);
3158 if (slen < 0) return slen;
3159
3160#ifdef STATIC_ANALYZER
3161 if (!out) return -1;
3162#endif
3163 if (!*out) {
3164 fr_strerror_const("Empty conditions are invalid");
3165 return -1;
3166 }
3167
3168 if (xlat_finalize(*out, t_rules->xlat.runtime_el) < 0) {
3169 TALLOC_FREE(*out);
3170 return -1;
3171 }
3172
3173 return slen;
3174}
3175
3176/** Allow callers to see if an xlat is truthy
3177 *
3178 * So the caller can cache it, and needs to check fewer things at run
3179 * time.
3180 *
3181 * @param[in] head of the xlat to check
3182 * @param[out] out truthiness of the box
3183 * @return
3184 * - false - xlat is not truthy, *out is unchanged.
3185 * - true - xlat is truthy, *out is the result of fr_value_box_is_truthy()
3186 */
3187bool xlat_is_truthy(xlat_exp_head_t const *head, bool *out)
3188{
3189 xlat_exp_t const *node;
3190 fr_value_box_t const *box;
3191
3192 /*
3193 * Only pure / constant things can be truthy.
3194 */
3195 if (!head->flags.pure) goto return_false;
3196
3197 node = xlat_exp_head(head);
3198 if (!node) {
3199 *out = false;
3200 return true;
3201 }
3202
3203 if (xlat_exp_next(head, node)) goto return_false;
3204
3205 if (node->type == XLAT_BOX) {
3206 box = &node->data;
3207
3208 } else if ((node->type == XLAT_TMPL) && tmpl_is_data(node->vpt)) {
3209 box = tmpl_value(node->vpt);
3210
3211 } else {
3212 return_false:
3213 *out = false;
3214 return false;
3215 }
3216
3217 *out = fr_value_box_is_truthy(box);
3218 return true;
3219}
args
va_list args
Definition acutest.h:770
UNCONST
#define UNCONST(_type, _ptr)
Remove const qualification from a pointer.
Definition build.h:167
RCSID
#define RCSID(id)
Definition build.h:485
L
#define L(_str)
Helper for initialising arrays of string literals.
Definition build.h:209
FALL_THROUGH
#define FALL_THROUGH
clang 10 doesn't recognised the FALL-THROUGH comment anymore
Definition build.h:324
unlikely
#define unlikely(_x)
Definition build.h:383
UNUSED
#define UNUSED
Definition build.h:317
NUM_ELEMENTS
#define NUM_ELEMENTS(_t)
Definition build.h:339
fr_value_calc_list_cmp
int fr_value_calc_list_cmp(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_value_box_list_t const *list1, fr_token_t op, fr_value_box_list_t const *list2)
Definition calc.c:2647
fr_value_calc_binary_op
int fr_value_calc_binary_op(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t hint, fr_value_box_t const *a, fr_token_t op, fr_value_box_t const *b)
Calculate DST = A OP B.
Definition calc.c:1924
fr_value_calc_unary_op
int fr_value_calc_unary_op(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_token_t op, fr_value_box_t const *src)
Calculate unary operations.
Definition calc.c:2481
fr_dcursor_append
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
fr_dcursor_s
Definition dcursor.h:93
MEM
#define MEM(x)
Definition debug.h:36
ERROR
#define ERROR(fmt,...)
Definition dhcpclient.c:41
fr_dict_attr_allowed_chars
bool const fr_dict_attr_allowed_chars[UINT8_MAX+1]
Characters that are allowed in dictionary attribute names.
Definition dict_util.c:47
fr_dict_internal
fr_dict_t const * fr_dict_internal(void)
Definition dict_util.c:4654
in
static fr_slen_t in
Definition dict.h:841
fr_dlist_remove
static void * fr_dlist_remove(fr_dlist_head_t *list_head, void *ptr)
Remove an item from the list.
Definition dlist.h:638
fr_dlist_num_elements
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
fr_dlist_pop_head
static void * fr_dlist_pop_head(fr_dlist_head_t *list_head)
Remove the head item in a list.
Definition dlist.h:672
fr_dlist_insert_tail
static int fr_dlist_insert_tail(fr_dlist_head_t *list_head, void *ptr)
Insert an item into the tail of a list.
Definition dlist.h:378
xlat_func_rcode
static xlat_action_t xlat_func_rcode(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, UNUSED fr_value_box_list_t *args)
Return the current rcode as a string.
Definition xlat_expr.c:1672
xlat_func_exists
static xlat_action_t xlat_func_exists(TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_ctx_t const *xctx, request_t *request, UNUSED fr_value_box_list_t *in)
See if a named attribute exists.
Definition xlat_expr.c:1779
xlat_func_expr_rcode
static xlat_action_t xlat_func_expr_rcode(TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Match the passed rcode against request->rcode.
Definition xlat_expr.c:1621
unlang_interpret_frame_talloc_ctx
TALLOC_CTX * unlang_interpret_frame_talloc_ctx(request_t *request)
Get a talloc_ctx which is valid only for this frame.
Definition interpret.c:1665
UNLANG_SUB_FRAME
#define UNLANG_SUB_FRAME
Definition interpret.h:37
unlang_result_t
Definition interpret.h:133
RDEBUG3
#define RDEBUG3(fmt,...)
Definition log.h:343
RPEDEBUG
#define RPEDEBUG(fmt,...)
Definition log.h:376
talloc_free
talloc_free(reap)
fr_type_t
fr_type_t
Definition merged_model.c:80
FR_TYPE_INT8
@ FR_TYPE_INT8
8 Bit signed integer.
Definition merged_model.c:103
FR_TYPE_STRING
@ FR_TYPE_STRING
String of printable characters.
Definition merged_model.c:83
FR_TYPE_NULL
@ FR_TYPE_NULL
Invalid (uninitialised) attribute type.
Definition merged_model.c:81
FR_TYPE_UINT16
@ FR_TYPE_UINT16
16 Bit unsigned integer.
Definition merged_model.c:98
FR_TYPE_INT64
@ FR_TYPE_INT64
64 Bit signed integer.
Definition merged_model.c:106
FR_TYPE_INT16
@ FR_TYPE_INT16
16 Bit signed integer.
Definition merged_model.c:104
FR_TYPE_UINT8
@ FR_TYPE_UINT8
8 Bit unsigned integer.
Definition merged_model.c:97
FR_TYPE_UINT32
@ FR_TYPE_UINT32
32 Bit unsigned integer.
Definition merged_model.c:99
FR_TYPE_INT32
@ FR_TYPE_INT32
32 Bit signed integer.
Definition merged_model.c:105
FR_TYPE_UINT64
@ FR_TYPE_UINT64
64 Bit unsigned integer.
Definition merged_model.c:100
FR_TYPE_VOID
@ FR_TYPE_VOID
User data.
Definition merged_model.c:127
FR_TYPE_BOOL
@ FR_TYPE_BOOL
A truth value.
Definition merged_model.c:95
FR_TYPE_SIZE
@ FR_TYPE_SIZE
Unsigned integer capable of representing any memory address on the local system.
Definition merged_model.c:115
FR_TYPE_OCTETS
@ FR_TYPE_OCTETS
Raw octets.
Definition merged_model.c:84
FR_TYPE_GROUP
@ FR_TYPE_GROUP
A grouping of other attributes.
Definition merged_model.c:124
uint32_t
unsigned int uint32_t
Definition merged_model.c:33
ssize_t
long int ssize_t
Definition merged_model.c:24
fr_slen_t
ssize_t fr_slen_t
Definition merged_model.c:35
fr_dict_attr_t
Definition merged_model.c:133
fr_sbuff_escape_rules_t
Definition merged_model.c:228
fr_sbuff_t
Definition merged_model.c:37
fr_value_box_t
Definition merged_model.c:136
request_t
Definition merged_model.c:210
tmpl_t
Definition merged_model.c:225
fr_assert
#define fr_assert(_expr)
Definition rad_assert.h:38
done
static bool done
Definition radclient.c:81
REDEBUG
#define REDEBUG(fmt,...)
Definition radclient.h:52
RDEBUG
#define RDEBUG(fmt,...)
Definition radclient.h:53
rcode_table
fr_table_num_sorted_t const rcode_table[]
Definition rcode.c:35
rlm_rcode_t
rlm_rcode_t
Return codes indicating the result of the module call.
Definition rcode.h:40
RLM_MODULE_NOT_SET
@ RLM_MODULE_NOT_SET
Error resolving rcode (should not be returned by modules).
Definition rcode.h:52
RLM_MODULE_NUMCODES
@ RLM_MODULE_NUMCODES
How many valid return codes there are.
Definition rcode.h:51
name
static char const * name
Definition rlm_redis_ippool_tool.c:156
fr_sbuff_is_terminal
bool fr_sbuff_is_terminal(fr_sbuff_t *in, fr_sbuff_term_t const *tt)
Efficient terminal string search.
Definition sbuff.c:2185
fr_sbuff_terminals_amerge
fr_sbuff_term_t * fr_sbuff_terminals_amerge(TALLOC_CTX *ctx, fr_sbuff_term_t const *a, fr_sbuff_term_t const *b)
Merge two sets of terminal strings.
Definition sbuff.c:647
fr_sbuff_next_if_char
bool fr_sbuff_next_if_char(fr_sbuff_t *sbuff, char c)
Return true if the current char matches, and if it does, advance.
Definition sbuff.c:2121
fr_sbuff_start
#define fr_sbuff_start(_sbuff_or_marker)
fr_sbuff_out_by_longest_prefix
#define fr_sbuff_out_by_longest_prefix(_match_len, _out, _table, _sbuff, _def)
fr_sbuff_is_str_literal
#define fr_sbuff_is_str_literal(_sbuff, _str)
FR_SBUFF_IN_CHAR_RETURN
#define FR_SBUFF_IN_CHAR_RETURN(_sbuff,...)
fr_sbuff_set
#define fr_sbuff_set(_dst, _src)
fr_sbuff_diff
#define fr_sbuff_diff(_a, _b)
fr_sbuff_adv_past_whitespace
#define fr_sbuff_adv_past_whitespace(_sbuff, _len, _tt)
fr_sbuff_current
#define fr_sbuff_current(_sbuff_or_marker)
fr_sbuff_char
#define fr_sbuff_char(_sbuff_or_marker, _eob)
FR_SBUFF_TERMS
#define FR_SBUFF_TERMS(...)
Initialise a terminal structure with a list of sorted strings.
Definition sbuff.h:192
FR_SBUFF_IN_STRCPY_LITERAL_RETURN
#define FR_SBUFF_IN_STRCPY_LITERAL_RETURN(_sbuff, _str)
fr_sbuff_extend
#define fr_sbuff_extend(_sbuff_or_marker)
fr_sbuff_used_total
#define fr_sbuff_used_total(_sbuff_or_marker)
FR_SBUFF_RETURN
#define FR_SBUFF_RETURN(_func, _sbuff,...)
fr_sbuff_is_char
#define fr_sbuff_is_char(_sbuff_or_marker, _c)
FR_SBUFF_ERROR_RETURN
#define FR_SBUFF_ERROR_RETURN(_sbuff_or_marker)
FR_SBUFF_SET_RETURN
#define FR_SBUFF_SET_RETURN(_dst, _src)
fr_sbuff_is_digit
#define fr_sbuff_is_digit(_sbuff_or_marker)
FR_SBUFF
#define FR_SBUFF(_sbuff_or_marker)
fr_sbuff_advance
#define fr_sbuff_advance(_sbuff_or_marker, _len)
fr_sbuff_remaining
#define fr_sbuff_remaining(_sbuff_or_marker)
fr_sbuff_used
#define fr_sbuff_used(_sbuff_or_marker)
fr_sbuff_behind
#define fr_sbuff_behind(_sbuff_or_marker)
FR_SBUFF_IN_STRCPY_RETURN
#define FR_SBUFF_IN_STRCPY_RETURN(...)
FR_SBUFF_TALLOC_THREAD_LOCAL
#define FR_SBUFF_TALLOC_THREAD_LOCAL(_out, _init, _max)
fr_sbuff_ptr_s
Definition sbuff.h:84
fr_sbuff_term_elem_t
Terminal element with pre-calculated lengths.
Definition sbuff.h:161
fr_sbuff_term_t
Set of terminal elements.
Definition merged_model.c:161
tmpl_contains_xlat
#define tmpl_contains_xlat(vpt)
Definition tmpl.h:227
tmpl_is_attr_unresolved
#define tmpl_is_attr_unresolved(vpt)
Definition tmpl.h:219
tmpl_resolve
int tmpl_resolve(tmpl_t *vpt, tmpl_res_rules_t const *tr_rules))
Attempt to resolve functions and attributes in xlats and attribute references.
Definition tmpl_tokenize.c:4203
tmpl_value
#define tmpl_value(_tmpl)
Definition tmpl.h:937
tmpl_contains_regex
#define tmpl_contains_regex(vpt)
Definition tmpl.h:226
tmpl_is_attr
#define tmpl_is_attr(vpt)
Definition tmpl.h:208
tmpl_rules_s::enumv
fr_dict_attr_t const * enumv
Enumeration attribute used to resolve enum values.
Definition tmpl.h:338
tmpl_xlat
#define tmpl_xlat(_tmpl)
Definition tmpl.h:930
tmpl_rules_cast
#define tmpl_rules_cast(_tmpl)
Definition tmpl.h:942
tmpl_contains_attr
#define tmpl_contains_attr(vpt)
Definition tmpl.h:225
tmpl_afrom_substr
ssize_t tmpl_afrom_substr(TALLOC_CTX *ctx, tmpl_t **out, fr_sbuff_t *in, fr_token_t quote, fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules))
Convert an arbitrary string into a tmpl_t.
Definition tmpl_tokenize.c:3155
tmpl_rules_s::xlat
tmpl_xlat_rules_t xlat
Rules/data for parsing xlats.
Definition tmpl.h:336
tmpl_is_list
static bool tmpl_is_list(tmpl_t const *vpt)
Definition tmpl.h:920
tmpl_cast_in_place
int tmpl_cast_in_place(tmpl_t *vpt, fr_type_t type, fr_dict_attr_t const *enumv))
Convert tmpl_t of type TMPL_TYPE_DATA_UNRESOLVED or TMPL_TYPE_DATA to TMPL_TYPE_DATA of type specifie...
Definition tmpl_tokenize.c:3894
tmpl_is_data
#define tmpl_is_data(vpt)
Definition tmpl.h:206
tmpl_debug
void tmpl_debug(tmpl_t const *vpt)
Definition tmpl_tokenize.c:310
vpt
static fr_slen_t vpt
Definition tmpl.h:1269
tmpl_value_type
#define tmpl_value_type(_tmpl)
Definition tmpl.h:939
tmpl_cast_get
static fr_type_t tmpl_cast_get(tmpl_t *vpt)
Definition tmpl.h:1218
tmpl_is_data_unresolved
#define tmpl_is_data_unresolved(vpt)
Definition tmpl.h:217
tmpl_rules_s::cast
fr_type_t cast
Whether there was an explicit cast.
Definition tmpl.h:340
tmpl_rules_s::attr
tmpl_attr_rules_t attr
Rules/data for parsing attribute references.
Definition tmpl.h:335
tmpl_attr_tail_da
static fr_dict_attr_t const * tmpl_attr_tail_da(tmpl_t const *vpt)
Return the last attribute reference da.
Definition tmpl.h:801
tmpl_res_rules_t
struct tmpl_res_rules_s tmpl_res_rules_t
Definition tmpl.h:237
tmpl_is_regex
#define tmpl_is_regex(vpt)
Definition tmpl.h:213
tmpl_res_rules_s::enumv
fr_dict_attr_t const * enumv
for resolving T_BARE_WORD
Definition tmpl.h:373
tmpl_xlat_rules_s::runtime_el
fr_event_list_t * runtime_el
The eventlist to use for runtime instantiation of xlats.
Definition tmpl.h:324
tmpl_needs_resolving
#define tmpl_needs_resolving(vpt)
Definition tmpl.h:223
tmpl_cast_set
int tmpl_cast_set(tmpl_t *vpt, fr_type_t type)
Set a cast for a tmpl.
Definition tmpl_tokenize.c:3707
tmpl_res_rules_s
Similar to tmpl_rules_t, but used to specify parameters that may change during subsequent resolution ...
Definition tmpl.h:364
tmpl_rules_s
Optional arguments passed to vp_tmpl functions.
Definition tmpl.h:332
xor
static void xor(char *out, char *in1, char *in2, int n)
Definition smbdes.c:183
lshift
static void lshift(char *d, int count, int n)
Definition smbdes.c:165
inst
eap_aka_sim_process_conf_t * inst
Definition state_machine.c:3651
type
fr_aka_sim_id_type_t type
Definition state_machine.c:3654
vp
fr_pair_t * vp
Definition state_machine.c:2293
tmpl_attr_rules_s::allow_unresolved
uint8_t allow_unresolved
Allow attributes that look valid but were not found in the dictionaries.
Definition tmpl.h:304
tmpl_attr_rules_s::dict_def
fr_dict_t const * dict_def
Default dictionary to use with unqualified attribute references.
Definition tmpl.h:273
value_pair_s
Stores an attribute, a value and various bits of other data.
Definition pair.h:68
fr_table_value_by_str
#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
fr_table_str_by_value
#define fr_table_str_by_value(_table, _number, _def)
Convert an integer to a string.
Definition table.h:772
fr_table_num_ordered_t
An element in an arbitrarily ordered array of name to num mappings.
Definition table.h:57
fr_table_num_sorted_t
An element in a lexicographically sorted array of name to num mappings.
Definition table.h:49
talloc_get_type_abort_const
#define talloc_get_type_abort_const
Definition talloc.h:287
talloc_const_free
static int talloc_const_free(void const *ptr)
Free const'd memory.
Definition talloc.h:229
tmpl_dcursor_clear
void tmpl_dcursor_clear(tmpl_dcursor_ctx_t *cc)
Clear any temporary state allocations.
Definition tmpl_dcursor.c:458
tmpl_dcursor_init
#define tmpl_dcursor_init(_err, _ctx, _cc, _cursor, _request, _vpt)
Definition tmpl_dcursor.h:100
tmpl_dcursor_ctx_s
Maintains state between cursor calls.
Definition tmpl_dcursor.h:62
fr_token_quote
const char fr_token_quote[T_TOKEN_LAST]
Convert tokens back to a quoting character.
Definition token.c:157
fr_tokens
char const * fr_tokens[T_TOKEN_LAST]
Definition token.c:79
fr_comparison_op
const bool fr_comparison_op[T_TOKEN_LAST]
Definition token.c:199
fr_binary_op
const bool fr_binary_op[T_TOKEN_LAST]
Definition token.c:217
fr_token_t
enum fr_token fr_token_t
T_AND
@ T_AND
Definition token.h:55
T_INVALID
@ T_INVALID
Definition token.h:39
T_SUB
@ T_SUB
Definition token.h:52
T_RSHIFT
@ T_RSHIFT
Definition token.h:62
T_NOT
@ T_NOT
Definition token.h:57
T_XOR
@ T_XOR
Definition token.h:58
T_DIV
@ T_DIV
Definition token.h:54
T_SINGLE_QUOTED_STRING
@ T_SINGLE_QUOTED_STRING
Definition token.h:122
T_MOD
@ T_MOD
Definition token.h:60
T_BARE_WORD
@ T_BARE_WORD
Definition token.h:120
T_OP_EQ
@ T_OP_EQ
Definition token.h:83
T_LAND
@ T_LAND
Definition token.h:91
T_COMPLEMENT
@ T_COMPLEMENT
Definition token.h:59
T_ADD
@ T_ADD
Definition token.h:51
T_BACK_QUOTED_STRING
@ T_BACK_QUOTED_STRING
Definition token.h:123
T_OP_NE
@ T_OP_NE
Definition token.h:97
T_LOR
@ T_LOR
Definition token.h:92
T_LSHIFT
@ T_LSHIFT
Definition token.h:63
T_OP_REG_EQ
@ T_OP_REG_EQ
Definition token.h:102
T_OP_CMP_EQ_TYPE
@ T_OP_CMP_EQ_TYPE
Definition token.h:107
T_DOUBLE_QUOTED_STRING
@ T_DOUBLE_QUOTED_STRING
Definition token.h:121
T_OP_CMP_EQ
@ T_OP_CMP_EQ
Definition token.h:106
T_LBRACE
@ T_LBRACE
Definition token.h:43
T_MUL
@ T_MUL
Definition token.h:53
T_OP_LE
@ T_OP_LE
Definition token.h:100
T_OP_CMP_NE_TYPE
@ T_OP_CMP_NE_TYPE
Definition token.h:108
T_OP_GE
@ T_OP_GE
Definition token.h:98
T_OP_GT
@ T_OP_GT
Definition token.h:99
T_SOLIDUS_QUOTED_STRING
@ T_SOLIDUS_QUOTED_STRING
Definition token.h:124
T_OP_LT
@ T_OP_LT
Definition token.h:101
T_OP_REG_NE
@ T_OP_REG_NE
Definition token.h:103
T_OR
@ T_OR
Definition token.h:56
T_TOKEN_LAST
#define T_TOKEN_LAST
Definition token.h:129
unlang_xlat_yield
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
unlang_xlat_push
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
xlat_res_rules_t::tr_rules
tmpl_res_rules_t const * tr_rules
tmpl resolution rules.
Definition xlat.h:165
xlat_arg_parser_t::type
fr_type_t type
Type to cast argument to.
Definition xlat.h:155
xlat_print
fr_slen_t xlat_print(fr_sbuff_t *in, xlat_exp_head_t const *node, fr_sbuff_escape_rules_t const *e_rules)
Reconstitute an xlat expression from its constituent nodes.
Definition xlat_tokenize.c:1317
head
static fr_slen_t head
Definition xlat.h:420
XLAT_RESULT_SUCCESS
#define XLAT_RESULT_SUCCESS(_p_result)
Definition xlat.h:503
xlat_aprint
static fr_slen_t xlat_aprint(TALLOC_CTX *ctx, char **out, xlat_exp_head_t const *head, fr_sbuff_escape_rules_t const *e_rules) 1(xlat_print
xlat_arg_parser_t::required
uint8_t required
Argument must be present, and non-empty.
Definition xlat.h:146
xlat_purify_op
int xlat_purify_op(TALLOC_CTX *ctx, xlat_exp_t **out, xlat_exp_t *lhs, fr_token_t op, xlat_exp_t *rhs)
Definition xlat_purify.c:537
xlat_func_t
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
XLAT_ARGS
#define XLAT_ARGS(_list,...)
Populate local variables with value boxes from the input list.
Definition xlat.h:383
xlat_flatten_to_argv
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:1849
xlat_arg_parser_t::concat
uint8_t concat
Concat boxes together.
Definition xlat.h:147
xlat_flags_t::needs_resolving
uint8_t needs_resolving
Needs pass2 resolution.
Definition xlat.h:109
XLAT_VERIFY
#define XLAT_VERIFY(_node)
Definition xlat.h:466
xlat_flags_t::can_purify
uint8_t can_purify
if the xlat has a pure function with pure arguments.
Definition xlat.h:112
xlat_flags_t::pure
uint8_t pure
has no external side effects, true for BOX, LITERAL, and some functions
Definition xlat.h:110
xlat_resolve
int xlat_resolve(xlat_exp_head_t *head, xlat_res_rules_t const *xr_rules)
Walk over an xlat tree recursively, resolving any unresolved functions or references.
Definition xlat_tokenize.c:1957
XLAT_ARG_PARSER_TERMINATOR
#define XLAT_ARG_PARSER_TERMINATOR
Definition xlat.h:170
xlat_finalize
int xlat_finalize(xlat_exp_head_t *head, fr_event_list_t *runtime_el)
Bootstrap static xlats, or instantiate ephemeral ones.
Definition xlat_inst.c:693
xlat_action_t
xlat_action_t
Definition xlat.h:37
XLAT_ACTION_FAIL
@ XLAT_ACTION_FAIL
An xlat function failed.
Definition xlat.h:44
XLAT_ACTION_YIELD
@ XLAT_ACTION_YIELD
An xlat function pushed a resume frame onto the stack.
Definition xlat.h:42
XLAT_ACTION_PUSH_UNLANG
@ XLAT_ACTION_PUSH_UNLANG
An xlat function pushed an unlang frame onto the unlang stack.
Definition xlat.h:39
XLAT_ACTION_DONE
@ XLAT_ACTION_DONE
We're done evaluating this level of nesting.
Definition xlat.h:43
xlat_flags_t::constant
uint8_t constant
xlat is just tmpl_attr_tail_data, or XLAT_BOX
Definition xlat.h:114
xlat_instance_unregister_func
int xlat_instance_unregister_func(xlat_exp_t *node)
Remove a node from the list of xlat instance data.
Definition xlat_inst.c:548
xlat_arg_parser_t
Definition for a single argument consumend by an xlat function.
Definition xlat.h:145
xlat_flags_t
Flags that control resolution and evaluation.
Definition xlat.h:108
xlat_res_rules_t
Definition xlat.h:164
parent
static fr_slen_t parent
Definition pair.h:839
fr_strerror_printf
#define fr_strerror_printf(_fmt,...)
Log to thread local error buffer.
Definition strerror.h:64
fr_strerror_const
#define fr_strerror_const(_msg)
Definition strerror.h:223
fr_type_table
fr_table_num_ordered_t const fr_type_table[]
Map data types to names representing those types.
Definition types.c:31
fr_type_is_variable_size
#define fr_type_is_variable_size(_x)
Definition types.h:384
fr_type_is_structural
#define fr_type_is_structural(_x)
Definition types.h:388
fr_type_is_null
#define fr_type_is_null(_x)
Definition types.h:343
fr_type_is_leaf
#define fr_type_is_leaf(_x)
Definition types.h:389
fr_type_to_str
static char const * fr_type_to_str(fr_type_t type)
Return a static string containing the type name.
Definition types.h:450
fr_value_box_list_concat_as_string
ssize_t fr_value_box_list_concat_as_string(fr_value_box_t *safety, fr_sbuff_t *sbuff, fr_value_box_list_t *list, char const *sep, size_t sep_len, fr_sbuff_escape_rules_t const *e_rules, fr_value_box_list_action_t proc_action, fr_value_box_safe_for_t safe_for, bool flatten)
Concatenate a list of value boxes together.
Definition value.c:5733
value_parse_rules_quoted
fr_sbuff_parse_rules_t const * value_parse_rules_quoted[T_TOKEN_LAST]
Parse rules for quoted strings.
Definition value.c:605
fr_value_box_copy
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
fr_value_box_is_truthy
bool fr_value_box_is_truthy(fr_value_box_t const *in)
Check truthiness of values.
Definition value.c:6587
fr_value_box_cast_in_place
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
fr_value_box_memdup_shallow
void fr_value_box_memdup_shallow(fr_value_box_t *dst, fr_dict_attr_t const *enumv, uint8_t const *src, size_t len, bool tainted)
Assign a buffer to a box, but don't copy it.
Definition value.c:4700
fr_value_box_strdup
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
fr_value_box_strdup_shallow
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:4267
fr_value_box_safety_copy
void fr_value_box_safety_copy(fr_value_box_t *out, fr_value_box_t const *in)
Copy the safety values from one box to another.
Definition value.c:6527
fr_value_box_clear
void fr_value_box_clear(fr_value_box_t *data)
Clear/free any existing value and metadata.
Definition value.c:3945
fr_value_box_bstrndup
int fr_value_box_bstrndup(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, size_t len, bool tainted)
Copy a string to to a fr_value_box_t.
Definition value.c:4379
FR_VALUE_BOX_LIST_FREE_BOX
@ FR_VALUE_BOX_LIST_FREE_BOX
Free each processed box.
Definition value.h:234
fr_value_box_alloc
#define fr_value_box_alloc(_ctx, _type, _enumv)
Allocate a value box of a specific type.
Definition value.h:640
fr_value_box_mark_safe_for
#define fr_value_box_mark_safe_for(_box, _safe_for)
Definition value.h:1071
fr_box_strvalue_len
#define fr_box_strvalue_len(_val, _len)
Definition value.h:305
VALUE_BOX_LIST_VERIFY
#define VALUE_BOX_LIST_VERIFY(_x)
Definition value.h:1319
nonnull
int nonnull(2, 5))
fr_value_box_alloc_null
#define fr_value_box_alloc_null(_ctx)
Allocate a value box for later use with a value assignment function.
Definition value.h:651
fr_value_box_init
#define fr_value_box_init(_vb, _type, _enumv, _tainted)
Initialise a fr_value_box_t.
Definition value.h:606
fr_value_box_list_foreach
#define fr_value_box_list_foreach(_list_head, _iter)
Definition value.h:222
out
static size_t char ** out
Definition value.h:1020
FR_VALUE_BOX_SAFE_FOR_ANY
#define FR_VALUE_BOX_SAFE_FOR_ANY
Definition value.h:171
xlat_exp_set_vpt
void xlat_exp_set_vpt(xlat_exp_t *node, tmpl_t *vpt)
Set the tmpl for a node, along with flags and the name.
Definition xlat_alloc.c:252
xlat_exp_set_name
void xlat_exp_set_name(xlat_exp_t *node, char const *fmt, size_t len)
Set the format string for an xlat node.
Definition xlat_alloc.c:308
xlat_exp_set_func
void xlat_exp_set_func(xlat_exp_t *node, xlat_t const *func, fr_dict_t const *dict)
Set the function for a node.
Definition xlat_alloc.c:274
xlat_exp_set_name_shallow
void xlat_exp_set_name_shallow(xlat_exp_t *node, char const *fmt)
Set the format string for an xlat node from a pre-existing buffer.
Definition xlat_alloc.c:338
xlat_ctx_s::rctx
void * rctx
Resume context.
Definition xlat_ctx.h:54
xlat_inst_ctx_s::ex
xlat_exp_t * ex
Tokenized expression to use in expansion.
Definition xlat_ctx.h:64
xlat_ctx_s::inst
void const * inst
xlat instance data.
Definition xlat_ctx.h:50
xlat_inst_ctx_s::inst
void * inst
xlat instance data to populate.
Definition xlat_ctx.h:63
xlat_ctx_s
An xlat calling ctx.
Definition xlat_ctx.h:49
xlat_inst_ctx_s
An xlat instantiation ctx.
Definition xlat_ctx.h:62
attr_expr_bool_enum
fr_dict_attr_t const * attr_expr_bool_enum
Definition xlat_eval.c:44
attr_cast_base
fr_dict_attr_t const * attr_cast_base
Definition xlat_eval.c:45
xlat_func_regex_search
static xlat_action_t xlat_func_regex_search(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *in)
Definition xlat_expr.c:836
xlat_exists_inst_t::vpt
tmpl_t const * vpt
the attribute reference
Definition xlat_expr.c:1692
fr_sbuff_skip_whitespace
#define fr_sbuff_skip_whitespace(_x)
Definition xlat_expr.c:2032
expr_assignment_op_table_len
static size_t const expr_assignment_op_table_len
Definition xlat_expr.c:2696
xlat_expr_print_binary
static fr_slen_t xlat_expr_print_binary(fr_sbuff_t *out, xlat_exp_t const *node, UNUSED void *inst, fr_sbuff_escape_rules_t const *e_rules)
Definition xlat_expr.c:151
XLAT_REGISTER_BOOL
#define XLAT_REGISTER_BOOL(_xlat, _func, _arg, _ret_type)
Definition xlat_expr.c:1836
xlat_logical_inst_t::argc
int argc
Definition xlat_expr.c:868
xlat_expr_print_rcode
static fr_slen_t xlat_expr_print_rcode(fr_sbuff_t *out, xlat_exp_t const *node, void *instance, UNUSED fr_sbuff_escape_rules_t const *e_rules)
Definition xlat_expr.c:1586
xlat_func_append_arg
static void xlat_func_append_arg(xlat_exp_t *head, xlat_exp_t *node, bool exists)
Definition xlat_expr.c:70
xlat_is_truthy
bool xlat_is_truthy(xlat_exp_head_t const *head, bool *out)
Allow callers to see if an xlat is truthy.
Definition xlat_expr.c:3187
xlat_func_logical
static xlat_action_t xlat_func_logical(TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *in)
Process logical &&, ||.
Definition xlat_expr.c:1383
xlat_regex_inst_t::xlat
xlat_exp_t * xlat
to expand
Definition xlat_expr.c:512
XLAT_BINARY_FUNC
#define XLAT_BINARY_FUNC(_name, _op)
Definition xlat_expr.c:373
bracket_terms
static const fr_sbuff_term_t bracket_terms
Definition xlat_expr.c:3023
expr_quote_table_len
static size_t expr_quote_table_len
Definition xlat_expr.c:2056
xlat_instantiate_exists
static int xlat_instantiate_exists(xlat_inst_ctx_t const *xctx)
Definition xlat_expr.c:1720
xlat_expr_print_nary
static fr_slen_t xlat_expr_print_nary(fr_sbuff_t *out, xlat_exp_t const *node, void *instance, fr_sbuff_escape_rules_t const *e_rules)
Definition xlat_expr.c:880
xlat_register_expressions
int xlat_register_expressions(void)
Definition xlat_expr.c:1852
xlat_func_exists_arg
static xlat_arg_parser_t const xlat_func_exists_arg[]
Definition xlat_expr.c:1695
xlat_logical_process_arg
static xlat_action_t xlat_logical_process_arg(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out, xlat_ctx_t const *xctx, request_t *request, UNUSED fr_value_box_list_t *in)
Process one argument of a logical operation.
Definition xlat_expr.c:1129
xlat_tokenize_expression_internal
static fr_slen_t xlat_tokenize_expression_internal(TALLOC_CTX *ctx, xlat_exp_head_t **out, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules, bool cond)
Definition xlat_expr.c:3048
xlat_expr_print_unary
static fr_slen_t xlat_expr_print_unary(fr_sbuff_t *out, xlat_exp_t const *node, UNUSED void *inst, fr_sbuff_escape_rules_t const *e_rules)
Definition xlat_expr.c:141
P
#define P(_x, _y)
Definition xlat_expr.c:1976
regex_op_xlat_args
static xlat_arg_parser_t const regex_op_xlat_args[]
Definition xlat_expr.c:629
xlat_ungroup
static void xlat_ungroup(xlat_exp_head_t *head)
Undo work which shouldn't have been done.
Definition xlat_expr.c:976
xlat_func_unary_complement
static xlat_action_t xlat_func_unary_complement(TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *in)
Definition xlat_expr.c:1491
xlat_cmp_op
static xlat_action_t xlat_cmp_op(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, fr_value_box_list_t *in, fr_token_t op)
Definition xlat_expr.c:447
precedence
static const int precedence[T_TOKEN_LAST]
Definition xlat_expr.c:1978
xlat_func_unary_minus
static xlat_action_t xlat_func_unary_minus(TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *in)
Definition xlat_expr.c:1484
xlat_logical_or_resume
static xlat_action_t xlat_logical_or_resume(TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *in)
Definition xlat_expr.c:1208
xlat_logical_rctx_t::last_result
unlang_result_t last_result
Definition xlat_expr.c:874
expr_quote_table
static fr_table_num_sorted_t const expr_quote_table[]
Definition xlat_expr.c:2050
XLAT_REGISTER_BINARY_OP
#define XLAT_REGISTER_BINARY_OP(_op, _name)
Definition xlat_expr.c:1794
XLAT_REGEX_FUNC
#define XLAT_REGEX_FUNC(_name, _op)
Definition xlat_expr.c:825
xlat_binary_op
static xlat_action_t xlat_binary_op(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *in, fr_token_t op, fr_type_t default_type, fr_dict_attr_t const *enumv)
Definition xlat_expr.c:302
valid_type
static bool valid_type(xlat_exp_t *node)
Definition xlat_expr.c:2698
xlat_logical_and
static bool xlat_logical_and(xlat_logical_rctx_t *rctx, fr_value_box_list_t const *in)
See if the input is truthy or not.
Definition xlat_expr.c:1265
xlat_logical_rctx_t::box
fr_value_box_t * box
output value-box
Definition xlat_expr.c:875
xlat_logical_inst_t::stop_on_match
bool stop_on_match
Definition xlat_expr.c:866
XLAT_DEBUG
#define XLAT_DEBUG(...)
Definition xlat_expr.c:38
xlat_regex_rctx_t::list
fr_value_box_list_t list
Definition xlat_expr.c:518
xlat_regex_op
static xlat_action_t xlat_regex_op(TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *in, fr_token_t op)
Definition xlat_expr.c:792
xlat_func_unary_not
static xlat_action_t xlat_func_unary_not(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, fr_value_box_list_t *in)
Definition xlat_expr.c:1457
xlat_regex_inst_t::regex_flags
fr_regex_flags_t * regex_flags
Definition xlat_expr.c:513
xlat_node_matches_bool
static bool xlat_node_matches_bool(bool *result, xlat_exp_t *parent, xlat_exp_head_t *head, bool sense)
Definition xlat_expr.c:928
xlat_instantiate_regex
static int xlat_instantiate_regex(xlat_inst_ctx_t const *xctx)
Definition xlat_expr.c:585
xlat_func_unary_op
static xlat_action_t xlat_func_unary_op(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *in, fr_token_t op)
Definition xlat_expr.c:1413
xlat_expr_resolve_binary
static int xlat_expr_resolve_binary(xlat_exp_t *node, UNUSED void *inst, xlat_res_rules_t const *xr_rules)
Definition xlat_expr.c:174
logical_ops
static const bool logical_ops[T_TOKEN_LAST]
Definition xlat_expr.c:1952
xlat_logical_inst_t::callback
xlat_func_t callback
Definition xlat_expr.c:867
binary_op_xlat_args
static xlat_arg_parser_t const binary_op_xlat_args[]
Definition xlat_expr.c:296
xlat_attr_exists
static xlat_action_t xlat_attr_exists(TALLOC_CTX *ctx, fr_dcursor_t *out, request_t *request, tmpl_t const *vpt, bool do_free)
Definition xlat_expr.c:1751
binary_cmp_xlat_args
static xlat_arg_parser_t const binary_cmp_xlat_args[]
Definition xlat_expr.c:392
multivalue_ops
static const bool multivalue_ops[T_TOKEN_LAST]
Definition xlat_expr.c:1965
tokenize_unary
static fr_slen_t tokenize_unary(xlat_exp_head_t *head, xlat_exp_t **out, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules, fr_sbuff_parse_rules_t const *bracket_rules, char *out_c, bool cond))
Definition xlat_expr.c:2072
binary_ops
static const fr_sbuff_term_elem_t binary_ops[T_TOKEN_LAST]
Definition xlat_expr.c:1920
xlat_logical_or
static bool xlat_logical_or(xlat_logical_rctx_t *rctx, fr_value_box_list_t const *in)
See if the input is truthy or not.
Definition xlat_expr.c:1166
xlat_logical_rctx_t::current
int current
Definition xlat_expr.c:876
xlat_regex_inst_t::op
fr_token_t op
Definition xlat_expr.c:510
xlat_logical_rctx_t::ctx
TALLOC_CTX * ctx
Definition xlat_expr.c:873
xlat_regex_inst_t::regex
regex_t * regex
precompiled regex
Definition xlat_expr.c:511
XLAT_REGISTER_NARY_OP
#define XLAT_REGISTER_NARY_OP(_op, _name, _func_name)
Definition xlat_expr.c:1815
xlat_instantiate_expr_rcode
static int xlat_instantiate_expr_rcode(xlat_inst_ctx_t const *xctx)
Convert static expr_rcode arguments into rcodes.
Definition xlat_expr.c:1514
fr_value_box_init_zero
static void fr_value_box_init_zero(fr_value_box_t *vb, fr_type_t type)
Definition xlat_expr.c:279
xlat_regex_resume
static xlat_action_t xlat_regex_resume(TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *in)
Definition xlat_expr.c:752
expr_assignment_op_table
static fr_table_num_ordered_t const expr_assignment_op_table[]
Definition xlat_expr.c:2664
xlat_exists_alloc
static xlat_exp_t * xlat_exists_alloc(TALLOC_CTX *ctx, xlat_exp_t *child)
Allocate a specific cast node.
Definition xlat_expr.c:112
expr_cast_alloc
static xlat_exp_t * expr_cast_alloc(TALLOC_CTX *ctx, fr_type_t type, xlat_exp_t *child)
Allocate a specific cast node.
Definition xlat_expr.c:2175
regex_search_xlat_args
static xlat_arg_parser_t const regex_search_xlat_args[]
Definition xlat_expr.c:635
expr_cast_from_substr
static fr_slen_t expr_cast_from_substr(fr_type_t *cast, fr_sbuff_t *in)
Definition xlat_expr.c:2212
tokenize_rcode
static ssize_t tokenize_rcode(xlat_exp_head_t *head, xlat_exp_t **out, fr_sbuff_t *in, fr_sbuff_term_t const *terminals)
Definition xlat_expr.c:2346
XLAT_REGISTER_BINARY_CMP
#define XLAT_REGISTER_BINARY_CMP(_op, _name)
Definition xlat_expr.c:1804
xlat_func_rcode_arg
static xlat_arg_parser_t const xlat_func_rcode_arg[]
Takes no arguments.
Definition xlat_expr.c:1658
xlat_expr_logical_purify
static int xlat_expr_logical_purify(xlat_exp_t *node, void *instance, request_t *request)
If any argument resolves to inst->stop_on_match, the entire thing is a bool of inst->stop_on_match.
Definition xlat_expr.c:1002
xlat_logical_rctx_t::list
fr_value_box_list_t list
Definition xlat_expr.c:877
xlat_rcode_inst_t::rcode
rlm_rcode_t rcode
The preparsed rcode.
Definition xlat_expr.c:1506
xlat_logical_inst_t::argv
xlat_exp_head_t ** argv
Definition xlat_expr.c:869
xlat_expr_print_exists
static fr_slen_t xlat_expr_print_exists(fr_sbuff_t *out, xlat_exp_t const *node, void *instance, fr_sbuff_escape_rules_t const *e_rules)
Definition xlat_expr.c:1703
xlat_instantiate_logical
static int xlat_instantiate_logical(xlat_inst_ctx_t const *xctx)
Definition xlat_expr.c:1363
XLAT_REGISTER_UNARY
#define XLAT_REGISTER_UNARY(_op, _xlat, _func)
Definition xlat_expr.c:1843
unary_op_xlat_args
static xlat_arg_parser_t const unary_op_xlat_args[]
Definition xlat_expr.c:1408
xlat_tokenize_expression
fr_slen_t xlat_tokenize_expression(TALLOC_CTX *ctx, xlat_exp_head_t **out, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules)
Definition xlat_expr.c:3124
xlat_func_expr_rcode_arg
static xlat_arg_parser_t const xlat_func_expr_rcode_arg[]
Definition xlat_expr.c:1498
tokenize_regex_rhs
static fr_slen_t tokenize_regex_rhs(xlat_exp_head_t *head, xlat_exp_t **out, fr_sbuff_t *in, tmpl_rules_t const *t_rules, fr_sbuff_parse_rules_t const *bracket_rules)
Definition xlat_expr.c:2252
xlat_expr_print_regex
static fr_slen_t xlat_expr_print_regex(fr_sbuff_t *out, xlat_exp_t const *node, void *instance, fr_sbuff_escape_rules_t const *e_rules)
Definition xlat_expr.c:521
operator_terms
static const fr_sbuff_term_t operator_terms
Definition xlat_expr.c:3028
XLAT_REGISTER_REGEX_OP
#define XLAT_REGISTER_REGEX_OP(_op, _name)
Definition xlat_expr.c:1826
xlat_logical_and_resume
static xlat_action_t xlat_logical_and_resume(TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *in)
Definition xlat_expr.c:1312
tokenize_expression
static ssize_t tokenize_expression(xlat_exp_head_t *head, xlat_exp_t **out, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules, fr_token_t prev, fr_sbuff_parse_rules_t const *bracket_rules, fr_sbuff_parse_rules_t const *input_rules, bool cond))
Tokenize a mathematical operation.
Definition xlat_expr.c:2737
XLAT_CMP_FUNC
#define XLAT_CMP_FUNC(_name, _op)
Definition xlat_expr.c:492
tokenize_field
static ssize_t tokenize_field(xlat_exp_head_t *head, xlat_exp_t **out, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules, fr_sbuff_parse_rules_t const *bracket_rules, char *out_c, bool cond))
Definition xlat_expr.c:2395
xlat_regex_rctx_t::last_result
unlang_result_t last_result
Definition xlat_expr.c:517
xlat_tokenize_condition
fr_slen_t xlat_tokenize_condition(TALLOC_CTX *ctx, xlat_exp_head_t **out, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules)
Definition xlat_expr.c:3152
xlat_regex_do_op
static xlat_action_t xlat_regex_do_op(TALLOC_CTX *ctx, request_t *request, fr_value_box_list_t *in, regex_t **preg, fr_dcursor_t *out, fr_token_t op)
Perform a regular expressions comparison between two operands.
Definition xlat_expr.c:663
xlat_exists_inst_t
Definition xlat_expr.c:1691
xlat_logical_inst_t
Definition xlat_expr.c:865
xlat_logical_rctx_t
Definition xlat_expr.c:872
xlat_rcode_inst_t
Holds the result of pre-parsing the rcode on startup.
Definition xlat_expr.c:1505
xlat_regex_inst_t
Definition xlat_expr.c:509
xlat_regex_rctx_t
Definition xlat_expr.c:516
xlat_func_flags_set
void xlat_func_flags_set(xlat_t *x, xlat_func_flags_t flags)
Specify flags that alter the xlat's behaviour.
Definition xlat_func.c:399
xlat_func_args_set
int xlat_func_args_set(xlat_t *x, xlat_arg_parser_t const args[])
Register the arguments of an xlat.
Definition xlat_func.c:363
xlat_func_register
xlat_t * xlat_func_register(TALLOC_CTX *ctx, char const *name, xlat_func_t func, fr_type_t return_type)
Register an xlat function.
Definition xlat_func.c:216
xlat_func_print_set
void xlat_func_print_set(xlat_t *xlat, xlat_print_t func)
Set a print routine for an xlat function.
Definition xlat_func.c:411
xlat_func_find
xlat_t * xlat_func_find(char const *in, ssize_t inlen)
Definition xlat_func.c:77
xlat_func_instantiate_set
#define xlat_func_instantiate_set(_xlat, _instantiate, _inst_struct, _detach, _uctx)
Set a callback for global instantiation of xlat functions.
Definition xlat_func.h:93
XLAT_FUNC_FLAG_PURE
@ XLAT_FUNC_FLAG_PURE
Definition xlat_func.h:38
XLAT_FUNC_FLAG_INTERNAL
@ XLAT_FUNC_FLAG_INTERNAL
Definition xlat_func.h:39
xlat_exp_head_alloc
#define xlat_exp_head_alloc(_ctx)
Definition xlat_priv.h:273
xlat_exp_s::flags
xlat_flags_t flags
Flags that control resolution and evaluation.
Definition xlat_priv.h:154
xlat_exp_next
static xlat_exp_t * xlat_exp_next(xlat_exp_head_t const *head, xlat_exp_t const *node)
Definition xlat_priv.h:246
xlat_exp_head_s::flags
xlat_flags_t flags
Flags that control resolution and evaluation.
Definition xlat_priv.h:190
xlat_tokenize_word
fr_slen_t xlat_tokenize_word(TALLOC_CTX *ctx, xlat_exp_t **out, fr_sbuff_t *in, fr_token_t quote, fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules)
Definition xlat_tokenize.c:1363
xlat_exp_s::quote
fr_token_t quote
Type of quoting around XLAT_GROUP types.
Definition xlat_priv.h:152
XLAT_BOX
@ XLAT_BOX
fr_value_box_t
Definition xlat_priv.h:108
XLAT_TMPL
@ XLAT_TMPL
xlat attribute
Definition xlat_priv.h:112
XLAT_FUNC
@ XLAT_FUNC
xlat module
Definition xlat_priv.h:110
XLAT_GROUP
@ XLAT_GROUP
encapsulated string of xlats
Definition xlat_priv.h:116
xlat_flags_merge
static void xlat_flags_merge(xlat_flags_t *parent, xlat_flags_t const *child)
Merge flags from child to parent.
Definition xlat_priv.h:229
xlat_exp_set_type
#define xlat_exp_set_type(_node, _type)
Definition xlat_priv.h:276
xlat_s::token
fr_token_t token
for expressions
Definition xlat_priv.h:70
xlat_exp_s::fmt
char const *_CONST fmt
The original format string (a talloced buffer).
Definition xlat_priv.h:151
xlat_print_node
ssize_t xlat_print_node(fr_sbuff_t *out, xlat_exp_head_t const *head, xlat_exp_t const *node, fr_sbuff_escape_rules_t const *e_rules, char c)
Definition xlat_tokenize.c:1119
xlat_purify_list
int xlat_purify_list(xlat_exp_head_t *head, request_t *request)
Definition xlat_purify.c:61
xlat_exp_s::type
xlat_type_t _CONST type
type of this expansion.
Definition xlat_priv.h:155
xlat_exp_alloc
#define xlat_exp_alloc(_ctx, _type, _in, _inlen)
Definition xlat_priv.h:282
xlat_s::flags
xlat_flags_t flags
various flags
Definition xlat_priv.h:92
xlat_exp_foreach
#define xlat_exp_foreach(_list_head, _iter)
Iterate over the contents of a list, only one level.
Definition xlat_priv.h:222
xlat_exp_insert_tail
static int xlat_exp_insert_tail(xlat_exp_head_t *head, xlat_exp_t *node)
Definition xlat_priv.h:238
xlat_exp_head
static xlat_exp_t * xlat_exp_head(xlat_exp_head_t const *head)
Definition xlat_priv.h:209
xlat_exp_head_s
Definition xlat_priv.h:188
xlat_exp_s
An xlat expansion node.
Definition xlat_priv.h:148
xlat_s
Definition xlat_priv.h:59
Generated by   doxygen 1.9.8