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