The FreeRADIUS server $Id: 15bac2a4c627c01d1aa2047687b3418955ac7f00 $
Loading...
Searching...
No Matches
tmpl_tokenize.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: 81b3c490bfb0c22ed4c096dd51a93c80626fbf0f $
19 *
20 * @brief #fr_pair_t template functions
21 * @file src/lib/server/tmpl_tokenize.c
22 *
23 * @ingroup AVP
24 *
25 * @copyright 2014-2020 The FreeRADIUS server project
26 */
27RCSID("$Id: 81b3c490bfb0c22ed4c096dd51a93c80626fbf0f $")
28
29#define _TMPL_PRIVATE 1
30
31#include <freeradius-devel/server/tmpl.h>
32#include <freeradius-devel/server/base.h>
33#include <freeradius-devel/protocol/freeradius/freeradius.internal.h>
34
35#include <freeradius-devel/util/base16.h>
36#include <freeradius-devel/util/skip.h>
37
38
39/*
40 * For xlat_exp_head_alloc(), because xlat_copy() doesn't create an output head.
41 */
42#include <freeradius-devel/unlang/xlat_priv.h>
43
44/** Define a global variable for specifying a default request reference
45 *
46 * @param[in] _name what the global variable should be called.
47 * @param[in] _ref one of the values of tmpl_request_ref_t
48 * - REQUEST_CURRENT
49 * - REQUEST_OUTER,
50 * - REQUEST_PARENT,
51 * - REQUEST_UNKNOWN
52 */
53#define TMPL_REQUEST_REF_DEF(_name, _ref) \
54static tmpl_request_t _name ## _entry = { \
55 .entry = { \
56 .entry = { \
57 .next = &_name.head.entry, \
58 .prev = &_name.head.entry \
59 } \
60 }, \
61 .request = _ref \
62}; \
63FR_DLIST_HEAD(tmpl_request_list) _name = { \
64 .head = { \
65 .offset = offsetof(tmpl_request_t, entry), \
66 .entry = { \
67 .next = &_name ## _entry.entry.entry, \
68 .prev = &_name ## _entry.entry.entry, \
69 }, \
70 .num_elements = 1, \
71 } \
72}
73
74/** Use the current request as the default
75 *
76 * Used as .attr.request_def = \&tmpl_request_def_current;
77 */
78TMPL_REQUEST_REF_DEF(tmpl_request_def_current, REQUEST_CURRENT);
79
80/** Use the outer request as the default
81 *
82 * Used as .attr.request_def = \&tmpl_request_def_outer;
83 */
84TMPL_REQUEST_REF_DEF(tmpl_request_def_outer, REQUEST_OUTER);
85
86/** Use the parent request as the default
87 *
88 * Used as .attr.request_def = \&tmpl_request_def_parent;
89 */
90TMPL_REQUEST_REF_DEF(tmpl_request_def_parent, REQUEST_PARENT);
91
92/** Default parser rules
93 *
94 * Because this is getting to be a ridiculous number of parsing rules
95 * to pass in via arguments.
96 *
97 * Defaults are used if a NULL rules pointer is passed to the parsing function.
98 */
99#define DEFAULT_RULES tmpl_rules_t default_rules = { .attr = { .list_def = request_attr_request }}
100
101#define CHECK_T_RULES do { \
102 if (!t_rules) { \
103 t_rules = &default_rules; \
104 } \
105 } while (0)
106
107
108/* clang-format off */
109/** Map #tmpl_type_t values to descriptive strings
110 */
111fr_table_num_ordered_t const tmpl_type_table[] = {
112 { L("uninitialised"), TMPL_TYPE_UNINITIALISED },
113
114 { L("data"), TMPL_TYPE_DATA },
115
116 { L("attr"), TMPL_TYPE_ATTR },
117
118 { L("exec"), TMPL_TYPE_EXEC },
119 { L("xlat"), TMPL_TYPE_XLAT },
120
121 { L("regex"), TMPL_TYPE_REGEX },
122 { L("regex-uncompiled"), TMPL_TYPE_REGEX_UNCOMPILED },
123 { L("regex-xlat"), TMPL_TYPE_REGEX_XLAT },
124
125 { L("data-unresolved"), TMPL_TYPE_DATA_UNRESOLVED },
126 { L("attr-unresolved"), TMPL_TYPE_ATTR_UNRESOLVED },
127 { L("exec-unresolved"), TMPL_TYPE_EXEC_UNRESOLVED },
128 { L("xlat-unresolved"), TMPL_TYPE_XLAT_UNRESOLVED },
129 { L("regex-unresolved"), TMPL_TYPE_REGEX_XLAT_UNRESOLVED }
130};
131size_t tmpl_type_table_len = NUM_ELEMENTS(tmpl_type_table);
132
133/** Attr ref types
134 */
135static fr_table_num_ordered_t const attr_table[] = {
136 { L("normal"), TMPL_ATTR_TYPE_NORMAL },
137 { L("unspecified"), TMPL_ATTR_TYPE_UNSPEC },
138 { L("unknown"), TMPL_ATTR_TYPE_UNKNOWN },
139 { L("unresolved"), TMPL_ATTR_TYPE_UNRESOLVED }
140};
141static size_t attr_table_len = NUM_ELEMENTS(attr_table);
142
143/** Map keywords to #tmpl_request_ref_t values
144 */
145fr_table_num_sorted_t const tmpl_request_ref_table[] = {
146 { L("current"), REQUEST_CURRENT },
147 { L("outer"), REQUEST_OUTER },
148 { L("parent"), REQUEST_PARENT },
149};
150size_t tmpl_request_ref_table_len = NUM_ELEMENTS(tmpl_request_ref_table);
151
152
153/** Special attribute reference indexes
154 */
155static fr_table_num_sorted_t const attr_num_table[] = {
156 { L("*"), NUM_ALL },
157 { L("#"), NUM_COUNT },
158 { L("u"), NUM_UNSPEC },
159 { L("n"), NUM_LAST }
160};
161static size_t attr_num_table_len = NUM_ELEMENTS(attr_num_table);
162/* clang-format on */
163
164static void attr_to_raw(tmpl_t *vpt, tmpl_attr_t *ref);
165
166/*
167 * Can't use |= or ^= else we get out of range errors
168 */
169#define UNRESOLVED_SET(_flags) (*(_flags) = (*(_flags) | TMPL_FLAG_UNRESOLVED))
170#define RESOLVED_SET(_flags) (*(_flags) = (*(_flags) & ~TMPL_FLAG_UNRESOLVED))
171
172/** Verify, after skipping whitespace, that a substring ends in a terminal char, or ends without further chars
173 *
174 * @param[in] in the sbuff to check.
175 * @param[in] p_rules to use terminals from.
176 * @return
177 * - true if substr is terminated correctly.
178 * - false if subst is not terminated correctly.
179 */
180static inline bool CC_HINT(always_inline) tmpl_substr_terminal_check(fr_sbuff_t *in,
181 fr_sbuff_parse_rules_t const *p_rules)
182{
183 fr_sbuff_marker_t m;
184 bool ret;
185
186 if (!fr_sbuff_extend(in)) return true; /* we're at the end of the string */
187 if (!p_rules || !p_rules->terminals) return false; /* more stuff to parse but don't have a terminal set */
188
189 fr_sbuff_marker(&m, in);
190 ret = fr_sbuff_is_terminal(in, p_rules->terminals);
191 fr_sbuff_set(in, &m);
192 fr_sbuff_marker_release(&m);
193 return ret;
194}
195
196void tmpl_attr_ref_debug(FILE *fp, const tmpl_attr_t *ar, int i)
197{
198 char buffer[sizeof(STRINGIFY(INT16_MAX)) + 1];
199
200 snprintf(buffer, sizeof(buffer), "%i", ar->ar_num);
201
202 switch (ar->type) {
203 case TMPL_ATTR_TYPE_NORMAL:
204 case TMPL_ATTR_TYPE_UNSPEC:
205 case TMPL_ATTR_TYPE_UNKNOWN:
206 if (!ar->da) {
207 fprintf(fp, "\t[%u] %s null%s%s%s\n",
208 i,
209 fr_table_str_by_value(attr_table, ar->type, "<INVALID>"),
210 ar->ar_num != NUM_UNSPEC ? "[" : "",
211 ar->ar_num != NUM_UNSPEC ? fr_table_str_by_value(attr_num_table, ar->ar_num, buffer) : "",
212 ar->ar_num != NUM_UNSPEC ? "]" : "");
213 return;
214 }
215
216 fprintf(fp, "\t[%u] %s %s %s%s%s%s (%p) attr %u\n ",
217 i,
218 fr_table_str_by_value(attr_table, ar->type, "<INVALID>"),
219 fr_type_to_str(ar->da->type),
220 ar->da->name,
221 ar->ar_num != NUM_UNSPEC ? "[" : "",
222 ar->ar_num != NUM_UNSPEC ? fr_table_str_by_value(attr_num_table, ar->ar_num, buffer) : "",
223 ar->ar_num != NUM_UNSPEC ? "]" : "",
224 ar->da,
225 ar->da->attr
226 );
227 fprintf(fp, "\t is_raw : %s\n", ar_is_raw(ar) ? "yes" : "no");
228 fprintf(fp, "\t is_unknown : %s", ar_is_unknown(ar) ? "yes" : "no");
229 if (ar->ar_parent) fprintf(fp, "\t parent : %s (%p)", ar->ar_parent->name, ar->ar_parent);
230 break;
231
232
233 case TMPL_ATTR_TYPE_UNRESOLVED:
234 /*
235 * Type reveals unresolved status
236 * so we don't need to add it explicitly
237 */
238 fprintf(fp, "\t[%u] %s %s%s%s%s\n",
239 i,
240 fr_table_str_by_value(attr_table, ar->type, "<INVALID>"),
241 ar->ar_unresolved,
242 ar->ar_num != NUM_UNSPEC ? "[" : "",
243 ar->ar_num != NUM_UNSPEC ? fr_table_str_by_value(attr_num_table, ar->ar_num, buffer) : "",
244 ar->ar_num != NUM_UNSPEC ? "]" : "");
245 if (ar->ar_parent) fprintf(fp, "\t parent : %s", ar->ar_parent->name);
246 if (ar->ar_unresolved_namespace) fprintf(fp, "\t namespace : %s", ar->ar_unresolved_namespace->name);
247 break;
248
249 default:
250 fprintf(fp, "\t[%u] Bad type %s(%u)",
251 i, fr_table_str_by_value(attr_table, ar->type, "<INVALID>"), ar->type);
252 break;
253 }
254}
255
256void tmpl_attr_ref_list_debug(FILE *fp, FR_DLIST_HEAD(tmpl_attr_list) const *ar_head)
257{
258 tmpl_attr_t *ar = NULL;
259 unsigned int i = 0;
260
261 fprintf(fp, "attribute references:\n");
262 /*
263 * Print all the attribute references
264 */
265 while ((ar = tmpl_attr_list_next(ar_head, ar))) {
266 tmpl_attr_ref_debug(fp, ar, i);
267 i++;
268 }
269}
270
271void tmpl_attr_debug(FILE *fp, tmpl_t const *vpt)
272{
273 tmpl_request_t *rr = NULL;
274 unsigned int i = 0;
275
276 switch (vpt->type) {
277 case TMPL_TYPE_ATTR:
278 case TMPL_TYPE_ATTR_UNRESOLVED:
279 break;
280
281 default:
282 fprintf(fp, "%s can't print tmpls of type %s\n", __FUNCTION__,
283 tmpl_type_to_str(vpt->type));
284 return;
285 }
286
287 fprintf(fp, "tmpl_t %s (%.8x) \"%pV\" (%p)\n",
288 tmpl_type_to_str(vpt->type),
289 vpt->type,
290 fr_box_strvalue_len(vpt->name, vpt->len), vpt);
291
292 fprintf(fp, "\tcast : %s\n", fr_type_to_str(tmpl_rules_cast(vpt)));
293 fprintf(fp, "\tquote : %s\n", fr_table_str_by_value(fr_token_quotes_table, vpt->quote, "<INVALID>"));
294
295 fprintf(fp, "request references:");
296
297 /*
298 * Print all the request references
299 */
300 while ((rr = tmpl_request_list_next(&vpt->data.attribute.rr, rr))) {
301 fprintf(fp, "\t[%u] %s (%u)\n", i,
302 fr_table_str_by_value(tmpl_request_ref_table, rr->request, "<INVALID>"), rr->request);
303 i++;
304 }
305
306 fprintf(fp, "list: %s\n", tmpl_list_name(tmpl_list(vpt), "<INVALID>"));
307 tmpl_attr_ref_list_debug(fp, tmpl_attr(vpt));
308}
309
310void tmpl_debug(FILE *fp, tmpl_t const *vpt)
311{
312 switch (vpt->type) {
313 case TMPL_TYPE_ATTR:
314 case TMPL_TYPE_ATTR_UNRESOLVED:
315 tmpl_attr_debug(fp, vpt);
316 return;
317
318 default:
319 break;
320 }
321
322 fprintf(fp, "tmpl_t %s (%.8x) \"%pR\" (%p)\n",
323 tmpl_type_to_str(vpt->type),
324 vpt->type,
325 vpt->name, vpt);
326
327 fprintf(fp, "\tcast : %s\n", fr_type_to_str(tmpl_rules_cast(vpt)));
328 fprintf(fp, "\tquote : %s\n", fr_table_str_by_value(fr_token_quotes_table, vpt->quote, "<INVALID>"));
329 switch (vpt->type) {
330 case TMPL_TYPE_DATA:
331 fprintf(fp, "\ttype : %s\n", fr_type_to_str(tmpl_value_type(vpt)));
332 fprintf(fp, "\tlen : %zu\n", tmpl_value_length(vpt));
333 fprintf(fp, "\tvalue : %pV\n", tmpl_value(vpt));
334
335 if (tmpl_value_enumv(vpt)) fprintf(fp, "\tenumv : %s (%p)",
336 tmpl_value_enumv(vpt)->name, tmpl_value_enumv(vpt));
337 return;
338
339 case TMPL_TYPE_XLAT:
340 case TMPL_TYPE_EXEC:
341 case TMPL_TYPE_REGEX_XLAT:
342 {
343 char *str;
344
345 xlat_aprint(NULL, &str, tmpl_xlat(vpt), NULL);
346
347 fprintf(fp, "\texpansion : %s\n", str);
348
349 talloc_free(str);
350 }
351 break;
352
353 case TMPL_TYPE_REGEX:
354 {
355 fprintf(fp, "\tpattern : %s\n", vpt->name);
356 }
357 break;
358
359 default:
360 if (tmpl_needs_resolving(vpt)) {
361 if (tmpl_is_data_unresolved(vpt)) {
362 fprintf(fp, "\tunescaped : %s\n", vpt->data.unescaped);
363 fprintf(fp, "\tlen : %zu\n", talloc_array_length(vpt->data.unescaped) - 1);
364 } else {
365 fprintf(fp, "\tunresolved : %s\n", vpt->name);
366 fprintf(fp, "\tlen : %zu\n", vpt->len);
367 }
368 } else {
369 fprintf(fp, "debug nyi\n");
370 }
371 break;
372 }
373}
374
375/** @name Parse list and request qualifiers to #fr_pair_list_t and #tmpl_request_ref_t values
376 *
377 * These functions also resolve #fr_pair_list_t and #tmpl_request_ref_t values to #request_t
378 * structs and the head of #fr_pair_t lists in those structs.
379 *
380 * For adding new #fr_pair_t to the lists, the #tmpl_list_ctx function can be used
381 * to obtain the appropriate TALLOC_CTX pointer.
382 *
383 * @note These don't really have much to do with #tmpl_t. They're in the same
384 * file as they're used almost exclusively by the tmpl_* functions.
385 * @{
386 */
387
388/** Parse one a single list reference
389 *
390 * @param[out] da_p attribute representing a list.
391 * @param[in] in Sbuff to read request references from.
392 * @return
393 * - > 0 the number of bytes parsed.
394 * - 0 no list qualifier found.
395 */
396fr_slen_t tmpl_attr_list_from_substr(fr_dict_attr_t const **da_p, fr_sbuff_t *in)
397{
398 fr_dict_attr_t const *da;
399 fr_sbuff_t our_in = FR_SBUFF(in);
400
401 if (((fr_sbuff_adv_past_strcase(&our_in, request_attr_request->name, request_attr_request->name_len)) &&
402 (da = request_attr_request)) ||
403 ((fr_sbuff_adv_past_strcase(&our_in, request_attr_reply->name, request_attr_reply->name_len)) &&
404 (da = request_attr_reply)) ||
405 ((fr_sbuff_adv_past_strcase(&our_in, request_attr_control->name, request_attr_control->name_len)) &&
406 (da = request_attr_control)) ||
407 ((fr_sbuff_adv_past_strcase(&our_in, request_attr_state->name, request_attr_state->name_len)) &&
408 (da = request_attr_state))) {
409 /* note: no local variables */
410 *da_p = da;
411 FR_SBUFF_SET_RETURN(in, &our_in);
412 }
413
414 return 0;
415}
416
417 /** Allocate a new request reference and add it to the end of the attribute reference list
418 *
419 */
420static inline CC_HINT(always_inline) CC_HINT(nonnull(2,3))
421void tmpl_request_ref_list_copy(TALLOC_CTX *ctx,
422 FR_DLIST_HEAD(tmpl_request_list) *out, FR_DLIST_HEAD(tmpl_request_list) const *in)
423{
424 tmpl_request_t *rr = NULL;
425 tmpl_request_t *n_rr = NULL;
426
427 /*
428 * Duplicate the complete default list
429 */
430 while ((rr = tmpl_request_list_next(in, rr))) {
431 MEM(n_rr = talloc(ctx, tmpl_request_t));
432 *n_rr = (tmpl_request_t){
433 .request = rr->request
434 };
435 tmpl_request_list_insert_tail(out, n_rr);
436 ctx = n_rr; /* Chain the contexts */
437 }
438}
439
440 /** Allocate a new request reference list and copy request references into it
441 *
442 */
443static inline CC_HINT(always_inline) CC_HINT(nonnull(2,3))
444void tmpl_request_ref_list_acopy(TALLOC_CTX *ctx,
445 FR_DLIST_HEAD(tmpl_request_list) **out, FR_DLIST_HEAD(tmpl_request_list) const *in)
446{
447 FR_DLIST_HEAD(tmpl_request_list) *rql;
448
449 MEM(rql = talloc_zero(ctx, FR_DLIST_HEAD(tmpl_request_list)));
450 tmpl_request_list_talloc_init(rql);
451
452 tmpl_request_ref_list_copy(rql, rql, in);
453
454 *out = rql;
455}
456
457/** Dump a request list to stderr
458 *
459 */
460void tmpl_request_ref_list_debug(FR_DLIST_HEAD(tmpl_request_list) const *rql)
461{
462 tmpl_request_t *rr = NULL;
463
464 while ((rr = tmpl_request_list_next(rql, rr))) {
465 FR_FAULT_LOG("request - %s (%u)",
466 fr_table_str_by_value(tmpl_request_ref_table, rr->request, "<INVALID>"),
467 rr->request);
468 }
469}
470
471/** Compare a list of request qualifiers
472 *
473 * @param[in] a first list. If NULL tmpl_request_def_current will be used.
474 * @param[in] b second list. If NULL tmpl_request_def_current will be used.
475 * @return
476 * - >0 a > b
477 * - 0 a == b
478 * - <0 a < b
479 */
480int8_t tmpl_request_ref_list_cmp(FR_DLIST_HEAD(tmpl_request_list) const *a, FR_DLIST_HEAD(tmpl_request_list) const *b)
481{
482 tmpl_request_t *a_rr = NULL, *b_rr = NULL;
483
484 /*
485 * NULL, uninit, empty are all equivalent
486 * to tmpl_request_def_current.
487 *
488 * We need all these equivalent checks to
489 * deal with uninitialised tmpl rules.
490 */
491 if (!a || !tmpl_request_list_initialised(a) || tmpl_request_list_empty(a)) a = &tmpl_request_def_current;
492 if (!b || !tmpl_request_list_initialised(b) || tmpl_request_list_empty(b)) b = &tmpl_request_def_current;
493
494 /*
495 * Fast path...
496 */
497 if (a == b) return 0;
498
499 for (;;) {
500 a_rr = tmpl_request_list_next(a, a_rr);
501 b_rr = tmpl_request_list_next(b, b_rr);
502
503 if (!a_rr || !b_rr) return CMP(tmpl_request_list_num_elements(a), tmpl_request_list_num_elements(b));
504
505 CMP_RETURN(a_rr, b_rr, request);
506 }
507}
508
509/** Parse one or more request references, writing the list to out
510 *
511 * @param[in] ctx to allocate request refs in.
512 * @param[out] err If !NULL where to write the parsing error.
513 * @param[in] out The list to write to.
514 * @param[in] in Sbuff to read request references from.
515 * @param[in] p_rules Parse rules.
516 * @param[in] t_rules Default list and other rules.
517 * @param[out] namespace the namespace to use
518 * @return
519 * - >= 0 the number of bytes parsed.
520 * - <0 negative offset for where the error occurred
521 */
522static fr_slen_t tmpl_request_ref_list_from_substr(TALLOC_CTX *ctx, tmpl_attr_error_t *err,
523 FR_DLIST_HEAD(tmpl_request_list) *out,
524 fr_sbuff_t *in,
525 fr_sbuff_parse_rules_t const *p_rules,
526 tmpl_rules_t const *t_rules,
527 fr_dict_attr_t const **namespace)
528{
529 tmpl_request_ref_t ref;
530 tmpl_request_t *rr;
531 size_t ref_len;
532 fr_sbuff_t our_in = FR_SBUFF(in);
533 tmpl_request_t *tail = tmpl_request_list_tail(out);
534 unsigned int depth = 0;
535 fr_sbuff_marker_t m;
536 tmpl_attr_rules_t const *at_rules;
537 DEFAULT_RULES;
538
539 CHECK_T_RULES;
540 at_rules = &t_rules->attr;
541
542 /*
543 * The caller wants to know the default namespace for
544 * resolving the attribute.
545 *
546 * @todo - why not use dict_def if it's set? Tho TBH we
547 * should probably just remove dict_def, and always use "namespace".
548 */
549 if (namespace) {
550 if (at_rules->namespace) {
551 *namespace = at_rules->namespace;
552 } else {
553 *namespace = NULL;
554 }
555 }
556
557 /*
558 * We could make the caller do this but as this
559 * function is intended to help populate tmpl rules,
560 * just be nice...
561 */
562 if (!tmpl_request_list_initialised(out)) tmpl_request_list_talloc_init(out);
563
564 fr_sbuff_marker(&m, &our_in);
565 for (depth = 0; depth < TMPL_MAX_REQUEST_REF_NESTING; depth++) {
566 bool end;
567
568 /*
569 * Search for a known request reference like
570 * 'current', or 'parent'.
571 */
572 fr_sbuff_out_by_longest_prefix(&ref_len, &ref, tmpl_request_ref_table, &our_in, REQUEST_UNKNOWN);
573
574 /*
575 * No match
576 */
577 if (ref_len == 0) {
578 /*
579 * If depth == 0, we're at the start
580 * so just use the default request
581 * reference.
582 */
583 default_ref:
584 if ((depth == 0) && at_rules->request_def) {
585 tmpl_request_ref_list_copy(ctx, out, at_rules->request_def);
586 }
587 break;
588 }
589
590 /*
591 * We don't want to misidentify the list
592 * as being part of an attribute.
593 */
594 if (!fr_sbuff_is_char(&our_in, '.') && (fr_sbuff_is_in_charset(&our_in, fr_dict_attr_allowed_chars) || !tmpl_substr_terminal_check(&our_in, p_rules))) {
595 goto default_ref;
596 }
597
598 if (depth == 0) {
599 if (at_rules->namespace || (at_rules->list_presence == TMPL_ATTR_LIST_FORBID)) {
600 fr_strerror_const("List qualifiers are not allowed here");
601 if (err) *err = TMPL_ATTR_ERROR_LIST_NOT_ALLOWED;
602
603 fr_sbuff_set(&our_in, in); /* Marker at the start */
604 error:
605 tmpl_request_list_talloc_free_to_tail(out, tail);
606 FR_SBUFF_ERROR_RETURN(&our_in);
607 }
608 }
609
610 /*
611 * If the caller is asking for a namespace, then walk back up the tmpl_rules_t to find a parent namespace.
612 */
613 if (namespace && t_rules && t_rules->parent) {
614 t_rules = t_rules->parent;
615
616 switch (ref) {
617 case REQUEST_OUTER:
618 while (t_rules->parent) t_rules = t_rules->parent; /* Walk back to the root */
619 FALL_THROUGH;
620
621 case REQUEST_PARENT:
622 if (t_rules->attr.namespace) {
623 *namespace = t_rules->attr.namespace;
624 } else if (t_rules->attr.dict_def) {
625 *namespace = fr_dict_root(t_rules->attr.dict_def);
626 } else {
627 *namespace = NULL;
628 }
629 break;
630
631 default:
632 break;
633 }
634 }
635
636 /*
637 * Add a new entry to the dlist
638 */
639 MEM(rr = talloc(ctx, tmpl_request_t));
640 *rr = (tmpl_request_t){
641 .request = ref
642 };
643 tmpl_request_list_insert_tail(out, rr);
644
645 /*
646 * Advance past the separator (if there is one)
647 */
648 end = !fr_sbuff_next_if_char(&our_in, '.');
649
650 /*
651 * Update to the last successfully parsed component
652 *
653 * This makes it easy to backtrack from refs like
654 *
655 * parent.outer-realm-name
656 */
657 fr_sbuff_set(&m, &our_in);
658
659 if (end) break;
660 }
661
662 /*
663 * Nesting level too deep
664 */
665 if (depth > TMPL_MAX_REQUEST_REF_NESTING) {
666 fr_strerror_const("Request ref nesting too deep");
667 if (err) *err = TMPL_ATTR_ERROR_NESTING_TOO_DEEP;
668 goto error; /* Leave marker at the end */
669 }
670
671 FR_SBUFF_SET_RETURN(in, &m);
672}
673
674/** Parse one or more request references, allocing a new list and adding the references to it
675 *
676 * This can be used to create request ref lists for rules and for tmpls.
677 *
678 * @param[in] ctx to allocate request refs in.
679 * @param[out] err If !NULL where to write the parsing error.
680 * @param[out] out The new list.
681 * @param[in] in Sbuff to read request references from.
682 * @return
683 * - >= 0 the number of bytes parsed.
684 * - <0 negative offset for where the error occurred
685 */
686fr_slen_t tmpl_request_ref_list_afrom_substr(TALLOC_CTX *ctx, tmpl_attr_error_t *err,
687 FR_DLIST_HEAD(tmpl_request_list) **out,
688 fr_sbuff_t *in)
689{
690 fr_slen_t slen;
691
692 FR_DLIST_HEAD(tmpl_request_list) *rql;
693
694 MEM(rql = talloc_zero(ctx, FR_DLIST_HEAD(tmpl_request_list)));
695 tmpl_request_list_talloc_init(rql);
696
697 slen = tmpl_request_ref_list_from_substr(rql, err, rql, in, NULL, NULL, NULL);
698 if (slen < 0) {
699 talloc_free(rql);
700 return slen;
701 }
702
703 *out = rql;
704
705 return slen;
706}
707/** @} */
708
709/** @name Alloc or initialise #tmpl_t
710 *
711 * @note Should not usually be called outside of tmpl_* functions, use one of
712 * the tmpl_*from_* functions instead.
713 * @{
714 */
715
716/** Initialise fields inside a tmpl depending on its type
717 *
718 */
719static inline CC_HINT(always_inline) void tmpl_type_init(tmpl_t *vpt, tmpl_type_t type)
720{
721
722 switch (type) {
723#ifndef HAVE_REGEX
724 case TMPL_TYPE_REGEX:
725 case TMPL_TYPE_REGEX_UNCOMPILED:
726 case TMPL_TYPE_REGEX_XLAT:
727 case TMPL_TYPE_REGEX_XLAT_UNRESOLVED:
728 fr_assert(0);
729 return;
730#endif
731
732 case TMPL_TYPE_ATTR:
733 case TMPL_TYPE_ATTR_UNRESOLVED:
734 tmpl_attr_list_talloc_init(tmpl_attr(vpt));
735 tmpl_request_list_talloc_init(&vpt->data.attribute.rr);
736 break;
737
738 default:
739 break;
740 }
741 vpt->type = type;
742 }
743
744/** Set the name on a pre-initialised tmpl
745 *
746 * @param[in] vpt to set the name for.
747 * @param[in] quote Original quoting around the name.
748 * @param[in] fmt string.
749 * @param[in] ... format arguments.
750 */
751void tmpl_set_name_printf(tmpl_t *vpt, fr_token_t quote, char const *fmt, ...)
752{
753 va_list ap;
754 char const *old = NULL;
755
756 if (vpt->type != TMPL_TYPE_UNINITIALISED) old = vpt->name;
757
758 va_start(ap, fmt);
759 vpt->name = fr_vasprintf(vpt, fmt, ap);
760 vpt->quote = quote;
761 vpt->len = talloc_array_length(vpt->name) - 1;
762 va_end(ap);
763
764 talloc_const_free(old); /* Free name last so it can be used in the format string */
765}
766
767/** Set the name on a pre-initialised tmpl
768 *
769 * @param[in] vpt to set the name for.
770 * @param[in] quote Original quoting around the name.
771 * @param[in] name of the #tmpl_t.
772 * @param[in] len The length of the buffer (or a substring of the buffer) pointed to by name.
773 * If < 0 strlen will be used to determine the length.
774 */
775void tmpl_set_name_shallow(tmpl_t *vpt, fr_token_t quote, char const *name, ssize_t len)
776{
777 fr_assert(vpt->type != TMPL_TYPE_UNINITIALISED);
778
779 vpt->name = name;
780 vpt->len = len < 0 ? strlen(name) : (size_t)len;
781 vpt->quote = quote;
782}
783
784/** Set the name on a pre-initialised tmpl
785 *
786 * @param[in] vpt to set the name for.
787 * @param[in] quote Original quoting around the name.
788 * @param[in] name of the #tmpl_t.
789 * @param[in] len The length of the buffer (or a substring of the buffer) pointed to by name.
790 * If < 0 strlen will be used to determine the length.
791 */
792void tmpl_set_name(tmpl_t *vpt, fr_token_t quote, char const *name, ssize_t len)
793{
794 fr_assert(vpt->type != TMPL_TYPE_UNINITIALISED);
795
796 talloc_const_free(vpt->name);
797
798 vpt->name = talloc_bstrndup(vpt, name, len < 0 ? strlen(name) : (size_t)len);
799 vpt->len = talloc_array_length(vpt->name) - 1;
800 vpt->quote = quote;
801}
802
803/** Change the default dictionary in the tmpl's resolution rules
804 *
805 * @param[in] vpt to alter.
806 * @param[in] dict to set.
807 */
808void tmpl_set_dict_def(tmpl_t *vpt, fr_dict_t const *dict)
809{
810 vpt->rules.attr.dict_def = dict;
811}
812
813/** Set escape parameters for the tmpl output
814 *
815 * @param[in] vpt to alter.
816 * @param[in] escape to set.
817 */
818void tmpl_set_escape(tmpl_t *vpt, tmpl_escape_t const *escape)
819{
820 vpt->rules.escape = *escape;
821}
822
823/** Change the default dictionary in the tmpl's resolution rules
824 *
825 * @param[in] vpt to alter.
826 * @param[in] xlat to set.
827 */
828void tmpl_set_xlat(tmpl_t *vpt, xlat_exp_head_t *xlat)
829{
830 fr_assert((vpt->type == TMPL_TYPE_XLAT) || (vpt->type == TMPL_TYPE_EXEC));
831
832 tmpl_xlat(vpt) = xlat;
833}
834
835
836/** Initialise a tmpl using a format string to create the name
837 *
838 * @param[in] vpt to initialise.
839 * @param[in] type of tmpl to initialise.
840 * @param[in] quote Original quoting around the name.
841 * @param[in] fmt string.
842 * @param[in] ... format arguments.
843 * @return A pointer to the newly initialised tmpl.
844 */
845tmpl_t *tmpl_init_printf(tmpl_t *vpt, tmpl_type_t type, fr_token_t quote, char const *fmt, ...)
846{
847 va_list ap;
848
849 memset(vpt, 0, sizeof(*vpt));
850 tmpl_type_init(vpt, type);
851
852 va_start(ap, fmt);
853 vpt->name = fr_vasprintf(vpt, fmt, ap);
854 vpt->len = talloc_array_length(vpt->name) - 1;
855 vpt->quote = quote;
856 va_end(ap);
857
858 return vpt;
859}
860
861/** Initialise a tmpl without copying the input name string
862 *
863 * @note Name is not talloc_strdup'd or memcpy'd so must be available, and must not change
864 * for the lifetime of the #tmpl_t.
865 *
866 * @param[out] vpt to initialise.
867 * @param[in] type to set in the #tmpl_t.
868 * @param[in] quote The type of quoting around the template name.
869 * @param[in] name of the #tmpl_t.
870 * @param[in] len The length of the buffer (or a substring of the buffer) pointed to by name.
871 * If < 0 strlen will be used to determine the length.
872 * @param[in] t_rules used during parsing.
873 * @return a pointer to the initialised #tmpl_t. The same value as vpt.
874 */
875tmpl_t *tmpl_init_shallow(tmpl_t *vpt, tmpl_type_t type, fr_token_t quote,
876 char const *name, ssize_t len, tmpl_rules_t const *t_rules)
877{
878 memset(vpt, 0, sizeof(*vpt));
879 tmpl_type_init(vpt, type);
880 tmpl_set_name_shallow(vpt, quote, name, len);
881 if (t_rules) vpt->rules = *t_rules;
882
883 return vpt;
884}
885
886/** Initialise a tmpl using a literal string to create the name
887 *
888 * @param[in] vpt to initialise.
889 * @param[in] type of tmpl to initialise.
890 * @param[in] quote Original quoting around the name.
891 * @param[in] name to set for the tmpl.
892 * @param[in] len Name length. If < 0 strlen will be used
893 * to determine the name.
894 * @param[in] t_rules used during parsing.
895 * @return A pointer to the newly initialised tmpl.
896 */
897tmpl_t *tmpl_init(tmpl_t *vpt, tmpl_type_t type, fr_token_t quote,
898 char const *name, ssize_t len, tmpl_rules_t const *t_rules)
899{
900 memset(vpt, 0, sizeof(*vpt));
901 tmpl_type_init(vpt, type);
902 tmpl_set_name(vpt, quote, name, len);
903 if (t_rules) vpt->rules = *t_rules;
904
905 return vpt;
906}
907
908/** Create a new heap allocated #tmpl_t
909 *
910 * Must be later initialised with a tmpl_init_* function.
911 *
912 * This function is provided to allow tmpls to be pre-allocated for talloc purposes before
913 * their name is known.
914 */
915static inline CC_HINT(always_inline) tmpl_t *tmpl_alloc_null(TALLOC_CTX *ctx)
916{
917 tmpl_t *vpt;
918
919 /*
920 * Allocate enough memory to hold at least
921 * one attribute reference and one request
922 * reference.
923 */
924 MEM(vpt = talloc_pooled_object(ctx, tmpl_t, 2, sizeof(tmpl_request_t) + sizeof(tmpl_attr_t)));
925 vpt->type = TMPL_TYPE_UNINITIALISED;
926
927 return vpt;
928}
929
930/** Create a new heap allocated #tmpl_t
931 *
932 * @param[in,out] ctx to allocate in.
933 * @param[in] type to set in the #tmpl_t.
934 * @param[in] name of the #tmpl_t (will be copied to a new talloc buffer parented
935 * by the #tmpl_t).
936 * @param[in] len The length of the buffer (or a substring of the buffer) pointed to by name.
937 * If < 0 strlen will be used to determine the length.
938 * @param[in] quote The type of quoting around the template name.
939 * @return the newly allocated #tmpl_t.
940 */
941tmpl_t *tmpl_alloc(TALLOC_CTX *ctx, tmpl_type_t type, fr_token_t quote, char const *name, ssize_t len)
942{
943 tmpl_t *vpt;
944
945 vpt = tmpl_alloc_null(ctx);
946 memset(vpt, 0, sizeof(*vpt));
947
948 tmpl_type_init(vpt, type);
949 if (name) tmpl_set_name(vpt, quote, name, len);
950
951 return vpt;
952}
953/** @} */
954
955/** @name Create new #tmpl_t from a string
956 *
957 * @{
958 */
959
960/** Allocate a new attribute reference and add it to the end of the attribute reference list
961 *
962 */
963static tmpl_attr_t *tmpl_attr_add(tmpl_t *vpt, tmpl_attr_type_t type)
964{
965 tmpl_attr_t *ar;
966 TALLOC_CTX *ctx;
967
968 if (tmpl_attr_list_num_elements(tmpl_attr(vpt)) == 0) {
969 ctx = vpt;
970 } else {
971 ctx = tmpl_attr_list_tail(tmpl_attr(vpt));
972 }
973
974 MEM(ar = talloc(ctx, tmpl_attr_t));
975 *ar = (tmpl_attr_t){
976 .type = type,
977 .filter = {
978 .type = TMPL_ATTR_FILTER_TYPE_NONE,
979 .num = NUM_UNSPEC
980 }
981 };
982 tmpl_attr_list_insert_tail(tmpl_attr(vpt), ar);
983
984 return ar;
985}
986
987/** Create a #tmpl_t from a #fr_value_box_t
988 *
989 * @param[in,out] ctx to allocate #tmpl_t in.
990 * @param[out] out Where to write pointer to new #tmpl_t.
991 * @param[in] data to convert.
992 * @param[in] steal If true, any buffers are moved to the new
993 * ctx instead of being duplicated.
994 * @return
995 * - 0 on success.
996 * - -1 on failure.
997 */
998int tmpl_afrom_value_box(TALLOC_CTX *ctx, tmpl_t **out, fr_value_box_t *data, bool steal)
999{
1000 char *name;
1001 fr_slen_t slen;
1002 tmpl_t *vpt;
1003 fr_token_t quote = (data->type == FR_TYPE_STRING) ? T_SINGLE_QUOTED_STRING : T_BARE_WORD;
1004
1005 MEM(vpt = talloc(ctx, tmpl_t));
1006 slen = fr_value_box_aprint(vpt, &name, data, fr_value_escape_by_quote[quote]);
1007 if (slen < 0) {
1008 error:
1009 talloc_free(vpt);
1010 return -1;
1011 }
1012
1013 tmpl_init_shallow(vpt, TMPL_TYPE_DATA, quote, name, slen, NULL);
1014
1015 if (steal) {
1016 if (fr_value_box_steal(vpt, tmpl_value(vpt), data) < 0) goto error;
1017 } else {
1018 if (unlikely(fr_value_box_copy(vpt, tmpl_value(vpt), data) < 0)) goto error;
1019 }
1020 *out = vpt;
1021
1022 return 0;
1023}
1024
1025/** Copy a list of attribute and request references from one tmpl to another
1026 *
1027 */
1028int tmpl_attr_copy(tmpl_t *dst, tmpl_t const *src)
1029{
1030 tmpl_attr_t *src_ar = NULL, *dst_ar;
1031
1032 /*
1033 * Clear any existing attribute references
1034 */
1035 if (tmpl_attr_list_num_elements(tmpl_attr(dst)) > 0) tmpl_attr_list_talloc_reverse_free(tmpl_attr(dst));
1036
1037 while ((src_ar = tmpl_attr_list_next(tmpl_attr(src), src_ar))) {
1038 dst_ar = tmpl_attr_add(dst, src_ar->type);
1039
1040 switch (src_ar->type) {
1041 case TMPL_ATTR_TYPE_NORMAL:
1042 dst_ar->ar_da = src_ar->ar_da;
1043 break;
1044
1045 case TMPL_ATTR_TYPE_UNSPEC: /* Nothing to copy */
1046 break;
1047
1048 case TMPL_ATTR_TYPE_UNKNOWN:
1049 dst_ar->ar_unknown = fr_dict_attr_unknown_copy(dst_ar, src_ar->ar_unknown);
1050 break;
1051
1052 case TMPL_ATTR_TYPE_UNRESOLVED:
1053 dst_ar->ar_unresolved = talloc_bstrdup(dst_ar, src_ar->ar_unresolved);
1054 break;
1055
1056 default:
1057 if (!fr_cond_assert(0)) return -1;
1058 }
1059 dst_ar->ar_num = src_ar->ar_num;
1060 dst_ar->ar_filter_type = src_ar->ar_filter_type;
1061 dst_ar->parent = src_ar->parent;
1062 }
1063
1064 /*
1065 * Clear any existing request references
1066 * and copy the ones from the source.
1067 */
1068 tmpl_request_list_talloc_reverse_free(&dst->data.attribute.rr);
1069 tmpl_request_ref_list_copy(dst, &dst->data.attribute.rr, &src->data.attribute.rr);
1070
1071 /*
1072 * Ensure that we copy over any parsing rules, defaults, etc.
1073 */
1074 dst->rules = src->rules;
1075
1076 TMPL_ATTR_VERIFY(dst);
1077
1078 return 0;
1079}
1080
1081/** Replace the current attribute reference
1082 *
1083 */
1084int tmpl_attr_set_da(tmpl_t *vpt, fr_dict_attr_t const *da)
1085{
1086 tmpl_attr_t *ref;
1087
1088 (void)talloc_get_type_abort_const(da, fr_dict_attr_t);
1089
1090 /*
1091 * Clear any existing references
1092 */
1093 if (tmpl_attr_list_num_elements(tmpl_attr(vpt)) > 0) {
1094 tmpl_attr_list_talloc_reverse_free(tmpl_attr(vpt));
1095 }
1096
1097 /*
1098 * Unknown attributes get copied
1099 */
1100 if (da->flags.is_unknown) {
1101 ref = tmpl_attr_add(vpt, TMPL_ATTR_TYPE_UNKNOWN);
1102 ref->da = ref->ar_unknown = fr_dict_attr_unknown_copy(vpt, da);
1103 } else {
1104 ref = tmpl_attr_add(vpt, TMPL_ATTR_TYPE_NORMAL);
1105 ref->da = da;
1106 }
1107 ref->ar_parent = fr_dict_root(fr_dict_by_da(da)); /* Parent is the root of the dictionary */
1108
1109 TMPL_ATTR_VERIFY(vpt);
1110
1111 return 0;
1112}
1113
1114/** Replace the leaf attribute only
1115 *
1116 */
1117int tmpl_attr_set_leaf_da(tmpl_t *vpt, fr_dict_attr_t const *da)
1118{
1119 tmpl_attr_t *ref, *parent = NULL;
1120
1121 tmpl_assert_type(tmpl_is_attr(vpt));
1122 (void)talloc_get_type_abort_const(da, fr_dict_attr_t);
1123
1124 /*
1125 * Clear any existing references
1126 */
1127 if (tmpl_attr_list_num_elements(tmpl_attr(vpt)) > 0) {
1128 if (tmpl_attr_list_num_elements(tmpl_attr(vpt)) > 1) {
1129 ref = tmpl_attr_list_tail(tmpl_attr(vpt));
1130 parent = tmpl_attr_list_prev(tmpl_attr(vpt), ref);
1131
1132 if (!fr_dict_attr_common_parent(parent->ar_da, da, true)) {
1133 fr_strerror_const("New leaf da and old leaf da do not share the same ancestor");
1134 return -1;
1135 }
1136 } else {
1137 ref = tmpl_attr_list_tail(tmpl_attr(vpt));
1138 }
1139
1140 /*
1141 * Free old unknown and unresolved attributes...
1142 */
1143 talloc_free_children(ref);
1144
1145 /*
1146 *
1147 */
1148 ref->ar_filter_type = TMPL_ATTR_FILTER_TYPE_NONE;
1149 ref->ar_num = NUM_UNSPEC;
1150
1151 } else {
1152 ref = tmpl_attr_add(vpt, da->flags.is_unknown ? TMPL_ATTR_TYPE_UNKNOWN : TMPL_ATTR_TYPE_NORMAL);
1153 }
1154
1155
1156 /*
1157 * Unknown attributes get copied
1158 */
1159 if (da->flags.is_unknown) {
1160 ref->da = ref->ar_unknown = fr_dict_attr_unknown_copy(vpt, da);
1161 } else {
1162 ref->da = da;
1163 }
1164
1165 /*
1166 * FIXME - Should be calculated from existing ar
1167 */
1168 ref->ar_parent = fr_dict_root(fr_dict_by_da(da)); /* Parent is the root of the dictionary */
1169
1170 TMPL_ATTR_VERIFY(vpt);
1171
1172 return 0;
1173}
1174
1175/** Rewrite the leaf's instance number
1176 *
1177 * This function is _only_ called from the compiler, for "update" and "foreach" keywords. In those cases,
1178 * the user historically did "foo-bar", but really meant "foo-bar[*]". We silently update that for
1179 * "update" sections, and complain about it in "foreach" sections.
1180 *
1181 * As the server now supports multiple types of leaf references, we do the rewrite _only_ from "none" (no
1182 * filter), OR where it's a numerical index, AND the index hasn't been specified.
1183 */
1184void tmpl_attr_rewrite_leaf_num(tmpl_t *vpt, int16_t to)
1185{
1186 tmpl_attr_t *ref = NULL;
1187
1188 tmpl_assert_type(tmpl_is_attr(vpt) || tmpl_is_attr_unresolved(vpt));
1189
1190 if (tmpl_attr_list_num_elements(tmpl_attr(vpt)) == 0) return;
1191
1192 ref = tmpl_attr_list_tail(tmpl_attr(vpt));
1193
1194 if (ref->ar_filter_type == TMPL_ATTR_FILTER_TYPE_NONE) {
1195 ref->ar_filter_type = TMPL_ATTR_FILTER_TYPE_INDEX;
1196 ref->ar_num = to;
1197
1198 } else if (ref->ar_filter_type != TMPL_ATTR_FILTER_TYPE_INDEX) {
1199 return;
1200
1201 } else if (ref->ar_num == NUM_UNSPEC) {
1202 ref->ar_num = to;
1203 }
1204
1205 TMPL_ATTR_VERIFY(vpt);
1206}
1207
1208/** Set the request for an attribute ref
1209 *
1210 */
1211void tmpl_attr_set_request_ref(tmpl_t *vpt, FR_DLIST_HEAD(tmpl_request_list) const *request_def)
1212{
1213 fr_assert_msg(tmpl_is_attr(vpt), "Expected tmpl type 'attr', got '%s'",
1214 tmpl_type_to_str(vpt->type));
1215
1216 /*
1217 * Clear any existing request references
1218 */
1219 tmpl_request_list_talloc_reverse_free(&vpt->data.attribute.rr);
1220 tmpl_request_ref_list_copy(vpt, &vpt->data.attribute.rr, request_def);
1221
1222 TMPL_ATTR_VERIFY(vpt);
1223}
1224
1225void tmpl_attr_set_list(tmpl_t *vpt, fr_dict_attr_t const *list)
1226{
1227 tmpl_attr_t *ref = tmpl_attr_list_head(tmpl_attr(vpt));
1228 if (tmpl_attr_is_list_attr(ref)) ref->da = list;
1229
1230 TMPL_ATTR_VERIFY(vpt);
1231}
1232
1233/** Create a new tmpl from a list tmpl and a da
1234 *
1235 */
1236int tmpl_attr_afrom_list(TALLOC_CTX *ctx, tmpl_t **out, tmpl_t const *list, fr_dict_attr_t const *da)
1237{
1238 tmpl_t *vpt;
1239 tmpl_attr_t *ar;
1240
1241 char attr[256];
1242 ssize_t slen;
1243
1244 MEM(vpt = tmpl_alloc(ctx, TMPL_TYPE_ATTR, T_BARE_WORD, NULL, 0));
1245
1246 /*
1247 * Copies request refs and the list ref
1248 */
1249 tmpl_attr_copy(vpt, list);
1250 tmpl_attr_set_list(vpt, tmpl_list(list));
1251
1252 if (da->flags.is_unknown) {
1253 ar = tmpl_attr_add(vpt, TMPL_ATTR_TYPE_UNKNOWN);
1254 ar->da = ar->ar_unknown = fr_dict_attr_unknown_copy(vpt, da);
1255 } else {
1256 ar = tmpl_attr_add(vpt, TMPL_ATTR_TYPE_NORMAL);
1257 ar->ar_da = da;
1258 }
1259
1260 ar->ar_parent = fr_dict_root(fr_dict_by_da(da));
1261
1262 /*
1263 * We need to rebuild the attribute name, to be the
1264 * one we copied from the source list.
1265 */
1266 slen = tmpl_print(&FR_SBUFF_OUT(attr, sizeof(attr)), vpt,
1267 fr_value_escape_by_quote[list->quote]);
1268 if (slen < 0) {
1269 fr_strerror_printf("Serialized attribute too long. Must be < "
1270 STRINGIFY(sizeof(attr)) " bytes, got %zu bytes", (size_t)-slen);
1271 talloc_free(vpt);
1272 return -1;
1273 }
1274
1275 vpt->len = (size_t)slen;
1276 vpt->name = talloc_typed_strdup(vpt, attr);
1277 vpt->quote = T_BARE_WORD;
1278
1279 TMPL_ATTR_VERIFY(vpt);
1280
1281 *out = vpt;
1282
1283 return 0;
1284}
1285/** @} */
1286
1287/** Insert an attribute reference into a tmpl
1288 *
1289 * Not all attribute references can be used to create new attributes,
1290 * for example those accessing instance > 0 or those that resolve
1291 * to special indexes.
1292 *
1293 * We mark up these references and their parents as resolve only
1294 * meaning that if any code needs to use a reference chain to build
1295 * out a pair tree, it bails out early.
1296 *
1297 * @param[in] vpt containing the reference list.
1298 * @param[in] ar to insert and check.
1299 */
1300static inline CC_HINT(always_inline) void tmpl_attr_insert(tmpl_t *vpt, tmpl_attr_t *ar)
1301{
1302 /*
1303 * Insert the reference into the list.
1304 */
1305 tmpl_attr_list_insert_tail(tmpl_attr(vpt), ar);
1306
1307 switch (ar->ar_num) {
1308 case 0:
1309 case NUM_UNSPEC:
1310 break;
1311
1312 default:
1313 ar->resolve_only = true;
1314 while ((ar = tmpl_attr_list_prev(tmpl_attr(vpt), ar))) ar->resolve_only = true;
1315 break;
1316 }
1317}
1318
1319/** Parse array subscript and in future other filters
1320 *
1321 * @param[out] err Parse error code.
1322 * @param[in] ar to populate filter for.
1323 * @param[in] name containing more attribute ref data.
1324 * @param[in] at_rules see tmpl_attr_afrom_attr_substr.
1325 * @return
1326 * - >0 if a filter was parsed.
1327 * - 0 if no filter was available.
1328 * - <0 on filter parse error.
1329 */
1330static fr_slen_t tmpl_attr_parse_filter(tmpl_attr_error_t *err, tmpl_attr_t *ar,
1331 fr_sbuff_t *name, tmpl_attr_rules_t const *at_rules)
1332{
1333 fr_sbuff_t our_name = FR_SBUFF(name);
1334
1335 /*
1336 * Parse array subscript (and eventually complex filters)
1337 */
1338 if (!fr_sbuff_next_if_char(&our_name, '[')) return 0;
1339
1340 if (at_rules->disallow_filters || tmpl_attr_is_list_attr(ar)) {
1341 fr_strerror_const("Filters not allowed here");
1342 if (err) *err = TMPL_ATTR_ERROR_FILTER_NOT_ALLOWED;
1343 fr_sbuff_set_to_start(&our_name);
1344 FR_SBUFF_ERROR_RETURN(&our_name);
1345 }
1346
1347 ar->ar_filter_type = TMPL_ATTR_FILTER_TYPE_INDEX;
1348 fr_sbuff_switch(&our_name, '\0') {
1349 case '#':
1350 ar->ar_num = NUM_COUNT;
1351 fr_sbuff_next(&our_name);
1352 break;
1353
1354 case '*':
1355 ar->ar_num = NUM_ALL;
1356 fr_sbuff_next(&our_name);
1357 break;
1358
1359 case '0':
1360 case '1':
1361 case '2':
1362 case '3':
1363 case '4':
1364 case '5':
1365 case '6':
1366 case '7':
1367 case '8':
1368 case '9':
1369 {
1370 ssize_t rcode;
1371 fr_sbuff_parse_error_t sberr = FR_SBUFF_PARSE_OK;
1372 fr_sbuff_t tmp = FR_SBUFF(&our_name);
1373
1374 /*
1375 * All digits (not hex).
1376 */
1377 rcode = fr_sbuff_out(&sberr, &ar->ar_num, &tmp);
1378 if ((rcode < 0) || !fr_sbuff_is_char(&tmp, ']')) goto parse_tmpl;
1379
1380 if ((ar->ar_num > 1000) || (ar->ar_num < 0)) {
1381 fr_strerror_printf("Invalid array index '%hi' (should be between 0-1000)", ar->ar_num);
1382 ar->ar_num = 0;
1383 goto error;
1384 }
1385
1386 fr_sbuff_set(&our_name, &tmp); /* Advance name _AFTER_ doing checks */
1387 break;
1388 }
1389
1390 case '"':
1391 case '\'':
1392 case '`':
1393 case '/':
1394 fr_strerror_const("Invalid data type for array index");
1395 goto error;
1396
1397 /* Used as EOB here */
1398 missing_closing:
1399 case '\0':
1400 fr_strerror_const("No closing ']' for array index");
1401 error:
1402 if (err) *err = TMPL_ATTR_ERROR_INVALID_ARRAY_INDEX;
1403 FR_SBUFF_ERROR_RETURN(&our_name);
1404
1405 case '(': /* (...) expression */
1406 {
1407 fr_sbuff_t tmp = FR_SBUFF(&our_name);
1408 fr_slen_t slen;
1409 tmpl_rules_t t_rules;
1410 fr_sbuff_parse_rules_t p_rules;
1411 fr_sbuff_term_t const filter_terminals = FR_SBUFF_TERMS(L("]"));
1412
1413
1414 tmp = FR_SBUFF(&our_name);
1415 t_rules = (tmpl_rules_t) {};
1416 t_rules.attr = *at_rules;
1417
1418 /*
1419 * Unspecified child, we can create a filter starting from the children.
1420 *
1421 * @todo - When parsing the condition, we need to ensure that the condition contains a
1422 * reference to the current cursor, and we need to decide what that syntax is.
1423 */
1424 if (ar->type == TMPL_ATTR_TYPE_UNSPEC) {
1425 if (at_rules->dict_def) t_rules.attr.namespace = fr_dict_root(at_rules->dict_def);
1426
1427 } else {
1428 if (!ar->ar_da || !fr_type_is_structural(ar->ar_da->type)) {
1429 fr_strerror_printf("Invalid filter - cannot use filter on leaf attributes");
1430 ar->ar_num = 0;
1431 goto error;
1432 }
1433 t_rules.attr.namespace = ar->ar_da;
1434 }
1435
1436 p_rules = (fr_sbuff_parse_rules_t) {
1437 .terminals = &filter_terminals,
1438 .escapes = NULL
1439 };
1440
1441 /*
1442 * Check if it's a condition.
1443 */
1444 slen = xlat_tokenize_condition(ar, &ar->ar_cond, &tmp, &p_rules, &t_rules);
1445 if (slen < 0) goto error;
1446
1447 if (xlat_impure_func(ar->ar_cond)) {
1448 fr_strerror_const("Condition in attribute index cannot depend on functions which call external databases");
1449 goto error;
1450 }
1451
1452 ar->ar_filter_type = TMPL_ATTR_FILTER_TYPE_CONDITION;
1453 fr_sbuff_set(&our_name, &tmp); /* Advance name _AFTER_ doing checks */
1454 break;
1455 }
1456
1457 case '%': /* ${...} expansion */
1458 {
1459 fr_sbuff_t tmp = FR_SBUFF(&our_name);
1460 fr_slen_t slen;
1461 tmpl_rules_t t_rules;
1462 fr_sbuff_parse_rules_t p_rules;
1463 fr_sbuff_term_t const filter_terminals = FR_SBUFF_TERMS(L("]"));
1464
1465 if (!fr_sbuff_is_str(&our_name, "%{", 2)) {
1466 fr_strerror_const("Invalid expression in attribute index");
1467 goto error;
1468 }
1469
1470 tmp = FR_SBUFF(&our_name);
1471 t_rules = (tmpl_rules_t) {};
1472 t_rules.attr = *at_rules;
1473
1474 p_rules = (fr_sbuff_parse_rules_t) {
1475 .terminals = &filter_terminals,
1476 .escapes = NULL
1477 };
1478
1479 /*
1480 * Check if it's an expression.
1481 */
1482 slen = xlat_tokenize_expression(ar, &ar->ar_expr, &tmp, &p_rules, &t_rules);
1483 if (slen < 0) goto error;
1484
1485 if (xlat_impure_func(ar->ar_expr)) {
1486 fr_strerror_const("Expression in attribute index cannot depend on functions which call external databases");
1487 goto error;
1488 }
1489
1490 ar->ar_filter_type = TMPL_ATTR_FILTER_TYPE_EXPR;
1491
1492 fr_sbuff_set(&our_name, &tmp); /* Advance name _AFTER_ doing checks */
1493 break;
1494 }
1495
1496 case 'n':
1497 /*
1498 * [n] is the last one
1499 *
1500 * [nope] is a reference to "nope".
1501 */
1502 if (fr_sbuff_is_str(&our_name, "n]", 2)) {
1503 ar->ar_num = NUM_LAST;
1504 fr_sbuff_next(&our_name);
1505 break;
1506 }
1507 FALL_THROUGH;
1508
1509 default:
1510 parse_tmpl:
1511 {
1512 fr_sbuff_t tmp = FR_SBUFF(&our_name);
1513 ssize_t slen;
1514 tmpl_rules_t t_rules;
1515 fr_sbuff_parse_rules_t p_rules;
1516 fr_sbuff_term_t const filter_terminals = FR_SBUFF_TERMS(L("]"));
1517
1518 tmp = FR_SBUFF(&our_name);
1519 t_rules = (tmpl_rules_t) {};
1520 t_rules.attr = *at_rules;
1521
1522 /*
1523 * Don't reset namespace, we always want to start searching from the top level of the
1524 * dictionaries.
1525 */
1526
1527 p_rules = (fr_sbuff_parse_rules_t) {
1528 .terminals = &filter_terminals,
1529 .escapes = NULL
1530 };
1531
1532 /*
1533 * @todo - for some reason, the tokenize_condition code allows for internal
1534 * vs protocol vs local attributes, whereas the tmpl function only accepts
1535 * internal ones.
1536 */
1537 slen = tmpl_afrom_substr(ar, &ar->ar_tmpl, &tmp, T_BARE_WORD, &p_rules, &t_rules);
1538 if (slen <= 0) goto error;
1539
1540 if (!tmpl_is_attr(ar->ar_tmpl)) {
1541 fr_strerror_printf("Invalid array index '%s'", ar->ar_tmpl->name);
1542 goto error;
1543 }
1544
1545 /*
1546 * Arguably we _could_ say &User-Name["foo"] matches all user-name with value "foo",
1547 * but that would confuse the issue for &Integer-Thing[4].
1548 *
1549 * For matching therefore, we really need to have a way to define "self".
1550 */
1551 if (!fr_type_numeric[tmpl_attr_tail_da(ar->ar_tmpl)->type]) {
1552 fr_strerror_const("Invalid data type for array index (must be numeric)");
1553 goto error;
1554 }
1555
1556 ar->ar_filter_type = TMPL_ATTR_FILTER_TYPE_TMPL;
1557 fr_sbuff_set(&our_name, &tmp); /* Advance name _AFTER_ doing checks */
1558 break;
1559 }
1560 }
1561
1562 /*
1563 * Always advance here, so the error
1564 * marker points to the bad char.
1565 */
1566 if (!fr_sbuff_next_if_char(&our_name, ']')) goto missing_closing;
1567
1568 FR_SBUFF_SET_RETURN(name, &our_name);
1569}
1570
1571extern fr_dict_attr_t const *tmpl_attr_unspec;
1572
1573static inline CC_HINT(nonnull(3,4))
1574fr_slen_t tmpl_attr_ref_from_unspecified_substr(tmpl_attr_t *ar, tmpl_attr_error_t *err,
1575 tmpl_t *vpt,
1576 fr_sbuff_t *name, tmpl_attr_rules_t const *at_rules)
1577{
1578 fr_slen_t slen;
1579
1580 *ar = (tmpl_attr_t){
1581 .ar_num = NUM_UNSPEC, /* May be changed by tmpl_attr_parse_filter */
1582 .ar_type = TMPL_ATTR_TYPE_UNSPEC,
1583 .ar_da = tmpl_attr_unspec,
1584 };
1585
1586 slen = tmpl_attr_parse_filter(err, ar, name, at_rules);
1587 if (slen < 0) {
1588 return slen;
1589
1590 /*
1591 * No filters and no previous elements is the equivalent of '&'
1592 * which is not allowed.
1593 *
1594 * &[<filter>] is allowed as this lets us perform filtering operations
1595 * at the root.
1596 */
1597 } else if ((slen == 0) && (tmpl_attr_num_elements(vpt) == 0)) {
1598 fr_strerror_const("Invalid attribute name");
1599 if (err) *err = TMPL_ATTR_ERROR_INVALID_NAME;
1600 return -1;
1601 }
1602
1603 tmpl_attr_insert(vpt, ar);
1604
1605 return slen;
1606}
1607
1608/** Parse an unresolved attribute, i.e. one which can't be found in the current dictionary
1609 *
1610 * This function calls itself recursively to process additional OID
1611 * components once we've failed to resolve one component.
1612 *
1613 * @note Do not call directly.
1614 *
1615 * @param[in] ctx to allocate new attribute reference in.
1616 * @param[out] err Parse error.
1617 * @param[in,out] vpt to append this reference to.
1618 * @param[in] parent Last known parent.
1619 * @param[in] namespace in which the attribute will be resolved.
1620 * @param[in] name to parse.
1621 * @param[in] at_rules see tmpl_attr_afrom_attr_substr.
1622 * @return
1623 * - <0 on error.
1624 * - 0 on success.
1625 */
1626static inline CC_HINT(nonnull(3,6))
1627fr_slen_t tmpl_attr_ref_afrom_unresolved_substr(TALLOC_CTX *ctx, tmpl_attr_error_t *err,
1628 tmpl_t *vpt,
1629 fr_dict_attr_t const *parent, fr_dict_attr_t const *namespace,
1630 fr_sbuff_t *name, tmpl_attr_rules_t const *at_rules)
1631{
1632 tmpl_attr_t *ar = NULL, *ar_curr;
1633 fr_sbuff_t our_name = FR_SBUFF(name);
1634 fr_slen_t slen;
1635 char *unresolved;
1636
1637 /*
1638 * Point we free from if something goes wrong.
1639 */
1640 ar_curr = tmpl_attr_list_tail(tmpl_attr(vpt));
1641 for (;;) {
1642 MEM(ar = talloc(ctx, tmpl_attr_t));
1643 /*
1644 * Copy out a string of allowed dictionary chars to form
1645 * the unresolved attribute name.
1646 *
1647 * This will be resolved later (outside of this function).
1648 */
1649 slen = fr_sbuff_out_abstrncpy_allowed(ar, &unresolved,
1650 &our_name, FR_DICT_ATTR_MAX_NAME_LEN + 1,
1651 fr_dict_attr_allowed_chars);
1652 if (slen == 0) {
1653 slen = tmpl_attr_ref_from_unspecified_substr(ar, err, vpt, &our_name, at_rules);
1654 if (slen < 0) {
1655 fr_sbuff_advance(&our_name, +slen);
1656 error:
1657 talloc_free(ar);
1658 tmpl_attr_list_talloc_free_to_tail(tmpl_attr(vpt), ar_curr);
1659 return -1;
1660 }
1661 return fr_sbuff_set(name, &our_name);
1662 } else if (slen > FR_DICT_ATTR_MAX_NAME_LEN) {
1663 fr_strerror_const("Attribute name is too long");
1664 if (err) *err = TMPL_ATTR_ERROR_INVALID_NAME;
1665 goto error;
1666 }
1667
1668 *ar = (tmpl_attr_t){
1669 .ar_num = NUM_UNSPEC,
1670 .ar_type = TMPL_ATTR_TYPE_UNRESOLVED,
1671 .ar_unresolved = unresolved,
1672 .ar_unresolved_namespace = namespace,
1673 .ar_parent = parent
1674 };
1675
1676 if (tmpl_attr_parse_filter(err, ar, &our_name, at_rules) < 0) goto error;
1677
1678 /*
1679 * Insert the ar into the list of attribute references
1680 */
1681 tmpl_attr_insert(vpt, ar);
1682
1683 /*
1684 * Once one OID component is created as unresolved all
1685 * future OID components are also unresolved.
1686 */
1687 if (!fr_sbuff_next_if_char(&our_name, '.')) break;
1688 }
1689
1690 /*
1691 * Mark the tmpl up as an unresolved attribute reference
1692 * the attribute reference will be resolved later.
1693 */
1694 vpt->type = TMPL_TYPE_ATTR_UNRESOLVED;
1695
1696 return fr_sbuff_set(name, &our_name);
1697}
1698
1699/*
1700 * Add attr_ref when we've parsed an intermediate dictionary name
1701 * which is itself a ref.
1702 */
1703static void tmpl_attr_ref_fixup(TALLOC_CTX *ctx, tmpl_t *vpt, fr_dict_attr_t const *da, fr_dict_attr_t const *parent)
1704{
1705 tmpl_attr_t *ar;
1706
1707 if (tmpl_attr_tail_da(vpt) == da) return;
1708
1709 if (da->parent != parent) tmpl_attr_ref_fixup(ctx, vpt, da->parent, parent);
1710
1711 MEM(ar = talloc(ctx, tmpl_attr_t));
1712 *ar = (tmpl_attr_t) {
1713 .ar_num = NUM_UNSPEC,
1714 .ar_type = TMPL_ATTR_TYPE_NORMAL,
1715 .ar_da = da,
1716 .ar_parent = da->parent,
1717 };
1718
1719 tmpl_attr_insert(vpt, ar);
1720}
1721
1722/** Parse an attribute reference, either an OID or attribute name
1723 *
1724 * @note Do not call directly.
1725 *
1726 * @param[in] ctx to allocate new attribute reference in.
1727 * @param[out] err Parse error.
1728 * @param[in,out] vpt to append this reference to.
1729 * @param[in] parent Parent where the attribute will be placed (group, struct, tlv, etc).
1730 * @param[in] namespace Where the child attribute will be parsed from (dict root, struct member, TLV child, etc)
1731 * @param[in] name to parse.
1732 * @param[in] p_rules Formatting rules used to check for trailing garbage.
1733 * @param[in] at_rules which places constraints on attribute reference parsing.
1734 * Rules interpreted by this function is:
1735 * - allow_unknown - If false unknown OID components
1736 * result in a parse error.
1737 * - allow_unresolved - If false unknown attribute names
1738 * result in a parse error.
1739 * - allow_foreign - If an attribute resolves in a dictionary
1740 * that does not match the parent
1741 * (exception being FR_TYPE_GROUP) then that results
1742 * in a parse error.
1743 * @param[in] depth How deep we are. Used to check for maximum nesting level.
1744 * @return
1745 * - <0 on error.
1746 * - 0 on success.
1747 */
1748static inline int tmpl_attr_afrom_attr_substr(TALLOC_CTX *ctx, tmpl_attr_error_t *err,
1749 tmpl_t *vpt,
1750 fr_dict_attr_t const *parent, fr_dict_attr_t const *namespace,
1751 fr_sbuff_t *name,
1752 fr_sbuff_parse_rules_t const *p_rules, tmpl_attr_rules_t const *at_rules,
1753 unsigned int depth)
1754{
1755 uint32_t oid = 0;
1756 tmpl_attr_t *ar = NULL;
1757 fr_dict_attr_t const *da;
1758 fr_sbuff_marker_t m_s;
1759 fr_dict_attr_err_t dict_err;
1760 fr_dict_attr_t const *our_parent = parent;
1761
1762 fr_sbuff_marker(&m_s, name);
1763
1764 if (depth > FR_DICT_MAX_TLV_STACK) {
1765 fr_strerror_const("Attribute nesting too deep");
1766 if (err) *err = TMPL_ATTR_ERROR_NESTING_TOO_DEEP;
1767 error:
1768 talloc_free(ar);
1769 fr_sbuff_marker_release(&m_s);
1770 FR_SBUFF_ERROR_RETURN(name);
1771 }
1772
1773 /*
1774 * Input too short
1775 */
1776 if (!fr_sbuff_extend(name)) {
1777 fr_strerror_const("Missing attribute reference");
1778 if (err) *err = TMPL_ATTR_ERROR_INVALID_NAME;
1779 goto error;
1780 }
1781
1782 /*
1783 * Maybe there's no child namespace (struct member, tlv child, etc). In which case we must
1784 * search from the default dictionary root.
1785 *
1786 * This search is probably wrong in some cases. See the comments below around FR_TYPE_GROUP.
1787 *
1788 * If we change out the dictionaries, we should arguably also change dict_def in the
1789 * tmpl_attr_rules_t. On top of that, the "dict_attr_search" functions take a #fr_dict_t
1790 * pointer, and not a pointer to the dict root. So we can't pass them a namespace.
1791 */
1792 if (!namespace) {
1793 fr_assert(parent == NULL);
1794
1795 (void)fr_dict_attr_search_by_qualified_name_substr(&dict_err, &da,
1796 at_rules->dict_def,
1797 name, p_rules ? p_rules->terminals : NULL,
1798 true,
1799 at_rules->allow_foreign);
1800 /*
1801 * The attribute was found either in the dict_def root, OR in the internal root, OR if
1802 * !dict_def && allow_foreign, in some other dictionary root.
1803 *
1804 * Otherwise we're still not sure what the attribute is. It may end up being an
1805 * unresolved one.
1806 */
1807 if (da) {
1808 our_parent = da->parent;
1809
1810 if (!our_parent->flags.is_root) {
1811 tmpl_attr_ref_fixup(ctx, vpt, our_parent, fr_dict_root(da->dict));
1812 }
1813 }
1814 } else {
1815 fr_assert(parent != NULL);
1816
1817 /*
1818 * Otherwise we're resolving the next piece in the context of where-ever we ended up from
1819 * parsing the last bit.
1820 *
1821 * The "parent" could be the same as "namespace", if both are at a dictionary root, OR
1822 * both are from a struct / tlv attribute.
1823
1824 * Or, "parent" could be a grouping attribute (e.g. request), and "namespace" could be
1825 * the dictionary root.
1826 */
1827 (void)fr_dict_attr_by_name_substr(&dict_err,
1828 &da,
1829 namespace,
1830 name,
1831 p_rules ? p_rules->terminals : NULL);
1832
1833 /*
1834 * Allow fallback to internal attributes
1835 * if the parent was a group, and we're
1836 * allowing internal resolution.
1837 *
1838 * Discard any errors here... It's more
1839 * useful to have the original.
1840 */
1841 if (!da) {
1842 ar = tmpl_attr_list_tail(&vpt->data.attribute.ar);
1843 if (!ar || ((ar->type == TMPL_ATTR_TYPE_NORMAL) && (ar->ar_da->type == FR_TYPE_GROUP))) {
1844 fr_dict_attr_t const *internal_root = fr_dict_root(fr_dict_internal());
1845
1846 (void)fr_dict_attr_by_name_substr(NULL,
1847 &da, internal_root,
1848 name,
1849 p_rules ? p_rules->terminals : NULL);
1850 if (da) {
1851 dict_err = FR_DICT_ATTR_OK;
1852 our_parent = internal_root;
1853 }
1854 }
1855 ar = NULL;
1856
1857 } else {
1858 /*
1859 * If we searched in a local dictionary, but found a real attribute
1860 * switch the namespace.
1861 */
1862 if (!da->flags.local && namespace->flags.local) namespace = our_parent = fr_dict_root(da->dict);
1863
1864 /*
1865 * We had an alias in the same namespace,
1866 * go add more things in.
1867 */
1868 if (da->parent != our_parent) {
1869 fr_assert(namespace == our_parent);
1870 tmpl_attr_ref_fixup(ctx, vpt, da->parent, our_parent);
1871 }
1872 }
1873 }
1874
1875 /*
1876 * Fatal errors related to nesting...
1877 */
1878 switch (dict_err) {
1879 case FR_DICT_ATTR_NO_CHILDREN:
1880 fr_assert(our_parent != NULL);
1881 if (our_parent->flags.is_unknown) break;
1882 goto error;
1883
1884 case FR_DICT_ATTR_NOT_DESCENDENT:
1885 goto error;
1886
1887 default:
1888 if (!da) break;
1889
1890 /*
1891 * The named component was a known attribute
1892 * so record it as a normal attribute
1893 * reference.
1894 */
1895 fr_assert(our_parent != NULL);
1896 goto alloc_ar;
1897 }
1898
1899 /*
1900 * At this point we haven't found a known attribute. What remains MUST be an OID component, OR an
1901 * unresolved attribute.
1902 *
1903 * The default is to parse the OIDs in the current namespace. If there is none, then we parse
1904 * the OIDs and unresolved attributes in the dict_def. And if that doesn't exist, in the
1905 * internal dictionaries.
1906 *
1907 * Note that we do NOT allow unknown attributes in the internal dictionary. Those attributes are
1908 * generally just DEFINEs, and their numbers have no meaning.
1909 */
1910 if (!namespace) {
1911 if (at_rules->dict_def) {
1912 our_parent = namespace = fr_dict_root(at_rules->dict_def);
1913 } else {
1914 our_parent = namespace = fr_dict_root(fr_dict_internal());
1915 }
1916 }
1917
1918 fr_assert(our_parent != NULL);
1919 fr_assert(namespace != NULL);
1920
1921 /*
1922 * See if the ref begins with an unsigned integer
1923 * if it does it's probably an OID component
1924 *
1925 * .<oid>
1926 */
1927 if (fr_sbuff_out(NULL, &oid, name) > 0) {
1928 namespace = fr_dict_unlocal(namespace);
1929
1930 fr_assert(ar == NULL);
1931
1932 fr_strerror_clear(); /* Clear out any existing errors */
1933
1934 if (fr_dict_by_da(namespace) == fr_dict_internal()) goto disallow_unknown;
1935
1936 /*
1937 * The OID component was a known attribute
1938 * so record it as a normal attribute
1939 * reference.
1940 */
1941 da = fr_dict_attr_child_by_num(namespace, oid);
1942 if (da) goto alloc_ar;
1943
1944 if (!at_rules->allow_unknown) {
1945 disallow_unknown:
1946 fr_strerror_const("Unknown attributes not allowed here");
1947 if (err) *err = TMPL_ATTR_ERROR_UNKNOWN_NOT_ALLOWED;
1948 fr_sbuff_set(name, &m_s);
1949 goto error;
1950 }
1951
1952 /*
1953 * If it's numeric and not a known attribute
1954 * then we create an unknown attribute with
1955 * the specified attribute number.
1956 */
1957 MEM(ar = talloc(ctx, tmpl_attr_t));
1958
1959 /*
1960 * VSAs have VENDORs as children. All others are just normal things.
1961 */
1962 switch (namespace->type) {
1963 case FR_TYPE_VSA:
1964 da = fr_dict_attr_unknown_vendor_afrom_num(ar, namespace, oid);
1965 break;
1966
1967 default:
1968 da = fr_dict_attr_unknown_raw_afrom_num(ar, namespace, oid);
1969 break;
1970 }
1971
1972 if (!da) {
1973 if (err) *err = TMPL_ATTR_ERROR_UNKNOWN_NOT_ALLOWED; /* strerror set by dict function */
1974 goto error;
1975 }
1976
1977 *ar = (tmpl_attr_t){
1978 .ar_num = NUM_UNSPEC,
1979 .ar_type = TMPL_ATTR_TYPE_UNKNOWN,
1980 .ar_unknown = UNCONST(fr_dict_attr_t *, da),
1981 .ar_da = da,
1982 .ar_parent = our_parent,
1983 };
1984 goto do_suffix;
1985 }
1986
1987 /*
1988 * Can't parse it as an attribute, might be a literal string
1989 * let the caller decide.
1990 *
1991 * Don't alter the fr_strerror buffer, may contain useful
1992 * errors from the dictionary code.
1993 */
1994 if (!at_rules->allow_unresolved && !(at_rules->allow_wildcard && fr_sbuff_is_char(name, '['))) {
1995 fr_strerror_const_push("Unresolved attributes are not allowed here");
1996 if (err) *err = TMPL_ATTR_ERROR_UNRESOLVED_NOT_ALLOWED;
1997 fr_sbuff_set(name, &m_s);
1998 goto error;
1999 }
2000
2001 fr_sbuff_marker_release(&m_s);
2002
2003 /*
2004 * Once we hit one unresolved attribute we have to treat
2005 * the rest of the components are unresolved as well.
2006 */
2007 return tmpl_attr_ref_afrom_unresolved_substr(ctx, err, vpt, our_parent, namespace, name, at_rules);
2008
2009alloc_ar:
2010 /*
2011 * We have a da, remove any of the errors recorded from failed
2012 * searches to find the attribute to avoid misleading messages
2013 * if something else fails.
2014 */
2015 fr_strerror_clear();
2016
2017 MEM(ar = talloc(ctx, tmpl_attr_t));
2018 *ar = (tmpl_attr_t) {
2019 .ar_num = NUM_UNSPEC,
2020 .ar_type = TMPL_ATTR_TYPE_NORMAL,
2021 .ar_da = da,
2022 .ar_parent = our_parent,
2023 };
2024
2025do_suffix:
2026 /*
2027 * Parse the attribute reference filter
2028 *
2029 * Error out immediately if the filter is bad
2030 * otherwise determine whether to keep the
2031 * attribute reference or omit it based on:
2032 *
2033 * - Whether there was a filter present.
2034 * - The type of attribute.
2035 * - If this is the leaf attribute reference.
2036 */
2037 if (tmpl_attr_parse_filter(err, ar, name, at_rules) < 0) goto error;
2038
2039 /*
2040 * Local variables are always unitary.
2041 *
2042 * [0] is allowed, as is [n], [*], and [#]. But [1], etc. aren't allowed.
2043 */
2044 if (da->flags.local && (ar->ar_num > 0)) {
2045 fr_strerror_printf("Invalid array reference for local variable");
2046 if (err) *err = TMPL_ATTR_ERROR_INVALID_ARRAY_INDEX;
2047 fr_sbuff_set(name, &m_s);
2048 goto error;
2049 }
2050
2051 /*
2052 * At the end of the attribute reference. If there's a
2053 * trailing '.' then there's another attribute reference
2054 * we need to parse, otherwise we're done.
2055 */
2056 fr_sbuff_marker_release(&m_s);
2057 fr_sbuff_marker(&m_s, name);
2058
2059 if (fr_sbuff_next_if_char(name, '.')) {
2060 fr_dict_attr_t const *ref;
2061
2062 switch (da->type) {
2063 case FR_TYPE_GROUP:
2064 ref = fr_dict_attr_ref(da);
2065
2066 /*
2067 * If the ref is outside of the internal namespace, then we use it.
2068 *
2069 * If the ref is inside of the internal namespace (e.g. "request"), then we do
2070 * something else.
2071 *
2072 * If we were given a root dictionary on input, use that. We have to follow this
2073 * dictionary because this function calls itself recursively, WITHOUT updating
2074 * "dict_def" in the attr_rules. So the dict-def there is whatever got passed
2075 * into tmpl_afrom_attr_substr(), BEFORE the "parent.parent.parent..." parsing.
2076 * Which means that in many cases, the "dict_def" is completely irrelevant.
2077 *
2078 * If there is no parent on input, then we just use dict_def.
2079 *
2080 * Otherwise we search through all of the dictionaries.
2081 *
2082 * Note that we cannot put random protocol attributes into an internal attribute
2083 * of type "group".
2084 */
2085 if (ref != fr_dict_root(fr_dict_internal())) {
2086 our_parent = namespace = ref;
2087
2088 } else if (parent && parent->flags.is_root) {
2089 our_parent = namespace = parent;
2090
2091 } else if (at_rules->dict_def) {
2092 our_parent = namespace = fr_dict_root(at_rules->dict_def);
2093
2094 } else {
2095 our_parent = namespace = NULL;
2096 }
2097 break;
2098
2099 case FR_TYPE_STRUCT:
2100 case FR_TYPE_TLV:
2101 case FR_TYPE_VENDOR:
2102 case FR_TYPE_VSA:
2103 is_union:
2104 /*
2105 * Structural types are parented and namespaced from their parent da.
2106 */
2107 namespace = our_parent = da;
2108 break;
2109
2110 default:
2111 /*
2112 * Key fields can have children, because we really don't know how else to
2113 * represent the child structures.
2114 */
2115 if (fr_dict_attr_is_key_field(da)) goto is_union;
2116
2117 fr_strerror_printf("Parent type of nested attribute %s must be of type "
2118 "\"struct\", \"tlv\", \"vendor\", \"vsa\" or \"group\", got \"%s\"",
2119 da->name,
2120 fr_type_to_str(da->type));
2121 fr_sbuff_set(name, &m_s);
2122 goto error;
2123 }
2124
2125 if (ar) tmpl_attr_insert(vpt, ar);
2126
2127 if (tmpl_attr_afrom_attr_substr(ctx, err, vpt, our_parent, namespace, name, p_rules, at_rules, depth + 1) < 0) {
2128 if (ar) {
2129 tmpl_attr_list_talloc_free_tail(&vpt->data.attribute.ar); /* Remove and free ar */
2130 ar = NULL;
2131 }
2132 goto error;
2133 }
2134
2135 /*
2136 * If it's a leaf we always insert the attribute
2137 * reference into the list, even if it's a
2138 * nesting attribute.
2139 *
2140 * This is useful for nested edit sections
2141 * where the tmpl might be the name of a new
2142 * subsection.
2143 */
2144 } else {
2145 tmpl_attr_insert(vpt, ar);
2146 }
2147
2148 /*
2149 * Remove unnecessary casts.
2150 */
2151 if (tmpl_is_attr(vpt) && tmpl_attr_tail_is_normal(vpt) &&
2152 (tmpl_rules_cast(vpt) == tmpl_attr_tail_da(vpt)->type)) vpt->rules.cast = FR_TYPE_NULL;
2153
2154 TMPL_VERIFY(vpt);
2155
2156 fr_sbuff_marker_release(&m_s);
2157 return 0;
2158}
2159
2160/** Parse a string into a TMPL_TYPE_ATTR_* type #tmpl_t
2161 *
2162 * @param[in,out] ctx to allocate #tmpl_t in.
2163 * @param[out] err May be NULL. Provides the exact error that the parser hit
2164 * when processing the attribute ref.
2165 * @param[out] out Where to write pointer to new #tmpl_t.
2166 * @param[in] name of attribute including #tmpl_request_ref_t and #fr_pair_list_t qualifiers.
2167 * @param[in] p_rules Formatting rules used to check for trailing garbage.
2168 * @param[in] t_rules Rules which control parsing:
2169 * - dict_def The default dictionary to use if attributes
2170 * are unqualified.
2171 * - request_def The default #request_t to set if no
2172 * #tmpl_request_ref_t qualifiers are found in name.
2173 * - list_def The default list to set if no #fr_pair_list_t
2174 * qualifiers are found in the name.
2175 * - allow_unknown If true attributes in the format accepted by
2176 * #fr_dict_attr_unknown_afrom_oid_substr will be allowed,
2177 * even if they're not in the main dictionaries.
2178 * If an unknown attribute is found a #TMPL_TYPE_ATTR
2179 * #tmpl_t will be produced.
2180 * If #tmpl_afrom_attr_substr is being called on
2181 * startup, the #tmpl_t may be passed to
2182 * #tmpl_attr_unknown_add to
2183 * add the unknown attribute to the main dictionary.
2184 * If the unknown attribute is not added to
2185 * the main dictionary the #tmpl_t cannot be used
2186 * to search for a #fr_pair_t in a #request_t.
2187 * - allow_unresolved If true, we don't generate a parse error on
2188 * unknown attributes. If an unknown attribute is
2189 * found a #TMPL_TYPE_ATTR_UNRESOLVED
2190 * #tmpl_t will be produced.
2191 * - allow_foreign If true, allow attribute names to be qualified
2192 * with a protocol outside of the passed dict_def.
2193 * - disallow_filters
2194 *
2195 * @see REMARKER to produce pretty error markers from the return value.
2196 *
2197 * @return
2198 * - <= 0 on error (offset as negative integer)
2199 * - > 0 on success (number of bytes parsed).
2200 */
2201ssize_t tmpl_afrom_attr_substr(TALLOC_CTX *ctx, tmpl_attr_error_t *err,
2202 tmpl_t **out, fr_sbuff_t *name,
2203 fr_sbuff_parse_rules_t const *p_rules,
2204 tmpl_rules_t const *t_rules)
2205{
2206 int ret;
2207 tmpl_t *vpt;
2208 fr_sbuff_t our_name = FR_SBUFF(name); /* Take a local copy in case we need to back track */
2209 bool is_raw = false;
2210 tmpl_attr_rules_t const *at_rules;
2211 fr_sbuff_marker_t m_l;
2212 fr_dict_attr_t const *namespace;
2213 DEFAULT_RULES;
2214
2215 CHECK_T_RULES;
2216
2217 at_rules = &t_rules->attr;
2218
2219 if (err) *err = TMPL_ATTR_ERROR_NONE;
2220
2221 if (!fr_sbuff_extend(&our_name)) {
2222 fr_strerror_const("Empty attribute reference");
2223 if (err) *err = TMPL_ATTR_ERROR_EMPTY;
2224 FR_SBUFF_ERROR_RETURN(&our_name);
2225 }
2226
2227 /*
2228 * '&' prefix is ignored.
2229 */
2230 (void) fr_sbuff_next_if_char(&our_name, '&');
2231
2232 /*
2233 * We parsed the tmpl as User-Name, but NOT %{User-Name}.
2234 */
2235 MEM(vpt = tmpl_alloc(ctx, TMPL_TYPE_ATTR, T_BARE_WORD, NULL, 0));
2236
2237 /*
2238 * The "raw." prefix marks up the leaf attribute
2239 * as unknown if it wasn't already which allows
2240 * users to stick whatever they want in there as
2241 * a value.
2242 */
2243 if (fr_sbuff_adv_past_strcase_literal(&our_name, "raw.")) is_raw = true;
2244
2245 /*
2246 * Parse one or more request references
2247 */
2248 ret = tmpl_request_ref_list_from_substr(vpt, NULL,
2249 &vpt->data.attribute.rr,
2250 &our_name,
2251 p_rules,
2252 t_rules,
2253 &namespace);
2254 if (ret < 0) {
2255 error:
2256 *out = NULL;
2257 talloc_free(vpt);
2258 FR_SBUFF_ERROR_RETURN(&our_name);
2259 }
2260
2261 fr_sbuff_marker(&m_l, &our_name);
2262
2263 /*
2264 * Parse the list and / or attribute reference
2265 */
2266 ret = tmpl_attr_afrom_attr_substr(vpt, err,
2267 vpt,
2268 namespace, namespace,
2269 &our_name, p_rules, at_rules, 0);
2270 if (ret < 0) goto error;
2271
2272 /*
2273 * Check to see if the user wants the leaf
2274 * attribute to be raw.
2275 *
2276 * We can only do the conversion now _if_
2277 * the complete hierarchy has been resolved
2278 * otherwise we'll need to do the conversion
2279 * later.
2280 */
2281 if (tmpl_is_attr(vpt) && is_raw) tmpl_attr_to_raw(vpt);
2282
2283 /*
2284 * Local variables cannot be given a list modifier.
2285 */
2286 if (tmpl_is_attr(vpt) && tmpl_attr_tail_da(vpt)) {
2287 tmpl_attr_t *ar = tmpl_attr_list_head(tmpl_attr(vpt));
2288 bool is_local = ar->ar_da->flags.local;
2289
2290 for (; ar != NULL;
2291 ar = tmpl_attr_list_next(tmpl_attr(vpt), ar)) {
2292 if (!ar->ar_da->flags.local ||
2293 (ar->ar_da->flags.local && is_local)) continue;
2294
2295 fr_strerror_printf("Local attributes cannot be used in any list");
2296 if (err) *err = TMPL_ATTR_ERROR_FOREIGN_NOT_ALLOWED;
2297 fr_sbuff_set(&our_name, &m_l);
2298 goto error;
2299 }
2300
2301 /*
2302 * That being said, local variables are named "foo", but are always put into the local list.
2303 */
2304 if (is_local && (at_rules->list_presence != TMPL_ATTR_LIST_FORBID)) {
2305 MEM(ar = talloc(vpt, tmpl_attr_t));
2306 *ar = (tmpl_attr_t){
2307 .ar_type = TMPL_ATTR_TYPE_NORMAL,
2308 .ar_da = request_attr_local,
2309 .ar_parent = fr_dict_root(fr_dict_internal())
2310 };
2311
2312 /*
2313 * Prepend the local list ref so it gets evaluated
2314 * first.
2315 */
2316 tmpl_attr_list_insert_head(tmpl_attr(vpt), ar);
2317 }
2318 }
2319
2320 /*
2321 * Check whether the tmpl has a list qualifier.
2322 */
2323 switch (at_rules->list_presence) {
2324 case TMPL_ATTR_LIST_ALLOW:
2325 break;
2326
2327 case TMPL_ATTR_LIST_FORBID:
2328 if (tmpl_attr_is_list_attr(tmpl_attr_list_head(tmpl_attr(vpt)))) {
2329 fr_strerror_const("List qualifiers are not allowed here.");
2330 if (err) *err = TMPL_ATTR_ERROR_LIST_NOT_ALLOWED;
2331 goto error;
2332 }
2333 break;
2334
2335 case TMPL_ATTR_LIST_REQUIRE:
2336 if (!tmpl_attr_is_list_attr(tmpl_attr_list_head(tmpl_attr(vpt)))) {
2337 fr_strerror_const("List qualifier is required, but no list was found.");
2338 if (err) *err = TMPL_ATTR_ERROR_LIST_MISSING;
2339 goto error;
2340 }
2341 break;
2342 }
2343
2344 /*
2345 * If we're using lists, ensure that the default list is specified.
2346 */
2347 if (!tmpl_attr_is_list_attr(tmpl_attr_list_head(tmpl_attr(vpt)))) {
2348 tmpl_attr_t *ar;
2349
2350 MEM(ar = talloc(vpt, tmpl_attr_t));
2351 *ar = (tmpl_attr_t){
2352 .ar_type = TMPL_ATTR_TYPE_NORMAL,
2353 .ar_parent = fr_dict_root(fr_dict_internal())
2354 };
2355
2356 fr_assert(at_rules->list_def);
2357 ar->ar_da = at_rules->list_def;
2358
2359 /*
2360 * Prepend the list ref so it gets evaluated
2361 * first.
2362 */
2363 tmpl_attr_list_insert_head(tmpl_attr(vpt), ar);
2364 }
2365
2366 tmpl_set_name(vpt, T_BARE_WORD, fr_sbuff_start(&our_name), fr_sbuff_used(&our_name));
2367 vpt->rules = *t_rules; /* Record the rules */
2368
2369 /*
2370 * If there are actual requests, duplicate them
2371 * and move them into the list.
2372 *
2373 * A NULL request_def pointer is equivalent to the
2374 * current request.
2375 */
2376 if (t_rules->attr.request_def) {
2377 tmpl_request_ref_list_acopy(vpt, &vpt->rules.attr.request_def, t_rules->attr.request_def);
2378 }
2379
2380 if (tmpl_is_attr(vpt)) {
2381 tmpl_attr_t *ar;
2382
2383 /*
2384 * Suppress useless casts.
2385 */
2386 if (tmpl_attr_tail_is_normal(vpt) && (tmpl_attr_tail_da(vpt)->type == tmpl_rules_cast(vpt))) {
2387 vpt->rules.cast = FR_TYPE_NULL;
2388 }
2389
2390 /*
2391 * Ensure that the list is set correctly, so that
2392 * the returned vpt just doesn't just match the
2393 * input rules, it is also internally consistent.
2394 */
2395 ar = tmpl_attr_list_head(tmpl_attr(vpt));
2396 fr_assert(ar != NULL);
2397
2398 if (tmpl_attr_is_list_attr(ar)) vpt->rules.attr.list_def = ar->ar_da;
2399 }
2400
2401 if (!tmpl_substr_terminal_check(&our_name, p_rules)) {
2402 fr_strerror_const("Unexpected text after attribute reference");
2403 if (err) *err = TMPL_ATTR_ERROR_MISSING_TERMINATOR;
2404 goto error;
2405 }
2406
2407 /*
2408 * If everything was resolved correctly
2409 * we now need to check the cast type.
2410 */
2411 if (!tmpl_needs_resolving(vpt) && !fr_type_is_null(t_rules->cast) &&
2412 !fr_type_cast(t_rules->cast, tmpl_attr_tail_da(vpt)->type)) {
2413 fr_strerror_printf("Cannot cast type '%s' to '%s'",
2414 fr_type_to_str(tmpl_attr_tail_da(vpt)->type), fr_type_to_str(t_rules->cast));
2415 if (err) *err = TMPL_ATTR_ERROR_BAD_CAST;
2416 fr_sbuff_set_to_start(&our_name);
2417 goto error;
2418 }
2419
2420 TMPL_VERIFY(vpt); /* Because we want to ensure we produced something sane */
2421
2422 *out = vpt;
2423 FR_SBUFF_SET_RETURN(name, &our_name);
2424}
2425
2426/** Parse a string into a TMPL_TYPE_ATTR_* type #tmpl_t
2427 *
2428 * @param[in,out] ctx to allocate #tmpl_t in.
2429 * @param[out] err May be NULL. Provides the exact error that the parser hit
2430 * when processing the attribute ref.
2431 * @param[out] out Where to write pointer to new #tmpl_t.
2432 * @param[in] name of attribute including #tmpl_request_ref_t and #fr_pair_list_t qualifiers.
2433 * @param[in] t_rules Rules which control parsing. See tmpl_afrom_attr_substr() for details.
2434 *
2435 * @note Unlike #tmpl_afrom_attr_substr this function will error out if the entire
2436 * name string isn't parsed.
2437 */
2438ssize_t tmpl_afrom_attr_str(TALLOC_CTX *ctx, tmpl_attr_error_t *err,
2439 tmpl_t **out, char const *name, tmpl_rules_t const *t_rules)
2440{
2441 ssize_t slen, name_len;
2442 DEFAULT_RULES;
2443
2444 CHECK_T_RULES;
2445
2446 name_len = strlen(name);
2447 slen = tmpl_afrom_attr_substr(ctx, err, out, &FR_SBUFF_IN(name, name_len), NULL, t_rules);
2448 if (slen <= 0) return slen;
2449
2450 if (!fr_cond_assert(*out)) return -1;
2451
2452 if (slen != name_len) {
2453 /* This looks wrong, but it produces meaningful errors for unknown attrs */
2454 fr_strerror_printf("Unexpected text after %s",
2455 tmpl_type_to_str((*out)->type));
2456 return -slen;
2457 }
2458
2459 TMPL_VERIFY(*out);
2460
2461 return slen;
2462}
2463
2464/** Create TMPL_TYPE_DATA from a string
2465 *
2466 * @param[in] ctx to allocate tmpl to.
2467 * @param[out] out where to write tmpl.
2468 * @param[in] in sbuff to parse.
2469 * @param[in] quote surrounding the operand to parse.
2470 * @param[in] t_rules specifying the cast and any enumeration values.
2471 * @param[in] allow_enum Whether parsing the value as an enum should be allowed.
2472 * @param[in] p_rules formatting rules.
2473 * @return
2474 * - <0 on error
2475 * - >=0 on success.
2476 */
2477static fr_slen_t tmpl_afrom_value_substr(TALLOC_CTX *ctx, tmpl_t **out, fr_sbuff_t *in,
2478 fr_token_t quote,
2479 tmpl_rules_t const *t_rules, bool allow_enum,
2480 fr_sbuff_parse_rules_t const *p_rules)
2481{
2482 fr_sbuff_t our_in = FR_SBUFF(in);
2483 fr_value_box_t tmp;
2484 tmpl_t *vpt;
2485 fr_type_t cast = FR_TYPE_STRING;
2486
2487 if (!fr_type_is_null(t_rules->cast)) cast = t_rules->cast;
2488
2489 if (!fr_type_is_leaf(cast)) {
2490 fr_strerror_printf("%s is not a valid cast type",
2491 fr_type_to_str(cast));
2492 FR_SBUFF_ERROR_RETURN(&our_in);
2493 }
2494
2495 vpt = tmpl_alloc_null(ctx);
2496 if (fr_value_box_from_substr(vpt, &tmp,
2497 cast, allow_enum ? t_rules->enumv : NULL,
2498 &our_in, p_rules) < 0) {
2499 talloc_free(vpt);
2500 FR_SBUFF_ERROR_RETURN(&our_in);
2501 }
2502 fr_value_box_mark_safe_for(&tmp, t_rules->literals_safe_for);
2503
2504 tmpl_init(vpt, TMPL_TYPE_DATA, quote, fr_sbuff_start(&our_in), fr_sbuff_used(&our_in), t_rules);
2505
2506 fr_value_box_copy_shallow(NULL, tmpl_value(vpt), &tmp);
2507
2508 *out = vpt;
2509
2510 if (cast == tmpl_value_type(vpt)) vpt->rules.cast = FR_TYPE_NULL;
2511
2512 TMPL_VERIFY(vpt);
2513
2514 FR_SBUFF_SET_RETURN(in, &our_in);
2515}
2516
2517/** Parse a truth value
2518 *
2519 * @param[in] ctx to allocate tmpl to.
2520 * @param[out] out where to write tmpl.
2521 * @param[in] in sbuff to parse.
2522 * @param[in] p_rules formatting rules.
2523 * @return
2524 * - < 0 sbuff does not contain a boolean value.
2525 * - > 0 how many bytes were parsed.
2526 */
2527static fr_slen_t tmpl_afrom_bool_substr(TALLOC_CTX *ctx, tmpl_t **out, fr_sbuff_t *in,
2528 fr_sbuff_parse_rules_t const *p_rules)
2529{
2530 fr_sbuff_t our_in = FR_SBUFF(in);
2531 bool a_bool;
2532 tmpl_t *vpt;
2533
2534 if (fr_sbuff_out(NULL, &a_bool, &our_in) < 0) {
2535 fr_strerror_const("Not a boolean value");
2536 return 0;
2537 }
2538
2539 if (!tmpl_substr_terminal_check(&our_in, p_rules)) {
2540 fr_strerror_const("Unexpected text after bool");
2541 FR_SBUFF_ERROR_RETURN(in);
2542 }
2543
2544 MEM(vpt = tmpl_alloc(ctx, TMPL_TYPE_DATA, T_BARE_WORD, fr_sbuff_start(&our_in), fr_sbuff_used(&our_in)));
2545
2546 fr_value_box_init(&vpt->data.literal, FR_TYPE_BOOL, NULL, false);
2547 vpt->data.literal.vb_bool = a_bool;
2548
2549 *out = vpt;
2550
2551 FR_SBUFF_SET_RETURN(in, &our_in);
2552}
2553
2554/** Parse bareword as an octet string
2555 *
2556 * @param[in] ctx to allocate tmpl to.
2557 * @param[out] out where to write tmpl.
2558 * @param[in] in sbuff to parse.
2559 * @param[in] p_rules formatting rules.
2560 * @return
2561 * - < 0 negative offset where parse error occurred.
2562 * - 0 sbuff does not contain a hex string.
2563 * - > 0 how many bytes were parsed.
2564 */
2565static fr_slen_t tmpl_afrom_octets_substr(TALLOC_CTX *ctx, tmpl_t **out, fr_sbuff_t *in,
2566 fr_sbuff_parse_rules_t const *p_rules)
2567{
2568 fr_sbuff_t our_in = FR_SBUFF(in);
2569 tmpl_t *vpt;
2570 char *hex;
2571 size_t binlen, len;
2572 uint8_t *bin;
2573
2574 if (!fr_sbuff_adv_past_strcase_literal(&our_in, "0x")) return 0;
2575
2576 MEM(vpt = tmpl_alloc(ctx, TMPL_TYPE_DATA, T_BARE_WORD, NULL, 0));
2577
2578 /*
2579 * This allows stream parsing to work correctly
2580 * we could be less lazy and copy hex data in
2581 * chunks, but never mind...
2582 */
2583 len = fr_sbuff_out_abstrncpy_allowed(vpt, &hex, &our_in, SIZE_MAX, sbuff_char_class_hex);
2584 if (len & 0x01) {
2585 fr_strerror_const("Hex string not even length");
2586 error:
2587 talloc_free(vpt);
2588 FR_SBUFF_ERROR_RETURN(&our_in);
2589 }
2590 if (len == 0) {
2591 fr_strerror_const("Zero length hex string is invalid");
2592 goto error;
2593 }
2594
2595 if (!tmpl_substr_terminal_check(&our_in, p_rules)) {
2596 fr_strerror_const("Unexpected text after hex string");
2597 goto error;
2598 }
2599
2600 bin = (uint8_t *)hex;
2601 binlen = len / 2;
2602
2603 tmpl_set_name(vpt, T_BARE_WORD, fr_sbuff_start(&our_in), fr_sbuff_used(&our_in));
2604
2605 (void)fr_base16_decode(NULL, &FR_DBUFF_TMP(bin, binlen), &FR_SBUFF_IN(hex, len), false);
2606 MEM(bin = talloc_realloc_size(vpt, bin, binlen)); /* Realloc to the correct length */
2607 (void)fr_value_box_memdup_shallow(&vpt->data.literal, NULL, bin, binlen, false);
2608
2609 *out = vpt;
2610
2611 FR_SBUFF_SET_RETURN(in, &our_in);
2612}
2613
2614/** Parse bareword as an IPv4 address or prefix
2615 *
2616 * @param[in] ctx to allocate tmpl to.
2617 * @param[out] out where to write tmpl.
2618 * @param[in] in sbuff to parse.
2619 * @param[in] p_rules formatting rules.
2620 * @return
2621 * - < 0 sbuff does not contain an IPv4 address or prefix.
2622 * - > 0 how many bytes were parsed.
2623 */
2624static fr_slen_t tmpl_afrom_ipv4_substr(TALLOC_CTX *ctx, tmpl_t **out, fr_sbuff_t *in,
2625 fr_sbuff_parse_rules_t const *p_rules)
2626{
2627 tmpl_t *vpt;
2628 fr_sbuff_t our_in = FR_SBUFF(in);
2629 fr_type_t type;
2630 int count;
2631 uint32_t ipaddr;
2632 uint8_t addr[4] = {}, prefix = 32;
2633
2634 for (count = 0; count < 4; count++) {
2635 if (!fr_sbuff_out(NULL, &addr[count], &our_in)) FR_SBUFF_ERROR_RETURN(&our_in);
2636
2637 if (count == 3) break;
2638
2639 if (fr_sbuff_next_if_char(&our_in, '.')) continue;
2640
2641 if (!fr_sbuff_is_char(&our_in, '/')) FR_SBUFF_ERROR_RETURN(&our_in);
2642 }
2643
2644 /*
2645 * If it has a trailing '/' then it's an IP prefix.
2646 */
2647 if (fr_sbuff_next_if_char(&our_in, '/')) {
2648 if (fr_sbuff_out(NULL, &prefix, &our_in) < 0) {
2649 fr_strerror_const("IPv4 CIDR mask malformed");
2650 FR_SBUFF_ERROR_RETURN(&our_in);
2651 }
2652
2653 if (prefix > 32) {
2654 fr_strerror_const("IPv4 CIDR mask too high");
2655 FR_SBUFF_ERROR_RETURN(&our_in);
2656 }
2657
2658 type = FR_TYPE_IPV4_PREFIX;
2659 } else {
2660 type = FR_TYPE_IPV4_ADDR;
2661 }
2662
2663 if (!tmpl_substr_terminal_check(&our_in, p_rules)) {
2664 fr_strerror_const("Unexpected text after IPv4 string or prefix");
2665 FR_SBUFF_ERROR_RETURN(&our_in);
2666 }
2667
2668 MEM(vpt = tmpl_alloc(ctx, TMPL_TYPE_DATA, T_BARE_WORD, fr_sbuff_start(&our_in), fr_sbuff_used(&our_in)));
2669 fr_value_box_init(&vpt->data.literal, type, NULL, false);
2670 vpt->data.literal.vb_ip.af = AF_INET;
2671 vpt->data.literal.vb_ip.prefix = prefix;
2672
2673 /*
2674 * Zero out lower bits
2675 */
2676 ipaddr = (((uint32_t) addr[0]) << 24) | (((uint32_t) addr[1]) << 16) | (((uint32_t) addr[2]) << 8) | addr[3];
2677 if (prefix < 32) {
2678 ipaddr &= ~((uint32_t) 0) << (32 - prefix);
2679 }
2680 vpt->data.literal.vb_ip.addr.v4.s_addr = htonl(ipaddr);
2681
2682 *out = vpt;
2683
2684 FR_SBUFF_SET_RETURN(in, &our_in);
2685}
2686
2687/** Parse bareword as an IPv6 address or prefix
2688 *
2689 * @param[in] ctx to allocate tmpl to.
2690 * @param[out] out where to write tmpl.
2691 * @param[in] in sbuff to parse.
2692 * @param[in] p_rules formatting rules.
2693 * @return
2694 * - < 0 sbuff does not contain an IPv4 address or prefix.
2695 * - > 0 how many bytes were parsed.
2696 */
2697static fr_slen_t tmpl_afrom_ipv6_substr(TALLOC_CTX *ctx, tmpl_t **out, fr_sbuff_t *in,
2698 fr_sbuff_parse_rules_t const *p_rules)
2699{
2700 tmpl_t *vpt;
2701 fr_sbuff_t our_in = FR_SBUFF(in);
2702 fr_sbuff_marker_t m;
2703 fr_type_t type;
2704 size_t len;
2705 char *sep_a, *sep_b;
2706
2707 static bool ipv6_chars[UINT8_MAX + 1] = {
2708 ['0'] = true, ['1'] = true, ['2'] = true, ['3'] = true, ['4'] = true,
2709 ['5'] = true, ['6'] = true, ['7'] = true, ['8'] = true, ['9'] = true,
2710 ['a'] = true, ['b'] = true, ['c'] = true, ['d'] = true, ['e'] = true,
2711 ['f'] = true,
2712 ['A'] = true, ['B'] = true, ['C'] = true, ['D'] = true, ['E'] = true,
2713 ['F'] = true,
2714 [':'] = true, ['.'] = true
2715 };
2716
2717 /*
2718 * Drop a marker to pin the start of the
2719 * address in the buffer.
2720 */
2721 fr_sbuff_marker(&m, &our_in);
2722
2723 /*
2724 * Check for something looking like an IPv6 address
2725 *
2726 * Minimum string is '::'
2727 */
2728 len = fr_sbuff_adv_past_allowed(&our_in, FR_IPADDR_STRLEN + 1, ipv6_chars, NULL);
2729 if ((len < 2) || (len > FR_IPADDR_STRLEN)) {
2730 error:
2731 FR_SBUFF_ERROR_RETURN(&our_in);
2732 }
2733
2734 /*
2735 * Got ':' after '.', this isn't allowed.
2736 *
2737 * We need this check else IPv4 gets parsed
2738 * as blank IPv6 address.
2739 */
2740 sep_a = memchr(fr_sbuff_current(&m), '.', len);
2741 if (sep_a && (!(sep_b = memchr(fr_sbuff_current(&m), ':', len)) || (sep_b > sep_a))) {
2742 fr_strerror_const("First IPv6 component separator was a '.'");
2743 goto error;
2744 }
2745
2746 /*
2747 * The v6 parse function will happily turn
2748 * integers into v6 addresses *sigh*.
2749 */
2750 sep_a = memchr(fr_sbuff_current(&m), ':', len);
2751 if (!sep_a) {
2752 fr_strerror_const("No IPv6 component separator");
2753 goto error;
2754 }
2755
2756 /*
2757 * Handle scope
2758 */
2759 if (fr_sbuff_next_if_char(&our_in, '%')) {
2760 len = fr_sbuff_adv_until(&our_in, IFNAMSIZ + 1, p_rules->terminals, '\0');
2761 if ((len < 1) || (len > IFNAMSIZ)) {
2762 fr_strerror_const("IPv6 scope too long");
2763 goto error;
2764 }
2765 }
2766
2767 /*
2768 * ...and finally the prefix.
2769 */
2770 if (fr_sbuff_next_if_char(&our_in, '/')) {
2771 uint8_t mask;
2772
2773 if (fr_sbuff_out(NULL, &mask, &our_in) < 0) {
2774 fr_strerror_const("IPv6 CIDR mask malformed");
2775 goto error;
2776 }
2777 if (mask > 128) {
2778 fr_strerror_const("IPv6 CIDR mask too high");
2779 goto error;
2780 }
2781
2782 type = FR_TYPE_IPV6_PREFIX;
2783 } else {
2784 type = FR_TYPE_IPV6_ADDR;
2785 }
2786
2787 if (!tmpl_substr_terminal_check(&our_in, p_rules)) {
2788 fr_strerror_const("Unexpected text after IPv6 string or prefix");
2789 goto error;
2790 }
2791
2792 MEM(vpt = tmpl_alloc(ctx, TMPL_TYPE_DATA, T_BARE_WORD, fr_sbuff_start(&our_in), fr_sbuff_used(&our_in)));
2793 if (fr_value_box_from_substr(vpt, &vpt->data.literal, type, NULL,
2794 &FR_SBUFF_REPARSE(&our_in),
2795 NULL) < 0) {
2796 talloc_free(vpt);
2797 goto error;
2798 }
2799 *out = vpt;
2800
2801 FR_SBUFF_SET_RETURN(in, &our_in);
2802}
2803
2804
2805/** Try and parse signed or unsigned integers
2806 *
2807 * @param[in] ctx to allocate tmpl to.
2808 * @param[out] out where to write tmpl.
2809 * @param[in] in sbuff to parse.
2810 * @param[in] p_rules formatting rules.
2811 * @return
2812 * - < 0 sbuff does not contain a mac address.
2813 * - > 0 how many bytes were parsed.
2814 */
2815static ssize_t tmpl_afrom_ether_substr(TALLOC_CTX *ctx, tmpl_t **out, fr_sbuff_t *in,
2816 fr_sbuff_parse_rules_t const *p_rules)
2817{
2818 tmpl_t *vpt;
2819 fr_sbuff_t our_in = FR_SBUFF(in);
2820 uint8_t buff[6] = {};
2821 fr_dbuff_t dbuff;
2822 fr_value_box_t *vb;
2823 fr_sbuff_parse_error_t err;
2824
2825 fr_dbuff_init(&dbuff, buff, sizeof(buff));
2826
2827 fr_base16_decode(&err, &dbuff, &our_in, true);
2828 if (err != FR_SBUFF_PARSE_OK) return 0;
2829
2830 if (!fr_sbuff_next_if_char(&our_in, ':')) return 0;
2831
2832 fr_base16_decode(&err, &dbuff, &our_in, true);
2833 if (err != FR_SBUFF_PARSE_OK) return 0;
2834
2835 if (!fr_sbuff_next_if_char(&our_in, ':')) return 0;
2836
2837 fr_base16_decode(&err, &dbuff, &our_in, true);
2838 if (err != FR_SBUFF_PARSE_OK) return 0;
2839
2840 if (!fr_sbuff_next_if_char(&our_in, ':')) return 0;
2841
2842 fr_base16_decode(&err, &dbuff, &our_in, true);
2843 if (err != FR_SBUFF_PARSE_OK) return 0;
2844
2845 if (!fr_sbuff_next_if_char(&our_in, ':')) return 0;
2846
2847 fr_base16_decode(&err, &dbuff, &our_in, true);
2848 if (err != FR_SBUFF_PARSE_OK) return 0;
2849
2850 if (!fr_sbuff_next_if_char(&our_in, ':')) return 0;
2851
2852 fr_base16_decode(&err, &dbuff, &our_in, true);
2853 if (err != FR_SBUFF_PARSE_OK) return 0;
2854
2855 if (!tmpl_substr_terminal_check(&our_in, p_rules)) {
2856 fr_strerror_const("Unexpected text after mac address");
2857 return 0;
2858 }
2859
2860 MEM(vpt = tmpl_alloc(ctx, TMPL_TYPE_DATA,
2861 T_BARE_WORD, fr_sbuff_start(&our_in), fr_sbuff_used(&our_in)));
2862 vb = tmpl_value(vpt);
2863
2864 fr_value_box_init(vb, FR_TYPE_ETHERNET, NULL, false);
2865 memcpy(vb->vb_ether, buff, sizeof(vb->vb_ether));
2866
2867 *out = vpt;
2868
2869 FR_SBUFF_SET_RETURN(in, &our_in);
2870}
2871
2872/** Try and parse signed or unsigned integers
2873 *
2874 * @param[in] ctx to allocate tmpl to.
2875 * @param[out] out where to write tmpl.
2876 * @param[in] in sbuff to parse.
2877 * @param[in] p_rules formatting rules.
2878 * @return
2879 * - < 0 sbuff does not contain an integer.
2880 * - > 0 how many bytes were parsed.
2881 */
2882static fr_slen_t tmpl_afrom_integer_substr(TALLOC_CTX *ctx, tmpl_t **out, fr_sbuff_t *in,
2883 fr_sbuff_parse_rules_t const *p_rules)
2884{
2885 tmpl_t *vpt;
2886 fr_sbuff_t our_in = FR_SBUFF(in);
2887 ssize_t slen;
2888 fr_value_box_t *vb;
2889
2890 /*
2891 * Pick the narrowest signed type
2892 */
2893 if (fr_sbuff_is_char(&our_in, '-')) {
2894 int64_t a_int;
2895
2896 slen = fr_sbuff_out(NULL, &a_int, &our_in);
2897 if (slen <= 0) return 0;
2898
2899 if (!tmpl_substr_terminal_check(&our_in, p_rules)) {
2900 fr_strerror_const("Unexpected text after signed integer");
2901 error:
2902 FR_SBUFF_ERROR_RETURN(&our_in);
2903 }
2904
2905 MEM(vpt = tmpl_alloc(ctx, TMPL_TYPE_DATA,
2906 T_BARE_WORD, fr_sbuff_start(&our_in), fr_sbuff_used(&our_in)));
2907 vb = tmpl_value(vpt);
2908 if (a_int >= INT8_MIN) {
2909 fr_value_box_init(vb, FR_TYPE_INT8, NULL, false);
2910 vb->vb_int8 = (int8_t)a_int;
2911 } else if (a_int >= INT16_MIN) {
2912 fr_value_box_init(vb, FR_TYPE_INT16, NULL, false);
2913 vb->vb_int16 = (int16_t)a_int;
2914 } else if (a_int >= INT32_MIN) {
2915 fr_value_box_init(vb, FR_TYPE_INT32, NULL, false);
2916 vb->vb_int32 = (int32_t)a_int;
2917 } else {
2918 fr_value_box_init(vb, FR_TYPE_INT64, NULL, false);
2919 vb->vb_int64 = (int64_t)a_int;
2920 }
2921 /*
2922 * Pick the narrowest unsigned type
2923 */
2924 } else {
2925 uint64_t a_uint;
2926
2927 slen = fr_sbuff_out(NULL, &a_uint, &our_in);
2928 if (slen <= 0) return slen;
2929
2930 if (!tmpl_substr_terminal_check(&our_in, p_rules)) {
2931 fr_strerror_const("Unexpected text after unsigned integer");
2932 goto error;
2933 }
2934
2935 MEM(vpt = tmpl_alloc(ctx, TMPL_TYPE_DATA,
2936 T_BARE_WORD, fr_sbuff_start(&our_in), fr_sbuff_used(&our_in)));
2937 vb = tmpl_value(vpt);
2938 if (a_uint <= UINT8_MAX) {
2939 fr_value_box_init(vb, FR_TYPE_UINT8, NULL, false);
2940 vb->vb_uint8 = (uint8_t)a_uint;
2941 } else if (a_uint <= UINT16_MAX) {
2942 fr_value_box_init(vb, FR_TYPE_UINT16, NULL, false);
2943 vb->vb_uint16 = (uint16_t)a_uint;
2944 } else if (a_uint <= UINT32_MAX) {
2945 fr_value_box_init(vb, FR_TYPE_UINT32, NULL, false);
2946 vb->vb_uint32 = (uint32_t)a_uint;
2947 } else {
2948 fr_value_box_init(vb, FR_TYPE_UINT64, NULL, false);
2949 vb->vb_uint64 = (uint64_t)a_uint;
2950 }
2951 }
2952
2953 *out = vpt;
2954
2955 FR_SBUFF_SET_RETURN(in, &our_in);
2956}
2957
2958static ssize_t tmpl_afrom_float_substr(TALLOC_CTX *ctx, tmpl_t **out, fr_sbuff_t *in,
2959 fr_sbuff_parse_rules_t const *p_rules)
2960{
2961 tmpl_t *vpt;
2962 fr_sbuff_t our_in = FR_SBUFF(in);
2963 double a_float;
2964 ssize_t slen;
2965 fr_value_box_t *vb;
2966
2967 slen = fr_sbuff_out(NULL, &a_float, &our_in);
2968 if (slen <= 0) return 0;
2969
2970 if (!tmpl_substr_terminal_check(&our_in, p_rules)) {
2971 fr_strerror_const("Unexpected text after float");
2972 FR_SBUFF_ERROR_RETURN(&our_in);
2973 }
2974
2975 MEM(vpt = tmpl_alloc(ctx, TMPL_TYPE_DATA,
2976 T_BARE_WORD, fr_sbuff_start(&our_in), fr_sbuff_used(&our_in)));
2977 vb = tmpl_value(vpt);
2978 fr_value_box_init(vb, FR_TYPE_FLOAT64, NULL, false);
2979 vb->vb_float64 = a_float;
2980
2981 *out = vpt;
2982
2983 FR_SBUFF_SET_RETURN(in, &our_in);
2984}
2985
2986static ssize_t tmpl_afrom_time_delta(TALLOC_CTX *ctx, tmpl_t **out, fr_sbuff_t *in,
2987 fr_sbuff_parse_rules_t const *p_rules)
2988{
2989 tmpl_t *vpt;
2990 fr_sbuff_t our_in = FR_SBUFF(in);
2991 fr_time_delta_t a_delta;
2992 fr_slen_t slen;
2993 fr_value_box_t *vb;
2994
2995 slen = fr_time_delta_from_substr(&a_delta, &our_in, FR_TIME_RES_SEC, true, p_rules ? p_rules->terminals : NULL);
2996 if (slen <= 0) return 0;
2997
2998 MEM(vpt = tmpl_alloc(ctx, TMPL_TYPE_DATA,
2999 T_BARE_WORD, fr_sbuff_start(&our_in), fr_sbuff_used(&our_in)));
3000 vb = tmpl_value(vpt);
3001 fr_value_box_init(vb, FR_TYPE_TIME_DELTA, NULL, false);
3002 vb->vb_time_delta = a_delta;
3003
3004 *out = vpt;
3005
3006 FR_SBUFF_SET_RETURN(in, &our_in);
3007}
3008
3009/*
3010 * ::value
3011 *
3012 * Treated as enum name. Note that this check MUST be done after the test for IPv6, as
3013 * "::1" is an allowed IPv6 address.
3014 *
3015 * @todo - Mark this up as an enum name? Or do we really care? Maybe we want to allow
3016 *
3017 * Service-Type == 'Framed-User'
3018 *
3019 * or
3020 *
3021 * Service-Type == "Framed-User'
3022 *
3023 * as the second one allows for xlat expansions of enum names.
3024 *
3025 * We probably do want to forbid the single-quoted form of enums,
3026 * as that doesn't seem to make sense.
3027 *
3028 * We also need to distinguish unresolved bare words as enums
3029 * (with :: prefix) from unresolved attributes without an & prefix.
3030 */
3031static ssize_t tmpl_afrom_enum(TALLOC_CTX *ctx, tmpl_t **out, fr_sbuff_t *in,
3032 fr_sbuff_parse_rules_t const *p_rules,
3033 tmpl_rules_t const *t_rules)
3034{
3035 tmpl_t *vpt;
3036 fr_sbuff_parse_error_t sberr;
3037 fr_sbuff_t our_in = FR_SBUFF(in);
3038 fr_sbuff_t *enum_buff;
3039
3040 FR_SBUFF_TALLOC_THREAD_LOCAL(&enum_buff, 1024, SIZE_MAX);
3041
3042 /*
3043 * If there isn't a "::" prefix, then check for migration flags, and enum.
3044 *
3045 * If we require an enum prefix, then the input can't be an enum, and we don't do any more
3046 * parsing.
3047 *
3048 * Otherwise if there's no prefix and no enumv, we know this input can't be an enum name.
3049 */
3050 if (!fr_sbuff_adv_past_str_literal(&our_in, "::")) {
3051 return 0;
3052
3053 } else if (t_rules->enumv &&
3054 ((t_rules->enumv->type == FR_TYPE_IPV6_ADDR) ||
3055 ((t_rules->enumv->type == FR_TYPE_IPV6_PREFIX)))) {
3056
3057 /*
3058 * We can't have enumerated names for IPv6 addresses.
3059 *
3060 * @todo - allow them ONLY if the RHS string is a valid enum name.
3061 */
3062 return 0;
3063 }
3064
3065 /*
3066 * Need to store the value with the prefix, because the value box functions
3067 * expect it to be there...
3068 */
3069 fr_sbuff_in_strcpy_literal(enum_buff, "::");
3070
3071 vpt = tmpl_alloc_null(ctx);
3072
3073 /*
3074 * If it doesn't match any other type of bareword, parse it as an enum name.
3075 *
3076 * Note that we don't actually try to resolve the enum name. The caller is responsible
3077 * for doing that.
3078 */
3079 if (fr_dict_enum_name_from_substr(enum_buff, &sberr, &our_in, p_rules ? p_rules->terminals : NULL) < 0) {
3080 /*
3081 * Produce our own errors which make
3082 * more sense in the context of tmpls
3083 */
3084 switch (sberr) {
3085 case FR_SBUFF_PARSE_ERROR_NOT_FOUND:
3086 fr_strerror_const("No operand found. Expected &ref, literal, "
3087 "'quoted literal', \"%{expansion}\", or enum value");
3088 break;
3089
3090 case FR_SBUFF_PARSE_ERROR_FORMAT:
3091 fr_strerror_const("enum values must contain at least one alpha character");
3092 break;
3093
3094 default:
3095 fr_strerror_const("Unexpected text after enum value.");
3096 break;
3097 }
3098
3099 talloc_free(vpt);
3100 FR_SBUFF_ERROR_RETURN(&our_in);
3101 }
3102
3103 /*
3104 * If there's a valid enum name, then we use it. Otherwise we leave name resolution to run time.
3105 */
3106 if (t_rules->enumv) {
3107 fr_dict_enum_value_t const *dv;
3108
3109 dv = fr_dict_enum_by_name(t_rules->enumv, fr_sbuff_start(enum_buff), fr_sbuff_used(enum_buff));
3110 if (dv) {
3111 tmpl_init(vpt, TMPL_TYPE_DATA, T_BARE_WORD,
3112 fr_sbuff_start(&our_in), fr_sbuff_used(&our_in), t_rules);
3113 if (unlikely(fr_value_box_copy(vpt, &vpt->data.literal, dv->value) < 0)) {
3114 talloc_free(vpt);
3115 return -1;
3116 }
3117 vpt->data.literal.enumv = t_rules->enumv;
3118
3119 *out = vpt;
3120 FR_SBUFF_SET_RETURN(in, &our_in);
3121 }
3122 }
3123
3124 /*
3125 * Either there's no enum, or the enum name didn't match one of the listed ones. There's no
3126 * point in waiting for an enum which might be declared later. That's not possible, so we fall
3127 * back to parsing the various data types.
3128 */
3129 if (t_rules->at_runtime) return 0;
3130
3131 tmpl_init(vpt, TMPL_TYPE_DATA_UNRESOLVED, T_BARE_WORD,
3132 fr_sbuff_start(&our_in), fr_sbuff_used(&our_in), t_rules);
3133 MEM(vpt->data.unescaped = talloc_bstrndup(vpt, fr_sbuff_start(enum_buff), fr_sbuff_used(enum_buff)));
3134 *out = vpt;
3135
3136 FR_SBUFF_SET_RETURN(in, &our_in);
3137}
3138
3139/** Convert an arbitrary string into a #tmpl_t
3140 *
3141 * @note Unlike #tmpl_afrom_attr_str return code 0 doesn't necessarily indicate failure,
3142 * may just mean a 0 length string was parsed. Check to see if the function emitted
3143 * a #tmpl_t in *out.
3144 *
3145 * @note xlats and regexes are left uncompiled. This is to support the two pass parsing
3146 * done by the modcall code. Compilation on pass1 of that code could fail, as
3147 * attributes or xlat functions registered by modules may not be available (yet).
3148 *
3149 * @note For details of attribute parsing see #tmpl_afrom_attr_substr.
3150 *
3151 * @param[in,out] ctx To allocate #tmpl_t in.
3152 * @param[out] out Where to write the pointer to the new #tmpl_t.
3153 * @param[in] in String to parse.
3154 * @param[in] quote Quoting around the tmpl. Determines what we
3155 * attempt to parse the string as.
3156 * @param[in] p_rules Formatting rules for the tmpl.
3157 * @param[in] t_rules Validation rules for attribute references.
3158 * @return
3159 * - < 0 on error (offset as negative integer)
3160 * - >= 0 on success (number of bytes parsed).
3161 *
3162 * @see REMARKER to produce pretty error markers from the return value.
3163 *
3164 * @see tmpl_afrom_attr_substr
3165 */
3166fr_slen_t tmpl_afrom_substr(TALLOC_CTX *ctx, tmpl_t **out,
3167 fr_sbuff_t *in, fr_token_t quote,
3168 fr_sbuff_parse_rules_t const *p_rules,
3169 tmpl_rules_t const *t_rules)
3170{
3171 fr_sbuff_t our_in = FR_SBUFF(in);
3172
3173 fr_slen_t slen;
3174 fr_sbuff_parse_error_t sberr;
3175 char *str;
3176
3177 tmpl_t *vpt = NULL;
3178 DEFAULT_RULES;
3179
3180 CHECK_T_RULES;
3181
3182 *out = NULL;
3183
3184 switch (quote) {
3185 case T_BARE_WORD:
3186 /*
3187 * Skip other bareword types if
3188 * we find a '&' prefix.
3189 */
3190 if (fr_sbuff_is_char(&our_in, '&')) return tmpl_afrom_attr_substr(ctx, NULL, out, in,
3191 p_rules, t_rules);
3192
3193 /*
3194 * Allow bareword xlats if we
3195 * find a '%' prefix.
3196 */
3197 if (fr_sbuff_is_char(&our_in, '%')) {
3198 tmpl_type_t type = TMPL_TYPE_XLAT;
3199 xlat_exp_head_t *head = NULL;
3200
3201 vpt = tmpl_alloc_null(ctx);
3202 slen = xlat_tokenize(vpt, &head, &our_in, p_rules, t_rules);
3203 if (slen <= 0) FR_SBUFF_ERROR_RETURN(&our_in);
3204
3205 if (xlat_needs_resolving(head)) {
3206 UNRESOLVED_SET(&type);
3207 goto set_tmpl;
3208
3209 } else if (fr_dlist_num_elements(&head->dlist) == 1) {
3210 xlat_exp_t *node = xlat_exp_head(head);
3211 tmpl_t *hoisted;
3212
3213 if (node->type != XLAT_TMPL) goto set_tmpl;
3214
3215 /*
3216 * We were asked to parse a tmpl. But it turned out to be an xlat %{...}
3217 *
3218 * If that xlat is identically a tmpl such as %{User-Name}, then we just
3219 * hoist the tmpl to this node. Otherwise at run time, we will have an
3220 * extra bounce through the xlat code, for no real reason.
3221 */
3222 hoisted = node->vpt;
3223
3224 (void) talloc_steal(ctx, hoisted);
3225 talloc_free(vpt);
3226 vpt = hoisted;
3227
3228 } else {
3229 set_tmpl:
3230 tmpl_init(vpt, type, quote, fr_sbuff_start(&our_in), slen, t_rules);
3231 vpt->data.xlat.ex = head;
3232 }
3233
3234 *out = vpt;
3235
3236 TMPL_VERIFY(vpt);
3237
3238 FR_SBUFF_SET_RETURN(in, &our_in);
3239 }
3240
3241 /*
3242 * Deal with explicit casts...
3243 */
3244 if (!fr_type_is_null(t_rules->cast)) return tmpl_afrom_value_substr(ctx, out, in, quote,
3245 t_rules, true, p_rules);
3246
3247 /*
3248 * We're at runtime and have a data type. Just parse it as that data type, without doing
3249 * endless "maybe it's this thing" attempts.
3250 */
3251 if (t_rules->at_runtime && t_rules->enumv) {
3252 tmpl_rules_t my_t_rules = *t_rules;
3253
3254 fr_assert(fr_type_is_leaf(t_rules->enumv->type));
3255
3256 my_t_rules.cast = my_t_rules.enumv->type;
3257
3258 return tmpl_afrom_value_substr(ctx, out, in, quote, &my_t_rules, true, p_rules);
3259 }
3260
3261 /*
3262 * Prefer enum names to IPv6 addresses.
3263 */
3264 if (t_rules->enumv && fr_sbuff_is_str_literal(&our_in, "::")) {
3265 slen = tmpl_afrom_enum(ctx, out, &our_in, p_rules, t_rules);
3266 if (slen > 0) goto done_bareword;
3267 fr_assert(!*out);
3268 }
3269
3270 /*
3271 * See if it's a boolean value
3272 */
3273 slen = tmpl_afrom_bool_substr(ctx, out, &our_in, p_rules);
3274 if (slen > 0) {
3275 done_bareword:
3276 TMPL_VERIFY(*out);
3277
3278 FR_SBUFF_SET_RETURN(in, &our_in);
3279 }
3280 fr_assert(!*out);
3281
3282 /*
3283 * See if it's an octets string
3284 */
3285 slen = tmpl_afrom_octets_substr(ctx, out, &our_in, p_rules);
3286 if (slen > 0) goto done_bareword;
3287 fr_assert(!*out);
3288
3289 /*
3290 * See if it's a mac address
3291 *
3292 * Needs to be before IPv6 as the pton functions
3293 * are too greedy, and on macOS will happily
3294 * convert a mac address to an IPv6 address.
3295 */
3296 slen = tmpl_afrom_ether_substr(ctx, out, &our_in, p_rules);
3297 if (slen > 0) goto done_bareword;
3298 fr_assert(!*out);
3299
3300 /*
3301 * See if it's an IPv4 address or prefix
3302 */
3303 slen = tmpl_afrom_ipv4_substr(ctx, out, &our_in, p_rules);
3304 if (slen > 0) goto done_bareword;
3305 fr_assert(!*out);
3306
3307 /*
3308 * See if it's an IPv6 address or prefix
3309 */
3310 slen = tmpl_afrom_ipv6_substr(ctx, out, &our_in, p_rules);
3311 if (slen > 0) goto done_bareword;
3312 fr_assert(!*out);
3313
3314 slen = tmpl_afrom_enum(ctx, out, &our_in, p_rules, t_rules);
3315 if (slen > 0) goto done_bareword;
3316 fr_assert(!*out);
3317
3318 /*
3319 * See if it's a integer
3320 */
3321 slen = tmpl_afrom_integer_substr(ctx, out, &our_in, p_rules);
3322 if (slen > 0) goto done_bareword;
3323 fr_assert(!*out);
3324
3325 /*
3326 * See if it's a float
3327 */
3328 slen = tmpl_afrom_float_substr(ctx, out, &our_in, p_rules);
3329 if (slen > 0) goto done_bareword;
3330 fr_assert(!*out);
3331
3332 /*
3333 * See if it's a time delta
3334 *
3335 * We do this after floats and integers so that
3336 * they get parsed as integer and float types
3337 * and not time deltas.
3338 */
3339 slen = tmpl_afrom_time_delta(ctx, out, &our_in, p_rules);
3340 if (slen > 0) goto done_bareword;
3341 fr_assert(!*out);
3342
3343 /*
3344 * See if it's an attribute reference
3345 * without the prefix.
3346 */
3347 slen = tmpl_afrom_attr_substr(ctx, NULL, out, &our_in, p_rules, t_rules);
3348 if (slen > 0) goto done_bareword;
3349 fr_assert(!*out);
3350
3351 /*
3352 * We can't parse it as anything, that's an error.
3353 *
3354 * But it may be an enumeration value for an
3355 * attribute which is loaded later. In which
3356 * case we allow parsing the enumeration.
3357 */
3358 if (!fr_sbuff_is_str_literal(&our_in, "::")) {
3359 /*
3360 * Return the error string from parsing the attribute!
3361 */
3362 FR_SBUFF_ERROR_RETURN(&our_in);
3363 }
3364
3365 /*
3366 * Attempt to resolve enumeration values
3367 */
3368 vpt = tmpl_alloc_null(ctx);
3369
3370 /*
3371 * If it doesn't match any other type of bareword, parse it as an enum name.
3372 *
3373 * Note that we don't actually try to resolve the enum name. The caller is responsible
3374 * for doing that.
3375 */
3376 if (fr_dict_enum_name_afrom_substr(vpt, &str, &sberr, &our_in, p_rules ? p_rules->terminals : NULL) < 0) {
3377 /*
3378 * Produce our own errors which make
3379 * more sense in the context of tmpls
3380 */
3381 switch (sberr) {
3382 case FR_SBUFF_PARSE_ERROR_NOT_FOUND:
3383 fr_strerror_const("No operand found. Expected &ref, literal, "
3384 "'quoted literal', \"%{expansion}\", or enum value");
3385 break;
3386
3387 case FR_SBUFF_PARSE_ERROR_FORMAT:
3388 fr_strerror_const("enum values must contain at least one alpha character");
3389 break;
3390
3391 default:
3392 fr_strerror_const("Unexpected text after enum value.");
3393 break;
3394 }
3395
3396 talloc_free(vpt);
3397 FR_SBUFF_ERROR_RETURN(&our_in);
3398 }
3399
3400 tmpl_init(vpt, TMPL_TYPE_DATA_UNRESOLVED, quote,
3401 fr_sbuff_start(&our_in), fr_sbuff_used(&our_in), t_rules);
3402 vpt->data.unescaped = str;
3403 *out = vpt;
3404
3405 FR_SBUFF_SET_RETURN(in, &our_in);
3406
3407 case T_SINGLE_QUOTED_STRING:
3408 /*
3409 * Single quoted strings can be cast
3410 * to a specific data type immediately
3411 * as they cannot contain expansions.
3412 */
3413 if (!fr_type_is_null(t_rules->cast)) return tmpl_afrom_value_substr(ctx, out, in, quote,
3414 t_rules, false,
3415 p_rules);
3416 vpt = tmpl_alloc_null(ctx);
3417 slen = fr_sbuff_out_aunescape_until(vpt, &str, &our_in, SIZE_MAX,
3418 p_rules ? p_rules->terminals : NULL,
3419 p_rules ? p_rules->escapes : NULL);
3420 tmpl_init(vpt, TMPL_TYPE_DATA_UNRESOLVED, quote, fr_sbuff_start(&our_in), slen, t_rules);
3421 vpt->data.unescaped = str;
3422 break;
3423
3424 case T_DOUBLE_QUOTED_STRING:
3425 {
3426 xlat_exp_head_t *head = NULL;
3427 tmpl_type_t type = TMPL_TYPE_XLAT;
3428
3429 vpt = tmpl_alloc_null(ctx);
3430
3431 slen = xlat_tokenize(vpt, &head, &our_in, p_rules, t_rules);
3432 if (slen < 0) FR_SBUFF_ERROR_RETURN(&our_in);
3433
3434 /*
3435 * If the string doesn't contain an xlat,
3436 * and we want to cast it as a specific
3437 * type, then do the conversion now.
3438 */
3439 if (xlat_is_literal(head)) {
3440 if (!fr_type_is_null(t_rules->cast)) {
3441 talloc_free(vpt); /* Also frees any nodes */
3442
3443 return tmpl_afrom_value_substr(ctx, out,
3444 in, quote,
3445 t_rules, false, p_rules);
3446 }
3447
3448 /*
3449 * If the string doesn't contain an xlat
3450 * and there's no cast, we just store
3451 * the string for conversion later.
3452 */
3453 if (xlat_to_string(vpt, &str, &head)) {
3454 TALLOC_FREE(head);
3455
3456 tmpl_init(vpt, TMPL_TYPE_DATA_UNRESOLVED, quote,
3457 fr_sbuff_start(&our_in), slen, t_rules);
3458 vpt->data.unescaped = str; /* Store the unescaped string for parsing later */
3459 break;
3460 }
3461 }
3462
3463 /*
3464 * If the string actually contains an xlat
3465 * store the compiled xlat.
3466 */
3467 if (xlat_needs_resolving(head)) UNRESOLVED_SET(&type);
3468
3469 tmpl_init(vpt, type, quote, fr_sbuff_start(&our_in), slen, t_rules);
3470 vpt->data.xlat.ex = head;
3471 }
3472 break;
3473
3474 case T_BACK_QUOTED_STRING:
3475 {
3476 tmpl_type_t type = TMPL_TYPE_EXEC;
3477 xlat_exp_head_t *head = NULL;
3478
3479 vpt = tmpl_alloc_null(ctx);
3480
3481 /*
3482 * Ensure that we pre-parse the exec string.
3483 * This allows us to catch parse errors as early
3484 * as possible.
3485 *
3486 * FIXME - We need an ephemeral version of this
3487 * too.
3488 */
3489 slen = xlat_tokenize_argv(vpt, &head, &our_in, NULL, p_rules, t_rules, true);
3490 if ((slen <= 0) || !head) {
3491 talloc_free(vpt);
3492 FR_SBUFF_ERROR_RETURN(&our_in);
3493 }
3494
3495 /*
3496 * Ensure any xlats produced are bootstrapped
3497 * so that their instance data will be created.
3498 */
3499 if (xlat_finalize(head, t_rules->xlat.runtime_el) < 0) {
3500 fr_strerror_const("Failed to bootstrap xlat");
3501 FR_SBUFF_ERROR_RETURN(&our_in);
3502 }
3503
3504 if (xlat_needs_resolving(head)) UNRESOLVED_SET(&type);
3505
3506 tmpl_init(vpt, type, quote, fr_sbuff_start(&our_in), slen, t_rules);
3507 vpt->data.xlat.ex = head;
3508 }
3509 break;
3510
3511 case T_SOLIDUS_QUOTED_STRING:
3512 {
3513 xlat_exp_head_t *head = NULL;
3514 tmpl_type_t type = TMPL_TYPE_REGEX_XLAT;
3515 tmpl_rules_t arg_t_rules = *t_rules;
3516
3517 arg_t_rules.literals_safe_for = FR_REGEX_SAFE_FOR;
3518
3519 if (!fr_type_is_null(t_rules->cast)) {
3520 fr_strerror_const("Casts cannot be used with regular expressions");
3521 fr_sbuff_set_to_start(&our_in); /* Point to the cast */
3522 FR_SBUFF_ERROR_RETURN(&our_in);
3523 }
3524
3525 vpt = tmpl_alloc_null(ctx);
3526
3527 slen = xlat_tokenize(vpt, &head, &our_in, p_rules, &arg_t_rules);
3528 if (slen < 0) FR_SBUFF_ERROR_RETURN(&our_in);
3529
3530 /*
3531 * Check if the string actually contains an xlat
3532 * if it doesn't, we unfortunately still
3533 * can't compile the regex here, as we don't know if
3534 * it should be ephemeral or what flags should be used
3535 * during the compilation.
3536 *
3537 * The caller will need to do the compilation after we
3538 * return.
3539 */
3540 if (xlat_to_string(vpt, &str, &head)) {
3541 tmpl_init(vpt, TMPL_TYPE_REGEX_UNCOMPILED, quote,
3542 fr_sbuff_start(&our_in), slen, t_rules);
3543 vpt->data.unescaped = str; /* Store the unescaped string for compilation later */
3544 break;
3545 }
3546 /*
3547 * Mark the regex up as a regex-xlat which
3548 * will need expanding before evaluation, and can never
3549 * be pre-compiled.
3550 */
3551 if (xlat_needs_resolving(head)) UNRESOLVED_SET(&type);
3552
3553 tmpl_init(vpt, type, quote, fr_sbuff_start(&our_in), slen, t_rules);
3554 vpt->data.xlat.ex = head;
3555 }
3556 break;
3557
3558 default:
3559 fr_assert_msg(0, "Unknown quote type %i", quote);
3560 FR_SBUFF_ERROR_RETURN(&our_in);
3561 }
3562
3563 TMPL_VERIFY(vpt);
3564 *out = vpt;
3565
3566 FR_SBUFF_SET_RETURN(in, &our_in);
3567}
3568
3569/** Copy a tmpl
3570 *
3571 * Fully duplicates the contents of a tmpl including any nested attribute
3572 * references.
3573 *
3574 * @param[in] ctx to perform allocations under.
3575 * @param[in] in tmpl to duplicate.
3576 * @return
3577 * - NULL on error.
3578 * - A new tmpl on success.
3579 */
3580tmpl_t *tmpl_copy(TALLOC_CTX *ctx, tmpl_t const *in)
3581{
3582 tmpl_t *vpt;
3583
3584 MEM(vpt = tmpl_alloc(ctx, in->type, in->quote, in->name, in->len));
3585 vpt->rules = in->rules;
3586
3587 /*
3588 * Copy over the unescaped data
3589 */
3590 if (tmpl_is_data_unresolved(vpt) || tmpl_is_regex_uncompiled(vpt)) {
3591 if (unlikely(!(vpt->data.unescaped = talloc_bstrdup(vpt, in->data.unescaped)))) {
3592 error:
3593 talloc_free(vpt);
3594 return NULL;
3595 }
3596 }
3597
3598 /*
3599 * Copy attribute references
3600 */
3601 else if (tmpl_contains_attr(vpt)) {
3602 if (unlikely(tmpl_attr_copy(vpt, in) < 0)) goto error;
3603
3604 /*
3605 * Copy flags for all regex flavours (and possibly recompile the regex)
3606 */
3607 } else if (tmpl_contains_regex(vpt)) {
3608 vpt->data.reg_flags = in->data.reg_flags;
3609
3610 /*
3611 * If the tmpl contains a _compiled_ regex
3612 * then convert it back to an uncompiled
3613 * regex and recompile.
3614 *
3615 * Most of the regex libraries don't allow
3616 * copying compiled expressions.
3617 */
3618 if (tmpl_is_regex(vpt)) {
3619 vpt->type = TMPL_TYPE_REGEX_UNCOMPILED;
3620 if (unlikely(!(vpt->data.unescaped = talloc_bstrdup(vpt, in->data.reg.src)))) goto error;
3621 if (unlikely(tmpl_regex_compile(vpt, vpt->data.reg.subcaptures) < 0)) goto error;
3622 return vpt;
3623 }
3624
3625 /*
3626 * Copy the xlat component.
3627 *
3628 * @todo - in general we can't copy an xlat, as the instances need resolving!
3629 *
3630 * We add an assertion here because nothing allocates the head, and we need it.
3631 */
3632 } else if (tmpl_contains_xlat(vpt)) {
3633 fr_assert(in->data.xlat.ex != NULL);
3634
3635 vpt->data.xlat.ex = xlat_exp_head_alloc(vpt);
3636 if (!vpt->data.xlat.ex) goto error;
3637
3638 if (unlikely(xlat_copy(vpt, vpt->data.xlat.ex, in->data.xlat.ex) < 0)) goto error;
3639
3640 } else if (tmpl_is_data(vpt)) {
3641 if (unlikely(fr_value_box_copy(vpt, &vpt->data.literal, &in->data.literal) < 0)) goto error;
3642
3643 } else {
3644 fr_assert(0); /* copy of this type is unimplemented */
3645 }
3646
3647 TMPL_VERIFY(vpt);
3648
3649 return vpt;
3650}
3651
3652/** Parse a cast specifier
3653 *
3654 * Note that casts are
3655 *
3656 * (foo)
3657 *
3658 * and NOT
3659 *
3660 * ( foo )
3661 *
3662 * Not for any particular reason, but to emphasize a bit that they're
3663 * not mathematical expressions.
3664 *
3665 * @param[out] rules to set the cast type in.
3666 * @param[in] in String containing the cast marker.
3667 * @return
3668 * - 0 no cast specifier found.
3669 * - >0 the number of bytes parsed.
3670 * - <0 offset of parse error.
3671 */
3672ssize_t tmpl_cast_from_substr(tmpl_rules_t *rules, fr_sbuff_t *in)
3673{
3674 char close = '\0';
3675 fr_sbuff_t our_in = FR_SBUFF(in);
3676 fr_sbuff_marker_t m;
3677 fr_type_t cast;
3678 ssize_t slen;
3679
3680 if (fr_sbuff_next_if_char(&our_in, '(')) {
3681 close = ')';
3682
3683 } else {
3684 if (rules) rules->cast = FR_TYPE_NULL;
3685 return 0;
3686 }
3687
3688 fr_sbuff_marker(&m, &our_in);
3689 fr_sbuff_out_by_longest_prefix(&slen, &cast, fr_type_table, &our_in, FR_TYPE_NULL);
3690 if (fr_type_is_null(cast)) {
3691 fr_strerror_const("Unknown data type");
3692 FR_SBUFF_ERROR_RETURN(&our_in);
3693 }
3694 if (fr_type_is_non_leaf(cast)) {
3695 fr_strerror_printf("Forbidden data type '%s' in cast", fr_type_to_str(cast));
3696 FR_SBUFF_ERROR_RETURN(&m);
3697 }
3698
3699 if (!fr_sbuff_next_if_char(&our_in, close)) {
3700 fr_strerror_const("Unterminated cast");
3701 FR_SBUFF_ERROR_RETURN(&our_in);
3702 }
3703 fr_sbuff_adv_past_whitespace(&our_in, SIZE_MAX, NULL);
3704
3705 if (rules) rules->cast = cast;
3706
3707 FR_SBUFF_SET_RETURN(in, &our_in);
3708}
3709
3710/** Set a cast for a tmpl
3711 *
3712 * @param[in,out] vpt to set cast for.
3713 * @param[in] dst_type to set.
3714 * @return
3715 * - 0 on success.
3716 * - -1 on failure.
3717 */
3718int tmpl_cast_set(tmpl_t *vpt, fr_type_t dst_type)
3719{
3720 fr_type_t src_type;
3721
3722 switch (dst_type) {
3723 default:
3724 fr_strerror_printf("Forbidden data type '%s' in cast",
3725 fr_type_to_str(dst_type));
3726 return -1;
3727
3728 /*
3729 * We can always remove a cast.
3730 */
3731 case FR_TYPE_NULL:
3732 goto done;
3733
3734 /*
3735 * Only "base" data types are allowed. Structural types
3736 * and horrid WiMAX crap is forbidden.
3737 */
3738 case FR_TYPE_LEAF:
3739 break;
3740 }
3741
3742 switch (vpt->type) {
3743 /*
3744 * This should have been fixed before we got here.
3745 */
3746 case TMPL_TYPE_ATTR_UNRESOLVED:
3747
3748 /*
3749 * By default, tmpl types cannot be cast to anything.
3750 */
3751 default:
3752 fr_strerror_const("Cannot use cast here.");
3753 return -1;
3754
3755 /*
3756 * These tmpl types are effectively of data type
3757 * "string", so they can be cast to anything.
3758 */
3759 case TMPL_TYPE_XLAT:
3760 case TMPL_TYPE_EXEC:
3761 case TMPL_TYPE_DATA_UNRESOLVED:
3762 case TMPL_TYPE_EXEC_UNRESOLVED:
3763 case TMPL_TYPE_XLAT_UNRESOLVED:
3764 break;
3765
3766 case TMPL_TYPE_DATA:
3767 src_type = tmpl_value_type(vpt);
3768 goto check_types;
3769
3770 case TMPL_TYPE_ATTR:
3771 {
3772 fr_dict_attr_t const *da = tmpl_attr_tail_da(vpt);
3773
3774 /*
3775 * If the attribute has an enum, then the cast means "use the raw value, and not
3776 * the enum name".
3777 */
3778 if (da->type == dst_type) {
3779 if (da->flags.has_value) goto done;
3780 return 0;
3781 }
3782 src_type = da->type;
3783 }
3784
3785 /*
3786 * Suppress casts where they are duplicate, unless there's an enumv. In which case the
3787 * cast means "don't print the enumv value, just print the raw data".
3788 */
3789 check_types:
3790 if (src_type == dst_type) {
3791 /*
3792 * Cast with enumv means "use the raw value, and not the enum name".
3793 */
3794 if (tmpl_rules_enumv(vpt)) {
3795 tmpl_rules_enumv(vpt) = NULL;
3796 goto done;
3797 }
3798 return 0;
3799 }
3800
3801 if (!fr_type_cast(dst_type, src_type)) {
3802 fr_strerror_printf("Cannot cast type '%s' to '%s'",
3803 fr_type_to_str(src_type),
3804 fr_type_to_str(dst_type));
3805 return -1;
3806 }
3807 break;
3808 }
3809
3810done:
3811 vpt->rules.cast = dst_type;
3812 return 0;
3813}
3814
3815#ifdef HAVE_REGEX
3816/** Parse a set of regular expression flags
3817 *
3818 * @param[out] vpt Write the flags to the regex flags field in this #tmpl_t.
3819 * @param[in] in Where to parse the flag string from.
3820 * @param[in] terminals That mark the end of the regex flag string.
3821 * @return
3822 * - 0 no flags found.
3823 * - >0 the number of bytes of flags parsed.
3824 * - <0 offset of parse error.
3825 */
3826ssize_t tmpl_regex_flags_substr(tmpl_t *vpt, fr_sbuff_t *in, fr_sbuff_term_t const *terminals)
3827{
3828 fr_slen_t slen;
3829 int err = 0;
3830
3831 fr_assert(tmpl_is_regex_uncompiled(vpt) || tmpl_is_regex_xlat(vpt) || tmpl_is_regex_xlat_unresolved(vpt));
3832
3833 slen = regex_flags_parse(&err, &vpt->data.reg_flags, in, terminals, true);
3834 switch (err) {
3835 case 0:
3836 break;
3837
3838 case -1: /* Non-flag and non-terminal */
3839 case -2: /* Duplicate flag */
3840 return slen;
3841 }
3842
3843 return slen;
3844}
3845#endif
3846
3847/** @name Change a #tmpl_t type, usually by casting or resolving a reference
3848 *
3849 * #tmpl_cast_in_place can be used to convert #TMPL_TYPE_DATA_UNRESOLVED to a #TMPL_TYPE_DATA of a
3850 * specified #fr_type_t.
3851 *
3852 * #tmpl_attr_unknown_add converts a #TMPL_TYPE_ATTR with an unknown #fr_dict_attr_t to a
3853 * #TMPL_TYPE_ATTR with a known #fr_dict_attr_t, by adding the unknown #fr_dict_attr_t to the main
3854 * dictionary, and updating the ``tmpl_attr_tail_da`` pointer.
3855 * @{
3856 */
3857
3858/** Determine the correct quoting after a cast
3859 *
3860 * @param[in] existing_quote Exiting quotation type.
3861 * @param[in] type Cast type.
3862 * @param[in] enumv Enumeration values.
3863 * @param[in] unescaped The unescaped value of an enumeration.
3864 * @param[in] unescaped_len Length of unescaped.
3865 */
3866static inline CC_HINT(always_inline)
3867fr_token_t tmpl_cast_quote(fr_token_t existing_quote,
3868 fr_type_t type, fr_dict_attr_t const *enumv,
3869 char const *unescaped, size_t unescaped_len)
3870{
3871 if (!fr_type_is_string(type)) return T_BARE_WORD;
3872
3873 if (enumv && fr_dict_enum_by_name(enumv, unescaped, unescaped_len)) return T_BARE_WORD;
3874
3875 /*
3876 * Leave the original quoting if it's
3877 * single or double, else default to
3878 * single quoting.
3879 */
3880 switch (existing_quote) {
3881 case T_SINGLE_QUOTED_STRING:
3882 case T_DOUBLE_QUOTED_STRING:
3883 return existing_quote;
3884
3885 default:
3886 return T_SINGLE_QUOTED_STRING;
3887 }
3888}
3889
3890
3891/** Convert #tmpl_t of type #TMPL_TYPE_DATA_UNRESOLVED or #TMPL_TYPE_DATA to #TMPL_TYPE_DATA of type specified
3892 *
3893 * @note Conversion is done in place.
3894 * @note Irrespective of whether the #tmpl_t was #TMPL_TYPE_DATA_UNRESOLVED or #TMPL_TYPE_DATA,
3895 * on successful cast it will be #TMPL_TYPE_DATA.
3896 *
3897 * @param[in,out] vpt The template to modify. Must be of type #TMPL_TYPE_DATA_UNRESOLVED
3898 * or #TMPL_TYPE_DATA.
3899 * @param[in] type to cast to.
3900 * @param[in] enumv Enumerated dictionary values associated with a #fr_dict_attr_t.
3901 * @return
3902 * - 0 on success.
3903 * - -1 on failure.
3904 */
3905int tmpl_cast_in_place(tmpl_t *vpt, fr_type_t type, fr_dict_attr_t const *enumv)
3906{
3907 TMPL_VERIFY(vpt);
3908
3909 fr_assert(tmpl_is_data_unresolved(vpt) || tmpl_is_data(vpt));
3910
3911 switch (vpt->type) {
3912 case TMPL_TYPE_DATA_UNRESOLVED:
3913 {
3914 char *unescaped = vpt->data.unescaped;
3915
3916 /*
3917 * We're trying to convert an unresolved (bareword)
3918 * tmpl to octets.
3919 *
3920 * tmpl_afrom_substr uses the 0x prefix as type
3921 * inference, so if it was a hex string the tmpl
3922 * type would not have fallen through to
3923 * unresolved.
3924 *
3925 * That means if we're trying to resolve it here
3926 * it's really a printable string, not a sequence
3927 * of hexits, so we just want the binary
3928 * representation of that string, and not the hex
3929 * to bin conversion.
3930 */
3931 if (fr_type_is_octets(type)) {
3932 if (fr_value_box_memdup(vpt, &vpt->data.literal, enumv,
3933 (uint8_t const *)unescaped, talloc_array_length(unescaped) - 1,
3934 false) < 0) return -1;
3935 } else {
3936 if (fr_value_box_from_str(vpt, &vpt->data.literal, type,
3937 enumv,
3938 unescaped, talloc_array_length(unescaped) - 1,
3939 NULL) < 0) return -1;
3940 }
3941 vpt->type = TMPL_TYPE_DATA;
3942 vpt->quote = tmpl_cast_quote(vpt->quote, type, enumv,
3943 unescaped, talloc_array_length(unescaped) - 1);
3944 talloc_free(unescaped);
3945 fr_value_box_mark_safe_for(&vpt->data.literal, vpt->rules.literals_safe_for);
3946
3947 /*
3948 * The data is now of the correct type, so we don't need to keep a cast.
3949 */
3950 vpt->rules.cast = FR_TYPE_NULL;
3951 }
3952 break;
3953
3954 case TMPL_TYPE_DATA:
3955 {
3956 if (type == tmpl_value_type(vpt)) return 0; /* noop */
3957
3958 /*
3959 * Enumerations aren't used when casting between
3960 * data types. They're only used when processing
3961 * unresolved tmpls.
3962 *
3963 * i.e. TMPL_TYPE_DATA_UNRESOLVED != TMPL_TYPE_DATA(FR_TYPE_STRING)
3964 */
3965 if (fr_value_box_cast_in_place(vpt, &vpt->data.literal, type, NULL) < 0) return -1;
3966// fr_value_box_mark_safe_for(&vpt->data.literal, vpt->rules.literals_safe_for); ??? is this necessary?
3967
3968 /*
3969 * Strings get quoted, everything else is a bare
3970 * word...
3971 */
3972 if (fr_type_is_string(type)) {
3973 vpt->quote = T_SINGLE_QUOTED_STRING;
3974 } else {
3975 vpt->quote = T_BARE_WORD;
3976 }
3977
3978 /*
3979 * The data is now of the correct type, so we don't need to keep a cast.
3980 */
3981 vpt->rules.cast = FR_TYPE_NULL;
3982 }
3983 break;
3984
3985 case TMPL_TYPE_ATTR:
3986 /*
3987 * Suppress casts to the same type.
3988 */
3989 if (tmpl_attr_tail_da(vpt)->type == type) {
3990 vpt->rules.cast = FR_TYPE_NULL;
3991 break;
3992 }
3993 FALL_THROUGH;
3994
3995 case TMPL_TYPE_ATTR_UNRESOLVED:
3996 vpt->rules.cast = type;
3997 break;
3998
3999 default:
4000 fr_assert(0);
4001 }
4002 TMPL_VERIFY(vpt);
4003
4004 return 0;
4005}
4006
4007/** Resolve an unresolved attribute
4008 *
4009 * Multi-pass parsing fixups for attribute references.
4010 *
4011 * @param[in] vpt to resolve.
4012 * @param[in] tr_rules Combined with the original parse rules for
4013 * additional resolution passes.
4014 * @return
4015 * - 0 if all references were resolved.
4016 * - -1 if there are unknown attributes which need
4017 * adding to the global dictionary first.
4018 * - -2 if there are attributes we couldn't resolve.
4019 */
4020static inline CC_HINT(always_inline) int tmpl_attr_resolve(tmpl_t *vpt, tmpl_res_rules_t const *tr_rules)
4021{
4022 tmpl_attr_t *ar = NULL, *next, *prev;
4023 fr_dict_attr_t const *da, *namespace;
4024 fr_dict_t const *dict_def;
4025
4026 fr_assert(tmpl_is_attr_unresolved(vpt));
4027
4028 TMPL_VERIFY(vpt);
4029
4030 dict_def = vpt->rules.attr.dict_def;
4031 if (!dict_def || tr_rules->force_dict_def) dict_def = tr_rules->dict_def;
4032
4033 /*
4034 * First component is special because we may need
4035 * to search for it in multiple dictionaries.
4036 *
4037 * This emulates what's done in the initial
4038 * tokenizer function.
4039 */
4040 ar = tmpl_attr_list_head(tmpl_attr(vpt));
4041 if (ar->type == TMPL_ATTR_TYPE_UNRESOLVED) {
4042 (void)fr_dict_attr_search_by_name_substr(NULL,
4043 &da,
4044 dict_def,
4045 &FR_SBUFF_IN(ar->ar_unresolved,
4046 talloc_array_length(ar->ar_unresolved) - 1),
4047 NULL,
4048 true,
4049 vpt->rules.attr.allow_foreign);
4050 if (!da) return -2; /* Can't resolve, maybe the caller can resolve later */
4051
4052 ar->ar_type = TMPL_ATTR_TYPE_NORMAL;
4053 ar->ar_da = da;
4054 ar->ar_parent = fr_dict_root(fr_dict_by_da(da));
4055
4056 /*
4057 * Record the dictionary that was
4058 * successfully used for resolution.
4059 */
4060 vpt->rules.attr.dict_def = tr_rules->dict_def;
4061
4062 /*
4063 * Reach into the next reference
4064 * and correct its parent and
4065 * namespace.
4066 */
4067 next = tmpl_attr_list_next(tmpl_attr(vpt), ar);
4068 if (next) {
4069 next->ar_parent = da;
4070 next->ar_unresolved_namespace = da;
4071 }
4072 }
4073
4074 /*
4075 * Loop, resolving each unresolved attribute in turn
4076 */
4077 while ((ar = tmpl_attr_list_next(tmpl_attr(vpt), ar))) {
4078 switch (ar->type) {
4079 case TMPL_ATTR_TYPE_NORMAL:
4080 case TMPL_ATTR_TYPE_UNSPEC:
4081 continue; /* Don't need to resolve */
4082
4083 case TMPL_ATTR_TYPE_UNKNOWN:
4084 return -1; /* Unknown attributes must be resolved first */
4085
4086 default:
4087 break;
4088 }
4089
4090 prev = tmpl_attr_list_prev(tmpl_attr(vpt), ar);
4091
4092 /*
4093 * If the parent is a list AR, then use the default dictionary for the namespace
4094 */
4095 namespace = (prev && dict_def && tmpl_attr_is_list_attr(prev)) ? fr_dict_root(dict_def) : ar->ar_unresolved_namespace;
4096
4097 (void)fr_dict_attr_by_name_substr(NULL,
4098 &da,
4099 namespace,
4100 &FR_SBUFF_IN(ar->ar_unresolved,
4101 talloc_array_length(ar->ar_unresolved) - 1),
4102 NULL);
4103 /*
4104 * Still can't resolve, check to see if
4105 * the last attribute reference was a
4106 * group.
4107 *
4108 * If it was, then we may be able to
4109 * fall back to resolving the attribute
4110 * in the internal dictionary.
4111 */
4112 if (!da) {
4113 if (prev && (prev->ar_da->type == FR_TYPE_GROUP)) {
4114 (void)fr_dict_attr_by_name_substr(NULL,
4115 &da,
4116 fr_dict_root(fr_dict_internal()),
4117 &FR_SBUFF_IN(ar->ar_unresolved,
4118 talloc_array_length(ar->ar_unresolved) - 1),
4119 NULL);
4120 }
4121 if (!da) return -2;
4122 }
4123
4124 /*
4125 * Known attribute, just rewrite.
4126 */
4127 ar->ar_type = TMPL_ATTR_TYPE_NORMAL;
4128 ar->ar_da = da;
4129
4130 /*
4131 * Parent should have been corrected in
4132 * the previous loop iteration.
4133 */
4134 fr_assert(ar->ar_parent && !ar->ar_parent->flags.is_unknown);
4135
4136 /*
4137 * Reach into the next reference
4138 * and correct its parent.
4139 */
4140 next = tmpl_attr_list_next(tmpl_attr(vpt), ar);
4141 if (next) {
4142 next->ar_parent = da;
4143 next->ar_unresolved_namespace = da;
4144 }
4145
4146 /*
4147 * Remove redundant attributes
4148 *
4149 * If it's not a group or does not specify
4150 * an index, the ar is redundant and should
4151 * be removed.
4152 */
4153 prev = tmpl_attr_list_prev(tmpl_attr(vpt), ar);
4154 if (prev && (prev->ar_da->type != FR_TYPE_GROUP) && (prev->ar_num == NUM_UNSPEC)) {
4155 tmpl_attr_list_remove(tmpl_attr(vpt), prev);
4156 ar->ar_parent = prev->ar_parent;
4157 talloc_free(prev);
4158 }
4159 }
4160
4161 RESOLVED_SET(&vpt->type);
4162 TMPL_VERIFY(vpt);
4163
4164 return 0;
4165}
4166
4167/** Resolve an unresolved xlat, i.e. one containing unresolved attribute references or xlat functions
4168 *
4169 * Multi-pass parsing fixups for attribute references.
4170 *
4171 * Works for base types:
4172 * - TMPL_TYPE_XLAT
4173 * - TMPL_TYPE_EXEC
4174 * - TMPL_TYPE_REGEX_XLAT
4175 *
4176 * @param[in] vpt Containing the xlat expansion to resolve.
4177 * @param[in] tr_rules Combined with the original parse rules for
4178 * additional resolution passes.
4179 * @return
4180 * - 0 on success.
4181 * - -1 on failure.
4182 */
4183static inline CC_HINT(always_inline)
4184int tmpl_xlat_resolve(tmpl_t *vpt, tmpl_res_rules_t const *tr_rules)
4185{
4186 if (xlat_resolve(vpt->data.xlat.ex,
4187 &(xlat_res_rules_t){
4188 .tr_rules = tr_rules,
4189 .allow_unresolved = false
4190 }) < 0) return -1;
4191
4192 fr_assert(!xlat_needs_resolving(vpt->data.xlat.ex));
4193
4194 RESOLVED_SET(&vpt->type);
4195 TMPL_VERIFY(vpt);
4196
4197 return 0;
4198}
4199
4200/** Attempt to resolve functions and attributes in xlats and attribute references
4201 *
4202 * @note If resolution is successful, the rules->attr.dict_def field will be modified to
4203 * reflect the dictionary resolution was successful in.
4204 *
4205 * @param[in,out] vpt to resolve. Should be of type TMPL_TYPE_XLAT_UNRESOLVED
4206 * or TMPL_TYPE_ATTR_UNRESOLVED. All other types will be
4207 * noops.
4208 * @param[in] tr_rules Combined with the original parse rules for
4209 * additional resolution passes.
4210 * @return
4211 * - 0 on success.
4212 * - -1 on failure.
4213 */
4214int tmpl_resolve(tmpl_t *vpt, tmpl_res_rules_t const *tr_rules)
4215{
4216 static tmpl_res_rules_t const default_tr_rules;
4217
4218 int ret = 0;
4219
4220 if (!tmpl_needs_resolving(vpt)) return 0; /* Nothing to do */
4221
4222 if (!tr_rules) tr_rules = &default_tr_rules;
4223
4224 /*
4225 * Sanity check. There shouldn't be conflicting
4226 * enumvs between the original rules and resolution
4227 * rules.
4228 *
4229 * Either the enumv was available during parsing
4230 * and shouldn't have changed during subsequent
4231 * resolution passes, or it wasn't available at
4232 * parse-time, but now is.
4233 */
4234 if (tr_rules->enumv && tmpl_rules_enumv(vpt) && !tmpl_rules_enumv(vpt)->flags.is_unknown &&
4235 (tr_rules->enumv != tmpl_rules_enumv(vpt))) {
4236 fr_strerror_printf("mismatch between parse-time enumv '%s' and resolution-time enumv '%s'",
4237 tmpl_rules_enumv(vpt)->name, tr_rules->enumv->name);
4238
4239 return -1;
4240 }
4241
4242 /*
4243 * The xlat component of the #tmpl_t needs resolving.
4244 *
4245 * This includes exec tmpls, which are largely xlats
4246 * "under the hood".
4247 */
4248 if (tmpl_contains_xlat(vpt)) {
4249 ret = tmpl_xlat_resolve(vpt, tr_rules);
4250
4251 /*
4252 * The attribute reference needs resolving.
4253 */
4254 } else if (tmpl_contains_attr(vpt)) {
4255 fr_type_t dst_type = tmpl_rules_cast(vpt);
4256
4257 fr_assert(vpt->quote == T_BARE_WORD); /* 'User-Name' or "User-Name" is not allowed. */
4258
4259 ret = tmpl_attr_resolve(vpt, tr_rules);
4260 if (ret < 0) return ret;
4261
4262 if (dst_type == tmpl_attr_tail_da(vpt)->type) {
4263 vpt->rules.cast = FR_TYPE_NULL;
4264 }
4265
4266 /*
4267 * Convert unresolved tmpls into enumvs, or failing that, string values.
4268 *
4269 * Unresolved tmpls are by definition TMPL_TYPE_DATA.
4270 */
4271 } else if (tmpl_is_data_unresolved(vpt)) {
4272 fr_type_t dst_type = tmpl_rules_cast(vpt);
4273 fr_dict_attr_t const *enumv = tmpl_rules_enumv(vpt);
4274
4275 /*
4276 * If there wasn't an enumv set in the
4277 * original rules, and we now have one
4278 * (possibly because the other side of a
4279 * binary expression has been resolved),
4280 * then use the new enumv.
4281 */
4282 if (!enumv) enumv = tr_rules->enumv;
4283
4284 /*
4285 * We don't have an explicit output type. Try to
4286 * interpret the data os the enumv data type, OR
4287 * if all else fails, it's a string.
4288 */
4289 if (fr_type_is_null(dst_type)) {
4290 /*
4291 * Infer the cast from the enumv type.
4292 */
4293 if (enumv) {
4294 dst_type = enumv->type;
4295
4296 } else if (vpt->quote != T_BARE_WORD) {
4297 dst_type = FR_TYPE_STRING; /* quoted strings are strings */
4298
4299 } else if (strncmp(vpt->data.unescaped, "::", 2) != 0) {
4300 /*
4301 * The rest of the code should have errored out before this.
4302 */
4303 fr_strerror_printf("Failed resolving data '%s' - it is not an attribute name or a quoted string", vpt->data.unescaped);
4304 return -1;
4305
4306 } else {
4307 /*
4308 * It's a valid enum ::NAME which was added _after_ the dictionaries were
4309 * loaded. That's fine. fr_value_box_from_substr() will skip over the
4310 * "::", and parse the enum name.
4311 */
4312 }
4313 }
4314
4315 /*
4316 * tmpl_cast_in_place first resolves using
4317 * the enumv, _then_ casts using the type.
4318 */
4319 if (tmpl_cast_in_place(vpt, dst_type, enumv) < 0) return -1;
4320
4321 TMPL_VERIFY(vpt);
4322 /*
4323 * Catch any other cases of unresolved things
4324 * we need to address. We put the assert here
4325 * so we don't end up running inappropriate
4326 * code for non-debug builds.
4327 */
4328 } else {
4329 fr_assert(0);
4330 }
4331
4332 TMPL_VERIFY(vpt);
4333
4334 return ret;
4335}
4336
4337/** Reset the tmpl, leaving only the name in place
4338 *
4339 * After calling this function, the tmpl type will revert to TMPL_TYPE_DATA_UNRESOLVED
4340 * and only the name and quoting will be preserved.
4341 *
4342 * @param[in] vpt to reset.
4343 */
4344void tmpl_unresolve(tmpl_t *vpt)
4345{
4346 tmpl_t tmp = {
4347 .type = TMPL_TYPE_DATA_UNRESOLVED,
4348 .name = vpt->name,
4349 .len = vpt->len,
4350 .quote = vpt->quote
4351 };
4352
4353 switch (vpt->type) {
4354 case TMPL_TYPE_UNINITIALISED:
4355 case TMPL_TYPE_MAX:
4356 fr_assert(0);
4357 break;
4358
4359 case TMPL_TYPE_DATA_UNRESOLVED:
4360 case TMPL_TYPE_REGEX_UNCOMPILED:
4361 break;
4362
4363 case TMPL_TYPE_DATA:
4364 fr_value_box_clear(&vpt->data.literal);
4365 break;
4366
4367 /*
4368 * These types contain dynamically allocated
4369 * attribute and request references.
4370 */
4371 case TMPL_TYPE_ATTR:
4372 case TMPL_TYPE_ATTR_UNRESOLVED:
4373 tmpl_attr_list_talloc_free(tmpl_attr(vpt));
4374 tmpl_request_list_talloc_free(&vpt->data.attribute.rr);
4375 break;
4376
4377 /*
4378 * These all store an xlat expansion
4379 */
4380 case TMPL_TYPE_EXEC:
4381 case TMPL_TYPE_XLAT:
4382 case TMPL_TYPE_REGEX_XLAT:
4383 case TMPL_TYPE_EXEC_UNRESOLVED:
4384 case TMPL_TYPE_XLAT_UNRESOLVED:
4385 case TMPL_TYPE_REGEX_XLAT_UNRESOLVED:
4386 TALLOC_FREE(vpt->data.xlat.ex);
4387 break;
4388
4389 case TMPL_TYPE_REGEX:
4390 talloc_free(vpt->data.reg.ex);
4391 break;
4392
4393 }
4394
4395 memcpy(vpt, &tmp, sizeof(*vpt));
4396
4397 TMPL_VERIFY(vpt);
4398}
4399
4400static void attr_to_raw(tmpl_t *vpt, tmpl_attr_t *ref)
4401{
4402 if (!ref) return;
4403
4404 switch (ref->type) {
4405 case TMPL_ATTR_TYPE_NORMAL:
4406 {
4407 ref->da = ref->ar_unknown = fr_dict_attr_unknown_afrom_da(vpt, ref->da);
4408 ref->ar_unknown->type = FR_TYPE_OCTETS;
4409 ref->is_raw = 1;
4410 ref->ar_unknown->flags.is_unknown = 1;
4411 ref->type = TMPL_ATTR_TYPE_UNKNOWN;
4412 }
4413 break;
4414 case TMPL_ATTR_TYPE_UNSPEC: /* noop */
4415 break;
4416
4417 case TMPL_ATTR_TYPE_UNKNOWN:
4418 ref->ar_unknown->type = FR_TYPE_OCTETS;
4419 ref->is_raw = 1;
4420 break;
4421
4422 case TMPL_ATTR_TYPE_UNRESOLVED:
4423 ref->is_raw = true;
4424 break;
4425 }
4426
4427 TMPL_ATTR_VERIFY(vpt);
4428}
4429
4430/** Convert the leaf attribute of a tmpl to a unknown/raw type
4431 *
4432 */
4433void tmpl_attr_to_raw(tmpl_t *vpt)
4434{
4435 attr_to_raw(vpt, tmpl_attr_list_tail(tmpl_attr(vpt)));
4436}
4437
4438/** Add an unknown #fr_dict_attr_t specified by a #tmpl_t to the main dictionary
4439 *
4440 * @param vpt to add. ``tmpl_attr_tail_da`` pointer will be updated to point to the
4441 * #fr_dict_attr_t inserted into the dictionary.
4442 * @return
4443 * - 1 noop (did nothing) - Not possible to convert tmpl.
4444 * - 0 on success.
4445 * - -1 on failure.
4446 */
4447int tmpl_attr_unknown_add(tmpl_t *vpt)
4448{
4449 tmpl_attr_t *ar = NULL, *next = NULL;
4450
4451 if (!vpt) return 1;
4452
4453 /*
4454 * Can't do this for expressions parsed at runtime
4455 */
4456 if (vpt->rules.at_runtime) return 1;
4457
4458 tmpl_assert_type(tmpl_is_attr(vpt));
4459
4460 TMPL_VERIFY(vpt);
4461
4462 if (!tmpl_attr_tail_is_unknown(vpt)) return 1; /* Ensure at least the leaf is unknown */
4463
4464 while ((ar = tmpl_attr_list_next(tmpl_attr(vpt), ar))) {
4465 fr_dict_attr_t const *unknown, *known;
4466
4467 switch (ar->type) {
4468 case TMPL_ATTR_TYPE_NORMAL: /* Skip */
4469 case TMPL_ATTR_TYPE_UNSPEC:
4470 continue;
4471
4472 case TMPL_ATTR_TYPE_UNRESOLVED: /* Shouldn't have been called */
4473 fr_strerror_const("Remaining attributes are unresolved");
4474 return -1;
4475
4476 case TMPL_ATTR_TYPE_UNKNOWN:
4477 break;
4478 }
4479
4480 unknown = ar->ar_unknown;
4481 known = fr_dict_attr_unknown_add(fr_dict_unconst(fr_dict_by_da(unknown)), unknown);
4482 if (!known) return -1;
4483
4484 /*
4485 * Fixup the parent of the next unknown
4486 * now it's known.
4487 */
4488 next = tmpl_attr_list_next(tmpl_attr(vpt), ar);
4489 if (next && (next->type == TMPL_ATTR_TYPE_UNKNOWN) &&
4490 (next->ar_da->parent == unknown)) {
4491 if (fr_dict_attr_unknown_parent_to_known(fr_dict_attr_unconst(next->ar_da),
4492 known) < 0) return -1;
4493 next->ar_parent = known;
4494 }
4495
4496 /*
4497 * Convert the ref to a normal type.
4498 * At runtime there should be no
4499 * "unknown" references as they should
4500 * have all been added to a
4501 * dictionary.
4502 */
4503 ar->type = TMPL_ATTR_TYPE_NORMAL;
4504
4505 /*
4506 * If the attribute is *NOT* raw then
4507 * swap the canonical unknown with the
4508 * one that was previously associated
4509 * with the tmpl.
4510 *
4511 * This establishes the unknown attribute
4512 * in the dictionary if it was really
4513 * unknown whilst not mucking up the
4514 * types for raw attributes.
4515 */
4516 if (!ar_is_raw(ar)) {
4517 fr_dict_attr_unknown_free(&ar->ar_da);
4518 ar->ar_da = known;
4519 } else if (!fr_cond_assert(!next)) {
4520 fr_strerror_const("Only the leaf may be raw");
4521 return -1;
4522 }
4523 }
4524
4525 return 0;
4526}
4527
4528/** Add an unresolved #fr_dict_attr_t specified by a #tmpl_t to the main dictionary
4529 *
4530 * @note fr_dict_attr_add will not return an error if the attribute already exists
4531 * meaning that multiple #tmpl_t specifying the same attribute can be
4532 * passed to this function to be fixed up, so long as the type and flags
4533 * are identical.
4534 *
4535 * @param[in] dict_def Default dictionary to use if none is
4536 * specified by the tmpl_attr_tail_unresolved.
4537 * @param[in] vpt specifying unresolved attribute to add.
4538 * ``tmpl_attr_tail_da`` pointer will be updated to
4539 * point to the #fr_dict_attr_t inserted
4540 * into the dictionary. Lists and requests
4541 * will be preserved.
4542 * @param[in] type to define unresolved attribute as.
4543 * @param[in] flags to define unresolved attribute with.
4544 * @return
4545 * - 1 noop (did nothing) - Not possible to convert tmpl.
4546 * - 0 on success.
4547 * - -1 on failure.
4548 */
4549int tmpl_attr_tail_unresolved_add(fr_dict_t *dict_def, tmpl_t *vpt,
4550 fr_type_t type, fr_dict_attr_flags_t const *flags)
4551{
4552 fr_dict_attr_t const *da;
4553 fr_dict_attr_flags_t our_flags = *flags;
4554
4555 our_flags.name_only = true;
4556
4557 if (!vpt) return -1;
4558
4559 TMPL_VERIFY(vpt);
4560
4561 if (!tmpl_is_attr_unresolved(vpt)) return 1;
4562
4563 if (fr_dict_attr_add(dict_def,
4564 fr_dict_root(fr_dict_internal()), tmpl_attr_tail_unresolved(vpt), 0, type, &our_flags) < 0) {
4565 return -1;
4566 }
4567 da = fr_dict_attr_by_name(NULL, fr_dict_root(dict_def), tmpl_attr_tail_unresolved(vpt));
4568 if (!da) return -1;
4569
4570 if (type != da->type) {
4571 fr_strerror_printf("Attribute %s of type %s already defined with type %s",
4572 da->name, fr_type_to_str(type),
4573 fr_type_to_str(da->type));
4574 return -1;
4575 }
4576
4577 if (memcmp(flags, &da->flags, sizeof(*flags)) != 0) {
4578 fr_strerror_printf("Attribute %s already defined with different flags", da->name);
4579 return -1;
4580 }
4581
4582 tmpl_attr_set_da(vpt, da);
4583 vpt->type = TMPL_TYPE_ATTR;
4584
4585 return 0;
4586}
4587
4588#ifdef HAVE_REGEX
4589/** Convert a TMPL_TYPE_REGEX_UNCOMPILED into a TMPL_TYPE_REGEX
4590 *
4591 * Other regex types become noops.
4592 */
4593ssize_t tmpl_regex_compile(tmpl_t *vpt, bool subcaptures)
4594{
4595 ssize_t slen;
4596 char *unescaped = vpt->data.unescaped;
4597
4598 if (tmpl_is_regex_xlat(vpt) || tmpl_is_regex(vpt)) return 0; /* Don't need compiling */
4599
4600 fr_assert(tmpl_is_regex_uncompiled(vpt));
4601
4602 slen = regex_compile(vpt, &vpt->data.reg.ex,
4603 unescaped, talloc_array_length(unescaped) - 1,
4604 &vpt->data.reg_flags, subcaptures, vpt->rules.at_runtime);
4605 if (slen <= 0) return vpt->quote != T_BARE_WORD ? slen - 1 : slen; /* Account for the quoting */
4606
4607 vpt->type = TMPL_TYPE_REGEX;
4608 vpt->data.reg.src = unescaped; /* Keep this around for debugging and copying */
4609 vpt->data.reg.subcaptures = subcaptures;
4610
4611 TMPL_VERIFY(vpt);
4612
4613 return slen;
4614}
4615#endif
4616/** @} */
4617
4618/** @name Print the contents of a #tmpl_t
4619 * @{
4620 */
4621fr_slen_t tmpl_request_ref_list_print(fr_sbuff_t *out, FR_DLIST_HEAD(tmpl_request_list) const *rql)
4622{
4623 fr_sbuff_t our_out = FR_SBUFF(out);
4624 tmpl_request_t *rr = tmpl_request_list_head(rql);
4625
4626 /*
4627 * Print request references
4628 */
4629 while (rr) {
4630 FR_SBUFF_IN_TABLE_STR_RETURN(&our_out, tmpl_request_ref_table, rr->request, "<INVALID>");
4631 rr = tmpl_request_list_next(rql, rr);
4632 if (rr) FR_SBUFF_IN_CHAR_RETURN(&our_out, '.');
4633 }
4634
4635 FR_SBUFF_SET_RETURN(out, &our_out);
4636}
4637
4638/** Print an attribute or list #tmpl_t to a string
4639 *
4640 * This function is the direct counterpart to #tmpl_afrom_attr_substr.
4641 *
4642 * @param[in] out Where to write the presentation format #tmpl_t string.
4643 * @param[in] vpt to print.
4644 * @return
4645 * - >0 the number of bytes written to the out buffer.
4646 * - 0 invalid argument.
4647 * - <0 the number of bytes we would have needed to complete the print.
4648 */
4649fr_slen_t tmpl_attr_print(fr_sbuff_t *out, tmpl_t const *vpt)
4650{
4651 tmpl_attr_t *ar = NULL;
4652 fr_da_stack_t stack;
4653 fr_sbuff_t our_out = FR_SBUFF(out);
4654 fr_slen_t slen;
4655
4656 TMPL_VERIFY(vpt);
4657
4658 /*
4659 * Only print things we can print...
4660 */
4661 switch (vpt->type) {
4662 case TMPL_TYPE_ATTR_UNRESOLVED:
4663 case TMPL_TYPE_ATTR:
4664 break;
4665
4666 default:
4667 fr_assert(0);
4668 return 0;
4669 }
4670
4671 /*
4672 * Print request references
4673 */
4674 slen = tmpl_request_ref_list_print(&our_out, &vpt->data.attribute.rr);
4675 if (slen > 0) FR_SBUFF_IN_CHAR_RETURN(&our_out, '.');
4676 if (slen < 0) return slen;
4677
4678 /*
4679 *
4680 * If the leaf attribute is unknown and raw we
4681 * add the raw. prefix.
4682 *
4683 * If the leaf attribute is unknown and not raw
4684 * we add the .unknown prefix.
4685 *
4686 */
4687 if (tmpl_attr_tail_is_raw(vpt)) FR_SBUFF_IN_STRCPY_LITERAL_RETURN(&our_out, "raw.");
4688
4689 /*
4690 * Print attribute identifiers
4691 */
4692 ar = NULL;
4693 while ((ar = tmpl_attr_list_next(tmpl_attr(vpt), ar))) {
4694 switch(ar->type) {
4695 case TMPL_ATTR_TYPE_UNSPEC:
4696 break;
4697
4698 case TMPL_ATTR_TYPE_NORMAL:
4699 case TMPL_ATTR_TYPE_UNKNOWN:
4700 {
4701 int i, depth = 0;
4702
4703 fr_assert(ar->ar_parent); /* All normal and unknown attributes must have parents */
4704
4705 fr_proto_da_stack_build_partial(&stack, ar->ar_parent, ar->ar_da);
4706
4707 /*
4708 * First component in the list has everything built
4709 */
4710 if (ar == tmpl_attr_list_head(tmpl_attr(vpt))) {
4711 depth = ar->ar_parent->depth - 1; /* Adjust for array index */
4712 /*
4713 * Everything else skips the first component
4714 */
4715 } else {
4716 depth = ar->ar_parent->depth;
4717 }
4718
4719 /*
4720 * Root attributes will be skipped by the build
4721 * function, so da[0] contains the attribute
4722 * we're looking for.
4723 */
4724 if (depth < 0) depth = 0;
4725
4726 /*
4727 * Print from our parent depth to the AR we're processing
4728 *
4729 * For refs we skip the attribute pointed to be the ref
4730 * and just print its children.
4731 *
4732 * In addition skip printing "request." in most cases.
4733 */
4734 if ((stack.da[depth] == request_attr_request) && tmpl_attr_list_next(tmpl_attr(vpt), ar) &&
4735 (ar->filter.type == TMPL_ATTR_FILTER_TYPE_NONE)) continue;
4736
4737 for (i = depth; (unsigned int)i < ar->ar_da->depth; i++) {
4738 FR_SBUFF_IN_STRCPY_RETURN(&our_out, stack.da[i]->name);
4739
4740 /*
4741 * Print intermediary separators
4742 * if necessary.
4743 */
4744 if (((unsigned int)i + 1) < ar->ar_da->depth) FR_SBUFF_IN_CHAR_RETURN(&our_out, '.');
4745 }
4746 }
4747 break;
4748
4749 /*
4750 * For unresolved attribute we print the raw identifier we
4751 * got when parsing the tmpl.
4752 */
4753 case TMPL_ATTR_TYPE_UNRESOLVED:
4754 {
4755 unsigned int i, depth;
4756
4757 /*
4758 * This is the first unresolved component in a potential
4759 * chain of unresolved components. Print the path up to
4760 * the last known parent.
4761 */
4762 if (ar->ar_parent && !ar->ar_parent->flags.is_root) {
4763 fr_proto_da_stack_build_partial(&stack, ar->ar_parent, ar->ar_parent);
4764 if (ar->ar_parent->flags.is_root) {
4765 depth = 0;
4766 } else {
4767 depth = ar->ar_parent->depth - 1;
4768 }
4769
4770 for (i = depth; i < ar->ar_parent->depth; i++) {
4771 FR_SBUFF_IN_STRCPY_RETURN(&our_out, stack.da[i]->name);
4772 FR_SBUFF_IN_CHAR_RETURN(&our_out, '.');
4773 }
4774 }
4775 /*
4776 * Then print the unresolved component
4777 */
4778 FR_SBUFF_IN_BSTRCPY_BUFFER_RETURN(&our_out, ar->ar_unresolved);
4779 break;
4780 }
4781 }
4782
4783 if (ar_filter_is_none(ar)) {
4784 /* do nothing */
4785
4786 } else if (ar_filter_is_num(ar)) {
4787 switch (ar->ar_num) {
4788 case NUM_UNSPEC:
4789 break;
4790
4791 case NUM_ALL:
4792 FR_SBUFF_IN_STRCPY_LITERAL_RETURN(&our_out, "[*]");
4793 break;
4794
4795 case NUM_COUNT:
4796 FR_SBUFF_IN_STRCPY_LITERAL_RETURN(&our_out, "[#]");
4797 break;
4798
4799 case NUM_LAST:
4800 FR_SBUFF_IN_STRCPY_LITERAL_RETURN(&our_out, "[n]");
4801 break;
4802
4803 default:
4804 FR_SBUFF_IN_SPRINTF_RETURN(&our_out, "[%i]", ar->ar_num);
4805 break;
4806 }
4807
4808 } else if (ar_filter_is_cond(ar)) {
4809 FR_SBUFF_IN_STRCPY_LITERAL_RETURN(&our_out, "[");
4810 (void) xlat_print(&our_out, ar->ar_cond, NULL);
4811 FR_SBUFF_IN_STRCPY_LITERAL_RETURN(&our_out, "]");
4812
4813 } else {
4814 fr_assert(0);
4815 }
4816
4817 if (tmpl_attr_list_next(tmpl_attr(vpt), ar)) FR_SBUFF_IN_CHAR_RETURN(&our_out, '.');
4818 }
4819 FR_SBUFF_SET_RETURN(out, &our_out);
4820}
4821
4822/** Print a #tmpl_t to a string
4823 *
4824 * This function should primarily be used for regenerating vpt->name when the contents
4825 * of the #tmpl_t is changed programmatically, or when the #tmpl_t is being serialized
4826 * in some non-standard way, i.e. as a value for a field in a database.
4827 *
4828 * This function is the direct counterpart to #tmpl_afrom_substr.
4829 *
4830 * @note Does not print flags for regular expressions, as the quoting char is needed
4831 * to separate the elements of the expression.
4832 * Call regex_flags_print to write the flags values to the output buffer.
4833 *
4834 * @param[out] out Where to write the presentation format #tmpl_t string.
4835 * @param[in] vpt to print.
4836 * @param[in] e_rules Escaping rules used to print strings.
4837 * @return
4838 * - >0 the number of bytes written to the out buffer.
4839 * - 0 invalid argument.
4840 * - <0 the number of bytes we would have needed to complete the print.
4841 */
4842fr_slen_t tmpl_print(fr_sbuff_t *out, tmpl_t const *vpt,
4843 fr_sbuff_escape_rules_t const *e_rules)
4844{
4845 fr_sbuff_t our_out = FR_SBUFF(out);
4846
4847 TMPL_VERIFY(vpt);
4848
4849 switch (vpt->type) {
4850 case TMPL_TYPE_ATTR_UNRESOLVED:
4851 case TMPL_TYPE_ATTR:
4852 FR_SBUFF_RETURN(tmpl_attr_print, &our_out, vpt);
4853 break;
4854
4855 case TMPL_TYPE_DATA:
4856 FR_SBUFF_RETURN(fr_value_box_print, &our_out, tmpl_value(vpt), e_rules);
4857 break;
4858
4859 case TMPL_TYPE_REGEX:
4860 FR_SBUFF_IN_BSTRNCPY_RETURN(&our_out, vpt->name, vpt->len); /* Fixme - double escapes */
4861 break;
4862
4863 case TMPL_TYPE_REGEX_UNCOMPILED:
4864 FR_SBUFF_IN_ESCAPE_BUFFER_RETURN(&our_out, vpt->data.unescaped, e_rules);
4865 break;
4866
4867 case TMPL_TYPE_UNINITIALISED:
4868 case TMPL_TYPE_MAX:
4869 fr_sbuff_terminate(out);
4870 break;
4871
4872 /*
4873 * The remaining types will either
4874 * be xlat expansions, or need
4875 * resolving, in which case the
4876 * unescaped string is available
4877 * in vpt->unescaped.
4878 */
4879 default:
4880 if (tmpl_contains_xlat(vpt)) {
4881 FR_SBUFF_RETURN(xlat_print, &our_out, tmpl_xlat(vpt), e_rules);
4882 break;
4883 }
4884
4885 if (tmpl_needs_resolving(vpt)) {
4886 FR_SBUFF_IN_ESCAPE_BUFFER_RETURN(&our_out, vpt->data.unescaped, e_rules);
4887 break;
4888 }
4889
4890 fr_assert_fail("Can't print invalid tmpl type %s", tmpl_type_to_str(vpt->type));
4891
4892 /*
4893 * Ensure we do something sane for non-debug builds
4894 */
4895 fr_sbuff_terminate(out);
4896 return 0;
4897 }
4898
4899 FR_SBUFF_SET_RETURN(out, &our_out);
4900}
4901
4902/** Print a #tmpl_t to a string with quotes
4903 *
4904 * This function should be used when the tmpl is embedded in some other construct
4905 * in the server's configuration.
4906 *
4907 * It adds standard quoting around tmpl's used as operands in expressions and applies
4908 * the correct escaping rules.
4909 *
4910 * @param[out] out Where to write the presentation format #tmpl_t string.
4911 * @param[in] vpt to print.
4912 * @return
4913 * - >0 the number of bytes written to the out buffer.
4914 * - 0 invalid argument.
4915 * - <0 the number of bytes we would have needed to complete the print.
4916 */
4917fr_slen_t tmpl_print_quoted(fr_sbuff_t *out, tmpl_t const *vpt)
4918{
4919 fr_sbuff_t our_out = FR_SBUFF(out);
4920
4921 char quote = fr_token_quote[vpt->quote];
4922
4923 if (quote != '\0') FR_SBUFF_IN_CHAR_RETURN(&our_out, quote);
4924 FR_SBUFF_RETURN(tmpl_print, &our_out, vpt,
4925 fr_value_escape_by_quote[vpt->quote]);
4926 if (quote != '\0') FR_SBUFF_IN_CHAR_RETURN(&our_out, quote);
4927
4928 /*
4929 * Optionally print the flags
4930 */
4931 if (vpt->type & TMPL_FLAG_REGEX) FR_SBUFF_RETURN(regex_flags_print, &our_out, tmpl_regex_flags(vpt));
4932
4933 FR_SBUFF_SET_RETURN(out, &our_out);
4934}
4935/** @} */
4936
4937
4938#ifdef WITH_VERIFY_PTR
4939/** Used to check whether areas of a tmpl_t are zeroed out
4940 *
4941 * @param ptr Offset to begin checking at.
4942 * @param len How many bytes to check.
4943 * @return
4944 * - Pointer to the first non-zero byte.
4945 * - NULL if all bytes were zero.
4946 */
4947static uint8_t const *is_zeroed(uint8_t const *ptr, size_t len)
4948{
4949 size_t i;
4950
4951 for (i = 0; i < len; i++) {
4952 if (ptr[i] != 0x00) return ptr + i;
4953 }
4954
4955 return NULL;
4956}
4957
4958/** Verify that unused regions of the struct are zeroed out
4959 *
4960 */
4961#define CHECK_ZEROED(_vpt, _field) is_zeroed(((uint8_t const *)&(_vpt)->data) + sizeof((_vpt)->data._field), sizeof((_vpt)->data) - sizeof((_vpt)->data._field))
4962
4963
4964/** Print hex data
4965 *
4966 */
4967#define PRINT_NON_ZEROED(_vpt, _field, _nz_ptr) \
4968do { \
4969 DEBUG("Expected live portion %p-%p (0-%zu)", \
4970 _vpt, \
4971 (uint8_t const *)&(_vpt)->data + sizeof((_vpt)->data._field), \
4972 sizeof((_vpt)->data._field)); \
4973 DEBUG("Expected zero portion %p-%p (%zu-%zu)", \
4974 (uint8_t const *)&(_vpt)->data + sizeof((_vpt)->data._field), \
4975 (uint8_t const *)&(_vpt)->data + sizeof((_vpt)->data), \
4976 sizeof((_vpt)->data._field), sizeof((_vpt)->data)); \
4977 HEX_MARKER1((uint8_t const *)&vpt->data, sizeof(vpt->data), nz - (uint8_t const *)&vpt->data, "non-zero memory", ""); \
4978} while (0)
4979
4980
4981/** Verify the attribute reference in a tmpl_t make sense
4982 *
4983 * @note If the attribute reference is is invalid, causes the server to exit.
4984 *
4985 * @param file obtained with __FILE__.
4986 * @param line obtained with __LINE__.
4987 * @param vpt to check.
4988 */
4989void tmpl_attr_verify(char const *file, int line, tmpl_t const *vpt)
4990{
4991 tmpl_attr_t *ar = NULL;
4992 tmpl_attr_t *slow = NULL, *fast = NULL;
4993 tmpl_attr_t *seen_unknown = NULL;
4994 tmpl_attr_t *seen_unresolved = NULL;
4995
4996 fr_assert(tmpl_is_attr_unresolved(vpt) || tmpl_is_attr(vpt));
4997
4998 /*
4999 * Loop detection
5000 */
5001 while ((slow = tmpl_attr_list_next(tmpl_attr(vpt), slow)) &&
5002 (fast = tmpl_attr_list_next(tmpl_attr(vpt), fast))) {
5003
5004 /*
5005 * Advances twice as fast as slow...
5006 */
5007 fast = tmpl_attr_list_next(tmpl_attr(vpt), fast);
5008 fr_fatal_assert_msg(fast != slow,
5009 "CONSISTENCY CHECK FAILED %s[%u]: Looping reference list found. "
5010 "Fast pointer hit slow pointer at \"%s\"",
5011 file, line,
5012 slow->type == TMPL_ATTR_TYPE_UNRESOLVED ? slow->ar_unresolved :
5013 slow->da ? slow->da->name : "(null-attr)");
5014 }
5015
5016 /*
5017 * Lineage type check
5018 *
5019 * Known attribute cannot come after unresolved or unknown attributes
5020 * Unknown attributes cannot come after unresolved attributes
5021 */
5022 if (!tmpl_is_list(vpt)) while ((ar = tmpl_attr_list_next(tmpl_attr(vpt), ar))) {
5023 switch (ar->type) {
5024 case TMPL_ATTR_TYPE_NORMAL:
5025 if (seen_unknown) {
5026 tmpl_attr_debug(stderr, vpt);
5027 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: "
5028 "TMPL_TYPE_ATTR known attribute \"%s\" "
5029 "occurred after unknown attribute %s "
5030 "in attr ref list",
5031 file, line,
5032 ar->da->name,
5033 ar->unknown.da->name);
5034 }
5035 if (seen_unresolved) {
5036 tmpl_attr_debug(stderr, vpt);
5037 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: "
5038 "TMPL_TYPE_ATTR known attribute \"%s\" "
5039 "occurred after unresolved attribute \"%s\""
5040 "in attr ref list",
5041 file, line,
5042 ar->da->name,
5043 ar->ar_unresolved);
5044 }
5045 fr_fatal_assert_msg(ar->ar_parent,
5046 "CONSISTENCY CHECK FAILED %s[%u]: attr ref missing parent",
5047 file, line);
5048 break;
5049
5050 case TMPL_ATTR_TYPE_UNSPEC:
5051 if (seen_unknown) {
5052 tmpl_attr_debug(stderr, vpt);
5053 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: "
5054 "TMPL_TYPE_ATTR unspecified attribute "
5055 "occurred after unknown attribute %s "
5056 "in attr ref list",
5057 file, line,
5058 ar->unknown.da->name);
5059 }
5060 if (seen_unresolved) {
5061 tmpl_attr_debug(stderr, vpt);
5062 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: "
5063 "TMPL_TYPE_ATTR unspecified attribute "
5064 "occurred after unresolved attribute \"%s\""
5065 "in attr ref list",
5066 file, line,
5067 ar->ar_unresolved);
5068 }
5069 break;
5070
5071 case TMPL_ATTR_TYPE_UNRESOLVED:
5072 seen_unresolved = ar;
5073 fr_fatal_assert_msg(ar->ar_unresolved_namespace,
5074 "CONSISTENCY CHECK FAILED %s[%u]: unresolved attr ref missing namespace",
5075 file, line);
5076 break;
5077
5078 case TMPL_ATTR_TYPE_UNKNOWN:
5079 seen_unknown = ar;
5080 if (seen_unresolved) {
5081 tmpl_attr_debug(stderr, vpt);
5082 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: "
5083 "TMPL_TYPE_ATTR unknown attribute \"%s\" "
5084 "occurred after unresolved attribute %s "
5085 "in attr ref list",
5086 file, line, ar->da->name,
5087 ar->ar_unresolved);
5088 }
5089 break;
5090 }
5091 }
5092}
5093
5094/** Verify fields of a tmpl_t make sense
5095 *
5096 * @note If the #tmpl_t is invalid, causes the server to exit.
5097 *
5098 * @param file obtained with __FILE__.
5099 * @param line obtained with __LINE__.
5100 * @param vpt to check.
5101 */
5102void tmpl_verify(char const *file, int line, tmpl_t const *vpt)
5103{
5104 uint8_t const *nz;
5105
5106 fr_assert(vpt);
5107
5108 if (tmpl_is_uninitialised(vpt)) {
5109 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: tmpl_t type was "
5110 "TMPL_TYPE_UNINITIALISED (uninitialised)", file, line);
5111 }
5112
5113 if (vpt->type >= TMPL_TYPE_MAX) {
5114 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: tmpl_t type was %i "
5115 "(outside range of tmpl_type_table)", file, line, vpt->type);
5116 }
5117
5118 if (!vpt->name && (vpt->quote != T_INVALID)) {
5119 char quote = vpt->quote >= T_TOKEN_LAST ? '?' : fr_token_quote[vpt->quote];
5120
5121 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: Quote type '%c' (%i) was set for NULL name",
5122 file, line, quote, vpt->quote);
5123 }
5124
5125 if (vpt->name && (vpt->quote == T_INVALID)) {
5126 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: No quoting type was set for name \"%.*s\"",
5127 file, line, (int)vpt->len, vpt->name);
5128 }
5129
5130 /*
5131 * Do a memcmp of the bytes after where the space allocated for
5132 * the union member should have ended and the end of the union.
5133 * These should always be zero if the union has been initialised
5134 * properly.
5135 *
5136 * If they're still all zero, do TMPL_TYPE specific checks.
5137 */
5138 switch (vpt->type) {
5139 case TMPL_TYPE_DATA_UNRESOLVED:
5140 if (!vpt->data.unescaped) {
5141 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_DATA_UNRESOLVED "
5142 "unescaped field is NULL", file, line);
5143 }
5144 break;
5145
5146 case TMPL_TYPE_XLAT_UNRESOLVED:
5147 if (!vpt->data.xlat.ex) {
5148 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_XLAT "
5149 "has a NULL xlat.ex field", file, line);
5150
5151 }
5152
5153 if (!xlat_needs_resolving(vpt->data.xlat.ex)) {
5154 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_XLAT_UNRESOLVED "
5155 "does not have 'needs resolving' flag set", file, line);
5156 }
5157 break;
5158
5159 case TMPL_TYPE_XLAT:
5160 if (!vpt->data.xlat.ex) {
5161 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_XLAT "
5162 "has a NULL xlat.ex field", file, line);
5163
5164 }
5165 break;
5166
5167/* @todo When regexes get converted to xlat the flags field of the regex union is used
5168 case TMPL_TYPE_XLAT_UNRESOLVED:
5169 if (is_zeroed((uint8_t const *)&vpt->data, sizeof(vpt->data))) {
5170 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_XLAT_UNRESOLVED "
5171 "has non-zero bytes in its data union", file, line);
5172 }
5173 break;
5174
5175 case TMPL_TYPE_XLAT:
5176 if (CHECK_ZEROED(vpt, xlat)) {
5177 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_XLAT "
5178 "has non-zero bytes after the data.xlat pointer in the union", file, line);
5179 }
5180 break;
5181*/
5182
5183 case TMPL_TYPE_EXEC:
5184 case TMPL_TYPE_EXEC_UNRESOLVED:
5185 /* tmpl_xlat(vpt) can be initialized */
5186 break;
5187
5188 case TMPL_TYPE_ATTR_UNRESOLVED:
5189 if ((tmpl_attr_list_num_elements(tmpl_attr(vpt)) > 0) &&
5190 ((tmpl_attr_t *)tmpl_attr_list_tail(tmpl_attr(vpt)))->da) {
5191#ifndef NDEBUG
5192 tmpl_attr_debug(stderr, vpt);
5193#endif
5194 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_ATTR_UNRESOLVED contains %u "
5195 "references", file, line, tmpl_attr_list_num_elements(tmpl_attr(vpt)));
5196 }
5197 break;
5198
5199 case TMPL_TYPE_ATTR:
5200 if ((nz = CHECK_ZEROED(vpt, attribute))) {
5201 PRINT_NON_ZEROED(vpt, attribute, nz);
5202 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_ATTR "
5203 "has non-zero bytes after the data.attribute struct in the union",
5204 file, line);
5205 }
5206
5207 if (tmpl_attr_tail_is_unspecified(vpt)) {
5208 fr_assert(vpt->rules.cast == FR_TYPE_NULL);
5209 break;
5210 }
5211
5212 if (tmpl_attr_tail_is_unknown(vpt)) {
5213 if (tmpl_attr_tail_da(vpt) != tmpl_attr_tail_unknown(vpt)) {
5214 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_ATTR "
5215 "da is marked as unknown, but address is not equal to the template's "
5216 "unknown da pointer", file, line);
5217 }
5218 /*
5219 * Raw attributes may not have been added to the dictionary yet
5220 */
5221 } else {
5222 fr_dict_attr_t const *da;
5223 fr_dict_t const *dict;
5224
5225 /*
5226 * Attribute may be present with multiple names
5227 */
5228 dict = fr_dict_by_da(tmpl_attr_tail_da(vpt));
5229 if (!dict) {
5230 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_ATTR "
5231 "attribute \"%s\" (%s) not rooted in a dictionary",
5232 file, line, tmpl_attr_tail_da(vpt)->name,
5233 fr_type_to_str(tmpl_attr_tail_da(vpt)->type));
5234 }
5235
5236 da = tmpl_attr_tail_da(vpt);
5237 if (!tmpl_attr_tail_is_raw(vpt) && (da != tmpl_attr_tail_da(vpt))) {
5238 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_ATTR "
5239 "dictionary pointer %p \"%s\" (%s) "
5240 "and global dictionary pointer %p \"%s\" (%s) differ",
5241 file, line,
5242 tmpl_attr_tail_da(vpt), tmpl_attr_tail_da(vpt)->name,
5243 fr_type_to_str(tmpl_attr_tail_da(vpt)->type),
5244 da, da->name,
5245 fr_type_to_str(da->type));
5246 }
5247
5248 tmpl_attr_verify(file, line, vpt);
5249 }
5250 break;
5251
5252 case TMPL_TYPE_DATA:
5253 if ((nz = CHECK_ZEROED(vpt, literal))) {
5254 PRINT_NON_ZEROED(vpt, literal, nz);
5255 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_DATA "
5256 "has non-zero bytes after the data.literal struct in the union",
5257 file, line);
5258 }
5259
5260 if (fr_type_is_null(tmpl_value_type(vpt))) {
5261 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_DATA type was "
5262 "FR_TYPE_NULL (uninitialised)", file, line);
5263 }
5264
5265 if (tmpl_value_type(vpt) >= FR_TYPE_MAX) {
5266 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_DATA type was "
5267 "%i (outside the range of fr_type_ts)", file, line, tmpl_value_type(vpt));
5268 }
5269 /*
5270 * Unlike fr_pair_ts we can't guarantee that fr_pair_t_TMPL buffers will
5271 * be talloced. They may be allocated on the stack or in global variables.
5272 */
5273 switch (tmpl_value_type(vpt)) {
5274 case FR_TYPE_STRING:
5275 if (tmpl_value(vpt)->vb_strvalue[tmpl_value_length(vpt)] != '\0') {
5276 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_DATA char buffer not \\0 "
5277 "terminated", file, line);
5278 }
5279 break;
5280
5281 case FR_TYPE_STRUCTURAL:
5282 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_DATA is of type TLV",
5283 file, line);
5284
5285 default:
5286 break;
5287 }
5288
5289 break;
5290
5291 case TMPL_TYPE_REGEX_UNCOMPILED:
5292 case TMPL_TYPE_REGEX_XLAT:
5293 case TMPL_TYPE_REGEX_XLAT_UNRESOLVED:
5294#ifndef HAVE_REGEX
5295 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_REGEX_XLAT_UNRESOLVED - No regex support",
5296 file, line);
5297#endif
5298 break;
5299
5300 case TMPL_TYPE_REGEX:
5301#ifdef HAVE_REGEX
5302 if (tmpl_regex(vpt) == NULL) {
5303 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_REGEX "
5304 "reg.ex field was NULL", file, line);
5305 }
5306#else
5307 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_REGEX - No regex support",
5308 file, line);
5309#endif
5310 break;
5311
5312 case TMPL_TYPE_UNINITIALISED:
5313 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_UNINITIALISED", file, line);
5314
5315 case TMPL_TYPE_MAX:
5316 fr_fatal_assert_fail("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_MAX", file, line);
5317 }
5318}
5319#endif
5320
5321static const bool array_terminal[UINT8_MAX + 1] = {
5322 [ ']' ] = true,
5323};
5324
5325#define return_P(_x) fr_strerror_const(_x);goto return_p
5326
5327/** Preparse a string in preparation for passing it to tmpl_afrom_substr()
5328 *
5329 * Note that the input string is not modified, which means that the
5330 * tmpl_afrom_substr() function MUST un-escape it.
5331 *
5332 * The caller should pass 'out' and 'outlen' to tmpl_afrom_substr()
5333 * as 'in' and 'inlen'. The caller should also pass 'type'.
5334 * The caller should also pass do_unescape=true.
5335 *
5336 * @param[out] out start of the string to parse
5337 * @param[out] outlen length of the string to parse
5338 * @param in where we start looking for the string
5339 * @param inlen length of the input string
5340 * @param[out] type token type of the string.
5341 * @return
5342 * - > 0, amount of parsed string to skip, to get to the next token
5343 * - <=0, -offset in 'start' where the parse error was located
5344 */
5345ssize_t tmpl_preparse(char const **out, size_t *outlen, char const *in, size_t inlen,
5346 fr_token_t *type)
5347{
5348 char const *p = in, *end = in + inlen;
5349 char quote;
5350 char close;
5351 int depth;
5352 bool triple;
5353
5354 *type = T_INVALID;
5355
5356 while (isspace((uint8_t) *p) && (p < end)) p++;
5357 if (p >= end) return p - in;
5358
5359 switch (*p) {
5360 /*
5361 * Allow bare xlat's
5362 */
5363 case '%':
5364 if (p[1] != '{') {
5365 char const *q;
5366
5367 q = p + 1;
5368
5369 /*
5370 * Function syntax: %foo(...)
5371 */
5372 while ((q < end) && (isalnum((int) *q) || (*q == '.') || (*q == '_') || (*q == '-'))) {
5373 q++;
5374 }
5375
5376 if (*q != '(') {
5377 p++;
5378 fr_strerror_const("Invalid character after '%'");
5379 return_p:
5380 return -(p - in);
5381 }
5382
5383 /*
5384 * Return the whole %foo(...) string.
5385 */
5386 *out = p;
5387 if (*type == T_INVALID) *type = T_BARE_WORD;
5388 close = ')';
5389
5390 p = q + 1;
5391 depth = 1;
5392 goto loop;
5393 }
5394
5395 /*
5396 * For now, %{...} is treated as a double-quoted
5397 * string. Once we clean other things up, the
5398 * xlats will be treated as strongly typed values
5399 * / lists on their own.
5400 */
5401 if (*type == T_INVALID) *type = T_BARE_WORD;
5402 depth = 0;
5403 close = '}';
5404
5405 /*
5406 * Xlat's are quoted by %{...} / %(...) nesting, not by
5407 * escapes, so we need to do special escaping.
5408 */
5409 *out = p;
5410 loop:
5411 while (*p) {
5412 /*
5413 * End of expansion. Return the entire
5414 * expansion, including the enclosing %{}
5415 * characters.
5416 */
5417 if ((*p == '}') || (*p == ')')) {
5418 bool match = (*p == close);
5419
5420 p++;
5421 depth--;
5422
5423 if (depth == 0) {
5424 if (!match) break;
5425
5426 *outlen = p - (*out);
5427 return p - in;
5428 }
5429 continue;
5430 }
5431
5432 if (*p == '\\') {
5433 p++;
5434 if (!p[1]) {
5435 return_P("End of string after escape");
5436 }
5437
5438 p++;
5439 continue;
5440 }
5441
5442 if ((p[0] == '%') && ((p[1] == '{') || (p[1] == '('))) {
5443 if (!p[2]) {
5444 return_P("End of string after expansion");
5445 }
5446
5447 p += 2;
5448 depth++;
5449 continue;
5450 }
5451
5452 /*
5453 * Allow (...) and {...}
5454 */
5455 if ((*p == '{') || (*p == '(')) {
5456 p++;
5457 depth++;
5458 continue;
5459 }
5460
5461 p++;
5462 }
5463
5464 /*
5465 * End of input without end of string.
5466 * Point the error to the start of the string.
5467 */
5468 p = *out;
5469 return_P("Unterminated expansion");
5470
5471 case '/':
5472 goto bare_word;
5473
5474 case '\'':
5475 quote = *(p++);
5476 *type = T_SINGLE_QUOTED_STRING;
5477 goto skip_string;
5478
5479 case '`':
5480 quote = *(p++);
5481 *type = T_BACK_QUOTED_STRING;
5482 goto skip_string;
5483
5484 case '"':
5485 quote = *(p++);
5486 *type = T_DOUBLE_QUOTED_STRING;
5487
5488 /*
5489 * We're not trying to do a *correct* parsing of
5490 * every string here. We're trying to do a
5491 * simple parse that isn't wrong. We therefore
5492 * accept most anything that's vaguely well
5493 * formed, and rely on the next stage to do a
5494 * more rigorous check.
5495 */
5496 skip_string:
5497 if ((inlen > 3) && (p[0] == quote) && (p[1] == quote)) {
5498 triple = true;
5499 p += 2;
5500 } else {
5501 triple = false;
5502 }
5503 *out = p;
5504
5505 while (*p) {
5506 if (p >= end) goto unterminated;
5507
5508 /*
5509 * End of string. Tell the caller the
5510 * length of the data inside of the
5511 * string, and return the number of
5512 * characters to skip.
5513 */
5514 if (*p == quote) {
5515 if (!triple) {
5516 *outlen = p - (*out);
5517 p++;
5518 return p - in;
5519
5520 }
5521
5522 if (((end - p) >= 3) && (p[1] == quote) && (p[2] == quote)) {
5523 *outlen = p - (*out);
5524 p += 3;
5525 return p - in;
5526 }
5527
5528 p++;
5529 continue;
5530 }
5531
5532 if (*p == '\\') {
5533 p++;
5534 if (!p[1]) {
5535 return_P("End of string after escape");
5536 }
5537 }
5538 p++;
5539 }
5540
5541 /*
5542 * End of input without end of string.
5543 * Point the error to the start of the string.
5544 */
5545 unterminated:
5546 p = *out;
5547 return_P("Unterminated string");
5548
5549 case '&':
5550 *out = p; /* the output string starts with '&' */
5551 p++;
5552 quote = '[';
5553 goto skip_word;
5554
5555 default:
5556 bare_word:
5557 *out = p;
5558 quote = '['; /* foo[1] is OK */
5559
5560 skip_word:
5561 *type = T_BARE_WORD;
5562 depth = 0;
5563
5564 /*
5565 * Allow *most* things. But stop on spaces and special characters.
5566 */
5567 while (*p) {
5568 if (isspace((uint8_t) *p)) {
5569 break;
5570 }
5571
5572 if (*p == '$') {
5573 if (p[1] == '{') {
5574 p += 2;
5575 depth++;
5576 continue;
5577
5578 } else if ((p[1] == 'E') &&
5579 (p[2] == 'N') &&
5580 (p[3] == 'V') &&
5581 (p[4] == '{')) {
5582 p += 5;
5583 depth++;
5584 continue;
5585
5586 } else {
5587 /*
5588 * Bare '$' is wrong...
5589 */
5590 break;
5591 }
5592 }
5593
5594 if (*p == '%') {
5595 if (p[1] == '{') {
5596 p += 2;
5597 depth++;
5598 continue;
5599 }
5600
5601 p++;
5602 continue;
5603 }
5604
5605 /*
5606 * If we're inside of a ${...} expansion,
5607 * then allow everything until the
5608 * closing '}'. This means that we can
5609 * do ${foo[bar].baz}, among other
5610 * thingds.
5611 */
5612 if (depth > 0) {
5613 if (*p == '}') {
5614 depth--;
5615 }
5616
5617 p++;
5618 continue;
5619 }
5620
5621 /*
5622 * '-' is special. We allow it for
5623 * attribute names, BUT it's a
5624 * terminating token if the NEXT
5625 * character is '='.
5626 *
5627 * We have the same criteria for IPv6
5628 * addresses and tagged attributes. ':'
5629 * is allowed, but ':=' is a breaking
5630 * token.
5631 */
5632 if ((*p == '-') || (*p == ':')) {
5633 if (p[1] == '=') break;
5634 p++;
5635 continue;
5636 }
5637
5638 /*
5639 * Allowed in attribute names, and/or
5640 * host names and IP addresses, and IPv6 addresses.
5641 */
5642 if ((*p == '.') || (*p == '/') || (*p == '_') || (*p == '*') ||
5643 (*p == ']') || (*p == '@')) {
5644 p++;
5645 continue;
5646 }
5647
5648 /*
5649 * [...] is an IPv6 address.
5650 */
5651 if ((p == in) && (*p == '[')) {
5652 p++;
5653 continue;
5654 }
5655
5656 /*
5657 * Allow letters and numbers
5658 */
5659 if (((*p >= 'a') && (*p <= 'z')) ||
5660 ((*p >= 'A') && (*p <= 'Z')) ||
5661 ((*p >= '0') && (*p <= '9'))) {
5662 p++;
5663 continue;
5664 }
5665
5666 /*
5667 * Allow UTF-8 sequences.
5668 */
5669 if (*(uint8_t const *)p > 0x80) {
5670 p++;
5671 continue;
5672 }
5673
5674 /*
5675 * If it's an attribute reference, allow
5676 * a few more things inside of a "[...]"
5677 * block.
5678 */
5679 if (*p == '[') {
5680 if (quote != '[') {
5681 return_P("Invalid location for '['");
5682 }
5683
5684 p++;
5685
5686 /*
5687 * Allow [#], etc. But stop
5688 * immediately after the ']'.
5689 */
5690 if ((*p == '#') || (*p == '*') || (*p == 'n')) {
5691 p++;
5692
5693 } else if (*p == '(') {
5694 ssize_t slen;
5695 bool eol = false;
5696
5697 slen = fr_skip_condition(p, end, array_terminal, &eol);
5698 if (slen < 0) {
5699 p += -slen;
5700 return -(p - in);
5701 }
5702 p += slen;
5703 continue;
5704
5705 } else {
5706 /*
5707 * Allow numbers as array indexes
5708 */
5709 while ((*p >= '0') && (*p <= '9')) {
5710 p++;
5711 }
5712
5713 if (*p != ']') {
5714 return_P("Array index is not an integer");
5715 }
5716 }
5717
5718 if (*p == ']') {
5719 p++;
5720 continue;
5721 }
5722 }
5723
5724 /*
5725 * Everything else is a breaking token
5726 */
5727 break;
5728 }
5729
5730 /*
5731 * Give some slightly better error messages.
5732 */
5733 if (*p == '\\') {
5734 return_P("Unexpected escape");
5735 }
5736
5737 if ((*p == '"') || (*p == '\'') || (*p == '`')) {
5738 return_P("Unexpected start of string");
5739 }
5740
5741 if (p == *out) {
5742 return_P("Empty string is invalid");
5743 }
5744
5745 *outlen = p - (*out);
5746 break;
5747 }
5748
5749 return p - in;
5750}
5751
5752/** Return whether or not async is required for this tmpl.
5753 *
5754 * If the tmpl is needs_async, then it is async
5755 * If the tmpl is not needs_async, then it will not yield
5756 *
5757 * If the tmpl yields, then async is required.
5758 */
5759bool tmpl_async_required(tmpl_t const *vpt)
5760{
5761 switch (vpt->type) {
5762 case TMPL_TYPE_EXEC: /* we don't have "exec no-wait" here */
5763 case TMPL_TYPE_XLAT_UNRESOLVED: /* we have no idea, so be safe */
5764#ifndef HAVE_REGEX
5765 case TMPL_TYPE_REGEX_XLAT_UNRESOLVED:
5766#endif
5767 return true;
5768
5769#ifndef HAVE_REGEX
5770 case TMPL_TYPE_REGEX_XLAT:
5771#endif
5772 case TMPL_TYPE_XLAT: /* synchronous xlats use unlang_interpret_synchronous() */
5773 default:
5774 return false;
5775 }
5776}
5777
5778/** Initialize a set of rules from a parent set of rules, and a parsed tmpl_t
5779 *
5780 */
5781void tmpl_rules_child_init(TALLOC_CTX *ctx, tmpl_rules_t *out, tmpl_rules_t const *parent, tmpl_t *vpt)
5782{
5783 fr_dict_attr_t const *da;
5784 fr_dict_attr_t const *ref;
5785 fr_dict_t const *dict, *internal;
5786
5787 *out = *parent;
5788 /* don't set ->parent=parent, that is only for switching subrequest, etc. */
5789
5790 if (!tmpl_is_attr(vpt)) return;
5791
5792 da = tmpl_attr_tail_da(vpt);
5793
5794 /*
5795 * The input tmpl is a leaf. We must parse the child as
5796 * a normal attribute reference (as with the parent tmpl).
5797 */
5798 if (!fr_type_structural[da->type]) {
5799 return;
5800 }
5801
5802 if (vpt->rules.attr.request_def) {
5803 tmpl_request_ref_list_acopy(ctx, &out->attr.request_def, vpt->rules.attr.request_def);
5804 }
5805 out->attr.list_def = tmpl_list(vpt);
5806
5807 /*
5808 * Parse the child attributes in the context of the parent struct / tlv / whatever.
5809 */
5810 if (da->type != FR_TYPE_GROUP) {
5811 out->attr.dict_def = fr_dict_by_da(da);
5812 out->attr.namespace = da;
5813 return;
5814 }
5815
5816 ref = fr_dict_attr_ref(da);
5817 dict = fr_dict_by_da(ref);
5818 internal = fr_dict_internal();
5819
5820 /*
5821 * Groups MAY change dictionaries. If so, then swap the dictionary and the parent.
5822 */
5823 if ((dict != internal) && (dict != out->attr.dict_def)) {
5824 out->attr.dict_def = dict;
5825 out->attr.namespace = ref;
5826 }
5827
5828 /*
5829 * Otherwise the reference is swapping FROM a protocol
5830 * dictionary TO the internal dictionary, and TO an
5831 * internal group. We fall back to leaving well enough
5832 * alone, and leave things as-is. This allows internal
5833 * grouping attributes to appear anywhere.
5834 */
5835}
5836
5837static void tmpl_attr_rules_debug(tmpl_attr_rules_t const *at_rules)
5838{
5839 FR_FAULT_LOG("\tdict_def = %s", at_rules->dict_def ? fr_dict_root(at_rules->dict_def)->name : "");
5840 FR_FAULT_LOG("\tnamespace = %s", at_rules->namespace ? at_rules->namespace->name : "");
5841
5842 FR_FAULT_LOG("\tlist_def = %s", at_rules->list_def ? at_rules->list_def->name : "");
5843
5844 FR_FAULT_LOG("\tallow_unknown = %u", at_rules->allow_unknown);
5845 FR_FAULT_LOG("\tallow_unresolved = %u", at_rules->allow_unresolved);
5846 FR_FAULT_LOG("\tallow_wildcard = %u", at_rules->allow_wildcard);
5847 FR_FAULT_LOG("\tallow_foreign = %u", at_rules->allow_foreign);
5848 FR_FAULT_LOG("\tdisallow_filters = %u", at_rules->disallow_filters);
5849}
5850
5851
5852void tmpl_rules_debug(tmpl_rules_t const *rules)
5853{
5854 FR_FAULT_LOG("\tparent = %p", rules->parent);
5855 FR_FAULT_LOG(" attr {");
5856 tmpl_attr_rules_debug(&rules->attr);
5857 FR_FAULT_LOG(" }");
5858 FR_FAULT_LOG("\tenumv = %s", rules->enumv ? rules->enumv->name : "");
5859 FR_FAULT_LOG("\tcast = %s", fr_type_to_str(rules->cast));
5860 FR_FAULT_LOG("\tat_runtime = %u", rules->at_runtime);
5861 FR_FAULT_LOG("\tliterals_safe_for = %lx", rules->literals_safe_for);
5862
5863}
buffer
static int const char char buffer[256]
Definition acutest.h:576
file
int const char * file
Definition acutest.h:702
va_end
va_end(args)
fmt
static int const char * fmt
Definition acutest.h:573
line
int const char int line
Definition acutest.h:702
va_start
va_start(args, fmt)
fr_base16_decode
#define fr_base16_decode(_err, _out, _in, _no_trailing)
Definition base16.h:95
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
STRINGIFY
#define STRINGIFY(x)
Definition build.h:197
CMP_RETURN
#define CMP_RETURN(_a, _b, _field)
Return if the comparison is not 0 (is unequal)
Definition build.h:121
CMP
#define CMP(_a, _b)
Same as CMP_PREFER_SMALLER use when you don't really care about ordering, you just want an ordering.
Definition build.h:112
unlikely
#define unlikely(_x)
Definition build.h:383
NUM_ELEMENTS
#define NUM_ELEMENTS(_t)
Definition build.h:339
skip_word
static char const * skip_word(char const *text)
Definition command.c:1880
fr_dbuff_init
#define fr_dbuff_init(_out, _start, _len_or_end)
Initialise an dbuff for encoding or decoding.
Definition dbuff.h:354
FR_DBUFF_TMP
#define FR_DBUFF_TMP(_start, _len_or_end)
Creates a compound literal to pass into functions which accept a dbuff.
Definition dbuff.h:514
fr_fatal_assert_fail
#define fr_fatal_assert_fail(_msg,...)
Calls panic_action ifndef NDEBUG, else logs error and causes the server to exit immediately with code...
Definition debug.h:183
fr_cond_assert
#define fr_cond_assert(_x)
Calls panic_action ifndef NDEBUG, else logs error and evaluates to value of _x.
Definition debug.h:131
fr_assert_msg
#define fr_assert_msg(_x, _msg,...)
Calls panic_action ifndef NDEBUG, else logs error and causes the server to exit immediately with code...
Definition debug.h:202
fr_assert_fail
#define fr_assert_fail(_msg,...)
Calls panic_action ifndef NDEBUG, else logs error.
Definition debug.h:208
FR_FAULT_LOG
#define FR_FAULT_LOG(_fmt,...)
Definition debug.h:50
fr_fatal_assert_msg
#define fr_fatal_assert_msg(_x, _fmt,...)
Calls panic_action ifndef NDEBUG, else logs error and causes the server to exit immediately with code...
Definition debug.h:176
MEM
#define MEM(x)
Definition debug.h:36
fr_dict_attr_by_name_substr
fr_slen_t fr_dict_attr_by_name_substr(fr_dict_attr_err_t *err, fr_dict_attr_t const **out, fr_dict_attr_t const *parent, fr_sbuff_t *name, fr_sbuff_term_t const *tt))
fr_dict_attr_flags_t::name_only
unsigned int name_only
this attribute should always be referred to by name.
Definition dict.h:101
fr_dict_enum_name_from_substr
fr_slen_t fr_dict_enum_name_from_substr(fr_sbuff_t *out, fr_sbuff_parse_error_t *err, fr_sbuff_t *in, fr_sbuff_term_t const *tt)
Extract an enumeration name from a string.
Definition dict_util.c:3570
fr_dict_unconst
fr_dict_t * fr_dict_unconst(fr_dict_t const *dict)
Coerce to non-const.
Definition dict_util.c:4642
fr_dict_by_da
fr_dict_t const * fr_dict_by_da(fr_dict_attr_t const *da)
Attempt to locate the protocol dictionary containing an attribute.
Definition dict_util.c:2620
fr_dict_attr_common_parent
fr_dict_attr_t const * fr_dict_attr_common_parent(fr_dict_attr_t const *a, fr_dict_attr_t const *b, bool is_ancestor)
Find a common ancestor that two TLV type attributes share.
Definition dict_util.c:2051
err
static fr_slen_t err
Definition dict.h:846
fr_dict_attr_unknown_vendor_afrom_num
static fr_dict_attr_t * fr_dict_attr_unknown_vendor_afrom_num(TALLOC_CTX *ctx, fr_dict_attr_t const *parent, unsigned int vendor)
Definition dict.h:585
fr_dict_attr_allowed_chars
bool const fr_dict_attr_allowed_chars[UINT8_MAX+1]
Characters allowed in a single dictionary attribute name.
Definition dict_util.c:64
fr_dict_attr_unknown_copy
static fr_dict_attr_t * fr_dict_attr_unknown_copy(TALLOC_CTX *ctx, fr_dict_attr_t const *da)
Definition dict.h:565
fr_dict_attr_unknown_add
fr_dict_attr_t const * fr_dict_attr_unknown_add(fr_dict_t *dict, fr_dict_attr_t const *old)
Converts an unknown to a known by adding it to the internal dictionaries.
Definition dict_unknown.c:38
fr_dict_attr_by_name
fr_dict_attr_t const * fr_dict_attr_by_name(fr_dict_attr_err_t *err, fr_dict_attr_t const *parent, char const *attr))
Locate a fr_dict_attr_t by its name.
Definition dict_util.c:3277
fr_dict_attr_unconst
fr_dict_attr_t * fr_dict_attr_unconst(fr_dict_attr_t const *da)
Coerce to non-const.
Definition dict_util.c:4654
fr_dict_attr_unknown_afrom_da
fr_dict_attr_t * fr_dict_attr_unknown_afrom_da(TALLOC_CTX *ctx, fr_dict_attr_t const *da))
Copy a known or unknown attribute to produce an unknown attribute with the specified name.
Definition dict_unknown.c:235
fr_dict_attr_unknown_raw_afrom_num
static fr_dict_attr_t * fr_dict_attr_unknown_raw_afrom_num(TALLOC_CTX *ctx, fr_dict_attr_t const *parent, unsigned int attr)
Definition dict.h:592
fr_dict_root
fr_dict_attr_t const * fr_dict_root(fr_dict_t const *dict)
Return the root attribute of a dictionary.
Definition dict_util.c:2414
fr_dict_attr_unknown_parent_to_known
int fr_dict_attr_unknown_parent_to_known(fr_dict_attr_t *da, fr_dict_attr_t const *parent)
Fixup the parent of an unknown attribute using an equivalent known attribute.
Definition dict_unknown.c:517
fr_dict_enum_value_t::value
fr_value_box_t const * value
Enum value (what name maps to).
Definition dict.h:237
fr_dict_attr_unknown_free
void fr_dict_attr_unknown_free(fr_dict_attr_t const **da)
Free dynamically allocated (unknown attributes)
Definition dict_unknown.c:148
fr_dict_internal
fr_dict_t const * fr_dict_internal(void)
Definition dict_util.c:4667
fr_dict_attr_search_by_qualified_name_substr
fr_slen_t fr_dict_attr_search_by_qualified_name_substr(fr_dict_attr_err_t *err, fr_dict_attr_t const **out, fr_dict_t const *dict_def, fr_sbuff_t *name, fr_sbuff_term_t const *tt, bool internal, bool foreign))
Locate a qualified fr_dict_attr_t by its name and a dictionary qualifier.
Definition dict_util.c:2989
fr_dict_attr_search_by_name_substr
fr_slen_t fr_dict_attr_search_by_name_substr(fr_dict_attr_err_t *err, fr_dict_attr_t const **out, fr_dict_t const *dict_def, fr_sbuff_t *name, fr_sbuff_term_t const *tt, bool internal, bool foreign))
Locate a fr_dict_attr_t by its name in the top level namespace of a dictionary.
Definition dict_util.c:3018
fr_dict_enum_name_afrom_substr
static fr_slen_t fr_dict_enum_name_afrom_substr(TALLOC_CTX *ctx, char **out, fr_sbuff_parse_error_t *err, fr_sbuff_t *in, fr_sbuff_term_t const *tt) 1(fr_dict_enum_name_from_substr
FR_DICT_MAX_TLV_STACK
#define FR_DICT_MAX_TLV_STACK
Maximum TLV stack size.
Definition dict.h:500
fr_dict_attr_err_t
fr_dict_attr_err_t
Errors returned by attribute lookup functions.
Definition dict.h:296
FR_DICT_ATTR_OK
@ FR_DICT_ATTR_OK
No error.
Definition dict.h:297
FR_DICT_ATTR_NOT_DESCENDENT
@ FR_DICT_ATTR_NOT_DESCENDENT
Attribute is not a descendent of the parent attribute.
Definition dict.h:303
FR_DICT_ATTR_NO_CHILDREN
@ FR_DICT_ATTR_NO_CHILDREN
Child lookup in attribute with no children.
Definition dict.h:307
fr_dict_attr_add
int fr_dict_attr_add(fr_dict_t *dict, fr_dict_attr_t const *parent, char const *name, unsigned int attr, fr_type_t type, fr_dict_attr_flags_t const *flags))
Add an attribute to the dictionary.
Definition dict_util.c:1726
fr_dict_attr_child_by_num
fr_dict_attr_t const * fr_dict_attr_child_by_num(fr_dict_attr_t const *parent, unsigned int attr)
Check if a child attribute exists in a parent using an attribute number.
Definition dict_util.c:3342
fr_dict_attr_is_key_field
#define fr_dict_attr_is_key_field(_da)
Definition dict.h:159
fr_dict_enum_by_name
fr_dict_enum_value_t const * fr_dict_enum_by_name(fr_dict_attr_t const *da, char const *name, ssize_t len)
Definition dict_util.c:3450
in
static fr_slen_t in
Definition dict.h:846
FR_DICT_ATTR_MAX_NAME_LEN
#define FR_DICT_ATTR_MAX_NAME_LEN
Maximum length of a attribute name.
Definition dict.h:480
fr_dict_attr_flags_t
Values of the encryption flags.
Definition merged_model.c:139
fr_dict_enum_value_t
Value of an enumerated attribute.
Definition dict.h:233
fr_dict_attr_ref
static fr_dict_attr_t const * fr_dict_attr_ref(fr_dict_attr_t const *da)
Return the reference associated with a group type attribute.
Definition dict_ext.h:184
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_HEAD
#define FR_DLIST_HEAD(_name)
Expands to the type name used for the head wrapper structure.
Definition dlist.h:1122
FR_IPADDR_STRLEN
#define FR_IPADDR_STRLEN
Like INET6_ADDRSTRLEN but includes space for the textual Zone ID.
Definition inet.h:89
talloc_free
talloc_free(reap)
stack
static char * stack[MAX_STACK]
Definition radmin.c:159
uint16_t
unsigned short uint16_t
Definition merged_model.c:31
fr_type_t
fr_type_t
Definition merged_model.c:80
FR_TYPE_TIME_DELTA
@ FR_TYPE_TIME_DELTA
A period of time measured in nanoseconds.
Definition merged_model.c:113
FR_TYPE_IPV4_ADDR
@ FR_TYPE_IPV4_ADDR
32 Bit IPv4 Address.
Definition merged_model.c:86
FR_TYPE_INT8
@ FR_TYPE_INT8
8 Bit signed integer.
Definition merged_model.c:103
FR_TYPE_TLV
@ FR_TYPE_TLV
Contains nested attributes.
Definition merged_model.c:118
FR_TYPE_ETHERNET
@ FR_TYPE_ETHERNET
48 Bit Mac-Address.
Definition merged_model.c:93
FR_TYPE_IPV6_PREFIX
@ FR_TYPE_IPV6_PREFIX
IPv6 Prefix.
Definition merged_model.c:89
FR_TYPE_STRING
@ FR_TYPE_STRING
String of printable characters.
Definition merged_model.c:83
FR_TYPE_MAX
@ FR_TYPE_MAX
Number of defined data types.
Definition merged_model.c:130
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_STRUCT
@ FR_TYPE_STRUCT
like TLV, but without T or L, and fixed-width children
Definition merged_model.c:119
FR_TYPE_INT32
@ FR_TYPE_INT32
32 Bit signed integer.
Definition merged_model.c:105
FR_TYPE_VENDOR
@ FR_TYPE_VENDOR
Attribute that represents a vendor in the attribute tree.
Definition merged_model.c:122
FR_TYPE_UINT64
@ FR_TYPE_UINT64
64 Bit unsigned integer.
Definition merged_model.c:100
FR_TYPE_IPV6_ADDR
@ FR_TYPE_IPV6_ADDR
128 Bit IPv6 Address.
Definition merged_model.c:88
FR_TYPE_IPV4_PREFIX
@ FR_TYPE_IPV4_PREFIX
IPv4 Prefix.
Definition merged_model.c:87
FR_TYPE_BOOL
@ FR_TYPE_BOOL
A truth value.
Definition merged_model.c:95
FR_TYPE_VSA
@ FR_TYPE_VSA
Vendor-Specific, for RADIUS attribute 26.
Definition merged_model.c:121
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
FR_TYPE_FLOAT64
@ FR_TYPE_FLOAT64
Double precision floating point.
Definition merged_model.c:109
uint32_t
unsigned int uint32_t
Definition merged_model.c:33
ssize_t
long int ssize_t
Definition merged_model.c:24
uint8_t
unsigned char uint8_t
Definition merged_model.c:30
fr_slen_t
ssize_t fr_slen_t
Definition merged_model.c:35
size_t
unsigned long int size_t
Definition merged_model.c:25
UINT8_MAX
#define UINT8_MAX
Definition merged_model.c:32
fr_sbuff_parse_error_t
fr_sbuff_parse_error_t
Definition merged_model.c:45
FR_SBUFF_PARSE_ERROR_NOT_FOUND
@ FR_SBUFF_PARSE_ERROR_NOT_FOUND
String does not contain a token matching the output type.
Definition merged_model.c:47
FR_SBUFF_PARSE_ERROR_FORMAT
@ FR_SBUFF_PARSE_ERROR_FORMAT
Format of data was invalid.
Definition merged_model.c:50
FR_SBUFF_PARSE_OK
@ FR_SBUFF_PARSE_OK
No error.
Definition merged_model.c:46
fr_dbuff_t
Definition merged_model.c:41
fr_dict_attr_t
Definition merged_model.c:133
fr_dict_t
Definition merged_model.c:198
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
tmpl_t
Definition merged_model.c:225
depth
static uint8_t depth(fr_minmax_heap_index_t i)
Definition minmax_heap.c:83
fr_vasprintf
char * fr_vasprintf(TALLOC_CTX *ctx, char const *fmt, va_list ap)
Definition print.c:851
fr_proto_da_stack_build_partial
void fr_proto_da_stack_build_partial(fr_da_stack_t *stack, fr_dict_attr_t const *parent, fr_dict_attr_t const *da)
Complete the DA stack for a child attribute.
Definition proto.c:159
fr_assert
#define fr_assert(_expr)
Definition rad_assert.h:38
done
static bool done
Definition radclient.c:81
mask
static uint32_t mask
Definition rbmonkey.c:39
request_attr_request
fr_dict_attr_t const * request_attr_request
Definition request.c:43
request_attr_control
fr_dict_attr_t const * request_attr_control
Definition request.c:45
request_attr_local
fr_dict_attr_t const * request_attr_local
Definition request.c:47
request_attr_state
fr_dict_attr_t const * request_attr_state
Definition request.c:46
request_attr_reply
fr_dict_attr_t const * request_attr_reply
Definition request.c:44
name
static char const * name
Definition rlm_redis_ippool_tool.c:156
fr_sbuff_adv_past_allowed
size_t fr_sbuff_adv_past_allowed(fr_sbuff_t *sbuff, size_t len, bool const allowed[static UINT8_MAX+1], fr_sbuff_term_t const *tt)
Wind position past characters in the allowed set.
Definition sbuff.c:1810
sbuff_char_class_hex
bool const sbuff_char_class_hex[UINT8_MAX+1]
Definition sbuff.c:94
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_adv_past_strcase
size_t fr_sbuff_adv_past_strcase(fr_sbuff_t *sbuff, char const *needle, size_t needle_len)
Return true and advance past the end of the needle if needle occurs next in the sbuff.
Definition sbuff.c:1776
fr_sbuff_adv_until
size_t fr_sbuff_adv_until(fr_sbuff_t *sbuff, size_t len, fr_sbuff_term_t const *tt, char escape_chr)
Wind position until we hit a character in the terminal set.
Definition sbuff.c:1885
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_IN_TABLE_STR_RETURN
#define FR_SBUFF_IN_TABLE_STR_RETURN(_sbuff, _table, _number, _def)
fr_sbuff_adv_past_str_literal
#define fr_sbuff_adv_past_str_literal(_sbuff, _needle)
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_IN
#define FR_SBUFF_IN(_start, _len_or_end)
fr_sbuff_adv_past_whitespace
#define fr_sbuff_adv_past_whitespace(_sbuff, _len, _tt)
fr_sbuff_adv_past_strcase_literal
#define fr_sbuff_adv_past_strcase_literal(_sbuff, _needle)
fr_sbuff_current
#define fr_sbuff_current(_sbuff_or_marker)
FR_SBUFF_REPARSE
#define FR_SBUFF_REPARSE(_sbuff_or_marker)
FR_SBUFF_IN_ESCAPE_BUFFER_RETURN
#define FR_SBUFF_IN_ESCAPE_BUFFER_RETURN(...)
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_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_IN_SPRINTF_RETURN
#define FR_SBUFF_IN_SPRINTF_RETURN(...)
FR_SBUFF
#define FR_SBUFF(_sbuff_or_marker)
FR_SBUFF_IN_BSTRNCPY_RETURN
#define FR_SBUFF_IN_BSTRNCPY_RETURN(...)
fr_sbuff_advance
#define fr_sbuff_advance(_sbuff_or_marker, _len)
fr_sbuff_out
#define fr_sbuff_out(_err, _out, _in)
fr_sbuff_switch
#define fr_sbuff_switch(_sbuff_or_marker, _eob)
FR_SBUFF_OUT
#define FR_SBUFF_OUT(_start, _len_or_end)
fr_sbuff_used
#define fr_sbuff_used(_sbuff_or_marker)
fr_sbuff_in_strcpy_literal
#define fr_sbuff_in_strcpy_literal(_sbuff, _str)
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_IN_BSTRCPY_BUFFER_RETURN
#define FR_SBUFF_IN_BSTRCPY_BUFFER_RETURN(...)
fr_sbuff_ptr_s
Definition sbuff.h:84
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_VERIFY
#define TMPL_VERIFY(_vpt)
Definition tmpl.h:961
tmpl_value_length
#define tmpl_value_length(_tmpl)
Definition tmpl.h:938
tmpl_type_to_str
static char const * tmpl_type_to_str(tmpl_type_t type)
Return a static string containing the type name.
Definition tmpl.h:634
tmpl_is_uninitialised
#define tmpl_is_uninitialised(vpt)
Helpers to verify the type of tmpl_t.
Definition tmpl.h:204
tmpl_is_attr_unresolved
#define tmpl_is_attr_unresolved(vpt)
Definition tmpl.h:219
tmpl_request_ref_t
enum requests_ref_e tmpl_request_ref_t
tmpl_attr_tail_is_unspecified
static bool tmpl_attr_tail_is_unspecified(tmpl_t const *vpt)
Return true if the last attribute reference is "unspecified".
Definition tmpl.h:726
NUM_LAST
#define NUM_LAST
Definition tmpl.h:393
tmpl_rules_enumv
#define tmpl_rules_enumv(_tmpl)
Definition tmpl.h:943
tmpl_attr_tail_is_normal
static bool tmpl_attr_tail_is_normal(tmpl_t const *vpt)
Return true if the last attribute reference is "normal".
Definition tmpl.h:710
tmpl_value
#define tmpl_value(_tmpl)
Definition tmpl.h:937
ar_is_unknown
#define ar_is_unknown(_ar)
Definition tmpl.h:507
tmpl_attr_tail_is_unknown
static bool tmpl_attr_tail_is_unknown(tmpl_t const *vpt)
Return true if the last attribute reference is "unknown".
Definition tmpl.h:742
tmpl_contains_regex
#define tmpl_contains_regex(vpt)
Definition tmpl.h:226
tmpl_rules_s::literals_safe_for
fr_value_box_safe_for_t literals_safe_for
safe_for value assigned to literal values in xlats, execs, and data.
Definition tmpl.h:347
ar_is_raw
#define ar_is_raw(_ar)
Definition tmpl.h:509
tmpl_is_attr
#define tmpl_is_attr(vpt)
Definition tmpl.h:208
NUM_ALL
#define NUM_ALL
Definition tmpl.h:391
tmpl_rules_s::enumv
fr_dict_attr_t const * enumv
Enumeration attribute used to resolve enum values.
Definition tmpl.h:338
tmpl_rules_s::parent
tmpl_rules_t const * parent
for parent / child relationships
Definition tmpl.h:333
tmpl_value_enumv
#define tmpl_value_enumv(_tmpl)
Definition tmpl.h:940
tmpl_xlat
#define tmpl_xlat(_tmpl)
Definition tmpl.h:930
tmpl_list
static fr_dict_attr_t const * tmpl_list(tmpl_t const *vpt)
Definition tmpl.h:904
tmpl_attr_is_list_attr
static bool tmpl_attr_is_list_attr(tmpl_attr_t const *ar)
Return true if the tmpl_attr is one of the list types.
Definition tmpl.h:679
ar_filter_is_num
#define ar_filter_is_num(_ar)
Definition tmpl.h:518
tmpl_rules_cast
#define tmpl_rules_cast(_tmpl)
Definition tmpl.h:942
TMPL_TYPE_REGEX_UNCOMPILED
@ TMPL_TYPE_REGEX_UNCOMPILED
Regex where compilation is possible but hasn't been performed yet.
Definition tmpl.h:158
TMPL_TYPE_MAX
@ TMPL_TYPE_MAX
Marker for the last tmpl type.
Definition tmpl.h:199
TMPL_TYPE_ATTR_UNRESOLVED
@ TMPL_TYPE_ATTR_UNRESOLVED
An attribute reference that we couldn't resolve but looked valid.
Definition tmpl.h:185
TMPL_TYPE_ATTR
@ TMPL_TYPE_ATTR
Reference to one or more attributes.
Definition tmpl.h:142
TMPL_TYPE_XLAT
@ TMPL_TYPE_XLAT
Pre-parsed xlat expansion.
Definition tmpl.h:146
TMPL_TYPE_EXEC
@ TMPL_TYPE_EXEC
Callout to an external script or program.
Definition tmpl.h:150
TMPL_TYPE_REGEX_XLAT_UNRESOLVED
@ TMPL_TYPE_REGEX_XLAT_UNRESOLVED
A regular expression with unresolved xlat functions or attribute references.
Definition tmpl.h:197
TMPL_TYPE_DATA
@ TMPL_TYPE_DATA
Value in native boxed format.
Definition tmpl.h:138
TMPL_TYPE_REGEX
@ TMPL_TYPE_REGEX
Compiled (and possibly JIT'd) regular expression.
Definition tmpl.h:154
TMPL_TYPE_DATA_UNRESOLVED
@ TMPL_TYPE_DATA_UNRESOLVED
Unparsed literal string.
Definition tmpl.h:179
TMPL_TYPE_XLAT_UNRESOLVED
@ TMPL_TYPE_XLAT_UNRESOLVED
A xlat expansion with unresolved xlat functions or attribute references.
Definition tmpl.h:193
TMPL_TYPE_REGEX_XLAT
@ TMPL_TYPE_REGEX_XLAT
A regex containing xlat expansions.
Definition tmpl.h:162
TMPL_TYPE_EXEC_UNRESOLVED
@ TMPL_TYPE_EXEC_UNRESOLVED
An exec with unresolved xlat function or attribute references.
Definition tmpl.h:189
TMPL_TYPE_UNINITIALISED
@ TMPL_TYPE_UNINITIALISED
Uninitialised.
Definition tmpl.h:134
tmpl_is_regex_xlat
#define tmpl_is_regex_xlat(vpt)
Definition tmpl.h:215
NUM_COUNT
#define NUM_COUNT
Definition tmpl.h:392
tmpl_assert_type
#define tmpl_assert_type(_cond)
Convenience macro for printing a meaningful assert message when we get a bad tmpl type.
Definition tmpl.h:620
tmpl_contains_attr
#define tmpl_contains_attr(vpt)
Definition tmpl.h:225
ar_da
#define ar_da
Definition tmpl.h:499
TMPL_FLAG_REGEX
#define TMPL_FLAG_REGEX
Is a type of regular expression.
Definition tmpl.h:116
ar_filter_is_cond
#define ar_filter_is_cond(_ar)
Definition tmpl.h:519
tmpl_rules_s::xlat
tmpl_xlat_rules_t xlat
Rules/data for parsing xlats.
Definition tmpl.h:336
tmpl_attr_tail_unresolved
static char const * tmpl_attr_tail_unresolved(tmpl_t const *vpt)
Return the last attribute reference unresolved da.
Definition tmpl.h:869
tmpl_rules_s::at_runtime
bool at_runtime
Produce an ephemeral/runtime tmpl.
Definition tmpl.h:344
tmpl_is_list
static bool tmpl_is_list(tmpl_t const *vpt)
Definition tmpl.h:920
TMPL_ATTR_VERIFY
#define TMPL_ATTR_VERIFY(_vpt)
Definition tmpl.h:960
tmpl_res_rules_s::force_dict_def
bool force_dict_def
Use supplied dict_def even if original vpt->rules->dict_def was not NULL.
Definition tmpl.h:370
tmpl_is_data
#define tmpl_is_data(vpt)
Definition tmpl.h:206
vpt
static fr_slen_t vpt
Definition tmpl.h:1269
tmpl_res_rules_s::dict_def
fr_dict_t const * dict_def
Alternative default dictionary to use if vpt->rules->dict_def is NULL.
Definition tmpl.h:365
NUM_UNSPEC
#define NUM_UNSPEC
Definition tmpl.h:390
tmpl_attr_num_elements
static size_t tmpl_attr_num_elements(tmpl_t const *vpt)
The number of attribute references contained within a tmpl.
Definition tmpl.h:896
tmpl_value_type
#define tmpl_value_type(_tmpl)
Definition tmpl.h:939
tmpl_attr
#define tmpl_attr(_tmpl)
Definition tmpl.h:654
tmpl_attr_error_t
tmpl_attr_error_t
Definition tmpl.h:1004
TMPL_ATTR_ERROR_INVALID_ARRAY_INDEX
@ TMPL_ATTR_ERROR_INVALID_ARRAY_INDEX
Invalid array index.
Definition tmpl.h:1023
TMPL_ATTR_ERROR_LIST_NOT_ALLOWED
@ TMPL_ATTR_ERROR_LIST_NOT_ALLOWED
List qualifier is not allowed here.
Definition tmpl.h:1008
TMPL_ATTR_ERROR_UNRESOLVED_NOT_ALLOWED
@ TMPL_ATTR_ERROR_UNRESOLVED_NOT_ALLOWED
Attribute couldn't be found in the dictionaries.
Definition tmpl.h:1014
TMPL_ATTR_ERROR_BAD_CAST
@ TMPL_ATTR_ERROR_BAD_CAST
Specified cast was invalid.
Definition tmpl.h:1027
TMPL_ATTR_ERROR_INVALID_NAME
@ TMPL_ATTR_ERROR_INVALID_NAME
Attribute ref length is zero, or longer than the maximum.
Definition tmpl.h:1016
TMPL_ATTR_ERROR_MISSING_TERMINATOR
@ TMPL_ATTR_ERROR_MISSING_TERMINATOR
Unexpected text found after attribute reference.
Definition tmpl.h:1026
TMPL_ATTR_ERROR_LIST_MISSING
@ TMPL_ATTR_ERROR_LIST_MISSING
List qualifier is required, but missing.
Definition tmpl.h:1009
TMPL_ATTR_ERROR_NONE
@ TMPL_ATTR_ERROR_NONE
No error.
Definition tmpl.h:1005
TMPL_ATTR_ERROR_FOREIGN_NOT_ALLOWED
@ TMPL_ATTR_ERROR_FOREIGN_NOT_ALLOWED
Attribute resolved in a dictionary different to the one specified.
Definition tmpl.h:1020
TMPL_ATTR_ERROR_UNKNOWN_NOT_ALLOWED
@ TMPL_ATTR_ERROR_UNKNOWN_NOT_ALLOWED
Attribute specified as OID, could not be found in the dictionaries, and is disallowed because 'disall...
Definition tmpl.h:1010
TMPL_ATTR_ERROR_FILTER_NOT_ALLOWED
@ TMPL_ATTR_ERROR_FILTER_NOT_ALLOWED
Filters disallowed by rules.
Definition tmpl.h:1022
TMPL_ATTR_ERROR_EMPTY
@ TMPL_ATTR_ERROR_EMPTY
Attribute ref contains no data.
Definition tmpl.h:1006
TMPL_ATTR_ERROR_NESTING_TOO_DEEP
@ TMPL_ATTR_ERROR_NESTING_TOO_DEEP
Too many levels of nesting.
Definition tmpl.h:1025
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_ATTR_LIST_REQUIRE
@ TMPL_ATTR_LIST_REQUIRE
Attribute refs are required to have a list.
Definition tmpl.h:264
TMPL_ATTR_LIST_ALLOW
@ TMPL_ATTR_LIST_ALLOW
Attribute refs are allowed to have a list.
Definition tmpl.h:262
TMPL_ATTR_LIST_FORBID
@ TMPL_ATTR_LIST_FORBID
Attribute refs are forbidden from having a list.
Definition tmpl.h:263
tmpl_type_t
enum tmpl_type_e tmpl_type_t
Types of tmpl_t.
tmpl_attr_tail_unknown
static fr_dict_attr_t const * tmpl_attr_tail_unknown(tmpl_t const *vpt)
Return the last attribute reference unknown da.
Definition tmpl.h:853
tmpl_is_regex
#define tmpl_is_regex(vpt)
Definition tmpl.h:213
tmpl_list_name
static char const * tmpl_list_name(fr_dict_attr_t const *list, char const *def)
Return the name of a tmpl list or def if list not provided.
Definition tmpl.h:915
tmpl_attr_tail_is_raw
static bool tmpl_attr_tail_is_raw(tmpl_t const *vpt)
Return true if the last attribute reference is "raw".
Definition tmpl.h:774
REQUEST_OUTER
@ REQUEST_OUTER
request_t containing the outer layer of the EAP conversation.
Definition tmpl.h:92
REQUEST_PARENT
@ REQUEST_PARENT
Parent (whatever it is).
Definition tmpl.h:96
REQUEST_UNKNOWN
@ REQUEST_UNKNOWN
Unknown request.
Definition tmpl.h:97
REQUEST_CURRENT
@ REQUEST_CURRENT
The current request (default).
Definition tmpl.h:91
tmpl_rules_t
struct tmpl_rules_s tmpl_rules_t
Definition tmpl.h:233
tmpl_is_regex_xlat_unresolved
#define tmpl_is_regex_xlat_unresolved(vpt)
Definition tmpl.h:221
tmpl_is_regex_uncompiled
#define tmpl_is_regex_uncompiled(vpt)
Definition tmpl.h:214
tmpl_res_rules_s::enumv
fr_dict_attr_t const * enumv
for resolving T_BARE_WORD
Definition tmpl.h:373
TMPL_MAX_REQUEST_REF_NESTING
#define TMPL_MAX_REQUEST_REF_NESTING
The maximum number of request references allowed.
Definition tmpl.h:85
tmpl_attr_type_t
tmpl_attr_type_t
Definition tmpl.h:376
TMPL_ATTR_TYPE_UNSPEC
@ TMPL_ATTR_TYPE_UNSPEC
No attribute was specified as this level only a filter.
Definition tmpl.h:378
TMPL_ATTR_TYPE_NORMAL
@ TMPL_ATTR_TYPE_NORMAL
Normal, resolved, attribute ref.
Definition tmpl.h:377
TMPL_ATTR_TYPE_UNKNOWN
@ TMPL_ATTR_TYPE_UNKNOWN
We have an attribute number but it doesn't match anything in the dictionary, or isn't a child of the ...
Definition tmpl.h:380
TMPL_ATTR_TYPE_UNRESOLVED
@ TMPL_ATTR_TYPE_UNRESOLVED
We have a name, but nothing else to identify the attribute.
Definition tmpl.h:385
TMPL_ATTR_FILTER_TYPE_TMPL
@ TMPL_ATTR_FILTER_TYPE_TMPL
Filter is a tmpl.
Definition tmpl.h:407
TMPL_ATTR_FILTER_TYPE_INDEX
@ TMPL_ATTR_FILTER_TYPE_INDEX
Filter is an index type.
Definition tmpl.h:405
TMPL_ATTR_FILTER_TYPE_CONDITION
@ TMPL_ATTR_FILTER_TYPE_CONDITION
Filter is a condition.
Definition tmpl.h:406
TMPL_ATTR_FILTER_TYPE_NONE
@ TMPL_ATTR_FILTER_TYPE_NONE
No filter present.
Definition tmpl.h:404
TMPL_ATTR_FILTER_TYPE_EXPR
@ TMPL_ATTR_FILTER_TYPE_EXPR
Filter is an expression.
Definition tmpl.h:408
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_attr_filter_t::type
tmpl_attr_filter_type_t _CONST type
Type of filter this is.
Definition tmpl.h:412
ar_filter_is_none
#define ar_filter_is_none(_ar)
Definition tmpl.h:517
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
buff
static char buff[sizeof("18446744073709551615")+3]
Definition size_tests.c:41
fr_skip_condition
ssize_t fr_skip_condition(char const *start, char const *end, bool const terminal[static UINT8_MAX+1], bool *eol)
Skip a conditional expression.
Definition skip.c:286
snprintf
PUBLIC int snprintf(char *string, size_t length, char *format, va_alist)
Definition snprintf.c:689
count
return count
Definition module.c:155
type
fr_aka_sim_id_type_t type
Definition state_machine.c:3654
tmpl_attr_rules_s
Define entry and head types for tmpl request references.
Definition tmpl.h:272
tmpl_attr_rules_s::list_presence
tmpl_attr_list_presence_t list_presence
Whether the attribute reference can have a list, forbid it, or require it.
Definition tmpl.h:298
tmpl_attr_rules_s::list_def
fr_dict_attr_t const * list_def
Default list to use with unqualified attribute reference.
Definition tmpl.h:295
tmpl_attr_rules_s::disallow_filters
uint8_t disallow_filters
disallow filters.
Definition tmpl.h:314
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::allow_foreign
uint8_t allow_foreign
Allow arguments not found in dict_def.
Definition tmpl.h:312
tmpl_attr_rules_s::dict_def
fr_dict_t const * dict_def
Default dictionary to use with unqualified attribute references.
Definition tmpl.h:273
tmpl_attr_rules_s::allow_wildcard
uint8_t allow_wildcard
Allow the special case of .
Definition tmpl.h:309
tmpl_attr_rules_s::allow_unknown
uint8_t allow_unknown
Allow unknown attributes i.e.
Definition tmpl.h:301
tmpl_attr_t
An element in a list of nested attribute references.
Definition tmpl.h:430
tmpl_attr_t::resolve_only
unsigned int _CONST resolve_only
This reference and those before it.
Definition tmpl.h:453
tmpl_attr_t::is_raw
unsigned int _CONST is_raw
Definition tmpl.h:456
tmpl_attr_t::da
fr_dict_attr_t const *_CONST da
Resolved dictionary attribute.
Definition tmpl.h:434
tmpl_attr_t::parent
fr_dict_attr_t const *_CONST parent
The parent we used when trying to resolve the attribute originally.
Definition tmpl.h:448
tmpl_attr_t::filter
tmpl_attr_filter_t _CONST filter
Filter associated with the attribute reference.
Definition tmpl.h:460
tmpl_attr_t::type
tmpl_attr_type_t _CONST type
is a raw reference
Definition tmpl.h:458
tmpl_request_t
Define manipulation functions for the attribute reference list.
Definition tmpl.h:471
tmpl_request_t::request
tmpl_request_ref_t _CONST request
Definition tmpl.h:475
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_bstrdup
char * talloc_bstrdup(TALLOC_CTX *ctx, char const *in)
Binary safe strdup function.
Definition talloc.c:558
talloc_bstrndup
char * talloc_bstrndup(TALLOC_CTX *ctx, char const *in, size_t inlen)
Binary safe strndup function.
Definition talloc.c:586
talloc_typed_strdup
char * talloc_typed_strdup(TALLOC_CTX *ctx, char const *p)
Call talloc_strdup, setting the type on the new chunk correctly.
Definition talloc.c:467
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
talloc_pooled_object
#define talloc_pooled_object(_ctx, _type, _num_subobjects, _total_subobjects_size)
Definition talloc.h:180
fr_time_delta_from_substr
fr_slen_t fr_time_delta_from_substr(fr_time_delta_t *out, fr_sbuff_t *in, fr_time_res_t hint, bool no_trailing, fr_sbuff_term_t const *tt)
Create fr_time_delta_t from a string.
Definition time.c:214
FR_TIME_RES_SEC
@ FR_TIME_RES_SEC
Definition time.h:50
fr_time_delta_s
A time delta, a difference in time measured in nanoseconds.
Definition time.h:80
tmpl_escape_t
Escaping rules for tmpls.
Definition tmpl_escape.h:80
tmpl_request_ref_list_cmp
int8_t tmpl_request_ref_list_cmp(FR_DLIST_HEAD(tmpl_request_list) const *a, FR_DLIST_HEAD(tmpl_request_list) const *b)
Compare a list of request qualifiers.
Definition tmpl_tokenize.c:480
tmpl_afrom_time_delta
static ssize_t tmpl_afrom_time_delta(TALLOC_CTX *ctx, tmpl_t **out, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *p_rules)
Definition tmpl_tokenize.c:2986
tmpl_request_ref_list_debug
void tmpl_request_ref_list_debug(FR_DLIST_HEAD(tmpl_request_list) const *rql)
Dump a request list to stderr.
Definition tmpl_tokenize.c:460
tmpl_request_ref_list_print
fr_slen_t tmpl_request_ref_list_print(fr_sbuff_t *out, FR_DLIST_HEAD(tmpl_request_list) const *rql)
Definition tmpl_tokenize.c:4621
tmpl_attr_set_list
void tmpl_attr_set_list(tmpl_t *vpt, fr_dict_attr_t const *list)
Definition tmpl_tokenize.c:1225
tmpl_init_shallow
tmpl_t * tmpl_init_shallow(tmpl_t *vpt, tmpl_type_t type, fr_token_t quote, char const *name, ssize_t len, tmpl_rules_t const *t_rules)
Initialise a tmpl without copying the input name string.
Definition tmpl_tokenize.c:875
tmpl_request_ref_list_afrom_substr
fr_slen_t tmpl_request_ref_list_afrom_substr(TALLOC_CTX *ctx, tmpl_attr_error_t *err, FR_DLIST_HEAD(tmpl_request_list) **out, fr_sbuff_t *in)
Parse one or more request references, allocing a new list and adding the references to it.
Definition tmpl_tokenize.c:686
attr_num_table
static fr_table_num_sorted_t const attr_num_table[]
Special attribute reference indexes.
Definition tmpl_tokenize.c:155
tmpl_unresolve
void tmpl_unresolve(tmpl_t *vpt)
Reset the tmpl, leaving only the name in place.
Definition tmpl_tokenize.c:4344
tmpl_set_xlat
void tmpl_set_xlat(tmpl_t *vpt, xlat_exp_head_t *xlat)
Change the default dictionary in the tmpl's resolution rules.
Definition tmpl_tokenize.c:828
tmpl_type_init
static void tmpl_type_init(tmpl_t *vpt, tmpl_type_t type)
Initialise fields inside a tmpl depending on its type.
Definition tmpl_tokenize.c:719
RESOLVED_SET
#define RESOLVED_SET(_flags)
Definition tmpl_tokenize.c:170
tmpl_attr_ref_afrom_unresolved_substr
static fr_slen_t tmpl_attr_ref_afrom_unresolved_substr(TALLOC_CTX *ctx, tmpl_attr_error_t *err, tmpl_t *vpt, fr_dict_attr_t const *parent, fr_dict_attr_t const *namespace, fr_sbuff_t *name, tmpl_attr_rules_t const *at_rules)
Parse an unresolved attribute, i.e.
Definition tmpl_tokenize.c:1627
tmpl_attr_set_request_ref
void tmpl_attr_set_request_ref(tmpl_t *vpt, FR_DLIST_HEAD(tmpl_request_list) const *request_def)
Set the request for an attribute ref.
Definition tmpl_tokenize.c:1211
tmpl_set_name_printf
void tmpl_set_name_printf(tmpl_t *vpt, fr_token_t quote, char const *fmt,...)
Set the name on a pre-initialised tmpl.
Definition tmpl_tokenize.c:751
tmpl_attr_set_da
int tmpl_attr_set_da(tmpl_t *vpt, fr_dict_attr_t const *da)
Replace the current attribute reference.
Definition tmpl_tokenize.c:1084
tmpl_attr_ref_debug
void tmpl_attr_ref_debug(FILE *fp, const tmpl_attr_t *ar, int i)
Definition tmpl_tokenize.c:196
attr_table
static fr_table_num_ordered_t const attr_table[]
Attr ref types.
Definition tmpl_tokenize.c:135
tmpl_xlat_resolve
static int tmpl_xlat_resolve(tmpl_t *vpt, tmpl_res_rules_t const *tr_rules)
Resolve an unresolved xlat, i.e.
Definition tmpl_tokenize.c:4184
tmpl_request_ref_table
fr_table_num_sorted_t const tmpl_request_ref_table[]
Map keywords to tmpl_request_ref_t values.
Definition tmpl_tokenize.c:145
tmpl_attr_debug
void tmpl_attr_debug(FILE *fp, tmpl_t const *vpt)
Definition tmpl_tokenize.c:271
tmpl_afrom_value_box
int tmpl_afrom_value_box(TALLOC_CTX *ctx, tmpl_t **out, fr_value_box_t *data, bool steal)
Create a tmpl_t from a fr_value_box_t.
Definition tmpl_tokenize.c:998
tmpl_alloc
tmpl_t * tmpl_alloc(TALLOC_CTX *ctx, tmpl_type_t type, fr_token_t quote, char const *name, ssize_t len)
Create a new heap allocated tmpl_t.
Definition tmpl_tokenize.c:941
tmpl_attr_unknown_add
int tmpl_attr_unknown_add(tmpl_t *vpt)
Add an unknown fr_dict_attr_t specified by a tmpl_t to the main dictionary.
Definition tmpl_tokenize.c:4447
tmpl_attr_print
fr_slen_t tmpl_attr_print(fr_sbuff_t *out, tmpl_t const *vpt)
Print an attribute or list tmpl_t to a string.
Definition tmpl_tokenize.c:4649
tmpl_set_escape
void tmpl_set_escape(tmpl_t *vpt, tmpl_escape_t const *escape)
Set escape parameters for the tmpl output.
Definition tmpl_tokenize.c:818
tmpl_async_required
bool tmpl_async_required(tmpl_t const *vpt)
Return whether or not async is required for this tmpl.
Definition tmpl_tokenize.c:5759
tmpl_rules_child_init
void tmpl_rules_child_init(TALLOC_CTX *ctx, tmpl_rules_t *out, tmpl_rules_t const *parent, tmpl_t *vpt)
Initialize a set of rules from a parent set of rules, and a parsed tmpl_t.
Definition tmpl_tokenize.c:5781
tmpl_afrom_attr_substr
ssize_t tmpl_afrom_attr_substr(TALLOC_CTX *ctx, tmpl_attr_error_t *err, tmpl_t **out, fr_sbuff_t *name, fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules)
Parse a string into a TMPL_TYPE_ATTR_* type tmpl_t.
Definition tmpl_tokenize.c:2201
tmpl_attr_ref_from_unspecified_substr
static fr_slen_t tmpl_attr_ref_from_unspecified_substr(tmpl_attr_t *ar, tmpl_attr_error_t *err, tmpl_t *vpt, fr_sbuff_t *name, tmpl_attr_rules_t const *at_rules)
Definition tmpl_tokenize.c:1574
attr_to_raw
static void attr_to_raw(tmpl_t *vpt, tmpl_attr_t *ref)
Definition tmpl_tokenize.c:4400
tmpl_init_printf
tmpl_t * tmpl_init_printf(tmpl_t *vpt, tmpl_type_t type, fr_token_t quote, char const *fmt,...)
Initialise a tmpl using a format string to create the name.
Definition tmpl_tokenize.c:845
tmpl_attr_insert
static void tmpl_attr_insert(tmpl_t *vpt, tmpl_attr_t *ar)
Insert an attribute reference into a tmpl.
Definition tmpl_tokenize.c:1300
tmpl_attr_ref_list_debug
void tmpl_attr_ref_list_debug(FILE *fp, FR_DLIST_HEAD(tmpl_attr_list) const *ar_head)
Definition tmpl_tokenize.c:256
tmpl_cast_set
int tmpl_cast_set(tmpl_t *vpt, fr_type_t dst_type)
Set a cast for a tmpl.
Definition tmpl_tokenize.c:3718
tmpl_afrom_ipv4_substr
static fr_slen_t tmpl_afrom_ipv4_substr(TALLOC_CTX *ctx, tmpl_t **out, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *p_rules)
Parse bareword as an IPv4 address or prefix.
Definition tmpl_tokenize.c:2624
tmpl_set_name
void tmpl_set_name(tmpl_t *vpt, fr_token_t quote, char const *name, ssize_t len)
Set the name on a pre-initialised tmpl.
Definition tmpl_tokenize.c:792
tmpl_attr_afrom_list
int tmpl_attr_afrom_list(TALLOC_CTX *ctx, tmpl_t **out, tmpl_t const *list, fr_dict_attr_t const *da)
Create a new tmpl from a list tmpl and a da.
Definition tmpl_tokenize.c:1236
tmpl_attr_to_raw
void tmpl_attr_to_raw(tmpl_t *vpt)
Convert the leaf attribute of a tmpl to a unknown/raw type.
Definition tmpl_tokenize.c:4433
tmpl_copy
tmpl_t * tmpl_copy(TALLOC_CTX *ctx, tmpl_t const *in)
Copy a tmpl.
Definition tmpl_tokenize.c:3580
tmpl_attr_rewrite_leaf_num
void tmpl_attr_rewrite_leaf_num(tmpl_t *vpt, int16_t to)
Rewrite the leaf's instance number.
Definition tmpl_tokenize.c:1184
tmpl_substr_terminal_check
static bool tmpl_substr_terminal_check(fr_sbuff_t *in, fr_sbuff_parse_rules_t const *p_rules)
Verify, after skipping whitespace, that a substring ends in a terminal char, or ends without further ...
Definition tmpl_tokenize.c:180
array_terminal
static const bool array_terminal[UINT8_MAX+1]
Definition tmpl_tokenize.c:5321
tmpl_request_ref_list_copy
static void tmpl_request_ref_list_copy(TALLOC_CTX *ctx, FR_DLIST_HEAD(tmpl_request_list) *out, FR_DLIST_HEAD(tmpl_request_list) const *in)
Allocate a new request reference and add it to the end of the attribute reference list.
Definition tmpl_tokenize.c:421
tmpl_attr_rules_debug
static void tmpl_attr_rules_debug(tmpl_attr_rules_t const *at_rules)
Definition tmpl_tokenize.c:5837
tmpl_preparse
ssize_t tmpl_preparse(char const **out, size_t *outlen, char const *in, size_t inlen, fr_token_t *type)
Preparse a string in preparation for passing it to tmpl_afrom_substr()
Definition tmpl_tokenize.c:5345
TMPL_REQUEST_REF_DEF
#define TMPL_REQUEST_REF_DEF(_name, _ref)
Define a global variable for specifying a default request reference.
Definition tmpl_tokenize.c:53
UNRESOLVED_SET
#define UNRESOLVED_SET(_flags)
Definition tmpl_tokenize.c:169
tmpl_set_name_shallow
void tmpl_set_name_shallow(tmpl_t *vpt, fr_token_t quote, char const *name, ssize_t len)
Set the name on a pre-initialised tmpl.
Definition tmpl_tokenize.c:775
tmpl_attr_afrom_attr_substr
static int tmpl_attr_afrom_attr_substr(TALLOC_CTX *ctx, tmpl_attr_error_t *err, tmpl_t *vpt, fr_dict_attr_t const *parent, fr_dict_attr_t const *namespace, fr_sbuff_t *name, fr_sbuff_parse_rules_t const *p_rules, tmpl_attr_rules_t const *at_rules, unsigned int depth)
Parse an attribute reference, either an OID or attribute name.
Definition tmpl_tokenize.c:1748
tmpl_afrom_ipv6_substr
static fr_slen_t tmpl_afrom_ipv6_substr(TALLOC_CTX *ctx, tmpl_t **out, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *p_rules)
Parse bareword as an IPv6 address or prefix.
Definition tmpl_tokenize.c:2697
tmpl_afrom_bool_substr
static fr_slen_t tmpl_afrom_bool_substr(TALLOC_CTX *ctx, tmpl_t **out, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *p_rules)
Parse a truth value.
Definition tmpl_tokenize.c:2527
tmpl_attr_add
static tmpl_attr_t * tmpl_attr_add(tmpl_t *vpt, tmpl_attr_type_t type)
Allocate a new attribute reference and add it to the end of the attribute reference list.
Definition tmpl_tokenize.c:963
attr_num_table_len
static size_t attr_num_table_len
Definition tmpl_tokenize.c:161
return_P
#define return_P(_x)
Definition tmpl_tokenize.c:5325
tmpl_debug
void tmpl_debug(FILE *fp, tmpl_t const *vpt)
Definition tmpl_tokenize.c:310
tmpl_afrom_attr_str
ssize_t tmpl_afrom_attr_str(TALLOC_CTX *ctx, tmpl_attr_error_t *err, tmpl_t **out, char const *name, tmpl_rules_t const *t_rules)
Parse a string into a TMPL_TYPE_ATTR_* type tmpl_t.
Definition tmpl_tokenize.c:2438
CHECK_T_RULES
#define CHECK_T_RULES
Definition tmpl_tokenize.c:101
tmpl_cast_from_substr
ssize_t tmpl_cast_from_substr(tmpl_rules_t *rules, fr_sbuff_t *in)
Parse a cast specifier.
Definition tmpl_tokenize.c:3672
tmpl_alloc_null
static tmpl_t * tmpl_alloc_null(TALLOC_CTX *ctx)
Create a new heap allocated tmpl_t.
Definition tmpl_tokenize.c:915
tmpl_request_ref_list_from_substr
static fr_slen_t tmpl_request_ref_list_from_substr(TALLOC_CTX *ctx, tmpl_attr_error_t *err, FR_DLIST_HEAD(tmpl_request_list) *out, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules, fr_dict_attr_t const **namespace)
Parse one or more request references, writing the list to out.
Definition tmpl_tokenize.c:522
tmpl_rules_debug
void tmpl_rules_debug(tmpl_rules_t const *rules)
Definition tmpl_tokenize.c:5852
tmpl_attr_copy
int tmpl_attr_copy(tmpl_t *dst, tmpl_t const *src)
Copy a list of attribute and request references from one tmpl to another.
Definition tmpl_tokenize.c:1028
tmpl_afrom_ether_substr
static ssize_t tmpl_afrom_ether_substr(TALLOC_CTX *ctx, tmpl_t **out, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *p_rules)
Try and parse signed or unsigned integers.
Definition tmpl_tokenize.c:2815
tmpl_afrom_float_substr
static ssize_t tmpl_afrom_float_substr(TALLOC_CTX *ctx, tmpl_t **out, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *p_rules)
Definition tmpl_tokenize.c:2958
tmpl_afrom_octets_substr
static fr_slen_t tmpl_afrom_octets_substr(TALLOC_CTX *ctx, tmpl_t **out, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *p_rules)
Parse bareword as an octet string.
Definition tmpl_tokenize.c:2565
tmpl_type_table_len
size_t tmpl_type_table_len
Definition tmpl_tokenize.c:131
tmpl_attr_resolve
static int tmpl_attr_resolve(tmpl_t *vpt, tmpl_res_rules_t const *tr_rules)
Resolve an unresolved attribute.
Definition tmpl_tokenize.c:4020
tmpl_afrom_enum
static ssize_t tmpl_afrom_enum(TALLOC_CTX *ctx, tmpl_t **out, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules)
Definition tmpl_tokenize.c:3031
tmpl_attr_set_leaf_da
int tmpl_attr_set_leaf_da(tmpl_t *vpt, fr_dict_attr_t const *da)
Replace the leaf attribute only.
Definition tmpl_tokenize.c:1117
tmpl_afrom_substr
fr_slen_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:3166
tmpl_cast_quote
static fr_token_t tmpl_cast_quote(fr_token_t existing_quote, fr_type_t type, fr_dict_attr_t const *enumv, char const *unescaped, size_t unescaped_len)
Determine the correct quoting after a cast.
Definition tmpl_tokenize.c:3867
tmpl_attr_unspec
fr_dict_attr_t const * tmpl_attr_unspec
Placeholder attribute for uses of unspecified attribute references.
Definition tmpl_eval.c:55
tmpl_afrom_value_substr
static fr_slen_t tmpl_afrom_value_substr(TALLOC_CTX *ctx, tmpl_t **out, fr_sbuff_t *in, fr_token_t quote, tmpl_rules_t const *t_rules, bool allow_enum, fr_sbuff_parse_rules_t const *p_rules)
Create TMPL_TYPE_DATA from a string.
Definition tmpl_tokenize.c:2477
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:4214
tmpl_set_dict_def
void tmpl_set_dict_def(tmpl_t *vpt, fr_dict_t const *dict)
Change the default dictionary in the tmpl's resolution rules.
Definition tmpl_tokenize.c:808
tmpl_init
tmpl_t * tmpl_init(tmpl_t *vpt, tmpl_type_t type, fr_token_t quote, char const *name, ssize_t len, tmpl_rules_t const *t_rules)
Initialise a tmpl using a literal string to create the name.
Definition tmpl_tokenize.c:897
tmpl_request_ref_list_acopy
static void tmpl_request_ref_list_acopy(TALLOC_CTX *ctx, FR_DLIST_HEAD(tmpl_request_list) **out, FR_DLIST_HEAD(tmpl_request_list) const *in)
Allocate a new request reference list and copy request references into it.
Definition tmpl_tokenize.c:444
tmpl_print
fr_slen_t tmpl_print(fr_sbuff_t *out, tmpl_t const *vpt, fr_sbuff_escape_rules_t const *e_rules)
Print a tmpl_t to a string.
Definition tmpl_tokenize.c:4842
tmpl_afrom_integer_substr
static fr_slen_t tmpl_afrom_integer_substr(TALLOC_CTX *ctx, tmpl_t **out, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *p_rules)
Try and parse signed or unsigned integers.
Definition tmpl_tokenize.c:2882
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:3905
tmpl_print_quoted
fr_slen_t tmpl_print_quoted(fr_sbuff_t *out, tmpl_t const *vpt)
Print a tmpl_t to a string with quotes.
Definition tmpl_tokenize.c:4917
tmpl_attr_ref_fixup
static void tmpl_attr_ref_fixup(TALLOC_CTX *ctx, tmpl_t *vpt, fr_dict_attr_t const *da, fr_dict_attr_t const *parent)
Definition tmpl_tokenize.c:1703
tmpl_attr_parse_filter
static fr_slen_t tmpl_attr_parse_filter(tmpl_attr_error_t *err, tmpl_attr_t *ar, fr_sbuff_t *name, tmpl_attr_rules_t const *at_rules)
Parse array subscript and in future other filters.
Definition tmpl_tokenize.c:1330
tmpl_attr_list_from_substr
fr_slen_t tmpl_attr_list_from_substr(fr_dict_attr_t const **da_p, fr_sbuff_t *in)
Parse one a single list reference.
Definition tmpl_tokenize.c:396
DEFAULT_RULES
#define DEFAULT_RULES
Default parser rules.
Definition tmpl_tokenize.c:99
tmpl_type_table
fr_table_num_ordered_t const tmpl_type_table[]
Map tmpl_type_t values to descriptive strings.
Definition tmpl_tokenize.c:111
attr_table_len
static size_t attr_table_len
Definition tmpl_tokenize.c:141
tmpl_attr_tail_unresolved_add
int tmpl_attr_tail_unresolved_add(fr_dict_t *dict_def, tmpl_t *vpt, fr_type_t type, fr_dict_attr_flags_t const *flags)
Add an unresolved fr_dict_attr_t specified by a tmpl_t to the main dictionary.
Definition tmpl_tokenize.c:4549
tmpl_request_ref_table_len
size_t tmpl_request_ref_table_len
Definition tmpl_tokenize.c:150
fr_token_quotes_table
fr_table_num_sorted_t const fr_token_quotes_table[]
Definition token.c:67
fr_token_quote
const char fr_token_quote[T_TOKEN_LAST]
Convert tokens back to a quoting character.
Definition token.c:157
fr_token_t
enum fr_token fr_token_t
T_INVALID
@ T_INVALID
Definition token.h:39
T_SINGLE_QUOTED_STRING
@ T_SINGLE_QUOTED_STRING
Definition token.h:122
T_BARE_WORD
@ T_BARE_WORD
Definition token.h:120
T_BACK_QUOTED_STRING
@ T_BACK_QUOTED_STRING
Definition token.h:123
T_DOUBLE_QUOTED_STRING
@ T_DOUBLE_QUOTED_STRING
Definition token.h:121
T_SOLIDUS_QUOTED_STRING
@ T_SOLIDUS_QUOTED_STRING
Definition token.h:124
T_TOKEN_LAST
#define T_TOKEN_LAST
Definition token.h:129
close
close(uq->fd)
xlat_needs_resolving
bool xlat_needs_resolving(xlat_exp_head_t const *head)
Check to see if the expansion needs resolving.
Definition xlat_tokenize.c:1902
xlat_is_literal
bool xlat_is_literal(xlat_exp_head_t const *head)
Check to see if the expansion consists entirely of value-box elements.
Definition xlat_tokenize.c:1886
xlat_tokenize_condition
fr_slen_t xlat_tokenize_condition(TALLOC_CTX *ctx, xlat_exp_head_t **head, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules))
Definition xlat_expr.c:3163
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
xlat_impure_func
bool xlat_impure_func(xlat_exp_head_t const *head)
Definition xlat_tokenize.c:2104
xlat_tokenize
fr_slen_t xlat_tokenize(TALLOC_CTX *ctx, xlat_exp_head_t **head, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules)
Tokenize an xlat expansion.
Definition xlat_tokenize.c:1848
head
static fr_slen_t head
Definition xlat.h:420
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_to_string
bool xlat_to_string(TALLOC_CTX *ctx, char **str, xlat_exp_head_t **head)
Convert an xlat node to an unescaped literal string and free the original node.
Definition xlat_tokenize.c:1918
xlat_copy
#define xlat_copy(_ctx, _out, _in)
Definition xlat.h:458
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_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_tokenize_argv
fr_slen_t xlat_tokenize_argv(TALLOC_CTX *ctx, xlat_exp_head_t **head, fr_sbuff_t *in, xlat_arg_parser_t const *xlat_args, fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules, bool spaces))
Tokenize an xlat expansion into a series of XLAT_TYPE_CHILD arguments.
Definition xlat_tokenize.c:1598
xlat_tokenize_expression
fr_slen_t xlat_tokenize_expression(TALLOC_CTX *ctx, xlat_exp_head_t **head, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules))
Definition xlat_expr.c:3135
xlat_res_rules_t
Definition xlat.h:164
parent
static fr_slen_t parent
Definition pair.h:841
fr_da_stack_t
Structure for holding the stack of dictionary attributes being encoded.
Definition proto.h:55
fr_strerror_clear
void fr_strerror_clear(void)
Clears all pending messages from the talloc pools.
Definition strerror.c:576
fr_strerror_printf
#define fr_strerror_printf(_fmt,...)
Log to thread local error buffer.
Definition strerror.h:64
fr_strerror_const_push
#define fr_strerror_const_push(_msg)
Definition strerror.h:227
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_cast
bool fr_type_cast(fr_type_t dst, fr_type_t src)
Return if we're allowed to cast the types.
Definition types.c:293
fr_type_numeric
bool const fr_type_numeric[FR_TYPE_MAX+1]
Definition types.c:183
fr_type_structural
bool const fr_type_structural[FR_TYPE_MAX+1]
Definition types.c:193
fr_type_is_non_leaf
#define fr_type_is_non_leaf(_x)
Definition types.h:392
fr_type_is_octets
#define fr_type_is_octets(_x)
Definition types.h:347
fr_type_is_structural
#define fr_type_is_structural(_x)
Definition types.h:390
fr_type_is_string
#define fr_type_is_string(_x)
Definition types.h:346
FR_TYPE_STRUCTURAL
#define FR_TYPE_STRUCTURAL
Definition types.h:314
fr_type_is_null
#define fr_type_is_null(_x)
Definition types.h:345
fr_type_is_leaf
#define fr_type_is_leaf(_x)
Definition types.h:391
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:452
FR_TYPE_LEAF
#define FR_TYPE_LEAF
Definition types.h:315
fr_value_box_print
ssize_t fr_value_box_print(fr_sbuff_t *out, fr_value_box_t const *data, fr_sbuff_escape_rules_t const *e_rules)
Print one boxed value to a string.
Definition value.c:5791
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:4156
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:3984
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:4917
fr_value_box_copy_shallow
void fr_value_box_copy_shallow(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_value_box_t const *src)
Perform a shallow copy of a value_box.
Definition value.c:4279
fr_value_box_from_str
ssize_t fr_value_box_from_str(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, char const *in, size_t inlen, fr_sbuff_unescape_rules_t const *erules)
Definition value.c:5754
fr_value_escape_by_quote
fr_sbuff_escape_rules_t * fr_value_escape_by_quote[T_TOKEN_LAST]
Definition value.c:447
fr_value_box_steal
int fr_value_box_steal(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_value_box_t *src)
Copy value data verbatim moving any buffers to the specified context.
Definition value.c:4308
fr_value_box_clear
void fr_value_box_clear(fr_value_box_t *data)
Clear/free any existing value and metadata.
Definition value.c:4139
fr_value_box_from_substr
ssize_t fr_value_box_from_substr(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *rules)
Convert string value to a fr_value_box_t type.
Definition value.c:5117
fr_value_box_memdup
int fr_value_box_memdup(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, uint8_t const *src, size_t len, bool tainted)
Copy a buffer to a fr_value_box_t.
Definition value.c:4837
fr_value_box_mark_safe_for
#define fr_value_box_mark_safe_for(_box, _safe_for)
Definition value.h:1074
fr_value_box_aprint
static fr_slen_t fr_value_box_aprint(TALLOC_CTX *ctx, char **out, fr_value_box_t const *data, fr_sbuff_escape_rules_t const *e_rules) 1(fr_value_box_print
data
static fr_slen_t data
Definition value.h:1291
fr_box_strvalue_len
#define fr_box_strvalue_len(_val, _len)
Definition value.h:308
inlen
static size_t char fr_sbuff_t size_t inlen
Definition value.h:1023
vb_strvalue
#define vb_strvalue
Definition value.h:259
nonnull
int nonnull(2, 5))
fr_value_box_init
#define fr_value_box_init(_vb, _type, _enumv, _tainted)
Initialise a fr_value_box_t.
Definition value.h:609
out
static size_t char ** out
Definition value.h:1023
xlat_exp_head_alloc
#define xlat_exp_head_alloc(_ctx)
Definition xlat_priv.h:273
XLAT_TMPL
@ XLAT_TMPL
xlat attribute
Definition xlat_priv.h:112
xlat_exp_s::type
xlat_type_t _CONST type
type of this expansion.
Definition xlat_priv.h:155
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
Generated by   doxygen 1.9.8