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