src/src/readconf.c

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