Introduce main config option allow_insecure_tainted_data
[exim.git] / src / src / readconf.c
index 1cbbd83ef868383f64770614e5ff3d529bdbeb91..133135f8fd38eb5331311c3c72932b25dead11e2 100644 (file)
@@ -2,7 +2,8 @@
 *     Exim - an Internet mail transport agent    *
 *************************************************/
 
-/* Copyright (c) University of Cambridge 1995 - 2016 */
+/* Copyright (c) University of Cambridge 1995 - 2018 */
+/* Copyright (c) The Exim Maintainers 2020 */
 /* See the file NOTICE for conditions of use and distribution. */
 
 /* Functions for reading the configuration file, and for displaying
@@ -15,8 +16,11 @@ implementation of the conditional .ifdef etc. */
 # include "macro_predef.h"
 #endif
 
+#define READCONF_DEBUG if (FALSE)      /* Change to TRUE to enable */
+
+
 static uschar * syslog_facility_str;
-static void fn_smtp_receive_timeout(const uschar *, const uschar *);
+static void fn_smtp_receive_timeout(const uschar *, const uschar *, unsigned);
 
 /*************************************************
 *           Main configuration options           *
@@ -26,350 +30,374 @@ static void fn_smtp_receive_timeout(const uschar *, const uschar *);
 must be in alphabetic order because it is searched by binary chop. */
 
 static optionlist optionlist_config[] = {
-  { "*set_exim_group",          opt_bool|opt_hidden, &exim_gid_set },
-  { "*set_exim_user",           opt_bool|opt_hidden, &exim_uid_set },
-  { "*set_system_filter_group", opt_bool|opt_hidden, &system_filter_gid_set },
-  { "*set_system_filter_user",  opt_bool|opt_hidden, &system_filter_uid_set },
-  { "accept_8bitmime",          opt_bool,        &accept_8bitmime },
-  { "acl_not_smtp",             opt_stringptr,   &acl_not_smtp },
+  { "*set_exim_group",          opt_bool|opt_hidden, {&exim_gid_set} },
+  { "*set_exim_user",           opt_bool|opt_hidden, {&exim_uid_set} },
+  { "*set_system_filter_group", opt_bool|opt_hidden, {&system_filter_gid_set} },
+  { "*set_system_filter_user",  opt_bool|opt_hidden, {&system_filter_uid_set} },
+  { "accept_8bitmime",          opt_bool,        {&accept_8bitmime} },
+  { "acl_not_smtp",             opt_stringptr,   {&acl_not_smtp} },
 #ifdef WITH_CONTENT_SCAN
-  { "acl_not_smtp_mime",        opt_stringptr,   &acl_not_smtp_mime },
+  { "acl_not_smtp_mime",        opt_stringptr,   {&acl_not_smtp_mime} },
 #endif
-  { "acl_not_smtp_start",       opt_stringptr,   &acl_not_smtp_start },
-  { "acl_smtp_auth",            opt_stringptr,   &acl_smtp_auth },
-  { "acl_smtp_connect",         opt_stringptr,   &acl_smtp_connect },
-  { "acl_smtp_data",            opt_stringptr,   &acl_smtp_data },
+  { "acl_not_smtp_start",       opt_stringptr,   {&acl_not_smtp_start} },
+  { "acl_smtp_auth",            opt_stringptr,   {&acl_smtp_auth} },
+  { "acl_smtp_connect",         opt_stringptr,   {&acl_smtp_connect} },
+  { "acl_smtp_data",            opt_stringptr,   {&acl_smtp_data} },
 #ifndef DISABLE_PRDR
-  { "acl_smtp_data_prdr",       opt_stringptr,   &acl_smtp_data_prdr },
+  { "acl_smtp_data_prdr",       opt_stringptr,   {&acl_smtp_data_prdr} },
 #endif
 #ifndef DISABLE_DKIM
-  { "acl_smtp_dkim",            opt_stringptr,   &acl_smtp_dkim },
+  { "acl_smtp_dkim",            opt_stringptr,   {&acl_smtp_dkim} },
 #endif
-  { "acl_smtp_etrn",            opt_stringptr,   &acl_smtp_etrn },
-  { "acl_smtp_expn",            opt_stringptr,   &acl_smtp_expn },
-  { "acl_smtp_helo",            opt_stringptr,   &acl_smtp_helo },
-  { "acl_smtp_mail",            opt_stringptr,   &acl_smtp_mail },
-  { "acl_smtp_mailauth",        opt_stringptr,   &acl_smtp_mailauth },
+  { "acl_smtp_etrn",            opt_stringptr,   {&acl_smtp_etrn} },
+  { "acl_smtp_expn",            opt_stringptr,   {&acl_smtp_expn} },
+  { "acl_smtp_helo",            opt_stringptr,   {&acl_smtp_helo} },
+  { "acl_smtp_mail",            opt_stringptr,   {&acl_smtp_mail} },
+  { "acl_smtp_mailauth",        opt_stringptr,   {&acl_smtp_mailauth} },
 #ifdef WITH_CONTENT_SCAN
-  { "acl_smtp_mime",            opt_stringptr,   &acl_smtp_mime },
+  { "acl_smtp_mime",            opt_stringptr,   {&acl_smtp_mime} },
+#endif
+  { "acl_smtp_notquit",         opt_stringptr,   {&acl_smtp_notquit} },
+  { "acl_smtp_predata",         opt_stringptr,   {&acl_smtp_predata} },
+  { "acl_smtp_quit",            opt_stringptr,   {&acl_smtp_quit} },
+  { "acl_smtp_rcpt",            opt_stringptr,   {&acl_smtp_rcpt} },
+#ifndef DISABLE_TLS
+  { "acl_smtp_starttls",        opt_stringptr,   {&acl_smtp_starttls} },
 #endif
-  { "acl_smtp_notquit",         opt_stringptr,   &acl_smtp_notquit },
-  { "acl_smtp_predata",         opt_stringptr,   &acl_smtp_predata },
-  { "acl_smtp_quit",            opt_stringptr,   &acl_smtp_quit },
-  { "acl_smtp_rcpt",            opt_stringptr,   &acl_smtp_rcpt },
-#ifdef SUPPORT_TLS
-  { "acl_smtp_starttls",        opt_stringptr,   &acl_smtp_starttls },
+  { "acl_smtp_vrfy",            opt_stringptr,   {&acl_smtp_vrfy} },
+  { "add_environment",          opt_stringptr,   {&add_environment} },
+  { "admin_groups",             opt_gidlist,     {&admin_groups} },
+  { "allow_domain_literals",    opt_bool,        {&allow_domain_literals} },
+#ifdef ALLOW_INSECURE_TAINTED_DATA
+  { "allow_insecure_tainted_data", opt_bool,     {&allow_insecure_tainted_data} },
 #endif
-  { "acl_smtp_vrfy",            opt_stringptr,   &acl_smtp_vrfy },
-  { "add_environment",          opt_stringptr,   &add_environment },
-  { "admin_groups",             opt_gidlist,     &admin_groups },
-  { "allow_domain_literals",    opt_bool,        &allow_domain_literals },
-  { "allow_mx_to_ip",           opt_bool,        &allow_mx_to_ip },
-  { "allow_utf8_domains",       opt_bool,        &allow_utf8_domains },
-  { "auth_advertise_hosts",     opt_stringptr,   &auth_advertise_hosts },
-  { "auto_thaw",                opt_time,        &auto_thaw },
+  { "allow_mx_to_ip",           opt_bool,        {&allow_mx_to_ip} },
+  { "allow_utf8_domains",       opt_bool,        {&allow_utf8_domains} },
+  { "auth_advertise_hosts",     opt_stringptr,   {&auth_advertise_hosts} },
+  { "auto_thaw",                opt_time,        {&auto_thaw} },
 #ifdef WITH_CONTENT_SCAN
-  { "av_scanner",               opt_stringptr,   &av_scanner },
+  { "av_scanner",               opt_stringptr,   {&av_scanner} },
 #endif
-  { "bi_command",               opt_stringptr,   &bi_command },
+  { "bi_command",               opt_stringptr,   {&bi_command} },
 #ifdef EXPERIMENTAL_BRIGHTMAIL
-  { "bmi_config_file",          opt_stringptr,   &bmi_config_file },
+  { "bmi_config_file",          opt_stringptr,   {&bmi_config_file} },
 #endif
-  { "bounce_message_file",      opt_stringptr,   &bounce_message_file },
-  { "bounce_message_text",      opt_stringptr,   &bounce_message_text },
-  { "bounce_return_body",       opt_bool,        &bounce_return_body },
-  { "bounce_return_linesize_limit", opt_mkint,   &bounce_return_linesize_limit },
-  { "bounce_return_message",    opt_bool,        &bounce_return_message },
-  { "bounce_return_size_limit", opt_mkint,       &bounce_return_size_limit },
-  { "bounce_sender_authentication",opt_stringptr,&bounce_sender_authentication },
-  { "callout_domain_negative_expire", opt_time,  &callout_cache_domain_negative_expire },
-  { "callout_domain_positive_expire", opt_time,  &callout_cache_domain_positive_expire },
-  { "callout_negative_expire",  opt_time,        &callout_cache_negative_expire },
-  { "callout_positive_expire",  opt_time,        &callout_cache_positive_expire },
-  { "callout_random_local_part",opt_stringptr,   &callout_random_local_part },
-  { "check_log_inodes",         opt_int,         &check_log_inodes },
-  { "check_log_space",          opt_Kint,        &check_log_space },
-  { "check_rfc2047_length",     opt_bool,        &check_rfc2047_length },
-  { "check_spool_inodes",       opt_int,         &check_spool_inodes },
-  { "check_spool_space",        opt_Kint,        &check_spool_space },
-  { "chunking_advertise_hosts", opt_stringptr,  &chunking_advertise_hosts },
-  { "commandline_checks_require_admin", opt_bool,&commandline_checks_require_admin },
-  { "daemon_smtp_port",         opt_stringptr|opt_hidden, &daemon_smtp_port },
-  { "daemon_smtp_ports",        opt_stringptr,   &daemon_smtp_port },
-  { "daemon_startup_retries",   opt_int,         &daemon_startup_retries },
-  { "daemon_startup_sleep",     opt_time,        &daemon_startup_sleep },
+  { "bounce_message_file",      opt_stringptr,   {&bounce_message_file} },
+  { "bounce_message_text",      opt_stringptr,   {&bounce_message_text} },
+  { "bounce_return_body",       opt_bool,        {&bounce_return_body} },
+  { "bounce_return_linesize_limit", opt_mkint,   {&bounce_return_linesize_limit} },
+  { "bounce_return_message",    opt_bool,        {&bounce_return_message} },
+  { "bounce_return_size_limit", opt_mkint,       {&bounce_return_size_limit} },
+  { "bounce_sender_authentication",opt_stringptr,{&bounce_sender_authentication} },
+  { "callout_domain_negative_expire", opt_time,  {&callout_cache_domain_negative_expire} },
+  { "callout_domain_positive_expire", opt_time,  {&callout_cache_domain_positive_expire} },
+  { "callout_negative_expire",  opt_time,        {&callout_cache_negative_expire} },
+  { "callout_positive_expire",  opt_time,        {&callout_cache_positive_expire} },
+  { "callout_random_local_part",opt_stringptr,   {&callout_random_local_part} },
+  { "check_log_inodes",         opt_int,         {&check_log_inodes} },
+  { "check_log_space",          opt_Kint,        {&check_log_space} },
+  { "check_rfc2047_length",     opt_bool,        {&check_rfc2047_length} },
+  { "check_spool_inodes",       opt_int,         {&check_spool_inodes} },
+  { "check_spool_space",        opt_Kint,        {&check_spool_space} },
+  { "chunking_advertise_hosts", opt_stringptr,  {&chunking_advertise_hosts} },
+  { "commandline_checks_require_admin", opt_bool,{&commandline_checks_require_admin} },
+  { "daemon_smtp_port",         opt_stringptr|opt_hidden, {&daemon_smtp_port} },
+  { "daemon_smtp_ports",        opt_stringptr,   {&daemon_smtp_port} },
+  { "daemon_startup_retries",   opt_int,         {&daemon_startup_retries} },
+  { "daemon_startup_sleep",     opt_time,        {&daemon_startup_sleep} },
 #ifdef EXPERIMENTAL_DCC
-  { "dcc_direct_add_header",    opt_bool,        &dcc_direct_add_header },
-  { "dccifd_address",           opt_stringptr,   &dccifd_address },
-  { "dccifd_options",           opt_stringptr,   &dccifd_options },
+  { "dcc_direct_add_header",    opt_bool,        {&dcc_direct_add_header} },
+  { "dccifd_address",           opt_stringptr,   {&dccifd_address} },
+  { "dccifd_options",           opt_stringptr,   {&dccifd_options} },
 #endif
-  { "debug_store",              opt_bool,        &debug_store },
-  { "delay_warning",            opt_timelist,    &delay_warning },
-  { "delay_warning_condition",  opt_stringptr,   &delay_warning_condition },
-  { "deliver_drop_privilege",   opt_bool,        &deliver_drop_privilege },
-  { "deliver_queue_load_max",   opt_fixed,       &deliver_queue_load_max },
-  { "delivery_date_remove",     opt_bool,        &delivery_date_remove },
+  { "debug_store",              opt_bool,        {&debug_store} },
+  { "delay_warning",            opt_timelist,    {&delay_warning} },
+  { "delay_warning_condition",  opt_stringptr,   {&delay_warning_condition} },
+  { "deliver_drop_privilege",   opt_bool,        {&deliver_drop_privilege} },
+  { "deliver_queue_load_max",   opt_fixed,       {&deliver_queue_load_max} },
+  { "delivery_date_remove",     opt_bool,        {&delivery_date_remove} },
 #ifdef ENABLE_DISABLE_FSYNC
-  { "disable_fsync",            opt_bool,        &disable_fsync },
+  { "disable_fsync",            opt_bool,        {&disable_fsync} },
 #endif
-  { "disable_ipv6",             opt_bool,        &disable_ipv6 },
+  { "disable_ipv6",             opt_bool,        {&disable_ipv6} },
 #ifndef DISABLE_DKIM
-  { "dkim_verify_signers",      opt_stringptr,   &dkim_verify_signers },
+  { "dkim_verify_hashes",       opt_stringptr,   {&dkim_verify_hashes} },
+  { "dkim_verify_keytypes",     opt_stringptr,   {&dkim_verify_keytypes} },
+  { "dkim_verify_min_keysizes", opt_stringptr,   {&dkim_verify_min_keysizes} },
+  { "dkim_verify_minimal",      opt_bool,        {&dkim_verify_minimal} },
+  { "dkim_verify_signers",      opt_stringptr,   {&dkim_verify_signers} },
 #endif
-#ifdef EXPERIMENTAL_DMARC
-  { "dmarc_forensic_sender",    opt_stringptr,   &dmarc_forensic_sender },
-  { "dmarc_history_file",       opt_stringptr,   &dmarc_history_file },
-  { "dmarc_tld_file",           opt_stringptr,   &dmarc_tld_file },
+#ifdef SUPPORT_DMARC
+  { "dmarc_forensic_sender",    opt_stringptr,   {&dmarc_forensic_sender} },
+  { "dmarc_history_file",       opt_stringptr,   {&dmarc_history_file} },
+  { "dmarc_tld_file",           opt_stringptr,   {&dmarc_tld_file} },
 #endif
-  { "dns_again_means_nonexist", opt_stringptr,   &dns_again_means_nonexist },
-  { "dns_check_names_pattern",  opt_stringptr,   &check_dns_names_pattern },
-  { "dns_csa_search_limit",     opt_int,         &dns_csa_search_limit },
-  { "dns_csa_use_reverse",      opt_bool,        &dns_csa_use_reverse },
-  { "dns_dnssec_ok",            opt_int,         &dns_dnssec_ok },
-  { "dns_ipv4_lookup",          opt_stringptr,   &dns_ipv4_lookup },
-  { "dns_retrans",              opt_time,        &dns_retrans },
-  { "dns_retry",                opt_int,         &dns_retry },
-  { "dns_trust_aa",             opt_stringptr,   &dns_trust_aa },
-  { "dns_use_edns0",            opt_int,         &dns_use_edns0 },
+  { "dns_again_means_nonexist", opt_stringptr,   {&dns_again_means_nonexist} },
+  { "dns_check_names_pattern",  opt_stringptr,   {&check_dns_names_pattern} },
+  { "dns_cname_loops",         opt_int,         {&dns_cname_loops} },
+  { "dns_csa_search_limit",     opt_int,         {&dns_csa_search_limit} },
+  { "dns_csa_use_reverse",      opt_bool,        {&dns_csa_use_reverse} },
+  { "dns_dnssec_ok",            opt_int,         {&dns_dnssec_ok} },
+  { "dns_ipv4_lookup",          opt_stringptr,   {&dns_ipv4_lookup} },
+  { "dns_retrans",              opt_time,        {&dns_retrans} },
+  { "dns_retry",                opt_int,         {&dns_retry} },
+  { "dns_trust_aa",             opt_stringptr,   {&dns_trust_aa} },
+  { "dns_use_edns0",            opt_int,         {&dns_use_edns0} },
  /* This option is now a no-op, retained for compatibility */
-  { "drop_cr",                  opt_bool,        &drop_cr },
+  { "drop_cr",                  opt_bool,        {&drop_cr} },
 /*********************************************************/
-  { "dsn_advertise_hosts",      opt_stringptr,   &dsn_advertise_hosts },
-  { "dsn_from",                 opt_stringptr,   &dsn_from },
-  { "envelope_to_remove",       opt_bool,        &envelope_to_remove },
-  { "errors_copy",              opt_stringptr,   &errors_copy },
-  { "errors_reply_to",          opt_stringptr,   &errors_reply_to },
+  { "dsn_advertise_hosts",      opt_stringptr,   {&dsn_advertise_hosts} },
+  { "dsn_from",                 opt_stringptr,   {&dsn_from} },
+  { "envelope_to_remove",       opt_bool,        {&envelope_to_remove} },
+  { "errors_copy",              opt_stringptr,   {&errors_copy} },
+  { "errors_reply_to",          opt_stringptr,   {&errors_reply_to} },
 #ifndef DISABLE_EVENT
-  { "event_action",             opt_stringptr,   &event_action },
+  { "event_action",             opt_stringptr,   {&event_action} },
 #endif
-  { "exim_group",               opt_gid,         &exim_gid },
-  { "exim_path",                opt_stringptr,   &exim_path },
-  { "exim_user",                opt_uid,         &exim_uid },
-  { "extra_local_interfaces",   opt_stringptr,   &extra_local_interfaces },
-  { "extract_addresses_remove_arguments", opt_bool, &extract_addresses_remove_arguments },
-  { "finduser_retries",         opt_int,         &finduser_retries },
-  { "freeze_tell",              opt_stringptr,   &freeze_tell },
-  { "gecos_name",               opt_stringptr,   &gecos_name },
-  { "gecos_pattern",            opt_stringptr,   &gecos_pattern },
-#ifdef SUPPORT_TLS
-  { "gnutls_allow_auto_pkcs11", opt_bool,        &gnutls_allow_auto_pkcs11 },
-  { "gnutls_compat_mode",       opt_bool,        &gnutls_compat_mode },
+  { "exim_group",               opt_gid,         {&exim_gid} },
+  { "exim_path",                opt_stringptr,   {&exim_path} },
+  { "exim_user",                opt_uid,         {&exim_uid} },
+  { "exim_version",             opt_stringptr,   {&version_string} },
+  { "extra_local_interfaces",   opt_stringptr,   {&extra_local_interfaces} },
+  { "extract_addresses_remove_arguments", opt_bool, {&extract_addresses_remove_arguments} },
+  { "finduser_retries",         opt_int,         {&finduser_retries} },
+  { "freeze_tell",              opt_stringptr,   {&freeze_tell} },
+  { "gecos_name",               opt_stringptr,   {&gecos_name} },
+  { "gecos_pattern",            opt_stringptr,   {&gecos_pattern} },
+#ifndef DISABLE_TLS
+  { "gnutls_allow_auto_pkcs11", opt_bool,        {&gnutls_allow_auto_pkcs11} },
+  { "gnutls_compat_mode",       opt_bool,        {&gnutls_compat_mode} },
 #endif
-  { "header_line_maxsize",      opt_int,         &header_line_maxsize },
-  { "header_maxsize",           opt_int,         &header_maxsize },
-  { "headers_charset",          opt_stringptr,   &headers_charset },
-  { "helo_accept_junk_hosts",   opt_stringptr,   &helo_accept_junk_hosts },
-  { "helo_allow_chars",         opt_stringptr,   &helo_allow_chars },
-  { "helo_lookup_domains",      opt_stringptr,   &helo_lookup_domains },
-  { "helo_try_verify_hosts",    opt_stringptr,   &helo_try_verify_hosts },
-  { "helo_verify_hosts",        opt_stringptr,   &helo_verify_hosts },
-  { "hold_domains",             opt_stringptr,   &hold_domains },
-  { "host_lookup",              opt_stringptr,   &host_lookup },
-  { "host_lookup_order",        opt_stringptr,   &host_lookup_order },
-  { "host_reject_connection",   opt_stringptr,   &host_reject_connection },
-  { "hosts_connection_nolog",   opt_stringptr,   &hosts_connection_nolog },
+  { "header_line_maxsize",      opt_int,         {&header_line_maxsize} },
+  { "header_maxsize",           opt_int,         {&header_maxsize} },
+  { "headers_charset",          opt_stringptr,   {&headers_charset} },
+  { "helo_accept_junk_hosts",   opt_stringptr,   {&helo_accept_junk_hosts} },
+  { "helo_allow_chars",         opt_stringptr,   {&helo_allow_chars} },
+  { "helo_lookup_domains",      opt_stringptr,   {&helo_lookup_domains} },
+  { "helo_try_verify_hosts",    opt_stringptr,   {&helo_try_verify_hosts} },
+  { "helo_verify_hosts",        opt_stringptr,   {&helo_verify_hosts} },
+  { "hold_domains",             opt_stringptr,   {&hold_domains} },
+  { "host_lookup",              opt_stringptr,   {&host_lookup} },
+  { "host_lookup_order",        opt_stringptr,   {&host_lookup_order} },
+  { "host_reject_connection",   opt_stringptr,   {&host_reject_connection} },
+  { "hosts_connection_nolog",   opt_stringptr,   {&hosts_connection_nolog} },
 #ifdef SUPPORT_PROXY
-  { "hosts_proxy",              opt_stringptr,   &hosts_proxy },
+  { "hosts_proxy",              opt_stringptr,   {&hosts_proxy} },
 #endif
-  { "hosts_treat_as_local",     opt_stringptr,   &hosts_treat_as_local },
+  { "hosts_treat_as_local",     opt_stringptr,   {&hosts_treat_as_local} },
 #ifdef LOOKUP_IBASE
-  { "ibase_servers",            opt_stringptr,   &ibase_servers },
+  { "ibase_servers",            opt_stringptr,   {&ibase_servers} },
 #endif
-  { "ignore_bounce_errors_after", opt_time,      &ignore_bounce_errors_after },
-  { "ignore_fromline_hosts",    opt_stringptr,   &ignore_fromline_hosts },
-  { "ignore_fromline_local",    opt_bool,        &ignore_fromline_local },
-  { "keep_environment",         opt_stringptr,   &keep_environment },
-  { "keep_malformed",           opt_time,        &keep_malformed },
+  { "ignore_bounce_errors_after", opt_time,      {&ignore_bounce_errors_after} },
+  { "ignore_fromline_hosts",    opt_stringptr,   {&ignore_fromline_hosts} },
+  { "ignore_fromline_local",    opt_bool,        {&ignore_fromline_local} },
+  { "keep_environment",         opt_stringptr,   {&keep_environment} },
+  { "keep_malformed",           opt_time,        {&keep_malformed} },
 #ifdef LOOKUP_LDAP
-  { "ldap_ca_cert_dir",         opt_stringptr,   &eldap_ca_cert_dir },
-  { "ldap_ca_cert_file",        opt_stringptr,   &eldap_ca_cert_file },
-  { "ldap_cert_file",           opt_stringptr,   &eldap_cert_file },
-  { "ldap_cert_key",            opt_stringptr,   &eldap_cert_key },
-  { "ldap_cipher_suite",        opt_stringptr,   &eldap_cipher_suite },
-  { "ldap_default_servers",     opt_stringptr,   &eldap_default_servers },
-  { "ldap_require_cert",        opt_stringptr,   &eldap_require_cert },
-  { "ldap_start_tls",           opt_bool,        &eldap_start_tls },
-  { "ldap_version",             opt_int,         &eldap_version },
+  { "ldap_ca_cert_dir",         opt_stringptr,   {&eldap_ca_cert_dir} },
+  { "ldap_ca_cert_file",        opt_stringptr,   {&eldap_ca_cert_file} },
+  { "ldap_cert_file",           opt_stringptr,   {&eldap_cert_file} },
+  { "ldap_cert_key",            opt_stringptr,   {&eldap_cert_key} },
+  { "ldap_cipher_suite",        opt_stringptr,   {&eldap_cipher_suite} },
+  { "ldap_default_servers",     opt_stringptr,   {&eldap_default_servers} },
+  { "ldap_require_cert",        opt_stringptr,   {&eldap_require_cert} },
+  { "ldap_start_tls",           opt_bool,        {&eldap_start_tls} },
+  { "ldap_version",             opt_int,         {&eldap_version} },
 #endif
-  { "local_from_check",         opt_bool,        &local_from_check },
-  { "local_from_prefix",        opt_stringptr,   &local_from_prefix },
-  { "local_from_suffix",        opt_stringptr,   &local_from_suffix },
-  { "local_interfaces",         opt_stringptr,   &local_interfaces },
-  { "local_scan_timeout",       opt_time,        &local_scan_timeout },
-  { "local_sender_retain",      opt_bool,        &local_sender_retain },
-  { "localhost_number",         opt_stringptr,   &host_number_string },
-  { "log_file_path",            opt_stringptr,   &log_file_path },
-  { "log_selector",             opt_stringptr,   &log_selector_string },
-  { "log_timezone",             opt_bool,        &log_timezone },
-  { "lookup_open_max",          opt_int,         &lookup_open_max },
-  { "max_username_length",      opt_int,         &max_username_length },
-  { "message_body_newlines",    opt_bool,        &message_body_newlines },
-  { "message_body_visible",     opt_mkint,       &message_body_visible },
-  { "message_id_header_domain", opt_stringptr,   &message_id_domain },
-  { "message_id_header_text",   opt_stringptr,   &message_id_text },
-  { "message_logs",             opt_bool,        &message_logs },
-  { "message_size_limit",       opt_stringptr,   &message_size_limit },
+  { "local_from_check",         opt_bool,        {&local_from_check} },
+  { "local_from_prefix",        opt_stringptr,   {&local_from_prefix} },
+  { "local_from_suffix",        opt_stringptr,   {&local_from_suffix} },
+  { "local_interfaces",         opt_stringptr,   {&local_interfaces} },
+#ifdef HAVE_LOCAL_SCAN
+  { "local_scan_timeout",       opt_time,        {&local_scan_timeout} },
+#endif
+  { "local_sender_retain",      opt_bool,        {&local_sender_retain} },
+  { "localhost_number",         opt_stringptr,   {&host_number_string} },
+  { "log_file_path",            opt_stringptr,   {&log_file_path} },
+  { "log_selector",             opt_stringptr,   {&log_selector_string} },
+  { "log_timezone",             opt_bool,        {&log_timezone} },
+  { "lookup_open_max",          opt_int,         {&lookup_open_max} },
+  { "max_username_length",      opt_int,         {&max_username_length} },
+  { "message_body_newlines",    opt_bool,        {&message_body_newlines} },
+  { "message_body_visible",     opt_mkint,       {&message_body_visible} },
+  { "message_id_header_domain", opt_stringptr,   {&message_id_domain} },
+  { "message_id_header_text",   opt_stringptr,   {&message_id_text} },
+  { "message_logs",             opt_bool,        {&message_logs} },
+  { "message_size_limit",       opt_stringptr,   {&message_size_limit} },
 #ifdef SUPPORT_MOVE_FROZEN_MESSAGES
-  { "move_frozen_messages",     opt_bool,        &move_frozen_messages },
+  { "move_frozen_messages",     opt_bool,        {&move_frozen_messages} },
 #endif
-  { "mua_wrapper",              opt_bool,        &mua_wrapper },
+  { "mua_wrapper",              opt_bool,        {&mua_wrapper} },
 #ifdef LOOKUP_MYSQL
-  { "mysql_servers",            opt_stringptr,   &mysql_servers },
+  { "mysql_servers",            opt_stringptr,   {&mysql_servers} },
 #endif
-  { "never_users",              opt_uidlist,     &never_users },
-#ifdef SUPPORT_TLS
-  { "openssl_options",          opt_stringptr,   &openssl_options },
+  { "never_users",              opt_uidlist,     {&never_users} },
+  { "notifier_socket",          opt_stringptr,   {&notifier_socket} },
+#ifndef DISABLE_TLS
+  { "openssl_options",          opt_stringptr,   {&openssl_options} },
 #endif
 #ifdef LOOKUP_ORACLE
-  { "oracle_servers",           opt_stringptr,   &oracle_servers },
+  { "oracle_servers",           opt_stringptr,   {&oracle_servers} },
 #endif
-  { "percent_hack_domains",     opt_stringptr,   &percent_hack_domains },
+  { "percent_hack_domains",     opt_stringptr,   {&percent_hack_domains} },
 #ifdef EXIM_PERL
-  { "perl_at_start",            opt_bool,        &opt_perl_at_start },
-  { "perl_startup",             opt_stringptr,   &opt_perl_startup },
-  { "perl_taintmode",           opt_bool,        &opt_perl_taintmode },
+  { "perl_at_start",            opt_bool,        {&opt_perl_at_start} },
+  { "perl_startup",             opt_stringptr,   {&opt_perl_startup} },
+  { "perl_taintmode",           opt_bool,        {&opt_perl_taintmode} },
 #endif
 #ifdef LOOKUP_PGSQL
-  { "pgsql_servers",            opt_stringptr,   &pgsql_servers },
+  { "pgsql_servers",            opt_stringptr,   {&pgsql_servers} },
+#endif
+  { "pid_file_path",            opt_stringptr,   {&pid_file_path} },
+  { "pipelining_advertise_hosts", opt_stringptr, {&pipelining_advertise_hosts} },
+#ifndef DISABLE_PIPE_CONNECT
+  { "pipelining_connect_advertise_hosts", opt_stringptr,
+                                                {&pipe_connect_advertise_hosts} },
 #endif
-  { "pid_file_path",            opt_stringptr,   &pid_file_path },
-  { "pipelining_advertise_hosts", opt_stringptr, &pipelining_advertise_hosts },
 #ifndef DISABLE_PRDR
-  { "prdr_enable",              opt_bool,        &prdr_enable },
+  { "prdr_enable",              opt_bool,        {&prdr_enable} },
+#endif
+  { "preserve_message_logs",    opt_bool,        {&preserve_message_logs} },
+  { "primary_hostname",         opt_stringptr,   {&primary_hostname} },
+  { "print_topbitchars",        opt_bool,        {&print_topbitchars} },
+  { "process_log_path",         opt_stringptr,   {&process_log_path} },
+  { "prod_requires_admin",      opt_bool,        {&prod_requires_admin} },
+  { "qualify_domain",           opt_stringptr,   {&qualify_domain_sender} },
+  { "qualify_recipient",        opt_stringptr,   {&qualify_domain_recipient} },
+  { "queue_domains",            opt_stringptr,   {&queue_domains} },
+#ifdef EXPERIMENTAL_QUEUE_RAMP
+  { "queue_fast_ramp",          opt_bool,        {&queue_fast_ramp} },
 #endif
-  { "preserve_message_logs",    opt_bool,        &preserve_message_logs },
-  { "primary_hostname",         opt_stringptr,   &primary_hostname },
-  { "print_topbitchars",        opt_bool,        &print_topbitchars },
-  { "process_log_path",         opt_stringptr,   &process_log_path },
-  { "prod_requires_admin",      opt_bool,        &prod_requires_admin },
-  { "qualify_domain",           opt_stringptr,   &qualify_domain_sender },
-  { "qualify_recipient",        opt_stringptr,   &qualify_domain_recipient },
-  { "queue_domains",            opt_stringptr,   &queue_domains },
-  { "queue_list_requires_admin",opt_bool,        &queue_list_requires_admin },
-  { "queue_only",               opt_bool,        &queue_only },
-  { "queue_only_file",          opt_stringptr,   &queue_only_file },
-  { "queue_only_load",          opt_fixed,       &queue_only_load },
-  { "queue_only_load_latch",    opt_bool,        &queue_only_load_latch },
-  { "queue_only_override",      opt_bool,        &queue_only_override },
-  { "queue_run_in_order",       opt_bool,        &queue_run_in_order },
-  { "queue_run_max",            opt_stringptr,   &queue_run_max },
-  { "queue_smtp_domains",       opt_stringptr,   &queue_smtp_domains },
-  { "receive_timeout",          opt_time,        &receive_timeout },
-  { "received_header_text",     opt_stringptr,   &received_header_text },
-  { "received_headers_max",     opt_int,         &received_headers_max },
-  { "recipient_unqualified_hosts", opt_stringptr, &recipient_unqualified_hosts },
-  { "recipients_max",           opt_int,         &recipients_max },
-  { "recipients_max_reject",    opt_bool,        &recipients_max_reject },
+  { "queue_list_requires_admin",opt_bool,        {&queue_list_requires_admin} },
+  { "queue_only",               opt_bool,        {&queue_only} },
+  { "queue_only_file",          opt_stringptr,   {&queue_only_file} },
+  { "queue_only_load",          opt_fixed,       {&queue_only_load} },
+  { "queue_only_load_latch",    opt_bool,        {&queue_only_load_latch} },
+  { "queue_only_override",      opt_bool,        {&queue_only_override} },
+  { "queue_run_in_order",       opt_bool,        {&queue_run_in_order} },
+  { "queue_run_max",            opt_stringptr,   {&queue_run_max} },
+  { "queue_smtp_domains",       opt_stringptr,   {&queue_smtp_domains} },
+  { "receive_timeout",          opt_time,        {&receive_timeout} },
+  { "received_header_text",     opt_stringptr,   {&received_header_text} },
+  { "received_headers_max",     opt_int,         {&received_headers_max} },
+  { "recipient_unqualified_hosts", opt_stringptr, {&recipient_unqualified_hosts} },
+  { "recipients_max",           opt_int,         {&recipients_max} },
+  { "recipients_max_reject",    opt_bool,        {&recipients_max_reject} },
 #ifdef LOOKUP_REDIS
-  { "redis_servers",            opt_stringptr,   &redis_servers },
+  { "redis_servers",            opt_stringptr,   {&redis_servers} },
 #endif
-  { "remote_max_parallel",      opt_int,         &remote_max_parallel },
-  { "remote_sort_domains",      opt_stringptr,   &remote_sort_domains },
-  { "retry_data_expire",        opt_time,        &retry_data_expire },
-  { "retry_interval_max",       opt_time,        &retry_interval_max },
-  { "return_path_remove",       opt_bool,        &return_path_remove },
-  { "return_size_limit",        opt_mkint|opt_hidden, &bounce_return_size_limit },
-  { "rfc1413_hosts",            opt_stringptr,   &rfc1413_hosts },
-  { "rfc1413_query_timeout",    opt_time,        &rfc1413_query_timeout },
-  { "sender_unqualified_hosts", opt_stringptr,   &sender_unqualified_hosts },
-  { "slow_lookup_log",          opt_int,         &slow_lookup_log },
-  { "smtp_accept_keepalive",    opt_bool,        &smtp_accept_keepalive },
-  { "smtp_accept_max",          opt_int,         &smtp_accept_max },
-  { "smtp_accept_max_nonmail",  opt_int,         &smtp_accept_max_nonmail },
-  { "smtp_accept_max_nonmail_hosts", opt_stringptr, &smtp_accept_max_nonmail_hosts },
-  { "smtp_accept_max_per_connection", opt_int,   &smtp_accept_max_per_connection },
-  { "smtp_accept_max_per_host", opt_stringptr,   &smtp_accept_max_per_host },
-  { "smtp_accept_queue",        opt_int,         &smtp_accept_queue },
-  { "smtp_accept_queue_per_connection", opt_int, &smtp_accept_queue_per_connection },
-  { "smtp_accept_reserve",      opt_int,         &smtp_accept_reserve },
-  { "smtp_active_hostname",     opt_stringptr,   &raw_active_hostname },
-  { "smtp_banner",              opt_stringptr,   &smtp_banner },
-  { "smtp_check_spool_space",   opt_bool,        &smtp_check_spool_space },
-  { "smtp_connect_backlog",     opt_int,         &smtp_connect_backlog },
-  { "smtp_enforce_sync",        opt_bool,        &smtp_enforce_sync },
-  { "smtp_etrn_command",        opt_stringptr,   &smtp_etrn_command },
-  { "smtp_etrn_serialize",      opt_bool,        &smtp_etrn_serialize },
-  { "smtp_load_reserve",        opt_fixed,       &smtp_load_reserve },
-  { "smtp_max_synprot_errors",  opt_int,         &smtp_max_synprot_errors },
-  { "smtp_max_unknown_commands",opt_int,         &smtp_max_unknown_commands },
-  { "smtp_ratelimit_hosts",     opt_stringptr,   &smtp_ratelimit_hosts },
-  { "smtp_ratelimit_mail",      opt_stringptr,   &smtp_ratelimit_mail },
-  { "smtp_ratelimit_rcpt",      opt_stringptr,   &smtp_ratelimit_rcpt },
-  { "smtp_receive_timeout",     opt_func,        &fn_smtp_receive_timeout },
-  { "smtp_reserve_hosts",       opt_stringptr,   &smtp_reserve_hosts },
-  { "smtp_return_error_details",opt_bool,        &smtp_return_error_details },
+  { "remote_max_parallel",      opt_int,         {&remote_max_parallel} },
+  { "remote_sort_domains",      opt_stringptr,   {&remote_sort_domains} },
+  { "retry_data_expire",        opt_time,        {&retry_data_expire} },
+  { "retry_interval_max",       opt_time,        {&retry_interval_max} },
+  { "return_path_remove",       opt_bool,        {&return_path_remove} },
+  { "return_size_limit",        opt_mkint|opt_hidden, {&bounce_return_size_limit} },
+  { "rfc1413_hosts",            opt_stringptr,   {&rfc1413_hosts} },
+  { "rfc1413_query_timeout",    opt_time,        {&rfc1413_query_timeout} },
+  { "sender_unqualified_hosts", opt_stringptr,   {&sender_unqualified_hosts} },
+  { "slow_lookup_log",          opt_int,         {&slow_lookup_log} },
+  { "smtp_accept_keepalive",    opt_bool,        {&smtp_accept_keepalive} },
+  { "smtp_accept_max",          opt_int,         {&smtp_accept_max} },
+  { "smtp_accept_max_nonmail",  opt_int,         {&smtp_accept_max_nonmail} },
+  { "smtp_accept_max_nonmail_hosts", opt_stringptr, {&smtp_accept_max_nonmail_hosts} },
+  { "smtp_accept_max_per_connection", opt_int,   {&smtp_accept_max_per_connection} },
+  { "smtp_accept_max_per_host", opt_stringptr,   {&smtp_accept_max_per_host} },
+  { "smtp_accept_queue",        opt_int,         {&smtp_accept_queue} },
+  { "smtp_accept_queue_per_connection", opt_int, {&smtp_accept_queue_per_connection} },
+  { "smtp_accept_reserve",      opt_int,         {&smtp_accept_reserve} },
+  { "smtp_active_hostname",     opt_stringptr,   {&raw_active_hostname} },
+  { "smtp_banner",              opt_stringptr,   {&smtp_banner} },
+  { "smtp_check_spool_space",   opt_bool,        {&smtp_check_spool_space} },
+  { "smtp_connect_backlog",     opt_int,         {&smtp_connect_backlog} },
+  { "smtp_enforce_sync",        opt_bool,        {&smtp_enforce_sync} },
+  { "smtp_etrn_command",        opt_stringptr,   {&smtp_etrn_command} },
+  { "smtp_etrn_serialize",      opt_bool,        {&smtp_etrn_serialize} },
+  { "smtp_load_reserve",        opt_fixed,       {&smtp_load_reserve} },
+  { "smtp_max_synprot_errors",  opt_int,         {&smtp_max_synprot_errors} },
+  { "smtp_max_unknown_commands",opt_int,         {&smtp_max_unknown_commands} },
+  { "smtp_ratelimit_hosts",     opt_stringptr,   {&smtp_ratelimit_hosts} },
+  { "smtp_ratelimit_mail",      opt_stringptr,   {&smtp_ratelimit_mail} },
+  { "smtp_ratelimit_rcpt",      opt_stringptr,   {&smtp_ratelimit_rcpt} },
+  { "smtp_receive_timeout",     opt_func,        {.fn = &fn_smtp_receive_timeout} },
+  { "smtp_reserve_hosts",       opt_stringptr,   {&smtp_reserve_hosts} },
+  { "smtp_return_error_details",opt_bool,        {&smtp_return_error_details} },
 #ifdef SUPPORT_I18N
-  { "smtputf8_advertise_hosts", opt_stringptr,   &smtputf8_advertise_hosts },
+  { "smtputf8_advertise_hosts", opt_stringptr,   {&smtputf8_advertise_hosts} },
 #endif
 #ifdef WITH_CONTENT_SCAN
-  { "spamd_address",            opt_stringptr,   &spamd_address },
+  { "spamd_address",            opt_stringptr,   {&spamd_address} },
 #endif
-#ifdef EXPERIMENTAL_SPF
-  { "spf_guess",                opt_stringptr,   &spf_guess },
+#ifdef SUPPORT_SPF
+  { "spf_guess",                opt_stringptr,   {&spf_guess} },
+  { "spf_smtp_comment_template",opt_stringptr,   {&spf_smtp_comment_template} },
 #endif
-  { "split_spool_directory",    opt_bool,        &split_spool_directory },
-  { "spool_directory",          opt_stringptr,   &spool_directory },
-  { "spool_wireformat",         opt_bool,        &spool_wireformat },
+  { "split_spool_directory",    opt_bool,        {&split_spool_directory} },
+  { "spool_directory",          opt_stringptr,   {&spool_directory} },
+  { "spool_wireformat",         opt_bool,        {&spool_wireformat} },
 #ifdef LOOKUP_SQLITE
-  { "sqlite_lock_timeout",      opt_int,         &sqlite_lock_timeout },
+  { "sqlite_dbfile",            opt_stringptr,   {&sqlite_dbfile} },
+  { "sqlite_lock_timeout",      opt_int,         {&sqlite_lock_timeout} },
 #endif
 #ifdef EXPERIMENTAL_SRS
-  { "srs_config",               opt_stringptr,   &srs_config },
-  { "srs_hashlength",           opt_int,         &srs_hashlength },
-  { "srs_hashmin",              opt_int,         &srs_hashmin },
-  { "srs_maxage",               opt_int,         &srs_maxage },
-  { "srs_secrets",              opt_stringptr,   &srs_secrets },
-  { "srs_usehash",              opt_bool,        &srs_usehash },
-  { "srs_usetimestamp",         opt_bool,        &srs_usetimestamp },
+  { "srs_config",               opt_stringptr,   {&srs_config} },
+  { "srs_hashlength",           opt_int,         {&srs_hashlength} },
+  { "srs_hashmin",              opt_int,         {&srs_hashmin} },
+  { "srs_maxage",               opt_int,         {&srs_maxage} },
+  { "srs_secrets",              opt_stringptr,   {&srs_secrets} },
+  { "srs_usehash",              opt_bool,        {&srs_usehash} },
+  { "srs_usetimestamp",         opt_bool,        {&srs_usetimestamp} },
 #endif
-  { "strict_acl_vars",          opt_bool,        &strict_acl_vars },
-  { "strip_excess_angle_brackets", opt_bool,     &strip_excess_angle_brackets },
-  { "strip_trailing_dot",       opt_bool,        &strip_trailing_dot },
-  { "syslog_duplication",       opt_bool,        &syslog_duplication },
-  { "syslog_facility",          opt_stringptr,   &syslog_facility_str },
-  { "syslog_pid",               opt_bool,        &syslog_pid },
-  { "syslog_processname",       opt_stringptr,   &syslog_processname },
-  { "syslog_timestamp",         opt_bool,        &syslog_timestamp },
-  { "system_filter",            opt_stringptr,   &system_filter },
-  { "system_filter_directory_transport", opt_stringptr,&system_filter_directory_transport },
-  { "system_filter_file_transport",opt_stringptr,&system_filter_file_transport },
-  { "system_filter_group",      opt_gid,         &system_filter_gid },
-  { "system_filter_pipe_transport",opt_stringptr,&system_filter_pipe_transport },
-  { "system_filter_reply_transport",opt_stringptr,&system_filter_reply_transport },
-  { "system_filter_user",       opt_uid,         &system_filter_uid },
-  { "tcp_nodelay",              opt_bool,        &tcp_nodelay },
+  { "strict_acl_vars",          opt_bool,        {&strict_acl_vars} },
+  { "strip_excess_angle_brackets", opt_bool,     {&strip_excess_angle_brackets} },
+  { "strip_trailing_dot",       opt_bool,        {&strip_trailing_dot} },
+  { "syslog_duplication",       opt_bool,        {&syslog_duplication} },
+  { "syslog_facility",          opt_stringptr,   {&syslog_facility_str} },
+  { "syslog_pid",               opt_bool,        {&syslog_pid} },
+  { "syslog_processname",       opt_stringptr,   {&syslog_processname} },
+  { "syslog_timestamp",         opt_bool,        {&syslog_timestamp} },
+  { "system_filter",            opt_stringptr,   {&system_filter} },
+  { "system_filter_directory_transport", opt_stringptr,{&system_filter_directory_transport} },
+  { "system_filter_file_transport",opt_stringptr,{&system_filter_file_transport} },
+  { "system_filter_group",      opt_gid,         {&system_filter_gid} },
+  { "system_filter_pipe_transport",opt_stringptr,{&system_filter_pipe_transport} },
+  { "system_filter_reply_transport",opt_stringptr,{&system_filter_reply_transport} },
+  { "system_filter_user",       opt_uid,         {&system_filter_uid} },
+  { "tcp_nodelay",              opt_bool,        {&tcp_nodelay} },
 #ifdef USE_TCP_WRAPPERS
-  { "tcp_wrappers_daemon_name", opt_stringptr,   &tcp_wrappers_daemon_name },
+  { "tcp_wrappers_daemon_name", opt_stringptr,   {&tcp_wrappers_daemon_name} },
 #endif
-  { "timeout_frozen_after",     opt_time,        &timeout_frozen_after },
-  { "timezone",                 opt_stringptr,   &timezone_string },
-  { "tls_advertise_hosts",      opt_stringptr,   &tls_advertise_hosts },
-#ifdef SUPPORT_TLS
-  { "tls_certificate",          opt_stringptr,   &tls_certificate },
-  { "tls_crl",                  opt_stringptr,   &tls_crl },
-  { "tls_dh_max_bits",          opt_int,         &tls_dh_max_bits },
-  { "tls_dhparam",              opt_stringptr,   &tls_dhparam },
-  { "tls_eccurve",              opt_stringptr,   &tls_eccurve },
+  { "timeout_frozen_after",     opt_time,        {&timeout_frozen_after} },
+  { "timezone",                 opt_stringptr,   {&timezone_string} },
+  { "tls_advertise_hosts",      opt_stringptr,   {&tls_advertise_hosts} },
+#ifndef DISABLE_TLS
+  { "tls_certificate",          opt_stringptr,   {&tls_certificate} },
+  { "tls_crl",                  opt_stringptr,   {&tls_crl} },
+  { "tls_dh_max_bits",          opt_int,         {&tls_dh_max_bits} },
+  { "tls_dhparam",              opt_stringptr,   {&tls_dhparam} },
+  { "tls_eccurve",              opt_stringptr,   {&tls_eccurve} },
 # ifndef DISABLE_OCSP
-  { "tls_ocsp_file",            opt_stringptr,   &tls_ocsp_file },
+  { "tls_ocsp_file",            opt_stringptr,   {&tls_ocsp_file} },
 # endif
-  { "tls_on_connect_ports",     opt_stringptr,   &tls_in.on_connect_ports },
-  { "tls_privatekey",           opt_stringptr,   &tls_privatekey },
-  { "tls_remember_esmtp",       opt_bool,        &tls_remember_esmtp },
-  { "tls_require_ciphers",      opt_stringptr,   &tls_require_ciphers },
-  { "tls_try_verify_hosts",     opt_stringptr,   &tls_try_verify_hosts },
-  { "tls_verify_certificates",  opt_stringptr,   &tls_verify_certificates },
-  { "tls_verify_hosts",         opt_stringptr,   &tls_verify_hosts },
+  { "tls_on_connect_ports",     opt_stringptr,   {&tls_in.on_connect_ports} },
+  { "tls_privatekey",           opt_stringptr,   {&tls_privatekey} },
+  { "tls_remember_esmtp",       opt_bool,        {&tls_remember_esmtp} },
+  { "tls_require_ciphers",      opt_stringptr,   {&tls_require_ciphers} },
+# ifdef EXPERIMENTAL_TLS_RESUME
+  { "tls_resumption_hosts",     opt_stringptr,   {&tls_resumption_hosts} },
+# endif
+  { "tls_try_verify_hosts",     opt_stringptr,   {&tls_try_verify_hosts} },
+  { "tls_verify_certificates",  opt_stringptr,   {&tls_verify_certificates} },
+  { "tls_verify_hosts",         opt_stringptr,   {&tls_verify_hosts} },
 #endif
-  { "trusted_groups",           opt_gidlist,     &trusted_groups },
-  { "trusted_users",            opt_uidlist,     &trusted_users },
-  { "unknown_login",            opt_stringptr,   &unknown_login },
-  { "unknown_username",         opt_stringptr,   &unknown_username },
-  { "untrusted_set_sender",     opt_stringptr,   &untrusted_set_sender },
-  { "uucp_from_pattern",        opt_stringptr,   &uucp_from_pattern },
-  { "uucp_from_sender",         opt_stringptr,   &uucp_from_sender },
-  { "warn_message_file",        opt_stringptr,   &warn_message_file },
-  { "write_rejectlog",          opt_bool,        &write_rejectlog }
+  { "trusted_groups",           opt_gidlist,     {&trusted_groups} },
+  { "trusted_users",            opt_uidlist,     {&trusted_users} },
+  { "unknown_login",            opt_stringptr,   {&unknown_login} },
+  { "unknown_username",         opt_stringptr,   {&unknown_username} },
+  { "untrusted_set_sender",     opt_stringptr,   {&untrusted_set_sender} },
+  { "uucp_from_pattern",        opt_stringptr,   {&uucp_from_pattern} },
+  { "uucp_from_sender",         opt_stringptr,   {&uucp_from_sender} },
+  { "warn_message_file",        opt_stringptr,   {&warn_message_file} },
+  { "write_rejectlog",          opt_bool,        {&write_rejectlog} }
 };
 
 #ifndef MACRO_PREDEF
