src/src/readconf.c

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