The FreeRADIUS server $Id: 15bac2a4c627c01d1aa2047687b3418955ac7f00 $
Loading...
Searching...
No Matches
dict_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/** Parse dictionary files
18 *
19 * @file src/lib/util/dict_tokenize.c
20 *
21 * @copyright 2019 The FreeRADIUS server project
22 * @copyright 2024 Arran Cudbard-Bell (a.cudbardb@freeradius.org)
23 */
24RCSID("$Id: 1bbd8569face2c918e6bd4d9948298c9cde4e55d $")
25
26#include <freeradius-devel/radius/defs.h>
27#include <freeradius-devel/util/conf.h>
28#include <freeradius-devel/util/dict_fixup_priv.h>
29#include <freeradius-devel/util/file.h>
30#include <freeradius-devel/util/rand.h>
31#include <freeradius-devel/util/syserror.h>
32
33#include <sys/stat.h>
34
35/** Maximum number of arguments
36 *
37 * For any one keyword, this is the maxiumum number of arguments that can be passed.
38 */
39#define DICT_MAX_ARGV (8)
40
41/** Maximum stack size
42 *
43 * This is the maximum number of nested BEGIN and $INCLUDE statements.
44 */
45#define DICT_MAX_STACK (32)
46
47/** This represents explicit BEGIN/END frames pushed onto the stack
48 *
49 * These are flags to allow multiple nesting types to be passed to the search function.
50 */
51DIAG_OFF(attributes)
52typedef enum CC_HINT(flag_enum) {
53 NEST_NONE = 0x00,
54 NEST_TOP = 0x01, //!< top of the stack
55 NEST_PROTOCOL = 0x02, //!< BEGIN-PROTOCOL
56 NEST_VENDOR = 0x04, //!< BEGIN-VENDOR
57 NEST_ATTRIBUTE = 0x08 //!< BEGIN foo
58} dict_nest_t;
59DIAG_ON(attributes)
60
61#define NEST_ANY (NEST_TOP | NEST_PROTOCOL | NEST_VENDOR | NEST_ATTRIBUTE)
62
63static fr_table_num_sorted_t const dict_nest_table[] = {
64 { L("ATTRIBUTE"), NEST_ATTRIBUTE },
65 { L("NONE"), NEST_NONE },
66 { L("PROTOCOL"), NEST_PROTOCOL },
67 { L("TOP"), NEST_TOP },
68 { L("VENDOR"), NEST_VENDOR }
69};
70static size_t const dict_nest_table_len = NUM_ELEMENTS(dict_nest_table);
71
72typedef int (*fr_dict_keyword_finalise_t)(dict_tokenize_ctx_t *dctx);
73
74/** Parser context for dict_from_file
75 *
76 * Allows vendor and TLV context to persist across $INCLUDEs
77 */
78typedef struct {
79 char *filename; //!< name of the file where we read this entry
80 int line; //!< line number where we read this entry
81 fr_dict_attr_t const *da; //!< the da we care about
82 dict_nest_t nest; //!< for manual vs automatic begin / end things
83
84 fr_dict_keyword_finalise_t finalise; //!< function to call when popping
85 int member_num; //!< structure member numbers
86 fr_dict_attr_t const *struct_is_closed; //!< no more members are allowed
87 ssize_t struct_size; //!< size of the struct.
88} dict_tokenize_frame_t;
89
90struct dict_tokenize_ctx_s {
91 fr_dict_t *dict; //!< Protocol dictionary we're inserting attributes into.
92
93 dict_tokenize_frame_t stack[DICT_MAX_STACK]; //!< stack of attributes to track
94 int stack_depth; //!< points to the last used stack frame
95
96 fr_dict_attr_t *value_attr; //!< Cache of last attribute to speed up value processing.
97 fr_dict_attr_t const *relative_attr; //!< for ".82" instead of "1.2.3.82". only for parents of type "tlv"
98 dict_fixup_ctx_t fixup;
99
100 char *filename; //!< current filename
101 int line; //!< current line
102};
103
104static int _dict_from_file(dict_tokenize_ctx_t *dctx,
105 char const *dir_name, char const *filename,
106 char const *src_file, int src_line);
107
108#define CURRENT_FRAME(_dctx) (&(_dctx)->stack[(_dctx)->stack_depth])
109#define CURRENT_DA(_dctx) (CURRENT_FRAME(_dctx)->da)
110#define CURRENT_FILENAME(_dctx) (CURRENT_FRAME(_dctx)->filename)
111#define CURRENT_LINE(_dctx) (CURRENT_FRAME(_dctx)->line)
112
113#define ASSERT_CURRENT_NEST(_dctx, _nest) fr_assert_msg(CURRENT_FRAME(_dctx)->nest == (_nest), "Expected frame type %s, got %s", \
114 fr_table_str_by_value(dict_nest_table, (_nest), "<INVALID>"), fr_table_str_by_value(dict_nest_table, CURRENT_FRAME(_dctx)->nest, "<INVALID>"))
115
116void dict_dctx_debug(dict_tokenize_ctx_t *dctx)
117{
118 int i;
119
120 for (i = 0; i <= dctx->stack_depth; i++) {
121 dict_tokenize_frame_t const *frame = &dctx->stack[i];
122
123 FR_FAULT_LOG("[%d]: %s %s (%s): %s[%d]",
124 i,
125 fr_table_str_by_value(dict_nest_table, frame->nest, "<INVALID>"),
126 frame->da->name,
127 fr_type_to_str(frame->da->type),
128 frame->filename, frame->line);
129 }
130}
131
132static dict_tokenize_frame_t const *dict_dctx_find_frame(dict_tokenize_ctx_t *dctx, dict_nest_t nest)
133{
134 int i;
135
136 for (i = dctx->stack_depth; i >= 0; i--) {
137 if (dctx->stack[i].nest & nest) return &dctx->stack[i];
138 }
139
140 return NULL;
141}
142
143static int CC_HINT(nonnull) dict_dctx_push(dict_tokenize_ctx_t *dctx, fr_dict_attr_t const *da, dict_nest_t nest)
144{
145 if ((dctx->stack_depth + 1) >= DICT_MAX_STACK) {
146 fr_strerror_const("Attribute definitions are nested too deep.");
147 return -1;
148 }
149
150 dctx->stack[++dctx->stack_depth] = (dict_tokenize_frame_t) {
151 .da = da,
152 .filename = dctx->filename,
153 .line = dctx->line,
154 .nest = nest,
155 };
156
157 return 0;
158}
159
160
161/** Pop the current stack frame
162 *
163 * @param[in] dctx Stack to pop from.
164 * @return
165 * - Pointer to the current stack frame.
166 * - NULL, if we're already at the root.
167 */
168static dict_tokenize_frame_t const *dict_dctx_pop(dict_tokenize_ctx_t *dctx)
169{
170 if (dctx->stack_depth == 0) return NULL;
171
172 fr_assert(!dctx->stack[dctx->stack_depth].finalise);
173
174 return &dctx->stack[dctx->stack_depth--];
175}
176
177/** Unwind the stack until it points to a particular type of stack frame
178 *
179 * @param[in] dctx Stack to unwind.
180 * @param[in] nest Frame type to unwind to.
181 * @return
182 * - Pointer to the frame matching nest
183 * - NULL, if we unwound the complete stack and didn't find the frame.
184 */
185static dict_tokenize_frame_t const *dict_dctx_unwind_until(dict_tokenize_ctx_t *dctx, dict_nest_t nest)
186{
187 int i;
188
189 for (i = dctx->stack_depth; i >= 0; i--) {
190 dict_tokenize_frame_t *frame;
191
192 /*
193 * We mash the stack depth here, because the finalisation function needs it. Plus, if
194 * there's any error, we don't care about the dctx stack, we just return up the C stack.
195 */
196 dctx->stack_depth = i;
197 frame = CURRENT_FRAME(dctx);
198
199 if (frame->finalise) {
200 if (frame->finalise(dctx) < 0) return NULL;
201 frame->finalise = NULL;
202 }
203
204 /*
205 * END-foo cannot be used without BEGIN-foo.
206 */
207 if (frame->filename && (frame->filename != dctx->filename) &&
208 (nest != NEST_ANY)) {
209 char const *name;
210
211 name = fr_table_str_by_value(dict_nest_table, nest, "<INVALID>");
212 fr_strerror_printf("END-%s in file %s[%d] without matching BEGIN-%s",
213 name, dctx->filename, dctx->line, name);
214 return NULL;
215 }
216
217 if ((frame->nest & nest) != 0) {
218 return frame;
219 }
220 }
221
222 return NULL;
223}
224
225static inline dict_tokenize_frame_t const *dict_dctx_unwind(dict_tokenize_ctx_t *dctx)
226{
227 return dict_dctx_unwind_until(dctx, NEST_ANY);
228}
229
230/*
231 * String split routine. Splits an input string IN PLACE
232 * into pieces, based on spaces.
233 */
234int fr_dict_str_to_argv(char *str, char **argv, int max_argc)
235{
236 int argc = 0;
237
238 while (*str) {
239 if (argc >= max_argc) break;
240
241 /*
242 * Chop out comments early.
243 */
244 if (*str == '#') {
245 *str = '\0';
246 break;
247 }
248
249 while ((*str == ' ') ||
250 (*str == '\t') ||
251 (*str == '\r') ||
252 (*str == '\n'))
253 *(str++) = '\0';
254
255 if (!*str) break;
256
257 argv[argc] = str;
258 argc++;
259
260 while (*str &&
261 (*str != ' ') &&
262 (*str != '\t') &&
263 (*str != '\r') &&
264 (*str != '\n'))
265 str++;
266 }
267
268 return argc;
269}
270
271static bool dict_read_sscanf_i(unsigned int *pvalue, char const *str)
272{
273 int unsigned ret = 0;
274 int base = 10;
275 char const *tab = "0123456789";
276
277 if ((str[0] == '0') &&
278 ((str[1] == 'x') || (str[1] == 'X'))) {
279 tab = "0123456789abcdef";
280 base = 16;
281
282 str += 2;
283 }
284
285 while (*str) {
286 char const *c;
287
288 if (*str == '.') break;
289
290 c = memchr(tab, tolower((uint8_t)*str), base);
291 if (!c) return false;
292
293 if (ret >= (UINT_MAX / base)) return false;
294
295 ret *= base;
296 ret += (c - tab);
297 str++;
298 }
299
300 *pvalue = ret;
301 return true;
302}
303
304/** Set a new root dictionary attribute
305 *
306 * @note Must only be called once per dictionary.
307 *
308 * @param[in] dict to modify.
309 * @param[in] name of dictionary root.
310 * @param[in] proto_number The artificial (or IANA allocated) number for the protocol.
311 * This is only used for
312 * @return
313 * - 0 on success.
314 * - -1 on failure.
315 */
316static int dict_root_set(fr_dict_t *dict, char const *name, unsigned int proto_number)
317{
318 fr_dict_attr_t *da;
319
320 fr_dict_attr_flags_t flags = {
321 .is_root = 1,
322 .type_size = dict->proto->default_type_size,
323 .length = dict->proto->default_type_length,
324 };
325
326 if (!fr_cond_assert(!dict->root)) {
327 fr_strerror_const("Dictionary root already set");
328 return -1;
329 }
330
331 da = dict_attr_alloc_root(dict->pool, dict, name, proto_number, &(dict_attr_args_t){ .flags = &flags });
332 if (unlikely(!da)) return -1;
333
334 dict->root = da;
335 dict->root->dict = dict;
336 DA_VERIFY(dict->root);
337
338 return 0;
339}
340
341static int dict_process_type_field(dict_tokenize_ctx_t *dctx, char const *name, fr_dict_attr_t **da_p)
342{
343 char *p;
344 fr_type_t type;
345
346 /*
347 * Some types can have fixed length
348 */
349 p = strchr(name, '[');
350 if (p) {
351 char *q;
352 unsigned int length;
353
354 *p = '\0';
355 q = strchr(p + 1, ']');
356 if (!q) {
357 fr_strerror_printf("Invalid format for '%s[...]'", name);
358 return -1;
359 }
360
361 *q = '\0';
362 if (q[1]) {
363 fr_strerror_const("length, if present, must end type field");
364 return -1;
365 }
366
367 if (!dict_read_sscanf_i(&length, p + 1)) {
368 fr_strerror_printf("Invalid length for '%s[...]'", name);
369 return -1;
370 }
371
372 /*
373 * "length" has to fit into the flags.length field.
374 */
375 if ((length == 0) || (length > UINT16_MAX)) {
376 fr_strerror_printf("Invalid length for '%s[...]'", name);
377 return -1;
378 }
379
380 /*
381 * Now that we have a length, check the data type.
382 */
383 if (strcmp(name, "octets") == 0) {
384 type = FR_TYPE_OCTETS;
385
386 } else if (strcmp(name, "string") == 0) {
387 type = FR_TYPE_STRING;
388
389 } else if (strcmp(name, "struct") == 0) {
390 type = FR_TYPE_STRUCT;
391
392 } else if (strcmp(name, "union") == 0) {
393 type = FR_TYPE_UNION;
394
395 } else if (strcmp(name, "bit") == 0) {
396 if (CURRENT_FRAME(dctx)->da->type != FR_TYPE_STRUCT) {
397 fr_strerror_const("Bit fields can only be defined as a MEMBER of data type 'struct'");
398 return -1;
399 }
400
401 (*da_p)->flags.extra = 1;
402 (*da_p)->flags.subtype = FLAG_BIT_FIELD;
403
404 if (length == 1) {
405 type = FR_TYPE_BOOL;
406 } else if (length <= 8) {
407 type = FR_TYPE_UINT8;
408 } else if (length <= 16) {
409 type = FR_TYPE_UINT16;
410 } else if (length <= 32) {
411 type = FR_TYPE_UINT32;
412 } else if (length <= 56) { /* for laziness in encode / decode */
413 type = FR_TYPE_UINT64;
414 } else {
415 fr_strerror_const("Invalid length for bit field");
416 return -1;
417 }
418
419 /*
420 * Cache where on a byte boundary this
421 * bit field ends. We could have the
422 * validation function loop through all
423 * previous siblings, but that's
424 * annoying.
425 */
426 (*da_p)->flags.flag_byte_offset = length;
427
428 } else {
429 fr_strerror_printf("Attributes of type '%s' cannot use the %s[...] syntax",
430 name, name);
431 return -1;
432 }
433
434 (*da_p)->flags.is_known_width = true;
435 (*da_p)->flags.length = length;
436 return dict_attr_type_init(da_p, type);
437 }
438
439 /*
440 * We default to using the standard FreeRADIUS types.
441 *
442 * However, if there is a protocol-specific type parsing
443 * function, we call that, too. That ordering allows the
444 * protocol-specific names to over-ride the default ones.
445 */
446 type = fr_type_from_str(name);
447
448 if (dctx->dict->proto->attr.type_parse &&
449 !dctx->dict->proto->attr.type_parse(&type, da_p, name)) {
450 return -1;
451 }
452
453 switch (type) {
454 /*
455 * Still not known, or is still a NULL type, that's an error.
456 *
457 * The protocol-specific function can return an error if
458 * it has an error in its parsing. Or, it can return
459 * "true"
460 */
461 case FR_TYPE_NULL:
462 fr_strerror_printf("Unknown data type '%s'", name);
463 return -1;
464
465 case FR_TYPE_LEAF:
466 case FR_TYPE_TLV:
467 case FR_TYPE_STRUCT:
468 case FR_TYPE_VSA:
469 case FR_TYPE_GROUP:
470 case FR_TYPE_UNION:
471 break;
472
473 /*
474 * @todo - allow definitions of type 'vendor' only if we need to have different
475 * type_size/length for VSAs or "evs" in the Extended-Attribute space.
476 */
477 case FR_TYPE_VENDOR:
478 fr_strerror_const("Cannot use data type 'vendor' - use BEGIN-VENDOR instead");
479 return -1;
480
481 default:
482 fr_strerror_printf("Invalid data type '%s'", name);
483 return -1;
484 }
485
486 return dict_attr_type_init(da_p, type);
487}
488
489/** Define a flag setting function, which sets one bit in a fr_dict_attr_flags_t
490 *
491 * This is here, because AFAIK there's no completely portable way to get the bit
492 * offset of a bit field in a structure.
493 */
494#define FLAG_FUNC(_name) \
495static int dict_flag_##_name(fr_dict_attr_t **da_p, UNUSED char const *value, UNUSED fr_dict_flag_parser_rule_t const *rules)\
496{ \
497 (*da_p)->flags._name = 1; \
498 return 0; \
499}
500
501FLAG_FUNC(array)
502
503static int dict_flag_clone(fr_dict_attr_t **da_p, char const *value, UNUSED fr_dict_flag_parser_rule_t const *rules)
504{
505 /*
506 * Clone has a limited scope.
507 */
508 switch ((*da_p)->type) {
509 case FR_TYPE_LEAF:
510 case FR_TYPE_STRUCT:
511 case FR_TYPE_TLV:
512 break;
513
514 default:
515 fr_strerror_printf("Attributes of data type '%s' cannot use 'clone=...'", fr_type_to_str((*da_p)->type));
516 return -1;
517 }
518
519 /*
520 * Allow cloning of any types, so long as
521 * the types are the same. We do the checks later.
522 */
523 if (unlikely(dict_attr_ref_aunresolved(da_p, value, FR_DICT_ATTR_REF_CLONE) < 0)) return -1;
524
525 /*
526 * We don't know how big the cloned reference is, so it isn't known width.
527 */
528 (*da_p)->flags.is_known_width = 0;
529
530 return 0;
531}
532
533FLAG_FUNC(counter)
534
535static int dict_flag_enum(fr_dict_attr_t **da_p, char const *value, UNUSED fr_dict_flag_parser_rule_t const *rule)
536{
537 /*
538 * Allow enum=... as an almost synonym for "clone", where we copy only the VALUEs, and not any
539 * children.
540 */
541 if (!fr_type_is_leaf((*da_p)->type)) {
542 fr_strerror_const("'enum=...' references cannot be used for structural types");
543 return -1;
544 }
545
546 /*
547 * Ensure that this attribute has room for enums.
548 */
549 if (!dict_attr_ext_alloc(da_p, FR_DICT_ATTR_EXT_ENUMV)) return -1;
550
551 if (unlikely(dict_attr_ref_aunresolved(da_p, value, FR_DICT_ATTR_REF_ENUM) < 0)) return -1;
552
553 return 0;
554}
555
556/** "flat"
557 *
558 * We have to parse the flat flag for tests, but only the various
559 * protocol libraries can set it for protocol-specific attributes.
560 */
561static int dict_flag_flat(fr_dict_attr_t **da_p, UNUSED char const *value, UNUSED fr_dict_flag_parser_rule_t const *rule)
562{
563 if ((*da_p)->type != FR_TYPE_GROUP) {
564 fr_strerror_const("'flat' flag can only be used for data type 'group'");
565 return -1;
566 }
567
568 if (!(*da_p)->flags.internal) {
569 fr_strerror_const("'flat' flag can only be used for 'internal' attributes");
570 return -1;
571 }
572
573 (*da_p)->flags.allow_flat = true;
574
575 return 0;
576}
577
578FLAG_FUNC(internal)
579
580static int dict_flag_key(fr_dict_attr_t **da_p, char const *value, UNUSED fr_dict_flag_parser_rule_t const *rule)
581{
582 fr_dict_attr_t *da = *da_p;
583 fr_dict_attr_t const *key;
584 fr_dict_attr_ext_ref_t *ext;
585
586 if (fr_type_is_leaf(da->type)) {
587 if (value) {
588 fr_strerror_const("Attributes defining a 'key' field cannot specify a key reference");
589 return -1;
590 }
591
592 if ((da->type != FR_TYPE_UINT8) && (da->type != FR_TYPE_UINT16) && (da->type != FR_TYPE_UINT32)) {
593 fr_strerror_const("The 'key' flag can only be used for attributes of type 'uint8', 'uint16', or 'uint32'");
594 return -1;
595 }
596
597 if (da->flags.extra) {
598 fr_strerror_const("Bit fields cannot be key fields");
599 return -1;
600 }
601
602 da->flags.extra = 1;
603 da->flags.subtype = FLAG_KEY_FIELD;
604 return 0;
605 }
606
607 if (da->type != FR_TYPE_UNION) {
608 fr_strerror_printf("Attributes of type '%s' cannot define a 'key' reference", fr_type_to_str(da->type));
609 return -1;
610 }
611
612 if (!value) {
613 fr_strerror_const("Missing reference for 'key=...'");
614 return -1;
615 }
616
617 /*
618 * The reference must be to a sibling, which is marked "is key".
619 */
620 key = fr_dict_attr_by_name(NULL, da->parent, value);
621 if (!key) {
622 fr_strerror_printf("Invalid reference for 'key=...'. Parent %s does not have a child attribute named %s",
623 da->parent->name, value);
624 return -1;
625 }
626
627 if (da->parent != key->parent) {
628 fr_strerror_printf("Invalid reference for 'key=...'. Reference %s does not share a common parent",
629 value);
630 return -1;
631 }
632
633 if (!fr_dict_attr_is_key_field(key)) {
634 fr_strerror_printf("Invalid reference for 'key=...'. Reference %s is not a 'key' field",
635 value);
636 return -1;
637 }
638
639 /*
640 * Allocate the ref and save the value. This link exists solely so that the children of the
641 * UNION can easily find the key field of the parent STRUCT.
642 */
643 ext = fr_dict_attr_ext(da, FR_DICT_ATTR_EXT_KEY);
644 if (ext) {
645 fr_strerror_printf("Attribute already has a 'key=...' defined");
646 return -1;
647 }
648
649 ext = dict_attr_ext_alloc(da_p, FR_DICT_ATTR_EXT_KEY); /* can change da_p */
650 if (unlikely(!ext)) return -1;
651
652 ext->type = FR_DICT_ATTR_REF_KEY;
653 ext->ref = key;
654
655 return 0;
656}
657
658static int dict_flag_length(fr_dict_attr_t **da_p, char const *value, UNUSED fr_dict_flag_parser_rule_t const *rule)
659{
660 fr_dict_attr_t *da = *da_p;
661
662 if (strcmp(value, "uint8") == 0) {
663 da->flags.is_known_width = true;
664 da->flags.extra = 1;
665 da->flags.subtype = FLAG_LENGTH_UINT8;
666
667 } else if (strcmp(value, "uint16") == 0) {
668 da->flags.is_known_width = true;
669 da->flags.extra = 1;
670 da->flags.subtype = FLAG_LENGTH_UINT16;
671
672 } else {
673 fr_strerror_const("Invalid value given for the 'length' flag");
674 return -1;
675 }
676 da->flags.type_size = 0;
677
678 return 0;
679}
680
681static int dict_flag_offset(fr_dict_attr_t **da_p, char const *value, UNUSED fr_dict_flag_parser_rule_t const *rule)
682{
683 fr_dict_attr_t *da = *da_p;
684 int offset;
685
686 if (da->type != FR_TYPE_STRUCT) {
687 fr_strerror_const("The 'offset' flag can only be used with data type 'struct'");
688 return -1;
689 }
690
691 if (!da_is_length_field(da)) {
692 fr_strerror_const("The 'offset' flag can only be used in combination with 'length=uint8' or 'length=uint16'");
693 return -1;
694 }
695
696 offset = atoi(value);
697 if ((offset <= 0) || (offset > 255)) {
698 fr_strerror_const("The 'offset' value must be between 1..255");
699 return -1;
700 }
701 da->flags.type_size = offset;
702
703 return 0;
704}
705
706static int dict_flag_precision(fr_dict_attr_t **da_p, char const *value, UNUSED fr_dict_flag_parser_rule_t const *rule)
707{
708 fr_dict_attr_t *da = *da_p;
709 int precision;
710
711 switch (da->type) {
712 case FR_TYPE_DATE:
713 case FR_TYPE_TIME_DELTA:
714 break;
715
716 default:
717 fr_strerror_const("The 'precision' flag can only be used with data types 'date' or 'time'");
718 return -1;
719 }
720
721 precision = fr_table_value_by_str(fr_time_precision_table, value, -1);
722 if (precision < 0) {
723 fr_strerror_printf("Unknown %s precision '%s'", fr_type_to_str(da->type), value);
724 return -1;
725 }
726 da->flags.flag_time_res = precision;
727
728 return 0;
729}
730
731static int dict_flag_ref(fr_dict_attr_t **da_p, char const *value, UNUSED fr_dict_flag_parser_rule_t const *rule)
732{
733 fr_dict_attr_t *da = *da_p;
734
735 if (da->flags.extra) {
736 fr_strerror_const("Cannot use 'ref' with other flags");
737 return -1;
738 }
739
740 if (da->type != FR_TYPE_GROUP) {
741 fr_strerror_printf("The 'ref' flag cannot be used for type '%s'",
742 fr_type_to_str(da->type));
743 return -1;
744 }
745
746 if (unlikely(dict_attr_ref_aunresolved(da_p, value, FR_DICT_ATTR_REF_ALIAS) < 0)) return -1;
747
748 return 0;
749}
750
751static int dict_flag_secret(fr_dict_attr_t **da_p, UNUSED char const *value, UNUSED fr_dict_flag_parser_rule_t const *rule)
752{
753 fr_dict_attr_t *da = *da_p;
754
755 da->flags.secret = 1;
756
757 if ((da->type != FR_TYPE_STRING) && (da->type != FR_TYPE_OCTETS)) {
758 fr_strerror_const("The 'secret' flag can only be used with data types 'string' or 'octets'");
759 return -1;
760 }
761
762 return 0;
763}
764
765static int dict_flag_subtype(fr_dict_attr_t **da_p, char const *value, UNUSED fr_dict_flag_parser_rule_t const *rule)
766{
767 fr_dict_attr_t *da = *da_p;
768 fr_type_t subtype;
769
770 switch (da->type) {
771 case FR_TYPE_DATE:
772 case FR_TYPE_TIME_DELTA:
773 break;
774
775 default:
776 fr_strerror_const("The 'subtype' flag can only be used with data types 'date' or 'time'");
777 return -1;
778 }
779
780 subtype = fr_type_from_str(value);
781 if (fr_type_is_null(subtype)) {
782 unknown_type:
783 fr_strerror_printf("Unknown or unsupported %s type '%s'",
784 fr_type_to_str(subtype),
785 value);
786 return -1;
787 }
788
789 switch (subtype) {
790 default:
791 goto unknown_type;
792
793 case FR_TYPE_INT16:
794 if (da->type == FR_TYPE_DATE) goto unknown_type;
795 da->flags.length = 2;
796 break;
797
798 case FR_TYPE_UINT16:
799 da->flags.is_unsigned = true;
800 da->flags.length = 2;
801 break;
802
803 case FR_TYPE_INT32:
804 if (da->type == FR_TYPE_DATE) goto unknown_type;
805 da->flags.length = 4;
806 break;
807
808 case FR_TYPE_UINT32:
809 da->flags.is_unsigned = true;
810 da->flags.length = 4;
811 break;
812
813 case FR_TYPE_INT64:
814 if (da->type == FR_TYPE_DATE) goto unknown_type;
815 da->flags.length = 8;
816 break;
817
818 case FR_TYPE_UINT64:
819 da->flags.is_unsigned = true;
820 da->flags.length = 8;
821 break;
822 }
823
824 return 0;
825}
826
827FLAG_FUNC(unsafe)
828
829/** A lookup function for dictionary attribute flags
830 *
831 */
832static TABLE_TYPE_NAME_FUNC_RPTR(table_sorted_value_by_str, fr_dict_flag_parser_t const *,
833 fr_dict_attr_flag_to_parser, fr_dict_flag_parser_rule_t const *, fr_dict_flag_parser_rule_t const *)
834
835static int CC_HINT(nonnull) dict_process_flag_field(dict_tokenize_ctx_t *dctx, char *name, fr_dict_attr_t **da_p)
836{
837 static fr_dict_flag_parser_t dict_common_flags[] = {
838 { L("array"), { .func = dict_flag_array } },
839 { L("clone"), { .func = dict_flag_clone, .needs_value = true } },
840 { L("counter"), { .func = dict_flag_counter } },
841 { L("enum"), { .func = dict_flag_enum, .needs_value = true } },
842 { L("flat"), { .func = dict_flag_flat } },
843 { L("internal"), { .func = dict_flag_internal } },
844 { L("key"), { .func = dict_flag_key } },
845 { L("length"), { .func = dict_flag_length, .needs_value = true } },
846 { L("offset"), { .func = dict_flag_offset, .needs_value = true } },
847 { L("precision"), { .func = dict_flag_precision, .needs_value = true } },
848 { L("ref"), { .func = dict_flag_ref, .needs_value = true } },
849 { L("secret"), { .func = dict_flag_secret } },
850 { L("subtype"), { .func = dict_flag_subtype, .needs_value = true } },
851 { L("unsafe"), { .func = dict_flag_unsafe } },
852 };
853 static size_t dict_common_flags_len = NUM_ELEMENTS(dict_common_flags);
854
855 char *p, *next = NULL;
856
857 if ((*da_p)->type == FR_TYPE_NULL) {
858 fr_strerror_const("Type must be specified before parsing flags");
859 return -1;
860 }
861
862 for (p = name; p && *p != '\0' ; p = next) {
863 char *key, *value;
864 fr_dict_flag_parser_rule_t const *parser;
865
866 key = p;
867
868 /*
869 * Search for the first '=' or ','
870 */
871 for (next = p + 1; *next && (*next != '=') && (*next != ','); next++) {
872 /* do nothing */
873 }
874
875 /*
876 * We have a value, zero out the '=' and point to the value.
877 */
878 if (*next == '=') {
879 *(next++) = '\0';
880 value = next;
881
882 if (!*value || (*value == ',')) {
883 fr_strerror_printf("Missing value after '%s='", key);
884 return -1;
885 }
886 } else {
887 value = NULL;
888 }
889
890 /*
891 * Skip any trailing text in the value.
892 */
893 for (/* nothing */; *next; next++) {
894 if (*next == ',') {
895 *(next++) = '\0';
896 break;
897 }
898 }
899
900 /*
901 * Search the protocol table, then the main table.
902 * This allows protocols to overload common flags.
903 */
904 if (!((dctx->dict->proto->attr.flags.table &&
905 fr_dict_attr_flag_to_parser(&parser, dctx->dict->proto->attr.flags.table,
906 dctx->dict->proto->attr.flags.table_len, key, NULL)) ||
907 fr_dict_attr_flag_to_parser(&parser, dict_common_flags, dict_common_flags_len, key, NULL))) {
908 fr_strerror_printf("Unknown flag '%s'", key);
909 return -1;
910 }
911
912 if (parser->needs_value && !value) {
913 fr_strerror_printf("Flag '%s' requires a value", key);
914 return -1;
915 }
916
917 if (unlikely(parser->func(da_p, value, parser) < 0)) return -1;
918 }
919
920 /*
921 * Don't check the flags field for validity via
922 * dict_attr_flags_valid(). It may be updated by various
923 * protocol-specific callback functions. And,
924 * fr_dict_attr_add() calls dict_attr_flags_valid() anyways.
925 */
926
927 return 0;
928}
929
930static int dict_finalise(dict_tokenize_ctx_t *dctx)
931{
932 if (dict_fixup_apply(&dctx->fixup) < 0) return -1;
933
934 dctx->value_attr = NULL;
935 dctx->relative_attr = NULL;
936
937 return 0;
938}
939
940static inline CC_HINT(always_inline)
941void dict_attr_location_set(dict_tokenize_ctx_t *dctx, fr_dict_attr_t *da)
942{
943 da->filename = CURRENT_FILENAME(dctx);
944 da->line = CURRENT_LINE(dctx);
945}
946
947/** Add an attribute to the dictionary, or add it to a list of attributes to clone later
948 *
949 * @param[in] fixup context to add an entry to (if needed).
950 * @param[in] da_p to either add, or create a fixup for.
951 * @return
952 * - 0 on success, and an attribute was added.
953 * - 1 on success, and a deferred entry was added.
954 * - -1 on failure.
955 */
956static int dict_attr_add_or_fixup(dict_fixup_ctx_t *fixup, fr_dict_attr_t **da_p)
957{
958 fr_dict_attr_ext_ref_t *ref;
959 fr_dict_attr_t *da = *da_p;
960 int ret = 0;
961
962 /*
963 * Check for any references associated with the attribute,
964 * if they're unresolved, then add fixups.
965 *
966 * We do this now, as we know the attribute memory chunk
967 * is stable, and we can safely add the fixups.
968 */
969 ref = fr_dict_attr_ext(*da_p, FR_DICT_ATTR_EXT_REF);
970 if (ref && fr_dict_attr_ref_is_unresolved(ref->type)) {
971 /*
972 * See if we can immediately apply the ref.
973 */
974 fr_dict_attr_t const *src;
975
976 switch (fr_dict_attr_ref_type(ref->type)) {
977 case FR_DICT_ATTR_REF_ALIAS:
978 /*
979 * IF the ref exists, we can always add it. The ref won't be changed later.
980 */
981 if (fr_dict_protocol_reference(&src, da->parent, &FR_SBUFF_IN_STR(ref->unresolved)) < 0) return -1;
982
983 if (src && (dict_attr_ref_set(*da_p, src, FR_DICT_ATTR_REF_ALIAS) < 0)) return -1;
984
985 if (fr_dict_attr_add_initialised(da) < 0) {
986 error:
987 talloc_free(da);
988 *da_p = NULL;
989 return -1;
990 }
991
992 if (!src && (dict_fixup_group_enqueue(fixup, da, ref->unresolved) < 0)) return -1;
993 ret = 1;
994 break;
995
996 case FR_DICT_ATTR_REF_ENUM:
997 /*
998 * Do NOT copy the enums now. Later dictionaries may add more values, and we
999 * want to be able to copy all values.
1000 */
1001 if (fr_dict_attr_add_initialised(da) < 0) goto error;
1002
1003 if (dict_fixup_clone_enum_enqueue(fixup, da, ref->unresolved) < 0) return -1;
1004 break;
1005
1006 case FR_DICT_ATTR_REF_CLONE:
1007 /*
1008 * @todo - if we defer this clone, we get errors loading dictionary.wimax. That
1009 * likely means there are issues with the dict_fixup_clone_apply() function.
1010 */
1011 if (fr_dict_protocol_reference(&src, da->parent, &FR_SBUFF_IN_STR(ref->unresolved)) < 0) return -1;
1012 if (src) {
1013 if (dict_fixup_clone(da_p, src) < 0) return -1;
1014 break;
1015 }
1016
1017 if (dict_fixup_clone_enqueue(fixup, da, ref->unresolved) < 0) return -1;
1018 ret = 1;
1019 break;
1020
1021 default:
1022 fr_strerror_const("Unknown reference type");
1023 return -1;
1024 }
1025 } else {
1026 if (fr_dict_attr_add_initialised(da) < 0) goto error;
1027 }
1028
1029 return ret;
1030}
1031
1032/** Check if this definition is a duplicate, and if it is, whether we should skip it error out
1033 *
1034 * @return
1035 * - 1 if this is not a duplicate.
1036 * - 0 if this is a duplicate, and we should ignore the definition.
1037 * - -1 if this is a duplicate, and we should error out.
1038 */
1039static int dict_attr_allow_dup(fr_dict_attr_t const *da)
1040{
1041 fr_dict_attr_t const *dup_name = NULL;
1042 fr_dict_attr_t const *dup_num = NULL;
1043 fr_dict_attr_t const *found;
1044
1045 /*
1046 * Search in the parent for a duplicate by name and then by num
1047 */
1048 if (!da->parent) return 1; /* no parent no conflicts possible */
1049
1050 dup_name = fr_dict_attr_by_name(NULL, da->parent, da->name);
1051 if (da->flags.name_only) dup_num = fr_dict_attr_child_by_num(da->parent, da->attr);
1052
1053 /*
1054 * Not a duplicate...
1055 */
1056 if (!dup_name && !dup_num) return 1;
1057
1058 found = dup_name ? dup_name : dup_num;
1059
1060 switch (da->type) {
1061 /*
1062 * For certain types, we allow strict duplicates as if
1063 * the user wants to add extra children in the custom
1064 * dictionary, or wants to avoid ordering issues between
1065 * multiple dictionaries, we need to support this.
1066 */
1067 case FR_TYPE_VSA:
1068 case FR_TYPE_VENDOR:
1069 case FR_TYPE_TLV:
1070 if (fr_dict_attr_cmp_fields(da, found) == 0) return 0;
1071 break;
1072
1073 case FR_TYPE_LEAF:
1074 /*
1075 * Leaf types can be duplicated if they are identical.
1076 */
1077 if ((da->type == found->type) &&
1078 (fr_dict_attr_cmp_fields(da, found) == 0)) return 0;
1079 break;
1080
1081 default:
1082 break;
1083 }
1084
1085 if (dup_name) {
1086 fr_strerror_printf("Duplicate attribute name '%s' in namespace '%s'. Originally defined %s[%d]",
1087 da->name, da->parent->name, dup_name->filename, dup_name->line);
1088 return -1;
1089 }
1090
1091 fr_strerror_printf("Duplicate attribute number %u in parent '%s'. Originally defined %s[%d]",
1092 da->attr, da->parent->name, dup_num->filename, dup_num->line);
1093 return -1;
1094}
1095
1096static int dict_struct_finalise(dict_tokenize_ctx_t *dctx)
1097{
1098 fr_dict_attr_t const *da;
1099 dict_tokenize_frame_t const *frame = CURRENT_FRAME(dctx);
1100
1101 da = frame->da;
1102 fr_assert(da->type == FR_TYPE_STRUCT);
1103
1104 /*
1105 * The structure was fixed-size, but the fields don't fill it. That's an error.
1106 *
1107 * Since process_member() checks for overflow, the check here is really only for
1108 * underflow.
1109 */
1110 if (da->flags.is_known_width) {
1111 if (CURRENT_FRAME(dctx)->struct_size != da->flags.length) {
1112 fr_strerror_printf("MEMBERs of %s struct[%u] do not exactly fill the fixed-size structure",
1113 da->name, da->flags.length);
1114 return -1;
1115 }
1116
1117 return 0;
1118 }
1119
1120 /*
1121 * If we have discovered that the structure has a fixed size, then update the da with that
1122 * information.
1123 */
1124 if (frame->struct_size < UINT16_MAX) {
1125 UNCONST(fr_dict_attr_t *, da)->flags.length = frame->struct_size;
1126 } /* else length 0 means "unknown / variable size / too large */
1127
1128 return 0;
1129}
1130
1131static int dict_set_value_attr(dict_tokenize_ctx_t *dctx, fr_dict_attr_t *da)
1132{
1133 /*
1134 * Adding an attribute of type 'struct' is an implicit
1135 * BEGIN-STRUCT.
1136 */
1137 if (da->type == FR_TYPE_STRUCT) {
1138 if (dict_dctx_push(dctx, da, NEST_NONE) < 0) return -1;
1139
1140 CURRENT_FRAME(dctx)->finalise = dict_struct_finalise;
1141 dctx->value_attr = NULL;
1142
1143 } else if (fr_type_is_leaf(da->type)) {
1144 dctx->value_attr = da;
1145
1146 } else {
1147 dctx->value_attr = NULL;
1148 }
1149
1150 return 0;
1151}
1152
1153static int dict_read_process_common(dict_tokenize_ctx_t *dctx, fr_dict_attr_t **da_p,
1154 fr_dict_attr_t const *parent, char const *name,
1155 char const *type_name, char *flag_name,
1156 fr_dict_attr_flags_t const *base_flags)
1157{
1158 fr_dict_attr_t *da, *to_free = NULL;
1159 size_t len;
1160
1161 /*
1162 * Dictionaries need to have real names, not v3-style ones "Attr-#". And not ones which are
1163 * solely numerical.
1164 */
1165 if (strncmp(name, "Attr-", 5) == 0) {
1166 fr_strerror_const("Invalid name - 'Attr-' is an invalid name");
1167 return -1;
1168 }
1169
1170 len = strlen(name);
1171 if (fr_sbuff_adv_past_allowed( &FR_SBUFF_IN(name, len), SIZE_MAX, sbuff_char_class_int, NULL) == len) {
1172 fr_strerror_printf("Invalid attribute name '%s' - the name cannot be an integer", name);
1173 return -1;
1174 }
1175
1176 /*
1177 * Allocate the attribute here, and then fill in the fields
1178 * as we start parsing the various elements of the definition.
1179 */
1180 if (!*da_p) {
1181 da = dict_attr_alloc_null(dctx->dict->pool, dctx->dict->proto);
1182 if (unlikely(!da)) return -1;
1183 to_free = da;
1184
1185 } else {
1186 da = *da_p;
1187 }
1188 dict_attr_location_set(dctx, da);
1189 da->dict = dctx->dict;
1190
1191 /*
1192 * Set some fields to be friendlier to the type / flag
1193 * parsing and validation routines.
1194 */
1195 da->parent = parent;
1196 da->name = name;
1197
1198 /*
1199 * Set the attribute flags from the base flags.
1200 */
1201 memcpy(&da->flags, base_flags, sizeof(da->flags));
1202
1203 if (unlikely(strcmp(type_name, "auto") == 0)) {
1204 fr_dict_attr_t const *src;
1205 char const *p, *end;
1206
1207 if (!flag_name || !(p = strstr(flag_name, "clone="))) {
1208 fr_strerror_const("Data type of 'auto' is missing the required flag 'clone=...'");
1209 goto error;
1210 }
1211
1212 p += 6;
1213 for (end = p; *end != '\0'; end++) {
1214 if (*end == ',') break;
1215 }
1216
1217 if (fr_dict_protocol_reference(&src, parent, &FR_SBUFF_IN(p, end)) < 0) goto error;
1218 if (!src) {
1219 fr_strerror_const("Data type 'auto' requires that the 'clone=...' reference points to an attribute which already exists");
1220 goto error;
1221 }
1222
1223 /*
1224 * Don't copy the source yet, as later things may add enums, children, etc. to the source
1225 * attribute. Instead, we just copy the data type.
1226 */
1227 if (dict_attr_type_init(&da, src->type) < 0) goto error;
1228
1229 } else {
1230 /*
1231 * Set the base type of the attribute.
1232 */
1233 if (dict_process_type_field(dctx, type_name, &da) < 0) {
1234 error:
1235 if (da == to_free) talloc_free(to_free);
1236 return -1;
1237 }
1238 }
1239
1240 /*
1241 * Clear the temporary parent pointer.
1242 */
1243 da->parent = NULL;
1244 if (unlikely(dict_attr_parent_init(&da, parent) < 0)) goto error;
1245
1246 /*
1247 * Parse optional flags. We pass in the partially allocated
1248 * attribute so that flags can be set directly.
1249 *
1250 * Where flags contain variable length fields, this is
1251 * significantly easier than populating a temporary struct.
1252 */
1253 if (flag_name) if (dict_process_flag_field(dctx, flag_name, &da) < 0) goto error;
1254
1255 da->name = NULL; /* the real name will be a talloc'd chunk */
1256
1257 *da_p = da;
1258 return 0;
1259}
1260
1261/*
1262 * Process the $INCLUDE command
1263 */
1264static int dict_read_process_include(dict_tokenize_ctx_t *dctx, char **argv, int argc, char const *dir)
1265{
1266 int rcode;
1267 bool required = true;
1268 int stack_depth = dctx->stack_depth;
1269 char *src_file = dctx->filename;
1270 int src_line = dctx->line;
1271 char *pattern;
1272 char const *filename;
1273 fr_globdir_iter_t iter;
1274
1275 /*
1276 * Allow "$INCLUDE" or "$INCLUDE-", but
1277 * not anything else.
1278 */
1279 if ((argv[0][8] != '\0') && ((argv[0][8] != '-') || (argv[0][9] != '\0'))) {
1280 fr_strerror_printf("Invalid keyword '%s'", argv[0]);
1281 return -1;
1282 }
1283
1284 if (argc != 2) {
1285 fr_strerror_printf("Unexpected text after $INCLUDE at %s[%d]", fr_cwd_strip(src_file), src_line);
1286 return -1;
1287 }
1288
1289 pattern = argv[1];
1290 required = (argv[0][8] != '-');
1291
1292 /*
1293 * Allow limited macro capability, so people don't have
1294 * to remember where the root dictionaries are located.
1295 */
1296 if (strncmp(pattern, "${dictdir}/", 11) == 0) {
1297 dir = fr_dict_global_ctx_dir();
1298 pattern += 11;
1299 }
1300
1301 /*
1302 * Figure out what we need to open, and put the result into "filename".
1303 */
1304 rcode = fr_globdir_iter_init(&filename, dir, pattern, &iter);
1305 if (rcode < 0) {
1306 failed:
1307 fr_strerror_printf("Failed opening $INCLUDE of %s/%s at %s[%d] - %s",
1308 dir, pattern, fr_cwd_strip(src_file), src_line, fr_syserror(errno));
1309 return -1;
1310 }
1311
1312 /*
1313 * No files may or may not be an error, depending on if the $INCLUDE was required.
1314 */
1315 if (rcode == 0) {
1316 if (required) {
1317 errno = ENOENT;
1318 goto failed;
1319 }
1320
1321 fr_strerror_clear(); /* delete all errors */
1322 return 0;
1323 }
1324
1325 /*
1326 * "filename" is already the file, so we use do{}while() instead of while{}
1327 */
1328 do {
1329 rcode = _dict_from_file(dctx, dir, filename, src_file, src_line);
1330 if (rcode < 0) {
1331 fr_strerror_printf_push("from $INCLUDE at %s[%d]", fr_cwd_strip(src_file), src_line);
1332 break;
1333 }
1334
1335 if (dctx->stack_depth < stack_depth) {
1336 fr_strerror_printf("unexpected END-??? in $INCLUDE at %s[%d]",
1337 fr_cwd_strip(src_file), src_line);
1338 rcode = -1;
1339 break;
1340 }
1341
1342 } while ((rcode = fr_globdir_iter_next(&filename, &iter)) == 1);
1343 (void) fr_globdir_iter_free(&iter);
1344
1345 /*
1346 * Reset the filename and line number.
1347 */
1348 dctx->filename = src_file;
1349 dctx->line = src_line;
1350 return rcode; /* could be an error! */
1351}
1352
1353static int dict_read_parse_format(char const *format, int *ptype, int *plength, bool *pcontinuation)
1354{
1355 char const *p;
1356 int type, length;
1357 bool continuation = false;
1358
1359 if (strncasecmp(format, "format=", 7) != 0) {
1360 fr_strerror_printf("Invalid format for VENDOR. Expected 'format=', got '%s'",
1361 format);
1362 return -1;
1363 }
1364
1365 p = format + 7;
1366 if ((strlen(p) < 3) ||
1367 !isdigit((uint8_t)p[0]) ||
1368 (p[1] != ',') ||
1369 !isdigit((uint8_t)p[2]) ||
1370 (p[3] && (p[3] != ','))) {
1371 fr_strerror_printf("Invalid format for VENDOR. Expected text like '1,1', got '%s'",
1372 p);
1373 return -1;
1374 }
1375
1376 type = (int)(p[0] - '0');
1377 length = (int)(p[2] - '0');
1378
1379 if ((type != 1) && (type != 2) && (type != 4)) {
1380 fr_strerror_printf("Invalid type value %d for VENDOR", type);
1381 return -1;
1382 }
1383
1384 if ((length != 0) && (length != 1) && (length != 2)) {
1385 fr_strerror_printf("Invalid length value %d for VENDOR", length);
1386 return -1;
1387 }
1388
1389 if (p[3] == ',') {
1390 if (!p[4]) {
1391 fr_strerror_printf("Invalid format for VENDOR. Expected text like '1,1', got '%s'",
1392 p);
1393 return -1;
1394 }
1395
1396 if ((p[4] != 'c') ||
1397 (p[5] != '\0')) {
1398 fr_strerror_printf("Invalid format for VENDOR. Expected text like '1,1', got '%s'",
1399 p);
1400 return -1;
1401 }
1402 continuation = true;
1403
1404 if ((type != 1) || (length != 1)) {
1405 fr_strerror_const("Only VSAs with 'format=1,1' can have continuations");
1406 return -1;
1407 }
1408 }
1409
1410 *ptype = type;
1411 *plength = length;
1412 *pcontinuation = continuation;
1413 return 0;
1414}
1415
1416/*
1417 * Process the ALIAS command
1418 *
1419 * ALIAS name ref
1420 *
1421 * Creates an attribute "name" in the root namespace of the current
1422 * dictionary, which is a pointer to "ref".
1423 */
1424static int dict_read_process_alias(dict_tokenize_ctx_t *dctx, char **argv, int argc, UNUSED fr_dict_attr_flags_t *base_flags)
1425{
1426 fr_dict_attr_t const *da;
1427 fr_dict_attr_t const *parent = CURRENT_FRAME(dctx)->da;
1428
1429 if (argc != 2) {
1430 fr_strerror_const("Invalid ALIAS syntax");
1431 return -1;
1432 }
1433
1434 /*
1435 * Dictionaries need to have real names, not shitty ones.
1436 */
1437 if (strncmp(argv[0], "Attr-", 5) == 0) {
1438 fr_strerror_const("Invalid ALIAS name");
1439 return -1;
1440 }
1441
1442 if (strchr(argv[0], '.') != NULL) {
1443 fr_strerror_const("ALIAS names must be in the local context, and cannot contain '.'");
1444 return -1;
1445 }
1446
1447 /*
1448 * Internally we can add aliases to STRUCTs and GROUPs. But the poor user can't.
1449 *
1450 * This limitation is mainly so that we can differentiate automatically added aliases (which
1451 * point to unions), from ones added by users. If we make dict_attr_acopy_aliases() a little
1452 * smarter, then we can relax those checks.
1453 */
1454 switch (parent->type) {
1455 case FR_TYPE_TLV:
1456 case FR_TYPE_VSA:
1457 case FR_TYPE_VENDOR:
1458 break;
1459
1460 default:
1461 fr_strerror_printf("ALIAS cannot be added to data type '%s'", fr_type_to_str(parent->type));
1462 return -1;
1463 }
1464
1465 /*
1466 * Relative refs get resolved from the current namespace.
1467 */
1468 if (argv[1][0] == '@') {
1469 fr_strerror_const("An ALIAS reference cannot cross protocol boundaries");
1470 return -1;
1471
1472 } else if (argv[1][0] == '.') {
1473 if (argv[1][1] == '.') goto no_up;
1474
1475 } else if (parent != dctx->dict->root) {
1476 no_up:
1477 fr_strerror_const("An ALIAS reference cannot go back up the tree");
1478 return -1;
1479 }
1480
1481 /*
1482 * The <ref> can be a name.
1483 */
1484 da = fr_dict_attr_by_oid(NULL, parent, argv[1]);
1485 if (!da) {
1486 /*
1487 * If we can't find it now, the file containing the ALIASes may have been read before
1488 * the ALIASed attributes.
1489 *
1490 * @todo - we likely just want to forbid this.
1491 */
1492 return dict_fixup_alias_enqueue(&dctx->fixup, CURRENT_FILENAME(dctx), CURRENT_LINE(dctx),
1493 fr_dict_attr_unconst(parent), argv[0],
1494 fr_dict_attr_unconst(parent), argv[1]);
1495 }
1496
1497 return dict_attr_alias_add(fr_dict_attr_unconst(parent), argv[0], da, true);
1498}
1499
1500/*
1501 * Process the ATTRIBUTE command
1502 */
1503static int dict_read_process_attribute(dict_tokenize_ctx_t *dctx, char **argv, int argc, fr_dict_attr_flags_t *base_flags)
1504{
1505 bool set_relative_attr;
1506
1507 ssize_t slen;
1508 unsigned int attr;
1509
1510 fr_dict_attr_t const *parent, *key = NULL;
1511 fr_dict_attr_t *da;
1512 fr_value_box_t box;
1513
1514 if ((argc < 3) || (argc > 4)) {
1515 fr_strerror_const("Invalid ATTRIBUTE syntax");
1516 return -1;
1517 }
1518
1519#ifdef STATIC_ANALYZER
1520 if (!dctx->dict) return -1;
1521#endif
1522
1523 /*
1524 * A non-relative ATTRIBUTE definition means that it is
1525 * in the context of the previous BEGIN-FOO. So we
1526 * unwind the stack to match.
1527 */
1528 if (argv[1][0] != '.') {
1529 dict_tokenize_frame_t const *frame;
1530
1531 frame = dict_dctx_unwind(dctx);
1532 if (!frame) return -1;
1533
1534 parent = frame->da;
1535
1536 /*
1537 * Allow '0xff00' as attribute numbers, but only
1538 * if there is no OID component.
1539 */
1540 if (strchr(argv[1], '.') == 0) {
1541 if (!dict_read_sscanf_i(&attr, argv[1])) {
1542 fr_strerror_const("Invalid ATTRIBUTE number");
1543 return -1;
1544 }
1545
1546 } else {
1547 slen = fr_dict_attr_by_oid_legacy(&parent, &attr, argv[1]);
1548 if (slen <= 0) return -1;
1549 }
1550
1551 /*
1552 * We allow relative attributes only for TLVs.
1553 *
1554 * We haven't parsed the type field yet, so we
1555 * just check it here manually.
1556 */
1557 set_relative_attr = (strcasecmp(argv[2], "tlv") == 0);
1558
1559 } else {
1560 if (!dctx->relative_attr) {
1561 fr_strerror_printf("No parent attribute reference was set for partial OID %s", argv[1]);
1562 return -1;
1563 }
1564
1565 parent = dctx->relative_attr;
1566
1567 slen = fr_dict_attr_by_oid_legacy(&parent, &attr, argv[1]);
1568 if (slen <= 0) return -1;
1569
1570 set_relative_attr = false;
1571 }
1572
1573 if (!fr_cond_assert(parent)) return -1; /* Should have provided us with a parent */
1574
1575 /*
1576 * Members of a 'struct' MUST use MEMBER, not ATTRIBUTE.
1577 */
1578 if (parent->type == FR_TYPE_STRUCT) {
1579 fr_strerror_printf("Member %s of ATTRIBUTE %s type 'struct' MUST use the \"MEMBER\" keyword",
1580 argv[0], parent->name);
1581 return -1;
1582 }
1583
1584 /*
1585 * A UNION can have child ATTRIBUTEs
1586 */
1587 if (parent->type == FR_TYPE_UNION) {
1588 fr_dict_attr_ext_ref_t *ext;
1589
1590 /*
1591 * The parent is a union. Get and verify the key ref.
1592 */
1593 ext = fr_dict_attr_ext(parent, FR_DICT_ATTR_EXT_KEY);
1594 fr_assert(ext != NULL);
1595
1596 /*
1597 * Double-check names against the reference.
1598 */
1599 key = ext->ref;
1600 fr_assert(key);
1601 fr_assert(fr_dict_attr_is_key_field(key));
1602 }
1603
1604 da = dict_attr_alloc_null(dctx->dict->pool, dctx->dict->proto);
1605 if (unlikely(!da)) return -1;
1606
1607 /*
1608 * Record the attribute number BEFORE we parse the type and flags.
1609 *
1610 * This is needed for the DER dictionaries, and 'option'.
1611 *
1612 * It can also be useful for other protocols, which may
1613 * have restrictions on the various fields. It is
1614 * therefore useful to have all fields initialized before
1615 * the type/flag validation routines are called.
1616 */
1617 if (unlikely(dict_attr_num_init(da, attr) < 0)) {
1618 error:
1619 talloc_free(da);
1620 return -1;
1621 }
1622
1623 /*
1624 * Check the attribute number against the allowed values.
1625 */
1626 if (key) {
1627 fr_value_box_init(&box, FR_TYPE_UINT32, NULL, false);
1628 box.vb_uint32 = attr;
1629
1630 if (fr_value_box_cast_in_place(da, &box, key->type, NULL) < 0) {
1631 fr_strerror_printf_push("Invalid attribute number as key field %s has data type %s",
1632 key->name, fr_type_to_str(key->type));
1633 goto error;
1634 }
1635 }
1636
1637 if (dict_read_process_common(dctx, &da, parent, argv[0], argv[2],
1638 (argc > 3) ? argv[3] : NULL, base_flags) < 0) {
1639 goto error;
1640 }
1641
1642 if (da_is_bit_field(da)) {
1643 fr_strerror_const("Bit fields can only be defined as a MEMBER of data type 'struct'");
1644 goto error;
1645 }
1646
1647 /*
1648 * Unions need a key field. And key fields can only appear inside of a struct.
1649 */
1650 if (da->type == FR_TYPE_UNION) {
1651 fr_strerror_const("ATTRIBUTEs of type 'union' can only be defined as a MEMBER of data type 'struct'");
1652 goto error;
1653 }
1654
1655 /*
1656 * Cross-check fixed lengths.
1657 */
1658 if (key && (parent->flags.is_known_width)) {
1659 if (!da->flags.is_known_width) {
1660 da->flags.is_known_width = 1;
1661 da->flags.length = parent->flags.length;
1662
1663 } else if (da->flags.length != parent->flags.length) {
1664 fr_strerror_printf("Invalid length %u for struct, the parent union %s has a different length %u",
1665 da->flags.length, parent->name, parent->flags.length);
1666 goto error;
1667 }
1668 }
1669
1670#ifdef WITH_DICTIONARY_WARNINGS
1671 /*
1672 * Hack to help us discover which vendors have illegal
1673 * attributes.
1674 */
1675 if (!vendor && (attr < 256) &&
1676 !strstr(fn, "rfc") && !strstr(fn, "illegal")) {
1677 fprintf(stderr, "WARNING: Illegal attribute %s in %s\n",
1678 argv[0], fn);
1679 }
1680#endif
1681
1682 /*
1683 * Set the attribute name
1684 */
1685 if (unlikely(dict_attr_finalise(&da, argv[0]) < 0)) {
1686 goto error;
1687 }
1688
1689 /*
1690 * Check to see if this is a duplicate attribute
1691 * and whether we should ignore it or error out...
1692 */
1693 switch (dict_attr_allow_dup(da)) {
1694 case 1:
1695 break;
1696
1697 case 0:
1698 talloc_free(da);
1699 return 0;
1700
1701 default:
1702 goto error;
1703 }
1704
1705 /*
1706 * Add the attribute we allocated earlier
1707 */
1708 switch (dict_attr_add_or_fixup(&dctx->fixup, &da)) {
1709 default:
1710 goto error;
1711
1712 /* New attribute, fixup stack */
1713 case 0:
1714 /*
1715 * Dynamically define where VSAs go. Note that we CANNOT
1716 * define VSAs until we define an attribute of type VSA!
1717 */
1718 if (da->type == FR_TYPE_VSA) {
1719 if (parent->flags.is_root) dctx->dict->vsa_parent = attr;
1720
1721 if (dict_fixup_vsa_enqueue(&dctx->fixup, da) < 0) {
1722 return -1; /* Leaves attr added */
1723 }
1724 }
1725
1726 /*
1727 * Add the VALUE to the key attribute, and ensure that
1728 * the VALUE also contains a pointer to the child struct.
1729 */
1730 if (key && (dict_attr_enum_add_name(fr_dict_attr_unconst(key), da->name, &box, false, true, da) < 0)) {
1731 return -1; /* Leaves attr added */
1732 }
1733
1734 /*
1735 * Adding an attribute of type 'struct' is an implicit
1736 * BEGIN-STRUCT.
1737 */
1738 if (da->type == FR_TYPE_STRUCT) {
1739 if (dict_dctx_push(dctx, da, NEST_NONE) < 0) return -1;
1740
1741 CURRENT_FRAME(dctx)->finalise = dict_struct_finalise;
1742 dctx->value_attr = NULL;
1743 } else {
1744 dctx->value_attr = da;
1745 }
1746
1747 if (set_relative_attr) dctx->relative_attr = da;
1748 break;
1749
1750 /* Deferred attribute, don't begin the TLV section automatically */
1751 case 1:
1752 break;
1753 }
1754
1755 /*
1756 * While UNIONs are named, it's nicer to hide them.
1757 * Therefore we automatically add an ALIAS in the unions
1758 * parent, for the child in the union.
1759 */
1760 if (parent->type == FR_TYPE_UNION) {
1761 fr_assert(parent->parent);
1762
1763 if (dict_attr_alias_add(parent->parent, da->name, da, false) < 0) {
1764 return -1; /* Leaves attr added */
1765 }
1766 }
1767
1768 return 0;
1769}
1770
1771static int dict_read_process_begin(dict_tokenize_ctx_t *dctx, char **argv, int argc, UNUSED fr_dict_attr_flags_t *base_flags)
1772{
1773 dict_tokenize_frame_t const *frame;
1774 fr_dict_attr_t const *da;
1775 fr_dict_attr_t const *common;
1776
1777 dctx->value_attr = NULL;
1778 dctx->relative_attr = NULL;
1779
1780 if (argc != 1) {
1781 fr_strerror_const("Invalid BEGIN keyword. Expected BEGIN <name>");
1782 return -1;
1783 }
1784
1785 frame = dict_dctx_find_frame(dctx, NEST_TOP | NEST_PROTOCOL | NEST_ATTRIBUTE);
1786 if (!fr_cond_assert_msg(frame, "Context stack doesn't have an attribute or dictionary "
1787 "root to begin searching from %s[%d]", CURRENT_FILENAME(dctx), CURRENT_LINE(dctx)) ||
1788 !fr_cond_assert_msg(fr_type_is_structural(frame->da->type), "Context attribute is not structural %s[%d]",
1789 CURRENT_FILENAME(dctx), CURRENT_LINE(dctx))) {
1790 return -1;
1791 }
1792
1793 /*
1794 * Not really a reference as we don't support any of the
1795 * fancy syntaxes like refs do. A straight OID string
1796 * resolved from the current level of nesting is all we support.
1797 */
1798 da = fr_dict_attr_by_oid(NULL, frame->da, argv[0]);
1799 if (!da) {
1800 fr_strerror_printf("BEGIN %s is not resolvable in current context '%s'", argv[0], frame->da->name);
1801 return -1;
1802 }
1803
1804 /*
1805 * We cannot use BEGIN/END on structs. Once they're defined, they can't be modified.
1806 *
1807 * This restriction can be lifted once we don't auto-push on FR_TYPE_STRUCT.
1808 */
1809 if (!fr_type_is_tlv(da->type) && (da->type != FR_TYPE_UNION)) {
1810 fr_strerror_printf("BEGIN %s cannot be used with data type '%s'",
1811 argv[0],
1812 fr_type_to_str(da->type));
1813 return -1;
1814 }
1815
1816 common = fr_dict_attr_common_parent(frame->da, da, true);
1817 if (!common) {
1818 fr_strerror_printf("BEGIN %s should be a child of '%s'",
1819 argv[0], CURRENT_FRAME(dctx)->da->name);
1820 return -1;
1821 }
1822
1823 return dict_dctx_push(dctx, da, NEST_ATTRIBUTE);
1824}
1825
1826static int dict_read_process_begin_protocol(dict_tokenize_ctx_t *dctx, char **argv, int argc,
1827 UNUSED fr_dict_attr_flags_t *base_flags)
1828{
1829 fr_dict_t *found;
1830 dict_tokenize_frame_t const *frame;
1831
1832 dctx->value_attr = NULL;
1833 dctx->relative_attr = NULL;
1834
1835 if (argc != 1) {
1836 fr_strerror_const("Invalid BEGIN-PROTOCOL entry");
1837 return -1;
1838 }
1839
1840 /*
1841 * If we're not parsing in the context of the internal
1842 * dictionary, then we don't allow BEGIN-PROTOCOL
1843 * statements.
1844 */
1845 if (dctx->dict != dict_gctx->internal) {
1846 fr_strerror_const("Nested BEGIN-PROTOCOL statements are not allowed");
1847 return -1;
1848 }
1849
1850 found = dict_by_protocol_name(argv[0]);
1851 if (!found) {
1852 fr_strerror_printf("Unknown protocol '%s'", argv[0]);
1853 return -1;
1854 }
1855
1856 frame = dict_dctx_find_frame(dctx, NEST_PROTOCOL | NEST_VENDOR | NEST_ATTRIBUTE);
1857 if (frame) {
1858 fr_strerror_printf("BEGIN-PROTOCOL cannot be used inside of any other BEGIN/END block. Previous definition is at %s[%d]",
1859 frame->filename, frame->line);
1860 return -1;
1861 }
1862
1863 /*
1864 * Add a temporary fixup pool
1865 */
1866 if (dict_fixup_init(&dctx->fixup) < 0) return -1;
1867
1868 /*
1869 * We're in the middle of loading this dictionary. Tell
1870 * fr_dict_protocol_afrom_file() to suppress recursive references.
1871 */
1872 found->loading = true;
1873
1874 dctx->dict = found;
1875
1876 return dict_dctx_push(dctx, dctx->dict->root, NEST_PROTOCOL);
1877}
1878
1879static int dict_read_process_begin_vendor(dict_tokenize_ctx_t *dctx, char **argv, int argc,
1880 UNUSED fr_dict_attr_flags_t *base_flags)
1881{
1882 fr_dict_vendor_t const *vendor;
1883
1884 fr_dict_attr_t const *vsa_da;
1885 fr_dict_attr_t const *vendor_da;
1886 fr_dict_attr_t *new;
1887 dict_tokenize_frame_t const *frame;
1888 char *p;
1889
1890 dctx->value_attr = NULL;
1891 dctx->relative_attr = NULL;
1892
1893 if (argc < 1) {
1894 fr_strerror_const("Invalid BEGIN-VENDOR entry");
1895 return -1;
1896 }
1897
1898 vendor = fr_dict_vendor_by_name(dctx->dict, argv[0]);
1899 if (!vendor) {
1900 fr_strerror_printf("Unknown vendor '%s'", argv[0]);
1901 return -1;
1902 }
1903
1904 /*
1905 * Check for extended attr VSAs
1906 *
1907 * BEGIN-VENDOR foo parent=Foo-Encapsulation-Attr
1908 */
1909 if (argc > 1) {
1910 fr_dict_attr_t const *da;
1911
1912 if (strncmp(argv[1], "parent=", 7) != 0) {
1913 fr_strerror_const("BEGIN-VENDOR invalid argument - expected 'parent='");
1914 return -1;
1915 }
1916
1917 p = argv[1] + 7;
1918 da = fr_dict_attr_by_oid(NULL, CURRENT_FRAME(dctx)->da, p);
1919 if (!da) {
1920 fr_strerror_printf("BEGIN-VENDOR Failed to find attribute '%s'", p);
1921 return -1;
1922 }
1923
1924 if (da->type != FR_TYPE_VSA) {
1925 fr_strerror_printf("Invalid parent for BEGIN-VENDOR. "
1926 "Attribute '%s' should be 'vsa' but is '%s'", p,
1927 fr_type_to_str(da->type));
1928 return -1;
1929 }
1930
1931 vsa_da = da;
1932
1933 } else if (dctx->dict->vsa_parent) {
1934 /*
1935 * Check that the protocol-specific VSA parent exists.
1936 */
1937 vsa_da = dict_attr_child_by_num(CURRENT_FRAME(dctx)->da, dctx->dict->vsa_parent);
1938 if (!vsa_da) {
1939 fr_strerror_printf("Failed finding VSA parent for Vendor %s",
1940 vendor->name);
1941 return -1;
1942 }
1943
1944 } else if (dctx->dict->string_based) {
1945 vsa_da = dctx->dict->root;
1946
1947 } else {
1948 fr_strerror_printf("BEGIN-VENDOR is forbidden for protocol %s - it has no ATTRIBUTE of type 'vsa'",
1949 dctx->dict->root->name);
1950 return -1;
1951 }
1952
1953 frame = dict_dctx_find_frame(dctx, NEST_VENDOR);
1954 if (frame) {
1955 fr_strerror_printf("Nested BEGIN-VENDOR is forbidden. Previous definition is at %s[%d]",
1956 frame->filename, frame->line);
1957 return -1;
1958 }
1959
1960 /*
1961 * Check if the VENDOR attribute exists under this VSA. If not, create one.
1962 *
1963 * @todo - There are no vendor fixups, so if the vendor has unusual type sizes, it MUST be
1964 * defined before the BEGIN-VENDOR is used.
1965 */
1966 vendor_da = dict_attr_child_by_num(vsa_da, vendor->pen);
1967 if (!vendor_da) {
1968 fr_dict_attr_flags_t flags = {};
1969
1970 new = dict_attr_alloc(dctx->dict->pool,
1971 vsa_da, argv[0], vendor->pen, FR_TYPE_VENDOR,
1972 &(dict_attr_args_t){ .flags = &flags });
1973 if (unlikely(!new)) return -1;
1974
1975 if (dict_attr_child_add(UNCONST(fr_dict_attr_t *, vsa_da), new) < 0) {
1976 talloc_free(new);
1977 return -1;
1978 }
1979
1980 if (dict_attr_add_to_namespace(UNCONST(fr_dict_attr_t *, vsa_da), new) < 0) {
1981 return -1; /* leaves attr added */
1982 }
1983
1984 vendor_da = new;
1985 } else {
1986 fr_assert(vendor_da->type == FR_TYPE_VENDOR);
1987 }
1988
1989 return dict_dctx_push(dctx, vendor_da, NEST_VENDOR);
1990}
1991
1992/*
1993 * Process the DEFINE command
1994 *
1995 * Which is mostly like ATTRIBUTE, but does not have a number.
1996 */
1997static int dict_read_process_define(dict_tokenize_ctx_t *dctx, char **argv, int argc,
1998 fr_dict_attr_flags_t *base_flags)
1999{
2000 fr_dict_attr_t const *parent;
2001 fr_dict_attr_t *da = NULL;
2002 dict_tokenize_frame_t const *frame;
2003
2004 if ((argc < 2) || (argc > 3)) {
2005 fr_strerror_const("Invalid DEFINE syntax");
2006 return -1;
2007 }
2008
2009 frame = dict_dctx_unwind(dctx);
2010 if (!fr_cond_assert(frame && frame->da)) return -1; /* Should have provided us with a parent */
2011
2012 parent = frame->da;
2013
2014 /*
2015 * Members of a 'struct' MUST use MEMBER, not ATTRIBUTE.
2016 */
2017 if (parent->type == FR_TYPE_STRUCT) {
2018 fr_strerror_printf("Member %s of parent %s type 'struct' MUST use the \"MEMBER\" keyword",
2019 argv[0], parent->name);
2020 return -1;
2021 }
2022
2023 if (parent->type == FR_TYPE_UNION) {
2024 fr_strerror_printf("Parent attribute %s is of type 'union', and cannot use DEFINE for children",
2025 parent->name);
2026 return -1;
2027 }
2028
2029 /*
2030 * We don't set the attribute number before parsing the
2031 * type and flags. The number is chosen internally, and
2032 * no one should depend on it.
2033 */
2034 if (dict_read_process_common(dctx, &da, parent, argv[0], argv[1],
2035 (argc > 2) ? argv[2] : NULL, base_flags) < 0) {
2036 return -1;
2037 }
2038
2039 /*
2040 * Certain structural types MUST have numbers.
2041 */
2042 switch (da->type) {
2043 case FR_TYPE_VSA:
2044 case FR_TYPE_VENDOR:
2045 fr_strerror_printf("DEFINE cannot be used for type '%s'", argv[1]);
2046 error:
2047 talloc_free(da);
2048 return -1;
2049
2050 default:
2051 break;
2052 }
2053
2054 if (da_is_bit_field(da)) {
2055 fr_strerror_const("Bit fields can only be defined as a MEMBER of data type 'struct'");
2056 goto error;
2057 }
2058
2059#ifdef STATIC_ANALYZER
2060 if (!dctx->dict) goto error;
2061#endif
2062
2063 /*
2064 * Since there is no number, the attribute cannot be
2065 * encoded as a number.
2066 */
2067 da->flags.name_only = true;
2068
2069 /*
2070 * Add an attribute number now so the allocations occur in order
2071 */
2072 if (unlikely(dict_attr_num_init_name_only(da) < 0)) goto error;
2073
2074 /*
2075 * Set the attribute name
2076 */
2077 if (unlikely(dict_attr_finalise(&da, argv[0]) < 0)) goto error;
2078
2079 /*
2080 * Check to see if this is a duplicate attribute
2081 * and whether we should ignore it or error out...
2082 */
2083 switch (dict_attr_allow_dup(da)) {
2084 case 1:
2085 break;
2086
2087 case 0:
2088 talloc_free(da);
2089 return 0;
2090
2091 default:
2092 goto error;
2093 }
2094
2095 /*
2096 * Add the attribute we allocated earlier
2097 */
2098 switch (dict_attr_add_or_fixup(&dctx->fixup, &da)) {
2099 default:
2100 goto error;
2101
2102 /* New attribute, fixup stack */
2103 case 0:
2104 if (dict_set_value_attr(dctx, da) < 0) return -1;
2105
2106 if (da->type == FR_TYPE_TLV) {
2107 dctx->relative_attr = da;
2108 } else {
2109 dctx->relative_attr = NULL;
2110 }
2111 break;
2112
2113 /* Deferred attribute, don't begin the TLV section automatically */
2114 case 1:
2115 break;
2116 }
2117
2118 return 0;
2119}
2120
2121static int dict_read_process_end(dict_tokenize_ctx_t *dctx, char **argv, int argc,
2122 UNUSED fr_dict_attr_flags_t *base_flags)
2123{
2124 fr_dict_attr_t const *current;
2125 fr_dict_attr_t const *da;
2126 dict_tokenize_frame_t const *frame;
2127
2128 dctx->value_attr = NULL;
2129 dctx->relative_attr = NULL;
2130
2131 if (argc > 2) {
2132 fr_strerror_const("Invalid END syntax, expected END <ref>");
2133 return -1;
2134 }
2135
2136 /*
2137 * Unwind until we hit an attribute nesting section
2138 */
2139 if (!dict_dctx_unwind_until(dctx, NEST_ATTRIBUTE)) {
2140 return -1;
2141 }
2142
2143 /*
2144 * Pop the stack to get the attribute we're ending.
2145 */
2146 current = dict_dctx_pop(dctx)->da;
2147
2148 /*
2149 * No checks on the attribute, we're just popping _A_ frame,
2150 * we don't care what attribute it represents.
2151 */
2152 if (argc == 0) return 0;
2153
2154 /*
2155 * This is where we'll have begun the previous search to
2156 * evaluate the BEGIN keyword.
2157 */
2158 frame = dict_dctx_find_frame(dctx, NEST_TOP | NEST_PROTOCOL | NEST_ATTRIBUTE);
2159 if (!fr_cond_assert(frame)) return -1;
2160
2161 da = fr_dict_attr_by_oid(NULL, frame->da, argv[0]);
2162 if (!da) {
2163 fr_strerror_const_push("Failed resolving attribute in BEGIN entry");
2164 return -1;
2165 }
2166
2167 if (da != current) {
2168 fr_strerror_printf("END %s does not match previous BEGIN %s", argv[0], current->name);
2169 return -1;
2170 }
2171
2172 return 0;
2173}
2174
2175static int dict_read_process_end_protocol(dict_tokenize_ctx_t *dctx, char **argv, int argc,
2176 UNUSED fr_dict_attr_flags_t *base_flags)
2177{
2178 fr_dict_t const *found;
2179
2180 dctx->value_attr = NULL;
2181 dctx->relative_attr = NULL;
2182
2183 if (argc != 1) {
2184 fr_strerror_const("Invalid END-PROTOCOL entry");
2185 return -1;
2186 }
2187
2188 found = dict_by_protocol_name(argv[0]);
2189 if (!found) {
2190 fr_strerror_printf("END-PROTOCOL %s does not refer to a valid protocol", argv[0]);
2191 return -1;
2192 }
2193
2194 if (found != dctx->dict) {
2195 fr_strerror_printf("END-PROTOCOL %s does not match previous BEGIN-PROTOCOL %s",
2196 argv[0], dctx->dict->root->name);
2197 return -1;
2198 }
2199
2200 /*
2201 * Unwind until we get to a BEGIN-PROTOCOL nesting.
2202 */
2203 if (!dict_dctx_unwind_until(dctx, NEST_PROTOCOL)) {
2204 return -1;
2205 }
2206
2207 if (found->root != CURRENT_FRAME(dctx)->da) {
2208 fr_strerror_printf("END-PROTOCOL %s does not match previous BEGIN-PROTOCOL %s", argv[0],
2209 CURRENT_FRAME(dctx)->da->name);
2210 return -1;
2211 }
2212
2213 /*
2214 * Applies fixups to any attributes added to the protocol
2215 * dictionary. Note that the finalise function prints
2216 * out the original filename / line of the error. So we
2217 * don't need to do that here.
2218 */
2219 if (dict_finalise(dctx) < 0) return -1;
2220
2221 ASSERT_CURRENT_NEST(dctx, NEST_PROTOCOL);
2222
2223 fr_assert(!dctx->stack[dctx->stack_depth].finalise);
2224 dctx->stack_depth--; /* nuke the BEGIN-PROTOCOL */
2225
2226 ASSERT_CURRENT_NEST(dctx, NEST_TOP);
2227 dctx->dict = dict_gctx->internal;
2228
2229 return 0;
2230}
2231
2232static int dict_read_process_end_vendor(dict_tokenize_ctx_t *dctx, char **argv, int argc,
2233 UNUSED fr_dict_attr_flags_t *base_flags)
2234{
2235 fr_dict_vendor_t const *vendor;
2236
2237 dctx->value_attr = NULL;
2238 dctx->relative_attr = NULL;
2239
2240 if (argc != 1) {
2241 fr_strerror_const("END-VENDOR is missing vendor name");
2242 return -1;
2243 }
2244
2245 vendor = fr_dict_vendor_by_name(dctx->dict, argv[0]);
2246 if (!vendor) {
2247 fr_strerror_printf("Unknown vendor '%s'", argv[0]);
2248 return -1;
2249 }
2250
2251 /*
2252 * Unwind until we get to a BEGIN-VENDOR nesting.
2253 */
2254 if (!dict_dctx_unwind_until(dctx, NEST_VENDOR)) {
2255 return -1;
2256 }
2257
2258 if (vendor->pen != CURRENT_FRAME(dctx)->da->attr) {
2259 fr_strerror_printf("END-VENDOR %s does not match previous BEGIN-VENDOR %s", argv[0],
2260 CURRENT_FRAME(dctx)->da->name);
2261 return -1;
2262 }
2263
2264 fr_assert(!dctx->stack[dctx->stack_depth].finalise);
2265 dctx->stack_depth--; /* nuke the BEGIN-VENDOR */
2266
2267 return 0;
2268}
2269
2270/*
2271 * Process the ENUM command
2272 */
2273static int dict_read_process_enum(dict_tokenize_ctx_t *dctx, char **argv, int argc,
2274 fr_dict_attr_flags_t *base_flags)
2275{
2276 fr_dict_attr_t const *parent;
2277 fr_dict_attr_t *da = NULL;
2278
2279 if (argc != 2) {
2280 fr_strerror_const("Invalid ENUM syntax");
2281 return -1;
2282 }
2283
2284 /*
2285 * Dictionaries need to have real names, not shitty ones.
2286 */
2287 if (strncmp(argv[0], "Attr-", 5) == 0) {
2288 fr_strerror_const("Invalid ENUM name");
2289 return -1;
2290 }
2291
2292#ifdef STATIC_ANALYZER
2293 if (!dctx->dict) goto error;
2294#endif
2295
2296 /*
2297 * Allocate the attribute here, and then fill in the fields
2298 * as we start parsing the various elements of the definition.
2299 */
2300 da = dict_attr_alloc_null(dctx->dict->pool, dctx->dict->proto);
2301 if (unlikely(da == NULL)) return -1;
2302 dict_attr_location_set(dctx, da);
2303 da->dict = dctx->dict;
2304
2305 /*
2306 * Set the attribute flags from the base flags.
2307 */
2308 memcpy(&da->flags, base_flags, sizeof(da->flags));
2309
2310 da->flags.name_only = true; /* values for ENUM are irrelevant */
2311 da->flags.internal = true; /* ENUMs will never get encoded into a protocol */
2312#if 0
2313 flags.is_enum = true; /* it's an enum, and can't be assigned to a #fr_pair_t */
2314#endif
2315
2316 /*
2317 * Set the base type of the attribute.
2318 */
2319 if (dict_process_type_field(dctx, argv[1], &da) < 0) {
2320 error:
2321 talloc_free(da);
2322 return -1;
2323 }
2324
2325 if (da_is_bit_field(da)) {
2326 fr_strerror_const("Bit fields can only be defined as a MEMBER of a data type 'struct'");
2327 goto error;
2328 }
2329
2330 switch (da->type) {
2331 case FR_TYPE_LEAF:
2332 break;
2333
2334 default:
2335 fr_strerror_printf("ENUMs can only be a leaf type, not %s",
2336 fr_type_to_str(da->type));
2337 goto error;
2338 }
2339
2340 parent = CURRENT_FRAME(dctx)->da;
2341 if (!parent) {
2342 fr_strerror_const("Invalid location for ENUM");
2343 goto error;
2344 }
2345
2346 /*
2347 * ENUMs cannot have a flag field, so we don't parse that.
2348 *
2349 * Maybe we do want a flag field for named time deltas?
2350 */
2351
2352 if (unlikely(dict_attr_parent_init(&da, parent) < 0)) goto error;
2353 if (unlikely(dict_attr_finalise(&da, argv[0]) < 0)) goto error;
2354
2355 /*
2356 * Add the attribute we allocated earlier
2357 */
2358 switch (dict_attr_add_or_fixup(&dctx->fixup, &da)) {
2359 default:
2360 goto error;
2361
2362 case 0:
2363 memcpy(&dctx->value_attr, &da, sizeof(da));
2364 break;
2365
2366 case 1:
2367 break;
2368 }
2369
2370 return 0;
2371}
2372
2373/*
2374 * Process the FLAGS command
2375 */
2376static int dict_read_process_flags(UNUSED dict_tokenize_ctx_t *dctx, char **argv, int argc,
2377 fr_dict_attr_flags_t *base_flags)
2378{
2379 bool sense = true;
2380
2381 if (argc == 1) {
2382 char *p;
2383
2384 p = argv[0];
2385 if (*p == '!') {
2386 sense = false;
2387 p++;
2388 }
2389
2390 if (strcmp(p, "internal") == 0) {
2391 base_flags->internal = sense;
2392 return 0;
2393 }
2394 }
2395
2396 fr_strerror_const("Invalid FLAGS syntax");
2397 return -1;
2398}
2399
2400/*
2401 * Process the MEMBER command
2402 */
2403static int dict_read_process_member(dict_tokenize_ctx_t *dctx, char **argv, int argc,
2404 fr_dict_attr_flags_t *base_flags)
2405{
2406 fr_dict_attr_t *da = NULL;
2407
2408 if ((argc < 2) || (argc > 3)) {
2409 fr_strerror_const("Invalid MEMBER syntax");
2410 return -1;
2411 }
2412
2413 if (CURRENT_FRAME(dctx)->da->type != FR_TYPE_STRUCT) {
2414 fr_strerror_printf("MEMBER can only be used for ATTRIBUTEs of type 'struct', not for data type %s",
2415 fr_type_to_str(CURRENT_FRAME(dctx)->da->type));
2416 return -1;
2417 }
2418
2419 /*
2420 * Check if the parent 'struct' is fixed size. And if
2421 * so, complain if we're adding a variable sized member.
2422 */
2423 if (CURRENT_FRAME(dctx)->struct_is_closed) {
2424 fr_strerror_printf("Cannot add MEMBER to 'struct' %s after a variable sized member %s",
2425 CURRENT_FRAME(dctx)->da->name,
2426 CURRENT_FRAME(dctx)->struct_is_closed->name);
2427 return -1;
2428 }
2429
2430 /*
2431 * We don't set the attribute number before parsing the
2432 * type and flags. The number is chosen internally, and
2433 * no one should depend on it.
2434 *
2435 * Although _arguably_, it may be useful to know which
2436 * field this is, 0..N?
2437 */
2438 if (dict_read_process_common(dctx, &da, CURRENT_FRAME(dctx)->da, argv[0], argv[1],
2439 (argc > 2) ? argv[2] : NULL, base_flags) < 0) {
2440 return -1;
2441 }
2442
2443#ifdef STATIC_ANALYZER
2444 if (!dctx->dict) goto error;
2445#endif
2446
2447 /*
2448 * If our parent is a known width struct, then we're
2449 * allowed to be variable width. The parent might just
2450 * have a "length=16" prefix, which lets its children be
2451 * variable sized.
2452 */
2453
2454 /*
2455 * Double check any bit field magic
2456 */
2457 if (CURRENT_FRAME(dctx)->member_num > 0) {
2458 fr_dict_attr_t const *previous;
2459
2460 previous = dict_attr_child_by_num(CURRENT_FRAME(dctx)->da,
2461 CURRENT_FRAME(dctx)->member_num);
2462 /*
2463 * Check that the previous bit field ended on a
2464 * byte boundary.
2465 *
2466 * Note that the previous attribute might be a deferred TLV, in which case it doesn't
2467 * exist. That's fine.
2468 */
2469 if (previous && da_is_bit_field(previous)) {
2470 /*
2471 * This attribute is a bit field. Keep
2472 * track of where in the byte we are
2473 * located.
2474 */
2475 if (da_is_bit_field(da)) {
2476 da->flags.flag_byte_offset = (da->flags.length + previous->flags.flag_byte_offset) & 0x07;
2477
2478 } else {
2479 if (previous->flags.flag_byte_offset != 0) {
2480 fr_strerror_printf("Previous bitfield %s did not end on a byte boundary",
2481 previous->name);
2482 error:
2483 talloc_free(da);
2484 return -1;
2485 }
2486 }
2487 }
2488 }
2489
2490 /*
2491 * Ensure that no previous child has "key" or "length" set.
2492 */
2493 if (da->type == FR_TYPE_TLV) {
2494 fr_dict_attr_t const *key;
2495 int i;
2496
2497 /*
2498 * @todo - cache the key field in the stack frame, so we don't have to loop over the children.
2499 */
2500 for (i = 1; i <= CURRENT_FRAME(dctx)->member_num; i++) {
2501 key = dict_attr_child_by_num(CURRENT_FRAME(dctx)->da, i);
2502 if (!key) continue; /* really should be WTF? */
2503
2504 /*
2505 * @todo - we can allow this if the _rest_ of the struct is fixed size, i.e. if
2506 * there is a key field, and then the union is fixed size.
2507 */
2508 if (fr_dict_attr_is_key_field(key)) {
2509 fr_strerror_printf("'struct' %s has a 'key' field %s, and cannot end with a TLV %s",
2510 CURRENT_FRAME(dctx)->da->name, key->name, argv[0]);
2511 goto error;
2512 }
2513
2514 if (da_is_length_field(key)) {
2515 fr_strerror_printf("'struct' %s has a 'length' field %s, and cannot end with a TLV %s",
2516 CURRENT_FRAME(dctx)->da->name, key->name, argv[0]);
2517 goto error;
2518 }
2519 }
2520
2521 /*
2522 * TLVs are variable sized, and close the parent struct.
2523 */
2524 CURRENT_FRAME(dctx)->struct_is_closed = da;
2525 }
2526
2527 /*
2528 * Unions close the parent struct, even if they're fixed size. For now, the struct to/from
2529 * network code assumes that a union is the last member of a structure.
2530 */
2531 if (da->type == FR_TYPE_UNION) {
2532 CURRENT_FRAME(dctx)->struct_is_closed = da;
2533 }
2534
2535 if (unlikely(dict_attr_num_init(da, CURRENT_FRAME(dctx)->member_num + 1) < 0)) goto error;
2536 if (unlikely(dict_attr_finalise(&da, argv[0]) < 0)) goto error;
2537
2538 /*
2539 * Check to see if this is a duplicate attribute
2540 * and whether we should ignore it or error out...
2541 */
2542 switch (dict_attr_allow_dup(da)) {
2543 case 1:
2544 break;
2545
2546 case 0:
2547 talloc_free(da);
2548 return 0;
2549
2550 default:
2551 goto error;
2552 }
2553
2554 switch (dict_attr_add_or_fixup(&dctx->fixup, &da)) {
2555 default:
2556 goto error;
2557
2558 case 1:
2559 /*
2560 * @todo - a MEMBER can theoretically have a "ref=..", though non currently do.
2561 *
2562 * If the ref is deferred, then we cannot finalise the parent struct until we have
2563 * resolved the reference. But the "finalise struct on fixup" code isn't written. So
2564 * instead of silently doing the wrong thing, we just return an error.
2565 */
2566 fr_strerror_printf("Cannot have MEMBER with deferred ref=...");
2567 return -1;
2568
2569 case 0:
2570 /*
2571 * New attribute - avoid lots of indentation.
2572 */
2573 break;
2574 }
2575
2576 /*
2577 * Check if this MEMBER closes the structure.
2578 *
2579 * Close this struct if the child struct is variable sized. For now, it we only support
2580 * child structs at the end of the parent.
2581 *
2582 * The solution is to update the unwind() function to check if the da we've
2583 * unwound to is a struct, and then if so... get the last child, and mark it
2584 * closed.
2585 *
2586 * @todo - a MEMBER which is of type 'struct' and has 'clone=foo', we delay the clone
2587 * until after all of the dictionaries have been loaded. As such, this attribute
2588 * is unknown width, and MUST be at the end of the parent structure.
2589 *
2590 * If the cloned MEMBER is in the middle of a structure, then the user will get an opaque
2591 * error. But that case should be rare.
2592 */
2593 if (!da->flags.is_known_width) {
2594 /*
2595 * The child is unknown width, but we were told that the parent has known width.
2596 * That's an error.
2597 */
2598 if (CURRENT_FRAME(dctx)->da->flags.length) {
2599 fr_strerror_printf("'struct' %s has fixed size %u, but member %s is of unknown size",
2600 CURRENT_FRAME(dctx)->da->name, CURRENT_FRAME(dctx)->da->flags.length,
2601 argv[0]);
2602 return -1;
2603 }
2604
2605 /*
2606 * Mark the structure as closed by this attribute. And then set the size to
2607 * zero, for "unknown size".
2608 */
2609 CURRENT_FRAME(dctx)->struct_is_closed = da;
2610 CURRENT_FRAME(dctx)->struct_size = 0;
2611
2612 /*
2613 * A 'struct' can have a MEMBER of type 'tlv', but ONLY
2614 * as the last entry in the 'struct'. If we see that,
2615 * set the previous attribute to the TLV we just added.
2616 * This allows the children of the TLV to be parsed as
2617 * partial OIDs, so we don't need to know the full path
2618 * to them.
2619 */
2620 if (da->type == FR_TYPE_TLV) {
2621 dctx->relative_attr = da;
2622 if (dict_dctx_push(dctx, dctx->relative_attr, NEST_NONE) < 0) return -1;
2623 }
2624
2625 } else if (CURRENT_FRAME(dctx)->da->flags.length) {
2626 /*
2627 * The parent is fixed size, so we track the length of the children.
2628 */
2629 CURRENT_FRAME(dctx)->struct_size += da->flags.length;
2630
2631 /*
2632 * Adding this child may result in an overflow, so we check that.
2633 */
2634 if (CURRENT_FRAME(dctx)->struct_size > CURRENT_FRAME(dctx)->da->flags.length) {
2635 fr_strerror_printf("'struct' %s has fixed size %u, but member %s overflows that length",
2636 CURRENT_FRAME(dctx)->da->name, CURRENT_FRAME(dctx)->da->flags.length,
2637 argv[0]);
2638 return -1;
2639 }
2640 }
2641
2642 /*
2643 * Now that we know everything is OK, we can increase the number.
2644 */
2645 CURRENT_FRAME(dctx)->member_num++;
2646
2647 /*
2648 * Set or clear the attribute for VALUE statements.
2649 */
2650 return dict_set_value_attr(dctx, da);
2651}
2652
2653
2654/** Process a value alias
2655 *
2656 */
2657static int dict_read_process_value(dict_tokenize_ctx_t *dctx, char **argv, int argc,
2658 UNUSED fr_dict_attr_flags_t *base_flags)
2659{
2660 fr_dict_attr_t *da;
2661 fr_value_box_t value = FR_VALUE_BOX_INITIALISER_NULL(value);
2662 size_t enum_len;
2663 fr_dict_attr_t const *parent = CURRENT_FRAME(dctx)->da;
2664 fr_dict_attr_t const *enumv = NULL;
2665
2666 if (argc != 3) {
2667 fr_strerror_const("Invalid VALUE syntax");
2668 return -1;
2669 }
2670
2671 /*
2672 * Most VALUEs are bunched together by ATTRIBUTE. We can
2673 * save a lot of lookups on dictionary initialization by
2674 * caching the last attribute for a VALUE.
2675 *
2676 * If it's not the same, we look up the attribute in the
2677 * current context, which is generally:
2678 *
2679 * * the current attribute of type `struct`
2680 * * if no `struct`, then the VENDOR for VSAs
2681 * * if no VENDOR, then the dictionary root
2682 */
2683 if (!dctx->value_attr || (strcasecmp(argv[0], dctx->value_attr->name) != 0)) {
2684 fr_dict_attr_t const *tmp;
2685
2686 if (!(tmp = fr_dict_attr_by_oid(NULL, parent, argv[0]))) goto fixup;
2687 dctx->value_attr = fr_dict_attr_unconst(tmp);
2688 }
2689 da = dctx->value_attr;
2690
2691 /*
2692 * Verify the enum name matches the expected from.
2693 */
2694 enum_len = strlen(argv[1]);
2695 if (fr_dict_enum_name_from_substr(NULL, NULL, &FR_SBUFF_IN(argv[1], enum_len), NULL) != (fr_slen_t) enum_len) {
2696 fr_strerror_printf_push("Invalid VALUE name '%s' for attribute '%s'", argv[1], da->name);
2697 return -1;
2698 }
2699
2700 /*
2701 * enum names cannot be integers. People should just use the integer instead.
2702 *
2703 * But what about IPv6 addresses, which also use a "::" prefix?
2704 *
2705 * The ::FOO addresses were historically part of the "ipv4 compatible ipv6 address" range
2706 * "::0.0.0.0/96". That range has since been deprecated, and the "::FOO" range is tracked in the
2707 * IANA Special-Purpose Address Registry. That lists three things beginning with ::
2708 *
2709 * * ::/128 - unspecified address (i.e. ::0/128).
2710 * * ::1/128 - Loopback address
2711 * * ::ffff:0:0/96 - IPv4-mapped address.
2712 *
2713 * Since IPv6 addresses are 128 bits, the first two are just ::0 and ::1. No other possibilities
2714 * exist.
2715 *
2716 * For the range "::ffff:0:0/96", a value such as "::ffff:192.168.1.2 is not a valid enum name.
2717 * It contains an extra ':' (and MUST contain the extra ':'), and the ':' is not allowed in an
2718 * enum name.
2719 *
2720 * IANA could assign other values in the :: range, but this seems unlikely.
2721 *
2722 * As a result, the only overlap between enum ::FOO and IPv6 addresses is the single case of ::1.
2723 * This check disallows that.
2724 */
2725 if (fr_sbuff_adv_past_allowed( &FR_SBUFF_IN(argv[1], enum_len), SIZE_MAX, sbuff_char_class_int, NULL) == enum_len) {
2726 fr_strerror_printf("Invalid VALUE name '%s' for attribute '%s' - the name cannot be an integer", argv[1], da->name);
2727 return -1;
2728 }
2729
2730 /*
2731 * Remember which attribute is associated with this
2732 * value. This allows us to define enum
2733 * values before the attribute exists, and fix them
2734 * up later.
2735 */
2736 if (!da) {
2737 fixup:
2738 if (!fr_cond_assert_msg(dctx->fixup.pool, "fixup pool context invalid")) return -1;
2739
2740 if (dict_fixup_enumv_enqueue(&dctx->fixup,
2741 CURRENT_FILENAME(dctx), CURRENT_LINE(dctx),
2742 argv[0], strlen(argv[0]),
2743 argv[1], strlen(argv[1]),
2744 argv[2], strlen(argv[2]), parent) < 0) {
2745 fr_strerror_const("Out of memory");
2746 return -1;
2747 }
2748 return 0;
2749 }
2750
2751 /*
2752 * Only a leaf types can have values defined.
2753 */
2754 if (!fr_type_is_leaf(da->type)) {
2755 fr_strerror_printf("Cannot define VALUE for attribute '%s' of data type '%s'", da->name,
2756 fr_type_to_str(da->type));
2757 return -1;
2758 }
2759
2760 /*
2761 * Pass in the DA. The value-box parsing functions will figure out where the enums are found.
2762 */
2763 if (da->type == FR_TYPE_ATTR) enumv = da;
2764
2765 if (fr_value_box_from_str(NULL, &value, da->type, enumv,
2766 argv[2], strlen(argv[2]),
2767 NULL) < 0) {
2768 fr_strerror_printf_push("Invalid VALUE '%s' for attribute '%s' of data type '%s'",
2769 argv[2],
2770 da->name,
2771 fr_type_to_str(da->type));
2772 return -1;
2773 }
2774
2775 if (fr_dict_enum_add_name(da, argv[1], &value, false, true) < 0) {
2776 fr_value_box_clear(&value);
2777 return -1;
2778 }
2779 fr_value_box_clear(&value);
2780
2781 return 0;
2782}
2783
2784/*
2785 * Process the VENDOR command
2786 */
2787static int dict_read_process_vendor(dict_tokenize_ctx_t *dctx, char **argv, int argc, UNUSED fr_dict_attr_flags_t *base_flags)
2788{
2789 unsigned int value;
2790 int type, length;
2791 bool continuation = false;
2792 fr_dict_vendor_t const *dv;
2793 fr_dict_vendor_t *mutable;
2794 fr_dict_t *dict = dctx->dict;
2795
2796 dctx->value_attr = NULL;
2797 dctx->relative_attr = NULL;
2798
2799 if ((argc < 2) || (argc > 3)) {
2800 fr_strerror_const("Invalid VENDOR syntax");
2801 return -1;
2802 }
2803
2804 /*
2805 * Validate all entries
2806 */
2807 if (!dict_read_sscanf_i(&value, argv[1])) {
2808 fr_strerror_const("Invalid number in VENDOR");
2809 return -1;
2810 }
2811
2812 /*
2813 * Look for a format statement. Allow it to over-ride the hard-coded formats below.
2814 */
2815 if (argc == 3) {
2816 if (dict_read_parse_format(argv[2], &type, &length, &continuation) < 0) return -1;
2817
2818 } else {
2819 type = length = 1;
2820 }
2821
2822 /* Create a new VENDOR entry for the list */
2823 if (dict_vendor_add(dict, argv[0], value) < 0) return -1;
2824
2825 dv = fr_dict_vendor_by_num(dict, value);
2826 if (!dv) {
2827 fr_strerror_const("Failed adding format for VENDOR");
2828 return -1;
2829 }
2830
2831 mutable = UNCONST(fr_dict_vendor_t *, dv);
2832 mutable->type = type;
2833 mutable->length = length;
2834 mutable->continuation = continuation;
2835
2836 return 0;
2837}
2838
2839/** The main protocols that we care about.
2840 *
2841 * Not all of them are listed here, but that should be fine.
2842 *
2843 */
2844static fr_table_num_ordered_t const dict_proto_table[] = {
2845 { L("RADIUS"), FR_DICT_PROTO_RADIUS },
2846 { L("DHCPv4"), FR_DICT_PROTO_DHCPv4 },
2847 { L("DHCPv6"), FR_DICT_PROTO_DHCPv6 },
2848 { L("Ethernet"), FR_DICT_PROTO_ETHERNET },
2849 { L("TACACS"), FR_DICT_PROTO_TACACS },
2850 { L("VMPS"), FR_DICT_PROTO_VMPS },
2851 { L("SNMP"), FR_DICT_PROTO_SNMP },
2852 { L("ARP"), FR_DICT_PROTO_ARP },
2853 { L("TFTP"), FR_DICT_PROTO_TFTP },
2854 { L("TLS"), FR_DICT_PROTO_TLS },
2855 { L("DNS"), FR_DICT_PROTO_DNS },
2856 { L("LDAP"), FR_DICT_PROTO_LDAP },
2857 { L("BFD"), FR_DICT_PROTO_BFD },
2858};
2859static size_t const dict_proto_table_len = NUM_ELEMENTS(dict_proto_table);
2860
2861/** Register the specified dictionary as a protocol dictionary
2862 *
2863 * Allows vendor and TLV context to persist across $INCLUDEs
2864 */
2865static int dict_read_process_protocol(dict_tokenize_ctx_t *dctx, char **argv, int argc, UNUSED fr_dict_attr_flags_t *base_flag)
2866{
2867 unsigned int value;
2868 unsigned int type_size = 0;
2869 fr_dict_t *dict;
2870 unsigned int required_value;
2871 char const *required_name;
2872 bool require_dl = false;
2873 bool string_based = false;
2874
2875 /*
2876 * We cannot define a PROTOCOL inside of another protocol.
2877 */
2878 if (CURRENT_FRAME(dctx)->nest != NEST_TOP) {
2879 fr_strerror_const("PROTOCOL definitions cannot occur inside of any other BEGIN/END block");
2880 return -1;
2881 }
2882
2883 dctx->value_attr = NULL;
2884 dctx->relative_attr = NULL;
2885
2886 if ((argc < 2) || (argc > 3)) {
2887 fr_strerror_const("Missing arguments after PROTOCOL. Expected PROTOCOL <num> <name>");
2888 return -1;
2889 }
2890
2891 /*
2892 * Validate all entries
2893 */
2894 if (!dict_read_sscanf_i(&value, argv[1])) {
2895 fr_strerror_printf("Invalid number '%s' following PROTOCOL", argv[1]);
2896 return -1;
2897 }
2898
2899 /*
2900 * 255 protocols FR_TYPE_GROUP type_size hack
2901 */
2902 if (!value) {
2903 fr_strerror_printf("Invalid value '%u' following PROTOCOL", value);
2904 return -1;
2905 }
2906
2907 /*
2908 * While the numbers are in the dictionaries, the administrator cannot change "RADIUS" to be a
2909 * different number. Similarly, they can't assign the RADIUS number to a different protocol.
2910 */
2911 required_value = fr_table_value_by_str(dict_proto_table, argv[0], 0);
2912 if (required_value && (required_value != value)) {
2913 fr_strerror_printf("Invalid value '%u' following PROTOCOL - expected '%u'", value, required_value);
2914 return -1;
2915 }
2916
2917 /*
2918 * And the administrator can't define the name to be a different number.
2919 */
2920 required_name = fr_table_str_by_value(dict_proto_table, value, NULL);
2921 if (required_name && (strcasecmp(required_name, argv[0]) != 0)) {
2922 fr_strerror_printf("Invalid value '%u' for PROTOCOL '%s' - that value is already used by '%s'",
2923 value, argv[0], required_name);
2924 return -1;
2925 }
2926
2927 /*
2928 * Look for a format statement. This may specify the
2929 * type length of the protocol's types.
2930 */
2931 if (argc == 3) {
2932 char const *p;
2933 char *q;
2934
2935 /*
2936 * For now, we don't allow multiple options here.
2937 *
2938 * @todo - allow multiple options.
2939 */
2940 if (strcmp(argv[2], "verify=lib") == 0) {
2941 require_dl = true;
2942 goto post_option;
2943 }
2944
2945 if (strcmp(argv[2], "format=string") == 0) {
2946 type_size = 4;
2947 string_based = true;
2948 goto post_option;
2949 }
2950
2951 if (strncasecmp(argv[2], "format=", 7) != 0) {
2952 fr_strerror_printf("Invalid format for PROTOCOL. Expected 'format=', got '%s'", argv[2]);
2953 return -1;
2954 }
2955 p = argv[2] + 7;
2956
2957 type_size = strtoul(p, &q, 10);
2958 if (q != (p + strlen(p))) {
2959 fr_strerror_printf("Found trailing garbage '%s' after format specifier", p);
2960 return -1;
2961 }
2962 }
2963post_option:
2964
2965 /*
2966 * Cross check name / number.
2967 */
2968 dict = dict_by_protocol_name(argv[0]);
2969 if (dict) {
2970#ifdef STATIC_ANALYZER
2971 if (!dict->root) return -1;
2972#endif
2973
2974 if (dict->root->attr != value) {
2975 fr_strerror_printf("Conflicting numbers %u vs %u for PROTOCOL \"%s\"",
2976 dict->root->attr, value, dict->root->name);
2977 return -1;
2978 }
2979
2980 } else if ((dict = dict_by_protocol_num(value)) != NULL) {
2981#ifdef STATIC_ANALYZER
2982 if (!dict->root || !dict->root->name || !argv[0]) return -1;
2983#endif
2984
2985 if (strcasecmp(dict->root->name, argv[0]) != 0) {
2986 fr_strerror_printf("Conflicting names current \"%s\" vs new \"%s\" for PROTOCOL %u",
2987 dict->root->name, argv[0], dict->root->attr);
2988 return -1;
2989 }
2990 }
2991
2992 /*
2993 * And check types no matter what.
2994 */
2995 if (dict) {
2996 if (type_size && (dict->root->flags.type_size != type_size)) {
2997 fr_strerror_printf("Conflicting flags for PROTOCOL \"%s\" (current %d versus new %u)",
2998 dict->root->name, dict->root->flags.type_size, type_size);
2999 return -1;
3000 }
3001
3002 /*
3003 * Do NOT talloc_free() dict on error.
3004 */
3005 return dict_dctx_push(dctx, dict->root, NEST_NONE);
3006 }
3007
3008 dict = dict_alloc(dict_gctx);
3009
3010 /*
3011 * Try to load protocol-specific validation routines.
3012 * Some protocols don't need them, so it's OK if the
3013 * validation routines don't exist.
3014 */
3015 if ((dict_dlopen(dict, argv[0]) < 0) && require_dl) {
3016 error:
3017 talloc_free(dict);
3018 return -1;
3019 }
3020
3021 /*
3022 * Set the root attribute with the protocol name
3023 */
3024 if (dict_root_set(dict, argv[0], value) < 0) goto error;
3025
3026 if (dict_protocol_add(dict) < 0) goto error;
3027
3028 dict->string_based = string_based;
3029 if (type_size) {
3030 fr_dict_attr_t *mutable;
3031
3032 mutable = UNCONST(fr_dict_attr_t *, dict->root);
3033 mutable->flags.type_size = type_size;
3034 mutable->flags.length = 1; /* who knows... */
3035 }
3036
3037 /*
3038 * Make the root available on the stack, in case
3039 * something wants to begin it. Note that we mark it as
3040 * NONE, so that it can be cleaned up by anything.
3041 *
3042 * This stack entry is just a place-holder so that the
3043 * BEGIN statement can find the dictionary.
3044 */
3045 if (unlikely(dict_dctx_push(dctx, dict->root, NEST_NONE) < 0)) goto error;
3046
3047 return 0;
3048}
3049
3050/** Maintain a linked list of filenames which we've seen loading this dictionary
3051 *
3052 * This is used for debug messages, so we have a copy of the original file path
3053 * that we can reference from fr_dict_attr_t without having the memory bloat of
3054 * assigning a buffer to every attribute.
3055 */
3056static inline int dict_filename_add(char **filename_out, fr_dict_t *dict, char const *filename,
3057 char const *src_file, int src_line)
3058{
3059 fr_dict_filename_t *file;
3060
3061 file = talloc_zero(dict, fr_dict_filename_t);
3062 if (unlikely(!file)) {
3063 oom:
3064 fr_strerror_const("Out of memory");
3065 return -1;
3066 }
3067 *filename_out = file->filename = talloc_strdup(file, filename);
3068 if (unlikely(!*filename_out)) goto oom;
3069
3070 if (src_file) {
3071 file->src_line = src_line;
3072 file->src_file = talloc_strdup(file, src_file);
3073 if (!file->src_file) goto oom;
3074 }
3075
3076 fr_dlist_insert_tail(&dict->filenames, file);
3077
3078 return 0;
3079}
3080
3081/** See if we have already loaded the file,
3082 *
3083 */
3084static inline bool dict_filename_loaded(fr_dict_t const *dict, char const *filename,
3085 char const *src_file, int src_line)
3086{
3087 fr_dict_filename_t *file;
3088
3089 for (file = (fr_dict_filename_t *) fr_dlist_head(&dict->filenames);
3090 file != NULL;
3091 file = (fr_dict_filename_t *) fr_dlist_next(&dict->filenames, &file->entry)) {
3092 if (file->src_file && src_file) {
3093 if (file->src_line != src_line) continue;
3094 if (strcmp(file->src_file, src_file) != 0) continue;
3095 }
3096
3097 if (strcmp(file->filename, filename) == 0) return true; /* this should always be true */
3098 }
3099
3100 return false;
3101}
3102
3103bool fr_dict_filename_loaded(fr_dict_t const *dict, char const *dir, char const *filename)
3104{
3105 char buffer[PATH_MAX];
3106
3107 if (!dict) return false;
3108
3109 snprintf(buffer, sizeof(buffer), "%s/%s", dir, filename);
3110
3111 return dict_filename_loaded(dict, buffer, NULL, 0);
3112}
3113
3114/** Process an inline BEGIN PROTOCOL block
3115 *
3116 * This function is called *after* the PROTOCOL handler.
3117 */
3118static int dict_begin_protocol(NDEBUG_UNUSED dict_tokenize_ctx_t *dctx)
3119{
3120 ASSERT_CURRENT_NEST(dctx, NEST_NONE);
3121 fr_assert(CURRENT_DA(dctx)->flags.is_root);
3122
3123 /*
3124 * Rewrite it in place.
3125 */
3126 CURRENT_FRAME(dctx)->nest = NEST_PROTOCOL;
3127 dctx->dict = CURRENT_DA(dctx)->dict;
3128
3129 return 0;
3130}
3131
3132/** Keyword parser
3133 *
3134 * @param[in] dctx containing the dictionary we're currently parsing.
3135 * @param[in] argv arguments to the keyword.
3136 * @param[in] argc number of arguments.
3137 * @param[in] base_flags set in the context of the current file.
3138 * @return
3139 * - 0 on success.
3140 * - -1 on failure.
3141 */
3142typedef int (*fr_dict_keyword_parse_t)(dict_tokenize_ctx_t *dctx, char **argv, int argc, fr_dict_attr_flags_t *base_flags);
3143
3144/** Pushes a new frame onto the top of the stack based on the current frame
3145 *
3146 * Whenever a protocol, vendor, or attribute is defined in the dictionary it either mutates or
3147 * pushes a new NONE frame onto the stack. This holds the last defined object at a given level
3148 * of nesting.
3149 *
3150 * This function is used to push an additional frame onto the stack, effectively entering the
3151 * context of the last defined object at a given level of nesting
3152 *
3153 * @param[in] dctx Contains the current state of the dictionary parser.
3154 * Used to track what PROTOCOL, VENDOR or TLV block
3155 * we're in.
3156 * @return
3157 * - 0 on success.
3158 * - -1 on failure.
3159 */
3160typedef int (*fr_dict_section_begin_t)(dict_tokenize_ctx_t *dctx);
3161
3162typedef struct {
3163 fr_dict_keyword_parse_t parse; //!< Function to parse the keyword with.
3164 fr_dict_section_begin_t begin; //!< Can have a BEGIN prefix
3165} fr_dict_keyword_parser_t;
3166
3167typedef struct {
3168 fr_table_elem_name_t name; //!< Name of the keyword, e.g. "ATTRIBUTE"
3169 fr_dict_keyword_parser_t value; //!< Value to return from lookup.
3170} fr_dict_keyword_t;
3171
3172static TABLE_TYPE_NAME_FUNC_RPTR(table_sorted_value_by_str, fr_dict_keyword_t const *,
3173 fr_dict_keyword, fr_dict_keyword_parser_t const *, fr_dict_keyword_parser_t const *)
3174
3175/** Parse a dictionary file
3176 *
3177 * @param[in] dctx Contains the current state of the dictionary parser.
3178 * Used to track what PROTOCOL, VENDOR or TLV block
3179 * we're in. Block context changes in $INCLUDEs should
3180 * not affect the context of the including file.
3181 * @param[in] dir Directory containing the dictionary we're loading.
3182 * @param[in] filename we're parsing.
3183 * @param[in] src_file The including file.
3184 * @param[in] src_line Line on which the $INCLUDE or $NCLUDE- statement was found.
3185 * @return
3186 * - 0 on success.
3187 * - -1 on failure.
3188 */
3189static int _dict_from_file(dict_tokenize_ctx_t *dctx,
3190 char const *dir, char const *filename,
3191 char const *src_file, int src_line)
3192{
3193 static fr_dict_keyword_t const keywords[] = {
3194 { L("ALIAS"), { .parse = dict_read_process_alias } },
3195 { L("ATTRIBUTE"), { .parse = dict_read_process_attribute } },
3196 { L("BEGIN-PROTOCOL"), { .parse = dict_read_process_begin_protocol } },
3197 { L("BEGIN-VENDOR"), { .parse = dict_read_process_begin_vendor } },
3198 { L("DEFINE"), { .parse = dict_read_process_define } },
3199 { L("END"), { .parse = dict_read_process_end } },
3200 { L("END-PROTOCOL"), { .parse = dict_read_process_end_protocol } },
3201 { L("END-VENDOR"), { .parse = dict_read_process_end_vendor } },
3202 { L("ENUM"), { .parse = dict_read_process_enum } },
3203 { L("FLAGS"), { .parse = dict_read_process_flags } },
3204 { L("MEMBER"), { .parse = dict_read_process_member } },
3205 { L("PROTOCOL"), { .parse = dict_read_process_protocol, .begin = dict_begin_protocol }},
3206 { L("VALUE"), { .parse = dict_read_process_value } },
3207 { L("VENDOR"), { .parse = dict_read_process_vendor } },
3208 };
3209
3210 FILE *fp;
3211 char filename_buf[256];
3212 char buf[256];
3213 char *p;
3214 int line = 0;
3215
3216 struct stat statbuf;
3217 char *argv[DICT_MAX_ARGV];
3218 int argc;
3219
3220 int stack_depth = dctx->stack_depth;
3221
3222 /*
3223 * Base flags are only set for the current file
3224 */
3225 fr_dict_attr_flags_t base_flags = {};
3226
3227 if (!fr_cond_assert(!dctx->dict->root || CURRENT_FRAME(dctx)->da)) return -1;
3228
3229 if ((strlen(dir) + 2 + strlen(filename)) > sizeof(filename_buf)) {
3230 fr_strerror_printf("%s: Filename name too long", "Error reading dictionary");
3231 return -1;
3232 }
3233
3234 /*
3235 * The filename is relative to the current directory.
3236 *
3237 * Ensure that the directory name doesn't end with 2 '/',
3238 * and then create the full path from dir + filename.
3239 */
3240 if (FR_DIR_IS_RELATIVE(filename)) {
3241 char const *q;
3242 bool slash = false;
3243
3244 /*
3245 * We either have to do strcpy + strrchr(), or manual checks.
3246 */
3247 p = filename_buf;
3248 for (q = dir; *q != '\0'; q++) {
3249 if (*q != '/') {
3250 *(p++) = *q;
3251 slash = false;
3252 continue;
3253 }
3254
3255 /*
3256 * Suppress multiple consecutive slashes.
3257 */
3258 if (slash) continue;
3259
3260 *(p++) = *q;
3261 slash = true;
3262 }
3263
3264 if (!slash) *(p++) = '/';
3265 strcpy(p, filename);
3266
3267 filename = filename_buf;
3268 }
3269 /*
3270 * Else we ignore the input directory. We also assume
3271 * that the filename is normalized, and therefore don't
3272 * change it.
3273 */
3274
3275 /*
3276 * See if we have already loaded this filename. If so, suppress it.
3277 */
3278 if (unlikely(dict_filename_loaded(dctx->dict, filename, src_file, src_line))) {
3279 fr_strerror_printf("ERROR - we have a recursive $INCLUDE or load of file %s", filename);
3280 return -1;
3281 }
3282
3283
3284 if ((fp = fopen(filename, "r")) == NULL) {
3285 if (!src_file) {
3286 fr_strerror_printf("Couldn't open dictionary %s: %s", fr_syserror(errno), filename);
3287 } else {
3288 fr_strerror_printf("Error reading dictionary: %s[%d]: Couldn't open dictionary '%s': %s",
3289 fr_cwd_strip(src_file), src_line, filename,
3290 fr_syserror(errno));
3291 }
3292 return -2;
3293 }
3294
3295 /*
3296 * If fopen works, this works.
3297 */
3298 if (fstat(fileno(fp), &statbuf) < 0) {
3299 fr_strerror_printf("Failed stating dictionary \"%s\" - %s", filename, fr_syserror(errno));
3300
3301 perm_error:
3302 fclose(fp);
3303 return -1;
3304 }
3305
3306 if (!S_ISREG(statbuf.st_mode)) {
3307 fr_strerror_printf("Dictionary is not a regular file: %s", filename);
3308 goto perm_error;
3309 }
3310
3311 /*
3312 * Globally writable dictionaries means that users can control
3313 * the server configuration with little difficulty.
3314 */
3315#ifdef S_IWOTH
3316 if (dict_gctx->perm_check && ((statbuf.st_mode & S_IWOTH) != 0)) {
3317 fr_strerror_printf("Dictionary is globally writable: %s. "
3318 "Refusing to start due to insecure configuration", filename);
3319 goto perm_error;
3320 }
3321#endif
3322
3323 /*
3324 * Now that we've opened the file, copy the filename into the dictionary and add it to the ctx
3325 * This string is safe to assign to the filename pointer in any attributes added beneath the
3326 * dictionary.
3327 */
3328 if (unlikely(dict_filename_add(&dctx->filename, dctx->dict, filename, src_file, src_line) < 0)) {
3329 goto perm_error;
3330 }
3331
3332 while (fgets(buf, sizeof(buf), fp) != NULL) {
3333 bool do_begin = false;
3334 fr_dict_keyword_parser_t const *parser;
3335 char **argv_p = argv;
3336
3337 dctx->line = ++line;
3338
3339 switch (buf[0]) {
3340 case '#':
3341 case '\0':
3342 case '\n':
3343 case '\r':
3344 continue;
3345 }
3346
3347 /*
3348 * Comment characters should NOT be appearing anywhere but
3349 * as start of a comment;
3350 */
3351 p = strchr(buf, '#');
3352 if (p) *p = '\0';
3353
3354 argc = fr_dict_str_to_argv(buf, argv, DICT_MAX_ARGV);
3355 if (argc == 0) continue;
3356
3357 if (argc == 1) {
3358 /*
3359 * Be nice.
3360 */
3361 if ((strcmp(argv[0], "BEGIN") == 0) ||
3362 (fr_dict_keyword(&parser, keywords, NUM_ELEMENTS(keywords), argv_p[0], NULL))) {
3363 fr_strerror_printf("Keyword %s is missing all of its arguments", argv[0]);
3364 } else {
3365 fr_strerror_printf("Invalid syntax - unknown keyword %s", argv[0]);
3366 }
3367
3368 error:
3369 fr_strerror_printf_push("Failed parsing dictionary at %s[%d]", fr_cwd_strip(filename), line);
3370 fclose(fp);
3371 return -1;
3372 }
3373
3374 /*
3375 * Special prefix for "beginnable" keywords.
3376 * These are keywords that can automatically change
3377 * the context of subsequent definitions if they're
3378 * prefixed with a BEGIN keyword.
3379 */
3380 if (strcasecmp(argv_p[0], "BEGIN") == 0) {
3381 do_begin = true;
3382 argv_p++;
3383 argc--;
3384 }
3385
3386 if (fr_dict_keyword(&parser, keywords, NUM_ELEMENTS(keywords), argv_p[0], NULL)) {
3387 /*
3388 * We are allowed to have attributes
3389 * named for keywords. Most notably
3390 * "value". If there's no such attribute
3391 * 'value', then the user will get a
3392 * descriptive error.
3393 */
3394 if (do_begin && !parser->begin) {
3395 goto process_begin;
3396 }
3397
3398 if (unlikely(parser->parse(dctx, argv_p + 1 , argc - 1, &base_flags) < 0)) goto error;
3399
3400 /*
3401 * We've processed the definition, now enter the section
3402 */
3403 if (do_begin && unlikely(parser->begin(dctx) < 0)) goto error;
3404 continue;
3405 }
3406
3407 /*
3408 * It's a naked BEGIN keyword
3409 */
3410 if (do_begin) {
3411 process_begin:
3412 if (unlikely(dict_read_process_begin(dctx, argv_p, argc, &base_flags) < 0)) goto error;
3413 continue;
3414 }
3415
3416 /*
3417 * See if we need to import another dictionary.
3418 */
3419 if (strncasecmp(argv_p[0], "$INCLUDE", 8) == 0) {
3420 /*
3421 * Included files operate on a copy of the context.
3422 *
3423 * This copy means that they inherit the
3424 * current context, including parents,
3425 * TLVs, etc. But if the included file
3426 * leaves a "dangling" TLV or "last
3427 * attribute", then it won't affect the
3428 * parent.
3429 */
3430 if (dict_read_process_include(dctx, argv_p, argc, dir) < 0) goto error;
3431 continue;
3432 } /* $INCLUDE */
3433
3434 /*
3435 * Any other string: We don't recognize it.
3436 */
3437 fr_strerror_printf("Invalid keyword '%s'", argv_p[0]);
3438 goto error;
3439 }
3440
3441 /*
3442 * Unwind until the stack depth matches what we had on input.
3443 */
3444 while (dctx->stack_depth > stack_depth) {
3445 dict_tokenize_frame_t *frame = CURRENT_FRAME(dctx);
3446
3447 if (frame->nest == NEST_PROTOCOL) {
3448 fr_strerror_printf("BEGIN-PROTOCOL at %s[%d] is missing END-PROTOCOL",
3449 fr_cwd_strip(frame->filename), line);
3450 goto error;
3451 }
3452
3453 if (frame->nest == NEST_ATTRIBUTE) {
3454 fr_strerror_printf("BEGIN %s at %s[%d] is missing END %s",
3455 frame->da->name, fr_cwd_strip(frame->filename), line,
3456 frame->da->name);
3457 goto error;
3458 }
3459
3460 if (frame->nest == NEST_VENDOR) {
3461 fr_strerror_printf("BEGIN-VENDOR at %s[%d] is missing END-VENDOR",
3462 fr_cwd_strip(frame->filename), line);
3463 goto error;
3464 }
3465
3466 /*
3467 * Run any necessary finalise callback, and then pop the frame.
3468 */
3469 if (frame->finalise) {
3470 if (frame->finalise(dctx) < 0) goto error;
3471 frame->finalise = NULL;
3472 }
3473
3474 fr_assert(!dctx->stack[dctx->stack_depth].finalise);
3475 dctx->stack_depth--;
3476 }
3477
3478 fclose(fp);
3479
3480 return 0;
3481}
3482
3483static int dict_from_file(fr_dict_t *dict,
3484 char const *dir_name, char const *filename,
3485 char const *src_file, int src_line)
3486{
3487 int ret;
3488 dict_tokenize_ctx_t dctx;
3489
3490 memset(&dctx, 0, sizeof(dctx));
3491 dctx.dict = dict;
3492 if (dict_fixup_init(&dctx.fixup) < 0) return -1;
3493 dctx.stack[0].da = dict->root;
3494 dctx.stack[0].nest = NEST_TOP;
3495
3496 ret = _dict_from_file(&dctx, dir_name, filename, src_file, src_line);
3497 if (ret < 0) {
3498 talloc_free(dctx.fixup.pool);
3499 return ret;
3500 }
3501
3502 /*
3503 * Applies to any attributes added to the *internal*
3504 * dictionary.
3505 *
3506 * Fixups should have been applied already to any protocol
3507 * dictionaries.
3508 */
3509 return dict_finalise(&dctx);
3510}
3511
3512/** (Re-)Initialize the special internal dictionary
3513 *
3514 * This dictionary has additional programmatically generated attributes added to it,
3515 * and is checked in addition to the protocol specific dictionaries.
3516 *
3517 * @note The dictionary pointer returned in out must have its reference counter
3518 * decremented with #fr_dict_free when no longer used.
3519 *
3520 * @param[out] out Where to write pointer to the internal dictionary.
3521 * @param[in] dict_subdir name of the internal dictionary dir (may be NULL).
3522 * @param[in] dependent Either C src file, or another dictionary.
3523 * @return
3524 * - 0 on success.
3525 * - -1 on failure.
3526 */
3527int fr_dict_internal_afrom_file(fr_dict_t **out, char const *dict_subdir, char const *dependent)
3528{
3529 fr_dict_t *dict;
3530 char *dict_path = NULL;
3531 size_t i;
3532 fr_dict_attr_flags_t flags = { .internal = true };
3533 char *type_name;
3534 fr_dict_attr_t *cast_base;
3535 fr_value_box_t box = FR_VALUE_BOX_INITIALISER_NULL(box);
3536
3537 if (unlikely(!dict_gctx)) {
3538 fr_strerror_const("fr_dict_global_ctx_init() must be called before loading dictionary files");
3539 return -1;
3540 }
3541
3542 /*
3543 * Increase the reference count of the internal dictionary.
3544 */
3545 if (dict_gctx->internal) {
3546 dict_dependent_add(dict_gctx->internal, dependent);
3547 *out = dict_gctx->internal;
3548 return 0;
3549 }
3550
3551 dict_path = dict_subdir ?
3552 talloc_asprintf(NULL, "%s%c%s", fr_dict_global_ctx_dir(), FR_DIR_SEP, dict_subdir) :
3553 talloc_strdup(NULL, fr_dict_global_ctx_dir());
3554
3555 fr_strerror_clear(); /* Ensure we don't report spurious errors */
3556
3557 dict = dict_alloc(dict_gctx);
3558 if (!dict) {
3559 error:
3560 if (!dict_gctx->internal) talloc_free(dict);
3561 talloc_free(dict_path);
3562 return -1;
3563 }
3564
3565 /*
3566 * Set the root name of the dictionary
3567 */
3568 if (dict_root_set(dict, "internal", 0) < 0) goto error;
3569
3570 if (dict_path && dict_from_file(dict, dict_path, FR_DICTIONARY_FILE, NULL, 0) < 0) goto error;
3571
3572 TALLOC_FREE(dict_path);
3573
3574 dict_dependent_add(dict, dependent);
3575
3576 if (!dict_gctx->internal) {
3577 dict_gctx->internal = dict;
3578 dict_dependent_add(dict, "global");
3579 }
3580
3581 /*
3582 * Try to load libfreeradius-internal, too. If that
3583 * fails (i.e. fuzzers???), ignore it.
3584 */
3585 (void) dict_dlopen(dict, "internal");
3586
3587 cast_base = dict_attr_child_by_num(dict->root, FR_CAST_BASE);
3588 if (!cast_base) {
3589 fr_strerror_printf("Failed to find 'Cast-Base' in internal dictionary");
3590 goto error;
3591 }
3592
3593 fr_assert(cast_base->type == FR_TYPE_UINT8);
3594 fr_value_box_init(&box, FR_TYPE_UINT8, NULL, false);
3595
3596 /*
3597 * Add cast attributes. We do it this way,
3598 * so cast attributes get added automatically for new types.
3599 *
3600 * We manually add the attributes to the dictionary, and bypass
3601 * fr_dict_attr_add(), because we know what we're doing, and
3602 * that function does too many checks.
3603 */
3604 for (i = 0; i < fr_type_table_len; i++) {
3605 fr_dict_attr_t *n;
3606 fr_table_num_ordered_t const *p = &fr_type_table[i];
3607
3608 switch (p->value) {
3609 case FR_TYPE_NULL: /* Can't cast to NULL */
3610 case FR_TYPE_VENDOR: /* Vendors can't exist in dictionaries as attributes */
3611 continue;
3612 }
3613
3614 type_name = talloc_typed_asprintf(NULL, "Tmp-Cast-%s", p->name.str);
3615
3616 n = dict_attr_alloc(dict->pool, dict->root, type_name,
3617 FR_CAST_BASE + p->value, p->value, &(dict_attr_args_t){ .flags = &flags});
3618 if (!n) {
3619 talloc_free(type_name);
3620 goto error;
3621 }
3622
3623 if (dict_attr_add_to_namespace(dict->root, n) < 0) {
3624 fr_strerror_printf_push("Failed inserting '%s' into internal dictionary", type_name);
3625 talloc_free(type_name);
3626 goto error;
3627 }
3628
3629 talloc_free(type_name);
3630
3631 /*
3632 * Set up parenting for the attribute.
3633 */
3634 if (dict_attr_child_add(dict->root, n) < 0) goto error;
3635
3636 /*
3637 * Add the enum, too.
3638 */
3639 box.vb_uint8 = p->value;
3640 if (dict_attr_enum_add_name(cast_base, p->name.str, &box, false, false, NULL) < 0) {
3641 fr_strerror_printf_push("Failed adding '%s' as a VALUE into internal dictionary", p->name.str);
3642 goto error;
3643 }
3644 }
3645
3646 *out = dict;
3647
3648 return 0;
3649}
3650
3651/** (Re)-initialize a protocol dictionary
3652 *
3653 * Initialize the directory, then fix the attr number of all attributes.
3654 *
3655 * @param[out] out Where to write a pointer to the new dictionary. Will free existing
3656 * dictionary if files have changed and *out is not NULL.
3657 * @param[in] proto_name that we're loading the dictionary for.
3658 * @param[in] proto_dir Explicitly set where to hunt for the dictionary files. May be NULL.
3659 * @param[in] dependent Either C src file, or another dictionary.
3660 * @return
3661 * - 0 on success.
3662 * - -1 on failure.
3663 */
3664int fr_dict_protocol_afrom_file(fr_dict_t **out, char const *proto_name, char const *proto_dir, char const *dependent)
3665{
3666 char *dict_dir = NULL;
3667 fr_dict_t *dict;
3668 bool added = false;
3669
3670 *out = NULL;
3671
3672 if (unlikely(!dict_gctx)) {
3673 fr_strerror_const("fr_dict_global_ctx_init() must be called before loading dictionary files");
3674 return -1;
3675 }
3676
3677 if (unlikely(!dict_gctx->internal)) {
3678 fr_strerror_const("Internal dictionary must be initialised before loading protocol dictionaries");
3679 return -1;
3680 }
3681
3682 /*
3683 * Increment the reference count if the dictionary
3684 * has already been loaded and return that.
3685 */
3686 dict = dict_by_protocol_name(proto_name);
3687 if (dict) {
3688 /*
3689 * If we're in the middle of loading this dictionary, then the only way we get back here
3690 * is via a circular reference. So we catch that, and drop the circular dependency.
3691 *
3692 * When we have A->B->A, it means that we don't need to track B->A, because we track
3693 * A->B. And if A is freed, then B is freed.
3694 */
3695 added = true;
3696 dict_dependent_add(dict, dependent);
3697
3698 /*
3699 * But we only return a pre-existing dict if _this function_ has loaded it.
3700 */
3701 if (dict->loaded) {
3702 *out = dict;
3703 return 0;
3704 }
3705
3706 /*
3707 * Set the flag to true _before_ loading the file. That prevents recursion.
3708 */
3709 dict->loaded = true;
3710 }
3711
3712 if (!proto_dir) {
3713 dict_dir = talloc_asprintf(NULL, "%s%c%s", fr_dict_global_ctx_dir(), FR_DIR_SEP, proto_name);
3714 } else {
3715 dict_dir = talloc_asprintf(NULL, "%s%c%s", fr_dict_global_ctx_dir(), FR_DIR_SEP, proto_dir);
3716 }
3717
3718 fr_strerror_clear(); /* Ensure we don't report spurious errors */
3719
3720 /*
3721 * Start in the context of the internal dictionary,
3722 * and switch to the context of a protocol dictionary
3723 * when we hit a BEGIN-PROTOCOL line.
3724 *
3725 * This allows a single file to provide definitions
3726 * for multiple protocols, which'll probably be useful
3727 * at some point.
3728 */
3729 if (dict_from_file(dict_gctx->internal, dict_dir, FR_DICTIONARY_FILE, NULL, 0) < 0) {
3730 error:
3731 if (dict) dict->loading = false;
3732 talloc_free(dict_dir);
3733 return -1;
3734 }
3735
3736 /*
3737 * Check the dictionary actually defined the protocol
3738 */
3739 dict = dict_by_protocol_name(proto_name);
3740 if (!dict) {
3741 fr_strerror_printf("Dictionary \"%s\" missing \"BEGIN-PROTOCOL %s\" declaration", dict_dir, proto_name);
3742 goto error;
3743 }
3744
3745 /*
3746 * Initialize the library.
3747 */
3748 dict->loaded = true;
3749 if (dict->proto && dict->proto->init) {
3750 if (dict->proto->init() < 0) goto error;
3751 }
3752 dict->loading = false;
3753
3754 dict->dir = talloc_steal(dict, dict_dir);
3755
3756 if (!added) dict_dependent_add(dict, dependent);
3757
3758 *out = dict;
3759
3760 return 0;
3761}
3762
3763/* Alloc a new root dictionary attribute
3764 *
3765 * @note Must only be called once per dictionary.
3766 *
3767 * @param[in] proto_name that we're loading the dictionary for.
3768 * @param[in] proto_number The artificial (or IANA allocated) number for the protocol.
3769 * @return
3770 * - A pointer to the new dict context on success.
3771 * - NULL on failure.
3772 */
3773fr_dict_t *fr_dict_alloc(char const *proto_name, unsigned int proto_number)
3774{
3775 fr_dict_t *dict;
3776
3777 if (unlikely(!dict_gctx)) {
3778 fr_strerror_printf("fr_dict_global_ctx_init() must be called before loading dictionary files");
3779 return NULL;
3780 }
3781
3782 /*
3783 * Alloc dict instance.
3784 */
3785 dict = dict_alloc(dict_gctx);
3786 if (!dict) return NULL;
3787
3788 /*
3789 * Set the root name of the dictionary
3790 */
3791 if (dict_root_set(dict, proto_name, proto_number) < 0) {
3792 talloc_free(dict);
3793 return NULL;
3794 }
3795
3796 return dict;
3797}
3798
3799/** Read supplementary attribute definitions into an existing dictionary
3800 *
3801 * @param[in] dict Existing dictionary.
3802 * @param[in] dir dictionary is located in.
3803 * @param[in] filename of the dictionary.
3804 * @return
3805 * - 0 on success.
3806 * - -1 on failure.
3807 */
3808int fr_dict_read(fr_dict_t *dict, char const *dir, char const *filename)
3809{
3810 INTERNAL_IF_NULL(dict, -1);
3811
3812 if (!dir) dir = dict->dir;
3813
3814 if (unlikely(dict->read_only)) {
3815 fr_strerror_printf("%s dictionary has been marked as read only", fr_dict_root(dict)->name);
3816 return -1;
3817 }
3818
3819 if (!dict->vendors_by_name) {
3820 fr_strerror_printf("%s: Must initialise dictionary before calling fr_dict_read()", __FUNCTION__);
3821 return -1;
3822 }
3823
3824 return dict_from_file(dict, dir, filename, NULL, 0);
3825}
3826
3827/*
3828 * External API for testing
3829 */
3830int fr_dict_parse_str(fr_dict_t *dict, char const *input, fr_dict_attr_t const *parent)
3831{
3832 int argc;
3833 char *argv[DICT_MAX_ARGV];
3834 int ret;
3835 fr_dict_attr_flags_t base_flags = {};
3836 dict_tokenize_ctx_t dctx;
3837 char *buf;
3838
3839 INTERNAL_IF_NULL(dict, -1);
3840
3841 /*
3842 * str_to_argv() mangles the input buffer, which messes with 'unit_test_attribute -w foo'
3843 */
3844 buf = talloc_strdup(NULL, input);
3845
3846 argc = fr_dict_str_to_argv(buf, argv, DICT_MAX_ARGV);
3847 if (argc == 0) {
3848 talloc_free(buf);
3849 return 0;
3850 }
3851
3852 memset(&dctx, 0, sizeof(dctx));
3853 dctx.dict = dict;
3854
3855 dctx.stack[0].da = parent;
3856 dctx.stack[0].nest = NEST_TOP;
3857
3858 if (dict_fixup_init(&dctx.fixup) < 0) {
3859 error:
3860 TALLOC_FREE(dctx.fixup.pool);
3861 talloc_free(buf);
3862 return -1;
3863 }
3864
3865 if (strcasecmp(argv[0], "VALUE") == 0) {
3866 if (argc < 4) {
3867 fr_strerror_printf("VALUE needs at least 4 arguments, got %i", argc);
3868 goto error;
3869 }
3870
3871 if (!fr_dict_attr_by_oid(NULL, fr_dict_root(dict), argv[1])) {
3872 fr_strerror_printf("Attribute '%s' does not exist in dictionary \"%s\"",
3873 argv[1], dict->root->name);
3874 goto error;
3875 }
3876 ret = dict_read_process_value(&dctx, argv + 1, argc - 1, &base_flags);
3877
3878 } else if (strcasecmp(argv[0], "ATTRIBUTE") == 0) {
3879 if (parent != dict->root) {
3880 (void) dict_dctx_push(&dctx, parent, NEST_NONE);
3881 }
3882
3883 ret = dict_read_process_attribute(&dctx,
3884 argv + 1, argc - 1, &base_flags);
3885
3886 } else if (strcasecmp(argv[0], "DEFINE") == 0) {
3887 if (parent != dict->root) {
3888 (void) dict_dctx_push(&dctx, parent, NEST_NONE);
3889 }
3890
3891 ret = dict_read_process_define(&dctx,
3892 argv + 1, argc - 1, &base_flags);
3893
3894 } else if (strcasecmp(argv[0], "VENDOR") == 0) {
3895 ret = dict_read_process_vendor(&dctx, argv + 1, argc - 1, &base_flags);
3896
3897 } else {
3898 fr_strerror_printf("Invalid input '%s'", argv[0]);
3899 goto error;
3900 }
3901
3902 if (ret < 0) goto error;
3903
3904 talloc_free(buf);
3905
3906 return dict_finalise(&dctx);
3907}
buffer
static int const char char buffer[256]
Definition acutest.h:578
file
int const char * file
Definition acutest.h:704
n
int n
Definition acutest.h:579
strcpy
strcpy(log_entry->msg, buffer)
line
int const char int line
Definition acutest.h:704
UNCONST
#define UNCONST(_type, _ptr)
Remove const qualification from a pointer.
Definition build.h:167
RCSID
#define RCSID(id)
Definition build.h:487
L
#define L(_str)
Helper for initialising arrays of string literals.
Definition build.h:209
NDEBUG_UNUSED
#define NDEBUG_UNUSED
Definition build.h:328
DIAG_ON
#define DIAG_ON(_x)
Definition build.h:462
unlikely
#define unlikely(_x)
Definition build.h:383
UNUSED
#define UNUSED
Definition build.h:317
NUM_ELEMENTS
#define NUM_ELEMENTS(_t)
Definition build.h:339
DIAG_OFF
#define DIAG_OFF(_x)
Definition build.h:461
fr_cond_assert
#define fr_cond_assert(_x)
Calls panic_action ifndef NDEBUG, else logs error and evaluates to value of _x.
Definition debug.h:131
FR_FAULT_LOG
#define FR_FAULT_LOG(_fmt,...)
Definition debug.h:50
fr_cond_assert_msg
#define fr_cond_assert_msg(_x, _fmt,...)
Calls panic_action ifndef NDEBUG, else logs error and evaluates to value of _x.
Definition debug.h:148
fr_dict_attr_add_initialised
int fr_dict_attr_add_initialised(fr_dict_attr_t *da)
A variant of fr_dict_attr_t that allows a pre-allocated, populated fr_dict_attr_t to be added.
Definition dict_util.c:1846
fr_dict_enum_name_from_substr
fr_slen_t fr_dict_enum_name_from_substr(fr_sbuff_t *out, fr_sbuff_parse_error_t *err, fr_sbuff_t *in, fr_sbuff_term_t const *tt)
Extract an enumeration name from a string.
Definition dict_util.c:3822
fr_dict_enum_add_name
int fr_dict_enum_add_name(fr_dict_attr_t *da, char const *name, fr_value_box_t const *value, bool coerce, bool replace)
Add a value name.
Definition dict_util.c:2218
fr_dict_vendor_t::name
char const * name
Vendor name.
Definition dict.h:276
fr_dict_attr_flags_t::is_root
unsigned int is_root
Is root of a dictionary.
Definition dict.h:77
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:2314
fr_dict_protocol_reference
int fr_dict_protocol_reference(fr_dict_attr_t const **da_p, fr_dict_attr_t const *root, fr_sbuff_t *in)
Resolve a reference string to a dictionary attribute.
Definition dict_fixup.c:135
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:3529
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:4916
fr_dict_attr_by_oid_legacy
fr_slen_t fr_dict_attr_by_oid_legacy(fr_dict_attr_t const **parent, unsigned int *attr, char const *oid)
Get the leaf attribute of an OID string.
Definition dict_util.c:2400
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:2666
fr_dict_flag_parser_rule_s::func
fr_dict_flag_parse_func_t func
Custom parsing function to convert a flag value string to a C type value.
Definition dict.h:397
fr_dict_attr_flags_t::internal
unsigned int internal
Internal attribute, should not be received in protocol packets, should not be encoded.
Definition dict.h:90
DA_VERIFY
#define DA_VERIFY(_x)
Definition dict.h:68
da_is_bit_field
#define da_is_bit_field(_da)
Definition dict.h:173
fr_dict_vendor_t::pen
uint32_t pen
Private enterprise number.
Definition dict.h:272
da_is_length_field
#define da_is_length_field(_da)
Definition dict.h:174
fr_dict_global_ctx_dir
char const * fr_dict_global_ctx_dir(void)
Definition dict_util.c:4811
FR_DICT_ATTR_EXT_ENUMV
@ FR_DICT_ATTR_EXT_ENUMV
Enumeration values.
Definition dict.h:190
FR_DICT_ATTR_EXT_REF
@ FR_DICT_ATTR_EXT_REF
Attribute references another attribute and/or dictionary.
Definition dict.h:186
FR_DICT_ATTR_EXT_KEY
@ FR_DICT_ATTR_EXT_KEY
UNION attribute references a key.
Definition dict.h:188
fr_dict_vendor_by_name
fr_dict_vendor_t const * fr_dict_vendor_by_name(fr_dict_t const *dict, char const *name)
Look up a vendor by its name.
Definition dict_util.c:2923
fr_dict_flag_parser_rule_s::needs_value
bool needs_value
This parsing flag must have a value. Else we error.
Definition dict.h:399
fr_dict_attr_by_oid
fr_dict_attr_t const * fr_dict_attr_by_oid(fr_dict_attr_err_t *err, fr_dict_attr_t const *parent, char const *oid))
Resolve an attribute using an OID string.
Definition dict_util.c:2639
fr_dict_vendor_by_num
fr_dict_vendor_t const * fr_dict_vendor_by_num(fr_dict_t const *dict, uint32_t vendor_pen)
Look up a vendor by its PEN.
Definition dict_util.c:2946
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:3594
fr_dict_attr_is_key_field
#define fr_dict_attr_is_key_field(_da)
Definition dict.h:172
fr_dict_attr_cmp_fields
static int8_t fr_dict_attr_cmp_fields(const fr_dict_attr_t *a, const fr_dict_attr_t *b)
Compare two dictionary attributes by their contents.
Definition dict.h:693
FLAG_LENGTH_UINT8
@ FLAG_LENGTH_UINT8
string / octets type is prefixed by uint8 of length
Definition dict.h:168
FLAG_LENGTH_UINT16
@ FLAG_LENGTH_UINT16
string / octets type is prefixed by uint16 of length
Definition dict.h:169
FLAG_KEY_FIELD
@ FLAG_KEY_FIELD
this is a key field for a subsequent struct
Definition dict.h:166
FLAG_BIT_FIELD
@ FLAG_BIT_FIELD
bit field inside of a struct
Definition dict.h:167
fr_dict_attr_flags_t
Values of the encryption flags.
Definition merged_model.c:139
fr_dict_flag_parser_rule_s
Definition dict.h:396
fr_dict_flag_parser_t
Protocol specific custom flag definitnion.
Definition dict.h:427
fr_dict_vendor_t
Private enterprise.
Definition dict.h:271
fr_dict_attr_ref_type
#define fr_dict_attr_ref_type(_type)
Definition dict_ext.h:72
fr_dict_attr_ext_ref_t::type
fr_dict_attr_ref_type_t type
The state of the reference.
Definition dict_ext.h:78
fr_dict_attr_ext
static void * fr_dict_attr_ext(fr_dict_attr_t const *da, fr_dict_attr_ext_t ext)
Definition dict_ext.h:121
fr_dict_attr_ref_is_unresolved
#define fr_dict_attr_ref_is_unresolved(_type)
Definition dict_ext.h:71
FR_DICT_ATTR_REF_ENUM
@ FR_DICT_ATTR_REF_ENUM
The attribute is an enumeration value.
Definition dict_ext.h:63
FR_DICT_ATTR_REF_KEY
@ FR_DICT_ATTR_REF_KEY
it is a UNION which has a ref to a key, and children.
Definition dict_ext.h:64
FR_DICT_ATTR_REF_ALIAS
@ FR_DICT_ATTR_REF_ALIAS
The attribute is an alias for another attribute.
Definition dict_ext.h:59
FR_DICT_ATTR_REF_CLONE
@ FR_DICT_ATTR_REF_CLONE
The attribute is a "copy" of another attribute.
Definition dict_ext.h:62
fr_dict_attr_ext_ref_t
Attribute extension - Holds a reference to an attribute in another dictionary.
Definition dict_ext.h:77
dict_attr_ref_set
static int dict_attr_ref_set(fr_dict_attr_t const *da, fr_dict_attr_t const *ref, fr_dict_attr_ref_type_t type)
Definition dict_ext_priv.h:172
dict_attr_ref_aunresolved
static int dict_attr_ref_aunresolved(fr_dict_attr_t **da_p, char const *ref, fr_dict_attr_ref_type_t type)
Definition dict_ext_priv.h:223
dict_attr_ext_alloc
static void * dict_attr_ext_alloc(fr_dict_attr_t **da_p, fr_dict_attr_ext_t ext)
Allocate an attribute extension.
Definition dict_ext_priv.h:68
dict_fixup_apply
int dict_fixup_apply(dict_fixup_ctx_t *fctx)
Apply all outstanding fixes to a set of dictionaries.
Definition dict_fixup.c:810
dict_fixup_enumv_enqueue
int dict_fixup_enumv_enqueue(dict_fixup_ctx_t *fctx, char const *filename, int line, char const *attr, size_t attr_len, char const *name, size_t name_len, char const *value, size_t value_len, fr_dict_attr_t const *parent)
Add an enumeration value to an attribute which has not yet been defined.
Definition dict_fixup.c:275
dict_fixup_alias_enqueue
int dict_fixup_alias_enqueue(dict_fixup_ctx_t *fctx, char const *filename, int line, fr_dict_attr_t *alias_parent, char const *alias, fr_dict_attr_t *ref_parent, char const *ref)
Resolve a group reference.
Definition dict_fixup.c:737
dict_fixup_clone_enqueue
int dict_fixup_clone_enqueue(dict_fixup_ctx_t *fctx, fr_dict_attr_t *da, char const *ref)
Clone one area of a tree into another.
Definition dict_fixup.c:425
dict_fixup_clone_enum_enqueue
int dict_fixup_clone_enum_enqueue(dict_fixup_ctx_t *fctx, fr_dict_attr_t *da, char const *ref)
Clone enumeration values from one attribute to another.
Definition dict_fixup.c:577
dict_fixup_vsa_enqueue
int dict_fixup_vsa_enqueue(dict_fixup_ctx_t *fctx, fr_dict_attr_t *da)
Push a fixup for a VSA.
Definition dict_fixup.c:676
dict_fixup_clone
int dict_fixup_clone(fr_dict_attr_t **dst_p, fr_dict_attr_t const *src)
Clone a dictionary attribute from a ref.
Definition dict_fixup.c:460
dict_fixup_group_enqueue
int dict_fixup_group_enqueue(dict_fixup_ctx_t *fctx, fr_dict_attr_t *da, char const *ref)
Resolve a group reference.
Definition dict_fixup.c:358
dict_fixup_init
int dict_fixup_init(dict_fixup_ctx_t *fctx)
Initialise a fixup ctx.
Definition dict_fixup.c:790
dict_fixup_ctx_t::pool
TALLOC_CTX * pool
Temporary pool for fixups, reduces holes.
Definition dict_fixup_priv.h:33
dict_fixup_ctx_t
Definition dict_fixup_priv.h:32
dict_attr_enum_add_name
int dict_attr_enum_add_name(fr_dict_attr_t *da, char const *name, fr_value_box_t const *value, bool coerce, bool replace, fr_dict_attr_t const *child_struct)
Definition dict_util.c:2021
dict_attr_type_init
int dict_attr_type_init(fr_dict_attr_t **da_p, fr_type_t type)
Initialise type specific fields within the dictionary attribute.
Definition dict_util.c:552
dict_attr_parent_init
int dict_attr_parent_init(fr_dict_attr_t **da_p, fr_dict_attr_t const *parent)
Initialise fields which depend on a parent attribute.
Definition dict_util.c:639
dict_attr_alloc
#define dict_attr_alloc(_ctx, _parent, _name, _attr, _type, _args)
Definition dict_priv.h:255
dict_alloc
fr_dict_t * dict_alloc(TALLOC_CTX *ctx)
Allocate a new dictionary.
Definition dict_util.c:4178
INTERNAL_IF_NULL
#define INTERNAL_IF_NULL(_dict, _ret)
Set the internal dictionary if none was provided.
Definition dict_priv.h:45
dict_attr_add_to_namespace
int dict_attr_add_to_namespace(fr_dict_attr_t const *parent, fr_dict_attr_t *da)
Add an attribute to the name table for an attribute.
Definition dict_util.c:1780
dict_attr_child_by_num
fr_dict_attr_t * dict_attr_child_by_num(fr_dict_attr_t const *parent, unsigned int attr)
Internal version of fr_dict_attr_child_by_num.
Definition dict_util.c:3547
dict_by_protocol_num
fr_dict_t * dict_by_protocol_num(unsigned int num)
Internal version of fr_dict_by_protocol_num.
Definition dict_util.c:2788
dict_attr_child_add
int dict_attr_child_add(fr_dict_attr_t *parent, fr_dict_attr_t *child)
Add a child to a parent.
Definition dict_util.c:1681
dict_vendor_add
int dict_vendor_add(fr_dict_t *dict, char const *name, unsigned int num)
Add a vendor to the dictionary.
Definition dict_util.c:1586
dict_attr_finalise
int dict_attr_finalise(fr_dict_attr_t **da_p, char const *name)
Set remaining fields in a dictionary attribute before insertion.
Definition dict_util.c:759
dict_attr_num_init
int dict_attr_num_init(fr_dict_attr_t *da, unsigned int num)
Set the attribute number (if any)
Definition dict_util.c:715
dict_attr_num_init_name_only
int dict_attr_num_init_name_only(fr_dict_attr_t *da)
Set the attribute number (if any)
Definition dict_util.c:733
dict_dlopen
int dict_dlopen(fr_dict_t *dict, char const *name)
Definition dict_util.c:3862
dict_by_protocol_name
fr_dict_t * dict_by_protocol_name(char const *name)
Internal version of fr_dict_by_protocol_name.
Definition dict_util.c:2774
FR_DICT_PROTO_LDAP
@ FR_DICT_PROTO_LDAP
Definition dict_priv.h:172
FR_DICT_PROTO_DNS
@ FR_DICT_PROTO_DNS
Definition dict_priv.h:171
FR_DICT_PROTO_RADIUS
@ FR_DICT_PROTO_RADIUS
Definition dict_priv.h:161
FR_DICT_PROTO_SNMP
@ FR_DICT_PROTO_SNMP
Definition dict_priv.h:167
FR_DICT_PROTO_DHCPv4
@ FR_DICT_PROTO_DHCPv4
Definition dict_priv.h:162
FR_DICT_PROTO_DHCPv6
@ FR_DICT_PROTO_DHCPv6
Definition dict_priv.h:163
FR_DICT_PROTO_TACACS
@ FR_DICT_PROTO_TACACS
Definition dict_priv.h:165
FR_DICT_PROTO_TLS
@ FR_DICT_PROTO_TLS
Definition dict_priv.h:170
FR_DICT_PROTO_VMPS
@ FR_DICT_PROTO_VMPS
Definition dict_priv.h:166
FR_DICT_PROTO_ARP
@ FR_DICT_PROTO_ARP
Definition dict_priv.h:168
FR_DICT_PROTO_ETHERNET
@ FR_DICT_PROTO_ETHERNET
Definition dict_priv.h:164
FR_DICT_PROTO_TFTP
@ FR_DICT_PROTO_TFTP
Definition dict_priv.h:169
FR_DICT_PROTO_BFD
@ FR_DICT_PROTO_BFD
Definition dict_priv.h:173
dict_attr_alias_add
int dict_attr_alias_add(fr_dict_attr_t const *parent, char const *alias, fr_dict_attr_t const *ref, bool from_public)
Add an alias to an existing attribute.
Definition dict_util.c:1405
fr_dict_gctx_s::internal
fr_dict_t * internal
Magic internal dictionary.
Definition dict_priv.h:155
dict_attr_alloc_null
fr_dict_attr_t * dict_attr_alloc_null(TALLOC_CTX *ctx, fr_dict_protocol_t const *dict)
Partial initialisation functions.
Definition dict_util.c:990
dict_dependent_add
int dict_dependent_add(fr_dict_t *dict, char const *dependent)
Record a new dependency on a dictionary.
Definition dict_util.c:3953
dict_attr_alloc_root
#define dict_attr_alloc_root(_ctx, _dict, _name, _attr, _args)
Definition dict_priv.h:247
dict_protocol_add
int dict_protocol_add(fr_dict_t *dict)
Add a protocol to the global protocol table.
Definition dict_util.c:1513
dict_gctx
fr_dict_gctx_t * dict_gctx
Top level structure containing global dictionary state.
Definition dict_util.c:42
fr_dict_gctx_s::perm_check
bool perm_check
Whether we should check dictionary file permissions as they're loaded.
Definition dict_priv.h:132
dict_attr_args_t
Optional arguments for initialising/allocating attributes.
Definition dict_priv.h:191
fr_dict_filename_t
Entry in the filename list of files associated with this dictionary.
Definition dict_priv.h:69
value
Test enumeration values.
Definition dict_test.h:92
dict_tokenize_frame_t::finalise
fr_dict_keyword_finalise_t finalise
function to call when popping
Definition dict_tokenize.c:84
fr_dict_filename_loaded
bool fr_dict_filename_loaded(fr_dict_t const *dict, char const *dir, char const *filename)
Definition dict_tokenize.c:3103
dict_flag_flat
static int dict_flag_flat(fr_dict_attr_t **da_p, UNUSED char const *value, UNUSED fr_dict_flag_parser_rule_t const *rule)
"flat"
Definition dict_tokenize.c:561
dict_nest_table
static fr_table_num_sorted_t const dict_nest_table[]
Definition dict_tokenize.c:63
dict_read_process_include
static int dict_read_process_include(dict_tokenize_ctx_t *dctx, char **argv, int argc, char const *dir)
Definition dict_tokenize.c:1264
dict_tokenize_frame_t::nest
dict_nest_t nest
for manual vs automatic begin / end things
Definition dict_tokenize.c:82
dict_tokenize_ctx_s::fixup
dict_fixup_ctx_t fixup
Definition dict_tokenize.c:98
dict_read_process_common
static int dict_read_process_common(dict_tokenize_ctx_t *dctx, fr_dict_attr_t **da_p, fr_dict_attr_t const *parent, char const *name, char const *type_name, char *flag_name, fr_dict_attr_flags_t const *base_flags)
Definition dict_tokenize.c:1153
NEST_ANY
#define NEST_ANY
Definition dict_tokenize.c:61
dict_read_process_attribute
static int dict_read_process_attribute(dict_tokenize_ctx_t *dctx, char **argv, int argc, fr_dict_attr_flags_t *base_flags)
Definition dict_tokenize.c:1503
dict_tokenize_frame_t::member_num
int member_num
structure member numbers
Definition dict_tokenize.c:85
dict_filename_add
static int dict_filename_add(char **filename_out, fr_dict_t *dict, char const *filename, char const *src_file, int src_line)
Maintain a linked list of filenames which we've seen loading this dictionary.
Definition dict_tokenize.c:3056
dict_process_type_field
static int dict_process_type_field(dict_tokenize_ctx_t *dctx, char const *name, fr_dict_attr_t **da_p)
Definition dict_tokenize.c:341
dict_read_process_alias
static int dict_read_process_alias(dict_tokenize_ctx_t *dctx, char **argv, int argc, UNUSED fr_dict_attr_flags_t *base_flags)
Definition dict_tokenize.c:1424
_dict_from_file
static int _dict_from_file(dict_tokenize_ctx_t *dctx, char const *dir_name, char const *filename, char const *src_file, int src_line)
fr_dict_keyword_parser_t::begin
fr_dict_section_begin_t begin
Can have a BEGIN prefix.
Definition dict_tokenize.c:3164
dict_attr_allow_dup
static int dict_attr_allow_dup(fr_dict_attr_t const *da)
Check if this definition is a duplicate, and if it is, whether we should skip it error out.
Definition dict_tokenize.c:1039
fr_dict_parse_str
int fr_dict_parse_str(fr_dict_t *dict, char const *input, fr_dict_attr_t const *parent)
Definition dict_tokenize.c:3830
dict_finalise
static int dict_finalise(dict_tokenize_ctx_t *dctx)
Definition dict_tokenize.c:930
dict_read_process_member
static int dict_read_process_member(dict_tokenize_ctx_t *dctx, char **argv, int argc, fr_dict_attr_flags_t *base_flags)
Definition dict_tokenize.c:2403
fr_dict_alloc
fr_dict_t * fr_dict_alloc(char const *proto_name, unsigned int proto_number)
Definition dict_tokenize.c:3773
dict_flag_ref
static int dict_flag_ref(fr_dict_attr_t **da_p, char const *value, UNUSED fr_dict_flag_parser_rule_t const *rule)
Definition dict_tokenize.c:731
dict_flag_precision
static int dict_flag_precision(fr_dict_attr_t **da_p, char const *value, UNUSED fr_dict_flag_parser_rule_t const *rule)
Definition dict_tokenize.c:706
dict_proto_table
static fr_table_num_ordered_t const dict_proto_table[]
The main protocols that we care about.
Definition dict_tokenize.c:2844
dict_read_process_end
static int dict_read_process_end(dict_tokenize_ctx_t *dctx, char **argv, int argc, UNUSED fr_dict_attr_flags_t *base_flags)
Definition dict_tokenize.c:2121
dict_tokenize_ctx_s::stack_depth
int stack_depth
points to the last used stack frame
Definition dict_tokenize.c:94
dict_tokenize_frame_t::struct_size
ssize_t struct_size
size of the struct.
Definition dict_tokenize.c:87
dict_read_sscanf_i
static bool dict_read_sscanf_i(unsigned int *pvalue, char const *str)
Definition dict_tokenize.c:271
dict_tokenize_frame_t::struct_is_closed
fr_dict_attr_t const * struct_is_closed
no more members are allowed
Definition dict_tokenize.c:86
dict_tokenize_ctx_s::filename
char * filename
current filename
Definition dict_tokenize.c:100
fr_dict_keyword_parse_t
int(* fr_dict_keyword_parse_t)(dict_tokenize_ctx_t *dctx, char **argv, int argc, fr_dict_attr_flags_t *base_flags)
Keyword parser.
Definition dict_tokenize.c:3142
dict_read_process_vendor
static int dict_read_process_vendor(dict_tokenize_ctx_t *dctx, char **argv, int argc, UNUSED fr_dict_attr_flags_t *base_flags)
Definition dict_tokenize.c:2787
fr_dict_protocol_afrom_file
int fr_dict_protocol_afrom_file(fr_dict_t **out, char const *proto_name, char const *proto_dir, char const *dependent)
(Re)-initialize a protocol dictionary
Definition dict_tokenize.c:3664
fr_dict_section_begin_t
int(* fr_dict_section_begin_t)(dict_tokenize_ctx_t *dctx)
Pushes a new frame onto the top of the stack based on the current frame.
Definition dict_tokenize.c:3160
fr_dict_str_to_argv
int fr_dict_str_to_argv(char *str, char **argv, int max_argc)
Definition dict_tokenize.c:234
dict_read_process_define
static int dict_read_process_define(dict_tokenize_ctx_t *dctx, char **argv, int argc, fr_dict_attr_flags_t *base_flags)
Definition dict_tokenize.c:1997
dict_nest_table_len
static size_t const dict_nest_table_len
Definition dict_tokenize.c:70
dict_read_parse_format
static int dict_read_parse_format(char const *format, int *ptype, int *plength, bool *pcontinuation)
Definition dict_tokenize.c:1353
dict_read_process_begin_vendor
static int dict_read_process_begin_vendor(dict_tokenize_ctx_t *dctx, char **argv, int argc, UNUSED fr_dict_attr_flags_t *base_flags)
Definition dict_tokenize.c:1879
ASSERT_CURRENT_NEST
#define ASSERT_CURRENT_NEST(_dctx, _nest)
Definition dict_tokenize.c:113
dict_dctx_unwind_until
static dict_tokenize_frame_t const * dict_dctx_unwind_until(dict_tokenize_ctx_t *dctx, dict_nest_t nest)
Unwind the stack until it points to a particular type of stack frame.
Definition dict_tokenize.c:185
dict_from_file
static int dict_from_file(fr_dict_t *dict, char const *dir_name, char const *filename, char const *src_file, int src_line)
Definition dict_tokenize.c:3483
dict_tokenize_frame_t::da
fr_dict_attr_t const * da
the da we care about
Definition dict_tokenize.c:81
dict_tokenize_ctx_s::value_attr
fr_dict_attr_t * value_attr
Cache of last attribute to speed up value processing.
Definition dict_tokenize.c:96
dict_read_process_protocol
static int dict_read_process_protocol(dict_tokenize_ctx_t *dctx, char **argv, int argc, UNUSED fr_dict_attr_flags_t *base_flag)
Register the specified dictionary as a protocol dictionary.
Definition dict_tokenize.c:2865
FLAG_FUNC
#define FLAG_FUNC(_name)
Define a flag setting function, which sets one bit in a fr_dict_attr_flags_t.
Definition dict_tokenize.c:494
CURRENT_LINE
#define CURRENT_LINE(_dctx)
Definition dict_tokenize.c:111
dict_dctx_pop
static dict_tokenize_frame_t const * dict_dctx_pop(dict_tokenize_ctx_t *dctx)
Pop the current stack frame.
Definition dict_tokenize.c:168
dict_tokenize_frame_t::filename
char * filename
name of the file where we read this entry
Definition dict_tokenize.c:79
dict_set_value_attr
static int dict_set_value_attr(dict_tokenize_ctx_t *dctx, fr_dict_attr_t *da)
Definition dict_tokenize.c:1131
dict_read_process_enum
static int dict_read_process_enum(dict_tokenize_ctx_t *dctx, char **argv, int argc, fr_dict_attr_flags_t *base_flags)
Definition dict_tokenize.c:2273
dict_tokenize_ctx_s::line
int line
current line
Definition dict_tokenize.c:101
CURRENT_FILENAME
#define CURRENT_FILENAME(_dctx)
Definition dict_tokenize.c:110
dict_struct_finalise
static int dict_struct_finalise(dict_tokenize_ctx_t *dctx)
Definition dict_tokenize.c:1096
dict_flag_offset
static int dict_flag_offset(fr_dict_attr_t **da_p, char const *value, UNUSED fr_dict_flag_parser_rule_t const *rule)
Definition dict_tokenize.c:681
dict_read_process_begin_protocol
static int dict_read_process_begin_protocol(dict_tokenize_ctx_t *dctx, char **argv, int argc, UNUSED fr_dict_attr_flags_t *base_flags)
Definition dict_tokenize.c:1826
dict_flag_key
static int dict_flag_key(fr_dict_attr_t **da_p, char const *value, UNUSED fr_dict_flag_parser_rule_t const *rule)
Definition dict_tokenize.c:580
dict_tokenize_ctx_s::dict
fr_dict_t * dict
Protocol dictionary we're inserting attributes into.
Definition dict_tokenize.c:91
dict_begin_protocol
static int dict_begin_protocol(NDEBUG_UNUSED dict_tokenize_ctx_t *dctx)
Process an inline BEGIN PROTOCOL block.
Definition dict_tokenize.c:3118
dict_flag_clone
static int dict_flag_clone(fr_dict_attr_t **da_p, char const *value, UNUSED fr_dict_flag_parser_rule_t const *rules)
Definition dict_tokenize.c:503
dict_tokenize_ctx_s::stack
dict_tokenize_frame_t stack[DICT_MAX_STACK]
stack of attributes to track
Definition dict_tokenize.c:93
dict_tokenize_frame_t::line
int line
line number where we read this entry
Definition dict_tokenize.c:80
dict_flag_enum
static int dict_flag_enum(fr_dict_attr_t **da_p, char const *value, UNUSED fr_dict_flag_parser_rule_t const *rule)
Definition dict_tokenize.c:535
dict_dctx_unwind
static dict_tokenize_frame_t const * dict_dctx_unwind(dict_tokenize_ctx_t *dctx)
Definition dict_tokenize.c:225
CURRENT_DA
#define CURRENT_DA(_dctx)
Definition dict_tokenize.c:109
DICT_MAX_ARGV
#define DICT_MAX_ARGV
Maximum number of arguments.
Definition dict_tokenize.c:39
dict_read_process_value
static int dict_read_process_value(dict_tokenize_ctx_t *dctx, char **argv, int argc, UNUSED fr_dict_attr_flags_t *base_flags)
Process a value alias.
Definition dict_tokenize.c:2657
dict_dctx_find_frame
static dict_tokenize_frame_t const * dict_dctx_find_frame(dict_tokenize_ctx_t *dctx, dict_nest_t nest)
Definition dict_tokenize.c:132
dict_proto_table_len
static size_t const dict_proto_table_len
Definition dict_tokenize.c:2859
fr_dict_keyword_t::value
fr_dict_keyword_parser_t value
Value to return from lookup.
Definition dict_tokenize.c:3169
dict_flag_length
static int dict_flag_length(fr_dict_attr_t **da_p, char const *value, UNUSED fr_dict_flag_parser_rule_t const *rule)
Definition dict_tokenize.c:658
dict_filename_loaded
static bool dict_filename_loaded(fr_dict_t const *dict, char const *filename, char const *src_file, int src_line)
See if we have already loaded the file,.
Definition dict_tokenize.c:3084
dict_read_process_end_vendor
static int dict_read_process_end_vendor(dict_tokenize_ctx_t *dctx, char **argv, int argc, UNUSED fr_dict_attr_flags_t *base_flags)
Definition dict_tokenize.c:2232
fr_dict_read
int fr_dict_read(fr_dict_t *dict, char const *dir, char const *filename)
Read supplementary attribute definitions into an existing dictionary.
Definition dict_tokenize.c:3808
DICT_MAX_STACK
#define DICT_MAX_STACK
Maximum stack size.
Definition dict_tokenize.c:45
dict_flag_subtype
static int dict_flag_subtype(fr_dict_attr_t **da_p, char const *value, UNUSED fr_dict_flag_parser_rule_t const *rule)
Definition dict_tokenize.c:765
dict_read_process_begin
static int dict_read_process_begin(dict_tokenize_ctx_t *dctx, char **argv, int argc, UNUSED fr_dict_attr_flags_t *base_flags)
Definition dict_tokenize.c:1771
fr_dict_internal_afrom_file
int fr_dict_internal_afrom_file(fr_dict_t **out, char const *dict_subdir, char const *dependent)
(Re-)Initialize the special internal dictionary
Definition dict_tokenize.c:3527
dict_dctx_push
static int dict_dctx_push(dict_tokenize_ctx_t *dctx, fr_dict_attr_t const *da, dict_nest_t nest)
Definition dict_tokenize.c:143
dict_read_process_flags
static int dict_read_process_flags(UNUSED dict_tokenize_ctx_t *dctx, char **argv, int argc, fr_dict_attr_flags_t *base_flags)
Definition dict_tokenize.c:2376
dict_attr_add_or_fixup
static int dict_attr_add_or_fixup(dict_fixup_ctx_t *fixup, fr_dict_attr_t **da_p)
Add an attribute to the dictionary, or add it to a list of attributes to clone later.
Definition dict_tokenize.c:956
fr_dict_keyword_finalise_t
int(* fr_dict_keyword_finalise_t)(dict_tokenize_ctx_t *dctx)
Definition dict_tokenize.c:72
CURRENT_FRAME
#define CURRENT_FRAME(_dctx)
Definition dict_tokenize.c:108
dict_attr_location_set
static void dict_attr_location_set(dict_tokenize_ctx_t *dctx, fr_dict_attr_t *da)
Definition dict_tokenize.c:941
dict_tokenize_ctx_s::relative_attr
fr_dict_attr_t const * relative_attr
for ".82" instead of "1.2.3.82". only for parents of type "tlv"
Definition dict_tokenize.c:97
dict_flag_secret
static int dict_flag_secret(fr_dict_attr_t **da_p, UNUSED char const *value, UNUSED fr_dict_flag_parser_rule_t const *rule)
Definition dict_tokenize.c:751
fr_dict_keyword_t::name
fr_table_elem_name_t name
Name of the keyword, e.g. "ATTRIBUTE".
Definition dict_tokenize.c:3168
dict_read_process_end_protocol
static int dict_read_process_end_protocol(dict_tokenize_ctx_t *dctx, char **argv, int argc, UNUSED fr_dict_attr_flags_t *base_flags)
Definition dict_tokenize.c:2175
fr_dict_keyword_parser_t::parse
fr_dict_keyword_parse_t parse
Function to parse the keyword with.
Definition dict_tokenize.c:3163
dict_dctx_debug
void dict_dctx_debug(dict_tokenize_ctx_t *dctx)
Definition dict_tokenize.c:116
dict_nest_t
dict_nest_t
This represents explicit BEGIN/END frames pushed onto the stack.
Definition dict_tokenize.c:52
NEST_TOP
@ NEST_TOP
top of the stack
Definition dict_tokenize.c:54
NEST_VENDOR
@ NEST_VENDOR
BEGIN-VENDOR.
Definition dict_tokenize.c:56
NEST_PROTOCOL
@ NEST_PROTOCOL
BEGIN-PROTOCOL.
Definition dict_tokenize.c:55
NEST_ATTRIBUTE
@ NEST_ATTRIBUTE
BEGIN foo.
Definition dict_tokenize.c:57
NEST_NONE
@ NEST_NONE
Definition dict_tokenize.c:53
dict_root_set
static int dict_root_set(fr_dict_t *dict, char const *name, unsigned int proto_number)
Set a new root dictionary attribute.
Definition dict_tokenize.c:316
dict_tokenize_ctx_s
Definition dict_tokenize.c:90
dict_tokenize_frame_t
Parser context for dict_from_file.
Definition dict_tokenize.c:78
fr_dict_keyword_parser_t
Definition dict_tokenize.c:3162
fr_dict_keyword_t
Definition dict_tokenize.c:3167
fr_dlist_head
static void * fr_dlist_head(fr_dlist_head_t const *list_head)
Return the HEAD item of a list or NULL if the list is empty.
Definition dlist.h:468
fr_dlist_insert_tail
static int fr_dlist_insert_tail(fr_dlist_head_t *list_head, void *ptr)
Insert an item into the tail of a list.
Definition dlist.h:360
fr_dlist_next
static void * fr_dlist_next(fr_dlist_head_t const *list_head, void const *ptr)
Get the next item in a list.
Definition dlist.h:537
talloc_free
talloc_free(hp)
fr_globdir_iter_init
int fr_globdir_iter_init(char const **filename, char const *dir, char const *pattern, fr_globdir_iter_t *iter)
Initialize an iterator over filenames.
Definition file.c:694
fr_globdir_iter_next
int fr_globdir_iter_next(char const **filename, fr_globdir_iter_t *iter)
Get the next filename.
Definition file.c:852
fr_cwd_strip
char const * fr_cwd_strip(char const *filename)
Intended to be used in logging functions to make output more readable.
Definition file.c:384
fr_globdir_iter_free
int fr_globdir_iter_free(fr_globdir_iter_t *iter)
Definition file.c:886
fr_globdir_iter_t
Definition file.h:86
stack_depth
static int stack_depth
Definition radmin.c:157
fr_type_t
fr_type_t
Definition merged_model.c:80
FR_TYPE_TIME_DELTA
@ FR_TYPE_TIME_DELTA
A period of time measured in nanoseconds.
Definition merged_model.c:113
FR_TYPE_TLV
@ FR_TYPE_TLV
Contains nested attributes.
Definition merged_model.c:118
FR_TYPE_STRING
@ FR_TYPE_STRING
String of printable characters.
Definition merged_model.c:83
FR_TYPE_NULL
@ FR_TYPE_NULL
Invalid (uninitialised) attribute type.
Definition merged_model.c:81
FR_TYPE_UINT16
@ FR_TYPE_UINT16
16 Bit unsigned integer.
Definition merged_model.c:98
FR_TYPE_INT64
@ FR_TYPE_INT64
64 Bit signed integer.
Definition merged_model.c:106
FR_TYPE_INT16
@ FR_TYPE_INT16
16 Bit signed integer.
Definition merged_model.c:104
FR_TYPE_DATE
@ FR_TYPE_DATE
Unix time stamp, always has value >2^31.
Definition merged_model.c:111
FR_TYPE_UINT8
@ FR_TYPE_UINT8
8 Bit unsigned integer.
Definition merged_model.c:97
FR_TYPE_UINT32
@ FR_TYPE_UINT32
32 Bit unsigned integer.
Definition merged_model.c:99
FR_TYPE_STRUCT
@ FR_TYPE_STRUCT
like TLV, but without T or L, and fixed-width children
Definition merged_model.c:119
FR_TYPE_INT32
@ FR_TYPE_INT32
32 Bit signed integer.
Definition merged_model.c:105
FR_TYPE_VENDOR
@ FR_TYPE_VENDOR
Attribute that represents a vendor in the attribute tree.
Definition merged_model.c:122
FR_TYPE_UINT64
@ FR_TYPE_UINT64
64 Bit unsigned integer.
Definition merged_model.c:100
FR_TYPE_BOOL
@ FR_TYPE_BOOL
A truth value.
Definition merged_model.c:95
FR_TYPE_VSA
@ FR_TYPE_VSA
Vendor-Specific, for RADIUS attribute 26.
Definition merged_model.c:121
FR_TYPE_OCTETS
@ FR_TYPE_OCTETS
Raw octets.
Definition merged_model.c:84
FR_TYPE_GROUP
@ FR_TYPE_GROUP
A grouping of other attributes.
Definition merged_model.c:124
ssize_t
long int ssize_t
Definition merged_model.c:24
uint8_t
unsigned char uint8_t
Definition merged_model.c:30
fr_slen_t
ssize_t fr_slen_t
Definition merged_model.c:35
fr_dict_attr_t
Definition merged_model.c:133
fr_dict_t
Definition merged_model.c:198
fr_value_box_t
Definition merged_model.c:136
strncasecmp
int strncasecmp(char *s1, char *s2, int n)
Definition missing.c:36
strcasecmp
int strcasecmp(char *s1, char *s2)
Definition missing.c:66
fr_assert
#define fr_assert(_expr)
Definition rad_assert.h:38
name
static char const * name
Definition rlm_redis_ippool_tool.c:156
fr_sbuff_adv_past_allowed
size_t fr_sbuff_adv_past_allowed(fr_sbuff_t *sbuff, size_t len, bool const allowed[static SBUFF_CHAR_CLASS], fr_sbuff_term_t const *tt)
Wind position past characters in the allowed set.
Definition sbuff.c:1810
sbuff_char_class_int
bool const sbuff_char_class_int[SBUFF_CHAR_CLASS]
Definition sbuff.c:68
FR_SBUFF_IN
#define FR_SBUFF_IN(_start, _len_or_end)
FR_SBUFF_IN_STR
#define FR_SBUFF_IN_STR(_start)
snprintf
PUBLIC int snprintf(char *string, size_t length, char *format, va_alist)
Definition snprintf.c:689
type
fr_aka_sim_id_type_t type
Definition state_machine.c:3656
fr_syserror
char const * fr_syserror(int num)
Guaranteed to be thread-safe version of strerror.
Definition syserror.c:243
fr_table_elem_name_t::str
char const * str
Literal string.
Definition table.h:42
fr_table_value_by_str
#define fr_table_value_by_str(_table, _name, _def)
Convert a string to a value using a sorted or ordered table.
Definition table.h:653
fr_table_str_by_value
#define fr_table_str_by_value(_table, _number, _def)
Convert an integer to a string.
Definition table.h:772
TABLE_TYPE_NAME_FUNC_RPTR
#define TABLE_TYPE_NAME_FUNC_RPTR(_func, _our_table_type, _our_name, _our_def_type, _our_out_type)
Create a type-specific name-to-value function.
Definition table.h:144
table_sorted_value_by_str
static void const * table_sorted_value_by_str(void const *table, size_t table_len, size_t element_size, char const *name)
Convert a string to a value using a lexicographically sorted table.
Definition table.h:328
fr_table_num_ordered_t::name
fr_table_elem_name_t name
Definition table.h:58
fr_table_elem_name_t
Definition table.h:41
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_typed_asprintf
char * talloc_typed_asprintf(TALLOC_CTX *ctx, char const *fmt,...)
Call talloc vasprintf, setting the type on the new chunk correctly.
Definition talloc.c:545
talloc_asprintf
#define talloc_asprintf
Definition talloc.h:147
talloc_strdup
#define talloc_strdup(_ctx, _str)
Definition talloc.h:145
fr_time_precision_table
fr_table_num_ordered_t const fr_time_precision_table[]
Definition time.c:46
FR_DICTIONARY_FILE
#define FR_DICTIONARY_FILE
Definition conf.h:7
parent
static fr_slen_t parent
Definition pair.h:858
fr_strerror_clear
void fr_strerror_clear(void)
Clears all pending messages from the talloc pools.
Definition strerror.c:576
fr_strerror_printf
#define fr_strerror_printf(_fmt,...)
Log to thread local error buffer.
Definition strerror.h:64
fr_strerror_printf_push
#define fr_strerror_printf_push(_fmt,...)
Add a message to an existing stack of messages at the tail.
Definition strerror.h:84
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_table_len
size_t fr_type_table_len
Definition types.c:87
fr_type_is_structural
#define fr_type_is_structural(_x)
Definition types.h:393
FR_TYPE_UNION
@ FR_TYPE_UNION
A union of limited children.
Definition types.h:82
FR_TYPE_ATTR
@ FR_TYPE_ATTR
A contains an attribute reference.
Definition types.h:84
fr_type_is_null
#define fr_type_is_null(_x)
Definition types.h:348
fr_type_is_tlv
#define fr_type_is_tlv(_x)
Definition types.h:373
fr_type_is_leaf
#define fr_type_is_leaf(_x)
Definition types.h:394
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:455
fr_type_from_str
static fr_type_t fr_type_from_str(char const *type)
Return the constant value representing a type.
Definition types.h:465
FR_TYPE_LEAF
#define FR_TYPE_LEAF
Definition types.h:318
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:4211
fr_value_box_from_str
ssize_t fr_value_box_from_str(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, char const *in, size_t inlen, fr_sbuff_unescape_rules_t const *erules)
Definition value.c:6079
fr_value_box_clear
void fr_value_box_clear(fr_value_box_t *data)
Clear/free any existing value and metadata.
Definition value.c:4392
FR_VALUE_BOX_INITIALISER_NULL
#define FR_VALUE_BOX_INITIALISER_NULL(_vb)
A static initialiser for stack/globally allocated boxes.
Definition value.h:511
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:610
format
int format(printf, 5, 0))
out
static size_t char ** out
Definition value.h:1024
Generated by   doxygen 1.9.8