src/src/readconf.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2018 */
   6 /* Copyright (c) The Exim Maintainers 2020 */
   7 /* See the file NOTICE for conditions of use and distribution. */
   8
   9 /* Functions for reading the configuration file, and for displaying
  10 overall configuration values. Thanks to Brian Candler for the original
  11 implementation of the conditional .ifdef etc. */
  12
  13 #include "exim.h"
  14
  15 #ifdef MACRO_PREDEF
  16 # include "macro_predef.h"
  17 #endif
  18
  19 #define READCONF_DEBUG  if (FALSE)      /* Change to TRUE to enable */
  20
  21
  22 static uschar * syslog_facility_str;
  23 static void fn_smtp_receive_timeout(const uschar *, const uschar *, unsigned);
  24
  25 /*************************************************
  26 *           Main configuration options           *
  27 *************************************************/
  28
  29 /* The list of options that can be set in the main configuration file. This
  30 must be in alphabetic order because it is searched by binary chop. */
  31
  32 static optionlist optionlist_config[] = {
  33   { "*set_exim_group",          opt_bool|opt_hidden, {&exim_gid_set} },
  34   { "*set_exim_user",           opt_bool|opt_hidden, {&exim_uid_set} },
  35   { "*set_system_filter_group", opt_bool|opt_hidden, {&system_filter_gid_set} },
  36   { "*set_system_filter_user",  opt_bool|opt_hidden, {&system_filter_uid_set} },
  37   { "accept_8bitmime",          opt_bool,        {&accept_8bitmime} },
  38   { "acl_not_smtp",             opt_stringptr,   {&acl_not_smtp} },
  39 #ifdef WITH_CONTENT_SCAN
  40   { "acl_not_smtp_mime",        opt_stringptr,   {&acl_not_smtp_mime} },
  41 #endif
  42   { "acl_not_smtp_start",       opt_stringptr,   {&acl_not_smtp_start} },
  43   { "acl_smtp_auth",            opt_stringptr,   {&acl_smtp_auth} },
  44   { "acl_smtp_connect",         opt_stringptr,   {&acl_smtp_connect} },
  45   { "acl_smtp_data",            opt_stringptr,   {&acl_smtp_data} },
  46 #ifndef DISABLE_PRDR
  47   { "acl_smtp_data_prdr",       opt_stringptr,   {&acl_smtp_data_prdr} },
  48 #endif
  49 #ifndef DISABLE_DKIM
  50   { "acl_smtp_dkim",            opt_stringptr,   {&acl_smtp_dkim} },
  51 #endif
  52   { "acl_smtp_etrn",            opt_stringptr,   {&acl_smtp_etrn} },
  53   { "acl_smtp_expn",            opt_stringptr,   {&acl_smtp_expn} },
  54   { "acl_smtp_helo",            opt_stringptr,   {&acl_smtp_helo} },
  55   { "acl_smtp_mail",            opt_stringptr,   {&acl_smtp_mail} },
  56   { "acl_smtp_mailauth",        opt_stringptr,   {&acl_smtp_mailauth} },
  57 #ifdef WITH_CONTENT_SCAN
  58   { "acl_smtp_mime",            opt_stringptr,   {&acl_smtp_mime} },
  59 #endif
  60   { "acl_smtp_notquit",         opt_stringptr,   {&acl_smtp_notquit} },
  61   { "acl_smtp_predata",         opt_stringptr,   {&acl_smtp_predata} },
  62   { "acl_smtp_quit",            opt_stringptr,   {&acl_smtp_quit} },
  63   { "acl_smtp_rcpt",            opt_stringptr,   {&acl_smtp_rcpt} },
  64 #ifndef DISABLE_TLS
  65   { "acl_smtp_starttls",        opt_stringptr,   {&acl_smtp_starttls} },
  66 #endif
  67   { "acl_smtp_vrfy",            opt_stringptr,   {&acl_smtp_vrfy} },
  68   { "add_environment",          opt_stringptr,   {&add_environment} },
  69   { "admin_groups",             opt_gidlist,     {&admin_groups} },
  70   { "allow_domain_literals",    opt_bool,        {&allow_domain_literals} },
  71 #ifdef ALLOW_INSECURE_TAINTED_DATA
  72   { "allow_insecure_tainted_data", opt_bool,     {&allow_insecure_tainted_data} },
  73 #endif
  74   { "allow_mx_to_ip",           opt_bool,        {&allow_mx_to_ip} },
  75   { "allow_utf8_domains",       opt_bool,        {&allow_utf8_domains} },
  76   { "auth_advertise_hosts",     opt_stringptr,   {&auth_advertise_hosts} },
  77   { "auto_thaw",                opt_time,        {&auto_thaw} },
  78 #ifdef WITH_CONTENT_SCAN
  79   { "av_scanner",               opt_stringptr,   {&av_scanner} },
  80 #endif
  81   { "bi_command",               opt_stringptr,   {&bi_command} },
  82 #ifdef EXPERIMENTAL_BRIGHTMAIL
  83   { "bmi_config_file",          opt_stringptr,   {&bmi_config_file} },
  84 #endif
  85   { "bounce_message_file",      opt_stringptr,   {&bounce_message_file} },
  86   { "bounce_message_text",      opt_stringptr,   {&bounce_message_text} },
  87   { "bounce_return_body",       opt_bool,        {&bounce_return_body} },
  88   { "bounce_return_linesize_limit", opt_mkint,   {&bounce_return_linesize_limit} },
  89   { "bounce_return_message",    opt_bool,        {&bounce_return_message} },
  90   { "bounce_return_size_limit", opt_mkint,       {&bounce_return_size_limit} },
  91   { "bounce_sender_authentication",opt_stringptr,{&bounce_sender_authentication} },
  92   { "callout_domain_negative_expire", opt_time,  {&callout_cache_domain_negative_expire} },
  93   { "callout_domain_positive_expire", opt_time,  {&callout_cache_domain_positive_expire} },
  94   { "callout_negative_expire",  opt_time,        {&callout_cache_negative_expire} },
  95   { "callout_positive_expire",  opt_time,        {&callout_cache_positive_expire} },
  96   { "callout_random_local_part",opt_stringptr,   {&callout_random_local_part} },
  97   { "check_log_inodes",         opt_int,         {&check_log_inodes} },
  98   { "check_log_space",          opt_Kint,        {&check_log_space} },
  99   { "check_rfc2047_length",     opt_bool,        {&check_rfc2047_length} },
 100   { "check_spool_inodes",       opt_int,         {&check_spool_inodes} },
 101   { "check_spool_space",        opt_Kint,        {&check_spool_space} },
 102   { "chunking_advertise_hosts", opt_stringptr,   {&chunking_advertise_hosts} },
 103   { "commandline_checks_require_admin", opt_bool,{&commandline_checks_require_admin} },
 104   { "daemon_smtp_port",         opt_stringptr|opt_hidden, {&daemon_smtp_port} },
 105   { "daemon_smtp_ports",        opt_stringptr,   {&daemon_smtp_port} },
 106   { "daemon_startup_retries",   opt_int,         {&daemon_startup_retries} },
 107   { "daemon_startup_sleep",     opt_time,        {&daemon_startup_sleep} },
 108 #ifdef EXPERIMENTAL_DCC
 109   { "dcc_direct_add_header",    opt_bool,        {&dcc_direct_add_header} },
 110   { "dccifd_address",           opt_stringptr,   {&dccifd_address} },
 111   { "dccifd_options",           opt_stringptr,   {&dccifd_options} },
 112 #endif
 113   { "debug_store",              opt_bool,        {&debug_store} },
 114   { "delay_warning",            opt_timelist,    {&delay_warning} },
 115   { "delay_warning_condition",  opt_stringptr,   {&delay_warning_condition} },
 116   { "deliver_drop_privilege",   opt_bool,        {&deliver_drop_privilege} },
 117   { "deliver_queue_load_max",   opt_fixed,       {&deliver_queue_load_max} },
 118   { "delivery_date_remove",     opt_bool,        {&delivery_date_remove} },
 119 #ifdef ENABLE_DISABLE_FSYNC
 120   { "disable_fsync",            opt_bool,        {&disable_fsync} },
 121 #endif
 122   { "disable_ipv6",             opt_bool,        {&disable_ipv6} },
 123 #ifndef DISABLE_DKIM
 124   { "dkim_verify_hashes",       opt_stringptr,   {&dkim_verify_hashes} },
 125   { "dkim_verify_keytypes",     opt_stringptr,   {&dkim_verify_keytypes} },
 126   { "dkim_verify_min_keysizes", opt_stringptr,   {&dkim_verify_min_keysizes} },
 127   { "dkim_verify_minimal",      opt_bool,        {&dkim_verify_minimal} },
 128   { "dkim_verify_signers",      opt_stringptr,   {&dkim_verify_signers} },
 129 #endif
 130 #ifdef SUPPORT_DMARC
 131   { "dmarc_forensic_sender",    opt_stringptr,   {&dmarc_forensic_sender} },
 132   { "dmarc_history_file",       opt_stringptr,   {&dmarc_history_file} },
 133   { "dmarc_tld_file",           opt_stringptr,   {&dmarc_tld_file} },
 134 #endif
 135   { "dns_again_means_nonexist", opt_stringptr,   {&dns_again_means_nonexist} },
 136   { "dns_check_names_pattern",  opt_stringptr,   {&check_dns_names_pattern} },
 137   { "dns_cname_loops",          opt_int,         {&dns_cname_loops} },
 138   { "dns_csa_search_limit",     opt_int,         {&dns_csa_search_limit} },
 139   { "dns_csa_use_reverse",      opt_bool,        {&dns_csa_use_reverse} },
 140   { "dns_dnssec_ok",            opt_int,         {&dns_dnssec_ok} },
 141   { "dns_ipv4_lookup",          opt_stringptr,   {&dns_ipv4_lookup} },
 142   { "dns_retrans",              opt_time,        {&dns_retrans} },
 143   { "dns_retry",                opt_int,         {&dns_retry} },
 144   { "dns_trust_aa",             opt_stringptr,   {&dns_trust_aa} },
 145   { "dns_use_edns0",            opt_int,         {&dns_use_edns0} },
 146  /* This option is now a no-op, retained for compatibility */
 147   { "drop_cr",                  opt_bool,        {&drop_cr} },
 148 /*********************************************************/
 149   { "dsn_advertise_hosts",      opt_stringptr,   {&dsn_advertise_hosts} },
 150   { "dsn_from",                 opt_stringptr,   {&dsn_from} },
 151   { "envelope_to_remove",       opt_bool,        {&envelope_to_remove} },
 152   { "errors_copy",              opt_stringptr,   {&errors_copy} },
 153   { "errors_reply_to",          opt_stringptr,   {&errors_reply_to} },
 154 #ifndef DISABLE_EVENT
 155   { "event_action",             opt_stringptr,   {&event_action} },
 156 #endif
 157   { "exim_group",               opt_gid,         {&exim_gid} },
 158   { "exim_path",                opt_stringptr,   {&exim_path} },
 159   { "exim_user",                opt_uid,         {&exim_uid} },
 160   { "exim_version",             opt_stringptr,   {&version_string} },
 161   { "extra_local_interfaces",   opt_stringptr,   {&extra_local_interfaces} },
 162   { "extract_addresses_remove_arguments", opt_bool, {&extract_addresses_remove_arguments} },
 163   { "finduser_retries",         opt_int,         {&finduser_retries} },
 164   { "freeze_tell",              opt_stringptr,   {&freeze_tell} },
 165   { "gecos_name",               opt_stringptr,   {&gecos_name} },
 166   { "gecos_pattern",            opt_stringptr,   {&gecos_pattern} },
 167 #ifndef DISABLE_TLS
 168   { "gnutls_allow_auto_pkcs11", opt_bool,        {&gnutls_allow_auto_pkcs11} },
 169   { "gnutls_compat_mode",       opt_bool,        {&gnutls_compat_mode} },
 170 #endif
 171   { "header_line_maxsize",      opt_int,         {&header_line_maxsize} },
 172   { "header_maxsize",           opt_int,         {&header_maxsize} },
 173   { "headers_charset",          opt_stringptr,   {&headers_charset} },
 174   { "helo_accept_junk_hosts",   opt_stringptr,   {&helo_accept_junk_hosts} },
 175   { "helo_allow_chars",         opt_stringptr,   {&helo_allow_chars} },
 176   { "helo_lookup_domains",      opt_stringptr,   {&helo_lookup_domains} },
 177   { "helo_try_verify_hosts",    opt_stringptr,   {&helo_try_verify_hosts} },
 178   { "helo_verify_hosts",        opt_stringptr,   {&helo_verify_hosts} },
 179   { "hold_domains",             opt_stringptr,   {&hold_domains} },
 180   { "host_lookup",              opt_stringptr,   {&host_lookup} },
 181   { "host_lookup_order",        opt_stringptr,   {&host_lookup_order} },
 182   { "host_reject_connection",   opt_stringptr,   {&host_reject_connection} },
 183   { "hosts_connection_nolog",   opt_stringptr,   {&hosts_connection_nolog} },
 184 #ifdef SUPPORT_PROXY
 185   { "hosts_proxy",              opt_stringptr,   {&hosts_proxy} },
 186 #endif
 187   { "hosts_require_helo",       opt_stringptr,   {&hosts_require_helo} },
 188   { "hosts_treat_as_local",     opt_stringptr,   {&hosts_treat_as_local} },
 189 #ifdef LOOKUP_IBASE
 190   { "ibase_servers",            opt_stringptr,   {&ibase_servers} },
 191 #endif
 192   { "ignore_bounce_errors_after", opt_time,      {&ignore_bounce_errors_after} },
 193   { "ignore_fromline_hosts",    opt_stringptr,   {&ignore_fromline_hosts} },
 194   { "ignore_fromline_local",    opt_bool,        {&ignore_fromline_local} },
 195   { "keep_environment",         opt_stringptr,   {&keep_environment} },
 196   { "keep_malformed",           opt_time,        {&keep_malformed} },
 197 #ifdef LOOKUP_LDAP
 198   { "ldap_ca_cert_dir",         opt_stringptr,   {&eldap_ca_cert_dir} },
 199   { "ldap_ca_cert_file",        opt_stringptr,   {&eldap_ca_cert_file} },
 200   { "ldap_cert_file",           opt_stringptr,   {&eldap_cert_file} },
 201   { "ldap_cert_key",            opt_stringptr,   {&eldap_cert_key} },
 202   { "ldap_cipher_suite",        opt_stringptr,   {&eldap_cipher_suite} },
 203   { "ldap_default_servers",     opt_stringptr,   {&eldap_default_servers} },
 204   { "ldap_require_cert",        opt_stringptr,   {&eldap_require_cert} },
 205   { "ldap_start_tls",           opt_bool,        {&eldap_start_tls} },
 206   { "ldap_version",             opt_int,         {&eldap_version} },
 207 #endif
 208 #ifdef EXPERIMENTAL_ESMTP_LIMITS
 209   { "limits_advertise_hosts", opt_stringptr, {&limits_advertise_hosts} },
 210 #endif
 211   { "local_from_check",         opt_bool,        {&local_from_check} },
 212   { "local_from_prefix",        opt_stringptr,   {&local_from_prefix} },
 213   { "local_from_suffix",        opt_stringptr,   {&local_from_suffix} },
 214   { "local_interfaces",         opt_stringptr,   {&local_interfaces} },
 215 #ifdef HAVE_LOCAL_SCAN
 216   { "local_scan_timeout",       opt_time,        {&local_scan_timeout} },
 217 #endif
 218   { "local_sender_retain",      opt_bool,        {&local_sender_retain} },
 219   { "localhost_number",         opt_stringptr,   {&host_number_string} },
 220   { "log_file_path",            opt_stringptr,   {&log_file_path} },
 221   { "log_selector",             opt_stringptr,   {&log_selector_string} },
 222   { "log_timezone",             opt_bool,        {&log_timezone} },
 223   { "lookup_open_max",          opt_int,         {&lookup_open_max} },
 224   { "max_username_length",      opt_int,         {&max_username_length} },
 225   { "message_body_newlines",    opt_bool,        {&message_body_newlines} },
 226   { "message_body_visible",     opt_mkint,       {&message_body_visible} },
 227   { "message_id_header_domain", opt_stringptr,   {&message_id_domain} },
 228   { "message_id_header_text",   opt_stringptr,   {&message_id_text} },
 229   { "message_logs",             opt_bool,        {&message_logs} },
 230   { "message_size_limit",       opt_stringptr,   {&message_size_limit} },
 231 #ifdef SUPPORT_MOVE_FROZEN_MESSAGES
 232   { "move_frozen_messages",     opt_bool,        {&move_frozen_messages} },
 233 #endif
 234   { "mua_wrapper",              opt_bool,        {&mua_wrapper} },
 235 #ifdef LOOKUP_MYSQL
 236   { "mysql_servers",            opt_stringptr,   {&mysql_servers} },
 237 #endif
 238   { "never_users",              opt_uidlist,     {&never_users} },
 239   { "notifier_socket",          opt_stringptr,   {&notifier_socket} },
 240 #ifndef DISABLE_TLS
 241   { "openssl_options",          opt_stringptr,   {&openssl_options} },
 242 #endif
 243 #ifdef LOOKUP_ORACLE
 244   { "oracle_servers",           opt_stringptr,   {&oracle_servers} },
 245 #endif
 246   { "percent_hack_domains",     opt_stringptr,   {&percent_hack_domains} },
 247 #ifdef EXIM_PERL
 248   { "perl_at_start",            opt_bool,        {&opt_perl_at_start} },
 249   { "perl_startup",             opt_stringptr,   {&opt_perl_startup} },
 250   { "perl_taintmode",           opt_bool,        {&opt_perl_taintmode} },
 251 #endif
 252 #ifdef LOOKUP_PGSQL
 253   { "pgsql_servers",            opt_stringptr,   {&pgsql_servers} },
 254 #endif
 255   { "pid_file_path",            opt_stringptr,   {&pid_file_path} },
 256   { "pipelining_advertise_hosts", opt_stringptr, {&pipelining_advertise_hosts} },
 257 #ifndef DISABLE_PIPE_CONNECT
 258   { "pipelining_connect_advertise_hosts", opt_stringptr,
 259                                                  {&pipe_connect_advertise_hosts} },
 260 #endif
 261 #ifndef DISABLE_PRDR
 262   { "prdr_enable",              opt_bool,        {&prdr_enable} },
 263 #endif
 264   { "preserve_message_logs",    opt_bool,        {&preserve_message_logs} },
 265   { "primary_hostname",         opt_stringptr,   {&primary_hostname} },
 266   { "print_topbitchars",        opt_bool,        {&print_topbitchars} },
 267   { "process_log_path",         opt_stringptr,   {&process_log_path} },
 268   { "prod_requires_admin",      opt_bool,        {&prod_requires_admin} },
 269 #ifdef SUPPORT_PROXY
 270   { "proxy_protocol_timeout",   opt_time,        {&proxy_protocol_timeout} },
 271 #endif
 272   { "qualify_domain",           opt_stringptr,   {&qualify_domain_sender} },
 273   { "qualify_recipient",        opt_stringptr,   {&qualify_domain_recipient} },
 274   { "queue_domains",            opt_stringptr,   {&queue_domains} },
 275 #ifndef DISABLE_QUEUE_RAMP
 276   { "queue_fast_ramp",          opt_bool,        {&queue_fast_ramp} },
 277 #endif
 278   { "queue_list_requires_admin",opt_bool,        {&queue_list_requires_admin} },
 279   { "queue_only",               opt_bool,        {&queue_only} },
 280   { "queue_only_file",          opt_stringptr,   {&queue_only_file} },
 281   { "queue_only_load",          opt_fixed,       {&queue_only_load} },
 282   { "queue_only_load_latch",    opt_bool,        {&queue_only_load_latch} },
 283   { "queue_only_override",      opt_bool,        {&queue_only_override} },
 284   { "queue_run_in_order",       opt_bool,        {&queue_run_in_order} },
 285   { "queue_run_max",            opt_stringptr,   {&queue_run_max} },
 286   { "queue_smtp_domains",       opt_stringptr,   {&queue_smtp_domains} },
 287   { "receive_timeout",          opt_time,        {&receive_timeout} },
 288   { "received_header_text",     opt_stringptr,   {&received_header_text} },
 289   { "received_headers_max",     opt_int,         {&received_headers_max} },
 290   { "recipient_unqualified_hosts", opt_stringptr, {&recipient_unqualified_hosts} },
 291   { "recipients_max",           opt_int,         {&recipients_max} },
 292   { "recipients_max_reject",    opt_bool,        {&recipients_max_reject} },
 293 #ifdef LOOKUP_REDIS
 294   { "redis_servers",            opt_stringptr,   {&redis_servers} },
 295 #endif
 296   { "remote_max_parallel",      opt_int,         {&remote_max_parallel} },
 297   { "remote_sort_domains",      opt_stringptr,   {&remote_sort_domains} },
 298   { "retry_data_expire",        opt_time,        {&retry_data_expire} },
 299   { "retry_interval_max",       opt_time,        {&retry_interval_max} },
 300   { "return_path_remove",       opt_bool,        {&return_path_remove} },
 301   { "return_size_limit",        opt_mkint|opt_hidden, {&bounce_return_size_limit} },
 302   { "rfc1413_hosts",            opt_stringptr,   {&rfc1413_hosts} },
 303   { "rfc1413_query_timeout",    opt_time,        {&rfc1413_query_timeout} },
 304   { "sender_unqualified_hosts", opt_stringptr,   {&sender_unqualified_hosts} },
 305   { "slow_lookup_log",          opt_int,         {&slow_lookup_log} },
 306   { "smtp_accept_keepalive",    opt_bool,        {&smtp_accept_keepalive} },
 307   { "smtp_accept_max",          opt_int,         {&smtp_accept_max} },
 308   { "smtp_accept_max_nonmail",  opt_int,         {&smtp_accept_max_nonmail} },
 309   { "smtp_accept_max_nonmail_hosts", opt_stringptr, {&smtp_accept_max_nonmail_hosts} },
 310   { "smtp_accept_max_per_connection", opt_stringptr,   {&smtp_accept_max_per_connection} },
 311   { "smtp_accept_max_per_host", opt_stringptr,   {&smtp_accept_max_per_host} },
 312   { "smtp_accept_queue",        opt_int,         {&smtp_accept_queue} },
 313   { "smtp_accept_queue_per_connection", opt_int, {&smtp_accept_queue_per_connection} },
 314   { "smtp_accept_reserve",      opt_int,         {&smtp_accept_reserve} },
 315   { "smtp_active_hostname",     opt_stringptr,   {&raw_active_hostname} },
 316   { "smtp_backlog_monitor",     opt_int,         {&smtp_backlog_monitor} },
 317   { "smtp_banner",              opt_stringptr,   {&smtp_banner} },
 318   { "smtp_check_spool_space",   opt_bool,        {&smtp_check_spool_space} },
 319   { "smtp_connect_backlog",     opt_int,         {&smtp_connect_backlog} },
 320   { "smtp_enforce_sync",        opt_bool,        {&smtp_enforce_sync} },
 321   { "smtp_etrn_command",        opt_stringptr,   {&smtp_etrn_command} },
 322   { "smtp_etrn_serialize",      opt_bool,        {&smtp_etrn_serialize} },
 323   { "smtp_load_reserve",        opt_fixed,       {&smtp_load_reserve} },
 324   { "smtp_max_synprot_errors",  opt_int,         {&smtp_max_synprot_errors} },
 325   { "smtp_max_unknown_commands",opt_int,         {&smtp_max_unknown_commands} },
 326   { "smtp_ratelimit_hosts",     opt_stringptr,   {&smtp_ratelimit_hosts} },
 327   { "smtp_ratelimit_mail",      opt_stringptr,   {&smtp_ratelimit_mail} },
 328   { "smtp_ratelimit_rcpt",      opt_stringptr,   {&smtp_ratelimit_rcpt} },
 329   { "smtp_receive_timeout",     opt_func,        {.fn = &fn_smtp_receive_timeout} },
 330   { "smtp_reserve_hosts",       opt_stringptr,   {&smtp_reserve_hosts} },
 331   { "smtp_return_error_details",opt_bool,        {&smtp_return_error_details} },
 332 #ifdef SUPPORT_I18N
 333   { "smtputf8_advertise_hosts", opt_stringptr,   {&smtputf8_advertise_hosts} },
 334 #endif
 335 #ifdef WITH_CONTENT_SCAN
 336   { "spamd_address",            opt_stringptr,   {&spamd_address} },
 337 #endif
 338 #ifdef SUPPORT_SPF
 339   { "spf_guess",                opt_stringptr,   {&spf_guess} },
 340   { "spf_smtp_comment_template",opt_stringptr,   {&spf_smtp_comment_template} },
 341 #endif
 342   { "split_spool_directory",    opt_bool,        {&split_spool_directory} },
 343   { "spool_directory",          opt_stringptr,   {&spool_directory} },
 344   { "spool_wireformat",         opt_bool,        {&spool_wireformat} },
 345 #ifdef LOOKUP_SQLITE
 346   { "sqlite_dbfile",            opt_stringptr,   {&sqlite_dbfile} },
 347   { "sqlite_lock_timeout",      opt_int,         {&sqlite_lock_timeout} },
 348 #endif
 349 #ifdef EXPERIMENTAL_SRS_ALT
 350   { "srs_config",               opt_stringptr,   {&srs_config} },
 351   { "srs_hashlength",           opt_int,         {&srs_hashlength} },
 352   { "srs_hashmin",              opt_int,         {&srs_hashmin} },
 353   { "srs_maxage",               opt_int,         {&srs_maxage} },
 354   { "srs_secrets",              opt_stringptr,   {&srs_secrets} },
 355   { "srs_usehash",              opt_bool,        {&srs_usehash} },
 356   { "srs_usetimestamp",         opt_bool,        {&srs_usetimestamp} },
 357 #endif
 358   { "strict_acl_vars",          opt_bool,        {&strict_acl_vars} },
 359   { "strip_excess_angle_brackets", opt_bool,     {&strip_excess_angle_brackets} },
 360   { "strip_trailing_dot",       opt_bool,        {&strip_trailing_dot} },
 361   { "syslog_duplication",       opt_bool,        {&syslog_duplication} },
 362   { "syslog_facility",          opt_stringptr,   {&syslog_facility_str} },
 363   { "syslog_pid",               opt_bool,        {&syslog_pid} },
 364   { "syslog_processname",       opt_stringptr,   {&syslog_processname} },
 365   { "syslog_timestamp",         opt_bool,        {&syslog_timestamp} },
 366   { "system_filter",            opt_stringptr,   {&system_filter} },
 367   { "system_filter_directory_transport", opt_stringptr,{&system_filter_directory_transport} },
 368   { "system_filter_file_transport",opt_stringptr,{&system_filter_file_transport} },
 369   { "system_filter_group",      opt_gid,         {&system_filter_gid} },
 370   { "system_filter_pipe_transport",opt_stringptr,{&system_filter_pipe_transport} },
 371   { "system_filter_reply_transport",opt_stringptr,{&system_filter_reply_transport} },
 372   { "system_filter_user",       opt_uid,         {&system_filter_uid} },
 373   { "tcp_nodelay",              opt_bool,        {&tcp_nodelay} },
 374 #ifdef USE_TCP_WRAPPERS
 375   { "tcp_wrappers_daemon_name", opt_stringptr,   {&tcp_wrappers_daemon_name} },
 376 #endif
 377   { "timeout_frozen_after",     opt_time,        {&timeout_frozen_after} },
 378   { "timezone",                 opt_stringptr,   {&timezone_string} },
 379   { "tls_advertise_hosts",      opt_stringptr,   {&tls_advertise_hosts} },
 380 #ifndef DISABLE_TLS
 381   { "tls_certificate",          opt_stringptr,   {&tls_certificate} },
 382   { "tls_crl",                  opt_stringptr,   {&tls_crl} },
 383   { "tls_dh_max_bits",          opt_int,         {&tls_dh_max_bits} },
 384   { "tls_dhparam",              opt_stringptr,   {&tls_dhparam} },
 385   { "tls_eccurve",              opt_stringptr,   {&tls_eccurve} },
 386 # ifndef DISABLE_OCSP
 387   { "tls_ocsp_file",            opt_stringptr,   {&tls_ocsp_file} },
 388 # endif
 389   { "tls_on_connect_ports",     opt_stringptr,   {&tls_in.on_connect_ports} },
 390   { "tls_privatekey",           opt_stringptr,   {&tls_privatekey} },
 391   { "tls_remember_esmtp",       opt_bool,        {&tls_remember_esmtp} },
 392   { "tls_require_ciphers",      opt_stringptr,   {&tls_require_ciphers} },
 393 # ifndef DISABLE_TLS_RESUME
 394   { "tls_resumption_hosts",     opt_stringptr,   {&tls_resumption_hosts} },
 395 # endif
 396   { "tls_try_verify_hosts",     opt_stringptr,   {&tls_try_verify_hosts} },
 397   { "tls_verify_certificates",  opt_stringptr,   {&tls_verify_certificates} },
 398   { "tls_verify_hosts",         opt_stringptr,   {&tls_verify_hosts} },
 399 #endif
 400   { "trusted_groups",           opt_gidlist,     {&trusted_groups} },
 401   { "trusted_users",            opt_uidlist,     {&trusted_users} },
 402   { "unknown_login",            opt_stringptr,   {&unknown_login} },
 403   { "unknown_username",         opt_stringptr,   {&unknown_username} },
 404   { "untrusted_set_sender",     opt_stringptr,   {&untrusted_set_sender} },
 405   { "uucp_from_pattern",        opt_stringptr,   {&uucp_from_pattern} },
 406   { "uucp_from_sender",         opt_stringptr,   {&uucp_from_sender} },
 407   { "warn_message_file",        opt_stringptr,   {&warn_message_file} },
 408   { "write_rejectlog",          opt_bool,        {&write_rejectlog} }
 409 };
 410
 411 #ifndef MACRO_PREDEF
 412 static int optionlist_config_size = nelem(optionlist_config);
 413 #endif
 414
 415
 416 #ifdef MACRO_PREDEF
 417
 418 static void
 419 fn_smtp_receive_timeout(const uschar * name, const uschar * str, unsigned flags) {/*Dummy*/}
 420
 421 void
 422 options_main(void)
 423 {
 424 options_from_list(optionlist_config, nelem(optionlist_config), US"MAIN", NULL);
 425 }
 426
 427 void
 428 options_auths(void)
 429 {
 430 uschar buf[EXIM_DRIVERNAME_MAX];
 431
 432 options_from_list(optionlist_auths, optionlist_auths_size, US"AUTHENTICATORS", NULL);
 433
 434 for (struct auth_info * ai = auths_available; ai->driver_name[0]; ai++)
 435   {
 436   spf(buf, sizeof(buf), US"_DRIVER_AUTHENTICATOR_%T", ai->driver_name);
 437   builtin_macro_create(buf);
 438   options_from_list(ai->options, (unsigned)*ai->options_count, US"AUTHENTICATOR", ai->driver_name);
 439
 440   if (ai->macros_create) (ai->macros_create)();
 441   }
 442 }
 443
 444 void
 445 options_logging(void)
 446 {
 447 uschar buf[EXIM_DRIVERNAME_MAX];
 448
 449 for (bit_table * bp = log_options; bp < log_options + log_options_count; bp++)
 450   {
 451   spf(buf, sizeof(buf), US"_LOG_%T", bp->name);
 452   builtin_macro_create(buf);
 453   }
 454 }
 455
 456
 457 #else   /*!MACRO_PREDEF*/
 458
 459 extern char **environ;
 460
 461 static void save_config_line(const uschar* line);
 462 static void save_config_position(const uschar *file, int line);
 463 static void print_config(BOOL admin, BOOL terse);
 464
 465
 466 #define CSTATE_STACK_SIZE 10
 467
 468 const uschar *config_directory = NULL;
 469
 470
 471 /* Structure for chain (stack) of .included files */
 472
 473 typedef struct config_file_item {
 474   struct config_file_item *next;
 475   const uschar *filename;
 476   const uschar *directory;
 477   FILE *file;
 478   int lineno;
 479 } config_file_item;
 480
 481 /* Structure for chain of configuration lines (-bP config) */
 482
 483 typedef struct config_line_item {
 484   struct config_line_item *next;
 485   uschar *line;
 486 } config_line_item;
 487
 488 static config_line_item* config_lines;
 489
 490 /* Structure of table of conditional words and their state transitions */
 491
 492 typedef struct cond_item {
 493   uschar *name;
 494   int    namelen;
 495   int    action1;
 496   int    action2;
 497   int    pushpop;
 498 } cond_item;
 499
 500 /* Structure of table of syslog facility names and values */
 501
 502 typedef struct syslog_fac_item {
 503   uschar *name;
 504   int    value;
 505 } syslog_fac_item;
 506
 507 /* constants */
 508 static const uschar * const hidden = US"<value not displayable>";
 509
 510 /* Static variables */
 511
 512 static config_file_item *config_file_stack = NULL;  /* For includes */
 513
 514 static uschar *syslog_facility_str  = NULL;
 515 static uschar next_section[24];
 516 static uschar time_buffer[24];
 517
 518 /* State variables for conditional loading (.ifdef / .else / .endif) */
 519
 520 static int cstate = 0;
 521 static int cstate_stack_ptr = -1;
 522 static int cstate_stack[CSTATE_STACK_SIZE];
 523
 524 /* Table of state transitions for handling conditional inclusions. There are
 525 four possible state transitions:
 526
 527   .ifdef true
 528   .ifdef false
 529   .elifdef true  (or .else)
 530   .elifdef false
 531
 532 .endif just causes the previous cstate to be popped off the stack */
 533
 534 static int next_cstate[3][4] =
 535   {
 536   /* State 0: reading from file, or reading until next .else or .endif */
 537   { 0, 1, 2, 2 },
 538   /* State 1: condition failed, skipping until next .else or .endif */
 539   { 2, 2, 0, 1 },
 540   /* State 2: skipping until .endif */
 541   { 2, 2, 2, 2 },
 542   };
 543
 544 /* Table of conditionals and the states to set. For each name, there are four
 545 values: the length of the name (to save computing it each time), the state to
 546 set if a macro was found in the line, the state to set if a macro was not found
 547 in the line, and a stack manipulation setting which is:
 548
 549   -1   pull state value off the stack
 550    0   don't alter the stack
 551   +1   push value onto stack, before setting new state
 552 */
 553
 554 static cond_item cond_list[] = {
 555   { US"ifdef",    5, 0, 1,  1 },
 556   { US"ifndef",   6, 1, 0,  1 },
 557   { US"elifdef",  7, 2, 3,  0 },
 558   { US"elifndef", 8, 3, 2,  0 },
 559   { US"else",     4, 2, 2,  0 },
 560   { US"endif",    5, 0, 0, -1 }
 561 };
 562
 563 static int cond_list_size = sizeof(cond_list)/sizeof(cond_item);
 564
 565 /* Table of syslog facility names and their values */
 566
 567 static syslog_fac_item syslog_list[] = {
 568   { US"mail",   LOG_MAIL },
 569   { US"user",   LOG_USER },
 570   { US"news",   LOG_NEWS },
 571   { US"uucp",   LOG_UUCP },
 572   { US"local0", LOG_LOCAL0 },
 573   { US"local1", LOG_LOCAL1 },
 574   { US"local2", LOG_LOCAL2 },
 575   { US"local3", LOG_LOCAL3 },
 576   { US"local4", LOG_LOCAL4 },
 577   { US"local5", LOG_LOCAL5 },
 578   { US"local6", LOG_LOCAL6 },
 579   { US"local7", LOG_LOCAL7 },
 580   { US"daemon", LOG_DAEMON }
 581 };
 582
 583 static int syslog_list_size = sizeof(syslog_list)/sizeof(syslog_fac_item);
 584
 585
 586 #define opt_fn_print            BIT(0)
 587 #define opt_fn_print_label      BIT(1)
 588
 589
 590 /*************************************************
 591 *         Find the name of an option             *
 592 *************************************************/
 593
 594 /* This function is to aid debugging. Various functions take arguments that are
 595 pointer variables in the options table or in option tables for various drivers.
 596 For debugging output, it is useful to be able to find the name of the option
 597 which is currently being processed. This function finds it, if it exists, by
 598 searching the table(s).
 599
 600 Arguments:   a value that is presumed to be in the table above
 601 Returns:     the option name, or an empty string
 602 */
 603
 604 uschar *
 605 readconf_find_option(void *p)
 606 {
 607 for (int i = 0; i < nelem(optionlist_config); i++)
 608   if (p == optionlist_config[i].v.value) return US optionlist_config[i].name;
 609
 610 for (router_instance * r = routers; r; r = r->next)
 611   {
 612   router_info *ri = r->info;
 613   for (int i = 0; i < *ri->options_count; i++)
 614     {
 615     if ((ri->options[i].type & opt_mask) != opt_stringptr) continue;
 616     if (p == CS (r->options_block) + ri->options[i].v.offset)
 617       return US ri->options[i].name;
 618     }
 619   }
 620
 621 for (transport_instance * t = transports; t; t = t->next)
 622   {
 623   transport_info *ti = t->info;
 624   for (int i = 0; i < *ti->options_count; i++)
 625     {
 626     optionlist * op = &ti->options[i];
 627     if ((op->type & opt_mask) != opt_stringptr) continue;
 628     if (p == (  op->type & opt_public
 629              ? CS t
 630              : CS t->options_block
 631              )
 632              + op->v.offset)
 633         return US op->name;
 634     }
 635   }
 636
 637 return US"";
 638 }
 639
 640
 641
 642
 643 /*************************************************
 644 *       Deal with an assignment to a macro       *
 645 *************************************************/
 646
 647 /* We have a new definition; append to the list.
 648
 649 Args:
 650  name   Name of the macro; will be copied
 651  val    Expansion result for the macro; will be copied
 652 */
 653
 654 macro_item *
 655 macro_create(const uschar * name, const uschar * val, BOOL command_line)
 656 {
 657 macro_item * m = store_get(sizeof(macro_item), FALSE);
 658
 659 READCONF_DEBUG fprintf(stderr, "%s: '%s' '%s'\n", __FUNCTION__, name, val);
 660 m->next = NULL;
 661 m->command_line = command_line;
 662 m->namelen = Ustrlen(name);
 663 m->replen = Ustrlen(val);
 664 m->name = string_copy(name);
 665 m->replacement = string_copy(val);
 666 if (mlast)
 667   mlast->next = m;
 668 else
 669   macros = m;
 670 mlast = m;
 671 if (!macros_user)
 672   macros_user = m;
 673 return m;
 674 }
 675
 676
 677 /* This function is called when a line that starts with an upper case letter is
 678 encountered. The argument "line" should contain a complete logical line, and
 679 start with the first letter of the macro name. The macro name and the
 680 replacement text are extracted and stored. Redefinition of existing,
 681 non-command line, macros is permitted using '==' instead of '='.
 682
 683 Arguments:
 684   s            points to the start of the logical line
 685
 686 Returns:       FALSE iff fatal error
 687 */
 688
 689 BOOL
 690 macro_read_assignment(uschar *s)
 691 {
 692 uschar name[EXIM_DRIVERNAME_MAX];
 693 int namelen = 0;
 694 BOOL redef = FALSE;
 695 macro_item *m;
 696
 697 while (isalnum(*s) || *s == '_')
 698   {
 699   if (namelen >= sizeof(name) - 1)
 700     {
 701     log_write(0, LOG_PANIC|LOG_CONFIG_IN,
 702       "macro name too long (maximum is " SIZE_T_FMT " characters)", sizeof(name) - 1);
 703     return FALSE;
 704     }
 705   name[namelen++] = *s++;
 706   }
 707 name[namelen] = 0;
 708
 709 Uskip_whitespace(&s);
 710 if (*s++ != '=')
 711   {
 712   log_write(0, LOG_PANIC|LOG_CONFIG_IN, "malformed macro definition");
 713   return FALSE;
 714   }
 715
 716 if (*s == '=')
 717   {
 718   redef = TRUE;
 719   s++;
 720   }
 721 Uskip_whitespace(&s);
 722
 723 /* If an existing macro of the same name was defined on the command line, we
 724 just skip this definition. It's an error to attempt to redefine a macro without
 725 redef set to TRUE, or to redefine a macro when it hasn't been defined earlier.
 726 It is also an error to define a macro whose name begins with the name of a
 727 previously defined macro.  This is the requirement that make using a tree
 728 for macros hard; we must check all macros for the substring.  Perhaps a
 729 sorted list, and a bsearch, would work?
 730 Note: it is documented that the other way round works. */
 731
 732 for (m = macros; m; m = m->next)
 733   {
 734   if (Ustrcmp(m->name, name) == 0)
 735     {
 736     if (!m->command_line && !redef)
 737       {
 738       log_write(0, LOG_CONFIG|LOG_PANIC, "macro \"%s\" is already "
 739        "defined (use \"==\" if you want to redefine it)", name);
 740       return FALSE;
 741       }
 742     break;
 743     }
 744
 745   if (m->namelen < namelen && Ustrstr(name, m->name) != NULL)
 746     {
 747     log_write(0, LOG_CONFIG|LOG_PANIC, "\"%s\" cannot be defined as "
 748       "a macro because previously defined macro \"%s\" is a substring",
 749       name, m->name);
 750     return FALSE;
 751     }
 752
 753   /* We cannot have this test, because it is documented that a substring
 754   macro is permitted (there is even an example).
 755   *
 756   * if (m->namelen > namelen && Ustrstr(m->name, name) != NULL)
 757   *   log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "\"%s\" cannot be defined as "
 758   *     "a macro because it is a substring of previously defined macro \"%s\"",
 759   *     name, m->name);
 760   */
 761   }
 762
 763 /* Check for an overriding command-line definition. */
 764
 765 if (m && m->command_line) return TRUE;
 766
 767 /* Redefinition must refer to an existing macro. */
 768
 769 if (redef)
 770   if (m)
 771     {
 772     m->replen = Ustrlen(s);
 773     m->replacement = string_copy(s);
 774     }
 775   else
 776     {
 777     log_write(0, LOG_CONFIG|LOG_PANIC, "can't redefine an undefined macro "
 778       "\"%s\"", name);
 779     return FALSE;
 780     }
 781
 782 /* We have a new definition. */
 783 else
 784   (void) macro_create(name, s, FALSE);
 785 return TRUE;
 786 }
 787
 788
 789
 790
 791
 792 /* Process line for macros. The line is in big_buffer starting at offset len.
 793 Expand big_buffer if needed.  Handle definitions of new macros, and
 794 macro expansions, rewriting the line in the buffer.
 795
 796 Arguments:
 797  len            Offset in buffer of start of line
 798  newlen         Pointer to offset of end of line, updated on return
 799  macro_found    Pointer to return that a macro was expanded
 800
 801 Return: pointer to first nonblank char in line
 802 */
 803
 804 uschar *
 805 macros_expand(int len, int * newlen, BOOL * macro_found)
 806 {
 807 uschar * ss = big_buffer + len;
 808 uschar * s;
 809
 810 /* Find the true start of the physical line - leading spaces are always
 811 ignored. */
 812
 813 Uskip_whitespace(&ss);
 814
 815 /* Process the physical line for macros. If this is the start of the logical
 816 line, skip over initial text at the start of the line if it starts with an
 817 upper case character followed by a sequence of name characters and an equals
 818 sign, because that is the definition of a new macro, and we don't do
 819 replacement therein. */
 820
 821 s = ss;
 822 if (len == 0 && isupper(*s))
 823   {
 824   while (isalnum(*s) || *s == '_') s++;
 825   if (Uskip_whitespace(&s) != '=') s = ss;          /* Not a macro definition */
 826   }
 827
 828 /* Skip leading chars which cannot start a macro name, to avoid multiple
 829 pointless rescans in Ustrstr calls. */
 830
 831 while (*s && !isupper(*s) && !(*s == '_' && isupper(s[1]))) s++;
 832
 833 /* For each defined macro, scan the line (from after XXX= if present),
 834 replacing all occurrences of the macro. */
 835
 836 *macro_found = FALSE;
 837 if (*s) for (macro_item * m = *s == '_' ? macros : macros_user; m; m = m->next)
 838   {
 839   uschar * p, *pp;
 840   uschar * t;
 841
 842   while (*s && !isupper(*s) && !(*s == '_' && isupper(s[1]))) s++;
 843   if (!*s) break;
 844
 845   t = s;
 846   while ((p = Ustrstr(t, m->name)) != NULL)
 847     {
 848     int moveby;
 849
 850     READCONF_DEBUG fprintf(stderr, "%s: matched '%s' in '%.*s'\n", __FUNCTION__,
 851       m->name, (int) Ustrlen(ss)-1, ss);
 852     /* Expand the buffer if necessary */
 853
 854     while (*newlen - m->namelen + m->replen + 1 > big_buffer_size)
 855       {
 856       int newsize = big_buffer_size + BIG_BUFFER_SIZE;
 857       uschar *newbuffer = store_malloc(newsize);
 858       memcpy(newbuffer, big_buffer, *newlen + 1);
 859       p = newbuffer  + (p - big_buffer);
 860       s = newbuffer  + (s - big_buffer);
 861       ss = newbuffer + (ss - big_buffer);
 862       t = newbuffer  + (t - big_buffer);
 863       big_buffer_size = newsize;
 864       store_free(big_buffer);
 865       big_buffer = newbuffer;
 866       }
 867
 868     /* Shuffle the remaining characters up or down in the buffer before
 869     copying in the replacement text. Don't rescan the replacement for this
 870     same macro. */
 871
 872     pp = p + m->namelen;
 873     if ((moveby = m->replen - m->namelen) != 0)
 874       {
 875       memmove(p + m->replen, pp, (big_buffer + *newlen) - pp + 1);
 876       *newlen += moveby;
 877       }
 878     Ustrncpy(p, m->replacement, m->replen);
 879     t = p + m->replen;
 880     while (*t && !isupper(*t) && !(*t == '_' && isupper(t[1]))) t++;
 881     *macro_found = TRUE;
 882     }
 883   }
 884
 885 /* An empty macro replacement at the start of a line could mean that ss no
 886 longer points to the first non-blank character. */
 887
 888 Uskip_whitespace(&ss);
 889 return ss;
 890 }
 891
 892 /*************************************************
 893 *            Read configuration line             *
 894 *************************************************/
 895
 896 /* A logical line of text is read from the configuration file into the big
 897 buffer, taking account of macros, .includes, and continuations. The size of
 898 big_buffer is increased if necessary. The count of configuration lines is
 899 maintained. Physical input lines starting with # (ignoring leading white space,
 900 and after macro replacement) and empty logical lines are always ignored.
 901 Leading and trailing spaces are removed.
 902
 903 If we hit a line of the form "begin xxxx", the xxxx is placed in the
 904 next_section vector, and the function returns NULL, indicating the end of a
 905 configuration section. On end-of-file, NULL is returned with next_section
 906 empty.
 907
 908 Arguments:      none
 909
 910 Returns:        a pointer to the first non-blank in the line,
 911                 or NULL if eof or end of section is reached
 912 */
 913
 914 static uschar *
 915 get_config_line(void)
 916 {
 917 int startoffset = 0;         /* To first non-blank char in logical line */
 918 int len = 0;                 /* Of logical line so far */
 919 int newlen;
 920 uschar *s, *ss;
 921 BOOL macro_found;
 922
 923 /* Loop for handling continuation lines, skipping comments, and dealing with
 924 .include files. */
 925
 926 for (;;)
 927   {
 928   if (Ufgets(big_buffer+len, big_buffer_size-len, config_file) == NULL)
 929     {
 930     if (config_file_stack != NULL)    /* EOF inside .include */
 931       {
 932       (void)fclose(config_file);
 933       config_file = config_file_stack->file;
 934       config_filename = config_file_stack->filename;
 935       config_directory = config_file_stack->directory;
 936       config_lineno = config_file_stack->lineno;
 937       config_file_stack = config_file_stack->next;
 938       if (config_lines)
 939         save_config_position(config_filename, config_lineno);
 940       continue;
 941       }
 942
 943     /* EOF at top level */
 944
 945     if (cstate_stack_ptr >= 0)
 946       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
 947         "Unexpected end of configuration file: .endif missing");
 948
 949     if (len != 0) break;        /* EOF after continuation */
 950     next_section[0] = 0;        /* EOF at start of logical line */
 951     return NULL;
 952     }
 953
 954   config_lineno++;
 955   newlen = len + Ustrlen(big_buffer + len);
 956
 957   if (config_lines && config_lineno == 1)
 958     save_config_position(config_filename, config_lineno);
 959
 960   /* Handle pathologically long physical lines - yes, it did happen - by
 961   extending big_buffer at this point. The code also copes with very long
 962   logical lines. */
 963
 964   while (newlen == big_buffer_size - 1 && big_buffer[newlen - 1] != '\n')
 965     {
 966     uschar *newbuffer;
 967     big_buffer_size += BIG_BUFFER_SIZE;
 968     newbuffer = store_malloc(big_buffer_size);
 969
 970     /* This use of strcpy is OK because we know that the string in the old
 971     buffer is shorter than the new buffer. */
 972
 973     Ustrcpy(newbuffer, big_buffer);
 974     store_free(big_buffer);
 975     big_buffer = newbuffer;
 976     if (Ufgets(big_buffer+newlen, big_buffer_size-newlen, config_file) == NULL)
 977       break;
 978     newlen += Ustrlen(big_buffer + newlen);
 979     }
 980
 981   ss = macros_expand(len, &newlen, &macro_found);
 982
 983   /* Check for comment lines - these are physical lines. */
 984
 985   if (*ss == '#') continue;
 986
 987   /* Handle conditionals, which are also applied to physical lines. Conditions
 988   are of the form ".ifdef ANYTEXT" and are treated as true if any macro
 989   expansion occurred on the rest of the line. A preliminary test for the leading
 990   '.' saves effort on most lines. */
 991
 992   if (*ss == '.')
 993     {
 994     int i;
 995
 996     /* Search the list of conditional directives */
 997
 998     for (i = 0; i < cond_list_size; i++)
 999       {
1000       int n;
1001       cond_item *c = cond_list+i;
1002       if (Ustrncmp(ss+1, c->name, c->namelen) != 0) continue;
1003
1004       /* The following character must be white space or end of string */
1005
1006       n = ss[1 + c->namelen];
1007       if (n != ' ' && n != 't' && n != '\n' && n != 0) break;
1008
1009       /* .ifdef and .ifndef push the current state onto the stack, then set
1010       a new one from the table. Stack overflow is an error */
1011
1012       if (c->pushpop > 0)
1013         {
1014         if (cstate_stack_ptr >= CSTATE_STACK_SIZE - 1)
1015           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1016             ".%s nested too deeply", c->name);
1017         cstate_stack[++cstate_stack_ptr] = cstate;
1018         cstate = next_cstate[cstate][macro_found? c->action1 : c->action2];
1019         }
1020
1021       /* For any of the others, stack underflow is an error. The next state
1022       comes either from the stack (.endif) or from the table. */
1023
1024       else
1025         {
1026         if (cstate_stack_ptr < 0)
1027           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1028             ".%s without matching .ifdef", c->name);
1029         cstate = (c->pushpop < 0)? cstate_stack[cstate_stack_ptr--] :
1030           next_cstate[cstate][macro_found? c->action1 : c->action2];
1031         }
1032
1033       /* Having dealt with a directive, break the loop */
1034
1035       break;
1036       }
1037
1038     /* If we have handled a conditional directive, continue with the next
1039     physical line. Otherwise, fall through. */
1040
1041     if (i < cond_list_size) continue;
1042     }
1043
1044   /* If the conditional state is not 0 (actively using these lines), ignore
1045   this input line. */
1046
1047   if (cstate != 0) continue;  /* Conditional skip */
1048
1049   /* Handle .include lines - these are also physical lines. */
1050
1051   if (Ustrncmp(ss, ".include", 8) == 0 &&
1052        (isspace(ss[8]) ||
1053          (Ustrncmp(ss+8, "_if_exists", 10) == 0 && isspace(ss[18]))))
1054     {
1055     uschar *t;
1056     int include_if_exists = isspace(ss[8])? 0 : 10;
1057     config_file_item *save;
1058     struct stat statbuf;
1059
1060     ss += 9 + include_if_exists;
1061     Uskip_whitespace(&ss);
1062     t = ss + Ustrlen(ss);
1063     while (t > ss && isspace(t[-1])) t--;
1064     if (*ss == '\"' && t[-1] == '\"')
1065       {
1066       ss++;
1067       t--;
1068       }
1069     *t = 0;
1070
1071     /* We allow relative file names. For security reasons currently
1072     relative names not allowed with .include_if_exists. For .include_if_exists
1073     we need to check the permissions/ownership of the containing folder */
1074     if (*ss != '/')
1075       if (include_if_exists) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, ".include specifies a non-"
1076           "absolute path \"%s\"", ss);
1077       else
1078         {
1079         gstring * g = string_append(NULL, 3, config_directory, "/", ss);
1080         ss = string_from_gstring(g);
1081         }
1082
1083     if (include_if_exists != 0 && (Ustat(ss, &statbuf) != 0)) continue;
1084
1085     if (config_lines)
1086       save_config_position(config_filename, config_lineno);
1087     save = store_get(sizeof(config_file_item), FALSE);
1088     save->next = config_file_stack;
1089     config_file_stack = save;
1090     save->file = config_file;
1091     save->filename = config_filename;
1092     save->directory = config_directory;
1093     save->lineno = config_lineno;
1094
1095     if (!(config_file = Ufopen(ss, "rb")))
1096       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to open included "
1097         "configuration file %s", ss);
1098
1099     config_filename = string_copy(ss);
1100     config_directory = string_copyn(ss, CUstrrchr(ss, '/') - ss);
1101     config_lineno = 0;
1102     continue;
1103     }
1104
1105   /* If this is the start of the logical line, remember where the non-blank
1106   data starts. Otherwise shuffle down continuation lines to remove leading
1107   white space. */
1108
1109   if (len == 0)
1110     startoffset = ss - big_buffer;
1111   else
1112     {
1113     s = big_buffer + len;
1114     if (ss > s)
1115       {
1116       memmove(s, ss, (newlen - len) -  (ss - s) + 1);
1117       newlen -= ss - s;
1118       }
1119     }
1120
1121   /* Accept the new addition to the line. Remove trailing white space. */
1122
1123   len = newlen;
1124   while (len > 0 && isspace(big_buffer[len-1])) len--;
1125   big_buffer[len] = 0;
1126
1127   /* We are done if the line does not end in backslash and contains some data.
1128   Empty logical lines are ignored. For continuations, remove the backslash and
1129   go round the loop to read the continuation line. */
1130
1131   if (len > 0)
1132     {
1133     if (big_buffer[len-1] != '\\') break;   /* End of logical line */
1134     big_buffer[--len] = 0;                  /* Remove backslash */
1135     }
1136   }     /* Loop for reading multiple physical lines */
1137
1138 /* We now have a logical line. Test for the end of a configuration section (or,
1139 more accurately, for the start of the next section). Place the name of the next
1140 section in next_section, and return NULL. If the name given is longer than
1141 next_section, truncate it. It will be unrecognized later, because all the known
1142 section names do fit. Leave space for pluralizing. */
1143
1144 s = big_buffer + startoffset;            /* First non-space character */
1145
1146 if (config_lines)
1147   save_config_line(s);
1148
1149 if (strncmpic(s, US"begin ", 6) == 0)
1150   {
1151   s += 6;
1152   Uskip_whitespace(&s);
1153   if (big_buffer + len - s > sizeof(next_section) - 2)
1154     s[sizeof(next_section) - 2] = 0;
1155   Ustrcpy(next_section, s);
1156   return NULL;
1157   }
1158
1159 /* Return the first non-blank character. */
1160
1161 return s;
1162 }
1163
1164
1165
1166 /*************************************************
1167 *             Read a name                        *
1168 *************************************************/
1169
1170 /* The yield is the pointer to the next uschar. Names longer than the
1171 output space are silently truncated. This function is also used from acl.c when
1172 parsing ACLs.
1173
1174 Arguments:
1175   name      where to put the name
1176   len       length of name
1177   s         input pointer
1178
1179 Returns:    new input pointer
1180 */
1181
1182 uschar *
1183 readconf_readname(uschar *name, int len, uschar *s)
1184 {
1185 int p = 0;
1186 BOOL broken = FALSE;
1187
1188 if (isalpha(Uskip_whitespace(&s)))
1189   while (isalnum(*s) || *s == '_')
1190     {
1191     if (p < len-1) name[p++] = *s;
1192     else {
1193       broken = TRUE;
1194       break;
1195     }
1196     s++;
1197     }
1198
1199 name[p] = 0;
1200 if (broken) {
1201   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1202             "exim item name too long (>%d), unable to use \"%s\" (truncated)",
1203             len, name);
1204 }
1205 Uskip_whitespace(&s);
1206 return s;
1207 }
1208
1209
1210
1211
1212 /*************************************************
1213 *          Read a time value                     *
1214 *************************************************/
1215
1216 /* This function is also called from outside, to read argument
1217 time values. The format of a time value is:
1218
1219   [<n>w][<n>d][<n>h][<n>m][<n>s]
1220
1221 as long as at least one is present. If a format error is encountered,
1222 return a negative value. The value must be terminated by the given
1223 terminator.
1224
1225 Arguments:
1226   s             input pointer
1227   terminator    required terminating character
1228   return_msec   if TRUE, allow fractional seconds and return milliseconds
1229
1230 Returns:        the time value, or -1 on syntax error
1231                 value is seconds if return_msec is FALSE
1232                 value is milliseconds if return_msec is TRUE
1233 */
1234
1235 int
1236 readconf_readtime(const uschar *s, int terminator, BOOL return_msec)
1237 {
1238 int yield = 0;
1239 for (;;)
1240   {
1241   int value, count;
1242   double fraction;
1243
1244   if (!isdigit(*s)) return -1;
1245   (void)sscanf(CCS s, "%d%n", &value, &count);
1246   s += count;
1247
1248   switch (*s)
1249     {
1250     case 'w': value *= 7;
1251     case 'd': value *= 24;
1252     case 'h': value *= 60;
1253     case 'm': value *= 60;
1254     case 's': s++;
1255     break;
1256
1257     case '.':
1258     if (!return_msec) return -1;
1259     (void)sscanf(CCS s, "%lf%n", &fraction, &count);
1260     s += count;
1261     if (*s++ != 's') return -1;
1262     yield += (int)(fraction * 1000.0);
1263     break;
1264
1265     default: return -1;
1266     }
1267
1268   if (return_msec) value *= 1000;
1269   yield += value;
1270   if (*s == terminator) return yield;
1271   }
1272 /* Control never reaches here. */
1273 }
1274
1275
1276
1277 /*************************************************
1278 *          Read a fixed point value              *
1279 *************************************************/
1280
1281 /* The value is returned *1000
1282
1283 Arguments:
1284   s           input pointer
1285   terminator  required terminator
1286
1287 Returns:      the value, or -1 on error
1288 */
1289
1290 static int
1291 readconf_readfixed(const uschar *s, int terminator)
1292 {
1293 int yield = 0;
1294 int value, count;
1295 if (!isdigit(*s)) return -1;
1296 (void)sscanf(CS  s, "%d%n", &value, &count);
1297 s += count;
1298 yield = value * 1000;
1299 if (*s == '.')
1300   {
1301   int m = 100;
1302   while (isdigit((*(++s))))
1303     {
1304     yield += (*s - '0') * m;
1305     m /= 10;
1306     }
1307   }
1308
1309 return (*s == terminator)? yield : (-1);
1310 }
1311
1312
1313
1314 /*************************************************
1315 *            Find option in list                 *
1316 *************************************************/
1317
1318 /* The lists are always in order, so binary chop can be used.
1319
1320 Arguments:
1321   name      the option name to search for
1322   ol        the first entry in the option list
1323   last      one more than the offset of the last entry in the option list
1324
1325 Returns:    pointer to an option entry, or NULL if not found
1326 */
1327
1328 static optionlist *
1329 find_option(const uschar *name, optionlist *ol, int last)
1330 {
1331 int first = 0;
1332 while (last > first)
1333   {
1334   int middle = (first + last)/2;
1335   int c = Ustrcmp(name, ol[middle].name);
1336
1337   if (c == 0) return ol + middle;
1338   else if (c > 0) first = middle + 1;
1339   else last = middle;
1340   }
1341 return NULL;
1342 }
1343
1344
1345
1346 /*************************************************
1347 *      Find a set flag in option list            *
1348 *************************************************/
1349
1350 /* Because some versions of Unix make no restrictions on the values of uids and
1351 gids (even negative ones), we cannot represent "unset" by a special value.
1352 There is therefore a separate boolean variable for each one indicating whether
1353 a value is set or not. This function returns a pointer to the boolean, given
1354 the original option name. It is a major disaster if the flag cannot be found.
1355
1356 Arguments:
1357   name          the name of the uid or gid option
1358   oltop         points to the start of the relevant option list
1359   last          one more than the offset of the last item in the option list
1360   data_block    NULL when reading main options => data values in the option
1361                   list are absolute addresses; otherwise they are byte offsets
1362                   in data_block (used for driver options)
1363
1364 Returns:        a pointer to the boolean flag.
1365 */
1366
1367 static BOOL *
1368 get_set_flag(const uschar *name, optionlist *oltop, int last, void *data_block)
1369 {
1370 optionlist *ol;
1371 uschar name2[EXIM_DRIVERNAME_MAX];
1372 sprintf(CS name2, "*set_%.50s", name);
1373 if (!(ol = find_option(name2, oltop, last)))
1374   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1375     "Exim internal error: missing set flag for %s", name);
1376 return data_block
1377   ? (BOOL *)(US data_block + ol->v.offset) : (BOOL *)ol->v.value;
1378 }
1379
1380
1381
1382
1383 /*************************************************
1384 *    Output extra characters message and die     *
1385 *************************************************/
1386
1387 /* Called when an option line has junk on the end. Sometimes this is because
1388 the sysadmin thinks comments are permitted.
1389
1390 Arguments:
1391   s          points to the extra characters
1392   t1..t3     strings to insert in the log message
1393
1394 Returns:     doesn't return; dies
1395 */
1396
1397 static void
1398 extra_chars_error(const uschar *s, const uschar *t1, const uschar *t2, const uschar *t3)
1399 {
1400 uschar *comment = US"";
1401 if (*s == '#') comment = US" (# is comment only at line start)";
1402 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1403   "extra characters follow %s%s%s%s", t1, t2, t3, comment);
1404 }
1405
1406
1407
1408 /*************************************************
1409 *              Read rewrite information          *
1410 *************************************************/
1411
1412 /* Each line of rewrite information contains:
1413
1414 .  A complete address in the form user@domain, possibly with
1415    leading * for each part; or alternatively, a regex.
1416
1417 .  A replacement string (which will be expanded).
1418
1419 .  An optional sequence of one-letter flags, indicating which
1420    headers etc. to apply this rule to.
1421
1422 All this is decoded and placed into a control block. The OR of the flags is
1423 maintained in a common word.
1424
1425 Arguments:
1426   p           points to the string that makes up the rule
1427   existflags  points to the overall flag word
1428   isglobal    TRUE if reading global rewrite rules
1429
1430 Returns:      the control block for the parsed rule.
1431 */
1432
1433 static rewrite_rule *
1434 readconf_one_rewrite(const uschar *p, int *existflags, BOOL isglobal)
1435 {
1436 rewrite_rule *next = store_get(sizeof(rewrite_rule), FALSE);
1437
1438 next->next = NULL;
1439 next->key = string_dequote(&p);
1440
1441 Uskip_whitespace(&p);
1442 if (!*p)
1443   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1444     "missing rewrite replacement string");
1445
1446 next->flags = 0;
1447 next->replacement = string_dequote(&p);
1448
1449 while (*p) switch (*p++)
1450   {
1451   case ' ': case '\t': break;
1452
1453   case 'q': next->flags |= rewrite_quit; break;
1454   case 'w': next->flags |= rewrite_whole; break;
1455
1456   case 'h': next->flags |= rewrite_all_headers; break;
1457   case 's': next->flags |= rewrite_sender; break;
1458   case 'f': next->flags |= rewrite_from; break;
1459   case 't': next->flags |= rewrite_to;   break;
1460   case 'c': next->flags |= rewrite_cc;   break;
1461   case 'b': next->flags |= rewrite_bcc;  break;
1462   case 'r': next->flags |= rewrite_replyto; break;
1463
1464   case 'E': next->flags |= rewrite_all_envelope; break;
1465   case 'F': next->flags |= rewrite_envfrom; break;
1466   case 'T': next->flags |= rewrite_envto; break;
1467
1468   case 'Q': next->flags |= rewrite_qualify; break;
1469   case 'R': next->flags |= rewrite_repeat; break;
1470
1471   case 'S':
1472   next->flags |= rewrite_smtp;
1473   if (next->key[0] != '^' && Ustrncmp(next->key, "\\N^", 3) != 0)
1474     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1475       "rewrite rule has the S flag but is not a regular expression");
1476   break;
1477
1478   default:
1479   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1480     "unknown rewrite flag character '%c' "
1481     "(could be missing quotes round replacement item)", p[-1]);
1482   break;
1483   }
1484
1485 /* If no action flags are set, set all the "normal" rewrites. */
1486
1487 if ((next->flags & (rewrite_all | rewrite_smtp)) == 0)
1488   next->flags |= isglobal? rewrite_all : rewrite_all_headers;
1489
1490 /* Remember which exist, for optimization, and return the rule */
1491
1492 *existflags |= next->flags;
1493 return next;
1494 }
1495
1496
1497
1498
1499 /*************************************************
1500 *          Read global rewrite information       *
1501 *************************************************/
1502
1503 /* Each line is a single rewrite rule; it is parsed into a control block
1504 by readconf_one_rewrite(), and its flags are ORed into the global flag
1505 word rewrite_existflags. */
1506
1507 void
1508 readconf_rewrites(void)
1509 {
1510 rewrite_rule **chain = &global_rewrite_rules;
1511 uschar *p;
1512
1513 while ((p = get_config_line()) != NULL)
1514   {
1515   rewrite_rule *next = readconf_one_rewrite(p, &rewrite_existflags, TRUE);
1516   *chain = next;
1517   chain = &(next->next);
1518   }
1519 }
1520
1521
1522
1523 /*************************************************
1524 *               Read a string                    *
1525 *************************************************/
1526
1527 /* Strings are read into the normal store pool. As long we aren't too
1528 near the end of the current block, the string will just use what is necessary
1529 on the top of the stacking pool, because string_cat() uses the extension
1530 mechanism.
1531
1532 Argument:
1533   s         the rest of the input line
1534   name      the option name (for errors)
1535
1536 Returns:    pointer to the string
1537 */
1538
1539 static uschar *
1540 read_string(const uschar *s, const uschar *name)
1541 {
1542 uschar *yield;
1543 const uschar *ss;
1544
1545 if (*s != '\"') return string_copy(s);
1546
1547 ss = s;
1548 yield = string_dequote(&s);
1549
1550 if (s == ss+1 || s[-1] != '\"')
1551   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1552     "missing quote at end of string value for %s", name);
1553
1554 if (*s != 0) extra_chars_error(s, US"string value for ", name, US"");
1555
1556 return yield;
1557 }
1558
1559
1560 /*************************************************
1561 *            Custom-handler options              *
1562 *************************************************/
1563 static void
1564 fn_smtp_receive_timeout(const uschar * name, const uschar * str, unsigned flags)
1565 {
1566 if (flags & opt_fn_print)
1567   {
1568   if (flags & opt_fn_print_label) printf("%s = ", name);
1569   printf("%s\n", smtp_receive_timeout_s
1570     ? string_printing2(smtp_receive_timeout_s, SP_TAB)
1571     : readconf_printtime(smtp_receive_timeout));
1572   }
1573 else if (*str == '$')
1574   smtp_receive_timeout_s = string_copy(str);
1575 else
1576   {
1577   /* "smtp_receive_timeout",     opt_time,        &smtp_receive_timeout */
1578   smtp_receive_timeout = readconf_readtime(str, 0, FALSE);
1579   if (smtp_receive_timeout < 0)
1580     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
1581       name);
1582   }
1583 }
1584
1585 /*************************************************
1586 *            Handle option line                  *
1587 *************************************************/
1588
1589 /* This function is called from several places to process a line containing the
1590 setting of an option. The first argument is the line to be decoded; it has been
1591 checked not to be empty and not to start with '#'. Trailing newlines and white
1592 space have been removed. The second argument is a pointer to the list of
1593 variable names that are to be recognized, together with their types and
1594 locations, and the third argument gives the number of entries in the list.
1595
1596 The fourth argument is a pointer to a data block. If it is NULL, then the data
1597 values in the options list are absolute addresses. Otherwise, they are byte
1598 offsets in the data block.
1599
1600 String option data may continue onto several lines; this function reads further
1601 data from config_file if necessary.
1602
1603 The yield of this function is normally zero. If a string continues onto
1604 multiple lines, then the data value is permitted to be followed by a comma
1605 or a semicolon (for use in drivers) and the yield is that character.
1606
1607 Arguments:
1608   buffer        contains the configuration line to be handled
1609   oltop         points to the start of the relevant option list
1610   last          one more than the offset of the last item in the option list
1611   data_block    NULL when reading main options => data values in the option
1612                   list are absolute addresses; otherwise they are byte offsets
1613                   in data_block when they have opt_public set; otherwise
1614                   they are byte offsets in data_block->options_block.
1615   unknown_txt   format string to use in panic message for unknown option;
1616                   must contain %s for option name
1617                 if given as NULL, don't panic on unknown option
1618
1619 Returns:        TRUE if an option was read successfully,
1620                 FALSE false for an unknown option if unknown_txt == NULL,
1621                   otherwise panic and die on an unknown option
1622 */
1623
1624 static BOOL
1625 readconf_handle_option(uschar *buffer, optionlist *oltop, int last,
1626   void *data_block, uschar *unknown_txt)
1627 {
1628 int ptr = 0;
1629 int offset = 0;
1630 int count, type, value;
1631 int issecure = 0;
1632 uid_t uid;
1633 gid_t gid;
1634 BOOL boolvalue = TRUE;
1635 BOOL freesptr = TRUE;
1636 optionlist *ol, *ol2;
1637 struct passwd *pw;
1638 rmark reset_point;
1639 int intbase = 0;
1640 uschar *inttype = US"";
1641 uschar *sptr;
1642 uschar *s = buffer;
1643 uschar **str_target;
1644 uschar name[EXIM_DRIVERNAME_MAX];
1645 uschar name2[EXIM_DRIVERNAME_MAX];
1646
1647 /* There may be leading spaces; thereafter, we expect an option name starting
1648 with a letter. */
1649
1650 while (isspace(*s)) s++;
1651 if (!isalpha(*s))
1652   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option setting expected: %s", s);
1653
1654 /* Read the name of the option, and skip any subsequent white space. If
1655 it turns out that what we read was "hide", set the flag indicating that
1656 this is a secure option, and loop to read the next word. */
1657
1658 for (int n = 0; n < 2; n++)
1659   {
1660   while (isalnum(*s) || *s == '_')
1661     {
1662     if (ptr < sizeof(name)-1) name[ptr++] = *s;
1663     s++;
1664     }
1665   name[ptr] = 0;
1666   while (isspace(*s)) s++;
1667   if (Ustrcmp(name, "hide") != 0) break;
1668   issecure = opt_secure;
1669   ptr = 0;
1670   }
1671
1672 /* Deal with "no_" or "not_" here for booleans */
1673
1674 if (Ustrncmp(name, "no_", 3) == 0)
1675   {
1676   boolvalue = FALSE;
1677   offset = 3;
1678   }
1679
1680 if (Ustrncmp(name, "not_", 4) == 0)
1681   {
1682   boolvalue = FALSE;
1683   offset = 4;
1684   }
1685
1686 /* Search the list for the given name. A non-existent name, or an option that
1687 is set twice, is a disaster. */
1688
1689 if (!(ol = find_option(name + offset, oltop, last)))
1690   {
1691   if (!unknown_txt) return FALSE;
1692   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, CS unknown_txt, name);
1693   }
1694
1695 if ((ol->type & opt_set)  && !(ol->type & (opt_rep_con | opt_rep_str)))
1696   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1697     "\"%s\" option set for the second time", name);
1698
1699 ol->type |= opt_set | issecure;
1700 type = ol->type & opt_mask;
1701
1702 /* Types with data values must be followed by '='; the "no[t]_" prefix
1703 applies only to boolean values. */
1704
1705 if (type < opt_bool || type > opt_bool_last)
1706   {
1707   if (offset != 0)
1708     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1709       "negation prefix applied to a non-boolean option");
1710   if (!*s)
1711     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1712       "unexpected end of line (data missing) after %s", name);
1713   if (*s != '=')
1714     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing \"=\" after %s", name);
1715   }
1716
1717 /* If a boolean wasn't preceded by "no[t]_" it can be followed by = and
1718 true/false/yes/no, or, in the case of opt_expand_bool, a general string that
1719 ultimately expands to one of those values. */
1720
1721 else if (*s && (offset != 0 || *s != '='))
1722   extra_chars_error(s, US"boolean option ", name, US"");
1723
1724 /* Skip white space after = */
1725
1726 if (*s == '=') while (isspace((*(++s))));
1727
1728 /* If there is a data block and the opt_public flag is not set, change
1729 the data block pointer to the private options block. */
1730
1731 if (data_block && !(ol->type & opt_public))
1732   data_block = (void *)(((driver_instance *)data_block)->options_block);
1733
1734 /* Now get the data according to the type. */
1735
1736 switch (type)
1737   {
1738   /* If a string value is not enclosed in quotes, it consists of
1739   the rest of the current line, verbatim. Otherwise, string escapes
1740   are processed.
1741
1742   A transport is specified as a string, which is then looked up in the
1743   list of transports. A search type is specified as one of a number of
1744   known strings.
1745
1746   A set or rewrite rules for a driver is specified as a string, which is
1747   then parsed into a suitable chain of control blocks.
1748
1749   Uids and gids are specified as strings which are then looked up in the
1750   passwd file. Lists of uids and gids are similarly specified as colon-
1751   separated strings. */
1752
1753   case opt_stringptr:
1754   case opt_uid:
1755   case opt_gid:
1756   case opt_expand_uid:
1757   case opt_expand_gid:
1758   case opt_uidlist:
1759   case opt_gidlist:
1760   case opt_rewrite:
1761
1762   reset_point = store_mark();
1763   sptr = read_string(s, name);
1764
1765   /* Having read a string, we now have several different ways of using it,
1766   depending on the data type, so do another switch. If keeping the actual
1767   string is not required (because it is interpreted), freesptr is set TRUE,
1768   and at the end we reset the pool. */
1769
1770   switch (type)
1771     {
1772     /* If this was a string, set the variable to point to the new string,
1773     and set the flag so its store isn't reclaimed. If it was a list of rewrite
1774     rules, we still keep the string (for printing), and parse the rules into a
1775     control block and flags word. */
1776
1777     case opt_stringptr:
1778     str_target = data_block ? USS (US data_block + ol->v.offset)
1779                             : USS ol->v.value;
1780     if (ol->type & opt_rep_con)
1781       {
1782       uschar * saved_condition;
1783       /* We already have a condition, we're conducting a crude hack to let
1784       multiple condition rules be chained together, despite storing them in
1785       text form. */
1786       *str_target = string_copy_perm( (saved_condition = *str_target)
1787         ? string_sprintf("${if and{{bool_lax{%s}}{bool_lax{%s}}}}",
1788             saved_condition, sptr)
1789         : sptr,
1790         FALSE);
1791       /* TODO(pdp): there is a memory leak here and just below
1792       when we set 3 or more conditions; I still don't
1793       understand the store mechanism enough to know
1794       what's the safe way to free content from an earlier store.
1795       AFAICT, stores stack, so freeing an early stored item also stores
1796       all data alloc'd after it.  If we knew conditions were adjacent,
1797       we could survive that, but we don't.  So I *think* we need to take
1798       another bit from opt_type to indicate "malloced"; this seems like
1799       quite a hack, especially for this one case.  It also means that
1800       we can't ever reclaim the store from the *first* condition.
1801
1802       Because we only do this once, near process start-up, I'm prepared to
1803       let this slide for the time being, even though it rankles.  */
1804       }
1805     else if (ol->type & opt_rep_str)
1806       {
1807       uschar sep_o =
1808         Ustrncmp(name, "headers_add", 11) == 0  ? '\n'
1809         : Ustrncmp(name, "set", 3) == 0         ? ';'
1810         : ':';
1811       int    sep_i = -(int)sep_o;
1812       const uschar * list = sptr;
1813       uschar * s;
1814       gstring * list_o = NULL;
1815
1816       if (*str_target)
1817         {
1818         list_o = string_get(Ustrlen(*str_target) + Ustrlen(sptr));
1819         list_o = string_cat(list_o, *str_target);
1820         }
1821
1822       while ((s = string_nextinlist(&list, &sep_i, NULL, 0)))
1823         list_o = string_append_listele(list_o, sep_o, s);
1824
1825       if (list_o)
1826         *str_target = string_copy_perm(string_from_gstring(list_o), FALSE);
1827       }
1828     else
1829       {
1830       *str_target = sptr;
1831       freesptr = FALSE;
1832       }
1833     break;
1834
1835     case opt_rewrite:
1836     if (data_block)
1837       *USS (US data_block + ol->v.offset) = sptr;
1838     else
1839       *USS ol->v.value = sptr;
1840     freesptr = FALSE;
1841     if (type == opt_rewrite)
1842       {
1843       int sep = 0;
1844       int *flagptr;
1845       uschar *p = sptr;
1846       rewrite_rule **chain;
1847       optionlist *ol3;
1848
1849       sprintf(CS name2, "*%.50s_rules", name);
1850       ol2 = find_option(name2, oltop, last);
1851       sprintf(CS name2, "*%.50s_flags", name);
1852       ol3 = find_option(name2, oltop, last);
1853
1854       if (!ol2 || !ol3)
1855         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1856           "rewrite rules not available for driver");
1857
1858       if (data_block)
1859         {
1860         chain = (rewrite_rule **)(US data_block + ol2->v.offset);
1861         flagptr = (int *)(US data_block + ol3->v.offset);
1862         }
1863       else
1864         {
1865         chain = (rewrite_rule **)ol2->v.value;
1866         flagptr = (int *)ol3->v.value;
1867         }
1868
1869       /* This will trap if sptr is tainted. Not sure if that can happen */
1870       while ((p = string_nextinlist(CUSS &sptr, &sep, big_buffer, BIG_BUFFER_SIZE)))
1871         {
1872         rewrite_rule *next = readconf_one_rewrite(p, flagptr, FALSE);
1873         *chain = next;
1874         chain = &(next->next);
1875         }
1876
1877       if ((*flagptr & (rewrite_all_envelope | rewrite_smtp)) != 0)
1878         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "rewrite rule specifies a "
1879           "non-header rewrite - not allowed at transport time -");
1880       }
1881     break;
1882
1883     /* If it was an expanded uid, see if there is any expansion to be
1884     done by checking for the presence of a $ character. If there is, save it
1885     in the corresponding *expand_user option field. Otherwise, fall through
1886     to treat it as a fixed uid. Ensure mutual exclusivity of the two kinds
1887     of data. */
1888
1889     case opt_expand_uid:
1890     sprintf(CS name2, "*expand_%.50s", name);
1891     if ((ol2 = find_option(name2, oltop, last)))
1892       {
1893       uschar *ss = (Ustrchr(sptr, '$') != NULL) ? sptr : NULL;
1894
1895       if (data_block)
1896         *(USS(US data_block + ol2->v.offset)) = ss;
1897       else
1898         *(USS ol2->v.value) = ss;
1899
1900       if (ss)
1901         {
1902         *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1903         freesptr = FALSE;
1904         break;
1905         }
1906       }
1907
1908     /* Look up a fixed uid, and also make use of the corresponding gid
1909     if a passwd entry is returned and the gid has not been set. */
1910
1911     case opt_uid:
1912     if (!route_finduser(sptr, &pw, &uid))
1913       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found", sptr);
1914     if (data_block)
1915       *(uid_t *)(US data_block + ol->v.offset) = uid;
1916     else
1917       *(uid_t *)ol->v.value = uid;
1918
1919     /* Set the flag indicating a fixed value is set */
1920
1921     *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1922
1923     /* Handle matching gid if we have a passwd entry: done by finding the
1924     same name with terminating "user" changed to "group"; if not found,
1925     ignore. Also ignore if the value is already set. */
1926
1927     if (pw == NULL) break;
1928     Ustrcpy(name+Ustrlen(name)-4, US"group");
1929     ol2 = find_option(name, oltop, last);
1930     if (ol2 && ((ol2->type & opt_mask) == opt_gid ||
1931         (ol2->type & opt_mask) == opt_expand_gid))
1932       {
1933       BOOL *set_flag = get_set_flag(name, oltop, last, data_block);
1934       if (!*set_flag)
1935         {
1936         if (data_block)
1937           *((gid_t *)(US data_block + ol2->v.offset)) = pw->pw_gid;
1938         else
1939           *((gid_t *)ol2->v.value) = pw->pw_gid;
1940         *set_flag = TRUE;
1941         }
1942       }
1943     break;
1944
1945     /* If it was an expanded gid, see if there is any expansion to be
1946     done by checking for the presence of a $ character. If there is, save it
1947     in the corresponding *expand_user option field. Otherwise, fall through
1948     to treat it as a fixed gid. Ensure mutual exclusivity of the two kinds
1949     of data. */
1950
1951     case opt_expand_gid:
1952     sprintf(CS name2, "*expand_%.50s", name);
1953     if ((ol2 = find_option(name2, oltop, last)))
1954       {
1955       uschar *ss = (Ustrchr(sptr, '$') != NULL) ? sptr : NULL;
1956
1957       if (data_block)
1958         *(USS(US data_block + ol2->v.offset)) = ss;
1959       else
1960         *(USS ol2->v.value) = ss;
1961
1962       if (ss)
1963         {
1964         *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1965         freesptr = FALSE;
1966         break;
1967         }
1968       }
1969
1970     /* Handle freestanding gid */
1971
1972     case opt_gid:
1973     if (!route_findgroup(sptr, &gid))
1974       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found", sptr);
1975     if (data_block)
1976       *((gid_t *)(US data_block + ol->v.offset)) = gid;
1977     else
1978       *((gid_t *)ol->v.value) = gid;
1979     *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1980     break;
1981
1982     /* If it was a uid list, look up each individual entry, and build
1983     a vector of uids, with a count in the first element. Put the vector
1984     in malloc store so we can free the string. (We are reading into
1985     permanent store already.) */
1986
1987     case opt_uidlist:
1988       {
1989       int count = 1;
1990       uid_t *list;
1991       int ptr = 0;
1992       const uschar *p;
1993       const uschar *op = expand_string (sptr);
1994
1995       if (op == NULL)
1996         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
1997           name, expand_string_message);
1998
1999       p = op;
2000       if (*p != 0) count++;
2001       while (*p != 0) if (*p++ == ':' && *p != 0) count++;
2002       list = store_malloc(count*sizeof(uid_t));
2003       list[ptr++] = (uid_t)(count - 1);
2004
2005       if (data_block)
2006         *((uid_t **)(US data_block + ol->v.offset)) = list;
2007       else
2008         *((uid_t **)ol->v.value) = list;
2009
2010       p = op;
2011       while (count-- > 1)
2012         {
2013         int sep = 0;
2014         /* If p is tainted we trap.  Not sure that can happen */
2015         (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
2016         if (!route_finduser(big_buffer, NULL, &uid))
2017           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found",
2018             big_buffer);
2019         list[ptr++] = uid;
2020         }
2021       }
2022     break;
2023
2024     /* If it was a gid list, look up each individual entry, and build
2025     a vector of gids, with a count in the first element. Put the vector
2026     in malloc store so we can free the string. (We are reading into permanent
2027     store already.) */
2028
2029     case opt_gidlist:
2030       {
2031       int count = 1;
2032       gid_t *list;
2033       int ptr = 0;
2034       const uschar *p;
2035       const uschar *op = expand_string (sptr);
2036
2037       if (!op)
2038         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
2039           name, expand_string_message);
2040
2041       p = op;
2042       if (*p != 0) count++;
2043       while (*p != 0) if (*p++ == ':' && *p != 0) count++;
2044       list = store_malloc(count*sizeof(gid_t));
2045       list[ptr++] = (gid_t)(count - 1);
2046
2047       if (data_block)
2048         *((gid_t **)(US data_block + ol->v.offset)) = list;
2049       else
2050         *((gid_t **)ol->v.value) = list;
2051
2052       p = op;
2053       while (count-- > 1)
2054         {
2055         int sep = 0;
2056         /* If p is tainted we trap.  Not sure that can happen */
2057         (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
2058         if (!route_findgroup(big_buffer, &gid))
2059           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found",
2060             big_buffer);
2061         list[ptr++] = gid;
2062         }
2063       }
2064     break;
2065     }
2066
2067   /* Release store if the value of the string doesn't need to be kept. */
2068
2069   if (freesptr) reset_point = store_reset(reset_point);
2070   break;
2071
2072   /* Expanded boolean: if no characters follow, or if there are no dollar
2073   characters, this is a fixed-valued boolean, and we fall through. Otherwise,
2074   save the string for later expansion in the alternate place. */
2075
2076   case opt_expand_bool:
2077   if (*s && Ustrchr(s, '$') != 0)
2078     {
2079     sprintf(CS name2, "*expand_%.50s", name);
2080     if ((ol2 = find_option(name2, oltop, last)))
2081       {
2082       reset_point = store_mark();
2083       sptr = read_string(s, name);
2084       if (data_block)
2085         *(USS(US data_block + ol2->v.offset)) = sptr;
2086       else
2087         *(USS ol2->v.value) = sptr;
2088       freesptr = FALSE;
2089       break;
2090       }
2091     }
2092   /* Fall through */
2093
2094   /* Boolean: if no characters follow, the value is boolvalue. Otherwise
2095   look for yes/not/true/false. Some booleans are stored in a single bit in
2096   a single int. There's a special fudge for verify settings; without a suffix
2097   they set both xx_sender and xx_recipient. The table points to the sender
2098   value; search subsequently for the recipient. There's another special case:
2099   opt_bool_set also notes when a boolean has been set. */
2100
2101   case opt_bool:
2102   case opt_bit:
2103   case opt_bool_verify:
2104   case opt_bool_set:
2105   if (*s != 0)
2106     {
2107     s = readconf_readname(name2, EXIM_DRIVERNAME_MAX, s);
2108     if (strcmpic(name2, US"true") == 0 || strcmpic(name2, US"yes") == 0)
2109       boolvalue = TRUE;
2110     else if (strcmpic(name2, US"false") == 0 || strcmpic(name2, US"no") == 0)
2111       boolvalue = FALSE;
2112     else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2113       "\"%s\" is not a valid value for the \"%s\" option", name2, name);
2114     if (*s != 0) extra_chars_error(s, string_sprintf("\"%s\" ", name2),
2115       US"for boolean option ", name);
2116     }
2117
2118   /* Handle single-bit type. */
2119
2120   if (type == opt_bit)
2121     {
2122     int bit = 1 << ((ol->type >> 16) & 31);
2123     int * ptr = data_block
2124       ? (int *)(US data_block + ol->v.offset)
2125       : (int *)ol->v.value;
2126     if (boolvalue) *ptr |= bit; else *ptr &= ~bit;
2127     break;
2128     }
2129
2130   /* Handle full BOOL types */
2131
2132   if (data_block)
2133     *((BOOL *)(US data_block + ol->v.offset)) = boolvalue;
2134   else
2135     *((BOOL *)ol->v.value) = boolvalue;
2136
2137   /* Verify fudge */
2138
2139   if (type == opt_bool_verify)
2140     {
2141     sprintf(CS name2, "%.50s_recipient", name + offset);
2142     if ((ol2 = find_option(name2, oltop, last)))
2143       if (data_block)
2144         *((BOOL *)(US data_block + ol2->v.offset)) = boolvalue;
2145       else
2146         *((BOOL *)ol2->v.value) = boolvalue;
2147     }
2148
2149   /* Note that opt_bool_set type is set, if there is somewhere to do so */
2150
2151   else if (type == opt_bool_set)
2152     {
2153     sprintf(CS name2, "*set_%.50s", name + offset);
2154     if ((ol2 = find_option(name2, oltop, last)))
2155       if (data_block)
2156         *((BOOL *)(US data_block + ol2->v.offset)) = TRUE;
2157       else
2158         *((BOOL *)ol2->v.value) = TRUE;
2159     }
2160   break;
2161
2162   /* Octal integer */
2163
2164   case opt_octint:
2165   intbase = 8;
2166   inttype = US"octal ";
2167
2168   /*  Integer: a simple(ish) case; allow octal and hex formats, and
2169   suffixes K, M, G, and T.  The different types affect output, not input. */
2170
2171   case opt_mkint:
2172   case opt_int:
2173     {
2174     uschar *endptr;
2175     long int lvalue;
2176
2177     errno = 0;
2178     lvalue = strtol(CS s, CSS &endptr, intbase);
2179
2180     if (endptr == s)
2181       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
2182         inttype, name);
2183
2184     if (errno != ERANGE && *endptr)
2185       {
2186       uschar * mp = US"TtGgMmKk\0";     /* YyZzEePpTtGgMmKk */
2187
2188       if ((mp = Ustrchr(mp, *endptr)))
2189         {
2190         endptr++;
2191         do
2192           {
2193           if (lvalue > INT_MAX/1024 || lvalue < INT_MIN/1024)
2194             {
2195             errno = ERANGE;
2196             break;
2197             }
2198           lvalue *= 1024;
2199           }
2200         while (*(mp += 2));
2201         }
2202       }
2203
2204     if (errno == ERANGE || lvalue > INT_MAX || lvalue < INT_MIN)
2205       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2206         "absolute value of integer \"%s\" is too large (overflow)", s);
2207
2208     while (isspace(*endptr)) endptr++;
2209     if (*endptr)
2210       extra_chars_error(endptr, inttype, US"integer value for ", name);
2211
2212     value = (int)lvalue;
2213     }
2214
2215   if (data_block)
2216     *(int *)(US data_block + ol->v.offset) = value;
2217   else
2218     *(int *)ol->v.value = value;
2219   break;
2220
2221   /*  Integer held in K: again, allow formats and suffixes as above. */
2222
2223   case opt_Kint:
2224     {
2225     uschar *endptr;
2226     errno = 0;
2227     int_eximarith_t lvalue = strtol(CS s, CSS &endptr, intbase);
2228
2229     if (endptr == s)
2230       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
2231         inttype, name);
2232
2233     if (errno != ERANGE && *endptr)
2234       {
2235       uschar * mp = US"ZzEePpTtGgMmKk\0";       /* YyZzEePpTtGgMmKk */
2236
2237       if ((mp = Ustrchr(mp, *endptr)))
2238         {
2239         endptr++;
2240         while (*(mp += 2))
2241           {
2242           if (lvalue > EXIM_ARITH_MAX/1024 || lvalue < EXIM_ARITH_MIN/1024)
2243             {
2244             errno = ERANGE;
2245             break;
2246             }
2247           lvalue *= 1024;
2248           }
2249         }
2250       else
2251         lvalue = (lvalue + 512)/1024;
2252       }
2253
2254     if (errno == ERANGE) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2255       "absolute value of integer \"%s\" is too large (overflow)", s);
2256
2257     while (isspace(*endptr)) endptr++;
2258     if (*endptr != 0)
2259       extra_chars_error(endptr, inttype, US"integer value for ", name);
2260
2261     if (data_block)
2262       *(int_eximarith_t *)(US data_block + ol->v.offset) = lvalue;
2263     else
2264       *(int_eximarith_t *)ol->v.value = lvalue;
2265     break;
2266     }
2267
2268   /*  Fixed-point number: held to 3 decimal places. */
2269
2270   case opt_fixed:
2271   if (sscanf(CS s, "%d%n", &value, &count) != 1)
2272     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2273       "fixed-point number expected for %s", name);
2274
2275   if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2276     "integer \"%s\" is too large (overflow)", s);
2277
2278   value *= 1000;
2279
2280   if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2281     "integer \"%s\" is too large (overflow)", s);
2282
2283   /* We get a coverity error here for using count, as it derived
2284   from the tainted buffer pointed to by s, as parsed by sscanf().
2285   By the definition of sscanf we must be accessing between start
2286   and end of s (assuming it is nul-terminated...) so ignore the error.  */
2287   /* coverity[tainted_data] */
2288   if (s[count] == '.')
2289     {
2290     int d = 100;
2291     while (isdigit(s[++count]))
2292       {
2293       value += (s[count] - '0') * d;
2294       d /= 10;
2295       }
2296     }
2297
2298   while (isspace(s[count])) count++;
2299
2300   if (s[count] != 0)
2301     extra_chars_error(s+count, US"fixed-point value for ", name, US"");
2302
2303   if (data_block)
2304     *((int *)(US data_block + ol->v.offset)) = value;
2305   else
2306     *((int *)ol->v.value) = value;
2307   break;
2308
2309   /* There's a special routine to read time values. */
2310
2311   case opt_time:
2312   value = readconf_readtime(s, 0, FALSE);
2313   if (value < 0)
2314     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2315       name);
2316   if (data_block)
2317     *((int *)(US data_block + ol->v.offset)) = value;
2318   else
2319     *((int *)ol->v.value) = value;
2320   break;
2321
2322   /* A time list is a list of colon-separated times, with the first
2323   element holding the size of the list and the second the number of
2324   entries used. */
2325
2326   case opt_timelist:
2327     {
2328     int count = 0;
2329     int * list = data_block
2330       ? (int *)(US data_block + ol->v.offset)
2331       : (int *)ol->v.value;
2332
2333     if (*s != 0) for (count = 1; count <= list[0] - 2; count++)
2334       {
2335       int terminator = 0;
2336       uschar *snext = Ustrchr(s, ':');
2337       if (snext != NULL)
2338         {
2339         uschar *ss = snext;
2340         while (ss > s && isspace(ss[-1])) ss--;
2341         terminator = *ss;
2342         }
2343       value = readconf_readtime(s, terminator, FALSE);
2344       if (value < 0)
2345         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2346           name);
2347       if (count > 1 && value <= list[count])
2348         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2349           "time value out of order for %s", name);
2350       list[count+1] = value;
2351       if (snext == NULL) break;
2352       s = snext + 1;
2353       while (isspace(*s)) s++;
2354       }
2355
2356     if (count > list[0] - 2)
2357       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many time values for %s",
2358         name);
2359     if (count > 0 && list[2] == 0) count = 0;
2360     list[1] = count;
2361     break;
2362     }
2363
2364   case opt_func:
2365     {
2366     void (*fn)() = ol->v.fn;
2367     fn(name, s, 0);
2368     break;
2369     }
2370   }
2371
2372 return TRUE;
2373 }
2374
2375
2376
2377 /*************************************************
2378 *               Print a time value               *
2379 *************************************************/
2380
2381 /*
2382 Argument:  a time value in seconds
2383 Returns:   pointer to a fixed buffer containing the time as a string,
2384            in readconf_readtime() format
2385 */
2386
2387 uschar *
2388 readconf_printtime(int t)
2389 {
2390 int s, m, h, d, w;
2391 uschar *p = time_buffer;
2392
2393 if (t < 0)
2394   {
2395   *p++ = '-';
2396   t = -t;
2397   }
2398
2399 s = t % 60;
2400 t /= 60;
2401 m = t % 60;
2402 t /= 60;
2403 h = t % 24;
2404 t /= 24;
2405 d = t % 7;
2406 w = t/7;
2407
2408 if (w > 0) p += sprintf(CS p, "%dw", w);
2409 if (d > 0) p += sprintf(CS p, "%dd", d);
2410 if (h > 0) p += sprintf(CS p, "%dh", h);
2411 if (m > 0) p += sprintf(CS p, "%dm", m);
2412 if (s > 0 || p == time_buffer) sprintf(CS p, "%ds", s);
2413
2414 return time_buffer;
2415 }
2416
2417
2418
2419 /*************************************************
2420 *      Print an individual option value          *
2421 *************************************************/
2422
2423 /* This is used by the -bP option, so prints to the standard output.
2424 The entire options list is passed in as an argument, because some options come
2425 in pairs - typically uid/gid settings, which can either be explicit numerical
2426 values, or strings to be expanded later. If the numerical value is unset,
2427 search for "*expand_<name>" to see if there is a string equivalent.
2428
2429 Arguments:
2430   ol             option entry, or NULL for an unknown option
2431   name           option name
2432   options_block  NULL for main configuration options; otherwise points to
2433                    a driver block; if the option doesn't have opt_public
2434                    set, then options_block->options_block is where the item
2435                    resides.
2436   oltop          points to the option list in which ol exists
2437   last           one more than the offset of the last entry in optop
2438   no_labels      do not show "foo = " at the start.
2439
2440 Returns:         boolean success
2441 */
2442
2443 static BOOL
2444 print_ol(optionlist *ol, const uschar *name, void *options_block,
2445   optionlist *oltop, int last, BOOL no_labels)
2446 {
2447 struct passwd *pw;
2448 struct group *gr;
2449 optionlist *ol2;
2450 void *value;
2451 uid_t *uidlist;
2452 gid_t *gidlist;
2453 uschar *s;
2454 uschar name2[EXIM_DRIVERNAME_MAX];
2455
2456 if (!ol)
2457   {
2458   printf("%s is not a known option\n", name);
2459   return FALSE;
2460   }
2461
2462 /* Non-admin callers cannot see options that have been flagged secure by the
2463 "hide" prefix. */
2464
2465 if (!f.admin_user && ol->type & opt_secure)
2466   {
2467   if (no_labels)
2468     printf("%s\n", CCS hidden);
2469   else
2470     printf("%s = %s\n", name, CCS hidden);
2471   return TRUE;
2472   }
2473
2474 /* Else show the value of the option */
2475
2476 value = ol->v.value;
2477 if (options_block)
2478   {
2479   if (!(ol->type & opt_public))
2480     options_block = (void *)(((driver_instance *)options_block)->options_block);
2481   value = (void *)(US options_block + (long int)value);
2482   }
2483
2484 switch(ol->type & opt_mask)
2485   {
2486   case opt_stringptr:
2487   case opt_rewrite:        /* Show the text value */
2488     s = *(USS value);
2489     if (!no_labels) printf("%s = ", name);
2490     printf("%s\n", s ? string_printing2(s, SP_TAB) : US"");
2491     break;
2492
2493   case opt_int:
2494     if (!no_labels) printf("%s = ", name);
2495     printf("%d\n", *((int *)value));
2496     break;
2497
2498   case opt_mkint:
2499     {
2500     int x = *((int *)value);
2501     if (x != 0 && (x & 1023) == 0)
2502       {
2503       int c = 'K';
2504       x >>= 10;
2505       if ((x & 1023) == 0)
2506         {
2507         c = 'M';
2508         x >>= 10;
2509         }
2510       if (!no_labels) printf("%s = ", name);
2511       printf("%d%c\n", x, c);
2512       }
2513     else
2514       {
2515       if (!no_labels) printf("%s = ", name);
2516       printf("%d\n", x);
2517       }
2518     }
2519     break;
2520
2521   case opt_Kint:
2522     {
2523     int_eximarith_t x = *((int_eximarith_t *)value);
2524     if (!no_labels) printf("%s = ", name);
2525     if (x == 0) printf("0\n");
2526     else if ((x & ((1<<30)-1)) == 0) printf(PR_EXIM_ARITH "T\n", x >> 30);
2527     else if ((x & ((1<<20)-1)) == 0) printf(PR_EXIM_ARITH "G\n", x >> 20);
2528     else if ((x & ((1<<10)-1)) == 0) printf(PR_EXIM_ARITH "M\n", x >> 10);
2529     else printf(PR_EXIM_ARITH "K\n", x);
2530     }
2531     break;
2532
2533   case opt_octint:
2534     if (!no_labels) printf("%s = ", name);
2535     printf("%#o\n", *((int *)value));
2536     break;
2537
2538   /* Can be negative only when "unset", in which case integer */
2539
2540   case opt_fixed:
2541     {
2542     int x = *((int *)value);
2543     int f = x % 1000;
2544     int d = 100;
2545     if (x < 0) printf("%s =\n", name); else
2546       {
2547       if (!no_labels) printf("%s = ", name);
2548       printf("%d.", x/1000);
2549       do
2550         {
2551         printf("%d", f/d);
2552         f %= d;
2553         d /= 10;
2554         }
2555       while (f != 0);
2556       printf("\n");
2557       }
2558     }
2559     break;
2560
2561   /* If the numerical value is unset, try for the string value */
2562
2563   case opt_expand_uid:
2564     if (! *get_set_flag(name, oltop, last, options_block))
2565       {
2566       sprintf(CS name2, "*expand_%.50s", name);
2567       if ((ol2 = find_option(name2, oltop, last)))
2568         {
2569         if (options_block)
2570           s = *USS (US options_block + ol2->v.offset);
2571         else
2572           s = *USS ol2->v.value;
2573         if (!no_labels) printf("%s = ", name);
2574         printf("%s\n", s ? string_printing(s) : US"");
2575         break;
2576         }
2577       }
2578
2579     /* Else fall through */
2580
2581   case opt_uid:
2582     if (!no_labels) printf("%s = ", name);
2583     if (! *get_set_flag(name, oltop, last, options_block))
2584       printf("\n");
2585     else
2586       if ((pw = getpwuid(*((uid_t *)value))))
2587         printf("%s\n", pw->pw_name);
2588       else
2589         printf("%ld\n", (long int)(*((uid_t *)value)));
2590     break;
2591
2592   /* If the numerical value is unset, try for the string value */
2593
2594   case opt_expand_gid:
2595     if (! *get_set_flag(name, oltop, last, options_block))
2596       {
2597       sprintf(CS name2, "*expand_%.50s", name);
2598       if (  (ol2 = find_option(name2, oltop, last))
2599          && (ol2->type & opt_mask) == opt_stringptr)
2600         {
2601         if (options_block)
2602           s = *USS (US options_block + ol2->v.offset);
2603         else
2604           s = *USS ol2->v.value;
2605         if (!no_labels) printf("%s = ", name);
2606         printf("%s\n", s ? string_printing(s) : US"");
2607         break;
2608         }
2609       }
2610
2611     /* Else fall through */
2612
2613   case opt_gid:
2614     if (!no_labels) printf("%s = ", name);
2615     if (! *get_set_flag(name, oltop, last, options_block))
2616       printf("\n");
2617     else
2618       if ((gr = getgrgid(*((int *)value))))
2619         printf("%s\n", gr->gr_name);
2620       else
2621          printf("%ld\n", (long int)(*((int *)value)));
2622     break;
2623
2624   case opt_uidlist:
2625     uidlist = *((uid_t **)value);
2626     if (!no_labels) printf("%s =", name);
2627     if (uidlist)
2628       {
2629       uschar sep = no_labels ? '\0' : ' ';
2630       for (int i = 1; i <= (int)(uidlist[0]); i++)
2631         {
2632         uschar *name = NULL;
2633         if ((pw = getpwuid(uidlist[i]))) name = US pw->pw_name;
2634         if (sep != '\0') printf("%c", sep);
2635         if (name) printf("%s", name);
2636         else printf("%ld", (long int)(uidlist[i]));
2637         sep = ':';
2638         }
2639       }
2640     printf("\n");
2641     break;
2642
2643   case opt_gidlist:
2644     gidlist = *((gid_t **)value);
2645     if (!no_labels) printf("%s =", name);
2646     if (gidlist)
2647       {
2648       uschar sep = no_labels ? '\0' : ' ';
2649       for (int i = 1; i <= (int)(gidlist[0]); i++)
2650         {
2651         uschar *name = NULL;
2652         if ((gr = getgrgid(gidlist[i]))) name = US gr->gr_name;
2653         if (sep != '\0') printf("%c", sep);
2654         if (name) printf("%s", name);
2655         else printf("%ld", (long int)(gidlist[i]));
2656         sep = ':';
2657         }
2658       }
2659     printf("\n");
2660     break;
2661
2662   case opt_time:
2663     if (!no_labels) printf("%s = ", name);
2664     printf("%s\n", readconf_printtime(*((int *)value)));
2665     break;
2666
2667   case opt_timelist:
2668     {
2669     int *list = (int *)value;
2670     if (!no_labels) printf("%s = ", name);
2671     for (int i = 0; i < list[1]; i++)
2672       printf("%s%s", i == 0 ? "" : ":", readconf_printtime(list[i+2]));
2673     printf("\n");
2674     }
2675     break;
2676
2677   case opt_bit:
2678     printf("%s%s\n", ((*((int *)value)) & (1 << ((ol->type >> 16) & 31)))?
2679       "" : "no_", name);
2680     break;
2681
2682   case opt_expand_bool:
2683     sprintf(CS name2, "*expand_%.50s", name);
2684     if ((ol2 = find_option(name2, oltop, last)) && ol2->v.value)
2685       {
2686       if (options_block)
2687         s = *USS (US options_block + ol2->v.offset);
2688       else
2689         s = *USS ol2->v.value;
2690       if (s)
2691         {
2692         if (!no_labels) printf("%s = ", name);
2693         printf("%s\n", string_printing(s));
2694         break;
2695         }
2696       /* s == NULL => string not set; fall through */
2697       }
2698
2699     /* Fall through */
2700
2701   case opt_bool:
2702   case opt_bool_verify:
2703   case opt_bool_set:
2704     printf("%s%s\n", (*((BOOL *)value))? "" : "no_", name);
2705     break;
2706
2707   case opt_func:
2708     ol->v.fn(name, NULL, no_labels ? opt_fn_print : opt_fn_print|opt_fn_print_label);
2709     break;
2710   }
2711 return TRUE;
2712 }
2713
2714
2715
2716 /*************************************************
2717 *        Print value from main configuration     *
2718 *************************************************/
2719
2720 /* This function, called as a result of encountering the -bP option,
2721 causes the value of any main configuration variable to be output if the
2722 second argument is NULL. There are some special values:
2723
2724   all                print all main configuration options
2725   config_file        print the name of the configuration file
2726                      (configure_file will still work, for backward
2727                      compatibility)
2728   routers            print the routers' configurations
2729   transports         print the transports' configuration
2730   authenticators     print the authenticators' configuration
2731   macros             print the macros' configuration
2732   router_list        print a list of router names
2733   transport_list     print a list of transport names
2734   authenticator_list print a list of authentication mechanism names
2735   macro_list         print a list of macro names
2736   +name              print a named list item
2737   local_scan         print the local_scan options
2738   config             print the configuration as it is parsed
2739   environment        print the used execution environment
2740
2741 If the second argument is not NULL, it must be one of "router", "transport",
2742 "authenticator" or "macro" in which case the first argument identifies the
2743 driver whose options are to be printed.
2744
2745 Arguments:
2746   name        option name if type == NULL; else driver name
2747   type        NULL or driver type name, as described above
2748   no_labels   avoid the "foo = " at the start of an item
2749
2750 Returns:      Boolean success
2751 */
2752
2753 BOOL
2754 readconf_print(const uschar *name, uschar *type, BOOL no_labels)
2755 {
2756 BOOL names_only = FALSE;
2757 optionlist *ol2 = NULL;
2758 driver_instance *d = NULL;
2759 int size = 0;
2760
2761 if (!type)
2762   {
2763   if (*name == '+')
2764     {
2765     tree_node *t;
2766     BOOL found = FALSE;
2767     static uschar *types[] = { US"address", US"domain", US"host",
2768       US"localpart" };
2769     static tree_node **anchors[] = { &addresslist_anchor, &domainlist_anchor,
2770       &hostlist_anchor, &localpartlist_anchor };
2771
2772     for (int i = 0; i < 4; i++)
2773       if ((t = tree_search(*(anchors[i]), name+1)))
2774         {
2775         namedlist_block * nb = t->data.ptr;
2776         const uschar * s = nb->hide ? hidden : nb->string;
2777         found = TRUE;
2778         if (no_labels)
2779           printf("%s\n", CCS s);
2780         else
2781           printf("%slist %s = %s\n", types[i], name+1, CCS s);
2782         }
2783
2784     if (!found)
2785       printf("no address, domain, host, or local part list called \"%s\" "
2786         "exists\n", name+1);
2787
2788     return found;
2789     }
2790
2791   if (  Ustrcmp(name, "configure_file") == 0
2792      || Ustrcmp(name, "config_file") == 0)
2793     {
2794     printf("%s\n", CS config_main_filename);
2795     return TRUE;
2796     }
2797
2798   if (Ustrcmp(name, "all") == 0)
2799     {
2800     for (optionlist * ol = optionlist_config;
2801          ol < optionlist_config + nelem(optionlist_config); ol++)
2802       if (!(ol->type & opt_hidden))
2803         (void) print_ol(ol, US ol->name, NULL,
2804                   optionlist_config, nelem(optionlist_config),
2805                   no_labels);
2806     return TRUE;
2807     }
2808
2809   if (Ustrcmp(name, "local_scan") == 0)
2810     {
2811 #ifndef LOCAL_SCAN_HAS_OPTIONS
2812     printf("local_scan() options are not supported\n");
2813     return FALSE;
2814 #else
2815     for (optionlist * ol = local_scan_options;
2816          ol < local_scan_options + local_scan_options_count; ol++)
2817       (void) print_ol(ol, US ol->name, NULL, local_scan_options,
2818                   local_scan_options_count, no_labels);
2819     return TRUE;
2820 #endif
2821     }
2822
2823   if (Ustrcmp(name, "config") == 0)
2824     {
2825     print_config(f.admin_user, no_labels);
2826     return TRUE;
2827     }
2828
2829   if (Ustrcmp(name, "routers") == 0)
2830     {
2831     type = US"router";
2832     name = NULL;
2833     }
2834   else if (Ustrcmp(name, "transports") == 0)
2835     {
2836     type = US"transport";
2837     name = NULL;
2838     }
2839   else if (Ustrcmp(name, "authenticators") == 0)
2840     {
2841     type = US"authenticator";
2842     name = NULL;
2843     }
2844   else if (Ustrcmp(name, "macros") == 0)
2845     {
2846     type = US"macro";
2847     name = NULL;
2848     }
2849   else if (Ustrcmp(name, "router_list") == 0)
2850     {
2851     type = US"router";
2852     name = NULL;
2853     names_only = TRUE;
2854     }
2855   else if (Ustrcmp(name, "transport_list") == 0)
2856     {
2857     type = US"transport";
2858     name = NULL;
2859     names_only = TRUE;
2860     }
2861   else if (Ustrcmp(name, "authenticator_list") == 0)
2862     {
2863     type = US"authenticator";
2864     name = NULL;
2865     names_only = TRUE;
2866     }
2867   else if (Ustrcmp(name, "macro_list") == 0)
2868     {
2869     type = US"macro";
2870     name = NULL;
2871     names_only = TRUE;
2872     }
2873   else if (Ustrcmp(name, "environment") == 0)
2874     {
2875     if (environ)
2876       {
2877       uschar ** p;
2878       for (p = USS environ; *p; p++) ;
2879       qsort(environ, p - USS environ, sizeof(*p), string_compare_by_pointer);
2880
2881       for (p = USS environ; *p; p++)
2882         {
2883         uschar * q;
2884         if (no_labels && (q = Ustrchr(*p, '='))) *q  = '\0';
2885         puts(CS *p);
2886         }
2887       }
2888     return TRUE;
2889     }
2890
2891   else
2892     return print_ol(find_option(name,
2893                       optionlist_config, nelem(optionlist_config)),
2894       name, NULL, optionlist_config, nelem(optionlist_config), no_labels);
2895   }
2896
2897 /* Handle the options for a router or transport. Skip options that are flagged
2898 as hidden. Some of these are options with names starting with '*', used for
2899 internal alternative representations of other options (which the printing
2900 function will sort out). Others are synonyms kept for backward compatibility.
2901 */
2902
2903 if (Ustrcmp(type, "router") == 0)
2904   {
2905   d = (driver_instance *)routers;
2906   ol2 = optionlist_routers;
2907   size = optionlist_routers_size;
2908   }
2909 else if (Ustrcmp(type, "transport") == 0)
2910   {
2911   d = (driver_instance *)transports;
2912   ol2 = optionlist_transports;
2913   size = optionlist_transports_size;
2914   }
2915 else if (Ustrcmp(type, "authenticator") == 0)
2916   {
2917   d = (driver_instance *)auths;
2918   ol2 = optionlist_auths;
2919   size = optionlist_auths_size;
2920   }
2921
2922 else if (Ustrcmp(type, "macro") == 0)
2923   {
2924   /* People store passwords in macros and they were previously not available
2925   for printing.  So we have an admin_users restriction. */
2926   if (!f.admin_user)
2927     {
2928     fprintf(stderr, "exim: permission denied\n");
2929     return FALSE;
2930     }
2931   for (macro_item * m = macros; m; m = m->next)
2932     if (!name || Ustrcmp(name, m->name) == 0)
2933       {
2934       if (names_only)
2935         printf("%s\n", CS m->name);
2936       else if (no_labels)
2937         printf("%s\n", CS m->replacement);
2938       else
2939         printf("%s=%s\n", CS m->name, CS m->replacement);
2940       if (name)
2941         return TRUE;
2942       }
2943   if (!name) return TRUE;
2944
2945   printf("%s %s not found\n", type, name);
2946   return FALSE;
2947   }
2948
2949 if (names_only)
2950   {
2951   for (; d; d = d->next) printf("%s\n", CS d->name);
2952   return TRUE;
2953   }
2954
2955 /* Either search for a given driver, or print all of them */
2956
2957 for (; d; d = d->next)
2958   {
2959   BOOL rc = FALSE;
2960   if (!name)
2961     printf("\n%s %s:\n", d->name, type);
2962   else if (Ustrcmp(d->name, name) != 0) continue;
2963
2964   for (optionlist * ol = ol2; ol < ol2 + size; ol++)
2965     if (!(ol->type & opt_hidden))
2966       rc |= print_ol(ol, US ol->name, d, ol2, size, no_labels);
2967
2968   for (optionlist * ol = d->info->options;
2969        ol < d->info->options + *(d->info->options_count); ol++)
2970     if (!(ol->type & opt_hidden))
2971       rc |= print_ol(ol, US ol->name, d, d->info->options,
2972                     *d->info->options_count, no_labels);
2973
2974   if (name) return rc;
2975   }
2976 if (!name) return TRUE;
2977
2978 printf("%s %s not found\n", type, name);
2979 return FALSE;
2980 }
2981
2982
2983
2984 /*************************************************
2985 *          Read a named list item                *
2986 *************************************************/
2987
2988 /* This function reads a name and a list (i.e. string). The name is used to
2989 save the list in a tree, sorted by its name. Each entry also has a number,
2990 which can be used for caching tests, but if the string contains any expansion
2991 items other than $key, the number is set negative to inhibit caching. This
2992 mechanism is used for domain, host, and address lists that are referenced by
2993 the "+name" syntax.
2994
2995 Arguments:
2996   anchorp     points to the tree anchor
2997   numberp     points to the current number for this tree
2998   max         the maximum number permitted
2999   s           the text of the option line, starting immediately after the name
3000                 of the list type
3001   tname       the name of the list type, for messages
3002   hide        do not output value on "-bP"
3003
3004 Returns:      nothing
3005 */
3006
3007 static void
3008 read_named_list(tree_node **anchorp, int *numberp, int max, uschar *s,
3009   uschar *tname, BOOL hide)
3010 {
3011 BOOL forcecache = FALSE;
3012 uschar *ss;
3013 tree_node *t;
3014 int old_pool = store_pool;
3015 namedlist_block * nb;
3016
3017 store_pool = POOL_PERM;
3018 nb = store_get(sizeof(namedlist_block), FALSE);
3019 store_pool = old_pool;
3020
3021 if (Ustrncmp(s, "_cache", 6) == 0)
3022   {
3023   forcecache = TRUE;
3024   s += 6;
3025   }
3026
3027 if (!isspace(*s))
3028   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unrecognized configuration line");
3029
3030 if (*numberp >= max)
3031  log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many named %ss (max is %d)\n",
3032    tname, max);
3033
3034 Uskip_whitespace(&s);
3035 ss = s;
3036 while (isalnum(*s) || *s == '_') s++;
3037 t = store_get(sizeof(tree_node) + s-ss, is_tainted(ss));
3038 Ustrncpy(t->name, ss, s-ss);
3039 t->name[s-ss] = 0;
3040 Uskip_whitespace(&s);
3041
3042 if (!tree_insertnode(anchorp, t))
3043   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3044     "duplicate name \"%s\" for a named %s", t->name, tname);
3045
3046 t->data.ptr = nb;
3047 nb->number = *numberp;
3048 *numberp += 1;
3049 nb->hide = hide;
3050
3051 if (*s++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3052   "missing '=' after \"%s\"", t->name);
3053 Uskip_whitespace(&s);
3054 nb->string = read_string(s, t->name);
3055 nb->cache_data = NULL;
3056
3057 /* Check the string for any expansions; if any are found, mark this list
3058 uncacheable unless the user has explicited forced caching. */
3059
3060 if (!forcecache && Ustrchr(nb->string, '$') != NULL) nb->number = -1;
3061 }
3062
3063
3064
3065
3066 /*************************************************
3067 *        Unpick data for a rate limit            *
3068 *************************************************/
3069
3070 /* This function is called to unpick smtp_ratelimit_{mail,rcpt} into four
3071 separate values.
3072
3073 Arguments:
3074   s            string, in the form t,b,f,l
3075                where t is the threshold (integer)
3076                b is the initial delay (time)
3077                f is the multiplicative factor (fixed point)
3078                k is the maximum time (time)
3079   threshold    where to store threshold
3080   base         where to store base in milliseconds
3081   factor       where to store factor in milliseconds
3082   limit        where to store limit
3083
3084 Returns:       nothing (panics on error)
3085 */
3086
3087 static void
3088 unpick_ratelimit(uschar *s, int *threshold, int *base, double *factor,
3089   int *limit)
3090 {
3091 uschar bstring[16], lstring[16];
3092
3093 if (sscanf(CS s, "%d, %15[0123456789smhdw.], %lf, %15s", threshold, bstring,
3094     factor, lstring) == 4)
3095   {
3096   *base = readconf_readtime(bstring, 0, TRUE);
3097   *limit = readconf_readtime(lstring, 0, TRUE);
3098   if (*base >= 0 && *limit >= 0) return;
3099   }
3100 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "malformed ratelimit data: %s", s);
3101 }
3102
3103
3104
3105
3106 /*************************************************
3107 *         Read main configuration options        *
3108 *************************************************/
3109
3110 /* This function is the first to be called for configuration reading. It
3111 opens the configuration file and reads general configuration settings until
3112 it reaches the end of the configuration section. The file is then left open so
3113 that the remaining configuration data can subsequently be read if needed for
3114 this run of Exim.
3115
3116 The configuration file must be owned either by root or exim, and be writeable
3117 only by root or uid/gid exim. The values for Exim's uid and gid can be changed
3118 in the config file, so the test is done on the compiled in values. A slight
3119 anomaly, to be carefully documented.
3120
3121 The name of the configuration file is taken from a list that is included in the
3122 binary of Exim. It can be altered from the command line, but if that is done,
3123 root privilege is immediately withdrawn unless the caller is root or exim.
3124 The first file on the list that exists is used.
3125
3126 For use on multiple systems that share file systems, first look for a
3127 configuration file whose name has the current node name on the end. If that is
3128 not found, try the generic name. For really contorted configurations, that run
3129 multiple Exims with different uid settings, first try adding the effective uid
3130 before the node name. These complications are going to waste resources on most
3131 systems. Therefore they are available only when requested by compile-time
3132 options. */
3133
3134 void
3135 readconf_main(BOOL nowarn)
3136 {
3137 int sep = 0;
3138 struct stat statbuf;
3139 uschar *s, *filename;
3140 const uschar *list = config_main_filelist;
3141
3142 /* Loop through the possible file names */
3143
3144 /* Should never be a tainted list */
3145 while((filename = string_nextinlist(&list, &sep, big_buffer, big_buffer_size)))
3146   {
3147
3148   /* Cut out all the fancy processing unless specifically wanted */
3149
3150 #if defined(CONFIGURE_FILE_USE_NODE) || defined(CONFIGURE_FILE_USE_EUID)
3151   uschar *suffix = filename + Ustrlen(filename);
3152
3153   /* Try for the node-specific file if a node name exists */
3154
3155 # ifdef CONFIGURE_FILE_USE_NODE
3156   struct utsname uts;
3157   if (uname(&uts) >= 0)
3158     {
3159 #  ifdef CONFIGURE_FILE_USE_EUID
3160     sprintf(CS suffix, ".%ld.%.256s", (long int)original_euid, uts.nodename);
3161     if (!(config_file = Ufopen(filename, "rb")))
3162 #  endif  /* CONFIGURE_FILE_USE_EUID */
3163       {
3164       sprintf(CS suffix, ".%.256s", uts.nodename);
3165       config_file = Ufopen(filename, "rb");
3166       }
3167     }
3168 # endif  /* CONFIGURE_FILE_USE_NODE */
3169
3170   /* Otherwise, try the generic name, possibly with the euid added */
3171
3172 # ifdef CONFIGURE_FILE_USE_EUID
3173   if (!config_file)
3174     {
3175     sprintf(CS suffix, ".%ld", (long int)original_euid);
3176     config_file = Ufopen(filename, "rb");
3177     }
3178 # endif  /* CONFIGURE_FILE_USE_EUID */
3179
3180   /* Finally, try the unadorned name */
3181
3182   if (!config_file)
3183     {
3184     *suffix = 0;
3185     config_file = Ufopen(filename, "rb");
3186     }
3187 #else  /* if neither defined */
3188
3189   /* This is the common case when the fancy processing is not included. */
3190
3191   config_file = Ufopen(filename, "rb");
3192 #endif
3193
3194   /* If the file does not exist, continue to try any others. For any other
3195   error, break out (and die). */
3196
3197   if (config_file || errno != ENOENT) break;
3198   }
3199
3200 /* On success, save the name for verification; config_filename is used when
3201 logging configuration errors (it changes for .included files) whereas
3202 config_main_filename is the name shown by -bP. Failure to open a configuration
3203 file is a serious disaster. */
3204
3205 if (config_file)
3206   {
3207   uschar *last_slash = Ustrrchr(filename, '/');
3208   config_filename = config_main_filename = string_copy(filename);
3209
3210   /* The config_main_directory we need for the $config_dir expansion.
3211   config_main_filename we need for $config_file expansion.
3212   And config_dir is the directory of the current configuration, used for
3213   relative .includes. We do need to know it's name, as we change our working
3214   directory later. */
3215
3216   if (filename[0] == '/')
3217     config_main_directory = last_slash == filename ? US"/" : string_copyn(filename, last_slash - filename);
3218   else
3219     {
3220     /* relative configuration file name: working dir + / + basename(filename) */
3221
3222     uschar buf[PATH_MAX];
3223     gstring * g;
3224
3225     if (os_getcwd(buf, PATH_MAX) == NULL)
3226       {
3227       perror("exim: getcwd");
3228       exit(EXIT_FAILURE);
3229       }
3230     g = string_cat(NULL, buf);
3231
3232     /* If the dir does not end with a "/", append one */
3233     if (g->s[g->ptr-1] != '/')
3234       g = string_catn(g, US"/", 1);
3235
3236     /* If the config file contains a "/", extract the directory part */
3237     if (last_slash)
3238       g = string_catn(g, filename, last_slash - filename);
3239
3240     config_main_directory = string_from_gstring(g);
3241     }
3242   config_directory = config_main_directory;
3243   }
3244 else
3245   if (!filename)
3246     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "non-existent configuration file(s): "
3247       "%s", config_main_filelist);
3248   else
3249     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
3250       string_open_failed("configuration file %s", filename));
3251
3252 /* Now, once we found and opened our configuration file, we change the directory
3253 to a safe place. Later we change to $spool_directory. */
3254
3255 if (Uchdir("/") < 0)
3256   {
3257   perror("exim: chdir `/': ");
3258   exit(EXIT_FAILURE);
3259   }
3260
3261 /* Check the status of the file we have opened, if we have retained root
3262 privileges and the file isn't /dev/null (which *should* be 0666). */
3263
3264 if (f.trusted_config && Ustrcmp(filename, US"/dev/null"))
3265   {
3266   if (fstat(fileno(config_file), &statbuf) != 0)
3267     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to stat configuration file %s",
3268       big_buffer);
3269
3270   if (    statbuf.st_uid != root_uid            /* owner not root */
3271 #ifdef CONFIGURE_OWNER
3272        && statbuf.st_uid != config_uid          /* owner not the special one */
3273 #endif
3274      ||                                         /* or */
3275           statbuf.st_gid != root_gid            /* group not root & */
3276 #ifdef CONFIGURE_GROUP
3277        && statbuf.st_gid != config_gid          /* group not the special one */
3278 #endif
3279        && (statbuf.st_mode & 020) != 0          /* group writeable  */
3280      ||                                         /* or */
3281        (statbuf.st_mode & 2) != 0               /* world writeable  */
3282      )
3283     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Exim configuration file %s has the "
3284       "wrong owner, group, or mode", big_buffer);
3285
3286   /* Do a dummy store-allocation of a size related to the (toplevel) file size.
3287   This assumes we will need this much storage to handle all the allocations
3288   during startup; it won't help when .include is being used.  When it does, it
3289   will cut down on the number of store blocks (and malloc calls, and sbrk
3290   syscalls).  It also assume we're on the relevant pool. */
3291
3292   if (statbuf.st_size > 8192)
3293     {
3294     rmark r = store_mark();
3295     void * dummy = store_get((int)statbuf.st_size, FALSE);
3296     store_reset(r);
3297     }
3298   }
3299
3300 /* Process the main configuration settings. They all begin with a lower case
3301 letter. If we see something starting with an upper case letter, it is taken as
3302 a macro definition. */
3303
3304 while ((s = get_config_line()))
3305   {
3306   BOOL hide;
3307   uschar * t;
3308
3309   if (config_lineno == 1 && Ustrstr(s, "\xef\xbb\xbf") == s)
3310     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3311       "found unexpected BOM (Byte Order Mark)");
3312
3313   if (isupper(*s))
3314     {
3315     if (!macro_read_assignment(s)) exim_exit(EXIT_FAILURE);
3316     continue;
3317     }
3318
3319   t = (hide = Ustrncmp(s, "hide", 4) == 0 && isspace(s[4])) ? s + 5 : s;
3320
3321   if (Ustrncmp(t, "domainlist", 10) == 0)
3322     read_named_list(&domainlist_anchor, &domainlist_count,
3323       MAX_NAMED_LIST, t+10, US"domain list", hide);
3324
3325   else if (Ustrncmp(t, "hostlist", 8) == 0)
3326     read_named_list(&hostlist_anchor, &hostlist_count,
3327       MAX_NAMED_LIST, t+8, US"host list", hide);
3328
3329   else if (Ustrncmp(t, "addresslist", 11) == 0)
3330     read_named_list(&addresslist_anchor, &addresslist_count,
3331       MAX_NAMED_LIST, t+11, US"address list", hide);
3332
3333   else if (Ustrncmp(t, "localpartlist", 13) == 0)
3334     read_named_list(&localpartlist_anchor, &localpartlist_count,
3335       MAX_NAMED_LIST, t+13, US"local part list", hide);
3336
3337   else
3338     (void) readconf_handle_option(s, optionlist_config, optionlist_config_size,
3339       NULL, US"main option \"%s\" unknown");
3340   }
3341
3342
3343 /* If local_sender_retain is set, local_from_check must be unset. */
3344
3345 if (local_sender_retain && local_from_check)
3346   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "both local_from_check and "
3347     "local_sender_retain are set; this combination is not allowed");
3348
3349 /* If the timezone string is empty, set it to NULL, implying no TZ variable
3350 wanted. */
3351
3352 if (timezone_string && !*timezone_string) timezone_string = NULL;
3353
3354 /* The max retry interval must not be greater than 24 hours. */
3355
3356 if (retry_interval_max > 24*60*60) retry_interval_max = 24*60*60;
3357
3358 /* remote_max_parallel must be > 0 */
3359
3360 if (remote_max_parallel <= 0) remote_max_parallel = 1;
3361
3362 /* Save the configured setting of freeze_tell, so we can re-instate it at the
3363 start of a new SMTP message. */
3364
3365 freeze_tell_config = freeze_tell;
3366
3367 /* The primary host name may be required for expansion of spool_directory
3368 and log_file_path, so make sure it is set asap. It is obtained from uname(),
3369 but if that yields an unqualified value, make a FQDN by using gethostbyname to
3370 canonize it. Some people like upper case letters in their host names, so we
3371 don't force the case. */
3372
3373 if (!primary_hostname)
3374   {
3375   const uschar * hostname;
3376   struct utsname uts;
3377
3378   if (uname(&uts) < 0)
3379     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "uname() failed to yield host name");
3380   hostname = US uts.nodename;
3381
3382   if (Ustrchr(hostname, '.') == NULL)
3383     {
3384     int af = AF_INET;
3385     struct hostent *hostdata;
3386
3387 #if HAVE_IPV6
3388     if (  !disable_ipv6
3389        && (  !dns_ipv4_lookup
3390           || match_isinlist(hostname, CUSS &dns_ipv4_lookup, 0, NULL, NULL,
3391             MCL_DOMAIN, TRUE, NULL) != OK))
3392       af = AF_INET6;
3393 #endif
3394
3395     for (;;)
3396       {
3397 #if HAVE_IPV6
3398 # if HAVE_GETIPNODEBYNAME
3399         int error_num;
3400         hostdata = getipnodebyname(CS hostname, af, 0, &error_num);
3401         #else
3402         hostdata = gethostbyname2(CS hostname, af);
3403 # endif
3404 #else
3405       hostdata = gethostbyname(CS hostname);
3406 #endif
3407
3408       if (hostdata)
3409         { hostname = US hostdata->h_name; break; }
3410
3411       if (af == AF_INET) break;
3412       af = AF_INET;
3413       }
3414     }
3415
3416   primary_hostname = string_copy(hostname);
3417   }
3418
3419 /* Set up default value for smtp_active_hostname */
3420
3421 smtp_active_hostname = primary_hostname;
3422
3423 /* If spool_directory wasn't set in the build-time configuration, it must have
3424 got set above. Of course, writing to the log may not work if log_file_path is
3425 not set, but it will at least get to syslog or somewhere, with any luck. */
3426
3427 if (!*spool_directory)
3428   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "spool_directory undefined: cannot "
3429     "proceed");
3430
3431 /* Expand the spool directory name; it may, for example, contain the primary
3432 host name. Same comment about failure. */
3433
3434 if (!(s = expand_string(spool_directory)))
3435   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand spool_directory "
3436     "\"%s\": %s", spool_directory, expand_string_message);
3437 spool_directory = s;
3438
3439 /* Expand log_file_path, which must contain "%s" in any component that isn't
3440 the null string or "syslog". It is also allowed to contain one instance of %D
3441 or %M. However, it must NOT contain % followed by anything else. */
3442
3443 if (*log_file_path)
3444   {
3445   const uschar *ss, *sss;
3446   int sep = ':';                       /* Fixed for log file path */
3447   if (!(s = expand_string(log_file_path)))
3448     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand log_file_path "
3449       "\"%s\": %s", log_file_path, expand_string_message);
3450
3451   ss = s;
3452   /* should never be a tainted list */
3453   while ((sss = string_nextinlist(&ss, &sep, big_buffer, big_buffer_size)))
3454     {
3455     uschar *t;
3456     if (sss[0] == 0 || Ustrcmp(sss, "syslog") == 0) continue;
3457     if (!(t = Ustrstr(sss, "%s")))
3458       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" does not "
3459         "contain \"%%s\"", sss);
3460     *t = 'X';
3461     if ((t = Ustrchr(sss, '%')))
3462       if ((t[1] != 'D' && t[1] != 'M') || Ustrchr(t+2, '%') != NULL)
3463         log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" contains "
3464           "unexpected \"%%\" character", s);
3465     }
3466
3467   log_file_path = s;
3468   }
3469
3470 /* Interpret syslog_facility into an integer argument for 'ident' param to
3471 openlog(). Default is LOG_MAIL set in globals.c. Allow the user to omit the
3472 leading "log_". */
3473
3474 if (syslog_facility_str)
3475   {
3476   int i;
3477   uschar *s = syslog_facility_str;
3478
3479   if ((Ustrlen(syslog_facility_str) >= 4) &&
3480         (strncmpic(syslog_facility_str, US"log_", 4) == 0))
3481     s += 4;
3482
3483   for (i = 0; i < syslog_list_size; i++)
3484     if (strcmpic(s, syslog_list[i].name) == 0)
3485       {
3486       syslog_facility = syslog_list[i].value;
3487       break;
3488       }
3489
3490   if (i >= syslog_list_size)
3491     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3492       "failed to interpret syslog_facility \"%s\"", syslog_facility_str);
3493   }
3494
3495 /* Expand pid_file_path */
3496
3497 if (*pid_file_path)
3498   {
3499   if (!(s = expand_string(pid_file_path)))
3500     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand pid_file_path "
3501       "\"%s\": %s", pid_file_path, expand_string_message);
3502   pid_file_path = s;
3503   }
3504
3505 /* Set default value of process_log_path */
3506
3507 if (!process_log_path || !*process_log_path)
3508   process_log_path = string_sprintf("%s/exim-process.info", spool_directory);
3509
3510 /* Compile the regex for matching a UUCP-style "From_" line in an incoming
3511 message. */
3512
3513 regex_From = regex_must_compile(uucp_from_pattern, FALSE, TRUE);
3514
3515 /* Unpick the SMTP rate limiting options, if set */
3516
3517 if (smtp_ratelimit_mail)
3518   unpick_ratelimit(smtp_ratelimit_mail, &smtp_rlm_threshold,
3519     &smtp_rlm_base, &smtp_rlm_factor, &smtp_rlm_limit);
3520
3521 if (smtp_ratelimit_rcpt)
3522   unpick_ratelimit(smtp_ratelimit_rcpt, &smtp_rlr_threshold,
3523     &smtp_rlr_base, &smtp_rlr_factor, &smtp_rlr_limit);
3524
3525 /* The qualify domains default to the primary host name */
3526
3527 if (!qualify_domain_sender)
3528   qualify_domain_sender = primary_hostname;
3529 if (!qualify_domain_recipient)
3530   qualify_domain_recipient = qualify_domain_sender;
3531
3532 /* Setting system_filter_user in the configuration sets the gid as well if a
3533 name is given, but a numerical value does not. */
3534
3535 if (system_filter_uid_set && !system_filter_gid_set)
3536   {
3537   struct passwd *pw = getpwuid(system_filter_uid);
3538   if (!pw)
3539     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to look up uid %ld",
3540       (long int)system_filter_uid);
3541   system_filter_gid = pw->pw_gid;
3542   system_filter_gid_set = TRUE;
3543   }
3544
3545 /* If the errors_reply_to field is set, check that it is syntactically valid
3546 and ensure it contains a domain. */
3547
3548 if (errors_reply_to)
3549   {
3550   uschar *errmess;
3551   int start, end, domain;
3552   uschar *recipient = parse_extract_address(errors_reply_to, &errmess,
3553     &start, &end, &domain, FALSE);
3554
3555   if (!recipient)
3556     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3557       "error in errors_reply_to (%s): %s", errors_reply_to, errmess);
3558
3559   if (!domain)
3560     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3561       "errors_reply_to (%s) does not contain a domain", errors_reply_to);
3562   }
3563
3564 /* If smtp_accept_queue or smtp_accept_max_per_host is set, then
3565 smtp_accept_max must also be set. */
3566
3567 if (smtp_accept_max == 0 && (smtp_accept_queue > 0 || smtp_accept_max_per_host))
3568   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3569     "smtp_accept_max must be set if smtp_accept_queue or "
3570     "smtp_accept_max_per_host is set");
3571
3572 /* Set up the host number if anything is specified. It is an expanded string
3573 so that it can be computed from the host name, for example. We do this last
3574 so as to ensure that everything else is set up before the expansion. */
3575
3576 if (host_number_string)
3577   {
3578   long int n;
3579   uschar *end;
3580   uschar *s = expand_string(host_number_string);
3581
3582   if (!s)
3583     log_write(0, LOG_MAIN|LOG_PANIC_DIE,
3584         "failed to expand localhost_number \"%s\": %s",
3585         host_number_string, expand_string_message);
3586   n = Ustrtol(s, &end, 0);
3587   while (isspace(*end)) end++;
3588   if (*end)
3589     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3590       "localhost_number value is not a number: %s", s);
3591   if (n > LOCALHOST_MAX)
3592     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3593       "localhost_number is greater than the maximum allowed value (%d)",
3594         LOCALHOST_MAX);
3595   host_number = n;
3596   }
3597
3598 #ifndef DISABLE_TLS
3599 /* If tls_verify_hosts is set, tls_verify_certificates must also be set */
3600
3601 if ((tls_verify_hosts || tls_try_verify_hosts) && !tls_verify_certificates)
3602   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3603     "tls_%sverify_hosts is set, but tls_verify_certificates is not set",
3604     tls_verify_hosts ? "" : "try_");
3605
3606 /* Magic number: at time of writing, 1024 has been the long-standing value
3607 used by so many clients, and what Exim used to use always, that it makes
3608 sense to just min-clamp this max-clamp at that. */
3609 if (tls_dh_max_bits < 1024)
3610   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3611       "tls_dh_max_bits is too small, must be at least 1024 for interop");
3612
3613 /* If openssl_options is set, validate it */
3614 if (openssl_options)
3615   {
3616 # ifdef USE_GNUTLS
3617   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3618     "openssl_options is set but we're using GnuTLS");
3619 # else
3620   long dummy;
3621   if (!tls_openssl_options_parse(openssl_options, &dummy))
3622     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3623       "openssl_options parse error: %s", openssl_options);
3624 # endif
3625   }
3626 #endif  /*DISABLE_TLS*/
3627
3628 if (!nowarn && !keep_environment && environ && *environ)
3629   log_write(0, LOG_MAIN,
3630       "Warning: purging the environment.\n"
3631       " Suggested action: use keep_environment.");
3632 }
3633
3634
3635
3636 /*************************************************
3637 *          Initialize one driver                 *
3638 *************************************************/
3639
3640 /* This is called once the driver's generic options, if any, have been read.
3641 We can now find the driver, set up defaults for the private options, and
3642 unset any "set" bits in the private options table (which might have been
3643 set by another incarnation of the same driver).
3644
3645 Arguments:
3646   d                   pointer to driver instance block, with generic
3647                         options filled in
3648   drivers_available   vector of available drivers
3649   size_of_info        size of each block in drivers_available
3650   class               class of driver, for error message
3651
3652 Returns:              pointer to the driver info block
3653 */
3654
3655 static driver_info *
3656 init_driver(driver_instance *d, driver_info *drivers_available,
3657   int size_of_info, uschar *class)
3658 {
3659 for (driver_info * dd = drivers_available; dd->driver_name[0] != 0;
3660      dd = (driver_info *)((US dd) + size_of_info))
3661   if (Ustrcmp(d->driver_name, dd->driver_name) == 0)
3662     {
3663     int len = dd->options_len;
3664     d->info = dd;
3665     d->options_block = store_get(len, FALSE);
3666     memcpy(d->options_block, dd->options_block, len);
3667     for (int i = 0; i < *(dd->options_count); i++)
3668       dd->options[i].type &= ~opt_set;
3669     return dd;
3670     }
3671
3672 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3673   "%s %s: cannot find %s driver \"%s\"", class, d->name, class, d->driver_name);
3674
3675 return NULL;   /* never obeyed */
3676 }
3677
3678
3679
3680
3681 /*************************************************
3682 *             Initialize driver list             *
3683 *************************************************/
3684
3685 /* This function is called for routers, transports, and authentication
3686 mechanisms. It reads the data from the current point in the configuration file
3687 up to the end of the section, and sets up a chain of instance blocks according
3688 to the file's contents. The file will already have been opened by a call to
3689 readconf_main, and must be left open for subsequent reading of further data.
3690
3691 Any errors cause a panic crash. Note that the blocks with names driver_info and
3692 driver_instance must map the first portions of all the _info and _instance
3693 blocks for this shared code to work.
3694
3695 Arguments:
3696   class                      "router", "transport", or "authenticator"
3697   anchor                     &routers, &transports, &auths
3698   drivers_available          available drivers
3699   size_of_info               size of each info block
3700   instance_default           points to default data for an instance
3701   instance_size              size of instance block
3702   driver_optionlist          generic option list
3703   driver_optionlist_count    count of generic option list
3704
3705 Returns:                     nothing
3706 */
3707
3708 void
3709 readconf_driver_init(
3710   uschar *class,
3711   driver_instance **anchor,
3712   driver_info *drivers_available,
3713   int size_of_info,
3714   void *instance_default,
3715   int  instance_size,
3716   optionlist *driver_optionlist,
3717   int  driver_optionlist_count)
3718 {
3719 driver_instance **p = anchor;
3720 driver_instance *d = NULL;
3721 uschar *buffer;
3722
3723 while ((buffer = get_config_line()))
3724   {
3725   uschar name[EXIM_DRIVERNAME_MAX];
3726   uschar *s;
3727
3728   /* Read the first name on the line and test for the start of a new driver. A
3729   macro definition indicates the end of the previous driver. If this isn't the
3730   start of a new driver, the line will be re-read. */
3731
3732   s = readconf_readname(name, sizeof(name), buffer);
3733
3734   /* Handle macro definition, first finishing off the initialization of the
3735   previous driver, if any. */
3736
3737   if (isupper(*name) && *s == '=')
3738     {
3739     if (d)
3740       {
3741       if (!d->driver_name)
3742         log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3743           "no driver defined for %s \"%s\"", class, d->name);
3744       /* s is using big_buffer, so this call had better not */
3745       (d->info->init)(d);
3746       d = NULL;
3747       }
3748     if (!macro_read_assignment(buffer)) exim_exit(EXIT_FAILURE);
3749     continue;
3750     }
3751
3752   /* If the line starts with a name terminated by a colon, we are at the
3753   start of the definition of a new driver. The rest of the line must be
3754   blank. */
3755
3756   if (*s++ == ':')
3757     {
3758     /* Finish off initializing the previous driver. */
3759
3760     if (d)
3761       {
3762       if (!d->driver_name)
3763         log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3764           "no driver defined for %s \"%s\"", class, d->name);
3765       (d->info->init)(d);
3766       }
3767
3768     /* Check that we haven't already got a driver of this name */
3769
3770     for (d = *anchor; d; d = d->next)
3771       if (Ustrcmp(name, d->name) == 0)
3772         log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3773           "there are two %ss called \"%s\"", class, name);
3774
3775     /* Set up a new driver instance data block on the chain, with
3776     its default values installed. */
3777
3778   {
3779   int old_pool = store_pool;
3780   if (Ustrncmp(class, "router", 7) == 0) store_pool = POOL_PERM;
3781     d = store_get(instance_size, FALSE);
3782   store_pool = old_pool;
3783   }
3784     memcpy(d, instance_default, instance_size);
3785     *p = d;
3786     p = &d->next;
3787     d->name = string_copy(name);
3788
3789     /* Clear out the "set" bits in the generic options */
3790
3791     for (int i = 0; i < driver_optionlist_count; i++)
3792       driver_optionlist[i].type &= ~opt_set;
3793
3794     /* Check nothing more on this line, then do the next loop iteration. */
3795
3796     Uskip_whitespace(&s);
3797     if (*s) extra_chars_error(s, US"driver name ", name, US"");
3798     continue;
3799     }
3800
3801   /* Not the start of a new driver. Give an error if we have not set up a
3802   current driver yet. */
3803
3804   if (!d)
3805     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s name missing", class);
3806
3807   /* First look to see if this is a generic option; if it is "driver",
3808   initialize the driver. If is it not a generic option, we can look for a
3809   private option provided that the driver has been previously set up. */
3810
3811   if (readconf_handle_option(buffer, driver_optionlist,
3812         driver_optionlist_count, d, NULL))
3813     {
3814     if (!d->info && d->driver_name)
3815       init_driver(d, drivers_available, size_of_info, class);
3816     }
3817
3818   /* Handle private options - pass the generic block because some may
3819   live therein. A flag with each option indicates if it is in the public
3820   block. */
3821
3822   else if (d->info)
3823     readconf_handle_option(buffer, d->info->options,
3824       *(d->info->options_count), d, US"option \"%s\" unknown");
3825
3826   /* The option is not generic and the driver name has not yet been given. */
3827
3828   else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option \"%s\" unknown "
3829     "(\"driver\" must be specified before any private options)", name);
3830   }
3831
3832 /* Run the initialization function for the final driver. */
3833
3834 if (d)
3835   {
3836   if (!d->driver_name)
3837     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3838       "no driver defined for %s \"%s\"", class, d->name);
3839   (d->info->init)(d);
3840   }
3841 }
3842
3843
3844
3845 /*************************************************
3846 *            Check driver dependency             *
3847 *************************************************/
3848
3849 /* This function is passed a driver instance and a string. It checks whether
3850 any of the string options for the driver contains the given string as an
3851 expansion variable.
3852
3853 Arguments:
3854   d        points to a driver instance block
3855   s        the string to search for
3856
3857 Returns:   TRUE if a dependency is found
3858 */
3859
3860 BOOL
3861 readconf_depends(driver_instance *d, uschar *s)
3862 {
3863 int count = *(d->info->options_count);
3864 uschar *ss;
3865
3866 for (optionlist * ol = d->info->options; ol < d->info->options + count; ol++)
3867   if ((ol->type & opt_mask) == opt_stringptr)
3868     {
3869     void * options_block = ol->type & opt_public ? (void *)d : d->options_block;
3870     uschar * value = *USS(US options_block + ol->v.offset);
3871
3872     if (value && (ss = Ustrstr(value, s)) != NULL)
3873       {
3874       if (ss <= value || (ss[-1] != '$' && ss[-1] != '{') ||
3875         isalnum(ss[Ustrlen(s)])) continue;
3876       DEBUG(D_transport) debug_printf("driver %s: \"%s\" option depends on %s\n",
3877         d->name, ol->name, s);
3878       return TRUE;
3879       }
3880     }
3881
3882 DEBUG(D_transport) debug_printf("driver %s does not depend on %s\n", d->name, s);
3883 return FALSE;
3884 }
3885
3886
3887
3888
3889 /*************************************************
3890 *      Decode an error type for retries          *
3891 *************************************************/
3892
3893 /* This function is global because it is also called from the main
3894 program when testing retry information. It decodes strings such as "quota_7d"
3895 into numerical error codes.
3896
3897 Arguments:
3898   pp           points to start of text
3899   p            points past end of text
3900   basic_errno  points to an int to receive the main error number
3901   more_errno   points to an int to receive the secondary error data
3902
3903 Returns:       NULL if decoded correctly; else points to error text
3904 */
3905
3906 uschar *
3907 readconf_retry_error(const uschar *pp, const uschar *p,
3908   int *basic_errno, int *more_errno)
3909 {
3910 int len;
3911 const uschar *q = pp;
3912 while (q < p && *q != '_') q++;
3913 len = q - pp;
3914
3915 if (len == 5 && strncmpic(pp, US"quota", len) == 0)
3916   {
3917   *basic_errno = ERRNO_EXIMQUOTA;
3918   if (q != p && (*more_errno = readconf_readtime(q+1, *p, FALSE)) < 0)
3919       return US"bad time value";
3920   }
3921
3922 else if (len == 7 && strncmpic(pp, US"refused", len) == 0)
3923   {
3924   *basic_errno = ECONNREFUSED;
3925   if (q != p)
3926     {
3927     if (strncmpic(q+1, US"MX", p-q-1) == 0) *more_errno = 'M';
3928     else if (strncmpic(q+1, US"A", p-q-1) == 0) *more_errno = 'A';
3929     else return US"A or MX expected after \"refused\"";
3930     }
3931   }
3932
3933 else if (len == 7 && strncmpic(pp, US"timeout", len) == 0)
3934   {
3935   *basic_errno = ETIMEDOUT;
3936   if (q != p)
3937     {
3938     int i;
3939     int xlen = p - q - 1;
3940     const uschar *x = q + 1;
3941
3942     static uschar *extras[] =
3943       { US"A", US"MX", US"connect", US"connect_A",  US"connect_MX" };
3944     static int values[] =
3945       { 'A',   'M',    RTEF_CTOUT,  RTEF_CTOUT|'A', RTEF_CTOUT|'M' };
3946
3947     for (i = 0; i < nelem(extras); i++)
3948       if (strncmpic(x, extras[i], xlen) == 0)
3949         {
3950         *more_errno = values[i];
3951         break;
3952         }
3953
3954     if (i >= nelem(extras))
3955       if (strncmpic(x, US"DNS", xlen) == 0)
3956         log_write(0, LOG_MAIN|LOG_PANIC, "\"timeout_dns\" is no longer "
3957           "available in retry rules (it has never worked) - treated as "
3958           "\"timeout\"");
3959       else
3960         return US"\"A\", \"MX\", or \"connect\" expected after \"timeout\"";
3961     }
3962   }
3963
3964 else if (strncmpic(pp, US"mail_4", 6) == 0 ||
3965          strncmpic(pp, US"rcpt_4", 6) == 0 ||
3966          strncmpic(pp, US"data_4", 6) == 0)
3967   {
3968   BOOL bad = FALSE;
3969   int x = 255;                           /* means "any 4xx code" */
3970   if (p != pp + 8) bad = TRUE; else
3971     {
3972     int a = pp[6], b = pp[7];
3973     if (isdigit(a))
3974       {
3975       x = (a - '0') * 10;
3976       if (isdigit(b)) x += b - '0';
3977       else if (b == 'x') x += 100;
3978       else bad = TRUE;
3979       }
3980     else if (a != 'x' || b != 'x') bad = TRUE;
3981     }
3982
3983   if (bad)
3984     return string_sprintf("%.4s_4 must be followed by xx, dx, or dd, where "
3985       "x is literal and d is any digit", pp);
3986
3987   *basic_errno = *pp == 'm' ? ERRNO_MAIL4XX :
3988                  *pp == 'r' ? ERRNO_RCPT4XX : ERRNO_DATA4XX;
3989   *more_errno = x << 8;
3990   }
3991
3992 else if (len == 4 && strncmpic(pp, US"auth", len) == 0 &&
3993          strncmpic(q+1, US"failed", p-q-1) == 0)
3994   *basic_errno = ERRNO_AUTHFAIL;
3995
3996 else if (strncmpic(pp, US"lost_connection", p - pp) == 0)
3997   *basic_errno = ERRNO_SMTPCLOSED;
3998
3999 else if (strncmpic(pp, US"tls_required", p - pp) == 0)
4000   *basic_errno = ERRNO_TLSREQUIRED;
4001
4002 else if (strncmpic(pp, US"lookup", p - pp) == 0)
4003   *basic_errno = ERRNO_UNKNOWNHOST;
4004
4005 else if (len != 1 || Ustrncmp(pp, "*", 1) != 0)
4006   return string_sprintf("unknown or malformed retry error \"%.*s\"", (int) (p-pp), pp);
4007
4008 return NULL;
4009 }
4010
4011
4012
4013
4014 /*************************************************
4015 *                Read retry information          *
4016 *************************************************/
4017
4018 /* Each line of retry information contains:
4019
4020 .  A domain name pattern or an address pattern;
4021
4022 .  An error name, possibly with additional data, or *;
4023
4024 .  An optional sequence of retry items, each consisting of an identifying
4025    letter, a cutoff time, and optional parameters.
4026
4027 All this is decoded and placed into a control block. */
4028
4029
4030 /* Subroutine to read an argument, preceded by a comma and terminated
4031 by comma, semicolon, whitespace, or newline. The types are: 0 = time value,
4032 1 = fixed point number (returned *1000).
4033
4034 Arguments:
4035   paddr     pointer to pointer to current character; updated
4036   type      0 => read a time; 1 => read a fixed point number
4037
4038 Returns:    time in seconds or fixed point number * 1000
4039 */
4040
4041 static int
4042 retry_arg(const uschar **paddr, int type)
4043 {
4044 const uschar *p = *paddr;
4045 const uschar *pp;
4046
4047 if (*p++ != ',') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma expected");
4048
4049 Uskip_whitespace(&p);
4050 pp = p;
4051 while (isalnum(*p) || (type == 1 && *p == '.')) p++;
4052
4053 if (*p != 0 && !isspace(*p) && *p != ',' && *p != ';')
4054   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma or semicolon expected");
4055
4056 *paddr = p;
4057 switch (type)
4058   {
4059   case 0: return readconf_readtime(pp, *p, FALSE);
4060   case 1: return readconf_readfixed(pp, *p);
4061   }
4062 return 0;    /* Keep picky compilers happy */
4063 }
4064
4065 /* The function proper */
4066
4067 void
4068 readconf_retries(void)
4069 {
4070 retry_config **chain = &retries;
4071 retry_config *next;
4072 const uschar *p;
4073
4074 while ((p = get_config_line()))
4075   {
4076   retry_rule **rchain;
4077   const uschar *pp;
4078   uschar *error;
4079
4080   next = store_get(sizeof(retry_config), FALSE);
4081   next->next = NULL;
4082   *chain = next;
4083   chain = &(next->next);
4084   next->basic_errno = next->more_errno = 0;
4085   next->senders = NULL;
4086   next->rules = NULL;
4087   rchain = &(next->rules);
4088
4089   next->pattern = string_dequote(&p);
4090   Uskip_whitespace(&p);
4091   pp = p;
4092   while (mac_isgraph(*p)) p++;
4093   if (p - pp <= 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4094     "missing error type in retry rule");
4095
4096   /* Test error names for things we understand. */
4097
4098   if ((error = readconf_retry_error(pp, p, &next->basic_errno,
4099        &next->more_errno)))
4100     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s", error);
4101
4102   /* There may be an optional address list of senders to be used as another
4103   constraint on the rule. This was added later, so the syntax is a bit of a
4104   fudge. Anything that is not a retry rule starting "F," or "G," is treated as
4105   an address list. */
4106
4107   Uskip_whitespace(&p);
4108   if (Ustrncmp(p, "senders", 7) == 0)
4109     {
4110     p += 7;
4111     Uskip_whitespace(&p);
4112     if (*p++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4113       "\"=\" expected after \"senders\" in retry rule");
4114     Uskip_whitespace(&p);
4115     next->senders = string_dequote(&p);
4116     }
4117
4118   /* Now the retry rules. Keep the maximum timeout encountered. */
4119
4120   Uskip_whitespace(&p);
4121
4122   while (*p)
4123     {
4124     retry_rule *rule = store_get(sizeof(retry_rule), FALSE);
4125     *rchain = rule;
4126     rchain = &(rule->next);
4127     rule->next = NULL;
4128     rule->rule = toupper(*p++);
4129     rule->timeout = retry_arg(&p, 0);
4130     if (rule->timeout > retry_maximum_timeout)
4131       retry_maximum_timeout = rule->timeout;
4132
4133     switch (rule->rule)
4134       {
4135       case 'F':   /* Fixed interval */
4136         rule->p1 = retry_arg(&p, 0);
4137         break;
4138
4139       case 'G':   /* Geometrically increasing intervals */
4140       case 'H':   /* Ditto, but with randomness */
4141         rule->p1 = retry_arg(&p, 0);
4142         rule->p2 = retry_arg(&p, 1);
4143         break;
4144
4145       default:
4146         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unknown retry rule letter");
4147         break;
4148       }
4149
4150     if (rule->timeout <= 0 || rule->p1 <= 0 ||
4151           (rule->rule != 'F' && rule->p2 < 1000))
4152       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4153         "bad parameters for retry rule");
4154
4155     if (Uskip_whitespace(&p) == ';')
4156       {
4157       p++;
4158       Uskip_whitespace(&p);
4159       }
4160     else if (*p)
4161       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "semicolon expected");
4162     }
4163   }
4164 }
4165
4166
4167
4168 /*************************************************
4169 *         Initialize authenticators              *
4170 *************************************************/
4171
4172 /* Read the authenticators section of the configuration file.
4173
4174 Arguments:   none
4175 Returns:     nothing
4176 */
4177
4178 static void
4179 auths_init(void)
4180 {
4181 #ifndef DISABLE_PIPE_CONNECT
4182 int nauths = 0;
4183 #endif
4184
4185 readconf_driver_init(US"authenticator",
4186   (driver_instance **)(&auths),      /* chain anchor */
4187   (driver_info *)auths_available,    /* available drivers */
4188   sizeof(auth_info),                 /* size of info block */
4189   &auth_defaults,                    /* default values for generic options */
4190   sizeof(auth_instance),             /* size of instance block */
4191   optionlist_auths,                  /* generic options */
4192   optionlist_auths_size);
4193
4194 for (auth_instance * au = auths; au; au = au->next)
4195   {
4196   if (!au->public_name)
4197     log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "no public name specified for "
4198       "the %s authenticator", au->name);
4199
4200   for (auth_instance * bu = au->next; bu; bu = bu->next)
4201     if (strcmpic(au->public_name, bu->public_name) == 0)
4202       if ((au->client && bu->client) || (au->server && bu->server))
4203         log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "two %s authenticators "
4204           "(%s and %s) have the same public name (%s)",
4205           au->client ? US"client" : US"server", au->name, bu->name,
4206           au->public_name);
4207 #ifndef DISABLE_PIPE_CONNECT
4208   nauths++;
4209 #endif
4210   }
4211 #ifndef DISABLE_PIPE_CONNECT
4212 f.smtp_in_early_pipe_no_auth = nauths > 16;
4213 #endif
4214 }
4215
4216
4217
4218
4219 /*************************************************
4220 *             Read ACL information               *
4221 *************************************************/
4222
4223 /* If this run of Exim is not doing something that involves receiving a
4224 message, we can just skip over the ACL information. No need to parse it.
4225
4226 First, we have a function for acl_read() to call back to get the next line. We
4227 need to remember the line we passed, because at the end it will contain the
4228 name of the next ACL. */
4229
4230 static uschar *acl_line;
4231
4232 static uschar *
4233 acl_callback(void)
4234 {
4235 acl_line = get_config_line();
4236 return acl_line;
4237 }
4238
4239
4240 /* Now the main function:
4241
4242 Arguments:    none
4243 Returns:      nothing
4244 */
4245
4246 static void
4247 readconf_acl(void)
4248 {
4249 uschar *p;
4250
4251 /* Read each ACL and add it into the tree. Macro (re)definitions are allowed
4252 between ACLs. */
4253
4254 acl_line = get_config_line();
4255
4256 while(acl_line)
4257   {
4258   uschar name[EXIM_DRIVERNAME_MAX];
4259   tree_node *node;
4260   uschar *error;
4261
4262   p = readconf_readname(name, sizeof(name), acl_line);
4263   if (isupper(*name) && *p == '=')
4264     {
4265     if (!macro_read_assignment(acl_line)) exim_exit(EXIT_FAILURE);
4266     acl_line = get_config_line();
4267     continue;
4268     }
4269
4270   if (*p != ':' || name[0] == 0)
4271     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing or malformed ACL name");
4272
4273   node = store_get(sizeof(tree_node) + Ustrlen(name), is_tainted(name));
4274   Ustrcpy(node->name, name);
4275   if (!tree_insertnode(&acl_anchor, node))
4276     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4277       "there are two ACLs called \"%s\"", name);
4278
4279   node->data.ptr = acl_read(acl_callback, &error);
4280
4281   if (node->data.ptr == NULL && error != NULL)
4282     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "error in ACL: %s", error);
4283   }
4284 }
4285
4286
4287
4288 /*************************************************
4289 *     Read configuration for local_scan()        *
4290 *************************************************/
4291
4292 /* This function is called after "begin local_scan" is encountered in the
4293 configuration file. If the local_scan() function allows for configuration
4294 options, we can process them. Otherwise, we expire in a panic.
4295
4296 Arguments:  none
4297 Returns:    nothing
4298 */
4299
4300 static void
4301 local_scan_init(void)
4302 {
4303 #ifndef LOCAL_SCAN_HAS_OPTIONS
4304 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "local_scan() options not supported: "
4305   "(LOCAL_SCAN_HAS_OPTIONS not defined in Local/Makefile)");
4306 #else
4307
4308 uschar *p;
4309 while ((p = get_config_line()))
4310   (void) readconf_handle_option(p, local_scan_options, local_scan_options_count,
4311     NULL, US"local_scan option \"%s\" unknown");
4312 #endif
4313 }
4314
4315
4316
4317 /*************************************************
4318 *     Read rest of configuration (after main)    *
4319 *************************************************/
4320
4321 /* This function reads the rest of the runtime configuration, after the main
4322 configuration. It is called only when actually needed. Each subsequent section
4323 of the configuration starts with a line of the form
4324
4325   begin name
4326
4327 where the name is "routers", "transports", etc. A section is terminated by
4328 hitting the next "begin" line, and the next name is left in next_section.
4329 Because it may confuse people as to whether the names are singular or plural,
4330 we add "s" if it's missing. There is always enough room in next_section for
4331 this. This function is basically just a switch.
4332
4333 Arguments:   none
4334 Returns:     nothing
4335 */
4336
4337 static uschar *section_list[] = {
4338   US"acls",
4339   US"authenticators",
4340   US"local_scans",
4341   US"retrys",
4342   US"rewrites",
4343   US"routers",
4344   US"transports"};
4345
4346 void
4347 readconf_rest(void)
4348 {
4349 int had = 0;
4350
4351 while(next_section[0] != 0)
4352   {
4353   int bit;
4354   int first = 0;
4355   int last = nelem(section_list);
4356   int mid = last/2;
4357   int n = Ustrlen(next_section);
4358
4359   if (tolower(next_section[n-1]) != 's') Ustrcpy(next_section+n, US"s");
4360
4361   for (;;)
4362     {
4363     int c = strcmpic(next_section, section_list[mid]);
4364     if (c == 0) break;
4365     if (c > 0) first = mid + 1; else last = mid;
4366     if (first >= last)
4367       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4368         "\"%.*s\" is not a known configuration section name", n, next_section);
4369     mid = (last + first)/2;
4370     }
4371
4372   bit = 1 << mid;
4373   if (((had ^= bit) & bit) == 0)
4374     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4375       "\"%.*s\" section is repeated in the configuration file", n,
4376         next_section);
4377
4378   switch(mid)
4379     {
4380     case 0: readconf_acl(); break;
4381     case 1: auths_init(); break;
4382     case 2: local_scan_init(); break;
4383     case 3: readconf_retries(); break;
4384     case 4: readconf_rewrites(); break;
4385     case 5: route_init(); break;
4386     case 6: transport_init(); break;
4387     }
4388   }
4389
4390 (void)fclose(config_file);
4391 }
4392
4393 /* Init the storage for the pre-parsed config lines */
4394 void
4395 readconf_save_config(const uschar *s)
4396 {
4397 save_config_line(string_sprintf("# Exim Configuration (%s)",
4398   f.running_in_test_harness ? US"X" : s));
4399 }
4400
4401 static void
4402 save_config_position(const uschar *file, int line)
4403 {
4404 save_config_line(string_sprintf("# %d \"%s\"", line, file));
4405 }
4406
4407 /* Append a pre-parsed logical line to the config lines store,
4408 this operates on a global (static) list that holds all the pre-parsed
4409 config lines, we do no further processing here, output formatting and
4410 honouring of <hide> or macros will be done during output */
4411
4412 static void
4413 save_config_line(const uschar* line)
4414 {
4415 static config_line_item *current;
4416 config_line_item *next;
4417
4418 next = (config_line_item*) store_get(sizeof(config_line_item), FALSE);
4419 next->line = string_copy(line);
4420 next->next = NULL;
4421
4422 if (!config_lines) config_lines = next;
4423 else current->next = next;
4424
4425 current = next;
4426 }
4427
4428 /* List the parsed config lines, care about nice formatting and
4429 hide the <hide> values unless we're the admin user */
4430 void
4431 print_config(BOOL admin, BOOL terse)
4432 {
4433 const int TS = terse ? 0 : 2;
4434 int indent = 0;
4435
4436 for (config_line_item * i = config_lines; i; i = i->next)
4437   {
4438   uschar *current;
4439   uschar *p;
4440
4441   /* skip over to the first non-space */
4442   for (current = i->line; *current && isspace(*current); ++current)
4443     ;
4444
4445   if (*current == '\0')
4446     continue;
4447
4448   /* Collapse runs of spaces. We stop this if we encounter one of the
4449    * following characters: "'$, as this may indicate careful formatting */
4450   for (p = current; *p; ++p)
4451     {
4452     uschar *next;
4453     if (!isspace(*p)) continue;
4454     if (*p != ' ') *p = ' ';
4455
4456     for (next = p; isspace(*next); ++next)
4457       ;
4458
4459     if (next - p > 1)
4460       memmove(p+1, next, Ustrlen(next)+1);
4461
4462     if (*next == '"' || *next == '\'' || *next == '$')
4463       break;
4464     }
4465
4466   /* # lines */
4467   if (current[0] == '#')
4468     puts(CCS current);
4469
4470   /* begin lines are left aligned */
4471   else if (Ustrncmp(current, "begin", 5) == 0 && isspace(current[5]))
4472     {
4473     if (!terse) puts("");
4474     puts(CCS current);
4475     indent = TS;
4476     }
4477
4478   /* router/acl/transport block names */
4479   else if (current[Ustrlen(current)-1] == ':' && !Ustrchr(current, '='))
4480     {
4481     if (!terse) puts("");
4482     printf("%*s%s\n", TS, "", current);
4483     indent = 2 * TS;
4484     }
4485
4486   /* hidden lines (all MACROS or lines prefixed with "hide") */
4487   else if (  !admin
4488           && (  isupper(*current)
4489              || Ustrncmp(current, "hide", 4) == 0 && isspace(current[4])
4490              )
4491           )
4492     {
4493     if ((p = Ustrchr(current, '=')))
4494       {
4495       *p = '\0';
4496       printf("%*s%s= %s\n", indent, "", current, CCS hidden);
4497       }
4498     /* e.g.: hide split_spool_directory */
4499     else
4500       printf("%*s\n", indent, CCS hidden);
4501     }
4502
4503   else
4504     /* rest is public */
4505     printf("%*s%s\n", indent, "", current);
4506   }
4507 }
4508
4509 #endif  /*!MACRO_PREDEF*/
4510 /* vi: aw ai sw=2
4511 */
4512 /* End of readconf.c */