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