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