_p, (_mismatch_char) 0), \
char const *** : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_STRING) && ((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_char_m) 0), \
- bool * : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_BOOLEAN) && !((_t) & FR_TYPE_MULTI), \
+ bool * : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_BOOL) && !((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_bool) 0), \
- bool ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_BOOLEAN) && ((_t) & FR_TYPE_MULTI), \
+ bool ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_BOOL) && ((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_bool_m) 0), \
- uint32_t * : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_INTEGER) && !((_t) & FR_TYPE_MULTI), \
+ uint32_t * : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_UINT32) && !((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_uint32) 0), \
- uint32_t ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_INTEGER) && ((_t) & FR_TYPE_MULTI), \
+ uint32_t ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_UINT32) && ((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_uint32_m) 0), \
fr_ipaddr_t * : __builtin_choose_expr(((PW_BASE_TYPE(_t) == FR_TYPE_IPV4_ADDR) || \
(PW_BASE_TYPE(_t) == FR_TYPE_IPV4_PREFIX) || \
_p, (_mismatch_uint8) 0), \
uint8_t const **: __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_OCTETS) && ((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_uint8_m) 0), \
- uint8_t * : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_BYTE) && !((_t) & FR_TYPE_MULTI), \
+ uint8_t * : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_UINT8) && !((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_uint8) 0), \
- uint8_t ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_BYTE) && ((_t) & FR_TYPE_MULTI), \
+ uint8_t ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_UINT8) && ((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_uint8_m) 0), \
uint8_t[8] : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_IFID) && !(_t & FR_TYPE_MULTI), \
_p, (_mismatch_ifid) 0), \
uint8_t*[8] : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_IFID) && ((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_ifid_m) 0), \
- uint16_t * : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_SHORT) && !((_t) & FR_TYPE_MULTI), \
+ uint16_t * : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_UINT16) && !((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_uint16) 0), \
- uint16_t ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_SHORT) && ((_t) & FR_TYPE_MULTI), \
+ uint16_t ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_UINT16) && ((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_uint16_m) 0), \
uint8_t[6] : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_ETHERNET) && !((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_ethernet) 0), \
uint8_t*[6] : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_ETHERNET) && ((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_ethernet_m) 0), \
- int32_t * : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_SIGNED) && !((_t) & FR_TYPE_MULTI), \
+ int32_t * : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_INT32) && !((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_int32) 0), \
- int32_t ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_SIGNED) && ((_t) & FR_TYPE_MULTI), \
+ int32_t ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_INT32) && ((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_int32_m) 0), \
- uint64_t * : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_INTEGER64) && !((_t) & FR_TYPE_MULTI), \
+ uint64_t * : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_UINT64) && !((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_uint64) 0), \
- uint64_t ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_INTEGER64) && ((_t) & FR_TYPE_MULTI), \
+ uint64_t ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_UINT64) && ((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_uint64_m) 0), \
_timeval_t * : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_TIMEVAL) && !((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_timeval) 0), \
char const **: FR_TYPE_STRING, \
uint8_t **: FR_TYPE_OCTETS, \
uint8_t const **: FR_TYPE_OCTETS, \
- uint8_t *: FR_TYPE_BYTE, \
- uint16_t *: FR_TYPE_SHORT, \
- uint32_t *: FR_TYPE_INTEGER, \
- uint64_t *: FR_TYPE_INTEGER64, \
+ uint8_t *: FR_TYPE_UINT8, \
+ uint16_t *: FR_TYPE_UINT16, \
+ uint32_t *: FR_TYPE_UINT32, \
+ uint64_t *: FR_TYPE_UINT64, \
struct timeval *: FR_TYPE_TIMEVAL)
/** Expand a tmpl to a C type, using existing storage to hold variably sized types
FR_TYPE_COMBO_IP_PREFIX, //!< IPv4 or IPv6 address prefix depending on length.
FR_TYPE_ETHERNET, //!< 48 Bit Mac-Address.
- FR_TYPE_BOOLEAN, //!< A truth value.
- FR_TYPE_BYTE, //!< 8 Bit unsigned integer.
- FR_TYPE_SHORT, //!< 16 Bit unsigned integer.
- FR_TYPE_INTEGER, //!< 32 Bit unsigned integer.
- FR_TYPE_INTEGER64, //!< 64 Bit unsigned integer.
+ FR_TYPE_BOOL, //!< A truth value.
+ FR_TYPE_UINT8, //!< 8 Bit unsigned integer.
+ FR_TYPE_UINT16, //!< 16 Bit unsigned integer.
+ FR_TYPE_UINT32, //!< 32 Bit unsigned integer.
+ FR_TYPE_UINT64, //!< 64 Bit unsigned integer.
+ FR_TYPE_INT32, //!< 32 Bit signed integer.
+ FR_TYPE_FLOAT64, //!< Double precision floating point.
+
FR_TYPE_SIZE, //!< Unsigned integer capable of representing any memory
//!< address on the local system.
- FR_TYPE_SIGNED, //!< 32 Bit signed integer.
FR_TYPE_TIMEVAL, //!< Time value (struct timeval), only for config items.
- FR_TYPE_DECIMAL, //!< Double precision floating point.
FR_TYPE_DATE, //!< 32 Bit Unix timestamp.
FR_TYPE_ABINARY, //!< Ascend binary format a packed data structure.
* functions that need to deal with all types representing values
*/
#define FR_TYPE_FIXED_SIZE \
- FR_TYPE_BYTE: \
- case FR_TYPE_SHORT: \
- case FR_TYPE_INTEGER: \
- case FR_TYPE_INTEGER64: \
+ FR_TYPE_UINT8: \
+ case FR_TYPE_UINT16: \
+ case FR_TYPE_UINT32: \
+ case FR_TYPE_UINT64: \
case FR_TYPE_SIZE: \
case FR_TYPE_DATE: \
case FR_TYPE_IFID: \
case FR_TYPE_IPV6_PREFIX: \
case FR_TYPE_COMBO_IP_ADDR: \
case FR_TYPE_COMBO_IP_PREFIX: \
- case FR_TYPE_SIGNED: \
+ case FR_TYPE_INT32: \
case FR_TYPE_TIMEVAL: \
- case FR_TYPE_BOOLEAN: \
- case FR_TYPE_DECIMAL
+ case FR_TYPE_BOOL: \
+ case FR_TYPE_FLOAT64
/** Match all variable length types in case statements
*
*
*/
#define FR_TYPE_NUMERIC \
- FR_TYPE_BOOLEAN: \
- case FR_TYPE_BYTE: \
- case FR_TYPE_SHORT: \
- case FR_TYPE_INTEGER: \
- case FR_TYPE_INTEGER64: \
+ FR_TYPE_BOOL: \
+ case FR_TYPE_UINT8: \
+ case FR_TYPE_UINT16: \
+ case FR_TYPE_UINT32: \
+ case FR_TYPE_UINT64: \
case FR_TYPE_SIZE: \
- case FR_TYPE_SIGNED: \
+ case FR_TYPE_INT32: \
case FR_TYPE_DATE
#endif /* _FR_TYPES_H */
{ "combo-prefix", FR_TYPE_COMBO_IP_PREFIX },
{ "ether", FR_TYPE_ETHERNET },
- { "bool", FR_TYPE_BOOLEAN },
- { "byte", FR_TYPE_BYTE },
- { "short", FR_TYPE_SHORT },
- { "integer", FR_TYPE_INTEGER },
- { "integer64", FR_TYPE_INTEGER64 },
+ { "bool", FR_TYPE_BOOL },
+ { "byte", FR_TYPE_UINT8 },
+ { "short", FR_TYPE_UINT16 },
+ { "integer", FR_TYPE_UINT32 },
+ { "integer64", FR_TYPE_UINT64 },
{ "size", FR_TYPE_SIZE },
- { "signed", FR_TYPE_SIGNED },
+ { "signed", FR_TYPE_INT32 },
- { "decimal", FR_TYPE_DECIMAL },
+ { "decimal", FR_TYPE_FLOAT64 },
{ "timeval", FR_TYPE_TIMEVAL },
{ "date", FR_TYPE_DATE },
* Alternative names
*/
{ "cidr", FR_TYPE_IPV4_PREFIX },
- { "uint8", FR_TYPE_BYTE },
- { "uint16", FR_TYPE_SHORT },
- { "uint32", FR_TYPE_INTEGER },
- { "uint64", FR_TYPE_INTEGER64 },
- { "int32", FR_TYPE_SIGNED },
+ { "uint8", FR_TYPE_UINT8 },
+ { "uint16", FR_TYPE_UINT16 },
+ { "uint32", FR_TYPE_UINT32 },
+ { "uint64", FR_TYPE_UINT64 },
+ { "int32", FR_TYPE_INT32 },
{ NULL, 0 }
};
[FR_TYPE_IFID] = {8, 8},
[FR_TYPE_ETHERNET] = {6, 6},
- [FR_TYPE_BOOLEAN] = {1, 1},
- [FR_TYPE_BYTE] = {1, 1},
- [FR_TYPE_SHORT] = {2, 2},
- [FR_TYPE_INTEGER] = {4, 4},
- [FR_TYPE_INTEGER64] = {8, 8},
+ [FR_TYPE_BOOL] = {1, 1},
+ [FR_TYPE_UINT8] = {1, 1},
+ [FR_TYPE_UINT16] = {2, 2},
+ [FR_TYPE_UINT32] = {4, 4},
+ [FR_TYPE_UINT64] = {8, 8},
[FR_TYPE_SIZE] = {sizeof(size_t), sizeof(size_t)},
- [FR_TYPE_SIGNED] = {4, 4},
+ [FR_TYPE_INT32] = {4, 4},
[FR_TYPE_DATE] = {4, 4},
[FR_TYPE_ABINARY] = {32, ~0},
* @note Must be updated to match the anonymous enum types union in fr_value_box_t
*/
bool const fr_dict_enum_types[FR_TYPE_MAX + 1] = {
- [FR_TYPE_BYTE] = true,
- [FR_TYPE_SHORT] = true,
- [FR_TYPE_INTEGER] = true,
- [FR_TYPE_INTEGER64] = true,
+ [FR_TYPE_UINT8] = true,
+ [FR_TYPE_UINT16] = true,
+ [FR_TYPE_UINT32] = true,
+ [FR_TYPE_UINT64] = true,
[FR_TYPE_SIZE] = true,
- [FR_TYPE_SIGNED] = true
+ [FR_TYPE_INT32] = true
};
/*
* Tags can only be used in a few limited situations.
*/
if (flags.has_tag) {
- if ((type != FR_TYPE_INTEGER) && (type != FR_TYPE_STRING)) {
+ if ((type != FR_TYPE_UINT32) && (type != FR_TYPE_STRING)) {
fr_strerror_printf("The 'has_tag' flag can only be used for attributes of type 'integer' "
"or 'string'");
goto error;
case FR_TYPE_IPV4_ADDR:
case FR_TYPE_IPV6_ADDR:
- case FR_TYPE_BYTE:
- case FR_TYPE_SHORT:
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT8:
+ case FR_TYPE_UINT16:
+ case FR_TYPE_UINT32:
case FR_TYPE_DATE:
case FR_TYPE_STRING:
break;
* caller sets it, we still sanity check it.
*/
if (flags.has_value) {
- if (type != FR_TYPE_INTEGER) {
+ if (type != FR_TYPE_UINT32) {
fr_strerror_printf("The 'has_value' flag can only be used with attributes "
"of type 'integer'");
goto error;
goto error;
case FR_TYPE_IPV4_ADDR:
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
case FR_TYPE_OCTETS:
if (flags.encrypt == FLAG_ENCRYPT_ASCEND_SECRET) goto encrypt_fail;
case FR_TYPE_INVALID:
case FR_TYPE_TIMEVAL:
- case FR_TYPE_DECIMAL:
+ case FR_TYPE_FLOAT64:
case FR_TYPE_COMBO_IP_PREFIX:
fr_strerror_printf("Attributes of type '%s' cannot be used in dictionaries",
fr_int2str(dict_attr_types, type, "?Unknown?"));
* Force "length" for data types of fixed length;
*/
switch (type) {
- case FR_TYPE_BYTE:
- case FR_TYPE_BOOLEAN:
+ case FR_TYPE_UINT8:
+ case FR_TYPE_BOOL:
flags.length = 1;
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
flags.length = 2;
break;
case FR_TYPE_DATE:
case FR_TYPE_IPV4_ADDR:
- case FR_TYPE_INTEGER:
- case FR_TYPE_SIGNED:
+ case FR_TYPE_UINT32:
+ case FR_TYPE_INT32:
flags.length = 4;
break;
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
flags.length = 8;
break;
* Don't worry about fixups...
*/
switch (da->type) {
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
if (value > UINT8_MAX) {
talloc_free(dval);
fr_strerror_printf("%s: ATTRIBUTEs of type 'byte' cannot have "
return -1;
}
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
if (value > UINT16_MAX) {
talloc_free(dval);
fr_strerror_printf("%s: ATTRIBUTEs of type 'short' cannot have "
}
break;
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
break;
default:
}
if (vp->da->flags.has_value) switch (vp->vp_type) {
- case FR_TYPE_BOOLEAN:
+ case FR_TYPE_BOOL:
return vp->vp_bool ? "yes" : "no";
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
enumv = fr_dict_enum_by_da(NULL, vp->da, vp->vp_byte);
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
enumv = fr_dict_enum_by_da(NULL, vp->da, vp->vp_short);
break;
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
enumv = fr_dict_enum_by_da(NULL, vp->da, vp->vp_integer);
break;
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
enumv = fr_dict_enum_by_da(NULL, vp->da, vp->vp_integer64);
break;
- case FR_TYPE_SIGNED:
+ case FR_TYPE_INT32:
enumv = fr_dict_enum_by_da(NULL, vp->da, vp->vp_signed);
break;
case FR_TYPE_STRING :
return talloc_typed_strdup(ctx, "_");
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
case FR_TYPE_SIZE:
- case FR_TYPE_SIGNED:
- case FR_TYPE_BYTE:
- case FR_TYPE_SHORT:
- case FR_TYPE_INTEGER:
+ case FR_TYPE_INT32:
+ case FR_TYPE_UINT8:
+ case FR_TYPE_UINT16:
+ case FR_TYPE_UINT32:
case FR_TYPE_DATE :
return talloc_typed_strdup(ctx, "0");
[FR_TYPE_IFID] = {8, 8},
[FR_TYPE_ETHERNET] = {6, 6},
- [FR_TYPE_BOOLEAN] = {1, 1},
- [FR_TYPE_BYTE] = {1, 1},
- [FR_TYPE_SHORT] = {2, 2},
- [FR_TYPE_INTEGER] = {4, 4},
- [FR_TYPE_INTEGER64] = {8, 8},
+ [FR_TYPE_BOOL] = {1, 1},
+ [FR_TYPE_UINT8] = {1, 1},
+ [FR_TYPE_UINT16] = {2, 2},
+ [FR_TYPE_UINT32] = {4, 4},
+ [FR_TYPE_UINT64] = {8, 8},
- [FR_TYPE_SIGNED] = {4, 4},
+ [FR_TYPE_INT32] = {4, 4},
[FR_TYPE_DATE] = {4, 4}, //!< 64bit on most machines.
[FR_TYPE_IFID] = SIZEOF_MEMBER(fr_value_box_t, datum.ifid),
[FR_TYPE_ETHERNET] = SIZEOF_MEMBER(fr_value_box_t, datum.ether),
- [FR_TYPE_BOOLEAN] = SIZEOF_MEMBER(fr_value_box_t, datum.boolean),
- [FR_TYPE_BYTE] = SIZEOF_MEMBER(fr_value_box_t, datum.byte),
- [FR_TYPE_SHORT] = SIZEOF_MEMBER(fr_value_box_t, datum.ushort),
- [FR_TYPE_INTEGER] = SIZEOF_MEMBER(fr_value_box_t, datum.integer),
- [FR_TYPE_INTEGER64] = SIZEOF_MEMBER(fr_value_box_t, datum.integer64),
+ [FR_TYPE_BOOL] = SIZEOF_MEMBER(fr_value_box_t, datum.boolean),
+ [FR_TYPE_UINT8] = SIZEOF_MEMBER(fr_value_box_t, datum.byte),
+ [FR_TYPE_UINT16] = SIZEOF_MEMBER(fr_value_box_t, datum.ushort),
+ [FR_TYPE_UINT32] = SIZEOF_MEMBER(fr_value_box_t, datum.integer),
+ [FR_TYPE_UINT64] = SIZEOF_MEMBER(fr_value_box_t, datum.integer64),
[FR_TYPE_SIZE] = SIZEOF_MEMBER(fr_value_box_t, datum.size),
- [FR_TYPE_SIGNED] = SIZEOF_MEMBER(fr_value_box_t, datum.sinteger),
+ [FR_TYPE_INT32] = SIZEOF_MEMBER(fr_value_box_t, datum.sinteger),
[FR_TYPE_TIMEVAL] = SIZEOF_MEMBER(fr_value_box_t, datum.timeval),
- [FR_TYPE_DECIMAL] = SIZEOF_MEMBER(fr_value_box_t, datum.decimal),
+ [FR_TYPE_FLOAT64] = SIZEOF_MEMBER(fr_value_box_t, datum.decimal),
[FR_TYPE_DATE] = SIZEOF_MEMBER(fr_value_box_t, datum.date),
[FR_TYPE_ABINARY] = SIZEOF_MEMBER(fr_value_box_t, datum.filter),
[FR_TYPE_IFID] = offsetof(fr_value_box_t, datum.ifid),
[FR_TYPE_ETHERNET] = offsetof(fr_value_box_t, datum.ether),
- [FR_TYPE_BOOLEAN] = offsetof(fr_value_box_t, datum.boolean),
- [FR_TYPE_BYTE] = offsetof(fr_value_box_t, datum.byte),
- [FR_TYPE_SHORT] = offsetof(fr_value_box_t, datum.ushort),
- [FR_TYPE_INTEGER] = offsetof(fr_value_box_t, datum.integer),
- [FR_TYPE_INTEGER64] = offsetof(fr_value_box_t, datum.integer64),
+ [FR_TYPE_BOOL] = offsetof(fr_value_box_t, datum.boolean),
+ [FR_TYPE_UINT8] = offsetof(fr_value_box_t, datum.byte),
+ [FR_TYPE_UINT16] = offsetof(fr_value_box_t, datum.ushort),
+ [FR_TYPE_UINT32] = offsetof(fr_value_box_t, datum.integer),
+ [FR_TYPE_UINT64] = offsetof(fr_value_box_t, datum.integer64),
[FR_TYPE_SIZE] = offsetof(fr_value_box_t, datum.size),
- [FR_TYPE_SIGNED] = offsetof(fr_value_box_t, datum.sinteger),
+ [FR_TYPE_INT32] = offsetof(fr_value_box_t, datum.sinteger),
[FR_TYPE_TIMEVAL] = offsetof(fr_value_box_t, datum.timeval),
- [FR_TYPE_DECIMAL] = offsetof(fr_value_box_t, datum.decimal),
+ [FR_TYPE_FLOAT64] = offsetof(fr_value_box_t, datum.decimal),
[FR_TYPE_DATE] = offsetof(fr_value_box_t, datum.date),
#define CHECK(_type) if (a->datum._type < b->datum._type) { compare = -1; \
} else if (a->datum._type > b->datum._type) { compare = +1; }
- case FR_TYPE_BOOLEAN: /* this isn't a RADIUS type, and shouldn't really ever be used */
- case FR_TYPE_BYTE:
+ case FR_TYPE_BOOL: /* this isn't a RADIUS type, and shouldn't really ever be used */
+ case FR_TYPE_UINT8:
CHECK(byte);
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
CHECK(ushort);
break;
CHECK(date);
break;
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
CHECK(integer);
break;
- case FR_TYPE_SIGNED:
+ case FR_TYPE_INT32:
CHECK(sinteger);
break;
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
CHECK(integer64);
break;
compare = fr_timeval_cmp(&a->datum.timeval, &b->datum.timeval);
break;
- case FR_TYPE_DECIMAL:
+ case FR_TYPE_FLOAT64:
CHECK(decimal);
break;
/* 8 byte integers */
switch (src->type) {
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
dst->datum.integer64 = htonll(src->datum.integer64);
fr_value_box_copy_meta(dst, src);
break;
/* 4 byte integers */
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
case FR_TYPE_DATE:
- case FR_TYPE_SIGNED:
+ case FR_TYPE_INT32:
dst->datum.integer = htonl(src->datum.integer);
fr_value_box_copy_meta(dst, src);
break;
/* 2 byte integers */
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
dst->datum.ushort = htons(src->datum.ushort);
fr_value_box_copy_meta(dst, src);
break;
* - FR_TYPE_IPV4_PREFIX (with 32bit mask).
* - FR_TYPE_IPV6_PREFIX (with v4 prefix and 128bit mask).
* - FR_TYPE_OCTETS (of length 4).
- * - FR_TYPE_INTEGER
+ * - FR_TYPE_UINT32
*
* @param ctx unused.
* @param dst Where to write result of casting.
memcpy(&dst->datum.ip.addr.v4, src->datum.octets, sizeof(dst->datum.ip.addr.v4.s_addr));
break;
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
{
uint32_t net;
memcpy(&dst->datum.ip.addr.v4, &src->datum.octets[1], sizeof(dst->datum.ip.addr.v4.s_addr));
break;
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
{
uint32_t net;
case FR_TYPE_COMBO_IP_ADDR:
case FR_TYPE_COMBO_IP_PREFIX:
case FR_TYPE_ETHERNET:
- case FR_TYPE_BOOLEAN:
- case FR_TYPE_BYTE:
- case FR_TYPE_SHORT:
- case FR_TYPE_INTEGER:
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_BOOL:
+ case FR_TYPE_UINT8:
+ case FR_TYPE_UINT16:
+ case FR_TYPE_UINT32:
+ case FR_TYPE_UINT64:
case FR_TYPE_SIZE:
- case FR_TYPE_SIGNED:
+ case FR_TYPE_INT32:
case FR_TYPE_TIMEVAL:
- case FR_TYPE_DECIMAL:
+ case FR_TYPE_FLOAT64:
case FR_TYPE_DATE:
case FR_TYPE_ABINARY:
break;
src->datum.strvalue, src->datum.length, '\0');
if ((src->type == FR_TYPE_IFID) &&
- (dst_type == FR_TYPE_INTEGER64)) {
+ (dst_type == FR_TYPE_UINT64)) {
memcpy(&dst->datum.integer64, src->datum.ifid, sizeof(src->datum.ifid));
dst->datum.integer64 = htonll(dst->datum.integer64);
return 0;
}
- if ((src->type == FR_TYPE_INTEGER64) &&
+ if ((src->type == FR_TYPE_UINT64) &&
(dst_type == FR_TYPE_ETHERNET)) {
uint8_t array[8];
uint64_t i;
goto fixed_length;
}
- if (dst_type == FR_TYPE_SHORT) {
+ if (dst_type == FR_TYPE_UINT16) {
switch (src->type) {
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
dst->datum.ushort = src->datum.byte;
break;
* We can cast LONG integers to SHORTER ones, so long
* as the long one is on the LHS.
*/
- if (dst_type == FR_TYPE_INTEGER) {
+ if (dst_type == FR_TYPE_UINT32) {
switch (src->type) {
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
dst->datum.integer = src->datum.byte;
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
dst->datum.integer = src->datum.ushort;
break;
- case FR_TYPE_SIGNED:
+ case FR_TYPE_INT32:
if (src->datum.sinteger < 0 ) {
fr_strerror_printf("Invalid cast: From signed to integer. "
"signed value %d is negative ", src->datum.sinteger);
* For integers, we allow the casting of a SMALL type to
* a larger type, but not vice-versa.
*/
- if (dst_type == FR_TYPE_INTEGER64) {
+ if (dst_type == FR_TYPE_UINT64) {
switch (src->type) {
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
dst->datum.integer64 = src->datum.byte;
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
dst->datum.integer64 = src->datum.ushort;
break;
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
dst->datum.integer64 = src->datum.integer;
break;
/*
* We can cast integers less that < INT_MAX to signed
*/
- if (dst_type == FR_TYPE_SIGNED) {
+ if (dst_type == FR_TYPE_INT32) {
switch (src->type) {
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
dst->datum.sinteger = src->datum.byte;
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
dst->datum.sinteger = src->datum.ushort;
break;
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
if (src->datum.integer > INT_MAX) {
fr_strerror_printf("Invalid cast: From integer to signed. integer value %u is larger "
"than max signed int and would overflow", src->datum.integer);
dst->datum.sinteger = (int)src->datum.integer;
break;
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
if (src->datum.integer > INT_MAX) {
fr_strerror_printf("Invalid cast: From integer64 to signed. integer64 value %" PRIu64
" is larger than max signed int and would overflow", src->datum.integer64);
if (dst_type == FR_TYPE_TIMEVAL) {
switch (src->type) {
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
dst->datum.timeval.tv_sec = src->datum.byte;
dst->datum.timeval.tv_usec = 0;
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
dst->datum.timeval.tv_sec = src->datum.ushort;
dst->datum.timeval.tv_usec = 0;
break;
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
dst->datum.timeval.tv_sec = src->datum.integer;
dst->datum.timeval.tv_usec = 0;
break;
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
/*
* tv_sec is a time_t, which is variable in size
* depending on the system.
* Convert host order to network byte order.
*/
if ((dst_type == FR_TYPE_IPV4_ADDR) &&
- ((src->type == FR_TYPE_INTEGER) ||
+ ((src->type == FR_TYPE_UINT32) ||
(src->type == FR_TYPE_DATE) ||
- (src->type == FR_TYPE_SIGNED))) {
+ (src->type == FR_TYPE_INT32))) {
dst->datum.ip.af = AF_INET;
dst->datum.ip.prefix = 32;
dst->datum.ip.scope_id = 0;
dst->datum.ip.addr.v4.s_addr = htonl(src->datum.integer);
} else if ((src->type == FR_TYPE_IPV4_ADDR) &&
- ((dst_type == FR_TYPE_INTEGER) ||
+ ((dst_type == FR_TYPE_UINT32) ||
(dst_type == FR_TYPE_DATE) ||
- (dst_type == FR_TYPE_SIGNED))) {
+ (dst_type == FR_TYPE_INT32))) {
dst->datum.integer = htonl(src->datum.ip.addr.v4.s_addr);
} else { /* they're of the same byte order */
break;
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
{
char *p;
unsigned int i;
break;
}
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
{
char *p;
unsigned int i;
break;
}
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
{
char *p;
}
break;
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
{
uint64_t i;
if (fr_timeval_from_str(&dst->datum.timeval, in) < 0) return -1;
break;
- case FR_TYPE_DECIMAL:
+ case FR_TYPE_FLOAT64:
{
double d;
}
break;
- case FR_TYPE_SIGNED:
+ case FR_TYPE_INT32:
/* Damned code for 1 WiMAX attribute */
dst->datum.sinteger = (int32_t)strtol(in, NULL, 10);
break;
- case FR_TYPE_BOOLEAN:
+ case FR_TYPE_BOOL:
if ((strcmp(in, "yes") == 0) || strcmp(in, "true") == 0) {
dst->datum.boolean = true;
} else if ((strcmp(in, "no") == 0) || (strcmp(in, "false") == 0)) {
fr_dict_enum_t const *dv;
fr_value_box_t tmp;
- fr_value_box_cast(ctx, &tmp, FR_TYPE_INTEGER, NULL, data);
+ fr_value_box_cast(ctx, &tmp, FR_TYPE_UINT32, NULL, data);
dv = fr_dict_enum_by_da(NULL, data->datum.enumv, tmp.datum.integer);
if (dv) return talloc_typed_strdup(ctx, dv->name);
data->datum.ether[4], data->datum.ether[5]);
break;
- case FR_TYPE_BOOLEAN:
+ case FR_TYPE_BOOL:
p = talloc_typed_strdup(ctx, data->datum.byte ? "yes" : "no");
break;
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
p = talloc_typed_asprintf(ctx, "%u", data->datum.byte);
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
p = talloc_typed_asprintf(ctx, "%u", data->datum.ushort);
break;
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
p = talloc_typed_asprintf(ctx, "%u", data->datum.integer);
break;
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
p = talloc_typed_asprintf(ctx, "%" PRIu64, data->datum.integer64);
break;
p = talloc_typed_asprintf(ctx, "%zu", data->datum.size);
break;
- case FR_TYPE_SIGNED:
+ case FR_TYPE_INT32:
p = talloc_typed_asprintf(ctx, "%d", data->datum.sinteger);
break;
(uint64_t)data->datum.timeval.tv_sec, (uint64_t)data->datum.timeval.tv_usec);
break;
- case FR_TYPE_DECIMAL:
+ case FR_TYPE_FLOAT64:
p = talloc_typed_asprintf(ctx, "%g", data->datum.decimal);
break;
fr_dict_enum_t const *dv;
fr_value_box_t tmp;
- fr_value_box_cast(NULL, &tmp, FR_TYPE_INTEGER, NULL, data);
+ fr_value_box_cast(NULL, &tmp, FR_TYPE_UINT32, NULL, data);
dv = fr_dict_enum_by_da(NULL, data->datum.enumv, tmp.datum.integer);
if (dv) return strlcpy(out, dv->name, outlen);
return fr_snprint(out, outlen, data->datum.strvalue, data->datum.length, quote);
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
return snprintf(out, outlen, "%u", data->datum.byte);
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
return snprintf(out, outlen, "%u", data->datum.ushort);
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
return snprintf(out, outlen, "%u", data->datum.integer);
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
return snprintf(out, outlen, "%" PRIu64, data->datum.integer64);
case FR_TYPE_SIZE:
return snprintf(out, outlen, "%zu", data->datum.size);
- case FR_TYPE_SIGNED: /* Damned code for 1 WiMAX attribute */
+ case FR_TYPE_INT32: /* Damned code for 1 WiMAX attribute */
len = snprintf(buf, sizeof(buf), "%d", data->datum.sinteger);
a = buf;
break;
data->datum.ether[2], data->datum.ether[3],
data->datum.ether[4], data->datum.ether[5]);
- case FR_TYPE_DECIMAL:
+ case FR_TYPE_FLOAT64:
return snprintf(out, outlen, "%g", data->datum.decimal);
/*
case FR_TYPE_EVS:
case FR_TYPE_VSA:
case FR_TYPE_VENDOR:
- case FR_TYPE_BOOLEAN:
+ case FR_TYPE_BOOL:
case FR_TYPE_STRUCT:
case FR_TYPE_MAX:
(void)fr_cond_assert(0);
#ifdef WITH_TCP
static CONF_PARSER limit_config[] = {
- { FR_CONF_OFFSET("max_connections", FR_TYPE_INTEGER, RADCLIENT, limit.max_connections), .dflt = "16" },
+ { FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, RADCLIENT, limit.max_connections), .dflt = "16" },
- { FR_CONF_OFFSET("lifetime", FR_TYPE_INTEGER, RADCLIENT, limit.lifetime), .dflt = "0" },
+ { FR_CONF_OFFSET("lifetime", FR_TYPE_UINT32, RADCLIENT, limit.lifetime), .dflt = "0" },
- { FR_CONF_OFFSET("idle_timeout", FR_TYPE_INTEGER, RADCLIENT, limit.idle_timeout), .dflt = "30" },
+ { FR_CONF_OFFSET("idle_timeout", FR_TYPE_UINT32, RADCLIENT, limit.idle_timeout), .dflt = "30" },
CONF_PARSER_TERMINATOR
};
#endif
{ FR_CONF_POINTER("src_ipaddr", FR_TYPE_STRING, &cl_srcipaddr) },
- { FR_CONF_OFFSET("require_message_authenticator", FR_TYPE_BOOLEAN, RADCLIENT, message_authenticator), .dflt = "no" },
+ { FR_CONF_OFFSET("require_message_authenticator", FR_TYPE_BOOL, RADCLIENT, message_authenticator), .dflt = "no" },
{ FR_CONF_OFFSET("secret", FR_TYPE_STRING | FR_TYPE_SECRET, RADCLIENT, secret) },
{ FR_CONF_OFFSET("shortname", FR_TYPE_STRING, RADCLIENT, shortname) },
#ifdef WITH_DYNAMIC_CLIENTS
{ FR_CONF_OFFSET("dynamic_clients", FR_TYPE_STRING, RADCLIENT, client_server) },
- { FR_CONF_OFFSET("lifetime", FR_TYPE_INTEGER, RADCLIENT, lifetime) },
- { FR_CONF_OFFSET("rate_limit", FR_TYPE_BOOLEAN, RADCLIENT, rate_limit) },
+ { FR_CONF_OFFSET("lifetime", FR_TYPE_UINT32, RADCLIENT, lifetime) },
+ { FR_CONF_OFFSET("rate_limit", FR_TYPE_BOOL, RADCLIENT, rate_limit) },
#endif
CONF_PARSER_TERMINATOR
};
{ FR_CONF_OFFSET("FreeRADIUS-Client-Src-IP-Address", FR_TYPE_IPV4_ADDR, RADCLIENT, src_ipaddr) },
{ FR_CONF_OFFSET("FreeRADIUS-Client-Src-IPv6-Address", FR_TYPE_IPV6_ADDR, RADCLIENT, src_ipaddr) },
- { FR_CONF_OFFSET("FreeRADIUS-Client-Require-MA", FR_TYPE_BOOLEAN, RADCLIENT, message_authenticator) },
+ { FR_CONF_OFFSET("FreeRADIUS-Client-Require-MA", FR_TYPE_BOOL, RADCLIENT, message_authenticator) },
{ FR_CONF_OFFSET("FreeRADIUS-Client-Secret", FR_TYPE_STRING, RADCLIENT, secret), .dflt = "" },
{ FR_CONF_OFFSET("FreeRADIUS-Client-Shortname", FR_TYPE_STRING, RADCLIENT, shortname), .dflt = "" },
}
break;
- case FR_TYPE_BOOLEAN:
+ case FR_TYPE_BOOL:
{
CONF_PARSER const *parse;
{ FR_CONF_DEPRECATED("uid", FR_TYPE_STRING, fr_command_socket_t, NULL) },
{ FR_CONF_OFFSET("gid", FR_TYPE_STRING, fr_command_socket_t, gid_name) },
{ FR_CONF_OFFSET("mode", FR_TYPE_STRING, fr_command_socket_t, mode_name) },
- { FR_CONF_OFFSET("peercred", FR_TYPE_BOOLEAN, fr_command_socket_t, peercred), .dflt = "yes" },
- { FR_CONF_OFFSET("blocking", FR_TYPE_BOOLEAN, fr_command_socket_t, blocking), },
+ { FR_CONF_OFFSET("peercred", FR_TYPE_BOOL, fr_command_socket_t, peercred), .dflt = "yes" },
+ { FR_CONF_OFFSET("blocking", FR_TYPE_BOOL, fr_command_socket_t, blocking), },
CONF_PARSER_TERMINATOR
};
variables[i].name);
break;
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
cprintf(listener, "%.*s%s = %u\n", indent, tabs,
variables[i].name, *(int const *) data);
break;
inet_ntop(AF_INET6, data, buffer, sizeof(buffer));
break;
- case FR_TYPE_BOOLEAN:
+ case FR_TYPE_BOOL:
cprintf(listener, "%.*s%s = %s\n", indent, tabs,
variables[i].name,
((*(bool const *) data) == false) ? "no" : "yes");
_l && (_l->type == FR_TYPE_STRING) &&\
_r && (_r->type == FR_TYPE_STRING) &&\
all_digits(lhs->datum.strvalue) && all_digits(rhs->datum.strvalue)) {\
- cast_type = FR_TYPE_INTEGER64;\
+ cast_type = FR_TYPE_UINT64;\
EVAL_DEBUG("OPERANDS ARE NUMBER STRINGS, SETTING CAST TO integer64");\
}\
} while (0)
* If the LHS has a small type, and the RHS has a large type,
* then add a cast to the LHS.
*/
- if (lhs_type == FR_TYPE_INTEGER64) {
- if ((c->data.map->rhs->tmpl_da->type == FR_TYPE_INTEGER) ||
- (c->data.map->rhs->tmpl_da->type == FR_TYPE_SHORT) ||
- (c->data.map->rhs->tmpl_da->type == FR_TYPE_BYTE)) {
+ if (lhs_type == FR_TYPE_UINT64) {
+ if ((c->data.map->rhs->tmpl_da->type == FR_TYPE_UINT32) ||
+ (c->data.map->rhs->tmpl_da->type == FR_TYPE_UINT16) ||
+ (c->data.map->rhs->tmpl_da->type == FR_TYPE_UINT8)) {
c->cast = NULL;
return true;
}
}
- if (lhs_type == FR_TYPE_INTEGER) {
- if ((c->data.map->rhs->tmpl_da->type == FR_TYPE_SHORT) ||
- (c->data.map->rhs->tmpl_da->type == FR_TYPE_BYTE)) {
+ if (lhs_type == FR_TYPE_UINT32) {
+ if ((c->data.map->rhs->tmpl_da->type == FR_TYPE_UINT16) ||
+ (c->data.map->rhs->tmpl_da->type == FR_TYPE_UINT8)) {
c->cast = NULL;
return true;
}
- if (c->data.map->rhs->tmpl_da->type == FR_TYPE_INTEGER64) {
+ if (c->data.map->rhs->tmpl_da->type == FR_TYPE_UINT64) {
c->cast = c->data.map->rhs->tmpl_da;
return true;
}
}
- if (lhs_type == FR_TYPE_SHORT) {
- if (c->data.map->rhs->tmpl_da->type == FR_TYPE_BYTE) {
+ if (lhs_type == FR_TYPE_UINT16) {
+ if (c->data.map->rhs->tmpl_da->type == FR_TYPE_UINT8) {
c->cast = NULL;
return true;
}
- if ((c->data.map->rhs->tmpl_da->type == FR_TYPE_INTEGER64) ||
- (c->data.map->rhs->tmpl_da->type == FR_TYPE_INTEGER)) {
+ if ((c->data.map->rhs->tmpl_da->type == FR_TYPE_UINT64) ||
+ (c->data.map->rhs->tmpl_da->type == FR_TYPE_UINT32)) {
c->cast = c->data.map->rhs->tmpl_da;
return true;
}
}
- if (lhs_type == FR_TYPE_BYTE) {
- if ((c->data.map->rhs->tmpl_da->type == FR_TYPE_INTEGER64) ||
- (c->data.map->rhs->tmpl_da->type == FR_TYPE_INTEGER) ||
- (c->data.map->rhs->tmpl_da->type == FR_TYPE_SHORT)) {
+ if (lhs_type == FR_TYPE_UINT8) {
+ if ((c->data.map->rhs->tmpl_da->type == FR_TYPE_UINT64) ||
+ (c->data.map->rhs->tmpl_da->type == FR_TYPE_UINT32) ||
+ (c->data.map->rhs->tmpl_da->type == FR_TYPE_UINT16)) {
c->cast = c->data.map->rhs->tmpl_da;
return true;
}
if ((map->lhs->type != TMPL_TYPE_ATTR) ||
!((map->lhs->tmpl_da->type == FR_TYPE_OCTETS) ||
- (map->lhs->tmpl_da->type == FR_TYPE_BYTE) ||
- (map->lhs->tmpl_da->type == FR_TYPE_SHORT) ||
- (map->lhs->tmpl_da->type == FR_TYPE_INTEGER) ||
- (map->lhs->tmpl_da->type == FR_TYPE_INTEGER64))) {
+ (map->lhs->tmpl_da->type == FR_TYPE_UINT8) ||
+ (map->lhs->tmpl_da->type == FR_TYPE_UINT16) ||
+ (map->lhs->tmpl_da->type == FR_TYPE_UINT32) ||
+ (map->lhs->tmpl_da->type == FR_TYPE_UINT64))) {
c->cast = fr_dict_attr_by_num(NULL, 0, PW_CAST_BASE + FR_TYPE_OCTETS);
}
}
* ifid to integer64 is OK
*/
if ((c->data.map->lhs->tmpl_da->type == FR_TYPE_IFID) &&
- (c->cast->type == FR_TYPE_INTEGER64)) {
+ (c->cast->type == FR_TYPE_UINT64)) {
goto cast_ok;
}
/*
* integer64 to ethernet is OK.
*/
- if ((c->data.map->lhs->tmpl_da->type == FR_TYPE_INTEGER64) &&
+ if ((c->data.map->lhs->tmpl_da->type == FR_TYPE_UINT64) &&
(c->cast->type == FR_TYPE_ETHERNET)) {
goto cast_ok;
}
}
switch (type) {
- case FR_TYPE_BOOLEAN:
+ case FR_TYPE_BOOL:
/*
* Allow yes/no, true/false, and on/off
*/
cf_log_info(cs, "%.*s\t%s = %s", cs->depth, parse_spaces, cf_pair_attr(cp), cp->value);
break;
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
{
unsigned long v = strtoul(cp->value, 0, 0);
}
break;
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
{
unsigned long v = strtoul(cp->value, 0, 0);
}
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
{
unsigned long v = strtoul(cp->value, 0, 0);
}
break;
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
*(uint64_t *)out = strtoull(cp->value, NULL, 10);
cf_log_info(cs, "%.*s\t%s = %" PRIu64, cs->depth, parse_spaces, cf_pair_attr(cp), *(uint64_t *)out);
break;
break;
}
- case FR_TYPE_SIGNED:
+ case FR_TYPE_INT32:
*(int32_t *)out = strtol(cp->value, NULL, 10);
cf_log_info(cs, "%.*s\t%s = %d", cs->depth, parse_spaces, cf_pair_attr(cp), *(int32_t *)out);
break;
* | fr_type_t | Data type | Dynamically allocated |
* | ----------------------- | ------------------ | ---------------------- |
* | FR_TYPE_TMPL | ``vp_tmpl_t`` | Yes |
- * | FR_TYPE_BOOLEAN | ``bool`` | No |
- * | FR_TYPE_INTEGER | ``uint32_t`` | No |
- * | FR_TYPE_SHORT | ``uint16_t`` | No |
- * | FR_TYPE_INTEGER64 | ``uint64_t`` | No |
- * | FR_TYPE_SIGNED | ``int32_t`` | No |
+ * | FR_TYPE_BOOL | ``bool`` | No |
+ * | FR_TYPE_UINT32 | ``uint32_t`` | No |
+ * | FR_TYPE_UINT16 | ``uint16_t`` | No |
+ * | FR_TYPE_UINT64 | ``uint64_t`` | No |
+ * | FR_TYPE_INT32 | ``int32_t`` | No |
* | FR_TYPE_STRING | ``char const *`` | Yes |
* | FR_TYPE_IPV4_ADDR | ``fr_ipaddr_t`` | No |
* | FR_TYPE_IPV4_PREFIX | ``fr_ipaddr_t`` | No |
* - ``data`` #FR_TYPE_TMPL - @copybrief FR_TYPE_TMPL
* Feeds the value into #tmpl_afrom_str. Value can be
* obtained when processing requests, with #tmpl_expand or #tmpl_aexpand.
- * - ``data`` #FR_TYPE_BOOLEAN - @copybrief FR_TYPE_BOOLEAN
- * - ``data`` #FR_TYPE_INTEGER - @copybrief FR_TYPE_INTEGER
- * - ``data`` #FR_TYPE_SHORT - @copybrief FR_TYPE_SHORT
- * - ``data`` #FR_TYPE_INTEGER64 - @copybrief FR_TYPE_INTEGER64
- * - ``data`` #FR_TYPE_SIGNED - @copybrief FR_TYPE_SIGNED
+ * - ``data`` #FR_TYPE_BOOL - @copybrief FR_TYPE_BOOL
+ * - ``data`` #FR_TYPE_UINT32 - @copybrief FR_TYPE_UINT32
+ * - ``data`` #FR_TYPE_UINT16 - @copybrief FR_TYPE_UINT16
+ * - ``data`` #FR_TYPE_UINT64 - @copybrief FR_TYPE_UINT64
+ * - ``data`` #FR_TYPE_INT32 - @copybrief FR_TYPE_INT32
* - ``data`` #FR_TYPE_STRING - @copybrief FR_TYPE_STRING
* - ``data`` #FR_TYPE_IPV4_ADDR - @copybrief FR_TYPE_IPV4_ADDR (IPv4 address with prefix 32).
* - ``data`` #FR_TYPE_IPV4_PREFIX - @copybrief FR_TYPE_IPV4_PREFIX (IPv4 address with variable prefix).
* talloc_array_length().
*/
} else switch (PW_BASE_TYPE(type)) {
- case FR_TYPE_BOOLEAN:
+ case FR_TYPE_BOOL:
array = (void **)talloc_zero_array(ctx, bool, count);
break;
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
array = (void **)talloc_zero_array(ctx, uint32_t, count);
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
array = (void **)talloc_zero_array(ctx, uint16_t, count);
break;
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
array = (void **)talloc_zero_array(ctx, uint64_t, count);
break;
- case FR_TYPE_SIGNED:
+ case FR_TYPE_INT32:
array = (void **)talloc_zero_array(ctx, int32_t, count);
break;
};
static const CONF_PARSER connection_config[] = {
- { FR_CONF_OFFSET("start", FR_TYPE_INTEGER, fr_connection_pool_t, start), .dflt = "5" },
- { FR_CONF_OFFSET("min", FR_TYPE_INTEGER, fr_connection_pool_t, min), .dflt = "5" },
- { FR_CONF_OFFSET("max", FR_TYPE_INTEGER, fr_connection_pool_t, max), .dflt = "10" },
- { FR_CONF_OFFSET("max_pending", FR_TYPE_INTEGER, fr_connection_pool_t, max_pending), .dflt = "0" },
- { FR_CONF_OFFSET("spare", FR_TYPE_INTEGER, fr_connection_pool_t, spare), .dflt = "3" },
- { FR_CONF_OFFSET("uses", FR_TYPE_INTEGER64, fr_connection_pool_t, max_uses), .dflt = "0" },
- { FR_CONF_OFFSET("lifetime", FR_TYPE_INTEGER, fr_connection_pool_t, lifetime), .dflt = "0" },
- { FR_CONF_OFFSET("cleanup_delay", FR_TYPE_INTEGER, fr_connection_pool_t, cleanup_interval) },
- { FR_CONF_OFFSET("cleanup_interval", FR_TYPE_INTEGER, fr_connection_pool_t, cleanup_interval), .dflt = "30" },
- { FR_CONF_OFFSET("idle_timeout", FR_TYPE_INTEGER, fr_connection_pool_t, idle_timeout), .dflt = "60" },
+ { FR_CONF_OFFSET("start", FR_TYPE_UINT32, fr_connection_pool_t, start), .dflt = "5" },
+ { FR_CONF_OFFSET("min", FR_TYPE_UINT32, fr_connection_pool_t, min), .dflt = "5" },
+ { FR_CONF_OFFSET("max", FR_TYPE_UINT32, fr_connection_pool_t, max), .dflt = "10" },
+ { FR_CONF_OFFSET("max_pending", FR_TYPE_UINT32, fr_connection_pool_t, max_pending), .dflt = "0" },
+ { FR_CONF_OFFSET("spare", FR_TYPE_UINT32, fr_connection_pool_t, spare), .dflt = "3" },
+ { FR_CONF_OFFSET("uses", FR_TYPE_UINT64, fr_connection_pool_t, max_uses), .dflt = "0" },
+ { FR_CONF_OFFSET("lifetime", FR_TYPE_UINT32, fr_connection_pool_t, lifetime), .dflt = "0" },
+ { FR_CONF_OFFSET("cleanup_delay", FR_TYPE_UINT32, fr_connection_pool_t, cleanup_interval) },
+ { FR_CONF_OFFSET("cleanup_interval", FR_TYPE_UINT32, fr_connection_pool_t, cleanup_interval), .dflt = "30" },
+ { FR_CONF_OFFSET("idle_timeout", FR_TYPE_UINT32, fr_connection_pool_t, idle_timeout), .dflt = "60" },
{ FR_CONF_OFFSET("connect_timeout", FR_TYPE_TIMEVAL, fr_connection_pool_t, connect_timeout), .dflt = "3.0" },
{ FR_CONF_OFFSET("held_trigger_min", FR_TYPE_TIMEVAL, fr_connection_pool_t, held_trigger_min), .dflt = "0.0" },
{ FR_CONF_OFFSET("held_trigger_max", FR_TYPE_TIMEVAL, fr_connection_pool_t, held_trigger_max), .dflt = "0.5" },
- { FR_CONF_OFFSET("retry_delay", FR_TYPE_INTEGER, fr_connection_pool_t, retry_delay), .dflt = "1" },
- { FR_CONF_OFFSET("spread", FR_TYPE_BOOLEAN, fr_connection_pool_t, spread), .dflt = "no" },
+ { FR_CONF_OFFSET("retry_delay", FR_TYPE_UINT32, fr_connection_pool_t, retry_delay), .dflt = "1" },
+ { FR_CONF_OFFSET("spread", FR_TYPE_BOOL, fr_connection_pool_t, spread), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
}
}
static CONF_PARSER performance_config[] = {
- { FR_CONF_OFFSET("skip_duplicate_checks", FR_TYPE_BOOLEAN, rad_listen_t, nodup) },
+ { FR_CONF_OFFSET("skip_duplicate_checks", FR_TYPE_BOOL, rad_listen_t, nodup) },
CONF_PARSER_TERMINATOR
};
static CONF_PARSER limit_config[] = {
- { FR_CONF_OFFSET("max_pps", FR_TYPE_INTEGER, listen_socket_t, max_rate) },
+ { FR_CONF_OFFSET("max_pps", FR_TYPE_UINT32, listen_socket_t, max_rate) },
#ifdef WITH_TCP
- { FR_CONF_OFFSET("max_connections", FR_TYPE_INTEGER, listen_socket_t, limit.max_connections), .dflt = "16" },
- { FR_CONF_OFFSET("lifetime", FR_TYPE_INTEGER, listen_socket_t, limit.lifetime), .dflt = "0" },
- { FR_CONF_OFFSET("idle_timeout", FR_TYPE_INTEGER, listen_socket_t, limit.idle_timeout), .dflt = STRINGIFY(30) },
+ { FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, listen_socket_t, limit.max_connections), .dflt = "16" },
+ { FR_CONF_OFFSET("lifetime", FR_TYPE_UINT32, listen_socket_t, limit.lifetime), .dflt = "0" },
+ { FR_CONF_OFFSET("idle_timeout", FR_TYPE_UINT32, listen_socket_t, limit.idle_timeout), .dflt = STRINGIFY(30) },
#endif
CONF_PARSER_TERMINATOR
};
ipaddr.addr.v6 = in6addr_any; /* in6addr_any binds to all addresses */
}
- rcode = cf_pair_parse(NULL, cs, "port", FR_ITEM_POINTER(FR_TYPE_SHORT, &sock->my_port), "0", T_BARE_WORD);
+ rcode = cf_pair_parse(NULL, cs, "port", FR_ITEM_POINTER(FR_TYPE_UINT16, &sock->my_port), "0", T_BARE_WORD);
if (rcode < 0) return -1;
- rcode = cf_pair_parse(NULL, cs, "recv_buff", FR_ITEM_POINTER(FR_TYPE_INTEGER, &recv_buff), "0", T_BARE_WORD);
+ rcode = cf_pair_parse(NULL, cs, "recv_buff", FR_ITEM_POINTER(FR_TYPE_UINT32, &recv_buff), "0", T_BARE_WORD);
if (rcode < 0) return -1;
if (recv_buff) {
FR_INTEGER_BOUND_CHECK("recv_buff", recv_buff, >=, 32);
{ FR_CONF_POINTER("log_file", FR_TYPE_STRING, &main_config.log_file) },
{ FR_CONF_POINTER("log_destination", FR_TYPE_STRING, &radlog_dest) },
- { FR_CONF_POINTER("use_utc", FR_TYPE_BOOLEAN, &log_dates_utc) },
- { FR_CONF_IS_SET_POINTER("timestamp", FR_TYPE_BOOLEAN, &log_timestamp) },
+ { FR_CONF_POINTER("use_utc", FR_TYPE_BOOL, &log_dates_utc) },
+ { FR_CONF_IS_SET_POINTER("timestamp", FR_TYPE_BOOL, &log_timestamp) },
CONF_PARSER_TERMINATOR
};
*
**********************************************************************/
static const CONF_PARSER log_config[] = {
- { FR_CONF_POINTER("stripped_names", FR_TYPE_BOOLEAN, &log_stripped_names), .dflt = "no" },
- { FR_CONF_POINTER("auth", FR_TYPE_BOOLEAN, &main_config.log_auth), .dflt = "no" },
- { FR_CONF_POINTER("auth_badpass", FR_TYPE_BOOLEAN, &main_config.log_auth_badpass), .dflt = "no" },
- { FR_CONF_POINTER("auth_goodpass", FR_TYPE_BOOLEAN, &main_config.log_auth_goodpass), .dflt = "no" },
+ { FR_CONF_POINTER("stripped_names", FR_TYPE_BOOL, &log_stripped_names), .dflt = "no" },
+ { FR_CONF_POINTER("auth", FR_TYPE_BOOL, &main_config.log_auth), .dflt = "no" },
+ { FR_CONF_POINTER("auth_badpass", FR_TYPE_BOOL, &main_config.log_auth_badpass), .dflt = "no" },
+ { FR_CONF_POINTER("auth_goodpass", FR_TYPE_BOOL, &main_config.log_auth_goodpass), .dflt = "no" },
{ FR_CONF_POINTER("msg_badpass", FR_TYPE_STRING, &main_config.auth_badpass_msg) },
{ FR_CONF_POINTER("msg_goodpass", FR_TYPE_STRING, &main_config.auth_goodpass_msg) },
- { FR_CONF_POINTER("colourise", FR_TYPE_BOOLEAN, &do_colourise) },
- { FR_CONF_POINTER("timestamp", FR_TYPE_BOOLEAN, &log_timestamp) },
- { FR_CONF_POINTER("use_utc", FR_TYPE_BOOLEAN, &log_dates_utc) },
+ { FR_CONF_POINTER("colourise", FR_TYPE_BOOL, &do_colourise) },
+ { FR_CONF_POINTER("timestamp", FR_TYPE_BOOL, &log_timestamp) },
+ { FR_CONF_POINTER("use_utc", FR_TYPE_BOOL, &log_dates_utc) },
{ FR_CONF_POINTER("msg_denied", FR_TYPE_STRING, &main_config.denied_msg), .dflt = "You are already logged in - access denied" },
#ifdef WITH_CONF_WRITE
{ FR_CONF_POINTER("write_dir", FR_TYPE_STRING, &main_config.write_dir), .dflt = NULL },
* Security configuration for the server.
*/
static const CONF_PARSER security_config[] = {
- { FR_CONF_POINTER("max_attributes", FR_TYPE_INTEGER, &fr_max_attributes), .dflt = STRINGIFY(0) },
+ { FR_CONF_POINTER("max_attributes", FR_TYPE_UINT32, &fr_max_attributes), .dflt = STRINGIFY(0) },
{ FR_CONF_POINTER("reject_delay", FR_TYPE_TIMEVAL, &main_config.reject_delay), .dflt = STRINGIFY(0) },
- { FR_CONF_POINTER("status_server", FR_TYPE_BOOLEAN, &main_config.status_server), .dflt = "no" },
+ { FR_CONF_POINTER("status_server", FR_TYPE_BOOL, &main_config.status_server), .dflt = "no" },
/*
* No default, so it isn't printed in debug mode.
*/
- { FR_CONF_POINTER("tunnel_password_zeros", FR_TYPE_BOOLEAN, &fr_tunnel_password_zeros) },
+ { FR_CONF_POINTER("tunnel_password_zeros", FR_TYPE_BOOL, &fr_tunnel_password_zeros) },
#ifdef ENABLE_OPENSSL_VERSION_CHECK
{ FR_CONF_POINTER("allow_vulnerable_openssl", FR_TYPE_STRING, &main_config.allow_vulnerable_openssl), .dflt = "no" },
#endif
- { FR_CONF_POINTER("server_id", FR_TYPE_BYTE, &main_config.state_server_id) },
+ { FR_CONF_POINTER("server_id", FR_TYPE_UINT8, &main_config.state_server_id) },
CONF_PARSER_TERMINATOR
};
*/
{ FR_CONF_POINTER("talloc_pool_size", FR_TYPE_SIZE, &main_config.talloc_pool_size) }, /* DO NOT SET DEFAULT */
{ FR_CONF_POINTER("talloc_memory_limit", FR_TYPE_SIZE, &main_config.talloc_memory_limit) }, /* DO NOT SET DEFAULT */
- { FR_CONF_POINTER("talloc_memory_report", FR_TYPE_BOOLEAN, &main_config.talloc_memory_report) }, /* DO NOT SET DEFAULT */
+ { FR_CONF_POINTER("talloc_memory_report", FR_TYPE_BOOL, &main_config.talloc_memory_report) }, /* DO NOT SET DEFAULT */
CONF_PARSER_TERMINATOR
};
{ FR_CONF_POINTER("libdir", FR_TYPE_STRING, &radlib_dir), .dflt = "${prefix}/lib"},
{ FR_CONF_POINTER("radacctdir", FR_TYPE_STRING, &radacct_dir), .dflt = "${logdir}/radacct" },
{ FR_CONF_POINTER("panic_action", FR_TYPE_STRING, &main_config.panic_action) },
- { FR_CONF_POINTER("hostname_lookups", FR_TYPE_BOOLEAN, &fr_dns_lookups), .dflt = "no" },
- { FR_CONF_POINTER("max_request_time", FR_TYPE_INTEGER, &main_config.max_request_time), .dflt = STRINGIFY(MAX_REQUEST_TIME) },
- { FR_CONF_POINTER("cleanup_delay", FR_TYPE_INTEGER, &main_config.cleanup_delay), .dflt = STRINGIFY(CLEANUP_DELAY) },
- { FR_CONF_POINTER("continuation_timeout", FR_TYPE_INTEGER, &main_config.continuation_timeout), .dflt = "15" },
- { FR_CONF_POINTER("max_requests", FR_TYPE_INTEGER, &main_config.max_requests), .dflt = STRINGIFY(MAX_REQUESTS) },
+ { FR_CONF_POINTER("hostname_lookups", FR_TYPE_BOOL, &fr_dns_lookups), .dflt = "no" },
+ { FR_CONF_POINTER("max_request_time", FR_TYPE_UINT32, &main_config.max_request_time), .dflt = STRINGIFY(MAX_REQUEST_TIME) },
+ { FR_CONF_POINTER("cleanup_delay", FR_TYPE_UINT32, &main_config.cleanup_delay), .dflt = STRINGIFY(CLEANUP_DELAY) },
+ { FR_CONF_POINTER("continuation_timeout", FR_TYPE_UINT32, &main_config.continuation_timeout), .dflt = "15" },
+ { FR_CONF_POINTER("max_requests", FR_TYPE_UINT32, &main_config.max_requests), .dflt = STRINGIFY(MAX_REQUESTS) },
{ FR_CONF_POINTER("pidfile", FR_TYPE_STRING, &main_config.pid_file), .dflt = "${run_dir}/radiusd.pid"},
{ FR_CONF_POINTER("checkrad", FR_TYPE_STRING, &main_config.checkrad), .dflt = "${sbindir}/checkrad" },
- { FR_CONF_POINTER("debug_level", FR_TYPE_INTEGER, &main_config.debug_level), .dflt = "0" },
+ { FR_CONF_POINTER("debug_level", FR_TYPE_UINT32, &main_config.debug_level), .dflt = "0" },
#ifdef WITH_PROXY
- { FR_CONF_POINTER("proxy_requests", FR_TYPE_BOOLEAN, &main_config.proxy_requests), .dflt = "yes" },
+ { FR_CONF_POINTER("proxy_requests", FR_TYPE_BOOL, &main_config.proxy_requests), .dflt = "yes" },
#endif
{ FR_CONF_POINTER("log", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) log_config },
* DON'T exist in radiusd.conf, then the previously parsed
* values for "log { foo = bar}" will be used.
*/
- { FR_CONF_POINTER("log_auth", FR_TYPE_BOOLEAN | FR_TYPE_DEPRECATED, &main_config.log_auth) },
- { FR_CONF_POINTER("log_auth_badpass", FR_TYPE_BOOLEAN | FR_TYPE_DEPRECATED, &main_config.log_auth_badpass) },
- { FR_CONF_POINTER("log_auth_goodpass", FR_TYPE_BOOLEAN | FR_TYPE_DEPRECATED, &main_config.log_auth_goodpass) },
- { FR_CONF_POINTER("log_stripped_names", FR_TYPE_BOOLEAN | FR_TYPE_DEPRECATED, &log_stripped_names) },
+ { FR_CONF_POINTER("log_auth", FR_TYPE_BOOL | FR_TYPE_DEPRECATED, &main_config.log_auth) },
+ { FR_CONF_POINTER("log_auth_badpass", FR_TYPE_BOOL | FR_TYPE_DEPRECATED, &main_config.log_auth_badpass) },
+ { FR_CONF_POINTER("log_auth_goodpass", FR_TYPE_BOOL | FR_TYPE_DEPRECATED, &main_config.log_auth_goodpass) },
+ { FR_CONF_POINTER("log_stripped_names", FR_TYPE_BOOL | FR_TYPE_DEPRECATED, &log_stripped_names) },
{ FR_CONF_POINTER("security", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) security_config },
CONF_PARSER_TERMINATOR
{ FR_CONF_POINTER("group", FR_TYPE_STRING, &gid_name) },
#endif
{ FR_CONF_POINTER("chroot", FR_TYPE_STRING, &chroot_dir) },
- { FR_CONF_POINTER("allow_core_dumps", FR_TYPE_BOOLEAN, &allow_core_dumps), .dflt = "no" },
+ { FR_CONF_POINTER("allow_core_dumps", FR_TYPE_BOOL, &allow_core_dumps), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
{ FR_CONF_POINTER("group", FR_TYPE_STRING | FR_TYPE_DEPRECATED, &gid_name) },
#endif
{ FR_CONF_POINTER("chroot", FR_TYPE_STRING | FR_TYPE_DEPRECATED, &chroot_dir) },
- { FR_CONF_POINTER("allow_core_dumps", FR_TYPE_BOOLEAN | FR_TYPE_DEPRECATED, &allow_core_dumps) },
+ { FR_CONF_POINTER("allow_core_dumps", FR_TYPE_BOOL | FR_TYPE_DEPRECATED, &allow_core_dumps) },
CONF_PARSER_TERMINATOR
};
check->vp_strvalue);
break;
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
ret = vp->vp_byte - check->vp_byte;
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
ret = vp->vp_short - check->vp_short;
break;
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
ret = vp->vp_integer - check->vp_integer;
break;
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
/*
* Don't want integer overflow!
*/
}
break;
- case FR_TYPE_SIGNED:
+ case FR_TYPE_INT32:
if (vp->vp_signed < check->vp_signed) {
ret = -1;
} else if (vp->vp_signed > check->vp_signed) {
break;
}
- if (index_attr->type != FR_TYPE_INTEGER) {
+ if (index_attr->type != FR_TYPE_UINT32) {
fr_strerror_printf("Index is not a \"integer\"");
break;
}
slen = dict_print_attr_oid(p, end - p, parent, vp->da->parent);
if (slen < 0) return -1;
- if (vp->vp_type != FR_TYPE_INTEGER) {
+ if (vp->vp_type != FR_TYPE_UINT32) {
fr_strerror_printf("Index attribute \"%s\" is not of type \"integer\"", vp->da->name);
return -1;
}
* Map the proxy server configuration parameters to variables.
*/
static const CONF_PARSER proxy_config[] = {
- { FR_CONF_OFFSET("retry_delay", FR_TYPE_INTEGER, realm_config_t, retry_delay), .dflt = STRINGIFY(RETRY_DELAY) },
+ { FR_CONF_OFFSET("retry_delay", FR_TYPE_UINT32, realm_config_t, retry_delay), .dflt = STRINGIFY(RETRY_DELAY) },
- { FR_CONF_OFFSET("retry_count", FR_TYPE_INTEGER, realm_config_t, retry_count), .dflt = STRINGIFY(RETRY_COUNT) },
+ { FR_CONF_OFFSET("retry_count", FR_TYPE_UINT32, realm_config_t, retry_count), .dflt = STRINGIFY(RETRY_COUNT) },
- { FR_CONF_OFFSET("default_fallback", FR_TYPE_BOOLEAN, realm_config_t, fallback), .dflt = "no" },
+ { FR_CONF_OFFSET("default_fallback", FR_TYPE_BOOL, realm_config_t, fallback), .dflt = "no" },
- { FR_CONF_OFFSET("dynamic", FR_TYPE_BOOLEAN, realm_config_t, dynamic) },
+ { FR_CONF_OFFSET("dynamic", FR_TYPE_BOOL, realm_config_t, dynamic) },
- { FR_CONF_OFFSET("dead_time", FR_TYPE_INTEGER, realm_config_t, dead_time), .dflt = STRINGIFY(DEAD_TIME) },
+ { FR_CONF_OFFSET("dead_time", FR_TYPE_UINT32, realm_config_t, dead_time), .dflt = STRINGIFY(DEAD_TIME) },
- { FR_CONF_OFFSET("wake_all_if_all_dead", FR_TYPE_BOOLEAN, realm_config_t, wake_all_if_all_dead), .dflt = "no" },
+ { FR_CONF_OFFSET("wake_all_if_all_dead", FR_TYPE_BOOL, realm_config_t, wake_all_if_all_dead), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
#endif
#ifdef WITH_PROXY
static CONF_PARSER limit_config[] = {
- { FR_CONF_OFFSET("max_connections", FR_TYPE_INTEGER, home_server_t, limit.max_connections), .dflt = "16" },
- { FR_CONF_OFFSET("max_requests", FR_TYPE_INTEGER, home_server_t, limit.max_requests), .dflt = "0" },
- { FR_CONF_OFFSET("lifetime", FR_TYPE_INTEGER, home_server_t, limit.lifetime), .dflt = "0" },
- { FR_CONF_OFFSET("idle_timeout", FR_TYPE_INTEGER, home_server_t, limit.idle_timeout), .dflt = "0" },
+ { FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, home_server_t, limit.max_connections), .dflt = "16" },
+ { FR_CONF_OFFSET("max_requests", FR_TYPE_UINT32, home_server_t, limit.max_requests), .dflt = "0" },
+ { FR_CONF_OFFSET("lifetime", FR_TYPE_UINT32, home_server_t, limit.lifetime), .dflt = "0" },
+ { FR_CONF_OFFSET("idle_timeout", FR_TYPE_UINT32, home_server_t, limit.idle_timeout), .dflt = "0" },
CONF_PARSER_TERMINATOR
};
#ifdef WITH_COA
static CONF_PARSER home_server_coa[] = {
- { FR_CONF_OFFSET("irt", FR_TYPE_INTEGER, home_server_t, coa_irt), .dflt = STRINGIFY(2) },
- { FR_CONF_OFFSET("mrt", FR_TYPE_INTEGER, home_server_t, coa_mrt), .dflt = STRINGIFY(16) },
- { FR_CONF_OFFSET("mrc", FR_TYPE_INTEGER, home_server_t, coa_mrc), .dflt = STRINGIFY(5) },
- { FR_CONF_OFFSET("mrd", FR_TYPE_INTEGER, home_server_t, coa_mrd), .dflt = STRINGIFY(30) },
+ { FR_CONF_OFFSET("irt", FR_TYPE_UINT32, home_server_t, coa_irt), .dflt = STRINGIFY(2) },
+ { FR_CONF_OFFSET("mrt", FR_TYPE_UINT32, home_server_t, coa_mrt), .dflt = STRINGIFY(16) },
+ { FR_CONF_OFFSET("mrc", FR_TYPE_UINT32, home_server_t, coa_mrc), .dflt = STRINGIFY(5) },
+ { FR_CONF_OFFSET("mrd", FR_TYPE_UINT32, home_server_t, coa_mrd), .dflt = STRINGIFY(30) },
CONF_PARSER_TERMINATOR
};
#endif
{ FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, home_server_t, ipaddr) },
{ FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING | FR_TYPE_NOT_EMPTY, home_server_t, server) },
- { FR_CONF_OFFSET("port", FR_TYPE_SHORT, home_server_t, port), .dflt = "0" },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, home_server_t, port), .dflt = "0" },
{ FR_CONF_OFFSET("type", FR_TYPE_STRING, home_server_t, type_str) },
{ FR_CONF_OFFSET("src_ipaddr", FR_TYPE_STRING, home_server_t, src_ipaddr_str) },
{ FR_CONF_OFFSET("response_window", FR_TYPE_TIMEVAL, home_server_t, response_window), .dflt = "30" },
- { FR_CONF_OFFSET("response_timeouts", FR_TYPE_INTEGER, home_server_t, max_response_timeouts), .dflt = "1" },
- { FR_CONF_OFFSET("max_outstanding", FR_TYPE_INTEGER, home_server_t, max_outstanding), .dflt = "65536" },
+ { FR_CONF_OFFSET("response_timeouts", FR_TYPE_UINT32, home_server_t, max_response_timeouts), .dflt = "1" },
+ { FR_CONF_OFFSET("max_outstanding", FR_TYPE_UINT32, home_server_t, max_outstanding), .dflt = "65536" },
- { FR_CONF_OFFSET("zombie_period", FR_TYPE_INTEGER, home_server_t, zombie_period), .dflt = "40" },
+ { FR_CONF_OFFSET("zombie_period", FR_TYPE_UINT32, home_server_t, zombie_period), .dflt = "40" },
{ FR_CONF_OFFSET("status_check", FR_TYPE_STRING, home_server_t, ping_check_str), .dflt = "none" },
{ FR_CONF_OFFSET("ping_check", FR_TYPE_STRING, home_server_t, ping_check_str) },
- { FR_CONF_OFFSET("ping_interval", FR_TYPE_INTEGER, home_server_t, ping_interval), .dflt = "30" },
- { FR_CONF_OFFSET("check_interval", FR_TYPE_INTEGER, home_server_t, ping_interval) },
+ { FR_CONF_OFFSET("ping_interval", FR_TYPE_UINT32, home_server_t, ping_interval), .dflt = "30" },
+ { FR_CONF_OFFSET("check_interval", FR_TYPE_UINT32, home_server_t, ping_interval) },
- { FR_CONF_OFFSET("check_timeout", FR_TYPE_INTEGER, home_server_t, ping_timeout), .dflt = "4" },
- { FR_CONF_OFFSET("status_check_timeout", FR_TYPE_INTEGER, home_server_t, ping_timeout) },
+ { FR_CONF_OFFSET("check_timeout", FR_TYPE_UINT32, home_server_t, ping_timeout), .dflt = "4" },
+ { FR_CONF_OFFSET("status_check_timeout", FR_TYPE_UINT32, home_server_t, ping_timeout) },
- { FR_CONF_OFFSET("num_answers_to_alive", FR_TYPE_INTEGER, home_server_t, num_pings_to_alive), .dflt = "3" },
- { FR_CONF_OFFSET("revive_interval", FR_TYPE_INTEGER, home_server_t, revive_interval), .dflt = "300" },
+ { FR_CONF_OFFSET("num_answers_to_alive", FR_TYPE_UINT32, home_server_t, num_pings_to_alive), .dflt = "3" },
+ { FR_CONF_OFFSET("revive_interval", FR_TYPE_UINT32, home_server_t, revive_interval), .dflt = "300" },
{ FR_CONF_OFFSET("username", FR_TYPE_STRING | FR_TYPE_NOT_EMPTY, home_server_t, ping_user_name) },
{ FR_CONF_OFFSET("password", FR_TYPE_STRING | FR_TYPE_NOT_EMPTY, home_server_t, ping_user_password) },
#ifdef WITH_STATS
- { FR_CONF_OFFSET("historic_average_window", FR_TYPE_INTEGER, home_server_t, ema.window) },
+ { FR_CONF_OFFSET("historic_average_window", FR_TYPE_UINT32, home_server_t, ema.window) },
#endif
{ FR_CONF_POINTER("limit", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) limit_config },
{ FR_CONF_POINTER("coa", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) home_server_coa },
#endif
- { FR_CONF_OFFSET("self", FR_TYPE_BOOLEAN, home_server_t, is_ourself), },
+ { FR_CONF_OFFSET("self", FR_TYPE_BOOL, home_server_t, is_ourself), },
CONF_PARSER_TERMINATOR
};
struct timeval now;
struct timeval diff;
- rad_assert(map->da->type == FR_TYPE_INTEGER);
+ rad_assert(map->da->type == FR_TYPE_UINT32);
gettimeofday(&now, NULL);
fr_timeval_subtract(&diff, &now, &uptime);
struct timeval now;
struct timeval diff;
- rad_assert(map->da->type == FR_TYPE_INTEGER);
+ rad_assert(map->da->type == FR_TYPE_UINT32);
gettimeofday(&now, NULL);
fr_timeval_subtract(&diff, &now, &reset_time);
static int snmp_config_reset_get(UNUSED TALLOC_CTX *ctx, fr_value_box_t *out, NDEBUG_UNUSED fr_snmp_map_t const *map,
UNUSED void *snmp_ctx)
{
- rad_assert(map->da->type == FR_TYPE_INTEGER);
+ rad_assert(map->da->type == FR_TYPE_UINT32);
out->datum.integer = reset_state;
static int snmp_config_reset_set(NDEBUG_UNUSED fr_snmp_map_t const *map, UNUSED void *snmp_ctx, fr_value_box_t *in)
{
- rad_assert(map->da->type == FR_TYPE_INTEGER);
+ rad_assert(map->da->type == FR_TYPE_UINT32);
switch (in->datum.integer) {
case PW_RADIUS_AUTH_SERV_CONFIG_RESET_VALUE_RESET:
static int snmp_auth_stats_offset_get(UNUSED TALLOC_CTX *ctx, fr_value_box_t *out,
fr_snmp_map_t const *map, UNUSED void *snmp_ctx)
{
- rad_assert(map->da->type == FR_TYPE_INTEGER);
+ rad_assert(map->da->type == FR_TYPE_UINT32);
out->datum.integer = *(uint32_t *)((uint8_t *)(&radius_auth_stats) + map->offset);
RADCLIENT *client = snmp_ctx;
rad_assert(client);
- rad_assert(map->da->type == FR_TYPE_INTEGER);
+ rad_assert(map->da->type == FR_TYPE_UINT32);
out->datum.integer = *(uint32_t *)((uint8_t *)(&client->auth) + map->offset);
goto error;
}
- if (tlv_stack[depth]->type != FR_TYPE_INTEGER) {
+ if (tlv_stack[depth]->type != FR_TYPE_UINT32) {
fr_strerror_printf("Bad index attribute: Index attribute \"%s\" should be a integer, "
"but is a %s", tlv_stack[depth]->name,
fr_int2str(dict_attr_types, tlv_stack[depth]->type, "?Unknown?"));
* When retrieving client by number, also
* echo back it's IP address.
*/
- if ((vp->vp_type == FR_TYPE_INTEGER) &&
+ if ((vp->vp_type == FR_TYPE_UINT32) &&
(client->ipaddr.af == AF_INET)) {
vp = radius_pair_create(request->reply,
&request->reply->vps,
* A mapping of configuration file names to internal integers
*/
static const CONF_PARSER thread_config[] = {
- { FR_CONF_POINTER("start_servers", FR_TYPE_INTEGER, &thread_pool.start_threads), .dflt = "5" },
- { FR_CONF_POINTER("max_servers", FR_TYPE_INTEGER, &thread_pool.max_threads), .dflt = "32" },
- { FR_CONF_POINTER("min_spare_servers", FR_TYPE_INTEGER, &thread_pool.min_spare_threads), .dflt = "3" },
- { FR_CONF_POINTER("max_spare_servers", FR_TYPE_INTEGER, &thread_pool.max_spare_threads), .dflt = "10" },
- { FR_CONF_POINTER("max_requests_per_server", FR_TYPE_INTEGER, &thread_pool.max_requests_per_thread), .dflt = "0" },
- { FR_CONF_POINTER("cleanup_delay", FR_TYPE_INTEGER, &thread_pool.cleanup_delay), .dflt = "5" },
- { FR_CONF_POINTER("max_queue_size", FR_TYPE_INTEGER, &thread_pool.max_queue_size), .dflt = "65536" },
+ { FR_CONF_POINTER("start_servers", FR_TYPE_UINT32, &thread_pool.start_threads), .dflt = "5" },
+ { FR_CONF_POINTER("max_servers", FR_TYPE_UINT32, &thread_pool.max_threads), .dflt = "32" },
+ { FR_CONF_POINTER("min_spare_servers", FR_TYPE_UINT32, &thread_pool.min_spare_threads), .dflt = "3" },
+ { FR_CONF_POINTER("max_spare_servers", FR_TYPE_UINT32, &thread_pool.max_spare_threads), .dflt = "10" },
+ { FR_CONF_POINTER("max_requests_per_server", FR_TYPE_UINT32, &thread_pool.max_requests_per_thread), .dflt = "0" },
+ { FR_CONF_POINTER("cleanup_delay", FR_TYPE_UINT32, &thread_pool.cleanup_delay), .dflt = "5" },
+ { FR_CONF_POINTER("max_queue_size", FR_TYPE_UINT32, &thread_pool.max_queue_size), .dflt = "65536" },
{ FR_CONF_POINTER("queue_priority", FR_TYPE_STRING, &thread_pool.queue_priority), .dflt = NULL },
#ifdef WITH_STATS
#ifdef WITH_ACCOUNTING
- { FR_CONF_POINTER("auto_limit_acct", FR_TYPE_BOOLEAN, &thread_pool.auto_limit_acct) },
+ { FR_CONF_POINTER("auto_limit_acct", FR_TYPE_BOOL, &thread_pool.auto_limit_acct) },
#endif
#endif
CONF_PARSER_TERMINATOR
static CONF_PARSER cache_config[] = {
{ FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING, fr_tls_conf_t, session_cache_server) },
{ FR_CONF_OFFSET("name", FR_TYPE_STRING, fr_tls_conf_t, session_id_name) },
- { FR_CONF_OFFSET("lifetime", FR_TYPE_INTEGER, fr_tls_conf_t, session_cache_lifetime), .dflt = "86400" },
- { FR_CONF_OFFSET("verify", FR_TYPE_BOOLEAN, fr_tls_conf_t, session_cache_verify), .dflt = "no" },
+ { FR_CONF_OFFSET("lifetime", FR_TYPE_UINT32, fr_tls_conf_t, session_cache_lifetime), .dflt = "86400" },
+ { FR_CONF_OFFSET("verify", FR_TYPE_BOOL, fr_tls_conf_t, session_cache_verify), .dflt = "no" },
#if OPENSSL_VERSION_NUMBER >= 0x10100000L
- { FR_CONF_OFFSET("require_extended_master_secret", FR_TYPE_BOOLEAN, fr_tls_conf_t, session_cache_require_extms), .dflt = "yes" },
- { FR_CONF_OFFSET("require_perfect_forward_secrecy", FR_TYPE_BOOLEAN, fr_tls_conf_t, session_cache_require_pfs), .dflt = "no" },
+ { FR_CONF_OFFSET("require_extended_master_secret", FR_TYPE_BOOL, fr_tls_conf_t, session_cache_require_extms), .dflt = "yes" },
+ { FR_CONF_OFFSET("require_perfect_forward_secrecy", FR_TYPE_BOOL, fr_tls_conf_t, session_cache_require_pfs), .dflt = "no" },
#endif
- { FR_CONF_DEPRECATED("enable", FR_TYPE_BOOLEAN, fr_tls_conf_t, NULL) },
- { FR_CONF_DEPRECATED("max_entries", FR_TYPE_INTEGER, fr_tls_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("enable", FR_TYPE_BOOL, fr_tls_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("max_entries", FR_TYPE_UINT32, fr_tls_conf_t, NULL) },
{ FR_CONF_DEPRECATED("persist_dir", FR_TYPE_STRING, fr_tls_conf_t, NULL) },
CONF_PARSER_TERMINATOR
#ifdef HAVE_OPENSSL_OCSP_H
static CONF_PARSER ocsp_config[] = {
- { FR_CONF_OFFSET("enable", FR_TYPE_BOOLEAN, fr_tls_ocsp_conf_t, enable), .dflt = "no" },
+ { FR_CONF_OFFSET("enable", FR_TYPE_BOOL, fr_tls_ocsp_conf_t, enable), .dflt = "no" },
{ FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING, fr_tls_ocsp_conf_t, cache_server) },
- { FR_CONF_OFFSET("override_cert_url", FR_TYPE_BOOLEAN, fr_tls_ocsp_conf_t, override_url), .dflt = "no" },
+ { FR_CONF_OFFSET("override_cert_url", FR_TYPE_BOOL, fr_tls_ocsp_conf_t, override_url), .dflt = "no" },
{ FR_CONF_OFFSET("url", FR_TYPE_STRING, fr_tls_ocsp_conf_t, url) },
- { FR_CONF_OFFSET("use_nonce", FR_TYPE_BOOLEAN, fr_tls_ocsp_conf_t, use_nonce), .dflt = "yes" },
- { FR_CONF_OFFSET("timeout", FR_TYPE_INTEGER, fr_tls_ocsp_conf_t, timeout), .dflt = "yes" },
- { FR_CONF_OFFSET("softfail", FR_TYPE_BOOLEAN, fr_tls_ocsp_conf_t, softfail), .dflt = "no" },
+ { FR_CONF_OFFSET("use_nonce", FR_TYPE_BOOL, fr_tls_ocsp_conf_t, use_nonce), .dflt = "yes" },
+ { FR_CONF_OFFSET("timeout", FR_TYPE_UINT32, fr_tls_ocsp_conf_t, timeout), .dflt = "yes" },
+ { FR_CONF_OFFSET("softfail", FR_TYPE_BOOL, fr_tls_ocsp_conf_t, softfail), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
#endif
static CONF_PARSER tls_server_config[] = {
- { FR_CONF_OFFSET("verify_depth", FR_TYPE_INTEGER, fr_tls_conf_t, verify_depth), .dflt = "0" },
+ { FR_CONF_OFFSET("verify_depth", FR_TYPE_UINT32, fr_tls_conf_t, verify_depth), .dflt = "0" },
{ FR_CONF_OFFSET("ca_path", FR_TYPE_FILE_INPUT, fr_tls_conf_t, ca_path) },
- { FR_CONF_OFFSET("pem_file_type", FR_TYPE_BOOLEAN, fr_tls_conf_t, file_type), .dflt = "yes" },
+ { FR_CONF_OFFSET("pem_file_type", FR_TYPE_BOOL, fr_tls_conf_t, file_type), .dflt = "yes" },
{ FR_CONF_OFFSET("private_key_file", FR_TYPE_FILE_INPUT, fr_tls_conf_t, private_key_file) },
{ FR_CONF_OFFSET("certificate_file", FR_TYPE_FILE_INPUT, fr_tls_conf_t, certificate_file) },
{ FR_CONF_OFFSET("ca_file", FR_TYPE_FILE_INPUT, fr_tls_conf_t, ca_file) },
#endif
{ FR_CONF_OFFSET("dh_file", FR_TYPE_FILE_INPUT, fr_tls_conf_t, dh_file) },
{ FR_CONF_OFFSET("random_file", FR_TYPE_FILE_EXISTS, fr_tls_conf_t, random_file) },
- { FR_CONF_OFFSET("fragment_size", FR_TYPE_INTEGER, fr_tls_conf_t, fragment_size), .dflt = "1024" },
- { FR_CONF_OFFSET("auto_chain", FR_TYPE_BOOLEAN, fr_tls_conf_t, auto_chain), .dflt = "yes" },
- { FR_CONF_OFFSET("disable_single_dh_use", FR_TYPE_BOOLEAN, fr_tls_conf_t, disable_single_dh_use) },
- { FR_CONF_OFFSET("check_crl", FR_TYPE_BOOLEAN, fr_tls_conf_t, check_crl), .dflt = "no" },
+ { FR_CONF_OFFSET("fragment_size", FR_TYPE_UINT32, fr_tls_conf_t, fragment_size), .dflt = "1024" },
+ { FR_CONF_OFFSET("auto_chain", FR_TYPE_BOOL, fr_tls_conf_t, auto_chain), .dflt = "yes" },
+ { FR_CONF_OFFSET("disable_single_dh_use", FR_TYPE_BOOL, fr_tls_conf_t, disable_single_dh_use) },
+ { FR_CONF_OFFSET("check_crl", FR_TYPE_BOOL, fr_tls_conf_t, check_crl), .dflt = "no" },
#ifdef X509_V_FLAG_CRL_CHECK_ALL
- { FR_CONF_DEPRECATED("check_all_crl", FR_TYPE_BOOLEAN, fr_tls_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("check_all_crl", FR_TYPE_BOOL, fr_tls_conf_t, NULL) },
#endif
- { FR_CONF_OFFSET("allow_expired_crl", FR_TYPE_BOOLEAN, fr_tls_conf_t, allow_expired_crl) },
+ { FR_CONF_OFFSET("allow_expired_crl", FR_TYPE_BOOL, fr_tls_conf_t, allow_expired_crl) },
{ FR_CONF_OFFSET("check_cert_cn", FR_TYPE_STRING, fr_tls_conf_t, check_cert_cn) },
{ FR_CONF_OFFSET("cipher_list", FR_TYPE_STRING, fr_tls_conf_t, cipher_list) },
- { FR_CONF_OFFSET("cipher_server_preference", FR_TYPE_BOOLEAN, fr_tls_conf_t, cipher_server_preference), .dflt = "yes" },
+ { FR_CONF_OFFSET("cipher_server_preference", FR_TYPE_BOOL, fr_tls_conf_t, cipher_server_preference), .dflt = "yes" },
#ifdef SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS
- { FR_CONF_OFFSET("allow_renegotiation", FR_TYPE_BOOLEAN, fr_tls_conf_t, allow_renegotiation), .dflt = "no" },
+ { FR_CONF_OFFSET("allow_renegotiation", FR_TYPE_BOOL, fr_tls_conf_t, allow_renegotiation), .dflt = "no" },
#endif
{ FR_CONF_OFFSET("check_cert_issuer", FR_TYPE_STRING, fr_tls_conf_t, check_cert_issuer) },
- { FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOLEAN, fr_tls_conf_t, require_client_cert) },
+ { FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOL, fr_tls_conf_t, require_client_cert) },
#if OPENSSL_VERSION_NUMBER >= 0x0090800fL
#ifndef OPENSSL_NO_ECDH
#endif
#ifdef SSL_OP_NO_TLSv1
- { FR_CONF_OFFSET("disable_tlsv1", FR_TYPE_BOOLEAN, fr_tls_conf_t, disable_tlsv1) },
+ { FR_CONF_OFFSET("disable_tlsv1", FR_TYPE_BOOL, fr_tls_conf_t, disable_tlsv1) },
#endif
#ifdef SSL_OP_NO_TLSv1_1
- { FR_CONF_OFFSET("disable_tlsv1_1", FR_TYPE_BOOLEAN, fr_tls_conf_t, disable_tlsv1_1) },
+ { FR_CONF_OFFSET("disable_tlsv1_1", FR_TYPE_BOOL, fr_tls_conf_t, disable_tlsv1_1) },
#endif
#ifdef SSL_OP_NO_TLSv1_2
- { FR_CONF_OFFSET("disable_tlsv1_2", FR_TYPE_BOOLEAN, fr_tls_conf_t, disable_tlsv1_2) },
+ { FR_CONF_OFFSET("disable_tlsv1_2", FR_TYPE_BOOL, fr_tls_conf_t, disable_tlsv1_2) },
#endif
{ FR_CONF_POINTER("cache", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) cache_config },
};
static CONF_PARSER tls_client_config[] = {
- { FR_CONF_OFFSET("verify_depth", FR_TYPE_INTEGER, fr_tls_conf_t, verify_depth), .dflt = "0" },
+ { FR_CONF_OFFSET("verify_depth", FR_TYPE_UINT32, fr_tls_conf_t, verify_depth), .dflt = "0" },
{ FR_CONF_OFFSET("ca_path", FR_TYPE_FILE_INPUT, fr_tls_conf_t, ca_path) },
- { FR_CONF_OFFSET("pem_file_type", FR_TYPE_BOOLEAN, fr_tls_conf_t, file_type), .dflt = "yes" },
+ { FR_CONF_OFFSET("pem_file_type", FR_TYPE_BOOL, fr_tls_conf_t, file_type), .dflt = "yes" },
{ FR_CONF_OFFSET("private_key_file", FR_TYPE_FILE_INPUT, fr_tls_conf_t, private_key_file) },
{ FR_CONF_OFFSET("certificate_file", FR_TYPE_FILE_INPUT, fr_tls_conf_t, certificate_file) },
{ FR_CONF_OFFSET("ca_file", FR_TYPE_FILE_INPUT, fr_tls_conf_t, ca_file) },
{ FR_CONF_OFFSET("private_key_password", FR_TYPE_STRING | FR_TYPE_SECRET, fr_tls_conf_t, private_key_password) },
{ FR_CONF_OFFSET("dh_file", FR_TYPE_STRING, fr_tls_conf_t, dh_file) },
{ FR_CONF_OFFSET("random_file", FR_TYPE_STRING, fr_tls_conf_t, random_file) },
- { FR_CONF_OFFSET("fragment_size", FR_TYPE_INTEGER, fr_tls_conf_t, fragment_size), .dflt = "1024" },
- { FR_CONF_OFFSET("check_crl", FR_TYPE_BOOLEAN, fr_tls_conf_t, check_crl), .dflt = "no" },
+ { FR_CONF_OFFSET("fragment_size", FR_TYPE_UINT32, fr_tls_conf_t, fragment_size), .dflt = "1024" },
+ { FR_CONF_OFFSET("check_crl", FR_TYPE_BOOL, fr_tls_conf_t, check_crl), .dflt = "no" },
{ FR_CONF_OFFSET("check_cert_cn", FR_TYPE_STRING, fr_tls_conf_t, check_cert_cn) },
{ FR_CONF_OFFSET("cipher_list", FR_TYPE_STRING, fr_tls_conf_t, cipher_list) },
{ FR_CONF_OFFSET("check_cert_issuer", FR_TYPE_STRING, fr_tls_conf_t, check_cert_issuer) },
#endif
#ifdef SSL_OP_NO_TLSv1
- { FR_CONF_OFFSET("disable_tlsv1", FR_TYPE_BOOLEAN, fr_tls_conf_t, disable_tlsv1) },
+ { FR_CONF_OFFSET("disable_tlsv1", FR_TYPE_BOOL, fr_tls_conf_t, disable_tlsv1) },
#endif
#ifdef SSL_OP_NO_TLSv1_1
- { FR_CONF_OFFSET("disable_tlsv1_1", FR_TYPE_BOOLEAN, fr_tls_conf_t, disable_tlsv1_1) },
+ { FR_CONF_OFFSET("disable_tlsv1_1", FR_TYPE_BOOL, fr_tls_conf_t, disable_tlsv1_1) },
#endif
#ifdef SSL_OP_NO_TLSv1_2
- { FR_CONF_OFFSET("disable_tlsv1_2", FR_TYPE_BOOLEAN, fr_tls_conf_t, disable_tlsv1_2) },
+ { FR_CONF_OFFSET("disable_tlsv1_2", FR_TYPE_BOOL, fr_tls_conf_t, disable_tlsv1_2) },
#endif
CONF_PARSER_TERMINATOR
};
* select which frame is being used.
*/
if ((g->vpt->type == TMPL_TYPE_ATTR) &&
- ((g->vpt->tmpl_da->type == FR_TYPE_BYTE) ||
- (g->vpt->tmpl_da->type == FR_TYPE_SHORT) ||
- (g->vpt->tmpl_da->type == FR_TYPE_INTEGER) ||
- (g->vpt->tmpl_da->type == FR_TYPE_INTEGER64))) {
+ ((g->vpt->tmpl_da->type == FR_TYPE_UINT8) ||
+ (g->vpt->tmpl_da->type == FR_TYPE_UINT16) ||
+ (g->vpt->tmpl_da->type == FR_TYPE_UINT32) ||
+ (g->vpt->tmpl_da->type == FR_TYPE_UINT64))) {
VALUE_PAIR *vp;
slen = tmpl_find_vp(&vp, request, g->vpt);
}
switch (g->vpt->tmpl_da->type) {
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
start = ((uint32_t) vp->vp_byte) % g->num_children;
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
start = ((uint32_t) vp->vp_short) % g->num_children;
break;
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
start = vp->vp_integer % g->num_children;
break;
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
start = (uint32_t) (vp->vp_integer64 % ((uint64_t) g->num_children));
break;
memcpy(&int32, vp->vp_octets, vp->vp_length);
return snprintf(*out, outlen, "%i", htonl(int32));
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
return snprintf(*out, outlen, "%" PRIu64, vp->vp_integer64);
/*
case FR_TYPE_IPV4_PREFIX: /* Same addr field */
return snprintf(*out, outlen, "%u", htonl(vp->vp_ipv4addr));
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
return snprintf(*out, outlen, "%u", vp->vp_integer);
case FR_TYPE_DATE:
return snprintf(*out, outlen, "%u", vp->vp_date);
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
return snprintf(*out, outlen, "%u", (unsigned int) vp->vp_byte);
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
return snprintf(*out, outlen, "%u", (unsigned int) vp->vp_short);
/*
memcpy(&int64, vp->vp_ether, sizeof(vp->vp_ether));
return snprintf(*out, outlen, "%" PRIu64, htonll(int64));
- case FR_TYPE_SIGNED:
+ case FR_TYPE_INT32:
return snprintf(*out, outlen, "%i", vp->vp_signed);
case FR_TYPE_IPV6_ADDR:
/*
* Allow over-riding of variables per session.
*/
- rcode = cf_pair_parse(NULL, cs, "demand", FR_ITEM_POINTER(FR_TYPE_BOOLEAN, &flag), NULL, T_INVALID);
+ rcode = cf_pair_parse(NULL, cs, "demand", FR_ITEM_POINTER(FR_TYPE_BOOL, &flag), NULL, T_INVALID);
if (rcode == 0) {
session->demand_mode = flag;
}
- rcode = cf_pair_parse(NULL, cs, "min_transmit_interval", FR_ITEM_POINTER(FR_TYPE_INTEGER, &number), NULL, T_INVALID);
+ rcode = cf_pair_parse(NULL, cs, "min_transmit_interval", FR_ITEM_POINTER(FR_TYPE_UINT32, &number), NULL, T_INVALID);
if (rcode == 0) {
if (number < 100) number = 100;
if (number > 10000) number = 10000;
session->desired_min_tx_interval = number * 1000;
}
- rcode = cf_pair_parse(NULL, cs, "min_receive_interval", FR_ITEM_POINTER(FR_TYPE_INTEGER, &number), NULL, T_INVALID);
+ rcode = cf_pair_parse(NULL, cs, "min_receive_interval", FR_ITEM_POINTER(FR_TYPE_UINT32, &number), NULL, T_INVALID);
if (rcode == 0) {
if (number < 100) number = 100;
if (number > 10000) number = 10000;
session->required_min_rx_interval = number * 1000;
}
- rcode = cf_pair_parse(NULL, cs, "max_timeouts", FR_ITEM_POINTER(FR_TYPE_INTEGER, &number), NULL, T_INVALID);
+ rcode = cf_pair_parse(NULL, cs, "max_timeouts", FR_ITEM_POINTER(FR_TYPE_UINT32, &number), NULL, T_INVALID);
if (rcode == 0) {
if (number == 0) number = 1;
if (number > 10) number = 10;
ipaddr->af = AF_INET6;
}
- rcode = cf_pair_parse(NULL, cs, "port", FR_ITEM_POINTER(FR_TYPE_SHORT, port), "0", T_INVALID);
+ rcode = cf_pair_parse(NULL, cs, "port", FR_ITEM_POINTER(FR_TYPE_UINT16, port), "0", T_INVALID);
if (rcode < 0) return -1;
return 0;
cf_pair_parse(sock, cs, "interface", FR_ITEM_POINTER(FR_TYPE_STRING, &sock->interface), NULL, T_INVALID);
- cf_pair_parse(sock, cs, "min_receive_interval", FR_ITEM_POINTER(FR_TYPE_INTEGER, &sock->min_rx_interval), "1000", T_BARE_WORD);
- cf_pair_parse(sock, cs, "max_timeouts", FR_ITEM_POINTER(FR_TYPE_INTEGER, &sock->max_timeouts), "3", T_BARE_WORD);
- cf_pair_parse(sock, cs, "demand", FR_ITEM_POINTER(FR_TYPE_BOOLEAN, &sock->demand), "no", T_DOUBLE_QUOTED_STRING);
+ cf_pair_parse(sock, cs, "min_receive_interval", FR_ITEM_POINTER(FR_TYPE_UINT32, &sock->min_rx_interval), "1000", T_BARE_WORD);
+ cf_pair_parse(sock, cs, "max_timeouts", FR_ITEM_POINTER(FR_TYPE_UINT32, &sock->max_timeouts), "3", T_BARE_WORD);
+ cf_pair_parse(sock, cs, "demand", FR_ITEM_POINTER(FR_TYPE_BOOL, &sock->demand), "no", T_DOUBLE_QUOTED_STRING);
cf_pair_parse(NULL, cs, "auth_type", FR_ITEM_POINTER(FR_TYPE_STRING, &auth_type_str), NULL, T_INVALID);
if (!this->server) {
static const CONF_PARSER detail_config[] = {
{ FR_CONF_OFFSET("detail", FR_TYPE_FILE_OUTPUT | FR_TYPE_DEPRECATED, listen_detail_t, filename) },
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_OUTPUT | FR_TYPE_REQUIRED, listen_detail_t, filename) },
- { FR_CONF_OFFSET("load_factor", FR_TYPE_INTEGER, listen_detail_t, load_factor), .dflt = STRINGIFY(10) },
- { FR_CONF_OFFSET("poll_interval", FR_TYPE_INTEGER, listen_detail_t, poll_interval), .dflt = STRINGIFY(1) },
- { FR_CONF_OFFSET("retry_interval", FR_TYPE_INTEGER, listen_detail_t, retry_interval), .dflt = STRINGIFY(30) },
- { FR_CONF_OFFSET("one_shot", FR_TYPE_BOOLEAN, listen_detail_t, one_shot), .dflt = "no" },
- { FR_CONF_OFFSET("track", FR_TYPE_BOOLEAN, listen_detail_t, track), .dflt = "no" },
+ { FR_CONF_OFFSET("load_factor", FR_TYPE_UINT32, listen_detail_t, load_factor), .dflt = STRINGIFY(10) },
+ { FR_CONF_OFFSET("poll_interval", FR_TYPE_UINT32, listen_detail_t, poll_interval), .dflt = STRINGIFY(1) },
+ { FR_CONF_OFFSET("retry_interval", FR_TYPE_UINT32, listen_detail_t, retry_interval), .dflt = STRINGIFY(30) },
+ { FR_CONF_OFFSET("one_shot", FR_TYPE_BOOL, listen_detail_t, one_shot), .dflt = "no" },
+ { FR_CONF_OFFSET("track", FR_TYPE_BOOL, listen_detail_t, track), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
* Could be an array of bytes, integers, etc.
*/
if (da->flags.array) switch (da->type) {
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
num_entries = len;
*out = 1;
break;
- case FR_TYPE_SHORT: /* ignore any trailing data */
+ case FR_TYPE_UINT16: /* ignore any trailing data */
num_entries = len >> 1;
*out = 2;
break;
case FR_TYPE_IPV4_ADDR:
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
case FR_TYPE_DATE: /* ignore any trailing data */
num_entries = len >> 2;
*out = 4;
if (da->flags.is_unknown) talloc_steal(vp, da);
switch (da->type) {
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
if (data_len != 1) goto raw;
vp->vp_byte = p[0];
p++;
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
if (data_len != 2) goto raw;
memcpy(&vp->vp_short, p, 2);
vp->vp_short = ntohs(vp->vp_short);
p += 2;
break;
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
if (data_len != 4) goto raw;
memcpy(&vp->vp_integer, p, 4);
vp->vp_integer = ntohl(vp->vp_integer);
}
switch (vp->vp_type) {
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
vp->vp_byte = p[0];
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
vp->vp_short = (p[0] << 8) | p[1];
break;
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
memcpy(&vp->vp_integer, p, 4);
vp->vp_integer = ntohl(vp->vp_integer);
break;
if (outlen < vp->vp_length) return 0;
switch (tlv_stack[depth]->type) {
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
p[0] = vp->vp_byte;
p ++;
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
p[0] = (vp->vp_short >> 8) & 0xff;
p[1] = vp->vp_short & 0xff;
p += 2;
break;
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
lvalue = htonl(vp->vp_integer);
memcpy(p, &lvalue, 4);
p += 4;
cp = cf_pair_find(cs, "suppress_responses");
if (cp) {
rcode = cf_pair_parse(sock, cs, "suppress_responses",
- FR_ITEM_POINTER(FR_TYPE_BOOLEAN, &sock->suppress_responses), NULL, T_INVALID);
+ FR_ITEM_POINTER(FR_TYPE_BOOL, &sock->suppress_responses), NULL, T_INVALID);
if (rcode < 0) return -1;
}
{ FR_CONF_OFFSET("attrs", FR_TYPE_STRING | FR_TYPE_MULTI, sync_config_t, attrs) },
- { FR_CONF_OFFSET("allow_refresh", FR_TYPE_BOOLEAN, sync_config_t, allow_refresh), .dflt = "no" },
+ { FR_CONF_OFFSET("allow_refresh", FR_TYPE_BOOL, sync_config_t, allow_refresh), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
static CONF_PARSER option_config[] = {
#ifdef LDAP_OPT_X_KEEPALIVE_IDLE
- { FR_CONF_OFFSET("idle", FR_TYPE_INTEGER, fr_ldap_handle_config_t, keepalive_idle), .dflt = "60" },
+ { FR_CONF_OFFSET("idle", FR_TYPE_UINT32, fr_ldap_handle_config_t, keepalive_idle), .dflt = "60" },
#endif
#ifdef LDAP_OPT_X_KEEPALIVE_PROBES
- { FR_CONF_OFFSET("probes", FR_TYPE_INTEGER, fr_ldap_handle_config_t, keepalive_probes), .dflt = "3" },
+ { FR_CONF_OFFSET("probes", FR_TYPE_UINT32, fr_ldap_handle_config_t, keepalive_probes), .dflt = "3" },
#endif
#ifdef LDAP_OPT_X_KEEPALIVE_INTERVAL
- { FR_CONF_OFFSET("interval", FR_TYPE_INTEGER, fr_ldap_handle_config_t, keepalive_interval), .dflt = "30" },
+ { FR_CONF_OFFSET("interval", FR_TYPE_UINT32, fr_ldap_handle_config_t, keepalive_interval), .dflt = "30" },
#endif
{ FR_CONF_OFFSET("dereference", FR_TYPE_STRING, fr_ldap_handle_config_t, dereference_str) },
/* allow server unlimited time for search (server-side limit) */
- { FR_CONF_OFFSET("srv_timelimit", FR_TYPE_INTEGER, fr_ldap_handle_config_t, srv_timelimit), .dflt = "20" },
+ { FR_CONF_OFFSET("srv_timelimit", FR_TYPE_UINT32, fr_ldap_handle_config_t, srv_timelimit), .dflt = "20" },
/* timeout for search results */
{ FR_CONF_OFFSET("res_timeout", FR_TYPE_TIMEVAL, fr_ldap_handle_config_t, res_timeout), .dflt = "20" },
#ifdef LDAP_OPT_NETWORK_TIMEOUT
/* timeout on network activity */
- { FR_CONF_DEPRECATED("net_timeout", FR_TYPE_INTEGER, fr_ldap_handle_config_t, net_timeout), .dflt = "10" },
+ { FR_CONF_DEPRECATED("net_timeout", FR_TYPE_UINT32, fr_ldap_handle_config_t, net_timeout), .dflt = "10" },
#endif
CONF_PARSER_TERMINATOR
static const CONF_PARSER global_config[] = {
{ FR_CONF_OFFSET("random_file", FR_TYPE_FILE_EXISTS, proto_ldap_inst_t, tls_random_file) },
- { FR_CONF_OFFSET("ldap_debug", FR_TYPE_INTEGER, proto_ldap_inst_t, ldap_debug), .dflt = "0x0000" }, /* Debugging flags to the server */
+ { FR_CONF_OFFSET("ldap_debug", FR_TYPE_UINT32, proto_ldap_inst_t, ldap_debug), .dflt = "0x0000" }, /* Debugging flags to the server */
CONF_PARSER_TERMINATOR
};
{ FR_CONF_OFFSET("ca_path", FR_TYPE_FILE_INPUT, fr_ldap_handle_config_t, tls_ca_path) },
{ FR_CONF_OFFSET("certificate_file", FR_TYPE_FILE_INPUT, fr_ldap_handle_config_t, tls_certificate_file) },
{ FR_CONF_OFFSET("private_key_file", FR_TYPE_FILE_INPUT, fr_ldap_handle_config_t, tls_private_key_file) },
- { FR_CONF_OFFSET("start_tls", FR_TYPE_BOOLEAN, fr_ldap_handle_config_t, start_tls), .dflt = "no" },
+ { FR_CONF_OFFSET("start_tls", FR_TYPE_BOOL, fr_ldap_handle_config_t, start_tls), .dflt = "no" },
{ FR_CONF_OFFSET("require_cert", FR_TYPE_STRING, fr_ldap_handle_config_t, tls_require_cert_str) },
CONF_PARSER_TERMINATOR
* LDAP server definition
*/
{ FR_CONF_OFFSET("server", FR_TYPE_STRING | FR_TYPE_MULTI | FR_TYPE_REQUIRED, proto_ldap_inst_t, handle_config.server_str) },
- { FR_CONF_OFFSET("port", FR_TYPE_SHORT, proto_ldap_inst_t, handle_config.port) },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, proto_ldap_inst_t, handle_config.port) },
{ FR_CONF_OFFSET("identity", FR_TYPE_STRING, proto_ldap_inst_t, handle_config.admin_identity) },
{ FR_CONF_OFFSET("password", FR_TYPE_STRING | FR_TYPE_SECRET, proto_ldap_inst_t, handle_config.admin_password) },
{ FR_CONF_OFFSET("sasl", FR_TYPE_SUBSECTION, proto_ldap_inst_t, handle_config.admin_sasl), .subcs = (void const *) sasl_mech_static },
*/
static const CONF_PARSER module_config[] = {
{ FR_CONF_OFFSET("rcode", FR_TYPE_STRING, rlm_always_t, rcode_str), .dflt = "fail" },
- { FR_CONF_OFFSET("simulcount", FR_TYPE_INTEGER, rlm_always_t, simulcount), .dflt = "0" },
- { FR_CONF_OFFSET("mpp", FR_TYPE_BOOLEAN, rlm_always_t, mpp), .dflt = "no" },
+ { FR_CONF_OFFSET("simulcount", FR_TYPE_UINT32, rlm_always_t, simulcount), .dflt = "0" },
+ { FR_CONF_OFFSET("mpp", FR_TYPE_BOOL, rlm_always_t, mpp), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER module_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT | FR_TYPE_REQUIRED, rlm_attr_filter_t, filename) },
{ FR_CONF_OFFSET("key", FR_TYPE_TMPL, rlm_attr_filter_t, key), .dflt = "&Realm", .quote = T_BARE_WORD },
- { FR_CONF_OFFSET("relaxed", FR_TYPE_BOOLEAN, rlm_attr_filter_t, relaxed), .dflt = "no" },
+ { FR_CONF_OFFSET("relaxed", FR_TYPE_BOOL, rlm_attr_filter_t, relaxed), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER module_config[] = {
{ FR_CONF_OFFSET("driver", FR_TYPE_STRING, rlm_cache_config_t, driver_name), .dflt = "rlm_cache_rbtree" },
{ FR_CONF_OFFSET("key", FR_TYPE_TMPL | FR_TYPE_REQUIRED, rlm_cache_config_t, key) },
- { FR_CONF_OFFSET("ttl", FR_TYPE_INTEGER, rlm_cache_config_t, ttl), .dflt = "500" },
- { FR_CONF_OFFSET("max_entries", FR_TYPE_INTEGER, rlm_cache_config_t, max_entries), .dflt = "0" },
+ { FR_CONF_OFFSET("ttl", FR_TYPE_UINT32, rlm_cache_config_t, ttl), .dflt = "500" },
+ { FR_CONF_OFFSET("max_entries", FR_TYPE_UINT32, rlm_cache_config_t, max_entries), .dflt = "0" },
/* Should be a type which matches time_t, @fixme before 2038 */
- { FR_CONF_OFFSET("epoch", FR_TYPE_SIGNED, rlm_cache_config_t, epoch), .dflt = "0" },
- { FR_CONF_OFFSET("add_stats", FR_TYPE_BOOLEAN, rlm_cache_config_t, stats), .dflt = "no" },
+ { FR_CONF_OFFSET("epoch", FR_TYPE_INT32, rlm_cache_config_t, epoch), .dflt = "0" },
+ { FR_CONF_OFFSET("add_stats", FR_TYPE_BOOL, rlm_cache_config_t, stats), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
unsigned int i;
switch (vp->vp_type) {
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
i = vp->vp_integer;
goto print_int;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
i = vp->vp_short;
goto print_int;
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
i = vp->vp_byte;
print_int:
return json_object_new_int(i);
#endif
- case FR_TYPE_SIGNED:
+ case FR_TYPE_INT32:
#ifdef HAVE_JSON_OBJECT_NEW_INT64
/* debug */
RDEBUG3("creating new int64 for signed 32 bit integer '%s'", vp->da->name);
return json_object_new_int(vp->vp_signed);
#endif
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
#ifdef HAVE_JSON_OBJECT_NEW_INT64
/* debug */
RDEBUG3("creating new int64 for 64 bit integer '%s'", vp->da->name);
#ifdef WITH_ACCOUNTING
{ FR_CONF_OFFSET("acct_key", FR_TYPE_TMPL, rlm_couchbase_t, acct_key), .dflt = "radacct_%{%{Acct-Unique-Session-Id}:-%{Acct-Session-Id}}", .quote = T_DOUBLE_QUOTED_STRING },
{ FR_CONF_OFFSET("doctype", FR_TYPE_STRING, rlm_couchbase_t, doctype), .dflt = "radacct" },
- { FR_CONF_OFFSET("expire", FR_TYPE_INTEGER, rlm_couchbase_t, expire), .dflt = 0 },
+ { FR_CONF_OFFSET("expire", FR_TYPE_UINT32, rlm_couchbase_t, expire), .dflt = 0 },
#endif
{ FR_CONF_OFFSET("user_key", FR_TYPE_TMPL, rlm_couchbase_t, user_key), .dflt = "raduser_%{md5:%{tolower:%{%{Stripped-User-Name}:-%{User-Name}}}}", .quote = T_DOUBLE_QUOTED_STRING },
- { FR_CONF_OFFSET("read_clients", FR_TYPE_BOOLEAN, rlm_couchbase_t, read_clients) }, /* NULL defaults to "no" */
+ { FR_CONF_OFFSET("read_clients", FR_TYPE_BOOL, rlm_couchbase_t, read_clients) }, /* NULL defaults to "no" */
{ FR_CONF_POINTER("client", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) client_config },
#ifdef WITH_SESSION_MGMT
- { FR_CONF_OFFSET("check_simul", FR_TYPE_BOOLEAN, rlm_couchbase_t, check_simul) }, /* NULL defaults to "no" */
+ { FR_CONF_OFFSET("check_simul", FR_TYPE_BOOL, rlm_couchbase_t, check_simul) }, /* NULL defaults to "no" */
{ FR_CONF_OFFSET("simul_view", FR_TYPE_STRING, rlm_couchbase_t, simul_view), .dflt = "_design/acct/_view/by_user" },
{ FR_CONF_OFFSET("simul_vkey", FR_TYPE_TMPL, rlm_couchbase_t, simul_vkey), .dflt = "%{tolower:%{%{Stripped-User-Name}:-%{User-Name}}}", .quote = T_DOUBLE_QUOTED_STRING },
- { FR_CONF_OFFSET("verify_simul", FR_TYPE_BOOLEAN, rlm_couchbase_t, verify_simul) }, /* NULL defaults to "no" */
+ { FR_CONF_OFFSET("verify_simul", FR_TYPE_BOOL, rlm_couchbase_t, verify_simul) }, /* NULL defaults to "no" */
#endif
CONF_PARSER_TERMINATOR
};
date = vp->vp_date;
goto encode;
- case FR_TYPE_INTEGER:
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT32:
+ case FR_TYPE_UINT64:
date = (time_t) vp->vp_integer;
encode:
*/
static const CONF_PARSER module_config[] = {
{ FR_CONF_OFFSET("delay", FR_TYPE_TMPL, rlm_delay_t, delay) },
- { FR_CONF_OFFSET("relative", FR_TYPE_BOOLEAN, rlm_delay_t, relative), .dflt = "no" },
- { FR_CONF_OFFSET("force_reschedule", FR_TYPE_BOOLEAN, rlm_delay_t, force_reschedule), .dflt = "no" },
+ { FR_CONF_OFFSET("relative", FR_TYPE_BOOL, rlm_delay_t, relative), .dflt = "no" },
+ { FR_CONF_OFFSET("force_reschedule", FR_TYPE_BOOL, rlm_delay_t, force_reschedule), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER module_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_OUTPUT | FR_TYPE_REQUIRED | FR_TYPE_XLAT, rlm_detail_t, filename), .dflt = "%A/%{Client-IP-Address}/detail" },
{ FR_CONF_OFFSET("header", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_detail_t, header), .dflt = "%t" },
- { FR_CONF_OFFSET("permissions", FR_TYPE_INTEGER, rlm_detail_t, perm), .dflt = "0600" },
+ { FR_CONF_OFFSET("permissions", FR_TYPE_UINT32, rlm_detail_t, perm), .dflt = "0600" },
{ FR_CONF_OFFSET("group", FR_TYPE_STRING, rlm_detail_t, group) },
- { FR_CONF_OFFSET("locking", FR_TYPE_BOOLEAN, rlm_detail_t, locking), .dflt = "no" },
- { FR_CONF_OFFSET("escape_filenames", FR_TYPE_BOOLEAN, rlm_detail_t, escape), .dflt = "no" },
- { FR_CONF_OFFSET("log_packet_header", FR_TYPE_BOOLEAN, rlm_detail_t, log_srcdst), .dflt = "no" },
+ { FR_CONF_OFFSET("locking", FR_TYPE_BOOL, rlm_detail_t, locking), .dflt = "no" },
+ { FR_CONF_OFFSET("escape_filenames", FR_TYPE_BOOL, rlm_detail_t, escape), .dflt = "no" },
+ { FR_CONF_OFFSET("log_packet_header", FR_TYPE_BOOL, rlm_detail_t, log_srcdst), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
case FR_TYPE_OCTETS:
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
if (attr_len != 2) goto raw;
break;
* | AT_<BOOL> | Length = 1 | Reserved |
* +---------------+---------------+-------------------------------+
*/
- case FR_TYPE_BOOLEAN:
+ case FR_TYPE_BOOL:
vp->vp_bool = true;
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
vp->vp_short = (p[0] << 8) | p[1];
break;
* | AT_<BOOL> | Length = 1 | Reserved |
* +---------------+---------------+-------------------------------+
*/
- case FR_TYPE_BOOLEAN:
+ case FR_TYPE_BOOL:
break;
/*
* | AT_<SHORT> | Length = 1 | Short 1 | Short 2 |
* +---------------+---------------+-------------------------------+
*/
- case FR_TYPE_BYTE: //!< 8 Bit unsigned integer.
- case FR_TYPE_SHORT: //!< 16 Bit unsigned integer.
- case FR_TYPE_INTEGER: //!< 32 Bit unsigned integer.
- case FR_TYPE_INTEGER64: //!< 64 Bit unsigned integer.
- case FR_TYPE_SIGNED: //!< 32 Bit signed integer.
+ case FR_TYPE_UINT8: //!< 8 Bit unsigned integer.
+ case FR_TYPE_UINT16: //!< 16 Bit unsigned integer.
+ case FR_TYPE_UINT32: //!< 32 Bit unsigned integer.
+ case FR_TYPE_UINT64: //!< 64 Bit unsigned integer.
+ case FR_TYPE_INT32: //!< 32 Bit signed integer.
{
fr_value_box_t data;
static const CONF_PARSER module_config[] = {
{ FR_CONF_OFFSET("default_eap_type", FR_TYPE_STRING, rlm_eap_config_t, default_method_name), .dflt = "md5" },
- { FR_CONF_DEPRECATED("timer_expire", FR_TYPE_INTEGER, rlm_eap_config_t, timer_limit), .dflt = "60" },
- { FR_CONF_OFFSET("ignore_unknown_eap_types", FR_TYPE_BOOLEAN, rlm_eap_config_t, ignore_unknown_types), .dflt = "no" },
- { FR_CONF_OFFSET("cisco_accounting_username_bug", FR_TYPE_BOOLEAN, rlm_eap_config_t,
+ { FR_CONF_DEPRECATED("timer_expire", FR_TYPE_UINT32, rlm_eap_config_t, timer_limit), .dflt = "60" },
+ { FR_CONF_OFFSET("ignore_unknown_eap_types", FR_TYPE_BOOL, rlm_eap_config_t, ignore_unknown_types), .dflt = "no" },
+ { FR_CONF_OFFSET("cisco_accounting_username_bug", FR_TYPE_BOOL, rlm_eap_config_t,
cisco_accounting_username_bug), .dflt = "no" },
- { FR_CONF_DEPRECATED("max_sessions", FR_TYPE_INTEGER, rlm_eap_config_t, max_sessions), .dflt = "2048" },
+ { FR_CONF_DEPRECATED("max_sessions", FR_TYPE_UINT32, rlm_eap_config_t, max_sessions), .dflt = "2048" },
CONF_PARSER_TERMINATOR
};
{ FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING | FR_TYPE_REQUIRED | FR_TYPE_NOT_EMPTY, rlm_eap_fast_t, virtual_server) },
- { FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOLEAN, rlm_eap_fast_t, req_client_cert), .dflt = "no" },
+ { FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOL, rlm_eap_fast_t, req_client_cert), .dflt = "no" },
- { FR_CONF_OFFSET("pac_lifetime", FR_TYPE_INTEGER, rlm_eap_fast_t, pac_lifetime), .dflt = "604800" },
+ { FR_CONF_OFFSET("pac_lifetime", FR_TYPE_UINT32, rlm_eap_fast_t, pac_lifetime), .dflt = "604800" },
{ FR_CONF_OFFSET("authority_identity", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_eap_fast_t, authority_identity) },
{ FR_CONF_OFFSET("pac_opaque_key", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_eap_fast_t, pac_opaque_key) },
} rlm_eap_mschapv2_t;
static CONF_PARSER submodule_config[] = {
- { FR_CONF_OFFSET("with_ntdomain_hack", FR_TYPE_BOOLEAN, rlm_eap_mschapv2_t, with_ntdomain_hack), .dflt = "no" },
+ { FR_CONF_OFFSET("with_ntdomain_hack", FR_TYPE_BOOL, rlm_eap_mschapv2_t, with_ntdomain_hack), .dflt = "no" },
- { FR_CONF_OFFSET("send_error", FR_TYPE_BOOLEAN, rlm_eap_mschapv2_t, send_error), .dflt = "no" },
+ { FR_CONF_OFFSET("send_error", FR_TYPE_BOOL, rlm_eap_mschapv2_t, send_error), .dflt = "no" },
{ FR_CONF_OFFSET("identity", FR_TYPE_STRING, rlm_eap_mschapv2_t, identity) },
CONF_PARSER_TERMINATOR
};
{ FR_CONF_OFFSET("inner_eap_module", FR_TYPE_STRING, rlm_eap_peap_t, inner_eap_module), },
- { FR_CONF_DEPRECATED("copy_request_to_tunnel", FR_TYPE_BOOLEAN, rlm_eap_peap_t, NULL), .dflt = "no" },
+ { FR_CONF_DEPRECATED("copy_request_to_tunnel", FR_TYPE_BOOL, rlm_eap_peap_t, NULL), .dflt = "no" },
- { FR_CONF_DEPRECATED("use_tunneled_reply", FR_TYPE_BOOLEAN, rlm_eap_peap_t, NULL), .dflt = "no" },
+ { FR_CONF_DEPRECATED("use_tunneled_reply", FR_TYPE_BOOL, rlm_eap_peap_t, NULL), .dflt = "no" },
#ifdef WITH_PROXY
- { FR_CONF_OFFSET("proxy_tunneled_request_as_eap", FR_TYPE_BOOLEAN, rlm_eap_peap_t, proxy_tunneled_request_as_eap), .dflt = "yes" },
+ { FR_CONF_OFFSET("proxy_tunneled_request_as_eap", FR_TYPE_BOOL, rlm_eap_peap_t, proxy_tunneled_request_as_eap), .dflt = "yes" },
#endif
{ FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING | FR_TYPE_REQUIRED | FR_TYPE_NOT_EMPTY, rlm_eap_peap_t, virtual_server) },
- { FR_CONF_OFFSET("soh", FR_TYPE_BOOLEAN, rlm_eap_peap_t, soh), .dflt = "no" },
+ { FR_CONF_OFFSET("soh", FR_TYPE_BOOL, rlm_eap_peap_t, soh), .dflt = "no" },
- { FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOLEAN, rlm_eap_peap_t, req_client_cert), .dflt = "no" },
+ { FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOL, rlm_eap_peap_t, req_client_cert), .dflt = "no" },
{ FR_CONF_OFFSET("soh_virtual_server", FR_TYPE_STRING, rlm_eap_peap_t, soh_virtual_server) },
CONF_PARSER_TERMINATOR
#define MSK_EMSK_LEN (2 * MPPE_KEY_LEN)
static CONF_PARSER submodule_config[] = {
- { FR_CONF_OFFSET("group", FR_TYPE_INTEGER, rlm_eap_pwd_t, group), .dflt = "19" },
- { FR_CONF_OFFSET("fragment_size", FR_TYPE_INTEGER, rlm_eap_pwd_t, fragment_size), .dflt = "1020" },
+ { FR_CONF_OFFSET("group", FR_TYPE_UINT32, rlm_eap_pwd_t, group), .dflt = "19" },
+ { FR_CONF_OFFSET("fragment_size", FR_TYPE_UINT32, rlm_eap_pwd_t, fragment_size), .dflt = "1020" },
{ FR_CONF_OFFSET("server_id", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_eap_pwd_t, server_id) },
CONF_PARSER_TERMINATOR
};
static CONF_PARSER submodule_config[] = {
{ FR_CONF_OFFSET("tls", FR_TYPE_STRING, rlm_eap_tls_t, tls_conf_name) },
- { FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOLEAN, rlm_eap_tls_t, req_client_cert), .dflt = "yes" },
- { FR_CONF_OFFSET("include_length", FR_TYPE_BOOLEAN, rlm_eap_tls_t, include_length), .dflt = "yes" },
+ { FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOL, rlm_eap_tls_t, req_client_cert), .dflt = "yes" },
+ { FR_CONF_OFFSET("include_length", FR_TYPE_BOOL, rlm_eap_tls_t, include_length), .dflt = "yes" },
{ FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING, rlm_eap_tls_t, virtual_server) },
CONF_PARSER_TERMINATOR
};
static CONF_PARSER submodule_config[] = {
{ FR_CONF_OFFSET("tls", FR_TYPE_STRING, rlm_eap_ttls_t, tls_conf_name) },
- { FR_CONF_DEPRECATED("copy_request_to_tunnel", FR_TYPE_BOOLEAN, rlm_eap_ttls_t, NULL), .dflt = "no" },
- { FR_CONF_DEPRECATED("use_tunneled_reply", FR_TYPE_BOOLEAN, rlm_eap_ttls_t, NULL), .dflt = "no" },
+ { FR_CONF_DEPRECATED("copy_request_to_tunnel", FR_TYPE_BOOL, rlm_eap_ttls_t, NULL), .dflt = "no" },
+ { FR_CONF_DEPRECATED("use_tunneled_reply", FR_TYPE_BOOL, rlm_eap_ttls_t, NULL), .dflt = "no" },
{ FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING | FR_TYPE_REQUIRED | FR_TYPE_NOT_EMPTY, rlm_eap_ttls_t, virtual_server) },
- { FR_CONF_OFFSET("include_length", FR_TYPE_BOOLEAN, rlm_eap_ttls_t, include_length), .dflt = "yes" },
- { FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOLEAN, rlm_eap_ttls_t, req_client_cert), .dflt = "no" },
+ { FR_CONF_OFFSET("include_length", FR_TYPE_BOOL, rlm_eap_ttls_t, include_length), .dflt = "yes" },
+ { FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOL, rlm_eap_ttls_t, req_client_cert), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
}
switch (vp->vp_type) {
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
case FR_TYPE_DATE:
attr = htonl(vp->vp_integer); /* stored in host order */
memcpy(p, &attr, sizeof(attr));
length = 4;
break;
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
attr64 = htonll(vp->vp_integer64); /* stored in host order */
memcpy(p, &attr64, sizeof(attr64));
length = 8;
* A mapping of configuration file names to internal variables.
*/
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("integer", FR_TYPE_INTEGER, rlm_example_t, value), .dflt = "1" },
- { FR_CONF_OFFSET("boolean", FR_TYPE_BOOLEAN, rlm_example_t, boolean), .dflt = "no" },
+ { FR_CONF_OFFSET("integer", FR_TYPE_UINT32, rlm_example_t, value), .dflt = "1" },
+ { FR_CONF_OFFSET("boolean", FR_TYPE_BOOL, rlm_example_t, boolean), .dflt = "no" },
{ FR_CONF_OFFSET("string", FR_TYPE_STRING, rlm_example_t, string) },
{ FR_CONF_OFFSET("ipaddr", FR_TYPE_IPV4_ADDR, rlm_example_t, ipaddr), .dflt = "*" },
CONF_PARSER_TERMINATOR
} rlm_exec_t;
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("wait", FR_TYPE_BOOLEAN, rlm_exec_t, wait), .dflt = "yes" },
+ { FR_CONF_OFFSET("wait", FR_TYPE_BOOL, rlm_exec_t, wait), .dflt = "yes" },
{ FR_CONF_OFFSET("program", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_exec_t, program) },
{ FR_CONF_OFFSET("input_pairs", FR_TYPE_STRING, rlm_exec_t, input) },
{ FR_CONF_OFFSET("output_pairs", FR_TYPE_STRING, rlm_exec_t, output) },
{ FR_CONF_OFFSET("packet_type", FR_TYPE_STRING, rlm_exec_t, packet_type) },
- { FR_CONF_OFFSET("shell_escape", FR_TYPE_BOOLEAN, rlm_exec_t, shell_escape), .dflt = "yes" },
- { FR_CONF_OFFSET("timeout", FR_TYPE_INTEGER, rlm_exec_t, timeout) },
+ { FR_CONF_OFFSET("shell_escape", FR_TYPE_BOOL, rlm_exec_t, shell_escape), .dflt = "yes" },
+ { FR_CONF_OFFSET("timeout", FR_TYPE_UINT32, rlm_exec_t, timeout) },
CONF_PARSER_TERMINATOR
};
i++, vp = tmpl_cursor_next(&cursor, vpt)) {
int64_t y;
- if (vp->vp_type != FR_TYPE_INTEGER64) {
+ if (vp->vp_type != FR_TYPE_UINT64) {
fr_value_box_t value;
- if (fr_value_box_cast(vp, &value, FR_TYPE_INTEGER64, NULL, &vp->data) < 0) {
+ if (fr_value_box_cast(vp, &value, FR_TYPE_UINT64, NULL, &vp->data) < 0) {
REDEBUG("Failed converting &%.*s to an integer value: %s", (int) vpt->len,
vpt->name, fr_strerror());
return false;
* be used.
*/
- { FR_CONF_OFFSET("allow_unassigned", FR_TYPE_BOOLEAN, rlm_idn_t, allow_unassigned), .dflt = "no" },
- { FR_CONF_OFFSET("use_std3_ascii_rules", FR_TYPE_BOOLEAN, rlm_idn_t, use_std3_ascii_rules), .dflt = "yes" },
+ { FR_CONF_OFFSET("allow_unassigned", FR_TYPE_BOOL, rlm_idn_t, allow_unassigned), .dflt = "no" },
+ { FR_CONF_OFFSET("use_std3_ascii_rules", FR_TYPE_BOOL, rlm_idn_t, use_std3_ascii_rules), .dflt = "yes" },
CONF_PARSER_TERMINATOR
};
break;
case json_type_double:
- in.type = FR_TYPE_DECIMAL;
+ in.type = FR_TYPE_FLOAT64;
in.datum.decimal = json_object_get_double(object);
break;
int32_t num;
#endif
#ifndef HAVE_JSON_OBJECT_GET_INT64
- if (dst_type == FR_TYPE_INTEGER64) {
+ if (dst_type == FR_TYPE_UINT64) {
fr_strerror_printf("64bit integers are not supported by linked json-c. "
"Upgrade to json-c > 0.10 to use this feature");
return -1;
return -1;
}
if (num > UINT32_MAX) { /* 64bit unsigned (supported) */
- in.type = FR_TYPE_INTEGER64;
+ in.type = FR_TYPE_UINT64;
in.datum.integer64 = (uint64_t) num;
} else
#endif
if (num < 0) { /* 32bit signed (supported) */
- in.type = FR_TYPE_SIGNED;
+ in.type = FR_TYPE_INT32;
in.datum.sinteger = num;
} else if (num > UINT16_MAX) { /* 32bit unsigned (supported) */
- in.type = FR_TYPE_INTEGER;
+ in.type = FR_TYPE_UINT32;
in.datum.integer = (uint32_t) num;
} else if (num > UINT8_MAX) { /* 16bit unsigned (supported) */
- in.type = FR_TYPE_SHORT;
+ in.type = FR_TYPE_UINT16;
in.datum.ushort = (uint16_t) num;
} else { /* 8bit unsigned (supported) */
- in.type = FR_TYPE_BYTE;
+ in.type = FR_TYPE_UINT8;
in.datum.byte = (uint8_t) num;
}
}
break;
case json_type_boolean:
- in.type = FR_TYPE_BOOLEAN;
+ in.type = FR_TYPE_BOOL;
in.datum.boolean = json_object_get_boolean(object);
break;
return obj;
}
- case FR_TYPE_BOOLEAN:
+ case FR_TYPE_BOOL:
return json_object_new_boolean(data->datum.byte);
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
return json_object_new_int(data->datum.byte);
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
return json_object_new_int(data->datum.ushort);
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
return json_object_new_int64((int64_t)data->datum.integer64); /* uint32_t (max) > int32_t (max) */
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
if (data->datum.integer64 > INT64_MAX) goto do_string;
return json_object_new_int64(data->datum.integer64);
- case FR_TYPE_SIGNED:
+ case FR_TYPE_INT32:
return json_object_new_int(data->datum.sinteger);
}
}
if (!vp->da->flags.has_tag) {
switch (vp->vp_type) {
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
if (vp->da->flags.has_value) break;
return snprintf(out, freespace, "%u", vp->vp_integer);
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
if (vp->da->flags.has_value) break;
return snprintf(out, freespace, "%u", (unsigned int) vp->vp_short);
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
if (vp->da->flags.has_value) break;
return snprintf(out, freespace, "%u", (unsigned int) vp->vp_byte);
- case FR_TYPE_SIGNED:
+ case FR_TYPE_INT32:
return snprintf(out, freespace, "%d", vp->vp_signed);
default:
char const *p;
#ifndef HAVE_JSON_OBJECT_GET_INT64
- if ((map->lhs->type == TMPL_TYPE_ATTR) && (map->lhs->tmpl_da->type == FR_TYPE_INTEGER64)) {
+ if ((map->lhs->type == TMPL_TYPE_ATTR) && (map->lhs->tmpl_da->type == FR_TYPE_UINT64)) {
cf_log_err_cp(cp, "64bit integers are not supported by linked json-c. "
"Upgrade to json-c >= 0.10 to use this feature");
return -1;
/*
* LDAP Specific TLS attributes
*/
- { FR_CONF_OFFSET("start_tls", FR_TYPE_BOOLEAN, fr_ldap_handle_config_t, start_tls), .dflt = "no" },
+ { FR_CONF_OFFSET("start_tls", FR_TYPE_BOOL, fr_ldap_handle_config_t, start_tls), .dflt = "no" },
{ FR_CONF_OFFSET("require_cert", FR_TYPE_STRING, fr_ldap_handle_config_t, tls_require_cert_str) },
{ FR_CONF_OFFSET("sort_by", FR_TYPE_STRING, rlm_ldap_t, userobj_sort_by) },
{ FR_CONF_OFFSET("access_attribute", FR_TYPE_STRING, rlm_ldap_t, userobj_access_attr) },
- { FR_CONF_OFFSET("access_positive", FR_TYPE_BOOLEAN, rlm_ldap_t, access_positive), .dflt = "yes" },
+ { FR_CONF_OFFSET("access_positive", FR_TYPE_BOOL, rlm_ldap_t, access_positive), .dflt = "yes" },
/* Should be deprecated */
{ FR_CONF_OFFSET("sasl", FR_TYPE_SUBSECTION, rlm_ldap_t, user_sasl), .subcs = (void const *) sasl_mech_dynamic },
{ FR_CONF_OFFSET("name_attribute", FR_TYPE_STRING, rlm_ldap_t, groupobj_name_attr), .dflt = "cn" },
{ FR_CONF_OFFSET("membership_attribute", FR_TYPE_STRING, rlm_ldap_t, userobj_membership_attr) },
{ FR_CONF_OFFSET("membership_filter", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_ldap_t, groupobj_membership_filter) },
- { FR_CONF_OFFSET("cacheable_name", FR_TYPE_BOOLEAN, rlm_ldap_t, cacheable_group_name), .dflt = "no" },
- { FR_CONF_OFFSET("cacheable_dn", FR_TYPE_BOOLEAN, rlm_ldap_t, cacheable_group_dn), .dflt = "no" },
+ { FR_CONF_OFFSET("cacheable_name", FR_TYPE_BOOL, rlm_ldap_t, cacheable_group_name), .dflt = "no" },
+ { FR_CONF_OFFSET("cacheable_dn", FR_TYPE_BOOL, rlm_ldap_t, cacheable_group_dn), .dflt = "no" },
{ FR_CONF_OFFSET("cache_attribute", FR_TYPE_STRING, rlm_ldap_t, cache_attribute) },
{ FR_CONF_OFFSET("group_attribute", FR_TYPE_STRING, rlm_ldap_t, group_attribute) },
CONF_PARSER_TERMINATOR
/*
* Pool config items
*/
- { FR_CONF_OFFSET("chase_referrals", FR_TYPE_BOOLEAN, rlm_ldap_t, handle_config.chase_referrals) },
+ { FR_CONF_OFFSET("chase_referrals", FR_TYPE_BOOL, rlm_ldap_t, handle_config.chase_referrals) },
- { FR_CONF_OFFSET("use_referral_credentials", FR_TYPE_BOOLEAN, rlm_ldap_t, handle_config.use_referral_credentials), .dflt = "no" },
+ { FR_CONF_OFFSET("use_referral_credentials", FR_TYPE_BOOL, rlm_ldap_t, handle_config.use_referral_credentials), .dflt = "no" },
- { FR_CONF_OFFSET("rebind", FR_TYPE_BOOLEAN, rlm_ldap_t, handle_config.rebind) },
+ { FR_CONF_OFFSET("rebind", FR_TYPE_BOOL, rlm_ldap_t, handle_config.rebind) },
#ifdef LDAP_OPT_NETWORK_TIMEOUT
/* timeout on network activity */
- { FR_CONF_DEPRECATED("net_timeout", FR_TYPE_INTEGER, rlm_ldap_t, handle_config.net_timeout), .dflt = "10" },
+ { FR_CONF_DEPRECATED("net_timeout", FR_TYPE_UINT32, rlm_ldap_t, handle_config.net_timeout), .dflt = "10" },
#endif
#ifdef LDAP_OPT_X_KEEPALIVE_IDLE
- { FR_CONF_OFFSET("idle", FR_TYPE_INTEGER, rlm_ldap_t, handle_config.keepalive_idle), .dflt = "60" },
+ { FR_CONF_OFFSET("idle", FR_TYPE_UINT32, rlm_ldap_t, handle_config.keepalive_idle), .dflt = "60" },
#endif
#ifdef LDAP_OPT_X_KEEPALIVE_PROBES
- { FR_CONF_OFFSET("probes", FR_TYPE_INTEGER, rlm_ldap_t, handle_config.keepalive_probes), .dflt = "3" },
+ { FR_CONF_OFFSET("probes", FR_TYPE_UINT32, rlm_ldap_t, handle_config.keepalive_probes), .dflt = "3" },
#endif
#ifdef LDAP_OPT_X_KEEPALIVE_INTERVAL
- { FR_CONF_OFFSET("interval", FR_TYPE_INTEGER, rlm_ldap_t, handle_config.keepalive_interval), .dflt = "30" },
+ { FR_CONF_OFFSET("interval", FR_TYPE_UINT32, rlm_ldap_t, handle_config.keepalive_interval), .dflt = "30" },
#endif
{ FR_CONF_OFFSET("dereference", FR_TYPE_STRING, rlm_ldap_t, handle_config.dereference_str) },
/* allow server unlimited time for search (server-side limit) */
- { FR_CONF_OFFSET("srv_timelimit", FR_TYPE_INTEGER, rlm_ldap_t, handle_config.srv_timelimit), .dflt = "20" },
+ { FR_CONF_OFFSET("srv_timelimit", FR_TYPE_UINT32, rlm_ldap_t, handle_config.srv_timelimit), .dflt = "20" },
/*
* Instance config items
static const CONF_PARSER global_config[] = {
{ FR_CONF_OFFSET("random_file", FR_TYPE_FILE_EXISTS, rlm_ldap_t, tls_random_file) },
- { FR_CONF_OFFSET("ldap_debug", FR_TYPE_INTEGER, rlm_ldap_t, ldap_debug), .dflt = "0x0000" }, /* Debugging flags to the server */
+ { FR_CONF_OFFSET("ldap_debug", FR_TYPE_UINT32, rlm_ldap_t, ldap_debug), .dflt = "0x0000" }, /* Debugging flags to the server */
CONF_PARSER_TERMINATOR
};
*/
{ FR_CONF_OFFSET("server", FR_TYPE_STRING | FR_TYPE_MULTI, rlm_ldap_t, handle_config.server_str) }, /* Do not set to required */
- { FR_CONF_OFFSET("port", FR_TYPE_SHORT, rlm_ldap_t, handle_config.port) },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, rlm_ldap_t, handle_config.port) },
{ FR_CONF_OFFSET("identity", FR_TYPE_STRING, rlm_ldap_t, handle_config.admin_identity) },
{ FR_CONF_OFFSET("password", FR_TYPE_STRING | FR_TYPE_SECRET, rlm_ldap_t, handle_config.admin_password) },
{ FR_CONF_OFFSET("valuepair_attribute", FR_TYPE_STRING, rlm_ldap_t, valuepair_attr) },
#ifdef LDAP_CONTROL_X_SESSION_TRACKING
- { FR_CONF_OFFSET("session_tracking", FR_TYPE_BOOLEAN, rlm_ldap_t, session_tracking), .dflt = "no" },
+ { FR_CONF_OFFSET("session_tracking", FR_TYPE_BOOL, rlm_ldap_t, session_tracking), .dflt = "no" },
#endif
#ifdef WITH_EDIR
/* support for eDirectory Universal Password */
- { FR_CONF_OFFSET("edir", FR_TYPE_BOOLEAN, rlm_ldap_t, edir) }, /* NULL defaults to "no" */
+ { FR_CONF_OFFSET("edir", FR_TYPE_BOOL, rlm_ldap_t, edir) }, /* NULL defaults to "no" */
/*
* Attempt to bind with the cleartext password we got from eDirectory
* Universal password for additional authorization checks.
*/
- { FR_CONF_OFFSET("edir_autz", FR_TYPE_BOOLEAN, rlm_ldap_t, edir_autz) }, /* NULL defaults to "no" */
+ { FR_CONF_OFFSET("edir_autz", FR_TYPE_BOOL, rlm_ldap_t, edir_autz) }, /* NULL defaults to "no" */
#endif
- { FR_CONF_OFFSET("read_clients", FR_TYPE_BOOLEAN, rlm_ldap_t, do_clients) }, /* NULL defaults to "no" */
+ { FR_CONF_OFFSET("read_clients", FR_TYPE_BOOL, rlm_ldap_t, do_clients) }, /* NULL defaults to "no" */
{ FR_CONF_POINTER("user", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) user_config },
static const CONF_PARSER file_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_OUTPUT | FR_TYPE_XLAT, linelog_instance_t, file.name) },
- { FR_CONF_OFFSET("permissions", FR_TYPE_INTEGER, linelog_instance_t, file.permissions), .dflt = "0600" },
+ { FR_CONF_OFFSET("permissions", FR_TYPE_UINT32, linelog_instance_t, file.permissions), .dflt = "0600" },
{ FR_CONF_OFFSET("group", FR_TYPE_STRING, linelog_instance_t, file.group_str) },
- { FR_CONF_OFFSET("escape_filenames", FR_TYPE_BOOLEAN, linelog_instance_t, file.escape), .dflt = "no" },
+ { FR_CONF_OFFSET("escape_filenames", FR_TYPE_BOOL, linelog_instance_t, file.escape), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER udp_config[] = {
{ FR_CONF_OFFSET("server", FR_TYPE_COMBO_IP_ADDR, linelog_net_t, dst_ipaddr) },
- { FR_CONF_OFFSET("port", FR_TYPE_SHORT, linelog_net_t, port) },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, linelog_net_t, port) },
{ FR_CONF_OFFSET("timeout", FR_TYPE_TIMEVAL, linelog_net_t, timeout), .dflt = "1000" },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER tcp_config[] = {
{ FR_CONF_OFFSET("server", FR_TYPE_COMBO_IP_ADDR, linelog_net_t, dst_ipaddr) },
- { FR_CONF_OFFSET("port", FR_TYPE_SHORT, linelog_net_t, port) },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, linelog_net_t, port) },
{ FR_CONF_OFFSET("timeout", FR_TYPE_TIMEVAL, linelog_net_t, timeout), .dflt = "1000" },
CONF_PARSER_TERMINATOR
};
* Deprecated config items
*/
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_OUTPUT | FR_TYPE_DEPRECATED, linelog_instance_t, file.name) },
- { FR_CONF_OFFSET("permissions", FR_TYPE_INTEGER | FR_TYPE_DEPRECATED, linelog_instance_t, file.permissions) },
+ { FR_CONF_OFFSET("permissions", FR_TYPE_UINT32 | FR_TYPE_DEPRECATED, linelog_instance_t, file.permissions) },
{ FR_CONF_OFFSET("group", FR_TYPE_STRING | FR_TYPE_DEPRECATED, linelog_instance_t, file.group_str) },
{ FR_CONF_OFFSET("syslog_facility", FR_TYPE_STRING | FR_TYPE_DEPRECATED, linelog_instance_t, syslog.facility) },
} rlm_logintime_t;
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("minimum_timeout", FR_TYPE_INTEGER, rlm_logintime_t, min_time), .dflt = "60" },
+ { FR_CONF_OFFSET("minimum_timeout", FR_TYPE_UINT32, rlm_logintime_t, min_time), .dflt = "60" },
CONF_PARSER_TERMINATOR
};
case FR_TYPE_IPV6_PREFIX:
case FR_TYPE_IFID:
case FR_TYPE_TLV:
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
fr_pair_value_snprint(buffer, sizeof(buffer), vp, '\0');
lua_pushstring(L, buffer);
break;
lua_pushlstring(L, (char const *)vp->vp_octets, vp->vp_length); /* lstring variant is embedded NULL safe */
break;
- case FR_TYPE_BYTE:
- case FR_TYPE_SHORT:
- case FR_TYPE_INTEGER:
- case FR_TYPE_SIGNED:
+ case FR_TYPE_UINT8:
+ case FR_TYPE_UINT16:
+ case FR_TYPE_UINT32:
+ case FR_TYPE_INT32:
lua_pushinteger(L, vp->vp_integer);
break;
break;
}
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
vp->vp_integer = (uint32_t) lua_tointeger(L, -1);
break;
}
break;
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
vp->vp_byte = (uint8_t) lua_tointeger(L, -1);
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
vp->vp_short = (uint16_t) lua_tointeger(L, -1);
break;
- case FR_TYPE_SIGNED:
+ case FR_TYPE_INT32:
vp->vp_signed = (int32_t) lua_tointeger(L, -1);
break;
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
vp->vp_integer64 = (uint64_t) lua_tointeger(L, -1);
break;
*/
static const CONF_PARSER module_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT | FR_TYPE_REQUIRED, rlm_lua_t, module), NULL},
- { FR_CONF_OFFSET("threads", FR_TYPE_BOOLEAN, rlm_lua_t, threads), .dflt = "no"},
+ { FR_CONF_OFFSET("threads", FR_TYPE_BOOL, rlm_lua_t, threads), .dflt = "no"},
{ FR_CONF_OFFSET("func_instantiate", FR_TYPE_STRING, rlm_lua_t, func_instantiate), NULL},
{ FR_CONF_OFFSET("func_detach", FR_TYPE_STRING, rlm_lua_t, func_detach), NULL},
{ FR_CONF_OFFSET("func_authorize", FR_TYPE_STRING, rlm_lua_t, func_authorize), NULL},
/*
* Cache the password by default.
*/
- { FR_CONF_OFFSET("use_mppe", FR_TYPE_BOOLEAN, rlm_mschap_t, use_mppe), .dflt = "yes" },
- { FR_CONF_OFFSET("require_encryption", FR_TYPE_BOOLEAN, rlm_mschap_t, require_encryption), .dflt = "no" },
- { FR_CONF_OFFSET("require_strong", FR_TYPE_BOOLEAN, rlm_mschap_t, require_strong), .dflt = "no" },
- { FR_CONF_OFFSET("with_ntdomain_hack", FR_TYPE_BOOLEAN, rlm_mschap_t, with_ntdomain_hack), .dflt = "yes" },
+ { FR_CONF_OFFSET("use_mppe", FR_TYPE_BOOL, rlm_mschap_t, use_mppe), .dflt = "yes" },
+ { FR_CONF_OFFSET("require_encryption", FR_TYPE_BOOL, rlm_mschap_t, require_encryption), .dflt = "no" },
+ { FR_CONF_OFFSET("require_strong", FR_TYPE_BOOL, rlm_mschap_t, require_strong), .dflt = "no" },
+ { FR_CONF_OFFSET("with_ntdomain_hack", FR_TYPE_BOOL, rlm_mschap_t, with_ntdomain_hack), .dflt = "yes" },
{ FR_CONF_OFFSET("ntlm_auth", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_mschap_t, ntlm_auth) },
- { FR_CONF_OFFSET("ntlm_auth_timeout", FR_TYPE_INTEGER, rlm_mschap_t, ntlm_auth_timeout) },
+ { FR_CONF_OFFSET("ntlm_auth_timeout", FR_TYPE_UINT32, rlm_mschap_t, ntlm_auth_timeout) },
{ FR_CONF_POINTER("passchange", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) passchange_config },
- { FR_CONF_OFFSET("allow_retry", FR_TYPE_BOOLEAN, rlm_mschap_t, allow_retry), .dflt = "yes" },
+ { FR_CONF_OFFSET("allow_retry", FR_TYPE_BOOL, rlm_mschap_t, allow_retry), .dflt = "yes" },
{ FR_CONF_OFFSET("retry_msg", FR_TYPE_STRING, rlm_mschap_t, retry_msg) },
{ FR_CONF_OFFSET("winbind_username", FR_TYPE_TMPL, rlm_mschap_t, wb_username) },
{ FR_CONF_OFFSET("winbind_domain", FR_TYPE_TMPL, rlm_mschap_t, wb_domain) },
#ifdef WITH_AUTH_WINBIND
- { FR_CONF_OFFSET("winbind_retry_with_normalised_username", FR_TYPE_BOOLEAN, rlm_mschap_t, wb_retry_with_normalised_username), .dflt = "no" },
+ { FR_CONF_OFFSET("winbind_retry_with_normalised_username", FR_TYPE_BOOL, rlm_mschap_t, wb_retry_with_normalised_username), .dflt = "no" },
#endif
#ifdef __APPLE__
- { FR_CONF_OFFSET("use_open_directory", FR_TYPE_BOOLEAN, rlm_mschap_t, open_directory), .dflt = "yes" },
+ { FR_CONF_OFFSET("use_open_directory", FR_TYPE_BOOL, rlm_mschap_t, open_directory), .dflt = "yes" },
#endif
CONF_PARSER_TERMINATOR
};
} rlm_pap_t;
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("normalise", FR_TYPE_BOOLEAN, rlm_pap_t, normify), .dflt = "yes" },
+ { FR_CONF_OFFSET("normalise", FR_TYPE_BOOL, rlm_pap_t, normify), .dflt = "yes" },
CONF_PARSER_TERMINATOR
};
{ FR_CONF_OFFSET("format", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_passwd_t, format) },
{ FR_CONF_OFFSET("delimiter", FR_TYPE_STRING, rlm_passwd_t, delimiter), .dflt = ":" },
- { FR_CONF_OFFSET("ignore_nislike", FR_TYPE_BOOLEAN, rlm_passwd_t, ignore_nislike), .dflt = "yes" },
+ { FR_CONF_OFFSET("ignore_nislike", FR_TYPE_BOOL, rlm_passwd_t, ignore_nislike), .dflt = "yes" },
- { FR_CONF_OFFSET("ignore_empty", FR_TYPE_BOOLEAN, rlm_passwd_t, ignore_empty), .dflt = "yes" },
+ { FR_CONF_OFFSET("ignore_empty", FR_TYPE_BOOL, rlm_passwd_t, ignore_empty), .dflt = "yes" },
- { FR_CONF_OFFSET("allow_multiple_keys", FR_TYPE_BOOLEAN, rlm_passwd_t, allow_multiple), .dflt = "no" },
+ { FR_CONF_OFFSET("allow_multiple_keys", FR_TYPE_BOOL, rlm_passwd_t, allow_multiple), .dflt = "no" },
- { FR_CONF_OFFSET("hash_size", FR_TYPE_INTEGER, rlm_passwd_t, hash_size), .dflt = "100" },
+ { FR_CONF_OFFSET("hash_size", FR_TYPE_UINT32, rlm_passwd_t, hash_size), .dflt = "100" },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER module_config[] = {
{ FR_CONF_OFFSET("huntgroups", FR_TYPE_FILE_INPUT, rlm_preprocess_t, huntgroup_file) },
{ FR_CONF_OFFSET("hints", FR_TYPE_FILE_INPUT, rlm_preprocess_t, hints_file) },
- { FR_CONF_OFFSET("with_ascend_hack", FR_TYPE_BOOLEAN, rlm_preprocess_t, with_ascend_hack), .dflt = "no" },
- { FR_CONF_OFFSET("ascend_channels_per_line", FR_TYPE_INTEGER, rlm_preprocess_t, ascend_channels_per_line), .dflt = "23" },
+ { FR_CONF_OFFSET("with_ascend_hack", FR_TYPE_BOOL, rlm_preprocess_t, with_ascend_hack), .dflt = "no" },
+ { FR_CONF_OFFSET("ascend_channels_per_line", FR_TYPE_UINT32, rlm_preprocess_t, ascend_channels_per_line), .dflt = "23" },
- { FR_CONF_OFFSET("with_ntdomain_hack", FR_TYPE_BOOLEAN, rlm_preprocess_t, with_ntdomain_hack), .dflt = "no" },
- { FR_CONF_OFFSET("with_specialix_jetstream_hack", FR_TYPE_BOOLEAN, rlm_preprocess_t, with_specialix_jetstream_hack), .dflt = "no" },
- { FR_CONF_OFFSET("with_cisco_vsa_hack", FR_TYPE_BOOLEAN, rlm_preprocess_t, with_cisco_vsa_hack), .dflt = "no" },
- { FR_CONF_OFFSET("with_alvarion_vsa_hack", FR_TYPE_BOOLEAN, rlm_preprocess_t, with_alvarion_vsa_hack), .dflt = "no" },
+ { FR_CONF_OFFSET("with_ntdomain_hack", FR_TYPE_BOOL, rlm_preprocess_t, with_ntdomain_hack), .dflt = "no" },
+ { FR_CONF_OFFSET("with_specialix_jetstream_hack", FR_TYPE_BOOL, rlm_preprocess_t, with_specialix_jetstream_hack), .dflt = "no" },
+ { FR_CONF_OFFSET("with_cisco_vsa_hack", FR_TYPE_BOOL, rlm_preprocess_t, with_cisco_vsa_hack), .dflt = "no" },
+ { FR_CONF_OFFSET("with_alvarion_vsa_hack", FR_TYPE_BOOL, rlm_preprocess_t, with_alvarion_vsa_hack), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
#undef A
{ FR_CONF_OFFSET("python_path", FR_TYPE_STRING, rlm_python_t, python_path) },
- { FR_CONF_OFFSET("cext_compat", FR_TYPE_BOOLEAN, rlm_python_t, cext_compat), .dflt = false },
+ { FR_CONF_OFFSET("cext_compat", FR_TYPE_BOOL, rlm_python_t, cext_compat), .dflt = false },
CONF_PARSER_TERMINATOR
};
value = PyString_FromStringAndSize((char const *)vp->vp_octets, vp->vp_length);
break;
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
value = PyLong_FromUnsignedLong(vp->vp_integer);
break;
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
value = PyLong_FromUnsignedLong(vp->vp_byte);
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
value = PyLong_FromUnsignedLong(vp->vp_short);
break;
- case FR_TYPE_SIGNED:
+ case FR_TYPE_INT32:
value = PyLong_FromLong(vp->vp_signed);
break;
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
value = PyLong_FromUnsignedLongLong(vp->vp_integer64);
break;
value = PyLong_FromUnsignedLongLong((unsigned long long)vp->vp_size);
break;
- case FR_TYPE_DECIMAL:
+ case FR_TYPE_FLOAT64:
value = PyFloat_FromDouble(vp->vp_decimal);
break;
- case FR_TYPE_BOOLEAN:
+ case FR_TYPE_BOOL:
value = PyBool_FromLong(vp->vp_bool);
break;
static const CONF_PARSER module_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_OUTPUT | FR_TYPE_REQUIRED, rlm_radutmp_t, filename), .dflt = RADUTMP },
{ FR_CONF_OFFSET("username", FR_TYPE_STRING | FR_TYPE_REQUIRED | FR_TYPE_XLAT, rlm_radutmp_t, username), .dflt = "%{User-Name}" },
- { FR_CONF_OFFSET("case_sensitive", FR_TYPE_BOOLEAN, rlm_radutmp_t, case_sensitive), .dflt = "yes" },
- { FR_CONF_OFFSET("check_with_nas", FR_TYPE_BOOLEAN, rlm_radutmp_t, check_nas), .dflt = "yes" },
- { FR_CONF_OFFSET("permissions", FR_TYPE_INTEGER, rlm_radutmp_t, permission), .dflt = "0644" },
- { FR_CONF_OFFSET("caller_id", FR_TYPE_BOOLEAN, rlm_radutmp_t, caller_id_ok), .dflt = "no" },
+ { FR_CONF_OFFSET("case_sensitive", FR_TYPE_BOOL, rlm_radutmp_t, case_sensitive), .dflt = "yes" },
+ { FR_CONF_OFFSET("check_with_nas", FR_TYPE_BOOL, rlm_radutmp_t, check_nas), .dflt = "yes" },
+ { FR_CONF_OFFSET("permissions", FR_TYPE_UINT32, rlm_radutmp_t, permission), .dflt = "0644" },
+ { FR_CONF_OFFSET("caller_id", FR_TYPE_BOOL, rlm_radutmp_t, caller_id_ok), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
static CONF_PARSER module_config[] = {
{ FR_CONF_OFFSET("format", FR_TYPE_STRING, rlm_realm_t, format_string), .dflt = "suffix" },
{ FR_CONF_OFFSET("delimiter", FR_TYPE_STRING, rlm_realm_t, delim), .dflt = "@" },
- { FR_CONF_OFFSET("ignore_default", FR_TYPE_BOOLEAN, rlm_realm_t, ignore_default), .dflt = "no" },
- { FR_CONF_OFFSET("ignore_null", FR_TYPE_BOOLEAN, rlm_realm_t, ignore_null), .dflt = "no" },
+ { FR_CONF_OFFSET("ignore_default", FR_TYPE_BOOL, rlm_realm_t, ignore_default), .dflt = "no" },
+ { FR_CONF_OFFSET("ignore_null", FR_TYPE_BOOL, rlm_realm_t, ignore_null), .dflt = "no" },
#ifdef HAVE_TRUST_ROUTER_TR_DH_H
{ FR_CONF_OFFSET("default_community", FR_TYPE_STRING, rlm_realm_t, default_community) },
{ FR_CONF_OFFSET("rp_realm", FR_TYPE_STRING, rlm_realm_t, rp_realm) },
{ FR_CONF_OFFSET("trust_router", FR_TYPE_STRING, rlm_realm_t, trust_router) },
- { FR_CONF_OFFSET("tr_port", FR_TYPE_INTEGER, rlm_realm_t, tr_port), .dflt = "0" },
+ { FR_CONF_OFFSET("tr_port", FR_TYPE_UINT32, rlm_realm_t, tr_port), .dflt = "0" },
#endif
CONF_PARSER_TERMINATOR
};
*
* Will work with REDIS_REPLY_STRING (which is converted to #FR_TYPE_STRING
* then cast to dst_type), or REDIS_REPLY_INTEGER (which is converted to
- * #FR_TYPE_INTEGER64, then cast to dst_type).
+ * #FR_TYPE_UINT64, then cast to dst_type).
*
* @note Any unsupported types will trigger an assert. You must check the
* reply type prior to calling this function.
return -1;
}
if (reply->integer < 0) { /* 32bit signed (supported) */
- in.type = FR_TYPE_SIGNED;
+ in.type = FR_TYPE_INT32;
in.datum.sinteger = (int32_t) reply->integer;
}
else if (reply->integer > UINT32_MAX) { /* 64bit unsigned (supported) */
- in.type = FR_TYPE_INTEGER64;
+ in.type = FR_TYPE_UINT64;
in.datum.integer64 = (uint64_t) reply->integer;
}
else if (reply->integer > UINT16_MAX) { /* 32bit unsigned (supported) */
- in.type = FR_TYPE_INTEGER;
+ in.type = FR_TYPE_UINT32;
in.datum.integer = (uint32_t) reply->integer;
}
else if (reply->integer > UINT8_MAX) { /* 16bit unsigned (supported) */
- in.type = FR_TYPE_SHORT;
+ in.type = FR_TYPE_UINT16;
in.datum.ushort = (uint16_t) reply->integer;
}
else { /* 8bit unsigned (supported) */
- in.type = FR_TYPE_BYTE;
+ in.type = FR_TYPE_UINT8;
in.datum.byte = (uint8_t) reply->integer;
}
break;
#define REDIS_COMMON_CONFIG \
{ FR_CONF_OFFSET("server", FR_TYPE_STRING | FR_TYPE_REQUIRED | FR_TYPE_MULTI, fr_redis_conf_t, hostname) }, \
- { FR_CONF_OFFSET("port", FR_TYPE_SHORT, fr_redis_conf_t, port), .dflt = "6379" }, \
- { FR_CONF_OFFSET("database", FR_TYPE_INTEGER, fr_redis_conf_t, database), .dflt = "0" }, \
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, fr_redis_conf_t, port), .dflt = "6379" }, \
+ { FR_CONF_OFFSET("database", FR_TYPE_UINT32, fr_redis_conf_t, database), .dflt = "0" }, \
{ FR_CONF_OFFSET("password", FR_TYPE_STRING | FR_TYPE_SECRET, fr_redis_conf_t, password) }, \
- { FR_CONF_OFFSET("max_nodes", FR_TYPE_BYTE, fr_redis_conf_t, max_nodes), .dflt = "20" }, \
- { FR_CONF_OFFSET("max_alt", FR_TYPE_INTEGER, fr_redis_conf_t, max_alt), .dflt = "3" }, \
- { FR_CONF_OFFSET("max_redirects", FR_TYPE_INTEGER, fr_redis_conf_t, max_redirects), .dflt = "2" }
+ { FR_CONF_OFFSET("max_nodes", FR_TYPE_UINT8, fr_redis_conf_t, max_nodes), .dflt = "20" }, \
+ { FR_CONF_OFFSET("max_alt", FR_TYPE_UINT32, fr_redis_conf_t, max_alt), .dflt = "3" }, \
+ { FR_CONF_OFFSET("max_redirects", FR_TYPE_UINT32, fr_redis_conf_t, max_redirects), .dflt = "2" }
void fr_redis_version_print(void);
{ FR_CONF_OFFSET("offer_time", FR_TYPE_TMPL, rlm_redis_ippool_t, offer_time) },
{ FR_CONF_OFFSET("lease_time", FR_TYPE_TMPL | FR_TYPE_REQUIRED, rlm_redis_ippool_t, lease_time) },
- { FR_CONF_OFFSET("wait_num", FR_TYPE_INTEGER, rlm_redis_ippool_t, wait_num) },
+ { FR_CONF_OFFSET("wait_num", FR_TYPE_UINT32, rlm_redis_ippool_t, wait_num) },
{ FR_CONF_OFFSET("wait_timeout", FR_TYPE_TIMEVAL, rlm_redis_ippool_t, wait_timeout) },
{ FR_CONF_OFFSET("requested_address", FR_TYPE_TMPL | FR_TYPE_REQUIRED, rlm_redis_ippool_t, requested_address), .dflt = "%{%{DHCP-Requested-IP-Address}:-%{DHCP-Client-IP-Address}}", .quote = T_DOUBLE_QUOTED_STRING },
{ FR_CONF_OFFSET("range_attr", FR_TYPE_TMPL | FR_TYPE_ATTRIBUTE | FR_TYPE_REQUIRED, rlm_redis_ippool_t, range_attr), .dflt = "&reply:Pool-Range", .quote = T_BARE_WORD },
{ FR_CONF_OFFSET("expiry_attr", FR_TYPE_TMPL | FR_TYPE_ATTRIBUTE, rlm_redis_ippool_t, expiry_attr) },
- { FR_CONF_OFFSET("ipv4_integer", FR_TYPE_BOOLEAN, rlm_redis_ippool_t, ipv4_integer) },
- { FR_CONF_OFFSET("copy_on_update", FR_TYPE_BOOLEAN, rlm_redis_ippool_t, copy_on_update), .dflt = "yes", .quote = T_BARE_WORD },
+ { FR_CONF_OFFSET("ipv4_integer", FR_TYPE_BOOL, rlm_redis_ippool_t, ipv4_integer) },
+ { FR_CONF_OFFSET("copy_on_update", FR_TYPE_BOOL, rlm_redis_ippool_t, copy_on_update), .dflt = "yes", .quote = T_BARE_WORD },
/*
* Split out to allow conversion to universal ippool module with
memset(&tmp, 0, sizeof(tmp));
tmp.datum.integer = ntohl((uint32_t)reply->element[1]->integer);
- tmp.type = FR_TYPE_INTEGER;
+ tmp.type = FR_TYPE_UINT32;
if (fr_value_box_cast(NULL, &ip_map.rhs->tmpl_value_box, FR_TYPE_IPV4_ADDR,
NULL, &tmp)) {
}
} else {
ip_map.rhs->tmpl_fr_value_box_datum.integer = ntohl((uint32_t)reply->element[1]->integer);
- ip_map.rhs->tmpl_fr_value_box_type = FR_TYPE_INTEGER;
+ ip_map.rhs->tmpl_fr_value_box_type = FR_TYPE_UINT32;
}
}
goto do_ip_map;
}
expiry_map.rhs->tmpl_fr_value_box_datum.integer = reply->element[3]->integer;
- expiry_map.rhs->tmpl_fr_value_box_type = FR_TYPE_INTEGER;
+ expiry_map.rhs->tmpl_fr_value_box_type = FR_TYPE_UINT32;
if (map_to_request(request, &expiry_map, map_to_vp, NULL) < 0) {
ret = IPPOOL_RCODE_FAIL;
goto finish;
};
expiry_map.rhs->tmpl_fr_value_box_datum.integer = expires;
- expiry_map.rhs->tmpl_fr_value_box_type = FR_TYPE_INTEGER;
+ expiry_map.rhs->tmpl_fr_value_box_type = FR_TYPE_UINT32;
if (map_to_request(request, &expiry_map, map_to_vp, NULL) < 0) {
ret = IPPOOL_RCODE_FAIL;
goto finish;
static CONF_PARSER module_config[] = {
REDIS_COMMON_CONFIG,
- { FR_CONF_OFFSET("trim_count", FR_TYPE_SIGNED, rlm_rediswho_t, trim_count), .dflt = "-1" },
+ { FR_CONF_OFFSET("trim_count", FR_TYPE_INT32, rlm_rediswho_t, trim_count), .dflt = "-1" },
/*
* These all smash the same variables, because we don't care about them right now.
case json_type_int:
if (flags->do_xlat) RWDEBUG("Ignoring do_xlat on 'int', attribute \"%s\"", da->name);
src.datum.sinteger = json_object_get_int(leaf);
- src.type = FR_TYPE_SIGNED;
+ src.type = FR_TYPE_INT32;
break;
case json_type_double:
if (flags->do_xlat) RWDEBUG("Ignoring do_xlat on 'double', attribute \"%s\"", da->name);
src.datum.decimal = json_object_get_double(leaf);
- src.type = FR_TYPE_DECIMAL;
+ src.type = FR_TYPE_FLOAT64;
break;
case json_type_string:
{ FR_CONF_OFFSET("private_key_file", FR_TYPE_FILE_INPUT, rlm_rest_section_t, tls_private_key_file) },
{ FR_CONF_OFFSET("private_key_password", FR_TYPE_STRING | FR_TYPE_SECRET, rlm_rest_section_t, tls_private_key_password) },
{ FR_CONF_OFFSET("random_file", FR_TYPE_STRING, rlm_rest_section_t, tls_random_file) },
- { FR_CONF_OFFSET("check_cert", FR_TYPE_BOOLEAN, rlm_rest_section_t, tls_check_cert), .dflt = "yes" },
- { FR_CONF_OFFSET("check_cert_cn", FR_TYPE_BOOLEAN, rlm_rest_section_t, tls_check_cert_cn), .dflt = "yes" },
- { FR_CONF_OFFSET("extract_cert_attrs", FR_TYPE_BOOLEAN, rlm_rest_section_t, tls_extract_cert_attrs), .dflt = "no" },
+ { FR_CONF_OFFSET("check_cert", FR_TYPE_BOOL, rlm_rest_section_t, tls_check_cert), .dflt = "yes" },
+ { FR_CONF_OFFSET("check_cert_cn", FR_TYPE_BOOL, rlm_rest_section_t, tls_check_cert_cn), .dflt = "yes" },
+ { FR_CONF_OFFSET("extract_cert_attrs", FR_TYPE_BOOL, rlm_rest_section_t, tls_extract_cert_attrs), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
{ FR_CONF_OFFSET("auth", FR_TYPE_STRING, rlm_rest_section_t, auth_str), .dflt = "none" },
{ FR_CONF_OFFSET("username", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_rest_section_t, username) },
{ FR_CONF_OFFSET("password", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_rest_section_t, password) },
- { FR_CONF_OFFSET("require_auth", FR_TYPE_BOOLEAN, rlm_rest_section_t, require_auth), .dflt = "no" },
+ { FR_CONF_OFFSET("require_auth", FR_TYPE_BOOL, rlm_rest_section_t, require_auth), .dflt = "no" },
/* Transfer configuration */
{ FR_CONF_OFFSET("timeout", FR_TYPE_TIMEVAL, rlm_rest_section_t, timeout_tv), .dflt = "4.0" },
- { FR_CONF_OFFSET("chunk", FR_TYPE_INTEGER, rlm_rest_section_t, chunk), .dflt = "0" },
+ { FR_CONF_OFFSET("chunk", FR_TYPE_UINT32, rlm_rest_section_t, chunk), .dflt = "0" },
/* TLS Parameters */
{ FR_CONF_POINTER("tls", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) tls_config },
{ FR_CONF_OFFSET("auth", FR_TYPE_STRING, rlm_rest_section_t, auth_str), .dflt = "none" },
{ FR_CONF_OFFSET("username", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_rest_section_t, username) },
{ FR_CONF_OFFSET("password", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_rest_section_t, password) },
- { FR_CONF_OFFSET("require_auth", FR_TYPE_BOOLEAN, rlm_rest_section_t, require_auth), .dflt = "no" },
+ { FR_CONF_OFFSET("require_auth", FR_TYPE_BOOL, rlm_rest_section_t, require_auth), .dflt = "no" },
/* Transfer configuration */
{ FR_CONF_OFFSET("timeout", FR_TYPE_TIMEVAL, rlm_rest_section_t, timeout_tv), .dflt = "4.0" },
- { FR_CONF_OFFSET("chunk", FR_TYPE_INTEGER, rlm_rest_section_t, chunk), .dflt = "0" },
+ { FR_CONF_OFFSET("chunk", FR_TYPE_UINT32, rlm_rest_section_t, chunk), .dflt = "0" },
/* TLS Parameters */
{ FR_CONF_POINTER("tls", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) tls_config },
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("timer_expire", FR_TYPE_INTEGER, rlm_securid_t, timer_limit), .dflt = "600" },
- { FR_CONF_OFFSET("max_sessions", FR_TYPE_INTEGER, rlm_securid_t, max_sessions), .dflt = "2048" },
- { FR_CONF_OFFSET("max_trips_per_session", FR_TYPE_INTEGER, rlm_securid_t, max_trips_per_session) },
- { FR_CONF_OFFSET("max_round_trips", FR_TYPE_INTEGER, rlm_securid_t, max_trips_per_session), .dflt = "6" },
+ { FR_CONF_OFFSET("timer_expire", FR_TYPE_UINT32, rlm_securid_t, timer_limit), .dflt = "600" },
+ { FR_CONF_OFFSET("max_sessions", FR_TYPE_UINT32, rlm_securid_t, max_sessions), .dflt = "2048" },
+ { FR_CONF_OFFSET("max_trips_per_session", FR_TYPE_UINT32, rlm_securid_t, max_trips_per_session) },
+ { FR_CONF_OFFSET("max_round_trips", FR_TYPE_UINT32, rlm_securid_t, max_trips_per_session), .dflt = "6" },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER sctp_config[] = {
{ FR_CONF_OFFSET("server", FR_TYPE_COMBO_IP_ADDR, rlm_sigtran_t, conn_conf.sctp_dst_ipaddr) },
- { FR_CONF_OFFSET("port", FR_TYPE_SHORT, rlm_sigtran_t, conn_conf.sctp_dst_port), .dflt = "2905" },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, rlm_sigtran_t, conn_conf.sctp_dst_port), .dflt = "2905" },
{ FR_CONF_OFFSET("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, rlm_sigtran_t, conn_conf.sctp_src_ipaddr ) },
- { FR_CONF_OFFSET("src_port", FR_TYPE_SHORT, rlm_sigtran_t, conn_conf.sctp_src_port), .dflt = "0" },
+ { FR_CONF_OFFSET("src_port", FR_TYPE_UINT16, rlm_sigtran_t, conn_conf.sctp_src_port), .dflt = "0" },
- { FR_CONF_OFFSET("timeout", FR_TYPE_INTEGER, rlm_sigtran_t, conn_conf.sctp_timeout), .dflt = "5" },
+ { FR_CONF_OFFSET("timeout", FR_TYPE_UINT32, rlm_sigtran_t, conn_conf.sctp_timeout), .dflt = "5" },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER m3ua_route[] = {
- { FR_CONF_IS_SET_OFFSET("dpc", FR_TYPE_INTEGER, sigtran_m3ua_route_t, dpc) },
- { FR_CONF_OFFSET("opc", FR_TYPE_INTEGER | FR_TYPE_MULTI, sigtran_m3ua_route_t, opc) },
- { FR_CONF_OFFSET("si", FR_TYPE_INTEGER | FR_TYPE_MULTI, sigtran_m3ua_route_t, si) },
+ { FR_CONF_IS_SET_OFFSET("dpc", FR_TYPE_UINT32, sigtran_m3ua_route_t, dpc) },
+ { FR_CONF_OFFSET("opc", FR_TYPE_UINT32 | FR_TYPE_MULTI, sigtran_m3ua_route_t, opc) },
+ { FR_CONF_OFFSET("si", FR_TYPE_UINT32 | FR_TYPE_MULTI, sigtran_m3ua_route_t, si) },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER m3ua_config[] = {
- { FR_CONF_OFFSET("link_index", FR_TYPE_SHORT, rlm_sigtran_t, conn_conf.m3ua_link_index) },
- { FR_CONF_OFFSET("routing_ctx", FR_TYPE_SHORT, rlm_sigtran_t, conn_conf.m3ua_routing_context) },
+ { FR_CONF_OFFSET("link_index", FR_TYPE_UINT16, rlm_sigtran_t, conn_conf.m3ua_link_index) },
+ { FR_CONF_OFFSET("routing_ctx", FR_TYPE_UINT16, rlm_sigtran_t, conn_conf.m3ua_routing_context) },
{ FR_CONF_OFFSET("traffic_mode", FR_TYPE_STRING, rlm_sigtran_t, conn_conf.m3ua_traffic_mode_str), .dflt = "loadshare" },
- { FR_CONF_OFFSET("ack_timeout", FR_TYPE_INTEGER, rlm_sigtran_t, conn_conf.m3ua_ack_timeout), .dflt = "2" },
- { FR_CONF_OFFSET("beat_interval", FR_TYPE_INTEGER, rlm_sigtran_t, conn_conf.m3ua_beat_interval), .dflt = "0" },
+ { FR_CONF_OFFSET("ack_timeout", FR_TYPE_UINT32, rlm_sigtran_t, conn_conf.m3ua_ack_timeout), .dflt = "2" },
+ { FR_CONF_OFFSET("beat_interval", FR_TYPE_UINT32, rlm_sigtran_t, conn_conf.m3ua_beat_interval), .dflt = "0" },
{ FR_CONF_IS_SET_OFFSET("route", FR_TYPE_SUBSECTION, rlm_sigtran_t, conn_conf.m3ua_routes), .subcs = (void const *) m3ua_route },
};
static const CONF_PARSER mtp3_config[] = {
- { FR_CONF_OFFSET("dpc", FR_TYPE_INTEGER | FR_TYPE_REQUIRED, rlm_sigtran_t, conn_conf.mtp3_dpc) },
- { FR_CONF_OFFSET("opc", FR_TYPE_INTEGER | FR_TYPE_REQUIRED, rlm_sigtran_t, conn_conf.mtp3_opc) },
+ { FR_CONF_OFFSET("dpc", FR_TYPE_UINT32 | FR_TYPE_REQUIRED, rlm_sigtran_t, conn_conf.mtp3_dpc) },
+ { FR_CONF_OFFSET("opc", FR_TYPE_UINT32 | FR_TYPE_REQUIRED, rlm_sigtran_t, conn_conf.mtp3_opc) },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER sccp_global_title[] = {
{ FR_CONF_OFFSET("address", FR_TYPE_STRING, sigtran_sccp_global_title_t, address) },
- { FR_CONF_IS_SET_OFFSET("tt", FR_TYPE_BYTE, sigtran_sccp_global_title_t, tt) },
- { FR_CONF_IS_SET_OFFSET("nai", FR_TYPE_BYTE, sigtran_sccp_global_title_t, nai) },
- { FR_CONF_IS_SET_OFFSET("np", FR_TYPE_BYTE, sigtran_sccp_global_title_t, np) },
- { FR_CONF_IS_SET_OFFSET("es", FR_TYPE_BYTE, sigtran_sccp_global_title_t, es) },
+ { FR_CONF_IS_SET_OFFSET("tt", FR_TYPE_UINT8, sigtran_sccp_global_title_t, tt) },
+ { FR_CONF_IS_SET_OFFSET("nai", FR_TYPE_UINT8, sigtran_sccp_global_title_t, nai) },
+ { FR_CONF_IS_SET_OFFSET("np", FR_TYPE_UINT8, sigtran_sccp_global_title_t, np) },
+ { FR_CONF_IS_SET_OFFSET("es", FR_TYPE_UINT8, sigtran_sccp_global_title_t, es) },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER sccp_address[] = {
- { FR_CONF_IS_SET_OFFSET("pc", FR_TYPE_INTEGER, sigtran_sccp_address_t, pc) },
- { FR_CONF_IS_SET_OFFSET("ssn", FR_TYPE_BYTE, sigtran_sccp_address_t, ssn) },
+ { FR_CONF_IS_SET_OFFSET("pc", FR_TYPE_UINT32, sigtran_sccp_address_t, pc) },
+ { FR_CONF_IS_SET_OFFSET("ssn", FR_TYPE_UINT8, sigtran_sccp_address_t, ssn) },
{ FR_CONF_IS_SET_OFFSET("gt", FR_TYPE_SUBSECTION, sigtran_sccp_address_t, gt), .subcs = (void const *) sccp_global_title },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER sccp_config[] = {
- { FR_CONF_OFFSET("ai8", FR_TYPE_BOOLEAN, rlm_sigtran_t, conn_conf.sccp_ai8) },
- { FR_CONF_OFFSET("route_on_ssn", FR_TYPE_BOOLEAN, rlm_sigtran_t, conn_conf.sccp_route_on_ssn) },
+ { FR_CONF_OFFSET("ai8", FR_TYPE_BOOL, rlm_sigtran_t, conn_conf.sccp_ai8) },
+ { FR_CONF_OFFSET("route_on_ssn", FR_TYPE_BOOL, rlm_sigtran_t, conn_conf.sccp_route_on_ssn) },
{ FR_CONF_OFFSET("called", FR_TYPE_SUBSECTION, rlm_sigtran_t, conn_conf.sccp_called), .subcs = (void const *) sccp_address },
{ FR_CONF_OFFSET("calling", FR_TYPE_SUBSECTION, rlm_sigtran_t, conn_conf.sccp_calling), .subcs = (void const *) sccp_address },
/*
* Do SoH over DHCP?
*/
- { FR_CONF_OFFSET("dhcp", FR_TYPE_BOOLEAN, rlm_soh_t, dhcp), .dflt = "no" },
+ { FR_CONF_OFFSET("dhcp", FR_TYPE_BOOL, rlm_soh_t, dhcp), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER module_config[] = {
{ FR_CONF_OFFSET("rcode", FR_TYPE_STRING, rlm_sometimes_t, rcode_str), .dflt = "fail" },
{ FR_CONF_OFFSET("key", FR_TYPE_TMPL | FR_TYPE_ATTRIBUTE, rlm_sometimes_t, key), .dflt = "&User-Name", .quote = T_BARE_WORD },
- { FR_CONF_OFFSET("start", FR_TYPE_INTEGER, rlm_sometimes_t, start), .dflt = "0" },
- { FR_CONF_OFFSET("end", FR_TYPE_INTEGER, rlm_sometimes_t, end), .dflt = "127" },
+ { FR_CONF_OFFSET("start", FR_TYPE_UINT32, rlm_sometimes_t, start), .dflt = "0" },
+ { FR_CONF_OFFSET("end", FR_TYPE_UINT32, rlm_sometimes_t, end), .dflt = "127" },
CONF_PARSER_TERMINATOR
};
static CONF_PARSER load_balance_dc_aware_config[] = {
{ FR_CONF_OFFSET("local_dc", FR_TYPE_STRING, rlm_sql_cassandra_t, lbdc_local_dc) },
- { FR_CONF_OFFSET("hosts_per_remote_dc", FR_TYPE_INTEGER, rlm_sql_cassandra_t, lbdc_hosts_per_remote_dc), .dflt = "0" },
- { FR_CONF_OFFSET("allow_remote_dcs_for_local_cl", FR_TYPE_BOOLEAN, rlm_sql_cassandra_t, lbdc_allow_remote_dcs_for_local_cl), .dflt = "no" },
+ { FR_CONF_OFFSET("hosts_per_remote_dc", FR_TYPE_UINT32, rlm_sql_cassandra_t, lbdc_hosts_per_remote_dc), .dflt = "0" },
+ { FR_CONF_OFFSET("allow_remote_dcs_for_local_cl", FR_TYPE_BOOL, rlm_sql_cassandra_t, lbdc_allow_remote_dcs_for_local_cl), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
{ FR_CONF_OFFSET("scale", FR_TYPE_TIMEVAL, rlm_sql_cassandra_t, lar_scale), .dflt = "0.1" },
{ FR_CONF_OFFSET("retry_period", FR_TYPE_TIMEVAL, rlm_sql_cassandra_t, lar_retry_period), .dflt = "10" },
{ FR_CONF_OFFSET("update_rate", FR_TYPE_TIMEVAL, rlm_sql_cassandra_t, lar_update_rate), .dflt = "0.1" },
- { FR_CONF_OFFSET("min_measured", FR_TYPE_INTEGER64, rlm_sql_cassandra_t, lar_min_measured), .dflt = "50" },
+ { FR_CONF_OFFSET("min_measured", FR_TYPE_UINT64, rlm_sql_cassandra_t, lar_min_measured), .dflt = "50" },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER driver_config[] = {
{ FR_CONF_OFFSET("consistency", FR_TYPE_STRING, rlm_sql_cassandra_t, consistency_str), .dflt = "quorum" },
- { FR_CONF_OFFSET("protocol_version", FR_TYPE_INTEGER, rlm_sql_cassandra_t, protocol_version) },
+ { FR_CONF_OFFSET("protocol_version", FR_TYPE_UINT32, rlm_sql_cassandra_t, protocol_version) },
- { FR_CONF_OFFSET("connections_per_host", FR_TYPE_INTEGER, rlm_sql_cassandra_t, connections_per_host) },
- { FR_CONF_OFFSET("connections_per_host_max", FR_TYPE_INTEGER, rlm_sql_cassandra_t, connections_per_host_max) },
+ { FR_CONF_OFFSET("connections_per_host", FR_TYPE_UINT32, rlm_sql_cassandra_t, connections_per_host) },
+ { FR_CONF_OFFSET("connections_per_host_max", FR_TYPE_UINT32, rlm_sql_cassandra_t, connections_per_host_max) },
- { FR_CONF_OFFSET("io_threads", FR_TYPE_INTEGER, rlm_sql_cassandra_t, io_threads) },
- { FR_CONF_OFFSET("io_queue_size", FR_TYPE_INTEGER, rlm_sql_cassandra_t, io_queue_size) },
- { FR_CONF_OFFSET("io_flush_requests_max", FR_TYPE_INTEGER, rlm_sql_cassandra_t, io_flush_requests_max) },
+ { FR_CONF_OFFSET("io_threads", FR_TYPE_UINT32, rlm_sql_cassandra_t, io_threads) },
+ { FR_CONF_OFFSET("io_queue_size", FR_TYPE_UINT32, rlm_sql_cassandra_t, io_queue_size) },
+ { FR_CONF_OFFSET("io_flush_requests_max", FR_TYPE_UINT32, rlm_sql_cassandra_t, io_flush_requests_max) },
- { FR_CONF_OFFSET("pending_requests_high", FR_TYPE_INTEGER, rlm_sql_cassandra_t, pending_requests_high) },
- { FR_CONF_OFFSET("pending_requests_low", FR_TYPE_INTEGER, rlm_sql_cassandra_t, pending_requests_low) },
- { FR_CONF_OFFSET("write_bytes_high", FR_TYPE_INTEGER, rlm_sql_cassandra_t, write_bytes_high) },
- { FR_CONF_OFFSET("write_bytes_low", FR_TYPE_INTEGER, rlm_sql_cassandra_t, write_bytes_low) },
+ { FR_CONF_OFFSET("pending_requests_high", FR_TYPE_UINT32, rlm_sql_cassandra_t, pending_requests_high) },
+ { FR_CONF_OFFSET("pending_requests_low", FR_TYPE_UINT32, rlm_sql_cassandra_t, pending_requests_low) },
+ { FR_CONF_OFFSET("write_bytes_high", FR_TYPE_UINT32, rlm_sql_cassandra_t, write_bytes_high) },
+ { FR_CONF_OFFSET("write_bytes_low", FR_TYPE_UINT32, rlm_sql_cassandra_t, write_bytes_low) },
- { FR_CONF_OFFSET("event_queue_size", FR_TYPE_INTEGER, rlm_sql_cassandra_t, event_queue_size) },
+ { FR_CONF_OFFSET("event_queue_size", FR_TYPE_UINT32, rlm_sql_cassandra_t, event_queue_size) },
- { FR_CONF_OFFSET("spawn_threshold", FR_TYPE_INTEGER, rlm_sql_cassandra_t, spawn_threshold) },
- { FR_CONF_OFFSET("spawn_max", FR_TYPE_INTEGER, rlm_sql_cassandra_t, spawn_max) },
+ { FR_CONF_OFFSET("spawn_threshold", FR_TYPE_UINT32, rlm_sql_cassandra_t, spawn_threshold) },
+ { FR_CONF_OFFSET("spawn_max", FR_TYPE_UINT32, rlm_sql_cassandra_t, spawn_max) },
{ FR_CONF_OFFSET("spawn_retry_delay", FR_TYPE_TIMEVAL, rlm_sql_cassandra_t, spawn_retry_delay) },
{ FR_CONF_POINTER("load_balance_dc_aware", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) load_balance_dc_aware_config },
- { FR_CONF_OFFSET("load_balance_round_robin", FR_TYPE_BOOLEAN, rlm_sql_cassandra_t, load_balance_round_robin), .dflt = "no" },
+ { FR_CONF_OFFSET("load_balance_round_robin", FR_TYPE_BOOL, rlm_sql_cassandra_t, load_balance_round_robin), .dflt = "no" },
- { FR_CONF_OFFSET("token_aware_routing", FR_TYPE_BOOLEAN, rlm_sql_cassandra_t, token_aware_routing), .dflt = "yes" },
+ { FR_CONF_OFFSET("token_aware_routing", FR_TYPE_BOOL, rlm_sql_cassandra_t, token_aware_routing), .dflt = "yes" },
{ FR_CONF_POINTER("latency_aware_routing", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) latency_aware_routing_config },
- { FR_CONF_OFFSET("tcp_keepalive", FR_TYPE_INTEGER, rlm_sql_cassandra_t, tcp_keepalive) },
- { FR_CONF_OFFSET("tcp_nodelay", FR_TYPE_BOOLEAN, rlm_sql_cassandra_t, tcp_nodelay), .dflt = "no" },
+ { FR_CONF_OFFSET("tcp_keepalive", FR_TYPE_UINT32, rlm_sql_cassandra_t, tcp_keepalive) },
+ { FR_CONF_OFFSET("tcp_nodelay", FR_TYPE_BOOL, rlm_sql_cassandra_t, tcp_nodelay), .dflt = "no" },
{ FR_CONF_POINTER("tls", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) tls_config },
CONF_PARSER_TERMINATOR
} rlm_sql_postgres_conn_t;
static CONF_PARSER driver_config[] = {
- { FR_CONF_OFFSET("send_application_name", FR_TYPE_BOOLEAN, rlm_sql_postgres_t, send_application_name), .dflt = "no" },
+ { FR_CONF_OFFSET("send_application_name", FR_TYPE_BOOL, rlm_sql_postgres_t, send_application_name), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER driver_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_OUTPUT | FR_TYPE_REQUIRED, rlm_sql_sqlite_t, filename) },
- { FR_CONF_OFFSET("busy_timeout", FR_TYPE_INTEGER, rlm_sql_sqlite_t, busy_timeout), .dflt = "200" },
+ { FR_CONF_OFFSET("busy_timeout", FR_TYPE_UINT32, rlm_sql_sqlite_t, busy_timeout), .dflt = "200" },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER module_config[] = {
{ FR_CONF_OFFSET("driver", FR_TYPE_STRING, rlm_sql_config_t, sql_driver_name), .dflt = "rlm_sql_null" },
{ FR_CONF_OFFSET("server", FR_TYPE_STRING, rlm_sql_config_t, sql_server), .dflt = "" }, /* Must be zero length so drivers can determine if it was set */
- { FR_CONF_OFFSET("port", FR_TYPE_INTEGER, rlm_sql_config_t, sql_port), .dflt = "0" },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT32, rlm_sql_config_t, sql_port), .dflt = "0" },
{ FR_CONF_OFFSET("login", FR_TYPE_STRING, rlm_sql_config_t, sql_login), .dflt = "" },
{ FR_CONF_OFFSET("password", FR_TYPE_STRING | FR_TYPE_SECRET, rlm_sql_config_t, sql_password), .dflt = "" },
{ FR_CONF_OFFSET("radius_db", FR_TYPE_STRING, rlm_sql_config_t, sql_db), .dflt = "radius" },
- { FR_CONF_OFFSET("read_groups", FR_TYPE_BOOLEAN, rlm_sql_config_t, read_groups), .dflt = "yes" },
- { FR_CONF_OFFSET("read_profiles", FR_TYPE_BOOLEAN, rlm_sql_config_t, read_profiles), .dflt = "yes" },
- { FR_CONF_OFFSET("read_clients", FR_TYPE_BOOLEAN, rlm_sql_config_t, do_clients), .dflt = "no" },
- { FR_CONF_OFFSET("delete_stale_sessions", FR_TYPE_BOOLEAN, rlm_sql_config_t, delete_stale_sessions), .dflt = "yes" },
+ { FR_CONF_OFFSET("read_groups", FR_TYPE_BOOL, rlm_sql_config_t, read_groups), .dflt = "yes" },
+ { FR_CONF_OFFSET("read_profiles", FR_TYPE_BOOL, rlm_sql_config_t, read_profiles), .dflt = "yes" },
+ { FR_CONF_OFFSET("read_clients", FR_TYPE_BOOL, rlm_sql_config_t, do_clients), .dflt = "no" },
+ { FR_CONF_OFFSET("delete_stale_sessions", FR_TYPE_BOOL, rlm_sql_config_t, delete_stale_sessions), .dflt = "yes" },
{ FR_CONF_OFFSET("sql_user_name", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sql_config_t, query_user), .dflt = "" },
{ FR_CONF_OFFSET("group_attribute", FR_TYPE_STRING, rlm_sql_config_t, group_attribute) },
{ FR_CONF_OFFSET("logfile", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sql_config_t, logfile) },
/*
* This only works for a few drivers.
*/
- { FR_CONF_OFFSET("query_timeout", FR_TYPE_INTEGER, rlm_sql_config_t, query_timeout) },
+ { FR_CONF_OFFSET("query_timeout", FR_TYPE_UINT32, rlm_sql_config_t, query_timeout) },
{ FR_CONF_POINTER("accounting", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) acct_config },
memset(&flags, 0, sizeof(flags));
flags.compare = 1; /* ugly hack */
- if (tmpl_define_undefined_attr(inst->paircmp_attr, FR_TYPE_INTEGER64, &flags) < 0) {
+ if (tmpl_define_undefined_attr(inst->paircmp_attr, FR_TYPE_UINT64, &flags) < 0) {
cf_log_err_cs(conf, "Failed defining counter attribute: %s", fr_strerror());
return -1;
}
flags.compare = 0;
- if (tmpl_define_undefined_attr(inst->limit_attr, FR_TYPE_INTEGER64, &flags) < 0) {
+ if (tmpl_define_undefined_attr(inst->limit_attr, FR_TYPE_UINT64, &flags) < 0) {
cf_log_err_cs(conf, "Failed defining check attribute: %s", fr_strerror());
return -1;
}
- if (inst->paircmp_attr->tmpl_da->type != FR_TYPE_INTEGER64) {
+ if (inst->paircmp_attr->tmpl_da->type != FR_TYPE_UINT64) {
cf_log_err_cs(conf, "Counter attribute %s MUST be integer64",
inst->paircmp_attr->tmpl_da->name);
return -1;
return -1;
}
- if (inst->limit_attr->tmpl_da->type != FR_TYPE_INTEGER64) {
+ if (inst->limit_attr->tmpl_da->type != FR_TYPE_UINT64) {
cf_log_err_cs(conf, "Check attribute %s MUST be integer64",
inst->limit_attr->tmpl_da->name);
return -1;
static CONF_PARSER module_config[] = {
{ FR_CONF_OFFSET("sql_module_instance", FR_TYPE_STRING, rlm_sqlhpwippool_t, sql_instance_name), .dflt = "sql" },
{ FR_CONF_OFFSET("db_name", FR_TYPE_STRING, rlm_sqlhpwippool_t, db_name), .dflt = "netvim" },
- { FR_CONF_OFFSET("no_free_fail", FR_TYPE_BOOLEAN, rlm_sqlhpwippool_t, no_free_fail), .dflt = "yes" },
- { FR_CONF_OFFSET("free_after", FR_TYPE_INTEGER, rlm_sqlhpwippool_t, free_after), .dflt = "300" },
- { FR_CONF_OFFSET("sync_after", FR_TYPE_INTEGER, rlm_sqlhpwippool_t, sync_after), .dflt = "25" },
+ { FR_CONF_OFFSET("no_free_fail", FR_TYPE_BOOL, rlm_sqlhpwippool_t, no_free_fail), .dflt = "yes" },
+ { FR_CONF_OFFSET("free_after", FR_TYPE_UINT32, rlm_sqlhpwippool_t, free_after), .dflt = "300" },
+ { FR_CONF_OFFSET("sync_after", FR_TYPE_UINT32, rlm_sqlhpwippool_t, sync_after), .dflt = "25" },
CONF_PARSER_TERMINATOR
};
static CONF_PARSER module_config[] = {
{ FR_CONF_OFFSET("sql_module_instance", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_sqlippool_t, sql_instance_name), .dflt = "sql" },
- { FR_CONF_OFFSET("lease_duration", FR_TYPE_INTEGER, rlm_sqlippool_t, lease_duration), .dflt = "86400" },
+ { FR_CONF_OFFSET("lease_duration", FR_TYPE_UINT32, rlm_sqlippool_t, lease_duration), .dflt = "86400" },
{ FR_CONF_OFFSET("pool_name", FR_TYPE_STRING, rlm_sqlippool_t, pool_name), .dflt = "" },
{ FR_CONF_OFFSET("default_pool", FR_TYPE_STRING, rlm_sqlippool_t, defaultpool), .dflt = "main_pool" },
- { FR_CONF_OFFSET("ipv6", FR_TYPE_BOOLEAN, rlm_sqlippool_t, ipv6) },
+ { FR_CONF_OFFSET("ipv6", FR_TYPE_BOOL, rlm_sqlippool_t, ipv6) },
{ FR_CONF_OFFSET("allocate_begin", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, allocate_begin), .dflt = "START TRANSACTION" },
{ FR_CONF_OFFSET("string", FR_TYPE_STRING, rlm_test_t, string) },
{ FR_CONF_OFFSET("string_m", FR_TYPE_STRING | FR_TYPE_MULTI, rlm_test_t, string_m) },
- { FR_CONF_OFFSET("boolean", FR_TYPE_BOOLEAN, rlm_test_t, boolean), .dflt = "no" },
- { FR_CONF_OFFSET("boolean_m", FR_TYPE_BOOLEAN | FR_TYPE_MULTI, rlm_test_t, boolean_m), .dflt = "no" },
+ { FR_CONF_OFFSET("boolean", FR_TYPE_BOOL, rlm_test_t, boolean), .dflt = "no" },
+ { FR_CONF_OFFSET("boolean_m", FR_TYPE_BOOL | FR_TYPE_MULTI, rlm_test_t, boolean_m), .dflt = "no" },
- { FR_CONF_OFFSET("integer", FR_TYPE_INTEGER, rlm_test_t, integer), .dflt = "1" },
- { FR_CONF_OFFSET("integer_m", FR_TYPE_INTEGER | FR_TYPE_MULTI, rlm_test_t, integer_m), .dflt = "2" },
+ { FR_CONF_OFFSET("integer", FR_TYPE_UINT32, rlm_test_t, integer), .dflt = "1" },
+ { FR_CONF_OFFSET("integer_m", FR_TYPE_UINT32 | FR_TYPE_MULTI, rlm_test_t, integer_m), .dflt = "2" },
{ FR_CONF_OFFSET("ipv4_addr", FR_TYPE_IPV4_ADDR, rlm_test_t, ipv4_addr), .dflt = "*" },
{ FR_CONF_OFFSET("ipv4_addr_m", FR_TYPE_IPV4_ADDR | FR_TYPE_MULTI, rlm_test_t, ipv4_addr_m), .dflt = "*" },
{ FR_CONF_OFFSET("octets", FR_TYPE_OCTETS, rlm_test_t, octets) },
{ FR_CONF_OFFSET("octets_m", FR_TYPE_OCTETS | FR_TYPE_MULTI, rlm_test_t, octets_m) },
- { FR_CONF_OFFSET("bytes", FR_TYPE_BYTE, rlm_test_t, byte) },
- { FR_CONF_OFFSET("bytes_m", FR_TYPE_BYTE | FR_TYPE_MULTI, rlm_test_t, byte_m) },
+ { FR_CONF_OFFSET("bytes", FR_TYPE_UINT8, rlm_test_t, byte) },
+ { FR_CONF_OFFSET("bytes_m", FR_TYPE_UINT8 | FR_TYPE_MULTI, rlm_test_t, byte_m) },
{ FR_CONF_OFFSET("ifid", FR_TYPE_IFID, rlm_test_t, ifid) },
{ FR_CONF_OFFSET("ifid_m", FR_TYPE_IFID | FR_TYPE_MULTI, rlm_test_t, ifid_m) },
- { FR_CONF_OFFSET("short", FR_TYPE_SHORT, rlm_test_t, shortint) },
- { FR_CONF_OFFSET("short_m", FR_TYPE_SHORT | FR_TYPE_MULTI, rlm_test_t, shortint_m) },
+ { FR_CONF_OFFSET("short", FR_TYPE_UINT16, rlm_test_t, shortint) },
+ { FR_CONF_OFFSET("short_m", FR_TYPE_UINT16 | FR_TYPE_MULTI, rlm_test_t, shortint_m) },
{ FR_CONF_OFFSET("ethernet", FR_TYPE_ETHERNET, rlm_test_t, ethernet) },
{ FR_CONF_OFFSET("ethernet_m", FR_TYPE_ETHERNET | FR_TYPE_MULTI, rlm_test_t, ethernet_m) },
- { FR_CONF_OFFSET("signed", FR_TYPE_SIGNED, rlm_test_t, sinteger) },
- { FR_CONF_OFFSET("signed_m", FR_TYPE_SIGNED | FR_TYPE_MULTI, rlm_test_t, sinteger_m) },
+ { FR_CONF_OFFSET("signed", FR_TYPE_INT32, rlm_test_t, sinteger) },
+ { FR_CONF_OFFSET("signed_m", FR_TYPE_INT32 | FR_TYPE_MULTI, rlm_test_t, sinteger_m) },
- { FR_CONF_OFFSET("uint64", FR_TYPE_INTEGER64, rlm_test_t, integer64) },
- { FR_CONF_OFFSET("uint64_m", FR_TYPE_INTEGER64 | FR_TYPE_MULTI, rlm_test_t, integer64_m) },
+ { FR_CONF_OFFSET("uint64", FR_TYPE_UINT64, rlm_test_t, integer64) },
+ { FR_CONF_OFFSET("uint64_m", FR_TYPE_UINT64 | FR_TYPE_MULTI, rlm_test_t, integer64_m) },
{ FR_CONF_OFFSET("timeval", FR_TYPE_TIMEVAL, rlm_test_t, timeval) },
{ FR_CONF_OFFSET("timeval_m", FR_TYPE_TIMEVAL | FR_TYPE_MULTI, rlm_test_t, timeval_m) },
*/
static const CONF_PARSER module_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT | FR_TYPE_REQUIRED, rlm_unbound_t, filename), .dflt = "${modconfdir}/unbound/default.conf" },
- { FR_CONF_OFFSET("timeout", FR_TYPE_INTEGER, rlm_unbound_t, timeout), .dflt = "3000" },
+ { FR_CONF_OFFSET("timeout", FR_TYPE_UINT32, rlm_unbound_t, timeout), .dflt = "3000" },
CONF_PARSER_TERMINATOR
};
* Hacks
*/
switch (type) {
- case FR_TYPE_SIGNED:
- case FR_TYPE_INTEGER:
+ case FR_TYPE_INT32:
+ case FR_TYPE_UINT32:
case FR_TYPE_DATE:
cast->vp_integer = ntohl(cast->vp_integer);
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
cast->vp_short = ((input[offset] << 8) | input[offset + 1]);
break;
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
cast->vp_integer64 = ntohll(cast->vp_integer64);
break;
} rlm_wimax_t;
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("delete_mppe_keys", FR_TYPE_BOOLEAN, rlm_wimax_t, delete_mppe_keys), .dflt = "no" },
+ { FR_CONF_OFFSET("delete_mppe_keys", FR_TYPE_BOOL, rlm_wimax_t, delete_mppe_keys), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER group_config[] = {
{ FR_CONF_OFFSET("group_search_username", FR_TYPE_TMPL, rlm_winbind_t, group_username) },
- { FR_CONF_OFFSET("group_add_domain", FR_TYPE_BOOLEAN, rlm_winbind_t, group_add_domain), .dflt = "yes" },
+ { FR_CONF_OFFSET("group_add_domain", FR_TYPE_BOOL, rlm_winbind_t, group_add_domain), .dflt = "yes" },
{ FR_CONF_OFFSET("group_attribute", FR_TYPE_STRING, rlm_winbind_t, group_attribute) },
CONF_PARSER_TERMINATOR
};
#ifdef HAVE_YKCLIENT
static const CONF_PARSER validation_config[] = {
- { FR_CONF_OFFSET("client_id", FR_TYPE_INTEGER, rlm_yubikey_t, client_id), .dflt = 0 },
+ { FR_CONF_OFFSET("client_id", FR_TYPE_UINT32, rlm_yubikey_t, client_id), .dflt = 0 },
{ FR_CONF_OFFSET("api_key", FR_TYPE_STRING | FR_TYPE_SECRET, rlm_yubikey_t, api_key) },
CONF_PARSER_TERMINATOR
};
#endif
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("id_length", FR_TYPE_INTEGER, rlm_yubikey_t, id_len), .dflt = "12" },
- { FR_CONF_OFFSET("split", FR_TYPE_BOOLEAN, rlm_yubikey_t, split), .dflt = "yes" },
- { FR_CONF_OFFSET("decrypt", FR_TYPE_BOOLEAN, rlm_yubikey_t, decrypt), .dflt = "no" },
- { FR_CONF_OFFSET("validate", FR_TYPE_BOOLEAN, rlm_yubikey_t, validate), .dflt = "no" },
+ { FR_CONF_OFFSET("id_length", FR_TYPE_UINT32, rlm_yubikey_t, id_len), .dflt = "12" },
+ { FR_CONF_OFFSET("split", FR_TYPE_BOOL, rlm_yubikey_t, split), .dflt = "yes" },
+ { FR_CONF_OFFSET("decrypt", FR_TYPE_BOOL, rlm_yubikey_t, decrypt), .dflt = "no" },
+ { FR_CONF_OFFSET("validate", FR_TYPE_BOOL, rlm_yubikey_t, validate), .dflt = "no" },
#ifdef HAVE_YKCLIENT
{ FR_CONF_POINTER("validation", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) validation_config },
#endif
[FR_TYPE_IFID] = {8, 8},
[FR_TYPE_ETHERNET] = {6, 6},
- [FR_TYPE_BOOLEAN] = {1, 1},
- [FR_TYPE_BYTE] = {1, 1},
- [FR_TYPE_SHORT] = {2, 2},
- [FR_TYPE_INTEGER] = {4, 4},
- [FR_TYPE_INTEGER64] = {8, 8},
+ [FR_TYPE_BOOL] = {1, 1},
+ [FR_TYPE_UINT8] = {1, 1},
+ [FR_TYPE_UINT16] = {2, 2},
+ [FR_TYPE_UINT32] = {4, 4},
+ [FR_TYPE_UINT64] = {8, 8},
[FR_TYPE_DATE] = {4, 4},
[FR_TYPE_ABINARY] = {32, ~0},
tag = p[0];
data_len -= 1;
- } else if (parent->type == FR_TYPE_INTEGER) {
+ } else if (parent->type == FR_TYPE_UINT32) {
memcpy(buffer, p, attr_len);
tag = buffer[0];
buffer[0] = 0;
if (data_len > sizeof(vp->vp_filter)) goto raw;
break;
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
case FR_TYPE_IPV4_ADDR:
case FR_TYPE_DATE:
- case FR_TYPE_SIGNED:
+ case FR_TYPE_INT32:
if (data_len != 4) goto raw;
break;
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
case FR_TYPE_IFID:
if (data_len != 8) goto raw;
break;
}
break;
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
if (data_len != 1) goto raw;
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
if (data_len != 2) goto raw;
break;
vp->vp_length = data_len;
break;
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
vp->vp_byte = p[0];
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
vp->vp_short = (p[0] << 8) | p[1];
break;
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
memcpy(&vp->vp_integer, p, 4);
vp->vp_integer = ntohl(vp->vp_integer);
break;
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
memcpy(&vp->vp_integer64, p, 8);
vp->vp_integer64 = ntohll(vp->vp_integer64);
break;
memcpy(&vp->vp_ip, &tmp_prefix, sizeof(vp->vp_ip));
break;
- case FR_TYPE_SIGNED: /* overloaded with vp_integer */
+ case FR_TYPE_INT32: /* overloaded with vp_integer */
memcpy(&vp->vp_integer, p, 4);
vp->vp_integer = ntohl(vp->vp_integer);
break;
memcpy(out, &vp->data.datum, outlen);
break;
- case FR_TYPE_BOOLEAN:
+ case FR_TYPE_BOOL:
out[0] = vp->vp_byte & 0x01;
break;
- case FR_TYPE_BYTE:
+ case FR_TYPE_UINT8:
out[0] = vp->vp_byte & 0xff;
break;
- case FR_TYPE_SHORT:
+ case FR_TYPE_UINT16:
out[0] = (vp->vp_short >> 8) & 0xff;
out[1] = vp->vp_short & 0xff;
break;
- case FR_TYPE_INTEGER:
+ case FR_TYPE_UINT32:
lvalue = htonl(vp->vp_integer);
memcpy(out, &lvalue, sizeof(lvalue));
break;
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT64:
lvalue64 = htonll(vp->vp_integer64);
memcpy(out, &lvalue64, sizeof(lvalue64));
break;
memcpy(out, &lvalue, sizeof(lvalue));
break;
- case FR_TYPE_SIGNED:
+ case FR_TYPE_INT32:
{
int32_t slvalue = htonl(vp->vp_signed);
memcpy(out, &slvalue, sizeof(slvalue));
case FR_TYPE_STRUCT:
case FR_TYPE_SIZE:
case FR_TYPE_TIMEVAL:
- case FR_TYPE_DECIMAL:
+ case FR_TYPE_FLOAT64:
case FR_TYPE_MAX:
fr_strerror_printf("Cannot get data for VALUE_PAIR type %i", vp->vp_type);
return -1;
case FR_TYPE_IPV4_PREFIX:
case FR_TYPE_ABINARY:
case FR_TYPE_ETHERNET: /* just in case */
- case FR_TYPE_BYTE:
- case FR_TYPE_BOOLEAN:
- case FR_TYPE_SHORT:
- case FR_TYPE_INTEGER:
- case FR_TYPE_INTEGER64:
+ case FR_TYPE_UINT8:
+ case FR_TYPE_BOOL:
+ case FR_TYPE_UINT16:
+ case FR_TYPE_UINT32:
+ case FR_TYPE_UINT64:
case FR_TYPE_DATE:
- case FR_TYPE_SIGNED:
+ case FR_TYPE_INT32:
len = fr_radius_encode_value_hton(buffer, sizeof(buffer), vp);
if (len < 0) return -1;
data = buffer;
if (len > ((ssize_t) (outlen - 1))) len = outlen - 1;
ptr[0] = vp->tag;
ptr++;
- } else if (vp->vp_type == FR_TYPE_INTEGER) {
+ } else if (vp->vp_type == FR_TYPE_UINT32) {
buffer[0] = vp->tag;
} /* else it can't be any other type */
}
case FR_TYPE_INVALID:
case FR_TYPE_VENDOR:
case FR_TYPE_TIMEVAL:
- case FR_TYPE_DECIMAL:
+ case FR_TYPE_FLOAT64:
case FR_TYPE_EVS:
case FR_TYPE_MAX:
fr_strerror_printf("%s: Cannot encode attribute %s", __FUNCTION__, vp->da->name);
projects / thirdparty / freeradius-server.git / commitdiff
