src/src/readconf.c

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