# after the opening brace, and before the closing brace.
#
# static conf_parser_t group_config[] = {
-# { FR_CONF_OFFSET("filter", FR_TYPE_STRING, rlm_ldap_t, groupobj_filter) }
+# { FR_CONF_OFFSET("filter", FR_TYPE_STRING, 0, rlm_ldap_t, groupobj_filter) }
# };
#
ContinuationIndentWidth: 8
} radutmpconfig;
static const conf_parser_t module_config[] = {
- { FR_CONF_POINTER("filename", FR_TYPE_FILE_INPUT, &radutmpconfig.radutmp_fn), .dflt = RADUTMP },
+ { FR_CONF_POINTER("filename", FR_TYPE_STRING, CONF_FLAG_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_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) },
- { FR_CONF_OFFSET("certificate_file", FR_TYPE_FILE_INPUT, fr_curl_tls_t, certificate_file) },
- { FR_CONF_OFFSET("private_key_file", FR_TYPE_FILE_INPUT, fr_curl_tls_t, private_key_file) },
- { FR_CONF_OFFSET("private_key_password", FR_TYPE_STRING | FR_TYPE_SECRET, fr_curl_tls_t, private_key_password) },
- { FR_CONF_OFFSET("random_file", FR_TYPE_STRING, fr_curl_tls_t, random_file) },
- { FR_CONF_OFFSET("require_cert", FR_TYPE_VOID, fr_curl_tls_t, require_cert),
+ { FR_CONF_OFFSET("ca_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_curl_tls_t, ca_file) },
+ { FR_CONF_OFFSET("ca_issuer_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_curl_tls_t, ca_issuer_file) },
+ { FR_CONF_OFFSET("ca_path", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_curl_tls_t, ca_path) },
+ { FR_CONF_OFFSET("certificate_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_curl_tls_t, certificate_file) },
+ { FR_CONF_OFFSET("private_key_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_curl_tls_t, private_key_file) },
+ { FR_CONF_OFFSET("private_key_password", FR_TYPE_STRING, CONF_FLAG_SECRET, fr_curl_tls_t, private_key_password) },
+ { FR_CONF_OFFSET("random_file", FR_TYPE_STRING, 0, fr_curl_tls_t, random_file) },
+ { FR_CONF_OFFSET("require_cert", FR_TYPE_VOID, 0, fr_curl_tls_t, require_cert),
.func = cf_table_parse_int,
.uctx = &(cf_table_parse_ctx_t){
.table = fr_curl_sslcode_table,
.len = &fr_curl_sslcode_table_len
},
.dflt = "allow" },
- { FR_CONF_OFFSET("check_cert", FR_TYPE_BOOL, fr_curl_tls_t, check_cert), .dflt = "yes" },
- { FR_CONF_OFFSET("check_cert_cn", FR_TYPE_BOOL, fr_curl_tls_t, check_cert_cn), .dflt = "yes" },
- { FR_CONF_OFFSET("extract_cert_attrs", FR_TYPE_BOOL, fr_curl_tls_t, extract_cert_attrs), .dflt = "no" },
+ { FR_CONF_OFFSET("check_cert", FR_TYPE_BOOL, 0, fr_curl_tls_t, check_cert), .dflt = "yes" },
+ { FR_CONF_OFFSET("check_cert_cn", FR_TYPE_BOOL, 0, fr_curl_tls_t, check_cert_cn), .dflt = "yes" },
+ { FR_CONF_OFFSET("extract_cert_attrs", FR_TYPE_BOOL, 0, fr_curl_tls_t, extract_cert_attrs), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
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" },
+ { FR_CONF_OFFSET("min", FR_TYPE_UINT32, 0, fr_slab_config_t, min_elements), .dflt = "10" },
+ { FR_CONF_OFFSET("max", FR_TYPE_UINT32, 0, fr_slab_config_t, max_elements), .dflt = "100" },
+ { FR_CONF_OFFSET("cleanup_interval", FR_TYPE_TIME_DELTA, 0, fr_slab_config_t, interval), .dflt = "30s" },
CONF_PARSER_TERMINATOR
};
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" },
+ { FR_CONF_OFFSET("reuse", 0, CONF_FLAG_SUBSECTION, fr_curl_conn_config_t, reuse), .subcs = (void const *) reuse_curl_conn_config },
+ { FR_CONF_OFFSET("connect_timeout", FR_TYPE_TIME_DELTA, 0, fr_curl_conn_config_t, connect_timeout), .dflt = "3.0" },
CONF_PARSER_TERMINATOR
};
};
static conf_parser_t const json_format_attr_config[] = {
- { FR_CONF_OFFSET("prefix", FR_TYPE_STRING, fr_json_format_attr_t, prefix) },
+ { FR_CONF_OFFSET("prefix", FR_TYPE_STRING, 0, fr_json_format_attr_t, prefix) },
CONF_PARSER_TERMINATOR
};
static conf_parser_t const json_format_value_config[] = {
- { FR_CONF_OFFSET("single_value_as_array", FR_TYPE_BOOL, 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" },
+ { FR_CONF_OFFSET("single_value_as_array", FR_TYPE_BOOL, 0, fr_json_format_value_t, value_is_always_array), .dflt = "no" },
+ { FR_CONF_OFFSET("enum_as_integer", FR_TYPE_BOOL, 0, fr_json_format_value_t, enum_as_int), .dflt = "no" },
+ { FR_CONF_OFFSET("always_string", FR_TYPE_BOOL, 0, fr_json_format_value_t, always_string), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
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),
+ { FR_CONF_OFFSET("output_mode", FR_TYPE_STRING, 0, fr_json_format_t, output_mode_str), .dflt = "object" },
+ { FR_CONF_OFFSET("attribute", 0, CONF_FLAG_SUBSECTION, fr_json_format_t, attr),
.subcs = (void const *) json_format_attr_config },
- { FR_CONF_OFFSET("value", FR_TYPE_SUBSECTION, fr_json_format_t, value),
+ { FR_CONF_OFFSET("value", 0, CONF_FLAG_SUBSECTION, fr_json_format_t, value),
.subcs = (void const *) json_format_value_config },
CONF_PARSER_TERMINATOR
{
char tmp[sizeof("18446744073709551615b")];
fr_kafka_conf_ctx_t const *kctx = rule->uctx;
- fr_type_t type = FR_BASE_TYPE(rule->type);
+ fr_type_t type = rule->type;
/*
* Apply any mappings available, but default back
break;
}
- MEM(*out = cf_pair_alloc(cs, rule->name, value, T_OP_EQ, T_BARE_WORD, quote));
+ MEM(*out = cf_pair_alloc(cs, rule->name1, value, T_OP_EQ, T_BARE_WORD, quote));
cf_pair_mark_parsed(*out); /* Don't re-parse this */
return 0;
if (ret == RD_KAFKA_CONF_UNKNOWN) {
if (kctx->empty_default) return 0;
- cf_log_debug(cs, "No default available for \"%s\" - \"%s\"", rule->name, kctx->property);
+ cf_log_debug(cs, "No default available for \"%s\" - \"%s\"", rule->name1, kctx->property);
return 0; /* Not an error */
}
return -1;
}
#if 0
- cf_log_debug(cs, "Retrieved dflt \"%s\" for \"%s\" - \"%s\"", buff, rule->name, kctx->property);
+ cf_log_debug(cs, "Retrieved dflt \"%s\" for \"%s\" - \"%s\"", buff, rule->name1, kctx->property);
#endif
value = buff;
if (ret == RD_KAFKA_CONF_UNKNOWN) {
if (kctx->empty_default) return 0;
- cf_log_debug(cs, "No default available for \"%s\" - \"%s\"", rule->name, kctx->property);
+ cf_log_debug(cs, "No default available for \"%s\" - \"%s\"", rule->name1, kctx->property);
return 0; /* Not an error */
}
return -1;
}
#if 0
- cf_log_debug(cs, "Retrieved dflt \"%s\" for \"%s\" - \"%s\"", buff, rule->name, kctx->property);
+ cf_log_debug(cs, "Retrieved dflt \"%s\" for \"%s\" - \"%s\"", buff, rule->name1, kctx->property);
#endif
value = buff;
{
fr_value_box_t vb = FR_VALUE_BOX_INITIALISER_NULL(vb);
fr_kafka_conf_ctx_t const *kctx = rule->uctx;
- fr_type_t type = FR_BASE_TYPE(rule->type);
+ fr_type_t type = rule->type;
static _Thread_local char buff[sizeof("18446744073709551615")];
static _Thread_local fr_sbuff_t sbuff;
FR_SBUFF_TALLOC_THREAD_LOCAL(&agg, 256, SIZE_MAX);
- count = cf_pair_count(cs, rule->name);
+ count = cf_pair_count(cs, rule->name1);
if (count <= 1) goto do_single;
MEM(array = talloc_array(ctx, char const *, count));
for (cp_p = cp, i = 0;
cp_p;
- cp_p = cf_pair_find_next(cs, cp_p, rule->name), i++) {
+ cp_p = cf_pair_find_next(cs, cp_p, rule->name1), i++) {
if (kafka_config_parse_single(&array[i], cp_p, rule) < 0) return -1;
cf_pair_mark_parsed(cp_p);
}
#endif
static conf_parser_t const kafka_sasl_oauth_config[] = {
- { FR_CONF_FUNC("oauthbearer_conf", FR_TYPE_STRING, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("oauthbearer_conf", FR_TYPE_STRING, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "sasl.oauthbearer.config", .empty_default = true }},
- { FR_CONF_FUNC("unsecure_jwt", FR_TYPE_BOOL, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("unsecure_jwt", FR_TYPE_BOOL, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "enable.sasl.oauthbearer.unsecure.jwt" }},
CONF_PARSER_TERMINATOR
/*
* Service principal
*/
- { FR_CONF_FUNC("service_name", FR_TYPE_STRING, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("service_name", FR_TYPE_STRING, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "sasl.kerberos.service.name" }},
/*
* Principal
*/
- { FR_CONF_FUNC("principal", FR_TYPE_STRING, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("principal", FR_TYPE_STRING, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "sasl.kerberos.principal" }},
/*
* knit cmd
*/
- { FR_CONF_FUNC("kinit_cmd", FR_TYPE_STRING, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("kinit_cmd", FR_TYPE_STRING, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "sasl.kerberos.kinit.cmd" }},
/*
* keytab
*/
- { FR_CONF_FUNC("keytab", FR_TYPE_STRING | FR_TYPE_FILE_INPUT, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("keytab", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "sasl.kerberos.kinit.keytab", .empty_default = true }},
/*
* How long between key refreshes
*/
- { FR_CONF_FUNC("refresh_delay", FR_TYPE_TIME_DELTA, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("refresh_delay", FR_TYPE_TIME_DELTA, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "sasl.kerberos.min.time.before.relogin" }},
CONF_PARSER_TERMINATOR
/*
* SASL mechanism
*/
- { FR_CONF_FUNC("mech", FR_TYPE_STRING, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("mech", FR_TYPE_STRING, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "sasl.mechanism" }},
/*
* Static SASL username
*/
- { FR_CONF_FUNC("username", FR_TYPE_STRING, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("username", FR_TYPE_STRING, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "sasl.username", .empty_default = true }},
/*
* Static SASL password
*/
- { FR_CONF_FUNC("password", FR_TYPE_STRING | FR_TYPE_SECRET, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("password", FR_TYPE_STRING, CONF_FLAG_SECRET, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "sasl.password", .empty_default = true }},
{ FR_CONF_SUBSECTION_GLOBAL("kerberos", 0, kafka_sasl_kerberos_config) },
/*
* Cipher suite list in OpenSSL's format
*/
- { FR_CONF_FUNC("cipher_list", FR_TYPE_STRING, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("cipher_list", FR_TYPE_STRING, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "ssl.cipher.suites", .empty_default = true }},
/*
* Curves list in OpenSSL's format
*/
- { FR_CONF_FUNC("curve_list", FR_TYPE_STRING, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("curve_list", FR_TYPE_STRING, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "ssl.curves.list", .empty_default = true }},
/*
* Curves list in OpenSSL's format
*/
- { FR_CONF_FUNC("sigalg_list", FR_TYPE_STRING, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("sigalg_list", FR_TYPE_STRING, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "ssl.sigalgs.list", .empty_default = true }},
/*
* Sets the full path to a CA certificate (used to validate
* the certificate the server presents).
*/
- { FR_CONF_FUNC("ca_file", FR_TYPE_STRING | FR_TYPE_FILE_INPUT, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("ca_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "ssl.ca.location", .empty_default = true }},
/*
* Location of the CRL file.
*/
- { FR_CONF_FUNC("crl_file", FR_TYPE_STRING | FR_TYPE_FILE_INPUT, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("crl_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "ssl.crl.location", .empty_default = true }},
/*
* Sets the path to the public certificate file we present
* to the servers.
*/
- { FR_CONF_FUNC("certificate_file", FR_TYPE_STRING | FR_TYPE_FILE_INPUT, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("certificate_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "ssl.certificate.location", .empty_default = true }},
/*
* Sets the path to the private key for our public
* certificate.
*/
- { FR_CONF_FUNC("private_key_file", FR_TYPE_STRING | FR_TYPE_FILE_INPUT, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("private_key_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "ssl.key.location", .empty_default = true }},
/*
* Enable or disable certificate validation
*/
- { FR_CONF_FUNC("require_cert", FR_TYPE_BOOL, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("require_cert", FR_TYPE_BOOL, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "enable.ssl.certificate.verification" }},
- { FR_CONF_FUNC("check_cert_cn", FR_TYPE_BOOL, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("check_cert_cn", FR_TYPE_BOOL, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "ssl.endpoint.identification.algorithm",
.mapping = kafka_check_cert_cn_table,
.mapping_len = &kafka_check_cert_cn_table_len }},
/*
* Socket timeout
*/
- { FR_CONF_FUNC("timeout", FR_TYPE_TIME_DELTA, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("timeout", FR_TYPE_TIME_DELTA, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "socket.timeout.ms" }},
/*
* Close broker connections after this period.
*/
- { FR_CONF_FUNC("idle_timeout", FR_TYPE_TIME_DELTA, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("idle_timeout", FR_TYPE_TIME_DELTA, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "connections.max.idle.ms" }},
/*
* Maximum requests in flight (per connection).
*/
- { FR_CONF_FUNC("max_requests_in_flight", FR_TYPE_UINT64, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("max_requests_in_flight", FR_TYPE_UINT64, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "max.in.flight.requests.per.connection" }},
/*
* Socket send buffer.
*/
- { FR_CONF_FUNC("send_buff", FR_TYPE_UINT64, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("send_buff", FR_TYPE_UINT64, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "socket.send.buffer.bytes" }},
/*
* Socket recv buffer.
*/
- { FR_CONF_FUNC("recv_buff", FR_TYPE_UINT64, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("recv_buff", FR_TYPE_UINT64, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "socket.receive.buffer.bytes" }},
/*
* If true, send TCP keepalives
*/
- { FR_CONF_FUNC("keepalive", FR_TYPE_BOOL, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("keepalive", FR_TYPE_BOOL, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "socket.keepalive.enable" }},
/*
* If true, disable nagle algorithm
*/
- { FR_CONF_FUNC("nodelay", FR_TYPE_BOOL, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("nodelay", FR_TYPE_BOOL, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "socket.nagle.disable" }},
/*
* How long the DNS resolver cache is valid for
*/
- { FR_CONF_FUNC("resolver_cache_ttl", FR_TYPE_TIME_DELTA, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("resolver_cache_ttl", FR_TYPE_TIME_DELTA, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "broker.address.ttl" }},
/*
* Should we use A records, AAAA records or either
* when resolving broker addresses
*/
- { FR_CONF_FUNC("resolver_addr_family", FR_TYPE_STRING, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("resolver_addr_family", FR_TYPE_STRING, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "broker.address.family" }},
/*
* How many failures before we reconnect the connection
*/
- { FR_CONF_FUNC("reconnection_failure_count", FR_TYPE_UINT32, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("reconnection_failure_count", FR_TYPE_UINT32, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "socket.max.fails" }},
/*
* Initial time to wait before reconnecting.
*/
- { FR_CONF_FUNC("reconnection_delay_initial", FR_TYPE_TIME_DELTA, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("reconnection_delay_initial", FR_TYPE_TIME_DELTA, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "reconnect.backoff.ms" }},
/*
* Max time to wait before reconnecting.
*/
- { FR_CONF_FUNC("reconnection_delay_max", FR_TYPE_TIME_DELTA, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("reconnection_delay_max", FR_TYPE_TIME_DELTA, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "reconnect.backoff.max.ms" }},
CONF_PARSER_TERMINATOR
/*
* Request the API version from connected brokers
*/
- { FR_CONF_FUNC("request", FR_TYPE_BOOL, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("request", FR_TYPE_BOOL, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "api.version.request" }},
/*
* How long to wait for a version response.
*/
- { FR_CONF_FUNC("timeout", FR_TYPE_TIME_DELTA, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("timeout", FR_TYPE_TIME_DELTA, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "api.version.request.timeout.ms" }},
/*
* How long to wait before retrying a version request.
*/
- { FR_CONF_FUNC("retry_delay", FR_TYPE_TIME_DELTA, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("retry_delay", FR_TYPE_TIME_DELTA, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "api.version.fallback.ms" }},
/*
* Default version to use if the version request fails.
*/
- { FR_CONF_FUNC("default", FR_TYPE_STRING, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("default", FR_TYPE_STRING, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "broker.version.fallback" }},
CONF_PARSER_TERMINATOR
/*
* Interval between attempts to refresh metadata from brokers
*/
- { FR_CONF_FUNC("refresh_interval", FR_TYPE_TIME_DELTA, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("refresh_interval", FR_TYPE_TIME_DELTA, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "topic.metadata.refresh.interval.ms" }},
/*
* Interval between attempts to refresh metadata from brokers
*/
- { FR_CONF_FUNC("max_age", FR_TYPE_TIME_DELTA, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("max_age", FR_TYPE_TIME_DELTA, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "metadata.max.age.ms" }},
/*
* Used when a topic loses its leader
*/
- { FR_CONF_FUNC("fast_refresh_interval", FR_TYPE_TIME_DELTA, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("fast_refresh_interval", FR_TYPE_TIME_DELTA, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "topic.metadata.refresh.fast.interval.ms" }},
/*
* Used when a topic loses its leader to prevent spurious metadata changes
*/
- { FR_CONF_FUNC("max_propagation", FR_TYPE_TIME_DELTA, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("max_propagation", FR_TYPE_TIME_DELTA, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "topic.metadata.propagation.max.ms" }},
/*
* Use sparse metadata requests which use less bandwidth maps
*/
- { FR_CONF_FUNC("refresh_sparse", FR_TYPE_BOOL, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("refresh_sparse", FR_TYPE_BOOL, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "topic.metadata.refresh.sparse" }},
/*
* List of topics to ignore
*/
- { FR_CONF_FUNC("blacklist", FR_TYPE_STRING | FR_TYPE_MULTI, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("blacklist", FR_TYPE_STRING, CONF_FLAG_MULTI, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "topic.blacklist", .string_sep = ",", .empty_default = true }},
CONF_PARSER_TERMINATOR
};
#define BASE_CONFIG \
- { FR_CONF_FUNC("server", FR_TYPE_STRING | FR_TYPE_REQUIRED | FR_TYPE_MULTI, kafka_config_parse, kafka_config_dflt), \
+ { FR_CONF_FUNC("server", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_MULTI, kafka_config_parse, kafka_config_dflt), \
.uctx = &(fr_kafka_conf_ctx_t){ .property = "metadata.broker.list", .string_sep = "," }}, \
- { FR_CONF_FUNC("client_id", FR_TYPE_STRING, kafka_config_parse, kafka_config_dflt), \
+ { FR_CONF_FUNC("client_id", FR_TYPE_STRING, 0, kafka_config_parse, kafka_config_dflt), \
.uctx = &(fr_kafka_conf_ctx_t){ .property = "client.id" }}, \
- { FR_CONF_FUNC("rack_id", FR_TYPE_STRING, kafka_config_parse, kafka_config_dflt), \
+ { FR_CONF_FUNC("rack_id", FR_TYPE_STRING, 0, kafka_config_parse, kafka_config_dflt), \
.uctx = &(fr_kafka_conf_ctx_t){ .property = "client.rack" }}, \
- { FR_CONF_FUNC("request_max_size", FR_TYPE_SIZE, kafka_config_parse, kafka_config_dflt), \
+ { FR_CONF_FUNC("request_max_size", FR_TYPE_SIZE, 0, kafka_config_parse, kafka_config_dflt), \
.uctx = &(fr_kafka_conf_ctx_t){ .property = "message.max.bytes" }}, \
- { FR_CONF_FUNC("request_copy_max_size", FR_TYPE_SIZE, kafka_config_parse, kafka_config_dflt), \
+ { FR_CONF_FUNC("request_copy_max_size", FR_TYPE_SIZE, 0, kafka_config_parse, kafka_config_dflt), \
.uctx = &(fr_kafka_conf_ctx_t){ .property = "message.copy.max.bytes" }}, \
- { FR_CONF_FUNC("response_max_size", FR_TYPE_SIZE, kafka_config_parse, kafka_config_dflt), \
+ { FR_CONF_FUNC("response_max_size", FR_TYPE_SIZE, 0, kafka_config_parse, kafka_config_dflt), \
.uctx = &(fr_kafka_conf_ctx_t){ .property = "receive.message.max.bytes" }}, \
- { FR_CONF_FUNC("feature", FR_TYPE_STRING | FR_TYPE_MULTI, kafka_config_parse, kafka_config_dflt), \
+ { FR_CONF_FUNC("feature", FR_TYPE_STRING, CONF_FLAG_MULTI, kafka_config_parse, kafka_config_dflt), \
.uctx = &(fr_kafka_conf_ctx_t){ .property = "builtin.features", .string_sep = "," }}, \
- { FR_CONF_FUNC("debug", FR_TYPE_STRING | FR_TYPE_MULTI, kafka_config_parse, kafka_config_dflt), \
+ { FR_CONF_FUNC("debug", FR_TYPE_STRING, CONF_FLAG_MULTI, kafka_config_parse, kafka_config_dflt), \
.uctx = &(fr_kafka_conf_ctx_t){ .property = "debug", .string_sep = "," }}, \
- { FR_CONF_FUNC("plugin", FR_TYPE_STRING | FR_TYPE_MULTI, kafka_config_parse, NULL), \
+ { FR_CONF_FUNC("plugin", FR_TYPE_STRING, CONF_FLAG_MULTI, kafka_config_parse, NULL), \
.uctx = &(fr_kafka_conf_ctx_t){ .property = "plugin.library.paths", .string_sep = ";" }}, \
{ FR_CONF_SUBSECTION_GLOBAL("metadata", 0, kafka_metadata_config) }, \
{ FR_CONF_SUBSECTION_GLOBAL("version", 0, kafka_version_config) }, \
/*
* Group consumer is a member of
*/
- { FR_CONF_FUNC("id", FR_TYPE_STRING, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("id", FR_TYPE_STRING, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "group.id" }},
/*
* A unique identifier of the consumer instance provided by the end user
*/
- { FR_CONF_FUNC("instance_id", FR_TYPE_STRING, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("instance_id", FR_TYPE_STRING, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "group.instance.id" }},
/*
* Range or roundrobin
*/
- { FR_CONF_FUNC("partition_assignment_strategy", FR_TYPE_STRING, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("partition_assignment_strategy", FR_TYPE_STRING, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "partition.assignment.strategy" }},
/*
* Client group session and failure detection timeout.
*/
- { FR_CONF_FUNC("session_timeout", FR_TYPE_TIME_DELTA, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("session_timeout", FR_TYPE_TIME_DELTA, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "session.timeout.ms" }},
/*
* Group session keepalive heartbeat interval.
*/
- { FR_CONF_FUNC("heartbeat_interval", FR_TYPE_TIME_DELTA, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("heartbeat_interval", FR_TYPE_TIME_DELTA, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "heartbeat.interval.ms" }},
/*
* How often to query for the current client group coordinator
*/
- { FR_CONF_FUNC("coordinator_query_interval", FR_TYPE_TIME_DELTA, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("coordinator_query_interval", FR_TYPE_TIME_DELTA, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "coordinator.query.interval.ms" }},
*
* High numbers may starve the worker thread
*/
- { FR_CONF_FUNC("max_messages_per_cycle", FR_TYPE_UINT32, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("max_messages_per_cycle", FR_TYPE_UINT32, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "consume.callback.max.messages" }},
/*
* Action to take when there is no initial offset
* in offset store or the desired offset is out of range.
*/
- { FR_CONF_FUNC("auto_offset_reset", FR_TYPE_STRING, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("auto_offset_reset", FR_TYPE_STRING, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "auto.offset.reset" }},
CONF_PARSER_TERMINATOR
*
*/
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) },
+ { FR_CONF_SUBSECTION_GLOBAL(CF_IDENT_ANY, CONF_FLAG_MULTI, kafka_base_consumer_topic_config) },
CONF_PARSER_TERMINATOR
};
/*
* Maximum allowed time between calls to consume messages.
*/
- { FR_CONF_FUNC("max_poll_interval", FR_TYPE_TIME_DELTA, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("max_poll_interval", FR_TYPE_TIME_DELTA, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "max.poll.interval.ms" }},
/*
* Toggle auto commit
*/
- { FR_CONF_FUNC("auto_commit", FR_TYPE_BOOL, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("auto_commit", FR_TYPE_BOOL, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "enable_auto.commit" }},
/*
* Auto commit interval
*/
- { FR_CONF_FUNC("auto_commit_interval", FR_TYPE_TIME_DELTA, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("auto_commit_interval", FR_TYPE_TIME_DELTA, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "auto.commit.interval.ms" }},
/*
* Automatically store offset of last message provided to application.
*/
- { FR_CONF_FUNC("auto_offset_store", FR_TYPE_BOOL, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("auto_offset_store", FR_TYPE_BOOL, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "enable.auto.offset.store" }},
/*
* Minimum number of messages per topic+partition librdkafka tries to
* maintain in the local consumer queue.
*/
- { FR_CONF_FUNC("queued_messages_min", FR_TYPE_UINT64, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("queued_messages_min", FR_TYPE_UINT64, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "queued.min.messages" }},
/*
* Maximum size of queued pre-fetched messages in the local consumer queue.
*/
- { FR_CONF_FUNC("queued_messages_max_size", FR_TYPE_SIZE, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("queued_messages_max_size", FR_TYPE_SIZE, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "queued.max.messages.kbytes", .size_scale = 1024 }},
/*
* Maximum time the broker may wait to fill the Fetch response.
*/
- { FR_CONF_FUNC("fetch_wait_max", FR_TYPE_TIME_DELTA, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("fetch_wait_max", FR_TYPE_TIME_DELTA, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "fetch.wait.max.ms" }},
/*
* Initial maximum number of bytes per topic+partition to request when
* fetching messages from the broker.
*/
- { FR_CONF_FUNC("fetch_message_max_size", FR_TYPE_SIZE, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("fetch_message_max_size", FR_TYPE_SIZE, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "fetch.message.max.bytes" }},
/*
* Initial maximum number of bytes per topic+partition to request when
* fetching messages from the broker.
*/
- { FR_CONF_FUNC("fetch_partition_max_size", FR_TYPE_SIZE, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("fetch_partition_max_size", FR_TYPE_SIZE, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "max.partition.fetch.bytes" }},
/*
* Maximum amount of data the broker shall return for a Fetch request.
*/
- { FR_CONF_FUNC("fetch_max_size", FR_TYPE_SIZE, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("fetch_max_size", FR_TYPE_SIZE, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "fetch.max.bytes" }},
/*
* Minimum number of bytes the broker responds with.
*/
- { FR_CONF_FUNC("fetch_min_size", FR_TYPE_SIZE, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("fetch_min_size", FR_TYPE_SIZE, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "fetch.min.bytes" }},
/*
* How long to postpone the next fetch request for a topic+partition
* in case of a fetch error.
*/
- { FR_CONF_FUNC("fetch_error_backoff", FR_TYPE_TIME_DELTA, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("fetch_error_backoff", FR_TYPE_TIME_DELTA, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "fetch.error.backoff.ms" }},
/*
* Controls how to read messages written transactionally
*/
- { FR_CONF_FUNC("isolation_level", FR_TYPE_STRING, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("isolation_level", FR_TYPE_STRING, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "isolation.level" }},
/*
* Verify CRC32 of consumed messages, ensuring no on-the-wire or
* on-disk corruption to the messages occurred.
*/
- { FR_CONF_FUNC("check_crcs", FR_TYPE_BOOL, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("check_crcs", FR_TYPE_BOOL, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "check.crcs" }},
/*
* Allow automatic topic creation on the broker when subscribing
* to or assigning non-existent topics
*/
- { FR_CONF_FUNC("auto_create_topic", FR_TYPE_BOOL, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("auto_create_topic", FR_TYPE_BOOL, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "allow.auto.create.topics" }},
{ FR_CONF_SUBSECTION_GLOBAL("topic", 0, kafka_base_consumer_topics_config) }, \
* This field indicates the number of acknowledgements the leader
* broker must receive from ISR brokers before responding to the request.
*/
- { FR_CONF_FUNC("request_required_acks", FR_TYPE_INT16, kafka_topic_config_parse, kafka_topic_config_dflt),
+ { FR_CONF_FUNC("request_required_acks", FR_TYPE_INT16, 0, kafka_topic_config_parse, kafka_topic_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "request.required.acks" }},
/*
* medium The ack timeout of the producer request in milliseconds
*/
- { FR_CONF_FUNC("request_timeout", FR_TYPE_TIME_DELTA, kafka_topic_config_parse, kafka_topic_config_dflt),
+ { FR_CONF_FUNC("request_timeout", FR_TYPE_TIME_DELTA, 0, kafka_topic_config_parse, kafka_topic_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "request.timeout.ms" }},
/*
* Local message timeout
*/
- { FR_CONF_FUNC("message_timeout", FR_TYPE_TIME_DELTA, kafka_topic_config_parse, kafka_topic_config_dflt),
+ { FR_CONF_FUNC("message_timeout", FR_TYPE_TIME_DELTA, 0, kafka_topic_config_parse, kafka_topic_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "message.timeout.ms" }},
/*
* Partitioning strategy
*/
- { FR_CONF_FUNC("partitioner", FR_TYPE_STRING, kafka_topic_config_parse, kafka_topic_config_dflt),
+ { FR_CONF_FUNC("partitioner", FR_TYPE_STRING, 0, kafka_topic_config_parse, kafka_topic_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "partitioner" }},
/*
* compression codec to use for compressing message sets.
*/
- { FR_CONF_FUNC("compression_type", FR_TYPE_STRING, kafka_topic_config_parse, kafka_topic_config_dflt),
+ { FR_CONF_FUNC("compression_type", FR_TYPE_STRING, 0, kafka_topic_config_parse, kafka_topic_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "compression.type" }},
/*
* compression level to use
*/
- { FR_CONF_FUNC("compression_level", FR_TYPE_INT8, kafka_topic_config_parse, kafka_topic_config_dflt),
+ { FR_CONF_FUNC("compression_level", FR_TYPE_INT8, 0, kafka_topic_config_parse, kafka_topic_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "compression.level" }},
CONF_PARSER_TERMINATOR
/*
* Enables the transactional producer
*/
- { FR_CONF_FUNC("transactional_id", FR_TYPE_STRING, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("transactional_id", FR_TYPE_STRING, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "transactional.id", .empty_default = true }},
/*
* coordinator will wait for a transaction status update from the
* producer before proactively aborting the ongoing transaction.
*/
- { FR_CONF_FUNC("transaction_timeout", FR_TYPE_TIME_DELTA, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("transaction_timeout", FR_TYPE_TIME_DELTA, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "transaction.timeout.ms" }},
/*
* successfully produced exactly once and in the original produce
* order.
*/
- { FR_CONF_FUNC("idempotence", FR_TYPE_BOOL, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("idempotence", FR_TYPE_BOOL, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "enable.idempotence" }},
/*
* When set to true, any error that could result in a gap in the
* produced message series when a batch of messages fails.
*/
- { FR_CONF_FUNC("gapless_guarantee", FR_TYPE_BOOL, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("gapless_guarantee", FR_TYPE_BOOL, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "enable.gapless.guarantee" }},
/*
* Maximum number of messages allowed on the producer queue.
* This queue is shared by all topics and partitions.
*/
- { FR_CONF_FUNC("queue_max_messages", FR_TYPE_UINT32, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("queue_max_messages", FR_TYPE_UINT32, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "queue.buffering.max.messages" }},
/*
* Maximum total message size sum allowed on the producer queue.
*/
- { FR_CONF_FUNC("queue_max_size", FR_TYPE_SIZE, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("queue_max_size", FR_TYPE_SIZE, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "queue.buffering.max.kbytes", .size_scale = 1024 }},
/*
* How long we wait to aggregate messages
*/
- { FR_CONF_FUNC("queue_max_delay", FR_TYPE_TIME_DELTA, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("queue_max_delay", FR_TYPE_TIME_DELTA, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "queue.buffering.max.ms" }},
/*
* How many times we resend a message
*/
- { FR_CONF_FUNC("message_retry_max", FR_TYPE_UINT32, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("message_retry_max", FR_TYPE_UINT32, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "message.send.max.retries" }},
/*
* The backoff time in milliseconds before retrying a protocol request.
*/
- { FR_CONF_FUNC("message_retry_interval", FR_TYPE_TIME_DELTA, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("message_retry_interval", FR_TYPE_TIME_DELTA, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "retry.backoff.ms" }},
/*
* The threshold of outstanding not yet transmitted broker requests
* needed to backpressure the producer's message accumulator.
*/
- { FR_CONF_FUNC("backpressure_threshold", FR_TYPE_UINT32, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("backpressure_threshold", FR_TYPE_UINT32, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "queue.buffering.backpressure.threshold" }},
/*
* compression codec to use for compressing message sets.
*/
- { FR_CONF_FUNC("compression_type", FR_TYPE_STRING, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("compression_type", FR_TYPE_STRING, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "compression.type" }},
/*
* Maximum size (in bytes) of all messages batched in one MessageSet
*/
- { FR_CONF_FUNC("batch_size", FR_TYPE_SIZE, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("batch_size", FR_TYPE_SIZE, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "batch.size" }},
/*
* Delay in milliseconds to wait to assign new sticky partitions for each topic
*/
- { FR_CONF_FUNC("sticky_partition_delay", FR_TYPE_TIME_DELTA, kafka_config_parse, kafka_config_dflt),
+ { FR_CONF_FUNC("sticky_partition_delay", FR_TYPE_TIME_DELTA, 0, kafka_config_parse, kafka_config_dflt),
.uctx = &(fr_kafka_conf_ctx_t){ .property = "sticky.partitioning.linger.ms" }},
- { FR_CONF_SUBSECTION_GLOBAL("topic", FR_TYPE_MULTI, kafka_base_producer_topics_config) }, \
+ { FR_CONF_SUBSECTION_GLOBAL("topic", CONF_FLAG_MULTI, kafka_base_producer_topics_config) }, \
CONF_PARSER_TERMINATOR
};
};
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" },
+ { FR_CONF_OFFSET("random_file", FR_TYPE_STRING, CONF_FLAG_FILE_EXISTS, fr_libldap_global_config_t, tls_random_file) },
+ { FR_CONF_OFFSET("ldap_debug", FR_TYPE_UINT32, 0, fr_libldap_global_config_t, ldap_debug), .dflt = "0x0000" },
CONF_PARSER_TERMINATOR
};
#include <freeradius-devel/ldap/conf.h>
conf_parser_t const fr_ldap_sasl_mech_static[] = {
- { FR_CONF_OFFSET("mech", FR_TYPE_STRING | 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) },
+ { FR_CONF_OFFSET("mech", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY, fr_ldap_sasl_t, mech) },
+ { FR_CONF_OFFSET("proxy", FR_TYPE_STRING, 0, fr_ldap_sasl_t, proxy) },
+ { FR_CONF_OFFSET("realm", FR_TYPE_STRING, 0, fr_ldap_sasl_t, realm) },
CONF_PARSER_TERMINATOR
};
/*
* Deprecated attributes
*/
- { FR_CONF_OFFSET("ca_file", FR_TYPE_FILE_INPUT, fr_ldap_config_t, tls_ca_file) },
+ { FR_CONF_OFFSET("ca_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_ldap_config_t, tls_ca_file) },
- { FR_CONF_OFFSET("ca_path", FR_TYPE_FILE_INPUT, fr_ldap_config_t, tls_ca_path) },
+ { FR_CONF_OFFSET("ca_path", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_ldap_config_t, tls_ca_path) },
- { FR_CONF_OFFSET("certificate_file", FR_TYPE_FILE_INPUT, fr_ldap_config_t, tls_certificate_file) },
+ { FR_CONF_OFFSET("certificate_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_ldap_config_t, tls_certificate_file) },
- { FR_CONF_OFFSET("private_key_file", FR_TYPE_FILE_INPUT, fr_ldap_config_t, tls_private_key_file) },
+ { FR_CONF_OFFSET("private_key_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_ldap_config_t, tls_private_key_file) },
/*
* LDAP Specific TLS attributes
*/
- { FR_CONF_OFFSET("start_tls", FR_TYPE_BOOL, fr_ldap_config_t, start_tls), .dflt = "no" },
+ { FR_CONF_OFFSET("start_tls", FR_TYPE_BOOL, 0, fr_ldap_config_t, start_tls), .dflt = "no" },
- { FR_CONF_OFFSET("require_cert", FR_TYPE_STRING, fr_ldap_config_t, tls_require_cert_str) },
+ { FR_CONF_OFFSET("require_cert", FR_TYPE_STRING, 0, fr_ldap_config_t, tls_require_cert_str) },
- { FR_CONF_OFFSET("tls_min_version", FR_TYPE_STRING, fr_ldap_config_t, tls_min_version_str) },
+ { FR_CONF_OFFSET("tls_min_version", FR_TYPE_STRING, 0, fr_ldap_config_t, tls_min_version_str) },
CONF_PARSER_TERMINATOR
};
/*
* Pool config items
*/
- { FR_CONF_OFFSET("chase_referrals", FR_TYPE_BOOL, fr_ldap_config_t, chase_referrals) },
+ { FR_CONF_OFFSET("chase_referrals", FR_TYPE_BOOL, 0, fr_ldap_config_t, chase_referrals) },
- { FR_CONF_OFFSET("use_referral_credentials", FR_TYPE_BOOL, fr_ldap_config_t, use_referral_credentials), .dflt = "no" },
+ { FR_CONF_OFFSET("use_referral_credentials", FR_TYPE_BOOL, 0, fr_ldap_config_t, use_referral_credentials), .dflt = "no" },
- { FR_CONF_OFFSET("referral_depth", FR_TYPE_UINT16, fr_ldap_config_t, referral_depth), .dflt = "5" },
+ { FR_CONF_OFFSET("referral_depth", FR_TYPE_UINT16, 0, fr_ldap_config_t, referral_depth), .dflt = "5" },
- { FR_CONF_OFFSET("rebind", FR_TYPE_BOOL, fr_ldap_config_t, rebind) },
+ { FR_CONF_OFFSET("rebind", FR_TYPE_BOOL, 0, fr_ldap_config_t, rebind) },
- { FR_CONF_OFFSET("sasl_secprops", FR_TYPE_STRING, fr_ldap_config_t, sasl_secprops) },
+ { FR_CONF_OFFSET("sasl_secprops", FR_TYPE_STRING, 0, fr_ldap_config_t, sasl_secprops) },
/*
* We use this config option to populate libldap's LDAP_OPT_NETWORK_TIMEOUT -
* timeout on network activity - specifically libldap's initial call to "connect"
* Must be non-zero for async connections to start correctly.
*/
- { FR_CONF_OFFSET("net_timeout", FR_TYPE_TIME_DELTA, fr_ldap_config_t, net_timeout), .dflt = "10" },
+ { FR_CONF_OFFSET("net_timeout", FR_TYPE_TIME_DELTA, 0, fr_ldap_config_t, net_timeout), .dflt = "10" },
- { FR_CONF_OFFSET("idle", FR_TYPE_TIME_DELTA, fr_ldap_config_t, keepalive_idle), .dflt = "60" },
+ { FR_CONF_OFFSET("idle", FR_TYPE_TIME_DELTA, 0, fr_ldap_config_t, keepalive_idle), .dflt = "60" },
- { FR_CONF_OFFSET("probes", FR_TYPE_UINT32, fr_ldap_config_t, keepalive_probes), .dflt = "3" },
+ { FR_CONF_OFFSET("probes", FR_TYPE_UINT32, 0, fr_ldap_config_t, keepalive_probes), .dflt = "3" },
- { FR_CONF_OFFSET("interval", FR_TYPE_TIME_DELTA, fr_ldap_config_t, keepalive_interval), .dflt = "30" },
+ { FR_CONF_OFFSET("interval", FR_TYPE_TIME_DELTA, 0, fr_ldap_config_t, keepalive_interval), .dflt = "30" },
- { FR_CONF_OFFSET("dereference", FR_TYPE_STRING, fr_ldap_config_t, dereference_str) },
+ { FR_CONF_OFFSET("dereference", FR_TYPE_STRING, 0, fr_ldap_config_t, dereference_str) },
/* allow server unlimited time for search (server-side limit) */
- { FR_CONF_OFFSET("srv_timelimit", FR_TYPE_TIME_DELTA, fr_ldap_config_t, srv_timelimit), .dflt = "20" },
+ { FR_CONF_OFFSET("srv_timelimit", FR_TYPE_TIME_DELTA, 0, fr_ldap_config_t, srv_timelimit), .dflt = "20" },
/*
* Instance config items
*/
/* timeout for search results */
- { FR_CONF_OFFSET("res_timeout", FR_TYPE_TIME_DELTA, fr_ldap_config_t, res_timeout), .dflt = "20" },
+ { FR_CONF_OFFSET("res_timeout", FR_TYPE_TIME_DELTA, 0, fr_ldap_config_t, res_timeout), .dflt = "20" },
- { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, fr_ldap_config_t, idle_timeout), .dflt = "300" },
+ { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, 0, fr_ldap_config_t, idle_timeout), .dflt = "300" },
- { FR_CONF_OFFSET("reconnection_delay", FR_TYPE_TIME_DELTA, fr_ldap_config_t, reconnection_delay), .dflt = "10" },
+ { FR_CONF_OFFSET("reconnection_delay", FR_TYPE_TIME_DELTA, 0, fr_ldap_config_t, reconnection_delay), .dflt = "10" },
CONF_PARSER_TERMINATOR
};
/*
* Macro for including common LDAP configuration items
*/
-#define FR_LDAP_COMMON_CONF(_conf) { FR_CONF_OFFSET("port", FR_TYPE_UINT16, _conf, handle_config.port) }, \
- { FR_CONF_OFFSET("identity", FR_TYPE_STRING, _conf, handle_config.admin_identity) }, \
- { FR_CONF_OFFSET("password", FR_TYPE_STRING | FR_TYPE_SECRET, _conf, handle_config.admin_password) }, \
- { FR_CONF_OFFSET("sasl", FR_TYPE_SUBSECTION, _conf, handle_config.admin_sasl), .subcs = (void const *) fr_ldap_sasl_mech_static }, \
- { FR_CONF_OFFSET("options", FR_TYPE_SUBSECTION, _conf, handle_config), .subcs = (void const *) fr_ldap_option_config }, \
- { FR_CONF_OFFSET("tls", FR_TYPE_SUBSECTION, _conf, handle_config), .subcs = (void const *) fr_ldap_tls_config }
+#define FR_LDAP_COMMON_CONF(_conf) { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, _conf, handle_config.port) }, \
+ { FR_CONF_OFFSET("identity", FR_TYPE_STRING, 0, _conf, handle_config.admin_identity) }, \
+ { FR_CONF_OFFSET("password", FR_TYPE_STRING, CONF_FLAG_SECRET, _conf, handle_config.admin_password) }, \
+ { FR_CONF_OFFSET("sasl", 0, CONF_FLAG_SUBSECTION, _conf, handle_config.admin_sasl), .subcs = (void const *) fr_ldap_sasl_mech_static }, \
+ { FR_CONF_OFFSET("options", 0, CONF_FLAG_SUBSECTION, _conf, handle_config), .subcs = (void const *) fr_ldap_option_config }, \
+ { FR_CONF_OFFSET("tls", 0, CONF_FLAG_SUBSECTION, _conf, handle_config), .subcs = (void const *) fr_ldap_tls_config }
} fr_redis_conf_t;
#define REDIS_COMMON_CONFIG \
- { FR_CONF_OFFSET("server", FR_TYPE_STRING | FR_TYPE_REQUIRED | FR_TYPE_MULTI, fr_redis_conf_t, hostname) }, \
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, fr_redis_conf_t, port), .dflt = "6379" }, \
- { FR_CONF_OFFSET("database", FR_TYPE_UINT32, fr_redis_conf_t, database), .dflt = "0" }, \
- { FR_CONF_OFFSET("use_tls", FR_TYPE_BOOL, fr_redis_conf_t, use_tls), .dflt = "no" }, \
- { FR_CONF_OFFSET("use_cluster_map", FR_TYPE_BOOL, fr_redis_conf_t, use_cluster_map), .dflt = "yes" }, \
- { FR_CONF_OFFSET("username", FR_TYPE_STRING, fr_redis_conf_t, username) }, \
- { FR_CONF_OFFSET("password", FR_TYPE_STRING | FR_TYPE_SECRET, fr_redis_conf_t, password) }, \
- { FR_CONF_OFFSET("max_nodes", FR_TYPE_UINT8, fr_redis_conf_t, max_nodes), .dflt = "20" }, \
- { FR_CONF_OFFSET("max_alt", FR_TYPE_UINT32, fr_redis_conf_t, max_alt), .dflt = "3" }, \
- { FR_CONF_OFFSET("max_redirects", FR_TYPE_UINT32, fr_redis_conf_t, max_redirects), .dflt = "2" }
+ { FR_CONF_OFFSET("server", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_MULTI, fr_redis_conf_t, hostname) }, \
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, fr_redis_conf_t, port), .dflt = "6379" }, \
+ { FR_CONF_OFFSET("database", FR_TYPE_UINT32, 0, fr_redis_conf_t, database), .dflt = "0" }, \
+ { FR_CONF_OFFSET("use_tls", FR_TYPE_BOOL, 0, fr_redis_conf_t, use_tls), .dflt = "no" }, \
+ { FR_CONF_OFFSET("use_cluster_map", FR_TYPE_BOOL, 0, fr_redis_conf_t, use_cluster_map), .dflt = "yes" }, \
+ { FR_CONF_OFFSET("username", FR_TYPE_STRING, 0, fr_redis_conf_t, username) }, \
+ { FR_CONF_OFFSET("password", FR_TYPE_STRING, CONF_FLAG_SECRET, fr_redis_conf_t, password) }, \
+ { FR_CONF_OFFSET("max_nodes", FR_TYPE_UINT8, 0, fr_redis_conf_t, max_nodes), .dflt = "20" }, \
+ { FR_CONF_OFFSET("max_alt", FR_TYPE_UINT32, 0, fr_redis_conf_t, max_alt), .dflt = "3" }, \
+ { FR_CONF_OFFSET("max_redirects", FR_TYPE_UINT32, 0, fr_redis_conf_t, max_redirects), .dflt = "2" }
void fr_redis_version_print(void);
/** Set the euid/egid used when performing file checks
*
* Sets the euid, and egid used when cf_file_check is called to check
- * permissions on conf items of type #FR_TYPE_FILE_INPUT.
+ * permissions on conf items of type #CONF_FLAG_FILE_INPUT
*
* @note This is probably only useful for the freeradius daemon itself.
*
char const *value;
char *tmp = NULL;
char const *quote = "";
- bool secret = (rule->type & FR_TYPE_SECRET);
- fr_type_t base_type;
+ bool secret = (rule->flags & CONF_FLAG_SECRET);
+ fr_type_t type;
if (cp->printed) return;
/*
* tmpls are special, they just need to get printed as string
*/
- if (rule->type == FR_TYPE_TMPL) {
- base_type = FR_TYPE_STRING;
+ if (rule->flags & CONF_FLAG_TMPL) {
+ type = FR_TYPE_STRING;
} else {
- base_type = FR_BASE_TYPE(rule->type);
+ type = rule->type;
}
if (secret && (fr_debug_lvl < L_DBG_LVL_3)) {
/*
* Print the strings with the correct quotation character and escaping.
*/
- if (fr_type_is_string(base_type)) {
+ if (fr_type_is_string(type)) {
value = tmp = fr_asprint(NULL, cp->value, talloc_array_length(cp->value) - 1, fr_token_quote[cp->rhs_quote]);
} else {
value = cf_pair_value(cp);
}
- if (fr_type_is_quoted(base_type)) {
+ if (fr_type_is_quoted(type)) {
switch (cf_pair_value_quote(cp)) {
default:
break;
*/
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);
-
- if (fr_value_box_from_str(ctx, out, type, NULL, cp->value, talloc_array_length(cp->value) - 1, NULL, false) < 0) {
+ if (fr_value_box_from_str(ctx, out, rule->type, NULL, cp->value, talloc_array_length(cp->value) - 1, NULL, false) < 0) {
cf_log_perr(cp, "Invalid value \"%s\" for config item %s",
cp->value, cp->attr);
/*
* Strings can be file paths...
*/
- if (fr_type_is_string(type)) {
+ if (fr_type_is_string(rule->type)) {
/*
* If there's out AND it's an input file, check
* that we can read it. This check allows errors
ssize_t slen;
- int type = rule->type;
CONF_PAIR *cp = cf_item_to_pair(ci);
cant_be_empty = fr_rule_not_empty(rule);
if (fr_rule_required(rule)) cant_be_empty = true; /* May want to review this in the future... */
- type = FR_BASE_TYPE(type); /* normal types are small */
-
/*
* Everything except templates must have a base type.
*/
- if (!type && !tmpl) {
+ if (!rule->type && !tmpl) {
cf_log_err(cp, "Configuration pair \"%s\" must have a data type", cp->attr);
return -1;
}
char const *expanded;
CONF_PAIR *cp;
char buffer[8192];
- int type;
fr_token_t dflt_quote = rule->quote;
fr_assert(rule->dflt || rule->dflt_func);
- type = FR_BASE_TYPE(rule->type);
-
if (fr_rule_required(rule)) {
- cf_log_err(cs, "Configuration pair \"%s\" must have a value", rule->name);
+ cf_log_err(cs, "Configuration pair \"%s\" must have a value", rule->name1);
return -1;
}
* If no default quote was set, determine it from the type
*/
if (dflt_quote == T_INVALID) {
- if (fr_type_is_quoted(type)) {
+ if (fr_type_is_quoted(rule->type)) {
dflt_quote = T_DOUBLE_QUOTED_STRING;
} else {
dflt_quote = T_BARE_WORD;
*/
if (rule->dflt_func) {
if (rule->dflt_func(out, parent, cs, dflt_quote, rule) < 0) {
- cf_log_perr(cs, "Failed producing default for \"%s\"", rule->name);
+ cf_log_perr(cs, "Failed producing default for \"%s\"", rule->name1);
return -1;
}
expanded = cf_expand_variables("<internal>", lineno, cs, buffer, sizeof(buffer), rule->dflt, -1, NULL);
if (!expanded) {
- cf_log_err(cs, "Failed expanding variable %s", rule->name);
+ cf_log_err(cs, "Failed expanding variable %s", rule->name1);
return -1;
}
- cp = cf_pair_alloc(cs, rule->name, expanded, T_OP_EQ, T_BARE_WORD, dflt_quote);
+ cp = cf_pair_alloc(cs, rule->name1, expanded, T_OP_EQ, T_BARE_WORD, dflt_quote);
if (!cp) return -1;
/*
static int cf_pair_unescape(CONF_PAIR *cp, conf_parser_t const *rule)
{
- fr_type_t type;
char const *p;
char *str, *unescaped, *q;
if (cp->rhs_quote != T_DOUBLE_QUOTED_STRING) return 0;
- if (rule->type != FR_TYPE_TMPL) {
- type = FR_BASE_TYPE(rule->type);
- if (type != FR_TYPE_STRING) return 0;
+ if (!(rule->flags & CONF_FLAG_TMPL)) {
+ if (rule->type != FR_TYPE_STRING) return 0;
}
if (strchr(cp->value, '\\') == NULL) return 0;
size_t count = 0;
CONF_PAIR *cp = NULL, *dflt_cp = NULL;
- unsigned int type = rule->type;
#ifndef NDEBUG
char const *dflt = rule->dflt;
fr_token_t dflt_quote = rule->quote;
/*
* Easier than re-allocing
*/
- count = cf_pair_count(cs, rule->name);
+ count = cf_pair_count(cs, rule->name1);
/*
* Multivalued, but there's no value, create a
if (!fr_rule_dflt(rule)) {
if (required) {
need_value:
- cf_log_err(cs, "Configuration item \"%s\" must have a value", rule->name);
+ cf_log_err(cs, "Configuration item \"%s\" must have a value", rule->name1);
return -1;
}
return 1;
}
if (cf_pair_default(&dflt_cp, base, cs, rule) < 0) return -1;
- count = cf_pair_count(cs, rule->name); /* Dynamic functions can add multiple defaults */
+ count = cf_pair_count(cs, rule->name1); /* Dynamic functions can add multiple defaults */
if (!count) {
if (fr_rule_not_empty(rule)) {
- cf_log_err(cs, "Configuration item \"%s\" cannot be empty", rule->name);
+ cf_log_err(cs, "Configuration item \"%s\" cannot be empty", rule->name1);
return -1;
}
return 0;
* Emit the deprecated warning in the
* context of the first pair.
*/
- cp = cf_pair_find(cs, rule->name);
+ cp = cf_pair_find(cs, rule->name1);
fr_assert(cp);
deprecated:
* talloc_array_length().
*/
} else {
- array = fr_type_array_alloc(ctx, FR_BASE_TYPE(type), count);
+ array = fr_type_array_alloc(ctx, rule->type, count);
if (unlikely(array == NULL)) {
cf_log_perr(cp, "Failed allocating value array");
return -1;
}
}
- while ((cp = cf_pair_find_next(cs, cp, rule->name))) {
+ while ((cp = cf_pair_find_next(cs, cp, rule->name1))) {
int ret;
void *entry;
TALLOC_CTX *value_ctx = array;
*/
if (!array) {
entry = NULL;
- } else if ((FR_BASE_TYPE(type) == FR_TYPE_VOID) || (type & FR_TYPE_TMPL)) {
+ } else if ((rule->type == FR_TYPE_VOID) || (rule->flags & CONF_FLAG_TMPL)) {
entry = &array[i++];
} else {
- entry = ((uint8_t *) array) + (i++ * fr_value_box_field_sizes[FR_BASE_TYPE(type)]);
+ entry = ((uint8_t *) array) + (i++ * fr_value_box_field_sizes[rule->type]);
}
if (cf_pair_unescape(cp, rule) < 0) return -1;
CONF_PAIR *next;
int ret;
- cp = cf_pair_find(cs, rule->name);
+ cp = cf_pair_find(cs, rule->name1);
if (!cp) {
if (deprecated) return 0;
cp = dflt_cp;
if (!cp) {
if (fr_rule_not_empty(rule)) {
- cf_log_err(cs, "Configuration item \"%s\" cannot be empty", rule->name);
+ cf_log_err(cs, "Configuration item \"%s\" cannot be empty", rule->name1);
return -1;
}
if (cf_pair_unescape(cp, rule) < 0) return -1;
}
- next = cf_pair_find_next(cs, cp, rule->name);
+ next = cf_pair_find_next(cs, cp, rule->name1);
if (next) {
- cf_log_err(cf_pair_to_item(next), "Invalid duplicate configuration item '%s'", rule->name);
+ cf_log_err(cf_pair_to_item(next), "Invalid duplicate configuration item '%s'", rule->name1);
return -1;
}
if (deprecated) goto deprecated;
* **fr_type_t to data type mappings**
* | fr_type_t | Data type | Dynamically allocated |
* | ----------------------- | ------------------ | ---------------------- |
- * | FR_TYPE_TMPL | ``tmpl_t`` | Yes |
* | FR_TYPE_BOOL | ``bool`` | No |
* | FR_TYPE_UINT32 | ``uint32_t`` | No |
* | FR_TYPE_UINT16 | ``uint16_t`` | No |
* @param[in] type Data type to parse #CONF_PAIR value as.
* Should be one of the following ``data`` types,
* and one or more of the following ``flag`` types or'd together:
- * - ``data`` #FR_TYPE_TMPL - @copybrief FR_TYPE_TMPL
- * Feeds the value into #tmpl_afrom_substr. Value can be
- * obtained when processing requests, with #tmpl_expand or #tmpl_aexpand.
+
* - ``data`` #FR_TYPE_BOOL - @copybrief FR_TYPE_BOOL
* - ``data`` #FR_TYPE_UINT32 - @copybrief FR_TYPE_UINT32
* - ``data`` #FR_TYPE_UINT16 - @copybrief FR_TYPE_UINT16
* - ``data`` #FR_TYPE_COMBO_IP_PREFIX - @copybrief FR_TYPE_COMBO_IP_PREFIX (IPv4/IPv6 address with
* variable prefix).
* - ``data`` #FR_TYPE_TIME_DELTA - @copybrief FR_TYPE_TIME_DELTA
+ * - ``flag`` #CONF_FLAG_TMPL - @copybrief CONF_FLAG_TMPL
+ * Feeds the value into #tmpl_afrom_substr. Value can be
+ * obtained when processing requests, with #tmpl_expand or #tmpl_aexpand.
* - ``flag`` #FR_TYPE_DEPRECATED - @copybrief FR_TYPE_DEPRECATED
- * - ``flag`` #FR_TYPE_REQUIRED - @copybrief FR_TYPE_REQUIRED
- * - ``flag`` #FR_TYPE_ATTRIBUTE - @copybrief FR_TYPE_ATTRIBUTE
- * - ``flag`` #FR_TYPE_SECRET - @copybrief FR_TYPE_SECRET
- * - ``flag`` #FR_TYPE_FILE_INPUT - @copybrief FR_TYPE_FILE_INPUT
- * - ``flag`` #FR_TYPE_NOT_EMPTY - @copybrief FR_TYPE_NOT_EMPTY
- * - ``flag`` #FR_TYPE_MULTI - @copybrief FR_TYPE_MULTI
- * - ``flag`` #FR_TYPE_IS_SET - @copybrief FR_TYPE_IS_SET
+ * - ``flag`` #CONF_FLAG_REQUIRED - @copybrief CONF_FLAG_REQUIRED
+ * - ``flag`` #CONF_FLAG_ATTRIBUTE - @copybrief CONF_FLAG_ATTRIBUTE
+ * - ``flag`` #CONF_FLAG_SECRET - @copybrief CONF_FLAG_SECRET
+ * - ``flag`` #CONF_FLAG_FILE_INPUT - @copybrief CONF_FLAG_FILE_INPUT
+ * - ``flag`` #CONF_FLAG_FILE_OUTPUT - @copybrief CONF_FLAG_FILE_OUTPUT
+ * - ``flag`` #CONF_FLAG_NOT_EMPTY - @copybrief CONF_FLAG_NOT_EMPTY
+ * - ``flag`` #CONF_FLAG_MULTI - @copybrief CONF_FLAG_MULTI
+ * - ``flag`` #CONF_FLAG_IS_SET - @copybrief CONF_FLAG_IS_SET
* @param[out] data Pointer to a global variable, or pointer to a field in the struct being populated with values.
* @param[in] dflt value to use, if no #CONF_PAIR is found.
* @param[in] dflt_quote around the dflt value.
unsigned int type, void *data, char const *dflt, fr_token_t dflt_quote)
{
conf_parser_t rule = {
- .name = name,
+ .name1 = name,
.type = type,
.dflt = dflt,
.quote = dflt_quote
{
CONF_PAIR *cp;
- if ((FR_BASE_TYPE(rule->type) == FR_TYPE_SUBSECTION)) {
+ if ((rule->flags & CONF_FLAG_SUBSECTION)) {
char const *name2 = NULL;
CONF_SECTION *subcs;
- subcs = cf_section_find(cs, rule->name, rule->ident2);
+ subcs = cf_section_find(cs, rule->name1, rule->name2);
/*
* Set the is_set field for the subsection.
*/
- if (rule->type & FR_TYPE_IS_SET) {
+ if (rule->flags & CONF_FLAG_IS_SET) {
bool *is_set;
is_set = rule->data ? rule->is_set_ptr : ((uint8_t *)base) + rule->is_set_offset;
* If there is no subsection, either complain,
* allow it, or create it with default values.
*/
- if (rule->type & FR_TYPE_REQUIRED) {
- cf_log_err(cs, "Missing %s {} subsection", rule->name);
+ if (rule->flags & CONF_FLAG_REQUIRED) {
+ cf_log_err(cs, "Missing %s {} subsection", rule->name1);
return -1;
}
* It's OK for this to be missing. Don't
* initialize it.
*/
- if ((rule->type & FR_TYPE_OK_MISSING) != 0) return 0;
+ if ((rule->flags & CONF_FLAG_OK_MISSING) != 0) return 0;
/*
* If there's no subsection in the
* that we can track the strings,
* etc. allocated in the subsection.
*/
- if (DEBUG_ENABLED4) cf_log_debug(cs, "Allocating fake section \"%s\"", rule->name);
+ if (DEBUG_ENABLED4) cf_log_debug(cs, "Allocating fake section \"%s\"", rule->name1);
/*
* If name1 is CF_IDENT_ANY, then don't
* alloc the section as we have no idea
* what it should be called.
*/
- if (rule->name == CF_IDENT_ANY) return 0;
+ if (rule->name1 == CF_IDENT_ANY) return 0;
/*
* Don't specify name2 if it's CF_IDENT_ANY
*/
- if (rule->ident2 != CF_IDENT_ANY) name2 = rule->ident2;
- subcs = cf_section_alloc(cs, cs, rule->name, name2);
+ if (rule->name2 != CF_IDENT_ANY) name2 = rule->name2;
+ subcs = cf_section_alloc(cs, cs, rule->name1, name2);
if (!subcs) return -1;
return 0;
/*
* Don't re-initialize data which was already parsed.
*/
- cp = cf_pair_find(cs, rule->name);
+ cp = cf_pair_find(cs, rule->name1);
if (cp && cp->parsed) return 0;
- if ((FR_BASE_TYPE(rule->type) != FR_TYPE_STRING) &&
- (rule->type != FR_TYPE_FILE_INPUT) &&
- (rule->type != FR_TYPE_FILE_OUTPUT)) {
+ if ((rule->type != FR_TYPE_STRING) &&
+ (rule->type != CONF_FLAG_FILE_INPUT) &&
+ (rule->type != CONF_FLAG_FILE_OUTPUT)) {
return 0;
}
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_t const *rules = rule->subcs;
uint8_t **array = NULL;
- fr_assert(type & FR_TYPE_SUBSECTION);
+ fr_assert(rule->flags & CONF_FLAG_SUBSECTION);
- subcs = cf_section_find(cs, rule->name, rule->ident2);
+ subcs = cf_section_find(cs, rule->name1, rule->name2);
if (!subcs) return 0;
/*
* Handle the single subsection case (which is simple)
*/
- if (!(type & FR_TYPE_MULTI)) {
+ if (!(rule->flags & CONF_FLAG_MULTI)) {
uint8_t *buff = NULL;
if (DEBUG_ENABLED4) cf_log_debug(cs, "Evaluating rules for %s section. Output %p",
* Handle the multi subsection case (which is harder)
*/
subcs = NULL;
- while ((subcs = cf_section_find_next(cs, subcs, rule->name, rule->ident2))) count++;
+ while ((subcs = cf_section_find_next(cs, subcs, rule->name1, rule->name2))) count++;
/*
* Allocate an array to hold the subsections
* keep the talloc hierarchy clean.
*/
subcs = NULL;
- while ((subcs = cf_section_find_next(cs, subcs, rule->name, rule->ident2))) {
+ while ((subcs = cf_section_find_next(cs, subcs, rule->name1, rule->name2))) {
uint8_t *buff = NULL;
if (DEBUG_ENABLED4) cf_log_debug(cs, "Evaluating rules for %s[%i] section. Output %p",
/*
* Handle subsections specially
*/
- if (FR_BASE_TYPE(rule->type) == FR_TYPE_SUBSECTION) {
+ if (rule->flags & CONF_FLAG_SUBSECTION) {
ret = cf_subsection_parse(ctx, data, base, cs, rule);
if (ret < 0) goto finish;
continue;
* Get pointer to where we need to write out
* whether the pointer was set.
*/
- if (rule->type & FR_TYPE_IS_SET) {
+ if (rule->flags & CONF_FLAG_IS_SET) {
is_set = rule->data ? rule->is_set_ptr : ((uint8_t *)base) + rule->is_set_offset;
}
case -2: /* Deprecated CONF ITEM */
if (((rule + 1)->offset && ((rule + 1)->offset == rule->offset)) ||
((rule + 1)->data && ((rule + 1)->data == rule->data))) {
- cf_log_err(cs, "Replace \"%s\" with \"%s\"", rule->name,
- (rule + 1)->name);
+ cf_log_err(cs, "Replace \"%s\" with \"%s\"", rule->name1,
+ (rule + 1)->name1);
}
goto finish;
}
CONF_DATA const *rule_cd = NULL;
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_t *rule;
- void *data;
- int type;
- fr_dict_t const *dict = NULL;
-
- rule = cf_data_value(rule_cd);
-
- type = rule->type;
- is_tmpl = (type & FR_TYPE_TMPL);
- is_xlat = (type & FR_TYPE_XLAT);
- attribute = (type & FR_TYPE_ATTRIBUTE);
- multi = (type & FR_TYPE_MULTI);
-
- type = FR_BASE_TYPE(type); /* normal types are small */
+ bool attribute, multi, is_tmpl, is_xlat;
+ CONF_PAIR *cp;
+ conf_parser_t *rule = cf_data_value(rule_cd);
+ void *data;
+ fr_type_t type = rule->type;
+ conf_parser_flags_t flags = rule->flags;
+ fr_dict_t const *dict = NULL;
+
+ is_tmpl = (flags & CONF_FLAG_TMPL);
+ is_xlat = (flags & CONF_FLAG_XLAT);
+ attribute = (flags & CONF_FLAG_ATTRIBUTE);
+ multi = (flags & CONF_FLAG_MULTI);
/*
* It's a section, recurse!
*/
- if (type == FR_TYPE_SUBSECTION) {
+ if (flags & CONF_FLAG_SUBSECTION) {
uint8_t *subcs_base;
- CONF_SECTION *subcs = cf_section_find(cs, rule->name, rule->ident2);
+ CONF_SECTION *subcs = cf_section_find(cs, rule->name1, rule->name2);
/*
* Select base by whether this is a nested struct,
* Find the CONF_PAIR, may still not exist if there was
* no default set for the conf_parser_t.
*/
- cp = cf_pair_find(cs, rule->name);
+ cp = cf_pair_find(cs, rule->name1);
if (!cp) continue;
/*
* Ignore %{... in shared secrets.
* They're never dynamically expanded.
*/
- if ((rule->type & FR_TYPE_SECRET) != 0) continue;
+ if ((rule->flags & CONF_FLAG_SECRET) != 0) continue;
if (strstr(cp->value, "%{") != NULL) {
cf_log_err(cp, "Found dynamic expansion in string which "
/*
* Parse (and throw away) the xlat string (for validation).
*
- * FIXME: All of these should be converted from FR_TYPE_XLAT
- * to FR_TYPE_TMPL.
+ * FIXME: All of these should be converted from CONF_FLAG_XLAT
+ * to CONF_FLAG_TMPL.
*/
if (is_xlat) {
ssize_t slen;
if (!cs || !rule) return 0;
- name1 = rule->name == CF_IDENT_ANY ? "__any__" : rule->name;
- name2 = rule->ident2 == CF_IDENT_ANY ? "__any__" : rule->ident2;
+ name1 = rule->name1 == CF_IDENT_ANY ? "__any__" : rule->name1;
+ name2 = rule->name2 == CF_IDENT_ANY ? "__any__" : rule->name2;
if (DEBUG_ENABLED4) {
cf_log_debug(cs, "Pushed parse rule to %s section: %s %s",
cf_section_name1(cs),
- name1, FR_BASE_TYPE(rule->type) & FR_TYPE_SUBSECTION ? "{}": "");
+ name1, rule->flags & CONF_FLAG_SUBSECTION ? "{}": "");
}
/*
* recurse and add the new sub-rules to the
* existing sub-section.
*/
- if (FR_BASE_TYPE(rule->type) == FR_TYPE_SUBSECTION) {
+ if (rule->flags & CONF_FLAG_SUBSECTION) {
CONF_SECTION *subcs;
subcs = cf_section_find(cs, name1, name2);
if (!cs || !rules) return 0;
- for (rule_p = rules; rule_p->name; rule_p++) {
- if (rule_p->type & FR_TYPE_DEPRECATED) continue; /* Skip deprecated */
+ for (rule_p = rules; rule_p->name1; rule_p++) {
+ if (rule_p->flags & CONF_FLAG_DEPRECATED) continue; /* Skip deprecated */
if (_cf_section_rule_push(cs, rule_p, filename, lineno) < 0) return -1;
}
typedef void _mismatch_bool; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
typedef void _mismatch_char_m; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
typedef void _mismatch_char; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
-typedef void _mismatch_double_m; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
+typedef void _mismatch_double_m; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
typedef void _mismatch_double; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
typedef void _mismatch_ethernet_m; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
typedef void _mismatch_ethernet; //!< Dummy type used to indicate FR_TYPE_*/C type mismatch.
* @param _ct data type of global or struct field, obtained with ``__typeof__``.
* @param _p Pointer or offset.
*/
-# define FR_CONF_TYPE_CHECK(_t, _ct, _p) \
-__builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_SUBSECTION), _p, \
-__builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_VOID), _p, \
-__builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_SIZE) && !((_t) & FR_TYPE_MULTI), \
+# define FR_CONF_FLAG_CHECK(_t, _f, _ct, _p) \
+__builtin_choose_expr(((_f) & CONF_FLAG_SUBSECTION), _p, \
+__builtin_choose_expr((_t == FR_TYPE_VOID), _p, \
+__builtin_choose_expr((_t == FR_TYPE_SIZE) && !((_f) & CONF_FLAG_MULTI), \
__builtin_choose_expr(IS_COMPATIBLE((_ct), size_t *), _p, (_mismatch_size) 0), \
-__builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_SIZE) && ((_t) & FR_TYPE_MULTI), \
+__builtin_choose_expr((_t == FR_TYPE_SIZE) && ((_f) & CONF_FLAG_MULTI), \
__builtin_choose_expr(IS_COMPATIBLE((_ct), size_t **), _p, (_mismatch_size_m) 0), \
-__builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_DATE) && !((_t) & FR_TYPE_MULTI), \
+__builtin_choose_expr((_t == FR_TYPE_DATE) && !((_f) & CONF_FLAG_MULTI), \
__builtin_choose_expr(IS_COMPATIBLE((_ct), time_t *), _p, (_mismatch_time) 0), \
-__builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_DATE) && ((_t) & FR_TYPE_MULTI), \
+__builtin_choose_expr((_t == FR_TYPE_DATE) && ((_f) & CONF_FLAG_MULTI), \
__builtin_choose_expr(IS_COMPATIBLE((_ct), time_t **), _p, (_mismatch_time_m) 0), \
-__builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_TIME_DELTA) && !((_t) & FR_TYPE_MULTI), \
+__builtin_choose_expr((_t == FR_TYPE_TIME_DELTA) && !((_f) & CONF_FLAG_MULTI), \
__builtin_choose_expr(IS_COMPATIBLE((_ct), fr_time_delta_t *), _p, (_mismatch_time_delta) 0), \
-__builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_TIME_DELTA) && ((_t) & FR_TYPE_MULTI), \
+__builtin_choose_expr((_t == FR_TYPE_TIME_DELTA) && ((_f) & CONF_FLAG_MULTI), \
__builtin_choose_expr(IS_COMPATIBLE((_ct), fr_time_delta_t **), _p, (_mismatch_time_delta_m) 0), \
-__builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_ETHERNET) && !((_t) & FR_TYPE_MULTI), \
+__builtin_choose_expr((_t == FR_TYPE_ETHERNET) && !((_f) & CONF_FLAG_MULTI), \
__builtin_choose_expr(IS_COMPATIBLE((_ct), uint8_t(*)[6]), _p, (_mismatch_ethernet) 0), \
-__builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_ETHERNET) && ((_t) & FR_TYPE_MULTI), \
+__builtin_choose_expr((_t == FR_TYPE_ETHERNET) && ((_f) & CONF_FLAG_MULTI), \
__builtin_choose_expr(IS_COMPATIBLE((_ct), uint8_t ***), _p, (_mismatch_ethernet_m) 0), \
-__builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_IFID) && !((_t) & FR_TYPE_MULTI), \
+__builtin_choose_expr((_t == FR_TYPE_IFID) && !((_f) & CONF_FLAG_MULTI), \
__builtin_choose_expr(IS_COMPATIBLE((_ct), uint8_t(*)[8]), _p, (_mismatch_ifid) 0), \
-__builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_IFID) && ((_t) & FR_TYPE_MULTI), \
+__builtin_choose_expr((_t == FR_TYPE_IFID) && ((_f) & CONF_FLAG_MULTI), \
__builtin_choose_expr(IS_COMPATIBLE((_ct), uint8_t ***), _p, (_mismatch_ifid_m) 0), \
_Generic((_ct), \
- tmpl_t ** : __builtin_choose_expr(((_t) & FR_TYPE_TMPL) && !((_t) & FR_TYPE_MULTI), \
+ tmpl_t ** : __builtin_choose_expr(((_f) & CONF_FLAG_TMPL) && !((_f) & CONF_FLAG_MULTI), \
_p, (_mismatch_vp_tmpl) 0), \
- tmpl_t *** : __builtin_choose_expr(((_t) & FR_TYPE_TMPL) && ((_t) & FR_TYPE_MULTI), \
+ tmpl_t *** : __builtin_choose_expr(((_f) & CONF_FLAG_TMPL) && ((_f) & CONF_FLAG_MULTI), \
_p, (_mismatch_tmpl_m) 0), \
- char const ** : __builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_STRING) && !((_t) & FR_TYPE_MULTI), \
+ char const ** : __builtin_choose_expr((_t == FR_TYPE_STRING) && !((_f) & CONF_FLAG_MULTI), \
_p, (_mismatch_char) 0), \
- char const *** : __builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_STRING) && ((_t) & FR_TYPE_MULTI), \
+ char const *** : __builtin_choose_expr((_t == FR_TYPE_STRING) && ((_f) & CONF_FLAG_MULTI), \
_p, (_mismatch_char_m) 0), \
- bool * : __builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_BOOL) && !((_t) & FR_TYPE_MULTI), \
+ bool * : __builtin_choose_expr((_t == FR_TYPE_BOOL) && !((_f) & CONF_FLAG_MULTI), \
_p, (_mismatch_bool) 0), \
- bool ** : __builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_BOOL) && ((_t) & FR_TYPE_MULTI), \
+ bool ** : __builtin_choose_expr((_t == FR_TYPE_BOOL) && ((_f) & CONF_FLAG_MULTI), \
_p, (_mismatch_bool_m) 0), \
- uint32_t * : __builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_UINT32) && !((_t) & FR_TYPE_MULTI), \
+ uint32_t * : __builtin_choose_expr((_t == FR_TYPE_UINT32) && !((_f) & CONF_FLAG_MULTI), \
_p, (_mismatch_uint32) 0), \
- uint32_t ** : __builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_UINT32) && ((_t) & FR_TYPE_MULTI), \
+ uint32_t ** : __builtin_choose_expr((_t == FR_TYPE_UINT32) && ((_f) & CONF_FLAG_MULTI), \
_p, (_mismatch_uint32_m) 0), \
- fr_ipaddr_t * : __builtin_choose_expr(((FR_BASE_TYPE(_t) == FR_TYPE_IPV4_ADDR) || \
- (FR_BASE_TYPE(_t) == FR_TYPE_IPV4_PREFIX) || \
- (FR_BASE_TYPE(_t) == FR_TYPE_IPV6_ADDR) || \
- (FR_BASE_TYPE(_t) == FR_TYPE_IPV6_PREFIX) || \
- (FR_BASE_TYPE(_t) == FR_TYPE_COMBO_IP_PREFIX) || \
- (FR_BASE_TYPE(_t) == FR_TYPE_COMBO_IP_ADDR)) || \
- !((_t) & FR_TYPE_MULTI), _p, (_mismatch_fripaddr) 0), \
- fr_ipaddr_t ** : __builtin_choose_expr(((FR_BASE_TYPE(_t) == FR_TYPE_IPV4_ADDR) || \
- (FR_BASE_TYPE(_t) == FR_TYPE_IPV4_PREFIX) || \
- (FR_BASE_TYPE(_t) == FR_TYPE_IPV6_ADDR) || \
- (FR_BASE_TYPE(_t) == FR_TYPE_IPV6_PREFIX) || \
- (FR_BASE_TYPE(_t) == FR_TYPE_COMBO_IP_PREFIX) || \
- (FR_BASE_TYPE(_t) == FR_TYPE_COMBO_IP_ADDR)) && \
- ((_t) & FR_TYPE_MULTI), _p, (_mismatch_fripaddr_m) 0), \
- uint8_t const ** : __builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_OCTETS) && !((_t) & FR_TYPE_MULTI), \
+ fr_ipaddr_t * : __builtin_choose_expr(((_t == FR_TYPE_IPV4_ADDR) || \
+ (_t == FR_TYPE_IPV4_PREFIX) || \
+ (_t == FR_TYPE_IPV6_ADDR) || \
+ (_t == FR_TYPE_IPV6_PREFIX) || \
+ (_t == FR_TYPE_COMBO_IP_PREFIX) || \
+ (_t == FR_TYPE_COMBO_IP_ADDR)) || \
+ !((_f) & CONF_FLAG_MULTI), _p, (_mismatch_fripaddr) 0), \
+ fr_ipaddr_t ** : __builtin_choose_expr(((_t == FR_TYPE_IPV4_ADDR) || \
+ (_t == FR_TYPE_IPV4_PREFIX) || \
+ (_t == FR_TYPE_IPV6_ADDR) || \
+ (_t == FR_TYPE_IPV6_PREFIX) || \
+ (_t == FR_TYPE_COMBO_IP_PREFIX) || \
+ (_t == FR_TYPE_COMBO_IP_ADDR)) && \
+ ((_f) & CONF_FLAG_MULTI), _p, (_mismatch_fripaddr_m) 0), \
+ uint8_t const ** : __builtin_choose_expr((_t == FR_TYPE_OCTETS) && !((_f) & CONF_FLAG_MULTI), \
_p, (_mismatch_uint8) 0), \
- uint8_t const ***: __builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_OCTETS) && ((_t) & FR_TYPE_MULTI), \
+ uint8_t const ***: __builtin_choose_expr((_t == FR_TYPE_OCTETS) && ((_f) & CONF_FLAG_MULTI), \
_p, (_mismatch_uint8_m) 0), \
- uint8_t * : __builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_UINT8) && !((_t) & FR_TYPE_MULTI), \
+ uint8_t * : __builtin_choose_expr((_t == FR_TYPE_UINT8) && !((_f) & CONF_FLAG_MULTI), \
_p, (_mismatch_uint8) 0), \
- uint8_t ** : __builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_UINT8) && ((_t) & FR_TYPE_MULTI), \
+ uint8_t ** : __builtin_choose_expr((_t == FR_TYPE_UINT8) && ((_f) & CONF_FLAG_MULTI), \
_p, (_mismatch_uint8_m) 0), \
- uint16_t * : __builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_UINT16) && !((_t) & FR_TYPE_MULTI), \
+ uint16_t * : __builtin_choose_expr((_t == FR_TYPE_UINT16) && !((_f) & CONF_FLAG_MULTI), \
_p, (_mismatch_uint16) 0), \
- uint16_t ** : __builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_UINT16) && ((_t) & FR_TYPE_MULTI), \
+ uint16_t ** : __builtin_choose_expr((_t == FR_TYPE_UINT16) && ((_f) & CONF_FLAG_MULTI), \
_p, (_mismatch_uint16_m) 0), \
- int32_t * : __builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_INT32) && !((_t) & FR_TYPE_MULTI), \
+ int32_t * : __builtin_choose_expr((_t == FR_TYPE_INT32) && !((_f) & CONF_FLAG_MULTI), \
_p, (_mismatch_int32) 0), \
- int32_t ** : __builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_INT32) && ((_t) & FR_TYPE_MULTI), \
+ int32_t ** : __builtin_choose_expr((_t == FR_TYPE_INT32) && ((_f) & CONF_FLAG_MULTI), \
_p, (_mismatch_int32_m) 0), \
- uint64_t * : __builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_UINT64) && !((_t) & FR_TYPE_MULTI), \
+ uint64_t * : __builtin_choose_expr((_t == FR_TYPE_UINT64) && !((_f) & CONF_FLAG_MULTI), \
_p, (_mismatch_uint64) 0), \
- uint64_t ** : __builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_UINT64) && ((_t) & FR_TYPE_MULTI), \
+ uint64_t ** : __builtin_choose_expr((_t == FR_TYPE_UINT64) && ((_f) & CONF_FLAG_MULTI), \
_p, (_mismatch_uint64_m) 0), \
- float * : __builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_FLOAT32) && !((_t) & FR_TYPE_MULTI), \
+ float * : __builtin_choose_expr((_t == FR_TYPE_FLOAT32) && !((_f) & CONF_FLAG_MULTI), \
_p, (_mismatch_float) 0), \
- float ** : __builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_FLOAT32) && ((_t) & FR_TYPE_MULTI), \
+ float ** : __builtin_choose_expr((_t == FR_TYPE_FLOAT32) && ((_f) & CONF_FLAG_MULTI), \
_p, (_mismatch_float_m) 0), \
- double * : __builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_FLOAT64) && !((_t) & FR_TYPE_MULTI), \
+ double * : __builtin_choose_expr((_t == FR_TYPE_FLOAT64) && !((_f) & CONF_FLAG_MULTI), \
_p, (_mismatch_double) 0), \
- double ** : __builtin_choose_expr((FR_BASE_TYPE(_t) == FR_TYPE_FLOAT64) && ((_t) & FR_TYPE_MULTI), \
+ double ** : __builtin_choose_expr((_t == FR_TYPE_FLOAT64) && ((_f) & CONF_FLAG_MULTI), \
_p, (_mismatch_double_m) 0), \
default: (conf_type_mismatch)0)))))))))))))
#else
-# define FR_CONF_TYPE_CHECK(_type, _c_type, _ptr_or_offset) _ptr_or_offset
+# define FR_CONF_FLAG_CHECK(_type, _flags, _c_type, _ptr_or_offset) _ptr_or_offset
#endif
/** 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.
+ * @param[in] _flags controlling parsing behaviour.
* @param[in] _struct contaning the field to write the result to.
* @param[in] _field to write the result to.
*/
-# define FR_CONF_OFFSET(_name, _type, _struct, _field) \
- .name = _name, \
- .type = _type, \
- .offset = FR_CONF_TYPE_CHECK((_type), &(((_struct *)NULL)->_field), offsetof(_struct, _field))
+# define FR_CONF_OFFSET(_name, _type, _flags, _struct, _field) \
+ .name1 = _name, \
+ .type = (_type), \
+ .flags = (_flags), \
+ .offset = FR_CONF_FLAG_CHECK((_type), (_flags), &(((_struct *)NULL)->_field), offsetof(_struct, _field))
/** 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.
+ * @param[in] _flags controlling parsing behaviour.
* @param[in] _struct contaning the field to write the result to.
* @param[in] _field to write the result to.
*/
-# define FR_CONF_OFFSET_IS_SET(_name, _type, _struct, _field) \
- .name = _name, \
- .type = (_type) | FR_TYPE_IS_SET, \
- .offset = FR_CONF_TYPE_CHECK((_type), &(((_struct *)NULL)->_field), offsetof(_struct, _field)), \
+# define FR_CONF_OFFSET_IS_SET(_name, _type, _flags, _struct, _field) \
+ .name1 = _name, \
+ .type = (_type), \
+ .flags = CONF_FLAG_IS_SET | (_flags), \
+ .offset = FR_CONF_FLAG_CHECK((_type), (_flags), &(((_struct *)NULL)->_field), offsetof(_struct, _field)), \
.is_set_offset = offsetof(_struct, _field ## _is_set)
/** 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.
+ * @param[in] _flags controlling parsing behaviour.
* @param[in] _struct containing the sub-struct to populate.
* @param[in] _field containing the sub-struct to populate.
* @param[in] _subcs CONF_SECTION to parse.
*/
# define FR_CONF_OFFSET_SUBSECTION(_name, _flags, _struct, _field, _subcs) \
- .name = _name, \
- .type = (FR_TYPE_SUBSECTION | _flags), \
+ .name1 = _name, \
+ .flags = CONF_FLAG_SUBSECTION | (_flags), \
.offset = offsetof(_struct, _field), \
.subcs = _subcs
*
* @param[in] _name of the CONF_PAIR to search for.
* @param[in] _type to parse the CONF_PAIR as.
+ * @param[in] _flags controlling parsing behaviour.
* @param[out] _res_p pointer to a global var, where the result will be written.
*/
-# define FR_CONF_POINTER(_name, _type, _res_p) \
- .name = _name, \
- .type = _type, \
- .data = FR_CONF_TYPE_CHECK((_type), (_res_p), _res_p)
+# define FR_CONF_POINTER(_name, _type, _flags, _res_p) \
+ .name1 = _name, \
+ .type = (_type), \
+ .flags = (_flags), \
+ .data = FR_CONF_FLAG_CHECK((_type), (_flags), (_res_p), _res_p)
/** 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
*
*
* @param[in] _name of the CONF_PAIR to search for.
* @param[in] _type to parse the CONF_PAIR as.
+ * @param[in] _flags controlling parsing behaviour.
* @param[out] _res_p pointer to a global var, where the result will be written.
*/
-# define FR_CONF_POINTER_IS_SET(_name, _type, _res_p) \
- .name = _name, \
- .type = (_type) | FR_TYPE_IS_SET, \
- .data = FR_CONF_TYPE_CHECK((_type), (_res_p), _res_p), \
+# define FR_CONF_POINTER_IS_SET(_name, _type, _flags, _res_p) \
+ .name1 = _name, \
+ .type = (_type), \
+ .flags = CONF_FLAG_IS_SET | (_flags), \
+ .data = FR_CONF_FLAG_CHECK((_type), (_flags), (_res_p), _res_p), \
.is_set_ptr = _res_p ## _is_set
-# define FR_ITEM_POINTER(_type, _res_p) _type, FR_CONF_TYPE_CHECK((_type), (_res_p), _res_p)
+# define FR_ITEM_POINTER(_type, _res_p) _type, FR_CONF_FLAG_CHECK((_type), 0, (_res_p), _res_p)
/** A conf_parser_t multi-subsection
*
* Parse multiple instance of a subsection, allocating an array of structs
* to hold the result.
*
- * @param _name name of subsection to search for.
- * @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_t array to use to parse subsection data.
+ * @param[in] _name name of subsection to search for.
+ * @param[in] _type the output type.
+ * @param[in] _flags flags controlling parsing behaviour.
+ * @param[in] _struct instance data struct.
+ * @param[in] _field field in instance data struct.
+ * @param[in] _subcs conf_parser_t array to use to parse subsection data.
*/
-# define FR_CONF_SUBSECTION_ALLOC(_name, _type, _struct, _field, _subcs) \
- .name = _name, \
+# define FR_CONF_SUBSECTION_ALLOC(_name, _type, _flags, _struct, _field, _subcs) \
+ .name1 = _name, \
.type = (_type), \
- .offset = FR_CONF_TYPE_CHECK((_type), &(((_struct *)NULL)->_field), offsetof(_struct, _field)), \
+ .flags = (_flags), \
+ .offset = FR_CONF_FLAG_CHECK((_type), (_flags), &(((_struct *)NULL)->_field), offsetof(_struct, _field)), \
.subcs = _subcs, \
.subcs_size = sizeof(**(((_struct *)0)->_field))
*
* @param[in] _name name of pair to search for.
* @param[in] _type base type to parse pair as.
+ * @param[in] _flags f lags controlling parsing behaviour.
* @param[in] _func to use to record value.
* @param[in] _dflt_func to use to get defaults from a 3rd party library.
*/
-# define FR_CONF_FUNC(_name, _type, _func, _dflt_func) \
- .name = _name, \
- .type = _type, \
+# define FR_CONF_FUNC(_name, _type, _flags, _func, _dflt_func) \
+ .name1 = _name, \
+ .type = (_type), \
+ .flags = (_flags), \
.func = _func, \
.dflt_func = _dflt_func
/** 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.
+ * @param[in] _flags flags controlling parsing behaviour.
* @param[in] _subcs to use to get defaults from a 3rd party library.
*/
# define FR_CONF_SUBSECTION_GLOBAL(_name, _flags, _subcs) \
- .name = _name, \
- .type = FR_TYPE_SUBSECTION, \
+ .name1 = _name, \
+ .flags = CONF_FLAG_SUBSECTION | (_flags), \
.subcs = _subcs
/** 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.
+ * @param[in] _flags flags controlling parsing behaviour.
* @param[in] _struct where the result was previously written.
* @param[in] _field in the struct where the result was previously written.
*/
-#define FR_CONF_DEPRECATED(_name, _type, _struct, _field) \
- .name = _name, \
- .type = (_type) | FR_TYPE_DEPRECATED
-
-/*
- * Instead of putting the information into a configuration structure,
- * the configuration file routines MAY just parse it directly into
- * user-supplied variables.
- */
-#define FR_TYPE_SUBSECTION 102
+#define FR_CONF_DEPRECATED(_name, _type, _flags, _struct, _field) \
+ .name1 = _name, \
+ .type = (_type ), \
+ .flags = (_flags) | CONF_FLAG_DEPRECATED
/*
* It's a developer option and should be used carefully.
* These flags should be or'd with another FR_TYPE_* value to create validation
* rules for the #cf_pair_parse function.
*
- * @note File FR_TYPE_FILE_* types have a base type of string, so they're validated
- * correctly by the config parser.
* @{
*/
-#define FR_TYPE_DEPRECATED (1 << 10) //!< If a matching #CONF_PAIR is found,
+DIAG_OFF(attribute)
+typedef enum CC_HINT(flag_enum) {
+ CONF_FLAG_SUBSECTION = (1 << 9), //!< Instead of putting the information into a
+ ///< configuration structure, the configuration
+ ///< file routines MAY just parse it directly into
+ ///< user-supplied variables.
+ CONF_FLAG_DEPRECATED = (1 << 10), //!< If a matching #CONF_PAIR is found,
//!< error out with a deprecated message.
-#define FR_TYPE_REQUIRED (1 << 11) //!< Error out if no matching #CONF_PAIR
+ CONF_FLAG_REQUIRED = (1 << 11), //!< Error out if no matching #CONF_PAIR
//!< is found, and no dflt value is set.
-#define FR_TYPE_ATTRIBUTE (1 << 12) //!< Value must resolve to attribute in dict
- //!< (deprecated, use #FR_TYPE_TMPL).
-#define FR_TYPE_SECRET (1 << 13) //!< Only print value if debug level >= 3.
+ CONF_FLAG_ATTRIBUTE = (1 << 12), //!< Value must resolve to attribute in dict
+ //!< (deprecated, use #CONF_FLAG_TMPL).
+ CONF_FLAG_SECRET = (1 << 13), //!< Only print value if debug level >= 3.
-#define FR_TYPE_FILE_INPUT ((1 << 14) | FR_TYPE_STRING) //!< File matching value must exist,
+ CONF_FLAG_FILE_INPUT = (1 << 14), //!< File matching value must exist,
//!< and must be readable.
-#define FR_TYPE_FILE_OUTPUT ((1 << 15) | FR_TYPE_STRING) //!< File matching value must exist,
+ CONF_FLAG_FILE_OUTPUT = (1 << 15), //!< File matching value must exist,
//!< and must be writable.
-#define FR_TYPE_XLAT (1 << 16) //!< string will be dynamically expanded.
-#define FR_TYPE_TMPL (1 << 17) //!< CONF_PAIR should be parsed as a template.
+ CONF_FLAG_XLAT = (1 << 16), //!< string will be dynamically expanded.
+ CONF_FLAG_TMPL = (1 << 17), //!< CONF_PAIR should be parsed as a template.
-#define FR_TYPE_MULTI (1 << 18) //!< CONF_PAIR can have multiple copies.
-#define FR_TYPE_NOT_EMPTY (1 << 19) //!< CONF_PAIR is required to have a non zero
+ CONF_FLAG_MULTI = (1 << 18), //!< CONF_PAIR can have multiple copies.
+ CONF_FLAG_NOT_EMPTY = (1 << 19), //!< CONF_PAIR is required to have a non zero
//!< length value.
-#define FR_TYPE_FILE_EXISTS ((1 << 20) | FR_TYPE_STRING) //!< File matching value must exist
+ CONF_FLAG_FILE_EXISTS = (1 << 20), //!< File matching value must exist
-#define FR_TYPE_IS_SET (1 << 21) //!< Write whether this config item was
+ CONF_FLAG_IS_SET = (1 << 21), //!< Write whether this config item was
//!< left as the default to is_set_offset
//!< or is_set_ptr.
-#define FR_TYPE_OK_MISSING (1 << 22) //!< OK if it's missing
+ CONF_FLAG_OK_MISSING = (1 << 22), //!< OK if it's missing
+} conf_parser_flags_t;
+DIAG_ON(attribute)
-#define FR_BASE_TYPE(_t) (0xff & (_t))
/** @} */
/** @name #conf_parser_t flags checks
*
* @{
*/
-#define fr_rule_deprecated(_rule) ((_rule)->type & FR_TYPE_DEPRECATED)
+#define fr_rule_deprecated(_rule) ((_rule)->flags & CONF_FLAG_DEPRECATED)
-#define fr_rule_required(_rule) ((_rule)->type & FR_TYPE_REQUIRED)
+#define fr_rule_required(_rule) ((_rule)->flags & CONF_FLAG_REQUIRED)
-#define fr_rule_secret(_rule) ((_rule)->type & FR_TYPE_SECRET)
+#define fr_rule_secret(_rule) ((_rule)->flags & CONF_FLAG_SECRET)
-#define fr_rule_file_input(_rule) (((_rule)->type & FR_TYPE_FILE_INPUT) == FR_TYPE_FILE_INPUT)
+#define fr_rule_file_input(_rule) ((_rule)->flags & CONF_FLAG_FILE_INPUT)
-#define fr_rule_file_output(_rule) (((_rule)->type & FR_TYPE_FILE_OUTPUT) == FR_TYPE_FILE_OUTPUT)
+#define fr_rule_file_output(_rule) ((_rule)->flags & CONF_FLAG_FILE_OUTPUT)
-#define fr_rule_multi(_rule) ((_rule)->type & FR_TYPE_MULTI)
+#define fr_rule_multi(_rule) ((_rule)->flags & CONF_FLAG_MULTI)
-#define fr_rule_not_empty(_rule) ((_rule)->type & FR_TYPE_NOT_EMPTY)
+#define fr_rule_not_empty(_rule) ((_rule)->flags & CONF_FLAG_NOT_EMPTY)
-#define fr_rule_is_set(_rule) ((_rule)->type & FR_TYPE_IS_SET)
+#define fr_rule_is_set(_rule) ((_rule)->flags & CONF_FLAG_IS_SET)
-#define fr_rule_ok_missing(_rule) ((_rule)->type & FR_TYPE_OK_MISSING)
+#define fr_rule_ok_missing(_rule) ((_rule)->flags & CONF_FLAG_OK_MISSING)
-#define fr_rule_file_exists(_rule) (((_rule)->type & FR_TYPE_FILE_EXISTS) == FR_TYPE_FILE_EXISTS)
+#define fr_rule_file_exists(_rule) ((_rule)->flags & CONF_FLAG_FILE_EXISTS)
#define fr_rule_dflt(_rule) ((_rule)->dflt || (_rule)->dflt_func)
-#define fr_rule_is_attribute(_rule) ((_rule)->type & FR_TYPE_ATTRIBUTE)
+#define fr_rule_is_attribute(_rule) ((_rule)->flags & CONF_FLAG_ATTRIBUTE)
-#define fr_rule_is_xlat(_rule) ((_rule)->type & FR_TYPE_XLAT)
+#define fr_rule_is_xlat(_rule) ((_rule)->flags & CONF_FLAG_XLAT)
-#define fr_rule_is_tmpl(_rule) ((_rule)->type & FR_TYPE_TMPL)
+#define fr_rule_is_tmpl(_rule) ((_rule)->flags & CONF_FLAG_TMPL)
/** @} */
#define FR_SIZE_COND_CHECK(_name, _var, _cond, _new)\
* Example with #FR_CONF_OFFSET :
@code{.c}
static conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("example", FR_TYPE_STRING | FR_TYPE_NOT_EMPTY, example_instance_t, example), .dflt = "default_value" },
+ { FR_CONF_OFFSET("example", FR_TYPE_STRING | CONF_FLAG_NOT_EMPTY, 0, 0, example_instance_t, example), .dflt = "default_value" },
CONF_PARSER_TERMINATOR
}
@endcode
* Example with #FR_CONF_POINTER :
@code{.c}
static conf_parser_t global_config[] = {
- { FR_CONF_POINTER("example", FR_TYPE_STRING | FR_TYPE_NOT_EMPTY, &my_global), .dflt = "default_value" },
+ { FR_CONF_POINTER("example", FR_TYPE_STRING | CONF_FLAG_NOT_EMPTY, 0, 0, 0, &my_global), .dflt = "default_value" },
CONF_PARSER_TERMINATOR
}
@endcode
* @see cf_pair_parse
*/
struct conf_parser_s {
- char const *name; //!< Name of the #CONF_ITEM to parse.
- char const *ident2; //!< Second identifier for #CONF_SECTION.
+ char const *name1; //!< Name of the #CONF_ITEM to parse.
+ char const *name2; //!< Second identifier for #CONF_SECTION.
+
+ fr_type_t type; //!< An #fr_type_t value, controls the output type.
- uint32_t type; //!< A #fr_type_t value, may be or'd with one or more FR_TYPE_* flags.
- //!< @see cf_pair_parse.
+ conf_parser_flags_t flags; //!< Flags which control parsing behaviour.
- size_t offset; //!< Relative offset of field or structure to write the parsed value to.
- //!< When #type is set to #FR_TYPE_SUBSECTION, may be used to specify
- //!< a base offset to add to all offsets contained within the
- //!< subsection.
- //!< @note Must be used exclusively to #data.
+ size_t offset; //!< Relative offset of field or structure to write the parsed value to.
+ //!< When #flags is set to #CONF_FLAG_SUBSECTION, may be used to specify
+ //!< a base offset to add to all offsets contained within the
+ //!< subsection.
+ //!< @note Must be used exclusively to #data.
- void *data; //!< Pointer to a static variable to write the parsed value to.
- //!< @note Must be used exclusively to #offset.
+ void *data; //!< Pointer to a static variable to write the parsed value to.
+ //!< @note Must be used exclusively to #offset.
- cf_parse_t func; //!< Override default parsing behaviour for the specified type with
- //!< a custom parsing function.
+ cf_parse_t func; //!< Override default parsing behaviour for the specified type with
+ //!< a custom parsing function.
- cf_parse_t on_read; //!< Function to call as the item is being read, just after
- //!< it has been allocated and initialized.
+ cf_parse_t on_read; //!< Function to call as the item is being read, just after
+ //!< it has been allocated and initialized.
- void const *uctx; //!< User data accessible by the #cf_parse_t func. Useful for
- ///< building reusable functions.
+ void const *uctx; //!< User data accessible by the #cf_parse_t func. Useful for
+ ///< building reusable functions.
/** Where to write status if FR_TYPE_IS_DEFAULT is set
*
};
struct {
- conf_parser_t const *subcs;//!< When type is set to #FR_TYPE_SUBSECTION, should
+ conf_parser_t const *subcs; //!< When #CONF_FLAG_SUBSECTION is set, should
//!< be a pointer to the start of another array of
//!< #conf_parser_t structs, forming the subsection.
size_t subcs_size; //!< If non-zero, allocate structs of this size to hold
size_t *len;
} cf_table_parse_ctx_t;
-#define CONF_PARSER_TERMINATOR { .name = NULL, .type = ~(UINT32_MAX - 1), \
+#define CONF_PARSER_TERMINATOR { .name1 = NULL, .type = ~(UINT32_MAX - 1), \
.offset = 0, .data = NULL, .dflt = NULL, .quote = T_INVALID }
-#define conf_parser_t_PARTIAL_TERMINATOR { .name = NULL, .type = ~(UINT32_MAX - 1), \
+#define CONF_PARSER_PARTIAL_TERMINATOR { .name1 = NULL, .type = ~(UINT32_MAX - 1), \
.offset = 1, .data = NULL, .dflt = NULL, .quote = T_INVALID }
#define CF_FILE_NONE (0)
if (cd) {
rule = cf_data_value(cd);
- if ((FR_BASE_TYPE(rule->type) == FR_TYPE_SUBSECTION) &&
+ if ((rule->flags & CONF_FLAG_SUBSECTION) &&
rule->on_read && rule->subcs) {
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) &&
+ for (rule_p = rule->subcs; rule_p->name1; rule_p++) {
+ if ((rule_p->flags & CONF_FLAG_SUBSECTION) &&
rule->on_read &&
- (strcmp(rule_p->name, name1) == 0)) {
+ (strcmp(rule_p->name1, name1) == 0)) {
if (_cf_section_rule_push(cs, rule_p,
cd->item.filename, cd->item.lineno) < 0) {
error:
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) &&
+ if ((rule->flags & CONF_FLAG_SUBSECTION) &&
rule->on_read) {
if (cf_section_rules_push(cs, rule->subcs) < 0) goto error;
if (rule->on_read(ctx, NULL, NULL, cf_section_to_item(cs), rule) < 0) goto error;
static char const *hs_proto = NULL;
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("max_connections", FR_TYPE_UINT32, 0, fr_client_t, limit.max_connections), .dflt = "16" },
- { FR_CONF_OFFSET("lifetime", FR_TYPE_TIME_DELTA, fr_client_t, limit.lifetime), .dflt = "0" },
+ { FR_CONF_OFFSET("lifetime", FR_TYPE_TIME_DELTA, 0, fr_client_t, limit.lifetime), .dflt = "0" },
- { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, fr_client_t, limit.idle_timeout), .dflt = "30s" },
+ { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, 0, fr_client_t, limit.idle_timeout), .dflt = "30s" },
CONF_PARSER_TERMINATOR
};
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) },
+ { FR_CONF_POINTER("ipaddr", FR_TYPE_COMBO_IP_PREFIX, 0, &cl_ipaddr) },
+ { FR_CONF_POINTER("ipv4addr", FR_TYPE_IPV4_PREFIX, 0, &cl_ipaddr) },
+ { FR_CONF_POINTER("ipv6addr", FR_TYPE_IPV6_PREFIX, 0, &cl_ipaddr) },
- { FR_CONF_POINTER("src_ipaddr", FR_TYPE_STRING, &cl_srcipaddr) },
+ { FR_CONF_POINTER("src_ipaddr", FR_TYPE_STRING, 0, &cl_srcipaddr) },
- { FR_CONF_OFFSET("secret", FR_TYPE_STRING | FR_TYPE_SECRET, fr_client_t, secret) },
- { FR_CONF_OFFSET("shortname", FR_TYPE_STRING, fr_client_t, shortname) },
+ { FR_CONF_OFFSET("secret", FR_TYPE_STRING, CONF_FLAG_SECRET, fr_client_t, secret) },
+ { FR_CONF_OFFSET("shortname", FR_TYPE_STRING, 0, fr_client_t, shortname) },
- { FR_CONF_OFFSET("nas_type", FR_TYPE_STRING, fr_client_t, nas_type) },
+ { FR_CONF_OFFSET("nas_type", FR_TYPE_STRING, 0, fr_client_t, nas_type) },
- { FR_CONF_OFFSET("track_connections", FR_TYPE_BOOL, fr_client_t, use_connected) },
+ { FR_CONF_OFFSET("track_connections", FR_TYPE_BOOL, 0, fr_client_t, use_connected) },
- { FR_CONF_OFFSET("require_message_authenticator", FR_TYPE_BOOL, fr_client_t, message_authenticator) },
+ { FR_CONF_OFFSET("require_message_authenticator", FR_TYPE_BOOL, 0, fr_client_t, message_authenticator) },
- { FR_CONF_OFFSET("dedup_authenticator", FR_TYPE_BOOL, fr_client_t, dedup_authenticator) },
+ { FR_CONF_OFFSET("dedup_authenticator", FR_TYPE_BOOL, 0, fr_client_t, dedup_authenticator) },
- { FR_CONF_OFFSET("response_window", FR_TYPE_TIME_DELTA, fr_client_t, response_window) },
+ { FR_CONF_OFFSET("response_window", FR_TYPE_TIME_DELTA, 0, fr_client_t, response_window) },
- { FR_CONF_POINTER("proto", FR_TYPE_STRING, &hs_proto) },
- { FR_CONF_POINTER("limit", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) limit_config },
+ { FR_CONF_POINTER("proto", FR_TYPE_STRING, 0, &hs_proto) },
+ { FR_CONF_POINTER("limit", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) limit_config },
CONF_PARSER_TERMINATOR
};
* Parse an fr_log_t configuration.
*/
static const conf_parser_t log_config[] = {
- { FR_CONF_POINTER("destination", FR_TYPE_STRING, &log_destination), .dflt = "files" },
+ { FR_CONF_POINTER("destination", FR_TYPE_STRING, 0, &log_destination), .dflt = "files" },
#if 0
/*
* @todo - once we allow this, also check that there's only _one_ destination
* which uses syslog_facility.
*/
- { FR_CONF_OFFSET("syslog_facility", FR_TYPE_VOID, main_config_t, syslog_facility), .dflt = "daemon",
+ { FR_CONF_OFFSET("syslog_facility", FR_TYPE_VOID, 0, main_config_t, syslog_facility), .dflt = "daemon",
.func = cf_table_parse_int,
.uctx = &(cf_table_parse_ctx_t){
.table = syslog_facility_table,
}
},
#endif
- { FR_CONF_POINTER_IS_SET("timestamp", FR_TYPE_BOOL, &log_timestamp) },
- { FR_CONF_OFFSET("file", FR_TYPE_STRING, fr_log_t, file), },
- { FR_CONF_OFFSET("colourise", FR_TYPE_BOOL, fr_log_t, colourise) },
- { FR_CONF_OFFSET("line_number", FR_TYPE_BOOL, fr_log_t, line_number) },
- { FR_CONF_OFFSET("use_utc", FR_TYPE_BOOL, fr_log_t, dates_utc) },
- { FR_CONF_OFFSET("print_level", FR_TYPE_BOOL, fr_log_t, print_level) },
+ { FR_CONF_POINTER_IS_SET("timestamp", FR_TYPE_BOOL, 0, &log_timestamp) },
+ { FR_CONF_OFFSET("file", FR_TYPE_STRING, 0, fr_log_t, file), },
+ { FR_CONF_OFFSET("colourise", FR_TYPE_BOOL, 0, fr_log_t, colourise) },
+ { FR_CONF_OFFSET("line_number", FR_TYPE_BOOL, 0, fr_log_t, line_number) },
+ { FR_CONF_OFFSET("use_utc", FR_TYPE_BOOL, 0, fr_log_t, dates_utc) },
+ { FR_CONF_OFFSET("print_level", FR_TYPE_BOOL, 0, fr_log_t, print_level) },
CONF_PARSER_TERMINATOR
};
* Log destinations
*/
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",
+ { FR_CONF_OFFSET("destination", FR_TYPE_STRING, 0, main_config_t, log_dest), .dflt = "files" },
+ { FR_CONF_OFFSET("syslog_facility", FR_TYPE_VOID, 0, main_config_t, syslog_facility), .dflt = "daemon",
.func = cf_table_parse_int,
.uctx = &(cf_table_parse_ctx_t){
.table = syslog_facility_table,
.len = &syslog_facility_table_len
}
},
- { FR_CONF_OFFSET("local_state_dir", FR_TYPE_STRING, main_config_t, local_state_dir), .dflt = "${prefix}/var"},
- { FR_CONF_OFFSET("logdir", FR_TYPE_STRING, main_config_t, log_dir), .dflt = "${local_state_dir}/log"},
- { FR_CONF_OFFSET("file", FR_TYPE_STRING, main_config_t, log_file), .dflt = "${logdir}/radius.log" },
- { FR_CONF_OFFSET("suppress_secrets", FR_TYPE_BOOL, main_config_t, suppress_secrets), .dflt = "no" },
+ { FR_CONF_OFFSET("local_state_dir", FR_TYPE_STRING, 0, main_config_t, local_state_dir), .dflt = "${prefix}/var"},
+ { FR_CONF_OFFSET("logdir", FR_TYPE_STRING, 0, main_config_t, log_dir), .dflt = "${local_state_dir}/log"},
+ { FR_CONF_OFFSET("file", FR_TYPE_STRING, 0, main_config_t, log_file), .dflt = "${logdir}/radius.log" },
+ { FR_CONF_OFFSET("suppress_secrets", FR_TYPE_BOOL, 0, main_config_t, suppress_secrets), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
* Basic configuration for the server.
*/
static const conf_parser_t initial_server_config[] = {
- { FR_CONF_POINTER("log", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) initial_log_config },
+ { FR_CONF_POINTER("log", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) initial_log_config },
CONF_PARSER_TERMINATOR
};
* Basic configuration for the server.
*/
static const conf_parser_t lib_dir_on_read_config[] = {
- { FR_CONF_OFFSET("prefix", FR_TYPE_STRING, main_config_t, prefix), .dflt = "/usr/local" },
+ { FR_CONF_OFFSET("prefix", FR_TYPE_STRING, 0, main_config_t, prefix), .dflt = "/usr/local" },
- { FR_CONF_OFFSET("use_utc", FR_TYPE_BOOL, main_config_t, log_dates_utc) },
- { FR_CONF_OFFSET_IS_SET("timestamp", FR_TYPE_BOOL, main_config_t, log_timestamp) },
+ { FR_CONF_OFFSET("use_utc", FR_TYPE_BOOL, 0, main_config_t, log_dates_utc) },
+ { FR_CONF_OFFSET_IS_SET("timestamp", FR_TYPE_BOOL, 0, main_config_t, log_timestamp) },
- { FR_CONF_OFFSET("libdir", FR_TYPE_STRING, main_config_t, lib_dir), .dflt = "${prefix}/lib",
+ { FR_CONF_OFFSET("libdir", FR_TYPE_STRING, 0, main_config_t, lib_dir), .dflt = "${prefix}/lib",
.on_read = lib_dir_on_read },
CONF_PARSER_TERMINATOR
*
**********************************************************************/
static const conf_parser_t log_config[] = {
- { FR_CONF_OFFSET("colourise", FR_TYPE_BOOL, 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) },
- { FR_CONF_OFFSET("use_utc", FR_TYPE_BOOL, main_config_t, log_dates_utc) },
+ { FR_CONF_OFFSET("colourise", FR_TYPE_BOOL, 0, main_config_t, do_colourise) },
+ { FR_CONF_OFFSET("line_number", FR_TYPE_BOOL, 0, main_config_t, log_line_number) },
+ { FR_CONF_OFFSET("timestamp", FR_TYPE_BOOL, 0, main_config_t, log_timestamp) },
+ { FR_CONF_OFFSET("use_utc", FR_TYPE_BOOL, 0, main_config_t, log_dates_utc) },
CONF_PARSER_TERMINATOR
};
* the config item will *not* get printed out in debug mode, so that no one knows
* it exists.
*/
- { FR_CONF_OFFSET("talloc_pool_size", FR_TYPE_SIZE | FR_TYPE_HIDDEN, main_config_t, talloc_pool_size), .func = talloc_pool_size_parse }, /* DO NOT SET DEFAULT */
- { FR_CONF_OFFSET("talloc_memory_report", FR_TYPE_BOOL | FR_TYPE_HIDDEN, main_config_t, talloc_memory_report) }, /* DO NOT SET DEFAULT */
+ { FR_CONF_OFFSET("talloc_pool_size", FR_TYPE_SIZE | FR_TYPE_HIDDEN, 0, main_config_t, talloc_pool_size), .func = talloc_pool_size_parse }, /* DO NOT SET DEFAULT */
+ { FR_CONF_OFFSET("talloc_memory_report", FR_TYPE_BOOL | FR_TYPE_HIDDEN, 0, main_config_t, talloc_memory_report) }, /* DO NOT SET DEFAULT */
CONF_PARSER_TERMINATOR
};
static const conf_parser_t thread_config[] = {
- { FR_CONF_OFFSET("num_networks", FR_TYPE_UINT32, main_config_t, max_networks), .dflt = STRINGIFY(1),
+ { FR_CONF_OFFSET("num_networks", FR_TYPE_UINT32, 0, 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),
+ { FR_CONF_OFFSET("num_workers", FR_TYPE_UINT32, 0, main_config_t, max_workers), .dflt = STRINGIFY(0),
.func = num_workers_parse, .dflt_func = num_workers_dflt },
- { FR_CONF_OFFSET("stats_interval", FR_TYPE_TIME_DELTA | FR_TYPE_HIDDEN, main_config_t, stats_interval), },
+ { FR_CONF_OFFSET("stats_interval", FR_TYPE_TIME_DELTA | FR_TYPE_HIDDEN, 0, main_config_t, stats_interval), },
#ifdef WITH_TLS
- { FR_CONF_OFFSET("openssl_async_pool_init", FR_TYPE_SIZE, main_config_t, openssl_async_pool_init), .dflt = "64" },
- { FR_CONF_OFFSET("openssl_async_pool_max", FR_TYPE_SIZE, main_config_t, openssl_async_pool_max), .dflt = "1024" },
+ { FR_CONF_OFFSET("openssl_async_pool_init", FR_TYPE_SIZE, 0, main_config_t, openssl_async_pool_init), .dflt = "64" },
+ { FR_CONF_OFFSET("openssl_async_pool_max", FR_TYPE_SIZE, 0, main_config_t, openssl_async_pool_max), .dflt = "1024" },
#endif
CONF_PARSER_TERMINATOR
* Migration configuration.
*/
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) },
+ { FR_CONF_OFFSET("rewrite_update", FR_TYPE_BOOL | FR_TYPE_HIDDEN, 0, main_config_t, rewrite_update) },
+ { FR_CONF_OFFSET("forbid_update", FR_TYPE_BOOL | FR_TYPE_HIDDEN, 0, main_config_t, forbid_update) },
CONF_PARSER_TERMINATOR
};
* Migration configuration.
*/
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) },
+ { FR_CONF_OFFSET("countup_instructions", FR_TYPE_BOOL | FR_TYPE_HIDDEN, 0, main_config_t, ins_countup) },
+ { FR_CONF_OFFSET("max_instructions", FR_TYPE_UINT32 | FR_TYPE_HIDDEN, 0, main_config_t, ins_max) },
CONF_PARSER_TERMINATOR
};
#endif
* hard-coded defines for the locations of the various
* files.
*/
- { FR_CONF_OFFSET("prefix", FR_TYPE_STRING, main_config_t, prefix), .dflt = "/usr/local" },
- { FR_CONF_OFFSET("local_state_dir", FR_TYPE_STRING, main_config_t, local_state_dir), .dflt = "${prefix}/var"},
- { FR_CONF_OFFSET("sbin_dir", FR_TYPE_STRING, main_config_t, sbin_dir), .dflt = "${prefix}/sbin"},
- { FR_CONF_OFFSET("logdir", FR_TYPE_STRING, main_config_t, log_dir), .dflt = "${local_state_dir}/log"},
- { FR_CONF_OFFSET("run_dir", FR_TYPE_STRING, main_config_t, run_dir), .dflt = "${local_state_dir}/run/${name}"},
- { FR_CONF_OFFSET("radacctdir", FR_TYPE_STRING, main_config_t, radacct_dir), .dflt = "${logdir}/radacct" },
- { FR_CONF_OFFSET("panic_action", FR_TYPE_STRING, main_config_t, panic_action) },
- { FR_CONF_OFFSET("reverse_lookups", FR_TYPE_BOOL, main_config_t, reverse_lookups), .dflt = "no", .func = reverse_lookups_parse },
- { FR_CONF_OFFSET("hostname_lookups", FR_TYPE_BOOL, main_config_t, hostname_lookups), .dflt = "yes", .func = hostname_lookups_parse },
- { FR_CONF_OFFSET("max_request_time", FR_TYPE_TIME_DELTA, main_config_t, max_request_time), .dflt = STRINGIFY(MAX_REQUEST_TIME), .func = max_request_time_parse },
- { FR_CONF_OFFSET("pidfile", FR_TYPE_STRING, main_config_t, pid_file), .dflt = "${run_dir}/radiusd.pid"},
+ { FR_CONF_OFFSET("prefix", FR_TYPE_STRING, 0, main_config_t, prefix), .dflt = "/usr/local" },
+ { FR_CONF_OFFSET("local_state_dir", FR_TYPE_STRING, 0, main_config_t, local_state_dir), .dflt = "${prefix}/var"},
+ { FR_CONF_OFFSET("sbin_dir", FR_TYPE_STRING, 0, main_config_t, sbin_dir), .dflt = "${prefix}/sbin"},
+ { FR_CONF_OFFSET("logdir", FR_TYPE_STRING, 0, main_config_t, log_dir), .dflt = "${local_state_dir}/log"},
+ { FR_CONF_OFFSET("run_dir", FR_TYPE_STRING, 0, main_config_t, run_dir), .dflt = "${local_state_dir}/run/${name}"},
+ { FR_CONF_OFFSET("radacctdir", FR_TYPE_STRING, 0, main_config_t, radacct_dir), .dflt = "${logdir}/radacct" },
+ { FR_CONF_OFFSET("panic_action", FR_TYPE_STRING, 0, main_config_t, panic_action) },
+ { FR_CONF_OFFSET("reverse_lookups", FR_TYPE_BOOL, 0, main_config_t, reverse_lookups), .dflt = "no", .func = reverse_lookups_parse },
+ { FR_CONF_OFFSET("hostname_lookups", FR_TYPE_BOOL, 0, main_config_t, hostname_lookups), .dflt = "yes", .func = hostname_lookups_parse },
+ { FR_CONF_OFFSET("max_request_time", FR_TYPE_TIME_DELTA, 0, main_config_t, max_request_time), .dflt = STRINGIFY(MAX_REQUEST_TIME), .func = max_request_time_parse },
+ { FR_CONF_OFFSET("pidfile", FR_TYPE_STRING, 0, main_config_t, pid_file), .dflt = "${run_dir}/radiusd.pid"},
- { FR_CONF_OFFSET("debug_level", FR_TYPE_UINT32 | FR_TYPE_HIDDEN, main_config_t, debug_level), .dflt = "0" },
- { FR_CONF_OFFSET("max_requests", FR_TYPE_UINT32, main_config_t, max_requests), .dflt = "0" },
+ { FR_CONF_OFFSET("debug_level", FR_TYPE_UINT32 | FR_TYPE_HIDDEN, 0, main_config_t, debug_level), .dflt = "0" },
+ { FR_CONF_OFFSET("max_requests", FR_TYPE_UINT32, 0, main_config_t, max_requests), .dflt = "0" },
- { FR_CONF_POINTER("log", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) log_config },
+ { FR_CONF_POINTER("log", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) log_config },
- { FR_CONF_POINTER("resources", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) resources },
+ { FR_CONF_POINTER("resources", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) resources },
- { FR_CONF_POINTER("thread", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) thread_config, .ident2 = CF_IDENT_ANY },
+ { FR_CONF_POINTER("thread", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) thread_config, .name2 = CF_IDENT_ANY },
- { FR_CONF_POINTER("migrate", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) migrate_config, .ident2 = CF_IDENT_ANY },
+ { FR_CONF_POINTER("migrate", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) migrate_config, .name2 = CF_IDENT_ANY },
#ifndef NDEBUG
- { FR_CONF_POINTER("interpret", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) interpret_config, .ident2 = CF_IDENT_ANY },
+ { FR_CONF_POINTER("interpret", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) interpret_config, .name2 = CF_IDENT_ANY },
#endif
CONF_PARSER_TERMINATOR
**********************************************************************/
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 },
+ { FR_CONF_OFFSET_IS_SET("user", FR_TYPE_VOID, 0, main_config_t, uid), .func = cf_parse_uid },
+ { FR_CONF_OFFSET_IS_SET("group", FR_TYPE_VOID, 0, main_config_t, gid), .func = cf_parse_gid },
#endif
- { FR_CONF_OFFSET("chroot", FR_TYPE_STRING, main_config_t, chroot_dir) },
- { FR_CONF_OFFSET("allow_core_dumps", FR_TYPE_BOOL, main_config_t, allow_core_dumps), .dflt = "no" },
+ { FR_CONF_OFFSET("chroot", FR_TYPE_STRING, 0, main_config_t, chroot_dir) },
+ { FR_CONF_OFFSET("allow_core_dumps", FR_TYPE_BOOL, 0, main_config_t, allow_core_dumps), .dflt = "no" },
#ifdef ENABLE_OPENSSL_VERSION_CHECK
- { FR_CONF_OFFSET("allow_vulnerable_openssl", FR_TYPE_STRING, main_config_t, allow_vulnerable_openssl), .dflt = "no" },
+ { FR_CONF_OFFSET("allow_vulnerable_openssl", FR_TYPE_STRING, 0, main_config_t, allow_vulnerable_openssl), .dflt = "no" },
#endif
#ifdef WITH_TLS
- { FR_CONF_OFFSET_IS_SET("openssl_fips_mode", FR_TYPE_BOOL, main_config_t, openssl_fips_mode), .dflt = "no" },
+ { FR_CONF_OFFSET_IS_SET("openssl_fips_mode", FR_TYPE_BOOL, 0, main_config_t, openssl_fips_mode), .dflt = "no" },
#endif
CONF_PARSER_TERMINATOR
};
static const conf_parser_t switch_users_config[] = {
- { FR_CONF_POINTER("security", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) security_config },
+ { FR_CONF_POINTER("security", 0, CONF_FLAG_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 */
+ { FR_CONF_OFFSET("name", FR_TYPE_STRING, 0, main_config_t, name), .func = name_parse }, /* DO NOT SET DEFAULT */
- { FR_CONF_OFFSET("prefix", FR_TYPE_STRING, main_config_t, prefix), .dflt = "/usr/local" },
- { FR_CONF_OFFSET("local_state_dir", FR_TYPE_STRING, main_config_t, local_state_dir), .dflt = "${prefix}/var"},
+ { FR_CONF_OFFSET("prefix", FR_TYPE_STRING, 0, main_config_t, prefix), .dflt = "/usr/local" },
+ { FR_CONF_OFFSET("local_state_dir", FR_TYPE_STRING, 0, main_config_t, local_state_dir), .dflt = "${prefix}/var"},
- { FR_CONF_OFFSET("run_dir", FR_TYPE_STRING, main_config_t, run_dir), .dflt = "${local_state_dir}/run/${name}"},
+ { FR_CONF_OFFSET("run_dir", FR_TYPE_STRING, 0, main_config_t, run_dir), .dflt = "${local_state_dir}/run/${name}"},
/*
* For backwards compatibility.
*/
#ifdef HAVE_SETUID
- { FR_CONF_OFFSET("user", FR_TYPE_VOID | FR_TYPE_DEPRECATED, main_config_t, uid) },
- { FR_CONF_OFFSET("group", FR_TYPE_VOID | FR_TYPE_DEPRECATED, main_config_t, gid) },
+ { FR_CONF_DEPRECATED("user", FR_TYPE_VOID, 0, main_config_t, uid) },
+ { FR_CONF_DEPRECATED("group", FR_TYPE_VOID, 0, main_config_t, gid) },
#endif
- { FR_CONF_DEPRECATED("chroot", FR_TYPE_STRING, main_config_t, NULL) },
- { FR_CONF_DEPRECATED("allow_core_dumps", FR_TYPE_BOOL, main_config_t, NULL) },
+ { FR_CONF_DEPRECATED("chroot", FR_TYPE_STRING, 0, main_config_t, NULL) },
+ { FR_CONF_DEPRECATED("allow_core_dumps", FR_TYPE_BOOL, 0, main_config_t, NULL) },
CONF_PARSER_TERMINATOR
};
value = num_workers_auto(conf, cf_section_to_item(cs));
strvalue = talloc_asprintf(NULL, "%u", value);
- *out = cf_pair_alloc(cs, rule->name, strvalue, T_OP_EQ, T_BARE_WORD, quote);
+ *out = cf_pair_alloc(cs, rule->name1, strvalue, T_OP_EQ, T_BARE_WORD, quote);
talloc_free(strvalue);
/*
};
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 },
- { FR_CONF_OFFSET("max_pending", FR_TYPE_UINT32, fr_pool_t, max_pending), .dflt = "0" },
- { FR_CONF_OFFSET("spare", FR_TYPE_UINT32, fr_pool_t, spare), .dflt = "3" },
- { FR_CONF_OFFSET("uses", FR_TYPE_UINT64, fr_pool_t, max_uses), .dflt = "0" },
- { FR_CONF_OFFSET("lifetime", FR_TYPE_TIME_DELTA, fr_pool_t, lifetime), .dflt = "0" },
- { FR_CONF_OFFSET("cleanup_interval", FR_TYPE_TIME_DELTA, fr_pool_t, cleanup_interval), .dflt = "30" },
- { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, fr_pool_t, idle_timeout), .dflt = "60" },
- { FR_CONF_OFFSET("connect_timeout", FR_TYPE_TIME_DELTA, fr_pool_t, connect_timeout), .dflt = "3.0" },
- { FR_CONF_OFFSET("held_trigger_min", FR_TYPE_TIME_DELTA, fr_pool_t, held_trigger_min), .dflt = "0.0" },
- { FR_CONF_OFFSET("held_trigger_max", FR_TYPE_TIME_DELTA, fr_pool_t, held_trigger_max), .dflt = "0.5" },
- { FR_CONF_OFFSET("retry_delay", FR_TYPE_TIME_DELTA, fr_pool_t, retry_delay), .dflt = "1" },
- { FR_CONF_OFFSET("spread", FR_TYPE_BOOL, fr_pool_t, spread), .dflt = "no" },
+ { FR_CONF_OFFSET("start", FR_TYPE_UINT32, 0, fr_pool_t, start), .dflt = "0" },
+ { FR_CONF_OFFSET("min", FR_TYPE_UINT32, 0, fr_pool_t, min), .dflt = "0" },
+ { FR_CONF_OFFSET("max", FR_TYPE_UINT32, 0, fr_pool_t, max), .dflt_func = max_dflt },
+ { FR_CONF_OFFSET("max_pending", FR_TYPE_UINT32, 0, fr_pool_t, max_pending), .dflt = "0" },
+ { FR_CONF_OFFSET("spare", FR_TYPE_UINT32, 0, fr_pool_t, spare), .dflt = "3" },
+ { FR_CONF_OFFSET("uses", FR_TYPE_UINT64, 0, fr_pool_t, max_uses), .dflt = "0" },
+ { FR_CONF_OFFSET("lifetime", FR_TYPE_TIME_DELTA, 0, fr_pool_t, lifetime), .dflt = "0" },
+ { FR_CONF_OFFSET("cleanup_interval", FR_TYPE_TIME_DELTA, 0, fr_pool_t, cleanup_interval), .dflt = "30" },
+ { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, 0, fr_pool_t, idle_timeout), .dflt = "60" },
+ { FR_CONF_OFFSET("connect_timeout", FR_TYPE_TIME_DELTA, 0, fr_pool_t, connect_timeout), .dflt = "3.0" },
+ { FR_CONF_OFFSET("held_trigger_min", FR_TYPE_TIME_DELTA, 0, fr_pool_t, held_trigger_min), .dflt = "0.0" },
+ { FR_CONF_OFFSET("held_trigger_max", FR_TYPE_TIME_DELTA, 0, fr_pool_t, held_trigger_max), .dflt = "0.5" },
+ { FR_CONF_OFFSET("retry_delay", FR_TYPE_TIME_DELTA, 0, fr_pool_t, retry_delay), .dflt = "1" },
+ { FR_CONF_OFFSET("spread", FR_TYPE_BOOL, 0, fr_pool_t, spread), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
char *strvalue;
strvalue = talloc_asprintf(NULL, "%u", main_config->max_workers);
- *out = cf_pair_alloc(cs, rule->name, strvalue, T_OP_EQ, T_BARE_WORD, quote);
+ *out = cf_pair_alloc(cs, rule->name1, strvalue, T_OP_EQ, T_BARE_WORD, quote);
talloc_free(strvalue);
return 0;
* 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_t structs, as it allows the
+ * useful when using the #CONF_FLAG_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_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" },
+ { FR_CONF_OFFSET("per_connection_max", FR_TYPE_UINT32, 0, fr_trunk_conf_t, max_req_per_conn), .dflt = "2000" },
+ { FR_CONF_OFFSET("per_connection_target", FR_TYPE_UINT32, 0, fr_trunk_conf_t, target_req_per_conn), .dflt = "1000" },
+ { FR_CONF_OFFSET("free_delay", FR_TYPE_TIME_DELTA, 0, fr_trunk_conf_t, req_cleanup_delay), .dflt = "10.0" },
CONF_PARSER_TERMINATOR
};
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" },
+ { FR_CONF_OFFSET("connect_timeout", FR_TYPE_TIME_DELTA, 0, fr_connection_conf_t, connection_timeout), .dflt = "3.0" },
+ { FR_CONF_OFFSET("reconnect_delay", FR_TYPE_TIME_DELTA, 0, fr_connection_conf_t, reconnection_delay), .dflt = "1" },
CONF_PARSER_TERMINATOR
};
#ifndef TRUNK_TESTS
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" },
- { FR_CONF_OFFSET("connecting", FR_TYPE_UINT16, fr_trunk_conf_t, connecting), .dflt = "2" },
- { FR_CONF_OFFSET("uses", FR_TYPE_UINT64, fr_trunk_conf_t, max_uses), .dflt = "0" },
- { FR_CONF_OFFSET("lifetime", FR_TYPE_TIME_DELTA, fr_trunk_conf_t, lifetime), .dflt = "0" },
+ { FR_CONF_OFFSET("start", FR_TYPE_UINT16, 0, fr_trunk_conf_t, start), .dflt = "5" },
+ { FR_CONF_OFFSET("min", FR_TYPE_UINT16, 0, fr_trunk_conf_t, min), .dflt = "1" },
+ { FR_CONF_OFFSET("max", FR_TYPE_UINT16, 0, fr_trunk_conf_t, max), .dflt = "5" },
+ { FR_CONF_OFFSET("connecting", FR_TYPE_UINT16, 0, fr_trunk_conf_t, connecting), .dflt = "2" },
+ { FR_CONF_OFFSET("uses", FR_TYPE_UINT64, 0, fr_trunk_conf_t, max_uses), .dflt = "0" },
+ { FR_CONF_OFFSET("lifetime", FR_TYPE_TIME_DELTA, 0, fr_trunk_conf_t, lifetime), .dflt = "0" },
- { FR_CONF_OFFSET("open_delay", FR_TYPE_TIME_DELTA, fr_trunk_conf_t, open_delay), .dflt = "0.2" },
- { FR_CONF_OFFSET("close_delay", FR_TYPE_TIME_DELTA, fr_trunk_conf_t, close_delay), .dflt = "10.0" },
+ { FR_CONF_OFFSET("open_delay", FR_TYPE_TIME_DELTA, 0, fr_trunk_conf_t, open_delay), .dflt = "0.2" },
+ { FR_CONF_OFFSET("close_delay", FR_TYPE_TIME_DELTA, 0, fr_trunk_conf_t, close_delay), .dflt = "10.0" },
- { FR_CONF_OFFSET("manage_interval", FR_TYPE_TIME_DELTA, fr_trunk_conf_t, manage_interval), .dflt = "0.2" },
+ { FR_CONF_OFFSET("manage_interval", FR_TYPE_TIME_DELTA, 0, fr_trunk_conf_t, manage_interval), .dflt = "0.2" },
- { FR_CONF_OFFSET("connection", FR_TYPE_SUBSECTION, fr_trunk_conf_t, conn_conf), .subcs = (void const *) fr_trunk_config_connection, .subcs_size = sizeof(fr_trunk_config_connection) },
- { FR_CONF_POINTER("request", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) fr_trunk_config_request },
+ { FR_CONF_OFFSET("connection", 0, CONF_FLAG_SUBSECTION, fr_trunk_conf_t, conn_conf), .subcs = (void const *) fr_trunk_config_connection, .subcs_size = sizeof(fr_trunk_config_connection) },
+ { FR_CONF_POINTER("request", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) fr_trunk_config_request },
CONF_PARSER_TERMINATOR
};
static int server_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, UNUSED conf_parser_t const *rule);
static const conf_parser_t server_on_read_config[] = {
- { FR_CONF_OFFSET("namespace", FR_TYPE_VOID | FR_TYPE_REQUIRED, fr_virtual_server_t, process_mi),
+ { FR_CONF_OFFSET("namespace", FR_TYPE_VOID, CONF_FLAG_REQUIRED, fr_virtual_server_t, process_mi),
.on_read = namespace_on_read },
CONF_PARSER_TERMINATOR
* Not really ok if it's missing but we want to
* let logic elsewhere handle the issue.
*/
- { FR_CONF_POINTER("server", FR_TYPE_SUBSECTION | FR_TYPE_MULTI | FR_TYPE_OK_MISSING, &virtual_servers),
+ { FR_CONF_POINTER("server", 0, CONF_FLAG_SUBSECTION | CONF_FLAG_OK_MISSING | CONF_FLAG_MULTI, &virtual_servers),
.subcs_size = sizeof(fr_virtual_server_t), .subcs_type = "fr_virtual_server_t",
- .subcs = (void const *) server_on_read_config, .ident2 = CF_IDENT_ANY,
+ .subcs = (void const *) server_on_read_config, .name2 = CF_IDENT_ANY,
.on_read = server_on_read },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t server_config[] = {
- { FR_CONF_OFFSET("namespace", FR_TYPE_VOID | FR_TYPE_REQUIRED, fr_virtual_server_t, process_mi),
+ { FR_CONF_OFFSET("namespace", FR_TYPE_VOID, CONF_FLAG_REQUIRED, fr_virtual_server_t, process_mi),
.func = namespace_parse },
- { FR_CONF_OFFSET("listen", FR_TYPE_SUBSECTION | FR_TYPE_MULTI | FR_TYPE_OK_MISSING,
+ { FR_CONF_OFFSET("listen", 0, CONF_FLAG_SUBSECTION | CONF_FLAG_OK_MISSING | CONF_FLAG_MULTI,
fr_virtual_server_t, listeners),
- .ident2 = CF_IDENT_ANY,
+ .name2 = CF_IDENT_ANY,
.subcs_size = sizeof(fr_virtual_listen_t), .subcs_type = "fr_virtual_listen_t",
.func = listen_parse },
* Not really ok if it's missing but we want to
* let logic elsewhere handle the issue.
*/
- { FR_CONF_POINTER("server", FR_TYPE_SUBSECTION | FR_TYPE_MULTI | FR_TYPE_OK_MISSING, &virtual_servers),
+ { FR_CONF_POINTER("server", 0, CONF_FLAG_SUBSECTION | CONF_FLAG_OK_MISSING | CONF_FLAG_MULTI, &virtual_servers),
.subcs_size = sizeof(fr_virtual_server_t), .subcs_type = "fr_virtual_server_t",
- .subcs = (void const *) server_config, .ident2 = CF_IDENT_ANY,
+ .subcs = (void const *) server_config, .name2 = CF_IDENT_ANY,
.func = server_parse },
CONF_PARSER_TERMINATOR
/** Define a values for Auth-Type attributes by the sections present in a virtual-server
*
- * The ident2 value of any sections found will be converted into values of the specified da.
+ * The.name2 value of any sections found will be converted into values of the specified da.
*
* @param[in] server_cs The virtual server containing the sections.
* @param[in] subcs_name of the subsection to search for.
*
*/
typedef struct {
- int file_format; //!< Whether the file is expected to be PEM encoded.
- ///< This allows us to load multiple chained PEM certificates
- ///< from a single file.
+ int file_format; //!< Whether the file is expected to be PEM encoded.
+ ///< This allows us to load multiple chained PEM certificates
+ ///< from a single file.
- char const *certificate_file; //!< Path to certificate.
+ char const *certificate_file; //!< Path to certificate.
- char const *password; //!< Password to decrypt the certificate(s).
- char const *private_key_file; //!< Path to certificate.
+ char const *password; //!< Password to decrypt the certificate(s).
+ char const *private_key_file; //!< Path to certificate.
- char const **ca_files; //!< Extra certificates to load.
- fr_tls_chain_verify_mode_t verify_mode; //!< How hard we try to build up a complete certificate
- ///< chain.
- bool include_root_ca; //!< Include the root ca in the chain we built.
+ char const **ca_files; //!< Extra certificates to load.
+ fr_tls_chain_verify_mode_t verify_mode; //!< How hard we try to build up a complete certificate
+ ///< chain.
+ bool include_root_ca; //!< Include the root ca in the chain we built.
- fr_unix_time_t valid_until; //!< The certificate in the chain which expires the earliest.
+ fr_unix_time_t valid_until; //!< The certificate in the chain which expires the earliest.
} fr_tls_chain_conf_t;
/** Control what types of session resumption we allow
static size_t verify_mode_table_len = NUM_ELEMENTS(verify_mode_table);
static conf_parser_t tls_cache_config[] = {
- { FR_CONF_OFFSET("mode", FR_TYPE_UINT32, fr_tls_cache_conf_t, mode),
+ { FR_CONF_OFFSET("mode", FR_TYPE_UINT32, 0, fr_tls_cache_conf_t, mode),
.func = tls_conf_parse_cache_mode,
.uctx = &(cf_table_parse_ctx_t){
.table = cache_mode_table,
.len = &cache_mode_table_len
},
.dflt = "auto" },
- { FR_CONF_OFFSET("name", FR_TYPE_TMPL, fr_tls_cache_conf_t, id_name),
+ { FR_CONF_OFFSET("name", FR_TYPE_VOID, CONF_FLAG_TMPL, fr_tls_cache_conf_t, id_name),
.dflt = "%{EAP-Type}%interpreter(server)", .quote = T_DOUBLE_QUOTED_STRING },
- { FR_CONF_OFFSET("lifetime", FR_TYPE_TIME_DELTA, fr_tls_cache_conf_t, lifetime), .dflt = "1d" },
+ { FR_CONF_OFFSET("lifetime", FR_TYPE_TIME_DELTA, 0, fr_tls_cache_conf_t, lifetime), .dflt = "1d" },
#if OPENSSL_VERSION_NUMBER >= 0x10100000L
- { FR_CONF_OFFSET("require_extended_master_secret", FR_TYPE_BOOL, fr_tls_cache_conf_t, require_extms), .dflt = "yes" },
- { FR_CONF_OFFSET("require_perfect_forward_secrecy", FR_TYPE_BOOL, fr_tls_cache_conf_t, require_pfs), .dflt = "no" },
+ { FR_CONF_OFFSET("require_extended_master_secret", FR_TYPE_BOOL, 0, fr_tls_cache_conf_t, require_extms), .dflt = "yes" },
+ { FR_CONF_OFFSET("require_perfect_forward_secrecy", FR_TYPE_BOOL, 0, fr_tls_cache_conf_t, require_pfs), .dflt = "no" },
#endif
- { FR_CONF_OFFSET("session_ticket_key", FR_TYPE_OCTETS, fr_tls_cache_conf_t, session_ticket_key) },
+ { FR_CONF_OFFSET("session_ticket_key", FR_TYPE_OCTETS, 0, fr_tls_cache_conf_t, session_ticket_key) },
/*
* Deprecated
*/
- { FR_CONF_DEPRECATED("enable", FR_TYPE_BOOL, fr_tls_cache_conf_t, NULL) },
- { FR_CONF_DEPRECATED("max_entries", FR_TYPE_UINT32, fr_tls_cache_conf_t, NULL) },
- { FR_CONF_DEPRECATED("persist_dir", FR_TYPE_STRING, fr_tls_cache_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("enable", FR_TYPE_BOOL, 0, fr_tls_cache_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("max_entries", FR_TYPE_UINT32, 0, fr_tls_cache_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("persist_dir", FR_TYPE_STRING, 0, fr_tls_cache_conf_t, NULL) },
CONF_PARSER_TERMINATOR
};
static conf_parser_t tls_chain_config[] = {
- { FR_CONF_OFFSET("format", FR_TYPE_VOID, fr_tls_chain_conf_t, file_format),
+ { FR_CONF_OFFSET("format", FR_TYPE_VOID, 0, fr_tls_chain_conf_t, file_format),
.func = cf_table_parse_int,
.uctx = &(cf_table_parse_ctx_t){
.table = certificate_format_table,
.len = &certificate_format_table_len
},
.dflt = "pem" },
- { FR_CONF_OFFSET("certificate_file", FR_TYPE_FILE_INPUT | FR_TYPE_FILE_EXISTS | FR_TYPE_REQUIRED , fr_tls_chain_conf_t, certificate_file) },
- { FR_CONF_OFFSET("private_key_password", FR_TYPE_STRING | FR_TYPE_SECRET, fr_tls_chain_conf_t, password) },
- { FR_CONF_OFFSET("private_key_file", FR_TYPE_FILE_INPUT | FR_TYPE_FILE_EXISTS | FR_TYPE_REQUIRED, fr_tls_chain_conf_t, private_key_file) },
+ { FR_CONF_OFFSET("certificate_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_FILE_EXISTS | CONF_FLAG_REQUIRED, fr_tls_chain_conf_t, certificate_file) },
+ { FR_CONF_OFFSET("private_key_password", FR_TYPE_STRING, CONF_FLAG_SECRET, fr_tls_chain_conf_t, password) },
+ { FR_CONF_OFFSET("private_key_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_FILE_EXISTS | CONF_FLAG_REQUIRED, fr_tls_chain_conf_t, private_key_file) },
- { FR_CONF_OFFSET("ca_file", FR_TYPE_FILE_INPUT | FR_TYPE_MULTI, fr_tls_chain_conf_t, ca_files) },
+ { FR_CONF_OFFSET("ca_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_MULTI, fr_tls_chain_conf_t, ca_files) },
- { FR_CONF_OFFSET("verify_mode", FR_TYPE_VOID, fr_tls_chain_conf_t, verify_mode),
+ { FR_CONF_OFFSET("verify_mode", FR_TYPE_VOID, 0, fr_tls_chain_conf_t, verify_mode),
.func = cf_table_parse_int,
.uctx = &(cf_table_parse_ctx_t){
.table = chain_verify_mode_table,
.len = &chain_verify_mode_table_len
},
.dflt = "hard" },
- { FR_CONF_OFFSET("include_root_ca", FR_TYPE_BOOL, fr_tls_chain_conf_t, include_root_ca), .dflt = "no" },
+ { FR_CONF_OFFSET("include_root_ca", FR_TYPE_BOOL, 0, fr_tls_chain_conf_t, include_root_ca), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
static conf_parser_t tls_verify_config[] = {
- { FR_CONF_OFFSET("mode", FR_TYPE_VOID, fr_tls_verify_conf_t, mode),
+ { FR_CONF_OFFSET("mode", FR_TYPE_VOID, 0, fr_tls_verify_conf_t, mode),
.func = cf_table_parse_int,
.uctx = &(cf_table_parse_ctx_t){
.table = verify_mode_table,
.len = &verify_mode_table_len
},
.dflt = "all" },
- { FR_CONF_OFFSET("attribute_mode", FR_TYPE_VOID, fr_tls_verify_conf_t, attribute_mode),
+ { FR_CONF_OFFSET("attribute_mode", FR_TYPE_VOID, 0, fr_tls_verify_conf_t, attribute_mode),
.func = cf_table_parse_int,
.uctx = &(cf_table_parse_ctx_t){
.table = verify_mode_table,
.len = &verify_mode_table_len
},
.dflt = "client-and-issuer" },
- { FR_CONF_OFFSET("check_crl", FR_TYPE_BOOL, fr_tls_verify_conf_t, check_crl), .dflt = "no" },
- { FR_CONF_OFFSET("allow_expired_crl", FR_TYPE_BOOL, fr_tls_verify_conf_t, allow_expired_crl) },
- { FR_CONF_OFFSET("allow_not_yet_valid_crl", FR_TYPE_BOOL, fr_tls_verify_conf_t, allow_not_yet_valid_crl) },
+ { FR_CONF_OFFSET("check_crl", FR_TYPE_BOOL, 0, fr_tls_verify_conf_t, check_crl), .dflt = "no" },
+ { FR_CONF_OFFSET("allow_expired_crl", FR_TYPE_BOOL, 0, fr_tls_verify_conf_t, allow_expired_crl) },
+ { FR_CONF_OFFSET("allow_not_yet_valid_crl", FR_TYPE_BOOL, 0, fr_tls_verify_conf_t, allow_not_yet_valid_crl) },
CONF_PARSER_TERMINATOR
};
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("virtual_server", FR_TYPE_VOID, 0, 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),
+ { FR_CONF_OFFSET("chain", 0, CONF_FLAG_SUBSECTION | CONF_FLAG_MULTI, fr_tls_conf_t, chains),
.subcs_size = sizeof(fr_tls_chain_conf_t), .subcs_type = "fr_tls_chain_conf_t",
- .subcs = tls_chain_config, .ident2 = CF_IDENT_ANY },
+ .subcs = tls_chain_config, .name2 = CF_IDENT_ANY },
- { FR_CONF_DEPRECATED("pem_file_type", FR_TYPE_BOOL, fr_tls_conf_t, NULL) },
- { FR_CONF_DEPRECATED("certificate_file", FR_TYPE_FILE_INPUT, fr_tls_conf_t, NULL) },
- { FR_CONF_DEPRECATED("private_key_password", FR_TYPE_STRING | FR_TYPE_SECRET, fr_tls_conf_t, NULL) },
- { FR_CONF_DEPRECATED("private_key_file", FR_TYPE_FILE_INPUT, fr_tls_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("pem_file_type", FR_TYPE_BOOL, 0, fr_tls_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("certificate_file", FR_TYPE_STRING, 0, fr_tls_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("private_key_password", FR_TYPE_STRING, 0, fr_tls_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("private_key_file", FR_TYPE_STRING, 0, fr_tls_conf_t, NULL) },
- { FR_CONF_OFFSET("verify_depth", FR_TYPE_UINT32, fr_tls_conf_t, verify_depth), .dflt = "0" },
- { FR_CONF_OFFSET("ca_path", FR_TYPE_FILE_INPUT, fr_tls_conf_t, ca_path) },
- { FR_CONF_OFFSET("ca_file", FR_TYPE_FILE_INPUT, fr_tls_conf_t, ca_file) },
+ { FR_CONF_OFFSET("verify_depth", FR_TYPE_UINT32, 0, fr_tls_conf_t, verify_depth), .dflt = "0" },
+ { FR_CONF_OFFSET("ca_path", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_tls_conf_t, ca_path) },
+ { FR_CONF_OFFSET("ca_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_tls_conf_t, ca_file) },
#ifdef PSK_MAX_IDENTITY_LEN
- { FR_CONF_OFFSET("psk_identity", FR_TYPE_STRING, fr_tls_conf_t, psk_identity) },
- { FR_CONF_OFFSET("psk_hexphrase", FR_TYPE_STRING | FR_TYPE_SECRET, fr_tls_conf_t, psk_password) },
- { FR_CONF_OFFSET("psk_query", FR_TYPE_STRING, fr_tls_conf_t, psk_query) },
+ { FR_CONF_OFFSET("psk_identity", FR_TYPE_STRING, 0, fr_tls_conf_t, psk_identity) },
+ { FR_CONF_OFFSET("psk_hexphrase", FR_TYPE_STRING, CONF_FLAG_SECRET, fr_tls_conf_t, psk_password) },
+ { FR_CONF_OFFSET("psk_query", FR_TYPE_STRING, 0, fr_tls_conf_t, psk_query) },
#endif
- { FR_CONF_OFFSET("keylog_file", FR_TYPE_STRING, fr_tls_conf_t, keylog_file) },
+ { FR_CONF_OFFSET("keylog_file", FR_TYPE_STRING, 0, fr_tls_conf_t, keylog_file) },
- { FR_CONF_OFFSET("dh_file", FR_TYPE_FILE_INPUT, fr_tls_conf_t, dh_file) },
- { FR_CONF_OFFSET("fragment_size", FR_TYPE_UINT32, fr_tls_conf_t, fragment_size), .dflt = "1024" },
- { FR_CONF_OFFSET("padding", FR_TYPE_UINT32, fr_tls_conf_t, padding_block_size), },
+ { FR_CONF_OFFSET("dh_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_tls_conf_t, dh_file) },
+ { FR_CONF_OFFSET("fragment_size", FR_TYPE_UINT32, 0, fr_tls_conf_t, fragment_size), .dflt = "1024" },
+ { FR_CONF_OFFSET("padding", FR_TYPE_UINT32, 0, fr_tls_conf_t, padding_block_size), },
- { FR_CONF_OFFSET("disable_single_dh_use", FR_TYPE_BOOL, fr_tls_conf_t, disable_single_dh_use) },
+ { FR_CONF_OFFSET("disable_single_dh_use", FR_TYPE_BOOL, 0, fr_tls_conf_t, disable_single_dh_use) },
- { FR_CONF_OFFSET("cipher_list", FR_TYPE_STRING, fr_tls_conf_t, cipher_list) },
- { FR_CONF_OFFSET("cipher_server_preference", FR_TYPE_BOOL, fr_tls_conf_t, cipher_server_preference), .dflt = "yes" },
+ { FR_CONF_OFFSET("cipher_list", FR_TYPE_STRING, 0, fr_tls_conf_t, cipher_list) },
+ { FR_CONF_OFFSET("cipher_server_preference", FR_TYPE_BOOL, 0, fr_tls_conf_t, cipher_server_preference), .dflt = "yes" },
#ifdef SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS
- { FR_CONF_OFFSET("allow_renegotiation", FR_TYPE_BOOL, fr_tls_conf_t, allow_renegotiation), .dflt = "no" },
+ { FR_CONF_OFFSET("allow_renegotiation", FR_TYPE_BOOL, 0, fr_tls_conf_t, allow_renegotiation), .dflt = "no" },
#endif
#ifndef OPENSSL_NO_ECDH
- { FR_CONF_OFFSET("ecdh_curve", FR_TYPE_STRING, fr_tls_conf_t, ecdh_curve), .dflt = "prime256v1" },
+ { FR_CONF_OFFSET("ecdh_curve", FR_TYPE_STRING, 0, fr_tls_conf_t, ecdh_curve), .dflt = "prime256v1" },
#endif
- { FR_CONF_OFFSET("tls_max_version", FR_TYPE_FLOAT32, fr_tls_conf_t, tls_max_version) },
+ { FR_CONF_OFFSET("tls_max_version", FR_TYPE_FLOAT32, 0, fr_tls_conf_t, tls_max_version) },
- { FR_CONF_OFFSET("tls_min_version", FR_TYPE_FLOAT32, fr_tls_conf_t, tls_min_version), .dflt = "1.2" },
+ { FR_CONF_OFFSET("tls_min_version", FR_TYPE_FLOAT32, 0, fr_tls_conf_t, tls_min_version), .dflt = "1.2" },
- { FR_CONF_OFFSET("session", FR_TYPE_SUBSECTION, fr_tls_conf_t, cache), .subcs = (void const *) tls_cache_config },
+ { FR_CONF_OFFSET("session", 0, CONF_FLAG_SUBSECTION, fr_tls_conf_t, cache), .subcs = (void const *) tls_cache_config },
- { FR_CONF_OFFSET("verify", FR_TYPE_SUBSECTION, fr_tls_conf_t, verify), .subcs = (void const *) tls_verify_config },
+ { FR_CONF_OFFSET("verify", 0, CONF_FLAG_SUBSECTION, fr_tls_conf_t, verify), .subcs = (void const *) tls_verify_config },
- { FR_CONF_DEPRECATED("check_cert_issuer", FR_TYPE_STRING, fr_tls_conf_t, check_cert_issuer) },
- { FR_CONF_DEPRECATED("check_cert_cn", FR_TYPE_STRING, fr_tls_conf_t, check_cert_cn) },
+ { FR_CONF_DEPRECATED("check_cert_issuer", FR_TYPE_STRING, 0, fr_tls_conf_t, check_cert_issuer) },
+ { FR_CONF_DEPRECATED("check_cert_cn", FR_TYPE_STRING, 0, fr_tls_conf_t, check_cert_cn) },
CONF_PARSER_TERMINATOR
};
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),
+ { FR_CONF_OFFSET("chain", 0, CONF_FLAG_SUBSECTION | CONF_FLAG_OK_MISSING | CONF_FLAG_MULTI, fr_tls_conf_t, chains),
.subcs_size = sizeof(fr_tls_chain_conf_t), .subcs_type = "fr_tls_chain_conf_t",
.subcs = tls_chain_config },
- { FR_CONF_DEPRECATED("pem_file_type", FR_TYPE_BOOL, fr_tls_conf_t, NULL) },
- { FR_CONF_DEPRECATED("certificate_file", FR_TYPE_FILE_INPUT, fr_tls_conf_t, NULL) },
- { FR_CONF_DEPRECATED("private_key_password", FR_TYPE_STRING | FR_TYPE_SECRET, fr_tls_conf_t, NULL) },
- { FR_CONF_DEPRECATED("private_key_file", FR_TYPE_FILE_INPUT, fr_tls_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("pem_file_type", FR_TYPE_BOOL, 0, fr_tls_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("certificate_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_tls_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("private_key_password", FR_TYPE_STRING, CONF_FLAG_SECRET, fr_tls_conf_t, NULL) },
+ { FR_CONF_DEPRECATED("private_key_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_tls_conf_t, NULL) },
#ifdef PSK_MAX_IDENTITY_LEN
- { FR_CONF_OFFSET("psk_identity", FR_TYPE_STRING, fr_tls_conf_t, psk_identity) },
- { FR_CONF_OFFSET("psk_hexphrase", FR_TYPE_STRING | FR_TYPE_SECRET, fr_tls_conf_t, psk_password) },
+ { FR_CONF_OFFSET("psk_identity", FR_TYPE_STRING, 0, fr_tls_conf_t, psk_identity) },
+ { FR_CONF_OFFSET("psk_hexphrase", FR_TYPE_STRING, CONF_FLAG_SECRET, fr_tls_conf_t, psk_password) },
#endif
- { FR_CONF_OFFSET("keylog_file", FR_TYPE_STRING, fr_tls_conf_t, keylog_file) },
+ { FR_CONF_OFFSET("keylog_file", FR_TYPE_STRING, 0, fr_tls_conf_t, keylog_file) },
- { FR_CONF_OFFSET("verify_depth", FR_TYPE_UINT32, fr_tls_conf_t, verify_depth), .dflt = "0" },
- { FR_CONF_OFFSET("ca_path", FR_TYPE_FILE_INPUT, fr_tls_conf_t, ca_path) },
+ { FR_CONF_OFFSET("verify_depth", FR_TYPE_UINT32, 0, fr_tls_conf_t, verify_depth), .dflt = "0" },
+ { FR_CONF_OFFSET("ca_path", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_tls_conf_t, ca_path) },
- { FR_CONF_OFFSET("ca_file", FR_TYPE_FILE_INPUT, fr_tls_conf_t, ca_file) },
- { FR_CONF_OFFSET("dh_file", FR_TYPE_STRING, fr_tls_conf_t, dh_file) },
- { FR_CONF_OFFSET("random_file", FR_TYPE_STRING, fr_tls_conf_t, random_file) },
- { FR_CONF_OFFSET("fragment_size", FR_TYPE_UINT32, fr_tls_conf_t, fragment_size), .dflt = "1024" },
+ { FR_CONF_OFFSET("ca_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, fr_tls_conf_t, ca_file) },
+ { FR_CONF_OFFSET("dh_file", FR_TYPE_STRING, 0, fr_tls_conf_t, dh_file) },
+ { FR_CONF_OFFSET("random_file", FR_TYPE_STRING, 0, fr_tls_conf_t, random_file) },
+ { FR_CONF_OFFSET("fragment_size", FR_TYPE_UINT32, 0, fr_tls_conf_t, fragment_size), .dflt = "1024" },
- { FR_CONF_OFFSET("cipher_list", FR_TYPE_STRING, fr_tls_conf_t, cipher_list) },
+ { FR_CONF_OFFSET("cipher_list", FR_TYPE_STRING, 0, fr_tls_conf_t, cipher_list) },
#ifndef OPENSSL_NO_ECDH
- { FR_CONF_OFFSET("ecdh_curve", FR_TYPE_STRING, fr_tls_conf_t, ecdh_curve), .dflt = "prime256v1" },
+ { FR_CONF_OFFSET("ecdh_curve", FR_TYPE_STRING, 0, fr_tls_conf_t, ecdh_curve), .dflt = "prime256v1" },
#endif
- { FR_CONF_OFFSET("tls_max_version", FR_TYPE_FLOAT32, fr_tls_conf_t, tls_max_version) },
+ { FR_CONF_OFFSET("tls_max_version", FR_TYPE_FLOAT32, 0, fr_tls_conf_t, tls_max_version) },
- { FR_CONF_OFFSET("tls_min_version", FR_TYPE_FLOAT32, fr_tls_conf_t, tls_min_version), .dflt = "1.2" },
+ { FR_CONF_OFFSET("tls_min_version", FR_TYPE_FLOAT32, 0, fr_tls_conf_t, tls_min_version), .dflt = "1.2" },
- { FR_CONF_DEPRECATED("check_cert_issuer", FR_TYPE_STRING, fr_tls_conf_t, check_cert_issuer) },
- { FR_CONF_DEPRECATED("check_cert_cn", FR_TYPE_STRING, fr_tls_conf_t, check_cert_cn) },
+ { FR_CONF_DEPRECATED("check_cert_issuer", FR_TYPE_STRING, 0, fr_tls_conf_t, check_cert_issuer) },
+ { FR_CONF_DEPRECATED("check_cert_cn", FR_TYPE_STRING, 0, fr_tls_conf_t, check_cert_cn) },
CONF_PARSER_TERMINATOR
};
* Concatenate multiple boxes if needed
*/
if (env->rule->pair.concat &&
- fr_value_box_list_concat_in_place(vb, vb, tmpl_expanded, FR_BASE_TYPE(env->rule->type),
+ fr_value_box_list_concat_in_place(vb, vb, tmpl_expanded, env->rule->type,
FR_VALUE_BOX_LIST_FREE, true, SIZE_MAX) < 0 ) {
RPEDEBUG("Failed concatenating values for %s", env->rule->name);
return CALL_ENV_INVALID;
fr_type_t type;
while (call_env->name) {
- if (FR_BASE_TYPE(call_env->type) == FR_TYPE_SUBSECTION) {
+ if (call_env->flags & CONF_FLAG_SUBSECTION) {
CONF_SECTION const *subcs;
subcs = cf_section_find(cs, call_env->name, call_env->section.ident2);
if (!subcs) {
quote = call_env->dflt_quote;
}
- type = FR_BASE_TYPE(call_env->type);
+ type = call_env->type;
if (tmpl_afrom_substr(call_env_parsed, &call_env_parsed->tmpl, &FR_SBUFF_IN(value, len),
quote, NULL, &(tmpl_rules_t){
.cast = (type == FR_TYPE_VOID ? FR_TYPE_NULL : type),
case TMPL_TYPE_DATA:
case TMPL_TYPE_EXEC:
case TMPL_TYPE_XLAT:
- if (call_env->type & FR_TYPE_ATTRIBUTE) {
+ if (call_env->type & CONF_FLAG_ATTRIBUTE) {
cf_log_perr(cp, "'%s' expands to %s - attribute reference required", value,
fr_table_str_by_value(tmpl_type_table, call_env_parsed->tmpl->type,
"<INVALID>"));
*names_len = 0;
while (call_env->name) {
- if (FR_BASE_TYPE(call_env->type) == FR_TYPE_SUBSECTION) {
+ if (call_env->flags & CONF_FLAG_SUBSECTION) {
CONF_SECTION const *subcs;
subcs = cf_section_find(cs, call_env->name, call_env->section.ident2);
if (!subcs) goto next;
char const *dflt; //!< Default string to pass to the tmpl_tokenizer if no CONF_PAIR found.
fr_token_t dflt_quote; //!< Default quoting for the default string.
- uint32_t type; //!< To cast boxes to. Also contains flags controlling parser behaviour.
+ fr_type_t type; //!< To cast boxes to. Also contains flags controlling parser behaviour.
+ conf_parser_flags_t flags; //!< Flags controlling parser behaviour.
size_t offset; //!< Where to write results in the output structure when the tmpls are evaluated.
/** Only FR_TYPE_STRING and FR_TYPE_OCTETS can be concatenated.
*/
#define FR_CALL_ENV_CONCAT(_c, _ct) \
-__builtin_choose_expr(FR_BASE_TYPE(_ct) == FR_TYPE_STRING, _c, \
-__builtin_choose_expr(FR_BASE_TYPE(_ct) == FR_TYPE_OCTETS, _c, \
+__builtin_choose_expr(_ct == FR_TYPE_STRING, _c, \
+__builtin_choose_expr(_ct == FR_TYPE_OCTETS, _c, \
__builtin_choose_expr(_c, (void)0, false)))
/** Mapping from field types to destination type enum
fr_value_box_list_t * : "fr_value_box_list_t" \
)
-#define FR_CALL_ENV_OFFSET(_name, _cast_type, _struct, _field, _dflt, _dflt_quote, _required, _nullable, _concat) \
+#define FR_CALL_ENV_OFFSET(_name, _cast_type, _flags, _struct, _field, _dflt, _dflt_quote, _required, _nullable, _concat) \
.name = _name, \
.type = _cast_type, \
.offset = offsetof(_struct, _field), \
/** Version of the above which sets optional field for pointer to tmpl
*/
-#define FR_CALL_ENV_TMPL_OFFSET(_name, _cast_type, _struct, _field, _tmpl_field, _dflt, _dflt_quote, _required, _nullable, _concat) \
+#define FR_CALL_ENV_TMPL_OFFSET(_name, _cast_type, _flags, _struct, _field, _tmpl_field, _dflt, _dflt_quote, _required, _nullable, _concat) \
.name = _name, \
.type = _cast_type, \
.offset = offsetof(_struct, _field), \
/** Version of the above which only sets the field for a pointer to the tmpl
*/
-#define FR_CALL_ENV_TMPL_ONLY_OFFSET(_name, _cast_type, _struct, _tmpl_field, _dflt, _dflt_quote, _required) \
+#define FR_CALL_ENV_TMPL_ONLY_OFFSET(_name, _cast_type, _flags, _struct, _tmpl_field, _dflt, _dflt_quote, _required) \
.name = _name, \
.type = _cast_type, \
.dflt = _dflt, \
#define FR_CALL_ENV_SUBSECTION(_name, _ident2, _subcs, _required ) \
.name = _name, \
- .type = FR_TYPE_SUBSECTION, \
+ .flags = CONF_FLAG_SUBSECTION, \
.section = { \
.ident2 = _ident2, \
.subcs = _subcs, \
/** conf_parser_t entries to populate user configurable slab values
*/
#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" }, \
+ { FR_CONF_OFFSET("min", FR_TYPE_UINT32, 0, fr_slab_config_t, min_elements), .dflt = "10" }, \
+ { FR_CONF_OFFSET("max", FR_TYPE_UINT32, 0, fr_slab_config_t, max_elements), .dflt = "100" }, \
+ { FR_CONF_OFFSET("cleanup_interval", FR_TYPE_TIME_DELTA, 0, fr_slab_config_t, interval), .dflt = "30s" }, \
/** Tuneable parameters for slabs
*/
*
*/
static conf_parser_t const proto_arp_config[] = {
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, proto_arp_t, num_messages) } ,
+ { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_arp_t, num_messages) } ,
- { FR_CONF_OFFSET("active", FR_TYPE_BOOL, proto_arp_t, active), .dflt = "false" } ,
+ { FR_CONF_OFFSET("active", FR_TYPE_BOOL, 0, proto_arp_t, active), .dflt = "false" } ,
CONF_PARSER_TERMINATOR
};
*
*/
static conf_parser_t const arp_listen_config[] = {
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING | FR_TYPE_NOT_EMPTY, proto_arp_ethernet_t,
+ { FR_CONF_OFFSET("interface", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY, proto_arp_ethernet_t,
interface), .dflt = "eth0" },
- { FR_CONF_OFFSET("filter", FR_TYPE_STRING, proto_arp_ethernet_t, filter) },
+ { FR_CONF_OFFSET("filter", FR_TYPE_STRING, 0, proto_arp_ethernet_t, filter) },
CONF_PARSER_TERMINATOR
};
*
*/
static conf_parser_t const proto_bfd_config[] = {
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_bfd_t, io.submodule),
+ { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_bfd_t, io.submodule),
.func = transport_parse },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t peer_config[] = {
- { FR_CONF_OFFSET("min_transmit_interval", FR_TYPE_TIME_DELTA, 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 ) },
- { FR_CONF_OFFSET("demand", FR_TYPE_BOOL, bfd_session_t, demand_mode ) },
+ { FR_CONF_OFFSET("min_transmit_interval", FR_TYPE_TIME_DELTA, 0, bfd_session_t, desired_min_tx_interval ) },
+ { FR_CONF_OFFSET("min_receive_interval", FR_TYPE_TIME_DELTA, 0, bfd_session_t, required_min_rx_interval ) },
+ { FR_CONF_OFFSET("max_timeouts", FR_TYPE_UINT32, 0, bfd_session_t, detect_multi ) },
+ { FR_CONF_OFFSET("demand", FR_TYPE_BOOL, 0, bfd_session_t, demand_mode ) },
- { FR_CONF_OFFSET("auth_type", FR_TYPE_VOID, bfd_session_t, auth_type ),
+ { FR_CONF_OFFSET("auth_type", FR_TYPE_VOID, 0, bfd_session_t, auth_type ),
.func = auth_type_parse },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, bfd_session_t, port ) },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, bfd_session_t, port ) },
CONF_PARSER_TERMINATOR
};
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) },
+ { FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_bfd_udp_t, allow) },
+ { FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_bfd_udp_t, deny) },
CONF_PARSER_TERMINATOR
};
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) },
+ { FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_bfd_udp_t, ipaddr) },
+ { FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, 0, proto_bfd_udp_t, ipaddr) },
+ { FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, 0, proto_bfd_udp_t, ipaddr) },
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, proto_bfd_udp_t, interface) },
- { FR_CONF_OFFSET("port_name", FR_TYPE_STRING, proto_bfd_udp_t, port_name) },
+ { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, proto_bfd_udp_t, interface) },
+ { FR_CONF_OFFSET("port_name", FR_TYPE_STRING, 0, proto_bfd_udp_t, port_name) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, proto_bfd_udp_t, port) },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, proto_bfd_udp_t, port) },
- { FR_CONF_OFFSET("ttl", FR_TYPE_UINT8, proto_bfd_udp_t, ttl), .dflt = "255" },
+ { FR_CONF_OFFSET("ttl", FR_TYPE_UINT8, 0, proto_bfd_udp_t, ttl), .dflt = "255" },
- { FR_CONF_OFFSET("only_state_changes", FR_TYPE_BOOL, proto_bfd_udp_t, only_state_changes), .dflt = "yes" },
+ { FR_CONF_OFFSET("only_state_changes", FR_TYPE_BOOL, 0, proto_bfd_udp_t, only_state_changes), .dflt = "yes" },
- { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, proto_bfd_udp_t, recv_buff) },
- { FR_CONF_OFFSET_IS_SET("send_buff", FR_TYPE_UINT32, proto_bfd_udp_t, send_buff) },
+ { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, proto_bfd_udp_t, recv_buff) },
+ { FR_CONF_OFFSET_IS_SET("send_buff", FR_TYPE_UINT32, 0, proto_bfd_udp_t, send_buff) },
-// { FR_CONF_OFFSET("dynamic_clients", FR_TYPE_BOOL, proto_bfd_udp_t, dynamic_clients) } ,
- { FR_CONF_POINTER("networks", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) networks_config },
+// { FR_CONF_OFFSET("dynamic_clients", FR_TYPE_BOOL, 0, proto_bfd_udp_t, dynamic_clients) } ,
+ { FR_CONF_POINTER("networks", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) networks_config },
CONF_PARSER_TERMINATOR
};
static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
static conf_parser_t const limit_config[] = {
- { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, 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" } ,
+ { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, 0, proto_control_t, io.idle_timeout), .dflt = "30.0" } ,
+ { FR_CONF_OFFSET("nak_lifetime", FR_TYPE_TIME_DELTA, 0, proto_control_t, io.nak_lifetime), .dflt = "30.0" } ,
- { FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, proto_control_t, io.max_connections), .dflt = "1024" } ,
- { FR_CONF_OFFSET("max_clients", FR_TYPE_UINT32, proto_control_t, io.max_clients), .dflt = "256" } ,
- { FR_CONF_OFFSET("max_pending_packets", FR_TYPE_UINT32, proto_control_t, io.max_pending_packets), .dflt = "256" } ,
+ { FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, 0, proto_control_t, io.max_connections), .dflt = "1024" } ,
+ { FR_CONF_OFFSET("max_clients", FR_TYPE_UINT32, 0, proto_control_t, io.max_clients), .dflt = "256" } ,
+ { FR_CONF_OFFSET("max_pending_packets", FR_TYPE_UINT32, 0, proto_control_t, io.max_pending_packets), .dflt = "256" } ,
/*
* For performance tweaking. NOT for normal humans.
*/
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, proto_control_t, max_packet_size) } ,
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, proto_control_t, num_messages) } ,
+ { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_control_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_control_t, num_messages) } ,
CONF_PARSER_TERMINATOR
};
*
*/
static conf_parser_t const proto_control_config[] = {
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_control_t, io.submodule),
+ { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_control_t, io.submodule),
.func = transport_parse },
- { FR_CONF_POINTER("limit", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) limit_config },
+ { FR_CONF_POINTER("limit", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) limit_config },
CONF_PARSER_TERMINATOR
};
} proto_control_unix_t;
static const conf_parser_t unix_listen_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING | FR_TYPE_REQUIRED, proto_control_unix_t, filename),
+ { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_REQUIRED, proto_control_unix_t, filename),
.dflt = "${run_dir}/radiusd.sock}" },
- { FR_CONF_OFFSET("uid", FR_TYPE_STRING, proto_control_unix_t, uid_name) },
- { FR_CONF_OFFSET("gid", FR_TYPE_STRING, proto_control_unix_t, gid_name) },
- { FR_CONF_OFFSET("mode", FR_TYPE_STRING, proto_control_unix_t, mode_name) },
- { FR_CONF_OFFSET("peercred", FR_TYPE_BOOL, proto_control_unix_t, peercred), .dflt = "yes" },
+ { FR_CONF_OFFSET("uid", FR_TYPE_STRING, 0, proto_control_unix_t, uid_name) },
+ { FR_CONF_OFFSET("gid", FR_TYPE_STRING, 0, proto_control_unix_t, gid_name) },
+ { FR_CONF_OFFSET("mode", FR_TYPE_STRING, 0, proto_control_unix_t, mode_name) },
+ { FR_CONF_OFFSET("peercred", FR_TYPE_BOOL, 0, proto_control_unix_t, peercred), .dflt = "yes" },
- { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, proto_control_unix_t, recv_buff) },
+ { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, proto_control_unix_t, recv_buff) },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, proto_control_unix_t, max_packet_size), .dflt = "4096" } ,
+ { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_control_unix_t, max_packet_size), .dflt = "4096" } ,
CONF_PARSER_TERMINATOR
};
/*
* For performance tweaking. NOT for normal humans.
*/
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, proto_cron_t, max_packet_size) } ,
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, proto_cron_t, num_messages) } ,
+ { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_cron_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_cron_t, num_messages) } ,
CONF_PARSER_TERMINATOR
};
*
*/
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,
+ { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_REQUIRED, proto_cron_t,
type), .func = type_parse },
- { FR_CONF_OFFSET("when", FR_TYPE_STRING | FR_TYPE_NOT_EMPTY | FR_TYPE_REQUIRED, proto_cron_t, spec),
+ { FR_CONF_OFFSET("when", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY | CONF_FLAG_REQUIRED, proto_cron_t, spec),
.func = time_parse },
- { FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT | FR_TYPE_REQUIRED | FR_TYPE_NOT_EMPTY, proto_cron_t, filename ) },
+ { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, proto_cron_t, filename ) },
- { FR_CONF_OFFSET("priority", FR_TYPE_UINT32, proto_cron_t, priority) },
+ { FR_CONF_OFFSET("priority", FR_TYPE_UINT32, 0, proto_cron_t, priority) },
- { FR_CONF_POINTER("limit", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) limit_config },
+ { FR_CONF_POINTER("limit", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) limit_config },
CONF_PARSER_TERMINATOR
};
*
*/
static conf_parser_t const proto_cron_config[] = {
- { FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_NOT_EMPTY | FR_TYPE_REQUIRED, proto_cron_t,
+ { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_REQUIRED, proto_cron_t,
type), .func = type_parse },
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_cron_t, io.submodule),
+ { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_cron_t, io.submodule),
.func = transport_parse, .dflt = "crontab" },
/*
* Add this as a synonym so normal humans can understand it.
*/
- { FR_CONF_OFFSET("max_entry_size", FR_TYPE_UINT32, proto_cron_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("max_entry_size", FR_TYPE_UINT32, 0, proto_cron_t, max_packet_size) } ,
/*
* For performance tweaking. NOT for normal humans.
*/
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, proto_cron_t, max_packet_size) } ,
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, proto_cron_t, num_messages) } ,
+ { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_cron_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_cron_t, num_messages) } ,
- { FR_CONF_OFFSET("priority", FR_TYPE_UINT32, proto_cron_t, priority) },
+ { FR_CONF_OFFSET("priority", FR_TYPE_UINT32, 0, proto_cron_t, priority) },
CONF_PARSER_TERMINATOR
};
static int time_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
static const conf_parser_t crontab_listen_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT | FR_TYPE_REQUIRED | FR_TYPE_NOT_EMPTY, proto_cron_crontab_t, filename) },
+ { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, proto_cron_crontab_t, filename) },
- { FR_CONF_OFFSET("timespec", FR_TYPE_STRING | FR_TYPE_NOT_EMPTY | FR_TYPE_REQUIRED, proto_cron_crontab_t, spec),
+ { FR_CONF_OFFSET("timespec", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY | CONF_FLAG_REQUIRED, proto_cron_crontab_t, spec),
.func = time_parse },
CONF_PARSER_TERMINATOR
*
*/
static conf_parser_t const proto_detail_config[] = {
- { FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_NOT_EMPTY | FR_TYPE_REQUIRED, proto_detail_t,
+ { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_REQUIRED, proto_detail_t,
type), .func = type_parse },
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_detail_t, io_submodule),
+ { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_detail_t, io_submodule),
.func = transport_parse, .dflt = "file" },
/*
* Add this as a synonym so normal humans can understand it.
*/
- { FR_CONF_OFFSET("max_entry_size", FR_TYPE_UINT32, proto_detail_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("max_entry_size", FR_TYPE_UINT32, 0, proto_detail_t, max_packet_size) } ,
/*
* For performance tweaking. NOT for normal humans.
*/
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, proto_detail_t, max_packet_size) } ,
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, proto_detail_t, num_messages) } ,
+ { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_detail_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_detail_t, num_messages) } ,
- { FR_CONF_OFFSET("exit_when_done", FR_TYPE_BOOL, proto_detail_t, exit_when_done) },
+ { FR_CONF_OFFSET("exit_when_done", FR_TYPE_BOOL, 0, proto_detail_t, exit_when_done) },
- { FR_CONF_OFFSET("priority", FR_TYPE_UINT32, proto_detail_t, priority) },
+ { FR_CONF_OFFSET("priority", FR_TYPE_UINT32, 0, proto_detail_t, priority) },
CONF_PARSER_TERMINATOR
};
static void mod_vnode_delete(fr_event_list_t *el, int fd, UNUSED int fflags, void *ctx);
static const conf_parser_t file_listen_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_STRING | FR_TYPE_REQUIRED, proto_detail_file_t, filename ) },
+ { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_REQUIRED, proto_detail_file_t, filename ) },
- { FR_CONF_OFFSET("filename_work", FR_TYPE_STRING, proto_detail_file_t, filename_work ) },
+ { FR_CONF_OFFSET("filename_work", FR_TYPE_STRING, 0, proto_detail_file_t, filename_work ) },
- { FR_CONF_OFFSET("poll_interval", FR_TYPE_UINT32, proto_detail_file_t, poll_interval), .dflt = "5" },
+ { FR_CONF_OFFSET("poll_interval", FR_TYPE_UINT32, 0, proto_detail_file_t, poll_interval), .dflt = "5" },
- { FR_CONF_OFFSET("immediate", FR_TYPE_BOOL, proto_detail_file_t, immediate) },
+ { FR_CONF_OFFSET("immediate", FR_TYPE_BOOL, 0, proto_detail_file_t, immediate) },
CONF_PARSER_TERMINATOR
};
} fr_detail_entry_t;
static conf_parser_t limit_config[] = {
- { FR_CONF_OFFSET("initial_rtx_time", FR_TYPE_TIME_DELTA, 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) },
+ { FR_CONF_OFFSET("initial_rtx_time", FR_TYPE_TIME_DELTA, 0, proto_detail_work_t, retry_config.irt), .dflt = STRINGIFY(2) },
+ { FR_CONF_OFFSET("max_rtx_time", FR_TYPE_TIME_DELTA, 0, proto_detail_work_t, retry_config.mrt), .dflt = STRINGIFY(16) },
/*
* Retransmit indefinitely, as v2 and v3 did.
*/
- { FR_CONF_OFFSET("max_rtx_count", FR_TYPE_UINT32, proto_detail_work_t, retry_config.mrc), .dflt = STRINGIFY(0) },
+ { FR_CONF_OFFSET("max_rtx_count", FR_TYPE_UINT32, 0, proto_detail_work_t, retry_config.mrc), .dflt = STRINGIFY(0) },
/*
* ...again same as v2 and v3.
*/
- { FR_CONF_OFFSET("max_rtx_duration", FR_TYPE_TIME_DELTA, proto_detail_work_t, retry_config.mrd), .dflt = STRINGIFY(0) },
- { FR_CONF_OFFSET("max_outstanding", FR_TYPE_UINT16, proto_detail_work_t, max_outstanding), .dflt = STRINGIFY(1) },
+ { FR_CONF_OFFSET("max_rtx_duration", FR_TYPE_TIME_DELTA, 0, proto_detail_work_t, retry_config.mrd), .dflt = STRINGIFY(0) },
+ { FR_CONF_OFFSET("max_outstanding", FR_TYPE_UINT16, 0, proto_detail_work_t, max_outstanding), .dflt = STRINGIFY(1) },
CONF_PARSER_TERMINATOR
};
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("filename", FR_TYPE_STRING, CONF_FLAG_REQUIRED, proto_detail_work_t, filename_work ) },
- { FR_CONF_OFFSET("track", FR_TYPE_BOOL, proto_detail_work_t, track_progress ) },
+ { FR_CONF_OFFSET("track", FR_TYPE_BOOL, 0, proto_detail_work_t, track_progress ) },
- { FR_CONF_OFFSET("retransmit", FR_TYPE_BOOL, proto_detail_work_t, retransmit ), .dflt = "yes" },
+ { FR_CONF_OFFSET("retransmit", FR_TYPE_BOOL, 0, proto_detail_work_t, retransmit ), .dflt = "yes" },
- { FR_CONF_POINTER("limit", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) limit_config },
+ { FR_CONF_POINTER("limit", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) limit_config },
CONF_PARSER_TERMINATOR
};
static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
static const conf_parser_t priority_config[] = {
- { FR_CONF_OFFSET("Discover", FR_TYPE_VOID, proto_dhcpv4_t, priorities[FR_DHCP_DISCOVER]),
+ { FR_CONF_OFFSET("Discover", FR_TYPE_VOID, 0, proto_dhcpv4_t, priorities[FR_DHCP_DISCOVER]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Request", FR_TYPE_VOID, proto_dhcpv4_t, priorities[FR_DHCP_REQUEST]),
+ { FR_CONF_OFFSET("Request", FR_TYPE_VOID, 0, proto_dhcpv4_t, priorities[FR_DHCP_REQUEST]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Decline", FR_TYPE_VOID, proto_dhcpv4_t, priorities[FR_DHCP_DECLINE]),
+ { FR_CONF_OFFSET("Decline", FR_TYPE_VOID, 0, proto_dhcpv4_t, priorities[FR_DHCP_DECLINE]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Release", FR_TYPE_VOID, proto_dhcpv4_t, priorities[FR_DHCP_RELEASE]),
+ { FR_CONF_OFFSET("Release", FR_TYPE_VOID, 0, proto_dhcpv4_t, priorities[FR_DHCP_RELEASE]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Inform", FR_TYPE_VOID, proto_dhcpv4_t, priorities[FR_DHCP_INFORM]),
+ { FR_CONF_OFFSET("Inform", FR_TYPE_VOID, 0, proto_dhcpv4_t, priorities[FR_DHCP_INFORM]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Lease-Query", FR_TYPE_VOID, proto_dhcpv4_t, priorities[FR_DHCP_LEASE_QUERY]),
+ { FR_CONF_OFFSET("Lease-Query", FR_TYPE_VOID, 0, proto_dhcpv4_t, priorities[FR_DHCP_LEASE_QUERY]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "low" },
- { FR_CONF_OFFSET("Bulk-Lease-Query", FR_TYPE_VOID, proto_dhcpv4_t, priorities[FR_DHCP_BULK_LEASE_QUERY]),
+ { FR_CONF_OFFSET("Bulk-Lease-Query", FR_TYPE_VOID, 0, proto_dhcpv4_t, priorities[FR_DHCP_BULK_LEASE_QUERY]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "low" },
CONF_PARSER_TERMINATOR
};
static conf_parser_t const limit_config[] = {
- { FR_CONF_OFFSET("cleanup_delay", FR_TYPE_TIME_DELTA, 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" } ,
+ { FR_CONF_OFFSET("cleanup_delay", FR_TYPE_TIME_DELTA, 0, proto_dhcpv4_t, io.cleanup_delay), .dflt = "5.0" } ,
+ { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, 0, proto_dhcpv4_t, io.idle_timeout), .dflt = "30.0" } ,
+ { FR_CONF_OFFSET("nak_lifetime", FR_TYPE_TIME_DELTA, 0, proto_dhcpv4_t, io.nak_lifetime), .dflt = "30.0" } ,
- { FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, proto_dhcpv4_t, io.max_connections), .dflt = "1024" } ,
- { FR_CONF_OFFSET("max_clients", FR_TYPE_UINT32, proto_dhcpv4_t, io.max_clients), .dflt = "256" } ,
- { FR_CONF_OFFSET("max_pending_packets", FR_TYPE_UINT32, proto_dhcpv4_t, io.max_pending_packets), .dflt = "256" } ,
+ { FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, 0, proto_dhcpv4_t, io.max_connections), .dflt = "1024" } ,
+ { FR_CONF_OFFSET("max_clients", FR_TYPE_UINT32, 0, proto_dhcpv4_t, io.max_clients), .dflt = "256" } ,
+ { FR_CONF_OFFSET("max_pending_packets", FR_TYPE_UINT32, 0, proto_dhcpv4_t, io.max_pending_packets), .dflt = "256" } ,
/*
* For performance tweaking. NOT for normal humans.
*/
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, proto_dhcpv4_t, max_packet_size) } ,
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, proto_dhcpv4_t, num_messages) } ,
- { FR_CONF_POINTER("priority", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) priority_config },
+ { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_dhcpv4_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_dhcpv4_t, num_messages) } ,
+ { FR_CONF_POINTER("priority", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) priority_config },
CONF_PARSER_TERMINATOR
};
*
*/
static conf_parser_t const proto_dhcpv4_config[] = {
- { FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_MULTI | FR_TYPE_NOT_EMPTY, proto_dhcpv4_t,
+ { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI, proto_dhcpv4_t,
allowed_types), .func = type_parse },
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_dhcpv4_t, io.submodule),
+ { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_dhcpv4_t, io.submodule),
.func = transport_parse },
- { FR_CONF_POINTER("limit", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) limit_config },
+ { FR_CONF_POINTER("limit", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) limit_config },
CONF_PARSER_TERMINATOR
};
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) },
+ { FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_dhcpv4_udp_t, allow) },
+ { FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_dhcpv4_udp_t, deny) },
CONF_PARSER_TERMINATOR
};
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) },
+ { FR_CONF_OFFSET("ipaddr", FR_TYPE_IPV4_ADDR, 0, proto_dhcpv4_udp_t, ipaddr) },
+ { FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, 0, proto_dhcpv4_udp_t, ipaddr) },
- { FR_CONF_OFFSET("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, proto_dhcpv4_udp_t, src_ipaddr) },
+ { FR_CONF_OFFSET("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_dhcpv4_udp_t, src_ipaddr) },
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, proto_dhcpv4_udp_t, interface) },
- { FR_CONF_OFFSET("port_name", FR_TYPE_STRING, proto_dhcpv4_udp_t, port_name) },
+ { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, proto_dhcpv4_udp_t, interface) },
+ { FR_CONF_OFFSET("port_name", FR_TYPE_STRING, 0, proto_dhcpv4_udp_t, port_name) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, proto_dhcpv4_udp_t, port) },
- { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, proto_dhcpv4_udp_t, recv_buff) },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, proto_dhcpv4_udp_t, port) },
+ { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, proto_dhcpv4_udp_t, recv_buff) },
- { FR_CONF_OFFSET("broadcast", FR_TYPE_BOOL, proto_dhcpv4_udp_t, broadcast) } ,
+ { FR_CONF_OFFSET("broadcast", FR_TYPE_BOOL, 0, proto_dhcpv4_udp_t, broadcast) } ,
- { FR_CONF_OFFSET("dynamic_clients", FR_TYPE_BOOL, proto_dhcpv4_udp_t, dynamic_clients) } ,
- { FR_CONF_POINTER("networks", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) networks_config },
+ { FR_CONF_OFFSET("dynamic_clients", FR_TYPE_BOOL, 0, proto_dhcpv4_udp_t, dynamic_clients) } ,
+ { FR_CONF_POINTER("networks", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) networks_config },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, proto_dhcpv4_udp_t, max_packet_size), .dflt = "4096" } ,
- { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, proto_dhcpv4_udp_t, max_attributes), .dflt = STRINGIFY(DHCPV4_MAX_ATTRIBUTES) } ,
+ { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_dhcpv4_udp_t, max_packet_size), .dflt = "4096" } ,
+ { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, 0, proto_dhcpv4_udp_t, max_attributes), .dflt = STRINGIFY(DHCPV4_MAX_ATTRIBUTES) } ,
CONF_PARSER_TERMINATOR
};
static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
static const conf_parser_t priority_config[] = {
- { FR_CONF_OFFSET("Solicit", FR_TYPE_VOID, proto_dhcpv6_t, priorities[FR_DHCPV6_SOLICIT]),
+ { FR_CONF_OFFSET("Solicit", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_SOLICIT]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Request", FR_TYPE_VOID, proto_dhcpv6_t, priorities[FR_DHCPV6_REQUEST]),
+ { FR_CONF_OFFSET("Request", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_REQUEST]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Renew", FR_TYPE_VOID, proto_dhcpv6_t, priorities[FR_DHCPV6_RENEW]),
+ { FR_CONF_OFFSET("Renew", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_RENEW]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Rebind", FR_TYPE_VOID, proto_dhcpv6_t, priorities[FR_DHCPV6_REBIND]),
+ { FR_CONF_OFFSET("Rebind", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_REBIND]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Release", FR_TYPE_VOID, proto_dhcpv6_t, priorities[FR_DHCPV6_RELEASE]),
+ { FR_CONF_OFFSET("Release", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_RELEASE]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Decline", FR_TYPE_VOID, proto_dhcpv6_t, priorities[FR_DHCPV6_DECLINE]),
+ { FR_CONF_OFFSET("Decline", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_DECLINE]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Information-Request", FR_TYPE_VOID, proto_dhcpv6_t, priorities[FR_DHCPV6_INFORMATION_REQUEST]),
+ { FR_CONF_OFFSET("Information-Request", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_INFORMATION_REQUEST]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Relay-Forward", FR_TYPE_VOID, proto_dhcpv6_t, priorities[FR_DHCPV6_RELAY_FORWARD]),
+ { FR_CONF_OFFSET("Relay-Forward", FR_TYPE_VOID, 0, proto_dhcpv6_t, priorities[FR_DHCPV6_RELAY_FORWARD]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
CONF_PARSER_TERMINATOR
};
static conf_parser_t const limit_config[] = {
- { FR_CONF_OFFSET("cleanup_delay", FR_TYPE_TIME_DELTA, 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" } ,
+ { FR_CONF_OFFSET("cleanup_delay", FR_TYPE_TIME_DELTA, 0, proto_dhcpv6_t, io.cleanup_delay), .dflt = "5.0" } ,
+ { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, 0, proto_dhcpv6_t, io.idle_timeout), .dflt = "30.0" } ,
+ { FR_CONF_OFFSET("nak_lifetime", FR_TYPE_TIME_DELTA, 0, proto_dhcpv6_t, io.nak_lifetime), .dflt = "30.0" } ,
- { FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, proto_dhcpv6_t, io.max_connections), .dflt = "1024" } ,
- { FR_CONF_OFFSET("max_clients", FR_TYPE_UINT32, proto_dhcpv6_t, io.max_clients), .dflt = "256" } ,
- { FR_CONF_OFFSET("max_pending_packets", FR_TYPE_UINT32, proto_dhcpv6_t, io.max_pending_packets), .dflt = "256" } ,
+ { FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, 0, proto_dhcpv6_t, io.max_connections), .dflt = "1024" } ,
+ { FR_CONF_OFFSET("max_clients", FR_TYPE_UINT32, 0, proto_dhcpv6_t, io.max_clients), .dflt = "256" } ,
+ { FR_CONF_OFFSET("max_pending_packets", FR_TYPE_UINT32, 0, proto_dhcpv6_t, io.max_pending_packets), .dflt = "256" } ,
/*
* For performance tweaking. NOT for normal humans.
*/
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, proto_dhcpv6_t, max_packet_size) } ,
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, proto_dhcpv6_t, num_messages) } ,
- { FR_CONF_POINTER("priority", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) priority_config },
+ { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_dhcpv6_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_dhcpv6_t, num_messages) } ,
+ { FR_CONF_POINTER("priority", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) priority_config },
CONF_PARSER_TERMINATOR
};
*
*/
static conf_parser_t const proto_dhcpv6_config[] = {
- { FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_MULTI | FR_TYPE_NOT_EMPTY, proto_dhcpv6_t,
+ { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI, proto_dhcpv6_t,
allowed_types), .func = type_parse },
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_dhcpv6_t, io.submodule),
+ { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_dhcpv6_t, io.submodule),
.func = transport_parse },
- { FR_CONF_POINTER("limit", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) limit_config },
+ { FR_CONF_POINTER("limit", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) limit_config },
CONF_PARSER_TERMINATOR
};
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) },
+ { FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_dhcpv6_udp_t, allow) },
+ { FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_dhcpv6_udp_t, deny) },
CONF_PARSER_TERMINATOR
};
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) },
+ { FR_CONF_OFFSET("ipaddr", FR_TYPE_IPV6_ADDR, 0, proto_dhcpv6_udp_t, ipaddr) },
+ { FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, 0, proto_dhcpv6_udp_t, ipaddr) },
- { FR_CONF_OFFSET("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, proto_dhcpv6_udp_t, src_ipaddr) },
+ { FR_CONF_OFFSET("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_dhcpv6_udp_t, src_ipaddr) },
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, proto_dhcpv6_udp_t, interface) },
- { FR_CONF_OFFSET("port_name", FR_TYPE_STRING, proto_dhcpv6_udp_t, port_name) },
+ { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, proto_dhcpv6_udp_t, interface) },
+ { FR_CONF_OFFSET("port_name", FR_TYPE_STRING, 0, proto_dhcpv6_udp_t, port_name) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, proto_dhcpv6_udp_t, port), .dflt = "547" },
- { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, proto_dhcpv6_udp_t, recv_buff) },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, proto_dhcpv6_udp_t, port), .dflt = "547" },
+ { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, proto_dhcpv6_udp_t, recv_buff) },
- { FR_CONF_OFFSET("hop_limit", FR_TYPE_UINT32, proto_dhcpv6_udp_t, hop_limit) },
+ { FR_CONF_OFFSET("hop_limit", FR_TYPE_UINT32, 0, proto_dhcpv6_udp_t, hop_limit) },
- { FR_CONF_OFFSET("dynamic_clients", FR_TYPE_BOOL, proto_dhcpv6_udp_t, dynamic_clients) } ,
- { FR_CONF_POINTER("networks", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) networks_config },
+ { FR_CONF_OFFSET("dynamic_clients", FR_TYPE_BOOL, 0, proto_dhcpv6_udp_t, dynamic_clients) } ,
+ { FR_CONF_POINTER("networks", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) networks_config },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, proto_dhcpv6_udp_t, max_packet_size), .dflt = "8192" } ,
- { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, proto_dhcpv6_udp_t, max_attributes), .dflt = STRINGIFY(DHCPV6_MAX_ATTRIBUTES) } ,
+ { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_dhcpv6_udp_t, max_packet_size), .dflt = "8192" } ,
+ { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, 0, proto_dhcpv6_udp_t, max_attributes), .dflt = STRINGIFY(DHCPV6_MAX_ATTRIBUTES) } ,
CONF_PARSER_TERMINATOR
};
static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
static const conf_parser_t priority_config[] = {
- { FR_CONF_OFFSET("query", FR_TYPE_VOID, proto_dns_t, priorities[FR_DNS_QUERY]),
+ { FR_CONF_OFFSET("query", FR_TYPE_VOID, 0, proto_dns_t, priorities[FR_DNS_QUERY]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
CONF_PARSER_TERMINATOR
};
static conf_parser_t const limit_config[] = {
- { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, proto_dns_t, io.idle_timeout), .dflt = "30.0" } ,
+ { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, 0, 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" } ,
+ { FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, 0, proto_dns_t, io.max_connections), .dflt = "1024" } ,
/*
* For performance tweaking. NOT for normal humans.
*/
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, proto_dns_t, max_packet_size) } ,
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, proto_dns_t, num_messages) } ,
- { FR_CONF_POINTER("priority", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) priority_config },
+ { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_dns_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_dns_t, num_messages) } ,
+ { FR_CONF_POINTER("priority", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) priority_config },
CONF_PARSER_TERMINATOR
};
*
*/
static conf_parser_t const proto_dns_config[] = {
- { FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_MULTI | FR_TYPE_NOT_EMPTY, proto_dns_t,
+ { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI, proto_dns_t,
allowed_types), .func = type_parse },
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_dns_t, io.submodule),
+ { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_dns_t, io.submodule),
.func = transport_parse },
- { FR_CONF_POINTER("limit", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) limit_config },
+ { FR_CONF_POINTER("limit", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) limit_config },
CONF_PARSER_TERMINATOR
};
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) },
+ { FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_dns_udp_t, allow) },
+ { FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_dns_udp_t, deny) },
CONF_PARSER_TERMINATOR
};
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) },
+ { FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_dns_udp_t, ipaddr) },
+ { FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, 0, proto_dns_udp_t, ipaddr) },
+ { FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, 0, proto_dns_udp_t, ipaddr) },
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, proto_dns_udp_t, interface) },
+ { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, proto_dns_udp_t, interface) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, proto_dns_udp_t, port), .dflt = "547" },
- { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, proto_dns_udp_t, recv_buff) },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, proto_dns_udp_t, port), .dflt = "547" },
+ { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, proto_dns_udp_t, recv_buff) },
- { FR_CONF_POINTER("networks", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) networks_config },
+ { FR_CONF_POINTER("networks", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) networks_config },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, proto_dns_udp_t, max_packet_size), .dflt = "576" } ,
- { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, proto_dns_udp_t, max_attributes), .dflt = STRINGIFY(DNS_MAX_ATTRIBUTES) } ,
+ { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_dns_udp_t, max_packet_size), .dflt = "576" } ,
+ { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, 0, proto_dns_udp_t, max_attributes), .dflt = STRINGIFY(DNS_MAX_ATTRIBUTES) } ,
CONF_PARSER_TERMINATOR
};
static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
static conf_parser_t const ldap_sync_search_config[] = {
- { FR_CONF_OFFSET("base_dn", FR_TYPE_STRING, sync_config_t, base_dn), .dflt = "", .quote = T_SINGLE_QUOTED_STRING },
+ { FR_CONF_OFFSET("base_dn", FR_TYPE_STRING, 0, sync_config_t, base_dn), .dflt = "", .quote = T_SINGLE_QUOTED_STRING },
- { FR_CONF_OFFSET("filter", FR_TYPE_STRING, sync_config_t, filter) },
+ { FR_CONF_OFFSET("filter", FR_TYPE_STRING, 0, sync_config_t, filter) },
- { FR_CONF_OFFSET("scope", FR_TYPE_STRING, sync_config_t, scope_str), .dflt = "sub" },
+ { FR_CONF_OFFSET("scope", FR_TYPE_STRING, 0, sync_config_t, scope_str), .dflt = "sub" },
/* For persistent search directories, setting this to "no" will load the whole directory. */
- { FR_CONF_OFFSET("changes_only", FR_TYPE_BOOL, sync_config_t, changes_only), .dflt = "yes" },
+ { FR_CONF_OFFSET("changes_only", FR_TYPE_BOOL, 0, sync_config_t, changes_only), .dflt = "yes" },
CONF_PARSER_TERMINATOR
};
static conf_parser_t const proto_ldap_sync_config[] = {
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_ldap_sync_t, io_submodule),
+ { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_ldap_sync_t, io_submodule),
.func = transport_parse },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, proto_ldap_sync_t, max_packet_size) },
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, proto_ldap_sync_t, num_messages) },
- { FR_CONF_OFFSET("cookie_interval", FR_TYPE_TIME_DELTA, proto_ldap_sync_t, cookie_interval), .dflt = "10" },
- { FR_CONF_OFFSET("cookie_changes", FR_TYPE_UINT32, proto_ldap_sync_t, cookie_changes), .dflt = "100" },
- { FR_CONF_OFFSET("retry_interval", FR_TYPE_TIME_DELTA, proto_ldap_sync_t, retry_interval), .dflt = "1" },
+ { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_ldap_sync_t, max_packet_size) },
+ { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_ldap_sync_t, num_messages) },
+ { FR_CONF_OFFSET("cookie_interval", FR_TYPE_TIME_DELTA, 0, proto_ldap_sync_t, cookie_interval), .dflt = "10" },
+ { FR_CONF_OFFSET("cookie_changes", FR_TYPE_UINT32, 0, proto_ldap_sync_t, cookie_changes), .dflt = "100" },
+ { FR_CONF_OFFSET("retry_interval", FR_TYPE_TIME_DELTA, 0, proto_ldap_sync_t, retry_interval), .dflt = "1" },
/*
* Areas of the DIT to listen on
*/
- { FR_CONF_SUBSECTION_ALLOC("sync", FR_TYPE_SUBSECTION | FR_TYPE_MULTI | FR_TYPE_REQUIRED, proto_ldap_sync_t, sync_config, ldap_sync_search_config) },
+ { FR_CONF_SUBSECTION_ALLOC("sync", 0, CONF_FLAG_SUBSECTION | CONF_FLAG_MULTI | CONF_FLAG_REQUIRED, proto_ldap_sync_t, sync_config, ldap_sync_search_config) },
CONF_PARSER_TERMINATOR
};
/*
* LDAP server definition
*/
- { FR_CONF_OFFSET("server", FR_TYPE_STRING | FR_TYPE_REQUIRED, proto_ldap_sync_ldap_t, server) },
+ { FR_CONF_OFFSET("server", FR_TYPE_STRING, CONF_FLAG_REQUIRED, proto_ldap_sync_ldap_t, server) },
/*
* Common LDAP conf parsers
/*
* Network tunable parameters
*/
- { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, proto_ldap_sync_ldap_t, recv_buff) },
- { FR_CONF_OFFSET("max_outstanding", FR_TYPE_UINT32, proto_ldap_sync_ldap_t, max_outstanding), .dflt = "65536" },
+ { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, proto_ldap_sync_ldap_t, recv_buff) },
+ { FR_CONF_OFFSET("max_outstanding", FR_TYPE_UINT32, 0, proto_ldap_sync_ldap_t, max_outstanding), .dflt = "65536" },
CONF_PARSER_TERMINATOR
};
*
*/
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,
+ { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_REQUIRED, proto_load_t,
type), .func = type_parse },
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_load_t, io.submodule),
+ { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_load_t, io.submodule),
.func = transport_parse, .dflt = "step" },
/*
* Add this as a synonym so normal humans can understand it.
*/
- { FR_CONF_OFFSET("max_entry_size", FR_TYPE_UINT32, proto_load_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("max_entry_size", FR_TYPE_UINT32, 0, proto_load_t, max_packet_size) } ,
/*
* For performance tweaking. NOT for normal humans.
*/
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, proto_load_t, max_packet_size) } ,
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, proto_load_t, num_messages) } ,
+ { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_load_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_load_t, num_messages) } ,
- { FR_CONF_OFFSET("priority", FR_TYPE_UINT32, proto_load_t, priority) },
+ { FR_CONF_OFFSET("priority", FR_TYPE_UINT32, 0, proto_load_t, priority) },
CONF_PARSER_TERMINATOR
};
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) },
-
- { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, proto_load_step_t, max_attributes), .dflt = STRINGIFY(RADIUS_MAX_ATTRIBUTES) } ,
-
- { FR_CONF_OFFSET("start_pps", FR_TYPE_UINT32, proto_load_step_t, load.start_pps) },
- { FR_CONF_OFFSET("max_pps", FR_TYPE_UINT32, proto_load_step_t, load.max_pps) },
- { FR_CONF_OFFSET("duration", FR_TYPE_TIME_DELTA, proto_load_step_t, load.duration) },
- { FR_CONF_OFFSET("step", FR_TYPE_UINT32, proto_load_step_t, load.step) },
- { FR_CONF_OFFSET("max_backlog", FR_TYPE_UINT32, proto_load_step_t, load.milliseconds) },
- { FR_CONF_OFFSET("parallel", FR_TYPE_UINT32, proto_load_step_t, load.parallel) },
- { FR_CONF_OFFSET("repeat", FR_TYPE_BOOL, proto_load_step_t, repeat) },
+ { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, proto_load_step_t, filename) },
+ { FR_CONF_OFFSET("csv", FR_TYPE_STRING, 0, proto_load_step_t, csv) },
+
+ { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, 0, proto_load_step_t, max_attributes), .dflt = STRINGIFY(RADIUS_MAX_ATTRIBUTES) } ,
+
+ { FR_CONF_OFFSET("start_pps", FR_TYPE_UINT32, 0, proto_load_step_t, load.start_pps) },
+ { FR_CONF_OFFSET("max_pps", FR_TYPE_UINT32, 0, proto_load_step_t, load.max_pps) },
+ { FR_CONF_OFFSET("duration", FR_TYPE_TIME_DELTA, 0, proto_load_step_t, load.duration) },
+ { FR_CONF_OFFSET("step", FR_TYPE_UINT32, 0, proto_load_step_t, load.step) },
+ { FR_CONF_OFFSET("max_backlog", FR_TYPE_UINT32, 0, proto_load_step_t, load.milliseconds) },
+ { FR_CONF_OFFSET("parallel", FR_TYPE_UINT32, 0, proto_load_step_t, load.parallel) },
+ { FR_CONF_OFFSET("repeat", FR_TYPE_BOOL, 0, proto_load_step_t, repeat) },
CONF_PARSER_TERMINATOR
};
static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
static conf_parser_t const limit_config[] = {
- { FR_CONF_OFFSET("cleanup_delay", FR_TYPE_TIME_DELTA, 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" } ,
+ { FR_CONF_OFFSET("cleanup_delay", FR_TYPE_TIME_DELTA, 0, proto_radius_t, io.cleanup_delay), .dflt = "5.0" } ,
+ { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, 0, proto_radius_t, io.idle_timeout), .dflt = "30.0" } ,
+ { FR_CONF_OFFSET("nak_lifetime", FR_TYPE_TIME_DELTA, 0, proto_radius_t, io.nak_lifetime), .dflt = "30.0" } ,
- { FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, proto_radius_t, io.max_connections), .dflt = "1024" } ,
- { FR_CONF_OFFSET("max_clients", FR_TYPE_UINT32, proto_radius_t, io.max_clients), .dflt = "256" } ,
- { FR_CONF_OFFSET("max_pending_packets", FR_TYPE_UINT32, proto_radius_t, io.max_pending_packets), .dflt = "256" } ,
+ { FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, 0, proto_radius_t, io.max_connections), .dflt = "1024" } ,
+ { FR_CONF_OFFSET("max_clients", FR_TYPE_UINT32, 0, proto_radius_t, io.max_clients), .dflt = "256" } ,
+ { FR_CONF_OFFSET("max_pending_packets", FR_TYPE_UINT32, 0, proto_radius_t, io.max_pending_packets), .dflt = "256" } ,
/*
* For performance tweaking. NOT for normal humans.
*/
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, proto_radius_t, max_packet_size) } ,
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, proto_radius_t, num_messages) } ,
+ { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_radius_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_radius_t, num_messages) } ,
CONF_PARSER_TERMINATOR
};
static const conf_parser_t priority_config[] = {
- { FR_CONF_OFFSET("Access-Request", FR_TYPE_VOID, proto_radius_t, priorities[FR_RADIUS_CODE_ACCESS_REQUEST]),
+ { FR_CONF_OFFSET("Access-Request", FR_TYPE_VOID, 0, proto_radius_t, priorities[FR_RADIUS_CODE_ACCESS_REQUEST]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "high" },
- { FR_CONF_OFFSET("Accounting-Request", FR_TYPE_VOID, proto_radius_t, priorities[FR_RADIUS_CODE_ACCOUNTING_REQUEST]),
+ { FR_CONF_OFFSET("Accounting-Request", FR_TYPE_VOID, 0, proto_radius_t, priorities[FR_RADIUS_CODE_ACCOUNTING_REQUEST]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "low" },
- { FR_CONF_OFFSET("CoA-Request", FR_TYPE_VOID, proto_radius_t, priorities[FR_RADIUS_CODE_COA_REQUEST]),
+ { FR_CONF_OFFSET("CoA-Request", FR_TYPE_VOID, 0, proto_radius_t, priorities[FR_RADIUS_CODE_COA_REQUEST]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Disconnect-Request", FR_TYPE_VOID, proto_radius_t, priorities[FR_RADIUS_CODE_DISCONNECT_REQUEST]),
+ { FR_CONF_OFFSET("Disconnect-Request", FR_TYPE_VOID, 0, proto_radius_t, priorities[FR_RADIUS_CODE_DISCONNECT_REQUEST]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "low" },
- { FR_CONF_OFFSET("Status-Server", FR_TYPE_VOID, proto_radius_t, priorities[FR_RADIUS_CODE_STATUS_SERVER]),
+ { FR_CONF_OFFSET("Status-Server", FR_TYPE_VOID, 0, proto_radius_t, priorities[FR_RADIUS_CODE_STATUS_SERVER]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "now" },
CONF_PARSER_TERMINATOR
*
*/
static conf_parser_t const proto_radius_config[] = {
- { FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_MULTI | FR_TYPE_NOT_EMPTY, proto_radius_t,
+ { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI, proto_radius_t,
allowed_types), .func = type_parse },
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_radius_t, io.submodule),
+ { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_radius_t, io.submodule),
.func = transport_parse },
/*
* Check whether or not the *trailing* bits of a
* Tunnel-Password are zero, as they should be.
*/
- { FR_CONF_OFFSET("tunnel_password_zeros", FR_TYPE_BOOL, proto_radius_t, tunnel_password_zeros) } ,
+ { FR_CONF_OFFSET("tunnel_password_zeros", FR_TYPE_BOOL, 0, proto_radius_t, tunnel_password_zeros) } ,
- { FR_CONF_POINTER("limit", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) limit_config },
- { FR_CONF_POINTER("priority", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) priority_config },
+ { FR_CONF_POINTER("limit", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) limit_config },
+ { FR_CONF_POINTER("priority", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) priority_config },
CONF_PARSER_TERMINATOR
};
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) },
+ { FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_radius_tcp_t, allow) },
+ { FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_radius_tcp_t, deny) },
CONF_PARSER_TERMINATOR
};
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) },
+ { FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_radius_tcp_t, ipaddr) },
+ { FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, 0, proto_radius_tcp_t, ipaddr) },
+ { FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, 0, proto_radius_tcp_t, ipaddr) },
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, proto_radius_tcp_t, interface) },
- { FR_CONF_OFFSET("port_name", FR_TYPE_STRING, proto_radius_tcp_t, port_name) },
+ { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, proto_radius_tcp_t, interface) },
+ { FR_CONF_OFFSET("port_name", FR_TYPE_STRING, 0, proto_radius_tcp_t, port_name) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, proto_radius_tcp_t, port) },
- { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, proto_radius_tcp_t, recv_buff) },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, proto_radius_tcp_t, port) },
+ { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, proto_radius_tcp_t, recv_buff) },
- { FR_CONF_OFFSET("dynamic_clients", FR_TYPE_BOOL, proto_radius_tcp_t, dynamic_clients) } ,
- { FR_CONF_OFFSET("accept_conflicting_packets", FR_TYPE_BOOL, proto_radius_tcp_t, dedup_authenticator) } ,
- { FR_CONF_POINTER("networks", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) networks_config },
+ { FR_CONF_OFFSET("dynamic_clients", FR_TYPE_BOOL, 0, proto_radius_tcp_t, dynamic_clients) } ,
+ { FR_CONF_OFFSET("accept_conflicting_packets", FR_TYPE_BOOL, 0, proto_radius_tcp_t, dedup_authenticator) } ,
+ { FR_CONF_POINTER("networks", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) networks_config },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, proto_radius_tcp_t, max_packet_size), .dflt = "4096" } ,
- { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, proto_radius_tcp_t, max_attributes), .dflt = STRINGIFY(RADIUS_MAX_ATTRIBUTES) } ,
+ { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_radius_tcp_t, max_packet_size), .dflt = "4096" } ,
+ { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, 0, proto_radius_tcp_t, max_attributes), .dflt = STRINGIFY(RADIUS_MAX_ATTRIBUTES) } ,
CONF_PARSER_TERMINATOR
};
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) },
+ { FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_radius_udp_t, allow) },
+ { FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_radius_udp_t, deny) },
CONF_PARSER_TERMINATOR
};
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) },
+ { FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_radius_udp_t, ipaddr) },
+ { FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, 0, proto_radius_udp_t, ipaddr) },
+ { FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, 0, proto_radius_udp_t, ipaddr) },
- { FR_CONF_OFFSET_IS_SET("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, proto_radius_udp_t, src_ipaddr) },
+ { FR_CONF_OFFSET_IS_SET("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_radius_udp_t, src_ipaddr) },
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, proto_radius_udp_t, interface) },
- { FR_CONF_OFFSET("port_name", FR_TYPE_STRING, proto_radius_udp_t, port_name) },
+ { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, proto_radius_udp_t, interface) },
+ { FR_CONF_OFFSET("port_name", FR_TYPE_STRING, 0, proto_radius_udp_t, port_name) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, proto_radius_udp_t, port) },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, proto_radius_udp_t, port) },
- { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, proto_radius_udp_t, recv_buff) },
- { FR_CONF_OFFSET_IS_SET("send_buff", FR_TYPE_UINT32, proto_radius_udp_t, send_buff) },
+ { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, proto_radius_udp_t, recv_buff) },
+ { FR_CONF_OFFSET_IS_SET("send_buff", FR_TYPE_UINT32, 0, proto_radius_udp_t, send_buff) },
- { FR_CONF_OFFSET("accept_conflicting_packets", FR_TYPE_BOOL, proto_radius_udp_t, dedup_authenticator) } ,
- { FR_CONF_OFFSET("dynamic_clients", FR_TYPE_BOOL, proto_radius_udp_t, dynamic_clients) } ,
- { FR_CONF_POINTER("networks", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) networks_config },
+ { FR_CONF_OFFSET("accept_conflicting_packets", FR_TYPE_BOOL, 0, proto_radius_udp_t, dedup_authenticator) } ,
+ { FR_CONF_OFFSET("dynamic_clients", FR_TYPE_BOOL, 0, proto_radius_udp_t, dynamic_clients) } ,
+ { FR_CONF_POINTER("networks", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) networks_config },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, proto_radius_udp_t, max_packet_size), .dflt = "4096" } ,
- { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, proto_radius_udp_t, max_attributes), .dflt = STRINGIFY(RADIUS_MAX_ATTRIBUTES) } ,
+ { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_radius_udp_t, max_packet_size), .dflt = "4096" } ,
+ { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, 0, proto_radius_udp_t, max_attributes), .dflt = STRINGIFY(RADIUS_MAX_ATTRIBUTES) } ,
CONF_PARSER_TERMINATOR
};
static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
static conf_parser_t const limit_config[] = {
- { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, proto_tacacs_t, io.idle_timeout), .dflt = "30.0" } ,
+ { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, 0, 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" } ,
+ { FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, 0, proto_tacacs_t, io.max_connections), .dflt = "1024" } ,
/*
* For performance tweaking. NOT for normal humans.
*/
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, proto_tacacs_t, max_packet_size) } ,
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, proto_tacacs_t, num_messages) } ,
+ { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_tacacs_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_tacacs_t, num_messages) } ,
CONF_PARSER_TERMINATOR
};
static const conf_parser_t priority_config[] = {
- { FR_CONF_OFFSET("Authentication-Start", FR_TYPE_VOID, proto_tacacs_t, priorities[FR_TAC_PLUS_AUTHEN]),
+ { FR_CONF_OFFSET("Authentication-Start", FR_TYPE_VOID, 0, proto_tacacs_t, priorities[FR_TAC_PLUS_AUTHEN]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "high" },
- { FR_CONF_OFFSET("Authentication-Continue", FR_TYPE_VOID, proto_tacacs_t, priorities[FR_TAC_PLUS_AUTHEN]),
+ { FR_CONF_OFFSET("Authentication-Continue", FR_TYPE_VOID, 0, proto_tacacs_t, priorities[FR_TAC_PLUS_AUTHEN]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "high" },
- { FR_CONF_OFFSET("Authorization-Request", FR_TYPE_VOID, proto_tacacs_t, priorities[FR_TAC_PLUS_AUTHOR]),
+ { FR_CONF_OFFSET("Authorization-Request", FR_TYPE_VOID, 0, proto_tacacs_t, priorities[FR_TAC_PLUS_AUTHOR]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "normal" },
- { FR_CONF_OFFSET("Accounting-Request", FR_TYPE_VOID, proto_tacacs_t, priorities[FR_TAC_PLUS_ACCT]),
+ { FR_CONF_OFFSET("Accounting-Request", FR_TYPE_VOID, 0, proto_tacacs_t, priorities[FR_TAC_PLUS_ACCT]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "low" },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t proto_tacacs_config[] = {
- { FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_MULTI | FR_TYPE_NOT_EMPTY, proto_tacacs_t, allowed_types),
+ { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI, proto_tacacs_t, allowed_types),
.func = type_parse },
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_tacacs_t, io.submodule),
+ { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_tacacs_t, io.submodule),
.func = transport_parse },
- { FR_CONF_POINTER("limit", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) limit_config },
- { FR_CONF_POINTER("priority", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) priority_config },
+ { FR_CONF_POINTER("limit", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) limit_config },
+ { FR_CONF_POINTER("priority", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) priority_config },
CONF_PARSER_TERMINATOR
};
} proto_tacacs_tcp_t;
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) },
+ { FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_tacacs_tcp_t, allow) },
+ { FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_tacacs_tcp_t, deny) },
CONF_PARSER_TERMINATOR
};
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) },
+ { FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_tacacs_tcp_t, ipaddr) },
+ { FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, 0, proto_tacacs_tcp_t, ipaddr) },
+ { FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, 0, proto_tacacs_tcp_t, ipaddr) },
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, proto_tacacs_tcp_t, interface) },
- { FR_CONF_OFFSET("port_name", FR_TYPE_STRING, proto_tacacs_tcp_t, port_name) },
+ { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, proto_tacacs_tcp_t, interface) },
+ { FR_CONF_OFFSET("port_name", FR_TYPE_STRING, 0, proto_tacacs_tcp_t, port_name) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, proto_tacacs_tcp_t, port), .dflt = "49" },
- { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, proto_tacacs_tcp_t, recv_buff) },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, proto_tacacs_tcp_t, port), .dflt = "49" },
+ { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, proto_tacacs_tcp_t, recv_buff) },
- { FR_CONF_OFFSET("dynamic_clients", FR_TYPE_BOOL, proto_tacacs_tcp_t, dynamic_clients) } ,
- { FR_CONF_POINTER("networks", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) networks_config },
+ { FR_CONF_OFFSET("dynamic_clients", FR_TYPE_BOOL, 0, proto_tacacs_tcp_t, dynamic_clients) } ,
+ { FR_CONF_POINTER("networks", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) networks_config },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, proto_tacacs_tcp_t, max_packet_size), .dflt = "4096" } ,
- { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, proto_tacacs_tcp_t, max_attributes), .dflt = STRINGIFY(TACACS_MAX_ATTRIBUTES) } ,
+ { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_tacacs_tcp_t, max_packet_size), .dflt = "4096" } ,
+ { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, 0, proto_tacacs_tcp_t, max_attributes), .dflt = STRINGIFY(TACACS_MAX_ATTRIBUTES) } ,
CONF_PARSER_TERMINATOR
};
CONF_ITEM *ci, conf_parser_t const *rule);
static const conf_parser_t priority_config[] = {
- { FR_CONF_OFFSET("Join-Request", FR_TYPE_VOID, proto_vmps_t, priorities[FR_PACKET_TYPE_VALUE_JOIN_REQUEST]),
+ { FR_CONF_OFFSET("Join-Request", FR_TYPE_VOID, 0, proto_vmps_t, priorities[FR_PACKET_TYPE_VALUE_JOIN_REQUEST]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "low" },
- { FR_CONF_OFFSET("Reconfirm-Request", FR_TYPE_VOID, proto_vmps_t, priorities[FR_PACKET_TYPE_VALUE_RECONFIRM_REQUEST]),
+ { FR_CONF_OFFSET("Reconfirm-Request", FR_TYPE_VOID, 0, proto_vmps_t, priorities[FR_PACKET_TYPE_VALUE_RECONFIRM_REQUEST]),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = channel_packet_priority, .len = &channel_packet_priority_len }, .dflt = "low" },
CONF_PARSER_TERMINATOR
};
static conf_parser_t const limit_config[] = {
- { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, 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" } ,
+ { FR_CONF_OFFSET("idle_timeout", FR_TYPE_TIME_DELTA, 0, proto_vmps_t, io.idle_timeout), .dflt = "30.0" } ,
+ { FR_CONF_OFFSET("nak_lifetime", FR_TYPE_TIME_DELTA, 0, proto_vmps_t, io.nak_lifetime), .dflt = "30.0" } ,
- { FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, proto_vmps_t, io.max_connections), .dflt = "1024" } ,
- { FR_CONF_OFFSET("max_clients", FR_TYPE_UINT32, proto_vmps_t, io.max_clients), .dflt = "256" } ,
- { FR_CONF_OFFSET("max_pending_packets", FR_TYPE_UINT32, proto_vmps_t, io.max_pending_packets), .dflt = "256" } ,
+ { FR_CONF_OFFSET("max_connections", FR_TYPE_UINT32, 0, proto_vmps_t, io.max_connections), .dflt = "1024" } ,
+ { FR_CONF_OFFSET("max_clients", FR_TYPE_UINT32, 0, proto_vmps_t, io.max_clients), .dflt = "256" } ,
+ { FR_CONF_OFFSET("max_pending_packets", FR_TYPE_UINT32, 0, proto_vmps_t, io.max_pending_packets), .dflt = "256" } ,
/*
* For performance tweaking. NOT for normal humans.
*/
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, proto_vmps_t, max_packet_size) } ,
- { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, proto_vmps_t, num_messages) } ,
+ { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_vmps_t, max_packet_size) } ,
+ { FR_CONF_OFFSET("num_messages", FR_TYPE_UINT32, 0, proto_vmps_t, num_messages) } ,
CONF_PARSER_TERMINATOR
};
*
*/
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,
+ { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI, proto_vmps_t,
allowed_types), .func = type_parse },
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, proto_vmps_t, io.submodule),
+ { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, proto_vmps_t, io.submodule),
.func = transport_parse },
- { FR_CONF_POINTER("limit", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) limit_config },
- { FR_CONF_POINTER("priority", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) priority_config },
+ { FR_CONF_POINTER("limit", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) limit_config },
+ { FR_CONF_POINTER("priority", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) priority_config },
CONF_PARSER_TERMINATOR
};
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) },
+ { FR_CONF_OFFSET("allow", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_vmps_udp_t, allow) },
+ { FR_CONF_OFFSET("deny", FR_TYPE_COMBO_IP_PREFIX , CONF_FLAG_MULTI, proto_vmps_udp_t, deny) },
CONF_PARSER_TERMINATOR
};
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) },
+ { FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, proto_vmps_udp_t, ipaddr) },
+ { FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, 0, proto_vmps_udp_t, ipaddr) },
+ { FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, 0, proto_vmps_udp_t, ipaddr) },
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, proto_vmps_udp_t, interface) },
- { FR_CONF_OFFSET("port_name", FR_TYPE_STRING, proto_vmps_udp_t, port_name) },
+ { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, proto_vmps_udp_t, interface) },
+ { FR_CONF_OFFSET("port_name", FR_TYPE_STRING, 0, proto_vmps_udp_t, port_name) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, proto_vmps_udp_t, port) },
- { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, proto_vmps_udp_t, recv_buff) },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, proto_vmps_udp_t, port) },
+ { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, proto_vmps_udp_t, recv_buff) },
- { FR_CONF_OFFSET("dynamic_clients", FR_TYPE_BOOL, proto_vmps_udp_t, dynamic_clients) } ,
- { FR_CONF_POINTER("networks", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) networks_config },
+ { FR_CONF_OFFSET("dynamic_clients", FR_TYPE_BOOL, 0, proto_vmps_udp_t, dynamic_clients) } ,
+ { FR_CONF_POINTER("networks", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) networks_config },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, proto_vmps_udp_t, max_packet_size), .dflt = "1024" } ,
+ { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, proto_vmps_udp_t, max_packet_size), .dflt = "1024" } ,
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("rcode", FR_TYPE_STRING, 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" },
+ { FR_CONF_OFFSET("rcode", FR_TYPE_STRING, 0, rlm_always_t, rcode_str), .dflt = "fail" },
+ { FR_CONF_OFFSET("simulcount", FR_TYPE_UINT32, 0, rlm_always_t, simulcount), .dflt = "0" },
+ { FR_CONF_OFFSET("mpp", FR_TYPE_BOOL, 0, rlm_always_t, mpp), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
} rlm_attr_filter_t;
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_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED, rlm_attr_filter_t, filename) },
+ { FR_CONF_OFFSET("key", 0, CONF_FLAG_TMPL, rlm_attr_filter_t, key), .dflt = "&Realm", .quote = T_BARE_WORD },
+ { FR_CONF_OFFSET("relaxed", FR_TYPE_BOOL, 0, rlm_attr_filter_t, relaxed), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
} rlm_cache_memcached_t;
static const conf_parser_t driver_config[] = {
- { FR_CONF_OFFSET("options", FR_TYPE_STRING, rlm_cache_memcached_t, options), .dflt = "--SERVER=localhost" },
+ { FR_CONF_OFFSET("options", FR_TYPE_STRING, 0, rlm_cache_memcached_t, options), .dflt = "--SERVER=localhost" },
CONF_PARSER_TERMINATOR
};
extern module_rlm_t rlm_cache;
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("driver", FR_TYPE_VOID, rlm_cache_t, driver_submodule), .dflt = "rbtree",
+ { FR_CONF_OFFSET("driver", FR_TYPE_VOID, 0, rlm_cache_t, driver_submodule), .dflt = "rbtree",
.func = module_rlm_submodule_parse },
- { FR_CONF_OFFSET("ttl", FR_TYPE_TIME_DELTA, rlm_cache_config_t, ttl), .dflt = "500s" },
- { FR_CONF_OFFSET("max_entries", FR_TYPE_UINT32, rlm_cache_config_t, max_entries), .dflt = "0" },
+ { FR_CONF_OFFSET("ttl", FR_TYPE_TIME_DELTA, 0, rlm_cache_config_t, ttl), .dflt = "500s" },
+ { FR_CONF_OFFSET("max_entries", FR_TYPE_UINT32, 0, rlm_cache_config_t, max_entries), .dflt = "0" },
/* Should be a type which matches time_t, @fixme before 2038 */
- { FR_CONF_OFFSET("epoch", FR_TYPE_INT32, rlm_cache_config_t, epoch), .dflt = "0" },
- { FR_CONF_OFFSET("add_stats", FR_TYPE_BOOL, rlm_cache_config_t, stats), .dflt = "no" },
+ { FR_CONF_OFFSET("epoch", FR_TYPE_INT32, 0, rlm_cache_config_t, epoch), .dflt = "0" },
+ { FR_CONF_OFFSET("add_stats", FR_TYPE_BOOL, 0, rlm_cache_config_t, stats), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
static const call_env_method_t cache_method_env = {
FR_CALL_ENV_METHOD_OUT(cache_call_env_t),
.env = (call_env_parser_t[]) {
- { FR_CALL_ENV_OFFSET("key", FR_TYPE_STRING, cache_call_env_t, key,
+ { FR_CALL_ENV_OFFSET("key", FR_TYPE_STRING, 0, cache_call_env_t, key,
NULL, T_INVALID, true, false, true) },
CALL_ENV_TERMINATOR
}
} rlm_chap_t;
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("min_challenge_len", FR_TYPE_SIZE, rlm_chap_t, min_challenge_len), .dflt = "16" },
+ { FR_CONF_OFFSET("min_challenge_len", FR_TYPE_SIZE, 0, rlm_chap_t, min_challenge_len), .dflt = "16" },
CONF_PARSER_TERMINATOR
};
static const call_env_method_t chap_xlat_method_env = { \
FR_CALL_ENV_METHOD_OUT(chap_xlat_call_env_t),
.env = (call_env_parser_t[]){
- { FR_CALL_ENV_OFFSET("chap_challenge", FR_TYPE_OCTETS | FR_TYPE_ATTRIBUTE, chap_xlat_call_env_t,
+ { FR_CALL_ENV_OFFSET("chap_challenge", FR_TYPE_OCTETS, CONF_FLAG_ATTRIBUTE, chap_xlat_call_env_t,
chap_challenge, "&Chap-Challenge", T_BARE_WORD, true, true, true) },
CALL_ENV_TERMINATOR
}
static const call_env_method_t chap_autz_method_env = { \
FR_CALL_ENV_METHOD_OUT(chap_autz_call_env_t),
.env = (call_env_parser_t[]){
- { FR_CALL_ENV_OFFSET("chap_password", FR_TYPE_OCTETS | FR_TYPE_ATTRIBUTE, chap_autz_call_env_t,
+ { FR_CALL_ENV_OFFSET("chap_password", FR_TYPE_OCTETS, CONF_FLAG_ATTRIBUTE, chap_autz_call_env_t,
chap_password, "&Chap-Password", T_BARE_WORD, true, true, true) },
- { FR_CALL_ENV_TMPL_OFFSET("chap_challenge", FR_TYPE_OCTETS | FR_TYPE_ATTRIBUTE, chap_autz_call_env_t,
+ { FR_CALL_ENV_TMPL_OFFSET("chap_challenge", FR_TYPE_OCTETS, CONF_FLAG_ATTRIBUTE, chap_autz_call_env_t,
chap_challenge, chap_challenge_tmpl, "&Chap-Challenge", T_BARE_WORD, true, true, true) },
CALL_ENV_TERMINATOR
}
static const call_env_method_t chap_auth_method_env = { \
FR_CALL_ENV_METHOD_OUT(chap_auth_call_env_t),
.env = (call_env_parser_t[]){
- { FR_CALL_ENV_OFFSET("username", FR_TYPE_STRING | FR_TYPE_ATTRIBUTE, chap_auth_call_env_t,
+ { FR_CALL_ENV_OFFSET("username", FR_TYPE_STRING, CONF_FLAG_ATTRIBUTE, chap_auth_call_env_t,
username, "&User-Name", T_BARE_WORD, true, false, true) },
- { FR_CALL_ENV_OFFSET("chap_password", FR_TYPE_OCTETS | FR_TYPE_ATTRIBUTE, chap_auth_call_env_t,
+ { FR_CALL_ENV_OFFSET("chap_password", FR_TYPE_OCTETS, CONF_FLAG_ATTRIBUTE, chap_auth_call_env_t,
chap_password, "&Chap-Password", T_BARE_WORD, true, true, true) },
- { FR_CALL_ENV_OFFSET("chap_challenge", FR_TYPE_OCTETS | FR_TYPE_ATTRIBUTE, chap_auth_call_env_t,
+ { FR_CALL_ENV_OFFSET("chap_challenge", FR_TYPE_OCTETS, CONF_FLAG_ATTRIBUTE, chap_auth_call_env_t,
chap_challenge, "&Chap-Challenge", T_BARE_WORD, true, true, true) },
CALL_ENV_TERMINATOR
}
*
*/
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) },
+ { FR_CONF_OFFSET("oaep_digest", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY, cipher_rsa_oaep_t, oaep_digest), .func = digest_type_parse, .dflt = "sha256" },
+ { FR_CONF_OFFSET("mgf1_digest", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY, cipher_rsa_oaep_t, mgf1_digest), .func = digest_type_parse, .dflt = "sha256" },
+ { FR_CONF_OFFSET("label", FR_TYPE_STRING, 0, cipher_rsa_oaep_t, label) },
CONF_PARSER_TERMINATOR
};
*
*/
static const conf_parser_t rsa_config[] = {
- { FR_CONF_OFFSET("verify_mode", FR_TYPE_VOID, cipher_rsa_t, verify_mode),
+ { FR_CONF_OFFSET("verify_mode", FR_TYPE_VOID, 0, cipher_rsa_t, verify_mode),
.func = cf_table_parse_int,
.uctx = &(cf_table_parse_ctx_t){
.table = cipher_cert_verify_mode_table,
},
.dflt = "hard" }, /* Must come before certificate file */
- { FR_CONF_OFFSET("private_key_password", FR_TYPE_STRING | FR_TYPE_SECRET, cipher_rsa_t, private_key_password) }, /* Must come before private_key */
- { FR_CONF_OFFSET("private_key_file", FR_TYPE_VOID | FR_TYPE_NOT_EMPTY, cipher_rsa_t, private_key_file), .func = cipher_rsa_private_key_file_load },
- { FR_CONF_OFFSET("certificate_file", FR_TYPE_VOID | FR_TYPE_NOT_EMPTY, cipher_rsa_t, certificate_file), .func = cipher_rsa_certificate_file_load },
+ { FR_CONF_OFFSET("private_key_password", FR_TYPE_STRING, CONF_FLAG_SECRET, cipher_rsa_t, private_key_password) }, /* Must come before private_key */
+ { FR_CONF_OFFSET("private_key_file", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY, cipher_rsa_t, private_key_file), .func = cipher_rsa_private_key_file_load },
+ { FR_CONF_OFFSET("certificate_file", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY, cipher_rsa_t, certificate_file), .func = cipher_rsa_certificate_file_load },
- { FR_CONF_OFFSET("random_file", FR_TYPE_STRING, cipher_rsa_t, random_file) },
+ { FR_CONF_OFFSET("random_file", FR_TYPE_STRING, 0, cipher_rsa_t, random_file) },
- { FR_CONF_OFFSET("signature_digest", FR_TYPE_VOID | FR_TYPE_NOT_EMPTY, cipher_rsa_t, sig_digest), .func = digest_type_parse, .dflt = "sha256" },
+ { FR_CONF_OFFSET("signature_digest", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY, cipher_rsa_t, sig_digest), .func = digest_type_parse, .dflt = "sha256" },
- { FR_CONF_OFFSET("padding_type", FR_TYPE_VOID | FR_TYPE_NOT_EMPTY, cipher_rsa_t, padding), .func = cipher_rsa_padding_type_parse, .dflt = "pkcs" },
+ { FR_CONF_OFFSET("padding_type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY, cipher_rsa_t, padding), .func = cipher_rsa_padding_type_parse, .dflt = "pkcs" },
- { FR_CONF_OFFSET("oaep", FR_TYPE_SUBSECTION, cipher_rsa_t, oaep),
+ { FR_CONF_OFFSET("oaep", 0, CONF_FLAG_SUBSECTION, cipher_rsa_t, oaep),
.subcs_size = sizeof(cipher_rsa_oaep_t), .subcs_type = "cipher_rsa_oaep_t", .subcs = (void const *) rsa_oaep_config },
CONF_PARSER_TERMINATOR
* A mapping of configuration file names to internal variables.
*/
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("type", FR_TYPE_VOID | 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),
+ { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY, rlm_cipher_t, type), .func = cipher_type_parse, .dflt = "rsa" },
+ { FR_CONF_OFFSET("rsa", 0, CONF_FLAG_SUBSECTION, rlm_cipher_t, rsa),
.subcs_size = sizeof(cipher_rsa_t), .subcs_type = "cipher_rsa_t", .subcs = (void const *) rsa_config },
CONF_PARSER_TERMINATOR
* Client Configuration
*/
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" },
+ { FR_CONF_OFFSET("view", FR_TYPE_STRING, 0, rlm_couchbase_t, client_view), .dflt = "_design/client/_view/by_name" },
CONF_PARSER_TERMINATOR
};
* Module Configuration
*/
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("server", FR_TYPE_STRING | 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) },
- { FR_CONF_OFFSET("password", FR_TYPE_STRING, rlm_couchbase_t, password) },
-
- { FR_CONF_OFFSET("acct_key", FR_TYPE_TMPL, rlm_couchbase_t, acct_key), .dflt = "radacct_%{%{Acct-Unique-Session-Id} || %{Acct-Session-Id}}", .quote = T_DOUBLE_QUOTED_STRING },
- { FR_CONF_OFFSET("doctype", FR_TYPE_STRING, rlm_couchbase_t, doctype), .dflt = "radacct" },
- { FR_CONF_OFFSET("expire", FR_TYPE_UINT32, rlm_couchbase_t, expire), .dflt = 0 },
-
- { FR_CONF_OFFSET("user_key", FR_TYPE_TMPL, rlm_couchbase_t, user_key), .dflt = "raduser_%{md5:%{tolower:%{%{Stripped-User-Name} || %{User-Name}}}}", .quote = T_DOUBLE_QUOTED_STRING },
- { FR_CONF_OFFSET("read_clients", FR_TYPE_BOOL, rlm_couchbase_t, read_clients) }, /* NULL defaults to "no" */
- { FR_CONF_POINTER("client", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) client_config },
+ { FR_CONF_OFFSET("server", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_couchbase_t, server_raw) },
+ { FR_CONF_OFFSET("bucket", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_couchbase_t, bucket) },
+ { FR_CONF_OFFSET("username", FR_TYPE_STRING, 0, rlm_couchbase_t, username) },
+ { FR_CONF_OFFSET("password", FR_TYPE_STRING, 0, rlm_couchbase_t, password) },
+
+ { FR_CONF_OFFSET("acct_key", 0, CONF_FLAG_TMPL, rlm_couchbase_t, acct_key), .dflt = "radacct_%{%{Acct-Unique-Session-Id} || %{Acct-Session-Id}}", .quote = T_DOUBLE_QUOTED_STRING },
+ { FR_CONF_OFFSET("doctype", FR_TYPE_STRING, 0, rlm_couchbase_t, doctype), .dflt = "radacct" },
+ { FR_CONF_OFFSET("expire", FR_TYPE_UINT32, 0, rlm_couchbase_t, expire), .dflt = 0 },
+
+ { FR_CONF_OFFSET("user_key", 0, CONF_FLAG_TMPL, rlm_couchbase_t, user_key), .dflt = "raduser_%{md5:%{tolower:%{%{Stripped-User-Name} || %{User-Name}}}}", .quote = T_DOUBLE_QUOTED_STRING },
+ { FR_CONF_OFFSET("read_clients", FR_TYPE_BOOL, 0, rlm_couchbase_t, read_clients) }, /* NULL defaults to "no" */
+ { FR_CONF_POINTER("client", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) client_config },
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_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) },
- { FR_CONF_OFFSET("header", FR_TYPE_BOOL, rlm_csv_t, header) },
- { FR_CONF_OFFSET("allow_multiple_keys", FR_TYPE_BOOL, rlm_csv_t, allow_multiple_keys) },
- { FR_CONF_OFFSET("index_field", FR_TYPE_STRING | FR_TYPE_REQUIRED | FR_TYPE_NOT_EMPTY, rlm_csv_t, index_field_name) },
- { FR_CONF_OFFSET("key", FR_TYPE_TMPL, rlm_csv_t, key) },
+ { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, rlm_csv_t, filename) },
+ { FR_CONF_OFFSET("delimiter", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY, rlm_csv_t, delimiter), .dflt = "," },
+ { FR_CONF_OFFSET("fields", FR_TYPE_STRING, 0, rlm_csv_t, fields) },
+ { FR_CONF_OFFSET("header", FR_TYPE_BOOL, 0, rlm_csv_t, header) },
+ { FR_CONF_OFFSET("allow_multiple_keys", FR_TYPE_BOOL, 0, rlm_csv_t, allow_multiple_keys) },
+ { FR_CONF_OFFSET("index_field", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, rlm_csv_t, index_field_name) },
+ { FR_CONF_OFFSET("key", 0, CONF_FLAG_TMPL, rlm_csv_t, key) },
CONF_PARSER_TERMINATOR
};
} rlm_date_t;
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" },
+ { FR_CONF_OFFSET("format", FR_TYPE_STRING, 0, rlm_date_t, fmt), .dflt = "%b %e %Y %H:%M:%S %Z" },
+ { FR_CONF_OFFSET("utc", FR_TYPE_BOOL, 0, rlm_date_t, utc), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
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" },
+ { FR_CONF_OFFSET("delay", 0, CONF_FLAG_TMPL, rlm_delay_t, delay) },
+ { FR_CONF_OFFSET("relative", FR_TYPE_BOOL, 0, rlm_delay_t, relative), .dflt = "no" },
+ { FR_CONF_OFFSET("force_reschedule", FR_TYPE_BOOL, 0, rlm_delay_t, force_reschedule), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
CONF_ITEM *ci, conf_parser_t const *rule);
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),
+ { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_OUTPUT | CONF_FLAG_XLAT, rlm_detail_t, filename), .dflt = "%A/%{Net.Src.IP}/detail" },
+ { FR_CONF_OFFSET("header", 0, CONF_FLAG_TMPL | CONF_FLAG_XLAT, rlm_detail_t, header),
.dflt = "%t", .quote = T_DOUBLE_QUOTED_STRING },
- { FR_CONF_OFFSET("permissions", FR_TYPE_UINT32, rlm_detail_t, perm), .dflt = "0600" },
- { FR_CONF_OFFSET_IS_SET("group", FR_TYPE_VOID, rlm_detail_t, group), .func = detail_group_parse },
- { FR_CONF_OFFSET("locking", FR_TYPE_BOOL, rlm_detail_t, locking), .dflt = "no" },
- { FR_CONF_OFFSET("escape_filenames", FR_TYPE_BOOL, rlm_detail_t, escape), .dflt = "no" },
- { FR_CONF_OFFSET("log_packet_header", FR_TYPE_BOOL, rlm_detail_t, log_srcdst), .dflt = "no" },
+ { FR_CONF_OFFSET("permissions", FR_TYPE_UINT32, 0, rlm_detail_t, perm), .dflt = "0600" },
+ { FR_CONF_OFFSET_IS_SET("group", FR_TYPE_VOID, 0, rlm_detail_t, group), .func = detail_group_parse },
+ { FR_CONF_OFFSET("locking", FR_TYPE_BOOL, 0, rlm_detail_t, locking), .dflt = "no" },
+ { FR_CONF_OFFSET("escape_filenames", FR_TYPE_BOOL, 0, rlm_detail_t, escape), .dflt = "no" },
+ { FR_CONF_OFFSET("log_packet_header", FR_TYPE_BOOL, 0, rlm_detail_t, log_srcdst), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
} rlm_dhcpv4_thread_t;
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) },
+ { FR_CONF_OFFSET("ipaddr", FR_TYPE_IPV4_ADDR, 0, rlm_dhcpv4_t, config.ipaddr), },
+ { FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, 0, rlm_dhcpv4_t, config.ipaddr) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, rlm_dhcpv4_t, config.port), .dflt = "68" },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, rlm_dhcpv4_t, config.port), .dflt = "68" },
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, rlm_dhcpv4_t, config.interface) },
+ { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, rlm_dhcpv4_t, config.interface) },
- { FR_CONF_OFFSET_IS_SET("send_buff", FR_TYPE_UINT32, rlm_dhcpv4_t, config.send_buff) },
+ { FR_CONF_OFFSET_IS_SET("send_buff", FR_TYPE_UINT32, 0, rlm_dhcpv4_t, config.send_buff) },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, rlm_dhcpv4_t, max_packet_size), .dflt = "576" },
- { FR_CONF_OFFSET("max_queued_packets", FR_TYPE_UINT32, rlm_dhcpv4_t, config.max_queued_packets), .dflt = "65536" },
+ { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, rlm_dhcpv4_t, max_packet_size), .dflt = "576" },
+ { FR_CONF_OFFSET("max_queued_packets", FR_TYPE_UINT32, 0, rlm_dhcpv4_t, config.max_queued_packets), .dflt = "65536" },
- { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, rlm_dhcpv4_t, config.max_queued_time), .dflt = "0" },
+ { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, 0, rlm_dhcpv4_t, config.max_queued_time), .dflt = "0" },
CONF_PARSER_TERMINATOR
};
static size_t require_identity_realm_table_len = NUM_ELEMENTS(require_identity_realm_table);
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("require_identity_realm", FR_TYPE_VOID, rlm_eap_t, require_realm),
+ { FR_CONF_OFFSET("require_identity_realm", FR_TYPE_VOID, 0, rlm_eap_t, require_realm),
.func = cf_table_parse_int,
.uctx = &(cf_table_parse_ctx_t){ .table = require_identity_realm_table, .len = &require_identity_realm_table_len },
.dflt = "nai" },
- { FR_CONF_OFFSET_IS_SET("default_eap_type", FR_TYPE_VOID, rlm_eap_t, default_method), .func = eap_type_parse },
+ { FR_CONF_OFFSET_IS_SET("default_eap_type", FR_TYPE_VOID, 0, rlm_eap_t, default_method), .func = eap_type_parse },
- { FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_MULTI | FR_TYPE_NOT_EMPTY, rlm_eap_t, type_submodules),
+ { FR_CONF_OFFSET("type", FR_TYPE_VOID, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI, rlm_eap_t, type_submodules),
.func = submodule_parse },
- { FR_CONF_OFFSET("ignore_unknown_eap_types", FR_TYPE_BOOL, rlm_eap_t, ignore_unknown_types), .dflt = "no" },
+ { FR_CONF_OFFSET("ignore_unknown_eap_types", FR_TYPE_BOOL, 0, rlm_eap_t, ignore_unknown_types), .dflt = "no" },
- { FR_CONF_DEPRECATED("timer_expire", FR_TYPE_UINT32, rlm_eap_t, timer_limit), .dflt = "60" },
- { FR_CONF_DEPRECATED("cisco_accounting_username_bug", FR_TYPE_BOOL, rlm_eap_t,
+ { FR_CONF_DEPRECATED("timer_expire", FR_TYPE_UINT32, 0, rlm_eap_t, timer_limit), .dflt = "60" },
+ { FR_CONF_DEPRECATED("cisco_accounting_username_bug", FR_TYPE_BOOL, 0, rlm_eap_t,
cisco_accounting_username_bug), .dflt = "no" },
- { FR_CONF_DEPRECATED("max_sessions", FR_TYPE_UINT32, rlm_eap_t, max_sessions), .dflt = "2048" },
+ { FR_CONF_DEPRECATED("max_sessions", FR_TYPE_UINT32, 0, rlm_eap_t, max_sessions), .dflt = "2048" },
CONF_PARSER_TERMINATOR
};
#include <freeradius-devel/util/debug.h>
static conf_parser_t submodule_config[] = {
- { FR_CONF_OFFSET("virtual_server", FR_TYPE_VOID, 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" },
+ { FR_CONF_OFFSET("virtual_server", FR_TYPE_VOID, 0, eap_aka_sim_module_conf_t, virtual_server), .func = virtual_server_cf_parse },
+ { FR_CONF_OFFSET_IS_SET("prefer_aka_prime", FR_TYPE_BOOL, 0, eap_aka_sim_module_conf_t, aka.send_at_bidding_prefer_prime ), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
#include <freeradius-devel/util/debug.h>
static conf_parser_t submodule_config[] = {
- { FR_CONF_OFFSET("virtual_server", FR_TYPE_VOID, eap_aka_sim_module_conf_t, virtual_server), .func = virtual_server_cf_parse },
+ { FR_CONF_OFFSET("virtual_server", FR_TYPE_VOID, 0, eap_aka_sim_module_conf_t, virtual_server), .func = virtual_server_cf_parse },
CONF_PARSER_TERMINATOR
};
static conf_parser_t submodule_config[] = {
- { FR_CONF_OFFSET("tls", FR_TYPE_STRING, rlm_eap_fast_t, tls_conf_name) },
+ { FR_CONF_OFFSET("tls", FR_TYPE_STRING, 0, 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" },
+ { FR_CONF_OFFSET("default_provisioning_eap_type", FR_TYPE_STRING, 0, rlm_eap_fast_t, default_provisioning_method_name), .dflt = "mschapv2" },
- { FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING | FR_TYPE_REQUIRED | FR_TYPE_NOT_EMPTY, rlm_eap_fast_t, virtual_server) },
- { FR_CONF_OFFSET("cipher_list", FR_TYPE_STRING, rlm_eap_fast_t, cipher_list) },
+ { FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, rlm_eap_fast_t, virtual_server) },
+ { FR_CONF_OFFSET("cipher_list", FR_TYPE_STRING, 0, rlm_eap_fast_t, cipher_list) },
- { FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOL, rlm_eap_fast_t, req_client_cert), .dflt = "no" },
+ { FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOL, 0, rlm_eap_fast_t, req_client_cert), .dflt = "no" },
- { FR_CONF_OFFSET("pac_lifetime", FR_TYPE_TIME_DELTA, rlm_eap_fast_t, pac_lifetime), .dflt = "604800" },
- { FR_CONF_OFFSET("authority_identity", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_eap_fast_t, authority_identity) },
- { FR_CONF_OFFSET("pac_opaque_key", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_eap_fast_t, pac_opaque_key) },
+ { FR_CONF_OFFSET("pac_lifetime", FR_TYPE_TIME_DELTA, 0, rlm_eap_fast_t, pac_lifetime), .dflt = "604800" },
+ { FR_CONF_OFFSET("authority_identity", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_eap_fast_t, authority_identity) },
+ { FR_CONF_OFFSET("pac_opaque_key", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_eap_fast_t, pac_opaque_key) },
CONF_PARSER_TERMINATOR
};
} rlm_eap_gtc_t;
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" },
+ { FR_CONF_OFFSET("challenge", FR_TYPE_STRING, 0, rlm_eap_gtc_t, challenge), .dflt = "Password: " },
+ { FR_CONF_OFFSET("auth_type", FR_TYPE_VOID, 0, rlm_eap_gtc_t, auth_type), .func = auth_type_parse, .dflt = "pap" },
CONF_PARSER_TERMINATOR
};
} rlm_eap_mschapv2_t;
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("with_ntdomain_hack", FR_TYPE_BOOL, 0, 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" },
- { FR_CONF_OFFSET("send_error", FR_TYPE_BOOL, rlm_eap_mschapv2_t, send_error), .dflt = "no" },
- { FR_CONF_OFFSET("identity", FR_TYPE_STRING, rlm_eap_mschapv2_t, identity) },
+ { FR_CONF_OFFSET("auth_type", FR_TYPE_VOID, 0, rlm_eap_mschapv2_t, auth_type), .func = auth_type_parse, .dflt = "mschap" },
+ { FR_CONF_OFFSET("send_error", FR_TYPE_BOOL, 0, rlm_eap_mschapv2_t, send_error), .dflt = "no" },
+ { FR_CONF_OFFSET("identity", FR_TYPE_STRING, 0, rlm_eap_mschapv2_t, identity) },
CONF_PARSER_TERMINATOR
};
} rlm_eap_peap_t;
static conf_parser_t submodule_config[] = {
- { FR_CONF_OFFSET("tls", FR_TYPE_STRING, rlm_eap_peap_t, tls_conf_name) },
+ { FR_CONF_OFFSET("tls", FR_TYPE_STRING, 0, rlm_eap_peap_t, tls_conf_name) },
- { FR_CONF_DEPRECATED("copy_request_to_tunnel", FR_TYPE_BOOL, rlm_eap_peap_t, NULL), .dflt = "no" },
+ { FR_CONF_DEPRECATED("copy_request_to_tunnel", FR_TYPE_BOOL, 0, rlm_eap_peap_t, NULL), .dflt = "no" },
- { FR_CONF_DEPRECATED("use_tunneled_reply", FR_TYPE_BOOL, rlm_eap_peap_t, NULL), .dflt = "no" },
+ { FR_CONF_DEPRECATED("use_tunneled_reply", FR_TYPE_BOOL, 0, rlm_eap_peap_t, NULL), .dflt = "no" },
#ifdef WITH_PROXY
- { FR_CONF_OFFSET("proxy_tunneled_request_as_eap", FR_TYPE_BOOL, rlm_eap_peap_t, proxy_tunneled_request_as_eap), .dflt = "yes" },
+ { FR_CONF_OFFSET("proxy_tunneled_request_as_eap", FR_TYPE_BOOL, 0, rlm_eap_peap_t, proxy_tunneled_request_as_eap), .dflt = "yes" },
#endif
- { FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING | FR_TYPE_REQUIRED | FR_TYPE_NOT_EMPTY, rlm_eap_peap_t, virtual_server) },
+ { FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, rlm_eap_peap_t, virtual_server) },
- { FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOL, rlm_eap_peap_t, req_client_cert), .dflt = "no" },
+ { FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOL, 0, rlm_eap_peap_t, req_client_cert), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
#define MSK_EMSK_LEN (2 * MPPE_KEY_LEN)
static conf_parser_t submodule_config[] = {
- { FR_CONF_OFFSET("group", FR_TYPE_UINT32, 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) },
+ { FR_CONF_OFFSET("group", FR_TYPE_UINT32, 0, rlm_eap_pwd_t, group), .dflt = "19" },
+ { FR_CONF_OFFSET("fragment_size", FR_TYPE_UINT32, 0, rlm_eap_pwd_t, fragment_size), .dflt = "1020" },
+ { FR_CONF_OFFSET("server_id", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_eap_pwd_t, server_id) },
CONF_PARSER_TERMINATOR
};
#include <freeradius-devel/util/debug.h>
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 },
+ { FR_CONF_OFFSET("virtual_server", FR_TYPE_VOID, CONF_FLAG_REQUIRED, eap_aka_sim_module_conf_t, virtual_server), .func = virtual_server_cf_parse },
CONF_PARSER_TERMINATOR
};
} rlm_eap_tls_thread_t;
static conf_parser_t submodule_config[] = {
- { FR_CONF_OFFSET("tls", FR_TYPE_STRING, rlm_eap_tls_t, tls_conf_name) },
+ { FR_CONF_OFFSET("tls", FR_TYPE_STRING, 0, 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" },
- { FR_CONF_OFFSET("include_length", FR_TYPE_BOOL, rlm_eap_tls_t, include_length), .dflt = "yes" },
- { FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING, rlm_eap_tls_t, virtual_server) },
+ { FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOL, 0, rlm_eap_tls_t, req_client_cert), .dflt = "yes" },
+ { FR_CONF_OFFSET("include_length", FR_TYPE_BOOL, 0, rlm_eap_tls_t, include_length), .dflt = "yes" },
+ { FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING, 0, rlm_eap_tls_t, virtual_server) },
CONF_PARSER_TERMINATOR
};
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" },
- { FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING | FR_TYPE_REQUIRED | FR_TYPE_NOT_EMPTY, rlm_eap_ttls_t, virtual_server) },
- { FR_CONF_OFFSET("include_length", FR_TYPE_BOOL, rlm_eap_ttls_t, include_length), .dflt = "yes" },
- { FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOL, rlm_eap_ttls_t, req_client_cert), .dflt = "no" },
+ { FR_CONF_OFFSET("tls", FR_TYPE_STRING, 0, rlm_eap_ttls_t, tls_conf_name) },
+ { FR_CONF_DEPRECATED("copy_request_to_tunnel", FR_TYPE_BOOL, 0, rlm_eap_ttls_t, NULL), .dflt = "no" },
+ { FR_CONF_DEPRECATED("use_tunneled_reply", FR_TYPE_BOOL, 0, rlm_eap_ttls_t, NULL), .dflt = "no" },
+ { FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, rlm_eap_ttls_t, virtual_server) },
+ { FR_CONF_OFFSET("include_length", FR_TYPE_BOOL, 0, rlm_eap_ttls_t, include_length), .dflt = "yes" },
+ { FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOL, 0, rlm_eap_ttls_t, req_client_cert), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
} rlm_escape_t;
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("safe_characters", FR_TYPE_STRING, rlm_escape_t, allowed_chars), .dflt = "@abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-_: /" },
+ { FR_CONF_OFFSET("safe_characters", FR_TYPE_STRING, 0, rlm_escape_t, allowed_chars), .dflt = "@abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-_: /" },
CONF_PARSER_TERMINATOR
};
} rlm_exec_t;
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("wait", FR_TYPE_BOOL, 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) },
- { FR_CONF_OFFSET("shell_escape", FR_TYPE_BOOL, rlm_exec_t, shell_escape), .dflt = "yes" },
- { FR_CONF_OFFSET("env_inherit", FR_TYPE_BOOL, rlm_exec_t, env_inherit), .dflt = "no" },
- { FR_CONF_OFFSET_IS_SET("timeout", FR_TYPE_TIME_DELTA, rlm_exec_t, timeout) },
+ { FR_CONF_OFFSET("wait", FR_TYPE_BOOL, 0, rlm_exec_t, wait), .dflt = "yes" },
+ { FR_CONF_OFFSET("input_pairs", 0, CONF_FLAG_TMPL, rlm_exec_t, input_list) },
+ { FR_CONF_OFFSET("output_pairs", 0, CONF_FLAG_TMPL, rlm_exec_t, output_list) },
+ { FR_CONF_OFFSET("shell_escape", FR_TYPE_BOOL, 0, rlm_exec_t, shell_escape), .dflt = "yes" },
+ { FR_CONF_OFFSET("env_inherit", FR_TYPE_BOOL, 0, rlm_exec_t, env_inherit), .dflt = "no" },
+ { FR_CONF_OFFSET_IS_SET("timeout", FR_TYPE_TIME_DELTA, 0, rlm_exec_t, timeout) },
CONF_PARSER_TERMINATOR
};
static const call_env_method_t exec_method_env = {
FR_CALL_ENV_METHOD_OUT(exec_call_env_t),
.env = (call_env_parser_t[]){
- { FR_CALL_ENV_TMPL_ONLY_OFFSET("program", FR_TYPE_STRING, exec_call_env_t, program, NULL,
+ { FR_CALL_ENV_TMPL_ONLY_OFFSET("program", FR_TYPE_STRING, 0, exec_call_env_t, program, NULL,
T_BACK_QUOTED_STRING, false), .pair.force_quote = true },
CALL_ENV_TERMINATOR
}
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) },
- { FR_CONF_OFFSET("auth_usersfile", FR_TYPE_FILE_INPUT, rlm_files_t, auth_usersfile) },
- { FR_CONF_OFFSET("postauth_usersfile", FR_TYPE_FILE_INPUT, rlm_files_t, postauth_usersfile) },
- { FR_CONF_OFFSET("key", FR_TYPE_TMPL | FR_TYPE_NOT_EMPTY, rlm_files_t, key), .dflt = "%{%{Stripped-User-Name} || %{User-Name}}", .quote = T_DOUBLE_QUOTED_STRING },
+ { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_files_t, filename) },
+ { FR_CONF_OFFSET("usersfile", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_files_t, usersfile) },
+ { FR_CONF_OFFSET("acctusersfile", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_files_t, acct_usersfile) },
+ { FR_CONF_OFFSET("auth_usersfile", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_files_t, auth_usersfile) },
+ { FR_CONF_OFFSET("postauth_usersfile", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_files_t, postauth_usersfile) },
+ { FR_CONF_OFFSET("key", 0, CONF_FLAG_TMPL | CONF_FLAG_NOT_EMPTY, rlm_files_t, key), .dflt = "%{%{Stripped-User-Name} || %{User-Name}}", .quote = T_DOUBLE_QUOTED_STRING },
CONF_PARSER_TERMINATOR
};
static const call_env_method_t method_env = {
FR_CALL_ENV_METHOD_OUT(rlm_files_env_t),
.env = (call_env_parser_t[]){
- { FR_CALL_ENV_OFFSET("key", FR_TYPE_VOID, rlm_files_env_t, key, "%{%{Stripped-User-Name} || %{User-Name}}",
+ { FR_CALL_ENV_OFFSET("key", FR_TYPE_VOID, 0, rlm_files_env_t, key, "%{%{Stripped-User-Name} || %{User-Name}}",
T_DOUBLE_QUOTED_STRING, true, false, false) },
CALL_ENV_TERMINATOR
},
}
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" },
+ { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, rlm_icmp_t, interface) },
+ { FR_CONF_OFFSET("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, rlm_icmp_t, src_ipaddr) },
+ { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, 0, rlm_icmp_t, timeout), .dflt = "1s" },
CONF_PARSER_TERMINATOR
};
* be used.
*/
- { FR_CONF_OFFSET("allow_unassigned", FR_TYPE_BOOL, rlm_idn_t, allow_unassigned), .dflt = "no" },
- { FR_CONF_OFFSET("use_std3_ascii_rules", FR_TYPE_BOOL, rlm_idn_t, use_std3_ascii_rules), .dflt = "yes" },
+ { FR_CONF_OFFSET("allow_unassigned", FR_TYPE_BOOL, 0, rlm_idn_t, allow_unassigned), .dflt = "no" },
+ { FR_CONF_OFFSET("use_std3_ascii_rules", FR_TYPE_BOOL, 0, rlm_idn_t, use_std3_ascii_rules), .dflt = "yes" },
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("uri", FR_TYPE_STRING, 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
- { FR_CONF_OFFSET("connection", FR_TYPE_SUBSECTION, rlm_imap_t, conn_config), .subcs = (void const *) fr_curl_conn_config },
+ { FR_CONF_OFFSET("uri", FR_TYPE_STRING, 0, rlm_imap_t, uri) },
+ { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, 0, rlm_imap_t, timeout), .dflt = "5.0" },
+ { FR_CONF_OFFSET("tls", 0, CONF_FLAG_SUBSECTION, rlm_imap_t, tls), .subcs = (void const *) fr_curl_tls_config },//!<loading the tls values
+ { FR_CONF_OFFSET("connection", 0, CONF_FLAG_SUBSECTION, rlm_imap_t, conn_config), .subcs = (void const *) fr_curl_conn_config },
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_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) },
+ { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, rlm_isc_dhcp_t, filename) },
+ { FR_CONF_OFFSET("debug", FR_TYPE_BOOL, 0, rlm_isc_dhcp_t, debug) },
+ { FR_CONF_OFFSET("pedantic", FR_TYPE_BOOL, 0, rlm_isc_dhcp_t, pedantic) },
CONF_PARSER_TERMINATOR
};
static conf_parser_t const module_config[] = {
- { FR_CONF_OFFSET("encode", FR_TYPE_SUBSECTION, rlm_json_t, format),
+ { FR_CONF_OFFSET("encode", 0, CONF_FLAG_SUBSECTION, rlm_json_t, format),
.subcs_size = sizeof(fr_json_format_t), .subcs_type = "fr_json_format_t",
.subcs = (void const *) fr_json_format_config },
#include "krb5.h"
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) },
+ { FR_CONF_OFFSET("keytab", FR_TYPE_STRING, 0, rlm_krb5_t, keytabname) },
+ { FR_CONF_OFFSET("service_principal", FR_TYPE_STRING, 0, rlm_krb5_t, service_princ) },
CONF_PARSER_TERMINATOR
};
} ldap_xlat_profile_call_env_t;
static const call_env_parser_t sasl_call_env[] = {
- { FR_CALL_ENV_OFFSET("mech", FR_TYPE_STRING, ldap_auth_call_env_t, user_sasl_mech,
+ { FR_CALL_ENV_OFFSET("mech", FR_TYPE_STRING, 0, ldap_auth_call_env_t, user_sasl_mech,
NULL, T_INVALID, false, false, false) },
- { FR_CALL_ENV_OFFSET("authname", FR_TYPE_STRING, ldap_auth_call_env_t, user_sasl_authname,
+ { FR_CALL_ENV_OFFSET("authname", FR_TYPE_STRING, 0, ldap_auth_call_env_t, user_sasl_authname,
NULL, T_INVALID, false, false, false) },
- { FR_CALL_ENV_OFFSET("proxy", FR_TYPE_STRING, ldap_auth_call_env_t, user_sasl_proxy,
+ { FR_CALL_ENV_OFFSET("proxy", FR_TYPE_STRING, 0, ldap_auth_call_env_t, user_sasl_proxy,
NULL, T_INVALID, false, true, false) },
- { FR_CALL_ENV_OFFSET("realm", FR_TYPE_STRING, ldap_auth_call_env_t, user_sasl_realm,
+ { FR_CALL_ENV_OFFSET("realm", FR_TYPE_STRING, 0, ldap_auth_call_env_t, user_sasl_realm,
NULL, T_INVALID, false, true, false) },
CALL_ENV_TERMINATOR
};
static conf_parser_t profile_config[] = {
- { FR_CONF_OFFSET("scope", FR_TYPE_INT32, rlm_ldap_t, profile_scope), .dflt = "base",
+ { FR_CONF_OFFSET("scope", FR_TYPE_INT32, 0, 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) },
- { FR_CONF_OFFSET("attribute_suspend", FR_TYPE_STRING, rlm_ldap_t, profile_attr_suspend) },
+ { FR_CONF_OFFSET("attribute", FR_TYPE_STRING, 0, rlm_ldap_t, profile_attr) },
+ { FR_CONF_OFFSET("attribute_suspend", FR_TYPE_STRING, 0, rlm_ldap_t, profile_attr_suspend) },
CONF_PARSER_TERMINATOR
};
static const call_env_parser_t autz_profile_call_env[] = {
- { FR_CALL_ENV_OFFSET("default", FR_TYPE_STRING, ldap_autz_call_env_t, default_profile,
+ { FR_CALL_ENV_OFFSET("default", FR_TYPE_STRING, 0, ldap_autz_call_env_t, default_profile,
NULL, T_INVALID, false, false, true) },
- { FR_CALL_ENV_OFFSET("filter", FR_TYPE_STRING, ldap_autz_call_env_t, profile_filter,
+ { FR_CALL_ENV_OFFSET("filter", FR_TYPE_STRING, 0, ldap_autz_call_env_t, profile_filter,
"(&)", T_SINGLE_QUOTED_STRING, false, false, true ) }, //!< Correct filter for when the DN is known.
CALL_ENV_TERMINATOR
};
* User configuration
*/
static conf_parser_t user_config[] = {
- { FR_CONF_OFFSET("scope", FR_TYPE_INT32, rlm_ldap_t, userobj_scope), .dflt = "sub",
+ { FR_CONF_OFFSET("scope", FR_TYPE_INT32, 0, 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) },
+ { FR_CONF_OFFSET("sort_by", FR_TYPE_STRING, 0, rlm_ldap_t, userobj_sort_by) },
- { FR_CONF_OFFSET("access_attribute", FR_TYPE_STRING, rlm_ldap_t, userobj_access_attr) },
- { FR_CONF_OFFSET("access_positive", FR_TYPE_BOOL, rlm_ldap_t, access_positive), .dflt = "yes" },
- { FR_CONF_OFFSET("access_value_negate", FR_TYPE_STRING, rlm_ldap_t, access_value_negate), .dflt = "false" },
- { FR_CONF_OFFSET("access_value_suspend", FR_TYPE_STRING, rlm_ldap_t, access_value_suspend), .dflt = "suspended" },
+ { FR_CONF_OFFSET("access_attribute", FR_TYPE_STRING, 0, rlm_ldap_t, userobj_access_attr) },
+ { FR_CONF_OFFSET("access_positive", FR_TYPE_BOOL, 0, rlm_ldap_t, access_positive), .dflt = "yes" },
+ { FR_CONF_OFFSET("access_value_negate", FR_TYPE_STRING, 0, rlm_ldap_t, access_value_negate), .dflt = "false" },
+ { FR_CONF_OFFSET("access_value_suspend", FR_TYPE_STRING, 0, rlm_ldap_t, access_value_suspend), .dflt = "suspended" },
CONF_PARSER_TERMINATOR
};
#define user_call_env(_prefix, _struct, ...) \
static const call_env_parser_t _prefix ## _user_call_env[] = { \
- { FR_CALL_ENV_OFFSET("base_dn", FR_TYPE_STRING, _struct, user_base, \
+ { FR_CALL_ENV_OFFSET("base_dn", FR_TYPE_STRING, 0, _struct, user_base, \
"", T_SINGLE_QUOTED_STRING, true, false, true) }, \
- { FR_CALL_ENV_OFFSET("filter", FR_TYPE_STRING, _struct, user_filter, \
+ { FR_CALL_ENV_OFFSET("filter", FR_TYPE_STRING, 0, _struct, user_filter, \
NULL, T_INVALID, false, true, true) }, \
##__VA_ARGS__, \
CALL_ENV_TERMINATOR \
}
user_call_env(auth, ldap_auth_call_env_t, { FR_CALL_ENV_SUBSECTION("sasl", NULL, sasl_call_env, false) },
- { FR_CALL_ENV_TMPL_OFFSET("password_attribute", FR_TYPE_STRING | FR_TYPE_ATTRIBUTE, ldap_auth_call_env_t, password,
+ { FR_CALL_ENV_TMPL_OFFSET("password_attribute", FR_TYPE_STRING, CONF_FLAG_ATTRIBUTE, ldap_auth_call_env_t, password,
password_tmpl, "&User-Password", T_BARE_WORD, true, true, true) } );
user_call_env(autz, ldap_autz_call_env_t);
* Group configuration
*/
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",
+ { FR_CONF_OFFSET("filter", FR_TYPE_STRING, 0, rlm_ldap_t, groupobj_filter) },
+ { FR_CONF_OFFSET("scope", FR_TYPE_INT32, 0, rlm_ldap_t, groupobj_scope), .dflt = "sub",
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = fr_ldap_scope, .len = &fr_ldap_scope_len } },
- { FR_CONF_OFFSET("name_attribute", FR_TYPE_STRING, rlm_ldap_t, groupobj_name_attr), .dflt = "cn" },
- { FR_CONF_OFFSET("membership_attribute", FR_TYPE_STRING, rlm_ldap_t, userobj_membership_attr) },
- { FR_CONF_OFFSET("membership_filter", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_ldap_t, groupobj_membership_filter) },
- { FR_CONF_OFFSET("cacheable_name", FR_TYPE_BOOL, rlm_ldap_t, cacheable_group_name), .dflt = "no" },
- { FR_CONF_OFFSET("cacheable_dn", FR_TYPE_BOOL, rlm_ldap_t, cacheable_group_dn), .dflt = "no" },
- { FR_CONF_OFFSET("cache_attribute", FR_TYPE_STRING, rlm_ldap_t, cache_attribute) },
- { FR_CONF_OFFSET("group_attribute", FR_TYPE_STRING, rlm_ldap_t, group_attribute) },
- { FR_CONF_OFFSET("allow_dangling_group_ref", FR_TYPE_BOOL, rlm_ldap_t, allow_dangling_group_refs), .dflt = "no" },
+ { FR_CONF_OFFSET("name_attribute", FR_TYPE_STRING, 0, rlm_ldap_t, groupobj_name_attr), .dflt = "cn" },
+ { FR_CONF_OFFSET("membership_attribute", FR_TYPE_STRING, 0, rlm_ldap_t, userobj_membership_attr) },
+ { FR_CONF_OFFSET("membership_filter", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_ldap_t, groupobj_membership_filter) },
+ { FR_CONF_OFFSET("cacheable_name", FR_TYPE_BOOL, 0, rlm_ldap_t, cacheable_group_name), .dflt = "no" },
+ { FR_CONF_OFFSET("cacheable_dn", FR_TYPE_BOOL, 0, rlm_ldap_t, cacheable_group_dn), .dflt = "no" },
+ { FR_CONF_OFFSET("cache_attribute", FR_TYPE_STRING, 0, rlm_ldap_t, cache_attribute) },
+ { FR_CONF_OFFSET("group_attribute", FR_TYPE_STRING, 0, rlm_ldap_t, group_attribute) },
+ { FR_CONF_OFFSET("allow_dangling_group_ref", FR_TYPE_BOOL, 0, rlm_ldap_t, allow_dangling_group_refs), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
static const call_env_parser_t autz_group_call_env[] = {
- { FR_CALL_ENV_OFFSET("base_dn", FR_TYPE_STRING, ldap_autz_call_env_t, group_base,
+ { FR_CALL_ENV_OFFSET("base_dn", FR_TYPE_STRING, 0, ldap_autz_call_env_t, group_base,
NULL, T_INVALID, false, false, true) },
CALL_ENV_TERMINATOR
};
static const call_env_parser_t memberof_group_call_env[] = {
- { FR_CALL_ENV_OFFSET("base_dn", FR_TYPE_STRING, ldap_xlat_memberof_call_env_t, group_base,
+ { FR_CALL_ENV_OFFSET("base_dn", FR_TYPE_STRING, 0, ldap_xlat_memberof_call_env_t, group_base,
NULL, T_INVALID, false, false, true) },
CALL_ENV_TERMINATOR
};
* Reference for accounting updates
*/
static const conf_parser_t acct_section_config[] = {
- { FR_CONF_OFFSET("reference", FR_TYPE_STRING | FR_TYPE_XLAT, ldap_acct_section_t, reference), .dflt = "." },
+ { FR_CONF_OFFSET("reference", FR_TYPE_STRING, CONF_FLAG_XLAT, ldap_acct_section_t, reference), .dflt = "." },
CONF_PARSER_TERMINATOR
};
/*
* Pool config items
*/
- { FR_CONF_OFFSET("server", FR_TYPE_STRING | FR_TYPE_MULTI, rlm_ldap_t, handle_config.server_str) }, /* Do not set to required */
+ { FR_CONF_OFFSET("server", FR_TYPE_STRING, CONF_FLAG_MULTI, rlm_ldap_t, handle_config.server_str) }, /* Do not set to required */
/*
* Common LDAP conf parsers
*/
FR_LDAP_COMMON_CONF(rlm_ldap_t),
- { FR_CONF_OFFSET("valuepair_attribute", FR_TYPE_STRING, rlm_ldap_t, valuepair_attr) },
+ { FR_CONF_OFFSET("valuepair_attribute", FR_TYPE_STRING, 0, rlm_ldap_t, valuepair_attr) },
#ifdef LDAP_CONTROL_X_SESSION_TRACKING
- { FR_CONF_OFFSET("session_tracking", FR_TYPE_BOOL, rlm_ldap_t, session_tracking), .dflt = "no" },
+ { FR_CONF_OFFSET("session_tracking", FR_TYPE_BOOL, 0, rlm_ldap_t, session_tracking), .dflt = "no" },
#endif
#ifdef WITH_EDIR
/* support for eDirectory Universal Password */
- { FR_CONF_OFFSET("edir", FR_TYPE_BOOL, rlm_ldap_t, edir) }, /* NULL defaults to "no" */
+ { FR_CONF_OFFSET("edir", FR_TYPE_BOOL, 0, rlm_ldap_t, edir) }, /* NULL defaults to "no" */
/*
* Attempt to bind with the cleartext password we got from eDirectory
* Universal password for additional authorization checks.
*/
- { FR_CONF_OFFSET("edir_autz", FR_TYPE_BOOL, rlm_ldap_t, edir_autz) }, /* NULL defaults to "no" */
+ { FR_CONF_OFFSET("edir_autz", FR_TYPE_BOOL, 0, rlm_ldap_t, edir_autz) }, /* NULL defaults to "no" */
#endif
- { FR_CONF_POINTER("user", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) user_config },
+ { FR_CONF_POINTER("user", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) user_config },
- { FR_CONF_POINTER("group", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) group_config },
+ { FR_CONF_POINTER("group", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) group_config },
- { FR_CONF_POINTER("profile", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) profile_config },
+ { FR_CONF_POINTER("profile", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) profile_config },
- { FR_CONF_OFFSET("pool", FR_TYPE_SUBSECTION, rlm_ldap_t, trunk_conf), .subcs = (void const *) fr_trunk_config },
+ { FR_CONF_OFFSET("pool", 0, CONF_FLAG_SUBSECTION, rlm_ldap_t, trunk_conf), .subcs = (void const *) fr_trunk_config },
- { FR_CONF_OFFSET("bind_pool", FR_TYPE_SUBSECTION, rlm_ldap_t, bind_trunk_conf),
+ { FR_CONF_OFFSET("bind_pool", 0, CONF_FLAG_SUBSECTION, rlm_ldap_t, bind_trunk_conf),
.subcs = (void const *) fr_trunk_config },
CONF_PARSER_TERMINATOR
.env = (call_env_parser_t[]) {
{ FR_CALL_ENV_SUBSECTION("profile", NULL,
((call_env_parser_t[]) {
- { FR_CALL_ENV_OFFSET("filter", FR_TYPE_STRING, ldap_xlat_profile_call_env_t, profile_filter,
+ { FR_CALL_ENV_OFFSET("filter", FR_TYPE_STRING, 0, ldap_xlat_profile_call_env_t, profile_filter,
"(&)", T_SINGLE_QUOTED_STRING, false, false, true ) }, //!< Correct filter for when the DN is known.
CALL_ENV_TERMINATOR
}),
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) },
- { FR_CONF_OFFSET("escape_filenames", FR_TYPE_BOOL, rlm_linelog_t, file.escape), .dflt = "no" },
+ { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_OUTPUT | CONF_FLAG_XLAT, rlm_linelog_t, file.name) },
+ { FR_CONF_OFFSET("permissions", FR_TYPE_UINT32, 0, rlm_linelog_t, file.permissions), .dflt = "0600" },
+ { FR_CONF_OFFSET("group", FR_TYPE_STRING, 0, rlm_linelog_t, file.group_str) },
+ { FR_CONF_OFFSET("escape_filenames", FR_TYPE_BOOL, 0, rlm_linelog_t, file.escape), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
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" },
+ { FR_CONF_OFFSET("facility", FR_TYPE_STRING, 0, rlm_linelog_t, syslog.facility) },
+ { FR_CONF_OFFSET("severity", FR_TYPE_STRING, 0, rlm_linelog_t, syslog.severity), .dflt = "info" },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t unix_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT, rlm_linelog_t, unix_sock.path) },
+ { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_linelog_t, unix_sock.path) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t udp_config[] = {
- { FR_CONF_OFFSET("server", FR_TYPE_COMBO_IP_ADDR, 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" },
+ { FR_CONF_OFFSET("server", FR_TYPE_COMBO_IP_ADDR, 0, linelog_net_t, dst_ipaddr) },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, linelog_net_t, port) },
+ { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, 0, linelog_net_t, timeout), .dflt = "1000" },
CONF_PARSER_TERMINATOR
};
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" },
+ { FR_CONF_OFFSET("server", FR_TYPE_COMBO_IP_ADDR, 0, linelog_net_t, dst_ipaddr) },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, linelog_net_t, port) },
+ { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, 0, linelog_net_t, timeout), .dflt = "1000" },
CONF_PARSER_TERMINATOR
};
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("destination", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_linelog_t, log_dst_str) },
- { FR_CONF_OFFSET("delimiter", FR_TYPE_STRING, rlm_linelog_t, delimiter), .dflt = "\n" },
- { FR_CONF_OFFSET("format", FR_TYPE_TMPL, rlm_linelog_t, log_src) },
- { FR_CONF_OFFSET("reference", FR_TYPE_TMPL, rlm_linelog_t, log_ref) },
- { FR_CONF_OFFSET("header", FR_TYPE_TMPL, rlm_linelog_t, log_head) },
+ { FR_CONF_OFFSET("delimiter", FR_TYPE_STRING, 0, rlm_linelog_t, delimiter), .dflt = "\n" },
+ { FR_CONF_OFFSET("format", 0, CONF_FLAG_TMPL, rlm_linelog_t, log_src) },
+ { FR_CONF_OFFSET("reference", 0, CONF_FLAG_TMPL, rlm_linelog_t, log_ref) },
+ { FR_CONF_OFFSET("header", 0, CONF_FLAG_TMPL, rlm_linelog_t, log_head) },
/*
* Log destinations
*/
- { FR_CONF_POINTER("file", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) file_config },
- { FR_CONF_POINTER("syslog", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) syslog_config },
- { FR_CONF_POINTER("unix", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) unix_config },
- { FR_CONF_OFFSET("tcp", FR_TYPE_SUBSECTION, rlm_linelog_t, tcp), .subcs= (void const *) tcp_config },
- { FR_CONF_OFFSET("udp", FR_TYPE_SUBSECTION, rlm_linelog_t, udp), .subcs = (void const *) udp_config },
+ { FR_CONF_POINTER("file", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) file_config },
+ { FR_CONF_POINTER("syslog", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) syslog_config },
+ { FR_CONF_POINTER("unix", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) unix_config },
+ { FR_CONF_OFFSET("tcp", 0, CONF_FLAG_SUBSECTION, rlm_linelog_t, tcp), .subcs= (void const *) tcp_config },
+ { FR_CONF_OFFSET("udp", 0, CONF_FLAG_SUBSECTION, rlm_linelog_t, udp), .subcs = (void const *) udp_config },
/*
* Deprecated config items
*/
- { FR_CONF_OFFSET("filename", FR_TYPE_FILE_OUTPUT | FR_TYPE_DEPRECATED, rlm_linelog_t, file.name) },
- { FR_CONF_OFFSET("permissions", FR_TYPE_UINT32 | FR_TYPE_DEPRECATED, rlm_linelog_t, file.permissions) },
- { FR_CONF_OFFSET("group", FR_TYPE_STRING | FR_TYPE_DEPRECATED, rlm_linelog_t, file.group_str) },
+ { FR_CONF_DEPRECATED("filename", FR_TYPE_STRING, CONF_FLAG_FILE_OUTPUT, rlm_linelog_t, file.name) },
+ { FR_CONF_DEPRECATED("permissions", FR_TYPE_UINT32, 0, rlm_linelog_t, file.permissions) },
+ { FR_CONF_DEPRECATED("group", FR_TYPE_STRING, 0, rlm_linelog_t, file.group_str) },
- { FR_CONF_OFFSET("syslog_facility", FR_TYPE_STRING | FR_TYPE_DEPRECATED, rlm_linelog_t, syslog.facility) },
- { FR_CONF_OFFSET("syslog_severity", FR_TYPE_STRING | FR_TYPE_DEPRECATED, rlm_linelog_t, syslog.severity) },
+ { FR_CONF_DEPRECATED("syslog_facility", FR_TYPE_STRING, 0, rlm_linelog_t, syslog.facility) },
+ { FR_CONF_DEPRECATED("syslog_severity", FR_TYPE_STRING, 0, rlm_linelog_t, syslog.severity) },
CONF_PARSER_TERMINATOR
};
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) },
- { FR_CONF_OFFSET("escape_filenames", FR_TYPE_BOOL, rlm_logtee_t, file.escape), .dflt = "no" },
+ { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_OUTPUT | CONF_FLAG_XLAT, rlm_logtee_t, file.name) },
+ { FR_CONF_OFFSET("permissions", FR_TYPE_UINT32, 0, rlm_logtee_t, file.permissions), .dflt = "0600" },
+ { FR_CONF_OFFSET("group", FR_TYPE_STRING, 0, rlm_logtee_t, file.group_str) },
+ { FR_CONF_OFFSET("escape_filenames", FR_TYPE_BOOL, 0, rlm_logtee_t, file.escape), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t unix_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT, rlm_logtee_t, unix_sock.path) },
+ { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_logtee_t, unix_sock.path) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t udp_config[] = {
- { FR_CONF_OFFSET("server", FR_TYPE_COMBO_IP_ADDR, logtee_net_t, dst_ipaddr) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, logtee_net_t, port) },
+ { FR_CONF_OFFSET("server", FR_TYPE_COMBO_IP_ADDR, 0, logtee_net_t, dst_ipaddr) },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, logtee_net_t, port) },
CONF_PARSER_TERMINATOR
};
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) },
+ { FR_CONF_OFFSET("server", FR_TYPE_COMBO_IP_ADDR, 0, logtee_net_t, dst_ipaddr) },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, logtee_net_t, port) },
CONF_PARSER_TERMINATOR
};
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" },
+ { FR_CONF_OFFSET("destination", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_logtee_t, log_dst_str) },
+ { FR_CONF_OFFSET("buffer_depth", FR_TYPE_SIZE, 0, rlm_logtee_t, buffer_depth), .dflt = "10000" },
- { FR_CONF_OFFSET("delimiter", FR_TYPE_STRING, rlm_logtee_t, delimiter), .dflt = "\n" },
- { FR_CONF_OFFSET("format", FR_TYPE_TMPL, rlm_logtee_t, log_fmt), .dflt = "%n - %s", .quote = T_DOUBLE_QUOTED_STRING },
+ { FR_CONF_OFFSET("delimiter", FR_TYPE_STRING, 0, rlm_logtee_t, delimiter), .dflt = "\n" },
+ { FR_CONF_OFFSET("format", 0, CONF_FLAG_TMPL, rlm_logtee_t, log_fmt), .dflt = "%n - %s", .quote = T_DOUBLE_QUOTED_STRING },
/*
* Log destinations
*/
- { FR_CONF_POINTER("file", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) file_config },
- { FR_CONF_POINTER("unix", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) unix_config },
- { FR_CONF_OFFSET("tcp", FR_TYPE_SUBSECTION, rlm_logtee_t, tcp), .subcs= (void const *) tcp_config },
- { FR_CONF_OFFSET("udp", FR_TYPE_SUBSECTION, rlm_logtee_t, udp), .subcs = (void const *) udp_config },
+ { FR_CONF_POINTER("file", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) file_config },
+ { FR_CONF_POINTER("unix", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) unix_config },
+ { FR_CONF_OFFSET("tcp", 0, CONF_FLAG_SUBSECTION, rlm_logtee_t, tcp), .subcs= (void const *) tcp_config },
+ { FR_CONF_OFFSET("udp", 0, CONF_FLAG_SUBSECTION, rlm_logtee_t, udp), .subcs = (void const *) udp_config },
- { FR_CONF_OFFSET("connection_timeout", FR_TYPE_TIME_DELTA, rlm_logtee_t, connection_timeout), .dflt = "1.0" },
- { FR_CONF_OFFSET("reconnection_delay", FR_TYPE_TIME_DELTA, rlm_logtee_t, reconnection_delay), .dflt = "1.0" },
+ { FR_CONF_OFFSET("connection_timeout", FR_TYPE_TIME_DELTA, 0, rlm_logtee_t, connection_timeout), .dflt = "1.0" },
+ { FR_CONF_OFFSET("reconnection_delay", FR_TYPE_TIME_DELTA, 0, rlm_logtee_t, reconnection_delay), .dflt = "1.0" },
CONF_PARSER_TERMINATOR
};
* buffer over-flows.
*/
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},
- { FR_CONF_OFFSET("func_authorize", FR_TYPE_STRING, rlm_lua_t, func_authorize), NULL},
- { FR_CONF_OFFSET("func_authenticate", FR_TYPE_STRING, rlm_lua_t, func_authenticate), NULL},
- { FR_CONF_OFFSET("func_accounting", FR_TYPE_STRING, rlm_lua_t, func_accounting), NULL},
- { FR_CONF_OFFSET("func_preacct", FR_TYPE_STRING, rlm_lua_t, func_preacct), NULL},
- { FR_CONF_OFFSET("func_xlat", FR_TYPE_STRING, rlm_lua_t, func_xlat), NULL},
- { FR_CONF_OFFSET("func_post_auth", FR_TYPE_STRING, rlm_lua_t, func_post_auth), NULL},
+ { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED, rlm_lua_t, module), NULL},
+ { FR_CONF_OFFSET("func_instantiate", FR_TYPE_STRING, 0, rlm_lua_t, func_instantiate), NULL},
+ { FR_CONF_OFFSET("func_detach", FR_TYPE_STRING, 0, rlm_lua_t, func_detach), NULL},
+ { FR_CONF_OFFSET("func_authorize", FR_TYPE_STRING, 0, rlm_lua_t, func_authorize), NULL},
+ { FR_CONF_OFFSET("func_authenticate", FR_TYPE_STRING, 0, rlm_lua_t, func_authenticate), NULL},
+ { FR_CONF_OFFSET("func_accounting", FR_TYPE_STRING, 0, rlm_lua_t, func_accounting), NULL},
+ { FR_CONF_OFFSET("func_preacct", FR_TYPE_STRING, 0, rlm_lua_t, func_preacct), NULL},
+ { FR_CONF_OFFSET("func_xlat", FR_TYPE_STRING, 0, rlm_lua_t, func_xlat), NULL},
+ { FR_CONF_OFFSET("func_post_auth", FR_TYPE_STRING, 0, rlm_lua_t, func_post_auth), NULL},
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT | FR_TYPE_REQUIRED, rlm_mruby_t, filename) },
- { FR_CONF_OFFSET("module", FR_TYPE_STRING, rlm_mruby_t, module_name), .dflt = "Radiusd" },
+ { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED, rlm_mruby_t, filename) },
+ { FR_CONF_OFFSET("module", FR_TYPE_STRING, 0, rlm_mruby_t, module_name), .dflt = "Radiusd" },
CONF_PARSER_TERMINATOR
};
#define ACB_FR_EXPIRED 0x00020000 //!< Password Expired.
static const conf_parser_t passchange_config[] = {
- { FR_CONF_OFFSET("ntlm_auth", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_mschap_t, ntlm_cpw) },
- { FR_CONF_OFFSET("ntlm_auth_username", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_mschap_t, ntlm_cpw_username) },
- { FR_CONF_OFFSET("ntlm_auth_domain", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_mschap_t, ntlm_cpw_domain) },
- { FR_CONF_OFFSET("local_cpw", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_mschap_t, local_cpw) },
+ { FR_CONF_OFFSET("ntlm_auth", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_mschap_t, ntlm_cpw) },
+ { FR_CONF_OFFSET("ntlm_auth_username", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_mschap_t, ntlm_cpw_username) },
+ { FR_CONF_OFFSET("ntlm_auth_domain", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_mschap_t, ntlm_cpw_domain) },
+ { FR_CONF_OFFSET("local_cpw", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_mschap_t, local_cpw) },
CONF_PARSER_TERMINATOR
};
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) },
+ { FR_CONF_OFFSET("username", 0, CONF_FLAG_TMPL, rlm_mschap_t, wb_username) },
+ { FR_CONF_OFFSET("domain", 0, CONF_FLAG_TMPL, rlm_mschap_t, wb_domain) },
#ifdef WITH_AUTH_WINBIND
- { FR_CONF_OFFSET("retry_with_normalised_username", FR_TYPE_BOOL, rlm_mschap_t, wb_retry_with_normalised_username), .dflt = "no" },
+ { FR_CONF_OFFSET("retry_with_normalised_username", FR_TYPE_BOOL, 0, rlm_mschap_t, wb_retry_with_normalised_username), .dflt = "no" },
#endif
CONF_PARSER_TERMINATOR
};
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("normalise", FR_TYPE_BOOL, rlm_mschap_t, normify), .dflt = "yes" },
+ { FR_CONF_OFFSET("normalise", FR_TYPE_BOOL, 0, rlm_mschap_t, normify), .dflt = "yes" },
/*
* Cache the password by default.
*/
- { FR_CONF_OFFSET("use_mppe", FR_TYPE_BOOL, rlm_mschap_t, use_mppe), .dflt = "yes" },
- { FR_CONF_OFFSET("require_encryption", FR_TYPE_BOOL, rlm_mschap_t, require_encryption), .dflt = "no" },
- { FR_CONF_OFFSET("require_strong", FR_TYPE_BOOL, rlm_mschap_t, require_strong), .dflt = "no" },
- { FR_CONF_OFFSET("with_ntdomain_hack", FR_TYPE_BOOL, rlm_mschap_t, with_ntdomain_hack), .dflt = "yes" },
- { FR_CONF_OFFSET("ntlm_auth", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_mschap_t, ntlm_auth) },
- { FR_CONF_OFFSET("ntlm_auth_timeout", FR_TYPE_TIME_DELTA, rlm_mschap_t, ntlm_auth_timeout) },
+ { FR_CONF_OFFSET("use_mppe", FR_TYPE_BOOL, 0, rlm_mschap_t, use_mppe), .dflt = "yes" },
+ { FR_CONF_OFFSET("require_encryption", FR_TYPE_BOOL, 0, rlm_mschap_t, require_encryption), .dflt = "no" },
+ { FR_CONF_OFFSET("require_strong", FR_TYPE_BOOL, 0, rlm_mschap_t, require_strong), .dflt = "no" },
+ { FR_CONF_OFFSET("with_ntdomain_hack", FR_TYPE_BOOL, 0, rlm_mschap_t, with_ntdomain_hack), .dflt = "yes" },
+ { FR_CONF_OFFSET("ntlm_auth", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_mschap_t, ntlm_auth) },
+ { FR_CONF_OFFSET("ntlm_auth_timeout", FR_TYPE_TIME_DELTA, 0, rlm_mschap_t, ntlm_auth_timeout) },
- { FR_CONF_POINTER("passchange", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) passchange_config },
- { FR_CONF_OFFSET("allow_retry", FR_TYPE_BOOL, rlm_mschap_t, allow_retry), .dflt = "yes" },
- { FR_CONF_OFFSET("retry_msg", FR_TYPE_STRING, rlm_mschap_t, retry_msg) },
+ { FR_CONF_POINTER("passchange", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) passchange_config },
+ { FR_CONF_OFFSET("allow_retry", FR_TYPE_BOOL, 0, rlm_mschap_t, allow_retry), .dflt = "yes" },
+ { FR_CONF_OFFSET("retry_msg", FR_TYPE_STRING, 0, rlm_mschap_t, retry_msg) },
#ifdef __APPLE__
- { FR_CONF_OFFSET("use_open_directory", FR_TYPE_BOOL, rlm_mschap_t, open_directory), .dflt = "yes" },
+ { FR_CONF_OFFSET("use_open_directory", FR_TYPE_BOOL, 0, rlm_mschap_t, open_directory), .dflt = "yes" },
#endif
- { FR_CONF_POINTER("winbind", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) winbind_config },
+ { FR_CONF_POINTER("winbind", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) winbind_config },
/*
* These are now in a subsection above.
*/
- { FR_CONF_OFFSET("winbind_username", FR_TYPE_TMPL | FR_TYPE_DEPRECATED, rlm_mschap_t, wb_username) },
- { FR_CONF_OFFSET("winbind_domain", FR_TYPE_TMPL | FR_TYPE_DEPRECATED, rlm_mschap_t, wb_domain) },
+ { FR_CONF_DEPRECATED("winbind_username", 0, CONF_FLAG_TMPL, rlm_mschap_t, wb_username) },
+ { FR_CONF_DEPRECATED("winbind_domain", 0, CONF_FLAG_TMPL, rlm_mschap_t, wb_domain) },
#ifdef WITH_AUTH_WINBIND
- { FR_CONF_OFFSET("winbind_retry_with_normalised_username", FR_TYPE_BOOL | FR_TYPE_DEPRECATED, rlm_mschap_t, wb_retry_with_normalised_username) },
+ { FR_CONF_DEPRECATED("winbind_retry_with_normalised_username", FR_TYPE_BOOL, 0, rlm_mschap_t, wb_retry_with_normalised_username) },
#endif
CONF_PARSER_TERMINATOR
};
}
#define MSCHAP_COMMON_CALL_ENV(_x) \
-{ FR_CALL_ENV_TMPL_ONLY_OFFSET("chap_challenge", FR_TYPE_OCTETS | FR_TYPE_ATTRIBUTE, mschap_ ## _x ## _call_env_t, \
+{ FR_CALL_ENV_TMPL_ONLY_OFFSET("chap_challenge", FR_TYPE_OCTETS, CONF_FLAG_ATTRIBUTE, mschap_ ## _x ## _call_env_t, \
chap_challenge, "&Vendor-Specific.Microsoft.CHAP-Challenge", T_BARE_WORD, true) }, \
-{ FR_CALL_ENV_TMPL_ONLY_OFFSET("chap_response", FR_TYPE_OCTETS | FR_TYPE_ATTRIBUTE, mschap_ ## _x ## _call_env_t, \
+{ FR_CALL_ENV_TMPL_ONLY_OFFSET("chap_response", FR_TYPE_OCTETS, CONF_FLAG_ATTRIBUTE, mschap_ ## _x ## _call_env_t, \
chap_response, "&Vendor-Specific.Microsoft.CHAP-Response", T_BARE_WORD, true) }, \
-{ FR_CALL_ENV_TMPL_ONLY_OFFSET("chap2_response", FR_TYPE_OCTETS | FR_TYPE_ATTRIBUTE, mschap_ ## _x ## _call_env_t, \
+{ FR_CALL_ENV_TMPL_ONLY_OFFSET("chap2_response", FR_TYPE_OCTETS, CONF_FLAG_ATTRIBUTE, mschap_ ## _x ## _call_env_t, \
chap2_response, "&Vendor-Specific.Microsoft.CHAP2-Response", T_BARE_WORD, true) }
#define MSCHAP_OPT_CALL_ENV(_opt, _x) \
-{ FR_CALL_ENV_TMPL_ONLY_OFFSET(STRINGIFY(_opt), FR_TYPE_OCTETS | FR_TYPE_ATTRIBUTE, mschap_ ## _x ## _call_env_t, \
+{ FR_CALL_ENV_TMPL_ONLY_OFFSET(STRINGIFY(_opt), FR_TYPE_OCTETS, CONF_FLAG_ATTRIBUTE, mschap_ ## _x ## _call_env_t, \
_opt, NULL, T_INVALID, false) }
typedef struct {
} mschap_xlat_call_env_t;
static const call_env_parser_t xlat_call_env[] = {
- { FR_CALL_ENV_TMPL_ONLY_OFFSET("username", FR_TYPE_STRING | FR_TYPE_ATTRIBUTE, mschap_xlat_call_env_t,
+ { FR_CALL_ENV_TMPL_ONLY_OFFSET("username", FR_TYPE_STRING, CONF_FLAG_ATTRIBUTE, mschap_xlat_call_env_t,
username, "&User-Name", T_BARE_WORD, true) },
MSCHAP_COMMON_CALL_ENV(xlat),
CALL_ENV_TERMINATOR
MSCHAP_CALL_ENV(xlat);
static const call_env_parser_t auth_call_env[] = {
- { FR_CALL_ENV_TMPL_ONLY_OFFSET("username", FR_TYPE_STRING | FR_TYPE_ATTRIBUTE, mschap_auth_call_env_t,
+ { FR_CALL_ENV_TMPL_ONLY_OFFSET("username", FR_TYPE_STRING, CONF_FLAG_ATTRIBUTE, mschap_auth_call_env_t,
username, "&User-Name", T_BARE_WORD, true) },
MSCHAP_COMMON_CALL_ENV(auth),
MSCHAP_OPT_CALL_ENV(chap2_success, auth),
#ifdef HAVE_OPENSSL_OCSP_H
static conf_parser_t ocsp_config[] = {
- { FR_CONF_OFFSET("enable", FR_TYPE_BOOL, fr_tls_ocsp_conf_t, enable), .dflt = "no" },
+ { FR_CONF_OFFSET("enable", FR_TYPE_BOOL, 0, fr_tls_ocsp_conf_t, enable), .dflt = "no" },
- { FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING, fr_tls_ocsp_conf_t, cache_server) },
+ { FR_CONF_OFFSET("virtual_server", FR_TYPE_STRING, 0, fr_tls_ocsp_conf_t, cache_server) },
- { FR_CONF_OFFSET("override_cert_url", FR_TYPE_BOOL, fr_tls_ocsp_conf_t, override_url), .dflt = "no" },
- { FR_CONF_OFFSET("url", FR_TYPE_STRING, fr_tls_ocsp_conf_t, url) },
- { FR_CONF_OFFSET("use_nonce", FR_TYPE_BOOL, fr_tls_ocsp_conf_t, use_nonce), .dflt = "yes" },
- { FR_CONF_OFFSET("timeout", FR_TYPE_UINT32, fr_tls_ocsp_conf_t, timeout), .dflt = "yes" },
- { FR_CONF_OFFSET("softfail", FR_TYPE_BOOL, fr_tls_ocsp_conf_t, softfail), .dflt = "no" },
- { FR_CONF_OFFSET("verifycert", FR_TYPE_BOOL, fr_tls_ocsp_conf_t, verifycert), .dflt = "yes" },
+ { FR_CONF_OFFSET("override_cert_url", FR_TYPE_BOOL, 0, fr_tls_ocsp_conf_t, override_url), .dflt = "no" },
+ { FR_CONF_OFFSET("url", FR_TYPE_STRING, 0, fr_tls_ocsp_conf_t, url) },
+ { FR_CONF_OFFSET("use_nonce", FR_TYPE_BOOL, 0, fr_tls_ocsp_conf_t, use_nonce), .dflt = "yes" },
+ { FR_CONF_OFFSET("timeout", FR_TYPE_UINT32, 0, fr_tls_ocsp_conf_t, timeout), .dflt = "yes" },
+ { FR_CONF_OFFSET("softfail", FR_TYPE_BOOL, 0, fr_tls_ocsp_conf_t, softfail), .dflt = "no" },
+ { FR_CONF_OFFSET("verifycert", FR_TYPE_BOOL, 0, fr_tls_ocsp_conf_t, verifycert), .dflt = "yes" },
CONF_PARSER_TERMINATOR
};
#endif
#ifdef HAVE_OPENSSL_OCSP_H
- { FR_CONF_OFFSET("ocsp", FR_TYPE_SUBSECTION, fr_tls_conf_t, ocsp), .subcs = (void const *) ocsp_config },
+ { FR_CONF_OFFSET("ocsp", 0, CONF_FLAG_SUBSECTION, fr_tls_conf_t, ocsp), .subcs = (void const *) ocsp_config },
- { FR_CONF_OFFSET("staple", FR_TYPE_SUBSECTION, fr_tls_conf_t, staple), .subcs = (void const *) ocsp_config },
+ { FR_CONF_OFFSET("staple", 0, CONF_FLAG_SUBSECTION, fr_tls_conf_t, staple), .subcs = (void const *) ocsp_config },
#endif
#ifdef HAVE_OPENSSL_OCSP_H
} rlm_pam_data_t;
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("pam_auth", FR_TYPE_STRING, rlm_pam_t, pam_auth_name) },
+ { FR_CONF_OFFSET("pam_auth", FR_TYPE_STRING, 0, rlm_pam_t, pam_auth_name) },
CONF_PARSER_TERMINATOR
};
typedef unlang_action_t (*pap_auth_func_t)(rlm_rcode_t *p_result, rlm_pap_t const *inst, request_t *request, fr_pair_t const *, fr_value_box_t const *);
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("normalise", FR_TYPE_BOOL, rlm_pap_t, normify), .dflt = "yes" },
+ { FR_CONF_OFFSET("normalise", FR_TYPE_BOOL, 0, rlm_pap_t, normify), .dflt = "yes" },
CONF_PARSER_TERMINATOR
};
.inst_size = sizeof(pap_call_env_t),
.inst_type = "pap_call_env_t",
.env = (call_env_parser_t[]) {
- { FR_CALL_ENV_TMPL_OFFSET("password_attribute", FR_TYPE_STRING | FR_TYPE_ATTRIBUTE, pap_call_env_t, password,
+ { FR_CALL_ENV_TMPL_OFFSET("password_attribute", FR_TYPE_STRING, CONF_FLAG_ATTRIBUTE, pap_call_env_t, password,
password_tmpl, "&User-Password", T_BARE_WORD, true, true, true) },
CALL_ENV_TERMINATOR
}
} rlm_passwd_t;
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 = ":" },
+ { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED, rlm_passwd_t, filename) },
+ { FR_CONF_OFFSET("format", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_passwd_t, format) },
+ { FR_CONF_OFFSET("delimiter", FR_TYPE_STRING, 0, rlm_passwd_t, delimiter), .dflt = ":" },
- { FR_CONF_OFFSET("ignore_nislike", FR_TYPE_BOOL, rlm_passwd_t, ignore_nislike), .dflt = "yes" },
+ { FR_CONF_OFFSET("ignore_nislike", FR_TYPE_BOOL, 0, rlm_passwd_t, ignore_nislike), .dflt = "yes" },
- { FR_CONF_OFFSET("ignore_empty", FR_TYPE_BOOL, rlm_passwd_t, ignore_empty), .dflt = "yes" },
+ { FR_CONF_OFFSET("ignore_empty", FR_TYPE_BOOL, 0, rlm_passwd_t, ignore_empty), .dflt = "yes" },
- { FR_CONF_OFFSET("allow_multiple_keys", FR_TYPE_BOOL, rlm_passwd_t, allow_multiple), .dflt = "no" },
+ { FR_CONF_OFFSET("allow_multiple_keys", FR_TYPE_BOOL, 0, rlm_passwd_t, allow_multiple), .dflt = "no" },
- { FR_CONF_OFFSET("hash_size", FR_TYPE_UINT32, rlm_passwd_t, hash_size), .dflt = "100" },
+ { FR_CONF_OFFSET("hash_size", FR_TYPE_UINT32, 0, rlm_passwd_t, hash_size), .dflt = "100" },
CONF_PARSER_TERMINATOR
};
/*
* A mapping of configuration file names to internal variables.
*/
-#define RLM_PERL_CONF(_x) { FR_CONF_OFFSET("func_" STRINGIFY(_x), FR_TYPE_STRING, rlm_perl_t, func_##_x), \
+#define RLM_PERL_CONF(_x) { FR_CONF_OFFSET("func_" STRINGIFY(_x), FR_TYPE_STRING, 0, rlm_perl_t, func_##_x), \
.data = NULL, .dflt = STRINGIFY(_x), .quote = T_INVALID }
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_FILE_INPUT | FR_TYPE_REQUIRED, rlm_perl_t, module) },
+ { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT | CONF_FLAG_REQUIRED, rlm_perl_t, module) },
RLM_PERL_CONF(authorize),
RLM_PERL_CONF(authenticate),
RLM_PERL_CONF(preacct),
RLM_PERL_CONF(detach),
- { FR_CONF_OFFSET("perl_flags", FR_TYPE_STRING, rlm_perl_t, perl_flags) },
+ { FR_CONF_OFFSET("perl_flags", FR_TYPE_STRING, 0, rlm_perl_t, perl_flags) },
CONF_PARSER_TERMINATOR
};
};
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) },
+ { FR_CONF_OFFSET("path", FR_TYPE_STRING, 0, libpython_global_config_t, path) },
+ { FR_CONF_OFFSET("path_include_default", FR_TYPE_BOOL, 0, libpython_global_config_t, path_include_default) },
CONF_PARSER_TERMINATOR
};
*/
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) },
+#define A(x) { FR_CONF_OFFSET("mod_" #x, FR_TYPE_STRING, 0, rlm_python_t, x.module_name), .dflt = "${.module}" }, \
+ { FR_CONF_OFFSET("func_" #x, FR_TYPE_STRING, 0, rlm_python_t, x.function_name) },
A(instantiate)
A(authorize)
static int status_check_update_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
static conf_parser_t const status_check_config[] = {
- { FR_CONF_OFFSET("type", FR_TYPE_VOID, rlm_radius_t, status_check),
+ { FR_CONF_OFFSET("type", FR_TYPE_VOID, 0, rlm_radius_t, status_check),
.func = status_check_type_parse },
CONF_PARSER_TERMINATOR
};
static conf_parser_t const status_check_update_config[] = {
- { FR_CONF_OFFSET("update", FR_TYPE_SUBSECTION | FR_TYPE_REQUIRED, rlm_radius_t, status_check_map),
- .ident2 = CF_IDENT_ANY,
+ { FR_CONF_OFFSET("update", 0, CONF_FLAG_SUBSECTION | CONF_FLAG_REQUIRED, rlm_radius_t, status_check_map),
+ .name2 = CF_IDENT_ANY,
.func = status_check_update_parse },
- { FR_CONF_OFFSET("num_answers_to_alive", FR_TYPE_UINT32, rlm_radius_t, num_answers_to_alive), .dflt = STRINGIFY(3) },
+ { FR_CONF_OFFSET("num_answers_to_alive", FR_TYPE_UINT32, 0, rlm_radius_t, num_answers_to_alive), .dflt = STRINGIFY(3) },
CONF_PARSER_TERMINATOR
};
* Retransmission intervals for the packets we support.
*/
static conf_parser_t auth_config[] = {
- { FR_CONF_OFFSET("initial_rtx_time", FR_TYPE_TIME_DELTA, 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) },
- { FR_CONF_OFFSET("max_rtx_duration", FR_TYPE_TIME_DELTA, rlm_radius_t, retry[FR_RADIUS_CODE_ACCESS_REQUEST].mrd), .dflt = STRINGIFY(30) },
+ { FR_CONF_OFFSET("initial_rtx_time", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_ACCESS_REQUEST].irt), .dflt = STRINGIFY(2) },
+ { FR_CONF_OFFSET("max_rtx_time", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_ACCESS_REQUEST].mrt), .dflt = STRINGIFY(16) },
+ { FR_CONF_OFFSET("max_rtx_count", FR_TYPE_UINT32, 0, rlm_radius_t, retry[FR_RADIUS_CODE_ACCESS_REQUEST].mrc), .dflt = STRINGIFY(5) },
+ { FR_CONF_OFFSET("max_rtx_duration", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_ACCESS_REQUEST].mrd), .dflt = STRINGIFY(30) },
CONF_PARSER_TERMINATOR
};
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) },
- { FR_CONF_OFFSET("max_rtx_duration", FR_TYPE_TIME_DELTA, rlm_radius_t, retry[FR_RADIUS_CODE_ACCOUNTING_REQUEST].mrd), .dflt = STRINGIFY(30) },
+ { FR_CONF_OFFSET("initial_rtx_time", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_ACCOUNTING_REQUEST].irt), .dflt = STRINGIFY(2) },
+ { FR_CONF_OFFSET("max_rtx_time", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_ACCOUNTING_REQUEST].mrt), .dflt = STRINGIFY(5) },
+ { FR_CONF_OFFSET("max_rtx_count", FR_TYPE_UINT32, 0, rlm_radius_t, retry[FR_RADIUS_CODE_ACCOUNTING_REQUEST].mrc), .dflt = STRINGIFY(1) },
+ { FR_CONF_OFFSET("max_rtx_duration", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_ACCOUNTING_REQUEST].mrd), .dflt = STRINGIFY(30) },
CONF_PARSER_TERMINATOR
};
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) },
- { FR_CONF_OFFSET("max_rtx_duration", FR_TYPE_TIME_DELTA, rlm_radius_t, retry[FR_RADIUS_CODE_STATUS_SERVER].mrd), .dflt = STRINGIFY(30) },
+ { FR_CONF_OFFSET("initial_rtx_time", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_STATUS_SERVER].irt), .dflt = STRINGIFY(2) },
+ { FR_CONF_OFFSET("max_rtx_time", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_STATUS_SERVER].mrt), .dflt = STRINGIFY(5) },
+ { FR_CONF_OFFSET("max_rtx_count", FR_TYPE_UINT32, 0, rlm_radius_t, retry[FR_RADIUS_CODE_STATUS_SERVER].mrc), .dflt = STRINGIFY(5) },
+ { FR_CONF_OFFSET("max_rtx_duration", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_STATUS_SERVER].mrd), .dflt = STRINGIFY(30) },
CONF_PARSER_TERMINATOR
};
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) },
- { FR_CONF_OFFSET("max_rtx_duration", FR_TYPE_TIME_DELTA, rlm_radius_t, retry[FR_RADIUS_CODE_COA_REQUEST].mrd), .dflt = STRINGIFY(30) },
+ { FR_CONF_OFFSET("initial_rtx_time", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_COA_REQUEST].irt), .dflt = STRINGIFY(2) },
+ { FR_CONF_OFFSET("max_rtx_time", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_COA_REQUEST].mrt), .dflt = STRINGIFY(16) },
+ { FR_CONF_OFFSET("max_rtx_count", FR_TYPE_UINT32, 0, rlm_radius_t, retry[FR_RADIUS_CODE_COA_REQUEST].mrc), .dflt = STRINGIFY(5) },
+ { FR_CONF_OFFSET("max_rtx_duration", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_COA_REQUEST].mrd), .dflt = STRINGIFY(30) },
CONF_PARSER_TERMINATOR
};
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) },
- { FR_CONF_OFFSET("max_rtx_duration", FR_TYPE_TIME_DELTA, rlm_radius_t, retry[FR_RADIUS_CODE_DISCONNECT_REQUEST].mrd), .dflt = STRINGIFY(30) },
+ { FR_CONF_OFFSET("initial_rtx_time", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_DISCONNECT_REQUEST].irt), .dflt = STRINGIFY(2) },
+ { FR_CONF_OFFSET("max_rtx_time", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_DISCONNECT_REQUEST].mrt), .dflt = STRINGIFY(16) },
+ { FR_CONF_OFFSET("max_rtx_count", FR_TYPE_UINT32, 0, rlm_radius_t, retry[FR_RADIUS_CODE_DISCONNECT_REQUEST].mrc), .dflt = STRINGIFY(5) },
+ { FR_CONF_OFFSET("max_rtx_duration", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, retry[FR_RADIUS_CODE_DISCONNECT_REQUEST].mrd), .dflt = STRINGIFY(30) },
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
static conf_parser_t const module_config[] = {
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, rlm_radius_t, io_submodule),
+ { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, rlm_radius_t, io_submodule),
.func = module_rlm_submodule_parse },
- { FR_CONF_OFFSET("type", FR_TYPE_UINT32 | FR_TYPE_MULTI | FR_TYPE_NOT_EMPTY | FR_TYPE_REQUIRED, rlm_radius_t, types),
+ { FR_CONF_OFFSET("type", FR_TYPE_UINT32, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI | CONF_FLAG_REQUIRED, rlm_radius_t, types),
.func = type_parse },
- { FR_CONF_OFFSET("replicate", FR_TYPE_BOOL, rlm_radius_t, replicate) },
+ { FR_CONF_OFFSET("replicate", FR_TYPE_BOOL, 0, rlm_radius_t, replicate) },
- { FR_CONF_OFFSET("synchronous", FR_TYPE_BOOL, rlm_radius_t, synchronous) },
+ { FR_CONF_OFFSET("synchronous", FR_TYPE_BOOL, 0, rlm_radius_t, synchronous) },
- { FR_CONF_OFFSET("originate", FR_TYPE_BOOL, rlm_radius_t, originate) },
+ { FR_CONF_OFFSET("originate", FR_TYPE_BOOL, 0, rlm_radius_t, originate) },
- { FR_CONF_POINTER("status_check", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) status_check_config },
+ { FR_CONF_POINTER("status_check", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) status_check_config },
- { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, rlm_radius_t, max_attributes), .dflt = STRINGIFY(RADIUS_MAX_ATTRIBUTES) },
+ { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, 0, rlm_radius_t, max_attributes), .dflt = STRINGIFY(RADIUS_MAX_ATTRIBUTES) },
- { FR_CONF_OFFSET("response_window", FR_TYPE_TIME_DELTA, rlm_radius_t, response_window), .dflt = STRINGIFY(20) },
+ { FR_CONF_OFFSET("response_window", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, response_window), .dflt = STRINGIFY(20) },
- { FR_CONF_OFFSET("zombie_period", FR_TYPE_TIME_DELTA, rlm_radius_t, zombie_period), .dflt = STRINGIFY(40) },
+ { FR_CONF_OFFSET("zombie_period", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, zombie_period), .dflt = STRINGIFY(40) },
- { FR_CONF_OFFSET("revive_interval", FR_TYPE_TIME_DELTA, rlm_radius_t, revive_interval) },
+ { FR_CONF_OFFSET("revive_interval", FR_TYPE_TIME_DELTA, 0, rlm_radius_t, revive_interval) },
- { FR_CONF_OFFSET("pool", FR_TYPE_SUBSECTION, rlm_radius_t, trunk_conf), .subcs = (void const *) fr_trunk_config, },
+ { FR_CONF_OFFSET("pool", 0, CONF_FLAG_SUBSECTION, rlm_radius_t, trunk_conf), .subcs = (void const *) fr_trunk_config, },
CONF_PARSER_TERMINATOR
};
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_ACCESS_REQUEST] = { FR_CONF_POINTER("Access-Request", 0, CONF_FLAG_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 },
- [FR_RADIUS_CODE_STATUS_SERVER] = { FR_CONF_POINTER("Status-Server", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) status_config },
- [FR_RADIUS_CODE_COA_REQUEST] = { FR_CONF_POINTER("CoA-Request", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) coa_config },
- [FR_RADIUS_CODE_DISCONNECT_REQUEST] = { FR_CONF_POINTER("Disconnect-Request", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) disconnect_config },
+ [FR_RADIUS_CODE_ACCOUNTING_REQUEST] = { FR_CONF_POINTER("Accounting-Request", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) acct_config },
+ [FR_RADIUS_CODE_STATUS_SERVER] = { FR_CONF_POINTER("Status-Server", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) status_config },
+ [FR_RADIUS_CODE_COA_REQUEST] = { FR_CONF_POINTER("CoA-Request", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) coa_config },
+ [FR_RADIUS_CODE_DISCONNECT_REQUEST] = { FR_CONF_POINTER("Disconnect-Request", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) disconnect_config },
};
static fr_dict_t const *dict_radius;
if (!code ||
(code >= FR_RADIUS_CODE_MAX) ||
- (!type_interval_config[code].name)) goto invalid_code;
+ (!type_interval_config[code].name1)) goto invalid_code;
/*
* If we're doing async proxying, push the timers for the
*/
if (!code ||
(code >= FR_RADIUS_CODE_MAX) ||
- (!type_interval_config[code].name)) goto invalid_code;
+ (!type_interval_config[code].name1)) goto invalid_code;
/*
* Add irt / mrt / mrd / mrc parsing, in the parent
};
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) },
+ { FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, rlm_radius_udp_t, dst_ipaddr), },
+ { FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, 0, rlm_radius_udp_t, dst_ipaddr) },
+ { FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, 0, rlm_radius_udp_t, dst_ipaddr) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, rlm_radius_udp_t, dst_port) },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, rlm_radius_udp_t, dst_port) },
- { FR_CONF_OFFSET("secret", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_radius_udp_t, secret) },
+ { FR_CONF_OFFSET("secret", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_radius_udp_t, secret) },
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, rlm_radius_udp_t, interface) },
+ { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, rlm_radius_udp_t, interface) },
- { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, rlm_radius_udp_t, recv_buff) },
- { FR_CONF_OFFSET_IS_SET("send_buff", FR_TYPE_UINT32, rlm_radius_udp_t, send_buff) },
+ { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, rlm_radius_udp_t, recv_buff) },
+ { FR_CONF_OFFSET_IS_SET("send_buff", FR_TYPE_UINT32, 0, rlm_radius_udp_t, send_buff) },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, rlm_radius_udp_t, max_packet_size), .dflt = "4096" },
- { FR_CONF_OFFSET("max_send_coalesce", FR_TYPE_UINT16, rlm_radius_udp_t, max_send_coalesce), .dflt = "1024" },
+ { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, rlm_radius_udp_t, max_packet_size), .dflt = "4096" },
+ { FR_CONF_OFFSET("max_send_coalesce", FR_TYPE_UINT16, 0, rlm_radius_udp_t, max_send_coalesce), .dflt = "1024" },
- { FR_CONF_OFFSET("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, rlm_radius_udp_t, src_ipaddr) },
- { FR_CONF_OFFSET("src_ipv4addr", FR_TYPE_IPV4_ADDR, rlm_radius_udp_t, src_ipaddr) },
- { FR_CONF_OFFSET("src_ipv6addr", FR_TYPE_IPV6_ADDR, rlm_radius_udp_t, src_ipaddr) },
+ { FR_CONF_OFFSET("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, rlm_radius_udp_t, src_ipaddr) },
+ { FR_CONF_OFFSET("src_ipv4addr", FR_TYPE_IPV4_ADDR, 0, rlm_radius_udp_t, src_ipaddr) },
+ { FR_CONF_OFFSET("src_ipv6addr", FR_TYPE_IPV6_ADDR, 0, rlm_radius_udp_t, src_ipaddr) },
CONF_PARSER_TERMINATOR
};
} rlm_radutmp_t;
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_CONF_OFFSET("permissions", FR_TYPE_UINT32, rlm_radutmp_t, permission), .dflt = "0644" },
- { FR_CONF_OFFSET("caller_id", FR_TYPE_BOOL, rlm_radutmp_t, caller_id_ok), .dflt = "no" },
+ { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_radutmp_t, filename), .dflt = RADUTMP },
+ { FR_CONF_OFFSET("username", FR_TYPE_STRING, CONF_FLAG_SECRET, rlm_radutmp_t, username), .dflt = "%{User-Name}" },
+ { FR_CONF_OFFSET("check_with_nas", FR_TYPE_BOOL, 0, rlm_radutmp_t, check_nas), .dflt = "yes" },
+ { FR_CONF_OFFSET("permissions", FR_TYPE_UINT32, 0, rlm_radutmp_t, permission), .dflt = "0644" },
+ { FR_CONF_OFFSET("caller_id", FR_TYPE_BOOL, 0, rlm_radutmp_t, caller_id_ok), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
static int lua_func_body_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule);
static conf_parser_t module_lua_func[] = {
- { FR_CONF_OFFSET("body", FR_TYPE_STRING, redis_lua_func_t, body), .func = lua_func_body_parse },
- { FR_CONF_OFFSET("read_only", FR_TYPE_BOOL, redis_lua_func_t, read_only) },
+ { FR_CONF_OFFSET("body", FR_TYPE_STRING, 0, redis_lua_func_t, body), .func = lua_func_body_parse },
+ { FR_CONF_OFFSET("read_only", FR_TYPE_BOOL, 0, redis_lua_func_t, read_only) },
CONF_PARSER_TERMINATOR
};
static conf_parser_t module_lua[] = {
- { FR_CONF_SUBSECTION_ALLOC("function", FR_TYPE_SUBSECTION | FR_TYPE_MULTI | FR_TYPE_OK_MISSING,
+ { FR_CONF_SUBSECTION_ALLOC("function", 0, CONF_FLAG_SUBSECTION | CONF_FLAG_OK_MISSING | CONF_FLAG_MULTI,
rlm_redis_lua_t, funcs, module_lua_func),
- .subcs_type = "redis_lua_func_t", .ident2 = CF_IDENT_ANY },
+ .subcs_type = "redis_lua_func_t", .name2 = CF_IDENT_ANY },
CONF_PARSER_TERMINATOR
};
};
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) },
+ { FR_CONF_OFFSET("wait_num", FR_TYPE_UINT32, 0, rlm_redis_ippool_t, wait_num) },
+ { FR_CONF_OFFSET("wait_timeout", FR_TYPE_TIME_DELTA, 0, rlm_redis_ippool_t, wait_timeout) },
- { FR_CONF_DEPRECATED("ip_address", FR_TYPE_TMPL | FR_TYPE_REQUIRED, rlm_redis_ippool_t, NULL) },
+ { FR_CONF_DEPRECATED("ip_address", 0, CONF_FLAG_TMPL | CONF_FLAG_REQUIRED, rlm_redis_ippool_t, NULL) },
- { FR_CONF_DEPRECATED("reply_attr", FR_TYPE_TMPL | FR_TYPE_ATTRIBUTE | FR_TYPE_REQUIRED, rlm_redis_ippool_t, NULL) },
+ { FR_CONF_DEPRECATED("reply_attr", 0, CONF_FLAG_TMPL | CONF_FLAG_ATTRIBUTE | CONF_FLAG_REQUIRED, rlm_redis_ippool_t, NULL) },
- { FR_CONF_OFFSET("ipv4_integer", FR_TYPE_BOOL, rlm_redis_ippool_t, ipv4_integer) },
- { FR_CONF_OFFSET("copy_on_update", FR_TYPE_BOOL, rlm_redis_ippool_t, copy_on_update), .dflt = "yes", .quote = T_BARE_WORD },
+ { FR_CONF_OFFSET("ipv4_integer", FR_TYPE_BOOL, 0, rlm_redis_ippool_t, ipv4_integer) },
+ { FR_CONF_OFFSET("copy_on_update", FR_TYPE_BOOL, 0, rlm_redis_ippool_t, copy_on_update), .dflt = "yes", .quote = T_BARE_WORD },
/*
* Split out to allow conversion to universal ippool module with
* minimum of config changes.
*/
- { FR_CONF_POINTER("redis", FR_TYPE_SUBSECTION, NULL), .subcs = redis_config },
+ { FR_CONF_POINTER("redis", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = redis_config },
CONF_PARSER_TERMINATOR
};
static const call_env_method_t redis_ippool_alloc_method_env = {
FR_CALL_ENV_METHOD_OUT(redis_ippool_alloc_call_env_t),
.env = (call_env_parser_t[]){
- { FR_CALL_ENV_OFFSET("pool_name", FR_TYPE_STRING, redis_ippool_alloc_call_env_t, pool_name,
+ { FR_CALL_ENV_OFFSET("pool_name", FR_TYPE_STRING, 0, redis_ippool_alloc_call_env_t, pool_name,
NULL, T_INVALID, true, false, true) },
- { FR_CALL_ENV_OFFSET("owner", FR_TYPE_STRING, redis_ippool_alloc_call_env_t, owner,
+ { FR_CALL_ENV_OFFSET("owner", FR_TYPE_STRING, 0, redis_ippool_alloc_call_env_t, owner,
NULL, T_INVALID, true, false, true) },
- { FR_CALL_ENV_OFFSET("gateway", FR_TYPE_STRING, redis_ippool_alloc_call_env_t, gateway_id,
+ { FR_CALL_ENV_OFFSET("gateway", FR_TYPE_STRING, 0, redis_ippool_alloc_call_env_t, gateway_id,
"", T_SINGLE_QUOTED_STRING, false, true, true ) },
- { FR_CALL_ENV_OFFSET("offer_time", FR_TYPE_UINT32, redis_ippool_alloc_call_env_t, offer_time,
+ { FR_CALL_ENV_OFFSET("offer_time", FR_TYPE_UINT32, 0, redis_ippool_alloc_call_env_t, offer_time,
NULL, T_INVALID, false, false, false) },
- { FR_CALL_ENV_OFFSET("lease_time", FR_TYPE_UINT32, redis_ippool_alloc_call_env_t, lease_time,
+ { FR_CALL_ENV_OFFSET("lease_time", FR_TYPE_UINT32, 0, redis_ippool_alloc_call_env_t, lease_time,
NULL, T_INVALID, true, false, false) },
- { FR_CALL_ENV_OFFSET("requested_address", FR_TYPE_STRING, redis_ippool_alloc_call_env_t, requested_address,
+ { FR_CALL_ENV_OFFSET("requested_address", FR_TYPE_STRING, 0, redis_ippool_alloc_call_env_t, requested_address,
"%{%{Requested-IP-Address} || %{Net.Src.IP}}", T_DOUBLE_QUOTED_STRING,
true, true, false) },
- { FR_CALL_ENV_TMPL_ONLY_OFFSET("allocated_address_attr", FR_TYPE_ATTRIBUTE, redis_ippool_alloc_call_env_t,
+ { FR_CALL_ENV_TMPL_ONLY_OFFSET("allocated_address_attr", 0, CONF_FLAG_ATTRIBUTE, redis_ippool_alloc_call_env_t,
allocated_address_attr, NULL, T_INVALID, true ) },
- { FR_CALL_ENV_TMPL_ONLY_OFFSET("range_attr", FR_TYPE_ATTRIBUTE, redis_ippool_alloc_call_env_t,
+ { FR_CALL_ENV_TMPL_ONLY_OFFSET("range_attr", 0, CONF_FLAG_ATTRIBUTe, redis_ippool_alloc_call_env_t,
range_attr, "&reply.IP-Pool.Range", T_BARE_WORD, true) },
- { FR_CALL_ENV_TMPL_ONLY_OFFSET("expiry_attr", FR_TYPE_ATTRIBUTE, redis_ippool_alloc_call_env_t,
+ { FR_CALL_ENV_TMPL_ONLY_OFFSET("expiry_attr", 0, CONF_FLAG_ATTRIBUTE, redis_ippool_alloc_call_env_t,
expiry_attr, NULL, T_INVALID, false) },
CALL_ENV_TERMINATOR
}
static const call_env_method_t redis_ippool_update_method_env = {
FR_CALL_ENV_METHOD_OUT(redis_ippool_update_call_env_t),
.env = (call_env_parser_t[]) {
- { FR_CALL_ENV_OFFSET("pool_name", FR_TYPE_STRING, redis_ippool_update_call_env_t, pool_name,
+ { FR_CALL_ENV_OFFSET("pool_name", FR_TYPE_STRING, 0, redis_ippool_update_call_env_t, pool_name,
NULL, T_INVALID, true, false, true) },
- { FR_CALL_ENV_OFFSET("owner", FR_TYPE_STRING, redis_ippool_update_call_env_t, owner,
+ { FR_CALL_ENV_OFFSET("owner", FR_TYPE_STRING, 0, redis_ippool_update_call_env_t, owner,
NULL, T_INVALID, true, false, true) },
- { FR_CALL_ENV_OFFSET("gateway", FR_TYPE_STRING, redis_ippool_update_call_env_t, gateway_id,
+ { FR_CALL_ENV_OFFSET("gateway", FR_TYPE_STRING, 0, redis_ippool_update_call_env_t, gateway_id,
"", T_SINGLE_QUOTED_STRING, false, true, true ) },
- { FR_CALL_ENV_OFFSET("lease_time", FR_TYPE_UINT32, redis_ippool_update_call_env_t, lease_time,
+ { FR_CALL_ENV_OFFSET("lease_time", FR_TYPE_UINT32, 0, redis_ippool_update_call_env_t, lease_time,
NULL, T_INVALID, true, false, false) },
- { FR_CALL_ENV_OFFSET("requested_address", FR_TYPE_STRING, redis_ippool_update_call_env_t, requested_address,
+ { FR_CALL_ENV_OFFSET("requested_address", FR_TYPE_STRING, 0, redis_ippool_update_call_env_t, requested_address,
"%{%{Requested-IP-Address} || %{Net.Src.IP}}", T_DOUBLE_QUOTED_STRING,
true, true, false) },
- { FR_CALL_ENV_TMPL_ONLY_OFFSET("allocated_address_attr", FR_TYPE_ATTRIBUTE, redis_ippool_update_call_env_t,
+ { FR_CALL_ENV_TMPL_ONLY_OFFSET("allocated_address_attr", 0, CONF_FLAG_ATTRIBUTE, redis_ippool_update_call_env_t,
allocated_address_attr, NULL, T_INVALID, true ) },
- { FR_CALL_ENV_TMPL_ONLY_OFFSET("range_attr", FR_TYPE_ATTRIBUTE, redis_ippool_update_call_env_t,
+ { FR_CALL_ENV_TMPL_ONLY_OFFSET("range_attr", 0, CONF_FLAG_ATTRIBUTE, redis_ippool_update_call_env_t,
range_attr, "&reply.IP-Pool.Range", T_BARE_WORD, true) },
- { FR_CALL_ENV_TMPL_ONLY_OFFSET("expiry_attr", FR_TYPE_ATTRIBUTE, redis_ippool_update_call_env_t,
+ { FR_CALL_ENV_TMPL_ONLY_OFFSET("expiry_attr", 0, CONF_FLAG_ATTRIBUTE, redis_ippool_update_call_env_t,
expiry_attr, NULL, T_INVALID, false) },
CALL_ENV_TERMINATOR
}
static const call_env_method_t redis_ippool_release_method_env = {
FR_CALL_ENV_METHOD_OUT(redis_ippool_release_call_env_t),
.env = (call_env_parser_t[]) {
- { FR_CALL_ENV_OFFSET("pool_name", FR_TYPE_STRING, redis_ippool_release_call_env_t, pool_name,
+ { FR_CALL_ENV_OFFSET("pool_name", FR_TYPE_STRING, 0, redis_ippool_release_call_env_t, pool_name,
NULL, T_INVALID, true, false, true) },
- { FR_CALL_ENV_OFFSET("owner", FR_TYPE_STRING, redis_ippool_release_call_env_t, owner,
+ { FR_CALL_ENV_OFFSET("owner", FR_TYPE_STRING, 0, redis_ippool_release_call_env_t, owner,
NULL, T_INVALID, true, false, true) },
- { FR_CALL_ENV_OFFSET("gateway", FR_TYPE_STRING, redis_ippool_release_call_env_t, gateway_id,
+ { FR_CALL_ENV_OFFSET("gateway", FR_TYPE_STRING, 0, redis_ippool_release_call_env_t, gateway_id,
"", T_SINGLE_QUOTED_STRING, false, true, true ) },
- { FR_CALL_ENV_OFFSET("requested_address", FR_TYPE_STRING, redis_ippool_release_call_env_t, requested_address,
+ { FR_CALL_ENV_OFFSET("requested_address", FR_TYPE_STRING, 0, redis_ippool_release_call_env_t, requested_address,
"%{%{Requested-IP-Address} || %{Net.Src.IP}}", T_DOUBLE_QUOTED_STRING,
true, true, false) },
CALL_ENV_TERMINATOR
static const call_env_method_t redis_ippool_bulk_release_method_env = {
FR_CALL_ENV_METHOD_OUT(redis_ippool_bulk_release_call_env_t),
.env = (call_env_parser_t[]) {
- { FR_CALL_ENV_OFFSET("pool_name", FR_TYPE_STRING, redis_ippool_bulk_release_call_env_t, pool_name,
+ { FR_CALL_ENV_OFFSET("pool_name", FR_TYPE_STRING, 0, redis_ippool_bulk_release_call_env_t, pool_name,
NULL, T_INVALID, true, false, true) },
- { FR_CALL_ENV_OFFSET("gateway", FR_TYPE_STRING, redis_ippool_bulk_release_call_env_t, gateway_id,
+ { FR_CALL_ENV_OFFSET("gateway", FR_TYPE_STRING, 0, redis_ippool_bulk_release_call_env_t, gateway_id,
"", T_SINGLE_QUOTED_STRING, false, true, true ) },
CALL_ENV_TERMINATOR
}
} rlm_rediswho_t;
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) },
+ { FR_CONF_OFFSET("insert", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_XLAT, rlm_rediswho_t, insert) },
+ { FR_CONF_OFFSET("trim", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_rediswho_t, trim) }, /* required only if trim_count > 0 */
+ { FR_CONF_OFFSET("expire", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_XLAT, rlm_rediswho_t, expire) },
CONF_PARSER_TERMINATOR
};
static conf_parser_t module_config[] = {
REDIS_COMMON_CONFIG,
- { FR_CONF_OFFSET("trim_count", FR_TYPE_INT32, rlm_rediswho_t, trim_count), .dflt = "-1" },
+ { FR_CONF_OFFSET("trim_count", FR_TYPE_INT32, 0, rlm_rediswho_t, trim_count), .dflt = "-1" },
/*
* These all smash the same variables, because we don't care about them right now.
* In 3.1, we should have a way of saying "parse a set of sub-sections according to a template"
*/
- { FR_CONF_POINTER("Start", FR_TYPE_SUBSECTION, NULL), .subcs = section_config },
- { FR_CONF_POINTER("Interim-Update", FR_TYPE_SUBSECTION, NULL), .subcs = section_config },
- { FR_CONF_POINTER("Stop", FR_TYPE_SUBSECTION, NULL), .subcs = section_config },
- { FR_CONF_POINTER("Accounting-On", FR_TYPE_SUBSECTION, NULL), .subcs = section_config },
- { FR_CONF_POINTER("Accounting-Off", FR_TYPE_SUBSECTION, NULL), .subcs = section_config },
- { FR_CONF_POINTER("Failed", FR_TYPE_SUBSECTION, NULL), .subcs = section_config },
+ { FR_CONF_POINTER("Start", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = section_config },
+ { FR_CONF_POINTER("Interim-Update", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = section_config },
+ { FR_CONF_POINTER("Stop", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = section_config },
+ { FR_CONF_POINTER("Accounting-On", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = section_config },
+ { FR_CONF_POINTER("Accounting-Off", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = section_config },
+ { FR_CONF_POINTER("Failed", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = section_config },
CONF_PARSER_TERMINATOR
};
}
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" },
- { FR_CONF_OFFSET("header", FR_TYPE_STRING | FR_TYPE_MULTI, rlm_rest_section_t, headers) },
- { FR_CONF_OFFSET("body", FR_TYPE_STRING, rlm_rest_section_t, body_str), .dflt = "none" },
- { FR_CONF_OFFSET("data", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_rest_section_t, data) },
- { FR_CONF_OFFSET("force_to", FR_TYPE_STRING, rlm_rest_section_t, force_to_str) },
+ { FR_CONF_OFFSET("uri", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_rest_section_t, uri), .dflt = "" },
+ { FR_CONF_OFFSET("proxy", FR_TYPE_STRING, 0, rlm_rest_section_t, proxy), .func = rest_proxy_parse },
+ { FR_CONF_OFFSET("method", FR_TYPE_STRING, 0, rlm_rest_section_t, method_str), .dflt = "GET" },
+ { FR_CONF_OFFSET("header", FR_TYPE_STRING, CONF_FLAG_MULTI, rlm_rest_section_t, headers) },
+ { FR_CONF_OFFSET("body", FR_TYPE_STRING, 0, rlm_rest_section_t, body_str), .dflt = "none" },
+ { FR_CONF_OFFSET("data", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_rest_section_t, data) },
+ { FR_CONF_OFFSET("force_to", FR_TYPE_STRING, 0, rlm_rest_section_t, force_to_str) },
/* User authentication */
- { FR_CONF_OFFSET_IS_SET("auth", FR_TYPE_VOID, rlm_rest_section_t, auth),
+ { FR_CONF_OFFSET_IS_SET("auth", FR_TYPE_VOID, 0, rlm_rest_section_t, auth),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = http_auth_table, .len = &http_auth_table_len }, .dflt = "none" },
- { FR_CONF_OFFSET("username", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_rest_section_t, username) },
- { FR_CONF_OFFSET("password", FR_TYPE_STRING | FR_TYPE_SECRET | FR_TYPE_XLAT, rlm_rest_section_t, password) },
- { FR_CONF_OFFSET("require_auth", FR_TYPE_BOOL, rlm_rest_section_t, require_auth), .dflt = "no" },
+ { FR_CONF_OFFSET("username", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_rest_section_t, username) },
+ { FR_CONF_OFFSET("password", FR_TYPE_STRING, CONF_FLAG_SECRET | CONF_FLAG_XLAT, rlm_rest_section_t, password) },
+ { FR_CONF_OFFSET("require_auth", FR_TYPE_BOOL, 0, rlm_rest_section_t, require_auth), .dflt = "no" },
/* Transfer configuration */
- { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, rlm_rest_section_t, timeout), .dflt = "4.0" },
- { FR_CONF_OFFSET("chunk", FR_TYPE_UINT32, rlm_rest_section_t, chunk), .dflt = "0" },
- { FR_CONF_OFFSET("max_body_in", FR_TYPE_SIZE, rlm_rest_section_t, max_body_in), .dflt = "16k" },
+ { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, 0, rlm_rest_section_t, timeout), .dflt = "4.0" },
+ { FR_CONF_OFFSET("chunk", FR_TYPE_UINT32, 0, rlm_rest_section_t, chunk), .dflt = "0" },
+ { FR_CONF_OFFSET("max_body_in", FR_TYPE_SIZE, 0, rlm_rest_section_t, max_body_in), .dflt = "16k" },
/* TLS Parameters */
- { FR_CONF_OFFSET("tls", FR_TYPE_SUBSECTION, rlm_rest_section_t, tls), .subcs = (void const *) fr_curl_tls_config },
+ { FR_CONF_OFFSET("tls", 0, CONF_FLAG_SUBSECTION, rlm_rest_section_t, tls), .subcs = (void const *) fr_curl_tls_config },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t xlat_config[] = {
- { FR_CONF_OFFSET("proxy", FR_TYPE_STRING, rlm_rest_section_t, proxy), .func = rest_proxy_parse },
+ { FR_CONF_OFFSET("proxy", FR_TYPE_STRING, 0, rlm_rest_section_t, proxy), .func = rest_proxy_parse },
/* User authentication */
- { FR_CONF_OFFSET_IS_SET("auth", FR_TYPE_VOID, rlm_rest_section_t, auth),
+ { FR_CONF_OFFSET_IS_SET("auth", FR_TYPE_VOID, 0, rlm_rest_section_t, auth),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = http_auth_table, .len = &http_auth_table_len }, .dflt = "none" },
- { FR_CONF_OFFSET("header", FR_TYPE_STRING | FR_TYPE_MULTI, rlm_rest_section_t, headers) },
+ { FR_CONF_OFFSET("header", FR_TYPE_STRING, CONF_FLAG_MULTI, rlm_rest_section_t, headers) },
- { FR_CONF_OFFSET("username", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_rest_section_t, username) },
- { FR_CONF_OFFSET("password", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_rest_section_t, password) },
- { FR_CONF_OFFSET("require_auth", FR_TYPE_BOOL, rlm_rest_section_t, require_auth), .dflt = "no" },
+ { FR_CONF_OFFSET("username", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_rest_section_t, username) },
+ { FR_CONF_OFFSET("password", FR_TYPE_STRING, CONF_FLAG_SECRET | CONF_FLAG_XLAT, rlm_rest_section_t, password) },
+ { FR_CONF_OFFSET("require_auth", FR_TYPE_BOOL, 0, rlm_rest_section_t, require_auth), .dflt = "no" },
/* Transfer configuration */
- { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, rlm_rest_section_t, timeout), .dflt = "4.0" },
- { FR_CONF_OFFSET("chunk", FR_TYPE_UINT32, rlm_rest_section_t, chunk), .dflt = "0" },
+ { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, 0, rlm_rest_section_t, timeout), .dflt = "4.0" },
+ { FR_CONF_OFFSET("chunk", FR_TYPE_UINT32, 0, rlm_rest_section_t, chunk), .dflt = "0" },
/* TLS Parameters */
- { FR_CONF_OFFSET("tls", FR_TYPE_SUBSECTION, rlm_rest_section_t, tls), .subcs = (void const *) fr_curl_tls_config },
+ { FR_CONF_OFFSET("tls", 0, CONF_FLAG_SUBSECTION, rlm_rest_section_t, tls), .subcs = (void const *) fr_curl_tls_config },
CONF_PARSER_TERMINATOR
};
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),
+ { FR_CONF_DEPRECATED("connect_timeout", FR_TYPE_TIME_DELTA, 0, rlm_rest_t, connect_timeout) },
+ { FR_CONF_OFFSET("connect_proxy", FR_TYPE_STRING, 0, rlm_rest_t, connect_proxy), .func = rest_proxy_parse },
+ { FR_CONF_OFFSET("http_negotiation", FR_TYPE_VOID, 0, rlm_rest_t, http_negotiation),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = http_negotiation_table, .len = &http_negotiation_table_len }, .dflt = "default" },
- { FR_CONF_OFFSET("connection", FR_TYPE_SUBSECTION, rlm_rest_t, conn_config), .subcs = (void const *) fr_curl_conn_config },
+ { FR_CONF_OFFSET("connection", 0, CONF_FLAG_SUBSECTION, rlm_rest_t, conn_config), .subcs = (void const *) fr_curl_conn_config },
#ifdef CURLPIPE_MULTIPLEX
- { FR_CONF_OFFSET("multiplex", FR_TYPE_BOOL, rlm_rest_t, multiplex), .dflt = "yes" },
+ { FR_CONF_OFFSET("multiplex", FR_TYPE_BOOL, 0, rlm_rest_t, multiplex), .dflt = "yes" },
#endif
#ifndef NDEBUG
- { FR_CONF_OFFSET("fail_header_decode", FR_TYPE_BOOL, rlm_rest_t, fail_header_decode), .dflt = "no" },
- { FR_CONF_OFFSET("fail_body_decode", FR_TYPE_BOOL, rlm_rest_t, fail_body_decode), .dflt = "no" },
+ { FR_CONF_OFFSET("fail_header_decode", FR_TYPE_BOOL, 0, rlm_rest_t, fail_header_decode), .dflt = "no" },
+ { FR_CONF_OFFSET("fail_body_decode", FR_TYPE_BOOL, 0, rlm_rest_t, fail_body_decode), .dflt = "no" },
#endif
CONF_PARSER_TERMINATOR
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) },
- { FR_CONF_OFFSET("max_round_trips", FR_TYPE_UINT32, rlm_securid_t, max_trips_per_session), .dflt = "6" },
+ { FR_CONF_OFFSET("timer_expire", FR_TYPE_UINT32, 0, rlm_securid_t, timer_limit), .dflt = "600" },
+ { FR_CONF_OFFSET("max_sessions", FR_TYPE_UINT32, 0, rlm_securid_t, max_sessions), .dflt = "2048" },
+ { FR_CONF_OFFSET("max_trips_per_session", FR_TYPE_UINT32, 0, rlm_securid_t, max_trips_per_session) },
+ { FR_CONF_OFFSET("max_round_trips", FR_TYPE_UINT32, 0, rlm_securid_t, max_trips_per_session), .dflt = "6" },
CONF_PARSER_TERMINATOR
};
static size_t m3ua_traffic_mode_table_len = NUM_ELEMENTS(m3ua_traffic_mode_table);
static const conf_parser_t sctp_config[] = {
- { FR_CONF_OFFSET("server", FR_TYPE_COMBO_IP_ADDR, 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" },
+ { FR_CONF_OFFSET("server", FR_TYPE_COMBO_IP_ADDR, 0, rlm_sigtran_t, conn_conf.sctp_dst_ipaddr) },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, rlm_sigtran_t, conn_conf.sctp_dst_port), .dflt = "2905" },
- { FR_CONF_OFFSET("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, rlm_sigtran_t, conn_conf.sctp_src_ipaddr ) },
- { FR_CONF_OFFSET("src_port", FR_TYPE_UINT16, rlm_sigtran_t, conn_conf.sctp_src_port), .dflt = "0" },
+ { FR_CONF_OFFSET("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, rlm_sigtran_t, conn_conf.sctp_src_ipaddr ) },
+ { FR_CONF_OFFSET("src_port", FR_TYPE_UINT16, 0, rlm_sigtran_t, conn_conf.sctp_src_port), .dflt = "0" },
- { FR_CONF_OFFSET("timeout", FR_TYPE_UINT32, rlm_sigtran_t, conn_conf.sctp_timeout), .dflt = "5" },
+ { FR_CONF_OFFSET("timeout", FR_TYPE_UINT32, 0, rlm_sigtran_t, conn_conf.sctp_timeout), .dflt = "5" },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t m3ua_route[] = {
- { FR_CONF_OFFSET_IS_SET("dpc", FR_TYPE_UINT32, 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) },
+ { FR_CONF_OFFSET_IS_SET("dpc", FR_TYPE_UINT32, 0, sigtran_m3ua_route_t, dpc) },
+ { FR_CONF_OFFSET("opc", FR_TYPE_UINT32 , CONF_FLAG_MULTI, sigtran_m3ua_route_t, opc) },
+ { FR_CONF_OFFSET("si", FR_TYPE_UINT32 , CONF_FLAG_MULTI, sigtran_m3ua_route_t, si) },
CONF_PARSER_TERMINATOR
};
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" },
- { FR_CONF_OFFSET("ack_timeout", FR_TYPE_UINT32, rlm_sigtran_t, conn_conf.m3ua_ack_timeout), .dflt = "2" },
- { FR_CONF_OFFSET("beat_interval", FR_TYPE_UINT32, rlm_sigtran_t, conn_conf.m3ua_beat_interval), .dflt = "0" },
+ { FR_CONF_OFFSET("link_index", FR_TYPE_UINT16, 0, rlm_sigtran_t, conn_conf.m3ua_link_index) },
+ { FR_CONF_OFFSET("routing_ctx", FR_TYPE_UINT16, 0, rlm_sigtran_t, conn_conf.m3ua_routing_context) },
+ { FR_CONF_OFFSET("traffic_mode", FR_TYPE_STRING, 0, rlm_sigtran_t, conn_conf.m3ua_traffic_mode_str), .dflt = "loadshare" },
+ { FR_CONF_OFFSET("ack_timeout", FR_TYPE_UINT32, 0, rlm_sigtran_t, conn_conf.m3ua_ack_timeout), .dflt = "2" },
+ { FR_CONF_OFFSET("beat_interval", FR_TYPE_UINT32, 0, rlm_sigtran_t, conn_conf.m3ua_beat_interval), .dflt = "0" },
- { FR_CONF_OFFSET_IS_SET("route", FR_TYPE_SUBSECTION, rlm_sigtran_t, conn_conf.m3ua_routes), .subcs = (void const *) m3ua_route },
+ { FR_CONF_OFFSET_IS_SET("route", 0, CONF_FLAG_SUBSECTION, rlm_sigtran_t, conn_conf.m3ua_routes), .subcs = (void const *) m3ua_route },
CONF_PARSER_TERMINATOR
};
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) },
+ { FR_CONF_OFFSET("dpc", FR_TYPE_UINT32, CONF_FLAG_REQUIRED, rlm_sigtran_t, conn_conf.mtp3_dpc) },
+ { FR_CONF_OFFSET("opc", FR_TYPE_UINT32, CONF_FLAG_REQUIRED, rlm_sigtran_t, conn_conf.mtp3_opc) },
CONF_PARSER_TERMINATOR
};
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) },
- { FR_CONF_OFFSET_IS_SET("np", FR_TYPE_UINT8, sigtran_sccp_global_title_t, np) },
- { FR_CONF_OFFSET_IS_SET("es", FR_TYPE_UINT8, sigtran_sccp_global_title_t, es) },
+ { FR_CONF_OFFSET("address", FR_TYPE_STRING, 0, sigtran_sccp_global_title_t, address) },
+ { FR_CONF_OFFSET_IS_SET("tt", FR_TYPE_UINT8, 0, sigtran_sccp_global_title_t, tt) },
+ { FR_CONF_OFFSET_IS_SET("nai", FR_TYPE_UINT8, 0, sigtran_sccp_global_title_t, nai) },
+ { FR_CONF_OFFSET_IS_SET("np", FR_TYPE_UINT8, 0, sigtran_sccp_global_title_t, np) },
+ { FR_CONF_OFFSET_IS_SET("es", FR_TYPE_UINT8, 0, sigtran_sccp_global_title_t, es) },
CONF_PARSER_TERMINATOR
};
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 },
+ { FR_CONF_OFFSET_IS_SET("pc", FR_TYPE_UINT32, 0, sigtran_sccp_address_t, pc) },
+ { FR_CONF_OFFSET_IS_SET("ssn", FR_TYPE_UINT8, 0, sigtran_sccp_address_t, ssn) },
+ { FR_CONF_OFFSET_IS_SET("gt", 0, CONF_FLAG_SUBSECTION, sigtran_sccp_address_t, gt), .subcs = (void const *) sccp_global_title },
CONF_PARSER_TERMINATOR
};
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) },
+ { FR_CONF_OFFSET("ai8", FR_TYPE_BOOL, 0, rlm_sigtran_t, conn_conf.sccp_ai8) },
+ { FR_CONF_OFFSET("route_on_ssn", FR_TYPE_BOOL, 0, rlm_sigtran_t, conn_conf.sccp_route_on_ssn) },
- { FR_CONF_OFFSET("called", FR_TYPE_SUBSECTION, rlm_sigtran_t, conn_conf.sccp_called), .subcs = (void const *) sccp_address },
- { FR_CONF_OFFSET("calling", FR_TYPE_SUBSECTION, rlm_sigtran_t, conn_conf.sccp_calling), .subcs = (void const *) sccp_address },
+ { FR_CONF_OFFSET("called", 0, CONF_FLAG_SUBSECTION, rlm_sigtran_t, conn_conf.sccp_called), .subcs = (void const *) sccp_address },
+ { FR_CONF_OFFSET("calling", 0, CONF_FLAG_SUBSECTION, rlm_sigtran_t, conn_conf.sccp_calling), .subcs = (void const *) sccp_address },
CONF_PARSER_TERMINATOR
};
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},
+ { FR_CONF_OFFSET("version", 0, CONF_FLAG_TMPL, rlm_sigtran_t, conn_conf.map_version), .dflt = "2", .quote = T_BARE_WORD},
CONF_PARSER_TERMINATOR
};
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 },
- { FR_CONF_POINTER("sccp", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) sccp_config },
- { FR_CONF_POINTER("map", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) map_config },
+ { FR_CONF_POINTER("sctp", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) sctp_config },
+ { FR_CONF_POINTER("m3ua", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) m3ua_config },
+ { FR_CONF_POINTER("mtp3", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) mtp3_config },
+ { FR_CONF_POINTER("sccp", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) sccp_config },
+ { FR_CONF_POINTER("map", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) map_config },
- { FR_CONF_OFFSET("imsi", FR_TYPE_TMPL | FR_TYPE_REQUIRED, rlm_sigtran_t, imsi) },
+ { FR_CONF_OFFSET("imsi", 0, CONF_FLAG_TMPL | CONF_FLAG_REQUIRED, rlm_sigtran_t, imsi) },
CONF_PARSER_TERMINATOR
};
int ret = 0;
ssize_t slen;
int type = rule->type;
- bool tmpl = (type & FR_TYPE_TMPL);
+ bool tmpl = (type & CONF_FLAG_TMPL);
CONF_PAIR *cp = cf_item_to_pair(ci);
tmpl_t *vpt;
* A mapping of configuration file names to internal variables.
*/
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),
+ { FR_CONF_OFFSET("uri", FR_TYPE_STRING, 0, rlm_smtp_t, uri) },
+ { FR_CONF_OFFSET("template_directory", FR_TYPE_STRING, 0, rlm_smtp_t, template_dir) },
+ { FR_CONF_OFFSET("attachments", 0, CONF_FLAG_TMPL | CONF_FLAG_MULTI, rlm_smtp_t, attachments),
.func = cf_table_parse_tmpl, .dflt = "&SMTP-Attachments[*]", .quote = T_BARE_WORD},
- { FR_CONF_OFFSET("sender_address", FR_TYPE_TMPL | FR_TYPE_MULTI, rlm_smtp_t, sender_address),
+ { FR_CONF_OFFSET("sender_address", 0, CONF_FLAG_TMPL | CONF_FLAG_MULTI, rlm_smtp_t, sender_address),
.func = cf_table_parse_tmpl},
- { FR_CONF_OFFSET("envelope_address", FR_TYPE_STRING, rlm_smtp_t, envelope_address) },
- { FR_CONF_OFFSET("recipients", FR_TYPE_TMPL | FR_TYPE_MULTI, rlm_smtp_t, recipient_addrs),
+ { FR_CONF_OFFSET("envelope_address", FR_TYPE_STRING, 0, rlm_smtp_t, envelope_address) },
+ { FR_CONF_OFFSET("recipients", 0, CONF_FLAG_TMPL | CONF_FLAG_MULTI, rlm_smtp_t, recipient_addrs),
.func = cf_table_parse_tmpl, .dflt = "&SMTP-Recipients[*]", .quote = T_BARE_WORD},
- { FR_CONF_OFFSET("TO", FR_TYPE_TMPL | FR_TYPE_MULTI, rlm_smtp_t, to_addrs), .func = cf_table_parse_tmpl,
+ { FR_CONF_OFFSET("TO", 0, CONF_FLAG_TMPL | CONF_FLAG_MULTI, rlm_smtp_t, to_addrs), .func = cf_table_parse_tmpl,
.dflt = "&SMTP-TO[*]", .quote = T_BARE_WORD},
- { FR_CONF_OFFSET("CC", FR_TYPE_TMPL | FR_TYPE_MULTI, rlm_smtp_t, cc_addrs),
+ { FR_CONF_OFFSET("CC", 0, CONF_FLAG_TMPL | CONF_FLAG_MULTI, rlm_smtp_t, cc_addrs),
.func = cf_table_parse_tmpl, .dflt = "&SMTP-CC[*]", .quote = T_BARE_WORD},
- { FR_CONF_OFFSET("BCC", FR_TYPE_TMPL | FR_TYPE_MULTI, rlm_smtp_t, bcc_addrs),
+ { FR_CONF_OFFSET("BCC", 0, CONF_FLAG_TMPL | CONF_FLAG_MULTI, rlm_smtp_t, bcc_addrs),
.func = cf_table_parse_tmpl, .dflt = "&SMTP-BCC[*]", .quote = T_BARE_WORD },
- { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, rlm_smtp_t, timeout) },
- { FR_CONF_OFFSET("set_date", FR_TYPE_BOOL, rlm_smtp_t, set_date), .dflt = "yes" },
- { FR_CONF_OFFSET("tls", FR_TYPE_SUBSECTION, rlm_smtp_t, tls), .subcs = (void const *) fr_curl_tls_config },//!<loading the tls values
- { FR_CONF_OFFSET("connection", FR_TYPE_SUBSECTION, rlm_smtp_t, conn_config), .subcs = (void const *) fr_curl_conn_config },
+ { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, 0, rlm_smtp_t, timeout) },
+ { FR_CONF_OFFSET("set_date", FR_TYPE_BOOL, 0, rlm_smtp_t, set_date), .dflt = "yes" },
+ { FR_CONF_OFFSET("tls", 0, CONF_FLAG_SUBSECTION, rlm_smtp_t, tls), .subcs = (void const *) fr_curl_tls_config },//!<loading the tls values
+ { FR_CONF_OFFSET("connection", 0, CONF_FLAG_SUBSECTION, rlm_smtp_t, conn_config), .subcs = (void const *) fr_curl_conn_config },
CONF_PARSER_TERMINATOR
};
static const call_env_method_t method_env = {
FR_CALL_ENV_METHOD_OUT(rlm_smtp_env_t),
.env = (call_env_parser_t[]) {
- { FR_CALL_ENV_TMPL_OFFSET("username", FR_TYPE_STRING, rlm_smtp_env_t, username, username_tmpl, NULL,
+ { FR_CALL_ENV_TMPL_OFFSET("username", FR_TYPE_STRING, 0, rlm_smtp_env_t, username, username_tmpl, NULL,
T_DOUBLE_QUOTED_STRING, false, true, true) },
- { FR_CALL_ENV_OFFSET("password", FR_TYPE_STRING, rlm_smtp_env_t, password, NULL,
+ { FR_CALL_ENV_OFFSET("password", FR_TYPE_STRING, 0, rlm_smtp_env_t, password, NULL,
T_DOUBLE_QUOTED_STRING, false, true, true) },
CALL_ENV_TERMINATOR
}
} rlm_sometimes_t;
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" },
+ { FR_CONF_OFFSET("rcode", FR_TYPE_STRING, 0, rlm_sometimes_t, rcode_str), .dflt = "fail" },
+ { FR_CONF_OFFSET("key", 0, CONF_FLAG_TMPL | CONF_FLAG_ATTRIBUTE, rlm_sometimes_t, key), .dflt = "&User-Name", .quote = T_BARE_WORD },
+ { FR_CONF_OFFSET("percentage", FR_TYPE_FLOAT32, 0, rlm_sometimes_t, percentage), .dflt = "0" },
CONF_PARSER_TERMINATOR
};
static size_t verify_cert_table_len = NUM_ELEMENTS(verify_cert_table);
static conf_parser_t load_balance_dc_aware_config[] = {
- { FR_CONF_OFFSET("local_dc", FR_TYPE_STRING, 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" },
+ { FR_CONF_OFFSET("local_dc", FR_TYPE_STRING, 0, rlm_sql_cassandra_t, lbdc_local_dc) },
+ { FR_CONF_OFFSET("hosts_per_remote_dc", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, lbdc_hosts_per_remote_dc), .dflt = "0" },
+ { FR_CONF_OFFSET("allow_remote_dcs_for_local_cl", FR_TYPE_BOOL, 0, rlm_sql_cassandra_t, lbdc_allow_remote_dcs_for_local_cl), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
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" },
- { FR_CONF_OFFSET("update_rate", FR_TYPE_TIME_DELTA, rlm_sql_cassandra_t, lar_update_rate), .dflt = "0.1" },
- { FR_CONF_OFFSET("min_measured", FR_TYPE_UINT64, rlm_sql_cassandra_t, lar_min_measured), .dflt = "50" },
+ { FR_CONF_OFFSET("exclusion_threshold", FR_TYPE_FLOAT64, 0, rlm_sql_cassandra_t, lar_exclusion_threshold), .dflt = "2.0" },
+ { FR_CONF_OFFSET("scale", FR_TYPE_TIME_DELTA, 0, rlm_sql_cassandra_t, lar_scale), .dflt = "0.1" },
+ { FR_CONF_OFFSET("retry_period", FR_TYPE_TIME_DELTA, 0, rlm_sql_cassandra_t, lar_retry_period), .dflt = "10" },
+ { FR_CONF_OFFSET("update_rate", FR_TYPE_TIME_DELTA, 0, rlm_sql_cassandra_t, lar_update_rate), .dflt = "0.1" },
+ { FR_CONF_OFFSET("min_measured", FR_TYPE_UINT64, 0, rlm_sql_cassandra_t, lar_min_measured), .dflt = "50" },
CONF_PARSER_TERMINATOR
};
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) },
- { FR_CONF_OFFSET("private_key_password", FR_TYPE_STRING | FR_TYPE_SECRET, rlm_sql_cassandra_t, tls_private_key_password) },
+ { FR_CONF_OFFSET("ca_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_cassandra_t, tls_ca_file) },
+ { FR_CONF_OFFSET("certificate_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_cassandra_t, tls_certificate_file) },
+ { FR_CONF_OFFSET("private_key_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_cassandra_t, tls_private_key_file) },
+ { FR_CONF_OFFSET("private_key_password", FR_TYPE_STRING, CONF_FLAG_SECRET, rlm_sql_cassandra_t, tls_private_key_password) },
- { FR_CONF_OFFSET("verify_cert", FR_TYPE_STRING, rlm_sql_cassandra_t, tls_verify_cert_str) },
+ { FR_CONF_OFFSET("verify_cert", FR_TYPE_STRING, 0, rlm_sql_cassandra_t, tls_verify_cert_str) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t driver_config[] = {
- { FR_CONF_OFFSET("consistency", FR_TYPE_STRING, rlm_sql_cassandra_t, consistency_str), .dflt = "quorum" },
+ { FR_CONF_OFFSET("consistency", FR_TYPE_STRING, 0, rlm_sql_cassandra_t, consistency_str), .dflt = "quorum" },
- { FR_CONF_OFFSET("protocol_version", FR_TYPE_UINT32, rlm_sql_cassandra_t, protocol_version) },
+ { FR_CONF_OFFSET("protocol_version", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, protocol_version) },
- { FR_CONF_OFFSET("connections_per_host", FR_TYPE_UINT32, rlm_sql_cassandra_t, connections_per_host) },
+ { FR_CONF_OFFSET("connections_per_host", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, connections_per_host) },
/*
* The below functions was deprecated in 2.10
*/
#if (CASS_VERSION_MAJOR >= 2 && CASS_VERSION_MINOR >= 10)
- { FR_CONF_DEPRECATED("connections_per_host_max", FR_TYPE_UINT32, rlm_sql_cassandra_t, connections_per_host_max) },
- { FR_CONF_DEPRECATED("io_flush_requests_max", FR_TYPE_UINT32, rlm_sql_cassandra_t, io_flush_requests_max) },
+ { FR_CONF_DEPRECATED("connections_per_host_max", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, connections_per_host_max) },
+ { FR_CONF_DEPRECATED("io_flush_requests_max", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, io_flush_requests_max) },
- { FR_CONF_DEPRECATED("pending_requests_high", FR_TYPE_UINT32, rlm_sql_cassandra_t, pending_requests_high) },
- { FR_CONF_DEPRECATED("pending_requests_low", FR_TYPE_UINT32, rlm_sql_cassandra_t, pending_requests_low) },
+ { FR_CONF_DEPRECATED("pending_requests_high", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, pending_requests_high) },
+ { FR_CONF_DEPRECATED("pending_requests_low", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, pending_requests_low) },
- { FR_CONF_DEPRECATED("write_bytes_high", FR_TYPE_UINT32, rlm_sql_cassandra_t, write_bytes_high) },
- { FR_CONF_DEPRECATED("write_bytes_low", FR_TYPE_UINT32, rlm_sql_cassandra_t, write_bytes_low) },
+ { FR_CONF_DEPRECATED("write_bytes_high", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, write_bytes_high) },
+ { FR_CONF_DEPRECATED("write_bytes_low", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, write_bytes_low) },
- { FR_CONF_DEPRECATED("spawn_threshold", FR_TYPE_UINT32, rlm_sql_cassandra_t, spawn_threshold) },
- { FR_CONF_DEPRECATED("spawn_max", FR_TYPE_UINT32, rlm_sql_cassandra_t, spawn_max) },
- { FR_CONF_OFFSET_IS_SET("spawn_retry_delay", FR_TYPE_TIME_DELTA | FR_TYPE_DEPRECATED, rlm_sql_cassandra_t, spawn_retry_delay) },
+ { FR_CONF_DEPRECATED("spawn_threshold", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, spawn_threshold) },
+ { FR_CONF_DEPRECATED("spawn_max", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, spawn_max) },
+ { FR_CONF_DEPRECATED("spawn_retry_delay", FR_TYPE_TIME_DELTA, 0, rlm_sql_cassandra_t, spawn_retry_delay) },
#else
- { FR_CONF_OFFSET("connections_per_host_max", FR_TYPE_UINT32, rlm_sql_cassandra_t, connections_per_host_max) },
- { FR_CONF_OFFSET("io_flush_requests_max", FR_TYPE_UINT32, rlm_sql_cassandra_t, io_flush_requests_max) },
+ { FR_CONF_OFFSET("connections_per_host_max", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, connections_per_host_max) },
+ { FR_CONF_OFFSET("io_flush_requests_max", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, io_flush_requests_max) },
- { FR_CONF_OFFSET("pending_requests_high", FR_TYPE_UINT32, rlm_sql_cassandra_t, pending_requests_high) },
- { FR_CONF_OFFSET("pending_requests_low", FR_TYPE_UINT32, rlm_sql_cassandra_t, pending_requests_low) },
+ { FR_CONF_OFFSET("pending_requests_high", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, pending_requests_high) },
+ { FR_CONF_OFFSET("pending_requests_low", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, pending_requests_low) },
- { FR_CONF_OFFSET("write_bytes_high", FR_TYPE_UINT32, rlm_sql_cassandra_t, write_bytes_high) },
- { FR_CONF_OFFSET("write_bytes_low", FR_TYPE_UINT32, rlm_sql_cassandra_t, write_bytes_low) },
+ { FR_CONF_OFFSET("write_bytes_high", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, write_bytes_high) },
+ { FR_CONF_OFFSET("write_bytes_low", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, write_bytes_low) },
- { FR_CONF_OFFSET("spawn_threshold", FR_TYPE_UINT32, rlm_sql_cassandra_t, spawn_threshold) },
- { FR_CONF_OFFSET("spawn_max", FR_TYPE_UINT32, rlm_sql_cassandra_t, spawn_max) },
- { FR_CONF_OFFSET_IS_SET("spawn_retry_delay", FR_TYPE_TIME_DELTA, rlm_sql_cassandra_t, spawn_retry_delay) },
+ { FR_CONF_OFFSET("spawn_threshold", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, spawn_threshold) },
+ { FR_CONF_OFFSET("spawn_max", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, spawn_max) },
+ { FR_CONF_OFFSET_IS_SET("spawn_retry_delay", FR_TYPE_TIME_DELTA, 0, rlm_sql_cassandra_t, spawn_retry_delay) },
#endif
- { FR_CONF_OFFSET("io_threads", FR_TYPE_UINT32, rlm_sql_cassandra_t, io_threads) },
- { FR_CONF_OFFSET("io_queue_size", FR_TYPE_UINT32, rlm_sql_cassandra_t, io_queue_size) },
+ { FR_CONF_OFFSET("io_threads", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, io_threads) },
+ { FR_CONF_OFFSET("io_queue_size", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, io_queue_size) },
- { FR_CONF_OFFSET("event_queue_size", FR_TYPE_UINT32, rlm_sql_cassandra_t, event_queue_size) },
+ { FR_CONF_OFFSET("event_queue_size", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, event_queue_size) },
- { FR_CONF_POINTER("load_balance_dc_aware", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) load_balance_dc_aware_config },
- { FR_CONF_OFFSET("load_balance_round_robin", FR_TYPE_BOOL, rlm_sql_cassandra_t, load_balance_round_robin), .dflt = "no" },
+ { FR_CONF_POINTER("load_balance_dc_aware", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) load_balance_dc_aware_config },
+ { FR_CONF_OFFSET("load_balance_round_robin", FR_TYPE_BOOL, 0, rlm_sql_cassandra_t, load_balance_round_robin), .dflt = "no" },
- { FR_CONF_OFFSET("token_aware_routing", FR_TYPE_BOOL, rlm_sql_cassandra_t, token_aware_routing), .dflt = "yes" },
- { FR_CONF_POINTER("latency_aware_routing", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) latency_aware_routing_config },
+ { FR_CONF_OFFSET("token_aware_routing", FR_TYPE_BOOL, 0, rlm_sql_cassandra_t, token_aware_routing), .dflt = "yes" },
+ { FR_CONF_POINTER("latency_aware_routing", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) latency_aware_routing_config },
- { FR_CONF_OFFSET("tcp_keepalive", FR_TYPE_UINT32, rlm_sql_cassandra_t, tcp_keepalive) },
- { FR_CONF_OFFSET("tcp_nodelay", FR_TYPE_BOOL, rlm_sql_cassandra_t, tcp_nodelay), .dflt = "no" },
+ { FR_CONF_OFFSET("tcp_keepalive", FR_TYPE_UINT32, 0, rlm_sql_cassandra_t, tcp_keepalive) },
+ { FR_CONF_OFFSET("tcp_nodelay", FR_TYPE_BOOL, 0, rlm_sql_cassandra_t, tcp_nodelay), .dflt = "no" },
- { FR_CONF_POINTER("tls", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) tls_config },
+ { FR_CONF_POINTER("tls", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) tls_config },
CONF_PARSER_TERMINATOR
};
} rlm_sql_mysql_t;
static conf_parser_t tls_config[] = {
- { FR_CONF_OFFSET("ca_file", FR_TYPE_FILE_INPUT, rlm_sql_mysql_t, tls_ca_file) },
- { FR_CONF_OFFSET("ca_path", FR_TYPE_FILE_INPUT, rlm_sql_mysql_t, tls_ca_path) },
- { FR_CONF_OFFSET("certificate_file", FR_TYPE_FILE_INPUT, rlm_sql_mysql_t, tls_certificate_file) },
- { FR_CONF_OFFSET("private_key_file", FR_TYPE_FILE_INPUT, rlm_sql_mysql_t, tls_private_key_file) },
+ { FR_CONF_OFFSET("ca_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_mysql_t, tls_ca_file) },
+ { FR_CONF_OFFSET("ca_path", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_mysql_t, tls_ca_path) },
+ { FR_CONF_OFFSET("certificate_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_mysql_t, tls_certificate_file) },
+ { FR_CONF_OFFSET("private_key_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_mysql_t, tls_private_key_file) },
#if HAVE_CRL_OPTIONS
- { FR_CONF_OFFSET("crl_file", FR_TYPE_FILE_INPUT, rlm_sql_mysql_t, tls_crl_file) },
- { FR_CONF_OFFSET("crl_path", FR_TYPE_FILE_INPUT, rlm_sql_mysql_t, tls_crl_path) },
+ { FR_CONF_OFFSET("crl_file", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_mysql_t, tls_crl_file) },
+ { FR_CONF_OFFSET("crl_path", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_sql_mysql_t, tls_crl_path) },
#endif
/*
* MySQL Specific TLS attributes
*/
- { FR_CONF_OFFSET("cipher", FR_TYPE_STRING, rlm_sql_mysql_t, tls_cipher) },
+ { FR_CONF_OFFSET("cipher", FR_TYPE_STRING, 0, rlm_sql_mysql_t, tls_cipher) },
/*
* The closest thing we have to these options in other modules is
* has provided an invalid list of flags.
*/
#if HAVE_TLS_OPTIONS
- { FR_CONF_OFFSET("tls_required", FR_TYPE_BOOL, rlm_sql_mysql_t, tls_required) },
+ { FR_CONF_OFFSET("tls_required", FR_TYPE_BOOL, 0, rlm_sql_mysql_t, tls_required) },
# if HAVE_TLS_VERIFY_OPTIONS
- { FR_CONF_OFFSET("check_cert", FR_TYPE_BOOL, rlm_sql_mysql_t, tls_check_cert) },
- { FR_CONF_OFFSET("check_cert_cn", FR_TYPE_BOOL, rlm_sql_mysql_t, tls_check_cert_cn) },
+ { FR_CONF_OFFSET("check_cert", FR_TYPE_BOOL, 0, rlm_sql_mysql_t, tls_check_cert) },
+ { FR_CONF_OFFSET("check_cert_cn", FR_TYPE_BOOL, 0, rlm_sql_mysql_t, tls_check_cert_cn) },
# endif
#endif
CONF_PARSER_TERMINATOR
};
static const conf_parser_t driver_config[] = {
- { FR_CONF_POINTER("tls", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) tls_config },
+ { FR_CONF_POINTER("tls", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) tls_config },
- { FR_CONF_OFFSET("warnings", FR_TYPE_STRING, rlm_sql_mysql_t, warnings_str), .dflt = "auto" },
+ { FR_CONF_OFFSET("warnings", FR_TYPE_STRING, 0, rlm_sql_mysql_t, warnings_str), .dflt = "auto" },
CONF_PARSER_TERMINATOR
};
} rlm_sql_oracle_conn_t;
static const conf_parser_t spool_config[] = {
- { FR_CONF_OFFSET("stmt_cache_size", FR_TYPE_UINT32, 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" },
- { FR_CONF_OFFSET("max", FR_TYPE_UINT32, rlm_sql_oracle_t, spool_max), .dflt = "2" },
- { FR_CONF_OFFSET("inc", FR_TYPE_UINT32, rlm_sql_oracle_t, spool_inc), .dflt = "1" },
+ { FR_CONF_OFFSET("stmt_cache_size", FR_TYPE_UINT32, 0, rlm_sql_oracle_t, stmt_cache_size), .dflt = "32" },
+ { FR_CONF_OFFSET("timeout", FR_TYPE_UINT32, 0, rlm_sql_oracle_t, spool_timeout), .dflt = "0" },
+ { FR_CONF_OFFSET("min", FR_TYPE_UINT32, 0, rlm_sql_oracle_t, spool_min), .dflt = "1" },
+ { FR_CONF_OFFSET("max", FR_TYPE_UINT32, 0, rlm_sql_oracle_t, spool_max), .dflt = "2" },
+ { FR_CONF_OFFSET("inc", FR_TYPE_UINT32, 0, rlm_sql_oracle_t, spool_inc), .dflt = "1" },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t driver_config[] = {
- { FR_CONF_POINTER("spool", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) spool_config },
+ { FR_CONF_POINTER("spool", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) spool_config },
CONF_PARSER_TERMINATOR
};
} rlm_sql_postgres_conn_t;
static conf_parser_t driver_config[] = {
- { FR_CONF_OFFSET("send_application_name", FR_TYPE_BOOL, rlm_sql_postgresql_t, send_application_name), .dflt = "yes" },
+ { FR_CONF_OFFSET("send_application_name", FR_TYPE_BOOL, 0, rlm_sql_postgresql_t, send_application_name), .dflt = "yes" },
CONF_PARSER_TERMINATOR
};
} rlm_sql_sqlite_t;
static const conf_parser_t driver_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_FILE_OUTPUT | FR_TYPE_REQUIRED, rlm_sql_sqlite_t, filename) },
+ { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_OUTPUT | CONF_FLAG_REQUIRED, rlm_sql_sqlite_t, filename) },
CONF_PARSER_TERMINATOR
};
* So we can do pass2 xlat checks on the queries.
*/
static const conf_parser_t query_config[] = {
- { FR_CONF_OFFSET("query", FR_TYPE_STRING | FR_TYPE_XLAT | FR_TYPE_MULTI, rlm_sql_config_t, accounting.query) },
+ { FR_CONF_OFFSET("query", FR_TYPE_STRING, CONF_FLAG_MULTI | CONF_FLAG_XLAT, rlm_sql_config_t, accounting.query) },
CONF_PARSER_TERMINATOR
};
* helps the average case.
*/
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 },
- { FR_CONF_POINTER("interim-update", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) query_config },
- { FR_CONF_POINTER("stop", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) query_config },
+ { FR_CONF_POINTER("accounting-on", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) query_config },
+ { FR_CONF_POINTER("accounting-off", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) query_config },
+ { FR_CONF_POINTER("start", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) query_config },
+ { FR_CONF_POINTER("interim-update", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) query_config },
+ { FR_CONF_POINTER("stop", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) query_config },
CONF_PARSER_TERMINATOR
};
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) },
+ { FR_CONF_OFFSET("reference", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sql_config_t, accounting.reference), .dflt = ".query" },
+ { FR_CONF_OFFSET("logfile", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sql_config_t, accounting.logfile) },
- { FR_CONF_POINTER("type", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) type_config },
+ { FR_CONF_POINTER("type", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) type_config },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t postauth_config[] = {
- { FR_CONF_OFFSET("reference", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sql_config_t, postauth.reference), .dflt = ".query" },
- { FR_CONF_OFFSET("logfile", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sql_config_t, postauth.logfile) },
+ { FR_CONF_OFFSET("reference", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sql_config_t, postauth.reference), .dflt = ".query" },
+ { FR_CONF_OFFSET("logfile", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sql_config_t, postauth.logfile) },
- { FR_CONF_OFFSET("query", FR_TYPE_STRING | FR_TYPE_XLAT | FR_TYPE_MULTI, rlm_sql_config_t, postauth.query) },
+ { FR_CONF_OFFSET("query", FR_TYPE_STRING, CONF_FLAG_MULTI | CONF_FLAG_XLAT, rlm_sql_config_t, postauth.query) },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("driver", FR_TYPE_VOID, rlm_sql_t, driver_submodule), .dflt = "null",
+ { FR_CONF_OFFSET("driver", FR_TYPE_VOID, 0, 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_CONF_OFFSET("port", FR_TYPE_UINT32, rlm_sql_config_t, sql_port), .dflt = "0" },
- { FR_CONF_OFFSET("login", FR_TYPE_STRING, rlm_sql_config_t, sql_login), .dflt = "" },
- { FR_CONF_OFFSET("password", FR_TYPE_STRING | FR_TYPE_SECRET, rlm_sql_config_t, sql_password), .dflt = "" },
- { FR_CONF_OFFSET("radius_db", FR_TYPE_STRING, rlm_sql_config_t, sql_db), .dflt = "radius" },
- { FR_CONF_OFFSET("read_groups", FR_TYPE_BOOL, rlm_sql_config_t, read_groups), .dflt = "yes" },
- { FR_CONF_OFFSET("sql_user_name", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sql_config_t, query_user), .dflt = "" },
- { FR_CONF_OFFSET("group_attribute", FR_TYPE_STRING, rlm_sql_config_t, group_attribute) },
- { FR_CONF_OFFSET("logfile", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sql_config_t, logfile) },
- { FR_CONF_OFFSET("open_query", FR_TYPE_STRING, rlm_sql_config_t, connect_query) },
-
- { FR_CONF_OFFSET("authorize_check_query", FR_TYPE_STRING | FR_TYPE_XLAT | FR_TYPE_NOT_EMPTY, rlm_sql_config_t, authorize_check_query) },
- { FR_CONF_OFFSET("authorize_reply_query", FR_TYPE_STRING | FR_TYPE_XLAT | FR_TYPE_NOT_EMPTY, rlm_sql_config_t, authorize_reply_query) },
-
- { FR_CONF_OFFSET("authorize_group_check_query", FR_TYPE_STRING | FR_TYPE_XLAT | FR_TYPE_NOT_EMPTY, rlm_sql_config_t, authorize_group_check_query) },
- { FR_CONF_OFFSET("authorize_group_reply_query", FR_TYPE_STRING | FR_TYPE_XLAT | FR_TYPE_NOT_EMPTY, rlm_sql_config_t, authorize_group_reply_query) },
- { FR_CONF_OFFSET("group_membership_query", FR_TYPE_STRING | FR_TYPE_XLAT | FR_TYPE_NOT_EMPTY, rlm_sql_config_t, groupmemb_query) },
- { FR_CONF_OFFSET("safe_characters", FR_TYPE_STRING, rlm_sql_config_t, allowed_chars), .dflt = "@abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-_: /" },
+ { FR_CONF_OFFSET("server", FR_TYPE_STRING, 0, rlm_sql_config_t, sql_server), .dflt = "" }, /* Must be zero length so drivers can determine if it was set */
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT32, 0, rlm_sql_config_t, sql_port), .dflt = "0" },
+ { FR_CONF_OFFSET("login", FR_TYPE_STRING, 0, rlm_sql_config_t, sql_login), .dflt = "" },
+ { FR_CONF_OFFSET("password", FR_TYPE_STRING, CONF_FLAG_SECRET, rlm_sql_config_t, sql_password), .dflt = "" },
+ { FR_CONF_OFFSET("radius_db", FR_TYPE_STRING, 0, rlm_sql_config_t, sql_db), .dflt = "radius" },
+ { FR_CONF_OFFSET("read_groups", FR_TYPE_BOOL, 0, rlm_sql_config_t, read_groups), .dflt = "yes" },
+ { FR_CONF_OFFSET("sql_user_name", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sql_config_t, query_user), .dflt = "" },
+ { FR_CONF_OFFSET("group_attribute", FR_TYPE_STRING, 0, rlm_sql_config_t, group_attribute) },
+ { FR_CONF_OFFSET("logfile", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sql_config_t, logfile) },
+ { FR_CONF_OFFSET("open_query", FR_TYPE_STRING, 0, rlm_sql_config_t, connect_query) },
+
+ { FR_CONF_OFFSET("authorize_check_query", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY | CONF_FLAG_XLAT, rlm_sql_config_t, authorize_check_query) },
+ { FR_CONF_OFFSET("authorize_reply_query", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY | CONF_FLAG_XLAT, rlm_sql_config_t, authorize_reply_query) },
+
+ { FR_CONF_OFFSET("authorize_group_check_query", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY | CONF_FLAG_XLAT, rlm_sql_config_t, authorize_group_check_query) },
+ { FR_CONF_OFFSET("authorize_group_reply_query", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY | CONF_FLAG_XLAT, rlm_sql_config_t, authorize_group_reply_query) },
+ { FR_CONF_OFFSET("group_membership_query", FR_TYPE_STRING, CONF_FLAG_NOT_EMPTY | CONF_FLAG_XLAT, rlm_sql_config_t, groupmemb_query) },
+ { FR_CONF_OFFSET("safe_characters", FR_TYPE_STRING, 0, rlm_sql_config_t, allowed_chars), .dflt = "@abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-_: /" },
/*
* This only works for a few drivers.
*/
- { FR_CONF_OFFSET("query_timeout", FR_TYPE_TIME_DELTA, rlm_sql_config_t, query_timeout) },
+ { FR_CONF_OFFSET("query_timeout", FR_TYPE_TIME_DELTA, 0, rlm_sql_config_t, query_timeout) },
- { FR_CONF_POINTER("accounting", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) acct_config },
+ { FR_CONF_POINTER("accounting", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) acct_config },
- { FR_CONF_POINTER("post-auth", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) postauth_config },
+ { FR_CONF_POINTER("post-auth", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) postauth_config },
CONF_PARSER_TERMINATOR
};
} rlm_sqlcounter_t;
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("sql_module_instance", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_sqlcounter_t, sqlmod_inst) },
+ { FR_CONF_OFFSET("sql_module_instance", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_sqlcounter_t, sqlmod_inst) },
- { FR_CONF_OFFSET("query", FR_TYPE_STRING | FR_TYPE_XLAT | FR_TYPE_REQUIRED, rlm_sqlcounter_t, query) },
- { FR_CONF_OFFSET("reset", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_sqlcounter_t, reset) },
+ { FR_CONF_OFFSET("query", FR_TYPE_STRING, CONF_FLAG_XLAT | CONF_FLAG_REQUIRED, rlm_sqlcounter_t, query) },
+ { FR_CONF_OFFSET("reset", FR_TYPE_STRING, CONF_FLAG_REQUIRED, rlm_sqlcounter_t, reset) },
- { FR_CONF_OFFSET("key", FR_TYPE_TMPL | FR_TYPE_NOT_EMPTY, rlm_sqlcounter_t, key), .dflt = "%{%{Stripped-User-Name} || %{User-Name}}", .quote = T_DOUBLE_QUOTED_STRING },
+ { FR_CONF_OFFSET("key", 0, CONF_FLAG_TMPL | CONF_FLAG_NOT_EMPTY, rlm_sqlcounter_t, key), .dflt = "%{%{Stripped-User-Name} || %{User-Name}}", .quote = T_DOUBLE_QUOTED_STRING },
- { FR_CONF_OFFSET("reset_period_start_name", FR_TYPE_TMPL | FR_TYPE_ATTRIBUTE, rlm_sqlcounter_t, start_attr),
+ { FR_CONF_OFFSET("reset_period_start_name", 0, CONF_FLAG_TMPL | CONF_FLAG_ATTRIBUTE, rlm_sqlcounter_t, start_attr),
.dflt = "&control.${.:instance}-Start" },
- { FR_CONF_OFFSET("reset_period_end_name", FR_TYPE_TMPL | FR_TYPE_ATTRIBUTE, rlm_sqlcounter_t, end_attr),
+ { FR_CONF_OFFSET("reset_period_end_name", 0, CONF_FLAG_TMPL | CONF_FLAG_ATTRIBUTE, rlm_sqlcounter_t, end_attr),
.dflt = "&control.${.:instance}-End" },
/* Just used to register a paircmp against */
- { FR_CONF_OFFSET("counter_name", FR_TYPE_TMPL | FR_TYPE_ATTRIBUTE | FR_TYPE_REQUIRED, rlm_sqlcounter_t, paircmp_attr) },
- { FR_CONF_OFFSET("check_name", FR_TYPE_TMPL | FR_TYPE_ATTRIBUTE | FR_TYPE_REQUIRED, rlm_sqlcounter_t, limit_attr) },
+ { FR_CONF_OFFSET("counter_name", 0, CONF_FLAG_TMPL | CONF_FLAG_ATTRIBUTE | CONF_FLAG_REQUIRED, rlm_sqlcounter_t, paircmp_attr) },
+ { FR_CONF_OFFSET("check_name", 0, CONF_FLAG_TMPL | CONF_FLAG_ATTRIBUTE | CONF_FLAG_REQUIRED, rlm_sqlcounter_t, limit_attr) },
/* Attribute to write remaining session to */
- { FR_CONF_OFFSET("reply_name", FR_TYPE_TMPL | FR_TYPE_ATTRIBUTE, rlm_sqlcounter_t, reply_attr) },
+ { FR_CONF_OFFSET("reply_name", 0, CONF_FLAG_TMPL | CONF_FLAG_ATTRIBUTE, rlm_sqlcounter_t, reply_attr) },
CONF_PARSER_TERMINATOR
};
} rlm_sqlippool_t;
static conf_parser_t message_config[] = {
- { FR_CONF_OFFSET("exists", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, log_exists) },
- { FR_CONF_OFFSET("success", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, log_success) },
- { FR_CONF_OFFSET("clear", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, log_clear) },
- { FR_CONF_OFFSET("failed", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, log_failed) },
- { FR_CONF_OFFSET("nopool", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, log_nopool) },
+ { FR_CONF_OFFSET("exists", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, log_exists) },
+ { FR_CONF_OFFSET("success", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, log_success) },
+ { FR_CONF_OFFSET("clear", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, log_clear) },
+ { FR_CONF_OFFSET("failed", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, log_failed) },
+ { FR_CONF_OFFSET("nopool", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, log_nopool) },
CONF_PARSER_TERMINATOR
};
static conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("sql_module_instance", FR_TYPE_STRING, rlm_sqlippool_t, sql_name), .dflt = "sql" },
+ { FR_CONF_OFFSET("sql_module_instance", FR_TYPE_STRING, 0, rlm_sqlippool_t, sql_name), .dflt = "sql" },
- { FR_CONF_OFFSET("lease_duration", FR_TYPE_UINT32, rlm_sqlippool_t, lease_duration), .dflt = "86400" },
+ { FR_CONF_OFFSET("lease_duration", FR_TYPE_UINT32, 0, rlm_sqlippool_t, lease_duration), .dflt = "86400" },
- { FR_CONF_OFFSET("pool_name", FR_TYPE_STRING, rlm_sqlippool_t, pool_name) },
+ { FR_CONF_OFFSET("pool_name", FR_TYPE_STRING, 0, rlm_sqlippool_t, pool_name) },
- { FR_CONF_OFFSET("allocated_address_attr", FR_TYPE_STRING | FR_TYPE_REQUIRED | FR_TYPE_NOT_EMPTY, rlm_sqlippool_t, allocated_address_attr) },
+ { FR_CONF_OFFSET("allocated_address_attr", FR_TYPE_STRING, CONF_FLAG_REQUIRED | CONF_FLAG_NOT_EMPTY, rlm_sqlippool_t, allocated_address_attr) },
- { FR_CONF_OFFSET("requested_address", FR_TYPE_TMPL, rlm_sqlippool_t, requested_address) },
+ { FR_CONF_OFFSET("requested_address", 0, CONF_FLAG_TMPL, rlm_sqlippool_t, requested_address) },
- { FR_CONF_OFFSET("default_pool", FR_TYPE_STRING, rlm_sqlippool_t, defaultpool), .dflt = "main_pool" },
+ { FR_CONF_OFFSET("default_pool", FR_TYPE_STRING, 0, rlm_sqlippool_t, defaultpool), .dflt = "main_pool" },
- { FR_CONF_OFFSET("alloc_begin", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, alloc_begin), .dflt = "START TRANSACTION" },
+ { FR_CONF_OFFSET("alloc_begin", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, alloc_begin), .dflt = "START TRANSACTION" },
- { FR_CONF_OFFSET("alloc_existing", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, alloc_existing) },
+ { FR_CONF_OFFSET("alloc_existing", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, alloc_existing) },
- { FR_CONF_OFFSET("alloc_requested", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, alloc_requested) },
+ { FR_CONF_OFFSET("alloc_requested", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, alloc_requested) },
- { FR_CONF_OFFSET("alloc_find", FR_TYPE_STRING | FR_TYPE_XLAT | FR_TYPE_REQUIRED, rlm_sqlippool_t, alloc_find) },
+ { FR_CONF_OFFSET("alloc_find", FR_TYPE_STRING, CONF_FLAG_XLAT | CONF_FLAG_REQUIRED, rlm_sqlippool_t, alloc_find) },
- { FR_CONF_OFFSET("alloc_update", FR_TYPE_STRING | FR_TYPE_XLAT , rlm_sqlippool_t, alloc_update) },
+ { FR_CONF_OFFSET("alloc_update", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, alloc_update) },
- { FR_CONF_OFFSET("alloc_commit", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, alloc_commit), .dflt = "COMMIT" },
+ { FR_CONF_OFFSET("alloc_commit", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, alloc_commit), .dflt = "COMMIT" },
- { FR_CONF_OFFSET("pool_check", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, pool_check) },
+ { FR_CONF_OFFSET("pool_check", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, pool_check) },
- { FR_CONF_OFFSET("update_begin", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, update_begin) },
+ { FR_CONF_OFFSET("update_begin", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, update_begin) },
- { FR_CONF_OFFSET("update_free", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, update_free) },
+ { FR_CONF_OFFSET("update_free", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, update_free) },
- { FR_CONF_OFFSET("update_update", FR_TYPE_STRING | FR_TYPE_XLAT , rlm_sqlippool_t, update_update) },
+ { FR_CONF_OFFSET("update_update", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, update_update) },
- { FR_CONF_OFFSET("update_commit", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, update_commit) },
+ { FR_CONF_OFFSET("update_commit", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, update_commit) },
- { FR_CONF_OFFSET("release_begin", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, release_begin) },
+ { FR_CONF_OFFSET("release_begin", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, release_begin) },
- { FR_CONF_OFFSET("release_clear", FR_TYPE_STRING | FR_TYPE_XLAT , rlm_sqlippool_t, release_clear) },
+ { FR_CONF_OFFSET("release_clear", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, release_clear) },
- { FR_CONF_OFFSET("release_commit", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, release_commit) },
+ { FR_CONF_OFFSET("release_commit", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, release_commit) },
- { FR_CONF_OFFSET("bulk_release_begin", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, bulk_release_begin) },
+ { FR_CONF_OFFSET("bulk_release_begin", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, bulk_release_begin) },
- { FR_CONF_OFFSET("bulk_release_clear", FR_TYPE_STRING | FR_TYPE_XLAT , rlm_sqlippool_t, bulk_release_clear) },
+ { FR_CONF_OFFSET("bulk_release_clear", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, bulk_release_clear) },
- { FR_CONF_OFFSET("bulk_release_commit", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, bulk_release_commit) },
+ { FR_CONF_OFFSET("bulk_release_commit", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, bulk_release_commit) },
- { FR_CONF_OFFSET("mark_begin", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, mark_begin) },
+ { FR_CONF_OFFSET("mark_begin", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, mark_begin) },
- { FR_CONF_OFFSET("mark_update", FR_TYPE_STRING | FR_TYPE_XLAT , rlm_sqlippool_t, mark_update) },
+ { FR_CONF_OFFSET("mark_update", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, mark_update) },
- { FR_CONF_OFFSET("mark_commit", FR_TYPE_STRING | FR_TYPE_XLAT, rlm_sqlippool_t, mark_commit) },
+ { FR_CONF_OFFSET("mark_commit", FR_TYPE_STRING, CONF_FLAG_XLAT, rlm_sqlippool_t, mark_commit) },
- { FR_CONF_POINTER("messages", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) message_config },
+ { FR_CONF_POINTER("messages", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) message_config },
CONF_PARSER_TERMINATOR
};
* Retransmission intervals for the packets we support.
*/
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) },
- { FR_CONF_OFFSET("max_rtx_duration", FR_TYPE_TIME_DELTA, fr_retry_config_t, mrd), .dflt = STRINGIFY(30) },
+ { FR_CONF_OFFSET("initial_rtx_time", FR_TYPE_TIME_DELTA, 0, fr_retry_config_t, irt), .dflt = STRINGIFY(2) },
+ { FR_CONF_OFFSET("max_rtx_time", FR_TYPE_TIME_DELTA, 0, fr_retry_config_t, mrt), .dflt = STRINGIFY(16) },
+ { FR_CONF_OFFSET("max_rtx_count", FR_TYPE_UINT32, 0, fr_retry_config_t, mrc), .dflt = STRINGIFY(5) },
+ { FR_CONF_OFFSET("max_rtx_duration", FR_TYPE_TIME_DELTA, 0, fr_retry_config_t, mrd), .dflt = STRINGIFY(30) },
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
static conf_parser_t const module_config[] = {
- { FR_CONF_OFFSET("transport", FR_TYPE_VOID, rlm_tacacs_t, io_submodule),
+ { FR_CONF_OFFSET("transport", FR_TYPE_VOID, 0, rlm_tacacs_t, io_submodule),
.func = module_rlm_submodule_parse },
- { FR_CONF_OFFSET("type", FR_TYPE_UINT32 | FR_TYPE_MULTI | FR_TYPE_NOT_EMPTY | FR_TYPE_REQUIRED, rlm_tacacs_t, types),
+ { FR_CONF_OFFSET("type", FR_TYPE_UINT32, CONF_FLAG_NOT_EMPTY | CONF_FLAG_MULTI | CONF_FLAG_REQUIRED, rlm_tacacs_t, types),
.func = type_parse },
- { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, rlm_tacacs_t, max_attributes), .dflt = STRINGIFY(FR_MAX_ATTRIBUTES) },
+ { FR_CONF_OFFSET("max_attributes", FR_TYPE_UINT32, 0, rlm_tacacs_t, max_attributes), .dflt = STRINGIFY(FR_MAX_ATTRIBUTES) },
- { FR_CONF_OFFSET("response_window", FR_TYPE_TIME_DELTA, rlm_tacacs_t, response_window), .dflt = STRINGIFY(20) },
+ { FR_CONF_OFFSET("response_window", FR_TYPE_TIME_DELTA, 0, rlm_tacacs_t, response_window), .dflt = STRINGIFY(20) },
- { FR_CONF_OFFSET("zombie_period", FR_TYPE_TIME_DELTA, rlm_tacacs_t, zombie_period), .dflt = STRINGIFY(40) },
+ { FR_CONF_OFFSET("zombie_period", FR_TYPE_TIME_DELTA, 0, rlm_tacacs_t, zombie_period), .dflt = STRINGIFY(40) },
- { FR_CONF_OFFSET("revive_interval", FR_TYPE_TIME_DELTA, rlm_tacacs_t, revive_interval) },
+ { FR_CONF_OFFSET("revive_interval", FR_TYPE_TIME_DELTA, 0, rlm_tacacs_t, revive_interval) },
- { FR_CONF_OFFSET("pool", FR_TYPE_SUBSECTION, rlm_tacacs_t, trunk_conf), .subcs = (void const *) fr_trunk_config, },
+ { FR_CONF_OFFSET("pool", 0, CONF_FLAG_SUBSECTION, rlm_tacacs_t, trunk_conf), .subcs = (void const *) fr_trunk_config, },
- { FR_CONF_OFFSET("retry", FR_TYPE_SUBSECTION, rlm_tacacs_t, retry), .subcs = (void const *) retry_config },
+ { FR_CONF_OFFSET("retry", 0, CONF_FLAG_SUBSECTION, rlm_tacacs_t, retry), .subcs = (void const *) retry_config },
CONF_PARSER_TERMINATOR
};
};
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) },
+ { FR_CONF_OFFSET("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, rlm_tacacs_tcp_t, dst_ipaddr), },
+ { FR_CONF_OFFSET("ipv4addr", FR_TYPE_IPV4_ADDR, 0, rlm_tacacs_tcp_t, dst_ipaddr) },
+ { FR_CONF_OFFSET("ipv6addr", FR_TYPE_IPV6_ADDR, 0, rlm_tacacs_tcp_t, dst_ipaddr) },
- { FR_CONF_OFFSET("port", FR_TYPE_UINT16, rlm_tacacs_tcp_t, dst_port) },
+ { FR_CONF_OFFSET("port", FR_TYPE_UINT16, 0, rlm_tacacs_tcp_t, dst_port) },
- { FR_CONF_OFFSET("secret", FR_TYPE_STRING, rlm_tacacs_tcp_t, secret) }, /* can be NULL */
+ { FR_CONF_OFFSET("secret", FR_TYPE_STRING, 0, rlm_tacacs_tcp_t, secret) }, /* can be NULL */
- { FR_CONF_OFFSET("interface", FR_TYPE_STRING, rlm_tacacs_tcp_t, interface) },
+ { FR_CONF_OFFSET("interface", FR_TYPE_STRING, 0, rlm_tacacs_tcp_t, interface) },
- { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, rlm_tacacs_tcp_t, recv_buff) },
- { FR_CONF_OFFSET_IS_SET("send_buff", FR_TYPE_UINT32, rlm_tacacs_tcp_t, send_buff) },
+ { FR_CONF_OFFSET_IS_SET("recv_buff", FR_TYPE_UINT32, 0, rlm_tacacs_tcp_t, recv_buff) },
+ { FR_CONF_OFFSET_IS_SET("send_buff", FR_TYPE_UINT32, 0, rlm_tacacs_tcp_t, send_buff) },
- { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, rlm_tacacs_tcp_t, max_packet_size), .dflt = STRINGIFY(FR_MAX_PACKET_SIZE) },
- { FR_CONF_OFFSET("max_send_coalesce", FR_TYPE_UINT16, rlm_tacacs_tcp_t, max_send_coalesce), .dflt = "1024" },
+ { FR_CONF_OFFSET("max_packet_size", FR_TYPE_UINT32, 0, rlm_tacacs_tcp_t, max_packet_size), .dflt = STRINGIFY(FR_MAX_PACKET_SIZE) },
+ { FR_CONF_OFFSET("max_send_coalesce", FR_TYPE_UINT16, 0, rlm_tacacs_tcp_t, max_send_coalesce), .dflt = "1024" },
- { FR_CONF_OFFSET("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, rlm_tacacs_tcp_t, src_ipaddr) },
- { FR_CONF_OFFSET("src_ipv4addr", FR_TYPE_IPV4_ADDR, rlm_tacacs_tcp_t, src_ipaddr) },
- { FR_CONF_OFFSET("src_ipv6addr", FR_TYPE_IPV6_ADDR, rlm_tacacs_tcp_t, src_ipaddr) },
+ { FR_CONF_OFFSET("src_ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, rlm_tacacs_tcp_t, src_ipaddr) },
+ { FR_CONF_OFFSET("src_ipv4addr", FR_TYPE_IPV4_ADDR, 0, rlm_tacacs_tcp_t, src_ipaddr) },
+ { FR_CONF_OFFSET("src_ipv6addr", FR_TYPE_IPV6_ADDR, 0, rlm_tacacs_tcp_t, src_ipaddr) },
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
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 },
+ { FR_CONF_OFFSET("tmpl", 0, CONF_FLAG_TMPL, rlm_test_t, tmpl), .dflt = "&Tmp-String-0", .quote = T_BARE_WORD },
+ { FR_CONF_OFFSET("tmpl_m", 0, CONF_FLAG_TMPL | CONF_FLAG_MULTI, rlm_test_t, tmpl_m), .dflt = "&Tmp-String-0", .quote = T_DOUBLE_QUOTED_STRING },
- { FR_CONF_OFFSET("string", FR_TYPE_STRING, rlm_test_t, string) },
- { FR_CONF_OFFSET("string_m", FR_TYPE_STRING | FR_TYPE_MULTI, rlm_test_t, string_m) },
+ { FR_CONF_OFFSET("string", FR_TYPE_STRING, 0, rlm_test_t, string) },
+ { FR_CONF_OFFSET("string_m", FR_TYPE_STRING, CONF_FLAG_MULTI, rlm_test_t, string_m) },
- { FR_CONF_OFFSET("boolean", FR_TYPE_BOOL, rlm_test_t, boolean), .dflt = "no" },
- { FR_CONF_OFFSET("boolean_m", FR_TYPE_BOOL | FR_TYPE_MULTI, rlm_test_t, boolean_m), .dflt = "no" },
+ { FR_CONF_OFFSET("boolean", FR_TYPE_BOOL, 0, rlm_test_t, boolean), .dflt = "no" },
+ { FR_CONF_OFFSET("boolean_m", FR_TYPE_BOOL , CONF_FLAG_MULTI, rlm_test_t, boolean_m), .dflt = "no" },
- { FR_CONF_OFFSET("integer", FR_TYPE_UINT32, rlm_test_t, integer), .dflt = "1" },
- { FR_CONF_OFFSET("integer_m", FR_TYPE_UINT32 | FR_TYPE_MULTI, rlm_test_t, integer_m), .dflt = "2" },
+ { FR_CONF_OFFSET("integer", FR_TYPE_UINT32, 0, rlm_test_t, integer), .dflt = "1" },
+ { FR_CONF_OFFSET("integer_m", FR_TYPE_UINT32 , CONF_FLAG_MULTI, rlm_test_t, integer_m), .dflt = "2" },
- { FR_CONF_OFFSET("ipv4_addr", FR_TYPE_IPV4_ADDR, rlm_test_t, ipv4_addr), .dflt = "*" },
- { FR_CONF_OFFSET("ipv4_addr_m", FR_TYPE_IPV4_ADDR | FR_TYPE_MULTI, rlm_test_t, ipv4_addr_m), .dflt = "*" },
+ { FR_CONF_OFFSET("ipv4_addr", FR_TYPE_IPV4_ADDR, 0, rlm_test_t, ipv4_addr), .dflt = "*" },
+ { FR_CONF_OFFSET("ipv4_addr_m", FR_TYPE_IPV4_ADDR , CONF_FLAG_MULTI, rlm_test_t, ipv4_addr_m), .dflt = "*" },
- { FR_CONF_OFFSET("ipv4_prefix", FR_TYPE_IPV4_PREFIX, rlm_test_t, ipv4_addr), .dflt = "192.168.0.1/24" },
- { FR_CONF_OFFSET("ipv4_prefix_m", FR_TYPE_IPV4_PREFIX | FR_TYPE_MULTI, rlm_test_t, ipv4_addr_m), .dflt = "192.168.0.1/24" },
+ { FR_CONF_OFFSET("ipv4_prefix", FR_TYPE_IPV4_PREFIX, 0, rlm_test_t, ipv4_addr), .dflt = "192.168.0.1/24" },
+ { FR_CONF_OFFSET("ipv4_prefix_m", FR_TYPE_IPV4_PREFIX , CONF_FLAG_MULTI, rlm_test_t, ipv4_addr_m), .dflt = "192.168.0.1/24" },
- { FR_CONF_OFFSET("ipv6_addr", FR_TYPE_IPV6_ADDR, rlm_test_t, ipv6_addr), .dflt = "*" },
- { FR_CONF_OFFSET("ipv6_addr_m", FR_TYPE_IPV6_ADDR | FR_TYPE_MULTI, rlm_test_t, ipv6_addr_m), .dflt = "*" },
+ { FR_CONF_OFFSET("ipv6_addr", FR_TYPE_IPV6_ADDR, 0, rlm_test_t, ipv6_addr), .dflt = "*" },
+ { FR_CONF_OFFSET("ipv6_addr_m", FR_TYPE_IPV6_ADDR , CONF_FLAG_MULTI, rlm_test_t, ipv6_addr_m), .dflt = "*" },
- { FR_CONF_OFFSET("ipv6_prefix", FR_TYPE_IPV6_PREFIX, rlm_test_t, ipv6_prefix), .dflt = "::1/128" },
- { FR_CONF_OFFSET("ipv6_prefix_m", FR_TYPE_IPV6_PREFIX | FR_TYPE_MULTI, rlm_test_t, ipv6_prefix_m), .dflt = "::1/128" },
+ { FR_CONF_OFFSET("ipv6_prefix", FR_TYPE_IPV6_PREFIX, 0, rlm_test_t, ipv6_prefix), .dflt = "::1/128" },
+ { FR_CONF_OFFSET("ipv6_prefix_m", FR_TYPE_IPV6_PREFIX , CONF_FLAG_MULTI, rlm_test_t, ipv6_prefix_m), .dflt = "::1/128" },
- { FR_CONF_OFFSET("combo", FR_TYPE_COMBO_IP_ADDR, rlm_test_t, combo_ipaddr), .dflt = "::1/128" },
- { FR_CONF_OFFSET("combo_m", FR_TYPE_COMBO_IP_ADDR | FR_TYPE_MULTI, rlm_test_t, combo_ipaddr_m), .dflt = "::1/128" },
+ { FR_CONF_OFFSET("combo", FR_TYPE_COMBO_IP_ADDR, 0, rlm_test_t, combo_ipaddr), .dflt = "::1/128" },
+ { FR_CONF_OFFSET("combo_m", FR_TYPE_COMBO_IP_ADDR , CONF_FLAG_MULTI, rlm_test_t, combo_ipaddr_m), .dflt = "::1/128" },
- { FR_CONF_OFFSET("date", FR_TYPE_DATE, rlm_test_t, date) },
- { FR_CONF_OFFSET("date_m", FR_TYPE_DATE | FR_TYPE_MULTI, rlm_test_t, date_m) },
+ { FR_CONF_OFFSET("date", FR_TYPE_DATE, 0, rlm_test_t, date) },
+ { FR_CONF_OFFSET("date_m", FR_TYPE_DATE , CONF_FLAG_MULTI, rlm_test_t, date_m) },
- { FR_CONF_OFFSET("octets", FR_TYPE_OCTETS, rlm_test_t, octets) },
- { FR_CONF_OFFSET("octets_m", FR_TYPE_OCTETS | FR_TYPE_MULTI, rlm_test_t, octets_m) },
+ { FR_CONF_OFFSET("octets", FR_TYPE_OCTETS, 0, rlm_test_t, octets) },
+ { FR_CONF_OFFSET("octets_m", FR_TYPE_OCTETS, CONF_FLAG_MULTI, rlm_test_t, octets_m) },
- { FR_CONF_OFFSET("bytes", FR_TYPE_UINT8, rlm_test_t, byte) },
- { FR_CONF_OFFSET("bytes_m", FR_TYPE_UINT8 | FR_TYPE_MULTI, rlm_test_t, byte_m) },
+ { FR_CONF_OFFSET("bytes", FR_TYPE_UINT8, 0, rlm_test_t, byte) },
+ { FR_CONF_OFFSET("bytes_m", FR_TYPE_UINT8 , CONF_FLAG_MULTI, rlm_test_t, byte_m) },
- { FR_CONF_OFFSET("ifid", FR_TYPE_IFID, rlm_test_t, ifid) },
- { FR_CONF_OFFSET("ifid_m", FR_TYPE_IFID | FR_TYPE_MULTI, rlm_test_t, ifid_m) },
+ { FR_CONF_OFFSET("ifid", FR_TYPE_IFID, 0, rlm_test_t, ifid) },
+ { FR_CONF_OFFSET("ifid_m", FR_TYPE_IFID , CONF_FLAG_MULTI, rlm_test_t, ifid_m) },
- { FR_CONF_OFFSET("short", FR_TYPE_UINT16, rlm_test_t, shortint) },
- { FR_CONF_OFFSET("short_m", FR_TYPE_UINT16 | FR_TYPE_MULTI, rlm_test_t, shortint_m) },
+ { FR_CONF_OFFSET("short", FR_TYPE_UINT16, 0, rlm_test_t, shortint) },
+ { FR_CONF_OFFSET("short_m", FR_TYPE_UINT16 , CONF_FLAG_MULTI, rlm_test_t, shortint_m) },
- { FR_CONF_OFFSET("ethernet", FR_TYPE_ETHERNET, rlm_test_t, ethernet) },
- { FR_CONF_OFFSET("ethernet_m", FR_TYPE_ETHERNET | FR_TYPE_MULTI, rlm_test_t, ethernet_m) },
+ { FR_CONF_OFFSET("ethernet", FR_TYPE_ETHERNET, 0, rlm_test_t, ethernet) },
+ { FR_CONF_OFFSET("ethernet_m", FR_TYPE_ETHERNET , CONF_FLAG_MULTI, rlm_test_t, ethernet_m) },
- { FR_CONF_OFFSET("signed", FR_TYPE_INT32, rlm_test_t, int32) },
- { FR_CONF_OFFSET("signed_m", FR_TYPE_INT32 | FR_TYPE_MULTI, rlm_test_t, int32_m) },
+ { FR_CONF_OFFSET("signed", FR_TYPE_INT32, 0, rlm_test_t, int32) },
+ { FR_CONF_OFFSET("signed_m", FR_TYPE_INT32 , CONF_FLAG_MULTI, rlm_test_t, int32_m) },
- { FR_CONF_OFFSET("uint64", FR_TYPE_UINT64, rlm_test_t, uint64) },
- { FR_CONF_OFFSET("uint64_m", FR_TYPE_UINT64 | FR_TYPE_MULTI, rlm_test_t, uint64_m) },
+ { FR_CONF_OFFSET("uint64", FR_TYPE_UINT64, 0, rlm_test_t, uint64) },
+ { FR_CONF_OFFSET("uint64_m", FR_TYPE_UINT64 , CONF_FLAG_MULTI, rlm_test_t, uint64_m) },
- { FR_CONF_OFFSET("time_delta", FR_TYPE_TIME_DELTA, rlm_test_t, time_delta) },
- { FR_CONF_OFFSET("time_delta_t", FR_TYPE_TIME_DELTA | FR_TYPE_MULTI, rlm_test_t, time_delta_m) },
+ { FR_CONF_OFFSET("time_delta", FR_TYPE_TIME_DELTA, 0, rlm_test_t, time_delta) },
+ { FR_CONF_OFFSET("time_delta_t", FR_TYPE_TIME_DELTA , CONF_FLAG_MULTI, rlm_test_t, time_delta_m) },
CONF_PARSER_TERMINATOR
};
static const call_env_method_t method_env = {
FR_CALL_ENV_METHOD_OUT(rlm_totp_call_env_t),
.env = (call_env_parser_t[]) {
- { FR_CALL_ENV_OFFSET("secret", FR_TYPE_STRING, rlm_totp_call_env_t, secret,
+ { FR_CALL_ENV_OFFSET("secret", FR_TYPE_STRING, 0, rlm_totp_call_env_t, secret,
"&control.TOTP.Secret", T_BARE_WORD, false, true, false) },
- { FR_CALL_ENV_OFFSET("key", FR_TYPE_STRING, rlm_totp_call_env_t, key,
+ { FR_CALL_ENV_OFFSET("key", FR_TYPE_STRING, 0, rlm_totp_call_env_t, key,
"&control.TOTP.key", T_BARE_WORD, false, true, false) },
- { FR_CALL_ENV_OFFSET("user_password", FR_TYPE_STRING, rlm_totp_call_env_t, user_password,
+ { FR_CALL_ENV_OFFSET("user_password", FR_TYPE_STRING, 0, rlm_totp_call_env_t, user_password,
"&request.TOTP.From-User", T_BARE_WORD, false, true, false) },
CALL_ENV_TERMINATOR
/* Map configuration file names to internal variables */
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" },
- { FR_CONF_OFFSET("lookback_interval", FR_TYPE_UINT32, rlm_totp_t, totp.lookback_interval), .dflt = "30" },
+ { FR_CONF_OFFSET("time_step", FR_TYPE_UINT32, 0, rlm_totp_t, totp.time_step), .dflt = "30" },
+ { FR_CONF_OFFSET("otp_length", FR_TYPE_UINT32, 0, rlm_totp_t, totp.otp_length), .dflt = "6" },
+ { FR_CONF_OFFSET("lookback_steps", FR_TYPE_UINT32, 0, rlm_totp_t, totp.lookback_steps), .dflt = "1" },
+ { FR_CONF_OFFSET("lookback_interval", FR_TYPE_UINT32, 0, rlm_totp_t, totp.lookback_interval), .dflt = "30" },
CONF_PARSER_TERMINATOR
};
* A mapping of configuration file names to internal variables.
*/
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("filename", FR_TYPE_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) },
- { FR_CONF_OFFSET("hosts", FR_TYPE_FILE_INPUT, rlm_unbound_t, hosts) },
+ { FR_CONF_OFFSET("filename", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_unbound_t, filename), .dflt = "${modconfdir}/unbound/default.conf" },
+ { FR_CONF_OFFSET("timeout", FR_TYPE_UINT32, 0, rlm_unbound_t, timeout), .dflt = "3000" },
+ { FR_CONF_OFFSET("resolvconf", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_unbound_t, resolvconf) },
+ { FR_CONF_OFFSET("hosts", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_unbound_t, hosts) },
CONF_PARSER_TERMINATOR
};
} rlm_unix_t;
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("radwtmp", FR_TYPE_FILE_OUTPUT, rlm_unix_t, radwtmp) },
+ { FR_CONF_OFFSET("radwtmp", FR_TYPE_STRING, CONF_FLAG_FILE_INPUT, rlm_unix_t, radwtmp) },
CONF_PARSER_TERMINATOR
};
} rlm_wimax_t;
static const conf_parser_t module_config[] = {
- { FR_CONF_OFFSET("delete_mppe_keys", FR_TYPE_BOOL, rlm_wimax_t, delete_mppe_keys), .dflt = "no" },
+ { FR_CONF_OFFSET("delete_mppe_keys", FR_TYPE_BOOL, 0, rlm_wimax_t, delete_mppe_keys), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
#include <wbclient.h>
static const conf_parser_t group_config[] = {
- { FR_CONF_OFFSET("search_username", 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) },
+ { FR_CONF_OFFSET("search_username", 0, CONF_FLAG_TMPL, rlm_winbind_t, group_username) },
+ { FR_CONF_OFFSET("add_domain", FR_TYPE_BOOL, 0, rlm_winbind_t, group_add_domain), .dflt = "yes" },
+ { FR_CONF_OFFSET("attribute", FR_TYPE_STRING, 0, rlm_winbind_t, group_attribute) },
CONF_PARSER_TERMINATOR
};
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 },
+ { FR_CONF_OFFSET("username", 0, CONF_FLAG_TMPL, rlm_winbind_t, wb_username) },
+ { FR_CONF_OFFSET("domain", 0, CONF_FLAG_TMPL, rlm_winbind_t, wb_domain) },
+ { FR_CONF_POINTER("group", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) group_config },
CONF_PARSER_TERMINATOR
};
#ifdef HAVE_YKCLIENT
static const conf_parser_t validation_config[] = {
- { FR_CONF_OFFSET("client_id", FR_TYPE_UINT32, rlm_yubikey_t, client_id), .dflt = 0 },
- { FR_CONF_OFFSET("api_key", FR_TYPE_STRING | FR_TYPE_SECRET, rlm_yubikey_t, api_key) },
+ { FR_CONF_OFFSET("client_id", FR_TYPE_UINT32, 0, rlm_yubikey_t, client_id), .dflt = 0 },
+ { FR_CONF_OFFSET("api_key", FR_TYPE_STRING, CONF_FLAG_SECRET, rlm_yubikey_t, api_key) },
CONF_PARSER_TERMINATOR
};
#endif
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" },
- { FR_CONF_OFFSET("validate", FR_TYPE_BOOL, rlm_yubikey_t, validate), .dflt = "no" },
+ { FR_CONF_OFFSET("id_length", FR_TYPE_UINT32, 0, rlm_yubikey_t, id_len), .dflt = "12" },
+ { FR_CONF_OFFSET("split", FR_TYPE_BOOL, 0, rlm_yubikey_t, split), .dflt = "yes" },
+ { FR_CONF_OFFSET("decrypt", FR_TYPE_BOOL, 0, rlm_yubikey_t, decrypt), .dflt = "no" },
+ { FR_CONF_OFFSET("validate", FR_TYPE_BOOL, 0, rlm_yubikey_t, validate), .dflt = "no" },
#ifdef HAVE_YKCLIENT
- { FR_CONF_POINTER("validation", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) validation_config },
+ { FR_CONF_POINTER("validation", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) validation_config },
#endif
CONF_PARSER_TERMINATOR
};
#include <freeradius-devel/server/process.h>
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" },
+ { FR_CONF_OFFSET("status_code_on_success", FR_TYPE_BOOL, 0, process_dhcpv6_t, status_code_on_success), .dflt = "no" },
+ { FR_CONF_OFFSET("send_failure_message", FR_TYPE_BOOL, 0, process_dhcpv6_t, send_failure_message), .dflt = "no" },
+ { FR_CONF_OFFSET("move_failure_message_to_parent", FR_TYPE_BOOL, 0, process_dhcpv6_t, move_failure_message_to_parent), .dflt = "yes" },
CONF_PARSER_TERMINATOR
};
#include <freeradius-devel/server/process.h>
static conf_parser_t submodule_config[] = {
- { FR_CONF_OFFSET("request_identity", FR_TYPE_VOID, eap_aka_sim_process_conf_t, request_identity ),
+ { FR_CONF_OFFSET("request_identity", FR_TYPE_VOID, 0, eap_aka_sim_process_conf_t, request_identity ),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = fr_aka_sim_id_request_table, .len = &fr_aka_sim_id_request_table_len }},
- { FR_CONF_OFFSET("strip_permanent_identity_hint", FR_TYPE_BOOL, eap_aka_sim_process_conf_t,
+ { FR_CONF_OFFSET("strip_permanent_identity_hint", FR_TYPE_BOOL, 0, eap_aka_sim_process_conf_t,
strip_permanent_identity_hint ), .dflt = "yes" },
- { FR_CONF_OFFSET("ephemeral_id_length", FR_TYPE_SIZE, eap_aka_sim_process_conf_t, ephemeral_id_length ), .dflt = "14" }, /* 14 for compatibility */
- { FR_CONF_OFFSET("protected_success", FR_TYPE_BOOL, eap_aka_sim_process_conf_t, protected_success ), .dflt = "no" },
+ { FR_CONF_OFFSET("ephemeral_id_length", FR_TYPE_SIZE, 0, eap_aka_sim_process_conf_t, ephemeral_id_length ), .dflt = "14" }, /* 14 for compatibility */
+ { FR_CONF_OFFSET("protected_success", FR_TYPE_BOOL, 0, eap_aka_sim_process_conf_t, protected_success ), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
#include <freeradius-devel/server/process.h>
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 ),
+ { FR_CONF_OFFSET("network_name", FR_TYPE_STRING, 0, eap_aka_sim_process_conf_t, network_name ) },
+ { FR_CONF_OFFSET("request_identity", FR_TYPE_VOID, 0, eap_aka_sim_process_conf_t, request_identity ),
.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,
+ { FR_CONF_OFFSET("strip_permanent_identity_hint", FR_TYPE_BOOL, 0, eap_aka_sim_process_conf_t,
strip_permanent_identity_hint ), .dflt = "yes" },
- { FR_CONF_OFFSET("ephemeral_id_length", FR_TYPE_SIZE, eap_aka_sim_process_conf_t, ephemeral_id_length ), .dflt = "14" }, /* 14 for compatibility */
- { FR_CONF_OFFSET("protected_success", FR_TYPE_BOOL, eap_aka_sim_process_conf_t, protected_success ), .dflt = "no" },
+ { FR_CONF_OFFSET("ephemeral_id_length", FR_TYPE_SIZE, 0, eap_aka_sim_process_conf_t, ephemeral_id_length ), .dflt = "14" }, /* 14 for compatibility */
+ { FR_CONF_OFFSET("protected_success", FR_TYPE_BOOL, 0, eap_aka_sim_process_conf_t, protected_success ), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
#include <freeradius-devel/server/process.h>
static conf_parser_t submodule_config[] = {
- { FR_CONF_OFFSET("request_identity", FR_TYPE_VOID, eap_aka_sim_process_conf_t, request_identity ),
+ { FR_CONF_OFFSET("request_identity", FR_TYPE_VOID, 0, eap_aka_sim_process_conf_t, request_identity ),
.func = cf_table_parse_int, .uctx = &(cf_table_parse_ctx_t){ .table = fr_aka_sim_id_request_table, .len = &fr_aka_sim_id_request_table_len }},
- { FR_CONF_OFFSET("strip_permanent_identity_hint", FR_TYPE_BOOL, eap_aka_sim_process_conf_t,
+ { FR_CONF_OFFSET("strip_permanent_identity_hint", FR_TYPE_BOOL, 0, eap_aka_sim_process_conf_t,
strip_permanent_identity_hint ), .dflt = "yes" },
- { FR_CONF_OFFSET("ephemeral_id_length", FR_TYPE_SIZE, eap_aka_sim_process_conf_t, ephemeral_id_length ), .dflt = "14" }, /* 14 for compatibility */
- { FR_CONF_OFFSET("protected_success", FR_TYPE_BOOL, eap_aka_sim_process_conf_t, protected_success ), .dflt = "no" },
+ { FR_CONF_OFFSET("ephemeral_id_length", FR_TYPE_SIZE, 0, eap_aka_sim_process_conf_t, ephemeral_id_length ), .dflt = "14" }, /* 14 for compatibility */
+ { FR_CONF_OFFSET("protected_success", FR_TYPE_BOOL, 0, eap_aka_sim_process_conf_t, protected_success ), .dflt = "no" },
CONF_PARSER_TERMINATOR
};
#include <freeradius-devel/server/process.h>
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) },
+ { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, 0, process_radius_auth_t, session_timeout), .dflt = "15" },
+ { FR_CONF_OFFSET("max", FR_TYPE_UINT32, 0, process_radius_auth_t, max_session), .dflt = "4096" },
+ { FR_CONF_OFFSET("state_server_id", FR_TYPE_UINT8, 0, process_radius_auth_t, state_server_id) },
CONF_PARSER_TERMINATOR
};
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" },
- { FR_CONF_OFFSET("auth_goodpass", FR_TYPE_BOOL,process_radius_auth_t, log_auth_goodpass), .dflt = "no" },
- { FR_CONF_OFFSET("msg_badpass", FR_TYPE_STRING, process_radius_auth_t, auth_badpass_msg) },
- { FR_CONF_OFFSET("msg_goodpass", FR_TYPE_STRING, process_radius_auth_t, auth_goodpass_msg) },
- { FR_CONF_OFFSET("msg_denied", FR_TYPE_STRING, process_radius_auth_t, denied_msg), .dflt = "You are already logged in - access denied" },
+ { FR_CONF_OFFSET("stripped_names", FR_TYPE_BOOL, 0, process_radius_auth_t, log_stripped_names), .dflt = "no" },
+ { FR_CONF_OFFSET("auth", FR_TYPE_BOOL, 0, process_radius_auth_t, log_auth), .dflt = "no" },
+ { FR_CONF_OFFSET("auth_badpass", FR_TYPE_BOOL, 0, process_radius_auth_t, log_auth_badpass), .dflt = "no" },
+ { FR_CONF_OFFSET("auth_goodpass", FR_TYPE_BOOL, 0,process_radius_auth_t, log_auth_goodpass), .dflt = "no" },
+ { FR_CONF_OFFSET("msg_badpass", FR_TYPE_STRING, 0, process_radius_auth_t, auth_badpass_msg) },
+ { FR_CONF_OFFSET("msg_goodpass", FR_TYPE_STRING, 0, process_radius_auth_t, auth_goodpass_msg) },
+ { FR_CONF_OFFSET("msg_denied", FR_TYPE_STRING, 0, process_radius_auth_t, denied_msg), .dflt = "You are already logged in - access denied" },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t auth_config[] = {
- { FR_CONF_POINTER("log", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) log_config },
+ { FR_CONF_POINTER("log", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) log_config },
- { FR_CONF_POINTER("session", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) session_config },
+ { FR_CONF_POINTER("session", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) session_config },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t config[] = {
- { FR_CONF_POINTER("Access-Request", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) auth_config,
+ { FR_CONF_POINTER("Access-Request", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) auth_config,
.offset = offsetof(process_radius_t, auth), },
CONF_PARSER_TERMINATOR
#include <freeradius-devel/server/process.h>
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" },
- { FR_CONF_OFFSET("state_server_id", FR_TYPE_UINT8, process_tacacs_auth_t, state_server_id) },
+ { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, 0, process_tacacs_auth_t, session_timeout), .dflt = "15" },
+ { FR_CONF_OFFSET("max", FR_TYPE_UINT32, 0, process_tacacs_auth_t, max_session), .dflt = "4096" },
+ { FR_CONF_OFFSET("max_rounds", FR_TYPE_UINT32, 0, process_tacacs_auth_t, max_rounds), .dflt = "4" },
+ { FR_CONF_OFFSET("state_server_id", FR_TYPE_UINT8, 0, process_tacacs_auth_t, state_server_id) },
CONF_PARSER_TERMINATOR
};
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" },
- { FR_CONF_OFFSET("auth_goodpass", FR_TYPE_BOOL,process_tacacs_auth_t, log_auth_goodpass), .dflt = "no" },
- { FR_CONF_OFFSET("msg_badpass", FR_TYPE_STRING, process_tacacs_auth_t, auth_badpass_msg) },
- { FR_CONF_OFFSET("msg_goodpass", FR_TYPE_STRING, process_tacacs_auth_t, auth_goodpass_msg) },
- { FR_CONF_OFFSET("msg_denied", FR_TYPE_STRING, process_tacacs_auth_t, denied_msg), .dflt = "You are already logged in - access denied" },
+ { FR_CONF_OFFSET("stripped_names", FR_TYPE_BOOL, 0, process_tacacs_auth_t, log_stripped_names), .dflt = "no" },
+ { FR_CONF_OFFSET("auth", FR_TYPE_BOOL, 0, process_tacacs_auth_t, log_auth), .dflt = "no" },
+ { FR_CONF_OFFSET("auth_badpass", FR_TYPE_BOOL, 0, process_tacacs_auth_t, log_auth_badpass), .dflt = "no" },
+ { FR_CONF_OFFSET("auth_goodpass", FR_TYPE_BOOL, 0,process_tacacs_auth_t, log_auth_goodpass), .dflt = "no" },
+ { FR_CONF_OFFSET("msg_badpass", FR_TYPE_STRING, 0, process_tacacs_auth_t, auth_badpass_msg) },
+ { FR_CONF_OFFSET("msg_goodpass", FR_TYPE_STRING, 0, process_tacacs_auth_t, auth_goodpass_msg) },
+ { FR_CONF_OFFSET("msg_denied", FR_TYPE_STRING, 0, process_tacacs_auth_t, denied_msg), .dflt = "You are already logged in - access denied" },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t auth_config[] = {
- { FR_CONF_POINTER("log", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) log_config },
+ { FR_CONF_POINTER("log", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) log_config },
- { FR_CONF_POINTER("session", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) session_config },
+ { FR_CONF_POINTER("session", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) session_config },
CONF_PARSER_TERMINATOR
};
static const conf_parser_t config[] = {
- { FR_CONF_POINTER("Authentication", FR_TYPE_SUBSECTION, NULL), .subcs = (void const *) auth_config,
+ { FR_CONF_POINTER("Authentication", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) auth_config,
.offset = offsetof(process_tacacs_t, auth), },
CONF_PARSER_TERMINATOR
#include <freeradius-devel/server/process.h>
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) },
+ { FR_CONF_OFFSET("timeout", FR_TYPE_TIME_DELTA, 0, process_ttls_session_t, timeout), .dflt = "15" },
+ { FR_CONF_OFFSET("max", FR_TYPE_UINT32, 0, process_ttls_session_t, max), .dflt = "4096" },
+ { FR_CONF_OFFSET("state_server_id", FR_TYPE_UINT8, 0, process_ttls_session_t, state_server_id) },
CONF_PARSER_TERMINATOR
};
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" },
- { FR_CONF_OFFSET("auth_goodpass", FR_TYPE_BOOL,process_ttls_auth_log_t, auth_goodpass), .dflt = "no" },
- { FR_CONF_OFFSET("msg_badpass", FR_TYPE_STRING, process_ttls_auth_log_t, auth_badpass_msg) },
- { FR_CONF_OFFSET("msg_goodpass", FR_TYPE_STRING, process_ttls_auth_log_t, auth_goodpass_msg) },
- { FR_CONF_OFFSET("msg_denied", FR_TYPE_STRING, process_ttls_auth_log_t, denied_msg), .dflt = "You are already logged in - access denied" },
+ { FR_CONF_OFFSET("stripped_names", FR_TYPE_BOOL, 0, process_ttls_auth_log_t, stripped_names), .dflt = "no" },
+ { FR_CONF_OFFSET("auth", FR_TYPE_BOOL, 0, process_ttls_auth_log_t, auth), .dflt = "no" },
+ { FR_CONF_OFFSET("auth_badpass", FR_TYPE_BOOL, 0, process_ttls_auth_log_t, auth_badpass), .dflt = "no" },
+ { FR_CONF_OFFSET("auth_goodpass", FR_TYPE_BOOL, 0,process_ttls_auth_log_t, auth_goodpass), .dflt = "no" },
+ { FR_CONF_OFFSET("msg_badpass", FR_TYPE_STRING, 0, process_ttls_auth_log_t, auth_badpass_msg) },
+ { FR_CONF_OFFSET("msg_goodpass", FR_TYPE_STRING, 0, process_ttls_auth_log_t, auth_goodpass_msg) },
+ { FR_CONF_OFFSET("msg_denied", FR_TYPE_STRING, 0, process_ttls_auth_log_t, denied_msg), .dflt = "You are already logged in - access denied" },
CONF_PARSER_TERMINATOR
};
projects / thirdparty / freeradius-server.git / commitdiff
