# Indents braced list initialisers correctly, with a space
# after the opening brace, and before the closing brace.
#
-# static CONF_PARSER group_config[] = {
+# static conf_parser_t group_config[] = {
# { FR_CONF_OFFSET("filter", FR_TYPE_STRING, rlm_ldap_t, groupobj_filter) }
# };
#
char const *radutmp_fn;
} radutmpconfig;
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_POINTER("filename", FR_TYPE_FILE_INPUT, &radutmpconfig.radutmp_fn), .dflt = RADUTMP },
CONF_PARSER_TERMINATOR
};
};
static size_t fr_curl_sslcode_table_len = NUM_ELEMENTS(fr_curl_sslcode_table);
-CONF_PARSER fr_curl_tls_config[] = {
+conf_parser_t fr_curl_tls_config[] = {
{ FR_CONF_OFFSET("ca_file", FR_TYPE_FILE_INPUT, fr_curl_tls_t, ca_file) },
{ FR_CONF_OFFSET("ca_issuer_file", FR_TYPE_FILE_INPUT, fr_curl_tls_t, ca_issuer_file) },
{ FR_CONF_OFFSET("ca_path", FR_TYPE_FILE_INPUT, fr_curl_tls_t, ca_path) },
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER reuse_curl_conn_config[] = {
+static conf_parser_t reuse_curl_conn_config[] = {
{ FR_CONF_OFFSET("min", FR_TYPE_UINT32, fr_slab_config_t, min_elements), .dflt = "10" },
{ FR_CONF_OFFSET("max", FR_TYPE_UINT32, fr_slab_config_t, max_elements), .dflt = "100" },
{ FR_CONF_OFFSET("cleanup_interval", FR_TYPE_TIME_DELTA, fr_slab_config_t, interval), .dflt = "30s" },
CONF_PARSER_TERMINATOR
};
-CONF_PARSER fr_curl_conn_config[] = {
+conf_parser_t fr_curl_conn_config[] = {
{ FR_CONF_OFFSET("reuse", FR_TYPE_SUBSECTION, fr_curl_conn_config_t, reuse), .subcs = (void const *) reuse_curl_conn_config },
{ FR_CONF_OFFSET("connect_timeout", FR_TYPE_TIME_DELTA, fr_curl_conn_config_t, connect_timeout), .dflt = "3.0" },
CONF_PARSER_TERMINATOR
fr_time_delta_t connect_timeout;
} fr_curl_conn_config_t;
-extern CONF_PARSER fr_curl_tls_config[];
-extern CONF_PARSER fr_curl_conn_config[];
+extern conf_parser_t fr_curl_tls_config[];
+extern conf_parser_t fr_curl_conn_config[];
extern global_lib_autoinst_t fr_curl_autoinst;
int fr_curl_io_request_enqueue(fr_curl_handle_t *mhandle,
*
*/
struct fr_json_format_s {
- char const *output_mode_str; //!< For CONF_PARSER only.
+ char const *output_mode_str; //!< For conf_parser_t only.
json_mode_type_t output_mode; //!< Determine the format of JSON document
//!< to generate.
typedef struct fr_json_format_s fr_json_format_t;
-extern CONF_PARSER const fr_json_format_config[];
+extern conf_parser_t const fr_json_format_config[];
/* jpath .c */
.output_mode = JSON_MODE_OBJECT
};
-static CONF_PARSER const json_format_attr_config[] = {
+static conf_parser_t const json_format_attr_config[] = {
{ FR_CONF_OFFSET("prefix", FR_TYPE_STRING, fr_json_format_attr_t, prefix) },
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER const json_format_value_config[] = {
+static conf_parser_t const json_format_value_config[] = {
{ FR_CONF_OFFSET("single_value_as_array", FR_TYPE_BOOL, fr_json_format_value_t, value_is_always_array), .dflt = "no" },
{ FR_CONF_OFFSET("enum_as_integer", FR_TYPE_BOOL, fr_json_format_value_t, enum_as_int), .dflt = "no" },
{ FR_CONF_OFFSET("always_string", FR_TYPE_BOOL, fr_json_format_value_t, always_string), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
-CONF_PARSER const fr_json_format_config[] = {
+conf_parser_t const fr_json_format_config[] = {
{ FR_CONF_OFFSET("output_mode", FR_TYPE_STRING, fr_json_format_t, output_mode_str), .dflt = "object" },
{ FR_CONF_OFFSET("attribute", FR_TYPE_SUBSECTION, fr_json_format_t, attr),
.subcs = (void const *) json_format_attr_config },
* - -1 on failure.
*/
static int kafka_config_dflt_single(CONF_PAIR **out, UNUSED void *parent, CONF_SECTION *cs, char const *value,
- fr_token_t quote, CONF_PARSER const *rule)
+ fr_token_t quote, conf_parser_t const *rule)
{
char tmp[sizeof("18446744073709551615b")];
fr_kafka_conf_ctx_t const *kctx = rule->uctx;
* - 0 on success.
* - -1 on failure.
*/
-static int kafka_config_dflt(CONF_PAIR **out, void *parent, CONF_SECTION *cs, fr_token_t quote, CONF_PARSER const *rule)
+static int kafka_config_dflt(CONF_PAIR **out, void *parent, CONF_SECTION *cs, fr_token_t quote, conf_parser_t const *rule)
{
char buff[1024];
size_t buff_len = sizeof(buff);
* - 0 on success.
* - -1 on failure.
*/
-static int kafka_topic_config_dflt(CONF_PAIR **out, void *parent, CONF_SECTION *cs, fr_token_t quote, CONF_PARSER const *rule)
+static int kafka_topic_config_dflt(CONF_PAIR **out, void *parent, CONF_SECTION *cs, fr_token_t quote, conf_parser_t const *rule)
{
char buff[1024];
size_t buff_len = sizeof(buff);
return 0;
}
-static int kafka_config_parse_single(char const **out, CONF_PAIR *cp, CONF_PARSER const *rule)
+static int kafka_config_parse_single(char const **out, CONF_PAIR *cp, conf_parser_t const *rule)
{
fr_value_box_t vb = FR_VALUE_BOX_INITIALISER_NULL(vb);
fr_kafka_conf_ctx_t const *kctx = rule->uctx;
* - -1 on failure
*/
static int kafka_config_parse(TALLOC_CTX *ctx, UNUSED void *out, UNUSED void *base,
- CONF_ITEM *ci, CONF_PARSER const *rule)
+ CONF_ITEM *ci, conf_parser_t const *rule)
{
fr_kafka_conf_ctx_t const *kctx = rule->uctx;
CONF_ITEM *parent = cf_parent(ci);
* - -1 on failure
*/
static int kafka_topic_config_parse(UNUSED TALLOC_CTX *ctx, UNUSED void *out, UNUSED void *base,
- CONF_ITEM *ci, CONF_PARSER const *rule)
+ CONF_ITEM *ci, conf_parser_t const *rule)
{
fr_kafka_conf_ctx_t const *kctx = rule->uctx;
CONF_ITEM *parent = cf_parent(ci);
*
*/
static int kafka_topic_new(UNUSED TALLOC_CTX *ctx, UNUSED void *out, UNUSED void *base,
- CONF_ITEM *ci, CONF_PARSER const *rule)
+ CONF_ITEM *ci, conf_parser_t const *rule)
{
fr_kafka_conf_ctx_t const *kctx = rule->uctx;
CONF_ITEM *parent = cf_parent(ci);
}
#endif
-static CONF_PARSER const kafka_sasl_oauth_config[] = {
+static conf_parser_t const kafka_sasl_oauth_config[] = {
{ FR_CONF_FUNC("oauthbearer_conf", FR_TYPE_STRING, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "sasl.oauthbearer.config", .empty_default = true }},
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER const kafka_sasl_kerberos_config[] = {
+static conf_parser_t const kafka_sasl_kerberos_config[] = {
/*
* Service principal
*/
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER const kafka_sasl_config[] = {
+static conf_parser_t const kafka_sasl_config[] = {
/*
* SASL mechanism
*/
};
static size_t kafka_check_cert_cn_table_len = NUM_ELEMENTS(kafka_check_cert_cn_table);
-static CONF_PARSER const kafka_tls_config[] = {
+static conf_parser_t const kafka_tls_config[] = {
/*
* Cipher suite list in OpenSSL's format
*/
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER const kafka_connection_config[] = {
+static conf_parser_t const kafka_connection_config[] = {
/*
* Socket timeout
*/
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER const kafka_version_config[] = {
+static conf_parser_t const kafka_version_config[] = {
/*
* Request the API version from connected brokers
*/
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER const kafka_metadata_config[] = {
+static conf_parser_t const kafka_metadata_config[] = {
/*
* Interval between attempts to refresh metadata from brokers
*/
{ FR_CONF_SUBSECTION_GLOBAL("tls", 0, kafka_tls_config) }, \
{ FR_CONF_SUBSECTION_GLOBAL("sasl", 0, kafka_sasl_config) }
-static CONF_PARSER const kafka_consumer_group_config[] = {
+static conf_parser_t const kafka_consumer_group_config[] = {
/*
* Group consumer is a member of
*/
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER const kafka_base_consumer_topic_config[] = {
+static conf_parser_t const kafka_base_consumer_topic_config[] = {
/*
* How many messages we process at a time
*
* }
*
*/
-static CONF_PARSER const kafka_base_consumer_topics_config[] = {
+static conf_parser_t const kafka_base_consumer_topics_config[] = {
{ FR_CONF_SUBSECTION_GLOBAL(CF_IDENT_ANY, FR_TYPE_MULTI, kafka_base_consumer_topic_config) },
CONF_PARSER_TERMINATOR
};
-CONF_PARSER const kafka_base_consumer_config[] = {
+conf_parser_t const kafka_base_consumer_config[] = {
BASE_CONFIG,
{ FR_CONF_SUBSECTION_GLOBAL("group", 0, kafka_consumer_group_config) },
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER const kafka_base_producer_topic_config[] = {
+static conf_parser_t const kafka_base_producer_topic_config[] = {
/*
* This field indicates the number of acknowledgements the leader
* broker must receive from ISR brokers before responding to the request.
* }
*
*/
-static CONF_PARSER const kafka_base_producer_topics_config[] = {
+static conf_parser_t const kafka_base_producer_topics_config[] = {
{ FR_CONF_SUBSECTION_GLOBAL(CF_IDENT_ANY, 0, kafka_base_producer_topic_config) },
CONF_PARSER_TERMINATOR
};
-CONF_PARSER const kafka_base_producer_config[] = {
+conf_parser_t const kafka_base_producer_config[] = {
BASE_CONFIG,
/*
extern "C" {
#endif
-extern CONF_PARSER const kafka_base_consumer_config[];
-extern CONF_PARSER const kafka_base_producer_config[];
+extern conf_parser_t const kafka_base_consumer_config[];
+extern conf_parser_t const kafka_base_producer_config[];
#ifdef __cplusplus
}
.tls_random_file = ""
};
-static CONF_PARSER const ldap_global_config[] = {
+static conf_parser_t const ldap_global_config[] = {
{ FR_CONF_OFFSET("random_file", FR_TYPE_FILE_EXISTS, fr_libldap_global_config_t, tls_random_file) },
{ FR_CONF_OFFSET("ldap_debug", FR_TYPE_UINT32, fr_libldap_global_config_t, ldap_debug), .dflt = "0x0000" },
CONF_PARSER_TERMINATOR
*/
global_lib_autoinst_t fr_libldap_global_config = {
.name = "ldap",
- .config = (const CONF_PARSER *)ldap_global_config,
+ .config = (const conf_parser_t *)ldap_global_config,
.inst = &libldap_global_config,
.init = libldap_init,
.free = libldap_free
#include <freeradius-devel/ldap/base.h>
#include <freeradius-devel/ldap/conf.h>
-CONF_PARSER const fr_ldap_sasl_mech_static[] = {
+conf_parser_t const fr_ldap_sasl_mech_static[] = {
{ FR_CONF_OFFSET("mech", FR_TYPE_STRING | FR_TYPE_NOT_EMPTY, fr_ldap_sasl_t, mech) },
{ FR_CONF_OFFSET("proxy", FR_TYPE_STRING, fr_ldap_sasl_t, proxy) },
{ FR_CONF_OFFSET("realm", FR_TYPE_STRING, fr_ldap_sasl_t, realm) },
/*
* TLS Configuration
*/
-CONF_PARSER const fr_ldap_tls_config[] = {
+conf_parser_t const fr_ldap_tls_config[] = {
/*
* Deprecated attributes
*/
*
* Note that these overlap a bit with the connection pool code!
*/
-CONF_PARSER const fr_ldap_option_config[] = {
+conf_parser_t const fr_ldap_option_config[] = {
/*
* Pool config items
*/
CONF_PARSER_TERMINATOR
};
-
#include <freeradius-devel/ldap/base.h>
-extern CONF_PARSER const fr_ldap_sasl_mech_static[];
-extern CONF_PARSER const fr_ldap_tls_config[];
-extern CONF_PARSER const fr_ldap_option_config[];
+extern conf_parser_t const fr_ldap_sasl_mech_static[];
+extern conf_parser_t const fr_ldap_tls_config[];
+extern conf_parser_t const fr_ldap_option_config[];
/*
* Macro for including common LDAP configuration items
char *buff, char const *filename, int lineno)
{
CONF_DATA const *cd;
- CONF_PARSER *rule;
+ conf_parser_t *rule;
CONF_PAIR *cp;
bool pass2 = false;
cf_lineno_set(cp, lineno);
cp->pass2 = pass2;
- cd = cf_data_find(CF_TO_ITEM(parent), CONF_PARSER, attr);
+ cd = cf_data_find(CF_TO_ITEM(parent), conf_parser_t, attr);
if (!cd) return 0;
rule = cf_data_value(cd);
#include <freeradius-devel/util/perm.h>
#include <freeradius-devel/util/types.h>
-static CONF_PARSER conf_term = CONF_PARSER_TERMINATOR;
+static conf_parser_t conf_term = CONF_PARSER_TERMINATOR;
static char const parse_spaces[] = " ";
#define PAIR_SPACE(_cs) ((_cs->depth + 1) * 2)
#define SECTION_SPACE(_cs) (_cs->depth * 2)
-void cf_pair_debug(CONF_SECTION const *cs, CONF_PAIR *cp, CONF_PARSER const *rule)
+void cf_pair_debug(CONF_SECTION const *cs, CONF_PAIR *cp, conf_parser_t const *rule)
{
char const *value;
char *tmp = NULL;
* - 0 on success.
* - -1 on failure.
*/
-int cf_pair_to_value_box(TALLOC_CTX *ctx, fr_value_box_t *out, CONF_PAIR *cp, CONF_PARSER const *rule)
+int cf_pair_to_value_box(TALLOC_CTX *ctx, fr_value_box_t *out, CONF_PAIR *cp, conf_parser_t const *rule)
{
fr_type_t type = FR_BASE_TYPE(rule->type);
* - 0 on success.
* - -1 on failure.
*/
-int cf_pair_parse_value(TALLOC_CTX *ctx, void *out, UNUSED void *base, CONF_ITEM *ci, CONF_PARSER const *rule)
+int cf_pair_parse_value(TALLOC_CTX *ctx, void *out, UNUSED void *base, CONF_ITEM *ci, conf_parser_t const *rule)
{
int ret = 0;
bool cant_be_empty, tmpl;
* - 0 on success.
* - -1 on failure.
*/
-static int cf_pair_default(CONF_PAIR **out, void *parent, CONF_SECTION *cs, CONF_PARSER const *rule)
+static int cf_pair_default(CONF_PAIR **out, void *parent, CONF_SECTION *cs, conf_parser_t const *rule)
{
int lineno = 0;
return 1;
}
-static int cf_pair_unescape(CONF_PAIR *cp, CONF_PARSER const *rule)
+static int cf_pair_unescape(CONF_PAIR *cp, conf_parser_t const *rule)
{
fr_type_t type;
char const *p;
* - -2 if deprecated.
*/
static int CC_HINT(nonnull(4,5)) cf_pair_parse_internal(TALLOC_CTX *ctx, void *out, void *base,
- CONF_SECTION *cs, CONF_PARSER const *rule)
+ CONF_SECTION *cs, conf_parser_t const *rule)
{
bool required, deprecated;
size_t count = 0;
int ret;
void *entry;
TALLOC_CTX *value_ctx = array;
-
+
/*
* Figure out where to write the output
*/
/** Parses a #CONF_PAIR into a C data type, with a default value.
*
- * Takes fields from a #CONF_PARSER struct and uses them to parse the string value
+ * Takes fields from a #conf_parser_t struct and uses them to parse the string value
* of a #CONF_PAIR into a C data type matching the type argument.
*
* The format of the types are the same as #fr_value_box_t types.
int cf_pair_parse(TALLOC_CTX *ctx, CONF_SECTION *cs, char const *name,
unsigned int type, void *data, char const *dflt, fr_token_t dflt_quote)
{
- CONF_PARSER rule = {
+ conf_parser_t rule = {
.name = name,
.type = type,
.dflt = dflt,
* - 0 on success.
* - -1 on failure.
*/
-static int cf_section_parse_init(CONF_SECTION *cs, void *base, CONF_PARSER const *rule)
+static int cf_section_parse_init(CONF_SECTION *cs, void *base, conf_parser_t const *rule)
{
CONF_PAIR *cp;
/*
* If there's no subsection in the
- * config, BUT the CONF_PARSER wants one,
+ * config, BUT the conf_parser_t wants one,
* then create an empty one. This is so
* that we can track the strings,
* etc. allocated in the subsection.
* - -1 on general error.
* - -2 if a deprecated #CONF_ITEM was found.
*/
-static int cf_subsection_parse(TALLOC_CTX *ctx, void *out, void *base, CONF_SECTION *cs, CONF_PARSER const *rule)
+static int cf_subsection_parse(TALLOC_CTX *ctx, void *out, void *base, CONF_SECTION *cs, conf_parser_t const *rule)
{
CONF_SECTION *subcs = NULL;
int count = 0, i = 0, ret;
fr_type_t type = rule->type;
size_t subcs_size = rule->subcs_size;
- CONF_PARSER const *rules = rule->subcs;
+ conf_parser_t const *rules = rule->subcs;
uint8_t **array = NULL;
/*
* Loop over all the children of the section
*/
- while ((rule_cd = cf_data_find_next(cs, rule_cd, CONF_PARSER, CF_IDENT_ANY))) {
- CONF_PARSER *rule;
+ while ((rule_cd = cf_data_find_next(cs, rule_cd, conf_parser_t, CF_IDENT_ANY))) {
+ conf_parser_t *rule;
bool *is_set = NULL;
rule = cf_data_value(rule_cd);
{
CONF_DATA const *rule_cd = NULL;
- while ((rule_cd = cf_data_find_next(cs, rule_cd, CONF_PARSER, CF_IDENT_ANY))) {
+ while ((rule_cd = cf_data_find_next(cs, rule_cd, conf_parser_t, CF_IDENT_ANY))) {
bool attribute, multi, is_tmpl, is_xlat;
CONF_PAIR *cp;
- CONF_PARSER *rule;
+ conf_parser_t *rule;
void *data;
int type;
fr_dict_t const *dict = NULL;
/*
* Find the CONF_PAIR, may still not exist if there was
- * no default set for the CONF_PARSER.
+ * no default set for the conf_parser_t.
*/
cp = cf_pair_find(cs, rule->name);
if (!cp) continue;
* - 0 on success.
* - -1 if the rules added conflict.
*/
-int _cf_section_rule_push(CONF_SECTION *cs, CONF_PARSER const *rule, char const *filename, int lineno)
+int _cf_section_rule_push(CONF_SECTION *cs, conf_parser_t const *rule, char const *filename, int lineno)
{
char const *name1, *name2;
*
* Fixme maybe?.. Can't have a section and pair with the same name.
*/
- if (!_cf_data_add_static(CF_TO_ITEM(cs), rule, "CONF_PARSER", name1, filename, lineno)) {
+ if (!_cf_data_add_static(CF_TO_ITEM(cs), rule, "conf_parser_t", name1, filename, lineno)) {
CONF_DATA const *cd;
- CONF_PARSER *old;
+ conf_parser_t *old;
- cd = cf_data_find(CF_TO_ITEM(cs), CONF_PARSER, name1);
+ cd = cf_data_find(CF_TO_ITEM(cs), conf_parser_t, name1);
old = cf_data_value(cd);
fr_assert(old != NULL);
}
cf_log_err(cs, "Data of type %s with name \"%s\" already exists. "
- "Existing data added %s[%i]", "CONF_PARSER",
+ "Existing data added %s[%i]", "conf_parser_t",
name1, cd->item.filename, cd->item.lineno);
cf_debug(cs);
* - 0 on success.
* - -1 on failure.
*/
-int _cf_section_rules_push(CONF_SECTION *cs, CONF_PARSER const *rules, char const *filename, int lineno)
+int _cf_section_rules_push(CONF_SECTION *cs, conf_parser_t const *rules, char const *filename, int lineno)
{
- CONF_PARSER const *rule_p;
+ conf_parser_t const *rule_p;
if (!cs || !rules) return 0;
*
*/
int cf_table_parse_int(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, CONF_PARSER const *rule)
+ CONF_ITEM *ci, conf_parser_t const *rule)
{
int num;
cf_table_parse_ctx_t const *parse_ctx = rule->uctx;
*
*/
int cf_table_parse_int32(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, CONF_PARSER const *rule)
+ CONF_ITEM *ci, conf_parser_t const *rule)
{
int32_t num;
cf_table_parse_ctx_t const *parse_ctx = rule->uctx;
*
*/
int cf_table_parse_uint32(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, CONF_PARSER const *rule)
+ CONF_ITEM *ci, conf_parser_t const *rule)
{
int32_t num;
cf_table_parse_ctx_t const *parse_ctx = rule->uctx;
* Type should be FR_TYPE_VOID, struct field should be a uid_t.
*/
int cf_parse_uid(TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
if (fr_perm_uid_from_str(ctx, (uid_t *)out, cf_pair_value(cf_item_to_pair(ci))) < 0) {
cf_log_perr(ci, "Failed resolving UID");
* Type should be FR_TYPE_VOID, struct field should be a gid_t.
*/
int cf_parse_gid(TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
if (fr_perm_gid_from_str(ctx, (gid_t *)out, cf_pair_value(cf_item_to_pair(ci))) < 0) {
cf_log_perr(ci, "Failed resolving GID");
return 0;
}
-
# define FR_CONF_TYPE_CHECK(_type, _c_type, _ptr_or_offset) _ptr_or_offset
#endif
-/** CONF_PARSER which parses a single CONF_PAIR, writing the result to a field in a struct
+/** 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] _type to parse the CONF_PAIR as.
.type = _type, \
.offset = FR_CONF_TYPE_CHECK((_type), &(((_struct *)NULL)->_field), offsetof(_struct, _field))
-/** CONF_PARSER which parses a single CONF_PAIR, writing the result to a field in a struct, recording if a default was used in `<_field>`_is_set
+/** conf_parser_t which parses a single CONF_PAIR, writing the result to a field in a struct, recording if a default was used in `<_field>`_is_set
*
* @param[in] _name of the CONF_PAIR to search for.
* @param[in] _type to parse the CONF_PAIR as.
.offset = FR_CONF_TYPE_CHECK((_type), &(((_struct *)NULL)->_field), offsetof(_struct, _field)), \
.is_set_offset = offsetof(_struct, _field ## _is_set)
-/** CONF_PARSER which populates a sub-struct using a CONF_SECTION
+/** conf_parser_t which populates a sub-struct using a CONF_SECTION
*
* @param[in] _name of the CONF_SECTION to search for.
* @param[in] _flags any additional flags to set.
.offset = offsetof(_struct, _field), \
.subcs = _subcs
-/** CONF_PARSER which parses a single CONF_PAIR producing a single global result
+/** conf_parser_t which parses a single CONF_PAIR producing a single global result
*
* @param[in] _name of the CONF_PAIR to search for.
* @param[in] _type to parse the CONF_PAIR as.
.type = _type, \
.data = FR_CONF_TYPE_CHECK((_type), (_res_p), _res_p)
-/** CONF_PARSER which parses a single CONF_PAIR producing a single global result, recording if a default was used in `<_res_p>`_is_set
+/** conf_parser_t which parses a single CONF_PAIR producing a single global result, recording if a default was used in `<_res_p>`_is_set
*
* @note is set state is recorded in variable `<_res_p>`_is_set.
*
.is_set_ptr = _res_p ## _is_set
# define FR_ITEM_POINTER(_type, _res_p) _type, FR_CONF_TYPE_CHECK((_type), (_res_p), _res_p)
-/** A CONF_PARSER multi-subsection
+/** A conf_parser_t multi-subsection
*
* Parse multiple instance of a subsection, allocating an array of structs
* to hold the result.
* @param _type Must be FR_TYPE_SUBSECTION | FR_TYPE_MULTI and any optional flags.
* @param _struct instance data struct.
* @param _field field in instance data struct.
- * @param _subcs CONF_PARSER array to use to parse subsection data.
+ * @param _subcs conf_parser_t array to use to parse subsection data.
*/
# define FR_CONF_SUBSECTION_ALLOC(_name, _type, _struct, _field, _subcs) \
.name = _name, \
.subcs = _subcs, \
.subcs_size = sizeof(**(((_struct *)0)->_field))
-/** CONF_PARSER entry which doesn't fill in a pointer or offset, but relies on functions to record values
+/** conf_parser_t entry which doesn't fill in a pointer or offset, but relies on functions to record values
*
* @param[in] _name name of pair to search for.
* @param[in] _type base type to parse pair as.
.func = _func, \
.dflt_func = _dflt_func
-/** CONF_PARSER entry which runs CONF_PARSER entries for a subsection without any output
+/** conf_parser_t entry which runs conf_parser_t entries for a subsection without any output
*
* @param[in] _name of pair to search for.
* @param[in] _flags any extra flags to add.
.type = FR_TYPE_SUBSECTION, \
.subcs = _subcs
-/** CONF_PARSER entry which raises an error if a matching CONF_PAIR is found
+/** conf_parser_t entry which raises an error if a matching CONF_PAIR is found
*
* @param[in] _name of pair to search for.
* @param[in] _type type, mostly unused.
*/
#define FR_TYPE_HIDDEN 0
-/** @name #CONF_PARSER type flags
+/** @name #conf_parser_t type flags
*
* These flags should be or'd with another FR_TYPE_* value to create validation
* rules for the #cf_pair_parse function.
#define FR_BASE_TYPE(_t) (0xff & (_t))
/** @} */
-/** @name #CONF_PARSER flags checks
+/** @name #conf_parser_t flags checks
*
* @{
*/
extern bool check_config;
-typedef struct CONF_PARSER CONF_PARSER;
+typedef struct conf_parser_t conf_parser_t;
/** Callback for performing custom parsing of a #CONF_SECTION or CONF_PAIR
*
* - 0 on success.
* - -1 on failure.
*/
-typedef int (*cf_parse_t)(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
+typedef int (*cf_parse_t)(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
/** Callback for producing dynamic defaults from 3rd party libraries
*
* - 0 on success.
* - -1 on failure.
*/
-typedef int (*cf_dflt_t)(CONF_PAIR **out, void *parent, CONF_SECTION *cs, fr_token_t quote, CONF_PARSER const *rule);
+typedef int (*cf_dflt_t)(CONF_PAIR **out, void *parent, CONF_SECTION *cs, fr_token_t quote, conf_parser_t const *rule);
/** Defines a #CONF_PAIR to C data type mapping
*
*
* Example with #FR_CONF_OFFSET :
@code{.c}
- static CONF_PARSER module_config[] = {
+ static conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("example", FR_TYPE_STRING | FR_TYPE_NOT_EMPTY, example_instance_t, example), .dflt = "default_value" },
CONF_PARSER_TERMINATOR
}
*
* Example with #FR_CONF_POINTER :
@code{.c}
- static CONF_PARSER global_config[] = {
+ static conf_parser_t global_config[] = {
{ FR_CONF_POINTER("example", FR_TYPE_STRING | FR_TYPE_NOT_EMPTY, &my_global), .dflt = "default_value" },
CONF_PARSER_TERMINATOR
}
* @see cf_section_parse
* @see cf_pair_parse
*/
-struct CONF_PARSER {
+struct conf_parser_t {
char const *name; //!< Name of the #CONF_ITEM to parse.
char const *ident2; //!< Second identifier for #CONF_SECTION.
};
struct {
- struct CONF_PARSER const *subcs;//!< When type is set to #FR_TYPE_SUBSECTION, should
+ struct conf_parser_t const *subcs;//!< When type is set to #FR_TYPE_SUBSECTION, should
//!< be a pointer to the start of another array of
- //!< #CONF_PARSER structs, forming the subsection.
+ //!< #conf_parser_t structs, forming the subsection.
size_t subcs_size; //!< If non-zero, allocate structs of this size to hold
//!< the parsed data.
char const *subcs_type; //!< Set a specific talloc type for subcs structures.
#define CONF_PARSER_TERMINATOR { .name = NULL, .type = ~(UINT32_MAX - 1), \
.offset = 0, .data = NULL, .dflt = NULL, .quote = T_INVALID }
-#define CONF_PARSER_PARTIAL_TERMINATOR { .name = NULL, .type = ~(UINT32_MAX - 1), \
+#define conf_parser_t_PARTIAL_TERMINATOR { .name = NULL, .type = ~(UINT32_MAX - 1), \
.offset = 1, .data = NULL, .dflt = NULL, .quote = T_INVALID }
#define CF_FILE_NONE (0)
#define CF_FILE_CONFIG (1 << 2)
#define CF_FILE_MODULE (1 << 3)
-void cf_pair_debug(CONF_SECTION const *cs, CONF_PAIR *cp, CONF_PARSER const *rule);
+void cf_pair_debug(CONF_SECTION const *cs, CONF_PAIR *cp, conf_parser_t const *rule);
/*
* Type validation and conversion
*/
-int cf_pair_to_value_box(TALLOC_CTX *ctx, fr_value_box_t *out, CONF_PAIR *cp, CONF_PARSER const *rule)
+int cf_pair_to_value_box(TALLOC_CTX *ctx, fr_value_box_t *out, CONF_PAIR *cp, conf_parser_t const *rule)
CC_HINT(nonnull(2, 3, 4));
-int cf_pair_parse_value(TALLOC_CTX *ctx, void *out, void *base, CONF_ITEM *ci, CONF_PARSER const *rule)
+int cf_pair_parse_value(TALLOC_CTX *ctx, void *out, void *base, CONF_ITEM *ci, conf_parser_t const *rule)
CC_HINT(nonnull(2, 4, 5));
int cf_pair_parse(TALLOC_CTX *ctx, CONF_SECTION *cs, char const *name,
* Runtime parse rules
*/
#define cf_section_rule_push(_cs, _rule) _cf_section_rule_push(_cs, _rule, __FILE__, __LINE__)
-int _cf_section_rule_push(CONF_SECTION *cs, CONF_PARSER const *rule, char const *filename, int lineno);
+int _cf_section_rule_push(CONF_SECTION *cs, conf_parser_t const *rule, char const *filename, int lineno);
#define cf_section_rules_push(_cs, _rule) _cf_section_rules_push(_cs, _rule, __FILE__, __LINE__)
-int _cf_section_rules_push(CONF_SECTION *cs, CONF_PARSER const *rules, char const *filename, int lineno);
+int _cf_section_rules_push(CONF_SECTION *cs, conf_parser_t const *rules, char const *filename, int lineno);
/*
* Generic parsing callback functions
*/
int cf_table_parse_int(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, CONF_PARSER const *rule);
+ CONF_ITEM *ci, conf_parser_t const *rule);
int cf_table_parse_uint32(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, CONF_PARSER const *rule);
+ CONF_ITEM *ci, conf_parser_t const *rule);
int cf_table_parse_int32(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, CONF_PARSER const *rule);
+ CONF_ITEM *ci, conf_parser_t const *rule);
int cf_parse_uid(TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, CONF_PARSER const *rule);
+ CONF_ITEM *ci, conf_parser_t const *rule);
int cf_parse_gid(TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, CONF_PARSER const *rule);
+ CONF_ITEM *ci, conf_parser_t const *rule);
#ifdef __cplusplus
}
if (parent) {
CONF_DATA const *cd;
- CONF_PARSER *rule;
+ conf_parser_t *rule;
/*
* Look up the parents parsing rules for itself.
* happens, we push the child parsing rules to
* this new child.
*/
- cd = cf_data_find(CF_TO_ITEM(parent), CONF_PARSER, cf_section_name1(parent));
+ cd = cf_data_find(CF_TO_ITEM(parent), conf_parser_t, cf_section_name1(parent));
if (cd) {
rule = cf_data_value(cd);
if ((FR_BASE_TYPE(rule->type) == FR_TYPE_SUBSECTION) &&
rule->on_read && rule->subcs) {
- CONF_PARSER const *rule_p;
+ conf_parser_t const *rule_p;
for (rule_p = rule->subcs; rule_p->name; rule_p++) {
if ((FR_BASE_TYPE(rule_p->type) == FR_TYPE_SUBSECTION) &&
* child rules for this section, and then do the
* on_read callback.
*/
- cd = cf_data_find(CF_TO_ITEM(parent), CONF_PARSER, name1);
+ cd = cf_data_find(CF_TO_ITEM(parent), conf_parser_t, name1);
if (cd) {
rule = cf_data_value(cd);
if ((FR_BASE_TYPE(rule->type) == FR_TYPE_SUBSECTION) &&
found = _cf_data_find(ci, type, name);
if (found) {
/*
- * Suppress these, as it's OK for the CONF_PARSER in main_config.c
+ * Suppress these, as it's OK for the conf_parser_t in main_config.c
*/
- if (strcmp(type, "CONF_PARSER") == 0) return NULL;
+ if (strcmp(type, "conf_parser_t") == 0) return NULL;
cf_log_err(ci, "Data of type %s with name \"%s\" already exists. Existing data added %s[%i]", type,
name, found->item.filename, found->item.lineno);
static char const *cl_srcipaddr = NULL;
static char const *hs_proto = NULL;
-static CONF_PARSER limit_config[] = {
+static conf_parser_t limit_config[] = {
{ FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, fr_client_t, limit.max_connections), .dflt = "16" },
{ FR_CONF_OFFSET("lifetime", FR_TYPE_TIME_DELTA, fr_client_t, limit.lifetime), .dflt = "0" },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER client_config[] = {
+static const conf_parser_t client_config[] = {
{ FR_CONF_POINTER("ipaddr", FR_TYPE_COMBO_IP_PREFIX, &cl_ipaddr) },
{ FR_CONF_POINTER("ipv4addr", FR_TYPE_IPV4_PREFIX, &cl_ipaddr) },
{ FR_CONF_POINTER("ipv6addr", FR_TYPE_IPV6_PREFIX, &cl_ipaddr) },
char const *name; \
size_t inst_size; \
char const *inst_type; \
- CONF_PARSER const *config; \
+ conf_parser_t const *config; \
dl_module_onload_t onload; \
dl_module_unload_t unload; \
module_detach_t detach; \
*/
typedef struct {
char const *name; //!< Name of library and section within global config
- CONF_PARSER const *config; //!< Config parser for this library's global options
+ conf_parser_t const *config; //!< Config parser for this library's global options
void *inst; //!< Module data to parse global config into
lib_init_t init; //!< Callback to initialise library
lib_free_t free; //!< Callback to free library
/*
* Parse an fr_log_t configuration.
*/
-static const CONF_PARSER log_config[] = {
+static const conf_parser_t log_config[] = {
{ FR_CONF_POINTER("destination", FR_TYPE_STRING, &log_destination), .dflt = "files" },
#if 0
/*
*
**********************************************************************/
-static int reverse_lookups_parse(TALLOC_CTX *ctx, void *out, void *parent,CONF_ITEM *ci, CONF_PARSER const *rule);
-static int hostname_lookups_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
+static int reverse_lookups_parse(TALLOC_CTX *ctx, void *out, void *parent,CONF_ITEM *ci, conf_parser_t const *rule);
+static int hostname_lookups_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
-static int num_networks_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
-static int num_workers_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
-static int num_workers_dflt(CONF_PAIR **out, void *parent, CONF_SECTION *cs, fr_token_t quote, CONF_PARSER const *rule);
+static int num_networks_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
+static int num_workers_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
+static int num_workers_dflt(CONF_PAIR **out, void *parent, CONF_SECTION *cs, fr_token_t quote, conf_parser_t const *rule);
-static int lib_dir_on_read(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
+static int lib_dir_on_read(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
-static int talloc_pool_size_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
+static int talloc_pool_size_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
-static int max_request_time_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
+static int max_request_time_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
-static int name_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
+static int name_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
/*
* Log destinations
*/
-static const CONF_PARSER initial_log_config[] = {
+static const conf_parser_t initial_log_config[] = {
{ FR_CONF_OFFSET("destination", FR_TYPE_STRING, main_config_t, log_dest), .dflt = "files" },
{ FR_CONF_OFFSET("syslog_facility", FR_TYPE_VOID, main_config_t, syslog_facility), .dflt = "daemon",
.func = cf_table_parse_int,
/*
* Basic configuration for the server.
*/
-static const CONF_PARSER initial_server_config[] = {
+static const conf_parser_t initial_server_config[] = {
{ FR_CONF_POINTER("log", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) initial_log_config },
CONF_PARSER_TERMINATOR
/*
* Basic configuration for the server.
*/
-static const CONF_PARSER lib_dir_on_read_config[] = {
+static const conf_parser_t lib_dir_on_read_config[] = {
{ FR_CONF_OFFSET("prefix", FR_TYPE_STRING, main_config_t, prefix), .dflt = "/usr/local" },
{ FR_CONF_OFFSET("use_utc", FR_TYPE_BOOL, main_config_t, log_dates_utc) },
* items, we can parse the rest of the configuration items.
*
**********************************************************************/
-static const CONF_PARSER log_config[] = {
+static const conf_parser_t log_config[] = {
{ FR_CONF_OFFSET("colourise", FR_TYPE_BOOL, main_config_t, do_colourise) },
{ FR_CONF_OFFSET("line_number", FR_TYPE_BOOL, main_config_t, log_line_number) },
{ FR_CONF_OFFSET("timestamp", FR_TYPE_BOOL, main_config_t, log_timestamp) },
};
-static const CONF_PARSER resources[] = {
+static const conf_parser_t resources[] = {
/*
* Don't set a default here. It's set in the code, below. This means that
* the config item will *not* get printed out in debug mode, so that no one knows
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER thread_config[] = {
+static const conf_parser_t thread_config[] = {
{ FR_CONF_OFFSET("num_networks", FR_TYPE_UINT32, main_config_t, max_networks), .dflt = STRINGIFY(1),
.func = num_networks_parse },
{ FR_CONF_OFFSET("num_workers", FR_TYPE_UINT32, main_config_t, max_workers), .dflt = STRINGIFY(0),
/*
* Migration configuration.
*/
-static const CONF_PARSER migrate_config[] = {
+static const conf_parser_t migrate_config[] = {
{ FR_CONF_OFFSET("rewrite_update", FR_TYPE_BOOL | FR_TYPE_HIDDEN, main_config_t, rewrite_update) },
{ FR_CONF_OFFSET("forbid_update", FR_TYPE_BOOL | FR_TYPE_HIDDEN, main_config_t, forbid_update) },
/*
* Migration configuration.
*/
-static const CONF_PARSER interpret_config[] = {
+static const conf_parser_t interpret_config[] = {
{ FR_CONF_OFFSET("countup_instructions", FR_TYPE_BOOL | FR_TYPE_HIDDEN, main_config_t, ins_countup) },
{ FR_CONF_OFFSET("max_instructions", FR_TYPE_UINT32 | FR_TYPE_HIDDEN, main_config_t, ins_max) },
CONF_PARSER_TERMINATOR
};
#endif
-static const CONF_PARSER server_config[] = {
+static const conf_parser_t server_config[] = {
/*
* FIXME: 'prefix' is the ONLY one which should be
* configured at compile time. Hard-coding it here is
* permissions.
*
**********************************************************************/
-static const CONF_PARSER security_config[] = {
+static const conf_parser_t security_config[] = {
#ifdef HAVE_SETUID
{ FR_CONF_OFFSET_IS_SET("user", FR_TYPE_VOID, main_config_t, uid), .func = cf_parse_uid },
{ FR_CONF_OFFSET_IS_SET("group", FR_TYPE_VOID, main_config_t, gid), .func = cf_parse_gid },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER switch_users_config[] = {
+static const conf_parser_t switch_users_config[] = {
{ FR_CONF_POINTER("security", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) security_config },
{ FR_CONF_OFFSET("name", FR_TYPE_STRING, main_config_t, name), .func = name_parse }, /* DO NOT SET DEFAULT */
};
static int reverse_lookups_parse(TALLOC_CTX *ctx, void *out, void *parent,
- CONF_ITEM *ci, CONF_PARSER const *rule)
+ CONF_ITEM *ci, conf_parser_t const *rule)
{
int ret;
}
static int hostname_lookups_parse(TALLOC_CTX *ctx, void *out, void *parent,
- CONF_ITEM *ci, CONF_PARSER const *rule)
+ CONF_ITEM *ci, conf_parser_t const *rule)
{
int ret;
}
static int talloc_pool_size_parse(TALLOC_CTX *ctx, void *out, void *parent,
- CONF_ITEM *ci, CONF_PARSER const *rule)
+ CONF_ITEM *ci, conf_parser_t const *rule)
{
int ret;
size_t value;
}
static int max_request_time_parse(TALLOC_CTX *ctx, void *out, void *parent,
- CONF_ITEM *ci, CONF_PARSER const *rule)
+ CONF_ITEM *ci, conf_parser_t const *rule)
{
int ret;
fr_time_delta_t value;
}
static int lib_dir_on_read(UNUSED TALLOC_CTX *ctx, UNUSED void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
CONF_PAIR *cp = cf_item_to_pair(ci);
char const *value;
*
*/
static int name_parse(TALLOC_CTX *ctx, void *out, void *parent,
- CONF_ITEM *ci, CONF_PARSER const *rule)
+ CONF_ITEM *ci, conf_parser_t const *rule)
{
main_config_t *config = parent;
}
static int num_networks_parse(TALLOC_CTX *ctx, void *out, void *parent,
- CONF_ITEM *ci, CONF_PARSER const *rule)
+ CONF_ITEM *ci, conf_parser_t const *rule)
{
int ret;
uint32_t value;
return value;
}
-static int num_workers_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, CONF_PARSER const *rule)
+static int num_workers_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule)
{
int ret;
uint32_t value;
return 0;
}
-static int num_workers_dflt(CONF_PAIR **out, void *parent, CONF_SECTION *cs, fr_token_t quote, CONF_PARSER const *rule)
+static int num_workers_dflt(CONF_PAIR **out, void *parent, CONF_SECTION *cs, fr_token_t quote, conf_parser_t const *rule)
{
char *strvalue;
uint32_t value;
return CMP(a, b);
}
-/** Generic callback for CONF_PARSER to load a submodule
+/** Generic callback for conf_parser_t to load a submodule
*
- * CONF_PARSER entry should point to a module_instance_t field in the instance data
+ * conf_parser_t entry should point to a module_instance_t field in the instance data
*
* @param[in] ctx unused.
* @param[out] out A pointer to a pointer to a module_instance_t.
* - -1 if we failed to load the submodule.
*/
int module_submodule_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent,
- CONF_ITEM *ci, CONF_PARSER const *rule)
+ CONF_ITEM *ci, conf_parser_t const *rule)
{
char const *name = cf_pair_value(cf_item_to_pair(ci));
CONF_SECTION *cs = cf_item_to_section(cf_parent(ci));
module_method_t func; //!< State function.
} module_state_func_table_t;
-/** @name Callbacks for the CONF_PARSER
+/** @name Callbacks for the conf_parser_t
*
* @{
*/
int module_submodule_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule) CC_HINT(warn_unused_result);
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule) CC_HINT(warn_unused_result);
/** @} */
/** @name Module and module thread lookup
return 0;
}
-/** Generic CONF_PARSER func for loading drivers
+/** Generic conf_parser_t func for loading drivers
*
*/
int module_rlm_submodule_parse(TALLOC_CTX *ctx, void *out, void *parent,
- CONF_ITEM *ci, CONF_PARSER const *rule)
+ CONF_ITEM *ci, conf_parser_t const *rule)
{
- CONF_PARSER our_rule = *rule;
+ conf_parser_t our_rule = *rule;
our_rule.uctx = &rlm_modules;
* @{
*/
int module_rlm_submodule_parse(TALLOC_CTX *ctx, void *out, void *parent,
- CONF_ITEM *ci, CONF_PARSER const *rule);
+ CONF_ITEM *ci, conf_parser_t const *rule);
/** @} */
/** @name Module and module thread initialisation and instantiation
typedef struct fr_pool_connection_s fr_pool_connection_t;
static int connection_check(fr_pool_t *pool, request_t *request);
-static int max_dflt(CONF_PAIR **out, void *parent, CONF_SECTION *cs, fr_token_t quote, CONF_PARSER const *rule);
+static int max_dflt(CONF_PAIR **out, void *parent, CONF_SECTION *cs, fr_token_t quote, conf_parser_t const *rule);
/** An individual connection within the connection pool
*
fr_pool_state_t state; //!< Stats and state of the connection pool.
};
-static const CONF_PARSER pool_config[] = {
+static const conf_parser_t pool_config[] = {
{ FR_CONF_OFFSET("start", FR_TYPE_UINT32, fr_pool_t, start), .dflt = "0" },
{ FR_CONF_OFFSET("min", FR_TYPE_UINT32, fr_pool_t, min), .dflt = "0" },
{ FR_CONF_OFFSET("max", FR_TYPE_UINT32, fr_pool_t, max), .dflt_func = max_dflt },
CONF_PARSER_TERMINATOR
};
-static int max_dflt(CONF_PAIR **out, UNUSED void *parent, CONF_SECTION *cs, fr_token_t quote, CONF_PARSER const *rule)
+static int max_dflt(CONF_PAIR **out, UNUSED void *parent, CONF_SECTION *cs, fr_token_t quote, conf_parser_t const *rule)
{
char *strvalue;
* functions may be used. These functions evaluate the VPT, execing, and xlat expanding
* as necessary. In the case of #TMPL_TYPE_ATTR, and #FR_TYPE_STRING or #FR_TYPE_OCTETS
* #tmpl_expand will return a pointer to the raw #fr_pair_t buffer. This can be very
- * useful when using the #FR_TYPE_TMPL type in #CONF_PARSER structs, as it allows the
+ * useful when using the #FR_TYPE_TMPL type in #conf_parser_t structs, as it allows the
* user to determine whether they want the module to sanitise the value using presentation
* format specific #xlat_escape_legacy_t function, or to operate on the raw value.
*
/** @} */
};
-static CONF_PARSER const fr_trunk_config_request[] = {
+static conf_parser_t const fr_trunk_config_request[] = {
{ FR_CONF_OFFSET("per_connection_max", FR_TYPE_UINT32, fr_trunk_conf_t, max_req_per_conn), .dflt = "2000" },
{ FR_CONF_OFFSET("per_connection_target", FR_TYPE_UINT32, fr_trunk_conf_t, target_req_per_conn), .dflt = "1000" },
{ FR_CONF_OFFSET("free_delay", FR_TYPE_TIME_DELTA, fr_trunk_conf_t, req_cleanup_delay), .dflt = "10.0" },
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER const fr_trunk_config_connection[] = {
+static conf_parser_t const fr_trunk_config_connection[] = {
{ FR_CONF_OFFSET("connect_timeout", FR_TYPE_TIME_DELTA, fr_connection_conf_t, connection_timeout), .dflt = "3.0" },
{ FR_CONF_OFFSET("reconnect_delay", FR_TYPE_TIME_DELTA, fr_connection_conf_t, reconnection_delay), .dflt = "1" },
};
#ifndef TRUNK_TESTS
-CONF_PARSER const fr_trunk_config[] = {
+conf_parser_t const fr_trunk_config[] = {
{ FR_CONF_OFFSET("start", FR_TYPE_UINT16, fr_trunk_conf_t, start), .dflt = "5" },
{ FR_CONF_OFFSET("min", FR_TYPE_UINT16, fr_trunk_conf_t, min), .dflt = "1" },
{ FR_CONF_OFFSET("max", FR_TYPE_UINT16, fr_trunk_conf_t, max), .dflt = "5" },
/** Config parser definitions to populate a fr_trunk_conf_t
*
*/
-extern CONF_PARSER const fr_trunk_config[];
+extern conf_parser_t const fr_trunk_config[];
#endif
/** Allocate a new connection for the trunk
static int8_t server_section_name_cmp(void const *one, void const *two);
-static int namespace_on_read(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
-static int server_on_read(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, UNUSED CONF_PARSER const *rule);
+static int namespace_on_read(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
+static int server_on_read(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, UNUSED conf_parser_t const *rule);
-static int namespace_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
-static int listen_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
-static int server_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, UNUSED CONF_PARSER const *rule);
+static int namespace_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
+static int listen_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
+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 server_on_read_config[] = {
+static const conf_parser_t server_on_read_config[] = {
{ FR_CONF_OFFSET("namespace", FR_TYPE_VOID | FR_TYPE_REQUIRED, fr_virtual_server_t, process_mi),
.on_read = namespace_on_read },
CONF_PARSER_TERMINATOR
};
-const CONF_PARSER virtual_servers_on_read_config[] = {
+const conf_parser_t virtual_servers_on_read_config[] = {
/*
* Not really ok if it's missing but we want to
* let logic elsewhere handle the issue.
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER server_config[] = {
+static const conf_parser_t server_config[] = {
{ FR_CONF_OFFSET("namespace", FR_TYPE_VOID | FR_TYPE_REQUIRED, fr_virtual_server_t, process_mi),
.func = namespace_parse },
CONF_PARSER_TERMINATOR
};
-const CONF_PARSER virtual_servers_config[] = {
+const conf_parser_t virtual_servers_config[] = {
/*
* Not really ok if it's missing but we want to
* let logic elsewhere handle the issue.
* - -1 on failure.
*/
static int namespace_on_read(TALLOC_CTX *ctx, UNUSED void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
CONF_PAIR *cp = cf_item_to_pair(ci);
CONF_SECTION *server_cs = cf_item_to_section(cf_parent(ci));
*
* This callback exists only as a place-holder to ensure that the
* listen_on_read function is called. The conf file routines won't
- * recurse into every CONF_PARSER section to check if there's an
+ * recurse into every conf_parser_t section to check if there's an
* "on_read" callback. So this place-holder is a signal.
*
* @param[in] ctx to allocate data in.
* - -1 on failure.
*/
static int server_on_read(UNUSED TALLOC_CTX *ctx, UNUSED void *out, UNUSED void *parent,
- UNUSED CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ UNUSED CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
return 0;
}
* - 0 on success.
* - -1 on failure.
*/
-static int namespace_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+static int namespace_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
CONF_PAIR *cp = cf_item_to_pair(ci);
CONF_SECTION *server_cs = cf_item_to_section(cf_parent(ci));
* - 0 on success.
* - -1 on failure.
*/
-static int listen_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+static int listen_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
fr_virtual_listen_t *listener = talloc_get_type_abort(out, fr_virtual_listen_t); /* Pre-allocated for us */
CONF_SECTION *listener_cs = cf_item_to_section(ci);
* - -1 on failure.
*/
static int server_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
fr_virtual_server_t *server = talloc_get_type_abort(out, fr_virtual_server_t);
CONF_SECTION *server_cs = cf_item_to_section(ci);
*
*/
int virtual_server_cf_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
CONF_SECTION *server_cs;
#include <freeradius-devel/unlang/module.h>
#include <freeradius-devel/util/dict.h>
-extern const CONF_PARSER virtual_servers_config[];
-extern const CONF_PARSER virtual_servers_on_read_config[];
+extern const conf_parser_t virtual_servers_config[];
+extern const conf_parser_t virtual_servers_on_read_config[];
/** @name Namespace management
*
CONF_SECTION *virtual_server_by_child(CONF_SECTION *section) CC_HINT(nonnull);
int virtual_server_cf_parse(TALLOC_CTX *ctx, void *out, void *parent,
- CONF_ITEM *ci, CONF_PARSER const *rule) CC_HINT(nonnull(2,4));
+ CONF_ITEM *ci, conf_parser_t const *rule) CC_HINT(nonnull(2,4));
/** @} */
fr_listen_t * listen_find_any(fr_listen_t *li) CC_HINT(nonnull);
FR_OPENSSL_DRAIN_LOG_QUEUE(_macro, _prefix, _queue); \
} while (0)
-extern CONF_PARSER fr_tls_server_config[];
-extern CONF_PARSER fr_tls_client_config[];
+extern conf_parser_t fr_tls_server_config[];
+extern conf_parser_t fr_tls_client_config[];
/** Holds the temporary context
*
#include "base.h"
#include "log.h"
-static int tls_conf_parse_cache_mode(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
+static int tls_conf_parse_cache_mode(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
/** Certificate formats
*
};
static size_t verify_mode_table_len = NUM_ELEMENTS(verify_mode_table);
-static CONF_PARSER tls_cache_config[] = {
+static conf_parser_t tls_cache_config[] = {
{ FR_CONF_OFFSET("mode", FR_TYPE_UINT32, fr_tls_cache_conf_t, mode),
.func = tls_conf_parse_cache_mode,
.uctx = &(cf_table_parse_ctx_t){
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER tls_chain_config[] = {
+static conf_parser_t tls_chain_config[] = {
{ FR_CONF_OFFSET("format", FR_TYPE_VOID, fr_tls_chain_conf_t, file_format),
.func = cf_table_parse_int,
.uctx = &(cf_table_parse_ctx_t){
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER tls_verify_config[] = {
+static conf_parser_t tls_verify_config[] = {
{ FR_CONF_OFFSET("mode", FR_TYPE_VOID, fr_tls_verify_conf_t, mode),
.func = cf_table_parse_int,
.uctx = &(cf_table_parse_ctx_t){
CONF_PARSER_TERMINATOR
};
-CONF_PARSER fr_tls_server_config[] = {
+conf_parser_t fr_tls_server_config[] = {
{ FR_CONF_OFFSET("virtual_server", FR_TYPE_VOID, fr_tls_conf_t, virtual_server), .func = virtual_server_cf_parse },
{ FR_CONF_OFFSET("chain", FR_TYPE_SUBSECTION | FR_TYPE_MULTI, fr_tls_conf_t, chains),
CONF_PARSER_TERMINATOR
};
-CONF_PARSER fr_tls_client_config[] = {
+conf_parser_t fr_tls_client_config[] = {
{ FR_CONF_OFFSET("chain", FR_TYPE_SUBSECTION | FR_TYPE_MULTI | FR_TYPE_OK_MISSING, fr_tls_conf_t, chains),
.subcs_size = sizeof(fr_tls_chain_conf_t), .subcs_type = "fr_tls_chain_conf_t",
.subcs = tls_chain_config },
CONF_PARSER_TERMINATOR
};
-static int tls_conf_parse_cache_mode(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, CONF_PARSER const *rule)
+static int tls_conf_parse_cache_mode(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule)
{
fr_tls_conf_t *conf = talloc_get_type_abort((uint8_t *)parent - offsetof(fr_tls_conf_t, cache), fr_tls_conf_t);
int cache_mode;
/** Per method call config
*
- * Similar to a CONF_PARSER used to hold details of conf pairs
+ * Similar to a conf_parser_t used to hold details of conf pairs
* which are evaluated per call for each module method / xlat.
*
* This allows the conf pairs to be evaluated within the appropriate context
}
/*
- * We don't use CONF_PARSER here for various
+ * We don't use conf_parser_t here for various
* magical reasons.
*/
if (strcmp(name, "initial_rtx_time") == 0) {
#include <freeradius-devel/util/dlist.h>
#include <freeradius-devel/util/event.h>
-/** CONF_PARSER entries to populate user configurable slab values
+/** conf_parser_t entries to populate user configurable slab values
*/
-#define FR_SLAB_CONFIG_CONF_PARSER \
+#define FR_SLAB_CONFIG_conf_parser_t \
{ FR_CONF_OFFSET("min", FR_TYPE_UINT32, fr_slab_config_t, min_elements), .dflt = "10" }, \
{ FR_CONF_OFFSET("max", FR_TYPE_UINT32, fr_slab_config_t, max_elements), .dflt = "100" }, \
{ FR_CONF_OFFSET("cleanup_interval", FR_TYPE_TIME_DELTA, fr_slab_config_t, interval), .dflt = "30s" }, \
/** How to parse an ARP listen section
*
*/
-static CONF_PARSER const proto_arp_config[] = {
+static conf_parser_t const proto_arp_config[] = {
{ FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, proto_arp_t, num_messages) } ,
{ FR_CONF_OFFSET("active", FR_TYPE_BOOL, proto_arp_t, active), .dflt = "false" } ,
/** How to parse an ARP listen section
*
*/
-static CONF_PARSER const arp_listen_config[] = {
+static conf_parser_t const arp_listen_config[] = {
{ FR_CONF_OFFSET("interface", FR_TYPE_STRING | FR_TYPE_NOT_EMPTY, proto_arp_ethernet_t,
interface), .dflt = "eth0" },
extern fr_app_t proto_bfd;
-static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
-static int auth_type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
+static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
+static int auth_type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
/** How to parse a BFD listen section
*
*/
-static CONF_PARSER const proto_bfd_config[] = {
+static conf_parser_t const proto_bfd_config[] = {
{ FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_bfd_t, io.submodule),
.func = transport_parse },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER peer_config[] = {
+static const conf_parser_t peer_config[] = {
{ FR_CONF_OFFSET("min_transmit_interval", FR_TYPE_TIME_DELTA, bfd_session_t, desired_min_tx_interval ) },
{ FR_CONF_OFFSET("min_receive_interval", FR_TYPE_TIME_DELTA, bfd_session_t, required_min_rx_interval ) },
{ FR_CONF_OFFSET("max_timeouts", FR_TYPE_UINT32, bfd_session_t, detect_multi ) },
* - 0 on success.
* - -1 on failure.
*/
-static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
char const *name = cf_pair_value(cf_item_to_pair(ci));
dl_module_inst_t *parent_inst;
* - 0 on success.
* - -1 on failure.
*/
-static int auth_type_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+static int auth_type_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
char const *name = cf_pair_value(cf_item_to_pair(ci));
int auth_type;
} proto_bfd_udp_t;
-static const CONF_PARSER networks_config[] = {
+static const conf_parser_t networks_config[] = {
{ FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX | FR_TYPE_MULTI, proto_bfd_udp_t, allow) },
{ FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX | FR_TYPE_MULTI, proto_bfd_udp_t, deny) },
};
-static const CONF_PARSER udp_listen_config[] = {
+static const conf_parser_t udp_listen_config[] = {
{ FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, proto_bfd_udp_t, ipaddr) },
{ FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, proto_bfd_udp_t, ipaddr) },
{ FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, proto_bfd_udp_t, ipaddr) },
#include "proto_control.h"
extern fr_app_t proto_control;
-static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
+static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
-static CONF_PARSER const limit_config[] = {
+static conf_parser_t const limit_config[] = {
{ FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, proto_control_t, io.idle_timeout), .dflt = "30.0" } ,
{ FR_CONF_OFFSET("nak_lifetime", FR_TYPE_TIME_DELTA, proto_control_t, io.nak_lifetime), .dflt = "30.0" } ,
/** How to parse a CONTROL listen section
*
*/
-static CONF_PARSER const proto_control_config[] = {
+static conf_parser_t const proto_control_config[] = {
{ FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_control_t, io.submodule),
.func = transport_parse },
* - 0 on success.
* - -1 on failure.
*/
-static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
char const *name = cf_pair_value(cf_item_to_pair(ci));
dl_module_inst_t *parent_inst;
bool peercred; //!< whether we use peercred or not
} proto_control_unix_t;
-static const CONF_PARSER unix_listen_config[] = {
+static const conf_parser_t unix_listen_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_STRING | FR_TYPE_REQUIRED, proto_control_unix_t, filename),
.dflt = "${run_dir}/radiusd.sock}" },
{ FR_CONF_OFFSET("uid", FR_TYPE_STRING, proto_control_unix_t, uid_name) },
#include "proto_cron.h"
extern fr_app_t proto_cron;
-static int type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
-static int time_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
+static int type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
+static int time_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
-static CONF_PARSER const limit_config[] = {
+static conf_parser_t const limit_config[] = {
/*
* For performance tweaking. NOT for normal humans.
*/
/** How to parse a CRON listen section
*
*/
-static CONF_PARSER const proto_cron_config[] = {
+static conf_parser_t const proto_cron_config[] = {
{ FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_NOT_EMPTY | FR_TYPE_REQUIRED, proto_cron_t,
type), .func = type_parse },
* - 0 on success.
* - -1 on failure.
*/
-static int type_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+static int type_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
proto_cron_t *inst = talloc_get_type_abort(parent, proto_cron_t);
fr_dict_enum_t const *type_enum;
*
* https://github.com/staticlibs/ccronexpr/blob/master/ccronexpr.c
*/
-static int time_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+static int time_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
// proto_cron_t *inst = talloc_get_type_abort(parent, proto_cron_t);
CONF_PAIR *cp = cf_item_to_pair(ci);
if (parse_field(ci, &p, "day of month", 1, 31) < 0) return -1;
if (parse_field(ci, &p, "month", 1,12) < 0) return -1;
if (parse_field(ci, &p, "day of week", 0, 6) < 0) return -1;
-
+
fr_skip_whitespace(p);
if (*p) {
DEBUG(951, 951, "Listening on %s bound to virtual server %s",
li->name, cf_section_name2(li->server_cs));
- inst->listen = li; /* Probably won't need it, but doesn't hurt */
+ inst->listen = li; /* Probably won't need it, but doesn't hurt */
inst->sc = sc;
return 0;
#include "proto_cron.h"
extern fr_app_t proto_cron;
-static int type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
-static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
+static int type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
+static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
/** How to parse a Load listen section
*
*/
-static CONF_PARSER const proto_cron_config[] = {
+static conf_parser_t const proto_cron_config[] = {
{ FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_NOT_EMPTY | FR_TYPE_REQUIRED, proto_cron_t,
type), .func = type_parse },
{ FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_cron_t, io.submodule),
* - 0 on success.
* - -1 on failure.
*/
-static int type_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+static int type_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
proto_cron_t *inst = talloc_get_type_abort(parent, proto_cron_t);
fr_dict_enum_value_t const *type_enum;
* - -1 on failure.
*/
static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
char const *name = cf_pair_value(cf_item_to_pair(ci));
dl_module_inst_t *parent_inst;
};
-static int time_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
+static int time_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
-static const CONF_PARSER crontab_listen_config[] = {
+static const conf_parser_t crontab_listen_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT | FR_TYPE_REQUIRED | FR_TYPE_NOT_EMPTY, proto_cron_crontab_t, filename) },
{ FR_CONF_OFFSET("timespec", FR_TYPE_STRING | FR_TYPE_NOT_EMPTY | FR_TYPE_REQUIRED, proto_cron_crontab_t, spec),
* - 0 on success.
* - -1 on failure.
*/
-static int time_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+static int time_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
proto_cron_crontab_t *inst = talloc_get_type_abort(parent, proto_cron_crontab_t);
CONF_PAIR *cp = cf_item_to_pair(ci);
#include "proto_detail.h"
extern fr_app_t proto_detail;
-static int type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
-static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
+static int type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
+static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
#if 0
/*
/** How to parse a Detail listen section
*
*/
-static CONF_PARSER const proto_detail_config[] = {
+static conf_parser_t const proto_detail_config[] = {
{ FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_NOT_EMPTY | FR_TYPE_REQUIRED, proto_detail_t,
type), .func = type_parse },
{ FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_detail_t, io_submodule),
* - 0 on success.
* - -1 on failure.
*/
-static int type_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+static int type_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
proto_detail_t *inst = talloc_get_type_abort(parent, proto_detail_t);
fr_dict_enum_value_t const *type_enum;
* - -1 on failure.
*/
static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
char const *name = cf_pair_value(cf_item_to_pair(ci));
dl_module_inst_t *parent_inst;
static void work_init(proto_detail_file_thread_t *thread, bool triggered_by_delete);
static void mod_vnode_delete(fr_event_list_t *el, int fd, UNUSED int fflags, void *ctx);
-static const CONF_PARSER file_listen_config[] = {
+static const conf_parser_t file_listen_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_STRING | FR_TYPE_REQUIRED, proto_detail_file_t, filename ) },
{ FR_CONF_OFFSET("filename_work", FR_TYPE_STRING, proto_detail_file_t, filename_work ) },
fr_dlist_t entry; //!< for the retransmission list
} fr_detail_entry_t;
-static CONF_PARSER limit_config[] = {
+static conf_parser_t limit_config[] = {
{ FR_CONF_OFFSET("initial_rtx_time", FR_TYPE_TIME_DELTA, proto_detail_work_t, retry_config.irt), .dflt = STRINGIFY(2) },
{ FR_CONF_OFFSET("max_rtx_time", FR_TYPE_TIME_DELTA, proto_detail_work_t, retry_config.mrt), .dflt = STRINGIFY(16) },
};
-static const CONF_PARSER file_listen_config[] = {
+static const conf_parser_t file_listen_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_STRING | FR_TYPE_REQUIRED, proto_detail_work_t, filename_work ) },
{ FR_CONF_OFFSET("track", FR_TYPE_BOOL, proto_detail_work_t, track_progress ) },
#include "proto_dhcpv4.h"
extern fr_app_t proto_dhcpv4;
-static int type_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
-static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
+static int type_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
+static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
-static const CONF_PARSER priority_config[] = {
+static const conf_parser_t priority_config[] = {
{ FR_CONF_OFFSET("Discover", FR_TYPE_VOID, 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, proto_dhcpv4_t, priorities[FR_DHCP_REQUEST]),
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER const limit_config[] = {
+static conf_parser_t const limit_config[] = {
{ FR_CONF_OFFSET("cleanup_delay", FR_TYPE_TIME_DELTA, proto_dhcpv4_t, io.cleanup_delay), .dflt = "5.0" } ,
{ FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, proto_dhcpv4_t, io.idle_timeout), .dflt = "30.0" } ,
{ FR_CONF_OFFSET("nak_lifetime", FR_TYPE_TIME_DELTA, proto_dhcpv4_t, io.nak_lifetime), .dflt = "30.0" } ,
/** How to parse a DHCPV4 listen section
*
*/
-static CONF_PARSER const proto_dhcpv4_config[] = {
+static conf_parser_t const proto_dhcpv4_config[] = {
{ FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_MULTI | FR_TYPE_NOT_EMPTY, proto_dhcpv4_t,
allowed_types), .func = type_parse },
{ FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_dhcpv4_t, io.submodule),
* - -1 on failure.
*/
static int type_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
proto_dhcpv4_t *inst = talloc_get_type_abort(parent, proto_dhcpv4_t);
fr_dict_enum_value_t *dv;
* - -1 on failure.
*/
static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
char const *name = cf_pair_value(cf_item_to_pair(ci));
dl_module_inst_t *parent_inst;
} proto_dhcpv4_udp_t;
-static const CONF_PARSER networks_config[] = {
+static const conf_parser_t networks_config[] = {
{ FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX | FR_TYPE_MULTI, proto_dhcpv4_udp_t, allow) },
{ FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX | FR_TYPE_MULTI, proto_dhcpv4_udp_t, deny) },
};
-static const CONF_PARSER udp_listen_config[] = {
+static const conf_parser_t udp_listen_config[] = {
{ FR_CONF_OFFSET("ipaddr", FR_TYPE_IPV4_ADDR, proto_dhcpv4_udp_t, ipaddr) },
{ FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, proto_dhcpv4_udp_t, ipaddr) },
#include "proto_dhcpv6.h"
extern fr_app_t proto_dhcpv6;
-static int type_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
-static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
+static int type_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
+static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
-static const CONF_PARSER priority_config[] = {
+static const conf_parser_t priority_config[] = {
{ FR_CONF_OFFSET("Solicit", FR_TYPE_VOID, 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, proto_dhcpv6_t, priorities[FR_DHCPV6_REQUEST]),
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER const limit_config[] = {
+static conf_parser_t const limit_config[] = {
{ FR_CONF_OFFSET("cleanup_delay", FR_TYPE_TIME_DELTA, proto_dhcpv6_t, io.cleanup_delay), .dflt = "5.0" } ,
{ FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, proto_dhcpv6_t, io.idle_timeout), .dflt = "30.0" } ,
{ FR_CONF_OFFSET("nak_lifetime", FR_TYPE_TIME_DELTA, proto_dhcpv6_t, io.nak_lifetime), .dflt = "30.0" } ,
/** How to parse a DHCPV6 listen section
*
*/
-static CONF_PARSER const proto_dhcpv6_config[] = {
+static conf_parser_t const proto_dhcpv6_config[] = {
{ FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_MULTI | FR_TYPE_NOT_EMPTY, proto_dhcpv6_t,
allowed_types), .func = type_parse },
{ FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_dhcpv6_t, io.submodule),
* - -1 on failure.
*/
static int type_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
proto_dhcpv6_t *inst = talloc_get_type_abort(parent, proto_dhcpv6_t);
fr_dict_enum_value_t *dv;
* - -1 on failure.
*/
static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
char const *name = cf_pair_value(cf_item_to_pair(ci));
dl_module_inst_t *parent_inst;
} proto_dhcpv6_udp_t;
-static const CONF_PARSER networks_config[] = {
+static const conf_parser_t networks_config[] = {
{ FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX | FR_TYPE_MULTI, proto_dhcpv6_udp_t, allow) },
{ FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX | FR_TYPE_MULTI, proto_dhcpv6_udp_t, deny) },
};
-static const CONF_PARSER udp_listen_config[] = {
+static const conf_parser_t udp_listen_config[] = {
{ FR_CONF_OFFSET("ipaddr", FR_TYPE_IPV6_ADDR, proto_dhcpv6_udp_t, ipaddr) },
{ FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, proto_dhcpv6_udp_t, ipaddr) },
#include "proto_dns.h"
extern fr_app_t proto_dns;
-static int type_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
-static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
+static int type_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
+static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
-static const CONF_PARSER priority_config[] = {
+static const conf_parser_t priority_config[] = {
{ FR_CONF_OFFSET("query", FR_TYPE_VOID, 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 const limit_config[] = {
+static conf_parser_t const limit_config[] = {
{ FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, proto_dns_t, io.idle_timeout), .dflt = "30.0" } ,
{ FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, proto_dns_t, io.max_connections), .dflt = "1024" } ,
/** How to parse a DNS listen section
*
*/
-static CONF_PARSER const proto_dns_config[] = {
+static conf_parser_t const proto_dns_config[] = {
{ FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_MULTI | FR_TYPE_NOT_EMPTY, proto_dns_t,
allowed_types), .func = type_parse },
{ FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_dns_t, io.submodule),
* - -1 on failure.
*/
static int type_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
proto_dns_t *inst = talloc_get_type_abort(parent, proto_dns_t);
fr_dict_enum_value_t *dv;
* - -1 on failure.
*/
static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
char const *name = cf_pair_value(cf_item_to_pair(ci));
dl_module_inst_t *parent_inst;
} proto_dns_udp_t;
-static const CONF_PARSER networks_config[] = {
+static const conf_parser_t networks_config[] = {
{ FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX | FR_TYPE_MULTI, proto_dns_udp_t, allow) },
{ FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX | FR_TYPE_MULTI, proto_dns_udp_t, deny) },
};
-static const CONF_PARSER udp_listen_config[] = {
+static const conf_parser_t udp_listen_config[] = {
{ FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, proto_dns_udp_t, ipaddr) },
{ FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, proto_dns_udp_t, ipaddr) },
{ FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, proto_dns_udp_t, ipaddr) },
extern fr_app_t proto_ldap_sync;
-static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
+static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
-static CONF_PARSER const ldap_sync_search_config[] = {
+static conf_parser_t const ldap_sync_search_config[] = {
{ FR_CONF_OFFSET("base_dn", FR_TYPE_STRING, sync_config_t, base_dn), .dflt = "", .quote = T_SINGLE_QUOTED_STRING },
{ FR_CONF_OFFSET("filter", FR_TYPE_STRING, sync_config_t, filter) },
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER const proto_ldap_sync_config[] = {
+static conf_parser_t const proto_ldap_sync_config[] = {
{ FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_ldap_sync_t, io_submodule),
.func = transport_parse },
* - -1 on failure.
*/
static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
char const *name = cf_pair_value(cf_item_to_pair(ci));
dl_module_inst_t *parent_inst;
extern fr_app_io_t proto_ldap_sync_ldap;
extern fr_app_io_t proto_ldap_sync_child;
-static CONF_PARSER const proto_ldap_sync_ldap_config[] = {
+static conf_parser_t const proto_ldap_sync_ldap_config[] = {
/*
* LDAP server definition
*/
#include "proto_load.h"
extern fr_app_t proto_load;
-static int type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
-static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
+static int type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
+static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
/** How to parse a Load listen section
*
*/
-static CONF_PARSER const proto_load_config[] = {
+static conf_parser_t const proto_load_config[] = {
{ FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_NOT_EMPTY | FR_TYPE_REQUIRED, proto_load_t,
type), .func = type_parse },
{ FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_load_t, io.submodule),
* - 0 on success.
* - -1 on failure.
*/
-static int type_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+static int type_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
proto_load_t *inst = talloc_get_type_abort(parent, proto_load_t);
fr_dict_enum_value_t const *type_enum;
* - -1 on failure.
*/
static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
char const *name = cf_pair_value(cf_item_to_pair(ci));
dl_module_inst_t *parent_inst;
};
-static const CONF_PARSER load_listen_config[] = {
+static const conf_parser_t load_listen_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT | FR_TYPE_REQUIRED | FR_TYPE_NOT_EMPTY, proto_load_step_t, filename) },
{ FR_CONF_OFFSET("csv", FR_TYPE_STRING, proto_load_step_t, csv) },
extern fr_app_t proto_radius;
-static int type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
-static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
+static int type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
+static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
-static CONF_PARSER const limit_config[] = {
+static conf_parser_t const limit_config[] = {
{ FR_CONF_OFFSET("cleanup_delay", FR_TYPE_TIME_DELTA, proto_radius_t, io.cleanup_delay), .dflt = "5.0" } ,
{ FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, proto_radius_t, io.idle_timeout), .dflt = "30.0" } ,
{ FR_CONF_OFFSET("nak_lifetime", FR_TYPE_TIME_DELTA, proto_radius_t, io.nak_lifetime), .dflt = "30.0" } ,
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER priority_config[] = {
+static const conf_parser_t priority_config[] = {
{ FR_CONF_OFFSET("Access-Request", FR_TYPE_VOID, 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, proto_radius_t, priorities[FR_RADIUS_CODE_ACCOUNTING_REQUEST]),
/** How to parse a RADIUS listen section
*
*/
-static CONF_PARSER const proto_radius_config[] = {
+static conf_parser_t const proto_radius_config[] = {
{ FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_MULTI | FR_TYPE_NOT_EMPTY, proto_radius_t,
allowed_types), .func = type_parse },
{ FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_radius_t, io.submodule),
* - 0 on success.
* - -1 on failure.
*/
-static int type_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+static int type_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
proto_radius_t *inst = talloc_get_type_abort(parent, proto_radius_t);
fr_dict_enum_value_t *dv;
* - 0 on success.
* - -1 on failure.
*/
-static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
char const *name = cf_pair_value(cf_item_to_pair(ci));
dl_module_inst_t *parent_inst;
} proto_radius_tcp_t;
-static const CONF_PARSER networks_config[] = {
+static const conf_parser_t networks_config[] = {
{ FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX | FR_TYPE_MULTI, proto_radius_tcp_t, allow) },
{ FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX | FR_TYPE_MULTI, proto_radius_tcp_t, deny) },
};
-static const CONF_PARSER tcp_listen_config[] = {
+static const conf_parser_t tcp_listen_config[] = {
{ FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, proto_radius_tcp_t, ipaddr) },
{ FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, proto_radius_tcp_t, ipaddr) },
{ FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, proto_radius_tcp_t, ipaddr) },
} proto_radius_udp_t;
-static const CONF_PARSER networks_config[] = {
+static const conf_parser_t networks_config[] = {
{ FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX | FR_TYPE_MULTI, proto_radius_udp_t, allow) },
{ FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX | FR_TYPE_MULTI, proto_radius_udp_t, deny) },
};
-static const CONF_PARSER udp_listen_config[] = {
+static const conf_parser_t udp_listen_config[] = {
{ FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, proto_radius_udp_t, ipaddr) },
{ FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, proto_radius_udp_t, ipaddr) },
{ FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, proto_radius_udp_t, ipaddr) },
extern fr_app_t proto_tacacs;
-static int type_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, UNUSED CONF_PARSER const *rule);
-static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
+static int type_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, UNUSED conf_parser_t const *rule);
+static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
-static CONF_PARSER const limit_config[] = {
+static conf_parser_t const limit_config[] = {
{ FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, proto_tacacs_t, io.idle_timeout), .dflt = "30.0" } ,
{ FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, proto_tacacs_t, io.max_connections), .dflt = "1024" } ,
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER priority_config[] = {
+static const conf_parser_t priority_config[] = {
{ FR_CONF_OFFSET("Authentication-Start", FR_TYPE_VOID, 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, proto_tacacs_t, priorities[FR_TAC_PLUS_AUTHEN]),
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER proto_tacacs_config[] = {
+static const conf_parser_t proto_tacacs_config[] = {
{ FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_MULTI | FR_TYPE_NOT_EMPTY, proto_tacacs_t, allowed_types),
.func = type_parse },
{ FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_tacacs_t, io.submodule),
* - 0 on success.
* - -1 on failure.
*/
-static int type_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+static int type_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
proto_tacacs_t *inst = talloc_get_type_abort(parent, proto_tacacs_t);
fr_dict_enum_value_t *dv;
* - 0 on success.
* - -1 on failure.
*/
-static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
char const *name = cf_pair_value(cf_item_to_pair(ci));
dl_module_inst_t *parent_inst;
fr_ipaddr_t *deny; //!< denied networks for dynamic clients
} proto_tacacs_tcp_t;
-static const CONF_PARSER networks_config[] = {
+static const conf_parser_t networks_config[] = {
{ FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX | FR_TYPE_MULTI, proto_tacacs_tcp_t, allow) },
{ FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX | FR_TYPE_MULTI, proto_tacacs_tcp_t, deny) },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER tcp_listen_config[] = {
+static const conf_parser_t tcp_listen_config[] = {
{ FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, proto_tacacs_tcp_t, ipaddr) },
{ FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, proto_tacacs_tcp_t, ipaddr) },
{ FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, proto_tacacs_tcp_t, ipaddr) },
extern fr_app_t proto_vmps;
static int type_parse(TALLOC_CTX *ctx, void *out, void *parent,
- CONF_ITEM *ci, CONF_PARSER const *rule);
+ CONF_ITEM *ci, conf_parser_t const *rule);
static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, CONF_PARSER const *rule);
+ CONF_ITEM *ci, conf_parser_t const *rule);
-static const CONF_PARSER priority_config[] = {
+static const conf_parser_t priority_config[] = {
{ FR_CONF_OFFSET("Join-Request", FR_TYPE_VOID, 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, proto_vmps_t, priorities[FR_PACKET_TYPE_VALUE_RECONFIRM_REQUEST]),
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER const limit_config[] = {
+static conf_parser_t const limit_config[] = {
{ FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, proto_vmps_t, io.idle_timeout), .dflt = "30.0" } ,
{ FR_CONF_OFFSET("nak_lifetime", FR_TYPE_TIME_DELTA, proto_vmps_t, io.nak_lifetime), .dflt = "30.0" } ,
/** How to parse a VMPS listen section
*
*/
-static CONF_PARSER const proto_vmps_config[] = {
+static conf_parser_t const proto_vmps_config[] = {
{ FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_MULTI | FR_TYPE_NOT_EMPTY, proto_vmps_t,
allowed_types), .func = type_parse },
{ FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_vmps_t, io.submodule),
* - -1 on failure.
*/
static int type_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
proto_vmps_t *inst = talloc_get_type_abort(parent, proto_vmps_t);
fr_dict_enum_value_t *dv;
* - -1 on failure.
*/
static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
char const *name = cf_pair_value(cf_item_to_pair(ci));
dl_module_inst_t *parent_inst;
} proto_vmps_udp_t;
-static const CONF_PARSER networks_config[] = {
+static const conf_parser_t networks_config[] = {
{ FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX | FR_TYPE_MULTI, proto_vmps_udp_t, allow) },
{ FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX | FR_TYPE_MULTI, proto_vmps_udp_t, deny) },
};
-static const CONF_PARSER udp_listen_config[] = {
+static const conf_parser_t udp_listen_config[] = {
{ FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, proto_vmps_udp_t, ipaddr) },
{ FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, proto_vmps_udp_t, ipaddr) },
{ FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, proto_vmps_udp_t, ipaddr) },
/*
* A mapping of configuration file names to internal variables.
*/
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("rcode", FR_TYPE_STRING, rlm_always_t, rcode_str), .dflt = "fail" },
{ FR_CONF_OFFSET("simulcount", FR_TYPE_UINT32, rlm_always_t, simulcount), .dflt = "0" },
{ FR_CONF_OFFSET("mpp", FR_TYPE_BOOL, rlm_always_t, mpp), .dflt = "no" },
PAIR_LIST_LIST attrs;
} rlm_attr_filter_t;
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT | FR_TYPE_REQUIRED, rlm_attr_filter_t, filename) },
{ FR_CONF_OFFSET("key", FR_TYPE_TMPL, rlm_attr_filter_t, key), .dflt = "&Realm", .quote = T_BARE_WORD },
{ FR_CONF_OFFSET("relaxed", FR_TYPE_BOOL, rlm_attr_filter_t, relaxed), .dflt = "no" },
fr_pool_t *pool;
} rlm_cache_memcached_t;
-static const CONF_PARSER driver_config[] = {
+static const conf_parser_t driver_config[] = {
{ FR_CONF_OFFSET("options", FR_TYPE_STRING, rlm_cache_memcached_t, options), .dflt = "--SERVER=localhost" },
CONF_PARSER_TERMINATOR
};
#include "../../rlm_cache.h"
#include <freeradius-devel/redis/base.h>
#include <freeradius-devel/redis/cluster.h>
-static CONF_PARSER driver_config[] = {
+static conf_parser_t driver_config[] = {
REDIS_COMMON_CONFIG,
CONF_PARSER_TERMINATOR
};
extern module_rlm_t rlm_cache;
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("driver", FR_TYPE_VOID, rlm_cache_t, driver_submodule), .dflt = "rbtree",
.func = module_rlm_submodule_parse },
{ FR_CONF_OFFSET("ttl", FR_TYPE_TIME_DELTA, rlm_cache_config_t, ttl), .dflt = "500s" },
size_t min_challenge_len;
} rlm_chap_t;
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("min_challenge_len", FR_TYPE_SIZE, rlm_chap_t, min_challenge_len), .dflt = "16" },
CONF_PARSER_TERMINATOR
};
#include <openssl/x509.h>
static int digest_type_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule);
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule);
static int cipher_rsa_padding_type_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule);
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule);
static int cipher_type_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule);
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule);
static int cipher_rsa_private_key_file_load(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule);
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule);
static int cipher_rsa_certificate_file_load(TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule);
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule);
typedef enum {
RLM_CIPHER_TYPE_INVALID = 0,
/** Configuration for the RSA-PCKS1-OAEP padding scheme
*
*/
-static const CONF_PARSER rsa_oaep_config[] = {
+static const conf_parser_t rsa_oaep_config[] = {
{ FR_CONF_OFFSET("oaep_digest", FR_TYPE_VOID | FR_TYPE_NOT_EMPTY, cipher_rsa_oaep_t, oaep_digest), .func = digest_type_parse, .dflt = "sha256" },
{ FR_CONF_OFFSET("mgf1_digest", FR_TYPE_VOID | FR_TYPE_NOT_EMPTY, cipher_rsa_oaep_t, mgf1_digest), .func = digest_type_parse, .dflt = "sha256" },
{ FR_CONF_OFFSET("label", FR_TYPE_STRING, cipher_rsa_oaep_t, label) },
/** Configuration for the RSA cipher type
*
*/
-static const CONF_PARSER rsa_config[] = {
+static const conf_parser_t rsa_config[] = {
{ FR_CONF_OFFSET("verify_mode", FR_TYPE_VOID, cipher_rsa_t, verify_mode),
.func = cf_table_parse_int,
.uctx = &(cf_table_parse_ctx_t){
/*
* A mapping of configuration file names to internal variables.
*/
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_NOT_EMPTY, rlm_cipher_t, type), .func = cipher_type_parse, .dflt = "rsa" },
{ FR_CONF_OFFSET("rsa", FR_TYPE_SUBSECTION, rlm_cipher_t, rsa),
.subcs_size = sizeof(cipher_rsa_t), .subcs_type = "cipher_rsa_t", .subcs = (void const *) rsa_config },
* - -1 on failure.
*/
static int digest_type_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
EVP_MD const *md;
char const *type_str;
* - -1 on failure.
*/
static int cipher_rsa_padding_type_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
int type;
char const *type_str;
* - 0 on success.
* - -1 on failure.
*/
-static int cipher_type_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+static int cipher_type_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
cipher_type_t type;
char const *type_str;
* - 0 on success.
*/
static int cipher_rsa_private_key_file_load(TALLOC_CTX *ctx, void *out, void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
FILE *fp;
char const *filename;
* - 0 on success.
*/
static int cipher_rsa_certificate_file_load(TALLOC_CTX *ctx, void *out, void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
FILE *fp;
char const *filename;
/**
* Client Configuration
*/
-static const CONF_PARSER client_config[] = {
+static const conf_parser_t client_config[] = {
{ FR_CONF_OFFSET("view", FR_TYPE_STRING, rlm_couchbase_t, client_view), .dflt = "_design/client/_view/by_name" },
CONF_PARSER_TERMINATOR
};
/**
* Module Configuration
*/
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("server", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_couchbase_t, server_raw) },
{ FR_CONF_OFFSET("bucket", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_couchbase_t, bucket) },
{ FR_CONF_OFFSET("username", FR_TYPE_STRING, rlm_couchbase_t, username) },
/*
* A mapping of configuration file names to internal variables.
*/
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT | FR_TYPE_REQUIRED | FR_TYPE_NOT_EMPTY, rlm_csv_t, filename) },
{ FR_CONF_OFFSET("delimiter", FR_TYPE_STRING | FR_TYPE_NOT_EMPTY, rlm_csv_t, delimiter), .dflt = "," },
{ FR_CONF_OFFSET("fields", FR_TYPE_STRING , rlm_csv_t, fields) },
bool utc;
} rlm_date_t;
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("format", FR_TYPE_STRING, rlm_date_t, fmt), .dflt = "%b %e %Y %H:%M:%S %Z" },
{ FR_CONF_OFFSET("utc", FR_TYPE_BOOL, rlm_date_t, utc), .dflt = "no" },
CONF_PARSER_TERMINATOR
.bootstrap = mod_bootstrap
}
};
-
/*
* A mapping of configuration file names to internal variables.
*/
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("delay", FR_TYPE_TMPL, rlm_delay_t, delay) },
{ FR_CONF_OFFSET("relative", FR_TYPE_BOOL, rlm_delay_t, relative), .dflt = "no" },
{ FR_CONF_OFFSET("force_reschedule", FR_TYPE_BOOL, rlm_delay_t, force_reschedule), .dflt = "no" },
} rlm_detail_t;
int detail_group_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent,
- CONF_ITEM *ci, CONF_PARSER const *rule);
+ CONF_ITEM *ci, conf_parser_t const *rule);
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_OUTPUT | FR_TYPE_XLAT, rlm_detail_t, filename), .dflt = "%A/%{Net.Src.IP}/detail" },
{ FR_CONF_OFFSET("header", FR_TYPE_TMPL | FR_TYPE_XLAT, rlm_detail_t, header),
.dflt = "%t", .quote = T_DOUBLE_QUOTED_STRING },
*
*/
int detail_group_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
char const *group;
char *endptr;
uint32_t xid; //!< XID
} rlm_dhcpv4_thread_t;
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("ipaddr", FR_TYPE_IPV4_ADDR, rlm_dhcpv4_t, config.ipaddr), },
{ FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, rlm_dhcpv4_t, config.ipaddr) },
} eap_auth_rctx_t;
static int submodule_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule);
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule);
static int eap_type_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule);
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule);
static fr_table_num_sorted_t const require_identity_realm_table[] = {
{ L("nai"), REQUIRE_REALM_NAI },
};
static size_t require_identity_realm_table_len = NUM_ELEMENTS(require_identity_realm_table);
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("require_identity_realm", FR_TYPE_VOID, 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 },
* - -1 on failure.
*/
static int submodule_parse(TALLOC_CTX *ctx, void *out, void *parent,
- CONF_ITEM *ci, CONF_PARSER const *rule)
+ CONF_ITEM *ci, conf_parser_t const *rule)
{ char const *name = cf_pair_value(cf_item_to_pair(ci));
char *our_name = NULL;
char *p;
* - -1 on failure.
*/
static int eap_type_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
char const *default_method_name = cf_pair_value(cf_item_to_pair(ci));
eap_type_t method;
#include <freeradius-devel/util/rand.h>
#include <freeradius-devel/util/debug.h>
-static CONF_PARSER submodule_config[] = {
+static conf_parser_t submodule_config[] = {
{ FR_CONF_OFFSET("virtual_server", FR_TYPE_VOID, eap_aka_sim_module_conf_t, virtual_server), .func = virtual_server_cf_parse },
{ FR_CONF_OFFSET_IS_SET("prefer_aka_prime", FR_TYPE_BOOL, eap_aka_sim_module_conf_t, aka.send_at_bidding_prefer_prime ), .dflt = "no" },
#include <freeradius-devel/util/rand.h>
#include <freeradius-devel/util/debug.h>
-static CONF_PARSER submodule_config[] = {
+static conf_parser_t submodule_config[] = {
{ FR_CONF_OFFSET("virtual_server", FR_TYPE_VOID, eap_aka_sim_module_conf_t, virtual_server), .func = virtual_server_cf_parse },
CONF_PARSER_TERMINATOR
} rlm_eap_fast_t;
-static CONF_PARSER submodule_config[] = {
+static conf_parser_t submodule_config[] = {
{ FR_CONF_OFFSET("tls", FR_TYPE_STRING, rlm_eap_fast_t, tls_conf_name) },
{ FR_CONF_OFFSET("default_provisioning_eap_type", FR_TYPE_STRING, rlm_eap_fast_t, default_provisioning_method_name), .dflt = "mschapv2" },
#include <freeradius-devel/unlang/interpret.h>
static int auth_type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule);
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule);
/*
* EAP-GTC is just ASCII data carried inside of the EAP session.
fr_dict_enum_value_t const *auth_type;
} rlm_eap_gtc_t;
-static CONF_PARSER submodule_config[] = {
+static conf_parser_t submodule_config[] = {
{ FR_CONF_OFFSET("challenge", FR_TYPE_STRING, rlm_eap_gtc_t, challenge), .dflt = "Password: " },
{ FR_CONF_OFFSET("auth_type", FR_TYPE_VOID, rlm_eap_gtc_t, auth_type), .func = auth_type_parse, .dflt = "pap" },
CONF_PARSER_TERMINATOR
* - -1 on failure.
*/
static int auth_type_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
char const *auth_type = cf_pair_value(cf_item_to_pair(ci));
#include "eap_mschapv2.h"
static int auth_type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule);
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule);
typedef struct {
bool with_ntdomain_hack;
fr_dict_enum_value_t *auth_type;
} rlm_eap_mschapv2_t;
-static CONF_PARSER submodule_config[] = {
+static conf_parser_t submodule_config[] = {
{ FR_CONF_OFFSET("with_ntdomain_hack", FR_TYPE_BOOL, rlm_eap_mschapv2_t, with_ntdomain_hack), .dflt = "no" },
{ FR_CONF_OFFSET("auth_type", FR_TYPE_VOID, rlm_eap_mschapv2_t, auth_type), .func = auth_type_parse, .dflt = "mschap" },
* - -1 on failure.
*/
static int auth_type_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
char const *auth_type = cf_pair_value(cf_item_to_pair(ci));
bool req_client_cert; //!< Do we do require a client cert?
} rlm_eap_peap_t;
-static CONF_PARSER submodule_config[] = {
+static conf_parser_t submodule_config[] = {
{ FR_CONF_OFFSET("tls", FR_TYPE_STRING, rlm_eap_peap_t, tls_conf_name) },
{ FR_CONF_DEPRECATED("copy_request_to_tunnel", FR_TYPE_BOOL, rlm_eap_peap_t, NULL), .dflt = "no" },
#define MPPE_KEY_LEN 32
#define MSK_EMSK_LEN (2 * MPPE_KEY_LEN)
-static CONF_PARSER submodule_config[] = {
+static conf_parser_t submodule_config[] = {
{ FR_CONF_OFFSET("group", FR_TYPE_UINT32, rlm_eap_pwd_t, group), .dflt = "19" },
{ FR_CONF_OFFSET("fragment_size", FR_TYPE_UINT32, rlm_eap_pwd_t, fragment_size), .dflt = "1020" },
{ FR_CONF_OFFSET("server_id", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_eap_pwd_t, server_id) },
.provides = { FR_EAP_METHOD_PWD },
.session_init = mod_session_init, /* Create the initial request */
};
-
#include <freeradius-devel/util/rand.h>
#include <freeradius-devel/util/debug.h>
-static CONF_PARSER submodule_config[] = {
+static conf_parser_t submodule_config[] = {
{ FR_CONF_OFFSET("virtual_server", FR_TYPE_VOID | FR_TYPE_REQUIRED, eap_aka_sim_module_conf_t, virtual_server), .func = virtual_server_cf_parse },
CONF_PARSER_TERMINATOR
};
SSL_CTX *ssl_ctx; //!< Thread local SSL_CTX.
} rlm_eap_tls_thread_t;
-static CONF_PARSER submodule_config[] = {
+static conf_parser_t submodule_config[] = {
{ FR_CONF_OFFSET("tls", FR_TYPE_STRING, rlm_eap_tls_t, tls_conf_name) },
{ FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOL, rlm_eap_tls_t, req_client_cert), .dflt = "yes" },
} rlm_eap_ttls_t;
-static CONF_PARSER submodule_config[] = {
+static conf_parser_t submodule_config[] = {
{ FR_CONF_OFFSET("tls", FR_TYPE_STRING, rlm_eap_ttls_t, tls_conf_name) },
{ FR_CONF_DEPRECATED("copy_request_to_tunnel", FR_TYPE_BOOL, rlm_eap_ttls_t, NULL), .dflt = "no" },
{ FR_CONF_DEPRECATED("use_tunneled_reply", FR_TYPE_BOOL, rlm_eap_ttls_t, NULL), .dflt = "no" },
char const *allowed_chars;
} rlm_escape_t;
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("safe_characters", FR_TYPE_STRING, rlm_escape_t, allowed_chars), .dflt = "@abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-_: /" },
CONF_PARSER_TERMINATOR
};
bool timeout_is_set;
} rlm_exec_t;
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("wait", FR_TYPE_BOOL, rlm_exec_t, wait), .dflt = "yes" },
{ FR_CONF_OFFSET("input_pairs", FR_TYPE_TMPL, rlm_exec_t, input_list) },
{ FR_CONF_OFFSET("output_pairs", FR_TYPE_TMPL, rlm_exec_t, output_list) },
};
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT, rlm_files_t, filename) },
{ FR_CONF_OFFSET("usersfile", FR_TYPE_FILE_INPUT, rlm_files_t, usersfile) },
{ FR_CONF_OFFSET("acctusersfile", FR_TYPE_FILE_INPUT, rlm_files_t, acct_usersfile) },
return ((uint16_t) ~sum);
}
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("interface", FR_TYPE_STRING, rlm_icmp_t, interface) },
{ FR_CONF_OFFSET("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, rlm_icmp_t, src_ipaddr) },
{ FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, rlm_icmp_t, timeout), .dflt = "1s" },
/*
* A mapping of configuration file names to internal variables.
*/
-static const CONF_PARSER mod_config[] = {
+static const conf_parser_t mod_config[] = {
/*
* If a STRINGPREP profile other than NAMEPREP is ever desired,
* we can implement an option, and it will default to NAMEPREP settings.
/*
* A mapping of configuration file names to internal variables.
*/
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("uri", FR_TYPE_STRING, rlm_imap_t, uri) },
{ FR_CONF_OFFSET("timeout",FR_TYPE_TIME_DELTA, rlm_imap_t, timeout), .dflt = "5.0" },
{ FR_CONF_OFFSET("tls", FR_TYPE_SUBSECTION, rlm_imap_t, tls), .subcs = (void const *) fr_curl_tls_config },//!<loading the tls values
/*
* A mapping of configuration file names to internal variables.
*/
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT | FR_TYPE_REQUIRED | FR_TYPE_NOT_EMPTY, rlm_isc_dhcp_t, filename) },
{ FR_CONF_OFFSET("debug", FR_TYPE_BOOL, rlm_isc_dhcp_t, debug) },
{ FR_CONF_OFFSET("pedantic", FR_TYPE_BOOL, rlm_isc_dhcp_t, pedantic) },
} rlm_json_t;
-static CONF_PARSER const module_config[] = {
+static conf_parser_t const module_config[] = {
{ FR_CONF_OFFSET("encode", FR_TYPE_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 },
#include <freeradius-devel/util/debug.h>
#include "krb5.h"
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("keytab", FR_TYPE_STRING, rlm_krb5_t, keytabname) },
{ FR_CONF_OFFSET("service_principal", FR_TYPE_STRING, rlm_krb5_t, service_princ) },
CONF_PARSER_TERMINATOR
CALL_ENV_TERMINATOR
};
-static CONF_PARSER profile_config[] = {
+static conf_parser_t profile_config[] = {
{ FR_CONF_OFFSET("scope", FR_TYPE_INT32, 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, rlm_ldap_t, profile_attr) },
/*
* User configuration
*/
-static CONF_PARSER user_config[] = {
+static conf_parser_t user_config[] = {
{ FR_CONF_OFFSET("scope", FR_TYPE_INT32, 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, rlm_ldap_t, userobj_sort_by) },
/*
* Group configuration
*/
-static CONF_PARSER group_config[] = {
+static conf_parser_t group_config[] = {
{ FR_CONF_OFFSET("filter", FR_TYPE_STRING, rlm_ldap_t, groupobj_filter) },
{ FR_CONF_OFFSET("scope", FR_TYPE_INT32, 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 } },
/*
* Reference for accounting updates
*/
-static const CONF_PARSER acct_section_config[] = {
+static const conf_parser_t acct_section_config[] = {
{ FR_CONF_OFFSET("reference", FR_TYPE_STRING | FR_TYPE_XLAT, ldap_acct_section_t, reference), .dflt = "." },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
/*
* Pool config items
*/
} linelog_conn_t;
-static const CONF_PARSER file_config[] = {
+static const conf_parser_t file_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_OUTPUT | FR_TYPE_XLAT, rlm_linelog_t, file.name) },
{ FR_CONF_OFFSET("permissions", FR_TYPE_UINT32, rlm_linelog_t, file.permissions), .dflt = "0600" },
{ FR_CONF_OFFSET("group", FR_TYPE_STRING, rlm_linelog_t, file.group_str) },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER syslog_config[] = {
+static const conf_parser_t syslog_config[] = {
{ FR_CONF_OFFSET("facility", FR_TYPE_STRING, rlm_linelog_t, syslog.facility) },
{ FR_CONF_OFFSET("severity", FR_TYPE_STRING, rlm_linelog_t, syslog.severity), .dflt = "info" },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER unix_config[] = {
+static const conf_parser_t unix_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT, rlm_linelog_t, unix_sock.path) },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER udp_config[] = {
+static const conf_parser_t udp_config[] = {
{ FR_CONF_OFFSET("server", FR_TYPE_COMBO_IP_ADDR, linelog_net_t, dst_ipaddr) },
{ FR_CONF_OFFSET("port", FR_TYPE_UINT16, linelog_net_t, port) },
{ FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, linelog_net_t, timeout), .dflt = "1000" },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER tcp_config[] = {
+static const conf_parser_t tcp_config[] = {
{ FR_CONF_OFFSET("server", FR_TYPE_COMBO_IP_ADDR, linelog_net_t, dst_ipaddr) },
{ FR_CONF_OFFSET("port", FR_TYPE_UINT16, linelog_net_t, port) },
{ FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, linelog_net_t, timeout), .dflt = "1000" },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("destination", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_linelog_t, log_dst_str) },
{ FR_CONF_OFFSET("delimiter", FR_TYPE_STRING, rlm_linelog_t, delimiter), .dflt = "\n" },
} rlm_logtee_thread_t;
-static const CONF_PARSER file_config[] = {
+static const conf_parser_t file_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_OUTPUT | FR_TYPE_XLAT, rlm_logtee_t, file.name) },
{ FR_CONF_OFFSET("permissions", FR_TYPE_UINT32, rlm_logtee_t, file.permissions), .dflt = "0600" },
{ FR_CONF_OFFSET("group", FR_TYPE_STRING, rlm_logtee_t, file.group_str) },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER unix_config[] = {
+static const conf_parser_t unix_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT, rlm_logtee_t, unix_sock.path) },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER udp_config[] = {
+static const conf_parser_t udp_config[] = {
{ FR_CONF_OFFSET("server", FR_TYPE_COMBO_IP_ADDR, logtee_net_t, dst_ipaddr) },
{ FR_CONF_OFFSET("port", FR_TYPE_UINT16, logtee_net_t, port) },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER tcp_config[] = {
+static const conf_parser_t tcp_config[] = {
{ FR_CONF_OFFSET("server", FR_TYPE_COMBO_IP_ADDR, logtee_net_t, dst_ipaddr) },
{ FR_CONF_OFFSET("port", FR_TYPE_UINT16, logtee_net_t, port) },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("destination", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_logtee_t, log_dst_str) },
{ FR_CONF_OFFSET("buffer_depth", FR_TYPE_SIZE, rlm_logtee_t, buffer_depth), .dflt = "10000" },
* to the strdup'd string into 'config.string'. This gets around
* buffer over-flows.
*/
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT | FR_TYPE_REQUIRED, rlm_lua_t, module), NULL},
{ FR_CONF_OFFSET("func_instantiate", FR_TYPE_STRING, rlm_lua_t, func_instantiate), NULL},
{ FR_CONF_OFFSET("func_detach", FR_TYPE_STRING, rlm_lua_t, func_detach), NULL},
/*
* A mapping of configuration file names to internal variables.
*/
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT | FR_TYPE_REQUIRED, rlm_mruby_t, filename) },
{ FR_CONF_OFFSET("module", FR_TYPE_STRING, rlm_mruby_t, module_name), .dflt = "Radiusd" },
CONF_PARSER_TERMINATOR
#define ACB_AUTOLOCK 0x04000000 //!< Account auto locked.
#define ACB_FR_EXPIRED 0x00020000 //!< Password Expired.
-static const CONF_PARSER passchange_config[] = {
+static const conf_parser_t passchange_config[] = {
{ FR_CONF_OFFSET("ntlm_auth", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_mschap_t, ntlm_cpw) },
{ FR_CONF_OFFSET("ntlm_auth_username", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_mschap_t, ntlm_cpw_username) },
{ FR_CONF_OFFSET("ntlm_auth_domain", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_mschap_t, ntlm_cpw_domain) },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER winbind_config[] = {
+static const conf_parser_t winbind_config[] = {
{ FR_CONF_OFFSET("username", FR_TYPE_TMPL, rlm_mschap_t, wb_username) },
{ FR_CONF_OFFSET("domain", FR_TYPE_TMPL, rlm_mschap_t, wb_domain) },
#ifdef WITH_AUTH_WINBIND
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("normalise", FR_TYPE_BOOL, rlm_mschap_t, normify), .dflt = "yes" },
/*
#ifdef HAVE_OPENSSL_OCSP_H
-static CONF_PARSER ocsp_config[] = {
+static conf_parser_t ocsp_config[] = {
{ FR_CONF_OFFSET("enable", FR_TYPE_BOOL, fr_tls_ocsp_conf_t, enable), .dflt = "no" },
{ FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING, fr_tls_ocsp_conf_t, cache_server) },
bool error; //!< True if pam_conv failed.
} rlm_pam_data_t;
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("pam_auth", FR_TYPE_STRING, 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 module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("normalise", FR_TYPE_BOOL, rlm_pap_t, normify), .dflt = "yes" },
CONF_PARSER_TERMINATOR
};
bool ignore_empty;
} rlm_passwd_t;
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT | FR_TYPE_REQUIRED, rlm_passwd_t, filename) },
{ FR_CONF_OFFSET("format", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_passwd_t, format) },
{ FR_CONF_OFFSET("delimiter", FR_TYPE_STRING, rlm_passwd_t, delimiter), .dflt = ":" },
#define RLM_PERL_CONF(_x) { FR_CONF_OFFSET("func_" STRINGIFY(_x), FR_TYPE_STRING, rlm_perl_t, func_##_x), \
.data = NULL, .dflt = STRINGIFY(_x), .quote = T_INVALID }
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT | FR_TYPE_REQUIRED, rlm_perl_t, module) },
RLM_PERL_CONF(authorize),
.path_include_default = true
};
-static CONF_PARSER const python_global_config[] = {
+static conf_parser_t const python_global_config[] = {
{ FR_CONF_OFFSET("path", FR_TYPE_STRING, libpython_global_config_t, path) },
{ FR_CONF_OFFSET("path_include_default", FR_TYPE_BOOL, libpython_global_config_t, path_include_default) },
CONF_PARSER_TERMINATOR
/*
* A mapping of configuration file names to internal variables.
*/
-static CONF_PARSER module_config[] = {
+static conf_parser_t module_config[] = {
#define A(x) { FR_CONF_OFFSET("mod_" #x, FR_TYPE_STRING, rlm_python_t, x.module_name), .dflt = "${.module}" }, \
{ FR_CONF_OFFSET("func_" #x, FR_TYPE_STRING, rlm_python_t, x.function_name) },
#include "rlm_radius.h"
-static int type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
-static int status_check_type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
-static int status_check_update_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
+static int type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
+static int status_check_type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
+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 const status_check_config[] = {
+static conf_parser_t const status_check_config[] = {
{ FR_CONF_OFFSET("type", FR_TYPE_VOID, rlm_radius_t, status_check),
.func = status_check_type_parse },
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER const status_check_update_config[] = {
+static conf_parser_t const status_check_update_config[] = {
{ FR_CONF_OFFSET("update", FR_TYPE_SUBSECTION | FR_TYPE_REQUIRED, rlm_radius_t, status_check_map),
.ident2 = CF_IDENT_ANY,
.func = status_check_update_parse },
/*
* Retransmission intervals for the packets we support.
*/
-static CONF_PARSER auth_config[] = {
+static conf_parser_t auth_config[] = {
{ FR_CONF_OFFSET("initial_rtx_time", FR_TYPE_TIME_DELTA, rlm_radius_t, retry[FR_RADIUS_CODE_ACCESS_REQUEST].irt), .dflt = STRINGIFY(2) },
{ FR_CONF_OFFSET("max_rtx_time", FR_TYPE_TIME_DELTA, rlm_radius_t, retry[FR_RADIUS_CODE_ACCESS_REQUEST].mrt), .dflt = STRINGIFY(16) },
{ FR_CONF_OFFSET("max_rtx_count", FR_TYPE_UINT32, rlm_radius_t, retry[FR_RADIUS_CODE_ACCESS_REQUEST].mrc), .dflt = STRINGIFY(5) },
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER acct_config[] = {
+static conf_parser_t acct_config[] = {
{ FR_CONF_OFFSET("initial_rtx_time", FR_TYPE_TIME_DELTA, rlm_radius_t, retry[FR_RADIUS_CODE_ACCOUNTING_REQUEST].irt), .dflt = STRINGIFY(2) },
{ FR_CONF_OFFSET("max_rtx_time", FR_TYPE_TIME_DELTA, rlm_radius_t, retry[FR_RADIUS_CODE_ACCOUNTING_REQUEST].mrt), .dflt = STRINGIFY(5) },
{ FR_CONF_OFFSET("max_rtx_count", FR_TYPE_UINT32, rlm_radius_t, retry[FR_RADIUS_CODE_ACCOUNTING_REQUEST].mrc), .dflt = STRINGIFY(1) },
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER status_config[] = {
+static conf_parser_t status_config[] = {
{ FR_CONF_OFFSET("initial_rtx_time", FR_TYPE_TIME_DELTA, rlm_radius_t, retry[FR_RADIUS_CODE_STATUS_SERVER].irt), .dflt = STRINGIFY(2) },
{ FR_CONF_OFFSET("max_rtx_time", FR_TYPE_TIME_DELTA, rlm_radius_t, retry[FR_RADIUS_CODE_STATUS_SERVER].mrt), .dflt = STRINGIFY(5) },
{ FR_CONF_OFFSET("max_rtx_count", FR_TYPE_UINT32, rlm_radius_t, retry[FR_RADIUS_CODE_STATUS_SERVER].mrc), .dflt = STRINGIFY(5) },
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER coa_config[] = {
+static conf_parser_t coa_config[] = {
{ FR_CONF_OFFSET("initial_rtx_time", FR_TYPE_TIME_DELTA, rlm_radius_t, retry[FR_RADIUS_CODE_COA_REQUEST].irt), .dflt = STRINGIFY(2) },
{ FR_CONF_OFFSET("max_rtx_time", FR_TYPE_TIME_DELTA, rlm_radius_t, retry[FR_RADIUS_CODE_COA_REQUEST].mrt), .dflt = STRINGIFY(16) },
{ FR_CONF_OFFSET("max_rtx_count", FR_TYPE_UINT32, rlm_radius_t, retry[FR_RADIUS_CODE_COA_REQUEST].mrc), .dflt = STRINGIFY(5) },
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER disconnect_config[] = {
+static conf_parser_t disconnect_config[] = {
{ FR_CONF_OFFSET("initial_rtx_time", FR_TYPE_TIME_DELTA, rlm_radius_t, retry[FR_RADIUS_CODE_DISCONNECT_REQUEST].irt), .dflt = STRINGIFY(2) },
{ FR_CONF_OFFSET("max_rtx_time", FR_TYPE_TIME_DELTA, rlm_radius_t, retry[FR_RADIUS_CODE_DISCONNECT_REQUEST].mrt), .dflt = STRINGIFY(16) },
{ FR_CONF_OFFSET("max_rtx_count", FR_TYPE_UINT32, rlm_radius_t, retry[FR_RADIUS_CODE_DISCONNECT_REQUEST].mrc), .dflt = STRINGIFY(5) },
/*
* A mapping of configuration file names to internal variables.
*/
-static CONF_PARSER const module_config[] = {
+static conf_parser_t const module_config[] = {
{ FR_CONF_OFFSET("transport", FR_TYPE_VOID, rlm_radius_t, io_submodule),
.func = module_rlm_submodule_parse },
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER const type_interval_config[FR_RADIUS_CODE_MAX] = {
+static conf_parser_t const type_interval_config[FR_RADIUS_CODE_MAX] = {
[FR_RADIUS_CODE_ACCESS_REQUEST] = { FR_CONF_POINTER("Access-Request", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) auth_config },
[FR_RADIUS_CODE_ACCOUNTING_REQUEST] = { FR_CONF_POINTER("Accounting-Request", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) acct_config },
* - -1 on failure.
*/
static int type_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
char const *type_str = cf_pair_value(cf_item_to_pair(ci));
CONF_SECTION *cs = cf_item_to_section(cf_parent(ci));
* - -1 on failure.
*/
static int status_check_type_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
char const *type_str = cf_pair_value(cf_item_to_pair(ci));
CONF_SECTION *cs = cf_item_to_section(cf_parent(ci));
* - -1 on failure.
*/
static int status_check_update_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
int rcode;
CONF_SECTION *cs;
fr_retry_t retry; //!< retransmission timers
};
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, rlm_radius_udp_t, dst_ipaddr), },
{ FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, rlm_radius_udp_t, dst_ipaddr) },
{ FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, rlm_radius_udp_t, dst_ipaddr) },
bool caller_id_ok;
} rlm_radutmp_t;
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_OUTPUT, rlm_radutmp_t, filename), .dflt = RADUTMP },
{ FR_CONF_OFFSET("username", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_radutmp_t, username), .dflt = "%{User-Name}" },
{ FR_CONF_OFFSET("check_with_nas", FR_TYPE_BOOL, rlm_radutmp_t, check_nas), .dflt = "yes" },
fr_redis_cluster_t *cluster; //!< Redis cluster.
} rlm_redis_t;
-static int lua_func_body_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
+static int lua_func_body_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
-static CONF_PARSER module_lua_func[] = {
+static conf_parser_t module_lua_func[] = {
{ FR_CONF_OFFSET("body", FR_TYPE_STRING, redis_lua_func_t, body), .func = lua_func_body_parse },
{ FR_CONF_OFFSET("read_only", FR_TYPE_BOOL, redis_lua_func_t, read_only) },
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER module_lua[] = {
+static conf_parser_t module_lua[] = {
{ FR_CONF_SUBSECTION_ALLOC("function", FR_TYPE_SUBSECTION | FR_TYPE_MULTI | FR_TYPE_OK_MISSING,
rlm_redis_lua_t, funcs, module_lua_func),
.subcs_type = "redis_lua_func_t", .ident2 = CF_IDENT_ANY },
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER module_config[] = {
+static conf_parser_t module_config[] = {
{ FR_CONF_OFFSET_SUBSECTION("lua", 0, rlm_redis_t, lua, module_lua) },
REDIS_COMMON_CONFIG,
CONF_PARSER_TERMINATOR
/** Do basic processing for a lua function body and compute its sha1 hash
*
*/
-static int lua_func_body_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, CONF_PARSER const *rule)
+static int lua_func_body_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule)
{
int ret;
redis_lua_func_t *func = talloc_get_type_abort(parent, redis_lua_func_t);
fr_redis_cluster_t *cluster; //!< Redis cluster.
} rlm_redis_ippool_t;
-static CONF_PARSER redis_config[] = {
+static conf_parser_t redis_config[] = {
REDIS_COMMON_CONFIG,
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER module_config[] = {
+static conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("wait_num", FR_TYPE_UINT32, rlm_redis_ippool_t, wait_num) },
{ FR_CONF_OFFSET("wait_timeout", FR_TYPE_TIME_DELTA, rlm_redis_ippool_t, wait_timeout) },
uint64_t static_1d; //!< Static leases that should renew in the next day.
} ippool_tool_stats_t;
-static CONF_PARSER redis_config[] = {
+static conf_parser_t redis_config[] = {
REDIS_COMMON_CONFIG,
CONF_PARSER_TERMINATOR
};
char const *expire; //!< Command for expiring entries.
} rlm_rediswho_t;
-static CONF_PARSER section_config[] = {
+static conf_parser_t section_config[] = {
{ FR_CONF_OFFSET("insert", FR_TYPE_STRING | FR_TYPE_REQUIRED | FR_TYPE_XLAT, rlm_rediswho_t, insert) },
{ FR_CONF_OFFSET("trim", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_rediswho_t, trim) }, /* required only if trim_count > 0 */
{ FR_CONF_OFFSET("expire", FR_TYPE_STRING | FR_TYPE_REQUIRED | FR_TYPE_XLAT, rlm_rediswho_t, expire) },
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER module_config[] = {
+static conf_parser_t module_config[] = {
REDIS_COMMON_CONFIG,
{ FR_CONF_OFFSET("trim_count", FR_TYPE_INT32, rlm_rediswho_t, trim_count), .dflt = "-1" },
char const *rest_no_proxy = "*";
static int rest_proxy_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
static fr_table_num_sorted_t const disable_proxy_table[] = {
{ L("no"), 1 },
return 0;
}
-static const CONF_PARSER section_config[] = {
+static const conf_parser_t section_config[] = {
{ FR_CONF_OFFSET("uri", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_rest_section_t, uri), .dflt = "" },
{ FR_CONF_OFFSET("proxy", FR_TYPE_STRING, rlm_rest_section_t, proxy), .func = rest_proxy_parse },
{ FR_CONF_OFFSET("method", FR_TYPE_STRING, rlm_rest_section_t, method_str), .dflt = "GET" },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER xlat_config[] = {
+static const conf_parser_t xlat_config[] = {
{ FR_CONF_OFFSET("proxy", FR_TYPE_STRING, rlm_rest_section_t, proxy), .func = rest_proxy_parse },
/* User authentication */
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_DEPRECATED("connect_timeout", FR_TYPE_TIME_DELTA, rlm_rest_t, connect_timeout) },
{ FR_CONF_OFFSET("connect_proxy", FR_TYPE_STRING, rlm_rest_t, connect_proxy), .func = rest_proxy_parse },
{ FR_CONF_OFFSET("http_negotiation", FR_TYPE_VOID, rlm_rest_t, http_negotiation),
return unlang_module_yield(request, mod_post_auth_result, rest_io_module_signal, ~FR_SIGNAL_CANCEL, handle);
}
-static int parse_sub_section(rlm_rest_t *inst, CONF_SECTION *parent, CONF_PARSER const *config_items,
+static int parse_sub_section(rlm_rest_t *inst, CONF_SECTION *parent, conf_parser_t const *config_items,
rlm_rest_section_t *config, char const *name)
{
CONF_SECTION *cs;
} SECURID_AUTH_RC;
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("timer_expire", FR_TYPE_UINT32, rlm_securid_t, timer_limit), .dflt = "600" },
{ FR_CONF_OFFSET("max_sessions", FR_TYPE_UINT32, rlm_securid_t, max_sessions), .dflt = "2048" },
{ FR_CONF_OFFSET("max_trips_per_session", FR_TYPE_UINT32, rlm_securid_t, max_trips_per_session) },
};
static size_t m3ua_traffic_mode_table_len = NUM_ELEMENTS(m3ua_traffic_mode_table);
-static const CONF_PARSER sctp_config[] = {
+static const conf_parser_t sctp_config[] = {
{ FR_CONF_OFFSET("server", FR_TYPE_COMBO_IP_ADDR, rlm_sigtran_t, conn_conf.sctp_dst_ipaddr) },
{ FR_CONF_OFFSET("port", FR_TYPE_UINT16, rlm_sigtran_t, conn_conf.sctp_dst_port), .dflt = "2905" },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER m3ua_route[] = {
+static const conf_parser_t m3ua_route[] = {
{ FR_CONF_OFFSET_IS_SET("dpc", FR_TYPE_UINT32, sigtran_m3ua_route_t, dpc) },
{ FR_CONF_OFFSET("opc", FR_TYPE_UINT32 | FR_TYPE_MULTI, sigtran_m3ua_route_t, opc) },
{ FR_CONF_OFFSET("si", FR_TYPE_UINT32 | FR_TYPE_MULTI, sigtran_m3ua_route_t, si) },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER m3ua_config[] = {
+static const conf_parser_t m3ua_config[] = {
{ FR_CONF_OFFSET("link_index", FR_TYPE_UINT16, rlm_sigtran_t, conn_conf.m3ua_link_index) },
{ FR_CONF_OFFSET("routing_ctx", FR_TYPE_UINT16, rlm_sigtran_t, conn_conf.m3ua_routing_context) },
{ FR_CONF_OFFSET("traffic_mode", FR_TYPE_STRING, rlm_sigtran_t, conn_conf.m3ua_traffic_mode_str), .dflt = "loadshare" },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER mtp3_config[] = {
+static const conf_parser_t mtp3_config[] = {
{ FR_CONF_OFFSET("dpc", FR_TYPE_UINT32 | FR_TYPE_REQUIRED, rlm_sigtran_t, conn_conf.mtp3_dpc) },
{ FR_CONF_OFFSET("opc", FR_TYPE_UINT32 | FR_TYPE_REQUIRED, rlm_sigtran_t, conn_conf.mtp3_opc) },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER sccp_global_title[] = {
+static const conf_parser_t sccp_global_title[] = {
{ FR_CONF_OFFSET("address", FR_TYPE_STRING, sigtran_sccp_global_title_t, address) },
{ FR_CONF_OFFSET_IS_SET("tt", FR_TYPE_UINT8, sigtran_sccp_global_title_t, tt) },
{ FR_CONF_OFFSET_IS_SET("nai", FR_TYPE_UINT8, sigtran_sccp_global_title_t, nai) },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER sccp_address[] = {
+static const conf_parser_t sccp_address[] = {
{ FR_CONF_OFFSET_IS_SET("pc", FR_TYPE_UINT32, sigtran_sccp_address_t, pc) },
{ FR_CONF_OFFSET_IS_SET("ssn", FR_TYPE_UINT8, sigtran_sccp_address_t, ssn) },
{ FR_CONF_OFFSET_IS_SET("gt", FR_TYPE_SUBSECTION, sigtran_sccp_address_t, gt), .subcs = (void const *) sccp_global_title },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER sccp_config[] = {
+static const conf_parser_t sccp_config[] = {
{ FR_CONF_OFFSET("ai8", FR_TYPE_BOOL, rlm_sigtran_t, conn_conf.sccp_ai8) },
{ FR_CONF_OFFSET("route_on_ssn", FR_TYPE_BOOL, rlm_sigtran_t, conn_conf.sccp_route_on_ssn) },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER map_config[] = {
+static const conf_parser_t map_config[] = {
{ FR_CONF_OFFSET("version", FR_TYPE_TMPL, rlm_sigtran_t, conn_conf.map_version), .dflt = "2", .quote = T_BARE_WORD},
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_POINTER("sctp", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) sctp_config },
{ FR_CONF_POINTER("m3ua", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) m3ua_config },
{ FR_CONF_POINTER("mtp3", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) mtp3_config },
* Used to ensure that only strings are being set to the tmpl_t ** output
*/
static int cf_table_parse_tmpl(TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, CONF_PARSER const *rule)
+ CONF_ITEM *ci, conf_parser_t const *rule)
{
int ret = 0;
ssize_t slen;
/*
* A mapping of configuration file names to internal variables.
*/
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("uri", FR_TYPE_STRING, rlm_smtp_t, uri) },
{ FR_CONF_OFFSET("template_directory", FR_TYPE_STRING, rlm_smtp_t, template_dir) },
{ FR_CONF_OFFSET("attachments", FR_TYPE_TMPL | FR_TYPE_MULTI, rlm_smtp_t, attachments),
tmpl_t *key;
} rlm_sometimes_t;
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("rcode", FR_TYPE_STRING, rlm_sometimes_t, rcode_str), .dflt = "fail" },
{ FR_CONF_OFFSET("key", FR_TYPE_TMPL | FR_TYPE_ATTRIBUTE, rlm_sometimes_t, key), .dflt = "&User-Name", .quote = T_BARE_WORD },
{ FR_CONF_OFFSET("percentage", FR_TYPE_FLOAT32, rlm_sometimes_t, percentage), .dflt = "0" },
};
static size_t verify_cert_table_len = NUM_ELEMENTS(verify_cert_table);
-static CONF_PARSER load_balance_dc_aware_config[] = {
+static conf_parser_t load_balance_dc_aware_config[] = {
{ FR_CONF_OFFSET("local_dc", FR_TYPE_STRING, rlm_sql_cassandra_t, lbdc_local_dc) },
{ FR_CONF_OFFSET("hosts_per_remote_dc", FR_TYPE_UINT32, rlm_sql_cassandra_t, lbdc_hosts_per_remote_dc), .dflt = "0" },
{ FR_CONF_OFFSET("allow_remote_dcs_for_local_cl", FR_TYPE_BOOL, rlm_sql_cassandra_t, lbdc_allow_remote_dcs_for_local_cl), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER latency_aware_routing_config[] = {
+static conf_parser_t latency_aware_routing_config[] = {
{ FR_CONF_OFFSET("exclusion_threshold", FR_TYPE_FLOAT64, rlm_sql_cassandra_t, lar_exclusion_threshold), .dflt = "2.0" },
{ FR_CONF_OFFSET("scale", FR_TYPE_TIME_DELTA, rlm_sql_cassandra_t, lar_scale), .dflt = "0.1" },
{ FR_CONF_OFFSET("retry_period", FR_TYPE_TIME_DELTA, rlm_sql_cassandra_t, lar_retry_period), .dflt = "10" },
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER tls_config[] = {
+static conf_parser_t tls_config[] = {
{ FR_CONF_OFFSET("ca_file", FR_TYPE_FILE_INPUT, rlm_sql_cassandra_t, tls_ca_file) },
{ FR_CONF_OFFSET("certificate_file", FR_TYPE_FILE_INPUT, rlm_sql_cassandra_t, tls_certificate_file) },
{ FR_CONF_OFFSET("private_key_file", FR_TYPE_FILE_INPUT, rlm_sql_cassandra_t, tls_private_key_file) },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER driver_config[] = {
+static const conf_parser_t driver_config[] = {
{ FR_CONF_OFFSET("consistency", FR_TYPE_STRING, rlm_sql_cassandra_t, consistency_str), .dflt = "quorum" },
{ FR_CONF_OFFSET("protocol_version", FR_TYPE_UINT32, rlm_sql_cassandra_t, protocol_version) },
//!< appear to work with NDB cluster
} rlm_sql_mysql_t;
-static CONF_PARSER tls_config[] = {
+static conf_parser_t tls_config[] = {
{ FR_CONF_OFFSET("ca_file", FR_TYPE_FILE_INPUT, rlm_sql_mysql_t, tls_ca_file) },
{ FR_CONF_OFFSET("ca_path", FR_TYPE_FILE_INPUT, rlm_sql_mysql_t, tls_ca_path) },
{ FR_CONF_OFFSET("certificate_file", FR_TYPE_FILE_INPUT, rlm_sql_mysql_t, tls_certificate_file) },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER driver_config[] = {
+static const conf_parser_t driver_config[] = {
{ FR_CONF_POINTER("tls", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) tls_config },
{ FR_CONF_OFFSET("warnings", FR_TYPE_STRING, rlm_sql_mysql_t, warnings_str), .dflt = "auto" },
int col_count; //!< Number of columns associated with the result set
} rlm_sql_oracle_conn_t;
-static const CONF_PARSER spool_config[] = {
+static const conf_parser_t spool_config[] = {
{ FR_CONF_OFFSET("stmt_cache_size", FR_TYPE_UINT32, rlm_sql_oracle_t, stmt_cache_size), .dflt = "32" },
{ FR_CONF_OFFSET("timeout", FR_TYPE_UINT32, rlm_sql_oracle_t, spool_timeout), .dflt = "0" },
{ FR_CONF_OFFSET("min", FR_TYPE_UINT32, rlm_sql_oracle_t, spool_min), .dflt = "1" },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER driver_config[] = {
+static const conf_parser_t driver_config[] = {
{ FR_CONF_POINTER("spool", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) spool_config },
CONF_PARSER_TERMINATOR
};
char **row;
} rlm_sql_postgres_conn_t;
-static CONF_PARSER driver_config[] = {
+static conf_parser_t driver_config[] = {
{ FR_CONF_OFFSET("send_application_name", FR_TYPE_BOOL, rlm_sql_postgresql_t, send_application_name), .dflt = "yes" },
CONF_PARSER_TERMINATOR
};
bool bootstrap;
} rlm_sql_sqlite_t;
-static const CONF_PARSER driver_config[] = {
+static const conf_parser_t driver_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_OUTPUT | FR_TYPE_REQUIRED, rlm_sql_sqlite_t, filename) },
CONF_PARSER_TERMINATOR
};
/*
* So we can do pass2 xlat checks on the queries.
*/
-static const CONF_PARSER query_config[] = {
+static const conf_parser_t query_config[] = {
{ FR_CONF_OFFSET("query", FR_TYPE_STRING | FR_TYPE_XLAT | FR_TYPE_MULTI, rlm_sql_config_t, accounting.query) },
CONF_PARSER_TERMINATOR
};
* For now hard-code the subsections. This isn't perfect, but it
* helps the average case.
*/
-static const CONF_PARSER type_config[] = {
+static const conf_parser_t type_config[] = {
{ FR_CONF_POINTER("accounting-on", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) query_config },
{ FR_CONF_POINTER("accounting-off", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) query_config },
{ FR_CONF_POINTER("start", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) query_config },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER acct_config[] = {
+static const conf_parser_t acct_config[] = {
{ FR_CONF_OFFSET("reference", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sql_config_t, accounting.reference), .dflt = ".query" },
{ FR_CONF_OFFSET("logfile", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sql_config_t, accounting.logfile) },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER postauth_config[] = {
+static const conf_parser_t postauth_config[] = {
{ FR_CONF_OFFSET("reference", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sql_config_t, postauth.reference), .dflt = ".query" },
{ FR_CONF_OFFSET("logfile", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sql_config_t, postauth.logfile) },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("driver", FR_TYPE_VOID, rlm_sql_t, driver_submodule), .dflt = "null",
.func = module_rlm_submodule_parse },
{ FR_CONF_OFFSET("server", FR_TYPE_STRING, rlm_sql_config_t, sql_server), .dflt = "" }, /* Must be zero length so drivers can determine if it was set */
fr_time_t last_reset;
} rlm_sqlcounter_t;
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("sql_module_instance", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_sqlcounter_t, sqlmod_inst) },
} rlm_sqlippool_t;
-static CONF_PARSER message_config[] = {
+static conf_parser_t message_config[] = {
{ FR_CONF_OFFSET("exists", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, log_exists) },
{ FR_CONF_OFFSET("success", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, log_success) },
{ FR_CONF_OFFSET("clear", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, log_clear) },
CONF_PARSER_TERMINATOR
};
-static CONF_PARSER module_config[] = {
+static conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("sql_module_instance", FR_TYPE_STRING, rlm_sqlippool_t, sql_instance_name), .dflt = "sql" },
{ FR_CONF_OFFSET("lease_duration", FR_TYPE_UINT32, rlm_sqlippool_t, lease_duration), .dflt = "86400" },
pthread_mutex_t mutex;
} rlm_stats_thread_t;
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
CONF_PARSER_TERMINATOR
};
#include "rlm_tacacs.h"
-static int type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, CONF_PARSER const *rule);
+static int type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
/*
* Retransmission intervals for the packets we support.
*/
-static CONF_PARSER retry_config[] = {
+static conf_parser_t retry_config[] = {
{ FR_CONF_OFFSET("initial_rtx_time", FR_TYPE_TIME_DELTA, fr_retry_config_t, irt), .dflt = STRINGIFY(2) },
{ FR_CONF_OFFSET("max_rtx_time", FR_TYPE_TIME_DELTA, fr_retry_config_t, mrt), .dflt = STRINGIFY(16) },
{ FR_CONF_OFFSET("max_rtx_count", FR_TYPE_UINT32, fr_retry_config_t, mrc), .dflt = STRINGIFY(5) },
/*
* A mapping of configuration file names to internal variables.
*/
-static CONF_PARSER const module_config[] = {
+static conf_parser_t const module_config[] = {
{ FR_CONF_OFFSET("transport", FR_TYPE_VOID, rlm_tacacs_t, io_submodule),
.func = module_rlm_submodule_parse },
* - -1 on failure.
*/
static int type_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent,
- CONF_ITEM *ci, UNUSED CONF_PARSER const *rule)
+ CONF_ITEM *ci, UNUSED conf_parser_t const *rule)
{
char const *type_str = cf_pair_value(cf_item_to_pair(ci));
fr_dict_enum_value_t const *type_enum;
fr_retry_t retry; //!< retransmission timers
};
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, rlm_tacacs_tcp_t, dst_ipaddr), },
{ FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, rlm_tacacs_tcp_t, dst_ipaddr) },
{ FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, rlm_tacacs_tcp_t, dst_ipaddr) },
/*
* A mapping of configuration file names to internal variables.
*/
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("tmpl", FR_TYPE_TMPL, rlm_test_t, tmpl), .dflt = "&Tmp-String-0", .quote = T_BARE_WORD },
{ FR_CONF_OFFSET("tmpl_m", FR_TYPE_TMPL | FR_TYPE_MULTI, rlm_test_t, tmpl_m), .dflt = "&Tmp-String-0", .quote = T_DOUBLE_QUOTED_STRING },
} rlm_totp_t;
/* Map configuration file names to internal variables */
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("time_step", FR_TYPE_UINT32, rlm_totp_t, totp.time_step), .dflt = "30" },
{ FR_CONF_OFFSET("otp_length", FR_TYPE_UINT32, rlm_totp_t, totp.otp_length), .dflt = "6" },
{ FR_CONF_OFFSET("lookback_steps", FR_TYPE_UINT32, rlm_totp_t, totp.lookback_steps), .dflt = "1" },
/*
* A mapping of configuration file names to internal variables.
*/
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT, rlm_unbound_t, filename), .dflt = "${modconfdir}/unbound/default.conf" },
{ FR_CONF_OFFSET("timeout", FR_TYPE_UINT32, rlm_unbound_t, timeout), .dflt = "3000" },
{ FR_CONF_OFFSET("resolvconf", FR_TYPE_FILE_INPUT, rlm_unbound_t, resolvconf) },
char const *radwtmp;
} rlm_unix_t;
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("radwtmp", FR_TYPE_FILE_OUTPUT, rlm_unix_t, radwtmp) },
CONF_PARSER_TERMINATOR
};
bool delete_mppe_keys;
} rlm_wimax_t;
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("delete_mppe_keys", FR_TYPE_BOOL, rlm_wimax_t, delete_mppe_keys), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
#include <grp.h>
#include <wbclient.h>
-static const CONF_PARSER group_config[] = {
+static const conf_parser_t group_config[] = {
{ FR_CONF_OFFSET("search_username", FR_TYPE_TMPL, rlm_winbind_t, group_username) },
{ FR_CONF_OFFSET("add_domain", FR_TYPE_BOOL, rlm_winbind_t, group_add_domain), .dflt = "yes" },
{ FR_CONF_OFFSET("attribute", FR_TYPE_STRING, rlm_winbind_t, group_attribute) },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("username", FR_TYPE_TMPL, rlm_winbind_t, wb_username) },
{ FR_CONF_OFFSET("domain", FR_TYPE_TMPL, rlm_winbind_t, wb_domain) },
{ FR_CONF_POINTER("group", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) group_config },
#include "rlm_yubikey.h"
#ifdef HAVE_YKCLIENT
-static const CONF_PARSER validation_config[] = {
+static const conf_parser_t validation_config[] = {
{ FR_CONF_OFFSET("client_id", FR_TYPE_UINT32, rlm_yubikey_t, client_id), .dflt = 0 },
{ FR_CONF_OFFSET("api_key", FR_TYPE_STRING | FR_TYPE_SECRET, rlm_yubikey_t, api_key) },
CONF_PARSER_TERMINATOR
};
#endif
-static const CONF_PARSER module_config[] = {
+static const conf_parser_t module_config[] = {
{ FR_CONF_OFFSET("id_length", FR_TYPE_UINT32, rlm_yubikey_t, id_len), .dflt = "12" },
{ FR_CONF_OFFSET("split", FR_TYPE_BOOL, rlm_yubikey_t, split), .dflt = "yes" },
{ FR_CONF_OFFSET("decrypt", FR_TYPE_BOOL, rlm_yubikey_t, decrypt), .dflt = "no" },
#define PROCESS_STATE_EXTRA_FIELDS fr_value_box_t const **status_codes[RLM_MODULE_NUMCODES];
#include <freeradius-devel/server/process.h>
-static CONF_PARSER dhcpv6_process_config[] = {
+static conf_parser_t dhcpv6_process_config[] = {
{ FR_CONF_OFFSET("status_code_on_success", FR_TYPE_BOOL, process_dhcpv6_t, status_code_on_success), .dflt = "no" },
{ FR_CONF_OFFSET("send_failure_message", FR_TYPE_BOOL, process_dhcpv6_t, send_failure_message), .dflt = "no" },
{ FR_CONF_OFFSET("move_failure_message_to_parent", FR_TYPE_BOOL, process_dhcpv6_t, move_failure_message_to_parent), .dflt = "yes" },
#include <freeradius-devel/server/virtual_servers.h>
#include <freeradius-devel/server/process.h>
-static CONF_PARSER submodule_config[] = {
+static conf_parser_t submodule_config[] = {
{ FR_CONF_OFFSET("request_identity", FR_TYPE_VOID, 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, eap_aka_sim_process_conf_t,
#include <freeradius-devel/server/virtual_servers.h>
#include <freeradius-devel/server/process.h>
-static CONF_PARSER submodule_config[] = {
+static conf_parser_t submodule_config[] = {
{ FR_CONF_OFFSET("network_name", FR_TYPE_STRING, eap_aka_sim_process_conf_t, network_name ) },
{ FR_CONF_OFFSET("request_identity", FR_TYPE_VOID, 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 }},
#include <freeradius-devel/server/virtual_servers.h>
#include <freeradius-devel/server/process.h>
-static CONF_PARSER submodule_config[] = {
+static conf_parser_t submodule_config[] = {
{ FR_CONF_OFFSET("request_identity", FR_TYPE_VOID, 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, eap_aka_sim_process_conf_t,
#define PROCESS_CODE_DYNAMIC_CLIENT FR_RADIUS_CODE_ACCESS_ACCEPT
#include <freeradius-devel/server/process.h>
-static const CONF_PARSER session_config[] = {
+static const conf_parser_t session_config[] = {
{ FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, process_radius_auth_t, session_timeout), .dflt = "15" },
{ FR_CONF_OFFSET("max", FR_TYPE_UINT32, process_radius_auth_t, max_session), .dflt = "4096" },
{ FR_CONF_OFFSET("state_server_id", FR_TYPE_UINT8, process_radius_auth_t, state_server_id) },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER log_config[] = {
+static const conf_parser_t log_config[] = {
{ FR_CONF_OFFSET("stripped_names", FR_TYPE_BOOL, process_radius_auth_t, log_stripped_names), .dflt = "no" },
{ FR_CONF_OFFSET("auth", FR_TYPE_BOOL, process_radius_auth_t, log_auth), .dflt = "no" },
{ FR_CONF_OFFSET("auth_badpass", FR_TYPE_BOOL, process_radius_auth_t, log_auth_badpass), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER auth_config[] = {
+static const conf_parser_t auth_config[] = {
{ FR_CONF_POINTER("log", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) log_config },
{ FR_CONF_POINTER("session", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) session_config },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER config[] = {
+static const conf_parser_t config[] = {
{ FR_CONF_POINTER("Access-Request", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) auth_config,
.offset = offsetof(process_radius_t, auth), },
#include <freeradius-devel/server/process.h>
-static const CONF_PARSER session_config[] = {
+static const conf_parser_t session_config[] = {
{ FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, process_tacacs_auth_t, session_timeout), .dflt = "15" },
{ FR_CONF_OFFSET("max", FR_TYPE_UINT32, process_tacacs_auth_t, max_session), .dflt = "4096" },
{ FR_CONF_OFFSET("max_rounds", FR_TYPE_UINT32, process_tacacs_auth_t, max_rounds), .dflt = "4" },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER log_config[] = {
+static const conf_parser_t log_config[] = {
{ FR_CONF_OFFSET("stripped_names", FR_TYPE_BOOL, process_tacacs_auth_t, log_stripped_names), .dflt = "no" },
{ FR_CONF_OFFSET("auth", FR_TYPE_BOOL, process_tacacs_auth_t, log_auth), .dflt = "no" },
{ FR_CONF_OFFSET("auth_badpass", FR_TYPE_BOOL, process_tacacs_auth_t, log_auth_badpass), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER auth_config[] = {
+static const conf_parser_t auth_config[] = {
{ FR_CONF_POINTER("log", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) log_config },
{ FR_CONF_POINTER("session", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) session_config },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER config[] = {
+static const conf_parser_t config[] = {
{ FR_CONF_POINTER("Authentication", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) auth_config,
.offset = offsetof(process_tacacs_t, auth), },
#define PROCESS_INST process_ttls_t
#include <freeradius-devel/server/process.h>
-static const CONF_PARSER session_config[] = {
+static const conf_parser_t session_config[] = {
{ FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, process_ttls_session_t, timeout), .dflt = "15" },
{ FR_CONF_OFFSET("max", FR_TYPE_UINT32, process_ttls_session_t, max), .dflt = "4096" },
{ FR_CONF_OFFSET("state_server_id", FR_TYPE_UINT8, process_ttls_session_t, state_server_id) },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER log_config[] = {
+static const conf_parser_t log_config[] = {
{ FR_CONF_OFFSET("stripped_names", FR_TYPE_BOOL, process_ttls_auth_log_t, stripped_names), .dflt = "no" },
{ FR_CONF_OFFSET("auth", FR_TYPE_BOOL, process_ttls_auth_log_t, auth), .dflt = "no" },
{ FR_CONF_OFFSET("auth_badpass", FR_TYPE_BOOL, process_ttls_auth_log_t, auth_badpass), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER auth_config[] = {
+static const conf_parser_t auth_config[] = {
{ FR_CONF_OFFSET_SUBSECTION("log,", 0, process_ttls_auth_t, log, log_config) },
{ FR_CONF_OFFSET_SUBSECTION("session", 0, process_ttls_auth_t, session, session_config )},
CONF_PARSER_TERMINATOR
};
-static const CONF_PARSER config[] = {
+static const conf_parser_t config[] = {
{ FR_CONF_OFFSET_SUBSECTION("Access-Request", 0, process_ttls_t, auth, auth_config) },
CONF_PARSER_TERMINATOR
projects / thirdparty / freeradius-server.git / commitdiff
