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