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