Testsuite: fix 0903
[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);
e94526c5 1181 ss[offset] = '\0'; /* string_append() does not zero terminate the string! */
f10e2052 1182 }
145396a6 1183
059ec3d9
PH
1184 if (include_if_exists != 0 && (Ustat(ss, &statbuf) != 0)) continue;
1185
bf3c2c6b
HSHR
1186 if (config_lines)
1187 save_config_position(config_filename, config_lineno);
059ec3d9
PH
1188 save = store_get(sizeof(config_file_item));
1189 save->next = config_file_stack;
1190 config_file_stack = save;
1191 save->file = config_file;
1192 save->filename = config_filename;
f10e2052 1193 save->directory = config_directory;
059ec3d9
PH
1194 save->lineno = config_lineno;
1195
4fab92fb 1196 if (!(config_file = Ufopen(ss, "rb")))
059ec3d9
PH
1197 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to open included "
1198 "configuration file %s", ss);
4fab92fb 1199
059ec3d9 1200 config_filename = string_copy(ss);
f10e2052 1201 config_directory = string_copyn(ss, (const uschar*) strrchr(ss, '/') - ss);
059ec3d9
PH
1202 config_lineno = 0;
1203 continue;
1204 }
1205
1206 /* If this is the start of the logical line, remember where the non-blank
1207 data starts. Otherwise shuffle down continuation lines to remove leading
1208 white space. */
1209
1210 if (len == 0)
1211 startoffset = ss - big_buffer;
1212 else
1213 {
1214 s = big_buffer + len;
1215 if (ss > s)
1216 {
1217 memmove(s, ss, (newlen - len) - (ss - s) + 1);
1218 newlen -= ss - s;
1219 }
1220 }
1221
1222 /* Accept the new addition to the line. Remove trailing white space. */
1223
1224 len = newlen;
1225 while (len > 0 && isspace(big_buffer[len-1])) len--;
1226 big_buffer[len] = 0;
1227
1228 /* We are done if the line does not end in backslash and contains some data.
1229 Empty logical lines are ignored. For continuations, remove the backslash and
1230 go round the loop to read the continuation line. */
1231
1232 if (len > 0)
1233 {
1234 if (big_buffer[len-1] != '\\') break; /* End of logical line */
1235 big_buffer[--len] = 0; /* Remove backslash */
1236 }
1237 } /* Loop for reading multiple physical lines */
1238
1239/* We now have a logical line. Test for the end of a configuration section (or,
1240more accurately, for the start of the next section). Place the name of the next
1241section in next_section, and return NULL. If the name given is longer than
1242next_section, truncate it. It will be unrecognized later, because all the known
1243section names do fit. Leave space for pluralizing. */
1244
1245s = big_buffer + startoffset; /* First non-space character */
bf3c2c6b
HSHR
1246
1247if (config_lines)
1248 save_config_line(s);
1249
059ec3d9
PH
1250if (strncmpic(s, US"begin ", 6) == 0)
1251 {
1252 s += 6;
1253 while (isspace(*s)) s++;
1254 if (big_buffer + len - s > sizeof(next_section) - 2)
1255 s[sizeof(next_section) - 2] = 0;
1256 Ustrcpy(next_section, s);
1257 return NULL;
1258 }
1259
1260/* Return the first non-blank character. */
1261
1262return s;
1263}
1264
1265
1266
1267/*************************************************
1268* Read a name *
1269*************************************************/
1270
1271/* The yield is the pointer to the next uschar. Names longer than the
1272output space are silently truncated. This function is also used from acl.c when
1273parsing ACLs.
1274
1275Arguments:
1276 name where to put the name
1277 len length of name
1278 s input pointer
1279
1280Returns: new input pointer
1281*/
1282
1283uschar *
1284readconf_readname(uschar *name, int len, uschar *s)
1285{
1286int p = 0;
1287while (isspace(*s)) s++;
1288if (isalpha(*s))
1289 {
1290 while (isalnum(*s) || *s == '_')
1291 {
1292 if (p < len-1) name[p++] = *s;
1293 s++;
1294 }
1295 }
1296name[p] = 0;
1297while (isspace(*s)) s++;
1298return s;
1299}
1300
1301
1302
1303
1304/*************************************************
1305* Read a time value *
1306*************************************************/
1307
1308/* This function is also called from outside, to read argument
1309time values. The format of a time value is:
1310
1311 [<n>w][<n>d][<n>h][<n>m][<n>s]
1312
1313as long as at least one is present. If a format error is encountered,
1314return a negative value. The value must be terminated by the given
1315terminator.
1316
1317Arguments:
1318 s input pointer
1319 terminator required terminating character
1320 return_msec if TRUE, allow fractional seconds and return milliseconds
1321
1322Returns: the time value, or -1 on syntax error
1323 value is seconds if return_msec is FALSE
1324 value is milliseconds if return_msec is TRUE
1325*/
1326
1327int
1ad6489e 1328readconf_readtime(const uschar *s, int terminator, BOOL return_msec)
059ec3d9
PH
1329{
1330int yield = 0;
1331for (;;)
1332 {
1333 int value, count;
1334 double fraction;
1335
1336 if (!isdigit(*s)) return -1;
1ad6489e 1337 (void)sscanf(CCS s, "%d%n", &value, &count);
059ec3d9
PH
1338 s += count;
1339
1340 switch (*s)
1341 {
1342 case 'w': value *= 7;
1343 case 'd': value *= 24;
1344 case 'h': value *= 60;
1345 case 'm': value *= 60;
1346 case 's': s++;
1347 break;
1348
1349 case '.':
1350 if (!return_msec) return -1;
1ad6489e 1351 (void)sscanf(CCS s, "%lf%n", &fraction, &count);
059ec3d9
PH
1352 s += count;
1353 if (*s++ != 's') return -1;
1354 yield += (int)(fraction * 1000.0);
1355 break;
1356
1357 default: return -1;
1358 }
1359
1360 if (return_msec) value *= 1000;
1361 yield += value;
1362 if (*s == terminator) return yield;
1363 }
1364/* Control never reaches here. */
1365}
1366
1367
1368
1369/*************************************************
1370* Read a fixed point value *
1371*************************************************/
1372
1373/* The value is returned *1000
1374
1375Arguments:
1376 s input pointer
1377 terminator required terminator
1378
1379Returns: the value, or -1 on error
1380*/
1381
1382static int
55414b25 1383readconf_readfixed(const uschar *s, int terminator)
059ec3d9
PH
1384{
1385int yield = 0;
1386int value, count;
1387if (!isdigit(*s)) return -1;
1388(void)sscanf(CS s, "%d%n", &value, &count);
1389s += count;
1390yield = value * 1000;
1391if (*s == '.')
1392 {
1393 int m = 100;
1394 while (isdigit((*(++s))))
1395 {
1396 yield += (*s - '0') * m;
1397 m /= 10;
1398 }
1399 }
1400
1401return (*s == terminator)? yield : (-1);
1402}
1403
1404
1405
1406/*************************************************
1407* Find option in list *
1408*************************************************/
1409
1410/* The lists are always in order, so binary chop can be used.
1411
1412Arguments:
1413 name the option name to search for
1414 ol the first entry in the option list
1415 last one more than the offset of the last entry in the option list
1416
1417Returns: pointer to an option entry, or NULL if not found
1418*/
1419
1420static optionlist *
1421find_option(uschar *name, optionlist *ol, int last)
1422{
1423int first = 0;
1424while (last > first)
1425 {
1426 int middle = (first + last)/2;
1427 int c = Ustrcmp(name, ol[middle].name);
4fab92fb 1428
059ec3d9 1429 if (c == 0) return ol + middle;
4fab92fb
HSHR
1430 else if (c > 0) first = middle + 1;
1431 else last = middle;
059ec3d9
PH
1432 }
1433return NULL;
1434}
1435
1436
1437
1438/*************************************************
1439* Find a set flag in option list *
1440*************************************************/
1441
1442/* Because some versions of Unix make no restrictions on the values of uids and
1443gids (even negative ones), we cannot represent "unset" by a special value.
1444There is therefore a separate boolean variable for each one indicating whether
1445a value is set or not. This function returns a pointer to the boolean, given
1446the original option name. It is a major disaster if the flag cannot be found.
1447
1448Arguments:
1449 name the name of the uid or gid option
1450 oltop points to the start of the relevant option list
1451 last one more than the offset of the last item in the option list
1452 data_block NULL when reading main options => data values in the option
1453 list are absolute addresses; otherwise they are byte offsets
1454 in data_block (used for driver options)
1455
1456Returns: a pointer to the boolean flag.
1457*/
1458
1459static BOOL *
1460get_set_flag(uschar *name, optionlist *oltop, int last, void *data_block)
1461{
1462optionlist *ol;
1463uschar name2[64];
1464sprintf(CS name2, "*set_%.50s", name);
1465ol = find_option(name2, oltop, last);
1466if (ol == NULL) log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1467 "Exim internal error: missing set flag for %s", name);
1468return (data_block == NULL)? (BOOL *)(ol->value) :
1469 (BOOL *)((uschar *)data_block + (long int)(ol->value));
1470}
1471
1472
1473
1474
1475/*************************************************
1476* Output extra characters message and die *
1477*************************************************/
1478
1479/* Called when an option line has junk on the end. Sometimes this is because
1480the sysadmin thinks comments are permitted.
1481
1482Arguments:
1483 s points to the extra characters
1484 t1..t3 strings to insert in the log message
1485
1486Returns: doesn't return; dies
1487*/
1488
1489static void
55414b25 1490extra_chars_error(const uschar *s, const uschar *t1, const uschar *t2, const uschar *t3)
059ec3d9
PH
1491{
1492uschar *comment = US"";
1493if (*s == '#') comment = US" (# is comment only at line start)";
1494log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1495 "extra characters follow %s%s%s%s", t1, t2, t3, comment);
1496}
1497
1498
1499
1500/*************************************************
1501* Read rewrite information *
1502*************************************************/
1503
1504/* Each line of rewrite information contains:
1505
1506. A complete address in the form user@domain, possibly with
1507 leading * for each part; or alternatively, a regex.
1508
1509. A replacement string (which will be expanded).
1510
1511. An optional sequence of one-letter flags, indicating which
1512 headers etc. to apply this rule to.
1513
1514All this is decoded and placed into a control block. The OR of the flags is
1515maintained in a common word.
1516
1517Arguments:
1518 p points to the string that makes up the rule
1519 existflags points to the overall flag word
1520 isglobal TRUE if reading global rewrite rules
1521
1522Returns: the control block for the parsed rule.
1523*/
1524
1525static rewrite_rule *
55414b25 1526readconf_one_rewrite(const uschar *p, int *existflags, BOOL isglobal)
059ec3d9
PH
1527{
1528rewrite_rule *next = store_get(sizeof(rewrite_rule));
1529
1530next->next = NULL;
1531next->key = string_dequote(&p);
1532
1533while (isspace(*p)) p++;
1534if (*p == 0)
1535 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1536 "missing rewrite replacement string");
1537
1538next->flags = 0;
1539next->replacement = string_dequote(&p);
1540
1541while (*p != 0) switch (*p++)
1542 {
1543 case ' ': case '\t': break;
1544
1545 case 'q': next->flags |= rewrite_quit; break;
1546 case 'w': next->flags |= rewrite_whole; break;
1547
1548 case 'h': next->flags |= rewrite_all_headers; break;
1549 case 's': next->flags |= rewrite_sender; break;
1550 case 'f': next->flags |= rewrite_from; break;
1551 case 't': next->flags |= rewrite_to; break;
1552 case 'c': next->flags |= rewrite_cc; break;
1553 case 'b': next->flags |= rewrite_bcc; break;
1554 case 'r': next->flags |= rewrite_replyto; break;
1555
1556 case 'E': next->flags |= rewrite_all_envelope; break;
1557 case 'F': next->flags |= rewrite_envfrom; break;
1558 case 'T': next->flags |= rewrite_envto; break;
1559
1560 case 'Q': next->flags |= rewrite_qualify; break;
1561 case 'R': next->flags |= rewrite_repeat; break;
1562
1563 case 'S':
1564 next->flags |= rewrite_smtp;
1565 if (next->key[0] != '^' && Ustrncmp(next->key, "\\N^", 3) != 0)
1566 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1567 "rewrite rule has the S flag but is not a regular expression");
1568 break;
1569
1570 default:
1571 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1572 "unknown rewrite flag character '%c' "
1573 "(could be missing quotes round replacement item)", p[-1]);
1574 break;
1575 }
1576
1577/* If no action flags are set, set all the "normal" rewrites. */
1578
1579if ((next->flags & (rewrite_all | rewrite_smtp)) == 0)
1580 next->flags |= isglobal? rewrite_all : rewrite_all_headers;
1581
1582/* Remember which exist, for optimization, and return the rule */
1583
1584*existflags |= next->flags;
1585return next;
1586}
1587
1588
1589
1590
1591/*************************************************
1592* Read global rewrite information *
1593*************************************************/
1594
1595/* Each line is a single rewrite rule; it is parsed into a control block
1596by readconf_one_rewrite(), and its flags are ORed into the global flag
1597word rewrite_existflags. */
1598
1599void
1600readconf_rewrites(void)
1601{
1602rewrite_rule **chain = &global_rewrite_rules;
1603uschar *p;
1604
1605while ((p = get_config_line()) != NULL)
1606 {
1607 rewrite_rule *next = readconf_one_rewrite(p, &rewrite_existflags, TRUE);
1608 *chain = next;
1609 chain = &(next->next);
1610 }
1611}
1612
1613
1614
1615/*************************************************
1616* Read a string *
1617*************************************************/
1618
1619/* Strings are read into the normal store pool. As long we aren't too
1620near the end of the current block, the string will just use what is necessary
1621on the top of the stacking pool, because string_cat() uses the extension
1622mechanism.
1623
1624Argument:
1625 s the rest of the input line
1626 name the option name (for errors)
1627
1628Returns: pointer to the string
1629*/
1630
1631static uschar *
55414b25 1632read_string(const uschar *s, const uschar *name)
059ec3d9
PH
1633{
1634uschar *yield;
55414b25 1635const uschar *ss;
059ec3d9
PH
1636
1637if (*s != '\"') return string_copy(s);
1638
1639ss = s;
1640yield = string_dequote(&s);
1641
1642if (s == ss+1 || s[-1] != '\"')
1643 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1644 "missing quote at end of string value for %s", name);
1645
1646if (*s != 0) extra_chars_error(s, US"string value for ", name, US"");
1647
1648return yield;
1649}
1650
1651
1652/*************************************************
1ad6489e
JH
1653* Custom-handler options *
1654*************************************************/
1655static void
1656fn_smtp_receive_timeout(const uschar * name, const uschar * str)
1657{
1ad6489e
JH
1658if (*str == '$')
1659 smtp_receive_timeout_s = string_copy(str);
1660else
1661 {
1662 /* "smtp_receive_timeout", opt_time, &smtp_receive_timeout */
1663 smtp_receive_timeout = readconf_readtime(str, 0, FALSE);
1664 if (smtp_receive_timeout < 0)
1665 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
1666 name);
1667 }
1668}
1669
1670/*************************************************
059ec3d9
PH
1671* Handle option line *
1672*************************************************/
1673
1674/* This function is called from several places to process a line containing the
1675setting of an option. The first argument is the line to be decoded; it has been
1676checked not to be empty and not to start with '#'. Trailing newlines and white
1677space have been removed. The second argument is a pointer to the list of
1678variable names that are to be recognized, together with their types and
1679locations, and the third argument gives the number of entries in the list.
1680
1681The fourth argument is a pointer to a data block. If it is NULL, then the data
1682values in the options list are absolute addresses. Otherwise, they are byte
1683offsets in the data block.
1684
1685String option data may continue onto several lines; this function reads further
1686data from config_file if necessary.
1687
1688The yield of this function is normally zero. If a string continues onto
1689multiple lines, then the data value is permitted to be followed by a comma
1690or a semicolon (for use in drivers) and the yield is that character.
1691
1692Arguments:
1693 buffer contains the configuration line to be handled
1694 oltop points to the start of the relevant option list
1695 last one more than the offset of the last item in the option list
1696 data_block NULL when reading main options => data values in the option
1697 list are absolute addresses; otherwise they are byte offsets
1698 in data_block when they have opt_public set; otherwise
1699 they are byte offsets in data_block->options_block.
1700 unknown_txt format string to use in panic message for unknown option;
1701 must contain %s for option name
1702 if given as NULL, don't panic on unknown option
1703
1704Returns: TRUE if an option was read successfully,
1705 FALSE false for an unknown option if unknown_txt == NULL,
1706 otherwise panic and die on an unknown option
1707*/
1708
1709static BOOL
1710readconf_handle_option(uschar *buffer, optionlist *oltop, int last,
1711 void *data_block, uschar *unknown_txt)
1712{
1713int ptr = 0;
1714int offset = 0;
1715int n, count, type, value;
1716int issecure = 0;
1717uid_t uid;
1718gid_t gid;
1719BOOL boolvalue = TRUE;
1720BOOL freesptr = TRUE;
1721optionlist *ol, *ol2;
1722struct passwd *pw;
1723void *reset_point;
1724int intbase = 0;
1725uschar *inttype = US"";
1726uschar *sptr;
1727uschar *s = buffer;
532be449 1728uschar **str_target;
059ec3d9
PH
1729uschar name[64];
1730uschar name2[64];
1731
1732/* There may be leading spaces; thereafter, we expect an option name starting
1733with a letter. */
1734
1735while (isspace(*s)) s++;
1736if (!isalpha(*s))
1737 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option setting expected: %s", s);
1738
1739/* Read the name of the option, and skip any subsequent white space. If
1740it turns out that what we read was "hide", set the flag indicating that
1741this is a secure option, and loop to read the next word. */
1742
1743for (n = 0; n < 2; n++)
1744 {
1745 while (isalnum(*s) || *s == '_')
1746 {
1747 if (ptr < sizeof(name)-1) name[ptr++] = *s;
1748 s++;
1749 }
1750 name[ptr] = 0;
1751 while (isspace(*s)) s++;
1752 if (Ustrcmp(name, "hide") != 0) break;
1753 issecure = opt_secure;
1754 ptr = 0;
1755 }
1756
1757/* Deal with "no_" or "not_" here for booleans */
1758
1759if (Ustrncmp(name, "no_", 3) == 0)
1760 {
1761 boolvalue = FALSE;
1762 offset = 3;
1763 }
1764
1765if (Ustrncmp(name, "not_", 4) == 0)
1766 {
1767 boolvalue = FALSE;
1768 offset = 4;
1769 }
1770
1771/* Search the list for the given name. A non-existent name, or an option that
1772is set twice, is a disaster. */
1773
4fab92fb 1774if (!(ol = find_option(name + offset, oltop, last)))
059ec3d9
PH
1775 {
1776 if (unknown_txt == NULL) return FALSE;
1777 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, CS unknown_txt, name);
1778 }
1779
846726c5
JH
1780if ((ol->type & opt_set) && !(ol->type & (opt_rep_con | opt_rep_str)))
1781 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1782 "\"%s\" option set for the second time", name);
059ec3d9
PH
1783
1784ol->type |= opt_set | issecure;
1785type = ol->type & opt_mask;
1786
1787/* Types with data values must be followed by '='; the "no[t]_" prefix
1788applies only to boolean values. */
1789
1790if (type < opt_bool || type > opt_bool_last)
1791 {
1792 if (offset != 0)
1793 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1794 "negation prefix applied to a non-boolean option");
1795 if (*s == 0)
1796 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1797 "unexpected end of line (data missing) after %s", name);
1798 if (*s != '=')
1799 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing \"=\" after %s", name);
1800 }
1801
1802/* If a boolean wasn't preceded by "no[t]_" it can be followed by = and
9c695f6d 1803true/false/yes/no, or, in the case of opt_expand_bool, a general string that
059ec3d9
PH
1804ultimately expands to one of those values. */
1805
1806else if (*s != 0 && (offset != 0 || *s != '='))
1807 extra_chars_error(s, US"boolean option ", name, US"");
1808
1809/* Skip white space after = */
1810
1811if (*s == '=') while (isspace((*(++s))));
1812
1813/* If there is a data block and the opt_public flag is not set, change
1814the data block pointer to the private options block. */
1815
1816if (data_block != NULL && (ol->type & opt_public) == 0)
1817 data_block = (void *)(((driver_instance *)data_block)->options_block);
1818
1819/* Now get the data according to the type. */
1820
1821switch (type)
1822 {
1823 /* If a string value is not enclosed in quotes, it consists of
1824 the rest of the current line, verbatim. Otherwise, string escapes
1825 are processed.
1826
1827 A transport is specified as a string, which is then looked up in the
1828 list of transports. A search type is specified as one of a number of
1829 known strings.
1830
1831 A set or rewrite rules for a driver is specified as a string, which is
1832 then parsed into a suitable chain of control blocks.
1833
1834 Uids and gids are specified as strings which are then looked up in the
1835 passwd file. Lists of uids and gids are similarly specified as colon-
1836 separated strings. */
1837
1838 case opt_stringptr:
1839 case opt_uid:
1840 case opt_gid:
1841 case opt_expand_uid:
1842 case opt_expand_gid:
1843 case opt_uidlist:
1844 case opt_gidlist:
1845 case opt_rewrite:
1846
1847 reset_point = sptr = read_string(s, name);
1848
1849 /* Having read a string, we now have several different ways of using it,
1850 depending on the data type, so do another switch. If keeping the actual
1851 string is not required (because it is interpreted), freesptr is set TRUE,
1852 and at the end we reset the pool. */
1853
1854 switch (type)
1855 {
1856 /* If this was a string, set the variable to point to the new string,
1857 and set the flag so its store isn't reclaimed. If it was a list of rewrite
1858 rules, we still keep the string (for printing), and parse the rules into a
1859 control block and flags word. */
1860
1861 case opt_stringptr:
4fab92fb
HSHR
1862 str_target = data_block ? USS (US data_block + (long int)(ol->value))
1863 : USS (ol->value);
846726c5 1864 if (ol->type & opt_rep_con)
532be449 1865 {
4fab92fb 1866 uschar * saved_condition;
6a8de854
PP
1867 /* We already have a condition, we're conducting a crude hack to let
1868 multiple condition rules be chained together, despite storing them in
1869 text form. */
4fab92fb
HSHR
1870 *str_target = string_copy_malloc( (saved_condition = *str_target)
1871 ? string_sprintf("${if and{{bool_lax{%s}}{bool_lax{%s}}}}",
1872 saved_condition, sptr)
1873 : sptr);
846726c5
JH
1874 /* TODO(pdp): there is a memory leak here and just below
1875 when we set 3 or more conditions; I still don't
1876 understand the store mechanism enough to know
1877 what's the safe way to free content from an earlier store.
6a8de854
PP
1878 AFAICT, stores stack, so freeing an early stored item also stores
1879 all data alloc'd after it. If we knew conditions were adjacent,
1880 we could survive that, but we don't. So I *think* we need to take
1881 another bit from opt_type to indicate "malloced"; this seems like
1882 quite a hack, especially for this one case. It also means that
1883 we can't ever reclaim the store from the *first* condition.
1884
1885 Because we only do this once, near process start-up, I'm prepared to
1886 let this slide for the time being, even though it rankles. */
532be449 1887 }
76146973
JH
1888 else if (ol->type & opt_rep_str)
1889 {
2ad78978
JH
1890 uschar sep_o = Ustrncmp(name, "headers_add", 11)==0 ? '\n' : ':';
1891 int sep_i = -(int)sep_o;
55414b25 1892 const uschar * list = sptr;
2ad78978
JH
1893 uschar * s;
1894 uschar * list_o = *str_target;
1895
1896 while ((s = string_nextinlist(&list, &sep_i, NULL, 0)))
1897 list_o = string_append_listele(list_o, sep_o, s);
1898 if (list_o)
1899 *str_target = string_copy_malloc(list_o);
76146973 1900 }
532be449
PP
1901 else
1902 {
1903 *str_target = sptr;
1904 freesptr = FALSE;
1905 }
1906 break;
1907
059ec3d9 1908 case opt_rewrite:
4fab92fb
HSHR
1909 if (data_block)
1910 *USS (US data_block + (long int)(ol->value)) = sptr;
059ec3d9 1911 else
4fab92fb 1912 *USS (ol->value) = sptr;
059ec3d9
PH
1913 freesptr = FALSE;
1914 if (type == opt_rewrite)
1915 {
1916 int sep = 0;
1917 int *flagptr;
1918 uschar *p = sptr;
1919 rewrite_rule **chain;
1920 optionlist *ol3;
1921
1922 sprintf(CS name2, "*%.50s_rules", name);
1923 ol2 = find_option(name2, oltop, last);
1924 sprintf(CS name2, "*%.50s_flags", name);
1925 ol3 = find_option(name2, oltop, last);
1926
1927 if (ol2 == NULL || ol3 == NULL)
1928 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1929 "rewrite rules not available for driver");
1930
1931 if (data_block == NULL)
1932 {
1933 chain = (rewrite_rule **)(ol2->value);
1934 flagptr = (int *)(ol3->value);
1935 }
1936 else
1937 {
1938 chain = (rewrite_rule **)((uschar *)data_block + (long int)(ol2->value));
1939 flagptr = (int *)((uschar *)data_block + (long int)(ol3->value));
1940 }
1941
55414b25 1942 while ((p = string_nextinlist(CUSS &sptr, &sep, big_buffer, BIG_BUFFER_SIZE)))
059ec3d9
PH
1943 {
1944 rewrite_rule *next = readconf_one_rewrite(p, flagptr, FALSE);
1945 *chain = next;
1946 chain = &(next->next);
1947 }
1948
1949 if ((*flagptr & (rewrite_all_envelope | rewrite_smtp)) != 0)
1950 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "rewrite rule specifies a "
1951 "non-header rewrite - not allowed at transport time -");
1952 }
1953 break;
1954
1955 /* If it was an expanded uid, see if there is any expansion to be
1956 done by checking for the presence of a $ character. If there is, save it
1957 in the corresponding *expand_user option field. Otherwise, fall through
1958 to treat it as a fixed uid. Ensure mutual exclusivity of the two kinds
1959 of data. */
1960
1961 case opt_expand_uid:
1962 sprintf(CS name2, "*expand_%.50s", name);
1963 ol2 = find_option(name2, oltop, last);
1964 if (ol2 != NULL)
1965 {
1966 uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
1967
1968 if (data_block == NULL)
1969 *((uschar **)(ol2->value)) = ss;
1970 else
1971 *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = ss;
1972
1973 if (ss != NULL)
1974 {
1975 *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1976 freesptr = FALSE;
1977 break;
1978 }
1979 }
1980
1981 /* Look up a fixed uid, and also make use of the corresponding gid
1982 if a passwd entry is returned and the gid has not been set. */
1983
1984 case opt_uid:
1985 if (!route_finduser(sptr, &pw, &uid))
1986 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found", sptr);
1987 if (data_block == NULL)
1988 *((uid_t *)(ol->value)) = uid;
1989 else
1990 *((uid_t *)((uschar *)data_block + (long int)(ol->value))) = uid;
1991
1992 /* Set the flag indicating a fixed value is set */
1993
1994 *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1995
1996 /* Handle matching gid if we have a passwd entry: done by finding the
1997 same name with terminating "user" changed to "group"; if not found,
1998 ignore. Also ignore if the value is already set. */
1999
2000 if (pw == NULL) break;
2001 Ustrcpy(name+Ustrlen(name)-4, "group");
2002 ol2 = find_option(name, oltop, last);
2003 if (ol2 != NULL && ((ol2->type & opt_mask) == opt_gid ||
2004 (ol2->type & opt_mask) == opt_expand_gid))
2005 {
2006 BOOL *set_flag = get_set_flag(name, oltop, last, data_block);
2007 if (! *set_flag)
2008 {
2009 if (data_block == NULL)
2010 *((gid_t *)(ol2->value)) = pw->pw_gid;
2011 else
2012 *((gid_t *)((uschar *)data_block + (long int)(ol2->value))) = pw->pw_gid;
2013 *set_flag = TRUE;
2014 }
2015 }
2016 break;
2017
2018 /* If it was an expanded gid, see if there is any expansion to be
2019 done by checking for the presence of a $ character. If there is, save it
2020 in the corresponding *expand_user option field. Otherwise, fall through
2021 to treat it as a fixed gid. Ensure mutual exclusivity of the two kinds
2022 of data. */
2023
2024 case opt_expand_gid:
2025 sprintf(CS name2, "*expand_%.50s", name);
2026 ol2 = find_option(name2, oltop, last);
2027 if (ol2 != NULL)
2028 {
2029 uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
2030
2031 if (data_block == NULL)
2032 *((uschar **)(ol2->value)) = ss;
2033 else
2034 *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = ss;
2035
2036 if (ss != NULL)
2037 {
2038 *(get_set_flag(name, oltop, last, data_block)) = FALSE;
2039 freesptr = FALSE;
2040 break;
2041 }
2042 }
2043
2044 /* Handle freestanding gid */
2045
2046 case opt_gid:
2047 if (!route_findgroup(sptr, &gid))
2048 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found", sptr);
2049 if (data_block == NULL)
2050 *((gid_t *)(ol->value)) = gid;
2051 else
2052 *((gid_t *)((uschar *)data_block + (long int)(ol->value))) = gid;
2053 *(get_set_flag(name, oltop, last, data_block)) = TRUE;
2054 break;
2055
2056 /* If it was a uid list, look up each individual entry, and build
2057 a vector of uids, with a count in the first element. Put the vector
2058 in malloc store so we can free the string. (We are reading into
2059 permanent store already.) */
2060
2061 case opt_uidlist:
2062 {
2063 int count = 1;
2064 uid_t *list;
2065 int ptr = 0;
55414b25
JH
2066 const uschar *p;
2067 const uschar *op = expand_string (sptr);
0925ede6
PH
2068
2069 if (op == NULL)
2070 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
2071 name, expand_string_message);
059ec3d9 2072
0925ede6 2073 p = op;
059ec3d9 2074 if (*p != 0) count++;
0925ede6 2075 while (*p != 0) if (*p++ == ':' && *p != 0) count++;
059ec3d9
PH
2076 list = store_malloc(count*sizeof(uid_t));
2077 list[ptr++] = (uid_t)(count - 1);
2078
2079 if (data_block == NULL)
2080 *((uid_t **)(ol->value)) = list;
2081 else
2082 *((uid_t **)((uschar *)data_block + (long int)(ol->value))) = list;
2083
0925ede6 2084 p = op;
059ec3d9
PH
2085 while (count-- > 1)
2086 {
2087 int sep = 0;
2088 (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
2089 if (!route_finduser(big_buffer, NULL, &uid))
2090 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found",
2091 big_buffer);
2092 list[ptr++] = uid;
2093 }
2094 }
2095 break;
2096
2097 /* If it was a gid list, look up each individual entry, and build
2098 a vector of gids, with a count in the first element. Put the vector
2099 in malloc store so we can free the string. (We are reading into permanent
2100 store already.) */
2101
2102 case opt_gidlist:
2103 {
2104 int count = 1;
2105 gid_t *list;
2106 int ptr = 0;
55414b25
JH
2107 const uschar *p;
2108 const uschar *op = expand_string (sptr);
0925ede6
PH
2109
2110 if (op == NULL)
2111 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
2112 name, expand_string_message);
059ec3d9 2113
0925ede6 2114 p = op;
059ec3d9 2115 if (*p != 0) count++;
0925ede6 2116 while (*p != 0) if (*p++ == ':' && *p != 0) count++;
059ec3d9
PH
2117 list = store_malloc(count*sizeof(gid_t));
2118 list[ptr++] = (gid_t)(count - 1);
2119
2120 if (data_block == NULL)
2121 *((gid_t **)(ol->value)) = list;
2122 else
2123 *((gid_t **)((uschar *)data_block + (long int)(ol->value))) = list;
2124
0925ede6 2125 p = op;
059ec3d9
PH
2126 while (count-- > 1)
2127 {
2128 int sep = 0;
2129 (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
2130 if (!route_findgroup(big_buffer, &gid))
2131 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found",
2132 big_buffer);
2133 list[ptr++] = gid;
2134 }
2135 }
2136 break;
2137 }
2138
2139 /* Release store if the value of the string doesn't need to be kept. */
2140
2141 if (freesptr) store_reset(reset_point);
2142 break;
2143
2144 /* Expanded boolean: if no characters follow, or if there are no dollar
2145 characters, this is a fixed-valued boolean, and we fall through. Otherwise,
2146 save the string for later expansion in the alternate place. */
2147
2148 case opt_expand_bool:
2149 if (*s != 0 && Ustrchr(s, '$') != 0)
2150 {
2151 sprintf(CS name2, "*expand_%.50s", name);
2152 ol2 = find_option(name2, oltop, last);
2153 if (ol2 != NULL)
2154 {
2155 reset_point = sptr = read_string(s, name);
2156 if (data_block == NULL)
2157 *((uschar **)(ol2->value)) = sptr;
2158 else
2159 *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = sptr;
2160 freesptr = FALSE;
2161 break;
2162 }
2163 }
2164 /* Fall through */
2165
2166 /* Boolean: if no characters follow, the value is boolvalue. Otherwise
2167 look for yes/not/true/false. Some booleans are stored in a single bit in
2168 a single int. There's a special fudge for verify settings; without a suffix
2169 they set both xx_sender and xx_recipient. The table points to the sender
2170 value; search subsequently for the recipient. There's another special case:
2171 opt_bool_set also notes when a boolean has been set. */
2172
2173 case opt_bool:
2174 case opt_bit:
2175 case opt_bool_verify:
2176 case opt_bool_set:
2177 if (*s != 0)
2178 {
2179 s = readconf_readname(name2, 64, s);
2180 if (strcmpic(name2, US"true") == 0 || strcmpic(name2, US"yes") == 0)
2181 boolvalue = TRUE;
2182 else if (strcmpic(name2, US"false") == 0 || strcmpic(name2, US"no") == 0)
2183 boolvalue = FALSE;
2184 else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2185 "\"%s\" is not a valid value for the \"%s\" option", name2, name);
2186 if (*s != 0) extra_chars_error(s, string_sprintf("\"%s\" ", name2),
2187 US"for boolean option ", name);
2188 }
2189
2190 /* Handle single-bit type. */
2191
2192 if (type == opt_bit)
2193 {
2194 int bit = 1 << ((ol->type >> 16) & 31);
2195 int *ptr = (data_block == NULL)?
2196 (int *)(ol->value) :
2197 (int *)((uschar *)data_block + (long int)ol->value);
2198 if (boolvalue) *ptr |= bit; else *ptr &= ~bit;
2199 break;
2200 }
2201
2202 /* Handle full BOOL types */
2203
2204 if (data_block == NULL)
2205 *((BOOL *)(ol->value)) = boolvalue;
2206 else
2207 *((BOOL *)((uschar *)data_block + (long int)(ol->value))) = boolvalue;
2208
2209 /* Verify fudge */
2210
2211 if (type == opt_bool_verify)
2212 {
2213 sprintf(CS name2, "%.50s_recipient", name + offset);
2214 ol2 = find_option(name2, oltop, last);
2215 if (ol2 != NULL)
2216 {
2217 if (data_block == NULL)
2218 *((BOOL *)(ol2->value)) = boolvalue;
2219 else
2220 *((BOOL *)((uschar *)data_block + (long int)(ol2->value))) = boolvalue;
2221 }
2222 }
2223
2224 /* Note that opt_bool_set type is set, if there is somewhere to do so */
2225
2226 else if (type == opt_bool_set)
2227 {
2228 sprintf(CS name2, "*set_%.50s", name + offset);
2229 ol2 = find_option(name2, oltop, last);
2230 if (ol2 != NULL)
2231 {
2232 if (data_block == NULL)
2233 *((BOOL *)(ol2->value)) = TRUE;
2234 else
2235 *((BOOL *)((uschar *)data_block + (long int)(ol2->value))) = TRUE;
2236 }
2237 }
2238 break;
2239
2240 /* Octal integer */
2241
2242 case opt_octint:
2243 intbase = 8;
2244 inttype = US"octal ";
2245
2246 /* Integer: a simple(ish) case; allow octal and hex formats, and
4fab92fb 2247 suffixes K, M and G. The different types affect output, not input. */
059ec3d9
PH
2248
2249 case opt_mkint:
2250 case opt_int:
2251 {
2252 uschar *endptr;
7e8d92ba
PH
2253 long int lvalue;
2254
059ec3d9 2255 errno = 0;
7e8d92ba 2256 lvalue = strtol(CS s, CSS &endptr, intbase);
059ec3d9
PH
2257
2258 if (endptr == s)
2259 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
2260 inttype, name);
2261
2262 if (errno != ERANGE)
059ec3d9
PH
2263 if (tolower(*endptr) == 'k')
2264 {
7e8d92ba
PH
2265 if (lvalue > INT_MAX/1024 || lvalue < INT_MIN/1024) errno = ERANGE;
2266 else lvalue *= 1024;
059ec3d9
PH
2267 endptr++;
2268 }
2269 else if (tolower(*endptr) == 'm')
2270 {
7e8d92ba 2271 if (lvalue > INT_MAX/(1024*1024) || lvalue < INT_MIN/(1024*1024))
059ec3d9 2272 errno = ERANGE;
7e8d92ba 2273 else lvalue *= 1024*1024;
059ec3d9
PH
2274 endptr++;
2275 }
4fab92fb
HSHR
2276 else if (tolower(*endptr) == 'g')
2277 {
2278 if (lvalue > INT_MAX/(1024*1024*1024) || lvalue < INT_MIN/(1024*1024*1024))
2279 errno = ERANGE;
2280 else lvalue *= 1024*1024*1024;
2281 endptr++;
2282 }
059ec3d9 2283
7e8d92ba
PH
2284 if (errno == ERANGE || lvalue > INT_MAX || lvalue < INT_MIN)
2285 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2286 "absolute value of integer \"%s\" is too large (overflow)", s);
059ec3d9
PH
2287
2288 while (isspace(*endptr)) endptr++;
2289 if (*endptr != 0)
2290 extra_chars_error(endptr, inttype, US"integer value for ", name);
7e8d92ba
PH
2291
2292 value = (int)lvalue;
059ec3d9
PH
2293 }
2294
2295 if (data_block == NULL)
2296 *((int *)(ol->value)) = value;
2297 else
2298 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2299 break;
2300
4fab92fb
HSHR
2301 /* Integer held in K: again, allow octal and hex formats, and suffixes K, M
2302 and G. */
2303 /*XXX consider moving to int_eximarith_t (but mind the overflow test 0415) */
059ec3d9
PH
2304
2305 case opt_Kint:
2306 {
2307 uschar *endptr;
2308 errno = 0;
2309 value = strtol(CS s, CSS &endptr, intbase);
2310
2311 if (endptr == s)
2312 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
2313 inttype, name);
2314
2315 if (errno != ERANGE)
4fab92fb 2316 if (tolower(*endptr) == 'g')
059ec3d9 2317 {
4fab92fb
HSHR
2318 if (value > INT_MAX/(1024*1024) || value < INT_MIN/(1024*1024))
2319 errno = ERANGE;
2320 else
2321 value *= 1024*1024;
059ec3d9
PH
2322 endptr++;
2323 }
4fab92fb 2324 else if (tolower(*endptr) == 'm')
059ec3d9 2325 {
4fab92fb
HSHR
2326 if (value > INT_MAX/1024 || value < INT_MIN/1024)
2327 errno = ERANGE;
2328 else
2329 value *= 1024;
059ec3d9
PH
2330 endptr++;
2331 }
4fab92fb
HSHR
2332 else if (tolower(*endptr) == 'k')
2333 endptr++;
059ec3d9 2334 else
059ec3d9 2335 value = (value + 512)/1024;
059ec3d9
PH
2336
2337 if (errno == ERANGE) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2338 "absolute value of integer \"%s\" is too large (overflow)", s);
2339
2340 while (isspace(*endptr)) endptr++;
2341 if (*endptr != 0)
2342 extra_chars_error(endptr, inttype, US"integer value for ", name);
2343 }
2344
2345 if (data_block == NULL)
2346 *((int *)(ol->value)) = value;
2347 else
2348 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2349 break;
2350
2351 /* Fixed-point number: held to 3 decimal places. */
2352
2353 case opt_fixed:
2354 if (sscanf(CS s, "%d%n", &value, &count) != 1)
2355 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2356 "fixed-point number expected for %s", name);
2357
2358 if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2359 "integer \"%s\" is too large (overflow)", s);
2360
2361 value *= 1000;
2362
2363 if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2364 "integer \"%s\" is too large (overflow)", s);
2365
4fab92fb
HSHR
2366 /* We get a coverity error here for using count, as it derived
2367 from the tainted buffer pointed to by s, as parsed by sscanf().
2368 By the definition of sscanf we must be aceessing between start
2369 and end of s (assuming it is nul-terminated...) so ignore the error. */
2370 /* coverity[tainted_data] */
059ec3d9
PH
2371 if (s[count] == '.')
2372 {
2373 int d = 100;
2374 while (isdigit(s[++count]))
2375 {
2376 value += (s[count] - '0') * d;
2377 d /= 10;
2378 }
2379 }
2380
2381 while (isspace(s[count])) count++;
2382
2383 if (s[count] != 0)
2384 extra_chars_error(s+count, US"fixed-point value for ", name, US"");
2385
2386 if (data_block == NULL)
2387 *((int *)(ol->value)) = value;
2388 else
2389 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2390 break;
2391
2392 /* There's a special routine to read time values. */
2393
2394 case opt_time:
2395 value = readconf_readtime(s, 0, FALSE);
2396 if (value < 0)
2397 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2398 name);
2399 if (data_block == NULL)
2400 *((int *)(ol->value)) = value;
2401 else
2402 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2403 break;
2404
2405 /* A time list is a list of colon-separated times, with the first
2406 element holding the size of the list and the second the number of
2407 entries used. */
2408
2409 case opt_timelist:
2410 {
2411 int count = 0;
2412 int *list = (data_block == NULL)?
2413 (int *)(ol->value) :
2414 (int *)((uschar *)data_block + (long int)(ol->value));
2415
2416 if (*s != 0) for (count = 1; count <= list[0] - 2; count++)
2417 {
2418 int terminator = 0;
2419 uschar *snext = Ustrchr(s, ':');
2420 if (snext != NULL)
2421 {
2422 uschar *ss = snext;
2423 while (ss > s && isspace(ss[-1])) ss--;
2424 terminator = *ss;
2425 }
2426 value = readconf_readtime(s, terminator, FALSE);
2427 if (value < 0)
2428 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2429 name);
2430 if (count > 1 && value <= list[count])
2431 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2432 "time value out of order for %s", name);
2433 list[count+1] = value;
2434 if (snext == NULL) break;
2435 s = snext + 1;
2436 while (isspace(*s)) s++;
2437 }
2438
2439 if (count > list[0] - 2)
2440 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many time values for %s",
2441 name);
2442 if (count > 0 && list[2] == 0) count = 0;
2443 list[1] = count;
1ad6489e 2444 break;
059ec3d9
PH
2445 }
2446
1ad6489e
JH
2447 case opt_func:
2448 {
2449 void (*fn)() = ol->value;
2450 fn(name, s);
2451 break;
2452 }
059ec3d9
PH
2453 }
2454
2455return TRUE;
2456}
2457
2458
2459
2460/*************************************************
2461* Print a time value *
2462*************************************************/
2463
2464/*
2465Argument: a time value in seconds
2466Returns: pointer to a fixed buffer containing the time as a string,
2467 in readconf_readtime() format
2468*/
2469
2470uschar *
2471readconf_printtime(int t)
2472{
2473int s, m, h, d, w;
2474uschar *p = time_buffer;
2475
ea49d0e1
PH
2476if (t < 0)
2477 {
2478 *p++ = '-';
2479 t = -t;
2480 }
2481
059ec3d9
PH
2482s = t % 60;
2483t /= 60;
2484m = t % 60;
2485t /= 60;
2486h = t % 24;
2487t /= 24;
2488d = t % 7;
2489w = t/7;
2490
2491if (w > 0) { sprintf(CS p, "%dw", w); while (*p) p++; }
2492if (d > 0) { sprintf(CS p, "%dd", d); while (*p) p++; }
2493if (h > 0) { sprintf(CS p, "%dh", h); while (*p) p++; }
2494if (m > 0) { sprintf(CS p, "%dm", m); while (*p) p++; }
2495if (s > 0 || p == time_buffer) sprintf(CS p, "%ds", s);
2496
2497return time_buffer;
2498}
2499
2500
2501
2502/*************************************************
2503* Print an individual option value *
2504*************************************************/
2505
2506/* This is used by the -bP option, so prints to the standard output.
2507The entire options list is passed in as an argument, because some options come
2508in pairs - typically uid/gid settings, which can either be explicit numerical
2509values, or strings to be expanded later. If the numerical value is unset,
2510search for "*expand_<name>" to see if there is a string equivalent.
2511
2512Arguments:
2513 ol option entry, or NULL for an unknown option
2514 name option name
2515 options_block NULL for main configuration options; otherwise points to
2516 a driver block; if the option doesn't have opt_public
2517 set, then options_block->options_block is where the item
2518 resides.
2519 oltop points to the option list in which ol exists
2520 last one more than the offset of the last entry in optop
12f69989 2521 no_labels do not show "foo = " at the start.
059ec3d9
PH
2522
2523Returns: nothing
2524*/
2525
2526static void
2527print_ol(optionlist *ol, uschar *name, void *options_block,
12f69989 2528 optionlist *oltop, int last, BOOL no_labels)
059ec3d9
PH
2529{
2530struct passwd *pw;
2531struct group *gr;
2532optionlist *ol2;
2533void *value;
2534uid_t *uidlist;
2535gid_t *gidlist;
2536uschar *s;
2537uschar name2[64];
2538
2539if (ol == NULL)
2540 {
2541 printf("%s is not a known option\n", name);
2542 return;
2543 }
2544
2545/* Non-admin callers cannot see options that have been flagged secure by the
2546"hide" prefix. */
2547
2548if (!admin_user && (ol->type & opt_secure) != 0)
2549 {
12f69989
PP
2550 if (no_labels)
2551 printf("%s\n", hidden);
2552 else
2553 printf("%s = %s\n", name, hidden);
059ec3d9
PH
2554 return;
2555 }
2556
2557/* Else show the value of the option */
2558
2559value = ol->value;
2560if (options_block != NULL)
2561 {
2562 if ((ol->type & opt_public) == 0)
2563 options_block = (void *)(((driver_instance *)options_block)->options_block);
2564 value = (void *)((uschar *)options_block + (long int)value);
2565 }
2566
2567switch(ol->type & opt_mask)
2568 {
2569 case opt_stringptr:
2570 case opt_rewrite: /* Show the text value */
2571 s = *((uschar **)value);
12f69989
PP
2572 if (!no_labels) printf("%s = ", name);
2573 printf("%s\n", (s == NULL)? US"" : string_printing2(s, FALSE));
059ec3d9
PH
2574 break;
2575
2576 case opt_int:
12f69989
PP
2577 if (!no_labels) printf("%s = ", name);
2578 printf("%d\n", *((int *)value));
059ec3d9
PH
2579 break;
2580
2581 case opt_mkint:
2582 {
2583 int x = *((int *)value);
2584 if (x != 0 && (x & 1023) == 0)
2585 {
2586 int c = 'K';
2587 x >>= 10;
2588 if ((x & 1023) == 0)
2589 {
2590 c = 'M';
2591 x >>= 10;
2592 }
12f69989
PP
2593 if (!no_labels) printf("%s = ", name);
2594 printf("%d%c\n", x, c);
2595 }
2596 else
2597 {
2598 if (!no_labels) printf("%s = ", name);
2599 printf("%d\n", x);
059ec3d9 2600 }
059ec3d9
PH
2601 }
2602 break;
2603
2604 case opt_Kint:
2605 {
2606 int x = *((int *)value);
12f69989
PP
2607 if (!no_labels) printf("%s = ", name);
2608 if (x == 0) printf("0\n");
2609 else if ((x & 1023) == 0) printf("%dM\n", x >> 10);
2610 else printf("%dK\n", x);
059ec3d9
PH
2611 }
2612 break;
2613
2614 case opt_octint:
12f69989
PP
2615 if (!no_labels) printf("%s = ", name);
2616 printf("%#o\n", *((int *)value));
059ec3d9
PH
2617 break;
2618
2619 /* Can be negative only when "unset", in which case integer */
2620
2621 case opt_fixed:
2622 {
2623 int x = *((int *)value);
2624 int f = x % 1000;
2625 int d = 100;
2626 if (x < 0) printf("%s =\n", name); else
2627 {
12f69989
PP
2628 if (!no_labels) printf("%s = ", name);
2629 printf("%d.", x/1000);
059ec3d9
PH
2630 do
2631 {
2632 printf("%d", f/d);
2633 f %= d;
2634 d /= 10;
2635 }
2636 while (f != 0);
2637 printf("\n");
2638 }
2639 }
2640 break;
2641
2642 /* If the numerical value is unset, try for the string value */
2643
2644 case opt_expand_uid:
2645 if (! *get_set_flag(name, oltop, last, options_block))
2646 {
2647 sprintf(CS name2, "*expand_%.50s", name);
2648 ol2 = find_option(name2, oltop, last);
2649 if (ol2 != NULL)
2650 {
2651 void *value2 = ol2->value;
2652 if (options_block != NULL)
2653 value2 = (void *)((uschar *)options_block + (long int)value2);
2654 s = *((uschar **)value2);
12f69989
PP
2655 if (!no_labels) printf("%s = ", name);
2656 printf("%s\n", (s == NULL)? US"" : string_printing(s));
059ec3d9
PH
2657 break;
2658 }
2659 }
2660
2661 /* Else fall through */
2662
2663 case opt_uid:
12f69989 2664 if (!no_labels) printf("%s = ", name);
059ec3d9 2665 if (! *get_set_flag(name, oltop, last, options_block))
12f69989 2666 printf("\n");
059ec3d9
PH
2667 else
2668 {
2669 pw = getpwuid(*((uid_t *)value));
2670 if (pw == NULL)
12f69989
PP
2671 printf("%ld\n", (long int)(*((uid_t *)value)));
2672 else printf("%s\n", pw->pw_name);
059ec3d9
PH
2673 }
2674 break;
2675
2676 /* If the numerical value is unset, try for the string value */
2677
2678 case opt_expand_gid:
2679 if (! *get_set_flag(name, oltop, last, options_block))
2680 {
2681 sprintf(CS name2, "*expand_%.50s", name);
2682 ol2 = find_option(name2, oltop, last);
2683 if (ol2 != NULL && (ol2->type & opt_mask) == opt_stringptr)
2684 {
2685 void *value2 = ol2->value;
2686 if (options_block != NULL)
2687 value2 = (void *)((uschar *)options_block + (long int)value2);
2688 s = *((uschar **)value2);
12f69989
PP
2689 if (!no_labels) printf("%s = ", name);
2690 printf("%s\n", (s == NULL)? US"" : string_printing(s));
059ec3d9
PH
2691 break;
2692 }
2693 }
2694
2695 /* Else fall through */
2696
2697 case opt_gid:
12f69989 2698 if (!no_labels) printf("%s = ", name);
059ec3d9 2699 if (! *get_set_flag(name, oltop, last, options_block))
12f69989 2700 printf("\n");
059ec3d9
PH
2701 else
2702 {
2703 gr = getgrgid(*((int *)value));
2704 if (gr == NULL)
12f69989
PP
2705 printf("%ld\n", (long int)(*((int *)value)));
2706 else printf("%s\n", gr->gr_name);
059ec3d9
PH
2707 }
2708 break;
2709
2710 case opt_uidlist:
2711 uidlist = *((uid_t **)value);
12f69989 2712 if (!no_labels) printf("%s =", name);
059ec3d9
PH
2713 if (uidlist != NULL)
2714 {
2715 int i;
2716 uschar sep = ' ';
12f69989 2717 if (no_labels) sep = '\0';
059ec3d9
PH
2718 for (i = 1; i <= (int)(uidlist[0]); i++)
2719 {
2720 uschar *name = NULL;
2721 pw = getpwuid(uidlist[i]);
2722 if (pw != NULL) name = US pw->pw_name;
12f69989
PP
2723 if (sep != '\0') printf("%c", sep);
2724 if (name != NULL) printf("%s", name);
2725 else printf("%ld", (long int)(uidlist[i]));
059ec3d9
PH
2726 sep = ':';
2727 }
2728 }
2729 printf("\n");
2730 break;
2731
2732 case opt_gidlist:
2733 gidlist = *((gid_t **)value);
12f69989 2734 if (!no_labels) printf("%s =", name);
059ec3d9
PH
2735 if (gidlist != NULL)
2736 {
2737 int i;
2738 uschar sep = ' ';
12f69989 2739 if (no_labels) sep = '\0';
059ec3d9
PH
2740 for (i = 1; i <= (int)(gidlist[0]); i++)
2741 {
2742 uschar *name = NULL;
2743 gr = getgrgid(gidlist[i]);
2744 if (gr != NULL) name = US gr->gr_name;
12f69989
PP
2745 if (sep != '\0') printf("%c", sep);
2746 if (name != NULL) printf("%s", name);
2747 else printf("%ld", (long int)(gidlist[i]));
059ec3d9
PH
2748 sep = ':';
2749 }
2750 }
2751 printf("\n");
2752 break;
2753
2754 case opt_time:
12f69989
PP
2755 if (!no_labels) printf("%s = ", name);
2756 printf("%s\n", readconf_printtime(*((int *)value)));
059ec3d9
PH
2757 break;
2758
2759 case opt_timelist:
2760 {
2761 int i;
2762 int *list = (int *)value;
12f69989 2763 if (!no_labels) printf("%s = ", name);
059ec3d9
PH
2764 for (i = 0; i < list[1]; i++)
2765 printf("%s%s", (i == 0)? "" : ":", readconf_printtime(list[i+2]));
2766 printf("\n");
2767 }
2768 break;
2769
2770 case opt_bit:
2771 printf("%s%s\n", ((*((int *)value)) & (1 << ((ol->type >> 16) & 31)))?
2772 "" : "no_", name);
2773 break;
2774
2775 case opt_expand_bool:
2776 sprintf(CS name2, "*expand_%.50s", name);
2777 ol2 = find_option(name2, oltop, last);
2778 if (ol2 != NULL && ol2->value != NULL)
2779 {
2780 void *value2 = ol2->value;
2781 if (options_block != NULL)
2782 value2 = (void *)((uschar *)options_block + (long int)value2);
2783 s = *((uschar **)value2);
2784 if (s != NULL)
2785 {
12f69989
PP
2786 if (!no_labels) printf("%s = ", name);
2787 printf("%s\n", string_printing(s));
059ec3d9
PH
2788 break;
2789 }
2790 /* s == NULL => string not set; fall through */
2791 }
2792
2793 /* Fall through */
2794
2795 case opt_bool:
2796 case opt_bool_verify:
2797 case opt_bool_set:
2798 printf("%s%s\n", (*((BOOL *)value))? "" : "no_", name);
2799 break;
2800 }
2801}
2802
2803
2804
2805/*************************************************
2806* Print value from main configuration *
2807*************************************************/
2808
2809/* This function, called as a result of encountering the -bP option,
2810causes the value of any main configuration variable to be output if the
2811second argument is NULL. There are some special values:
2812
2813 all print all main configuration options
44f6c01d
HSHR
2814 config_file print the name of the configuration file
2815 (configure_file will still work, for backward
2816 compatibility)
059ec3d9
PH
2817 routers print the routers' configurations
2818 transports print the transports' configuration
2819 authenticators print the authenticators' configuration
5d9c27ec 2820 macros print the macros' configuration
059ec3d9
PH
2821 router_list print a list of router names
2822 transport_list print a list of transport names
2823 authenticator_list print a list of authentication mechanism names
5d9c27ec 2824 macro_list print a list of macro names
059ec3d9
PH
2825 +name print a named list item
2826 local_scan print the local_scan options
bf3c2c6b 2827 config print the configuration as it is parsed
4fab92fb 2828 environment print the used execution environment
059ec3d9 2829
5d9c27ec
TK
2830If the second argument is not NULL, it must be one of "router", "transport",
2831"authenticator" or "macro" in which case the first argument identifies the
2832driver whose options are to be printed.
059ec3d9
PH
2833
2834Arguments:
2835 name option name if type == NULL; else driver name
2836 type NULL or driver type name, as described above
12f69989 2837 no_labels avoid the "foo = " at the start of an item
059ec3d9
PH
2838
2839Returns: nothing
2840*/
2841
2842void
12f69989 2843readconf_print(uschar *name, uschar *type, BOOL no_labels)
059ec3d9
PH
2844{
2845BOOL names_only = FALSE;
2846optionlist *ol;
2847optionlist *ol2 = NULL;
2848driver_instance *d = NULL;
5d9c27ec 2849macro_item *m;
059ec3d9
PH
2850int size = 0;
2851
2852if (type == NULL)
2853 {
2854 if (*name == '+')
2855 {
2856 int i;
2857 tree_node *t;
2858 BOOL found = FALSE;
2859 static uschar *types[] = { US"address", US"domain", US"host",
2860 US"localpart" };
2861 static tree_node **anchors[] = { &addresslist_anchor, &domainlist_anchor,
2862 &hostlist_anchor, &localpartlist_anchor };
2863
2864 for (i = 0; i < 4; i++)
2865 {
2866 t = tree_search(*(anchors[i]), name+1);
2867 if (t != NULL)
2868 {
2869 found = TRUE;
12f69989
PP
2870 if (no_labels)
2871 printf("%s\n", ((namedlist_block *)(t->data.ptr))->string);
2872 else
2873 printf("%slist %s = %s\n", types[i], name+1,
2874 ((namedlist_block *)(t->data.ptr))->string);
059ec3d9
PH
2875 }
2876 }
2877
2878 if (!found)
2879 printf("no address, domain, host, or local part list called \"%s\" "
2880 "exists\n", name+1);
2881
2882 return;
2883 }
2884
4fab92fb
HSHR
2885 if ( Ustrcmp(name, "configure_file") == 0
2886 || Ustrcmp(name, "config_file") == 0)
059ec3d9
PH
2887 {
2888 printf("%s\n", CS config_main_filename);
2889 return;
2890 }
2891
2892 if (Ustrcmp(name, "all") == 0)
2893 {
2894 for (ol = optionlist_config;
4fab92fb 2895 ol < optionlist_config + nelem(optionlist_config); ol++)
059ec3d9
PH
2896 {
2897 if ((ol->type & opt_hidden) == 0)
12f69989 2898 print_ol(ol, US ol->name, NULL,
4fab92fb 2899 optionlist_config, nelem(optionlist_config),
12f69989 2900 no_labels);
059ec3d9
PH
2901 }
2902 return;
2903 }
2904
2905 if (Ustrcmp(name, "local_scan") == 0)
2906 {
2907 #ifndef LOCAL_SCAN_HAS_OPTIONS
2908 printf("local_scan() options are not supported\n");
2909 #else
2910 for (ol = local_scan_options;
2911 ol < local_scan_options + local_scan_options_count; ol++)
2912 {
2913 print_ol(ol, US ol->name, NULL, local_scan_options,
12f69989 2914 local_scan_options_count, no_labels);
059ec3d9
PH
2915 }
2916 #endif
2917 return;
2918 }
2919
bf3c2c6b
HSHR
2920 if (Ustrcmp(name, "config") == 0)
2921 {
4fab92fb 2922 print_config(admin_user, no_labels);
bf3c2c6b
HSHR
2923 return;
2924 }
2925
059ec3d9
PH
2926 if (Ustrcmp(name, "routers") == 0)
2927 {
2928 type = US"router";
2929 name = NULL;
2930 }
2931 else if (Ustrcmp(name, "transports") == 0)
2932 {
2933 type = US"transport";
2934 name = NULL;
2935 }
2936
2937 else if (Ustrcmp(name, "authenticators") == 0)
2938 {
2939 type = US"authenticator";
2940 name = NULL;
2941 }
2942
5d9c27ec 2943 else if (Ustrcmp(name, "macros") == 0)
059ec3d9 2944 {
5d9c27ec 2945 type = US"macro";
059ec3d9 2946 name = NULL;
059ec3d9
PH
2947 }
2948
2949 else if (Ustrcmp(name, "router_list") == 0)
2950 {
2951 type = US"router";
2952 name = NULL;
2953 names_only = TRUE;
2954 }
5d9c27ec 2955
059ec3d9
PH
2956 else if (Ustrcmp(name, "transport_list") == 0)
2957 {
2958 type = US"transport";
2959 name = NULL;
2960 names_only = TRUE;
2961 }
5d9c27ec
TK
2962
2963 else if (Ustrcmp(name, "authenticator_list") == 0)
2964 {
2965 type = US"authenticator";
2966 name = NULL;
2967 names_only = TRUE;
2968 }
2969
2970 else if (Ustrcmp(name, "macro_list") == 0)
2971 {
2972 type = US"macro";
2973 name = NULL;
2974 names_only = TRUE;
2975 }
2976
4fab92fb
HSHR
2977 else if (Ustrcmp(name, "environment") == 0)
2978 {
2979 if (environ)
2980 {
2981 uschar ** p;
2982 for (p = USS environ; *p; p++) ;
2983 qsort(environ, p - USS environ, sizeof(*p), string_compare_by_pointer);
2984
2985 for (p = USS environ; *p; p++)
2986 {
2987 uschar * q;
2988 if (no_labels && (q = Ustrchr(*p, '='))) *q = '\0';
2989 puts(CS *p);
2990 }
2991 }
2992 return;
2993 }
2994
059ec3d9
PH
2995 else
2996 {
4fab92fb
HSHR
2997 print_ol(find_option(name, optionlist_config, nelem(optionlist_config)),
2998 name, NULL, optionlist_config, nelem(optionlist_config), no_labels);
059ec3d9
PH
2999 return;
3000 }
3001 }
3002
3003/* Handle the options for a router or transport. Skip options that are flagged
3004as hidden. Some of these are options with names starting with '*', used for
3005internal alternative representations of other options (which the printing
3006function will sort out). Others are synonyms kept for backward compatibility.
3007*/
3008
3009if (Ustrcmp(type, "router") == 0)
3010 {
3011 d = (driver_instance *)routers;
3012 ol2 = optionlist_routers;
3013 size = optionlist_routers_size;
3014 }
3015else if (Ustrcmp(type, "transport") == 0)
3016 {
3017 d = (driver_instance *)transports;
3018 ol2 = optionlist_transports;
3019 size = optionlist_transports_size;
3020 }
3021else if (Ustrcmp(type, "authenticator") == 0)
3022 {
3023 d = (driver_instance *)auths;
3024 ol2 = optionlist_auths;
3025 size = optionlist_auths_size;
3026 }
3027
5d9c27ec
TK
3028else if (Ustrcmp(type, "macro") == 0)
3029 {
3030 /* People store passwords in macros and they were previously not available
3031 for printing. So we have an admin_users restriction. */
3032 if (!admin_user)
3033 {
3034 fprintf(stderr, "exim: permission denied\n");
3035 exit(EXIT_FAILURE);
3036 }
4fab92fb
HSHR
3037 if (!macros_builtin_created) macros_create_builtin();
3038 for (m = macros; m; m = m->next)
3039 if (!name || Ustrcmp(name, m->name) == 0)
5d9c27ec
TK
3040 {
3041 if (names_only)
3042 printf("%s\n", CS m->name);
3043 else
3044 printf("%s=%s\n", CS m->name, CS m->replacement);
4fab92fb 3045 if (name)
5d9c27ec
TK
3046 return;
3047 }
4fab92fb 3048 if (name)
5d9c27ec
TK
3049 printf("%s %s not found\n", type, name);
3050 return;
3051 }
3052
059ec3d9
PH
3053if (names_only)
3054 {
3055 for (; d != NULL; d = d->next) printf("%s\n", CS d->name);
3056 return;
3057 }
3058
3059/* Either search for a given driver, or print all of them */
3060
3061for (; d != NULL; d = d->next)
3062 {
3063 if (name == NULL)
3064 printf("\n%s %s:\n", d->name, type);
3065 else if (Ustrcmp(d->name, name) != 0) continue;
3066
3067 for (ol = ol2; ol < ol2 + size; ol++)
3068 {
3069 if ((ol->type & opt_hidden) == 0)
12f69989 3070 print_ol(ol, US ol->name, d, ol2, size, no_labels);
059ec3d9
PH
3071 }
3072
3073 for (ol = d->info->options;
3074 ol < d->info->options + *(d->info->options_count); ol++)
3075 {
3076 if ((ol->type & opt_hidden) == 0)
12f69989 3077 print_ol(ol, US ol->name, d, d->info->options, *(d->info->options_count), no_labels);
059ec3d9
PH
3078 }
3079 if (name != NULL) return;
3080 }
3081if (name != NULL) printf("%s %s not found\n", type, name);
3082}
3083
3084
3085
3086/*************************************************
3087* Read a named list item *
3088*************************************************/
3089
3090/* This function reads a name and a list (i.e. string). The name is used to
3091save the list in a tree, sorted by its name. Each entry also has a number,
3092which can be used for caching tests, but if the string contains any expansion
3093items other than $key, the number is set negative to inhibit caching. This
3094mechanism is used for domain, host, and address lists that are referenced by
3095the "+name" syntax.
3096
3097Arguments:
3098 anchorp points to the tree anchor
3099 numberp points to the current number for this tree
3100 max the maximum number permitted
3101 s the text of the option line, starting immediately after the name
3102 of the list type
3103 tname the name of the list type, for messages
3104
3105Returns: nothing
3106*/
3107
3108static void
3109read_named_list(tree_node **anchorp, int *numberp, int max, uschar *s,
3110 uschar *tname)
3111{
3112BOOL forcecache = FALSE;
3113uschar *ss;
3114tree_node *t;
3115namedlist_block *nb = store_get(sizeof(namedlist_block));
3116
3117if (Ustrncmp(s, "_cache", 6) == 0)
3118 {
3119 forcecache = TRUE;
3120 s += 6;
3121 }
3122
3123if (!isspace(*s))
3124 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unrecognized configuration line");
3125
3126if (*numberp >= max)
3127 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many named %ss (max is %d)\n",
3128 tname, max);
3129
3130while (isspace(*s)) s++;
3131ss = s;
3132while (isalnum(*s) || *s == '_') s++;
3133t = store_get(sizeof(tree_node) + s-ss);
3134Ustrncpy(t->name, ss, s-ss);
3135t->name[s-ss] = 0;
3136while (isspace(*s)) s++;
3137
3138if (!tree_insertnode(anchorp, t))
3139 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3140 "duplicate name \"%s\" for a named %s", t->name, tname);
3141
3142t->data.ptr = nb;
3143nb->number = *numberp;
3144*numberp += 1;
3145
3146if (*s++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3147 "missing '=' after \"%s\"", t->name);
3148while (isspace(*s)) s++;
3149nb->string = read_string(s, t->name);
3150nb->cache_data = NULL;
3151
3152/* Check the string for any expansions; if any are found, mark this list
3153uncacheable unless the user has explicited forced caching. */
3154
3155if (!forcecache && Ustrchr(nb->string, '$') != NULL) nb->number = -1;
3156}
3157
3158
3159
3160
3161/*************************************************
3162* Unpick data for a rate limit *
3163*************************************************/
3164
3165/* This function is called to unpick smtp_ratelimit_{mail,rcpt} into four
3166separate values.
3167
3168Arguments:
3169 s string, in the form t,b,f,l
3170 where t is the threshold (integer)
3171 b is the initial delay (time)
3172 f is the multiplicative factor (fixed point)
3173 k is the maximum time (time)
3174 threshold where to store threshold
3175 base where to store base in milliseconds
3176 factor where to store factor in milliseconds
3177 limit where to store limit
3178
3179Returns: nothing (panics on error)
3180*/
3181
3182static void
3183unpick_ratelimit(uschar *s, int *threshold, int *base, double *factor,
3184 int *limit)
3185{
3186uschar bstring[16], lstring[16];
3187
3188if (sscanf(CS s, "%d, %15[0123456789smhdw.], %lf, %15s", threshold, bstring,
3189 factor, lstring) == 4)
3190 {
3191 *base = readconf_readtime(bstring, 0, TRUE);
3192 *limit = readconf_readtime(lstring, 0, TRUE);
3193 if (*base >= 0 && *limit >= 0) return;
3194 }
3195log_write(0, LOG_MAIN|LOG_PANIC_DIE, "malformed ratelimit data: %s", s);
3196}
3197
3198
3199
3200
3201/*************************************************
3375e053
PP
3202* Drop privs for checking TLS config *
3203*************************************************/
3204
3205/* We want to validate TLS options during readconf, but do not want to be
3206root when we call into the TLS library, in case of library linkage errors
3207which cause segfaults; before this check, those were always done as the Exim
3208runtime user and it makes sense to continue with that.
3209
3210Assumes: tls_require_ciphers has been set, if it will be
3211 exim_user has been set, if it will be
3212 exim_group has been set, if it will be
3213
3214Returns: bool for "okay"; false will cause caller to immediately exit.
3215*/
3216
3217#ifdef SUPPORT_TLS
3218static BOOL
4fab92fb 3219tls_dropprivs_validate_require_cipher(BOOL nowarn)
3375e053
PP
3220{
3221const uschar *errmsg;
3222pid_t pid;
3223int rc, status;
3224void (*oldsignal)(int);
3225
23f3dc67
JH
3226/* If TLS will never be used, no point checking ciphers */
3227
3228if ( !tls_advertise_hosts
3229 || !*tls_advertise_hosts
3230 || Ustrcmp(tls_advertise_hosts, ":") == 0
3231 )
3232 return TRUE;
4fab92fb
HSHR
3233else if (!nowarn && !tls_certificate)
3234 log_write(0, LOG_MAIN,
3235 "Warning: No server certificate defined; will use a selfsigned one.\n"
23f3dc67
JH
3236 " Suggested action: either install a certificate or change tls_advertise_hosts option");
3237
3375e053
PP
3238oldsignal = signal(SIGCHLD, SIG_DFL);
3239
3240fflush(NULL);
3241if ((pid = fork()) < 0)
3242 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "fork failed for TLS check");
3243
3244if (pid == 0)
3245 {
1d7a353e
PP
3246 /* in some modes, will have dropped privilege already */
3247 if (!geteuid())
3248 exim_setugid(exim_uid, exim_gid, FALSE,
3249 US"calling tls_validate_require_cipher");
3375e053
PP
3250
3251 errmsg = tls_validate_require_cipher();
3252 if (errmsg)
3253 {
3254 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3255 "tls_require_ciphers invalid: %s", errmsg);
3256 }
3257 fflush(NULL);
3258 _exit(0);
3259 }
3260
3261do {
3262 rc = waitpid(pid, &status, 0);
3263} while (rc < 0 && errno == EINTR);
3264
9d26b8c0 3265DEBUG(D_tls)
3375e053
PP
3266 debug_printf("tls_validate_require_cipher child %d ended: status=0x%x\n",
3267 (int)pid, status);
3268
3269signal(SIGCHLD, oldsignal);
3270
3271return status == 0;
3272}
3273#endif /* SUPPORT_TLS */
3274
3275
3276
3277
3278/*************************************************
059ec3d9
PH
3279* Read main configuration options *
3280*************************************************/
3281
3282/* This function is the first to be called for configuration reading. It
3283opens the configuration file and reads general configuration settings until
3284it reaches the end of the configuration section. The file is then left open so
3285that the remaining configuration data can subsequently be read if needed for
3286this run of Exim.
3287
3288The configuration file must be owned either by root or exim, and be writeable
3289only by root or uid/gid exim. The values for Exim's uid and gid can be changed
3290in the config file, so the test is done on the compiled in values. A slight
3291anomaly, to be carefully documented.
3292
3293The name of the configuration file is taken from a list that is included in the
3294binary of Exim. It can be altered from the command line, but if that is done,
3295root privilege is immediately withdrawn unless the caller is root or exim.
3296The first file on the list that exists is used.
3297
3298For use on multiple systems that share file systems, first look for a
3299configuration file whose name has the current node name on the end. If that is
3300not found, try the generic name. For really contorted configurations, that run
3301multiple Exims with different uid settings, first try adding the effective uid
3302before the node name. These complications are going to waste resources on most
3303systems. Therefore they are available only when requested by compile-time
3304options. */
3305
3306void
4fab92fb 3307readconf_main(BOOL nowarn)
059ec3d9
PH
3308{
3309int sep = 0;
3310struct stat statbuf;
3311uschar *s, *filename;
55414b25 3312const uschar *list = config_main_filelist;
059ec3d9
PH
3313
3314/* Loop through the possible file names */
3315
4fab92fb 3316while((filename = string_nextinlist(&list, &sep, big_buffer, big_buffer_size)))
059ec3d9 3317 {
4fab92fb 3318
059ec3d9
PH
3319 /* Cut out all the fancy processing unless specifically wanted */
3320
3321 #if defined(CONFIGURE_FILE_USE_NODE) || defined(CONFIGURE_FILE_USE_EUID)
3322 uschar *suffix = filename + Ustrlen(filename);
3323
3324 /* Try for the node-specific file if a node name exists */
3325
3326 #ifdef CONFIGURE_FILE_USE_NODE
3327 struct utsname uts;
3328 if (uname(&uts) >= 0)
3329 {
3330 #ifdef CONFIGURE_FILE_USE_EUID
3331 sprintf(CS suffix, ".%ld.%.256s", (long int)original_euid, uts.nodename);
3332 config_file = Ufopen(filename, "rb");
3333 if (config_file == NULL)
3334 #endif /* CONFIGURE_FILE_USE_EUID */
3335 {
3336 sprintf(CS suffix, ".%.256s", uts.nodename);
3337 config_file = Ufopen(filename, "rb");
3338 }
3339 }
3340 #endif /* CONFIGURE_FILE_USE_NODE */
3341
3342 /* Otherwise, try the generic name, possibly with the euid added */
3343
3344 #ifdef CONFIGURE_FILE_USE_EUID
3345 if (config_file == NULL)
3346 {
3347 sprintf(CS suffix, ".%ld", (long int)original_euid);
3348 config_file = Ufopen(filename, "rb");
3349 }
3350 #endif /* CONFIGURE_FILE_USE_EUID */
3351
3352 /* Finally, try the unadorned name */
3353
3354 if (config_file == NULL)
3355 {
3356 *suffix = 0;
3357 config_file = Ufopen(filename, "rb");
3358 }
3359 #else /* if neither defined */
3360
3361 /* This is the common case when the fancy processing is not included. */
3362
3363 config_file = Ufopen(filename, "rb");
3364 #endif
3365
3366 /* If the file does not exist, continue to try any others. For any other
3367 error, break out (and die). */
3368
3369 if (config_file != NULL || errno != ENOENT) break;
3370 }
3371
3372/* On success, save the name for verification; config_filename is used when
3373logging configuration errors (it changes for .included files) whereas
3374config_main_filename is the name shown by -bP. Failure to open a configuration
3375file is a serious disaster. */
3376
3377if (config_file != NULL)
3378 {
f10e2052 3379 uschar *slash = Ustrrchr(filename, '/');
059ec3d9 3380 config_filename = config_main_filename = string_copy(filename);
98b8312f 3381
f10e2052
HSHR
3382 /* the config_main_directory we need for the $config_dir expansion.
3383 And config_dir is the directory of the current configuration, used for
3384 relative .includes. We do need to know it's name, as we change our working
3385 directory later. */
3386
3387 if (filename[0] == '/')
3388 config_main_directory = slash > filename ? string_copyn(filename, slash - filename) : US"/";
3389 else
3390 {
3391 /* relative configuration file name: working dir + / + basename(filename) */
3392
3393 char buf[PATH_MAX];
3394 int offset = 0;
3395 int size = 0;
3396 const uschar *p = Ustrrchr(filename, '/');
3397
3398 if (getcwd(buf, PATH_MAX) == NULL)
3399 {
3400 perror("exim: getcwd");
3401 exit(EXIT_FAILURE);
3402 }
3403 config_main_directory = string_cat(NULL, &size, &offset, buf);
3404
3405 /* If the dir does not end with a "/", append one */
3406 if (config_main_directory[offset-1] != '/')
3407 string_cat(config_main_directory, &size, &offset, US"/");
3408
3409 /* If the config file contains a "/", extract the directory part */
3410 if (p)
3411 string_catn(config_main_directory, &size, &offset, filename, p - filename);
3412 }
3413 config_directory = config_main_directory;
059ec3d9
PH
3414 }
3415else
3416 {
3417 if (filename == NULL)
3418 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "non-existent configuration file(s): "
3419 "%s", config_main_filelist);
3420 else
3421 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", string_open_failed(errno,
3422 "configuration file %s", filename));
3423 }
3424
f10e2052
HSHR
3425/* Now, once we found and opened our configuration file, we change the directory
3426to a safe place. Later we change to $spool_directory. */
3427
3428if (Uchdir("/") < 0)
3429 {
3430 perror("exim: chdir `/': ");
3431 exit(EXIT_FAILURE);
3432 }
3433
e2f5dc15 3434/* Check the status of the file we have opened, if we have retained root
fea24b2e 3435privileges and the file isn't /dev/null (which *should* be 0666). */
059ec3d9 3436
fea24b2e 3437if (trusted_config && Ustrcmp(filename, US"/dev/null"))
059ec3d9
PH
3438 {
3439 if (fstat(fileno(config_file), &statbuf) != 0)
3440 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to stat configuration file %s",
3441 big_buffer);
3442
c1d94452 3443 if ((statbuf.st_uid != root_uid /* owner not root */
059ec3d9
PH
3444 #ifdef CONFIGURE_OWNER
3445 && statbuf.st_uid != config_uid /* owner not the special one */
3446 #endif
3447 ) || /* or */
c1d94452 3448 (statbuf.st_gid != root_gid /* group not root & */
35edf2ff
PH
3449 #ifdef CONFIGURE_GROUP
3450 && statbuf.st_gid != config_gid /* group not the special one */
8e669ac1 3451 #endif
35edf2ff 3452 && (statbuf.st_mode & 020) != 0) || /* group writeable */
059ec3d9
PH
3453 /* or */
3454 ((statbuf.st_mode & 2) != 0)) /* world writeable */
3455
3456 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Exim configuration file %s has the "
3457 "wrong owner, group, or mode", big_buffer);
3458 }
3459
3460/* Process the main configuration settings. They all begin with a lower case
3461letter. If we see something starting with an upper case letter, it is taken as
3462a macro definition. */
3463
3464while ((s = get_config_line()) != NULL)
3465 {
cf00dad6 3466 if (isupper(s[0])) read_macro_assignment(s);
059ec3d9
PH
3467
3468 else if (Ustrncmp(s, "domainlist", 10) == 0)
3469 read_named_list(&domainlist_anchor, &domainlist_count,
3470 MAX_NAMED_LIST, s+10, US"domain list");
3471
3472 else if (Ustrncmp(s, "hostlist", 8) == 0)
3473 read_named_list(&hostlist_anchor, &hostlist_count,
3474 MAX_NAMED_LIST, s+8, US"host list");
3475
3476 else if (Ustrncmp(s, US"addresslist", 11) == 0)
3477 read_named_list(&addresslist_anchor, &addresslist_count,
3478 MAX_NAMED_LIST, s+11, US"address list");
3479
3480 else if (Ustrncmp(s, US"localpartlist", 13) == 0)
3481 read_named_list(&localpartlist_anchor, &localpartlist_count,
3482 MAX_NAMED_LIST, s+13, US"local part list");
3483
3484 else
3485 (void) readconf_handle_option(s, optionlist_config, optionlist_config_size,
3486 NULL, US"main option \"%s\" unknown");
3487 }
3488
3489
3490/* If local_sender_retain is set, local_from_check must be unset. */
3491
3492if (local_sender_retain && local_from_check)
3493 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "both local_from_check and "
3494 "local_sender_retain are set; this combination is not allowed");
3495
3496/* If the timezone string is empty, set it to NULL, implying no TZ variable
3497wanted. */
3498
3499if (timezone_string != NULL && *timezone_string == 0) timezone_string = NULL;
3500
944a9c55
PH
3501/* The max retry interval must not be greater than 24 hours. */
3502
3503if (retry_interval_max > 24*60*60) retry_interval_max = 24*60*60;
3504
059ec3d9
PH
3505/* remote_max_parallel must be > 0 */
3506
3507if (remote_max_parallel <= 0) remote_max_parallel = 1;
3508
6a3f1455
PH
3509/* Save the configured setting of freeze_tell, so we can re-instate it at the
3510start of a new SMTP message. */
3511
3512freeze_tell_config = freeze_tell;
3513
059ec3d9
PH
3514/* The primary host name may be required for expansion of spool_directory
3515and log_file_path, so make sure it is set asap. It is obtained from uname(),
3516but if that yields an unqualified value, make a FQDN by using gethostbyname to
3517canonize it. Some people like upper case letters in their host names, so we
3518don't force the case. */
3519
3520if (primary_hostname == NULL)
3521 {
55414b25 3522 const uschar *hostname;
059ec3d9
PH
3523 struct utsname uts;
3524 if (uname(&uts) < 0)
3525 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "uname() failed to yield host name");
3526 hostname = US uts.nodename;
3527
3528 if (Ustrchr(hostname, '.') == NULL)
3529 {
3530 int af = AF_INET;
3531 struct hostent *hostdata;
3532
3533 #if HAVE_IPV6
7e66e54d 3534 if (!disable_ipv6 && (dns_ipv4_lookup == NULL ||
55414b25
JH
3535 match_isinlist(hostname, CUSS &dns_ipv4_lookup, 0, NULL, NULL,
3536 MCL_DOMAIN, TRUE, NULL) != OK))
059ec3d9
PH
3537 af = AF_INET6;
3538 #else
3539 af = AF_INET;
3540 #endif
3541
3542 for (;;)
3543 {
3544 #if HAVE_IPV6
3545 #if HAVE_GETIPNODEBYNAME
3546 int error_num;
3547 hostdata = getipnodebyname(CS hostname, af, 0, &error_num);
3548 #else
3549 hostdata = gethostbyname2(CS hostname, af);
3550 #endif
3551 #else
3552 hostdata = gethostbyname(CS hostname);
3553 #endif
3554
3555 if (hostdata != NULL)
3556 {
3557 hostname = US hostdata->h_name;
3558 break;
3559 }
3560
3561 if (af == AF_INET) break;
3562 af = AF_INET;
3563 }
3564 }
3565
3566 primary_hostname = string_copy(hostname);
3567 }
3568
3569/* Set up default value for smtp_active_hostname */
3570
3571smtp_active_hostname = primary_hostname;
3572
3573/* If spool_directory wasn't set in the build-time configuration, it must have
3574got set above. Of course, writing to the log may not work if log_file_path is
3575not set, but it will at least get to syslog or somewhere, with any luck. */
3576
3577if (*spool_directory == 0)
3578 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "spool_directory undefined: cannot "
3579 "proceed");
3580
3581/* Expand the spool directory name; it may, for example, contain the primary
3582host name. Same comment about failure. */
3583
3584s = expand_string(spool_directory);
3585if (s == NULL)
3586 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand spool_directory "
3587 "\"%s\": %s", spool_directory, expand_string_message);
3588spool_directory = s;
3589
3590/* Expand log_file_path, which must contain "%s" in any component that isn't
f1e5fef5
PP
3591the null string or "syslog". It is also allowed to contain one instance of %D
3592or %M. However, it must NOT contain % followed by anything else. */
059ec3d9
PH
3593
3594if (*log_file_path != 0)
3595 {
55414b25 3596 const uschar *ss, *sss;
059ec3d9
PH
3597 int sep = ':'; /* Fixed for log file path */
3598 s = expand_string(log_file_path);
3599 if (s == NULL)
3600 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand log_file_path "
3601 "\"%s\": %s", log_file_path, expand_string_message);
3602
3603 ss = s;
3604 while ((sss = string_nextinlist(&ss,&sep,big_buffer,big_buffer_size)) != NULL)
3605 {
3606 uschar *t;
3607 if (sss[0] == 0 || Ustrcmp(sss, "syslog") == 0) continue;
3608 t = Ustrstr(sss, "%s");
3609 if (t == NULL)
3610 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" does not "
3611 "contain \"%%s\"", sss);
3612 *t = 'X';
3613 t = Ustrchr(sss, '%');
3614 if (t != NULL)
3615 {
f1e5fef5 3616 if ((t[1] != 'D' && t[1] != 'M') || Ustrchr(t+2, '%') != NULL)
059ec3d9
PH
3617 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" contains "
3618 "unexpected \"%%\" character", s);
3619 }
3620 }
3621
3622 log_file_path = s;
3623 }
3624
3625/* Interpret syslog_facility into an integer argument for 'ident' param to
3626openlog(). Default is LOG_MAIL set in globals.c. Allow the user to omit the
3627leading "log_". */
3628
3629if (syslog_facility_str != NULL)
3630 {
3631 int i;
3632 uschar *s = syslog_facility_str;
3633
3634 if ((Ustrlen(syslog_facility_str) >= 4) &&
3635 (strncmpic(syslog_facility_str, US"log_", 4) == 0))
3636 s += 4;
3637
3638 for (i = 0; i < syslog_list_size; i++)
3639 {
3640 if (strcmpic(s, syslog_list[i].name) == 0)
3641 {
3642 syslog_facility = syslog_list[i].value;
3643 break;
3644 }
3645 }
3646
3647 if (i >= syslog_list_size)
3648 {
3649 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3650 "failed to interpret syslog_facility \"%s\"", syslog_facility_str);
3651 }
3652 }
3653
3654/* Expand pid_file_path */
3655
3656if (*pid_file_path != 0)
3657 {
3658 s = expand_string(pid_file_path);
3659 if (s == NULL)
3660 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand pid_file_path "
3661 "\"%s\": %s", pid_file_path, expand_string_message);
3662 pid_file_path = s;
3663 }
3664
921b12ca
TF
3665/* Set default value of process_log_path */
3666
3667if (process_log_path == NULL || *process_log_path =='\0')
3668 process_log_path = string_sprintf("%s/exim-process.info", spool_directory);
3669
059ec3d9
PH
3670/* Compile the regex for matching a UUCP-style "From_" line in an incoming
3671message. */
3672
3673regex_From = regex_must_compile(uucp_from_pattern, FALSE, TRUE);
3674
3675/* Unpick the SMTP rate limiting options, if set */
3676
3677if (smtp_ratelimit_mail != NULL)
3678 {
3679 unpick_ratelimit(smtp_ratelimit_mail, &smtp_rlm_threshold,
3680 &smtp_rlm_base, &smtp_rlm_factor, &smtp_rlm_limit);
3681 }
3682
3683if (smtp_ratelimit_rcpt != NULL)
3684 {
3685 unpick_ratelimit(smtp_ratelimit_rcpt, &smtp_rlr_threshold,
3686 &smtp_rlr_base, &smtp_rlr_factor, &smtp_rlr_limit);
3687 }
3688
3689/* The qualify domains default to the primary host name */
3690
3691if (qualify_domain_sender == NULL)
3692 qualify_domain_sender = primary_hostname;
3693if (qualify_domain_recipient == NULL)
3694 qualify_domain_recipient = qualify_domain_sender;
3695
3696/* Setting system_filter_user in the configuration sets the gid as well if a
3697name is given, but a numerical value does not. */
3698
3699if (system_filter_uid_set && !system_filter_gid_set)
3700 {
3701 struct passwd *pw = getpwuid(system_filter_uid);
3702 if (pw == NULL)
3703 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to look up uid %ld",
3704 (long int)system_filter_uid);
3705 system_filter_gid = pw->pw_gid;
3706 system_filter_gid_set = TRUE;
3707 }
3708
3709/* If the errors_reply_to field is set, check that it is syntactically valid
3710and ensure it contains a domain. */
3711
3712if (errors_reply_to != NULL)
3713 {
3714 uschar *errmess;
3715 int start, end, domain;
3716 uschar *recipient = parse_extract_address(errors_reply_to, &errmess,
3717 &start, &end, &domain, FALSE);
3718
3719 if (recipient == NULL)
3720 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3721 "error in errors_reply_to (%s): %s", errors_reply_to, errmess);
3722
3723 if (domain == 0)
3724 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3725 "errors_reply_to (%s) does not contain a domain", errors_reply_to);
3726 }
3727
3728/* If smtp_accept_queue or smtp_accept_max_per_host is set, then
3729smtp_accept_max must also be set. */
3730
3731if (smtp_accept_max == 0 &&
3732 (smtp_accept_queue > 0 || smtp_accept_max_per_host != NULL))
3733 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3734 "smtp_accept_max must be set if smtp_accept_queue or "
3735 "smtp_accept_max_per_host is set");
3736
3737/* Set up the host number if anything is specified. It is an expanded string
3738so that it can be computed from the host name, for example. We do this last
3739so as to ensure that everything else is set up before the expansion. */
3740
3741if (host_number_string != NULL)
3742 {
ef840681 3743 long int n;
059ec3d9
PH
3744 uschar *end;
3745 uschar *s = expand_string(host_number_string);
ef840681
PP
3746 if (s == NULL)
3747 log_write(0, LOG_MAIN|LOG_PANIC_DIE,
3748 "failed to expand localhost_number \"%s\": %s",
3749 host_number_string, expand_string_message);
3750 n = Ustrtol(s, &end, 0);
059ec3d9
PH
3751 while (isspace(*end)) end++;
3752 if (*end != 0)
3753 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3754 "localhost_number value is not a number: %s", s);
3755 if (n > LOCALHOST_MAX)
3756 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3757 "localhost_number is greater than the maximum allowed value (%d)",
3758 LOCALHOST_MAX);
3759 host_number = n;
3760 }
3761
3762#ifdef SUPPORT_TLS
3763/* If tls_verify_hosts is set, tls_verify_certificates must also be set */
3764
3765if ((tls_verify_hosts != NULL || tls_try_verify_hosts != NULL) &&
3766 tls_verify_certificates == NULL)
3767 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3768 "tls_%sverify_hosts is set, but tls_verify_certificates is not set",
3769 (tls_verify_hosts != NULL)? "" : "try_");
77bb000f 3770
3375e053
PP
3771/* This also checks that the library linkage is working and we can call
3772routines in it, so call even if tls_require_ciphers is unset */
4fab92fb 3773if (!tls_dropprivs_validate_require_cipher(nowarn))
3375e053
PP
3774 exit(1);
3775
3776/* Magic number: at time of writing, 1024 has been the long-standing value
3777used by so many clients, and what Exim used to use always, that it makes
3778sense to just min-clamp this max-clamp at that. */
3779if (tls_dh_max_bits < 1024)
3780 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3781 "tls_dh_max_bits is too small, must be at least 1024 for interop");
3782
77bb000f
PP
3783/* If openssl_options is set, validate it */
3784if (openssl_options != NULL)
3785 {
3786# ifdef USE_GNUTLS
3787 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
a053d125 3788 "openssl_options is set but we're using GnuTLS");
77bb000f
PP
3789# else
3790 long dummy;
3791 if (!(tls_openssl_options_parse(openssl_options, &dummy)))
3792 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
a053d125 3793 "openssl_options parse error: %s", openssl_options);
77bb000f
PP
3794# endif
3795 }
32d07012 3796#endif /*SUPPORT_TLS*/
4fab92fb
HSHR
3797
3798if (!nowarn && !keep_environment && environ && *environ)
3799 log_write(0, LOG_MAIN,
3800 "Warning: purging the environment.\n"
3801 " Suggested action: use keep_environment.");
059ec3d9
PH
3802}
3803
3804
3805
3806/*************************************************
3807* Initialize one driver *
3808*************************************************/
3809
3810/* This is called once the driver's generic options, if any, have been read.
3811We can now find the driver, set up defaults for the private options, and
3812unset any "set" bits in the private options table (which might have been
3813set by another incarnation of the same driver).
3814
3815Arguments:
3816 d pointer to driver instance block, with generic
3817 options filled in
3818 drivers_available vector of available drivers
3819 size_of_info size of each block in drive