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