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