src/src/readconf.c

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