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