The FreeRADIUS server $Id: 15bac2a4c627c01d1aa2047687b3418955ac7f00 $
Loading...
Searching...
No Matches
pair_tests.c
Go to the documentation of this file.
1/*
2 * This library is free software; you can redistribute it and/or
3 * modify it under the terms of the GNU Lesser General Public
4 * License as published by the Free Software Foundation; either
5 * version 2.1 of the License, or (at your option) any later version.
6 *
7 * This library 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 GNU
10 * Lesser General Public License for more details.
11 *
12 * You should have received a copy of the GNU Lesser General Public
13 * License along with this library; if not, write to the Free Software
14 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
15 */
16
17/** Tests for a AVP manipulation and search API.
18 *
19 * @file src/lib/util/pair_tests.c
20 * @author Jorge Pereira <jpereira@freeradius.org>
21 * @copyright 2020 Network RADIUS SAS (legal@networkradius.com)
22 */
23
24/**
25 * The 'TEST_INIT' macro provided by 'acutest.h' allowing to register a function to be called
26 * before call the unit tests. Therefore, It calls the function ALL THE TIME causing an overhead.
27 * That is why we are initializing test_init() by "__attribute__((constructor));" reducing the
28 * test execution by 50% of the time.
29 */
30#define USE_CONSTRUCTOR
31
32/*
33 * It should be declared before include the "acutest.h"
34 */
35#ifdef USE_CONSTRUCTOR
36static void test_init(void) __attribute__((constructor));
37#else
38static void test_init(void);
39# define TEST_INIT test_init()
40#endif
41
42#include <freeradius-devel/util/acutest.h>
43#include <freeradius-devel/util/acutest_helpers.h>
44#include <freeradius-devel/util/pair_test_helpers.h>
45
46#include <freeradius-devel/util/conf.h>
47#include <freeradius-devel/util/dict.h>
48
49#ifdef HAVE_GPERFTOOLS_PROFILER_H
50# include <gperftools/profiler.h>
51#endif
52
53static TALLOC_CTX *autofree;
54static fr_pair_list_t test_pairs;
55static fr_dict_t *test_dict;
56
57/** Global initialisation
58 */
59static void test_init(void)
60{
61 autofree = talloc_autofree_context();
62 if (!autofree) {
63 error:
64#ifdef TEST_NESTED_PAIRS
65 fr_perror("pair_nested_tests");
66#else
67 fr_perror("pair_tests");
68#endif
69 fr_exit_now(EXIT_FAILURE);
70 }
71
72 /*
73 * Mismatch between the binary and the libraries it depends on
74 */
75 if (fr_check_lib_magic(RADIUSD_MAGIC_NUMBER) < 0) goto error;
76
77 if (fr_dict_test_init(autofree, &test_dict, NULL) < 0) goto error;
78
79 /* Initialize the "test_pairs" list */
80 fr_pair_list_init(&test_pairs);
81
82#ifdef TEST_NESTED_PAIRS
83 if (fr_pair_test_list_alloc_nested(autofree, &test_pairs, NULL) < 0) goto error;
84#else
85 if (fr_pair_test_list_alloc(autofree, &test_pairs, NULL) < 0) goto error;
86#endif
87}
88
89/*
90 * Tests functions
91 */
92static void test_fr_pair_afrom_da(void)
93{
94 fr_pair_t *vp;
95
96 TEST_CASE("Allocation using fr_pair_afrom_da");
97 TEST_CHECK((vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_string)) != NULL);
98
99 TEST_CHECK(vp != NULL);
100 if (!vp) return;
101
102 TEST_CHECK(fr_pair_value_from_str(vp, test_string, strlen(test_string), &fr_value_unescape_double, false) == 0);
103
104 TEST_CASE("Validating PAIR_VERIFY()");
105 PAIR_VERIFY(vp);
106
107 TEST_CHECK(vp && strcmp(vp->vp_strvalue, test_string) == 0);
108 TEST_MSG("Expected vp->vp_strvalue == test_string");
109
110 talloc_free(vp);
111}
112
113static void test_fr_pair_afrom_child_num(void)
114{
115 fr_pair_t *vp;
116 unsigned int attr = FR_TEST_ATTR_STRING;
117
118 TEST_CASE("Allocation using fr_pair_afrom_child_num");
119 TEST_CHECK((vp = fr_pair_afrom_child_num(autofree, fr_dict_root(test_dict), attr)) != NULL);
120
121 TEST_CASE("Validating PAIR_VERIFY()");
122 PAIR_VERIFY(vp);
123
124 TEST_CHECK(vp && vp->da->attr == FR_TEST_ATTR_STRING);
125 TEST_MSG("Expected attr(%u) == vp->da->attr(%u)", attr, vp->da->attr);
126
127 talloc_free(vp);
128}
129
130static void test_fr_pair_afrom_da_nested(void)
131{
132 fr_pair_t *vp, *parent = NULL;
133 fr_pair_list_t local_pairs;
134
135 fr_pair_list_init(&local_pairs);
136
137 TEST_CASE("Allocation using fr_pair_afrom_da_nested");
138 TEST_CHECK((vp = fr_pair_afrom_da_nested(autofree, &local_pairs, fr_dict_attr_test_tlv_string)) != NULL);
139
140 TEST_CHECK(vp && vp->da == fr_dict_attr_test_tlv_string);
141 TEST_MSG("Expected attr(%s) == vp->da->attr(%s)", fr_dict_attr_test_tlv_string->name, vp->da->name);
142
143 TEST_CASE("Validating PAIR_VERIFY()");
144 PAIR_VERIFY(vp);
145
146 TEST_CASE("Top list does not have the tlv child attribute");
147 TEST_CHECK(fr_pair_find_by_da(&local_pairs, NULL, fr_dict_attr_test_tlv_string) == NULL);
148
149 TEST_CASE("Top list does have the tlv attribute");
150 parent = fr_pair_find_by_da(&local_pairs, NULL, fr_dict_attr_test_tlv);
151 TEST_ASSERT(parent != NULL);
152
153 TEST_CASE("Parent list does have the tlv child attribute");
154 TEST_CHECK(fr_pair_find_by_da(&parent->vp_group, NULL, fr_dict_attr_test_tlv_string) == vp);
155
156 talloc_free(parent); /* not vp! */
157}
158
159static void test_fr_pair_delete_by_da_nested(void)
160{
161 int count;
162 fr_pair_t *vp, *parent = NULL;
163 fr_pair_list_t local_pairs;
164
165 fr_pair_list_init(&local_pairs);
166
167 TEST_CASE("Allocation using fr_pair_afrom_da_nested");
168 TEST_CHECK((vp = fr_pair_afrom_da_nested(autofree, &local_pairs, fr_dict_attr_test_tlv_string)) != NULL);
169
170 TEST_CHECK(vp && vp->da == fr_dict_attr_test_tlv_string);
171 TEST_MSG("Expected attr(%s) == vp->da->attr(%s)", fr_dict_attr_test_tlv_string->name, vp->da->name);
172
173 TEST_CASE("Deleted nested pair");
174 TEST_CHECK((count = fr_pair_delete_by_da_nested(&local_pairs, fr_dict_attr_test_tlv_string)) == 1);
175
176 TEST_CASE("Top list still has the tlv attribute");
177 parent = fr_pair_find_by_da(&local_pairs, NULL, fr_dict_attr_test_tlv);
178 TEST_ASSERT(parent != NULL);
179
180 TEST_CASE("Parent list does not have the tlv child attribute");
181 TEST_CHECK(fr_pair_find_by_da(&parent->vp_group, NULL, fr_dict_attr_test_tlv_string) == NULL);
182
183 fr_pair_list_free(&local_pairs);
184}
185
191
192
193static void test_fr_pair_copy(void)
194{
195 fr_pair_t *vp, *copy;
196
197 TEST_CASE("Allocation using fr_pair_copy");
198 TEST_CHECK((vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_uint32)) != NULL);
199
200 TEST_CASE("Validating PAIR_VERIFY()");
201 PAIR_VERIFY(vp);
202
203 copy = fr_pair_copy(autofree, vp);
204
205 TEST_CASE("Validating PAIR_VERIFY()");
206 PAIR_VERIFY(copy);
207
208 vp->op = T_OP_CMP_EQ;
209
210 TEST_CASE("Compare fr_pair_cmp(copy == vp) should be TRUE");
211 TEST_CHECK(fr_pair_cmp(vp, copy) == 1);
212
213 talloc_free(vp);
214 talloc_free(copy);
215}
216
217static void test_fr_pair_steal(void)
218{
219 fr_pair_t *vp;
220 TALLOC_CTX *ctx = talloc_null_ctx();
221
222 TEST_CASE("Allocate a new attribute fr_pair_afrom_da");
223 TEST_CHECK((vp = fr_pair_afrom_da(ctx, fr_dict_attr_test_uint32)) != NULL);
224
225 TEST_CASE("Validating PAIR_VERIFY()");
226 PAIR_VERIFY(vp);
227
228 TEST_CASE("Stealing 'vp' pair using fr_pair_steal()");
229 fr_pair_steal(autofree, vp); /* It should exit without memory-leaks */
230
231 TEST_CASE("Checking if talloc_parent(vp) == autofree");
232 TEST_CHECK(talloc_parent(vp) == autofree);
233}
234
235static void test_fr_pair_raw_afrom_pair(void)
236{
237 fr_pair_t *vp;
238 uint8_t value = 0;
239
240 TEST_CASE("Allocate a new attribute fr_pair_afrom_da");
241 TEST_CHECK((vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_octets)) != NULL);
242
243 TEST_CASE("Validating PAIR_VERIFY()");
244 PAIR_VERIFY(vp);
245
246 TEST_CASE("Converting regular 'vp' as unknown");
247 TEST_CHECK(fr_pair_raw_afrom_pair(vp, &value, 1) == 0);
248
249 TEST_CASE("Checking if a real 'raw' vp");
250 TEST_CHECK(vp && vp->vp_raw);
251}
252
253static void test_fr_pair_dcursor_by_da_init(void)
254{
255 fr_pair_t *vp, *needle;
256 fr_dcursor_t cursor;
257
258 TEST_CASE("Searching for fr_dict_attr_test_uint32 using fr_pair_dcursor_by_da_init()");
259 needle = NULL;
260 for (vp = fr_pair_dcursor_by_da_init(&cursor, &test_pairs, fr_dict_attr_test_uint32);
261 vp;
262 vp = fr_dcursor_next(&cursor)) {
263 if (!needle) {
264 needle = vp;
265 continue;
266 }
267 TEST_CHECK(1 == 1); /* this never will be reached */
268 }
269
270 TEST_CASE("Validating PAIR_VERIFY()");
271
272 TEST_CHECK(needle != NULL);
273 if (needle) PAIR_VERIFY(needle);
274
275 TEST_CASE("Expected (needle->da == fr_dict_attr_test_uint32)");
276 TEST_CHECK(needle && needle->da == fr_dict_attr_test_uint32);
277}
278
279static void test_fr_pair_dcursor_by_ancestor_init(void)
280{
281 fr_pair_t *vp, *needle;
282 fr_dcursor_t cursor;
283
284 TEST_CASE("Searching for fr_dict_attr_test_tlv_string as ascend of fr_dict_attr_test_tlv using fr_pair_dcursor_by_ancestor_init()");
285 needle = NULL;
286 for (vp = fr_pair_dcursor_by_ancestor_init(&cursor, &test_pairs, fr_dict_attr_test_tlv);
287 vp;
288 vp = fr_dcursor_next(&cursor)) {
289 TEST_CHECK(vp != NULL);
290 if (vp->da == fr_dict_attr_test_tlv_string) {
291 needle = vp;
292 continue;
293 }
294 }
295
296 TEST_CHECK(needle != NULL);
297
298 TEST_CASE("Validating PAIR_VERIFY()");
299 if (needle) PAIR_VERIFY(needle);
300
301 TEST_CASE("Expected (needle->da == fr_dict_attr_test_tlv_string)");
302 TEST_CHECK(needle && needle->da == fr_dict_attr_test_tlv_string);
303}
304
305static void test_fr_pair_dcursor_value_init(void)
306{
307 int i = 0;
308 fr_value_box_t *box;
309 fr_dcursor_t cursor;
310 fr_pair_t *vp;
311 fr_pair_list_t local_pairs;
312
313 fr_pair_list_init(&local_pairs);
314
315 MEM(vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_string));
316 fr_pair_value_strdup(vp, "hello", false);
317 fr_pair_append(&local_pairs, vp);
318
319 MEM(vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_uint32));
320 vp->vp_uint32 = 6809;
321 fr_pair_append(&local_pairs, vp);
322
323 MEM(vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_uint8));
324 vp->vp_uint8 = 12;
325 fr_pair_append(&local_pairs, vp);
326
327 TEST_CASE("Searching for fr_dict_attr_test_tlv_string as ascend of fr_dict_attr_test_tlv using fr_pair_dcursor_by_ancestor_init()");
328 for (box = fr_pair_dcursor_value_init(&cursor);
329 box;
330 box = fr_dcursor_next(&cursor), i++) {
331 switch (i) {
332 case 0:
333 TEST_CASE("First box is a string with value 'hello'");
334 TEST_CHECK(box->type == FR_TYPE_STRING);
335 TEST_CHECK(strcmp(box->vb_strvalue, "hello") == 0);
336 break;
337
338 case 1:
339 TEST_CASE("First box is a uint32 with value 6809");
340 TEST_CHECK(box->type == FR_TYPE_UINT32);
341 TEST_CHECK(box->vb_uint32 == 6809);
342 break;
343
344 case 2:
345 TEST_CASE("First box is a uint8 r with value 12");
346 TEST_CHECK(box->type == FR_TYPE_UINT8);
347 TEST_CHECK(box->vb_uint8 == 12);
348 break;
349
350 default:
351 TEST_CASE("Too many pairs");
352 TEST_CHECK(i < 3);
353 break;
354 }
355 }
356
357 fr_pair_list_free(&local_pairs);
358}
359
360static void test_fr_pair_find_by_da_idx(void)
361{
362 fr_pair_t *vp;
363
364 TEST_CASE("Search for fr_dict_attr_test_string using fr_pair_find_by_da_idx()");
365 TEST_CHECK((vp = fr_pair_find_by_da_idx(&test_pairs, fr_dict_attr_test_string, 0)) != NULL);
366
367 TEST_CASE("Validating PAIR_VERIFY()");
368 PAIR_VERIFY(vp);
369
370 TEST_CASE("Expected (vp->da == fr_dict_attr_test_string)");
371 TEST_CHECK(vp && vp->da == fr_dict_attr_test_string);
372}
373
374static void test_fr_pair_find_by_child_num_idx(void)
375{
376 fr_pair_t *vp;
377
378 TEST_CASE("Search for FR_TEST_ATTR_STRING using fr_pair_find_by_child_num_idx()");
379 TEST_CHECK((vp = fr_pair_find_by_child_num_idx(&test_pairs, fr_dict_root(test_dict), FR_TEST_ATTR_STRING, 0)) != NULL);
380
381 TEST_CASE("Validating PAIR_VERIFY()");
382 PAIR_VERIFY(vp);
383
384 TEST_CASE("Expected (vp->da == fr_dict_attr_test_string)");
385 TEST_CHECK(vp && vp->da == fr_dict_attr_test_string);
386}
387
388static void test_fr_pair_find_by_da_nested(void)
389{
390 fr_pair_t *vp1, *vp2, *vp3, *vp4, *vp5, *vp_found;
391 fr_pair_list_t local_pairs;
392
393 fr_pair_list_init(&local_pairs);
394
395 /*
396 * Build a list with 2 TLV structures, each with different leaf nodes
397 */
398 MEM(vp1 = fr_pair_afrom_da(autofree, fr_dict_attr_test_nested_top_tlv));
399 fr_pair_append(&local_pairs, vp1);
400 MEM(vp2 = fr_pair_afrom_da(vp1, fr_dict_attr_test_nested_child_tlv));
401 fr_pair_append(&vp1->vp_group, vp2);
402 MEM(vp1 = fr_pair_afrom_da(vp2, fr_dict_attr_test_nested_leaf_string));
403 fr_pair_append(&vp2->vp_group, vp1);
404 MEM(vp2 = fr_pair_afrom_da(autofree, fr_dict_attr_test_nested_top_tlv));
405 fr_pair_append(&local_pairs, vp2);
406 MEM(vp3 = fr_pair_afrom_da(vp2, fr_dict_attr_test_nested_child_tlv));
407 fr_pair_append(&vp2->vp_group, vp3);
408 MEM(vp2 = fr_pair_afrom_da(vp3, fr_dict_attr_test_nested_leaf_int32));
409 fr_pair_append(&vp3->vp_group, vp2);
410
411 vp_found = fr_pair_find_by_da_nested(&local_pairs, NULL, fr_dict_attr_test_nested_leaf_string);
412 TEST_CASE("Find child node in first TLV");
413 TEST_CHECK_PAIR(vp_found, vp1);
414
415 vp_found = fr_pair_find_by_da_nested(&local_pairs, NULL, fr_dict_attr_test_nested_leaf_int32);
416 TEST_CASE("Find child node in second TLV");
417 TEST_CHECK_PAIR(vp_found, vp2);
418
419 vp_found = fr_pair_find_by_da_nested(&local_pairs, vp_found, fr_dict_attr_test_nested_leaf_string);
420 TEST_CASE("Look for child in first node after second");
421 TEST_CHECK_PAIR(vp_found, NULL);
422
423 /*
424 * Add third nested TLV with child of same type as first
425 */
426 MEM(vp3 = fr_pair_afrom_da(autofree, fr_dict_attr_test_nested_top_tlv));
427 fr_pair_append(&local_pairs, vp3);
428 MEM(vp4 = fr_pair_afrom_da(vp3, fr_dict_attr_test_nested_child_tlv));
429 fr_pair_append(&vp3->vp_group, vp4);
430 MEM(vp3 = fr_pair_afrom_da(vp4, fr_dict_attr_test_nested_leaf_string));
431 fr_pair_append(&vp4->vp_group, vp3);
432
433 /*
434 * Repeat search 3 times to find both instances and then NULL
435 */
436 vp_found = fr_pair_find_by_da_nested(&local_pairs, NULL, fr_dict_attr_test_nested_leaf_string);
437 TEST_CASE("Find child node in first TLV");
438 TEST_CHECK_PAIR(vp_found, vp1);
439
440 vp_found = fr_pair_find_by_da_nested(&local_pairs, vp_found, fr_dict_attr_test_nested_leaf_string);
441 TEST_CASE("Find child node in third TLV");
442 TEST_CHECK_PAIR(vp_found, vp3);
443
444 vp_found = fr_pair_find_by_da_nested(&local_pairs, vp_found, fr_dict_attr_test_nested_leaf_string);
445 TEST_CASE("Find child node after third TLV");
446 TEST_CHECK_PAIR(vp_found, NULL);
447
448 /*
449 * Add some "flat list" attributes
450 */
451 MEM(vp4 = fr_pair_afrom_da(autofree, fr_dict_attr_test_nested_leaf_string));
452 fr_pair_prepend(&local_pairs, vp4);
453 MEM(vp5 = fr_pair_afrom_da(autofree, fr_dict_attr_test_nested_leaf_string));
454 fr_pair_append(&local_pairs, vp5);
455
456 /*
457 * Repeat search 5 times to find all instances and then NULL
458 * fr_pair_find_by_da_nested searches nested first then flat
459 */
460 vp_found = fr_pair_find_by_da_nested(&local_pairs, NULL, fr_dict_attr_test_nested_leaf_string);
461 TEST_CASE("Find child node in first TLV");
462 TEST_CHECK_PAIR(vp_found, vp1);
463
464 vp_found = fr_pair_find_by_da_nested(&local_pairs, vp_found, fr_dict_attr_test_nested_leaf_string);
465 TEST_CASE("Find child node in third TLV");
466 TEST_CHECK_PAIR(vp_found, vp3);
467
468 vp_found = fr_pair_find_by_da_nested(&local_pairs, vp_found, fr_dict_attr_test_nested_leaf_string);
469 TEST_CASE("Find first entry in \"flat\" list");
470 TEST_CHECK_PAIR(vp_found, vp4);
471
472 vp_found = fr_pair_find_by_da_nested(&local_pairs, vp_found, fr_dict_attr_test_nested_leaf_string);
473 TEST_CASE("Find second \"flat\" list entry");
474 TEST_CHECK_PAIR(vp_found, vp5);
475
476 vp_found = fr_pair_find_by_da_nested(&local_pairs, vp_found, fr_dict_attr_test_nested_leaf_string);
477 TEST_CASE("Find NULL at end of list");
478 TEST_CHECK_PAIR(vp_found, NULL);
479
480 fr_pair_list_free(&local_pairs);
481}
482
483static void test_fr_pair_append(void)
484{
485 fr_dcursor_t cursor;
486 fr_pair_t *vp;
487 fr_pair_list_t local_pairs;
488 size_t count = 0;
489
490 TEST_CASE("Add 3 pairs using fr_pair_append()");
491
492 fr_pair_list_init(&local_pairs);
493
494 MEM(vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_octets));
495 fr_pair_append(&local_pairs, vp);
496 MEM(vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_uint32));
497 fr_pair_append(&local_pairs, vp);
498 MEM(vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_tlv));
499 fr_pair_append(&local_pairs, vp);
500
501 /* lets' count */
502 for (vp = fr_pair_dcursor_init(&cursor, &local_pairs);
503 vp;
504 vp = fr_dcursor_next(&cursor)) count++;
505
506 TEST_CASE("Expected (count == 3)");
507 TEST_CHECK(count == 3);
508
509 fr_pair_list_free(&local_pairs);
510}
511
512static void test_fr_pair_append_by_da_parent(void)
513{
514 fr_pair_t *leaf1, *leaf2, *found, *inter1, *inter2;
515 fr_pair_list_t local_pairs;
516 int ret;
517
518 fr_pair_list_init(&local_pairs);
519
520 TEST_CASE("Add nested attribute including parents");
521 ret = fr_pair_append_by_da_parent(autofree, &leaf1, &local_pairs, fr_dict_attr_test_nested_leaf_int32);
522 TEST_CHECK(ret == 0);
523 TEST_CHECK(leaf1 != NULL);
524
525 TEST_CASE("Check nested attributes added");
526 found = fr_pair_find_by_da(&local_pairs, NULL, fr_dict_attr_test_nested_top_tlv);
527 TEST_ASSERT(found != NULL);
528 inter1 = found;
529 found = fr_pair_find_by_da(&inter1->vp_group, NULL, fr_dict_attr_test_nested_child_tlv);
530 TEST_ASSERT(found != NULL);
531 inter2 = found;
532 found = fr_pair_find_by_da(&inter2->vp_group, NULL, fr_dict_attr_test_nested_leaf_int32);
533 TEST_CHECK_PAIR(found, leaf1);
534
535 TEST_CASE("Ensure no flat list attribute created");
536 found = fr_pair_find_by_da(&local_pairs, NULL, fr_dict_attr_test_nested_leaf_int32);
537 TEST_CHECK_PAIR(found, NULL);
538
539 TEST_CASE("Add additional nested attribute where parents exist");
540 ret = fr_pair_append_by_da_parent(autofree, &leaf2, &local_pairs, fr_dict_attr_test_nested_leaf_string);
541 TEST_CHECK(ret == 0);
542 TEST_CHECK(leaf2 != NULL);
543 TEST_CHECK(leaf2 != leaf1);
544
545 TEST_CASE("Check additional leaf added under existing parent");
546 found = fr_pair_find_by_da(&inter2->vp_group, NULL, fr_dict_attr_test_nested_leaf_string);
547 TEST_CHECK_PAIR(found, leaf2);
548
549 TEST_CASE("Check no extra parent attributes created");
550 found = fr_pair_find_by_da(&local_pairs, NULL, fr_dict_attr_test_nested_top_tlv);
551 TEST_CHECK_PAIR(found, inter1);
552 found = fr_pair_find_by_da(&local_pairs, inter1, fr_dict_attr_test_nested_top_tlv);
553 TEST_CHECK_PAIR(found, NULL);
554
555 found = fr_pair_find_by_da(&inter1->vp_group, NULL, fr_dict_attr_test_nested_child_tlv);
556 TEST_CHECK_PAIR(found, inter2);
557 found = fr_pair_find_by_da(&inter1->vp_group, inter2, fr_dict_attr_test_nested_child_tlv);
558 TEST_CHECK_PAIR(found, NULL);
559
560 fr_pair_list_free(&local_pairs);
561}
562
563static void test_fr_pair_delete_by_child_num(void)
564{
565 TEST_CASE("Delete fr_dict_attr_test_string using fr_pair_delete_by_child_num()");
566 fr_pair_delete_by_child_num(&test_pairs, fr_dict_root(test_dict), FR_TEST_ATTR_STRING);
567
568 TEST_CASE("The fr_dict_attr_test_string shouldn't exist in 'test_pairs'");
569 TEST_CHECK(fr_pair_find_by_child_num_idx(&test_pairs, fr_dict_root(test_dict), FR_TEST_ATTR_STRING, 0) == NULL);
570
571 TEST_CASE("Add fr_dict_attr_test_string back into 'test_pairs'");
572 TEST_CHECK(fr_pair_prepend_by_da(autofree, NULL, &test_pairs, fr_dict_attr_test_string) == 0);
573}
574
575static void test_fr_pair_prepend_by_da(void)
576{
577 fr_dcursor_t cursor;
578 fr_pair_t *vp;
579 fr_pair_list_t local_pairs;
580 TALLOC_CTX *ctx = talloc_null_ctx();
581
582 fr_pair_list_init(&local_pairs);
583
584 TEST_CASE("Add using fr_pair_prepend_by_da()");
585 TEST_CHECK(fr_pair_prepend_by_da(ctx, NULL, &local_pairs, fr_dict_attr_test_string) == 0);
586
587 /* lets' count */
588 for (vp = fr_pair_dcursor_init(&cursor, &local_pairs);
589 vp;
590 vp = fr_dcursor_next(&cursor)) {
591 TEST_CASE("Expected (vp->da == fr_dict_attr_test_string)");
592 TEST_CHECK(vp->da == fr_dict_attr_test_string);
593 }
594
595 fr_pair_list_free(&local_pairs);
596}
597
598static void test_fr_pair_update_by_da_parent(void)
599{
600 fr_pair_t *vp, *group;
601
602 TEST_CHECK((group = fr_pair_afrom_da(autofree, fr_dict_attr_test_group)) != NULL);
603 if (!group) return; /* quiet clang scan */
604
605 TEST_CASE("Update Add using fr_pair_prepend_by_da()");
606 TEST_CHECK(fr_pair_update_by_da_parent(group, &vp, fr_dict_attr_test_uint32) == 0); /* attribute doesn't exist in this group */
607 vp->vp_uint32 = 54321;
608
609 TEST_CASE("Expected fr_dict_attr_test_uint32 (vp->vp_uint32 == 54321)");
610 TEST_CHECK((vp = fr_pair_find_by_da(&group->vp_group, NULL, fr_dict_attr_test_uint32)) != NULL);
611
612 TEST_CASE("Validating PAIR_VERIFY()");
613 PAIR_VERIFY(vp);
614
615 TEST_CASE("Expected (vp == 54321)");
616 TEST_CHECK(vp && vp->vp_uint32 == 54321);
617
618 talloc_free(group);
619}
620
621static void test_fr_pair_delete_by_da(void)
622{
623 TEST_CASE("Delete fr_dict_attr_test_string using fr_pair_delete_by_da()");
624 TEST_CHECK(fr_pair_delete_by_da(&test_pairs, fr_dict_attr_test_string) == 1);
625
626 TEST_CASE("The fr_dict_attr_test_string shouldn't exist in 'test_pairs'");
627 TEST_CHECK(fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_string) == NULL);
628
629 TEST_CASE("Add fr_dict_attr_test_string back into 'test_pairs'");
630 TEST_CHECK(fr_pair_prepend_by_da(autofree, NULL, &test_pairs, fr_dict_attr_test_string) == 0);
631}
632
633static void test_fr_pair_delete(void)
634{
635 fr_pair_t *vp;
636
637 TEST_CASE("Delete fr_dict_attr_test_string using fr_pair_delete()");
638 TEST_CHECK((vp = fr_pair_find_by_child_num_idx(&test_pairs, fr_dict_root(test_dict), FR_TEST_ATTR_STRING, 0)) != NULL);
639 fr_pair_delete(&test_pairs, vp);
640
641 TEST_CASE("The fr_dict_attr_test_string shouldn't exist in 'test_pairs'");
642 TEST_CHECK((vp = fr_pair_find_by_child_num_idx(&test_pairs, fr_dict_root(test_dict), FR_TEST_ATTR_STRING, 0)) == NULL);
643
644 TEST_CASE("Add fr_dict_attr_test_string back into 'test_pairs'");
645 TEST_CHECK(fr_pair_prepend_by_da(autofree, NULL, &test_pairs, fr_dict_attr_test_string) == 0);
646}
647
648static void test_fr_pair_cmp(void)
649{
650 fr_pair_t *vp1, *vp2;
651
652 TEST_CASE("Create the vp1 'Test-Integer = 123'");
653 TEST_CHECK((vp1 = fr_pair_afrom_da(autofree, fr_dict_attr_test_uint32)) != NULL);
654
655 TEST_CASE("Validating PAIR_VERIFY()");
656 PAIR_VERIFY(vp1);
657
658 vp1->op = T_OP_EQ;
659 vp1->vp_uint32 = 123;
660
661 TEST_CASE("Create the vp2 'Test-Integer = 321'");
662 TEST_CHECK((vp2 = fr_pair_afrom_da(autofree, fr_dict_attr_test_uint32)) != NULL);
663
664 TEST_CASE("Validating PAIR_VERIFY()");
665 PAIR_VERIFY(vp2);
666
667 vp2->op = T_OP_CMP_EQ;
668 vp2->vp_uint32 = 321;
669
670 TEST_CASE("Compare fr_pair_cmp(vp1 == vp2) should be FALSE");
671 TEST_CHECK(fr_pair_cmp(vp1, vp2) == 0);
672}
673
674static void test_fr_pair_list_cmp(void)
675{
676 fr_pair_list_t local_pairs1, local_pairs2;
677
678 fr_pair_list_init(&local_pairs1);
679 fr_pair_list_init(&local_pairs2);
680
681 TEST_CASE("Create 'local_pairs1'");
682 TEST_CHECK(fr_pair_test_list_alloc(autofree, &local_pairs1, NULL) == 0);
683
684 TEST_CASE("Create 'local_pairs2'");
685 TEST_CHECK(fr_pair_test_list_alloc(autofree, &local_pairs2, NULL) == 0);
686
687 TEST_CASE("Check if 'local_pairs1' == 'local_pairs2' using fr_pair_list_cmp()");
688 TEST_CHECK(fr_pair_list_cmp(&local_pairs1, &local_pairs2) == 0);
689
690 fr_pair_list_free(&local_pairs1);
691 fr_pair_list_free(&local_pairs2);
692}
693
694static void test_fr_pair_list_copy(void)
695{
696 fr_pair_list_t local_pairs;
697
698 fr_pair_list_init(&local_pairs);
699
700 TEST_CASE("Copy 'test_pairs' into 'local_pairs'");
701 TEST_CHECK(fr_pair_list_copy(autofree, &local_pairs, &test_pairs) > 0);
702
703 TEST_CASE("Check if 'local_pairs' == 'test_pairs' using fr_pair_list_cmp()");
704 TEST_CHECK(fr_pair_list_cmp(&local_pairs, &test_pairs) == 0);
705
706 fr_pair_list_free(&local_pairs);
707}
708
709static void test_fr_pair_list_copy_by_da(void)
710{
711 fr_dcursor_t cursor;
712 fr_pair_t *vp;
713 fr_pair_list_t local_pairs;
714
715 fr_pair_list_init(&local_pairs);
716
717 TEST_CASE("Copy 'test_pairs' into 'local_pairs'");
718 TEST_CHECK(fr_pair_list_copy_by_da(autofree, &local_pairs, &test_pairs, fr_dict_attr_test_string, 0) > 0);
719
720 TEST_CASE("The 'local_pairs' should have only fr_dict_attr_test_string");
721 for (vp = fr_pair_dcursor_init(&cursor, &local_pairs);
722 vp;
723 vp = fr_dcursor_next(&cursor)) {
724 TEST_CASE("Validating PAIR_VERIFY()");
725 PAIR_VERIFY(vp);
726
727 TEST_CASE("Expected (vp->da == fr_dict_attr_test_string)");
728 TEST_CHECK(vp->da == fr_dict_attr_test_string);
729 }
730
731 fr_pair_list_free(&local_pairs);
732}
733
734static void test_fr_pair_list_copy_by_ancestor(void)
735{
736 fr_pair_t *vp;
737 fr_pair_list_t local_pairs;
738
739 fr_pair_list_init(&local_pairs);
740
741 TEST_CASE("Copy 'test_pairs' into 'local_pairs'");
742 TEST_CHECK(fr_pair_list_copy_by_ancestor(autofree, &local_pairs, &test_pairs, fr_dict_attr_test_tlv) > 0);
743
744 TEST_CASE("The 'local_pairs' should have only one attribute in it");
745 TEST_CHECK(fr_pair_list_num_elements(&local_pairs) == 1);
746
747 TEST_CASE("The 'local_pairs' should have only fr_dict_attr_test_tlv_string (ancestor of 'Test-TLV-Root'");
748 vp = fr_pair_list_head(&local_pairs);
749
750 TEST_CASE("Validating we copied the attribute");
751 TEST_CHECK(vp != NULL);
752 if (!vp) return;
753
754#ifdef TEST_NESTED_PAIRS
755 TEST_CASE("Expected copied attribute == fr_dict_attr_test_tlv)");
756 TEST_CHECK(vp->da == fr_dict_attr_test_tlv);
757#else
758 TEST_CASE("Expected copied attribute == fr_dict_attr_test_tlv_string)");
759 TEST_CHECK(vp->da == fr_dict_attr_test_tlv_string);
760#endif
761
762 TEST_CASE("Verifying the copied attribute");
763 PAIR_VERIFY(vp);
764
765 TEST_CASE("Expecting nothing else in local list");
766 TEST_CHECK(fr_pair_list_next(&local_pairs, vp) == NULL);
767
768 fr_pair_list_free(&local_pairs);
769}
770
771static void test_fr_pair_list_sort(void)
772{
773 fr_dcursor_t cursor;
774 fr_pair_t *vp;
775 fr_pair_list_t local_pairs;
776 TALLOC_CTX *ctx = talloc_null_ctx();
777
778 TEST_CASE("Create 'local_pairs' with 3 attributes not ordered");
779 fr_pair_list_init(&local_pairs);
780
781 TEST_CASE("Add fr_dict_attr_test_string back into 'local_pairs'");
782 TEST_CHECK(fr_pair_prepend_by_da(ctx, NULL, &local_pairs, fr_dict_attr_test_date) == 0);
783 TEST_CHECK(fr_pair_prepend_by_da(ctx, NULL, &local_pairs, fr_dict_attr_test_ipv4_addr) == 0);
784 TEST_CHECK(fr_pair_prepend_by_da(ctx, NULL, &local_pairs, fr_dict_attr_test_octets) == 0);
785 TEST_CHECK(fr_pair_prepend_by_da(ctx, NULL, &local_pairs, fr_dict_attr_test_uint32) == 0);
786 TEST_CHECK(fr_pair_prepend_by_da(ctx, NULL, &local_pairs, fr_dict_attr_test_enum) == 0); // It will be go to the tail
787 TEST_CHECK(fr_pair_prepend_by_da(ctx, NULL, &local_pairs, fr_dict_attr_test_string) == 0);
788
789 /*
790 * FIXME - This test doesn't check for intra-type stability
791 */
792 TEST_CASE("Sorting 'local_pairs' by fr_pair_list_sort(local_pairs, fr_pair_cmp_by_da)");
793 fr_pair_list_sort(&local_pairs, fr_pair_cmp_by_da);
794
795 TEST_CASE("1st (da == fr_dict_attr_test_string)");
796 TEST_CHECK((vp = fr_pair_dcursor_init(&cursor, &local_pairs)) != NULL);
797 TEST_CHECK(vp && vp->da == fr_dict_attr_test_string);
798
799 TEST_CASE("2nd (da == fr_dict_attr_test_octets)");
800 TEST_CHECK((vp = fr_dcursor_next(&cursor)) != NULL);
801 TEST_CHECK(vp && vp->da == fr_dict_attr_test_octets);
802
803 TEST_CASE("3rd (da == fr_dict_attr_test_ipv4_addr)");
804 TEST_CHECK((vp = fr_dcursor_next(&cursor)) != NULL);
805 TEST_CHECK(vp && vp->da == fr_dict_attr_test_ipv4_addr);
806
807 TEST_CASE("4th (da == fr_dict_attr_test_uint32)");
808 TEST_CHECK((vp = fr_dcursor_next(&cursor)) != NULL);
809 TEST_CHECK(vp && vp->da == fr_dict_attr_test_uint32);
810
811 TEST_CASE("5th (da == fr_dict_attr_test_date)");
812 TEST_CHECK((vp = fr_dcursor_next(&cursor)) != NULL);
813 TEST_CHECK(vp && vp->da == fr_dict_attr_test_date);
814
815 TEST_CASE("6th (da == fr_dict_attr_test_enum)");
816 TEST_CHECK((vp = fr_dcursor_next(&cursor)) != NULL);
817 TEST_CHECK(vp && vp->da == fr_dict_attr_test_enum);
818
819 fr_pair_list_free(&local_pairs);
820}
821
822static void test_fr_pair_value_copy(void)
823{
824 fr_pair_t *vp1, *vp2;
825
826 TEST_CASE("Create 'vp1' with Test-Integer = 123");
827 TEST_CHECK((vp1 = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_uint32)) != NULL);
828 vp1->vp_uint32 = 123;
829
830 TEST_CASE("Validating PAIR_VERIFY()");
831 PAIR_VERIFY(vp1);
832
833 TEST_CASE("Create 'vp2'");
834 TEST_CHECK((vp2 = fr_pair_afrom_da(autofree, fr_dict_attr_test_uint32)) != NULL);
835
836 TEST_CASE("Validating PAIR_VERIFY()");
837 PAIR_VERIFY(vp2);
838
839 TEST_CASE("Copy 'vp1' to 'vp2' using fr_pair_value_copy()");
840 TEST_CHECK(fr_pair_value_copy(vp2, vp1) == 0);
841
842 TEST_CASE("Validating PAIR_VERIFY()");
843 PAIR_VERIFY(vp2);
844
845 TEST_CASE("Check (vp1 == vp2)");
846 TEST_CHECK(vp2->vp_uint32 == 123);
847}
848
849static void test_fr_pair_value_from_str(void)
850{
851 fr_pair_t *vp;
852
853 TEST_CASE("Find 'Test-String'");
854 TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_string)) != NULL);
855
856 TEST_CASE("Validating PAIR_VERIFY()");
857 PAIR_VERIFY(vp);
858
859 TEST_CASE("Convert 'test_string' value to attribute value using fr_pair_value_from_str()");
860 TEST_CHECK(fr_pair_value_from_str(vp, test_string, strlen(test_string), &fr_value_unescape_double, false) == 0);
861
862 TEST_CASE("Validating PAIR_VERIFY()");
863 PAIR_VERIFY(vp);
864
865 TEST_CASE("Check (vp->vp_string == test_string)");
866 TEST_CHECK(vp && strcmp(vp->vp_strvalue, test_string) == 0);
867}
868
869static void test_fr_pair_value_strdup(void)
870{
871 fr_pair_t *vp;
872
873 TEST_CASE("Find 'Test-String'");
874 TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_string)) != NULL);
875
876 TEST_CASE("Validating PAIR_VERIFY()");
877 PAIR_VERIFY(vp);
878
879 TEST_CASE("Copy content of 'test_string' to attribute value using fr_pair_value_strdup()");
880 TEST_CHECK(fr_pair_value_strdup(vp, test_string, false) == 0);
881
882 TEST_CASE("Validating PAIR_VERIFY()");
883 PAIR_VERIFY(vp);
884
885 TEST_CASE("Check (vp->vp_string == test_string)");
886 TEST_CHECK(vp && strcmp(vp->vp_strvalue, test_string) == 0);
887}
888
889static void test_fr_pair_value_strdup_shallow(void)
890{
891 fr_pair_t *vp, *nvp;
892 char *copy_test_string;
893
894 TEST_CASE("Find 'Test-String'");
895 TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_string)) != NULL);
896
897 TEST_CASE("Validating PAIR_VERIFY()");
898 PAIR_VERIFY(vp);
899
900 MEM(nvp = fr_pair_copy(NULL, vp));
901
902 copy_test_string = talloc_strdup(nvp, test_string);
903 talloc_set_type(copy_test_string, char);
904
905 TEST_CASE("Copy content of 'test_string' to attribute value using fr_pair_value_strdup_shallow()");
906 TEST_CHECK(fr_pair_value_strdup_shallow(nvp, copy_test_string, true) == 0);
907
908 TEST_CASE("Validating PAIR_VERIFY()");
909 PAIR_VERIFY(nvp);
910
911 TEST_CASE("Check (vp->vp_string == copy_test_string)");
912 TEST_CHECK(nvp && strncmp(nvp->vp_strvalue, test_string, strlen(copy_test_string)) == 0);
913
914 talloc_free(nvp);
915}
916
917static void test_fr_pair_value_strtrim(void)
918{
919 fr_pair_t *vp;
920
921 TEST_CASE("Find 'Test-String'");
922 TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_string)) != NULL);
923
924 TEST_CASE("Validating PAIR_VERIFY()");
925 PAIR_VERIFY(vp);
926
927 TEST_CASE("Copy content of 'test_string' to attribute value using fr_pair_value_strdup_shallow()");
928 TEST_CHECK(fr_pair_value_strdup(vp, test_string, false) == 0);
929
930 TEST_CASE("Trim the length of the string buffer using fr_pair_value_strtrim()");
931 TEST_CHECK(fr_pair_value_strtrim(vp) == 0);
932
933 TEST_CASE("Validating PAIR_VERIFY()");
934 PAIR_VERIFY(vp);
935
936 TEST_CASE("Check (vp->vp_string == test_string)");
937 TEST_CHECK(vp && strcmp(vp->vp_strvalue, test_string) == 0);
938}
939
940static void test_fr_pair_value_aprintf(void)
941{
942 fr_pair_t *vp;
943 char fmt_test[64];
944 fr_time_t now = fr_time();
945
946 snprintf(fmt_test, sizeof(fmt_test), "Now is %"PRId64, fr_time_unwrap(now));
947
948 TEST_CASE("Find 'Test-String'");
949 TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_string)) != NULL);
950
951 TEST_CASE("Validating PAIR_VERIFY()");
952 PAIR_VERIFY(vp);
953
954 TEST_CASE("Copy content of 'fmt_test' to attribute value using fr_pair_value_aprintf()");
955 TEST_CHECK(fr_pair_value_aprintf(vp, "Now is %"PRId64, fr_time_unwrap(now)) == 0);
956
957 TEST_CASE("Validating PAIR_VERIFY()");
958 PAIR_VERIFY(vp);
959
960 TEST_CASE("Check (vp->vp_string == fmt_test)");
961 TEST_CHECK(vp && strcmp(vp->vp_strvalue, fmt_test) == 0);
962}
963
964static void test_fr_pair_value_bstr_alloc(void)
965{
966 fr_pair_t *vp;
967 char *out = NULL;
968
969 TEST_CASE("Find 'Test-String'");
970 TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_string)) != NULL);
971
972 TEST_CASE("Validating PAIR_VERIFY()");
973 PAIR_VERIFY(vp);
974
975 TEST_CASE("Pre-allocate a memory buffer using fr_pair_value_bstr_alloc()");
976 TEST_CHECK(fr_pair_value_bstr_alloc(vp, &out, test_string_len, false) == 0);
977
978 TEST_CASE("Validating PAIR_VERIFY()");
979 PAIR_VERIFY(vp);
980
981 TEST_CASE("Copy 'test_string' to the pre-allocated pointer");
982 TEST_CHECK(strlcpy(out, test_string, test_string_len) == test_string_len);
983
984 TEST_CASE("Check (out == test_string)");
985 TEST_CHECK(memcmp(out, test_string, test_string_len-1) == 0);
986
987 TEST_CASE("Check (vp->vp_string == test_string)");
988 TEST_CHECK(vp && memcmp(vp->vp_strvalue, test_string, test_string_len-1) == 0);
989}
990
991static void test_fr_pair_value_bstr_realloc(void)
992{
993 fr_pair_t *vp;
994 char *out = NULL;
995
996 TEST_CASE("Find 'Test-String'");
997 TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_string)) != NULL);
998
999 TEST_CASE("Validating PAIR_VERIFY()");
1000 PAIR_VERIFY(vp);
1001
1002 TEST_CASE("Pre-allocate 1 byte of memory buffer using fr_pair_value_bstr_alloc()");
1003 TEST_CHECK(fr_pair_value_bstr_alloc(vp, &out, 1, false) == 0);
1004
1005 TEST_CASE("Re-allocate (test_string_len-1) byte of memory buffer using fr_pair_value_bstr_realloc()");
1006 TEST_CHECK(fr_pair_value_bstr_realloc(vp, &out, (test_string_len - 1)) == 0);
1007
1008 TEST_CASE("Validating PAIR_VERIFY()");
1009 PAIR_VERIFY(vp);
1010
1011 TEST_CASE("Copy 'test_string' to the pre-allocated pointer");
1012 TEST_CHECK(strlcpy(out, test_string, test_string_len) == test_string_len);
1013
1014 TEST_CASE("Check (out == test_string)");
1015 TEST_CHECK(memcmp(out, test_string, test_string_len-1) == 0);
1016
1017 TEST_CASE("Check (vp->vp_string == test_string)");
1018 TEST_CHECK(vp && memcmp(vp->vp_strvalue, test_string, test_string_len-1) == 0);
1019}
1020
1021static void test_fr_pair_value_bstrndup(void)
1022{
1023 fr_pair_t *vp;
1024
1025 TEST_CASE("Find 'Test-String'");
1026 TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_string)) != NULL);
1027
1028 TEST_CASE("Validating PAIR_VERIFY()");
1029 PAIR_VERIFY(vp);
1030
1031 TEST_CASE("Copy content of 'test_string' to attribute value using fr_pair_value_bstrndup()");
1032 TEST_CHECK(fr_pair_value_bstrndup(vp, test_string, test_string_len-1, false) == 0);
1033
1034 TEST_CASE("Check (vp->vp_string == test_string)");
1035 TEST_CHECK(vp && memcmp(vp->vp_strvalue, test_string, test_string_len-1) == 0);
1036}
1037
1038static void test_fr_pair_value_bstrdup_buffer(void)
1039{
1040 fr_pair_t *vp;
1041 char *copy_test_string;
1042
1043 TEST_CASE("Find 'Test-String'");
1044 TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_string)) != NULL);
1045
1046 TEST_CASE("Validating PAIR_VERIFY()");
1047 PAIR_VERIFY(vp);
1048
1049 copy_test_string = talloc_strdup(vp, test_string);
1050 talloc_set_type(copy_test_string, char);
1051
1052 TEST_CASE("Copy content of 'copy_test_string' to attribute value using fr_pair_value_bstrdup_buffer()");
1053 TEST_CHECK(fr_pair_value_bstrdup_buffer(vp, copy_test_string, false) == 0);
1054
1055 TEST_CASE("Check (vp->vp_string == test_string)");
1056 TEST_CHECK(vp && strcmp(vp->vp_strvalue, copy_test_string) == 0);
1057
1058 talloc_free(copy_test_string);
1059}
1060
1061static void test_fr_pair_value_bstrndup_shallow(void)
1062{
1063 fr_pair_t *vp;
1064 char *copy_test_string;
1065
1066 TEST_CASE("Find 'Test-String'");
1067 TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_string)) != NULL);
1068
1069 TEST_CASE("Validating PAIR_VERIFY()");
1070 PAIR_VERIFY(vp);
1071
1072 copy_test_string = talloc_strdup(vp, test_string);
1073 talloc_set_type(copy_test_string, char);
1074
1075 TEST_CASE("Copy content of 'test_string' to attribute value using fr_pair_value_bstrndup_shallow()");
1076 TEST_CHECK(fr_pair_value_bstrndup_shallow(vp, copy_test_string, strlen(copy_test_string), true) == 0);
1077
1078 TEST_CASE("Check (vp->vp_string == copy_test_string)");
1079 TEST_CHECK(vp && strncmp(vp->vp_strvalue, test_string, test_string_len) == 0);
1080
1081 talloc_free(copy_test_string);
1082}
1083
1084static void test_fr_pair_value_bstrdup_buffer_shallow(void)
1085{
1086 fr_pair_t *vp;
1087 char *copy_test_string;
1088
1089 TEST_CASE("Find 'Test-String'");
1090 TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_string)) != NULL);
1091
1092 TEST_CASE("Validating PAIR_VERIFY()");
1093 PAIR_VERIFY(vp);
1094
1095 copy_test_string = talloc_strdup(vp, test_string);
1096 talloc_set_type(copy_test_string, char);
1097
1098 TEST_CASE("Copy content of 'test_string' to attribute value using fr_pair_value_bstrdup_buffer_shallow()");
1099 TEST_CHECK(fr_pair_value_bstrdup_buffer_shallow(vp, copy_test_string, true) == 0);
1100
1101 TEST_CASE("Check (vp->vp_string == copy_test_string)");
1102 TEST_CHECK(vp && strncmp(vp->vp_strvalue, test_string, test_string_len) == 0);
1103
1104 talloc_free(copy_test_string);
1105}
1106
1107static void test_fr_pair_value_bstrn_append(void)
1108{
1109 fr_pair_t *vp;
1110 char *copy_test_string;
1111
1112 TEST_CASE("Find 'Test-String'");
1113 TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_string)) != NULL);
1114
1115 TEST_CASE("Validating PAIR_VERIFY()");
1116 PAIR_VERIFY(vp);
1117
1118 copy_test_string = talloc_strdup(vp, test_string);
1119 talloc_set_type(copy_test_string, char);
1120
1121 TEST_CASE("Copy content of 'test_string' to attribute value using fr_pair_value_bstrndup()");
1122 TEST_CHECK(fr_pair_value_bstrndup(vp, test_string, test_string_len, false) == 0);
1123
1124 TEST_CASE("Append the 'copy_test_string' value using fr_pair_value_bstrn_append()");
1125 TEST_CHECK(fr_pair_value_bstrn_append(vp, copy_test_string, test_string_len, true) == 0);
1126
1127 // awful hack, just verify the first part of buffer and then the second part. yep, just appended twice.
1128 TEST_CASE("Check 1. part (vp->vp_string == test_string)");
1129 TEST_CHECK(vp && strncmp(vp->vp_strvalue, test_string, test_string_len) == 0);
1130
1131 TEST_CASE("Check 2. part ((vp->vp_string+test_string_len) == test_string)");
1132 TEST_CHECK(vp && strncmp(vp->vp_strvalue+test_string_len, test_string, test_string_len) == 0);
1133
1134 talloc_free(copy_test_string);
1135}
1136
1137static void test_fr_pair_value_bstr_append_buffer(void)
1138{
1139 fr_pair_t *vp;
1140 char *copy_test_string;
1141
1142 TEST_CASE("Find 'Test-String'");
1143 TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_string)) != NULL);
1144
1145 TEST_CASE("Validating PAIR_VERIFY()");
1146 PAIR_VERIFY(vp);
1147
1148 copy_test_string = talloc_strdup(vp, test_string);
1149 talloc_set_type(copy_test_string, char);
1150
1151 TEST_CASE("Copy content of 'test_string' to attribute value using fr_pair_value_bstrndup()");
1152 TEST_CHECK(fr_pair_value_bstrndup(vp, test_string, test_string_len, false) == 0);
1153
1154 TEST_CASE("Append the 'copy_test_string' value using fr_pair_value_bstr_append_buffer()");
1155 TEST_CHECK(fr_pair_value_bstr_append_buffer(vp, copy_test_string, true) == 0);
1156
1157 TEST_CASE("Validating PAIR_VERIFY()");
1158 PAIR_VERIFY(vp);
1159
1160 // awful hack, just verify the first part of buffer and then the second part. yep, just appended twice.
1161 TEST_CASE("Check 1. part (vp->vp_string == test_string)");
1162 TEST_CHECK(vp && strncmp(vp->vp_strvalue, test_string, test_string_len) == 0);
1163
1164 TEST_CASE("Check 2. part ((vp->vp_string+test_string_len) == test_string)");
1165 TEST_CHECK(vp && strncmp(vp->vp_strvalue+test_string_len, test_string, test_string_len) == 0);
1166
1167 talloc_free(copy_test_string);
1168}
1169
1170static void test_fr_pair_value_mem_alloc(void)
1171{
1172 fr_pair_t *vp;
1173 uint8_t *out;
1174
1175 TEST_CASE("Find 'Test-Octets'");
1176 TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_octets)) != NULL);
1177
1178 TEST_CASE("Validating PAIR_VERIFY()");
1179 PAIR_VERIFY(vp);
1180
1181 TEST_CASE("Pre-allocate a memory buffer using fr_pair_value_bstr_alloc()");
1182 TEST_CHECK(fr_pair_value_mem_alloc(vp, &out, NUM_ELEMENTS(test_octets), false) == 0);
1183
1184 TEST_CASE("Copy 'test_octets' to the pre-allocated pointer");
1185 TEST_CHECK(memcpy(out, test_octets, NUM_ELEMENTS(test_octets)) != NULL);
1186
1187 TEST_CASE("Check (out == test_octets)");
1188 TEST_CHECK(memcmp(out, test_octets, NUM_ELEMENTS(test_octets)) == 0);
1189
1190 TEST_CASE("Check (vp->vp_octets == test_octets)");
1191 TEST_CHECK(vp && memcmp(vp->vp_octets, test_octets, NUM_ELEMENTS(test_octets)) == 0);
1192}
1193
1194static void test_fr_pair_value_mem_realloc(void)
1195{
1196 fr_pair_t *vp;
1197 uint8_t *out;
1198
1199 TEST_CASE("Find 'Test-Octets'");
1200 TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_octets)) != NULL);
1201
1202 TEST_CASE("Validating PAIR_VERIFY()");
1203 PAIR_VERIFY(vp);
1204
1205 TEST_CASE("Pre-allocate a memory buffer using fr_pair_value_bstr_alloc()");
1206 TEST_CHECK(fr_pair_value_mem_alloc(vp, &out, NUM_ELEMENTS(test_octets), false) == 0);
1207
1208 TEST_CASE("Copy 'test_octets' to the pre-allocated pointer");
1209 TEST_CHECK(memcpy(out, test_octets, NUM_ELEMENTS(test_octets)) != NULL);
1210
1211 TEST_CASE("Realloc pre-allocated pointer to fit extra 'test_octets' copy");
1212 TEST_CHECK(fr_pair_value_mem_realloc(vp, &out, NUM_ELEMENTS(test_octets)*2) == 0);
1213
1214 TEST_CASE("Copy 'test_octets' into the tail");
1215 TEST_CHECK(memcpy(out+NUM_ELEMENTS(test_octets), test_octets, NUM_ELEMENTS(test_octets)) != NULL);
1216
1217 TEST_CASE("Check first chunk (out == test_octets)");
1218 TEST_CHECK(memcmp(out, test_octets, NUM_ELEMENTS(test_octets)) == 0);
1219
1220 TEST_CHECK(vp != NULL);
1221
1222 TEST_CASE("Check first chunk (vp->vp_octets == test_octets)");
1223 TEST_CHECK(vp && memcmp(vp->vp_octets, test_octets, NUM_ELEMENTS(test_octets)) == 0);
1224
1225 TEST_CASE("Check second chunk (out+NUM_ELEMENTS(test_octets) == test_octets)");
1226 TEST_CHECK(memcmp(out+NUM_ELEMENTS(test_octets), test_octets, NUM_ELEMENTS(test_octets)) == 0);
1227
1228 TEST_CASE("Check second chunk (vp->vp_octets+NUM_ELEMENTS(test_octets) == test_octets)");
1229 TEST_CHECK(vp && memcmp(vp->vp_octets+NUM_ELEMENTS(test_octets), test_octets, NUM_ELEMENTS(test_octets)) == 0);
1230}
1231
1232static void test_fr_pair_value_memdup(void)
1233{
1234 fr_pair_t *vp;
1235
1236 TEST_CASE("Find 'Test-Octets'");
1237 TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_octets)) != NULL);
1238
1239 TEST_CASE("Validating PAIR_VERIFY()");
1240 PAIR_VERIFY(vp);
1241
1242 TEST_CASE("Copy content of 'test_octets' to attribute value using fr_pair_value_memdup()");
1243 TEST_CHECK(fr_pair_value_memdup(vp, test_octets, NUM_ELEMENTS(test_octets), false) == 0);
1244
1245 TEST_CASE("Check (vp->vp_octets == test_octets)");
1246 TEST_CHECK(vp && memcmp(vp->vp_octets, test_octets, NUM_ELEMENTS(test_octets)) == 0);
1247}
1248
1249static void test_fr_pair_value_memdup_buffer(void)
1250{
1251 fr_pair_t *vp;
1252 uint8_t *copy_test_octets;
1253
1254 TEST_CASE("Find 'Test-Octets'");
1255 TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_octets)) != NULL);
1256
1257 TEST_CASE("Validating PAIR_VERIFY()");
1258 PAIR_VERIFY(vp);
1259
1260 copy_test_octets = talloc_memdup(vp, test_octets, NUM_ELEMENTS(test_octets));
1261 talloc_set_type(copy_test_octets, uint8_t);
1262
1263 TEST_CASE("Copy content of 'test_octets' to attribute value using fr_pair_value_memdup_buffer()");
1264 TEST_CHECK(fr_pair_value_memdup_buffer(vp, copy_test_octets, true) == 0);
1265
1266 TEST_CASE("Check (vp->vp_octets == test_octets)");
1267 TEST_CHECK(vp && memcmp(vp->vp_octets, test_octets, NUM_ELEMENTS(test_octets)) == 0);
1268
1269 talloc_free(copy_test_octets);
1270}
1271
1272static void test_fr_pair_value_memdup_shallow(void)
1273{
1274 fr_pair_t *vp;
1275 uint8_t *copy_test_octets;
1276
1277 TEST_CASE("Find 'Test-Octets'");
1278 TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_octets)) != NULL);
1279
1280 TEST_CASE("Validating PAIR_VERIFY()");
1281 PAIR_VERIFY(vp);
1282
1283 copy_test_octets = talloc_memdup(vp, test_octets, NUM_ELEMENTS(test_octets));
1284 talloc_set_type(copy_test_octets, uint8_t);
1285
1286 TEST_CASE("Copy content of 'test_octets' to attribute value using fr_pair_value_memdup_shallow()");
1287 TEST_CHECK(fr_pair_value_memdup_shallow(vp, copy_test_octets, NUM_ELEMENTS(test_octets), true) == 0);
1288
1289 TEST_CASE("Check (vp->vp_octets == test_octets)");
1290 TEST_CHECK(vp && memcmp(vp->vp_octets, test_octets, NUM_ELEMENTS(test_octets)) == 0);
1291
1292 talloc_free(copy_test_octets);
1293}
1294
1295static void test_fr_pair_value_memdup_buffer_shallow(void)
1296{
1297 fr_pair_t *vp;
1298 uint8_t *copy_test_octets;
1299
1300 TEST_CASE("Find 'Test-Octets'");
1301 TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_octets)) != NULL);
1302
1303 TEST_CASE("Validating PAIR_VERIFY()");
1304 PAIR_VERIFY(vp);
1305
1306 copy_test_octets = talloc_memdup(vp, test_octets, NUM_ELEMENTS(test_octets));
1307 talloc_set_type(copy_test_octets, uint8_t);
1308
1309 TEST_CASE("Copy content of 'test_octets' to attribute value using fr_pair_value_memdup_buffer_shallow()");
1310 TEST_CHECK(fr_pair_value_memdup_buffer_shallow(vp, copy_test_octets, true) == 0);
1311
1312 TEST_CASE("Check (vp->vp_octets == copy_test_octets)");
1313 TEST_CHECK(vp && memcmp(vp->vp_octets, test_octets, NUM_ELEMENTS(test_octets)) == 0);
1314
1315 talloc_free(copy_test_octets);
1316}
1317
1318static void test_fr_pair_value_mem_append(void)
1319{
1320 fr_pair_t *vp;
1321
1322 TEST_CASE("Find 'Test-Octets'");
1323 TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_octets)) != NULL);
1324
1325 TEST_CASE("Validating PAIR_VERIFY()");
1326 PAIR_VERIFY(vp);
1327
1328 TEST_CASE("Copy content of 'test_octets' to attribute value using fr_pair_value_memdup()");
1329 TEST_CHECK(fr_pair_value_memdup(vp, test_octets, NUM_ELEMENTS(test_octets), false) == 0);
1330
1331 TEST_CASE("Append the 'test_octets' value using fr_pair_value_mem_append()");
1332 TEST_CHECK(fr_pair_value_mem_append(vp, test_octets, NUM_ELEMENTS(test_octets), true) == 0);
1333
1334 // awful hack, just verify the first part of buffer and then the second part. yep, just appended twice.
1335 TEST_CASE("Check 1. part (vp->vp_octets == test_octets)");
1336 TEST_CHECK(vp && memcmp(vp->vp_octets, test_octets, NUM_ELEMENTS(test_octets)) == 0);
1337
1338 TEST_CASE("Check 2. part ((vp->vp_string+NUM_ELEMENTS(test_octets)) == test_octets)");
1339 TEST_CHECK(vp && memcmp(vp->vp_octets+NUM_ELEMENTS(test_octets), test_octets, NUM_ELEMENTS(test_octets)) == 0);
1340}
1341
1342static void test_fr_pair_value_mem_append_buffer(void)
1343{
1344 fr_pair_t *vp;
1345 uint8_t *copy_test_octets;
1346
1347 TEST_CASE("Find 'Test-Octets'");
1348 TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_octets)) != NULL);
1349
1350 TEST_CASE("Validating PAIR_VERIFY()");
1351 PAIR_VERIFY(vp);
1352
1353 copy_test_octets = talloc_memdup(vp, test_octets, NUM_ELEMENTS(test_octets));
1354 talloc_set_type(copy_test_octets, uint8_t);
1355
1356 TEST_CASE("Copy content of 'copy_test_octets' to attribute value using fr_pair_value_memdup()");
1357 TEST_CHECK(fr_pair_value_memdup(vp, copy_test_octets, NUM_ELEMENTS(test_octets), false) == 0);
1358
1359 TEST_CASE("Append the 'copy_test_octets' value using fr_pair_value_mem_append_buffer()");
1360 TEST_CHECK(fr_pair_value_mem_append_buffer(vp, copy_test_octets, true) == 0);
1361
1362 // awful hack, just verify the first part of buffer and then the second part. yep, just appended twice.
1363 TEST_CASE("Check 1. part (vp->vp_octets == test_octets)");
1364 TEST_CHECK(vp && memcmp(vp->vp_octets, test_octets, NUM_ELEMENTS(test_octets)) == 0);
1365
1366 TEST_CASE("Check 2. part ((vp->vp_string+NUM_ELEMENTS(test_octets)) == test_octets)");
1367 TEST_CHECK(vp && memcmp(vp->vp_octets+NUM_ELEMENTS(test_octets), test_octets, NUM_ELEMENTS(test_octets)) == 0);
1368
1369 talloc_free(copy_test_octets);
1370}
1371
1372static void test_fr_pair_value_enum(void)
1373{
1374 fr_pair_t *vp;
1375 char const *var;
1376 char buf[20];
1377
1378 TEST_CASE("Find 'Test-Values'");
1379 TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_enum)) != NULL);
1380
1381 TEST_CASE("Validating PAIR_VERIFY()");
1382 PAIR_VERIFY(vp);
1383
1384 vp->vp_uint32 = 123;
1385
1386 TEST_CASE("Lookup enum value attribute using fr_pair_value_enum()");
1387
1388 TEST_CHECK((var = fr_pair_value_enum(vp, buf)) != NULL);
1389 TEST_MSG("Checking fr_pair_value_enum()");
1390
1391 TEST_CHECK(var && strcmp(var, "test123") == 0);
1392 TEST_MSG("Expected var == 'test123'");
1393}
1394
1395static void test_fr_pair_value_enum_box(void)
1396{
1397 fr_pair_t *vp;
1398 fr_value_box_t const *vb;
1399
1400 TEST_CASE("Find 'Test-Values'");
1401 TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, NULL, fr_dict_attr_test_enum)) != NULL);
1402
1403 TEST_CASE("Validating PAIR_VERIFY()");
1404 PAIR_VERIFY(vp);
1405
1406 vp->vp_uint32 = 123;
1407
1408 TEST_CASE("Lookup enum value attribute using fr_pair_value_enum_box()");
1409
1410 TEST_CHECK(fr_pair_value_enum_box(&vb, vp) >= 0);
1411 TEST_MSG("Checking fr_pair_value_enum()");
1412
1413 TEST_CHECK(vb->vb_uint32 == 123);
1414 TEST_MSG("Expected vb->vb_uint32 == 123");
1415}
1416
1417TEST_LIST = {
1418 /*
1419 * Allocation and management
1420 */
1421 { "fr_pair_afrom_da", test_fr_pair_afrom_da },
1422 { "fr_pair_afrom_child_num", test_fr_pair_afrom_child_num },
1423 { "fr_pair_afrom_da_nested", test_fr_pair_afrom_da_nested },
1424 { "fr_pair_copy", test_fr_pair_copy },
1425 { "fr_pair_steal", test_fr_pair_steal },
1426
1427 /* Searching and list modification */
1428 { "fr_dcursor_iter_by_da_init", test_fr_pair_dcursor_by_da_init },
1429 { "fr_pair_dcursor_by_ancestor_init", test_fr_pair_dcursor_by_ancestor_init },
1430 { "fr_pair_dcursor_value_init", test_fr_pair_dcursor_value_init },
1431 { "fr_pair_raw_afrom_pair", test_fr_pair_raw_afrom_pair },
1432 { "fr_pair_find_by_da_idx", test_fr_pair_find_by_da_idx },
1433 { "fr_pair_find_by_child_num_idx", test_fr_pair_find_by_child_num_idx },
1434 { "fr_pair_find_by_da_nested", test_fr_pair_find_by_da_nested },
1435 { "fr_pair_append", test_fr_pair_append },
1436 { "fr_pair_prepend_by_da", test_fr_pair_prepend_by_da },
1437 { "fr_pair_append_by_da_parent", test_fr_pair_append_by_da_parent },
1438 { "fr_pair_delete_by_child_num", test_fr_pair_delete_by_child_num },
1439 { "fr_pair_update_by_da_parent", test_fr_pair_update_by_da_parent },
1440 { "fr_pair_delete", test_fr_pair_delete },
1441 { "fr_pair_delete_by_da", test_fr_pair_delete_by_da },
1442 { "fr_pair_delete_by_da_nested", test_fr_pair_delete_by_da_nested },
1443
1444 /* Compare */
1445 { "fr_pair_cmp", test_fr_pair_cmp },
1446 { "fr_pair_list_cmp", test_fr_pair_list_cmp },
1447
1448 /* Lists */
1449 { "fr_pair_list_copy", test_fr_pair_list_copy },
1450 { "fr_pair_list_copy_by_da", test_fr_pair_list_copy_by_da },
1451 { "fr_pair_list_copy_by_ancestor", test_fr_pair_list_copy_by_ancestor },
1452 { "fr_pair_list_sort", test_fr_pair_list_sort },
1453
1454 /* Copy */
1455 { "fr_pair_value_copy", test_fr_pair_value_copy },
1456
1457
1458 /* parenting */
1459 { "test_fr_pair_nested_verify", test_fr_pair_nested_verify },
1460
1461 /* Strings */
1462 { "fr_pair_value_from_str", test_fr_pair_value_from_str },
1463 { "fr_pair_value_strdup", test_fr_pair_value_strdup },
1464 { "fr_pair_value_strdup_shallow", test_fr_pair_value_strdup_shallow },
1465 { "fr_pair_value_strtrim", test_fr_pair_value_strtrim },
1466 { "fr_pair_value_aprintf", test_fr_pair_value_aprintf },
1467
1468 /* Assign and manipulate binary-safe strings */
1469 { "fr_pair_value_bstr_alloc", test_fr_pair_value_bstr_alloc },
1470 { "fr_pair_value_bstr_realloc", test_fr_pair_value_bstr_realloc },
1471 { "fr_pair_value_bstrndup", test_fr_pair_value_bstrndup },
1472 { "fr_pair_value_bstrdup_buffer", test_fr_pair_value_bstrdup_buffer },
1473 { "fr_pair_value_bstrndup_shallow", test_fr_pair_value_bstrndup_shallow },
1474 { "fr_pair_value_bstrdup_buffer_shallow", test_fr_pair_value_bstrdup_buffer_shallow },
1475 { "fr_pair_value_bstrn_append", test_fr_pair_value_bstrn_append },
1476 { "fr_pair_value_bstr_append_buffer", test_fr_pair_value_bstr_append_buffer },
1477
1478 /* Assign and manipulate octets strings */
1479 { "fr_pair_value_mem_alloc", test_fr_pair_value_mem_alloc },
1480 { "fr_pair_value_mem_realloc", test_fr_pair_value_mem_realloc },
1481 { "fr_pair_value_memdup", test_fr_pair_value_memdup },
1482 { "fr_pair_value_memdup_buffer", test_fr_pair_value_memdup_buffer },
1483 { "fr_pair_value_memdup_shallow", test_fr_pair_value_memdup_shallow },
1484 { "fr_pair_value_memdup_buffer_shallow", test_fr_pair_value_memdup_buffer_shallow },
1485 { "fr_pair_value_mem_append", test_fr_pair_value_mem_append },
1486 { "fr_pair_value_mem_append_buffer", test_fr_pair_value_mem_append_buffer },
1487
1488 /* Enum functions */
1489 { "fr_pair_value_enum", test_fr_pair_value_enum },
1490 { "fr_pair_value_enum_box", test_fr_pair_value_enum_box },
1491
1492 { NULL }
1493};
TEST_CHECK
#define TEST_CHECK(cond)
Definition acutest.h:85
TEST_CASE
#define TEST_CASE(name)
Definition acutest.h:184
TEST_ASSERT
#define TEST_ASSERT(cond)
Definition acutest.h:108
TEST_MSG
#define TEST_MSG(...)
Definition acutest.h:215
__attribute__
Definition bfd.h:63
NUM_ELEMENTS
#define NUM_ELEMENTS(_t)
Definition build.h:337
fr_dcursor_next
static void * fr_dcursor_next(fr_dcursor_t *cursor)
Advanced the cursor to the next item.
Definition dcursor.h:288
fr_dcursor_s
Definition dcursor.h:93
MEM
#define MEM(x)
Definition debug.h:36
fr_exit_now
#define fr_exit_now(_x)
Exit without calling atexit() handlers, producing a log message in debug builds.
Definition debug.h:234
fr_dict_attr_can_contain
bool fr_dict_attr_can_contain(fr_dict_attr_t const *parent, fr_dict_attr_t const *child)
See if a structural da is allowed to contain another da.
Definition dict_util.c:4875
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:2400
fr_dict_attr_test_tlv_string
fr_dict_attr_t const * fr_dict_attr_test_tlv_string
Definition dict_test.c:65
fr_dict_attr_test_nested_leaf_string
fr_dict_attr_t const * fr_dict_attr_test_nested_leaf_string
Definition dict_test.c:78
fr_dict_attr_test_enum
fr_dict_attr_t const * fr_dict_attr_test_enum
Definition dict_test.c:81
fr_dict_attr_test_date
fr_dict_attr_t const * fr_dict_attr_test_date
Definition dict_test.c:58
fr_dict_attr_test_tlv
fr_dict_attr_t const * fr_dict_attr_test_tlv
Definition dict_test.c:64
fr_dict_attr_test_nested_top_tlv
fr_dict_attr_t const * fr_dict_attr_test_nested_top_tlv
Definition dict_test.c:76
fr_dict_attr_test_uint32
fr_dict_attr_t const * fr_dict_attr_test_uint32
Definition dict_test.c:47
fr_dict_attr_test_octets
fr_dict_attr_t const * fr_dict_attr_test_octets
Definition dict_test.c:31
fr_dict_attr_test_string
fr_dict_attr_t const * fr_dict_attr_test_string
Definition dict_test.c:30
fr_dict_attr_test_ipv4_addr
fr_dict_attr_t const * fr_dict_attr_test_ipv4_addr
Definition dict_test.c:33
fr_dict_attr_test_nested_child_tlv
fr_dict_attr_t const * fr_dict_attr_test_nested_child_tlv
Definition dict_test.c:77
fr_dict_test_init
int fr_dict_test_init(TALLOC_CTX *ctx, fr_dict_t **dict_p, fr_dict_test_attr_t const *test_defs)
Initialise a test dictionary and add our test_defs to it.
Definition dict_test.c:248
fr_dict_attr_test_uint8
fr_dict_attr_t const * fr_dict_attr_test_uint8
Definition dict_test.c:45
fr_dict_attr_test_group
fr_dict_attr_t const * fr_dict_attr_test_group
Definition dict_test.c:74
fr_dict_attr_test_nested_leaf_int32
fr_dict_attr_t const * fr_dict_attr_test_nested_leaf_int32
Definition dict_test.c:79
fr_dict_attr_test_vsa
fr_dict_attr_t const * fr_dict_attr_test_vsa
Definition dict_test.c:70
FR_TEST_ATTR_STRING
@ FR_TEST_ATTR_STRING
Definition dict_test.h:37
value
Test enumeration values.
Definition dict_test.h:92
talloc_free
talloc_free(reap)
FR_TYPE_STRING
@ FR_TYPE_STRING
String of printable characters.
Definition merged_model.c:83
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
uint8_t
unsigned char uint8_t
Definition merged_model.c:30
fr_dict_t
Definition merged_model.c:198
fr_value_box_t
Definition merged_model.c:136
fr_pair_list_copy_by_da
int fr_pair_list_copy_by_da(TALLOC_CTX *ctx, fr_pair_list_t *to, fr_pair_list_t const *from, fr_dict_attr_t const *da, unsigned int count)
Duplicate pairs in a list matching the specified da.
Definition pair.c:2406
fr_pair_value_bstrn_append
int fr_pair_value_bstrn_append(fr_pair_t *vp, char const *src, size_t len, bool tainted)
Append bytes from a buffer to an existing "string" type value pair.
Definition pair.c:2880
fr_pair_list_cmp
int fr_pair_list_cmp(fr_pair_list_t const *a, fr_pair_list_t const *b)
Determine equality of two lists.
Definition pair.c:2047
fr_pair_value_memdup_buffer
int fr_pair_value_memdup_buffer(fr_pair_t *vp, uint8_t const *src, bool tainted)
Copy data from a talloced buffer into an "octets" data type.
Definition pair.c:3011
fr_pair_value_enum_box
int fr_pair_value_enum_box(fr_value_box_t const **out, fr_pair_t *vp)
Get value box of a VP, optionally prefer enum value.
Definition pair.c:3158
fr_pair_value_aprintf
int fr_pair_value_aprintf(fr_pair_t *vp, char const *fmt,...)
Print data into an "string" data type.
Definition pair.c:2698
fr_pair_delete_by_da_nested
int fr_pair_delete_by_da_nested(fr_pair_list_t *list, fr_dict_attr_t const *da)
Delete matching pairs from the specified list, and prune any empty branches.
Definition pair.c:1713
fr_pair_value_mem_append
int fr_pair_value_mem_append(fr_pair_t *vp, uint8_t *src, size_t len, bool tainted)
Append bytes from a buffer to an existing "octets" type value pair.
Definition pair.c:3078
fr_pair_list_copy
int fr_pair_list_copy(TALLOC_CTX *ctx, fr_pair_list_t *to, fr_pair_list_t const *from)
Duplicate a list of pairs.
Definition pair.c:2319
fr_pair_value_mem_append_buffer
int fr_pair_value_mem_append_buffer(fr_pair_t *vp, uint8_t *src, bool tainted)
Append a talloced buffer to an existing "octets" type value pair.
Definition pair.c:3101
fr_pair_value_memdup
int fr_pair_value_memdup(fr_pair_t *vp, uint8_t const *src, size_t len, bool tainted)
Copy data into an "octets" data type.
Definition pair.c:2981
fr_pair_find_by_da_nested
fr_pair_t * fr_pair_find_by_da_nested(fr_pair_list_t const *list, fr_pair_t const *prev, fr_dict_attr_t const *da)
Find a pair with a matching fr_dict_attr_t, by walking the nested fr_dict_attr_t tree.
Definition pair.c:770
fr_pair_value_strdup
int fr_pair_value_strdup(fr_pair_t *vp, char const *src, bool tainted)
Copy data into an "string" data type.
Definition pair.c:2634
fr_pair_value_bstrdup_buffer_shallow
int fr_pair_value_bstrdup_buffer_shallow(fr_pair_t *vp, char const *src, bool tainted)
Assign a string to a "string" type value pair.
Definition pair.c:2855
fr_pair_find_by_da
fr_pair_t * fr_pair_find_by_da(fr_pair_list_t const *list, fr_pair_t const *prev, fr_dict_attr_t const *da)
Find the first pair with a matching da.
Definition pair.c:693
fr_pair_find_by_child_num_idx
fr_pair_t * fr_pair_find_by_child_num_idx(fr_pair_list_t const *list, fr_dict_attr_t const *parent, unsigned int attr, unsigned int idx)
Find the pair with the matching child attribute at a given index.
Definition pair.c:893
fr_pair_cmp
int fr_pair_cmp(fr_pair_t const *a, fr_pair_t const *b)
Compare two pairs, using the operator from "a".
Definition pair.c:1969
fr_pair_value_bstrndup_shallow
int fr_pair_value_bstrndup_shallow(fr_pair_t *vp, char const *src, size_t len, bool tainted)
Assign a string to a "string" type value pair.
Definition pair.c:2835
fr_pair_append
int fr_pair_append(fr_pair_list_t *list, fr_pair_t *to_add)
Add a VP to the end of the list.
Definition pair.c:1345
fr_pair_delete_by_da
int fr_pair_delete_by_da(fr_pair_list_t *list, fr_dict_attr_t const *da)
Delete matching pairs from the specified list.
Definition pair.c:1689
fr_pair_find_by_da_idx
fr_pair_t * fr_pair_find_by_da_idx(fr_pair_list_t const *list, fr_dict_attr_t const *da, unsigned int idx)
Find a pair with a matching da at a given index.
Definition pair.c:741
fr_pair_afrom_da
fr_pair_t * fr_pair_afrom_da(TALLOC_CTX *ctx, fr_dict_attr_t const *da)
Dynamically allocate a new attribute and assign a fr_dict_attr_t.
Definition pair.c:283
fr_pair_update_by_da_parent
int fr_pair_update_by_da_parent(fr_pair_t *parent, fr_pair_t **out, fr_dict_attr_t const *da)
Return the first fr_pair_t matching the fr_dict_attr_t or alloc a new fr_pair_t and its subtree (and ...
Definition pair.c:1596
fr_pair_list_copy_by_ancestor
int fr_pair_list_copy_by_ancestor(TALLOC_CTX *ctx, fr_pair_list_t *to, fr_pair_list_t const *from, fr_dict_attr_t const *parent_da)
Duplicate pairs in a list where the da is a descendant of parent_da.
Definition pair.c:2455
fr_pair_list_init
void fr_pair_list_init(fr_pair_list_t *list)
Initialise a pair list header.
Definition pair.c:46
fr_pair_value_mem_realloc
int fr_pair_value_mem_realloc(fr_pair_t *vp, uint8_t **out, size_t size)
Change the length of a buffer for a "octets" type value pair.
Definition pair.c:2955
fr_pair_value_enum
char const * fr_pair_value_enum(fr_pair_t const *vp, char buff[20])
Return a const buffer for an enum type attribute.
Definition pair.c:3125
fr_pair_value_bstrndup
int fr_pair_value_bstrndup(fr_pair_t *vp, char const *src, size_t len, bool tainted)
Copy data into a "string" type value pair.
Definition pair.c:2784
fr_pair_value_bstr_alloc
int fr_pair_value_bstr_alloc(fr_pair_t *vp, char **out, size_t size, bool tainted)
Pre-allocate a memory buffer for a "string" type value pair.
Definition pair.c:2730
fr_pair_value_bstr_append_buffer
int fr_pair_value_bstr_append_buffer(fr_pair_t *vp, char const *src, bool tainted)
Append a talloced buffer to an existing "string" type value pair.
Definition pair.c:2903
fr_pair_value_bstr_realloc
int fr_pair_value_bstr_realloc(fr_pair_t *vp, char **out, size_t size)
Change the length of a buffer for a "string" type value pair.
Definition pair.c:2755
fr_pair_delete
int fr_pair_delete(fr_pair_list_t *list, fr_pair_t *vp)
Remove fr_pair_t from a list and free.
Definition pair.c:1826
fr_pair_append_by_da_parent
int fr_pair_append_by_da_parent(TALLOC_CTX *ctx, fr_pair_t **out, fr_pair_list_t *list, fr_dict_attr_t const *da)
Alloc a new fr_pair_t, adding the parent attributes if required.
Definition pair.c:1523
fr_pair_delete_by_child_num
int fr_pair_delete_by_child_num(fr_pair_list_t *list, fr_dict_attr_t const *parent, unsigned int attr)
Delete matching pairs from the specified list.
Definition pair.c:1808
fr_pair_value_copy
int fr_pair_value_copy(fr_pair_t *dst, fr_pair_t *src)
Copy the value from one pair to another.
Definition pair.c:2563
fr_pair_steal
int fr_pair_steal(TALLOC_CTX *ctx, fr_pair_t *vp)
Steal one VP.
Definition pair.c:521
fr_pair_value_memdup_shallow
int fr_pair_value_memdup_shallow(fr_pair_t *vp, uint8_t const *src, size_t len, bool tainted)
Assign a buffer to a "octets" type value pair.
Definition pair.c:3036
fr_pair_copy
fr_pair_t * fr_pair_copy(TALLOC_CTX *ctx, fr_pair_t const *vp)
Copy a single valuepair.
Definition pair.c:489
fr_pair_value_mem_alloc
int fr_pair_value_mem_alloc(fr_pair_t *vp, uint8_t **out, size_t size, bool tainted)
Pre-allocate a memory buffer for a "octets" type value pair.
Definition pair.c:2930
fr_pair_value_strtrim
int fr_pair_value_strtrim(fr_pair_t *vp)
Trim the length of the string buffer to match the length of the C string.
Definition pair.c:2677
fr_pair_afrom_da_nested
fr_pair_t * fr_pair_afrom_da_nested(TALLOC_CTX *ctx, fr_pair_list_t *list, fr_dict_attr_t const *da)
Create a pair (and all intermediate parents), and append it to the list.
Definition pair.c:467
fr_pair_value_from_str
int fr_pair_value_from_str(fr_pair_t *vp, char const *value, size_t inlen, fr_sbuff_unescape_rules_t const *uerules, bool tainted)
Convert string value to native attribute value.
Definition pair.c:2589
fr_pair_prepend
int fr_pair_prepend(fr_pair_list_t *list, fr_pair_t *to_add)
Add a VP to the start of the list.
Definition pair.c:1314
fr_pair_dcursor_value_init
fr_value_box_t * fr_pair_dcursor_value_init(fr_dcursor_t *cursor)
Initialises a special dcursor over a fr_pair_list_t, but which returns fr_value_box_t.
Definition pair.c:1248
fr_pair_raw_afrom_pair
int fr_pair_raw_afrom_pair(fr_pair_t *vp, uint8_t const *data, size_t data_len)
Mark malformed attribute as raw.
Definition pair.c:593
fr_pair_cmp_by_da
int8_t fr_pair_cmp_by_da(void const *a, void const *b)
Order attributes by their da, and tag.
Definition pair.c:1844
fr_pair_value_memdup_buffer_shallow
int fr_pair_value_memdup_buffer_shallow(fr_pair_t *vp, uint8_t const *src, bool tainted)
Assign a talloced buffer to a "octets" type value pair.
Definition pair.c:3056
fr_pair_value_strdup_shallow
int fr_pair_value_strdup_shallow(fr_pair_t *vp, char const *src, bool tainted)
Assign a buffer containing a nul terminated string to a vp, but don't copy it.
Definition pair.c:2658
fr_pair_prepend_by_da
int fr_pair_prepend_by_da(TALLOC_CTX *ctx, fr_pair_t **out, fr_pair_list_t *list, fr_dict_attr_t const *da)
Alloc a new fr_pair_t (and prepend)
Definition pair.c:1493
fr_pair_afrom_child_num
fr_pair_t * fr_pair_afrom_child_num(TALLOC_CTX *ctx, fr_dict_attr_t const *parent, unsigned int attr)
Create a new valuepair.
Definition pair.c:371
test_pairs
static fr_pair_list_t test_pairs
Definition pair_server_tests.c:45
test_dict
static fr_dict_t * test_dict
Definition pair_server_tests.c:46
fr_pair_test_list_alloc_nested
static int fr_pair_test_list_alloc_nested(TALLOC_CTX *ctx, fr_pair_list_t *out, fr_dict_test_attr_t const *test_defs)
Definition pair_test_helpers.h:61
test_octets
static uint8_t test_octets[]
Definition pair_test_helpers.h:36
fr_pair_test_list_alloc
static int fr_pair_test_list_alloc(TALLOC_CTX *ctx, fr_pair_list_t *out, fr_dict_test_attr_t const *test_defs)
Definition pair_test_helpers.h:43
test_string_len
static size_t test_string_len
Definition pair_test_helpers.h:35
test_string
static char const * test_string
Definition pair_test_helpers.h:34
test_fr_pair_value_memdup_shallow
static void test_fr_pair_value_memdup_shallow(void)
Definition pair_tests.c:1272
TEST_LIST
TEST_LIST
Definition pair_tests.c:1417
test_fr_pair_value_mem_append_buffer
static void test_fr_pair_value_mem_append_buffer(void)
Definition pair_tests.c:1342
test_fr_pair_list_copy_by_ancestor
static void test_fr_pair_list_copy_by_ancestor(void)
Definition pair_tests.c:734
test_fr_pair_afrom_child_num
static void test_fr_pair_afrom_child_num(void)
Definition pair_tests.c:113
test_fr_pair_value_aprintf
static void test_fr_pair_value_aprintf(void)
Definition pair_tests.c:940
test_fr_pair_value_mem_realloc
static void test_fr_pair_value_mem_realloc(void)
Definition pair_tests.c:1194
test_fr_pair_value_memdup_buffer
static void test_fr_pair_value_memdup_buffer(void)
Definition pair_tests.c:1249
test_fr_pair_value_enum_box
static void test_fr_pair_value_enum_box(void)
Definition pair_tests.c:1395
test_fr_pair_value_bstrdup_buffer
static void test_fr_pair_value_bstrdup_buffer(void)
Definition pair_tests.c:1038
test_fr_pair_value_copy
static void test_fr_pair_value_copy(void)
Definition pair_tests.c:822
test_fr_pair_delete
static void test_fr_pair_delete(void)
Definition pair_tests.c:633
test_fr_pair_list_cmp
static void test_fr_pair_list_cmp(void)
Definition pair_tests.c:674
test_fr_pair_value_bstrn_append
static void test_fr_pair_value_bstrn_append(void)
Definition pair_tests.c:1107
test_fr_pair_copy
static void test_fr_pair_copy(void)
Definition pair_tests.c:193
test_fr_pair_afrom_da
static void test_fr_pair_afrom_da(void)
Definition pair_tests.c:92
test_fr_pair_value_mem_alloc
static void test_fr_pair_value_mem_alloc(void)
Definition pair_tests.c:1170
test_fr_pair_value_bstrndup
static void test_fr_pair_value_bstrndup(void)
Definition pair_tests.c:1021
test_fr_pair_find_by_child_num_idx
static void test_fr_pair_find_by_child_num_idx(void)
Definition pair_tests.c:374
test_fr_pair_value_bstrndup_shallow
static void test_fr_pair_value_bstrndup_shallow(void)
Definition pair_tests.c:1061
test_fr_pair_value_bstrdup_buffer_shallow
static void test_fr_pair_value_bstrdup_buffer_shallow(void)
Definition pair_tests.c:1084
test_fr_pair_list_copy
static void test_fr_pair_list_copy(void)
Definition pair_tests.c:694
test_fr_pair_value_memdup_buffer_shallow
static void test_fr_pair_value_memdup_buffer_shallow(void)
Definition pair_tests.c:1295
test_fr_pair_value_bstr_realloc
static void test_fr_pair_value_bstr_realloc(void)
Definition pair_tests.c:991
test_fr_pair_dcursor_by_da_init
static void test_fr_pair_dcursor_by_da_init(void)
Definition pair_tests.c:253
test_fr_pair_delete_by_da
static void test_fr_pair_delete_by_da(void)
Definition pair_tests.c:621
test_fr_pair_append
static void test_fr_pair_append(void)
Definition pair_tests.c:483
test_fr_pair_value_strdup_shallow
static void test_fr_pair_value_strdup_shallow(void)
Definition pair_tests.c:889
test_fr_pair_find_by_da_idx
static void test_fr_pair_find_by_da_idx(void)
Definition pair_tests.c:360
test_fr_pair_nested_verify
static void test_fr_pair_nested_verify(void)
Definition pair_tests.c:186
test_fr_pair_value_strtrim
static void test_fr_pair_value_strtrim(void)
Definition pair_tests.c:917
test_fr_pair_value_enum
static void test_fr_pair_value_enum(void)
Definition pair_tests.c:1372
test_fr_pair_value_bstr_alloc
static void test_fr_pair_value_bstr_alloc(void)
Definition pair_tests.c:964
test_fr_pair_list_sort
static void test_fr_pair_list_sort(void)
Definition pair_tests.c:771
test_fr_pair_value_strdup
static void test_fr_pair_value_strdup(void)
Definition pair_tests.c:869
test_fr_pair_cmp
static void test_fr_pair_cmp(void)
Definition pair_tests.c:648
test_fr_pair_prepend_by_da
static void test_fr_pair_prepend_by_da(void)
Definition pair_tests.c:575
test_fr_pair_afrom_da_nested
static void test_fr_pair_afrom_da_nested(void)
Definition pair_tests.c:130
test_fr_pair_list_copy_by_da
static void test_fr_pair_list_copy_by_da(void)
Definition pair_tests.c:709
test_fr_pair_value_from_str
static void test_fr_pair_value_from_str(void)
Definition pair_tests.c:849
test_fr_pair_value_mem_append
static void test_fr_pair_value_mem_append(void)
Definition pair_tests.c:1318
test_fr_pair_append_by_da_parent
static void test_fr_pair_append_by_da_parent(void)
Definition pair_tests.c:512
test_fr_pair_steal
static void test_fr_pair_steal(void)
Definition pair_tests.c:217
test_fr_pair_delete_by_child_num
static void test_fr_pair_delete_by_child_num(void)
Definition pair_tests.c:563
test_fr_pair_dcursor_by_ancestor_init
static void test_fr_pair_dcursor_by_ancestor_init(void)
Definition pair_tests.c:279
test_fr_pair_delete_by_da_nested
static void test_fr_pair_delete_by_da_nested(void)
Definition pair_tests.c:159
test_init
static void test_init(void)
Global initialisation.
Definition pair_tests.c:36
test_fr_pair_raw_afrom_pair
static void test_fr_pair_raw_afrom_pair(void)
Definition pair_tests.c:235
test_fr_pair_update_by_da_parent
static void test_fr_pair_update_by_da_parent(void)
Definition pair_tests.c:598
test_fr_pair_find_by_da_nested
static void test_fr_pair_find_by_da_nested(void)
Definition pair_tests.c:388
test_fr_pair_value_bstr_append_buffer
static void test_fr_pair_value_bstr_append_buffer(void)
Definition pair_tests.c:1137
test_fr_pair_dcursor_value_init
static void test_fr_pair_dcursor_value_init(void)
Definition pair_tests.c:305
test_fr_pair_value_memdup
static void test_fr_pair_value_memdup(void)
Definition pair_tests.c:1232
autofree
static TALLOC_CTX * autofree
Definition radclient-ng.c:107
local_pairs
#define local_pairs
Convenience macro for accessing the state list.
Definition request.h:134
snprintf
PUBLIC int snprintf(char *string, size_t length, char *format, va_alist)
Definition snprintf.c:689
count
return count
Definition module.c:163
fr_pair_value_bstrdup_buffer
fr_pair_value_bstrdup_buffer(vp, eap_session->identity, true)
vp
fr_pair_t * vp
Definition state_machine.c:2262
fr_time
#define fr_time()
Allow us to arbitrarily manipulate time.
Definition state_test.c:8
strlcpy
size_t strlcpy(char *dst, char const *src, size_t siz)
Definition strlcpy.c:34
pair_list_s
Definition pair.h:52
value_pair_s
Stores an attribute, a value and various bits of other data.
Definition pair.h:68
value_pair_s::da
fr_dict_attr_t const *_CONST da
Dictionary attribute defines the attribute number, vendor and type of the pair.
Definition pair.h:69
talloc_null_ctx
void * talloc_null_ctx(void)
Retrieve the current talloc NULL ctx.
Definition talloc.c:53
talloc_autofree_context
#define talloc_autofree_context
The original function is deprecated, so replace it with our version.
Definition talloc.h:51
fr_time_unwrap
static int64_t fr_time_unwrap(fr_time_t time)
Definition time.h:146
fr_time_s
"server local" time.
Definition time.h:69
T_OP_EQ
@ T_OP_EQ
Definition token.h:83
T_OP_CMP_EQ
@ T_OP_CMP_EQ
Definition token.h:106
fr_pair_dcursor_by_da_init
#define fr_pair_dcursor_by_da_init(_cursor, _list, _da)
Initialise a cursor that will return only attributes matching the specified fr_dict_attr_t.
Definition pair.h:628
PAIR_VERIFY
#define PAIR_VERIFY(_x)
Definition pair.h:191
fr_pair_list_sort
void fr_pair_list_sort(fr_pair_list_t *list, fr_cmp_t cmp)
Sort a doubly linked list of fr_pair_ts using merge sort.
Definition pair_inline.c:140
fr_pair_list_next
fr_pair_t * fr_pair_list_next(fr_pair_list_t const *list, fr_pair_t const *item))
Get the next item in a valuepair list after a specific entry.
Definition pair_inline.c:70
fr_pair_list_free
void fr_pair_list_free(fr_pair_list_t *list)
Free memory used by a valuepair list.
Definition pair_inline.c:113
fr_pair_dcursor_init
#define fr_pair_dcursor_init(_cursor, _list)
Initialises a special dcursor with callbacks that will maintain the attr sublists correctly.
Definition pair.h:591
fr_pair_list_head
fr_pair_t * fr_pair_list_head(fr_pair_list_t const *list)
Get the head of a valuepair list.
Definition pair_inline.c:43
fr_pair_dcursor_by_ancestor_init
#define fr_pair_dcursor_by_ancestor_init(_cursor, _list, _da)
Initialise a cursor that will return only attributes descended from the specified fr_dict_attr_t.
Definition pair.h:646
fr_pair_list_num_elements
size_t fr_pair_list_num_elements(fr_pair_list_t const *list)
Get the length of a list of fr_pair_t.
Definition pair_inline.c:151
parent
static fr_slen_t parent
Definition pair.h:851
fr_perror
void fr_perror(char const *fmt,...)
Print the current error to stderr with a prefix.
Definition strerror.c:733
fr_check_lib_magic
int fr_check_lib_magic(uint64_t magic)
Check if the application linking to the library has the correct magic number.
Definition version.c:40
RADIUSD_MAGIC_NUMBER
#define RADIUSD_MAGIC_NUMBER
Definition version.h:81
fr_value_unescape_double
fr_sbuff_unescape_rules_t fr_value_unescape_double
Definition value.c:266
out
static size_t char ** out
Definition value.h:997
Generated by   doxygen 1.9.8