@@ -379,7 +407,8 @@ static int optionlist_config_size = nelem(optionlist_config);
 
 #ifdef MACRO_PREDEF
 
-static void fn_smtp_receive_timeout(const uschar * name, const uschar * str) {/*Dummy*/}
+static void
+fn_smtp_receive_timeout(const uschar * name, const uschar * str, unsigned flags) {/*Dummy*/}
 
 void
 options_main(void)
@@ -390,16 +419,29 @@ options_from_list(optionlist_config, nelem(optionlist_config), US"MAIN", NULL);
 void
 options_auths(void)
 {
-struct auth_info * ai;
 uschar buf[64];
 
 options_from_list(optionlist_auths, optionlist_auths_size, US"AUTHENTICATORS", NULL);
 
-for (ai = auths_available; ai->driver_name[0]; ai++)
+for (struct auth_info * ai = auths_available; ai->driver_name[0]; ai++)
   {
   spf(buf, sizeof(buf), US"_DRIVER_AUTHENTICATOR_%T", ai->driver_name);
   builtin_macro_create(buf);
   options_from_list(ai->options, (unsigned)*ai->options_count, US"AUTHENTICATOR", ai->driver_name);
+
+  if (ai->macros_create) (ai->macros_create)();
+  }
+}
+
+void
+options_logging(void)
+{
+uschar buf[64];
+
+for (bit_table * bp = log_options; bp < log_options + log_options_count; bp++)
+  {
+  spf(buf, sizeof(buf), US"_LOG_%T", bp->name);
+  builtin_macro_create(buf);
   }
 }
 
