src/src/readconf.c

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