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