typedef struct timeval _timeval_t;
#ifdef HAVE_BUILTIN_CHOOSE_EXPR
-typedef void _mismatch_vp_tmpl; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_vp_tmpl_m; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_char; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_char_m; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_bool; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_bool_m; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_uint32; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_uint32_m; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_fripaddr; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_fripaddr_m; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_time; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_time_m; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_abinary; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_abinary_m; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_uint8; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_uint8_m; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_uint8_m_m; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_ifid; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_ifid_m; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_uint16; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_uint16_m; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_ethernet; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_ethernet_m; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_int32; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_int32_m; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_uint64; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_uint64_m; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_size; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_size_m; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_timeval; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_timeval_m; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void _mismatch_default; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-
-typedef void conf_type_mismatch; //!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
-typedef void conf_type_invalid; //!< Dummy type used to indicate invalid PW_TYPE_*.
+typedef void _mismatch_vp_tmpl; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_vp_tmpl_m; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_char; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_char_m; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_bool; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_bool_m; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_uint32; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_uint32_m; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_fripaddr; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_fripaddr_m; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_time; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_time_m; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_abinary; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_abinary_m; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_uint8; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_uint8_m; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_uint8_m_m; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_ifid; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_ifid_m; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_uint16; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_uint16_m; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_ethernet; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_ethernet_m; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_int32; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_int32_m; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_uint64; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_uint64_m; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_size; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_size_m; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_timeval; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_timeval_m; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_default; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+
+typedef void conf_type_mismatch; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void conf_type_invalid; //!< Dummy type used to indicate invalid FR_TYPE_*.
/** Check if two types are compatible (the C11 way)
*
*
* @note The warnings/errors emitted are usually awful.
*
- * @param _t a #PW_TYPE value with optional PW_TYPE_* flags.
+ * @param _t a #fr_type_t value with optional FR_TYPE_* flags.
* @param _ct data type of global or struct field, obtained with ``__typeof__``.
* @param _p Pointer or offset.
*/
# define FR_CONF_TYPE_CHECK(_t, _ct, _p) \
-__builtin_choose_expr((_t) & PW_TYPE_SUBSECTION, _p, \
-__builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_SIZE) && !((_t) & PW_TYPE_MULTI), \
+__builtin_choose_expr((_t) & FR_TYPE_SUBSECTION, _p, \
+__builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_SIZE) && !((_t) & FR_TYPE_MULTI), \
__builtin_choose_expr(is_compatible((_ct), size_t *), _p, (_mismatch_size) 0), \
-__builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_SIZE) && ((_t) & PW_TYPE_MULTI), \
+__builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_SIZE) && ((_t) & FR_TYPE_MULTI), \
__builtin_choose_expr(is_compatible((_ct), size_t **), _p, (_mismatch_size_m) 0), \
-__builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_DATE) && !((_t) & PW_TYPE_MULTI), \
+__builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_DATE) && !((_t) & FR_TYPE_MULTI), \
__builtin_choose_expr(is_compatible((_ct), time_t *), _p, (_mismatch_time) 0), \
-__builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_DATE) && ((_t) & PW_TYPE_MULTI), \
+__builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_DATE) && ((_t) & FR_TYPE_MULTI), \
__builtin_choose_expr(is_compatible((_ct), time_t **), _p, (_mismatch_time_m) 0), \
_Generic((_ct), \
- vp_tmpl_t ** : __builtin_choose_expr(((_t) & PW_TYPE_TMPL) && !((_t) & PW_TYPE_MULTI), \
+ vp_tmpl_t ** : __builtin_choose_expr(((_t) & FR_TYPE_TMPL) && !((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_vp_tmpl) 0), \
- vp_tmpl_t *** : __builtin_choose_expr(((_t) & PW_TYPE_TMPL) && ((_t) & PW_TYPE_MULTI), \
+ vp_tmpl_t *** : __builtin_choose_expr(((_t) & FR_TYPE_TMPL) && ((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_vp_tmpl_m) 0), \
- char const ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_STRING) && !((_t) & PW_TYPE_MULTI), \
+ char const ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_STRING) && !((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_char) 0), \
- char const *** : __builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_STRING) && ((_t) & PW_TYPE_MULTI), \
+ 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) == PW_TYPE_BOOLEAN) && !((_t) & PW_TYPE_MULTI), \
+ bool * : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_BOOLEAN) && !((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_bool) 0), \
- bool ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_BOOLEAN) && ((_t) & PW_TYPE_MULTI), \
+ bool ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_BOOLEAN) && ((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_bool_m) 0), \
- uint32_t * : __builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_INTEGER) && !((_t) & PW_TYPE_MULTI), \
+ uint32_t * : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_INTEGER) && !((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_uint32) 0), \
- uint32_t ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_INTEGER) && ((_t) & PW_TYPE_MULTI), \
+ uint32_t ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_INTEGER) && ((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_uint32_m) 0), \
- fr_ipaddr_t * : __builtin_choose_expr(((PW_BASE_TYPE(_t) == PW_TYPE_IPV4_ADDR) || \
- (PW_BASE_TYPE(_t) == PW_TYPE_IPV4_PREFIX) || \
- (PW_BASE_TYPE(_t) == PW_TYPE_IPV6_ADDR) || \
- (PW_BASE_TYPE(_t) == PW_TYPE_IPV6_PREFIX) || \
- (PW_BASE_TYPE(_t) == PW_TYPE_COMBO_IP_ADDR)) || \
- !((_t) & PW_TYPE_MULTI), _p, (_mismatch_fripaddr) 0), \
- fr_ipaddr_t ** : __builtin_choose_expr(((PW_BASE_TYPE(_t) == PW_TYPE_IPV4_ADDR) || \
- (PW_BASE_TYPE(_t) == PW_TYPE_IPV4_PREFIX) || \
- (PW_BASE_TYPE(_t) == PW_TYPE_IPV6_ADDR) || \
- (PW_BASE_TYPE(_t) == PW_TYPE_IPV6_PREFIX) || \
- (PW_BASE_TYPE(_t) == PW_TYPE_COMBO_IP_ADDR)) && \
- ((_t) & PW_TYPE_MULTI), _p, (_mismatch_fripaddr_m) 0), \
- size_t[32/sizeof(size_t)] : __builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_ABINARY) && !((_t) & PW_TYPE_MULTI), \
+ fr_ipaddr_t * : __builtin_choose_expr(((PW_BASE_TYPE(_t) == FR_TYPE_IPV4_ADDR) || \
+ (PW_BASE_TYPE(_t) == FR_TYPE_IPV4_PREFIX) || \
+ (PW_BASE_TYPE(_t) == FR_TYPE_IPV6_ADDR) || \
+ (PW_BASE_TYPE(_t) == FR_TYPE_IPV6_PREFIX) || \
+ (PW_BASE_TYPE(_t) == FR_TYPE_COMBO_IP_ADDR)) || \
+ !((_t) & FR_TYPE_MULTI), _p, (_mismatch_fripaddr) 0), \
+ fr_ipaddr_t ** : __builtin_choose_expr(((PW_BASE_TYPE(_t) == FR_TYPE_IPV4_ADDR) || \
+ (PW_BASE_TYPE(_t) == FR_TYPE_IPV4_PREFIX) || \
+ (PW_BASE_TYPE(_t) == FR_TYPE_IPV6_ADDR) || \
+ (PW_BASE_TYPE(_t) == FR_TYPE_IPV6_PREFIX) || \
+ (PW_BASE_TYPE(_t) == FR_TYPE_COMBO_IP_ADDR)) && \
+ ((_t) & FR_TYPE_MULTI), _p, (_mismatch_fripaddr_m) 0), \
+ size_t[32/sizeof(size_t)] : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_ABINARY) && !((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_abinary) 0), \
- size_t*[32/sizeof(size_t)] : __builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_ABINARY) && ((_t) & PW_TYPE_MULTI), \
+ size_t*[32/sizeof(size_t)] : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_ABINARY) && ((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_abinary_m) 0), \
- uint8_t const * : __builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_OCTETS) && !((_t) & PW_TYPE_MULTI), \
+ uint8_t const * : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_OCTETS) && !((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_uint8) 0), \
- uint8_t const **: __builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_OCTETS) && ((_t) & PW_TYPE_MULTI), \
+ 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) == PW_TYPE_BYTE) && !((_t) & PW_TYPE_MULTI), \
+ uint8_t * : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_BYTE) && !((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_uint8) 0), \
- uint8_t ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_BYTE) && ((_t) & PW_TYPE_MULTI), \
+ uint8_t ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_BYTE) && ((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_uint8_m) 0), \
- uint8_t[8] : __builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_IFID) && !(_t & PW_TYPE_MULTI), \
+ 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) == PW_TYPE_IFID) && ((_t) & PW_TYPE_MULTI), \
+ 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) == PW_TYPE_SHORT) && !((_t) & PW_TYPE_MULTI), \
+ uint16_t * : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_SHORT) && !((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_uint16) 0), \
- uint16_t ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_SHORT) && ((_t) & PW_TYPE_MULTI), \
+ uint16_t ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_SHORT) && ((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_uint16_m) 0), \
- uint8_t[6] : __builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_ETHERNET) && !((_t) & PW_TYPE_MULTI), \
+ 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) == PW_TYPE_ETHERNET) && ((_t) & PW_TYPE_MULTI), \
+ 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) == PW_TYPE_SIGNED) && !((_t) & PW_TYPE_MULTI), \
+ int32_t * : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_SIGNED) && !((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_int32) 0), \
- int32_t ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_SIGNED) && ((_t) & PW_TYPE_MULTI), \
+ int32_t ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_SIGNED) && ((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_int32_m) 0), \
- uint64_t * : __builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_INTEGER64) && !((_t) & PW_TYPE_MULTI), \
+ uint64_t * : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_INTEGER64) && !((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_uint64) 0), \
- uint64_t ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_INTEGER64) && ((_t) & PW_TYPE_MULTI), \
+ uint64_t ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_INTEGER64) && ((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_uint64_m) 0), \
- _timeval_t * : __builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_TIMEVAL) && !((_t) & PW_TYPE_MULTI), \
+ _timeval_t * : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_TIMEVAL) && !((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_timeval) 0), \
- _timeval_t ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_TIMEVAL) && ((_t) & PW_TYPE_MULTI), \
+ _timeval_t ** : __builtin_choose_expr((PW_BASE_TYPE(_t) == FR_TYPE_TIMEVAL) && ((_t) & FR_TYPE_MULTI), \
_p, (_mismatch_timeval_m) 0), \
default: (conf_type_mismatch)0))))))
.offset = FR_CONF_TYPE_CHECK((_t), &(((_s *)NULL)->_f), offsetof(_s, _f))
# define FR_CONF_IS_SET_OFFSET(_n, _t, _s, _f) \
.name = _n, \
- .type = (_t) | PW_TYPE_IS_SET, \
+ .type = (_t) | FR_TYPE_IS_SET, \
.offset = FR_CONF_TYPE_CHECK((_t), &(((_s *)NULL)->_f), offsetof(_s, _f)), \
.is_set_offset = offsetof(_s, _f ## _is_set)
# define FR_CONF_POINTER(_n, _t, _p) \
# define FR_CONF_IS_SET_POINTER(_n, _t, _p) \
.name = _n, \
- .type = (_t) | PW_TYPE_IS_SET, \
+ .type = (_t) | FR_TYPE_IS_SET, \
.data = FR_CONF_TYPE_CHECK((_t), (_p), _p), \
.is_set_ptr = _p ## _is_set
# define FR_ITEM_POINTER(_t, _p) _t, FR_CONF_TYPE_CHECK((_t), (_p), _p)
* Parse multiple instance of a subsection.
*
* @param _n name of subsection to search for.
- * @param _t Must be PW_TYPE_SUBSECTION | PW_TYPE_MULTI and any optional flags.
+ * @param _t Must be FR_TYPE_SUBSECTION | FR_TYPE_MULTI and any optional flags.
* @param _s instance data struct.
* @param _f field in instance data struct.
* @param _sub CONF_PARSER array to use to parse subsection data.
.offset = offsetof(_s, _f)
# define FR_CONF_IS_SET_OFFSET(_n, _t, _s, _f) \
.name = _n, \
- .type = (_t) | PW_TYPE_IS_SET, \
+ .type = (_t) | FR_TYPE_IS_SET, \
.offset = offsetof(_s, _f), \
.is_set_offset = offsetof(_s, _f ## _is_set)
# define FR_CONF_POINTER(_n, _t, _p) \
.data = _p
# define FR_CONF_IS_SET_POINTER(_n, _t, _p) \
.name = _n, \
- .type = (_t) | PW_TYPE_IS_SET, \
+ .type = (_t) | FR_TYPE_IS_SET, \
.data = _p, \
.is_set_ptr = _p ## _is_set
# define FR_ITEM_POINTER(_t, _p) _t, _p
* Parse multiple instance of a subsection.
*
* @param _n name of subsection to search for.
- * @param _t Must be PW_TYPE_SUBSECTION | PW_TYPE_MULTI and any optional flags.
+ * @param _t Must be FR_TYPE_SUBSECTION | FR_TYPE_MULTI and any optional flags.
* @param _s instance data struct.
* @param _f field in instance data struct.
* @param _sub CONF_PARSER array to use to parse subsection data.
#define FR_CONF_DEPRECATED(_n, _t, _p, _f) \
.name = _n, \
- .type = (_t) | PW_TYPE_DEPRECATED
+ .type = (_t) | FR_TYPE_DEPRECATED
/*
* Instead of putting the information into a configuration structure,
* the configuration file routines MAY just parse it directly into
* user-supplied variables.
*/
-#define PW_TYPE_SUBSECTION 102
+#define FR_TYPE_SUBSECTION 102
/** @name #CONF_PARSER type flags
*
- * These flags should be or'd with another PW_TYPE_* value to create validation
+ * These flags should be or'd with another FR_TYPE_* value to create validation
* rules for the #cf_pair_parse function.
*
- * @note File PW_TYPE_FILE_* types have a base type of string, so they're validated
+ * @note File FR_TYPE_FILE_* types have a base type of string, so they're validated
* correctly by the config parser.
* @{
*/
-#define PW_TYPE_DEPRECATED (1 << 10) //!< If a matching #CONF_PAIR is found,
+#define FR_TYPE_DEPRECATED (1 << 10) //!< If a matching #CONF_PAIR is found,
//!< error out with a deprecated message.
-#define PW_TYPE_REQUIRED (1 << 11) //!< Error out if no matching #CONF_PAIR
+#define FR_TYPE_REQUIRED (1 << 11) //!< Error out if no matching #CONF_PAIR
//!< is found, and no dflt value is set.
-#define PW_TYPE_ATTRIBUTE (1 << 12) //!< Value must resolve to attribute in dict
- //!< (deprecated, use #PW_TYPE_TMPL).
-#define PW_TYPE_SECRET (1 << 13) //!< Only print value if debug level >= 3.
+#define FR_TYPE_ATTRIBUTE (1 << 12) //!< Value must resolve to attribute in dict
+ //!< (deprecated, use #FR_TYPE_TMPL).
+#define FR_TYPE_SECRET (1 << 13) //!< Only print value if debug level >= 3.
-#define PW_TYPE_FILE_INPUT ((1 << 14) | PW_TYPE_STRING) //!< File matching value must exist,
+#define FR_TYPE_FILE_INPUT ((1 << 14) | FR_TYPE_STRING) //!< File matching value must exist,
//!< and must be readable.
-#define PW_TYPE_FILE_OUTPUT ((1 << 15) | PW_TYPE_STRING) //!< File matching value must exist,
+#define FR_TYPE_FILE_OUTPUT ((1 << 15) | FR_TYPE_STRING) //!< File matching value must exist,
//!< and must be writeable.
-#define PW_TYPE_XLAT (1 << 16) //!< string will be dynamically expanded.
-#define PW_TYPE_TMPL (1 << 17) //!< CONF_PAIR should be parsed as a template.
+#define FR_TYPE_XLAT (1 << 16) //!< string will be dynamically expanded.
+#define FR_TYPE_TMPL (1 << 17) //!< CONF_PAIR should be parsed as a template.
-#define PW_TYPE_MULTI (1 << 18) //!< CONF_PAIR can have multiple copies.
-#define PW_TYPE_NOT_EMPTY (1 << 19) //!< CONF_PAIR is required to have a non zero
+#define FR_TYPE_MULTI (1 << 18) //!< CONF_PAIR can have multiple copies.
+#define FR_TYPE_NOT_EMPTY (1 << 19) //!< CONF_PAIR is required to have a non zero
//!< length value.
-#define PW_TYPE_FILE_EXISTS ((1 << 20) | PW_TYPE_STRING) //!< File matching value must exist
+#define FR_TYPE_FILE_EXISTS ((1 << 20) | FR_TYPE_STRING) //!< File matching value must exist
-#define PW_TYPE_IS_SET (1 << 21) //!< Write whether this config item was
+#define FR_TYPE_IS_SET (1 << 21) //!< Write whether this config item was
//!< left as the default to is_set_offset
//!< or is_set_ptr.
* Example with #FR_CONF_OFFSET :
@code{.c}
static CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("example", PW_TYPE_STRING | PW_TYPE_NOT_EMPTY, example_instance_t, example), .dflt = "default_value" },
+ { FR_CONF_OFFSET("example", FR_TYPE_STRING | FR_TYPE_NOT_EMPTY, example_instance_t, example), .dflt = "default_value" },
CONF_PARSER_TERMINATOR
}
@endcode
* Example with #FR_CONF_POINTER :
@code{.c}
static CONF_PARSER global_config[] = {
- { FR_CONF_POINTER("example", PW_TYPE_STRING | PW_TYPE_NOT_EMPTY, &my_global), .dflt = "default_value" },
+ { FR_CONF_POINTER("example", FR_TYPE_STRING | FR_TYPE_NOT_EMPTY, &my_global), .dflt = "default_value" },
CONF_PARSER_TERMINATOR
}
@endcode
*/
typedef struct CONF_PARSER {
char const *name; //!< Name of the #CONF_ITEM to parse.
- uint32_t type; //!< A #PW_TYPE value, may be or'd with one or more PW_TYPE_* flags.
+ uint32_t type; //!< A #fr_type_t value, may be or'd with one or more FR_TYPE_* flags.
//!< @see cf_pair_parse.
size_t offset; //!< Relative offset of field or structure to write the parsed value to.
- //!< When #type is set to #PW_TYPE_SUBSECTION, may be used to specify
+ //!< When #type is set to #FR_TYPE_SUBSECTION, may be used to specify
//!< a base offset to add to all offsets contained within the
//!< subsection.
//!< @note Must be used exclusively to #data.
void *data; //!< Pointer to a static variable to write the parsed value to.
//!< @note Must be used exclusively to #offset.
- /** Where to write status if PW_TYPE_IS_DEFAULT is set
+ /** Where to write status if FR_TYPE_IS_DEFAULT is set
*
* @note Which field is used, is determined by whether
* data ptr is set.
*/
union {
- size_t is_set_offset; //!< If type contains PW_TYPE_IS_DEFAULT write status to bool.
+ size_t is_set_offset; //!< If type contains FR_TYPE_IS_DEFAULT write status to bool.
//!< at this address.
- void *is_set_ptr; //!< If type contains PW_TYPE_IS_DEFAULT write status to ptr
+ void *is_set_ptr; //!< If type contains FR_TYPE_IS_DEFAULT write status to ptr
//!< at this address.
};
char const *dflt; //!< Default as it would appear in radiusd.conf.
struct {
- struct CONF_PARSER const *subcs; //!< When type is set to #PW_TYPE_SUBSECTION, should
+ struct CONF_PARSER const *subcs; //!< When type is set to #FR_TYPE_SUBSECTION, should
//!< be a pointer to the start of another array of
//!< #CONF_PARSER structs, forming the subsection.
size_t subcs_size; //!< If non-zero, allocate structs of this size to hold
} fr_dict_attr_flags_t;
extern const FR_NAME_NUMBER dict_attr_types[];
-extern const size_t dict_attr_sizes[PW_TYPE_MAX + 1][2];
+extern const size_t dict_attr_sizes[FR_TYPE_MAX + 1][2];
typedef struct dict_attr fr_dict_attr_t;
typedef struct fr_dict fr_dict_t;
struct dict_attr {
unsigned int vendor; //!< Vendor that defines this attribute.
unsigned int attr; //!< Attribute number.
- PW_TYPE type; //!< Value type.
+ fr_type_t type; //!< Value type.
fr_dict_attr_t const *parent; //!< Immediate parent of this attribute.
fr_dict_attr_t const **children; //!< Children of this attribute.
*
*/
extern bool const fr_dict_attr_allowed_chars[UINT8_MAX];
-extern bool const fr_dict_non_data_types[PW_TYPE_MAX + 1];
-extern bool const fr_dict_enum_types[PW_TYPE_MAX + 1];
+extern bool const fr_dict_non_data_types[FR_TYPE_MAX + 1];
+extern bool const fr_dict_enum_types[FR_TYPE_MAX + 1];
/*
* Dictionary debug
int fr_dict_vendor_add(fr_dict_t *dict, char const *name, unsigned int value);
int fr_dict_attr_add(fr_dict_t *dict, fr_dict_attr_t const *parent, char const *name, int attr,
- PW_TYPE type, fr_dict_attr_flags_t flags);
+ fr_type_t type, fr_dict_attr_flags_t flags);
int fr_dict_enum_add(fr_dict_t *dict, char const *attr, char const *alias, int value);
fr_dict_attr_t const *fr_dict_attr_by_num(fr_dict_t *dict, unsigned int vendor, unsigned int attr);
-fr_dict_attr_t const *fr_dict_attr_by_type(fr_dict_attr_t const *da, PW_TYPE type);
+fr_dict_attr_t const *fr_dict_attr_by_type(fr_dict_attr_t const *da, fr_type_t type);
fr_dict_attr_t const *fr_dict_attr_child_by_da(fr_dict_attr_t const *parent, fr_dict_attr_t const *child);
size_t fr_pair_snprint(char *out, size_t outlen, VALUE_PAIR const *vp);
void fr_pair_fprint(FILE *, VALUE_PAIR const *vp);
void fr_pair_list_fprint(FILE *, VALUE_PAIR const *vp);
-char *fr_pair_type_asprint(TALLOC_CTX *ctx, PW_TYPE type);
+char *fr_pair_type_asprint(TALLOC_CTX *ctx, fr_type_t type);
char *fr_pair_asprint(TALLOC_CTX *ctx, VALUE_PAIR const *vp, char quote);
void fr_pair_list_tainted(VALUE_PAIR *vp);
*
* If you just need the string value of whatever the VPT refers to, the tmpl_*expand
* functions may be used. These functions evaluate the VPT, execing, and xlat expanding
- * as necessary. In the case of #TMPL_TYPE_ATTR, and #PW_TYPE_STRING or #PW_TYPE_OCTETS
+ * as necessary. In the case of #TMPL_TYPE_ATTR, and #FR_TYPE_STRING or #FR_TYPE_OCTETS
* #tmpl_expand will return a pointer to the raw #VALUE_PAIR buffer. This can be very
- * useful when using the #PW_TYPE_TMPL type in #CONF_PARSER structs, as it allows the
+ * useful when using the #FR_TYPE_TMPL type in #CONF_PARSER structs, as it allows the
* user to determine whether they want the module to sanitise the value using presentation
* format specific #xlat_escape_t function, or to operate on the raw value.
*
value.strvalue = talloc_strdup(NULL, "my new username");
value.length = talloc_array_length(value.strvalue) - 1;
- if (fr_pair_update_by_num(ctx, head, PW_USERNAME, 0, TAG_ANY, PW_TYPE_STRING, &value) < 0) return -1; // error
+ if (fr_pair_update_by_num(ctx, head, PW_USERNAME, 0, TAG_ANY, FR_TYPE_STRING, &value) < 0) return -1; // error
@endcode
*
* @param _ctx new #VALUE_PAIR s should be allocated in for the specified list.
/** Map ptr type to a boxed type
*
*/
-#define PW_TYPE_FROM_PTR(_ptr) \
+#define FR_TYPE_FROM_PTR(_ptr) \
_Generic((_ptr), \
- char **: PW_TYPE_STRING, \
- char const **: PW_TYPE_STRING, \
- uint8_t **: PW_TYPE_OCTETS, \
- uint8_t const **: PW_TYPE_OCTETS, \
- uint8_t *: PW_TYPE_BYTE, \
- uint16_t *: PW_TYPE_SHORT, \
- uint32_t *: PW_TYPE_INTEGER, \
- uint64_t *: PW_TYPE_INTEGER64, \
- struct timeval *: PW_TYPE_TIMEVAL)
+ char **: FR_TYPE_STRING, \
+ 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, \
+ struct timeval *: FR_TYPE_TIMEVAL)
/** Expand a tmpl to a C type, using existing storage to hold variably sized types
*
*/
#define tmpl_expand(_out, _buff, _buff_len, _request, _vpt, _escape, _escape_ctx) \
_tmpl_to_type((void *)(_out), (uint8_t *)_buff, _buff_len, \
- _request, _vpt, _escape, _escape_ctx, PW_TYPE_FROM_PTR(_out))
+ _request, _vpt, _escape, _escape_ctx, FR_TYPE_FROM_PTR(_out))
/** Expand a tmpl to a C type, allocing a new buffer to hold the string
*
* @see _tmpl_to_atype
*/
#define tmpl_aexpand(_ctx, _out, _request, _vpt, _escape, _escape_ctx) \
- _tmpl_to_atype(_ctx, (void *)(_out), _request, _vpt, _escape, _escape_ctx, PW_TYPE_FROM_PTR(_out))
+ _tmpl_to_atype(_ctx, (void *)(_out), _request, _vpt, _escape, _escape_ctx, FR_TYPE_FROM_PTR(_out))
VALUE_PAIR **radius_list(REQUEST *request, pair_lists_t list);
ssize_t tmpl_afrom_str(TALLOC_CTX *ctx, vp_tmpl_t **out, char const *name, size_t inlen,
FR_TOKEN type, request_refs_t request_def, pair_lists_t list_def, bool do_escape);
-int tmpl_cast_in_place(vp_tmpl_t *vpt, PW_TYPE type, fr_dict_attr_t const *enumv);
+int tmpl_cast_in_place(vp_tmpl_t *vpt, fr_type_t type, fr_dict_attr_t const *enumv);
void tmpl_cast_in_place_str(vp_tmpl_t *vpt);
REQUEST *request,
vp_tmpl_t const *vpt,
xlat_escape_t escape, void const *escape_ctx,
- PW_TYPE dst_type)
+ fr_type_t dst_type)
CC_HINT(nonnull (1, 4, 5));
ssize_t _tmpl_to_atype(TALLOC_CTX *ctx, void *out,
REQUEST *request,
vp_tmpl_t const *vpt,
xlat_escape_t escape, void const *escape_ctx,
- PW_TYPE dst_type)
+ fr_type_t dst_type)
CC_HINT(nonnull (2, 3, 4));
VALUE_PAIR *tmpl_cursor_init(int *err, vp_cursor_t *cursor, REQUEST *request,
int tmpl_define_unknown_attr(vp_tmpl_t *vpt);
-int tmpl_define_undefined_attr(vp_tmpl_t *vpt, PW_TYPE type, fr_dict_attr_flags_t const *flags);
+int tmpl_define_undefined_attr(vp_tmpl_t *vpt, fr_type_t type, fr_dict_attr_flags_t const *flags);
#ifdef __cplusplus
}
*
*/
typedef enum {
- PW_TYPE_INVALID = 0, //!< Invalid (uninitialised) attribute type.
-
- PW_TYPE_STRING, //!< String of printable characters.
- PW_TYPE_OCTETS, //!< Raw octets.
-
- PW_TYPE_IPV4_ADDR, //!< 32 Bit IPv4 Address.
- PW_TYPE_IPV4_PREFIX, //!< IPv4 Prefix.
- PW_TYPE_IPV6_ADDR, //!< 128 Bit IPv6 Address.
- PW_TYPE_IPV6_PREFIX, //!< IPv6 Prefix.
- PW_TYPE_IFID, //!< Interface ID.
- PW_TYPE_COMBO_IP_ADDR, //!< IPv4 or IPv6 address depending on length.
- PW_TYPE_COMBO_IP_PREFIX, //!< IPv4 or IPv6 address prefix depending on length.
- PW_TYPE_ETHERNET, //!< 48 Bit Mac-Address.
-
- PW_TYPE_BOOLEAN, //!< A truth value.
- PW_TYPE_BYTE, //!< 8 Bit unsigned integer.
- PW_TYPE_SHORT, //!< 16 Bit unsigned integer.
- PW_TYPE_INTEGER, //!< 32 Bit unsigned integer.
- PW_TYPE_INTEGER64, //!< 64 Bit unsigned integer.
- PW_TYPE_SIZE, //!< Unsigned integer capable of representing any memory
+ FR_TYPE_INVALID = 0, //!< Invalid (uninitialised) attribute type.
+
+ FR_TYPE_STRING, //!< String of printable characters.
+ FR_TYPE_OCTETS, //!< Raw octets.
+
+ FR_TYPE_IPV4_ADDR, //!< 32 Bit IPv4 Address.
+ FR_TYPE_IPV4_PREFIX, //!< IPv4 Prefix.
+ FR_TYPE_IPV6_ADDR, //!< 128 Bit IPv6 Address.
+ FR_TYPE_IPV6_PREFIX, //!< IPv6 Prefix.
+ FR_TYPE_IFID, //!< Interface ID.
+ FR_TYPE_COMBO_IP_ADDR, //!< IPv4 or IPv6 address depending on length.
+ 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_SIZE, //!< Unsigned integer capable of representing any memory
//!< address on the local system.
- PW_TYPE_SIGNED, //!< 32 Bit signed integer.
+ FR_TYPE_SIGNED, //!< 32 Bit signed integer.
- PW_TYPE_TIMEVAL, //!< Time value (struct timeval), only for config items.
- PW_TYPE_DECIMAL, //!< Double precision floating point.
- PW_TYPE_DATE, //!< 32 Bit Unix timestamp.
+ 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.
- PW_TYPE_ABINARY, //!< Ascend binary format a packed data structure.
+ FR_TYPE_ABINARY, //!< Ascend binary format a packed data structure.
- PW_TYPE_TLV, //!< Contains nested attributes.
- PW_TYPE_STRUCT, //!< like TLV, but without T or L, and fixed-width children
+ FR_TYPE_TLV, //!< Contains nested attributes.
+ FR_TYPE_STRUCT, //!< like TLV, but without T or L, and fixed-width children
- PW_TYPE_EXTENDED, //!< Extended attribute space attribute.
- PW_TYPE_LONG_EXTENDED, //!< Long extended attribute space attribute.
+ FR_TYPE_EXTENDED, //!< Extended attribute space attribute.
+ FR_TYPE_LONG_EXTENDED, //!< Long extended attribute space attribute.
- PW_TYPE_VSA, //!< Vendor-Specific, for RADIUS attribute 26.
- PW_TYPE_EVS, //!< Extended attribute, vendor specific.
- PW_TYPE_VENDOR, //!< Attribute that represents a vendor in the attribute tree.
+ FR_TYPE_VSA, //!< Vendor-Specific, for RADIUS attribute 26.
+ FR_TYPE_EVS, //!< Extended attribute, vendor specific.
+ FR_TYPE_VENDOR, //!< Attribute that represents a vendor in the attribute tree.
- PW_TYPE_MAX //!< Number of defined data types.
-} PW_TYPE;
+ FR_TYPE_MAX //!< Number of defined data types.
+} fr_type_t;
/** Match all fixed length types in case statements
*
* @note This should be used for switch statements in printing and casting
* functions that need to deal with all types representing values
*/
-#define PW_TYPE_FIXED_SIZE \
- PW_TYPE_BYTE: \
- case PW_TYPE_SHORT: \
- case PW_TYPE_INTEGER: \
- case PW_TYPE_INTEGER64: \
- case PW_TYPE_SIZE: \
- case PW_TYPE_DATE: \
- case PW_TYPE_IFID: \
- case PW_TYPE_ETHERNET: \
- case PW_TYPE_IPV4_ADDR: \
- case PW_TYPE_IPV4_PREFIX: \
- case PW_TYPE_IPV6_ADDR: \
- case PW_TYPE_IPV6_PREFIX: \
- case PW_TYPE_COMBO_IP_ADDR: \
- case PW_TYPE_COMBO_IP_PREFIX: \
- case PW_TYPE_SIGNED: \
- case PW_TYPE_TIMEVAL: \
- case PW_TYPE_BOOLEAN: \
- case PW_TYPE_DECIMAL
+#define FR_TYPE_FIXED_SIZE \
+ FR_TYPE_BYTE: \
+ case FR_TYPE_SHORT: \
+ case FR_TYPE_INTEGER: \
+ case FR_TYPE_INTEGER64: \
+ case FR_TYPE_SIZE: \
+ case FR_TYPE_DATE: \
+ case FR_TYPE_IFID: \
+ case FR_TYPE_ETHERNET: \
+ case FR_TYPE_IPV4_ADDR: \
+ case FR_TYPE_IPV4_PREFIX: \
+ case FR_TYPE_IPV6_ADDR: \
+ case FR_TYPE_IPV6_PREFIX: \
+ case FR_TYPE_COMBO_IP_ADDR: \
+ case FR_TYPE_COMBO_IP_PREFIX: \
+ case FR_TYPE_SIGNED: \
+ case FR_TYPE_TIMEVAL: \
+ case FR_TYPE_BOOLEAN: \
+ case FR_TYPE_DECIMAL
/** Match all variable length types in case statements
*
* @note This should be used for switch statements in printing and casting
* functions that need to deal with all types representing values
*/
-#define PW_TYPE_VARIABLE_SIZE \
- PW_TYPE_STRING: \
- case PW_TYPE_OCTETS: \
- case PW_TYPE_ABINARY \
+#define FR_TYPE_VARIABLE_SIZE \
+ FR_TYPE_STRING: \
+ case FR_TYPE_OCTETS: \
+ case FR_TYPE_ABINARY \
-#define PW_TYPE_BAD \
- PW_TYPE_MAX: \
- case PW_TYPE_INVALID
+#define FR_TYPE_BAD \
+ FR_TYPE_MAX: \
+ case FR_TYPE_INVALID
/** Stupid hack for things which produce special error messages for VSAs
*
* @note This should be used for switch statements in printing and casting
* functions that need to deal with all types representing values
*/
-#define PW_TYPE_STRUCTURAL_EXCEPT_VSA \
- PW_TYPE_EXTENDED: \
- case PW_TYPE_LONG_EXTENDED: \
- case PW_TYPE_EVS: \
- case PW_TYPE_TLV: \
- case PW_TYPE_STRUCT
+#define FR_TYPE_STRUCTURAL_EXCEPT_VSA \
+ FR_TYPE_EXTENDED: \
+ case FR_TYPE_LONG_EXTENDED: \
+ case FR_TYPE_EVS: \
+ case FR_TYPE_TLV: \
+ case FR_TYPE_STRUCT
/** Match all non value types in case statements
*
* @note This should be used for switch statements in printing and casting
* functions that need to deal with all types representing values
*/
-#define PW_TYPE_STRUCTURAL \
- PW_TYPE_STRUCTURAL_EXCEPT_VSA: \
- case PW_TYPE_VSA: \
- case PW_TYPE_VENDOR
+#define FR_TYPE_STRUCTURAL \
+ FR_TYPE_STRUCTURAL_EXCEPT_VSA: \
+ case FR_TYPE_VSA: \
+ case FR_TYPE_VENDOR
/** Naturally numeric types
*
*/
-#define PW_TYPE_NUMERIC \
- PW_TYPE_BOOLEAN: \
- case PW_TYPE_BYTE: \
- case PW_TYPE_SHORT: \
- case PW_TYPE_INTEGER: \
- case PW_TYPE_INTEGER64: \
- case PW_TYPE_SIZE: \
- case PW_TYPE_SIGNED: \
- case PW_TYPE_DATE
+#define FR_TYPE_NUMERIC \
+ FR_TYPE_BOOLEAN: \
+ case FR_TYPE_BYTE: \
+ case FR_TYPE_SHORT: \
+ case FR_TYPE_INTEGER: \
+ case FR_TYPE_INTEGER64: \
+ case FR_TYPE_SIZE: \
+ case FR_TYPE_SIGNED: \
+ case FR_TYPE_DATE
#endif /* _FR_TYPES_H */
* This union contains all data types that can be represented by VALUE_PAIRs. It may also be used in other parts
* of the server where values of different types need to be stored.
*
- * PW_TYPE should be an enumeration of the values in this union.
+ * fr_type_t should be an enumeration of the values in this union.
*/
typedef struct value_box value_box_t;
struct value_box {
} datum;
- PW_TYPE type; //!< Type of this value-box.
+ fr_type_t type; //!< Type of this value-box.
bool tainted; //!< i.e. did it come from an untrusted source
/*
* Allocation
*/
-value_box_t *value_box_alloc(TALLOC_CTX *ctx, PW_TYPE type);
+value_box_t *value_box_alloc(TALLOC_CTX *ctx, fr_type_t type);
void value_box_clear(value_box_t *data);
int value_box_hton(value_box_t *dst, value_box_t const *src);
int value_box_cast(TALLOC_CTX *ctx, value_box_t *dst,
- PW_TYPE dst_type, fr_dict_attr_t const *dst_enumv,
+ fr_type_t dst_type, fr_dict_attr_t const *dst_enumv,
value_box_t const *src);
/*
int value_box_from_ipaddr(value_box_t *dst, fr_ipaddr_t const *ipaddr);
int value_box_from_str(TALLOC_CTX *ctx, value_box_t *dst,
- PW_TYPE *src_type, fr_dict_attr_t const *src_enumv,
+ fr_type_t *src_type, fr_dict_attr_t const *src_enumv,
char const *src, ssize_t src_len, char quote);
/*
{
value->datum.ptr = berval->bv_val;
value->datum.length = berval->bv_len;
- value->type = PW_TYPE_OCTETS;
+ value->type = FR_TYPE_OCTETS;
}
/*
/** Map data types to names representing those types
*/
FR_NAME_NUMBER const dict_attr_types[] = {
- { "string", PW_TYPE_STRING },
- { "octets", PW_TYPE_OCTETS },
-
- { "ipaddr", PW_TYPE_IPV4_ADDR },
- { "ipv4prefix", PW_TYPE_IPV4_PREFIX },
- { "ipv6addr", PW_TYPE_IPV6_ADDR },
- { "ipv6prefix", PW_TYPE_IPV6_PREFIX },
- { "ifid", PW_TYPE_IFID },
- { "combo-ip", PW_TYPE_COMBO_IP_ADDR },
- { "combo-prefix", PW_TYPE_COMBO_IP_PREFIX },
- { "ether", PW_TYPE_ETHERNET },
-
- { "bool", PW_TYPE_BOOLEAN },
- { "byte", PW_TYPE_BYTE },
- { "short", PW_TYPE_SHORT },
- { "integer", PW_TYPE_INTEGER },
- { "integer64", PW_TYPE_INTEGER64 },
- { "size", PW_TYPE_SIZE },
- { "signed", PW_TYPE_SIGNED },
-
- { "decimal", PW_TYPE_DECIMAL },
- { "timeval", PW_TYPE_TIMEVAL },
- { "date", PW_TYPE_DATE },
-
- { "abinary", PW_TYPE_ABINARY },
-
- { "tlv", PW_TYPE_TLV },
- { "struct", PW_TYPE_STRUCT },
-
- { "extended", PW_TYPE_EXTENDED },
- { "long-extended", PW_TYPE_LONG_EXTENDED },
-
- { "vsa", PW_TYPE_VSA },
- { "evs", PW_TYPE_EVS },
- { "vendor", PW_TYPE_VENDOR },
+ { "string", FR_TYPE_STRING },
+ { "octets", FR_TYPE_OCTETS },
+
+ { "ipaddr", FR_TYPE_IPV4_ADDR },
+ { "ipv4prefix", FR_TYPE_IPV4_PREFIX },
+ { "ipv6addr", FR_TYPE_IPV6_ADDR },
+ { "ipv6prefix", FR_TYPE_IPV6_PREFIX },
+ { "ifid", FR_TYPE_IFID },
+ { "combo-ip", FR_TYPE_COMBO_IP_ADDR },
+ { "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 },
+ { "size", FR_TYPE_SIZE },
+ { "signed", FR_TYPE_SIGNED },
+
+ { "decimal", FR_TYPE_DECIMAL },
+ { "timeval", FR_TYPE_TIMEVAL },
+ { "date", FR_TYPE_DATE },
+
+ { "abinary", FR_TYPE_ABINARY },
+
+ { "tlv", FR_TYPE_TLV },
+ { "struct", FR_TYPE_STRUCT },
+
+ { "extended", FR_TYPE_EXTENDED },
+ { "long-extended", FR_TYPE_LONG_EXTENDED },
+
+ { "vsa", FR_TYPE_VSA },
+ { "evs", FR_TYPE_EVS },
+ { "vendor", FR_TYPE_VENDOR },
/*
* Alternative names
*/
- { "cidr", PW_TYPE_IPV4_PREFIX },
- { "uint8", PW_TYPE_BYTE },
- { "uint16", PW_TYPE_SHORT },
- { "uint32", PW_TYPE_INTEGER },
- { "uint64", PW_TYPE_INTEGER64 },
- { "int32", PW_TYPE_SIGNED },
+ { "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 },
{ NULL, 0 }
};
/** Map data types to min / max data sizes
*/
-size_t const dict_attr_sizes[PW_TYPE_MAX + 1][2] = {
- [PW_TYPE_INVALID] = {~0, 0}, //!< Ensure array starts at 0 (umm?)
+size_t const dict_attr_sizes[FR_TYPE_MAX + 1][2] = {
+ [FR_TYPE_INVALID] = {~0, 0}, //!< Ensure array starts at 0 (umm?)
- [PW_TYPE_STRING] = {0, ~0},
- [PW_TYPE_OCTETS] = {0, ~0},
+ [FR_TYPE_STRING] = {0, ~0},
+ [FR_TYPE_OCTETS] = {0, ~0},
- [PW_TYPE_IPV4_ADDR] = {4, 4},
- [PW_TYPE_IPV4_PREFIX] = {6, 6},
- [PW_TYPE_IPV6_ADDR] = {16, 16},
- [PW_TYPE_IPV6_PREFIX] = {2, 18},
- [PW_TYPE_COMBO_IP_ADDR] = {4, 16},
- [PW_TYPE_IFID] = {8, 8},
- [PW_TYPE_ETHERNET] = {6, 6},
+ [FR_TYPE_IPV4_ADDR] = {4, 4},
+ [FR_TYPE_IPV4_PREFIX] = {6, 6},
+ [FR_TYPE_IPV6_ADDR] = {16, 16},
+ [FR_TYPE_IPV6_PREFIX] = {2, 18},
+ [FR_TYPE_COMBO_IP_ADDR] = {4, 16},
+ [FR_TYPE_IFID] = {8, 8},
+ [FR_TYPE_ETHERNET] = {6, 6},
- [PW_TYPE_BOOLEAN] = {1, 1},
- [PW_TYPE_BYTE] = {1, 1},
- [PW_TYPE_SHORT] = {2, 2},
- [PW_TYPE_INTEGER] = {4, 4},
- [PW_TYPE_INTEGER64] = {8, 8},
- [PW_TYPE_SIZE] = {sizeof(size_t), sizeof(size_t)},
- [PW_TYPE_SIGNED] = {4, 4},
+ [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_SIZE] = {sizeof(size_t), sizeof(size_t)},
+ [FR_TYPE_SIGNED] = {4, 4},
- [PW_TYPE_DATE] = {4, 4},
- [PW_TYPE_ABINARY] = {32, ~0},
+ [FR_TYPE_DATE] = {4, 4},
+ [FR_TYPE_ABINARY] = {32, ~0},
- [PW_TYPE_TLV] = {2, ~0},
- [PW_TYPE_STRUCT] = {1, ~0},
+ [FR_TYPE_TLV] = {2, ~0},
+ [FR_TYPE_STRUCT] = {1, ~0},
- [PW_TYPE_EXTENDED] = {2, ~0},
- [PW_TYPE_LONG_EXTENDED] = {3, ~0},
+ [FR_TYPE_EXTENDED] = {2, ~0},
+ [FR_TYPE_LONG_EXTENDED] = {3, ~0},
- [PW_TYPE_VSA] = {4, ~0},
- [PW_TYPE_EVS] = {6, ~0},
+ [FR_TYPE_VSA] = {4, ~0},
+ [FR_TYPE_EVS] = {6, ~0},
- [PW_TYPE_MAX] = {~0, 0} //!< Ensure array covers all types.
+ [FR_TYPE_MAX] = {~0, 0} //!< Ensure array covers all types.
};
/** Characters allowed in dictionary names
/** Structural data types
*
*/
-bool const fr_dict_non_data_types[PW_TYPE_MAX + 1] = {
- [PW_TYPE_TLV] = true,
- [PW_TYPE_STRUCT] = true,
- [PW_TYPE_EXTENDED] = true,
- [PW_TYPE_LONG_EXTENDED] = true,
- [PW_TYPE_VSA] = true,
- [PW_TYPE_EVS] = true,
- [PW_TYPE_VENDOR] = true
+bool const fr_dict_non_data_types[FR_TYPE_MAX + 1] = {
+ [FR_TYPE_TLV] = true,
+ [FR_TYPE_STRUCT] = true,
+ [FR_TYPE_EXTENDED] = true,
+ [FR_TYPE_LONG_EXTENDED] = true,
+ [FR_TYPE_VSA] = true,
+ [FR_TYPE_EVS] = true,
+ [FR_TYPE_VENDOR] = true
};
/** Numeric dictionary types
*
* @note Must be updated to match the anonymous enum types union in value_box_t
*/
-bool const fr_dict_enum_types[PW_TYPE_MAX + 1] = {
- [PW_TYPE_BYTE] = true,
- [PW_TYPE_SHORT] = true,
- [PW_TYPE_INTEGER] = true,
- [PW_TYPE_INTEGER64] = true,
- [PW_TYPE_SIZE] = true,
- [PW_TYPE_SIGNED] = true
+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_SIZE] = true,
+ [FR_TYPE_SIGNED] = true
};
/*
* Structural attributes always take priority.
*/
switch (child->type) {
- case PW_TYPE_STRUCTURAL:
+ case FR_TYPE_STRUCTURAL:
child_is_struct = true;
break;
}
switch ((*bin)->type) {
- case PW_TYPE_STRUCTURAL:
+ case FR_TYPE_STRUCTURAL:
bin_is_struct = true;
break;
static fr_dict_attr_t *fr_dict_attr_alloc(TALLOC_CTX *ctx,
fr_dict_attr_t const *parent,
char const *name, unsigned int vendor, int attr,
- PW_TYPE type, fr_dict_attr_flags_t const *flags)
+ fr_type_t type, fr_dict_attr_flags_t const *flags)
{
fr_dict_attr_t *da;
* - NULL on failure
*/
static fr_dict_attr_t *fr_dict_attr_add_by_name(fr_dict_t *dict, fr_dict_attr_t const *parent,
- char const *name, int attr, PW_TYPE type, fr_dict_attr_flags_t flags)
+ char const *name, int attr, fr_type_t type, fr_dict_attr_flags_t flags)
{
unsigned int vendor;
size_t namelen;
* type_size is used to limit the maximum attribute number, so it's checked first.
*/
if (flags.type_size) {
- if ((type != PW_TYPE_TLV) && (type != PW_TYPE_VENDOR)) {
+ if ((type != FR_TYPE_TLV) && (type != FR_TYPE_VENDOR)) {
fr_strerror_printf("The 'format=' flag can only be used with attributes of type 'tlv'");
goto error;
}
} else
for (v = parent; v != NULL; v = v->parent) {
- if ((v->type == PW_TYPE_TLV) || (v->type == PW_TYPE_VENDOR)) {
+ if ((v->type == FR_TYPE_TLV) || (v->type == FR_TYPE_VENDOR)) {
if ((v->flags.type_size < 4) &&
(attr >= (1 << (8 * v->flags.type_size)))) {
fr_strerror_printf("Attributes must have value between 1..%u",
* Tags can only be used in a few limited situations.
*/
if (flags.has_tag) {
- if ((type != PW_TYPE_INTEGER) && (type != PW_TYPE_STRING)) {
+ if ((type != FR_TYPE_INTEGER) && (type != FR_TYPE_STRING)) {
fr_strerror_printf("The 'has_tag' flag can only be used for attributes of type 'integer' "
"or 'string'");
goto error;
}
if (!(parent->flags.is_root ||
- ((parent->type == PW_TYPE_VENDOR) &&
- (parent->parent && parent->parent->type == PW_TYPE_VSA)))) {
+ ((parent->type == FR_TYPE_VENDOR) &&
+ (parent->parent && parent->parent->type == FR_TYPE_VSA)))) {
fr_strerror_printf("The 'has_tag' flag can only be used with RFC and VSA attributes");
goto error;
}
* 'concat' can only be used in a few limited situations.
*/
if (flags.concat) {
- if (type != PW_TYPE_OCTETS) {
+ if (type != FR_TYPE_OCTETS) {
fr_strerror_printf("The 'concat' flag can only be used for attributes of type 'octets'");
goto error;
}
return NULL;
}
- if ((type == PW_TYPE_TLV) || (type == PW_TYPE_VENDOR)) {
+ if ((type == FR_TYPE_TLV) || (type == FR_TYPE_VENDOR)) {
if ((flags.length != 1) &&
(flags.length != 2) &&
(flags.length != 4)) {
goto error;
}
- } else if ((type != PW_TYPE_OCTETS) &&
- (type != PW_TYPE_STRUCT)) {
+ } else if ((type != FR_TYPE_OCTETS) &&
+ (type != FR_TYPE_STRUCT)) {
fr_strerror_printf("The 'length' flag can only be set for attributes of type 'octets' or 'struct'");
goto error;
}
- if (type == PW_TYPE_STRUCT) {
+ if (type == FR_TYPE_STRUCT) {
if (flags.type_size != 0) {
fr_strerror_printf("Invalid initializer for type_size");
goto error;
*/
if (flags.array) {
for (v = parent; v != NULL; v = v->parent) {
- if (v->type != PW_TYPE_VENDOR) continue;
+ if (v->type != FR_TYPE_VENDOR) continue;
if ((v->attr != 34673) && /* freedhcp */
(v->attr != DHCP_MAGIC_VENDOR)) {
fr_int2str(dict_attr_types, type, "<UNKNOWN>"));
goto error;
- case PW_TYPE_IPV4_ADDR:
- case PW_TYPE_IPV6_ADDR:
- case PW_TYPE_BYTE:
- case PW_TYPE_SHORT:
- case PW_TYPE_INTEGER:
- case PW_TYPE_DATE:
- case PW_TYPE_STRING:
+ 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_DATE:
+ case FR_TYPE_STRING:
break;
}
* caller sets it, we still sanity check it.
*/
if (flags.has_value) {
- if (type != PW_TYPE_INTEGER) {
+ if (type != FR_TYPE_INTEGER) {
fr_strerror_printf("The 'has_value' flag can only be used with attributes "
"of type 'integer'");
goto error;
* MS-CHAP-MPPE-Keys, the data is binary crap. So... we
* MUST specify a length in the dictionary.
*/
- if ((flags.encrypt == FLAG_ENCRYPT_USER_PASSWORD) && (type != PW_TYPE_STRING)) {
- if (type != PW_TYPE_OCTETS) {
+ if ((flags.encrypt == FLAG_ENCRYPT_USER_PASSWORD) && (type != FR_TYPE_STRING)) {
+ if (type != FR_TYPE_OCTETS) {
fr_strerror_printf("The 'encrypt=1' flag can only be used with "
"attributes of type 'string'");
goto error;
if ((flags.encrypt != FLAG_ENCRYPT_TUNNEL_PASSWORD) && !flags.internal && !parent->flags.internal) {
for (v = parent; v != NULL; v = v->parent) {
switch (v->type) {
- case PW_TYPE_EXTENDED:
- case PW_TYPE_LONG_EXTENDED:
- case PW_TYPE_EVS:
+ case FR_TYPE_EXTENDED:
+ case FR_TYPE_LONG_EXTENDED:
+ case FR_TYPE_EVS:
fr_strerror_printf("The 'encrypt=%d' flag cannot be used with attributes "
"of type '%s'", flags.encrypt,
fr_int2str(dict_attr_types, type, "<UNKNOWN>"));
}
switch (type) {
- case PW_TYPE_TLV:
+ case FR_TYPE_TLV:
if (flags.internal || parent->flags.internal) break;
/* FALL-THROUGH */
fr_int2str(dict_attr_types, type, "<UNKNOWN>"));
goto error;
- case PW_TYPE_IPV4_ADDR:
- case PW_TYPE_INTEGER:
- case PW_TYPE_OCTETS:
+ case FR_TYPE_IPV4_ADDR:
+ case FR_TYPE_INTEGER:
+ case FR_TYPE_OCTETS:
if (flags.encrypt == FLAG_ENCRYPT_ASCEND_SECRET) goto encrypt_fail;
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
break;
}
}
/*
* These types may only be parented from the root of the dictionary
*/
- case PW_TYPE_EXTENDED:
- case PW_TYPE_LONG_EXTENDED:
- case PW_TYPE_VSA:
+ case FR_TYPE_EXTENDED:
+ case FR_TYPE_LONG_EXTENDED:
+ case FR_TYPE_VSA:
if (!parent->flags.is_root) {
fr_strerror_printf("Attributes of type '%s' can only be used in the RFC space",
fr_int2str(dict_attr_types, type, "?Unknown?"));
/*
* EVS may only occur under extended and long extended.
*/
- case PW_TYPE_EVS:
- if ((parent->type != PW_TYPE_EXTENDED) && (parent->type != PW_TYPE_LONG_EXTENDED)) {
+ case FR_TYPE_EVS:
+ if ((parent->type != FR_TYPE_EXTENDED) && (parent->type != FR_TYPE_LONG_EXTENDED)) {
fr_strerror_printf("Attributes of type 'evs' MUST have a parent of type 'extended', "
"instead of '%s'", fr_int2str(dict_attr_types, parent->type, "?Unknown?"));
goto error;
}
break;
- case PW_TYPE_VENDOR:
- if ((parent->type != PW_TYPE_VSA) && (parent->type != PW_TYPE_EVS)) {
+ case FR_TYPE_VENDOR:
+ if ((parent->type != FR_TYPE_VSA) && (parent->type != FR_TYPE_EVS)) {
fr_strerror_printf("Attributes of type 'vendor' MUST have a parent of type 'vsa' or "
"'evs', instead of '%s'",
fr_int2str(dict_attr_types, parent->type, "?Unknown?"));
goto error;
}
- if (parent->type == PW_TYPE_VSA) {
+ if (parent->type == FR_TYPE_VSA) {
fr_dict_vendor_t const *dv;
dv = fr_dict_vendor_by_num(dict, attr);
}
break;
- case PW_TYPE_TLV:
+ case FR_TYPE_TLV:
/*
* Ensure that type_size and length are set.
*/
for (v = parent; v != NULL; v = v->parent) {
- if ((v->type == PW_TYPE_TLV) || (v->type == PW_TYPE_VENDOR)) {
+ if ((v->type == FR_TYPE_TLV) || (v->type == FR_TYPE_VENDOR)) {
break;
}
}
/*
- * root is always PW_TYPE_TLV, so we're OK.
+ * root is always FR_TYPE_TLV, so we're OK.
*/
if (!v) {
fr_strerror_printf("Attributes of type '%s' require a parent attribute",
flags.length = v->flags.length;
break;
- case PW_TYPE_COMBO_IP_ADDR:
+ case FR_TYPE_COMBO_IP_ADDR:
/*
* RFC 6929 says that this is a terrible idea.
*/
for (v = parent; v != NULL; v = v->parent) {
- if (v->type == PW_TYPE_VSA) {
+ if (v->type == FR_TYPE_VSA) {
break;
}
}
}
break;
- case PW_TYPE_INVALID:
- case PW_TYPE_TIMEVAL:
- case PW_TYPE_DECIMAL:
- case PW_TYPE_COMBO_IP_PREFIX:
+ case FR_TYPE_INVALID:
+ case FR_TYPE_TIMEVAL:
+ case FR_TYPE_DECIMAL:
+ 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?"));
goto error;
* Force "length" for data types of fixed length;
*/
switch (type) {
- case PW_TYPE_BYTE:
- case PW_TYPE_BOOLEAN:
+ case FR_TYPE_BYTE:
+ case FR_TYPE_BOOLEAN:
flags.length = 1;
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
flags.length = 2;
break;
- case PW_TYPE_DATE:
- case PW_TYPE_IPV4_ADDR:
- case PW_TYPE_INTEGER:
- case PW_TYPE_SIGNED:
+ case FR_TYPE_DATE:
+ case FR_TYPE_IPV4_ADDR:
+ case FR_TYPE_INTEGER:
+ case FR_TYPE_SIGNED:
flags.length = 4;
break;
- case PW_TYPE_INTEGER64:
+ case FR_TYPE_INTEGER64:
flags.length = 8;
break;
- case PW_TYPE_SIZE:
+ case FR_TYPE_SIZE:
flags.length = sizeof(size_t);
break;
- case PW_TYPE_ETHERNET:
+ case FR_TYPE_ETHERNET:
flags.length = 6;
break;
- case PW_TYPE_IFID:
+ case FR_TYPE_IFID:
flags.length = 8;
break;
- case PW_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_ADDR:
flags.length = 16;
break;
- case PW_TYPE_EXTENDED:
+ case FR_TYPE_EXTENDED:
if (!parent->flags.is_root || (attr < 241)) {
fr_strerror_printf("Attributes of type 'extended' MUST be "
"RFC attributes with value >= 241.");
flags.length = 0;
break;
- case PW_TYPE_LONG_EXTENDED:
+ case FR_TYPE_LONG_EXTENDED:
if (!parent->flags.is_root || (attr < 241)) {
fr_strerror_printf("Attributes of type 'long-extended' MUST "
"be RFC attributes with value >= 241.");
flags.length = 0;
break;
- case PW_TYPE_EVS:
+ case FR_TYPE_EVS:
if (attr != PW_VENDOR_SPECIFIC) {
fr_strerror_printf("Attributes of type 'evs' MUST have attribute code 26, got %i", attr);
goto error;
* The length is calculated from th children, not
* input as the flags.
*/
- case PW_TYPE_STRUCT:
+ case FR_TYPE_STRUCT:
flags.length = 0;
break;
- case PW_TYPE_STRING:
- case PW_TYPE_OCTETS:
- case PW_TYPE_TLV:
+ case FR_TYPE_STRING:
+ case FR_TYPE_OCTETS:
+ case FR_TYPE_TLV:
flags.is_pointer = true;
break;
/*
* Validate attribute based on parent.
*/
- if (parent->type == PW_TYPE_STRUCT) {
+ if (parent->type == FR_TYPE_STRUCT) {
fr_dict_attr_t *mutable;
/*
* STRUCTs will have their length filled in later.
*/
- if ((type != PW_TYPE_STRUCT) && (flags.length == 0)) {
+ if ((type != FR_TYPE_STRUCT) && (flags.length == 0)) {
fr_strerror_printf("Children of 'struct' type attributes MUST have fixed length.");
goto error;
}
/*
* Propogate vendor down the attribute tree.
*/
- if (parent->type == PW_TYPE_VENDOR) {
+ if (parent->type == FR_TYPE_VENDOR) {
vendor = parent->attr;
} else {
vendor = parent->vendor;
/*
* Hacks for combo-IP
*/
- if (n->type == PW_TYPE_COMBO_IP_ADDR) {
+ if (n->type == FR_TYPE_COMBO_IP_ADDR) {
fr_dict_attr_t *v4, *v6;
v4 = (fr_dict_attr_t *)talloc_zero_array(dict->pool, uint8_t, sizeof(*v4) + namelen);
talloc_set_type(v6, fr_dict_attr_t);
memcpy(v4, n, sizeof(*v4) + namelen);
- v4->type = PW_TYPE_IPV4_ADDR;
+ v4->type = FR_TYPE_IPV4_ADDR;
memcpy(v6, n, sizeof(*v6) + namelen);
- v6->type = PW_TYPE_IPV6_ADDR;
+ v6->type = FR_TYPE_IPV6_ADDR;
if (!fr_hash_table_replace(dict->attributes_combo, v4)) {
fr_strerror_printf("Failed inserting IPv4 version of combo attribute");
goto error;
* - -1 on failure.
*/
int fr_dict_attr_add(fr_dict_t *dict, fr_dict_attr_t const *parent,
- char const *name, int attr, PW_TYPE type, fr_dict_attr_flags_t flags)
+ char const *name, int attr, fr_type_t type, fr_dict_attr_flags_t flags)
{
fr_dict_attr_t *n;
fr_dict_attr_t *mutable;
* Don't worry about fixups...
*/
switch (da->type) {
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
if (value > UINT8_MAX) {
talloc_free(dval);
fr_strerror_printf("%s: ATTRIBUTEs of type 'byte' cannot have "
return -1;
}
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
if (value > UINT16_MAX) {
talloc_free(dval);
fr_strerror_printf("%s: ATTRIBUTEs of type 'short' cannot have "
}
break;
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
break;
default:
goto error;
}
- if (da->type != PW_TYPE_TLV) {
+ if (da->type != FR_TYPE_TLV) {
fr_strerror_printf("Attribute '%s' should be a 'tlv', but is a '%s'",
argv[1],
fr_int2str(dict_attr_types, da->type, "?Unknown?"));
common = fr_dict_parent_common(ctx->parent, da, true);
if (!common ||
- (common->type == PW_TYPE_VSA) ||
- (common->type == PW_TYPE_EVS)) {
+ (common->type == FR_TYPE_VSA) ||
+ (common->type == FR_TYPE_EVS)) {
fr_strerror_printf("Attribute '%s' is not a child of '%s'", argv[1], ctx->parent->name);
goto error;
}
goto error;
}
- if (da->type != PW_TYPE_EVS) {
+ if (da->type != FR_TYPE_EVS) {
fr_strerror_printf("Invalid format for BEGIN-VENDOR. Attribute '%s' should "
"be 'evs' but is '%s'", p,
fr_int2str(dict_attr_types, da->type, "?Unknown?"));
memcpy(&mutable, &ctx->parent, sizeof(mutable));
new = fr_dict_attr_alloc(mutable, fr_dict_root(ctx->dict), "Vendor-Specific", 0,
- PW_VENDOR_SPECIFIC, PW_TYPE_VSA, &flags);
+ PW_VENDOR_SPECIFIC, FR_TYPE_VSA, &flags);
fr_dict_attr_child_add(mutable, new);
vsa_da = new;
}
if (!vendor_da) {
memset(&flags, 0, sizeof(flags));
- if (vsa_da->type == PW_TYPE_VSA) {
+ if (vsa_da->type == FR_TYPE_VSA) {
fr_dict_vendor_t const *dv;
dv = fr_dict_vendor_by_num(ctx->dict, vendor);
memcpy(&mutable, &vsa_da, sizeof(mutable));
new = fr_dict_attr_alloc(mutable, ctx->parent,
- argv[1], 0, vendor, PW_TYPE_VENDOR, &flags);
+ argv[1], 0, vendor, FR_TYPE_VENDOR, &flags);
fr_dict_attr_child_add(mutable, new);
vendor_da = new;
strcpy(dict->root->name, name);
talloc_set_type(dict->root, fr_dict_attr_t);
dict->root->flags.is_root = 1;
- dict->root->type = PW_TYPE_TLV;
+ dict->root->type = FR_TYPE_TLV;
dict->root->flags.type_size = 1;
dict->root->flags.length = 1;
* prefer the new name when printing
* values.
*/
- if (a->parent->flags.is_root || ((a->parent->type == PW_TYPE_VENDOR) &&
- (a->parent->parent->type == PW_TYPE_VSA))) {
+ if (a->parent->flags.is_root || ((a->parent->type == FR_TYPE_VENDOR) &&
+ (a->parent->parent->type == FR_TYPE_VSA))) {
if (!fr_hash_table_finddata(dict->values_by_da, this->dval)) {
fr_hash_table_replace(dict->values_by_da, this->dval);
}
* Ensure the vendor is present in the
* vendor hash.
*/
- if (old->type == PW_TYPE_VENDOR) if (fr_dict_vendor_add(dict, old->name, old->attr) < 0) return NULL;
+ if (old->type == FR_TYPE_VENDOR) if (fr_dict_vendor_add(dict, old->name, old->attr) < 0) return NULL;
/*
* Look up the attribute by number. If it doesn't exist,
da->attr = attr;
da->vendor = vendor;
- da->type = PW_TYPE_OCTETS;
+ da->type = FR_TYPE_OCTETS;
da->flags.is_unknown = true;
da->flags.is_raw = true;
da->flags.is_pointer = true;
* a TLV, in which case the vendor should be known
* and we don't need to modify the parent.
*/
- if (vendor && ((parent->type == PW_TYPE_VSA) || (parent->type == PW_TYPE_EVS))) {
+ if (vendor && ((parent->type == FR_TYPE_VSA) || (parent->type == FR_TYPE_EVS))) {
da = fr_dict_attr_child_by_num(parent, vendor);
if (!da) {
if (fr_dict_unknown_vendor_afrom_num(ctx, &new_parent, parent, vendor) < 0) return NULL;
* Vendor attributes can occur under VSA or EVS attributes.
*/
switch (parent->type) {
- case PW_TYPE_VSA:
- case PW_TYPE_EVS:
+ case FR_TYPE_VSA:
+ case FR_TYPE_EVS:
if (!fr_cond_assert(!parent->flags.is_unknown)) return -1;
- *out = fr_dict_attr_alloc(ctx, parent, NULL, 0, vendor, PW_TYPE_VENDOR, &flags);
+ *out = fr_dict_attr_alloc(ctx, parent, NULL, 0, vendor, FR_TYPE_VENDOR, &flags);
return 0;
- case PW_TYPE_VENDOR:
+ case FR_TYPE_VENDOR:
if (!fr_cond_assert(!parent->flags.is_unknown)) return -1;
fr_strerror_printf("Unknown vendor cannot be parented by another vendor");
return -1;
*out = NULL;
- if (parent->type == PW_TYPE_VENDOR) vendor = parent->attr;
+ if (parent->type == FR_TYPE_VENDOR) vendor = parent->attr;
- da = fr_dict_attr_alloc(ctx, parent, NULL, vendor, num, PW_TYPE_OCTETS, &flags);
+ da = fr_dict_attr_alloc(ctx, parent, NULL, vendor, num, FR_TYPE_OCTETS, &flags);
if (!da) return -1;
*out = da;
if (!our_parent) goto is_root;
switch (our_parent->type) {
- case PW_TYPE_EVS:
- case PW_TYPE_VSA:
+ case FR_TYPE_EVS:
+ case FR_TYPE_VSA:
da = fr_dict_attr_child_by_num(our_parent, num);
- if (!fr_cond_assert(!da || (da->type == PW_TYPE_VENDOR))) goto error;
+ if (!fr_cond_assert(!da || (da->type == FR_TYPE_VENDOR))) goto error;
if (!da) {
if (fr_dict_unknown_vendor_afrom_num(our_ctx, &n,
}
break;
- case PW_TYPE_TLV:
- case PW_TYPE_EXTENDED:
- case PW_TYPE_LONG_EXTENDED:
+ case FR_TYPE_TLV:
+ case FR_TYPE_EXTENDED:
+ case FR_TYPE_LONG_EXTENDED:
is_root:
if (fr_dict_unknown_attr_afrom_num(our_ctx, &n, our_parent, num) < 0) {
goto error;
break;
/*
- * Can't have a PW_TYPE_STRING inside a
- * PW_TYPE_STRING (for example)
+ * Can't have a FR_TYPE_STRING inside a
+ * FR_TYPE_STRING (for example)
*/
default:
fr_strerror_printf("Parent OID component (%s) in \"%.*s\" specified a "
fr_dict_snprint_flags(buff, sizeof(buff), da->flags);
switch (da->type) {
- case PW_TYPE_VSA:
+ case FR_TYPE_VSA:
name = "VSA";
break;
- case PW_TYPE_EXTENDED:
+ case FR_TYPE_EXTENDED:
name = "EXTENDED";
break;
- case PW_TYPE_TLV:
+ case FR_TYPE_TLV:
name = "TLV";
break;
- case PW_TYPE_EVS:
+ case FR_TYPE_EVS:
name = "EVS";
break;
- case PW_TYPE_VENDOR:
+ case FR_TYPE_VENDOR:
name = "VENDOR";
break;
- case PW_TYPE_LONG_EXTENDED:
+ case FR_TYPE_LONG_EXTENDED:
name = "LONG EXTENDED";
break;
- case PW_TYPE_STRUCT:
+ case FR_TYPE_STRUCT:
name = "STRUCT";
break;
}
switch ((*parent)->type) {
- case PW_TYPE_STRUCTURAL:
+ case FR_TYPE_STRUCTURAL:
break;
default:
*
* @fixme: find the TLV parent, and check it's size
*/
- if (((*parent)->type != PW_TYPE_VENDOR) && !(*parent)->flags.is_root &&
+ if (((*parent)->type != FR_TYPE_VENDOR) && !(*parent)->flags.is_root &&
(num > UINT8_MAX)) {
fr_strerror_printf("TLV attributes must be between 0..255 inclusive");
return 0;
fr_dict_attr_t const *da_p = da;
while (da_p->parent) {
- if (da_p->type == PW_TYPE_VENDOR) break;
+ if (da_p->type == FR_TYPE_VENDOR) break;
da_p = da_p->parent;
}
- if (da_p->type != PW_TYPE_VENDOR) return NULL;
+ if (da_p->type != FR_TYPE_VENDOR) return NULL;
return da_p;
}
}
switch (da->type) {
- case PW_TYPE_VSA: /* Vendor specific attribute */
- case PW_TYPE_EVS: /* Extended vendor specific attribute */
+ case FR_TYPE_VSA: /* Vendor specific attribute */
+ case FR_TYPE_EVS: /* Extended vendor specific attribute */
break;
default:
fr_strerror_printf("Wrong type for vendor root, expected '%s' or '%s' got '%s'",
- fr_int2str(dict_attr_types, PW_TYPE_VSA, "<INVALID>"),
- fr_int2str(dict_attr_types, PW_TYPE_EVS, "<INVALID>"),
+ fr_int2str(dict_attr_types, FR_TYPE_VSA, "<INVALID>"),
+ fr_int2str(dict_attr_types, FR_TYPE_EVS, "<INVALID>"),
fr_int2str(dict_attr_types, da->type, "<INVALID>"));
return NULL;
}
return NULL;
}
- if (da->type != PW_TYPE_VENDOR) {
+ if (da->type != FR_TYPE_VENDOR) {
fr_strerror_printf("Wrong type for vendor, expected '%s' got '%s'",
fr_int2str(dict_attr_types, da->type, "<INVALID>"),
- fr_int2str(dict_attr_types, PW_TYPE_VENDOR, "<INVALID>"));
+ fr_int2str(dict_attr_types, FR_TYPE_VENDOR, "<INVALID>"));
return NULL;
}
/** Lookup a attribute by its its vendor and attribute numbers and data type
*
- * @note Only works with PW_TYPE_COMBO_IP
+ * @note Only works with FR_TYPE_COMBO_IP
*
* @param[in] da to look for type variant of.
* @param[in] type Variant of attribute to lookup.
* - Attribute matching parent/attr/type.
* - NULL if no matching attribute could be found.
*/
-fr_dict_attr_t const *fr_dict_attr_by_type(fr_dict_attr_t const *da, PW_TYPE type)
+fr_dict_attr_t const *fr_dict_attr_by_type(fr_dict_attr_t const *da, fr_type_t type)
{
fr_dict_t *dict = fr_dict_by_da(da);
fr_dict_attr_t find = {
default:
return NULL;
- case PW_TYPE_STRUCTURAL:
+ case FR_TYPE_STRUCTURAL:
break;
}
default:
return NULL;
- case PW_TYPE_STRUCTURAL:
+ case FR_TYPE_STRUCTURAL:
break;
}
* will be returned.
*
* If attr or vendor are uknown will call dict_attruknown to create a dynamic
- * #fr_dict_attr_t of #PW_TYPE_OCTETS.
+ * #fr_dict_attr_t of #FR_TYPE_OCTETS.
*
* Which type of #fr_dict_attr_t the #VALUE_PAIR was created with can be determined by
* checking @verbatim vp->da->flags.is_unknown @endverbatim.
}
vp->da = da;
- vp->vp_type = da->type; /* PW_TYPE_OCTETS */
+ vp->vp_type = da->type; /* FR_TYPE_OCTETS */
return vp;
}
* will be returned.
*
* If attr or vendor are uknown will call dict_attruknown to create a dynamic
- * #fr_dict_attr_t of #PW_TYPE_OCTETS.
+ * #fr_dict_attr_t of #FR_TYPE_OCTETS.
*
* Which type of #fr_dict_attr_t the #VALUE_PAIR was created with can be determined by
* checking @verbatim vp->da->flags.is_unknown @endverbatim.
}
switch (vp->vp_type) {
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
n->vp_octets = NULL; /* else fr_pair_value_memcpy will free vp's value */
fr_pair_value_memcpy(n, vp->vp_octets, n->vp_length);
break;
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
n->vp_strvalue = NULL; /* else pairstrnpy will free vp's value */
fr_pair_value_bstrncpy(n, vp->vp_strvalue, n->vp_length);
break;
for(i = *head; i; i = next) {
VERIFY_VP(i);
next = i->next;
- if ((i->da->parent->type == PW_TYPE_VENDOR) &&
+ if ((i->da->parent->type == FR_TYPE_VENDOR) &&
(i->da->attr == attr) && (i->da->vendor == vendor) &&
(!i->da->flags.has_tag || TAG_EQ(tag, i->tag))) {
*last = next;
regex_t *preg;
char *value;
- if (!fr_cond_assert(a->vp_type == PW_TYPE_STRING)) return -1;
+ if (!fr_cond_assert(a->vp_type == FR_TYPE_STRING)) return -1;
slen = regex_compile(NULL, &preg, a->xlat, talloc_array_length(a->xlat) - 1, false, false, false, true);
if (slen <= 0) {
continue;
}
} else {
- if ((vp->da->parent->type != PW_TYPE_VENDOR) ||
+ if ((vp->da->parent->type != FR_TYPE_VENDOR) ||
(vp->da->attr != attr) || (vp->da->vendor != vendor)) {
continue;
}
found->next = j;
break;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
fr_pair_value_memsteal(found, i->vp_octets);
i->vp_octets = NULL;
break;
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
fr_pair_value_strsteal(found, i->vp_strvalue);
i->vp_strvalue = NULL;
found->tag = i->tag;
continue;
}
} else {
- if (!((i->da->parent->type == PW_TYPE_VENDOR) &&
+ if (!((i->da->parent->type == FR_TYPE_VENDOR) &&
(i->da->attr == attr) && (i->da->vendor == vendor))) {
iprev = i;
continue;
*/
int fr_pair_value_from_str(VALUE_PAIR *vp, char const *value, size_t inlen)
{
- PW_TYPE type;
+ fr_type_t type;
if (!value) return -1;
vp->vp_octets = p;
vp->vp_length = size;
- vp->vp_type = PW_TYPE_OCTETS;
+ vp->vp_type = FR_TYPE_OCTETS;
talloc_set_type(vp->vp_ptr, uint8_t);
vp->type = VT_DATA;
vp->vp_octets = talloc_steal(vp, src);
vp->vp_length = talloc_array_length(vp->vp_octets);
- vp->vp_type = PW_TYPE_OCTETS;
+ vp->vp_type = FR_TYPE_OCTETS;
talloc_set_type(vp->vp_ptr, uint8_t);
vp->type = VT_DATA;
*/
void fr_pair_value_strsteal(VALUE_PAIR *vp, char const *src)
{
- if (!fr_cond_assert(vp->da->type == PW_TYPE_STRING)) return;
+ if (!fr_cond_assert(vp->da->type == FR_TYPE_STRING)) return;
value_box_clear(&vp->data);
vp->vp_strvalue = talloc_steal(vp, src);
vp->vp_length = talloc_array_length(vp->vp_strvalue) - 1;
- vp->vp_type = PW_TYPE_STRING;
+ vp->vp_type = FR_TYPE_STRING;
talloc_set_type(vp->vp_ptr, char);
vp->type = VT_DATA;
*
* If len is larger than the current buffer, the additional space will be filled with '\0'
*
- * @note vp->da must be of type PW_TYPE_STRING.
+ * @note vp->da must be of type FR_TYPE_STRING.
*
* @param[in,out] vp to update
* @param[in] src buffer to steal.
char *p;
size_t buf_len;
- if (!fr_cond_assert(vp->da->type == PW_TYPE_STRING)) return;
+ if (!fr_cond_assert(vp->da->type == FR_TYPE_STRING)) return;
value_box_clear(&vp->data);
vp->vp_strvalue = talloc_steal(vp, src);
}
vp->vp_length = len;
- vp->vp_type = PW_TYPE_STRING;
+ vp->vp_type = FR_TYPE_STRING;
talloc_set_type(vp->vp_ptr, char);
vp->type = VT_DATA;
/** Copy data into an "string" data type.
*
- * @note vp->da must be of type PW_TYPE_STRING.
+ * @note vp->da must be of type FR_TYPE_STRING.
*
* @param[in,out] vp to update
* @param[in] src data to copy
{
char *p;
- if (!fr_cond_assert(vp->da->type == PW_TYPE_STRING)) return;
+ if (!fr_cond_assert(vp->da->type == FR_TYPE_STRING)) return;
p = talloc_strdup(vp, src);
if (!p) return;
vp->vp_strvalue = p;
vp->type = VT_DATA;
vp->vp_length = talloc_array_length(vp->vp_strvalue) - 1;
- vp->vp_type = PW_TYPE_STRING;
+ vp->vp_type = FR_TYPE_STRING;
talloc_set_type(vp->vp_ptr, char);
VERIFY_VP(vp);
* @note unlike the original strncpy, this function does not stop
* if it finds \0 bytes embedded in the string.
*
- * @note vp->da must be of type PW_TYPE_STRING.
+ * @note vp->da must be of type FR_TYPE_STRING.
*
* @param[in,out] vp to update.
* @param[in] src data to copy.
{
char *p;
- if (!fr_cond_assert(vp->da->type == PW_TYPE_STRING)) return;
+ if (!fr_cond_assert(vp->da->type == FR_TYPE_STRING)) return;
p = talloc_array(vp, char, len + 1);
if (!p) return;
vp->vp_strvalue = p;
vp->vp_length = len;
- vp->vp_type = PW_TYPE_STRING;
+ vp->vp_type = FR_TYPE_STRING;
talloc_set_type(vp->vp_ptr, char);
vp->type = VT_DATA;
/** Print data into an "string" data type.
*
- * @note vp->da must be of type PW_TYPE_STRING.
+ * @note vp->da must be of type FR_TYPE_STRING.
*
* @param[in,out] vp to update
* @param[in] fmt the format string
va_list ap;
char *p;
- if (!fr_cond_assert(vp->da->type == PW_TYPE_STRING)) return;
+ if (!fr_cond_assert(vp->da->type == FR_TYPE_STRING)) return;
va_start(ap, fmt);
p = talloc_vasprintf(vp, fmt, ap);
vp->vp_strvalue = p;
vp->vp_length = talloc_array_length(vp->vp_strvalue) - 1;
- vp->vp_type = PW_TYPE_STRING;
+ vp->vp_type = FR_TYPE_STRING;
talloc_set_type(vp->vp_ptr, char);
vp->type = VT_DATA;
fr_dict_enum_t const *enumv = NULL;
switch (vp->vp_type) {
- case PW_TYPE_NUMERIC:
+ case FR_TYPE_NUMERIC:
break;
default:
}
if (vp->da->flags.has_value) switch (vp->vp_type) {
- case PW_TYPE_BOOLEAN:
+ case FR_TYPE_BOOLEAN:
return vp->vp_bool ? "yes" : "no";
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
enumv = fr_dict_enum_by_da(NULL, vp->da, vp->vp_byte);
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
enumv = fr_dict_enum_by_da(NULL, vp->da, vp->vp_short);
break;
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
enumv = fr_dict_enum_by_da(NULL, vp->da, vp->vp_integer);
break;
- case PW_TYPE_INTEGER64:
+ case FR_TYPE_INTEGER64:
enumv = fr_dict_enum_by_da(NULL, vp->da, vp->vp_integer64);
break;
- case PW_TYPE_SIGNED:
+ case FR_TYPE_SIGNED:
enumv = fr_dict_enum_by_da(NULL, vp->da, vp->vp_signed);
break;
return str;
}
-char *fr_pair_type_asprint(TALLOC_CTX *ctx, PW_TYPE type)
+char *fr_pair_type_asprint(TALLOC_CTX *ctx, fr_type_t type)
{
switch (type) {
- case PW_TYPE_STRING :
+ case FR_TYPE_STRING :
return talloc_typed_strdup(ctx, "_");
- case PW_TYPE_INTEGER64:
- case PW_TYPE_SIZE:
- case PW_TYPE_SIGNED:
- case PW_TYPE_BYTE:
- case PW_TYPE_SHORT:
- case PW_TYPE_INTEGER:
- case PW_TYPE_DATE :
+ case FR_TYPE_INTEGER64:
+ case FR_TYPE_SIZE:
+ case FR_TYPE_SIGNED:
+ case FR_TYPE_BYTE:
+ case FR_TYPE_SHORT:
+ case FR_TYPE_INTEGER:
+ case FR_TYPE_DATE :
return talloc_typed_strdup(ctx, "0");
- case PW_TYPE_IPV4_ADDR :
+ case FR_TYPE_IPV4_ADDR :
return talloc_typed_strdup(ctx, "?.?.?.?");
- case PW_TYPE_IPV4_PREFIX:
+ case FR_TYPE_IPV4_PREFIX:
return talloc_typed_strdup(ctx, "?.?.?.?/?");
- case PW_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_ADDR:
return talloc_typed_strdup(ctx, "[:?:]");
- case PW_TYPE_IPV6_PREFIX:
+ case FR_TYPE_IPV6_PREFIX:
return talloc_typed_strdup(ctx, "[:?:]/?");
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
return talloc_typed_strdup(ctx, "??");
- case PW_TYPE_ETHERNET:
+ case FR_TYPE_ETHERNET:
return talloc_typed_strdup(ctx, "??:??:??:??:??:??:??:??");
#ifdef WITH_ASCEND_BINARY
- case PW_TYPE_ABINARY:
+ case FR_TYPE_ABINARY:
return talloc_typed_strdup(ctx, "??");
#endif
value = fr_pair_value_asprint(ctx, vp, quote);
if (vp->da->flags.has_tag) {
- if (quote && (vp->vp_type == PW_TYPE_STRING)) {
+ if (quote && (vp->vp_type == FR_TYPE_STRING)) {
str = talloc_asprintf(ctx, "%s:%d %s %c%s%c", vp->da->name, vp->tag, token, quote, value, quote);
} else {
str = talloc_asprintf(ctx, "%s:%d %s %s", vp->da->name, vp->tag, token, value);
}
} else {
- if (quote && (vp->vp_type == PW_TYPE_STRING)) {
+ if (quote && (vp->vp_type == FR_TYPE_STRING)) {
str = talloc_asprintf(ctx, "%s %s %c%s%c", vp->da->name, token, quote, value, quote);
} else {
str = talloc_asprintf(ctx, "%s %s %s", vp->da->name, token, value);
fr_dict_verify(file, line, vp->da);
if (vp->vp_ptr) switch (vp->vp_type) {
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
{
size_t len;
TALLOC_CTX *parent;
}
break;
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
{
size_t len;
TALLOC_CTX *parent;
}
break;
- case PW_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_ADDR:
if (vp->vp_ip.af != AF_INET) {
FR_FAULT_LOG("CONSISTENCY CHECK FAILED %s[%u]: VALUE_PAIR \"%s\" address family is not "
"set correctly for IPv4 address. Expected %i got %i\n",
}
break;
- case PW_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_ADDR:
if (vp->vp_ip.af != AF_INET6) {
FR_FAULT_LOG("CONSISTENCY CHECK FAILED %s[%u]: VALUE_PAIR \"%s\" address family is not "
"set correctly for IPv6 address. Expected %i got %i\n",
if (!fr_cond_assert(0)) fr_exit_now(1);
}
- if (da->type == PW_TYPE_COMBO_IP_ADDR) {
+ if (da->type == FR_TYPE_COMBO_IP_ADDR) {
da = fr_dict_attr_by_type(vp->da, vp->da->type);
if (!da) {
FR_FAULT_LOG("CONSISTENCY CHECK FAILED %s[%u]: VALUE_PAIR attribute %p \"%s\" "
}
if (vp->da->flags.is_raw || vp->da->flags.is_unknown) {
- if (vp->data.type != PW_TYPE_OCTETS) {
+ if (vp->data.type != FR_TYPE_OCTETS) {
FR_FAULT_LOG("CONSISTENCY CHECK FAILED %s[%u]: VALUE_PAIR (raw/unknown) attribute %p \"%s\" "
"data type incorrect. Expected %s, got %s",
file, line, vp->da, vp->da->name,
- fr_int2str(dict_attr_types, PW_TYPE_OCTETS, "<INVALID>"),
+ fr_int2str(dict_attr_types, FR_TYPE_OCTETS, "<INVALID>"),
fr_int2str(dict_attr_types, vp->data.type, "<INVALID>"));
if (!fr_cond_assert(0)) fr_exit_now(1);
}
i != NULL;
i = i->next) {
VERIFY_VP(i);
- if ((i->da->parent->type == PW_TYPE_VENDOR) &&
+ if ((i->da->parent->type == FR_TYPE_VENDOR) &&
(i->da->attr == attr) && (i->da->vendor == vendor) &&
(!i->da->flags.has_tag || TAG_EQ(tag, i->tag))) {
break;
* Use #value_box_network_length instead, as that deals with variable
* length attributes too.
*/
-static size_t const value_box_network_sizes[PW_TYPE_MAX + 1][2] = {
- [PW_TYPE_INVALID] = {~0, 0},
+static size_t const value_box_network_sizes[FR_TYPE_MAX + 1][2] = {
+ [FR_TYPE_INVALID] = {~0, 0},
- [PW_TYPE_STRING] = {0, ~0},
- [PW_TYPE_OCTETS] = {0, ~0},
+ [FR_TYPE_STRING] = {0, ~0},
+ [FR_TYPE_OCTETS] = {0, ~0},
- [PW_TYPE_IPV4_ADDR] = {4, 4},
- [PW_TYPE_IPV4_PREFIX] = {6, 6},
- [PW_TYPE_IPV6_ADDR] = {16, 16},
- [PW_TYPE_IPV6_PREFIX] = {18, 18},
- [PW_TYPE_IFID] = {8, 8},
- [PW_TYPE_ETHERNET] = {6, 6},
+ [FR_TYPE_IPV4_ADDR] = {4, 4},
+ [FR_TYPE_IPV4_PREFIX] = {6, 6},
+ [FR_TYPE_IPV6_ADDR] = {16, 16},
+ [FR_TYPE_IPV6_PREFIX] = {18, 18},
+ [FR_TYPE_IFID] = {8, 8},
+ [FR_TYPE_ETHERNET] = {6, 6},
- [PW_TYPE_BOOLEAN] = {1, 1},
- [PW_TYPE_BYTE] = {1, 1},
- [PW_TYPE_SHORT] = {2, 2},
- [PW_TYPE_INTEGER] = {4, 4},
- [PW_TYPE_INTEGER64] = {8, 8},
+ [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},
- [PW_TYPE_SIGNED] = {4, 4},
+ [FR_TYPE_SIGNED] = {4, 4},
- [PW_TYPE_DATE] = {4, 4}, //!< 64bit on most machines.
+ [FR_TYPE_DATE] = {4, 4}, //!< 64bit on most machines.
- [PW_TYPE_ABINARY] = {32, ~0},
- [PW_TYPE_MAX] = {~0, 0} //!< Ensure array covers all types.
+ [FR_TYPE_ABINARY] = {32, ~0},
+ [FR_TYPE_MAX] = {~0, 0} //!< Ensure array covers all types.
};
static_assert(SIZEOF_MEMBER(value_box_t, datum.ip.addr.v4.s_addr) == 4,
* location passed as a void *.
*/
size_t const value_box_field_sizes[] = {
- [PW_TYPE_STRING] = SIZEOF_MEMBER(value_box_t, datum.strvalue),
- [PW_TYPE_OCTETS] = SIZEOF_MEMBER(value_box_t, datum.octets),
-
- [PW_TYPE_IPV4_ADDR] = SIZEOF_MEMBER(value_box_t, datum.ip),
- [PW_TYPE_IPV4_PREFIX] = SIZEOF_MEMBER(value_box_t, datum.ip),
- [PW_TYPE_IPV6_ADDR] = SIZEOF_MEMBER(value_box_t, datum.ip),
- [PW_TYPE_IPV6_PREFIX] = SIZEOF_MEMBER(value_box_t, datum.ip),
- [PW_TYPE_IFID] = SIZEOF_MEMBER(value_box_t, datum.ifid),
- [PW_TYPE_ETHERNET] = SIZEOF_MEMBER(value_box_t, datum.ether),
-
- [PW_TYPE_BOOLEAN] = SIZEOF_MEMBER(value_box_t, datum.boolean),
- [PW_TYPE_BYTE] = SIZEOF_MEMBER(value_box_t, datum.byte),
- [PW_TYPE_SHORT] = SIZEOF_MEMBER(value_box_t, datum.ushort),
- [PW_TYPE_INTEGER] = SIZEOF_MEMBER(value_box_t, datum.integer),
- [PW_TYPE_INTEGER64] = SIZEOF_MEMBER(value_box_t, datum.integer64),
- [PW_TYPE_SIZE] = SIZEOF_MEMBER(value_box_t, datum.size),
-
- [PW_TYPE_SIGNED] = SIZEOF_MEMBER(value_box_t, datum.sinteger),
-
- [PW_TYPE_TIMEVAL] = SIZEOF_MEMBER(value_box_t, datum.timeval),
- [PW_TYPE_DECIMAL] = SIZEOF_MEMBER(value_box_t, datum.decimal),
- [PW_TYPE_DATE] = SIZEOF_MEMBER(value_box_t, datum.date),
-
- [PW_TYPE_ABINARY] = SIZEOF_MEMBER(value_box_t, datum.filter),
- [PW_TYPE_MAX] = 0 //!< Ensure array covers all types.
+ [FR_TYPE_STRING] = SIZEOF_MEMBER(value_box_t, datum.strvalue),
+ [FR_TYPE_OCTETS] = SIZEOF_MEMBER(value_box_t, datum.octets),
+
+ [FR_TYPE_IPV4_ADDR] = SIZEOF_MEMBER(value_box_t, datum.ip),
+ [FR_TYPE_IPV4_PREFIX] = SIZEOF_MEMBER(value_box_t, datum.ip),
+ [FR_TYPE_IPV6_ADDR] = SIZEOF_MEMBER(value_box_t, datum.ip),
+ [FR_TYPE_IPV6_PREFIX] = SIZEOF_MEMBER(value_box_t, datum.ip),
+ [FR_TYPE_IFID] = SIZEOF_MEMBER(value_box_t, datum.ifid),
+ [FR_TYPE_ETHERNET] = SIZEOF_MEMBER(value_box_t, datum.ether),
+
+ [FR_TYPE_BOOLEAN] = SIZEOF_MEMBER(value_box_t, datum.boolean),
+ [FR_TYPE_BYTE] = SIZEOF_MEMBER(value_box_t, datum.byte),
+ [FR_TYPE_SHORT] = SIZEOF_MEMBER(value_box_t, datum.ushort),
+ [FR_TYPE_INTEGER] = SIZEOF_MEMBER(value_box_t, datum.integer),
+ [FR_TYPE_INTEGER64] = SIZEOF_MEMBER(value_box_t, datum.integer64),
+ [FR_TYPE_SIZE] = SIZEOF_MEMBER(value_box_t, datum.size),
+
+ [FR_TYPE_SIGNED] = SIZEOF_MEMBER(value_box_t, datum.sinteger),
+
+ [FR_TYPE_TIMEVAL] = SIZEOF_MEMBER(value_box_t, datum.timeval),
+ [FR_TYPE_DECIMAL] = SIZEOF_MEMBER(value_box_t, datum.decimal),
+ [FR_TYPE_DATE] = SIZEOF_MEMBER(value_box_t, datum.date),
+
+ [FR_TYPE_ABINARY] = SIZEOF_MEMBER(value_box_t, datum.filter),
+ [FR_TYPE_MAX] = 0 //!< Ensure array covers all types.
};
/** Where the value starts in the #value_box_t
*
*/
size_t const value_box_offsets[] = {
- [PW_TYPE_STRING] = offsetof(value_box_t, datum.strvalue),
- [PW_TYPE_OCTETS] = offsetof(value_box_t, datum.octets),
+ [FR_TYPE_STRING] = offsetof(value_box_t, datum.strvalue),
+ [FR_TYPE_OCTETS] = offsetof(value_box_t, datum.octets),
- [PW_TYPE_IPV4_ADDR] = offsetof(value_box_t, datum.ip),
- [PW_TYPE_IPV4_PREFIX] = offsetof(value_box_t, datum.ip),
- [PW_TYPE_IPV6_ADDR] = offsetof(value_box_t, datum.ip),
- [PW_TYPE_IPV6_PREFIX] = offsetof(value_box_t, datum.ip),
- [PW_TYPE_IFID] = offsetof(value_box_t, datum.ifid),
- [PW_TYPE_ETHERNET] = offsetof(value_box_t, datum.ether),
+ [FR_TYPE_IPV4_ADDR] = offsetof(value_box_t, datum.ip),
+ [FR_TYPE_IPV4_PREFIX] = offsetof(value_box_t, datum.ip),
+ [FR_TYPE_IPV6_ADDR] = offsetof(value_box_t, datum.ip),
+ [FR_TYPE_IPV6_PREFIX] = offsetof(value_box_t, datum.ip),
+ [FR_TYPE_IFID] = offsetof(value_box_t, datum.ifid),
+ [FR_TYPE_ETHERNET] = offsetof(value_box_t, datum.ether),
- [PW_TYPE_BOOLEAN] = offsetof(value_box_t, datum.boolean),
- [PW_TYPE_BYTE] = offsetof(value_box_t, datum.byte),
- [PW_TYPE_SHORT] = offsetof(value_box_t, datum.ushort),
- [PW_TYPE_INTEGER] = offsetof(value_box_t, datum.integer),
- [PW_TYPE_INTEGER64] = offsetof(value_box_t, datum.integer64),
- [PW_TYPE_SIZE] = offsetof(value_box_t, datum.size),
+ [FR_TYPE_BOOLEAN] = offsetof(value_box_t, datum.boolean),
+ [FR_TYPE_BYTE] = offsetof(value_box_t, datum.byte),
+ [FR_TYPE_SHORT] = offsetof(value_box_t, datum.ushort),
+ [FR_TYPE_INTEGER] = offsetof(value_box_t, datum.integer),
+ [FR_TYPE_INTEGER64] = offsetof(value_box_t, datum.integer64),
+ [FR_TYPE_SIZE] = offsetof(value_box_t, datum.size),
- [PW_TYPE_SIGNED] = offsetof(value_box_t, datum.sinteger),
+ [FR_TYPE_SIGNED] = offsetof(value_box_t, datum.sinteger),
- [PW_TYPE_TIMEVAL] = offsetof(value_box_t, datum.timeval),
- [PW_TYPE_DECIMAL] = offsetof(value_box_t, datum.decimal),
+ [FR_TYPE_TIMEVAL] = offsetof(value_box_t, datum.timeval),
+ [FR_TYPE_DECIMAL] = offsetof(value_box_t, datum.decimal),
- [PW_TYPE_DATE] = offsetof(value_box_t, datum.date),
+ [FR_TYPE_DATE] = offsetof(value_box_t, datum.date),
- [PW_TYPE_ABINARY] = offsetof(value_box_t, datum.filter),
- [PW_TYPE_MAX] = 0 //!< Ensure array covers all types.
+ [FR_TYPE_ABINARY] = offsetof(value_box_t, datum.filter),
+ [FR_TYPE_MAX] = 0 //!< Ensure array covers all types.
};
/** Allocate a value box of a specific type
* - A new value_box_t.
* - NULL on error.
*/
-value_box_t *value_box_alloc(TALLOC_CTX *ctx, PW_TYPE type)
+value_box_t *value_box_alloc(TALLOC_CTX *ctx, fr_type_t type)
{
value_box_t *value;
inline void value_box_clear(value_box_t *data)
{
switch (data->type) {
- case PW_TYPE_OCTETS:
- case PW_TYPE_STRING:
+ case FR_TYPE_OCTETS:
+ case FR_TYPE_STRING:
TALLOC_FREE(data->datum.ptr);
data->datum.length = 0;
break;
- case PW_TYPE_STRUCTURAL:
+ case FR_TYPE_STRUCTURAL:
if (!fr_cond_assert(0)) return;
- case PW_TYPE_INVALID:
+ case FR_TYPE_INVALID:
return;
default:
}
data->tainted = false;
- data->type = PW_TYPE_INVALID;
+ data->type = FR_TYPE_INVALID;
}
/** Copy flags and type data from one value box to another
static inline void value_box_copy_meta(value_box_t *dst, value_box_t const *src)
{
switch (src->type) {
- case PW_TYPE_VARIABLE_SIZE:
+ case FR_TYPE_VARIABLE_SIZE:
dst->datum.length = src->datum.length;
break;
{
int compare = 0;
- if (!fr_cond_assert(a->type != PW_TYPE_INVALID)) return -1;
- if (!fr_cond_assert(b->type != PW_TYPE_INVALID)) return -1;
+ if (!fr_cond_assert(a->type != FR_TYPE_INVALID)) return -1;
+ if (!fr_cond_assert(b->type != FR_TYPE_INVALID)) return -1;
if (a->type != b->type) {
fr_strerror_printf("Can't compare values of different types");
* do the per-type comparison here.
*/
switch (a->type) {
- case PW_TYPE_VARIABLE_SIZE:
+ case FR_TYPE_VARIABLE_SIZE:
{
size_t length;
#define CHECK(_type) if (a->datum._type < b->datum._type) { compare = -1; \
} else if (a->datum._type > b->datum._type) { compare = +1; }
- case PW_TYPE_BOOLEAN: /* this isn't a RADIUS type, and shouldn't really ever be used */
- case PW_TYPE_BYTE:
+ case FR_TYPE_BOOLEAN: /* this isn't a RADIUS type, and shouldn't really ever be used */
+ case FR_TYPE_BYTE:
CHECK(byte);
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
CHECK(ushort);
break;
- case PW_TYPE_DATE:
+ case FR_TYPE_DATE:
CHECK(date);
break;
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
CHECK(integer);
break;
- case PW_TYPE_SIGNED:
+ case FR_TYPE_SIGNED:
CHECK(sinteger);
break;
- case PW_TYPE_INTEGER64:
+ case FR_TYPE_INTEGER64:
CHECK(integer64);
break;
- case PW_TYPE_SIZE:
+ case FR_TYPE_SIZE:
CHECK(size);
break;
- case PW_TYPE_TIMEVAL:
+ case FR_TYPE_TIMEVAL:
compare = fr_timeval_cmp(&a->datum.timeval, &b->datum.timeval);
break;
- case PW_TYPE_DECIMAL:
+ case FR_TYPE_DECIMAL:
CHECK(decimal);
break;
- case PW_TYPE_ETHERNET:
+ case FR_TYPE_ETHERNET:
compare = memcmp(a->datum.ether, b->datum.ether, sizeof(a->datum.ether));
break;
- case PW_TYPE_IPV4_ADDR:
- case PW_TYPE_IPV4_PREFIX:
- case PW_TYPE_IPV6_ADDR:
- case PW_TYPE_IPV6_PREFIX:
+ case FR_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_PREFIX:
+ case FR_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_PREFIX:
compare = memcmp(&a->datum.ip, &b->datum.ip, sizeof(a->datum.ip));
break;
- case PW_TYPE_IFID:
+ case FR_TYPE_IFID:
compare = memcmp(a->datum.ifid, b->datum.ifid, sizeof(a->datum.ifid));
break;
/*
* These should be handled at some point
*/
- case PW_TYPE_COMBO_IP_ADDR: /* This should have been converted into IPADDR/IPV6ADDR */
- case PW_TYPE_COMBO_IP_PREFIX: /* This should have been converted into IPADDR/IPV6ADDR */
- case PW_TYPE_STRUCTURAL:
- case PW_TYPE_BAD:
+ case FR_TYPE_COMBO_IP_ADDR: /* This should have been converted into IPADDR/IPV6ADDR */
+ case FR_TYPE_COMBO_IP_PREFIX: /* This should have been converted into IPADDR/IPV6ADDR */
+ case FR_TYPE_STRUCTURAL:
+ case FR_TYPE_BAD:
(void)fr_cond_assert(0); /* unknown type */
return -2;
if (!a || !b) return -1;
- if (!fr_cond_assert(a->type != PW_TYPE_INVALID)) return -1;
- if (!fr_cond_assert(b->type != PW_TYPE_INVALID)) return -1;
+ if (!fr_cond_assert(a->type != FR_TYPE_INVALID)) return -1;
+ if (!fr_cond_assert(b->type != FR_TYPE_INVALID)) return -1;
switch (a->type) {
- case PW_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_ADDR:
switch (b->type) {
- case PW_TYPE_IPV4_ADDR: /* IPv4 and IPv4 */
+ case FR_TYPE_IPV4_ADDR: /* IPv4 and IPv4 */
goto cmp;
- case PW_TYPE_IPV4_PREFIX: /* IPv4 and IPv4 Prefix */
+ case FR_TYPE_IPV4_PREFIX: /* IPv4 and IPv4 Prefix */
return value_box_cidr_cmp_op(op, 4, 32, (uint8_t const *) &a->datum.ip.addr.v4.s_addr,
b->datum.ip.prefix, (uint8_t const *) &b->datum.ip.addr.v4.s_addr);
return -1;
}
- case PW_TYPE_IPV4_PREFIX: /* IPv4 and IPv4 Prefix */
+ case FR_TYPE_IPV4_PREFIX: /* IPv4 and IPv4 Prefix */
switch (b->type) {
- case PW_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_ADDR:
return value_box_cidr_cmp_op(op, 4, a->datum.ip.prefix,
(uint8_t const *) &a->datum.ip.addr.v4.s_addr,
32, (uint8_t const *) &b->datum.ip.addr.v4);
- case PW_TYPE_IPV4_PREFIX: /* IPv4 Prefix and IPv4 Prefix */
+ case FR_TYPE_IPV4_PREFIX: /* IPv4 Prefix and IPv4 Prefix */
return value_box_cidr_cmp_op(op, 4, a->datum.ip.prefix,
(uint8_t const *) &a->datum.ip.addr.v4.s_addr,
b->datum.ip.prefix, (uint8_t const *) &b->datum.ip.addr.v4.s_addr);
return -1;
}
- case PW_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_ADDR:
switch (b->type) {
- case PW_TYPE_IPV6_ADDR: /* IPv6 and IPv6 */
+ case FR_TYPE_IPV6_ADDR: /* IPv6 and IPv6 */
goto cmp;
- case PW_TYPE_IPV6_PREFIX: /* IPv6 and IPv6 Preifx */
+ case FR_TYPE_IPV6_PREFIX: /* IPv6 and IPv6 Preifx */
return value_box_cidr_cmp_op(op, 16, 128, (uint8_t const *) &a->datum.ip.addr.v6,
b->datum.ip.prefix, (uint8_t const *) &b->datum.ip.addr.v6);
return -1;
}
- case PW_TYPE_IPV6_PREFIX:
+ case FR_TYPE_IPV6_PREFIX:
switch (b->type) {
- case PW_TYPE_IPV6_ADDR: /* IPv6 Prefix and IPv6 */
+ case FR_TYPE_IPV6_ADDR: /* IPv6 Prefix and IPv6 */
return value_box_cidr_cmp_op(op, 16, a->datum.ip.prefix,
(uint8_t const *) &a->datum.ip.addr.v6,
128, (uint8_t const *) &b->datum.ip.addr.v6);
- case PW_TYPE_IPV6_PREFIX: /* IPv6 Prefix and IPv6 */
+ case FR_TYPE_IPV6_PREFIX: /* IPv6 Prefix and IPv6 */
return value_box_cidr_cmp_op(op, 16, a->datum.ip.prefix,
(uint8_t const *) &a->datum.ip.addr.v6,
b->datum.ip.prefix, (uint8_t const *) &b->datum.ip.addr.v6);
*/
int value_box_hton(value_box_t *dst, value_box_t const *src)
{
- if (!fr_cond_assert(src->type != PW_TYPE_INVALID)) return -1;
+ if (!fr_cond_assert(src->type != FR_TYPE_INVALID)) return -1;
/* 8 byte integers */
switch (src->type) {
- case PW_TYPE_INTEGER64:
+ case FR_TYPE_INTEGER64:
dst->datum.integer64 = htonll(src->datum.integer64);
value_box_copy_meta(dst, src);
break;
/* 4 byte integers */
- case PW_TYPE_INTEGER:
- case PW_TYPE_DATE:
- case PW_TYPE_SIGNED:
+ case FR_TYPE_INTEGER:
+ case FR_TYPE_DATE:
+ case FR_TYPE_SIGNED:
dst->datum.integer = htonl(src->datum.integer);
value_box_copy_meta(dst, src);
break;
/* 2 byte integers */
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
dst->datum.ushort = htons(src->datum.ushort);
value_box_copy_meta(dst, src);
break;
- case PW_TYPE_OCTETS:
- case PW_TYPE_STRING:
+ case FR_TYPE_OCTETS:
+ case FR_TYPE_STRING:
if (!fr_cond_assert(0)) return -1; /* shouldn't happen */
default:
* @param src Input data.
*/
static inline int value_box_cast_to_strvalue(TALLOC_CTX *ctx, value_box_t *dst,
- PW_TYPE dst_type, UNUSED fr_dict_attr_t const *dst_enumv,
+ fr_type_t dst_type, UNUSED fr_dict_attr_t const *dst_enumv,
value_box_t const *src)
{
- if (!fr_cond_assert(dst_type == PW_TYPE_STRING)) return -1;
+ if (!fr_cond_assert(dst_type == FR_TYPE_STRING)) return -1;
switch (src->type) {
/*
* The presentation format of octets is hex
* What we actually want here is the raw string
*/
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
dst->datum.strvalue = talloc_bstrndup(ctx, (char const *)src->datum.octets, src->datum.length);
dst->datum.length = src->datum.length; /* It's the same, even though the buffer is slightly bigger */
break;
}
if (!dst->datum.strvalue) return -1;
- dst->type = PW_TYPE_STRING;
+ dst->type = FR_TYPE_STRING;
return 0;
}
* @param src Input data.
*/
static inline int value_box_cast_to_octets(TALLOC_CTX *ctx, value_box_t *dst,
- PW_TYPE dst_type, UNUSED fr_dict_attr_t const *dst_enumv,
+ fr_type_t dst_type, UNUSED fr_dict_attr_t const *dst_enumv,
value_box_t const *src)
{
uint8_t *bin;
- if (!fr_cond_assert(dst_type == PW_TYPE_OCTETS)) return -1;
+ if (!fr_cond_assert(dst_type == FR_TYPE_OCTETS)) return -1;
switch (src->type) {
/*
* <string> (excluding terminating \0)
*/
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
bin = talloc_memdup(ctx, (uint8_t const *)src->datum.strvalue, src->datum.length);
break;
/*
* <4 bytes address>
*/
- case PW_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_ADDR:
{
bin = talloc_memdup(ctx, (uint8_t const *)&src->datum.ip.addr.v4.s_addr,
sizeof(src->datum.ip.addr.v4.s_addr));
/*
* <1 byte prefix> + <4 bytes address>
*/
- case PW_TYPE_IPV4_PREFIX:
+ case FR_TYPE_IPV4_PREFIX:
bin = talloc_array(ctx, uint8_t, sizeof(src->datum.ip.addr.v4.s_addr) + 1);
bin[0] = src->datum.ip.prefix;
memcpy(&bin[1], (uint8_t const *)&src->datum.ip.addr.v4.s_addr, sizeof(src->datum.ip.addr.v4.s_addr));
/*
* <16 bytes address>
*/
- case PW_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_ADDR:
bin = talloc_memdup(ctx, (uint8_t const *)src->datum.ip.addr.v6.s6_addr,
sizeof(src->datum.ip.addr.v6.s6_addr));
break;
/*
* <1 byte prefix> + <1 byte scope> + <16 bytes address>
*/
- case PW_TYPE_IPV6_PREFIX:
+ case FR_TYPE_IPV6_PREFIX:
bin = talloc_array(ctx, uint8_t, sizeof(src->datum.ip.addr.v6.s6_addr) + 2);
bin[0] = src->datum.ip.scope_id;
bin[1] = src->datum.ip.prefix;
talloc_set_type(bin, uint8_t);
value_box_memsteal(ctx, dst, bin, src->tainted);
- dst->type = PW_TYPE_OCTETS;
+ dst->type = FR_TYPE_OCTETS;
return 0;
}
/** Convert any supported type to an IPv4 address
*
* Allowed input types are:
- * - PW_TYPE_IPV6_ADDR (with v4 prefix).
- * - PW_TYPE_IPV4_PREFIX (with 32bit mask).
- * - PW_TYPE_IPV6_PREFIX (with v4 prefix and 128bit mask).
- * - PW_TYPE_OCTETS (of length 4).
- * - PW_TYPE_INTEGER
+ * - FR_TYPE_IPV6_ADDR (with v4 prefix).
+ * - 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
*
* @param ctx unused.
* @param dst Where to write result of casting.
* @param src Input data.
*/
static inline int value_box_cast_to_ipv4addr(TALLOC_CTX *ctx, value_box_t *dst,
- PW_TYPE dst_type, fr_dict_attr_t const *dst_enumv,
+ fr_type_t dst_type, fr_dict_attr_t const *dst_enumv,
value_box_t const *src)
{
- if (!fr_cond_assert(dst_type == PW_TYPE_IPV4_ADDR)) return -1;
+ if (!fr_cond_assert(dst_type == FR_TYPE_IPV4_ADDR)) return -1;
switch (src->type) {
- case PW_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_ADDR:
if (memcmp(src->datum.ip.addr.v6.s6_addr, v4_v6_map, sizeof(v4_v6_map)) != 0) {
bad_v6_prefix_map:
fr_strerror_printf("Invalid cast from %s to %s. No IPv4-IPv6 mapping prefix",
break;
- case PW_TYPE_IPV4_PREFIX:
+ case FR_TYPE_IPV4_PREFIX:
if (src->datum.ip.prefix != 32) {
fr_strerror_printf("Invalid cast from %s to %s. Only /32 (not %i/) prefixes may be "
"cast to IP address types",
memcpy(&dst->datum.ip.addr.v4, &src->datum.ip.addr.v4, sizeof(dst->datum.ip.addr.v4));
break;
- case PW_TYPE_IPV6_PREFIX:
+ case FR_TYPE_IPV6_PREFIX:
if (src->datum.ip.prefix != 128) {
fr_strerror_printf("Invalid cast from %s to %s. Only /128 (not /%i) prefixes may be "
"cast to IP address types",
sizeof(dst->datum.ip.addr.v4));
break;
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
if (value_box_from_str(ctx, dst, &dst_type, dst_enumv,
src->datum.strvalue, src->datum.length, '\0') < 0) return -1;
break;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
if (src->datum.length != sizeof(dst->datum.ip.addr.v4.s_addr)) {
fr_strerror_printf("Invalid cast from %s to %s. Only %zu byte octet strings "
"may be cast to IP address types",
memcpy(&dst->datum.ip.addr.v4, src->datum.octets, sizeof(dst->datum.ip.addr.v4.s_addr));
break;
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
{
uint32_t net;
dst->datum.ip.af = AF_INET;
dst->datum.ip.prefix = 32;
dst->datum.ip.scope_id = 0;
- dst->type = PW_TYPE_IPV4_ADDR;
+ dst->type = FR_TYPE_IPV4_ADDR;
return 0;
}
/** Convert any supported type to an IPv6 address
*
* Allowed input types are:
- * - PW_TYPE_IPV4_ADDR
- * - PW_TYPE_IPV4_PREFIX (with 32bit mask).
- * - PW_TYPE_IPV6_PREFIX (with 128bit mask).
- * - PW_TYPE_OCTETS (of length 16).
+ * - FR_TYPE_IPV4_ADDR
+ * - FR_TYPE_IPV4_PREFIX (with 32bit mask).
+ * - FR_TYPE_IPV6_PREFIX (with 128bit mask).
+ * - FR_TYPE_OCTETS (of length 16).
*
* @param ctx unused.
* @param dst Where to write result of casting.
* @param src Input data.
*/
static inline int value_box_cast_to_ipv4prefix(TALLOC_CTX *ctx, value_box_t *dst,
- PW_TYPE dst_type, fr_dict_attr_t const *dst_enumv,
+ fr_type_t dst_type, fr_dict_attr_t const *dst_enumv,
value_box_t const *src)
{
- if (!fr_cond_assert(dst_type == PW_TYPE_IPV4_PREFIX)) return -1;
+ if (!fr_cond_assert(dst_type == FR_TYPE_IPV4_PREFIX)) return -1;
switch (src->type) {
- case PW_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_ADDR:
memcpy(&dst->datum.ip, &src->datum.ip, sizeof(dst->datum.ip));
break;
/*
* Copy the last four bytes, to make an IPv4prefix
*/
- case PW_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_ADDR:
if (memcmp(src->datum.ip.addr.v6.s6_addr, v4_v6_map, sizeof(v4_v6_map)) != 0) {
bad_v6_prefix_map:
fr_strerror_printf("Invalid cast from %s to %s. No IPv4-IPv6 mapping prefix",
dst->datum.ip.prefix = 32;
break;
- case PW_TYPE_IPV6_PREFIX:
+ case FR_TYPE_IPV6_PREFIX:
if (memcmp(src->datum.ip.addr.v6.s6_addr, v4_v6_map, sizeof(v4_v6_map)) != 0) goto bad_v6_prefix_map;
if (src->datum.ip.prefix < (sizeof(v4_v6_map) << 3)) {
dst->datum.ip.prefix = src->datum.ip.prefix - (sizeof(v4_v6_map) << 3);
break;
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
if (value_box_from_str(ctx, dst, &dst_type, dst_enumv,
src->datum.strvalue, src->datum.length, '\0') < 0) return -1;
break;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
if (src->datum.length != sizeof(dst->datum.ip.addr.v4.s_addr) + 1) {
fr_strerror_printf("Invalid cast from %s to %s. Only %zu byte octet strings "
"may be cast to IP address types",
memcpy(&dst->datum.ip.addr.v4, &src->datum.octets[1], sizeof(dst->datum.ip.addr.v4.s_addr));
break;
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
{
uint32_t net;
dst->datum.ip.af = AF_INET;
dst->datum.ip.scope_id = 0;
- dst->type = PW_TYPE_IPV4_PREFIX;
+ dst->type = FR_TYPE_IPV4_PREFIX;
return 0;
}
/** Convert any supported type to an IPv6 address
*
* Allowed input types are:
- * - PW_TYPE_IPV4_ADDR
- * - PW_TYPE_IPV4_PREFIX (with 32bit mask).
- * - PW_TYPE_IPV6_PREFIX (with 128bit mask).
- * - PW_TYPE_OCTETS (of length 16).
+ * - FR_TYPE_IPV4_ADDR
+ * - FR_TYPE_IPV4_PREFIX (with 32bit mask).
+ * - FR_TYPE_IPV6_PREFIX (with 128bit mask).
+ * - FR_TYPE_OCTETS (of length 16).
*
* @param ctx unused.
* @param dst Where to write result of casting.
* @param src Input data.
*/
static inline int value_box_cast_to_ipv6addr(TALLOC_CTX *ctx, value_box_t *dst,
- PW_TYPE dst_type, fr_dict_attr_t const *dst_enumv,
+ fr_type_t dst_type, fr_dict_attr_t const *dst_enumv,
value_box_t const *src)
{
- if (!fr_cond_assert(dst_type == PW_TYPE_IPV6_ADDR)) return -1;
+ if (!fr_cond_assert(dst_type == FR_TYPE_IPV6_ADDR)) return -1;
static_assert((sizeof(v4_v6_map) + sizeof(src->datum.ip.addr.v4)) <=
sizeof(src->datum.ip.addr.v6), "IPv6 storage too small");
switch (src->type) {
- case PW_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_ADDR:
{
uint8_t *p = dst->datum.ip.addr.v6.s6_addr;
}
break;
- case PW_TYPE_IPV4_PREFIX:
+ case FR_TYPE_IPV4_PREFIX:
{
uint8_t *p = dst->datum.ip.addr.v6.s6_addr;
}
break;
- case PW_TYPE_IPV6_PREFIX:
+ case FR_TYPE_IPV6_PREFIX:
if (src->datum.ip.prefix != 128) {
fr_strerror_printf("Invalid cast from %s to %s. Only /128 (not /%i) prefixes may be "
"cast to IP address types",
dst->datum.ip.scope_id = src->datum.ip.scope_id;
break;
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
if (value_box_from_str(ctx, dst, &dst_type, dst_enumv,
src->datum.strvalue, src->datum.length, '\0') < 0) return -1;
break;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
if (src->datum.length != sizeof(dst->datum.ip.addr.v6.s6_addr)) {
fr_strerror_printf("Invalid cast from %s to %s. Only %zu byte octet strings "
"may be cast to IP address types",
dst->datum.ip.af = AF_INET6;
dst->datum.ip.prefix = 128;
- dst->type = PW_TYPE_IPV6_ADDR;
+ dst->type = FR_TYPE_IPV6_ADDR;
return 0;
}
/** Convert any supported type to an IPv6 address
*
* Allowed input types are:
- * - PW_TYPE_IPV4_ADDR
- * - PW_TYPE_IPV4_PREFIX (with 32bit mask).
- * - PW_TYPE_IPV6_PREFIX (with 128bit mask).
- * - PW_TYPE_OCTETS (of length 16).
+ * - FR_TYPE_IPV4_ADDR
+ * - FR_TYPE_IPV4_PREFIX (with 32bit mask).
+ * - FR_TYPE_IPV6_PREFIX (with 128bit mask).
+ * - FR_TYPE_OCTETS (of length 16).
*
* @param ctx unused.
* @param dst Where to write result of casting.
* @param src Input data.
*/
static inline int value_box_cast_to_ipv6prefix(TALLOC_CTX *ctx, value_box_t *dst,
- PW_TYPE dst_type, fr_dict_attr_t const *dst_enumv,
+ fr_type_t dst_type, fr_dict_attr_t const *dst_enumv,
value_box_t const *src)
{
switch (src->type) {
- case PW_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_ADDR:
{
uint8_t *p = dst->datum.ip.addr.v6.s6_addr;
}
break;
- case PW_TYPE_IPV4_PREFIX:
+ case FR_TYPE_IPV4_PREFIX:
{
uint8_t *p = dst->datum.ip.addr.v6.s6_addr;
}
break;
- case PW_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_ADDR:
memcpy(dst->datum.ip.addr.v6.s6_addr, src->datum.ip.addr.v6.s6_addr,
sizeof(dst->datum.ip.addr.v6.s6_addr));
dst->datum.ip.prefix = 128;
dst->datum.ip.scope_id = src->datum.ip.scope_id;
break;
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
if (value_box_from_str(ctx, dst, &dst_type, dst_enumv,
src->datum.strvalue, src->datum.length, '\0') < 0) return -1;
break;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
if (src->datum.length != (sizeof(dst->datum.ip.addr.v6.s6_addr) + 2)) {
fr_strerror_printf("Invalid cast from %s to %s. Only %zu byte octet strings "
"may be cast to IP address types",
}
dst->datum.ip.af = AF_INET6;
- dst->type = PW_TYPE_IPV6_PREFIX;
+ dst->type = FR_TYPE_IPV6_PREFIX;
return 0;
}
* - -1 on failure.
*/
int value_box_cast(TALLOC_CTX *ctx, value_box_t *dst,
- PW_TYPE dst_type, fr_dict_attr_t const *dst_enumv,
+ fr_type_t dst_type, fr_dict_attr_t const *dst_enumv,
value_box_t const *src)
{
- if (!fr_cond_assert(dst_type != PW_TYPE_INVALID)) return -1;
- if (!fr_cond_assert(src->type != PW_TYPE_INVALID)) return -1;
+ if (!fr_cond_assert(dst_type != FR_TYPE_INVALID)) return -1;
+ if (!fr_cond_assert(src->type != FR_TYPE_INVALID)) return -1;
if (fr_dict_non_data_types[dst_type]) {
fr_strerror_printf("Invalid cast from %s to %s. Can only cast simple data types.",
* Dispatch to specialised cast functions
*/
switch (dst_type) {
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
return value_box_cast_to_strvalue(ctx, dst, dst_type, dst_enumv, src);
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
return value_box_cast_to_octets(ctx, dst, dst_type, dst_enumv, src);
- case PW_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_ADDR:
return value_box_cast_to_ipv4addr(ctx, dst, dst_type, dst_enumv, src);
- case PW_TYPE_IPV4_PREFIX:
+ case FR_TYPE_IPV4_PREFIX:
return value_box_cast_to_ipv4prefix(ctx, dst, dst_type, dst_enumv, src);
- case PW_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_ADDR:
return value_box_cast_to_ipv6addr(ctx, dst, dst_type, dst_enumv, src);
- case PW_TYPE_IPV6_PREFIX:
+ case FR_TYPE_IPV6_PREFIX:
return value_box_cast_to_ipv6prefix(ctx, dst, dst_type, dst_enumv, src);
/*
* Need func
*/
- case PW_TYPE_IFID:
- case PW_TYPE_COMBO_IP_ADDR:
- case PW_TYPE_COMBO_IP_PREFIX:
- case PW_TYPE_ETHERNET:
- case PW_TYPE_BOOLEAN:
- case PW_TYPE_BYTE:
- case PW_TYPE_SHORT:
- case PW_TYPE_INTEGER:
- case PW_TYPE_INTEGER64:
- case PW_TYPE_SIZE:
- case PW_TYPE_SIGNED:
- case PW_TYPE_TIMEVAL:
- case PW_TYPE_DECIMAL:
- case PW_TYPE_DATE:
- case PW_TYPE_ABINARY:
+ case FR_TYPE_IFID:
+ 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_SIZE:
+ case FR_TYPE_SIGNED:
+ case FR_TYPE_TIMEVAL:
+ case FR_TYPE_DECIMAL:
+ case FR_TYPE_DATE:
+ case FR_TYPE_ABINARY:
break;
/*
* Invalid types for casting (should have been caught earlier)
*/
- case PW_TYPE_STRUCTURAL:
- case PW_TYPE_INVALID:
- case PW_TYPE_MAX:
+ case FR_TYPE_STRUCTURAL:
+ case FR_TYPE_INVALID:
+ case FR_TYPE_MAX:
if (!fr_cond_assert(0)) return -1;
}
/*
* Deserialise a value_box_t
*/
- if (src->type == PW_TYPE_STRING) return value_box_from_str(ctx, dst, &dst_type, dst_enumv,
+ if (src->type == FR_TYPE_STRING) return value_box_from_str(ctx, dst, &dst_type, dst_enumv,
src->datum.strvalue, src->datum.length, '\0');
- if ((src->type == PW_TYPE_IFID) &&
- (dst_type == PW_TYPE_INTEGER64)) {
+ if ((src->type == FR_TYPE_IFID) &&
+ (dst_type == FR_TYPE_INTEGER64)) {
memcpy(&dst->datum.integer64, src->datum.ifid, sizeof(src->datum.ifid));
dst->datum.integer64 = htonll(dst->datum.integer64);
return 0;
}
- if ((src->type == PW_TYPE_INTEGER64) &&
- (dst_type == PW_TYPE_ETHERNET)) {
+ if ((src->type == FR_TYPE_INTEGER64) &&
+ (dst_type == FR_TYPE_ETHERNET)) {
uint8_t array[8];
uint64_t i;
goto fixed_length;
}
- if (dst_type == PW_TYPE_SHORT) {
+ if (dst_type == FR_TYPE_SHORT) {
switch (src->type) {
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
dst->datum.ushort = src->datum.byte;
break;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
goto do_octets;
default:
* We can cast LONG integers to SHORTER ones, so long
* as the long one is on the LHS.
*/
- if (dst_type == PW_TYPE_INTEGER) {
+ if (dst_type == FR_TYPE_INTEGER) {
switch (src->type) {
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
dst->datum.integer = src->datum.byte;
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
dst->datum.integer = src->datum.ushort;
break;
- case PW_TYPE_SIGNED:
+ case FR_TYPE_SIGNED:
if (src->datum.sinteger < 0 ) {
fr_strerror_printf("Invalid cast: From signed to integer. "
"signed value %d is negative ", src->datum.sinteger);
dst->datum.integer = (uint32_t)src->datum.sinteger;
break;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
goto do_octets;
default:
* For integers, we allow the casting of a SMALL type to
* a larger type, but not vice-versa.
*/
- if (dst_type == PW_TYPE_INTEGER64) {
+ if (dst_type == FR_TYPE_INTEGER64) {
switch (src->type) {
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
dst->datum.integer64 = src->datum.byte;
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
dst->datum.integer64 = src->datum.ushort;
break;
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
dst->datum.integer64 = src->datum.integer;
break;
- case PW_TYPE_DATE:
+ case FR_TYPE_DATE:
dst->datum.integer64 = src->datum.date;
break;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
goto do_octets;
default:
/*
* We can cast integers less that < INT_MAX to signed
*/
- if (dst_type == PW_TYPE_SIGNED) {
+ if (dst_type == FR_TYPE_SIGNED) {
switch (src->type) {
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
dst->datum.sinteger = src->datum.byte;
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
dst->datum.sinteger = src->datum.ushort;
break;
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
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 PW_TYPE_INTEGER64:
+ case FR_TYPE_INTEGER64:
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);
dst->datum.sinteger = (int)src->datum.integer64;
break;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
goto do_octets;
default:
goto fixed_length;
}
- if (dst_type == PW_TYPE_TIMEVAL) {
+ if (dst_type == FR_TYPE_TIMEVAL) {
switch (src->type) {
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
dst->datum.timeval.tv_sec = src->datum.byte;
dst->datum.timeval.tv_usec = 0;
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
dst->datum.timeval.tv_sec = src->datum.ushort;
dst->datum.timeval.tv_usec = 0;
break;
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
dst->datum.timeval.tv_sec = src->datum.integer;
dst->datum.timeval.tv_usec = 0;
break;
- case PW_TYPE_INTEGER64:
+ case FR_TYPE_INTEGER64:
/*
* tv_sec is a time_t, which is variable in size
* depending on the system.
}
}
- if (src->type == PW_TYPE_OCTETS) {
+ if (src->type == FR_TYPE_OCTETS) {
value_box_t tmp;
do_octets:
* Fixup IP addresses.
*/
switch (dst->type) {
- case PW_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_ADDR:
dst->datum.ip.af = AF_INET;
dst->datum.ip.prefix = 128;
dst->datum.ip.scope_id = 0;
break;
- case PW_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_ADDR:
dst->datum.ip.af = AF_INET6;
dst->datum.ip.prefix = 128;
dst->datum.ip.scope_id = 0;
/*
* Convert host order to network byte order.
*/
- if ((dst_type == PW_TYPE_IPV4_ADDR) &&
- ((src->type == PW_TYPE_INTEGER) ||
- (src->type == PW_TYPE_DATE) ||
- (src->type == PW_TYPE_SIGNED))) {
+ if ((dst_type == FR_TYPE_IPV4_ADDR) &&
+ ((src->type == FR_TYPE_INTEGER) ||
+ (src->type == FR_TYPE_DATE) ||
+ (src->type == FR_TYPE_SIGNED))) {
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 == PW_TYPE_IPV4_ADDR) &&
- ((dst_type == PW_TYPE_INTEGER) ||
- (dst_type == PW_TYPE_DATE) ||
- (dst_type == PW_TYPE_SIGNED))) {
+ } else if ((src->type == FR_TYPE_IPV4_ADDR) &&
+ ((dst_type == FR_TYPE_INTEGER) ||
+ (dst_type == FR_TYPE_DATE) ||
+ (dst_type == FR_TYPE_SIGNED))) {
dst->datum.integer = htonl(src->datum.ip.addr.v4.s_addr);
} else { /* they're of the same byte order */
*/
int value_box_copy(TALLOC_CTX *ctx, value_box_t *dst, const value_box_t *src)
{
- if (!fr_cond_assert(src->type != PW_TYPE_INVALID)) return -1;
+ if (!fr_cond_assert(src->type != FR_TYPE_INVALID)) return -1;
switch (src->type) {
default:
value_box_field_sizes[src->type]);
break;
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
{
char *str = NULL;
}
break;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
{
uint8_t *bin = NULL;
*
* Like #value_box_copy, but does not duplicate the buffers of the src value_box.
*
- * For #PW_TYPE_STRING and #PW_TYPE_OCTETS adds a reference from ctx so that the
+ * For #FR_TYPE_STRING and #FR_TYPE_OCTETS adds a reference from ctx so that the
* buffer cannot be freed until the ctx is freed.
*
* @note Will free any exiting buffers associated with the dst #value_box_t.
value_box_copy(ctx, dst, src);
break;
- case PW_TYPE_STRING:
- case PW_TYPE_OCTETS:
+ case FR_TYPE_STRING:
+ case FR_TYPE_OCTETS:
dst->datum.ptr = ctx ? talloc_reference(ctx, src->datum.ptr) : src->datum.ptr;
value_box_copy_meta(dst, src);
break;
*/
int value_box_steal(TALLOC_CTX *ctx, value_box_t *dst, value_box_t const *src)
{
- if (!fr_cond_assert(src->type != PW_TYPE_INVALID)) return -1;
+ if (!fr_cond_assert(src->type != FR_TYPE_INVALID)) return -1;
switch (src->type) {
default:
return value_box_copy(ctx, dst, src);
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
{
char const *str;
}
return 0;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
{
uint8_t const *bin;
return -1;
}
- dst->type = PW_TYPE_STRING;
+ dst->type = FR_TYPE_STRING;
dst->tainted = tainted;
dst->datum.strvalue = str;
dst->datum.length = talloc_array_length(str) - 1;
return -1;
}
- dst->type = PW_TYPE_STRING;
+ dst->type = FR_TYPE_STRING;
dst->tainted = tainted;
dst->datum.strvalue = str;
dst->datum.length = talloc_array_length(str) - 1;
return -1;
}
- dst->type = PW_TYPE_STRING;
+ dst->type = FR_TYPE_STRING;
dst->tainted = tainted;
dst->datum.strvalue = str;
dst->datum.length = len - 1;
*/
int value_box_strdup_shallow(value_box_t *dst, char const *src, bool tainted)
{
- dst->type = PW_TYPE_STRING;
+ dst->type = FR_TYPE_STRING;
dst->tainted = tainted;
dst->datum.strvalue = src;
dst->datum.length = strlen(src);
return -1;
}
- dst->type = PW_TYPE_STRING;
+ dst->type = FR_TYPE_STRING;
dst->tainted = tainted;
dst->datum.strvalue = ctx ? talloc_reference(ctx, src) : src;
dst->datum.length = len - 1;
return -1;
}
- dst->type = PW_TYPE_OCTETS;
+ dst->type = FR_TYPE_OCTETS;
dst->tainted = tainted;
dst->datum.octets = bin;
dst->datum.length = len;
return -1;
}
- dst->type = PW_TYPE_OCTETS;
+ dst->type = FR_TYPE_OCTETS;
dst->tainted = tainted;
dst->datum.octets = bin;
dst->datum.length = talloc_array_length(src);
*/
int value_box_memdup_shallow(value_box_t *dst, uint8_t *src, size_t len, bool tainted)
{
- dst->type = PW_TYPE_OCTETS;
+ dst->type = FR_TYPE_OCTETS;
dst->tainted = tainted;
dst->datum.octets = src;
dst->datum.length = len;
{
(void) talloc_get_type_abort(src, uint8_t);
- dst->type = PW_TYPE_OCTETS;
+ dst->type = FR_TYPE_OCTETS;
dst->tainted = tainted;
dst->datum.octets = ctx ? talloc_reference(ctx, src) : src;
dst->datum.length = talloc_array_length(src);
*/
int value_box_from_ipaddr(value_box_t *dst, fr_ipaddr_t const *ipaddr)
{
- PW_TYPE type;
+ fr_type_t type;
switch (ipaddr->af) {
case AF_INET:
}
if (ipaddr->prefix == 32) {
- type = PW_TYPE_IPV4_ADDR;
+ type = FR_TYPE_IPV4_ADDR;
} else {
- type = PW_TYPE_IPV4_PREFIX;
+ type = FR_TYPE_IPV4_PREFIX;
}
break;
}
if (ipaddr->prefix == 128) {
- type = PW_TYPE_IPV6_ADDR;
+ type = FR_TYPE_IPV6_ADDR;
} else {
- type = PW_TYPE_IPV6_PREFIX;
+ type = FR_TYPE_IPV6_PREFIX;
}
break;
* - -1 on parse error.
*/
int value_box_from_str(TALLOC_CTX *ctx, value_box_t *dst,
- PW_TYPE *dst_type, fr_dict_attr_t const *dst_enumv,
+ fr_type_t *dst_type, fr_dict_attr_t const *dst_enumv,
char const *in, ssize_t inlen, char quote)
{
fr_dict_enum_t *dval;
ssize_t ret;
char buffer[256];
- if (!fr_cond_assert(*dst_type != PW_TYPE_INVALID)) return -1;
+ if (!fr_cond_assert(*dst_type != FR_TYPE_INVALID)) return -1;
if (!in) return -1;
* of size len and copy.
*/
switch (*dst_type) {
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
{
char *buff, *p;
}
goto finish;
- case PW_TYPE_VSA:
+ case FR_TYPE_VSA:
fr_strerror_printf("Must use 'Attr-26 = ...' instead of 'Vendor-Specific = ...'");
return -1;
/* raw octets: 0x01020304... */
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
{
uint8_t *p;
}
goto finish;
- case PW_TYPE_ABINARY:
+ case FR_TYPE_ABINARY:
#ifdef WITH_ASCEND_BINARY
if ((len > 1) && (strncasecmp(in, "0x", 2) == 0)) {
ssize_t bin;
goto do_octets;
#endif
- case PW_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_ADDR:
{
fr_ipaddr_t addr;
}
goto finish;
- case PW_TYPE_IPV4_PREFIX:
+ case FR_TYPE_IPV4_PREFIX:
if (fr_inet_pton4(&dst->datum.ip, in, inlen, fr_hostname_lookups, false, true) < 0) return -1;
goto finish;
- case PW_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_ADDR:
{
fr_ipaddr_t addr;
}
goto finish;
- case PW_TYPE_IPV6_PREFIX:
+ case FR_TYPE_IPV6_PREFIX:
if (fr_inet_pton6(&dst->datum.ip, in, inlen, fr_hostname_lookups, false, true) < 0) return -1;
goto finish;
default:
break;
- case PW_TYPE_STRUCTURAL_EXCEPT_VSA:
- case PW_TYPE_VENDOR:
- case PW_TYPE_BAD:
+ case FR_TYPE_STRUCTURAL_EXCEPT_VSA:
+ case FR_TYPE_VENDOR:
+ case FR_TYPE_BAD:
fr_strerror_printf("Invalid dst_type %d", *dst_type);
return -1;
}
}
switch (*dst_type) {
- case PW_TYPE_IPV4_ADDR:
- case PW_TYPE_IPV4_PREFIX:
- case PW_TYPE_IPV6_ADDR:
- case PW_TYPE_IPV6_PREFIX:
+ case FR_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_PREFIX:
+ case FR_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_PREFIX:
break;
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
{
char *p;
unsigned int i;
break;
}
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
{
char *p;
unsigned int i;
break;
}
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
{
char *p;
}
break;
- case PW_TYPE_INTEGER64:
+ case FR_TYPE_INTEGER64:
{
uint64_t i;
}
break;
- case PW_TYPE_SIZE:
+ case FR_TYPE_SIZE:
{
size_t i;
}
break;
- case PW_TYPE_TIMEVAL:
+ case FR_TYPE_TIMEVAL:
if (fr_timeval_from_str(&dst->datum.timeval, in) < 0) return -1;
break;
- case PW_TYPE_DECIMAL:
+ case FR_TYPE_DECIMAL:
{
double d;
}
break;
- case PW_TYPE_DATE:
+ case FR_TYPE_DATE:
{
/*
* time_t may be 64 bits, whule vp_date MUST be 32-bits. We need an
break;
- case PW_TYPE_IFID:
+ case FR_TYPE_IFID:
if (fr_inet_ifid_pton((void *) dst->datum.ifid, in) == NULL) {
fr_strerror_printf("Failed to parse interface-id string \"%s\"", in);
return -1;
}
break;
- case PW_TYPE_ETHERNET:
+ case FR_TYPE_ETHERNET:
{
char const *c1, *c2, *cp;
size_t p_len = 0;
* These are not dynamic da, and will have the same vendor
* and attribute as the original.
*/
- case PW_TYPE_COMBO_IP_ADDR:
+ case FR_TYPE_COMBO_IP_ADDR:
{
if (fr_inet_pton(&dst->datum.ip, in, inlen, AF_UNSPEC, fr_hostname_lookups, true) < 0) return -1;
switch (dst->datum.ip.af) {
case AF_INET:
- ret = dict_attr_sizes[PW_TYPE_COMBO_IP_ADDR][0]; /* size of IPv4 address */
- *dst_type = PW_TYPE_IPV4_ADDR;
+ ret = dict_attr_sizes[FR_TYPE_COMBO_IP_ADDR][0]; /* size of IPv4 address */
+ *dst_type = FR_TYPE_IPV4_ADDR;
break;
case AF_INET6:
- *dst_type = PW_TYPE_IPV6_ADDR;
- ret = dict_attr_sizes[PW_TYPE_COMBO_IP_ADDR][1]; /* size of IPv6 address */
+ *dst_type = FR_TYPE_IPV6_ADDR;
+ ret = dict_attr_sizes[FR_TYPE_COMBO_IP_ADDR][1]; /* size of IPv6 address */
break;
default:
}
break;
- case PW_TYPE_SIGNED:
+ case FR_TYPE_SIGNED:
/* Damned code for 1 WiMAX attribute */
dst->datum.sinteger = (int32_t)strtol(in, NULL, 10);
break;
- case PW_TYPE_BOOLEAN:
+ case FR_TYPE_BOOLEAN:
if ((strcmp(in, "yes") == 0) || strcmp(in, "true") == 0) {
dst->datum.boolean = true;
} else if ((strcmp(in, "no") == 0) || (strcmp(in, "false") == 0)) {
}
break;
- case PW_TYPE_COMBO_IP_PREFIX:
+ case FR_TYPE_COMBO_IP_PREFIX:
break;
- case PW_TYPE_VARIABLE_SIZE: /* Should have been dealt with above */
- case PW_TYPE_STRUCTURAL: /* Listed again to suppress compiler warnings */
- case PW_TYPE_BAD:
+ case FR_TYPE_VARIABLE_SIZE: /* Should have been dealt with above */
+ case FR_TYPE_STRUCTURAL: /* Listed again to suppress compiler warnings */
+ case FR_TYPE_BAD:
fr_strerror_printf("Unknown attribute dst_type %d", *dst_type);
return -1;
}
size_t value_box_network_length(value_box_t *value)
{
switch (value->type) {
- case PW_TYPE_VARIABLE_SIZE:
+ case FR_TYPE_VARIABLE_SIZE:
return value->datum.length;
default:
{
char *p = NULL;
- if (!fr_cond_assert(data->type != PW_TYPE_INVALID)) return NULL;
+ if (!fr_cond_assert(data->type != FR_TYPE_INVALID)) return NULL;
if (fr_dict_enum_types[data->type] && data->datum.enumv) {
fr_dict_enum_t const *dv;
value_box_t tmp;
- value_box_cast(ctx, &tmp, PW_TYPE_INTEGER, NULL, data);
+ value_box_cast(ctx, &tmp, FR_TYPE_INTEGER, NULL, data);
dv = fr_dict_enum_by_da(NULL, data->datum.enumv, tmp.datum.integer);
if (dv) return talloc_typed_strdup(ctx, dv->name);
}
switch (data->type) {
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
{
size_t len, ret;
break;
}
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
p = talloc_array(ctx, char, 2 + 1 + data->datum.length * 2);
if (!p) return NULL;
p[0] = '0';
*
* An example is tunneled ipv4 in ipv6 addresses.
*/
- case PW_TYPE_IPV4_ADDR:
- case PW_TYPE_IPV4_PREFIX:
+ case FR_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_PREFIX:
{
char buff[INET_ADDRSTRLEN + 4]; // + /prefix
}
break;
- case PW_TYPE_IPV6_ADDR:
- case PW_TYPE_IPV6_PREFIX:
+ case FR_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_PREFIX:
{
char buff[INET6_ADDRSTRLEN + 4]; // + /prefix
}
break;
- case PW_TYPE_IFID:
+ case FR_TYPE_IFID:
p = talloc_typed_asprintf(ctx, "%x:%x:%x:%x",
(data->datum.ifid[0] << 8) | data->datum.ifid[1],
(data->datum.ifid[2] << 8) | data->datum.ifid[3],
(data->datum.ifid[6] << 8) | data->datum.ifid[7]);
break;
- case PW_TYPE_ETHERNET:
+ case FR_TYPE_ETHERNET:
p = talloc_typed_asprintf(ctx, "%02x:%02x:%02x:%02x:%02x:%02x",
data->datum.ether[0], data->datum.ether[1],
data->datum.ether[2], data->datum.ether[3],
data->datum.ether[4], data->datum.ether[5]);
break;
- case PW_TYPE_BOOLEAN:
+ case FR_TYPE_BOOLEAN:
p = talloc_typed_strdup(ctx, data->datum.byte ? "yes" : "no");
break;
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
p = talloc_typed_asprintf(ctx, "%u", data->datum.byte);
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
p = talloc_typed_asprintf(ctx, "%u", data->datum.ushort);
break;
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
p = talloc_typed_asprintf(ctx, "%u", data->datum.integer);
break;
- case PW_TYPE_INTEGER64:
+ case FR_TYPE_INTEGER64:
p = talloc_typed_asprintf(ctx, "%" PRIu64, data->datum.integer64);
break;
- case PW_TYPE_SIZE:
+ case FR_TYPE_SIZE:
p = talloc_typed_asprintf(ctx, "%zu", data->datum.size);
break;
- case PW_TYPE_SIGNED:
+ case FR_TYPE_SIGNED:
p = talloc_typed_asprintf(ctx, "%d", data->datum.sinteger);
break;
- case PW_TYPE_TIMEVAL:
+ case FR_TYPE_TIMEVAL:
p = talloc_typed_asprintf(ctx, "%" PRIu64 ".%06" PRIu64,
(uint64_t)data->datum.timeval.tv_sec, (uint64_t)data->datum.timeval.tv_usec);
break;
- case PW_TYPE_DECIMAL:
+ case FR_TYPE_DECIMAL:
p = talloc_typed_asprintf(ctx, "%g", data->datum.decimal);
break;
- case PW_TYPE_DATE:
+ case FR_TYPE_DATE:
{
time_t t;
struct tm s_tm;
break;
}
- case PW_TYPE_ABINARY:
+ case FR_TYPE_ABINARY:
#ifdef WITH_ASCEND_BINARY
p = talloc_array(ctx, char, 128);
if (!p) return NULL;
/*
* Don't add default here
*/
- case PW_TYPE_COMBO_IP_ADDR:
- case PW_TYPE_COMBO_IP_PREFIX:
- case PW_TYPE_STRUCTURAL:
- case PW_TYPE_BAD:
+ case FR_TYPE_COMBO_IP_ADDR:
+ case FR_TYPE_COMBO_IP_PREFIX:
+ case FR_TYPE_STRUCTURAL:
+ case FR_TYPE_BAD:
(void)fr_cond_assert(0);
return NULL;
}
size_t len = 0, freespace = outlen;
- if (!fr_cond_assert(data->type != PW_TYPE_INVALID)) return -1;
+ if (!fr_cond_assert(data->type != FR_TYPE_INVALID)) return -1;
if (!data) return 0;
if (outlen == 0) return data->datum.length;
fr_dict_enum_t const *dv;
value_box_t tmp;
- value_box_cast(NULL, &tmp, PW_TYPE_INTEGER, NULL, data);
+ value_box_cast(NULL, &tmp, FR_TYPE_INTEGER, NULL, data);
dv = fr_dict_enum_by_da(NULL, data->datum.enumv, tmp.datum.integer);
if (dv) return strlcpy(out, dv->name, outlen);
}
switch (data->type) {
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
/*
* Ensure that WE add the quotation marks around the string.
return fr_snprint(out, outlen, data->datum.strvalue, data->datum.length, quote);
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
return snprintf(out, outlen, "%u", data->datum.byte);
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
return snprintf(out, outlen, "%u", data->datum.ushort);
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
return snprintf(out, outlen, "%u", data->datum.integer);
- case PW_TYPE_INTEGER64:
+ case FR_TYPE_INTEGER64:
return snprintf(out, outlen, "%" PRIu64, data->datum.integer64);
- case PW_TYPE_SIZE:
+ case FR_TYPE_SIZE:
return snprintf(out, outlen, "%zu", data->datum.size);
- case PW_TYPE_SIGNED: /* Damned code for 1 WiMAX attribute */
+ case FR_TYPE_SIGNED: /* Damned code for 1 WiMAX attribute */
len = snprintf(buf, sizeof(buf), "%d", data->datum.sinteger);
a = buf;
break;
- case PW_TYPE_TIMEVAL:
+ case FR_TYPE_TIMEVAL:
len = snprintf(buf, sizeof(buf), "%" PRIu64 ".%06" PRIu64,
(uint64_t)data->datum.timeval.tv_sec, (uint64_t)data->datum.timeval.tv_usec);
a = buf;
break;
- case PW_TYPE_DATE:
+ case FR_TYPE_DATE:
t = data->datum.date;
if (quote > 0) {
len = strftime(buf, sizeof(buf) - 1, "%%%b %e %Y %H:%M:%S %Z%%", localtime_r(&t, &s_tm));
a = buf;
break;
- case PW_TYPE_IPV4_ADDR:
- case PW_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV6_ADDR:
a = fr_inet_ntop(buf, sizeof(buf), &data->datum.ip);
len = strlen(buf);
break;
- case PW_TYPE_IPV4_PREFIX:
- case PW_TYPE_IPV6_PREFIX:
+ case FR_TYPE_IPV4_PREFIX:
+ case FR_TYPE_IPV6_PREFIX:
a = fr_inet_ntop_prefix(buf, sizeof(buf), &data->datum.ip);
len = strlen(buf);
break;
- case PW_TYPE_ABINARY:
+ case FR_TYPE_ABINARY:
#ifdef WITH_ASCEND_BINARY
print_abinary(buf, sizeof(buf), (uint8_t const *) data->datum.filter, data->datum.length, quote);
a = buf;
#else
/* FALL THROUGH */
#endif
- case PW_TYPE_OCTETS:
- case PW_TYPE_TLV:
+ case FR_TYPE_OCTETS:
+ case FR_TYPE_TLV:
{
size_t max;
}
return len;
- case PW_TYPE_IFID:
+ case FR_TYPE_IFID:
a = fr_inet_ifid_ntop(buf, sizeof(buf), data->datum.ifid);
len = strlen(buf);
break;
- case PW_TYPE_ETHERNET:
+ case FR_TYPE_ETHERNET:
return snprintf(out, outlen, "%02x:%02x:%02x:%02x:%02x:%02x",
data->datum.ether[0], data->datum.ether[1],
data->datum.ether[2], data->datum.ether[3],
data->datum.ether[4], data->datum.ether[5]);
- case PW_TYPE_DECIMAL:
+ case FR_TYPE_DECIMAL:
return snprintf(out, outlen, "%g", data->datum.decimal);
/*
* Don't add default here
*/
- case PW_TYPE_INVALID:
- case PW_TYPE_COMBO_IP_ADDR:
- case PW_TYPE_COMBO_IP_PREFIX:
- case PW_TYPE_EXTENDED:
- case PW_TYPE_LONG_EXTENDED:
- case PW_TYPE_EVS:
- case PW_TYPE_VSA:
- case PW_TYPE_VENDOR:
- case PW_TYPE_BOOLEAN:
- case PW_TYPE_STRUCT:
- case PW_TYPE_MAX:
+ case FR_TYPE_INVALID:
+ case FR_TYPE_COMBO_IP_ADDR:
+ case FR_TYPE_COMBO_IP_PREFIX:
+ case FR_TYPE_EXTENDED:
+ case FR_TYPE_LONG_EXTENDED:
+ case FR_TYPE_EVS:
+ case FR_TYPE_VSA:
+ case FR_TYPE_VENDOR:
+ case FR_TYPE_BOOLEAN:
+ case FR_TYPE_STRUCT:
+ case FR_TYPE_MAX:
(void)fr_cond_assert(0);
*out = '\0';
return 0;
#ifdef WITH_TCP
static CONF_PARSER limit_config[] = {
- { FR_CONF_OFFSET("max_connections", PW_TYPE_INTEGER, RADCLIENT, limit.max_connections), .dflt = "16" },
+ { FR_CONF_OFFSET("max_connections", FR_TYPE_INTEGER, RADCLIENT, limit.max_connections), .dflt = "16" },
- { FR_CONF_OFFSET("lifetime", PW_TYPE_INTEGER, RADCLIENT, limit.lifetime), .dflt = "0" },
+ { FR_CONF_OFFSET("lifetime", FR_TYPE_INTEGER, RADCLIENT, limit.lifetime), .dflt = "0" },
- { FR_CONF_OFFSET("idle_timeout", PW_TYPE_INTEGER, RADCLIENT, limit.idle_timeout), .dflt = "30" },
+ { FR_CONF_OFFSET("idle_timeout", FR_TYPE_INTEGER, RADCLIENT, limit.idle_timeout), .dflt = "30" },
CONF_PARSER_TERMINATOR
};
#endif
static const CONF_PARSER client_config[] = {
- { FR_CONF_POINTER("ipaddr", PW_TYPE_COMBO_IP_PREFIX, &cl_ipaddr) },
- { FR_CONF_POINTER("ipv4addr", PW_TYPE_IPV4_PREFIX, &cl_ipaddr) },
- { FR_CONF_POINTER("ipv6addr", PW_TYPE_IPV6_PREFIX, &cl_ipaddr) },
+ { FR_CONF_POINTER("ipaddr", FR_TYPE_COMBO_IP_PREFIX, &cl_ipaddr) },
+ { FR_CONF_POINTER("ipv4addr", FR_TYPE_IPV4_PREFIX, &cl_ipaddr) },
+ { FR_CONF_POINTER("ipv6addr", FR_TYPE_IPV6_PREFIX, &cl_ipaddr) },
- { FR_CONF_POINTER("src_ipaddr", PW_TYPE_STRING, &cl_srcipaddr) },
+ { FR_CONF_POINTER("src_ipaddr", FR_TYPE_STRING, &cl_srcipaddr) },
- { FR_CONF_OFFSET("require_message_authenticator", PW_TYPE_BOOLEAN, RADCLIENT, message_authenticator), .dflt = "no" },
+ { FR_CONF_OFFSET("require_message_authenticator", FR_TYPE_BOOLEAN, RADCLIENT, message_authenticator), .dflt = "no" },
- { FR_CONF_OFFSET("secret", PW_TYPE_STRING | PW_TYPE_SECRET, RADCLIENT, secret) },
- { FR_CONF_OFFSET("shortname", PW_TYPE_STRING, RADCLIENT, shortname) },
+ { FR_CONF_OFFSET("secret", FR_TYPE_STRING | FR_TYPE_SECRET, RADCLIENT, secret) },
+ { FR_CONF_OFFSET("shortname", FR_TYPE_STRING, RADCLIENT, shortname) },
- { FR_CONF_OFFSET("nas_type", PW_TYPE_STRING, RADCLIENT, nas_type) },
+ { FR_CONF_OFFSET("nas_type", FR_TYPE_STRING, RADCLIENT, nas_type) },
- { FR_CONF_OFFSET("login", PW_TYPE_STRING, RADCLIENT, login) },
- { FR_CONF_OFFSET("password", PW_TYPE_STRING, RADCLIENT, password) },
- { FR_CONF_OFFSET("virtual_server", PW_TYPE_STRING, RADCLIENT, server) },
- { FR_CONF_OFFSET("response_window", PW_TYPE_TIMEVAL, RADCLIENT, response_window) },
+ { FR_CONF_OFFSET("login", FR_TYPE_STRING, RADCLIENT, login) },
+ { FR_CONF_OFFSET("password", FR_TYPE_STRING, RADCLIENT, password) },
+ { FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING, RADCLIENT, server) },
+ { FR_CONF_OFFSET("response_window", FR_TYPE_TIMEVAL, RADCLIENT, response_window) },
#ifdef WITH_TCP
- { FR_CONF_POINTER("proto", PW_TYPE_STRING, &hs_proto) },
- { FR_CONF_POINTER("limit", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) limit_config },
+ { FR_CONF_POINTER("proto", FR_TYPE_STRING, &hs_proto) },
+ { FR_CONF_POINTER("limit", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) limit_config },
#endif
#ifdef WITH_DYNAMIC_CLIENTS
- { FR_CONF_OFFSET("dynamic_clients", PW_TYPE_STRING, RADCLIENT, client_server) },
- { FR_CONF_OFFSET("lifetime", PW_TYPE_INTEGER, RADCLIENT, lifetime) },
- { FR_CONF_OFFSET("rate_limit", PW_TYPE_BOOLEAN, RADCLIENT, rate_limit) },
+ { 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) },
#endif
CONF_PARSER_TERMINATOR
};
* We overload this structure a lot.
*/
static const CONF_PARSER dynamic_config[] = {
- { FR_CONF_OFFSET("FreeRADIUS-Client-IP-Address", PW_TYPE_IPV4_ADDR, RADCLIENT, ipaddr) },
- { FR_CONF_OFFSET("FreeRADIUS-Client-IPv6-Address", PW_TYPE_IPV6_ADDR, RADCLIENT, ipaddr) },
- { FR_CONF_OFFSET("FreeRADIUS-Client-IP-Prefix", PW_TYPE_IPV4_PREFIX, RADCLIENT, ipaddr) },
- { FR_CONF_OFFSET("FreeRADIUS-Client-IPv6-Prefix", PW_TYPE_IPV6_PREFIX, RADCLIENT, ipaddr) },
- { FR_CONF_OFFSET("FreeRADIUS-Client-Src-IP-Address", PW_TYPE_IPV4_ADDR, RADCLIENT, src_ipaddr) },
- { FR_CONF_OFFSET("FreeRADIUS-Client-Src-IPv6-Address", PW_TYPE_IPV6_ADDR, RADCLIENT, src_ipaddr) },
-
- { FR_CONF_OFFSET("FreeRADIUS-Client-Require-MA", PW_TYPE_BOOLEAN, RADCLIENT, message_authenticator) },
-
- { FR_CONF_OFFSET("FreeRADIUS-Client-Secret", PW_TYPE_STRING, RADCLIENT, secret), .dflt = "" },
- { FR_CONF_OFFSET("FreeRADIUS-Client-Shortname", PW_TYPE_STRING, RADCLIENT, shortname), .dflt = "" },
- { FR_CONF_OFFSET("FreeRADIUS-Client-NAS-Type", PW_TYPE_STRING, RADCLIENT, nas_type) },
- { FR_CONF_OFFSET("FreeRADIUS-Client-Virtual-Server", PW_TYPE_STRING, RADCLIENT, server) },
+ { FR_CONF_OFFSET("FreeRADIUS-Client-IP-Address", FR_TYPE_IPV4_ADDR, RADCLIENT, ipaddr) },
+ { FR_CONF_OFFSET("FreeRADIUS-Client-IPv6-Address", FR_TYPE_IPV6_ADDR, RADCLIENT, ipaddr) },
+ { FR_CONF_OFFSET("FreeRADIUS-Client-IP-Prefix", FR_TYPE_IPV4_PREFIX, RADCLIENT, ipaddr) },
+ { FR_CONF_OFFSET("FreeRADIUS-Client-IPv6-Prefix", FR_TYPE_IPV6_PREFIX, RADCLIENT, ipaddr) },
+ { 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-Secret", FR_TYPE_STRING, RADCLIENT, secret), .dflt = "" },
+ { FR_CONF_OFFSET("FreeRADIUS-Client-Shortname", FR_TYPE_STRING, RADCLIENT, shortname), .dflt = "" },
+ { FR_CONF_OFFSET("FreeRADIUS-Client-NAS-Type", FR_TYPE_STRING, RADCLIENT, nas_type) },
+ { FR_CONF_OFFSET("FreeRADIUS-Client-Virtual-Server", FR_TYPE_STRING, RADCLIENT, server) },
CONF_PARSER_TERMINATOR
};
strvalue = fr_pair_value_asprint(vp, vp, '\'');
switch (dynamic_config[i].type) {
- case PW_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_ADDR:
if (da->attr == PW_FREERADIUS_CLIENT_IP_ADDRESS) {
memcpy(&c->ipaddr, &vp->vp_ip, sizeof(c->ipaddr));
cp = cf_pair_alloc(c->cs, "ipv4addr", strvalue, T_OP_SET, T_BARE_WORD, T_BARE_WORD);
break;
- case PW_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_ADDR:
if (da->attr == PW_FREERADIUS_CLIENT_IPV6_ADDRESS) {
memcpy(&c->ipaddr, &vp->vp_ip, sizeof(c->ipaddr));
cp = cf_pair_alloc(c->cs, "ipv6addr", strvalue, T_OP_SET, T_BARE_WORD, T_BARE_WORD);
break;
- case PW_TYPE_IPV4_PREFIX:
+ case FR_TYPE_IPV4_PREFIX:
if (da->attr == PW_FREERADIUS_CLIENT_IP_PREFIX) {
memcpy(&c->ipaddr, &vp->vp_ip, sizeof(c->ipaddr));
cp = cf_pair_alloc(c->cs, "ipv4addr", strvalue, T_OP_SET, T_BARE_WORD, T_BARE_WORD);
break;
- case PW_TYPE_IPV6_PREFIX:
+ case FR_TYPE_IPV6_PREFIX:
if (da->attr == PW_FREERADIUS_CLIENT_IPV6_PREFIX) {
memcpy(&c->ipaddr, &vp->vp_ip, sizeof(c->ipaddr));;
cp = cf_pair_alloc(c->cs, "ipv6addr", strvalue, T_OP_SET, T_BARE_WORD, T_BARE_WORD);
break;
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
{
CONF_PARSER const *parse;
}
break;
- case PW_TYPE_BOOLEAN:
+ case FR_TYPE_BOOLEAN:
{
CONF_PARSER const *parse;
goto error;
}
- if (vp->vp_type == PW_TYPE_STRING) {
+ if (vp->vp_type == FR_TYPE_STRING) {
RDEBUG2("%s = '%s'", vp->da->name, value);
cp = cf_pair_alloc(c->cs, vp->da->name, value, T_OP_SET,
T_BARE_WORD, T_SINGLE_QUOTED_STRING);
} fr_command_socket_t;
static const CONF_PARSER command_config[] = {
- { FR_CONF_OFFSET("socket", PW_TYPE_STRING, fr_command_socket_t, path), .dflt = "${run_dir}/radiusd.sock" },
- { FR_CONF_DEPRECATED("uid", PW_TYPE_STRING, fr_command_socket_t, NULL) },
- { FR_CONF_OFFSET("gid", PW_TYPE_STRING, fr_command_socket_t, gid_name) },
- { FR_CONF_OFFSET("mode", PW_TYPE_STRING, fr_command_socket_t, mode_name) },
- { FR_CONF_OFFSET("peercred", PW_TYPE_BOOLEAN, fr_command_socket_t, peercred), .dflt = "yes" },
- { FR_CONF_OFFSET("blocking", PW_TYPE_BOOLEAN, fr_command_socket_t, blocking), },
+ { FR_CONF_OFFSET("socket", FR_TYPE_STRING, fr_command_socket_t, path), .dflt = "${run_dir}/radiusd.sock" },
+ { 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), },
CONF_PARSER_TERMINATOR
};
variables[i].name);
break;
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
cprintf(listener, "%.*s%s = %u\n", indent, tabs,
variables[i].name, *(int const *) data);
break;
- case PW_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_ADDR:
inet_ntop(AF_INET, data, buffer, sizeof(buffer));
break;
- case PW_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_ADDR:
inet_ntop(AF_INET6, data, buffer, sizeof(buffer));
break;
- case PW_TYPE_BOOLEAN:
+ case FR_TYPE_BOOLEAN:
cprintf(listener, "%.*s%s = %s\n", indent, tabs,
variables[i].name,
((*(bool const *) data) == false) ? "no" : "yes");
break;
- case PW_TYPE_STRING:
- case PW_TYPE_FILE_INPUT:
- case PW_TYPE_FILE_OUTPUT:
+ case FR_TYPE_STRING:
+ case FR_TYPE_FILE_INPUT:
+ case FR_TYPE_FILE_OUTPUT:
/*
* FIXME: Escape things in the string!
*/
/*
* FIXME: Recurse into sub-types somehow...
*/
- if (PW_BASE_TYPE(variables[i].type) == PW_TYPE_SUBSECTION) continue;
+ if (PW_BASE_TYPE(variables[i].type) == FR_TYPE_SUBSECTION) continue;
if (strcmp(variables[i].name, argv[1]) == 0) {
rcode = i;
size_t nmatch = sizeof(rxmatch) / sizeof(regmatch_t);
if (!rad_cond_assert(lhs != NULL)) return -1;
- if (!rad_cond_assert(lhs->type == PW_TYPE_STRING)) return -1;
+ if (!rad_cond_assert(lhs->type == FR_TYPE_STRING)) return -1;
EVAL_DEBUG("CMP WITH REGEX %s %s",
map->rhs->tmpl_iflag ? "CASE INSENSITIVE" : "CASE SENSITIVE",
break;
default:
- if (!rad_cond_assert(rhs && rhs->type == PW_TYPE_STRING)) return -1;
+ if (!rad_cond_assert(rhs && rhs->type == FR_TYPE_STRING)) return -1;
if (!rad_cond_assert(rhs && rhs->datum.strvalue)) return -1;
slen = regex_compile(request, &rreg, rhs->datum.strvalue, rhs->datum.length,
map->rhs->tmpl_iflag, map->rhs->tmpl_mflag, true, true);
static void cond_print_operands(value_box_t const *lhs, value_box_t const *rhs)
{
if (lhs) {
- if (lhs->type == PW_TYPE_STRING) {
+ if (lhs->type == FR_TYPE_STRING) {
EVAL_DEBUG("LHS: \"%s\" (%zu)" , lhs->datum.strvalue, lhs->datum.length);
} else {
EVAL_DEBUG("LHS: 0x%pH (%zu)", lhs->datum.octets, lhs->datum.length);
}
if (rhs) {
- if (rhs->type == PW_TYPE_STRING) {
+ if (rhs->type == FR_TYPE_STRING) {
EVAL_DEBUG("RHS: \"%s\" (%zu)", rhs->datum.strvalue, rhs->datum.length);
} else {
EVAL_DEBUG("RHS: 0x%pH (%zu)", rhs->datum.octets, rhs->datum.length);
value_box_t *rhs = NULL;
fr_dict_attr_t const *cast = NULL;
- PW_TYPE cast_type = PW_TYPE_INVALID;
+ fr_type_t cast_type = FR_TYPE_INVALID;
value_box_t lhs_cast, rhs_cast;
void *lhs_cast_buff = NULL, *rhs_cast_buff = NULL;
*/
#define CAST(_s) \
do {\
- if ((cast_type != PW_TYPE_INVALID) && _s && (_s ->type != PW_TYPE_INVALID) && (cast_type != _s->type)) {\
+ if ((cast_type != FR_TYPE_INVALID) && _s && (_s ->type != FR_TYPE_INVALID) && (cast_type != _s->type)) {\
EVAL_DEBUG("CASTING " #_s " FROM %s TO %s",\
fr_int2str(dict_attr_types, _s->type, "<INVALID>"),\
fr_int2str(dict_attr_types, cast_type, "<INVALID>"));\
#define CHECK_INT_CAST(_l, _r) \
do {\
- if ((cast_type == PW_TYPE_INVALID) &&\
- _l && (_l->type == PW_TYPE_STRING) &&\
- _r && (_r->type == PW_TYPE_STRING) &&\
+ if ((cast_type == FR_TYPE_INVALID) &&\
+ _l && (_l->type == FR_TYPE_STRING) &&\
+ _r && (_r->type == FR_TYPE_STRING) &&\
all_digits(lhs->datum.strvalue) && all_digits(rhs->datum.strvalue)) {\
- cast_type = PW_TYPE_INTEGER64;\
+ cast_type = FR_TYPE_INTEGER64;\
EVAL_DEBUG("OPERANDS ARE NUMBER STRINGS, SETTING CAST TO integer64");\
}\
} while (0)
*/
#ifdef HAVE_REGEX
if (map->op == T_OP_REG_EQ) {
- cast_type = PW_TYPE_STRING;
+ cast_type = FR_TYPE_STRING;
if (map->rhs->type == TMPL_TYPE_XLAT_STRUCT) escape = regex_escape;
}
data.datum.strvalue = map->rhs->name;
data.datum.length = map->rhs->len;
}
- data.type = PW_TYPE_STRING;
+ data.type = FR_TYPE_STRING;
rad_assert(data.datum.strvalue);
data.datum.length = map->lhs->len;
}
rad_assert(data.datum.strvalue);
- data.type = PW_TYPE_STRING;
+ data.type = FR_TYPE_STRING;
rcode = cond_normalise_and_cmp(request, c, &data);
if (p) talloc_free(p);
*/
value_box_t data;
char quote = *start;
- PW_TYPE src_type = PW_TYPE_STRING;
+ fr_type_t src_type = FR_TYPE_STRING;
/*
* Regex compilers can handle escapes. So we don't do it.
{
char const *p = start;
char const *q;
- PW_TYPE cast;
+ fr_type_t cast;
while (isspace((int) *p)) p++; /* skip spaces before condition */
q = p;
while (*q && *q != '>') q++;
- cast = fr_substr2int(dict_attr_types, p, PW_TYPE_INVALID, q - p);
- if (cast == PW_TYPE_INVALID) {
+ cast = fr_substr2int(dict_attr_types, p, FR_TYPE_INVALID, q - p);
+ if (cast == FR_TYPE_INVALID) {
*error = "Invalid data type in cast";
return -(p - start);
}
return q - start;
}
-static bool cond_type_check(fr_cond_t *c, PW_TYPE lhs_type)
+static bool cond_type_check(fr_cond_t *c, fr_type_t lhs_type)
{
/*
* SOME integer mismatch is OK. If the LHS has a large type,
* If the LHS has a small type, and the RHS has a large type,
* then add a cast to the LHS.
*/
- if (lhs_type == PW_TYPE_INTEGER64) {
- if ((c->data.map->rhs->tmpl_da->type == PW_TYPE_INTEGER) ||
- (c->data.map->rhs->tmpl_da->type == PW_TYPE_SHORT) ||
- (c->data.map->rhs->tmpl_da->type == PW_TYPE_BYTE)) {
+ 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)) {
c->cast = NULL;
return true;
}
}
- if (lhs_type == PW_TYPE_INTEGER) {
- if ((c->data.map->rhs->tmpl_da->type == PW_TYPE_SHORT) ||
- (c->data.map->rhs->tmpl_da->type == PW_TYPE_BYTE)) {
+ 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)) {
c->cast = NULL;
return true;
}
- if (c->data.map->rhs->tmpl_da->type == PW_TYPE_INTEGER64) {
+ if (c->data.map->rhs->tmpl_da->type == FR_TYPE_INTEGER64) {
c->cast = c->data.map->rhs->tmpl_da;
return true;
}
}
- if (lhs_type == PW_TYPE_SHORT) {
- if (c->data.map->rhs->tmpl_da->type == PW_TYPE_BYTE) {
+ if (lhs_type == FR_TYPE_SHORT) {
+ if (c->data.map->rhs->tmpl_da->type == FR_TYPE_BYTE) {
c->cast = NULL;
return true;
}
- if ((c->data.map->rhs->tmpl_da->type == PW_TYPE_INTEGER64) ||
- (c->data.map->rhs->tmpl_da->type == PW_TYPE_INTEGER)) {
+ if ((c->data.map->rhs->tmpl_da->type == FR_TYPE_INTEGER64) ||
+ (c->data.map->rhs->tmpl_da->type == FR_TYPE_INTEGER)) {
c->cast = c->data.map->rhs->tmpl_da;
return true;
}
}
- if (lhs_type == PW_TYPE_BYTE) {
- if ((c->data.map->rhs->tmpl_da->type == PW_TYPE_INTEGER64) ||
- (c->data.map->rhs->tmpl_da->type == PW_TYPE_INTEGER) ||
- (c->data.map->rhs->tmpl_da->type == PW_TYPE_SHORT)) {
+ 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)) {
c->cast = c->data.map->rhs->tmpl_da;
return true;
}
}
- if ((lhs_type == PW_TYPE_IPV4_PREFIX) &&
- (c->data.map->rhs->tmpl_da->type == PW_TYPE_IPV4_ADDR)) {
+ if ((lhs_type == FR_TYPE_IPV4_PREFIX) &&
+ (c->data.map->rhs->tmpl_da->type == FR_TYPE_IPV4_ADDR)) {
return true;
}
- if ((lhs_type == PW_TYPE_IPV6_PREFIX) &&
- (c->data.map->rhs->tmpl_da->type == PW_TYPE_IPV6_ADDR)) {
+ if ((lhs_type == FR_TYPE_IPV6_PREFIX) &&
+ (c->data.map->rhs->tmpl_da->type == FR_TYPE_IPV6_ADDR)) {
return true;
}
* Same checks as above, but with the types swapped, and
* with explicit cast for the interpretor.
*/
- if ((lhs_type == PW_TYPE_IPV4_ADDR) &&
- (c->data.map->rhs->tmpl_da->type == PW_TYPE_IPV4_PREFIX)) {
+ if ((lhs_type == FR_TYPE_IPV4_ADDR) &&
+ (c->data.map->rhs->tmpl_da->type == FR_TYPE_IPV4_PREFIX)) {
c->cast = c->data.map->rhs->tmpl_da;
return true;
}
- if ((lhs_type == PW_TYPE_IPV6_ADDR) &&
- (c->data.map->rhs->tmpl_da->type == PW_TYPE_IPV6_PREFIX)) {
+ if ((lhs_type == FR_TYPE_IPV6_ADDR) &&
+ (c->data.map->rhs->tmpl_da->type == FR_TYPE_IPV6_PREFIX)) {
c->cast = c->data.map->rhs->tmpl_da;
return true;
}
return_P("Empty octet string is invalid");
}
- c->cast = fr_dict_attr_by_num(NULL, 0, PW_CAST_BASE + PW_TYPE_OCTETS);
+ c->cast = fr_dict_attr_by_num(NULL, 0, PW_CAST_BASE + FR_TYPE_OCTETS);
}
while (isspace((int)*p)) p++; /* skip spaces after LHS */
}
if ((map->lhs->type != TMPL_TYPE_ATTR) ||
- !((map->lhs->tmpl_da->type == PW_TYPE_OCTETS) ||
- (map->lhs->tmpl_da->type == PW_TYPE_BYTE) ||
- (map->lhs->tmpl_da->type == PW_TYPE_SHORT) ||
- (map->lhs->tmpl_da->type == PW_TYPE_INTEGER) ||
- (map->lhs->tmpl_da->type == PW_TYPE_INTEGER64))) {
- c->cast = fr_dict_attr_by_num(NULL, 0, PW_CAST_BASE + PW_TYPE_OCTETS);
+ !((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))) {
+ c->cast = fr_dict_attr_by_num(NULL, 0, PW_CAST_BASE + FR_TYPE_OCTETS);
}
}
* Run-time parsing of strings.
* Run-time copying of octets.
*/
- if ((c->data.map->lhs->tmpl_da->type == PW_TYPE_STRING) ||
- (c->data.map->lhs->tmpl_da->type == PW_TYPE_OCTETS)) {
+ if ((c->data.map->lhs->tmpl_da->type == FR_TYPE_STRING) ||
+ (c->data.map->lhs->tmpl_da->type == FR_TYPE_OCTETS)) {
goto cast_ok;
}
/*
* ifid to integer64 is OK
*/
- if ((c->data.map->lhs->tmpl_da->type == PW_TYPE_IFID) &&
- (c->cast->type == PW_TYPE_INTEGER64)) {
+ if ((c->data.map->lhs->tmpl_da->type == FR_TYPE_IFID) &&
+ (c->cast->type == FR_TYPE_INTEGER64)) {
goto cast_ok;
}
/*
* ipaddr to ipv4prefix is OK
*/
- if ((c->data.map->lhs->tmpl_da->type == PW_TYPE_IPV4_ADDR) &&
- (c->cast->type == PW_TYPE_IPV4_PREFIX)) {
+ if ((c->data.map->lhs->tmpl_da->type == FR_TYPE_IPV4_ADDR) &&
+ (c->cast->type == FR_TYPE_IPV4_PREFIX)) {
goto cast_ok;
}
/*
* ipv6addr to ipv6prefix is OK
*/
- if ((c->data.map->lhs->tmpl_da->type == PW_TYPE_IPV6_ADDR) &&
- (c->cast->type == PW_TYPE_IPV6_PREFIX)) {
+ if ((c->data.map->lhs->tmpl_da->type == FR_TYPE_IPV6_ADDR) &&
+ (c->cast->type == FR_TYPE_IPV6_PREFIX)) {
goto cast_ok;
}
/*
* integer64 to ethernet is OK.
*/
- if ((c->data.map->lhs->tmpl_da->type == PW_TYPE_INTEGER64) &&
- (c->cast->type == PW_TYPE_ETHERNET)) {
+ if ((c->data.map->lhs->tmpl_da->type == FR_TYPE_INTEGER64) &&
+ (c->cast->type == FR_TYPE_ETHERNET)) {
goto cast_ok;
}
*/
if ((c->data.map->lhs->type == TMPL_TYPE_ATTR) &&
(c->data.map->rhs->type != TMPL_TYPE_ATTR) &&
- (c->data.map->lhs->tmpl_da->type == PW_TYPE_STRING) &&
+ (c->data.map->lhs->tmpl_da->type == FR_TYPE_STRING) &&
(c->data.map->op != T_OP_CMP_TRUE) &&
(c->data.map->op != T_OP_CMP_FALSE) &&
(map->rhs->quote == T_BARE_WORD)) {
*/
if ((c->data.map->lhs->type == TMPL_TYPE_ATTR) &&
(c->data.map->rhs->type != TMPL_TYPE_ATTR) &&
- (c->data.map->lhs->tmpl_da->type != PW_TYPE_STRING) &&
- (c->data.map->lhs->tmpl_da->type != PW_TYPE_OCTETS) &&
- (c->data.map->lhs->tmpl_da->type != PW_TYPE_DATE) &&
+ (c->data.map->lhs->tmpl_da->type != FR_TYPE_STRING) &&
+ (c->data.map->lhs->tmpl_da->type != FR_TYPE_OCTETS) &&
+ (c->data.map->lhs->tmpl_da->type != FR_TYPE_DATE) &&
(rhs_type == T_SINGLE_QUOTED_STRING)) {
*error = "Comparison value must be an unquoted string";
return_rhs:
if ((c->data.map->lhs->type == TMPL_TYPE_ATTR) &&
((c->data.map->rhs->type == TMPL_TYPE_UNPARSED) ||
(c->data.map->rhs->type == TMPL_TYPE_DATA))) {
- PW_TYPE type = c->data.map->lhs->tmpl_da->type;
+ fr_type_t type = c->data.map->lhs->tmpl_da->type;
switch (c->data.map->lhs->tmpl_da->type) {
- case PW_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_ADDR:
if (strchr(c->data.map->rhs->name, '/') != NULL) {
- type = PW_TYPE_IPV4_PREFIX;
+ type = FR_TYPE_IPV4_PREFIX;
c->cast = fr_dict_attr_by_num(NULL, 0, PW_CAST_BASE + type);
}
break;
- case PW_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_ADDR:
if (strchr(c->data.map->rhs->name, '/') != NULL) {
- type = PW_TYPE_IPV6_PREFIX;
+ type = FR_TYPE_IPV6_PREFIX;
c->cast = fr_dict_attr_by_num(NULL, 0, PW_CAST_BASE + type);
}
break;
* Cast the LHS to the
* type of the RHS.
*/
- if (c->data.map->lhs->tmpl_da->type == PW_TYPE_COMBO_IP_ADDR) {
+ if (c->data.map->lhs->tmpl_da->type == FR_TYPE_COMBO_IP_ADDR) {
fr_dict_attr_t const *da;
da = fr_dict_attr_by_type(c->data.map->lhs->tmpl_da,
((c->data.map->rhs->type == TMPL_TYPE_XLAT) ||
(c->data.map->rhs->type == TMPL_TYPE_XLAT_STRUCT) ||
(c->data.map->rhs->type == TMPL_TYPE_EXEC))) {
- if (c->data.map->lhs->tmpl_da->type == PW_TYPE_IPV4_ADDR) {
+ if (c->data.map->lhs->tmpl_da->type == FR_TYPE_IPV4_ADDR) {
c->cast = fr_dict_attr_by_num(NULL, 0,
- PW_CAST_BASE + PW_TYPE_IPV4_PREFIX);
+ PW_CAST_BASE + FR_TYPE_IPV4_PREFIX);
}
- if (c->data.map->lhs->tmpl_da->type == PW_TYPE_IPV6_ADDR) {
+ if (c->data.map->lhs->tmpl_da->type == FR_TYPE_IPV6_ADDR) {
c->cast = fr_dict_attr_by_num(NULL, 0,
- PW_CAST_BASE + PW_TYPE_IPV6_PREFIX);
+ PW_CAST_BASE + FR_TYPE_IPV6_PREFIX);
}
}
/** Set the euid/egid used when performing file checks
*
* Sets the euid, and egid used when cf_file_check is called to check
- * permissions on conf items of type #PW_TYPE_FILE_INPUT.
+ * permissions on conf items of type #FR_TYPE_FILE_INPUT.
*
* @note This is probably only useful for the freeradius daemon itself.
*
/** Validation function for ipaddr conf_file types
*
*/
-static inline int fr_item_validate_ipaddr(CONF_SECTION *cs, char const *name, PW_TYPE type, char const *value,
+static inline int fr_item_validate_ipaddr(CONF_SECTION *cs, char const *name, fr_type_t type, char const *value,
fr_ipaddr_t *ipaddr)
{
char ipbuf[128];
}
switch (type) {
- case PW_TYPE_IPV4_ADDR:
- case PW_TYPE_IPV6_ADDR:
- case PW_TYPE_COMBO_IP_ADDR:
+ case FR_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV6_ADDR:
+ case FR_TYPE_COMBO_IP_ADDR:
switch (ipaddr->af) {
case AF_INET:
if (ipaddr->prefix != 32) {
char const *name = variables[i].name;
int type = variables[i].type;
- is_tmpl = (type & PW_TYPE_TMPL);
- is_xlat = (type & PW_TYPE_XLAT);
- attribute = (type & PW_TYPE_ATTRIBUTE);
- multi = (type & PW_TYPE_MULTI);
+ is_tmpl = (type & FR_TYPE_TMPL);
+ is_xlat = (type & FR_TYPE_XLAT);
+ attribute = (type & FR_TYPE_ATTRIBUTE);
+ multi = (type & FR_TYPE_MULTI);
type = PW_BASE_TYPE(type); /* normal types are small */
/*
* It's a section, recurse!
*/
- if (type == PW_TYPE_SUBSECTION) {
+ if (type == FR_TYPE_SUBSECTION) {
uint8_t *subcs_base;
CONF_SECTION *subcs = cf_subsection_find(cs, name);
*/
if (!base) {
subcs_base = NULL;
- } else if (type & PW_TYPE_MULTI) {
+ } else if (type & FR_TYPE_MULTI) {
size_t j, len;
uint8_t **array;
* Ignore %{... in shared secrets.
* They're never dynamically expanded.
*/
- if ((variables[i].type & PW_TYPE_SECRET) != 0) continue;
+ if ((variables[i].type & FR_TYPE_SECRET) != 0) continue;
if (strstr(cp->value, "%{") != NULL) {
cf_log_err(&cp->item, "Found dynamic expansion in string which "
/*
* Parse (and throw away) the xlat string (for validation).
*
- * FIXME: All of these should be converted from PW_TYPE_XLAT
- * to PW_TYPE_TMPL.
+ * FIXME: All of these should be converted from FR_TYPE_XLAT
+ * to FR_TYPE_TMPL.
*/
if (is_xlat) {
char const *error;
if (!cs) return -1;
- attribute = (type & PW_TYPE_ATTRIBUTE);
- required = (type & PW_TYPE_REQUIRED);
- secret = (type & PW_TYPE_SECRET);
- file_input = (type == PW_TYPE_FILE_INPUT); /* check, not and */
- file_exists = (type == PW_TYPE_FILE_EXISTS); /* check, not and */
- cant_be_empty = (type & PW_TYPE_NOT_EMPTY);
- tmpl = (type & PW_TYPE_TMPL);
+ attribute = (type & FR_TYPE_ATTRIBUTE);
+ required = (type & FR_TYPE_REQUIRED);
+ secret = (type & FR_TYPE_SECRET);
+ file_input = (type == FR_TYPE_FILE_INPUT); /* check, not and */
+ file_exists = (type == FR_TYPE_FILE_EXISTS); /* check, not and */
+ cant_be_empty = (type & FR_TYPE_NOT_EMPTY);
+ tmpl = (type & FR_TYPE_TMPL);
rad_assert(cp);
- rad_assert(!(type & PW_TYPE_ATTRIBUTE) || tmpl); /* Attribute flag only valid for templates */
+ rad_assert(!(type & FR_TYPE_ATTRIBUTE) || tmpl); /* Attribute flag only valid for templates */
if (required) cant_be_empty = true; /* May want to review this in the future... */
}
switch (type) {
- case PW_TYPE_BOOLEAN:
+ case FR_TYPE_BOOLEAN:
/*
* 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 PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
{
unsigned long v = strtoul(cp->value, 0, 0);
}
break;
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
{
unsigned long v = strtoul(cp->value, 0, 0);
}
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
{
unsigned long v = strtoul(cp->value, 0, 0);
}
break;
- case PW_TYPE_INTEGER64:
+ case FR_TYPE_INTEGER64:
*(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;
- case PW_TYPE_SIZE:
+ case FR_TYPE_SIZE:
{
if (fr_size_from_str((size_t *)out, cp->value) < 0) {
cf_log_err(&(cs->item), "Invalid value \"%s\" for variable %s: %s", cp->value,
break;
}
- case PW_TYPE_SIGNED:
+ case FR_TYPE_SIGNED:
*(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;
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
{
char **str = out;
}
break;
- case PW_TYPE_IPV4_ADDR:
- case PW_TYPE_IPV4_PREFIX:
+ case FR_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_PREFIX:
ipaddr = out;
if (fr_inet_pton4(ipaddr, cp->value, -1, true, false, true) < 0) {
}
break;
- case PW_TYPE_IPV6_ADDR:
- case PW_TYPE_IPV6_PREFIX:
+ case FR_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_PREFIX:
ipaddr = out;
if (fr_inet_pton6(ipaddr, cp->value, -1, true, false, true) < 0) {
}
break;
- case PW_TYPE_COMBO_IP_ADDR:
- case PW_TYPE_COMBO_IP_PREFIX:
+ case FR_TYPE_COMBO_IP_ADDR:
+ case FR_TYPE_COMBO_IP_PREFIX:
ipaddr = out;
if (fr_inet_pton(ipaddr, cp->value, -1, AF_UNSPEC, true, true) < 0) {
}
break;
- case PW_TYPE_TIMEVAL:
+ case FR_TYPE_TIMEVAL:
{
struct timeval tv;
* It's not an error parsing the configuration
* file.
*/
- rad_assert(type > PW_TYPE_INVALID);
- rad_assert(type < PW_TYPE_MAX);
+ rad_assert(type > FR_TYPE_INVALID);
+ rad_assert(type < FR_TYPE_MAX);
cf_log_err(&(cp->item), "type '%s' (%i) is not supported in the configuration files",
fr_int2str(dict_attr_types, type, "?Unknown?"), type);
*/
if (dflt_quote == T_INVALID) {
switch (type) {
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
dflt_quote = T_DOUBLE_QUOTED_STRING;
break;
- case PW_TYPE_FILE_INPUT:
- case PW_TYPE_FILE_OUTPUT:
+ case FR_TYPE_FILE_INPUT:
+ case FR_TYPE_FILE_OUTPUT:
dflt_quote = T_DOUBLE_QUOTED_STRING;
break;
* @note The dflt value will only be used if no matching #CONF_PAIR is found. Empty strings will not
* result in the dflt value being used.
*
- * **PW_TYPE to data type mappings**
- * | PW_TYPE | Data type | Dynamically allocated |
+ * **fr_type_t to data type mappings**
+ * | fr_type_t | Data type | Dynamically allocated |
* | ----------------------- | ------------------ | ---------------------- |
- * | PW_TYPE_TMPL | ``vp_tmpl_t`` | Yes |
- * | PW_TYPE_BOOLEAN | ``bool`` | No |
- * | PW_TYPE_INTEGER | ``uint32_t`` | No |
- * | PW_TYPE_SHORT | ``uint16_t`` | No |
- * | PW_TYPE_INTEGER64 | ``uint64_t`` | No |
- * | PW_TYPE_SIGNED | ``int32_t`` | No |
- * | PW_TYPE_STRING | ``char const *`` | Yes |
- * | PW_TYPE_IPV4_ADDR | ``fr_ipaddr_t`` | No |
- * | PW_TYPE_IPV4_PREFIX | ``fr_ipaddr_t`` | No |
- * | PW_TYPE_IPV6_ADDR | ``fr_ipaddr_t`` | No |
- * | PW_TYPE_IPV6_PREFIX | ``fr_ipaddr_t`` | No |
- * | PW_TYPE_COMBO_IP_ADDR | ``fr_ipaddr_t`` | No |
- * | PW_TYPE_COMBO_IP_PREFIX | ``fr_ipaddr_t`` | No |
- * | PW_TYPE_TIMEVAL | ``struct timeval`` | No |
+ * | 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_STRING | ``char const *`` | Yes |
+ * | FR_TYPE_IPV4_ADDR | ``fr_ipaddr_t`` | No |
+ * | FR_TYPE_IPV4_PREFIX | ``fr_ipaddr_t`` | No |
+ * | FR_TYPE_IPV6_ADDR | ``fr_ipaddr_t`` | No |
+ * | FR_TYPE_IPV6_PREFIX | ``fr_ipaddr_t`` | No |
+ * | FR_TYPE_COMBO_IP_ADDR | ``fr_ipaddr_t`` | No |
+ * | FR_TYPE_COMBO_IP_PREFIX | ``fr_ipaddr_t`` | No |
+ * | FR_TYPE_TIMEVAL | ``struct timeval`` | No |
*
* @param[in] ctx To allocate arrays and values in.
* @param[in] cs to search for matching #CONF_PAIR in.
* @param[in] type Data type to parse #CONF_PAIR value as.
* Should be one of the following ``data`` types,
* and one or more of the following ``flag`` types or'd together:
- * - ``data`` #PW_TYPE_TMPL - @copybrief PW_TYPE_TMPL
+ * - ``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`` #PW_TYPE_BOOLEAN - @copybrief PW_TYPE_BOOLEAN
- * - ``data`` #PW_TYPE_INTEGER - @copybrief PW_TYPE_INTEGER
- * - ``data`` #PW_TYPE_SHORT - @copybrief PW_TYPE_SHORT
- * - ``data`` #PW_TYPE_INTEGER64 - @copybrief PW_TYPE_INTEGER64
- * - ``data`` #PW_TYPE_SIGNED - @copybrief PW_TYPE_SIGNED
- * - ``data`` #PW_TYPE_STRING - @copybrief PW_TYPE_STRING
- * - ``data`` #PW_TYPE_IPV4_ADDR - @copybrief PW_TYPE_IPV4_ADDR (IPv4 address with prefix 32).
- * - ``data`` #PW_TYPE_IPV4_PREFIX - @copybrief PW_TYPE_IPV4_PREFIX (IPv4 address with variable prefix).
- * - ``data`` #PW_TYPE_IPV6_ADDR - @copybrief PW_TYPE_IPV6_ADDR (IPv6 address with prefix 128).
- * - ``data`` #PW_TYPE_IPV6_PREFIX - @copybrief PW_TYPE_IPV6_PREFIX (IPv6 address with variable prefix).
- * - ``data`` #PW_TYPE_COMBO_IP_ADDR - @copybrief PW_TYPE_COMBO_IP_ADDR (IPv4/IPv6 address with
+ * - ``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_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).
+ * - ``data`` #FR_TYPE_IPV6_ADDR - @copybrief FR_TYPE_IPV6_ADDR (IPv6 address with prefix 128).
+ * - ``data`` #FR_TYPE_IPV6_PREFIX - @copybrief FR_TYPE_IPV6_PREFIX (IPv6 address with variable prefix).
+ * - ``data`` #FR_TYPE_COMBO_IP_ADDR - @copybrief FR_TYPE_COMBO_IP_ADDR (IPv4/IPv6 address with
* prefix 32/128).
- * - ``data`` #PW_TYPE_COMBO_IP_PREFIX - @copybrief PW_TYPE_COMBO_IP_PREFIX (IPv4/IPv6 address with
+ * - ``data`` #FR_TYPE_COMBO_IP_PREFIX - @copybrief FR_TYPE_COMBO_IP_PREFIX (IPv4/IPv6 address with
* variable prefix).
- * - ``data`` #PW_TYPE_TIMEVAL - @copybrief PW_TYPE_TIMEVAL
- * - ``flag`` #PW_TYPE_DEPRECATED - @copybrief PW_TYPE_DEPRECATED
- * - ``flag`` #PW_TYPE_REQUIRED - @copybrief PW_TYPE_REQUIRED
- * - ``flag`` #PW_TYPE_ATTRIBUTE - @copybrief PW_TYPE_ATTRIBUTE
- * - ``flag`` #PW_TYPE_SECRET - @copybrief PW_TYPE_SECRET
- * - ``flag`` #PW_TYPE_FILE_INPUT - @copybrief PW_TYPE_FILE_INPUT
- * - ``flag`` #PW_TYPE_NOT_EMPTY - @copybrief PW_TYPE_NOT_EMPTY
- * - ``flag`` #PW_TYPE_MULTI - @copybrief PW_TYPE_MULTI
- * - ``flag`` #PW_TYPE_IS_SET - @copybrief PW_TYPE_IS_SET
+ * - ``data`` #FR_TYPE_TIMEVAL - @copybrief FR_TYPE_TIMEVAL
+ * - ``flag`` #FR_TYPE_DEPRECATED - @copybrief FR_TYPE_DEPRECATED
+ * - ``flag`` #FR_TYPE_REQUIRED - @copybrief FR_TYPE_REQUIRED
+ * - ``flag`` #FR_TYPE_ATTRIBUTE - @copybrief FR_TYPE_ATTRIBUTE
+ * - ``flag`` #FR_TYPE_SECRET - @copybrief FR_TYPE_SECRET
+ * - ``flag`` #FR_TYPE_FILE_INPUT - @copybrief FR_TYPE_FILE_INPUT
+ * - ``flag`` #FR_TYPE_NOT_EMPTY - @copybrief FR_TYPE_NOT_EMPTY
+ * - ``flag`` #FR_TYPE_MULTI - @copybrief FR_TYPE_MULTI
+ * - ``flag`` #FR_TYPE_IS_SET - @copybrief FR_TYPE_IS_SET
* @param[out] out Pointer to a global variable, or pointer to a field in the struct being populated with values.
* @param[in] dflt value to use, if no #CONF_PAIR is found.
* @param[in] dflt_quote around the dflt value.
size_t count = 0;
CONF_PAIR *cp, *dflt_cp = NULL;
- rad_assert(!(type & PW_TYPE_TMPL) || !dflt || (dflt_quote != T_INVALID)); /* We ALWAYS need a quoting type for templates */
+ rad_assert(!(type & FR_TYPE_TMPL) || !dflt || (dflt_quote != T_INVALID)); /* We ALWAYS need a quoting type for templates */
- multi = (type & PW_TYPE_MULTI);
- required = (type & PW_TYPE_REQUIRED);
- deprecated = (type & PW_TYPE_DEPRECATED);
+ multi = (type & FR_TYPE_MULTI);
+ required = (type & FR_TYPE_REQUIRED);
+ deprecated = (type & FR_TYPE_DEPRECATED);
/*
* If the item is multi-valued we allocate an array
/*
* Tmpl is outside normal range
*/
- if (type & PW_TYPE_TMPL) {
+ if (type & FR_TYPE_TMPL) {
array = (void **)talloc_zero_array(ctx, vp_tmpl_t *, count);
/*
* Allocate an array of values.
* talloc_array_length().
*/
} else switch (PW_BASE_TYPE(type)) {
- case PW_TYPE_BOOLEAN:
+ case FR_TYPE_BOOLEAN:
array = (void **)talloc_zero_array(ctx, bool, count);
break;
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
array = (void **)talloc_zero_array(ctx, uint32_t, count);
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
array = (void **)talloc_zero_array(ctx, uint16_t, count);
break;
- case PW_TYPE_INTEGER64:
+ case FR_TYPE_INTEGER64:
array = (void **)talloc_zero_array(ctx, uint64_t, count);
break;
- case PW_TYPE_SIGNED:
+ case FR_TYPE_SIGNED:
array = (void **)talloc_zero_array(ctx, int32_t, count);
break;
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
array = (void **)talloc_zero_array(ctx, char *, count);
break;
- case PW_TYPE_IPV4_ADDR:
- case PW_TYPE_IPV4_PREFIX:
- case PW_TYPE_IPV6_ADDR:
- case PW_TYPE_IPV6_PREFIX:
- case PW_TYPE_COMBO_IP_ADDR:
- case PW_TYPE_COMBO_IP_PREFIX:
+ case FR_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_PREFIX:
+ case FR_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_PREFIX:
+ case FR_TYPE_COMBO_IP_ADDR:
+ case FR_TYPE_COMBO_IP_PREFIX:
array = (void **)talloc_zero_array(ctx, fr_ipaddr_t, count);
break;
- case PW_TYPE_TIMEVAL:
+ case FR_TYPE_TIMEVAL:
array = (void **)talloc_zero_array(ctx, struct timeval, count);
break;
int i;
for (i = 0; variables[i].name != NULL; i++) {
- if ((PW_BASE_TYPE(variables[i].type) == PW_TYPE_SUBSECTION)) {
+ if ((PW_BASE_TYPE(variables[i].type) == FR_TYPE_SUBSECTION)) {
CONF_SECTION *subcs;
if (!variables[i].dflt) continue;
subcs = cf_subsection_find(cs, variables[i].name);
- if (!subcs && (variables[i].type & PW_TYPE_REQUIRED)) {
+ if (!subcs && (variables[i].type & FR_TYPE_REQUIRED)) {
cf_log_err_cs(cs, "Missing %s {} subsection", variables[i].name);
return -1;
}
/*
* Set the is_set field for the subsection.
*/
- if (variables[i].type & PW_TYPE_IS_SET) {
+ if (variables[i].type & FR_TYPE_IS_SET) {
bool *is_set;
is_set = variables[i].data ? variables[i].is_set_ptr :
continue;
}
- if ((PW_BASE_TYPE(variables[i].type) != PW_TYPE_STRING) &&
- (variables[i].type != PW_TYPE_FILE_INPUT) &&
- (variables[i].type != PW_TYPE_FILE_OUTPUT)) {
+ if ((PW_BASE_TYPE(variables[i].type) != FR_TYPE_STRING) &&
+ (variables[i].type != FR_TYPE_FILE_INPUT) &&
+ (variables[i].type != FR_TYPE_FILE_OUTPUT)) {
continue;
}
* - -2 if a deprecated #CONF_ITEM was found.
*/
static int cf_subsection_parse(TALLOC_CTX *ctx, void *out, CONF_SECTION *cs,
- char const *name, PW_TYPE type, CONF_PARSER const *subcs_vars, size_t subcs_size)
+ char const *name, fr_type_t type, CONF_PARSER const *subcs_vars, size_t subcs_size)
{
CONF_SECTION *subcs;
int count, i, ret;
uint8_t **array;
- rad_assert(type & PW_TYPE_SUBSECTION);
+ rad_assert(type & FR_TYPE_SUBSECTION);
subcs = cf_subsection_find(cs, name);
rad_assert(subcs); /* should have been pre-allocated earlier */
/*
* Handle the single subsection case (which is simple)
*/
- if (!(type & PW_TYPE_MULTI)) {
+ if (!(type & FR_TYPE_MULTI)) {
uint8_t *buff;
/*
/*
* Handle subsections specially
*/
- if (PW_BASE_TYPE(variables[i].type) == PW_TYPE_SUBSECTION) {
+ if (PW_BASE_TYPE(variables[i].type) == FR_TYPE_SUBSECTION) {
if (cf_subsection_parse(ctx, (uint8_t *)base + variables[i].offset, cs,
variables[i].name, variables[i].type,
variables[i].subcs, variables[i].subcs_size) < 0) goto finish;
* Get pointer to where we need to write out
* whether the pointer was set.
*/
- if (variables[i].type & PW_TYPE_IS_SET) {
+ if (variables[i].type & FR_TYPE_IS_SET) {
is_set = variables[i].data ? variables[i].is_set_ptr :
((uint8_t *)base) + variables[i].is_set_offset;
}
};
static const CONF_PARSER connection_config[] = {
- { FR_CONF_OFFSET("start", PW_TYPE_INTEGER, fr_connection_pool_t, start), .dflt = "5" },
- { FR_CONF_OFFSET("min", PW_TYPE_INTEGER, fr_connection_pool_t, min), .dflt = "5" },
- { FR_CONF_OFFSET("max", PW_TYPE_INTEGER, fr_connection_pool_t, max), .dflt = "10" },
- { FR_CONF_OFFSET("max_pending", PW_TYPE_INTEGER, fr_connection_pool_t, max_pending), .dflt = "0" },
- { FR_CONF_OFFSET("spare", PW_TYPE_INTEGER, fr_connection_pool_t, spare), .dflt = "3" },
- { FR_CONF_OFFSET("uses", PW_TYPE_INTEGER64, fr_connection_pool_t, max_uses), .dflt = "0" },
- { FR_CONF_OFFSET("lifetime", PW_TYPE_INTEGER, fr_connection_pool_t, lifetime), .dflt = "0" },
- { FR_CONF_OFFSET("cleanup_delay", PW_TYPE_INTEGER, fr_connection_pool_t, cleanup_interval) },
- { FR_CONF_OFFSET("cleanup_interval", PW_TYPE_INTEGER, fr_connection_pool_t, cleanup_interval), .dflt = "30" },
- { FR_CONF_OFFSET("idle_timeout", PW_TYPE_INTEGER, fr_connection_pool_t, idle_timeout), .dflt = "60" },
- { FR_CONF_OFFSET("connect_timeout", PW_TYPE_TIMEVAL, fr_connection_pool_t, connect_timeout), .dflt = "3.0" },
- { FR_CONF_OFFSET("held_trigger_min", PW_TYPE_TIMEVAL, fr_connection_pool_t, held_trigger_min), .dflt = "0.0" },
- { FR_CONF_OFFSET("held_trigger_max", PW_TYPE_TIMEVAL, fr_connection_pool_t, held_trigger_max), .dflt = "0.5" },
- { FR_CONF_OFFSET("retry_delay", PW_TYPE_INTEGER, fr_connection_pool_t, retry_delay), .dflt = "1" },
- { FR_CONF_OFFSET("spread", PW_TYPE_BOOLEAN, fr_connection_pool_t, spread), .dflt = "no" },
+ { 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("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" },
CONF_PARSER_TERMINATOR
};
value_box_t boxed_answer = {
.datum.strvalue = answer,
.datum.length = len,
- .type = PW_TYPE_STRING
+ .type = FR_TYPE_STRING
};
status = WEXITSTATUS(status);
vp = fr_pair_cursor_next(&cursor)) {
if (((vp->op == T_OP_REG_EQ) ||
(vp->op == T_OP_REG_NE)) &&
- (vp->vp_type != PW_TYPE_STRING)) {
+ (vp->vp_type != FR_TYPE_STRING)) {
pairlist_free(&pl);
talloc_free(check_tmp);
ERROR("%s[%d]: Cannot use regular expressions for non-string attributes in entry %s",
}
}
static CONF_PARSER performance_config[] = {
- { FR_CONF_OFFSET("skip_duplicate_checks", PW_TYPE_BOOLEAN, rad_listen_t, nodup) },
+ { FR_CONF_OFFSET("skip_duplicate_checks", FR_TYPE_BOOLEAN, rad_listen_t, nodup) },
CONF_PARSER_TERMINATOR
};
static CONF_PARSER limit_config[] = {
- { FR_CONF_OFFSET("max_pps", PW_TYPE_INTEGER, listen_socket_t, max_rate) },
+ { FR_CONF_OFFSET("max_pps", FR_TYPE_INTEGER, listen_socket_t, max_rate) },
#ifdef WITH_TCP
- { FR_CONF_OFFSET("max_connections", PW_TYPE_INTEGER, listen_socket_t, limit.max_connections), .dflt = "16" },
- { FR_CONF_OFFSET("lifetime", PW_TYPE_INTEGER, listen_socket_t, limit.lifetime), .dflt = "0" },
- { FR_CONF_OFFSET("idle_timeout", PW_TYPE_INTEGER, listen_socket_t, limit.idle_timeout), .dflt = STRINGIFY(30) },
+ { 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) },
#endif
CONF_PARSER_TERMINATOR
};
memset(&ipaddr, 0, sizeof(ipaddr));
ipaddr.addr.v4.s_addr = htonl(INADDR_NONE);
- rcode = cf_pair_parse(NULL, cs, "ipaddr", FR_ITEM_POINTER(PW_TYPE_COMBO_IP_ADDR, &ipaddr), NULL, T_INVALID);
+ rcode = cf_pair_parse(NULL, cs, "ipaddr", FR_ITEM_POINTER(FR_TYPE_COMBO_IP_ADDR, &ipaddr), NULL, T_INVALID);
if (rcode < 0) return -1;
if (rcode != 0) rcode = cf_pair_parse(NULL, cs, "ipv4addr",
- FR_ITEM_POINTER(PW_TYPE_IPV4_ADDR, &ipaddr), NULL, T_INVALID);
+ FR_ITEM_POINTER(FR_TYPE_IPV4_ADDR, &ipaddr), NULL, T_INVALID);
if (rcode < 0) return -1;
if (rcode != 0) rcode = cf_pair_parse(NULL, cs, "ipv6addr",
- FR_ITEM_POINTER(PW_TYPE_IPV6_ADDR, &ipaddr), NULL, T_INVALID);
+ FR_ITEM_POINTER(FR_TYPE_IPV6_ADDR, &ipaddr), NULL, T_INVALID);
if (rcode < 0) return -1;
/*
* Default to all IPv6 interfaces (it's the future)
ipaddr.addr.v6 = in6addr_any; /* in6addr_any binds to all addresses */
}
- rcode = cf_pair_parse(NULL, cs, "port", FR_ITEM_POINTER(PW_TYPE_SHORT, &sock->my_port), "0", T_BARE_WORD);
+ rcode = cf_pair_parse(NULL, cs, "port", FR_ITEM_POINTER(FR_TYPE_SHORT, &sock->my_port), "0", T_BARE_WORD);
if (rcode < 0) return -1;
- rcode = cf_pair_parse(NULL, cs, "recv_buff", FR_ITEM_POINTER(PW_TYPE_INTEGER, &recv_buff), "0", T_BARE_WORD);
+ rcode = cf_pair_parse(NULL, cs, "recv_buff", FR_ITEM_POINTER(FR_TYPE_INTEGER, &recv_buff), "0", T_BARE_WORD);
if (rcode < 0) return -1;
if (recv_buff) {
FR_INTEGER_BOUND_CHECK("recv_buff", recv_buff, >=, 32);
CONF_SECTION *tls;
# endif
- rcode = cf_pair_parse(NULL, cs, "proto", FR_ITEM_POINTER(PW_TYPE_STRING, &proto),
+ rcode = cf_pair_parse(NULL, cs, "proto", FR_ITEM_POINTER(FR_TYPE_STRING, &proto),
"udp", T_DOUBLE_QUOTED_STRING);
if (rcode < 0) return -1;
*/
clients_cs = NULL;
parent_cs = cf_top_section(cs);
- rcode = cf_pair_parse(NULL, cs, "clients", FR_ITEM_POINTER(PW_TYPE_STRING, §ion_name), NULL, T_INVALID);
+ rcode = cf_pair_parse(NULL, cs, "clients", FR_ITEM_POINTER(FR_TYPE_STRING, §ion_name), NULL, T_INVALID);
if (rcode < 0) return -1; /* bad string */
if (rcode == 0) {
/*
this->fd = -1;
this->cs = cs;
- rcode = cf_pair_parse(this, cs, "type", FR_ITEM_POINTER(PW_TYPE_STRING, &listen_type),
+ rcode = cf_pair_parse(this, cs, "type", FR_ITEM_POINTER(FR_TYPE_STRING, &listen_type),
"", T_DOUBLE_QUOTED_STRING);
if (rcode < 0) {
talloc_free(this);
* Log destinations
*/
static const CONF_PARSER startup_log_config[] = {
- { FR_CONF_POINTER("destination", PW_TYPE_STRING, &radlog_dest), .dflt = "files" },
- { FR_CONF_POINTER("syslog_facility", PW_TYPE_STRING, &syslog_facility), .dflt = STRINGIFY(0) },
+ { FR_CONF_POINTER("destination", FR_TYPE_STRING, &radlog_dest), .dflt = "files" },
+ { FR_CONF_POINTER("syslog_facility", FR_TYPE_STRING, &syslog_facility), .dflt = STRINGIFY(0) },
- { FR_CONF_POINTER("localstatedir", PW_TYPE_STRING, &localstatedir), .dflt = "${prefix}/var"},
- { FR_CONF_POINTER("logdir", PW_TYPE_STRING, &radlog_dir), .dflt = "${localstatedir}/log"},
- { FR_CONF_POINTER("file", PW_TYPE_STRING, &main_config.log_file), .dflt = "${logdir}/radius.log" },
- { FR_CONF_POINTER("requests", PW_TYPE_STRING | PW_TYPE_DEPRECATED, &default_log.file) },
+ { FR_CONF_POINTER("localstatedir", FR_TYPE_STRING, &localstatedir), .dflt = "${prefix}/var"},
+ { FR_CONF_POINTER("logdir", FR_TYPE_STRING, &radlog_dir), .dflt = "${localstatedir}/log"},
+ { FR_CONF_POINTER("file", FR_TYPE_STRING, &main_config.log_file), .dflt = "${logdir}/radius.log" },
+ { FR_CONF_POINTER("requests", FR_TYPE_STRING | FR_TYPE_DEPRECATED, &default_log.file) },
CONF_PARSER_TERMINATOR
};
* Basic configuration for the server.
*/
static const CONF_PARSER startup_server_config[] = {
- { FR_CONF_POINTER("log", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) startup_log_config },
+ { FR_CONF_POINTER("log", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) startup_log_config },
- { FR_CONF_POINTER("name", PW_TYPE_STRING, &my_name), .dflt = "radiusd" },
- { FR_CONF_POINTER("prefix", PW_TYPE_STRING, &prefix), .dflt = "/usr/local" },
+ { FR_CONF_POINTER("name", FR_TYPE_STRING, &my_name), .dflt = "radiusd" },
+ { FR_CONF_POINTER("prefix", FR_TYPE_STRING, &prefix), .dflt = "/usr/local" },
- { FR_CONF_POINTER("log_file", PW_TYPE_STRING, &main_config.log_file) },
- { FR_CONF_POINTER("log_destination", PW_TYPE_STRING, &radlog_dest) },
- { FR_CONF_POINTER("use_utc", PW_TYPE_BOOLEAN, &log_dates_utc) },
- { FR_CONF_IS_SET_POINTER("timestamp", PW_TYPE_BOOLEAN, &log_timestamp) },
+ { 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) },
CONF_PARSER_TERMINATOR
};
*
**********************************************************************/
static const CONF_PARSER log_config[] = {
- { FR_CONF_POINTER("stripped_names", PW_TYPE_BOOLEAN, &log_stripped_names), .dflt = "no" },
- { FR_CONF_POINTER("auth", PW_TYPE_BOOLEAN, &main_config.log_auth), .dflt = "no" },
- { FR_CONF_POINTER("auth_badpass", PW_TYPE_BOOLEAN, &main_config.log_auth_badpass), .dflt = "no" },
- { FR_CONF_POINTER("auth_goodpass", PW_TYPE_BOOLEAN, &main_config.log_auth_goodpass), .dflt = "no" },
- { FR_CONF_POINTER("msg_badpass", PW_TYPE_STRING, &main_config.auth_badpass_msg) },
- { FR_CONF_POINTER("msg_goodpass", PW_TYPE_STRING, &main_config.auth_goodpass_msg) },
- { FR_CONF_POINTER("colourise", PW_TYPE_BOOLEAN, &do_colourise) },
- { FR_CONF_POINTER("timestamp", PW_TYPE_BOOLEAN, &log_timestamp) },
- { FR_CONF_POINTER("use_utc", PW_TYPE_BOOLEAN, &log_dates_utc) },
- { FR_CONF_POINTER("msg_denied", PW_TYPE_STRING, &main_config.denied_msg), .dflt = "You are already logged in - access denied" },
+ { 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("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("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", PW_TYPE_STRING, &main_config.write_dir), .dflt = NULL },
+ { FR_CONF_POINTER("write_dir", FR_TYPE_STRING, &main_config.write_dir), .dflt = NULL },
#endif
CONF_PARSER_TERMINATOR
};
* Security configuration for the server.
*/
static const CONF_PARSER security_config[] = {
- { FR_CONF_POINTER("max_attributes", PW_TYPE_INTEGER, &fr_max_attributes), .dflt = STRINGIFY(0) },
- { FR_CONF_POINTER("reject_delay", PW_TYPE_TIMEVAL, &main_config.reject_delay), .dflt = STRINGIFY(0) },
- { FR_CONF_POINTER("status_server", PW_TYPE_BOOLEAN, &main_config.status_server), .dflt = "no" },
+ { FR_CONF_POINTER("max_attributes", FR_TYPE_INTEGER, &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" },
/*
* No default, so it isn't printed in debug mode.
*/
- { FR_CONF_POINTER("tunnel_password_zeros", PW_TYPE_BOOLEAN, &fr_tunnel_password_zeros) },
+ { FR_CONF_POINTER("tunnel_password_zeros", FR_TYPE_BOOLEAN, &fr_tunnel_password_zeros) },
#ifdef ENABLE_OPENSSL_VERSION_CHECK
- { FR_CONF_POINTER("allow_vulnerable_openssl", PW_TYPE_STRING, &main_config.allow_vulnerable_openssl), .dflt = "no" },
+ { FR_CONF_POINTER("allow_vulnerable_openssl", FR_TYPE_STRING, &main_config.allow_vulnerable_openssl), .dflt = "no" },
#endif
- { FR_CONF_POINTER("server_id", PW_TYPE_BYTE, &main_config.state_server_id) },
+ { FR_CONF_POINTER("server_id", FR_TYPE_BYTE, &main_config.state_server_id) },
CONF_PARSER_TERMINATOR
};
* the config item will *not* get printed out in debug mode, so that no one knows
* it exists.
*/
- { FR_CONF_POINTER("talloc_pool_size", PW_TYPE_SIZE, &main_config.talloc_pool_size) }, /* DO NOT SET DEFAULT */
- { FR_CONF_POINTER("talloc_memory_limit", PW_TYPE_SIZE, &main_config.talloc_memory_limit) }, /* DO NOT SET DEFAULT */
- { FR_CONF_POINTER("talloc_memory_report", PW_TYPE_BOOLEAN, &main_config.talloc_memory_report) }, /* DO NOT SET DEFAULT */
+ { 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 */
CONF_PARSER_TERMINATOR
};
* hard-coded defines for the locations of the various
* files.
*/
- { FR_CONF_POINTER("name", PW_TYPE_STRING, &my_name), .dflt = "radiusd" },
- { FR_CONF_POINTER("prefix", PW_TYPE_STRING, &prefix), .dflt = "/usr/local" },
- { FR_CONF_POINTER("localstatedir", PW_TYPE_STRING, &localstatedir), .dflt = "${prefix}/var"},
- { FR_CONF_POINTER("sbindir", PW_TYPE_STRING, &sbindir), .dflt = "${prefix}/sbin"},
- { FR_CONF_POINTER("logdir", PW_TYPE_STRING, &radlog_dir), .dflt = "${localstatedir}/log"},
- { FR_CONF_POINTER("run_dir", PW_TYPE_STRING, &run_dir), .dflt = "${localstatedir}/run/${name}"},
- { FR_CONF_POINTER("libdir", PW_TYPE_STRING, &radlib_dir), .dflt = "${prefix}/lib"},
- { FR_CONF_POINTER("radacctdir", PW_TYPE_STRING, &radacct_dir), .dflt = "${logdir}/radacct" },
- { FR_CONF_POINTER("panic_action", PW_TYPE_STRING, &main_config.panic_action) },
- { FR_CONF_POINTER("hostname_lookups", PW_TYPE_BOOLEAN, &fr_dns_lookups), .dflt = "no" },
- { FR_CONF_POINTER("max_request_time", PW_TYPE_INTEGER, &main_config.max_request_time), .dflt = STRINGIFY(MAX_REQUEST_TIME) },
- { FR_CONF_POINTER("cleanup_delay", PW_TYPE_INTEGER, &main_config.cleanup_delay), .dflt = STRINGIFY(CLEANUP_DELAY) },
- { FR_CONF_POINTER("continuation_timeout", PW_TYPE_INTEGER, &main_config.continuation_timeout), .dflt = "15" },
- { FR_CONF_POINTER("max_requests", PW_TYPE_INTEGER, &main_config.max_requests), .dflt = STRINGIFY(MAX_REQUESTS) },
- { FR_CONF_POINTER("pidfile", PW_TYPE_STRING, &main_config.pid_file), .dflt = "${run_dir}/radiusd.pid"},
- { FR_CONF_POINTER("checkrad", PW_TYPE_STRING, &main_config.checkrad), .dflt = "${sbindir}/checkrad" },
-
- { FR_CONF_POINTER("debug_level", PW_TYPE_INTEGER, &main_config.debug_level), .dflt = "0" },
+ { FR_CONF_POINTER("name", FR_TYPE_STRING, &my_name), .dflt = "radiusd" },
+ { FR_CONF_POINTER("prefix", FR_TYPE_STRING, &prefix), .dflt = "/usr/local" },
+ { FR_CONF_POINTER("localstatedir", FR_TYPE_STRING, &localstatedir), .dflt = "${prefix}/var"},
+ { FR_CONF_POINTER("sbindir", FR_TYPE_STRING, &sbindir), .dflt = "${prefix}/sbin"},
+ { FR_CONF_POINTER("logdir", FR_TYPE_STRING, &radlog_dir), .dflt = "${localstatedir}/log"},
+ { FR_CONF_POINTER("run_dir", FR_TYPE_STRING, &run_dir), .dflt = "${localstatedir}/run/${name}"},
+ { 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("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" },
#ifdef WITH_PROXY
- { FR_CONF_POINTER("proxy_requests", PW_TYPE_BOOLEAN, &main_config.proxy_requests), .dflt = "yes" },
+ { FR_CONF_POINTER("proxy_requests", FR_TYPE_BOOLEAN, &main_config.proxy_requests), .dflt = "yes" },
#endif
- { FR_CONF_POINTER("log", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) log_config },
+ { FR_CONF_POINTER("log", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) log_config },
- { FR_CONF_POINTER("resources", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) resources },
+ { FR_CONF_POINTER("resources", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) resources },
/*
* People with old configs will have these. They are listed
* DON'T exist in radiusd.conf, then the previously parsed
* values for "log { foo = bar}" will be used.
*/
- { FR_CONF_POINTER("log_auth", PW_TYPE_BOOLEAN | PW_TYPE_DEPRECATED, &main_config.log_auth) },
- { FR_CONF_POINTER("log_auth_badpass", PW_TYPE_BOOLEAN | PW_TYPE_DEPRECATED, &main_config.log_auth_badpass) },
- { FR_CONF_POINTER("log_auth_goodpass", PW_TYPE_BOOLEAN | PW_TYPE_DEPRECATED, &main_config.log_auth_goodpass) },
- { FR_CONF_POINTER("log_stripped_names", PW_TYPE_BOOLEAN | PW_TYPE_DEPRECATED, &log_stripped_names) },
+ { 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("security", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) security_config },
+ { FR_CONF_POINTER("security", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) security_config },
CONF_PARSER_TERMINATOR
};
**********************************************************************/
static const CONF_PARSER bootstrap_security_config[] = {
#ifdef HAVE_SETUID
- { FR_CONF_POINTER("user", PW_TYPE_STRING, &uid_name) },
- { FR_CONF_POINTER("group", PW_TYPE_STRING, &gid_name) },
+ { FR_CONF_POINTER("user", FR_TYPE_STRING, &uid_name) },
+ { FR_CONF_POINTER("group", FR_TYPE_STRING, &gid_name) },
#endif
- { FR_CONF_POINTER("chroot", PW_TYPE_STRING, &chroot_dir) },
- { FR_CONF_POINTER("allow_core_dumps", PW_TYPE_BOOLEAN, &allow_core_dumps), .dflt = "no" },
+ { FR_CONF_POINTER("chroot", FR_TYPE_STRING, &chroot_dir) },
+ { FR_CONF_POINTER("allow_core_dumps", FR_TYPE_BOOLEAN, &allow_core_dumps), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER bootstrap_config[] = {
- { FR_CONF_POINTER("security", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) bootstrap_security_config },
+ { FR_CONF_POINTER("security", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) bootstrap_security_config },
- { FR_CONF_POINTER("name", PW_TYPE_STRING, &my_name), .dflt = "radiusd" },
- { FR_CONF_POINTER("prefix", PW_TYPE_STRING, &prefix), .dflt = "/usr/local" },
- { FR_CONF_POINTER("localstatedir", PW_TYPE_STRING, &localstatedir), .dflt = "${prefix}/var"},
+ { FR_CONF_POINTER("name", FR_TYPE_STRING, &my_name), .dflt = "radiusd" },
+ { FR_CONF_POINTER("prefix", FR_TYPE_STRING, &prefix), .dflt = "/usr/local" },
+ { FR_CONF_POINTER("localstatedir", FR_TYPE_STRING, &localstatedir), .dflt = "${prefix}/var"},
- { FR_CONF_POINTER("logdir", PW_TYPE_STRING, &radlog_dir), .dflt = "${localstatedir}/log"},
- { FR_CONF_POINTER("run_dir", PW_TYPE_STRING, &run_dir), .dflt = "${localstatedir}/run/${name}"},
+ { FR_CONF_POINTER("logdir", FR_TYPE_STRING, &radlog_dir), .dflt = "${localstatedir}/log"},
+ { FR_CONF_POINTER("run_dir", FR_TYPE_STRING, &run_dir), .dflt = "${localstatedir}/run/${name}"},
/*
* For backwards compatibility.
*/
#ifdef HAVE_SETUID
- { FR_CONF_POINTER("user", PW_TYPE_STRING | PW_TYPE_DEPRECATED, &uid_name) },
- { FR_CONF_POINTER("group", PW_TYPE_STRING | PW_TYPE_DEPRECATED, &gid_name) },
+ { FR_CONF_POINTER("user", FR_TYPE_STRING | FR_TYPE_DEPRECATED, &uid_name) },
+ { FR_CONF_POINTER("group", FR_TYPE_STRING | FR_TYPE_DEPRECATED, &gid_name) },
#endif
- { FR_CONF_POINTER("chroot", PW_TYPE_STRING | PW_TYPE_DEPRECATED, &chroot_dir) },
- { FR_CONF_POINTER("allow_core_dumps", PW_TYPE_BOOLEAN | PW_TYPE_DEPRECATED, &allow_core_dumps) },
+ { 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) },
CONF_PARSER_TERMINATOR
};
fr_dict_attr_t const *da;
VALUE_PAIR *vp = NULL;
vp_tmpl_t *vpt;
- value_box_t bin = { .type = PW_TYPE_STRING }, cast;
+ value_box_t bin = { .type = FR_TYPE_STRING }, cast;
rad_assert(map != NULL);
vp = fr_pair_cursor_remove(&from);
talloc_free(vp);
- rad_assert((n->vp_type != PW_TYPE_STRING) || (n->vp_strvalue != NULL));
+ rad_assert((n->vp_type != FR_TYPE_STRING) || (n->vp_strvalue != NULL));
n->op = map->op;
n->tag = map->lhs->tmpl_tag;
if (!vp->da->parent->flags.is_root) continue;
if (vp->da->vendor != 0) continue;
if (vp->da->flags.has_tag) continue;
- if (vp->vp_type != PW_TYPE_STRING) continue;
+ if (vp->vp_type != FR_TYPE_STRING) continue;
if (!context->username && (vp->da->attr == PW_USER_NAME)) {
context->username = vp;
if (!rad_cond_assert(map->rhs != NULL)) return -1;
if ((map->lhs->type == TMPL_TYPE_ATTR) &&
- (map->lhs->tmpl_da->type == PW_TYPE_STRING) &&
+ (map->lhs->tmpl_da->type == FR_TYPE_STRING) &&
(map->rhs->type == TMPL_TYPE_UNPARSED)) {
*(p++) = '\'';
len = tmpl_snprint(p, (end - p) - 1, map->rhs); /* -1 for proceeding '\'' */
vp_tmpl_t vpt;
char const *quote;
- quote = (vp->vp_type == PW_TYPE_STRING) ? "\"" : "";
+ quote = (vp->vp_type == FR_TYPE_STRING) ? "\"" : "";
/*
* Fudge a temporary tmpl that describes the attribute we're copying
{
char const *quote;
- quote = (vp->vp_type == PW_TYPE_STRING) ? "\"" : "";
+ quote = (vp->vp_type == FR_TYPE_STRING) ? "\"" : "";
/*
* Not appropriate to use map->rhs->quote here, as that's the quoting
char *expr = NULL, *value = NULL;
char const *expr_p, *value_p;
- if (check->vp_type == PW_TYPE_STRING) {
+ if (check->vp_type == FR_TYPE_STRING) {
expr_p = check->vp_strvalue;
} else {
expr_p = expr = fr_pair_value_asprint(check, check, '\0');
}
- if (vp->vp_type == PW_TYPE_STRING) {
+ if (vp->vp_type == FR_TYPE_STRING) {
value_p = vp->vp_strvalue;
} else {
value_p = value = fr_pair_value_asprint(vp, vp, '\0');
* Ascend binary attributes can be treated
* as opaque objects, I guess...
*/
- case PW_TYPE_ABINARY:
+ case FR_TYPE_ABINARY:
#endif
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
if (vp->vp_length != check->vp_length) {
ret = 1; /* NOT equal */
break;
ret = memcmp(vp->vp_strvalue, check->vp_strvalue, vp->vp_length);
break;
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
ret = strcmp(vp->vp_strvalue,
check->vp_strvalue);
break;
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
ret = vp->vp_byte - check->vp_byte;
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
ret = vp->vp_short - check->vp_short;
break;
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
ret = vp->vp_integer - check->vp_integer;
break;
- case PW_TYPE_INTEGER64:
+ case FR_TYPE_INTEGER64:
/*
* Don't want integer overflow!
*/
}
break;
- case PW_TYPE_SIGNED:
+ case FR_TYPE_SIGNED:
if (vp->vp_signed < check->vp_signed) {
ret = -1;
} else if (vp->vp_signed > check->vp_signed) {
}
break;
- case PW_TYPE_DATE:
+ case FR_TYPE_DATE:
ret = vp->vp_date - check->vp_date;
break;
- case PW_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_ADDR:
ret = ntohl(vp->vp_ipv4addr) - ntohl(check->vp_ipv4addr);
break;
- case PW_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_ADDR:
ret = memcmp(vp->vp_ip.addr.v6.s6_addr, check->vp_ip.addr.v6.s6_addr,
sizeof(vp->vp_ip.addr.v6.s6_addr));
break;
- case PW_TYPE_IPV4_PREFIX:
- case PW_TYPE_IPV6_PREFIX:
+ case FR_TYPE_IPV4_PREFIX:
+ case FR_TYPE_IPV6_PREFIX:
ret = memcmp(&vp->vp_ip, &check->vp_ip, sizeof(vp->vp_ip));
break;
- case PW_TYPE_IFID:
+ case FR_TYPE_IFID:
ret = memcmp(vp->vp_ifid, check->vp_ifid, sizeof(vp->vp_ifid));
break;
{
size_t i;
- if (!vp || (vp->vp_type != PW_TYPE_OCTETS)) return true;
+ if (!vp || (vp->vp_type != FR_TYPE_OCTETS)) return true;
/*
* If it's 17 octets, it *might* be already encoded.
talloc_free(q);
vp->vp_octets = talloc_steal(vp, p);
- vp->data.type = PW_TYPE_OCTETS;
+ vp->data.type = FR_TYPE_OCTETS;
vp->type = VT_DATA;
VERIFY_VP(vp);
* Now find the socket name (sigh)
*/
rcode = cf_pair_parse(NULL, subcs, "socket",
- FR_ITEM_POINTER(PW_TYPE_STRING, &file), NULL, T_DOUBLE_QUOTED_STRING);
+ FR_ITEM_POINTER(FR_TYPE_STRING, &file), NULL, T_DOUBLE_QUOTED_STRING);
if (rcode < 0) {
fprintf(stderr, "%s: Failed parsing listen section 'socket'\n", progname);
exit(1);
* Check UID and GID.
*/
rcode = cf_pair_parse(NULL, subcs, "uid",
- FR_ITEM_POINTER(PW_TYPE_STRING, &uid_name), NULL, T_DOUBLE_QUOTED_STRING);
+ FR_ITEM_POINTER(FR_TYPE_STRING, &uid_name), NULL, T_DOUBLE_QUOTED_STRING);
if (rcode < 0) {
fprintf(stderr, "%s: Failed parsing listen section 'uid'\n", progname);
exit(1);
if (uid != pwd->pw_uid) continue;
rcode = cf_pair_parse(NULL, subcs, "gid",
- FR_ITEM_POINTER(PW_TYPE_STRING, &gid_name), NULL, T_DOUBLE_QUOTED_STRING);
+ FR_ITEM_POINTER(FR_TYPE_STRING, &gid_name), NULL, T_DOUBLE_QUOTED_STRING);
if (rcode < 0) {
fprintf(stderr, "%s: Failed parsing listen section 'gid'\n", progname);
exit(1);
for (i = 0; i < conf->list_da_num; i++) {
vp = fr_pair_find_by_da(packet->vps, conf->list_da[i], TAG_ANY);
if (vp && (vp->vp_length > 0)) {
- if (conf->list_da[i]->type == PW_TYPE_STRING) {
+ if (conf->list_da[i]->type == FR_TYPE_STRING) {
*p++ = '"';
s--;
if (s <= 0) return;
break;
}
- if (index_attr->type != PW_TYPE_INTEGER) {
+ if (index_attr->type != FR_TYPE_INTEGER) {
fr_strerror_printf("Index is not a \"integer\"");
break;
}
/*
* Entry must be a TLV type
*/
- if (parent->type != PW_TYPE_TLV) {
+ if (parent->type != FR_TYPE_TLV) {
fr_strerror_printf("Entry is not \"tlv\"");
break;
}
* of conveying information, so empty TLVs are
* disallowed.
*/
- case PW_TYPE_TLV:
+ case FR_TYPE_TLV:
vp->da = fr_dict_unknown_afrom_fields(vp, vp->da->parent, vp->da->vendor, vp->da->attr);
/* FALL-THROUGH */
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
fr_pair_value_memcpy(vp, (uint8_t const *)"\0", 1);
break;
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
fr_pair_value_bstrncpy(vp, "\0", 1);
break;
return slen;
}
- if (da->type == PW_TYPE_TLV) {
+ if (da->type == FR_TYPE_TLV) {
fr_strerror_printf("TLVs cannot hold values");
return -(slen);
}
slen = dict_print_attr_oid(p, end - p, parent, vp->da->parent);
if (slen < 0) return -1;
- if (vp->vp_type != PW_TYPE_INTEGER) {
+ if (vp->vp_type != FR_TYPE_INTEGER) {
fr_strerror_printf("Index attribute \"%s\" is not of type \"integer\"", vp->da->name);
return -1;
}
io_vector[3].iov_len = 1;
switch (vp->vp_type) {
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
memcpy(&io_vector[4].iov_base, &vp->vp_strvalue, sizeof(io_vector[4].iov_base));
io_vector[4].iov_len = vp->vp_length;
break;
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
memcpy(&io_vector[4].iov_base, &vp->vp_strvalue, sizeof(io_vector[4].iov_base));
io_vector[4].iov_len = vp->vp_length;
break;
} radutmpconfig;
static const CONF_PARSER module_config[] = {
- { FR_CONF_POINTER("filename", PW_TYPE_FILE_INPUT, &radutmpconfig.radutmp_fn), .dflt = RADUTMP },
+ { FR_CONF_POINTER("filename", FR_TYPE_FILE_INPUT, &radutmpconfig.radutmp_fn), .dflt = RADUTMP },
CONF_PARSER_TERMINATOR
};
* Map the proxy server configuration parameters to variables.
*/
static const CONF_PARSER proxy_config[] = {
- { FR_CONF_OFFSET("retry_delay", PW_TYPE_INTEGER, realm_config_t, retry_delay), .dflt = STRINGIFY(RETRY_DELAY) },
+ { FR_CONF_OFFSET("retry_delay", FR_TYPE_INTEGER, realm_config_t, retry_delay), .dflt = STRINGIFY(RETRY_DELAY) },
- { FR_CONF_OFFSET("retry_count", PW_TYPE_INTEGER, realm_config_t, retry_count), .dflt = STRINGIFY(RETRY_COUNT) },
+ { FR_CONF_OFFSET("retry_count", FR_TYPE_INTEGER, realm_config_t, retry_count), .dflt = STRINGIFY(RETRY_COUNT) },
- { FR_CONF_OFFSET("default_fallback", PW_TYPE_BOOLEAN, realm_config_t, fallback), .dflt = "no" },
+ { FR_CONF_OFFSET("default_fallback", FR_TYPE_BOOLEAN, realm_config_t, fallback), .dflt = "no" },
- { FR_CONF_OFFSET("dynamic", PW_TYPE_BOOLEAN, realm_config_t, dynamic) },
+ { FR_CONF_OFFSET("dynamic", FR_TYPE_BOOLEAN, realm_config_t, dynamic) },
- { FR_CONF_OFFSET("dead_time", PW_TYPE_INTEGER, realm_config_t, dead_time), .dflt = STRINGIFY(DEAD_TIME) },
+ { FR_CONF_OFFSET("dead_time", FR_TYPE_INTEGER, realm_config_t, dead_time), .dflt = STRINGIFY(DEAD_TIME) },
- { FR_CONF_OFFSET("wake_all_if_all_dead", PW_TYPE_BOOLEAN, realm_config_t, wake_all_if_all_dead), .dflt = "no" },
+ { FR_CONF_OFFSET("wake_all_if_all_dead", FR_TYPE_BOOLEAN, 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", PW_TYPE_INTEGER, home_server_t, limit.max_connections), .dflt = "16" },
- { FR_CONF_OFFSET("max_requests", PW_TYPE_INTEGER, home_server_t, limit.max_requests), .dflt = "0" },
- { FR_CONF_OFFSET("lifetime", PW_TYPE_INTEGER, home_server_t, limit.lifetime), .dflt = "0" },
- { FR_CONF_OFFSET("idle_timeout", PW_TYPE_INTEGER, home_server_t, limit.idle_timeout), .dflt = "0" },
+ { 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" },
CONF_PARSER_TERMINATOR
};
#ifdef WITH_COA
static CONF_PARSER home_server_coa[] = {
- { FR_CONF_OFFSET("irt", PW_TYPE_INTEGER, home_server_t, coa_irt), .dflt = STRINGIFY(2) },
- { FR_CONF_OFFSET("mrt", PW_TYPE_INTEGER, home_server_t, coa_mrt), .dflt = STRINGIFY(16) },
- { FR_CONF_OFFSET("mrc", PW_TYPE_INTEGER, home_server_t, coa_mrc), .dflt = STRINGIFY(5) },
- { FR_CONF_OFFSET("mrd", PW_TYPE_INTEGER, home_server_t, coa_mrd), .dflt = STRINGIFY(30) },
+ { 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) },
CONF_PARSER_TERMINATOR
};
#endif
static CONF_PARSER home_server_config[] = {
- { FR_CONF_OFFSET("ipaddr", PW_TYPE_COMBO_IP_ADDR, home_server_t, ipaddr) },
- { FR_CONF_OFFSET("ipv4addr", PW_TYPE_IPV4_ADDR, home_server_t, ipaddr) },
- { FR_CONF_OFFSET("ipv6addr", PW_TYPE_IPV6_ADDR, home_server_t, ipaddr) },
- { FR_CONF_OFFSET("virtual_server", PW_TYPE_STRING | PW_TYPE_NOT_EMPTY, home_server_t, server) },
+ { FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, home_server_t, ipaddr) },
+ { FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, home_server_t, ipaddr) },
+ { 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", PW_TYPE_SHORT, home_server_t, port), .dflt = "0" },
+ { FR_CONF_OFFSET("port", FR_TYPE_SHORT, home_server_t, port), .dflt = "0" },
- { FR_CONF_OFFSET("type", PW_TYPE_STRING, home_server_t, type_str) },
+ { FR_CONF_OFFSET("type", FR_TYPE_STRING, home_server_t, type_str) },
#ifdef WITH_TCP
- { FR_CONF_OFFSET("proto", PW_TYPE_STRING | PW_TYPE_NOT_EMPTY, home_server_t, proto_str) },
+ { FR_CONF_OFFSET("proto", FR_TYPE_STRING | FR_TYPE_NOT_EMPTY, home_server_t, proto_str) },
#endif
- { FR_CONF_OFFSET("secret", PW_TYPE_STRING | PW_TYPE_SECRET, home_server_t, secret) },
+ { FR_CONF_OFFSET("secret", FR_TYPE_STRING | FR_TYPE_SECRET, home_server_t, secret) },
- { FR_CONF_OFFSET("src_ipaddr", PW_TYPE_STRING, home_server_t, src_ipaddr_str) },
+ { FR_CONF_OFFSET("src_ipaddr", FR_TYPE_STRING, home_server_t, src_ipaddr_str) },
- { FR_CONF_OFFSET("response_window", PW_TYPE_TIMEVAL, home_server_t, response_window), .dflt = "30" },
- { FR_CONF_OFFSET("response_timeouts", PW_TYPE_INTEGER, home_server_t, max_response_timeouts), .dflt = "1" },
- { FR_CONF_OFFSET("max_outstanding", PW_TYPE_INTEGER, home_server_t, max_outstanding), .dflt = "65536" },
+ { 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("zombie_period", PW_TYPE_INTEGER, home_server_t, zombie_period), .dflt = "40" },
+ { FR_CONF_OFFSET("zombie_period", FR_TYPE_INTEGER, home_server_t, zombie_period), .dflt = "40" },
- { FR_CONF_OFFSET("status_check", PW_TYPE_STRING, home_server_t, ping_check_str), .dflt = "none" },
- { FR_CONF_OFFSET("ping_check", PW_TYPE_STRING, home_server_t, ping_check_str) },
+ { 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", PW_TYPE_INTEGER, home_server_t, ping_interval), .dflt = "30" },
- { FR_CONF_OFFSET("check_interval", PW_TYPE_INTEGER, home_server_t, ping_interval) },
+ { 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("check_timeout", PW_TYPE_INTEGER, home_server_t, ping_timeout), .dflt = "4" },
- { FR_CONF_OFFSET("status_check_timeout", PW_TYPE_INTEGER, home_server_t, ping_timeout) },
+ { 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("num_answers_to_alive", PW_TYPE_INTEGER, home_server_t, num_pings_to_alive), .dflt = "3" },
- { FR_CONF_OFFSET("revive_interval", PW_TYPE_INTEGER, home_server_t, revive_interval), .dflt = "300" },
+ { 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("username", PW_TYPE_STRING | PW_TYPE_NOT_EMPTY, home_server_t, ping_user_name) },
- { FR_CONF_OFFSET("password", PW_TYPE_STRING | PW_TYPE_NOT_EMPTY, home_server_t, ping_user_password) },
+ { 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", PW_TYPE_INTEGER, home_server_t, ema.window) },
+ { FR_CONF_OFFSET("historic_average_window", FR_TYPE_INTEGER, home_server_t, ema.window) },
#endif
- { FR_CONF_POINTER("limit", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) limit_config },
+ { FR_CONF_POINTER("limit", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) limit_config },
#ifdef WITH_COA
- { FR_CONF_POINTER("coa", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) home_server_coa },
+ { FR_CONF_POINTER("coa", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) home_server_coa },
#endif
- { FR_CONF_OFFSET("self", PW_TYPE_BOOLEAN, home_server_t, is_ourself), },
+ { FR_CONF_OFFSET("self", FR_TYPE_BOOLEAN, home_server_t, is_ourself), },
CONF_PARSER_TERMINATOR
};
static int snmp_value_serv_ident_get(TALLOC_CTX *ctx, value_box_t *out, NDEBUG_UNUSED fr_snmp_map_t const *map,
UNUSED void *snmp_ctx)
{
- rad_assert(map->da->type == PW_TYPE_STRING);
+ rad_assert(map->da->type == FR_TYPE_STRING);
out->datum.strvalue = talloc_typed_asprintf(ctx, "FreeRADIUS %s", radiusd_version_short);
out->datum.length = talloc_array_length(out->datum.strvalue) - 1;
struct timeval now;
struct timeval diff;
- rad_assert(map->da->type == PW_TYPE_INTEGER);
+ rad_assert(map->da->type == FR_TYPE_INTEGER);
gettimeofday(&now, NULL);
fr_timeval_subtract(&diff, &now, &uptime);
struct timeval now;
struct timeval diff;
- rad_assert(map->da->type == PW_TYPE_INTEGER);
+ rad_assert(map->da->type == FR_TYPE_INTEGER);
gettimeofday(&now, NULL);
fr_timeval_subtract(&diff, &now, &reset_time);
static int snmp_config_reset_get(UNUSED TALLOC_CTX *ctx, value_box_t *out, NDEBUG_UNUSED fr_snmp_map_t const *map,
UNUSED void *snmp_ctx)
{
- rad_assert(map->da->type == PW_TYPE_INTEGER);
+ rad_assert(map->da->type == FR_TYPE_INTEGER);
out->datum.integer = reset_state;
static int snmp_config_reset_set(NDEBUG_UNUSED fr_snmp_map_t const *map, UNUSED void *snmp_ctx, value_box_t *in)
{
- rad_assert(map->da->type == PW_TYPE_INTEGER);
+ rad_assert(map->da->type == FR_TYPE_INTEGER);
switch (in->datum.integer) {
case PW_RADIUS_AUTH_SERV_CONFIG_RESET_VALUE_RESET:
static int snmp_auth_stats_offset_get(UNUSED TALLOC_CTX *ctx, value_box_t *out,
fr_snmp_map_t const *map, UNUSED void *snmp_ctx)
{
- rad_assert(map->da->type == PW_TYPE_INTEGER);
+ rad_assert(map->da->type == FR_TYPE_INTEGER);
out->datum.integer = *(uint32_t *)((uint8_t *)(&radius_auth_stats) + map->offset);
RADCLIENT *client = snmp_ctx;
rad_assert(client);
- rad_assert(map->da->type == PW_TYPE_IPV4_ADDR);
+ rad_assert(map->da->type == FR_TYPE_IPV4_ADDR);
/*
* The old SNMP MIB only allowed access
size_t len;
rad_assert(client);
- rad_assert(map->da->type == PW_TYPE_STRING);
+ rad_assert(map->da->type == FR_TYPE_STRING);
len = talloc_array_length(client->longname) - 1;
RADCLIENT *client = snmp_ctx;
rad_assert(client);
- rad_assert(map->da->type == PW_TYPE_INTEGER);
+ rad_assert(map->da->type == FR_TYPE_INTEGER);
out->datum.integer = *(uint32_t *)((uint8_t *)(&client->auth) + map->offset);
goto error;
}
- if (tlv_stack[depth]->type != PW_TYPE_INTEGER) {
+ if (tlv_stack[depth]->type != FR_TYPE_INTEGER) {
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?"));
* matching the next deepest DA in the
* tlv_stack.
*/
- if (tlv_stack[depth]->type == PW_TYPE_TLV) return snmp_process_tlv(out, request, tlv_stack, depth, cursor,
+ if (tlv_stack[depth]->type == FR_TYPE_TLV) return snmp_process_tlv(out, request, tlv_stack, depth, cursor,
map, snmp_ctx, snmp_op);
/*
/*
* Clear out any junk values
*/
- if (da->type == PW_TYPE_TLV) {
+ if (da->type == FR_TYPE_TLV) {
switch (vp->vp_type) {
- case PW_TYPE_OCTETS:
- case PW_TYPE_STRING:
+ case FR_TYPE_OCTETS:
+ case FR_TYPE_STRING:
talloc_free(vp->data.datum.ptr);
/* FALL-THROUGH */
* When retrieving client by number, also
* echo back it's IP address.
*/
- if ((vp->vp_type == PW_TYPE_INTEGER) &&
+ if ((vp->vp_type == FR_TYPE_INTEGER) &&
(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", PW_TYPE_INTEGER, &thread_pool.start_threads), .dflt = "5" },
- { FR_CONF_POINTER("max_servers", PW_TYPE_INTEGER, &thread_pool.max_threads), .dflt = "32" },
- { FR_CONF_POINTER("min_spare_servers", PW_TYPE_INTEGER, &thread_pool.min_spare_threads), .dflt = "3" },
- { FR_CONF_POINTER("max_spare_servers", PW_TYPE_INTEGER, &thread_pool.max_spare_threads), .dflt = "10" },
- { FR_CONF_POINTER("max_requests_per_server", PW_TYPE_INTEGER, &thread_pool.max_requests_per_thread), .dflt = "0" },
- { FR_CONF_POINTER("cleanup_delay", PW_TYPE_INTEGER, &thread_pool.cleanup_delay), .dflt = "5" },
- { FR_CONF_POINTER("max_queue_size", PW_TYPE_INTEGER, &thread_pool.max_queue_size), .dflt = "65536" },
- { FR_CONF_POINTER("queue_priority", PW_TYPE_STRING, &thread_pool.queue_priority), .dflt = NULL },
+ { 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("queue_priority", FR_TYPE_STRING, &thread_pool.queue_priority), .dflt = NULL },
#ifdef WITH_STATS
#ifdef WITH_ACCOUNTING
- { FR_CONF_POINTER("auto_limit_acct", PW_TYPE_BOOLEAN, &thread_pool.auto_limit_acct) },
+ { FR_CONF_POINTER("auto_limit_acct", FR_TYPE_BOOLEAN, &thread_pool.auto_limit_acct) },
#endif
#endif
CONF_PARSER_TERMINATOR
#include <freeradius-devel/rad_assert.h>
static CONF_PARSER cache_config[] = {
- { FR_CONF_OFFSET("virtual_server", PW_TYPE_STRING, fr_tls_conf_t, session_cache_server) },
- { FR_CONF_OFFSET("name", PW_TYPE_STRING, fr_tls_conf_t, session_id_name) },
- { FR_CONF_OFFSET("lifetime", PW_TYPE_INTEGER, fr_tls_conf_t, session_cache_lifetime), .dflt = "86400" },
- { FR_CONF_OFFSET("verify", PW_TYPE_BOOLEAN, fr_tls_conf_t, session_cache_verify), .dflt = "no" },
+ { 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" },
#if OPENSSL_VERSION_NUMBER >= 0x10100000L
- { FR_CONF_OFFSET("require_extended_master_secret", PW_TYPE_BOOLEAN, fr_tls_conf_t, session_cache_require_extms), .dflt = "yes" },
- { FR_CONF_OFFSET("require_perfect_forward_secrecy", PW_TYPE_BOOLEAN, fr_tls_conf_t, session_cache_require_pfs), .dflt = "no" },
+ { 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" },
#endif
- { FR_CONF_DEPRECATED("enable", PW_TYPE_BOOLEAN, fr_tls_conf_t, NULL) },
- { FR_CONF_DEPRECATED("max_entries", PW_TYPE_INTEGER, fr_tls_conf_t, NULL) },
- { FR_CONF_DEPRECATED("persist_dir", PW_TYPE_STRING, fr_tls_conf_t, NULL) },
+ { 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("persist_dir", FR_TYPE_STRING, fr_tls_conf_t, NULL) },
CONF_PARSER_TERMINATOR
};
static CONF_PARSER verify_config[] = {
- { FR_CONF_OFFSET("tmpdir", PW_TYPE_STRING, fr_tls_conf_t, verify_tmp_dir) },
- { FR_CONF_OFFSET("client", PW_TYPE_STRING, fr_tls_conf_t, verify_client_cert_cmd) },
+ { FR_CONF_OFFSET("tmpdir", FR_TYPE_STRING, fr_tls_conf_t, verify_tmp_dir) },
+ { FR_CONF_OFFSET("client", FR_TYPE_STRING, fr_tls_conf_t, verify_client_cert_cmd) },
CONF_PARSER_TERMINATOR
};
#ifdef HAVE_OPENSSL_OCSP_H
static CONF_PARSER ocsp_config[] = {
- { FR_CONF_OFFSET("enable", PW_TYPE_BOOLEAN, fr_tls_ocsp_conf_t, enable), .dflt = "no" },
+ { FR_CONF_OFFSET("enable", FR_TYPE_BOOLEAN, fr_tls_ocsp_conf_t, enable), .dflt = "no" },
- { FR_CONF_OFFSET("virtual_server", PW_TYPE_STRING, fr_tls_ocsp_conf_t, cache_server) },
+ { FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING, fr_tls_ocsp_conf_t, cache_server) },
- { FR_CONF_OFFSET("override_cert_url", PW_TYPE_BOOLEAN, fr_tls_ocsp_conf_t, override_url), .dflt = "no" },
- { FR_CONF_OFFSET("url", PW_TYPE_STRING, fr_tls_ocsp_conf_t, url) },
- { FR_CONF_OFFSET("use_nonce", PW_TYPE_BOOLEAN, fr_tls_ocsp_conf_t, use_nonce), .dflt = "yes" },
- { FR_CONF_OFFSET("timeout", PW_TYPE_INTEGER, fr_tls_ocsp_conf_t, timeout), .dflt = "yes" },
- { FR_CONF_OFFSET("softfail", PW_TYPE_BOOLEAN, fr_tls_ocsp_conf_t, softfail), .dflt = "no" },
+ { FR_CONF_OFFSET("override_cert_url", FR_TYPE_BOOLEAN, 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" },
CONF_PARSER_TERMINATOR
};
#endif
static CONF_PARSER tls_server_config[] = {
- { FR_CONF_OFFSET("verify_depth", PW_TYPE_INTEGER, fr_tls_conf_t, verify_depth), .dflt = "0" },
- { FR_CONF_OFFSET("ca_path", PW_TYPE_FILE_INPUT, fr_tls_conf_t, ca_path) },
- { FR_CONF_OFFSET("pem_file_type", PW_TYPE_BOOLEAN, fr_tls_conf_t, file_type), .dflt = "yes" },
- { FR_CONF_OFFSET("private_key_file", PW_TYPE_FILE_INPUT, fr_tls_conf_t, private_key_file) },
- { FR_CONF_OFFSET("certificate_file", PW_TYPE_FILE_INPUT, fr_tls_conf_t, certificate_file) },
- { FR_CONF_OFFSET("ca_file", PW_TYPE_FILE_INPUT, fr_tls_conf_t, ca_file) },
- { FR_CONF_OFFSET("private_key_password", PW_TYPE_STRING | PW_TYPE_SECRET, fr_tls_conf_t, private_key_password) },
+ { FR_CONF_OFFSET("verify_depth", FR_TYPE_INTEGER, 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("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) },
#ifdef PSK_MAX_IDENTITY_LEN
- { FR_CONF_OFFSET("psk_identity", PW_TYPE_STRING, fr_tls_conf_t, psk_identity) },
- { FR_CONF_OFFSET("psk_hexphrase", PW_TYPE_STRING | PW_TYPE_SECRET, fr_tls_conf_t, psk_password) },
- { FR_CONF_OFFSET("psk_query", PW_TYPE_STRING, fr_tls_conf_t, psk_query) },
+ { FR_CONF_OFFSET("psk_identity", FR_TYPE_STRING, fr_tls_conf_t, psk_identity) },
+ { FR_CONF_OFFSET("psk_hexphrase", FR_TYPE_STRING | FR_TYPE_SECRET, fr_tls_conf_t, psk_password) },
+ { FR_CONF_OFFSET("psk_query", FR_TYPE_STRING, fr_tls_conf_t, psk_query) },
#endif
- { FR_CONF_OFFSET("dh_file", PW_TYPE_FILE_INPUT, fr_tls_conf_t, dh_file) },
- { FR_CONF_OFFSET("random_file", PW_TYPE_FILE_EXISTS, fr_tls_conf_t, random_file) },
- { FR_CONF_OFFSET("fragment_size", PW_TYPE_INTEGER, fr_tls_conf_t, fragment_size), .dflt = "1024" },
- { FR_CONF_OFFSET("auto_chain", PW_TYPE_BOOLEAN, fr_tls_conf_t, auto_chain), .dflt = "yes" },
- { FR_CONF_OFFSET("disable_single_dh_use", PW_TYPE_BOOLEAN, fr_tls_conf_t, disable_single_dh_use) },
- { FR_CONF_OFFSET("check_crl", PW_TYPE_BOOLEAN, fr_tls_conf_t, check_crl), .dflt = "no" },
+ { 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" },
#ifdef X509_V_FLAG_CRL_CHECK_ALL
- { FR_CONF_DEPRECATED("check_all_crl", PW_TYPE_BOOLEAN, fr_tls_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("check_all_crl", FR_TYPE_BOOLEAN, fr_tls_conf_t, NULL) },
#endif
- { FR_CONF_OFFSET("allow_expired_crl", PW_TYPE_BOOLEAN, fr_tls_conf_t, allow_expired_crl) },
- { FR_CONF_OFFSET("check_cert_cn", PW_TYPE_STRING, fr_tls_conf_t, check_cert_cn) },
- { FR_CONF_OFFSET("cipher_list", PW_TYPE_STRING, fr_tls_conf_t, cipher_list) },
- { FR_CONF_OFFSET("cipher_server_preference", PW_TYPE_BOOLEAN, fr_tls_conf_t, cipher_server_preference), .dflt = "yes" },
+ { FR_CONF_OFFSET("allow_expired_crl", FR_TYPE_BOOLEAN, 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" },
#ifdef SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS
- { FR_CONF_OFFSET("allow_renegotiation", PW_TYPE_BOOLEAN, fr_tls_conf_t, allow_renegotiation), .dflt = "no" },
+ { FR_CONF_OFFSET("allow_renegotiation", FR_TYPE_BOOLEAN, fr_tls_conf_t, allow_renegotiation), .dflt = "no" },
#endif
- { FR_CONF_OFFSET("check_cert_issuer", PW_TYPE_STRING, fr_tls_conf_t, check_cert_issuer) },
- { FR_CONF_OFFSET("require_client_cert", PW_TYPE_BOOLEAN, fr_tls_conf_t, require_client_cert) },
+ { 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) },
#if OPENSSL_VERSION_NUMBER >= 0x0090800fL
#ifndef OPENSSL_NO_ECDH
- { FR_CONF_OFFSET("ecdh_curve", PW_TYPE_STRING, fr_tls_conf_t, ecdh_curve), .dflt = "prime256v1" },
+ { FR_CONF_OFFSET("ecdh_curve", FR_TYPE_STRING, fr_tls_conf_t, ecdh_curve), .dflt = "prime256v1" },
#endif
#endif
#ifdef SSL_OP_NO_TLSv1
- { FR_CONF_OFFSET("disable_tlsv1", PW_TYPE_BOOLEAN, fr_tls_conf_t, disable_tlsv1) },
+ { FR_CONF_OFFSET("disable_tlsv1", FR_TYPE_BOOLEAN, fr_tls_conf_t, disable_tlsv1) },
#endif
#ifdef SSL_OP_NO_TLSv1_1
- { FR_CONF_OFFSET("disable_tlsv1_1", PW_TYPE_BOOLEAN, fr_tls_conf_t, disable_tlsv1_1) },
+ { FR_CONF_OFFSET("disable_tlsv1_1", FR_TYPE_BOOLEAN, fr_tls_conf_t, disable_tlsv1_1) },
#endif
#ifdef SSL_OP_NO_TLSv1_2
- { FR_CONF_OFFSET("disable_tlsv1_2", PW_TYPE_BOOLEAN, fr_tls_conf_t, disable_tlsv1_2) },
+ { FR_CONF_OFFSET("disable_tlsv1_2", FR_TYPE_BOOLEAN, fr_tls_conf_t, disable_tlsv1_2) },
#endif
- { FR_CONF_POINTER("cache", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) cache_config },
+ { FR_CONF_POINTER("cache", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) cache_config },
- { FR_CONF_POINTER("verify", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) verify_config },
+ { FR_CONF_POINTER("verify", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) verify_config },
#ifdef HAVE_OPENSSL_OCSP_H
- { FR_CONF_OFFSET("ocsp", PW_TYPE_SUBSECTION, fr_tls_conf_t, ocsp), .subcs = (void const *) ocsp_config },
+ { FR_CONF_OFFSET("ocsp", FR_TYPE_SUBSECTION, fr_tls_conf_t, ocsp), .subcs = (void const *) ocsp_config },
- { FR_CONF_OFFSET("staple", PW_TYPE_SUBSECTION, fr_tls_conf_t, staple), .subcs = (void const *) ocsp_config },
+ { FR_CONF_OFFSET("staple", FR_TYPE_SUBSECTION, fr_tls_conf_t, staple), .subcs = (void const *) ocsp_config },
#endif
CONF_PARSER_TERMINATOR
};
static CONF_PARSER tls_client_config[] = {
- { FR_CONF_OFFSET("verify_depth", PW_TYPE_INTEGER, fr_tls_conf_t, verify_depth), .dflt = "0" },
- { FR_CONF_OFFSET("ca_path", PW_TYPE_FILE_INPUT, fr_tls_conf_t, ca_path) },
- { FR_CONF_OFFSET("pem_file_type", PW_TYPE_BOOLEAN, fr_tls_conf_t, file_type), .dflt = "yes" },
- { FR_CONF_OFFSET("private_key_file", PW_TYPE_FILE_INPUT, fr_tls_conf_t, private_key_file) },
- { FR_CONF_OFFSET("certificate_file", PW_TYPE_FILE_INPUT, fr_tls_conf_t, certificate_file) },
- { FR_CONF_OFFSET("ca_file", PW_TYPE_FILE_INPUT, fr_tls_conf_t, ca_file) },
- { FR_CONF_OFFSET("private_key_password", PW_TYPE_STRING | PW_TYPE_SECRET, fr_tls_conf_t, private_key_password) },
- { FR_CONF_OFFSET("dh_file", PW_TYPE_STRING, fr_tls_conf_t, dh_file) },
- { FR_CONF_OFFSET("random_file", PW_TYPE_STRING, fr_tls_conf_t, random_file) },
- { FR_CONF_OFFSET("fragment_size", PW_TYPE_INTEGER, fr_tls_conf_t, fragment_size), .dflt = "1024" },
- { FR_CONF_OFFSET("check_crl", PW_TYPE_BOOLEAN, fr_tls_conf_t, check_crl), .dflt = "no" },
- { FR_CONF_OFFSET("check_cert_cn", PW_TYPE_STRING, fr_tls_conf_t, check_cert_cn) },
- { FR_CONF_OFFSET("cipher_list", PW_TYPE_STRING, fr_tls_conf_t, cipher_list) },
- { FR_CONF_OFFSET("check_cert_issuer", PW_TYPE_STRING, fr_tls_conf_t, check_cert_issuer) },
+ { FR_CONF_OFFSET("verify_depth", FR_TYPE_INTEGER, 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("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("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) },
#if OPENSSL_VERSION_NUMBER >= 0x0090800fL
#ifndef OPENSSL_NO_ECDH
- { FR_CONF_OFFSET("ecdh_curve", PW_TYPE_STRING, fr_tls_conf_t, ecdh_curve), .dflt = "prime256v1" },
+ { FR_CONF_OFFSET("ecdh_curve", FR_TYPE_STRING, fr_tls_conf_t, ecdh_curve), .dflt = "prime256v1" },
#endif
#endif
#ifdef SSL_OP_NO_TLSv1
- { FR_CONF_OFFSET("disable_tlsv1", PW_TYPE_BOOLEAN, fr_tls_conf_t, disable_tlsv1) },
+ { FR_CONF_OFFSET("disable_tlsv1", FR_TYPE_BOOLEAN, fr_tls_conf_t, disable_tlsv1) },
#endif
#ifdef SSL_OP_NO_TLSv1_1
- { FR_CONF_OFFSET("disable_tlsv1_1", PW_TYPE_BOOLEAN, fr_tls_conf_t, disable_tlsv1_1) },
+ { FR_CONF_OFFSET("disable_tlsv1_1", FR_TYPE_BOOLEAN, fr_tls_conf_t, disable_tlsv1_1) },
#endif
#ifdef SSL_OP_NO_TLSv1_2
- { FR_CONF_OFFSET("disable_tlsv1_2", PW_TYPE_BOOLEAN, fr_tls_conf_t, disable_tlsv1_2) },
+ { FR_CONF_OFFSET("disable_tlsv1_2", FR_TYPE_BOOLEAN, fr_tls_conf_t, disable_tlsv1_2) },
#endif
CONF_PARSER_TERMINATOR
};
vpt = talloc(ctx, vp_tmpl_t);
name = value_box_asprint(vpt, data, '\0');
tmpl_init(vpt, TMPL_TYPE_DATA, name, talloc_array_length(name),
- (data->type == PW_TYPE_STRING) ? T_SINGLE_QUOTED_STRING : T_BARE_WORD);
+ (data->type == FR_TYPE_STRING) ? T_SINGLE_QUOTED_STRING : T_BARE_WORD);
if (steal) {
if (value_box_steal(vpt, &vpt->tmpl_value_box, data) < 0) {
char quote;
char const *p;
ssize_t slen;
- PW_TYPE data_type = PW_TYPE_STRING;
+ fr_type_t data_type = FR_TYPE_STRING;
vp_tmpl_t *vpt = NULL;
value_box_t data;
vpt = tmpl_alloc(ctx, TMPL_TYPE_DATA, in, inlen, type);
vpt->tmpl_value_box_datum.ptr = talloc_array(vpt, uint8_t, binlen);
vpt->tmpl_value_box_length = binlen;
- vpt->tmpl_value_box_type = PW_TYPE_OCTETS;
+ vpt->tmpl_value_box_type = FR_TYPE_OCTETS;
len = fr_hex2bin(vpt->tmpl_value_box_datum.ptr, binlen, in + 2, inlen - 2);
if (len != binlen) {
/** @name Cast or convert #vp_tmpl_t
*
* #tmpl_cast_in_place can be used to convert #TMPL_TYPE_UNPARSED to a #TMPL_TYPE_DATA of a
- * specified #PW_TYPE.
+ * specified #fr_type_t.
*
* #tmpl_cast_in_place_str does the same as #tmpl_cast_in_place, but will always convert to
- * #PW_TYPE #PW_TYPE_STRING.
+ * #fr_type_t #FR_TYPE_STRING.
*
* #tmpl_cast_to_vp does the same as #tmpl_cast_in_place, but outputs a #VALUE_PAIR.
*
* - 0 on success.
* - -1 on failure.
*/
-int tmpl_cast_in_place(vp_tmpl_t *vpt, PW_TYPE type, fr_dict_attr_t const *enumv)
+int tmpl_cast_in_place(vp_tmpl_t *vpt, fr_type_t type, fr_dict_attr_t const *enumv)
{
VERIFY_TMPL(vpt);
* Free old value buffers
*/
switch (vpt->tmpl_value_box_type) {
- case PW_TYPE_STRING:
- case PW_TYPE_OCTETS:
+ case FR_TYPE_STRING:
+ case FR_TYPE_OCTETS:
talloc_free(vpt->tmpl_value_box_datum.ptr);
break;
return 0;
}
-/** Convert #vp_tmpl_t of type #TMPL_TYPE_UNPARSED to #TMPL_TYPE_DATA of type #PW_TYPE_STRING
+/** Convert #vp_tmpl_t of type #TMPL_TYPE_UNPARSED to #TMPL_TYPE_DATA of type #FR_TYPE_STRING
*
* @note Conversion is done in place.
*
rad_assert(vpt->tmpl_value_box_datum.strvalue != NULL);
vpt->type = TMPL_TYPE_DATA;
- vpt->tmpl_value_box_type = PW_TYPE_STRING;
+ vpt->tmpl_value_box_type = FR_TYPE_STRING;
vpt->tmpl_value_box_length = talloc_array_length(vpt->tmpl_value_box_datum.strvalue) - 1;
}
/*
* New escapes: strings are in binary form.
*/
- if (vp->vp_type == PW_TYPE_STRING) {
+ if (vp->vp_type == FR_TYPE_STRING) {
vp->data.datum.ptr = talloc_steal(vp, data.datum.ptr);
vp->vp_length = rcode;
} else if (fr_pair_value_from_str(vp, data.datum.strvalue, rcode) < 0) {
* - 0 on success.
* - -1 on failure.
*/
-int tmpl_define_undefined_attr(vp_tmpl_t *vpt, PW_TYPE type, fr_dict_attr_flags_t const *flags)
+int tmpl_define_undefined_attr(vp_tmpl_t *vpt, fr_type_t type, fr_dict_attr_flags_t const *flags)
{
fr_dict_attr_t const *da;
*
* The intended use of #tmpl_expand and #tmpl_aexpand is for modules to easily convert a #vp_tmpl_t
* provided by the conf parser, into a usable value.
- * The value returned should be raw and undoctored for #PW_TYPE_STRING and #PW_TYPE_OCTETS types,
+ * The value returned should be raw and undoctored for #FR_TYPE_STRING and #FR_TYPE_OCTETS types,
* and the printable (string) version of the data for all others.
*
* Depending what arguments are passed, either copies the value to buff, or writes a pointer
* - #TMPL_TYPE_DATA
* @param[in] escape xlat escape function (only used for xlat types).
* @param[in] escape_ctx xlat escape function data.
- * @param dst_type PW_TYPE_* matching out pointer. @see tmpl_expand.
+ * @param dst_type FR_TYPE_* matching out pointer. @see tmpl_expand.
* @return
* - -1 on failure.
* - The length of data written to buff, or pointed to by out.
REQUEST *request,
vp_tmpl_t const *vpt,
xlat_escape_t escape, void const *escape_ctx,
- PW_TYPE dst_type)
+ fr_type_t dst_type)
{
value_box_t value_to_cast;
value_box_t value_from_cast;
VALUE_PAIR *vp = NULL;
- PW_TYPE src_type = PW_TYPE_STRING;
+ fr_type_t src_type = FR_TYPE_STRING;
ssize_t slen = -1; /* quiet compiler */
* Deal with casts.
*/
switch (src_type) {
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
switch (dst_type) {
- case PW_TYPE_STRING:
- case PW_TYPE_OCTETS:
+ case FR_TYPE_STRING:
+ case FR_TYPE_OCTETS:
from_cast = to_cast;
break;
}
break;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
switch (dst_type) {
/*
* Need to use the expansion buffer for this conversion as
* we need to add a \0 terminator.
*/
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
if (!buff) {
fr_strerror_printf("Missing expansion buffer for octet->string cast");
return -1;
/*
* Just copy the pointer. Length does not include \0.
*/
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
from_cast = to_cast;
break;
* that works with buffers, but it's not a high priority...
*/
switch (dst_type) {
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
if (!buff) {
fr_strerror_printf("Missing expansion buffer to store cast output");
error:
value_from_cast.datum.strvalue = (char *)buff;
break;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
if (!buff) {
fr_strerror_printf("Missing expansion buffer to store cast output");
goto error;
*
* The intended use of #tmpl_expand and #tmpl_aexpand is for modules to easily convert a #vp_tmpl_t
* provided by the conf parser, into a usable value.
- * The value returned should be raw and undoctored for #PW_TYPE_STRING and #PW_TYPE_OCTETS types,
+ * The value returned should be raw and undoctored for #FR_TYPE_STRING and #FR_TYPE_OCTETS types,
* and the printable (string) version of the data for all others.
*
* This function will always duplicate values, whereas #tmpl_expand may return a pointer to an
* - #TMPL_TYPE_DATA
* @param escape xlat escape function (only used for TMPL_TYPE_XLAT_* types).
* @param escape_ctx xlat escape function data (only used for TMPL_TYPE_XLAT_* types).
- * @param dst_type PW_TYPE_* matching out pointer. @see tmpl_aexpand.
+ * @param dst_type FR_TYPE_* matching out pointer. @see tmpl_aexpand.
* @return
* - -1 on failure.
* - The length of data written to buff, or pointed to by out.
REQUEST *request,
vp_tmpl_t const *vpt,
xlat_escape_t escape, void const *escape_ctx,
- PW_TYPE dst_type)
+ fr_type_t dst_type)
{
value_box_t const *to_cast = NULL;
value_box_t from_cast;
value.datum.length = vpt->len;
value.datum.strvalue = vpt->name;
- value.type = PW_TYPE_STRING;
+ value.type = FR_TYPE_STRING;
to_cast = &value;
needs_dup = true;
break;
return slen;
}
value.datum.length = strlen(value.datum.strvalue);
- value.type = PW_TYPE_STRING;
+ value.type = FR_TYPE_STRING;
MEM(value.datum.strvalue = talloc_realloc(tmp_ctx, value.datum.ptr, char, value.datum.length + 1)); /* Trim */
rad_assert(value.datum.strvalue[value.datum.length] == '\0');
to_cast = &value;
case TMPL_TYPE_XLAT:
{
value_box_t tmp;
- PW_TYPE src_type = PW_TYPE_STRING;
+ fr_type_t src_type = FR_TYPE_STRING;
RDEBUG4("EXPAND TMPL XLAT");
value.datum.strvalue = tmp.datum.strvalue;
value.datum.length = tmp.datum.length;
- value.type = PW_TYPE_STRING;
+ value.type = FR_TYPE_STRING;
to_cast = &value;
}
break;
case TMPL_TYPE_XLAT_STRUCT:
{
value_box_t tmp;
- PW_TYPE src_type = PW_TYPE_STRING;
+ fr_type_t src_type = FR_TYPE_STRING;
RDEBUG4("EXPAND TMPL XLAT STRUCT");
RDEBUG2("EXPAND %s", vpt->name); /* xlat_struct doesn't do this */
value.datum.strvalue = tmp.datum.strvalue;
value.datum.length = tmp.datum.length;
- value.type = PW_TYPE_STRING;
+ value.type = FR_TYPE_STRING;
to_cast = &value;
RDEBUG2(" --> %s", value.datum.strvalue); /* Print post-unescaping */
to_cast = &vp->data;
switch (to_cast->type) {
- case PW_TYPE_STRING:
- case PW_TYPE_OCTETS:
+ case FR_TYPE_STRING:
+ case FR_TYPE_OCTETS:
rad_assert(to_cast->datum.ptr);
needs_dup = true;
break;
to_cast = &vpt->tmpl_value_box;
switch (to_cast->type) {
- case PW_TYPE_STRING:
- case PW_TYPE_OCTETS:
+ case FR_TYPE_STRING:
+ case FR_TYPE_OCTETS:
rad_assert(to_cast->datum.ptr);
needs_dup = true;
break;
if (ret < 0) goto error;
} else {
switch (to_cast->type) {
- case PW_TYPE_OCTETS:
- case PW_TYPE_STRING:
+ case FR_TYPE_OCTETS:
+ case FR_TYPE_STRING:
/*
* Ensure we don't free the output buffer when the
* tmp_ctx is freed.
if (!fr_cond_assert(0)) fr_exit_now(1);
}
- if ((da->type == PW_TYPE_COMBO_IP_ADDR) && (da->type != vpt->tmpl_da->type)) {
+ if ((da->type == FR_TYPE_COMBO_IP_ADDR) && (da->type != vpt->tmpl_da->type)) {
da = fr_dict_attr_by_type(vpt->tmpl_da, vpt->tmpl_da->type);
if (!da) {
FR_FAULT_LOG("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_ATTR "
if (!fr_cond_assert(0)) fr_exit_now(1);
}
- if (vpt->tmpl_value_box_type == PW_TYPE_INVALID) {
+ if (vpt->tmpl_value_box_type == FR_TYPE_INVALID) {
FR_FAULT_LOG("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_DATA type was "
- "PW_TYPE_INVALID (uninitialised)", file, line);
+ "FR_TYPE_INVALID (uninitialised)", file, line);
if (!fr_cond_assert(0)) fr_exit_now(1);
}
- if (vpt->tmpl_value_box_type >= PW_TYPE_MAX) {
+ if (vpt->tmpl_value_box_type >= FR_TYPE_MAX) {
FR_FAULT_LOG("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_DATA type was "
- "%i (outside the range of PW_TYPEs)", file, line, vpt->tmpl_value_box_type);
+ "%i (outside the range of fr_type_ts)", file, line, vpt->tmpl_value_box_type);
if (!fr_cond_assert(0)) fr_exit_now(1);
}
/*
* be talloced. They may be allocated on the stack or in global variables.
*/
switch (vpt->tmpl_value_box_type) {
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
if (vpt->tmpl_value_box_datum.strvalue[vpt->tmpl_value_box_length] != '\0') {
FR_FAULT_LOG("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_DATA char buffer not \\0 "
"terminated", file, line);
}
break;
- case PW_TYPE_TLV:
+ case FR_TYPE_TLV:
FR_FAULT_LOG("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_DATA is of type TLV",
file, line);
if (!fr_cond_assert(0)) fr_exit_now(1);
talloc_free(q);
vp->vp_octets = talloc_steal(vp, p);
- vp->data.type = PW_TYPE_OCTETS;
+ vp->data.type = FR_TYPE_OCTETS;
vp->type = VT_DATA;
VERIFY_VP(vp);
for (i = 0; variables[i].name != NULL; i++) {
int ret;
- if (PW_BASE_TYPE(variables[i].type) == PW_TYPE_SUBSECTION) continue;
+ if (PW_BASE_TYPE(variables[i].type) == FR_TYPE_SUBSECTION) continue;
/* else it's a CONF_PAIR */
/*
(map->rhs->type == TMPL_TYPE_UNPARSED)) {
if ((map->rhs->len > 0) ||
(map->op != T_OP_CMP_EQ) ||
- (map->lhs->tmpl_da->type == PW_TYPE_STRING) ||
- (map->lhs->tmpl_da->type == PW_TYPE_OCTETS)) {
+ (map->lhs->tmpl_da->type == FR_TYPE_STRING) ||
+ (map->lhs->tmpl_da->type == FR_TYPE_OCTETS)) {
if (tmpl_cast_in_place(map->rhs, map->lhs->tmpl_da->type, map->lhs->tmpl_da) < 0) {
cf_log_err(map->ci, "Failed to parse data type %s from string: %s",
* select which frame is being used.
*/
if ((g->vpt->type == TMPL_TYPE_ATTR) &&
- ((g->vpt->tmpl_da->type == PW_TYPE_BYTE) ||
- (g->vpt->tmpl_da->type == PW_TYPE_SHORT) ||
- (g->vpt->tmpl_da->type == PW_TYPE_INTEGER) ||
- (g->vpt->tmpl_da->type == PW_TYPE_INTEGER64))) {
+ ((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))) {
VALUE_PAIR *vp;
slen = tmpl_find_vp(&vp, request, g->vpt);
}
switch (g->vpt->tmpl_da->type) {
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
start = ((uint32_t) vp->vp_byte) % g->num_children;
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
start = ((uint32_t) vp->vp_short) % g->num_children;
break;
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
start = vp->vp_integer % g->num_children;
break;
- case PW_TYPE_INTEGER64:
+ case FR_TYPE_INTEGER64:
start = (uint32_t) (vp->vp_integer64 % ((uint64_t) g->num_children));
break;
* This is really the reverse of fr_snprint().
*/
if (*child) {
- PW_TYPE type;
+ fr_type_t type;
value_box_t data;
- type = PW_TYPE_STRING;
+ type = FR_TYPE_STRING;
if (value_box_from_str(ctx, &data, &type, NULL, child,
talloc_array_length(child) - 1, '"') < 0) {
talloc_free(child);
if ((radius_get_vp(&vp, request, fmt) < 0) || !vp) return 0;
switch (vp->vp_type) {
- case PW_TYPE_OCTETS:
- case PW_TYPE_STRING:
+ case FR_TYPE_OCTETS:
+ case FR_TYPE_STRING:
if (vp->vp_length > 8) {
break;
}
memcpy(&int32, vp->vp_octets, vp->vp_length);
return snprintf(*out, outlen, "%i", htonl(int32));
- case PW_TYPE_INTEGER64:
+ case FR_TYPE_INTEGER64:
return snprintf(*out, outlen, "%" PRIu64, vp->vp_integer64);
/*
* IP addresses are treated specially, as parsing functions assume the value
* is bigendian and will convert it for us.
*/
- case PW_TYPE_IPV4_ADDR:
- case PW_TYPE_IPV4_PREFIX: /* Same addr field */
+ case FR_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_PREFIX: /* Same addr field */
return snprintf(*out, outlen, "%u", htonl(vp->vp_ipv4addr));
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
return snprintf(*out, outlen, "%u", vp->vp_integer);
- case PW_TYPE_DATE:
+ case FR_TYPE_DATE:
return snprintf(*out, outlen, "%u", vp->vp_date);
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
return snprintf(*out, outlen, "%u", (unsigned int) vp->vp_byte);
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
return snprintf(*out, outlen, "%u", (unsigned int) vp->vp_short);
/*
* Ethernet is weird... It's network related, so we assume to it should be
* bigendian.
*/
- case PW_TYPE_ETHERNET:
+ case FR_TYPE_ETHERNET:
memcpy(&int64, vp->vp_ether, sizeof(vp->vp_ether));
return snprintf(*out, outlen, "%" PRIu64, htonll(int64));
- case PW_TYPE_SIGNED:
+ case FR_TYPE_SIGNED:
return snprintf(*out, outlen, "%i", vp->vp_signed);
- case PW_TYPE_IPV6_ADDR:
- case PW_TYPE_IPV6_PREFIX:
+ case FR_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_PREFIX:
return fr_snprint_uint128(*out, outlen, ntohlll(*(uint128_t const *) &vp->vp_ipv6addr));
default:
/*
* The easy case.
*/
- if (vp->vp_type == PW_TYPE_OCTETS) {
+ if (vp->vp_type == FR_TYPE_OCTETS) {
p = vp->vp_octets;
len = vp->vp_length;
/*
* print that as hex.
*/
} else {
- if (value_box_cast(request, &dst, PW_TYPE_OCTETS, NULL, &vp->data) < 0) {
+ if (value_box_cast(request, &dst, FR_TYPE_OCTETS, NULL, &vp->data) < 0) {
REDEBUG("%s", fr_strerror());
goto error;
}
RIDEBUG2("Type : %s", fr_int2str(dict_attr_types, vp->vp_type, "<INVALID>"));
switch (vp->vp_type) {
- case PW_TYPE_VARIABLE_SIZE:
+ case FR_TYPE_VARIABLE_SIZE:
RIDEBUG2("Length : %zu", vp->vp_length);
break;
value_box_t *dst = NULL;
- if ((PW_TYPE) type->number == vp->vp_type) goto next_type;
+ if ((fr_type_t) type->number == vp->vp_type) goto next_type;
switch (type->number) {
- case PW_TYPE_INVALID: /* Not real type */
- case PW_TYPE_MAX: /* Not real type */
- case PW_TYPE_COMBO_IP_ADDR: /* Covered by IPv4 address IPv6 address */
- case PW_TYPE_COMBO_IP_PREFIX: /* Covered by IPv4 address IPv6 address */
- case PW_TYPE_TIMEVAL: /* Not a VALUE_PAIR type */
- case PW_TYPE_STRUCTURAL:
+ case FR_TYPE_INVALID: /* Not real type */
+ case FR_TYPE_MAX: /* Not real type */
+ case FR_TYPE_COMBO_IP_ADDR: /* Covered by IPv4 address IPv6 address */
+ case FR_TYPE_COMBO_IP_PREFIX: /* Covered by IPv4 address IPv6 address */
+ case FR_TYPE_TIMEVAL: /* Not a VALUE_PAIR type */
+ case FR_TYPE_STRUCTURAL:
goto next_type;
default:
* These are printed specially.
*/
switch (vp->vp_type) {
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
return fr_snprint(*out, outlen, (char const *) vp->vp_octets, vp->vp_length, '"');
/*
* Note that "%{string:...}" is NOT binary safe!
* It is explicitly used to get rid of embedded zeros.
*/
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
return strlcpy(*out, vp->vp_strvalue, outlen);
default:
/*
* If it's a string, expand it again
*/
- if (vp->vp_type == PW_TYPE_STRING) {
+ if (vp->vp_type == FR_TYPE_STRING) {
slen = xlat_eval(*out, outlen, request, vp->vp_strvalue, NULL, NULL);
if (slen <= 0) return slen;
/*
size_t len;
char const *value = NULL;
- rcode = cf_pair_parse(NULL, cs, "secret", FR_ITEM_POINTER(PW_TYPE_STRING, &value), NULL, T_INVALID);
+ rcode = cf_pair_parse(NULL, cs, "secret", FR_ITEM_POINTER(FR_TYPE_STRING, &value), NULL, T_INVALID);
if (rcode != 0) return 0;
len = strlen(value);
/*
* Allow over-riding of variables per session.
*/
- rcode = cf_pair_parse(NULL, cs, "demand", FR_ITEM_POINTER(PW_TYPE_BOOLEAN, &flag), NULL, T_INVALID);
+ rcode = cf_pair_parse(NULL, cs, "demand", FR_ITEM_POINTER(FR_TYPE_BOOLEAN, &flag), NULL, T_INVALID);
if (rcode == 0) {
session->demand_mode = flag;
}
- rcode = cf_pair_parse(NULL, cs, "min_transmit_interval", FR_ITEM_POINTER(PW_TYPE_INTEGER, &number), NULL, T_INVALID);
+ rcode = cf_pair_parse(NULL, cs, "min_transmit_interval", FR_ITEM_POINTER(FR_TYPE_INTEGER, &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(PW_TYPE_INTEGER, &number), NULL, T_INVALID);
+ rcode = cf_pair_parse(NULL, cs, "min_receive_interval", FR_ITEM_POINTER(FR_TYPE_INTEGER, &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(PW_TYPE_INTEGER, &number), NULL, T_INVALID);
+ rcode = cf_pair_parse(NULL, cs, "max_timeouts", FR_ITEM_POINTER(FR_TYPE_INTEGER, &number), NULL, T_INVALID);
if (rcode == 0) {
if (number == 0) number = 1;
if (number > 10) number = 10;
*/
memset(ipaddr, 0, sizeof(*ipaddr));
ipaddr->addr.v4.s_addr = htonl(INADDR_NONE);
- rcode = cf_pair_parse(NULL, cs, "ipaddr", FR_ITEM_POINTER(PW_TYPE_IPV4_ADDR, ipaddr), NULL, T_INVALID);
+ rcode = cf_pair_parse(NULL, cs, "ipaddr", FR_ITEM_POINTER(FR_TYPE_IPV4_ADDR, ipaddr), NULL, T_INVALID);
if (rcode < 0) return -1;
if (rcode == 0) { /* successfully parsed IPv4 */
ipaddr->af = AF_INET;
} else { /* maybe IPv6? */
- rcode = cf_pair_parse(NULL, cs, "ipv6addr", FR_ITEM_POINTER(PW_TYPE_IPV6_ADDR, ipaddr), NULL, T_INVALID);
+ rcode = cf_pair_parse(NULL, cs, "ipv6addr", FR_ITEM_POINTER(FR_TYPE_IPV6_ADDR, ipaddr), NULL, T_INVALID);
if (rcode < 0) return -1;
if (rcode == 1) {
ipaddr->af = AF_INET6;
}
- rcode = cf_pair_parse(NULL, cs, "port", FR_ITEM_POINTER(PW_TYPE_SHORT, port), "0", T_INVALID);
+ rcode = cf_pair_parse(NULL, cs, "port", FR_ITEM_POINTER(FR_TYPE_SHORT, port), "0", T_INVALID);
if (rcode < 0) return -1;
return 0;
sock->my_ipaddr = ipaddr;
sock->my_port = listen_port;
- cf_pair_parse(sock, cs, "interface", FR_ITEM_POINTER(PW_TYPE_STRING, &sock->interface), NULL, T_INVALID);
+ 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(PW_TYPE_INTEGER, &sock->min_rx_interval), "1000", T_BARE_WORD);
- cf_pair_parse(sock, cs, "max_timeouts", FR_ITEM_POINTER(PW_TYPE_INTEGER, &sock->max_timeouts), "3", T_BARE_WORD);
- cf_pair_parse(sock, cs, "demand", FR_ITEM_POINTER(PW_TYPE_BOOLEAN, &sock->demand), "no", T_DOUBLE_QUOTED_STRING);
- cf_pair_parse(NULL, cs, "auth_type", FR_ITEM_POINTER(PW_TYPE_STRING, &auth_type_str), 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(NULL, cs, "auth_type", FR_ITEM_POINTER(FR_TYPE_STRING, &auth_type_str), NULL, T_INVALID);
if (!this->server) {
- cf_pair_parse(sock, cs, "server", FR_ITEM_POINTER(PW_TYPE_STRING, &sock->server), NULL, T_INVALID);
+ cf_pair_parse(sock, cs, "server", FR_ITEM_POINTER(FR_TYPE_STRING, &sock->server), NULL, T_INVALID);
} else {
sock->server = this->server;
}
static const CONF_PARSER detail_config[] = {
- { FR_CONF_OFFSET("detail", PW_TYPE_FILE_OUTPUT | PW_TYPE_DEPRECATED, listen_detail_t, filename) },
- { FR_CONF_OFFSET("filename", PW_TYPE_FILE_OUTPUT | PW_TYPE_REQUIRED, listen_detail_t, filename) },
- { FR_CONF_OFFSET("load_factor", PW_TYPE_INTEGER, listen_detail_t, load_factor), .dflt = STRINGIFY(10) },
- { FR_CONF_OFFSET("poll_interval", PW_TYPE_INTEGER, listen_detail_t, poll_interval), .dflt = STRINGIFY(1) },
- { FR_CONF_OFFSET("retry_interval", PW_TYPE_INTEGER, listen_detail_t, retry_interval), .dflt = STRINGIFY(30) },
- { FR_CONF_OFFSET("one_shot", PW_TYPE_BOOLEAN, listen_detail_t, one_shot), .dflt = "no" },
- { FR_CONF_OFFSET("track", PW_TYPE_BOOLEAN, listen_detail_t, track), .dflt = "no" },
+ { 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" },
CONF_PARSER_TERMINATOR
};
* Could be an array of bytes, integers, etc.
*/
if (da->flags.array) switch (da->type) {
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
num_entries = len;
*out = 1;
break;
- case PW_TYPE_SHORT: /* ignore any trailing data */
+ case FR_TYPE_SHORT: /* ignore any trailing data */
num_entries = len >> 1;
*out = 2;
break;
- case PW_TYPE_IPV4_ADDR:
- case PW_TYPE_INTEGER:
- case PW_TYPE_DATE: /* ignore any trailing data */
+ case FR_TYPE_IPV4_ADDR:
+ case FR_TYPE_INTEGER:
+ case FR_TYPE_DATE: /* ignore any trailing data */
num_entries = len >> 2;
*out = 4;
break;
- case PW_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_ADDR:
num_entries = len >> 4;
*out = 16;
break;
if (da->flags.is_unknown) talloc_steal(vp, da);
switch (da->type) {
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
if (data_len != 1) goto raw;
vp->vp_byte = p[0];
p++;
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
if (data_len != 2) goto raw;
memcpy(&vp->vp_short, p, 2);
vp->vp_short = ntohs(vp->vp_short);
p += 2;
break;
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
if (data_len != 4) goto raw;
memcpy(&vp->vp_integer, p, 4);
vp->vp_integer = ntohl(vp->vp_integer);
p += 4;
break;
- case PW_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_ADDR:
if (data_len != 4) goto raw;
/*
* Keep value in Network Order!
p += 4;
break;
- case PW_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_ADDR:
if (data_len != 16) goto raw;
/*
* Keep value in Network Order!
* In DHCPv4, string options which can also be arrays,
* have their values '\0' delimited.
*/
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
{
uint8_t const *q, *end;
}
break;
- case PW_TYPE_ETHERNET:
+ case FR_TYPE_ETHERNET:
memcpy(vp->vp_ether, data, sizeof(vp->vp_ether));
p += sizeof(vp->vp_ether);
break;
FR_PROTO_TRACE("decoding as unknown type");
if (fr_pair_to_unknown(vp) < 0) return -1;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
if (data_len > UINT8_MAX) return -1;
fr_pair_value_memcpy(vp, data, data_len);
p += data_len;
/*
* TLVs can't be coalesced as they're variable length
*/
- if (parent->type == PW_TYPE_TLV) return decode_tlv(ctx, cursor, parent, data, data_len);
+ if (parent->type == FR_TYPE_TLV) return decode_tlv(ctx, cursor, parent, data, data_len);
/*
* Values with a fixed length may be coalesced into a single option
}
switch (vp->vp_type) {
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
vp->vp_byte = p[0];
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
vp->vp_short = (p[0] << 8) | p[1];
break;
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
memcpy(&vp->vp_integer, p, 4);
vp->vp_integer = ntohl(vp->vp_integer);
break;
- case PW_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_ADDR:
memcpy(&vp->vp_ipv4addr, p, 4);
break;
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
/*
* According to RFC 2131, these are null terminated strings.
* We don't trust everyone to abide by the RFC, though.
if (vp->vp_length == 0) fr_pair_list_free(&vp);
break;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
if (packet->data[2] == 0) break;
fr_pair_value_memcpy(vp, p, packet->data[2]);
break;
- case PW_TYPE_ETHERNET:
+ case FR_TYPE_ETHERNET:
memcpy(vp->vp_ether, p, sizeof(vp->vp_ether));
break;
/*
* DHCP-Message-Type is first, for simplicity.
*/
- if (((my_a->da->parent->type != PW_TYPE_TLV) && (my_a->da->attr == PW_DHCP_MESSAGE_TYPE)) &&
- ((my_b->da->parent->type == PW_TYPE_TLV) || (my_b->da->attr != PW_DHCP_MESSAGE_TYPE))) return -1;
- if (((my_a->da->parent->type == PW_TYPE_TLV) || (my_a->da->attr != PW_DHCP_MESSAGE_TYPE)) &&
- ((my_b->da->parent->type != PW_TYPE_TLV) && (my_b->da->attr == PW_DHCP_MESSAGE_TYPE))) return +1;
+ if (((my_a->da->parent->type != FR_TYPE_TLV) && (my_a->da->attr == PW_DHCP_MESSAGE_TYPE)) &&
+ ((my_b->da->parent->type == FR_TYPE_TLV) || (my_b->da->attr != PW_DHCP_MESSAGE_TYPE))) return -1;
+ if (((my_a->da->parent->type == FR_TYPE_TLV) || (my_a->da->attr != PW_DHCP_MESSAGE_TYPE)) &&
+ ((my_b->da->parent->type != FR_TYPE_TLV) && (my_b->da->attr == PW_DHCP_MESSAGE_TYPE))) return +1;
/*
* Relay-Agent is last.
if (outlen < vp->vp_length) return 0;
switch (tlv_stack[depth]->type) {
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
p[0] = vp->vp_byte;
p ++;
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
p[0] = (vp->vp_short >> 8) & 0xff;
p[1] = vp->vp_short & 0xff;
p += 2;
break;
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
lvalue = htonl(vp->vp_integer);
memcpy(p, &lvalue, 4);
p += 4;
break;
- case PW_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_ADDR:
memcpy(p, &vp->vp_ipv4addr, 4);
p += 4;
break;
- case PW_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_ADDR:
memcpy(p, &vp->vp_ipv6addr, 16);
p += 16;
break;
- case PW_TYPE_ETHERNET:
+ case FR_TYPE_ETHERNET:
memcpy(p, vp->vp_ether, 6);
p += 6;
break;
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
memcpy(p, vp->vp_strvalue, vp->vp_length);
p += vp->vp_length;
break;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
memcpy(p, vp->vp_octets, vp->vp_length);
p += vp->vp_length;
break;
/*
* Determine the nested type and call the appropriate encoder
*/
- if (tlv_stack[depth + 1]->type == PW_TYPE_TLV) {
+ if (tlv_stack[depth + 1]->type == FR_TYPE_TLV) {
len = encode_tlv_hdr(p, outlen - out[1], tlv_stack, depth + 1, cursor);
} else {
len = encode_rfc_hdr(p, outlen - out[1], tlv_stack, depth + 1, cursor);
* We only have two types of options in DHCPv4
*/
switch (tlv_stack[depth]->type) {
- case PW_TYPE_TLV:
+ case FR_TYPE_TLV:
len = encode_tlv_hdr(out, outlen, tlv_stack, depth, cursor);
break;
/* DHCP-Client-Hardware-Address */
if ((vp = fr_pair_find_by_num(packet->vps, DHCP_MAGIC_VENDOR, 267, TAG_ANY))) {
- if (vp->vp_type == PW_TYPE_ETHERNET) {
+ if (vp->vp_type == FR_TYPE_ETHERNET) {
/*
* Ensure that we mark the packet as being Ethernet.
* This is mainly for DHCP-Lease-Query responses.
#endif
if (!fr_cond_assert(macaddr) ||
- !fr_cond_assert((macaddr->vp_type == PW_TYPE_ETHERNET) || (macaddr->vp_type == PW_TYPE_OCTETS))) {
+ !fr_cond_assert((macaddr->vp_type == FR_TYPE_ETHERNET) || (macaddr->vp_type == FR_TYPE_OCTETS))) {
fr_strerror_printf("Wrong VP type (%s) for chaddr",
fr_int2str(dict_attr_types, macaddr->vp_type, "<invalid>"));
return -1;
}
- if (macaddr->vp_type == PW_TYPE_OCTETS) {
+ if (macaddr->vp_type == FR_TYPE_OCTETS) {
if (macaddr->vp_length > sizeof(req.arp_ha.sa_data)) {
fr_strerror_printf("arp sa_data field too small (%zu octets) to contain chaddr (%zu octets)",
sizeof(req.arp_ha.sa_data), macaddr->vp_length);
strlcpy(req.arp_dev, interface, sizeof(req.arp_dev));
- if (macaddr->vp_type == PW_TYPE_ETHERNET) {
+ if (macaddr->vp_type == FR_TYPE_ETHERNET) {
memcpy(&req.arp_ha.sa_data, macaddr->vp_ether, sizeof(macaddr->vp_ether));
} else {
memcpy(&req.arp_ha.sa_data, macaddr->vp_octets, macaddr->vp_length);
/* set ethernet source address to our MAC address (DHCP-Client-Hardware-Address). */
uint8_t dhmac[ETH_ADDR_LEN] = { 0 };
if ((vp = fr_pair_find_by_num(packet->vps, 267, DHCP_MAGIC_VENDOR, TAG_ANY))) {
- if (vp->vp_type == PW_TYPE_ETHERNET) memcpy(dhmac, vp->vp_ether, sizeof(vp->vp_ether));
+ if (vp->vp_type == FR_TYPE_ETHERNET) memcpy(dhmac, vp->vp_ether, sizeof(vp->vp_ether));
}
/* fill in Ethernet layer (L2) */
*/
if ((memcmp(ð_bcast, ð_hdr->ether_dst, ETH_ADDR_LEN) != 0) &&
(vp = fr_pair_find_by_num(request->vps, 267, DHCP_MAGIC_VENDOR, TAG_ANY)) &&
- ((vp->vp_type == PW_TYPE_ETHERNET) && (memcmp(vp->vp_ether, ð_hdr->ether_dst, ETH_ADDR_LEN) != 0))) {
+ ((vp->vp_type == FR_TYPE_ETHERNET) && (memcmp(vp->vp_ether, ð_hdr->ether_dst, ETH_ADDR_LEN) != 0))) {
char eth_dest[17 + 1];
char eth_req_src[17 + 1];
cp = cf_pair_find(cs, "suppress_responses");
if (cp) {
rcode = cf_pair_parse(sock, cs, "suppress_responses",
- FR_ITEM_POINTER(PW_TYPE_BOOLEAN, &sock->suppress_responses), NULL, T_INVALID);
+ FR_ITEM_POINTER(FR_TYPE_BOOLEAN, &sock->suppress_responses), NULL, T_INVALID);
if (rcode < 0) return -1;
}
cp = cf_pair_find(cs, "src_interface");
if (cp) {
rcode = cf_pair_parse(sock, cs, "src_interface",
- FR_ITEM_POINTER(PW_TYPE_STRING, &sock->src_interface), NULL, T_INVALID);
+ FR_ITEM_POINTER(FR_TYPE_STRING, &sock->src_interface), NULL, T_INVALID);
if (rcode < 0) return -1;
} else {
sock->src_interface = sock->lsock.interface;
memset(&sock->src_ipaddr, 0, sizeof(sock->src_ipaddr));
sock->src_ipaddr.addr.v4.s_addr = htonl(INADDR_NONE);
rcode = cf_pair_parse(sock, cs, "src_ipaddr",
- FR_ITEM_POINTER(PW_TYPE_IPV4_ADDR, &sock->src_ipaddr), NULL, T_INVALID);
+ FR_ITEM_POINTER(FR_TYPE_IPV4_ADDR, &sock->src_ipaddr), NULL, T_INVALID);
if (rcode < 0) return -1;
sock->src_ipaddr.af = AF_INET;
goto error;
}
- if (src->tmpl_da->type != PW_TYPE_OCTETS) {
+ if (src->tmpl_da->type != FR_TYPE_OCTETS) {
REDEBUG("dhcp_options got a %s attribute needed octets",
fr_int2str(dict_attr_types, src->tmpl_da->type, "<INVALID>"));
goto error;
};
static CONF_PARSER sasl_mech_static[] = {
- { FR_CONF_OFFSET("mech", PW_TYPE_STRING | PW_TYPE_NOT_EMPTY, fr_ldap_sasl_t, mech) },
+ { FR_CONF_OFFSET("mech", FR_TYPE_STRING | FR_TYPE_NOT_EMPTY, fr_ldap_sasl_t, mech) },
- { FR_CONF_OFFSET("proxy", PW_TYPE_STRING, fr_ldap_sasl_t, proxy) },
+ { FR_CONF_OFFSET("proxy", FR_TYPE_STRING, fr_ldap_sasl_t, proxy) },
- { FR_CONF_OFFSET("realm", PW_TYPE_STRING, fr_ldap_sasl_t, realm) },
+ { FR_CONF_OFFSET("realm", FR_TYPE_STRING, fr_ldap_sasl_t, realm) },
CONF_PARSER_TERMINATOR
};
static CONF_PARSER ldap_sync_search_config[] = {
- { FR_CONF_OFFSET("base_dn", PW_TYPE_STRING, sync_config_t, base_dn), .dflt = "", .quote = T_SINGLE_QUOTED_STRING },
+ { FR_CONF_OFFSET("base_dn", FR_TYPE_STRING, sync_config_t, base_dn), .dflt = "", .quote = T_SINGLE_QUOTED_STRING },
- { FR_CONF_OFFSET("filter", PW_TYPE_STRING, sync_config_t, filter) },
+ { FR_CONF_OFFSET("filter", FR_TYPE_STRING, sync_config_t, filter) },
- { FR_CONF_OFFSET("scope", PW_TYPE_STRING, sync_config_t, scope_str), .dflt = "sub" },
+ { FR_CONF_OFFSET("scope", FR_TYPE_STRING, sync_config_t, scope_str), .dflt = "sub" },
- { FR_CONF_OFFSET("attrs", PW_TYPE_STRING | PW_TYPE_MULTI, sync_config_t, attrs) },
+ { FR_CONF_OFFSET("attrs", FR_TYPE_STRING | FR_TYPE_MULTI, sync_config_t, attrs) },
- { FR_CONF_OFFSET("allow_refresh", PW_TYPE_BOOLEAN, sync_config_t, allow_refresh), .dflt = "no" },
+ { FR_CONF_OFFSET("allow_refresh", FR_TYPE_BOOLEAN, 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", PW_TYPE_INTEGER, fr_ldap_handle_config_t, keepalive_idle), .dflt = "60" },
+ { FR_CONF_OFFSET("idle", FR_TYPE_INTEGER, fr_ldap_handle_config_t, keepalive_idle), .dflt = "60" },
#endif
#ifdef LDAP_OPT_X_KEEPALIVE_PROBES
- { FR_CONF_OFFSET("probes", PW_TYPE_INTEGER, fr_ldap_handle_config_t, keepalive_probes), .dflt = "3" },
+ { FR_CONF_OFFSET("probes", FR_TYPE_INTEGER, fr_ldap_handle_config_t, keepalive_probes), .dflt = "3" },
#endif
#ifdef LDAP_OPT_X_KEEPALIVE_INTERVAL
- { FR_CONF_OFFSET("interval", PW_TYPE_INTEGER, fr_ldap_handle_config_t, keepalive_interval), .dflt = "30" },
+ { FR_CONF_OFFSET("interval", FR_TYPE_INTEGER, fr_ldap_handle_config_t, keepalive_interval), .dflt = "30" },
#endif
- { FR_CONF_OFFSET("dereference", PW_TYPE_STRING, fr_ldap_handle_config_t, dereference_str) },
+ { 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", PW_TYPE_INTEGER, fr_ldap_handle_config_t, srv_timelimit), .dflt = "20" },
+ { FR_CONF_OFFSET("srv_timelimit", FR_TYPE_INTEGER, fr_ldap_handle_config_t, srv_timelimit), .dflt = "20" },
/* timeout for search results */
- { FR_CONF_OFFSET("res_timeout", PW_TYPE_TIMEVAL, fr_ldap_handle_config_t, res_timeout), .dflt = "20" },
+ { 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", PW_TYPE_INTEGER, fr_ldap_handle_config_t, net_timeout), .dflt = "10" },
+ { FR_CONF_DEPRECATED("net_timeout", FR_TYPE_INTEGER, fr_ldap_handle_config_t, net_timeout), .dflt = "10" },
#endif
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER global_config[] = {
- { FR_CONF_OFFSET("random_file", PW_TYPE_FILE_EXISTS, proto_ldap_inst_t, tls_random_file) },
- { FR_CONF_OFFSET("ldap_debug", PW_TYPE_INTEGER, proto_ldap_inst_t, ldap_debug), .dflt = "0x0000" }, /* Debugging flags to the server */
+ { 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 */
CONF_PARSER_TERMINATOR
};
* TLS Configuration
*/
static CONF_PARSER tls_config[] = {
- { FR_CONF_OFFSET("ca_file", PW_TYPE_FILE_INPUT, fr_ldap_handle_config_t, tls_ca_file) },
- { FR_CONF_OFFSET("ca_path", PW_TYPE_FILE_INPUT, fr_ldap_handle_config_t, tls_ca_path) },
- { FR_CONF_OFFSET("certificate_file", PW_TYPE_FILE_INPUT, fr_ldap_handle_config_t, tls_certificate_file) },
- { FR_CONF_OFFSET("private_key_file", PW_TYPE_FILE_INPUT, fr_ldap_handle_config_t, tls_private_key_file) },
- { FR_CONF_OFFSET("start_tls", PW_TYPE_BOOLEAN, fr_ldap_handle_config_t, start_tls), .dflt = "no" },
- { FR_CONF_OFFSET("require_cert", PW_TYPE_STRING, fr_ldap_handle_config_t, tls_require_cert_str) },
+ { FR_CONF_OFFSET("ca_file", FR_TYPE_FILE_INPUT, fr_ldap_handle_config_t, tls_ca_file) },
+ { 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("require_cert", FR_TYPE_STRING, fr_ldap_handle_config_t, tls_require_cert_str) },
CONF_PARSER_TERMINATOR
};
/*
* LDAP server definition
*/
- { FR_CONF_OFFSET("server", PW_TYPE_STRING | PW_TYPE_MULTI | PW_TYPE_REQUIRED, proto_ldap_inst_t, handle_config.server_str) },
- { FR_CONF_OFFSET("port", PW_TYPE_SHORT, proto_ldap_inst_t, handle_config.port) },
- { FR_CONF_OFFSET("identity", PW_TYPE_STRING, proto_ldap_inst_t, handle_config.admin_identity) },
- { FR_CONF_OFFSET("password", PW_TYPE_STRING | PW_TYPE_SECRET, proto_ldap_inst_t, handle_config.admin_password) },
- { FR_CONF_OFFSET("sasl", PW_TYPE_SUBSECTION, proto_ldap_inst_t, handle_config.admin_sasl), .subcs = (void const *) sasl_mech_static },
+ { 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("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 },
- { FR_CONF_OFFSET("sync_retry_interval", PW_TYPE_TIMEVAL, proto_ldap_inst_t, sync_retry_interval), .dflt = "5" },
- { FR_CONF_OFFSET("conn_retry_interval", PW_TYPE_TIMEVAL, proto_ldap_inst_t, conn_retry_interval), .dflt = "5" },
+ { FR_CONF_OFFSET("sync_retry_interval", FR_TYPE_TIMEVAL, proto_ldap_inst_t, sync_retry_interval), .dflt = "5" },
+ { FR_CONF_OFFSET("conn_retry_interval", FR_TYPE_TIMEVAL, proto_ldap_inst_t, conn_retry_interval), .dflt = "5" },
/*
* Areas of the DIT to listen on
*/
- { FR_CONF_SUBSECTION_MULTI("sync", PW_TYPE_SUBSECTION | PW_TYPE_MULTI | PW_TYPE_REQUIRED, proto_ldap_inst_t, sync_config, ldap_sync_search_config) },
+ { FR_CONF_SUBSECTION_MULTI("sync", FR_TYPE_SUBSECTION | FR_TYPE_MULTI | FR_TYPE_REQUIRED, proto_ldap_inst_t, sync_config, ldap_sync_search_config) },
/*
* Extra configuration items
*/
- { FR_CONF_POINTER("options", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) option_config },
- { FR_CONF_POINTER("global", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) global_config },
- { FR_CONF_OFFSET("tls", PW_TYPE_SUBSECTION, proto_ldap_inst_t, handle_config), .subcs = (void const *) tls_config },
+ { FR_CONF_POINTER("options", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) option_config },
+ { FR_CONF_POINTER("global", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) global_config },
+ { FR_CONF_OFFSET("tls", FR_TYPE_SUBSECTION, proto_ldap_inst_t, handle_config), .subcs = (void const *) tls_config },
CONF_PARSER_TERMINATOR
};
#define VQP_VERSION (1)
#define VQP_MAX_ATTRIBUTES (12)
-static size_t const fr_vqp_attr_sizes[PW_TYPE_MAX + 1][2] = {
- [PW_TYPE_INVALID] = {~0, 0}, //!< Ensure array starts at 0 (umm?)
+static size_t const fr_vqp_attr_sizes[FR_TYPE_MAX + 1][2] = {
+ [FR_TYPE_INVALID] = {~0, 0}, //!< Ensure array starts at 0 (umm?)
- [PW_TYPE_STRING] = {0, ~0},
- [PW_TYPE_OCTETS] = {0, ~0},
+ [FR_TYPE_STRING] = {0, ~0},
+ [FR_TYPE_OCTETS] = {0, ~0},
- [PW_TYPE_IPV4_ADDR] = {4, 4},
- [PW_TYPE_ETHERNET] = {6, 6},
+ [FR_TYPE_IPV4_ADDR] = {4, 4},
+ [FR_TYPE_ETHERNET] = {6, 6},
- [PW_TYPE_MAX] = {~0, 0} //!< Ensure array covers all types.
+ [FR_TYPE_MAX] = {~0, 0} //!< Ensure array covers all types.
};
static ssize_t vqp_recv_header(int sockfd)
}
switch (vp->vp_type) {
- case PW_TYPE_ETHERNET:
+ case FR_TYPE_ETHERNET:
if (attr_len != fr_vqp_attr_sizes[vp->vp_type][0]) goto unknown;
memcpy(&vp->vp_ether, ptr, 6);
break;
- case PW_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_ADDR:
if (attr_len == fr_vqp_attr_sizes[vp->vp_type][0]) {
memcpy(&vp->vp_ipv4addr, ptr, 4);
break;
/* FALL-THROUGH */
default:
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
fr_pair_value_memcpy(vp, ptr, attr_len);
break;
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
fr_pair_value_bstrncpy(vp, ptr, attr_len);
break;
}
debug_pair(vp);
switch (vp->vp_type) {
- case PW_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_ADDR:
len = fr_vqp_attr_sizes[vp->vp_type][0];
break;
- case PW_TYPE_ETHERNET:
+ case FR_TYPE_ETHERNET:
len = fr_vqp_attr_sizes[vp->vp_type][0];
break;
- case PW_TYPE_OCTETS:
- case PW_TYPE_STRING:
+ case FR_TYPE_OCTETS:
+ case FR_TYPE_STRING:
len = vp->vp_length;
break;
/* Data */
switch (vp->vp_type) {
- case PW_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_ADDR:
memcpy(out, &vp->vp_ipv4addr, len);
out += len;
break;
- case PW_TYPE_ETHERNET:
+ case FR_TYPE_ETHERNET:
memcpy(out, vp->vp_ether, len);
out += len;
break;
- case PW_TYPE_OCTETS:
- case PW_TYPE_STRING:
+ case FR_TYPE_OCTETS:
+ case FR_TYPE_STRING:
memcpy(out, vp->vp_octets, len);
out += len;
break;
* A mapping of configuration file names to internal variables.
*/
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("rcode", PW_TYPE_STRING, rlm_always_t, rcode_str), .dflt = "fail" },
- { FR_CONF_OFFSET("simulcount", PW_TYPE_INTEGER, rlm_always_t, simulcount), .dflt = "0" },
- { FR_CONF_OFFSET("mpp", PW_TYPE_BOOLEAN, rlm_always_t, mpp), .dflt = "no" },
+ { 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" },
CONF_PARSER_TERMINATOR
};
} rlm_attr_filter_t;
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("filename", PW_TYPE_FILE_INPUT | PW_TYPE_REQUIRED, rlm_attr_filter_t, filename) },
- { FR_CONF_OFFSET("key", PW_TYPE_TMPL, rlm_attr_filter_t, key), .dflt = "&Realm", .quote = T_BARE_WORD },
- { FR_CONF_OFFSET("relaxed", PW_TYPE_BOOLEAN, rlm_attr_filter_t, relaxed), .dflt = "no" },
+ { 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" },
CONF_PARSER_TERMINATOR
};
} rlm_cache_memcached_t;
static const CONF_PARSER driver_config[] = {
- { FR_CONF_OFFSET("options", PW_TYPE_STRING | PW_TYPE_REQUIRED, rlm_cache_memcached_t, options), .dflt = "--SERVER=localhost" },
+ { FR_CONF_OFFSET("options", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_cache_memcached_t, options), .dflt = "--SERVER=localhost" },
CONF_PARSER_TERMINATOR
};
* Encode the entry created date
*/
tmpl_init(&created_value, TMPL_TYPE_DATA, "<TEMP>", 6, T_BARE_WORD);
- created_value.tmpl_value_box_type = PW_TYPE_DATE;
+ created_value.tmpl_value_box_type = FR_TYPE_DATE;
created_value.tmpl_value_box_datum.date = c->created;
/*
* to ignore entries that were created before the last epoch.
*/
tmpl_init(&expires_value, TMPL_TYPE_DATA, "<TEMP>", 6, T_BARE_WORD);
- expires_value.tmpl_value_box_type = PW_TYPE_DATE;
+ expires_value.tmpl_value_box_type = FR_TYPE_DATE;
expires_value.tmpl_value_box_datum.date = c->expires;
expires.next = c->maps; /* Head of the list */
extern rad_module_t rlm_cache;
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("driver", PW_TYPE_STRING, rlm_cache_config_t, driver_name), .dflt = "rlm_cache_rbtree" },
- { FR_CONF_OFFSET("key", PW_TYPE_TMPL | PW_TYPE_REQUIRED, rlm_cache_config_t, key) },
- { FR_CONF_OFFSET("ttl", PW_TYPE_INTEGER, rlm_cache_config_t, ttl), .dflt = "500" },
- { FR_CONF_OFFSET("max_entries", PW_TYPE_INTEGER, rlm_cache_config_t, max_entries), .dflt = "0" },
+ { 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" },
/* Should be a type which matches time_t, @fixme before 2038 */
- { FR_CONF_OFFSET("epoch", PW_TYPE_SIGNED, rlm_cache_config_t, epoch), .dflt = "0" },
- { FR_CONF_OFFSET("add_stats", PW_TYPE_BOOLEAN, rlm_cache_config_t, stats), .dflt = "no" },
+ { 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" },
CONF_PARSER_TERMINATOR
};
return RLM_MODULE_FAIL;
}
c_map->rhs->tmpl_value_box_type = vp->vp_type;
- if (vp->vp_type == PW_TYPE_STRING) {
+ if (vp->vp_type == FR_TYPE_STRING) {
c_map->rhs->quote = is_printable(vp->vp_strvalue, vp->vp_length) ?
T_SINGLE_QUOTED_STRING : T_DOUBLE_QUOTED_STRING;
}
unsigned int i;
switch (vp->vp_type) {
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
i = vp->vp_integer;
goto print_int;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
i = vp->vp_short;
goto print_int;
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
i = vp->vp_byte;
print_int:
return json_object_new_int(i);
#endif
- case PW_TYPE_SIGNED:
+ case FR_TYPE_SIGNED:
#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 PW_TYPE_INTEGER64:
+ case FR_TYPE_INTEGER64:
#ifdef HAVE_JSON_OBJECT_NEW_INT64
/* debug */
RDEBUG3("creating new int64 for 64 bit integer '%s'", vp->da->name);
/* keep going if not set above */
switch (vp->vp_type) {
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
/* debug */
RDEBUG3("assigning string '%s' as string", vp->da->name);
/* return string value */
* Client Configuration
*/
static const CONF_PARSER client_config[] = {
- { FR_CONF_OFFSET("view", PW_TYPE_STRING, rlm_couchbase_t, client_view), .dflt = "_design/client/_view/by_name" },
+ { FR_CONF_OFFSET("view", FR_TYPE_STRING, rlm_couchbase_t, client_view), .dflt = "_design/client/_view/by_name" },
CONF_PARSER_TERMINATOR
};
* Module Configuration
*/
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("server", PW_TYPE_STRING | PW_TYPE_REQUIRED, rlm_couchbase_t, server_raw) },
- { FR_CONF_OFFSET("bucket", PW_TYPE_STRING | PW_TYPE_REQUIRED, rlm_couchbase_t, bucket) },
- { FR_CONF_OFFSET("password", PW_TYPE_STRING, rlm_couchbase_t, password) },
+ { FR_CONF_OFFSET("server", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_couchbase_t, server_raw) },
+ { FR_CONF_OFFSET("bucket", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_couchbase_t, bucket) },
+ { FR_CONF_OFFSET("password", FR_TYPE_STRING, rlm_couchbase_t, password) },
#ifdef WITH_ACCOUNTING
- { FR_CONF_OFFSET("acct_key", PW_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", PW_TYPE_STRING, rlm_couchbase_t, doctype), .dflt = "radacct" },
- { FR_CONF_OFFSET("expire", PW_TYPE_INTEGER, rlm_couchbase_t, expire), .dflt = 0 },
+ { 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 },
#endif
- { FR_CONF_OFFSET("user_key", PW_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", PW_TYPE_BOOLEAN, rlm_couchbase_t, read_clients) }, /* NULL defaults to "no" */
- { FR_CONF_POINTER("client", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) client_config },
+ { 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_POINTER("client", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) client_config },
#ifdef WITH_SESSION_MGMT
- { FR_CONF_OFFSET("check_simul", PW_TYPE_BOOLEAN, rlm_couchbase_t, check_simul) }, /* NULL defaults to "no" */
- { FR_CONF_OFFSET("simul_view", PW_TYPE_STRING, rlm_couchbase_t, simul_view), .dflt = "_design/acct/_view/by_user" },
- { FR_CONF_OFFSET("simul_vkey", PW_TYPE_TMPL, rlm_couchbase_t, simul_vkey), .dflt = "%{tolower:%{%{Stripped-User-Name}:-%{User-Name}}}", .quote = T_DOUBLE_QUOTED_STRING },
- { FR_CONF_OFFSET("verify_simul", PW_TYPE_BOOLEAN, rlm_couchbase_t, verify_simul) }, /* NULL defaults to "no" */
+ { FR_CONF_OFFSET("check_simul", FR_TYPE_BOOLEAN, 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" */
#endif
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("filename", PW_TYPE_FILE_INPUT | PW_TYPE_REQUIRED | PW_TYPE_NOT_EMPTY, rlm_csv_t, filename) },
- { FR_CONF_OFFSET("delimiter", PW_TYPE_STRING | PW_TYPE_REQUIRED | PW_TYPE_NOT_EMPTY, rlm_csv_t, delimiter), .dflt = "," },
- { FR_CONF_OFFSET("header", PW_TYPE_STRING | PW_TYPE_REQUIRED | PW_TYPE_NOT_EMPTY, rlm_csv_t, header) },
- { FR_CONF_OFFSET("key_field", PW_TYPE_STRING | PW_TYPE_REQUIRED | PW_TYPE_NOT_EMPTY, rlm_csv_t, key) },
+ { FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT | FR_TYPE_REQUIRED | FR_TYPE_NOT_EMPTY, rlm_csv_t, filename) },
+ { FR_CONF_OFFSET("delimiter", FR_TYPE_STRING | FR_TYPE_REQUIRED | FR_TYPE_NOT_EMPTY, rlm_csv_t, delimiter), .dflt = "," },
+ { FR_CONF_OFFSET("header", FR_TYPE_STRING | FR_TYPE_REQUIRED | FR_TYPE_NOT_EMPTY, rlm_csv_t, header) },
+ { FR_CONF_OFFSET("key_field", FR_TYPE_STRING | FR_TYPE_REQUIRED | FR_TYPE_NOT_EMPTY, rlm_csv_t, key) },
CONF_PARSER_TERMINATOR
};
} rlm_date_t;
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("format", PW_TYPE_STRING, rlm_date_t, fmt), .dflt = "%b %e %Y %H:%M:%S %Z" },
+ { FR_CONF_OFFSET("format", FR_TYPE_STRING, rlm_date_t, fmt), .dflt = "%b %e %Y %H:%M:%S %Z" },
CONF_PARSER_TERMINATOR
};
* to a time structure, and then output it in the specified
* format as a string.
*/
- case PW_TYPE_DATE:
+ case FR_TYPE_DATE:
date = vp->vp_date;
goto encode;
- case PW_TYPE_INTEGER:
- case PW_TYPE_INTEGER64:
+ case FR_TYPE_INTEGER:
+ case FR_TYPE_INTEGER64:
date = (time_t) vp->vp_integer;
encode:
* into a time structure, and then output it as an integer
* unix timestamp.
*/
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
if (strptime(vp->vp_strvalue, inst->fmt, &tminfo) == NULL) {
REDEBUG("Failed to parse time string \"%s\" as format '%s'", vp->vp_strvalue, inst->fmt);
goto error;
* A mapping of configuration file names to internal variables.
*/
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("delay", PW_TYPE_TMPL, rlm_delay_t, delay) },
- { FR_CONF_OFFSET("relative", PW_TYPE_BOOLEAN, rlm_delay_t, relative), .dflt = "no" },
- { FR_CONF_OFFSET("force_reschedule", PW_TYPE_BOOLEAN, rlm_delay_t, force_reschedule), .dflt = "no" },
+ { 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" },
CONF_PARSER_TERMINATOR
};
} rlm_detail_t;
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("filename", PW_TYPE_FILE_OUTPUT | PW_TYPE_REQUIRED | PW_TYPE_XLAT, rlm_detail_t, filename), .dflt = "%A/%{Client-IP-Address}/detail" },
- { FR_CONF_OFFSET("header", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_detail_t, header), .dflt = "%t" },
- { FR_CONF_OFFSET("permissions", PW_TYPE_INTEGER, rlm_detail_t, perm), .dflt = "0600" },
- { FR_CONF_OFFSET("group", PW_TYPE_STRING, rlm_detail_t, group) },
- { FR_CONF_OFFSET("locking", PW_TYPE_BOOLEAN, rlm_detail_t, locking), .dflt = "no" },
- { FR_CONF_OFFSET("escape_filenames", PW_TYPE_BOOLEAN, rlm_detail_t, escape), .dflt = "no" },
- { FR_CONF_OFFSET("log_packet_header", PW_TYPE_BOOLEAN, rlm_detail_t, log_srcdst), .dflt = "no" },
+ { 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("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" },
CONF_PARSER_TERMINATOR
};
* Could be an array of bytes, integers, etc.
*/
switch (da->type) {
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
if (da->flags.length == 0) return 1;
element_len = da->flags.length;
break;
* block cipher (16 in the case of AES-128-CBC).
*/
case PW_SIM_PADDING:
- if (!parent->parent || (parent->parent->type != PW_TYPE_TLV) || (!parent->parent->flags.encrypt)) {
+ if (!parent->parent || (parent->parent->type != FR_TYPE_TLV) || (!parent->parent->flags.encrypt)) {
fr_strerror_printf("%s: Found padding attribute outside of an encrypted TLV", __FUNCTION__);
return -1;
}
FR_PROTO_TRACE("Type \"%s\" (%u)", fr_int2str(dict_attr_types, parent->type, "?Unknown?"), parent->type);
switch (parent->type) {
- case PW_TYPE_STRING:
- case PW_TYPE_OCTETS:
+ case FR_TYPE_STRING:
+ case FR_TYPE_OCTETS:
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
if (attr_len != 2) goto raw;
break;
- case PW_TYPE_TLV:
+ case FR_TYPE_TLV:
/*
* We presume that the TLVs all fit into one
* attribute, OR they've already been grouped
* Strings have a two byte 'real length' field in front of the
* actual value, and that gives us the length of the string value.
*/
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
{
uint16_t str_len = (p[0] << 8) | p[1];
}
break;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
fr_pair_value_memcpy(vp, p, attr_len);
vp->vp_length = attr_len;
break;
* | AT_<BOOL> | Length = 1 | Reserved |
* +---------------+---------------+-------------------------------+
*/
- case PW_TYPE_BOOLEAN:
+ case FR_TYPE_BOOLEAN:
vp->vp_bool = true;
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
vp->vp_short = (p[0] << 8) | p[1];
break;
/*
* String attributes have a 16bit "Actual Length" field at the start.
*/
- } else if (vp->vp_type == PW_TYPE_STRING) {
+ } else if (vp->vp_type == FR_TYPE_STRING) {
vp_len = vp->vp_length + 2;
/*
* All other attributes we trust the length.
/*
* For strings we have an 'actual' value field.
*/
- if (vp->vp_type == PW_TYPE_STRING) {
+ if (vp->vp_type == FR_TYPE_STRING) {
vp_len = vp->vp_length + 2;
/*
* All other attributes we trust the length.
p[1] = rounded_len >> 2;
switch (vp->vp_type) {
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
memcpy(&p[2], vp->vp_octets, vp->vp_length);
break;
* | |
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
{
uint16_t actual_len = htons((vp->vp_length & UINT16_MAX));
* | AT_<BOOL> | Length = 1 | Reserved |
* +---------------+---------------+-------------------------------+
*/
- case PW_TYPE_BOOLEAN:
+ case FR_TYPE_BOOLEAN:
break;
/*
* | AT_<SHORT> | Length = 1 | Short 1 | Short 2 |
* +---------------+---------------+-------------------------------+
*/
- case PW_TYPE_BYTE: //!< 8 Bit unsigned integer.
- case PW_TYPE_SHORT: //!< 16 Bit unsigned integer.
- case PW_TYPE_INTEGER: //!< 32 Bit unsigned integer.
- case PW_TYPE_INTEGER64: //!< 64 Bit unsigned integer.
- case PW_TYPE_SIGNED: //!< 32 Bit signed integer.
+ 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.
{
value_box_t data;
extern rad_module_t rlm_eap;
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("default_eap_type", PW_TYPE_STRING, rlm_eap_config_t, default_method_name), .dflt = "md5" },
- { FR_CONF_DEPRECATED("timer_expire", PW_TYPE_INTEGER, rlm_eap_config_t, timer_limit), .dflt = "60" },
- { FR_CONF_OFFSET("ignore_unknown_eap_types", PW_TYPE_BOOLEAN, rlm_eap_config_t, ignore_unknown_types), .dflt = "no" },
- { FR_CONF_OFFSET("cisco_accounting_username_bug", PW_TYPE_BOOLEAN, rlm_eap_config_t,
+ { 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,
cisco_accounting_username_bug), .dflt = "no" },
- { FR_CONF_DEPRECATED("max_sessions", PW_TYPE_INTEGER, rlm_eap_config_t, max_sessions), .dflt = "2048" },
+ { FR_CONF_DEPRECATED("max_sessions", FR_TYPE_INTEGER, rlm_eap_config_t, max_sessions), .dflt = "2048" },
CONF_PARSER_TERMINATOR
};
da = fr_dict_attr_child_by_num(fast_da, attr);
if (!da) goto next_attr;
- if (da->type == PW_TYPE_TLV) {
+ if (da->type == FR_TYPE_TLV) {
eap_fast_fast2vp(request, ssl, data, length, da, out);
goto next_attr;
}
static CONF_PARSER submodule_config[] = {
- { FR_CONF_OFFSET("tls", PW_TYPE_STRING, rlm_eap_fast_t, tls_conf_name) },
+ { FR_CONF_OFFSET("tls", FR_TYPE_STRING, rlm_eap_fast_t, tls_conf_name) },
- { FR_CONF_OFFSET("default_provisioning_eap_type", PW_TYPE_STRING, rlm_eap_fast_t, default_provisioning_method_name), .dflt = "mschapv2" },
+ { FR_CONF_OFFSET("default_provisioning_eap_type", FR_TYPE_STRING, rlm_eap_fast_t, default_provisioning_method_name), .dflt = "mschapv2" },
- { FR_CONF_OFFSET("virtual_server", PW_TYPE_STRING | PW_TYPE_REQUIRED | PW_TYPE_NOT_EMPTY, rlm_eap_fast_t, virtual_server) },
+ { 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", PW_TYPE_BOOLEAN, rlm_eap_fast_t, req_client_cert), .dflt = "no" },
+ { FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOLEAN, rlm_eap_fast_t, req_client_cert), .dflt = "no" },
- { FR_CONF_OFFSET("pac_lifetime", PW_TYPE_INTEGER, rlm_eap_fast_t, pac_lifetime), .dflt = "604800" },
- { FR_CONF_OFFSET("authority_identity", PW_TYPE_STRING | PW_TYPE_REQUIRED, rlm_eap_fast_t, authority_identity) },
- { FR_CONF_OFFSET("pac_opaque_key", PW_TYPE_STRING | PW_TYPE_REQUIRED, rlm_eap_fast_t, pac_opaque_key) },
+ { FR_CONF_OFFSET("pac_lifetime", FR_TYPE_INTEGER, 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) },
CONF_PARSER_TERMINATOR
};
} rlm_eap_gtc_t;
static CONF_PARSER submodule_config[] = {
- { FR_CONF_OFFSET("challenge", PW_TYPE_STRING, rlm_eap_gtc_t, challenge), .dflt = "Password: " },
- { FR_CONF_OFFSET("auth_type", PW_TYPE_STRING, rlm_eap_gtc_t, auth_type_name), .dflt = "PAP" },
+ { FR_CONF_OFFSET("challenge", FR_TYPE_STRING, rlm_eap_gtc_t, challenge), .dflt = "Password: " },
+ { FR_CONF_OFFSET("auth_type", FR_TYPE_STRING, rlm_eap_gtc_t, auth_type_name), .dflt = "PAP" },
CONF_PARSER_TERMINATOR
};
} rlm_eap_mschapv2_t;
static CONF_PARSER submodule_config[] = {
- { FR_CONF_OFFSET("with_ntdomain_hack", PW_TYPE_BOOLEAN, rlm_eap_mschapv2_t, with_ntdomain_hack), .dflt = "no" },
+ { FR_CONF_OFFSET("with_ntdomain_hack", FR_TYPE_BOOLEAN, rlm_eap_mschapv2_t, with_ntdomain_hack), .dflt = "no" },
- { FR_CONF_OFFSET("send_error", PW_TYPE_BOOLEAN, rlm_eap_mschapv2_t, send_error), .dflt = "no" },
- { FR_CONF_OFFSET("identity", PW_TYPE_STRING, rlm_eap_mschapv2_t, identity) },
+ { FR_CONF_OFFSET("send_error", FR_TYPE_BOOLEAN, rlm_eap_mschapv2_t, send_error), .dflt = "no" },
+ { FR_CONF_OFFSET("identity", FR_TYPE_STRING, rlm_eap_mschapv2_t, identity) },
CONF_PARSER_TERMINATOR
};
static CONF_PARSER submodule_config[] = {
- { FR_CONF_OFFSET("tls", PW_TYPE_STRING, rlm_eap_peap_t, tls_conf_name) },
+ { FR_CONF_OFFSET("tls", FR_TYPE_STRING, rlm_eap_peap_t, tls_conf_name) },
- { FR_CONF_OFFSET("inner_eap_module", PW_TYPE_STRING, rlm_eap_peap_t, inner_eap_module), },
+ { FR_CONF_OFFSET("inner_eap_module", FR_TYPE_STRING, rlm_eap_peap_t, inner_eap_module), },
- { FR_CONF_DEPRECATED("copy_request_to_tunnel", PW_TYPE_BOOLEAN, rlm_eap_peap_t, NULL), .dflt = "no" },
+ { FR_CONF_DEPRECATED("copy_request_to_tunnel", FR_TYPE_BOOLEAN, rlm_eap_peap_t, NULL), .dflt = "no" },
- { FR_CONF_DEPRECATED("use_tunneled_reply", PW_TYPE_BOOLEAN, rlm_eap_peap_t, NULL), .dflt = "no" },
+ { FR_CONF_DEPRECATED("use_tunneled_reply", FR_TYPE_BOOLEAN, rlm_eap_peap_t, NULL), .dflt = "no" },
#ifdef WITH_PROXY
- { FR_CONF_OFFSET("proxy_tunneled_request_as_eap", PW_TYPE_BOOLEAN, rlm_eap_peap_t, proxy_tunneled_request_as_eap), .dflt = "yes" },
+ { FR_CONF_OFFSET("proxy_tunneled_request_as_eap", FR_TYPE_BOOLEAN, rlm_eap_peap_t, proxy_tunneled_request_as_eap), .dflt = "yes" },
#endif
- { FR_CONF_OFFSET("virtual_server", PW_TYPE_STRING | PW_TYPE_REQUIRED | PW_TYPE_NOT_EMPTY, rlm_eap_peap_t, virtual_server) },
+ { 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", PW_TYPE_BOOLEAN, rlm_eap_peap_t, soh), .dflt = "no" },
+ { FR_CONF_OFFSET("soh", FR_TYPE_BOOLEAN, rlm_eap_peap_t, soh), .dflt = "no" },
- { FR_CONF_OFFSET("require_client_cert", PW_TYPE_BOOLEAN, rlm_eap_peap_t, req_client_cert), .dflt = "no" },
+ { FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOLEAN, rlm_eap_peap_t, req_client_cert), .dflt = "no" },
- { FR_CONF_OFFSET("soh_virtual_server", PW_TYPE_STRING, rlm_eap_peap_t, soh_virtual_server) },
+ { 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", PW_TYPE_INTEGER, rlm_eap_pwd_t, group), .dflt = "19" },
- { FR_CONF_OFFSET("fragment_size", PW_TYPE_INTEGER, rlm_eap_pwd_t, fragment_size), .dflt = "1020" },
- { FR_CONF_OFFSET("server_id", PW_TYPE_STRING | PW_TYPE_REQUIRED, rlm_eap_pwd_t, server_id) },
+ { 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("server_id", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_eap_pwd_t, server_id) },
CONF_PARSER_TERMINATOR
};
#endif
static CONF_PARSER submodule_config[] = {
- { FR_CONF_OFFSET("tls", PW_TYPE_STRING, rlm_eap_tls_t, tls_conf_name) },
+ { FR_CONF_OFFSET("tls", FR_TYPE_STRING, rlm_eap_tls_t, tls_conf_name) },
- { FR_CONF_OFFSET("require_client_cert", PW_TYPE_BOOLEAN, rlm_eap_tls_t, req_client_cert), .dflt = "yes" },
- { FR_CONF_OFFSET("include_length", PW_TYPE_BOOLEAN, rlm_eap_tls_t, include_length), .dflt = "yes" },
- { FR_CONF_OFFSET("virtual_server", PW_TYPE_STRING, rlm_eap_tls_t, virtual_server) },
+ { 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("virtual_server", FR_TYPE_STRING, rlm_eap_tls_t, virtual_server) },
CONF_PARSER_TERMINATOR
};
static CONF_PARSER submodule_config[] = {
- { FR_CONF_OFFSET("tls", PW_TYPE_STRING, rlm_eap_ttls_t, tls_conf_name) },
- { FR_CONF_DEPRECATED("copy_request_to_tunnel", PW_TYPE_BOOLEAN, rlm_eap_ttls_t, NULL), .dflt = "no" },
- { FR_CONF_DEPRECATED("use_tunneled_reply", PW_TYPE_BOOLEAN, rlm_eap_ttls_t, NULL), .dflt = "no" },
- { FR_CONF_OFFSET("virtual_server", PW_TYPE_STRING | PW_TYPE_REQUIRED | PW_TYPE_NOT_EMPTY, rlm_eap_ttls_t, virtual_server) },
- { FR_CONF_OFFSET("include_length", PW_TYPE_BOOLEAN, rlm_eap_ttls_t, include_length), .dflt = "yes" },
- { FR_CONF_OFFSET("require_client_cert", PW_TYPE_BOOLEAN, rlm_eap_ttls_t, req_client_cert), .dflt = "no" },
+ { 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_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" },
CONF_PARSER_TERMINATOR
};
/*
* Diameter pads strings (i.e. User-Password) with trailing zeros.
*/
- if (vp->vp_type == PW_TYPE_STRING) {
+ if (vp->vp_type == FR_TYPE_STRING) {
fr_pair_value_strcpy(vp, vp->vp_strvalue);
}
}
switch (vp->vp_type) {
- case PW_TYPE_INTEGER:
- case PW_TYPE_DATE:
+ case FR_TYPE_INTEGER:
+ case FR_TYPE_DATE:
attr = htonl(vp->vp_integer); /* stored in host order */
memcpy(p, &attr, sizeof(attr));
length = 4;
break;
- case PW_TYPE_INTEGER64:
+ case FR_TYPE_INTEGER64:
attr64 = htonll(vp->vp_integer64); /* stored in host order */
memcpy(p, &attr64, sizeof(attr64));
length = 8;
break;
- case PW_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_ADDR:
memcpy(p, &vp->vp_ipv4addr, 4); /* network order */
length = 4;
break;
- case PW_TYPE_STRING:
- case PW_TYPE_OCTETS:
+ case FR_TYPE_STRING:
+ case FR_TYPE_OCTETS:
default:
memcpy(p, vp->vp_strvalue, vp->vp_length);
length = vp->vp_length;
* A mapping of configuration file names to internal variables.
*/
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("integer", PW_TYPE_INTEGER, rlm_example_t, value), .dflt = "1" },
- { FR_CONF_OFFSET("boolean", PW_TYPE_BOOLEAN, rlm_example_t, boolean), .dflt = "no" },
- { FR_CONF_OFFSET("string", PW_TYPE_STRING, rlm_example_t, string) },
- { FR_CONF_OFFSET("ipaddr", PW_TYPE_IPV4_ADDR, rlm_example_t, ipaddr), .dflt = "*" },
+ { 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("string", FR_TYPE_STRING, rlm_example_t, string) },
+ { FR_CONF_OFFSET("ipaddr", FR_TYPE_IPV4_ADDR, rlm_example_t, ipaddr), .dflt = "*" },
CONF_PARSER_TERMINATOR
};
static int rlm_example_cmp(UNUSED void *instance, REQUEST *request, UNUSED VALUE_PAIR *thing, VALUE_PAIR *check,
UNUSED VALUE_PAIR *check_pairs, UNUSED VALUE_PAIR **reply_pairs)
{
- rad_assert(check->vp_type == PW_TYPE_STRING);
+ rad_assert(check->vp_type == FR_TYPE_STRING);
RINFO("Example-Paircmp called with \"%s\"", check->vp_strvalue);
} rlm_exec_t;
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("wait", PW_TYPE_BOOLEAN, rlm_exec_t, wait), .dflt = "yes" },
- { FR_CONF_OFFSET("program", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_exec_t, program) },
- { FR_CONF_OFFSET("input_pairs", PW_TYPE_STRING, rlm_exec_t, input) },
- { FR_CONF_OFFSET("output_pairs", PW_TYPE_STRING, rlm_exec_t, output) },
- { FR_CONF_OFFSET("packet_type", PW_TYPE_STRING, rlm_exec_t, packet_type) },
- { FR_CONF_OFFSET("shell_escape", PW_TYPE_BOOLEAN, rlm_exec_t, shell_escape), .dflt = "yes" },
- { FR_CONF_OFFSET("timeout", PW_TYPE_INTEGER, rlm_exec_t, timeout) },
+ { FR_CONF_OFFSET("wait", FR_TYPE_BOOLEAN, 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) },
CONF_PARSER_TERMINATOR
};
VERIFY_VP(req);
VERIFY_VP(check);
- rad_assert(req->vp_type == PW_TYPE_STRING);
+ rad_assert(req->vp_type == FR_TYPE_STRING);
name = req->vp_strvalue;
} rlm_expr_t;
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("safe_characters", PW_TYPE_STRING, rlm_expr_t, allowed_chars), .dflt = "@abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-_: /" },
+ { FR_CONF_OFFSET("safe_characters", FR_TYPE_STRING, rlm_expr_t, allowed_chars), .dflt = "@abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-_: /" },
CONF_PARSER_TERMINATOR
};
i++, vp = tmpl_cursor_next(&cursor, vpt)) {
int64_t y;
- if (vp->vp_type != PW_TYPE_INTEGER64) {
+ if (vp->vp_type != FR_TYPE_INTEGER64) {
value_box_t value;
- if (value_box_cast(vp, &value, PW_TYPE_INTEGER64, NULL, &vp->data) < 0) {
+ if (value_box_cast(vp, &value, FR_TYPE_INTEGER64, NULL, &vp->data) < 0) {
REDEBUG("Failed converting &%.*s to an integer value: %s", (int) vpt->len,
vpt->name, fr_strerror());
return false;
memset(out, 0, sizeof(*out));
out->datum.strvalue = fmt;
out->datum.length = talloc_array_length(fmt) - 1;
- out->type = PW_TYPE_STRING;
+ out->type = FR_TYPE_STRING;
return 0;
}
value_box_t bin;
switch (in->type) {
- case PW_TYPE_STRING:
- case PW_TYPE_OCTETS:
+ case FR_TYPE_STRING:
+ case FR_TYPE_OCTETS:
memcpy(out, &in->datum.ptr, sizeof(in));
*outlen = in->datum.length;
return 0;
default:
- if (value_box_cast(ctx, &bin, PW_TYPE_OCTETS, NULL, in) < 0) {
+ if (value_box_cast(ctx, &bin, FR_TYPE_OCTETS, NULL, in) < 0) {
RPERROR("Failed casting xlat input to 'octets'");
return -1;
}
* so we need to check the type of each attribute.
*/
switch (vp->vp_type) {
- case PW_TYPE_OCTETS:
- case PW_TYPE_STRING:
+ case FR_TYPE_OCTETS:
+ case FR_TYPE_STRING:
break;
default:
new->tag = vp->tag;
switch (vp->vp_type) {
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
{
uint8_t *buff;
}
break;
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
{
char *buff;
}
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("filename", PW_TYPE_FILE_INPUT, rlm_files_t, filename) },
- { FR_CONF_OFFSET("usersfile", PW_TYPE_FILE_INPUT, rlm_files_t, usersfile) },
- { FR_CONF_OFFSET("acctusersfile", PW_TYPE_FILE_INPUT, rlm_files_t, acct_usersfile) },
+ { FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT, rlm_files_t, filename) },
+ { FR_CONF_OFFSET("usersfile", FR_TYPE_FILE_INPUT, rlm_files_t, usersfile) },
+ { FR_CONF_OFFSET("acctusersfile", FR_TYPE_FILE_INPUT, rlm_files_t, acct_usersfile) },
#ifdef WITH_PROXY
- { FR_CONF_OFFSET("preproxy_usersfile", PW_TYPE_FILE_INPUT, rlm_files_t, preproxy_usersfile) },
- { FR_CONF_OFFSET("postproxy_usersfile", PW_TYPE_FILE_INPUT, rlm_files_t, postproxy_usersfile) },
+ { FR_CONF_OFFSET("preproxy_usersfile", FR_TYPE_FILE_INPUT, rlm_files_t, preproxy_usersfile) },
+ { FR_CONF_OFFSET("postproxy_usersfile", FR_TYPE_FILE_INPUT, rlm_files_t, postproxy_usersfile) },
#endif
- { FR_CONF_OFFSET("auth_usersfile", PW_TYPE_FILE_INPUT, rlm_files_t, auth_usersfile) },
- { FR_CONF_OFFSET("postauth_usersfile", PW_TYPE_FILE_INPUT, rlm_files_t, postauth_usersfile) },
- { FR_CONF_OFFSET("key", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_files_t, key) },
+ { FR_CONF_OFFSET("auth_usersfile", FR_TYPE_FILE_INPUT, rlm_files_t, auth_usersfile) },
+ { FR_CONF_OFFSET("postauth_usersfile", FR_TYPE_FILE_INPUT, rlm_files_t, postauth_usersfile) },
+ { FR_CONF_OFFSET("key", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_files_t, key) },
CONF_PARSER_TERMINATOR
};
* be used.
*/
- { FR_CONF_OFFSET("allow_unassigned", PW_TYPE_BOOLEAN, rlm_idn_t, allow_unassigned), .dflt = "no" },
- { FR_CONF_OFFSET("use_std3_ascii_rules", PW_TYPE_BOOLEAN, rlm_idn_t, use_std3_ascii_rules), .dflt = "yes" },
+ { 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" },
CONF_PARSER_TERMINATOR
};
* - -1 on error.
*/
static int jpath_evaluate(TALLOC_CTX *ctx, value_box_t ***tail,
- PW_TYPE dst_type, fr_dict_attr_t const *dst_enumv,
+ fr_type_t dst_type, fr_dict_attr_t const *dst_enumv,
json_object *object, fr_jpath_node_t const *jpath)
{
value_box_t *value;
* - -1 on error.
*/
int fr_jpath_evaluate_leaf(TALLOC_CTX *ctx, value_box_t **out,
- PW_TYPE dst_type, fr_dict_attr_t const *dst_enumv,
+ fr_type_t dst_type, fr_dict_attr_t const *dst_enumv,
json_object *root, fr_jpath_node_t const *jpath)
{
value_box_t **tail = out;
* - -1 on failure.
*/
int fr_json_object_to_value_box(TALLOC_CTX *ctx, value_box_t *out, json_object *object,
- PW_TYPE dst_type, fr_dict_attr_t const *dst_enumv)
+ fr_type_t dst_type, fr_dict_attr_t const *dst_enumv)
{
value_box_t in;
switch (fr_json_object_get_type(object)) {
case json_type_string:
- in.type = PW_TYPE_STRING;
+ in.type = FR_TYPE_STRING;
in.datum.strvalue = json_object_get_string(object);
in.datum.length = json_object_get_string_len(object);
break;
case json_type_double:
- in.type = PW_TYPE_DECIMAL;
+ in.type = FR_TYPE_DECIMAL;
in.datum.decimal = json_object_get_double(object);
break;
int32_t num;
#endif
#ifndef HAVE_JSON_OBJECT_GET_INT64
- if (dst_type == PW_TYPE_INTEGER64) {
+ if (dst_type == FR_TYPE_INTEGER64) {
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 = PW_TYPE_INTEGER64;
+ in.type = FR_TYPE_INTEGER64;
in.datum.integer64 = (uint64_t) num;
} else
#endif
if (num < 0) { /* 32bit signed (supported) */
- in.type = PW_TYPE_SIGNED;
+ in.type = FR_TYPE_SIGNED;
in.datum.sinteger = num;
} else if (num > UINT16_MAX) { /* 32bit unsigned (supported) */
- in.type = PW_TYPE_INTEGER;
+ in.type = FR_TYPE_INTEGER;
in.datum.integer = (uint32_t) num;
} else if (num > UINT8_MAX) { /* 16bit unsigned (supported) */
- in.type = PW_TYPE_SHORT;
+ in.type = FR_TYPE_SHORT;
in.datum.ushort = (uint16_t) num;
} else { /* 8bit unsigned (supported) */
- in.type = PW_TYPE_BYTE;
+ in.type = FR_TYPE_BYTE;
in.datum.byte = (uint8_t) num;
}
}
break;
case json_type_boolean:
- in.type = PW_TYPE_BOOLEAN;
+ in.type = FR_TYPE_BOOLEAN;
in.datum.boolean = json_object_get_boolean(object);
break;
case json_type_null:
case json_type_array:
case json_type_object:
- in.type = PW_TYPE_STRING;
+ in.type = FR_TYPE_STRING;
in.datum.strvalue = json_object_to_json_string(object);
in.datum.length = strlen(in.datum.strvalue);
break;
return obj;
}
- case PW_TYPE_BOOLEAN:
+ case FR_TYPE_BOOLEAN:
return json_object_new_boolean(data->datum.byte);
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
return json_object_new_int(data->datum.byte);
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
return json_object_new_int(data->datum.ushort);
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
return json_object_new_int64((int64_t)data->datum.integer64); /* uint32_t (max) > int32_t (max) */
- case PW_TYPE_INTEGER64:
+ case FR_TYPE_INTEGER64:
if (data->datum.integer64 > INT64_MAX) goto do_string;
return json_object_new_int64(data->datum.integer64);
- case PW_TYPE_SIGNED:
+ case FR_TYPE_SIGNED:
return json_object_new_int(data->datum.sinteger);
}
}
if (!vp->da->flags.has_tag) {
switch (vp->vp_type) {
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
if (vp->da->flags.has_value) break;
return snprintf(out, freespace, "%u", vp->vp_integer);
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
if (vp->da->flags.has_value) break;
return snprintf(out, freespace, "%u", (unsigned int) vp->vp_short);
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
if (vp->da->flags.has_value) break;
return snprintf(out, freespace, "%u", (unsigned int) vp->vp_byte);
- case PW_TYPE_SIGNED:
+ case FR_TYPE_SIGNED:
return snprintf(out, freespace, "%d", vp->vp_signed);
default:
}
}
- if (vp->vp_type == PW_TYPE_STRING) {
+ if (vp->vp_type == FR_TYPE_STRING) {
char *tmp = fr_json_from_string(NULL, vp->vp_strvalue, true);
/* Indicate truncation */
char const *in, UNUSED void *arg);
int fr_jpath_evaluate_leaf(TALLOC_CTX *ctx, value_box_t **out,
- PW_TYPE dst_type, fr_dict_attr_t const *dst_enumv,
+ fr_type_t dst_type, fr_dict_attr_t const *dst_enumv,
json_object *root, fr_jpath_node_t const *jpath);
char *fr_jpath_asprint(TALLOC_CTX *ctx, fr_jpath_node_t const *head);
/* json.c */
int fr_json_object_to_value_box(TALLOC_CTX *ctx, value_box_t *out, json_object *object,
- PW_TYPE dst_type, fr_dict_attr_t const *dst_enumv);
+ fr_type_t dst_type, fr_dict_attr_t const *dst_enumv);
json_object *json_object_from_value_box(TALLOC_CTX *ctx, value_box_t const *data);
char const *p;
#ifndef HAVE_JSON_OBJECT_GET_INT64
- if ((map->lhs->type == TMPL_TYPE_ATTR) && (map->lhs->tmpl_da->type == PW_TYPE_INTEGER64)) {
+ if ((map->lhs->type == TMPL_TYPE_ATTR) && (map->lhs->tmpl_da->type == FR_TYPE_INTEGER64)) {
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;
break;
case TMPL_TYPE_DATA:
- if (map->rhs->tmpl_value_box_type != PW_TYPE_STRING) {
+ if (map->rhs->tmpl_value_box_type != FR_TYPE_STRING) {
cf_log_err_cp(cp, "Right side of map must be a string");
return -1;
}
#include "krb5.h"
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("keytab", PW_TYPE_STRING, rlm_krb5_t, keytabname) },
- { FR_CONF_OFFSET("service_principal", PW_TYPE_STRING, rlm_krb5_t, service_princ) },
+ { FR_CONF_OFFSET("keytab", FR_TYPE_STRING, rlm_krb5_t, keytabname) },
+ { FR_CONF_OFFSET("service_principal", FR_TYPE_STRING, rlm_krb5_t, service_princ) },
CONF_PARSER_TERMINATOR
};
#include <freeradius-devel/map_proc.h>
static CONF_PARSER sasl_mech_dynamic[] = {
- { FR_CONF_OFFSET("mech", PW_TYPE_TMPL | PW_TYPE_NOT_EMPTY, fr_ldap_sasl_t_dynamic_t, mech) },
- { FR_CONF_OFFSET("proxy", PW_TYPE_TMPL, fr_ldap_sasl_t_dynamic_t, proxy) },
- { FR_CONF_OFFSET("realm", PW_TYPE_TMPL, fr_ldap_sasl_t_dynamic_t, realm) },
+ { FR_CONF_OFFSET("mech", FR_TYPE_TMPL | FR_TYPE_NOT_EMPTY, fr_ldap_sasl_t_dynamic_t, mech) },
+ { FR_CONF_OFFSET("proxy", FR_TYPE_TMPL, fr_ldap_sasl_t_dynamic_t, proxy) },
+ { FR_CONF_OFFSET("realm", FR_TYPE_TMPL, fr_ldap_sasl_t_dynamic_t, realm) },
CONF_PARSER_TERMINATOR
};
static CONF_PARSER sasl_mech_static[] = {
- { FR_CONF_OFFSET("mech", PW_TYPE_STRING | PW_TYPE_NOT_EMPTY, fr_ldap_sasl_t, mech) },
- { FR_CONF_OFFSET("proxy", PW_TYPE_STRING, fr_ldap_sasl_t, proxy) },
- { FR_CONF_OFFSET("realm", PW_TYPE_STRING, fr_ldap_sasl_t, realm) },
+ { FR_CONF_OFFSET("mech", FR_TYPE_STRING | FR_TYPE_NOT_EMPTY, fr_ldap_sasl_t, mech) },
+ { FR_CONF_OFFSET("proxy", FR_TYPE_STRING, fr_ldap_sasl_t, proxy) },
+ { FR_CONF_OFFSET("realm", FR_TYPE_STRING, fr_ldap_sasl_t, realm) },
CONF_PARSER_TERMINATOR
};
/*
* Deprecated attributes
*/
- { FR_CONF_OFFSET("ca_file", PW_TYPE_FILE_INPUT, fr_ldap_handle_config_t, tls_ca_file) },
+ { FR_CONF_OFFSET("ca_file", FR_TYPE_FILE_INPUT, fr_ldap_handle_config_t, tls_ca_file) },
- { FR_CONF_OFFSET("ca_path", PW_TYPE_FILE_INPUT, fr_ldap_handle_config_t, tls_ca_path) },
+ { FR_CONF_OFFSET("ca_path", FR_TYPE_FILE_INPUT, fr_ldap_handle_config_t, tls_ca_path) },
- { FR_CONF_OFFSET("certificate_file", PW_TYPE_FILE_INPUT, fr_ldap_handle_config_t, tls_certificate_file) },
+ { FR_CONF_OFFSET("certificate_file", FR_TYPE_FILE_INPUT, fr_ldap_handle_config_t, tls_certificate_file) },
- { FR_CONF_OFFSET("private_key_file", PW_TYPE_FILE_INPUT, fr_ldap_handle_config_t, tls_private_key_file) },
+ { FR_CONF_OFFSET("private_key_file", FR_TYPE_FILE_INPUT, fr_ldap_handle_config_t, tls_private_key_file) },
/*
* LDAP Specific TLS attributes
*/
- { FR_CONF_OFFSET("start_tls", PW_TYPE_BOOLEAN, fr_ldap_handle_config_t, start_tls), .dflt = "no" },
+ { FR_CONF_OFFSET("start_tls", FR_TYPE_BOOLEAN, fr_ldap_handle_config_t, start_tls), .dflt = "no" },
- { FR_CONF_OFFSET("require_cert", PW_TYPE_STRING, fr_ldap_handle_config_t, tls_require_cert_str) },
+ { FR_CONF_OFFSET("require_cert", FR_TYPE_STRING, fr_ldap_handle_config_t, tls_require_cert_str) },
CONF_PARSER_TERMINATOR
};
static CONF_PARSER profile_config[] = {
- { FR_CONF_OFFSET("filter", PW_TYPE_TMPL, rlm_ldap_t, profile_filter), .dflt = "(&)", .quote = T_SINGLE_QUOTED_STRING }, //!< Correct filter for when the DN is known.
- { FR_CONF_OFFSET("attribute", PW_TYPE_STRING, rlm_ldap_t, profile_attr) },
- { FR_CONF_OFFSET("default", PW_TYPE_TMPL, rlm_ldap_t, default_profile) },
+ { FR_CONF_OFFSET("filter", FR_TYPE_TMPL, rlm_ldap_t, profile_filter), .dflt = "(&)", .quote = T_SINGLE_QUOTED_STRING }, //!< Correct filter for when the DN is known.
+ { FR_CONF_OFFSET("attribute", FR_TYPE_STRING, rlm_ldap_t, profile_attr) },
+ { FR_CONF_OFFSET("default", FR_TYPE_TMPL, rlm_ldap_t, default_profile) },
CONF_PARSER_TERMINATOR
};
* User configuration
*/
static CONF_PARSER user_config[] = {
- { FR_CONF_OFFSET("filter", PW_TYPE_TMPL, rlm_ldap_t, userobj_filter) },
- { FR_CONF_OFFSET("scope", PW_TYPE_STRING, rlm_ldap_t, userobj_scope_str), .dflt = "sub" },
- { FR_CONF_OFFSET("base_dn", PW_TYPE_TMPL, rlm_ldap_t, userobj_base_dn), .dflt = "", .quote = T_SINGLE_QUOTED_STRING },
- { FR_CONF_OFFSET("sort_by", PW_TYPE_STRING, rlm_ldap_t, userobj_sort_by) },
+ { FR_CONF_OFFSET("filter", FR_TYPE_TMPL, rlm_ldap_t, userobj_filter) },
+ { FR_CONF_OFFSET("scope", FR_TYPE_STRING, rlm_ldap_t, userobj_scope_str), .dflt = "sub" },
+ { FR_CONF_OFFSET("base_dn", FR_TYPE_TMPL, rlm_ldap_t, userobj_base_dn), .dflt = "", .quote = T_SINGLE_QUOTED_STRING },
+ { FR_CONF_OFFSET("sort_by", FR_TYPE_STRING, rlm_ldap_t, userobj_sort_by) },
- { FR_CONF_OFFSET("access_attribute", PW_TYPE_STRING, rlm_ldap_t, userobj_access_attr) },
- { FR_CONF_OFFSET("access_positive", PW_TYPE_BOOLEAN, rlm_ldap_t, access_positive), .dflt = "yes" },
+ { 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" },
/* Should be deprecated */
- { FR_CONF_OFFSET("sasl", PW_TYPE_SUBSECTION, rlm_ldap_t, user_sasl), .subcs = (void const *) sasl_mech_dynamic },
+ { FR_CONF_OFFSET("sasl", FR_TYPE_SUBSECTION, rlm_ldap_t, user_sasl), .subcs = (void const *) sasl_mech_dynamic },
CONF_PARSER_TERMINATOR
};
* Group configuration
*/
static CONF_PARSER group_config[] = {
- { FR_CONF_OFFSET("filter", PW_TYPE_STRING, rlm_ldap_t, groupobj_filter) },
- { FR_CONF_OFFSET("scope", PW_TYPE_STRING, rlm_ldap_t, groupobj_scope_str), .dflt = "sub" },
- { FR_CONF_OFFSET("base_dn", PW_TYPE_TMPL, rlm_ldap_t, groupobj_base_dn), .dflt = "", .quote = T_SINGLE_QUOTED_STRING },
-
- { FR_CONF_OFFSET("name_attribute", PW_TYPE_STRING, rlm_ldap_t, groupobj_name_attr), .dflt = "cn" },
- { FR_CONF_OFFSET("membership_attribute", PW_TYPE_STRING, rlm_ldap_t, userobj_membership_attr) },
- { FR_CONF_OFFSET("membership_filter", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_ldap_t, groupobj_membership_filter) },
- { FR_CONF_OFFSET("cacheable_name", PW_TYPE_BOOLEAN, rlm_ldap_t, cacheable_group_name), .dflt = "no" },
- { FR_CONF_OFFSET("cacheable_dn", PW_TYPE_BOOLEAN, rlm_ldap_t, cacheable_group_dn), .dflt = "no" },
- { FR_CONF_OFFSET("cache_attribute", PW_TYPE_STRING, rlm_ldap_t, cache_attribute) },
- { FR_CONF_OFFSET("group_attribute", PW_TYPE_STRING, rlm_ldap_t, group_attribute) },
+ { FR_CONF_OFFSET("filter", FR_TYPE_STRING, rlm_ldap_t, groupobj_filter) },
+ { FR_CONF_OFFSET("scope", FR_TYPE_STRING, rlm_ldap_t, groupobj_scope_str), .dflt = "sub" },
+ { FR_CONF_OFFSET("base_dn", FR_TYPE_TMPL, rlm_ldap_t, groupobj_base_dn), .dflt = "", .quote = T_SINGLE_QUOTED_STRING },
+
+ { 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("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
};
static CONF_PARSER client_config[] = {
- { FR_CONF_OFFSET("filter", PW_TYPE_STRING, rlm_ldap_t, clientobj_filter) },
- { FR_CONF_OFFSET("scope", PW_TYPE_STRING, rlm_ldap_t, clientobj_scope_str), .dflt = "sub" },
- { FR_CONF_OFFSET("base_dn", PW_TYPE_STRING, rlm_ldap_t, clientobj_base_dn), .dflt = "" },
+ { FR_CONF_OFFSET("filter", FR_TYPE_STRING, rlm_ldap_t, clientobj_filter) },
+ { FR_CONF_OFFSET("scope", FR_TYPE_STRING, rlm_ldap_t, clientobj_scope_str), .dflt = "sub" },
+ { FR_CONF_OFFSET("base_dn", FR_TYPE_STRING, rlm_ldap_t, clientobj_base_dn), .dflt = "" },
CONF_PARSER_TERMINATOR
};
* Reference for accounting updates
*/
static const CONF_PARSER acct_section_config[] = {
- { FR_CONF_OFFSET("reference", PW_TYPE_STRING | PW_TYPE_XLAT, ldap_acct_section_t, reference), .dflt = "." },
+ { FR_CONF_OFFSET("reference", FR_TYPE_STRING | FR_TYPE_XLAT, ldap_acct_section_t, reference), .dflt = "." },
CONF_PARSER_TERMINATOR
};
/*
* Pool config items
*/
- { FR_CONF_OFFSET("chase_referrals", PW_TYPE_BOOLEAN, rlm_ldap_t, handle_config.chase_referrals) },
+ { FR_CONF_OFFSET("chase_referrals", FR_TYPE_BOOLEAN, rlm_ldap_t, handle_config.chase_referrals) },
- { FR_CONF_OFFSET("use_referral_credentials", PW_TYPE_BOOLEAN, rlm_ldap_t, handle_config.use_referral_credentials), .dflt = "no" },
+ { FR_CONF_OFFSET("use_referral_credentials", FR_TYPE_BOOLEAN, rlm_ldap_t, handle_config.use_referral_credentials), .dflt = "no" },
- { FR_CONF_OFFSET("rebind", PW_TYPE_BOOLEAN, rlm_ldap_t, handle_config.rebind) },
+ { FR_CONF_OFFSET("rebind", FR_TYPE_BOOLEAN, rlm_ldap_t, handle_config.rebind) },
#ifdef LDAP_OPT_NETWORK_TIMEOUT
/* timeout on network activity */
- { FR_CONF_DEPRECATED("net_timeout", PW_TYPE_INTEGER, rlm_ldap_t, handle_config.net_timeout), .dflt = "10" },
+ { FR_CONF_DEPRECATED("net_timeout", FR_TYPE_INTEGER, rlm_ldap_t, handle_config.net_timeout), .dflt = "10" },
#endif
#ifdef LDAP_OPT_X_KEEPALIVE_IDLE
- { FR_CONF_OFFSET("idle", PW_TYPE_INTEGER, rlm_ldap_t, handle_config.keepalive_idle), .dflt = "60" },
+ { FR_CONF_OFFSET("idle", FR_TYPE_INTEGER, rlm_ldap_t, handle_config.keepalive_idle), .dflt = "60" },
#endif
#ifdef LDAP_OPT_X_KEEPALIVE_PROBES
- { FR_CONF_OFFSET("probes", PW_TYPE_INTEGER, rlm_ldap_t, handle_config.keepalive_probes), .dflt = "3" },
+ { FR_CONF_OFFSET("probes", FR_TYPE_INTEGER, rlm_ldap_t, handle_config.keepalive_probes), .dflt = "3" },
#endif
#ifdef LDAP_OPT_X_KEEPALIVE_INTERVAL
- { FR_CONF_OFFSET("interval", PW_TYPE_INTEGER, rlm_ldap_t, handle_config.keepalive_interval), .dflt = "30" },
+ { FR_CONF_OFFSET("interval", FR_TYPE_INTEGER, rlm_ldap_t, handle_config.keepalive_interval), .dflt = "30" },
#endif
- { FR_CONF_OFFSET("dereference", PW_TYPE_STRING, rlm_ldap_t, handle_config.dereference_str) },
+ { 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", PW_TYPE_INTEGER, rlm_ldap_t, handle_config.srv_timelimit), .dflt = "20" },
+ { FR_CONF_OFFSET("srv_timelimit", FR_TYPE_INTEGER, rlm_ldap_t, handle_config.srv_timelimit), .dflt = "20" },
/*
* Instance config items
*/
/* timeout for search results */
- { FR_CONF_OFFSET("res_timeout", PW_TYPE_TIMEVAL, rlm_ldap_t, handle_config.res_timeout), .dflt = "20" },
+ { FR_CONF_OFFSET("res_timeout", FR_TYPE_TIMEVAL, rlm_ldap_t, handle_config.res_timeout), .dflt = "20" },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER global_config[] = {
- { FR_CONF_OFFSET("random_file", PW_TYPE_FILE_EXISTS, rlm_ldap_t, tls_random_file) },
+ { FR_CONF_OFFSET("random_file", FR_TYPE_FILE_EXISTS, rlm_ldap_t, tls_random_file) },
- { FR_CONF_OFFSET("ldap_debug", PW_TYPE_INTEGER, rlm_ldap_t, ldap_debug), .dflt = "0x0000" }, /* Debugging flags to the server */
+ { FR_CONF_OFFSET("ldap_debug", FR_TYPE_INTEGER, rlm_ldap_t, ldap_debug), .dflt = "0x0000" }, /* Debugging flags to the server */
CONF_PARSER_TERMINATOR
};
/*
* Pool config items
*/
- { FR_CONF_OFFSET("server", PW_TYPE_STRING | PW_TYPE_MULTI, rlm_ldap_t, handle_config.server_str) }, /* Do not set to required */
+ { 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", PW_TYPE_SHORT, rlm_ldap_t, handle_config.port) },
+ { FR_CONF_OFFSET("port", FR_TYPE_SHORT, rlm_ldap_t, handle_config.port) },
- { FR_CONF_OFFSET("identity", PW_TYPE_STRING, rlm_ldap_t, handle_config.admin_identity) },
- { FR_CONF_OFFSET("password", PW_TYPE_STRING | PW_TYPE_SECRET, rlm_ldap_t, handle_config.admin_password) },
+ { 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("sasl", PW_TYPE_SUBSECTION, rlm_ldap_t, handle_config.admin_sasl), .subcs = (void const *) sasl_mech_static },
+ { FR_CONF_OFFSET("sasl", FR_TYPE_SUBSECTION, rlm_ldap_t, handle_config.admin_sasl), .subcs = (void const *) sasl_mech_static },
- { FR_CONF_OFFSET("valuepair_attribute", PW_TYPE_STRING, rlm_ldap_t, valuepair_attr) },
+ { FR_CONF_OFFSET("valuepair_attribute", FR_TYPE_STRING, rlm_ldap_t, valuepair_attr) },
#ifdef LDAP_CONTROL_X_SESSION_TRACKING
- { FR_CONF_OFFSET("session_tracking", PW_TYPE_BOOLEAN, rlm_ldap_t, session_tracking), .dflt = "no" },
+ { FR_CONF_OFFSET("session_tracking", FR_TYPE_BOOLEAN, rlm_ldap_t, session_tracking), .dflt = "no" },
#endif
#ifdef WITH_EDIR
/* support for eDirectory Universal Password */
- { FR_CONF_OFFSET("edir", PW_TYPE_BOOLEAN, rlm_ldap_t, edir) }, /* NULL defaults to "no" */
+ { FR_CONF_OFFSET("edir", FR_TYPE_BOOLEAN, 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", PW_TYPE_BOOLEAN, rlm_ldap_t, edir_autz) }, /* NULL defaults to "no" */
+ { FR_CONF_OFFSET("edir_autz", FR_TYPE_BOOLEAN, rlm_ldap_t, edir_autz) }, /* NULL defaults to "no" */
#endif
- { FR_CONF_OFFSET("read_clients", PW_TYPE_BOOLEAN, rlm_ldap_t, do_clients) }, /* NULL defaults to "no" */
+ { FR_CONF_OFFSET("read_clients", FR_TYPE_BOOLEAN, rlm_ldap_t, do_clients) }, /* NULL defaults to "no" */
- { FR_CONF_POINTER("user", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) user_config },
+ { FR_CONF_POINTER("user", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) user_config },
- { FR_CONF_POINTER("group", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) group_config },
+ { FR_CONF_POINTER("group", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) group_config },
- { FR_CONF_POINTER("client", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) client_config },
+ { FR_CONF_POINTER("client", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) client_config },
- { FR_CONF_POINTER("profile", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) profile_config },
+ { FR_CONF_POINTER("profile", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) profile_config },
- { FR_CONF_POINTER("options", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) option_config },
+ { FR_CONF_POINTER("options", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) option_config },
- { FR_CONF_POINTER("global", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) global_config },
+ { FR_CONF_POINTER("global", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) global_config },
- { FR_CONF_OFFSET("tls", PW_TYPE_SUBSECTION, rlm_ldap_t, handle_config), .subcs = (void const *) tls_config },
+ { FR_CONF_OFFSET("tls", FR_TYPE_SUBSECTION, rlm_ldap_t, handle_config), .subcs = (void const *) tls_config },
CONF_PARSER_TERMINATOR
};
fr_dict_attr_flags_t flags;
memset(&flags, 0, sizeof(flags));
- if (fr_dict_attr_add(NULL, fr_dict_root(fr_dict_internal), inst->cache_attribute, -1, PW_TYPE_STRING,
+ if (fr_dict_attr_add(NULL, fr_dict_root(fr_dict_internal), inst->cache_attribute, -1, FR_TYPE_STRING,
flags) < 0) {
PERROR("Error creating cache attribute");
error:
static const CONF_PARSER file_config[] = {
- { FR_CONF_OFFSET("filename", PW_TYPE_FILE_OUTPUT | PW_TYPE_XLAT, linelog_instance_t, file.name) },
- { FR_CONF_OFFSET("permissions", PW_TYPE_INTEGER, linelog_instance_t, file.permissions), .dflt = "0600" },
- { FR_CONF_OFFSET("group", PW_TYPE_STRING, linelog_instance_t, file.group_str) },
- { FR_CONF_OFFSET("escape_filenames", PW_TYPE_BOOLEAN, linelog_instance_t, file.escape), .dflt = "no" },
+ { 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("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" },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER syslog_config[] = {
- { FR_CONF_OFFSET("facility", PW_TYPE_STRING, linelog_instance_t, syslog.facility) },
- { FR_CONF_OFFSET("severity", PW_TYPE_STRING, linelog_instance_t, syslog.severity), .dflt = "info" },
+ { FR_CONF_OFFSET("facility", FR_TYPE_STRING, linelog_instance_t, syslog.facility) },
+ { FR_CONF_OFFSET("severity", FR_TYPE_STRING, linelog_instance_t, syslog.severity), .dflt = "info" },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER unix_config[] = {
- { FR_CONF_OFFSET("filename", PW_TYPE_FILE_INPUT, linelog_instance_t, unix_sock.path) },
+ { FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT, linelog_instance_t, unix_sock.path) },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER udp_config[] = {
- { FR_CONF_OFFSET("server", PW_TYPE_COMBO_IP_ADDR, linelog_net_t, dst_ipaddr) },
- { FR_CONF_OFFSET("port", PW_TYPE_SHORT, linelog_net_t, port) },
- { FR_CONF_OFFSET("timeout", PW_TYPE_TIMEVAL, linelog_net_t, timeout), .dflt = "1000" },
+ { 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("timeout", FR_TYPE_TIMEVAL, linelog_net_t, timeout), .dflt = "1000" },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER tcp_config[] = {
- { FR_CONF_OFFSET("server", PW_TYPE_COMBO_IP_ADDR, linelog_net_t, dst_ipaddr) },
- { FR_CONF_OFFSET("port", PW_TYPE_SHORT, linelog_net_t, port) },
- { FR_CONF_OFFSET("timeout", PW_TYPE_TIMEVAL, linelog_net_t, timeout), .dflt = "1000" },
+ { 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("timeout", FR_TYPE_TIMEVAL, linelog_net_t, timeout), .dflt = "1000" },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("destination", PW_TYPE_STRING | PW_TYPE_REQUIRED, linelog_instance_t, log_dst_str) },
+ { FR_CONF_OFFSET("destination", FR_TYPE_STRING | FR_TYPE_REQUIRED, linelog_instance_t, log_dst_str) },
- { FR_CONF_OFFSET("delimiter", PW_TYPE_STRING, linelog_instance_t, delimiter), .dflt = "\n" },
- { FR_CONF_OFFSET("format", PW_TYPE_TMPL, linelog_instance_t, log_src) },
- { FR_CONF_OFFSET("reference", PW_TYPE_TMPL, linelog_instance_t, log_ref) },
+ { FR_CONF_OFFSET("delimiter", FR_TYPE_STRING, linelog_instance_t, delimiter), .dflt = "\n" },
+ { FR_CONF_OFFSET("format", FR_TYPE_TMPL, linelog_instance_t, log_src) },
+ { FR_CONF_OFFSET("reference", FR_TYPE_TMPL, linelog_instance_t, log_ref) },
/*
* Log destinations
*/
- { FR_CONF_POINTER("file", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) file_config },
- { FR_CONF_POINTER("syslog", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) syslog_config },
- { FR_CONF_POINTER("unix", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) unix_config },
- { FR_CONF_OFFSET("tcp", PW_TYPE_SUBSECTION, linelog_instance_t, tcp), .subcs= (void const *) tcp_config },
- { FR_CONF_OFFSET("udp", PW_TYPE_SUBSECTION, linelog_instance_t, udp), .subcs = (void const *) udp_config },
+ { FR_CONF_POINTER("file", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) file_config },
+ { FR_CONF_POINTER("syslog", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) syslog_config },
+ { FR_CONF_POINTER("unix", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) unix_config },
+ { FR_CONF_OFFSET("tcp", FR_TYPE_SUBSECTION, linelog_instance_t, tcp), .subcs= (void const *) tcp_config },
+ { FR_CONF_OFFSET("udp", FR_TYPE_SUBSECTION, linelog_instance_t, udp), .subcs = (void const *) udp_config },
/*
* Deprecated config items
*/
- { FR_CONF_OFFSET("filename", PW_TYPE_FILE_OUTPUT | PW_TYPE_DEPRECATED, linelog_instance_t, file.name) },
- { FR_CONF_OFFSET("permissions", PW_TYPE_INTEGER | PW_TYPE_DEPRECATED, linelog_instance_t, file.permissions) },
- { FR_CONF_OFFSET("group", PW_TYPE_STRING | PW_TYPE_DEPRECATED, linelog_instance_t, file.group_str) },
+ { 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("group", FR_TYPE_STRING | FR_TYPE_DEPRECATED, linelog_instance_t, file.group_str) },
- { FR_CONF_OFFSET("syslog_facility", PW_TYPE_STRING | PW_TYPE_DEPRECATED, linelog_instance_t, syslog.facility) },
- { FR_CONF_OFFSET("syslog_severity", PW_TYPE_STRING | PW_TYPE_DEPRECATED, linelog_instance_t, syslog.severity) },
+ { FR_CONF_OFFSET("syslog_facility", FR_TYPE_STRING | FR_TYPE_DEPRECATED, linelog_instance_t, syslog.facility) },
+ { FR_CONF_OFFSET("syslog_severity", FR_TYPE_STRING | FR_TYPE_DEPRECATED, linelog_instance_t, syslog.severity) },
CONF_PARSER_TERMINATOR
};
}
switch (vp->vp_type) {
- case PW_TYPE_OCTETS:
- case PW_TYPE_STRING:
+ case FR_TYPE_OCTETS:
+ case FR_TYPE_STRING:
vector[i].iov_base = vp->vp_ptr;
vector[i].iov_len = vp->vp_length;
break;
} rlm_logintime_t;
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("minimum_timeout", PW_TYPE_INTEGER, rlm_logintime_t, min_time), .dflt = "60" },
+ { FR_CONF_OFFSET("minimum_timeout", FR_TYPE_INTEGER, rlm_logintime_t, min_time), .dflt = "60" },
CONF_PARSER_TERMINATOR
};
if (!vp) return -1;
switch (vp->vp_type) {
- case PW_TYPE_DATE:
- case PW_TYPE_ETHERNET:
- case PW_TYPE_IPV4_ADDR:
- case PW_TYPE_IPV6_ADDR:
- case PW_TYPE_IPV4_PREFIX:
- case PW_TYPE_IPV6_PREFIX:
- case PW_TYPE_IFID:
- case PW_TYPE_TLV:
- case PW_TYPE_INTEGER64:
+ case FR_TYPE_DATE:
+ case FR_TYPE_ETHERNET:
+ case FR_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV4_PREFIX:
+ case FR_TYPE_IPV6_PREFIX:
+ case FR_TYPE_IFID:
+ case FR_TYPE_TLV:
+ case FR_TYPE_INTEGER64:
fr_pair_value_snprint(buffer, sizeof(buffer), vp, '\0');
lua_pushstring(L, buffer);
break;
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
lua_pushlstring(L, vp->vp_strvalue, vp->vp_length);
break;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
lua_pushlstring(L, (char const *)vp->vp_octets, vp->vp_length); /* lstring variant is embedded NULL safe */
break;
- case PW_TYPE_BYTE:
- case PW_TYPE_SHORT:
- case PW_TYPE_INTEGER:
- case PW_TYPE_SIGNED:
+ case FR_TYPE_BYTE:
+ case FR_TYPE_SHORT:
+ case FR_TYPE_INTEGER:
+ case FR_TYPE_SIGNED:
lua_pushinteger(L, vp->vp_integer);
break;
switch (lua_type(L, -1)) {
case LUA_TNUMBER:
switch (vp->vp_type) {
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
{
char *p;
p = talloc_asprintf(vp, "%f", lua_tonumber(L, -1));
break;
}
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
vp->vp_integer = (uint32_t) lua_tointeger(L, -1);
break;
- case PW_TYPE_IPV4_ADDR:
- case PW_TYPE_COMBO_IP_ADDR:
+ case FR_TYPE_IPV4_ADDR:
+ case FR_TYPE_COMBO_IP_ADDR:
vp->vp_ipv4addr = (uint32_t) lua_tointeger(L, -1);
break;
- case PW_TYPE_DATE:
+ case FR_TYPE_DATE:
vp->vp_date = (uint32_t) lua_tointeger(L, -1);
break;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
{
lua_Number number = lua_tonumber(L, -1);
fr_pair_value_memcpy(vp, (uint8_t*) &number, sizeof(number));
}
break;
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
vp->vp_byte = (uint8_t) lua_tointeger(L, -1);
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
vp->vp_short = (uint16_t) lua_tointeger(L, -1);
break;
- case PW_TYPE_SIGNED:
+ case FR_TYPE_SIGNED:
vp->vp_signed = (int32_t) lua_tointeger(L, -1);
break;
- case PW_TYPE_INTEGER64:
+ case FR_TYPE_INTEGER64:
vp->vp_integer64 = (uint64_t) lua_tointeger(L, -1);
break;
* any other unprintable chars any different from those in a plaintext
* string.
*/
- if (da->type == PW_TYPE_OCTETS) {
+ if (da->type == FR_TYPE_OCTETS) {
uint8_t const *p;
size_t len;
* buffer over-flows.
*/
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("filename", PW_TYPE_FILE_INPUT | PW_TYPE_REQUIRED, rlm_lua_t, module), NULL},
- { FR_CONF_OFFSET("threads", PW_TYPE_BOOLEAN, rlm_lua_t, threads), .dflt = "no"},
- { FR_CONF_OFFSET("func_instantiate", PW_TYPE_STRING, rlm_lua_t, func_instantiate), NULL},
- { FR_CONF_OFFSET("func_detach", PW_TYPE_STRING, rlm_lua_t, func_detach), NULL},
- { FR_CONF_OFFSET("func_authorize", PW_TYPE_STRING, rlm_lua_t, func_authorize), NULL},
- { FR_CONF_OFFSET("func_authenticate", PW_TYPE_STRING, rlm_lua_t, func_authenticate), NULL},
+ { 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("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},
+ { FR_CONF_OFFSET("func_authenticate", FR_TYPE_STRING, rlm_lua_t, func_authenticate), NULL},
#ifdef WITH_ACCOUNTING
- { FR_CONF_OFFSET("func_accounting", PW_TYPE_STRING, rlm_lua_t, func_accounting), NULL},
- { FR_CONF_OFFSET("func_preacct", PW_TYPE_STRING, rlm_lua_t, func_preacct), NULL},
+ { FR_CONF_OFFSET("func_accounting", FR_TYPE_STRING, rlm_lua_t, func_accounting), NULL},
+ { FR_CONF_OFFSET("func_preacct", FR_TYPE_STRING, rlm_lua_t, func_preacct), NULL},
#endif
- { FR_CONF_OFFSET("func_checksimul", PW_TYPE_STRING, rlm_lua_t, func_checksimul), NULL},
- { FR_CONF_OFFSET("func_xlat", PW_TYPE_STRING, rlm_lua_t, func_xlat), NULL},
+ { FR_CONF_OFFSET("func_checksimul", FR_TYPE_STRING, rlm_lua_t, func_checksimul), NULL},
+ { FR_CONF_OFFSET("func_xlat", FR_TYPE_STRING, rlm_lua_t, func_xlat), NULL},
#ifdef WITH_PROXY
- { FR_CONF_OFFSET("func_pre_proxy", PW_TYPE_STRING, rlm_lua_t, func_pre_proxy), NULL},
- { FR_CONF_OFFSET("func_post_proxy", PW_TYPE_STRING, rlm_lua_t, func_post_proxy), NULL},
+ { FR_CONF_OFFSET("func_pre_proxy", FR_TYPE_STRING, rlm_lua_t, func_pre_proxy), NULL},
+ { FR_CONF_OFFSET("func_post_proxy", FR_TYPE_STRING, rlm_lua_t, func_post_proxy), NULL},
#endif
- { FR_CONF_OFFSET("func_post_auth", PW_TYPE_STRING, rlm_lua_t, func_post_auth), NULL},
+ { FR_CONF_OFFSET("func_post_auth", FR_TYPE_STRING, rlm_lua_t, func_post_auth), NULL},
#ifdef WITH_COA
- { FR_CONF_OFFSET("func_recv_coa", PW_TYPE_STRING, rlm_lua_t, func_recv_coa), NULL},
- { FR_CONF_OFFSET("func_send_coa", PW_TYPE_STRING, rlm_lua_t, func_send_coa), NULL},
+ { FR_CONF_OFFSET("func_recv_coa", FR_TYPE_STRING, rlm_lua_t, func_recv_coa), NULL},
+ { FR_CONF_OFFSET("func_send_coa", FR_TYPE_STRING, rlm_lua_t, func_send_coa), NULL},
#endif
CONF_PARSER_TERMINATOR
static const CONF_PARSER passchange_config[] = {
- { FR_CONF_OFFSET("ntlm_auth", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_mschap_t, ntlm_cpw) },
- { FR_CONF_OFFSET("ntlm_auth_username", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_mschap_t, ntlm_cpw_username) },
- { FR_CONF_OFFSET("ntlm_auth_domain", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_mschap_t, ntlm_cpw_domain) },
- { FR_CONF_OFFSET("local_cpw", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_mschap_t, local_cpw) },
+ { FR_CONF_OFFSET("ntlm_auth", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_mschap_t, ntlm_cpw) },
+ { FR_CONF_OFFSET("ntlm_auth_username", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_mschap_t, ntlm_cpw_username) },
+ { FR_CONF_OFFSET("ntlm_auth_domain", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_mschap_t, ntlm_cpw_domain) },
+ { FR_CONF_OFFSET("local_cpw", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_mschap_t, local_cpw) },
CONF_PARSER_TERMINATOR
};
/*
* Cache the password by default.
*/
- { FR_CONF_OFFSET("use_mppe", PW_TYPE_BOOLEAN, rlm_mschap_t, use_mppe), .dflt = "yes" },
- { FR_CONF_OFFSET("require_encryption", PW_TYPE_BOOLEAN, rlm_mschap_t, require_encryption), .dflt = "no" },
- { FR_CONF_OFFSET("require_strong", PW_TYPE_BOOLEAN, rlm_mschap_t, require_strong), .dflt = "no" },
- { FR_CONF_OFFSET("with_ntdomain_hack", PW_TYPE_BOOLEAN, rlm_mschap_t, with_ntdomain_hack), .dflt = "yes" },
- { FR_CONF_OFFSET("ntlm_auth", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_mschap_t, ntlm_auth) },
- { FR_CONF_OFFSET("ntlm_auth_timeout", PW_TYPE_INTEGER, rlm_mschap_t, ntlm_auth_timeout) },
- { FR_CONF_POINTER("passchange", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) passchange_config },
- { FR_CONF_OFFSET("allow_retry", PW_TYPE_BOOLEAN, rlm_mschap_t, allow_retry), .dflt = "yes" },
- { FR_CONF_OFFSET("retry_msg", PW_TYPE_STRING, rlm_mschap_t, retry_msg) },
- { FR_CONF_OFFSET("winbind_username", PW_TYPE_TMPL, rlm_mschap_t, wb_username) },
- { FR_CONF_OFFSET("winbind_domain", PW_TYPE_TMPL, rlm_mschap_t, wb_domain) },
+ { 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("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_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("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", PW_TYPE_BOOLEAN, rlm_mschap_t, wb_retry_with_normalised_username), .dflt = "no" },
+ { FR_CONF_OFFSET("winbind_retry_with_normalised_username", FR_TYPE_BOOLEAN, rlm_mschap_t, wb_retry_with_normalised_username), .dflt = "no" },
#endif
#ifdef __APPLE__
- { FR_CONF_OFFSET("use_open_directory", PW_TYPE_BOOLEAN, rlm_mschap_t, open_directory), .dflt = "yes" },
+ { FR_CONF_OFFSET("use_open_directory", FR_TYPE_BOOLEAN, rlm_mschap_t, open_directory), .dflt = "yes" },
#endif
CONF_PARSER_TERMINATOR
};
return;
}
- if (vp->vp_type == PW_TYPE_STRING) {
+ if (vp->vp_type == FR_TYPE_STRING) {
char *p;
p = talloc_array(vp, char, len + 1 + 1); /* Account for the ident byte */
} rlm_pam_t;
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("pam_auth", PW_TYPE_STRING, rlm_pam_t, pam_auth_name) },
+ { FR_CONF_OFFSET("pam_auth", FR_TYPE_STRING, rlm_pam_t, pam_auth_name) },
CONF_PARSER_TERMINATOR
};
} rlm_pap_t;
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("normalise", PW_TYPE_BOOLEAN, rlm_pap_t, normify), .dflt = "yes" },
+ { FR_CONF_OFFSET("normalise", FR_TYPE_BOOLEAN, rlm_pap_t, normify), .dflt = "yes" },
CONF_PARSER_TERMINATOR
};
if (min_len >= sizeof(buffer)) return; /* paranoia */
- rad_assert((vp->da->type == PW_TYPE_OCTETS) || (vp->da->type == PW_TYPE_STRING));
+ rad_assert((vp->da->type == FR_TYPE_OCTETS) || (vp->da->type == FR_TYPE_STRING));
/*
* Hex encoding. Length is even, and it's greater than
* Ensure this is only ever called with a
* string type attribute.
*/
- rad_assert(vp->da->type == PW_TYPE_STRING);
+ rad_assert(vp->da->type == FR_TYPE_STRING);
redo:
p = vp->vp_strvalue;
* we ensure that there's a trailing zero, too.
*/
new = fr_pair_afrom_num(request, 0, attr);
- if (new->da->type == PW_TYPE_OCTETS) {
+ if (new->da->type == FR_TYPE_OCTETS) {
fr_pair_value_memcpy(new, (uint8_t const *) q + 1, (len - hlen) + 1);
new->vp_length = (len - hlen); /* lie about the length */
} else {
} rlm_passwd_t;
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("filename", PW_TYPE_FILE_INPUT | PW_TYPE_REQUIRED, rlm_passwd_t, filename) },
- { FR_CONF_OFFSET("format", PW_TYPE_STRING | PW_TYPE_REQUIRED, rlm_passwd_t, format) },
- { FR_CONF_OFFSET("delimiter", PW_TYPE_STRING, rlm_passwd_t, delimiter), .dflt = ":" },
+ { FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT | FR_TYPE_REQUIRED, rlm_passwd_t, filename) },
+ { 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", PW_TYPE_BOOLEAN, rlm_passwd_t, ignore_nislike), .dflt = "yes" },
+ { FR_CONF_OFFSET("ignore_nislike", FR_TYPE_BOOLEAN, rlm_passwd_t, ignore_nislike), .dflt = "yes" },
- { FR_CONF_OFFSET("ignore_empty", PW_TYPE_BOOLEAN, rlm_passwd_t, ignore_empty), .dflt = "yes" },
+ { FR_CONF_OFFSET("ignore_empty", FR_TYPE_BOOLEAN, rlm_passwd_t, ignore_empty), .dflt = "yes" },
- { FR_CONF_OFFSET("allow_multiple_keys", PW_TYPE_BOOLEAN, rlm_passwd_t, allow_multiple), .dflt = "no" },
+ { FR_CONF_OFFSET("allow_multiple_keys", FR_TYPE_BOOLEAN, rlm_passwd_t, allow_multiple), .dflt = "no" },
- { FR_CONF_OFFSET("hash_size", PW_TYPE_INTEGER, rlm_passwd_t, hash_size), .dflt = "100" },
+ { FR_CONF_OFFSET("hash_size", FR_TYPE_INTEGER, rlm_passwd_t, hash_size), .dflt = "100" },
CONF_PARSER_TERMINATOR
};
/*
* A mapping of configuration file names to internal variables.
*/
-#define RLM_PERL_CONF(_x) { FR_CONF_OFFSET("func_" STRINGIFY(_x), PW_TYPE_STRING, rlm_perl_t, func_##_x), \
+#define RLM_PERL_CONF(_x) { FR_CONF_OFFSET("func_" STRINGIFY(_x), FR_TYPE_STRING, rlm_perl_t, func_##_x), \
.data = NULL, .dflt = STRINGIFY(_x), .quote = T_INVALID }
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("filename", PW_TYPE_FILE_INPUT | PW_TYPE_REQUIRED, rlm_perl_t, module) },
+ { FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT | FR_TYPE_REQUIRED, rlm_perl_t, module) },
RLM_PERL_CONF(authorize),
RLM_PERL_CONF(authenticate),
RLM_PERL_CONF(recv_coa),
RLM_PERL_CONF(send_coa),
#endif
- { FR_CONF_OFFSET("perl_flags", PW_TYPE_STRING, rlm_perl_t, perl_flags) },
+ { FR_CONF_OFFSET("perl_flags", FR_TYPE_STRING, rlm_perl_t, perl_flags) },
- { FR_CONF_OFFSET("func_start_accounting", PW_TYPE_STRING, rlm_perl_t, func_start_accounting) },
+ { FR_CONF_OFFSET("func_start_accounting", FR_TYPE_STRING, rlm_perl_t, func_start_accounting) },
- { FR_CONF_OFFSET("func_stop_accounting", PW_TYPE_STRING, rlm_perl_t, func_stop_accounting) },
+ { FR_CONF_OFFSET("func_stop_accounting", FR_TYPE_STRING, rlm_perl_t, func_stop_accounting) },
CONF_PARSER_TERMINATOR
};
char buffer[1024];
switch (vp->vp_type) {
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
RDEBUG("$%s{'%s'}[%i] = &%s:%s -> '%s'", hash_name, vp->da->name, *i,
list_name, vp->da->name, vp->vp_strvalue);
av_push(av, newSVpvn(vp->vp_strvalue, vp->vp_length));
break;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
if (RDEBUG_ENABLED) {
char *hex;
* It's a normal single valued attribute
*/
switch (vp->vp_type) {
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
RDEBUG("$%s{'%s'} = &%s:%s -> '%s'", hash_name, vp->da->name, list_name,
vp->da->name, vp->vp_strvalue);
(void)hv_store(rad_hv, name, strlen(name), newSVpvn(vp->vp_strvalue, vp->vp_length), 0);
break;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
if (RDEBUG_ENABLED) {
char *hex;
}
switch (vp->vp_type) {
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
fr_pair_value_bstrncpy(vp, val, len);
break;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
fr_pair_value_memcpy(vp, (uint8_t const *)val, len);
break;
} rlm_preprocess_t;
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("huntgroups", PW_TYPE_FILE_INPUT, rlm_preprocess_t, huntgroup_file) },
- { FR_CONF_OFFSET("hints", PW_TYPE_FILE_INPUT, rlm_preprocess_t, hints_file) },
- { FR_CONF_OFFSET("with_ascend_hack", PW_TYPE_BOOLEAN, rlm_preprocess_t, with_ascend_hack), .dflt = "no" },
- { FR_CONF_OFFSET("ascend_channels_per_line", PW_TYPE_INTEGER, rlm_preprocess_t, ascend_channels_per_line), .dflt = "23" },
+ { 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_ntdomain_hack", PW_TYPE_BOOLEAN, rlm_preprocess_t, with_ntdomain_hack), .dflt = "no" },
- { FR_CONF_OFFSET("with_specialix_jetstream_hack", PW_TYPE_BOOLEAN, rlm_preprocess_t, with_specialix_jetstream_hack), .dflt = "no" },
- { FR_CONF_OFFSET("with_cisco_vsa_hack", PW_TYPE_BOOLEAN, rlm_preprocess_t, with_cisco_vsa_hack), .dflt = "no" },
- { FR_CONF_OFFSET("with_alvarion_vsa_hack", PW_TYPE_BOOLEAN, rlm_preprocess_t, with_alvarion_vsa_hack), .dflt = "no" },
+ { 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" },
CONF_PARSER_TERMINATOR
};
continue; /* not a Cisco or Quintum VSA, continue */
}
- if (vp->vp_type != PW_TYPE_STRING) continue;
+ if (vp->vp_type != FR_TYPE_STRING) continue;
/*
* No weird packing. Ignore it.
if (vp->da->vendor != 12394) continue;
- if (vp->vp_type != PW_TYPE_STRING) continue;
+ if (vp->vp_type != FR_TYPE_STRING) continue;
da = fr_dict_attr_by_num(NULL, 12394, number);
if (!da) continue;
*/
static CONF_PARSER module_config[] = {
-#define A(x) { FR_CONF_OFFSET("mod_" #x, PW_TYPE_STRING, rlm_python_t, x.module_name), .dflt = "${.module}" }, \
- { FR_CONF_OFFSET("func_" #x, PW_TYPE_STRING, rlm_python_t, x.function_name) },
+#define A(x) { FR_CONF_OFFSET("mod_" #x, FR_TYPE_STRING, rlm_python_t, x.module_name), .dflt = "${.module}" }, \
+ { FR_CONF_OFFSET("func_" #x, FR_TYPE_STRING, rlm_python_t, x.function_name) },
A(instantiate)
A(authorize)
#undef A
- { FR_CONF_OFFSET("python_path", PW_TYPE_STRING, rlm_python_t, python_path) },
- { FR_CONF_OFFSET("cext_compat", PW_TYPE_BOOLEAN, rlm_python_t, cext_compat), .dflt = false },
+ { 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 },
CONF_PARSER_TERMINATOR
};
PyTuple_SET_ITEM(pp, 0, attribute);
switch (vp->vp_type) {
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
value = PyUnicode_FromStringAndSize(vp->vp_strvalue, vp->vp_length);
break;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
value = PyString_FromStringAndSize((char const *)vp->vp_octets, vp->vp_length);
break;
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
value = PyLong_FromUnsignedLong(vp->vp_integer);
break;
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
value = PyLong_FromUnsignedLong(vp->vp_byte);
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
value = PyLong_FromUnsignedLong(vp->vp_short);
break;
- case PW_TYPE_SIGNED:
+ case FR_TYPE_SIGNED:
value = PyLong_FromLong(vp->vp_signed);
break;
- case PW_TYPE_INTEGER64:
+ case FR_TYPE_INTEGER64:
value = PyLong_FromUnsignedLongLong(vp->vp_integer64);
break;
- case PW_TYPE_SIZE:
+ case FR_TYPE_SIZE:
value = PyLong_FromUnsignedLongLong((unsigned long long)vp->vp_size);
break;
- case PW_TYPE_DECIMAL:
+ case FR_TYPE_DECIMAL:
value = PyFloat_FromDouble(vp->vp_decimal);
break;
- case PW_TYPE_BOOLEAN:
+ case FR_TYPE_BOOLEAN:
value = PyBool_FromLong(vp->vp_bool);
break;
- case PW_TYPE_TIMEVAL:
- case PW_TYPE_IPV4_ADDR:
- case PW_TYPE_DATE:
- case PW_TYPE_ABINARY:
- case PW_TYPE_IFID:
- case PW_TYPE_IPV6_ADDR:
- case PW_TYPE_IPV6_PREFIX:
- case PW_TYPE_ETHERNET:
- case PW_TYPE_COMBO_IP_ADDR:
- case PW_TYPE_IPV4_PREFIX:
- case PW_TYPE_COMBO_IP_PREFIX:
+ case FR_TYPE_TIMEVAL:
+ case FR_TYPE_IPV4_ADDR:
+ case FR_TYPE_DATE:
+ case FR_TYPE_ABINARY:
+ case FR_TYPE_IFID:
+ case FR_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_PREFIX:
+ case FR_TYPE_ETHERNET:
+ case FR_TYPE_COMBO_IP_ADDR:
+ case FR_TYPE_IPV4_PREFIX:
+ case FR_TYPE_COMBO_IP_PREFIX:
{
size_t len;
char buffer[256];
}
break;
- case PW_TYPE_STRUCTURAL:
- case PW_TYPE_BAD:
+ case FR_TYPE_STRUCTURAL:
+ case FR_TYPE_BAD:
rad_assert(0);
return -1;
}
} rlm_radius_client_instance_t;
static const CONF_PARSER listen_config[] = {
- { FR_CONF_OFFSET("ipaddr", PW_TYPE_IPV4_ADDR, rlm_radius_client_instance_t, src_ipaddr) },
+ { FR_CONF_OFFSET("ipaddr", FR_TYPE_IPV4_ADDR, rlm_radius_client_instance_t, src_ipaddr) },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER module_config[] = {
- { FR_CONF_POINTER("listen", PW_TYPE_SUBSECTION, NULL), .dflt = (void const *) listen_config },
+ { FR_CONF_POINTER("listen", FR_TYPE_SUBSECTION, NULL), .dflt = (void const *) listen_config },
- { FR_CONF_OFFSET("virtual_server", PW_TYPE_STRING, rlm_radius_client_instance_t, virtual_server) },
+ { FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING, rlm_radius_client_instance_t, virtual_server) },
CONF_PARSER_TERMINATOR
};
} rlm_radutmp_t;
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("filename", PW_TYPE_FILE_OUTPUT | PW_TYPE_REQUIRED, rlm_radutmp_t, filename), .dflt = RADUTMP },
- { FR_CONF_OFFSET("username", PW_TYPE_STRING | PW_TYPE_REQUIRED | PW_TYPE_XLAT, rlm_radutmp_t, username), .dflt = "%{User-Name}" },
- { FR_CONF_OFFSET("case_sensitive", PW_TYPE_BOOLEAN, rlm_radutmp_t, case_sensitive), .dflt = "yes" },
- { FR_CONF_OFFSET("check_with_nas", PW_TYPE_BOOLEAN, rlm_radutmp_t, check_nas), .dflt = "yes" },
- { FR_CONF_OFFSET("permissions", PW_TYPE_INTEGER, rlm_radutmp_t, permission), .dflt = "0644" },
- { FR_CONF_OFFSET("caller_id", PW_TYPE_BOOLEAN, rlm_radutmp_t, caller_id_ok), .dflt = "no" },
+ { 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" },
CONF_PARSER_TERMINATOR
};
} rlm_realm_t;
static CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("format", PW_TYPE_STRING, rlm_realm_t, format_string), .dflt = "suffix" },
- { FR_CONF_OFFSET("delimiter", PW_TYPE_STRING, rlm_realm_t, delim), .dflt = "@" },
- { FR_CONF_OFFSET("ignore_default", PW_TYPE_BOOLEAN, rlm_realm_t, ignore_default), .dflt = "no" },
- { FR_CONF_OFFSET("ignore_null", PW_TYPE_BOOLEAN, rlm_realm_t, ignore_null), .dflt = "no" },
+ { 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" },
#ifdef HAVE_TRUST_ROUTER_TR_DH_H
- { FR_CONF_OFFSET("default_community", PW_TYPE_STRING, rlm_realm_t, default_community) },
- { FR_CONF_OFFSET("rp_realm", PW_TYPE_STRING, rlm_realm_t, rp_realm) },
- { FR_CONF_OFFSET("trust_router", PW_TYPE_STRING, rlm_realm_t, trust_router) },
- { FR_CONF_OFFSET("tr_port", PW_TYPE_INTEGER, rlm_realm_t, tr_port), .dflt = "0" },
+ { 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" },
#endif
CONF_PARSER_TERMINATOR
};
/*
* Catch the case of broken dictionaries.
*/
- if (vp->vp_type != PW_TYPE_STRING) return RLM_MODULE_NOOP;
+ if (vp->vp_type != FR_TYPE_STRING) return RLM_MODULE_NOOP;
/*
* The string is too short.
/** Convert a string or integer type to #value_box_t of specified type
*
- * Will work with REDIS_REPLY_STRING (which is converted to #PW_TYPE_STRING
+ * 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
- * #PW_TYPE_INTEGER64, then cast to dst_type).
+ * #FR_TYPE_INTEGER64, then cast to dst_type).
*
* @note Any unsupported types will trigger an assert. You must check the
* reply type prior to calling this function.
* - -1 on cast or parse failure.
*/
int fr_redis_reply_to_value_box(TALLOC_CTX *ctx, value_box_t *out, redisReply *reply,
- PW_TYPE dst_type, fr_dict_attr_t const *dst_enumv)
+ fr_type_t dst_type, fr_dict_attr_t const *dst_enumv)
{
value_box_t in;
return -1;
}
if (reply->integer < 0) { /* 32bit signed (supported) */
- in.type = PW_TYPE_SIGNED;
+ in.type = FR_TYPE_SIGNED;
in.datum.sinteger = (int32_t) reply->integer;
}
else if (reply->integer > UINT32_MAX) { /* 64bit unsigned (supported) */
- in.type = PW_TYPE_INTEGER64;
+ in.type = FR_TYPE_INTEGER64;
in.datum.integer64 = (uint64_t) reply->integer;
}
else if (reply->integer > UINT16_MAX) { /* 32bit unsigned (supported) */
- in.type = PW_TYPE_INTEGER;
+ in.type = FR_TYPE_INTEGER;
in.datum.integer = (uint32_t) reply->integer;
}
else if (reply->integer > UINT8_MAX) { /* 16bit unsigned (supported) */
- in.type = PW_TYPE_SHORT;
+ in.type = FR_TYPE_SHORT;
in.datum.ushort = (uint16_t) reply->integer;
}
else { /* 8bit unsigned (supported) */
- in.type = PW_TYPE_BYTE;
+ in.type = FR_TYPE_BYTE;
in.datum.byte = (uint8_t) reply->integer;
}
break;
case REDIS_REPLY_STRING:
- in.type = PW_TYPE_STRING;
+ in.type = FR_TYPE_STRING;
in.datum.ptr = reply->str;
in.datum.length = reply->len;
break;
if (!key) return -1;
switch (map->rhs->tmpl_value_box_type) {
- case PW_TYPE_STRING:
- case PW_TYPE_OCTETS:
+ case FR_TYPE_STRING:
+ case FR_TYPE_OCTETS:
out[2] = map->rhs->tmpl_value_box_datum.ptr;
out_len[2] = map->rhs->tmpl_value_box_length;
break;
} fr_redis_conf_t;
#define REDIS_COMMON_CONFIG \
- { FR_CONF_OFFSET("server", PW_TYPE_STRING | PW_TYPE_REQUIRED | PW_TYPE_MULTI, fr_redis_conf_t, hostname) }, \
- { FR_CONF_OFFSET("port", PW_TYPE_SHORT, fr_redis_conf_t, port), .dflt = "6379" }, \
- { FR_CONF_OFFSET("database", PW_TYPE_INTEGER, fr_redis_conf_t, database), .dflt = "0" }, \
- { FR_CONF_OFFSET("password", PW_TYPE_STRING | PW_TYPE_SECRET, fr_redis_conf_t, password) }, \
- { FR_CONF_OFFSET("max_nodes", PW_TYPE_BYTE, fr_redis_conf_t, max_nodes), .dflt = "20" }, \
- { FR_CONF_OFFSET("max_alt", PW_TYPE_INTEGER, fr_redis_conf_t, max_alt), .dflt = "3" }, \
- { FR_CONF_OFFSET("max_redirects", PW_TYPE_INTEGER, fr_redis_conf_t, max_redirects), .dflt = "2" }
+ { 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("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" }
void fr_redis_version_print(void);
void fr_redis_reply_print(log_lvl_t lvl, redisReply *reply, REQUEST *request, int idx);
int fr_redis_reply_to_value_box(TALLOC_CTX *ctx, value_box_t *out, redisReply *reply,
- PW_TYPE dst_type, fr_dict_attr_t const *dst_enumv);
+ fr_type_t dst_type, fr_dict_attr_t const *dst_enumv);
int fr_redis_reply_to_map(TALLOC_CTX *ctx, vp_map_t **out,
REQUEST *request, redisReply *key, redisReply *op, redisReply *value);
};
static CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("pool_name", PW_TYPE_TMPL | PW_TYPE_REQUIRED, rlm_redis_ippool_t, pool_name) },
+ { FR_CONF_OFFSET("pool_name", FR_TYPE_TMPL | FR_TYPE_REQUIRED, rlm_redis_ippool_t, pool_name) },
- { FR_CONF_OFFSET("device", PW_TYPE_TMPL | PW_TYPE_REQUIRED, rlm_redis_ippool_t, device_id) },
- { FR_CONF_OFFSET("gateway", PW_TYPE_TMPL, rlm_redis_ippool_t, gateway_id) },\
+ { FR_CONF_OFFSET("device", FR_TYPE_TMPL | FR_TYPE_REQUIRED, rlm_redis_ippool_t, device_id) },
+ { FR_CONF_OFFSET("gateway", FR_TYPE_TMPL, rlm_redis_ippool_t, gateway_id) },\
- { FR_CONF_OFFSET("offer_time", PW_TYPE_TMPL, rlm_redis_ippool_t, offer_time) },
- { FR_CONF_OFFSET("lease_time", PW_TYPE_TMPL | PW_TYPE_REQUIRED, rlm_redis_ippool_t, lease_time) },
+ { 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", PW_TYPE_INTEGER, rlm_redis_ippool_t, wait_num) },
- { FR_CONF_OFFSET("wait_timeout", PW_TYPE_TIMEVAL, rlm_redis_ippool_t, wait_timeout) },
+ { FR_CONF_OFFSET("wait_num", FR_TYPE_INTEGER, 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", PW_TYPE_TMPL | PW_TYPE_REQUIRED, rlm_redis_ippool_t, requested_address), .dflt = "%{%{DHCP-Requested-IP-Address}:-%{DHCP-Client-IP-Address}}", .quote = T_DOUBLE_QUOTED_STRING },
- { FR_CONF_DEPRECATED("ip_address", PW_TYPE_TMPL | PW_TYPE_REQUIRED, rlm_redis_ippool_t, NULL) },
+ { 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_DEPRECATED("ip_address", FR_TYPE_TMPL | FR_TYPE_REQUIRED, rlm_redis_ippool_t, NULL) },
- { FR_CONF_OFFSET("allocated_address_attr", PW_TYPE_TMPL | PW_TYPE_ATTRIBUTE | PW_TYPE_REQUIRED, rlm_redis_ippool_t, allocated_address_attr), .dflt = "&reply:DHCP-Your-IP-Address", .quote = T_BARE_WORD },
- { FR_CONF_DEPRECATED("reply_attr", PW_TYPE_TMPL | PW_TYPE_ATTRIBUTE | PW_TYPE_REQUIRED, rlm_redis_ippool_t, NULL) },
+ { FR_CONF_OFFSET("allocated_address_attr", FR_TYPE_TMPL | FR_TYPE_ATTRIBUTE | FR_TYPE_REQUIRED, rlm_redis_ippool_t, allocated_address_attr), .dflt = "&reply:DHCP-Your-IP-Address", .quote = T_BARE_WORD },
+ { FR_CONF_DEPRECATED("reply_attr", FR_TYPE_TMPL | FR_TYPE_ATTRIBUTE | FR_TYPE_REQUIRED, rlm_redis_ippool_t, NULL) },
- { FR_CONF_OFFSET("range_attr", PW_TYPE_TMPL | PW_TYPE_ATTRIBUTE | PW_TYPE_REQUIRED, rlm_redis_ippool_t, range_attr), .dflt = "&reply:Pool-Range", .quote = T_BARE_WORD },
- { FR_CONF_OFFSET("expiry_attr", PW_TYPE_TMPL | PW_TYPE_ATTRIBUTE, rlm_redis_ippool_t, expiry_attr) },
+ { 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", PW_TYPE_BOOLEAN, rlm_redis_ippool_t, ipv4_integer) },
- { FR_CONF_OFFSET("copy_on_update", PW_TYPE_BOOLEAN, rlm_redis_ippool_t, copy_on_update), .dflt = "yes", .quote = T_BARE_WORD },
+ { 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 },
/*
* Split out to allow conversion to universal ippool module with
* minimum of config changes.
*/
- { FR_CONF_POINTER("redis", PW_TYPE_SUBSECTION, NULL), .subcs = redis_config },
+ { FR_CONF_POINTER("redis", FR_TYPE_SUBSECTION, NULL), .subcs = redis_config },
CONF_PARSER_TERMINATOR
};
if (reply->elements > 1) {
vp_tmpl_t ip_rhs = {
.type = TMPL_TYPE_DATA,
- .tmpl_value_box_type = PW_TYPE_STRING
+ .tmpl_value_box_type = FR_TYPE_STRING
};
vp_map_t ip_map = {
.lhs = inst->allocated_address_attr,
*/
case REDIS_REPLY_INTEGER:
{
- if (ip_map.lhs->tmpl_da->type != PW_TYPE_IPV4_ADDR) {
+ if (ip_map.lhs->tmpl_da->type != FR_TYPE_IPV4_ADDR) {
value_box_t tmp;
memset(&tmp, 0, sizeof(tmp));
tmp.datum.integer = ntohl((uint32_t)reply->element[1]->integer);
- tmp.type = PW_TYPE_INTEGER;
+ tmp.type = FR_TYPE_INTEGER;
- if (value_box_cast(NULL, &ip_map.rhs->tmpl_value_box, PW_TYPE_IPV4_ADDR,
+ if (value_box_cast(NULL, &ip_map.rhs->tmpl_value_box, FR_TYPE_IPV4_ADDR,
NULL, &tmp)) {
RPEDEBUG("Failed converting integer to IPv4 address");
ret = IPPOOL_RCODE_FAIL;
}
} else {
ip_map.rhs->tmpl_value_box_datum.integer = ntohl((uint32_t)reply->element[1]->integer);
- ip_map.rhs->tmpl_value_box_type = PW_TYPE_INTEGER;
+ ip_map.rhs->tmpl_value_box_type = FR_TYPE_INTEGER;
}
}
goto do_ip_map;
case REDIS_REPLY_STRING:
ip_map.rhs->tmpl_value_box_datum.strvalue = reply->element[1]->str;
ip_map.rhs->tmpl_value_box_length = reply->element[1]->len;
- ip_map.rhs->tmpl_value_box_type = PW_TYPE_STRING;
+ ip_map.rhs->tmpl_value_box_type = FR_TYPE_STRING;
do_ip_map:
if (map_to_request(request, &ip_map, map_to_vp, NULL) < 0) {
vp_tmpl_t range_rhs = {
.name = "",
.type = TMPL_TYPE_DATA,
- .tmpl_value_box_type = PW_TYPE_STRING,
+ .tmpl_value_box_type = FR_TYPE_STRING,
.quote = T_DOUBLE_QUOTED_STRING
};
vp_map_t range_map = {
range_map.rhs->tmpl_value_box_datum.strvalue = reply->element[2]->str;
range_map.rhs->tmpl_value_box_length = reply->element[2]->len;
- range_map.rhs->tmpl_value_box_type = PW_TYPE_STRING;
+ range_map.rhs->tmpl_value_box_type = FR_TYPE_STRING;
if (map_to_request(request, &range_map, map_to_vp, NULL) < 0) {
ret = IPPOOL_RCODE_FAIL;
goto finish;
vp_tmpl_t expiry_rhs = {
.name = "",
.type = TMPL_TYPE_DATA,
- .tmpl_value_box_type = PW_TYPE_STRING,
+ .tmpl_value_box_type = FR_TYPE_STRING,
.quote = T_DOUBLE_QUOTED_STRING
};
vp_map_t expiry_map = {
}
expiry_map.rhs->tmpl_value_box_datum.integer = reply->element[3]->integer;
- expiry_map.rhs->tmpl_value_box_type = PW_TYPE_INTEGER;
+ expiry_map.rhs->tmpl_value_box_type = FR_TYPE_INTEGER;
if (map_to_request(request, &expiry_map, map_to_vp, NULL) < 0) {
ret = IPPOOL_RCODE_FAIL;
goto finish;
fr_redis_rcode_t status;
ippool_rcode_t ret = IPPOOL_RCODE_SUCCESS;
- vp_tmpl_t range_rhs = { .name = "", .type = TMPL_TYPE_DATA, .tmpl_value_box_type = PW_TYPE_STRING, .quote = T_DOUBLE_QUOTED_STRING };
+ vp_tmpl_t range_rhs = { .name = "", .type = TMPL_TYPE_DATA, .tmpl_value_box_type = FR_TYPE_STRING, .quote = T_DOUBLE_QUOTED_STRING };
vp_map_t range_map = { .lhs = inst->range_attr, .op = T_OP_SET, .rhs = &range_rhs };
gettimeofday(&now, NULL);
case REDIS_REPLY_STRING:
range_map.rhs->tmpl_value_box_datum.strvalue = reply->element[1]->str;
range_map.rhs->tmpl_value_box_length = reply->element[1]->len;
- range_map.rhs->tmpl_value_box_type = PW_TYPE_STRING;
+ range_map.rhs->tmpl_value_box_type = FR_TYPE_STRING;
if (map_to_request(request, &range_map, map_to_vp, NULL) < 0) {
ret = IPPOOL_RCODE_FAIL;
goto finish;
vp_tmpl_t expiry_rhs = {
.name = "",
.type = TMPL_TYPE_DATA,
- .tmpl_value_box_type = PW_TYPE_STRING,
+ .tmpl_value_box_type = FR_TYPE_STRING,
.quote = T_DOUBLE_QUOTED_STRING
};
vp_map_t expiry_map = {
};
expiry_map.rhs->tmpl_value_box_datum.integer = expires;
- expiry_map.rhs->tmpl_value_box_type = PW_TYPE_INTEGER;
+ expiry_map.rhs->tmpl_value_box_type = FR_TYPE_INTEGER;
if (map_to_request(request, &expiry_map, map_to_vp, NULL) < 0) {
ret = IPPOOL_RCODE_FAIL;
goto finish;
ip_rhs.tmpl_value_box_length = strlen(ip_str);
ip_rhs.tmpl_value_box_datum.strvalue = ip_str;
- ip_rhs.tmpl_value_box_type = PW_TYPE_STRING;
+ ip_rhs.tmpl_value_box_type = FR_TYPE_STRING;
if (map_to_request(request, &ip_map, map_to_vp, NULL) < 0) return RLM_MODULE_FAIL;
}
} rlm_rediswho_t;
static CONF_PARSER section_config[] = {
- { FR_CONF_OFFSET("insert", PW_TYPE_STRING | PW_TYPE_REQUIRED | PW_TYPE_XLAT, rlm_rediswho_t, insert) },
- { FR_CONF_OFFSET("trim", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_rediswho_t, trim) }, /* required only if trim_count > 0 */
- { FR_CONF_OFFSET("expire", PW_TYPE_STRING | PW_TYPE_REQUIRED | PW_TYPE_XLAT, rlm_rediswho_t, expire) },
+ { FR_CONF_OFFSET("insert", FR_TYPE_STRING | FR_TYPE_REQUIRED | FR_TYPE_XLAT, rlm_rediswho_t, insert) },
+ { FR_CONF_OFFSET("trim", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_rediswho_t, trim) }, /* required only if trim_count > 0 */
+ { FR_CONF_OFFSET("expire", FR_TYPE_STRING | FR_TYPE_REQUIRED | FR_TYPE_XLAT, rlm_rediswho_t, expire) },
CONF_PARSER_TERMINATOR
};
static CONF_PARSER module_config[] = {
REDIS_COMMON_CONFIG,
- { FR_CONF_OFFSET("trim_count", PW_TYPE_SIGNED, rlm_rediswho_t, trim_count), .dflt = "-1" },
+ { FR_CONF_OFFSET("trim_count", FR_TYPE_SIGNED, rlm_rediswho_t, trim_count), .dflt = "-1" },
/*
* These all smash the same variables, because we don't care about them right now.
* In 3.1, we should have a way of saying "parse a set of sub-sections according to a template"
*/
- { FR_CONF_POINTER("Start", PW_TYPE_SUBSECTION, NULL), .subcs = section_config },
- { FR_CONF_POINTER("Interim-Update", PW_TYPE_SUBSECTION, NULL), .subcs = section_config },
- { FR_CONF_POINTER("Stop", PW_TYPE_SUBSECTION, NULL), .subcs = section_config },
+ { FR_CONF_POINTER("Start", FR_TYPE_SUBSECTION, NULL), .subcs = section_config },
+ { FR_CONF_POINTER("Interim-Update", FR_TYPE_SUBSECTION, NULL), .subcs = section_config },
+ { FR_CONF_POINTER("Stop", FR_TYPE_SUBSECTION, NULL), .subcs = section_config },
CONF_PARSER_TERMINATOR
};
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 = PW_TYPE_SIGNED;
+ src.type = FR_TYPE_SIGNED;
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 = PW_TYPE_DECIMAL;
+ src.type = FR_TYPE_DECIMAL;
break;
case json_type_string:
src.datum.strvalue = value;
src.datum.length = json_object_get_string_len(leaf);
}
- src.type = PW_TYPE_STRING;
+ src.type = FR_TYPE_STRING;
break;
return NULL;
}
- src.type = PW_TYPE_STRING;
+ src.type = FR_TYPE_STRING;
src.datum.length = strlen(src.datum.strvalue);
}
* TLS Configuration
*/
static CONF_PARSER tls_config[] = {
- { FR_CONF_OFFSET("ca_file", PW_TYPE_FILE_INPUT, rlm_rest_section_t, tls_ca_file) },
- { FR_CONF_OFFSET("ca_path", PW_TYPE_FILE_INPUT, rlm_rest_section_t, tls_ca_path) },
- { FR_CONF_OFFSET("certificate_file", PW_TYPE_FILE_INPUT, rlm_rest_section_t, tls_certificate_file) },
- { FR_CONF_OFFSET("private_key_file", PW_TYPE_FILE_INPUT, rlm_rest_section_t, tls_private_key_file) },
- { FR_CONF_OFFSET("private_key_password", PW_TYPE_STRING | PW_TYPE_SECRET, rlm_rest_section_t, tls_private_key_password) },
- { FR_CONF_OFFSET("random_file", PW_TYPE_STRING, rlm_rest_section_t, tls_random_file) },
- { FR_CONF_OFFSET("check_cert", PW_TYPE_BOOLEAN, rlm_rest_section_t, tls_check_cert), .dflt = "yes" },
- { FR_CONF_OFFSET("check_cert_cn", PW_TYPE_BOOLEAN, rlm_rest_section_t, tls_check_cert_cn), .dflt = "yes" },
- { FR_CONF_OFFSET("extract_cert_attrs", PW_TYPE_BOOLEAN, rlm_rest_section_t, tls_extract_cert_attrs), .dflt = "no" },
+ { FR_CONF_OFFSET("ca_file", FR_TYPE_FILE_INPUT, rlm_rest_section_t, tls_ca_file) },
+ { FR_CONF_OFFSET("ca_path", FR_TYPE_FILE_INPUT, rlm_rest_section_t, tls_ca_path) },
+ { FR_CONF_OFFSET("certificate_file", FR_TYPE_FILE_INPUT, rlm_rest_section_t, tls_certificate_file) },
+ { 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" },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER section_config[] = {
- { FR_CONF_OFFSET("uri", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_rest_section_t, uri), .dflt = "" },
- { FR_CONF_OFFSET("proxy", PW_TYPE_STRING, rlm_rest_section_t, proxy) },
- { FR_CONF_OFFSET("method", PW_TYPE_STRING, rlm_rest_section_t, method_str), .dflt = "GET" },
- { FR_CONF_OFFSET("body", PW_TYPE_STRING, rlm_rest_section_t, body_str), .dflt = "none" },
- { FR_CONF_OFFSET("data", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_rest_section_t, data) },
- { FR_CONF_OFFSET("force_to", PW_TYPE_STRING, rlm_rest_section_t, force_to_str) },
+ { FR_CONF_OFFSET("uri", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_rest_section_t, uri), .dflt = "" },
+ { FR_CONF_OFFSET("proxy", FR_TYPE_STRING, rlm_rest_section_t, proxy) },
+ { FR_CONF_OFFSET("method", FR_TYPE_STRING, rlm_rest_section_t, method_str), .dflt = "GET" },
+ { FR_CONF_OFFSET("body", FR_TYPE_STRING, rlm_rest_section_t, body_str), .dflt = "none" },
+ { FR_CONF_OFFSET("data", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_rest_section_t, data) },
+ { FR_CONF_OFFSET("force_to", FR_TYPE_STRING, rlm_rest_section_t, force_to_str) },
/* User authentication */
- { FR_CONF_OFFSET("auth", PW_TYPE_STRING, rlm_rest_section_t, auth_str), .dflt = "none" },
- { FR_CONF_OFFSET("username", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_rest_section_t, username) },
- { FR_CONF_OFFSET("password", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_rest_section_t, password) },
- { FR_CONF_OFFSET("require_auth", PW_TYPE_BOOLEAN, rlm_rest_section_t, require_auth), .dflt = "no" },
+ { 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" },
/* Transfer configuration */
- { FR_CONF_OFFSET("timeout", PW_TYPE_TIMEVAL, rlm_rest_section_t, timeout_tv), .dflt = "4.0" },
- { FR_CONF_OFFSET("chunk", PW_TYPE_INTEGER, rlm_rest_section_t, chunk), .dflt = "0" },
+ { 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" },
/* TLS Parameters */
- { FR_CONF_POINTER("tls", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) tls_config },
+ { FR_CONF_POINTER("tls", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) tls_config },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER xlat_config[] = {
- { FR_CONF_OFFSET("proxy", PW_TYPE_STRING, rlm_rest_section_t, proxy) },
+ { FR_CONF_OFFSET("proxy", FR_TYPE_STRING, rlm_rest_section_t, proxy) },
/* User authentication */
- { FR_CONF_OFFSET("auth", PW_TYPE_STRING, rlm_rest_section_t, auth_str), .dflt = "none" },
- { FR_CONF_OFFSET("username", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_rest_section_t, username) },
- { FR_CONF_OFFSET("password", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_rest_section_t, password) },
- { FR_CONF_OFFSET("require_auth", PW_TYPE_BOOLEAN, rlm_rest_section_t, require_auth), .dflt = "no" },
+ { 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" },
/* Transfer configuration */
- { FR_CONF_OFFSET("timeout", PW_TYPE_TIMEVAL, rlm_rest_section_t, timeout_tv), .dflt = "4.0" },
- { FR_CONF_OFFSET("chunk", PW_TYPE_INTEGER, rlm_rest_section_t, chunk), .dflt = "0" },
+ { 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" },
/* TLS Parameters */
- { FR_CONF_POINTER("tls", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) tls_config },
+ { FR_CONF_POINTER("tls", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) tls_config },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER module_config[] = {
- { FR_CONF_DEPRECATED("connect_timeout", PW_TYPE_TIMEVAL, rlm_rest_t, connect_timeout) },
- { FR_CONF_OFFSET("connect_proxy", PW_TYPE_STRING, rlm_rest_t, connect_proxy) },
+ { FR_CONF_DEPRECATED("connect_timeout", FR_TYPE_TIMEVAL, rlm_rest_t, connect_timeout) },
+ { FR_CONF_OFFSET("connect_proxy", FR_TYPE_STRING, rlm_rest_t, connect_proxy) },
CONF_PARSER_TERMINATOR
};
} rlm_ruby_t;
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("filename", PW_TYPE_FILE_INPUT | PW_TYPE_REQUIRED, struct rlm_ruby_t, filename) },
- { FR_CONF_OFFSET("module", PW_TYPE_STRING, struct rlm_ruby_t, module_name), .dflt = "Radiusd" },
+ { FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT | FR_TYPE_REQUIRED, struct rlm_ruby_t, filename) },
+ { FR_CONF_OFFSET("module", FR_TYPE_STRING, struct rlm_ruby_t, module_name), .dflt = "Radiusd" },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("timer_expire", PW_TYPE_INTEGER, rlm_securid_t, timer_limit), .dflt = "600" },
- { FR_CONF_OFFSET("max_sessions", PW_TYPE_INTEGER, rlm_securid_t, max_sessions), .dflt = "2048" },
- { FR_CONF_OFFSET("max_trips_per_session", PW_TYPE_INTEGER, rlm_securid_t, max_trips_per_session) },
- { FR_CONF_OFFSET("max_round_trips", PW_TYPE_INTEGER, rlm_securid_t, max_trips_per_session), .dflt = "6" },
+ { 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" },
CONF_PARSER_TERMINATOR
};
};
static const CONF_PARSER sctp_config[] = {
- { FR_CONF_OFFSET("server", PW_TYPE_COMBO_IP_ADDR, rlm_sigtran_t, conn_conf.sctp_dst_ipaddr) },
- { FR_CONF_OFFSET("port", PW_TYPE_SHORT, rlm_sigtran_t, conn_conf.sctp_dst_port), .dflt = "2905" },
+ { 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("src_ipaddr", PW_TYPE_COMBO_IP_ADDR, rlm_sigtran_t, conn_conf.sctp_src_ipaddr ) },
- { FR_CONF_OFFSET("src_port", PW_TYPE_SHORT, rlm_sigtran_t, conn_conf.sctp_src_port), .dflt = "0" },
+ { 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("timeout", PW_TYPE_INTEGER, rlm_sigtran_t, conn_conf.sctp_timeout), .dflt = "5" },
+ { FR_CONF_OFFSET("timeout", FR_TYPE_INTEGER, rlm_sigtran_t, conn_conf.sctp_timeout), .dflt = "5" },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER m3ua_route[] = {
- { FR_CONF_IS_SET_OFFSET("dpc", PW_TYPE_INTEGER, sigtran_m3ua_route_t, dpc) },
- { FR_CONF_OFFSET("opc", PW_TYPE_INTEGER | PW_TYPE_MULTI, sigtran_m3ua_route_t, opc) },
- { FR_CONF_OFFSET("si", PW_TYPE_INTEGER | PW_TYPE_MULTI, sigtran_m3ua_route_t, si) },
+ { 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) },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER m3ua_config[] = {
- { FR_CONF_OFFSET("link_index", PW_TYPE_SHORT, rlm_sigtran_t, conn_conf.m3ua_link_index) },
- { FR_CONF_OFFSET("routing_ctx", PW_TYPE_SHORT, rlm_sigtran_t, conn_conf.m3ua_routing_context) },
- { FR_CONF_OFFSET("traffic_mode", PW_TYPE_STRING, rlm_sigtran_t, conn_conf.m3ua_traffic_mode_str), .dflt = "loadshare" },
- { FR_CONF_OFFSET("ack_timeout", PW_TYPE_INTEGER, rlm_sigtran_t, conn_conf.m3ua_ack_timeout), .dflt = "2" },
- { FR_CONF_OFFSET("beat_interval", PW_TYPE_INTEGER, rlm_sigtran_t, conn_conf.m3ua_beat_interval), .dflt = "0" },
+ { 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("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_IS_SET_OFFSET("route", PW_TYPE_SUBSECTION, rlm_sigtran_t, conn_conf.m3ua_routes), .subcs = (void const *) m3ua_route },
+ { FR_CONF_IS_SET_OFFSET("route", FR_TYPE_SUBSECTION, rlm_sigtran_t, conn_conf.m3ua_routes), .subcs = (void const *) m3ua_route },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER mtp3_config[] = {
- { FR_CONF_OFFSET("dpc", PW_TYPE_INTEGER | PW_TYPE_REQUIRED, rlm_sigtran_t, conn_conf.mtp3_dpc) },
- { FR_CONF_OFFSET("opc", PW_TYPE_INTEGER | PW_TYPE_REQUIRED, rlm_sigtran_t, conn_conf.mtp3_opc) },
+ { 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) },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER sccp_global_title[] = {
- { FR_CONF_OFFSET("address", PW_TYPE_STRING, sigtran_sccp_global_title_t, address) },
- { FR_CONF_IS_SET_OFFSET("tt", PW_TYPE_BYTE, sigtran_sccp_global_title_t, tt) },
- { FR_CONF_IS_SET_OFFSET("nai", PW_TYPE_BYTE, sigtran_sccp_global_title_t, nai) },
- { FR_CONF_IS_SET_OFFSET("np", PW_TYPE_BYTE, sigtran_sccp_global_title_t, np) },
- { FR_CONF_IS_SET_OFFSET("es", PW_TYPE_BYTE, sigtran_sccp_global_title_t, es) },
+ { 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) },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER sccp_address[] = {
- { FR_CONF_IS_SET_OFFSET("pc", PW_TYPE_INTEGER, sigtran_sccp_address_t, pc) },
- { FR_CONF_IS_SET_OFFSET("ssn", PW_TYPE_BYTE, sigtran_sccp_address_t, ssn) },
- { FR_CONF_IS_SET_OFFSET("gt", PW_TYPE_SUBSECTION, sigtran_sccp_address_t, gt), .subcs = (void const *) sccp_global_title },
+ { 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("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", PW_TYPE_BOOLEAN, rlm_sigtran_t, conn_conf.sccp_ai8) },
- { FR_CONF_OFFSET("route_on_ssn", PW_TYPE_BOOLEAN, rlm_sigtran_t, conn_conf.sccp_route_on_ssn) },
+ { 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("called", PW_TYPE_SUBSECTION, rlm_sigtran_t, conn_conf.sccp_called), .subcs = (void const *) sccp_address },
- { FR_CONF_OFFSET("calling", PW_TYPE_SUBSECTION, rlm_sigtran_t, conn_conf.sccp_calling), .subcs = (void const *) sccp_address },
+ { 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 },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER map_config[] = {
- { FR_CONF_OFFSET("version", PW_TYPE_TMPL, rlm_sigtran_t, conn_conf.map_version), .dflt = "2", .quote = T_BARE_WORD},
+ { FR_CONF_OFFSET("version", FR_TYPE_TMPL, rlm_sigtran_t, conn_conf.map_version), .dflt = "2", .quote = T_BARE_WORD},
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER module_config[] = {
- { FR_CONF_POINTER("sctp", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) sctp_config },
- { FR_CONF_POINTER("m3ua", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) m3ua_config },
- { FR_CONF_POINTER("mtp3", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) mtp3_config },
- { FR_CONF_POINTER("sccp", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) sccp_config },
- { FR_CONF_POINTER("map", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) map_config },
+ { FR_CONF_POINTER("sctp", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) sctp_config },
+ { FR_CONF_POINTER("m3ua", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) m3ua_config },
+ { FR_CONF_POINTER("mtp3", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) mtp3_config },
+ { FR_CONF_POINTER("sccp", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) sccp_config },
+ { FR_CONF_POINTER("map", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) map_config },
- { FR_CONF_OFFSET("imsi", PW_TYPE_TMPL | PW_TYPE_REQUIRED, rlm_sigtran_t, imsi) },
+ { FR_CONF_OFFSET("imsi", FR_TYPE_TMPL | FR_TYPE_REQUIRED, rlm_sigtran_t, imsi) },
CONF_PARSER_TERMINATOR
};
/*
* Do SoH over DHCP?
*/
- { FR_CONF_OFFSET("dhcp", PW_TYPE_BOOLEAN, rlm_soh_t, dhcp), .dflt = "no" },
+ { FR_CONF_OFFSET("dhcp", FR_TYPE_BOOLEAN, rlm_soh_t, dhcp), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
} rlm_sometimes_t;
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("rcode", PW_TYPE_STRING, rlm_sometimes_t, rcode_str), .dflt = "fail" },
- { FR_CONF_OFFSET("key", PW_TYPE_TMPL | PW_TYPE_ATTRIBUTE, rlm_sometimes_t, key), .dflt = "&User-Name", .quote = T_BARE_WORD },
- { FR_CONF_OFFSET("start", PW_TYPE_INTEGER, rlm_sometimes_t, start), .dflt = "0" },
- { FR_CONF_OFFSET("end", PW_TYPE_INTEGER, rlm_sometimes_t, end), .dflt = "127" },
+ { 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" },
CONF_PARSER_TERMINATOR
};
if (!vp) return RLM_MODULE_NOOP;
switch (vp->vp_type) {
- case PW_TYPE_OCTETS:
- case PW_TYPE_STRING:
+ case FR_TYPE_OCTETS:
+ case FR_TYPE_STRING:
hash = fr_hash(vp->data.datum.ptr, vp->vp_length);
break;
- case PW_TYPE_ABINARY:
+ case FR_TYPE_ABINARY:
hash = fr_hash(vp->vp_filter, vp->vp_length);
break;
- case PW_TYPE_STRUCTURAL:
+ case FR_TYPE_STRUCTURAL:
return RLM_MODULE_FAIL;
default:
};
static CONF_PARSER load_balance_dc_aware_config[] = {
- { FR_CONF_OFFSET("local_dc", PW_TYPE_STRING, rlm_sql_cassandra_t, lbdc_local_dc) },
- { FR_CONF_OFFSET("hosts_per_remote_dc", PW_TYPE_INTEGER, rlm_sql_cassandra_t, lbdc_hosts_per_remote_dc), .dflt = "0" },
- { FR_CONF_OFFSET("allow_remote_dcs_for_local_cl", PW_TYPE_BOOLEAN, rlm_sql_cassandra_t, lbdc_allow_remote_dcs_for_local_cl), .dflt = "no" },
+ { 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" },
CONF_PARSER_TERMINATOR
};
static CONF_PARSER latency_aware_routing_config[] = {
- { FR_CONF_OFFSET("exclusion_threshold", PW_TYPE_TIMEVAL, rlm_sql_cassandra_t, lar_exclusion_threshold), .dflt = "2.0" },
- { FR_CONF_OFFSET("scale", PW_TYPE_TIMEVAL, rlm_sql_cassandra_t, lar_scale), .dflt = "0.1" },
- { FR_CONF_OFFSET("retry_period", PW_TYPE_TIMEVAL, rlm_sql_cassandra_t, lar_retry_period), .dflt = "10" },
- { FR_CONF_OFFSET("update_rate", PW_TYPE_TIMEVAL, rlm_sql_cassandra_t, lar_update_rate), .dflt = "0.1" },
- { FR_CONF_OFFSET("min_measured", PW_TYPE_INTEGER64, rlm_sql_cassandra_t, lar_min_measured), .dflt = "50" },
+ { FR_CONF_OFFSET("exclusion_threshold", FR_TYPE_TIMEVAL, rlm_sql_cassandra_t, lar_exclusion_threshold), .dflt = "2.0" },
+ { 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" },
CONF_PARSER_TERMINATOR
};
static CONF_PARSER tls_config[] = {
- { FR_CONF_OFFSET("ca_file", PW_TYPE_FILE_INPUT, rlm_sql_cassandra_t, tls_ca_file) },
- { FR_CONF_OFFSET("certificate_file", PW_TYPE_FILE_INPUT, rlm_sql_cassandra_t, tls_certificate_file) },
- { FR_CONF_OFFSET("private_key_file", PW_TYPE_FILE_INPUT, rlm_sql_cassandra_t, tls_private_key_file) },
- { FR_CONF_OFFSET("private_key_password", PW_TYPE_STRING | PW_TYPE_SECRET, rlm_sql_cassandra_t, tls_private_key_password) },
+ { FR_CONF_OFFSET("ca_file", FR_TYPE_FILE_INPUT, rlm_sql_cassandra_t, tls_ca_file) },
+ { FR_CONF_OFFSET("certificate_file", FR_TYPE_FILE_INPUT, rlm_sql_cassandra_t, tls_certificate_file) },
+ { FR_CONF_OFFSET("private_key_file", FR_TYPE_FILE_INPUT, rlm_sql_cassandra_t, tls_private_key_file) },
+ { FR_CONF_OFFSET("private_key_password", FR_TYPE_STRING | FR_TYPE_SECRET, rlm_sql_cassandra_t, tls_private_key_password) },
- { FR_CONF_OFFSET("verify_cert", PW_TYPE_STRING, rlm_sql_cassandra_t, tls_verify_cert_str) },
+ { FR_CONF_OFFSET("verify_cert", FR_TYPE_STRING, rlm_sql_cassandra_t, tls_verify_cert_str) },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER driver_config[] = {
- { FR_CONF_OFFSET("consistency", PW_TYPE_STRING, rlm_sql_cassandra_t, consistency_str), .dflt = "quorum" },
+ { FR_CONF_OFFSET("consistency", FR_TYPE_STRING, rlm_sql_cassandra_t, consistency_str), .dflt = "quorum" },
- { FR_CONF_OFFSET("protocol_version", PW_TYPE_INTEGER, rlm_sql_cassandra_t, protocol_version) },
+ { FR_CONF_OFFSET("protocol_version", FR_TYPE_INTEGER, rlm_sql_cassandra_t, protocol_version) },
- { FR_CONF_OFFSET("connections_per_host", PW_TYPE_INTEGER, rlm_sql_cassandra_t, connections_per_host) },
- { FR_CONF_OFFSET("connections_per_host_max", PW_TYPE_INTEGER, rlm_sql_cassandra_t, connections_per_host_max) },
+ { 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("io_threads", PW_TYPE_INTEGER, rlm_sql_cassandra_t, io_threads) },
- { FR_CONF_OFFSET("io_queue_size", PW_TYPE_INTEGER, rlm_sql_cassandra_t, io_queue_size) },
- { FR_CONF_OFFSET("io_flush_requests_max", PW_TYPE_INTEGER, rlm_sql_cassandra_t, io_flush_requests_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("pending_requests_high", PW_TYPE_INTEGER, rlm_sql_cassandra_t, pending_requests_high) },
- { FR_CONF_OFFSET("pending_requests_low", PW_TYPE_INTEGER, rlm_sql_cassandra_t, pending_requests_low) },
- { FR_CONF_OFFSET("write_bytes_high", PW_TYPE_INTEGER, rlm_sql_cassandra_t, write_bytes_high) },
- { FR_CONF_OFFSET("write_bytes_low", PW_TYPE_INTEGER, rlm_sql_cassandra_t, write_bytes_low) },
+ { 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("event_queue_size", PW_TYPE_INTEGER, rlm_sql_cassandra_t, event_queue_size) },
+ { FR_CONF_OFFSET("event_queue_size", FR_TYPE_INTEGER, rlm_sql_cassandra_t, event_queue_size) },
- { FR_CONF_OFFSET("spawn_threshold", PW_TYPE_INTEGER, rlm_sql_cassandra_t, spawn_threshold) },
- { FR_CONF_OFFSET("spawn_max", PW_TYPE_INTEGER, rlm_sql_cassandra_t, spawn_max) },
- { FR_CONF_OFFSET("spawn_retry_delay", PW_TYPE_TIMEVAL, rlm_sql_cassandra_t, spawn_retry_delay) },
+ { 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_retry_delay", FR_TYPE_TIMEVAL, rlm_sql_cassandra_t, spawn_retry_delay) },
- { FR_CONF_POINTER("load_balance_dc_aware", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) load_balance_dc_aware_config },
- { FR_CONF_OFFSET("load_balance_round_robin", PW_TYPE_BOOLEAN, rlm_sql_cassandra_t, load_balance_round_robin), .dflt = "no" },
+ { 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("token_aware_routing", PW_TYPE_BOOLEAN, rlm_sql_cassandra_t, token_aware_routing), .dflt = "yes" },
- { FR_CONF_POINTER("latency_aware_routing", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) latency_aware_routing_config },
+ { FR_CONF_OFFSET("token_aware_routing", FR_TYPE_BOOLEAN, 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", PW_TYPE_INTEGER, rlm_sql_cassandra_t, tcp_keepalive) },
- { FR_CONF_OFFSET("tcp_nodelay", PW_TYPE_BOOLEAN, rlm_sql_cassandra_t, tcp_nodelay), .dflt = "no" },
+ { 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_POINTER("tls", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) tls_config },
+ { FR_CONF_POINTER("tls", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) tls_config },
CONF_PARSER_TERMINATOR
};
} rlm_sql_mysql_t;
static CONF_PARSER tls_config[] = {
- { FR_CONF_OFFSET("ca_file", PW_TYPE_FILE_INPUT, rlm_sql_mysql_t, tls_ca_file) },
- { FR_CONF_OFFSET("ca_path", PW_TYPE_FILE_INPUT, rlm_sql_mysql_t, tls_ca_path) },
- { FR_CONF_OFFSET("certificate_file", PW_TYPE_FILE_INPUT, rlm_sql_mysql_t, tls_certificate_file) },
- { FR_CONF_OFFSET("private_key_file", PW_TYPE_FILE_INPUT, rlm_sql_mysql_t, tls_private_key_file) },
+ { FR_CONF_OFFSET("ca_file", FR_TYPE_FILE_INPUT, rlm_sql_mysql_t, tls_ca_file) },
+ { FR_CONF_OFFSET("ca_path", FR_TYPE_FILE_INPUT, rlm_sql_mysql_t, tls_ca_path) },
+ { FR_CONF_OFFSET("certificate_file", FR_TYPE_FILE_INPUT, rlm_sql_mysql_t, tls_certificate_file) },
+ { FR_CONF_OFFSET("private_key_file", FR_TYPE_FILE_INPUT, rlm_sql_mysql_t, tls_private_key_file) },
/*
* MySQL Specific TLS attributes
*/
- { FR_CONF_OFFSET("cipher", PW_TYPE_STRING, rlm_sql_mysql_t, tls_cipher) },
+ { FR_CONF_OFFSET("cipher", FR_TYPE_STRING, rlm_sql_mysql_t, tls_cipher) },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER driver_config[] = {
- { FR_CONF_POINTER("tls", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) tls_config },
+ { FR_CONF_POINTER("tls", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) tls_config },
- { FR_CONF_OFFSET("warnings", PW_TYPE_STRING, rlm_sql_mysql_t, warnings_str), .dflt = "auto" },
+ { FR_CONF_OFFSET("warnings", FR_TYPE_STRING, rlm_sql_mysql_t, warnings_str), .dflt = "auto" },
CONF_PARSER_TERMINATOR
};
} rlm_sql_postgres_conn_t;
static CONF_PARSER driver_config[] = {
- { FR_CONF_OFFSET("send_application_name", PW_TYPE_BOOLEAN, rlm_sql_postgres_t, send_application_name), .dflt = "no" },
+ { FR_CONF_OFFSET("send_application_name", FR_TYPE_BOOLEAN, rlm_sql_postgres_t, send_application_name), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
} rlm_sql_sqlite_t;
static const CONF_PARSER driver_config[] = {
- { FR_CONF_OFFSET("filename", PW_TYPE_FILE_OUTPUT | PW_TYPE_REQUIRED, rlm_sql_sqlite_t, filename) },
- { FR_CONF_OFFSET("busy_timeout", PW_TYPE_INTEGER, rlm_sql_sqlite_t, busy_timeout), .dflt = "200" },
+ { 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" },
CONF_PARSER_TERMINATOR
};
* So we can do pass2 xlat checks on the queries.
*/
static const CONF_PARSER query_config[] = {
- { FR_CONF_OFFSET("query", PW_TYPE_STRING | PW_TYPE_XLAT | PW_TYPE_MULTI, rlm_sql_config_t, accounting.query) },
+ { FR_CONF_OFFSET("query", FR_TYPE_STRING | FR_TYPE_XLAT | FR_TYPE_MULTI, rlm_sql_config_t, accounting.query) },
CONF_PARSER_TERMINATOR
};
* helps the average case.
*/
static const CONF_PARSER type_config[] = {
- { FR_CONF_POINTER("accounting-on", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) query_config },
- { FR_CONF_POINTER("accounting-off", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) query_config },
- { FR_CONF_POINTER("start", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) query_config },
- { FR_CONF_POINTER("interim-update", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) query_config },
- { FR_CONF_POINTER("stop", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) query_config },
+ { FR_CONF_POINTER("accounting-on", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) query_config },
+ { FR_CONF_POINTER("accounting-off", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) query_config },
+ { FR_CONF_POINTER("start", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) query_config },
+ { FR_CONF_POINTER("interim-update", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) query_config },
+ { FR_CONF_POINTER("stop", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) query_config },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER acct_config[] = {
- { FR_CONF_OFFSET("reference", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sql_config_t, accounting.reference), .dflt = ".query" },
- { FR_CONF_OFFSET("logfile", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sql_config_t, accounting.logfile) },
+ { FR_CONF_OFFSET("reference", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sql_config_t, accounting.reference), .dflt = ".query" },
+ { FR_CONF_OFFSET("logfile", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sql_config_t, accounting.logfile) },
- { FR_CONF_POINTER("type", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) type_config },
+ { FR_CONF_POINTER("type", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) type_config },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER postauth_config[] = {
- { FR_CONF_OFFSET("reference", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sql_config_t, postauth.reference), .dflt = ".query" },
- { FR_CONF_OFFSET("logfile", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sql_config_t, postauth.logfile) },
+ { FR_CONF_OFFSET("reference", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sql_config_t, postauth.reference), .dflt = ".query" },
+ { FR_CONF_OFFSET("logfile", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sql_config_t, postauth.logfile) },
- { FR_CONF_OFFSET("query", PW_TYPE_STRING | PW_TYPE_XLAT | PW_TYPE_MULTI, rlm_sql_config_t, postauth.query) },
+ { FR_CONF_OFFSET("query", FR_TYPE_STRING | FR_TYPE_XLAT | FR_TYPE_MULTI, rlm_sql_config_t, postauth.query) },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("driver", PW_TYPE_STRING, rlm_sql_config_t, sql_driver_name), .dflt = "rlm_sql_null" },
- { FR_CONF_OFFSET("server", PW_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", PW_TYPE_INTEGER, rlm_sql_config_t, sql_port), .dflt = "0" },
- { FR_CONF_OFFSET("login", PW_TYPE_STRING, rlm_sql_config_t, sql_login), .dflt = "" },
- { FR_CONF_OFFSET("password", PW_TYPE_STRING | PW_TYPE_SECRET, rlm_sql_config_t, sql_password), .dflt = "" },
- { FR_CONF_OFFSET("radius_db", PW_TYPE_STRING, rlm_sql_config_t, sql_db), .dflt = "radius" },
- { FR_CONF_OFFSET("read_groups", PW_TYPE_BOOLEAN, rlm_sql_config_t, read_groups), .dflt = "yes" },
- { FR_CONF_OFFSET("read_profiles", PW_TYPE_BOOLEAN, rlm_sql_config_t, read_profiles), .dflt = "yes" },
- { FR_CONF_OFFSET("read_clients", PW_TYPE_BOOLEAN, rlm_sql_config_t, do_clients), .dflt = "no" },
- { FR_CONF_OFFSET("delete_stale_sessions", PW_TYPE_BOOLEAN, rlm_sql_config_t, delete_stale_sessions), .dflt = "yes" },
- { FR_CONF_OFFSET("sql_user_name", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sql_config_t, query_user), .dflt = "" },
- { FR_CONF_OFFSET("group_attribute", PW_TYPE_STRING, rlm_sql_config_t, group_attribute) },
- { FR_CONF_OFFSET("logfile", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sql_config_t, logfile) },
- { FR_CONF_OFFSET("default_user_profile", PW_TYPE_STRING, rlm_sql_config_t, default_profile), .dflt = "" },
- { FR_CONF_OFFSET("client_query", PW_TYPE_STRING, rlm_sql_config_t, client_query), .dflt = "SELECT id,nasname,shortname,type,secret FROM nas" },
- { FR_CONF_OFFSET("open_query", PW_TYPE_STRING, rlm_sql_config_t, connect_query) },
-
- { FR_CONF_OFFSET("authorize_check_query", PW_TYPE_STRING | PW_TYPE_XLAT | PW_TYPE_NOT_EMPTY, rlm_sql_config_t, authorize_check_query) },
- { FR_CONF_OFFSET("authorize_reply_query", PW_TYPE_STRING | PW_TYPE_XLAT | PW_TYPE_NOT_EMPTY, rlm_sql_config_t, authorize_reply_query) },
-
- { FR_CONF_OFFSET("authorize_group_check_query", PW_TYPE_STRING | PW_TYPE_XLAT | PW_TYPE_NOT_EMPTY, rlm_sql_config_t, authorize_group_check_query) },
- { FR_CONF_OFFSET("authorize_group_reply_query", PW_TYPE_STRING | PW_TYPE_XLAT | PW_TYPE_NOT_EMPTY, rlm_sql_config_t, authorize_group_reply_query) },
- { FR_CONF_OFFSET("group_membership_query", PW_TYPE_STRING | PW_TYPE_XLAT | PW_TYPE_NOT_EMPTY, rlm_sql_config_t, groupmemb_query) },
+ { 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("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("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) },
+ { FR_CONF_OFFSET("default_user_profile", FR_TYPE_STRING, rlm_sql_config_t, default_profile), .dflt = "" },
+ { FR_CONF_OFFSET("client_query", FR_TYPE_STRING, rlm_sql_config_t, client_query), .dflt = "SELECT id,nasname,shortname,type,secret FROM nas" },
+ { FR_CONF_OFFSET("open_query", FR_TYPE_STRING, rlm_sql_config_t, connect_query) },
+
+ { FR_CONF_OFFSET("authorize_check_query", FR_TYPE_STRING | FR_TYPE_XLAT | FR_TYPE_NOT_EMPTY, rlm_sql_config_t, authorize_check_query) },
+ { FR_CONF_OFFSET("authorize_reply_query", FR_TYPE_STRING | FR_TYPE_XLAT | FR_TYPE_NOT_EMPTY, rlm_sql_config_t, authorize_reply_query) },
+
+ { FR_CONF_OFFSET("authorize_group_check_query", FR_TYPE_STRING | FR_TYPE_XLAT | FR_TYPE_NOT_EMPTY, rlm_sql_config_t, authorize_group_check_query) },
+ { FR_CONF_OFFSET("authorize_group_reply_query", FR_TYPE_STRING | FR_TYPE_XLAT | FR_TYPE_NOT_EMPTY, rlm_sql_config_t, authorize_group_reply_query) },
+ { FR_CONF_OFFSET("group_membership_query", FR_TYPE_STRING | FR_TYPE_XLAT | FR_TYPE_NOT_EMPTY, rlm_sql_config_t, groupmemb_query) },
#ifdef WITH_SESSION_MGMT
- { FR_CONF_OFFSET("simul_count_query", PW_TYPE_STRING | PW_TYPE_XLAT | PW_TYPE_NOT_EMPTY, rlm_sql_config_t, simul_count_query) },
- { FR_CONF_OFFSET("simul_verify_query", PW_TYPE_STRING | PW_TYPE_XLAT | PW_TYPE_NOT_EMPTY, rlm_sql_config_t, simul_verify_query) },
+ { FR_CONF_OFFSET("simul_count_query", FR_TYPE_STRING | FR_TYPE_XLAT | FR_TYPE_NOT_EMPTY, rlm_sql_config_t, simul_count_query) },
+ { FR_CONF_OFFSET("simul_verify_query", FR_TYPE_STRING | FR_TYPE_XLAT | FR_TYPE_NOT_EMPTY, rlm_sql_config_t, simul_verify_query) },
#endif
- { FR_CONF_OFFSET("safe_characters", PW_TYPE_STRING, rlm_sql_config_t, allowed_chars), .dflt = "@abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-_: /" },
+ { FR_CONF_OFFSET("safe_characters", FR_TYPE_STRING, rlm_sql_config_t, allowed_chars), .dflt = "@abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-_: /" },
/*
* This only works for a few drivers.
*/
- { FR_CONF_OFFSET("query_timeout", PW_TYPE_INTEGER, rlm_sql_config_t, query_timeout) },
+ { FR_CONF_OFFSET("query_timeout", FR_TYPE_INTEGER, rlm_sql_config_t, query_timeout) },
- { FR_CONF_POINTER("accounting", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) acct_config },
+ { FR_CONF_POINTER("accounting", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) acct_config },
- { FR_CONF_POINTER("post-auth", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) postauth_config },
+ { FR_CONF_POINTER("post-auth", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) postauth_config },
CONF_PARSER_TERMINATOR
};
} rlm_sqlcounter_t;
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("sql_module_instance", PW_TYPE_STRING | PW_TYPE_REQUIRED, rlm_sqlcounter_t, sqlmod_inst) },
+ { FR_CONF_OFFSET("sql_module_instance", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_sqlcounter_t, sqlmod_inst) },
- { FR_CONF_OFFSET("query", PW_TYPE_STRING | PW_TYPE_XLAT | PW_TYPE_REQUIRED, rlm_sqlcounter_t, query) },
- { FR_CONF_OFFSET("reset", PW_TYPE_STRING | PW_TYPE_REQUIRED, rlm_sqlcounter_t, reset) },
+ { FR_CONF_OFFSET("query", FR_TYPE_STRING | FR_TYPE_XLAT | FR_TYPE_REQUIRED, rlm_sqlcounter_t, query) },
+ { FR_CONF_OFFSET("reset", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_sqlcounter_t, reset) },
- { FR_CONF_OFFSET("key", PW_TYPE_TMPL | PW_TYPE_ATTRIBUTE, rlm_sqlcounter_t, key_attr), .dflt = "&request:User-Name", .quote = T_BARE_WORD },
+ { FR_CONF_OFFSET("key", FR_TYPE_TMPL | FR_TYPE_ATTRIBUTE, rlm_sqlcounter_t, key_attr), .dflt = "&request:User-Name", .quote = T_BARE_WORD },
/* Just used to register a paircompare against */
- { FR_CONF_OFFSET("counter_name", PW_TYPE_TMPL | PW_TYPE_ATTRIBUTE | PW_TYPE_REQUIRED, rlm_sqlcounter_t, paircmp_attr) },
- { FR_CONF_OFFSET("check_name", PW_TYPE_TMPL | PW_TYPE_ATTRIBUTE | PW_TYPE_REQUIRED, rlm_sqlcounter_t, limit_attr) },
+ { FR_CONF_OFFSET("counter_name", FR_TYPE_TMPL | FR_TYPE_ATTRIBUTE | FR_TYPE_REQUIRED, rlm_sqlcounter_t, paircmp_attr) },
+ { FR_CONF_OFFSET("check_name", FR_TYPE_TMPL | FR_TYPE_ATTRIBUTE | FR_TYPE_REQUIRED, rlm_sqlcounter_t, limit_attr) },
/* Attribute to write remaining session to */
- { FR_CONF_OFFSET("reply_name", PW_TYPE_TMPL | PW_TYPE_ATTRIBUTE, rlm_sqlcounter_t, reply_attr) },
+ { FR_CONF_OFFSET("reply_name", FR_TYPE_TMPL | FR_TYPE_ATTRIBUTE, rlm_sqlcounter_t, reply_attr) },
CONF_PARSER_TERMINATOR
};
memset(&flags, 0, sizeof(flags));
flags.compare = 1; /* ugly hack */
- if (tmpl_define_undefined_attr(inst->paircmp_attr, PW_TYPE_INTEGER64, &flags) < 0) {
+ if (tmpl_define_undefined_attr(inst->paircmp_attr, FR_TYPE_INTEGER64, &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, PW_TYPE_INTEGER64, &flags) < 0) {
+ if (tmpl_define_undefined_attr(inst->limit_attr, FR_TYPE_INTEGER64, &flags) < 0) {
cf_log_err_cs(conf, "Failed defining check attribute: %s", fr_strerror());
return -1;
}
- if (inst->paircmp_attr->tmpl_da->type != PW_TYPE_INTEGER64) {
+ if (inst->paircmp_attr->tmpl_da->type != FR_TYPE_INTEGER64) {
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 != PW_TYPE_INTEGER64) {
+ if (inst->limit_attr->tmpl_da->type != FR_TYPE_INTEGER64) {
cf_log_err_cs(conf, "Check attribute %s MUST be integer64",
inst->limit_attr->tmpl_da->name);
return -1;
/* char *name, int type,
* size_t offset, void *data, char *dflt */
static CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("sql_module_instance", PW_TYPE_STRING, rlm_sqlhpwippool_t, sql_instance_name), .dflt = "sql" },
- { FR_CONF_OFFSET("db_name", PW_TYPE_STRING, rlm_sqlhpwippool_t, db_name), .dflt = "netvim" },
- { FR_CONF_OFFSET("no_free_fail", PW_TYPE_BOOLEAN, rlm_sqlhpwippool_t, no_free_fail), .dflt = "yes" },
- { FR_CONF_OFFSET("free_after", PW_TYPE_INTEGER, rlm_sqlhpwippool_t, free_after), .dflt = "300" },
- { FR_CONF_OFFSET("sync_after", PW_TYPE_INTEGER, rlm_sqlhpwippool_t, sync_after), .dflt = "25" },
+ { 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" },
CONF_PARSER_TERMINATOR
};
} rlm_sqlippool_t;
static CONF_PARSER message_config[] = {
- { FR_CONF_OFFSET("exists", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sqlippool_t, log_exists) },
- { FR_CONF_OFFSET("success", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sqlippool_t, log_success) },
- { FR_CONF_OFFSET("clear", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sqlippool_t, log_clear) },
- { FR_CONF_OFFSET("failed", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sqlippool_t, log_failed) },
- { FR_CONF_OFFSET("nopool", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sqlippool_t, log_nopool) },
+ { FR_CONF_OFFSET("exists", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, log_exists) },
+ { FR_CONF_OFFSET("success", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, log_success) },
+ { FR_CONF_OFFSET("clear", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, log_clear) },
+ { FR_CONF_OFFSET("failed", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, log_failed) },
+ { FR_CONF_OFFSET("nopool", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, log_nopool) },
CONF_PARSER_TERMINATOR
};
static CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("sql_module_instance", PW_TYPE_STRING | PW_TYPE_REQUIRED, rlm_sqlippool_t, sql_instance_name), .dflt = "sql" },
+ { 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", PW_TYPE_INTEGER, rlm_sqlippool_t, lease_duration), .dflt = "86400" },
+ { FR_CONF_OFFSET("lease_duration", FR_TYPE_INTEGER, rlm_sqlippool_t, lease_duration), .dflt = "86400" },
- { FR_CONF_OFFSET("pool_name", PW_TYPE_STRING, rlm_sqlippool_t, pool_name), .dflt = "" },
+ { FR_CONF_OFFSET("pool_name", FR_TYPE_STRING, rlm_sqlippool_t, pool_name), .dflt = "" },
- { FR_CONF_OFFSET("default_pool", PW_TYPE_STRING, rlm_sqlippool_t, defaultpool), .dflt = "main_pool" },
+ { FR_CONF_OFFSET("default_pool", FR_TYPE_STRING, rlm_sqlippool_t, defaultpool), .dflt = "main_pool" },
- { FR_CONF_OFFSET("ipv6", PW_TYPE_BOOLEAN, rlm_sqlippool_t, ipv6) },
+ { FR_CONF_OFFSET("ipv6", FR_TYPE_BOOLEAN, rlm_sqlippool_t, ipv6) },
- { FR_CONF_OFFSET("allocate_begin", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sqlippool_t, allocate_begin), .dflt = "START TRANSACTION" },
+ { FR_CONF_OFFSET("allocate_begin", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, allocate_begin), .dflt = "START TRANSACTION" },
- { FR_CONF_OFFSET("allocate_clear", PW_TYPE_STRING | PW_TYPE_XLAT , rlm_sqlippool_t, allocate_clear), .dflt = "" },
+ { FR_CONF_OFFSET("allocate_clear", FR_TYPE_STRING | FR_TYPE_XLAT , rlm_sqlippool_t, allocate_clear), .dflt = "" },
- { FR_CONF_OFFSET("allocate_find", PW_TYPE_STRING | PW_TYPE_XLAT | PW_TYPE_REQUIRED, rlm_sqlippool_t, allocate_find), .dflt = "" },
+ { FR_CONF_OFFSET("allocate_find", FR_TYPE_STRING | FR_TYPE_XLAT | FR_TYPE_REQUIRED, rlm_sqlippool_t, allocate_find), .dflt = "" },
- { FR_CONF_OFFSET("allocate_update", PW_TYPE_STRING | PW_TYPE_XLAT , rlm_sqlippool_t, allocate_update), .dflt = "" },
+ { FR_CONF_OFFSET("allocate_update", FR_TYPE_STRING | FR_TYPE_XLAT , rlm_sqlippool_t, allocate_update), .dflt = "" },
- { FR_CONF_OFFSET("allocate_commit", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sqlippool_t, allocate_commit), .dflt = "COMMIT" },
+ { FR_CONF_OFFSET("allocate_commit", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, allocate_commit), .dflt = "COMMIT" },
- { FR_CONF_OFFSET("pool_check", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sqlippool_t, pool_check), .dflt = "" },
+ { FR_CONF_OFFSET("pool_check", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, pool_check), .dflt = "" },
- { FR_CONF_OFFSET("start_begin", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sqlippool_t, start_begin), .dflt = "START TRANSACTION" },
+ { FR_CONF_OFFSET("start_begin", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, start_begin), .dflt = "START TRANSACTION" },
- { FR_CONF_OFFSET("start_update", PW_TYPE_STRING | PW_TYPE_XLAT , rlm_sqlippool_t, start_update), .dflt = "" },
+ { FR_CONF_OFFSET("start_update", FR_TYPE_STRING | FR_TYPE_XLAT , rlm_sqlippool_t, start_update), .dflt = "" },
- { FR_CONF_OFFSET("start_commit", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sqlippool_t, start_commit), .dflt = "COMMIT" },
+ { FR_CONF_OFFSET("start_commit", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, start_commit), .dflt = "COMMIT" },
- { FR_CONF_OFFSET("alive_begin", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sqlippool_t, alive_begin), .dflt = "START TRANSACTION" },
+ { FR_CONF_OFFSET("alive_begin", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, alive_begin), .dflt = "START TRANSACTION" },
- { FR_CONF_OFFSET("alive_update", PW_TYPE_STRING | PW_TYPE_XLAT , rlm_sqlippool_t, alive_update), .dflt = "" },
+ { FR_CONF_OFFSET("alive_update", FR_TYPE_STRING | FR_TYPE_XLAT , rlm_sqlippool_t, alive_update), .dflt = "" },
- { FR_CONF_OFFSET("alive_commit", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sqlippool_t, alive_commit), .dflt = "COMMIT" },
+ { FR_CONF_OFFSET("alive_commit", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, alive_commit), .dflt = "COMMIT" },
- { FR_CONF_OFFSET("stop_begin", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sqlippool_t, stop_begin), .dflt = "START TRANSACTION" },
+ { FR_CONF_OFFSET("stop_begin", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, stop_begin), .dflt = "START TRANSACTION" },
- { FR_CONF_OFFSET("stop_clear", PW_TYPE_STRING | PW_TYPE_XLAT , rlm_sqlippool_t, stop_clear), .dflt = "" },
+ { FR_CONF_OFFSET("stop_clear", FR_TYPE_STRING | FR_TYPE_XLAT , rlm_sqlippool_t, stop_clear), .dflt = "" },
- { FR_CONF_OFFSET("stop_commit", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sqlippool_t, stop_commit), .dflt = "COMMIT" },
+ { FR_CONF_OFFSET("stop_commit", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, stop_commit), .dflt = "COMMIT" },
- { FR_CONF_OFFSET("on_begin", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sqlippool_t, on_begin), .dflt = "START TRANSACTION" },
+ { FR_CONF_OFFSET("on_begin", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, on_begin), .dflt = "START TRANSACTION" },
- { FR_CONF_OFFSET("on_clear", PW_TYPE_STRING | PW_TYPE_XLAT , rlm_sqlippool_t, on_clear), .dflt = "" },
+ { FR_CONF_OFFSET("on_clear", FR_TYPE_STRING | FR_TYPE_XLAT , rlm_sqlippool_t, on_clear), .dflt = "" },
- { FR_CONF_OFFSET("on_commit", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sqlippool_t, on_commit), .dflt = "COMMIT" },
+ { FR_CONF_OFFSET("on_commit", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, on_commit), .dflt = "COMMIT" },
- { FR_CONF_OFFSET("off_begin", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sqlippool_t, off_begin), .dflt = "START TRANSACTION" },
+ { FR_CONF_OFFSET("off_begin", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, off_begin), .dflt = "START TRANSACTION" },
- { FR_CONF_OFFSET("off_clear", PW_TYPE_STRING | PW_TYPE_XLAT , rlm_sqlippool_t, off_clear), .dflt = "" },
+ { FR_CONF_OFFSET("off_clear", FR_TYPE_STRING | FR_TYPE_XLAT , rlm_sqlippool_t, off_clear), .dflt = "" },
- { FR_CONF_OFFSET("off_commit", PW_TYPE_STRING | PW_TYPE_XLAT, rlm_sqlippool_t, off_commit), .dflt = "COMMIT" },
+ { FR_CONF_OFFSET("off_commit", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, off_commit), .dflt = "COMMIT" },
- { FR_CONF_POINTER("messages", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) message_config },
+ { FR_CONF_POINTER("messages", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) message_config },
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("tmpl", PW_TYPE_TMPL, rlm_test_t, tmpl), .dflt = "&User-Name", .quote = T_BARE_WORD },
- { FR_CONF_OFFSET("tmpl_m", PW_TYPE_TMPL | PW_TYPE_MULTI, rlm_test_t, tmpl_m), .dflt = "%{User-Name}", .quote = T_DOUBLE_QUOTED_STRING },
+ { FR_CONF_OFFSET("tmpl", FR_TYPE_TMPL, rlm_test_t, tmpl), .dflt = "&User-Name", .quote = T_BARE_WORD },
+ { FR_CONF_OFFSET("tmpl_m", FR_TYPE_TMPL | FR_TYPE_MULTI, rlm_test_t, tmpl_m), .dflt = "%{User-Name}", .quote = T_DOUBLE_QUOTED_STRING },
- { FR_CONF_OFFSET("string", PW_TYPE_STRING, rlm_test_t, string) },
- { FR_CONF_OFFSET("string_m", PW_TYPE_STRING | PW_TYPE_MULTI, rlm_test_t, string_m) },
+ { 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", PW_TYPE_BOOLEAN, rlm_test_t, boolean), .dflt = "no" },
- { FR_CONF_OFFSET("boolean_m", PW_TYPE_BOOLEAN | PW_TYPE_MULTI, rlm_test_t, boolean_m), .dflt = "no" },
+ { 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("integer", PW_TYPE_INTEGER, rlm_test_t, integer), .dflt = "1" },
- { FR_CONF_OFFSET("integer_m", PW_TYPE_INTEGER | PW_TYPE_MULTI, rlm_test_t, integer_m), .dflt = "2" },
+ { 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("ipv4_addr", PW_TYPE_IPV4_ADDR, rlm_test_t, ipv4_addr), .dflt = "*" },
- { FR_CONF_OFFSET("ipv4_addr_m", PW_TYPE_IPV4_ADDR | PW_TYPE_MULTI, rlm_test_t, ipv4_addr_m), .dflt = "*" },
+ { 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("ipv4_prefix", PW_TYPE_IPV4_PREFIX, rlm_test_t, ipv4_addr), .dflt = "192.168.0.1/24" },
- { FR_CONF_OFFSET("ipv4_prefix_m", PW_TYPE_IPV4_PREFIX | PW_TYPE_MULTI, rlm_test_t, ipv4_addr_m), .dflt = "192.168.0.1/24" },
+ { FR_CONF_OFFSET("ipv4_prefix", FR_TYPE_IPV4_PREFIX, rlm_test_t, ipv4_addr), .dflt = "192.168.0.1/24" },
+ { FR_CONF_OFFSET("ipv4_prefix_m", FR_TYPE_IPV4_PREFIX | FR_TYPE_MULTI, rlm_test_t, ipv4_addr_m), .dflt = "192.168.0.1/24" },
- { FR_CONF_OFFSET("ipv6_addr", PW_TYPE_IPV6_ADDR, rlm_test_t, ipv6_addr), .dflt = "*" },
- { FR_CONF_OFFSET("ipv6_addr_m", PW_TYPE_IPV6_ADDR | PW_TYPE_MULTI, rlm_test_t, ipv6_addr_m), .dflt = "*" },
+ { FR_CONF_OFFSET("ipv6_addr", FR_TYPE_IPV6_ADDR, rlm_test_t, ipv6_addr), .dflt = "*" },
+ { FR_CONF_OFFSET("ipv6_addr_m", FR_TYPE_IPV6_ADDR | FR_TYPE_MULTI, rlm_test_t, ipv6_addr_m), .dflt = "*" },
- { FR_CONF_OFFSET("ipv6_prefix", PW_TYPE_IPV6_PREFIX, rlm_test_t, ipv6_prefix), .dflt = "::1/128" },
- { FR_CONF_OFFSET("ipv6_prefix_m", PW_TYPE_IPV6_PREFIX | PW_TYPE_MULTI, rlm_test_t, ipv6_prefix_m), .dflt = "::1/128" },
+ { FR_CONF_OFFSET("ipv6_prefix", FR_TYPE_IPV6_PREFIX, rlm_test_t, ipv6_prefix), .dflt = "::1/128" },
+ { FR_CONF_OFFSET("ipv6_prefix_m", FR_TYPE_IPV6_PREFIX | FR_TYPE_MULTI, rlm_test_t, ipv6_prefix_m), .dflt = "::1/128" },
- { FR_CONF_OFFSET("combo", PW_TYPE_COMBO_IP_ADDR, rlm_test_t, combo_ipaddr), .dflt = "::1/128" },
- { FR_CONF_OFFSET("combo_m", PW_TYPE_COMBO_IP_ADDR | PW_TYPE_MULTI, rlm_test_t, combo_ipaddr_m), .dflt = "::1/128" },
+ { FR_CONF_OFFSET("combo", FR_TYPE_COMBO_IP_ADDR, rlm_test_t, combo_ipaddr), .dflt = "::1/128" },
+ { FR_CONF_OFFSET("combo_m", FR_TYPE_COMBO_IP_ADDR | FR_TYPE_MULTI, rlm_test_t, combo_ipaddr_m), .dflt = "::1/128" },
- { FR_CONF_OFFSET("date", PW_TYPE_DATE, rlm_test_t, date) },
- { FR_CONF_OFFSET("date_m", PW_TYPE_DATE | PW_TYPE_MULTI, rlm_test_t, date_m) },
+ { FR_CONF_OFFSET("date", FR_TYPE_DATE, rlm_test_t, date) },
+ { FR_CONF_OFFSET("date_m", FR_TYPE_DATE | FR_TYPE_MULTI, rlm_test_t, date_m) },
- { FR_CONF_OFFSET("abinary", PW_TYPE_ABINARY, rlm_test_t, abinary) },
- { FR_CONF_OFFSET("abinary_m", PW_TYPE_ABINARY | PW_TYPE_MULTI, rlm_test_t, abinary_m) },
+ { FR_CONF_OFFSET("abinary", FR_TYPE_ABINARY, rlm_test_t, abinary) },
+ { FR_CONF_OFFSET("abinary_m", FR_TYPE_ABINARY | FR_TYPE_MULTI, rlm_test_t, abinary_m) },
- { FR_CONF_OFFSET("octets", PW_TYPE_OCTETS, rlm_test_t, octets) },
- { FR_CONF_OFFSET("octets_m", PW_TYPE_OCTETS | PW_TYPE_MULTI, rlm_test_t, octets_m) },
+ { 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", PW_TYPE_BYTE, rlm_test_t, byte) },
- { FR_CONF_OFFSET("bytes_m", PW_TYPE_BYTE | PW_TYPE_MULTI, rlm_test_t, byte_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("ifid", PW_TYPE_IFID, rlm_test_t, ifid) },
- { FR_CONF_OFFSET("ifid_m", PW_TYPE_IFID | PW_TYPE_MULTI, rlm_test_t, ifid_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", PW_TYPE_SHORT, rlm_test_t, shortint) },
- { FR_CONF_OFFSET("short_m", PW_TYPE_SHORT | PW_TYPE_MULTI, rlm_test_t, shortint_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("ethernet", PW_TYPE_ETHERNET, rlm_test_t, ethernet) },
- { FR_CONF_OFFSET("ethernet_m", PW_TYPE_ETHERNET | PW_TYPE_MULTI, rlm_test_t, ethernet_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", PW_TYPE_SIGNED, rlm_test_t, sinteger) },
- { FR_CONF_OFFSET("signed_m", PW_TYPE_SIGNED | PW_TYPE_MULTI, rlm_test_t, sinteger_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("uint64", PW_TYPE_INTEGER64, rlm_test_t, integer64) },
- { FR_CONF_OFFSET("uint64_m", PW_TYPE_INTEGER64 | PW_TYPE_MULTI, rlm_test_t, integer64_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("timeval", PW_TYPE_TIMEVAL, rlm_test_t, timeval) },
- { FR_CONF_OFFSET("timeval_m", PW_TYPE_TIMEVAL | PW_TYPE_MULTI, rlm_test_t, timeval_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) },
CONF_PARSER_TERMINATOR
};
static int rlm_test_cmp(UNUSED void *instance, REQUEST *request, UNUSED VALUE_PAIR *thing, VALUE_PAIR *check,
UNUSED VALUE_PAIR *check_pairs, UNUSED VALUE_PAIR **reply_pairs)
{
- rad_assert(check->vp_type == PW_TYPE_STRING);
+ rad_assert(check->vp_type == FR_TYPE_STRING);
RINFO("test-Paircmp called with \"%s\"", check->vp_strvalue);
* A mapping of configuration file names to internal variables.
*/
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("filename", PW_TYPE_FILE_INPUT | PW_TYPE_REQUIRED, rlm_unbound_t, filename), .dflt = "${modconfdir}/unbound/default.conf" },
- { FR_CONF_OFFSET("timeout", PW_TYPE_INTEGER, rlm_unbound_t, timeout), .dflt = "3000" },
+ { 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" },
CONF_PARSER_TERMINATOR
};
} rlm_unix_t;
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("radwtmp", PW_TYPE_FILE_OUTPUT | PW_TYPE_REQUIRED, rlm_unix_t, radwtmp), .dflt = "NULL" },
+ { FR_CONF_OFFSET("radwtmp", FR_TYPE_FILE_OUTPUT | FR_TYPE_REQUIRED, rlm_unix_t, radwtmp), .dflt = "NULL" },
CONF_PARSER_TERMINATOR
};
char *p;
size_t len, input_len;
int offset;
- PW_TYPE type;
+ fr_type_t type;
fr_dict_attr_t const *da;
VALUE_PAIR *vp, *cast;
uint8_t const *input;
if (*data_name == '&') {
if (radius_get_vp(&vp, request, data_name) < 0) goto nothing;
- if ((vp->vp_type != PW_TYPE_OCTETS) &&
- (vp->vp_type != PW_TYPE_STRING)) {
+ if ((vp->vp_type != FR_TYPE_OCTETS) &&
+ (vp->vp_type != FR_TYPE_STRING)) {
REDEBUG("unpack requires the input attribute to be 'string' or 'octets'");
goto nothing;
}
goto nothing;
}
- type = fr_str2int(dict_attr_types, data_type, PW_TYPE_INVALID);
- if (type == PW_TYPE_INVALID) {
+ type = fr_str2int(dict_attr_types, data_type, FR_TYPE_INVALID);
+ if (type == FR_TYPE_INVALID) {
REDEBUG("Invalid data type '%s'", data_type);
goto nothing;
}
* Hacks
*/
switch (type) {
- case PW_TYPE_SIGNED:
- case PW_TYPE_INTEGER:
- case PW_TYPE_DATE:
+ case FR_TYPE_SIGNED:
+ case FR_TYPE_INTEGER:
+ case FR_TYPE_DATE:
cast->vp_integer = ntohl(cast->vp_integer);
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
cast->vp_short = ((input[offset] << 8) | input[offset + 1]);
break;
- case PW_TYPE_INTEGER64:
+ case FR_TYPE_INTEGER64:
cast->vp_integer64 = ntohll(cast->vp_integer64);
break;
for (vp = fr_pair_cursor_init(&cursor, &request->packet->vps);
vp;
vp = fr_pair_cursor_next(&cursor)) {
- if (vp->vp_type != PW_TYPE_STRING) continue;
+ if (vp->vp_type != FR_TYPE_STRING) continue;
for (i = 0; i < vp->vp_length; i += len) {
len = fr_utf8_char(&vp->vp_octets[i], -1);
} rlm_wimax_t;
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("delete_mppe_keys", PW_TYPE_BOOLEAN, rlm_wimax_t, delete_mppe_keys), .dflt = "no" },
+ { FR_CONF_OFFSET("delete_mppe_keys", FR_TYPE_BOOLEAN, rlm_wimax_t, delete_mppe_keys), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
#include <wbclient.h>
static const CONF_PARSER group_config[] = {
- { FR_CONF_OFFSET("group_search_username", PW_TYPE_TMPL, rlm_winbind_t, group_username) },
- { FR_CONF_OFFSET("group_add_domain", PW_TYPE_BOOLEAN, rlm_winbind_t, group_add_domain), .dflt = "yes" },
- { FR_CONF_OFFSET("group_attribute", PW_TYPE_STRING, rlm_winbind_t, group_attribute) },
+ { 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_attribute", FR_TYPE_STRING, rlm_winbind_t, group_attribute) },
CONF_PARSER_TERMINATOR
};
static const CONF_PARSER module_config[] = {
- { FR_CONF_OFFSET("winbind_username", PW_TYPE_TMPL, rlm_winbind_t, wb_username) },
- { FR_CONF_OFFSET("winbind_domain", PW_TYPE_TMPL, rlm_winbind_t, wb_domain) },
- { FR_CONF_POINTER("group", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) group_config },
+ { FR_CONF_OFFSET("winbind_username", FR_TYPE_TMPL, rlm_winbind_t, wb_username) },
+ { FR_CONF_OFFSET("winbind_domain", FR_TYPE_TMPL, rlm_winbind_t, wb_domain) },
+ { FR_CONF_POINTER("group", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) group_config },
CONF_PARSER_TERMINATOR
};
#ifdef HAVE_YKCLIENT
static const CONF_PARSER validation_config[] = {
- { FR_CONF_OFFSET("client_id", PW_TYPE_INTEGER, rlm_yubikey_t, client_id), .dflt = 0 },
- { FR_CONF_OFFSET("api_key", PW_TYPE_STRING | PW_TYPE_SECRET, rlm_yubikey_t, api_key) },
+ { FR_CONF_OFFSET("client_id", FR_TYPE_INTEGER, 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", PW_TYPE_INTEGER, rlm_yubikey_t, id_len), .dflt = "12" },
- { FR_CONF_OFFSET("split", PW_TYPE_BOOLEAN, rlm_yubikey_t, split), .dflt = "yes" },
- { FR_CONF_OFFSET("decrypt", PW_TYPE_BOOLEAN, rlm_yubikey_t, decrypt), .dflt = "no" },
- { FR_CONF_OFFSET("validate", PW_TYPE_BOOLEAN, rlm_yubikey_t, validate), .dflt = "no" },
+ { 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" },
#ifdef HAVE_YKCLIENT
- { FR_CONF_POINTER("validation", PW_TYPE_SUBSECTION, NULL), .subcs = (void const *) validation_config },
+ { FR_CONF_POINTER("validation", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) validation_config },
#endif
CONF_PARSER_TERMINATOR
};
* These sizes may be different than the sizes of INTERNAL formats, PRESENTATION
* formats and generic NETWORK formats.
*/
-size_t const fr_radius_attr_sizes[PW_TYPE_MAX + 1][2] = {
- [PW_TYPE_INVALID] = {~0, 0}, //!< Ensure array starts at 0 (umm?)
+size_t const fr_radius_attr_sizes[FR_TYPE_MAX + 1][2] = {
+ [FR_TYPE_INVALID] = {~0, 0}, //!< Ensure array starts at 0 (umm?)
- [PW_TYPE_STRING] = {0, ~0},
- [PW_TYPE_OCTETS] = {0, ~0},
+ [FR_TYPE_STRING] = {0, ~0},
+ [FR_TYPE_OCTETS] = {0, ~0},
- [PW_TYPE_IPV4_ADDR] = {4, 4},
- [PW_TYPE_IPV4_PREFIX] = {6, 6},
- [PW_TYPE_IPV6_ADDR] = {16, 16},
- [PW_TYPE_IPV6_PREFIX] = {2, 18},
- [PW_TYPE_COMBO_IP_ADDR] = {4, 16},
- [PW_TYPE_IFID] = {8, 8},
- [PW_TYPE_ETHERNET] = {6, 6},
+ [FR_TYPE_IPV4_ADDR] = {4, 4},
+ [FR_TYPE_IPV4_PREFIX] = {6, 6},
+ [FR_TYPE_IPV6_ADDR] = {16, 16},
+ [FR_TYPE_IPV6_PREFIX] = {2, 18},
+ [FR_TYPE_COMBO_IP_ADDR] = {4, 16},
+ [FR_TYPE_IFID] = {8, 8},
+ [FR_TYPE_ETHERNET] = {6, 6},
- [PW_TYPE_BOOLEAN] = {1, 1},
- [PW_TYPE_BYTE] = {1, 1},
- [PW_TYPE_SHORT] = {2, 2},
- [PW_TYPE_INTEGER] = {4, 4},
- [PW_TYPE_INTEGER64] = {8, 8},
+ [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},
- [PW_TYPE_DATE] = {4, 4},
- [PW_TYPE_ABINARY] = {32, ~0},
+ [FR_TYPE_DATE] = {4, 4},
+ [FR_TYPE_ABINARY] = {32, ~0},
- [PW_TYPE_TLV] = {2, ~0},
- [PW_TYPE_STRUCT] = {1, ~0},
+ [FR_TYPE_TLV] = {2, ~0},
+ [FR_TYPE_STRUCT] = {1, ~0},
- [PW_TYPE_EXTENDED] = {2, ~0},
- [PW_TYPE_LONG_EXTENDED] = {3, ~0},
+ [FR_TYPE_EXTENDED] = {2, ~0},
+ [FR_TYPE_LONG_EXTENDED] = {3, ~0},
- [PW_TYPE_VSA] = {4, ~0},
- [PW_TYPE_EVS] = {6, ~0},
+ [FR_TYPE_VSA] = {4, ~0},
+ [FR_TYPE_EVS] = {6, ~0},
- [PW_TYPE_MAX] = {~0, 0} //!< Ensure array covers all types.
+ [FR_TYPE_MAX] = {~0, 0} //!< Ensure array covers all types.
};
/*
size_t fr_radius_attr_len(VALUE_PAIR const *vp)
{
switch (vp->vp_type) {
- case PW_TYPE_VARIABLE_SIZE:
+ case FR_TYPE_VARIABLE_SIZE:
return vp->vp_length;
default:
return fr_radius_attr_sizes[vp->vp_type][0];
- case PW_TYPE_STRUCTURAL:
+ case FR_TYPE_STRUCTURAL:
if (!fr_cond_assert(0)) return 0;
}
}
/*
* Parent must be a vendor
*/
- if (!fr_cond_assert(parent->type == PW_TYPE_VENDOR)) {
+ if (!fr_cond_assert(parent->type == FR_TYPE_VENDOR)) {
fr_strerror_printf("%s: Internal sanity check failed", __FUNCTION__);
return -1;
}
/*
* Container must be a VSA
*/
- if (!fr_cond_assert(parent->type == PW_TYPE_VSA)) return -1;
+ if (!fr_cond_assert(parent->type == FR_TYPE_VSA)) return -1;
if (attr_len > packet_len) return -1;
if (attr_len < 5) return -1; /* vid, value */
*/
if (data_len >= sizeof(buffer)) return -1;
- if (parent->type == PW_TYPE_STRING) {
+ if (parent->type == FR_TYPE_STRING) {
memcpy(buffer, p + 1, data_len - 1);
tag = p[0];
data_len -= 1;
- } else if (parent->type == PW_TYPE_INTEGER) {
+ } else if (parent->type == FR_TYPE_INTEGER) {
memcpy(buffer, p, attr_len);
tag = buffer[0];
buffer[0] = 0;
/*
* Chop the attribute to its maximum length.
*/
- if ((parent->type == PW_TYPE_OCTETS) &&
+ if ((parent->type == FR_TYPE_OCTETS) &&
(parent->flags.length && (data_len > parent->flags.length))) {
data_len = parent->flags.length;
}
*/
FR_PROTO_TRACE("Type \"%s\" (%u)", fr_int2str(dict_attr_types, parent->type, "?Unknown?"), parent->type);
switch (parent->type) {
- case PW_TYPE_STRING:
- case PW_TYPE_OCTETS:
+ case FR_TYPE_STRING:
+ case FR_TYPE_OCTETS:
break;
- case PW_TYPE_ABINARY:
+ case FR_TYPE_ABINARY:
if (data_len > sizeof(vp->vp_filter)) goto raw;
break;
- case PW_TYPE_INTEGER:
- case PW_TYPE_IPV4_ADDR:
- case PW_TYPE_DATE:
- case PW_TYPE_SIGNED:
+ case FR_TYPE_INTEGER:
+ case FR_TYPE_IPV4_ADDR:
+ case FR_TYPE_DATE:
+ case FR_TYPE_SIGNED:
if (data_len != 4) goto raw;
break;
- case PW_TYPE_INTEGER64:
- case PW_TYPE_IFID:
+ case FR_TYPE_INTEGER64:
+ case FR_TYPE_IFID:
if (data_len != 8) goto raw;
break;
- case PW_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_ADDR:
if (data_len != 16) goto raw;
break;
- case PW_TYPE_IPV4_PREFIX:
+ case FR_TYPE_IPV4_PREFIX:
if (data_len != 6) goto raw;
if (p[0] != 0) goto raw;
if ((p[1] & 0x3f) > 32) goto raw;
if (memcmp(p + 2, (uint8_t *)&tmp_prefix.addr.v4.s_addr, data_len - 2) != 0) goto raw;
break;
- case PW_TYPE_IPV6_PREFIX:
+ case FR_TYPE_IPV6_PREFIX:
{
if ((data_len < 2) || (data_len > 18)) goto raw;
if (p[0] != 0) goto raw; /* First byte is always 0 */
}
break;
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
if (data_len != 1) goto raw;
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
if (data_len != 2) goto raw;
break;
- case PW_TYPE_ETHERNET:
+ case FR_TYPE_ETHERNET:
if (data_len != 6) goto raw;
break;
- case PW_TYPE_COMBO_IP_ADDR:
+ case FR_TYPE_COMBO_IP_ADDR:
if (data_len == 4) {
- child = fr_dict_attr_by_type(parent, PW_TYPE_IPV4_ADDR);
+ child = fr_dict_attr_by_type(parent, FR_TYPE_IPV4_ADDR);
} else if (data_len == 16) {
- child = fr_dict_attr_by_type(parent, PW_TYPE_IPV6_ADDR);
+ child = fr_dict_attr_by_type(parent, FR_TYPE_IPV6_ADDR);
} else {
goto raw;
}
* recursion! Ask yourself, "is recursion OK?"
*/
- case PW_TYPE_EXTENDED:
+ case FR_TYPE_EXTENDED:
if (data_len < 2) goto raw; /* etype, value */
child = fr_dict_attr_child_by_num(parent, p[0]);
if (rcode < 0) goto raw;
return 1 + rcode;
- case PW_TYPE_LONG_EXTENDED:
+ case FR_TYPE_LONG_EXTENDED:
if (data_len < 3) goto raw; /* etype, flags, value */
child = fr_dict_attr_child_by_num(parent, p[0]);
*/
return decode_extended(ctx, cursor, child, data, attr_len, packet_len, decoder_ctx);
- case PW_TYPE_EVS:
+ case FR_TYPE_EVS:
{
fr_dict_attr_t const *vendor_child;
return 5 + rcode;
}
- case PW_TYPE_TLV:
+ case FR_TYPE_TLV:
/*
* We presume that the TLVs all fit into one
* attribute, OR they've already been grouped
if (rcode < 0) goto raw;
return rcode;
- case PW_TYPE_STRUCT:
+ case FR_TYPE_STRUCT:
/*
* We presume that the struct fits into one
* attribute, OR it's already been grouped
if (rcode < 0) goto raw;
return rcode;
- case PW_TYPE_VSA:
+ case FR_TYPE_VSA:
/*
* VSAs can be WiMAX, in which case they don't
* fit into one attribute.
/*
* Fix for Coverity.
*/
- if (parent->type != PW_TYPE_OCTETS) {
+ if (parent->type != FR_TYPE_OCTETS) {
fr_dict_unknown_free(&parent);
return -1;
}
vp->tag = tag;
switch (parent->type) {
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
fr_pair_value_bstrncpy(vp, p, data_len); /* sets vp_length */
break;
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
fr_pair_value_memcpy(vp, p, data_len); /* sets vp_length */
break;
- case PW_TYPE_ABINARY:
+ case FR_TYPE_ABINARY:
if (data_len > sizeof(vp->vp_filter)) data_len = sizeof(vp->vp_filter);
memcpy(vp->vp_filter, p, data_len);
vp->vp_length = data_len;
break;
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
vp->vp_byte = p[0];
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
vp->vp_short = (p[0] << 8) | p[1];
break;
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
memcpy(&vp->vp_integer, p, 4);
vp->vp_integer = ntohl(vp->vp_integer);
break;
- case PW_TYPE_INTEGER64:
+ case FR_TYPE_INTEGER64:
memcpy(&vp->vp_integer64, p, 8);
vp->vp_integer64 = ntohll(vp->vp_integer64);
break;
- case PW_TYPE_DATE:
+ case FR_TYPE_DATE:
memcpy(&vp->vp_date, p, 4);
vp->vp_date = ntohl(vp->vp_date);
break;
- case PW_TYPE_ETHERNET:
+ case FR_TYPE_ETHERNET:
memcpy(vp->vp_ether, p, 6);
break;
- case PW_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV4_ADDR:
vp->vp_ip.af = AF_INET;
vp->vp_ip.prefix = 32;
vp->vp_ip.scope_id = 0;
memcpy(&vp->vp_ipv4addr, p, 4);
break;
- case PW_TYPE_IFID:
+ case FR_TYPE_IFID:
memcpy(vp->vp_ifid, p, 8);
break;
- case PW_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_ADDR:
vp->vp_ip.af = AF_INET6;
vp->vp_ip.prefix = 128;
vp->vp_ip.scope_id = 0;
memcpy(&vp->vp_ipv6addr, p, 16);
break;
- case PW_TYPE_IPV4_PREFIX:
- case PW_TYPE_IPV6_PREFIX:
+ case FR_TYPE_IPV4_PREFIX:
+ case FR_TYPE_IPV6_PREFIX:
memcpy(&vp->vp_ip, &tmp_prefix, sizeof(vp->vp_ip));
break;
- case PW_TYPE_SIGNED: /* overloaded with vp_integer */
+ case FR_TYPE_SIGNED: /* overloaded with vp_integer */
memcpy(&vp->vp_integer, p, 4);
vp->vp_integer = ntohl(vp->vp_integer);
break;
if (outlen > len) outlen = len;
switch (vp->vp_type) {
- case PW_TYPE_STRING:
- case PW_TYPE_OCTETS:
+ case FR_TYPE_STRING:
+ case FR_TYPE_OCTETS:
memcpy(out, vp->vp_ptr, outlen);
return outlen;
/*
* All of these values are at the same location.
*/
- case PW_TYPE_IFID:
- case PW_TYPE_IPV4_ADDR:
- case PW_TYPE_IPV6_ADDR:
- case PW_TYPE_IPV6_PREFIX:
- case PW_TYPE_IPV4_PREFIX:
- case PW_TYPE_ABINARY:
- case PW_TYPE_ETHERNET:
- case PW_TYPE_COMBO_IP_ADDR:
+ case FR_TYPE_IFID:
+ case FR_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_PREFIX:
+ case FR_TYPE_IPV4_PREFIX:
+ case FR_TYPE_ABINARY:
+ case FR_TYPE_ETHERNET:
+ case FR_TYPE_COMBO_IP_ADDR:
memcpy(out, &vp->data.datum, outlen);
break;
- case PW_TYPE_BOOLEAN:
+ case FR_TYPE_BOOLEAN:
out[0] = vp->vp_byte & 0x01;
break;
- case PW_TYPE_BYTE:
+ case FR_TYPE_BYTE:
out[0] = vp->vp_byte & 0xff;
break;
- case PW_TYPE_SHORT:
+ case FR_TYPE_SHORT:
out[0] = (vp->vp_short >> 8) & 0xff;
out[1] = vp->vp_short & 0xff;
break;
- case PW_TYPE_INTEGER:
+ case FR_TYPE_INTEGER:
lvalue = htonl(vp->vp_integer);
memcpy(out, &lvalue, sizeof(lvalue));
break;
- case PW_TYPE_INTEGER64:
+ case FR_TYPE_INTEGER64:
lvalue64 = htonll(vp->vp_integer64);
memcpy(out, &lvalue64, sizeof(lvalue64));
break;
- case PW_TYPE_DATE:
+ case FR_TYPE_DATE:
lvalue = htonl(vp->vp_date);
memcpy(out, &lvalue, sizeof(lvalue));
break;
- case PW_TYPE_SIGNED:
+ case FR_TYPE_SIGNED:
{
int32_t slvalue = htonl(vp->vp_signed);
memcpy(out, &slvalue, sizeof(slvalue));
break;
}
- case PW_TYPE_INVALID:
- case PW_TYPE_EXTENDED:
- case PW_TYPE_LONG_EXTENDED:
- case PW_TYPE_COMBO_IP_PREFIX:
- case PW_TYPE_EVS:
- case PW_TYPE_VSA:
- case PW_TYPE_VENDOR:
- case PW_TYPE_TLV:
- case PW_TYPE_STRUCT:
- case PW_TYPE_SIZE:
- case PW_TYPE_TIMEVAL:
- case PW_TYPE_DECIMAL:
- case PW_TYPE_MAX:
+ case FR_TYPE_INVALID:
+ case FR_TYPE_EXTENDED:
+ case FR_TYPE_LONG_EXTENDED:
+ case FR_TYPE_COMBO_IP_PREFIX:
+ case FR_TYPE_EVS:
+ case FR_TYPE_VSA:
+ case FR_TYPE_VENDOR:
+ case FR_TYPE_TLV:
+ case FR_TYPE_STRUCT:
+ case FR_TYPE_SIZE:
+ case FR_TYPE_TIMEVAL:
+ case FR_TYPE_DECIMAL:
+ case FR_TYPE_MAX:
fr_strerror_printf("Cannot get data for VALUE_PAIR type %i", vp->vp_type);
return -1;
VERIFY_VP(fr_pair_cursor_current(cursor));
FR_PROTO_STACK_PRINT(tlv_stack, depth);
- if (tlv_stack[depth]->type != PW_TYPE_STRUCT) {
+ if (tlv_stack[depth]->type != FR_TYPE_STRUCT) {
fr_strerror_printf("%s: Expected type \"struct\" got \"%s\"", __FUNCTION__,
fr_int2str(dict_attr_types, tlv_stack[depth]->type, "?Unknown?"));
return -1;
/*
* Determine the nested type and call the appropriate encoder
*/
- if (tlv_stack[depth + 1]->type == PW_TYPE_TLV) {
+ if (tlv_stack[depth + 1]->type == FR_TYPE_TLV) {
len = encode_tlv_hdr(p, sublen, tlv_stack, depth + 1, cursor, encoder_ctx);
} else {
len = encode_rfc_hdr_internal(p, sublen, tlv_stack, depth + 1, cursor, encoder_ctx);
VERIFY_VP(fr_pair_cursor_current(cursor));
FR_PROTO_STACK_PRINT(tlv_stack, depth);
- if (tlv_stack[depth]->type != PW_TYPE_TLV) {
+ if (tlv_stack[depth]->type != FR_TYPE_TLV) {
fr_strerror_printf("%s: Expected type \"tlv\" got \"%s\"", __FUNCTION__,
fr_int2str(dict_attr_types, tlv_stack[depth]->type, "?Unknown?"));
return -1;
* It's a little weird to consider a TLV as a value,
* but it seems to work OK.
*/
- if (da->type == PW_TYPE_TLV) {
+ if (da->type == FR_TYPE_TLV) {
return encode_tlv_hdr(out, outlen, tlv_stack, depth, cursor, encoder_ctx);
}
/*
* This has special requirements.
*/
- if (da->type == PW_TYPE_STRUCT) {
+ if (da->type == FR_TYPE_STRUCT) {
len = encode_struct(out, outlen, tlv_stack, depth, cursor, encoder_ctx);
if (len < 0) return len;
}
switch (da->type) {
- case PW_TYPE_STRUCTURAL:
+ case FR_TYPE_STRUCTURAL:
fr_strerror_printf("%s: Called with structural type %s", __FUNCTION__,
fr_int2str(dict_attr_types, tlv_stack[depth]->type, "?Unknown?"));
return -1;
len = fr_radius_attr_len(vp);
switch (da->type) {
- case PW_TYPE_OCTETS:
+ case FR_TYPE_OCTETS:
/*
* If asked to encode more data than allowed, we
* encode only the allowed data.
}
/* FALL-THROUGH */
- case PW_TYPE_STRING:
+ case FR_TYPE_STRING:
data = vp->vp_ptr;
if (!data) {
fr_strerror_printf("ERROR: Cannot encode NULL data");
/*
* Simple data types use the common encoder.
*/
- case PW_TYPE_IFID:
- case PW_TYPE_IPV4_ADDR:
- case PW_TYPE_IPV6_ADDR:
- case PW_TYPE_IPV6_PREFIX:
- case PW_TYPE_IPV4_PREFIX:
- case PW_TYPE_ABINARY:
- case PW_TYPE_ETHERNET: /* just in case */
- case PW_TYPE_BYTE:
- case PW_TYPE_BOOLEAN:
- case PW_TYPE_SHORT:
- case PW_TYPE_INTEGER:
- case PW_TYPE_INTEGER64:
- case PW_TYPE_DATE:
- case PW_TYPE_SIGNED:
+ case FR_TYPE_IFID:
+ case FR_TYPE_IPV4_ADDR:
+ case FR_TYPE_IPV6_ADDR:
+ case FR_TYPE_IPV6_PREFIX:
+ 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_DATE:
+ case FR_TYPE_SIGNED:
len = fr_radius_encode_value_hton(buffer, sizeof(buffer), vp);
if (len < 0) return -1;
data = buffer;
* Attributes with encrypted values MUST be less than
* 128 bytes long.
*/
- if (da->type != PW_TYPE_STRUCT) switch (vp->da->flags.encrypt) {
+ if (da->type != FR_TYPE_STRUCT) switch (vp->da->flags.encrypt) {
case FLAG_ENCRYPT_USER_PASSWORD:
encode_password(ptr, &len, data, len, packet_ctx->secret, packet_ctx->vector);
break;
default:
if (vp->da->flags.has_tag && TAG_VALID(vp->tag)) {
- if (vp->vp_type == PW_TYPE_STRING) {
+ if (vp->vp_type == FR_TYPE_STRING) {
if (len > ((ssize_t) (outlen - 1))) len = outlen - 1;
ptr[0] = vp->tag;
ptr++;
- } else if (vp->vp_type == PW_TYPE_INTEGER) {
+ } else if (vp->vp_type == FR_TYPE_INTEGER) {
buffer[0] = vp->tag;
} /* else it can't be any other type */
}
vp_cursor_t *cursor, void *encoder_ctx)
{
int len;
- PW_TYPE attr_type;
+ fr_type_t attr_type;
#ifndef NDEBUG
- PW_TYPE vsa_type;
+ fr_type_t vsa_type;
#endif
uint8_t *start = out;
VALUE_PAIR const *vp = fr_pair_cursor_current(cursor);
VERIFY_VP(vp);
FR_PROTO_STACK_PRINT(tlv_stack, depth);
- if ((tlv_stack[depth]->type != PW_TYPE_EXTENDED) && (tlv_stack[depth]->type != PW_TYPE_LONG_EXTENDED)) {
+ if ((tlv_stack[depth]->type != FR_TYPE_EXTENDED) && (tlv_stack[depth]->type != FR_TYPE_LONG_EXTENDED)) {
fr_strerror_printf("%s : Called for non-extended attribute type %s",
__FUNCTION__, fr_int2str(dict_attr_types, tlv_stack[depth]->type, "?Unknown?"));
return -1;
/*
* Encode the header for "short" or "long" attributes
*/
- if (attr_type == PW_TYPE_EXTENDED) {
+ if (attr_type == FR_TYPE_EXTENDED) {
if (outlen < 3) return 0;
out[1] = 3;
/*
* Handle EVS
*/
- if (tlv_stack[depth]->type == PW_TYPE_EVS) {
+ if (tlv_stack[depth]->type == FR_TYPE_EVS) {
uint8_t *evs = out + out[1];
uint32_t lvalue;
* "outlen" can be larger than 255 here, but only for the
* "long" extended type.
*/
- if ((attr_type == PW_TYPE_EXTENDED) && (outlen > 255)) outlen = 255;
+ if ((attr_type == FR_TYPE_EXTENDED) && (outlen > 255)) outlen = 255;
- if (tlv_stack[depth]->type == PW_TYPE_TLV) {
+ if (tlv_stack[depth]->type == FR_TYPE_TLV) {
len = encode_tlv_hdr_internal(out + out[1], outlen - out[1], tlv_stack, depth, cursor, encoder_ctx);
} else {
len = encode_value(out + out[1], outlen - out[1], tlv_stack, depth, cursor, encoder_ctx);
int jump = 3;
fprintf(fr_log_fp, "\t\t%02x %02x ", out[0], out[1]);
- if (attr_type == PW_TYPE_EXTENDED) {
+ if (attr_type == FR_TYPE_EXTENDED) {
fprintf(fr_log_fp, "%02x ", out[2]);
} else {
jump = 4;
}
- if (vsa_type == PW_TYPE_EVS) {
+ if (vsa_type == FR_TYPE_EVS) {
fprintf(fr_log_fp, "%02x%02x%02x%02x (%u) %02x ",
out[jump], out[jump + 1],
out[jump + 2], out[jump + 3],
FR_PROTO_STACK_PRINT(tlv_stack, depth);
switch (tlv_stack[depth]->type) {
- case PW_TYPE_STRUCTURAL:
+ case FR_TYPE_STRUCTURAL:
fr_strerror_printf("%s: Called with structural type %s", __FUNCTION__,
fr_int2str(dict_attr_types, tlv_stack[depth]->type, "?Unknown?"));
return -1;
dv = tlv_stack[depth++];
- if (dv->type != PW_TYPE_VENDOR) {
+ if (dv->type != FR_TYPE_VENDOR) {
fr_strerror_printf("Expected Vendor");
return -1;
}
da = tlv_stack[depth];
- if ((da->type != PW_TYPE_TLV) && (dv->flags.type_size == 1) && (dv->flags.length == 1)) {
+ if ((da->type != FR_TYPE_TLV) && (dv->flags.type_size == 1) && (dv->flags.length == 1)) {
return encode_rfc_hdr_internal(out, outlen, tlv_stack, depth, cursor, encoder_ctx);
}
* if this is a TLV, we must process it via the
* internal tlv function, else we get a double TLV header.
*/
- if (tlv_stack[depth]->type == PW_TYPE_TLV) {
+ if (tlv_stack[depth]->type == FR_TYPE_TLV) {
len = encode_tlv_hdr_internal(out + hdr_len, outlen - hdr_len, tlv_stack, depth, cursor, encoder_ctx);
} else {
len = encode_value(out + hdr_len, outlen - hdr_len, tlv_stack, depth, cursor, encoder_ctx);
* "outlen" can be larger than 255 because of the "continuation" byte.
*/
- if (tlv_stack[depth]->type == PW_TYPE_TLV) {
+ if (tlv_stack[depth]->type == FR_TYPE_TLV) {
len = encode_tlv_hdr_internal(out + out[1], outlen - out[1], tlv_stack, depth, cursor, encoder_ctx);
if (len <= 0) return len;
} else {
FR_PROTO_STACK_PRINT(tlv_stack, depth);
- if (da->type != PW_TYPE_VSA) {
+ if (da->type != FR_TYPE_VSA) {
fr_strerror_printf("%s: Expected type \"vsa\" got \"%s\"", __FUNCTION__,
fr_int2str(dict_attr_types, da->type, "?Unknown?"));
return -1;
da = tlv_stack[++depth];
FR_PROTO_STACK_PRINT(tlv_stack, depth);
- if (da->type != PW_TYPE_VENDOR) {
+ if (da->type != FR_TYPE_VENDOR) {
fr_strerror_printf("%s: Expected type \"vsa\" got \"%s\"", __FUNCTION__,
fr_int2str(dict_attr_types, da->type, "?Unknown?"));
return -1;
FR_PROTO_STACK_PRINT(tlv_stack, depth);
switch (tlv_stack[depth]->type) {
- case PW_TYPE_STRUCTURAL:
+ case FR_TYPE_STRUCTURAL:
fr_strerror_printf("%s: Expected leaf type got \"%s\"", __FUNCTION__,
fr_int2str(dict_attr_types, tlv_stack[depth]->type, "?Unknown?"));
return -1;
/*
* Fast path for the common case.
*/
- if (vp->da->parent->flags.is_root && !vp->da->flags.concat && (vp->vp_type != PW_TYPE_TLV)) {
+ if (vp->da->parent->flags.is_root && !vp->da->flags.concat && (vp->vp_type != FR_TYPE_TLV)) {
tlv_stack[0] = vp->da;
tlv_stack[1] = NULL;
FR_PROTO_STACK_PRINT(tlv_stack, 0);
ret = encode_rfc_hdr(out, attr_len, tlv_stack, 0, cursor, encoder_ctx);
break;
- case PW_TYPE_VSA:
+ case FR_TYPE_VSA:
if (vp->da->vendor == VENDORPEC_WIMAX) {
/*
* WiMAX has a non-standard format for
ret = encode_vsa_hdr(out, attr_len, tlv_stack, 0, cursor, encoder_ctx);
break;
- case PW_TYPE_TLV:
+ case FR_TYPE_TLV:
ret = encode_tlv_hdr(out, attr_len, tlv_stack, 0, cursor, encoder_ctx);
break;
- case PW_TYPE_EXTENDED:
+ case FR_TYPE_EXTENDED:
ret = encode_extended_hdr(out, attr_len, tlv_stack, 0, cursor, encoder_ctx);
break;
- case PW_TYPE_LONG_EXTENDED:
+ case FR_TYPE_LONG_EXTENDED:
/*
* These attributes can be longer than 253
* octets. We therefore fragment the data across
ret = encode_extended_hdr(out, outlen, tlv_stack, 0, cursor, encoder_ctx);
break;
- case PW_TYPE_INVALID:
- case PW_TYPE_VENDOR:
- case PW_TYPE_TIMEVAL:
- case PW_TYPE_DECIMAL:
- case PW_TYPE_EVS:
- case PW_TYPE_MAX:
+ case FR_TYPE_INVALID:
+ case FR_TYPE_VENDOR:
+ case FR_TYPE_TIMEVAL:
+ case FR_TYPE_DECIMAL:
+ case FR_TYPE_EVS:
+ case FR_TYPE_MAX:
fr_strerror_printf("%s: Cannot encode attribute %s", __FUNCTION__, vp->da->name);
return -1;
}
#define AUTH_PASS_LEN (AUTH_VECTOR_LEN)
#define MAX_PASS_LEN (128)
#define FR_TUNNEL_PW_ENC_LENGTH(_x) (2 + 1 + _x + PAD(_x + 1, 16))
-extern size_t const fr_radius_attr_sizes[PW_TYPE_MAX + 1][2];
+extern size_t const fr_radius_attr_sizes[FR_TYPE_MAX + 1][2];
extern FR_NAME_NUMBER const fr_request_types[];
typedef enum {
projects / thirdparty / freeradius-server.git / commitdiff
