projects / exim.git / blob
? search:


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