src/src/readconf.c

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