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