From: Arran Cudbard-Bell Date: Sat, 18 Nov 2023 03:25:32 +0000 (-0500) Subject: Split type and flags fields in conf_parser_t X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=213a948d5aba892945f422c80c2a2b94aaefde40;p=thirdparty%2Ffreeradius-server.git Split type and flags fields in conf_parser_t --- diff --git a/.clang-format b/.clang-format index 93585db7492..59723be9309 100644 --- a/.clang-format +++ b/.clang-format @@ -16,7 +16,7 @@ SortIncludes: false # 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 diff --git a/src/bin/radwho.c b/src/bin/radwho.c index 321f7c0bf03..6752323b357 100644 --- a/src/bin/radwho.c +++ b/src/bin/radwho.c @@ -57,7 +57,7 @@ static struct radutmp_config_t { } 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 }; diff --git a/src/lib/curl/base.c b/src/lib/curl/base.c index f67829bee95..9a1c0959157 100644 --- a/src/lib/curl/base.c +++ b/src/lib/curl/base.c @@ -52,36 +52,36 @@ static fr_table_num_sorted_t const fr_curl_sslcode_table[] = { 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 }; diff --git a/src/lib/json/json.c b/src/lib/json/json.c index 6b7ba107801..728ba05f00f 100644 --- a/src/lib/json/json.c +++ b/src/lib/json/json.c @@ -49,22 +49,22 @@ static fr_json_format_t const default_json_format = { }; 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 diff --git a/src/lib/kafka/base.c b/src/lib/kafka/base.c index dd05180630f..2604532ca9b 100644 --- a/src/lib/kafka/base.c +++ b/src/lib/kafka/base.c @@ -129,7 +129,7 @@ static int kafka_config_dflt_single(CONF_PAIR **out, UNUSED void *parent, CONF_S { 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 @@ -184,7 +184,7 @@ static int kafka_config_dflt_single(CONF_PAIR **out, UNUSED void *parent, CONF_S 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; @@ -218,7 +218,7 @@ static int kafka_config_dflt(CONF_PAIR **out, void *parent, CONF_SECTION *cs, fr 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 */ } @@ -226,7 +226,7 @@ static int kafka_config_dflt(CONF_PAIR **out, void *parent, CONF_SECTION *cs, fr 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; @@ -300,7 +300,7 @@ static int kafka_topic_config_dflt(CONF_PAIR **out, void *parent, CONF_SECTION * 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 */ } @@ -309,7 +309,7 @@ static int kafka_topic_config_dflt(CONF_PAIR **out, void *parent, CONF_SECTION * 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; @@ -325,7 +325,7 @@ static int kafka_config_parse_single(char const **out, CONF_PAIR *cp, conf_parse { 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; @@ -446,13 +446,13 @@ static int kafka_config_parse(TALLOC_CTX *ctx, UNUSED void *out, UNUSED void *ba 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); } @@ -539,10 +539,10 @@ static int kafka_topic_new(UNUSED TALLOC_CTX *ctx, UNUSED void *out, UNUSED void #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 @@ -552,31 +552,31 @@ static conf_parser_t const kafka_sasl_kerberos_config[] = { /* * 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 @@ -586,19 +586,19 @@ static conf_parser_t const kafka_sasl_config[] = { /* * 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) }, @@ -620,55 +620,55 @@ static conf_parser_t const kafka_tls_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 }}, @@ -679,74 +679,74 @@ static conf_parser_t const kafka_connection_config[] = { /* * 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 @@ -756,25 +756,25 @@ static conf_parser_t const kafka_version_config[] = { /* * 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 @@ -784,60 +784,60 @@ static conf_parser_t const kafka_metadata_config[] = { /* * 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) }, \ @@ -849,37 +849,37 @@ static conf_parser_t const kafka_consumer_group_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" }}, @@ -892,14 +892,14 @@ static conf_parser_t const kafka_base_consumer_topic_config[] = { * * 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 @@ -916,7 +916,7 @@ static conf_parser_t const kafka_base_consumer_topic_config[] = { * */ static conf_parser_t const kafka_base_consumer_topics_config[] = { - { FR_CONF_SUBSECTION_GLOBAL(CF_IDENT_ANY, FR_TYPE_MULTI, kafka_base_consumer_topic_config) }, + { FR_CONF_SUBSECTION_GLOBAL(CF_IDENT_ANY, CONF_FLAG_MULTI, kafka_base_consumer_topic_config) }, CONF_PARSER_TERMINATOR }; @@ -928,97 +928,97 @@ conf_parser_t const kafka_base_consumer_config[] = { /* * 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) }, \ @@ -1031,37 +1031,37 @@ static conf_parser_t const kafka_base_producer_topic_config[] = { * This field indicates the number of acknowledgements the leader * broker must receive from ISR brokers before responding to the request. */ - { 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 @@ -1089,7 +1089,7 @@ conf_parser_t const kafka_base_producer_config[] = { /* * 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 }}, /* @@ -1097,7 +1097,7 @@ conf_parser_t const kafka_base_producer_config[] = { * 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" }}, /* @@ -1105,73 +1105,73 @@ conf_parser_t const kafka_base_producer_config[] = { * 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 }; diff --git a/src/lib/ldap/base.c b/src/lib/ldap/base.c index 1f39baf8b82..d276b79de24 100644 --- a/src/lib/ldap/base.c +++ b/src/lib/ldap/base.c @@ -97,8 +97,8 @@ static fr_libldap_global_config_t libldap_global_config = { }; static conf_parser_t const ldap_global_config[] = { - { FR_CONF_OFFSET("random_file", FR_TYPE_FILE_EXISTS, fr_libldap_global_config_t, tls_random_file) }, - { FR_CONF_OFFSET("ldap_debug", FR_TYPE_UINT32, fr_libldap_global_config_t, ldap_debug), .dflt = "0x0000" }, + { 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 }; diff --git a/src/lib/ldap/conf.c b/src/lib/ldap/conf.c index 589059ffc26..00d10830d36 100644 --- a/src/lib/ldap/conf.c +++ b/src/lib/ldap/conf.c @@ -28,9 +28,9 @@ RCSID("$Id$") #include 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 }; @@ -41,22 +41,22 @@ conf_parser_t const fr_ldap_tls_config[] = { /* * 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 }; @@ -70,43 +70,43 @@ conf_parser_t const fr_ldap_option_config[] = { /* * 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 }; diff --git a/src/lib/ldap/conf.h b/src/lib/ldap/conf.h index 2f3b20e2d60..bde7c3595b7 100644 --- a/src/lib/ldap/conf.h +++ b/src/lib/ldap/conf.h @@ -16,9 +16,9 @@ extern conf_parser_t const fr_ldap_option_config[]; /* * 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 } diff --git a/src/lib/redis/base.h b/src/lib/redis/base.h index c5f1b2f128e..ee2f90068a2 100644 --- a/src/lib/redis/base.h +++ b/src/lib/redis/base.h @@ -131,16 +131,16 @@ typedef struct { } 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); diff --git a/src/lib/server/cf_file.c b/src/lib/server/cf_file.c index fea0c961fc7..f6b68634f5e 100644 --- a/src/lib/server/cf_file.c +++ b/src/lib/server/cf_file.c @@ -2985,7 +2985,7 @@ void cf_file_free(CONF_SECTION *cs) /** 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. * diff --git a/src/lib/server/cf_parse.c b/src/lib/server/cf_parse.c index 4ec23ca8b79..a06f48782eb 100644 --- a/src/lib/server/cf_parse.c +++ b/src/lib/server/cf_parse.c @@ -51,18 +51,18 @@ void cf_pair_debug(CONF_SECTION const *cs, CONF_PAIR *cp, conf_parser_t const *r 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)) { @@ -73,14 +73,14 @@ void cf_pair_debug(CONF_SECTION const *cs, CONF_PAIR *cp, conf_parser_t const *r /* * 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; @@ -125,9 +125,7 @@ void cf_pair_debug(CONF_SECTION const *cs, CONF_PAIR *cp, conf_parser_t const *r */ 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); @@ -137,7 +135,7 @@ int cf_pair_to_value_box(TALLOC_CTX *ctx, fr_value_box_t *out, CONF_PAIR *cp, co /* * 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 @@ -177,7 +175,6 @@ int cf_pair_parse_value(TALLOC_CTX *ctx, void *out, UNUSED void *base, CONF_ITEM ssize_t slen; - int type = rule->type; CONF_PAIR *cp = cf_item_to_pair(ci); cant_be_empty = fr_rule_not_empty(rule); @@ -188,12 +185,10 @@ int cf_pair_parse_value(TALLOC_CTX *ctx, void *out, UNUSED void *base, CONF_ITEM 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; } @@ -312,15 +307,12 @@ static int cf_pair_default(CONF_PAIR **out, void *parent, CONF_SECTION *cs, conf 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; } @@ -328,7 +320,7 @@ static int cf_pair_default(CONF_PAIR **out, void *parent, CONF_SECTION *cs, conf * 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; @@ -340,7 +332,7 @@ static int cf_pair_default(CONF_PAIR **out, void *parent, CONF_SECTION *cs, conf */ 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; } @@ -349,11 +341,11 @@ static int cf_pair_default(CONF_PAIR **out, void *parent, CONF_SECTION *cs, conf expanded = cf_expand_variables("", 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; /* @@ -366,7 +358,6 @@ static int cf_pair_default(CONF_PAIR **out, void *parent, CONF_SECTION *cs, conf static int cf_pair_unescape(CONF_PAIR *cp, conf_parser_t const *rule) { - fr_type_t type; char const *p; char *str, *unescaped, *q; @@ -374,9 +365,8 @@ static int cf_pair_unescape(CONF_PAIR *cp, conf_parser_t const *rule) 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; @@ -461,7 +451,6 @@ static int CC_HINT(nonnull(4,5)) cf_pair_parse_internal(TALLOC_CTX *ctx, void *o 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; @@ -495,7 +484,7 @@ static int CC_HINT(nonnull(4,5)) cf_pair_parse_internal(TALLOC_CTX *ctx, void *o /* * 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 @@ -507,17 +496,17 @@ static int CC_HINT(nonnull(4,5)) cf_pair_parse_internal(TALLOC_CTX *ctx, void *o 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; @@ -529,7 +518,7 @@ static int CC_HINT(nonnull(4,5)) cf_pair_parse_internal(TALLOC_CTX *ctx, void *o * 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: @@ -556,14 +545,14 @@ static int CC_HINT(nonnull(4,5)) cf_pair_parse_internal(TALLOC_CTX *ctx, void *o * 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; @@ -573,10 +562,10 @@ static int CC_HINT(nonnull(4,5)) cf_pair_parse_internal(TALLOC_CTX *ctx, void *o */ 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; @@ -604,7 +593,7 @@ static int CC_HINT(nonnull(4,5)) cf_pair_parse_internal(TALLOC_CTX *ctx, void *o 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; @@ -617,7 +606,7 @@ static int CC_HINT(nonnull(4,5)) cf_pair_parse_internal(TALLOC_CTX *ctx, void *o 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; } @@ -627,9 +616,9 @@ static int CC_HINT(nonnull(4,5)) cf_pair_parse_internal(TALLOC_CTX *ctx, void *o 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; @@ -658,7 +647,6 @@ static int CC_HINT(nonnull(4,5)) cf_pair_parse_internal(TALLOC_CTX *ctx, void *o * **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 | @@ -679,9 +667,7 @@ static int CC_HINT(nonnull(4,5)) cf_pair_parse_internal(TALLOC_CTX *ctx, void *o * @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 @@ -697,14 +683,18 @@ static int CC_HINT(nonnull(4,5)) cf_pair_parse_internal(TALLOC_CTX *ctx, void *o * - ``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. @@ -718,7 +708,7 @@ int cf_pair_parse(TALLOC_CTX *ctx, CONF_SECTION *cs, char const *name, unsigned int type, void *data, char const *dflt, fr_token_t dflt_quote) { conf_parser_t rule = { - .name = name, + .name1 = name, .type = type, .dflt = dflt, .quote = dflt_quote @@ -740,16 +730,16 @@ static int cf_section_parse_init(CONF_SECTION *cs, void *base, conf_parser_t con { 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; @@ -765,8 +755,8 @@ static int cf_section_parse_init(CONF_SECTION *cs, void *base, conf_parser_t con * 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; } @@ -774,7 +764,7 @@ static int cf_section_parse_init(CONF_SECTION *cs, void *base, conf_parser_t con * 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 @@ -783,20 +773,20 @@ static int cf_section_parse_init(CONF_SECTION *cs, void *base, conf_parser_t con * 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; @@ -805,12 +795,12 @@ static int cf_section_parse_init(CONF_SECTION *cs, void *base, conf_parser_t con /* * 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; } @@ -874,21 +864,20 @@ static int cf_subsection_parse(TALLOC_CTX *ctx, void *out, void *base, CONF_SECT 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", @@ -930,7 +919,7 @@ static int cf_subsection_parse(TALLOC_CTX *ctx, void *out, void *base, CONF_SECT * 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 @@ -947,7 +936,7 @@ static int cf_subsection_parse(TALLOC_CTX *ctx, void *out, void *base, CONF_SECT * 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", @@ -1041,7 +1030,7 @@ int cf_section_parse(TALLOC_CTX *ctx, void *base, CONF_SECTION *cs) /* * 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; @@ -1061,7 +1050,7 @@ int cf_section_parse(TALLOC_CTX *ctx, void *base, CONF_SECTION *cs) * 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; } @@ -1085,8 +1074,8 @@ int cf_section_parse(TALLOC_CTX *ctx, void *base, CONF_SECTION *cs) 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; } @@ -1183,29 +1172,25 @@ int cf_section_parse_pass2(void *base, CONF_SECTION *cs) 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, @@ -1235,7 +1220,7 @@ int cf_section_parse_pass2(void *base, CONF_SECTION *cs) * 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; /* @@ -1263,7 +1248,7 @@ int cf_section_parse_pass2(void *base, CONF_SECTION *cs) * 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 " @@ -1283,8 +1268,8 @@ int cf_section_parse_pass2(void *base, CONF_SECTION *cs) /* * 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; @@ -1376,13 +1361,13 @@ int _cf_section_rule_push(CONF_SECTION *cs, conf_parser_t const *rule, char cons 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 ? "{}": ""); } /* @@ -1433,7 +1418,7 @@ int _cf_section_rule_push(CONF_SECTION *cs, conf_parser_t const *rule, char cons * 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); @@ -1473,8 +1458,8 @@ int _cf_section_rules_push(CONF_SECTION *cs, conf_parser_t const *rules, char co 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; } diff --git a/src/lib/server/cf_parse.h b/src/lib/server/cf_parse.h index c99f5bf87de..00310fd96b8 100644 --- a/src/lib/server/cf_parse.h +++ b/src/lib/server/cf_parse.h @@ -48,7 +48,7 @@ typedef void _mismatch_bool_m; //!< Dummy type used to indicate FR_TYPE_*/C typ 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. @@ -99,129 +99,133 @@ typedef void conf_type_invalid; //!< Dummy type used to indicate invalid FR_TYP * @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 @@ -229,12 +233,14 @@ _Generic((_ct), \ * * @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 * @@ -242,30 +248,34 @@ _Generic((_ct), \ * * @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)) @@ -273,43 +283,40 @@ _Generic((_ct), \ * * @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. @@ -321,71 +328,76 @@ _Generic((_ct), \ * 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)\ @@ -465,7 +477,7 @@ typedef int (*cf_dflt_t)(CONF_PAIR **out, void *parent, CONF_SECTION *cs, fr_tok * 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 @@ -473,7 +485,7 @@ typedef int (*cf_dflt_t)(CONF_PAIR **out, void *parent, CONF_SECTION *cs, fr_tok * 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 @@ -484,29 +496,30 @@ typedef int (*cf_dflt_t)(CONF_PAIR **out, void *parent, CONF_SECTION *cs, fr_tok * @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 * @@ -528,7 +541,7 @@ struct conf_parser_s { }; 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 @@ -545,10 +558,10 @@ typedef struct { 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) diff --git a/src/lib/server/cf_util.c b/src/lib/server/cf_util.c index 5b4548ecc3c..c92a3a0735a 100644 --- a/src/lib/server/cf_util.c +++ b/src/lib/server/cf_util.c @@ -806,14 +806,14 @@ CONF_SECTION *_cf_section_alloc(TALLOC_CTX *ctx, CONF_SECTION *parent, 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: @@ -838,7 +838,7 @@ CONF_SECTION *_cf_section_alloc(TALLOC_CTX *ctx, CONF_SECTION *parent, 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; diff --git a/src/lib/server/client.c b/src/lib/server/client.c index 42f86f3f94c..0c1d21550eb 100644 --- a/src/lib/server/client.c +++ b/src/lib/server/client.c @@ -425,36 +425,36 @@ static char const *cl_srcipaddr = NULL; 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 }; diff --git a/src/lib/server/log.c b/src/lib/server/log.c index fce3055bf14..1345a322f2f 100644 --- a/src/lib/server/log.c +++ b/src/lib/server/log.c @@ -1103,13 +1103,13 @@ static bool log_timestamp_is_set; * 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, @@ -1117,12 +1117,12 @@ static const conf_parser_t log_config[] = { } }, #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 }; diff --git a/src/lib/server/main_config.c b/src/lib/server/main_config.c index 27ce768605c..bb090a56133 100644 --- a/src/lib/server/main_config.c +++ b/src/lib/server/main_config.c @@ -103,18 +103,18 @@ static int name_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, c * 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 }; @@ -122,7 +122,7 @@ static const conf_parser_t initial_log_config[] = { * 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 }; @@ -131,12 +131,12 @@ static const conf_parser_t initial_server_config[] = { * 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 @@ -149,10 +149,10 @@ static const conf_parser_t lib_dir_on_read_config[] = { * **********************************************************************/ static const conf_parser_t log_config[] = { - { FR_CONF_OFFSET("colourise", FR_TYPE_BOOL, main_config_t, do_colourise) }, - { FR_CONF_OFFSET("line_number", FR_TYPE_BOOL, main_config_t, log_line_number) }, - { FR_CONF_OFFSET("timestamp", FR_TYPE_BOOL, main_config_t, log_timestamp) }, - { 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 }; @@ -163,22 +163,22 @@ static const conf_parser_t resources[] = { * 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 @@ -188,8 +188,8 @@ static const conf_parser_t thread_config[] = { * 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 }; @@ -199,8 +199,8 @@ static const conf_parser_t migrate_config[] = { * 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 @@ -213,31 +213,31 @@ static const conf_parser_t server_config[] = { * 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 @@ -260,42 +260,42 @@ static const conf_parser_t server_config[] = { **********************************************************************/ static const conf_parser_t security_config[] = { #ifdef HAVE_SETUID - { FR_CONF_OFFSET_IS_SET("user", FR_TYPE_VOID, main_config_t, uid), .func = cf_parse_uid }, - { FR_CONF_OFFSET_IS_SET("group", FR_TYPE_VOID, main_config_t, gid), .func = cf_parse_gid }, + { 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 }; @@ -482,7 +482,7 @@ static int num_workers_dflt(CONF_PAIR **out, void *parent, CONF_SECTION *cs, fr_ 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); /* diff --git a/src/lib/server/pool.c b/src/lib/server/pool.c index bb97d8f84e4..1c61d161b5d 100644 --- a/src/lib/server/pool.c +++ b/src/lib/server/pool.c @@ -149,20 +149,20 @@ struct fr_pool_s { }; 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 }; @@ -171,7 +171,7 @@ static int max_dflt(CONF_PAIR **out, UNUSED void *parent, CONF_SECTION *cs, fr_t 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; diff --git a/src/lib/server/tmpl.h b/src/lib/server/tmpl.h index 5fd3fb8bdec..19be4209f9c 100644 --- a/src/lib/server/tmpl.h +++ b/src/lib/server/tmpl.h @@ -58,7 +58,7 @@ * 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. * diff --git a/src/lib/server/trunk.c b/src/lib/server/trunk.c index 1c8c3d0f698..55d609b9171 100644 --- a/src/lib/server/trunk.c +++ b/src/lib/server/trunk.c @@ -288,36 +288,36 @@ struct fr_trunk_s { }; 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 }; diff --git a/src/lib/server/virtual_servers.c b/src/lib/server/virtual_servers.c index eca27e72b55..c6320eee815 100644 --- a/src/lib/server/virtual_servers.c +++ b/src/lib/server/virtual_servers.c @@ -117,7 +117,7 @@ static int listen_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_IT 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 @@ -128,21 +128,21 @@ const conf_parser_t virtual_servers_on_read_config[] = { * Not really ok if it's missing but we want to * let logic elsewhere handle the issue. */ - { 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 }, @@ -154,9 +154,9 @@ const conf_parser_t virtual_servers_config[] = { * 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 @@ -1023,7 +1023,7 @@ virtual_server_method_t const *virtual_server_section_methods(char const *name1, /** 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. diff --git a/src/lib/tls/conf-h b/src/lib/tls/conf-h index bc6772df1a3..ff38fbd467d 100644 --- a/src/lib/tls/conf-h +++ b/src/lib/tls/conf-h @@ -61,21 +61,21 @@ typedef enum { * */ 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 diff --git a/src/lib/tls/conf.c b/src/lib/tls/conf.c index 2a29081adf4..974bdd57078 100644 --- a/src/lib/tls/conf.c +++ b/src/lib/tls/conf.c @@ -81,168 +81,168 @@ static fr_table_num_sorted_t const verify_mode_table[] = { 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 }; diff --git a/src/lib/unlang/call_env.c b/src/lib/unlang/call_env.c index 629cf10695a..952ad1498bd 100644 --- a/src/lib/unlang/call_env.c +++ b/src/lib/unlang/call_env.c @@ -57,7 +57,7 @@ call_env_result_t call_env_value_parse(TALLOC_CTX *ctx, request_t *request, void * 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; @@ -257,7 +257,7 @@ static int call_env_parse(TALLOC_CTX *ctx, call_env_parsed_head_t *parsed, char 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) { @@ -308,7 +308,7 @@ static int call_env_parse(TALLOC_CTX *ctx, call_env_parsed_head_t *parsed, char 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), @@ -330,7 +330,7 @@ static int call_env_parse(TALLOC_CTX *ctx, call_env_parsed_head_t *parsed, char 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, "")); @@ -375,7 +375,7 @@ static size_t call_env_count(size_t *names_len, CONF_SECTION const *cs, call_env *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; diff --git a/src/lib/unlang/call_env.h b/src/lib/unlang/call_env.h index 4282da664f8..910258463b6 100644 --- a/src/lib/unlang/call_env.h +++ b/src/lib/unlang/call_env.h @@ -69,7 +69,8 @@ struct call_env_parser_s { 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. @@ -155,8 +156,8 @@ _Generic((((_s *)NULL)->_f), \ /** 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 @@ -185,7 +186,7 @@ _Generic((((_s *)NULL)->_f), \ 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), \ @@ -205,7 +206,7 @@ _Generic((((_s *)NULL)->_f), \ /** 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), \ @@ -225,7 +226,7 @@ _Generic((((_s *)NULL)->_f), \ /** 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, \ @@ -238,7 +239,7 @@ _Generic((((_s *)NULL)->_f), \ #define FR_CALL_ENV_SUBSECTION(_name, _ident2, _subcs, _required ) \ .name = _name, \ - .type = FR_TYPE_SUBSECTION, \ + .flags = CONF_FLAG_SUBSECTION, \ .section = { \ .ident2 = _ident2, \ .subcs = _subcs, \ diff --git a/src/lib/util/slab.h b/src/lib/util/slab.h index 3177c62809b..127ec748d40 100644 --- a/src/lib/util/slab.h +++ b/src/lib/util/slab.h @@ -33,9 +33,9 @@ extern "C" { /** 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 */ diff --git a/src/listen/arp/proto_arp.c b/src/listen/arp/proto_arp.c index 1e3e4065c3a..687b48aeb7a 100644 --- a/src/listen/arp/proto_arp.c +++ b/src/listen/arp/proto_arp.c @@ -34,9 +34,9 @@ extern fr_app_t proto_arp; * */ 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 }; diff --git a/src/listen/arp/proto_arp_ethernet.c b/src/listen/arp/proto_arp_ethernet.c index 568994b032e..68564fee1c3 100644 --- a/src/listen/arp/proto_arp_ethernet.c +++ b/src/listen/arp/proto_arp_ethernet.c @@ -49,10 +49,10 @@ typedef struct { * */ 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 }; diff --git a/src/listen/bfd/proto_bfd.c b/src/listen/bfd/proto_bfd.c index aa1a077c95f..441180677e8 100644 --- a/src/listen/bfd/proto_bfd.c +++ b/src/listen/bfd/proto_bfd.c @@ -38,22 +38,22 @@ static int auth_type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF * */ 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 }; diff --git a/src/listen/bfd/proto_bfd_udp.c b/src/listen/bfd/proto_bfd_udp.c index 49b3f502040..9fd7c423e81 100644 --- a/src/listen/bfd/proto_bfd_udp.c +++ b/src/listen/bfd/proto_bfd_udp.c @@ -75,32 +75,32 @@ typedef struct { 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 }; diff --git a/src/listen/control/proto_control.c b/src/listen/control/proto_control.c index 4c1e14abcf1..32b51b922c2 100644 --- a/src/listen/control/proto_control.c +++ b/src/listen/control/proto_control.c @@ -30,18 +30,18 @@ extern fr_app_t proto_control; 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 }; @@ -50,10 +50,10 @@ static conf_parser_t const limit_config[] = { * */ 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 }; diff --git a/src/listen/control/proto_control_unix.c b/src/listen/control/proto_control_unix.c index ad6beae2775..4243720739d 100644 --- a/src/listen/control/proto_control_unix.c +++ b/src/listen/control/proto_control_unix.c @@ -82,16 +82,16 @@ typedef struct { } 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 }; diff --git a/src/listen/cron/cron.c b/src/listen/cron/cron.c index 52a2f2e1469..032356f3bed 100644 --- a/src/listen/cron/cron.c +++ b/src/listen/cron/cron.c @@ -35,8 +35,8 @@ static conf_parser_t const limit_config[] = { /* * 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 }; @@ -45,17 +45,17 @@ static conf_parser_t const limit_config[] = { * */ static conf_parser_t const proto_cron_config[] = { - { FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_NOT_EMPTY | FR_TYPE_REQUIRED, proto_cron_t, + { 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 }; diff --git a/src/listen/cron/proto_cron.c b/src/listen/cron/proto_cron.c index db2fe6e9354..e10e7164e40 100644 --- a/src/listen/cron/proto_cron.c +++ b/src/listen/cron/proto_cron.c @@ -37,23 +37,23 @@ static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF * */ 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 }; diff --git a/src/listen/cron/proto_cron_crontab.c b/src/listen/cron/proto_cron_crontab.c index 06fae43502e..93d0b3be975 100644 --- a/src/listen/cron/proto_cron_crontab.c +++ b/src/listen/cron/proto_cron_crontab.c @@ -82,9 +82,9 @@ struct proto_cron_tab_s { 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 diff --git a/src/listen/detail/proto_detail.c b/src/listen/detail/proto_detail.c index d3c61b20eff..66eb807a8c6 100644 --- a/src/listen/detail/proto_detail.c +++ b/src/listen/detail/proto_detail.c @@ -48,25 +48,25 @@ static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF * */ 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 }; diff --git a/src/listen/detail/proto_detail_file.c b/src/listen/detail/proto_detail_file.c index c45e2ca489b..7de261fe6b7 100644 --- a/src/listen/detail/proto_detail_file.c +++ b/src/listen/detail/proto_detail_file.c @@ -72,13 +72,13 @@ static void work_init(proto_detail_file_thread_t *thread, bool triggered_by_dele 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 }; diff --git a/src/listen/detail/proto_detail_work.c b/src/listen/detail/proto_detail_work.c index 935fd30a6be..908d5c44d60 100644 --- a/src/listen/detail/proto_detail_work.c +++ b/src/listen/detail/proto_detail_work.c @@ -65,30 +65,30 @@ typedef struct { } 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 }; diff --git a/src/listen/dhcpv4/proto_dhcpv4.c b/src/listen/dhcpv4/proto_dhcpv4.c index 2e6b6273226..bf8303f29ac 100644 --- a/src/listen/dhcpv4/proto_dhcpv4.c +++ b/src/listen/dhcpv4/proto_dhcpv4.c @@ -34,38 +34,38 @@ static int type_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, c 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 }; @@ -74,12 +74,12 @@ static conf_parser_t const limit_config[] = { * */ static conf_parser_t const proto_dhcpv4_config[] = { - { FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_MULTI | FR_TYPE_NOT_EMPTY, proto_dhcpv4_t, + { 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 }; diff --git a/src/listen/dhcpv4/proto_dhcpv4_udp.c b/src/listen/dhcpv4/proto_dhcpv4_udp.c index 4e2135e41aa..fed50c3e778 100644 --- a/src/listen/dhcpv4/proto_dhcpv4_udp.c +++ b/src/listen/dhcpv4/proto_dhcpv4_udp.c @@ -78,32 +78,32 @@ typedef struct { 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 }; diff --git a/src/listen/dhcpv6/proto_dhcpv6.c b/src/listen/dhcpv6/proto_dhcpv6.c index 0317e96ca85..bae5ded472d 100644 --- a/src/listen/dhcpv6/proto_dhcpv6.c +++ b/src/listen/dhcpv6/proto_dhcpv6.c @@ -33,40 +33,40 @@ static int type_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, c 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 }; @@ -75,12 +75,12 @@ static conf_parser_t const limit_config[] = { * */ static conf_parser_t const proto_dhcpv6_config[] = { - { FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_MULTI | FR_TYPE_NOT_EMPTY, proto_dhcpv6_t, + { 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 }; diff --git a/src/listen/dhcpv6/proto_dhcpv6_udp.c b/src/listen/dhcpv6/proto_dhcpv6_udp.c index d8fc76f2173..1a33c758fb9 100644 --- a/src/listen/dhcpv6/proto_dhcpv6_udp.c +++ b/src/listen/dhcpv6/proto_dhcpv6_udp.c @@ -78,32 +78,32 @@ typedef struct { 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 }; diff --git a/src/listen/dns/proto_dns.c b/src/listen/dns/proto_dns.c index d2740501bab..35a3d21bde6 100644 --- a/src/listen/dns/proto_dns.c +++ b/src/listen/dns/proto_dns.c @@ -33,23 +33,23 @@ static int type_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, c 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 }; @@ -58,12 +58,12 @@ static conf_parser_t const limit_config[] = { * */ static conf_parser_t const proto_dns_config[] = { - { FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_MULTI | FR_TYPE_NOT_EMPTY, proto_dns_t, + { 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 }; diff --git a/src/listen/dns/proto_dns_udp.c b/src/listen/dns/proto_dns_udp.c index cb55835d185..41245fcbe7b 100644 --- a/src/listen/dns/proto_dns_udp.c +++ b/src/listen/dns/proto_dns_udp.c @@ -70,27 +70,27 @@ typedef struct { 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 }; diff --git a/src/listen/ldap_sync/proto_ldap_sync.c b/src/listen/ldap_sync/proto_ldap_sync.c index feb2bc5481c..d060bb57f33 100644 --- a/src/listen/ldap_sync/proto_ldap_sync.c +++ b/src/listen/ldap_sync/proto_ldap_sync.c @@ -36,31 +36,31 @@ extern fr_app_t proto_ldap_sync; 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 }; diff --git a/src/listen/ldap_sync/proto_ldap_sync_ldap.c b/src/listen/ldap_sync/proto_ldap_sync_ldap.c index 5dcd5b65845..def8819e2a0 100644 --- a/src/listen/ldap_sync/proto_ldap_sync_ldap.c +++ b/src/listen/ldap_sync/proto_ldap_sync_ldap.c @@ -48,7 +48,7 @@ static conf_parser_t const proto_ldap_sync_ldap_config[] = { /* * 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 @@ -58,8 +58,8 @@ static conf_parser_t const proto_ldap_sync_ldap_config[] = { /* * 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 }; diff --git a/src/listen/load/proto_load.c b/src/listen/load/proto_load.c index 1252d927e8f..f104598f21a 100644 --- a/src/listen/load/proto_load.c +++ b/src/listen/load/proto_load.c @@ -37,23 +37,23 @@ static int transport_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF * */ 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 }; diff --git a/src/listen/load/proto_load_step.c b/src/listen/load/proto_load_step.c index 3dee3c61372..6db9b17529c 100644 --- a/src/listen/load/proto_load_step.c +++ b/src/listen/load/proto_load_step.c @@ -78,18 +78,18 @@ struct proto_load_step_s { 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 }; diff --git a/src/listen/radius/proto_radius.c b/src/listen/radius/proto_radius.c index 07c2daa899f..af78a24fcba 100644 --- a/src/listen/radius/proto_radius.c +++ b/src/listen/radius/proto_radius.c @@ -34,33 +34,33 @@ static int type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM 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 @@ -70,19 +70,19 @@ static const conf_parser_t priority_config[] = { * */ static conf_parser_t const proto_radius_config[] = { - { FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_MULTI | FR_TYPE_NOT_EMPTY, proto_radius_t, + { 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 }; diff --git a/src/listen/radius/proto_radius_tcp.c b/src/listen/radius/proto_radius_tcp.c index c213af0dab5..64040a6c8a2 100644 --- a/src/listen/radius/proto_radius_tcp.c +++ b/src/listen/radius/proto_radius_tcp.c @@ -71,30 +71,30 @@ typedef struct { 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 }; diff --git a/src/listen/radius/proto_radius_udp.c b/src/listen/radius/proto_radius_udp.c index 9d5054cc6f6..7420a9a4643 100644 --- a/src/listen/radius/proto_radius_udp.c +++ b/src/listen/radius/proto_radius_udp.c @@ -79,34 +79,34 @@ typedef struct { 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 }; diff --git a/src/listen/tacacs/proto_tacacs.c b/src/listen/tacacs/proto_tacacs.c index 9f1f03e7b0a..adb34f63206 100644 --- a/src/listen/tacacs/proto_tacacs.c +++ b/src/listen/tacacs/proto_tacacs.c @@ -37,40 +37,40 @@ static int type_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, U 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 }; diff --git a/src/listen/tacacs/proto_tacacs_tcp.c b/src/listen/tacacs/proto_tacacs_tcp.c index ebfcda82aba..39638010f0a 100644 --- a/src/listen/tacacs/proto_tacacs_tcp.c +++ b/src/listen/tacacs/proto_tacacs_tcp.c @@ -71,28 +71,28 @@ typedef struct { } 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 }; diff --git a/src/listen/vmps/proto_vmps.c b/src/listen/vmps/proto_vmps.c index e4217345859..4a731deb7ed 100644 --- a/src/listen/vmps/proto_vmps.c +++ b/src/listen/vmps/proto_vmps.c @@ -36,27 +36,27 @@ 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("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 }; @@ -65,13 +65,13 @@ static conf_parser_t const limit_config[] = { * */ static conf_parser_t const proto_vmps_config[] = { - { FR_CONF_OFFSET("type", FR_TYPE_VOID | FR_TYPE_MULTI | FR_TYPE_NOT_EMPTY, proto_vmps_t, + { 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 }; diff --git a/src/listen/vmps/proto_vmps_udp.c b/src/listen/vmps/proto_vmps_udp.c index 5a9ee069122..8201050c70d 100644 --- a/src/listen/vmps/proto_vmps_udp.c +++ b/src/listen/vmps/proto_vmps_udp.c @@ -73,28 +73,28 @@ typedef struct { 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 }; diff --git a/src/modules/rlm_always/rlm_always.c b/src/modules/rlm_always/rlm_always.c index 4f837883682..d55fa0edcb8 100644 --- a/src/modules/rlm_always/rlm_always.c +++ b/src/modules/rlm_always/rlm_always.c @@ -47,9 +47,9 @@ typedef struct { * 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 }; diff --git a/src/modules/rlm_attr_filter/rlm_attr_filter.c b/src/modules/rlm_attr_filter/rlm_attr_filter.c index 91e317878b3..84c2e7fc816 100644 --- a/src/modules/rlm_attr_filter/rlm_attr_filter.c +++ b/src/modules/rlm_attr_filter/rlm_attr_filter.c @@ -48,9 +48,9 @@ typedef struct { } 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 }; diff --git a/src/modules/rlm_cache/drivers/rlm_cache_memcached/rlm_cache_memcached.c b/src/modules/rlm_cache/drivers/rlm_cache_memcached/rlm_cache_memcached.c index 73d104704a5..1d05e41092c 100644 --- a/src/modules/rlm_cache/drivers/rlm_cache_memcached/rlm_cache_memcached.c +++ b/src/modules/rlm_cache/drivers/rlm_cache_memcached/rlm_cache_memcached.c @@ -44,7 +44,7 @@ typedef struct { } 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 }; diff --git a/src/modules/rlm_cache/rlm_cache.c b/src/modules/rlm_cache/rlm_cache.c index ad530e019ff..a75788df342 100644 --- a/src/modules/rlm_cache/rlm_cache.c +++ b/src/modules/rlm_cache/rlm_cache.c @@ -39,14 +39,14 @@ RCSID("$Id$") 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 }; @@ -57,7 +57,7 @@ typedef struct { 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 } diff --git a/src/modules/rlm_chap/rlm_chap.c b/src/modules/rlm_chap/rlm_chap.c index 915ffaba212..cc83a58d956 100644 --- a/src/modules/rlm_chap/rlm_chap.c +++ b/src/modules/rlm_chap/rlm_chap.c @@ -38,7 +38,7 @@ typedef struct { } 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 }; @@ -49,7 +49,7 @@ typedef struct { 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 } @@ -64,9 +64,9 @@ typedef struct { 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 } @@ -81,11 +81,11 @@ typedef struct { 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 } diff --git a/src/modules/rlm_cipher/rlm_cipher.c b/src/modules/rlm_cipher/rlm_cipher.c index 295ab805e2d..c0050371701 100644 --- a/src/modules/rlm_cipher/rlm_cipher.c +++ b/src/modules/rlm_cipher/rlm_cipher.c @@ -194,9 +194,9 @@ typedef struct { * */ 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 }; @@ -205,7 +205,7 @@ static const conf_parser_t rsa_oaep_config[] = { * */ 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, @@ -213,17 +213,17 @@ static const conf_parser_t rsa_config[] = { }, .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 @@ -233,8 +233,8 @@ static const conf_parser_t rsa_config[] = { * 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 diff --git a/src/modules/rlm_couchbase/rlm_couchbase.c b/src/modules/rlm_couchbase/rlm_couchbase.c index ab3eaa035be..0abc829905f 100644 --- a/src/modules/rlm_couchbase/rlm_couchbase.c +++ b/src/modules/rlm_couchbase/rlm_couchbase.c @@ -42,7 +42,7 @@ RCSID("$Id$") * 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 }; @@ -50,18 +50,18 @@ static const conf_parser_t client_config[] = { * 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 }; diff --git a/src/modules/rlm_csv/rlm_csv.c b/src/modules/rlm_csv/rlm_csv.c index cbfb090570b..535abbbea0b 100644 --- a/src/modules/rlm_csv/rlm_csv.c +++ b/src/modules/rlm_csv/rlm_csv.c @@ -79,13 +79,13 @@ struct rlm_csv_entry_s { * 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 }; diff --git a/src/modules/rlm_date/rlm_date.c b/src/modules/rlm_date/rlm_date.c index e2756fc371d..87174580bb6 100644 --- a/src/modules/rlm_date/rlm_date.c +++ b/src/modules/rlm_date/rlm_date.c @@ -36,8 +36,8 @@ typedef struct { } 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 }; diff --git a/src/modules/rlm_delay/rlm_delay.c b/src/modules/rlm_delay/rlm_delay.c index 35d978fc5f5..dde228738e5 100644 --- a/src/modules/rlm_delay/rlm_delay.c +++ b/src/modules/rlm_delay/rlm_delay.c @@ -41,9 +41,9 @@ typedef struct { * 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 }; diff --git a/src/modules/rlm_detail/rlm_detail.c b/src/modules/rlm_detail/rlm_detail.c index 2adc69f76ca..3396b8a0241 100644 --- a/src/modules/rlm_detail/rlm_detail.c +++ b/src/modules/rlm_detail/rlm_detail.c @@ -74,14 +74,14 @@ int detail_group_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent, 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 }; diff --git a/src/modules/rlm_dhcpv4/rlm_dhcpv4.c b/src/modules/rlm_dhcpv4/rlm_dhcpv4.c index 80252624d47..260df5fe688 100644 --- a/src/modules/rlm_dhcpv4/rlm_dhcpv4.c +++ b/src/modules/rlm_dhcpv4/rlm_dhcpv4.c @@ -83,19 +83,19 @@ typedef struct { } 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 }; diff --git a/src/modules/rlm_eap/rlm_eap.c b/src/modules/rlm_eap/rlm_eap.c index 6e786bff90a..adf4150b6b9 100644 --- a/src/modules/rlm_eap/rlm_eap.c +++ b/src/modules/rlm_eap/rlm_eap.c @@ -61,22 +61,22 @@ static fr_table_num_sorted_t const require_identity_realm_table[] = { 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 }; diff --git a/src/modules/rlm_eap/types/rlm_eap_aka/rlm_eap_aka.c b/src/modules/rlm_eap/types/rlm_eap_aka/rlm_eap_aka.c index fae01fcf219..c59da89c898 100644 --- a/src/modules/rlm_eap/types/rlm_eap_aka/rlm_eap_aka.c +++ b/src/modules/rlm_eap/types/rlm_eap_aka/rlm_eap_aka.c @@ -37,8 +37,8 @@ RCSID("$Id$") #include 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 }; diff --git a/src/modules/rlm_eap/types/rlm_eap_aka_prime/rlm_eap_aka_prime.c b/src/modules/rlm_eap/types/rlm_eap_aka_prime/rlm_eap_aka_prime.c index fd4841875e0..9695667267c 100644 --- a/src/modules/rlm_eap/types/rlm_eap_aka_prime/rlm_eap_aka_prime.c +++ b/src/modules/rlm_eap/types/rlm_eap_aka_prime/rlm_eap_aka_prime.c @@ -37,7 +37,7 @@ RCSID("$Id$") #include 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 }; diff --git a/src/modules/rlm_eap/types/rlm_eap_fast/rlm_eap_fast.c b/src/modules/rlm_eap/types/rlm_eap_fast/rlm_eap_fast.c index f07c95d0f0b..e020c3cfef0 100644 --- a/src/modules/rlm_eap/types/rlm_eap_fast/rlm_eap_fast.c +++ b/src/modules/rlm_eap/types/rlm_eap_fast/rlm_eap_fast.c @@ -62,18 +62,18 @@ typedef struct { 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 }; diff --git a/src/modules/rlm_eap/types/rlm_eap_gtc/rlm_eap_gtc.c b/src/modules/rlm_eap/types/rlm_eap_gtc/rlm_eap_gtc.c index f609ac3c366..ac3dfbda8ee 100644 --- a/src/modules/rlm_eap/types/rlm_eap_gtc/rlm_eap_gtc.c +++ b/src/modules/rlm_eap/types/rlm_eap_gtc/rlm_eap_gtc.c @@ -44,8 +44,8 @@ typedef struct { } 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 }; diff --git a/src/modules/rlm_eap/types/rlm_eap_mschapv2/rlm_eap_mschapv2.c b/src/modules/rlm_eap/types/rlm_eap_mschapv2/rlm_eap_mschapv2.c index ffbc8933211..79ce2ccc71d 100644 --- a/src/modules/rlm_eap/types/rlm_eap_mschapv2/rlm_eap_mschapv2.c +++ b/src/modules/rlm_eap/types/rlm_eap_mschapv2/rlm_eap_mschapv2.c @@ -44,11 +44,11 @@ typedef struct { } 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 }; diff --git a/src/modules/rlm_eap/types/rlm_eap_peap/rlm_eap_peap.c b/src/modules/rlm_eap/types/rlm_eap_peap/rlm_eap_peap.c index 91ffdf88534..d075269089c 100644 --- a/src/modules/rlm_eap/types/rlm_eap_peap/rlm_eap_peap.c +++ b/src/modules/rlm_eap/types/rlm_eap_peap/rlm_eap_peap.c @@ -48,19 +48,19 @@ typedef struct { } 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 }; diff --git a/src/modules/rlm_eap/types/rlm_eap_pwd/rlm_eap_pwd.c b/src/modules/rlm_eap/types/rlm_eap_pwd/rlm_eap_pwd.c index b4fa6ecad35..ce1deeb21ae 100644 --- a/src/modules/rlm_eap/types/rlm_eap_pwd/rlm_eap_pwd.c +++ b/src/modules/rlm_eap/types/rlm_eap_pwd/rlm_eap_pwd.c @@ -52,9 +52,9 @@ typedef struct { #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 }; diff --git a/src/modules/rlm_eap/types/rlm_eap_sim/rlm_eap_sim.c b/src/modules/rlm_eap/types/rlm_eap_sim/rlm_eap_sim.c index 2b156d2c9c5..6d5c31c01f2 100644 --- a/src/modules/rlm_eap/types/rlm_eap_sim/rlm_eap_sim.c +++ b/src/modules/rlm_eap/types/rlm_eap_sim/rlm_eap_sim.c @@ -37,7 +37,7 @@ RCSID("$Id$") #include 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 }; diff --git a/src/modules/rlm_eap/types/rlm_eap_tls/rlm_eap_tls.c b/src/modules/rlm_eap/types/rlm_eap_tls/rlm_eap_tls.c index 439d07a1a80..84eddfe0635 100644 --- a/src/modules/rlm_eap/types/rlm_eap_tls/rlm_eap_tls.c +++ b/src/modules/rlm_eap/types/rlm_eap_tls/rlm_eap_tls.c @@ -43,11 +43,11 @@ typedef struct { } 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 }; diff --git a/src/modules/rlm_eap/types/rlm_eap_ttls/rlm_eap_ttls.c b/src/modules/rlm_eap/types/rlm_eap_ttls/rlm_eap_ttls.c index 0f9965b5524..142ced47503 100644 --- a/src/modules/rlm_eap/types/rlm_eap_ttls/rlm_eap_ttls.c +++ b/src/modules/rlm_eap/types/rlm_eap_ttls/rlm_eap_ttls.c @@ -64,12 +64,12 @@ typedef struct { 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 }; diff --git a/src/modules/rlm_escape/rlm_escape.c b/src/modules/rlm_escape/rlm_escape.c index 843c74eca03..d9bc927d3d3 100644 --- a/src/modules/rlm_escape/rlm_escape.c +++ b/src/modules/rlm_escape/rlm_escape.c @@ -41,7 +41,7 @@ typedef struct { } 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 }; diff --git a/src/modules/rlm_exec/rlm_exec.c b/src/modules/rlm_exec/rlm_exec.c index 96e34e8e575..e0d95d760df 100644 --- a/src/modules/rlm_exec/rlm_exec.c +++ b/src/modules/rlm_exec/rlm_exec.c @@ -55,12 +55,12 @@ typedef struct { } 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 }; @@ -71,7 +71,7 @@ typedef struct { 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 } diff --git a/src/modules/rlm_files/rlm_files.c b/src/modules/rlm_files/rlm_files.c index 185ac53c98d..37331a105f5 100644 --- a/src/modules/rlm_files/rlm_files.c +++ b/src/modules/rlm_files/rlm_files.c @@ -90,12 +90,12 @@ fr_dict_attr_autoload_t rlm_files_dict_attr[] = { 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 }; @@ -709,7 +709,7 @@ static unlang_action_t CC_HINT(nonnull) mod_post_auth(rlm_rcode_t *p_result, mod 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 }, diff --git a/src/modules/rlm_icmp/rlm_icmp.c b/src/modules/rlm_icmp/rlm_icmp.c index 6dca5279821..b992ab4f386 100644 --- a/src/modules/rlm_icmp/rlm_icmp.c +++ b/src/modules/rlm_icmp/rlm_icmp.c @@ -104,9 +104,9 @@ static uint16_t icmp_checksum(uint8_t *data, size_t data_len, uint16_t checksum) } 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 }; diff --git a/src/modules/rlm_idn/rlm_idn.c b/src/modules/rlm_idn/rlm_idn.c index cd781f8ad5f..ff4f3a768cf 100644 --- a/src/modules/rlm_idn/rlm_idn.c +++ b/src/modules/rlm_idn/rlm_idn.c @@ -82,8 +82,8 @@ static const conf_parser_t mod_config[] = { * 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 }; diff --git a/src/modules/rlm_imap/rlm_imap.c b/src/modules/rlm_imap/rlm_imap.c index 66b75ff580e..32bea363f41 100644 --- a/src/modules/rlm_imap/rlm_imap.c +++ b/src/modules/rlm_imap/rlm_imap.c @@ -73,10 +73,10 @@ typedef struct { * 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 },//!= 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 @@ -255,7 +255,7 @@ static int status_check_type_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED voi */ 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 diff --git a/src/modules/rlm_radius/rlm_radius_udp.c b/src/modules/rlm_radius/rlm_radius_udp.c index 027e99c3217..725b6b1bfe2 100644 --- a/src/modules/rlm_radius/rlm_radius_udp.c +++ b/src/modules/rlm_radius/rlm_radius_udp.c @@ -162,25 +162,25 @@ struct udp_request_s { }; 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 }; diff --git a/src/modules/rlm_radutmp/rlm_radutmp.c b/src/modules/rlm_radutmp/rlm_radutmp.c index f77b9214bc6..97eccbe235c 100644 --- a/src/modules/rlm_radutmp/rlm_radutmp.c +++ b/src/modules/rlm_radutmp/rlm_radutmp.c @@ -58,11 +58,11 @@ typedef struct { } 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 }; diff --git a/src/modules/rlm_redis/rlm_redis.c b/src/modules/rlm_redis/rlm_redis.c index 916ea52e5c1..1f1ce322b59 100644 --- a/src/modules/rlm_redis/rlm_redis.c +++ b/src/modules/rlm_redis/rlm_redis.c @@ -88,15 +88,15 @@ typedef struct { 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 }; diff --git a/src/modules/rlm_redis_ippool/rlm_redis_ippool.c b/src/modules/rlm_redis_ippool/rlm_redis_ippool.c index 9225231afe3..cad99d12788 100644 --- a/src/modules/rlm_redis_ippool/rlm_redis_ippool.c +++ b/src/modules/rlm_redis_ippool/rlm_redis_ippool.c @@ -83,21 +83,21 @@ static conf_parser_t redis_config[] = { }; static conf_parser_t module_config[] = { - { FR_CONF_OFFSET("wait_num", FR_TYPE_UINT32, rlm_redis_ippool_t, wait_num) }, - { FR_CONF_OFFSET("wait_timeout", FR_TYPE_TIME_DELTA, rlm_redis_ippool_t, wait_timeout) }, + { 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 }; @@ -183,24 +183,24 @@ typedef struct { 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 } @@ -209,22 +209,22 @@ static const call_env_method_t redis_ippool_alloc_method_env = { 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 } @@ -233,13 +233,13 @@ static const call_env_method_t redis_ippool_update_method_env = { 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 @@ -249,9 +249,9 @@ static const call_env_method_t redis_ippool_release_method_env = { 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 } diff --git a/src/modules/rlm_rediswho/rlm_rediswho.c b/src/modules/rlm_rediswho/rlm_rediswho.c index 29c3e00d755..c13aa71f72e 100644 --- a/src/modules/rlm_rediswho/rlm_rediswho.c +++ b/src/modules/rlm_rediswho/rlm_rediswho.c @@ -52,27 +52,27 @@ typedef struct { } 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 }; diff --git a/src/modules/rlm_rest/rlm_rest.c b/src/modules/rlm_rest/rlm_rest.c index 0666ad9a80a..532de02e99d 100644 --- a/src/modules/rlm_rest/rlm_rest.c +++ b/src/modules/rlm_rest/rlm_rest.c @@ -89,68 +89,68 @@ static int rest_proxy_parse(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *pare } 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 diff --git a/src/modules/rlm_securid/rlm_securid.c b/src/modules/rlm_securid/rlm_securid.c index 59b32ff4ab1..e99d7e11929 100644 --- a/src/modules/rlm_securid/rlm_securid.c +++ b/src/modules/rlm_securid/rlm_securid.c @@ -42,10 +42,10 @@ typedef enum { 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 }; diff --git a/src/modules/rlm_sigtran/rlm_sigtran.c b/src/modules/rlm_sigtran/rlm_sigtran.c index 5c406692a6c..8011345929d 100644 --- a/src/modules/rlm_sigtran/rlm_sigtran.c +++ b/src/modules/rlm_sigtran/rlm_sigtran.c @@ -71,86 +71,86 @@ static fr_table_num_sorted_t const m3ua_traffic_mode_table[] = { 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 }; diff --git a/src/modules/rlm_smtp/rlm_smtp.c b/src/modules/rlm_smtp/rlm_smtp.c index 5c55f46757c..65d0bb0dc5e 100644 --- a/src/modules/rlm_smtp/rlm_smtp.c +++ b/src/modules/rlm_smtp/rlm_smtp.c @@ -153,7 +153,7 @@ static int cf_table_parse_tmpl(TALLOC_CTX *ctx, void *out, UNUSED void *parent, 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; @@ -213,25 +213,25 @@ finish: * 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 },//!= 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 }; diff --git a/src/modules/rlm_sql/drivers/rlm_sql_mysql/rlm_sql_mysql.c b/src/modules/rlm_sql/drivers/rlm_sql_mysql/rlm_sql_mysql.c index 9f4bd6f45a4..eb903fb8b9c 100644 --- a/src/modules/rlm_sql/drivers/rlm_sql_mysql/rlm_sql_mysql.c +++ b/src/modules/rlm_sql/drivers/rlm_sql_mysql/rlm_sql_mysql.c @@ -114,19 +114,19 @@ typedef struct { } 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 @@ -137,19 +137,19 @@ static conf_parser_t tls_config[] = { * 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 }; diff --git a/src/modules/rlm_sql/drivers/rlm_sql_oracle/rlm_sql_oracle.c b/src/modules/rlm_sql/drivers/rlm_sql_oracle/rlm_sql_oracle.c index 1b052194d8a..17afd4cf03b 100644 --- a/src/modules/rlm_sql/drivers/rlm_sql_oracle/rlm_sql_oracle.c +++ b/src/modules/rlm_sql/drivers/rlm_sql_oracle/rlm_sql_oracle.c @@ -73,16 +73,16 @@ typedef struct { } 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 }; diff --git a/src/modules/rlm_sql/drivers/rlm_sql_postgresql/rlm_sql_postgresql.c b/src/modules/rlm_sql/drivers/rlm_sql_postgresql/rlm_sql_postgresql.c index 1fee312fd66..bfc22295cf2 100644 --- a/src/modules/rlm_sql/drivers/rlm_sql_postgresql/rlm_sql_postgresql.c +++ b/src/modules/rlm_sql/drivers/rlm_sql_postgresql/rlm_sql_postgresql.c @@ -75,7 +75,7 @@ typedef struct { } 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 }; diff --git a/src/modules/rlm_sql/drivers/rlm_sql_sqlite/rlm_sql_sqlite.c b/src/modules/rlm_sql/drivers/rlm_sql_sqlite/rlm_sql_sqlite.c index e04bc05eda2..2dabc8b2733 100644 --- a/src/modules/rlm_sql/drivers/rlm_sql_sqlite/rlm_sql_sqlite.c +++ b/src/modules/rlm_sql/drivers/rlm_sql_sqlite/rlm_sql_sqlite.c @@ -61,7 +61,7 @@ typedef struct { } 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 }; diff --git a/src/modules/rlm_sql/rlm_sql.c b/src/modules/rlm_sql/rlm_sql.c index 710bc27ce1f..5cd297cc40c 100644 --- a/src/modules/rlm_sql/rlm_sql.c +++ b/src/modules/rlm_sql/rlm_sql.c @@ -49,7 +49,7 @@ extern module_rlm_t rlm_sql; * 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 }; @@ -58,60 +58,60 @@ static const conf_parser_t query_config[] = { * 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 }; diff --git a/src/modules/rlm_sqlcounter/rlm_sqlcounter.c b/src/modules/rlm_sqlcounter/rlm_sqlcounter.c index e29a783c60d..f1e36f0fba9 100644 --- a/src/modules/rlm_sqlcounter/rlm_sqlcounter.c +++ b/src/modules/rlm_sqlcounter/rlm_sqlcounter.c @@ -77,25 +77,25 @@ typedef struct { } 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 }; diff --git a/src/modules/rlm_sqlippool/rlm_sqlippool.c b/src/modules/rlm_sqlippool/rlm_sqlippool.c index 283c039a063..d0963670df4 100644 --- a/src/modules/rlm_sqlippool/rlm_sqlippool.c +++ b/src/modules/rlm_sqlippool/rlm_sqlippool.c @@ -96,75 +96,75 @@ typedef struct { } 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 }; diff --git a/src/modules/rlm_tacacs/rlm_tacacs.c b/src/modules/rlm_tacacs/rlm_tacacs.c index bc01fed3e5b..b9b7e948d72 100644 --- a/src/modules/rlm_tacacs/rlm_tacacs.c +++ b/src/modules/rlm_tacacs/rlm_tacacs.c @@ -36,10 +36,10 @@ static int type_parse(TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM * 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 }; @@ -47,23 +47,23 @@ static conf_parser_t retry_config[] = { * 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 }; diff --git a/src/modules/rlm_tacacs/rlm_tacacs_tcp.c b/src/modules/rlm_tacacs/rlm_tacacs_tcp.c index c2abefb1173..db7a24ab75c 100644 --- a/src/modules/rlm_tacacs/rlm_tacacs_tcp.c +++ b/src/modules/rlm_tacacs/rlm_tacacs_tcp.c @@ -153,25 +153,25 @@ struct udp_request_s { }; 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 }; diff --git a/src/modules/rlm_test/rlm_test.c b/src/modules/rlm_test/rlm_test.c index bbd4c011192..8ecb0f518dd 100644 --- a/src/modules/rlm_test/rlm_test.c +++ b/src/modules/rlm_test/rlm_test.c @@ -120,59 +120,59 @@ typedef struct { * 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 }; diff --git a/src/modules/rlm_totp/rlm_totp.c b/src/modules/rlm_totp/rlm_totp.c index 3217ed639be..1712128f7a2 100644 --- a/src/modules/rlm_totp/rlm_totp.c +++ b/src/modules/rlm_totp/rlm_totp.c @@ -42,13 +42,13 @@ typedef struct { 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 @@ -63,10 +63,10 @@ typedef struct rlm_totp_t { /* 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 }; diff --git a/src/modules/rlm_unbound/rlm_unbound.c b/src/modules/rlm_unbound/rlm_unbound.c index 1d0e66527f5..dc98d975c1d 100644 --- a/src/modules/rlm_unbound/rlm_unbound.c +++ b/src/modules/rlm_unbound/rlm_unbound.c @@ -69,10 +69,10 @@ typedef struct { * 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 }; diff --git a/src/modules/rlm_unix/rlm_unix.c b/src/modules/rlm_unix/rlm_unix.c index f4d466a03b6..a11e14dca4e 100644 --- a/src/modules/rlm_unix/rlm_unix.c +++ b/src/modules/rlm_unix/rlm_unix.c @@ -53,7 +53,7 @@ typedef struct { } 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 }; diff --git a/src/modules/rlm_wimax/rlm_wimax.c b/src/modules/rlm_wimax/rlm_wimax.c index 692122c8345..8a1b1be0973 100644 --- a/src/modules/rlm_wimax/rlm_wimax.c +++ b/src/modules/rlm_wimax/rlm_wimax.c @@ -45,7 +45,7 @@ typedef struct { } 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 }; diff --git a/src/modules/rlm_winbind/rlm_winbind.c b/src/modules/rlm_winbind/rlm_winbind.c index 527ac89d4dc..1af460e1376 100644 --- a/src/modules/rlm_winbind/rlm_winbind.c +++ b/src/modules/rlm_winbind/rlm_winbind.c @@ -38,16 +38,16 @@ RCSID("$Id$") #include 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 }; diff --git a/src/modules/rlm_yubikey/rlm_yubikey.c b/src/modules/rlm_yubikey/rlm_yubikey.c index 41e6851ba6b..6fd294fb065 100644 --- a/src/modules/rlm_yubikey/rlm_yubikey.c +++ b/src/modules/rlm_yubikey/rlm_yubikey.c @@ -31,19 +31,19 @@ RCSID("$Id$") #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 }; diff --git a/src/process/dhcpv6/base.c b/src/process/dhcpv6/base.c index 6c6dcf90044..71c9f94d17f 100644 --- a/src/process/dhcpv6/base.c +++ b/src/process/dhcpv6/base.c @@ -186,9 +186,9 @@ fr_dict_enum_autoload_t process_dhcpv6_dict_enum[] = { #include 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 }; diff --git a/src/process/eap_aka/base.c b/src/process/eap_aka/base.c index 5b16e9ac44e..6ecd1f763f6 100644 --- a/src/process/eap_aka/base.c +++ b/src/process/eap_aka/base.c @@ -35,12 +35,12 @@ #include 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 }; diff --git a/src/process/eap_aka_prime/base.c b/src/process/eap_aka_prime/base.c index 65bf5f1c2c3..7faedd98772 100644 --- a/src/process/eap_aka_prime/base.c +++ b/src/process/eap_aka_prime/base.c @@ -35,13 +35,13 @@ #include 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 }; diff --git a/src/process/eap_sim/base.c b/src/process/eap_sim/base.c index 7e7071bbc9b..bd1c4eb9155 100644 --- a/src/process/eap_sim/base.c +++ b/src/process/eap_sim/base.c @@ -35,12 +35,12 @@ #include 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 }; diff --git a/src/process/radius/base.c b/src/process/radius/base.c index 7ca78484ec6..c72b8116574 100644 --- a/src/process/radius/base.c +++ b/src/process/radius/base.c @@ -182,35 +182,35 @@ typedef struct { #include 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 diff --git a/src/process/tacacs/base.c b/src/process/tacacs/base.c index 7ee88ac2b7f..7992bdd3d02 100644 --- a/src/process/tacacs/base.c +++ b/src/process/tacacs/base.c @@ -207,36 +207,36 @@ typedef struct { #include 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 diff --git a/src/process/ttls/base.c b/src/process/ttls/base.c index eb21d256904..290a98fcb31 100644 --- a/src/process/ttls/base.c +++ b/src/process/ttls/base.c @@ -166,21 +166,21 @@ typedef struct { #include 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 };