tidying
[exim.git] / src / src / readconf.c
1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 /* Functions for reading the configuration file, and for displaying
9 overall configuration values. Thanks to Brian Candler for the original
10 implementation of the conditional .ifdef etc. */
11
12 #include "exim.h"
13
14 #ifdef MACRO_PREDEF
15 # include "macro_predef.h"
16 #endif
17
18 #define READCONF_DEBUG if (FALSE) /* Change to TRUE to enable */
19
20
21 static uschar * syslog_facility_str;
22 static void fn_smtp_receive_timeout(const uschar *, const uschar *);
23
24 /*************************************************
25 * Main configuration options *
26 *************************************************/
27
28 /* The list of options that can be set in the main configuration file. This
29 must be in alphabetic order because it is searched by binary chop. */
30
31 static optionlist optionlist_config[] = {
32 { "*set_exim_group", opt_bool|opt_hidden, &exim_gid_set },
33 { "*set_exim_user", opt_bool|opt_hidden, &exim_uid_set },
34 { "*set_system_filter_group", opt_bool|opt_hidden, &system_filter_gid_set },
35 { "*set_system_filter_user", opt_bool|opt_hidden, &system_filter_uid_set },
36 { "accept_8bitmime", opt_bool, &accept_8bitmime },
37 { "acl_not_smtp", opt_stringptr, &acl_not_smtp },
38 #ifdef WITH_CONTENT_SCAN
39 { "acl_not_smtp_mime", opt_stringptr, &acl_not_smtp_mime },
40 #endif
41 { "acl_not_smtp_start", opt_stringptr, &acl_not_smtp_start },
42 { "acl_smtp_auth", opt_stringptr, &acl_smtp_auth },
43 { "acl_smtp_connect", opt_stringptr, &acl_smtp_connect },
44 { "acl_smtp_data", opt_stringptr, &acl_smtp_data },
45 #ifndef DISABLE_PRDR
46 { "acl_smtp_data_prdr", opt_stringptr, &acl_smtp_data_prdr },
47 #endif
48 #ifndef DISABLE_DKIM
49 { "acl_smtp_dkim", opt_stringptr, &acl_smtp_dkim },
50 #endif
51 { "acl_smtp_etrn", opt_stringptr, &acl_smtp_etrn },
52 { "acl_smtp_expn", opt_stringptr, &acl_smtp_expn },
53 { "acl_smtp_helo", opt_stringptr, &acl_smtp_helo },
54 { "acl_smtp_mail", opt_stringptr, &acl_smtp_mail },
55 { "acl_smtp_mailauth", opt_stringptr, &acl_smtp_mailauth },
56 #ifdef WITH_CONTENT_SCAN
57 { "acl_smtp_mime", opt_stringptr, &acl_smtp_mime },
58 #endif
59 { "acl_smtp_notquit", opt_stringptr, &acl_smtp_notquit },
60 { "acl_smtp_predata", opt_stringptr, &acl_smtp_predata },
61 { "acl_smtp_quit", opt_stringptr, &acl_smtp_quit },
62 { "acl_smtp_rcpt", opt_stringptr, &acl_smtp_rcpt },
63 #ifdef SUPPORT_TLS
64 { "acl_smtp_starttls", opt_stringptr, &acl_smtp_starttls },
65 #endif
66 { "acl_smtp_vrfy", opt_stringptr, &acl_smtp_vrfy },
67 { "add_environment", opt_stringptr, &add_environment },
68 { "admin_groups", opt_gidlist, &admin_groups },
69 { "allow_domain_literals", opt_bool, &allow_domain_literals },
70 { "allow_mx_to_ip", opt_bool, &allow_mx_to_ip },
71 { "allow_utf8_domains", opt_bool, &allow_utf8_domains },
72 { "auth_advertise_hosts", opt_stringptr, &auth_advertise_hosts },
73 { "auto_thaw", opt_time, &auto_thaw },
74 #ifdef WITH_CONTENT_SCAN
75 { "av_scanner", opt_stringptr, &av_scanner },
76 #endif
77 { "bi_command", opt_stringptr, &bi_command },
78 #ifdef EXPERIMENTAL_BRIGHTMAIL
79 { "bmi_config_file", opt_stringptr, &bmi_config_file },
80 #endif
81 { "bounce_message_file", opt_stringptr, &bounce_message_file },
82 { "bounce_message_text", opt_stringptr, &bounce_message_text },
83 { "bounce_return_body", opt_bool, &bounce_return_body },
84 { "bounce_return_linesize_limit", opt_mkint, &bounce_return_linesize_limit },
85 { "bounce_return_message", opt_bool, &bounce_return_message },
86 { "bounce_return_size_limit", opt_mkint, &bounce_return_size_limit },
87 { "bounce_sender_authentication",opt_stringptr,&bounce_sender_authentication },
88 { "callout_domain_negative_expire", opt_time, &callout_cache_domain_negative_expire },
89 { "callout_domain_positive_expire", opt_time, &callout_cache_domain_positive_expire },
90 { "callout_negative_expire", opt_time, &callout_cache_negative_expire },
91 { "callout_positive_expire", opt_time, &callout_cache_positive_expire },
92 { "callout_random_local_part",opt_stringptr, &callout_random_local_part },
93 { "check_log_inodes", opt_int, &check_log_inodes },
94 { "check_log_space", opt_Kint, &check_log_space },
95 { "check_rfc2047_length", opt_bool, &check_rfc2047_length },
96 { "check_spool_inodes", opt_int, &check_spool_inodes },
97 { "check_spool_space", opt_Kint, &check_spool_space },
98 { "chunking_advertise_hosts", opt_stringptr, &chunking_advertise_hosts },
99 { "commandline_checks_require_admin", opt_bool,&commandline_checks_require_admin },
100 { "daemon_smtp_port", opt_stringptr|opt_hidden, &daemon_smtp_port },
101 { "daemon_smtp_ports", opt_stringptr, &daemon_smtp_port },
102 { "daemon_startup_retries", opt_int, &daemon_startup_retries },
103 { "daemon_startup_sleep", opt_time, &daemon_startup_sleep },
104 #ifdef EXPERIMENTAL_DCC
105 { "dcc_direct_add_header", opt_bool, &dcc_direct_add_header },
106 { "dccifd_address", opt_stringptr, &dccifd_address },
107 { "dccifd_options", opt_stringptr, &dccifd_options },
108 #endif
109 { "debug_store", opt_bool, &debug_store },
110 { "delay_warning", opt_timelist, &delay_warning },
111 { "delay_warning_condition", opt_stringptr, &delay_warning_condition },
112 { "deliver_drop_privilege", opt_bool, &deliver_drop_privilege },
113 { "deliver_queue_load_max", opt_fixed, &deliver_queue_load_max },
114 { "delivery_date_remove", opt_bool, &delivery_date_remove },
115 #ifdef ENABLE_DISABLE_FSYNC
116 { "disable_fsync", opt_bool, &disable_fsync },
117 #endif
118 { "disable_ipv6", opt_bool, &disable_ipv6 },
119 #ifndef DISABLE_DKIM
120 { "dkim_verify_signers", opt_stringptr, &dkim_verify_signers },
121 #endif
122 #ifdef EXPERIMENTAL_DMARC
123 { "dmarc_forensic_sender", opt_stringptr, &dmarc_forensic_sender },
124 { "dmarc_history_file", opt_stringptr, &dmarc_history_file },
125 { "dmarc_tld_file", opt_stringptr, &dmarc_tld_file },
126 #endif
127 { "dns_again_means_nonexist", opt_stringptr, &dns_again_means_nonexist },
128 { "dns_check_names_pattern", opt_stringptr, &check_dns_names_pattern },
129 { "dns_cname_loops", opt_int, &dns_cname_loops },
130 { "dns_csa_search_limit", opt_int, &dns_csa_search_limit },
131 { "dns_csa_use_reverse", opt_bool, &dns_csa_use_reverse },
132 { "dns_dnssec_ok", opt_int, &dns_dnssec_ok },
133 { "dns_ipv4_lookup", opt_stringptr, &dns_ipv4_lookup },
134 { "dns_retrans", opt_time, &dns_retrans },
135 { "dns_retry", opt_int, &dns_retry },
136 { "dns_trust_aa", opt_stringptr, &dns_trust_aa },
137 { "dns_use_edns0", opt_int, &dns_use_edns0 },
138 /* This option is now a no-op, retained for compatibility */
139 { "drop_cr", opt_bool, &drop_cr },
140 /*********************************************************/
141 { "dsn_advertise_hosts", opt_stringptr, &dsn_advertise_hosts },
142 { "dsn_from", opt_stringptr, &dsn_from },
143 { "envelope_to_remove", opt_bool, &envelope_to_remove },
144 { "errors_copy", opt_stringptr, &errors_copy },
145 { "errors_reply_to", opt_stringptr, &errors_reply_to },
146 #ifndef DISABLE_EVENT
147 { "event_action", opt_stringptr, &event_action },
148 #endif
149 { "exim_group", opt_gid, &exim_gid },
150 { "exim_path", opt_stringptr, &exim_path },
151 { "exim_user", opt_uid, &exim_uid },
152 { "extra_local_interfaces", opt_stringptr, &extra_local_interfaces },
153 { "extract_addresses_remove_arguments", opt_bool, &extract_addresses_remove_arguments },
154 { "finduser_retries", opt_int, &finduser_retries },
155 { "freeze_tell", opt_stringptr, &freeze_tell },
156 { "gecos_name", opt_stringptr, &gecos_name },
157 { "gecos_pattern", opt_stringptr, &gecos_pattern },
158 #ifdef SUPPORT_TLS
159 { "gnutls_allow_auto_pkcs11", opt_bool, &gnutls_allow_auto_pkcs11 },
160 { "gnutls_compat_mode", opt_bool, &gnutls_compat_mode },
161 #endif
162 { "header_line_maxsize", opt_int, &header_line_maxsize },
163 { "header_maxsize", opt_int, &header_maxsize },
164 { "headers_charset", opt_stringptr, &headers_charset },
165 { "helo_accept_junk_hosts", opt_stringptr, &helo_accept_junk_hosts },
166 { "helo_allow_chars", opt_stringptr, &helo_allow_chars },
167 { "helo_lookup_domains", opt_stringptr, &helo_lookup_domains },
168 { "helo_try_verify_hosts", opt_stringptr, &helo_try_verify_hosts },
169 { "helo_verify_hosts", opt_stringptr, &helo_verify_hosts },
170 { "hold_domains", opt_stringptr, &hold_domains },
171 { "host_lookup", opt_stringptr, &host_lookup },
172 { "host_lookup_order", opt_stringptr, &host_lookup_order },
173 { "host_reject_connection", opt_stringptr, &host_reject_connection },
174 { "hosts_connection_nolog", opt_stringptr, &hosts_connection_nolog },
175 #ifdef SUPPORT_PROXY
176 { "hosts_proxy", opt_stringptr, &hosts_proxy },
177 #endif
178 { "hosts_treat_as_local", opt_stringptr, &hosts_treat_as_local },
179 #ifdef LOOKUP_IBASE
180 { "ibase_servers", opt_stringptr, &ibase_servers },
181 #endif
182 { "ignore_bounce_errors_after", opt_time, &ignore_bounce_errors_after },
183 { "ignore_fromline_hosts", opt_stringptr, &ignore_fromline_hosts },
184 { "ignore_fromline_local", opt_bool, &ignore_fromline_local },
185 { "keep_environment", opt_stringptr, &keep_environment },
186 { "keep_malformed", opt_time, &keep_malformed },
187 #ifdef LOOKUP_LDAP
188 { "ldap_ca_cert_dir", opt_stringptr, &eldap_ca_cert_dir },
189 { "ldap_ca_cert_file", opt_stringptr, &eldap_ca_cert_file },
190 { "ldap_cert_file", opt_stringptr, &eldap_cert_file },
191 { "ldap_cert_key", opt_stringptr, &eldap_cert_key },
192 { "ldap_cipher_suite", opt_stringptr, &eldap_cipher_suite },
193 { "ldap_default_servers", opt_stringptr, &eldap_default_servers },
194 { "ldap_require_cert", opt_stringptr, &eldap_require_cert },
195 { "ldap_start_tls", opt_bool, &eldap_start_tls },
196 { "ldap_version", opt_int, &eldap_version },
197 #endif
198 { "local_from_check", opt_bool, &local_from_check },
199 { "local_from_prefix", opt_stringptr, &local_from_prefix },
200 { "local_from_suffix", opt_stringptr, &local_from_suffix },
201 { "local_interfaces", opt_stringptr, &local_interfaces },
202 #ifdef HAVE_LOCAL_SCAN
203 { "local_scan_timeout", opt_time, &local_scan_timeout },
204 #endif
205 { "local_sender_retain", opt_bool, &local_sender_retain },
206 { "localhost_number", opt_stringptr, &host_number_string },
207 { "log_file_path", opt_stringptr, &log_file_path },
208 { "log_selector", opt_stringptr, &log_selector_string },
209 { "log_timezone", opt_bool, &log_timezone },
210 { "lookup_open_max", opt_int, &lookup_open_max },
211 { "max_username_length", opt_int, &max_username_length },
212 { "message_body_newlines", opt_bool, &message_body_newlines },
213 { "message_body_visible", opt_mkint, &message_body_visible },
214 { "message_id_header_domain", opt_stringptr, &message_id_domain },
215 { "message_id_header_text", opt_stringptr, &message_id_text },
216 { "message_logs", opt_bool, &message_logs },
217 { "message_size_limit", opt_stringptr, &message_size_limit },
218 #ifdef SUPPORT_MOVE_FROZEN_MESSAGES
219 { "move_frozen_messages", opt_bool, &move_frozen_messages },
220 #endif
221 { "mua_wrapper", opt_bool, &mua_wrapper },
222 #ifdef LOOKUP_MYSQL
223 { "mysql_servers", opt_stringptr, &mysql_servers },
224 #endif
225 { "never_users", opt_uidlist, &never_users },
226 #ifdef SUPPORT_TLS
227 { "openssl_options", opt_stringptr, &openssl_options },
228 #endif
229 #ifdef LOOKUP_ORACLE
230 { "oracle_servers", opt_stringptr, &oracle_servers },
231 #endif
232 { "percent_hack_domains", opt_stringptr, &percent_hack_domains },
233 #ifdef EXIM_PERL
234 { "perl_at_start", opt_bool, &opt_perl_at_start },
235 { "perl_startup", opt_stringptr, &opt_perl_startup },
236 { "perl_taintmode", opt_bool, &opt_perl_taintmode },
237 #endif
238 #ifdef LOOKUP_PGSQL
239 { "pgsql_servers", opt_stringptr, &pgsql_servers },
240 #endif
241 { "pid_file_path", opt_stringptr, &pid_file_path },
242 { "pipelining_advertise_hosts", opt_stringptr, &pipelining_advertise_hosts },
243 #ifndef DISABLE_PRDR
244 { "prdr_enable", opt_bool, &prdr_enable },
245 #endif
246 { "preserve_message_logs", opt_bool, &preserve_message_logs },
247 { "primary_hostname", opt_stringptr, &primary_hostname },
248 { "print_topbitchars", opt_bool, &print_topbitchars },
249 { "process_log_path", opt_stringptr, &process_log_path },
250 { "prod_requires_admin", opt_bool, &prod_requires_admin },
251 { "qualify_domain", opt_stringptr, &qualify_domain_sender },
252 { "qualify_recipient", opt_stringptr, &qualify_domain_recipient },
253 { "queue_domains", opt_stringptr, &queue_domains },
254 { "queue_list_requires_admin",opt_bool, &queue_list_requires_admin },
255 { "queue_only", opt_bool, &queue_only },
256 { "queue_only_file", opt_stringptr, &queue_only_file },
257 { "queue_only_load", opt_fixed, &queue_only_load },
258 { "queue_only_load_latch", opt_bool, &queue_only_load_latch },
259 { "queue_only_override", opt_bool, &queue_only_override },
260 { "queue_run_in_order", opt_bool, &queue_run_in_order },
261 { "queue_run_max", opt_stringptr, &queue_run_max },
262 { "queue_smtp_domains", opt_stringptr, &queue_smtp_domains },
263 { "receive_timeout", opt_time, &receive_timeout },
264 { "received_header_text", opt_stringptr, &received_header_text },
265 { "received_headers_max", opt_int, &received_headers_max },
266 { "recipient_unqualified_hosts", opt_stringptr, &recipient_unqualified_hosts },
267 { "recipients_max", opt_int, &recipients_max },
268 { "recipients_max_reject", opt_bool, &recipients_max_reject },
269 #ifdef LOOKUP_REDIS
270 { "redis_servers", opt_stringptr, &redis_servers },
271 #endif
272 { "remote_max_parallel", opt_int, &remote_max_parallel },
273 { "remote_sort_domains", opt_stringptr, &remote_sort_domains },
274 { "retry_data_expire", opt_time, &retry_data_expire },
275 { "retry_interval_max", opt_time, &retry_interval_max },
276 { "return_path_remove", opt_bool, &return_path_remove },
277 { "return_size_limit", opt_mkint|opt_hidden, &bounce_return_size_limit },
278 { "rfc1413_hosts", opt_stringptr, &rfc1413_hosts },
279 { "rfc1413_query_timeout", opt_time, &rfc1413_query_timeout },
280 { "sender_unqualified_hosts", opt_stringptr, &sender_unqualified_hosts },
281 { "slow_lookup_log", opt_int, &slow_lookup_log },
282 { "smtp_accept_keepalive", opt_bool, &smtp_accept_keepalive },
283 { "smtp_accept_max", opt_int, &smtp_accept_max },
284 { "smtp_accept_max_nonmail", opt_int, &smtp_accept_max_nonmail },
285 { "smtp_accept_max_nonmail_hosts", opt_stringptr, &smtp_accept_max_nonmail_hosts },
286 { "smtp_accept_max_per_connection", opt_int, &smtp_accept_max_per_connection },
287 { "smtp_accept_max_per_host", opt_stringptr, &smtp_accept_max_per_host },
288 { "smtp_accept_queue", opt_int, &smtp_accept_queue },
289 { "smtp_accept_queue_per_connection", opt_int, &smtp_accept_queue_per_connection },
290 { "smtp_accept_reserve", opt_int, &smtp_accept_reserve },
291 { "smtp_active_hostname", opt_stringptr, &raw_active_hostname },
292 { "smtp_banner", opt_stringptr, &smtp_banner },
293 { "smtp_check_spool_space", opt_bool, &smtp_check_spool_space },
294 { "smtp_connect_backlog", opt_int, &smtp_connect_backlog },
295 { "smtp_enforce_sync", opt_bool, &smtp_enforce_sync },
296 { "smtp_etrn_command", opt_stringptr, &smtp_etrn_command },
297 { "smtp_etrn_serialize", opt_bool, &smtp_etrn_serialize },
298 { "smtp_load_reserve", opt_fixed, &smtp_load_reserve },
299 { "smtp_max_synprot_errors", opt_int, &smtp_max_synprot_errors },
300 { "smtp_max_unknown_commands",opt_int, &smtp_max_unknown_commands },
301 { "smtp_ratelimit_hosts", opt_stringptr, &smtp_ratelimit_hosts },
302 { "smtp_ratelimit_mail", opt_stringptr, &smtp_ratelimit_mail },
303 { "smtp_ratelimit_rcpt", opt_stringptr, &smtp_ratelimit_rcpt },
304 { "smtp_receive_timeout", opt_func, &fn_smtp_receive_timeout },
305 { "smtp_reserve_hosts", opt_stringptr, &smtp_reserve_hosts },
306 { "smtp_return_error_details",opt_bool, &smtp_return_error_details },
307 #ifdef SUPPORT_I18N
308 { "smtputf8_advertise_hosts", opt_stringptr, &smtputf8_advertise_hosts },
309 #endif
310 #ifdef WITH_CONTENT_SCAN
311 { "spamd_address", opt_stringptr, &spamd_address },
312 #endif
313 #ifdef SUPPORT_SPF
314 { "spf_guess", opt_stringptr, &spf_guess },
315 #endif
316 { "split_spool_directory", opt_bool, &split_spool_directory },
317 { "spool_directory", opt_stringptr, &spool_directory },
318 { "spool_wireformat", opt_bool, &spool_wireformat },
319 #ifdef LOOKUP_SQLITE
320 { "sqlite_lock_timeout", opt_int, &sqlite_lock_timeout },
321 #endif
322 #ifdef EXPERIMENTAL_SRS
323 { "srs_config", opt_stringptr, &srs_config },
324 { "srs_hashlength", opt_int, &srs_hashlength },
325 { "srs_hashmin", opt_int, &srs_hashmin },
326 { "srs_maxage", opt_int, &srs_maxage },
327 { "srs_secrets", opt_stringptr, &srs_secrets },
328 { "srs_usehash", opt_bool, &srs_usehash },
329 { "srs_usetimestamp", opt_bool, &srs_usetimestamp },
330 #endif
331 { "strict_acl_vars", opt_bool, &strict_acl_vars },
332 { "strip_excess_angle_brackets", opt_bool, &strip_excess_angle_brackets },
333 { "strip_trailing_dot", opt_bool, &strip_trailing_dot },
334 { "syslog_duplication", opt_bool, &syslog_duplication },
335 { "syslog_facility", opt_stringptr, &syslog_facility_str },
336 { "syslog_pid", opt_bool, &syslog_pid },
337 { "syslog_processname", opt_stringptr, &syslog_processname },
338 { "syslog_timestamp", opt_bool, &syslog_timestamp },
339 { "system_filter", opt_stringptr, &system_filter },
340 { "system_filter_directory_transport", opt_stringptr,&system_filter_directory_transport },
341 { "system_filter_file_transport",opt_stringptr,&system_filter_file_transport },
342 { "system_filter_group", opt_gid, &system_filter_gid },
343 { "system_filter_pipe_transport",opt_stringptr,&system_filter_pipe_transport },
344 { "system_filter_reply_transport",opt_stringptr,&system_filter_reply_transport },
345 { "system_filter_user", opt_uid, &system_filter_uid },
346 { "tcp_nodelay", opt_bool, &tcp_nodelay },
347 #ifdef USE_TCP_WRAPPERS
348 { "tcp_wrappers_daemon_name", opt_stringptr, &tcp_wrappers_daemon_name },
349 #endif
350 { "timeout_frozen_after", opt_time, &timeout_frozen_after },
351 { "timezone", opt_stringptr, &timezone_string },
352 { "tls_advertise_hosts", opt_stringptr, &tls_advertise_hosts },
353 #ifdef SUPPORT_TLS
354 # ifdef EXPERIMENTAL_REQUIRETLS
355 { "tls_advertise_requiretls", opt_stringptr, &tls_advertise_requiretls },
356 # endif
357 { "tls_certificate", opt_stringptr, &tls_certificate },
358 { "tls_crl", opt_stringptr, &tls_crl },
359 { "tls_dh_max_bits", opt_int, &tls_dh_max_bits },
360 { "tls_dhparam", opt_stringptr, &tls_dhparam },
361 { "tls_eccurve", opt_stringptr, &tls_eccurve },
362 # ifndef DISABLE_OCSP
363 { "tls_ocsp_file", opt_stringptr, &tls_ocsp_file },
364 # endif
365 { "tls_on_connect_ports", opt_stringptr, &tls_in.on_connect_ports },
366 { "tls_privatekey", opt_stringptr, &tls_privatekey },
367 { "tls_remember_esmtp", opt_bool, &tls_remember_esmtp },
368 { "tls_require_ciphers", opt_stringptr, &tls_require_ciphers },
369 { "tls_try_verify_hosts", opt_stringptr, &tls_try_verify_hosts },
370 { "tls_verify_certificates", opt_stringptr, &tls_verify_certificates },
371 { "tls_verify_hosts", opt_stringptr, &tls_verify_hosts },
372 #endif
373 { "trusted_groups", opt_gidlist, &trusted_groups },
374 { "trusted_users", opt_uidlist, &trusted_users },
375 { "unknown_login", opt_stringptr, &unknown_login },
376 { "unknown_username", opt_stringptr, &unknown_username },
377 { "untrusted_set_sender", opt_stringptr, &untrusted_set_sender },
378 { "uucp_from_pattern", opt_stringptr, &uucp_from_pattern },
379 { "uucp_from_sender", opt_stringptr, &uucp_from_sender },
380 { "warn_message_file", opt_stringptr, &warn_message_file },
381 { "write_rejectlog", opt_bool, &write_rejectlog }
382 };
383
384 #ifndef MACRO_PREDEF
385 static int optionlist_config_size = nelem(optionlist_config);
386 #endif
387
388
389 #ifdef MACRO_PREDEF
390
391 static void fn_smtp_receive_timeout(const uschar * name, const uschar * str) {/*Dummy*/}
392
393 void
394 options_main(void)
395 {
396 options_from_list(optionlist_config, nelem(optionlist_config), US"MAIN", NULL);
397 }
398
399 void
400 options_auths(void)
401 {
402 struct auth_info * ai;
403 uschar buf[64];
404
405 options_from_list(optionlist_auths, optionlist_auths_size, US"AUTHENTICATORS", NULL);
406
407 for (ai = auths_available; ai->driver_name[0]; ai++)
408 {
409 spf(buf, sizeof(buf), US"_DRIVER_AUTHENTICATOR_%T", ai->driver_name);
410 builtin_macro_create(buf);
411 options_from_list(ai->options, (unsigned)*ai->options_count, US"AUTHENTICATOR", ai->driver_name);
412 }
413 }
414
415 void
416 options_logging(void)
417 {
418 bit_table * bp;
419 uschar buf[64];
420
421 for (bp = log_options; bp < log_options + log_options_count; bp++)
422 {
423 spf(buf, sizeof(buf), US"_LOG_%T", bp->name);
424 builtin_macro_create(buf);
425 }
426 }
427
428
429 #else /*!MACRO_PREDEF*/
430
431 extern char **environ;
432
433 static void save_config_line(const uschar* line);
434 static void save_config_position(const uschar *file, int line);
435 static void print_config(BOOL admin, BOOL terse);
436
437
438 #define CSTATE_STACK_SIZE 10
439
440 const uschar *config_directory = NULL;
441
442
443 /* Structure for chain (stack) of .included files */
444
445 typedef struct config_file_item {
446 struct config_file_item *next;
447 const uschar *filename;
448 const uschar *directory;
449 FILE *file;
450 int lineno;
451 } config_file_item;
452
453 /* Structure for chain of configuration lines (-bP config) */
454
455 typedef struct config_line_item {
456 struct config_line_item *next;
457 uschar *line;
458 } config_line_item;
459
460 static config_line_item* config_lines;
461
462 /* Structure of table of conditional words and their state transitions */
463
464 typedef struct cond_item {
465 uschar *name;
466 int namelen;
467 int action1;
468 int action2;
469 int pushpop;
470 } cond_item;
471
472 /* Structure of table of syslog facility names and values */
473
474 typedef struct syslog_fac_item {
475 uschar *name;
476 int value;
477 } syslog_fac_item;
478
479 /* constants */
480 static const char * const hidden = "<value not displayable>";
481
482 /* Static variables */
483
484 static config_file_item *config_file_stack = NULL; /* For includes */
485
486 static uschar *syslog_facility_str = NULL;
487 static uschar next_section[24];
488 static uschar time_buffer[24];
489
490 /* State variables for conditional loading (.ifdef / .else / .endif) */
491
492 static int cstate = 0;
493 static int cstate_stack_ptr = -1;
494 static int cstate_stack[CSTATE_STACK_SIZE];
495
496 /* Table of state transitions for handling conditional inclusions. There are
497 four possible state transitions:
498
499 .ifdef true
500 .ifdef false
501 .elifdef true (or .else)
502 .elifdef false
503
504 .endif just causes the previous cstate to be popped off the stack */
505
506 static int next_cstate[3][4] =
507 {
508 /* State 0: reading from file, or reading until next .else or .endif */
509 { 0, 1, 2, 2 },
510 /* State 1: condition failed, skipping until next .else or .endif */
511 { 2, 2, 0, 1 },
512 /* State 2: skipping until .endif */
513 { 2, 2, 2, 2 },
514 };
515
516 /* Table of conditionals and the states to set. For each name, there are four
517 values: the length of the name (to save computing it each time), the state to
518 set if a macro was found in the line, the state to set if a macro was not found
519 in the line, and a stack manipulation setting which is:
520
521 -1 pull state value off the stack
522 0 don't alter the stack
523 +1 push value onto stack, before setting new state
524 */
525
526 static cond_item cond_list[] = {
527 { US"ifdef", 5, 0, 1, 1 },
528 { US"ifndef", 6, 1, 0, 1 },
529 { US"elifdef", 7, 2, 3, 0 },
530 { US"elifndef", 8, 3, 2, 0 },
531 { US"else", 4, 2, 2, 0 },
532 { US"endif", 5, 0, 0, -1 }
533 };
534
535 static int cond_list_size = sizeof(cond_list)/sizeof(cond_item);
536
537 /* Table of syslog facility names and their values */
538
539 static syslog_fac_item syslog_list[] = {
540 { US"mail", LOG_MAIL },
541 { US"user", LOG_USER },
542 { US"news", LOG_NEWS },
543 { US"uucp", LOG_UUCP },
544 { US"local0", LOG_LOCAL0 },
545 { US"local1", LOG_LOCAL1 },
546 { US"local2", LOG_LOCAL2 },
547 { US"local3", LOG_LOCAL3 },
548 { US"local4", LOG_LOCAL4 },
549 { US"local5", LOG_LOCAL5 },
550 { US"local6", LOG_LOCAL6 },
551 { US"local7", LOG_LOCAL7 },
552 { US"daemon", LOG_DAEMON }
553 };
554
555 static int syslog_list_size = sizeof(syslog_list)/sizeof(syslog_fac_item);
556
557
558
559
560 /*************************************************
561 * Find the name of an option *
562 *************************************************/
563
564 /* This function is to aid debugging. Various functions take arguments that are
565 pointer variables in the options table or in option tables for various drivers.
566 For debugging output, it is useful to be able to find the name of the option
567 which is currently being processed. This function finds it, if it exists, by
568 searching the table(s).
569
570 Arguments: a value that is presumed to be in the table above
571 Returns: the option name, or an empty string
572 */
573
574 uschar *
575 readconf_find_option(void *p)
576 {
577 int i;
578 router_instance *r;
579 transport_instance *t;
580
581 for (i = 0; i < nelem(optionlist_config); i++)
582 if (p == optionlist_config[i].value) return US optionlist_config[i].name;
583
584 for (r = routers; r; r = r->next)
585 {
586 router_info *ri = r->info;
587 for (i = 0; i < *ri->options_count; i++)
588 {
589 if ((ri->options[i].type & opt_mask) != opt_stringptr) continue;
590 if (p == CS (r->options_block) + (long int)(ri->options[i].value))
591 return US ri->options[i].name;
592 }
593 }
594
595 for (t = transports; t; t = t->next)
596 {
597 transport_info *ti = t->info;
598 for (i = 0; i < *ti->options_count; i++)
599 {
600 optionlist * op = &ti->options[i];
601 if ((op->type & opt_mask) != opt_stringptr) continue;
602 if (p == ( op->type & opt_public
603 ? CS t
604 : CS t->options_block
605 )
606 + (long int)op->value)
607 return US op->name;
608 }
609 }
610
611 return US"";
612 }
613
614
615
616
617 /*************************************************
618 * Deal with an assignment to a macro *
619 *************************************************/
620
621 /* We have a new definition; append to the list.
622
623 Args:
624 name Name of the macro; will be copied
625 val Expansion result for the macro; will be copied
626 */
627
628 macro_item *
629 macro_create(const uschar * name, const uschar * val, BOOL command_line)
630 {
631 macro_item * m = store_get(sizeof(macro_item));
632
633 READCONF_DEBUG fprintf(stderr, "%s: '%s' '%s'\n", __FUNCTION__, name, val);
634 m->next = NULL;
635 m->command_line = command_line;
636 m->namelen = Ustrlen(name);
637 m->replen = Ustrlen(val);
638 m->name = string_copy(name);
639 m->replacement = string_copy(val);
640 if (mlast)
641 mlast->next = m;
642 else
643 macros = m;
644 mlast = m;
645 if (!macros_user)
646 macros_user = m;
647 return m;
648 }
649
650
651 /* This function is called when a line that starts with an upper case letter is
652 encountered. The argument "line" should contain a complete logical line, and
653 start with the first letter of the macro name. The macro name and the
654 replacement text are extracted and stored. Redefinition of existing,
655 non-command line, macros is permitted using '==' instead of '='.
656
657 Arguments:
658 s points to the start of the logical line
659
660 Returns: FALSE iff fatal error
661 */
662
663 BOOL
664 macro_read_assignment(uschar *s)
665 {
666 uschar name[64];
667 int namelen = 0;
668 BOOL redef = FALSE;
669 macro_item *m;
670
671 while (isalnum(*s) || *s == '_')
672 {
673 if (namelen >= sizeof(name) - 1)
674 {
675 log_write(0, LOG_PANIC|LOG_CONFIG_IN,
676 "macro name too long (maximum is " SIZE_T_FMT " characters)", sizeof(name) - 1);
677 return FALSE;
678 }
679 name[namelen++] = *s++;
680 }
681 name[namelen] = 0;
682
683 while (isspace(*s)) s++;
684 if (*s++ != '=')
685 {
686 log_write(0, LOG_PANIC|LOG_CONFIG_IN, "malformed macro definition");
687 return FALSE;
688 }
689
690 if (*s == '=')
691 {
692 redef = TRUE;
693 s++;
694 }
695 while (isspace(*s)) s++;
696
697 /* If an existing macro of the same name was defined on the command line, we
698 just skip this definition. It's an error to attempt to redefine a macro without
699 redef set to TRUE, or to redefine a macro when it hasn't been defined earlier.
700 It is also an error to define a macro whose name begins with the name of a
701 previously defined macro. This is the requirement that make using a tree
702 for macros hard; we must check all macros for the substring. Perhaps a
703 sorted list, and a bsearch, would work?
704 Note: it is documented that the other way round works. */
705
706 for (m = macros; m; m = m->next)
707 {
708 if (Ustrcmp(m->name, name) == 0)
709 {
710 if (!m->command_line && !redef)
711 {
712 log_write(0, LOG_CONFIG|LOG_PANIC, "macro \"%s\" is already "
713 "defined (use \"==\" if you want to redefine it)", name);
714 return FALSE;
715 }
716 break;
717 }
718
719 if (m->namelen < namelen && Ustrstr(name, m->name) != NULL)
720 {
721 log_write(0, LOG_CONFIG|LOG_PANIC, "\"%s\" cannot be defined as "
722 "a macro because previously defined macro \"%s\" is a substring",
723 name, m->name);
724 return FALSE;
725 }
726
727 /* We cannot have this test, because it is documented that a substring
728 macro is permitted (there is even an example).
729 *
730 * if (m->namelen > namelen && Ustrstr(m->name, name) != NULL)
731 * log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "\"%s\" cannot be defined as "
732 * "a macro because it is a substring of previously defined macro \"%s\"",
733 * name, m->name);
734 */
735 }
736
737 /* Check for an overriding command-line definition. */
738
739 if (m && m->command_line) return TRUE;
740
741 /* Redefinition must refer to an existing macro. */
742
743 if (redef)
744 if (m)
745 {
746 m->replen = Ustrlen(s);
747 m->replacement = string_copy(s);
748 }
749 else
750 {
751 log_write(0, LOG_CONFIG|LOG_PANIC, "can't redefine an undefined macro "
752 "\"%s\"", name);
753 return FALSE;
754 }
755
756 /* We have a new definition. */
757 else
758 (void) macro_create(name, s, FALSE);
759 return TRUE;
760 }
761
762
763
764
765
766 /* Process line for macros. The line is in big_buffer starting at offset len.
767 Expand big_buffer if needed. Handle definitions of new macros, and
768 macro expansions, rewriting the line in the buffer.
769
770 Arguments:
771 len Offset in buffer of start of line
772 newlen Pointer to offset of end of line, updated on return
773 macro_found Pointer to return that a macro was expanded
774
775 Return: pointer to first nonblank char in line
776 */
777
778 uschar *
779 macros_expand(int len, int * newlen, BOOL * macro_found)
780 {
781 uschar * ss = big_buffer + len;
782 uschar * s;
783 macro_item * m;
784
785 /* Find the true start of the physical line - leading spaces are always
786 ignored. */
787
788 while (isspace(*ss)) ss++;
789
790 /* Process the physical line for macros. If this is the start of the logical
791 line, skip over initial text at the start of the line if it starts with an
792 upper case character followed by a sequence of name characters and an equals
793 sign, because that is the definition of a new macro, and we don't do
794 replacement therein. */
795
796 s = ss;
797 if (len == 0 && isupper(*s))
798 {
799 while (isalnum(*s) || *s == '_') s++;
800 while (isspace(*s)) s++;
801 if (*s != '=') s = ss; /* Not a macro definition */
802 }
803
804 /* Skip leading chars which cannot start a macro name, to avoid multiple
805 pointless rescans in Ustrstr calls. */
806
807 while (*s && !isupper(*s) && !(*s == '_' && isupper(s[1]))) s++;
808
809 /* For each defined macro, scan the line (from after XXX= if present),
810 replacing all occurrences of the macro. */
811
812 *macro_found = FALSE;
813 if (*s) for (m = *s == '_' ? macros : macros_user; m; m = m->next)
814 {
815 uschar * p, *pp;
816 uschar * t;
817
818 while (*s && !isupper(*s) && !(*s == '_' && isupper(s[1]))) s++;
819 if (!*s) break;
820
821 t = s;
822 while ((p = Ustrstr(t, m->name)) != NULL)
823 {
824 int moveby;
825
826 READCONF_DEBUG fprintf(stderr, "%s: matched '%s' in '%.*s'\n", __FUNCTION__,
827 m->name, (int) Ustrlen(ss)-1, ss);
828 /* Expand the buffer if necessary */
829
830 while (*newlen - m->namelen + m->replen + 1 > big_buffer_size)
831 {
832 int newsize = big_buffer_size + BIG_BUFFER_SIZE;
833 uschar *newbuffer = store_malloc(newsize);
834 memcpy(newbuffer, big_buffer, *newlen + 1);
835 p = newbuffer + (p - big_buffer);
836 s = newbuffer + (s - big_buffer);
837 ss = newbuffer + (ss - big_buffer);
838 t = newbuffer + (t - big_buffer);
839 big_buffer_size = newsize;
840 store_free(big_buffer);
841 big_buffer = newbuffer;
842 }
843
844 /* Shuffle the remaining characters up or down in the buffer before
845 copying in the replacement text. Don't rescan the replacement for this
846 same macro. */
847
848 pp = p + m->namelen;
849 if ((moveby = m->replen - m->namelen) != 0)
850 {
851 memmove(p + m->replen, pp, (big_buffer + *newlen) - pp + 1);
852 *newlen += moveby;
853 }
854 Ustrncpy(p, m->replacement, m->replen);
855 t = p + m->replen;
856 while (*t && !isupper(*t) && !(*t == '_' && isupper(t[1]))) t++;
857 *macro_found = TRUE;
858 }
859 }
860
861 /* An empty macro replacement at the start of a line could mean that ss no
862 longer points to the first non-blank character. */
863
864 while (isspace(*ss)) ss++;
865 return ss;
866 }
867
868 /*************************************************
869 * Read configuration line *
870 *************************************************/
871
872 /* A logical line of text is read from the configuration file into the big
873 buffer, taking account of macros, .includes, and continuations. The size of
874 big_buffer is increased if necessary. The count of configuration lines is
875 maintained. Physical input lines starting with # (ignoring leading white space,
876 and after macro replacement) and empty logical lines are always ignored.
877 Leading and trailing spaces are removed.
878
879 If we hit a line of the form "begin xxxx", the xxxx is placed in the
880 next_section vector, and the function returns NULL, indicating the end of a
881 configuration section. On end-of-file, NULL is returned with next_section
882 empty.
883
884 Arguments: none
885
886 Returns: a pointer to the first non-blank in the line,
887 or NULL if eof or end of section is reached
888 */
889
890 static uschar *
891 get_config_line(void)
892 {
893 int startoffset = 0; /* To first non-blank char in logical line */
894 int len = 0; /* Of logical line so far */
895 int newlen;
896 uschar *s, *ss;
897 BOOL macro_found;
898
899 /* Loop for handling continuation lines, skipping comments, and dealing with
900 .include files. */
901
902 for (;;)
903 {
904 if (Ufgets(big_buffer+len, big_buffer_size-len, config_file) == NULL)
905 {
906 if (config_file_stack != NULL) /* EOF inside .include */
907 {
908 (void)fclose(config_file);
909 config_file = config_file_stack->file;
910 config_filename = config_file_stack->filename;
911 config_directory = config_file_stack->directory;
912 config_lineno = config_file_stack->lineno;
913 config_file_stack = config_file_stack->next;
914 if (config_lines)
915 save_config_position(config_filename, config_lineno);
916 continue;
917 }
918
919 /* EOF at top level */
920
921 if (cstate_stack_ptr >= 0)
922 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
923 "Unexpected end of configuration file: .endif missing");
924
925 if (len != 0) break; /* EOF after continuation */
926 next_section[0] = 0; /* EOF at start of logical line */
927 return NULL;
928 }
929
930 config_lineno++;
931 newlen = len + Ustrlen(big_buffer + len);
932
933 if (config_lines && config_lineno == 1)
934 save_config_position(config_filename, config_lineno);
935
936 /* Handle pathologically long physical lines - yes, it did happen - by
937 extending big_buffer at this point. The code also copes with very long
938 logical lines. */
939
940 while (newlen == big_buffer_size - 1 && big_buffer[newlen - 1] != '\n')
941 {
942 uschar *newbuffer;
943 big_buffer_size += BIG_BUFFER_SIZE;
944 newbuffer = store_malloc(big_buffer_size);
945
946 /* This use of strcpy is OK because we know that the string in the old
947 buffer is shorter than the new buffer. */
948
949 Ustrcpy(newbuffer, big_buffer);
950 store_free(big_buffer);
951 big_buffer = newbuffer;
952 if (Ufgets(big_buffer+newlen, big_buffer_size-newlen, config_file) == NULL)
953 break;
954 newlen += Ustrlen(big_buffer + newlen);
955 }
956
957 ss = macros_expand(len, &newlen, &macro_found);
958
959 /* Check for comment lines - these are physical lines. */
960
961 if (*ss == '#') continue;
962
963 /* Handle conditionals, which are also applied to physical lines. Conditions
964 are of the form ".ifdef ANYTEXT" and are treated as true if any macro
965 expansion occured on the rest of the line. A preliminary test for the leading
966 '.' saves effort on most lines. */
967
968 if (*ss == '.')
969 {
970 int i;
971
972 /* Search the list of conditional directives */
973
974 for (i = 0; i < cond_list_size; i++)
975 {
976 int n;
977 cond_item *c = cond_list+i;
978 if (Ustrncmp(ss+1, c->name, c->namelen) != 0) continue;
979
980 /* The following character must be white space or end of string */
981
982 n = ss[1 + c->namelen];
983 if (n != ' ' && n != 't' && n != '\n' && n != 0) break;
984
985 /* .ifdef and .ifndef push the current state onto the stack, then set
986 a new one from the table. Stack overflow is an error */
987
988 if (c->pushpop > 0)
989 {
990 if (cstate_stack_ptr >= CSTATE_STACK_SIZE - 1)
991 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
992 ".%s nested too deeply", c->name);
993 cstate_stack[++cstate_stack_ptr] = cstate;
994 cstate = next_cstate[cstate][macro_found? c->action1 : c->action2];
995 }
996
997 /* For any of the others, stack underflow is an error. The next state
998 comes either from the stack (.endif) or from the table. */
999
1000 else
1001 {
1002 if (cstate_stack_ptr < 0)
1003 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1004 ".%s without matching .ifdef", c->name);
1005 cstate = (c->pushpop < 0)? cstate_stack[cstate_stack_ptr--] :
1006 next_cstate[cstate][macro_found? c->action1 : c->action2];
1007 }
1008
1009 /* Having dealt with a directive, break the loop */
1010
1011 break;
1012 }
1013
1014 /* If we have handled a conditional directive, continue with the next
1015 physical line. Otherwise, fall through. */
1016
1017 if (i < cond_list_size) continue;
1018 }
1019
1020 /* If the conditional state is not 0 (actively using these lines), ignore
1021 this input line. */
1022
1023 if (cstate != 0) continue; /* Conditional skip */
1024
1025 /* Handle .include lines - these are also physical lines. */
1026
1027 if (Ustrncmp(ss, ".include", 8) == 0 &&
1028 (isspace(ss[8]) ||
1029 (Ustrncmp(ss+8, "_if_exists", 10) == 0 && isspace(ss[18]))))
1030 {
1031 uschar *t;
1032 int include_if_exists = isspace(ss[8])? 0 : 10;
1033 config_file_item *save;
1034 struct stat statbuf;
1035
1036 ss += 9 + include_if_exists;
1037 while (isspace(*ss)) ss++;
1038 t = ss + Ustrlen(ss);
1039 while (t > ss && isspace(t[-1])) t--;
1040 if (*ss == '\"' && t[-1] == '\"')
1041 {
1042 ss++;
1043 t--;
1044 }
1045 *t = 0;
1046
1047 /* We allow relative file names. For security reasons currently
1048 relative names not allowed with .include_if_exists. For .include_if_exists
1049 we need to check the permissions/ownership of the containing folder */
1050 if (*ss != '/')
1051 if (include_if_exists) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, ".include specifies a non-"
1052 "absolute path \"%s\"", ss);
1053 else
1054 {
1055 gstring * g = string_append(NULL, 3, config_directory, "/", ss);
1056 ss = string_from_gstring(g);
1057 }
1058
1059 if (include_if_exists != 0 && (Ustat(ss, &statbuf) != 0)) continue;
1060
1061 if (config_lines)
1062 save_config_position(config_filename, config_lineno);
1063 save = store_get(sizeof(config_file_item));
1064 save->next = config_file_stack;
1065 config_file_stack = save;
1066 save->file = config_file;
1067 save->filename = config_filename;
1068 save->directory = config_directory;
1069 save->lineno = config_lineno;
1070
1071 if (!(config_file = Ufopen(ss, "rb")))
1072 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to open included "
1073 "configuration file %s", ss);
1074
1075 config_filename = string_copy(ss);
1076 config_directory = string_copyn(ss, CUstrrchr(ss, '/') - ss);
1077 config_lineno = 0;
1078 continue;
1079 }
1080
1081 /* If this is the start of the logical line, remember where the non-blank
1082 data starts. Otherwise shuffle down continuation lines to remove leading
1083 white space. */
1084
1085 if (len == 0)
1086 startoffset = ss - big_buffer;
1087 else
1088 {
1089 s = big_buffer + len;
1090 if (ss > s)
1091 {
1092 memmove(s, ss, (newlen - len) - (ss - s) + 1);
1093 newlen -= ss - s;
1094 }
1095 }
1096
1097 /* Accept the new addition to the line. Remove trailing white space. */
1098
1099 len = newlen;
1100 while (len > 0 && isspace(big_buffer[len-1])) len--;
1101 big_buffer[len] = 0;
1102
1103 /* We are done if the line does not end in backslash and contains some data.
1104 Empty logical lines are ignored. For continuations, remove the backslash and
1105 go round the loop to read the continuation line. */
1106
1107 if (len > 0)
1108 {
1109 if (big_buffer[len-1] != '\\') break; /* End of logical line */
1110 big_buffer[--len] = 0; /* Remove backslash */
1111 }
1112 } /* Loop for reading multiple physical lines */
1113
1114 /* We now have a logical line. Test for the end of a configuration section (or,
1115 more accurately, for the start of the next section). Place the name of the next
1116 section in next_section, and return NULL. If the name given is longer than
1117 next_section, truncate it. It will be unrecognized later, because all the known
1118 section names do fit. Leave space for pluralizing. */
1119
1120 s = big_buffer + startoffset; /* First non-space character */
1121
1122 if (config_lines)
1123 save_config_line(s);
1124
1125 if (strncmpic(s, US"begin ", 6) == 0)
1126 {
1127 s += 6;
1128 while (isspace(*s)) s++;
1129 if (big_buffer + len - s > sizeof(next_section) - 2)
1130 s[sizeof(next_section) - 2] = 0;
1131 Ustrcpy(next_section, s);
1132 return NULL;
1133 }
1134
1135 /* Return the first non-blank character. */
1136
1137 return s;
1138 }
1139
1140
1141
1142 /*************************************************
1143 * Read a name *
1144 *************************************************/
1145
1146 /* The yield is the pointer to the next uschar. Names longer than the
1147 output space are silently truncated. This function is also used from acl.c when
1148 parsing ACLs.
1149
1150 Arguments:
1151 name where to put the name
1152 len length of name
1153 s input pointer
1154
1155 Returns: new input pointer
1156 */
1157
1158 uschar *
1159 readconf_readname(uschar *name, int len, uschar *s)
1160 {
1161 int p = 0;
1162 while (isspace(*s)) s++;
1163 if (isalpha(*s))
1164 {
1165 while (isalnum(*s) || *s == '_')
1166 {
1167 if (p < len-1) name[p++] = *s;
1168 s++;
1169 }
1170 }
1171 name[p] = 0;
1172 while (isspace(*s)) s++;
1173 return s;
1174 }
1175
1176
1177
1178
1179 /*************************************************
1180 * Read a time value *
1181 *************************************************/
1182
1183 /* This function is also called from outside, to read argument
1184 time values. The format of a time value is:
1185
1186 [<n>w][<n>d][<n>h][<n>m][<n>s]
1187
1188 as long as at least one is present. If a format error is encountered,
1189 return a negative value. The value must be terminated by the given
1190 terminator.
1191
1192 Arguments:
1193 s input pointer
1194 terminator required terminating character
1195 return_msec if TRUE, allow fractional seconds and return milliseconds
1196
1197 Returns: the time value, or -1 on syntax error
1198 value is seconds if return_msec is FALSE
1199 value is milliseconds if return_msec is TRUE
1200 */
1201
1202 int
1203 readconf_readtime(const uschar *s, int terminator, BOOL return_msec)
1204 {
1205 int yield = 0;
1206 for (;;)
1207 {
1208 int value, count;
1209 double fraction;
1210
1211 if (!isdigit(*s)) return -1;
1212 (void)sscanf(CCS s, "%d%n", &value, &count);
1213 s += count;
1214
1215 switch (*s)
1216 {
1217 case 'w': value *= 7;
1218 case 'd': value *= 24;
1219 case 'h': value *= 60;
1220 case 'm': value *= 60;
1221 case 's': s++;
1222 break;
1223
1224 case '.':
1225 if (!return_msec) return -1;
1226 (void)sscanf(CCS s, "%lf%n", &fraction, &count);
1227 s += count;
1228 if (*s++ != 's') return -1;
1229 yield += (int)(fraction * 1000.0);
1230 break;
1231
1232 default: return -1;
1233 }
1234
1235 if (return_msec) value *= 1000;
1236 yield += value;
1237 if (*s == terminator) return yield;
1238 }
1239 /* Control never reaches here. */
1240 }
1241
1242
1243
1244 /*************************************************
1245 * Read a fixed point value *
1246 *************************************************/
1247
1248 /* The value is returned *1000
1249
1250 Arguments:
1251 s input pointer
1252 terminator required terminator
1253
1254 Returns: the value, or -1 on error
1255 */
1256
1257 static int
1258 readconf_readfixed(const uschar *s, int terminator)
1259 {
1260 int yield = 0;
1261 int value, count;
1262 if (!isdigit(*s)) return -1;
1263 (void)sscanf(CS s, "%d%n", &value, &count);
1264 s += count;
1265 yield = value * 1000;
1266 if (*s == '.')
1267 {
1268 int m = 100;
1269 while (isdigit((*(++s))))
1270 {
1271 yield += (*s - '0') * m;
1272 m /= 10;
1273 }
1274 }
1275
1276 return (*s == terminator)? yield : (-1);
1277 }
1278
1279
1280
1281 /*************************************************
1282 * Find option in list *
1283 *************************************************/
1284
1285 /* The lists are always in order, so binary chop can be used.
1286
1287 Arguments:
1288 name the option name to search for
1289 ol the first entry in the option list
1290 last one more than the offset of the last entry in the option list
1291
1292 Returns: pointer to an option entry, or NULL if not found
1293 */
1294
1295 static optionlist *
1296 find_option(uschar *name, optionlist *ol, int last)
1297 {
1298 int first = 0;
1299 while (last > first)
1300 {
1301 int middle = (first + last)/2;
1302 int c = Ustrcmp(name, ol[middle].name);
1303
1304 if (c == 0) return ol + middle;
1305 else if (c > 0) first = middle + 1;
1306 else last = middle;
1307 }
1308 return NULL;
1309 }
1310
1311
1312
1313 /*************************************************
1314 * Find a set flag in option list *
1315 *************************************************/
1316
1317 /* Because some versions of Unix make no restrictions on the values of uids and
1318 gids (even negative ones), we cannot represent "unset" by a special value.
1319 There is therefore a separate boolean variable for each one indicating whether
1320 a value is set or not. This function returns a pointer to the boolean, given
1321 the original option name. It is a major disaster if the flag cannot be found.
1322
1323 Arguments:
1324 name the name of the uid or gid option
1325 oltop points to the start of the relevant option list
1326 last one more than the offset of the last item in the option list
1327 data_block NULL when reading main options => data values in the option
1328 list are absolute addresses; otherwise they are byte offsets
1329 in data_block (used for driver options)
1330
1331 Returns: a pointer to the boolean flag.
1332 */
1333
1334 static BOOL *
1335 get_set_flag(uschar *name, optionlist *oltop, int last, void *data_block)
1336 {
1337 optionlist *ol;
1338 uschar name2[64];
1339 sprintf(CS name2, "*set_%.50s", name);
1340 ol = find_option(name2, oltop, last);
1341 if (ol == NULL) log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1342 "Exim internal error: missing set flag for %s", name);
1343 return (data_block == NULL)? (BOOL *)(ol->value) :
1344 (BOOL *)(US data_block + (long int)(ol->value));
1345 }
1346
1347
1348
1349
1350 /*************************************************
1351 * Output extra characters message and die *
1352 *************************************************/
1353
1354 /* Called when an option line has junk on the end. Sometimes this is because
1355 the sysadmin thinks comments are permitted.
1356
1357 Arguments:
1358 s points to the extra characters
1359 t1..t3 strings to insert in the log message
1360
1361 Returns: doesn't return; dies
1362 */
1363
1364 static void
1365 extra_chars_error(const uschar *s, const uschar *t1, const uschar *t2, const uschar *t3)
1366 {
1367 uschar *comment = US"";
1368 if (*s == '#') comment = US" (# is comment only at line start)";
1369 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1370 "extra characters follow %s%s%s%s", t1, t2, t3, comment);
1371 }
1372
1373
1374
1375 /*************************************************
1376 * Read rewrite information *
1377 *************************************************/
1378
1379 /* Each line of rewrite information contains:
1380
1381 . A complete address in the form user@domain, possibly with
1382 leading * for each part; or alternatively, a regex.
1383
1384 . A replacement string (which will be expanded).
1385
1386 . An optional sequence of one-letter flags, indicating which
1387 headers etc. to apply this rule to.
1388
1389 All this is decoded and placed into a control block. The OR of the flags is
1390 maintained in a common word.
1391
1392 Arguments:
1393 p points to the string that makes up the rule
1394 existflags points to the overall flag word
1395 isglobal TRUE if reading global rewrite rules
1396
1397 Returns: the control block for the parsed rule.
1398 */
1399
1400 static rewrite_rule *
1401 readconf_one_rewrite(const uschar *p, int *existflags, BOOL isglobal)
1402 {
1403 rewrite_rule *next = store_get(sizeof(rewrite_rule));
1404
1405 next->next = NULL;
1406 next->key = string_dequote(&p);
1407
1408 while (isspace(*p)) p++;
1409 if (*p == 0)
1410 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1411 "missing rewrite replacement string");
1412
1413 next->flags = 0;
1414 next->replacement = string_dequote(&p);
1415
1416 while (*p != 0) switch (*p++)
1417 {
1418 case ' ': case '\t': break;
1419
1420 case 'q': next->flags |= rewrite_quit; break;
1421 case 'w': next->flags |= rewrite_whole; break;
1422
1423 case 'h': next->flags |= rewrite_all_headers; break;
1424 case 's': next->flags |= rewrite_sender; break;
1425 case 'f': next->flags |= rewrite_from; break;
1426 case 't': next->flags |= rewrite_to; break;
1427 case 'c': next->flags |= rewrite_cc; break;
1428 case 'b': next->flags |= rewrite_bcc; break;
1429 case 'r': next->flags |= rewrite_replyto; break;
1430
1431 case 'E': next->flags |= rewrite_all_envelope; break;
1432 case 'F': next->flags |= rewrite_envfrom; break;
1433 case 'T': next->flags |= rewrite_envto; break;
1434
1435 case 'Q': next->flags |= rewrite_qualify; break;
1436 case 'R': next->flags |= rewrite_repeat; break;
1437
1438 case 'S':
1439 next->flags |= rewrite_smtp;
1440 if (next->key[0] != '^' && Ustrncmp(next->key, "\\N^", 3) != 0)
1441 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1442 "rewrite rule has the S flag but is not a regular expression");
1443 break;
1444
1445 default:
1446 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1447 "unknown rewrite flag character '%c' "
1448 "(could be missing quotes round replacement item)", p[-1]);
1449 break;
1450 }
1451
1452 /* If no action flags are set, set all the "normal" rewrites. */
1453
1454 if ((next->flags & (rewrite_all | rewrite_smtp)) == 0)
1455 next->flags |= isglobal? rewrite_all : rewrite_all_headers;
1456
1457 /* Remember which exist, for optimization, and return the rule */
1458
1459 *existflags |= next->flags;
1460 return next;
1461 }
1462
1463
1464
1465
1466 /*************************************************
1467 * Read global rewrite information *
1468 *************************************************/
1469
1470 /* Each line is a single rewrite rule; it is parsed into a control block
1471 by readconf_one_rewrite(), and its flags are ORed into the global flag
1472 word rewrite_existflags. */
1473
1474 void
1475 readconf_rewrites(void)
1476 {
1477 rewrite_rule **chain = &global_rewrite_rules;
1478 uschar *p;
1479
1480 while ((p = get_config_line()) != NULL)
1481 {
1482 rewrite_rule *next = readconf_one_rewrite(p, &rewrite_existflags, TRUE);
1483 *chain = next;
1484 chain = &(next->next);
1485 }
1486 }
1487
1488
1489
1490 /*************************************************
1491 * Read a string *
1492 *************************************************/
1493
1494 /* Strings are read into the normal store pool. As long we aren't too
1495 near the end of the current block, the string will just use what is necessary
1496 on the top of the stacking pool, because string_cat() uses the extension
1497 mechanism.
1498
1499 Argument:
1500 s the rest of the input line
1501 name the option name (for errors)
1502
1503 Returns: pointer to the string
1504 */
1505
1506 static uschar *
1507 read_string(const uschar *s, const uschar *name)
1508 {
1509 uschar *yield;
1510 const uschar *ss;
1511
1512 if (*s != '\"') return string_copy(s);
1513
1514 ss = s;
1515 yield = string_dequote(&s);
1516
1517 if (s == ss+1 || s[-1] != '\"')
1518 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1519 "missing quote at end of string value for %s", name);
1520
1521 if (*s != 0) extra_chars_error(s, US"string value for ", name, US"");
1522
1523 return yield;
1524 }
1525
1526
1527 /*************************************************
1528 * Custom-handler options *
1529 *************************************************/
1530 static void
1531 fn_smtp_receive_timeout(const uschar * name, const uschar * str)
1532 {
1533 if (*str == '$')
1534 smtp_receive_timeout_s = string_copy(str);
1535 else
1536 {
1537 /* "smtp_receive_timeout", opt_time, &smtp_receive_timeout */
1538 smtp_receive_timeout = readconf_readtime(str, 0, FALSE);
1539 if (smtp_receive_timeout < 0)
1540 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
1541 name);
1542 }
1543 }
1544
1545 /*************************************************
1546 * Handle option line *
1547 *************************************************/
1548
1549 /* This function is called from several places to process a line containing the
1550 setting of an option. The first argument is the line to be decoded; it has been
1551 checked not to be empty and not to start with '#'. Trailing newlines and white
1552 space have been removed. The second argument is a pointer to the list of
1553 variable names that are to be recognized, together with their types and
1554 locations, and the third argument gives the number of entries in the list.
1555
1556 The fourth argument is a pointer to a data block. If it is NULL, then the data
1557 values in the options list are absolute addresses. Otherwise, they are byte
1558 offsets in the data block.
1559
1560 String option data may continue onto several lines; this function reads further
1561 data from config_file if necessary.
1562
1563 The yield of this function is normally zero. If a string continues onto
1564 multiple lines, then the data value is permitted to be followed by a comma
1565 or a semicolon (for use in drivers) and the yield is that character.
1566
1567 Arguments:
1568 buffer contains the configuration line to be handled
1569 oltop points to the start of the relevant option list
1570 last one more than the offset of the last item in the option list
1571 data_block NULL when reading main options => data values in the option
1572 list are absolute addresses; otherwise they are byte offsets
1573 in data_block when they have opt_public set; otherwise
1574 they are byte offsets in data_block->options_block.
1575 unknown_txt format string to use in panic message for unknown option;
1576 must contain %s for option name
1577 if given as NULL, don't panic on unknown option
1578
1579 Returns: TRUE if an option was read successfully,
1580 FALSE false for an unknown option if unknown_txt == NULL,
1581 otherwise panic and die on an unknown option
1582 */
1583
1584 static BOOL
1585 readconf_handle_option(uschar *buffer, optionlist *oltop, int last,
1586 void *data_block, uschar *unknown_txt)
1587 {
1588 int ptr = 0;
1589 int offset = 0;
1590 int n, count, type, value;
1591 int issecure = 0;
1592 uid_t uid;
1593 gid_t gid;
1594 BOOL boolvalue = TRUE;
1595 BOOL freesptr = TRUE;
1596 optionlist *ol, *ol2;
1597 struct passwd *pw;
1598 void *reset_point;
1599 int intbase = 0;
1600 uschar *inttype = US"";
1601 uschar *sptr;
1602 uschar *s = buffer;
1603 uschar **str_target;
1604 uschar name[64];
1605 uschar name2[64];
1606
1607 /* There may be leading spaces; thereafter, we expect an option name starting
1608 with a letter. */
1609
1610 while (isspace(*s)) s++;
1611 if (!isalpha(*s))
1612 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option setting expected: %s", s);
1613
1614 /* Read the name of the option, and skip any subsequent white space. If
1615 it turns out that what we read was "hide", set the flag indicating that
1616 this is a secure option, and loop to read the next word. */
1617
1618 for (n = 0; n < 2; n++)
1619 {
1620 while (isalnum(*s) || *s == '_')
1621 {
1622 if (ptr < sizeof(name)-1) name[ptr++] = *s;
1623 s++;
1624 }
1625 name[ptr] = 0;
1626 while (isspace(*s)) s++;
1627 if (Ustrcmp(name, "hide") != 0) break;
1628 issecure = opt_secure;
1629 ptr = 0;
1630 }
1631
1632 /* Deal with "no_" or "not_" here for booleans */
1633
1634 if (Ustrncmp(name, "no_", 3) == 0)
1635 {
1636 boolvalue = FALSE;
1637 offset = 3;
1638 }
1639
1640 if (Ustrncmp(name, "not_", 4) == 0)
1641 {
1642 boolvalue = FALSE;
1643 offset = 4;
1644 }
1645
1646 /* Search the list for the given name. A non-existent name, or an option that
1647 is set twice, is a disaster. */
1648
1649 if (!(ol = find_option(name + offset, oltop, last)))
1650 {
1651 if (unknown_txt == NULL) return FALSE;
1652 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, CS unknown_txt, name);
1653 }
1654
1655 if ((ol->type & opt_set) && !(ol->type & (opt_rep_con | opt_rep_str)))
1656 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1657 "\"%s\" option set for the second time", name);
1658
1659 ol->type |= opt_set | issecure;
1660 type = ol->type & opt_mask;
1661
1662 /* Types with data values must be followed by '='; the "no[t]_" prefix
1663 applies only to boolean values. */
1664
1665 if (type < opt_bool || type > opt_bool_last)
1666 {
1667 if (offset != 0)
1668 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1669 "negation prefix applied to a non-boolean option");
1670 if (*s == 0)
1671 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1672 "unexpected end of line (data missing) after %s", name);
1673 if (*s != '=')
1674 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing \"=\" after %s", name);
1675 }
1676
1677 /* If a boolean wasn't preceded by "no[t]_" it can be followed by = and
1678 true/false/yes/no, or, in the case of opt_expand_bool, a general string that
1679 ultimately expands to one of those values. */
1680
1681 else if (*s != 0 && (offset != 0 || *s != '='))
1682 extra_chars_error(s, US"boolean option ", name, US"");
1683
1684 /* Skip white space after = */
1685
1686 if (*s == '=') while (isspace((*(++s))));
1687
1688 /* If there is a data block and the opt_public flag is not set, change
1689 the data block pointer to the private options block. */
1690
1691 if (data_block != NULL && (ol->type & opt_public) == 0)
1692 data_block = (void *)(((driver_instance *)data_block)->options_block);
1693
1694 /* Now get the data according to the type. */
1695
1696 switch (type)
1697 {
1698 /* If a string value is not enclosed in quotes, it consists of
1699 the rest of the current line, verbatim. Otherwise, string escapes
1700 are processed.
1701
1702 A transport is specified as a string, which is then looked up in the
1703 list of transports. A search type is specified as one of a number of
1704 known strings.
1705
1706 A set or rewrite rules for a driver is specified as a string, which is
1707 then parsed into a suitable chain of control blocks.
1708
1709 Uids and gids are specified as strings which are then looked up in the
1710 passwd file. Lists of uids and gids are similarly specified as colon-
1711 separated strings. */
1712
1713 case opt_stringptr:
1714 case opt_uid:
1715 case opt_gid:
1716 case opt_expand_uid:
1717 case opt_expand_gid:
1718 case opt_uidlist:
1719 case opt_gidlist:
1720 case opt_rewrite:
1721
1722 reset_point = sptr = read_string(s, name);
1723
1724 /* Having read a string, we now have several different ways of using it,
1725 depending on the data type, so do another switch. If keeping the actual
1726 string is not required (because it is interpreted), freesptr is set TRUE,
1727 and at the end we reset the pool. */
1728
1729 switch (type)
1730 {
1731 /* If this was a string, set the variable to point to the new string,
1732 and set the flag so its store isn't reclaimed. If it was a list of rewrite
1733 rules, we still keep the string (for printing), and parse the rules into a
1734 control block and flags word. */
1735
1736 case opt_stringptr:
1737 str_target = data_block ? USS (US data_block + (long int)(ol->value))
1738 : USS (ol->value);
1739 if (ol->type & opt_rep_con)
1740 {
1741 uschar * saved_condition;
1742 /* We already have a condition, we're conducting a crude hack to let
1743 multiple condition rules be chained together, despite storing them in
1744 text form. */
1745 *str_target = string_copy_malloc( (saved_condition = *str_target)
1746 ? string_sprintf("${if and{{bool_lax{%s}}{bool_lax{%s}}}}",
1747 saved_condition, sptr)
1748 : sptr);
1749 /* TODO(pdp): there is a memory leak here and just below
1750 when we set 3 or more conditions; I still don't
1751 understand the store mechanism enough to know
1752 what's the safe way to free content from an earlier store.
1753 AFAICT, stores stack, so freeing an early stored item also stores
1754 all data alloc'd after it. If we knew conditions were adjacent,
1755 we could survive that, but we don't. So I *think* we need to take
1756 another bit from opt_type to indicate "malloced"; this seems like
1757 quite a hack, especially for this one case. It also means that
1758 we can't ever reclaim the store from the *first* condition.
1759
1760 Because we only do this once, near process start-up, I'm prepared to
1761 let this slide for the time being, even though it rankles. */
1762 }
1763 else if (ol->type & opt_rep_str)
1764 {
1765 uschar sep_o = Ustrncmp(name, "headers_add", 11)==0 ? '\n' : ':';
1766 int sep_i = -(int)sep_o;
1767 const uschar * list = sptr;
1768 uschar * s;
1769 gstring * list_o = NULL;
1770
1771 if (*str_target)
1772 {
1773 list_o = string_get(Ustrlen(*str_target) + Ustrlen(sptr));
1774 list_o = string_cat(list_o, *str_target);
1775 }
1776
1777 while ((s = string_nextinlist(&list, &sep_i, NULL, 0)))
1778 list_o = string_append_listele(list_o, sep_o, s);
1779
1780 if (list_o)
1781 *str_target = string_copy_malloc(string_from_gstring(list_o));
1782 }
1783 else
1784 {
1785 *str_target = sptr;
1786 freesptr = FALSE;
1787 }
1788 break;
1789
1790 case opt_rewrite:
1791 if (data_block)
1792 *USS (US data_block + (long int)(ol->value)) = sptr;
1793 else
1794 *USS (ol->value) = sptr;
1795 freesptr = FALSE;
1796 if (type == opt_rewrite)
1797 {
1798 int sep = 0;
1799 int *flagptr;
1800 uschar *p = sptr;
1801 rewrite_rule **chain;
1802 optionlist *ol3;
1803
1804 sprintf(CS name2, "*%.50s_rules", name);
1805 ol2 = find_option(name2, oltop, last);
1806 sprintf(CS name2, "*%.50s_flags", name);
1807 ol3 = find_option(name2, oltop, last);
1808
1809 if (ol2 == NULL || ol3 == NULL)
1810 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1811 "rewrite rules not available for driver");
1812
1813 if (data_block == NULL)
1814 {
1815 chain = (rewrite_rule **)(ol2->value);
1816 flagptr = (int *)(ol3->value);
1817 }
1818 else
1819 {
1820 chain = (rewrite_rule **)(US data_block + (long int)(ol2->value));
1821 flagptr = (int *)(US data_block + (long int)(ol3->value));
1822 }
1823
1824 while ((p = string_nextinlist(CUSS &sptr, &sep, big_buffer, BIG_BUFFER_SIZE)))
1825 {
1826 rewrite_rule *next = readconf_one_rewrite(p, flagptr, FALSE);
1827 *chain = next;
1828 chain = &(next->next);
1829 }
1830
1831 if ((*flagptr & (rewrite_all_envelope | rewrite_smtp)) != 0)
1832 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "rewrite rule specifies a "
1833 "non-header rewrite - not allowed at transport time -");
1834 }
1835 break;
1836
1837 /* If it was an expanded uid, see if there is any expansion to be
1838 done by checking for the presence of a $ character. If there is, save it
1839 in the corresponding *expand_user option field. Otherwise, fall through
1840 to treat it as a fixed uid. Ensure mutual exclusivity of the two kinds
1841 of data. */
1842
1843 case opt_expand_uid:
1844 sprintf(CS name2, "*expand_%.50s", name);
1845 ol2 = find_option(name2, oltop, last);
1846 if (ol2 != NULL)
1847 {
1848 uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
1849
1850 if (data_block == NULL)
1851 *((uschar **)(ol2->value)) = ss;
1852 else
1853 *((uschar **)(US data_block + (long int)(ol2->value))) = ss;
1854
1855 if (ss != NULL)
1856 {
1857 *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1858 freesptr = FALSE;
1859 break;
1860 }
1861 }
1862
1863 /* Look up a fixed uid, and also make use of the corresponding gid
1864 if a passwd entry is returned and the gid has not been set. */
1865
1866 case opt_uid:
1867 if (!route_finduser(sptr, &pw, &uid))
1868 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found", sptr);
1869 if (data_block == NULL)
1870 *((uid_t *)(ol->value)) = uid;
1871 else
1872 *((uid_t *)(US data_block + (long int)(ol->value))) = uid;
1873
1874 /* Set the flag indicating a fixed value is set */
1875
1876 *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1877
1878 /* Handle matching gid if we have a passwd entry: done by finding the
1879 same name with terminating "user" changed to "group"; if not found,
1880 ignore. Also ignore if the value is already set. */
1881
1882 if (pw == NULL) break;
1883 Ustrcpy(name+Ustrlen(name)-4, "group");
1884 ol2 = find_option(name, oltop, last);
1885 if (ol2 != NULL && ((ol2->type & opt_mask) == opt_gid ||
1886 (ol2->type & opt_mask) == opt_expand_gid))
1887 {
1888 BOOL *set_flag = get_set_flag(name, oltop, last, data_block);
1889 if (! *set_flag)
1890 {
1891 if (data_block == NULL)
1892 *((gid_t *)(ol2->value)) = pw->pw_gid;
1893 else
1894 *((gid_t *)(US data_block + (long int)(ol2->value))) = pw->pw_gid;
1895 *set_flag = TRUE;
1896 }
1897 }
1898 break;
1899
1900 /* If it was an expanded gid, see if there is any expansion to be
1901 done by checking for the presence of a $ character. If there is, save it
1902 in the corresponding *expand_user option field. Otherwise, fall through
1903 to treat it as a fixed gid. Ensure mutual exclusivity of the two kinds
1904 of data. */
1905
1906 case opt_expand_gid:
1907 sprintf(CS name2, "*expand_%.50s", name);
1908 ol2 = find_option(name2, oltop, last);
1909 if (ol2 != NULL)
1910 {
1911 uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
1912
1913 if (data_block == NULL)
1914 *((uschar **)(ol2->value)) = ss;
1915 else
1916 *((uschar **)(US data_block + (long int)(ol2->value))) = ss;
1917
1918 if (ss != NULL)
1919 {
1920 *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1921 freesptr = FALSE;
1922 break;
1923 }
1924 }
1925
1926 /* Handle freestanding gid */
1927
1928 case opt_gid:
1929 if (!route_findgroup(sptr, &gid))
1930 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found", sptr);
1931 if (data_block == NULL)
1932 *((gid_t *)(ol->value)) = gid;
1933 else
1934 *((gid_t *)(US data_block + (long int)(ol->value))) = gid;
1935 *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1936 break;
1937
1938 /* If it was a uid list, look up each individual entry, and build
1939 a vector of uids, with a count in the first element. Put the vector
1940 in malloc store so we can free the string. (We are reading into
1941 permanent store already.) */
1942
1943 case opt_uidlist:
1944 {
1945 int count = 1;
1946 uid_t *list;
1947 int ptr = 0;
1948 const uschar *p;
1949 const uschar *op = expand_string (sptr);
1950
1951 if (op == NULL)
1952 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
1953 name, expand_string_message);
1954
1955 p = op;
1956 if (*p != 0) count++;
1957 while (*p != 0) if (*p++ == ':' && *p != 0) count++;
1958 list = store_malloc(count*sizeof(uid_t));
1959 list[ptr++] = (uid_t)(count - 1);
1960
1961 if (data_block == NULL)
1962 *((uid_t **)(ol->value)) = list;
1963 else
1964 *((uid_t **)(US data_block + (long int)(ol->value))) = list;
1965
1966 p = op;
1967 while (count-- > 1)
1968 {
1969 int sep = 0;
1970 (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
1971 if (!route_finduser(big_buffer, NULL, &uid))
1972 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found",
1973 big_buffer);
1974 list[ptr++] = uid;
1975 }
1976 }
1977 break;
1978
1979 /* If it was a gid list, look up each individual entry, and build
1980 a vector of gids, with a count in the first element. Put the vector
1981 in malloc store so we can free the string. (We are reading into permanent
1982 store already.) */
1983
1984 case opt_gidlist:
1985 {
1986 int count = 1;
1987 gid_t *list;
1988 int ptr = 0;
1989 const uschar *p;
1990 const uschar *op = expand_string (sptr);
1991
1992 if (op == NULL)
1993 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
1994 name, expand_string_message);
1995
1996 p = op;
1997 if (*p != 0) count++;
1998 while (*p != 0) if (*p++ == ':' && *p != 0) count++;
1999 list = store_malloc(count*sizeof(gid_t));
2000 list[ptr++] = (gid_t)(count - 1);
2001
2002 if (data_block == NULL)
2003 *((gid_t **)(ol->value)) = list;
2004 else
2005 *((gid_t **)(US data_block + (long int)(ol->value))) = list;
2006
2007 p = op;
2008 while (count-- > 1)
2009 {
2010 int sep = 0;
2011 (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
2012 if (!route_findgroup(big_buffer, &gid))
2013 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found",
2014 big_buffer);
2015 list[ptr++] = gid;
2016 }
2017 }
2018 break;
2019 }
2020
2021 /* Release store if the value of the string doesn't need to be kept. */
2022
2023 if (freesptr) store_reset(reset_point);
2024 break;
2025
2026 /* Expanded boolean: if no characters follow, or if there are no dollar
2027 characters, this is a fixed-valued boolean, and we fall through. Otherwise,
2028 save the string for later expansion in the alternate place. */
2029
2030 case opt_expand_bool:
2031 if (*s != 0 && Ustrchr(s, '$') != 0)
2032 {
2033 sprintf(CS name2, "*expand_%.50s", name);
2034 ol2 = find_option(name2, oltop, last);
2035 if (ol2 != NULL)
2036 {
2037 reset_point = sptr = read_string(s, name);
2038 if (data_block == NULL)
2039 *((uschar **)(ol2->value)) = sptr;
2040 else
2041 *((uschar **)(US data_block + (long int)(ol2->value))) = sptr;
2042 freesptr = FALSE;
2043 break;
2044 }
2045 }
2046 /* Fall through */
2047
2048 /* Boolean: if no characters follow, the value is boolvalue. Otherwise
2049 look for yes/not/true/false. Some booleans are stored in a single bit in
2050 a single int. There's a special fudge for verify settings; without a suffix
2051 they set both xx_sender and xx_recipient. The table points to the sender
2052 value; search subsequently for the recipient. There's another special case:
2053 opt_bool_set also notes when a boolean has been set. */
2054
2055 case opt_bool:
2056 case opt_bit:
2057 case opt_bool_verify:
2058 case opt_bool_set:
2059 if (*s != 0)
2060 {
2061 s = readconf_readname(name2, 64, s);
2062 if (strcmpic(name2, US"true") == 0 || strcmpic(name2, US"yes") == 0)
2063 boolvalue = TRUE;
2064 else if (strcmpic(name2, US"false") == 0 || strcmpic(name2, US"no") == 0)
2065 boolvalue = FALSE;
2066 else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2067 "\"%s\" is not a valid value for the \"%s\" option", name2, name);
2068 if (*s != 0) extra_chars_error(s, string_sprintf("\"%s\" ", name2),
2069 US"for boolean option ", name);
2070 }
2071
2072 /* Handle single-bit type. */
2073
2074 if (type == opt_bit)
2075 {
2076 int bit = 1 << ((ol->type >> 16) & 31);
2077 int *ptr = (data_block == NULL)?
2078 (int *)(ol->value) :
2079 (int *)(US data_block + (long int)ol->value);
2080 if (boolvalue) *ptr |= bit; else *ptr &= ~bit;
2081 break;
2082 }
2083
2084 /* Handle full BOOL types */
2085
2086 if (data_block == NULL)
2087 *((BOOL *)(ol->value)) = boolvalue;
2088 else
2089 *((BOOL *)(US data_block + (long int)(ol->value))) = boolvalue;
2090
2091 /* Verify fudge */
2092
2093 if (type == opt_bool_verify)
2094 {
2095 sprintf(CS name2, "%.50s_recipient", name + offset);
2096 ol2 = find_option(name2, oltop, last);
2097 if (ol2 != NULL)
2098 {
2099 if (data_block == NULL)
2100 *((BOOL *)(ol2->value)) = boolvalue;
2101 else
2102 *((BOOL *)(US data_block + (long int)(ol2->value))) = boolvalue;
2103 }
2104 }
2105
2106 /* Note that opt_bool_set type is set, if there is somewhere to do so */
2107
2108 else if (type == opt_bool_set)
2109 {
2110 sprintf(CS name2, "*set_%.50s", name + offset);
2111 ol2 = find_option(name2, oltop, last);
2112 if (ol2 != NULL)
2113 {
2114 if (data_block == NULL)
2115 *((BOOL *)(ol2->value)) = TRUE;
2116 else
2117 *((BOOL *)(US data_block + (long int)(ol2->value))) = TRUE;
2118 }
2119 }
2120 break;
2121
2122 /* Octal integer */
2123
2124 case opt_octint:
2125 intbase = 8;
2126 inttype = US"octal ";
2127
2128 /* Integer: a simple(ish) case; allow octal and hex formats, and
2129 suffixes K, M and G. The different types affect output, not input. */
2130
2131 case opt_mkint:
2132 case opt_int:
2133 {
2134 uschar *endptr;
2135 long int lvalue;
2136
2137 errno = 0;
2138 lvalue = strtol(CS s, CSS &endptr, intbase);
2139
2140 if (endptr == s)
2141 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
2142 inttype, name);
2143
2144 if (errno != ERANGE)
2145 if (tolower(*endptr) == 'k')
2146 {
2147 if (lvalue > INT_MAX/1024 || lvalue < INT_MIN/1024) errno = ERANGE;
2148 else lvalue *= 1024;
2149 endptr++;
2150 }
2151 else if (tolower(*endptr) == 'm')
2152 {
2153 if (lvalue > INT_MAX/(1024*1024) || lvalue < INT_MIN/(1024*1024))
2154 errno = ERANGE;
2155 else lvalue *= 1024*1024;
2156 endptr++;
2157 }
2158 else if (tolower(*endptr) == 'g')
2159 {
2160 if (lvalue > INT_MAX/(1024*1024*1024) || lvalue < INT_MIN/(1024*1024*1024))
2161 errno = ERANGE;
2162 else lvalue *= 1024*1024*1024;
2163 endptr++;
2164 }
2165
2166 if (errno == ERANGE || lvalue > INT_MAX || lvalue < INT_MIN)
2167 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2168 "absolute value of integer \"%s\" is too large (overflow)", s);
2169
2170 while (isspace(*endptr)) endptr++;
2171 if (*endptr != 0)
2172 extra_chars_error(endptr, inttype, US"integer value for ", name);
2173
2174 value = (int)lvalue;
2175 }
2176
2177 if (data_block == NULL)
2178 *((int *)(ol->value)) = value;
2179 else
2180 *((int *)(US data_block + (long int)(ol->value))) = value;
2181 break;
2182
2183 /* Integer held in K: again, allow octal and hex formats, and suffixes K, M
2184 and G. */
2185 /*XXX consider moving to int_eximarith_t (but mind the overflow test 0415) */
2186
2187 case opt_Kint:
2188 {
2189 uschar *endptr;
2190 errno = 0;
2191 value = strtol(CS s, CSS &endptr, intbase);
2192
2193 if (endptr == s)
2194 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
2195 inttype, name);
2196
2197 if (errno != ERANGE)
2198 if (tolower(*endptr) == 'g')
2199 {
2200 if (value > INT_MAX/(1024*1024) || value < INT_MIN/(1024*1024))
2201 errno = ERANGE;
2202 else
2203 value *= 1024*1024;
2204 endptr++;
2205 }
2206 else if (tolower(*endptr) == 'm')
2207 {
2208 if (value > INT_MAX/1024 || value < INT_MIN/1024)
2209 errno = ERANGE;
2210 else
2211 value *= 1024;
2212 endptr++;
2213 }
2214 else if (tolower(*endptr) == 'k')
2215 endptr++;
2216 else
2217 value = (value + 512)/1024;
2218
2219 if (errno == ERANGE) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2220 "absolute value of integer \"%s\" is too large (overflow)", s);
2221
2222 while (isspace(*endptr)) endptr++;
2223 if (*endptr != 0)
2224 extra_chars_error(endptr, inttype, US"integer value for ", name);
2225 }
2226
2227 if (data_block == NULL)
2228 *((int *)(ol->value)) = value;
2229 else
2230 *((int *)(US data_block + (long int)(ol->value))) = value;
2231 break;
2232
2233 /* Fixed-point number: held to 3 decimal places. */
2234
2235 case opt_fixed:
2236 if (sscanf(CS s, "%d%n", &value, &count) != 1)
2237 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2238 "fixed-point number expected for %s", name);
2239
2240 if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2241 "integer \"%s\" is too large (overflow)", s);
2242
2243 value *= 1000;
2244
2245 if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2246 "integer \"%s\" is too large (overflow)", s);
2247
2248 /* We get a coverity error here for using count, as it derived
2249 from the tainted buffer pointed to by s, as parsed by sscanf().
2250 By the definition of sscanf we must be accessing between start
2251 and end of s (assuming it is nul-terminated...) so ignore the error. */
2252 /* coverity[tainted_data] */
2253 if (s[count] == '.')
2254 {
2255 int d = 100;
2256 while (isdigit(s[++count]))
2257 {
2258 value += (s[count] - '0') * d;
2259 d /= 10;
2260 }
2261 }
2262
2263 while (isspace(s[count])) count++;
2264
2265 if (s[count] != 0)
2266 extra_chars_error(s+count, US"fixed-point value for ", name, US"");
2267
2268 if (data_block == NULL)
2269 *((int *)(ol->value)) = value;
2270 else
2271 *((int *)(US data_block + (long int)(ol->value))) = value;
2272 break;
2273
2274 /* There's a special routine to read time values. */
2275
2276 case opt_time:
2277 value = readconf_readtime(s, 0, FALSE);
2278 if (value < 0)
2279 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2280 name);
2281 if (data_block == NULL)
2282 *((int *)(ol->value)) = value;
2283 else
2284 *((int *)(US data_block + (long int)(ol->value))) = value;
2285 break;
2286
2287 /* A time list is a list of colon-separated times, with the first
2288 element holding the size of the list and the second the number of
2289 entries used. */
2290
2291 case opt_timelist:
2292 {
2293 int count = 0;
2294 int *list = (data_block == NULL)?
2295 (int *)(ol->value) :
2296 (int *)(US data_block + (long int)(ol->value));
2297
2298 if (*s != 0) for (count = 1; count <= list[0] - 2; count++)
2299 {
2300 int terminator = 0;
2301 uschar *snext = Ustrchr(s, ':');
2302 if (snext != NULL)
2303 {
2304 uschar *ss = snext;
2305 while (ss > s && isspace(ss[-1])) ss--;
2306 terminator = *ss;
2307 }
2308 value = readconf_readtime(s, terminator, FALSE);
2309 if (value < 0)
2310 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2311 name);
2312 if (count > 1 && value <= list[count])
2313 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2314 "time value out of order for %s", name);
2315 list[count+1] = value;
2316 if (snext == NULL) break;
2317 s = snext + 1;
2318 while (isspace(*s)) s++;
2319 }
2320
2321 if (count > list[0] - 2)
2322 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many time values for %s",
2323 name);
2324 if (count > 0 && list[2] == 0) count = 0;
2325 list[1] = count;
2326 break;
2327 }
2328
2329 case opt_func:
2330 {
2331 void (*fn)() = ol->value;
2332 fn(name, s);
2333 break;
2334 }
2335 }
2336
2337 return TRUE;
2338 }
2339
2340
2341
2342 /*************************************************
2343 * Print a time value *
2344 *************************************************/
2345
2346 /*
2347 Argument: a time value in seconds
2348 Returns: pointer to a fixed buffer containing the time as a string,
2349 in readconf_readtime() format
2350 */
2351
2352 uschar *
2353 readconf_printtime(int t)
2354 {
2355 int s, m, h, d, w;
2356 uschar *p = time_buffer;
2357
2358 if (t < 0)
2359 {
2360 *p++ = '-';
2361 t = -t;
2362 }
2363
2364 s = t % 60;
2365 t /= 60;
2366 m = t % 60;
2367 t /= 60;
2368 h = t % 24;
2369 t /= 24;
2370 d = t % 7;
2371 w = t/7;
2372
2373 if (w > 0) p += sprintf(CS p, "%dw", w);
2374 if (d > 0) p += sprintf(CS p, "%dd", d);
2375 if (h > 0) p += sprintf(CS p, "%dh", h);
2376 if (m > 0) p += sprintf(CS p, "%dm", m);
2377 if (s > 0 || p == time_buffer) sprintf(CS p, "%ds", s);
2378
2379 return time_buffer;
2380 }
2381
2382
2383
2384 /*************************************************
2385 * Print an individual option value *
2386 *************************************************/
2387
2388 /* This is used by the -bP option, so prints to the standard output.
2389 The entire options list is passed in as an argument, because some options come
2390 in pairs - typically uid/gid settings, which can either be explicit numerical
2391 values, or strings to be expanded later. If the numerical value is unset,
2392 search for "*expand_<name>" to see if there is a string equivalent.
2393
2394 Arguments:
2395 ol option entry, or NULL for an unknown option
2396 name option name
2397 options_block NULL for main configuration options; otherwise points to
2398 a driver block; if the option doesn't have opt_public
2399 set, then options_block->options_block is where the item
2400 resides.
2401 oltop points to the option list in which ol exists
2402 last one more than the offset of the last entry in optop
2403 no_labels do not show "foo = " at the start.
2404
2405 Returns: boolean success
2406 */
2407
2408 static BOOL
2409 print_ol(optionlist *ol, uschar *name, void *options_block,
2410 optionlist *oltop, int last, BOOL no_labels)
2411 {
2412 struct passwd *pw;
2413 struct group *gr;
2414 optionlist *ol2;
2415 void *value;
2416 uid_t *uidlist;
2417 gid_t *gidlist;
2418 uschar *s;
2419 uschar name2[64];
2420
2421 if (!ol)
2422 {
2423 printf("%s is not a known option\n", name);
2424 return FALSE;
2425 }
2426
2427 /* Non-admin callers cannot see options that have been flagged secure by the
2428 "hide" prefix. */
2429
2430 if (!f.admin_user && ol->type & opt_secure)
2431 {
2432 if (no_labels)
2433 printf("%s\n", hidden);
2434 else
2435 printf("%s = %s\n", name, hidden);
2436 return TRUE;
2437 }
2438
2439 /* Else show the value of the option */
2440
2441 value = ol->value;
2442 if (options_block)
2443 {
2444 if (!(ol->type & opt_public))
2445 options_block = (void *)(((driver_instance *)options_block)->options_block);
2446 value = (void *)(US options_block + (long int)value);
2447 }
2448
2449 switch(ol->type & opt_mask)
2450 {
2451 case opt_stringptr:
2452 case opt_rewrite: /* Show the text value */
2453 s = *(USS value);
2454 if (!no_labels) printf("%s = ", name);
2455 printf("%s\n", s ? string_printing2(s, FALSE) : US"");
2456 break;
2457
2458 case opt_int:
2459 if (!no_labels) printf("%s = ", name);
2460 printf("%d\n", *((int *)value));
2461 break;
2462
2463 case opt_mkint:
2464 {
2465 int x = *((int *)value);
2466 if (x != 0 && (x & 1023) == 0)
2467 {
2468 int c = 'K';
2469 x >>= 10;
2470 if ((x & 1023) == 0)
2471 {
2472 c = 'M';
2473 x >>= 10;
2474 }
2475 if (!no_labels) printf("%s = ", name);
2476 printf("%d%c\n", x, c);
2477 }
2478 else
2479 {
2480 if (!no_labels) printf("%s = ", name);
2481 printf("%d\n", x);
2482 }
2483 }
2484 break;
2485
2486 case opt_Kint:
2487 {
2488 int x = *((int *)value);
2489 if (!no_labels) printf("%s = ", name);
2490 if (x == 0) printf("0\n");
2491 else if ((x & 1023) == 0) printf("%dM\n", x >> 10);
2492 else printf("%dK\n", x);
2493 }
2494 break;
2495
2496 case opt_octint:
2497 if (!no_labels) printf("%s = ", name);
2498 printf("%#o\n", *((int *)value));
2499 break;
2500
2501 /* Can be negative only when "unset", in which case integer */
2502
2503 case opt_fixed:
2504 {
2505 int x = *((int *)value);
2506 int f = x % 1000;
2507 int d = 100;
2508 if (x < 0) printf("%s =\n", name); else
2509 {
2510 if (!no_labels) printf("%s = ", name);
2511 printf("%d.", x/1000);
2512 do
2513 {
2514 printf("%d", f/d);
2515 f %= d;
2516 d /= 10;
2517 }
2518 while (f != 0);
2519 printf("\n");
2520 }
2521 }
2522 break;
2523
2524 /* If the numerical value is unset, try for the string value */
2525
2526 case opt_expand_uid:
2527 if (! *get_set_flag(name, oltop, last, options_block))
2528 {
2529 sprintf(CS name2, "*expand_%.50s", name);
2530 if ((ol2 = find_option(name2, oltop, last)))
2531 {
2532 void *value2 = ol2->value;
2533 if (options_block)
2534 value2 = (void *)(US options_block + (long int)value2);
2535 s = *(USS value2);
2536 if (!no_labels) printf("%s = ", name);
2537 printf("%s\n", s ? string_printing(s) : US"");
2538 break;
2539 }
2540 }
2541
2542 /* Else fall through */
2543
2544 case opt_uid:
2545 if (!no_labels) printf("%s = ", name);
2546 if (! *get_set_flag(name, oltop, last, options_block))
2547 printf("\n");
2548 else
2549 if ((pw = getpwuid(*((uid_t *)value))))
2550 printf("%s\n", pw->pw_name);
2551 else
2552 printf("%ld\n", (long int)(*((uid_t *)value)));
2553 break;
2554
2555 /* If the numerical value is unset, try for the string value */
2556
2557 case opt_expand_gid:
2558 if (! *get_set_flag(name, oltop, last, options_block))
2559 {
2560 sprintf(CS name2, "*expand_%.50s", name);
2561 if ( (ol2 = find_option(name2, oltop, last))
2562 && (ol2->type & opt_mask) == opt_stringptr)
2563 {
2564 void *value2 = ol2->value;
2565 if (options_block)
2566 value2 = (void *)(US options_block + (long int)value2);
2567 s = *(USS value2);
2568 if (!no_labels) printf("%s = ", name);
2569 printf("%s\n", s ? string_printing(s) : US"");
2570 break;
2571 }
2572 }
2573
2574 /* Else fall through */
2575
2576 case opt_gid:
2577 if (!no_labels) printf("%s = ", name);
2578 if (! *get_set_flag(name, oltop, last, options_block))
2579 printf("\n");
2580 else
2581 if ((gr = getgrgid(*((int *)value))))
2582 printf("%s\n", gr->gr_name);
2583 else
2584 printf("%ld\n", (long int)(*((int *)value)));
2585 break;
2586
2587 case opt_uidlist:
2588 uidlist = *((uid_t **)value);
2589 if (!no_labels) printf("%s =", name);
2590 if (uidlist)
2591 {
2592 int i;
2593 uschar sep = no_labels ? '\0' : ' ';
2594 for (i = 1; i <= (int)(uidlist[0]); i++)
2595 {
2596 uschar *name = NULL;
2597 if ((pw = getpwuid(uidlist[i]))) name = US pw->pw_name;
2598 if (sep != '\0') printf("%c", sep);
2599 if (name) printf("%s", name);
2600 else printf("%ld", (long int)(uidlist[i]));
2601 sep = ':';
2602 }
2603 }
2604 printf("\n");
2605 break;
2606
2607 case opt_gidlist:
2608 gidlist = *((gid_t **)value);
2609 if (!no_labels) printf("%s =", name);
2610 if (gidlist)
2611 {
2612 int i;
2613 uschar sep = no_labels ? '\0' : ' ';
2614 for (i = 1; i <= (int)(gidlist[0]); i++)
2615 {
2616 uschar *name = NULL;
2617 if ((gr = getgrgid(gidlist[i]))) name = US gr->gr_name;
2618 if (sep != '\0') printf("%c", sep);
2619 if (name) printf("%s", name);
2620 else printf("%ld", (long int)(gidlist[i]));
2621 sep = ':';
2622 }
2623 }
2624 printf("\n");
2625 break;
2626
2627 case opt_time:
2628 if (!no_labels) printf("%s = ", name);
2629 printf("%s\n", readconf_printtime(*((int *)value)));
2630 break;
2631
2632 case opt_timelist:
2633 {
2634 int i;
2635 int *list = (int *)value;
2636 if (!no_labels) printf("%s = ", name);
2637 for (i = 0; i < list[1]; i++)
2638 printf("%s%s", i == 0 ? "" : ":", readconf_printtime(list[i+2]));
2639 printf("\n");
2640 }
2641 break;
2642
2643 case opt_bit:
2644 printf("%s%s\n", ((*((int *)value)) & (1 << ((ol->type >> 16) & 31)))?
2645 "" : "no_", name);
2646 break;
2647
2648 case opt_expand_bool:
2649 sprintf(CS name2, "*expand_%.50s", name);
2650 if ((ol2 = find_option(name2, oltop, last)) && ol2->value)
2651 {
2652 void *value2 = ol2->value;
2653 if (options_block)
2654 value2 = (void *)(US options_block + (long int)value2);
2655 s = *(USS value2);
2656 if (s)
2657 {
2658 if (!no_labels) printf("%s = ", name);
2659 printf("%s\n", string_printing(s));
2660 break;
2661 }
2662 /* s == NULL => string not set; fall through */
2663 }
2664
2665 /* Fall through */
2666
2667 case opt_bool:
2668 case opt_bool_verify:
2669 case opt_bool_set:
2670 printf("%s%s\n", (*((BOOL *)value))? "" : "no_", name);
2671 break;
2672 }
2673 return TRUE;
2674 }
2675
2676
2677
2678 /*************************************************
2679 * Print value from main configuration *
2680 *************************************************/
2681
2682 /* This function, called as a result of encountering the -bP option,
2683 causes the value of any main configuration variable to be output if the
2684 second argument is NULL. There are some special values:
2685
2686 all print all main configuration options
2687 config_file print the name of the configuration file
2688 (configure_file will still work, for backward
2689 compatibility)
2690 routers print the routers' configurations
2691 transports print the transports' configuration
2692 authenticators print the authenticators' configuration
2693 macros print the macros' configuration
2694 router_list print a list of router names
2695 transport_list print a list of transport names
2696 authenticator_list print a list of authentication mechanism names
2697 macro_list print a list of macro names
2698 +name print a named list item
2699 local_scan print the local_scan options
2700 config print the configuration as it is parsed
2701 environment print the used execution environment
2702
2703 If the second argument is not NULL, it must be one of "router", "transport",
2704 "authenticator" or "macro" in which case the first argument identifies the
2705 driver whose options are to be printed.
2706
2707 Arguments:
2708 name option name if type == NULL; else driver name
2709 type NULL or driver type name, as described above
2710 no_labels avoid the "foo = " at the start of an item
2711
2712 Returns: Boolean success
2713 */
2714
2715 BOOL
2716 readconf_print(uschar *name, uschar *type, BOOL no_labels)
2717 {
2718 BOOL names_only = FALSE;
2719 optionlist *ol;
2720 optionlist *ol2 = NULL;
2721 driver_instance *d = NULL;
2722 macro_item *m;
2723 int size = 0;
2724
2725 if (!type)
2726 {
2727 if (*name == '+')
2728 {
2729 int i;
2730 tree_node *t;
2731 BOOL found = FALSE;
2732 static uschar *types[] = { US"address", US"domain", US"host",
2733 US"localpart" };
2734 static tree_node **anchors[] = { &addresslist_anchor, &domainlist_anchor,
2735 &hostlist_anchor, &localpartlist_anchor };
2736
2737 for (i = 0; i < 4; i++)
2738 if ((t = tree_search(*(anchors[i]), name+1)))
2739 {
2740 found = TRUE;
2741 if (no_labels)
2742 printf("%s\n", ((namedlist_block *)(t->data.ptr))->string);
2743 else
2744 printf("%slist %s = %s\n", types[i], name+1,
2745 ((namedlist_block *)(t->data.ptr))->string);
2746 }
2747
2748 if (!found)
2749 printf("no address, domain, host, or local part list called \"%s\" "
2750 "exists\n", name+1);
2751
2752 return found;
2753 }
2754
2755 if ( Ustrcmp(name, "configure_file") == 0
2756 || Ustrcmp(name, "config_file") == 0)
2757 {
2758 printf("%s\n", CS config_main_filename);
2759 return TRUE;
2760 }
2761
2762 if (Ustrcmp(name, "all") == 0)
2763 {
2764 for (ol = optionlist_config;
2765 ol < optionlist_config + nelem(optionlist_config); ol++)
2766 if (!(ol->type & opt_hidden))
2767 (void) print_ol(ol, US ol->name, NULL,
2768 optionlist_config, nelem(optionlist_config),
2769 no_labels);
2770 return TRUE;
2771 }
2772
2773 if (Ustrcmp(name, "local_scan") == 0)
2774 {
2775 #ifndef LOCAL_SCAN_HAS_OPTIONS
2776 printf("local_scan() options are not supported\n");
2777 return FALSE;
2778 #else
2779 for (ol = local_scan_options;
2780 ol < local_scan_options + local_scan_options_count; ol++)
2781 (void) print_ol(ol, US ol->name, NULL, local_scan_options,
2782 local_scan_options_count, no_labels);
2783 return TRUE;
2784 #endif
2785 }
2786
2787 if (Ustrcmp(name, "config") == 0)
2788 {
2789 print_config(f.admin_user, no_labels);
2790 return TRUE;
2791 }
2792
2793 if (Ustrcmp(name, "routers") == 0)
2794 {
2795 type = US"router";
2796 name = NULL;
2797 }
2798 else if (Ustrcmp(name, "transports") == 0)
2799 {
2800 type = US"transport";
2801 name = NULL;
2802 }
2803 else if (Ustrcmp(name, "authenticators") == 0)
2804 {
2805 type = US"authenticator";
2806 name = NULL;
2807 }
2808 else if (Ustrcmp(name, "macros") == 0)
2809 {
2810 type = US"macro";
2811 name = NULL;
2812 }
2813 else if (Ustrcmp(name, "router_list") == 0)
2814 {
2815 type = US"router";
2816 name = NULL;
2817 names_only = TRUE;
2818 }
2819 else if (Ustrcmp(name, "transport_list") == 0)
2820 {
2821 type = US"transport";
2822 name = NULL;
2823 names_only = TRUE;
2824 }
2825 else if (Ustrcmp(name, "authenticator_list") == 0)
2826 {
2827 type = US"authenticator";
2828 name = NULL;
2829 names_only = TRUE;
2830 }
2831 else if (Ustrcmp(name, "macro_list") == 0)
2832 {
2833 type = US"macro";
2834 name = NULL;
2835 names_only = TRUE;
2836 }
2837 else if (Ustrcmp(name, "environment") == 0)
2838 {
2839 if (environ)
2840 {
2841 uschar ** p;
2842 for (p = USS environ; *p; p++) ;
2843 qsort(environ, p - USS environ, sizeof(*p), string_compare_by_pointer);
2844
2845 for (p = USS environ; *p; p++)
2846 {
2847 uschar * q;
2848 if (no_labels && (q = Ustrchr(*p, '='))) *q = '\0';
2849 puts(CS *p);
2850 }
2851 }
2852 return TRUE;
2853 }
2854
2855 else
2856 return print_ol(find_option(name,
2857 optionlist_config, nelem(optionlist_config)),
2858 name, NULL, optionlist_config, nelem(optionlist_config), no_labels);
2859 }
2860
2861 /* Handle the options for a router or transport. Skip options that are flagged
2862 as hidden. Some of these are options with names starting with '*', used for
2863 internal alternative representations of other options (which the printing
2864 function will sort out). Others are synonyms kept for backward compatibility.
2865 */
2866
2867 if (Ustrcmp(type, "router") == 0)
2868 {
2869 d = (driver_instance *)routers;
2870 ol2 = optionlist_routers;
2871 size = optionlist_routers_size;
2872 }
2873 else if (Ustrcmp(type, "transport") == 0)
2874 {
2875 d = (driver_instance *)transports;
2876 ol2 = optionlist_transports;
2877 size = optionlist_transports_size;
2878 }
2879 else if (Ustrcmp(type, "authenticator") == 0)
2880 {
2881 d = (driver_instance *)auths;
2882 ol2 = optionlist_auths;
2883 size = optionlist_auths_size;
2884 }
2885
2886 else if (Ustrcmp(type, "macro") == 0)
2887 {
2888 /* People store passwords in macros and they were previously not available
2889 for printing. So we have an admin_users restriction. */
2890 if (!f.admin_user)
2891 {
2892 fprintf(stderr, "exim: permission denied\n");
2893 return FALSE;
2894 }
2895 for (m = macros; m; m = m->next)
2896 if (!name || Ustrcmp(name, m->name) == 0)
2897 {
2898 if (names_only)
2899 printf("%s\n", CS m->name);
2900 else if (no_labels)
2901 printf("%s\n", CS m->replacement);
2902 else
2903 printf("%s=%s\n", CS m->name, CS m->replacement);
2904 if (name)
2905 return TRUE;
2906 }
2907 if (!name) return TRUE;
2908
2909 printf("%s %s not found\n", type, name);
2910 return FALSE;
2911 }
2912
2913 if (names_only)
2914 {
2915 for (; d; d = d->next) printf("%s\n", CS d->name);
2916 return TRUE;
2917 }
2918
2919 /* Either search for a given driver, or print all of them */
2920
2921 for (; d; d = d->next)
2922 {
2923 BOOL rc = FALSE;
2924 if (!name)
2925 printf("\n%s %s:\n", d->name, type);
2926 else if (Ustrcmp(d->name, name) != 0) continue;
2927
2928 for (ol = ol2; ol < ol2 + size; ol++)
2929 if (!(ol->type & opt_hidden))
2930 rc |= print_ol(ol, US ol->name, d, ol2, size, no_labels);
2931
2932 for (ol = d->info->options;
2933 ol < d->info->options + *(d->info->options_count); ol++)
2934 if (!(ol->type & opt_hidden))
2935 rc |= print_ol(ol, US ol->name, d, d->info->options,
2936 *d->info->options_count, no_labels);
2937
2938 if (name) return rc;
2939 }
2940 if (!name) return TRUE;
2941
2942 printf("%s %s not found\n", type, name);
2943 return FALSE;
2944 }
2945
2946
2947
2948 /*************************************************
2949 * Read a named list item *
2950 *************************************************/
2951
2952 /* This function reads a name and a list (i.e. string). The name is used to
2953 save the list in a tree, sorted by its name. Each entry also has a number,
2954 which can be used for caching tests, but if the string contains any expansion
2955 items other than $key, the number is set negative to inhibit caching. This
2956 mechanism is used for domain, host, and address lists that are referenced by
2957 the "+name" syntax.
2958
2959 Arguments:
2960 anchorp points to the tree anchor
2961 numberp points to the current number for this tree
2962 max the maximum number permitted
2963 s the text of the option line, starting immediately after the name
2964 of the list type
2965 tname the name of the list type, for messages
2966
2967 Returns: nothing
2968 */
2969
2970 static void
2971 read_named_list(tree_node **anchorp, int *numberp, int max, uschar *s,
2972 uschar *tname)
2973 {
2974 BOOL forcecache = FALSE;
2975 uschar *ss;
2976 tree_node *t;
2977 namedlist_block *nb = store_get(sizeof(namedlist_block));
2978
2979 if (Ustrncmp(s, "_cache", 6) == 0)
2980 {
2981 forcecache = TRUE;
2982 s += 6;
2983 }
2984
2985 if (!isspace(*s))
2986 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unrecognized configuration line");
2987
2988 if (*numberp >= max)
2989 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many named %ss (max is %d)\n",
2990 tname, max);
2991
2992 while (isspace(*s)) s++;
2993 ss = s;
2994 while (isalnum(*s) || *s == '_') s++;
2995 t = store_get(sizeof(tree_node) + s-ss);
2996 Ustrncpy(t->name, ss, s-ss);
2997 t->name[s-ss] = 0;
2998 while (isspace(*s)) s++;
2999
3000 if (!tree_insertnode(anchorp, t))
3001 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3002 "duplicate name \"%s\" for a named %s", t->name, tname);
3003
3004 t->data.ptr = nb;
3005 nb->number = *numberp;
3006 *numberp += 1;
3007
3008 if (*s++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3009 "missing '=' after \"%s\"", t->name);
3010 while (isspace(*s)) s++;
3011 nb->string = read_string(s, t->name);
3012 nb->cache_data = NULL;
3013
3014 /* Check the string for any expansions; if any are found, mark this list
3015 uncacheable unless the user has explicited forced caching. */
3016
3017 if (!forcecache && Ustrchr(nb->string, '$') != NULL) nb->number = -1;
3018 }
3019
3020
3021
3022
3023 /*************************************************
3024 * Unpick data for a rate limit *
3025 *************************************************/
3026
3027 /* This function is called to unpick smtp_ratelimit_{mail,rcpt} into four
3028 separate values.
3029
3030 Arguments:
3031 s string, in the form t,b,f,l
3032 where t is the threshold (integer)
3033 b is the initial delay (time)
3034 f is the multiplicative factor (fixed point)
3035 k is the maximum time (time)
3036 threshold where to store threshold
3037 base where to store base in milliseconds
3038 factor where to store factor in milliseconds
3039 limit where to store limit
3040
3041 Returns: nothing (panics on error)
3042 */
3043
3044 static void
3045 unpick_ratelimit(uschar *s, int *threshold, int *base, double *factor,
3046 int *limit)
3047 {
3048 uschar bstring[16], lstring[16];
3049
3050 if (sscanf(CS s, "%d, %15[0123456789smhdw.], %lf, %15s", threshold, bstring,
3051 factor, lstring) == 4)
3052 {
3053 *base = readconf_readtime(bstring, 0, TRUE);
3054 *limit = readconf_readtime(lstring, 0, TRUE);
3055 if (*base >= 0 && *limit >= 0) return;
3056 }
3057 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "malformed ratelimit data: %s", s);
3058 }
3059
3060
3061
3062
3063 /*************************************************
3064 * Drop privs for checking TLS config *
3065 *************************************************/
3066
3067 /* We want to validate TLS options during readconf, but do not want to be
3068 root when we call into the TLS library, in case of library linkage errors
3069 which cause segfaults; before this check, those were always done as the Exim
3070 runtime user and it makes sense to continue with that.
3071
3072 Assumes: tls_require_ciphers has been set, if it will be
3073 exim_user has been set, if it will be
3074 exim_group has been set, if it will be
3075
3076 Returns: bool for "okay"; false will cause caller to immediately exit.
3077 */
3078
3079 #ifdef SUPPORT_TLS
3080 static BOOL
3081 tls_dropprivs_validate_require_cipher(BOOL nowarn)
3082 {
3083 const uschar *errmsg;
3084 pid_t pid;
3085 int rc, status;
3086 void (*oldsignal)(int);
3087
3088 /* If TLS will never be used, no point checking ciphers */
3089
3090 if ( !tls_advertise_hosts
3091 || !*tls_advertise_hosts
3092 || Ustrcmp(tls_advertise_hosts, ":") == 0
3093 )
3094 return TRUE;
3095 else if (!nowarn && !tls_certificate)
3096 log_write(0, LOG_MAIN,
3097 "Warning: No server certificate defined; will use a selfsigned one.\n"
3098 " Suggested action: either install a certificate or change tls_advertise_hosts option");
3099
3100 oldsignal = signal(SIGCHLD, SIG_DFL);
3101
3102 fflush(NULL);
3103 if ((pid = fork()) < 0)
3104 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "fork failed for TLS check");
3105
3106 if (pid == 0)
3107 {
3108 /* in some modes, will have dropped privilege already */
3109 if (!geteuid())
3110 exim_setugid(exim_uid, exim_gid, FALSE,
3111 US"calling tls_validate_require_cipher");
3112
3113 if ((errmsg = tls_validate_require_cipher()))
3114 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3115 "tls_require_ciphers invalid: %s", errmsg);
3116 fflush(NULL);
3117 _exit(0);
3118 }
3119
3120 do {
3121 rc = waitpid(pid, &status, 0);
3122 } while (rc < 0 && errno == EINTR);
3123
3124 DEBUG(D_tls)
3125 debug_printf("tls_validate_require_cipher child %d ended: status=0x%x\n",
3126 (int)pid, status);
3127
3128 signal(SIGCHLD, oldsignal);
3129
3130 return status == 0;
3131 }
3132 #endif /* SUPPORT_TLS */
3133
3134
3135
3136
3137 /*************************************************
3138 * Read main configuration options *
3139 *************************************************/
3140
3141 /* This function is the first to be called for configuration reading. It
3142 opens the configuration file and reads general configuration settings until
3143 it reaches the end of the configuration section. The file is then left open so
3144 that the remaining configuration data can subsequently be read if needed for
3145 this run of Exim.
3146
3147 The configuration file must be owned either by root or exim, and be writeable
3148 only by root or uid/gid exim. The values for Exim's uid and gid can be changed
3149 in the config file, so the test is done on the compiled in values. A slight
3150 anomaly, to be carefully documented.
3151
3152 The name of the configuration file is taken from a list that is included in the
3153 binary of Exim. It can be altered from the command line, but if that is done,
3154 root privilege is immediately withdrawn unless the caller is root or exim.
3155 The first file on the list that exists is used.
3156
3157 For use on multiple systems that share file systems, first look for a
3158 configuration file whose name has the current node name on the end. If that is
3159 not found, try the generic name. For really contorted configurations, that run
3160 multiple Exims with different uid settings, first try adding the effective uid
3161 before the node name. These complications are going to waste resources on most
3162 systems. Therefore they are available only when requested by compile-time
3163 options. */
3164
3165 void
3166 readconf_main(BOOL nowarn)
3167 {
3168 int sep = 0;
3169 struct stat statbuf;
3170 uschar *s, *filename;
3171 const uschar *list = config_main_filelist;
3172
3173 /* Loop through the possible file names */
3174
3175 while((filename = string_nextinlist(&list, &sep, big_buffer, big_buffer_size)))
3176 {
3177
3178 /* Cut out all the fancy processing unless specifically wanted */
3179
3180 #if defined(CONFIGURE_FILE_USE_NODE) || defined(CONFIGURE_FILE_USE_EUID)
3181 uschar *suffix = filename + Ustrlen(filename);
3182
3183 /* Try for the node-specific file if a node name exists */
3184
3185 #ifdef CONFIGURE_FILE_USE_NODE
3186 struct utsname uts;
3187 if (uname(&uts) >= 0)
3188 {
3189 #ifdef CONFIGURE_FILE_USE_EUID
3190 sprintf(CS suffix, ".%ld.%.256s", (long int)original_euid, uts.nodename);
3191 config_file = Ufopen(filename, "rb");
3192 if (config_file == NULL)
3193 #endif /* CONFIGURE_FILE_USE_EUID */
3194 {
3195 sprintf(CS suffix, ".%.256s", uts.nodename);
3196 config_file = Ufopen(filename, "rb");
3197 }
3198 }
3199 #endif /* CONFIGURE_FILE_USE_NODE */
3200
3201 /* Otherwise, try the generic name, possibly with the euid added */
3202
3203 #ifdef CONFIGURE_FILE_USE_EUID
3204 if (config_file == NULL)
3205 {
3206 sprintf(CS suffix, ".%ld", (long int)original_euid);
3207 config_file = Ufopen(filename, "rb");
3208 }
3209 #endif /* CONFIGURE_FILE_USE_EUID */
3210
3211 /* Finally, try the unadorned name */
3212
3213 if (config_file == NULL)
3214 {
3215 *suffix = 0;
3216 config_file = Ufopen(filename, "rb");
3217 }
3218 #else /* if neither defined */
3219
3220 /* This is the common case when the fancy processing is not included. */
3221
3222 config_file = Ufopen(filename, "rb");
3223 #endif
3224
3225 /* If the file does not exist, continue to try any others. For any other
3226 error, break out (and die). */
3227
3228 if (config_file != NULL || errno != ENOENT) break;
3229 }
3230
3231 /* On success, save the name for verification; config_filename is used when
3232 logging configuration errors (it changes for .included files) whereas
3233 config_main_filename is the name shown by -bP. Failure to open a configuration
3234 file is a serious disaster. */
3235
3236 if (config_file)
3237 {
3238 uschar *last_slash = Ustrrchr(filename, '/');
3239 config_filename = config_main_filename = string_copy(filename);
3240
3241 /* The config_main_directory we need for the $config_dir expansion.
3242 config_main_filename we need for $config_file expansion.
3243 And config_dir is the directory of the current configuration, used for
3244 relative .includes. We do need to know it's name, as we change our working
3245 directory later. */
3246
3247 if (filename[0] == '/')
3248 config_main_directory = last_slash == filename ? US"/" : string_copyn(filename, last_slash - filename);
3249 else
3250 {
3251 /* relative configuration file name: working dir + / + basename(filename) */
3252
3253 uschar buf[PATH_MAX];
3254 gstring * g;
3255
3256 if (os_getcwd(buf, PATH_MAX) == NULL)
3257 {
3258 perror("exim: getcwd");
3259 exit(EXIT_FAILURE);
3260 }
3261 g = string_cat(NULL, buf);
3262
3263 /* If the dir does not end with a "/", append one */
3264 if (g->s[g->ptr-1] != '/')
3265 g = string_catn(g, US"/", 1);
3266
3267 /* If the config file contains a "/", extract the directory part */
3268 if (last_slash)
3269 g = string_catn(g, filename, last_slash - filename);
3270
3271 config_main_directory = string_from_gstring(g);
3272 }
3273 config_directory = config_main_directory;
3274 }
3275 else
3276 {
3277 if (filename == NULL)
3278 log_write(