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