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