@@ -455,7 +497,7 @@ typedef struct syslog_fac_item {
 } syslog_fac_item;
 
 /* constants */
-static const char * const hidden = "<value not displayable>";
+static const uschar * const hidden = US"<value not displayable>";
 
 /* Static variables */
 
@@ -533,6 +575,8 @@ static syslog_fac_item syslog_list[] = {
 static int syslog_list_size = sizeof(syslog_list)/sizeof(syslog_fac_item);
 
 
+#define opt_fn_print           BIT(0)
+#define opt_fn_print_label     BIT(1)
 
 
 /*************************************************
@@ -552,28 +596,24 @@ Returns:     the option name, or an empty string
 uschar *
 readconf_find_option(void *p)
 {
-int i;
-router_instance *r;
-transport_instance *t;
-
-for (i = 0; i < nelem(optionlist_config); i++)
-  if (p == optionlist_config[i].value) return US optionlist_config[i].name;
+for (int i = 0; i < nelem(optionlist_config); i++)
+  if (p == optionlist_config[i].v.value) return US optionlist_config[i].name;
 
-for (r = routers; r; r = r->next)
+for (router_instance * r = routers; r; r = r->next)
   {
   router_info *ri = r->info;
-  for (i = 0; i < *ri->options_count; i++)
+  for (int i = 0; i < *ri->options_count; i++)
     {
     if ((ri->options[i].type & opt_mask) != opt_stringptr) continue;
-    if (p == CS (r->options_block) + (long int)(ri->options[i].value))
+    if (p == CS (r->options_block) + ri->options[i].v.offset)
       return US ri->options[i].name;
     }
   }
 
-for (t = transports; t; t = t->next)
+for (transport_instance * t = transports; t; t = t->next)
   {
   transport_info *ti = t->info;
-  for (i = 0; i < *ti->options_count; i++)
+  for (int i = 0; i < *ti->options_count; i++)
     {
     optionlist * op = &ti->options[i];
     if ((op->type & opt_mask) != opt_stringptr) continue;
@@ -581,7 +621,7 @@ for (t = transports; t; t = t->next)
             ? CS t
             : CS t->options_block
             )
-            + (long int)op->value)
+            + op->v.offset)
        return US op->name;
     }
   }
@@ -599,24 +639,29 @@ return US"";
 /* We have a new definition; append to the list.
 
 Args:
- name  Name of the macro.  Must be in storage persistent past the call
- val   Expansion result for the macro.  Ditto persistence.
+ name  Name of the macro; will be copied
+ val   Expansion result for the macro; will be copied
 */
 
 macro_item *
 macro_create(const uschar * name, const uschar * val, BOOL command_line)
 {
-macro_item * m = store_get(sizeof(macro_item));
+macro_item * m = store_get(sizeof(macro_item), FALSE);
 
-/* fprintf(stderr, "%s: '%s' '%s'\n", __FUNCTION__, name, val); */
+READCONF_DEBUG fprintf(stderr, "%s: '%s' '%s'\n", __FUNCTION__, name, val);
 m->next = NULL;
 m->command_line = command_line;
 m->namelen = Ustrlen(name);
 m->replen = Ustrlen(val);
-m->name = name;
-m->replacement = val;
-mlast->next = m;
+m->name = string_copy(name);
+m->replacement = string_copy(val);
+if (mlast)
+  mlast->next = m;
+else
+  macros = m;
 mlast = m;
+if (!macros_user)
+  macros_user = m;
 return m;
 }
 
@@ -630,11 +675,11 @@ non-command line, macros is permitted using '==' instead of '='.
 Arguments:
   s            points to the start of the logical line
 
-Returns:       nothing
+Returns:       FALSE iff fatal error
 */
 
-static void
-read_macro_assignment(uschar *s)
+BOOL
+macro_read_assignment(uschar *s)
 {
 uschar name[64];
 int namelen = 0;
@@ -644,22 +689,28 @@ macro_item *m;
 while (isalnum(*s) || *s == '_')
   {
   if (namelen >= sizeof(name) - 1)
-    log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
+    {
+    log_write(0, LOG_PANIC|LOG_CONFIG_IN,
       "macro name too long (maximum is " SIZE_T_FMT " characters)", sizeof(name) - 1);
+    return FALSE;
+    }
   name[namelen++] = *s++;
   }
 name[namelen] = 0;
 
-while (isspace(*s)) s++;
+Uskip_whitespace(&s);
 if (*s++ != '=')
-  log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "malformed macro definition");
+  {
+  log_write(0, LOG_PANIC|LOG_CONFIG_IN, "malformed macro definition");
+  return FALSE;
+  }
 
 if (*s == '=')
   {
   redef = TRUE;
   s++;
   }
-while (isspace(*s)) s++;
+Uskip_whitespace(&s);
 
 /* If an existing macro of the same name was defined on the command line, we
 just skip this definition. It's an error to attempt to redefine a macro without
@@ -675,15 +726,21 @@ for (m = macros; m; m = m->next)
   if (Ustrcmp(m->name, name) == 0)
     {
     if (!m->command_line && !redef)
-      log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "macro \"%s\" is already "
-       "defined (use \"==\" if you want to redefine it", name);
+      {
+      log_write(0, LOG_CONFIG|LOG_PANIC, "macro \"%s\" is already "
+       "defined (use \"==\" if you want to redefine it)", name);
+      return FALSE;
+      }
     break;
     }
 
   if (m->namelen < namelen && Ustrstr(name, m->name) != NULL)
-    log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "\"%s\" cannot be defined as "
+    {
+    log_write(0, LOG_CONFIG|LOG_PANIC, "\"%s\" cannot be defined as "
       "a macro because previously defined macro \"%s\" is a substring",
       name, m->name);
+    return FALSE;
+    }
 
   /* We cannot have this test, because it is documented that a substring
   macro is permitted (there is even an example).
@@ -697,7 +754,7 @@ for (m = macros; m; m = m->next)
 
 /* Check for an overriding command-line definition. */
 
-if (m && m->command_line) return;
+if (m && m->command_line) return TRUE;
 
 /* Redefinition must refer to an existing macro. */
 
@@ -708,18 +765,122 @@ if (redef)
     m->replacement = string_copy(s);
     }
   else
