projects / exim.git / blob
? search:


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