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