-    log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "can't redefine an undefined macro "
+    {
+    log_write(0, LOG_CONFIG|LOG_PANIC, "can't redefine an undefined macro "
       "\"%s\"", name);
+    return FALSE;
+    }
 
 /* We have a new definition. */
 else
-  (void) macro_create(string_copy(name), string_copy(s), FALSE);
+  (void) macro_create(name, s, FALSE);
+return TRUE;
 }
 
 
 
 
 
+/* Process line for macros. The line is in big_buffer starting at offset len.
+Expand big_buffer if needed.  Handle definitions of new macros, and
+macro expansions, rewriting the line in the buffer.
+
+Arguments:
+ len           Offset in buffer of start of line
+ newlen                Pointer to offset of end of line, updated on return
+ macro_found   Pointer to return that a macro was expanded
+
+Return: pointer to first nonblank char in line
+*/
+
+uschar *
+macros_expand(int len, int * newlen, BOOL * macro_found)
+{
+uschar * ss = big_buffer + len;
+uschar * s;
+
+/* Find the true start of the physical line - leading spaces are always
+ignored. */
+
+Uskip_whitespace(&ss);
+
+/* Process the physical line for macros. If this is the start of the logical
+line, skip over initial text at the start of the line if it starts with an
+upper case character followed by a sequence of name characters and an equals
+sign, because that is the definition of a new macro, and we don't do
+replacement therein. */
+
+s = ss;
+if (len == 0 && isupper(*s))
+  {
+  while (isalnum(*s) || *s == '_') s++;
+  if (Uskip_whitespace(&s) != '=') s = ss;          /* Not a macro definition */
+  }
+
+/* Skip leading chars which cannot start a macro name, to avoid multiple
+pointless rescans in Ustrstr calls. */
+
+while (*s && !isupper(*s) && !(*s == '_' && isupper(s[1]))) s++;
+
+/* For each defined macro, scan the line (from after XXX= if present),
+replacing all occurrences of the macro. */
+
+*macro_found = FALSE;
+if (*s) for (macro_item * m = *s == '_' ? macros : macros_user; m; m = m->next)
+  {
+  uschar * p, *pp;
+  uschar * t;
+
+  while (*s && !isupper(*s) && !(*s == '_' && isupper(s[1]))) s++;
+  if (!*s) break;
+
+  t = s;
+  while ((p = Ustrstr(t, m->name)) != NULL)
+    {
+    int moveby;
+
+    READCONF_DEBUG fprintf(stderr, "%s: matched '%s' in '%.*s'\n", __FUNCTION__,
+      m->name, (int) Ustrlen(ss)-1, ss);
+    /* Expand the buffer if necessary */
+
+    while (*newlen - m->namelen + m->replen + 1 > big_buffer_size)
+      {
+      int newsize = big_buffer_size + BIG_BUFFER_SIZE;
+      uschar *newbuffer = store_malloc(newsize);
+      memcpy(newbuffer, big_buffer, *newlen + 1);
+      p = newbuffer  + (p - big_buffer);
+      s = newbuffer  + (s - big_buffer);
+      ss = newbuffer + (ss - big_buffer);
+      t = newbuffer  + (t - big_buffer);
+      big_buffer_size = newsize;
+      store_free(big_buffer);
+      big_buffer = newbuffer;
+      }
+
+    /* Shuffle the remaining characters up or down in the buffer before
+    copying in the replacement text. Don't rescan the replacement for this
+    same macro. */
+
+    pp = p + m->namelen;
+    if ((moveby = m->replen - m->namelen) != 0)
+      {
+      memmove(p + m->replen, pp, (big_buffer + *newlen) - pp + 1);
+      *newlen += moveby;
+      }
+    Ustrncpy(p, m->replacement, m->replen);
+    t = p + m->replen;
+    while (*t && !isupper(*t) && !(*t == '_' && isupper(t[1]))) t++;
+    *macro_found = TRUE;
+    }
+  }
+
+/* An empty macro replacement at the start of a line could mean that ss no
+longer points to the first non-blank character. */
+
+Uskip_whitespace(&ss);
+return ss;
+}
+
 /*************************************************
 *            Read configuration line             *
 *************************************************/
@@ -749,7 +910,6 @@ int startoffset = 0;         /* To first non-blank char in logical line */
 int len = 0;                 /* Of logical line so far */
 int newlen;
 uschar *s, *ss;
-macro_item *m;
 BOOL macro_found;
 
 /* Loop for handling continuation lines, skipping comments, and dealing with
@@ -810,82 +970,7 @@ for (;;)
     newlen += Ustrlen(big_buffer + newlen);
     }
 
-  /* Find the true start of the physical line - leading spaces are always
-  ignored. */
-
-  ss = big_buffer + len;
-  while (isspace(*ss)) ss++;
-
-  /* Process the physical line for macros. If this is the start of the logical
-  line, skip over initial text at the start of the line if it starts with an
-  upper case character followed by a sequence of name characters and an equals
-  sign, because that is the definition of a new macro, and we don't do
-  replacement therein. */
-
-  s = ss;
-  if (len == 0 && isupper(*s))
-    {
-    while (isalnum(*s) || *s == '_') s++;
-    while (isspace(*s)) s++;
-    if (*s != '=') s = ss;          /* Not a macro definition */
-    }
-
-  /* Skip leading chars which cannot start a macro name, to avoid multiple
-  pointless rescans in Ustrstr calls. */
-
-  while (*s && !isupper(*s) && *s != '_') s++;
-
-  /* For each defined macro, scan the line (from after XXX= if present),
-  replacing all occurrences of the macro. */
-
-  macro_found = FALSE;
-  for (m = macros; m; m = m->next)
-    {
-    uschar * p, *pp;
-    uschar * t = s;
-
-    while ((p = Ustrstr(t, m->name)) != NULL)
-      {
-      int moveby;
-
-/* fprintf(stderr, "%s: matched '%s' in '%s'\n", __FUNCTION__, m->name, ss); */
-      /* Expand the buffer if necessary */
-
-      while (newlen - m->namelen + m->replen + 1 > big_buffer_size)
-        {
-        int newsize = big_buffer_size + BIG_BUFFER_SIZE;
-        uschar *newbuffer = store_malloc(newsize);
-        memcpy(newbuffer, big_buffer, newlen + 1);
-        p = newbuffer  + (p - big_buffer);
-        s = newbuffer  + (s - big_buffer);
-        ss = newbuffer + (ss - big_buffer);
-        t = newbuffer  + (t - big_buffer);
-        big_buffer_size = newsize;
-        store_free(big_buffer);
-        big_buffer = newbuffer;
-        }
-
-      /* Shuffle the remaining characters up or down in the buffer before
-      copying in the replacement text. Don't rescan the replacement for this
-      same macro. */
-
-      pp = p + m->namelen;
-      if ((moveby = m->replen - m->namelen) != 0)
-        {
-        memmove(p + m->replen, pp, (big_buffer + newlen) - pp + 1);
-        newlen += moveby;
-        }
-      Ustrncpy(p, m->replacement, m->replen);
-      t = p + m->replen;
-      while (*t && !isupper(*t) && *t != '_') t++;
-      macro_found = TRUE;
-      }
-    }
-
-  /* An empty macro replacement at the start of a line could mean that ss no
-  longer points to the first non-blank character. */
-
-  while (isspace(*ss)) ss++;
+  ss = macros_expand(len, &newlen, &macro_found);
 
   /* Check for comment lines - these are physical lines. */
 
@@ -893,7 +978,7 @@ for (;;)
 
   /* Handle conditionals, which are also applied to physical lines. Conditions
   are of the form ".ifdef ANYTEXT" and are treated as true if any macro
-  expansion occured on the rest of the line. A preliminary test for the leading
+  expansion occurred on the rest of the line. A preliminary test for the leading
   '.' saves effort on most lines. */
 
   if (*ss == '.')
@@ -965,7 +1050,7 @@ for (;;)
     struct stat statbuf;
 
     ss += 9 + include_if_exists;
-    while (isspace(*ss)) ss++;
+    Uskip_whitespace(&ss);
     t = ss + Ustrlen(ss);
     while (t > ss && isspace(t[-1])) t--;
     if (*ss == '\"' && t[-1] == '\"')
@@ -991,7 +1076,7 @@ for (;;)
 
     if (config_lines)
       save_config_position(config_filename, config_lineno);
-    save = store_get(sizeof(config_file_item));
+    save = store_get(sizeof(config_file_item), FALSE);
     save->next = config_file_stack;
     config_file_stack = save;
     save->file = config_file;
@@ -1056,7 +1141,7 @@ if (config_lines)
 if (strncmpic(s, US"begin ", 6) == 0)
   {
   s += 6;
-  while (isspace(*s)) s++;
+  Uskip_whitespace(&s);
   if (big_buffer + len - s > sizeof(next_section) - 2)
     s[sizeof(next_section) - 2] = 0;
   Ustrcpy(next_section, s);
@@ -1090,17 +1175,16 @@ uschar *
 readconf_readname(uschar *name, int len, uschar *s)
 {
 int p = 0;
-while (isspace(*s)) s++;
-if (isalpha(*s))
-  {
+
+if (isalpha(Uskip_whitespace(&s)))
   while (isalnum(*s) || *s == '_')
     {
     if (p < len-1) name[p++] = *s;
     s++;
     }
-  }
+
 name[p] = 0;
-while (isspace(*s)) s++;
+Uskip_whitespace(&s);
 return s;
 }
 
@@ -1268,11 +1352,11 @@ get_set_flag(uschar *name, optionlist *oltop, int last, void *data_block)
 optionlist *ol;
 uschar name2[64];
 sprintf(CS name2, "*set_%.50s", name);
-ol = find_option(name2, oltop, last);
-if (ol == NULL) log_write(0, LOG_MAIN|LOG_PANIC_DIE,
-  "Exim internal error: missing set flag for %s", name);
-return (data_block == NULL)? (BOOL *)(ol->value) :
-  (BOOL *)(US data_block + (long int)(ol->value));
+if (!(ol = find_option(name2, oltop, last)))
+  log_write(0, LOG_MAIN|LOG_PANIC_DIE,
+    "Exim internal error: missing set flag for %s", name);
+return data_block
+  ? (BOOL *)(US data_block + ol->v.offset) : (BOOL *)ol->v.value;
 }
 
 
@@ -1331,20 +1415,20 @@ Returns:      the control block for the parsed rule.
 static rewrite_rule *
 readconf_one_rewrite(const uschar *p, int *existflags, BOOL isglobal)
 {
-rewrite_rule *next = store_get(sizeof(rewrite_rule));
+rewrite_rule *next = store_get(sizeof(rewrite_rule), FALSE);
 
 next->next = NULL;
 next->key = string_dequote(&p);
 
-while (isspace(*p)) p++;
-if (*p == 0)
+Uskip_whitespace(&p);
+if (!*p)
   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
     "missing rewrite replacement string");
 
 next->flags = 0;
 next->replacement = string_dequote(&p);
 
