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