src/src/readconf.c

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