-while (*p != 0) switch (*p++)
+while (*p) switch (*p++)
   {
   case ' ': case '\t': break;
 
@@ -1459,9 +1543,16 @@ return yield;
 *            Custom-handler options              *
 *************************************************/
 static void
-fn_smtp_receive_timeout(const uschar * name, const uschar * str)
+fn_smtp_receive_timeout(const uschar * name, const uschar * str, unsigned flags)
 {
-if (*str == '$')
+if (flags & opt_fn_print)
+  {
+  if (flags & opt_fn_print_label) printf("%s = ", name);
+  printf("%s\n", smtp_receive_timeout_s
+    ? string_printing2(smtp_receive_timeout_s, SP_TAB)
+    : readconf_printtime(smtp_receive_timeout));
+  }
+else if (*str == '$')
   smtp_receive_timeout_s = string_copy(str);
 else
   {
@@ -1518,7 +1609,7 @@ readconf_handle_option(uschar *buffer, optionlist *oltop, int last,
 {
 int ptr = 0;
 int offset = 0;
-int n, count, type, value;
+int count, type, value;
 int issecure = 0;
 uid_t uid;
 gid_t gid;
@@ -1526,7 +1617,7 @@ BOOL boolvalue = TRUE;
 BOOL freesptr = TRUE;
 optionlist *ol, *ol2;
 struct passwd *pw;
-void *reset_point;
+rmark reset_point;
 int intbase = 0;
 uschar *inttype = US"";
 uschar *sptr;
@@ -1546,7 +1637,7 @@ if (!isalpha(*s))
 it turns out that what we read was "hide", set the flag indicating that
 this is a secure option, and loop to read the next word. */
 
-for (n = 0; n < 2; n++)
+for (int n = 0; n < 2; n++)
   {
   while (isalnum(*s) || *s == '_')
     {
@@ -1579,7 +1670,7 @@ is set twice, is a disaster. */
 
 if (!(ol = find_option(name + offset, oltop, last)))
   {
-  if (unknown_txt == NULL) return FALSE;
+  if (!unknown_txt) return FALSE;
   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, CS unknown_txt, name);
   }
 
@@ -1598,7 +1689,7 @@ if (type < opt_bool || type > opt_bool_last)
   if (offset != 0)
     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
       "negation prefix applied to a non-boolean option");
-  if (*s == 0)
+  if (!*s)
     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
       "unexpected end of line (data missing) after %s", name);
   if (*s != '=')
@@ -1609,7 +1700,7 @@ if (type < opt_bool || type > opt_bool_last)
 true/false/yes/no, or, in the case of opt_expand_bool, a general string that
 ultimately expands to one of those values. */
 
-else if (*s != 0 && (offset != 0 || *s != '='))
+else if (*s && (offset != 0 || *s != '='))
   extra_chars_error(s, US"boolean option ", name, US"");
 
 /* Skip white space after = */
@@ -1619,7 +1710,7 @@ if (*s == '=') while (isspace((*(++s))));
 /* If there is a data block and the opt_public flag is not set, change
 the data block pointer to the private options block. */
 
-if (data_block != NULL && (ol->type & opt_public) == 0)
+if (data_block && !(ol->type & opt_public))
   data_block = (void *)(((driver_instance *)data_block)->options_block);
 
 /* Now get the data according to the type. */
@@ -1650,7 +1741,8 @@ switch (type)
   case opt_gidlist:
   case opt_rewrite:
 
-  reset_point = sptr = read_string(s, name);
+  reset_point = store_mark();
+  sptr = read_string(s, name);
 
   /* Having read a string, we now have several different ways of using it,
   depending on the data type, so do another switch. If keeping the actual
@@ -1665,18 +1757,19 @@ switch (type)
     control block and flags word. */
 
     case opt_stringptr:
-    str_target = data_block ? USS (US data_block + (long int)(ol->value))
-                           : USS (ol->value);
+    str_target = data_block ? USS (US data_block + ol->v.offset)
+                           : USS ol->v.value;
     if (ol->type & opt_rep_con)
       {
       uschar * saved_condition;
       /* We already have a condition, we're conducting a crude hack to let
       multiple condition rules be chained together, despite storing them in
       text form. */
-      *str_target = string_copy_malloc( (saved_condition = *str_target)
+      *str_target = string_copy_perm( (saved_condition = *str_target)
        ? string_sprintf("${if and{{bool_lax{%s}}{bool_lax{%s}}}}",
            saved_condition, sptr)
-       : sptr);
+       : sptr,
+       FALSE);
       /* TODO(pdp): there is a memory leak here and just below
       when we set 3 or more conditions; I still don't
       understand the store mechanism enough to know
@@ -1693,7 +1786,10 @@ switch (type)
       }
     else if (ol->type & opt_rep_str)
       {
-      uschar sep_o = Ustrncmp(name, "headers_add", 11)==0 ? '\n' : ':';
+      uschar sep_o =
+       Ustrncmp(name, "headers_add", 11) == 0  ? '\n'
+       : Ustrncmp(name, "set", 3) == 0         ? ';'
+       : ':';
       int    sep_i = -(int)sep_o;
       const uschar * list = sptr;
       uschar * s;
@@ -1709,7 +1805,7 @@ switch (type)
        list_o = string_append_listele(list_o, sep_o, s);
 
       if (list_o)
-       *str_target = string_copy_malloc(string_from_gstring(list_o));
+       *str_target = string_copy_perm(string_from_gstring(list_o), FALSE);
       }
     else
       {
@@ -1720,9 +1816,9 @@ switch (type)
 
     case opt_rewrite:
     if (data_block)
-      *USS (US data_block + (long int)(ol->value)) = sptr;
+      *USS (US data_block + ol->v.offset) = sptr;
     else
-      *USS (ol->value) = sptr;
+      *USS ol->v.value = sptr;
     freesptr = FALSE;
     if (type == opt_rewrite)
       {
@@ -1737,19 +1833,19 @@ switch (type)
       sprintf(CS name2, "*%.50s_flags", name);
       ol3 = find_option(name2, oltop, last);
 
-      if (ol2 == NULL || ol3 == NULL)
+      if (!ol2 || !ol3)
         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
           "rewrite rules not available for driver");
 
-      if (data_block == NULL)
+      if (data_block)
         {
-        chain = (rewrite_rule **)(ol2->value);
-        flagptr = (int *)(ol3->value);
+        chain = (rewrite_rule **)(US data_block + ol2->v.offset);
+        flagptr = (int *)(US data_block + ol3->v.offset);
         }
       else
         {
-        chain = (rewrite_rule **)(US data_block + (long int)(ol2->value));
-        flagptr = (int *)(US data_block + (long int)(ol3->value));
+        chain = (rewrite_rule **)ol2->v.value;
+        flagptr = (int *)ol3->v.value;
         }
 
       while ((p = string_nextinlist(CUSS &sptr, &sep, big_buffer, BIG_BUFFER_SIZE)))
@@ -1773,17 +1869,16 @@ switch (type)
 
     case opt_expand_uid:
     sprintf(CS name2, "*expand_%.50s", name);
-    ol2 = find_option(name2, oltop, last);
-    if (ol2 != NULL)
+    if ((ol2 = find_option(name2, oltop, last)))
       {
-      uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
+      uschar *ss = (Ustrchr(sptr, '$') != NULL) ? sptr : NULL;
 
-      if (data_block == NULL)
-        *((uschar **)(ol2->value)) = ss;
+      if (data_block)
+        *(USS(US data_block + ol2->v.offset)) = ss;
       else
-        *((uschar **)(US data_block + (long int)(ol2->value))) = ss;
+        *(USS ol2->v.value) = ss;
 
-      if (ss != NULL)
+      if (ss)
         {
         *(get_set_flag(name, oltop, last, data_block)) = FALSE;
         freesptr = FALSE;
@@ -1797,10 +1892,10 @@ switch (type)
     case opt_uid:
     if (!route_finduser(sptr, &pw, &uid))
       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found", sptr);
-    if (data_block == NULL)
-      *((uid_t *)(ol->value)) = uid;
+    if (data_block)
+      *(uid_t *)(US data_block + ol->v.offset) = uid;
     else
-      *((uid_t *)(US data_block + (long int)(ol->value))) = uid;
+      *(uid_t *)ol->v.value = uid;
 
     /* Set the flag indicating a fixed value is set */
 
@@ -1811,18 +1906,18 @@ switch (type)
     ignore. Also ignore if the value is already set. */
 
     if (pw == NULL) break;
-    Ustrcpy(name+Ustrlen(name)-4, "group");
+    Ustrcpy(name+Ustrlen(name)-4, US"group");
     ol2 = find_option(name, oltop, last);
-    if (ol2 != NULL && ((ol2->type & opt_mask) == opt_gid ||
+    if (ol2 && ((ol2->type & opt_mask) == opt_gid ||
         (ol2->type & opt_mask) == opt_expand_gid))
       {
       BOOL *set_flag = get_set_flag(name, oltop, last, data_block);
-      if (! *set_flag)
+      if (!*set_flag)
         {
-        if (data_block == NULL)
-          *((gid_t *)(ol2->value)) = pw->pw_gid;
+        if (data_block)
+          *((gid_t *)(US data_block + ol2->v.offset)) = pw->pw_gid;
         else
-          *((gid_t *)(US data_block + (long int)(ol2->value))) = pw->pw_gid;
+          *((gid_t *)ol2->v.value) = pw->pw_gid;
         *set_flag = TRUE;
         }
       }
@@ -1836,17 +1931,16 @@ switch (type)
 
     case opt_expand_gid:
     sprintf(CS name2, "*expand_%.50s", name);
-    ol2 = find_option(name2, oltop, last);
-    if (ol2 != NULL)
+    if ((ol2 = find_option(name2, oltop, last)))
       {
-      uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
+      uschar *ss = (Ustrchr(sptr, '$') != NULL) ? sptr : NULL;
 
-      if (data_block == NULL)
-        *((uschar **)(ol2->value)) = ss;
+      if (data_block)
+        *(USS(US data_block + ol2->v.offset)) = ss;
       else
-        *((uschar **)(US data_block + (long int)(ol2->value))) = ss;
+        *(USS ol2->v.value) = ss;
 
-      if (ss != NULL)
+      if (ss)
         {
         *(get_set_flag(name, oltop, last, data_block)) = FALSE;
         freesptr = FALSE;
@@ -1859,10 +1953,10 @@ switch (type)
     case opt_gid:
     if (!route_findgroup(sptr, &gid))
       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found", sptr);
-    if (data_block == NULL)
-      *((gid_t *)(ol->value)) = gid;
+    if (data_block)
+      *((gid_t *)(US data_block + ol->v.offset)) = gid;
     else
-      *((gid_t *)(US data_block + (long int)(ol->value))) = gid;
+      *((gid_t *)ol->v.value) = gid;
     *(get_set_flag(name, oltop, last, data_block)) = TRUE;
     break;
 
@@ -1889,10 +1983,10 @@ switch (type)
       list = store_malloc(count*sizeof(uid_t));
       list[ptr++] = (uid_t)(count - 1);
 
-      if (data_block == NULL)
-        *((uid_t **)(ol->value)) = list;
+      if (data_block)
+        *((uid_t **)(US data_block + ol->v.offset)) = list;
       else
-        *((uid_t **)(US data_block + (long int)(ol->value))) = list;
+        *((uid_t **)ol->v.value) = list;
 
       p = op;
       while (count-- > 1)
@@ -1920,7 +2014,7 @@ switch (type)
       const uschar *p;
       const uschar *op = expand_string (sptr);
 
-      if (op == NULL)
+      if (!op)
         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
           name, expand_string_message);
 
@@ -1930,10 +2024,10 @@ switch (type)
       list = store_malloc(count*sizeof(gid_t));
       list[ptr++] = (gid_t)(count - 1);
 
-      if (data_block == NULL)
-        *((gid_t **)(ol->value)) = list;
+      if (data_block)
+        *((gid_t **)(US data_block + ol->v.offset)) = list;
       else
-        *((gid_t **)(US data_block + (long int)(ol->value))) = list;
+        *((gid_t **)ol->v.value) = list;
 
       p = op;
       while (count-- > 1)
@@ -1951,7 +2045,7 @@ switch (type)
 
   /* Release store if the value of the string doesn't need to be kept. */
 
-  if (freesptr) store_reset(reset_point);
+  if (freesptr) reset_point = store_reset(reset_point);
   break;
 
   /* Expanded boolean: if no characters follow, or if there are no dollar
@@ -1959,17 +2053,17 @@ switch (type)
   save the string for later expansion in the alternate place. */
 
   case opt_expand_bool:
-  if (*s != 0 && Ustrchr(s, '$') != 0)
+  if (*s && Ustrchr(s, '$') != 0)
     {
     sprintf(CS name2, "*expand_%.50s", name);
-    ol2 = find_option(name2, oltop, last);
-    if (ol2 != NULL)
+    if ((ol2 = find_option(name2, oltop, last)))
       {
-      reset_point = sptr = read_string(s, name);
-      if (data_block == NULL)
-        *((uschar **)(ol2->value)) = sptr;
+      reset_point = store_mark();
+      sptr = read_string(s, name);
+      if (data_block)
+        *(USS(US data_block + ol2->v.offset)) = sptr;
       else
-        *((uschar **)(US data_block + (long int)(ol2->value))) = sptr;
+        *(USS ol2->v.value) = sptr;
       freesptr = FALSE;
       break;
       }
@@ -2005,33 +2099,30 @@ switch (type)
   if (type == opt_bit)
     {
     int bit = 1 << ((ol->type >> 16) & 31);
-    int *ptr = (data_block == NULL)?
-      (int *)(ol->value) :
-      (int *)(US data_block + (long int)ol->value);
+    int * ptr = data_block
+      ? (int *)(US data_block + ol->v.offset)
+      : (int *)ol->v.value;
     if (boolvalue) *ptr |= bit; else *ptr &= ~bit;
     break;
     }
 
   /* Handle full BOOL types */
 
-  if (data_block == NULL)
-    *((BOOL *)(ol->value)) = boolvalue;
+  if (data_block)
+    *((BOOL *)(US data_block + ol->v.offset)) = boolvalue;
   else
-    *((BOOL *)(US data_block + (long int)(ol->value))) = boolvalue;
+    *((BOOL *)ol->v.value) = boolvalue;
 
   /* Verify fudge */
 
   if (type == opt_bool_verify)
     {
     sprintf(CS name2, "%.50s_recipient", name + offset);
-    ol2 = find_option(name2, oltop, last);
-    if (ol2 != NULL)
-      {
-      if (data_block == NULL)
-        *((BOOL *)(ol2->value)) = boolvalue;
+    if ((ol2 = find_option(name2, oltop, last)))
+      if (data_block)
+        *((BOOL *)(US data_block + ol2->v.offset)) = boolvalue;
       else
-        *((BOOL *)(US data_block + (long int)(ol2->value))) = boolvalue;
-      }
+        *((BOOL *)ol2->v.value) = boolvalue;
     }
 
   /* Note that opt_bool_set type is set, if there is somewhere to do so */
@@ -2039,14 +2130,11 @@ switch (type)
   else if (type == opt_bool_set)
     {
     sprintf(CS name2, "*set_%.50s", name + offset);
-    ol2 = find_option(name2, oltop, last);
-    if (ol2 != NULL)
-      {
-      if (data_block == NULL)
-        *((BOOL *)(ol2->value)) = TRUE;
+    if ((ol2 = find_option(name2, oltop, last)))
+      if (data_block)
+        *((BOOL *)(US data_block + ol2->v.offset)) = TRUE;
       else
-        *((BOOL *)(US data_block + (long int)(ol2->value))) = TRUE;
-      }
+        *((BOOL *)ol2->v.value) = TRUE;
     }
   break;
 
@@ -2057,7 +2145,7 @@ switch (type)
   inttype = US"octal ";
 
   /*  Integer: a simple(ish) case; allow octal and hex formats, and
-  suffixes K, M and G. The different types affect output, not input. */
+  suffixes K, M, G, and T.  The different types affect output, not input. */
 
   case opt_mkint:
   case opt_int:
@@ -2072,80 +2160,75 @@ switch (type)
       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
         inttype, name);
 
-    if (errno != ERANGE)
-      if (tolower(*endptr) == 'k')
-        {
-        if (lvalue > INT_MAX/1024 || lvalue < INT_MIN/1024) errno = ERANGE;
-          else lvalue *= 1024;
-        endptr++;
-        }
-      else if (tolower(*endptr) == 'm')
-        {
-        if (lvalue > INT_MAX/(1024*1024) || lvalue < INT_MIN/(1024*1024))
-          errno = ERANGE;
-        else lvalue *= 1024*1024;
-        endptr++;
-        }
-      else if (tolower(*endptr) == 'g')
-        {
-        if (lvalue > INT_MAX/(1024*1024*1024) || lvalue < INT_MIN/(1024*1024*1024))
-          errno = ERANGE;
-        else lvalue *= 1024*1024*1024;
-        endptr++;
-        }
+    if (errno != ERANGE && *endptr)
+      {
+      uschar * mp = US"TtGgMmKk\0";    /* YyZzEePpTtGgMmKk */
+
+      if ((mp = Ustrchr(mp, *endptr)))
+       {
+       endptr++;
+       do
+         {
+         if (lvalue > INT_MAX/1024 || lvalue < INT_MIN/1024)
+           {
+           errno = ERANGE;
+           break;
+           }
+         lvalue *= 1024;
+         }
+       while (*(mp += 2));
+       }
+      }
 
     if (errno == ERANGE || lvalue > INT_MAX || lvalue < INT_MIN)
       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
         "absolute value of integer \"%s\" is too large (overflow)", s);
 
     while (isspace(*endptr)) endptr++;
-    if (*endptr != 0)
+    if (*endptr)
       extra_chars_error(endptr, inttype, US"integer value for ", name);
 
     value = (int)lvalue;
     }
 
-  if (data_block == NULL)
-    *((int *)(ol->value)) = value;
+  if (data_block)
+    *(int *)(US data_block + ol->v.offset) = value;
   else
-    *((int *)(US data_block + (long int)(ol->value))) = value;
+    *(int *)ol->v.value = value;
   break;
 
-  /*  Integer held in K: again, allow octal and hex formats, and suffixes K, M
-  and G. */
-  /*XXX consider moving to int_eximarith_t (but mind the overflow test 0415) */
+  /*  Integer held in K: again, allow formats and suffixes as above. */
 
   case opt_Kint:
     {
     uschar *endptr;
     errno = 0;
-    value = strtol(CS s, CSS &endptr, intbase);
+    int_eximarith_t lvalue = strtol(CS s, CSS &endptr, intbase);
 
     if (endptr == s)
       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
         inttype, name);
 
-    if (errno != ERANGE)
-      if (tolower(*endptr) == 'g')
-        {
-        if (value > INT_MAX/(1024*1024) || value < INT_MIN/(1024*1024))
-         errno = ERANGE;
-       else
-         value *= 1024*1024;
-        endptr++;
-        }
-      else if (tolower(*endptr) == 'm')
-        {
-        if (value > INT_MAX/1024 || value < INT_MIN/1024)
-         errno = ERANGE;
-       else
-         value *= 1024;
-        endptr++;
-        }
-      else if (tolower(*endptr) == 'k')
-        endptr++;
+    if (errno != ERANGE && *endptr)
+      {
+      uschar * mp = US"ZzEePpTtGgMmKk\0";      /* YyZzEePpTtGgMmKk */
+
+      if ((mp = Ustrchr(mp, *endptr)))
+       {
+       endptr++;
+       while (*(mp += 2))
+         {
+         if (lvalue > EXIM_ARITH_MAX/1024 || lvalue < EXIM_ARITH_MIN/1024)
+           {
+           errno = ERANGE;
+           break;
+           }
+         lvalue *= 1024;
+         }
+       }
       else
-        value = (value + 512)/1024;
+       lvalue = (lvalue + 512)/1024;
+      }
 
     if (errno == ERANGE) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
       "absolute value of integer \"%s\" is too large (overflow)", s);
@@ -2153,13 +2236,13 @@ switch (type)
     while (isspace(*endptr)) endptr++;
     if (*endptr != 0)
       extra_chars_error(endptr, inttype, US"integer value for ", name);
-    }
 
-  if (data_block == NULL)
-    *((int *)(ol->value)) = value;
-  else
-    *((int *)(US data_block + (long int)(ol->value))) = value;
-  break;
+    if (data_block)
+      *(int_eximarith_t *)(US data_block + ol->v.offset) = lvalue;
+    else
+      *(int_eximarith_t *)ol->v.value = lvalue;
+    break;
+    }
 
   /*  Fixed-point number: held to 3 decimal places. */
 
@@ -2196,10 +2279,10 @@ switch (type)
   if (s[count] != 0)
     extra_chars_error(s+count, US"fixed-point value for ", name, US"");
 
-  if (data_block == NULL)
-    *((int *)(ol->value)) = value;
+  if (data_block)
+    *((int *)(US data_block + ol->v.offset)) = value;
   else
-    *((int *)(US data_block + (long int)(ol->value))) = value;
+    *((int *)ol->v.value) = value;
   break;
 
   /* There's a special routine to read time values. */
@@ -2209,10 +2292,10 @@ switch (type)
   if (value < 0)
     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
       name);
-  if (data_block == NULL)
-    *((int *)(ol->value)) = value;
+  if (data_block)
+    *((int *)(US data_block + ol->v.offset)) = value;
   else
-    *((int *)(US data_block + (long int)(ol->value))) = value;
+    *((int *)ol->v.value) = value;
   break;
 
   /* A time list is a list of colon-separated times, with the first
@@ -2222,9 +2305,9 @@ switch (type)
   case opt_timelist:
     {
     int count = 0;
-    int *list = (data_block == NULL)?
-      (int *)(ol->value) :
-      (int *)(US data_block + (long int)(ol->value));
+    int * list = data_block
+      ? (int *)(US data_block + ol->v.offset)
+      : (int *)ol->v.value;
 
     if (*s != 0) for (count = 1; count <= list[0] - 2; count++)
       {
@@ -2259,8 +2342,8 @@ switch (type)
 
   case opt_func:
     {
-    void (*fn)() = ol->value;
-    fn(name, s);
+    void (*fn)() = ol->v.fn;
+    fn(name, s, 0);
     break;
     }
   }
@@ -2333,10 +2416,10 @@ Arguments:
   last           one more than the offset of the last entry in optop
   no_labels      do not show "foo = " at the start.
 
-Returns:         nothing
+Returns:         boolean success
 */
 
-static void
+static BOOL
 print_ol(optionlist *ol, uschar *name, void *options_block,
   optionlist *oltop, int last, BOOL no_labels)
 {
@@ -2349,30 +2432,30 @@ gid_t *gidlist;
 uschar *s;
 uschar name2[64];
 
-if (ol == NULL)
+if (!ol)
   {
   printf("%s is not a known option\n", name);
-  return;
+  return FALSE;
   }
 
 /* Non-admin callers cannot see options that have been flagged secure by the
 "hide" prefix. */
 
-if (!admin_user && (ol->type & opt_secure) != 0)
+if (!f.admin_user && ol->type & opt_secure)
   {
   if (no_labels)
-    printf("%s\n", hidden);
+    printf("%s\n", CCS hidden);
   else
-    printf("%s = %s\n", name, hidden);
-  return;
+    printf("%s = %s\n", name, CCS hidden);
+  return TRUE;
   }
 
 /* Else show the value of the option */
 
-value = ol->value;
-if (options_block != NULL)
+value = ol->v.value;
+if (options_block)
   {
-  if ((ol->type & opt_public) == 0)
+  if (!(ol->type & opt_public))
     options_block = (void *)(((driver_instance *)options_block)->options_block);
   value = (void *)(US options_block + (long int)value);
   }
@@ -2381,15 +2464,15 @@ switch(ol->type & opt_mask)
   {
   case opt_stringptr:
   case opt_rewrite:        /* Show the text value */
-  s = *((uschar **)value);
-  if (!no_labels) printf("%s = ", name);
-  printf("%s\n", (s == NULL)? US"" : string_printing2(s, FALSE));
-  break;
+    s = *(USS value);
+    if (!no_labels) printf("%s = ", name);
+    printf("%s\n", s ? string_printing2(s, SP_TAB) : US"");
+    break;
 
   case opt_int:
-  if (!no_labels) printf("%s = ", name);
-  printf("%d\n", *((int *)value));
-  break;
+    if (!no_labels) printf("%s = ", name);
+    printf("%d\n", *((int *)value));
+    break;
 
   case opt_mkint:
     {
@@ -2412,22 +2495,24 @@ switch(ol->type & opt_mask)
       printf("%d\n", x);
       }
     }
-  break;
+    break;
 
   case opt_Kint:
     {
-    int x = *((int *)value);
+    int_eximarith_t x = *((int_eximarith_t *)value);
     if (!no_labels) printf("%s = ", name);
     if (x == 0) printf("0\n");
-      else if ((x & 1023) == 0) printf("%dM\n", x >> 10);
-        else printf("%dK\n", x);
+    else if ((x & ((1<<30)-1)) == 0) printf(PR_EXIM_ARITH "T\n", x >> 30);
+    else if ((x & ((1<<20)-1)) == 0) printf(PR_EXIM_ARITH "G\n", x >> 20);
+    else if ((x & ((1<<10)-1)) == 0) printf(PR_EXIM_ARITH "M\n", x >> 10);
+    else printf(PR_EXIM_ARITH "K\n", x);
     }
-  break;
+    break;
 
   case opt_octint:
-  if (!no_labels) printf("%s = ", name);
-  printf("%#o\n", *((int *)value));
-  break;
+    if (!no_labels) printf("%s = ", name);
+    printf("%#o\n", *((int *)value));
+    break;
 
   /* Can be negative only when "unset", in which case integer */
 
@@ -2450,167 +2535,159 @@ switch(ol->type & opt_mask)
       printf("\n");
       }
     }
-  break;
+    break;
 
   /* If the numerical value is unset, try for the string value */
 
   case opt_expand_uid:
-  if (! *get_set_flag(name, oltop, last, options_block))
-    {
-    sprintf(CS name2, "*expand_%.50s", name);
-    ol2 = find_option(name2, oltop, last);
-    if (ol2 != NULL)
+    if (! *get_set_flag(name, oltop, last, options_block))
       {
-      void *value2 = ol2->value;
-      if (options_block != NULL)
-        value2 = (void *)(US options_block + (long int)value2);
-      s = *((uschar **)value2);
-      if (!no_labels) printf("%s = ", name);
-      printf("%s\n", (s == NULL)? US"" : string_printing(s));
-      break;
+      sprintf(CS name2, "*expand_%.50s", name);
+      if ((ol2 = find_option(name2, oltop, last)))
+       {
+       if (options_block)
+         s = *USS (US options_block + ol2->v.offset);
+       else
+         s = *USS ol2->v.value;
+       if (!no_labels) printf("%s = ", name);
+       printf("%s\n", s ? string_printing(s) : US"");
+       break;
+       }
       }
-    }
 
-  /* Else fall through */
+    /* Else fall through */
 
   case opt_uid:
-  if (!no_labels) printf("%s = ", name);
-  if (! *get_set_flag(name, oltop, last, options_block))
-    printf("\n");
-  else
-    {
-    pw = getpwuid(*((uid_t *)value));
-    if (pw == NULL)
-      printf("%ld\n", (long int)(*((uid_t *)value)));
-    else printf("%s\n", pw->pw_name);
-    }
-  break;
+    if (!no_labels) printf("%s = ", name);
+    if (! *get_set_flag(name, oltop, last, options_block))
+      printf("\n");
+    else
+      if ((pw = getpwuid(*((uid_t *)value))))
+       printf("%s\n", pw->pw_name);
+      else
+       printf("%ld\n", (long int)(*((uid_t *)value)));
+    break;
 
   /* If the numerical value is unset, try for the string value */
 
   case opt_expand_gid:
-  if (! *get_set_flag(name, oltop, last, options_block))
-    {
-    sprintf(CS name2, "*expand_%.50s", name);
-    ol2 = find_option(name2, oltop, last);
-    if (ol2 != NULL && (ol2->type & opt_mask) == opt_stringptr)
+    if (! *get_set_flag(name, oltop, last, options_block))
       {
-      void *value2 = ol2->value;
-      if (options_block != NULL)
-        value2 = (void *)(US options_block + (long int)value2);
-      s = *((uschar **)value2);
-      if (!no_labels) printf("%s = ", name);
-      printf("%s\n", (s == NULL)? US"" : string_printing(s));
-      break;
+      sprintf(CS name2, "*expand_%.50s", name);
+      if (  (ol2 = find_option(name2, oltop, last))
+        && (ol2->type & opt_mask) == opt_stringptr)
+       {
+       if (options_block)
+         s = *USS (US options_block + ol2->v.offset);
+       else
+         s = *USS ol2->v.value;
+       if (!no_labels) printf("%s = ", name);
+       printf("%s\n", s ? string_printing(s) : US"");
+       break;
+       }
       }
-    }
 
-  /* Else fall through */
+    /* Else fall through */
 
   case opt_gid:
-  if (!no_labels) printf("%s = ", name);
-  if (! *get_set_flag(name, oltop, last, options_block))
-    printf("\n");
-  else
-    {
-    gr = getgrgid(*((int *)value));
-    if (gr == NULL)
-       printf("%ld\n", (long int)(*((int *)value)));
-    else printf("%s\n", gr->gr_name);
-    }
-  break;
+    if (!no_labels) printf("%s = ", name);
+    if (! *get_set_flag(name, oltop, last, options_block))
+      printf("\n");
+    else
+      if ((gr = getgrgid(*((int *)value))))
+       printf("%s\n", gr->gr_name);
+      else
+        printf("%ld\n", (long int)(*((int *)value)));
+    break;
 
   case opt_uidlist:
-  uidlist = *((uid_t **)value);
-  if (!no_labels) printf("%s =", name);
-  if (uidlist != NULL)
-    {
-    int i;
-    uschar sep = ' ';
-    if (no_labels) sep = '\0';
-    for (i = 1; i <= (int)(uidlist[0]); i++)
+    uidlist = *((uid_t **)value);
+    if (!no_labels) printf("%s =", name);
+    if (uidlist)
       {
-      uschar *name = NULL;
-      pw = getpwuid(uidlist[i]);
-      if (pw != NULL) name = US pw->pw_name;
-      if (sep != '\0') printf("%c", sep);
-      if (name != NULL) printf("%s", name);
-        else printf("%ld", (long int)(uidlist[i]));
-      sep = ':';
+      uschar sep = no_labels ? '\0' : ' ';
+      for (int i = 1; i <= (int)(uidlist[0]); i++)
+       {
+       uschar *name = NULL;
+       if ((pw = getpwuid(uidlist[i]))) name = US pw->pw_name;
+       if (sep != '\0') printf("%c", sep);
+       if (name) printf("%s", name);
+       else printf("%ld", (long int)(uidlist[i]));
+       sep = ':';
+       }
       }
-    }
-  printf("\n");
-  break;
+    printf("\n");
+    break;
 
   case opt_gidlist:
-  gidlist = *((gid_t **)value);
-  if (!no_labels) printf("%s =", name);
-  if (gidlist != NULL)
-    {
-    int i;
-    uschar sep = ' ';
-    if (no_labels) sep = '\0';
-    for (i = 1; i <= (int)(gidlist[0]); i++)
+    gidlist = *((gid_t **)value);
+    if (!no_labels) printf("%s =", name);
+    if (gidlist)
       {
-      uschar *name = NULL;
-      gr = getgrgid(gidlist[i]);
-      if (gr != NULL) name = US gr->gr_name;
-      if (sep != '\0') printf("%c", sep);
-      if (name != NULL) printf("%s", name);
-        else printf("%ld", (long int)(gidlist[i]));
-      sep = ':';
+      uschar sep = no_labels ? '\0' : ' ';
+      for (int i = 1; i <= (int)(gidlist[0]); i++)
+       {
+       uschar *name = NULL;
+       if ((gr = getgrgid(gidlist[i]))) name = US gr->gr_name;
+       if (sep != '\0') printf("%c", sep);
+       if (name) printf("%s", name);
+       else printf("%ld", (long int)(gidlist[i]));
+       sep = ':';
+       }
       }
-    }
-  printf("\n");
-  break;
+    printf("\n");
+    break;
 
   case opt_time:
-  if (!no_labels) printf("%s = ", name);
-  printf("%s\n", readconf_printtime(*((int *)value)));
-  break;
+    if (!no_labels) printf("%s = ", name);
+    printf("%s\n", readconf_printtime(*((int *)value)));
+    break;
 
   case opt_timelist:
     {
-    int i;
     int *list = (int *)value;
     if (!no_labels) printf("%s = ", name);
-    for (i = 0; i < list[1]; i++)
-      printf("%s%s", (i == 0)? "" : ":", readconf_printtime(list[i+2]));
+    for (int i = 0; i < list[1]; i++)
+      printf("%s%s", i == 0 ? "" : ":", readconf_printtime(list[i+2]));
     printf("\n");
     }
-  break;
+    break;
 
   case opt_bit:
-  printf("%s%s\n", ((*((int *)value)) & (1 << ((ol->type >> 16) & 31)))?
-    "" : "no_", name);
-  break;
+    printf("%s%s\n", ((*((int *)value)) & (1 << ((ol->type >> 16) & 31)))?
+      "" : "no_", name);
+    break;
 
   case opt_expand_bool:
-  sprintf(CS name2, "*expand_%.50s", name);
-  ol2 = find_option(name2, oltop, last);
-  if (ol2 != NULL && ol2->value != NULL)
-    {
-    void *value2 = ol2->value;
-    if (options_block != NULL)
-      value2 = (void *)(US options_block + (long int)value2);
-    s = *((uschar **)value2);
-    if (s != NULL)
+    sprintf(CS name2, "*expand_%.50s", name);
+    if ((ol2 = find_option(name2, oltop, last)) && ol2->v.value)
       {
-      if (!no_labels) printf("%s = ", name);
-      printf("%s\n", string_printing(s));
-      break;
+      if (options_block)
+       s = *USS (US options_block + ol2->v.offset);
+      else
+       s = *USS ol2->v.value;
+      if (s)
+       {
+       if (!no_labels) printf("%s = ", name);
+       printf("%s\n", string_printing(s));
+       break;
+       }
+      /* s == NULL => string not set; fall through */
       }
-    /* s == NULL => string not set; fall through */
-    }
 
-  /* Fall through */
+    /* Fall through */
 
   case opt_bool:
   case opt_bool_verify:
   case opt_bool_set:
-  printf("%s%s\n", (*((BOOL *)value))? "" : "no_", name);
-  break;
+    printf("%s%s\n", (*((BOOL *)value))? "" : "no_", name);
+    break;
+
+  case opt_func:
+    ol->v.fn(name, NULL, no_labels ? opt_fn_print : opt_fn_print|opt_fn_print_label);
+    break;
   }
