# after the opening brace, and before the closing brace.
#
# static conf_parser_t group_config[] = {
-# { FR_CONF_OFFSET("filter", FR_TYPE_STRING, 0, rlm_ldap_t, groupobj_filter) }
+# { FR_CONF_OFFSET("filter", rlm_ldap_t, groupobj_filter) }
# };
#
ContinuationIndentWidth: 8
static size_t fr_curl_sslcode_table_len = NUM_ELEMENTS(fr_curl_sslcode_table);
conf_parser_t fr_curl_tls_config[] = {
- { FR_CONF_OFFSET("ca_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_curl_tls_t, ca_file) },
- { FR_CONF_OFFSET("ca_issuer_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_curl_tls_t, ca_issuer_file) },
- { FR_CONF_OFFSET("ca_path", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_curl_tls_t, ca_path) },
- { FR_CONF_OFFSET("certificate_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_curl_tls_t, certificate_file) },
- { FR_CONF_OFFSET("private_key_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_curl_tls_t, private_key_file) },
- { FR_CONF_OFFSET("private_key_password", FR_TYPE_STRING, CONF_FLAG_SECRET, fr_curl_tls_t, private_key_password) },
- { FR_CONF_OFFSET("random_file", FR_TYPE_STRING, 0, fr_curl_tls_t, random_file) },
- { FR_CONF_OFFSET("require_cert", FR_TYPE_VOID, 0, fr_curl_tls_t, require_cert),
+ { FR_CONF_OFFSET_FLAGS("ca_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_curl_tls_t, ca_file) },
+ { FR_CONF_OFFSET_FLAGS("ca_issuer_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_curl_tls_t, ca_issuer_file) },
+ { FR_CONF_OFFSET_FLAGS("ca_path", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_curl_tls_t, ca_path) },
+ { FR_CONF_OFFSET_FLAGS("certificate_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_curl_tls_t, certificate_file) },
+ { FR_CONF_OFFSET_FLAGS("private_key_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_curl_tls_t, private_key_file) },
+ { FR_CONF_OFFSET_FLAGS("private_key_password", FR_TYPE_STRING, CONF_FLAG_SECRET, fr_curl_tls_t, private_key_password) },
+ { FR_CONF_OFFSET("random_file", fr_curl_tls_t, random_file) },
+ { FR_CONF_OFFSET_FLAGS("require_cert", FR_TYPE_VOID, 0, fr_curl_tls_t, require_cert),
.func = cf_table_parse_int,
.uctx = &(cf_table_parse_ctx_t){
.table = fr_curl_sslcode_table,
.len = &fr_curl_sslcode_table_len
},
.dflt = "allow" },
- { FR_CONF_OFFSET("check_cert", FR_TYPE_BOOL, 0, fr_curl_tls_t, check_cert), .dflt = "yes" },
- { FR_CONF_OFFSET("check_cert_cn", FR_TYPE_BOOL, 0, fr_curl_tls_t, check_cert_cn), .dflt = "yes" },
- { FR_CONF_OFFSET("extract_cert_attrs", FR_TYPE_BOOL, 0, fr_curl_tls_t, extract_cert_attrs), .dflt = "no" },
+ { FR_CONF_OFFSET("check_cert", fr_curl_tls_t, check_cert), .dflt = "yes" },
+ { FR_CONF_OFFSET("check_cert_cn", fr_curl_tls_t, check_cert_cn), .dflt = "yes" },
+ { FR_CONF_OFFSET("extract_cert_attrs", fr_curl_tls_t, extract_cert_attrs), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
static conf_parser_t reuse_curl_conn_config[] = {
- { FR_CONF_OFFSET("min", FR_TYPE_UINT32, 0, fr_slab_config_t, min_elements), .dflt = "10" },
- { FR_CONF_OFFSET("max", FR_TYPE_UINT32, 0, fr_slab_config_t, max_elements), .dflt = "100" },
- { FR_CONF_OFFSET("cleanup_interval", FR_TYPE_TIME_DELTA, 0, fr_slab_config_t, interval), .dflt = "30s" },
+ { FR_CONF_OFFSET("min", fr_slab_config_t, min_elements), .dflt = "10" },
+ { FR_CONF_OFFSET("max", fr_slab_config_t, max_elements), .dflt = "100" },
+ { FR_CONF_OFFSET("cleanup_interval", fr_slab_config_t, interval), .dflt = "30s" },
CONF_PARSER_TERMINATOR
};
conf_parser_t fr_curl_conn_config[] = {
- { FR_CONF_OFFSET("reuse", 0, CONF_FLAG_SUBSECTION, fr_curl_conn_config_t, reuse), .subcs = (void const *) reuse_curl_conn_config },
- { FR_CONF_OFFSET("connect_timeout", FR_TYPE_TIME_DELTA, 0, fr_curl_conn_config_t, connect_timeout), .dflt = "3.0" },
+ { FR_CONF_OFFSET_SUBSECTION("reuse", 0, fr_curl_conn_config_t, reuse, reuse_curl_conn_config) },
+ { FR_CONF_OFFSET("connect_timeout", fr_curl_conn_config_t, connect_timeout), .dflt = "3.0" },
CONF_PARSER_TERMINATOR
};
};
static conf_parser_t const json_format_attr_config[] = {
- { FR_CONF_OFFSET("prefix", FR_TYPE_STRING, 0, fr_json_format_attr_t, prefix) },
+ { FR_CONF_OFFSET("prefix", fr_json_format_attr_t, prefix) },
CONF_PARSER_TERMINATOR
};
static conf_parser_t const json_format_value_config[] = {
- { FR_CONF_OFFSET("single_value_as_array", FR_TYPE_BOOL, 0, fr_json_format_value_t, value_is_always_array), .dflt = "no" },
- { FR_CONF_OFFSET("enum_as_integer", FR_TYPE_BOOL, 0, fr_json_format_value_t, enum_as_int), .dflt = "no" },
- { FR_CONF_OFFSET("always_string", FR_TYPE_BOOL, 0, fr_json_format_value_t, always_string), .dflt = "no" },
+ { FR_CONF_OFFSET("single_value_as_array", fr_json_format_value_t, value_is_always_array), .dflt = "no" },
+ { FR_CONF_OFFSET("enum_as_integer", fr_json_format_value_t, enum_as_int), .dflt = "no" },
+ { FR_CONF_OFFSET("always_string", fr_json_format_value_t, always_string), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
conf_parser_t const fr_json_format_config[] = {
- { FR_CONF_OFFSET("output_mode", FR_TYPE_STRING, 0, fr_json_format_t, output_mode_str), .dflt = "object" },
- { FR_CONF_OFFSET("attribute", 0, CONF_FLAG_SUBSECTION, fr_json_format_t, attr),
- .subcs = (void const *) json_format_attr_config },
- { FR_CONF_OFFSET("value", 0, CONF_FLAG_SUBSECTION, fr_json_format_t, value),
- .subcs = (void const *) json_format_value_config },
+ { FR_CONF_OFFSET("output_mode", fr_json_format_t, output_mode_str), .dflt = "object" },
+ { FR_CONF_OFFSET_SUBSECTION("attribute", 0, fr_json_format_t, attr, json_format_attr_config) },
+ { FR_CONF_OFFSET_SUBSECTION("value", 0, fr_json_format_t, value, json_format_value_config) },
CONF_PARSER_TERMINATOR
};
};
static conf_parser_t const ldap_global_config[] = {
- { FR_CONF_OFFSET("random_file", FR_TYPE_STRING, CONF_FLAG_FILE_EXISTS, fr_libldap_global_config_t, tls_random_file) },
- { FR_CONF_OFFSET("ldap_debug", FR_TYPE_UINT32, 0, fr_libldap_global_config_t, ldap_debug), .dflt = "0x0000" },
+ { FR_CONF_OFFSET_FLAGS("random_file", FR_TYPE_STRING, CONF_FLAG_FILE_EXISTS, fr_libldap_global_config_t, tls_random_file) },
+ { FR_CONF_OFFSET("ldap_debug", fr_libldap_global_config_t, ldap_debug), .dflt = "0x0000" },
CONF_PARSER_TERMINATOR
};
#include <freeradius-devel/ldap/conf.h>
conf_parser_t const fr_ldap_sasl_mech_static[] = {
- { FR_CONF_OFFSET("mech", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY, fr_ldap_sasl_t, mech) },
- { FR_CONF_OFFSET("proxy", FR_TYPE_STRING, 0, fr_ldap_sasl_t, proxy) },
- { FR_CONF_OFFSET("realm", FR_TYPE_STRING, 0, fr_ldap_sasl_t, realm) },
+ { FR_CONF_OFFSET_FLAGS("mech", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY, fr_ldap_sasl_t, mech) },
+ { FR_CONF_OFFSET("proxy", fr_ldap_sasl_t, proxy) },
+ { FR_CONF_OFFSET("realm", fr_ldap_sasl_t, realm) },
CONF_PARSER_TERMINATOR
};
/*
* Deprecated attributes
*/
- { FR_CONF_OFFSET("ca_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_ldap_config_t, tls_ca_file) },
+ { FR_CONF_OFFSET_FLAGS("ca_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_ldap_config_t, tls_ca_file) },
- { FR_CONF_OFFSET("ca_path", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_ldap_config_t, tls_ca_path) },
+ { FR_CONF_OFFSET_FLAGS("ca_path", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_ldap_config_t, tls_ca_path) },
- { FR_CONF_OFFSET("certificate_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_ldap_config_t, tls_certificate_file) },
+ { FR_CONF_OFFSET_FLAGS("certificate_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_ldap_config_t, tls_certificate_file) },
- { FR_CONF_OFFSET("private_key_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_ldap_config_t, tls_private_key_file) },
+ { FR_CONF_OFFSET_FLAGS("private_key_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_ldap_config_t, tls_private_key_file) },
/*
* LDAP Specific TLS attributes
*/
- { FR_CONF_OFFSET("start_tls", FR_TYPE_BOOL, 0, fr_ldap_config_t, start_tls), .dflt = "no" },
+ { FR_CONF_OFFSET("start_tls", fr_ldap_config_t, start_tls), .dflt = "no" },
- { FR_CONF_OFFSET("require_cert", FR_TYPE_STRING, 0, fr_ldap_config_t, tls_require_cert_str) },
+ { FR_CONF_OFFSET("require_cert", fr_ldap_config_t, tls_require_cert_str) },
- { FR_CONF_OFFSET("tls_min_version", FR_TYPE_STRING, 0, fr_ldap_config_t, tls_min_version_str) },
+ { FR_CONF_OFFSET("tls_min_version", fr_ldap_config_t, tls_min_version_str) },
CONF_PARSER_TERMINATOR
};
/*
* Pool config items
*/
- { FR_CONF_OFFSET("chase_referrals", FR_TYPE_BOOL, 0, fr_ldap_config_t, chase_referrals) },
+ { FR_CONF_OFFSET("chase_referrals", fr_ldap_config_t, chase_referrals) },
- { FR_CONF_OFFSET("use_referral_credentials", FR_TYPE_BOOL, 0, fr_ldap_config_t, use_referral_credentials), .dflt = "no" },
+ { FR_CONF_OFFSET("use_referral_credentials", fr_ldap_config_t, use_referral_credentials), .dflt = "no" },
- { FR_CONF_OFFSET("referral_depth", FR_TYPE_UINT16, 0, fr_ldap_config_t, referral_depth), .dflt = "5" },
+ { FR_CONF_OFFSET("referral_depth", fr_ldap_config_t, referral_depth), .dflt = "5" },
- { FR_CONF_OFFSET("rebind", FR_TYPE_BOOL, 0, fr_ldap_config_t, rebind) },
+ { FR_CONF_OFFSET("rebind", fr_ldap_config_t, rebind) },
- { FR_CONF_OFFSET("sasl_secprops", FR_TYPE_STRING, 0, fr_ldap_config_t, sasl_secprops) },
+ { FR_CONF_OFFSET("sasl_secprops", fr_ldap_config_t, sasl_secprops) },
/*
* We use this config option to populate libldap's LDAP_OPT_NETWORK_TIMEOUT -
* timeout on network activity - specifically libldap's initial call to "connect"
* Must be non-zero for async connections to start correctly.
*/
- { FR_CONF_OFFSET("net_timeout", FR_TYPE_TIME_DELTA, 0, fr_ldap_config_t, net_timeout), .dflt = "10" },
+ { FR_CONF_OFFSET("net_timeout", fr_ldap_config_t, net_timeout), .dflt = "10" },
- { FR_CONF_OFFSET("idle", FR_TYPE_TIME_DELTA, 0, fr_ldap_config_t, keepalive_idle), .dflt = "60" },
+ { FR_CONF_OFFSET("idle", fr_ldap_config_t, keepalive_idle), .dflt = "60" },
- { FR_CONF_OFFSET("probes", FR_TYPE_UINT32, 0, fr_ldap_config_t, keepalive_probes), .dflt = "3" },
+ { FR_CONF_OFFSET("probes", fr_ldap_config_t, keepalive_probes), .dflt = "3" },
- { FR_CONF_OFFSET("interval", FR_TYPE_TIME_DELTA, 0, fr_ldap_config_t, keepalive_interval), .dflt = "30" },
+ { FR_CONF_OFFSET("interval", fr_ldap_config_t, keepalive_interval), .dflt = "30" },
- { FR_CONF_OFFSET("dereference", FR_TYPE_STRING, 0, fr_ldap_config_t, dereference_str) },
+ { FR_CONF_OFFSET("dereference", fr_ldap_config_t, dereference_str) },
/* allow server unlimited time for search (server-side limit) */
- { FR_CONF_OFFSET("srv_timelimit", FR_TYPE_TIME_DELTA, 0, fr_ldap_config_t, srv_timelimit), .dflt = "20" },
+ { FR_CONF_OFFSET("srv_timelimit", fr_ldap_config_t, srv_timelimit), .dflt = "20" },
/*
* Instance config items
*/
/* timeout for search results */
- { FR_CONF_OFFSET("res_timeout", FR_TYPE_TIME_DELTA, 0, fr_ldap_config_t, res_timeout), .dflt = "20" },
+ { FR_CONF_OFFSET("res_timeout", fr_ldap_config_t, res_timeout), .dflt = "20" },
- { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, 0, fr_ldap_config_t, idle_timeout), .dflt = "300" },
+ { FR_CONF_OFFSET("idle_timeout", fr_ldap_config_t, idle_timeout), .dflt = "300" },
- { FR_CONF_OFFSET("reconnection_delay", FR_TYPE_TIME_DELTA, 0, fr_ldap_config_t, reconnection_delay), .dflt = "10" },
+ { FR_CONF_OFFSET("reconnection_delay", fr_ldap_config_t, reconnection_delay), .dflt = "10" },
CONF_PARSER_TERMINATOR
};
/*
* Macro for including common LDAP configuration items
*/
-#define FR_LDAP_COMMON_CONF(_conf) { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, _conf, handle_config.port) }, \
- { FR_CONF_OFFSET("identity", FR_TYPE_STRING, 0, _conf, handle_config.admin_identity) }, \
- { FR_CONF_OFFSET("password", FR_TYPE_STRING, CONF_FLAG_SECRET, _conf, handle_config.admin_password) }, \
- { FR_CONF_OFFSET("sasl", 0, CONF_FLAG_SUBSECTION, _conf, handle_config.admin_sasl), .subcs = (void const *) fr_ldap_sasl_mech_static }, \
- { FR_CONF_OFFSET("options", 0, CONF_FLAG_SUBSECTION, _conf, handle_config), .subcs = (void const *) fr_ldap_option_config }, \
- { FR_CONF_OFFSET("tls", 0, CONF_FLAG_SUBSECTION, _conf, handle_config), .subcs = (void const *) fr_ldap_tls_config }
+#define FR_LDAP_COMMON_CONF(_conf) { FR_CONF_OFFSET("port", _conf, handle_config.port) }, \
+ { FR_CONF_OFFSET("identity", _conf, handle_config.admin_identity) }, \
+ { FR_CONF_OFFSET_FLAGS("password", FR_TYPE_STRING, CONF_FLAG_SECRET, _conf, handle_config.admin_password) }, \
+ { FR_CONF_OFFSET_SUBSECTION("sasl", 0, _conf, handle_config.admin_sasl, fr_ldap_sasl_mech_static) }, \
+ { FR_CONF_OFFSET_SUBSECTION("options", 0, _conf, handle_config, fr_ldap_option_config) }, \
+ { FR_CONF_OFFSET_SUBSECTION("tls", 0, _conf, handle_config, fr_ldap_tls_config) }
} fr_redis_conf_t;
#define REDIS_COMMON_CONFIG \
- { FR_CONF_OFFSET("server", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_MULTI, fr_redis_conf_t, hostname) }, \
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, fr_redis_conf_t, port), .dflt = "6379" }, \
- { FR_CONF_OFFSET("database", FR_TYPE_UINT32, 0, fr_redis_conf_t, database), .dflt = "0" }, \
- { FR_CONF_OFFSET("use_tls", FR_TYPE_BOOL, 0, fr_redis_conf_t, use_tls), .dflt = "no" }, \
- { FR_CONF_OFFSET("use_cluster_map", FR_TYPE_BOOL, 0, fr_redis_conf_t, use_cluster_map), .dflt = "yes" }, \
- { FR_CONF_OFFSET("username", FR_TYPE_STRING, 0, fr_redis_conf_t, username) }, \
- { FR_CONF_OFFSET("password", FR_TYPE_STRING, CONF_FLAG_SECRET, fr_redis_conf_t, password) }, \
- { FR_CONF_OFFSET("max_nodes", FR_TYPE_UINT8, 0, fr_redis_conf_t, max_nodes), .dflt = "20" }, \
- { FR_CONF_OFFSET("max_alt", FR_TYPE_UINT32, 0, fr_redis_conf_t, max_alt), .dflt = "3" }, \
- { FR_CONF_OFFSET("max_redirects", FR_TYPE_UINT32, 0, fr_redis_conf_t, max_redirects), .dflt = "2" }
+ { FR_CONF_OFFSET_FLAGS("server", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_MULTI, fr_redis_conf_t, hostname) }, \
+ { FR_CONF_OFFSET("port", fr_redis_conf_t, port), .dflt = "6379" }, \
+ { FR_CONF_OFFSET("database", fr_redis_conf_t, database), .dflt = "0" }, \
+ { FR_CONF_OFFSET("use_tls", fr_redis_conf_t, use_tls), .dflt = "no" }, \
+ { FR_CONF_OFFSET("use_cluster_map", fr_redis_conf_t, use_cluster_map), .dflt = "yes" }, \
+ { FR_CONF_OFFSET("username", fr_redis_conf_t, username) }, \
+ { FR_CONF_OFFSET_FLAGS("password", FR_TYPE_STRING, CONF_FLAG_SECRET, fr_redis_conf_t, password) }, \
+ { FR_CONF_OFFSET("max_nodes", fr_redis_conf_t, max_nodes), .dflt = "20" }, \
+ { FR_CONF_OFFSET("max_alt", fr_redis_conf_t, max_alt), .dflt = "3" }, \
+ { FR_CONF_OFFSET("max_redirects", fr_redis_conf_t, max_redirects), .dflt = "2" }
void fr_redis_version_print(void);
# define FR_CONF_FLAG_CHECK(_type, _flags, _c_type, _ptr_or_offset) _ptr_or_offset
#endif
+#define CONF_CTYPE_TO_FLAGS(_ct) \
+_Generic(&(_ct), \
+ tmpl_t ** : CONF_FLAG_TMPL, \
+ tmpl_t *** : CONF_FLAG_TMPL | CONF_FLAG_MULTI, \
+ xlat_t ** : CONF_FLAG_XLAT, \
+ xlat_t *** : CONF_FLAG_XLAT | CONF_FLAG_MULTI, \
+ fr_ethernet_t * : 0, \
+ fr_ethernet_t ** : CONF_FLAG_MULTI, \
+ fr_ifid_t * : 0, \
+ fr_ifid_t ** : CONF_FLAG_MULTI, \
+ fr_time_t * : 0, \
+ fr_time_t ** : CONF_FLAG_MULTI, \
+ fr_time_delta_t * : 0, \
+ fr_time_delta_t ** : CONF_FLAG_MULTI, \
+ char const ** : 0, \
+ char const *** : CONF_FLAG_MULTI, \
+ bool * : 0, \
+ bool ** : CONF_FLAG_MULTI, \
+ uint8_t const ** : 0, \
+ uint8_t const *** : CONF_FLAG_MULTI, \
+ uint8_t * : 0, \
+ uint8_t ** : CONF_FLAG_MULTI, \
+ uint16_t * : 0, \
+ uint16_t ** : CONF_FLAG_MULTI, \
+ uint32_t * : 0, \
+ uint32_t ** : CONF_FLAG_MULTI, \
+ uint64_t * : 0, \
+ uint64_t ** : CONF_FLAG_MULTI, \
+ int8_t * : 0, \
+ int8_t ** : CONF_FLAG_MULTI, \
+ int16_t * : 0, \
+ int16_t ** : CONF_FLAG_MULTI, \
+ int32_t * : 0, \
+ int32_t ** : CONF_FLAG_MULTI, \
+ int64_t * : 0, \
+ int64_t ** : CONF_FLAG_MULTI, \
+ float * : 0, \
+ float ** : CONF_FLAG_MULTI, \
+ double * : 0, \
+ double ** : CONF_FLAG_MULTI)
+
/** conf_parser_t which parses a single CONF_PAIR, writing the result to a field in a struct
+ *
+ * @param[in] _name of the CONF_PAIR to search for.
+ * @param[in] _struct contaning the field to write the result to.
+ * @param[in] _field to write the result to.
+ */
+# define FR_CONF_OFFSET(_name, _struct, _field) \
+ FR_CONF_OFFSET_FLAGS(_name, \
+ FR_CTYPE_TO_TYPE((((_struct *)NULL)->_field)), \
+ CONF_CTYPE_TO_FLAGS((((_struct *)NULL)->_field)),\
+ _struct, _field)
+
+/** conf_parser_t which parses a single CONF_PAIR, writing the result to a field in a struct
+ *
+ * This variant takes output type and flags manually, instead of determining them automatically.
*
* @param[in] _name of the CONF_PAIR to search for.
* @param[in] _type to parse the CONF_PAIR as.
* @param[in] _struct contaning the field to write the result to.
* @param[in] _field to write the result to.
*/
-# define FR_CONF_OFFSET(_name, _type, _flags, _struct, _field) \
+# define FR_CONF_OFFSET_FLAGS(_name, _type, _flags, _struct, _field) \
.name1 = _name, \
.type = (_type), \
.flags = (_flags), \
* @param[in] _struct where the result was previously written.
* @param[in] _field in the struct where the result was previously written.
*/
-#define FR_CONF_DEPRECATED(_name, _type, _flags, _struct, _field) \
+#define FR_CONF_DEPRECATED(_name, _struct, _field) \
.name1 = _name, \
- .type = (_type ), \
- .flags = (_flags) | CONF_FLAG_DEPRECATED
+ .flags = CONF_FLAG_DEPRECATED
/*
* It's a developer option and should be used carefully.
* Example with #FR_CONF_OFFSET :
@code{.c}
static conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("example", FR_TYPE_STRING | CONF_FLAG_NOT_EMPTY, 0, 0, example_instance_t, example), .dflt = "default_value" },
+ { FR_CONF_OFFSET_FLAGS("example", FR_TYPE_STRING | CONF_FLAG_NOT_EMPTY, 0, 0, example_instance_t, example), .dflt = "default_value" },
CONF_PARSER_TERMINATOR
}
@endcode
static char const *hs_proto = NULL;
static conf_parser_t limit_config[] = {
- { FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, 0, fr_client_t, limit.max_connections), .dflt = "16" },
+ { FR_CONF_OFFSET("max_connections", fr_client_t, limit.max_connections), .dflt = "16" },
- { FR_CONF_OFFSET("lifetime", FR_TYPE_TIME_DELTA, 0, fr_client_t, limit.lifetime), .dflt = "0" },
+ { FR_CONF_OFFSET("lifetime", fr_client_t, limit.lifetime), .dflt = "0" },
- { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, 0, fr_client_t, limit.idle_timeout), .dflt = "30s" },
+ { FR_CONF_OFFSET("idle_timeout", fr_client_t, limit.idle_timeout), .dflt = "30s" },
CONF_PARSER_TERMINATOR
};
{ FR_CONF_POINTER("src_ipaddr", FR_TYPE_STRING, 0, &cl_srcipaddr) },
- { FR_CONF_OFFSET("secret", FR_TYPE_STRING, CONF_FLAG_SECRET, fr_client_t, secret) },
- { FR_CONF_OFFSET("shortname", FR_TYPE_STRING, 0, fr_client_t, shortname) },
+ { FR_CONF_OFFSET_FLAGS("secret", FR_TYPE_STRING, CONF_FLAG_SECRET, fr_client_t, secret) },
+ { FR_CONF_OFFSET("shortname", fr_client_t, shortname) },
- { FR_CONF_OFFSET("nas_type", FR_TYPE_STRING, 0, fr_client_t, nas_type) },
+ { FR_CONF_OFFSET("nas_type", fr_client_t, nas_type) },
- { FR_CONF_OFFSET("track_connections", FR_TYPE_BOOL, 0, fr_client_t, use_connected) },
+ { FR_CONF_OFFSET("track_connections", fr_client_t, use_connected) },
- { FR_CONF_OFFSET("require_message_authenticator", FR_TYPE_BOOL, 0, fr_client_t, message_authenticator) },
+ { FR_CONF_OFFSET("require_message_authenticator", fr_client_t, message_authenticator) },
- { FR_CONF_OFFSET("dedup_authenticator", FR_TYPE_BOOL, 0, fr_client_t, dedup_authenticator) },
+ { FR_CONF_OFFSET("dedup_authenticator", fr_client_t, dedup_authenticator) },
- { FR_CONF_OFFSET("response_window", FR_TYPE_TIME_DELTA, 0, fr_client_t, response_window) },
+ { FR_CONF_OFFSET("response_window", fr_client_t, response_window) },
{ FR_CONF_POINTER("proto", FR_TYPE_STRING, 0, &hs_proto) },
{ FR_CONF_POINTER("limit", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) limit_config },
* @todo - once we allow this, also check that there's only _one_ destination
* which uses syslog_facility.
*/
- { FR_CONF_OFFSET("syslog_facility", FR_TYPE_VOID, 0, main_config_t, syslog_facility), .dflt = "daemon",
+ { FR_CONF_OFFSET_FLAGS("syslog_facility", FR_TYPE_VOID, 0, main_config_t, syslog_facility), .dflt = "daemon",
.func = cf_table_parse_int,
.uctx = &(cf_table_parse_ctx_t){
.table = syslog_facility_table,
},
#endif
{ FR_CONF_POINTER_IS_SET("timestamp", FR_TYPE_BOOL, 0, &log_timestamp) },
- { FR_CONF_OFFSET("file", FR_TYPE_STRING, 0, fr_log_t, file), },
- { FR_CONF_OFFSET("colourise", FR_TYPE_BOOL, 0, fr_log_t, colourise) },
- { FR_CONF_OFFSET("line_number", FR_TYPE_BOOL, 0, fr_log_t, line_number) },
- { FR_CONF_OFFSET("use_utc", FR_TYPE_BOOL, 0, fr_log_t, dates_utc) },
- { FR_CONF_OFFSET("print_level", FR_TYPE_BOOL, 0, fr_log_t, print_level) },
+ { FR_CONF_OFFSET("file", fr_log_t, file), },
+ { FR_CONF_OFFSET("colourise", fr_log_t, colourise) },
+ { FR_CONF_OFFSET("line_number", fr_log_t, line_number) },
+ { FR_CONF_OFFSET("use_utc", fr_log_t, dates_utc) },
+ { FR_CONF_OFFSET("print_level", fr_log_t, print_level) },
CONF_PARSER_TERMINATOR
};
* Log destinations
*/
static const conf_parser_t initial_log_config[] = {
- { FR_CONF_OFFSET("destination", FR_TYPE_STRING, 0, main_config_t, log_dest), .dflt = "files" },
- { FR_CONF_OFFSET("syslog_facility", FR_TYPE_VOID, 0, main_config_t, syslog_facility), .dflt = "daemon",
+ { FR_CONF_OFFSET("destination", main_config_t, log_dest), .dflt = "files" },
+ { FR_CONF_OFFSET_FLAGS("syslog_facility", FR_TYPE_VOID, 0, main_config_t, syslog_facility), .dflt = "daemon",
.func = cf_table_parse_int,
.uctx = &(cf_table_parse_ctx_t){
.table = syslog_facility_table,
.len = &syslog_facility_table_len
}
},
- { FR_CONF_OFFSET("local_state_dir", FR_TYPE_STRING, 0, main_config_t, local_state_dir), .dflt = "${prefix}/var"},
- { FR_CONF_OFFSET("logdir", FR_TYPE_STRING, 0, main_config_t, log_dir), .dflt = "${local_state_dir}/log"},
- { FR_CONF_OFFSET("file", FR_TYPE_STRING, 0, main_config_t, log_file), .dflt = "${logdir}/radius.log" },
- { FR_CONF_OFFSET("suppress_secrets", FR_TYPE_BOOL, 0, main_config_t, suppress_secrets), .dflt = "no" },
+ { FR_CONF_OFFSET("local_state_dir", main_config_t, local_state_dir), .dflt = "${prefix}/var"},
+ { FR_CONF_OFFSET("logdir", main_config_t, log_dir), .dflt = "${local_state_dir}/log"},
+ { FR_CONF_OFFSET("file", main_config_t, log_file), .dflt = "${logdir}/radius.log" },
+ { FR_CONF_OFFSET("suppress_secrets", main_config_t, suppress_secrets), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
* Basic configuration for the server.
*/
static const conf_parser_t lib_dir_on_read_config[] = {
- { FR_CONF_OFFSET("prefix", FR_TYPE_STRING, 0, main_config_t, prefix), .dflt = "/usr/local" },
+ { FR_CONF_OFFSET("prefix", main_config_t, prefix), .dflt = "/usr/local" },
- { FR_CONF_OFFSET("use_utc", FR_TYPE_BOOL, 0, main_config_t, log_dates_utc) },
+ { FR_CONF_OFFSET("use_utc", main_config_t, log_dates_utc) },
{ FR_CONF_OFFSET_IS_SET("timestamp", FR_TYPE_BOOL, 0, main_config_t, log_timestamp) },
- { FR_CONF_OFFSET("libdir", FR_TYPE_STRING, 0, main_config_t, lib_dir), .dflt = "${prefix}/lib",
+ { FR_CONF_OFFSET("libdir", main_config_t, lib_dir), .dflt = "${prefix}/lib",
.on_read = lib_dir_on_read },
CONF_PARSER_TERMINATOR
*
**********************************************************************/
static const conf_parser_t log_config[] = {
- { FR_CONF_OFFSET("colourise", FR_TYPE_BOOL, 0, main_config_t, do_colourise) },
- { FR_CONF_OFFSET("line_number", FR_TYPE_BOOL, 0, main_config_t, log_line_number) },
- { FR_CONF_OFFSET("timestamp", FR_TYPE_BOOL, 0, main_config_t, log_timestamp) },
- { FR_CONF_OFFSET("use_utc", FR_TYPE_BOOL, 0, main_config_t, log_dates_utc) },
+ { FR_CONF_OFFSET("colourise", main_config_t, do_colourise) },
+ { FR_CONF_OFFSET("line_number", main_config_t, log_line_number) },
+ { FR_CONF_OFFSET("timestamp", main_config_t, log_timestamp) },
+ { FR_CONF_OFFSET("use_utc", main_config_t, log_dates_utc) },
CONF_PARSER_TERMINATOR
};
* the config item will *not* get printed out in debug mode, so that no one knows
* it exists.
*/
- { FR_CONF_OFFSET("talloc_pool_size", FR_TYPE_SIZE | FR_TYPE_HIDDEN, 0, main_config_t, talloc_pool_size), .func = talloc_pool_size_parse }, /* DO NOT SET DEFAULT */
- { FR_CONF_OFFSET("talloc_memory_report", FR_TYPE_BOOL | FR_TYPE_HIDDEN, 0, main_config_t, talloc_memory_report) }, /* DO NOT SET DEFAULT */
+ { FR_CONF_OFFSET_FLAGS("talloc_pool_size", FR_TYPE_SIZE | FR_TYPE_HIDDEN, 0, main_config_t, talloc_pool_size), .func = talloc_pool_size_parse }, /* DO NOT SET DEFAULT */
+ { FR_CONF_OFFSET_FLAGS("talloc_memory_report", FR_TYPE_BOOL | FR_TYPE_HIDDEN, 0, main_config_t, talloc_memory_report) }, /* DO NOT SET DEFAULT */
CONF_PARSER_TERMINATOR
};
static const conf_parser_t thread_config[] = {
- { FR_CONF_OFFSET("num_networks", FR_TYPE_UINT32, 0, main_config_t, max_networks), .dflt = STRINGIFY(1),
+ { FR_CONF_OFFSET("num_networks", main_config_t, max_networks), .dflt = STRINGIFY(1),
.func = num_networks_parse },
- { FR_CONF_OFFSET("num_workers", FR_TYPE_UINT32, 0, main_config_t, max_workers), .dflt = STRINGIFY(0),
+ { FR_CONF_OFFSET("num_workers", main_config_t, max_workers), .dflt = STRINGIFY(0),
.func = num_workers_parse, .dflt_func = num_workers_dflt },
- { FR_CONF_OFFSET("stats_interval", FR_TYPE_TIME_DELTA | FR_TYPE_HIDDEN, 0, main_config_t, stats_interval), },
+ { FR_CONF_OFFSET_FLAGS("stats_interval", FR_TYPE_TIME_DELTA | FR_TYPE_HIDDEN, 0, main_config_t, stats_interval), },
#ifdef WITH_TLS
- { FR_CONF_OFFSET("openssl_async_pool_init", FR_TYPE_SIZE, 0, main_config_t, openssl_async_pool_init), .dflt = "64" },
- { FR_CONF_OFFSET("openssl_async_pool_max", FR_TYPE_SIZE, 0, main_config_t, openssl_async_pool_max), .dflt = "1024" },
+ { FR_CONF_OFFSET_FLAGS("openssl_async_pool_init", FR_TYPE_SIZE, 0, main_config_t, openssl_async_pool_init), .dflt = "64" },
+ { FR_CONF_OFFSET_FLAGS("openssl_async_pool_max", FR_TYPE_SIZE, 0, main_config_t, openssl_async_pool_max), .dflt = "1024" },
#endif
CONF_PARSER_TERMINATOR
* Migration configuration.
*/
static const conf_parser_t migrate_config[] = {
- { FR_CONF_OFFSET("rewrite_update", FR_TYPE_BOOL | FR_TYPE_HIDDEN, 0, main_config_t, rewrite_update) },
- { FR_CONF_OFFSET("forbid_update", FR_TYPE_BOOL | FR_TYPE_HIDDEN, 0, main_config_t, forbid_update) },
+ { FR_CONF_OFFSET_FLAGS("rewrite_update", FR_TYPE_BOOL | FR_TYPE_HIDDEN, 0, main_config_t, rewrite_update) },
+ { FR_CONF_OFFSET_FLAGS("forbid_update", FR_TYPE_BOOL | FR_TYPE_HIDDEN, 0, main_config_t, forbid_update) },
CONF_PARSER_TERMINATOR
};
* Migration configuration.
*/
static const conf_parser_t interpret_config[] = {
- { FR_CONF_OFFSET("countup_instructions", FR_TYPE_BOOL | FR_TYPE_HIDDEN, 0, main_config_t, ins_countup) },
- { FR_CONF_OFFSET("max_instructions", FR_TYPE_UINT32 | FR_TYPE_HIDDEN, 0, main_config_t, ins_max) },
+ { FR_CONF_OFFSET_FLAGS("countup_instructions", FR_TYPE_BOOL | FR_TYPE_HIDDEN, 0, main_config_t, ins_countup) },
+ { FR_CONF_OFFSET_FLAGS("max_instructions", FR_TYPE_UINT32 | FR_TYPE_HIDDEN, 0, main_config_t, ins_max) },
CONF_PARSER_TERMINATOR
};
#endif
* hard-coded defines for the locations of the various
* files.
*/
- { FR_CONF_OFFSET("prefix", FR_TYPE_STRING, 0, main_config_t, prefix), .dflt = "/usr/local" },
- { FR_CONF_OFFSET("local_state_dir", FR_TYPE_STRING, 0, main_config_t, local_state_dir), .dflt = "${prefix}/var"},
- { FR_CONF_OFFSET("sbin_dir", FR_TYPE_STRING, 0, main_config_t, sbin_dir), .dflt = "${prefix}/sbin"},
- { FR_CONF_OFFSET("logdir", FR_TYPE_STRING, 0, main_config_t, log_dir), .dflt = "${local_state_dir}/log"},
- { FR_CONF_OFFSET("run_dir", FR_TYPE_STRING, 0, main_config_t, run_dir), .dflt = "${local_state_dir}/run/${name}"},
- { FR_CONF_OFFSET("radacctdir", FR_TYPE_STRING, 0, main_config_t, radacct_dir), .dflt = "${logdir}/radacct" },
- { FR_CONF_OFFSET("panic_action", FR_TYPE_STRING, 0, main_config_t, panic_action) },
- { FR_CONF_OFFSET("reverse_lookups", FR_TYPE_BOOL, 0, main_config_t, reverse_lookups), .dflt = "no", .func = reverse_lookups_parse },
- { FR_CONF_OFFSET("hostname_lookups", FR_TYPE_BOOL, 0, main_config_t, hostname_lookups), .dflt = "yes", .func = hostname_lookups_parse },
- { FR_CONF_OFFSET("max_request_time", FR_TYPE_TIME_DELTA, 0, main_config_t, max_request_time), .dflt = STRINGIFY(MAX_REQUEST_TIME), .func = max_request_time_parse },
- { FR_CONF_OFFSET("pidfile", FR_TYPE_STRING, 0, main_config_t, pid_file), .dflt = "${run_dir}/radiusd.pid"},
-
- { FR_CONF_OFFSET("debug_level", FR_TYPE_UINT32 | FR_TYPE_HIDDEN, 0, main_config_t, debug_level), .dflt = "0" },
- { FR_CONF_OFFSET("max_requests", FR_TYPE_UINT32, 0, main_config_t, max_requests), .dflt = "0" },
+ { FR_CONF_OFFSET("prefix", main_config_t, prefix), .dflt = "/usr/local" },
+ { FR_CONF_OFFSET("local_state_dir", main_config_t, local_state_dir), .dflt = "${prefix}/var"},
+ { FR_CONF_OFFSET("sbin_dir", main_config_t, sbin_dir), .dflt = "${prefix}/sbin"},
+ { FR_CONF_OFFSET("logdir", main_config_t, log_dir), .dflt = "${local_state_dir}/log"},
+ { FR_CONF_OFFSET("run_dir", main_config_t, run_dir), .dflt = "${local_state_dir}/run/${name}"},
+ { FR_CONF_OFFSET("radacctdir", main_config_t, radacct_dir), .dflt = "${logdir}/radacct" },
+ { FR_CONF_OFFSET("panic_action", main_config_t, panic_action) },
+ { FR_CONF_OFFSET("reverse_lookups", main_config_t, reverse_lookups), .dflt = "no", .func = reverse_lookups_parse },
+ { FR_CONF_OFFSET("hostname_lookups", main_config_t, hostname_lookups), .dflt = "yes", .func = hostname_lookups_parse },
+ { FR_CONF_OFFSET("max_request_time", main_config_t, max_request_time), .dflt = STRINGIFY(MAX_REQUEST_TIME), .func = max_request_time_parse },
+ { FR_CONF_OFFSET("pidfile", main_config_t, pid_file), .dflt = "${run_dir}/radiusd.pid"},
+
+ { FR_CONF_OFFSET_FLAGS("debug_level", FR_TYPE_UINT32 | FR_TYPE_HIDDEN, 0, main_config_t, debug_level), .dflt = "0" },
+ { FR_CONF_OFFSET("max_requests", main_config_t, max_requests), .dflt = "0" },
{ FR_CONF_POINTER("log", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) log_config },
{ FR_CONF_OFFSET_IS_SET("user", FR_TYPE_VOID, 0, main_config_t, uid), .func = cf_parse_uid },
{ FR_CONF_OFFSET_IS_SET("group", FR_TYPE_VOID, 0, main_config_t, gid), .func = cf_parse_gid },
#endif
- { FR_CONF_OFFSET("chroot", FR_TYPE_STRING, 0, main_config_t, chroot_dir) },
- { FR_CONF_OFFSET("allow_core_dumps", FR_TYPE_BOOL, 0, main_config_t, allow_core_dumps), .dflt = "no" },
+ { FR_CONF_OFFSET("chroot", main_config_t, chroot_dir) },
+ { FR_CONF_OFFSET("allow_core_dumps", main_config_t, allow_core_dumps), .dflt = "no" },
#ifdef ENABLE_OPENSSL_VERSION_CHECK
- { FR_CONF_OFFSET("allow_vulnerable_openssl", FR_TYPE_STRING, 0, main_config_t, allow_vulnerable_openssl), .dflt = "no" },
+ { FR_CONF_OFFSET("allow_vulnerable_openssl", main_config_t, allow_vulnerable_openssl), .dflt = "no" },
#endif
#ifdef WITH_TLS
static const conf_parser_t switch_users_config[] = {
{ FR_CONF_POINTER("security", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) security_config },
- { FR_CONF_OFFSET("name", FR_TYPE_STRING, 0, main_config_t, name), .func = name_parse }, /* DO NOT SET DEFAULT */
+ { FR_CONF_OFFSET("name", main_config_t, name), .func = name_parse }, /* DO NOT SET DEFAULT */
- { FR_CONF_OFFSET("prefix", FR_TYPE_STRING, 0, main_config_t, prefix), .dflt = "/usr/local" },
- { FR_CONF_OFFSET("local_state_dir", FR_TYPE_STRING, 0, main_config_t, local_state_dir), .dflt = "${prefix}/var"},
+ { FR_CONF_OFFSET("prefix", main_config_t, prefix), .dflt = "/usr/local" },
+ { FR_CONF_OFFSET("local_state_dir", main_config_t, local_state_dir), .dflt = "${prefix}/var"},
- { FR_CONF_OFFSET("run_dir", FR_TYPE_STRING, 0, main_config_t, run_dir), .dflt = "${local_state_dir}/run/${name}"},
+ { FR_CONF_OFFSET("run_dir", main_config_t, run_dir), .dflt = "${local_state_dir}/run/${name}"},
/*
* For backwards compatibility.
*/
#ifdef HAVE_SETUID
- { FR_CONF_DEPRECATED("user", FR_TYPE_VOID, 0, main_config_t, uid) },
- { FR_CONF_DEPRECATED("group", FR_TYPE_VOID, 0, main_config_t, gid) },
+ { FR_CONF_DEPRECATED("user", main_config_t, uid) },
+ { FR_CONF_DEPRECATED("group", main_config_t, gid) },
#endif
- { FR_CONF_DEPRECATED("chroot", FR_TYPE_STRING, 0, main_config_t, NULL) },
- { FR_CONF_DEPRECATED("allow_core_dumps", FR_TYPE_BOOL, 0, main_config_t, NULL) },
+ { FR_CONF_DEPRECATED("chroot", main_config_t, NULL) },
+ { FR_CONF_DEPRECATED("allow_core_dumps", main_config_t, NULL) },
CONF_PARSER_TERMINATOR
};
};
static const conf_parser_t pool_config[] = {
- { FR_CONF_OFFSET("start", FR_TYPE_UINT32, 0, fr_pool_t, start), .dflt = "0" },
- { FR_CONF_OFFSET("min", FR_TYPE_UINT32, 0, fr_pool_t, min), .dflt = "0" },
- { FR_CONF_OFFSET("max", FR_TYPE_UINT32, 0, fr_pool_t, max), .dflt_func = max_dflt },
- { FR_CONF_OFFSET("max_pending", FR_TYPE_UINT32, 0, fr_pool_t, max_pending), .dflt = "0" },
- { FR_CONF_OFFSET("spare", FR_TYPE_UINT32, 0, fr_pool_t, spare), .dflt = "3" },
- { FR_CONF_OFFSET("uses", FR_TYPE_UINT64, 0, fr_pool_t, max_uses), .dflt = "0" },
- { FR_CONF_OFFSET("lifetime", FR_TYPE_TIME_DELTA, 0, fr_pool_t, lifetime), .dflt = "0" },
- { FR_CONF_OFFSET("cleanup_interval", FR_TYPE_TIME_DELTA, 0, fr_pool_t, cleanup_interval), .dflt = "30" },
- { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, 0, fr_pool_t, idle_timeout), .dflt = "60" },
- { FR_CONF_OFFSET("connect_timeout", FR_TYPE_TIME_DELTA, 0, fr_pool_t, connect_timeout), .dflt = "3.0" },
- { FR_CONF_OFFSET("held_trigger_min", FR_TYPE_TIME_DELTA, 0, fr_pool_t, held_trigger_min), .dflt = "0.0" },
- { FR_CONF_OFFSET("held_trigger_max", FR_TYPE_TIME_DELTA, 0, fr_pool_t, held_trigger_max), .dflt = "0.5" },
- { FR_CONF_OFFSET("retry_delay", FR_TYPE_TIME_DELTA, 0, fr_pool_t, retry_delay), .dflt = "1" },
- { FR_CONF_OFFSET("spread", FR_TYPE_BOOL, 0, fr_pool_t, spread), .dflt = "no" },
+ { FR_CONF_OFFSET("start", fr_pool_t, start), .dflt = "0" },
+ { FR_CONF_OFFSET("min", fr_pool_t, min), .dflt = "0" },
+ { FR_CONF_OFFSET("max", fr_pool_t, max), .dflt_func = max_dflt },
+ { FR_CONF_OFFSET("max_pending", fr_pool_t, max_pending), .dflt = "0" },
+ { FR_CONF_OFFSET("spare", fr_pool_t, spare), .dflt = "3" },
+ { FR_CONF_OFFSET("uses", fr_pool_t, max_uses), .dflt = "0" },
+ { FR_CONF_OFFSET("lifetime", fr_pool_t, lifetime), .dflt = "0" },
+ { FR_CONF_OFFSET("cleanup_interval", fr_pool_t, cleanup_interval), .dflt = "30" },
+ { FR_CONF_OFFSET("idle_timeout", fr_pool_t, idle_timeout), .dflt = "60" },
+ { FR_CONF_OFFSET("connect_timeout", fr_pool_t, connect_timeout), .dflt = "3.0" },
+ { FR_CONF_OFFSET("held_trigger_min", fr_pool_t, held_trigger_min), .dflt = "0.0" },
+ { FR_CONF_OFFSET("held_trigger_max", fr_pool_t, held_trigger_max), .dflt = "0.5" },
+ { FR_CONF_OFFSET("retry_delay", fr_pool_t, retry_delay), .dflt = "1" },
+ { FR_CONF_OFFSET("spread", fr_pool_t, spread), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
};
static conf_parser_t const fr_trunk_config_request[] = {
- { FR_CONF_OFFSET("per_connection_max", FR_TYPE_UINT32, 0, fr_trunk_conf_t, max_req_per_conn), .dflt = "2000" },
- { FR_CONF_OFFSET("per_connection_target", FR_TYPE_UINT32, 0, fr_trunk_conf_t, target_req_per_conn), .dflt = "1000" },
- { FR_CONF_OFFSET("free_delay", FR_TYPE_TIME_DELTA, 0, fr_trunk_conf_t, req_cleanup_delay), .dflt = "10.0" },
+ { FR_CONF_OFFSET("per_connection_max", fr_trunk_conf_t, max_req_per_conn), .dflt = "2000" },
+ { FR_CONF_OFFSET("per_connection_target", fr_trunk_conf_t, target_req_per_conn), .dflt = "1000" },
+ { FR_CONF_OFFSET("free_delay", fr_trunk_conf_t, req_cleanup_delay), .dflt = "10.0" },
CONF_PARSER_TERMINATOR
};
static conf_parser_t const fr_trunk_config_connection[] = {
- { FR_CONF_OFFSET("connect_timeout", FR_TYPE_TIME_DELTA, 0, fr_connection_conf_t, connection_timeout), .dflt = "3.0" },
- { FR_CONF_OFFSET("reconnect_delay", FR_TYPE_TIME_DELTA, 0, fr_connection_conf_t, reconnection_delay), .dflt = "1" },
+ { FR_CONF_OFFSET("connect_timeout", fr_connection_conf_t, connection_timeout), .dflt = "3.0" },
+ { FR_CONF_OFFSET("reconnect_delay", fr_connection_conf_t, reconnection_delay), .dflt = "1" },
CONF_PARSER_TERMINATOR
};
#ifndef TRUNK_TESTS
conf_parser_t const fr_trunk_config[] = {
- { FR_CONF_OFFSET("start", FR_TYPE_UINT16, 0, fr_trunk_conf_t, start), .dflt = "5" },
- { FR_CONF_OFFSET("min", FR_TYPE_UINT16, 0, fr_trunk_conf_t, min), .dflt = "1" },
- { FR_CONF_OFFSET("max", FR_TYPE_UINT16, 0, fr_trunk_conf_t, max), .dflt = "5" },
- { FR_CONF_OFFSET("connecting", FR_TYPE_UINT16, 0, fr_trunk_conf_t, connecting), .dflt = "2" },
- { FR_CONF_OFFSET("uses", FR_TYPE_UINT64, 0, fr_trunk_conf_t, max_uses), .dflt = "0" },
- { FR_CONF_OFFSET("lifetime", FR_TYPE_TIME_DELTA, 0, fr_trunk_conf_t, lifetime), .dflt = "0" },
+ { FR_CONF_OFFSET("start", fr_trunk_conf_t, start), .dflt = "5" },
+ { FR_CONF_OFFSET("min", fr_trunk_conf_t, min), .dflt = "1" },
+ { FR_CONF_OFFSET("max", fr_trunk_conf_t, max), .dflt = "5" },
+ { FR_CONF_OFFSET("connecting", fr_trunk_conf_t, connecting), .dflt = "2" },
+ { FR_CONF_OFFSET("uses", fr_trunk_conf_t, max_uses), .dflt = "0" },
+ { FR_CONF_OFFSET("lifetime", fr_trunk_conf_t, lifetime), .dflt = "0" },
- { FR_CONF_OFFSET("open_delay", FR_TYPE_TIME_DELTA, 0, fr_trunk_conf_t, open_delay), .dflt = "0.2" },
- { FR_CONF_OFFSET("close_delay", FR_TYPE_TIME_DELTA, 0, fr_trunk_conf_t, close_delay), .dflt = "10.0" },
+ { FR_CONF_OFFSET("open_delay", fr_trunk_conf_t, open_delay), .dflt = "0.2" },
+ { FR_CONF_OFFSET("close_delay", fr_trunk_conf_t, close_delay), .dflt = "10.0" },
- { FR_CONF_OFFSET("manage_interval", FR_TYPE_TIME_DELTA, 0, fr_trunk_conf_t, manage_interval), .dflt = "0.2" },
+ { FR_CONF_OFFSET("manage_interval", fr_trunk_conf_t, manage_interval), .dflt = "0.2" },
- { FR_CONF_OFFSET("connection", 0, CONF_FLAG_SUBSECTION, fr_trunk_conf_t, conn_conf), .subcs = (void const *) fr_trunk_config_connection, .subcs_size = sizeof(fr_trunk_config_connection) },
+ { FR_CONF_OFFSET_SUBSECTION("connection", 0, fr_trunk_conf_t, conn_conf, fr_trunk_config_connection), .subcs_size = sizeof(fr_trunk_config_connection) },
{ FR_CONF_POINTER("request", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) fr_trunk_config_request },
CONF_PARSER_TERMINATOR
static int server_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, UNUSED conf_parser_t const *rule);
static const conf_parser_t server_on_read_config[] = {
- { FR_CONF_OFFSET("namespace", FR_TYPE_VOID, CONF_FLAG_REQUIRED, fr_virtual_server_t, process_mi),
+ { FR_CONF_OFFSET_FLAGS("namespace", FR_TYPE_VOID, CONF_FLAG_REQUIRED, fr_virtual_server_t, process_mi),
.on_read = namespace_on_read },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t server_config[] = {
- { FR_CONF_OFFSET("namespace", FR_TYPE_VOID, CONF_FLAG_REQUIRED, fr_virtual_server_t, process_mi),
+ { FR_CONF_OFFSET_FLAGS("namespace", FR_TYPE_VOID, CONF_FLAG_REQUIRED, fr_virtual_server_t, process_mi),
.func = namespace_parse },
- { FR_CONF_OFFSET("listen", 0, CONF_FLAG_SUBSECTION | CONF_FLAG_OK_MISSING | CONF_FLAG_MULTI,
+ { FR_CONF_OFFSET_FLAGS("listen", 0, CONF_FLAG_SUBSECTION | CONF_FLAG_OK_MISSING | CONF_FLAG_MULTI,
fr_virtual_server_t, listeners),
.name2 = CF_IDENT_ANY,
.subcs_size = sizeof(fr_virtual_listen_t), .subcs_type = "fr_virtual_listen_t",
static size_t verify_mode_table_len = NUM_ELEMENTS(verify_mode_table);
static conf_parser_t tls_cache_config[] = {
- { FR_CONF_OFFSET("mode", FR_TYPE_UINT32, 0, fr_tls_cache_conf_t, mode),
+ { FR_CONF_OFFSET("mode", fr_tls_cache_conf_t, mode),
.func = tls_conf_parse_cache_mode,
.uctx = &(cf_table_parse_ctx_t){
.table = cache_mode_table,
.len = &cache_mode_table_len
},
.dflt = "auto" },
- { FR_CONF_OFFSET("name", FR_TYPE_VOID, CONF_FLAG_TMPL, fr_tls_cache_conf_t, id_name),
+ { FR_CONF_OFFSET("name", fr_tls_cache_conf_t, id_name),
.dflt = "%{EAP-Type}%interpreter(server)", .quote = T_DOUBLE_QUOTED_STRING },
- { FR_CONF_OFFSET("lifetime", FR_TYPE_TIME_DELTA, 0, fr_tls_cache_conf_t, lifetime), .dflt = "1d" },
+ { FR_CONF_OFFSET("lifetime", fr_tls_cache_conf_t, lifetime), .dflt = "1d" },
#if OPENSSL_VERSION_NUMBER >= 0x10100000L
- { FR_CONF_OFFSET("require_extended_master_secret", FR_TYPE_BOOL, 0, fr_tls_cache_conf_t, require_extms), .dflt = "yes" },
- { FR_CONF_OFFSET("require_perfect_forward_secrecy", FR_TYPE_BOOL, 0, fr_tls_cache_conf_t, require_pfs), .dflt = "no" },
+ { FR_CONF_OFFSET("require_extended_master_secret", fr_tls_cache_conf_t, require_extms), .dflt = "yes" },
+ { FR_CONF_OFFSET("require_perfect_forward_secrecy", fr_tls_cache_conf_t, require_pfs), .dflt = "no" },
#endif
- { FR_CONF_OFFSET("session_ticket_key", FR_TYPE_OCTETS, 0, fr_tls_cache_conf_t, session_ticket_key) },
+ { FR_CONF_OFFSET("session_ticket_key", fr_tls_cache_conf_t, session_ticket_key) },
/*
* Deprecated
*/
- { FR_CONF_DEPRECATED("enable", FR_TYPE_BOOL, 0, fr_tls_cache_conf_t, NULL) },
- { FR_CONF_DEPRECATED("max_entries", FR_TYPE_UINT32, 0, fr_tls_cache_conf_t, NULL) },
- { FR_CONF_DEPRECATED("persist_dir", FR_TYPE_STRING, 0, fr_tls_cache_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("enable", fr_tls_cache_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("max_entries", fr_tls_cache_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("persist_dir", fr_tls_cache_conf_t, NULL) },
CONF_PARSER_TERMINATOR
};
static conf_parser_t tls_chain_config[] = {
- { FR_CONF_OFFSET("format", FR_TYPE_VOID, 0, fr_tls_chain_conf_t, file_format),
+ { FR_CONF_OFFSET_FLAGS("format", FR_TYPE_VOID, 0, fr_tls_chain_conf_t, file_format),
.func = cf_table_parse_int,
.uctx = &(cf_table_parse_ctx_t){
.table = certificate_format_table,
.len = &certificate_format_table_len
},
.dflt = "pem" },
- { FR_CONF_OFFSET("certificate_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_FILE_EXISTS | CONF_FLAG_REQUIRED, fr_tls_chain_conf_t, certificate_file) },
- { FR_CONF_OFFSET("private_key_password", FR_TYPE_STRING, CONF_FLAG_SECRET, fr_tls_chain_conf_t, password) },
- { FR_CONF_OFFSET("private_key_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_FILE_EXISTS | CONF_FLAG_REQUIRED, fr_tls_chain_conf_t, private_key_file) },
+ { FR_CONF_OFFSET_FLAGS("certificate_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_FILE_EXISTS | CONF_FLAG_REQUIRED, fr_tls_chain_conf_t, certificate_file) },
+ { FR_CONF_OFFSET_FLAGS("private_key_password", FR_TYPE_STRING, CONF_FLAG_SECRET, fr_tls_chain_conf_t, password) },
+ { FR_CONF_OFFSET_FLAGS("private_key_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_FILE_EXISTS | CONF_FLAG_REQUIRED, fr_tls_chain_conf_t, private_key_file) },
- { FR_CONF_OFFSET("ca_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_MULTI, fr_tls_chain_conf_t, ca_files) },
+ { FR_CONF_OFFSET_FLAGS("ca_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_MULTI, fr_tls_chain_conf_t, ca_files) },
- { FR_CONF_OFFSET("verify_mode", FR_TYPE_VOID, 0, fr_tls_chain_conf_t, verify_mode),
+ { FR_CONF_OFFSET_FLAGS("verify_mode", FR_TYPE_VOID, 0, fr_tls_chain_conf_t, verify_mode),
.func = cf_table_parse_int,
.uctx = &(cf_table_parse_ctx_t){
.table = chain_verify_mode_table,
.len = &chain_verify_mode_table_len
},
.dflt = "hard" },
- { FR_CONF_OFFSET("include_root_ca", FR_TYPE_BOOL, 0, fr_tls_chain_conf_t, include_root_ca), .dflt = "no" },
+ { FR_CONF_OFFSET("include_root_ca", fr_tls_chain_conf_t, include_root_ca), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
static conf_parser_t tls_verify_config[] = {
- { FR_CONF_OFFSET("mode", FR_TYPE_VOID, 0, fr_tls_verify_conf_t, mode),
+ { FR_CONF_OFFSET_FLAGS("mode", FR_TYPE_VOID, 0, fr_tls_verify_conf_t, mode),
.func = cf_table_parse_int,
.uctx = &(cf_table_parse_ctx_t){
.table = verify_mode_table,
.len = &verify_mode_table_len
},
.dflt = "all" },
- { FR_CONF_OFFSET("attribute_mode", FR_TYPE_VOID, 0, fr_tls_verify_conf_t, attribute_mode),
+ { FR_CONF_OFFSET_FLAGS("attribute_mode", FR_TYPE_VOID, 0, fr_tls_verify_conf_t, attribute_mode),
.func = cf_table_parse_int,
.uctx = &(cf_table_parse_ctx_t){
.table = verify_mode_table,
.len = &verify_mode_table_len
},
.dflt = "client-and-issuer" },
- { FR_CONF_OFFSET("check_crl", FR_TYPE_BOOL, 0, fr_tls_verify_conf_t, check_crl), .dflt = "no" },
- { FR_CONF_OFFSET("allow_expired_crl", FR_TYPE_BOOL, 0, fr_tls_verify_conf_t, allow_expired_crl) },
- { FR_CONF_OFFSET("allow_not_yet_valid_crl", FR_TYPE_BOOL, 0, fr_tls_verify_conf_t, allow_not_yet_valid_crl) },
+ { FR_CONF_OFFSET("check_crl", fr_tls_verify_conf_t, check_crl), .dflt = "no" },
+ { FR_CONF_OFFSET("allow_expired_crl", fr_tls_verify_conf_t, allow_expired_crl) },
+ { FR_CONF_OFFSET("allow_not_yet_valid_crl", fr_tls_verify_conf_t, allow_not_yet_valid_crl) },
CONF_PARSER_TERMINATOR
};
conf_parser_t fr_tls_server_config[] = {
- { FR_CONF_OFFSET("virtual_server", FR_TYPE_VOID, 0, fr_tls_conf_t, virtual_server), .func = virtual_server_cf_parse },
+ { FR_CONF_OFFSET_FLAGS("virtual_server", FR_TYPE_VOID, 0, fr_tls_conf_t, virtual_server), .func = virtual_server_cf_parse },
- { FR_CONF_OFFSET("chain", 0, CONF_FLAG_SUBSECTION | CONF_FLAG_MULTI, fr_tls_conf_t, chains),
- .subcs_size = sizeof(fr_tls_chain_conf_t), .subcs_type = "fr_tls_chain_conf_t",
- .subcs = tls_chain_config, .name2 = CF_IDENT_ANY },
+ { FR_CONF_OFFSET_SUBSECTION("chain", CONF_FLAG_MULTI, fr_tls_conf_t, chains, tls_chain_config),
+ .subcs_size = sizeof(fr_tls_chain_conf_t), .subcs_type = "fr_tls_chain_conf_t", .name2 = CF_IDENT_ANY },
- { FR_CONF_DEPRECATED("pem_file_type", FR_TYPE_BOOL, 0, fr_tls_conf_t, NULL) },
- { FR_CONF_DEPRECATED("certificate_file", FR_TYPE_STRING, 0, fr_tls_conf_t, NULL) },
- { FR_CONF_DEPRECATED("private_key_password", FR_TYPE_STRING, 0, fr_tls_conf_t, NULL) },
- { FR_CONF_DEPRECATED("private_key_file", FR_TYPE_STRING, 0, fr_tls_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("pem_file_type", fr_tls_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("certificate_file", fr_tls_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("private_key_password", fr_tls_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("private_key_file", fr_tls_conf_t, NULL) },
- { FR_CONF_OFFSET("verify_depth", FR_TYPE_UINT32, 0, fr_tls_conf_t, verify_depth), .dflt = "0" },
- { FR_CONF_OFFSET("ca_path", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_tls_conf_t, ca_path) },
- { FR_CONF_OFFSET("ca_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_tls_conf_t, ca_file) },
+ { FR_CONF_OFFSET("verify_depth", fr_tls_conf_t, verify_depth), .dflt = "0" },
+ { FR_CONF_OFFSET_FLAGS("ca_path", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_tls_conf_t, ca_path) },
+ { FR_CONF_OFFSET_FLAGS("ca_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_tls_conf_t, ca_file) },
#ifdef PSK_MAX_IDENTITY_LEN
- { FR_CONF_OFFSET("psk_identity", FR_TYPE_STRING, 0, fr_tls_conf_t, psk_identity) },
- { FR_CONF_OFFSET("psk_hexphrase", FR_TYPE_STRING, CONF_FLAG_SECRET, fr_tls_conf_t, psk_password) },
- { FR_CONF_OFFSET("psk_query", FR_TYPE_STRING, 0, fr_tls_conf_t, psk_query) },
+ { FR_CONF_OFFSET("psk_identity", fr_tls_conf_t, psk_identity) },
+ { FR_CONF_OFFSET_FLAGS("psk_hexphrase", FR_TYPE_STRING, CONF_FLAG_SECRET, fr_tls_conf_t, psk_password) },
+ { FR_CONF_OFFSET("psk_query", fr_tls_conf_t, psk_query) },
#endif
- { FR_CONF_OFFSET("keylog_file", FR_TYPE_STRING, 0, fr_tls_conf_t, keylog_file) },
+ { FR_CONF_OFFSET("keylog_file", fr_tls_conf_t, keylog_file) },
- { FR_CONF_OFFSET("dh_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_tls_conf_t, dh_file) },
- { FR_CONF_OFFSET("fragment_size", FR_TYPE_UINT32, 0, fr_tls_conf_t, fragment_size), .dflt = "1024" },
- { FR_CONF_OFFSET("padding", FR_TYPE_UINT32, 0, fr_tls_conf_t, padding_block_size), },
+ { FR_CONF_OFFSET_FLAGS("dh_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_tls_conf_t, dh_file) },
+ { FR_CONF_OFFSET("fragment_size", fr_tls_conf_t, fragment_size), .dflt = "1024" },
+ { FR_CONF_OFFSET("padding", fr_tls_conf_t, padding_block_size), },
- { FR_CONF_OFFSET("disable_single_dh_use", FR_TYPE_BOOL, 0, fr_tls_conf_t, disable_single_dh_use) },
+ { FR_CONF_OFFSET("disable_single_dh_use", fr_tls_conf_t, disable_single_dh_use) },
- { FR_CONF_OFFSET("cipher_list", FR_TYPE_STRING, 0, fr_tls_conf_t, cipher_list) },
- { FR_CONF_OFFSET("cipher_server_preference", FR_TYPE_BOOL, 0, fr_tls_conf_t, cipher_server_preference), .dflt = "yes" },
+ { FR_CONF_OFFSET("cipher_list", fr_tls_conf_t, cipher_list) },
+ { FR_CONF_OFFSET("cipher_server_preference", fr_tls_conf_t, cipher_server_preference), .dflt = "yes" },
#ifdef SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS
- { FR_CONF_OFFSET("allow_renegotiation", FR_TYPE_BOOL, 0, fr_tls_conf_t, allow_renegotiation), .dflt = "no" },
+ { FR_CONF_OFFSET("allow_renegotiation", fr_tls_conf_t, allow_renegotiation), .dflt = "no" },
#endif
#ifndef OPENSSL_NO_ECDH
- { FR_CONF_OFFSET("ecdh_curve", FR_TYPE_STRING, 0, fr_tls_conf_t, ecdh_curve), .dflt = "prime256v1" },
+ { FR_CONF_OFFSET("ecdh_curve", fr_tls_conf_t, ecdh_curve), .dflt = "prime256v1" },
#endif
- { FR_CONF_OFFSET("tls_max_version", FR_TYPE_FLOAT32, 0, fr_tls_conf_t, tls_max_version) },
+ { FR_CONF_OFFSET("tls_max_version", fr_tls_conf_t, tls_max_version) },
- { FR_CONF_OFFSET("tls_min_version", FR_TYPE_FLOAT32, 0, fr_tls_conf_t, tls_min_version), .dflt = "1.2" },
+ { FR_CONF_OFFSET("tls_min_version", fr_tls_conf_t, tls_min_version), .dflt = "1.2" },
- { FR_CONF_OFFSET("session", 0, CONF_FLAG_SUBSECTION, fr_tls_conf_t, cache), .subcs = (void const *) tls_cache_config },
+ { FR_CONF_OFFSET_SUBSECTION("session", 0, fr_tls_conf_t, cache, tls_cache_config) },
- { FR_CONF_OFFSET("verify", 0, CONF_FLAG_SUBSECTION, fr_tls_conf_t, verify), .subcs = (void const *) tls_verify_config },
+ { FR_CONF_OFFSET_SUBSECTION("verify", 0, fr_tls_conf_t, verify, tls_verify_config) },
- { FR_CONF_DEPRECATED("check_cert_issuer", FR_TYPE_STRING, 0, fr_tls_conf_t, check_cert_issuer) },
- { FR_CONF_DEPRECATED("check_cert_cn", FR_TYPE_STRING, 0, fr_tls_conf_t, check_cert_cn) },
+ { FR_CONF_DEPRECATED("check_cert_issuer", fr_tls_conf_t, check_cert_issuer) },
+ { FR_CONF_DEPRECATED("check_cert_cn", fr_tls_conf_t, check_cert_cn) },
CONF_PARSER_TERMINATOR
};
conf_parser_t fr_tls_client_config[] = {
- { FR_CONF_OFFSET("chain", 0, CONF_FLAG_SUBSECTION | CONF_FLAG_OK_MISSING | CONF_FLAG_MULTI, fr_tls_conf_t, chains),
- .subcs_size = sizeof(fr_tls_chain_conf_t), .subcs_type = "fr_tls_chain_conf_t",
- .subcs = tls_chain_config },
+ { FR_CONF_OFFSET_SUBSECTION("chain", CONF_FLAG_OK_MISSING | CONF_FLAG_MULTI, fr_tls_conf_t, chains, tls_chain_config),
+ .subcs_size = sizeof(fr_tls_chain_conf_t), .subcs_type = "fr_tls_chain_conf_t" },
- { FR_CONF_DEPRECATED("pem_file_type", FR_TYPE_BOOL, 0, fr_tls_conf_t, NULL) },
- { FR_CONF_DEPRECATED("certificate_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_tls_conf_t, NULL) },
- { FR_CONF_DEPRECATED("private_key_password", FR_TYPE_STRING, CONF_FLAG_SECRET, fr_tls_conf_t, NULL) },
- { FR_CONF_DEPRECATED("private_key_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_tls_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("pem_file_type", fr_tls_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("certificate_file", fr_tls_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("private_key_password", fr_tls_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("private_key_file", fr_tls_conf_t, NULL) },
#ifdef PSK_MAX_IDENTITY_LEN
- { FR_CONF_OFFSET("psk_identity", FR_TYPE_STRING, 0, fr_tls_conf_t, psk_identity) },
- { FR_CONF_OFFSET("psk_hexphrase", FR_TYPE_STRING, CONF_FLAG_SECRET, fr_tls_conf_t, psk_password) },
+ { FR_CONF_OFFSET("psk_identity", fr_tls_conf_t, psk_identity) },
+ { FR_CONF_OFFSET_FLAGS("psk_hexphrase", FR_TYPE_STRING, CONF_FLAG_SECRET, fr_tls_conf_t, psk_password) },
#endif
- { FR_CONF_OFFSET("keylog_file", FR_TYPE_STRING, 0, fr_tls_conf_t, keylog_file) },
+ { FR_CONF_OFFSET("keylog_file", fr_tls_conf_t, keylog_file) },
- { FR_CONF_OFFSET("verify_depth", FR_TYPE_UINT32, 0, fr_tls_conf_t, verify_depth), .dflt = "0" },
- { FR_CONF_OFFSET("ca_path", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_tls_conf_t, ca_path) },
+ { FR_CONF_OFFSET("verify_depth", fr_tls_conf_t, verify_depth), .dflt = "0" },
+ { FR_CONF_OFFSET_FLAGS("ca_path", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_tls_conf_t, ca_path) },
- { FR_CONF_OFFSET("ca_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_tls_conf_t, ca_file) },
- { FR_CONF_OFFSET("dh_file", FR_TYPE_STRING, 0, fr_tls_conf_t, dh_file) },
- { FR_CONF_OFFSET("random_file", FR_TYPE_STRING, 0, fr_tls_conf_t, random_file) },
- { FR_CONF_OFFSET("fragment_size", FR_TYPE_UINT32, 0, fr_tls_conf_t, fragment_size), .dflt = "1024" },
+ { FR_CONF_OFFSET_FLAGS("ca_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_tls_conf_t, ca_file) },
+ { FR_CONF_OFFSET("dh_file", fr_tls_conf_t, dh_file) },
+ { FR_CONF_OFFSET("random_file", fr_tls_conf_t, random_file) },
+ { FR_CONF_OFFSET("fragment_size", fr_tls_conf_t, fragment_size), .dflt = "1024" },
- { FR_CONF_OFFSET("cipher_list", FR_TYPE_STRING, 0, fr_tls_conf_t, cipher_list) },
+ { FR_CONF_OFFSET("cipher_list", fr_tls_conf_t, cipher_list) },
#ifndef OPENSSL_NO_ECDH
- { FR_CONF_OFFSET("ecdh_curve", FR_TYPE_STRING, 0, fr_tls_conf_t, ecdh_curve), .dflt = "prime256v1" },
+ { FR_CONF_OFFSET("ecdh_curve", fr_tls_conf_t, ecdh_curve), .dflt = "prime256v1" },
#endif
- { FR_CONF_OFFSET("tls_max_version", FR_TYPE_FLOAT32, 0, fr_tls_conf_t, tls_max_version) },
+ { FR_CONF_OFFSET("tls_max_version", fr_tls_conf_t, tls_max_version) },
- { FR_CONF_OFFSET("tls_min_version", FR_TYPE_FLOAT32, 0, fr_tls_conf_t, tls_min_version), .dflt = "1.2" },
+ { FR_CONF_OFFSET("tls_min_version", fr_tls_conf_t, tls_min_version), .dflt = "1.2" },
- { FR_CONF_DEPRECATED("check_cert_issuer", FR_TYPE_STRING, 0, fr_tls_conf_t, check_cert_issuer) },
- { FR_CONF_DEPRECATED("check_cert_cn", FR_TYPE_STRING, 0, fr_tls_conf_t, check_cert_cn) },
+ { FR_CONF_DEPRECATED("check_cert_issuer", fr_tls_conf_t, check_cert_issuer) },
+ { FR_CONF_DEPRECATED("check_cert_cn", fr_tls_conf_t, check_cert_cn) },
CONF_PARSER_TERMINATOR
};
/** conf_parser_t entries to populate user configurable slab values
*/
#define FR_SLAB_CONFIG_conf_parser_t \
- { FR_CONF_OFFSET("min", FR_TYPE_UINT32, 0, fr_slab_config_t, min_elements), .dflt = "10" }, \
- { FR_CONF_OFFSET("max", FR_TYPE_UINT32, 0, fr_slab_config_t, max_elements), .dflt = "100" }, \
- { FR_CONF_OFFSET("cleanup_interval", FR_TYPE_TIME_DELTA, 0, fr_slab_config_t, interval), .dflt = "30s" }, \
+ { FR_CONF_OFFSET("min", fr_slab_config_t, min_elements), .dflt = "10" }, \
+ { FR_CONF_OFFSET("max", fr_slab_config_t, max_elements), .dflt = "100" }, \
+ { FR_CONF_OFFSET("cleanup_interval", fr_slab_config_t, interval), .dflt = "30s" }, \
/** Tuneable parameters for slabs
*/
uint32_t ** : FR_TYPE_UINT32, \
uint64_t * : FR_TYPE_UINT64, \
uint64_t ** : FR_TYPE_UINT64, \
- int8_t * : FR_TYPE_INT8, \
+ int8_t * : FR_TYPE_INT8, \
int8_t ** : FR_TYPE_INT8, \
int16_t * : FR_TYPE_INT16, \
int16_t ** : FR_TYPE_INT16, \
float * : FR_TYPE_FLOAT32, \
float ** : FR_TYPE_FLOAT32, \
double * : FR_TYPE_FLOAT64, \
- double ** : FR_TYPE_FLOAT64)
+ double ** : FR_TYPE_FLOAT64, \
+ default : FR_TYPE_VOID )
extern fr_table_num_ordered_t const fr_type_table[];
extern size_t fr_type_table_len;
*
*/
static conf_parser_t const proto_arp_config[] = {
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_arp_t, num_messages) } ,
+ { FR_CONF_OFFSET("num_messages", proto_arp_t, num_messages) } ,
- { FR_CONF_OFFSET("active", FR_TYPE_BOOL, 0, proto_arp_t, active), .dflt = "false" } ,
+ { FR_CONF_OFFSET("active", proto_arp_t, active), .dflt = "false" } ,
CONF_PARSER_TERMINATOR
};
*
*/
static conf_parser_t const arp_listen_config[] = {
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY, proto_arp_ethernet_t,
+ { FR_CONF_OFFSET_FLAGS("interface", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY, proto_arp_ethernet_t,
interface), .dflt = "eth0" },
- { FR_CONF_OFFSET("filter", FR_TYPE_STRING, 0, proto_arp_ethernet_t, filter) },
+ { FR_CONF_OFFSET("filter", proto_arp_ethernet_t, filter) },
CONF_PARSER_TERMINATOR
};
*
*/
static conf_parser_t const proto_bfd_config[] = {
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_bfd_t, io.submodule),
+ { FR_CONF_OFFSET_FLAGS("transport", FR_TYPE_VOID, 0, proto_bfd_t, io.submodule),
.func = transport_parse },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t peer_config[] = {
- { FR_CONF_OFFSET("min_transmit_interval", FR_TYPE_TIME_DELTA, 0, bfd_session_t, desired_min_tx_interval ) },
- { FR_CONF_OFFSET("min_receive_interval", FR_TYPE_TIME_DELTA, 0, bfd_session_t, required_min_rx_interval ) },
- { FR_CONF_OFFSET("max_timeouts", FR_TYPE_UINT32, 0, bfd_session_t, detect_multi ) },
- { FR_CONF_OFFSET("demand", FR_TYPE_BOOL, 0, bfd_session_t, demand_mode ) },
+ { FR_CONF_OFFSET("min_transmit_interval", bfd_session_t, desired_min_tx_interval ) },
+ { FR_CONF_OFFSET("min_receive_interval", bfd_session_t, required_min_rx_interval ) },
+ { FR_CONF_OFFSET("max_timeouts", bfd_session_t, detect_multi ) },
+ { FR_CONF_OFFSET("demand", bfd_session_t, demand_mode ) },
- { FR_CONF_OFFSET("auth_type", FR_TYPE_VOID, 0, bfd_session_t, auth_type ),
+ { FR_CONF_OFFSET_FLAGS("auth_type", FR_TYPE_VOID, 0, bfd_session_t, auth_type ),
.func = auth_type_parse },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, bfd_session_t, port ) },
+ { FR_CONF_OFFSET("port", bfd_session_t, port ) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t networks_config[] = {
- { FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_bfd_udp_t, allow) },
- { FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_bfd_udp_t, deny) },
+ { FR_CONF_OFFSET_FLAGS("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_bfd_udp_t, allow) },
+ { FR_CONF_OFFSET_FLAGS("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_bfd_udp_t, deny) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t udp_listen_config[] = {
- { FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_bfd_udp_t, ipaddr) },
- { FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, 0, proto_bfd_udp_t, ipaddr) },
- { FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, 0, proto_bfd_udp_t, ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_bfd_udp_t, ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipv4addr", FR_TYPE_IPV4_ADDR, 0, proto_bfd_udp_t, ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipv6addr", FR_TYPE_IPV6_ADDR, 0, proto_bfd_udp_t, ipaddr) },
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, proto_bfd_udp_t, interface) },
- { FR_CONF_OFFSET("port_name", FR_TYPE_STRING, 0, proto_bfd_udp_t, port_name) },
+ { FR_CONF_OFFSET("interface", proto_bfd_udp_t, interface) },
+ { FR_CONF_OFFSET("port_name", proto_bfd_udp_t, port_name) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, proto_bfd_udp_t, port) },
+ { FR_CONF_OFFSET("port", proto_bfd_udp_t, port) },
- { FR_CONF_OFFSET("ttl", FR_TYPE_UINT8, 0, proto_bfd_udp_t, ttl), .dflt = "255" },
+ { FR_CONF_OFFSET("ttl", proto_bfd_udp_t, ttl), .dflt = "255" },
- { FR_CONF_OFFSET("only_state_changes", FR_TYPE_BOOL, 0, proto_bfd_udp_t, only_state_changes), .dflt = "yes" },
+ { FR_CONF_OFFSET("only_state_changes", proto_bfd_udp_t, only_state_changes), .dflt = "yes" },
{ FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, proto_bfd_udp_t, recv_buff) },
{ FR_CONF_OFFSET_IS_SET("send_buff", FR_TYPE_UINT32, 0, proto_bfd_udp_t, send_buff) },
-// { FR_CONF_OFFSET("dynamic_clients", FR_TYPE_BOOL, 0, proto_bfd_udp_t, dynamic_clients) } ,
+// { FR_CONF_OFFSET("dynamic_clients", proto_bfd_udp_t, dynamic_clients) } ,
{ FR_CONF_POINTER("networks", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) networks_config },
CONF_PARSER_TERMINATOR
static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
static conf_parser_t const limit_config[] = {
- { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, 0, proto_control_t, io.idle_timeout), .dflt = "30.0" } ,
- { FR_CONF_OFFSET("nak_lifetime", FR_TYPE_TIME_DELTA, 0, proto_control_t, io.nak_lifetime), .dflt = "30.0" } ,
+ { FR_CONF_OFFSET("idle_timeout", proto_control_t, io.idle_timeout), .dflt = "30.0" } ,
+ { FR_CONF_OFFSET("nak_lifetime", proto_control_t, io.nak_lifetime), .dflt = "30.0" } ,
- { FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, 0, proto_control_t, io.max_connections), .dflt = "1024" } ,
- { FR_CONF_OFFSET("max_clients", FR_TYPE_UINT32, 0, proto_control_t, io.max_clients), .dflt = "256" } ,
- { FR_CONF_OFFSET("max_pending_packets", FR_TYPE_UINT32, 0, proto_control_t, io.max_pending_packets), .dflt = "256" } ,
+ { FR_CONF_OFFSET("max_connections", proto_control_t, io.max_connections), .dflt = "1024" } ,
+ { FR_CONF_OFFSET("max_clients", proto_control_t, io.max_clients), .dflt = "256" } ,
+ { FR_CONF_OFFSET("max_pending_packets", proto_control_t, io.max_pending_packets), .dflt = "256" } ,
/*
* For performance tweaking. NOT for normal humans.
*/
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_control_t, max_packet_size) } ,
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_control_t, num_messages) } ,
+ { FR_CONF_OFFSET("max_packet_size", proto_control_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("num_messages", proto_control_t, num_messages) } ,
CONF_PARSER_TERMINATOR
};
*
*/
static conf_parser_t const proto_control_config[] = {
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_control_t, io.submodule),
+ { FR_CONF_OFFSET_FLAGS("transport", FR_TYPE_VOID, 0, proto_control_t, io.submodule),
.func = transport_parse },
{ FR_CONF_POINTER("limit", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) limit_config },
} proto_control_unix_t;
static const conf_parser_t unix_listen_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_REQUIRED, proto_control_unix_t, filename),
+ { FR_CONF_OFFSET_FLAGS("filename", FR_TYPE_STRING, CONF_FLAG_REQUIRED, proto_control_unix_t, filename),
.dflt = "${run_dir}/radiusd.sock}" },
- { FR_CONF_OFFSET("uid", FR_TYPE_STRING, 0, proto_control_unix_t, uid_name) },
- { FR_CONF_OFFSET("gid", FR_TYPE_STRING, 0, proto_control_unix_t, gid_name) },
- { FR_CONF_OFFSET("mode", FR_TYPE_STRING, 0, proto_control_unix_t, mode_name) },
- { FR_CONF_OFFSET("peercred", FR_TYPE_BOOL, 0, proto_control_unix_t, peercred), .dflt = "yes" },
+ { FR_CONF_OFFSET("uid", proto_control_unix_t, uid_name) },
+ { FR_CONF_OFFSET("gid", proto_control_unix_t, gid_name) },
+ { FR_CONF_OFFSET("mode", proto_control_unix_t, mode_name) },
+ { FR_CONF_OFFSET("peercred", proto_control_unix_t, peercred), .dflt = "yes" },
{ FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, proto_control_unix_t, recv_buff) },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_control_unix_t, max_packet_size), .dflt = "4096" } ,
+ { FR_CONF_OFFSET("max_packet_size", proto_control_unix_t, max_packet_size), .dflt = "4096" } ,
CONF_PARSER_TERMINATOR
};
/*
* For performance tweaking. NOT for normal humans.
*/
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_cron_t, max_packet_size) } ,
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_cron_t, num_messages) } ,
+ { FR_CONF_OFFSET("max_packet_size", proto_cron_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("num_messages", proto_cron_t, num_messages) } ,
CONF_PARSER_TERMINATOR
};
*
*/
static conf_parser_t const proto_cron_config[] = {
- { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_REQUIRED, proto_cron_t,
+ { FR_CONF_OFFSET_FLAGS("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_REQUIRED, proto_cron_t,
type), .func = type_parse },
- { FR_CONF_OFFSET("when", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY | CONF_FLAG_REQUIRED, proto_cron_t, spec),
+ { FR_CONF_OFFSET_FLAGS("when", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY | CONF_FLAG_REQUIRED, proto_cron_t, spec),
.func = time_parse },
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, proto_cron_t, filename ) },
+ { FR_CONF_OFFSET_FLAGS("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, proto_cron_t, filename ) },
- { FR_CONF_OFFSET("priority", FR_TYPE_UINT32, 0, proto_cron_t, priority) },
+ { FR_CONF_OFFSET("priority", proto_cron_t, priority) },
{ FR_CONF_POINTER("limit", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) limit_config },
CONF_PARSER_TERMINATOR
*
*/
static conf_parser_t const proto_cron_config[] = {
- { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_REQUIRED, proto_cron_t,
+ { FR_CONF_OFFSET_FLAGS("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_REQUIRED, proto_cron_t,
type), .func = type_parse },
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_cron_t, io.submodule),
+ { FR_CONF_OFFSET_FLAGS("transport", FR_TYPE_VOID, 0, proto_cron_t, io.submodule),
.func = transport_parse, .dflt = "crontab" },
/*
* Add this as a synonym so normal humans can understand it.
*/
- { FR_CONF_OFFSET("max_entry_size", FR_TYPE_UINT32, 0, proto_cron_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("max_entry_size", proto_cron_t, max_packet_size) } ,
/*
* For performance tweaking. NOT for normal humans.
*/
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_cron_t, max_packet_size) } ,
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_cron_t, num_messages) } ,
+ { FR_CONF_OFFSET("max_packet_size", proto_cron_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("num_messages", proto_cron_t, num_messages) } ,
- { FR_CONF_OFFSET("priority", FR_TYPE_UINT32, 0, proto_cron_t, priority) },
+ { FR_CONF_OFFSET("priority", proto_cron_t, priority) },
CONF_PARSER_TERMINATOR
};
static int time_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
static const conf_parser_t crontab_listen_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, proto_cron_crontab_t, filename) },
+ { FR_CONF_OFFSET_FLAGS("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, proto_cron_crontab_t, filename) },
- { FR_CONF_OFFSET("timespec", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY | CONF_FLAG_REQUIRED, proto_cron_crontab_t, spec),
+ { FR_CONF_OFFSET_FLAGS("timespec", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY | CONF_FLAG_REQUIRED, proto_cron_crontab_t, spec),
.func = time_parse },
CONF_PARSER_TERMINATOR
*
*/
static conf_parser_t const proto_detail_config[] = {
- { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_REQUIRED, proto_detail_t,
+ { FR_CONF_OFFSET_FLAGS("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_REQUIRED, proto_detail_t,
type), .func = type_parse },
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_detail_t, io_submodule),
+ { FR_CONF_OFFSET_FLAGS("transport", FR_TYPE_VOID, 0, proto_detail_t, io_submodule),
.func = transport_parse, .dflt = "file" },
/*
* Add this as a synonym so normal humans can understand it.
*/
- { FR_CONF_OFFSET("max_entry_size", FR_TYPE_UINT32, 0, proto_detail_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("max_entry_size", proto_detail_t, max_packet_size) } ,
/*
* For performance tweaking. NOT for normal humans.
*/
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_detail_t, max_packet_size) } ,
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_detail_t, num_messages) } ,
+ { FR_CONF_OFFSET("max_packet_size", proto_detail_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("num_messages", proto_detail_t, num_messages) } ,
- { FR_CONF_OFFSET("exit_when_done", FR_TYPE_BOOL, 0, proto_detail_t, exit_when_done) },
+ { FR_CONF_OFFSET("exit_when_done", proto_detail_t, exit_when_done) },
- { FR_CONF_OFFSET("priority", FR_TYPE_UINT32, 0, proto_detail_t, priority) },
+ { FR_CONF_OFFSET("priority", proto_detail_t, priority) },
CONF_PARSER_TERMINATOR
};
static void mod_vnode_delete(fr_event_list_t *el, int fd, UNUSED int fflags, void *ctx);
static const conf_parser_t file_listen_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_REQUIRED, proto_detail_file_t, filename ) },
+ { FR_CONF_OFFSET_FLAGS("filename", FR_TYPE_STRING, CONF_FLAG_REQUIRED, proto_detail_file_t, filename ) },
- { FR_CONF_OFFSET("filename_work", FR_TYPE_STRING, 0, proto_detail_file_t, filename_work ) },
+ { FR_CONF_OFFSET("filename_work", proto_detail_file_t, filename_work ) },
- { FR_CONF_OFFSET("poll_interval", FR_TYPE_UINT32, 0, proto_detail_file_t, poll_interval), .dflt = "5" },
+ { FR_CONF_OFFSET("poll_interval", proto_detail_file_t, poll_interval), .dflt = "5" },
- { FR_CONF_OFFSET("immediate", FR_TYPE_BOOL, 0, proto_detail_file_t, immediate) },
+ { FR_CONF_OFFSET("immediate", proto_detail_file_t, immediate) },
CONF_PARSER_TERMINATOR
};
} fr_detail_entry_t;
static conf_parser_t limit_config[] = {
- { FR_CONF_OFFSET("initial_rtx_time", FR_TYPE_TIME_DELTA, 0, proto_detail_work_t, retry_config.irt), .dflt = STRINGIFY(2) },
- { FR_CONF_OFFSET("max_rtx_time", FR_TYPE_TIME_DELTA, 0, proto_detail_work_t, retry_config.mrt), .dflt = STRINGIFY(16) },
+ { FR_CONF_OFFSET("initial_rtx_time", proto_detail_work_t, retry_config.irt), .dflt = STRINGIFY(2) },
+ { FR_CONF_OFFSET("max_rtx_time", proto_detail_work_t, retry_config.mrt), .dflt = STRINGIFY(16) },
/*
* Retransmit indefinitely, as v2 and v3 did.
*/
- { FR_CONF_OFFSET("max_rtx_count", FR_TYPE_UINT32, 0, proto_detail_work_t, retry_config.mrc), .dflt = STRINGIFY(0) },
+ { FR_CONF_OFFSET("max_rtx_count", proto_detail_work_t, retry_config.mrc), .dflt = STRINGIFY(0) },
/*
* ...again same as v2 and v3.
*/
- { FR_CONF_OFFSET("max_rtx_duration", FR_TYPE_TIME_DELTA, 0, proto_detail_work_t, retry_config.mrd), .dflt = STRINGIFY(0) },
- { FR_CONF_OFFSET("max_outstanding", FR_TYPE_UINT16, 0, proto_detail_work_t, max_outstanding), .dflt = STRINGIFY(1) },
+ { FR_CONF_OFFSET("max_rtx_duration", proto_detail_work_t, retry_config.mrd), .dflt = STRINGIFY(0) },
+ { FR_CONF_OFFSET("max_outstanding", proto_detail_work_t, max_outstanding), .dflt = STRINGIFY(1) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t file_listen_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_REQUIRED, proto_detail_work_t, filename_work ) },
+ { FR_CONF_OFFSET_FLAGS("filename", FR_TYPE_STRING, CONF_FLAG_REQUIRED, proto_detail_work_t, filename_work ) },
- { FR_CONF_OFFSET("track", FR_TYPE_BOOL, 0, proto_detail_work_t, track_progress ) },
+ { FR_CONF_OFFSET("track", proto_detail_work_t, track_progress ) },
- { FR_CONF_OFFSET("retransmit", FR_TYPE_BOOL, 0, proto_detail_work_t, retransmit ), .dflt = "yes" },
+ { FR_CONF_OFFSET("retransmit", proto_detail_work_t, retransmit ), .dflt = "yes" },
{ FR_CONF_POINTER("limit", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) limit_config },
CONF_PARSER_TERMINATOR
static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
static const conf_parser_t priority_config[] = {
- { FR_CONF_OFFSET("Discover", FR_TYPE_VOID, 0, proto_dhcpv4_t, priorities[FR_DHCP_DISCOVER]),
+ { FR_CONF_OFFSET_FLAGS("Discover", FR_TYPE_VOID, 0, proto_dhcpv4_t, priorities[FR_DHCP_DISCOVER]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Request", FR_TYPE_VOID, 0, proto_dhcpv4_t, priorities[FR_DHCP_REQUEST]),
+ { FR_CONF_OFFSET_FLAGS("Request", FR_TYPE_VOID, 0, proto_dhcpv4_t, priorities[FR_DHCP_REQUEST]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Decline", FR_TYPE_VOID, 0, proto_dhcpv4_t, priorities[FR_DHCP_DECLINE]),
+ { FR_CONF_OFFSET_FLAGS("Decline", FR_TYPE_VOID, 0, proto_dhcpv4_t, priorities[FR_DHCP_DECLINE]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Release", FR_TYPE_VOID, 0, proto_dhcpv4_t, priorities[FR_DHCP_RELEASE]),
+ { FR_CONF_OFFSET_FLAGS("Release", FR_TYPE_VOID, 0, proto_dhcpv4_t, priorities[FR_DHCP_RELEASE]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Inform", FR_TYPE_VOID, 0, proto_dhcpv4_t, priorities[FR_DHCP_INFORM]),
+ { FR_CONF_OFFSET_FLAGS("Inform", FR_TYPE_VOID, 0, proto_dhcpv4_t, priorities[FR_DHCP_INFORM]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Lease-Query", FR_TYPE_VOID, 0, proto_dhcpv4_t, priorities[FR_DHCP_LEASE_QUERY]),
+ { FR_CONF_OFFSET_FLAGS("Lease-Query", FR_TYPE_VOID, 0, proto_dhcpv4_t, priorities[FR_DHCP_LEASE_QUERY]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "low" },
- { FR_CONF_OFFSET("Bulk-Lease-Query", FR_TYPE_VOID, 0, proto_dhcpv4_t, priorities[FR_DHCP_BULK_LEASE_QUERY]),
+ { FR_CONF_OFFSET_FLAGS("Bulk-Lease-Query", FR_TYPE_VOID, 0, proto_dhcpv4_t, priorities[FR_DHCP_BULK_LEASE_QUERY]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "low" },
CONF_PARSER_TERMINATOR
};
static conf_parser_t const limit_config[] = {
- { FR_CONF_OFFSET("cleanup_delay", FR_TYPE_TIME_DELTA, 0, proto_dhcpv4_t, io.cleanup_delay), .dflt = "5.0" } ,
- { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, 0, proto_dhcpv4_t, io.idle_timeout), .dflt = "30.0" } ,
- { FR_CONF_OFFSET("nak_lifetime", FR_TYPE_TIME_DELTA, 0, proto_dhcpv4_t, io.nak_lifetime), .dflt = "30.0" } ,
+ { FR_CONF_OFFSET("cleanup_delay", proto_dhcpv4_t, io.cleanup_delay), .dflt = "5.0" } ,
+ { FR_CONF_OFFSET("idle_timeout", proto_dhcpv4_t, io.idle_timeout), .dflt = "30.0" } ,
+ { FR_CONF_OFFSET("nak_lifetime", proto_dhcpv4_t, io.nak_lifetime), .dflt = "30.0" } ,
- { FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, 0, proto_dhcpv4_t, io.max_connections), .dflt = "1024" } ,
- { FR_CONF_OFFSET("max_clients", FR_TYPE_UINT32, 0, proto_dhcpv4_t, io.max_clients), .dflt = "256" } ,
- { FR_CONF_OFFSET("max_pending_packets", FR_TYPE_UINT32, 0, proto_dhcpv4_t, io.max_pending_packets), .dflt = "256" } ,
+ { FR_CONF_OFFSET("max_connections", proto_dhcpv4_t, io.max_connections), .dflt = "1024" } ,
+ { FR_CONF_OFFSET("max_clients", proto_dhcpv4_t, io.max_clients), .dflt = "256" } ,
+ { FR_CONF_OFFSET("max_pending_packets", proto_dhcpv4_t, io.max_pending_packets), .dflt = "256" } ,
/*
* For performance tweaking. NOT for normal humans.
*/
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_dhcpv4_t, max_packet_size) } ,
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_dhcpv4_t, num_messages) } ,
+ { FR_CONF_OFFSET("max_packet_size", proto_dhcpv4_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("num_messages", proto_dhcpv4_t, num_messages) } ,
{ FR_CONF_POINTER("priority", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) priority_config },
CONF_PARSER_TERMINATOR
*
*/
static conf_parser_t const proto_dhcpv4_config[] = {
- { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI, proto_dhcpv4_t,
+ { FR_CONF_OFFSET_FLAGS("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI, proto_dhcpv4_t,
allowed_types), .func = type_parse },
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_dhcpv4_t, io.submodule),
+ { FR_CONF_OFFSET_FLAGS("transport", FR_TYPE_VOID, 0, proto_dhcpv4_t, io.submodule),
.func = transport_parse },
{ FR_CONF_POINTER("limit", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) limit_config },
static const conf_parser_t networks_config[] = {
- { FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_dhcpv4_udp_t, allow) },
- { FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_dhcpv4_udp_t, deny) },
+ { FR_CONF_OFFSET_FLAGS("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_dhcpv4_udp_t, allow) },
+ { FR_CONF_OFFSET_FLAGS("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_dhcpv4_udp_t, deny) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t udp_listen_config[] = {
- { FR_CONF_OFFSET("ipaddr", FR_TYPE_IPV4_ADDR, 0, proto_dhcpv4_udp_t, ipaddr) },
- { FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, 0, proto_dhcpv4_udp_t, ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipaddr", FR_TYPE_IPV4_ADDR, 0, proto_dhcpv4_udp_t, ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipv4addr", FR_TYPE_IPV4_ADDR, 0, proto_dhcpv4_udp_t, ipaddr) },
- { FR_CONF_OFFSET("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_dhcpv4_udp_t, src_ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_dhcpv4_udp_t, src_ipaddr) },
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, proto_dhcpv4_udp_t, interface) },
- { FR_CONF_OFFSET("port_name", FR_TYPE_STRING, 0, proto_dhcpv4_udp_t, port_name) },
+ { FR_CONF_OFFSET("interface", proto_dhcpv4_udp_t, interface) },
+ { FR_CONF_OFFSET("port_name", proto_dhcpv4_udp_t, port_name) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, proto_dhcpv4_udp_t, port) },
+ { FR_CONF_OFFSET("port", proto_dhcpv4_udp_t, port) },
{ FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, proto_dhcpv4_udp_t, recv_buff) },
- { FR_CONF_OFFSET("broadcast", FR_TYPE_BOOL, 0, proto_dhcpv4_udp_t, broadcast) } ,
+ { FR_CONF_OFFSET("broadcast", proto_dhcpv4_udp_t, broadcast) } ,
- { FR_CONF_OFFSET("dynamic_clients", FR_TYPE_BOOL, 0, proto_dhcpv4_udp_t, dynamic_clients) } ,
+ { FR_CONF_OFFSET("dynamic_clients", proto_dhcpv4_udp_t, dynamic_clients) } ,
{ FR_CONF_POINTER("networks", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) networks_config },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_dhcpv4_udp_t, max_packet_size), .dflt = "4096" } ,
- { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, 0, proto_dhcpv4_udp_t, max_attributes), .dflt = STRINGIFY(DHCPV4_MAX_ATTRIBUTES) } ,
+ { FR_CONF_OFFSET("max_packet_size", proto_dhcpv4_udp_t, max_packet_size), .dflt = "4096" } ,
+ { FR_CONF_OFFSET("max_attributes", proto_dhcpv4_udp_t, max_attributes), .dflt = STRINGIFY(DHCPV4_MAX_ATTRIBUTES) } ,
CONF_PARSER_TERMINATOR
};
static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
static const conf_parser_t priority_config[] = {
- { FR_CONF_OFFSET("Solicit", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_SOLICIT]),
+ { FR_CONF_OFFSET_FLAGS("Solicit", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_SOLICIT]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Request", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_REQUEST]),
+ { FR_CONF_OFFSET_FLAGS("Request", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_REQUEST]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Renew", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_RENEW]),
+ { FR_CONF_OFFSET_FLAGS("Renew", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_RENEW]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Rebind", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_REBIND]),
+ { FR_CONF_OFFSET_FLAGS("Rebind", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_REBIND]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Release", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_RELEASE]),
+ { FR_CONF_OFFSET_FLAGS("Release", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_RELEASE]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Decline", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_DECLINE]),
+ { FR_CONF_OFFSET_FLAGS("Decline", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_DECLINE]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Information-Request", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_INFORMATION_REQUEST]),
+ { FR_CONF_OFFSET_FLAGS("Information-Request", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_INFORMATION_REQUEST]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Relay-Forward", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_RELAY_FORWARD]),
+ { FR_CONF_OFFSET_FLAGS("Relay-Forward", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_RELAY_FORWARD]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
CONF_PARSER_TERMINATOR
};
static conf_parser_t const limit_config[] = {
- { FR_CONF_OFFSET("cleanup_delay", FR_TYPE_TIME_DELTA, 0, proto_dhcpv6_t, io.cleanup_delay), .dflt = "5.0" } ,
- { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, 0, proto_dhcpv6_t, io.idle_timeout), .dflt = "30.0" } ,
- { FR_CONF_OFFSET("nak_lifetime", FR_TYPE_TIME_DELTA, 0, proto_dhcpv6_t, io.nak_lifetime), .dflt = "30.0" } ,
+ { FR_CONF_OFFSET("cleanup_delay", proto_dhcpv6_t, io.cleanup_delay), .dflt = "5.0" } ,
+ { FR_CONF_OFFSET("idle_timeout", proto_dhcpv6_t, io.idle_timeout), .dflt = "30.0" } ,
+ { FR_CONF_OFFSET("nak_lifetime", proto_dhcpv6_t, io.nak_lifetime), .dflt = "30.0" } ,
- { FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, 0, proto_dhcpv6_t, io.max_connections), .dflt = "1024" } ,
- { FR_CONF_OFFSET("max_clients", FR_TYPE_UINT32, 0, proto_dhcpv6_t, io.max_clients), .dflt = "256" } ,
- { FR_CONF_OFFSET("max_pending_packets", FR_TYPE_UINT32, 0, proto_dhcpv6_t, io.max_pending_packets), .dflt = "256" } ,
+ { FR_CONF_OFFSET("max_connections", proto_dhcpv6_t, io.max_connections), .dflt = "1024" } ,
+ { FR_CONF_OFFSET("max_clients", proto_dhcpv6_t, io.max_clients), .dflt = "256" } ,
+ { FR_CONF_OFFSET("max_pending_packets", proto_dhcpv6_t, io.max_pending_packets), .dflt = "256" } ,
/*
* For performance tweaking. NOT for normal humans.
*/
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_dhcpv6_t, max_packet_size) } ,
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_dhcpv6_t, num_messages) } ,
+ { FR_CONF_OFFSET("max_packet_size", proto_dhcpv6_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("num_messages", proto_dhcpv6_t, num_messages) } ,
{ FR_CONF_POINTER("priority", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) priority_config },
CONF_PARSER_TERMINATOR
*
*/
static conf_parser_t const proto_dhcpv6_config[] = {
- { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI, proto_dhcpv6_t,
+ { FR_CONF_OFFSET_FLAGS("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI, proto_dhcpv6_t,
allowed_types), .func = type_parse },
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_dhcpv6_t, io.submodule),
+ { FR_CONF_OFFSET_FLAGS("transport", FR_TYPE_VOID, 0, proto_dhcpv6_t, io.submodule),
.func = transport_parse },
{ FR_CONF_POINTER("limit", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) limit_config },
static const conf_parser_t networks_config[] = {
- { FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_dhcpv6_udp_t, allow) },
- { FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_dhcpv6_udp_t, deny) },
+ { FR_CONF_OFFSET_FLAGS("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_dhcpv6_udp_t, allow) },
+ { FR_CONF_OFFSET_FLAGS("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_dhcpv6_udp_t, deny) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t udp_listen_config[] = {
- { FR_CONF_OFFSET("ipaddr", FR_TYPE_IPV6_ADDR, 0, proto_dhcpv6_udp_t, ipaddr) },
- { FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, 0, proto_dhcpv6_udp_t, ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipaddr", FR_TYPE_IPV6_ADDR, 0, proto_dhcpv6_udp_t, ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipv6addr", FR_TYPE_IPV6_ADDR, 0, proto_dhcpv6_udp_t, ipaddr) },
- { FR_CONF_OFFSET("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_dhcpv6_udp_t, src_ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_dhcpv6_udp_t, src_ipaddr) },
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, proto_dhcpv6_udp_t, interface) },
- { FR_CONF_OFFSET("port_name", FR_TYPE_STRING, 0, proto_dhcpv6_udp_t, port_name) },
+ { FR_CONF_OFFSET("interface", proto_dhcpv6_udp_t, interface) },
+ { FR_CONF_OFFSET("port_name", proto_dhcpv6_udp_t, port_name) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, proto_dhcpv6_udp_t, port), .dflt = "547" },
+ { FR_CONF_OFFSET("port", proto_dhcpv6_udp_t, port), .dflt = "547" },
{ FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, proto_dhcpv6_udp_t, recv_buff) },
- { FR_CONF_OFFSET("hop_limit", FR_TYPE_UINT32, 0, proto_dhcpv6_udp_t, hop_limit) },
+ { FR_CONF_OFFSET("hop_limit", proto_dhcpv6_udp_t, hop_limit) },
- { FR_CONF_OFFSET("dynamic_clients", FR_TYPE_BOOL, 0, proto_dhcpv6_udp_t, dynamic_clients) } ,
+ { FR_CONF_OFFSET("dynamic_clients", proto_dhcpv6_udp_t, dynamic_clients) } ,
{ FR_CONF_POINTER("networks", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) networks_config },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_dhcpv6_udp_t, max_packet_size), .dflt = "8192" } ,
- { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, 0, proto_dhcpv6_udp_t, max_attributes), .dflt = STRINGIFY(DHCPV6_MAX_ATTRIBUTES) } ,
+ { FR_CONF_OFFSET("max_packet_size", proto_dhcpv6_udp_t, max_packet_size), .dflt = "8192" } ,
+ { FR_CONF_OFFSET("max_attributes", proto_dhcpv6_udp_t, max_attributes), .dflt = STRINGIFY(DHCPV6_MAX_ATTRIBUTES) } ,
CONF_PARSER_TERMINATOR
};
static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
static const conf_parser_t priority_config[] = {
- { FR_CONF_OFFSET("query", FR_TYPE_VOID, 0, proto_dns_t, priorities[FR_DNS_QUERY]),
+ { FR_CONF_OFFSET_FLAGS("query", FR_TYPE_VOID, 0, proto_dns_t, priorities[FR_DNS_QUERY]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
CONF_PARSER_TERMINATOR
};
static conf_parser_t const limit_config[] = {
- { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, 0, proto_dns_t, io.idle_timeout), .dflt = "30.0" } ,
+ { FR_CONF_OFFSET("idle_timeout", proto_dns_t, io.idle_timeout), .dflt = "30.0" } ,
- { FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, 0, proto_dns_t, io.max_connections), .dflt = "1024" } ,
+ { FR_CONF_OFFSET("max_connections", proto_dns_t, io.max_connections), .dflt = "1024" } ,
/*
* For performance tweaking. NOT for normal humans.
*/
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_dns_t, max_packet_size) } ,
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_dns_t, num_messages) } ,
+ { FR_CONF_OFFSET("max_packet_size", proto_dns_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("num_messages", proto_dns_t, num_messages) } ,
{ FR_CONF_POINTER("priority", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) priority_config },
CONF_PARSER_TERMINATOR
*
*/
static conf_parser_t const proto_dns_config[] = {
- { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI, proto_dns_t,
+ { FR_CONF_OFFSET_FLAGS("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI, proto_dns_t,
allowed_types), .func = type_parse },
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_dns_t, io.submodule),
+ { FR_CONF_OFFSET_FLAGS("transport", FR_TYPE_VOID, 0, proto_dns_t, io.submodule),
.func = transport_parse },
{ FR_CONF_POINTER("limit", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) limit_config },
static const conf_parser_t networks_config[] = {
- { FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_dns_udp_t, allow) },
- { FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_dns_udp_t, deny) },
+ { FR_CONF_OFFSET_FLAGS("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_dns_udp_t, allow) },
+ { FR_CONF_OFFSET_FLAGS("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_dns_udp_t, deny) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t udp_listen_config[] = {
- { FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_dns_udp_t, ipaddr) },
- { FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, 0, proto_dns_udp_t, ipaddr) },
- { FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, 0, proto_dns_udp_t, ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_dns_udp_t, ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipv6addr", FR_TYPE_IPV6_ADDR, 0, proto_dns_udp_t, ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipv4addr", FR_TYPE_IPV4_ADDR, 0, proto_dns_udp_t, ipaddr) },
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, proto_dns_udp_t, interface) },
+ { FR_CONF_OFFSET("interface", proto_dns_udp_t, interface) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, proto_dns_udp_t, port), .dflt = "547" },
+ { FR_CONF_OFFSET("port", proto_dns_udp_t, port), .dflt = "547" },
{ FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, proto_dns_udp_t, recv_buff) },
{ FR_CONF_POINTER("networks", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) networks_config },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_dns_udp_t, max_packet_size), .dflt = "576" } ,
- { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, 0, proto_dns_udp_t, max_attributes), .dflt = STRINGIFY(DNS_MAX_ATTRIBUTES) } ,
+ { FR_CONF_OFFSET("max_packet_size", proto_dns_udp_t, max_packet_size), .dflt = "576" } ,
+ { FR_CONF_OFFSET("max_attributes", proto_dns_udp_t, max_attributes), .dflt = STRINGIFY(DNS_MAX_ATTRIBUTES) } ,
CONF_PARSER_TERMINATOR
};
static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
static conf_parser_t const ldap_sync_search_config[] = {
- { FR_CONF_OFFSET("base_dn", FR_TYPE_STRING, 0, sync_config_t, base_dn), .dflt = "", .quote = T_SINGLE_QUOTED_STRING },
+ { FR_CONF_OFFSET("base_dn", sync_config_t, base_dn), .dflt = "", .quote = T_SINGLE_QUOTED_STRING },
- { FR_CONF_OFFSET("filter", FR_TYPE_STRING, 0, sync_config_t, filter) },
+ { FR_CONF_OFFSET("filter", sync_config_t, filter) },
- { FR_CONF_OFFSET("scope", FR_TYPE_STRING, 0, sync_config_t, scope_str), .dflt = "sub" },
+ { FR_CONF_OFFSET("scope", sync_config_t, scope_str), .dflt = "sub" },
/* For persistent search directories, setting this to "no" will load the whole directory. */
- { FR_CONF_OFFSET("changes_only", FR_TYPE_BOOL, 0, sync_config_t, changes_only), .dflt = "yes" },
+ { FR_CONF_OFFSET("changes_only", sync_config_t, changes_only), .dflt = "yes" },
CONF_PARSER_TERMINATOR
};
static conf_parser_t const proto_ldap_sync_config[] = {
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_ldap_sync_t, io_submodule),
+ { FR_CONF_OFFSET_FLAGS("transport", FR_TYPE_VOID, 0, proto_ldap_sync_t, io_submodule),
.func = transport_parse },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_ldap_sync_t, max_packet_size) },
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_ldap_sync_t, num_messages) },
- { FR_CONF_OFFSET("cookie_interval", FR_TYPE_TIME_DELTA, 0, proto_ldap_sync_t, cookie_interval), .dflt = "10" },
- { FR_CONF_OFFSET("cookie_changes", FR_TYPE_UINT32, 0, proto_ldap_sync_t, cookie_changes), .dflt = "100" },
- { FR_CONF_OFFSET("retry_interval", FR_TYPE_TIME_DELTA, 0, proto_ldap_sync_t, retry_interval), .dflt = "1" },
+ { FR_CONF_OFFSET("max_packet_size", proto_ldap_sync_t, max_packet_size) },
+ { FR_CONF_OFFSET("num_messages", proto_ldap_sync_t, num_messages) },
+ { FR_CONF_OFFSET("cookie_interval", proto_ldap_sync_t, cookie_interval), .dflt = "10" },
+ { FR_CONF_OFFSET("cookie_changes", proto_ldap_sync_t, cookie_changes), .dflt = "100" },
+ { FR_CONF_OFFSET("retry_interval", proto_ldap_sync_t, retry_interval), .dflt = "1" },
/*
* Areas of the DIT to listen on
/*
* LDAP server definition
*/
- { FR_CONF_OFFSET("server", FR_TYPE_STRING, CONF_FLAG_REQUIRED, proto_ldap_sync_ldap_t, server) },
+ { FR_CONF_OFFSET_FLAGS("server", FR_TYPE_STRING, CONF_FLAG_REQUIRED, proto_ldap_sync_ldap_t, server) },
/*
* Common LDAP conf parsers
* Network tunable parameters
*/
{ FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, proto_ldap_sync_ldap_t, recv_buff) },
- { FR_CONF_OFFSET("max_outstanding", FR_TYPE_UINT32, 0, proto_ldap_sync_ldap_t, max_outstanding), .dflt = "65536" },
+ { FR_CONF_OFFSET("max_outstanding", proto_ldap_sync_ldap_t, max_outstanding), .dflt = "65536" },
CONF_PARSER_TERMINATOR
};
*
*/
static conf_parser_t const proto_load_config[] = {
- { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_REQUIRED, proto_load_t,
+ { FR_CONF_OFFSET_FLAGS("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_REQUIRED, proto_load_t,
type), .func = type_parse },
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_load_t, io.submodule),
+ { FR_CONF_OFFSET_FLAGS("transport", FR_TYPE_VOID, 0, proto_load_t, io.submodule),
.func = transport_parse, .dflt = "step" },
/*
* Add this as a synonym so normal humans can understand it.
*/
- { FR_CONF_OFFSET("max_entry_size", FR_TYPE_UINT32, 0, proto_load_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("max_entry_size", proto_load_t, max_packet_size) } ,
/*
* For performance tweaking. NOT for normal humans.
*/
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_load_t, max_packet_size) } ,
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_load_t, num_messages) } ,
+ { FR_CONF_OFFSET("max_packet_size", proto_load_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("num_messages", proto_load_t, num_messages) } ,
- { FR_CONF_OFFSET("priority", FR_TYPE_UINT32, 0, proto_load_t, priority) },
+ { FR_CONF_OFFSET("priority", proto_load_t, priority) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t load_listen_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, proto_load_step_t, filename) },
- { FR_CONF_OFFSET("csv", FR_TYPE_STRING, 0, proto_load_step_t, csv) },
-
- { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, 0, proto_load_step_t, max_attributes), .dflt = STRINGIFY(RADIUS_MAX_ATTRIBUTES) } ,
-
- { FR_CONF_OFFSET("start_pps", FR_TYPE_UINT32, 0, proto_load_step_t, load.start_pps) },
- { FR_CONF_OFFSET("max_pps", FR_TYPE_UINT32, 0, proto_load_step_t, load.max_pps) },
- { FR_CONF_OFFSET("duration", FR_TYPE_TIME_DELTA, 0, proto_load_step_t, load.duration) },
- { FR_CONF_OFFSET("step", FR_TYPE_UINT32, 0, proto_load_step_t, load.step) },
- { FR_CONF_OFFSET("max_backlog", FR_TYPE_UINT32, 0, proto_load_step_t, load.milliseconds) },
- { FR_CONF_OFFSET("parallel", FR_TYPE_UINT32, 0, proto_load_step_t, load.parallel) },
- { FR_CONF_OFFSET("repeat", FR_TYPE_BOOL, 0, proto_load_step_t, repeat) },
+ { FR_CONF_OFFSET_FLAGS("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, proto_load_step_t, filename) },
+ { FR_CONF_OFFSET("csv", proto_load_step_t, csv) },
+
+ { FR_CONF_OFFSET("max_attributes", proto_load_step_t, max_attributes), .dflt = STRINGIFY(RADIUS_MAX_ATTRIBUTES) } ,
+
+ { FR_CONF_OFFSET("start_pps", proto_load_step_t, load.start_pps) },
+ { FR_CONF_OFFSET("max_pps", proto_load_step_t, load.max_pps) },
+ { FR_CONF_OFFSET("duration", proto_load_step_t, load.duration) },
+ { FR_CONF_OFFSET("step", proto_load_step_t, load.step) },
+ { FR_CONF_OFFSET("max_backlog", proto_load_step_t, load.milliseconds) },
+ { FR_CONF_OFFSET("parallel", proto_load_step_t, load.parallel) },
+ { FR_CONF_OFFSET("repeat", proto_load_step_t, repeat) },
CONF_PARSER_TERMINATOR
};
static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
static conf_parser_t const limit_config[] = {
- { FR_CONF_OFFSET("cleanup_delay", FR_TYPE_TIME_DELTA, 0, proto_radius_t, io.cleanup_delay), .dflt = "5.0" } ,
- { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, 0, proto_radius_t, io.idle_timeout), .dflt = "30.0" } ,
- { FR_CONF_OFFSET("nak_lifetime", FR_TYPE_TIME_DELTA, 0, proto_radius_t, io.nak_lifetime), .dflt = "30.0" } ,
+ { FR_CONF_OFFSET("cleanup_delay", proto_radius_t, io.cleanup_delay), .dflt = "5.0" } ,
+ { FR_CONF_OFFSET("idle_timeout", proto_radius_t, io.idle_timeout), .dflt = "30.0" } ,
+ { FR_CONF_OFFSET("nak_lifetime", proto_radius_t, io.nak_lifetime), .dflt = "30.0" } ,
- { FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, 0, proto_radius_t, io.max_connections), .dflt = "1024" } ,
- { FR_CONF_OFFSET("max_clients", FR_TYPE_UINT32, 0, proto_radius_t, io.max_clients), .dflt = "256" } ,
- { FR_CONF_OFFSET("max_pending_packets", FR_TYPE_UINT32, 0, proto_radius_t, io.max_pending_packets), .dflt = "256" } ,
+ { FR_CONF_OFFSET("max_connections", proto_radius_t, io.max_connections), .dflt = "1024" } ,
+ { FR_CONF_OFFSET("max_clients", proto_radius_t, io.max_clients), .dflt = "256" } ,
+ { FR_CONF_OFFSET("max_pending_packets", proto_radius_t, io.max_pending_packets), .dflt = "256" } ,
/*
* For performance tweaking. NOT for normal humans.
*/
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_radius_t, max_packet_size) } ,
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_radius_t, num_messages) } ,
+ { FR_CONF_OFFSET("max_packet_size", proto_radius_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("num_messages", proto_radius_t, num_messages) } ,
CONF_PARSER_TERMINATOR
};
static const conf_parser_t priority_config[] = {
- { FR_CONF_OFFSET("Access-Request", FR_TYPE_VOID, 0, proto_radius_t, priorities[FR_RADIUS_CODE_ACCESS_REQUEST]),
+ { FR_CONF_OFFSET_FLAGS("Access-Request", FR_TYPE_VOID, 0, proto_radius_t, priorities[FR_RADIUS_CODE_ACCESS_REQUEST]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "high" },
- { FR_CONF_OFFSET("Accounting-Request", FR_TYPE_VOID, 0, proto_radius_t, priorities[FR_RADIUS_CODE_ACCOUNTING_REQUEST]),
+ { FR_CONF_OFFSET_FLAGS("Accounting-Request", FR_TYPE_VOID, 0, proto_radius_t, priorities[FR_RADIUS_CODE_ACCOUNTING_REQUEST]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "low" },
- { FR_CONF_OFFSET("CoA-Request", FR_TYPE_VOID, 0, proto_radius_t, priorities[FR_RADIUS_CODE_COA_REQUEST]),
+ { FR_CONF_OFFSET_FLAGS("CoA-Request", FR_TYPE_VOID, 0, proto_radius_t, priorities[FR_RADIUS_CODE_COA_REQUEST]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Disconnect-Request", FR_TYPE_VOID, 0, proto_radius_t, priorities[FR_RADIUS_CODE_DISCONNECT_REQUEST]),
+ { FR_CONF_OFFSET_FLAGS("Disconnect-Request", FR_TYPE_VOID, 0, proto_radius_t, priorities[FR_RADIUS_CODE_DISCONNECT_REQUEST]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "low" },
- { FR_CONF_OFFSET("Status-Server", FR_TYPE_VOID, 0, proto_radius_t, priorities[FR_RADIUS_CODE_STATUS_SERVER]),
+ { FR_CONF_OFFSET_FLAGS("Status-Server", FR_TYPE_VOID, 0, proto_radius_t, priorities[FR_RADIUS_CODE_STATUS_SERVER]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "now" },
CONF_PARSER_TERMINATOR
*
*/
static conf_parser_t const proto_radius_config[] = {
- { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI, proto_radius_t,
+ { FR_CONF_OFFSET_FLAGS("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI, proto_radius_t,
allowed_types), .func = type_parse },
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_radius_t, io.submodule),
+ { FR_CONF_OFFSET_FLAGS("transport", FR_TYPE_VOID, 0, proto_radius_t, io.submodule),
.func = transport_parse },
/*
* Check whether or not the *trailing* bits of a
* Tunnel-Password are zero, as they should be.
*/
- { FR_CONF_OFFSET("tunnel_password_zeros", FR_TYPE_BOOL, 0, proto_radius_t, tunnel_password_zeros) } ,
+ { FR_CONF_OFFSET("tunnel_password_zeros", proto_radius_t, tunnel_password_zeros) } ,
{ FR_CONF_POINTER("limit", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) limit_config },
{ FR_CONF_POINTER("priority", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) priority_config },
static const conf_parser_t networks_config[] = {
- { FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_radius_tcp_t, allow) },
- { FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_radius_tcp_t, deny) },
+ { FR_CONF_OFFSET_FLAGS("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_radius_tcp_t, allow) },
+ { FR_CONF_OFFSET_FLAGS("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_radius_tcp_t, deny) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t tcp_listen_config[] = {
- { FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_radius_tcp_t, ipaddr) },
- { FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, 0, proto_radius_tcp_t, ipaddr) },
- { FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, 0, proto_radius_tcp_t, ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_radius_tcp_t, ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipv4addr", FR_TYPE_IPV4_ADDR, 0, proto_radius_tcp_t, ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipv6addr", FR_TYPE_IPV6_ADDR, 0, proto_radius_tcp_t, ipaddr) },
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, proto_radius_tcp_t, interface) },
- { FR_CONF_OFFSET("port_name", FR_TYPE_STRING, 0, proto_radius_tcp_t, port_name) },
+ { FR_CONF_OFFSET("interface", proto_radius_tcp_t, interface) },
+ { FR_CONF_OFFSET("port_name", proto_radius_tcp_t, port_name) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, proto_radius_tcp_t, port) },
+ { FR_CONF_OFFSET("port", proto_radius_tcp_t, port) },
{ FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, proto_radius_tcp_t, recv_buff) },
- { FR_CONF_OFFSET("dynamic_clients", FR_TYPE_BOOL, 0, proto_radius_tcp_t, dynamic_clients) } ,
- { FR_CONF_OFFSET("accept_conflicting_packets", FR_TYPE_BOOL, 0, proto_radius_tcp_t, dedup_authenticator) } ,
+ { FR_CONF_OFFSET("dynamic_clients", proto_radius_tcp_t, dynamic_clients) } ,
+ { FR_CONF_OFFSET("accept_conflicting_packets", proto_radius_tcp_t, dedup_authenticator) } ,
{ FR_CONF_POINTER("networks", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) networks_config },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_radius_tcp_t, max_packet_size), .dflt = "4096" } ,
- { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, 0, proto_radius_tcp_t, max_attributes), .dflt = STRINGIFY(RADIUS_MAX_ATTRIBUTES) } ,
+ { FR_CONF_OFFSET("max_packet_size", proto_radius_tcp_t, max_packet_size), .dflt = "4096" } ,
+ { FR_CONF_OFFSET("max_attributes", proto_radius_tcp_t, max_attributes), .dflt = STRINGIFY(RADIUS_MAX_ATTRIBUTES) } ,
CONF_PARSER_TERMINATOR
};
static const conf_parser_t networks_config[] = {
- { FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_radius_udp_t, allow) },
- { FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_radius_udp_t, deny) },
+ { FR_CONF_OFFSET_FLAGS("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_radius_udp_t, allow) },
+ { FR_CONF_OFFSET_FLAGS("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_radius_udp_t, deny) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t udp_listen_config[] = {
- { FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_radius_udp_t, ipaddr) },
- { FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, 0, proto_radius_udp_t, ipaddr) },
- { FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, 0, proto_radius_udp_t, ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_radius_udp_t, ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipv4addr", FR_TYPE_IPV4_ADDR, 0, proto_radius_udp_t, ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipv6addr", FR_TYPE_IPV6_ADDR, 0, proto_radius_udp_t, ipaddr) },
{ FR_CONF_OFFSET_IS_SET("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_radius_udp_t, src_ipaddr) },
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, proto_radius_udp_t, interface) },
- { FR_CONF_OFFSET("port_name", FR_TYPE_STRING, 0, proto_radius_udp_t, port_name) },
+ { FR_CONF_OFFSET("interface", proto_radius_udp_t, interface) },
+ { FR_CONF_OFFSET("port_name", proto_radius_udp_t, port_name) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, proto_radius_udp_t, port) },
+ { FR_CONF_OFFSET("port", proto_radius_udp_t, port) },
{ FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, proto_radius_udp_t, recv_buff) },
{ FR_CONF_OFFSET_IS_SET("send_buff", FR_TYPE_UINT32, 0, proto_radius_udp_t, send_buff) },
- { FR_CONF_OFFSET("accept_conflicting_packets", FR_TYPE_BOOL, 0, proto_radius_udp_t, dedup_authenticator) } ,
- { FR_CONF_OFFSET("dynamic_clients", FR_TYPE_BOOL, 0, proto_radius_udp_t, dynamic_clients) } ,
+ { FR_CONF_OFFSET("accept_conflicting_packets", proto_radius_udp_t, dedup_authenticator) } ,
+ { FR_CONF_OFFSET("dynamic_clients", proto_radius_udp_t, dynamic_clients) } ,
{ FR_CONF_POINTER("networks", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) networks_config },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_radius_udp_t, max_packet_size), .dflt = "4096" } ,
- { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, 0, proto_radius_udp_t, max_attributes), .dflt = STRINGIFY(RADIUS_MAX_ATTRIBUTES) } ,
+ { FR_CONF_OFFSET("max_packet_size", proto_radius_udp_t, max_packet_size), .dflt = "4096" } ,
+ { FR_CONF_OFFSET("max_attributes", proto_radius_udp_t, max_attributes), .dflt = STRINGIFY(RADIUS_MAX_ATTRIBUTES) } ,
CONF_PARSER_TERMINATOR
};
static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
static conf_parser_t const limit_config[] = {
- { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, 0, proto_tacacs_t, io.idle_timeout), .dflt = "30.0" } ,
+ { FR_CONF_OFFSET("idle_timeout", proto_tacacs_t, io.idle_timeout), .dflt = "30.0" } ,
- { FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, 0, proto_tacacs_t, io.max_connections), .dflt = "1024" } ,
+ { FR_CONF_OFFSET("max_connections", proto_tacacs_t, io.max_connections), .dflt = "1024" } ,
/*
* For performance tweaking. NOT for normal humans.
*/
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_tacacs_t, max_packet_size) } ,
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_tacacs_t, num_messages) } ,
+ { FR_CONF_OFFSET("max_packet_size", proto_tacacs_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("num_messages", proto_tacacs_t, num_messages) } ,
CONF_PARSER_TERMINATOR
};
static const conf_parser_t priority_config[] = {
- { FR_CONF_OFFSET("Authentication-Start", FR_TYPE_VOID, 0, proto_tacacs_t, priorities[FR_TAC_PLUS_AUTHEN]),
+ { FR_CONF_OFFSET_FLAGS("Authentication-Start", FR_TYPE_VOID, 0, proto_tacacs_t, priorities[FR_TAC_PLUS_AUTHEN]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "high" },
- { FR_CONF_OFFSET("Authentication-Continue", FR_TYPE_VOID, 0, proto_tacacs_t, priorities[FR_TAC_PLUS_AUTHEN]),
+ { FR_CONF_OFFSET_FLAGS("Authentication-Continue", FR_TYPE_VOID, 0, proto_tacacs_t, priorities[FR_TAC_PLUS_AUTHEN]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "high" },
- { FR_CONF_OFFSET("Authorization-Request", FR_TYPE_VOID, 0, proto_tacacs_t, priorities[FR_TAC_PLUS_AUTHOR]),
+ { FR_CONF_OFFSET_FLAGS("Authorization-Request", FR_TYPE_VOID, 0, proto_tacacs_t, priorities[FR_TAC_PLUS_AUTHOR]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Accounting-Request", FR_TYPE_VOID, 0, proto_tacacs_t, priorities[FR_TAC_PLUS_ACCT]),
+ { FR_CONF_OFFSET_FLAGS("Accounting-Request", FR_TYPE_VOID, 0, proto_tacacs_t, priorities[FR_TAC_PLUS_ACCT]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "low" },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t proto_tacacs_config[] = {
- { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI, proto_tacacs_t, allowed_types),
+ { FR_CONF_OFFSET_FLAGS("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI, proto_tacacs_t, allowed_types),
.func = type_parse },
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_tacacs_t, io.submodule),
+ { FR_CONF_OFFSET_FLAGS("transport", FR_TYPE_VOID, 0, proto_tacacs_t, io.submodule),
.func = transport_parse },
{ FR_CONF_POINTER("limit", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) limit_config },
} proto_tacacs_tcp_t;
static const conf_parser_t networks_config[] = {
- { FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_tacacs_tcp_t, allow) },
- { FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_tacacs_tcp_t, deny) },
+ { FR_CONF_OFFSET_FLAGS("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_tacacs_tcp_t, allow) },
+ { FR_CONF_OFFSET_FLAGS("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_tacacs_tcp_t, deny) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t tcp_listen_config[] = {
- { FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_tacacs_tcp_t, ipaddr) },
- { FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, 0, proto_tacacs_tcp_t, ipaddr) },
- { FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, 0, proto_tacacs_tcp_t, ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_tacacs_tcp_t, ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipv4addr", FR_TYPE_IPV4_ADDR, 0, proto_tacacs_tcp_t, ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipv6addr", FR_TYPE_IPV6_ADDR, 0, proto_tacacs_tcp_t, ipaddr) },
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, proto_tacacs_tcp_t, interface) },
- { FR_CONF_OFFSET("port_name", FR_TYPE_STRING, 0, proto_tacacs_tcp_t, port_name) },
+ { FR_CONF_OFFSET("interface", proto_tacacs_tcp_t, interface) },
+ { FR_CONF_OFFSET("port_name", proto_tacacs_tcp_t, port_name) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, proto_tacacs_tcp_t, port), .dflt = "49" },
+ { FR_CONF_OFFSET("port", proto_tacacs_tcp_t, port), .dflt = "49" },
{ FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, proto_tacacs_tcp_t, recv_buff) },
- { FR_CONF_OFFSET("dynamic_clients", FR_TYPE_BOOL, 0, proto_tacacs_tcp_t, dynamic_clients) } ,
+ { FR_CONF_OFFSET("dynamic_clients", proto_tacacs_tcp_t, dynamic_clients) } ,
{ FR_CONF_POINTER("networks", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) networks_config },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_tacacs_tcp_t, max_packet_size), .dflt = "4096" } ,
- { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, 0, proto_tacacs_tcp_t, max_attributes), .dflt = STRINGIFY(TACACS_MAX_ATTRIBUTES) } ,
+ { FR_CONF_OFFSET("max_packet_size", proto_tacacs_tcp_t, max_packet_size), .dflt = "4096" } ,
+ { FR_CONF_OFFSET("max_attributes", proto_tacacs_tcp_t, max_attributes), .dflt = STRINGIFY(TACACS_MAX_ATTRIBUTES) } ,
CONF_PARSER_TERMINATOR
};
CONF_ITEM *ci, conf_parser_t const *rule);
static const conf_parser_t priority_config[] = {
- { FR_CONF_OFFSET("Join-Request", FR_TYPE_VOID, 0, proto_vmps_t, priorities[FR_PACKET_TYPE_VALUE_JOIN_REQUEST]),
+ { FR_CONF_OFFSET_FLAGS("Join-Request", FR_TYPE_VOID, 0, proto_vmps_t, priorities[FR_PACKET_TYPE_VALUE_JOIN_REQUEST]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "low" },
- { FR_CONF_OFFSET("Reconfirm-Request", FR_TYPE_VOID, 0, proto_vmps_t, priorities[FR_PACKET_TYPE_VALUE_RECONFIRM_REQUEST]),
+ { FR_CONF_OFFSET_FLAGS("Reconfirm-Request", FR_TYPE_VOID, 0, proto_vmps_t, priorities[FR_PACKET_TYPE_VALUE_RECONFIRM_REQUEST]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "low" },
CONF_PARSER_TERMINATOR
};
static conf_parser_t const limit_config[] = {
- { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, 0, proto_vmps_t, io.idle_timeout), .dflt = "30.0" } ,
- { FR_CONF_OFFSET("nak_lifetime", FR_TYPE_TIME_DELTA, 0, proto_vmps_t, io.nak_lifetime), .dflt = "30.0" } ,
+ { FR_CONF_OFFSET("idle_timeout", proto_vmps_t, io.idle_timeout), .dflt = "30.0" } ,
+ { FR_CONF_OFFSET("nak_lifetime", proto_vmps_t, io.nak_lifetime), .dflt = "30.0" } ,
- { FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, 0, proto_vmps_t, io.max_connections), .dflt = "1024" } ,
- { FR_CONF_OFFSET("max_clients", FR_TYPE_UINT32, 0, proto_vmps_t, io.max_clients), .dflt = "256" } ,
- { FR_CONF_OFFSET("max_pending_packets", FR_TYPE_UINT32, 0, proto_vmps_t, io.max_pending_packets), .dflt = "256" } ,
+ { FR_CONF_OFFSET("max_connections", proto_vmps_t, io.max_connections), .dflt = "1024" } ,
+ { FR_CONF_OFFSET("max_clients", proto_vmps_t, io.max_clients), .dflt = "256" } ,
+ { FR_CONF_OFFSET("max_pending_packets", proto_vmps_t, io.max_pending_packets), .dflt = "256" } ,
/*
* For performance tweaking. NOT for normal humans.
*/
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_vmps_t, max_packet_size) } ,
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_vmps_t, num_messages) } ,
+ { FR_CONF_OFFSET("max_packet_size", proto_vmps_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("num_messages", proto_vmps_t, num_messages) } ,
CONF_PARSER_TERMINATOR
};
*
*/
static conf_parser_t const proto_vmps_config[] = {
- { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI, proto_vmps_t,
+ { FR_CONF_OFFSET_FLAGS("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI, proto_vmps_t,
allowed_types), .func = type_parse },
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_vmps_t, io.submodule),
+ { FR_CONF_OFFSET_FLAGS("transport", FR_TYPE_VOID, 0, proto_vmps_t, io.submodule),
.func = transport_parse },
{ FR_CONF_POINTER("limit", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) limit_config },
static const conf_parser_t networks_config[] = {
- { FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_vmps_udp_t, allow) },
- { FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_vmps_udp_t, deny) },
+ { FR_CONF_OFFSET_FLAGS("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_vmps_udp_t, allow) },
+ { FR_CONF_OFFSET_FLAGS("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_vmps_udp_t, deny) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t udp_listen_config[] = {
- { FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_vmps_udp_t, ipaddr) },
- { FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, 0, proto_vmps_udp_t, ipaddr) },
- { FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, 0, proto_vmps_udp_t, ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_vmps_udp_t, ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipv4addr", FR_TYPE_IPV4_ADDR, 0, proto_vmps_udp_t, ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipv6addr", FR_TYPE_IPV6_ADDR, 0, proto_vmps_udp_t, ipaddr) },
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, proto_vmps_udp_t, interface) },
- { FR_CONF_OFFSET("port_name", FR_TYPE_STRING, 0, proto_vmps_udp_t, port_name) },
+ { FR_CONF_OFFSET("interface", proto_vmps_udp_t, interface) },
+ { FR_CONF_OFFSET("port_name", proto_vmps_udp_t, port_name) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, proto_vmps_udp_t, port) },
+ { FR_CONF_OFFSET("port", proto_vmps_udp_t, port) },
{ FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, proto_vmps_udp_t, recv_buff) },
- { FR_CONF_OFFSET("dynamic_clients", FR_TYPE_BOOL, 0, proto_vmps_udp_t, dynamic_clients) } ,
+ { FR_CONF_OFFSET("dynamic_clients", proto_vmps_udp_t, dynamic_clients) } ,
{ FR_CONF_POINTER("networks", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) networks_config },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_vmps_udp_t, max_packet_size), .dflt = "1024" } ,
+ { FR_CONF_OFFSET("max_packet_size", proto_vmps_udp_t, max_packet_size), .dflt = "1024" } ,
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("rcode", FR_TYPE_STRING, 0, rlm_always_t, rcode_str), .dflt = "fail" },
- { FR_CONF_OFFSET("simulcount", FR_TYPE_UINT32, 0, rlm_always_t, simulcount), .dflt = "0" },
- { FR_CONF_OFFSET("mpp", FR_TYPE_BOOL, 0, rlm_always_t, mpp), .dflt = "no" },
+ { FR_CONF_OFFSET("rcode", rlm_always_t, rcode_str), .dflt = "fail" },
+ { FR_CONF_OFFSET("simulcount", rlm_always_t, simulcount), .dflt = "0" },
+ { FR_CONF_OFFSET("mpp", rlm_always_t, mpp), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
} rlm_attr_filter_t;
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED, rlm_attr_filter_t, filename) },
- { FR_CONF_OFFSET("key", 0, CONF_FLAG_TMPL, rlm_attr_filter_t, key), .dflt = "&Realm", .quote = T_BARE_WORD },
- { FR_CONF_OFFSET("relaxed", FR_TYPE_BOOL, 0, rlm_attr_filter_t, relaxed), .dflt = "no" },
+ { FR_CONF_OFFSET_FLAGS("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED, rlm_attr_filter_t, filename) },
+ { FR_CONF_OFFSET("key", rlm_attr_filter_t, key), .dflt = "&Realm", .quote = T_BARE_WORD },
+ { FR_CONF_OFFSET("relaxed", rlm_attr_filter_t, relaxed), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
} rlm_cache_memcached_t;
static const conf_parser_t driver_config[] = {
- { FR_CONF_OFFSET("options", FR_TYPE_STRING, 0, rlm_cache_memcached_t, options), .dflt = "--SERVER=localhost" },
+ { FR_CONF_OFFSET("options", rlm_cache_memcached_t, options), .dflt = "--SERVER=localhost" },
CONF_PARSER_TERMINATOR
};
extern module_rlm_t rlm_cache;
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("driver", FR_TYPE_VOID, 0, rlm_cache_t, driver_submodule), .dflt = "rbtree",
+ { FR_CONF_OFFSET_FLAGS("driver", FR_TYPE_VOID, 0, rlm_cache_t, driver_submodule), .dflt = "rbtree",
.func = module_rlm_submodule_parse },
- { FR_CONF_OFFSET("ttl", FR_TYPE_TIME_DELTA, 0, rlm_cache_config_t, ttl), .dflt = "500s" },
- { FR_CONF_OFFSET("max_entries", FR_TYPE_UINT32, 0, rlm_cache_config_t, max_entries), .dflt = "0" },
+ { FR_CONF_OFFSET("ttl", rlm_cache_config_t, ttl), .dflt = "500s" },
+ { FR_CONF_OFFSET("max_entries", rlm_cache_config_t, max_entries), .dflt = "0" },
/* Should be a type which matches time_t, @fixme before 2038 */
- { FR_CONF_OFFSET("epoch", FR_TYPE_INT32, 0, rlm_cache_config_t, epoch), .dflt = "0" },
- { FR_CONF_OFFSET("add_stats", FR_TYPE_BOOL, 0, rlm_cache_config_t, stats), .dflt = "no" },
+ { FR_CONF_OFFSET("epoch", rlm_cache_config_t, epoch), .dflt = "0" },
+ { FR_CONF_OFFSET("add_stats", rlm_cache_config_t, stats), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
} rlm_chap_t;
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("min_challenge_len", FR_TYPE_SIZE, 0, rlm_chap_t, min_challenge_len), .dflt = "16" },
+ { FR_CONF_OFFSET_FLAGS("min_challenge_len", FR_TYPE_SIZE, 0, rlm_chap_t, min_challenge_len), .dflt = "16" },
CONF_PARSER_TERMINATOR
};
*
*/
static const conf_parser_t rsa_oaep_config[] = {
- { FR_CONF_OFFSET("oaep_digest", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY, cipher_rsa_oaep_t, oaep_digest), .func = digest_type_parse, .dflt = "sha256" },
- { FR_CONF_OFFSET("mgf1_digest", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY, cipher_rsa_oaep_t, mgf1_digest), .func = digest_type_parse, .dflt = "sha256" },
- { FR_CONF_OFFSET("label", FR_TYPE_STRING, 0, cipher_rsa_oaep_t, label) },
+ { FR_CONF_OFFSET_FLAGS("oaep_digest", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY, cipher_rsa_oaep_t, oaep_digest), .func = digest_type_parse, .dflt = "sha256" },
+ { FR_CONF_OFFSET_FLAGS("mgf1_digest", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY, cipher_rsa_oaep_t, mgf1_digest), .func = digest_type_parse, .dflt = "sha256" },
+ { FR_CONF_OFFSET("label", cipher_rsa_oaep_t, label) },
CONF_PARSER_TERMINATOR
};
*
*/
static const conf_parser_t rsa_config[] = {
- { FR_CONF_OFFSET("verify_mode", FR_TYPE_VOID, 0, cipher_rsa_t, verify_mode),
+ { FR_CONF_OFFSET_FLAGS("verify_mode", FR_TYPE_VOID, 0, cipher_rsa_t, verify_mode),
.func = cf_table_parse_int,
.uctx = &(cf_table_parse_ctx_t){
.table = cipher_cert_verify_mode_table,
},
.dflt = "hard" }, /* Must come before certificate file */
- { FR_CONF_OFFSET("private_key_password", FR_TYPE_STRING, CONF_FLAG_SECRET, cipher_rsa_t, private_key_password) }, /* Must come before private_key */
- { FR_CONF_OFFSET("private_key_file", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY, cipher_rsa_t, private_key_file), .func = cipher_rsa_private_key_file_load },
- { FR_CONF_OFFSET("certificate_file", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY, cipher_rsa_t, certificate_file), .func = cipher_rsa_certificate_file_load },
+ { FR_CONF_OFFSET_FLAGS("private_key_password", FR_TYPE_STRING, CONF_FLAG_SECRET, cipher_rsa_t, private_key_password) }, /* Must come before private_key */
+ { FR_CONF_OFFSET_FLAGS("private_key_file", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY, cipher_rsa_t, private_key_file), .func = cipher_rsa_private_key_file_load },
+ { FR_CONF_OFFSET_FLAGS("certificate_file", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY, cipher_rsa_t, certificate_file), .func = cipher_rsa_certificate_file_load },
- { FR_CONF_OFFSET("random_file", FR_TYPE_STRING, 0, cipher_rsa_t, random_file) },
+ { FR_CONF_OFFSET("random_file", cipher_rsa_t, random_file) },
- { FR_CONF_OFFSET("signature_digest", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY, cipher_rsa_t, sig_digest), .func = digest_type_parse, .dflt = "sha256" },
+ { FR_CONF_OFFSET_FLAGS("signature_digest", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY, cipher_rsa_t, sig_digest), .func = digest_type_parse, .dflt = "sha256" },
- { FR_CONF_OFFSET("padding_type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY, cipher_rsa_t, padding), .func = cipher_rsa_padding_type_parse, .dflt = "pkcs" },
+ { FR_CONF_OFFSET_FLAGS("padding_type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY, cipher_rsa_t, padding), .func = cipher_rsa_padding_type_parse, .dflt = "pkcs" },
- { FR_CONF_OFFSET("oaep", 0, CONF_FLAG_SUBSECTION, cipher_rsa_t, oaep),
- .subcs_size = sizeof(cipher_rsa_oaep_t), .subcs_type = "cipher_rsa_oaep_t", .subcs = (void const *) rsa_oaep_config },
+ { FR_CONF_OFFSET_SUBSECTION("oaep", 0, cipher_rsa_t, oaep, rsa_oaep_config),
+ .subcs_size = sizeof(cipher_rsa_oaep_t), .subcs_type = "cipher_rsa_oaep_t" },
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY, rlm_cipher_t, type), .func = cipher_type_parse, .dflt = "rsa" },
- { FR_CONF_OFFSET("rsa", 0, CONF_FLAG_SUBSECTION, rlm_cipher_t, rsa),
- .subcs_size = sizeof(cipher_rsa_t), .subcs_type = "cipher_rsa_t", .subcs = (void const *) rsa_config },
+ { FR_CONF_OFFSET_FLAGS("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY, rlm_cipher_t, type), .func = cipher_type_parse, .dflt = "rsa" },
+ { FR_CONF_OFFSET_SUBSECTION("rsa", 0, rlm_cipher_t, rsa, rsa_config), .subcs_size = sizeof(cipher_rsa_t), .subcs_type = "cipher_rsa_t" },
CONF_PARSER_TERMINATOR
};
* Client Configuration
*/
static const conf_parser_t client_config[] = {
- { FR_CONF_OFFSET("view", FR_TYPE_STRING, 0, rlm_couchbase_t, client_view), .dflt = "_design/client/_view/by_name" },
+ { FR_CONF_OFFSET("view", rlm_couchbase_t, client_view), .dflt = "_design/client/_view/by_name" },
CONF_PARSER_TERMINATOR
};
* Module Configuration
*/
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("server", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_couchbase_t, server_raw) },
- { FR_CONF_OFFSET("bucket", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_couchbase_t, bucket) },
- { FR_CONF_OFFSET("username", FR_TYPE_STRING, 0, rlm_couchbase_t, username) },
- { FR_CONF_OFFSET("password", FR_TYPE_STRING, 0, rlm_couchbase_t, password) },
+ { FR_CONF_OFFSET_FLAGS("server", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_couchbase_t, server_raw) },
+ { FR_CONF_OFFSET_FLAGS("bucket", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_couchbase_t, bucket) },
+ { FR_CONF_OFFSET("username", rlm_couchbase_t, username) },
+ { FR_CONF_OFFSET("password", rlm_couchbase_t, password) },
- { FR_CONF_OFFSET("acct_key", 0, CONF_FLAG_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, 0, rlm_couchbase_t, doctype), .dflt = "radacct" },
- { FR_CONF_OFFSET("expire", FR_TYPE_UINT32, 0, rlm_couchbase_t, expire), .dflt = 0 },
+ { FR_CONF_OFFSET("acct_key", rlm_couchbase_t, acct_key), .dflt = "radacct_%{%{Acct-Unique-Session-Id} || %{Acct-Session-Id}}", .quote = T_DOUBLE_QUOTED_STRING },
+ { FR_CONF_OFFSET("doctype", rlm_couchbase_t, doctype), .dflt = "radacct" },
+ { FR_CONF_OFFSET("expire", rlm_couchbase_t, expire), .dflt = 0 },
- { FR_CONF_OFFSET("user_key", 0, CONF_FLAG_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_BOOL, 0, rlm_couchbase_t, read_clients) }, /* NULL defaults to "no" */
+ { FR_CONF_OFFSET("user_key", rlm_couchbase_t, user_key), .dflt = "raduser_%md5(%tolower(%{Stripped-User-Name} || %{User-Name}))", .quote = T_DOUBLE_QUOTED_STRING },
+ { FR_CONF_OFFSET("read_clients", rlm_couchbase_t, read_clients) }, /* NULL defaults to "no" */
{ FR_CONF_POINTER("client", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) client_config },
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, rlm_csv_t, filename) },
- { FR_CONF_OFFSET("delimiter", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY, rlm_csv_t, delimiter), .dflt = "," },
- { FR_CONF_OFFSET("fields", FR_TYPE_STRING, 0, rlm_csv_t, fields) },
- { FR_CONF_OFFSET("header", FR_TYPE_BOOL, 0, rlm_csv_t, header) },
- { FR_CONF_OFFSET("allow_multiple_keys", FR_TYPE_BOOL, 0, rlm_csv_t, allow_multiple_keys) },
- { FR_CONF_OFFSET("index_field", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, rlm_csv_t, index_field_name) },
- { FR_CONF_OFFSET("key", 0, CONF_FLAG_TMPL, rlm_csv_t, key) },
+ { FR_CONF_OFFSET_FLAGS("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, rlm_csv_t, filename) },
+ { FR_CONF_OFFSET_FLAGS("delimiter", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY, rlm_csv_t, delimiter), .dflt = "," },
+ { FR_CONF_OFFSET("fields", rlm_csv_t, fields) },
+ { FR_CONF_OFFSET("header", rlm_csv_t, header) },
+ { FR_CONF_OFFSET("allow_multiple_keys", rlm_csv_t, allow_multiple_keys) },
+ { FR_CONF_OFFSET_FLAGS("index_field", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, rlm_csv_t, index_field_name) },
+ { FR_CONF_OFFSET("key", rlm_csv_t, key) },
CONF_PARSER_TERMINATOR
};
} rlm_date_t;
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("format", FR_TYPE_STRING, 0, rlm_date_t, fmt), .dflt = "%b %e %Y %H:%M:%S %Z" },
- { FR_CONF_OFFSET("utc", FR_TYPE_BOOL, 0, rlm_date_t, utc), .dflt = "no" },
+ { FR_CONF_OFFSET("format", rlm_date_t, fmt), .dflt = "%b %e %Y %H:%M:%S %Z" },
+ { FR_CONF_OFFSET("utc", rlm_date_t, utc), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("delay", 0, CONF_FLAG_TMPL, rlm_delay_t, delay) },
- { FR_CONF_OFFSET("relative", FR_TYPE_BOOL, 0, rlm_delay_t, relative), .dflt = "no" },
- { FR_CONF_OFFSET("force_reschedule", FR_TYPE_BOOL, 0, rlm_delay_t, force_reschedule), .dflt = "no" },
+ { FR_CONF_OFFSET("delay", rlm_delay_t, delay) },
+ { FR_CONF_OFFSET("relative", rlm_delay_t, relative), .dflt = "no" },
+ { FR_CONF_OFFSET("force_reschedule", rlm_delay_t, force_reschedule), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
CONF_ITEM *ci, conf_parser_t const *rule);
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_OUTPUT | CONF_FLAG_XLAT, rlm_detail_t, filename), .dflt = "%A/%{Net.Src.IP}/detail" },
- { FR_CONF_OFFSET("header", 0, CONF_FLAG_TMPL | CONF_FLAG_XLAT, rlm_detail_t, header),
+ { FR_CONF_OFFSET_FLAGS("filename", FR_TYPE_STRING, CONF_FLAG_FILE_OUTPUT | CONF_FLAG_XLAT, rlm_detail_t, filename), .dflt = "%A/%{Net.Src.IP}/detail" },
+ { FR_CONF_OFFSET_FLAGS("header", 0, CONF_FLAG_TMPL | CONF_FLAG_XLAT, rlm_detail_t, header),
.dflt = "%t", .quote = T_DOUBLE_QUOTED_STRING },
- { FR_CONF_OFFSET("permissions", FR_TYPE_UINT32, 0, rlm_detail_t, perm), .dflt = "0600" },
+ { FR_CONF_OFFSET("permissions", rlm_detail_t, perm), .dflt = "0600" },
{ FR_CONF_OFFSET_IS_SET("group", FR_TYPE_VOID, 0, rlm_detail_t, group), .func = detail_group_parse },
- { FR_CONF_OFFSET("locking", FR_TYPE_BOOL, 0, rlm_detail_t, locking), .dflt = "no" },
- { FR_CONF_OFFSET("escape_filenames", FR_TYPE_BOOL, 0, rlm_detail_t, escape), .dflt = "no" },
- { FR_CONF_OFFSET("log_packet_header", FR_TYPE_BOOL, 0, rlm_detail_t, log_srcdst), .dflt = "no" },
+ { FR_CONF_OFFSET("locking", rlm_detail_t, locking), .dflt = "no" },
+ { FR_CONF_OFFSET("escape_filenames", rlm_detail_t, escape), .dflt = "no" },
+ { FR_CONF_OFFSET("log_packet_header", rlm_detail_t, log_srcdst), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
} rlm_dhcpv4_thread_t;
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("ipaddr", FR_TYPE_IPV4_ADDR, 0, rlm_dhcpv4_t, config.ipaddr), },
- { FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, 0, rlm_dhcpv4_t, config.ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipaddr", FR_TYPE_IPV4_ADDR, 0, rlm_dhcpv4_t, config.ipaddr), },
+ { FR_CONF_OFFSET_FLAGS("ipv4addr", FR_TYPE_IPV4_ADDR, 0, rlm_dhcpv4_t, config.ipaddr) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, rlm_dhcpv4_t, config.port), .dflt = "68" },
+ { FR_CONF_OFFSET("port", rlm_dhcpv4_t, config.port), .dflt = "68" },
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, rlm_dhcpv4_t, config.interface) },
+ { FR_CONF_OFFSET("interface", rlm_dhcpv4_t, config.interface) },
{ FR_CONF_OFFSET_IS_SET("send_buff", FR_TYPE_UINT32, 0, rlm_dhcpv4_t, config.send_buff) },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, rlm_dhcpv4_t, max_packet_size), .dflt = "576" },
- { FR_CONF_OFFSET("max_queued_packets", FR_TYPE_UINT32, 0, rlm_dhcpv4_t, config.max_queued_packets), .dflt = "65536" },
+ { FR_CONF_OFFSET("max_packet_size", rlm_dhcpv4_t, max_packet_size), .dflt = "576" },
+ { FR_CONF_OFFSET("max_queued_packets", rlm_dhcpv4_t, config.max_queued_packets), .dflt = "65536" },
- { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, 0, rlm_dhcpv4_t, config.max_queued_time), .dflt = "0" },
+ { FR_CONF_OFFSET("timeout", rlm_dhcpv4_t, config.max_queued_time), .dflt = "0" },
CONF_PARSER_TERMINATOR
};
static size_t require_identity_realm_table_len = NUM_ELEMENTS(require_identity_realm_table);
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("require_identity_realm", FR_TYPE_VOID, 0, rlm_eap_t, require_realm),
+ { FR_CONF_OFFSET_FLAGS("require_identity_realm", FR_TYPE_VOID, 0, rlm_eap_t, require_realm),
.func = cf_table_parse_int,
.uctx = &(cf_table_parse_ctx_t){ .table = require_identity_realm_table, .len = &require_identity_realm_table_len },
.dflt = "nai" },
{ FR_CONF_OFFSET_IS_SET("default_eap_type", FR_TYPE_VOID, 0, rlm_eap_t, default_method), .func = eap_type_parse },
- { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI, rlm_eap_t, type_submodules),
+ { FR_CONF_OFFSET_FLAGS("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI, rlm_eap_t, type_submodules),
.func = submodule_parse },
- { FR_CONF_OFFSET("ignore_unknown_eap_types", FR_TYPE_BOOL, 0, rlm_eap_t, ignore_unknown_types), .dflt = "no" },
+ { FR_CONF_OFFSET("ignore_unknown_eap_types", rlm_eap_t, ignore_unknown_types), .dflt = "no" },
- { FR_CONF_DEPRECATED("timer_expire", FR_TYPE_UINT32, 0, rlm_eap_t, timer_limit), .dflt = "60" },
- { FR_CONF_DEPRECATED("cisco_accounting_username_bug", FR_TYPE_BOOL, 0, rlm_eap_t,
+ { FR_CONF_DEPRECATED("timer_expire", rlm_eap_t, timer_limit), .dflt = "60" },
+ { FR_CONF_DEPRECATED("cisco_accounting_username_bug", rlm_eap_t,
cisco_accounting_username_bug), .dflt = "no" },
- { FR_CONF_DEPRECATED("max_sessions", FR_TYPE_UINT32, 0, rlm_eap_t, max_sessions), .dflt = "2048" },
+ { FR_CONF_DEPRECATED("max_sessions", rlm_eap_t, max_sessions), .dflt = "2048" },
CONF_PARSER_TERMINATOR
};
#include <freeradius-devel/util/debug.h>
static conf_parser_t submodule_config[] = {
- { FR_CONF_OFFSET("virtual_server", FR_TYPE_VOID, 0, eap_aka_sim_module_conf_t, virtual_server), .func = virtual_server_cf_parse },
+ { FR_CONF_OFFSET_FLAGS("virtual_server", FR_TYPE_VOID, 0, eap_aka_sim_module_conf_t, virtual_server), .func = virtual_server_cf_parse },
{ FR_CONF_OFFSET_IS_SET("prefer_aka_prime", FR_TYPE_BOOL, 0, eap_aka_sim_module_conf_t, aka.send_at_bidding_prefer_prime ), .dflt = "no" },
CONF_PARSER_TERMINATOR
#include <freeradius-devel/util/debug.h>
static conf_parser_t submodule_config[] = {
- { FR_CONF_OFFSET("virtual_server", FR_TYPE_VOID, 0, eap_aka_sim_module_conf_t, virtual_server), .func = virtual_server_cf_parse },
+ { FR_CONF_OFFSET_FLAGS("virtual_server", FR_TYPE_VOID, 0, eap_aka_sim_module_conf_t, virtual_server), .func = virtual_server_cf_parse },
CONF_PARSER_TERMINATOR
};
static conf_parser_t submodule_config[] = {
- { FR_CONF_OFFSET("tls", FR_TYPE_STRING, 0, rlm_eap_fast_t, tls_conf_name) },
+ { FR_CONF_OFFSET("tls", rlm_eap_fast_t, tls_conf_name) },
- { FR_CONF_OFFSET("default_provisioning_eap_type", FR_TYPE_STRING, 0, rlm_eap_fast_t, default_provisioning_method_name), .dflt = "mschapv2" },
+ { FR_CONF_OFFSET("default_provisioning_eap_type", rlm_eap_fast_t, default_provisioning_method_name), .dflt = "mschapv2" },
- { FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, rlm_eap_fast_t, virtual_server) },
- { FR_CONF_OFFSET("cipher_list", FR_TYPE_STRING, 0, rlm_eap_fast_t, cipher_list) },
+ { FR_CONF_OFFSET_FLAGS("virtual_server", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, rlm_eap_fast_t, virtual_server) },
+ { FR_CONF_OFFSET("cipher_list", rlm_eap_fast_t, cipher_list) },
- { FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOL, 0, rlm_eap_fast_t, req_client_cert), .dflt = "no" },
+ { FR_CONF_OFFSET("require_client_cert", rlm_eap_fast_t, req_client_cert), .dflt = "no" },
- { FR_CONF_OFFSET("pac_lifetime", FR_TYPE_TIME_DELTA, 0, rlm_eap_fast_t, pac_lifetime), .dflt = "604800" },
- { FR_CONF_OFFSET("authority_identity", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_eap_fast_t, authority_identity) },
- { FR_CONF_OFFSET("pac_opaque_key", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_eap_fast_t, pac_opaque_key) },
+ { FR_CONF_OFFSET("pac_lifetime", rlm_eap_fast_t, pac_lifetime), .dflt = "604800" },
+ { FR_CONF_OFFSET_FLAGS("authority_identity", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_eap_fast_t, authority_identity) },
+ { FR_CONF_OFFSET_FLAGS("pac_opaque_key", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_eap_fast_t, pac_opaque_key) },
CONF_PARSER_TERMINATOR
};
} rlm_eap_gtc_t;
static conf_parser_t submodule_config[] = {
- { FR_CONF_OFFSET("challenge", FR_TYPE_STRING, 0, rlm_eap_gtc_t, challenge), .dflt = "Password: " },
- { FR_CONF_OFFSET("auth_type", FR_TYPE_VOID, 0, rlm_eap_gtc_t, auth_type), .func = auth_type_parse, .dflt = "pap" },
+ { FR_CONF_OFFSET("challenge", rlm_eap_gtc_t, challenge), .dflt = "Password: " },
+ { FR_CONF_OFFSET_FLAGS("auth_type", FR_TYPE_VOID, 0, rlm_eap_gtc_t, auth_type), .func = auth_type_parse, .dflt = "pap" },
CONF_PARSER_TERMINATOR
};
} rlm_eap_mschapv2_t;
static conf_parser_t submodule_config[] = {
- { FR_CONF_OFFSET("with_ntdomain_hack", FR_TYPE_BOOL, 0, rlm_eap_mschapv2_t, with_ntdomain_hack), .dflt = "no" },
+ { FR_CONF_OFFSET("with_ntdomain_hack", rlm_eap_mschapv2_t, with_ntdomain_hack), .dflt = "no" },
- { FR_CONF_OFFSET("auth_type", FR_TYPE_VOID, 0, rlm_eap_mschapv2_t, auth_type), .func = auth_type_parse, .dflt = "mschap" },
- { FR_CONF_OFFSET("send_error", FR_TYPE_BOOL, 0, rlm_eap_mschapv2_t, send_error), .dflt = "no" },
- { FR_CONF_OFFSET("identity", FR_TYPE_STRING, 0, rlm_eap_mschapv2_t, identity) },
+ { FR_CONF_OFFSET_FLAGS("auth_type", FR_TYPE_VOID, 0, rlm_eap_mschapv2_t, auth_type), .func = auth_type_parse, .dflt = "mschap" },
+ { FR_CONF_OFFSET("send_error", rlm_eap_mschapv2_t, send_error), .dflt = "no" },
+ { FR_CONF_OFFSET("identity", rlm_eap_mschapv2_t, identity) },
CONF_PARSER_TERMINATOR
};
} rlm_eap_peap_t;
static conf_parser_t submodule_config[] = {
- { FR_CONF_OFFSET("tls", FR_TYPE_STRING, 0, rlm_eap_peap_t, tls_conf_name) },
+ { FR_CONF_OFFSET("tls", rlm_eap_peap_t, tls_conf_name) },
- { FR_CONF_DEPRECATED("copy_request_to_tunnel", FR_TYPE_BOOL, 0, rlm_eap_peap_t, NULL), .dflt = "no" },
+ { FR_CONF_DEPRECATED("copy_request_to_tunnel", rlm_eap_peap_t, NULL), .dflt = "no" },
- { FR_CONF_DEPRECATED("use_tunneled_reply", FR_TYPE_BOOL, 0, rlm_eap_peap_t, NULL), .dflt = "no" },
+ { FR_CONF_DEPRECATED("use_tunneled_reply", rlm_eap_peap_t, NULL), .dflt = "no" },
#ifdef WITH_PROXY
- { FR_CONF_OFFSET("proxy_tunneled_request_as_eap", FR_TYPE_BOOL, 0, rlm_eap_peap_t, proxy_tunneled_request_as_eap), .dflt = "yes" },
+ { FR_CONF_OFFSET("proxy_tunneled_request_as_eap", rlm_eap_peap_t, proxy_tunneled_request_as_eap), .dflt = "yes" },
#endif
- { FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, rlm_eap_peap_t, virtual_server) },
+ { FR_CONF_OFFSET_FLAGS("virtual_server", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, rlm_eap_peap_t, virtual_server) },
- { FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOL, 0, rlm_eap_peap_t, req_client_cert), .dflt = "no" },
+ { FR_CONF_OFFSET("require_client_cert", rlm_eap_peap_t, req_client_cert), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
#define MSK_EMSK_LEN (2 * MPPE_KEY_LEN)
static conf_parser_t submodule_config[] = {
- { FR_CONF_OFFSET("group", FR_TYPE_UINT32, 0, rlm_eap_pwd_t, group), .dflt = "19" },
- { FR_CONF_OFFSET("fragment_size", FR_TYPE_UINT32, 0, rlm_eap_pwd_t, fragment_size), .dflt = "1020" },
- { FR_CONF_OFFSET("server_id", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_eap_pwd_t, server_id) },
+ { FR_CONF_OFFSET("group", rlm_eap_pwd_t, group), .dflt = "19" },
+ { FR_CONF_OFFSET("fragment_size", rlm_eap_pwd_t, fragment_size), .dflt = "1020" },
+ { FR_CONF_OFFSET_FLAGS("server_id", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_eap_pwd_t, server_id) },
CONF_PARSER_TERMINATOR
};
#include <freeradius-devel/util/debug.h>
static conf_parser_t submodule_config[] = {
- { FR_CONF_OFFSET("virtual_server", FR_TYPE_VOID, CONF_FLAG_REQUIRED, eap_aka_sim_module_conf_t, virtual_server), .func = virtual_server_cf_parse },
+ { FR_CONF_OFFSET_FLAGS("virtual_server", FR_TYPE_VOID, CONF_FLAG_REQUIRED, eap_aka_sim_module_conf_t, virtual_server), .func = virtual_server_cf_parse },
CONF_PARSER_TERMINATOR
};
} rlm_eap_tls_thread_t;
static conf_parser_t submodule_config[] = {
- { FR_CONF_OFFSET("tls", FR_TYPE_STRING, 0, rlm_eap_tls_t, tls_conf_name) },
+ { FR_CONF_OFFSET("tls", rlm_eap_tls_t, tls_conf_name) },
- { FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOL, 0, rlm_eap_tls_t, req_client_cert), .dflt = "yes" },
- { FR_CONF_OFFSET("include_length", FR_TYPE_BOOL, 0, rlm_eap_tls_t, include_length), .dflt = "yes" },
- { FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING, 0, rlm_eap_tls_t, virtual_server) },
+ { FR_CONF_OFFSET("require_client_cert", rlm_eap_tls_t, req_client_cert), .dflt = "yes" },
+ { FR_CONF_OFFSET("include_length", rlm_eap_tls_t, include_length), .dflt = "yes" },
+ { FR_CONF_OFFSET("virtual_server", rlm_eap_tls_t, virtual_server) },
CONF_PARSER_TERMINATOR
};
static conf_parser_t submodule_config[] = {
- { FR_CONF_OFFSET("tls", FR_TYPE_STRING, 0, rlm_eap_ttls_t, tls_conf_name) },
- { FR_CONF_DEPRECATED("copy_request_to_tunnel", FR_TYPE_BOOL, 0, rlm_eap_ttls_t, NULL), .dflt = "no" },
- { FR_CONF_DEPRECATED("use_tunneled_reply", FR_TYPE_BOOL, 0, rlm_eap_ttls_t, NULL), .dflt = "no" },
- { FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, rlm_eap_ttls_t, virtual_server) },
- { FR_CONF_OFFSET("include_length", FR_TYPE_BOOL, 0, rlm_eap_ttls_t, include_length), .dflt = "yes" },
- { FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOL, 0, rlm_eap_ttls_t, req_client_cert), .dflt = "no" },
+ { FR_CONF_OFFSET("tls", rlm_eap_ttls_t, tls_conf_name) },
+ { FR_CONF_DEPRECATED("copy_request_to_tunnel", rlm_eap_ttls_t, NULL), .dflt = "no" },
+ { FR_CONF_DEPRECATED("use_tunneled_reply", rlm_eap_ttls_t, NULL), .dflt = "no" },
+ { FR_CONF_OFFSET_FLAGS("virtual_server", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, rlm_eap_ttls_t, virtual_server) },
+ { FR_CONF_OFFSET("include_length", rlm_eap_ttls_t, include_length), .dflt = "yes" },
+ { FR_CONF_OFFSET("require_client_cert", rlm_eap_ttls_t, req_client_cert), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
} rlm_escape_t;
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("safe_characters", FR_TYPE_STRING, 0, rlm_escape_t, allowed_chars), .dflt = "@abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-_: /" },
+ { FR_CONF_OFFSET("safe_characters", rlm_escape_t, allowed_chars), .dflt = "@abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-_: /" },
CONF_PARSER_TERMINATOR
};
} rlm_exec_t;
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("wait", FR_TYPE_BOOL, 0, rlm_exec_t, wait), .dflt = "yes" },
- { FR_CONF_OFFSET("input_pairs", 0, CONF_FLAG_TMPL, rlm_exec_t, input_list) },
- { FR_CONF_OFFSET("output_pairs", 0, CONF_FLAG_TMPL, rlm_exec_t, output_list) },
- { FR_CONF_OFFSET("shell_escape", FR_TYPE_BOOL, 0, rlm_exec_t, shell_escape), .dflt = "yes" },
- { FR_CONF_OFFSET("env_inherit", FR_TYPE_BOOL, 0, rlm_exec_t, env_inherit), .dflt = "no" },
+ { FR_CONF_OFFSET("wait", rlm_exec_t, wait), .dflt = "yes" },
+ { FR_CONF_OFFSET("input_pairs", rlm_exec_t, input_list) },
+ { FR_CONF_OFFSET("output_pairs", rlm_exec_t, output_list) },
+ { FR_CONF_OFFSET("shell_escape", rlm_exec_t, shell_escape), .dflt = "yes" },
+ { FR_CONF_OFFSET("env_inherit", rlm_exec_t, env_inherit), .dflt = "no" },
{ FR_CONF_OFFSET_IS_SET("timeout", FR_TYPE_TIME_DELTA, 0, rlm_exec_t, timeout) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_files_t, filename) },
- { FR_CONF_OFFSET("usersfile", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_files_t, usersfile) },
- { FR_CONF_OFFSET("acctusersfile", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_files_t, acct_usersfile) },
- { FR_CONF_OFFSET("auth_usersfile", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_files_t, auth_usersfile) },
- { FR_CONF_OFFSET("postauth_usersfile", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_files_t, postauth_usersfile) },
- { FR_CONF_OFFSET("key", 0, CONF_FLAG_TMPL | CONF_FLAG_NOT_EMPTY, rlm_files_t, key), .dflt = "%{%{Stripped-User-Name} || %{User-Name}}", .quote = T_DOUBLE_QUOTED_STRING },
+ { FR_CONF_OFFSET_FLAGS("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_files_t, filename) },
+ { FR_CONF_OFFSET_FLAGS("usersfile", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_files_t, usersfile) },
+ { FR_CONF_OFFSET_FLAGS("acctusersfile", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_files_t, acct_usersfile) },
+ { FR_CONF_OFFSET_FLAGS("auth_usersfile", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_files_t, auth_usersfile) },
+ { FR_CONF_OFFSET_FLAGS("postauth_usersfile", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_files_t, postauth_usersfile) },
+ { FR_CONF_OFFSET_FLAGS("key", 0, CONF_FLAG_TMPL | CONF_FLAG_NOT_EMPTY, rlm_files_t, key), .dflt = "%{%{Stripped-User-Name} || %{User-Name}}", .quote = T_DOUBLE_QUOTED_STRING },
CONF_PARSER_TERMINATOR
};
}
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, rlm_icmp_t, interface) },
- { FR_CONF_OFFSET("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, rlm_icmp_t, src_ipaddr) },
- { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, 0, rlm_icmp_t, timeout), .dflt = "1s" },
+ { FR_CONF_OFFSET("interface", rlm_icmp_t, interface) },
+ { FR_CONF_OFFSET_FLAGS("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, rlm_icmp_t, src_ipaddr) },
+ { FR_CONF_OFFSET("timeout", rlm_icmp_t, timeout), .dflt = "1s" },
CONF_PARSER_TERMINATOR
};
* be used.
*/
- { FR_CONF_OFFSET("allow_unassigned", FR_TYPE_BOOL, 0, rlm_idn_t, allow_unassigned), .dflt = "no" },
- { FR_CONF_OFFSET("use_std3_ascii_rules", FR_TYPE_BOOL, 0, rlm_idn_t, use_std3_ascii_rules), .dflt = "yes" },
+ { FR_CONF_OFFSET("allow_unassigned", rlm_idn_t, allow_unassigned), .dflt = "no" },
+ { FR_CONF_OFFSET("use_std3_ascii_rules", rlm_idn_t, use_std3_ascii_rules), .dflt = "yes" },
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("uri", FR_TYPE_STRING, 0, rlm_imap_t, uri) },
- { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, 0, rlm_imap_t, timeout), .dflt = "5.0" },
- { FR_CONF_OFFSET("tls", 0, CONF_FLAG_SUBSECTION, rlm_imap_t, tls), .subcs = (void const *) fr_curl_tls_config },//!<loading the tls values
- { FR_CONF_OFFSET("connection", 0, CONF_FLAG_SUBSECTION, rlm_imap_t, conn_config), .subcs = (void const *) fr_curl_conn_config },
+ { FR_CONF_OFFSET("uri", rlm_imap_t, uri) },
+ { FR_CONF_OFFSET("timeout", rlm_imap_t, timeout), .dflt = "5.0" },
+ { FR_CONF_OFFSET_SUBSECTION("tls", 0, rlm_imap_t, tls, fr_curl_tls_config ) },//!<loading the tls values
+ { FR_CONF_OFFSET_SUBSECTION("connection", 0, rlm_imap_t, conn_config, fr_curl_conn_config ) },
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, rlm_isc_dhcp_t, filename) },
- { FR_CONF_OFFSET("debug", FR_TYPE_BOOL, 0, rlm_isc_dhcp_t, debug) },
- { FR_CONF_OFFSET("pedantic", FR_TYPE_BOOL, 0, rlm_isc_dhcp_t, pedantic) },
+ { FR_CONF_OFFSET_FLAGS("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, rlm_isc_dhcp_t, filename) },
+ { FR_CONF_OFFSET("debug", rlm_isc_dhcp_t, debug) },
+ { FR_CONF_OFFSET("pedantic", rlm_isc_dhcp_t, pedantic) },
CONF_PARSER_TERMINATOR
};
static conf_parser_t const module_config[] = {
- { FR_CONF_OFFSET("encode", 0, CONF_FLAG_SUBSECTION, rlm_json_t, format),
- .subcs_size = sizeof(fr_json_format_t), .subcs_type = "fr_json_format_t",
- .subcs = (void const *) fr_json_format_config },
+ { FR_CONF_OFFSET_SUBSECTION("encode", 0, rlm_json_t, format, fr_json_format_config),
+ .subcs_size = sizeof(fr_json_format_t), .subcs_type = "fr_json_format_t" },
CONF_PARSER_TERMINATOR
};
#include "krb5.h"
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("keytab", FR_TYPE_STRING, 0, rlm_krb5_t, keytabname) },
- { FR_CONF_OFFSET("service_principal", FR_TYPE_STRING, 0, rlm_krb5_t, service_princ) },
+ { FR_CONF_OFFSET("keytab", rlm_krb5_t, keytabname) },
+ { FR_CONF_OFFSET("service_principal", rlm_krb5_t, service_princ) },
CONF_PARSER_TERMINATOR
};
};
static conf_parser_t profile_config[] = {
- { FR_CONF_OFFSET("scope", FR_TYPE_INT32, 0, rlm_ldap_t, profile_scope), .dflt = "base",
+ { FR_CONF_OFFSET("scope", rlm_ldap_t, profile_scope), .dflt = "base",
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = fr_ldap_scope, .len = &fr_ldap_scope_len } },
- { FR_CONF_OFFSET("attribute", FR_TYPE_STRING, 0, rlm_ldap_t, profile_attr) },
- { FR_CONF_OFFSET("attribute_suspend", FR_TYPE_STRING, 0, rlm_ldap_t, profile_attr_suspend) },
+ { FR_CONF_OFFSET("attribute", rlm_ldap_t, profile_attr) },
+ { FR_CONF_OFFSET("attribute_suspend", rlm_ldap_t, profile_attr_suspend) },
CONF_PARSER_TERMINATOR
};
* User configuration
*/
static conf_parser_t user_config[] = {
- { FR_CONF_OFFSET("scope", FR_TYPE_INT32, 0, rlm_ldap_t, userobj_scope), .dflt = "sub",
+ { FR_CONF_OFFSET("scope", rlm_ldap_t, userobj_scope), .dflt = "sub",
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = fr_ldap_scope, .len = &fr_ldap_scope_len } },
- { FR_CONF_OFFSET("sort_by", FR_TYPE_STRING, 0, rlm_ldap_t, userobj_sort_by) },
+ { FR_CONF_OFFSET("sort_by", rlm_ldap_t, userobj_sort_by) },
- { FR_CONF_OFFSET("access_attribute", FR_TYPE_STRING, 0, rlm_ldap_t, userobj_access_attr) },
- { FR_CONF_OFFSET("access_positive", FR_TYPE_BOOL, 0, rlm_ldap_t, access_positive), .dflt = "yes" },
- { FR_CONF_OFFSET("access_value_negate", FR_TYPE_STRING, 0, rlm_ldap_t, access_value_negate), .dflt = "false" },
- { FR_CONF_OFFSET("access_value_suspend", FR_TYPE_STRING, 0, rlm_ldap_t, access_value_suspend), .dflt = "suspended" },
+ { FR_CONF_OFFSET("access_attribute", rlm_ldap_t, userobj_access_attr) },
+ { FR_CONF_OFFSET("access_positive", rlm_ldap_t, access_positive), .dflt = "yes" },
+ { FR_CONF_OFFSET("access_value_negate", rlm_ldap_t, access_value_negate), .dflt = "false" },
+ { FR_CONF_OFFSET("access_value_suspend", rlm_ldap_t, access_value_suspend), .dflt = "suspended" },
CONF_PARSER_TERMINATOR
};
* Group configuration
*/
static conf_parser_t group_config[] = {
- { FR_CONF_OFFSET("filter", FR_TYPE_STRING, 0, rlm_ldap_t, groupobj_filter) },
- { FR_CONF_OFFSET("scope", FR_TYPE_INT32, 0, rlm_ldap_t, groupobj_scope), .dflt = "sub",
+ { FR_CONF_OFFSET("filter", rlm_ldap_t, groupobj_filter) },
+ { FR_CONF_OFFSET("scope", rlm_ldap_t, groupobj_scope), .dflt = "sub",
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = fr_ldap_scope, .len = &fr_ldap_scope_len } },
- { FR_CONF_OFFSET("name_attribute", FR_TYPE_STRING, 0, rlm_ldap_t, groupobj_name_attr), .dflt = "cn" },
- { FR_CONF_OFFSET("membership_attribute", FR_TYPE_STRING, 0, rlm_ldap_t, userobj_membership_attr) },
- { FR_CONF_OFFSET("membership_filter", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_ldap_t, groupobj_membership_filter) },
- { FR_CONF_OFFSET("cacheable_name", FR_TYPE_BOOL, 0, rlm_ldap_t, cacheable_group_name), .dflt = "no" },
- { FR_CONF_OFFSET("cacheable_dn", FR_TYPE_BOOL, 0, rlm_ldap_t, cacheable_group_dn), .dflt = "no" },
- { FR_CONF_OFFSET("cache_attribute", FR_TYPE_STRING, 0, rlm_ldap_t, cache_attribute) },
- { FR_CONF_OFFSET("group_attribute", FR_TYPE_STRING, 0, rlm_ldap_t, group_attribute) },
- { FR_CONF_OFFSET("allow_dangling_group_ref", FR_TYPE_BOOL, 0, rlm_ldap_t, allow_dangling_group_refs), .dflt = "no" },
+ { FR_CONF_OFFSET("name_attribute", rlm_ldap_t, groupobj_name_attr), .dflt = "cn" },
+ { FR_CONF_OFFSET("membership_attribute", rlm_ldap_t, userobj_membership_attr) },
+ { FR_CONF_OFFSET_FLAGS("membership_filter", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_ldap_t, groupobj_membership_filter) },
+ { FR_CONF_OFFSET("cacheable_name", rlm_ldap_t, cacheable_group_name), .dflt = "no" },
+ { FR_CONF_OFFSET("cacheable_dn", rlm_ldap_t, cacheable_group_dn), .dflt = "no" },
+ { FR_CONF_OFFSET("cache_attribute", rlm_ldap_t, cache_attribute) },
+ { FR_CONF_OFFSET("group_attribute", rlm_ldap_t, group_attribute) },
+ { FR_CONF_OFFSET("allow_dangling_group_ref", rlm_ldap_t, allow_dangling_group_refs), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
* Reference for accounting updates
*/
static const conf_parser_t acct_section_config[] = {
- { FR_CONF_OFFSET("reference", FR_TYPE_STRING, CONF_FLAG_XLAT, ldap_acct_section_t, reference), .dflt = "." },
+ { FR_CONF_OFFSET_FLAGS("reference", FR_TYPE_STRING, CONF_FLAG_XLAT, ldap_acct_section_t, reference), .dflt = "." },
CONF_PARSER_TERMINATOR
};
/*
* Pool config items
*/
- { FR_CONF_OFFSET("server", FR_TYPE_STRING, CONF_FLAG_MULTI, rlm_ldap_t, handle_config.server_str) }, /* Do not set to required */
+ { FR_CONF_OFFSET_FLAGS("server", FR_TYPE_STRING, CONF_FLAG_MULTI, rlm_ldap_t, handle_config.server_str) }, /* Do not set to required */
/*
* Common LDAP conf parsers
*/
FR_LDAP_COMMON_CONF(rlm_ldap_t),
- { FR_CONF_OFFSET("valuepair_attribute", FR_TYPE_STRING, 0, rlm_ldap_t, valuepair_attr) },
+ { FR_CONF_OFFSET("valuepair_attribute", rlm_ldap_t, valuepair_attr) },
#ifdef LDAP_CONTROL_X_SESSION_TRACKING
- { FR_CONF_OFFSET("session_tracking", FR_TYPE_BOOL, 0, rlm_ldap_t, session_tracking), .dflt = "no" },
+ { FR_CONF_OFFSET("session_tracking", rlm_ldap_t, session_tracking), .dflt = "no" },
#endif
#ifdef WITH_EDIR
/* support for eDirectory Universal Password */
- { FR_CONF_OFFSET("edir", FR_TYPE_BOOL, 0, rlm_ldap_t, edir) }, /* NULL defaults to "no" */
+ { FR_CONF_OFFSET("edir", rlm_ldap_t, edir) }, /* NULL defaults to "no" */
/*
* Attempt to bind with the cleartext password we got from eDirectory
* Universal password for additional authorization checks.
*/
- { FR_CONF_OFFSET("edir_autz", FR_TYPE_BOOL, 0, rlm_ldap_t, edir_autz) }, /* NULL defaults to "no" */
+ { FR_CONF_OFFSET("edir_autz", rlm_ldap_t, edir_autz) }, /* NULL defaults to "no" */
#endif
{ FR_CONF_POINTER("user", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) user_config },
{ FR_CONF_POINTER("profile", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) profile_config },
- { FR_CONF_OFFSET("pool", 0, CONF_FLAG_SUBSECTION, rlm_ldap_t, trunk_conf), .subcs = (void const *) fr_trunk_config },
+ { FR_CONF_OFFSET_SUBSECTION("pool", 0, rlm_ldap_t, trunk_conf, fr_trunk_config ) },
- { FR_CONF_OFFSET("bind_pool", 0, CONF_FLAG_SUBSECTION, rlm_ldap_t, bind_trunk_conf),
- .subcs = (void const *) fr_trunk_config },
+ { FR_CONF_OFFSET_SUBSECTION("bind_pool", 0, rlm_ldap_t, bind_trunk_conf, fr_trunk_config ) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t file_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_OUTPUT | CONF_FLAG_XLAT, rlm_linelog_t, file.name) },
- { FR_CONF_OFFSET("permissions", FR_TYPE_UINT32, 0, rlm_linelog_t, file.permissions), .dflt = "0600" },
- { FR_CONF_OFFSET("group", FR_TYPE_STRING, 0, rlm_linelog_t, file.group_str) },
- { FR_CONF_OFFSET("escape_filenames", FR_TYPE_BOOL, 0, rlm_linelog_t, file.escape), .dflt = "no" },
+ { FR_CONF_OFFSET_FLAGS("filename", FR_TYPE_STRING, CONF_FLAG_FILE_OUTPUT | CONF_FLAG_XLAT, rlm_linelog_t, file.name) },
+ { FR_CONF_OFFSET("permissions", rlm_linelog_t, file.permissions), .dflt = "0600" },
+ { FR_CONF_OFFSET("group", rlm_linelog_t, file.group_str) },
+ { FR_CONF_OFFSET("escape_filenames", rlm_linelog_t, file.escape), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t syslog_config[] = {
- { FR_CONF_OFFSET("facility", FR_TYPE_STRING, 0, rlm_linelog_t, syslog.facility) },
- { FR_CONF_OFFSET("severity", FR_TYPE_STRING, 0, rlm_linelog_t, syslog.severity), .dflt = "info" },
+ { FR_CONF_OFFSET("facility", rlm_linelog_t, syslog.facility) },
+ { FR_CONF_OFFSET("severity", rlm_linelog_t, syslog.severity), .dflt = "info" },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t unix_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_linelog_t, unix_sock.path) },
+ { FR_CONF_OFFSET_FLAGS("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_linelog_t, unix_sock.path) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t udp_config[] = {
- { FR_CONF_OFFSET("server", FR_TYPE_COMBO_IP_ADDR, 0, linelog_net_t, dst_ipaddr) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, linelog_net_t, port) },
- { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, 0, linelog_net_t, timeout), .dflt = "1000" },
+ { FR_CONF_OFFSET_FLAGS("server", FR_TYPE_COMBO_IP_ADDR, 0, linelog_net_t, dst_ipaddr) },
+ { FR_CONF_OFFSET("port", linelog_net_t, port) },
+ { FR_CONF_OFFSET("timeout", linelog_net_t, timeout), .dflt = "1000" },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t tcp_config[] = {
- { FR_CONF_OFFSET("server", FR_TYPE_COMBO_IP_ADDR, 0, linelog_net_t, dst_ipaddr) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, linelog_net_t, port) },
- { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, 0, linelog_net_t, timeout), .dflt = "1000" },
+ { FR_CONF_OFFSET_FLAGS("server", FR_TYPE_COMBO_IP_ADDR, 0, linelog_net_t, dst_ipaddr) },
+ { FR_CONF_OFFSET("port", linelog_net_t, port) },
+ { FR_CONF_OFFSET("timeout", linelog_net_t, timeout), .dflt = "1000" },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("destination", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_linelog_t, log_dst_str) },
+ { FR_CONF_OFFSET_FLAGS("destination", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_linelog_t, log_dst_str) },
- { FR_CONF_OFFSET("delimiter", FR_TYPE_STRING, 0, rlm_linelog_t, delimiter), .dflt = "\n" },
- { FR_CONF_OFFSET("format", 0, CONF_FLAG_TMPL, rlm_linelog_t, log_src) },
- { FR_CONF_OFFSET("reference", 0, CONF_FLAG_TMPL, rlm_linelog_t, log_ref) },
- { FR_CONF_OFFSET("header", 0, CONF_FLAG_TMPL, rlm_linelog_t, log_head) },
+ { FR_CONF_OFFSET("delimiter", rlm_linelog_t, delimiter), .dflt = "\n" },
+ { FR_CONF_OFFSET("format", rlm_linelog_t, log_src) },
+ { FR_CONF_OFFSET("reference", rlm_linelog_t, log_ref) },
+ { FR_CONF_OFFSET("header", rlm_linelog_t, log_head) },
/*
* Log destinations
{ FR_CONF_POINTER("file", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) file_config },
{ FR_CONF_POINTER("syslog", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) syslog_config },
{ FR_CONF_POINTER("unix", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) unix_config },
- { FR_CONF_OFFSET("tcp", 0, CONF_FLAG_SUBSECTION, rlm_linelog_t, tcp), .subcs= (void const *) tcp_config },
- { FR_CONF_OFFSET("udp", 0, CONF_FLAG_SUBSECTION, rlm_linelog_t, udp), .subcs = (void const *) udp_config },
+ { FR_CONF_OFFSET_SUBSECTION("tcp", 0, rlm_linelog_t, tcp, tcp_config) },
+ { FR_CONF_OFFSET_SUBSECTION("udp", 0, rlm_linelog_t, udp, udp_config) },
/*
* Deprecated config items
*/
- { FR_CONF_DEPRECATED("filename", FR_TYPE_STRING, CONF_FLAG_FILE_OUTPUT, rlm_linelog_t, file.name) },
- { FR_CONF_DEPRECATED("permissions", FR_TYPE_UINT32, 0, rlm_linelog_t, file.permissions) },
- { FR_CONF_DEPRECATED("group", FR_TYPE_STRING, 0, rlm_linelog_t, file.group_str) },
+ { FR_CONF_DEPRECATED("filename", rlm_linelog_t, file.name) },
+ { FR_CONF_DEPRECATED("permissions", rlm_linelog_t, file.permissions) },
+ { FR_CONF_DEPRECATED("group", rlm_linelog_t, file.group_str) },
- { FR_CONF_DEPRECATED("syslog_facility", FR_TYPE_STRING, 0, rlm_linelog_t, syslog.facility) },
- { FR_CONF_DEPRECATED("syslog_severity", FR_TYPE_STRING, 0, rlm_linelog_t, syslog.severity) },
+ { FR_CONF_DEPRECATED("syslog_facility", rlm_linelog_t, syslog.facility) },
+ { FR_CONF_DEPRECATED("syslog_severity", rlm_linelog_t, syslog.severity) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t file_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_OUTPUT | CONF_FLAG_XLAT, rlm_logtee_t, file.name) },
- { FR_CONF_OFFSET("permissions", FR_TYPE_UINT32, 0, rlm_logtee_t, file.permissions), .dflt = "0600" },
- { FR_CONF_OFFSET("group", FR_TYPE_STRING, 0, rlm_logtee_t, file.group_str) },
- { FR_CONF_OFFSET("escape_filenames", FR_TYPE_BOOL, 0, rlm_logtee_t, file.escape), .dflt = "no" },
+ { FR_CONF_OFFSET_FLAGS("filename", FR_TYPE_STRING, CONF_FLAG_FILE_OUTPUT | CONF_FLAG_XLAT, rlm_logtee_t, file.name) },
+ { FR_CONF_OFFSET("permissions", rlm_logtee_t, file.permissions), .dflt = "0600" },
+ { FR_CONF_OFFSET("group", rlm_logtee_t, file.group_str) },
+ { FR_CONF_OFFSET("escape_filenames", rlm_logtee_t, file.escape), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t unix_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_logtee_t, unix_sock.path) },
+ { FR_CONF_OFFSET_FLAGS("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_logtee_t, unix_sock.path) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t udp_config[] = {
- { FR_CONF_OFFSET("server", FR_TYPE_COMBO_IP_ADDR, 0, logtee_net_t, dst_ipaddr) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, logtee_net_t, port) },
+ { FR_CONF_OFFSET_FLAGS("server", FR_TYPE_COMBO_IP_ADDR, 0, logtee_net_t, dst_ipaddr) },
+ { FR_CONF_OFFSET("port", logtee_net_t, port) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t tcp_config[] = {
- { FR_CONF_OFFSET("server", FR_TYPE_COMBO_IP_ADDR, 0, logtee_net_t, dst_ipaddr) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, logtee_net_t, port) },
+ { FR_CONF_OFFSET_FLAGS("server", FR_TYPE_COMBO_IP_ADDR, 0, logtee_net_t, dst_ipaddr) },
+ { FR_CONF_OFFSET("port", logtee_net_t, port) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("destination", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_logtee_t, log_dst_str) },
- { FR_CONF_OFFSET("buffer_depth", FR_TYPE_SIZE, 0, rlm_logtee_t, buffer_depth), .dflt = "10000" },
+ { FR_CONF_OFFSET_FLAGS("destination", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_logtee_t, log_dst_str) },
+ { FR_CONF_OFFSET_FLAGS("buffer_depth", FR_TYPE_SIZE, 0, rlm_logtee_t, buffer_depth), .dflt = "10000" },
- { FR_CONF_OFFSET("delimiter", FR_TYPE_STRING, 0, rlm_logtee_t, delimiter), .dflt = "\n" },
- { FR_CONF_OFFSET("format", 0, CONF_FLAG_TMPL, rlm_logtee_t, log_fmt), .dflt = "%n - %s", .quote = T_DOUBLE_QUOTED_STRING },
+ { FR_CONF_OFFSET("delimiter", rlm_logtee_t, delimiter), .dflt = "\n" },
+ { FR_CONF_OFFSET("format", rlm_logtee_t, log_fmt), .dflt = "%n - %s", .quote = T_DOUBLE_QUOTED_STRING },
/*
* Log destinations
*/
{ FR_CONF_POINTER("file", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) file_config },
{ FR_CONF_POINTER("unix", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) unix_config },
- { FR_CONF_OFFSET("tcp", 0, CONF_FLAG_SUBSECTION, rlm_logtee_t, tcp), .subcs= (void const *) tcp_config },
- { FR_CONF_OFFSET("udp", 0, CONF_FLAG_SUBSECTION, rlm_logtee_t, udp), .subcs = (void const *) udp_config },
+ { FR_CONF_OFFSET_SUBSECTION("tcp", 0, rlm_logtee_t, tcp, tcp_config) },
+ { FR_CONF_OFFSET_SUBSECTION("udp", 0, rlm_logtee_t, udp, udp_config) },
- { FR_CONF_OFFSET("connection_timeout", FR_TYPE_TIME_DELTA, 0, rlm_logtee_t, connection_timeout), .dflt = "1.0" },
- { FR_CONF_OFFSET("reconnection_delay", FR_TYPE_TIME_DELTA, 0, rlm_logtee_t, reconnection_delay), .dflt = "1.0" },
+ { FR_CONF_OFFSET("connection_timeout", rlm_logtee_t, connection_timeout), .dflt = "1.0" },
+ { FR_CONF_OFFSET("reconnection_delay", rlm_logtee_t, reconnection_delay), .dflt = "1.0" },
CONF_PARSER_TERMINATOR
};
* buffer over-flows.
*/
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED, rlm_lua_t, module), NULL},
- { FR_CONF_OFFSET("func_instantiate", FR_TYPE_STRING, 0, rlm_lua_t, func_instantiate), NULL},
- { FR_CONF_OFFSET("func_detach", FR_TYPE_STRING, 0, rlm_lua_t, func_detach), NULL},
- { FR_CONF_OFFSET("func_authorize", FR_TYPE_STRING, 0, rlm_lua_t, func_authorize), NULL},
- { FR_CONF_OFFSET("func_authenticate", FR_TYPE_STRING, 0, rlm_lua_t, func_authenticate), NULL},
- { FR_CONF_OFFSET("func_accounting", FR_TYPE_STRING, 0, rlm_lua_t, func_accounting), NULL},
- { FR_CONF_OFFSET("func_preacct", FR_TYPE_STRING, 0, rlm_lua_t, func_preacct), NULL},
- { FR_CONF_OFFSET("func_xlat", FR_TYPE_STRING, 0, rlm_lua_t, func_xlat), NULL},
- { FR_CONF_OFFSET("func_post_auth", FR_TYPE_STRING, 0, rlm_lua_t, func_post_auth), NULL},
+ { FR_CONF_OFFSET_FLAGS("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED, rlm_lua_t, module), NULL},
+ { FR_CONF_OFFSET("func_instantiate", rlm_lua_t, func_instantiate), NULL},
+ { FR_CONF_OFFSET("func_detach", rlm_lua_t, func_detach), NULL},
+ { FR_CONF_OFFSET("func_authorize", rlm_lua_t, func_authorize), NULL},
+ { FR_CONF_OFFSET("func_authenticate", rlm_lua_t, func_authenticate), NULL},
+ { FR_CONF_OFFSET("func_accounting", rlm_lua_t, func_accounting), NULL},
+ { FR_CONF_OFFSET("func_preacct", rlm_lua_t, func_preacct), NULL},
+ { FR_CONF_OFFSET("func_xlat", rlm_lua_t, func_xlat), NULL},
+ { FR_CONF_OFFSET("func_post_auth", rlm_lua_t, func_post_auth), NULL},
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED, rlm_mruby_t, filename) },
- { FR_CONF_OFFSET("module", FR_TYPE_STRING, 0, rlm_mruby_t, module_name), .dflt = "Radiusd" },
+ { FR_CONF_OFFSET_FLAGS("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED, rlm_mruby_t, filename) },
+ { FR_CONF_OFFSET("module", rlm_mruby_t, module_name), .dflt = "Radiusd" },
CONF_PARSER_TERMINATOR
};
#define ACB_FR_EXPIRED 0x00020000 //!< Password Expired.
static const conf_parser_t passchange_config[] = {
- { FR_CONF_OFFSET("ntlm_auth", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_mschap_t, ntlm_cpw) },
- { FR_CONF_OFFSET("ntlm_auth_username", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_mschap_t, ntlm_cpw_username) },
- { FR_CONF_OFFSET("ntlm_auth_domain", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_mschap_t, ntlm_cpw_domain) },
- { FR_CONF_OFFSET("local_cpw", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_mschap_t, local_cpw) },
+ { FR_CONF_OFFSET_FLAGS("ntlm_auth", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_mschap_t, ntlm_cpw) },
+ { FR_CONF_OFFSET_FLAGS("ntlm_auth_username", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_mschap_t, ntlm_cpw_username) },
+ { FR_CONF_OFFSET_FLAGS("ntlm_auth_domain", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_mschap_t, ntlm_cpw_domain) },
+ { FR_CONF_OFFSET_FLAGS("local_cpw", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_mschap_t, local_cpw) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t winbind_config[] = {
- { FR_CONF_OFFSET("username", 0, CONF_FLAG_TMPL, rlm_mschap_t, wb_username) },
- { FR_CONF_OFFSET("domain", 0, CONF_FLAG_TMPL, rlm_mschap_t, wb_domain) },
+ { FR_CONF_OFFSET("username", rlm_mschap_t, wb_username) },
+ { FR_CONF_OFFSET("domain", rlm_mschap_t, wb_domain) },
#ifdef WITH_AUTH_WINBIND
- { FR_CONF_OFFSET("retry_with_normalised_username", FR_TYPE_BOOL, 0, rlm_mschap_t, wb_retry_with_normalised_username), .dflt = "no" },
+ { FR_CONF_OFFSET("retry_with_normalised_username", rlm_mschap_t, wb_retry_with_normalised_username), .dflt = "no" },
#endif
CONF_PARSER_TERMINATOR
};
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("normalise", FR_TYPE_BOOL, 0, rlm_mschap_t, normify), .dflt = "yes" },
+ { FR_CONF_OFFSET("normalise", rlm_mschap_t, normify), .dflt = "yes" },
/*
* Cache the password by default.
*/
- { FR_CONF_OFFSET("use_mppe", FR_TYPE_BOOL, 0, rlm_mschap_t, use_mppe), .dflt = "yes" },
- { FR_CONF_OFFSET("require_encryption", FR_TYPE_BOOL, 0, rlm_mschap_t, require_encryption), .dflt = "no" },
- { FR_CONF_OFFSET("require_strong", FR_TYPE_BOOL, 0, rlm_mschap_t, require_strong), .dflt = "no" },
- { FR_CONF_OFFSET("with_ntdomain_hack", FR_TYPE_BOOL, 0, rlm_mschap_t, with_ntdomain_hack), .dflt = "yes" },
- { FR_CONF_OFFSET("ntlm_auth", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_mschap_t, ntlm_auth) },
- { FR_CONF_OFFSET("ntlm_auth_timeout", FR_TYPE_TIME_DELTA, 0, rlm_mschap_t, ntlm_auth_timeout) },
+ { FR_CONF_OFFSET("use_mppe", rlm_mschap_t, use_mppe), .dflt = "yes" },
+ { FR_CONF_OFFSET("require_encryption", rlm_mschap_t, require_encryption), .dflt = "no" },
+ { FR_CONF_OFFSET("require_strong", rlm_mschap_t, require_strong), .dflt = "no" },
+ { FR_CONF_OFFSET("with_ntdomain_hack", rlm_mschap_t, with_ntdomain_hack), .dflt = "yes" },
+ { FR_CONF_OFFSET_FLAGS("ntlm_auth", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_mschap_t, ntlm_auth) },
+ { FR_CONF_OFFSET("ntlm_auth_timeout", rlm_mschap_t, ntlm_auth_timeout) },
{ FR_CONF_POINTER("passchange", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) passchange_config },
- { FR_CONF_OFFSET("allow_retry", FR_TYPE_BOOL, 0, rlm_mschap_t, allow_retry), .dflt = "yes" },
- { FR_CONF_OFFSET("retry_msg", FR_TYPE_STRING, 0, rlm_mschap_t, retry_msg) },
+ { FR_CONF_OFFSET("allow_retry", rlm_mschap_t, allow_retry), .dflt = "yes" },
+ { FR_CONF_OFFSET("retry_msg", rlm_mschap_t, retry_msg) },
#ifdef __APPLE__
- { FR_CONF_OFFSET("use_open_directory", FR_TYPE_BOOL, 0, rlm_mschap_t, open_directory), .dflt = "yes" },
+ { FR_CONF_OFFSET("use_open_directory", rlm_mschap_t, open_directory), .dflt = "yes" },
#endif
{ FR_CONF_POINTER("winbind", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) winbind_config },
/*
* These are now in a subsection above.
*/
- { FR_CONF_DEPRECATED("winbind_username", 0, CONF_FLAG_TMPL, rlm_mschap_t, wb_username) },
- { FR_CONF_DEPRECATED("winbind_domain", 0, CONF_FLAG_TMPL, rlm_mschap_t, wb_domain) },
+ { FR_CONF_DEPRECATED("winbind_username", rlm_mschap_t, wb_username) },
+ { FR_CONF_DEPRECATED("winbind_domain", rlm_mschap_t, wb_domain) },
#ifdef WITH_AUTH_WINBIND
- { FR_CONF_DEPRECATED("winbind_retry_with_normalised_username", FR_TYPE_BOOL, 0, rlm_mschap_t, wb_retry_with_normalised_username) },
+ { FR_CONF_DEPRECATED("winbind_retry_with_normalised_username", rlm_mschap_t, wb_retry_with_normalised_username) },
#endif
CONF_PARSER_TERMINATOR
};
#ifdef HAVE_OPENSSL_OCSP_H
static conf_parser_t ocsp_config[] = {
- { FR_CONF_OFFSET("enable", FR_TYPE_BOOL, 0, fr_tls_ocsp_conf_t, enable), .dflt = "no" },
+ { FR_CONF_OFFSET("enable", fr_tls_ocsp_conf_t, enable), .dflt = "no" },
- { FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING, 0, fr_tls_ocsp_conf_t, cache_server) },
+ { FR_CONF_OFFSET("virtual_server", fr_tls_ocsp_conf_t, cache_server) },
- { FR_CONF_OFFSET("override_cert_url", FR_TYPE_BOOL, 0, fr_tls_ocsp_conf_t, override_url), .dflt = "no" },
- { FR_CONF_OFFSET("url", FR_TYPE_STRING, 0, fr_tls_ocsp_conf_t, url) },
- { FR_CONF_OFFSET("use_nonce", FR_TYPE_BOOL, 0, fr_tls_ocsp_conf_t, use_nonce), .dflt = "yes" },
- { FR_CONF_OFFSET("timeout", FR_TYPE_UINT32, 0, fr_tls_ocsp_conf_t, timeout), .dflt = "yes" },
- { FR_CONF_OFFSET("softfail", FR_TYPE_BOOL, 0, fr_tls_ocsp_conf_t, softfail), .dflt = "no" },
- { FR_CONF_OFFSET("verifycert", FR_TYPE_BOOL, 0, fr_tls_ocsp_conf_t, verifycert), .dflt = "yes" },
+ { FR_CONF_OFFSET("override_cert_url", fr_tls_ocsp_conf_t, override_url), .dflt = "no" },
+ { FR_CONF_OFFSET("url", fr_tls_ocsp_conf_t, url) },
+ { FR_CONF_OFFSET("use_nonce", fr_tls_ocsp_conf_t, use_nonce), .dflt = "yes" },
+ { FR_CONF_OFFSET("timeout", fr_tls_ocsp_conf_t, timeout), .dflt = "yes" },
+ { FR_CONF_OFFSET("softfail", fr_tls_ocsp_conf_t, softfail), .dflt = "no" },
+ { FR_CONF_OFFSET("verifycert", fr_tls_ocsp_conf_t, verifycert), .dflt = "yes" },
CONF_PARSER_TERMINATOR
};
#endif
#ifdef HAVE_OPENSSL_OCSP_H
- { FR_CONF_OFFSET("ocsp", 0, CONF_FLAG_SUBSECTION, fr_tls_conf_t, ocsp), .subcs = (void const *) ocsp_config },
+ { FR_CONF_OFFSET_SUBSECTION("ocsp", 0, fr_tls_conf_t, ocsp, ocsp_config) },
- { FR_CONF_OFFSET("staple", 0, CONF_FLAG_SUBSECTION, fr_tls_conf_t, staple), .subcs = (void const *) ocsp_config },
+ { FR_CONF_OFFSET_SUBSCTION("staple", 0, fr_tls_conf_t, staple, ocsp_config) },
#endif
#ifdef HAVE_OPENSSL_OCSP_H
} rlm_pam_data_t;
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("pam_auth", FR_TYPE_STRING, 0, rlm_pam_t, pam_auth_name) },
+ { FR_CONF_OFFSET("pam_auth", rlm_pam_t, pam_auth_name) },
CONF_PARSER_TERMINATOR
};
typedef unlang_action_t (*pap_auth_func_t)(rlm_rcode_t *p_result, rlm_pap_t const *inst, request_t *request, fr_pair_t const *, fr_value_box_t const *);
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("normalise", FR_TYPE_BOOL, 0, rlm_pap_t, normify), .dflt = "yes" },
+ { FR_CONF_OFFSET("normalise", rlm_pap_t, normify), .dflt = "yes" },
CONF_PARSER_TERMINATOR
};
} rlm_passwd_t;
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED, rlm_passwd_t, filename) },
- { FR_CONF_OFFSET("format", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_passwd_t, format) },
- { FR_CONF_OFFSET("delimiter", FR_TYPE_STRING, 0, rlm_passwd_t, delimiter), .dflt = ":" },
+ { FR_CONF_OFFSET_FLAGS("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED, rlm_passwd_t, filename) },
+ { FR_CONF_OFFSET_FLAGS("format", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_passwd_t, format) },
+ { FR_CONF_OFFSET("delimiter", rlm_passwd_t, delimiter), .dflt = ":" },
- { FR_CONF_OFFSET("ignore_nislike", FR_TYPE_BOOL, 0, rlm_passwd_t, ignore_nislike), .dflt = "yes" },
+ { FR_CONF_OFFSET("ignore_nislike", rlm_passwd_t, ignore_nislike), .dflt = "yes" },
- { FR_CONF_OFFSET("ignore_empty", FR_TYPE_BOOL, 0, rlm_passwd_t, ignore_empty), .dflt = "yes" },
+ { FR_CONF_OFFSET("ignore_empty", rlm_passwd_t, ignore_empty), .dflt = "yes" },
- { FR_CONF_OFFSET("allow_multiple_keys", FR_TYPE_BOOL, 0, rlm_passwd_t, allow_multiple), .dflt = "no" },
+ { FR_CONF_OFFSET("allow_multiple_keys", rlm_passwd_t, allow_multiple), .dflt = "no" },
- { FR_CONF_OFFSET("hash_size", FR_TYPE_UINT32, 0, rlm_passwd_t, hash_size), .dflt = "100" },
+ { FR_CONF_OFFSET("hash_size", 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), FR_TYPE_STRING, 0, rlm_perl_t, func_##_x), \
+#define RLM_PERL_CONF(_x) { FR_CONF_OFFSET("func_" STRINGIFY(_x), rlm_perl_t, func_##_x), \
.data = NULL, .dflt = STRINGIFY(_x), .quote = T_INVALID }
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED, rlm_perl_t, module) },
+ { FR_CONF_OFFSET_FLAGS("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED, rlm_perl_t, module) },
RLM_PERL_CONF(authorize),
RLM_PERL_CONF(authenticate),
RLM_PERL_CONF(preacct),
RLM_PERL_CONF(detach),
- { FR_CONF_OFFSET("perl_flags", FR_TYPE_STRING, 0, rlm_perl_t, perl_flags) },
+ { FR_CONF_OFFSET("perl_flags", rlm_perl_t, perl_flags) },
CONF_PARSER_TERMINATOR
};
};
static conf_parser_t const python_global_config[] = {
- { FR_CONF_OFFSET("path", FR_TYPE_STRING, 0, libpython_global_config_t, path) },
- { FR_CONF_OFFSET("path_include_default", FR_TYPE_BOOL, 0, libpython_global_config_t, path_include_default) },
+ { FR_CONF_OFFSET("path", libpython_global_config_t, path) },
+ { FR_CONF_OFFSET("path_include_default", libpython_global_config_t, path_include_default) },
CONF_PARSER_TERMINATOR
};
*/
static conf_parser_t module_config[] = {
-#define A(x) { FR_CONF_OFFSET("mod_" #x, FR_TYPE_STRING, 0, rlm_python_t, x.module_name), .dflt = "${.module}" }, \
- { FR_CONF_OFFSET("func_" #x, FR_TYPE_STRING, 0, rlm_python_t, x.function_name) },
+#define A(x) { FR_CONF_OFFSET("mod_" #x, rlm_python_t, x.module_name), .dflt = "${.module}" }, \
+ { FR_CONF_OFFSET("func_" #x, rlm_python_t, x.function_name) },
A(instantiate)
A(authorize)
static int status_check_update_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
static conf_parser_t const status_check_config[] = {
- { FR_CONF_OFFSET("type", FR_TYPE_VOID, 0, rlm_radius_t, status_check),
+ { FR_CONF_OFFSET_FLAGS("type", FR_TYPE_VOID, 0, rlm_radius_t, status_check),
.func = status_check_type_parse },
CONF_PARSER_TERMINATOR
};
static conf_parser_t const status_check_update_config[] = {
- { FR_CONF_OFFSET("update", 0, CONF_FLAG_SUBSECTION | CONF_FLAG_REQUIRED, rlm_radius_t, status_check_map),
+ { FR_CONF_OFFSET_FLAGS("update", 0, CONF_FLAG_SUBSECTION | CONF_FLAG_REQUIRED, rlm_radius_t, status_check_map),
.name2 = CF_IDENT_ANY,
.func = status_check_update_parse },
- { FR_CONF_OFFSET("num_answers_to_alive", FR_TYPE_UINT32, 0, rlm_radius_t, num_answers_to_alive), .dflt = STRINGIFY(3) },
+ { FR_CONF_OFFSET("num_answers_to_alive", rlm_radius_t, num_answers_to_alive), .dflt = STRINGIFY(3) },
CONF_PARSER_TERMINATOR
};
* Retransmission intervals for the packets we support.
*/
static conf_parser_t auth_config[] = {
- { FR_CONF_OFFSET("initial_rtx_time", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_ACCESS_REQUEST].irt), .dflt = STRINGIFY(2) },
- { FR_CONF_OFFSET("max_rtx_time", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_ACCESS_REQUEST].mrt), .dflt = STRINGIFY(16) },
- { FR_CONF_OFFSET("max_rtx_count", FR_TYPE_UINT32, 0, rlm_radius_t, retry[FR_RADIUS_CODE_ACCESS_REQUEST].mrc), .dflt = STRINGIFY(5) },
- { FR_CONF_OFFSET("max_rtx_duration", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_ACCESS_REQUEST].mrd), .dflt = STRINGIFY(30) },
+ { FR_CONF_OFFSET("initial_rtx_time", rlm_radius_t, retry[FR_RADIUS_CODE_ACCESS_REQUEST].irt), .dflt = STRINGIFY(2) },
+ { FR_CONF_OFFSET("max_rtx_time", rlm_radius_t, retry[FR_RADIUS_CODE_ACCESS_REQUEST].mrt), .dflt = STRINGIFY(16) },
+ { FR_CONF_OFFSET("max_rtx_count", rlm_radius_t, retry[FR_RADIUS_CODE_ACCESS_REQUEST].mrc), .dflt = STRINGIFY(5) },
+ { FR_CONF_OFFSET("max_rtx_duration", rlm_radius_t, retry[FR_RADIUS_CODE_ACCESS_REQUEST].mrd), .dflt = STRINGIFY(30) },
CONF_PARSER_TERMINATOR
};
static conf_parser_t acct_config[] = {
- { FR_CONF_OFFSET("initial_rtx_time", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_ACCOUNTING_REQUEST].irt), .dflt = STRINGIFY(2) },
- { FR_CONF_OFFSET("max_rtx_time", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_ACCOUNTING_REQUEST].mrt), .dflt = STRINGIFY(5) },
- { FR_CONF_OFFSET("max_rtx_count", FR_TYPE_UINT32, 0, rlm_radius_t, retry[FR_RADIUS_CODE_ACCOUNTING_REQUEST].mrc), .dflt = STRINGIFY(1) },
- { FR_CONF_OFFSET("max_rtx_duration", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_ACCOUNTING_REQUEST].mrd), .dflt = STRINGIFY(30) },
+ { FR_CONF_OFFSET("initial_rtx_time", rlm_radius_t, retry[FR_RADIUS_CODE_ACCOUNTING_REQUEST].irt), .dflt = STRINGIFY(2) },
+ { FR_CONF_OFFSET("max_rtx_time", rlm_radius_t, retry[FR_RADIUS_CODE_ACCOUNTING_REQUEST].mrt), .dflt = STRINGIFY(5) },
+ { FR_CONF_OFFSET("max_rtx_count", rlm_radius_t, retry[FR_RADIUS_CODE_ACCOUNTING_REQUEST].mrc), .dflt = STRINGIFY(1) },
+ { FR_CONF_OFFSET("max_rtx_duration", rlm_radius_t, retry[FR_RADIUS_CODE_ACCOUNTING_REQUEST].mrd), .dflt = STRINGIFY(30) },
CONF_PARSER_TERMINATOR
};
static conf_parser_t status_config[] = {
- { FR_CONF_OFFSET("initial_rtx_time", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_STATUS_SERVER].irt), .dflt = STRINGIFY(2) },
- { FR_CONF_OFFSET("max_rtx_time", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_STATUS_SERVER].mrt), .dflt = STRINGIFY(5) },
- { FR_CONF_OFFSET("max_rtx_count", FR_TYPE_UINT32, 0, rlm_radius_t, retry[FR_RADIUS_CODE_STATUS_SERVER].mrc), .dflt = STRINGIFY(5) },
- { FR_CONF_OFFSET("max_rtx_duration", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_STATUS_SERVER].mrd), .dflt = STRINGIFY(30) },
+ { FR_CONF_OFFSET("initial_rtx_time", rlm_radius_t, retry[FR_RADIUS_CODE_STATUS_SERVER].irt), .dflt = STRINGIFY(2) },
+ { FR_CONF_OFFSET("max_rtx_time", rlm_radius_t, retry[FR_RADIUS_CODE_STATUS_SERVER].mrt), .dflt = STRINGIFY(5) },
+ { FR_CONF_OFFSET("max_rtx_count", rlm_radius_t, retry[FR_RADIUS_CODE_STATUS_SERVER].mrc), .dflt = STRINGIFY(5) },
+ { FR_CONF_OFFSET("max_rtx_duration", rlm_radius_t, retry[FR_RADIUS_CODE_STATUS_SERVER].mrd), .dflt = STRINGIFY(30) },
CONF_PARSER_TERMINATOR
};
static conf_parser_t coa_config[] = {
- { FR_CONF_OFFSET("initial_rtx_time", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_COA_REQUEST].irt), .dflt = STRINGIFY(2) },
- { FR_CONF_OFFSET("max_rtx_time", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_COA_REQUEST].mrt), .dflt = STRINGIFY(16) },
- { FR_CONF_OFFSET("max_rtx_count", FR_TYPE_UINT32, 0, rlm_radius_t, retry[FR_RADIUS_CODE_COA_REQUEST].mrc), .dflt = STRINGIFY(5) },
- { FR_CONF_OFFSET("max_rtx_duration", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_COA_REQUEST].mrd), .dflt = STRINGIFY(30) },
+ { FR_CONF_OFFSET("initial_rtx_time", rlm_radius_t, retry[FR_RADIUS_CODE_COA_REQUEST].irt), .dflt = STRINGIFY(2) },
+ { FR_CONF_OFFSET("max_rtx_time", rlm_radius_t, retry[FR_RADIUS_CODE_COA_REQUEST].mrt), .dflt = STRINGIFY(16) },
+ { FR_CONF_OFFSET("max_rtx_count", rlm_radius_t, retry[FR_RADIUS_CODE_COA_REQUEST].mrc), .dflt = STRINGIFY(5) },
+ { FR_CONF_OFFSET("max_rtx_duration", rlm_radius_t, retry[FR_RADIUS_CODE_COA_REQUEST].mrd), .dflt = STRINGIFY(30) },
CONF_PARSER_TERMINATOR
};
static conf_parser_t disconnect_config[] = {
- { FR_CONF_OFFSET("initial_rtx_time", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_DISCONNECT_REQUEST].irt), .dflt = STRINGIFY(2) },
- { FR_CONF_OFFSET("max_rtx_time", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_DISCONNECT_REQUEST].mrt), .dflt = STRINGIFY(16) },
- { FR_CONF_OFFSET("max_rtx_count", FR_TYPE_UINT32, 0, rlm_radius_t, retry[FR_RADIUS_CODE_DISCONNECT_REQUEST].mrc), .dflt = STRINGIFY(5) },
- { FR_CONF_OFFSET("max_rtx_duration", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_DISCONNECT_REQUEST].mrd), .dflt = STRINGIFY(30) },
+ { FR_CONF_OFFSET("initial_rtx_time", rlm_radius_t, retry[FR_RADIUS_CODE_DISCONNECT_REQUEST].irt), .dflt = STRINGIFY(2) },
+ { FR_CONF_OFFSET("max_rtx_time", rlm_radius_t, retry[FR_RADIUS_CODE_DISCONNECT_REQUEST].mrt), .dflt = STRINGIFY(16) },
+ { FR_CONF_OFFSET("max_rtx_count", rlm_radius_t, retry[FR_RADIUS_CODE_DISCONNECT_REQUEST].mrc), .dflt = STRINGIFY(5) },
+ { FR_CONF_OFFSET("max_rtx_duration", rlm_radius_t, retry[FR_RADIUS_CODE_DISCONNECT_REQUEST].mrd), .dflt = STRINGIFY(30) },
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
static conf_parser_t const module_config[] = {
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, rlm_radius_t, io_submodule),
+ { FR_CONF_OFFSET_FLAGS("transport", FR_TYPE_VOID, 0, rlm_radius_t, io_submodule),
.func = module_rlm_submodule_parse },
- { FR_CONF_OFFSET("type", FR_TYPE_UINT32, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI | CONF_FLAG_REQUIRED, rlm_radius_t, types),
+ { FR_CONF_OFFSET_FLAGS("type", FR_TYPE_UINT32, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI | CONF_FLAG_REQUIRED, rlm_radius_t, types),
.func = type_parse },
- { FR_CONF_OFFSET("replicate", FR_TYPE_BOOL, 0, rlm_radius_t, replicate) },
+ { FR_CONF_OFFSET("replicate", rlm_radius_t, replicate) },
- { FR_CONF_OFFSET("synchronous", FR_TYPE_BOOL, 0, rlm_radius_t, synchronous) },
+ { FR_CONF_OFFSET("synchronous", rlm_radius_t, synchronous) },
- { FR_CONF_OFFSET("originate", FR_TYPE_BOOL, 0, rlm_radius_t, originate) },
+ { FR_CONF_OFFSET("originate", rlm_radius_t, originate) },
{ FR_CONF_POINTER("status_check", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) status_check_config },
- { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, 0, rlm_radius_t, max_attributes), .dflt = STRINGIFY(RADIUS_MAX_ATTRIBUTES) },
+ { FR_CONF_OFFSET("max_attributes", rlm_radius_t, max_attributes), .dflt = STRINGIFY(RADIUS_MAX_ATTRIBUTES) },
- { FR_CONF_OFFSET("response_window", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, response_window), .dflt = STRINGIFY(20) },
+ { FR_CONF_OFFSET("response_window", rlm_radius_t, response_window), .dflt = STRINGIFY(20) },
- { FR_CONF_OFFSET("zombie_period", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, zombie_period), .dflt = STRINGIFY(40) },
+ { FR_CONF_OFFSET("zombie_period", rlm_radius_t, zombie_period), .dflt = STRINGIFY(40) },
- { FR_CONF_OFFSET("revive_interval", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, revive_interval) },
+ { FR_CONF_OFFSET("revive_interval", rlm_radius_t, revive_interval) },
- { FR_CONF_OFFSET("pool", 0, CONF_FLAG_SUBSECTION, rlm_radius_t, trunk_conf), .subcs = (void const *) fr_trunk_config, },
+ { FR_CONF_OFFSET_SUBSECTION("pool", 0, rlm_radius_t, trunk_conf, fr_trunk_config ) },
CONF_PARSER_TERMINATOR
};
};
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, rlm_radius_udp_t, dst_ipaddr), },
- { FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, 0, rlm_radius_udp_t, dst_ipaddr) },
- { FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, 0, rlm_radius_udp_t, dst_ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, rlm_radius_udp_t, dst_ipaddr), },
+ { FR_CONF_OFFSET_FLAGS("ipv4addr", FR_TYPE_IPV4_ADDR, 0, rlm_radius_udp_t, dst_ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipv6addr", FR_TYPE_IPV6_ADDR, 0, rlm_radius_udp_t, dst_ipaddr) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, rlm_radius_udp_t, dst_port) },
+ { FR_CONF_OFFSET("port", rlm_radius_udp_t, dst_port) },
- { FR_CONF_OFFSET("secret", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_radius_udp_t, secret) },
+ { FR_CONF_OFFSET_FLAGS("secret", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_radius_udp_t, secret) },
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, rlm_radius_udp_t, interface) },
+ { FR_CONF_OFFSET("interface", rlm_radius_udp_t, interface) },
{ FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, rlm_radius_udp_t, recv_buff) },
{ FR_CONF_OFFSET_IS_SET("send_buff", FR_TYPE_UINT32, 0, rlm_radius_udp_t, send_buff) },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, rlm_radius_udp_t, max_packet_size), .dflt = "4096" },
- { FR_CONF_OFFSET("max_send_coalesce", FR_TYPE_UINT16, 0, rlm_radius_udp_t, max_send_coalesce), .dflt = "1024" },
+ { FR_CONF_OFFSET("max_packet_size", rlm_radius_udp_t, max_packet_size), .dflt = "4096" },
+ { FR_CONF_OFFSET("max_send_coalesce", rlm_radius_udp_t, max_send_coalesce), .dflt = "1024" },
- { FR_CONF_OFFSET("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, rlm_radius_udp_t, src_ipaddr) },
- { FR_CONF_OFFSET("src_ipv4addr", FR_TYPE_IPV4_ADDR, 0, rlm_radius_udp_t, src_ipaddr) },
- { FR_CONF_OFFSET("src_ipv6addr", FR_TYPE_IPV6_ADDR, 0, rlm_radius_udp_t, src_ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, rlm_radius_udp_t, src_ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("src_ipv4addr", FR_TYPE_IPV4_ADDR, 0, rlm_radius_udp_t, src_ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("src_ipv6addr", FR_TYPE_IPV6_ADDR, 0, rlm_radius_udp_t, src_ipaddr) },
CONF_PARSER_TERMINATOR
};
} rlm_radutmp_t;
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_OUTPUT, rlm_radutmp_t, filename), .dflt = RADUTMP },
- { FR_CONF_OFFSET("username", FR_TYPE_STRING, CONF_FLAG_SECRET, rlm_radutmp_t, username), .dflt = "%{User-Name}" },
- { FR_CONF_OFFSET("check_with_nas", FR_TYPE_BOOL, 0, rlm_radutmp_t, check_nas), .dflt = "yes" },
- { FR_CONF_OFFSET("permissions", FR_TYPE_UINT32, 0, rlm_radutmp_t, permission), .dflt = "0644" },
- { FR_CONF_OFFSET("caller_id", FR_TYPE_BOOL, 0, rlm_radutmp_t, caller_id_ok), .dflt = "no" },
+ { FR_CONF_OFFSET_FLAGS("filename", FR_TYPE_STRING, CONF_FLAG_FILE_OUTPUT, rlm_radutmp_t, filename), .dflt = RADUTMP },
+ { FR_CONF_OFFSET_FLAGS("username", FR_TYPE_STRING, CONF_FLAG_SECRET, rlm_radutmp_t, username), .dflt = "%{User-Name}" },
+ { FR_CONF_OFFSET("check_with_nas", rlm_radutmp_t, check_nas), .dflt = "yes" },
+ { FR_CONF_OFFSET("permissions", rlm_radutmp_t, permission), .dflt = "0644" },
+ { FR_CONF_OFFSET("caller_id", rlm_radutmp_t, caller_id_ok), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
static int lua_func_body_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
static conf_parser_t module_lua_func[] = {
- { FR_CONF_OFFSET("body", FR_TYPE_STRING, 0, redis_lua_func_t, body), .func = lua_func_body_parse },
- { FR_CONF_OFFSET("read_only", FR_TYPE_BOOL, 0, redis_lua_func_t, read_only) },
+ { FR_CONF_OFFSET("body", redis_lua_func_t, body), .func = lua_func_body_parse },
+ { FR_CONF_OFFSET("read_only", redis_lua_func_t, read_only) },
CONF_PARSER_TERMINATOR
};
};
static conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("wait_num", FR_TYPE_UINT32, 0, rlm_redis_ippool_t, wait_num) },
- { FR_CONF_OFFSET("wait_timeout", FR_TYPE_TIME_DELTA, 0, rlm_redis_ippool_t, wait_timeout) },
+ { FR_CONF_OFFSET("wait_num", rlm_redis_ippool_t, wait_num) },
+ { FR_CONF_OFFSET("wait_timeout", rlm_redis_ippool_t, wait_timeout) },
- { FR_CONF_DEPRECATED("ip_address", 0, CONF_FLAG_TMPL | CONF_FLAG_REQUIRED, rlm_redis_ippool_t, NULL) },
+ { FR_CONF_DEPRECATED("ip_address", rlm_redis_ippool_t, NULL) },
- { FR_CONF_DEPRECATED("reply_attr", 0, CONF_FLAG_TMPL | CONF_FLAG_ATTRIBUTE | CONF_FLAG_REQUIRED, rlm_redis_ippool_t, NULL) },
+ { FR_CONF_DEPRECATED("reply_attr", rlm_redis_ippool_t, NULL) },
- { FR_CONF_OFFSET("ipv4_integer", FR_TYPE_BOOL, 0, rlm_redis_ippool_t, ipv4_integer) },
- { FR_CONF_OFFSET("copy_on_update", FR_TYPE_BOOL, 0, rlm_redis_ippool_t, copy_on_update), .dflt = "yes", .quote = T_BARE_WORD },
+ { FR_CONF_OFFSET("ipv4_integer", rlm_redis_ippool_t, ipv4_integer) },
+ { FR_CONF_OFFSET("copy_on_update", rlm_redis_ippool_t, copy_on_update), .dflt = "yes", .quote = T_BARE_WORD },
/*
* Split out to allow conversion to universal ippool module with
} rlm_rediswho_t;
static conf_parser_t section_config[] = {
- { FR_CONF_OFFSET("insert", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_XLAT, rlm_rediswho_t, insert) },
- { FR_CONF_OFFSET("trim", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_rediswho_t, trim) }, /* required only if trim_count > 0 */
- { FR_CONF_OFFSET("expire", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_XLAT, rlm_rediswho_t, expire) },
+ { FR_CONF_OFFSET_FLAGS("insert", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_XLAT, rlm_rediswho_t, insert) },
+ { FR_CONF_OFFSET_FLAGS("trim", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_rediswho_t, trim) }, /* required only if trim_count > 0 */
+ { FR_CONF_OFFSET_FLAGS("expire", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_XLAT, rlm_rediswho_t, expire) },
CONF_PARSER_TERMINATOR
};
static conf_parser_t module_config[] = {
REDIS_COMMON_CONFIG,
- { FR_CONF_OFFSET("trim_count", FR_TYPE_INT32, 0, rlm_rediswho_t, trim_count), .dflt = "-1" },
+ { FR_CONF_OFFSET("trim_count", rlm_rediswho_t, trim_count), .dflt = "-1" },
/*
* These all smash the same variables, because we don't care about them right now.
}
static const conf_parser_t section_config[] = {
- { FR_CONF_OFFSET("uri", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_rest_section_t, uri), .dflt = "" },
- { FR_CONF_OFFSET("proxy", FR_TYPE_STRING, 0, rlm_rest_section_t, proxy), .func = rest_proxy_parse },
- { FR_CONF_OFFSET("method", FR_TYPE_STRING, 0, rlm_rest_section_t, method_str), .dflt = "GET" },
- { FR_CONF_OFFSET("header", FR_TYPE_STRING, CONF_FLAG_MULTI, rlm_rest_section_t, headers) },
- { FR_CONF_OFFSET("body", FR_TYPE_STRING, 0, rlm_rest_section_t, body_str), .dflt = "none" },
- { FR_CONF_OFFSET("data", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_rest_section_t, data) },
- { FR_CONF_OFFSET("force_to", FR_TYPE_STRING, 0, rlm_rest_section_t, force_to_str) },
+ { FR_CONF_OFFSET_FLAGS("uri", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_rest_section_t, uri), .dflt = "" },
+ { FR_CONF_OFFSET("proxy", rlm_rest_section_t, proxy), .func = rest_proxy_parse },
+ { FR_CONF_OFFSET("method", rlm_rest_section_t, method_str), .dflt = "GET" },
+ { FR_CONF_OFFSET_FLAGS("header", FR_TYPE_STRING, CONF_FLAG_MULTI, rlm_rest_section_t, headers) },
+ { FR_CONF_OFFSET("body", rlm_rest_section_t, body_str), .dflt = "none" },
+ { FR_CONF_OFFSET_FLAGS("data", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_rest_section_t, data) },
+ { FR_CONF_OFFSET("force_to", rlm_rest_section_t, force_to_str) },
/* User authentication */
{ FR_CONF_OFFSET_IS_SET("auth", FR_TYPE_VOID, 0, rlm_rest_section_t, auth),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = http_auth_table, .len = &http_auth_table_len }, .dflt = "none" },
- { FR_CONF_OFFSET("username", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_rest_section_t, username) },
- { FR_CONF_OFFSET("password", FR_TYPE_STRING, CONF_FLAG_SECRET | CONF_FLAG_XLAT, rlm_rest_section_t, password) },
- { FR_CONF_OFFSET("require_auth", FR_TYPE_BOOL, 0, rlm_rest_section_t, require_auth), .dflt = "no" },
+ { FR_CONF_OFFSET_FLAGS("username", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_rest_section_t, username) },
+ { FR_CONF_OFFSET_FLAGS("password", FR_TYPE_STRING, CONF_FLAG_SECRET | CONF_FLAG_XLAT, rlm_rest_section_t, password) },
+ { FR_CONF_OFFSET("require_auth", rlm_rest_section_t, require_auth), .dflt = "no" },
/* Transfer configuration */
- { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, 0, rlm_rest_section_t, timeout), .dflt = "4.0" },
- { FR_CONF_OFFSET("chunk", FR_TYPE_UINT32, 0, rlm_rest_section_t, chunk), .dflt = "0" },
- { FR_CONF_OFFSET("max_body_in", FR_TYPE_SIZE, 0, rlm_rest_section_t, max_body_in), .dflt = "16k" },
+ { FR_CONF_OFFSET("timeout", rlm_rest_section_t, timeout), .dflt = "4.0" },
+ { FR_CONF_OFFSET("chunk", rlm_rest_section_t, chunk), .dflt = "0" },
+ { FR_CONF_OFFSET_FLAGS("max_body_in", FR_TYPE_SIZE, 0, rlm_rest_section_t, max_body_in), .dflt = "16k" },
/* TLS Parameters */
- { FR_CONF_OFFSET("tls", 0, CONF_FLAG_SUBSECTION, rlm_rest_section_t, tls), .subcs = (void const *) fr_curl_tls_config },
+ { FR_CONF_OFFSET_SUBSECTION("tls", 0, rlm_rest_section_t, tls, fr_curl_tls_config) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t xlat_config[] = {
- { FR_CONF_OFFSET("proxy", FR_TYPE_STRING, 0, rlm_rest_section_t, proxy), .func = rest_proxy_parse },
+ { FR_CONF_OFFSET("proxy", rlm_rest_section_t, proxy), .func = rest_proxy_parse },
/* User authentication */
{ FR_CONF_OFFSET_IS_SET("auth", FR_TYPE_VOID, 0, rlm_rest_section_t, auth),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = http_auth_table, .len = &http_auth_table_len }, .dflt = "none" },
- { FR_CONF_OFFSET("header", FR_TYPE_STRING, CONF_FLAG_MULTI, rlm_rest_section_t, headers) },
+ { FR_CONF_OFFSET_FLAGS("header", FR_TYPE_STRING, CONF_FLAG_MULTI, rlm_rest_section_t, headers) },
- { FR_CONF_OFFSET("username", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_rest_section_t, username) },
- { FR_CONF_OFFSET("password", FR_TYPE_STRING, CONF_FLAG_SECRET | CONF_FLAG_XLAT, rlm_rest_section_t, password) },
- { FR_CONF_OFFSET("require_auth", FR_TYPE_BOOL, 0, rlm_rest_section_t, require_auth), .dflt = "no" },
+ { FR_CONF_OFFSET_FLAGS("username", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_rest_section_t, username) },
+ { FR_CONF_OFFSET_FLAGS("password", FR_TYPE_STRING, CONF_FLAG_SECRET | CONF_FLAG_XLAT, rlm_rest_section_t, password) },
+ { FR_CONF_OFFSET("require_auth", rlm_rest_section_t, require_auth), .dflt = "no" },
/* Transfer configuration */
- { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, 0, rlm_rest_section_t, timeout), .dflt = "4.0" },
- { FR_CONF_OFFSET("chunk", FR_TYPE_UINT32, 0, rlm_rest_section_t, chunk), .dflt = "0" },
+ { FR_CONF_OFFSET("timeout", rlm_rest_section_t, timeout), .dflt = "4.0" },
+ { FR_CONF_OFFSET("chunk", rlm_rest_section_t, chunk), .dflt = "0" },
/* TLS Parameters */
- { FR_CONF_OFFSET("tls", 0, CONF_FLAG_SUBSECTION, rlm_rest_section_t, tls), .subcs = (void const *) fr_curl_tls_config },
+ { FR_CONF_OFFSET_SUBSECTION("tls", 0, rlm_rest_section_t, tls, fr_curl_tls_config) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t module_config[] = {
- { FR_CONF_DEPRECATED("connect_timeout", FR_TYPE_TIME_DELTA, 0, rlm_rest_t, connect_timeout) },
- { FR_CONF_OFFSET("connect_proxy", FR_TYPE_STRING, 0, rlm_rest_t, connect_proxy), .func = rest_proxy_parse },
- { FR_CONF_OFFSET("http_negotiation", FR_TYPE_VOID, 0, rlm_rest_t, http_negotiation),
+ { FR_CONF_DEPRECATED("connect_timeout", rlm_rest_t, connect_timeout) },
+ { FR_CONF_OFFSET("connect_proxy", rlm_rest_t, connect_proxy), .func = rest_proxy_parse },
+ { FR_CONF_OFFSET_FLAGS("http_negotiation", FR_TYPE_VOID, 0, rlm_rest_t, http_negotiation),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = http_negotiation_table, .len = &http_negotiation_table_len }, .dflt = "default" },
- { FR_CONF_OFFSET("connection", 0, CONF_FLAG_SUBSECTION, rlm_rest_t, conn_config), .subcs = (void const *) fr_curl_conn_config },
+ { FR_CONF_OFFSET_SUBSECTION("connection", 0, rlm_rest_t, conn_config, fr_curl_conn_config) },
#ifdef CURLPIPE_MULTIPLEX
- { FR_CONF_OFFSET("multiplex", FR_TYPE_BOOL, 0, rlm_rest_t, multiplex), .dflt = "yes" },
+ { FR_CONF_OFFSET("multiplex", rlm_rest_t, multiplex), .dflt = "yes" },
#endif
#ifndef NDEBUG
- { FR_CONF_OFFSET("fail_header_decode", FR_TYPE_BOOL, 0, rlm_rest_t, fail_header_decode), .dflt = "no" },
- { FR_CONF_OFFSET("fail_body_decode", FR_TYPE_BOOL, 0, rlm_rest_t, fail_body_decode), .dflt = "no" },
+ { FR_CONF_OFFSET("fail_header_decode", rlm_rest_t, fail_header_decode), .dflt = "no" },
+ { FR_CONF_OFFSET("fail_body_decode", rlm_rest_t, fail_body_decode), .dflt = "no" },
#endif
CONF_PARSER_TERMINATOR
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("timer_expire", FR_TYPE_UINT32, 0, rlm_securid_t, timer_limit), .dflt = "600" },
- { FR_CONF_OFFSET("max_sessions", FR_TYPE_UINT32, 0, rlm_securid_t, max_sessions), .dflt = "2048" },
- { FR_CONF_OFFSET("max_trips_per_session", FR_TYPE_UINT32, 0, rlm_securid_t, max_trips_per_session) },
- { FR_CONF_OFFSET("max_round_trips", FR_TYPE_UINT32, 0, rlm_securid_t, max_trips_per_session), .dflt = "6" },
+ { FR_CONF_OFFSET("timer_expire", rlm_securid_t, timer_limit), .dflt = "600" },
+ { FR_CONF_OFFSET("max_sessions", rlm_securid_t, max_sessions), .dflt = "2048" },
+ { FR_CONF_OFFSET("max_trips_per_session", rlm_securid_t, max_trips_per_session) },
+ { FR_CONF_OFFSET("max_round_trips", rlm_securid_t, max_trips_per_session), .dflt = "6" },
CONF_PARSER_TERMINATOR
};
static size_t m3ua_traffic_mode_table_len = NUM_ELEMENTS(m3ua_traffic_mode_table);
static const conf_parser_t sctp_config[] = {
- { FR_CONF_OFFSET("server", FR_TYPE_COMBO_IP_ADDR, 0, rlm_sigtran_t, conn_conf.sctp_dst_ipaddr) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, rlm_sigtran_t, conn_conf.sctp_dst_port), .dflt = "2905" },
+ { FR_CONF_OFFSET_FLAGS("server", FR_TYPE_COMBO_IP_ADDR, 0, rlm_sigtran_t, conn_conf.sctp_dst_ipaddr) },
+ { FR_CONF_OFFSET("port", rlm_sigtran_t, conn_conf.sctp_dst_port), .dflt = "2905" },
- { FR_CONF_OFFSET("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, rlm_sigtran_t, conn_conf.sctp_src_ipaddr ) },
- { FR_CONF_OFFSET("src_port", FR_TYPE_UINT16, 0, rlm_sigtran_t, conn_conf.sctp_src_port), .dflt = "0" },
+ { FR_CONF_OFFSET_FLAGS("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, rlm_sigtran_t, conn_conf.sctp_src_ipaddr ) },
+ { FR_CONF_OFFSET("src_port", rlm_sigtran_t, conn_conf.sctp_src_port), .dflt = "0" },
- { FR_CONF_OFFSET("timeout", FR_TYPE_UINT32, 0, rlm_sigtran_t, conn_conf.sctp_timeout), .dflt = "5" },
+ { FR_CONF_OFFSET("timeout", rlm_sigtran_t, conn_conf.sctp_timeout), .dflt = "5" },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t m3ua_route[] = {
{ FR_CONF_OFFSET_IS_SET("dpc", FR_TYPE_UINT32, 0, sigtran_m3ua_route_t, dpc) },
- { FR_CONF_OFFSET("opc", FR_TYPE_UINT32 , CONF_FLAG_MULTI, sigtran_m3ua_route_t, opc) },
- { FR_CONF_OFFSET("si", FR_TYPE_UINT32 , CONF_FLAG_MULTI, sigtran_m3ua_route_t, si) },
+ { FR_CONF_OFFSET_FLAGS("opc", FR_TYPE_UINT32 , CONF_FLAG_MULTI, sigtran_m3ua_route_t, opc) },
+ { FR_CONF_OFFSET_FLAGS("si", FR_TYPE_UINT32 , CONF_FLAG_MULTI, sigtran_m3ua_route_t, si) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t m3ua_config[] = {
- { FR_CONF_OFFSET("link_index", FR_TYPE_UINT16, 0, rlm_sigtran_t, conn_conf.m3ua_link_index) },
- { FR_CONF_OFFSET("routing_ctx", FR_TYPE_UINT16, 0, rlm_sigtran_t, conn_conf.m3ua_routing_context) },
- { FR_CONF_OFFSET("traffic_mode", FR_TYPE_STRING, 0, rlm_sigtran_t, conn_conf.m3ua_traffic_mode_str), .dflt = "loadshare" },
- { FR_CONF_OFFSET("ack_timeout", FR_TYPE_UINT32, 0, rlm_sigtran_t, conn_conf.m3ua_ack_timeout), .dflt = "2" },
- { FR_CONF_OFFSET("beat_interval", FR_TYPE_UINT32, 0, rlm_sigtran_t, conn_conf.m3ua_beat_interval), .dflt = "0" },
+ { FR_CONF_OFFSET("link_index", rlm_sigtran_t, conn_conf.m3ua_link_index) },
+ { FR_CONF_OFFSET("routing_ctx", rlm_sigtran_t, conn_conf.m3ua_routing_context) },
+ { FR_CONF_OFFSET("traffic_mode", rlm_sigtran_t, conn_conf.m3ua_traffic_mode_str), .dflt = "loadshare" },
+ { FR_CONF_OFFSET("ack_timeout", rlm_sigtran_t, conn_conf.m3ua_ack_timeout), .dflt = "2" },
+ { FR_CONF_OFFSET("beat_interval", rlm_sigtran_t, conn_conf.m3ua_beat_interval), .dflt = "0" },
{ FR_CONF_OFFSET_IS_SET("route", 0, CONF_FLAG_SUBSECTION, rlm_sigtran_t, conn_conf.m3ua_routes), .subcs = (void const *) m3ua_route },
};
static const conf_parser_t mtp3_config[] = {
- { FR_CONF_OFFSET("dpc", FR_TYPE_UINT32, CONF_FLAG_REQUIRED, rlm_sigtran_t, conn_conf.mtp3_dpc) },
- { FR_CONF_OFFSET("opc", FR_TYPE_UINT32, CONF_FLAG_REQUIRED, rlm_sigtran_t, conn_conf.mtp3_opc) },
+ { FR_CONF_OFFSET_FLAGS("dpc", FR_TYPE_UINT32, CONF_FLAG_REQUIRED, rlm_sigtran_t, conn_conf.mtp3_dpc) },
+ { FR_CONF_OFFSET_FLAGS("opc", FR_TYPE_UINT32, CONF_FLAG_REQUIRED, rlm_sigtran_t, conn_conf.mtp3_opc) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t sccp_global_title[] = {
- { FR_CONF_OFFSET("address", FR_TYPE_STRING, 0, sigtran_sccp_global_title_t, address) },
+ { FR_CONF_OFFSET("address", sigtran_sccp_global_title_t, address) },
{ FR_CONF_OFFSET_IS_SET("tt", FR_TYPE_UINT8, 0, sigtran_sccp_global_title_t, tt) },
{ FR_CONF_OFFSET_IS_SET("nai", FR_TYPE_UINT8, 0, sigtran_sccp_global_title_t, nai) },
{ FR_CONF_OFFSET_IS_SET("np", FR_TYPE_UINT8, 0, sigtran_sccp_global_title_t, np) },
};
static const conf_parser_t sccp_config[] = {
- { FR_CONF_OFFSET("ai8", FR_TYPE_BOOL, 0, rlm_sigtran_t, conn_conf.sccp_ai8) },
- { FR_CONF_OFFSET("route_on_ssn", FR_TYPE_BOOL, 0, rlm_sigtran_t, conn_conf.sccp_route_on_ssn) },
+ { FR_CONF_OFFSET("ai8", rlm_sigtran_t, conn_conf.sccp_ai8) },
+ { FR_CONF_OFFSET("route_on_ssn", rlm_sigtran_t, conn_conf.sccp_route_on_ssn) },
- { FR_CONF_OFFSET("called", 0, CONF_FLAG_SUBSECTION, rlm_sigtran_t, conn_conf.sccp_called), .subcs = (void const *) sccp_address },
- { FR_CONF_OFFSET("calling", 0, CONF_FLAG_SUBSECTION, rlm_sigtran_t, conn_conf.sccp_calling), .subcs = (void const *) sccp_address },
+ { FR_CONF_OFFSET_SUBSECTION("called", 0, rlm_sigtran_t, conn_conf.sccp_called, .subcs = sccp_address) },
+ { FR_CONF_OFFSET_SUBSECTION("calling", 0, rlm_sigtran_t, conn_conf.sccp_calling, .subcs = sccp_address) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t map_config[] = {
- { FR_CONF_OFFSET("version", 0, CONF_FLAG_TMPL, rlm_sigtran_t, conn_conf.map_version), .dflt = "2", .quote = T_BARE_WORD},
+ { FR_CONF_OFFSET("version", rlm_sigtran_t, conn_conf.map_version), .dflt = "2", .quote = T_BARE_WORD},
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("uri", FR_TYPE_STRING, 0, rlm_smtp_t, uri) },
- { FR_CONF_OFFSET("template_directory", FR_TYPE_STRING, 0, rlm_smtp_t, template_dir) },
- { FR_CONF_OFFSET("attachments", 0, CONF_FLAG_TMPL | CONF_FLAG_MULTI, rlm_smtp_t, attachments), .dflt = "&SMTP-Attachments[*]", .quote = T_BARE_WORD},
- { FR_CONF_OFFSET("sender_address", 0, CONF_FLAG_TMPL | CONF_FLAG_MULTI, rlm_smtp_t, sender_address) },
- { FR_CONF_OFFSET("envelope_address", FR_TYPE_STRING, 0, rlm_smtp_t, envelope_address) },
- { FR_CONF_OFFSET("recipients", 0, CONF_FLAG_TMPL | CONF_FLAG_MULTI, rlm_smtp_t, recipient_addrs),
- .dflt = "&SMTP-Recipients[*]", .quote = T_BARE_WORD},
- { FR_CONF_OFFSET("TO", 0, CONF_FLAG_TMPL | CONF_FLAG_MULTI, rlm_smtp_t, to_addrs),
- .dflt = "&SMTP-TO[*]", .quote = T_BARE_WORD},
- { FR_CONF_OFFSET("CC", 0, CONF_FLAG_TMPL | CONF_FLAG_MULTI, rlm_smtp_t, cc_addrs),
- .dflt = "&SMTP-CC[*]", .quote = T_BARE_WORD},
- { FR_CONF_OFFSET("BCC", 0, CONF_FLAG_TMPL | CONF_FLAG_MULTI, rlm_smtp_t, bcc_addrs),
- .dflt = "&SMTP-BCC[*]", .quote = T_BARE_WORD },
- { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, 0, rlm_smtp_t, timeout) },
- { FR_CONF_OFFSET("set_date", FR_TYPE_BOOL, 0, rlm_smtp_t, set_date), .dflt = "yes" },
- { FR_CONF_OFFSET("tls", 0, CONF_FLAG_SUBSECTION, rlm_smtp_t, tls), .subcs = (void const *) fr_curl_tls_config },//!<loading the tls values
- { FR_CONF_OFFSET("connection", 0, CONF_FLAG_SUBSECTION, rlm_smtp_t, conn_config), .subcs = (void const *) fr_curl_conn_config },
+ { FR_CONF_OFFSET("uri", rlm_smtp_t, uri) },
+ { FR_CONF_OFFSET("template_directory", rlm_smtp_t, template_dir) },
+ { FR_CONF_OFFSET("attachments", rlm_smtp_t, attachments), .dflt = "&SMTP-Attachments[*]", .quote = T_BARE_WORD},
+ { FR_CONF_OFFSET("sender_address", rlm_smtp_t, sender_address) },
+ { FR_CONF_OFFSET("envelope_address", rlm_smtp_t, envelope_address) },
+ { FR_CONF_OFFSET("recipients", rlm_smtp_t, recipient_addrs), .dflt = "&SMTP-Recipients[*]", .quote = T_BARE_WORD},
+ { FR_CONF_OFFSET("TO", rlm_smtp_t, to_addrs), .dflt = "&SMTP-TO[*]", .quote = T_BARE_WORD},
+ { FR_CONF_OFFSET("CC", rlm_smtp_t, cc_addrs), .dflt = "&SMTP-CC[*]", .quote = T_BARE_WORD},
+ { FR_CONF_OFFSET("BCC", rlm_smtp_t, bcc_addrs), .dflt = "&SMTP-BCC[*]", .quote = T_BARE_WORD },
+ { FR_CONF_OFFSET("timeout", rlm_smtp_t, timeout) },
+ { FR_CONF_OFFSET("set_date", rlm_smtp_t, set_date), .dflt = "yes" },
+ { FR_CONF_OFFSET_SUBSECTION("tls", 0, rlm_smtp_t, tls, fr_curl_tls_config) },//!<loading the tls values
+ { FR_CONF_OFFSET_SUBSECTION("connection", 0, rlm_smtp_t, conn_config, fr_curl_conn_config) },
CONF_PARSER_TERMINATOR
};
} rlm_sometimes_t;
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("rcode", FR_TYPE_STRING, 0, rlm_sometimes_t, rcode_str), .dflt = "fail" },
- { FR_CONF_OFFSET("key", 0, CONF_FLAG_TMPL | CONF_FLAG_ATTRIBUTE, rlm_sometimes_t, key), .dflt = "&User-Name", .quote = T_BARE_WORD },
- { FR_CONF_OFFSET("percentage", FR_TYPE_FLOAT32, 0, rlm_sometimes_t, percentage), .dflt = "0" },
+ { FR_CONF_OFFSET("rcode", rlm_sometimes_t, rcode_str), .dflt = "fail" },
+ { FR_CONF_OFFSET_FLAGS("key", 0, CONF_FLAG_TMPL | CONF_FLAG_ATTRIBUTE, rlm_sometimes_t, key), .dflt = "&User-Name", .quote = T_BARE_WORD },
+ { FR_CONF_OFFSET("percentage", rlm_sometimes_t, percentage), .dflt = "0" },
CONF_PARSER_TERMINATOR
};
static size_t verify_cert_table_len = NUM_ELEMENTS(verify_cert_table);
static conf_parser_t load_balance_dc_aware_config[] = {
- { FR_CONF_OFFSET("local_dc", FR_TYPE_STRING, 0, rlm_sql_cassandra_t, lbdc_local_dc) },
- { FR_CONF_OFFSET("hosts_per_remote_dc", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, lbdc_hosts_per_remote_dc), .dflt = "0" },
- { FR_CONF_OFFSET("allow_remote_dcs_for_local_cl", FR_TYPE_BOOL, 0, rlm_sql_cassandra_t, lbdc_allow_remote_dcs_for_local_cl), .dflt = "no" },
+ { FR_CONF_OFFSET("local_dc", rlm_sql_cassandra_t, lbdc_local_dc) },
+ { FR_CONF_OFFSET("hosts_per_remote_dc", rlm_sql_cassandra_t, lbdc_hosts_per_remote_dc), .dflt = "0" },
+ { FR_CONF_OFFSET("allow_remote_dcs_for_local_cl", rlm_sql_cassandra_t, lbdc_allow_remote_dcs_for_local_cl), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
static conf_parser_t latency_aware_routing_config[] = {
- { FR_CONF_OFFSET("exclusion_threshold", FR_TYPE_FLOAT64, 0, rlm_sql_cassandra_t, lar_exclusion_threshold), .dflt = "2.0" },
- { FR_CONF_OFFSET("scale", FR_TYPE_TIME_DELTA, 0, rlm_sql_cassandra_t, lar_scale), .dflt = "0.1" },
- { FR_CONF_OFFSET("retry_period", FR_TYPE_TIME_DELTA, 0, rlm_sql_cassandra_t, lar_retry_period), .dflt = "10" },
- { FR_CONF_OFFSET("update_rate", FR_TYPE_TIME_DELTA, 0, rlm_sql_cassandra_t, lar_update_rate), .dflt = "0.1" },
- { FR_CONF_OFFSET("min_measured", FR_TYPE_UINT64, 0, rlm_sql_cassandra_t, lar_min_measured), .dflt = "50" },
+ { FR_CONF_OFFSET("exclusion_threshold", rlm_sql_cassandra_t, lar_exclusion_threshold), .dflt = "2.0" },
+ { FR_CONF_OFFSET("scale", rlm_sql_cassandra_t, lar_scale), .dflt = "0.1" },
+ { FR_CONF_OFFSET("retry_period", rlm_sql_cassandra_t, lar_retry_period), .dflt = "10" },
+ { FR_CONF_OFFSET("update_rate", rlm_sql_cassandra_t, lar_update_rate), .dflt = "0.1" },
+ { FR_CONF_OFFSET("min_measured", rlm_sql_cassandra_t, lar_min_measured), .dflt = "50" },
CONF_PARSER_TERMINATOR
};
static conf_parser_t tls_config[] = {
- { FR_CONF_OFFSET("ca_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_cassandra_t, tls_ca_file) },
- { FR_CONF_OFFSET("certificate_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_cassandra_t, tls_certificate_file) },
- { FR_CONF_OFFSET("private_key_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_cassandra_t, tls_private_key_file) },
- { FR_CONF_OFFSET("private_key_password", FR_TYPE_STRING, CONF_FLAG_SECRET, rlm_sql_cassandra_t, tls_private_key_password) },
+ { FR_CONF_OFFSET_FLAGS("ca_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_cassandra_t, tls_ca_file) },
+ { FR_CONF_OFFSET_FLAGS("certificate_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_cassandra_t, tls_certificate_file) },
+ { FR_CONF_OFFSET_FLAGS("private_key_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_cassandra_t, tls_private_key_file) },
+ { FR_CONF_OFFSET_FLAGS("private_key_password", FR_TYPE_STRING, CONF_FLAG_SECRET, rlm_sql_cassandra_t, tls_private_key_password) },
- { FR_CONF_OFFSET("verify_cert", FR_TYPE_STRING, 0, rlm_sql_cassandra_t, tls_verify_cert_str) },
+ { FR_CONF_OFFSET("verify_cert", rlm_sql_cassandra_t, tls_verify_cert_str) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t driver_config[] = {
- { FR_CONF_OFFSET("consistency", FR_TYPE_STRING, 0, rlm_sql_cassandra_t, consistency_str), .dflt = "quorum" },
+ { FR_CONF_OFFSET("consistency", rlm_sql_cassandra_t, consistency_str), .dflt = "quorum" },
- { FR_CONF_OFFSET("protocol_version", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, protocol_version) },
+ { FR_CONF_OFFSET("protocol_version", rlm_sql_cassandra_t, protocol_version) },
- { FR_CONF_OFFSET("connections_per_host", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, connections_per_host) },
+ { FR_CONF_OFFSET("connections_per_host", rlm_sql_cassandra_t, connections_per_host) },
/*
* The below functions was deprecated in 2.10
*/
#if (CASS_VERSION_MAJOR >= 2 && CASS_VERSION_MINOR >= 10)
- { FR_CONF_DEPRECATED("connections_per_host_max", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, connections_per_host_max) },
- { FR_CONF_DEPRECATED("io_flush_requests_max", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, io_flush_requests_max) },
+ { FR_CONF_DEPRECATED("connections_per_host_max", rlm_sql_cassandra_t, connections_per_host_max) },
+ { FR_CONF_DEPRECATED("io_flush_requests_max", rlm_sql_cassandra_t, io_flush_requests_max) },
- { FR_CONF_DEPRECATED("pending_requests_high", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, pending_requests_high) },
- { FR_CONF_DEPRECATED("pending_requests_low", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, pending_requests_low) },
+ { FR_CONF_DEPRECATED("pending_requests_high", rlm_sql_cassandra_t, pending_requests_high) },
+ { FR_CONF_DEPRECATED("pending_requests_low", rlm_sql_cassandra_t, pending_requests_low) },
- { FR_CONF_DEPRECATED("write_bytes_high", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, write_bytes_high) },
- { FR_CONF_DEPRECATED("write_bytes_low", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, write_bytes_low) },
+ { FR_CONF_DEPRECATED("write_bytes_high", rlm_sql_cassandra_t, write_bytes_high) },
+ { FR_CONF_DEPRECATED("write_bytes_low", rlm_sql_cassandra_t, write_bytes_low) },
- { FR_CONF_DEPRECATED("spawn_threshold", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, spawn_threshold) },
- { FR_CONF_DEPRECATED("spawn_max", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, spawn_max) },
- { FR_CONF_DEPRECATED("spawn_retry_delay", FR_TYPE_TIME_DELTA, 0, rlm_sql_cassandra_t, spawn_retry_delay) },
+ { FR_CONF_DEPRECATED("spawn_threshold", rlm_sql_cassandra_t, spawn_threshold) },
+ { FR_CONF_DEPRECATED("spawn_max", rlm_sql_cassandra_t, spawn_max) },
+ { FR_CONF_DEPRECATED("spawn_retry_delay", rlm_sql_cassandra_t, spawn_retry_delay) },
#else
- { FR_CONF_OFFSET("connections_per_host_max", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, connections_per_host_max) },
- { FR_CONF_OFFSET("io_flush_requests_max", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, io_flush_requests_max) },
+ { FR_CONF_OFFSET("connections_per_host_max", rlm_sql_cassandra_t, connections_per_host_max) },
+ { FR_CONF_OFFSET("io_flush_requests_max", rlm_sql_cassandra_t, io_flush_requests_max) },
- { FR_CONF_OFFSET("pending_requests_high", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, pending_requests_high) },
- { FR_CONF_OFFSET("pending_requests_low", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, pending_requests_low) },
+ { FR_CONF_OFFSET("pending_requests_high", rlm_sql_cassandra_t, pending_requests_high) },
+ { FR_CONF_OFFSET("pending_requests_low", rlm_sql_cassandra_t, pending_requests_low) },
- { FR_CONF_OFFSET("write_bytes_high", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, write_bytes_high) },
- { FR_CONF_OFFSET("write_bytes_low", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, write_bytes_low) },
+ { FR_CONF_OFFSET("write_bytes_high", rlm_sql_cassandra_t, write_bytes_high) },
+ { FR_CONF_OFFSET("write_bytes_low", rlm_sql_cassandra_t, write_bytes_low) },
- { FR_CONF_OFFSET("spawn_threshold", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, spawn_threshold) },
- { FR_CONF_OFFSET("spawn_max", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, spawn_max) },
+ { FR_CONF_OFFSET("spawn_threshold", rlm_sql_cassandra_t, spawn_threshold) },
+ { FR_CONF_OFFSET("spawn_max", rlm_sql_cassandra_t, spawn_max) },
{ FR_CONF_OFFSET_IS_SET("spawn_retry_delay", FR_TYPE_TIME_DELTA, 0, rlm_sql_cassandra_t, spawn_retry_delay) },
#endif
- { FR_CONF_OFFSET("io_threads", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, io_threads) },
- { FR_CONF_OFFSET("io_queue_size", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, io_queue_size) },
+ { FR_CONF_OFFSET("io_threads", rlm_sql_cassandra_t, io_threads) },
+ { FR_CONF_OFFSET("io_queue_size", rlm_sql_cassandra_t, io_queue_size) },
- { FR_CONF_OFFSET("event_queue_size", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, event_queue_size) },
+ { FR_CONF_OFFSET("event_queue_size", rlm_sql_cassandra_t, event_queue_size) },
{ FR_CONF_POINTER("load_balance_dc_aware", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) load_balance_dc_aware_config },
- { FR_CONF_OFFSET("load_balance_round_robin", FR_TYPE_BOOL, 0, rlm_sql_cassandra_t, load_balance_round_robin), .dflt = "no" },
+ { FR_CONF_OFFSET("load_balance_round_robin", rlm_sql_cassandra_t, load_balance_round_robin), .dflt = "no" },
- { FR_CONF_OFFSET("token_aware_routing", FR_TYPE_BOOL, 0, rlm_sql_cassandra_t, token_aware_routing), .dflt = "yes" },
+ { FR_CONF_OFFSET("token_aware_routing", rlm_sql_cassandra_t, token_aware_routing), .dflt = "yes" },
{ FR_CONF_POINTER("latency_aware_routing", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) latency_aware_routing_config },
- { FR_CONF_OFFSET("tcp_keepalive", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, tcp_keepalive) },
- { FR_CONF_OFFSET("tcp_nodelay", FR_TYPE_BOOL, 0, rlm_sql_cassandra_t, tcp_nodelay), .dflt = "no" },
+ { FR_CONF_OFFSET("tcp_keepalive", rlm_sql_cassandra_t, tcp_keepalive) },
+ { FR_CONF_OFFSET("tcp_nodelay", rlm_sql_cassandra_t, tcp_nodelay), .dflt = "no" },
{ FR_CONF_POINTER("tls", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) tls_config },
CONF_PARSER_TERMINATOR
} rlm_sql_mysql_t;
static conf_parser_t tls_config[] = {
- { FR_CONF_OFFSET("ca_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_mysql_t, tls_ca_file) },
- { FR_CONF_OFFSET("ca_path", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_mysql_t, tls_ca_path) },
- { FR_CONF_OFFSET("certificate_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_mysql_t, tls_certificate_file) },
- { FR_CONF_OFFSET("private_key_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_mysql_t, tls_private_key_file) },
+ { FR_CONF_OFFSET_FLAGS("ca_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_mysql_t, tls_ca_file) },
+ { FR_CONF_OFFSET_FLAGS("ca_path", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_mysql_t, tls_ca_path) },
+ { FR_CONF_OFFSET_FLAGS("certificate_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_mysql_t, tls_certificate_file) },
+ { FR_CONF_OFFSET_FLAGS("private_key_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_mysql_t, tls_private_key_file) },
#if HAVE_CRL_OPTIONS
- { FR_CONF_OFFSET("crl_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_mysql_t, tls_crl_file) },
- { FR_CONF_OFFSET("crl_path", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_mysql_t, tls_crl_path) },
+ { FR_CONF_OFFSET_FLAGS("crl_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_mysql_t, tls_crl_file) },
+ { FR_CONF_OFFSET_FLAGS("crl_path", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_mysql_t, tls_crl_path) },
#endif
/*
* MySQL Specific TLS attributes
*/
- { FR_CONF_OFFSET("cipher", FR_TYPE_STRING, 0, rlm_sql_mysql_t, tls_cipher) },
+ { FR_CONF_OFFSET("cipher", rlm_sql_mysql_t, tls_cipher) },
/*
* The closest thing we have to these options in other modules is
* has provided an invalid list of flags.
*/
#if HAVE_TLS_OPTIONS
- { FR_CONF_OFFSET("tls_required", FR_TYPE_BOOL, 0, rlm_sql_mysql_t, tls_required) },
+ { FR_CONF_OFFSET("tls_required", rlm_sql_mysql_t, tls_required) },
# if HAVE_TLS_VERIFY_OPTIONS
- { FR_CONF_OFFSET("check_cert", FR_TYPE_BOOL, 0, rlm_sql_mysql_t, tls_check_cert) },
- { FR_CONF_OFFSET("check_cert_cn", FR_TYPE_BOOL, 0, rlm_sql_mysql_t, tls_check_cert_cn) },
+ { FR_CONF_OFFSET("check_cert", rlm_sql_mysql_t, tls_check_cert) },
+ { FR_CONF_OFFSET("check_cert_cn", rlm_sql_mysql_t, tls_check_cert_cn) },
# endif
#endif
CONF_PARSER_TERMINATOR
static const conf_parser_t driver_config[] = {
{ FR_CONF_POINTER("tls", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) tls_config },
- { FR_CONF_OFFSET("warnings", FR_TYPE_STRING, 0, rlm_sql_mysql_t, warnings_str), .dflt = "auto" },
+ { FR_CONF_OFFSET("warnings", rlm_sql_mysql_t, warnings_str), .dflt = "auto" },
CONF_PARSER_TERMINATOR
};
} rlm_sql_oracle_conn_t;
static const conf_parser_t spool_config[] = {
- { FR_CONF_OFFSET("stmt_cache_size", FR_TYPE_UINT32, 0, rlm_sql_oracle_t, stmt_cache_size), .dflt = "32" },
- { FR_CONF_OFFSET("timeout", FR_TYPE_UINT32, 0, rlm_sql_oracle_t, spool_timeout), .dflt = "0" },
- { FR_CONF_OFFSET("min", FR_TYPE_UINT32, 0, rlm_sql_oracle_t, spool_min), .dflt = "1" },
- { FR_CONF_OFFSET("max", FR_TYPE_UINT32, 0, rlm_sql_oracle_t, spool_max), .dflt = "2" },
- { FR_CONF_OFFSET("inc", FR_TYPE_UINT32, 0, rlm_sql_oracle_t, spool_inc), .dflt = "1" },
+ { FR_CONF_OFFSET("stmt_cache_size", rlm_sql_oracle_t, stmt_cache_size), .dflt = "32" },
+ { FR_CONF_OFFSET("timeout", rlm_sql_oracle_t, spool_timeout), .dflt = "0" },
+ { FR_CONF_OFFSET("min", rlm_sql_oracle_t, spool_min), .dflt = "1" },
+ { FR_CONF_OFFSET("max", rlm_sql_oracle_t, spool_max), .dflt = "2" },
+ { FR_CONF_OFFSET("inc", rlm_sql_oracle_t, spool_inc), .dflt = "1" },
CONF_PARSER_TERMINATOR
};
} rlm_sql_postgres_conn_t;
static conf_parser_t driver_config[] = {
- { FR_CONF_OFFSET("send_application_name", FR_TYPE_BOOL, 0, rlm_sql_postgresql_t, send_application_name), .dflt = "yes" },
+ { FR_CONF_OFFSET("send_application_name", rlm_sql_postgresql_t, send_application_name), .dflt = "yes" },
CONF_PARSER_TERMINATOR
};
} rlm_sql_sqlite_t;
static const conf_parser_t driver_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_OUTPUT | CONF_FLAG_REQUIRED, rlm_sql_sqlite_t, filename) },
+ { FR_CONF_OFFSET_FLAGS("filename", FR_TYPE_STRING, CONF_FLAG_FILE_OUTPUT | CONF_FLAG_REQUIRED, rlm_sql_sqlite_t, filename) },
CONF_PARSER_TERMINATOR
};
* So we can do pass2 xlat checks on the queries.
*/
static const conf_parser_t query_config[] = {
- { FR_CONF_OFFSET("query", FR_TYPE_STRING, CONF_FLAG_MULTI | CONF_FLAG_XLAT, rlm_sql_config_t, accounting.query) },
+ { FR_CONF_OFFSET_FLAGS("query", FR_TYPE_STRING, CONF_FLAG_MULTI | CONF_FLAG_XLAT, rlm_sql_config_t, accounting.query) },
CONF_PARSER_TERMINATOR
};
};
static const conf_parser_t acct_config[] = {
- { FR_CONF_OFFSET("reference", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sql_config_t, accounting.reference), .dflt = ".query" },
- { FR_CONF_OFFSET("logfile", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sql_config_t, accounting.logfile) },
+ { FR_CONF_OFFSET_FLAGS("reference", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sql_config_t, accounting.reference), .dflt = ".query" },
+ { FR_CONF_OFFSET_FLAGS("logfile", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sql_config_t, accounting.logfile) },
{ FR_CONF_POINTER("type", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) type_config },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t postauth_config[] = {
- { FR_CONF_OFFSET("reference", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sql_config_t, postauth.reference), .dflt = ".query" },
- { FR_CONF_OFFSET("logfile", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sql_config_t, postauth.logfile) },
+ { FR_CONF_OFFSET_FLAGS("reference", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sql_config_t, postauth.reference), .dflt = ".query" },
+ { FR_CONF_OFFSET_FLAGS("logfile", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sql_config_t, postauth.logfile) },
- { FR_CONF_OFFSET("query", FR_TYPE_STRING, CONF_FLAG_MULTI | CONF_FLAG_XLAT, rlm_sql_config_t, postauth.query) },
+ { FR_CONF_OFFSET_FLAGS("query", FR_TYPE_STRING, CONF_FLAG_MULTI | CONF_FLAG_XLAT, rlm_sql_config_t, postauth.query) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("driver", FR_TYPE_VOID, 0, rlm_sql_t, driver_submodule), .dflt = "null",
+ { FR_CONF_OFFSET_FLAGS("driver", FR_TYPE_VOID, 0, rlm_sql_t, driver_submodule), .dflt = "null",
.func = module_rlm_submodule_parse },
- { FR_CONF_OFFSET("server", FR_TYPE_STRING, 0, 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_UINT32, 0, rlm_sql_config_t, sql_port), .dflt = "0" },
- { FR_CONF_OFFSET("login", FR_TYPE_STRING, 0, rlm_sql_config_t, sql_login), .dflt = "" },
- { FR_CONF_OFFSET("password", FR_TYPE_STRING, CONF_FLAG_SECRET, rlm_sql_config_t, sql_password), .dflt = "" },
- { FR_CONF_OFFSET("radius_db", FR_TYPE_STRING, 0, rlm_sql_config_t, sql_db), .dflt = "radius" },
- { FR_CONF_OFFSET("read_groups", FR_TYPE_BOOL, 0, rlm_sql_config_t, read_groups), .dflt = "yes" },
- { FR_CONF_OFFSET("sql_user_name", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sql_config_t, query_user), .dflt = "" },
- { FR_CONF_OFFSET("group_attribute", FR_TYPE_STRING, 0, rlm_sql_config_t, group_attribute) },
- { FR_CONF_OFFSET("logfile", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sql_config_t, logfile) },
- { FR_CONF_OFFSET("open_query", FR_TYPE_STRING, 0, rlm_sql_config_t, connect_query) },
-
- { FR_CONF_OFFSET("authorize_check_query", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY | CONF_FLAG_XLAT, rlm_sql_config_t, authorize_check_query) },
- { FR_CONF_OFFSET("authorize_reply_query", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY | CONF_FLAG_XLAT, rlm_sql_config_t, authorize_reply_query) },
-
- { FR_CONF_OFFSET("authorize_group_check_query", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY | CONF_FLAG_XLAT, rlm_sql_config_t, authorize_group_check_query) },
- { FR_CONF_OFFSET("authorize_group_reply_query", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY | CONF_FLAG_XLAT, rlm_sql_config_t, authorize_group_reply_query) },
- { FR_CONF_OFFSET("group_membership_query", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY | CONF_FLAG_XLAT, rlm_sql_config_t, groupmemb_query) },
- { FR_CONF_OFFSET("safe_characters", FR_TYPE_STRING, 0, rlm_sql_config_t, allowed_chars), .dflt = "@abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-_: /" },
+ { FR_CONF_OFFSET("server", rlm_sql_config_t, sql_server), .dflt = "" }, /* Must be zero length so drivers can determine if it was set */
+ { FR_CONF_OFFSET("port", rlm_sql_config_t, sql_port), .dflt = "0" },
+ { FR_CONF_OFFSET("login", rlm_sql_config_t, sql_login), .dflt = "" },
+ { FR_CONF_OFFSET_FLAGS("password", FR_TYPE_STRING, CONF_FLAG_SECRET, rlm_sql_config_t, sql_password), .dflt = "" },
+ { FR_CONF_OFFSET("radius_db", rlm_sql_config_t, sql_db), .dflt = "radius" },
+ { FR_CONF_OFFSET("read_groups", rlm_sql_config_t, read_groups), .dflt = "yes" },
+ { FR_CONF_OFFSET_FLAGS("sql_user_name", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sql_config_t, query_user), .dflt = "" },
+ { FR_CONF_OFFSET("group_attribute", rlm_sql_config_t, group_attribute) },
+ { FR_CONF_OFFSET_FLAGS("logfile", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sql_config_t, logfile) },
+ { FR_CONF_OFFSET("open_query", rlm_sql_config_t, connect_query) },
+
+ { FR_CONF_OFFSET_FLAGS("authorize_check_query", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY | CONF_FLAG_XLAT, rlm_sql_config_t, authorize_check_query) },
+ { FR_CONF_OFFSET_FLAGS("authorize_reply_query", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY | CONF_FLAG_XLAT, rlm_sql_config_t, authorize_reply_query) },
+
+ { FR_CONF_OFFSET_FLAGS("authorize_group_check_query", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY | CONF_FLAG_XLAT, rlm_sql_config_t, authorize_group_check_query) },
+ { FR_CONF_OFFSET_FLAGS("authorize_group_reply_query", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY | CONF_FLAG_XLAT, rlm_sql_config_t, authorize_group_reply_query) },
+ { FR_CONF_OFFSET_FLAGS("group_membership_query", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY | CONF_FLAG_XLAT, rlm_sql_config_t, groupmemb_query) },
+ { FR_CONF_OFFSET("safe_characters", rlm_sql_config_t, allowed_chars), .dflt = "@abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-_: /" },
/*
* This only works for a few drivers.
*/
- { FR_CONF_OFFSET("query_timeout", FR_TYPE_TIME_DELTA, 0, rlm_sql_config_t, query_timeout) },
+ { FR_CONF_OFFSET("query_timeout", rlm_sql_config_t, query_timeout) },
{ FR_CONF_POINTER("accounting", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) acct_config },
} rlm_sqlcounter_t;
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("sql_module_instance", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_sqlcounter_t, sqlmod_inst) },
+ { FR_CONF_OFFSET_FLAGS("sql_module_instance", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_sqlcounter_t, sqlmod_inst) },
- { FR_CONF_OFFSET("query", FR_TYPE_STRING, CONF_FLAG_XLAT | CONF_FLAG_REQUIRED, rlm_sqlcounter_t, query) },
- { FR_CONF_OFFSET("reset", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_sqlcounter_t, reset) },
+ { FR_CONF_OFFSET_FLAGS("query", FR_TYPE_STRING, CONF_FLAG_XLAT | CONF_FLAG_REQUIRED, rlm_sqlcounter_t, query) },
+ { FR_CONF_OFFSET_FLAGS("reset", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_sqlcounter_t, reset) },
- { FR_CONF_OFFSET("key", 0, CONF_FLAG_TMPL | CONF_FLAG_NOT_EMPTY, rlm_sqlcounter_t, key), .dflt = "%{%{Stripped-User-Name} || %{User-Name}}", .quote = T_DOUBLE_QUOTED_STRING },
+ { FR_CONF_OFFSET_FLAGS("key", 0, CONF_FLAG_TMPL | CONF_FLAG_NOT_EMPTY, rlm_sqlcounter_t, key), .dflt = "%{%{Stripped-User-Name} || %{User-Name}}", .quote = T_DOUBLE_QUOTED_STRING },
- { FR_CONF_OFFSET("reset_period_start_name", 0, CONF_FLAG_TMPL | CONF_FLAG_ATTRIBUTE, rlm_sqlcounter_t, start_attr),
+ { FR_CONF_OFFSET_FLAGS("reset_period_start_name", 0, CONF_FLAG_TMPL | CONF_FLAG_ATTRIBUTE, rlm_sqlcounter_t, start_attr),
.dflt = "&control.${.:instance}-Start" },
- { FR_CONF_OFFSET("reset_period_end_name", 0, CONF_FLAG_TMPL | CONF_FLAG_ATTRIBUTE, rlm_sqlcounter_t, end_attr),
+ { FR_CONF_OFFSET_FLAGS("reset_period_end_name", 0, CONF_FLAG_TMPL | CONF_FLAG_ATTRIBUTE, rlm_sqlcounter_t, end_attr),
.dflt = "&control.${.:instance}-End" },
/* Just used to register a paircmp against */
- { FR_CONF_OFFSET("counter_name", 0, CONF_FLAG_TMPL | CONF_FLAG_ATTRIBUTE | CONF_FLAG_REQUIRED, rlm_sqlcounter_t, paircmp_attr) },
- { FR_CONF_OFFSET("check_name", 0, CONF_FLAG_TMPL | CONF_FLAG_ATTRIBUTE | CONF_FLAG_REQUIRED, rlm_sqlcounter_t, limit_attr) },
+ { FR_CONF_OFFSET_FLAGS("counter_name", 0, CONF_FLAG_TMPL | CONF_FLAG_ATTRIBUTE | CONF_FLAG_REQUIRED, rlm_sqlcounter_t, paircmp_attr) },
+ { FR_CONF_OFFSET_FLAGS("check_name", 0, CONF_FLAG_TMPL | CONF_FLAG_ATTRIBUTE | CONF_FLAG_REQUIRED, rlm_sqlcounter_t, limit_attr) },
/* Attribute to write remaining session to */
- { FR_CONF_OFFSET("reply_name", 0, CONF_FLAG_TMPL | CONF_FLAG_ATTRIBUTE, rlm_sqlcounter_t, reply_attr) },
+ { FR_CONF_OFFSET_FLAGS("reply_name", 0, CONF_FLAG_TMPL | CONF_FLAG_ATTRIBUTE, rlm_sqlcounter_t, reply_attr) },
CONF_PARSER_TERMINATOR
};
} rlm_sqlippool_t;
static conf_parser_t message_config[] = {
- { FR_CONF_OFFSET("exists", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, log_exists) },
- { FR_CONF_OFFSET("success", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, log_success) },
- { FR_CONF_OFFSET("clear", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, log_clear) },
- { FR_CONF_OFFSET("failed", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, log_failed) },
- { FR_CONF_OFFSET("nopool", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, log_nopool) },
+ { FR_CONF_OFFSET_FLAGS("exists", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, log_exists) },
+ { FR_CONF_OFFSET_FLAGS("success", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, log_success) },
+ { FR_CONF_OFFSET_FLAGS("clear", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, log_clear) },
+ { FR_CONF_OFFSET_FLAGS("failed", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, log_failed) },
+ { FR_CONF_OFFSET_FLAGS("nopool", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, log_nopool) },
CONF_PARSER_TERMINATOR
};
static conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("sql_module_instance", FR_TYPE_STRING, 0, rlm_sqlippool_t, sql_name), .dflt = "sql" },
+ { FR_CONF_OFFSET("sql_module_instance", rlm_sqlippool_t, sql_name), .dflt = "sql" },
- { FR_CONF_OFFSET("lease_duration", FR_TYPE_UINT32, 0, rlm_sqlippool_t, lease_duration), .dflt = "86400" },
+ { FR_CONF_OFFSET("lease_duration", rlm_sqlippool_t, lease_duration), .dflt = "86400" },
- { FR_CONF_OFFSET("pool_name", FR_TYPE_STRING, 0, rlm_sqlippool_t, pool_name) },
+ { FR_CONF_OFFSET("pool_name", rlm_sqlippool_t, pool_name) },
- { FR_CONF_OFFSET("allocated_address_attr", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, rlm_sqlippool_t, allocated_address_attr) },
+ { FR_CONF_OFFSET_FLAGS("allocated_address_attr", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, rlm_sqlippool_t, allocated_address_attr) },
- { FR_CONF_OFFSET("requested_address", 0, CONF_FLAG_TMPL, rlm_sqlippool_t, requested_address) },
+ { FR_CONF_OFFSET_FLAGS("requested_address", 0, CONF_FLAG_TMPL, rlm_sqlippool_t, requested_address) },
- { FR_CONF_OFFSET("default_pool", FR_TYPE_STRING, 0, rlm_sqlippool_t, defaultpool), .dflt = "main_pool" },
+ { FR_CONF_OFFSET("default_pool", rlm_sqlippool_t, defaultpool), .dflt = "main_pool" },
- { FR_CONF_OFFSET("alloc_begin", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, alloc_begin), .dflt = "START TRANSACTION" },
+ { FR_CONF_OFFSET_FLAGS("alloc_begin", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, alloc_begin), .dflt = "START TRANSACTION" },
- { FR_CONF_OFFSET("alloc_existing", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, alloc_existing) },
+ { FR_CONF_OFFSET_FLAGS("alloc_existing", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, alloc_existing) },
- { FR_CONF_OFFSET("alloc_requested", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, alloc_requested) },
+ { FR_CONF_OFFSET_FLAGS("alloc_requested", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, alloc_requested) },
- { FR_CONF_OFFSET("alloc_find", FR_TYPE_STRING, CONF_FLAG_XLAT | CONF_FLAG_REQUIRED, rlm_sqlippool_t, alloc_find) },
+ { FR_CONF_OFFSET_FLAGS("alloc_find", FR_TYPE_STRING, CONF_FLAG_XLAT | CONF_FLAG_REQUIRED, rlm_sqlippool_t, alloc_find) },
- { FR_CONF_OFFSET("alloc_update", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, alloc_update) },
+ { FR_CONF_OFFSET_FLAGS("alloc_update", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, alloc_update) },
- { FR_CONF_OFFSET("alloc_commit", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, alloc_commit), .dflt = "COMMIT" },
+ { FR_CONF_OFFSET_FLAGS("alloc_commit", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, alloc_commit), .dflt = "COMMIT" },
- { FR_CONF_OFFSET("pool_check", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, pool_check) },
+ { FR_CONF_OFFSET_FLAGS("pool_check", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, pool_check) },
- { FR_CONF_OFFSET("update_begin", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, update_begin) },
+ { FR_CONF_OFFSET_FLAGS("update_begin", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, update_begin) },
- { FR_CONF_OFFSET("update_free", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, update_free) },
+ { FR_CONF_OFFSET_FLAGS("update_free", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, update_free) },
- { FR_CONF_OFFSET("update_update", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, update_update) },
+ { FR_CONF_OFFSET_FLAGS("update_update", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, update_update) },
- { FR_CONF_OFFSET("update_commit", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, update_commit) },
+ { FR_CONF_OFFSET_FLAGS("update_commit", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, update_commit) },
- { FR_CONF_OFFSET("release_begin", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, release_begin) },
+ { FR_CONF_OFFSET_FLAGS("release_begin", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, release_begin) },
- { FR_CONF_OFFSET("release_clear", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, release_clear) },
+ { FR_CONF_OFFSET_FLAGS("release_clear", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, release_clear) },
- { FR_CONF_OFFSET("release_commit", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, release_commit) },
+ { FR_CONF_OFFSET_FLAGS("release_commit", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, release_commit) },
- { FR_CONF_OFFSET("bulk_release_begin", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, bulk_release_begin) },
+ { FR_CONF_OFFSET_FLAGS("bulk_release_begin", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, bulk_release_begin) },
- { FR_CONF_OFFSET("bulk_release_clear", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, bulk_release_clear) },
+ { FR_CONF_OFFSET_FLAGS("bulk_release_clear", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, bulk_release_clear) },
- { FR_CONF_OFFSET("bulk_release_commit", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, bulk_release_commit) },
+ { FR_CONF_OFFSET_FLAGS("bulk_release_commit", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, bulk_release_commit) },
- { FR_CONF_OFFSET("mark_begin", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, mark_begin) },
+ { FR_CONF_OFFSET_FLAGS("mark_begin", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, mark_begin) },
- { FR_CONF_OFFSET("mark_update", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, mark_update) },
+ { FR_CONF_OFFSET_FLAGS("mark_update", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, mark_update) },
- { FR_CONF_OFFSET("mark_commit", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, mark_commit) },
+ { FR_CONF_OFFSET_FLAGS("mark_commit", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, mark_commit) },
{ FR_CONF_POINTER("messages", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) message_config },
* Retransmission intervals for the packets we support.
*/
static conf_parser_t retry_config[] = {
- { FR_CONF_OFFSET("initial_rtx_time", FR_TYPE_TIME_DELTA, 0, fr_retry_config_t, irt), .dflt = STRINGIFY(2) },
- { FR_CONF_OFFSET("max_rtx_time", FR_TYPE_TIME_DELTA, 0, fr_retry_config_t, mrt), .dflt = STRINGIFY(16) },
- { FR_CONF_OFFSET("max_rtx_count", FR_TYPE_UINT32, 0, fr_retry_config_t, mrc), .dflt = STRINGIFY(5) },
- { FR_CONF_OFFSET("max_rtx_duration", FR_TYPE_TIME_DELTA, 0, fr_retry_config_t, mrd), .dflt = STRINGIFY(30) },
+ { FR_CONF_OFFSET("initial_rtx_time", fr_retry_config_t, irt), .dflt = STRINGIFY(2) },
+ { FR_CONF_OFFSET("max_rtx_time", fr_retry_config_t, mrt), .dflt = STRINGIFY(16) },
+ { FR_CONF_OFFSET("max_rtx_count", fr_retry_config_t, mrc), .dflt = STRINGIFY(5) },
+ { FR_CONF_OFFSET("max_rtx_duration", fr_retry_config_t, mrd), .dflt = STRINGIFY(30) },
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
static conf_parser_t const module_config[] = {
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, rlm_tacacs_t, io_submodule),
+ { FR_CONF_OFFSET_FLAGS("transport", FR_TYPE_VOID, 0, rlm_tacacs_t, io_submodule),
.func = module_rlm_submodule_parse },
- { FR_CONF_OFFSET("type", FR_TYPE_UINT32, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI | CONF_FLAG_REQUIRED, rlm_tacacs_t, types),
+ { FR_CONF_OFFSET_FLAGS("type", FR_TYPE_UINT32, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI | CONF_FLAG_REQUIRED, rlm_tacacs_t, types),
.func = type_parse },
- { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, 0, rlm_tacacs_t, max_attributes), .dflt = STRINGIFY(FR_MAX_ATTRIBUTES) },
+ { FR_CONF_OFFSET("max_attributes", rlm_tacacs_t, max_attributes), .dflt = STRINGIFY(FR_MAX_ATTRIBUTES) },
- { FR_CONF_OFFSET("response_window", FR_TYPE_TIME_DELTA, 0, rlm_tacacs_t, response_window), .dflt = STRINGIFY(20) },
+ { FR_CONF_OFFSET("response_window", rlm_tacacs_t, response_window), .dflt = STRINGIFY(20) },
- { FR_CONF_OFFSET("zombie_period", FR_TYPE_TIME_DELTA, 0, rlm_tacacs_t, zombie_period), .dflt = STRINGIFY(40) },
+ { FR_CONF_OFFSET("zombie_period", rlm_tacacs_t, zombie_period), .dflt = STRINGIFY(40) },
- { FR_CONF_OFFSET("revive_interval", FR_TYPE_TIME_DELTA, 0, rlm_tacacs_t, revive_interval) },
+ { FR_CONF_OFFSET("revive_interval", rlm_tacacs_t, revive_interval) },
- { FR_CONF_OFFSET("pool", 0, CONF_FLAG_SUBSECTION, rlm_tacacs_t, trunk_conf), .subcs = (void const *) fr_trunk_config, },
+ { FR_CONF_OFFSET_SUBSECTION("pool", 0, rlm_tacacs_t, trunk_conf, fr_trunk_config ) },
- { FR_CONF_OFFSET("retry", 0, CONF_FLAG_SUBSECTION, rlm_tacacs_t, retry), .subcs = (void const *) retry_config },
+ { FR_CONF_OFFSET_SUBSECTION("retry", 0, rlm_tacacs_t, retry, retry_config ) },
CONF_PARSER_TERMINATOR
};
};
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, rlm_tacacs_tcp_t, dst_ipaddr), },
- { FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, 0, rlm_tacacs_tcp_t, dst_ipaddr) },
- { FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, 0, rlm_tacacs_tcp_t, dst_ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, rlm_tacacs_tcp_t, dst_ipaddr), },
+ { FR_CONF_OFFSET_FLAGS("ipv4addr", FR_TYPE_IPV4_ADDR, 0, rlm_tacacs_tcp_t, dst_ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("ipv6addr", FR_TYPE_IPV6_ADDR, 0, rlm_tacacs_tcp_t, dst_ipaddr) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, rlm_tacacs_tcp_t, dst_port) },
+ { FR_CONF_OFFSET("port", rlm_tacacs_tcp_t, dst_port) },
- { FR_CONF_OFFSET("secret", FR_TYPE_STRING, 0, rlm_tacacs_tcp_t, secret) }, /* can be NULL */
+ { FR_CONF_OFFSET("secret", rlm_tacacs_tcp_t, secret) }, /* can be NULL */
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, rlm_tacacs_tcp_t, interface) },
+ { FR_CONF_OFFSET("interface", rlm_tacacs_tcp_t, interface) },
{ FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, rlm_tacacs_tcp_t, recv_buff) },
{ FR_CONF_OFFSET_IS_SET("send_buff", FR_TYPE_UINT32, 0, rlm_tacacs_tcp_t, send_buff) },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, rlm_tacacs_tcp_t, max_packet_size), .dflt = STRINGIFY(FR_MAX_PACKET_SIZE) },
- { FR_CONF_OFFSET("max_send_coalesce", FR_TYPE_UINT16, 0, rlm_tacacs_tcp_t, max_send_coalesce), .dflt = "1024" },
+ { FR_CONF_OFFSET("max_packet_size", rlm_tacacs_tcp_t, max_packet_size), .dflt = STRINGIFY(FR_MAX_PACKET_SIZE) },
+ { FR_CONF_OFFSET("max_send_coalesce", rlm_tacacs_tcp_t, max_send_coalesce), .dflt = "1024" },
- { FR_CONF_OFFSET("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, rlm_tacacs_tcp_t, src_ipaddr) },
- { FR_CONF_OFFSET("src_ipv4addr", FR_TYPE_IPV4_ADDR, 0, rlm_tacacs_tcp_t, src_ipaddr) },
- { FR_CONF_OFFSET("src_ipv6addr", FR_TYPE_IPV6_ADDR, 0, rlm_tacacs_tcp_t, src_ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, rlm_tacacs_tcp_t, src_ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("src_ipv4addr", FR_TYPE_IPV4_ADDR, 0, rlm_tacacs_tcp_t, src_ipaddr) },
+ { FR_CONF_OFFSET_FLAGS("src_ipv6addr", FR_TYPE_IPV6_ADDR, 0, rlm_tacacs_tcp_t, src_ipaddr) },
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("tmpl", 0, CONF_FLAG_TMPL, rlm_test_t, tmpl), .dflt = "&Tmp-String-0", .quote = T_BARE_WORD },
- { FR_CONF_OFFSET("tmpl_m", 0, CONF_FLAG_TMPL | CONF_FLAG_MULTI, rlm_test_t, tmpl_m), .dflt = "&Tmp-String-0", .quote = T_DOUBLE_QUOTED_STRING },
+ { FR_CONF_OFFSET("tmpl", rlm_test_t, tmpl), .dflt = "&Tmp-String-0", .quote = T_BARE_WORD },
+ { FR_CONF_OFFSET("tmpl_m", rlm_test_t, tmpl_m), .dflt = "&Tmp-String-0", .quote = T_DOUBLE_QUOTED_STRING },
- { FR_CONF_OFFSET("string", FR_TYPE_STRING, 0, rlm_test_t, string) },
- { FR_CONF_OFFSET("string_m", FR_TYPE_STRING, CONF_FLAG_MULTI, rlm_test_t, string_m) },
+ { FR_CONF_OFFSET("string", rlm_test_t, string) },
+ { FR_CONF_OFFSET("string_m", rlm_test_t, string_m) },
- { FR_CONF_OFFSET("boolean", FR_TYPE_BOOL, 0, rlm_test_t, boolean), .dflt = "no" },
- { FR_CONF_OFFSET("boolean_m", FR_TYPE_BOOL , CONF_FLAG_MULTI, rlm_test_t, boolean_m), .dflt = "no" },
+ { FR_CONF_OFFSET("boolean", rlm_test_t, boolean), .dflt = "no" },
+ { FR_CONF_OFFSET("boolean_m", rlm_test_t, boolean_m), .dflt = "no" },
- { FR_CONF_OFFSET("integer", FR_TYPE_UINT32, 0, rlm_test_t, integer), .dflt = "1" },
- { FR_CONF_OFFSET("integer_m", FR_TYPE_UINT32 , CONF_FLAG_MULTI, rlm_test_t, integer_m), .dflt = "2" },
+ { FR_CONF_OFFSET("integer", rlm_test_t, integer), .dflt = "1" },
+ { FR_CONF_OFFSET_FLAGS("integer_m", FR_TYPE_UINT32 , CONF_FLAG_MULTI, rlm_test_t, integer_m), .dflt = "2" },
- { FR_CONF_OFFSET("ipv4_addr", FR_TYPE_IPV4_ADDR, 0, rlm_test_t, ipv4_addr), .dflt = "*" },
- { FR_CONF_OFFSET("ipv4_addr_m", FR_TYPE_IPV4_ADDR , CONF_FLAG_MULTI, rlm_test_t, ipv4_addr_m), .dflt = "*" },
+ { FR_CONF_OFFSET_FLAGS("ipv4_addr", FR_TYPE_IPV4_ADDR, 0, rlm_test_t, ipv4_addr), .dflt = "*" },
+ { FR_CONF_OFFSET_FLAGS("ipv4_addr_m", FR_TYPE_IPV4_ADDR, CONF_FLAG_MULTI, rlm_test_t, ipv4_addr_m), .dflt = "*" },
- { FR_CONF_OFFSET("ipv4_prefix", FR_TYPE_IPV4_PREFIX, 0, rlm_test_t, ipv4_addr), .dflt = "192.168.0.1/24" },
- { FR_CONF_OFFSET("ipv4_prefix_m", FR_TYPE_IPV4_PREFIX , CONF_FLAG_MULTI, rlm_test_t, ipv4_addr_m), .dflt = "192.168.0.1/24" },
+ { FR_CONF_OFFSET_FLAGS("ipv4_prefix", FR_TYPE_IPV4_PREFIX, 0, rlm_test_t, ipv4_addr), .dflt = "192.168.0.1/24" },
+ { FR_CONF_OFFSET_FLAGS("ipv4_prefix_m", FR_TYPE_IPV4_PREFIX, CONF_FLAG_MULTI, rlm_test_t, ipv4_addr_m), .dflt = "192.168.0.1/24" },
- { FR_CONF_OFFSET("ipv6_addr", FR_TYPE_IPV6_ADDR, 0, rlm_test_t, ipv6_addr), .dflt = "*" },
- { FR_CONF_OFFSET("ipv6_addr_m", FR_TYPE_IPV6_ADDR , CONF_FLAG_MULTI, rlm_test_t, ipv6_addr_m), .dflt = "*" },
+ { FR_CONF_OFFSET_FLAGS("ipv6_addr", FR_TYPE_IPV6_ADDR, 0, rlm_test_t, ipv6_addr), .dflt = "*" },
+ { FR_CONF_OFFSET_FLAGS("ipv6_addr_m", FR_TYPE_IPV6_ADDR, CONF_FLAG_MULTI, rlm_test_t, ipv6_addr_m), .dflt = "*" },
- { FR_CONF_OFFSET("ipv6_prefix", FR_TYPE_IPV6_PREFIX, 0, rlm_test_t, ipv6_prefix), .dflt = "::1/128" },
- { FR_CONF_OFFSET("ipv6_prefix_m", FR_TYPE_IPV6_PREFIX , CONF_FLAG_MULTI, rlm_test_t, ipv6_prefix_m), .dflt = "::1/128" },
+ { FR_CONF_OFFSET_FLAGS("ipv6_prefix", FR_TYPE_IPV6_PREFIX, 0, rlm_test_t, ipv6_prefix), .dflt = "::1/128" },
+ { FR_CONF_OFFSET_FLAGS("ipv6_prefix_m", FR_TYPE_IPV6_PREFIX, CONF_FLAG_MULTI, rlm_test_t, ipv6_prefix_m), .dflt = "::1/128" },
- { FR_CONF_OFFSET("combo", FR_TYPE_COMBO_IP_ADDR, 0, rlm_test_t, combo_ipaddr), .dflt = "::1/128" },
- { FR_CONF_OFFSET("combo_m", FR_TYPE_COMBO_IP_ADDR , CONF_FLAG_MULTI, rlm_test_t, combo_ipaddr_m), .dflt = "::1/128" },
+ { FR_CONF_OFFSET_FLAGS("combo", FR_TYPE_COMBO_IP_ADDR, 0, rlm_test_t, combo_ipaddr), .dflt = "::1/128" },
+ { FR_CONF_OFFSET_FLAGS("combo_m", FR_TYPE_COMBO_IP_ADDR, CONF_FLAG_MULTI, rlm_test_t, combo_ipaddr_m), .dflt = "::1/128" },
- { FR_CONF_OFFSET("date", FR_TYPE_DATE, 0, rlm_test_t, date) },
- { FR_CONF_OFFSET("date_m", FR_TYPE_DATE , CONF_FLAG_MULTI, rlm_test_t, date_m) },
+ { FR_CONF_OFFSET("date", rlm_test_t, date) },
+ { FR_CONF_OFFSET("date_m", rlm_test_t, date_m) },
- { FR_CONF_OFFSET("octets", FR_TYPE_OCTETS, 0, rlm_test_t, octets) },
- { FR_CONF_OFFSET("octets_m", FR_TYPE_OCTETS, CONF_FLAG_MULTI, rlm_test_t, octets_m) },
+ { FR_CONF_OFFSET("octets", rlm_test_t, octets) },
+ { FR_CONF_OFFSET("octets_m", rlm_test_t, octets_m) },
- { FR_CONF_OFFSET("bytes", FR_TYPE_UINT8, 0, rlm_test_t, byte) },
- { FR_CONF_OFFSET("bytes_m", FR_TYPE_UINT8 , CONF_FLAG_MULTI, rlm_test_t, byte_m) },
+ { FR_CONF_OFFSET("bytes", rlm_test_t, byte) },
+ { FR_CONF_OFFSET("bytes_m", rlm_test_t, byte_m) },
- { FR_CONF_OFFSET("ifid", FR_TYPE_IFID, 0, rlm_test_t, ifid) },
- { FR_CONF_OFFSET("ifid_m", FR_TYPE_IFID , CONF_FLAG_MULTI, rlm_test_t, ifid_m) },
+ { FR_CONF_OFFSET("ifid", rlm_test_t, ifid) },
+ { FR_CONF_OFFSET("ifid_m", rlm_test_t, ifid_m) },
- { FR_CONF_OFFSET("short", FR_TYPE_UINT16, 0, rlm_test_t, shortint) },
- { FR_CONF_OFFSET("short_m", FR_TYPE_UINT16 , CONF_FLAG_MULTI, rlm_test_t, shortint_m) },
+ { FR_CONF_OFFSET("short", rlm_test_t, shortint) },
+ { FR_CONF_OFFSET("short_m", rlm_test_t, shortint_m) },
- { FR_CONF_OFFSET("ethernet", FR_TYPE_ETHERNET, 0, rlm_test_t, ethernet) },
- { FR_CONF_OFFSET("ethernet_m", FR_TYPE_ETHERNET , CONF_FLAG_MULTI, rlm_test_t, ethernet_m) },
+ { FR_CONF_OFFSET("ethernet", rlm_test_t, ethernet) },
+ { FR_CONF_OFFSET("ethernet_m", rlm_test_t, ethernet_m) },
- { FR_CONF_OFFSET("signed", FR_TYPE_INT32, 0, rlm_test_t, int32) },
- { FR_CONF_OFFSET("signed_m", FR_TYPE_INT32 , CONF_FLAG_MULTI, rlm_test_t, int32_m) },
+ { FR_CONF_OFFSET("signed", rlm_test_t, int32) },
+ { FR_CONF_OFFSET("signed_m", rlm_test_t, int32_m) },
- { FR_CONF_OFFSET("uint64", FR_TYPE_UINT64, 0, rlm_test_t, uint64) },
- { FR_CONF_OFFSET("uint64_m", FR_TYPE_UINT64 , CONF_FLAG_MULTI, rlm_test_t, uint64_m) },
+ { FR_CONF_OFFSET("uint64", rlm_test_t, uint64) },
+ { FR_CONF_OFFSET("uint64_m", rlm_test_t, uint64_m) },
- { FR_CONF_OFFSET("time_delta", FR_TYPE_TIME_DELTA, 0, rlm_test_t, time_delta) },
- { FR_CONF_OFFSET("time_delta_t", FR_TYPE_TIME_DELTA , CONF_FLAG_MULTI, rlm_test_t, time_delta_m) },
+ { FR_CONF_OFFSET("time_delta", rlm_test_t, time_delta) },
+ { FR_CONF_OFFSET("time_delta_t", rlm_test_t, time_delta_m) },
CONF_PARSER_TERMINATOR
};
/* Map configuration file names to internal variables */
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("time_step", FR_TYPE_UINT32, 0, rlm_totp_t, totp.time_step), .dflt = "30" },
- { FR_CONF_OFFSET("otp_length", FR_TYPE_UINT32, 0, rlm_totp_t, totp.otp_length), .dflt = "6" },
- { FR_CONF_OFFSET("lookback_steps", FR_TYPE_UINT32, 0, rlm_totp_t, totp.lookback_steps), .dflt = "1" },
- { FR_CONF_OFFSET("lookback_interval", FR_TYPE_UINT32, 0, rlm_totp_t, totp.lookback_interval), .dflt = "30" },
+ { FR_CONF_OFFSET("time_step", rlm_totp_t, totp.time_step), .dflt = "30" },
+ { FR_CONF_OFFSET("otp_length", rlm_totp_t, totp.otp_length), .dflt = "6" },
+ { FR_CONF_OFFSET("lookback_steps", rlm_totp_t, totp.lookback_steps), .dflt = "1" },
+ { FR_CONF_OFFSET("lookback_interval", rlm_totp_t, totp.lookback_interval), .dflt = "30" },
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_unbound_t, filename), .dflt = "${modconfdir}/unbound/default.conf" },
- { FR_CONF_OFFSET("timeout", FR_TYPE_UINT32, 0, rlm_unbound_t, timeout), .dflt = "3000" },
- { FR_CONF_OFFSET("resolvconf", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_unbound_t, resolvconf) },
- { FR_CONF_OFFSET("hosts", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_unbound_t, hosts) },
+ { FR_CONF_OFFSET_FLAGS("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_unbound_t, filename), .dflt = "${modconfdir}/unbound/default.conf" },
+ { FR_CONF_OFFSET("timeout", rlm_unbound_t, timeout), .dflt = "3000" },
+ { FR_CONF_OFFSET_FLAGS("resolvconf", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_unbound_t, resolvconf) },
+ { FR_CONF_OFFSET_FLAGS("hosts", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_unbound_t, hosts) },
CONF_PARSER_TERMINATOR
};
} rlm_unix_t;
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("radwtmp", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_unix_t, radwtmp) },
+ { FR_CONF_OFFSET_FLAGS("radwtmp", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_unix_t, radwtmp) },
CONF_PARSER_TERMINATOR
};
} rlm_wimax_t;
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("delete_mppe_keys", FR_TYPE_BOOL, 0, rlm_wimax_t, delete_mppe_keys), .dflt = "no" },
+ { FR_CONF_OFFSET("delete_mppe_keys", rlm_wimax_t, delete_mppe_keys), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
#include <wbclient.h>
static const conf_parser_t group_config[] = {
- { FR_CONF_OFFSET("search_username", 0, CONF_FLAG_TMPL, rlm_winbind_t, group_username) },
- { FR_CONF_OFFSET("add_domain", FR_TYPE_BOOL, 0, rlm_winbind_t, group_add_domain), .dflt = "yes" },
- { FR_CONF_OFFSET("attribute", FR_TYPE_STRING, 0, rlm_winbind_t, group_attribute) },
+ { FR_CONF_OFFSET("search_username", rlm_winbind_t, group_username) },
+ { FR_CONF_OFFSET("add_domain", rlm_winbind_t, group_add_domain), .dflt = "yes" },
+ { FR_CONF_OFFSET("attribute", rlm_winbind_t, group_attribute) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("username", 0, CONF_FLAG_TMPL, rlm_winbind_t, wb_username) },
- { FR_CONF_OFFSET("domain", 0, CONF_FLAG_TMPL, rlm_winbind_t, wb_domain) },
+ { FR_CONF_OFFSET("username", rlm_winbind_t, wb_username) },
+ { FR_CONF_OFFSET("domain", rlm_winbind_t, wb_domain) },
{ FR_CONF_POINTER("group", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) group_config },
CONF_PARSER_TERMINATOR
};
#ifdef HAVE_YKCLIENT
static const conf_parser_t validation_config[] = {
- { FR_CONF_OFFSET("client_id", FR_TYPE_UINT32, 0, rlm_yubikey_t, client_id), .dflt = 0 },
- { FR_CONF_OFFSET("api_key", FR_TYPE_STRING, CONF_FLAG_SECRET, rlm_yubikey_t, api_key) },
+ { FR_CONF_OFFSET("client_id", rlm_yubikey_t, client_id), .dflt = 0 },
+ { FR_CONF_OFFSET_FLAGS("api_key", FR_TYPE_STRING, CONF_FLAG_SECRET, rlm_yubikey_t, api_key) },
CONF_PARSER_TERMINATOR
};
#endif
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("id_length", FR_TYPE_UINT32, 0, rlm_yubikey_t, id_len), .dflt = "12" },
- { FR_CONF_OFFSET("split", FR_TYPE_BOOL, 0, rlm_yubikey_t, split), .dflt = "yes" },
- { FR_CONF_OFFSET("decrypt", FR_TYPE_BOOL, 0, rlm_yubikey_t, decrypt), .dflt = "no" },
- { FR_CONF_OFFSET("validate", FR_TYPE_BOOL, 0, rlm_yubikey_t, validate), .dflt = "no" },
+ { FR_CONF_OFFSET("id_length", rlm_yubikey_t, id_len), .dflt = "12" },
+ { FR_CONF_OFFSET("split", rlm_yubikey_t, split), .dflt = "yes" },
+ { FR_CONF_OFFSET("decrypt", rlm_yubikey_t, decrypt), .dflt = "no" },
+ { FR_CONF_OFFSET("validate", rlm_yubikey_t, validate), .dflt = "no" },
#ifdef HAVE_YKCLIENT
{ FR_CONF_POINTER("validation", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) validation_config },
#endif
#include <freeradius-devel/server/process.h>
static conf_parser_t dhcpv6_process_config[] = {
- { FR_CONF_OFFSET("status_code_on_success", FR_TYPE_BOOL, 0, process_dhcpv6_t, status_code_on_success), .dflt = "no" },
- { FR_CONF_OFFSET("send_failure_message", FR_TYPE_BOOL, 0, process_dhcpv6_t, send_failure_message), .dflt = "no" },
- { FR_CONF_OFFSET("move_failure_message_to_parent", FR_TYPE_BOOL, 0, process_dhcpv6_t, move_failure_message_to_parent), .dflt = "yes" },
+ { FR_CONF_OFFSET("status_code_on_success", process_dhcpv6_t, status_code_on_success), .dflt = "no" },
+ { FR_CONF_OFFSET("send_failure_message", process_dhcpv6_t, send_failure_message), .dflt = "no" },
+ { FR_CONF_OFFSET("move_failure_message_to_parent", process_dhcpv6_t, move_failure_message_to_parent), .dflt = "yes" },
CONF_PARSER_TERMINATOR
};
#include <freeradius-devel/server/process.h>
static conf_parser_t submodule_config[] = {
- { FR_CONF_OFFSET("request_identity", FR_TYPE_VOID, 0, eap_aka_sim_process_conf_t, request_identity ),
+ { FR_CONF_OFFSET_FLAGS("request_identity", FR_TYPE_VOID, 0, eap_aka_sim_process_conf_t, request_identity ),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = fr_aka_sim_id_request_table, .len = &fr_aka_sim_id_request_table_len }},
- { FR_CONF_OFFSET("strip_permanent_identity_hint", FR_TYPE_BOOL, 0, eap_aka_sim_process_conf_t,
+ { FR_CONF_OFFSET("strip_permanent_identity_hint", eap_aka_sim_process_conf_t,
strip_permanent_identity_hint ), .dflt = "yes" },
- { FR_CONF_OFFSET("ephemeral_id_length", FR_TYPE_SIZE, 0, eap_aka_sim_process_conf_t, ephemeral_id_length ), .dflt = "14" }, /* 14 for compatibility */
- { FR_CONF_OFFSET("protected_success", FR_TYPE_BOOL, 0, eap_aka_sim_process_conf_t, protected_success ), .dflt = "no" },
+ { FR_CONF_OFFSET_FLAGS("ephemeral_id_length", FR_TYPE_SIZE, 0, eap_aka_sim_process_conf_t, ephemeral_id_length ), .dflt = "14" }, /* 14 for compatibility */
+ { FR_CONF_OFFSET("protected_success", eap_aka_sim_process_conf_t, protected_success ), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
#include <freeradius-devel/server/process.h>
static conf_parser_t submodule_config[] = {
- { FR_CONF_OFFSET("network_name", FR_TYPE_STRING, 0, eap_aka_sim_process_conf_t, network_name ) },
- { FR_CONF_OFFSET("request_identity", FR_TYPE_VOID, 0, eap_aka_sim_process_conf_t, request_identity ),
+ { FR_CONF_OFFSET("network_name", eap_aka_sim_process_conf_t, network_name ) },
+ { FR_CONF_OFFSET_FLAGS("request_identity", FR_TYPE_VOID, 0, eap_aka_sim_process_conf_t, request_identity ),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = fr_aka_sim_id_request_table, .len = &fr_aka_sim_id_request_table_len }},
- { FR_CONF_OFFSET("strip_permanent_identity_hint", FR_TYPE_BOOL, 0, eap_aka_sim_process_conf_t,
+ { FR_CONF_OFFSET("strip_permanent_identity_hint", eap_aka_sim_process_conf_t,
strip_permanent_identity_hint ), .dflt = "yes" },
- { FR_CONF_OFFSET("ephemeral_id_length", FR_TYPE_SIZE, 0, eap_aka_sim_process_conf_t, ephemeral_id_length ), .dflt = "14" }, /* 14 for compatibility */
- { FR_CONF_OFFSET("protected_success", FR_TYPE_BOOL, 0, eap_aka_sim_process_conf_t, protected_success ), .dflt = "no" },
+ { FR_CONF_OFFSET_FLAGS("ephemeral_id_length", FR_TYPE_SIZE, 0, eap_aka_sim_process_conf_t, ephemeral_id_length ), .dflt = "14" }, /* 14 for compatibility */
+ { FR_CONF_OFFSET("protected_success", eap_aka_sim_process_conf_t, protected_success ), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
#include <freeradius-devel/server/process.h>
static conf_parser_t submodule_config[] = {
- { FR_CONF_OFFSET("request_identity", FR_TYPE_VOID, 0, eap_aka_sim_process_conf_t, request_identity ),
+ { FR_CONF_OFFSET_FLAGS("request_identity", FR_TYPE_VOID, 0, eap_aka_sim_process_conf_t, request_identity ),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = fr_aka_sim_id_request_table, .len = &fr_aka_sim_id_request_table_len }},
- { FR_CONF_OFFSET("strip_permanent_identity_hint", FR_TYPE_BOOL, 0, eap_aka_sim_process_conf_t,
+ { FR_CONF_OFFSET("strip_permanent_identity_hint", eap_aka_sim_process_conf_t,
strip_permanent_identity_hint ), .dflt = "yes" },
- { FR_CONF_OFFSET("ephemeral_id_length", FR_TYPE_SIZE, 0, eap_aka_sim_process_conf_t, ephemeral_id_length ), .dflt = "14" }, /* 14 for compatibility */
- { FR_CONF_OFFSET("protected_success", FR_TYPE_BOOL, 0, eap_aka_sim_process_conf_t, protected_success ), .dflt = "no" },
+ { FR_CONF_OFFSET_FLAGS("ephemeral_id_length", FR_TYPE_SIZE, 0, eap_aka_sim_process_conf_t, ephemeral_id_length ), .dflt = "14" }, /* 14 for compatibility */
+ { FR_CONF_OFFSET("protected_success", eap_aka_sim_process_conf_t, protected_success ), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
#include <freeradius-devel/server/process.h>
static const conf_parser_t session_config[] = {
- { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, 0, process_radius_auth_t, session_timeout), .dflt = "15" },
- { FR_CONF_OFFSET("max", FR_TYPE_UINT32, 0, process_radius_auth_t, max_session), .dflt = "4096" },
- { FR_CONF_OFFSET("state_server_id", FR_TYPE_UINT8, 0, process_radius_auth_t, state_server_id) },
+ { FR_CONF_OFFSET("timeout", process_radius_auth_t, session_timeout), .dflt = "15" },
+ { FR_CONF_OFFSET("max", process_radius_auth_t, max_session), .dflt = "4096" },
+ { FR_CONF_OFFSET("state_server_id", process_radius_auth_t, state_server_id) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t log_config[] = {
- { FR_CONF_OFFSET("stripped_names", FR_TYPE_BOOL, 0, process_radius_auth_t, log_stripped_names), .dflt = "no" },
- { FR_CONF_OFFSET("auth", FR_TYPE_BOOL, 0, process_radius_auth_t, log_auth), .dflt = "no" },
- { FR_CONF_OFFSET("auth_badpass", FR_TYPE_BOOL, 0, process_radius_auth_t, log_auth_badpass), .dflt = "no" },
- { FR_CONF_OFFSET("auth_goodpass", FR_TYPE_BOOL, 0,process_radius_auth_t, log_auth_goodpass), .dflt = "no" },
- { FR_CONF_OFFSET("msg_badpass", FR_TYPE_STRING, 0, process_radius_auth_t, auth_badpass_msg) },
- { FR_CONF_OFFSET("msg_goodpass", FR_TYPE_STRING, 0, process_radius_auth_t, auth_goodpass_msg) },
- { FR_CONF_OFFSET("msg_denied", FR_TYPE_STRING, 0, process_radius_auth_t, denied_msg), .dflt = "You are already logged in - access denied" },
+ { FR_CONF_OFFSET("stripped_names", process_radius_auth_t, log_stripped_names), .dflt = "no" },
+ { FR_CONF_OFFSET("auth", process_radius_auth_t, log_auth), .dflt = "no" },
+ { FR_CONF_OFFSET("auth_badpass", process_radius_auth_t, log_auth_badpass), .dflt = "no" },
+ { FR_CONF_OFFSET("auth_goodpass", process_radius_auth_t, log_auth_goodpass), .dflt = "no" },
+ { FR_CONF_OFFSET("msg_badpass", process_radius_auth_t, auth_badpass_msg) },
+ { FR_CONF_OFFSET("msg_goodpass", process_radius_auth_t, auth_goodpass_msg) },
+ { FR_CONF_OFFSET("msg_denied", process_radius_auth_t, denied_msg), .dflt = "You are already logged in - access denied" },
CONF_PARSER_TERMINATOR
};
#include <freeradius-devel/server/process.h>
static const conf_parser_t session_config[] = {
- { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, 0, process_tacacs_auth_t, session_timeout), .dflt = "15" },
- { FR_CONF_OFFSET("max", FR_TYPE_UINT32, 0, process_tacacs_auth_t, max_session), .dflt = "4096" },
- { FR_CONF_OFFSET("max_rounds", FR_TYPE_UINT32, 0, process_tacacs_auth_t, max_rounds), .dflt = "4" },
- { FR_CONF_OFFSET("state_server_id", FR_TYPE_UINT8, 0, process_tacacs_auth_t, state_server_id) },
+ { FR_CONF_OFFSET("timeout", process_tacacs_auth_t, session_timeout), .dflt = "15" },
+ { FR_CONF_OFFSET("max", process_tacacs_auth_t, max_session), .dflt = "4096" },
+ { FR_CONF_OFFSET("max_rounds", process_tacacs_auth_t, max_rounds), .dflt = "4" },
+ { FR_CONF_OFFSET("state_server_id", process_tacacs_auth_t, state_server_id) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t log_config[] = {
- { FR_CONF_OFFSET("stripped_names", FR_TYPE_BOOL, 0, process_tacacs_auth_t, log_stripped_names), .dflt = "no" },
- { FR_CONF_OFFSET("auth", FR_TYPE_BOOL, 0, process_tacacs_auth_t, log_auth), .dflt = "no" },
- { FR_CONF_OFFSET("auth_badpass", FR_TYPE_BOOL, 0, process_tacacs_auth_t, log_auth_badpass), .dflt = "no" },
- { FR_CONF_OFFSET("auth_goodpass", FR_TYPE_BOOL, 0,process_tacacs_auth_t, log_auth_goodpass), .dflt = "no" },
- { FR_CONF_OFFSET("msg_badpass", FR_TYPE_STRING, 0, process_tacacs_auth_t, auth_badpass_msg) },
- { FR_CONF_OFFSET("msg_goodpass", FR_TYPE_STRING, 0, process_tacacs_auth_t, auth_goodpass_msg) },
- { FR_CONF_OFFSET("msg_denied", FR_TYPE_STRING, 0, process_tacacs_auth_t, denied_msg), .dflt = "You are already logged in - access denied" },
+ { FR_CONF_OFFSET("stripped_names", process_tacacs_auth_t, log_stripped_names), .dflt = "no" },
+ { FR_CONF_OFFSET("auth", process_tacacs_auth_t, log_auth), .dflt = "no" },
+ { FR_CONF_OFFSET("auth_badpass", process_tacacs_auth_t, log_auth_badpass), .dflt = "no" },
+ { FR_CONF_OFFSET("auth_goodpass", process_tacacs_auth_t, log_auth_goodpass), .dflt = "no" },
+ { FR_CONF_OFFSET("msg_badpass", process_tacacs_auth_t, auth_badpass_msg) },
+ { FR_CONF_OFFSET("msg_goodpass", process_tacacs_auth_t, auth_goodpass_msg) },
+ { FR_CONF_OFFSET("msg_denied", process_tacacs_auth_t, denied_msg), .dflt = "You are already logged in - access denied" },
CONF_PARSER_TERMINATOR
};
#include <freeradius-devel/server/process.h>
static const conf_parser_t session_config[] = {
- { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, 0, process_ttls_session_t, timeout), .dflt = "15" },
- { FR_CONF_OFFSET("max", FR_TYPE_UINT32, 0, process_ttls_session_t, max), .dflt = "4096" },
- { FR_CONF_OFFSET("state_server_id", FR_TYPE_UINT8, 0, process_ttls_session_t, state_server_id) },
+ { FR_CONF_OFFSET("timeout", process_ttls_session_t, timeout), .dflt = "15" },
+ { FR_CONF_OFFSET("max", process_ttls_session_t, max), .dflt = "4096" },
+ { FR_CONF_OFFSET("state_server_id", process_ttls_session_t, state_server_id) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t log_config[] = {
- { FR_CONF_OFFSET("stripped_names", FR_TYPE_BOOL, 0, process_ttls_auth_log_t, stripped_names), .dflt = "no" },
- { FR_CONF_OFFSET("auth", FR_TYPE_BOOL, 0, process_ttls_auth_log_t, auth), .dflt = "no" },
- { FR_CONF_OFFSET("auth_badpass", FR_TYPE_BOOL, 0, process_ttls_auth_log_t, auth_badpass), .dflt = "no" },
- { FR_CONF_OFFSET("auth_goodpass", FR_TYPE_BOOL, 0,process_ttls_auth_log_t, auth_goodpass), .dflt = "no" },
- { FR_CONF_OFFSET("msg_badpass", FR_TYPE_STRING, 0, process_ttls_auth_log_t, auth_badpass_msg) },
- { FR_CONF_OFFSET("msg_goodpass", FR_TYPE_STRING, 0, process_ttls_auth_log_t, auth_goodpass_msg) },
- { FR_CONF_OFFSET("msg_denied", FR_TYPE_STRING, 0, process_ttls_auth_log_t, denied_msg), .dflt = "You are already logged in - access denied" },
+ { FR_CONF_OFFSET("stripped_names", process_ttls_auth_log_t, stripped_names), .dflt = "no" },
+ { FR_CONF_OFFSET("auth", process_ttls_auth_log_t, auth), .dflt = "no" },
+ { FR_CONF_OFFSET("auth_badpass", process_ttls_auth_log_t, auth_badpass), .dflt = "no" },
+ { FR_CONF_OFFSET("auth_goodpass", process_ttls_auth_log_t, auth_goodpass), .dflt = "no" },
+ { FR_CONF_OFFSET("msg_badpass", process_ttls_auth_log_t, auth_badpass_msg) },
+ { FR_CONF_OFFSET("msg_goodpass", process_ttls_auth_log_t, auth_goodpass_msg) },
+ { FR_CONF_OFFSET("msg_denied", process_ttls_auth_log_t, denied_msg), .dflt = "You are already logged in - access denied" },
CONF_PARSER_TERMINATOR
};
projects / thirdparty / freeradius-server.git / commitdiff
