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