+return TRUE;
 }
 
 
@@ -2649,24 +2726,21 @@ Arguments:
   type        NULL or driver type name, as described above
   no_labels   avoid the "foo = " at the start of an item
 
-Returns:      nothing
+Returns:      Boolean success
 */
 
-void
+BOOL
 readconf_print(uschar *name, uschar *type, BOOL no_labels)
 {
 BOOL names_only = FALSE;
-optionlist *ol;
 optionlist *ol2 = NULL;
 driver_instance *d = NULL;
-macro_item *m;
 int size = 0;
 
-if (type == NULL)
+if (!type)
   {
   if (*name == '+')
     {
-    int i;
     tree_node *t;
     BOOL found = FALSE;
     static uschar *types[] = { US"address", US"domain", US"host",
@@ -2674,66 +2748,61 @@ if (type == NULL)
     static tree_node **anchors[] = { &addresslist_anchor, &domainlist_anchor,
       &hostlist_anchor, &localpartlist_anchor };
 
-    for (i = 0; i < 4; i++)
-      {
-      t = tree_search(*(anchors[i]), name+1);
-      if (t != NULL)
+    for (int i = 0; i < 4; i++)
+      if ((t = tree_search(*(anchors[i]), name+1)))
         {
+       namedlist_block * nb = t->data.ptr;
+       const uschar * s = nb->hide ? hidden : nb->string;
         found = TRUE;
         if (no_labels)
-          printf("%s\n", ((namedlist_block *)(t->data.ptr))->string);
+          printf("%s\n", CCS s);
         else
-          printf("%slist %s = %s\n", types[i], name+1,
-            ((namedlist_block *)(t->data.ptr))->string);
+          printf("%slist %s = %s\n", types[i], name+1, CCS s);
         }
-      }
 
     if (!found)
       printf("no address, domain, host, or local part list called \"%s\" "
         "exists\n", name+1);
 
-    return;
+    return found;
     }
 
   if (  Ustrcmp(name, "configure_file") == 0
      || Ustrcmp(name, "config_file") == 0)
     {
     printf("%s\n", CS config_main_filename);
-    return;
+    return TRUE;
     }
 
   if (Ustrcmp(name, "all") == 0)
     {
-    for (ol = optionlist_config;
+    for (optionlist * ol = optionlist_config;
          ol < optionlist_config + nelem(optionlist_config); ol++)
-      {
-      if ((ol->type & opt_hidden) == 0)
-        print_ol(ol, US ol->name, NULL,
-            optionlist_config, nelem(optionlist_config),
-            no_labels);
-      }
-    return;
+      if (!(ol->type & opt_hidden))
+        (void) print_ol(ol, US ol->name, NULL,
+                 optionlist_config, nelem(optionlist_config),
+                 no_labels);
+    return TRUE;
     }
 
   if (Ustrcmp(name, "local_scan") == 0)
     {
-    #ifndef LOCAL_SCAN_HAS_OPTIONS
+#ifndef LOCAL_SCAN_HAS_OPTIONS
     printf("local_scan() options are not supported\n");
-    #else
-    for (ol = local_scan_options;
+    return FALSE;
+#else
+    for (optionlist * ol = local_scan_options;
          ol < local_scan_options + local_scan_options_count; ol++)
-      {
-      print_ol(ol, US ol->name, NULL, local_scan_options,
-        local_scan_options_count, no_labels);
-      }
-    #endif
-    return;
+      (void) print_ol(ol, US ol->name, NULL, local_scan_options,
+                 local_scan_options_count, no_labels);
+    return TRUE;
+#endif
     }
 
   if (Ustrcmp(name, "config") == 0)
     {
-    print_config(admin_user, no_labels);
-    return;
+    print_config(f.admin_user, no_labels);
+    return TRUE;
     }
 
   if (Ustrcmp(name, "routers") == 0)
@@ -2746,47 +2815,40 @@ if (type == NULL)
     type = US"transport";
     name = NULL;
     }
-
   else if (Ustrcmp(name, "authenticators") == 0)
     {
     type = US"authenticator";
     name = NULL;
     }
-
   else if (Ustrcmp(name, "macros") == 0)
     {
     type = US"macro";
     name = NULL;
     }
-
   else if (Ustrcmp(name, "router_list") == 0)
     {
     type = US"router";
     name = NULL;
     names_only = TRUE;
     }
-
   else if (Ustrcmp(name, "transport_list") == 0)
     {
     type = US"transport";
     name = NULL;
     names_only = TRUE;
     }
-
   else if (Ustrcmp(name, "authenticator_list") == 0)
     {
     type = US"authenticator";
     name = NULL;
     names_only = TRUE;
     }
-
   else if (Ustrcmp(name, "macro_list") == 0)
     {
     type = US"macro";
     name = NULL;
     names_only = TRUE;
     }
-
   else if (Ustrcmp(name, "environment") == 0)
     {
     if (environ)
@@ -2802,15 +2864,13 @@ if (type == NULL)
         puts(CS *p);
         }
       }
-    return;
+    return TRUE;
     }
 
   else
-    {
-    print_ol(find_option(name, optionlist_config, nelem(optionlist_config)),
+    return print_ol(find_option(name,
+      optionlist_config, nelem(optionlist_config)),
       name, NULL, optionlist_config, nelem(optionlist_config), no_labels);
-    return;
-    }
   }
 
 /* Handle the options for a router or transport. Skip options that are flagged
@@ -2842,55 +2902,60 @@ else if (Ustrcmp(type, "macro") == 0)
   {
   /* People store passwords in macros and they were previously not available
   for printing.  So we have an admin_users restriction. */
-  if (!admin_user)
+  if (!f.admin_user)
     {
     fprintf(stderr, "exim: permission denied\n");
-    exit(EXIT_FAILURE);
+    return FALSE;
     }
-  for (m = macros; m; m = m->next)
+  for (macro_item * m = macros; m; m = m->next)
     if (!name || Ustrcmp(name, m->name) == 0)
       {
       if (names_only)
         printf("%s\n", CS m->name);
+      else if (no_labels)
+        printf("%s\n", CS m->replacement);
       else
         printf("%s=%s\n", CS m->name, CS m->replacement);
       if (name)
-        return;
+        return TRUE;
       }
-  if (name)
-    printf("%s %s not found\n", type, name);
-  return;
+  if (!name) return TRUE;
+
+  printf("%s %s not found\n", type, name);
+  return FALSE;
   }
 
 if (names_only)
   {
-  for (; d != NULL; d = d->next) printf("%s\n", CS d->name);
-  return;
+  for (; d; d = d->next) printf("%s\n", CS d->name);
+  return TRUE;
   }
 
 /* Either search for a given driver, or print all of them */
 
-for (; d != NULL; d = d->next)
+for (; d; d = d->next)
   {
-  if (name == NULL)
+  BOOL rc = FALSE;
+  if (!name)
     printf("\n%s %s:\n", d->name, type);
   else if (Ustrcmp(d->name, name) != 0) continue;
 
-  for (ol = ol2; ol < ol2 + size; ol++)
-    {
-    if ((ol->type & opt_hidden) == 0)
-      print_ol(ol, US ol->name, d, ol2, size, no_labels);
-    }
+  for (optionlist * ol = ol2; ol < ol2 + size; ol++)
+    if (!(ol->type & opt_hidden))
+      rc |= print_ol(ol, US ol->name, d, ol2, size, no_labels);
 
-  for (ol = d->info->options;
+  for (optionlist * ol = d->info->options;
        ol < d->info->options + *(d->info->options_count); ol++)
-    {
-    if ((ol->type & opt_hidden) == 0)
-      print_ol(ol, US ol->name, d, d->info->options, *(d->info->options_count), no_labels);
-    }
-  if (name != NULL) return;
+    if (!(ol->type & opt_hidden))
+      rc |= print_ol(ol, US ol->name, d, d->info->options,
+                   *d->info->options_count, no_labels);
+
+  if (name) return rc;
   }
-if (name != NULL) printf("%s %s not found\n", type, name);
+if (!name) return TRUE;
+
+printf("%s %s not found\n", type, name);
+return FALSE;
 }
 
 
@@ -2913,18 +2978,19 @@ Arguments:
   s           the text of the option line, starting immediately after the name
                 of the list type
   tname       the name of the list type, for messages
+  hide       do not output value on "-bP"
 
 Returns:      nothing
 */
 
 static void
 read_named_list(tree_node **anchorp, int *numberp, int max, uschar *s,
-  uschar *tname)
+  uschar *tname, BOOL hide)
 {
 BOOL forcecache = FALSE;
 uschar *ss;
 tree_node *t;
-namedlist_block *nb = store_get(sizeof(namedlist_block));
+namedlist_block * nb = store_get(sizeof(namedlist_block), FALSE);
 
 if (Ustrncmp(s, "_cache", 6) == 0)
   {
@@ -2939,13 +3005,13 @@ if (*numberp >= max)
  log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many named %ss (max is %d)\n",
    tname, max);
 
-while (isspace(*s)) s++;
+Uskip_whitespace(&s);
 ss = s;
 while (isalnum(*s) || *s == '_') s++;
-t = store_get(sizeof(tree_node) + s-ss);
+t = store_get(sizeof(tree_node) + s-ss, is_tainted(ss));
 Ustrncpy(t->name, ss, s-ss);
 t->name[s-ss] = 0;
-while (isspace(*s)) s++;
+Uskip_whitespace(&s);
 
 if (!tree_insertnode(anchorp, t))
   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
@@ -2954,10 +3020,11 @@ if (!tree_insertnode(anchorp, t))
 t->data.ptr = nb;
 nb->number = *numberp;
 *numberp += 1;
+nb->hide = hide;
 
 if (*s++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
   "missing '=' after \"%s\"", t->name);
-while (isspace(*s)) s++;
+Uskip_whitespace(&s);
 nb->string = read_string(s, t->name);
 nb->cache_data = NULL;
 
@@ -3010,80 +3077,6 @@ log_write(0, LOG_MAIN|LOG_PANIC_DIE, "malformed ratelimit data: %s", s);
 
 
 
-/*************************************************
-*       Drop privs for checking TLS config      *
-*************************************************/
-
-/* We want to validate TLS options during readconf, but do not want to be
-root when we call into the TLS library, in case of library linkage errors
-which cause segfaults; before this check, those were always done as the Exim
-runtime user and it makes sense to continue with that.
-
-Assumes:  tls_require_ciphers has been set, if it will be
-          exim_user has been set, if it will be
-          exim_group has been set, if it will be
-
-Returns:  bool for "okay"; false will cause caller to immediately exit.
-*/
-
-#ifdef SUPPORT_TLS
-static BOOL
-tls_dropprivs_validate_require_cipher(BOOL nowarn)
-{
-const uschar *errmsg;
-pid_t pid;
-int rc, status;
-void (*oldsignal)(int);
-
-/* If TLS will never be used, no point checking ciphers */
-
-if (  !tls_advertise_hosts
-   || !*tls_advertise_hosts
-   || Ustrcmp(tls_advertise_hosts, ":") == 0
-   )
-  return TRUE;
-else if (!nowarn && !tls_certificate)
-  log_write(0, LOG_MAIN,
-    "Warning: No server certificate defined; will use a selfsigned one.\n"
-    " Suggested action: either install a certificate or change tls_advertise_hosts option");
-
-oldsignal = signal(SIGCHLD, SIG_DFL);
-
-fflush(NULL);
-if ((pid = fork()) < 0)
-  log_write(0, LOG_MAIN|LOG_PANIC_DIE, "fork failed for TLS check");
-
-if (pid == 0)
-  {
-  /* in some modes, will have dropped privilege already */
-  if (!geteuid())
-    exim_setugid(exim_uid, exim_gid, FALSE,
-        US"calling tls_validate_require_cipher");
-
-  if ((errmsg = tls_validate_require_cipher()))
-    log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
-        "tls_require_ciphers invalid: %s", errmsg);
-  fflush(NULL);
-  _exit(0);
-  }
-
-do {
-  rc = waitpid(pid, &status, 0);
-} while (rc < 0 && errno == EINTR);
-
-DEBUG(D_tls)
-  debug_printf("tls_validate_require_cipher child %d ended: status=0x%x\n",
-      (int)pid, status);
-
-signal(SIGCHLD, oldsignal);
-
-return status == 0;
-}
-#endif /* SUPPORT_TLS */
-
-
-
-
 /*************************************************
 *         Read main configuration options        *
 *************************************************/
