src/src/readconf.c

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