src/src/readconf.c

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