src/src/readconf.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2014 */
   6 /* See the file NOTICE for conditions of use and distribution. */
   7
   8 /* Functions for reading the configuration file, and for displaying
   9 overall configuration values. Thanks to Brian Candler for the original
  10 implementation of the conditional .ifdef etc. */
  11
  12 #include "exim.h"
  13
  14 #define CSTATE_STACK_SIZE 10
  15
  16
  17 /* Structure for chain (stack) of .included files */
  18
  19 typedef struct config_file_item {
  20   struct config_file_item *next;
  21   uschar *filename;
  22   FILE *file;
  23   int lineno;
  24 } config_file_item;
  25
  26 /* Structure of table of conditional words and their state transitions */
  27
  28 typedef struct cond_item {
  29   uschar *name;
  30   int    namelen;
  31   int    action1;
  32   int    action2;
  33   int    pushpop;
  34 } cond_item;
  35
  36 /* Structure of table of syslog facility names and values */
  37
  38 typedef struct syslog_fac_item {
  39   uschar *name;
  40   int    value;
  41 } syslog_fac_item;
  42
  43
  44 /* Static variables */
  45
  46 static config_file_item *config_file_stack = NULL;  /* For includes */
  47
  48 static uschar *syslog_facility_str  = NULL;
  49 static uschar next_section[24];
  50 static uschar time_buffer[24];
  51
  52 /* State variables for conditional loading (.ifdef / .else / .endif) */
  53
  54 static int cstate = 0;
  55 static int cstate_stack_ptr = -1;
  56 static int cstate_stack[CSTATE_STACK_SIZE];
  57
  58 /* Table of state transitions for handling conditional inclusions. There are
  59 four possible state transitions:
  60
  61   .ifdef true
  62   .ifdef false
  63   .elifdef true  (or .else)
  64   .elifdef false
  65
  66 .endif just causes the previous cstate to be popped off the stack */
  67
  68 static int next_cstate[3][4] =
  69   {
  70   /* State 0: reading from file, or reading until next .else or .endif */
  71   { 0, 1, 2, 2 },
  72   /* State 1: condition failed, skipping until next .else or .endif */
  73   { 2, 2, 0, 1 },
  74   /* State 2: skipping until .endif */
  75   { 2, 2, 2, 2 },
  76   };
  77
  78 /* Table of conditionals and the states to set. For each name, there are four
  79 values: the length of the name (to save computing it each time), the state to
  80 set if a macro was found in the line, the state to set if a macro was not found
  81 in the line, and a stack manipulation setting which is:
  82
  83   -1   pull state value off the stack
  84    0   don't alter the stack
  85   +1   push value onto stack, before setting new state
  86 */
  87
  88 static cond_item cond_list[] = {
  89   { US"ifdef",    5, 0, 1,  1 },
  90   { US"ifndef",   6, 1, 0,  1 },
  91   { US"elifdef",  7, 2, 3,  0 },
  92   { US"elifndef", 8, 3, 2,  0 },
  93   { US"else",     4, 2, 2,  0 },
  94   { US"endif",    5, 0, 0, -1 }
  95 };
  96
  97 static int cond_list_size = sizeof(cond_list)/sizeof(cond_item);
  98
  99 /* Table of syslog facility names and their values */
 100
 101 static syslog_fac_item syslog_list[] = {
 102   { US"mail",   LOG_MAIL },
 103   { US"user",   LOG_USER },
 104   { US"news",   LOG_NEWS },
 105   { US"uucp",   LOG_UUCP },
 106   { US"local0", LOG_LOCAL0 },
 107   { US"local1", LOG_LOCAL1 },
 108   { US"local2", LOG_LOCAL2 },
 109   { US"local3", LOG_LOCAL3 },
 110   { US"local4", LOG_LOCAL4 },
 111   { US"local5", LOG_LOCAL5 },
 112   { US"local6", LOG_LOCAL6 },
 113   { US"local7", LOG_LOCAL7 },
 114   { US"daemon", LOG_DAEMON }
 115 };
 116
 117 static int syslog_list_size = sizeof(syslog_list)/sizeof(syslog_fac_item);
 118
 119
 120
 121
 122 /*************************************************
 123 *           Main configuration options           *
 124 *************************************************/
 125
 126 /* The list of options that can be set in the main configuration file. This
 127 must be in alphabetic order because it is searched by binary chop. */
 128
 129 static optionlist optionlist_config[] = {
 130   { "*set_exim_group",          opt_bool|opt_hidden, &exim_gid_set },
 131   { "*set_exim_user",           opt_bool|opt_hidden, &exim_uid_set },
 132   { "*set_system_filter_group", opt_bool|opt_hidden, &system_filter_gid_set },
 133   { "*set_system_filter_user",  opt_bool|opt_hidden, &system_filter_uid_set },
 134   { "accept_8bitmime",          opt_bool,        &accept_8bitmime },
 135   { "acl_not_smtp",             opt_stringptr,   &acl_not_smtp },
 136 #ifdef WITH_CONTENT_SCAN
 137   { "acl_not_smtp_mime",        opt_stringptr,   &acl_not_smtp_mime },
 138 #endif
 139   { "acl_not_smtp_start",       opt_stringptr,   &acl_not_smtp_start },
 140   { "acl_smtp_auth",            opt_stringptr,   &acl_smtp_auth },
 141   { "acl_smtp_connect",         opt_stringptr,   &acl_smtp_connect },
 142   { "acl_smtp_data",            opt_stringptr,   &acl_smtp_data },
 143 #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)
 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 (ol->type & opt_rep_str)
1566       {
1567       uschar sep = Ustrncmp(name, "headers_add", 11)==0 ? '\n' : ':';
1568       uschar * cp;
1569
1570       /* Strip trailing whitespace and seperators */
1571       for (cp = sptr + Ustrlen(sptr) - 1;
1572           cp >= sptr && (*cp == '\n' || *cp == '\t' || *cp == ' ' || *cp == sep);
1573           cp--) *cp = '\0';
1574
1575       if (cp >= sptr)
1576         *str_target = string_copy_malloc(
1577                       *str_target ? string_sprintf("%s%c%s", *str_target, sep, sptr)
1578                                   : sptr);
1579       }
1580     else
1581       {
1582       *str_target = sptr;
1583       freesptr = FALSE;
1584       }
1585     break;
1586
1587     case opt_rewrite:
1588     if (data_block == NULL)
1589       *((uschar **)(ol->value)) = sptr;
1590     else
1591       *((uschar **)((uschar *)data_block + (long int)(ol->value))) = sptr;
1592     freesptr = FALSE;
1593     if (type == opt_rewrite)
1594       {
1595       int sep = 0;
1596       int *flagptr;
1597       uschar *p = sptr;
1598       rewrite_rule **chain;
1599       optionlist *ol3;
1600
1601       sprintf(CS name2, "*%.50s_rules", name);
1602       ol2 = find_option(name2, oltop, last);
1603       sprintf(CS name2, "*%.50s_flags", name);
1604       ol3 = find_option(name2, oltop, last);
1605
1606       if (ol2 == NULL || ol3 == NULL)
1607         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1608           "rewrite rules not available for driver");
1609
1610       if (data_block == NULL)
1611         {
1612         chain = (rewrite_rule **)(ol2->value);
1613         flagptr = (int *)(ol3->value);
1614         }
1615       else
1616         {
1617         chain = (rewrite_rule **)((uschar *)data_block + (long int)(ol2->value));
1618         flagptr = (int *)((uschar *)data_block + (long int)(ol3->value));
1619         }
1620
1621       while ((p = string_nextinlist(&sptr, &sep, big_buffer, BIG_BUFFER_SIZE))
1622               != NULL)
1623         {
1624         rewrite_rule *next = readconf_one_rewrite(p, flagptr, FALSE);
1625         *chain = next;
1626         chain = &(next->next);
1627         }
1628
1629       if ((*flagptr & (rewrite_all_envelope | rewrite_smtp)) != 0)
1630         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "rewrite rule specifies a "
1631           "non-header rewrite - not allowed at transport time -");
1632       }
1633     break;
1634
1635     /* If it was an expanded uid, see if there is any expansion to be
1636     done by checking for the presence of a $ character. If there is, save it
1637     in the corresponding *expand_user option field. Otherwise, fall through
1638     to treat it as a fixed uid. Ensure mutual exclusivity of the two kinds
1639     of data. */
1640
1641     case opt_expand_uid:
1642     sprintf(CS name2, "*expand_%.50s", name);
1643     ol2 = find_option(name2, oltop, last);
1644     if (ol2 != NULL)
1645       {
1646       uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
1647
1648       if (data_block == NULL)
1649         *((uschar **)(ol2->value)) = ss;
1650       else
1651         *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = ss;
1652
1653       if (ss != NULL)
1654         {
1655         *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1656         freesptr = FALSE;
1657         break;
1658         }
1659       }
1660
1661     /* Look up a fixed uid, and also make use of the corresponding gid
1662     if a passwd entry is returned and the gid has not been set. */
1663
1664     case opt_uid:
1665     if (!route_finduser(sptr, &pw, &uid))
1666       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found", sptr);
1667     if (data_block == NULL)
1668       *((uid_t *)(ol->value)) = uid;
1669     else
1670       *((uid_t *)((uschar *)data_block + (long int)(ol->value))) = uid;
1671
1672     /* Set the flag indicating a fixed value is set */
1673
1674     *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1675
1676     /* Handle matching gid if we have a passwd entry: done by finding the
1677     same name with terminating "user" changed to "group"; if not found,
1678     ignore. Also ignore if the value is already set. */
1679
1680     if (pw == NULL) break;
1681     Ustrcpy(name+Ustrlen(name)-4, "group");
1682     ol2 = find_option(name, oltop, last);
1683     if (ol2 != NULL && ((ol2->type & opt_mask) == opt_gid ||
1684         (ol2->type & opt_mask) == opt_expand_gid))
1685       {
1686       BOOL *set_flag = get_set_flag(name, oltop, last, data_block);
1687       if (! *set_flag)
1688         {
1689         if (data_block == NULL)
1690           *((gid_t *)(ol2->value)) = pw->pw_gid;
1691         else
1692           *((gid_t *)((uschar *)data_block + (long int)(ol2->value))) = pw->pw_gid;
1693         *set_flag = TRUE;
1694         }
1695       }
1696     break;
1697
1698     /* If it was an expanded gid, see if there is any expansion to be
1699     done by checking for the presence of a $ character. If there is, save it
1700     in the corresponding *expand_user option field. Otherwise, fall through
1701     to treat it as a fixed gid. Ensure mutual exclusivity of the two kinds
1702     of data. */
1703
1704     case opt_expand_gid:
1705     sprintf(CS name2, "*expand_%.50s", name);
1706     ol2 = find_option(name2, oltop, last);
1707     if (ol2 != NULL)
1708       {
1709       uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
1710
1711       if (data_block == NULL)
1712         *((uschar **)(ol2->value)) = ss;
1713       else
1714         *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = ss;
1715
1716       if (ss != NULL)
1717         {
1718         *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1719         freesptr = FALSE;
1720         break;
1721         }
1722       }
1723
1724     /* Handle freestanding gid */
1725
1726     case opt_gid:
1727     if (!route_findgroup(sptr, &gid))
1728       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found", sptr);
1729     if (data_block == NULL)
1730       *((gid_t *)(ol->value)) = gid;
1731     else
1732       *((gid_t *)((uschar *)data_block + (long int)(ol->value))) = gid;
1733     *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1734     break;
1735
1736     /* If it was a uid list, look up each individual entry, and build
1737     a vector of uids, with a count in the first element. Put the vector
1738     in malloc store so we can free the string. (We are reading into
1739     permanent store already.) */
1740
1741     case opt_uidlist:
1742       {
1743       int count = 1;
1744       uid_t *list;
1745       int ptr = 0;
1746       uschar *p;
1747       uschar *op = expand_string (sptr);
1748
1749       if (op == NULL)
1750         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
1751           name, expand_string_message);
1752
1753       p = op;
1754       if (*p != 0) count++;
1755       while (*p != 0) if (*p++ == ':' && *p != 0) count++;
1756       list = store_malloc(count*sizeof(uid_t));
1757       list[ptr++] = (uid_t)(count - 1);
1758
1759       if (data_block == NULL)
1760         *((uid_t **)(ol->value)) = list;
1761       else
1762         *((uid_t **)((uschar *)data_block + (long int)(ol->value))) = list;
1763
1764       p = op;
1765       while (count-- > 1)
1766         {
1767         int sep = 0;
1768         (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
1769         if (!route_finduser(big_buffer, NULL, &uid))
1770           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found",
1771             big_buffer);
1772         list[ptr++] = uid;
1773         }
1774       }
1775     break;
1776
1777     /* If it was a gid list, look up each individual entry, and build
1778     a vector of gids, with a count in the first element. Put the vector
1779     in malloc store so we can free the string. (We are reading into permanent
1780     store already.) */
1781
1782     case opt_gidlist:
1783       {
1784       int count = 1;
1785       gid_t *list;
1786       int ptr = 0;
1787       uschar *p;
1788       uschar *op = expand_string (sptr);
1789
1790       if (op == NULL)
1791         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
1792           name, expand_string_message);
1793
1794       p = op;
1795       if (*p != 0) count++;
1796       while (*p != 0) if (*p++ == ':' && *p != 0) count++;
1797       list = store_malloc(count*sizeof(gid_t));
1798       list[ptr++] = (gid_t)(count - 1);
1799
1800       if (data_block == NULL)
1801         *((gid_t **)(ol->value)) = list;
1802       else
1803         *((gid_t **)((uschar *)data_block + (long int)(ol->value))) = list;
1804
1805       p = op;
1806       while (count-- > 1)
1807         {
1808         int sep = 0;
1809         (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
1810         if (!route_findgroup(big_buffer, &gid))
1811           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found",
1812             big_buffer);
1813         list[ptr++] = gid;
1814         }
1815       }
1816     break;
1817     }
1818
1819   /* Release store if the value of the string doesn't need to be kept. */
1820
1821   if (freesptr) store_reset(reset_point);
1822   break;
1823
1824   /* Expanded boolean: if no characters follow, or if there are no dollar
1825   characters, this is a fixed-valued boolean, and we fall through. Otherwise,
1826   save the string for later expansion in the alternate place. */
1827
1828   case opt_expand_bool:
1829   if (*s != 0 && Ustrchr(s, '$') != 0)
1830     {
1831     sprintf(CS name2, "*expand_%.50s", name);
1832     ol2 = find_option(name2, oltop, last);
1833     if (ol2 != NULL)
1834       {
1835       reset_point = sptr = read_string(s, name);
1836       if (data_block == NULL)
1837         *((uschar **)(ol2->value)) = sptr;
1838       else
1839         *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = sptr;
1840       freesptr = FALSE;
1841       break;
1842       }
1843     }
1844   /* Fall through */
1845
1846   /* Boolean: if no characters follow, the value is boolvalue. Otherwise
1847   look for yes/not/true/false. Some booleans are stored in a single bit in
1848   a single int. There's a special fudge for verify settings; without a suffix
1849   they set both xx_sender and xx_recipient. The table points to the sender
1850   value; search subsequently for the recipient. There's another special case:
1851   opt_bool_set also notes when a boolean has been set. */
1852
1853   case opt_bool:
1854   case opt_bit:
1855   case opt_bool_verify:
1856   case opt_bool_set:
1857   if (*s != 0)
1858     {
1859     s = readconf_readname(name2, 64, s);
1860     if (strcmpic(name2, US"true") == 0 || strcmpic(name2, US"yes") == 0)
1861       boolvalue = TRUE;
1862     else if (strcmpic(name2, US"false") == 0 || strcmpic(name2, US"no") == 0)
1863       boolvalue = FALSE;
1864     else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1865       "\"%s\" is not a valid value for the \"%s\" option", name2, name);
1866     if (*s != 0) extra_chars_error(s, string_sprintf("\"%s\" ", name2),
1867       US"for boolean option ", name);
1868     }
1869
1870   /* Handle single-bit type. */
1871
1872   if (type == opt_bit)
1873     {
1874     int bit = 1 << ((ol->type >> 16) & 31);
1875     int *ptr = (data_block == NULL)?
1876       (int *)(ol->value) :
1877       (int *)((uschar *)data_block + (long int)ol->value);
1878     if (boolvalue) *ptr |= bit; else *ptr &= ~bit;
1879     break;
1880     }
1881
1882   /* Handle full BOOL types */
1883
1884   if (data_block == NULL)
1885     *((BOOL *)(ol->value)) = boolvalue;
1886   else
1887     *((BOOL *)((uschar *)data_block + (long int)(ol->value))) = boolvalue;
1888
1889   /* Verify fudge */
1890
1891   if (type == opt_bool_verify)
1892     {
1893     sprintf(CS name2, "%.50s_recipient", name + offset);
1894     ol2 = find_option(name2, oltop, last);
1895     if (ol2 != NULL)
1896       {
1897       if (data_block == NULL)
1898         *((BOOL *)(ol2->value)) = boolvalue;
1899       else
1900         *((BOOL *)((uschar *)data_block + (long int)(ol2->value))) = boolvalue;
1901       }
1902     }
1903
1904   /* Note that opt_bool_set type is set, if there is somewhere to do so */
1905
1906   else if (type == opt_bool_set)
1907     {
1908     sprintf(CS name2, "*set_%.50s", name + offset);
1909     ol2 = find_option(name2, oltop, last);
1910     if (ol2 != NULL)
1911       {
1912       if (data_block == NULL)
1913         *((BOOL *)(ol2->value)) = TRUE;
1914       else
1915         *((BOOL *)((uschar *)data_block + (long int)(ol2->value))) = TRUE;
1916       }
1917     }
1918   break;
1919
1920   /* Octal integer */
1921
1922   case opt_octint:
1923   intbase = 8;
1924   inttype = US"octal ";
1925
1926   /*  Integer: a simple(ish) case; allow octal and hex formats, and
1927   suffixes K and M. The different types affect output, not input. */
1928
1929   case opt_mkint:
1930   case opt_int:
1931     {
1932     uschar *endptr;
1933     long int lvalue;
1934
1935     errno = 0;
1936     lvalue = strtol(CS s, CSS &endptr, intbase);
1937
1938     if (endptr == s)
1939       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
1940         inttype, name);
1941
1942     if (errno != ERANGE)
1943       {
1944       if (tolower(*endptr) == 'k')
1945         {
1946         if (lvalue > INT_MAX/1024 || lvalue < INT_MIN/1024) errno = ERANGE;
1947           else lvalue *= 1024;
1948         endptr++;
1949         }
1950       else if (tolower(*endptr) == 'm')
1951         {
1952         if (lvalue > INT_MAX/(1024*1024) || lvalue < INT_MIN/(1024*1024))
1953           errno = ERANGE;
1954         else lvalue *= 1024*1024;
1955         endptr++;
1956         }
1957       }
1958
1959     if (errno == ERANGE || lvalue > INT_MAX || lvalue < INT_MIN)
1960       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1961         "absolute value of integer \"%s\" is too large (overflow)", s);
1962
1963     while (isspace(*endptr)) endptr++;
1964     if (*endptr != 0)
1965       extra_chars_error(endptr, inttype, US"integer value for ", name);
1966
1967     value = (int)lvalue;
1968     }
1969
1970   if (data_block == NULL)
1971     *((int *)(ol->value)) = value;
1972   else
1973     *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
1974   break;
1975
1976   /*  Integer held in K: again, allow octal and hex formats, and suffixes K and
1977   M. */
1978
1979   case opt_Kint:
1980     {
1981     uschar *endptr;
1982     errno = 0;
1983     value = strtol(CS s, CSS &endptr, intbase);
1984
1985     if (endptr == s)
1986       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
1987         inttype, name);
1988
1989     if (errno != ERANGE)
1990       {
1991       if (tolower(*endptr) == 'm')
1992         {
1993         if (value > INT_MAX/1024 || value < INT_MIN/1024) errno = ERANGE;
1994           else value *= 1024;
1995         endptr++;
1996         }
1997       else if (tolower(*endptr) == 'k')
1998         {
1999         endptr++;
2000         }
2001       else
2002         {
2003         value = (value + 512)/1024;
2004         }
2005       }
2006
2007     if (errno == ERANGE) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2008       "absolute value of integer \"%s\" is too large (overflow)", s);
2009
2010     while (isspace(*endptr)) endptr++;
2011     if (*endptr != 0)
2012       extra_chars_error(endptr, inttype, US"integer value for ", name);
2013     }
2014
2015   if (data_block == NULL)
2016     *((int *)(ol->value)) = value;
2017   else
2018     *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2019   break;
2020
2021   /*  Fixed-point number: held to 3 decimal places. */
2022
2023   case opt_fixed:
2024   if (sscanf(CS s, "%d%n", &value, &count) != 1)
2025     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2026       "fixed-point number expected for %s", name);
2027
2028   if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2029     "integer \"%s\" is too large (overflow)", s);
2030
2031   value *= 1000;
2032
2033   if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2034     "integer \"%s\" is too large (overflow)", s);
2035
2036   if (s[count] == '.')
2037     {
2038     int d = 100;
2039     while (isdigit(s[++count]))
2040       {
2041       value += (s[count] - '0') * d;
2042       d /= 10;
2043       }
2044     }
2045
2046   while (isspace(s[count])) count++;
2047
2048   if (s[count] != 0)
2049     extra_chars_error(s+count, US"fixed-point value for ", name, US"");
2050
2051   if (data_block == NULL)
2052     *((int *)(ol->value)) = value;
2053   else
2054     *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2055   break;
2056
2057   /* There's a special routine to read time values. */
2058
2059   case opt_time:
2060   value = readconf_readtime(s, 0, FALSE);
2061   if (value < 0)
2062     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2063       name);
2064   if (data_block == NULL)
2065     *((int *)(ol->value)) = value;
2066   else
2067     *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2068   break;
2069
2070   /* A time list is a list of colon-separated times, with the first
2071   element holding the size of the list and the second the number of
2072   entries used. */
2073
2074   case opt_timelist:
2075     {
2076     int count = 0;
2077     int *list = (data_block == NULL)?
2078       (int *)(ol->value) :
2079       (int *)((uschar *)data_block + (long int)(ol->value));
2080
2081     if (*s != 0) for (count = 1; count <= list[0] - 2; count++)
2082       {
2083       int terminator = 0;
2084       uschar *snext = Ustrchr(s, ':');
2085       if (snext != NULL)
2086         {
2087         uschar *ss = snext;
2088         while (ss > s && isspace(ss[-1])) ss--;
2089         terminator = *ss;
2090         }
2091       value = readconf_readtime(s, terminator, FALSE);
2092       if (value < 0)
2093         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2094           name);
2095       if (count > 1 && value <= list[count])
2096         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2097           "time value out of order for %s", name);
2098       list[count+1] = value;
2099       if (snext == NULL) break;
2100       s = snext + 1;
2101       while (isspace(*s)) s++;
2102       }
2103
2104     if (count > list[0] - 2)
2105       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many time values for %s",
2106         name);
2107     if (count > 0 && list[2] == 0) count = 0;
2108     list[1] = count;
2109     }
2110
2111   break;
2112   }
2113
2114 return TRUE;
2115 }
2116
2117
2118
2119 /*************************************************
2120 *               Print a time value               *
2121 *************************************************/
2122
2123 /*
2124 Argument:  a time value in seconds
2125 Returns:   pointer to a fixed buffer containing the time as a string,
2126            in readconf_readtime() format
2127 */
2128
2129 uschar *
2130 readconf_printtime(int t)
2131 {
2132 int s, m, h, d, w;
2133 uschar *p = time_buffer;
2134
2135 if (t < 0)
2136   {
2137   *p++ = '-';
2138   t = -t;
2139   }
2140
2141 s = t % 60;
2142 t /= 60;
2143 m = t % 60;
2144 t /= 60;
2145 h = t % 24;
2146 t /= 24;
2147 d = t % 7;
2148 w = t/7;
2149
2150 if (w > 0) { sprintf(CS p, "%dw", w); while (*p) p++; }
2151 if (d > 0) { sprintf(CS p, "%dd", d); while (*p) p++; }
2152 if (h > 0) { sprintf(CS p, "%dh", h); while (*p) p++; }
2153 if (m > 0) { sprintf(CS p, "%dm", m); while (*p) p++; }
2154 if (s > 0 || p == time_buffer) sprintf(CS p, "%ds", s);
2155
2156 return time_buffer;
2157 }
2158
2159
2160
2161 /*************************************************
2162 *      Print an individual option value          *
2163 *************************************************/
2164
2165 /* This is used by the -bP option, so prints to the standard output.
2166 The entire options list is passed in as an argument, because some options come
2167 in pairs - typically uid/gid settings, which can either be explicit numerical
2168 values, or strings to be expanded later. If the numerical value is unset,
2169 search for "*expand_<name>" to see if there is a string equivalent.
2170
2171 Arguments:
2172   ol             option entry, or NULL for an unknown option
2173   name           option name
2174   options_block  NULL for main configuration options; otherwise points to
2175                    a driver block; if the option doesn't have opt_public
2176                    set, then options_block->options_block is where the item
2177                    resides.
2178   oltop          points to the option list in which ol exists
2179   last           one more than the offset of the last entry in optop
2180   no_labels      do not show "foo = " at the start.
2181
2182 Returns:         nothing
2183 */
2184
2185 static void
2186 print_ol(optionlist *ol, uschar *name, void *options_block,
2187   optionlist *oltop, int last, BOOL no_labels)
2188 {
2189 struct passwd *pw;
2190 struct group *gr;
2191 optionlist *ol2;
2192 void *value;
2193 uid_t *uidlist;
2194 gid_t *gidlist;
2195 uschar *s;
2196 uschar name2[64];
2197
2198 if (ol == NULL)
2199   {
2200   printf("%s is not a known option\n", name);
2201   return;
2202   }
2203
2204 /* Non-admin callers cannot see options that have been flagged secure by the
2205 "hide" prefix. */
2206
2207 if (!admin_user && (ol->type & opt_secure) != 0)
2208   {
2209   const char * const hidden = "<value not displayable>";
2210   if (no_labels)
2211     printf("%s\n", hidden);
2212   else
2213     printf("%s = %s\n", name, hidden);
2214   return;
2215   }
2216
2217 /* Else show the value of the option */
2218
2219 value = ol->value;
2220 if (options_block != NULL)
2221   {
2222   if ((ol->type & opt_public) == 0)
2223     options_block = (void *)(((driver_instance *)options_block)->options_block);
2224   value = (void *)((uschar *)options_block + (long int)value);
2225   }
2226
2227 switch(ol->type & opt_mask)
2228   {
2229   case opt_stringptr:
2230   case opt_rewrite:        /* Show the text value */
2231   s = *((uschar **)value);
2232   if (!no_labels) printf("%s = ", name);
2233   printf("%s\n", (s == NULL)? US"" : string_printing2(s, FALSE));
2234   break;
2235
2236   case opt_int:
2237   if (!no_labels) printf("%s = ", name);
2238   printf("%d\n", *((int *)value));
2239   break;
2240
2241   case opt_mkint:
2242     {
2243     int x = *((int *)value);
2244     if (x != 0 && (x & 1023) == 0)
2245       {
2246       int c = 'K';
2247       x >>= 10;
2248       if ((x & 1023) == 0)
2249         {
2250         c = 'M';
2251         x >>= 10;
2252         }
2253       if (!no_labels) printf("%s = ", name);
2254       printf("%d%c\n", x, c);
2255       }
2256     else
2257       {
2258       if (!no_labels) printf("%s = ", name);
2259       printf("%d\n", x);
2260       }
2261     }
2262   break;
2263
2264   case opt_Kint:
2265     {
2266     int x = *((int *)value);
2267     if (!no_labels) printf("%s = ", name);
2268     if (x == 0) printf("0\n");
2269       else if ((x & 1023) == 0) printf("%dM\n", x >> 10);
2270         else printf("%dK\n", x);
2271     }
2272   break;
2273
2274   case opt_octint:
2275   if (!no_labels) printf("%s = ", name);
2276   printf("%#o\n", *((int *)value));
2277   break;
2278
2279   /* Can be negative only when "unset", in which case integer */
2280
2281   case opt_fixed:
2282     {
2283     int x = *((int *)value);
2284     int f = x % 1000;
2285     int d = 100;
2286     if (x < 0) printf("%s =\n", name); else
2287       {
2288       if (!no_labels) printf("%s = ", name);
2289       printf("%d.", x/1000);
2290       do
2291         {
2292         printf("%d", f/d);
2293         f %= d;
2294         d /= 10;
2295         }
2296       while (f != 0);
2297       printf("\n");
2298       }
2299     }
2300   break;
2301
2302   /* If the numerical value is unset, try for the string value */
2303
2304   case opt_expand_uid:
2305   if (! *get_set_flag(name, oltop, last, options_block))
2306     {
2307     sprintf(CS name2, "*expand_%.50s", name);
2308     ol2 = find_option(name2, oltop, last);
2309     if (ol2 != NULL)
2310       {
2311       void *value2 = ol2->value;
2312       if (options_block != NULL)
2313         value2 = (void *)((uschar *)options_block + (long int)value2);
2314       s = *((uschar **)value2);
2315       if (!no_labels) printf("%s = ", name);
2316       printf("%s\n", (s == NULL)? US"" : string_printing(s));
2317       break;
2318       }
2319     }
2320
2321   /* Else fall through */
2322
2323   case opt_uid:
2324   if (!no_labels) printf("%s = ", name);
2325   if (! *get_set_flag(name, oltop, last, options_block))
2326     printf("\n");
2327   else
2328     {
2329     pw = getpwuid(*((uid_t *)value));
2330     if (pw == NULL)
2331       printf("%ld\n", (long int)(*((uid_t *)value)));
2332     else printf("%s\n", pw->pw_name);
2333     }
2334   break;
2335
2336   /* If the numerical value is unset, try for the string value */
2337
2338   case opt_expand_gid:
2339   if (! *get_set_flag(name, oltop, last, options_block))
2340     {
2341     sprintf(CS name2, "*expand_%.50s", name);
2342     ol2 = find_option(name2, oltop, last);
2343     if (ol2 != NULL && (ol2->type & opt_mask) == opt_stringptr)
2344       {
2345       void *value2 = ol2->value;
2346       if (options_block != NULL)
2347         value2 = (void *)((uschar *)options_block + (long int)value2);
2348       s = *((uschar **)value2);
2349       if (!no_labels) printf("%s = ", name);
2350       printf("%s\n", (s == NULL)? US"" : string_printing(s));
2351       break;
2352       }
2353     }
2354
2355   /* Else fall through */
2356
2357   case opt_gid:
2358   if (!no_labels) printf("%s = ", name);
2359   if (! *get_set_flag(name, oltop, last, options_block))
2360     printf("\n");
2361   else
2362     {
2363     gr = getgrgid(*((int *)value));
2364     if (gr == NULL)
2365        printf("%ld\n", (long int)(*((int *)value)));
2366     else printf("%s\n", gr->gr_name);
2367     }
2368   break;
2369
2370   case opt_uidlist:
2371   uidlist = *((uid_t **)value);
2372   if (!no_labels) printf("%s =", name);
2373   if (uidlist != NULL)
2374     {
2375     int i;
2376     uschar sep = ' ';
2377     if (no_labels) sep = '\0';
2378     for (i = 1; i <= (int)(uidlist[0]); i++)
2379       {
2380       uschar *name = NULL;
2381       pw = getpwuid(uidlist[i]);
2382       if (pw != NULL) name = US pw->pw_name;
2383       if (sep != '\0') printf("%c", sep);
2384       if (name != NULL) printf("%s", name);
2385         else printf("%ld", (long int)(uidlist[i]));
2386       sep = ':';
2387       }
2388     }
2389   printf("\n");
2390   break;
2391
2392   case opt_gidlist:
2393   gidlist = *((gid_t **)value);
2394   if (!no_labels) printf("%s =", name);
2395   if (gidlist != NULL)
2396     {
2397     int i;
2398     uschar sep = ' ';
2399     if (no_labels) sep = '\0';
2400     for (i = 1; i <= (int)(gidlist[0]); i++)
2401       {
2402       uschar *name = NULL;
2403       gr = getgrgid(gidlist[i]);
2404       if (gr != NULL) name = US gr->gr_name;
2405       if (sep != '\0') printf("%c", sep);
2406       if (name != NULL) printf("%s", name);
2407         else printf("%ld", (long int)(gidlist[i]));
2408       sep = ':';
2409       }
2410     }
2411   printf("\n");
2412   break;
2413
2414   case opt_time:
2415   if (!no_labels) printf("%s = ", name);
2416   printf("%s\n", readconf_printtime(*((int *)value)));
2417   break;
2418
2419   case opt_timelist:
2420     {
2421     int i;
2422     int *list = (int *)value;
2423     if (!no_labels) printf("%s = ", name);
2424     for (i = 0; i < list[1]; i++)
2425       printf("%s%s", (i == 0)? "" : ":", readconf_printtime(list[i+2]));
2426     printf("\n");
2427     }
2428   break;
2429
2430   case opt_bit:
2431   printf("%s%s\n", ((*((int *)value)) & (1 << ((ol->type >> 16) & 31)))?
2432     "" : "no_", name);
2433   break;
2434
2435   case opt_expand_bool:
2436   sprintf(CS name2, "*expand_%.50s", name);
2437   ol2 = find_option(name2, oltop, last);
2438   if (ol2 != NULL && ol2->value != NULL)
2439     {
2440     void *value2 = ol2->value;
2441     if (options_block != NULL)
2442       value2 = (void *)((uschar *)options_block + (long int)value2);
2443     s = *((uschar **)value2);
2444     if (s != NULL)
2445       {
2446       if (!no_labels) printf("%s = ", name);
2447       printf("%s\n", string_printing(s));
2448       break;
2449       }
2450     /* s == NULL => string not set; fall through */
2451     }
2452
2453   /* Fall through */
2454
2455   case opt_bool:
2456   case opt_bool_verify:
2457   case opt_bool_set:
2458   printf("%s%s\n", (*((BOOL *)value))? "" : "no_", name);
2459   break;
2460   }
2461 }
2462
2463
2464
2465 /*************************************************
2466 *        Print value from main configuration     *
2467 *************************************************/
2468
2469 /* This function, called as a result of encountering the -bP option,
2470 causes the value of any main configuration variable to be output if the
2471 second argument is NULL. There are some special values:
2472
2473   all                print all main configuration options
2474   configure_file     print the name of the configuration file
2475   routers            print the routers' configurations
2476   transports         print the transports' configuration
2477   authenticators     print the authenticators' configuration
2478   macros             print the macros' configuration
2479   router_list        print a list of router names
2480   transport_list     print a list of transport names
2481   authenticator_list print a list of authentication mechanism names
2482   macro_list         print a list of macro names
2483   +name              print a named list item
2484   local_scan         print the local_scan options
2485
2486 If the second argument is not NULL, it must be one of "router", "transport",
2487 "authenticator" or "macro" in which case the first argument identifies the
2488 driver whose options are to be printed.
2489
2490 Arguments:
2491   name        option name if type == NULL; else driver name
2492   type        NULL or driver type name, as described above
2493   no_labels   avoid the "foo = " at the start of an item
2494
2495 Returns:      nothing
2496 */
2497
2498 void
2499 readconf_print(uschar *name, uschar *type, BOOL no_labels)
2500 {
2501 BOOL names_only = FALSE;
2502 optionlist *ol;
2503 optionlist *ol2 = NULL;
2504 driver_instance *d = NULL;
2505 macro_item *m;
2506 int size = 0;
2507
2508 if (type == NULL)
2509   {
2510   if (*name == '+')
2511     {
2512     int i;
2513     tree_node *t;
2514     BOOL found = FALSE;
2515     static uschar *types[] = { US"address", US"domain", US"host",
2516       US"localpart" };
2517     static tree_node **anchors[] = { &addresslist_anchor, &domainlist_anchor,
2518       &hostlist_anchor, &localpartlist_anchor };
2519
2520     for (i = 0; i < 4; i++)
2521       {
2522       t = tree_search(*(anchors[i]), name+1);
2523       if (t != NULL)
2524         {
2525         found = TRUE;
2526         if (no_labels)
2527           printf("%s\n", ((namedlist_block *)(t->data.ptr))->string);
2528         else
2529           printf("%slist %s = %s\n", types[i], name+1,
2530             ((namedlist_block *)(t->data.ptr))->string);
2531         }
2532       }
2533
2534     if (!found)
2535       printf("no address, domain, host, or local part list called \"%s\" "
2536         "exists\n", name+1);
2537
2538     return;
2539     }
2540
2541   if (Ustrcmp(name, "configure_file") == 0)
2542     {
2543     printf("%s\n", CS config_main_filename);
2544     return;
2545     }
2546
2547   if (Ustrcmp(name, "all") == 0)
2548     {
2549     for (ol = optionlist_config;
2550          ol < optionlist_config + optionlist_config_size; ol++)
2551       {
2552       if ((ol->type & opt_hidden) == 0)
2553         print_ol(ol, US ol->name, NULL,
2554             optionlist_config, optionlist_config_size,
2555             no_labels);
2556       }
2557     return;
2558     }
2559
2560   if (Ustrcmp(name, "local_scan") == 0)
2561     {
2562     #ifndef LOCAL_SCAN_HAS_OPTIONS
2563     printf("local_scan() options are not supported\n");
2564     #else
2565     for (ol = local_scan_options;
2566          ol < local_scan_options + local_scan_options_count; ol++)
2567       {
2568       print_ol(ol, US ol->name, NULL, local_scan_options,
2569         local_scan_options_count, no_labels);
2570       }
2571     #endif
2572     return;
2573     }
2574
2575   if (Ustrcmp(name, "routers") == 0)
2576     {
2577     type = US"router";
2578     name = NULL;
2579     }
2580   else if (Ustrcmp(name, "transports") == 0)
2581     {
2582     type = US"transport";
2583     name = NULL;
2584     }
2585
2586   else if (Ustrcmp(name, "authenticators") == 0)
2587     {
2588     type = US"authenticator";
2589     name = NULL;
2590     }
2591
2592   else if (Ustrcmp(name, "macros") == 0)
2593     {
2594     type = US"macro";
2595     name = NULL;
2596     }
2597
2598   else if (Ustrcmp(name, "router_list") == 0)
2599     {
2600     type = US"router";
2601     name = NULL;
2602     names_only = TRUE;
2603     }
2604
2605   else if (Ustrcmp(name, "transport_list") == 0)
2606     {
2607     type = US"transport";
2608     name = NULL;
2609     names_only = TRUE;
2610     }
2611
2612   else if (Ustrcmp(name, "authenticator_list") == 0)
2613     {
2614     type = US"authenticator";
2615     name = NULL;
2616     names_only = TRUE;
2617     }
2618
2619   else if (Ustrcmp(name, "macro_list") == 0)
2620     {
2621     type = US"macro";
2622     name = NULL;
2623     names_only = TRUE;
2624     }
2625
2626   else
2627     {
2628     print_ol(find_option(name, optionlist_config, optionlist_config_size),
2629       name, NULL, optionlist_config, optionlist_config_size, no_labels);
2630     return;
2631     }
2632   }
2633
2634 /* Handle the options for a router or transport. Skip options that are flagged
2635 as hidden. Some of these are options with names starting with '*', used for
2636 internal alternative representations of other options (which the printing
2637 function will sort out). Others are synonyms kept for backward compatibility.
2638 */
2639
2640 if (Ustrcmp(type, "router") == 0)
2641   {
2642   d = (driver_instance *)routers;
2643   ol2 = optionlist_routers;
2644   size = optionlist_routers_size;
2645   }
2646 else if (Ustrcmp(type, "transport") == 0)
2647   {
2648   d = (driver_instance *)transports;
2649   ol2 = optionlist_transports;
2650   size = optionlist_transports_size;
2651   }
2652 else if (Ustrcmp(type, "authenticator") == 0)
2653   {
2654   d = (driver_instance *)auths;
2655   ol2 = optionlist_auths;
2656   size = optionlist_auths_size;
2657   }
2658
2659 else if (Ustrcmp(type, "macro") == 0)
2660   {
2661   /* People store passwords in macros and they were previously not available
2662   for printing.  So we have an admin_users restriction. */
2663   if (!admin_user)
2664     {
2665     fprintf(stderr, "exim: permission denied\n");
2666     exit(EXIT_FAILURE);
2667     }
2668   for (m = macros; m != NULL; m = m->next)
2669     {
2670     if (name == NULL || Ustrcmp(name, m->name) == 0)
2671       {
2672       if (names_only)
2673         printf("%s\n", CS m->name);
2674       else
2675         printf("%s=%s\n", CS m->name, CS m->replacement);
2676       if (name != NULL)
2677         return;
2678       }
2679     }
2680   if (name != NULL)
2681     printf("%s %s not found\n", type, name);
2682   return;
2683   }
2684
2685 if (names_only)
2686   {
2687   for (; d != NULL; d = d->next) printf("%s\n", CS d->name);
2688   return;
2689   }
2690
2691 /* Either search for a given driver, or print all of them */
2692
2693 for (; d != NULL; d = d->next)
2694   {
2695   if (name == NULL)
2696     printf("\n%s %s:\n", d->name, type);
2697   else if (Ustrcmp(d->name, name) != 0) continue;
2698
2699   for (ol = ol2; ol < ol2 + size; ol++)
2700     {
2701     if ((ol->type & opt_hidden) == 0)
2702       print_ol(ol, US ol->name, d, ol2, size, no_labels);
2703     }
2704
2705   for (ol = d->info->options;
2706        ol < d->info->options + *(d->info->options_count); ol++)
2707     {
2708     if ((ol->type & opt_hidden) == 0)
2709       print_ol(ol, US ol->name, d, d->info->options, *(d->info->options_count), no_labels);
2710     }
2711   if (name != NULL) return;
2712   }
2713 if (name != NULL) printf("%s %s not found\n", type, name);
2714 }
2715
2716
2717
2718 /*************************************************
2719 *          Read a named list item                *
2720 *************************************************/
2721
2722 /* This function reads a name and a list (i.e. string). The name is used to
2723 save the list in a tree, sorted by its name. Each entry also has a number,
2724 which can be used for caching tests, but if the string contains any expansion
2725 items other than $key, the number is set negative to inhibit caching. This
2726 mechanism is used for domain, host, and address lists that are referenced by
2727 the "+name" syntax.
2728
2729 Arguments:
2730   anchorp     points to the tree anchor
2731   numberp     points to the current number for this tree
2732   max         the maximum number permitted
2733   s           the text of the option line, starting immediately after the name
2734                 of the list type
2735   tname       the name of the list type, for messages
2736
2737 Returns:      nothing
2738 */
2739
2740 static void
2741 read_named_list(tree_node **anchorp, int *numberp, int max, uschar *s,
2742   uschar *tname)
2743 {
2744 BOOL forcecache = FALSE;
2745 uschar *ss;
2746 tree_node *t;
2747 namedlist_block *nb = store_get(sizeof(namedlist_block));
2748
2749 if (Ustrncmp(s, "_cache", 6) == 0)
2750   {
2751   forcecache = TRUE;
2752   s += 6;
2753   }
2754
2755 if (!isspace(*s))
2756   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unrecognized configuration line");
2757
2758 if (*numberp >= max)
2759  log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many named %ss (max is %d)\n",
2760    tname, max);
2761
2762 while (isspace(*s)) s++;
2763 ss = s;
2764 while (isalnum(*s) || *s == '_') s++;
2765 t = store_get(sizeof(tree_node) + s-ss);
2766 Ustrncpy(t->name, ss, s-ss);
2767 t->name[s-ss] = 0;
2768 while (isspace(*s)) s++;
2769
2770 if (!tree_insertnode(anchorp, t))
2771   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2772     "duplicate name \"%s\" for a named %s", t->name, tname);
2773
2774 t->data.ptr = nb;
2775 nb->number = *numberp;
2776 *numberp += 1;
2777
2778 if (*s++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2779   "missing '=' after \"%s\"", t->name);
2780 while (isspace(*s)) s++;
2781 nb->string = read_string(s, t->name);
2782 nb->cache_data = NULL;
2783
2784 /* Check the string for any expansions; if any are found, mark this list
2785 uncacheable unless the user has explicited forced caching. */
2786
2787 if (!forcecache && Ustrchr(nb->string, '$') != NULL) nb->number = -1;
2788 }
2789
2790
2791
2792
2793 /*************************************************
2794 *        Unpick data for a rate limit            *
2795 *************************************************/
2796
2797 /* This function is called to unpick smtp_ratelimit_{mail,rcpt} into four
2798 separate values.
2799
2800 Arguments:
2801   s            string, in the form t,b,f,l
2802                where t is the threshold (integer)
2803                b is the initial delay (time)
2804                f is the multiplicative factor (fixed point)
2805                k is the maximum time (time)
2806   threshold    where to store threshold
2807   base         where to store base in milliseconds
2808   factor       where to store factor in milliseconds
2809   limit        where to store limit
2810
2811 Returns:       nothing (panics on error)
2812 */
2813
2814 static void
2815 unpick_ratelimit(uschar *s, int *threshold, int *base, double *factor,
2816   int *limit)
2817 {
2818 uschar bstring[16], lstring[16];
2819
2820 if (sscanf(CS s, "%d, %15[0123456789smhdw.], %lf, %15s", threshold, bstring,
2821     factor, lstring) == 4)
2822   {
2823   *base = readconf_readtime(bstring, 0, TRUE);
2824   *limit = readconf_readtime(lstring, 0, TRUE);
2825   if (*base >= 0 && *limit >= 0) return;
2826   }
2827 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "malformed ratelimit data: %s", s);
2828 }
2829
2830
2831
2832
2833 /*************************************************
2834 *       Drop privs for checking TLS config      *
2835 *************************************************/
2836
2837 /* We want to validate TLS options during readconf, but do not want to be
2838 root when we call into the TLS library, in case of library linkage errors
2839 which cause segfaults; before this check, those were always done as the Exim
2840 runtime user and it makes sense to continue with that.
2841
2842 Assumes:  tls_require_ciphers has been set, if it will be
2843           exim_user has been set, if it will be
2844           exim_group has been set, if it will be
2845
2846 Returns:  bool for "okay"; false will cause caller to immediately exit.
2847 */
2848
2849 #ifdef SUPPORT_TLS
2850 static BOOL
2851 tls_dropprivs_validate_require_cipher(void)
2852 {
2853 const uschar *errmsg;
2854 pid_t pid;
2855 int rc, status;
2856 void (*oldsignal)(int);
2857
2858 oldsignal = signal(SIGCHLD, SIG_DFL);
2859
2860 fflush(NULL);
2861 if ((pid = fork()) < 0)
2862   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "fork failed for TLS check");
2863
2864 if (pid == 0)
2865   {
2866   /* in some modes, will have dropped privilege already */
2867   if (!geteuid())
2868     exim_setugid(exim_uid, exim_gid, FALSE,
2869         US"calling tls_validate_require_cipher");
2870
2871   errmsg = tls_validate_require_cipher();
2872   if (errmsg)
2873     {
2874     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
2875         "tls_require_ciphers invalid: %s", errmsg);
2876     }
2877   fflush(NULL);
2878   _exit(0);
2879   }
2880
2881 do {
2882   rc = waitpid(pid, &status, 0);
2883 } while (rc < 0 && errno == EINTR);
2884
2885 DEBUG(D_tls)
2886   debug_printf("tls_validate_require_cipher child %d ended: status=0x%x\n",
2887       (int)pid, status);
2888
2889 signal(SIGCHLD, oldsignal);
2890
2891 return status == 0;
2892 }
2893 #endif /* SUPPORT_TLS */
2894
2895
2896
2897
2898 /*************************************************
2899 *         Read main configuration options        *
2900 *************************************************/
2901
2902 /* This function is the first to be called for configuration reading. It
2903 opens the configuration file and reads general configuration settings until
2904 it reaches the end of the configuration section. The file is then left open so
2905 that the remaining configuration data can subsequently be read if needed for
2906 this run of Exim.
2907
2908 The configuration file must be owned either by root or exim, and be writeable
2909 only by root or uid/gid exim. The values for Exim's uid and gid can be changed
2910 in the config file, so the test is done on the compiled in values. A slight
2911 anomaly, to be carefully documented.
2912
2913 The name of the configuration file is taken from a list that is included in the
2914 binary of Exim. It can be altered from the command line, but if that is done,
2915 root privilege is immediately withdrawn unless the caller is root or exim.
2916 The first file on the list that exists is used.
2917
2918 For use on multiple systems that share file systems, first look for a
2919 configuration file whose name has the current node name on the end. If that is
2920 not found, try the generic name. For really contorted configurations, that run
2921 multiple Exims with different uid settings, first try adding the effective uid
2922 before the node name. These complications are going to waste resources on most
2923 systems. Therefore they are available only when requested by compile-time
2924 options. */
2925
2926 void
2927 readconf_main(void)
2928 {
2929 int sep = 0;
2930 struct stat statbuf;
2931 uschar *s, *filename;
2932 uschar *list = config_main_filelist;
2933
2934 /* Loop through the possible file names */
2935
2936 while((filename = string_nextinlist(&list, &sep, big_buffer, big_buffer_size))
2937        != NULL)
2938   {
2939   /* Cut out all the fancy processing unless specifically wanted */
2940
2941   #if defined(CONFIGURE_FILE_USE_NODE) || defined(CONFIGURE_FILE_USE_EUID)
2942   uschar *suffix = filename + Ustrlen(filename);
2943
2944   /* Try for the node-specific file if a node name exists */
2945
2946   #ifdef CONFIGURE_FILE_USE_NODE
2947   struct utsname uts;
2948   if (uname(&uts) >= 0)
2949     {
2950     #ifdef CONFIGURE_FILE_USE_EUID
2951     sprintf(CS suffix, ".%ld.%.256s", (long int)original_euid, uts.nodename);
2952     config_file = Ufopen(filename, "rb");
2953     if (config_file == NULL)
2954     #endif  /* CONFIGURE_FILE_USE_EUID */
2955       {
2956       sprintf(CS suffix, ".%.256s", uts.nodename);
2957       config_file = Ufopen(filename, "rb");
2958       }
2959     }
2960   #endif  /* CONFIGURE_FILE_USE_NODE */
2961
2962   /* Otherwise, try the generic name, possibly with the euid added */
2963
2964   #ifdef CONFIGURE_FILE_USE_EUID
2965   if (config_file == NULL)
2966     {
2967     sprintf(CS suffix, ".%ld", (long int)original_euid);
2968     config_file = Ufopen(filename, "rb");
2969     }
2970   #endif  /* CONFIGURE_FILE_USE_EUID */
2971
2972   /* Finally, try the unadorned name */
2973
2974   if (config_file == NULL)
2975     {
2976     *suffix = 0;
2977     config_file = Ufopen(filename, "rb");
2978     }
2979   #else  /* if neither defined */
2980
2981   /* This is the common case when the fancy processing is not included. */
2982
2983   config_file = Ufopen(filename, "rb");
2984   #endif
2985
2986   /* If the file does not exist, continue to try any others. For any other
2987   error, break out (and die). */
2988
2989   if (config_file != NULL || errno != ENOENT) break;
2990   }
2991
2992 /* On success, save the name for verification; config_filename is used when
2993 logging configuration errors (it changes for .included files) whereas
2994 config_main_filename is the name shown by -bP. Failure to open a configuration
2995 file is a serious disaster. */
2996
2997 if (config_file != NULL)
2998   {
2999   config_filename = config_main_filename = string_copy(filename);
3000   }
3001 else
3002   {
3003   if (filename == NULL)
3004     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "non-existent configuration file(s): "
3005       "%s", config_main_filelist);
3006   else
3007     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", string_open_failed(errno,
3008       "configuration file %s", filename));
3009   }
3010
3011 /* Check the status of the file we have opened, if we have retained root
3012 privileges and the file isn't /dev/null (which *should* be 0666). */
3013
3014 if (trusted_config && Ustrcmp(filename, US"/dev/null"))
3015   {
3016   if (fstat(fileno(config_file), &statbuf) != 0)
3017     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to stat configuration file %s",
3018       big_buffer);
3019
3020   if ((statbuf.st_uid != root_uid                /* owner not root */
3021        #ifdef CONFIGURE_OWNER
3022        && statbuf.st_uid != config_uid           /* owner not the special one */
3023        #endif
3024          ) ||                                    /* or */
3025       (statbuf.st_gid != root_gid                /* group not root & */
3026        #ifdef CONFIGURE_GROUP
3027        && statbuf.st_gid != config_gid           /* group not the special one */
3028        #endif
3029        && (statbuf.st_mode & 020) != 0) ||       /* group writeable  */
3030                                                  /* or */
3031       ((statbuf.st_mode & 2) != 0))              /* world writeable  */
3032
3033     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Exim configuration file %s has the "
3034       "wrong owner, group, or mode", big_buffer);
3035   }
3036
3037 /* Process the main configuration settings. They all begin with a lower case
3038 letter. If we see something starting with an upper case letter, it is taken as
3039 a macro definition. */
3040
3041 while ((s = get_config_line()) != NULL)
3042   {
3043   if (isupper(s[0])) read_macro_assignment(s);
3044
3045   else if (Ustrncmp(s, "domainlist", 10) == 0)
3046     read_named_list(&domainlist_anchor, &domainlist_count,
3047       MAX_NAMED_LIST, s+10, US"domain list");
3048
3049   else if (Ustrncmp(s, "hostlist", 8) == 0)
3050     read_named_list(&hostlist_anchor, &hostlist_count,
3051       MAX_NAMED_LIST, s+8, US"host list");
3052
3053   else if (Ustrncmp(s, US"addresslist", 11) == 0)
3054     read_named_list(&addresslist_anchor, &addresslist_count,
3055       MAX_NAMED_LIST, s+11, US"address list");
3056
3057   else if (Ustrncmp(s, US"localpartlist", 13) == 0)
3058     read_named_list(&localpartlist_anchor, &localpartlist_count,
3059       MAX_NAMED_LIST, s+13, US"local part list");
3060
3061   else
3062     (void) readconf_handle_option(s, optionlist_config, optionlist_config_size,
3063       NULL, US"main option \"%s\" unknown");
3064   }
3065
3066
3067 /* If local_sender_retain is set, local_from_check must be unset. */
3068
3069 if (local_sender_retain && local_from_check)
3070   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "both local_from_check and "
3071     "local_sender_retain are set; this combination is not allowed");
3072
3073 /* If the timezone string is empty, set it to NULL, implying no TZ variable
3074 wanted. */
3075
3076 if (timezone_string != NULL && *timezone_string == 0) timezone_string = NULL;
3077
3078 /* The max retry interval must not be greater than 24 hours. */
3079
3080 if (retry_interval_max > 24*60*60) retry_interval_max = 24*60*60;
3081
3082 /* remote_max_parallel must be > 0 */
3083
3084 if (remote_max_parallel <= 0) remote_max_parallel = 1;
3085
3086 /* Save the configured setting of freeze_tell, so we can re-instate it at the
3087 start of a new SMTP message. */
3088
3089 freeze_tell_config = freeze_tell;
3090
3091 /* The primary host name may be required for expansion of spool_directory
3092 and log_file_path, so make sure it is set asap. It is obtained from uname(),
3093 but if that yields an unqualified value, make a FQDN by using gethostbyname to
3094 canonize it. Some people like upper case letters in their host names, so we
3095 don't force the case. */
3096
3097 if (primary_hostname == NULL)
3098   {
3099   uschar *hostname;
3100   struct utsname uts;
3101   if (uname(&uts) < 0)
3102     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "uname() failed to yield host name");
3103   hostname = US uts.nodename;
3104
3105   if (Ustrchr(hostname, '.') == NULL)
3106     {
3107     int af = AF_INET;
3108     struct hostent *hostdata;
3109
3110     #if HAVE_IPV6
3111     if (!disable_ipv6 && (dns_ipv4_lookup == NULL ||
3112          match_isinlist(hostname, &dns_ipv4_lookup, 0, NULL, NULL, MCL_DOMAIN,
3113            TRUE, NULL) != OK))
3114       af = AF_INET6;
3115     #else
3116     af = AF_INET;
3117     #endif
3118
3119     for (;;)
3120       {
3121       #if HAVE_IPV6
3122         #if HAVE_GETIPNODEBYNAME
3123         int error_num;
3124         hostdata = getipnodebyname(CS hostname, af, 0, &error_num);
3125         #else
3126         hostdata = gethostbyname2(CS hostname, af);
3127         #endif
3128       #else
3129       hostdata = gethostbyname(CS hostname);
3130       #endif
3131
3132       if (hostdata != NULL)
3133         {
3134         hostname = US hostdata->h_name;
3135         break;
3136         }
3137
3138       if (af == AF_INET) break;
3139       af = AF_INET;
3140       }
3141     }
3142
3143   primary_hostname = string_copy(hostname);
3144   }
3145
3146 /* Set up default value for smtp_active_hostname */
3147
3148 smtp_active_hostname = primary_hostname;
3149
3150 /* If spool_directory wasn't set in the build-time configuration, it must have
3151 got set above. Of course, writing to the log may not work if log_file_path is
3152 not set, but it will at least get to syslog or somewhere, with any luck. */
3153
3154 if (*spool_directory == 0)
3155   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "spool_directory undefined: cannot "
3156     "proceed");
3157
3158 /* Expand the spool directory name; it may, for example, contain the primary
3159 host name. Same comment about failure. */
3160
3161 s = expand_string(spool_directory);
3162 if (s == NULL)
3163   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand spool_directory "
3164     "\"%s\": %s", spool_directory, expand_string_message);
3165 spool_directory = s;
3166
3167 /* Expand log_file_path, which must contain "%s" in any component that isn't
3168 the null string or "syslog". It is also allowed to contain one instance of %D
3169 or %M. However, it must NOT contain % followed by anything else. */
3170
3171 if (*log_file_path != 0)
3172   {
3173   uschar *ss, *sss;
3174   int sep = ':';                       /* Fixed for log file path */
3175   s = expand_string(log_file_path);
3176   if (s == NULL)
3177     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand log_file_path "
3178       "\"%s\": %s", log_file_path, expand_string_message);
3179
3180   ss = s;
3181   while ((sss = string_nextinlist(&ss,&sep,big_buffer,big_buffer_size)) != NULL)
3182     {
3183     uschar *t;
3184     if (sss[0] == 0 || Ustrcmp(sss, "syslog") == 0) continue;
3185     t = Ustrstr(sss, "%s");
3186     if (t == NULL)
3187       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" does not "
3188         "contain \"%%s\"", sss);
3189     *t = 'X';
3190     t = Ustrchr(sss, '%');
3191     if (t != NULL)
3192       {
3193       if ((t[1] != 'D' && t[1] != 'M') || Ustrchr(t+2, '%') != NULL)
3194         log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" contains "
3195           "unexpected \"%%\" character", s);
3196       }
3197     }
3198
3199   log_file_path = s;
3200   }
3201
3202 /* Interpret syslog_facility into an integer argument for 'ident' param to
3203 openlog(). Default is LOG_MAIL set in globals.c. Allow the user to omit the
3204 leading "log_". */
3205
3206 if (syslog_facility_str != NULL)
3207   {
3208   int i;
3209   uschar *s = syslog_facility_str;
3210
3211   if ((Ustrlen(syslog_facility_str) >= 4) &&
3212         (strncmpic(syslog_facility_str, US"log_", 4) == 0))
3213     s += 4;
3214
3215   for (i = 0; i < syslog_list_size; i++)
3216     {
3217     if (strcmpic(s, syslog_list[i].name) == 0)
3218       {
3219       syslog_facility = syslog_list[i].value;
3220       break;
3221       }
3222     }
3223
3224   if (i >= syslog_list_size)
3225     {
3226     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3227       "failed to interpret syslog_facility \"%s\"", syslog_facility_str);
3228     }
3229   }
3230
3231 /* Expand pid_file_path */
3232
3233 if (*pid_file_path != 0)
3234   {
3235   s = expand_string(pid_file_path);
3236   if (s == NULL)
3237     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand pid_file_path "
3238       "\"%s\": %s", pid_file_path, expand_string_message);
3239   pid_file_path = s;
3240   }
3241
3242 /* Set default value of process_log_path */
3243
3244 if (process_log_path == NULL || *process_log_path =='\0')
3245   process_log_path = string_sprintf("%s/exim-process.info", spool_directory);
3246
3247 /* Compile the regex for matching a UUCP-style "From_" line in an incoming
3248 message. */
3249
3250 regex_From = regex_must_compile(uucp_from_pattern, FALSE, TRUE);
3251
3252 /* Unpick the SMTP rate limiting options, if set */
3253
3254 if (smtp_ratelimit_mail != NULL)
3255   {
3256   unpick_ratelimit(smtp_ratelimit_mail, &smtp_rlm_threshold,
3257     &smtp_rlm_base, &smtp_rlm_factor, &smtp_rlm_limit);
3258   }
3259
3260 if (smtp_ratelimit_rcpt != NULL)
3261   {
3262   unpick_ratelimit(smtp_ratelimit_rcpt, &smtp_rlr_threshold,
3263     &smtp_rlr_base, &smtp_rlr_factor, &smtp_rlr_limit);
3264   }
3265
3266 /* The qualify domains default to the primary host name */
3267
3268 if (qualify_domain_sender == NULL)
3269   qualify_domain_sender = primary_hostname;
3270 if (qualify_domain_recipient == NULL)
3271   qualify_domain_recipient = qualify_domain_sender;
3272
3273 /* Setting system_filter_user in the configuration sets the gid as well if a
3274 name is given, but a numerical value does not. */
3275
3276 if (system_filter_uid_set && !system_filter_gid_set)
3277   {
3278   struct passwd *pw = getpwuid(system_filter_uid);
3279   if (pw == NULL)
3280     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to look up uid %ld",
3281       (long int)system_filter_uid);
3282   system_filter_gid = pw->pw_gid;
3283   system_filter_gid_set = TRUE;
3284   }
3285
3286 /* If the errors_reply_to field is set, check that it is syntactically valid
3287 and ensure it contains a domain. */
3288
3289 if (errors_reply_to != NULL)
3290   {
3291   uschar *errmess;
3292   int start, end, domain;
3293   uschar *recipient = parse_extract_address(errors_reply_to, &errmess,
3294     &start, &end, &domain, FALSE);
3295
3296   if (recipient == NULL)
3297     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3298       "error in errors_reply_to (%s): %s", errors_reply_to, errmess);
3299
3300   if (domain == 0)
3301     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3302       "errors_reply_to (%s) does not contain a domain", errors_reply_to);
3303   }
3304
3305 /* If smtp_accept_queue or smtp_accept_max_per_host is set, then
3306 smtp_accept_max must also be set. */
3307
3308 if (smtp_accept_max == 0 &&
3309     (smtp_accept_queue > 0 || smtp_accept_max_per_host != NULL))
3310   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3311     "smtp_accept_max must be set if smtp_accept_queue or "
3312     "smtp_accept_max_per_host is set");
3313
3314 /* Set up the host number if anything is specified. It is an expanded string
3315 so that it can be computed from the host name, for example. We do this last
3316 so as to ensure that everything else is set up before the expansion. */
3317
3318 if (host_number_string != NULL)
3319   {
3320   long int n;
3321   uschar *end;
3322   uschar *s = expand_string(host_number_string);
3323   if (s == NULL)
3324     log_write(0, LOG_MAIN|LOG_PANIC_DIE,
3325         "failed to expand localhost_number \"%s\": %s",
3326         host_number_string, expand_string_message);
3327   n = Ustrtol(s, &end, 0);
3328   while (isspace(*end)) end++;
3329   if (*end != 0)
3330     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3331       "localhost_number value is not a number: %s", s);
3332   if (n > LOCALHOST_MAX)
3333     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3334       "localhost_number is greater than the maximum allowed value (%d)",
3335         LOCALHOST_MAX);
3336   host_number = n;
3337   }
3338
3339 #ifdef SUPPORT_TLS
3340 /* If tls_verify_hosts is set, tls_verify_certificates must also be set */
3341
3342 if ((tls_verify_hosts != NULL || tls_try_verify_hosts != NULL) &&
3343      tls_verify_certificates == NULL)
3344   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3345     "tls_%sverify_hosts is set, but tls_verify_certificates is not set",
3346     (tls_verify_hosts != NULL)? "" : "try_");
3347
3348 /* This also checks that the library linkage is working and we can call
3349 routines in it, so call even if tls_require_ciphers is unset */
3350 if (!tls_dropprivs_validate_require_cipher())
3351   exit(1);
3352
3353 /* Magic number: at time of writing, 1024 has been the long-standing value
3354 used by so many clients, and what Exim used to use always, that it makes
3355 sense to just min-clamp this max-clamp at that. */
3356 if (tls_dh_max_bits < 1024)
3357   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3358       "tls_dh_max_bits is too small, must be at least 1024 for interop");
3359
3360 /* If openssl_options is set, validate it */
3361 if (openssl_options != NULL)
3362   {
3363 # ifdef USE_GNUTLS
3364   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3365     "openssl_options is set but we're using GnuTLS");
3366 # else
3367   long dummy;
3368   if (!(tls_openssl_options_parse(openssl_options, &dummy)))
3369     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3370       "openssl_options parse error: %s", openssl_options);
3371 # endif
3372   }
3373 #endif
3374 }
3375
3376
3377
3378 /*************************************************
3379 *          Initialize one driver                 *
3380 *************************************************/
3381
3382 /* This is called once the driver's generic options, if any, have been read.
3383 We can now find the driver, set up defaults for the private options, and
3384 unset any "set" bits in the private options table (which might have been
3385 set by another incarnation of the same driver).
3386
3387 Arguments:
3388   d                   pointer to driver instance block, with generic
3389                         options filled in
3390   drivers_available   vector of available drivers
3391   size_of_info        size of each block in drivers_available
3392   class               class of driver, for error message
3393
3394 Returns:              pointer to the driver info block
3395 */
3396
3397 static driver_info *
3398 init_driver(driver_instance *d, driver_info *drivers_available,
3399   int size_of_info, uschar *class)
3400 {
3401 driver_info *dd;
3402
3403 for (dd = drivers_available; dd->driver_name[0] != 0;
3404      dd = (driver_info *)(((uschar *)dd) + size_of_info))
3405   {
3406   if (Ustrcmp(d->driver_name, dd->driver_name) == 0)
3407     {
3408     int i;
3409     int len = dd->options_len;
3410     d->info = dd;
3411     d->options_block = store_get(len);
3412     memcpy(d->options_block, dd->options_block, len);
3413     for (i = 0; i < *(dd->options_count); i++)
3414       dd->options[i].type &= ~opt_set;
3415     return dd;
3416     }
3417   }
3418
3419 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3420   "%s %s: cannot find %s driver \"%s\"", class, d->name, class, d->driver_name);
3421
3422 return NULL;   /* never obeyed */
3423 }
3424
3425
3426
3427
3428 /*************************************************
3429 *             Initialize driver list             *
3430 *************************************************/
3431
3432 /* This function is called for routers, transports, and authentication
3433 mechanisms. It reads the data from the current point in the configuration file
3434 up to the end of the section, and sets up a chain of instance blocks according
3435 to the file's contents. The file will already have been opened by a call to
3436 readconf_main, and must be left open for subsequent reading of further data.
3437
3438 Any errors cause a panic crash. Note that the blocks with names driver_info and
3439 driver_instance must map the first portions of all the _info and _instance
3440 blocks for this shared code to work.
3441
3442 Arguments:
3443   class                      "router", "transport", or "authenticator"
3444   anchor                     &routers, &transports, &auths
3445   drivers_available          available drivers
3446   size_of_info               size of each info block
3447   instance_default           points to default data for an instance
3448   instance_size              size of instance block
3449   driver_optionlist          generic option list
3450   driver_optionlist_count    count of generic option list
3451
3452 Returns:                     nothing
3453 */
3454
3455 void
3456 readconf_driver_init(
3457   uschar *class,
3458   driver_instance **anchor,
3459   driver_info *drivers_available,
3460   int size_of_info,
3461   void *instance_default,
3462   int  instance_size,
3463   optionlist *driver_optionlist,
3464   int  driver_optionlist_count)
3465 {
3466 driver_instance **p = anchor;
3467 driver_instance *d = NULL;
3468 uschar *buffer;
3469
3470 while ((buffer = get_config_line()) != NULL)
3471   {
3472   uschar name[64];
3473   uschar *s;
3474
3475   /* Read the first name on the line and test for the start of a new driver. A
3476   macro definition indicates the end of the previous driver. If this isn't the
3477   start of a new driver, the line will be re-read. */
3478
3479   s = readconf_readname(name, sizeof(name), buffer);
3480
3481   /* Handle macro definition, first finishing off the initialization of the
3482   previous driver, if any. */
3483
3484   if (isupper(*name) && *s == '=')
3485     {
3486     if (d != NULL)
3487       {
3488       if (d->driver_name == NULL)
3489         log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3490           "no driver defined for %s \"%s\"", class, d->name);
3491       (d->info->init)(d);
3492       d = NULL;
3493       }
3494     read_macro_assignment(buffer);
3495     continue;
3496     }
3497
3498   /* If the line starts with a name terminated by a colon, we are at the
3499   start of the definition of a new driver. The rest of the line must be
3500   blank. */
3501
3502   if (*s++ == ':')
3503     {
3504     int i;
3505
3506     /* Finish off initializing the previous driver. */
3507
3508     if (d != NULL)
3509       {
3510       if (d->driver_name == NULL)
3511         log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3512           "no driver defined for %s \"%s\"", class, d->name);
3513       (d->info->init)(d);
3514       }
3515
3516     /* Check that we haven't already got a driver of this name */
3517
3518     for (d = *anchor; d != NULL; d = d->next)
3519       if (Ustrcmp(name, d->name) == 0)
3520         log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3521           "there are two %ss called \"%s\"", class, name);
3522
3523     /* Set up a new driver instance data block on the chain, with
3524     its default values installed. */
3525
3526     d = store_get(instance_size);
3527     memcpy(d, instance_default, instance_size);
3528     *p = d;
3529     p = &(d->next);
3530     d->name = string_copy(name);
3531
3532     /* Clear out the "set" bits in the generic options */
3533
3534     for (i = 0; i < driver_optionlist_count; i++)
3535       driver_optionlist[i].type &= ~opt_set;
3536
3537     /* Check nothing more on this line, then do the next loop iteration. */
3538
3539     while (isspace(*s)) s++;
3540     if (*s != 0) extra_chars_error(s, US"driver name ", name, US"");
3541     continue;
3542     }
3543
3544   /* Not the start of a new driver. Give an error if we have not set up a
3545   current driver yet. */
3546
3547   if (d == NULL) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3548     "%s name missing", class);
3549
3550   /* First look to see if this is a generic option; if it is "driver",
3551   initialize the driver. If is it not a generic option, we can look for a
3552   private option provided that the driver has been previously set up. */
3553
3554   if (readconf_handle_option(buffer, driver_optionlist,
3555         driver_optionlist_count, d, NULL))
3556     {
3557     if (d->info == NULL && d->driver_name != NULL)
3558       init_driver(d, drivers_available, size_of_info, class);
3559     }
3560
3561   /* Handle private options - pass the generic block because some may
3562   live therein. A flag with each option indicates if it is in the public
3563   block. */
3564
3565   else if (d->info != NULL)
3566     {
3567     readconf_handle_option(buffer, d->info->options,
3568       *(d->info->options_count), d, US"option \"%s\" unknown");
3569     }
3570
3571   /* The option is not generic and the driver name has not yet been given. */
3572
3573   else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option \"%s\" unknown "
3574     "(\"driver\" must be specified before any private options)", name);
3575   }
3576
3577 /* Run the initialization function for the final driver. */
3578
3579 if (d != NULL)
3580   {
3581   if (d->driver_name == NULL)
3582     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3583       "no driver defined for %s \"%s\"", class, d->name);
3584   (d->info->init)(d);
3585   }
3586 }
3587
3588
3589
3590 /*************************************************
3591 *            Check driver dependency             *
3592 *************************************************/
3593
3594 /* This function is passed a driver instance and a string. It checks whether
3595 any of the string options for the driver contains the given string as an
3596 expansion variable.
3597
3598 Arguments:
3599   d        points to a driver instance block
3600   s        the string to search for
3601
3602 Returns:   TRUE if a dependency is found
3603 */
3604
3605 BOOL
3606 readconf_depends(driver_instance *d, uschar *s)
3607 {
3608 int count = *(d->info->options_count);
3609 optionlist *ol;
3610 uschar *ss;
3611
3612 for (ol = d->info->options; ol < d->info->options + count; ol++)
3613   {
3614   void *options_block;
3615   uschar *value;
3616   int type = ol->type & opt_mask;
3617   if (type != opt_stringptr) continue;
3618   options_block = ((ol->type & opt_public) == 0)? d->options_block : (void *)d;
3619   value = *(uschar **)((uschar *)options_block + (long int)(ol->value));
3620   if (value != NULL && (ss = Ustrstr(value, s)) != NULL)
3621     {
3622     if (ss <= value || (ss[-1] != '$' && ss[-1] != '{') ||
3623       isalnum(ss[Ustrlen(s)])) continue;
3624     DEBUG(D_transport) debug_printf("driver %s: \"%s\" option depends on %s\n",
3625       d->name, ol->name, s);
3626     return TRUE;
3627     }
3628   }
3629
3630 DEBUG(D_transport) debug_printf("driver %s does not depend on %s\n", d->name, s);
3631 return FALSE;
3632 }
3633
3634
3635
3636
3637 /*************************************************
3638 *      Decode an error type for retries          *
3639 *************************************************/
3640
3641 /* This function is global because it is also called from the main
3642 program when testing retry information. It decodes strings such as "quota_7d"
3643 into numerical error codes.
3644
3645 Arguments:
3646   pp           points to start of text
3647   p            points past end of text
3648   basic_errno  points to an int to receive the main error number
3649   more_errno   points to an int to receive the secondary error data
3650
3651 Returns:       NULL if decoded correctly; else points to error text
3652 */
3653
3654 uschar *
3655 readconf_retry_error(uschar *pp, uschar *p, int *basic_errno, int *more_errno)
3656 {
3657 int len;
3658 uschar *q = pp;
3659 while (q < p && *q != '_') q++;
3660 len = q - pp;
3661
3662 if (len == 5 && strncmpic(pp, US"quota", len) == 0)
3663   {
3664   *basic_errno = ERRNO_EXIMQUOTA;
3665   if (q != p && (*more_errno = readconf_readtime(q+1, *p, FALSE)) < 0)
3666       return US"bad time value";
3667   }
3668
3669 else if (len == 7 && strncmpic(pp, US"refused", len) == 0)
3670   {
3671   *basic_errno = ECONNREFUSED;
3672   if (q != p)
3673     {
3674     if (strncmpic(q+1, US"MX", p-q-1) == 0) *more_errno = 'M';
3675     else if (strncmpic(q+1, US"A", p-q-1) == 0) *more_errno = 'A';
3676     else return US"A or MX expected after \"refused\"";
3677     }
3678   }
3679
3680 else if (len == 7 && strncmpic(pp, US"timeout", len) == 0)
3681   {
3682   *basic_errno = ETIMEDOUT;
3683   if (q != p)
3684     {
3685     int i;
3686     int xlen = p - q - 1;
3687     uschar *x = q + 1;
3688
3689     static uschar *extras[] =
3690       { US"A", US"MX", US"connect", US"connect_A",  US"connect_MX" };
3691     static int values[] =
3692       { 'A',   'M',    RTEF_CTOUT,  RTEF_CTOUT|'A', RTEF_CTOUT|'M' };
3693
3694     for (i = 0; i < sizeof(extras)/sizeof(uschar *); i++)
3695       {
3696       if (strncmpic(x, extras[i], xlen) == 0)
3697         {
3698         *more_errno = values[i];
3699         break;
3700         }
3701       }
3702
3703     if (i >= sizeof(extras)/sizeof(uschar *))
3704       {
3705       if (strncmpic(x, US"DNS", xlen) == 0)
3706         {
3707         log_write(0, LOG_MAIN|LOG_PANIC, "\"timeout_dns\" is no longer "
3708           "available in retry rules (it has never worked) - treated as "
3709           "\"timeout\"");
3710         }
3711       else return US"\"A\", \"MX\", or \"connect\" expected after \"timeout\"";
3712       }
3713     }
3714   }
3715
3716 else if (strncmpic(pp, US"mail_4", 6) == 0 ||
3717          strncmpic(pp, US"rcpt_4", 6) == 0 ||
3718          strncmpic(pp, US"data_4", 6) == 0)
3719   {
3720   BOOL bad = FALSE;
3721   int x = 255;                           /* means "any 4xx code" */
3722   if (p != pp + 8) bad = TRUE; else
3723     {
3724     int a = pp[6], b = pp[7];
3725     if (isdigit(a))
3726       {
3727       x = (a - '0') * 10;
3728       if (isdigit(b)) x += b - '0';
3729       else if (b == 'x') x += 100;
3730       else bad = TRUE;
3731       }
3732     else if (a != 'x' || b != 'x') bad = TRUE;
3733     }
3734
3735   if (bad)
3736     return string_sprintf("%.4s_4 must be followed by xx, dx, or dd, where "
3737       "x is literal and d is any digit", pp);
3738
3739   *basic_errno = (*pp == 'm')? ERRNO_MAIL4XX :
3740                  (*pp == 'r')? ERRNO_RCPT4XX : ERRNO_DATA4XX;
3741   *more_errno = x << 8;
3742   }
3743
3744 else if (len == 4 && strncmpic(pp, US"auth", len) == 0 &&
3745          strncmpic(q+1, US"failed", p-q-1) == 0)
3746   *basic_errno = ERRNO_AUTHFAIL;
3747
3748 else if (strncmpic(pp, US"lost_connection", p - pp) == 0)
3749   *basic_errno = ERRNO_SMTPCLOSED;
3750
3751 else if (strncmpic(pp, US"tls_required", p - pp) == 0)
3752   *basic_errno = ERRNO_TLSREQUIRED;
3753
3754 else if (len != 1 || Ustrncmp(pp, "*", 1) != 0)
3755   return string_sprintf("unknown or malformed retry error \"%.*s\"", (int) (p-pp), pp);
3756
3757 return NULL;
3758 }
3759
3760
3761
3762
3763 /*************************************************
3764 *                Read retry information          *
3765 *************************************************/
3766
3767 /* Each line of retry information contains:
3768
3769 .  A domain name pattern or an address pattern;
3770
3771 .  An error name, possibly with additional data, or *;
3772
3773 .  An optional sequence of retry items, each consisting of an identifying
3774    letter, a cutoff time, and optional parameters.
3775
3776 All this is decoded and placed into a control block. */
3777
3778
3779 /* Subroutine to read an argument, preceded by a comma and terminated
3780 by comma, semicolon, whitespace, or newline. The types are: 0 = time value,
3781 1 = fixed point number (returned *1000).
3782
3783 Arguments:
3784   paddr     pointer to pointer to current character; updated
3785   type      0 => read a time; 1 => read a fixed point number
3786
3787 Returns:    time in seconds or fixed point number * 1000
3788 */
3789
3790 static int
3791 retry_arg(uschar **paddr, int type)
3792 {
3793 uschar *p = *paddr;
3794 uschar *pp;
3795
3796 if (*p++ != ',') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma expected");
3797
3798 while (isspace(*p)) p++;
3799 pp = p;
3800 while (isalnum(*p) || (type == 1 && *p == '.')) p++;
3801
3802 if (*p != 0 && !isspace(*p) && *p != ',' && *p != ';')
3803   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma or semicolon expected");
3804
3805 *paddr = p;
3806 switch (type)
3807   {
3808   case 0:
3809   return readconf_readtime(pp, *p, FALSE);
3810   case 1:
3811   return readconf_readfixed(pp, *p);
3812   }
3813 return 0;    /* Keep picky compilers happy */
3814 }
3815
3816 /* The function proper */
3817
3818 void
3819 readconf_retries(void)
3820 {
3821 retry_config **chain = &retries;
3822 retry_config *next;
3823 uschar *p;
3824
3825 while ((p = get_config_line()) != NULL)
3826   {
3827   retry_rule **rchain;
3828   uschar *pp, *error;
3829
3830   next = store_get(sizeof(retry_config));
3831   next->next = NULL;
3832   *chain = next;
3833   chain = &(next->next);
3834   next->basic_errno = next->more_errno = 0;
3835   next->senders = NULL;
3836   next->rules = NULL;
3837   rchain = &(next->rules);
3838
3839   next->pattern = string_dequote(&p);
3840   while (isspace(*p)) p++;
3841   pp = p;
3842   while (mac_isgraph(*p)) p++;
3843   if (p - pp <= 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3844     "missing error type in retry rule");
3845
3846   /* Test error names for things we understand. */
3847
3848   if ((error = readconf_retry_error(pp, p, &(next->basic_errno),
3849        &(next->more_errno))) != NULL)
3850     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s", error);
3851
3852   /* There may be an optional address list of senders to be used as another
3853   constraint on the rule. This was added later, so the syntax is a bit of a
3854   fudge. Anything that is not a retry rule starting "F," or "G," is treated as
3855   an address list. */
3856
3857   while (isspace(*p)) p++;
3858   if (Ustrncmp(p, "senders", 7) == 0)
3859     {
3860     p += 7;
3861     while (isspace(*p)) p++;
3862     if (*p++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3863       "\"=\" expected after \"senders\" in retry rule");
3864     while (isspace(*p)) p++;
3865     next->senders = string_dequote(&p);
3866     }
3867
3868   /* Now the retry rules. Keep the maximum timeout encountered. */
3869
3870   while (isspace(*p)) p++;
3871
3872   while (*p != 0)
3873     {
3874     retry_rule *rule = store_get(sizeof(retry_rule));
3875     *rchain = rule;
3876     rchain = &(rule->next);
3877     rule->next = NULL;
3878     rule->rule = toupper(*p++);
3879     rule->timeout = retry_arg(&p, 0);
3880     if (rule->timeout > retry_maximum_timeout)
3881       retry_maximum_timeout = rule->timeout;
3882
3883     switch (rule->rule)
3884       {
3885       case 'F':   /* Fixed interval */
3886       rule->p1 = retry_arg(&p, 0);
3887       break;
3888
3889       case 'G':   /* Geometrically increasing intervals */
3890       case 'H':   /* Ditto, but with randomness */
3891       rule->p1 = retry_arg(&p, 0);
3892       rule->p2 = retry_arg(&p, 1);
3893       break;
3894
3895       default:
3896       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unknown retry rule letter");
3897       break;
3898       }
3899
3900     if (rule->timeout <= 0 || rule->p1 <= 0 ||
3901           (rule->rule != 'F' && rule->p2 < 1000))
3902       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3903         "bad parameters for retry rule");
3904
3905     while (isspace(*p)) p++;
3906     if (*p == ';')
3907       {
3908       p++;
3909       while (isspace(*p)) p++;
3910       }
3911     else if (*p != 0)
3912       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "semicolon expected");
3913     }
3914   }
3915 }
3916
3917
3918
3919 /*************************************************
3920 *         Initialize authenticators              *
3921 *************************************************/
3922
3923 /* Read the authenticators section of the configuration file.
3924
3925 Arguments:   none
3926 Returns:     nothing
3927 */
3928
3929 static void
3930 auths_init(void)
3931 {
3932 auth_instance *au, *bu;
3933 readconf_driver_init(US"authenticator",
3934   (driver_instance **)(&auths),      /* chain anchor */
3935   (driver_info *)auths_available,    /* available drivers */
3936   sizeof(auth_info),                 /* size of info block */
3937   &auth_defaults,                    /* default values for generic options */
3938   sizeof(auth_instance),             /* size of instance block */
3939   optionlist_auths,                  /* generic options */
3940   optionlist_auths_size);
3941
3942 for (au = auths; au != NULL; au = au->next)
3943   {
3944   if (au->public_name == NULL)
3945     log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "no public name specified for "
3946       "the %s authenticator", au->name);
3947   for (bu = au->next; bu != NULL; bu = bu->next)
3948     {
3949     if (strcmpic(au->public_name, bu->public_name) == 0)
3950       {
3951       if ((au->client && bu->client) || (au->server && bu->server))
3952         log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "two %s authenticators "
3953           "(%s and %s) have the same public name (%s)",
3954           (au->client)? US"client" : US"server", au->name, bu->name,
3955           au->public_name);
3956       }
3957     }
3958   }
3959 }
3960
3961
3962
3963
3964 /*************************************************
3965 *             Read ACL information               *
3966 *************************************************/
3967
3968 /* If this run of Exim is not doing something that involves receiving a
3969 message, we can just skip over the ACL information. No need to parse it.
3970
3971 First, we have a function for acl_read() to call back to get the next line. We
3972 need to remember the line we passed, because at the end it will contain the
3973 name of the next ACL. */
3974
3975 static uschar *acl_line;
3976
3977 static uschar *
3978 acl_callback(void)
3979 {
3980 acl_line = get_config_line();
3981 return acl_line;
3982 }
3983
3984
3985 /* Now the main function:
3986
3987 Arguments:    none
3988 Returns:      nothing
3989 */
3990
3991 static void
3992 readconf_acl(void)
3993 {
3994 uschar *p;
3995
3996 /* Read each ACL and add it into the tree. Macro (re)definitions are allowed
3997 between ACLs. */
3998
3999 acl_line = get_config_line();
4000
4001 while(acl_line != NULL)
4002   {
4003   uschar name[64];
4004   tree_node *node;
4005   uschar *error;
4006
4007   p = readconf_readname(name, sizeof(name), acl_line);
4008   if (isupper(*name) && *p == '=')
4009     {
4010     read_macro_assignment(acl_line);
4011     acl_line = get_config_line();
4012     continue;
4013     }
4014
4015   if (*p != ':' || name[0] == 0)
4016     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing or malformed ACL name");
4017
4018   node = store_get(sizeof(tree_node) + Ustrlen(name));
4019   Ustrcpy(node->name, name);
4020   if (!tree_insertnode(&acl_anchor, node))
4021     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4022       "there are two ACLs called \"%s\"", name);
4023
4024   node->data.ptr = acl_read(acl_callback, &error);
4025
4026   if (node->data.ptr == NULL && error != NULL)
4027     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "error in ACL: %s", error);
4028   }
4029 }
4030
4031
4032
4033 /*************************************************
4034 *     Read configuration for local_scan()        *
4035 *************************************************/
4036
4037 /* This function is called after "begin local_scan" is encountered in the
4038 configuration file. If the local_scan() function allows for configuration
4039 options, we can process them. Otherwise, we expire in a panic.
4040
4041 Arguments:  none
4042 Returns:    nothing
4043 */
4044
4045 static void
4046 local_scan_init(void)
4047 {
4048 #ifndef LOCAL_SCAN_HAS_OPTIONS
4049 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "local_scan() options not supported: "
4050   "(LOCAL_SCAN_HAS_OPTIONS not defined in Local/Makefile)");
4051 #else
4052
4053 uschar *p;
4054 while ((p = get_config_line()) != NULL)
4055   {
4056   (void) readconf_handle_option(p, local_scan_options, local_scan_options_count,
4057     NULL, US"local_scan option \"%s\" unknown");
4058   }
4059 #endif
4060 }
4061
4062
4063
4064 /*************************************************
4065 *     Read rest of configuration (after main)    *
4066 *************************************************/
4067
4068 /* This function reads the rest of the runtime configuration, after the main
4069 configuration. It is called only when actually needed. Each subsequent section
4070 of the configuration starts with a line of the form
4071
4072   begin name
4073
4074 where the name is "routers", "transports", etc. A section is terminated by
4075 hitting the next "begin" line, and the next name is left in next_section.
4076 Because it may confuse people as to whether the names are singular or plural,
4077 we add "s" if it's missing. There is always enough room in next_section for
4078 this. This function is basically just a switch.
4079
4080 Arguments:   none
4081 Returns:     nothing
4082 */
4083
4084 static uschar *section_list[] = {
4085   US"acls",
4086   US"authenticators",
4087   US"local_scans",
4088   US"retrys",
4089   US"rewrites",
4090   US"routers",
4091   US"transports"};
4092
4093 void
4094 readconf_rest(void)
4095 {
4096 int had = 0;
4097
4098 while(next_section[0] != 0)
4099   {
4100   int bit;
4101   int first = 0;
4102   int last = sizeof(section_list) / sizeof(uschar *);
4103   int mid = last/2;
4104   int n = Ustrlen(next_section);
4105
4106   if (tolower(next_section[n-1]) != 's') Ustrcpy(next_section+n, "s");
4107
4108   for (;;)
4109     {
4110     int c = strcmpic(next_section, section_list[mid]);
4111     if (c == 0) break;
4112     if (c > 0) first = mid + 1; else last = mid;
4113     if (first >= last)
4114       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4115         "\"%.*s\" is not a known configuration section name", n, next_section);
4116     mid = (last + first)/2;
4117     }
4118
4119   bit = 1 << mid;
4120   if (((had ^= bit) & bit) == 0)
4121     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4122       "\"%.*s\" section is repeated in the configuration file", n,
4123         next_section);
4124
4125   switch(mid)
4126     {
4127     case 0: readconf_acl(); break;
4128     case 1: auths_init(); break;
4129     case 2: local_scan_init(); break;
4130     case 3: readconf_retries(); break;
4131     case 4: readconf_rewrites(); break;
4132     case 5: route_init(); break;
4133     case 6: transport_init(); break;
4134     }
4135   }
4136
4137 (void)fclose(config_file);
4138 }
4139
4140 /* vi: aw ai sw=2
4141 */
4142 /* End of readconf.c */