45RCSID(
"$Id: aef20f9768e87368d647c3e0ce7bbf5f07f71e76 $")
48#include <freeradius-devel/util/value.h>
51#include <freeradius-devel/util/atexit.h>
52#include <freeradius-devel/util/base16.h>
53#include <freeradius-devel/util/dcursor.h>
54#include <freeradius-devel/util/size.h>
55#include <freeradius-devel/util/time.h>
64 "in_addr.s_addr has unexpected length");
66 "in6_addr.s6_addr has unexpected length");
68 "vb_ifid has unexpected length");
70 "vb_ether has unexpected length");
73 "datum.boolean has unexpected length");
75 "vb_uint8 has unexpected length");
77 "vb_uint16 has unexpected length");
79 "vb_uint32 has unexpected length");
81 "vb_uint64 has unexpected length");
84 "vb_int16 has unexpected length");
86 "vb_int16 has unexpected length");
88 "vb_int32 has unexpected length");
90 "vb_int64 has unexpected length");
93 "vb_float32 has unexpected length");
95 "vb_float64 has unexpected length");
107#define network_min_size(_x) (fr_value_box_network_sizes[_x][0])
108#define network_max_size(_x) (fr_value_box_network_sizes[_x][1])
373#pragma clang diagnostic ignored "-Wgnu-designator"
456 .name =
"unprintables",
550 L(
""),
L(
"\n"),
L(
"\r"),
L(
"\""))
556 L(
""),
L(
"\n"),
L(
"\r"),
L(
"'"))
562 L(
""),
L(
"\n"),
L(
"\r"),
L(
"/"))
568 L(
""),
L(
"\n"),
L(
"\r"),
L(
"`"))
577 L(
""),
L(
"\n"),
L(
"\r"),
L(
"\"\"\""))
583 L(
""),
L(
"\n"),
L(
"\r"),
L(
"'''"))
589 L(
""),
L(
"\n"),
L(
"\r"),
L(
"///"))
595 L(
""),
L(
"\n"),
L(
"\r"),
L(
"```"))
642 dst->vb_length = src->vb_length;
651 fr_value_box_list_init(&dst->vb_group);
658 dst->enumv = src->enumv;
659 dst->type = src->type;
660 dst->tainted = src->tainted;
661 dst->safe_for = src->safe_for;
662 dst->secret = src->secret;
663 fr_value_box_list_entry_init(dst);
681 if (a->type != b->type) {
695 if (a->vb_length < b->vb_length) {
696 length = a->vb_length;
698 length = b->vb_length;
707 if (a->secret || b->secret) {
710 cmp = memcmp(a->datum.ptr, b->datum.ptr, length);
712 if (cmp != 0)
return CMP(cmp, 0);
721 return CMP(a->vb_length, b->vb_length);
727#define RETURN(_type) return CMP(a->datum._type, b->datum._type)
728#define COMPARE(_type) return CMP(memcmp(&a->datum._type, &b->datum._type, sizeof(a->datum._type)), 0)
817 if (a_net == b_net) {
820 compare = memcmp(a, b, bytes);
826 if ((compare == 0) &&
888 if (common == 0)
return true;
893 if (common < 8)
break;
895 if (a[i] != b[i])
return false;
903 mask <<= (8 - common);
907 if ((a[i] &
mask) == ((b[i] &
mask))) {
942 if (b->vb_ip.af != AF_INET)
goto fail_cmp_v4;
949 if (b->vb_ip.af != AF_INET)
goto fail_cmp_v4;
954 b->vb_ip.prefix, (
uint8_t const *) &b->vb_ip.addr.v4.s_addr);
966 if (b->vb_ip.af != AF_INET)
goto fail_cmp_v4;
971 (
uint8_t const *) &a->vb_ip.addr.v4.s_addr,
972 32, (
uint8_t const *) &b->vb_ip.addr.v4);
975 if (b->vb_ip.af != AF_INET)
goto fail_cmp_v4;
980 (
uint8_t const *) &a->vb_ip.addr.v4.s_addr,
981 b->vb_ip.prefix, (
uint8_t const *) &b->vb_ip.addr.v4.s_addr);
991 if (b->vb_ip.af != AF_INET6)
goto fail_cmp_v6;
998 if (b->vb_ip.af != AF_INET6)
goto fail_cmp_v6;
1003 b->vb_ip.prefix, (
uint8_t const *) &b->vb_ip.addr.v6);
1015 if (b->vb_ip.af != AF_INET6)
goto fail_cmp_v6;
1020 (
uint8_t const *) &a->vb_ip.addr.v6,
1021 128, (
uint8_t const *) &b->vb_ip.addr.v6);
1024 if (b->vb_ip.af != AF_INET6)
goto fail_cmp_v6;
1029 (
uint8_t const *) &a->vb_ip.addr.v6,
1030 b->vb_ip.prefix, (
uint8_t const *) &b->vb_ip.addr.v6);
1038 if (a->vb_ip.af != b->vb_ip.af)
goto fail_cmp_v4;
1043 if (a->vb_ip.af != b->vb_ip.af)
goto fail_cmp_v4;
1045 if (a->vb_ip.af == AF_INET)
goto cmp_prefix_v4;
1062 return (compare == 0);
1065 return (compare != 0);
1068 return (compare < 0);
1071 return (compare > 0);
1074 return (compare <= 0);
1077 return (compare >= 0);
1235 switch (src->type) {
1272 switch (src->type) {
1274 dst->vb_uint16 = htons(src->vb_uint16);
1278 dst->vb_uint32 = htonl(src->vb_uint32);
1282 dst->vb_uint64 = htonll(src->vb_uint64);
1286 dst->vb_int16 = htons(src->vb_int16);
1290 dst->vb_int32 = htonl(src->vb_int32);
1294 dst->vb_int64 = htonll(src->vb_int64);
1306 dst->vb_float32 = htonl((
uint32_t)src->vb_float32);
1310 dst->vb_float64 = htonll((uint64_t)src->vb_float64);
1327 switch (
value->type) {
1333 if (
value->enumv->flags.length) {
1334 return value->enumv->flags.length;
1342 if (
value->vb_length > 255)
return 255;
1345 if (
value->vb_length > 65535)
return 65535;
1349 return value->vb_length;
1356 if (
value->enumv)
return value->enumv->flags.length;
1423 switch (
value->type) {
1426 max =
value->vb_length;
1433 if (
value->enumv->flags.length) {
1437 if (max < value->enumv->flags.length) {
1442 }
else if (max >
value->enumv->flags.length) {
1446 max =
value->enumv->flags.length;
1454 if (max > 255) max = 255;
1458 if (max > 65536) max = 65535;
1492 switch (
value->type) {
1497 sizeof(
value->vb_ip.addr.v4.s_addr));
1507 sizeof(
value->vb_ip.addr.v4.s_addr));
1528 switch (
value->vb_ip.af) {
1543 switch (
value->vb_ip.af) {
1598 if (!
value->enumv) {
1601 res =
value->enumv->flags.flag_time_res;
1605 if (!
value->enumv) {
1608 }
else switch (
value->enumv->flags.length) {
1610 if (date > UINT16_MAX) date = UINT16_MAX;
1616 if (date > UINT32_MAX) date = UINT32_MAX;
1635 if (
value->enumv) res =
value->enumv->flags.flag_time_res;
1639 if (!
value->enumv) {
1642 }
else if (!
value->enumv->flags.is_unsigned) {
1643 switch (
value->enumv->flags.length) {
1645 if (date < INT16_MIN) {
1647 }
else if (date > INT16_MAX) {
1655 if (date < INT32_MIN) {
1657 }
else if (date > INT32_MAX) {
1671 switch (
value->enumv->flags.length) {
1675 }
else if (date > UINT16_MAX) {
1684 }
else if (date > UINT32_MAX) {
1767 "Expected length >= %zu bytes, got %zu bytes",
1777 if (enumv && !enumv->flags.array) {
1779 "Expected length <= %zu bytes, got %zu bytes",
1792 size_t newlen = len;
1799 if (enumv->flags.length) {
1800 newlen = enumv->flags.length;
1831 if (newlen > len)
return -(newlen + offset);
1889 dst->vb_ip.scope_id = scope_id;
1905 dst->vb_ip.scope_id = scope_id;
1933 dst->datum.boolean = (val != 0);
1996 length = enumv->flags.length;
2004 if (len > length)
return -(length);
2026 length = enumv->flags.length;
2034 if (len > length)
return -(length);
2038 if (!enumv || !enumv->flags.is_unsigned) {
2050 if (tmp > INT64_MAX) tmp = INT64_MAX;
2089 switch (
value->type) {
2091 if (*outlen < 8)
return -1;
2106 if (slen < 0)
return -1;
2115 *outlen =
value->vb_ip.prefix;
2121 *outlen =
value->vb_length * 8;
2126 *outlen =
sizeof(
value->vb_ether) * 8;
2157 "destination type size %zu",
2170 if (!src->vb_length)
return 0;
2172 ptr = (
uint8_t *) &dst->datum;
2185 memcpy(ptr, src->vb_octets, src->vb_length);
2196 0x00, 0x00, 0x00, 0x00, 0xff, 0xff };
2217 switch (src->type) {
2225 (
char const *)src->vb_octets, src->vb_length, src->tainted);
2229 dst,
UNCONST(fr_value_box_list_t *, &src->vb_group),
2269 switch (src->type) {
2276 (
uint8_t const *)src->vb_strvalue, src->vb_length, src->tainted);
2280 dst,
UNCONST(fr_value_box_list_t *, &src->vb_group),
2289 (
uint8_t const *)&src->vb_ip.addr.v4.s_addr,
2290 sizeof(src->vb_ip.addr.v4.s_addr), src->tainted);
2300 sizeof(src->vb_ip.addr.v4.s_addr) + 1, src->tainted) < 0)
return -1;
2302 bin[0] = src->vb_ip.prefix;
2303 memcpy(&bin[1], (
uint8_t const *)&src->vb_ip.addr.v4.s_addr,
sizeof(src->vb_ip.addr.v4.s_addr));
2312 (
uint8_t const *)src->vb_ip.addr.v6.s6_addr,
2313 sizeof(src->vb_ip.addr.v6.s6_addr), src->tainted);
2323 sizeof(src->vb_ip.addr.v6.s6_addr) + 2, src->tainted) < 0)
return -1;
2324 bin[0] = src->vb_ip.scope_id;
2325 bin[1] = src->vb_ip.prefix;
2326 memcpy(&bin[2], src->vb_ip.addr.v6.s6_addr,
sizeof(src->vb_ip.addr.v6.s6_addr));
2351#define CAST_IP_FIX_COMBO \
2352 case FR_TYPE_COMBO_IP_ADDR: \
2353 if (src->vb_ip.af == AF_INET) { \
2354 src_type = FR_TYPE_IPV4_ADDR; \
2355 } else if (src->vb_ip.af == AF_INET6) { \
2356 src_type = FR_TYPE_IPV6_ADDR; \
2359 case FR_TYPE_COMBO_IP_PREFIX: \
2360 if (src->vb_ip.af == AF_INET) { \
2361 src_type = FR_TYPE_IPV4_PREFIX; \
2362 } else if (src->vb_ip.af == AF_INET6) { \
2363 src_type = FR_TYPE_IPV6_PREFIX; \
2395 src->vb_strvalue, src->vb_length,
2408 dst->vb_ip.af = AF_INET;
2409 dst->vb_ip.prefix = 32;
2410 dst->vb_ip.scope_id = 0;
2422 memcpy(&dst->vb_ip.addr.v4, &src->vb_ip.addr.v6.s6_addr[
sizeof(
v4_v6_map)],
2423 sizeof(dst->vb_ip.addr.v4));
2428 if (src->vb_ip.prefix != 32) {
2430 "cast to IP address types",
2439 memcpy(&dst->vb_ip.addr.v4, &src->vb_ip.addr.v4,
sizeof(dst->vb_ip.addr.v4));
2443 if (src->vb_ip.prefix != 128) {
2444 fr_strerror_printf(
"Invalid cast from %s to %s. Only /128 (not /%i) prefixes may be "
2445 "cast to IP address types",
2451 if (memcmp(&src->vb_ip.addr.v6.s6_addr,
v4_v6_map,
sizeof(
v4_v6_map)) != 0)
goto bad_v6_prefix_map;
2452 memcpy(&dst->vb_ip.addr.v4, &src->vb_ip.addr.v6.s6_addr[
sizeof(
v4_v6_map)],
2453 sizeof(dst->vb_ip.addr.v4));
2457 if (src->vb_length !=
sizeof(dst->vb_ip.addr.v4.s_addr)) {
2458 fr_strerror_printf(
"Invalid cast from %s to %s. Needed octet string of length %zu, got %zu",
2461 sizeof(dst->vb_ip.addr.v4.s_addr), src->vb_length);
2464 memcpy(&dst->vb_ip.addr.v4, src->vb_octets,
sizeof(dst->vb_ip.addr.v4.s_addr));
2471 net = ntohl(src->vb_uint32);
2472 memcpy(&dst->vb_ip.addr.v4, (
uint8_t *)&net,
sizeof(dst->vb_ip.addr.v4.s_addr));
2512 src->vb_strvalue, src->vb_length,
2525 dst->vb_ip.af = AF_INET;
2526 dst->vb_ip.scope_id = 0;
2530 dst->vb_ip.prefix = src->vb_ip.prefix;
2534 memcpy(&dst->vb_ip, &src->vb_ip,
sizeof(dst->vb_ip));
2548 memcpy(&dst->vb_ip.addr.v4.s_addr, &src->vb_ip.addr.v6.s6_addr[
sizeof(
v4_v6_map)],
2549 sizeof(dst->vb_ip.addr.v4.s_addr));
2550 dst->vb_ip.prefix = 32;
2554 if (memcmp(src->vb_ip.addr.v6.s6_addr,
v4_v6_map,
sizeof(
v4_v6_map)) != 0)
goto bad_v6_prefix_map;
2556 if (src->vb_ip.prefix < (
sizeof(
v4_v6_map) << 3)) {
2557 fr_strerror_printf(
"Invalid cast from %s to %s. Expected prefix >= %u bits got %u bits",
2560 (
unsigned int)(
sizeof(
v4_v6_map) << 3), src->vb_ip.prefix);
2563 memcpy(&dst->vb_ip.addr.v4.s_addr, &src->vb_ip.addr.v6.s6_addr[
sizeof(
v4_v6_map)],
2564 sizeof(dst->vb_ip.addr.v4.s_addr));
2569 dst->vb_ip.prefix = src->vb_ip.prefix - (
sizeof(
v4_v6_map) << 3);
2573 if (src->vb_length !=
sizeof(dst->vb_ip.addr.v4.s_addr) + 1) {
2574 fr_strerror_printf(
"Invalid cast from %s to %s. Needed octet string of length %zu, got %zu",
2577 sizeof(dst->vb_ip.addr.v4.s_addr) + 1, src->vb_length);
2580 dst->vb_ip.prefix = src->vb_octets[0];
2581 memcpy(&dst->vb_ip.addr.v4, &src->vb_octets[1],
sizeof(dst->vb_ip.addr.v4.s_addr));
2588 net = ntohl(src->vb_uint32);
2589 memcpy(&dst->vb_ip.addr.v4, (
uint8_t *)&net,
sizeof(dst->vb_ip.addr.v4.s_addr));
2590 dst->vb_ip.prefix = 32;
2624 static_assert((
sizeof(
v4_v6_map) +
sizeof(src->vb_ip.addr.v4)) <=
2625 sizeof(src->vb_ip.addr.v6),
"IPv6 storage too small");
2633 src->vb_strvalue, src->vb_length,
2646 dst->vb_ip.af = AF_INET6;
2647 dst->vb_ip.prefix = 128;
2652 uint8_t *p = dst->vb_ip.addr.v6.s6_addr;
2657 memcpy(p, (
uint8_t const *)&src->vb_ip.addr.v4.s_addr,
sizeof(src->vb_ip.addr.v4.s_addr));
2658 dst->vb_ip.scope_id = 0;
2664 uint8_t *p = dst->vb_ip.addr.v6.s6_addr;
2666 if (src->vb_ip.prefix != 32) {
2668 "cast to IP address types",
2678 memcpy(p, (
uint8_t const *)&src->vb_ip.addr.v4.s_addr,
sizeof(src->vb_ip.addr.v4.s_addr));
2679 dst->vb_ip.scope_id = 0;
2684 if (src->vb_ip.prefix != 128) {
2685 fr_strerror_printf(
"Invalid cast from %s to %s. Only /128 (not /%i) prefixes may be "
2686 "cast to IP address types",
2695 memcpy(dst->vb_ip.addr.v6.s6_addr, src->vb_ip.addr.v6.s6_addr,
2696 sizeof(dst->vb_ip.addr.v6.s6_addr));
2697 dst->vb_ip.scope_id = src->vb_ip.scope_id;
2701 if (src->vb_length !=
sizeof(dst->vb_ip.addr.v6.s6_addr)) {
2702 fr_strerror_printf(
"Invalid cast from %s to %s. Needed octet string of length %zu, got %zu",
2705 sizeof(dst->vb_ip.addr.v6.s6_addr), src->vb_length);
2708 memcpy(&dst->vb_ip.addr.v6.s6_addr, src->vb_octets,
sizeof(dst->vb_ip.addr.v6.s6_addr));
2747 src->vb_strvalue, src->vb_length,
2760 dst->vb_ip.af = AF_INET6;
2765 uint8_t *p = dst->vb_ip.addr.v6.s6_addr;
2770 memcpy(p, (
uint8_t const *)&src->vb_ip.addr.v4.s_addr,
sizeof(src->vb_ip.addr.v4.s_addr));
2771 dst->vb_ip.prefix = 128;
2772 dst->vb_ip.scope_id = 0;
2778 uint8_t *p = dst->vb_ip.addr.v6.s6_addr;
2783 memcpy(p, (
uint8_t const *)&src->vb_ip.addr.v4.s_addr,
sizeof(src->vb_ip.addr.v4.s_addr));
2784 dst->vb_ip.prefix = (
sizeof(
v4_v6_map) << 3) + src->vb_ip.prefix;
2785 dst->vb_ip.scope_id = 0;
2790 dst->vb_ip.prefix = src->vb_ip.prefix;
2794 dst->vb_ip.prefix = 128;
2796 memcpy(dst->vb_ip.addr.v6.s6_addr, src->vb_ip.addr.v6.s6_addr,
2797 sizeof(dst->vb_ip.addr.v6.s6_addr));
2798 dst->vb_ip.scope_id = src->vb_ip.scope_id;
2802 if (src->vb_length != (
sizeof(dst->vb_ip.addr.v6.s6_addr) + 2)) {
2803 fr_strerror_printf(
"Invalid cast from %s to %s. Needed octet string of length %zu, got %zu",
2806 sizeof(dst->vb_ip.addr.v6.s6_addr) + 2, src->vb_length);
2809 dst->vb_ip.scope_id = src->vb_octets[0];
2810 dst->vb_ip.prefix = src->vb_octets[1];
2811 memcpy(&dst->vb_ip.addr.v6.s6_addr, src->vb_octets,
sizeof(dst->vb_ip.addr.v6.s6_addr));
2843 switch (src->type) {
2846 src->vb_strvalue, src->vb_length,
2861 switch (src->type) {
2870 if ((array[0] != 0) || (array[1] != 0))
return -1;
2872 memcpy(dst->vb_ether, &array[2], 6);
2904 switch (src->type) {
2907 src->vb_strvalue, src->vb_length,
2925 switch (src->type) {
2927 dst->vb_bool = (src->vb_int8 != 0);
2931 dst->vb_bool = (src->vb_uint8 != 0);
2935 dst->vb_bool = (src->vb_int16 != 0);
2939 dst->vb_bool = (src->vb_uint16 != 0);
2943 dst->vb_bool = (src->vb_int32 != 0);
2947 dst->vb_bool = (src->vb_uint32 != 0);
2951 dst->vb_bool = (src->vb_int64 != 0);
2955 dst->vb_bool = (src->vb_uint64 != 0);
2959 dst->vb_bool = (src->vb_size != 0);
2967 dst->vb_bool = (fpclassify(src->vb_float32) == FP_ZERO);
2971 dst->vb_bool = (fpclassify(src->vb_float64) == FP_ZERO);
2997#define SIGN_BIT_HIGH(_int, _len) ((((uint64_t)1) << (((_len) << 3) - 1)) & (_int))
2998#define SIGN_PROMOTE(_int, _len) ((_len) < sizeof(_int) ? \
2999 (_int) | (~((__typeof__(_int))0)) << ((_len) << 3) : (_int))
3001#if !defined(NDEBUG) || defined(STATIC_ANALYZER)
3007 "invalid source type len, expected > 0, got %zu",
3013 "Invalid cast from %s to %s. "
3014 "invalid source type len, expected <= %zu, got %zu",
3017 sizeof(uint64_t), len))
return -1;
3020 switch (src->type) {
3033 if (src->enumv) res = src->enumv->flags.flag_time_res;
3049 if (src->enumv) res = src->enumv->flags.flag_time_res;
3056#ifdef WORDS_BIGENDIAN
3057 memcpy(((
uint8_t *)&tmp) + (
sizeof(tmp) - len),
3074 if ((int64_t)tmp <
min) {
3076 "outside value range %"PRId64
"-%"PRIu64,
3085 "outside value range 0-%"PRIu64,
3098 if (dst->enumv) res = dst->enumv->flags.flag_time_res;
3112 if (dst->enumv) res = dst->enumv->flags.flag_time_res;
3123#ifdef WORDS_BIGENDIAN
3148 switch (src->type) {
3151 src->vb_strvalue, src->vb_length,
3179 memcpy(&tmp.vb_uint32, &src->vb_ip.addr.v4,
sizeof(tmp.vb_uint32));
3200 memcpy(((
uint8_t *)&tmp.vb_uint64) + (
sizeof(tmp.vb_uint64) -
sizeof(src->vb_ether)),
3201 &src->vb_ether,
sizeof(src->vb_ether));
3202#ifndef WORDS_BIGENDIAN
3252 switch (src->type) {
3255 num = (double) src->vb_float32;
3263 num = src->vb_float64;
3278 num = src->vb_int16;
3282 num = src->vb_int32;
3286 num = src->vb_int64;
3290 num = src->vb_uint8;
3294 num = src->vb_uint16;
3298 num = src->vb_uint32;
3302 num = src->vb_uint64;
3333 dst->vb_float32 = num;
3335 dst->vb_float64 = num;
3400 if (dst_type == src->type) {
3404 if (ret < 0)
return ret;
3406 dst->enumv = dst_enumv;
3462 dst->enumv = dst_enumv;
3478 if (when > INT64_MAX) {
3484 dst->enumv = dst_enumv;
3526 src->vb_strvalue, src->vb_length,
3533 fr_strerror_printf(
"Invalid cast from %s to %s. Source is length %zu is smaller than "
3534 "destination type size %zu",
3544 "destination type size %zu",
3559 tmp.type = dst_type;
3560 dst->enumv = dst_enumv;
3570 dst->enumv = dst_enumv;
3598 fr_value_box_entry_t entry = vb->entry;
3604 if (vb->type == dst_type) {
3605 vb->enumv = dst_enumv;
3653 switch (ipaddr->
af) {
3668 memcpy(&dst->vb_ip, ipaddr,
sizeof(dst->vb_ip));
3689 memcpy(dst, &src->vb_ip,
sizeof(*dst));
3702 switch (
data->type) {
3719 while ((vb = fr_value_box_list_next(&
data->vb_group, vb))) {
3733 memset(&
data->datum, 0,
sizeof(
data->datum));
3761 switch (src->type) {
3783 dst->vb_strvalue = str;
3792 if (src->vb_length) {
3793 bin = talloc_memdup(ctx, src->vb_octets, src->vb_length);
3798 talloc_set_type(bin,
uint8_t);
3800 bin = talloc_array(ctx,
uint8_t, 0);
3802 dst->vb_octets = bin;
3813 while ((child = fr_value_box_list_next(&src->vb_group, child))) {
3823 fr_value_box_list_talloc_free(&dst->vb_group);
3834 fr_value_box_list_insert_tail(&dst->vb_group,
new);
3866 switch (src->type) {
3873 dst->datum.ptr = ctx ? talloc_reference(ctx, src->datum.ptr) : src->datum.ptr;
3892 switch (src->type) {
3900 str = talloc_steal(ctx, src->vb_strvalue);
3905 talloc_set_type(str,
char);
3906 dst->vb_strvalue = str;
3908 memset(&src->datum, 0,
sizeof(src->datum));
3916 bin = talloc_steal(ctx, src->vb_octets);
3921 talloc_set_type(bin,
uint8_t);
3923 dst->vb_octets = bin;
3925 memset(&src->datum, 0,
sizeof(src->datum));
3933 while ((child = fr_value_box_list_pop_head(&src->vb_group))) {
3934 child = talloc_steal(ctx, child);
3939 fr_value_box_list_insert_tail(&dst->vb_group, child);
3958 char const *src,
bool tainted)
3969 dst->vb_strvalue = str;
3970 dst->vb_length = talloc_array_length(str) - 1;
3990 len = strlen(vb->vb_strvalue);
3991 str = talloc_realloc(ctx,
UNCONST(
char *, vb->vb_strvalue),
char, len + 1);
3996 vb->vb_length = len;
4014 char const *
fmt, va_list ap)
4023 if (!str)
return -1;
4026 dst->vb_strvalue = str;
4027 dst->vb_length = talloc_array_length(str) - 1;
4045 char const *
fmt, ...)
4067 char const *src,
bool tainted)
4070 dst->vb_strvalue = src;
4071 dst->vb_length = strlen(src);
4085 vb->vb_strvalue = src;
4086 vb->vb_length = len < 0 ? strlen(src) : (
size_t)len;
4102 size_t len,
bool tainted)
4106 str = talloc_zero_array(ctx,
char, len + 1);
4114 dst->vb_strvalue = str;
4115 dst->vb_length = len;
4142 memcpy(&cstr, &dst->vb_strvalue,
sizeof(cstr));
4144 clen = talloc_array_length(dst->vb_strvalue) - 1;
4145 if (clen == len)
return 0;
4147 str = talloc_realloc(ctx, cstr,
char, len + 1);
4157 memset(str + clen,
'\0', (len - clen) + 1);
4161 dst->vb_strvalue = str;
4162 dst->vb_length = len;
4179 char const *src,
size_t len,
bool tainted)
4196 dst->vb_strvalue = str;
4197 dst->vb_length = len;
4207 str = talloc_array(ctx,
char, len + 1);
4217 dst->vb_strvalue = str;
4218 dst->vb_length = len;
4239 char const *src,
bool tainted)
4245 len = talloc_array_length(src);
4246 if ((len == 0) || (src[len - 1] !=
'\0')) {
4263 char const *src,
size_t len,
bool tainted)
4266 dst->vb_strvalue = src;
4267 dst->vb_length = len;
4284 char const *src,
bool tainted)
4290 len = talloc_array_length(src);
4291 if ((len == 0) || (src[len - 1] !=
'\0')) {
4297 dst->vb_strvalue = ctx ? talloc_reference(ctx, src) : src;
4298 dst->vb_length = len - 1;
4323 size_t len,
bool tainted)
4327 bin = talloc_array(ctx,
uint8_t, len);
4332 talloc_set_type(bin,
uint8_t);
4335 dst->vb_octets = bin;
4336 dst->vb_length = len;
4363 memcpy(&cbin, &dst->vb_octets,
sizeof(cbin));
4365 clen = talloc_array_length(dst->vb_octets);
4366 if (clen == len)
return 0;
4374 bin = talloc_realloc(ctx, cbin,
uint8_t, len);
4376 bin = talloc_array(ctx,
uint8_t, 0);
4392 if (clen < len) memset(bin + clen, 0x00, len - clen);
4393 dst->vb_octets = bin;
4394 dst->vb_length = len;
4420 uint8_t const *src,
size_t len,
bool tainted)
4430 bin = talloc_memdup(ctx, src, len);
4435 talloc_set_type(bin,
uint8_t);
4438 dst->vb_octets = bin;
4439 dst->vb_length = len;
4449 bin = talloc_size(ctx, len);
4455 talloc_set_type(bin,
uint8_t);
4458 dst->vb_octets = bin;
4459 dst->vb_length = len;
4478 uint8_t const *src,
bool tainted)
4500 uint8_t const *src,
size_t len,
bool tainted)
4503 dst->vb_octets = src;
4504 dst->vb_length = len;
4518 uint8_t const *src,
bool tainted)
4523 dst->vb_octets = ctx ? talloc_reference(ctx, src) : src;
4524 dst->vb_length = talloc_array_length(src);
4537 vb->vb_uint8 = vb->vb_uint8 ==
UINT8_MAX ? 0 : vb->vb_uint8 + 1;
4541 vb->vb_uint16 = vb->vb_uint16 == UINT16_MAX ? 0 : vb->vb_uint16 + 1;
4545 vb->vb_uint32 = vb->vb_uint32 == UINT32_MAX ? 0 : vb->vb_uint32 + 1;
4549 vb->vb_uint64 = vb->vb_uint64 == UINT64_MAX ? 0 : vb->vb_uint64 + 1;
4553 vb->vb_int8 = vb->vb_int8 == INT8_MAX ? INT8_MIN : vb->vb_int8 + 1;
4557 vb->vb_int16 = vb->vb_int16 == INT16_MAX ? INT16_MIN : vb->vb_int16 + 1;
4561 vb->vb_int32 = vb->vb_int32 == INT32_MAX ? INT32_MIN : vb->vb_int32 + 1;
4565 vb->vb_int64 = vb->vb_int64 == INT64_MAX ? INT64_MIN : vb->vb_int64 + 1;
4585static inline CC_HINT(always_inline)
4588 fr_sbuff_t *
in, fr_sbuff_parse_rules_t const *rules,
bool tainted)
4654 rules->escapes ? rules->escapes->chr :
'\0');
4666 fr_sbuff_parse_error_to_strerror(
err);
4690 static fr_sbuff_parse_rules_t default_rules;
4697 if (!rules) rules = &default_rules;
4704 if (dst_enumv && dst_enumv->flags.has_value) {
4721 if (!rules->escapes) {
4725 fr_sbuff_marker(&m, &our_in);
4730 fr_sbuff_marker_release(&m);
4732 if (!len)
goto parse;
4766 rules->terminals, rules->escapes);
4768 fr_sbuff_set_to_start(&our_in);
4774 fr_sbuff_set_to_start(&our_in);
4797 if (!dst_enumv || !unescaped) {
4800 if (
unlikely(fr_sbuff_out_aunescape_until(ctx, &
buff, &our_in, SIZE_MAX,
4801 rules->terminals, rules->escapes) < 0)) {
4827 if (!dst_enumv || !unescaped) {
4832 fr_sbuff_out_aunescape_until(ctx, &
buff, &our_in, SIZE_MAX,
4833 rules->terminals, rules->escapes);
4835 if (talloc_array_length(
buff) == 1) {
4840 bin = talloc_realloc(ctx,
buff,
uint8_t, talloc_array_length(
buff) - 1);
4846 talloc_set_type(bin,
uint8_t);
4857 bin = talloc_zero_array(ctx,
uint8_t, 0);
4872 fr_sbuff_marker(&hex_start, &our_in);
4889 if ((hex_len & 0x01) != 0) {
4915 if (!name_len)
return 0;
4927 "for non-prefix types", addr.
prefix);
4931 memcpy(&dst->vb_ip, &addr,
sizeof(dst->vb_ip));
4938 if (!name_len)
return 0;
4948 if (!name_len)
return 0;
4964 if (addr.
prefix != 128) {
4967 "for non-prefix types", addr.
prefix);
4971 memcpy(&dst->vb_ip, &addr,
sizeof(dst->vb_ip));
4978 if (!name_len)
return 0;
4988 if (!name_len)
return 0;
5000 if ((addr.
af == AF_INET) && (addr.
prefix != 32)) {
5001 goto fail_ipv4_prefix;
5004 if ((addr.
af == AF_INET6) && (addr.
prefix != 128)) {
5005 goto fail_ipv6_prefix;
5008 memcpy(&dst->vb_ip, &addr,
sizeof(dst->vb_ip));
5015 if (!name_len)
return 0;
5045 if (slen >= 0)
return slen;
5051 if (!rules->escapes) {
5057 dst->vb_bool = (stmp != 0);
5063 dst->vb_bool = (utmp != 0);
5069 "\"yes\", \"no\", \"true\", \"false\" or any unquoted integer");
5109 fr_sbuff_set_to_start(&our_in);
5114 fr_sbuff_parse_error_to_strerror(
err);
5157 false, rules->terminals);
5158 if (slen < 0)
return slen;
5180 if (rules && rules->terminals) {
5184 rules->terminals, rules->escapes);
5185 if (len >=
sizeof(
buffer))
goto too_small;
5216 dst->enumv = dst_enumv;
5233 dst->type = dst_type;
5234 dst->tainted =
false;
5240 dst->enumv = dst_enumv;
5241 fr_value_box_list_entry_init(dst);
5252 fr_sbuff_parse_rules_t prules = { .escapes = erules };
5255 if (slen <= 0)
return slen;
5258 fr_strerror_printf(
"Failed parsing '%s'. %zu bytes of trailing data after string value \"%pV\"",
5262 return (slen -
inlen) - 1;
5289 if (
data->enumv &&
data->enumv->flags.has_value) {
5299 switch (
data->type) {
5302 data->vb_strvalue,
data->vb_length, e_rules);
5339 data->vb_ether[0],
data->vb_ether[1],
5340 data->vb_ether[2],
data->vb_ether[3],
5341 data->vb_ether[4],
data->vb_ether[5]);
5392 if (
data->enumv) res =
data->enumv->flags.flag_time_res;
5405 bool is_unsigned =
false;
5408 res =
data->enumv->flags.flag_time_res;
5409 is_unsigned =
data->enumv->flags.is_unsigned;
5425 if (!e_rules || (!e_rules->do_oct && !e_rules->do_hex)) {
5436 NULL, &our_out,
UNCONST(fr_value_box_list_t *, &
data->vb_group),
5437 ", ", (
sizeof(
", ") - 1), e_rules,
5477 switch (
data->type) {
5521 if (fr_value_box_list_empty(list))
return 0;
5523 if (
fr_debug_lvl >= 4) fprintf(stderr,
"CONCAT AS STRING");
5532 if (!flatten)
goto print;
5534 sep, sep_len, e_rules,
5535 proc_action, safe_for, flatten);
5544 box_safe_for = safe_for;
5546 slen =
fr_sbuff_in_escape(&our_sbuff, (
char const *)vb->vb_strvalue, vb->vb_length, e_rules);
5566 if (e_rules) box_safe_for = safe_for;
5570 if (slen < 0)
return slen;
5575 if (sep && fr_value_box_list_next(list, vb)) {
5577 if (slen < 0)
return slen;
5589 (safety->safe_for != box_safe_for)) {
5591 safety->safe_for = box_safe_for;
5597 safety->tainted |= vb->tainted;
5598 safety->secret |= vb->secret;
5635 uint8_t const *sep,
size_t sep_len,
5639 TALLOC_CTX *tmp_ctx = NULL;
5642 if (fr_value_box_list_empty(list))
return 0;
5647 if (!flatten)
goto cast;
5650 proc_action, flatten);
5669 if (!tmp_ctx) tmp_ctx = talloc_pool(NULL, 1024);
5691 if (sep && fr_value_box_list_next(list, vb)) {
5693 if (slen < 0)
goto error;
5740 fr_dbuff_uctx_talloc_t dbuff_tctx;
5747 fr_value_box_entry_t entry;
5749 if (fr_value_box_list_empty(list)) {
5758 if ((fr_value_box_list_num_elements(list) == 1) && (head_vb ==
out) && (head_vb->type ==
type))
return 0;
5762 if (
unlikely(!fr_sbuff_init_talloc(ctx, &sbuff, &sbuff_tctx, 256, max_size)))
return -1;
5784 if (
out == head_vb) {
5821 fr_value_box_list_insert_head(list, head_vb);
5836 proc_action, flatten) < 0) {
5837 fr_value_box_list_insert_head(list, head_vb);
5849 fr_value_box_list_insert_head(list,
out);
5875 proc_action, flatten) < 0)
goto error;
5927 ret = escape->
func(vb, uctx);
5931 vb->tainted =
false;
5975 fr_value_box_list_remove(&child->vb_group, grandchild);
5976 if (steal) talloc_steal(ctx, grandchild);
5977 fr_value_box_list_insert_before(list, child, grandchild);
5998 char *aggr, *td = NULL;
5999 TALLOC_CTX *pool = NULL;
6001 if (!vb)
return NULL;
6004 if (!aggr)
return NULL;
6005 if (!fr_value_box_list_next(list, vb))
return aggr;
6011 pool = talloc_pool(NULL, 255);
6014 while ((vb = fr_value_box_list_next(list, vb))) {
6015 char *str, *new_aggr;
6048 char *aggr, *td = NULL;
6049 TALLOC_CTX *pool = NULL;
6051 if (!vb)
return NULL;
6058 if (!aggr)
return NULL;
6059 if (!fr_value_box_list_next(list, vb))
return aggr;
6065 pool = talloc_pool(NULL, 255);
6068 while ((vb = fr_value_box_list_next(list, vb))) {
6069 char *str, *new_aggr;
6103 return fr_hash(vb->vb_strvalue, vb->vb_length);
6106 return fr_hash(vb->vb_octets, vb->vb_length);
6128 while ((in_p = fr_value_box_list_next(
in, in_p))) {
6134 fr_value_box_list_talloc_free(
out);
6156 while ((vb = fr_value_box_list_next(
head, vb))) {
6158 if (vb->tainted)
return true;
6172 while ((vb = fr_value_box_list_next(
head, vb))) {
6187 while ((vb = fr_value_box_list_next(
head, vb))) {
6189 vb->tainted =
false;
6215 fr_fatal_assert_msg(vb->vb_strvalue,
"CONSISTENCY CHECK FAILED %s[%d]: fr_value_box_t strvalue field "
6218 "CONSISTENCY CHECK FAILED %s[%i]: fr_value_box_t strvalue field "
6219 "not null terminated",
file,
line);
6221 size_t len = talloc_array_length(vb->vb_strvalue);
6225 fr_fatal_assert_fail(
"CONSISTENCY CHECK FAILED %s[%d]: Expected fr_value_box_t->vb_strvalue talloc buffer "
6226 "len >= %zu, got %zu",
6227 file,
line, vb->vb_length + 1, len);
6233 fr_fatal_assert_msg(vb->vb_octets,
"CONSISTENCY CHECK FAILED %s[%d]: fr_value_box_t octets field "
6238 fr_fatal_assert_msg(vb->vb_void,
"CONSISTENCY CHECK FAILED %s[%d]: fr_value_box_t ptr field "
6271 vb->safe_for = safe_for;
6300 vb->safe_for = safe_for;
6310 if (
out ==
in)
return;
6312 out->safe_for =
in->safe_for;
6313 out->tainted =
in->tainted;
6314 out->secret =
in->secret;
6324 out->tainted =
in->tainted;
6325 out->secret =
in->secret;
6332 if (
out ==
in)
return;
6340 (
out->safe_for !=
in->safe_for)) {
6348 out->safe_for =
in->safe_for;
6355 out->tainted |=
in->tainted;
6356 out->secret |=
in->secret;
6378 return (fr_value_box_list_num_elements(&
in->vb_group) > 0);
6385 return (
in->vb_length > 0);
6402#define INFO_INDENT(_fmt, ...) FR_FAULT_LOG("%*s"_fmt, depth * 2, " ", ## __VA_ARGS__)
6436 vb->secret ?
"s" :
"-",
6437 vb->tainted ?
"t" :
"-",
6442 vb->secret ?
"s" :
"-",
6443 vb->tainted ?
"t" :
"-",
static int const char char buffer[256]
static int const char * fmt
#define fr_base16_encode(_out, _in)
#define fr_base16_decode(_err, _out, _in, _no_trailing)
#define UNCONST(_type, _ptr)
Remove const qualification from a pointer.
#define L(_str)
Helper for initialising arrays of string literals.
#define FALL_THROUGH
clang 10 doesn't recognised the FALL-THROUGH comment anymore
#define SIZEOF_MEMBER(_t, _m)
#define CMP(_a, _b)
Same as CMP_PREFER_SMALLER use when you don't really care about ordering, you just want an ordering.
static fr_atomic_queue_t * aq
static size_t min(size_t x, size_t y)
int fr_dbuff_trim_talloc(fr_dbuff_t *dbuff, size_t len)
Trim a talloced dbuff to the minimum length required to represent the contained string.
#define fr_dbuff_used(_dbuff_or_marker)
Return the number of bytes remaining between the start of the dbuff or marker and the current positio...
#define FR_DBUFF_OUT_UINT64V_RETURN(_num, _dbuff_or_marker, _len)
Read bytes from a dbuff or marker and interpret them as a network order unsigned integer.
#define fr_dbuff_set(_dst, _src)
Set the 'current' position in a dbuff or marker using another dbuff or marker, a char pointer,...
#define fr_dbuff_init(_out, _start, _len_or_end)
Initialise an dbuff for encoding or decoding.
#define fr_dbuff_start(_dbuff_or_marker)
Return the 'start' position of a dbuff or marker.
#define FR_DBUFF_OUT_INT64V_RETURN(_num, _dbuff_or_marker, _len)
Read bytes from a dbuff or marker and interpret them as a network order unsigned integer.
#define fr_dbuff_buff(_dbuff_or_marker)
Return the underlying buffer in a dbuff or one of marker.
#define fr_dbuff_out_memcpy(_out, _dbuff_or_marker, _outlen)
Copy exactly _outlen bytes from the dbuff.
#define FR_DBUFF_MEMSET_RETURN(_dbuff_or_marker, _c, _inlen)
Set _inlen bytes of a dbuff or marker to _c returning if there is insufficient space.
#define FR_DBUFF_OUT_MEMCPY_RETURN(_out, _dbuff_or_marker, _outlen)
Copy outlen bytes from the dbuff returning if there's insufficient data in the dbuff.
#define FR_DBUFF_IN_MEMCPY_RETURN(_dbuff_or_marker, _in, _inlen)
Copy exactly _inlen bytes into dbuff or marker returning if there's insufficient space.
#define fr_dbuff_in_memcpy(_dbuff_or_marker, _in, _inlen)
Copy exactly _inlen bytes into a dbuff or marker.
#define FR_DBUFF_IN_RETURN(_dbuff_or_marker, _in)
Copy data from a fixed sized C type into a dbuff returning if there is insufficient space.
#define FR_DBUFF(_dbuff_or_marker)
Create a new dbuff pointing to the same underlying buffer.
#define FR_DBUFF_OUT_RETURN(_out, _dbuff_or_marker)
Copy data from a dbuff or marker to a fixed sized C type returning if there is insufficient data.
static fr_dbuff_t * fr_dbuff_init_talloc(TALLOC_CTX *ctx, fr_dbuff_t *dbuff, fr_dbuff_uctx_talloc_t *tctx, size_t init, size_t max)
Initialise a special dbuff which automatically extends as additional data is written.
#define FR_DBUFF_IN_BYTES_RETURN(_dbuff_or_marker,...)
Copy a byte sequence into a dbuff or marker returning if there's insufficient space.
#define FR_DBUFF_TMP(_start, _len_or_end)
Creates a compound literal to pass into functions which accept a dbuff.
#define fr_fatal_assert_fail(_msg,...)
Calls panic_action ifndef NDEBUG, else logs error and causes the server to exit immediately with code...
#define fr_cond_assert(_x)
Calls panic_action ifndef NDEBUG, else logs error and evaluates to value of _x.
#define fr_assert_fail(_msg,...)
Calls panic_action ifndef NDEBUG, else logs error.
#define fr_cond_assert_msg(_x, _fmt,...)
Calls panic_action ifndef NDEBUG, else logs error and evaluates to value of _x.
#define fr_fatal_assert_msg(_x, _fmt,...)
Calls panic_action ifndef NDEBUG, else logs error and causes the server to exit immediately with code...
bool const fr_dict_enum_allowed_chars[UINT8_MAX+1]
Characters that are allowed in dictionary enumeration value names.
fr_value_box_t const * value
Enum value (what name maps to).
char const * fr_dict_enum_name_by_value(fr_dict_attr_t const *da, fr_value_box_t const *value)
Lookup the name of an enum value in a fr_dict_attr_t.
fr_dict_enum_value_t * fr_dict_enum_by_name(fr_dict_attr_t const *da, char const *name, ssize_t len)
#define da_is_length_field(_da)
@ FLAG_LENGTH_UINT8
string / octets type is prefixed by uint8 of length
@ FLAG_LENGTH_UINT16
string / octets type is prefixed by uint16 of length
Value of an enumerated attribute.
static int fr_dlist_insert_tail(fr_dlist_head_t *list_head, void *ptr)
Insert an item into the tail of a list.
uint32_t fr_hash(void const *data, size_t size)
int fr_ipaddr_is_prefix(fr_ipaddr_t const *ipaddr)
Determine if an address is a prefix.
char * fr_inet_ntop_prefix(char out[static FR_IPADDR_PREFIX_STRLEN], size_t outlen, fr_ipaddr_t const *addr)
Print a fr_ipaddr_t as a CIDR style network prefix.
int fr_inet_pton6(fr_ipaddr_t *out, char const *value, ssize_t inlen, bool resolve, bool fallback, bool mask)
Parse an IPv6 address or IPv6 prefix in presentation format (and others)
bool fr_hostname_lookups
hostname -> IP lookups?
int fr_inet_pton(fr_ipaddr_t *out, char const *value, ssize_t inlen, int af, bool resolve, bool mask)
Simple wrapper to decide whether an IP value is v4 or v6 and call the appropriate parser.
int fr_ipaddr_is_inaddr_any(fr_ipaddr_t const *ipaddr)
Determine if an address is the INADDR_ANY address for its address family.
char * fr_inet_ntop(char out[static FR_IPADDR_STRLEN], size_t outlen, fr_ipaddr_t const *addr)
Print the address portion of a fr_ipaddr_t.
int8_t fr_ipaddr_cmp(fr_ipaddr_t const *a, fr_ipaddr_t const *b)
Compare two ip addresses.
char * fr_inet_ifid_ntop(char *out, size_t outlen, uint8_t const *ifid)
Print an interface-id in standard colon notation.
uint8_t * fr_inet_ifid_pton(uint8_t out[static 8], char const *ifid_str)
Convert interface-id in colon notation to 8 byte binary form.
uint8_t prefix
Prefix length - Between 0-32 for IPv4 and 0-128 for IPv6.
uint8_t addr[6]
Ethernet address.
Struct to represent an ethernet address.
#define fr_multiply(_out, _a, _b)
Multiplies two integers together.
static const uint8_t * zero
size_t fr_sbuff_out_unescape_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)
@ FR_TYPE_TIME_DELTA
A period of time measured in nanoseconds.
@ FR_TYPE_FLOAT32
Single precision floating point.
@ FR_TYPE_IPV4_ADDR
32 Bit IPv4 Address.
@ FR_TYPE_INT8
8 Bit signed integer.
@ FR_TYPE_TLV
Contains nested attributes.
@ FR_TYPE_ETHERNET
48 Bit Mac-Address.
@ FR_TYPE_IPV6_PREFIX
IPv6 Prefix.
@ FR_TYPE_STRING
String of printable characters.
@ FR_TYPE_MAX
Number of defined data types.
@ FR_TYPE_NULL
Invalid (uninitialised) attribute type.
@ FR_TYPE_UINT16
16 Bit unsigned integer.
@ FR_TYPE_INT64
64 Bit signed integer.
@ FR_TYPE_INT16
16 Bit signed integer.
@ FR_TYPE_DATE
Unix time stamp, always has value >2^31.
@ FR_TYPE_COMBO_IP_PREFIX
IPv4 or IPv6 address prefix depending on length.
@ FR_TYPE_VALUE_BOX
A boxed value.
@ FR_TYPE_UINT8
8 Bit unsigned integer.
@ FR_TYPE_UINT32
32 Bit unsigned integer.
@ FR_TYPE_STRUCT
like TLV, but without T or L, and fixed-width children
@ FR_TYPE_INT32
32 Bit signed integer.
@ FR_TYPE_VENDOR
Attribute that represents a vendor in the attribute tree.
@ FR_TYPE_UINT64
64 Bit unsigned integer.
@ FR_TYPE_IPV6_ADDR
128 Bit IPv6 Address.
@ FR_TYPE_IPV4_PREFIX
IPv4 Prefix.
@ FR_TYPE_BOOL
A truth value.
@ FR_TYPE_SIZE
Unsigned integer capable of representing any memory address on the local system.
@ FR_TYPE_VSA
Vendor-Specific, for RADIUS attribute 26.
@ FR_TYPE_COMBO_IP_ADDR
IPv4 or IPv6 address depending on length.
@ FR_TYPE_IFID
Interface ID.
@ FR_TYPE_OCTETS
Raw octets.
@ FR_TYPE_GROUP
A grouping of other attributes.
@ FR_TYPE_FLOAT64
Double precision floating point.
int fr_inet_pton4(fr_ipaddr_t *out, char const *value, ssize_t inlen, bool resolve, bool fallback, bool mask_bits)
@ FR_SBUFF_PARSE_ERROR_NOT_FOUND
String does not contain a token matching the output type.
@ FR_SBUFF_PARSE_OK
No error.
static uint8_t depth(fr_minmax_heap_index_t i)
int fr_digest_cmp(uint8_t const *a, uint8_t const *b, size_t length)
Do a comparison of two authentication digests by comparing the FULL data.
void * memset_explicit(void *ptr, int ch, size_t len)
static uint64_t fr_nbo_to_uint64(uint8_t const data[static sizeof(uint64_t)])
Read an unsigned 64bit integer from wire format (big endian)
static void fr_nbo_from_uint64(uint8_t out[static sizeof(uint64_t)], uint64_t num)
Write out an unsigned 64bit integer in wire format (big endian)
char * fr_vasprintf(TALLOC_CTX *ctx, char const *fmt, va_list ap)
int fr_sbuff_trim_talloc(fr_sbuff_t *sbuff, size_t len)
Trim a talloced sbuff to the minimum length required to represent the contained string.
size_t fr_sbuff_adv_past_allowed(fr_sbuff_t *sbuff, size_t len, bool const allowed[static UINT8_MAX+1], fr_sbuff_term_t const *tt)
Wind position past characters in the allowed set.
ssize_t fr_sbuff_in_escape(fr_sbuff_t *sbuff, char const *in, size_t inlen, fr_sbuff_escape_rules_t const *e_rules)
Print an escaped string to an sbuff.
bool const sbuff_char_class_hex[UINT8_MAX+1]
bool const sbuff_char_class_uint[UINT8_MAX+1]
bool const sbuff_char_class_hostname[UINT8_MAX+1]
bool fr_sbuff_is_terminal(fr_sbuff_t *in, fr_sbuff_term_t const *tt)
Efficient terminal string search.
ssize_t fr_sbuff_in_bstrncpy(fr_sbuff_t *sbuff, char const *str, size_t len)
Copy bytes into the sbuff up to the first \0.
size_t fr_sbuff_adv_until(fr_sbuff_t *sbuff, size_t len, fr_sbuff_term_t const *tt, char escape_chr)
Wind position until we hit a character in the terminal set.
size_t fr_sbuff_out_bstrncpy(fr_sbuff_t *out, fr_sbuff_t *in, size_t len)
Copy as many bytes as possible from a sbuff to a sbuff.
bool fr_sbuff_next_if_char(fr_sbuff_t *sbuff, char c)
Return true if the current char matches, and if it does, advance.
#define fr_sbuff_start(_sbuff_or_marker)
#define fr_sbuff_adv_past_str_literal(_sbuff, _needle)
#define FR_SBUFF_IN_CHAR_RETURN(_sbuff,...)
#define fr_sbuff_set(_dst, _src)
#define FR_SBUFF_IN(_start, _len_or_end)
#define fr_sbuff_adv_past_strcase_literal(_sbuff, _needle)
#define fr_sbuff_current(_sbuff_or_marker)
char chr
Character at the start of an escape sequence.
#define FR_SBUFF_IN_ESCAPE_BUFFER_RETURN(...)
#define FR_SBUFF_TERMS(...)
Initialise a terminal structure with a list of sorted strings.
char const * name
Name for rule set to aid we debugging.
#define FR_SBUFF_IN_STRCPY_LITERAL_RETURN(_sbuff, _str)
#define fr_sbuff_extend(_sbuff_or_marker)
#define fr_sbuff_buff(_sbuff_or_marker)
#define FR_SBUFF_RETURN(_func, _sbuff,...)
#define FR_SBUFF_ERROR_RETURN(_sbuff_or_marker)
#define FR_SBUFF_SET_RETURN(_dst, _src)
#define FR_SBUFF_IN_SPRINTF_RETURN(...)
#define SBUFF_CHAR_UNPRINTABLES_EXTENDED
#define FR_SBUFF(_sbuff_or_marker)
#define fr_sbuff_advance(_sbuff_or_marker, _len)
#define fr_sbuff_out(_err, _out, _in)
#define FR_SBUFF_IN_ESCAPE_RETURN(...)
#define fr_sbuff_remaining(_sbuff_or_marker)
#define FR_SBUFF_OUT(_start, _len_or_end)
#define SBUFF_CHAR_UNPRINTABLES_LOW
#define fr_sbuff_used(_sbuff_or_marker)
#define FR_SBUFF_TERM(_str)
Initialise a terminal structure with a single string.
#define FR_SBUFF_IN_STRCPY_RETURN(...)
#define FR_SBUFF_TALLOC_THREAD_LOCAL(_out, _init, _max)
Talloc sbuff extension structure.
Set of parsing rules for *unescape_until functions.
fr_slen_t fr_size_from_str(size_t *out, fr_sbuff_t *in)
Parse a size string with optional unit.
fr_slen_t fr_size_to_str(fr_sbuff_t *out, size_t in)
Print a size string with unit.
static char buff[sizeof("18446744073709551615")+3]
fr_aka_sim_id_type_t type
char * talloc_buffer_append_variadic_buffer(TALLOC_CTX *ctx, char *to, int argc,...)
Concatenate to + ...
char * talloc_bstrndup(TALLOC_CTX *ctx, char const *in, size_t inlen)
Binary safe strndup function.
char * talloc_typed_strdup(TALLOC_CTX *ctx, char const *p)
Call talloc_strdup, setting the type on the new chunk correctly.
#define talloc_get_type_abort_const
fr_slen_t fr_time_delta_from_substr(fr_time_delta_t *out, fr_sbuff_t *in, fr_time_res_t hint, bool no_trailing, fr_sbuff_term_t const *tt)
Create fr_time_delta_t from a string.
int fr_unix_time_from_str(fr_unix_time_t *date, char const *date_str, fr_time_res_t hint)
Convert string in various formats to a fr_unix_time_t.
int64_t fr_time_scale(int64_t t, fr_time_res_t hint)
Scale an input time to NSEC, clamping it at max / min.
fr_slen_t fr_time_delta_to_str(fr_sbuff_t *out, fr_time_delta_t delta, fr_time_res_t res, bool is_unsigned)
Print fr_time_delta_t to a string with an appropriate suffix.
fr_slen_t fr_unix_time_to_str(fr_sbuff_t *out, fr_unix_time_t time, fr_time_res_t res, bool utc)
Convert unix time to string.
int64_t const fr_time_multiplier_by_res[]
static fr_time_delta_t fr_time_delta_from_integer(bool *overflow, int64_t integer, fr_time_res_t res)
static int64_t fr_time_delta_to_integer(fr_time_delta_t delta, fr_time_res_t res)
static int64_t fr_time_delta_unwrap(fr_time_delta_t time)
static int8_t fr_time_delta_cmp(fr_time_delta_t a, fr_time_delta_t b)
Compare two fr_time_delta_t values.
#define fr_time_delta_isneg(_a)
#define fr_time_delta_wrap(_time)
#define fr_unix_time_wrap(_time)
fr_time_res_t
The base resolution for print parse operations.
static fr_unix_time_t fr_unix_time_from_integer(bool *overflow, int64_t integer, fr_time_res_t res)
static int8_t fr_unix_time_cmp(fr_unix_time_t a, fr_unix_time_t b)
Compare two fr_unix_time_t values.
static uint64_t fr_unix_time_unwrap(fr_unix_time_t time)
static int64_t fr_unix_time_to_integer(fr_unix_time_t delta, fr_time_res_t res)
const char fr_token_quote[T_TOKEN_LAST]
Convert tokens back to a quoting character.
@ T_SOLIDUS_QUOTED_STRING
void fr_strerror_clear(void)
Clears all pending messages from the talloc pools.
#define fr_strerror_printf(_fmt,...)
Log to thread local error buffer.
#define fr_strerror_const(_msg)
#define FR_TYPE_VARIABLE_SIZE
#define FR_TYPE_STRUCTURAL_EXCEPT_GROUP
#define fr_type_is_non_leaf(_x)
#define fr_type_is_group(_x)
#define fr_type_is_variable_size(_x)
#define fr_type_is_structural(_x)
#define fr_type_is_fixed_size(_x)
#define FR_TYPE_STRUCTURAL
#define fr_type_is_ip(_x)
#define FR_TYPE_INTEGER_EXCEPT_BOOL
#define fr_type_is_leaf(_x)
static char const * fr_type_to_str(fr_type_t type)
Return a static string containing the type name.
#define FR_TYPE_FIXED_SIZE
int fr_value_box_bstrndup_dbuff(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, fr_dbuff_t *dbuff, size_t len, bool tainted)
void fr_value_box_list_verify(char const *file, int line, fr_value_box_list_t const *list)
static void _fr_value_box_list_debug(fr_value_box_list_t const *head, int depth)
static void _fr_value_box_debug(fr_value_box_t const *vb, int depth, int idx)
void fr_value_box_memdup_buffer_shallow(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, uint8_t const *src, bool tainted)
Assign a talloced buffer to a box, but don't copy it.
size_t const fr_value_box_field_sizes[]
How many bytes wide each of the value data fields are.
fr_sbuff_escape_rules_t fr_value_escape_double
int fr_value_box_hton(fr_value_box_t *dst, fr_value_box_t const *src)
Performs byte order reversal for types that need it.
size_t fr_value_box_network_length(fr_value_box_t const *value)
Get the size of the value held by the fr_value_box_t.
int fr_value_box_vasprintf(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, bool tainted, char const *fmt, va_list ap)
Print a formatted string using our internal printf wrapper and assign it to a value box.
void fr_value_box_debug(fr_value_box_t const *vb)
Print the value of a box as info messages.
#define INFO_INDENT(_fmt,...)
void fr_value_box_mark_unsafe(fr_value_box_t *vb)
Mark a value-box as "unsafe".
ssize_t fr_value_box_list_concat_as_string(fr_value_box_t *safety, fr_sbuff_t *sbuff, fr_value_box_list_t *list, char const *sep, size_t sep_len, fr_sbuff_escape_rules_t const *e_rules, fr_value_box_list_action_t proc_action, fr_value_box_safe_for_t safe_for, bool flatten)
Concatenate a list of value boxes together.
fr_sbuff_escape_rules_t fr_value_escape_single
int fr_value_box_strtrim(TALLOC_CTX *ctx, fr_value_box_t *vb)
Trim the length of the string buffer to match the length of the C string.
uint32_t fr_value_box_hash(fr_value_box_t const *vb)
Hash the contents of a value box.
ssize_t fr_value_box_print(fr_sbuff_t *out, fr_value_box_t const *data, fr_sbuff_escape_rules_t const *e_rules)
Print one boxed value to a string.
fr_sbuff_parse_rules_t const value_parse_rules_single_3quoted
static fr_slen_t fr_value_box_from_numeric_substr(fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *rules, bool tainted)
Convert integer encoded as string to a fr_value_box_t type.
static int fr_value_box_cast_to_strvalue(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, fr_value_box_t const *src)
Convert any supported type to a string.
fr_sbuff_parse_rules_t const value_parse_rules_double_unquoted
char * fr_value_box_list_aprint_secure(TALLOC_CTX *ctx, fr_value_box_list_t const *list, char const *delim, fr_sbuff_escape_rules_t const *e_rules)
Concatenate the string representations of a list of value boxes together hiding "secret" values.
fr_sbuff_parse_rules_t const value_parse_rules_solidus_quoted
ssize_t fr_value_box_from_network(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t type, fr_dict_attr_t const *enumv, fr_dbuff_t *dbuff, size_t len, bool tainted)
Decode a fr_value_box_t from serialized binary data.
int fr_value_box_mem_alloc(TALLOC_CTX *ctx, uint8_t **out, fr_value_box_t *dst, fr_dict_attr_t const *enumv, size_t len, bool tainted)
Pre-allocate an octets buffer for filling by the caller.
int fr_value_box_memdup_buffer(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, uint8_t const *src, bool tainted)
Copy a talloced buffer to a fr_value_box_t.
#define network_min_size(_x)
Sanity checks.
int fr_value_box_bstrdup_buffer(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, bool tainted)
Copy a nul terminated talloced buffer to a fr_value_box_t.
int fr_value_box_cast(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, fr_value_box_t const *src)
Convert one type of fr_value_box_t to another.
int fr_value_box_asprintf(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, bool tainted, char const *fmt,...)
Print a formatted string using our internal printf wrapper and assign it to a value box.
fr_sbuff_parse_rules_t const * value_parse_rules_unquoted_char[UINT8_MAX]
fr_sbuff_parse_rules_t const * value_parse_rules_quoted[T_TOKEN_LAST]
Parse rules for quoted strings.
char * fr_value_box_list_aprint(TALLOC_CTX *ctx, fr_value_box_list_t const *list, char const *delim, fr_sbuff_escape_rules_t const *e_rules)
Concatenate the string representations of a list of value boxes together.
int fr_value_box_mem_realloc(TALLOC_CTX *ctx, uint8_t **out, fr_value_box_t *dst, size_t len)
Change the length of a buffer already allocated to a value box.
static size_t const fr_value_box_network_sizes[FR_TYPE_MAX+1][2]
static int fr_value_box_cast_to_float(UNUSED TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, fr_value_box_t const *src)
Convert any value to a floating point value.
int8_t fr_value_box_cmp(fr_value_box_t const *a, fr_value_box_t const *b)
Compare two values.
#define SIGN_BIT_HIGH(_int, _len)
size_t const fr_value_box_offsets[]
Where the value starts in the fr_value_box_t.
fr_sbuff_parse_rules_t const * value_parse_rules_quoted_char[UINT8_MAX]
#define CAST_IP_FIX_COMBO
void fr_value_box_list_untaint(fr_value_box_list_t *head)
Untaint every list member (and their children)
fr_sbuff_parse_rules_t const value_parse_rules_bareword_unquoted
Default formatting rules.
static int fr_value_box_cast_to_ipv4addr(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, fr_value_box_t const *src)
Convert any supported type to an IPv4 address.
int fr_value_box_copy(TALLOC_CTX *ctx, fr_value_box_t *dst, const fr_value_box_t *src)
Copy value data verbatim duplicating any buffers.
fr_sbuff_parse_rules_t const value_parse_rules_single_unquoted
int fr_value_box_cmp_op(fr_token_t op, fr_value_box_t const *a, fr_value_box_t const *b)
Compare two attributes using an operator.
int fr_value_box_list_escape_in_place(fr_value_box_list_t *list, fr_value_box_escape_t const *escape, void *uctx)
Escape a list of value boxes in place.
fr_sbuff_unescape_rules_t fr_value_unescape_solidus
bool fr_value_box_is_truthy(fr_value_box_t const *in)
Check truthiness of values.
int fr_value_box_cast_in_place(TALLOC_CTX *ctx, fr_value_box_t *vb, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv)
Convert one type of fr_value_box_t to another in place.
fr_sbuff_parse_rules_t const value_parse_rules_single_quoted
static uint8_t const v4_v6_map[]
v4 to v6 mapping prefix
fr_sbuff_unescape_rules_t * fr_value_unescape_by_char[UINT8_MAX+1]
void fr_value_box_list_debug(fr_value_box_list_t const *head)
Print a list of value boxes as info messages.
void fr_value_box_memdup_shallow(fr_value_box_t *dst, fr_dict_attr_t const *enumv, uint8_t const *src, size_t len, bool tainted)
Assign a buffer to a box, but don't copy it.
fr_sbuff_escape_rules_t fr_value_escape_solidus
void fr_value_box_copy_shallow(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_value_box_t const *src)
Perform a shallow copy of a value_box.
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)
ssize_t fr_value_box_list_concat_as_octets(fr_value_box_t *safety, fr_dbuff_t *dbuff, fr_value_box_list_t *list, uint8_t const *sep, size_t sep_len, fr_value_box_list_action_t proc_action, bool flatten)
Concatenate a list of value boxes together.
static int fr_value_box_cast_to_octets(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, fr_value_box_t const *src)
Convert any supported type to octets.
void fr_value_box_increment(fr_value_box_t *vb)
Increment a boxed value.
fr_sbuff_escape_rules_t * fr_value_escape_by_quote[T_TOKEN_LAST]
void _fr_value_box_mark_safe_for(fr_value_box_t *vb, fr_value_box_safe_for_t safe_for)
Mark a value-box as "safe", of a particular type.
size_t fr_value_str_unescape(fr_sbuff_t *out, fr_sbuff_t *in, size_t inlen, char quote)
Convert a string value with escape sequences into its binary form.
void fr_value_box_clear_value(fr_value_box_t *data)
Clear/free any existing value.
void fr_value_box_verify(char const *file, int line, fr_value_box_t const *vb)
Validation function to check that a fr_value_box_t is correctly initialised.
fr_sbuff_parse_rules_t const * value_parse_rules_3quoted[T_TOKEN_LAST]
int fr_value_box_strdup(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, bool tainted)
Copy a nul terminated string to a fr_value_box_t.
#define network_max_size(_x)
void fr_value_box_strdup_shallow_replace(fr_value_box_t *vb, char const *src, ssize_t len)
Free the existing buffer (if talloced) associated with the valuebox, and replace it with a new one.
ssize_t fr_value_box_print_quoted(fr_sbuff_t *out, fr_value_box_t const *data, fr_token_t quote)
Print one boxed value to a string with quotes (where needed)
fr_sbuff_parse_rules_t const value_parse_rules_double_3quoted
static int fr_value_box_cast_to_integer(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, fr_value_box_t const *src)
Convert any value to a signed or unsigned integer.
fr_sbuff_escape_rules_t fr_value_escape_unprintables
static int fr_value_box_cast_to_ipv6prefix(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, fr_value_box_t const *src)
Convert any supported type to an IPv6 address.
void fr_value_box_safety_copy_changed(fr_value_box_t *out, fr_value_box_t const *in)
Copy the safety values from one box to another.
fr_sbuff_escape_rules_t fr_value_escape_backtick
int fr_value_box_ipaddr(fr_value_box_t *dst, fr_dict_attr_t const *enumv, fr_ipaddr_t const *ipaddr, bool tainted)
Assign a fr_value_box_t value from an fr_ipaddr_t.
void fr_value_box_list_taint(fr_value_box_list_t *head)
Taint every list member (and their children)
static int fr_value_box_cidr_cmp_op(fr_token_t op, int bytes, uint8_t a_net, uint8_t const *a, uint8_t b_net, uint8_t const *b)
static void fr_value_box_copy_meta(fr_value_box_t *dst, fr_value_box_t const *src)
Copy flags and type data from one value box to another.
void fr_value_box_list_mark_safe_for(fr_value_box_list_t *list, fr_value_box_safe_for_t safe_for)
Set the escaped flag for all value boxes in a list.
fr_sbuff_escape_rules_t * fr_value_escape_by_char[UINT8_MAX+1]
static int fr_value_box_fixed_size_from_octets(fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, fr_value_box_t const *src)
Convert octets to a fixed size value box value.
static int fr_value_box_cast_to_bool(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, fr_value_box_t const *src)
Convert any supported type to a bool.
fr_sbuff_unescape_rules_t fr_value_unescape_backtick
int fr_value_unbox_ipaddr(fr_ipaddr_t *dst, fr_value_box_t *src)
Unbox an IP address performing a type check.
fr_sbuff_parse_rules_t const value_parse_rules_bareword_quoted
void fr_value_box_safety_merge(fr_value_box_t *out, fr_value_box_t const *in)
Merge safety results.
fr_sbuff_parse_rules_t const value_parse_rules_backtick_3quoted
static uint64_t const fr_value_box_integer_max[]
void fr_value_box_strdup_shallow(fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, bool tainted)
Assign a buffer containing a nul terminated string to a box, but don't copy it.
fr_sbuff_parse_rules_t const value_parse_rules_solidus_unquoted
fr_sbuff_parse_rules_t const value_parse_rules_backtick_quoted
fr_sbuff_parse_rules_t const * value_parse_rules_unquoted[T_TOKEN_LAST]
Parse rules for non-quoted strings.
static int fr_value_box_cast_to_ipv4prefix(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, fr_value_box_t const *src)
Convert any supported type to an IPv6 address.
static int fr_value_box_cast_to_ethernet(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, fr_value_box_t const *src)
Convert any supported type to an ethernet address.
fr_sbuff_unescape_rules_t fr_value_unescape_single
void fr_value_box_safety_copy(fr_value_box_t *out, fr_value_box_t const *in)
Copy the safety values from one box to another.
fr_sbuff_parse_rules_t const value_parse_rules_backtick_unquoted
fr_sbuff_parse_rules_t const value_parse_rules_double_quoted
int fr_value_box_bstr_alloc(TALLOC_CTX *ctx, char **out, fr_value_box_t *dst, fr_dict_attr_t const *enumv, size_t len, bool tainted)
Alloc and assign an empty \0 terminated string to a fr_value_box_t.
fr_sbuff_unescape_rules_t * fr_value_unescape_by_quote[T_TOKEN_LAST]
#define SIGN_PROMOTE(_int, _len)
fr_sbuff_parse_rules_t const value_parse_rules_solidus_3quoted
int fr_value_box_steal(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_value_box_t *src)
Copy value data verbatim moving any buffers to the specified context.
int fr_value_box_to_key(uint8_t **out, size_t *outlen, fr_value_box_t const *value)
Get a key from a value box.
void fr_value_box_flatten(TALLOC_CTX *ctx, fr_value_box_list_t *list, bool steal, bool free)
Removes a single layer of nesting, moving all children into the parent list.
int fr_value_box_list_acopy(TALLOC_CTX *ctx, fr_value_box_list_t *out, fr_value_box_list_t const *in)
Do a full copy of a list of value boxes.
void fr_value_box_clear(fr_value_box_t *data)
Clear/free any existing value and metadata.
bool fr_value_box_list_tainted(fr_value_box_list_t const *head)
Check to see if any list members (or their children) are tainted.
ssize_t fr_value_box_to_network(fr_dbuff_t *dbuff, fr_value_box_t const *value)
Encode a single value box, serializing its contents in generic network format.
static int64_t const fr_value_box_integer_min[]
int fr_value_box_bstr_realloc(TALLOC_CTX *ctx, char **out, fr_value_box_t *dst, size_t len)
Change the length of a buffer already allocated to a value box.
int fr_value_box_bstrndup(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, size_t len, bool tainted)
Copy a string to to a fr_value_box_t.
int fr_value_box_memdup_dbuff(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, fr_dbuff_t *dbuff, size_t len, bool tainted)
int fr_regex_cmp_op(fr_token_t op, fr_value_box_t const *a, fr_value_box_t const *b)
Compare two boxes using an operator.
fr_sbuff_unescape_rules_t fr_value_unescape_double
int fr_value_box_bstrdup_buffer_shallow(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, bool tainted)
Assign a talloced buffer containing a nul terminated string to a box, but don't copy it.
size_t fr_value_substr_unescape(fr_sbuff_t *out, fr_sbuff_t *in, size_t inlen, char quote)
Convert a string value with escape sequences into its binary form.
fr_sbuff_escape_rules_t fr_value_escape_secret
Escape secret fields by simply mashing all data to '.
ssize_t fr_value_box_from_substr(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *rules)
Convert string value to a fr_value_box_t type.
int fr_value_box_escape_in_place(fr_value_box_t *vb, fr_value_box_escape_t const *escape, void *uctx)
Escape a single value box in place.
void fr_value_box_bstrndup_shallow(fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, size_t len, bool tainted)
Assign a string to to a fr_value_box_t.
static int fr_value_box_cast_to_ipv6addr(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, fr_value_box_t const *src)
Convert any supported type to an IPv6 address.
int fr_value_box_memdup(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, uint8_t const *src, size_t len, bool tainted)
Copy a buffer to a fr_value_box_t.
static int fr_value_box_cast_integer_to_integer(UNUSED TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, fr_value_box_t const *src)
Convert any signed or unsigned integer type to any other signed or unsigned integer type.
int fr_value_box_list_concat_in_place(TALLOC_CTX *ctx, fr_value_box_t *out, fr_value_box_list_t *list, fr_type_t type, fr_value_box_list_action_t proc_action, bool flatten, size_t max_size)
Concatenate a list of value boxes.
fr_value_box_list_action_t
Actions to perform when we process a box in a list.
@ FR_VALUE_BOX_LIST_NONE
Do nothing to processed boxes.
@ FR_VALUE_BOX_LIST_REMOVE
Remove the box from the input list.
#define vb_should_free(_action)
#define fr_value_box_list_foreach_safe(_list_head, _iter)
#define vb_should_free_value(_action)
#define vb_should_remove(_action)
static int fr_value_box_memcpy_out(void *out, fr_value_box_t const *vb)
Copy the value of a value box to a field in a C struct.
static fr_slen_t fr_value_box_aprint(TALLOC_CTX *ctx, char **out, fr_value_box_t const *data, fr_sbuff_escape_rules_t const *e_rules) 1(fr_value_box_print
static bool fr_value_box_contains_secret(fr_value_box_t const *box)
#define FR_VALUE_BOX_NET_ERROR
Special value to indicate fr_value_box_from_network experienced a general error.
static uint8_t * fr_value_box_raw(fr_value_box_t const *vb, fr_type_t type)
Return a pointer to the "raw" value from a value-box.
#define fr_box_strvalue_len(_val, _len)
#define FR_VALUE_BOX_MAGIC
#define fr_value_box_init_null(_vb)
Initialise an empty/null box that will be filled later.
#define fr_value_box_is_safe_for(_box, _safe_for)
static size_t char fr_sbuff_t size_t inlen
fr_value_box_safe_for_t safe_for
#define FR_VALUE_BOX_SAFE_FOR_NONE
uintptr_t fr_value_box_safe_for_t
Escaping that's been applied to a value box.
#define fr_value_box_alloc_null(_ctx)
Allocate a value box for later use with a value assignment function.
fr_value_box_escape_func_t func
static always_inline int fr_value_box_ethernet_addr(fr_value_box_t *dst, fr_dict_attr_t const *enumv, fr_ethernet_t const *src, bool tainted)
#define fr_value_box_init(_vb, _type, _enumv, _tainted)
Initialise a fr_value_box_t.
#define fr_value_box_list_foreach(_list_head, _iter)
#define FR_VALUE_BOX_NET_OOM
Special value to indicate fr_value_box_from_network hit an out of memory error.
static size_t char ** out
#define FR_VALUE_BOX_SAFE_FOR_ANY