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