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