@@ -3244,7 +3237,7 @@ if (Uchdir("/") < 0)
 /* Check the status of the file we have opened, if we have retained root
 privileges and the file isn't /dev/null (which *should* be 0666). */
 
-if (trusted_config && Ustrcmp(filename, US"/dev/null"))
+if (f.trusted_config && Ustrcmp(filename, US"/dev/null"))
   {
   if (fstat(fileno(config_file), &statbuf) != 0)
     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to stat configuration file %s",
@@ -3265,36 +3258,57 @@ if (trusted_config && Ustrcmp(filename, US"/dev/null"))
 
     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Exim configuration file %s has the "
       "wrong owner, group, or mode", big_buffer);
+
+  /* Do a dummy store-allocation of a size related to the (toplevel) file size.
+  This assumes we will need this much storage to handle all the allocations
+  during startup; it won't help when .include is being used.  When it does, it
+  will cut down on the number of store blocks (and malloc calls, and sbrk
+  syscalls).  It also assume we're on the relevant pool. */
+
+  if (statbuf.st_size > 8192)
+    {
+    rmark r = store_mark();
+    void * dummy = store_get((int)statbuf.st_size, FALSE);
+    store_reset(r);
+    }
   }
 
 /* Process the main configuration settings. They all begin with a lower case
 letter. If we see something starting with an upper case letter, it is taken as
 a macro definition. */
 
-while ((s = get_config_line()) != NULL)
+while ((s = get_config_line()))
   {
+  BOOL hide;
+  uschar * t;
 
   if (config_lineno == 1 && Ustrstr(s, "\xef\xbb\xbf") == s)
     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
       "found unexpected BOM (Byte Order Mark)");
 
-  if (isupper(s[0])) read_macro_assignment(s);
+  if (isupper(*s))
+    {
+    if (!macro_read_assignment(s)) exim_exit(EXIT_FAILURE);
+    continue;
+    }
+
+  t = (hide = Ustrncmp(s, "hide", 4) == 0 && isspace(s[4])) ? s + 5 : s;
 
-  else if (Ustrncmp(s, "domainlist", 10) == 0)
+  if (Ustrncmp(t, "domainlist", 10) == 0)
     read_named_list(&domainlist_anchor, &domainlist_count,
-      MAX_NAMED_LIST, s+10, US"domain list");
+      MAX_NAMED_LIST, t+10, US"domain list", hide);
 
-  else if (Ustrncmp(s, "hostlist", 8) == 0)
+  else if (Ustrncmp(t, "hostlist", 8) == 0)
     read_named_list(&hostlist_anchor, &hostlist_count,
-      MAX_NAMED_LIST, s+8, US"host list");
+      MAX_NAMED_LIST, t+8, US"host list", hide);
 
-  else if (Ustrncmp(s, US"addresslist", 11) == 0)
+  else if (Ustrncmp(t, US"addresslist", 11) == 0)
     read_named_list(&addresslist_anchor, &addresslist_count,
-      MAX_NAMED_LIST, s+11, US"address list");
+      MAX_NAMED_LIST, t+11, US"address list", hide);
 
-  else if (Ustrncmp(s, US"localpartlist", 13) == 0)
+  else if (Ustrncmp(t, US"localpartlist", 13) == 0)
     read_named_list(&localpartlist_anchor, &localpartlist_count,
-      MAX_NAMED_LIST, s+13, US"local part list");
+      MAX_NAMED_LIST, t+13, US"local part list", hide);
 
   else
     (void) readconf_handle_option(s, optionlist_config, optionlist_config_size,
@@ -3389,15 +3403,14 @@ smtp_active_hostname = primary_hostname;
 got set above. Of course, writing to the log may not work if log_file_path is
 not set, but it will at least get to syslog or somewhere, with any luck. */
 
-if (*spool_directory == 0)
+if (!*spool_directory)
   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "spool_directory undefined: cannot "
     "proceed");
 
 /* Expand the spool directory name; it may, for example, contain the primary
 host name. Same comment about failure. */
 
-s = expand_string(spool_directory);
-if (s == NULL)
+if (!(s = expand_string(spool_directory)))
   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand spool_directory "
     "\"%s\": %s", spool_directory, expand_string_message);
 spool_directory = s;
@@ -3406,32 +3419,27 @@ spool_directory = s;
 the null string or "syslog". It is also allowed to contain one instance of %D
 or %M. However, it must NOT contain % followed by anything else. */
 
-if (*log_file_path != 0)
+if (*log_file_path)
   {
   const uschar *ss, *sss;
   int sep = ':';                       /* Fixed for log file path */
-  s = expand_string(log_file_path);
-  if (s == NULL)
+  if (!(s = expand_string(log_file_path)))
     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand log_file_path "
       "\"%s\": %s", log_file_path, expand_string_message);
 
   ss = s;
-  while ((sss = string_nextinlist(&ss,&sep,big_buffer,big_buffer_size)) != NULL)
+  while ((sss = string_nextinlist(&ss, &sep, big_buffer, big_buffer_size)))
     {
     uschar *t;
     if (sss[0] == 0 || Ustrcmp(sss, "syslog") == 0) continue;
-    t = Ustrstr(sss, "%s");
-    if (t == NULL)
+    if (!(t = Ustrstr(sss, "%s")))
       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" does not "
         "contain \"%%s\"", sss);
     *t = 'X';
-    t = Ustrchr(sss, '%');
-    if (t != NULL)
-      {
+    if ((t = Ustrchr(sss, '%')))
       if ((t[1] != 'D' && t[1] != 'M') || Ustrchr(t+2, '%') != NULL)
         log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" contains "
           "unexpected \"%%\" character", s);
-      }
     }
 
   log_file_path = s;
@@ -3441,7 +3449,7 @@ if (*log_file_path != 0)
 openlog(). Default is LOG_MAIL set in globals.c. Allow the user to omit the
 leading "log_". */
 
