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