src/src/readconf.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2016 */
   6 /* See the file NOTICE for conditions of use and distribution. */
   7
   8 /* Functions for reading the configuration file, and for displaying
   9 overall configuration values. Thanks to Brian Candler for the original
  10 implementation of the conditional .ifdef etc. */
  11
  12 #include "exim.h"
  13
  14 extern char **environ;
  15
  16 static void fn_smtp_receive_timeout(const uschar * name, const uschar * str);
  17 static void save_config_line(const uschar* line);
  18 static void save_config_position(const uschar *file, int line);
  19 static void print_config(BOOL admin, BOOL terse);
  20 static void readconf_options_auths(void);
  21
  22
  23 #define CSTATE_STACK_SIZE 10
  24
  25
  26 /* Structure for chain (stack) of .included files */
  27
  28 typedef struct config_file_item {
  29   struct config_file_item *next;
  30   uschar *filename;
  31   FILE *file;
  32   int lineno;
  33 } config_file_item;
  34
  35 /* Structure for chain of configuration lines (-bP config) */
  36
  37 typedef struct config_line_item {
  38   struct config_line_item *next;
  39   uschar *line;
  40 } config_line_item;
  41
  42 static config_line_item* config_lines;
  43
  44 /* Structure of table of conditional words and their state transitions */
  45
  46 typedef struct cond_item {
  47   uschar *name;
  48   int    namelen;
  49   int    action1;
  50   int    action2;
  51   int    pushpop;
  52 } cond_item;
  53
  54 /* Structure of table of syslog facility names and values */
  55
  56 typedef struct syslog_fac_item {
  57   uschar *name;
  58   int    value;
  59 } syslog_fac_item;
  60
  61 /* constants */
  62 static const char * const hidden = "<value not displayable>";
  63
  64 /* Static variables */
  65
  66 static config_file_item *config_file_stack = NULL;  /* For includes */
  67
  68 static uschar *syslog_facility_str  = NULL;
  69 static uschar next_section[24];
  70 static uschar time_buffer[24];
  71
  72 /* State variables for conditional loading (.ifdef / .else / .endif) */
  73
  74 static int cstate = 0;
  75 static int cstate_stack_ptr = -1;
  76 static int cstate_stack[CSTATE_STACK_SIZE];
  77
  78 /* Table of state transitions for handling conditional inclusions. There are
  79 four possible state transitions:
  80
  81   .ifdef true
  82   .ifdef false
  83   .elifdef true  (or .else)
  84   .elifdef false
  85
  86 .endif just causes the previous cstate to be popped off the stack */
  87
  88 static int next_cstate[3][4] =
  89   {
  90   /* State 0: reading from file, or reading until next .else or .endif */
  91   { 0, 1, 2, 2 },
  92   /* State 1: condition failed, skipping until next .else or .endif */
  93   { 2, 2, 0, 1 },
  94   /* State 2: skipping until .endif */
  95   { 2, 2, 2, 2 },
  96   };
  97
  98 /* Table of conditionals and the states to set. For each name, there are four
  99 values: the length of the name (to save computing it each time), the state to
 100 set if a macro was found in the line, the state to set if a macro was not found
 101 in the line, and a stack manipulation setting which is:
 102
 103   -1   pull state value off the stack
 104    0   don't alter the stack
 105   +1   push value onto stack, before setting new state
 106 */
 107
 108 static cond_item cond_list[] = {
 109   { US"ifdef",    5, 0, 1,  1 },
 110   { US"ifndef",   6, 1, 0,  1 },
 111   { US"elifdef",  7, 2, 3,  0 },
 112   { US"elifndef", 8, 3, 2,  0 },
 113   { US"else",     4, 2, 2,  0 },
 114   { US"endif",    5, 0, 0, -1 }
 115 };
 116
 117 static int cond_list_size = sizeof(cond_list)/sizeof(cond_item);
 118
 119 /* Table of syslog facility names and their values */
 120
 121 static syslog_fac_item syslog_list[] = {
 122   { US"mail",   LOG_MAIL },
 123   { US"user",   LOG_USER },
 124   { US"news",   LOG_NEWS },
 125   { US"uucp",   LOG_UUCP },
 126   { US"local0", LOG_LOCAL0 },
 127   { US"local1", LOG_LOCAL1 },
 128   { US"local2", LOG_LOCAL2 },
 129   { US"local3", LOG_LOCAL3 },
 130   { US"local4", LOG_LOCAL4 },
 131   { US"local5", LOG_LOCAL5 },
 132   { US"local6", LOG_LOCAL6 },
 133   { US"local7", LOG_LOCAL7 },
 134   { US"daemon", LOG_DAEMON }
 135 };
 136
 137 static int syslog_list_size = sizeof(syslog_list)/sizeof(syslog_fac_item);
 138
 139
 140
 141
 142 /*************************************************
 143 *           Main configuration options           *
 144 *************************************************/
 145
 146 /* The list of options that can be set in the main configuration file. This
 147 must be in alphabetic order because it is searched by binary chop. */
 148
 149 static optionlist optionlist_config[] = {
 150   { "*set_exim_group",          opt_bool|opt_hidden, &exim_gid_set },
 151   { "*set_exim_user",           opt_bool|opt_hidden, &exim_uid_set },
 152   { "*set_system_filter_group", opt_bool|opt_hidden, &system_filter_gid_set },
 153   { "*set_system_filter_user",  opt_bool|opt_hidden, &system_filter_uid_set },
 154   { "accept_8bitmime",          opt_bool,        &accept_8bitmime },
 155   { "acl_not_smtp",             opt_stringptr,   &acl_not_smtp },
 156 #ifdef WITH_CONTENT_SCAN
 157   { "acl_not_smtp_mime",        opt_stringptr,   &acl_not_smtp_mime },
 158 #endif
 159   { "acl_not_smtp_start",       opt_stringptr,   &acl_not_smtp_start },
 160   { "acl_smtp_auth",            opt_stringptr,   &acl_smtp_auth },
 161   { "acl_smtp_connect",         opt_stringptr,   &acl_smtp_connect },
 162   { "acl_smtp_data",            opt_stringptr,   &acl_smtp_data },
 163 #ifndef DISABLE_PRDR
 164   { "acl_smtp_data_prdr",       opt_stringptr,   &acl_smtp_data_prdr },
 165 #endif
 166 #ifndef DISABLE_DKIM
 167   { "acl_smtp_dkim",            opt_stringptr,   &acl_smtp_dkim },
 168 #endif
 169   { "acl_smtp_etrn",            opt_stringptr,   &acl_smtp_etrn },
 170   { "acl_smtp_expn",            opt_stringptr,   &acl_smtp_expn },
 171   { "acl_smtp_helo",            opt_stringptr,   &acl_smtp_helo },
 172   { "acl_smtp_mail",            opt_stringptr,   &acl_smtp_mail },
 173   { "acl_smtp_mailauth",        opt_stringptr,   &acl_smtp_mailauth },
 174 #ifdef WITH_CONTENT_SCAN
 175   { "acl_smtp_mime",            opt_stringptr,   &acl_smtp_mime },
 176 #endif
 177   { "acl_smtp_notquit",         opt_stringptr,   &acl_smtp_notquit },
 178   { "acl_smtp_predata",         opt_stringptr,   &acl_smtp_predata },
 179   { "acl_smtp_quit",            opt_stringptr,   &acl_smtp_quit },
 180   { "acl_smtp_rcpt",            opt_stringptr,   &acl_smtp_rcpt },
 181 #ifdef SUPPORT_TLS
 182   { "acl_smtp_starttls",        opt_stringptr,   &acl_smtp_starttls },
 183 #endif
 184   { "acl_smtp_vrfy",            opt_stringptr,   &acl_smtp_vrfy },
 185   { "add_environment",          opt_stringptr,   &add_environment },
 186   { "admin_groups",             opt_gidlist,     &admin_groups },
 187   { "allow_domain_literals",    opt_bool,        &allow_domain_literals },
 188   { "allow_mx_to_ip",           opt_bool,        &allow_mx_to_ip },
 189   { "allow_utf8_domains",       opt_bool,        &allow_utf8_domains },
 190   { "auth_advertise_hosts",     opt_stringptr,   &auth_advertise_hosts },
 191   { "auto_thaw",                opt_time,        &auto_thaw },
 192 #ifdef WITH_CONTENT_SCAN
 193   { "av_scanner",               opt_stringptr,   &av_scanner },
 194 #endif
 195   { "bi_command",               opt_stringptr,   &bi_command },
 196 #ifdef EXPERIMENTAL_BRIGHTMAIL
 197   { "bmi_config_file",          opt_stringptr,   &bmi_config_file },
 198 #endif
 199   { "bounce_message_file",      opt_stringptr,   &bounce_message_file },
 200   { "bounce_message_text",      opt_stringptr,   &bounce_message_text },
 201   { "bounce_return_body",       opt_bool,        &bounce_return_body },
 202   { "bounce_return_linesize_limit", opt_mkint,   &bounce_return_linesize_limit },
 203   { "bounce_return_message",    opt_bool,        &bounce_return_message },
 204   { "bounce_return_size_limit", opt_mkint,       &bounce_return_size_limit },
 205   { "bounce_sender_authentication",opt_stringptr,&bounce_sender_authentication },
 206   { "callout_domain_negative_expire", opt_time,  &callout_cache_domain_negative_expire },
 207   { "callout_domain_positive_expire", opt_time,  &callout_cache_domain_positive_expire },
 208   { "callout_negative_expire",  opt_time,        &callout_cache_negative_expire },
 209   { "callout_positive_expire",  opt_time,        &callout_cache_positive_expire },
 210   { "callout_random_local_part",opt_stringptr,   &callout_random_local_part },
 211   { "check_log_inodes",         opt_int,         &check_log_inodes },
 212   { "check_log_space",          opt_Kint,        &check_log_space },
 213   { "check_rfc2047_length",     opt_bool,        &check_rfc2047_length },
 214   { "check_spool_inodes",       opt_int,         &check_spool_inodes },
 215   { "check_spool_space",        opt_Kint,        &check_spool_space },
 216   { "chunking_advertise_hosts", opt_stringptr,   &chunking_advertise_hosts },
 217   { "daemon_smtp_port",         opt_stringptr|opt_hidden, &daemon_smtp_port },
 218   { "daemon_smtp_ports",        opt_stringptr,   &daemon_smtp_port },
 219   { "daemon_startup_retries",   opt_int,         &daemon_startup_retries },
 220   { "daemon_startup_sleep",     opt_time,        &daemon_startup_sleep },
 221 #ifdef EXPERIMENTAL_DCC
 222   { "dcc_direct_add_header",    opt_bool,        &dcc_direct_add_header },
 223   { "dccifd_address",           opt_stringptr,   &dccifd_address },
 224   { "dccifd_options",           opt_stringptr,   &dccifd_options },
 225 #endif
 226   { "delay_warning",            opt_timelist,    &delay_warning },
 227   { "delay_warning_condition",  opt_stringptr,   &delay_warning_condition },
 228   { "deliver_drop_privilege",   opt_bool,        &deliver_drop_privilege },
 229   { "deliver_queue_load_max",   opt_fixed,       &deliver_queue_load_max },
 230   { "delivery_date_remove",     opt_bool,        &delivery_date_remove },
 231 #ifdef ENABLE_DISABLE_FSYNC
 232   { "disable_fsync",            opt_bool,        &disable_fsync },
 233 #endif
 234   { "disable_ipv6",             opt_bool,        &disable_ipv6 },
 235 #ifndef DISABLE_DKIM
 236   { "dkim_verify_signers",      opt_stringptr,   &dkim_verify_signers },
 237 #endif
 238 #ifdef EXPERIMENTAL_DMARC
 239   { "dmarc_forensic_sender",    opt_stringptr,   &dmarc_forensic_sender },
 240   { "dmarc_history_file",       opt_stringptr,   &dmarc_history_file },
 241   { "dmarc_tld_file",           opt_stringptr,   &dmarc_tld_file },
 242 #endif
 243   { "dns_again_means_nonexist", opt_stringptr,   &dns_again_means_nonexist },
 244   { "dns_check_names_pattern",  opt_stringptr,   &check_dns_names_pattern },
 245   { "dns_csa_search_limit",     opt_int,         &dns_csa_search_limit },
 246   { "dns_csa_use_reverse",      opt_bool,        &dns_csa_use_reverse },
 247   { "dns_dnssec_ok",            opt_int,         &dns_dnssec_ok },
 248   { "dns_ipv4_lookup",          opt_stringptr,   &dns_ipv4_lookup },
 249   { "dns_retrans",              opt_time,        &dns_retrans },
 250   { "dns_retry",                opt_int,         &dns_retry },
 251   { "dns_trust_aa",             opt_stringptr,   &dns_trust_aa },
 252   { "dns_use_edns0",            opt_int,         &dns_use_edns0 },
 253  /* This option is now a no-op, retained for compability */
 254   { "drop_cr",                  opt_bool,        &drop_cr },
 255 /*********************************************************/
 256   { "dsn_advertise_hosts",      opt_stringptr,   &dsn_advertise_hosts },
 257   { "dsn_from",                 opt_stringptr,   &dsn_from },
 258   { "envelope_to_remove",       opt_bool,        &envelope_to_remove },
 259   { "errors_copy",              opt_stringptr,   &errors_copy },
 260   { "errors_reply_to",          opt_stringptr,   &errors_reply_to },
 261 #ifndef DISABLE_EVENT
 262   { "event_action",             opt_stringptr,   &event_action },
 263 #endif
 264   { "exim_group",               opt_gid,         &exim_gid },
 265   { "exim_path",                opt_stringptr,   &exim_path },
 266   { "exim_user",                opt_uid,         &exim_uid },
 267   { "extra_local_interfaces",   opt_stringptr,   &extra_local_interfaces },
 268   { "extract_addresses_remove_arguments", opt_bool, &extract_addresses_remove_arguments },
 269   { "finduser_retries",         opt_int,         &finduser_retries },
 270   { "freeze_tell",              opt_stringptr,   &freeze_tell },
 271   { "gecos_name",               opt_stringptr,   &gecos_name },
 272   { "gecos_pattern",            opt_stringptr,   &gecos_pattern },
 273 #ifdef SUPPORT_TLS
 274   { "gnutls_allow_auto_pkcs11", opt_bool,        &gnutls_allow_auto_pkcs11 },
 275   { "gnutls_compat_mode",       opt_bool,        &gnutls_compat_mode },
 276 #endif
 277   { "header_line_maxsize",      opt_int,         &header_line_maxsize },
 278   { "header_maxsize",           opt_int,         &header_maxsize },
 279   { "headers_charset",          opt_stringptr,   &headers_charset },
 280   { "helo_accept_junk_hosts",   opt_stringptr,   &helo_accept_junk_hosts },
 281   { "helo_allow_chars",         opt_stringptr,   &helo_allow_chars },
 282   { "helo_lookup_domains",      opt_stringptr,   &helo_lookup_domains },
 283   { "helo_try_verify_hosts",    opt_stringptr,   &helo_try_verify_hosts },
 284   { "helo_verify_hosts",        opt_stringptr,   &helo_verify_hosts },
 285   { "hold_domains",             opt_stringptr,   &hold_domains },
 286   { "host_lookup",              opt_stringptr,   &host_lookup },
 287   { "host_lookup_order",        opt_stringptr,   &host_lookup_order },
 288   { "host_reject_connection",   opt_stringptr,   &host_reject_connection },
 289   { "hosts_connection_nolog",   opt_stringptr,   &hosts_connection_nolog },
 290 #ifdef SUPPORT_PROXY
 291   { "hosts_proxy",              opt_stringptr,   &hosts_proxy },
 292 #endif
 293   { "hosts_treat_as_local",     opt_stringptr,   &hosts_treat_as_local },
 294 #ifdef LOOKUP_IBASE
 295   { "ibase_servers",            opt_stringptr,   &ibase_servers },
 296 #endif
 297   { "ignore_bounce_errors_after", opt_time,      &ignore_bounce_errors_after },
 298   { "ignore_fromline_hosts",    opt_stringptr,   &ignore_fromline_hosts },
 299   { "ignore_fromline_local",    opt_bool,        &ignore_fromline_local },
 300   { "keep_environment",         opt_stringptr,   &keep_environment },
 301   { "keep_malformed",           opt_time,        &keep_malformed },
 302 #ifdef LOOKUP_LDAP
 303   { "ldap_ca_cert_dir",         opt_stringptr,   &eldap_ca_cert_dir },
 304   { "ldap_ca_cert_file",        opt_stringptr,   &eldap_ca_cert_file },
 305   { "ldap_cert_file",           opt_stringptr,   &eldap_cert_file },
 306   { "ldap_cert_key",            opt_stringptr,   &eldap_cert_key },
 307   { "ldap_cipher_suite",        opt_stringptr,   &eldap_cipher_suite },
 308   { "ldap_default_servers",     opt_stringptr,   &eldap_default_servers },
 309   { "ldap_require_cert",        opt_stringptr,   &eldap_require_cert },
 310   { "ldap_start_tls",           opt_bool,        &eldap_start_tls },
 311   { "ldap_version",             opt_int,         &eldap_version },
 312 #endif
 313   { "local_from_check",         opt_bool,        &local_from_check },
 314   { "local_from_prefix",        opt_stringptr,   &local_from_prefix },
 315   { "local_from_suffix",        opt_stringptr,   &local_from_suffix },
 316   { "local_interfaces",         opt_stringptr,   &local_interfaces },
 317   { "local_scan_timeout",       opt_time,        &local_scan_timeout },
 318   { "local_sender_retain",      opt_bool,        &local_sender_retain },
 319   { "localhost_number",         opt_stringptr,   &host_number_string },
 320   { "log_file_path",            opt_stringptr,   &log_file_path },
 321   { "log_selector",             opt_stringptr,   &log_selector_string },
 322   { "log_timezone",             opt_bool,        &log_timezone },
 323   { "lookup_open_max",          opt_int,         &lookup_open_max },
 324   { "max_username_length",      opt_int,         &max_username_length },
 325   { "message_body_newlines",    opt_bool,        &message_body_newlines },
 326   { "message_body_visible",     opt_mkint,       &message_body_visible },
 327   { "message_id_header_domain", opt_stringptr,   &message_id_domain },
 328   { "message_id_header_text",   opt_stringptr,   &message_id_text },
 329   { "message_logs",             opt_bool,        &message_logs },
 330   { "message_size_limit",       opt_stringptr,   &message_size_limit },
 331 #ifdef SUPPORT_MOVE_FROZEN_MESSAGES
 332   { "move_frozen_messages",     opt_bool,        &move_frozen_messages },
 333 #endif
 334   { "mua_wrapper",              opt_bool,        &mua_wrapper },
 335 #ifdef LOOKUP_MYSQL
 336   { "mysql_servers",            opt_stringptr,   &mysql_servers },
 337 #endif
 338   { "never_users",              opt_uidlist,     &never_users },
 339 #ifdef SUPPORT_TLS
 340   { "openssl_options",          opt_stringptr,   &openssl_options },
 341 #endif
 342 #ifdef LOOKUP_ORACLE
 343   { "oracle_servers",           opt_stringptr,   &oracle_servers },
 344 #endif
 345   { "percent_hack_domains",     opt_stringptr,   &percent_hack_domains },
 346 #ifdef EXIM_PERL
 347   { "perl_at_start",            opt_bool,        &opt_perl_at_start },
 348   { "perl_startup",             opt_stringptr,   &opt_perl_startup },
 349   { "perl_taintmode",           opt_bool,        &opt_perl_taintmode },
 350 #endif
 351 #ifdef LOOKUP_PGSQL
 352   { "pgsql_servers",            opt_stringptr,   &pgsql_servers },
 353 #endif
 354   { "pid_file_path",            opt_stringptr,   &pid_file_path },
 355   { "pipelining_advertise_hosts", opt_stringptr, &pipelining_advertise_hosts },
 356 #ifndef DISABLE_PRDR
 357   { "prdr_enable",              opt_bool,        &prdr_enable },
 358 #endif
 359   { "preserve_message_logs",    opt_bool,        &preserve_message_logs },
 360   { "primary_hostname",         opt_stringptr,   &primary_hostname },
 361   { "print_topbitchars",        opt_bool,        &print_topbitchars },
 362   { "process_log_path",         opt_stringptr,   &process_log_path },
 363   { "prod_requires_admin",      opt_bool,        &prod_requires_admin },
 364   { "qualify_domain",           opt_stringptr,   &qualify_domain_sender },
 365   { "qualify_recipient",        opt_stringptr,   &qualify_domain_recipient },
 366   { "queue_domains",            opt_stringptr,   &queue_domains },
 367   { "queue_list_requires_admin",opt_bool,        &queue_list_requires_admin },
 368   { "queue_only",               opt_bool,        &queue_only },
 369   { "queue_only_file",          opt_stringptr,   &queue_only_file },
 370   { "queue_only_load",          opt_fixed,       &queue_only_load },
 371   { "queue_only_load_latch",    opt_bool,        &queue_only_load_latch },
 372   { "queue_only_override",      opt_bool,        &queue_only_override },
 373   { "queue_run_in_order",       opt_bool,        &queue_run_in_order },
 374   { "queue_run_max",            opt_stringptr,   &queue_run_max },
 375   { "queue_smtp_domains",       opt_stringptr,   &queue_smtp_domains },
 376   { "receive_timeout",          opt_time,        &receive_timeout },
 377   { "received_header_text",     opt_stringptr,   &received_header_text },
 378   { "received_headers_max",     opt_int,         &received_headers_max },
 379   { "recipient_unqualified_hosts", opt_stringptr, &recipient_unqualified_hosts },
 380   { "recipients_max",           opt_int,         &recipients_max },
 381   { "recipients_max_reject",    opt_bool,        &recipients_max_reject },
 382 #ifdef LOOKUP_REDIS
 383   { "redis_servers",            opt_stringptr,   &redis_servers },
 384 #endif
 385   { "remote_max_parallel",      opt_int,         &remote_max_parallel },
 386   { "remote_sort_domains",      opt_stringptr,   &remote_sort_domains },
 387   { "retry_data_expire",        opt_time,        &retry_data_expire },
 388   { "retry_interval_max",       opt_time,        &retry_interval_max },
 389   { "return_path_remove",       opt_bool,        &return_path_remove },
 390   { "return_size_limit",        opt_mkint|opt_hidden, &bounce_return_size_limit },
 391   { "rfc1413_hosts",            opt_stringptr,   &rfc1413_hosts },
 392   { "rfc1413_query_timeout",    opt_time,        &rfc1413_query_timeout },
 393   { "sender_unqualified_hosts", opt_stringptr,   &sender_unqualified_hosts },
 394   { "slow_lookup_log",          opt_int,         &slow_lookup_log },
 395   { "smtp_accept_keepalive",    opt_bool,        &smtp_accept_keepalive },
 396   { "smtp_accept_max",          opt_int,         &smtp_accept_max },
 397   { "smtp_accept_max_nonmail",  opt_int,         &smtp_accept_max_nonmail },
 398   { "smtp_accept_max_nonmail_hosts", opt_stringptr, &smtp_accept_max_nonmail_hosts },
 399   { "smtp_accept_max_per_connection", opt_int,   &smtp_accept_max_per_connection },
 400   { "smtp_accept_max_per_host", opt_stringptr,   &smtp_accept_max_per_host },
 401   { "smtp_accept_queue",        opt_int,         &smtp_accept_queue },
 402   { "smtp_accept_queue_per_connection", opt_int, &smtp_accept_queue_per_connection },
 403   { "smtp_accept_reserve",      opt_int,         &smtp_accept_reserve },
 404   { "smtp_active_hostname",     opt_stringptr,   &raw_active_hostname },
 405   { "smtp_banner",              opt_stringptr,   &smtp_banner },
 406   { "smtp_check_spool_space",   opt_bool,        &smtp_check_spool_space },
 407   { "smtp_connect_backlog",     opt_int,         &smtp_connect_backlog },
 408   { "smtp_enforce_sync",        opt_bool,        &smtp_enforce_sync },
 409   { "smtp_etrn_command",        opt_stringptr,   &smtp_etrn_command },
 410   { "smtp_etrn_serialize",      opt_bool,        &smtp_etrn_serialize },
 411   { "smtp_load_reserve",        opt_fixed,       &smtp_load_reserve },
 412   { "smtp_max_synprot_errors",  opt_int,         &smtp_max_synprot_errors },
 413   { "smtp_max_unknown_commands",opt_int,         &smtp_max_unknown_commands },
 414   { "smtp_ratelimit_hosts",     opt_stringptr,   &smtp_ratelimit_hosts },
 415   { "smtp_ratelimit_mail",      opt_stringptr,   &smtp_ratelimit_mail },
 416   { "smtp_ratelimit_rcpt",      opt_stringptr,   &smtp_ratelimit_rcpt },
 417   { "smtp_receive_timeout",     opt_func,        &fn_smtp_receive_timeout },
 418   { "smtp_reserve_hosts",       opt_stringptr,   &smtp_reserve_hosts },
 419   { "smtp_return_error_details",opt_bool,        &smtp_return_error_details },
 420 #ifdef SUPPORT_I18N
 421   { "smtputf8_advertise_hosts", opt_stringptr,   &smtputf8_advertise_hosts },
 422 #endif
 423 #ifdef WITH_CONTENT_SCAN
 424   { "spamd_address",            opt_stringptr,   &spamd_address },
 425 #endif
 426 #ifdef EXPERIMENTAL_SPF
 427   { "spf_guess",                opt_stringptr,   &spf_guess },
 428 #endif
 429   { "split_spool_directory",    opt_bool,        &split_spool_directory },
 430   { "spool_directory",          opt_stringptr,   &spool_directory },
 431 #ifdef LOOKUP_SQLITE
 432   { "sqlite_lock_timeout",      opt_int,         &sqlite_lock_timeout },
 433 #endif
 434 #ifdef EXPERIMENTAL_SRS
 435   { "srs_config",               opt_stringptr,   &srs_config },
 436   { "srs_hashlength",           opt_int,         &srs_hashlength },
 437   { "srs_hashmin",              opt_int,         &srs_hashmin },
 438   { "srs_maxage",               opt_int,         &srs_maxage },
 439   { "srs_secrets",              opt_stringptr,   &srs_secrets },
 440   { "srs_usehash",              opt_bool,        &srs_usehash },
 441   { "srs_usetimestamp",         opt_bool,        &srs_usetimestamp },
 442 #endif
 443   { "strict_acl_vars",          opt_bool,        &strict_acl_vars },
 444   { "strip_excess_angle_brackets", opt_bool,     &strip_excess_angle_brackets },
 445   { "strip_trailing_dot",       opt_bool,        &strip_trailing_dot },
 446   { "syslog_duplication",       opt_bool,        &syslog_duplication },
 447   { "syslog_facility",          opt_stringptr,   &syslog_facility_str },
 448   { "syslog_processname",       opt_stringptr,   &syslog_processname },
 449   { "syslog_timestamp",         opt_bool,        &syslog_timestamp },
 450   { "system_filter",            opt_stringptr,   &system_filter },
 451   { "system_filter_directory_transport", opt_stringptr,&system_filter_directory_transport },
 452   { "system_filter_file_transport",opt_stringptr,&system_filter_file_transport },
 453   { "system_filter_group",      opt_gid,         &system_filter_gid },
 454   { "system_filter_pipe_transport",opt_stringptr,&system_filter_pipe_transport },
 455   { "system_filter_reply_transport",opt_stringptr,&system_filter_reply_transport },
 456   { "system_filter_user",       opt_uid,         &system_filter_uid },
 457   { "tcp_nodelay",              opt_bool,        &tcp_nodelay },
 458 #ifdef USE_TCP_WRAPPERS
 459   { "tcp_wrappers_daemon_name", opt_stringptr,   &tcp_wrappers_daemon_name },
 460 #endif
 461   { "timeout_frozen_after",     opt_time,        &timeout_frozen_after },
 462   { "timezone",                 opt_stringptr,   &timezone_string },
 463   { "tls_advertise_hosts",      opt_stringptr,   &tls_advertise_hosts },
 464 #ifdef SUPPORT_TLS
 465   { "tls_certificate",          opt_stringptr,   &tls_certificate },
 466   { "tls_crl",                  opt_stringptr,   &tls_crl },
 467   { "tls_dh_max_bits",          opt_int,         &tls_dh_max_bits },
 468   { "tls_dhparam",              opt_stringptr,   &tls_dhparam },
 469   { "tls_eccurve",              opt_stringptr,   &tls_eccurve },
 470 # ifndef DISABLE_OCSP
 471   { "tls_ocsp_file",            opt_stringptr,   &tls_ocsp_file },
 472 # endif
 473   { "tls_on_connect_ports",     opt_stringptr,   &tls_in.on_connect_ports },
 474   { "tls_privatekey",           opt_stringptr,   &tls_privatekey },
 475   { "tls_remember_esmtp",       opt_bool,        &tls_remember_esmtp },
 476   { "tls_require_ciphers",      opt_stringptr,   &tls_require_ciphers },
 477   { "tls_try_verify_hosts",     opt_stringptr,   &tls_try_verify_hosts },
 478   { "tls_verify_certificates",  opt_stringptr,   &tls_verify_certificates },
 479   { "tls_verify_hosts",         opt_stringptr,   &tls_verify_hosts },
 480 #endif
 481   { "trusted_groups",           opt_gidlist,     &trusted_groups },
 482   { "trusted_users",            opt_uidlist,     &trusted_users },
 483   { "unknown_login",            opt_stringptr,   &unknown_login },
 484   { "unknown_username",         opt_stringptr,   &unknown_username },
 485   { "untrusted_set_sender",     opt_stringptr,   &untrusted_set_sender },
 486   { "uucp_from_pattern",        opt_stringptr,   &uucp_from_pattern },
 487   { "uucp_from_sender",         opt_stringptr,   &uucp_from_sender },
 488   { "warn_message_file",        opt_stringptr,   &warn_message_file },
 489   { "write_rejectlog",          opt_bool,        &write_rejectlog }
 490 };
 491
 492 static int optionlist_config_size = nelem(optionlist_config);
 493
 494
 495
 496 /*************************************************
 497 *         Find the name of an option             *
 498 *************************************************/
 499
 500 /* This function is to aid debugging. Various functions take arguments that are
 501 pointer variables in the options table or in option tables for various drivers.
 502 For debugging output, it is useful to be able to find the name of the option
 503 which is currently being processed. This function finds it, if it exists, by
 504 searching the table(s).
 505
 506 Arguments:   a value that is presumed to be in the table above
 507 Returns:     the option name, or an empty string
 508 */
 509
 510 uschar *
 511 readconf_find_option(void *p)
 512 {
 513 int i;
 514 router_instance *r;
 515 transport_instance *t;
 516
 517 for (i = 0; i < nelem(optionlist_config); i++)
 518   if (p == optionlist_config[i].value) return US optionlist_config[i].name;
 519
 520 for (r = routers; r; r = r->next)
 521   {
 522   router_info *ri = r->info;
 523   for (i = 0; i < *ri->options_count; i++)
 524     {
 525     if ((ri->options[i].type & opt_mask) != opt_stringptr) continue;
 526     if (p == (char *)(r->options_block) + (long int)(ri->options[i].value))
 527       return US ri->options[i].name;
 528     }
 529   }
 530
 531 for (t = transports; t; t = t->next)
 532   {
 533   transport_info *ti = t->info;
 534   for (i = 0; i < *ti->options_count; i++)
 535     {
 536     optionlist * op = &ti->options[i];
 537     if ((op->type & opt_mask) != opt_stringptr) continue;
 538     if (p == (  op->type & opt_public
 539              ? (char *)t
 540              : (char *)t->options_block
 541              )
 542              + (long int)op->value)
 543         return US op->name;
 544     }
 545   }
 546
 547 return US"";
 548 }
 549
 550
 551
 552
 553 /*************************************************
 554 *       Deal with an assignment to a macro       *
 555 *************************************************/
 556
 557 /* This function is called when a line that starts with an upper case letter is
 558 encountered. The argument "line" should contain a complete logical line, and
 559 start with the first letter of the macro name. The macro name and the
 560 replacement text are extracted and stored. Redefinition of existing,
 561 non-command line, macros is permitted using '==' instead of '='.
 562
 563 Arguments:
 564   s            points to the start of the logical line
 565
 566 Returns:       nothing
 567 */
 568
 569 void
 570 read_macro_assignment(uschar *s)
 571 {
 572 uschar name[64];
 573 int namelen = 0;
 574 BOOL redef = FALSE;
 575 macro_item *m;
 576 macro_item *mlast = NULL;
 577
 578 while (isalnum(*s) || *s == '_')
 579   {
 580   if (namelen >= sizeof(name) - 1)
 581     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
 582       "macro name too long (maximum is " SIZE_T_FMT " characters)", sizeof(name) - 1);
 583   name[namelen++] = *s++;
 584   }
 585 name[namelen] = 0;
 586
 587 while (isspace(*s)) s++;
 588 if (*s++ != '=')
 589   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "malformed macro definition");
 590
 591 if (*s == '=')
 592   {
 593   redef = TRUE;
 594   s++;
 595   }
 596 while (isspace(*s)) s++;
 597
 598 /* If an existing macro of the same name was defined on the command line, we
 599 just skip this definition. It's an error to attempt to redefine a macro without
 600 redef set to TRUE, or to redefine a macro when it hasn't been defined earlier.
 601 It is also an error to define a macro whose name begins with the name of a
 602 previously defined macro. Note: it is documented that the other way round
 603 works. */
 604
 605 for (m = macros; m != NULL; m = m->next)
 606   {
 607   int len = Ustrlen(m->name);
 608
 609   if (Ustrcmp(m->name, name) == 0)
 610     {
 611     if (!m->command_line && !redef)
 612       log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "macro \"%s\" is already "
 613        "defined (use \"==\" if you want to redefine it", name);
 614     break;
 615     }
 616
 617   if (len < namelen && Ustrstr(name, m->name) != NULL)
 618     log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "\"%s\" cannot be defined as "
 619       "a macro because previously defined macro \"%s\" is a substring",
 620       name, m->name);
 621
 622   /* We cannot have this test, because it is documented that a substring
 623   macro is permitted (there is even an example).
 624   *
 625   * if (len > namelen && Ustrstr(m->name, name) != NULL)
 626   *   log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "\"%s\" cannot be defined as "
 627   *     "a macro because it is a substring of previously defined macro \"%s\"",
 628   *     name, m->name);
 629   */
 630
 631   mlast = m;
 632   }
 633
 634 /* Check for an overriding command-line definition. */
 635
 636 if (m != NULL && m->command_line) return;
 637
 638 /* Redefinition must refer to an existing macro. */
 639
 640 if (redef)
 641   {
 642   if (m == NULL)
 643     log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "can't redefine an undefined macro "
 644       "\"%s\"", name);
 645   }
 646
 647 /* We have a new definition. The macro_item structure includes a final vector
 648 called "name" which is one byte long. Thus, adding "namelen" gives us enough
 649 room to store the "name" string. */
 650
 651 else
 652   {
 653   m = store_get(sizeof(macro_item) + namelen);
 654   if (macros == NULL) macros = m; else mlast->next = m;
 655   Ustrncpy(m->name, name, namelen);
 656   m->name[namelen] = 0;
 657   m->next = NULL;
 658   m->command_line = FALSE;
 659   }
 660
 661 /* Set the value of the new or redefined macro */
 662
 663 m->replacement = string_copy(s);
 664 }
 665
 666
 667
 668
 669
 670 /*************************************************
 671 *            Read configuration line             *
 672 *************************************************/
 673
 674 /* A logical line of text is read from the configuration file into the big
 675 buffer, taking account of macros, .includes, and continuations. The size of
 676 big_buffer is increased if necessary. The count of configuration lines is
 677 maintained. Physical input lines starting with # (ignoring leading white space,
 678 and after macro replacement) and empty logical lines are always ignored.
 679 Leading and trailing spaces are removed.
 680
 681 If we hit a line of the form "begin xxxx", the xxxx is placed in the
 682 next_section vector, and the function returns NULL, indicating the end of a
 683 configuration section. On end-of-file, NULL is returned with next_section
 684 empty.
 685
 686 Arguments:      none
 687
 688 Returns:        a pointer to the first non-blank in the line,
 689                 or NULL if eof or end of section is reached
 690 */
 691
 692 static uschar *
 693 get_config_line(void)
 694 {
 695 int startoffset = 0;         /* To first non-blank char in logical line */
 696 int len = 0;                 /* Of logical line so far */
 697 int newlen;
 698 uschar *s, *ss;
 699 macro_item *m;
 700 BOOL macro_found;
 701
 702 /* Loop for handling continuation lines, skipping comments, and dealing with
 703 .include files. */
 704
 705 for (;;)
 706   {
 707   if (Ufgets(big_buffer+len, big_buffer_size-len, config_file) == NULL)
 708     {
 709     if (config_file_stack != NULL)    /* EOF inside .include */
 710       {
 711       (void)fclose(config_file);
 712       config_file = config_file_stack->file;
 713       config_filename = config_file_stack->filename;
 714       config_lineno = config_file_stack->lineno;
 715       config_file_stack = config_file_stack->next;
 716       if (config_lines)
 717         save_config_position(config_filename, config_lineno);
 718       continue;
 719       }
 720
 721     /* EOF at top level */
 722
 723     if (cstate_stack_ptr >= 0)
 724       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
 725         "Unexpected end of configuration file: .endif missing");
 726
 727     if (len != 0) break;        /* EOF after continuation */
 728     next_section[0] = 0;        /* EOF at start of logical line */
 729     return NULL;
 730     }
 731
 732   config_lineno++;
 733   newlen = len + Ustrlen(big_buffer + len);
 734
 735   if (config_lines && config_lineno == 1)
 736     save_config_position(config_filename, config_lineno);
 737
 738   /* Handle pathologically long physical lines - yes, it did happen - by
 739   extending big_buffer at this point. The code also copes with very long
 740   logical lines. */
 741
 742   while (newlen == big_buffer_size - 1 && big_buffer[newlen - 1] != '\n')
 743     {
 744     uschar *newbuffer;
 745     big_buffer_size += BIG_BUFFER_SIZE;
 746     newbuffer = store_malloc(big_buffer_size);
 747
 748     /* This use of strcpy is OK because we know that the string in the old
 749     buffer is shorter than the new buffer. */
 750
 751     Ustrcpy(newbuffer, big_buffer);
 752     store_free(big_buffer);
 753     big_buffer = newbuffer;
 754     if (Ufgets(big_buffer+newlen, big_buffer_size-newlen, config_file) == NULL)
 755       break;
 756     newlen += Ustrlen(big_buffer + newlen);
 757     }
 758
 759   /* Find the true start of the physical line - leading spaces are always
 760   ignored. */
 761
 762   ss = big_buffer + len;
 763   while (isspace(*ss)) ss++;
 764
 765   /* Process the physical line for macros. If this is the start of the logical
 766   line, skip over initial text at the start of the line if it starts with an
 767   upper case character followed by a sequence of name characters and an equals
 768   sign, because that is the definition of a new macro, and we don't do
 769   replacement therein. */
 770
 771   s = ss;
 772   if (len == 0 && isupper(*s))
 773     {
 774     while (isalnum(*s) || *s == '_') s++;
 775     while (isspace(*s)) s++;
 776     if (*s != '=') s = ss;          /* Not a macro definition */
 777     }
 778
 779   /* For each defined macro, scan the line (from after XXX= if present),
 780   replacing all occurrences of the macro. */
 781
 782   macro_found = FALSE;
 783   for (m = macros; m != NULL; m = m->next)
 784     {
 785     uschar *p, *pp;
 786     uschar *t = s;
 787
 788     while ((p = Ustrstr(t, m->name)) != NULL)
 789       {
 790       int moveby;
 791       int namelen = Ustrlen(m->name);
 792       int replen = Ustrlen(m->replacement);
 793
 794       /* Expand the buffer if necessary */
 795
 796       while (newlen - namelen + replen + 1 > big_buffer_size)
 797         {
 798         int newsize = big_buffer_size + BIG_BUFFER_SIZE;
 799         uschar *newbuffer = store_malloc(newsize);
 800         memcpy(newbuffer, big_buffer, newlen + 1);
 801         p = newbuffer  + (p - big_buffer);
 802         s = newbuffer  + (s - big_buffer);
 803         ss = newbuffer + (ss - big_buffer);
 804         t = newbuffer  + (t - big_buffer);
 805         big_buffer_size = newsize;
 806         store_free(big_buffer);
 807         big_buffer = newbuffer;
 808         }
 809
 810       /* Shuffle the remaining characters up or down in the buffer before
 811       copying in the replacement text. Don't rescan the replacement for this
 812       same macro. */
 813
 814       pp = p + namelen;
 815       moveby = replen - namelen;
 816       if (moveby != 0)
 817         {
 818         memmove(p + replen, pp, (big_buffer + newlen) - pp + 1);
 819         newlen += moveby;
 820         }
 821       Ustrncpy(p, m->replacement, replen);
 822       t = p + replen;
 823       macro_found = TRUE;
 824       }
 825     }
 826
 827   /* An empty macro replacement at the start of a line could mean that ss no
 828   longer points to the first non-blank character. */
 829
 830   while (isspace(*ss)) ss++;
 831
 832   /* Check for comment lines - these are physical lines. */
 833
 834   if (*ss == '#') continue;
 835
 836   /* Handle conditionals, which are also applied to physical lines. Conditions
 837   are of the form ".ifdef ANYTEXT" and are treated as true if any macro
 838   expansion occured on the rest of the line. A preliminary test for the leading
 839   '.' saves effort on most lines. */
 840
 841   if (*ss == '.')
 842     {
 843     int i;
 844
 845     /* Search the list of conditional directives */
 846
 847     for (i = 0; i < cond_list_size; i++)
 848       {
 849       int n;
 850       cond_item *c = cond_list+i;
 851       if (Ustrncmp(ss+1, c->name, c->namelen) != 0) continue;
 852
 853       /* The following character must be white space or end of string */
 854
 855       n = ss[1 + c->namelen];
 856       if (n != ' ' && n != 't' && n != '\n' && n != 0) break;
 857
 858       /* .ifdef and .ifndef push the current state onto the stack, then set
 859       a new one from the table. Stack overflow is an error */
 860
 861       if (c->pushpop > 0)
 862         {
 863         if (cstate_stack_ptr >= CSTATE_STACK_SIZE - 1)
 864           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
 865             ".%s nested too deeply", c->name);
 866         cstate_stack[++cstate_stack_ptr] = cstate;
 867         cstate = next_cstate[cstate][macro_found? c->action1 : c->action2];
 868         }
 869
 870       /* For any of the others, stack underflow is an error. The next state
 871       comes either from the stack (.endif) or from the table. */
 872
 873       else
 874         {
 875         if (cstate_stack_ptr < 0)
 876           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
 877             ".%s without matching .ifdef", c->name);
 878         cstate = (c->pushpop < 0)? cstate_stack[cstate_stack_ptr--] :
 879           next_cstate[cstate][macro_found? c->action1 : c->action2];
 880         }
 881
 882       /* Having dealt with a directive, break the loop */
 883
 884       break;
 885       }
 886
 887     /* If we have handled a conditional directive, continue with the next
 888     physical line. Otherwise, fall through. */
 889
 890     if (i < cond_list_size) continue;
 891     }
 892
 893   /* If the conditional state is not 0 (actively using these lines), ignore
 894   this input line. */
 895
 896   if (cstate != 0) continue;  /* Conditional skip */
 897
 898   /* Handle .include lines - these are also physical lines. */
 899
 900   if (Ustrncmp(ss, ".include", 8) == 0 &&
 901        (isspace(ss[8]) ||
 902          (Ustrncmp(ss+8, "_if_exists", 10) == 0 && isspace(ss[18]))))
 903     {
 904     uschar *t;
 905     int include_if_exists = isspace(ss[8])? 0 : 10;
 906     config_file_item *save;
 907     struct stat statbuf;
 908
 909     ss += 9 + include_if_exists;
 910     while (isspace(*ss)) ss++;
 911     t = ss + Ustrlen(ss);
 912     while (t > ss && isspace(t[-1])) t--;
 913     if (*ss == '\"' && t[-1] == '\"')
 914       {
 915       ss++;
 916       t--;
 917       }
 918     *t = 0;
 919
 920     if (*ss != '/')
 921       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, ".include specifies a non-"
 922         "absolute path \"%s\"", ss);
 923
 924     if (include_if_exists != 0 && (Ustat(ss, &statbuf) != 0)) continue;
 925
 926     if (config_lines)
 927       save_config_position(config_filename, config_lineno);
 928     save = store_get(sizeof(config_file_item));
 929     save->next = config_file_stack;
 930     config_file_stack = save;
 931     save->file = config_file;
 932     save->filename = config_filename;
 933     save->lineno = config_lineno;
 934
 935     if (!(config_file = Ufopen(ss, "rb")))
 936       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to open included "
 937         "configuration file %s", ss);
 938
 939     config_filename = string_copy(ss);
 940     config_lineno = 0;
 941     continue;
 942     }
 943
 944   /* If this is the start of the logical line, remember where the non-blank
 945   data starts. Otherwise shuffle down continuation lines to remove leading
 946   white space. */
 947
 948   if (len == 0)
 949     startoffset = ss - big_buffer;
 950   else
 951     {
 952     s = big_buffer + len;
 953     if (ss > s)
 954       {
 955       memmove(s, ss, (newlen - len) -  (ss - s) + 1);
 956       newlen -= ss - s;
 957       }
 958     }
 959
 960   /* Accept the new addition to the line. Remove trailing white space. */
 961
 962   len = newlen;
 963   while (len > 0 && isspace(big_buffer[len-1])) len--;
 964   big_buffer[len] = 0;
 965
 966   /* We are done if the line does not end in backslash and contains some data.
 967   Empty logical lines are ignored. For continuations, remove the backslash and
 968   go round the loop to read the continuation line. */
 969
 970   if (len > 0)
 971     {
 972     if (big_buffer[len-1] != '\\') break;   /* End of logical line */
 973     big_buffer[--len] = 0;                  /* Remove backslash */
 974     }
 975   }     /* Loop for reading multiple physical lines */
 976
 977 /* We now have a logical line. Test for the end of a configuration section (or,
 978 more accurately, for the start of the next section). Place the name of the next
 979 section in next_section, and return NULL. If the name given is longer than
 980 next_section, truncate it. It will be unrecognized later, because all the known
 981 section names do fit. Leave space for pluralizing. */
 982
 983 s = big_buffer + startoffset;            /* First non-space character */
 984
 985 if (config_lines)
 986   save_config_line(s);
 987
 988 if (strncmpic(s, US"begin ", 6) == 0)
 989   {
 990   s += 6;
 991   while (isspace(*s)) s++;
 992   if (big_buffer + len - s > sizeof(next_section) - 2)
 993     s[sizeof(next_section) - 2] = 0;
 994   Ustrcpy(next_section, s);
 995   return NULL;
 996   }
 997
 998 /* Return the first non-blank character. */
 999
