1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) The Exim Maintainers 2020 - 2024 */
6 /* Copyright (c) University of Cambridge 1995 - 2018 */
7 /* See the file NOTICE for conditions of use and distribution. */
8 /* SPDX-License-Identifier: GPL-2.0-or-later */
10 /* Functions for reading the configuration file, and for displaying
11 overall configuration values. Thanks to Brian Candler for the original
12 implementation of the conditional .ifdef etc. */
17 # include "macro_predef.h"
20 #define READCONF_DEBUG if (FALSE) /* Change to TRUE to enable */
23 static uschar * syslog_facility_str;
24 static void fn_smtp_receive_timeout(const uschar *, const uschar *, unsigned);
26 /*************************************************
27 * Main configuration options *
28 *************************************************/
30 /* The list of options that can be set in the main configuration file. This
31 must be in alphabetic order because it is searched by binary chop. */
33 static optionlist optionlist_config[] = {
34 { "*set_exim_group", opt_bool|opt_hidden, {&exim_gid_set} },
35 { "*set_exim_user", opt_bool|opt_hidden, {&exim_uid_set} },
36 { "*set_system_filter_group", opt_bool|opt_hidden, {&system_filter_gid_set} },
37 { "*set_system_filter_user", opt_bool|opt_hidden, {&system_filter_uid_set} },
38 { "accept_8bitmime", opt_bool, {&accept_8bitmime} },
39 { "acl_not_smtp", opt_stringptr, {&acl_not_smtp} },
40 #ifdef WITH_CONTENT_SCAN
41 { "acl_not_smtp_mime", opt_stringptr, {&acl_not_smtp_mime} },
43 { "acl_not_smtp_start", opt_stringptr, {&acl_not_smtp_start} },
44 { "acl_smtp_auth", opt_stringptr, {&acl_smtp_auth} },
45 { "acl_smtp_connect", opt_stringptr, {&acl_smtp_connect} },
46 { "acl_smtp_data", opt_stringptr, {&acl_smtp_data} },
48 { "acl_smtp_data_prdr", opt_stringptr, {&acl_smtp_data_prdr} },
51 { "acl_smtp_dkim", opt_module, {US"dkim"} },
53 { "acl_smtp_etrn", opt_stringptr, {&acl_smtp_etrn} },
54 { "acl_smtp_expn", opt_stringptr, {&acl_smtp_expn} },
55 { "acl_smtp_helo", opt_stringptr, {&acl_smtp_helo} },
56 { "acl_smtp_mail", opt_stringptr, {&acl_smtp_mail} },
57 { "acl_smtp_mailauth", opt_stringptr, {&acl_smtp_mailauth} },
58 #ifdef WITH_CONTENT_SCAN
59 { "acl_smtp_mime", opt_stringptr, {&acl_smtp_mime} },
61 { "acl_smtp_notquit", opt_stringptr, {&acl_smtp_notquit} },
62 { "acl_smtp_predata", opt_stringptr, {&acl_smtp_predata} },
63 { "acl_smtp_quit", opt_stringptr, {&acl_smtp_quit} },
64 { "acl_smtp_rcpt", opt_stringptr, {&acl_smtp_rcpt} },
66 { "acl_smtp_starttls", opt_stringptr, {&acl_smtp_starttls} },
68 { "acl_smtp_vrfy", opt_stringptr, {&acl_smtp_vrfy} },
69 #ifndef DISABLE_WELLKNOWN
70 { "acl_smtp_wellknown", opt_stringptr, {&acl_smtp_wellknown} },
72 { "add_environment", opt_stringptr, {&add_environment} },
73 { "admin_groups", opt_gidlist, {&admin_groups} },
74 { "allow_domain_literals", opt_bool, {&allow_domain_literals} },
75 { "allow_mx_to_ip", opt_bool, {&allow_mx_to_ip} },
76 { "allow_utf8_domains", opt_bool, {&allow_utf8_domains} },
77 { "auth_advertise_hosts", opt_stringptr, {&auth_advertise_hosts} },
78 { "auto_thaw", opt_time, {&auto_thaw} },
79 #ifdef WITH_CONTENT_SCAN
80 { "av_scanner", opt_stringptr, {&av_scanner} },
82 { "bi_command", opt_stringptr, {&bi_command} },
83 #ifdef EXPERIMENTAL_BRIGHTMAIL
84 { "bmi_config_file", opt_stringptr, {&bmi_config_file} },
86 { "bounce_message_file", opt_stringptr, {&bounce_message_file} },
87 { "bounce_message_text", opt_stringptr, {&bounce_message_text} },
88 { "bounce_return_body", opt_bool, {&bounce_return_body} },
89 { "bounce_return_linesize_limit", opt_mkint, {&bounce_return_linesize_limit} },
90 { "bounce_return_message", opt_bool, {&bounce_return_message} },
91 { "bounce_return_size_limit", opt_mkint, {&bounce_return_size_limit} },
92 { "bounce_sender_authentication",opt_stringptr,{&bounce_sender_authentication} },
93 { "callout_domain_negative_expire", opt_time, {&callout_cache_domain_negative_expire} },
94 { "callout_domain_positive_expire", opt_time, {&callout_cache_domain_positive_expire} },
95 { "callout_negative_expire", opt_time, {&callout_cache_negative_expire} },
96 { "callout_positive_expire", opt_time, {&callout_cache_positive_expire} },
97 { "callout_random_local_part",opt_stringptr, {&callout_random_local_part} },
98 { "check_log_inodes", opt_int, {&check_log_inodes} },
99 { "check_log_space", opt_Kint, {&check_log_space} },
100 { "check_rfc2047_length", opt_bool, {&check_rfc2047_length} },
101 { "check_spool_inodes", opt_int, {&check_spool_inodes} },
102 { "check_spool_space", opt_Kint, {&check_spool_space} },
103 { "chunking_advertise_hosts", opt_stringptr, {&chunking_advertise_hosts} },
104 { "commandline_checks_require_admin", opt_bool,{&commandline_checks_require_admin} },
105 { "daemon_smtp_port", opt_stringptr|opt_hidden, {&daemon_smtp_port} },
106 { "daemon_smtp_ports", opt_stringptr, {&daemon_smtp_port} },
107 { "daemon_startup_retries", opt_int, {&daemon_startup_retries} },
108 { "daemon_startup_sleep", opt_time, {&daemon_startup_sleep} },
109 #ifdef EXPERIMENTAL_DCC
110 { "dcc_direct_add_header", opt_bool, {&dcc_direct_add_header} },
111 { "dccifd_address", opt_stringptr, {&dccifd_address} },
112 { "dccifd_options", opt_stringptr, {&dccifd_options} },
114 { "debug_store", opt_bool, {&debug_store} },
115 { "delay_warning", opt_timelist, {&delay_warning} },
116 { "delay_warning_condition", opt_stringptr, {&delay_warning_condition} },
117 { "deliver_drop_privilege", opt_bool, {&deliver_drop_privilege} },
118 { "deliver_queue_load_max", opt_fixed, {&deliver_queue_load_max} },
119 { "delivery_date_remove", opt_bool, {&delivery_date_remove} },
120 #ifdef ENABLE_DISABLE_FSYNC
121 { "disable_fsync", opt_bool, {&disable_fsync} },
123 { "disable_ipv6", opt_bool, {&disable_ipv6} },
125 { "dkim_verify_hashes", opt_module, {US"dkim"} },
126 { "dkim_verify_keytypes", opt_module, {US"dkim"} },
127 { "dkim_verify_min_keysizes", opt_module, {US"dkim"} },
128 { "dkim_verify_minimal", opt_module, {US"dkim"} },
129 { "dkim_verify_signers", opt_module, {US"dkim"} },
132 { "dmarc_forensic_sender", opt_module, {US"dmarc"} },
133 { "dmarc_history_file", opt_module, {US"dmarc"} },
134 { "dmarc_tld_file", opt_module, {US"dmarc"} },
136 { "dns_again_means_nonexist", opt_stringptr, {&dns_again_means_nonexist} },
137 { "dns_check_names_pattern", opt_stringptr, {&check_dns_names_pattern} },
138 { "dns_cname_loops", opt_int, {&dns_cname_loops} },
139 { "dns_csa_search_limit", opt_int, {&dns_csa_search_limit} },
140 { "dns_csa_use_reverse", opt_bool, {&dns_csa_use_reverse} },
141 { "dns_dnssec_ok", opt_int, {&dns_dnssec_ok} },
142 { "dns_ipv4_lookup", opt_stringptr, {&dns_ipv4_lookup} },
143 { "dns_retrans", opt_time, {&dns_retrans} },
144 { "dns_retry", opt_int, {&dns_retry} },
145 { "dns_trust_aa", opt_stringptr, {&dns_trust_aa} },
146 { "dns_use_edns0", opt_int, {&dns_use_edns0} },
147 /* This option is now a no-op, retained for compatibility */
148 { "drop_cr", opt_bool, {&drop_cr} },
149 /*********************************************************/
150 { "dsn_advertise_hosts", opt_stringptr, {&dsn_advertise_hosts} },
151 { "dsn_from", opt_stringptr, {&dsn_from} },
152 { "envelope_to_remove", opt_bool, {&envelope_to_remove} },
153 { "errors_copy", opt_stringptr, {&errors_copy} },
154 { "errors_reply_to", opt_stringptr, {&errors_reply_to} },
155 #ifndef DISABLE_EVENT
156 { "event_action", opt_stringptr, {&event_action} },
158 { "exim_group", opt_gid, {&exim_gid} },
159 { "exim_path", opt_stringptr, {&exim_path} },
160 { "exim_user", opt_uid, {&exim_uid} },
161 { "exim_version", opt_stringptr, {&version_string} },
162 { "extra_local_interfaces", opt_stringptr, {&extra_local_interfaces} },
163 { "extract_addresses_remove_arguments", opt_bool, {&extract_addresses_remove_arguments} },
164 { "finduser_retries", opt_int, {&finduser_retries} },
165 { "freeze_tell", opt_stringptr, {&freeze_tell} },
166 { "gecos_name", opt_stringptr, {&gecos_name} },
167 { "gecos_pattern", opt_stringptr, {&gecos_pattern} },
169 { "gnutls_allow_auto_pkcs11", opt_bool, {&gnutls_allow_auto_pkcs11} },
170 { "gnutls_compat_mode", opt_bool, {&gnutls_compat_mode} },
172 { "header_line_maxsize", opt_int, {&header_line_maxsize} },
173 { "header_maxsize", opt_int, {&header_maxsize} },
174 { "headers_charset", opt_stringptr, {&headers_charset} },
175 { "helo_accept_junk_hosts", opt_stringptr, {&helo_accept_junk_hosts} },
176 { "helo_allow_chars", opt_stringptr, {&helo_allow_chars} },
177 { "helo_lookup_domains", opt_stringptr, {&helo_lookup_domains} },
178 { "helo_try_verify_hosts", opt_stringptr, {&helo_try_verify_hosts} },
179 { "helo_verify_hosts", opt_stringptr, {&helo_verify_hosts} },
180 { "hold_domains", opt_stringptr, {&hold_domains} },
181 { "host_lookup", opt_stringptr, {&host_lookup} },
182 { "host_lookup_order", opt_stringptr, {&host_lookup_order} },
183 { "host_reject_connection", opt_stringptr, {&host_reject_connection} },
184 { "hosts_connection_nolog", opt_stringptr, {&hosts_connection_nolog} },
186 { "hosts_proxy", opt_stringptr, {&hosts_proxy} },
189 { "hosts_require_alpn", opt_stringptr, {&hosts_require_alpn} },
191 { "hosts_require_helo", opt_stringptr, {&hosts_require_helo} },
192 { "hosts_treat_as_local", opt_stringptr, {&hosts_treat_as_local} },
193 #ifdef EXPERIMENTAL_XCLIENT
194 { "hosts_xclient", opt_stringptr, {&hosts_xclient} },
197 { "ibase_servers", opt_stringptr, {&ibase_servers} },
199 { "ignore_bounce_errors_after", opt_time, {&ignore_bounce_errors_after} },
200 { "ignore_fromline_hosts", opt_stringptr, {&ignore_fromline_hosts} },
201 { "ignore_fromline_local", opt_bool, {&ignore_fromline_local} },
202 { "keep_environment", opt_stringptr, {&keep_environment} },
203 { "keep_malformed", opt_time, {&keep_malformed} },
205 { "ldap_ca_cert_dir", opt_stringptr, {&eldap_ca_cert_dir} },
206 { "ldap_ca_cert_file", opt_stringptr, {&eldap_ca_cert_file} },
207 { "ldap_cert_file", opt_stringptr, {&eldap_cert_file} },
208 { "ldap_cert_key", opt_stringptr, {&eldap_cert_key} },
209 { "ldap_cipher_suite", opt_stringptr, {&eldap_cipher_suite} },
210 { "ldap_default_servers", opt_stringptr, {&eldap_default_servers} },
211 { "ldap_require_cert", opt_stringptr, {&eldap_require_cert} },
212 { "ldap_start_tls", opt_bool, {&eldap_start_tls} },
213 { "ldap_version", opt_int, {&eldap_version} },
215 #ifndef DISABLE_ESMTP_LIMITS
216 { "limits_advertise_hosts", opt_stringptr, {&limits_advertise_hosts} },
218 { "local_from_check", opt_bool, {&local_from_check} },
219 { "local_from_prefix", opt_stringptr, {&local_from_prefix} },
220 { "local_from_suffix", opt_stringptr, {&local_from_suffix} },
221 { "local_interfaces", opt_stringptr, {&local_interfaces} },
222 #ifdef HAVE_LOCAL_SCAN
223 { "local_scan_timeout", opt_time, {&local_scan_timeout} },
225 { "local_sender_retain", opt_bool, {&local_sender_retain} },
226 { "localhost_number", opt_stringptr, {&host_number_string} },
227 { "log_file_path", opt_stringptr, {&log_file_path} },
228 { "log_selector", opt_stringptr, {&log_selector_string} },
229 { "log_timezone", opt_bool, {&log_timezone} },
230 { "lookup_open_max", opt_int, {&lookup_open_max} },
231 { "max_username_length", opt_int, {&max_username_length} },
232 { "message_body_newlines", opt_bool, {&message_body_newlines} },
233 { "message_body_visible", opt_mkint, {&message_body_visible} },
234 { "message_id_header_domain", opt_stringptr, {&message_id_domain} },
235 { "message_id_header_text", opt_stringptr, {&message_id_text} },
236 { "message_logs", opt_bool, {&message_logs} },
237 { "message_size_limit", opt_stringptr, {&message_size_limit} },
238 #ifdef SUPPORT_MOVE_FROZEN_MESSAGES
239 { "move_frozen_messages", opt_bool, {&move_frozen_messages} },
241 { "mua_wrapper", opt_bool, {&mua_wrapper} },
243 { "mysql_servers", opt_stringptr, {&mysql_servers} },
245 { "never_users", opt_uidlist, {&never_users} },
246 { "notifier_socket", opt_stringptr, {¬ifier_socket} },
248 { "openssl_options", opt_stringptr, {&openssl_options} },
251 { "oracle_servers", opt_stringptr, {&oracle_servers} },
253 { "panic_coredump", opt_bool, {&panic_coredump} },
254 { "percent_hack_domains", opt_stringptr, {&percent_hack_domains} },
256 { "perl_at_start", opt_bool, {&opt_perl_at_start} },
257 { "perl_startup", opt_stringptr, {&opt_perl_startup} },
258 { "perl_taintmode", opt_bool, {&opt_perl_taintmode} },
261 { "pgsql_servers", opt_stringptr, {&pgsql_servers} },
263 { "pid_file_path", opt_stringptr, {&pid_file_path} },
264 { "pipelining_advertise_hosts", opt_stringptr, {&pipelining_advertise_hosts} },
265 #ifndef DISABLE_PIPE_CONNECT
266 { "pipelining_connect_advertise_hosts", opt_stringptr,
267 {&pipe_connect_advertise_hosts} },
270 { "prdr_enable", opt_bool, {&prdr_enable} },
272 { "preserve_message_logs", opt_bool, {&preserve_message_logs} },
273 { "primary_hostname", opt_stringptr, {&primary_hostname} },
274 { "print_topbitchars", opt_bool, {&print_topbitchars} },
275 { "process_log_path", opt_stringptr, {&process_log_path} },
276 { "prod_requires_admin", opt_bool, {&prod_requires_admin} },
278 { "proxy_protocol_timeout", opt_time, {&proxy_protocol_timeout} },
280 { "qualify_domain", opt_stringptr, {&qualify_domain_sender} },
281 { "qualify_recipient", opt_stringptr, {&qualify_domain_recipient} },
282 { "queue_domains", opt_stringptr, {&queue_domains} },
283 #ifndef DISABLE_QUEUE_RAMP
284 { "queue_fast_ramp", opt_bool, {&queue_fast_ramp} },
286 { "queue_list_requires_admin",opt_bool, {&queue_list_requires_admin} },
287 { "queue_only", opt_bool, {&queue_only} },
288 { "queue_only_file", opt_stringptr, {&queue_only_file} },
289 { "queue_only_load", opt_fixed, {&queue_only_load} },
290 { "queue_only_load_latch", opt_bool, {&queue_only_load_latch} },
291 { "queue_only_override", opt_bool, {&queue_only_override} },
292 { "queue_run_in_order", opt_bool, {&queue_run_in_order} },
293 { "queue_run_max", opt_stringptr, {&queue_run_max} },
294 { "queue_smtp_domains", opt_stringptr, {&queue_smtp_domains} },
295 { "receive_timeout", opt_time, {&receive_timeout} },
296 { "received_header_text", opt_stringptr, {&received_header_text} },
297 { "received_headers_max", opt_int, {&received_headers_max} },
298 { "recipient_unqualified_hosts", opt_stringptr, {&recipient_unqualified_hosts} },
299 { "recipients_max", opt_stringptr, {&recipients_max} },
300 { "recipients_max_reject", opt_bool, {&recipients_max_reject} },
302 { "redis_servers", opt_stringptr, {&redis_servers} },
304 { "remote_max_parallel", opt_int, {&remote_max_parallel} },
305 { "remote_sort_domains", opt_stringptr, {&remote_sort_domains} },
306 { "retry_data_expire", opt_time, {&retry_data_expire} },
307 { "retry_interval_max", opt_time, {&retry_interval_max} },
308 { "return_path_remove", opt_bool, {&return_path_remove} },
309 { "return_size_limit", opt_mkint|opt_hidden, {&bounce_return_size_limit} },
310 { "rfc1413_hosts", opt_stringptr, {&rfc1413_hosts} },
311 { "rfc1413_query_timeout", opt_time, {&rfc1413_query_timeout} },
312 { "sender_unqualified_hosts", opt_stringptr, {&sender_unqualified_hosts} },
313 { "slow_lookup_log", opt_int, {&slow_lookup_log} },
314 { "smtp_accept_keepalive", opt_bool, {&smtp_accept_keepalive} },
315 { "smtp_accept_max", opt_int, {&smtp_accept_max} },
316 { "smtp_accept_max_nonmail", opt_int, {&smtp_accept_max_nonmail} },
317 { "smtp_accept_max_nonmail_hosts", opt_stringptr, {&smtp_accept_max_nonmail_hosts} },
318 { "smtp_accept_max_per_connection", opt_stringptr, {&smtp_accept_max_per_connection} },
319 { "smtp_accept_max_per_host", opt_stringptr, {&smtp_accept_max_per_host} },
320 { "smtp_accept_queue", opt_int, {&smtp_accept_queue} },
321 { "smtp_accept_queue_per_connection", opt_int, {&smtp_accept_queue_per_connection} },
322 { "smtp_accept_reserve", opt_int, {&smtp_accept_reserve} },
323 { "smtp_active_hostname", opt_stringptr, {&raw_active_hostname} },
324 { "smtp_backlog_monitor", opt_int, {&smtp_backlog_monitor} },
325 { "smtp_banner", opt_stringptr, {&smtp_banner} },
326 { "smtp_check_spool_space", opt_bool, {&smtp_check_spool_space} },
327 { "smtp_connect_backlog", opt_int, {&smtp_connect_backlog} },
328 { "smtp_enforce_sync", opt_bool, {&smtp_enforce_sync} },
329 { "smtp_etrn_command", opt_stringptr, {&smtp_etrn_command} },
330 { "smtp_etrn_serialize", opt_bool, {&smtp_etrn_serialize} },
331 { "smtp_load_reserve", opt_fixed, {&smtp_load_reserve} },
332 { "smtp_max_synprot_errors", opt_int, {&smtp_max_synprot_errors} },
333 { "smtp_max_unknown_commands",opt_int, {&smtp_max_unknown_commands} },
334 { "smtp_ratelimit_hosts", opt_stringptr, {&smtp_ratelimit_hosts} },
335 { "smtp_ratelimit_mail", opt_stringptr, {&smtp_ratelimit_mail} },
336 { "smtp_ratelimit_rcpt", opt_stringptr, {&smtp_ratelimit_rcpt} },
337 { "smtp_receive_timeout", opt_func, {.fn = &fn_smtp_receive_timeout} },
338 { "smtp_reserve_hosts", opt_stringptr, {&smtp_reserve_hosts} },
339 { "smtp_return_error_details",opt_bool, {&smtp_return_error_details} },
341 { "smtputf8_advertise_hosts", opt_stringptr, {&smtputf8_advertise_hosts} },
343 #ifdef WITH_CONTENT_SCAN
344 { "spamd_address", opt_stringptr, {&spamd_address} },
347 { "spf_guess", opt_module, {US"spf"} },
348 { "spf_smtp_comment_template",opt_module, {US"spf"} },
350 { "split_spool_directory", opt_bool, {&split_spool_directory} },
351 { "spool_directory", opt_stringptr, {&spool_directory} },
352 { "spool_wireformat", opt_bool, {&spool_wireformat} },
354 { "sqlite_dbfile", opt_stringptr, {&sqlite_dbfile} },
355 { "sqlite_lock_timeout", opt_int, {&sqlite_lock_timeout} },
357 { "strict_acl_vars", opt_bool, {&strict_acl_vars} },
358 { "strip_excess_angle_brackets", opt_bool, {&strip_excess_angle_brackets} },
359 { "strip_trailing_dot", opt_bool, {&strip_trailing_dot} },
360 { "syslog_duplication", opt_bool, {&syslog_duplication} },
361 { "syslog_facility", opt_stringptr, {&syslog_facility_str} },
362 { "syslog_pid", opt_bool, {&syslog_pid} },
363 { "syslog_processname", opt_stringptr, {&syslog_processname} },
364 { "syslog_timestamp", opt_bool, {&syslog_timestamp} },
365 { "system_filter", opt_stringptr, {&system_filter} },
366 { "system_filter_directory_transport", opt_stringptr,{&system_filter_directory_transport} },
367 { "system_filter_file_transport",opt_stringptr,{&system_filter_file_transport} },
368 { "system_filter_group", opt_gid, {&system_filter_gid} },
369 { "system_filter_pipe_transport",opt_stringptr,{&system_filter_pipe_transport} },
370 { "system_filter_reply_transport",opt_stringptr,{&system_filter_reply_transport} },
371 { "system_filter_user", opt_uid, {&system_filter_uid} },
372 { "tcp_nodelay", opt_bool, {&tcp_nodelay} },
373 #ifdef USE_TCP_WRAPPERS
374 { "tcp_wrappers_daemon_name", opt_stringptr, {&tcp_wrappers_daemon_name} },
376 { "timeout_frozen_after", opt_time, {&timeout_frozen_after} },
377 { "timezone", opt_stringptr, {&timezone_string} },
378 { "tls_advertise_hosts", opt_stringptr, {&tls_advertise_hosts} },
380 { "tls_alpn", opt_stringptr, {&tls_alpn} },
381 { "tls_certificate", opt_stringptr, {&tls_certificate} },
382 { "tls_crl", opt_stringptr, {&tls_crl} },
383 { "tls_dh_max_bits", opt_int, {&tls_dh_max_bits} },
384 { "tls_dhparam", opt_stringptr, {&tls_dhparam} },
385 { "tls_eccurve", opt_stringptr, {&tls_eccurve} },
386 # ifndef DISABLE_OCSP
387 { "tls_ocsp_file", opt_stringptr, {&tls_ocsp_file} },
389 { "tls_on_connect_ports", opt_stringptr, {&tls_in.on_connect_ports} },
390 { "tls_privatekey", opt_stringptr, {&tls_privatekey} },
391 { "tls_remember_esmtp", opt_bool, {&tls_remember_esmtp} },
392 { "tls_require_ciphers", opt_stringptr, {&tls_require_ciphers} },
393 # ifndef DISABLE_TLS_RESUME
394 { "tls_resumption_hosts", opt_stringptr, {&tls_resumption_hosts} },
396 { "tls_try_verify_hosts", opt_stringptr, {&tls_try_verify_hosts} },
397 { "tls_verify_certificates", opt_stringptr, {&tls_verify_certificates} },
398 { "tls_verify_hosts", opt_stringptr, {&tls_verify_hosts} },
400 { "trusted_groups", opt_gidlist, {&trusted_groups} },
401 { "trusted_users", opt_uidlist, {&trusted_users} },
402 { "unknown_login", opt_stringptr, {&unknown_login} },
403 { "unknown_username", opt_stringptr, {&unknown_username} },
404 { "untrusted_set_sender", opt_stringptr, {&untrusted_set_sender} },
405 { "uucp_from_pattern", opt_stringptr, {&uucp_from_pattern} },
406 { "uucp_from_sender", opt_stringptr, {&uucp_from_sender} },
407 { "warn_message_file", opt_stringptr, {&warn_message_file} },
408 #ifndef DISABLE_WELLKNOWN
409 { "wellknown_advertise_hosts",opt_stringptr, {&wellknown_advertise_hosts} },
411 { "write_rejectlog", opt_bool, {&write_rejectlog} },
415 static int optionlist_config_size = nelem(optionlist_config);
422 fn_smtp_receive_timeout(const uschar * name, const uschar * str, unsigned flags) {/*Dummy*/}
427 options_from_list(optionlist_config, nelem(optionlist_config), US"MAIN", NULL);
433 uschar buf[EXIM_DRIVERNAME_MAX];
435 options_from_list(optionlist_auths, optionlist_auths_size,
436 US"AUTHENTICATORS", NULL);
438 for (driver_info * di = (driver_info *)auths_available; di; di = di->next)
440 auth_info * ai = (auth_info *)di;
442 spf(buf, sizeof(buf), US"_DRIVER_AUTHENTICATOR_%T", di->driver_name);
443 builtin_macro_create(buf);
444 options_from_list(di->options, (unsigned)*di->options_count,
445 US"AUTHENTICATOR", di->driver_name);
447 if (ai->macros_create) (ai->macros_create)();
452 options_logging(void)
454 uschar buf[EXIM_DRIVERNAME_MAX];
456 for (bit_table * bp = log_options; bp < log_options + log_options_count; bp++)
458 spf(buf, sizeof(buf), US"_LOG_%T", bp->name);
459 builtin_macro_create(buf);
464 #else /*!MACRO_PREDEF*/
466 extern char **environ;
468 static void save_config_line(const uschar* line);
469 static void save_config_position(const uschar *file, int line);
470 static void print_config(BOOL admin, BOOL terse);
473 #define CSTATE_STACK_SIZE 10
475 const uschar *config_directory = NULL;
478 /* Structure for chain (stack) of .included files */
480 typedef struct config_file_item {
481 struct config_file_item *next;
482 const uschar *filename;
483 const uschar *directory;
488 /* Structure for chain of configuration lines (-bP config) */
490 typedef struct config_line_item {
491 struct config_line_item *next;
495 static config_line_item* config_lines;
497 /* Structure of table of conditional words and their state transitions */
499 typedef struct cond_item {
507 /* Structure of table of syslog facility names and values */
509 typedef struct syslog_fac_item {
515 static const uschar * const hidden = US"<value not displayable>";
517 /* Static variables */
519 static config_file_item *config_file_stack = NULL; /* For includes */
521 static uschar *syslog_facility_str = NULL;
522 static uschar next_section[24];
523 static uschar time_buffer[24];
525 /* State variables for conditional loading (.ifdef / .else / .endif) */
527 static int cstate = 0;
528 static int cstate_stack_ptr = -1;
529 static int cstate_stack[CSTATE_STACK_SIZE];
531 /* Table of state transitions for handling conditional inclusions. There are
532 four possible state transitions:
536 .elifdef true (or .else)
539 .endif just causes the previous cstate to be popped off the stack */
541 static int next_cstate[3][4] =
543 /* State 0: reading from file, or reading until next .else or .endif */
545 /* State 1: condition failed, skipping until next .else or .endif */
547 /* State 2: skipping until .endif */
551 /* Table of conditionals and the states to set. For each name, there are four
552 values: the length of the name (to save computing it each time), the state to
553 set if a macro was found in the line, the state to set if a macro was not found
554 in the line, and a stack manipulation setting which is:
556 -1 pull state value off the stack
557 0 don't alter the stack
558 +1 push value onto stack, before setting new state
561 static cond_item cond_list[] = {
562 { US"ifdef", 5, 0, 1, 1 },
563 { US"ifndef", 6, 1, 0, 1 },
564 { US"elifdef", 7, 2, 3, 0 },
565 { US"elifndef", 8, 3, 2, 0 },
566 { US"else", 4, 2, 2, 0 },
567 { US"endif", 5, 0, 0, -1 }
570 static int cond_list_size = sizeof(cond_list)/sizeof(cond_item);
572 /* Table of syslog facility names and their values */
574 static syslog_fac_item syslog_list[] = {
575 { US"mail", LOG_MAIL },
576 { US"user", LOG_USER },
577 { US"news", LOG_NEWS },
578 { US"uucp", LOG_UUCP },
579 { US"local0", LOG_LOCAL0 },
580 { US"local1", LOG_LOCAL1 },
581 { US"local2", LOG_LOCAL2 },
582 { US"local3", LOG_LOCAL3 },
583 { US"local4", LOG_LOCAL4 },
584 { US"local5", LOG_LOCAL5 },
585 { US"local6", LOG_LOCAL6 },
586 { US"local7", LOG_LOCAL7 },
587 { US"daemon", LOG_DAEMON }
590 static int syslog_list_size = sizeof(syslog_list)/sizeof(syslog_fac_item);
593 #define opt_fn_print BIT(0)
594 #define opt_fn_print_label BIT(1)
597 /*************************************************
598 * Find the name of an option *
599 *************************************************/
601 /* This function is to aid debugging. Various functions take arguments that are
602 pointer variables in the options table or in option tables for various drivers.
603 For debugging output, it is useful to be able to find the name of the option
604 which is currently being processed. This function finds it, if it exists, by
605 searching the table(s) for a value with the given content.
607 Arguments: a value that is presumed to be in the table above
608 Returns: the option name, or an empty string
612 readconf_find_option(void * listptr)
614 uschar * list = * USS listptr;
615 const uschar * name = NULL, * drname = NULL;
617 for (optionlist * o = optionlist_config; /* main-config options */
618 o < optionlist_config + optionlist_config_size; o++)
619 if (listptr == o->v.value)
623 for (const driver_instance * rd = (driver_instance *)routers;
624 rd; rd = rd->next) if (Ustrcmp(rd->name, router_name) == 0)
626 const router_instance * r = (router_instance *)rd;
627 const router_info * ri = (router_info *)rd->info;
629 /* Check for a listptr match first */
631 for (optionlist * o = optionlist_routers; /* generic options */
632 o < optionlist_routers + optionlist_routers_size; o++)
633 if ( (o->type & opt_mask) == opt_stringptr
634 && listptr == CS r + o->v.offset)
637 for (optionlist * o = ri->drinfo.options; /* private options */
638 o < ri->drinfo.options + *ri->drinfo.options_count; o++)
639 if ( (o->type & opt_mask) == opt_stringptr
640 && listptr == CS rd->options_block + o->v.offset)
643 /* Check for a list addr match, unless null */
647 for (optionlist * o = optionlist_routers; /* generic options */
648 o < optionlist_routers + optionlist_routers_size; o++)
649 if ( (o->type & opt_mask) == opt_stringptr
650 && list == * USS(CS r + o->v.offset))
652 return string_sprintf("DUP: %s %s vs. %s %s",
653 drname, name, rd->name, o->name);
655 { name = US o->name; drname = rd->name; }
657 for (optionlist * o = ri->drinfo.options; /* private options */
658 o < ri->drinfo.options + *ri->drinfo.options_count; o++)
659 if ( (o->type & opt_mask) == opt_stringptr
660 && list == * USS(CS rd->options_block + o->v.offset))
662 return string_sprintf("DUP: %s %s vs. %s %s",
663 drname, name, rd->name, o->name);
665 { name = US o->name; drname = rd->name; }
669 for (transport_instance * t = transports; t; t = t->drinst.next)
670 if (Ustrcmp(t->drinst.name, transport_name) == 0)
672 const transport_info * ti = t->drinst.info;
674 /* Check for a listptr match first */
676 for (optionlist * o = optionlist_transports; /* generic options */
677 o < optionlist_transports + optionlist_transports_size; o++)
678 if ( (o->type & opt_mask) == opt_stringptr
679 && listptr == CS t + o->v.offset)
682 for (optionlist * o = ti->drinfo.options; /* private options */
683 o < ti->drinfo.options + *ti->drinfo.options_count; o++)
684 if ( (o->type & opt_mask) == opt_stringptr
685 && listptr == CS t->drinst.options_block + o->v.offset)
688 /* Check for a list addr match, unless null */
692 for (optionlist * o = optionlist_transports; /* generic options */
693 o < optionlist_transports + optionlist_transports_size; o++)
694 if ( (o->type & opt_mask) == opt_stringptr
695 && list == * USS(CS t + o->v.offset))
697 return string_sprintf("DUP: %s %s vs. %s %s",
698 drname, name, t->drinst.name, o->name);
700 { name = US o->name; drname = t->drinst.name; }
702 for (optionlist * o = ti->drinfo.options; /* private options */
703 o < ti->drinfo.options + *ti->drinfo.options_count; o++)
704 if ( (o->type & opt_mask) == opt_stringptr
705 && list == * USS(CS t->drinst.options_block + o->v.offset))
707 return string_sprintf("DUP: %s %s vs. %s %s",
708 drname, name, t->drinst.name, o->name);
710 { name = US o->name; drname = t->drinst.name; }
713 return name ? name : US"";
719 /*************************************************
720 * Deal with an assignment to a macro *
721 *************************************************/
723 /* We have a new definition; append to the list.
726 name Name of the macro; will be copied
727 val Expansion result for the macro; will be copied
731 macro_create(const uschar * name, const uschar * val, BOOL command_line)
733 macro_item * m = store_get(sizeof(macro_item), GET_UNTAINTED);
735 READCONF_DEBUG fprintf(stderr, "%s: '%s' '%s'\n", __FUNCTION__, name, val);
737 m->command_line = command_line;
738 m->namelen = Ustrlen(name);
739 m->replen = Ustrlen(val);
740 m->name = string_copy(name);
741 m->replacement = string_copy(val);
753 /* This function is called when a line that starts with an upper case letter is
754 encountered. The argument "line" should contain a complete logical line, and
755 start with the first letter of the macro name. The macro name and the
756 replacement text are extracted and stored. Redefinition of existing,
757 non-command line, macros is permitted using '==' instead of '='.
760 s points to the start of the logical line
762 Returns: FALSE iff fatal error
766 macro_read_assignment(uschar *s)
768 uschar name[EXIM_DRIVERNAME_MAX];
773 while (isalnum(*s) || *s == '_')
775 if (namelen >= sizeof(name) - 1)
777 log_write(0, LOG_PANIC|LOG_CONFIG_IN,
778 "macro name too long (maximum is " SIZE_T_FMT " characters)", sizeof(name) - 1);
781 name[namelen++] = *s++;
785 Uskip_whitespace(&s);
788 log_write(0, LOG_PANIC|LOG_CONFIG_IN, "malformed macro definition");
797 Uskip_whitespace(&s);
799 /* If an existing macro of the same name was defined on the command line, we
800 just skip this definition. It's an error to attempt to redefine a macro without
801 redef set to TRUE, or to redefine a macro when it hasn't been defined earlier.
802 It is also an error to define a macro whose name begins with the name of a
803 previously defined macro. This is the requirement that make using a tree
804 for macros hard; we must check all macros for the substring. Perhaps a
805 sorted list, and a bsearch, would work?
806 Note: it is documented that the other way round works. */
808 for (m = macros; m; m = m->next)
810 if (Ustrcmp(m->name, name) == 0)
812 if (!m->command_line && !redef)
814 log_write(0, LOG_CONFIG|LOG_PANIC, "macro \"%s\" is already "
815 "defined (use \"==\" if you want to redefine it)", name);
821 if (m->namelen < namelen && Ustrstr(name, m->name) != NULL)
823 log_write(0, LOG_CONFIG|LOG_PANIC, "\"%s\" cannot be defined as "
824 "a macro because previously defined macro \"%s\" is a substring",
829 /* We cannot have this test, because it is documented that a substring
830 macro is permitted (there is even an example).
832 * if (m->namelen > namelen && Ustrstr(m->name, name) != NULL)
833 * log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "\"%s\" cannot be defined as "
834 * "a macro because it is a substring of previously defined macro \"%s\"",
839 /* Check for an overriding command-line definition. */
841 if (m && m->command_line) return TRUE;
843 /* Redefinition must refer to an existing macro. */
848 m->replen = Ustrlen(s);
849 m->replacement = string_copy(s);
853 log_write(0, LOG_CONFIG|LOG_PANIC, "can't redefine an undefined macro "
858 /* We have a new definition. */
860 (void) macro_create(name, s, FALSE);
868 /* Process line for macros. The line is in big_buffer starting at offset len.
869 Expand big_buffer if needed. Handle definitions of new macros, and
870 macro expansions, rewriting the line in the buffer.
873 len Offset in buffer of start of line
874 newlen Pointer to offset of end of line, updated on return
875 macro_found Pointer to return that a macro was expanded
877 Return: pointer to first nonblank char in line
881 macros_expand(int len, int * newlen, BOOL * macro_found)
883 uschar * ss = big_buffer + len;
886 /* Find the true start of the physical line - leading spaces are always
889 Uskip_whitespace(&ss);
891 /* Process the physical line for macros. If this is the start of the logical
892 line, skip over initial text at the start of the line if it starts with an
893 upper case character followed by a sequence of name characters and an equals
894 sign, because that is the definition of a new macro, and we don't do
895 replacement therein. */
898 if (len == 0 && isupper(*s))
900 while (isalnum(*s) || *s == '_') s++;
901 if (Uskip_whitespace(&s) != '=') s = ss; /* Not a macro definition */
904 /* Skip leading chars which cannot start a macro name, to avoid multiple
905 pointless rescans in Ustrstr calls. */
907 while (*s && !isupper(*s) && !(*s == '_' && isupper(s[1]))) s++;
909 /* For each defined macro, scan the line (from after XXX= if present),
910 replacing all occurrences of the macro. */
912 *macro_found = FALSE;
913 if (*s) for (macro_item * m = *s == '_' ? macros : macros_user; m; m = m->next)
918 while (*s && !isupper(*s) && !(*s == '_' && isupper(s[1]))) s++;
922 while ((p = Ustrstr(t, m->name)) != NULL)
926 READCONF_DEBUG fprintf(stderr, "%s: matched '%s' in '%.*s'\n", __FUNCTION__,
927 m->name, (int) Ustrlen(ss)-1, ss);
928 /* Expand the buffer if necessary */
930 while (*newlen - m->namelen + m->replen + 1 > big_buffer_size)
932 int newsize = big_buffer_size + BIG_BUFFER_SIZE;
933 uschar *newbuffer = store_malloc(newsize);
934 memcpy(newbuffer, big_buffer, *newlen + 1);
935 p = newbuffer + (p - big_buffer);
936 s = newbuffer + (s - big_buffer);
937 ss = newbuffer + (ss - big_buffer);
938 t = newbuffer + (t - big_buffer);
939 big_buffer_size = newsize;
940 store_free(big_buffer);
941 big_buffer = newbuffer;
944 /* Shuffle the remaining characters up or down in the buffer before
945 copying in the replacement text. Don't rescan the replacement for this
949 if ((moveby = m->replen - m->namelen) != 0)
951 memmove(p + m->replen, pp, (big_buffer + *newlen) - pp + 1);
954 Ustrncpy(p, m->replacement, m->replen);
956 while (*t && !isupper(*t) && !(*t == '_' && isupper(t[1]))) t++;
961 /* An empty macro replacement at the start of a line could mean that ss no
962 longer points to the first non-blank character. */
964 Uskip_whitespace(&ss);
968 /*************************************************
969 * Read configuration line *
970 *************************************************/
972 /* A logical line of text is read from the configuration file into the big
973 buffer, taking account of macros, .includes, and continuations. The size of
974 big_buffer is increased if necessary. The count of configuration lines is
975 maintained. Physical input lines starting with # (ignoring leading white space,
976 and after macro replacement) and empty logical lines are always ignored.
977 Leading and trailing spaces are removed.
979 If we hit a line of the form "begin xxxx", the xxxx is placed in the
980 next_section vector, and the function returns NULL, indicating the end of a
981 configuration section. On end-of-file, NULL is returned with next_section
986 Returns: a pointer to the first non-blank in the line,
987 or NULL if eof or end of section is reached
991 get_config_line(void)
993 int startoffset = 0; /* To first non-blank char in logical line */
994 int len = 0; /* Of logical line so far */
999 /* Loop for handling continuation lines, skipping comments, and dealing with
1004 if (Ufgets(big_buffer+len, big_buffer_size-len, config_file) == NULL)
1006 if (config_file_stack != NULL) /* EOF inside .include */
1008 (void)fclose(config_file);
1009 config_file = config_file_stack->file;
1010 config_filename = config_file_stack->filename;
1011 config_directory = config_file_stack->directory;
1012 config_lineno = config_file_stack->lineno;
1013 config_file_stack = config_file_stack->next;
1015 save_config_position(config_filename, config_lineno);
1019 /* EOF at top level */
1021 if (cstate_stack_ptr >= 0)
1022 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1023 "Unexpected end of configuration file: .endif missing");
1025 if (len != 0) break; /* EOF after continuation */
1026 next_section[0] = 0; /* EOF at start of logical line */
1031 newlen = len + Ustrlen(big_buffer + len);
1033 if (config_lines && config_lineno == 1)
1034 save_config_position(config_filename, config_lineno);
1036 /* Handle pathologically long physical lines - yes, it did happen - by
1037 extending big_buffer at this point. The code also copes with very long
1040 while (newlen == big_buffer_size - 1 && big_buffer[newlen - 1] != '\n')
1043 big_buffer_size += BIG_BUFFER_SIZE;
1044 newbuffer = store_malloc(big_buffer_size);
1046 /* This use of strcpy is OK because we know that the string in the old
1047 buffer is shorter than the new buffer. */
1049 Ustrcpy(newbuffer, big_buffer);
1050 store_free(big_buffer);
1051 big_buffer = newbuffer;
1052 if (Ufgets(big_buffer+newlen, big_buffer_size-newlen, config_file) == NULL)
1054 newlen += Ustrlen(big_buffer + newlen);
1057 ss = macros_expand(len, &newlen, ¯o_found);
1059 /* Check for comment lines - these are physical lines. */
1061 if (*ss == '#') continue;
1063 /* Handle conditionals, which are also applied to physical lines. Conditions
1064 are of the form ".ifdef ANYTEXT" and are treated as true if any macro
1065 expansion occurred on the rest of the line. A preliminary test for the leading
1066 '.' saves effort on most lines. */
1072 /* Search the list of conditional directives */
1074 for (i = 0; i < cond_list_size; i++)
1077 cond_item *c = cond_list+i;
1078 if (Ustrncmp(ss+1, c->name, c->namelen) != 0) continue;
1080 /* The following character must be white space or end of string */
1082 n = ss[1 + c->namelen];
1083 if (n != ' ' && n != 't' && n != '\n' && n != 0) break;
1085 /* .ifdef and .ifndef push the current state onto the stack, then set
1086 a new one from the table. Stack overflow is an error */
1090 if (cstate_stack_ptr >= CSTATE_STACK_SIZE - 1)
1091 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1092 ".%s nested too deeply", c->name);
1093 cstate_stack[++cstate_stack_ptr] = cstate;
1094 cstate = next_cstate[cstate][macro_found? c->action1 : c->action2];
1097 /* For any of the others, stack underflow is an error. The next state
1098 comes either from the stack (.endif) or from the table. */
1102 if (cstate_stack_ptr < 0)
1103 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1104 ".%s without matching .ifdef", c->name);
1105 cstate = (c->pushpop < 0)? cstate_stack[cstate_stack_ptr--] :
1106 next_cstate[cstate][macro_found? c->action1 : c->action2];
1109 /* Having dealt with a directive, break the loop */
1114 /* If we have handled a conditional directive, continue with the next
1115 physical line. Otherwise, fall through. */
1117 if (i < cond_list_size) continue;
1120 /* If the conditional state is not 0 (actively using these lines), ignore
1123 if (cstate != 0) continue; /* Conditional skip */
1125 /* Handle .include lines - these are also physical lines. */
1127 if (Ustrncmp(ss, ".include", 8) == 0 &&
1129 (Ustrncmp(ss+8, "_if_exists", 10) == 0 && isspace(ss[18]))))
1132 int include_if_exists = isspace(ss[8]) ? 0 : 10;
1133 config_file_item *save;
1134 struct stat statbuf;
1136 ss += 9 + include_if_exists;
1137 Uskip_whitespace(&ss);
1138 t = ss + Ustrlen(ss);
1139 while (t > ss && isspace(t[-1])) t--;
1140 if (*ss == '\"' && t[-1] == '\"')
1147 /* We allow relative file names. For security reasons currently
1148 relative names not allowed with .include_if_exists. For .include_if_exists
1149 we need to check the permissions/ownership of the containing folder */
1151 if (include_if_exists) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, ".include specifies a non-"
1152 "absolute path \"%s\"", ss);
1155 gstring * g = string_append(NULL, 3, config_directory, "/", ss);
1156 ss = string_from_gstring(g);
1159 if (include_if_exists != 0 && (Ustat(ss, &statbuf) != 0)) continue;
1162 save_config_position(config_filename, config_lineno);
1163 save = store_get(sizeof(config_file_item), GET_UNTAINTED);
1164 save->next = config_file_stack;
1165 config_file_stack = save;
1166 save->file = config_file;
1167 save->filename = config_filename;
1168 save->directory = config_directory;
1169 save->lineno = config_lineno;
1171 if (!(config_file = Ufopen(ss, "rb")))
1172 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to open included "
1173 "configuration file %s", ss);
1175 config_filename = string_copy(ss);
1176 config_directory = string_copyn(ss, CUstrrchr(ss, '/') - ss);
1181 /* If this is the start of the logical line, remember where the non-blank
1182 data starts. Otherwise shuffle down continuation lines to remove leading
1186 startoffset = ss - big_buffer;
1189 s = big_buffer + len;
1192 memmove(s, ss, (newlen - len) - (ss - s) + 1);
1197 /* Accept the new addition to the line. Remove trailing white space. */
1200 while (len > 0 && isspace(big_buffer[len-1])) len--;
1201 big_buffer[len] = 0;
1203 /* We are done if the line does not end in backslash and contains some data.
1204 Empty logical lines are ignored. For continuations, remove the backslash and
1205 go round the loop to read the continuation line. */
1209 if (big_buffer[len-1] != '\\') break; /* End of logical line */
1210 big_buffer[--len] = 0; /* Remove backslash */
1212 } /* Loop for reading multiple physical lines */
1214 /* We now have a logical line. Test for the end of a configuration section (or,
1215 more accurately, for the start of the next section). Place the name of the next
1216 section in next_section, and return NULL. If the name given is longer than
1217 next_section, truncate it. It will be unrecognized later, because all the known
1218 section names do fit. Leave space for pluralizing. */
1220 s = big_buffer + startoffset; /* First non-space character */
1223 save_config_line(s);
1225 if (strncmpic(s, US"begin ", 6) == 0)
1228 Uskip_whitespace(&s);
1229 if (big_buffer + len - s > sizeof(next_section) - 2)
1230 s[sizeof(next_section) - 2] = 0;
1231 Ustrcpy(next_section, s);
1235 #ifdef LOOKUP_MODULE_DIR
1236 /* Check for any required module load operations */
1238 //mod_load_check(s);
1241 /* Return the first non-blank character. */
1248 /*************************************************
1250 *************************************************/
1252 /* The yield is the pointer to the next uschar. Names longer than the
1253 output space are silently truncated. This function is also used from acl.c when
1257 name where to put the name
1261 Returns: new input pointer
1265 readconf_readname(uschar * name, int len, const uschar * s)
1268 BOOL broken = FALSE;
1270 if (isalpha(Uskip_whitespace(&s)))
1271 while (isalnum(*s) || *s == '_')
1273 if (p < len-1) name[p++] = *s;
1283 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1284 "exim item name too long (>%d), unable to use \"%s\" (truncated)",
1287 Uskip_whitespace(&s);
1294 /*************************************************
1295 * Read a time value *
1296 *************************************************/
1298 /* This function is also called from outside, to read argument
1299 time values. The format of a time value is:
1301 [<n>w][<n>d][<n>h][<n>m][<n>s]
1303 as long as at least one is present. If a format error is encountered,
1304 return a negative value. The value must be terminated by the given
1309 terminator required terminating character
1310 return_msec if TRUE, allow fractional seconds and return milliseconds
1312 Returns: the time value, or -1 on syntax error
1313 value is seconds if return_msec is FALSE
1314 value is milliseconds if return_msec is TRUE
1318 readconf_readtime(const uschar *s, int terminator, BOOL return_msec)
1326 if (!isdigit(*s)) return -1;
1327 (void)sscanf(CCS s, "%d%n", &value, &count);
1332 case 'w': value *= 7;
1333 case 'd': value *= 24;
1334 case 'h': value *= 60;
1335 case 'm': value *= 60;
1340 if (!return_msec) return -1;
1341 (void)sscanf(CCS s, "%lf%n", &fraction, &count);
1343 if (*s++ != 's') return -1;
1344 yield += (int)(fraction * 1000.0);
1350 if (return_msec) value *= 1000;
1352 if (*s == terminator) return yield;
1354 /* Control never reaches here. */
1359 /*************************************************
1360 * Read a fixed point value *
1361 *************************************************/
1363 /* The value is returned *1000
1367 terminator required terminator
1369 Returns: the value, or -1 on error
1373 readconf_readfixed(const uschar *s, int terminator)
1377 if (!isdigit(*s)) return -1;
1378 (void)sscanf(CS s, "%d%n", &value, &count);
1380 yield = value * 1000;
1384 while (isdigit((*(++s))))
1386 yield += (*s - '0') * m;
1391 return (*s == terminator)? yield : (-1);
1396 /*************************************************
1397 * Find option in list *
1398 *************************************************/
1400 /* The lists are always in order, so binary chop can be used.
1403 name the option name to search for
1404 ol the first entry in the option list
1405 last one more than the offset of the last entry in the option list
1407 Returns: pointer to an option entry, or NULL if not found
1411 find_option(const uschar *name, optionlist *ol, int last)
1414 while (last > first)
1416 int middle = (first + last)/2;
1417 int c = Ustrcmp(name, ol[middle].name);
1419 if (c == 0) return ol + middle;
1420 else if (c > 0) first = middle + 1;
1428 /*************************************************
1429 * Find a set flag in option list *
1430 *************************************************/
1432 /* Because some versions of Unix make no restrictions on the values of uids and
1433 gids (even negative ones), we cannot represent "unset" by a special value.
1434 There is therefore a separate boolean variable for each one indicating whether
1435 a value is set or not. This function returns a pointer to the boolean, given
1436 the original option name. It is a major disaster if the flag cannot be found.
1439 name the name of the uid or gid option
1440 oltop points to the start of the relevant option list
1441 last one more than the offset of the last item in the option list
1442 data_block NULL when reading main options => data values in the option
1443 list are absolute addresses; otherwise they are byte offsets
1444 in data_block (used for driver options)
1446 Returns: a pointer to the boolean flag.
1450 get_set_flag(const uschar *name, optionlist *oltop, int last, void *data_block)
1453 uschar name2[EXIM_DRIVERNAME_MAX];
1454 sprintf(CS name2, "*set_%.50s", name);
1455 if (!(ol = find_option(name2, oltop, last)))
1456 log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1457 "Exim internal error: missing set flag for %s", name);
1459 ? (BOOL *)(US data_block + ol->v.offset) : (BOOL *)ol->v.value;
1465 /*************************************************
1466 * Output extra characters message and die *
1467 *************************************************/
1469 /* Called when an option line has junk on the end. Sometimes this is because
1470 the sysadmin thinks comments are permitted.
1473 s points to the extra characters
1474 t1..t3 strings to insert in the log message
1476 Returns: doesn't return; dies
1480 extra_chars_error(const uschar *s, const uschar *t1, const uschar *t2, const uschar *t3)
1482 uschar *comment = US"";
1483 if (*s == '#') comment = US" (# is comment only at line start)";
1484 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1485 "extra characters follow %s%s%s%s", t1, t2, t3, comment);
1490 /*************************************************
1491 * Read rewrite information *
1492 *************************************************/
1494 /* Each line of rewrite information contains:
1496 . A complete address in the form user@domain, possibly with
1497 leading * for each part; or alternatively, a regex.
1499 . A replacement string (which will be expanded).
1501 . An optional sequence of one-letter flags, indicating which
1502 headers etc. to apply this rule to.
1504 All this is decoded and placed into a control block. The OR of the flags is
1505 maintained in a common word.
1508 p points to the string that makes up the rule
1509 existflags points to the overall flag word
1510 isglobal TRUE if reading global rewrite rules
1512 Returns: the control block for the parsed rule.
1515 static rewrite_rule *
1516 readconf_one_rewrite(const uschar *p, int *existflags, BOOL isglobal)
1518 rewrite_rule * next = store_get(sizeof(rewrite_rule), GET_UNTAINTED);
1521 next->key = string_dequote(&p);
1523 Uskip_whitespace(&p);
1525 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1526 "missing rewrite replacement string");
1529 next->replacement = string_dequote(&p);
1531 while (*p) switch (*p++)
1533 case ' ': case '\t': break;
1535 case 'q': next->flags |= rewrite_quit; break;
1536 case 'w': next->flags |= rewrite_whole; break;
1538 case 'h': next->flags |= rewrite_all_headers; break;
1539 case 's': next->flags |= rewrite_sender; break;
1540 case 'f': next->flags |= rewrite_from; break;
1541 case 't': next->flags |= rewrite_to; break;
1542 case 'c': next->flags |= rewrite_cc; break;
1543 case 'b': next->flags |= rewrite_bcc; break;
1544 case 'r': next->flags |= rewrite_replyto; break;
1546 case 'E': next->flags |= rewrite_all_envelope; break;
1547 case 'F': next->flags |= rewrite_envfrom; break;
1548 case 'T': next->flags |= rewrite_envto; break;
1550 case 'Q': next->flags |= rewrite_qualify; break;
1551 case 'R': next->flags |= rewrite_repeat; break;
1554 next->flags |= rewrite_smtp;
1555 if (next->key[0] != '^' && Ustrncmp(next->key, "\\N^", 3) != 0)
1556 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1557 "rewrite rule has the S flag but is not a regular expression");
1561 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1562 "unknown rewrite flag character '%c' "
1563 "(could be missing quotes round replacement item)", p[-1]);
1567 /* If no action flags are set, set all the "normal" rewrites. */
1569 if ((next->flags & (rewrite_all | rewrite_smtp)) == 0)
1570 next->flags |= isglobal? rewrite_all : rewrite_all_headers;
1572 /* Remember which exist, for optimization, and return the rule */
1574 *existflags |= next->flags;
1581 /*************************************************
1582 * Read global rewrite information *
1583 *************************************************/
1585 /* Each line is a single rewrite rule; it is parsed into a control block
1586 by readconf_one_rewrite(), and its flags are ORed into the global flag
1587 word rewrite_existflags. */
1590 readconf_rewrites(void)
1592 rewrite_rule **chain = &global_rewrite_rules;
1595 while ((p = get_config_line()) != NULL)
1597 rewrite_rule *next = readconf_one_rewrite(p, &rewrite_existflags, TRUE);
1599 chain = &(next->next);
1605 /*************************************************
1607 *************************************************/
1609 /* Strings are read into the normal store pool. As long we aren't too
1610 near the end of the current block, the string will just use what is necessary
1611 on the top of the stacking pool, because string_cat() uses the extension
1615 s the rest of the input line
1616 name the option name (for errors)
1618 Returns: pointer to the string
1622 read_string(const uschar *s, const uschar *name)
1627 if (*s != '\"') return string_copy(s);
1630 yield = string_dequote(&s);
1632 if (s == ss+1 || s[-1] != '\"')
1633 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1634 "missing quote at end of string value for %s", name);
1636 if (*s != 0) extra_chars_error(s, US"string value for ", name, US"");
1642 /*************************************************
1643 * Custom-handler options *
1644 *************************************************/
1646 fn_smtp_receive_timeout(const uschar * name, const uschar * str, unsigned flags)
1648 if (flags & opt_fn_print)
1650 if (flags & opt_fn_print_label) printf("%s = ", name);
1651 printf("%s\n", smtp_receive_timeout_s
1652 ? string_printing2(smtp_receive_timeout_s, SP_TAB)
1653 : readconf_printtime(smtp_receive_timeout));
1655 else if (*str == '$')
1656 smtp_receive_timeout_s = string_copy(str);
1659 /* "smtp_receive_timeout", opt_time, &smtp_receive_timeout */
1660 smtp_receive_timeout = readconf_readtime(str, 0, FALSE);
1661 if (smtp_receive_timeout < 0)
1662 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
1667 /*************************************************
1668 * Handle option line *
1669 *************************************************/
1671 /* This function is called from several places to process a line containing the
1672 setting of an option. The first argument is the line to be decoded; it has been
1673 checked not to be empty and not to start with '#'. Trailing newlines and white
1674 space have been removed. The second argument is a pointer to the list of
1675 variable names that are to be recognized, together with their types and
1676 locations, and the third argument gives the number of entries in the list.
1678 The fourth argument is a pointer to a data block. If it is NULL, then the data
1679 values in the options list are absolute addresses. Otherwise, they are byte
1680 offsets in the data block.
1682 String option data may continue onto several lines; this function reads further
1683 data from config_file if necessary.
1685 The yield of this function is normally zero. If a string continues onto
1686 multiple lines, then the data value is permitted to be followed by a comma
1687 or a semicolon (for use in drivers) and the yield is that character.
1690 buffer contains the configuration line to be handled
1691 oltop points to the start of the relevant option list
1692 last one more than the offset of the last item in the option list
1693 data_block NULL when reading main options => data values in the option
1694 list are absolute addresses; otherwise they are byte offsets
1695 in data_block when they have opt_public set; otherwise
1696 they are byte offsets in data_block->options_block.
1697 unknown_txt format string to use in panic message for unknown option;
1698 must contain %s for option name
1699 if given as NULL, don't panic on unknown option
1701 Returns: TRUE if an option was read successfully,
1702 FALSE false for an unknown option if unknown_txt == NULL,
1703 otherwise panic and die on an unknown option
1707 readconf_handle_option(uschar *buffer, optionlist *oltop, int last,
1708 void *data_block, uschar *unknown_txt)
1712 int count, type, value;
1716 BOOL boolvalue = TRUE;
1717 BOOL freesptr = TRUE;
1718 optionlist *ol, *ol2;
1722 uschar *inttype = US"";
1725 uschar **str_target;
1726 uschar name[EXIM_DRIVERNAME_MAX];
1727 uschar name2[EXIM_DRIVERNAME_MAX];
1734 /* There may be leading spaces; thereafter, we expect an option name starting
1737 if (!isalpha( Uskip_whitespace(&s) ))
1738 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option setting expected: %s", s);
1740 /* Read the name of the option, and skip any subsequent white space. If
1741 it turns out that what we read was "hide", set the flag indicating that
1742 this is a secure option, and loop to read the next word. */
1744 for (int n = 0; n < 2; n++)
1746 while (isalnum(*s) || *s == '_')
1748 if (ptr < sizeof(name)-1) name[ptr++] = *s;
1752 Uskip_whitespace(&s);
1753 if (Ustrcmp(name, "hide") != 0) break;
1754 issecure = opt_secure;
1758 /* Deal with "no_" or "not_" here for booleans */
1760 if (Ustrncmp(name, "no_", 3) == 0)
1766 if (Ustrncmp(name, "not_", 4) == 0)
1772 /* Search the list for the given name. A non-existent name, or an option that
1773 is set twice, is a disaster. */
1775 if (!(ol = find_option(name + offset, oltop, last)))
1777 if (!unknown_txt) return FALSE;
1778 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, CS unknown_txt, name);
1781 if ((ol->type & opt_set) && !(ol->type & (opt_rep_con | opt_rep_str)))
1782 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1783 "\"%s\" option set for the second time", name);
1785 ol->type |= opt_set | issecure;
1786 type = ol->type & opt_mask;
1788 /* Types with data values must be followed by '='; the "no[t]_" prefix
1789 applies only to boolean values. */
1791 if (type < opt_bool || type > opt_bool_last)
1794 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1795 "negation prefix applied to a non-boolean option");
1797 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1798 "unexpected end of line (data missing) after %s", name);
1800 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing \"=\" after %s", name);
1803 /* If a boolean wasn't preceded by "no[t]_" it can be followed by = and
1804 true/false/yes/no, or, in the case of opt_expand_bool, a general string that
1805 ultimately expands to one of those values. */
1807 else if (*s && (offset != 0 || *s != '='))
1808 extra_chars_error(s, US"boolean option ", name, US"");
1810 /* Skip white space after = */
1812 if (*s == '=') while (isspace(*++s));
1814 /* If there is a data block and the opt_public flag is not set, change
1815 the data block pointer to the private options block. */
1817 if (data_block && !(ol->type & opt_public))
1818 data_block = (void *)(((driver_instance *)data_block)->options_block);
1820 /* Now get the data according to the type. */
1824 /* If a string value is not enclosed in quotes, it consists of
1825 the rest of the current line, verbatim. Otherwise, string escapes
1828 A transport is specified as a string, which is then looked up in the
1829 list of transports. A search type is specified as one of a number of
1832 A set or rewrite rules for a driver is specified as a string, which is
1833 then parsed into a suitable chain of control blocks.
1835 Uids and gids are specified as strings which are then looked up in the
1836 passwd file. Lists of uids and gids are similarly specified as colon-
1837 separated strings. */
1842 case opt_expand_uid:
1843 case opt_expand_gid:
1848 reset_point = store_mark();
1849 sptr = read_string(s, name);
1851 /* Having read a string, we now have several different ways of using it,
1852 depending on the data type, so do another switch. If keeping the actual
1853 string is not required (because it is interpreted), freesptr is set TRUE,
1854 and at the end we reset the pool. */
1858 /* If this was a string, set the variable to point to the new string,
1859 and set the flag so its store isn't reclaimed. If it was a list of rewrite
1860 rules, we still keep the string (for printing), and parse the rules into a
1861 control block and flags word. */
1864 str_target = data_block ? USS (US data_block + ol->v.offset)
1866 if (ol->type & opt_rep_con)
1868 uschar * saved_condition;
1869 /* We already have a condition, we're conducting a crude hack to let
1870 multiple condition rules be chained together, despite storing them in
1872 *str_target = string_copy_perm( (saved_condition = *str_target)
1873 ? string_sprintf("${if and{{bool_lax{%s}}{bool_lax{%s}}}}",
1874 saved_condition, sptr)
1877 /* TODO(pdp): there is a memory leak here and just below
1878 when we set 3 or more conditions; I still don't
1879 understand the store mechanism enough to know
1880 what's the safe way to free content from an earlier store.
1881 AFAICT, stores stack, so freeing an early stored item also stores
1882 all data alloc'd after it. If we knew conditions were adjacent,
1883 we could survive that, but we don't. So I *think* we need to take
1884 another bit from opt_type to indicate "malloced"; this seems like
1885 quite a hack, especially for this one case. It also means that
1886 we can't ever reclaim the store from the *first* condition.
1888 Because we only do this once, near process start-up, I'm prepared to
1889 let this slide for the time being, even though it rankles. */
1891 else if (ol->type & opt_rep_str)
1894 Ustrncmp(name, "headers_add", 11) == 0 ? '\n'
1895 : Ustrncmp(name, "set", 3) == 0 ? ';'
1897 int sep_i = -(int)sep_o;
1898 const uschar * list = sptr;
1900 gstring * list_o = NULL;
1904 list_o = string_get(Ustrlen(*str_target) + Ustrlen(sptr));
1905 list_o = string_cat(list_o, *str_target);
1908 while ((s = string_nextinlist(&list, &sep_i, NULL, 0)))
1909 list_o = string_append_listele(list_o, sep_o, s);
1912 *str_target = string_copy_perm(string_from_gstring(list_o), FALSE);
1923 *USS (US data_block + ol->v.offset) = sptr;
1925 *USS ol->v.value = sptr;
1927 if (type == opt_rewrite)
1932 rewrite_rule **chain;
1935 sprintf(CS name2, "*%.50s_rules", name);
1936 ol2 = find_option(name2, oltop, last);
1937 sprintf(CS name2, "*%.50s_flags", name);
1938 ol3 = find_option(name2, oltop, last);
1941 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1942 "rewrite rules not available for driver");
1946 chain = (rewrite_rule **)(US data_block + ol2->v.offset);
1947 flagptr = (int *)(US data_block + ol3->v.offset);
1951 chain = (rewrite_rule **)ol2->v.value;
1952 flagptr = (int *)ol3->v.value;
1955 /* This will trap if sptr is tainted. Not sure if that can happen */
1956 while ((p = string_nextinlist(CUSS &sptr, &sep, big_buffer, BIG_BUFFER_SIZE)))
1958 rewrite_rule *next = readconf_one_rewrite(p, flagptr, FALSE);
1960 chain = &(next->next);
1963 if ((*flagptr & (rewrite_all_envelope | rewrite_smtp)) != 0)
1964 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "rewrite rule specifies a "
1965 "non-header rewrite - not allowed at transport time -");
1969 /* If it was an expanded uid, see if there is any expansion to be
1970 done by checking for the presence of a $ character. If there is, save it
1971 in the corresponding *expand_user option field. Otherwise, fall through
1972 to treat it as a fixed uid. Ensure mutual exclusivity of the two kinds
1975 case opt_expand_uid:
1976 sprintf(CS name2, "*expand_%.50s", name);
1977 if ((ol2 = find_option(name2, oltop, last)))
1979 uschar *ss = (Ustrchr(sptr, '$') != NULL) ? sptr : NULL;
1982 *(USS(US data_block + ol2->v.offset)) = ss;
1984 *(USS ol2->v.value) = ss;
1988 *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1994 /* Look up a fixed uid, and also make use of the corresponding gid
1995 if a passwd entry is returned and the gid has not been set. */
1998 if (!route_finduser(sptr, &pw, &uid))
1999 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found", sptr);
2001 *(uid_t *)(US data_block + ol->v.offset) = uid;
2003 *(uid_t *)ol->v.value = uid;
2005 /* Set the flag indicating a fixed value is set */
2007 *(get_set_flag(name, oltop, last, data_block)) = TRUE;
2009 /* Handle matching gid if we have a passwd entry: done by finding the
2010 same name with terminating "user" changed to "group"; if not found,
2011 ignore. Also ignore if the value is already set. */
2013 if (pw == NULL) break;
2014 Ustrcpy(name+Ustrlen(name)-4, US"group");
2015 ol2 = find_option(name, oltop, last);
2016 if (ol2 && ((ol2->type & opt_mask) == opt_gid ||
2017 (ol2->type & opt_mask) == opt_expand_gid))
2019 BOOL *set_flag = get_set_flag(name, oltop, last, data_block);
2023 *((gid_t *)(US data_block + ol2->v.offset)) = pw->pw_gid;
2025 *((gid_t *)ol2->v.value) = pw->pw_gid;
2031 /* If it was an expanded gid, see if there is any expansion to be
2032 done by checking for the presence of a $ character. If there is, save it
2033 in the corresponding *expand_user option field. Otherwise, fall through
2034 to treat it as a fixed gid. Ensure mutual exclusivity of the two kinds
2037 case opt_expand_gid:
2038 sprintf(CS name2, "*expand_%.50s", name);
2039 if ((ol2 = find_option(name2, oltop, last)))
2041 uschar *ss = (Ustrchr(sptr, '$') != NULL) ? sptr : NULL;
2044 *(USS(US data_block + ol2->v.offset)) = ss;
2046 *(USS ol2->v.value) = ss;
2050 *(get_set_flag(name, oltop, last, data_block)) = FALSE;
2056 /* Handle freestanding gid */
2059 if (!route_findgroup(sptr, &gid))
2060 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found", sptr);
2062 *((gid_t *)(US data_block + ol->v.offset)) = gid;
2064 *((gid_t *)ol->v.value) = gid;
2065 *(get_set_flag(name, oltop, last, data_block)) = TRUE;
2068 /* If it was a uid list, look up each individual entry, and build
2069 a vector of uids, with a count in the first element. Put the vector
2070 in malloc store so we can free the string. (We are reading into
2071 permanent store already.) */
2079 const uschar *op = expand_string (sptr);
2082 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
2083 name, expand_string_message);
2086 if (*p != 0) count++;
2087 while (*p != 0) if (*p++ == ':' && *p != 0) count++;
2088 list = store_malloc(count*sizeof(uid_t));
2089 list[ptr++] = (uid_t)(count - 1);
2092 *((uid_t **)(US data_block + ol->v.offset)) = list;
2094 *((uid_t **)ol->v.value) = list;
2100 /* If p is tainted we trap. Not sure that can happen */
2101 (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
2102 if (!route_finduser(big_buffer, NULL, &uid))
2103 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found",
2110 /* If it was a gid list, look up each individual entry, and build
2111 a vector of gids, with a count in the first element. Put the vector
2112 in malloc store so we can free the string. (We are reading into permanent
2121 const uschar *op = expand_string (sptr);
2124 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
2125 name, expand_string_message);
2128 if (*p != 0) count++;
2129 while (*p != 0) if (*p++ == ':' && *p != 0) count++;
2130 list = store_malloc(count*sizeof(gid_t));
2131 list[ptr++] = (gid_t)(count - 1);
2134 *((gid_t **)(US data_block + ol->v.offset)) = list;
2136 *((gid_t **)ol->v.value) = list;
2142 /* If p is tainted we trap. Not sure that can happen */
2143 (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
2144 if (!route_findgroup(big_buffer, &gid))
2145 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found",
2153 /* Release store if the value of the string doesn't need to be kept. */
2155 if (freesptr) reset_point = store_reset(reset_point);
2158 /* Expanded boolean: if no characters follow, or if there are no dollar
2159 characters, this is a fixed-valued boolean, and we fall through. Otherwise,
2160 save the string for later expansion in the alternate place. */
2162 case opt_expand_bool:
2163 if (*s && Ustrchr(s, '$') != 0)
2165 sprintf(CS name2, "*expand_%.50s", name);
2166 if ((ol2 = find_option(name2, oltop, last)))
2168 reset_point = store_mark();
2169 sptr = read_string(s, name);
2171 *(USS(US data_block + ol2->v.offset)) = sptr;
2173 *(USS ol2->v.value) = sptr;
2180 /* Boolean: if no characters follow, the value is boolvalue. Otherwise
2181 look for yes/not/true/false. Some booleans are stored in a single bit in
2182 a single int. There's a special fudge for verify settings; without a suffix
2183 they set both xx_sender and xx_recipient. The table points to the sender
2184 value; search subsequently for the recipient. There's another special case:
2185 opt_bool_set also notes when a boolean has been set. */
2189 case opt_bool_verify:
2193 s = readconf_readname(name2, EXIM_DRIVERNAME_MAX, s);
2194 if (strcmpic(name2, US"true") == 0 || strcmpic(name2, US"yes") == 0)
2196 else if (strcmpic(name2, US"false") == 0 || strcmpic(name2, US"no") == 0)
2198 else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2199 "\"%s\" is not a valid value for the \"%s\" option", name2, name);
2200 if (*s != 0) extra_chars_error(s, string_sprintf("\"%s\" ", name2),
2201 US"for boolean option ", name);
2204 /* Handle single-bit type. */
2206 if (type == opt_bit)
2208 int bit = 1 << ((ol->type >> 16) & 31);
2209 int * ptr = data_block
2210 ? (int *)(US data_block + ol->v.offset)
2211 : (int *)ol->v.value;
2212 if (boolvalue) *ptr |= bit; else *ptr &= ~bit;
2216 /* Handle full BOOL types */
2219 *((BOOL *)(US data_block + ol->v.offset)) = boolvalue;
2221 *((BOOL *)ol->v.value) = boolvalue;
2225 if (type == opt_bool_verify)
2227 sprintf(CS name2, "%.50s_recipient", name + offset);
2228 if ((ol2 = find_option(name2, oltop, last)))
2230 *((BOOL *)(US data_block + ol2->v.offset)) = boolvalue;
2232 *((BOOL *)ol2->v.value) = boolvalue;
2235 /* Note that opt_bool_set type is set, if there is somewhere to do so */
2237 else if (type == opt_bool_set)
2239 sprintf(CS name2, "*set_%.50s", name + offset);
2240 if ((ol2 = find_option(name2, oltop, last)))
2242 *((BOOL *)(US data_block + ol2->v.offset)) = TRUE;
2244 *((BOOL *)ol2->v.value) = TRUE;
2252 inttype = US"octal ";
2254 /* Integer: a simple(ish) case; allow octal and hex formats, and
2255 suffixes K, M, G, and T. The different types affect output, not input. */
2264 lvalue = strtol(CS s, CSS &endptr, intbase);
2267 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
2270 if (errno != ERANGE && *endptr)
2272 uschar * mp = US"TtGgMmKk\0"; /* YyZzEePpTtGgMmKk */
2274 if ((mp = Ustrchr(mp, *endptr)))
2279 if (lvalue > INT_MAX/1024 || lvalue < INT_MIN/1024)
2290 if (errno == ERANGE || lvalue > INT_MAX || lvalue < INT_MIN)
2291 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2292 "absolute value of integer \"%s\" is too large (overflow)", s);
2294 if (Uskip_whitespace(&endptr))
2295 extra_chars_error(endptr, inttype, US"integer value for ", name);
2297 value = (int)lvalue;
2301 *(int *)(US data_block + ol->v.offset) = value;
2303 *(int *)ol->v.value = value;
2306 /* Integer held in K: again, allow formats and suffixes as above. */
2312 int_eximarith_t lvalue = strtol(CS s, CSS &endptr, intbase);
2315 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
2318 if (errno != ERANGE && *endptr)
2320 uschar * mp = US"ZzEePpTtGgMmKk\0"; /* YyZzEePpTtGgMmKk */
2322 if ((mp = Ustrchr(mp, *endptr)))
2327 if (lvalue > EXIM_ARITH_MAX/1024 || lvalue < EXIM_ARITH_MIN/1024)
2336 lvalue = (lvalue + 512)/1024;
2339 if (errno == ERANGE) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2340 "absolute value of integer \"%s\" is too large (overflow)", s);
2342 if (Uskip_whitespace(&endptr))
2343 extra_chars_error(endptr, inttype, US"integer value for ", name);
2346 *(int_eximarith_t *)(US data_block + ol->v.offset) = lvalue;
2348 *(int_eximarith_t *)ol->v.value = lvalue;
2352 /* Fixed-point number: held to 3 decimal places. */
2355 if (sscanf(CS s, "%d%n", &value, &count) != 1)
2356 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2357 "fixed-point number expected for %s", name);
2359 if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2360 "integer \"%s\" is too large (overflow)", s);
2364 if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2365 "integer \"%s\" is too large (overflow)", s);
2367 /* We get a coverity error here for using count, as it derived
2368 from the tainted buffer pointed to by s, as parsed by sscanf().
2369 By the definition of sscanf we must be accessing between start
2370 and end of s (assuming it is nul-terminated...) so ignore the error. */
2371 /* coverity[tainted_data] */
2372 if (s[count] == '.')
2375 while (isdigit(s[++count]))
2377 value += (s[count] - '0') * d;
2382 while (isspace(s[count])) count++;
2385 extra_chars_error(s+count, US"fixed-point value for ", name, US"");
2388 *((int *)(US data_block + ol->v.offset)) = value;
2390 *((int *)ol->v.value) = value;
2393 /* There's a special routine to read time values. */
2396 value = readconf_readtime(s, 0, FALSE);
2398 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2401 *((int *)(US data_block + ol->v.offset)) = value;
2403 *((int *)ol->v.value) = value;
2406 /* A time list is a list of colon-separated times, with the first
2407 element holding the size of the list and the second the number of
2413 int * list = data_block
2414 ? (int *)(US data_block + ol->v.offset)
2415 : (int *)ol->v.value;
2417 if (*s != 0) for (count = 1; count <= list[0] - 2; count++)
2420 uschar *snext = Ustrchr(s, ':');
2424 while (ss > s && isspace(ss[-1])) ss--;
2427 value = readconf_readtime(s, terminator, FALSE);
2429 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2431 if (count > 1 && value <= list[count])
2432 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2433 "time value out of order for %s", name);
2434 list[count+1] = value;
2435 if (snext == NULL) break;
2437 Uskip_whitespace(&s);
2440 if (count > list[0] - 2)
2441 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many time values for %s",
2443 if (count > 0 && list[2] == 0) count = 0;
2449 ol->v.fn(name, s, 0);
2455 misc_module_info * mi = misc_mod_find(US ol->v.value, &errstr);
2457 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2458 "failed to find %s module for %s: %s", US ol->v.value, name, errstr);
2460 oltop = mi->options;
2461 last = mi->options_count;
2471 /*************************************************
2472 * Print a time value *
2473 *************************************************/
2476 Argument: a time value in seconds
2477 Returns: pointer to a fixed buffer containing the time as a string,
2478 in readconf_readtime() format
2482 readconf_printtime(int t)
2485 uschar *p = time_buffer;
2487 if (t < 0) *p++ = '-', t = -t;
2498 if (w > 0) p += sprintf(CS p, "%dw", w);
2499 if (d > 0) p += sprintf(CS p, "%dd", d);
2500 if (h > 0) p += sprintf(CS p, "%dh", h);
2501 if (m > 0) p += sprintf(CS p, "%dm", m);
2502 if (s > 0 || p == time_buffer) sprintf(CS p, "%ds", s);
2509 /*************************************************
2510 * Print an individual option value *
2511 *************************************************/
2513 /* This is used by the -bP option, so prints to the standard output.
2514 The entire options list is passed in as an argument, because some options come
2515 in pairs - typically uid/gid settings, which can either be explicit numerical
2516 values, or strings to be expanded later. If the numerical value is unset,
2517 search for "*expand_<name>" to see if there is a string equivalent.
2520 ol option entry, or NULL for an unknown option
2522 options_block NULL for main configuration options; otherwise points to
2523 a driver block; if the option doesn't have opt_public
2524 set, then options_block->options_block is where the item
2526 oltop points to the option list in which ol exists
2527 last one more than the offset of the last entry in optop
2528 no_labels do not show "foo = " at the start.
2530 Returns: boolean success
2534 print_ol(optionlist *ol, const uschar *name, void *options_block,
2535 optionlist *oltop, int last, BOOL no_labels)
2544 uschar name2[EXIM_DRIVERNAME_MAX];
2548 printf("%s is not a known option\n", name);
2552 /* Non-admin callers cannot see options that have been flagged secure by the
2555 if (!f.admin_user && ol->type & opt_secure)
2558 printf("%s\n", CCS hidden);
2560 printf("%s = %s\n", name, CCS hidden);
2564 /* Else show the value of the option */
2566 value = ol->v.value;
2569 if (!(ol->type & opt_public))
2570 options_block = (void *)(((driver_instance *)options_block)->options_block);
2571 value = (void *)(US options_block + (long int)value);
2574 switch(ol->type & opt_mask)
2577 case opt_rewrite: /* Show the text value */
2579 if (!no_labels) printf("%s = ", name);
2580 printf("%s\n", s ? string_printing2(s, SP_TAB) : US"");
2584 if (!no_labels) printf("%s = ", name);
2585 printf("%d\n", *((int *)value));
2590 int x = *((int *)value);
2591 if (x != 0 && (x & 1023) == 0)
2595 if ((x & 1023) == 0)
2600 if (!no_labels) printf("%s = ", name);
2601 printf("%d%c\n", x, c);
2605 if (!no_labels) printf("%s = ", name);
2613 int_eximarith_t x = *((int_eximarith_t *)value);
2614 if (!no_labels) printf("%s = ", name);
2615 if (x == 0) printf("0\n");
2616 else if ((x & ((1<<30)-1)) == 0) printf(PR_EXIM_ARITH "T\n", x >> 30);
2617 else if ((x & ((1<<20)-1)) == 0) printf(PR_EXIM_ARITH "G\n", x >> 20);
2618 else if ((x & ((1<<10)-1)) == 0) printf(PR_EXIM_ARITH "M\n", x >> 10);
2619 else printf(PR_EXIM_ARITH "K\n", x);
2624 if (!no_labels) printf("%s = ", name);
2625 printf("%#o\n", *((int *)value));
2628 /* Can be negative only when "unset", in which case integer */
2632 int x = *((int *)value);
2635 if (x < 0) printf("%s =\n", name); else
2637 if (!no_labels) printf("%s = ", name);
2638 printf("%d.", x/1000);
2651 /* If the numerical value is unset, try for the string value */
2653 case opt_expand_uid:
2654 if (! *get_set_flag(name, oltop, last, options_block))
2656 sprintf(CS name2, "*expand_%.50s", name);
2657 if ((ol2 = find_option(name2, oltop, last)))
2660 s = *USS (US options_block + ol2->v.offset);
2662 s = *USS ol2->v.value;
2663 if (!no_labels) printf("%s = ", name);
2664 printf("%s\n", s ? string_printing(s) : US"");
2669 /* Else fall through */
2672 if (!no_labels) printf("%s = ", name);
2673 if (! *get_set_flag(name, oltop, last, options_block))
2676 if ((pw = getpwuid(*((uid_t *)value))))
2677 printf("%s\n", pw->pw_name);
2679 printf("%ld\n", (long int)(*((uid_t *)value)));
2682 /* If the numerical value is unset, try for the string value */
2684 case opt_expand_gid:
2685 if (! *get_set_flag(name, oltop, last, options_block))
2687 sprintf(CS name2, "*expand_%.50s", name);
2688 if ( (ol2 = find_option(name2, oltop, last))
2689 && (ol2->type & opt_mask) == opt_stringptr)
2692 s = *USS (US options_block + ol2->v.offset);
2694 s = *USS ol2->v.value;
2695 if (!no_labels) printf("%s = ", name);
2696 printf("%s\n", s ? string_printing(s) : US"");
2701 /* Else fall through */
2704 if (!no_labels) printf("%s = ", name);
2705 if (! *get_set_flag(name, oltop, last, options_block))
2708 if ((gr = getgrgid(*((int *)value))))
2709 printf("%s\n", gr->gr_name);
2711 printf("%ld\n", (long int)(*((int *)value)));
2715 uidlist = *((uid_t **)value);
2716 if (!no_labels) printf("%s =", name);
2719 uschar sep = no_labels ? '\0' : ' ';
2720 for (int i = 1; i <= (int)(uidlist[0]); i++)
2722 uschar *name = NULL;
2723 if ((pw = getpwuid(uidlist[i]))) name = US pw->pw_name;
2724 if (sep != '\0') printf("%c", sep);
2725 if (name) printf("%s", name);
2726 else printf("%ld", (long int)(uidlist[i]));
2734 gidlist = *((gid_t **)value);
2735 if (!no_labels) printf("%s =", name);
2738 uschar sep = no_labels ? '\0' : ' ';
2739 for (int i = 1; i <= (int)(gidlist[0]); i++)
2741 uschar *name = NULL;
2742 if ((gr = getgrgid(gidlist[i]))) name = US gr->gr_name;
2743 if (sep != '\0') printf("%c", sep);
2744 if (name) printf("%s", name);
2745 else printf("%ld", (long int)(gidlist[i]));
2753 if (!no_labels) printf("%s = ", name);
2754 printf("%s\n", readconf_printtime(*((int *)value)));
2759 int *list = (int *)value;
2760 if (!no_labels) printf("%s = ", name);
2761 for (int i = 0; i < list[1]; i++)
2762 printf("%s%s", i == 0 ? "" : ":", readconf_printtime(list[i+2]));
2768 printf("%s%s\n", (*((int *)value)) & (1 << ((ol->type >> 16) & 31))
2769 ? "" : "no_", name);
2772 case opt_expand_bool:
2773 sprintf(CS name2, "*expand_%.50s", name);
2774 if ((ol2 = find_option(name2, oltop, last)) && ol2->v.value)
2777 s = *USS (US options_block + ol2->v.offset);
2779 s = *USS ol2->v.value;
2782 if (!no_labels) printf("%s = ", name);
2783 printf("%s\n", string_printing(s));
2786 /* s == NULL => string not set; fall through */
2792 case opt_bool_verify:
2794 printf("%s%s\n", *((BOOL *)value) ? "" : "no_", name);
2798 ol->v.fn(name, NULL, no_labels ? opt_fn_print : opt_fn_print|opt_fn_print_label);
2806 /*************************************************
2807 * Print value from main configuration *
2808 *************************************************/
2810 /* This function, called as a result of encountering the -bP option,
2811 causes the value of any main configuration variable to be output if the
2812 second argument is NULL. There are some special values:
2814 all print all main configuration options
2815 config_file print the name of the configuration file
2816 (configure_file will still work, for backward
2818 routers print the routers' configurations
2819 transports print the transports' configuration
2820 authenticators print the authenticators' configuration
2821 macros print the macros' configuration
2822 router_list print a list of router names
2823 transport_list print a list of transport names
2824 authenticator_list print a list of authentication mechanism names
2825 macro_list print a list of macro names
2826 +name print a named list item
2827 local_scan print the local_scan options
2828 config print the configuration as it is parsed
2829 environment print the used execution environment
2831 If the second argument is not NULL, it must be one of "router", "transport",
2832 "authenticator" or "macro" in which case the first argument identifies the
2833 driver whose options are to be printed.
2836 name option name if type == NULL; else driver name
2837 type NULL or driver type name, as described above
2838 no_labels avoid the "foo = " at the start of an item
2840 Returns: Boolean success
2844 readconf_print(const uschar * name, const uschar * type, BOOL no_labels)
2846 BOOL names_only = FALSE;
2847 optionlist *ol2 = NULL;
2848 driver_instance *d = NULL;
2857 static uschar *types[] = { US"address", US"domain", US"host",
2859 static tree_node **anchors[] = { &addresslist_anchor, &domainlist_anchor,
2860 &hostlist_anchor, &localpartlist_anchor };
2862 for (int i = 0; i < 4; i++)
2863 if ((t = tree_search(*(anchors[i]), name+1)))
2865 namedlist_block * nb = t->data.ptr;
2866 const uschar * s = nb->hide ? hidden : nb->string;
2869 printf("%s\n", CCS s);
2871 printf("%slist %s = %s\n", types[i], name+1, CCS s);
2875 printf("no address, domain, host, or local part list called \"%s\" "
2876 "exists\n", name+1);
2881 if ( Ustrcmp(name, "configure_file") == 0
2882 || Ustrcmp(name, "config_file") == 0)
2884 printf("%s\n", CS config_main_filename);
2888 if (Ustrcmp(name, "all") == 0)
2890 for (optionlist * ol = optionlist_config;
2891 ol < optionlist_config + nelem(optionlist_config); ol++)
2892 if (!(ol->type & opt_hidden))
2893 (void) print_ol(ol, US ol->name, NULL,
2894 optionlist_config, nelem(optionlist_config),
2899 if (Ustrcmp(name, "local_scan") == 0)
2901 #ifndef LOCAL_SCAN_HAS_OPTIONS
2902 printf("local_scan() options are not supported\n");
2905 for (optionlist * ol = local_scan_options;
2906 ol < local_scan_options + local_scan_options_count; ol++)
2907 (void) print_ol(ol, US ol->name, NULL, local_scan_options,
2908 local_scan_options_count, no_labels);
2913 if (Ustrcmp(name, "config") == 0)
2915 print_config(f.admin_user, no_labels);
2919 if (Ustrcmp(name, "routers") == 0)
2924 else if (Ustrcmp(name, "transports") == 0)
2926 type = US"transport";
2929 else if (Ustrcmp(name, "authenticators") == 0)
2931 type = US"authenticator";
2934 else if (Ustrcmp(name, "macros") == 0)
2939 else if (Ustrcmp(name, "router_list") == 0)
2945 else if (Ustrcmp(name, "transport_list") == 0)
2947 type = US"transport";
2951 else if (Ustrcmp(name, "authenticator_list") == 0)
2953 type = US"authenticator";
2957 else if (Ustrcmp(name, "macro_list") == 0)
2963 else if (Ustrcmp(name, "environment") == 0)
2968 for (p = USS environ; *p; p++) ;
2969 qsort(environ, p - USS environ, sizeof(*p), string_compare_by_pointer);
2971 for (p = USS environ; *p; p++)
2974 if (no_labels && (q = Ustrchr(*p, '='))) *q = '\0';
2982 return print_ol(find_option(name,
2983 optionlist_config, nelem(optionlist_config)),
2984 name, NULL, optionlist_config, nelem(optionlist_config), no_labels);
2987 /* Handle the options for a router or transport. Skip options that are flagged
2988 as hidden. Some of these are options with names starting with '*', used for
2989 internal alternative representations of other options (which the printing
2990 function will sort out). Others are synonyms kept for backward compatibility.
2993 if (Ustrcmp(type, "router") == 0)
2995 d = (driver_instance *)routers;
2996 ol2 = optionlist_routers;
2997 size = optionlist_routers_size;
2999 else if (Ustrcmp(type, "transport") == 0)
3001 d = (driver_instance *)transports;
3002 ol2 = optionlist_transports;
3003 size = optionlist_transports_size;
3005 else if (Ustrcmp(type, "authenticator") == 0)
3007 d = (driver_instance *)auths;
3008 ol2 = optionlist_auths;
3009 size = optionlist_auths_size;
3012 else if (Ustrcmp(type, "macro") == 0)
3014 /* People store passwords in macros and they were previously not available
3015 for printing. So we have an admin_users restriction. */
3018 fprintf(stderr, "exim: permission denied; not admin\n");
3021 for (macro_item * m = macros; m; m = m->next)
3022 if (!name || Ustrcmp(name, m->name) == 0)
3025 printf("%s\n", CS m->name);
3027 printf("%s\n", CS m->replacement);
3029 printf("%s=%s\n", CS m->name, CS m->replacement);
3033 if (!name) return TRUE;
3035 printf("%s %s not found\n", type, name);
3041 for (; d; d = d->next) printf("%s\n", CS d->name);
3045 /* Either search for a given driver, or print all of them */
3047 for (; d; d = d->next)
3050 driver_info * di = d->info;
3053 printf("\n%s %s:\n", d->name, type);
3054 else if (Ustrcmp(d->name, name) != 0) continue;
3056 for (optionlist * ol = ol2; ol < ol2 + size; ol++)
3057 if (!(ol->type & opt_hidden))
3058 rc |= print_ol(ol, US ol->name, d, ol2, size, no_labels);
3060 for (optionlist * ol = di->options;
3061 ol < di->options + *di->options_count; ol++)
3062 if (!(ol->type & opt_hidden))
3063 rc |= print_ol(ol, US ol->name, d, di->options,
3064 *di->options_count, no_labels);
3066 if (name) return rc;
3068 if (!name) return TRUE;
3070 printf("%s %s not found\n", type, name);
3076 /*************************************************
3077 * Read a named list item *
3078 *************************************************/
3080 /* This function reads a name and a list (i.e. string). The name is used to
3081 save the list in a tree, sorted by its name. Each entry also has a number,
3082 which can be used for caching tests, but if the string contains any expansion
3083 items other than $key, the number is set negative to inhibit caching. This
3084 mechanism is used for domain, host, and address lists that are referenced by
3088 anchorp points to the tree anchor
3089 numberp points to the current number for this tree
3090 max the maximum number permitted
3091 s the text of the option line, starting immediately after the name
3093 tname the name of the list type, for messages
3094 hide do not output value on "-bP"
3100 read_named_list(tree_node **anchorp, int *numberp, int max, uschar *s,
3101 uschar *tname, BOOL hide)
3103 BOOL forcecache = FALSE;
3106 namedlist_block * nb = store_get_perm(sizeof(namedlist_block), GET_UNTAINTED);
3108 if (Ustrncmp(s, "_cache", 6) == 0)
3115 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unrecognized configuration line");
3117 if (*numberp >= max)
3118 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many named %ss (max is %d)\n",
3121 Uskip_whitespace(&s);
3123 while (isalnum(*s) || *s == '_') s++;
3124 t = store_get(sizeof(tree_node) + s-ss, ss);
3125 Ustrncpy(t->name, ss, s-ss);
3127 Uskip_whitespace(&s);
3129 if (!tree_insertnode(anchorp, t))
3130 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3131 "duplicate name \"%s\" for a named %s", t->name, tname);
3134 nb->number = *numberp;
3138 if (*s++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3139 "missing '=' after \"%s\"", t->name);
3140 Uskip_whitespace(&s);
3141 nb->string = read_string(s, t->name);
3142 nb->cache_data = NULL;
3144 /* Check the string for any expansions; if any are found, mark this list
3145 uncacheable unless the user has explicited forced caching. */
3147 if (!forcecache && Ustrchr(nb->string, '$') != NULL) nb->number = -1;
3153 /*************************************************
3154 * Unpick data for a rate limit *
3155 *************************************************/
3157 /* This function is called to unpick smtp_ratelimit_{mail,rcpt} into four
3161 s string, in the form t,b,f,l
3162 where t is the threshold (integer)
3163 b is the initial delay (time)
3164 f is the multiplicative factor (fixed point)
3165 k is the maximum time (time)
3166 threshold where to store threshold
3167 base where to store base in milliseconds
3168 factor where to store factor in milliseconds
3169 limit where to store limit
3171 Returns: nothing (panics on error)
3175 unpick_ratelimit(uschar *s, int *threshold, int *base, double *factor,
3178 uschar bstring[16], lstring[16];
3180 if (sscanf(CS s, "%d, %15[0123456789smhdw.], %lf, %15s", threshold, bstring,
3181 factor, lstring) == 4)
3183 *base = readconf_readtime(bstring, 0, TRUE);
3184 *limit = readconf_readtime(lstring, 0, TRUE);
3185 if (*base >= 0 && *limit >= 0) return;
3187 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "malformed ratelimit data: %s", s);
3193 /*************************************************
3194 * Read main configuration options *
3195 *************************************************/
3197 /* This function is the first to be called for configuration reading. It
3198 opens the configuration file and reads general configuration settings until
3199 it reaches the end of the configuration section. The file is then left open so
3200 that the remaining configuration data can subsequently be read if needed for
3203 The configuration file must be owned either by root or exim, and be writeable
3204 only by root or uid/gid exim. The values for Exim's uid and gid can be changed
3205 in the config file, so the test is done on the compiled in values. A slight
3206 anomaly, to be carefully documented.
3208 The name of the configuration file is taken from a list that is included in the
3209 binary of Exim. It can be altered from the command line, but if that is done,
3210 root privilege is immediately withdrawn unless the caller is root or exim.
3211 The first file on the list that exists is used.
3213 For use on multiple systems that share file systems, first look for a
3214 configuration file whose name has the current node name on the end. If that is
3215 not found, try the generic name. For really contorted configurations, that run
3216 multiple Exims with different uid settings, first try adding the effective uid
3217 before the node name. These complications are going to waste resources on most
3218 systems. Therefore they are available only when requested by compile-time
3222 readconf_main(BOOL nowarn)
3225 struct stat statbuf;
3226 uschar * s, * filename;
3227 const uschar * list = config_main_filelist;
3229 /* Loop through the possible file names */
3231 /* Should never be a tainted list */
3232 while((filename = string_nextinlist(&list, &sep, big_buffer, big_buffer_size)))
3235 /* Cut out all the fancy processing unless specifically wanted */
3237 #if defined(CONFIGURE_FILE_USE_NODE) || defined(CONFIGURE_FILE_USE_EUID)
3238 uschar *suffix = filename + Ustrlen(filename);
3240 /* Try for the node-specific file if a node name exists */
3242 # ifdef CONFIGURE_FILE_USE_NODE
3244 if (uname(&uts) >= 0)
3246 # ifdef CONFIGURE_FILE_USE_EUID
3247 sprintf(CS suffix, ".%ld.%.256s", (long int)original_euid, uts.nodename);
3248 if (!(config_file = Ufopen(filename, "rb")))
3249 # endif /* CONFIGURE_FILE_USE_EUID */
3251 sprintf(CS suffix, ".%.256s", uts.nodename);
3252 config_file = Ufopen(filename, "rb");
3255 # endif /* CONFIGURE_FILE_USE_NODE */
3257 /* Otherwise, try the generic name, possibly with the euid added */
3259 # ifdef CONFIGURE_FILE_USE_EUID
3262 sprintf(CS suffix, ".%ld", (long int)original_euid);
3263 config_file = Ufopen(filename, "rb");
3265 # endif /* CONFIGURE_FILE_USE_EUID */
3267 /* Finally, try the unadorned name */
3272 config_file = Ufopen(filename, "rb");
3274 #else /* if neither defined */
3276 /* This is the common case when the fancy processing is not included. */
3278 config_file = Ufopen(filename, "rb");
3281 /* If the file does not exist, continue to try any others. For any other
3282 error, break out (and die). */
3284 if (config_file || errno != ENOENT) break;
3287 /* On success, save the name for verification; config_filename is used when
3288 logging configuration errors (it changes for .included files) whereas
3289 config_main_filename is the name shown by -bP. Failure to open a configuration
3290 file is a serious disaster. */
3294 uschar *last_slash = Ustrrchr(filename, '/');
3295 config_filename = config_main_filename = string_copy(filename);
3297 /* The config_main_directory we need for the $config_dir expansion.
3298 config_main_filename we need for $config_file expansion.
3299 And config_dir is the directory of the current configuration, used for
3300 relative .includes. We do need to know it's name, as we change our working
3303 if (filename[0] == '/')
3304 config_main_directory = last_slash == filename ? US"/" : string_copyn(filename, last_slash - filename);
3307 /* relative configuration file name: working dir + / + basename(filename) */
3309 uschar buf[PATH_MAX];
3312 if (os_getcwd(buf, PATH_MAX) == NULL)
3314 perror("exim: getcwd");
3315 exim_exit(EXIT_FAILURE);
3317 g = string_cat(NULL, buf);
3319 /* If the dir does not end with a "/", append one */
3320 if (gstring_last_char(g) != '/')
3321 g = string_catn(g, US"/", 1);
3323 /* If the config file contains a "/", extract the directory part */
3325 g = string_catn(g, filename, last_slash - filename);
3327 config_main_directory = string_from_gstring(g);
3329 config_directory = config_main_directory;
3333 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "non-existent configuration file(s): "
3334 "%s", config_main_filelist);
3336 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
3337 string_open_failed("configuration file %s", filename));
3339 /* Now, once we found and opened our configuration file, we change the directory
3340 to a safe place. Later we change to $spool_directory. */
3342 if (Uchdir("/") < 0)
3344 perror("exim: chdir `/': ");
3345 exim_exit(EXIT_FAILURE);
3348 /* Check the status of the file we have opened, if we have retained root
3349 privileges and the file isn't /dev/null (which *should* be 0666). */
3351 if (f.trusted_config && Ustrcmp(filename, US"/dev/null"))
3353 if (fstat(fileno(config_file), &statbuf) != 0)
3354 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to stat configuration file %s",
3357 if ( statbuf.st_uid != root_uid /* owner not root */
3358 #ifdef CONFIGURE_OWNER
3359 && statbuf.st_uid != config_uid /* owner not the special one */
3362 statbuf.st_gid != root_gid /* group not root & */
3363 #ifdef CONFIGURE_GROUP
3364 && statbuf.st_gid != config_gid /* group not the special one */
3366 && (statbuf.st_mode & 020) != 0 /* group writeable */
3368 (statbuf.st_mode & 2) != 0 /* world writeable */
3370 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Exim configuration file %s has the "
3371 "wrong owner, group, or mode", big_buffer);
3373 /* Do a dummy store-allocation of a size related to the (toplevel) file size.
3374 This assumes we will need this much storage to handle all the allocations
3375 during startup; it won't help when .include is being used. When it does, it
3376 will cut down on the number of store blocks (and malloc calls, and sbrk
3377 syscalls). It also assume we're on the relevant pool. */
3379 if (statbuf.st_size > 8192)
3381 rmark r = store_mark();
3382 void * dummy = store_get((int)statbuf.st_size, GET_UNTAINTED);
3387 /* Process the main configuration settings. They all begin with a lower case
3388 letter. If we see something starting with an upper case letter, it is taken as
3389 a macro definition. */
3391 while ((s = get_config_line()))
3396 if (config_lineno == 1 && Ustrstr(s, "\xef\xbb\xbf") == s)
3397 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3398 "found unexpected BOM (Byte Order Mark)");
3402 if (!macro_read_assignment(s)) exim_exit(EXIT_FAILURE);
3406 t = (hide = Ustrncmp(s, "hide", 4) == 0 && isspace(s[4])) ? s + 5 : s;
3408 if (Ustrncmp(t, "domainlist", 10) == 0)
3409 read_named_list(&domainlist_anchor, &domainlist_count,
3410 MAX_NAMED_LIST, t+10, US"domain list", hide);
3412 else if (Ustrncmp(t, "hostlist", 8) == 0)
3413 read_named_list(&hostlist_anchor, &hostlist_count,
3414 MAX_NAMED_LIST, t+8, US"host list", hide);
3416 else if (Ustrncmp(t, "addresslist", 11) == 0)
3417 read_named_list(&addresslist_anchor, &addresslist_count,
3418 MAX_NAMED_LIST, t+11, US"address list", hide);
3420 else if (Ustrncmp(t, "localpartlist", 13) == 0)
3421 read_named_list(&localpartlist_anchor, &localpartlist_count,
3422 MAX_NAMED_LIST, t+13, US"local part list", hide);
3425 (void) readconf_handle_option(s, optionlist_config, optionlist_config_size,
3426 NULL, US"main option \"%s\" unknown");
3430 /* If local_sender_retain is set, local_from_check must be unset. */
3432 if (local_sender_retain && local_from_check)
3433 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "both local_from_check and "
3434 "local_sender_retain are set; this combination is not allowed");
3436 /* If the timezone string is empty, set it to NULL, implying no TZ variable
3439 if (timezone_string && !*timezone_string) timezone_string = NULL;
3441 /* The max retry interval must not be greater than 24 hours. */
3443 if (retry_interval_max > 24*60*60) retry_interval_max = 24*60*60;
3445 /* remote_max_parallel must be > 0 */
3447 if (remote_max_parallel <= 0) remote_max_parallel = 1;
3449 /* Save the configured setting of freeze_tell, so we can re-instate it at the
3450 start of a new SMTP message. */
3452 freeze_tell_config = freeze_tell;
3454 /* The primary host name may be required for expansion of spool_directory
3455 and log_file_path, so make sure it is set asap. It is obtained from uname(),
3456 but if that yields an unqualified value, make a FQDN by using gethostbyname to
3457 canonize it. Some people like upper case letters in their host names, so we
3458 don't force the case. */
3460 if (!primary_hostname)
3462 const uschar * hostname;
3465 if (uname(&uts) < 0)
3466 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "uname() failed to yield host name");
3467 hostname = US uts.nodename;
3469 if (Ustrchr(hostname, '.') == NULL)
3472 struct hostent *hostdata;
3476 && ( !dns_ipv4_lookup
3477 || match_isinlist(hostname, CUSS &dns_ipv4_lookup, 0, NULL, NULL,
3478 MCL_DOMAIN, TRUE, NULL) != OK))
3485 # if HAVE_GETIPNODEBYNAME
3487 hostdata = getipnodebyname(CS hostname, af, 0, &error_num);
3489 hostdata = gethostbyname2(CS hostname, af);
3492 hostdata = gethostbyname(CS hostname);
3496 { hostname = US hostdata->h_name; break; }
3498 if (af == AF_INET) break;
3503 primary_hostname = string_copy(hostname);
3506 /* Set up default value for smtp_active_hostname */
3508 smtp_active_hostname = primary_hostname;
3510 /* If spool_directory wasn't set in the build-time configuration, it must have
3511 got set above. Of course, writing to the log may not work if log_file_path is
3512 not set, but it will at least get to syslog or somewhere, with any luck. */
3514 if (!*spool_directory)
3515 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "spool_directory undefined: cannot "
3518 /* Expand the spool directory name; it may, for example, contain the primary
3519 host name. Same comment about failure. */
3521 DEBUG(D_any) if (Ustrchr(spool_directory, '$'))
3522 debug_printf("Expanding spool_directory option\n");
3524 if (!(s = expand_string(spool_directory)))
3525 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand spool_directory "
3526 "\"%s\": %s", spool_directory, expand_string_message);
3527 spool_directory = s;
3529 /* Expand log_file_path, which must contain "%s" in any component that isn't
3530 the null string or "syslog". It is also allowed to contain one instance of %D
3531 or %M. However, it must NOT contain % followed by anything else. */
3535 const uschar *ss, *sss;
3536 int sep = ':'; /* Fixed for log file path */
3537 if (!(s = expand_string(log_file_path)))
3538 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand log_file_path "
3539 "\"%s\": %s", log_file_path, expand_string_message);
3542 /* should never be a tainted list */
3543 while ((sss = string_nextinlist(&ss, &sep, big_buffer, big_buffer_size)))
3546 if (sss[0] == 0 || Ustrcmp(sss, "syslog") == 0) continue;
3547 if (!(t = Ustrstr(sss, "%s")))
3548 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" does not "
3549 "contain \"%%s\"", sss);
3551 if ((t = Ustrchr(sss, '%')))
3552 if ((t[1] != 'D' && t[1] != 'M') || Ustrchr(t+2, '%') != NULL)
3553 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" contains "
3554 "unexpected \"%%\" character", s);
3560 /* Interpret syslog_facility into an integer argument for 'ident' param to
3561 openlog(). Default is LOG_MAIL set in globals.c. Allow the user to omit the
3564 if (syslog_facility_str)
3567 uschar * s = syslog_facility_str;
3569 if ((Ustrlen(syslog_facility_str) >= 4) &&
3570 (strncmpic(syslog_facility_str, US"log_", 4) == 0))
3573 for (i = 0; i < syslog_list_size; i++)
3574 if (strcmpic(s, syslog_list[i].name) == 0)
3576 syslog_facility = syslog_list[i].value;
3580 if (i >= syslog_list_size)
3581 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3582 "failed to interpret syslog_facility \"%s\"", syslog_facility_str);
3585 /* Expand pid_file_path */
3589 const uschar * t = expand_cstring(pid_file_path);
3591 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand pid_file_path "
3592 "\"%s\": %s", pid_file_path, expand_string_message);
3596 /* Set default value of process_log_path */
3598 if (!process_log_path || !*process_log_path)
3599 process_log_path = string_sprintf("%s/exim-process.info", spool_directory);
3601 /* Compile the regex for matching a UUCP-style "From_" line in an incoming
3604 regex_From = regex_must_compile(uucp_from_pattern, MCS_NOFLAGS, TRUE);
3606 /* Unpick the SMTP rate limiting options, if set */
3608 if (smtp_ratelimit_mail)
3609 unpick_ratelimit(smtp_ratelimit_mail, &smtp_rlm_threshold,
3610 &smtp_rlm_base, &smtp_rlm_factor, &smtp_rlm_limit);
3612 if (smtp_ratelimit_rcpt)
3613 unpick_ratelimit(smtp_ratelimit_rcpt, &smtp_rlr_threshold,
3614 &smtp_rlr_base, &smtp_rlr_factor, &smtp_rlr_limit);
3616 /* The qualify domains default to the primary host name */
3618 if (!qualify_domain_sender)
3619 qualify_domain_sender = primary_hostname;
3620 if (!qualify_domain_recipient)
3621 qualify_domain_recipient = qualify_domain_sender;
3623 /* Setting system_filter_user in the configuration sets the gid as well if a
3624 name is given, but a numerical value does not. */
3626 if (system_filter_uid_set && !system_filter_gid_set)
3628 struct passwd *pw = getpwuid(system_filter_uid);
3630 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to look up uid %ld",
3631 (long int)system_filter_uid);
3632 system_filter_gid = pw->pw_gid;
3633 system_filter_gid_set = TRUE;
3636 /* If the errors_reply_to field is set, check that it is syntactically valid
3637 and ensure it contains a domain. */
3639 if (errors_reply_to)
3642 int start, end, domain;
3643 uschar *recipient = parse_extract_address(errors_reply_to, &errmess,
3644 &start, &end, &domain, FALSE);
3647 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3648 "error in errors_reply_to (%s): %s", errors_reply_to, errmess);
3651 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3652 "errors_reply_to (%s) does not contain a domain", errors_reply_to);
3655 /* If smtp_accept_queue or smtp_accept_max_per_host is set, then
3656 smtp_accept_max must also be set. */
3658 if (smtp_accept_max == 0 && (smtp_accept_queue > 0 || smtp_accept_max_per_host))
3659 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3660 "smtp_accept_max must be set if smtp_accept_queue or "
3661 "smtp_accept_max_per_host is set");
3663 /* Set up the host number if anything is specified. It is an expanded string
3664 so that it can be computed from the host name, for example. We do this last
3665 so as to ensure that everything else is set up before the expansion. */
3667 if (host_number_string)
3671 uschar *s = expand_string(host_number_string);
3674 log_write(0, LOG_MAIN|LOG_PANIC_DIE,
3675 "failed to expand localhost_number \"%s\": %s",
3676 host_number_string, expand_string_message);
3677 n = Ustrtol(s, &end, 0);
3678 if (Uskip_whitespace(&end))
3679 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3680 "localhost_number value is not a number: %s", s);
3681 if (n > LOCALHOST_MAX)
3682 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3683 "localhost_number is greater than the maximum allowed value (%d)",
3689 /* If tls_verify_hosts is set, tls_verify_certificates must also be set */
3691 if ((tls_verify_hosts || tls_try_verify_hosts) && !tls_verify_certificates)
3692 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3693 "tls_%sverify_hosts is set, but tls_verify_certificates is not set",
3694 tls_verify_hosts ? "" : "try_");
3696 /* Magic number: at time of writing, 1024 has been the long-standing value
3697 used by so many clients, and what Exim used to use always, that it makes
3698 sense to just min-clamp this max-clamp at that. */
3699 if (tls_dh_max_bits < 1024)
3700 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3701 "tls_dh_max_bits is too small, must be at least 1024 for interop");
3703 /* If openssl_options is set, validate it */
3704 if (openssl_options)
3707 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3708 "openssl_options is set but we're using GnuTLS");
3711 if (!tls_openssl_options_parse(openssl_options, &dummy))
3712 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3713 "openssl_options parse error: %s", openssl_options);
3716 #endif /*DISABLE_TLS*/
3718 if (!nowarn && !keep_environment && environ && *environ)
3719 log_write(0, LOG_MAIN,
3720 "Warning: purging the environment.\n"
3721 " Suggested action: use keep_environment.");
3726 /* Add a driver info struct to a list. */
3729 add_driver_info(driver_info ** drlist_p, const driver_info * newent,
3732 driver_info * listent = store_get(size, newent);
3733 memcpy(listent, newent, size);
3734 listent->next = *drlist_p;
3738 /*************************************************
3739 * Initialize one driver *
3740 *************************************************/
3742 /* This is called once the driver's generic options, if any, have been read.
3743 We can now find the driver, set up defaults for the private options, and
3744 unset any "set" bits in the private options table (which might have been
3745 set by another incarnation of the same driver).
3748 d pointer to driver instance block, with generic
3750 info_anchor list of available drivers
3751 size_of_info size of each block in drivers_available
3752 class class of driver
3754 Returns: pointer to the driver info block
3757 static driver_info *
3758 init_driver(driver_instance * d, driver_info ** info_anchor,
3759 int size_of_info, const uschar * class)
3765 /* First scan the list of driver seen so far. */
3767 for (di = *info_anchor; di; di = di->next)
3768 if (Ustrcmp(d->driver_name, di->driver_name) == 0)
3771 #ifdef LOOKUP_MODULE_DIR
3772 /* Potentially a loadable module. Look for a file with the right name. */
3774 if (!(dd = exim_opendir(CUS LOOKUP_MODULE_DIR)))
3776 log_write(0, LOG_MAIN|LOG_PANIC,
3777 "Couldn't open %s: not loading driver modules\n", LOOKUP_MODULE_DIR);
3781 uschar * fname = string_sprintf("%s_%s." DYNLIB_FN_EXT, d->driver_name, class), * sname;
3782 const char * errormsg;
3784 DEBUG(D_any) debug_printf("Loading %s %s driver from %s\n",
3785 d->driver_name, class, LOOKUP_MODULE_DIR);
3787 for(struct dirent * ent; ent = readdir(dd); ) if (Ustrcmp(ent->d_name, fname) == 0)
3789 void * dl = dlopen(CS string_sprintf(LOOKUP_MODULE_DIR "/%s", fname), RTLD_NOW);
3790 static driver_magics dm[] = {
3791 { ROUTER_MAGIC, US"router" },
3792 { TRANSPORT_MAGIC, US"transport" },
3793 { AUTH_MAGIC, US"auth" },
3798 errormsg = dlerror();
3799 log_write(0, LOG_MAIN|LOG_PANIC, "Error loading %s %s driver: %s\n",
3800 d->driver_name, class, errormsg);
3803 (void) dlerror(); /* cf. comment in init_lookup_list() */
3805 di = (driver_info *) dlsym(dl, CS string_sprintf("_%s_info", class));
3806 if ((errormsg = dlerror()))
3808 log_write(0, LOG_MAIN|LOG_PANIC,
3809 "%s does not appear to be a %s module (%s)\n", fname, class, errormsg);
3813 for(driver_magics * dmp = dm; dmp < dm + nelem(dm); dmp++)
3814 if(Ustrcmp(dmp->class, class) == 0 && dmp->magic == di->dyn_magic)
3816 int old_pool = store_pool;
3817 store_pool = POOL_PERM;
3818 add_driver_info(info_anchor, di, size_of_info);
3819 store_pool = old_pool;
3820 DEBUG(D_any) debug_printf("Loaded %s %s\n", d->driver_name, class);
3825 log_write(0, LOG_MAIN|LOG_PANIC,
3826 "%s module %s is not compatible with this version of Exim\n",
3827 class, d->driver_name);
3833 #endif /* LOOKUP_MODULE_DIR */
3835 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3836 "%s %s: cannot find %s driver \"%s\"", class, d->name, class, d->driver_name);
3840 len = di->options_len;
3842 d->options_block = store_get_perm(len, GET_UNTAINTED);
3843 memcpy(d->options_block, di->options_block, len);
3844 for (int i = 0; i < *di->options_count; i++)
3845 di->options[i].type &= ~opt_set;
3853 driver_init_fini(driver_instance * d, const uschar * class)
3855 driver_info * di = d->info;
3857 if (!d->driver_name)
3858 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3859 "no driver defined for %s \"%s\"", class, d->name);
3864 /*************************************************
3865 * Initialize driver list *
3866 *************************************************/
3868 /* This function is called for routers, transports, and authentication
3869 mechanisms. It reads the data from the current point in the configuration file
3870 up to the end of the section, and sets up a chain of instance blocks according
3871 to the file's contents. The file will already have been opened by a call to
3872 readconf_main, and must be left open for subsequent reading of further data.
3874 Any errors cause a panic crash. Note that the blocks with names driver_info and
3875 driver_instance must map the first portions of all the _info and _instance
3876 blocks for this shared code to work.
3879 anchor &routers, &transports, &auths
3880 info_anchor available drivers
3881 size_of_info size of each info block
3882 instance_default points to default data for an instance
3883 instance_size size of instance block
3884 driver_optionlist generic option list
3885 driver_optionlist_count count of generic option list
3886 class "router", "transport", or "auth"
3887 for filename component (and error message)
3893 readconf_driver_init(
3894 driver_instance ** anchor,
3895 driver_info ** info_anchor,
3897 void * instance_default,
3899 optionlist * driver_optionlist,
3900 int driver_optionlist_count,
3901 const uschar * class)
3903 driver_instance ** p = anchor;
3904 driver_instance * d = NULL;
3907 while ((buffer = get_config_line()))
3909 uschar name[EXIM_DRIVERNAME_MAX];
3912 /* Read the first name on the line and test for the start of a new driver. A
3913 macro definition indicates the end of the previous driver. If this isn't the
3914 start of a new driver, the line will be re-read. */
3916 s = readconf_readname(name, sizeof(name), buffer);
3918 /* Handle macro definition, first finishing off the initialization of the
3919 previous driver, if any. */
3921 if (isupper(*name) && *s == '=')
3925 /* s is using big_buffer, so this call had better not */
3926 driver_init_fini(d, class);
3929 if (!macro_read_assignment(buffer)) exim_exit(EXIT_FAILURE);
3933 /* If the line starts with a name terminated by a colon, we are at the
3934 start of the definition of a new driver. The rest of the line must be
3939 /* Finish off initializing the previous driver. */
3942 driver_init_fini(d, class);
3944 /* Check that we haven't already got a driver of this name */
3946 for (d = *anchor; d; d = d->next)
3947 if (Ustrcmp(name, d->name) == 0)
3948 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3949 "there are two %ss called \"%s\"", class, name);
3951 /* Set up a new driver instance data block on the chain, with
3952 its default values installed. */
3954 d = store_get_perm(instance_size, GET_UNTAINTED);
3955 memcpy(d, instance_default, instance_size);
3957 p = (driver_instance **)&d->next;
3958 d->name = string_copy(name);
3959 d->srcfile = config_filename;
3960 d->srcline = config_lineno;
3962 /* Clear out the "set" bits in the generic options */
3964 for (int i = 0; i < driver_optionlist_count; i++)
3965 driver_optionlist[i].type &= ~opt_set;
3967 /* Check nothing more on this line, then do the next loop iteration. */
3969 Uskip_whitespace(&s);
3970 if (*s) extra_chars_error(s, US"driver name ", name, US"");
3974 /* Not the start of a new driver. Give an error if we have not set up a
3975 current driver yet. */
3978 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s name missing", class);
3980 /* First look to see if this is a generic option; if it is "driver",
3981 initialize the driver. If is it not a generic option, we can look for a
3982 private option provided that the driver has been previously set up. */
3984 if (readconf_handle_option(buffer, driver_optionlist,
3985 driver_optionlist_count, d, NULL))
3987 if (!d->info && d->driver_name)
3988 init_driver(d, info_anchor, size_of_info, class);
3991 /* Handle private options - pass the generic block because some may
3992 live therein. A flag with each option indicates if it is in the public
3997 driver_info * di = d->info;
3998 readconf_handle_option(buffer, di->options,
3999 *di->options_count, d, US"option \"%s\" unknown");
4002 /* The option is not generic and the driver name has not yet been given. */
4004 else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option \"%s\" unknown "
4005 "(\"driver\" must be specified before any private options)", name);
4008 /* Run the initialization function for the final driver. */
4011 driver_init_fini(d, class);
4016 /*************************************************
4017 * Check driver dependency *
4018 *************************************************/
4020 /* This function is passed a driver instance and a string. It checks whether
4021 any of the string options for the driver contains the given string as an
4025 d points to a driver instance block
4026 s the string to search for
4028 Returns: TRUE if a dependency is found
4032 readconf_depends(driver_instance * d, uschar * s)
4034 driver_info * di = d->info;
4035 int count = *di->options_count;
4038 for (optionlist * ol = di->options; ol < di->options + count; ol++)
4039 if ((ol->type & opt_mask) == opt_stringptr)
4041 void * options_block = ol->type & opt_public ? (void *)d : d->options_block;
4042 uschar * value = *USS(US options_block + ol->v.offset);
4044 if (value && (ss = Ustrstr(value, s)) != NULL)
4046 if (ss <= value || (ss[-1] != '$' && ss[-1] != '{') ||
4047 isalnum(ss[Ustrlen(s)])) continue;
4048 DEBUG(D_transport) debug_printf("driver %s: \"%s\" option depends on %s\n",
4049 d->name, ol->name, s);
4054 DEBUG(D_transport) debug_printf("driver %s does not depend on %s\n", d->name, s);
4061 /*************************************************
4062 * Decode an error type for retries *
4063 *************************************************/
4065 /* This function is global because it is also called from the main
4066 program when testing retry information. It decodes strings such as "quota_7d"
4067 into numerical error codes.
4070 pp points to start of text
4071 p points past end of text
4072 basic_errno points to an int to receive the main error number
4073 more_errno points to an int to receive the secondary error data
4075 Returns: NULL if decoded correctly; else points to error text
4079 readconf_retry_error(const uschar *pp, const uschar *p,
4080 int *basic_errno, int *more_errno)
4083 const uschar *q = pp;
4084 while (q < p && *q != '_') q++;
4087 if (len == 5 && strncmpic(pp, US"quota", len) == 0)
4089 *basic_errno = ERRNO_EXIMQUOTA;
4090 if (q != p && (*more_errno = readconf_readtime(q+1, *p, FALSE)) < 0)
4091 return US"bad time value";
4094 else if (len == 7 && strncmpic(pp, US"refused", len) == 0)
4096 *basic_errno = ECONNREFUSED;
4099 if (strncmpic(q+1, US"MX", p-q-1) == 0) *more_errno = 'M';
4100 else if (strncmpic(q+1, US"A", p-q-1) == 0) *more_errno = 'A';
4101 else return US"A or MX expected after \"refused\"";
4105 else if (len == 7 && strncmpic(pp, US"timeout", len) == 0)
4107 *basic_errno = ETIMEDOUT;
4111 int xlen = p - q - 1;
4112 const uschar *x = q + 1;
4114 static uschar *extras[] =
4115 { US"A", US"MX", US"connect", US"connect_A", US"connect_MX" };
4116 static int values[] =
4117 { 'A', 'M', RTEF_CTOUT, RTEF_CTOUT|'A', RTEF_CTOUT|'M' };
4119 for (i = 0; i < nelem(extras); i++)
4120 if (strncmpic(x, extras[i], xlen) == 0)
4122 *more_errno = values[i];
4126 if (i >= nelem(extras))
4127 if (strncmpic(x, US"DNS", xlen) == 0)
4128 log_write(0, LOG_MAIN|LOG_PANIC, "\"timeout_dns\" is no longer "
4129 "available in retry rules (it has never worked) - treated as "
4132 return US"\"A\", \"MX\", or \"connect\" expected after \"timeout\"";
4136 else if (strncmpic(pp, US"mail_4", 6) == 0 ||
4137 strncmpic(pp, US"rcpt_4", 6) == 0 ||
4138 strncmpic(pp, US"data_4", 6) == 0)
4141 int x = 255; /* means "any 4xx code" */
4142 if (p != pp + 8) bad = TRUE; else
4144 int a = pp[6], b = pp[7];
4148 if (isdigit(b)) x += b - '0';
4149 else if (b == 'x') x += 100;
4152 else if (a != 'x' || b != 'x') bad = TRUE;
4156 return string_sprintf("%.4s_4 must be followed by xx, dx, or dd, where "
4157 "x is literal and d is any digit", pp);
4159 *basic_errno = *pp == 'm' ? ERRNO_MAIL4XX :
4160 *pp == 'r' ? ERRNO_RCPT4XX : ERRNO_DATA4XX;
4161 *more_errno = x << 8;
4164 else if (len == 4 && strncmpic(pp, US"auth", len) == 0 &&
4165 strncmpic(q+1, US"failed", p-q-1) == 0)
4166 *basic_errno = ERRNO_AUTHFAIL;
4168 else if (strncmpic(pp, US"lost_connection", p - pp) == 0)
4169 *basic_errno = ERRNO_SMTPCLOSED;
4171 else if (strncmpic(pp, US"tls_required", p - pp) == 0)
4172 *basic_errno = ERRNO_TLSREQUIRED;
4174 else if (strncmpic(pp, US"lookup", p - pp) == 0)
4175 *basic_errno = ERRNO_UNKNOWNHOST;
4177 else if (len != 1 || Ustrncmp(pp, "*", 1) != 0)
4178 return string_sprintf("unknown or malformed retry error \"%.*s\"", (int) (p-pp), pp);
4186 /*************************************************
4187 * Read retry information *
4188 *************************************************/
4190 /* Each line of retry information contains:
4192 . A domain name pattern or an address pattern;
4194 . An error name, possibly with additional data, or *;
4196 . An optional sequence of retry items, each consisting of an identifying
4197 letter, a cutoff time, and optional parameters.
4199 All this is decoded and placed into a control block. */
4202 /* Subroutine to read an argument, preceded by a comma and terminated
4203 by comma, semicolon, whitespace, or newline. The types are: 0 = time value,
4204 1 = fixed point number (returned *1000).
4207 paddr pointer to pointer to current character; updated
4208 type 0 => read a time; 1 => read a fixed point number
4210 Returns: time in seconds or fixed point number * 1000
4214 retry_arg(const uschar ** paddr, int type)
4216 const uschar * p = *paddr, * pp;
4218 if (*p++ != ',') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma expected");
4220 Uskip_whitespace(&p);
4222 while (isalnum(*p) || (type == 1 && *p == '.')) p++;
4224 if (*p && !isspace(*p) && *p != ',' && *p != ';')
4225 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma or semicolon expected");
4230 case 0: return readconf_readtime(pp, *p, FALSE);
4231 case 1: return readconf_readfixed(pp, *p);
4233 return 0; /* Keep picky compilers happy */
4236 /* The function proper */
4239 readconf_retries(void)
4241 retry_config **chain = &retries;
4245 while ((p = get_config_line()))
4247 retry_rule **rchain;
4251 next = store_get(sizeof(retry_config), GET_UNTAINTED);
4254 chain = &(next->next);
4255 next->basic_errno = next->more_errno = 0;
4256 next->senders = NULL;
4258 rchain = &(next->rules);
4260 next->pattern = string_dequote(&p);
4261 Uskip_whitespace(&p);
4263 while (mac_isgraph(*p)) p++;
4264 if (p - pp <= 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4265 "missing error type in retry rule");
4267 /* Test error names for things we understand. */
4269 if ((error = readconf_retry_error(pp, p, &next->basic_errno,
4270 &next->more_errno)))
4271 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s", error);
4273 /* There may be an optional address list of senders to be used as another
4274 constraint on the rule. This was added later, so the syntax is a bit of a
4275 fudge. Anything that is not a retry rule starting "F," or "G," is treated as
4278 Uskip_whitespace(&p);
4279 if (Ustrncmp(p, "senders", 7) == 0)
4282 Uskip_whitespace(&p);
4283 if (*p++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4284 "\"=\" expected after \"senders\" in retry rule");
4285 Uskip_whitespace(&p);
4286 next->senders = string_dequote(&p);
4289 /* Now the retry rules. Keep the maximum timeout encountered. */
4291 Uskip_whitespace(&p);
4295 retry_rule * rule = store_get(sizeof(retry_rule), GET_UNTAINTED);
4297 rchain = &(rule->next);
4299 rule->rule = toupper(*p++);
4300 rule->timeout = retry_arg(&p, 0);
4301 if (rule->timeout > retry_maximum_timeout)
4302 retry_maximum_timeout = rule->timeout;
4306 case 'F': /* Fixed interval */
4307 rule->p1 = retry_arg(&p, 0);
4310 case 'G': /* Geometrically increasing intervals */
4311 case 'H': /* Ditto, but with randomness */
4312 rule->p1 = retry_arg(&p, 0);
4313 rule->p2 = retry_arg(&p, 1);
4317 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unknown retry rule letter");
4321 if (rule->timeout <= 0 || rule->p1 <= 0 ||
4322 (rule->rule != 'F' && rule->p2 < 1000))
4323 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4324 "bad parameters for retry rule");
4326 if (Uskip_whitespace(&p) == ';')
4329 Uskip_whitespace(&p);
4332 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "semicolon expected");
4339 /*************************************************
4340 * Initialize authenticators *
4341 *************************************************/
4343 /* Read the authenticators section of the configuration file.
4352 #ifndef DISABLE_PIPE_CONNECT
4355 int old_pool = store_pool;
4356 store_pool = POOL_PERM;
4358 driver_info ** anchor = (driver_info **) &auths_available;
4359 extern auth_info cram_md5_auth_info;
4360 extern auth_info cyrus_sasl_auth_info;
4361 extern auth_info dovecot_auth_info;
4362 extern auth_info external_auth_info;
4363 extern auth_info gsasl_auth_info;
4364 extern auth_info heimdal_gssapi_auth_info;
4365 extern auth_info plaintext_auth_info;
4366 extern auth_info spa_auth_info;
4367 extern auth_info tls_auth_info;
4369 /* Add the transport drivers that are built for static linkage to the
4370 list of availables. */
4372 #if defined(AUTH_CRAM_MD5) && AUTH_CRAM_MD5!=2
4373 add_driver_info(anchor, &cram_md5_auth_info.drinfo, sizeof(auth_info));
4375 #if defined(AUTH_CYRUS_SASL) && AUTH_CYRUS_SASL!=2
4376 add_driver_info(anchor, &cyrus_sasl_auth_info.drinfo, sizeof(auth_info));
4378 #if defined(AUTH_DOVECOT) && AUTH_DOVECOT!=2
4379 add_driver_info(anchor, &dovecot_auth_info.drinfo, sizeof(auth_info));
4381 #if defined(AUTH_EXTERNAL) && AUTH_EXTERNAL!=2
4382 add_driver_info(anchor, &external_auth_info.drinfo, sizeof(auth_info));
4384 #if defined(AUTH_GSASL) && AUTH_GSASL!=2
4385 add_driver_info(anchor, &gsasl_auth_info.drinfo, sizeof(auth_info));
4387 #if defined(AUTH_HEIMDAL_GSSAPI) && AUTH_HEIMDAL_GSSAPI!=2
4388 add_driver_info(anchor, &heimdal_gssapi_auth_info.drinfo, sizeof(auth_info));
4390 #if defined(AUTH_PLAINTEXT) && AUTH_PLAINTEXT!=2
4391 add_driver_info(anchor, &plaintext_auth_info.drinfo, sizeof(auth_info));
4393 #if defined(AUTH_SPA) && AUTH_SPA!=2
4394 add_driver_info(anchor, &spa_auth_info.drinfo, sizeof(auth_info));
4396 #if defined(AUTH_TLS) && AUTH_TLS!=2
4397 add_driver_info(anchor, &tls_auth_info.drinfo, sizeof(auth_info));
4400 store_pool = old_pool;
4402 /* Read the config file "authenticators" section, creating an auth instance list.
4403 For any yet-undiscovered driver, check for a loadable module and add it to
4406 readconf_driver_init((driver_instance **)&auths, /* chain anchor */
4407 (driver_info **)&auths_available, /* available drivers */
4408 sizeof(auth_info), /* size of info block */
4409 &auth_defaults, /* default values for generic options */
4410 sizeof(auth_instance), /* size of instance block */
4411 optionlist_auths, /* generic options */
4412 optionlist_auths_size,
4415 for (auth_instance * au = auths; au; au = au->drinst.next)
4417 if (!au->public_name)
4418 log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "no public name specified for "
4419 "the %s authenticator", au->drinst.name);
4421 for (auth_instance * bu = au->drinst.next; bu; bu = bu->drinst.next)
4422 if (strcmpic(au->public_name, bu->public_name) == 0)
4423 if ( au->client && bu->client
4424 || au->server && bu->server)
4425 log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "two %s authenticators "
4426 "(%s and %s) have the same public name (%s)",
4427 au->client && bu->client ? US"client" : US"server",
4428 au->drinst.name, bu->drinst.name, au->public_name);
4429 #ifndef DISABLE_PIPE_CONNECT
4433 #ifndef DISABLE_PIPE_CONNECT
4434 f.smtp_in_early_pipe_no_auth = nauths > 16; /* bits in bitmap limit */
4439 /* For error messages, a string describing the config location associated
4440 with current processing. NULL if we are not in an authenticator. */
4443 authenticator_current_name(void)
4445 if (!authenticator_name) return NULL;
4446 return string_sprintf(" (authenticator %s, %s %d)", authenticator_name, driver_srcfile, driver_srcline);
4453 /*************************************************
4454 * Read ACL information *
4455 *************************************************/
4457 /* If this run of Exim is not doing something that involves receiving a
4458 message, we can just skip over the ACL information. No need to parse it.
4460 First, we have a function for acl_read() to call back to get the next line. We
4461 need to remember the line we passed, because at the end it will contain the
4462 name of the next ACL. */
4464 static uschar *acl_line;
4469 acl_line = get_config_line();
4474 /* Now the main function:
4483 /* Read each ACL and add it into the tree. Macro (re)definitions are allowed
4486 acl_line = get_config_line();
4490 uschar name[EXIM_DRIVERNAME_MAX];
4493 const uschar * p = readconf_readname(name, sizeof(name), acl_line);
4495 if (isupper(*name) && *p == '=')
4497 if (!macro_read_assignment(acl_line)) exim_exit(EXIT_FAILURE);
4498 acl_line = get_config_line();
4502 if (*p != ':' || name[0] == 0)
4503 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing or malformed ACL name");
4505 node = store_get_perm(sizeof(tree_node) + Ustrlen(name), name);
4506 Ustrcpy(node->name, name);
4507 if (!tree_insertnode(&acl_anchor, node))
4508 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4509 "there are two ACLs called \"%s\"", name);
4511 node->data.ptr = acl_read(acl_callback, &error);
4513 if (node->data.ptr == NULL && error != NULL)
4514 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "error in ACL: %s", error);
4520 /*************************************************
4521 * Read configuration for local_scan() *
4522 *************************************************/
4524 /* This function is called after "begin local_scan" is encountered in the
4525 configuration file. If the local_scan() function allows for configuration
4526 options, we can process them. Otherwise, we expire in a panic.
4533 local_scan_init(void)
4535 #ifndef LOCAL_SCAN_HAS_OPTIONS
4536 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "local_scan() options not supported: "
4537 "(LOCAL_SCAN_HAS_OPTIONS not defined in Local/Makefile)");
4541 while ((p = get_config_line()))
4542 (void) readconf_handle_option(p, local_scan_options, local_scan_options_count,
4543 NULL, US"local_scan option \"%s\" unknown");
4549 /*************************************************
4550 * Read rest of configuration (after main) *
4551 *************************************************/
4553 /* This function reads the rest of the runtime configuration, after the main
4554 configuration. It is called only when actually needed. Each subsequent section
4555 of the configuration starts with a line of the form
4559 where the name is "routers", "transports", etc. A section is terminated by
4560 hitting the next "begin" line, and the next name is left in next_section.
4561 Because it may confuse people as to whether the names are singular or plural,
4562 we add "s" if it's missing. There is always enough room in next_section for
4563 this. This function is basically just a switch.
4569 static uschar *section_list[] = {
4583 while(next_section[0] != 0)
4587 int last = nelem(section_list);
4589 int n = Ustrlen(next_section);
4591 READCONF_DEBUG fprintf(stderr, "%s: %s\n", __FUNCTION__, next_section);
4592 if (tolower(next_section[n-1]) != 's') Ustrcpy(next_section+n, US"s");
4596 int c = strcmpic(next_section, section_list[mid]);
4598 if (c > 0) first = mid + 1; else last = mid;
4600 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4601 "\"%.*s\" is not a known configuration section name", n, next_section);
4602 mid = (last + first)/2;
4606 if (((had ^= bit) & bit) == 0)
4607 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4608 "\"%.*s\" section is repeated in the configuration file", n,
4613 case 0: readconf_acl(); break;
4614 case 1: auths_init(); break;
4615 case 2: local_scan_init(); break;
4616 case 3: readconf_retries(); break;
4617 case 4: readconf_rewrites(); break;
4618 case 5: route_init(); break;
4619 case 6: transport_init(); break;
4623 (void)fclose(config_file);
4624 config_lineno = 0; /* Ensure we don't log a spurious position */
4627 /* Init the storage for the pre-parsed config lines */
4629 readconf_save_config(const uschar *s)
4631 save_config_line(string_sprintf("# Exim Configuration (%s)",
4632 f.running_in_test_harness ? US"X" : s));
4636 save_config_position(const uschar *file, int line)
4638 save_config_line(string_sprintf("# %d \"%s\"", line, file));
4641 /* Append a pre-parsed logical line to the config lines store,
4642 this operates on a global (static) list that holds all the pre-parsed
4643 config lines, we do no further processing here, output formatting and
4644 honouring of <hide> or macros will be done during output */
4647 save_config_line(const uschar* line)
4649 static config_line_item *current;
4650 config_line_item *next;
4652 next = (config_line_item*) store_get(sizeof(config_line_item), GET_UNTAINTED);
4653 next->line = string_copy(line);
4656 if (!config_lines) config_lines = next;
4657 else current->next = next;
4662 /* List the parsed config lines, care about nice formatting and
4663 hide the <hide> values unless we're the admin user */
4665 print_config(BOOL admin, BOOL terse)
4667 const int TS = terse ? 0 : 2;
4671 for (const config_line_item * i = config_lines; i; i = i->next)
4673 uschar * current, * p;
4675 if (r) store_reset(r);
4678 /* skip over to the first non-space */
4679 current = string_copy(i->line);
4680 if (!Uskip_whitespace(¤t))
4683 /* Collapse runs of spaces. We stop this if we encounter one of the
4684 following characters: "'$, as this may indicate careful formatting */
4686 for (p = current; *p; p++) if (isspace(*p))
4689 if (*p != ' ') *p = ' ';
4691 Uskip_whitespace(&p);
4694 memmove(p+1, next, Ustrlen(next)+1);
4696 if (*next == '"' || *next == '\'' || *next == '$')
4701 if (current[0] == '#')
4704 /* begin lines are left aligned */
4705 else if (Ustrncmp(current, "begin", 5) == 0 && isspace(current[5]))
4707 if (!terse) puts("");
4712 /* router/acl/transport block names */
4713 else if (current[Ustrlen(current)-1] == ':' && !Ustrchr(current, '='))
4715 if (!terse) puts("");
4716 printf("%*s%s\n", TS, "", current);
4720 /* hidden lines (all MACROS or lines prefixed with "hide") */
4722 && ( isupper(*current)
4723 || Ustrncmp(current, "hide", 4) == 0 && isspace(current[4])
4727 if ((p = Ustrchr(current, '=')))
4730 printf("%*s%s= %s\n", indent, "", current, CCS hidden);
4732 /* e.g.: hide split_spool_directory */
4734 printf("%*s\n", indent, CCS hidden);
4738 /* rest is public */
4739 printf("%*s%s\n", indent, "", current);
4741 if (r) store_reset(r);
4744 #endif /*!MACRO_PREDEF*/
4747 /* End of readconf.c */