The FreeRADIUS server $Id: 15bac2a4c627c01d1aa2047687b3418955ac7f00 $
Loading...
Searching...
No Matches
dict_fixup.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/** Code to apply fctx and finalisation steps to a dictionary
18 *
19 * @file src/lib/util/dict_fixup.c
20 *
21 * @copyright 2020 The FreeRADIUS server project
22 * @copyright 2020,2024 Arran Cudbard-Bell <a.cudbardb@freeradius.org>
23 */
24RCSID("$Id: 667a92708b794b922cb0e987053244ffcdcc87b5 $")
25
26#include <freeradius-devel/util/dict.h>
27#include <freeradius-devel/util/file.h>
28#include <freeradius-devel/util/value.h>
29
30#include "dict_fixup_priv.h"
31
32/** Common fields for every fixup structure
33 *
34 */
35typedef struct {
36 fr_dlist_t entry; //!< Entry in linked list of fctx.
38
39/** Add an enumeration value to an attribute that wasn't defined at the time the value was parsed
40 *
41 */
42typedef struct {
43 dict_fixup_common_t common; //!< Common fields.
44
45 char *filename; //!< where the line being fixed up.
46 int line; //!< ditto.
47
48 char *alias; //!< we need to create.
49 fr_dict_attr_t *alias_parent; //!< Where to add the alias.
50
51 char *ref; //!< what the alias references.
52 fr_dict_attr_t *ref_parent; //!< Parent attribute to resolve the 'attribute' string in.
54
55/** Add an enumeration value to an attribute that wasn't defined at the time the value was parsed
56 *
57 */
58typedef struct {
59 dict_fixup_common_t common; //!< Common fields.
60
61 char *filename; //!< where the line being fixed up.
62 int line; //!< ditto.
63
64 char *attribute; //!< we couldn't find (and will need to resolve later).
65 char *name; //!< Raw enum name.
66 char *value; //!< Raw enum value. We can't do anything with this until
67 //!< we know the attribute type, which we only find out later.
68
69 fr_dict_attr_t const *parent; //!< Parent attribute to resolve the 'attribute' string in.
71
72/** Resolve a group reference
73 *
74 */
75typedef struct {
76 dict_fixup_common_t common; //!< Common fields.
77
78 fr_dict_attr_t *da; //!< FR_TYPE_GROUP to fix
79 char *ref; //!< the reference name
81
82/** Clone operation from one tree node to another
83 *
84 */
85typedef struct {
86 dict_fixup_common_t common; //!< Common fields.
87
88 fr_dict_attr_t *da; //!< to populate with cloned information.
89 char *ref; //!< the target attribute to clone
91
92/** Run fixup callbacks for a VSA
93 *
94 */
95typedef struct {
96 dict_fixup_common_t common; //!< Common fields.
97
98 fr_dict_attr_t *da; //!< FR_TYPE_VSA to fix
100
101/** Dictionary attribute namespaces need their hash tables finalised
102 *
103 */
104typedef struct {
105 dict_fixup_common_t common; //!< Common fields.
106
107 fr_hash_table_t *hash; //!< We need to finalise.
109
110/** Initialise common fields in fixup struct, and add it to a fixup list
111 *
112 * @param[in] fixup_list to add fixup to.
113 * @param[in] common common header to populate.
114 * @return
115 * - 0 on success.
116 * - -1 on out of memory.
117 */
118static inline CC_HINT(always_inline) int dict_fixup_common(fr_dlist_head_t *fixup_list, dict_fixup_common_t *common)
119{
120 fr_dlist_insert_tail(fixup_list, common);
121
122 return 0;
123}
124
125/** Resolve a reference string to a dictionary attribute
126 *
127 * @param[out] da_p Where the attribute will be stored
128 * @param[in] rel Relative attribute to resolve from.
129 * @param[in] in Reference string.
130 * @return
131 * - <0 on error
132 * - 0 on parse OK, but *da_p is NULL;
133 * - 1 for parse OK, and *da_p is !NULL
134 */
136{
137 fr_dict_t *dict = fr_dict_unconst(rel->dict);
138 fr_dict_attr_t const *da = rel;
139 ssize_t slen;
140
141 *da_p = NULL;
142
143 /*
144 * Are we resolving a foreign reference?
145 */
146 if (fr_sbuff_next_if_char(in, '@')) {
147 char proto_name[FR_DICT_ATTR_MAX_NAME_LEN + 1];
148 fr_sbuff_t proto_name_sbuff = FR_SBUFF_OUT(proto_name, sizeof(proto_name));
149
150 /*
151 * @.foo is "foo from the current root".
152 *
153 * This is a bit clearer than "foo".
154 */
155 if (fr_sbuff_next_if_char(in, '.')) {
156 if (fr_sbuff_is_char(in, '.')) goto above_root;
157
158 da = rel->dict->root;
159 goto more;
160 }
161
162 slen = dict_by_protocol_substr(NULL, &dict, in, NULL);
163 /* Need to load it... */
164 if (slen <= 0) {
165 /* Quiet coverity */
166 fr_sbuff_terminate(&proto_name_sbuff);
167
168 /* Fixme, probably want to limit allowed chars */
169 if (fr_sbuff_out_bstrncpy_until(&proto_name_sbuff, in, SIZE_MAX,
170 &FR_SBUFF_TERMS(L(""), L(".")), NULL) <= 0) {
171 invalid_name:
172 fr_strerror_const("Invalid protocol name");
173 return -1;
174 }
175
176 /*
177 * The filenames are lowercase. The names in the dictionaries are case-insensitive. So
178 * we mash the name to all lowercase.
179 */
180 fr_tolower(proto_name);
181
182 /*
183 * Catch this early, so people don't do stupid things
184 * like put slashes in the references and then claim
185 * it's a security issue.
186 */
187 if (fr_dict_valid_oid_str(proto_name, -1) < 0) goto invalid_name;
188
189 /*
190 * Load the new dictionary, and mark it as loaded from our dictionary.
191 */
192 if (fr_dict_protocol_afrom_file(&dict, proto_name, NULL, (rel->dict)->root->name) < 0) {
193 fr_strerror_printf_push("Perhaps there is a '.' missing before the attribute name in %.*s ?",
195 return -1;
196 }
197
198 if (!fr_hash_table_insert((rel->dict)->autoref, dict)) {
199 fr_strerror_const("Failed inserting into internal autoref table");
200 return -1;
201 }
202 }
203
204 /*
205 * Didn't stop at an attribute ref... we're done
206 */
207 if (fr_sbuff_eof(in)) {
208 *da_p = dict->root;
209 return 1;
210 }
211
212 da = dict->root;
213 }
214
215 /*
216 * ref=.foo is a ref from the current parent.
217 *
218 * ref=@foo is a ref from the root of the tree.
219 */
220
221 if (!fr_sbuff_next_if_char(in, '.')) {
222 fr_strerror_printf("Invalid reference '%s' - it should start with '@' (from the root), or '.' (from the parent)",
224 return -1;
225 }
226
227 /*
228 * First '.' makes it relative, subsequent ones traverse up the tree.
229 *
230 * No '.' means use the root.
231 */
232 while (fr_sbuff_next_if_char(in, '.')) {
233 if (!da->parent) {
234 above_root:
235 fr_strerror_const("Reference attempted to navigate above dictionary root");
236 return -1;
237 }
238 da = da->parent;
239 }
240
241 /*
242 * Look up the attribute. Note that this call will
243 * update *da_p with a partial reference if it exists.
244 */
245more:
246 slen = fr_dict_attr_by_oid_substr(NULL, da_p, da, in, NULL);
247 if (slen < 0) return -1;
248
249 if (slen == 0) {
250 *da_p = NULL;
251 return 0;
252 }
253
254 return 1;
255}
256
257/** Add an enumeration value to an attribute which has not yet been defined
258 *
259 * @param[in] fctx Holds current dictionary parsing information.
260 * @param[in] filename this fixup relates to.
261 * @param[in] line this fixup relates to.
262 * @param[in] attr The OID string pointing to the attribute
263 * to add the enumeration value to.
264 * @param[in] attr_len The length of the attr string.
265 * @param[in] name The name of the enumv.
266 * @param[in] name_len Length of the name string.
267 * @param[in] value Value string. This is kept as a string until we know
268 * what type we want to transform it into.
269 * @param[in] value_len Length of the value string.
270 * @param[in] parent of this attribute.
271 * @return
272 * - 0 on success.
273 * - -1 on out of memory.
274 */
275int dict_fixup_enumv_enqueue(dict_fixup_ctx_t *fctx, char const *filename, int line,
276 char const *attr, size_t attr_len,
277 char const *name, size_t name_len,
278 char const *value, size_t value_len,
279 fr_dict_attr_t const *parent)
280{
281 dict_fixup_enumv_t *fixup;
282
283 fixup = talloc(fctx->pool, dict_fixup_enumv_t);
284 if (!fixup) {
285 oom:
286 fr_strerror_const("Out of memory");
287 return -1;
288 }
289 *fixup = (dict_fixup_enumv_t) {
290 .attribute = talloc_bstrndup(fixup, attr, attr_len),
291 .name = talloc_bstrndup(fixup, name, name_len),
292 .value = talloc_bstrndup(fixup, value, value_len),
293 .parent = parent
294 };
295 if (!fixup->attribute || !fixup->name || !fixup->value) goto oom;
296
297 fixup->filename = talloc_strdup(fixup, filename);
298 if (!fixup->filename) goto oom;
299 fixup->line = line;
300
301 return dict_fixup_common(&fctx->enumv, &fixup->common);
302}
303
304/** Add a previously defined enumeration value to an existing attribute
305 *
306 * @param[in] fctx Holds current dictionary parsing information.
307 * @param[in] fixup Hash table to fill.
308 * @return
309 * - 0 on success.
310 * - -1 on failure.
311 */
312static inline CC_HINT(always_inline) int dict_fixup_enumv_apply(UNUSED dict_fixup_ctx_t *fctx, dict_fixup_enumv_t *fixup)
313{
314 fr_dict_attr_t *da;
317 int ret;
318 fr_dict_attr_t const *da_const;
319
320 da_const = fr_dict_attr_by_oid(NULL, fixup->parent, fixup->attribute);
321 if (!da_const) {
322 fr_strerror_printf_push("Failed resolving ATTRIBUTE referenced by VALUE '%s' at %s[%d]",
323 fixup->name, fr_cwd_strip(fixup->filename), fixup->line);
324 return -1;
325 }
326 da = fr_dict_attr_unconst(da_const);
327 type = da->type;
328
329 if (fr_value_box_from_str(fixup, &value, type, NULL,
330 fixup->value, talloc_array_length(fixup->value) - 1,
331 NULL) < 0) {
332 fr_strerror_printf_push("Invalid VALUE '%pV' for attribute '%s' at %s[%d]",
334 da->name,
335 fr_cwd_strip(fixup->filename), fixup->line);
336 return -1;
337 }
338
339 ret = fr_dict_enum_add_name(da, fixup->name, &value, false, false);
341 da->flags.has_fixup = false;
342
343 return ret;
344}
345
346/** Resolve a group reference
347 *
348 * This is required as the reference may point to another dictionary which
349 * hasn't been loaded yet.
350 *
351 * @param[in] fctx Holds current dictionary parsing information.
352 * @param[in] da The group dictionary attribute.
353 * @param[in] ref OID string representing what the group references.
354 * @return
355 * - 0 on success.
356 * - -1 on out of memory.
357 */
359{
360 dict_fixup_group_t *fixup;
361
362 fixup = talloc(fctx->pool, dict_fixup_group_t);
363 if (!fixup) {
364 fr_strerror_const("Out of memory");
365 return -1;
366 }
367 *fixup = (dict_fixup_group_t) {
368 .da = da,
369 .ref = talloc_strdup(fixup, ref),
370 };
371
372 da->flags.has_fixup = true;
373
374 return dict_fixup_common(&fctx->group, &fixup->common);
375}
376
377/** Resolve a group reference
378 *
379 * @param[in] fctx Holds current dictionary parsing information.
380 * @param[in] fixup Hash table to fill.
381 * @return
382 * - 0 on success.
383 * - -1 on failure.
384 */
385static inline CC_HINT(always_inline) int dict_fixup_group_apply(UNUSED dict_fixup_ctx_t *fctx, dict_fixup_group_t *fixup)
386{
387 fr_dict_attr_t const *da;
388
389 (void) fr_dict_protocol_reference(&da, fixup->da->parent, &FR_SBUFF_IN_STR(fixup->ref));
390 if (!da) {
391 fr_strerror_printf_push("Failed resolving reference for attribute %s at %s[%d]",
392 fixup->da->name, fr_cwd_strip(fixup->da->filename), fixup->da->line);
393 return -1;
394 }
395
396 if (da->type != FR_TYPE_TLV) {
397 fr_strerror_printf("References MUST be to attributes of type 'tlv' at %s[%d]",
398 fr_cwd_strip(fixup->da->filename), fixup->da->line);
399 return -1;
400 }
401
402 if (fr_dict_attr_ref(da)) {
403 fr_strerror_printf("References MUST NOT refer to an ATTRIBUTE which also has 'ref=...' at %s[%d]",
404 fr_cwd_strip(fixup->da->filename), fixup->da->line);
405 return -1;
406 }
407
408 fixup->da->flags.has_fixup = false;
409
410 return dict_attr_ref_resolve(fixup->da, da);
411}
412
413/** Clone one area of a tree into another
414 *
415 * These must be processed later to ensure that we've finished building an
416 * attribute by the time it has been cloned.
417 *
418 * @param[in] fctx Holds current dictionary parsing information.
419 * @param[in] da The group dictionary attribute.
420 * @param[in] ref OID string representing what the group references..
421 * @return
422 * - 0 on success.
423 * - -1 on out of memory.
424 */
426{
427 dict_fixup_clone_t *fixup;
428
429 /*
430 * Delay type checks until we've loaded all of the
431 * dictionaries. This means that errors are produced
432 * later, but that shouldn't matter for the default
433 * dictionaries. They're supposed to work.
434 */
435 fixup = talloc(fctx->pool, dict_fixup_clone_t);
436 if (!fixup) {
437 fr_strerror_const("Out of memory");
438 return -1;
439 }
440 *fixup = (dict_fixup_clone_t) {
441 .da = da,
442 .ref = talloc_typed_strdup(fixup, ref)
443 };
444
445 return dict_fixup_common(&fctx->clone, &fixup->common);
446}
447
448/** Clone a dictionary attribute from a ref
449 *
450 * @param[in] dst_p will either be inserted directly, with fields from the clone, or will be
451 * cloned, and then inserted. In this case the original dst da will be freed
452 * and the new cloned attribute will be written back to dst_p.
453 * @param[in] src to clone.
454 * @return
455 * - 0 on success.
456 * - -1 on failure.
457 */
459{
460 fr_dict_attr_t *dst = *dst_p;
461 fr_dict_t *dict = fr_dict_unconst(dst->dict);
462 fr_dict_attr_t *cloned;
463
464 if (src->dict->proto != dst->dict->proto) {
465 fr_strerror_printf("Incompatible protocols. Referenced '%s', referencing '%s'. Defined at %s[%d]",
466 src->dict->proto->name, dst->dict->proto->name, dst->filename, dst->line);
467 return -1;
468 }
469
470 /*
471 * The referenced DA is higher than the one we're
472 * creating. Ensure it's not a parent.
473 */
474 if (src->depth < dst->depth) {
475 fr_dict_attr_t const *parent;
476
477 for (parent = dst->parent; !parent->flags.is_root; parent = parent->parent) {
478 if (parent == src) {
479 fr_strerror_printf("References MUST NOT refer to a parent attribute %s at %s[%d]",
480 parent->name, fr_cwd_strip(dst->filename), dst->line);
481 return -1;
482 }
483 }
484 }
485
486 if (fr_dict_attr_ref(src)) {
487 fr_strerror_printf("References MUST NOT refer to an ATTRIBUTE which itself has a 'ref=...' at %s[%d]",
488 fr_cwd_strip(dst->filename), dst->line);
489 return -1;
490 }
491
492 /*
493 * If the attributes are of different types, then we have
494 * to _manually_ clone the values. This means looping
495 * over the ref da, and _casting_ the values to the new
496 * data type. If the cast succeeds, we add the value.
497 * Otherwise we don't
498 *
499 * We do this if the source type is a leaf node, AND the
500 * types are different, or the destination has no
501 * children.
502 */
503 if (!fr_type_is_non_leaf(dst->type) &&
504 ((src->type != dst->type) || !dict_attr_children(src))) {
505 int copied;
506
507 /*
508 * Only TLV and STRUCT types can be the source or destination of clones.
509 *
510 * Leaf types can be cloned, even if they're
511 * different types. But only if they don't have
512 * children (i.e. key fields).
513 */
514 if (fr_type_is_non_leaf(src->type) || fr_type_is_non_leaf(dst->type) ||
516 fr_strerror_printf("Reference MUST be to a simple data type of type '%s' at %s[%d]",
517 fr_type_to_str(dst->type),
518 fr_cwd_strip(dst->filename), dst->line);
519 return -1;
520 }
521
522 /*
523 * We copy all of the VALUEs over from the source
524 * da by hand, by casting them.
525 *
526 * We have to do this work manually because we
527 * can't call dict_attr_acopy(), as that function
528 * copies the VALUE with the *source* data type,
529 * where we need the *destination* data type.
530 */
531 copied = dict_attr_acopy_enumv(dst, src);
532 if (copied < 0) return -1;
533
534 if (!copied) {
535 fr_strerror_printf("Reference copied no VALUEs from type type '%s' at %s[%d]",
536 fr_type_to_str(dst->type),
537 fr_cwd_strip(dst->filename), dst->line);
538 return -1;
539 }
540
541 return 0;
542 }
543
544 /*
545 * Can't clone KEY fields directly, you MUST clone the parent struct.
546 *
547 * @todo - remove after migration_union_key is deleted
548 */
550 fr_strerror_printf("Invalid reference from '%s' to %s", dst->name, src->name);
551 return -1;
552 }
553
554 /*
555 * Copy the source attribute, but with a
556 * new name and a new attribute number.
557 */
558 cloned = dict_attr_acopy(dict->pool, src, dst->name);
559 if (!cloned) {
560 fr_strerror_printf("Failed copying attribute '%s' to %s", src->name, dst->name);
561 return -1;
562 }
563
564 cloned->attr = dst->attr;
565 cloned->parent = dst->parent; /* we need to re-parent this attribute */
566 cloned->depth = cloned->parent->depth + 1;
567
568 /*
569 * Copy any pre-existing children over.
570 */
571 if (dict_attr_children(dst)) {
572 if (dict_attr_acopy_children(dict, cloned, dst) < 0) {
573 fr_strerror_printf("Failed populating attribute '%s' with children of %s - %s", src->name, dst->name, fr_strerror());
574 return -1;
575 }
576 }
577
578 /*
579 * Copy children of the DA we're cloning.
580 */
581 if (dict_attr_children(src)) {
582 if (dict_attr_acopy_children(dict, cloned, src) < 0) {
583 fr_strerror_printf("Failed populating attribute '%s' with children of %s - %s", src->name, dst->name, fr_strerror());
584 return -1;
585 }
586 }
587
588 if (fr_dict_attr_add_initialised(cloned) < 0) {
589 talloc_free(cloned);
590 return -1;
591 }
592
593 /*
594 * Free the original and pass back our new cloned attribute
595 */
596 talloc_free(dst);
597 *dst_p = cloned;
598
599 return 0;
600}
601
602/** Clone one are of a tree into another
603 *
604 * @param[in] fctx Holds current dictionary parsing information.
605 * @param[in] fixup Containing source/destination of the clone.
606 * @return
607 * - 0 on success.
608 * - -1 on failure.
609 */
610static inline CC_HINT(always_inline) int dict_fixup_clone_apply(UNUSED dict_fixup_ctx_t *fctx, dict_fixup_clone_t *fixup)
611{
612 fr_dict_attr_t const *src;
613
614 (void) fr_dict_protocol_reference(&src, fixup->da->parent, &FR_SBUFF_IN_STR(fixup->ref));
615 if (!src) {
616 fr_strerror_printf_push("Failed resolving reference for attribute %s at %s[%d]",
617 fixup->da->name, fr_cwd_strip(fixup->da->filename), fixup->da->line);
618 return -1;
619 }
620
621 fixup->da->flags.has_fixup = false;
622 return dict_fixup_clone(&fixup->da, src);
623}
624
625/** Clone enumeration values from one attribute to another
626 *
627 * These must be processed later to ensure that we've finished building an
628 * attribute by the time it has been cloned.
629 *
630 * @param[in] fctx Holds current dictionary parsing information.
631 * @param[in] da The group dictionary attribute.
632 * @param[in] ref OID string representing what the group references..
633 * @return
634 * - 0 on success.
635 * - -1 on out of memory.
636 */
638{
639 dict_fixup_clone_t *fixup;
640
641 /*
642 * Delay type checks until we've loaded all of the
643 * dictionaries. This means that errors are produced
644 * later, but that shouldn't matter for the default
645 * dictionaries. They're supposed to work.
646 */
647 fixup = talloc(fctx->pool, dict_fixup_clone_t);
648 if (!fixup) {
649 fr_strerror_const("Out of memory");
650 return -1;
651 }
652 *fixup = (dict_fixup_clone_t) {
653 .da = da,
654 .ref = talloc_typed_strdup(fixup, ref)
655 };
656
657 return dict_fixup_common(&fctx->clone, &fixup->common);
658}
659
660/** Clone one are of a tree into another
661 *
662 * @param[in] fctx Holds current dictionary parsing information.
663 * @param[in] fixup Containing source/destination of the clone.
664 * @return
665 * - 0 on success.
666 * - -1 on failure.
667 */
668static inline CC_HINT(always_inline) int dict_fixup_clone_enum_apply(UNUSED dict_fixup_ctx_t *fctx, dict_fixup_clone_t *fixup)
669{
670 fr_dict_attr_t const *src;
671 int copied;
672
673 (void) fr_dict_protocol_reference(&src, fixup->da->parent, &FR_SBUFF_IN_STR(fixup->ref));
674 if (!src) {
675 fr_strerror_printf_push("Failed resolving reference for attribute %s at %s[%d]",
676 fixup->da->name, fr_cwd_strip(fixup->da->filename), fixup->da->line);
677 return -1;
678 }
679
680 if (src->dict->proto != fixup->da->dict->proto) {
681 fr_strerror_printf("Incompatible protocols. Referenced '%s', referencing '%s'. Defined at %s[%d]",
682 src->dict->proto->name, fixup->da->dict->proto->name, fixup->da->filename, fixup->da->line);
683 return -1;
684 }
685
686 if (fr_dict_attr_ref(src)) {
687 fr_strerror_printf("References MUST NOT refer to an ATTRIBUTE which itself has a 'ref=...' at %s[%d]",
688 fr_cwd_strip(fixup->da->filename), fixup->da->line);
689 return -1;
690 }
691
692 if (!fr_type_is_non_leaf(fixup->da->type)) {
693 fr_strerror_printf("enum copy can only be applied to leaf types, not %s", fr_type_to_str(fixup->da->type));
694 return -1;
695 }
696
697 if (src->type != fixup->da->type) {
698 fr_strerror_printf("enum copy type mismatch. src '%s', dst '%s'",
699 fr_type_to_str(src->type), fr_type_to_str(fixup->da->type));
700 return -1;
701 }
702
703 /*
704 * We copy all of the VALUEs over from the source
705 * da by hand, by casting them.
706 *
707 * We have to do this work manually because we
708 * can't call dict_attr_acopy(), as that function
709 * copies the VALUE with the *source* data type,
710 * where we need the *destination* data type.
711 */
712 copied = dict_attr_acopy_enumv(fixup->da, src);
713 if (copied < 0) return -1;
714
715 if (!copied) {
716 fr_strerror_printf("Reference copied no VALUEs from type type '%s' at %s[%d]",
717 fr_type_to_str(fixup->da->type),
718 fr_cwd_strip(fixup->da->filename), fixup->da->line);
719 return -1;
720 }
721
722 fixup->da->flags.has_fixup = false;
723 return 0;
724}
725
726/** Push a fixup for a VSA.
727 *
728 * This is required so that we can define VENDORs for all VSAs, even
729 * if the dictionary doesn't contain VENDOR children for that VSA.
730 * This fixup means that we can define VENDORs elsewhere, and then
731 * use them in all VSA definitions. It means that we don't have to
732 * do these lookups at run-time.
733 *
734 * @param[in] fctx Holds current dictionary parsing information.
735 * @param[in] da The group dictionary attribute.
736 * @return
737 * - 0 on success.
738 * - -1 on out of memory.
739 */
741{
742 dict_fixup_vsa_t *fixup;
743
744 fixup = talloc(fctx->pool, dict_fixup_vsa_t);
745 if (!fixup) {
746 fr_strerror_const("Out of memory");
747 return -1;
748 }
749 *fixup = (dict_fixup_vsa_t) {
750 .da = da,
751 };
752
753 return dict_fixup_common(&fctx->vsa, &fixup->common);
754}
755
756/** Run VSA fixups
757 *
758 * @param[in] fctx Holds current dictionary parsing information.
759 * @param[in] fixup entry for fixup
760 * @return
761 * - 0 on success.
762 * - -1 on failure.
763 */
764static inline CC_HINT(always_inline) int dict_fixup_vsa_apply(UNUSED dict_fixup_ctx_t *fctx, dict_fixup_vsa_t *fixup)
765{
767 fr_dict_t *dict = fr_dict_unconst(fr_dict_by_da(fixup->da));
768 fr_hash_iter_t iter;
769
770 if (!dict->vendors_by_num) return 0;
771
772 for (dv = fr_hash_table_iter_init(dict->vendors_by_num, &iter);
773 dv;
774 dv = fr_hash_table_iter_next(dict->vendors_by_num, &iter)) {
775 if (dict_attr_child_by_num(fixup->da, dv->pen)) continue;
776
777 if (fr_dict_attr_add(dict, fixup->da, dv->name, dv->pen, FR_TYPE_VENDOR, NULL) < 0) return -1;
778 }
779
780 fixup->da->flags.has_fixup = false;
781 return 0;
782}
783
784
785/** Resolve a group reference
786 *
787 * This is required as the reference may point to another dictionary which
788 * hasn't been loaded yet.
789 *
790 * @param[in] fctx Holds current dictionary parsing information.
791 * @param[in] filename this fixup relates to.
792 * @param[in] line this fixup relates to.
793 * @param[in] alias_parent where to add the alias.
794 * @param[in] alias alias to add.
795 * @param[in] ref_parent attribute that should contain the reference.
796 * @param[in] ref OID string representing what the group references.
797 * @return
798 * - 0 on success.
799 * - -1 on out of memory.
800 */
801int dict_fixup_alias_enqueue(dict_fixup_ctx_t *fctx, char const *filename, int line,
802 fr_dict_attr_t *alias_parent, char const *alias,
803 fr_dict_attr_t *ref_parent, char const *ref)
804{
805 dict_fixup_alias_t *fixup;
806
807 fixup = talloc(fctx->pool, dict_fixup_alias_t);
808 if (!fixup) {
809 oom:
810 fr_strerror_const("Out of memory");
811 return -1;
812 }
813 *fixup = (dict_fixup_alias_t) {
814 .alias = talloc_typed_strdup(fixup, alias),
815 .alias_parent = alias_parent,
816 .ref = talloc_typed_strdup(fixup, ref),
817 .ref_parent = ref_parent
818 };
819
820 fixup->filename = talloc_strdup(fixup, filename);
821 if (!fixup->filename) goto oom;
822 fixup->line = line;
823
824 return dict_fixup_common(&fctx->alias, &fixup->common);
825}
826
827static inline CC_HINT(always_inline) int dict_fixup_alias_apply(UNUSED dict_fixup_ctx_t *fctx, dict_fixup_alias_t *fixup)
828{
829 fr_dict_attr_t const *da;
830
831 /*
832 * The <ref> can be a name.
833 */
834 da = fr_dict_attr_by_oid(NULL, fixup->ref_parent, fixup->ref);
835 if (!da) {
836 fr_strerror_printf("Attribute '%s' aliased by '%s' doesn't exist in namespace '%s', at %s[%d]",
837 fixup->ref, fixup->alias, fixup->ref_parent->name, fixup->filename, fixup->line);
838 return -1;
839 }
840
841 fr_dict_attr_unconst(da)->flags.has_fixup = false;
842 return dict_attr_alias_add(fixup->alias_parent, fixup->alias, da);
843}
844
845/** Initialise a fixup ctx
846 *
847 * @param[in] ctx to allocate the fixup pool in.
848 * @param[in] fctx to initialise.
849 * @return
850 * - 0 on success.
851 * - -1 on failure.
852 */
853int dict_fixup_init(TALLOC_CTX *ctx, dict_fixup_ctx_t *fctx)
854{
855 if (fctx->pool) return 0;
856
857 fr_dlist_talloc_init(&fctx->enumv, dict_fixup_enumv_t, common.entry);
858 fr_dlist_talloc_init(&fctx->group, dict_fixup_group_t, common.entry);
859 fr_dlist_talloc_init(&fctx->clone, dict_fixup_clone_t, common.entry);
860 fr_dlist_talloc_init(&fctx->vsa, dict_fixup_vsa_t, common.entry);
861 fr_dlist_talloc_init(&fctx->alias, dict_fixup_alias_t, common.entry);
862
863 fctx->pool = talloc_pool(ctx, DICT_FIXUP_POOL_SIZE);
864 if (!fctx->pool) return -1;
865
866 return 0;
867}
868
869/** Apply all outstanding fixes to a set of dictionaries
870 *
871 */
873{
874
875#define APPLY_FIXUP(_fctx, _list, _func, _type) \
876do { \
877 _type *_fixup; \
878 while ((_fixup = fr_dlist_head(&(_fctx)->_list))) { \
879 if (_func(_fctx, _fixup) < 0) return -1; \
880 fr_dlist_remove(&(_fctx)->_list, _fixup); \
881 talloc_free(_fixup); \
882 } \
883} while (0)
884
885 /*
886 * Apply all the fctx in order
887 *
888
889 * - Enumerations first as they have no dependencies
890 * - Group references next, as group attributes may be cloned.
891 * - Clones last as all other references and additions should
892 * be applied before cloning.
893 * - Clone enum clones the enumeration values from a dedicated
894 * enum, or another attribute with enumerations.
895 * - VSAs
896 * - Aliases last as all attributes need to be defined.
897 */
904
905 TALLOC_FREE(fctx->pool);
906
907 return 0;
908}
909
910/** Fixup all hash tables in the dictionary so they're suitable for threaded access
911 *
912 */
913static int _dict_attr_fixup_hash_tables(fr_dict_attr_t const *da, UNUSED void *uctx)
914{
915 {
917
919 if (ext) {
922 }
923 }
924
925 {
927
930 }
931
932 return 0;
933}
934
935/** Walk a dictionary finalising the hash tables in all attributes with a distinct namespace
936 *
937 * @param[in] dict to finalise namespaces for.
938 */
940{
942
943 (void)_dict_attr_fixup_hash_tables(root, NULL);
944
946
947 /*
948 * Walk over all of the hash tables to ensure they're
949 * initialized. We do this because the threads may perform
950 * lookups, and we don't want multi-threaded re-ordering
951 * of the table entries. That would be bad.
952 */
953 fr_hash_table_fill(dict->vendors_by_name);
954 fr_hash_table_fill(dict->vendors_by_num);
955}
int const char int line
Definition acutest.h:702
#define RCSID(id)
Definition build.h:485
#define L(_str)
Helper for initialising arrays of string literals.
Definition build.h:209
#define UNUSED
Definition build.h:317
int dict_attr_acopy_children(fr_dict_t *dict, fr_dict_attr_t *dst, fr_dict_attr_t const *src)
Copy the children of an existing attribute.
Definition dict_util.c:1177
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:1668
ssize_t fr_dict_valid_oid_str(char const *name, ssize_t len)
Definition dict_util.c:4802
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:2037
char const * name
Vendor name.
Definition dict.h:269
fr_dict_t * fr_dict_unconst(fr_dict_t const *dict)
Coerce to non-const.
Definition dict_util.c:4724
fr_dict_t const * fr_dict_by_da(fr_dict_attr_t const *da)
Attempt to locate the protocol dictionary containing an attribute.
Definition dict_util.c:2702
int fr_dict_walk(fr_dict_attr_t const *da, fr_dict_walk_t callback, void *uctx)
Definition dict_util.c:4916
fr_dict_attr_t * fr_dict_attr_unconst(fr_dict_attr_t const *da)
Coerce to non-const.
Definition dict_util.c:4736
fr_slen_t fr_dict_attr_by_oid_substr(fr_dict_attr_err_t *err, fr_dict_attr_t const **out, fr_dict_attr_t const *parent, fr_sbuff_t *in, fr_sbuff_term_t const *tt))
Resolve an attribute using an OID string.
Definition dict_util.c:2420
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
fr_dict_attr_t const * fr_dict_root(fr_dict_t const *dict)
Return the root attribute of a dictionary.
Definition dict_util.c:2496
uint32_t pen
Private enterprise number.
Definition dict.h:265
@ FR_DICT_ATTR_EXT_ENUMV
Enumeration values.
Definition dict.h:188
int fr_dict_attr_add(fr_dict_t *dict, fr_dict_attr_t const *parent, char const *name, unsigned int attr, fr_type_t type, fr_dict_attr_flags_t const *flags))
Add an attribute to the dictionary.
Definition dict_util.c:1790
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:2469
#define fr_dict_attr_is_key_field(_da)
Definition dict.h:169
static fr_slen_t in
Definition dict.h:861
#define FR_DICT_ATTR_MAX_NAME_LEN
Maximum length of a attribute name.
Definition dict.h:493
Private enterprise.
Definition dict.h:264
fr_hash_table_t * name_by_value
Lookup a name by value.
Definition dict_ext.h:111
static void * fr_dict_attr_ext(fr_dict_attr_t const *da, fr_dict_attr_ext_t ext)
Definition dict_ext.h:141
fr_hash_table_t * value_by_name
Lookup an enumeration value by name.
Definition dict_ext.h:110
static fr_dict_attr_t const * fr_dict_attr_ref(fr_dict_attr_t const *da)
Return the reference associated with a group type attribute.
Definition dict_ext.h:185
Attribute extension - Holds enumeration values.
Definition dict_ext.h:108
static fr_hash_table_t * dict_attr_namespace(fr_dict_attr_t const *da)
Return the namespace hash table associated with the attribute.
static int dict_attr_ref_resolve(fr_dict_attr_t const *da, fr_dict_attr_t const *ref)
static fr_dict_attr_t const ** dict_attr_children(fr_dict_attr_t const *da)
fr_dict_attr_t * da
FR_TYPE_GROUP to fix.
Definition dict_fixup.c:78
dict_fixup_common_t common
Common fields.
Definition dict_fixup.c:59
int dict_fixup_apply(dict_fixup_ctx_t *fctx)
Apply all outstanding fixes to a set of dictionaries.
Definition dict_fixup.c:872
char * ref
the target attribute to clone
Definition dict_fixup.c:89
char * attribute
we couldn't find (and will need to resolve later).
Definition dict_fixup.c:64
static int dict_fixup_clone_apply(UNUSED dict_fixup_ctx_t *fctx, dict_fixup_clone_t *fixup)
Clone one are of a tree into another.
Definition dict_fixup.c:610
char * value
Raw enum value.
Definition dict_fixup.c:66
char * alias
we need to create.
Definition dict_fixup.c:48
char * ref
what the alias references.
Definition dict_fixup.c:51
static int dict_fixup_common(fr_dlist_head_t *fixup_list, dict_fixup_common_t *common)
Initialise common fields in fixup struct, and add it to a fixup list.
Definition dict_fixup.c:118
char * filename
where the line being fixed up.
Definition dict_fixup.c:61
int dict_fixup_enumv_enqueue(dict_fixup_ctx_t *fctx, char const *filename, int line, char const *attr, size_t attr_len, char const *name, size_t name_len, char const *value, size_t value_len, fr_dict_attr_t const *parent)
Add an enumeration value to an attribute which has not yet been defined.
Definition dict_fixup.c:275
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:801
int dict_fixup_clone_enqueue(dict_fixup_ctx_t *fctx, fr_dict_attr_t *da, char const *ref)
Clone one area of a tree into another.
Definition dict_fixup.c:425
dict_fixup_common_t common
Common fields.
Definition dict_fixup.c:96
dict_fixup_common_t common
Common fields.
Definition dict_fixup.c:76
static int dict_fixup_clone_enum_apply(UNUSED dict_fixup_ctx_t *fctx, dict_fixup_clone_t *fixup)
Clone one are of a tree into another.
Definition dict_fixup.c:668
int dict_fixup_init(TALLOC_CTX *ctx, dict_fixup_ctx_t *fctx)
Initialise a fixup ctx.
Definition dict_fixup.c:853
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:637
static int dict_fixup_vsa_apply(UNUSED dict_fixup_ctx_t *fctx, dict_fixup_vsa_t *fixup)
Run VSA fixups.
Definition dict_fixup.c:764
fr_dict_attr_t * alias_parent
Where to add the alias.
Definition dict_fixup.c:49
fr_dlist_t entry
Entry in linked list of fctx.
Definition dict_fixup.c:36
fr_dict_attr_t const * parent
Parent attribute to resolve the 'attribute' string in.
Definition dict_fixup.c:69
static int _dict_attr_fixup_hash_tables(fr_dict_attr_t const *da, UNUSED void *uctx)
Fixup all hash tables in the dictionary so they're suitable for threaded access.
Definition dict_fixup.c:913
dict_fixup_common_t common
Common fields.
Definition dict_fixup.c:105
char * filename
where the line being fixed up.
Definition dict_fixup.c:45
fr_hash_table_t * hash
We need to finalise.
Definition dict_fixup.c:107
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:740
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:458
static int dict_fixup_group_apply(UNUSED dict_fixup_ctx_t *fctx, dict_fixup_group_t *fixup)
Resolve a group reference.
Definition dict_fixup.c:385
dict_fixup_common_t common
Common fields.
Definition dict_fixup.c:43
int dict_fixup_group_enqueue(dict_fixup_ctx_t *fctx, fr_dict_attr_t *da, char const *ref)
Resolve a group reference.
Definition dict_fixup.c:358
char * ref
the reference name
Definition dict_fixup.c:79
int fr_dict_protocol_reference(fr_dict_attr_t const **da_p, fr_dict_attr_t const *rel, fr_sbuff_t *in)
Resolve a reference string to a dictionary attribute.
Definition dict_fixup.c:135
static int dict_fixup_enumv_apply(UNUSED dict_fixup_ctx_t *fctx, dict_fixup_enumv_t *fixup)
Add a previously defined enumeration value to an existing attribute.
Definition dict_fixup.c:312
#define APPLY_FIXUP(_fctx, _list, _func, _type)
fr_dict_attr_t * ref_parent
Parent attribute to resolve the 'attribute' string in.
Definition dict_fixup.c:52
char * name
Raw enum name.
Definition dict_fixup.c:65
void dict_hash_tables_finalise(fr_dict_t *dict)
Walk a dictionary finalising the hash tables in all attributes with a distinct namespace.
Definition dict_fixup.c:939
fr_dict_attr_t * da
FR_TYPE_VSA to fix.
Definition dict_fixup.c:98
static int dict_fixup_alias_apply(UNUSED dict_fixup_ctx_t *fctx, dict_fixup_alias_t *fixup)
Definition dict_fixup.c:827
fr_dict_attr_t * da
to populate with cloned information.
Definition dict_fixup.c:88
dict_fixup_common_t common
Common fields.
Definition dict_fixup.c:86
Add an enumeration value to an attribute that wasn't defined at the time the value was parsed.
Definition dict_fixup.c:42
Clone operation from one tree node to another.
Definition dict_fixup.c:85
Common fields for every fixup structure.
Definition dict_fixup.c:35
Add an enumeration value to an attribute that wasn't defined at the time the value was parsed.
Definition dict_fixup.c:58
Resolve a group reference.
Definition dict_fixup.c:75
Dictionary attribute namespaces need their hash tables finalised.
Definition dict_fixup.c:104
Run fixup callbacks for a VSA.
Definition dict_fixup.c:95
Functions to finalise and fixup dictionaries.
fr_dlist_head_t alias
Aliases that can't be resolved immediately.
fr_dlist_head_t group
Group references to resolve.
fr_dlist_head_t clone
Clone operation to apply.
fr_dlist_head_t vsa
VSAs to add vendors for.
fr_dlist_head_t enumv
Raw enumeration values to add.
TALLOC_CTX * pool
Temporary pool for fixups, reduces holes.
fr_slen_t dict_by_protocol_substr(fr_dict_attr_err_t *err, fr_dict_t **out, fr_sbuff_t *name, fr_dict_t const *dict_def)
Definition dict_util.c:2511
#define DICT_FIXUP_POOL_SIZE
Definition dict_priv.h:38
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:3377
fr_dict_attr_t * dict_attr_acopy(TALLOC_CTX *ctx, fr_dict_attr_t const *in, char const *new_name)
Copy a an existing attribute.
Definition dict_util.c:1089
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:1249
int dict_attr_acopy_enumv(fr_dict_attr_t *dst, fr_dict_attr_t const *src)
Copy the VALUEs of an existing attribute, by casting them.
Definition dict_util.c:1220
Test enumeration values.
Definition dict_test.h:92
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
#define fr_dlist_talloc_init(_head, _type, _field)
Initialise the head structure of a doubly linked list.
Definition dlist.h:275
Head of a doubly linked list.
Definition dlist.h:51
Entry in a doubly linked list.
Definition dlist.h:41
char const * fr_cwd_strip(char const *filename)
Intended to be used in logging functions to make output more readable.
Definition file.c:384
void * fr_hash_table_iter_next(fr_hash_table_t *ht, fr_hash_iter_t *iter)
Iterate over entries in a hash table.
Definition hash.c:626
void * fr_hash_table_iter_init(fr_hash_table_t *ht, fr_hash_iter_t *iter)
Initialise an iterator.
Definition hash.c:678
bool fr_hash_table_insert(fr_hash_table_t *ht, void const *data)
Insert data into a hash table.
Definition hash.c:468
void fr_hash_table_fill(fr_hash_table_t *ht)
Ensure all buckets are filled.
Definition hash.c:719
Stores the state of the current iteration operation.
Definition hash.h:41
talloc_free(reap)
fr_type_t
@ FR_TYPE_TLV
Contains nested attributes.
@ FR_TYPE_VENDOR
Attribute that represents a vendor in the attribute tree.
long int ssize_t
size_t fr_sbuff_out_bstrncpy_until(fr_sbuff_t *out, fr_sbuff_t *in, size_t len, fr_sbuff_term_t const *tt, fr_sbuff_unescape_rules_t const *u_rules)
char * fr_tolower(char *str)
Definition misc.c:226
static unsigned int hash(char const *username, unsigned int tablesize)
Definition rlm_passwd.c:132
static char const * name
bool fr_sbuff_next_if_char(fr_sbuff_t *sbuff, char c)
Return true if the current char matches, and if it does, advance.
Definition sbuff.c:2116
#define fr_sbuff_start(_sbuff_or_marker)
#define FR_SBUFF_TERMS(...)
Initialise a terminal structure with a list of sorted strings.
Definition sbuff.h:192
#define fr_sbuff_is_char(_sbuff_or_marker, _c)
#define fr_sbuff_eof(_x)
#define FR_SBUFF_IN_STR(_start)
#define FR_SBUFF_OUT(_start, _len_or_end)
#define fr_sbuff_used(_sbuff_or_marker)
fr_aka_sim_id_type_t type
char * talloc_bstrndup(TALLOC_CTX *ctx, char const *in, size_t inlen)
Binary safe strndup function.
Definition talloc.c:586
char * talloc_typed_strdup(TALLOC_CTX *ctx, char const *p)
Call talloc_strdup, setting the type on the new chunk correctly.
Definition talloc.c:467
static fr_slen_t parent
Definition pair.h:841
char const * fr_strerror(void)
Get the last library error.
Definition strerror.c:553
#define fr_strerror_printf(_fmt,...)
Log to thread local error buffer.
Definition strerror.h:64
#define fr_strerror_printf_push(_fmt,...)
Add a message to an existing stack of messages at the tail.
Definition strerror.h:84
#define fr_strerror_const(_msg)
Definition strerror.h:223
#define fr_type_is_non_leaf(_x)
Definition types.h:395
static char const * fr_type_to_str(fr_type_t type)
Return a static string containing the type name.
Definition types.h:455
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:5747
void fr_value_box_clear(fr_value_box_t *data)
Clear/free any existing value and metadata.
Definition value.c:4131
#define fr_box_strvalue_buffer(_val)
Definition value.h:311
#define FR_VALUE_BOX_INITIALISER_NULL(_vb)
A static initialiser for stack/globally allocated boxes.
Definition value.h:510