src/src/readconf.c

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