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