src/src/readconf.c

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