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