1000 return s;
1001 }
1002
1003
1004
1005 /*************************************************
1006 *             Read a name                        *
1007 *************************************************/
1008
1009 /* The yield is the pointer to the next uschar. Names longer than the
1010 output space are silently truncated. This function is also used from acl.c when
1011 parsing ACLs.
1012
1013 Arguments:
1014   name      where to put the name
1015   len       length of name
1016   s         input pointer
1017
1018 Returns:    new input pointer
1019 */
1020
1021 uschar *
1022 readconf_readname(uschar *name, int len, uschar *s)
1023 {
1024 int p = 0;
1025 while (isspace(*s)) s++;
1026 if (isalpha(*s))
1027   {
1028   while (isalnum(*s) || *s == '_')
1029     {
1030     if (p < len-1) name[p++] = *s;
1031     s++;
1032     }
1033   }
1034 name[p] = 0;
1035 while (isspace(*s)) s++;
1036 return s;
1037 }
1038
1039
1040
1041
1042 /*************************************************
1043 *          Read a time value                     *
1044 *************************************************/
1045
1046 /* This function is also called from outside, to read argument
1047 time values. The format of a time value is:
1048
1049   [<n>w][<n>d][<n>h][<n>m][<n>s]
1050
1051 as long as at least one is present. If a format error is encountered,
1052 return a negative value. The value must be terminated by the given
1053 terminator.
1054
1055 Arguments:
1056   s             input pointer
1057   terminator    required terminating character
1058   return_msec   if TRUE, allow fractional seconds and return milliseconds
1059
1060 Returns:        the time value, or -1 on syntax error
1061                 value is seconds if return_msec is FALSE
1062                 value is milliseconds if return_msec is TRUE
1063 */
1064
1065 int
1066 readconf_readtime(const uschar *s, int terminator, BOOL return_msec)
1067 {
1068 int yield = 0;
1069 for (;;)
1070   {
1071   int value, count;
1072   double fraction;
1073
1074   if (!isdigit(*s)) return -1;
1075   (void)sscanf(CCS s, "%d%n", &value, &count);
1076   s += count;
1077
1078   switch (*s)
1079     {
1080     case 'w': value *= 7;
1081     case 'd': value *= 24;
1082     case 'h': value *= 60;
1083     case 'm': value *= 60;
1084     case 's': s++;
1085     break;
1086
1087     case '.':
1088     if (!return_msec) return -1;
1089     (void)sscanf(CCS s, "%lf%n", &fraction, &count);
1090     s += count;
1091     if (*s++ != 's') return -1;
1092     yield += (int)(fraction * 1000.0);
1093     break;
1094
1095     default: return -1;
1096     }
1097
1098   if (return_msec) value *= 1000;
1099   yield += value;
1100   if (*s == terminator) return yield;
1101   }
1102 /* Control never reaches here. */
1103 }
1104
1105
1106
1107 /*************************************************
1108 *          Read a fixed point value              *
1109 *************************************************/
1110
1111 /* The value is returned *1000
1112
1113 Arguments:
1114   s           input pointer
1115   terminator  required terminator
1116
1117 Returns:      the value, or -1 on error
1118 */
1119
1120 static int
1121 readconf_readfixed(const uschar *s, int terminator)
1122 {
1123 int yield = 0;
1124 int value, count;
1125 if (!isdigit(*s)) return -1;
1126 (void)sscanf(CS  s, "%d%n", &value, &count);
1127 s += count;
1128 yield = value * 1000;
1129 if (*s == '.')
1130   {
1131   int m = 100;
1132   while (isdigit((*(++s))))
1133     {
1134     yield += (*s - '0') * m;
1135     m /= 10;
1136     }
1137   }
1138
1139 return (*s == terminator)? yield : (-1);
1140 }
1141
1142
1143
1144 /*************************************************
1145 *            Find option in list                 *
1146 *************************************************/
1147
1148 /* The lists are always in order, so binary chop can be used.
1149
1150 Arguments:
1151   name      the option name to search for
1152   ol        the first entry in the option list
1153   last      one more than the offset of the last entry in the option list
1154
1155 Returns:    pointer to an option entry, or NULL if not found
1156 */
1157
1158 static optionlist *
1159 find_option(uschar *name, optionlist *ol, int last)
1160 {
1161 int first = 0;
1162 while (last > first)
1163   {
1164   int middle = (first + last)/2;
1165   int c = Ustrcmp(name, ol[middle].name);
1166
1167   if (c == 0) return ol + middle;
1168   else if (c > 0) first = middle + 1;
1169   else last = middle;
1170   }
1171 return NULL;
1172 }
1173
1174
1175
1176 /*************************************************
1177 *      Find a set flag in option list            *
1178 *************************************************/
1179
1180 /* Because some versions of Unix make no restrictions on the values of uids and
1181 gids (even negative ones), we cannot represent "unset" by a special value.
1182 There is therefore a separate boolean variable for each one indicating whether
1183 a value is set or not. This function returns a pointer to the boolean, given
1184 the original option name. It is a major disaster if the flag cannot be found.
1185
1186 Arguments:
1187   name          the name of the uid or gid option
1188   oltop         points to the start of the relevant option list
1189   last          one more than the offset of the last item in the option list
1190   data_block    NULL when reading main options => data values in the option
1191                   list are absolute addresses; otherwise they are byte offsets
1192                   in data_block (used for driver options)
1193
1194 Returns:        a pointer to the boolean flag.
1195 */
1196
1197 static BOOL *
1198 get_set_flag(uschar *name, optionlist *oltop, int last, void *data_block)
1199 {
1200 optionlist *ol;
1201 uschar name2[64];
1202 sprintf(CS name2, "*set_%.50s", name);
1203 ol = find_option(name2, oltop, last);
1204 if (ol == NULL) log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1205   "Exim internal error: missing set flag for %s", name);
1206 return (data_block == NULL)? (BOOL *)(ol->value) :
1207   (BOOL *)((uschar *)data_block + (long int)(ol->value));
1208 }
1209
1210
1211
1212
1213 /*************************************************
1214 *    Output extra characters message and die     *
1215 *************************************************/
1216
1217 /* Called when an option line has junk on the end. Sometimes this is because
1218 the sysadmin thinks comments are permitted.
1219
1220 Arguments:
1221   s          points to the extra characters
1222   t1..t3     strings to insert in the log message
1223
1224 Returns:     doesn't return; dies
1225 */
1226
1227 static void
1228 extra_chars_error(const uschar *s, const uschar *t1, const uschar *t2, const uschar *t3)
1229 {
1230 uschar *comment = US"";
1231 if (*s == '#') comment = US" (# is comment only at line start)";
1232 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1233   "extra characters follow %s%s%s%s", t1, t2, t3, comment);
1234 }
1235
1236
1237
1238 /*************************************************
1239 *              Read rewrite information          *
1240 *************************************************/
1241
1242 /* Each line of rewrite information contains:
1243
1244 .  A complete address in the form user@domain, possibly with
1245    leading * for each part; or alternatively, a regex.
1246
1247 .  A replacement string (which will be expanded).
1248
1249 .  An optional sequence of one-letter flags, indicating which
1250    headers etc. to apply this rule to.
1251
1252 All this is decoded and placed into a control block. The OR of the flags is
1253 maintained in a common word.
1254
1255 Arguments:
1256   p           points to the string that makes up the rule
1257   existflags  points to the overall flag word
1258   isglobal    TRUE if reading global rewrite rules
1259
1260 Returns:      the control block for the parsed rule.
1261 */
1262
1263 static rewrite_rule *
1264 readconf_one_rewrite(const uschar *p, int *existflags, BOOL isglobal)
1265 {
1266 rewrite_rule *next = store_get(sizeof(rewrite_rule));
1267
1268 next->next = NULL;
1269 next->key = string_dequote(&p);
1270
1271 while (isspace(*p)) p++;
1272 if (*p == 0)
1273   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1274     "missing rewrite replacement string");
1275
1276 next->flags = 0;
1277 next->replacement = string_dequote(&p);
1278
1279 while (*p != 0) switch (*p++)
1280   {
1281   case ' ': case '\t': break;
1282
1283   case 'q': next->flags |= rewrite_quit; break;
1284   case 'w': next->flags |= rewrite_whole; break;
1285
1286   case 'h': next->flags |= rewrite_all_headers; break;
1287   case 's': next->flags |= rewrite_sender; break;
1288   case 'f': next->flags |= rewrite_from; break;
1289   case 't': next->flags |= rewrite_to;   break;
1290   case 'c': next->flags |= rewrite_cc;   break;
1291   case 'b': next->flags |= rewrite_bcc;  break;
1292   case 'r': next->flags |= rewrite_replyto; break;
1293
1294   case 'E': next->flags |= rewrite_all_envelope; break;
1295   case 'F': next->flags |= rewrite_envfrom; break;
1296   case 'T': next->flags |= rewrite_envto; break;
1297
1298   case 'Q': next->flags |= rewrite_qualify; break;
1299   case 'R': next->flags |= rewrite_repeat; break;
1300
1301   case 'S':
1302   next->flags |= rewrite_smtp;
1303   if (next->key[0] != '^' && Ustrncmp(next->key, "\\N^", 3) != 0)
1304     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1305       "rewrite rule has the S flag but is not a regular expression");
1306   break;
1307
1308   default:
1309   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1310     "unknown rewrite flag character '%c' "
1311     "(could be missing quotes round replacement item)", p[-1]);
1312   break;
1313   }
1314
1315 /* If no action flags are set, set all the "normal" rewrites. */
1316
1317 if ((next->flags & (rewrite_all | rewrite_smtp)) == 0)
1318   next->flags |= isglobal? rewrite_all : rewrite_all_headers;
1319
1320 /* Remember which exist, for optimization, and return the rule */
1321
1322 *existflags |= next->flags;
1323 return next;
1324 }
1325
1326
1327
1328
1329 /*************************************************
1330 *          Read global rewrite information       *
1331 *************************************************/
1332
1333 /* Each line is a single rewrite rule; it is parsed into a control block
1334 by readconf_one_rewrite(), and its flags are ORed into the global flag
1335 word rewrite_existflags. */
1336
1337 void
1338 readconf_rewrites(void)
1339 {
1340 rewrite_rule **chain = &global_rewrite_rules;
1341 uschar *p;
1342
1343 while ((p = get_config_line()) != NULL)
1344   {
1345   rewrite_rule *next = readconf_one_rewrite(p, &rewrite_existflags, TRUE);
1346   *chain = next;
1347   chain = &(next->next);
1348   }
1349 }
1350
1351
1352
1353 /*************************************************
1354 *               Read a string                    *
1355 *************************************************/
1356
1357 /* Strings are read into the normal store pool. As long we aren't too
1358 near the end of the current block, the string will just use what is necessary
1359 on the top of the stacking pool, because string_cat() uses the extension
1360 mechanism.
1361
1362 Argument:
1363   s         the rest of the input line
1364   name      the option name (for errors)
1365
1366 Returns:    pointer to the string
1367 */
1368
1369 static uschar *
1370 read_string(const uschar *s, const uschar *name)
1371 {
1372 uschar *yield;
1373 const uschar *ss;
1374
1375 if (*s != '\"') return string_copy(s);
1376
1377 ss = s;
1378 yield = string_dequote(&s);
1379
1380 if (s == ss+1 || s[-1] != '\"')
1381   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1382     "missing quote at end of string value for %s", name);
1383
1384 if (*s != 0) extra_chars_error(s, US"string value for ", name, US"");
1385
1386 return yield;
1387 }
1388
1389
1390 /*************************************************
1391 *            Custom-handler options              *
1392 *************************************************/
1393 static void
1394 fn_smtp_receive_timeout(const uschar * name, const uschar * str)
1395 {
1396 if (*str == '$')
1397   smtp_receive_timeout_s = string_copy(str);
1398 else
1399   {
1400   /* "smtp_receive_timeout",     opt_time,        &smtp_receive_timeout */
1401   smtp_receive_timeout = readconf_readtime(str, 0, FALSE);
1402   if (smtp_receive_timeout < 0)
1403     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
1404       name);
1405   }
1406 }
1407
1408 /*************************************************
1409 *            Handle option line                  *
1410 *************************************************/
1411
1412 /* This function is called from several places to process a line containing the
1413 setting of an option. The first argument is the line to be decoded; it has been
1414 checked not to be empty and not to start with '#'. Trailing newlines and white
1415 space have been removed. The second argument is a pointer to the list of
1416 variable names that are to be recognized, together with their types and
1417 locations, and the third argument gives the number of entries in the list.
1418
1419 The fourth argument is a pointer to a data block. If it is NULL, then the data
1420 values in the options list are absolute addresses. Otherwise, they are byte
1421 offsets in the data block.
1422
1423 String option data may continue onto several lines; this function reads further
1424 data from config_file if necessary.
1425
1426 The yield of this function is normally zero. If a string continues onto
1427 multiple lines, then the data value is permitted to be followed by a comma
1428 or a semicolon (for use in drivers) and the yield is that character.
1429
1430 Arguments:
1431   buffer        contains the configuration line to be handled
1432   oltop         points to the start of the relevant option list
1433   last          one more than the offset of the last item in the option list
1434   data_block    NULL when reading main options => data values in the option
1435                   list are absolute addresses; otherwise they are byte offsets
1436                   in data_block when they have opt_public set; otherwise
1437                   they are byte offsets in data_block->options_block.
1438   unknown_txt   format string to use in panic message for unknown option;
1439                   must contain %s for option name
1440                 if given as NULL, don't panic on unknown option
1441
1442 Returns:        TRUE if an option was read successfully,
1443                 FALSE false for an unknown option if unknown_txt == NULL,
1444                   otherwise panic and die on an unknown option
1445 */
1446
1447 static BOOL
1448 readconf_handle_option(uschar *buffer, optionlist *oltop, int last,
1449   void *data_block, uschar *unknown_txt)
1450 {
1451 int ptr = 0;
1452 int offset = 0;
1453 int n, count, type, value;
1454 int issecure = 0;
1455 uid_t uid;
1456 gid_t gid;
1457 BOOL boolvalue = TRUE;
1458 BOOL freesptr = TRUE;
1459 optionlist *ol, *ol2;
1460 struct passwd *pw;
1461 void *reset_point;
1462 int intbase = 0;
1463 uschar *inttype = US"";
1464 uschar *sptr;
1465 uschar *s = buffer;
1466 uschar **str_target;
1467 uschar name[64];
1468 uschar name2[64];
1469
1470 /* There may be leading spaces; thereafter, we expect an option name starting
1471 with a letter. */
1472
1473 while (isspace(*s)) s++;
1474 if (!isalpha(*s))
1475   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option setting expected: %s", s);
1476
1477 /* Read the name of the option, and skip any subsequent white space. If
1478 it turns out that what we read was "hide", set the flag indicating that
1479 this is a secure option, and loop to read the next word. */
1480
1481 for (n = 0; n < 2; n++)
1482   {
1483   while (isalnum(*s) || *s == '_')
1484     {
1485     if (ptr < sizeof(name)-1) name[ptr++] = *s;
1486     s++;
1487     }
1488   name[ptr] = 0;
1489   while (isspace(*s)) s++;
1490   if (Ustrcmp(name, "hide") != 0) break;
1491   issecure = opt_secure;
1492   ptr = 0;
1493   }
1494
1495 /* Deal with "no_" or "not_" here for booleans */
1496
1497 if (Ustrncmp(name, "no_", 3) == 0)
1498   {
1499   boolvalue = FALSE;
1500   offset = 3;
1501   }
1502
1503 if (Ustrncmp(name, "not_", 4) == 0)
1504   {
1505   boolvalue = FALSE;
1506   offset = 4;
1507   }
1508
1509 /* Search the list for the given name. A non-existent name, or an option that
1510 is set twice, is a disaster. */
1511
1512 if (!(ol = find_option(name + offset, oltop, last)))
1513   {
1514   if (unknown_txt == NULL) return FALSE;
1515   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, CS unknown_txt, name);
1516   }
1517
1518 if ((ol->type & opt_set)  && !(ol->type & (opt_rep_con | opt_rep_str)))
1519   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1520     "\"%s\" option set for the second time", name);
1521
1522 ol->type |= opt_set | issecure;
1523 type = ol->type & opt_mask;
1524
1525 /* Types with data values must be followed by '='; the "no[t]_" prefix
1526 applies only to boolean values. */
1527
1528 if (type < opt_bool || type > opt_bool_last)
1529   {
1530   if (offset != 0)
1531     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1532       "negation prefix applied to a non-boolean option");
1533   if (*s == 0)
1534     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1535       "unexpected end of line (data missing) after %s", name);
1536   if (*s != '=')
1537     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing \"=\" after %s", name);
1538   }
1539
1540 /* If a boolean wasn't preceded by "no[t]_" it can be followed by = and
1541 true/false/yes/no, or, in the case of opt_expand_bool, a general string that
1542 ultimately expands to one of those values. */
1543
1544 else if (*s != 0 && (offset != 0 || *s != '='))
1545   extra_chars_error(s, US"boolean option ", name, US"");
1546
1547 /* Skip white space after = */
1548
1549 if (*s == '=') while (isspace((*(++s))));
1550
1551 /* If there is a data block and the opt_public flag is not set, change
1552 the data block pointer to the private options block. */
1553
1554 if (data_block != NULL && (ol->type & opt_public) == 0)
1555   data_block = (void *)(((driver_instance *)data_block)->options_block);
1556
1557 /* Now get the data according to the type. */
1558
1559 switch (type)
1560   {
1561   /* If a string value is not enclosed in quotes, it consists of
1562   the rest of the current line, verbatim. Otherwise, string escapes
1563   are processed.
1564
1565   A transport is specified as a string, which is then looked up in the
1566   list of transports. A search type is specified as one of a number of
1567   known strings.
1568
1569   A set or rewrite rules for a driver is specified as a string, which is
1570   then parsed into a suitable chain of control blocks.
1571
1572   Uids and gids are specified as strings which are then looked up in the
1573   passwd file. Lists of uids and gids are similarly specified as colon-
1574   separated strings. */
1575
1576   case opt_stringptr:
1577   case opt_uid:
1578   case opt_gid:
1579   case opt_expand_uid:
1580   case opt_expand_gid:
1581   case opt_uidlist:
1582   case opt_gidlist:
1583   case opt_rewrite:
1584
1585   reset_point = sptr = read_string(s, name);
1586
1587   /* Having read a string, we now have several different ways of using it,
1588   depending on the data type, so do another switch. If keeping the actual
1589   string is not required (because it is interpreted), freesptr is set TRUE,
1590   and at the end we reset the pool. */
1591
1592   switch (type)
1593     {
1594     /* If this was a string, set the variable to point to the new string,
1595     and set the flag so its store isn't reclaimed. If it was a list of rewrite
1596     rules, we still keep the string (for printing), and parse the rules into a
1597     control block and flags word. */
1598
1599     case opt_stringptr:
1600     str_target = data_block ? USS (US data_block + (long int)(ol->value))
1601                             : USS (ol->value);
1602     if (ol->type & opt_rep_con)
1603       {
1604       uschar * saved_condition;
1605       /* We already have a condition, we're conducting a crude hack to let
1606       multiple condition rules be chained together, despite storing them in
1607       text form. */
1608       *str_target = string_copy_malloc( (saved_condition = *str_target)
1609         ? string_sprintf("${if and{{bool_lax{%s}}{bool_lax{%s}}}}",
1610             saved_condition, sptr)
1611         : sptr);
1612       /* TODO(pdp): there is a memory leak here and just below
1613       when we set 3 or more conditions; I still don't
1614       understand the store mechanism enough to know
1615       what's the safe way to free content from an earlier store.
1616       AFAICT, stores stack, so freeing an early stored item also stores
1617       all data alloc'd after it.  If we knew conditions were adjacent,
1618       we could survive that, but we don't.  So I *think* we need to take
1619       another bit from opt_type to indicate "malloced"; this seems like
1620       quite a hack, especially for this one case.  It also means that
1621       we can't ever reclaim the store from the *first* condition.
1622
1623       Because we only do this once, near process start-up, I'm prepared to
1624       let this slide for the time being, even though it rankles.  */
1625       }
1626     else if (ol->type & opt_rep_str)
1627       {
1628       uschar sep_o = Ustrncmp(name, "headers_add", 11)==0 ? '\n' : ':';
1629       int    sep_i = -(int)sep_o;
1630       const uschar * list = sptr;
1631       uschar * s;
1632       uschar * list_o = *str_target;
1633
1634       while ((s = string_nextinlist(&list, &sep_i, NULL, 0)))
1635         list_o = string_append_listele(list_o, sep_o, s);
1636       if (list_o)
1637         *str_target = string_copy_malloc(list_o);
1638       }
1639     else
1640       {
1641       *str_target = sptr;
1642       freesptr = FALSE;
1643       }
1644     break;
1645
1646     case opt_rewrite:
1647     if (data_block)
1648       *USS (US data_block + (long int)(ol->value)) = sptr;
1649     else
1650       *USS (ol->value) = sptr;
1651     freesptr = FALSE;
1652     if (type == opt_rewrite)
1653       {
1654       int sep = 0;
1655       int *flagptr;
1656       uschar *p = sptr;
1657       rewrite_rule **chain;
1658       optionlist *ol3;
1659
1660       sprintf(CS name2, "*%.50s_rules", name);
1661       ol2 = find_option(name2, oltop, last);
1662       sprintf(CS name2, "*%.50s_flags", name);
1663       ol3 = find_option(name2, oltop, last);
1664
1665       if (ol2 == NULL || ol3 == NULL)
1666         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1667           "rewrite rules not available for driver");
1668
1669       if (data_block == NULL)
1670         {
1671         chain = (rewrite_rule **)(ol2->value);
1672         flagptr = (int *)(ol3->value);
1673         }
1674       else
1675         {
1676         chain = (rewrite_rule **)((uschar *)data_block + (long int)(ol2->value));
1677         flagptr = (int *)((uschar *)data_block + (long int)(ol3->value));
1678         }
1679
1680       while ((p = string_nextinlist(CUSS &sptr, &sep, big_buffer, BIG_BUFFER_SIZE)))
1681         {
1682         rewrite_rule *next = readconf_one_rewrite(p, flagptr, FALSE);
1683         *chain = next;
1684         chain = &(next->next);
1685         }
1686
1687       if ((*flagptr & (rewrite_all_envelope | rewrite_smtp)) != 0)
1688         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "rewrite rule specifies a "
1689           "non-header rewrite - not allowed at transport time -");
1690       }
1691     break;
1692
1693     /* If it was an expanded uid, see if there is any expansion to be
1694     done by checking for the presence of a $ character. If there is, save it
1695     in the corresponding *expand_user option field. Otherwise, fall through
1696     to treat it as a fixed uid. Ensure mutual exclusivity of the two kinds
1697     of data. */
1698
1699     case opt_expand_uid:
1700     sprintf(CS name2, "*expand_%.50s", name);
1701     ol2 = find_option(name2, oltop, last);
1702     if (ol2 != NULL)
1703       {
1704       uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
1705
1706       if (data_block == NULL)
1707         *((uschar **)(ol2->value)) = ss;
1708       else
1709         *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = ss;
1710
1711       if (ss != NULL)
1712         {
1713         *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1714         freesptr = FALSE;
1715         break;
1716         }
1717       }
1718
1719     /* Look up a fixed uid, and also make use of the corresponding gid
1720     if a passwd entry is returned and the gid has not been set. */
1721
1722     case opt_uid:
1723     if (!route_finduser(sptr, &pw, &uid))
1724       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found", sptr);
1725     if (data_block == NULL)
1726       *((uid_t *)(ol->value)) = uid;
1727     else
1728       *((uid_t *)((uschar *)data_block + (long int)(ol->value))) = uid;
1729
1730     /* Set the flag indicating a fixed value is set */
1731
1732     *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1733
1734     /* Handle matching gid if we have a passwd entry: done by finding the
1735     same name with terminating "user" changed to "group"; if not found,
1736     ignore. Also ignore if the value is already set. */
1737
1738     if (pw == NULL) break;
1739     Ustrcpy(name+Ustrlen(name)-4, "group");
1740     ol2 = find_option(name, oltop, last);
1741     if (ol2 != NULL && ((ol2->type & opt_mask) == opt_gid ||
1742         (ol2->type & opt_mask) == opt_expand_gid))
1743       {
1744       BOOL *set_flag = get_set_flag(name, oltop, last, data_block);
1745       if (! *set_flag)
1746         {
1747         if (data_block == NULL)
1748           *((gid_t *)(ol2->value)) = pw->pw_gid;
1749         else
1750           *((gid_t *)((uschar *)data_block + (long int)(ol2->value))) = pw->pw_gid;
1751         *set_flag = TRUE;
1752         }
1753       }
1754     break;
1755
1756     /* If it was an expanded gid, see if there is any expansion to be
1757     done by checking for the presence of a $ character. If there is, save it
1758     in the corresponding *expand_user option field. Otherwise, fall through
1759     to treat it as a fixed gid. Ensure mutual exclusivity of the two kinds
1760     of data. */
1761
1762     case opt_expand_gid:
1763     sprintf(CS name2, "*expand_%.50s", name);
1764     ol2 = find_option(name2, oltop, last);
1765     if (ol2 != NULL)
1766       {
1767       uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
1768
1769       if (data_block == NULL)
1770         *((uschar **)(ol2->value)) = ss;
1771       else
1772         *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = ss;
1773
1774       if (ss != NULL)
1775         {
1776         *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1777         freesptr = FALSE;
1778         break;
1779         }
1780       }
1781
1782     /* Handle freestanding gid */
1783
1784     case opt_gid:
1785     if (!route_findgroup(sptr, &gid))
1786       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found", sptr);
1787     if (data_block == NULL)
1788       *((gid_t *)(ol->value)) = gid;
1789     else
1790       *((gid_t *)((uschar *)data_block + (long int)(ol->value))) = gid;
1791     *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1792     break;
1793
1794     /* If it was a uid list, look up each individual entry, and build
1795     a vector of uids, with a count in the first element. Put the vector
1796     in malloc store so we can free the string. (We are reading into
1797     permanent store already.) */
1798
1799     case opt_uidlist:
1800       {
1801       int count = 1;
1802       uid_t *list;
1803       int ptr = 0;
1804       const uschar *p;
1805       const uschar *op = expand_string (sptr);
1806
1807       if (op == NULL)
1808         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
1809           name, expand_string_message);
1810
1811       p = op;
1812       if (*p != 0) count++;
1813       while (*p != 0) if (*p++ == ':' && *p != 0) count++;
1814       list = store_malloc(count*sizeof(uid_t));
1815       list[ptr++] = (uid_t)(count - 1);
1816
1817       if (data_block == NULL)
1818         *((uid_t **)(ol->value)) = list;
1819       else
1820         *((uid_t **)((uschar *)data_block + (long int)(ol->value))) = list;
1821
1822       p = op;
1823       while (count-- > 1)
1824         {
1825         int sep = 0;
1826         (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
1827         if (!route_finduser(big_buffer, NULL, &uid))
1828           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found",
1829             big_buffer);
1830         list[ptr++] = uid;
1831         }
1832       }
1833     break;
1834
1835     /* If it was a gid list, look up each individual entry, and build
1836     a vector of gids, with a count in the first element. Put the vector
1837     in malloc store so we can free the string. (We are reading into permanent
1838     store already.) */
1839
1840     case opt_gidlist:
1841       {
1842       int count = 1;
1843       gid_t *list;
1844       int ptr = 0;
1845       const uschar *p;
1846       const uschar *op = expand_string (sptr);
1847
1848       if (op == NULL)
1849         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
1850           name, expand_string_message);
1851
1852       p = op;
1853       if (*p != 0) count++;
1854       while (*p != 0) if (*p++ == ':' && *p != 0) count++;
1855       list = store_malloc(count*sizeof(gid_t));
1856       list[ptr++] = (gid_t)(count - 1);
1857
1858       if (data_block == NULL)
1859         *((gid_t **)(ol->value)) = list;
1860       else
1861         *((gid_t **)((uschar *)data_block + (long int)(ol->value))) = list;
1862
1863       p = op;
1864       while (count-- > 1)
1865         {
1866         int sep = 0;
1867         (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
1868         if (!route_findgroup(big_buffer, &gid))
1869           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found",
1870             big_buffer);
1871         list[ptr++] = gid;
1872         }
1873       }
1874     break;
1875     }
1876
1877   /* Release store if the value of the string doesn't need to be kept. */
1878
1879   if (freesptr) store_reset(reset_point);
1880   break;
1881
1882   /* Expanded boolean: if no characters follow, or if there are no dollar
1883   characters, this is a fixed-valued boolean, and we fall through. Otherwise,
1884   save the string for later expansion in the alternate place. */
1885
1886   case opt_expand_bool:
1887   if (*s != 0 && Ustrchr(s, '$') != 0)
1888     {
1889     sprintf(CS name2, "*expand_%.50s", name);
1890     ol2 = find_option(name2, oltop, last);
1891     if (ol2 != NULL)
1892       {
1893       reset_point = sptr = read_string(s, name);
1894       if (data_block == NULL)
1895         *((uschar **)(ol2->value)) = sptr;
1896       else
1897         *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = sptr;
1898       freesptr = FALSE;
1899       break;
1900       }
1901     }
1902   /* Fall through */
1903
1904   /* Boolean: if no characters follow, the value is boolvalue. Otherwise
1905   look for yes/not/true/false. Some booleans are stored in a single bit in
1906   a single int. There's a special fudge for verify settings; without a suffix
1907   they set both xx_sender and xx_recipient. The table points to the sender
1908   value; search subsequently for the recipient. There's another special case:
1909   opt_bool_set also notes when a boolean has been set. */
1910
1911   case opt_bool:
1912   case opt_bit:
1913   case opt_bool_verify:
1914   case opt_bool_set:
1915   if (*s != 0)
1916     {
1917     s = readconf_readname(name2, 64, s);
1918     if (strcmpic(name2, US"true") == 0 || strcmpic(name2, US"yes") == 0)
1919       boolvalue = TRUE;
1920     else if (strcmpic(name2, US"false") == 0 || strcmpic(name2, US"no") == 0)
1921       boolvalue = FALSE;
1922     else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1923       "\"%s\" is not a valid value for the \"%s\" option", name2, name);
1924     if (*s != 0) extra_chars_error(s, string_sprintf("\"%s\" ", name2),
1925       US"for boolean option ", name);
1926     }
1927
1928   /* Handle single-bit type. */
1929
1930   if (type == opt_bit)
1931     {
1932     int bit = 1 << ((ol->type >> 16) & 31);
1933     int *ptr = (data_block == NULL)?
1934       (int *)(ol->value) :
1935       (int *)((uschar *)data_block + (long int)ol->value);
1936     if (boolvalue) *ptr |= bit; else *ptr &= ~bit;
1937     break;
1938     }
1939
1940   /* Handle full BOOL types */
1941
1942   if (data_block == NULL)
1943     *((BOOL *)(ol->value)) = boolvalue;
1944   else
1945     *((BOOL *)((uschar *)data_block + (long int)(ol->value))) = boolvalue;
1946
1947   /* Verify fudge */
1948
1949   if (type == opt_bool_verify)
1950     {
1951     sprintf(CS name2, "%.50s_recipient", name + offset);
1952     ol2 = find_option(name2, oltop, last);
1953     if (ol2 != NULL)
1954       {
1955       if (data_block == NULL)
1956         *((BOOL *)(ol2->value)) = boolvalue;
1957       else
1958         *((BOOL *)((uschar *)data_block + (long int)(ol2->value))) = boolvalue;
1959       }
1960     }
1961
1962   /* Note that opt_bool_set type is set, if there is somewhere to do so */
1963
1964   else if (type == opt_bool_set)
1965     {
1966     sprintf(CS name2, "*set_%.50s", name + offset);
1967     ol2 = find_option(name2, oltop, last);
1968     if (ol2 != NULL)
1969       {
1970       if (data_block == NULL)
1971         *((BOOL *)(ol2->value)) = TRUE;
1972       else
1973         *((BOOL *)((uschar *)data_block + (long int)(ol2->value))) = TRUE;
1974       }
1975     }
1976   break;
1977
1978   /* Octal integer */
1979
1980   case opt_octint:
1981   intbase = 8;
1982   inttype = US"octal ";
1983
1984   /*  Integer: a simple(ish) case; allow octal and hex formats, and
1985   suffixes K, M and G. The different types affect output, not input. */
1986
1987   case opt_mkint:
1988   case opt_int:
1989     {
1990     uschar *endptr;
1991     long int lvalue;
1992
1993     errno = 0;
1994     lvalue = strtol(CS s, CSS &endptr, intbase);
1995
1996     if (endptr == s)
1997       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
1998         inttype, name);
1999
2000     if (errno != ERANGE)
2001       if (tolower(*endptr) == 'k')
2002         {
2003         if (lvalue > INT_MAX/1024 || lvalue < INT_MIN/1024) errno = ERANGE;
2004           else lvalue *= 1024;
2005         endptr++;
2006         }
2007       else if (tolower(*endptr) == 'm')
2008         {
2009         if (lvalue > INT_MAX/(1024*1024) || lvalue < INT_MIN/(1024*1024))
2010           errno = ERANGE;
2011         else lvalue *= 1024*1024;
2012         endptr++;
2013         }
2014       else if (tolower(*endptr) == 'g')
2015         {
2016         if (lvalue > INT_MAX/(1024*1024*1024) || lvalue < INT_MIN/(1024*1024*1024))
2017           errno = ERANGE;
2018         else lvalue *= 1024*1024*1024;
2019         endptr++;
2020         }
2021
2022     if (errno == ERANGE || lvalue > INT_MAX || lvalue < INT_MIN)
2023       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2024         "absolute value of integer \"%s\" is too large (overflow)", s);
2025
2026     while (isspace(*endptr)) endptr++;
2027     if (*endptr != 0)
2028       extra_chars_error(endptr, inttype, US"integer value for ", name);
2029
2030     value = (int)lvalue;
2031     }
2032
2033   if (data_block == NULL)
2034     *((int *)(ol->value)) = value;
2035   else
2036     *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2037   break;
2038
2039   /*  Integer held in K: again, allow octal and hex formats, and suffixes K, M
2040   and G. */
2041   /*XXX consider moving to int_eximarith_t (but mind the overflow test 0415) */
2042
2043   case opt_Kint:
2044     {
2045     uschar *endptr;
2046     errno = 0;
2047     value = strtol(CS s, CSS &endptr, intbase);
2048
2049     if (endptr == s)
2050       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
2051         inttype, name);
2052
2053     if (errno != ERANGE)
2054       if (tolower(*endptr) == 'g')
2055         {
2056         if (value > INT_MAX/(1024*1024) || value < INT_MIN/(1024*1024))
2057           errno = ERANGE;
2058         else
2059           value *= 1024*1024;
2060         endptr++;
2061         }
2062       else if (tolower(*endptr) == 'm')
2063         {
2064         if (value > INT_MAX/1024 || value < INT_MIN/1024)
2065           errno = ERANGE;
2066         else
2067           value *= 1024;
2068         endptr++;
2069         }
2070       else if (tolower(*endptr) == 'k')
2071         endptr++;
2072       else
2073         value = (value + 512)/1024;
2074
2075     if (errno == ERANGE) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2076       "absolute value of integer \"%s\" is too large (overflow)", s);
2077
2078     while (isspace(*endptr)) endptr++;
2079     if (*endptr != 0)
2080       extra_chars_error(endptr, inttype, US"integer value for ", name);
2081     }
2082
2083   if (data_block == NULL)
2084     *((int *)(ol->value)) = value;
2085   else
2086     *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2087   break;
2088
2089   /*  Fixed-point number: held to 3 decimal places. */
2090
2091   case opt_fixed:
2092   if (sscanf(CS s, "%d%n", &value, &count) != 1)
2093     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2094       "fixed-point number expected for %s", name);
2095
2096   if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2097     "integer \"%s\" is too large (overflow)", s);
2098
2099   value *= 1000;
2100
2101   if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2102     "integer \"%s\" is too large (overflow)", s);
2103
2104   if (s[count] == '.')
2105     {
2106     int d = 100;
2107     while (isdigit(s[++count]))
2108       {
2109       value += (s[count] - '0') * d;
2110       d /= 10;
2111       }
2112     }
2113
2114   while (isspace(s[count])) count++;
2115
2116   if (s[count] != 0)
2117     extra_chars_error(s+count, US"fixed-point value for ", name, US"");
2118
2119   if (data_block == NULL)
2120     *((int *)(ol->value)) = value;
2121   else
2122     *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2123   break;
2124
2125   /* There's a special routine to read time values. */
2126
2127   case opt_time:
2128   value = readconf_readtime(s, 0, FALSE);
2129   if (value < 0)
2130     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2131       name);
2132   if (data_block == NULL)
2133     *((int *)(ol->value)) = value;
2134   else
2135     *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2136   break;
2137
2138   /* A time list is a list of colon-separated times, with the first
2139   element holding the size of the list and the second the number of
2140   entries used. */
2141
2142   case opt_timelist:
2143     {
2144     int count = 0;
2145     int *list = (data_block == NULL)?
2146       (int *)(ol->value) :
2147       (int *)((uschar *)data_block + (long int)(ol->value));
2148
2149     if (*s != 0) for (count = 1; count <= list[0] - 2; count++)
2150       {
2151       int terminator = 0;
2152       uschar *snext = Ustrchr(s, ':');
2153       if (snext != NULL)
2154         {
2155         uschar *ss = snext;
2156         while (ss > s && isspace(ss[-1])) ss--;
2157         terminator = *ss;
2158         }
2159       value = readconf_readtime(s, terminator, FALSE);
2160       if (value < 0)
2161         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2162           name);
2163       if (count > 1 && value <= list[count])
2164         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2165           "time value out of order for %s", name);
2166       list[count+1] = value;
2167       if (snext == NULL) break;
2168       s = snext + 1;
2169       while (isspace(*s)) s++;
2170       }
2171
2172     if (count > list[0] - 2)
2173       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many time values for %s",
2174         name);
2175     if (count > 0 && list[2] == 0) count = 0;
2176     list[1] = count;
2177     break;
2178     }
2179
2180   case opt_func:
2181     {
2182     void (*fn)() = ol->value;
2183     fn(name, s);
2184     break;
2185     }
2186   }
2187
2188 return TRUE;
2189 }
2190
2191
2192
2193 /*************************************************
2194 *               Print a time value               *
2195 *************************************************/
2196
2197 /*
2198 Argument:  a time value in seconds
2199 Returns:   pointer to a fixed buffer containing the time as a string,
2200            in readconf_readtime() format
2201 */
2202
2203 uschar *
2204 readconf_printtime(int t)
2205 {
2206 int s, m, h, d, w;
2207 uschar *p = time_buffer;
2208
2209 if (t < 0)
2210   {
2211   *p++ = '-';
2212   t = -t;
2213   }
2214
2215 s = t % 60;
2216 t /= 60;
2217 m = t % 60;
2218 t /= 60;
2219 h = t % 24;
2220 t /= 24;
2221 d = t % 7;
2222 w = t/7;
2223
2224 if (w > 0) { sprintf(CS p, "%dw", w); while (*p) p++; }
2225 if (d > 0) { sprintf(CS p, "%dd", d); while (*p) p++; }
2226 if (h > 0) { sprintf(CS p, "%dh", h); while (*p) p++; }
2227 if (m > 0) { sprintf(CS p, "%dm", m); while (*p) p++; }
2228 if (s > 0 || p == time_buffer) sprintf(CS p, "%ds", s);
2229
2230 return time_buffer;
2231 }
2232
2233
2234
2235 /*************************************************
2236 *      Print an individual option value          *
2237 *************************************************/
2238
2239 /* This is used by the -bP option, so prints to the standard output.
2240 The entire options list is passed in as an argument, because some options come
2241 in pairs - typically uid/gid settings, which can either be explicit numerical
2242 values, or strings to be expanded later. If the numerical value is unset,
2243 search for "*expand_<name>" to see if there is a string equivalent.
2244
2245 Arguments:
2246   ol             option entry, or NULL for an unknown option
2247   name           option name
2248   options_block  NULL for main configuration options; otherwise points to
2249                    a driver block; if the option doesn't have opt_public
2250                    set, then options_block->options_block is where the item
2251                    resides.
2252   oltop          points to the option list in which ol exists
2253   last           one more than the offset of the last entry in optop
2254   no_labels      do not show "foo = " at the start.
2255
2256 Returns:         nothing
2257 */
2258
2259 static void
2260 print_ol(optionlist *ol, uschar *name, void *options_block,
2261   optionlist *oltop, int last, BOOL no_labels)
2262 {
2263 struct passwd *pw;
2264 struct group *gr;
2265 optionlist *ol2;
2266 void *value;
2267 uid_t *uidlist;
2268 gid_t *gidlist;
2269 uschar *s;
2270 uschar name2[64];
2271
2272 if (ol == NULL)
2273   {
2274   printf("%s is not a known option\n", name);
2275   return;
2276   }
2277
2278 /* Non-admin callers cannot see options that have been flagged secure by the
2279 "hide" prefix. */
2280
2281 if (!admin_user && (ol->type & opt_secure) != 0)
2282   {
2283   if (no_labels)
2284     printf("%s\n", hidden);
2285   else
2286     printf("%s = %s\n", name, hidden);
2287   return;
2288   }
2289
2290 /* Else show the value of the option */
2291
2292 value = ol->value;
2293 if (options_block != NULL)
2294   {
2295   if ((ol->type & opt_public) == 0)
2296     options_block = (void *)(((driver_instance *)options_block)->options_block);
2297   value = (void *)((uschar *)options_block + (long int)value);
2298   }
2299
2300 switch(ol->type & opt_mask)
2301   {
2302   case opt_stringptr:
2303   case opt_rewrite:        /* Show the text value */
2304   s = *((uschar **)value);
2305   if (!no_labels) printf("%s = ", name);
2306   printf("%s\n", (s == NULL)? US"" : string_printing2(s, FALSE));
2307   break;
2308
2309   case opt_int:
2310   if (!no_labels) printf("%s = ", name);
2311   printf("%d\n", *((int *)value));
2312   break;
2313
2314   case opt_mkint:
2315     {
2316     int x = *((int *)value);
2317     if (x != 0 && (x & 1023) == 0)
2318       {
2319       int c = 'K';
2320       x >>= 10;
2321       if ((x & 1023) == 0)
2322         {
2323         c = 'M';
2324         x >>= 10;
2325         }
2326       if (!no_labels) printf("%s = ", name);
2327       printf("%d%c\n", x, c);
2328       }
2329     else
2330       {
2331       if (!no_labels) printf("%s = ", name);
2332       printf("%d\n", x);
2333       }
2334     }
2335   break;
2336
2337   case opt_Kint:
2338     {
2339     int x = *((int *)value);
2340     if (!no_labels) printf("%s = ", name);
2341     if (x == 0) printf("0\n");
2342       else if ((x & 1023) == 0) printf("%dM\n", x >> 10);
2343         else printf("%dK\n", x);
2344     }
2345   break;
2346
2347   case opt_octint:
2348   if (!no_labels) printf("%s = ", name);
2349   printf("%#o\n", *((int *)value));
2350   break;
2351
2352   /* Can be negative only when "unset", in which case integer */
2353
2354   case opt_fixed:
2355     {
2356     int x = *((int *)value);
2357     int f = x % 1000;
2358     int d = 100;
2359     if (x < 0) printf("%s =\n", name); else
2360       {
2361       if (!no_labels) printf("%s = ", name);
2362       printf("%d.", x/1000);
2363       do
2364         {
2365         printf("%d", f/d);
2366         f %= d;
2367         d /= 10;
2368         }
2369       while (f != 0);
2370       printf("\n");
2371       }
2372     }
2373   break;
2374
2375   /* If the numerical value is unset, try for the string value */
2376
2377   case opt_expand_uid:
2378   if (! *get_set_flag(name, oltop, last, options_block))
2379     {
2380     sprintf(CS name2, "*expand_%.50s", name);
2381     ol2 = find_option(name2, oltop, last);
2382     if (ol2 != NULL)
2383       {
2384       void *value2 = ol2->value;
2385       if (options_block != NULL)
2386         value2 = (void *)((uschar *)options_block + (long int)value2);
2387       s = *((uschar **)value2);
2388       if (!no_labels) printf("%s = ", name);
2389       printf("%s\n", (s == NULL)? US"" : string_printing(s));
2390       break;
2391       }
2392     }
2393
2394   /* Else fall through */
2395
2396   case opt_uid:
2397   if (!no_labels) printf("%s = ", name);
2398   if (! *get_set_flag(name, oltop, last, options_block))
2399     printf("\n");
2400   else
2401     {
2402     pw = getpwuid(*((uid_t *)value));
2403     if (pw == NULL)
2404       printf("%ld\n", (long int)(*((uid_t *)value)));
2405     else printf("%s\n", pw->pw_name);
2406     }
2407   break;
2408
2409   /* If the numerical value is unset, try for the string value */
2410
2411   case opt_expand_gid:
2412   if (! *get_set_flag(name, oltop, last, options_block))
2413     {
2414     sprintf(CS name2, "*expand_%.50s", name);
2415     ol2 = find_option(name2, oltop, last);
2416     if (ol2 != NULL && (ol2->type & opt_mask) == opt_stringptr)
2417       {
2418       void *value2 = ol2->value;
2419       if (options_block != NULL)
2420         value2 = (void *)((uschar *)options_block + (long int)value2);
2421       s = *((uschar **)value2);
2422       if (!no_labels) printf("%s = ", name);
2423       printf("%s\n", (s == NULL)? US"" : string_printing(s));
2424       break;
2425       }
2426     }
2427
2428   /* Else fall through */
2429
2430   case opt_gid:
2431   if (!no_labels) printf("%s = ", name);
2432   if (! *get_set_flag(name, oltop, last, options_block))
2433     printf("\n");
2434   else
2435     {
2436     gr = getgrgid(*((int *)value));
2437     if (gr == NULL)
2438        printf("%ld\n", (long int)(*((int *)value)));
2439     else printf("%s\n", gr->gr_name);
2440     }
2441   break;
2442
2443   case opt_uidlist:
2444   uidlist = *((uid_t **)value);
2445   if (!no_labels) printf("%s =", name);
2446   if (uidlist != NULL)
2447     {
2448     int i;
2449     uschar sep = ' ';
2450     if (no_labels) sep = '\0';
2451     for (i = 1; i <= (int)(uidlist[0]); i++)
2452       {
2453       uschar *name = NULL;
2454       pw = getpwuid(uidlist[i]);
2455       if (pw != NULL) name = US pw->pw_name;
2456       if (sep != '\0') printf("%c", sep);
2457       if (name != NULL) printf("%s", name);
2458         else printf("%ld", (long int)(uidlist[i]));
2459       sep = ':';
2460       }
2461     }
2462   printf("\n");
2463   break;
2464
2465   case opt_gidlist:
2466   gidlist = *((gid_t **)value);
2467   if (!no_labels) printf("%s =", name);
2468   if (gidlist != NULL)
2469     {
2470     int i;
2471     uschar sep = ' ';
2472     if (no_labels) sep = '\0';
2473     for (i = 1; i <= (int)(gidlist[0]); i++)
2474       {
2475       uschar *name = NULL;
2476       gr = getgrgid(gidlist[i]);
2477       if (gr != NULL) name = US gr->gr_name;
2478       if (sep != '\0') printf("%c", sep);
2479       if (name != NULL) printf("%s", name);
2480         else printf("%ld", (long int)(gidlist[i]));
2481       sep = ':';
2482       }
2483     }
2484   printf("\n");
2485   break;
2486
2487   case opt_time:
2488   if (!no_labels) printf("%s = ", name);
2489   printf("%s\n", readconf_printtime(*((int *)value)));
2490   break;
2491
2492   case opt_timelist:
2493     {
2494     int i;
2495     int *list = (int *)value;
2496     if (!no_labels) printf("%s = ", name);
2497     for (i = 0; i < list[1]; i++)
2498       printf("%s%s", (i == 0)? "" : ":", readconf_printtime(list[i+2]));
2499     printf("\n");
2500     }
2501   break;
2502
2503   case opt_bit:
2504   printf("%s%s\n", ((*((int *)value)) & (1 << ((ol->type >> 16) & 31)))?
2505     "" : "no_", name);
2506   break;
2507
2508   case opt_expand_bool:
2509   sprintf(CS name2, "*expand_%.50s", name);
2510   ol2 = find_option(name2, oltop, last);
2511   if (ol2 != NULL && ol2->value != NULL)
2512     {
2513     void *value2 = ol2->value;
2514     if (options_block != NULL)
2515       value2 = (void *)((uschar *)options_block + (long int)value2);
2516     s = *((uschar **)value2);
2517     if (s != NULL)
2518       {
2519       if (!no_labels) printf("%s = ", name);
2520       printf("%s\n", string_printing(s));
2521       break;
2522       }
2523     /* s == NULL => string not set; fall through */
2524     }
2525
2526   /* Fall through */
2527
2528   case opt_bool:
2529   case opt_bool_verify:
2530   case opt_bool_set:
2531   printf("%s%s\n", (*((BOOL *)value))? "" : "no_", name);
2532   break;
2533   }
2534 }
2535
2536
2537
2538 /*************************************************
2539 *        Print value from main configuration     *
2540 *************************************************/
2541
2542 /* This function, called as a result of encountering the -bP option,
2543 causes the value of any main configuration variable to be output if the
2544 second argument is NULL. There are some special values:
2545
2546   all                print all main configuration options
2547   config_file        print the name of the configuration file
2548                      (configure_file will still work, for backward
2549                      compatibility)
2550   routers            print the routers' configurations
2551   transports         print the transports' configuration
2552   authenticators     print the authenticators' configuration
2553   macros             print the macros' configuration
2554   router_list        print a list of router names
2555   transport_list     print a list of transport names
2556   authenticator_list print a list of authentication mechanism names
2557   macro_list         print a list of macro names
2558   +name              print a named list item
2559   local_scan         print the local_scan options
2560   config             print the configuration as it is parsed
2561   environment        print the used execution environment
2562
2563 If the second argument is not NULL, it must be one of "router", "transport",
2564 "authenticator" or "macro" in which case the first argument identifies the
2565 driver whose options are to be printed.
2566
2567 Arguments:
2568   name        option name if type == NULL; else driver name
2569   type        NULL or driver type name, as described above
2570   no_labels   avoid the "foo = " at the start of an item
2571
2572 Returns:      nothing
2573 */
2574
2575 void
2576 readconf_print(uschar *name, uschar *type, BOOL no_labels)
2577 {
2578 BOOL names_only = FALSE;
2579 optionlist *ol;
2580 optionlist *ol2 = NULL;
2581 driver_instance *d = NULL;
2582 macro_item *m;
2583 int size = 0;
2584
2585 if (type == NULL)
2586   {
2587   if (*name == '+')
2588     {
2589     int i;
2590     tree_node *t;
2591     BOOL found = FALSE;
2592     static uschar *types[] = { US"address", US"domain", US"host",
2593       US"localpart" };
2594     static tree_node **anchors[] = { &addresslist_anchor, &domainlist_anchor,
2595       &hostlist_anchor, &localpartlist_anchor };
2596
2597     for (i = 0; i < 4; i++)
2598       {
2599       t = tree_search(*(anchors[i]), name+1);
2600       if (t != NULL)
2601         {
2602         found = TRUE;
2603         if (no_labels)
2604           printf("%s\n", ((namedlist_block *)(t->data.ptr))->string);
2605         else
2606           printf("%slist %s = %s\n", types[i], name+1,
2607             ((namedlist_block *)(t->data.ptr))->string);
2608         }
2609       }
2610
2611     if (!found)
2612       printf("no address, domain, host, or local part list called \"%s\" "
2613         "exists\n", name+1);
2614
2615     return;
2616     }
2617
2618   if (  Ustrcmp(name, "configure_file") == 0
2619      || Ustrcmp(name, "config_file") == 0)
2620     {
2621     printf("%s\n", CS config_main_filename);
2622     return;
2623     }
2624
2625   if (Ustrcmp(name, "all") == 0)
2626     {
2627     for (ol = optionlist_config;
2628          ol < optionlist_config + nelem(optionlist_config); ol++)
2629       {
2630       if ((ol->type & opt_hidden) == 0)
2631         print_ol(ol, US ol->name, NULL,
2632             optionlist_config, nelem(optionlist_config),
2633             no_labels);
2634       }
2635     return;
2636     }
2637
2638   if (Ustrcmp(name, "local_scan") == 0)
2639     {
2640     #ifndef LOCAL_SCAN_HAS_OPTIONS
2641     printf("local_scan() options are not supported\n");
2642     #else
2643     for (ol = local_scan_options;
2644          ol < local_scan_options + local_scan_options_count; ol++)
2645       {
2646       print_ol(ol, US ol->name, NULL, local_scan_options,
2647         local_scan_options_count, no_labels);
2648       }
2649     #endif
2650     return;
2651     }
2652
2653   if (Ustrcmp(name, "config") == 0)
2654     {
2655     print_config(admin_user, no_labels);
2656     return;
2657     }
2658
2659   if (Ustrcmp(name, "routers") == 0)
2660     {
2661     type = US"router";
2662     name = NULL;
2663     }
2664   else if (Ustrcmp(name, "transports") == 0)
2665     {
2666     type = US"transport";
2667     name = NULL;
2668     }
2669
2670   else if (Ustrcmp(name, "authenticators") == 0)
2671     {
2672     type = US"authenticator";
2673     name = NULL;
2674     }
2675
2676   else if (Ustrcmp(name, "macros") == 0)
2677     {
2678     type = US"macro";
2679     name = NULL;
2680     }
2681
2682   else if (Ustrcmp(name, "router_list") == 0)
2683     {
2684     type = US"router";
2685     name = NULL;
2686     names_only = TRUE;
2687     }
2688
2689   else if (Ustrcmp(name, "transport_list") == 0)
2690     {
2691     type = US"transport";
2692     name = NULL;
2693     names_only = TRUE;
2694     }
2695
2696   else if (Ustrcmp(name, "authenticator_list") == 0)
2697     {
2698     type = US"authenticator";
2699     name = NULL;
2700     names_only = TRUE;
2701     }
2702
2703   else if (Ustrcmp(name, "macro_list") == 0)
2704     {
2705     type = US"macro";
2706     name = NULL;
2707     names_only = TRUE;
2708     }
2709
2710   else if (Ustrcmp(name, "environment") == 0)
2711     {
2712     if (environ)
2713       {
2714       uschar ** p;
2715       for (p = USS environ; *p; p++) ;
2716       qsort(environ, p - USS environ, sizeof(*p), string_compare_by_pointer);
2717
2718       for (p = USS environ; *p; p++)
2719         {
2720         uschar * q;
2721         if (no_labels && (q = Ustrchr(*p, '='))) *q  = '\0';
2722         puts(CS *p);
2723         }
2724       }
2725     return;
2726     }
2727
2728   else
2729     {
2730     print_ol(find_option(name, optionlist_config, nelem(optionlist_config)),
2731       name, NULL, optionlist_config, nelem(optionlist_config), no_labels);
2732     return;
2733     }
2734   }
2735
2736 /* Handle the options for a router or transport. Skip options that are flagged
2737 as hidden. Some of these are options with names starting with '*', used for
2738 internal alternative representations of other options (which the printing
2739 function will sort out). Others are synonyms kept for backward compatibility.
2740 */
2741
2742 if (Ustrcmp(type, "router") == 0)
2743   {
2744   d = (driver_instance *)routers;
2745   ol2 = optionlist_routers;
2746   size = optionlist_routers_size;
2747   }
2748 else if (Ustrcmp(type, "transport") == 0)
2749   {
2750   d = (driver_instance *)transports;
2751   ol2 = optionlist_transports;
2752   size = optionlist_transports_size;
2753   }
2754 else if (Ustrcmp(type, "authenticator") == 0)
2755   {
2756   d = (driver_instance *)auths;
2757   ol2 = optionlist_auths;
2758   size = optionlist_auths_size;
2759   }
2760
2761 else if (Ustrcmp(type, "macro") == 0)
2762   {
2763   /* People store passwords in macros and they were previously not available
2764   for printing.  So we have an admin_users restriction. */
2765   if (!admin_user)
2766     {
2767     fprintf(stderr, "exim: permission denied\n");
2768     exit(EXIT_FAILURE);
2769     }
2770   for (m = macros; m != NULL; m = m->next)
2771     {
2772     if (name == NULL || Ustrcmp(name, m->name) == 0)
2773       {
2774       if (names_only)
2775         printf("%s\n", CS m->name);
2776       else
2777         printf("%s=%s\n", CS m->name, CS m->replacement);
2778       if (name != NULL)
2779         return;
2780       }
2781     }
2782   if (name != NULL)
2783     printf("%s %s not found\n", type, name);
2784   return;
2785   }
2786
2787 if (names_only)
2788   {
2789   for (; d != NULL; d = d->next) printf("%s\n", CS d->name);
2790   return;
2791   }
2792
2793 /* Either search for a given driver, or print all of them */
2794
2795 for (; d != NULL; d = d->next)
2796   {
2797   if (name == NULL)
2798     printf("\n%s %s:\n", d->name, type);
2799   else if (Ustrcmp(d->name, name) != 0) continue;
2800
2801   for (ol = ol2; ol < ol2 + size; ol++)
2802     {
2803     if ((ol->type & opt_hidden) == 0)
2804       print_ol(ol, US ol->name, d, ol2, size, no_labels);
2805     }
2806
2807   for (ol = d->info->options;
2808        ol < d->info->options + *(d->info->options_count); ol++)
2809     {
2810     if ((ol->type & opt_hidden) == 0)
2811       print_ol(ol, US ol->name, d, d->info->options, *(d->info->options_count), no_labels);
2812     }
2813   if (name != NULL) return;
2814   }
2815 if (name != NULL) printf("%s %s not found\n", type, name);
2816 }
2817
2818
2819
2820 /*************************************************
2821 *          Read a named list item                *
2822 *************************************************/
2823
2824 /* This function reads a name and a list (i.e. string). The name is used to
2825 save the list in a tree, sorted by its name. Each entry also has a number,
2826 which can be used for caching tests, but if the string contains any expansion
2827 items other than $key, the number is set negative to inhibit caching. This
2828 mechanism is used for domain, host, and address lists that are referenced by
2829 the "+name" syntax.
2830
2831 Arguments:
2832   anchorp     points to the tree anchor
2833   numberp     points to the current number for this tree
2834   max         the maximum number permitted
2835   s           the text of the option line, starting immediately after the name
2836                 of the list type
2837   tname       the name of the list type, for messages
2838
2839 Returns:      nothing
2840 */
2841
2842 static void
2843 read_named_list(tree_node **anchorp, int *numberp, int max, uschar *s,
2844   uschar *tname)
2845 {
2846 BOOL forcecache = FALSE;
2847 uschar *ss;
2848 tree_node *t;
2849 namedlist_block *nb = store_get(sizeof(namedlist_block));
2850
2851 if (Ustrncmp(s, "_cache", 6) == 0)
2852   {
2853   forcecache = TRUE;
2854   s += 6;
2855   }
2856
2857 if (!isspace(*s))
2858   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unrecognized configuration line");
2859
2860 if (*numberp >= max)
2861  log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many named %ss (max is %d)\n",
2862    tname, max);
2863
2864 while (isspace(*s)) s++;
2865 ss = s;
2866 while (isalnum(*s) || *s == '_') s++;
2867 t = store_get(sizeof(tree_node) + s-ss);
2868 Ustrncpy(t->name, ss, s-ss);
2869 t->name[s-ss] = 0;
2870 while (isspace(*s)) s++;
2871
2872 if (!tree_insertnode(anchorp, t))
2873   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2874     "duplicate name \"%s\" for a named %s", t->name, tname);
2875
2876 t->data.ptr = nb;
2877 nb->number = *numberp;
2878 *numberp += 1;
2879
2880 if (*s++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2881   "missing '=' after \"%s\"", t->name);
2882 while (isspace(*s)) s++;
2883 nb->string = read_string(s, t->name);
2884 nb->cache_data = NULL;
2885
2886 /* Check the string for any expansions; if any are found, mark this list
2887 uncacheable unless the user has explicited forced caching. */
2888
2889 if (!forcecache && Ustrchr(nb->string, '$') != NULL) nb->number = -1;
2890 }
2891
2892
2893
2894
2895 /*************************************************
2896 *        Unpick data for a rate limit            *
2897 *************************************************/
2898
2899 /* This function is called to unpick smtp_ratelimit_{mail,rcpt} into four
2900 separate values.
2901
2902 Arguments:
2903   s            string, in the form t,b,f,l
2904                where t is the threshold (integer)
2905                b is the initial delay (time)
2906                f is the multiplicative factor (fixed point)
2907                k is the maximum time (time)
2908   threshold    where to store threshold
2909   base         where to store base in milliseconds
2910   factor       where to store factor in milliseconds
2911   limit        where to store limit
2912
2913 Returns:       nothing (panics on error)
2914 */
2915
2916 static void
2917 unpick_ratelimit(uschar *s, int *threshold, int *base, double *factor,
2918   int *limit)
2919 {
2920 uschar bstring[16], lstring[16];
2921
2922 if (sscanf(CS s, "%d, %15[0123456789smhdw.], %lf, %15s", threshold, bstring,
2923     factor, lstring) == 4)
2924   {
2925   *base = readconf_readtime(bstring, 0, TRUE);
2926   *limit = readconf_readtime(lstring, 0, TRUE);
2927   if (*base >= 0 && *limit >= 0) return;
2928   }
2929 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "malformed ratelimit data: %s", s);
2930 }
2931
2932
2933
2934
2935 /*************************************************
2936 *       Drop privs for checking TLS config      *
2937 *************************************************/
2938
2939 /* We want to validate TLS options during readconf, but do not want to be
2940 root when we call into the TLS library, in case of library linkage errors
2941 which cause segfaults; before this check, those were always done as the Exim
2942 runtime user and it makes sense to continue with that.
2943
2944 Assumes:  tls_require_ciphers has been set, if it will be
2945           exim_user has been set, if it will be
2946           exim_group has been set, if it will be
2947
2948 Returns:  bool for "okay"; false will cause caller to immediately exit.
2949 */
2950
2951 #ifdef SUPPORT_TLS
2952 static BOOL
2953 tls_dropprivs_validate_require_cipher(BOOL nowarn)
2954 {
2955 const uschar *errmsg;
2956 pid_t pid;
2957 int rc, status;
2958 void (*oldsignal)(int);
2959
2960 /* If TLS will never be used, no point checking ciphers */
2961
2962 if (  !tls_advertise_hosts
2963    || !*tls_advertise_hosts
2964    || Ustrcmp(tls_advertise_hosts, ":") == 0
2965    )
2966   return TRUE;
2967 else if (!nowarn && !tls_certificate)
2968   log_write(0, LOG_MAIN,
2969     "Warning: No server certificate defined; will use a selfsigned one.\n"
2970     " Suggested action: either install a certificate or change tls_advertise_hosts option");
2971
2972 oldsignal = signal(SIGCHLD, SIG_DFL);
2973
2974 fflush(NULL);
2975 if ((pid = fork()) < 0)
2976   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "fork failed for TLS check");
2977
2978 if (pid == 0)
2979   {
2980   /* in some modes, will have dropped privilege already */
2981   if (!geteuid())
2982     exim_setugid(exim_uid, exim_gid, FALSE,
2983         US"calling tls_validate_require_cipher");
2984
2985   errmsg = tls_validate_require_cipher();
2986   if (errmsg)
2987     {
2988     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
2989         "tls_require_ciphers invalid: %s", errmsg);
2990     }
2991   fflush(NULL);
2992   _exit(0);
2993   }
2994
2995 do {
2996   rc = waitpid(pid, &status, 0);
2997 } while (rc < 0 && errno == EINTR);
2998
2999 DEBUG(D_tls)
3000   debug_printf("tls_validate_require_cipher child %d ended: status=0x%x\n",
3001       (int)pid, status);
3002
3003 signal(SIGCHLD, oldsignal);
3004
3005 return status == 0;
3006 }
3007 #endif /* SUPPORT_TLS */
3008
3009
3010
3011
3012 /*************************************************/
3013 /* Create compile-time feature macros */
3014 void
3015 readconf_features(void)
3016 {
3017 /* Probably we could work out a static initialiser for wherever
3018 macros are stored, but this will do for now. Some names are awkward
3019 due to conflicts with other common macros. */
3020
3021 #ifdef SUPPORT_CRYPTEQ
3022   read_macro_assignment(US"_HAVE_CRYPTEQ=y");
3023 #endif
3024 #if HAVE_ICONV
3025   read_macro_assignment(US"_HAVE_ICONV=y");
3026 #endif
3027 #if HAVE_IPV6
3028   read_macro_assignment(US"_HAVE_IPV6=y");
3029 #endif
3030 #ifdef HAVE_SETCLASSRESOURCES
3031   read_macro_assignment(US"_HAVE_SETCLASSRESOURCES=y");
3032 #endif
3033 #ifdef SUPPORT_PAM
3034   read_macro_assignment(US"_HAVE_PAM=y");
3035 #endif
3036 #ifdef EXIM_PERL
3037   read_macro_assignment(US"_HAVE_PERL=y");
3038 #endif
3039 #ifdef EXPAND_DLFUNC
3040   read_macro_assignment(US"_HAVE_DLFUNC=y");
3041 #endif
3042 #ifdef USE_TCP_WRAPPERS
3043   read_macro_assignment(US"_HAVE_TCPWRAPPERS=y");
3044 #endif
3045 #ifdef SUPPORT_TLS
3046   read_macro_assignment(US"_HAVE_TLS=y");
3047 # ifdef USE_GNUTLS
3048   read_macro_assignment(US"_HAVE_GNUTLS=y");
3049 # else
3050   read_macro_assignment(US"_HAVE_OPENSSL=y");
3051 # endif
3052 #endif
3053 #ifdef SUPPORT_TRANSLATE_IP_ADDRESS
3054   read_macro_assignment(US"_HAVE_TRANSLATE_IP_ADDRESS=y");
3055 #endif
3056 #ifdef SUPPORT_MOVE_FROZEN_MESSAGES
3057   read_macro_assignment(US"_HAVE_MOVE_FROZEN_MESSAGES=y");
3058 #endif
3059 #ifdef WITH_CONTENT_SCAN
3060   read_macro_assignment(US"_HAVE_CONTENT_SCANNING=y");
3061 #endif
3062 #ifndef DISABLE_DKIM
3063   read_macro_assignment(US"_HAVE_DKIM=y");
3064 #endif
3065 #ifndef DISABLE_DNSSEC
3066   read_macro_assignment(US"_HAVE_DNSSEC=y");
3067 #endif
3068 #ifndef DISABLE_EVENT
3069   read_macro_assignment(US"_HAVE_Event=y");
3070 #endif
3071 #ifdef SUPPORT_I18N
3072   read_macro_assignment(US"_HAVE_I18N=y");
3073 #endif
3074 #ifndef DISABLE_OCSP
3075   read_macro_assignment(US"_HAVE_OCSP=y");
3076 #endif
3077 #ifndef DISABLE_PRDR
3078   read_macro_assignment(US"_HAVE_PRDR=y");
3079 #endif
3080 #ifdef SUPPORT_PROXY
3081   read_macro_assignment(US"_HAVE_PROXY=y");
3082 #endif
3083 #ifdef SUPPORT_SOCKS
3084   read_macro_assignment(US"_HAVE_SOCKS=y");
3085 #endif
3086 #ifdef EXPERIMENTAL_LMDB
3087   read_macro_assignment(US"_HAVE_LMDB=y");
3088 #endif
3089 #ifdef EXPERIMENTAL_SPF
3090   read_macro_assignment(US"_HAVE_SPF=y");
3091 #endif
3092 #ifdef EXPERIMENTAL_SRS
3093   read_macro_assignment(US"_HAVE_SRS=y");
3094 #endif
3095 #ifdef EXPERIMENTAL_BRIGHTMAIL
3096   read_macro_assignment(US"_HAVE_BRIGHTMAIL=y");
3097 #endif
3098 #ifdef EXPERIMENTAL_DANE
3099   read_macro_assignment(US"_HAVE_DANE=y");
3100 #endif
3101 #ifdef EXPERIMENTAL_DCC
3102   read_macro_assignment(US"_HAVE_DCC=y");
3103 #endif
3104 #ifdef EXPERIMENTAL_DMARC
3105   read_macro_assignment(US"_HAVE_DMARC=y");
3106 #endif
3107 #ifdef EXPERIMENTAL_DSN_INFO
3108   read_macro_assignment(US"_HAVE_DSN_INFO=y");
3109 #endif
3110
3111 #ifdef LOOKUP_LSEARCH
3112   read_macro_assignment(US"_HAVE_LKUP_LSEARCH=y");
3113 #endif
3114 #ifdef LOOKUP_CDB
3115   read_macro_assignment(US"_HAVE_LKUP_CDB=y");
3116 #endif
3117 #ifdef LOOKUP_DBM
3118   read_macro_assignment(US"_HAVE_LKUP_DBM=y");
3119 #endif
3120 #ifdef LOOKUP_DNSDB
3121   read_macro_assignment(US"_HAVE_LKUP_DNSDB=y");
3122 #endif
3123 #ifdef LOOKUP_DSEARCH
3124   read_macro_assignment(US"_HAVE_LKUP_DSEARCH=y");
3125 #endif
3126 #ifdef LOOKUP_IBASE
3127   read_macro_assignment(US"_HAVE_LKUP_IBASE=y");
3128 #endif
3129 #ifdef LOOKUP_LDAP
3130   read_macro_assignment(US"_HAVE_LKUP_LDAP=y");
3131 #endif
3132 #ifdef EXPERIMENTAL_LMDB
3133   read_macro_assignment(US"_HAVE_LKUP_LMDB=y");
3134 #endif
3135 #ifdef LOOKUP_MYSQL
3136   read_macro_assignment(US"_HAVE_LKUP_MYSQL=y");
3137 #endif
3138 #ifdef LOOKUP_NIS
3139   read_macro_assignment(US"_HAVE_LKUP_NIS=y");
3140 #endif
3141 #ifdef LOOKUP_NISPLUS
3142   read_macro_assignment(US"_HAVE_LKUP_NISPLUS=y");
3143 #endif
3144 #ifdef LOOKUP_ORACLE
3145   read_macro_assignment(US"_HAVE_LKUP_ORACLE=y");
3146 #endif
3147 #ifdef LOOKUP_PASSWD
3148   read_macro_assignment(US"_HAVE_LKUP_PASSWD=y");
3149 #endif
3150 #ifdef LOOKUP_PGSQL
3151   read_macro_assignment(US"_HAVE_LKUP_PGSQL=y");
3152 #endif
3153 #ifdef LOOKUP_REDIS
3154   read_macro_assignment(US"_HAVE_LKUP_REDIS=y");
3155 #endif
3156 #ifdef LOOKUP_SQLITE
3157   read_macro_assignment(US"_HAVE_LKUP_SQLITE=y");
3158 #endif
3159 #ifdef LOOKUP_TESTDB
3160   read_macro_assignment(US"_HAVE_LKUP_TESTDB=y");
3161 #endif
3162 #ifdef LOOKUP_WHOSON
3163   read_macro_assignment(US"_HAVE_LKUP_WHOSON=y");
3164 #endif
3165
3166 #ifdef TRANSPORT_APPENDFILE
3167 # ifdef SUPPORT_MAILDIR
3168   read_macro_assignment(US"_HAVE_TPT_APPEND_MAILDR=y");
3169 # endif
3170 # ifdef SUPPORT_MAILSTORE
3171   read_macro_assignment(US"_HAVE_TPT_APPEND_MAILSTORE=y");
3172 # endif
3173 # ifdef SUPPORT_MBX
3174   read_macro_assignment(US"_HAVE_TPT_APPEND_MBX=y");
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   read_macro_assignment(string_sprintf("_OPT_%T_%T=y", group, s));
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   read_macro_assignment(string_sprintf("_DRVR_AUTH_%T=y", ai->driver_name));
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 */