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