src/src/readconf.c

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