src/src/readconf.c

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