-if (syslog_facility_str != NULL)
+if (syslog_facility_str)
   {
   int i;
   uschar *s = syslog_facility_str;
@@ -3451,27 +3459,22 @@ if (syslog_facility_str != NULL)
     s += 4;
 
   for (i = 0; i < syslog_list_size; i++)
-    {
     if (strcmpic(s, syslog_list[i].name) == 0)
       {
       syslog_facility = syslog_list[i].value;
       break;
       }
-    }
 
   if (i >= syslog_list_size)
-    {
     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
       "failed to interpret syslog_facility \"%s\"", syslog_facility_str);
-    }
   }
 
 /* Expand pid_file_path */
 
 if (*pid_file_path != 0)
   {
-  s = expand_string(pid_file_path);
-  if (s == NULL)
+  if (!(s = expand_string(pid_file_path)))
     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand pid_file_path "
       "\"%s\": %s", pid_file_path, expand_string_message);
   pid_file_path = s;
@@ -3479,7 +3482,7 @@ if (*pid_file_path != 0)
 
 /* Set default value of process_log_path */
 
-if (process_log_path == NULL || *process_log_path =='\0')
+if (!process_log_path || *process_log_path =='\0')
   process_log_path = string_sprintf("%s/exim-process.info", spool_directory);
 
 /* Compile the regex for matching a UUCP-style "From_" line in an incoming
@@ -3489,23 +3492,19 @@ regex_From = regex_must_compile(uucp_from_pattern, FALSE, TRUE);
 
 /* Unpick the SMTP rate limiting options, if set */
 
-if (smtp_ratelimit_mail != NULL)
-  {
+if (smtp_ratelimit_mail)
   unpick_ratelimit(smtp_ratelimit_mail, &smtp_rlm_threshold,
     &smtp_rlm_base, &smtp_rlm_factor, &smtp_rlm_limit);
-  }
 
-if (smtp_ratelimit_rcpt != NULL)
-  {
+if (smtp_ratelimit_rcpt)
   unpick_ratelimit(smtp_ratelimit_rcpt, &smtp_rlr_threshold,
     &smtp_rlr_base, &smtp_rlr_factor, &smtp_rlr_limit);
-  }
 
 /* The qualify domains default to the primary host name */
 
-if (qualify_domain_sender == NULL)
+if (!qualify_domain_sender)
   qualify_domain_sender = primary_hostname;
-if (qualify_domain_recipient == NULL)
+if (!qualify_domain_recipient)
   qualify_domain_recipient = qualify_domain_sender;
 
 /* Setting system_filter_user in the configuration sets the gid as well if a
@@ -3514,7 +3513,7 @@ name is given, but a numerical value does not. */
 if (system_filter_uid_set && !system_filter_gid_set)
   {
   struct passwd *pw = getpwuid(system_filter_uid);
-  if (pw == NULL)
+  if (!pw)
     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to look up uid %ld",
       (long int)system_filter_uid);
   system_filter_gid = pw->pw_gid;
@@ -3524,14 +3523,14 @@ if (system_filter_uid_set && !system_filter_gid_set)
 /* If the errors_reply_to field is set, check that it is syntactically valid
 and ensure it contains a domain. */
 
-if (errors_reply_to != NULL)
+if (errors_reply_to)
   {
   uschar *errmess;
   int start, end, domain;
   uschar *recipient = parse_extract_address(errors_reply_to, &errmess,
     &start, &end, &domain, FALSE);
 
-  if (recipient == NULL)
+  if (!recipient)
     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
       "error in errors_reply_to (%s): %s", errors_reply_to, errmess);
 
@@ -3553,12 +3552,13 @@ if (smtp_accept_max == 0 &&
 so that it can be computed from the host name, for example. We do this last
 so as to ensure that everything else is set up before the expansion. */
 
-if (host_number_string != NULL)
+if (host_number_string)
   {
   long int n;
   uschar *end;
   uschar *s = expand_string(host_number_string);
-  if (s == NULL)
+
+  if (!s)
     log_write(0, LOG_MAIN|LOG_PANIC_DIE,
         "failed to expand localhost_number \"%s\": %s",
         host_number_string, expand_string_message);
@@ -3574,19 +3574,13 @@ if (host_number_string != NULL)
   host_number = n;
   }
 
-#ifdef SUPPORT_TLS
+#ifndef DISABLE_TLS
 /* If tls_verify_hosts is set, tls_verify_certificates must also be set */
 
-if ((tls_verify_hosts != NULL || tls_try_verify_hosts != NULL) &&
-     tls_verify_certificates == NULL)
+if ((tls_verify_hosts || tls_try_verify_hosts) && !tls_verify_certificates)
   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
     "tls_%sverify_hosts is set, but tls_verify_certificates is not set",
-    (tls_verify_hosts != NULL)? "" : "try_");
-
-/* This also checks that the library linkage is working and we can call
-routines in it, so call even if tls_require_ciphers is unset */
-if (!tls_dropprivs_validate_require_cipher(nowarn))
-  exit(1);
+    tls_verify_hosts ? "" : "try_");
 
 /* Magic number: at time of writing, 1024 has been the long-standing value
 used by so many clients, and what Exim used to use always, that it makes
@@ -3608,7 +3602,7 @@ if (openssl_options)
       "openssl_options parse error: %s", openssl_options);
 # endif
   }
-#endif /*SUPPORT_TLS*/
+#endif /*DISABLE_TLS*/
 
 if (!nowarn && !keep_environment && environ && *environ)
   log_write(0, LOG_MAIN,
@@ -3641,23 +3635,18 @@ static driver_info *
 init_driver(driver_instance *d, driver_info *drivers_available,
   int size_of_info, uschar *class)
 {
-driver_info *dd;
-
-for (dd = drivers_available; dd->driver_name[0] != 0;
+for (driver_info * dd = drivers_available; dd->driver_name[0] != 0;
      dd = (driver_info *)((US dd) + size_of_info))
-  {
   if (Ustrcmp(d->driver_name, dd->driver_name) == 0)
     {
-    int i;
     int len = dd->options_len;
     d->info = dd;
-    d->options_block = store_get(len);
+    d->options_block = store_get(len, FALSE);
     memcpy(d->options_block, dd->options_block, len);
-    for (i = 0; i < *(dd->options_count); i++)
+    for (int i = 0; i < *(dd->options_count); i++)
       dd->options[i].type &= ~opt_set;
     return dd;
     }
-  }
 
 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
   "%s %s: cannot find %s driver \"%s\"", class, d->name, class, d->driver_name);
@@ -3710,7 +3699,7 @@ driver_instance **p = anchor;
 driver_instance *d = NULL;
 uschar *buffer;
 
-while ((buffer = get_config_line()) != NULL)
+while ((buffer = get_config_line()))
   {
   uschar name[64];
   uschar *s;
@@ -3731,10 +3720,11 @@ while ((buffer = get_config_line()) != NULL)
       if (!d->driver_name)
         log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
           "no driver defined for %s \"%s\"", class, d->name);
+      /* s is using big_buffer, so this call had better not */
       (d->info->init)(d);
       d = NULL;
       }
-    read_macro_assignment(buffer);
+    if (!macro_read_assignment(buffer)) exim_exit(EXIT_FAILURE);
     continue;
     }
 
@@ -3744,8 +3734,6 @@ while ((buffer = get_config_line()) != NULL)
 
   if (*s++ == ':')
     {
-    int i;
-
     /* Finish off initializing the previous driver. */
 
     if (d)
@@ -3766,7 +3754,7 @@ while ((buffer = get_config_line()) != NULL)
     /* Set up a new driver instance data block on the chain, with
     its default values installed. */
 
-    d = store_get(instance_size);
+    d = store_get(instance_size, FALSE);
     memcpy(d, instance_default, instance_size);
     *p = d;
     p = &d->next;
@@ -3774,13 +3762,13 @@ while ((buffer = get_config_line()) != NULL)
 
     /* Clear out the "set" bits in the generic options */
 
-    for (i = 0; i < driver_optionlist_count; i++)
+    for (int i = 0; i < driver_optionlist_count; i++)
       driver_optionlist[i].type &= ~opt_set;
 
     /* Check nothing more on this line, then do the next loop iteration. */
 
-    while (isspace(*s)) s++;
-    if (*s != 0) extra_chars_error(s, US"driver name ", name, US"");
+    Uskip_whitespace(&s);
+    if (*s) extra_chars_error(s, US"driver name ", name, US"");
     continue;
     }
 
@@ -3847,26 +3835,23 @@ BOOL
 readconf_depends(driver_instance *d, uschar *s)
 {
 int count = *(d->info->options_count);
-optionlist *ol;
 uschar *ss;
 
-for (ol = d->info->options; ol < d->info->options + count; ol++)
-  {
-  void *options_block;
-  uschar *value;
-  int type = ol->type & opt_mask;
-  if (type != opt_stringptr) continue;
-  options_block = ((ol->type & opt_public) == 0)? d->options_block : (void *)d;
-  value = *(uschar **)(US options_block + (long int)(ol->value));
-  if (value != NULL && (ss = Ustrstr(value, s)) != NULL)
+for (optionlist * ol = d->info->options; ol < d->info->options + count; ol++)
+  if ((ol->type & opt_mask) == opt_stringptr)
     {
-    if (ss <= value || (ss[-1] != '$' && ss[-1] != '{') ||
-      isalnum(ss[Ustrlen(s)])) continue;
-    DEBUG(D_transport) debug_printf("driver %s: \"%s\" option depends on %s\n",
-      d->name, ol->name, s);
-    return TRUE;
+    void * options_block = ol->type & opt_public ? (void *)d : d->options_block;
+    uschar * value = *USS(US options_block + ol->v.offset);
+
+    if (value && (ss = Ustrstr(value, s)) != NULL)
+      {
+      if (ss <= value || (ss[-1] != '$' && ss[-1] != '{') ||
+       isalnum(ss[Ustrlen(s)])) continue;
+      DEBUG(D_transport) debug_printf("driver %s: \"%s\" option depends on %s\n",
+       d->name, ol->name, s);
+      return TRUE;
+      }
     }
-  }
 
 DEBUG(D_transport) debug_printf("driver %s does not depend on %s\n", d->name, s);
 return FALSE;
@@ -4035,7 +4020,7 @@ const uschar *pp;
 
 if (*p++ != ',') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma expected");
 
-while (isspace(*p)) p++;
+Uskip_whitespace(&p);
 pp = p;
 while (isalnum(*p) || (type == 1 && *p == '.')) p++;
 
@@ -4066,7 +4051,7 @@ while ((p = get_config_line()))
   const uschar *pp;
   uschar *error;
 
-  next = store_get(sizeof(retry_config));
+  next = store_get(sizeof(retry_config), FALSE);
   next->next = NULL;
   *chain = next;
   chain = &(next->next);
@@ -4076,7 +4061,7 @@ while ((p = get_config_line()))
   rchain = &(next->rules);
 
   next->pattern = string_dequote(&p);
-  while (isspace(*p)) p++;
+  Uskip_whitespace(&p);
   pp = p;
   while (mac_isgraph(*p)) p++;
   if (p - pp <= 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
@@ -4093,24 +4078,24 @@ while ((p = get_config_line()))
   fudge. Anything that is not a retry rule starting "F," or "G," is treated as
   an address list. */
 
-  while (isspace(*p)) p++;
+  Uskip_whitespace(&p);
   if (Ustrncmp(p, "senders", 7) == 0)
     {
     p += 7;
-    while (isspace(*p)) p++;
+    Uskip_whitespace(&p);
     if (*p++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
       "\"=\" expected after \"senders\" in retry rule");
-    while (isspace(*p)) p++;
+    Uskip_whitespace(&p);
     next->senders = string_dequote(&p);
     }
 
   /* Now the retry rules. Keep the maximum timeout encountered. */
 
-  while (isspace(*p)) p++;
+  Uskip_whitespace(&p);
 
-  while (*p != 0)
+  while (*p)
     {
-    retry_rule *rule = store_get(sizeof(retry_rule));
+    retry_rule *rule = store_get(sizeof(retry_rule), FALSE);
     *rchain = rule;
     rchain = &(rule->next);
     rule->next = NULL;
@@ -4141,13 +4126,12 @@ while ((p = get_config_line()))
       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
         "bad parameters for retry rule");
 
-    while (isspace(*p)) p++;
-    if (*p == ';')
+    if (Uskip_whitespace(&p) == ';')
       {
       p++;
-      while (isspace(*p)) p++;
+      Uskip_whitespace(&p);
       }
-    else if (*p != 0)
+    else if (*p)
       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "semicolon expected");
     }
   }
@@ -4168,7 +4152,9 @@ Returns:     nothing
 static void
 auths_init(void)
 {
-auth_instance *au, *bu;
+#ifndef DISABLE_PIPE_CONNECT
+int nauths = 0;
+#endif
 
 readconf_driver_init(US"authenticator",
   (driver_instance **)(&auths),      /* chain anchor */
@@ -4179,20 +4165,26 @@ readconf_driver_init(US"authenticator",
   optionlist_auths,                  /* generic options */
   optionlist_auths_size);
 
-for (au = auths; au; au = au->next)
+for (auth_instance * au = auths; au; au = au->next)
   {
   if (!au->public_name)
     log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "no public name specified for "
       "the %s authenticator", au->name);
 
-  for (bu = au->next; bu; bu = bu->next)
+  for (auth_instance * bu = au->next; bu; bu = bu->next)
     if (strcmpic(au->public_name, bu->public_name) == 0)
       if ((au->client && bu->client) || (au->server && bu->server))
         log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "two %s authenticators "
           "(%s and %s) have the same public name (%s)",
           au->client ? US"client" : US"server", au->name, bu->name,
           au->public_name);
+#ifndef DISABLE_PIPE_CONNECT
+  nauths++;
+#endif
   }
+#ifndef DISABLE_PIPE_CONNECT
+f.smtp_in_early_pipe_no_auth = nauths > 16;
+#endif
 }
 
 
@@ -4235,7 +4227,7 @@ between ACLs. */
 
 acl_line = get_config_line();
 
-while(acl_line != NULL)
+while(acl_line)
   {
   uschar name[64];
   tree_node *node;
@@ -4244,7 +4236,7 @@ while(acl_line != NULL)
   p = readconf_readname(name, sizeof(name), acl_line);
   if (isupper(*name) && *p == '=')
     {
-    read_macro_assignment(acl_line);
+    if (!macro_read_assignment(acl_line)) exim_exit(EXIT_FAILURE);
     acl_line = get_config_line();
     continue;
     }
@@ -4252,7 +4244,7 @@ while(acl_line != NULL)
   if (*p != ':' || name[0] == 0)
     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing or malformed ACL name");
 
-  node = store_get(sizeof(tree_node) + Ustrlen(name));
+  node = store_get(sizeof(tree_node) + Ustrlen(name), is_tainted(name));
   Ustrcpy(node->name, name);
   if (!tree_insertnode(&acl_anchor, node))
     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
@@ -4288,11 +4280,9 @@ log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "local_scan() options not supported: "
 #else
 
 uschar *p;
-while ((p = get_config_line()) != NULL)
-  {
+while ((p = get_config_line()))
   (void) readconf_handle_option(p, local_scan_options, local_scan_options_count,
     NULL, US"local_scan option \"%s\" unknown");
-  }
 #endif
 }
 
@@ -4340,7 +4330,7 @@ while(next_section[0] != 0)
   int mid = last/2;
   int n = Ustrlen(next_section);
 
-  if (tolower(next_section[n-1]) != 's') Ustrcpy(next_section+n, "s");
+  if (tolower(next_section[n-1]) != 's') Ustrcpy(next_section+n, US"s");
 
   for (;;)
     {
@@ -4378,14 +4368,14 @@ while(next_section[0] != 0)
 void
 readconf_save_config(const uschar *s)
 {
-  save_config_line(string_sprintf("# Exim Configuration (%s)",
-    running_in_test_harness ? US"X" : s));
+save_config_line(string_sprintf("# Exim Configuration (%s)",
+  f.running_in_test_harness ? US"X" : s));
 }
 
 static void
 save_config_position(const uschar *file, int line)
 {
-  save_config_line(string_sprintf("# %d \"%s\"", line, file));
+save_config_line(string_sprintf("# %d \"%s\"", line, file));
 }
 
 /* Append a pre-parsed logical line to the config lines store,
@@ -4399,7 +4389,7 @@ save_config_line(const uschar* line)
 static config_line_item *current;
 config_line_item *next;
 
-next = (config_line_item*) store_get(sizeof(config_line_item));
+next = (config_line_item*) store_get(sizeof(config_line_item), FALSE);
 next->line = string_copy(line);
 next->next = NULL;
 
@@ -4414,11 +4404,10 @@ hide the <hide> values unless we're the admin user */
 void
 print_config(BOOL admin, BOOL terse)
 {
-config_line_item *i;
 const int TS = terse ? 0 : 2;
 int indent = 0;
 
-for (i = config_lines; i; i = i->next)
+for (config_line_item * i = config_lines; i; i = i->next)
   {
   uschar *current;
   uschar *p;
@@ -4478,11 +4467,11 @@ for (i = config_lines; i; i = i->next)
     if ((p = Ustrchr(current, '=')))
       {
       *p = '\0';
-      printf("%*s%s= %s\n", indent, "", current, hidden);
+      printf("%*s%s= %s\n", indent, "", current, CCS hidden);
       }
     /* e.g.: hide split_spool_directory */
     else
-      printf("%*s\n", indent, hidden);
+      printf("%*s\n", indent, CCS hidden);
     }
 
   else