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