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