45RCSID(
"$Id: a6410f8f4ea9bbd476ef722bfc502b22dfe2f821 $")
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/size.h>
63 "in_addr.s_addr has unexpected length");
65 "in6_addr.s6_addr has unexpected length");
67 "vb_ifid has unexpected length");
69 "vb_ether has unexpected length");
72 "datum.boolean has unexpected length");
74 "vb_uint8 has unexpected length");
76 "vb_uint16 has unexpected length");
78 "vb_uint32 has unexpected length");
80 "vb_uint64 has unexpected length");
83 "vb_int16 has unexpected length");
85 "vb_int16 has unexpected length");
87 "vb_int32 has unexpected length");
89 "vb_int64 has unexpected length");
92 "vb_float32 has unexpected length");
94 "vb_float64 has unexpected length");
106#define network_min_size(_x) (fr_value_box_network_sizes[_x][0])
107#define network_max_size(_x) (fr_value_box_network_sizes[_x][1])
374#pragma clang diagnostic ignored "-Wgnu-designator"
457 .name =
"unprintables",
551 L(
""),
L(
"\n"),
L(
"\r"),
L(
"\""))
557 L(
""),
L(
"\n"),
L(
"\r"),
L(
"'"))
563 L(
""),
L(
"\n"),
L(
"\r"),
L(
"/"))
569 L(
""),
L(
"\n"),
L(
"\r"),
L(
"`"))
578 L(
""),
L(
"\n"),
L(
"\r"),
L(
"\"\"\""))
584 L(
""),
L(
"\n"),
L(
"\r"),
L(
"'''"))
590 L(
""),
L(
"\n"),
L(
"\r"),
L(
"///"))
596 L(
""),
L(
"\n"),
L(
"\r"),
L(
"```"))
643 dst->vb_length = src->vb_length;
652 fr_value_box_list_init(&dst->vb_group);
659 dst->enumv = src->enumv;
660 dst->type = src->type;
661 dst->tainted = src->tainted;
662 dst->safe_for = src->safe_for;
663 dst->secret = src->secret;
664 fr_value_box_list_entry_init(dst);
679 if (a == b)
return 0;
689 if ((fpclassify(a) == FP_ZERO) || (fpclassify(b) == FP_ZERO)) {
691 if (diff < DBL_EPSILON)
return 0;
699 sum = fabs(a) + fabs(b);
704 if (sum < DBL_MIN)
goto check;
709 if ((diff / fmin(sum, DBL_MAX)) < DBL_EPSILON)
return 0;
726 if (a->type != b->type) {
740 if (a->vb_length < b->vb_length) {
741 length = a->vb_length;
743 length = b->vb_length;
752 if (a->secret || b->secret) {
755 cmp = memcmp(a->datum.ptr, b->datum.ptr, length);
757 if (cmp != 0)
return CMP(cmp, 0);
766 return CMP(a->vb_length, b->vb_length);
772#define RETURN(_type) return CMP(a->datum._type, b->datum._type)
773#define COMPARE(_type) return CMP(memcmp(&a->datum._type, &b->datum._type, sizeof(a->datum._type)), 0)
812 return float_cmp(a->vb_float32, b->vb_float32);
815 return float_cmp(a->vb_float64, b->vb_float64);
835 return CMP(a->vb_attr, b->vb_attr);
868 if (a_net == b_net) {
871 compare = memcmp(a, b, bytes);
877 if ((compare == 0) &&
939 if (common == 0)
return true;
944 if (common < 8)
break;
946 if (a[i] != b[i])
return false;
954 mask <<= (8 - common);
958 if ((a[i] &
mask) == ((b[i] &
mask))) {
991 if (b->vb_ip.af != AF_INET)
goto fail_cmp_v4;
998 if (b->vb_ip.af != AF_INET)
goto fail_cmp_v4;
1003 b->vb_ip.prefix, (
uint8_t const *) &b->vb_ip.addr.v4.s_addr);
1015 if (b->vb_ip.af != AF_INET)
goto fail_cmp_v4;
1020 (
uint8_t const *) &a->vb_ip.addr.v4.s_addr,
1021 32, (
uint8_t const *) &b->vb_ip.addr.v4);
1024 if (b->vb_ip.af != AF_INET)
goto fail_cmp_v4;
1029 (
uint8_t const *) &a->vb_ip.addr.v4.s_addr,
1030 b->vb_ip.prefix, (
uint8_t const *) &b->vb_ip.addr.v4.s_addr);
1040 if (b->vb_ip.af != AF_INET6)
goto fail_cmp_v6;
1047 if (b->vb_ip.af != AF_INET6)
goto fail_cmp_v6;
1052 b->vb_ip.prefix, (
uint8_t const *) &b->vb_ip.addr.v6);
1064 if (b->vb_ip.af != AF_INET6)
goto fail_cmp_v6;
1069 (
uint8_t const *) &a->vb_ip.addr.v6,
1070 128, (
uint8_t const *) &b->vb_ip.addr.v6);
1073 if (b->vb_ip.af != AF_INET6)
goto fail_cmp_v6;
1078 (
uint8_t const *) &a->vb_ip.addr.v6,
1079 b->vb_ip.prefix, (
uint8_t const *) &b->vb_ip.addr.v6);
1087 if (a->vb_ip.af != b->vb_ip.af)
goto fail_cmp_v4;
1092 if (a->vb_ip.af != b->vb_ip.af)
goto fail_cmp_v4;
1094 if (a->vb_ip.af == AF_INET)
goto cmp_prefix_v4;
1111 return (compare == 0);
1114 return (compare != 0);
1117 return (compare < 0);
1120 return (compare > 0);
1123 return (compare <= 0);
1126 return (compare >= 0);
1282 switch (src->type) {
1324 switch (src->type) {
1326 dst->vb_uint16 = htons(src->vb_uint16);
1330 dst->vb_uint32 = htonl(src->vb_uint32);
1334 dst->vb_uint64 = htonll(src->vb_uint64);
1338 dst->vb_int16 = htons(src->vb_int16);
1342 dst->vb_int32 = htonl(src->vb_int32);
1346 dst->vb_int64 = htonll(src->vb_int64);
1358 dst->vb_float32 = htonl((
uint32_t)src->vb_float32);
1362 dst->vb_float64 = htonll((uint64_t)src->vb_float64);
1379 switch (
value->type) {
1385 if (
value->enumv->flags.length) {
1386 return value->enumv->flags.length;
1394 if (
value->vb_length > 255)
return 255;
1397 if (
value->vb_length > 65535)
return 65535;
1401 return value->vb_length;
1408 if (
value->enumv)
return value->enumv->flags.length;
1475 switch (
value->type) {
1478 max =
value->vb_length;
1485 if (
value->enumv->flags.length) {
1489 if (max < value->enumv->flags.length) {
1494 }
else if (max >
value->enumv->flags.length) {
1498 max =
value->enumv->flags.length;
1506 if (max > 255) max = 255;
1510 if (max > 65536) max = 65535;
1544 switch (
value->type) {
1549 sizeof(
value->vb_ip.addr.v4.s_addr));
1559 sizeof(
value->vb_ip.addr.v4.s_addr));
1580 switch (
value->vb_ip.af) {
1595 switch (
value->vb_ip.af) {
1647 if (
value->vb_attr->depth != 1) {
1649 value->vb_attr->depth,
value->vb_attr->name);
1653 switch (
value->vb_attr->flags.length) {
1656 base.vb_uint8 =
value->vb_attr->attr;
1661 base.vb_uint16 =
value->vb_attr->attr;
1666 base.vb_uint32 =
value->vb_attr->attr;
1671 value->vb_attr->flags.length,
value->vb_attr->name);
1692 if (!
value->enumv) {
1695 res =
value->enumv->flags.flag_time_res;
1699 if (!
value->enumv) {
1702 }
else switch (
value->enumv->flags.length) {
1704 if (date > UINT16_MAX) date = UINT16_MAX;
1710 if (date > UINT32_MAX) date = UINT32_MAX;
1729 if (
value->enumv) res =
value->enumv->flags.flag_time_res;
1733 if (!
value->enumv) {
1736 }
else if (!
value->enumv->flags.is_unsigned) {
1737 switch (
value->enumv->flags.length) {
1739 if (date < INT16_MIN) {
1741 }
else if (date > INT16_MAX) {
1749 if (date < INT32_MIN) {
1751 }
else if (date > INT32_MAX) {
1765 switch (
value->enumv->flags.length) {
1769 }
else if (date > UINT16_MAX) {
1778 }
else if (date > UINT32_MAX) {
1861 "Expected length >= %zu bytes, got %zu bytes",
1871 if (enumv && !enumv->flags.array) {
1873 "Expected length <= %zu bytes, got %zu bytes",
1886 size_t newlen = len;
1893 if (enumv->flags.length) {
1894 newlen = enumv->flags.length;
1925 if (newlen > len)
return -(newlen + offset);
1983 dst->vb_ip.scope_id = scope_id;
1999 dst->vb_ip.scope_id = scope_id;
2027 dst->datum.boolean = (val != 0);
2078 fr_strerror_const(
"No enumv (i.e. root) passed to fr_value_box_from_network for type 'attribute'");
2092 switch (enumv->flags.length) {
2114 if (!dst->vb_attr) {
2116 if (!dst->vb_attr)
return 0;
2136 length = enumv->flags.length;
2144 if (len > length)
return -(length);
2166 length = enumv->flags.length;
2174 if (len > length)
return -(length);
2178 if (!enumv || !enumv->flags.is_unsigned) {
2190 if (tmp > INT64_MAX) tmp = INT64_MAX;
2229 switch (
value->type) {
2231 if (*outlen < 8)
return -1;
2246 if (slen < 0)
return -1;
2255 *outlen =
value->vb_ip.prefix;
2261 *outlen =
value->vb_length * 8;
2266 *outlen =
sizeof(
value->vb_ether) * 8;
2297 "destination type size %zu",
2310 if (!src->vb_length)
return 0;
2312 ptr = (
uint8_t *) &dst->datum;
2325 memcpy(ptr, src->vb_octets, src->vb_length);
2336 0x00, 0x00, 0x00, 0x00, 0xff, 0xff };
2357 switch (src->type) {
2365 (
char const *)src->vb_octets, src->vb_length, src->tainted);
2369 dst,
UNCONST(fr_value_box_list_t *, &src->vb_group),
2409 switch (src->type) {
2416 (
uint8_t const *)src->vb_strvalue, src->vb_length, src->tainted);
2420 dst,
UNCONST(fr_value_box_list_t *, &src->vb_group),
2429 (
uint8_t const *)&src->vb_ip.addr.v4.s_addr,
2430 sizeof(src->vb_ip.addr.v4.s_addr), src->tainted);
2440 sizeof(src->vb_ip.addr.v4.s_addr) + 1, src->tainted) < 0)
return -1;
2442 bin[0] = src->vb_ip.prefix;
2443 memcpy(&bin[1], (
uint8_t const *)&src->vb_ip.addr.v4.s_addr,
sizeof(src->vb_ip.addr.v4.s_addr));
2452 (
uint8_t const *)src->vb_ip.addr.v6.s6_addr,
2453 sizeof(src->vb_ip.addr.v6.s6_addr), src->tainted);
2463 sizeof(src->vb_ip.addr.v6.s6_addr) + 2, src->tainted) < 0)
return -1;
2464 bin[0] = src->vb_ip.scope_id;
2465 bin[1] = src->vb_ip.prefix;
2466 memcpy(&bin[2], src->vb_ip.addr.v6.s6_addr,
sizeof(src->vb_ip.addr.v6.s6_addr));
2491#define CAST_IP_FIX_COMBO \
2492 case FR_TYPE_COMBO_IP_ADDR: \
2493 if (src->vb_ip.af == AF_INET) { \
2494 src_type = FR_TYPE_IPV4_ADDR; \
2495 } else if (src->vb_ip.af == AF_INET6) { \
2496 src_type = FR_TYPE_IPV6_ADDR; \
2499 case FR_TYPE_COMBO_IP_PREFIX: \
2500 if (src->vb_ip.af == AF_INET) { \
2501 src_type = FR_TYPE_IPV4_PREFIX; \
2502 } else if (src->vb_ip.af == AF_INET6) { \
2503 src_type = FR_TYPE_IPV6_PREFIX; \
2535 src->vb_strvalue, src->vb_length,
2548 dst->vb_ip.af = AF_INET;
2549 dst->vb_ip.prefix = 32;
2550 dst->vb_ip.scope_id = 0;
2562 memcpy(&dst->vb_ip.addr.v4, &src->vb_ip.addr.v6.s6_addr[
sizeof(
v4_v6_map)],
2563 sizeof(dst->vb_ip.addr.v4));
2568 if (src->vb_ip.prefix != 32) {
2570 "cast to IP address types",
2579 memcpy(&dst->vb_ip.addr.v4, &src->vb_ip.addr.v4,
sizeof(dst->vb_ip.addr.v4));
2583 if (src->vb_ip.prefix != 128) {
2584 fr_strerror_printf(
"Invalid cast from %s to %s. Only /128 (not /%i) prefixes may be "
2585 "cast to IP address types",
2591 if (memcmp(&src->vb_ip.addr.v6.s6_addr,
v4_v6_map,
sizeof(
v4_v6_map)) != 0)
goto bad_v6_prefix_map;
2592 memcpy(&dst->vb_ip.addr.v4, &src->vb_ip.addr.v6.s6_addr[
sizeof(
v4_v6_map)],
2593 sizeof(dst->vb_ip.addr.v4));
2597 if (src->vb_length !=
sizeof(dst->vb_ip.addr.v4.s_addr)) {
2598 fr_strerror_printf(
"Invalid cast from %s to %s. Needed octet string of length %zu, got %zu",
2601 sizeof(dst->vb_ip.addr.v4.s_addr), src->vb_length);
2604 memcpy(&dst->vb_ip.addr.v4, src->vb_octets,
sizeof(dst->vb_ip.addr.v4.s_addr));
2611 net = ntohl(src->vb_uint32);
2612 memcpy(&dst->vb_ip.addr.v4, (
uint8_t *)&net,
sizeof(dst->vb_ip.addr.v4.s_addr));
2652 src->vb_strvalue, src->vb_length,
2665 dst->vb_ip.af = AF_INET;
2666 dst->vb_ip.scope_id = 0;
2670 dst->vb_ip.prefix = src->vb_ip.prefix;
2674 memcpy(&dst->vb_ip, &src->vb_ip,
sizeof(dst->vb_ip));
2688 memcpy(&dst->vb_ip.addr.v4.s_addr, &src->vb_ip.addr.v6.s6_addr[
sizeof(
v4_v6_map)],
2689 sizeof(dst->vb_ip.addr.v4.s_addr));
2690 dst->vb_ip.prefix = 32;
2694 if (memcmp(src->vb_ip.addr.v6.s6_addr,
v4_v6_map,
sizeof(
v4_v6_map)) != 0)
goto bad_v6_prefix_map;
2696 if (src->vb_ip.prefix < (
sizeof(
v4_v6_map) << 3)) {
2697 fr_strerror_printf(
"Invalid cast from %s to %s. Expected prefix >= %u bits got %u bits",
2700 (
unsigned int)(
sizeof(
v4_v6_map) << 3), src->vb_ip.prefix);
2703 memcpy(&dst->vb_ip.addr.v4.s_addr, &src->vb_ip.addr.v6.s6_addr[
sizeof(
v4_v6_map)],
2704 sizeof(dst->vb_ip.addr.v4.s_addr));
2709 dst->vb_ip.prefix = src->vb_ip.prefix - (
sizeof(
v4_v6_map) << 3);
2713 if (src->vb_length !=
sizeof(dst->vb_ip.addr.v4.s_addr) + 1) {
2714 fr_strerror_printf(
"Invalid cast from %s to %s. Needed octet string of length %zu, got %zu",
2717 sizeof(dst->vb_ip.addr.v4.s_addr) + 1, src->vb_length);
2720 dst->vb_ip.prefix = src->vb_octets[0];
2721 memcpy(&dst->vb_ip.addr.v4, &src->vb_octets[1],
sizeof(dst->vb_ip.addr.v4.s_addr));
2728 net = ntohl(src->vb_uint32);
2729 memcpy(&dst->vb_ip.addr.v4, (
uint8_t *)&net,
sizeof(dst->vb_ip.addr.v4.s_addr));
2730 dst->vb_ip.prefix = 32;
2764 static_assert((
sizeof(
v4_v6_map) +
sizeof(src->vb_ip.addr.v4)) <=
2765 sizeof(src->vb_ip.addr.v6),
"IPv6 storage too small");
2773 src->vb_strvalue, src->vb_length,
2786 dst->vb_ip.af = AF_INET6;
2787 dst->vb_ip.prefix = 128;
2792 uint8_t *p = dst->vb_ip.addr.v6.s6_addr;
2797 memcpy(p, (
uint8_t const *)&src->vb_ip.addr.v4.s_addr,
sizeof(src->vb_ip.addr.v4.s_addr));
2798 dst->vb_ip.scope_id = 0;
2804 uint8_t *p = dst->vb_ip.addr.v6.s6_addr;
2806 if (src->vb_ip.prefix != 32) {
2808 "cast to IP address types",
2818 memcpy(p, (
uint8_t const *)&src->vb_ip.addr.v4.s_addr,
sizeof(src->vb_ip.addr.v4.s_addr));
2819 dst->vb_ip.scope_id = 0;
2824 if (src->vb_ip.prefix != 128) {
2825 fr_strerror_printf(
"Invalid cast from %s to %s. Only /128 (not /%i) prefixes may be "
2826 "cast to IP address types",
2835 memcpy(dst->vb_ip.addr.v6.s6_addr, src->vb_ip.addr.v6.s6_addr,
2836 sizeof(dst->vb_ip.addr.v6.s6_addr));
2837 dst->vb_ip.scope_id = src->vb_ip.scope_id;
2841 if (src->vb_length !=
sizeof(dst->vb_ip.addr.v6.s6_addr)) {
2842 fr_strerror_printf(
"Invalid cast from %s to %s. Needed octet string of length %zu, got %zu",
2845 sizeof(dst->vb_ip.addr.v6.s6_addr), src->vb_length);
2848 memcpy(&dst->vb_ip.addr.v6.s6_addr, src->vb_octets,
sizeof(dst->vb_ip.addr.v6.s6_addr));
2887 src->vb_strvalue, src->vb_length,
2900 dst->vb_ip.af = AF_INET6;
2905 uint8_t *p = dst->vb_ip.addr.v6.s6_addr;
2910 memcpy(p, (
uint8_t const *)&src->vb_ip.addr.v4.s_addr,
sizeof(src->vb_ip.addr.v4.s_addr));
2911 dst->vb_ip.prefix = 128;
2912 dst->vb_ip.scope_id = 0;
2918 uint8_t *p = dst->vb_ip.addr.v6.s6_addr;
2923 memcpy(p, (
uint8_t const *)&src->vb_ip.addr.v4.s_addr,
sizeof(src->vb_ip.addr.v4.s_addr));
2924 dst->vb_ip.prefix = (
sizeof(
v4_v6_map) << 3) + src->vb_ip.prefix;
2925 dst->vb_ip.scope_id = 0;
2930 dst->vb_ip.prefix = src->vb_ip.prefix;
2934 dst->vb_ip.prefix = 128;
2936 memcpy(dst->vb_ip.addr.v6.s6_addr, src->vb_ip.addr.v6.s6_addr,
2937 sizeof(dst->vb_ip.addr.v6.s6_addr));
2938 dst->vb_ip.scope_id = src->vb_ip.scope_id;
2942 if (src->vb_length != (
sizeof(dst->vb_ip.addr.v6.s6_addr) + 2)) {
2943 fr_strerror_printf(
"Invalid cast from %s to %s. Needed octet string of length %zu, got %zu",
2946 sizeof(dst->vb_ip.addr.v6.s6_addr) + 2, src->vb_length);
2949 dst->vb_ip.scope_id = src->vb_octets[0];
2950 dst->vb_ip.prefix = src->vb_octets[1];
2951 memcpy(&dst->vb_ip.addr.v6.s6_addr, src->vb_octets,
sizeof(dst->vb_ip.addr.v6.s6_addr));
2983 switch (src->type) {
2986 src->vb_strvalue, src->vb_length,
3001 switch (src->type) {
3010 if ((array[0] != 0) || (array[1] != 0))
return -1;
3012 memcpy(dst->vb_ether, &array[2], 6);
3044 switch (src->type) {
3047 src->vb_strvalue, src->vb_length,
3065 switch (src->type) {
3067 dst->vb_bool = (src->vb_int8 != 0);
3071 dst->vb_bool = (src->vb_uint8 != 0);
3075 dst->vb_bool = (src->vb_int16 != 0);
3079 dst->vb_bool = (src->vb_uint16 != 0);
3083 dst->vb_bool = (src->vb_int32 != 0);
3087 dst->vb_bool = (src->vb_uint32 != 0);
3091 dst->vb_bool = (src->vb_int64 != 0);
3095 dst->vb_bool = (src->vb_uint64 != 0);
3099 dst->vb_bool = (src->vb_size != 0);
3107 dst->vb_bool = (fpclassify(src->vb_float32) == FP_ZERO);
3111 dst->vb_bool = (fpclassify(src->vb_float64) == FP_ZERO);
3137#define SIGN_BIT_HIGH(_int, _len) ((((uint64_t)1) << (((_len) << 3) - 1)) & (_int))
3138#define SIGN_PROMOTE(_int, _len) ((_len) < sizeof(_int) ? \
3139 (_int) | (~((__typeof__(_int))0)) << ((_len) << 3) : (_int))
3141#if !defined(NDEBUG) || defined(STATIC_ANALYZER)
3147 "invalid source type len, expected > 0, got %zu",
3153 "Invalid cast from %s to %s. "
3154 "invalid source type len, expected <= %zu, got %zu",
3157 sizeof(uint64_t), len))
return -1;
3160 switch (src->type) {
3173 if (src->enumv) res = src->enumv->flags.flag_time_res;
3189 if (src->enumv) res = src->enumv->flags.flag_time_res;
3196#ifdef WORDS_BIGENDIAN
3197 memcpy(((
uint8_t *)&tmp) + (
sizeof(tmp) - len),
3214 if ((int64_t)tmp <
min) {
3216 "outside value range %"PRId64
"-%"PRIu64,
3225 "outside value range 0-%"PRIu64,
3238 if (dst->enumv) res = dst->enumv->flags.flag_time_res;
3252 if (dst->enumv) res = dst->enumv->flags.flag_time_res;
3263#ifdef WORDS_BIGENDIAN
3288 switch (src->type) {
3291 src->vb_strvalue, src->vb_length,
3319 memcpy(&tmp.vb_uint32, &src->vb_ip.addr.v4,
sizeof(tmp.vb_uint32));
3340 memcpy(((
uint8_t *)&tmp.vb_uint64) + (
sizeof(tmp.vb_uint64) -
sizeof(src->vb_ether)),
3341 &src->vb_ether,
sizeof(src->vb_ether));
3342#ifndef WORDS_BIGENDIAN
3382 dst->vb_uint8 = src->vb_float32;
3386 dst->vb_uint16 = src->vb_float32;
3390 dst->vb_uint32 = src->vb_float32;
3394 dst->vb_uint64 = src->vb_float32;
3398 dst->vb_int8 = src->vb_float32;
3402 dst->vb_int16 = src->vb_float32;
3406 dst->vb_int32 = src->vb_float32;
3410 dst->vb_int64 = src->vb_float32;
3414 dst->vb_size = src->vb_float32;
3420 sec = src->vb_float32;
3422 nsec = ((src->vb_float32 *
NSEC) - ((
float) sec));
3435 sec = src->vb_float32;
3437 nsec = ((src->vb_float32 * res) - ((
double) sec));
3441 if (fail)
goto overflow;
3457 dst->vb_uint8 = src->vb_float64;
3461 dst->vb_uint16 = src->vb_float64;
3465 dst->vb_uint32 = src->vb_float64;
3469 dst->vb_uint64 = src->vb_float64;
3473 dst->vb_int8 = src->vb_float64;
3477 dst->vb_int16 = src->vb_float64;
3481 dst->vb_int32 = src->vb_float64;
3485 dst->vb_int64 = src->vb_float64;
3489 dst->vb_size = src->vb_float64;
3495 sec = src->vb_float64;
3497 nsec = ((src->vb_float64 *
NSEC) - ((
double) sec));
3510 sec = src->vb_float64;
3512 nsec = ((src->vb_float64 * res) - ((
double) sec));
3516 if (fail)
goto overflow;
3550 switch (src->type) {
3553 num = (double) src->vb_float32;
3561 num = src->vb_float64;
3576 num = src->vb_int16;
3580 num = src->vb_int32;
3584 num = src->vb_int64;
3588 num = src->vb_uint8;
3592 num = src->vb_uint16;
3596 num = src->vb_uint32;
3600 num = src->vb_uint64;
3631 dst->vb_float32 = num;
3633 dst->vb_float64 = num;
3696 if (dst_type == src->type) {
3700 if (ret < 0)
return ret;
3702 dst->enumv = dst_enumv;
3758 dst->enumv = dst_enumv;
3774 if (when > INT64_MAX) {
3780 dst->enumv = dst_enumv;
3808 switch (src->vb_attr->flags.length) {
3811 dst->vb_uint8 = src->vb_attr->attr;
3816 dst->vb_uint16 = src->vb_attr->attr;
3821 dst->vb_uint32 = src->vb_attr->attr;
3826 src->vb_attr->flags.length, src->vb_attr->name);
3846 src->vb_strvalue, src->vb_length,
3853 fr_strerror_printf(
"Invalid cast from %s to %s. Source is length %zu is smaller than "
3854 "destination type size %zu",
3864 "destination type size %zu",
3879 tmp.type = dst_type;
3880 dst->enumv = dst_enumv;
3890 dst->enumv = dst_enumv;
3918 fr_value_box_entry_t entry = vb->entry;
3924 if (vb->type == dst_type) {
3925 vb->enumv = dst_enumv;
3973 switch (ipaddr->
af) {
3988 memcpy(&dst->vb_ip, ipaddr,
sizeof(dst->vb_ip));
4009 memcpy(dst, &src->vb_ip,
sizeof(*dst));
4022 switch (
data->type) {
4039 while ((vb = fr_value_box_list_next(&
data->vb_group, vb))) {
4057 memset(&
data->datum, 0,
sizeof(
data->datum));
4085 switch (src->type) {
4107 dst->vb_strvalue = str;
4116 if (src->vb_length) {
4117 bin = talloc_memdup(ctx, src->vb_octets, src->vb_length);
4122 talloc_set_type(bin,
uint8_t);
4124 bin = talloc_array(ctx,
uint8_t, 0);
4126 dst->vb_octets = bin;
4137 while ((child = fr_value_box_list_next(&src->vb_group, child))) {
4147 fr_value_box_list_talloc_free(&dst->vb_group);
4158 fr_value_box_list_insert_tail(&dst->vb_group,
new);
4188 switch (src->type) {
4195 dst->datum.ptr = ctx ? talloc_reference(ctx, src->datum.ptr) : src->datum.ptr;
4212 switch (src->type) {
4220 str = talloc_steal(ctx, src->vb_strvalue);
4225 talloc_set_type(str,
char);
4226 dst->vb_strvalue = str;
4228 memset(&src->datum, 0,
sizeof(src->datum));
4236 bin = talloc_steal(ctx, src->vb_octets);
4241 talloc_set_type(bin,
uint8_t);
4243 dst->vb_octets = bin;
4245 memset(&src->datum, 0,
sizeof(src->datum));
4253 while ((child = fr_value_box_list_pop_head(&src->vb_group))) {
4254 child = talloc_steal(ctx, child);
4259 fr_value_box_list_insert_tail(&dst->vb_group, child);
4278 char const *src,
bool tainted)
4289 dst->vb_strvalue = str;
4290 dst->vb_length = talloc_array_length(str) - 1;
4310 len = strlen(vb->vb_strvalue);
4311 str = talloc_realloc(ctx,
UNCONST(
char *, vb->vb_strvalue),
char, len + 1);
4316 vb->vb_length = len;
4334 char const *
fmt, va_list ap)
4343 if (!str)
return -1;
4346 dst->vb_strvalue = str;
4347 dst->vb_length = talloc_array_length(str) - 1;
4365 char const *
fmt, ...)
4387 char const *src,
bool tainted)
4390 dst->vb_strvalue = src;
4391 dst->vb_length = strlen(src);
4405 vb->vb_strvalue = src;
4406 vb->vb_length = len < 0 ? strlen(src) : (
size_t)len;
4422 size_t len,
bool tainted)
4426 str = talloc_zero_array(ctx,
char, len + 1);
4434 dst->vb_strvalue = str;
4435 dst->vb_length = len;
4462 memcpy(&cstr, &dst->vb_strvalue,
sizeof(cstr));
4464 clen = talloc_array_length(dst->vb_strvalue) - 1;
4465 if (clen == len)
return 0;
4467 str = talloc_realloc(ctx, cstr,
char, len + 1);
4477 memset(str + clen,
'\0', (len - clen) + 1);
4481 dst->vb_strvalue = str;
4482 dst->vb_length = len;
4499 char const *src,
size_t len,
bool tainted)
4516 dst->vb_strvalue = str;
4517 dst->vb_length = len;
4527 str = talloc_array(ctx,
char, len + 1);
4537 dst->vb_strvalue = str;
4538 dst->vb_length = len;
4559 char const *src,
bool tainted)
4565 len = talloc_array_length(src);
4566 if ((len == 0) || (src[len - 1] !=
'\0')) {
4583 char const *src,
size_t len,
bool tainted)
4586 dst->vb_strvalue = src;
4587 dst->vb_length = len;
4604 char const *src,
bool tainted)
4610 len = talloc_array_length(src);
4611 if ((len == 0) || (src[len - 1] !=
'\0')) {
4617 dst->vb_strvalue = ctx ? talloc_reference(ctx, src) : src;
4618 dst->vb_length = len - 1;
4643 size_t len,
bool tainted)
4647 bin = talloc_array(ctx,
uint8_t, len);
4652 talloc_set_type(bin,
uint8_t);
4655 dst->vb_octets = bin;
4656 dst->vb_length = len;
4683 memcpy(&cbin, &dst->vb_octets,
sizeof(cbin));
4685 clen = talloc_array_length(dst->vb_octets);
4686 if (clen == len)
return 0;
4694 bin = talloc_realloc(ctx, cbin,
uint8_t, len);
4696 bin = talloc_array(ctx,
uint8_t, 0);
4712 if (clen < len) memset(bin + clen, 0x00, len - clen);
4713 dst->vb_octets = bin;
4714 dst->vb_length = len;
4740 uint8_t const *src,
size_t len,
bool tainted)
4750 bin = talloc_memdup(ctx, src, len);
4755 talloc_set_type(bin,
uint8_t);
4758 dst->vb_octets = bin;
4759 dst->vb_length = len;
4769 bin = talloc_size(ctx, len);
4775 talloc_set_type(bin,
uint8_t);
4778 dst->vb_octets = bin;
4779 dst->vb_length = len;
4798 uint8_t const *src,
bool tainted)
4820 uint8_t const *src,
size_t len,
bool tainted)
4823 dst->vb_octets = src;
4824 dst->vb_length = len;
4838 uint8_t const *src,
bool tainted)
4843 dst->vb_octets = ctx ? talloc_reference(ctx, src) : src;
4844 dst->vb_length = talloc_array_length(src);
4855 dst->vb_cursor = cursor;
4856 dst->vb_cursor_name =
name;
4869 vb->vb_uint8 = vb->vb_uint8 ==
UINT8_MAX ? 0 : vb->vb_uint8 + 1;
4873 vb->vb_uint16 = vb->vb_uint16 == UINT16_MAX ? 0 : vb->vb_uint16 + 1;
4877 vb->vb_uint32 = vb->vb_uint32 == UINT32_MAX ? 0 : vb->vb_uint32 + 1;
4881 vb->vb_uint64 = vb->vb_uint64 == UINT64_MAX ? 0 : vb->vb_uint64 + 1;
4885 vb->vb_int8 = vb->vb_int8 == INT8_MAX ? INT8_MIN : vb->vb_int8 + 1;
4889 vb->vb_int16 = vb->vb_int16 == INT16_MAX ? INT16_MIN : vb->vb_int16 + 1;
4893 vb->vb_int32 = vb->vb_int32 == INT32_MAX ? INT32_MIN : vb->vb_int32 + 1;
4897 vb->vb_int64 = vb->vb_int64 == INT64_MAX ? INT64_MIN : vb->vb_int64 + 1;
4917static inline CC_HINT(always_inline)
4920 fr_sbuff_t *
in, fr_sbuff_parse_rules_t const *rules,
bool tainted)
4986 rules->escapes ? rules->escapes->chr :
'\0');
4998 fr_sbuff_parse_error_to_strerror(
err);
5022 static fr_sbuff_parse_rules_t default_rules;
5029 if (!rules) rules = &default_rules;
5036 if (dst_enumv && dst_enumv->flags.has_value && (dst_type !=
FR_TYPE_ATTR)) {
5053 if (!rules->escapes) {
5057 fr_sbuff_marker(&m, &our_in);
5062 fr_sbuff_marker_release(&m);
5064 if (!len)
goto parse;
5098 rules->terminals, rules->escapes);
5100 fr_sbuff_set_to_start(&our_in);
5106 fr_sbuff_set_to_start(&our_in);
5129 if (!dst_enumv || !unescaped) {
5132 if (
unlikely(fr_sbuff_out_aunescape_until(ctx, &
buff, &our_in, SIZE_MAX,
5133 rules->terminals, rules->escapes) < 0)) {
5159 if (!dst_enumv || !unescaped) {
5164 fr_sbuff_out_aunescape_until(ctx, &
buff, &our_in, SIZE_MAX,
5165 rules->terminals, rules->escapes);
5167 if (talloc_array_length(
buff) == 1) {
5172 bin = talloc_realloc(ctx,
buff,
uint8_t, talloc_array_length(
buff) - 1);
5178 talloc_set_type(bin,
uint8_t);
5189 bin = talloc_zero_array(ctx,
uint8_t, 0);
5204 fr_sbuff_marker(&hex_start, &our_in);
5221 if ((hex_len & 0x01) != 0) {
5247 if (!name_len)
return 0;
5259 "for non-prefix types", addr.
prefix);
5263 memcpy(&dst->vb_ip, &addr,
sizeof(dst->vb_ip));
5270 if (!name_len)
return 0;
5280 if (!name_len)
return 0;
5296 if (addr.
prefix != 128) {
5299 "for non-prefix types", addr.
prefix);
5303 memcpy(&dst->vb_ip, &addr,
sizeof(dst->vb_ip));
5310 if (!name_len)
return 0;
5320 if (!name_len)
return 0;
5332 if ((addr.
af == AF_INET) && (addr.
prefix != 32)) {
5333 goto fail_ipv4_prefix;
5336 if ((addr.
af == AF_INET6) && (addr.
prefix != 128)) {
5337 goto fail_ipv6_prefix;
5340 memcpy(&dst->vb_ip, &addr,
sizeof(dst->vb_ip));
5347 if (!name_len)
return 0;
5377 if (slen >= 0)
return slen;
5383 if (!rules->escapes) {
5389 dst->vb_bool = (stmp != 0);
5395 dst->vb_bool = (utmp != 0);
5401 "\"yes\", \"no\", \"true\", \"false\" or any unquoted integer");
5441 fr_sbuff_set_to_start(&our_in);
5446 fr_sbuff_parse_error_to_strerror(
err);
5489 false, rules->terminals);
5490 if (slen < 0)
return slen;
5515 }
else if (!dst_enumv->flags.is_root) {
5516 fr_strerror_printf(
"Can only start from dictionary root for data type 'attr', and not from %s", dst_enumv->name);
5550 if (rules && rules->terminals) {
5554 rules->terminals, rules->escapes);
5555 if (len >=
sizeof(
buffer))
goto too_small;
5586 dst->enumv = dst_enumv;
5603 dst->type = dst_type;
5604 dst->tainted =
false;
5610 dst->enumv = dst_enumv;
5611 fr_value_box_list_entry_init(dst);
5622 fr_sbuff_parse_rules_t prules = { .escapes = erules };
5625 if (slen <= 0)
return slen;
5628 fr_strerror_printf(
"Failed parsing '%s'. %zu bytes of trailing data after string value \"%pV\"",
5632 return (slen -
inlen) - 1;
5659 if (
data->enumv &&
data->enumv->flags.has_value) {
5669 switch (
data->type) {
5672 data->vb_strvalue,
data->vb_length, e_rules);
5709 data->vb_ether[0],
data->vb_ether[1],
5710 data->vb_ether[2],
data->vb_ether[3],
5711 data->vb_ether[4],
data->vb_ether[5]);
5762 if (
data->enumv) res =
data->enumv->flags.flag_time_res;
5775 bool is_unsigned =
false;
5778 res =
data->enumv->flags.flag_time_res;
5779 is_unsigned =
data->enumv->flags.is_unsigned;
5795 if (!e_rules || (!e_rules->do_oct && !e_rules->do_hex)) {
5806 NULL, &our_out,
UNCONST(fr_value_box_list_t *, &
data->vb_group),
5807 ", ", (
sizeof(
", ") - 1), e_rules,
5882 switch (
data->type) {
5926 if (fr_value_box_list_empty(list))
return 0;
5933 if (!flatten)
goto print;
5935 sep, sep_len, e_rules,
5936 proc_action, safe_for, flatten);
5945 box_safe_for = safe_for;
5947 slen =
fr_sbuff_in_escape(&our_sbuff, (
char const *)vb->vb_strvalue, vb->vb_length, e_rules);
5967 if (e_rules) box_safe_for = safe_for;
5971 if (slen < 0)
return slen;
5976 if (sep && fr_value_box_list_next(list, vb)) {
5978 if (slen < 0)
return slen;
5990 (safety->safe_for != box_safe_for)) {
5992 safety->safe_for = box_safe_for;
5998 safety->tainted |= vb->tainted;
5999 safety->secret |= vb->secret;
6036 uint8_t const *sep,
size_t sep_len,
6040 TALLOC_CTX *tmp_ctx = NULL;
6043 if (fr_value_box_list_empty(list))
return 0;
6048 if (!flatten)
goto cast;
6051 proc_action, flatten);
6070 if (!tmp_ctx) tmp_ctx = talloc_pool(NULL, 1024);
6092 if (sep && fr_value_box_list_next(list, vb)) {
6094 if (slen < 0)
goto error;
6141 fr_dbuff_uctx_talloc_t dbuff_tctx;
6148 fr_value_box_entry_t entry;
6150 if (fr_value_box_list_empty(list)) {
6159 if ((fr_value_box_list_num_elements(list) == 1) && (head_vb ==
out) && (head_vb->type ==
type))
return 0;
6163 if (
unlikely(!fr_sbuff_init_talloc(ctx, &sbuff, &sbuff_tctx, 256, max_size)))
return -1;
6185 if (
out == head_vb) {
6222 fr_value_box_list_insert_head(list, head_vb);
6237 proc_action, flatten) < 0) {
6238 fr_value_box_list_insert_head(list, head_vb);
6250 fr_value_box_list_insert_head(list,
out);
6276 proc_action, flatten) < 0)
goto error;
6329 ret = escape->
func(vb, uctx);
6335 if (!ret) vb->safe_for = escape->
safe_for;
6336 vb->tainted =
false;
6380 fr_value_box_list_remove(&child->vb_group, grandchild);
6381 if (steal) talloc_steal(ctx, grandchild);
6382 fr_value_box_list_insert_before(list, child, grandchild);
6403 char *aggr, *td = NULL;
6404 TALLOC_CTX *pool = NULL;
6406 if (!vb)
return NULL;
6409 if (!aggr)
return NULL;
6410 if (!fr_value_box_list_next(list, vb))
return aggr;
6416 pool = talloc_pool(NULL, 255);
6419 while ((vb = fr_value_box_list_next(list, vb))) {
6420 char *str, *new_aggr;
6453 char *aggr, *td = NULL;
6454 TALLOC_CTX *pool = NULL;
6456 if (!vb)
return NULL;
6463 if (!aggr)
return NULL;
6464 if (!fr_value_box_list_next(list, vb))
return aggr;
6470 pool = talloc_pool(NULL, 255);
6473 while ((vb = fr_value_box_list_next(list, vb))) {
6474 char *str, *new_aggr;
6508 return fr_hash(vb->vb_strvalue, vb->vb_length);
6511 return fr_hash(vb->vb_octets, vb->vb_length);
6533 while ((in_p = fr_value_box_list_next(
in, in_p))) {
6539 fr_value_box_list_talloc_free(
out);
6561 while ((vb = fr_value_box_list_next(
head, vb))) {
6563 if (vb->tainted)
return true;
6577 while ((vb = fr_value_box_list_next(
head, vb))) {
6592 while ((vb = fr_value_box_list_next(
head, vb))) {
6594 vb->tainted =
false;
6620 fr_fatal_assert_msg(vb->vb_strvalue,
"CONSISTENCY CHECK FAILED %s[%d]: fr_value_box_t strvalue field "
6623 "CONSISTENCY CHECK FAILED %s[%i]: fr_value_box_t strvalue field "
6624 "not null terminated",
file,
line);
6626 size_t len = talloc_array_length(vb->vb_strvalue);
6630 fr_fatal_assert_fail(
"CONSISTENCY CHECK FAILED %s[%d]: Expected fr_value_box_t->vb_strvalue talloc buffer "
6631 "len >= %zu, got %zu",
6632 file,
line, vb->vb_length + 1, len);
6638 fr_fatal_assert_msg(vb->vb_octets,
"CONSISTENCY CHECK FAILED %s[%d]: fr_value_box_t octets field "
6643 fr_fatal_assert_msg(vb->vb_void,
"CONSISTENCY CHECK FAILED %s[%d]: fr_value_box_t ptr field "
6652 if (vb->vb_attr)
break;
6654 fr_fatal_assert_msg(vb->vb_void,
"CONSISTENCY CHECK FAILED %s[%d]: fr_value_box_t vb_attr field "
6683 vb->safe_for = safe_for;
6712 vb->safe_for = safe_for;
6722 if (
out ==
in)
return;
6724 out->safe_for =
in->safe_for;
6725 out->tainted =
in->tainted;
6726 out->secret =
in->secret;
6736 out->tainted =
in->tainted;
6737 out->secret =
in->secret;
6744 if (
out ==
in)
return;
6752 (
out->safe_for !=
in->safe_for)) {
6760 out->safe_for =
in->safe_for;
6767 out->tainted |=
in->tainted;
6768 out->secret |=
in->secret;
6790 return (fr_value_box_list_num_elements(&
in->vb_group) > 0);
6797 return (
in->vb_length > 0);
6814#define INFO_INDENT(_fmt, ...) FR_FAULT_LOG("%*s"_fmt, depth * 2, " ", ## __VA_ARGS__)
6860 vb->secret ?
"s" :
"-",
6861 vb->tainted ?
"t" :
"-",
6866 vb->secret ?
"s" :
"-",
6867 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...
fr_slen_t fr_dict_attr_by_oid_substr(fr_dict_attr_err_t *err, fr_dict_attr_t const **out, fr_dict_attr_t const *parent, fr_sbuff_t *in, fr_sbuff_term_t const *tt))
Resolve an attribute using an OID string.
static fr_dict_attr_t * fr_dict_attr_unknown_raw_afrom_num(TALLOC_CTX *ctx, fr_dict_attr_t const *parent, unsigned int attr)
fr_dict_attr_t const * fr_dict_root(fr_dict_t const *dict)
Return the root attribute of a dictionary.
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).
@ FLAG_LENGTH_UINT8
string / octets type is prefixed by uint8 of length
@ FLAG_LENGTH_UINT16
string / octets type is prefixed by uint16 of length
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.
#define da_is_length_field(_da)
fr_slen_t fr_dict_attr_unknown_afrom_oid_substr(TALLOC_CTX *ctx, fr_dict_attr_t const **out, fr_dict_attr_t const *parent, fr_sbuff_t *in, fr_type_t type))
Create a fr_dict_attr_t from an ASCII attribute and value.
#define FR_DICT_ATTR_OID_PRINT_RETURN(...)
fr_dict_attr_t const * fr_dict_attr_child_by_num(fr_dict_attr_t const *parent, unsigned int attr)
Check if a child attribute exists in a parent using an attribute number.
fr_dict_enum_value_t const * fr_dict_enum_by_name(fr_dict_attr_t const *da, char const *name, ssize_t len)
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]
PUBLIC int snprintf(char *string, size_t length, char *format, va_alist)
fr_aka_sim_id_type_t type
#define fr_table_str_by_value(_table, _number, _def)
Convert an integer to a string.
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_table_num_ordered_t const fr_time_precision_table[]
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 fr_unix_time_t fr_unix_time_from_nsec(int64_t nsec)
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)
@ FR_TYPE_VALUE_BOX_CURSOR
cursor over a fr_value_box_t
@ FR_TYPE_ATTR
A contains an attribute reference.
@ FR_TYPE_PAIR_CURSOR
cursor over a fr_pair_t
#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
void fr_value_box_set_cursor(fr_value_box_t *dst, fr_type_t type, void *cursor, char const *name)
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.
static int8_t float_cmp(double a, double b)
Compare two floating point numbers for equality.
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