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