src/src/readconf.c

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