1 /* $Cambridge: exim/src/src/readconf.c,v 1.27 2007/01/18 15:35:42 ph10 Exp $ */
3 /*************************************************
4 * Exim - an Internet mail transport agent *
5 *************************************************/
7 /* Copyright (c) University of Cambridge 1995 - 2007 */
8 /* See the file NOTICE for conditions of use and distribution. */
10 /* Functions for reading the configuration file, and for displaying
11 overall configuration values. Thanks to Brian Candler for the original
12 implementation of the conditional .ifdef etc. */
16 #define CSTATE_STACK_SIZE 10
19 /* Structure for chain (stack) of .included files */
21 typedef struct config_file_item {
22 struct config_file_item *next;
28 /* Structure of table of conditional words and their state transitions */
30 typedef struct cond_item {
38 /* Structure of table of syslog facility names and values */
40 typedef struct syslog_fac_item {
46 /* Static variables */
48 static config_file_item *config_file_stack = NULL; /* For includes */
50 static uschar *syslog_facility_str = NULL;
51 static uschar next_section[24];
52 static uschar time_buffer[24];
54 /* State variables for conditional loading (.ifdef / .else / .endif) */
56 static int cstate = 0;
57 static int cstate_stack_ptr = -1;
58 static int cstate_stack[CSTATE_STACK_SIZE];
60 /* Table of state transitions for handling conditional inclusions. There are
61 four possible state transitions:
65 .elifdef true (or .else)
68 .endif just causes the previous cstate to be popped off the stack */
70 static int next_cstate[3][4] =
72 /* State 0: reading from file, or reading until next .else or .endif */
74 /* State 1: condition failed, skipping until next .else or .endif */
76 /* State 2: skipping until .endif */
80 /* Table of conditionals and the states to set. For each name, there are four
81 values: the length of the name (to save computing it each time), the state to
82 set if a macro was found in the line, the state to set if a macro was not found
83 in the line, and a stack manipulation setting which is:
85 -1 pull state value off the stack
86 0 don't alter the stack
87 +1 push value onto stack, before setting new state
90 static cond_item cond_list[] = {
91 { US"ifdef", 5, 0, 1, 1 },
92 { US"ifndef", 6, 1, 0, 1 },
93 { US"elifdef", 7, 2, 3, 0 },
94 { US"elifndef", 8, 3, 2, 0 },
95 { US"else", 4, 2, 2, 0 },
96 { US"endif", 5, 0, 0, -1 }
99 static int cond_list_size = sizeof(cond_list)/sizeof(cond_item);
101 /* Table of syslog facility names and their values */
103 static syslog_fac_item syslog_list[] = {
104 { US"mail", LOG_MAIL },
105 { US"user", LOG_USER },
106 { US"news", LOG_NEWS },
107 { US"uucp", LOG_UUCP },
108 { US"local0", LOG_LOCAL0 },
109 { US"local1", LOG_LOCAL1 },
110 { US"local2", LOG_LOCAL2 },
111 { US"local3", LOG_LOCAL3 },
112 { US"local4", LOG_LOCAL4 },
113 { US"local5", LOG_LOCAL5 },
114 { US"local6", LOG_LOCAL6 },
115 { US"local7", LOG_LOCAL7 },
116 { US"daemon", LOG_DAEMON }
119 static int syslog_list_size = sizeof(syslog_list)/sizeof(syslog_fac_item);
124 /*************************************************
125 * Main configuration options *
126 *************************************************/
128 /* The list of options that can be set in the main configuration file. This
129 must be in alphabetic order because it is searched by binary chop. */
131 static optionlist optionlist_config[] = {
132 { "*set_exim_group", opt_bool|opt_hidden, &exim_gid_set },
133 { "*set_exim_user", opt_bool|opt_hidden, &exim_uid_set },
134 { "*set_system_filter_group", opt_bool|opt_hidden, &system_filter_gid_set },
135 { "*set_system_filter_user", opt_bool|opt_hidden, &system_filter_uid_set },
136 { "accept_8bitmime", opt_bool, &accept_8bitmime },
137 { "acl_not_smtp", opt_stringptr, &acl_not_smtp },
138 #ifdef WITH_CONTENT_SCAN
139 { "acl_not_smtp_mime", opt_stringptr, &acl_not_smtp_mime },
141 { "acl_not_smtp_start", opt_stringptr, &acl_not_smtp_start },
142 { "acl_smtp_auth", opt_stringptr, &acl_smtp_auth },
143 { "acl_smtp_connect", opt_stringptr, &acl_smtp_connect },
144 { "acl_smtp_data", opt_stringptr, &acl_smtp_data },
145 { "acl_smtp_etrn", opt_stringptr, &acl_smtp_etrn },
146 { "acl_smtp_expn", opt_stringptr, &acl_smtp_expn },
147 { "acl_smtp_helo", opt_stringptr, &acl_smtp_helo },
148 { "acl_smtp_mail", opt_stringptr, &acl_smtp_mail },
149 { "acl_smtp_mailauth", opt_stringptr, &acl_smtp_mailauth },
150 #ifdef WITH_CONTENT_SCAN
151 { "acl_smtp_mime", opt_stringptr, &acl_smtp_mime },
153 { "acl_smtp_predata", opt_stringptr, &acl_smtp_predata },
154 { "acl_smtp_quit", opt_stringptr, &acl_smtp_quit },
155 { "acl_smtp_rcpt", opt_stringptr, &acl_smtp_rcpt },
157 { "acl_smtp_starttls", opt_stringptr, &acl_smtp_starttls },
159 { "acl_smtp_vrfy", opt_stringptr, &acl_smtp_vrfy },
160 { "admin_groups", opt_gidlist, &admin_groups },
161 { "allow_domain_literals", opt_bool, &allow_domain_literals },
162 { "allow_mx_to_ip", opt_bool, &allow_mx_to_ip },
163 { "allow_utf8_domains", opt_bool, &allow_utf8_domains },
164 { "auth_advertise_hosts", opt_stringptr, &auth_advertise_hosts },
165 { "auto_thaw", opt_time, &auto_thaw },
166 #ifdef WITH_CONTENT_SCAN
167 { "av_scanner", opt_stringptr, &av_scanner },
169 { "bi_command", opt_stringptr, &bi_command },
170 #ifdef EXPERIMENTAL_BRIGHTMAIL
171 { "bmi_config_file", opt_stringptr, &bmi_config_file },
173 { "bounce_message_file", opt_stringptr, &bounce_message_file },
174 { "bounce_message_text", opt_stringptr, &bounce_message_text },
175 { "bounce_return_body", opt_bool, &bounce_return_body },
176 { "bounce_return_message", opt_bool, &bounce_return_message },
177 { "bounce_return_size_limit", opt_mkint, &bounce_return_size_limit },
178 { "bounce_sender_authentication",opt_stringptr,&bounce_sender_authentication },
179 { "callout_domain_negative_expire", opt_time, &callout_cache_domain_negative_expire },
180 { "callout_domain_positive_expire", opt_time, &callout_cache_domain_positive_expire },
181 { "callout_negative_expire", opt_time, &callout_cache_negative_expire },
182 { "callout_positive_expire", opt_time, &callout_cache_positive_expire },
183 { "callout_random_local_part",opt_stringptr, &callout_random_local_part },
184 { "check_log_inodes", opt_int, &check_log_inodes },
185 { "check_log_space", opt_Kint, &check_log_space },
186 { "check_rfc2047_length", opt_bool, &check_rfc2047_length },
187 { "check_spool_inodes", opt_int, &check_spool_inodes },
188 { "check_spool_space", opt_Kint, &check_spool_space },
189 { "daemon_smtp_port", opt_stringptr|opt_hidden, &daemon_smtp_port },
190 { "daemon_smtp_ports", opt_stringptr, &daemon_smtp_port },
191 { "daemon_startup_retries", opt_int, &daemon_startup_retries },
192 { "daemon_startup_sleep", opt_time, &daemon_startup_sleep },
193 { "delay_warning", opt_timelist, &delay_warning },
194 { "delay_warning_condition", opt_stringptr, &delay_warning_condition },
195 { "deliver_drop_privilege", opt_bool, &deliver_drop_privilege },
196 { "deliver_queue_load_max", opt_fixed, &deliver_queue_load_max },
197 { "delivery_date_remove", opt_bool, &delivery_date_remove },
198 { "disable_ipv6", opt_bool, &disable_ipv6 },
199 { "dns_again_means_nonexist", opt_stringptr, &dns_again_means_nonexist },
200 { "dns_check_names_pattern", opt_stringptr, &check_dns_names_pattern },
201 { "dns_csa_search_limit", opt_int, &dns_csa_search_limit },
202 { "dns_csa_use_reverse", opt_bool, &dns_csa_use_reverse },
203 { "dns_ipv4_lookup", opt_stringptr, &dns_ipv4_lookup },
204 { "dns_retrans", opt_time, &dns_retrans },
205 { "dns_retry", opt_int, &dns_retry },
206 /* This option is now a no-op, retained for compability */
207 { "drop_cr", opt_bool, &drop_cr },
208 /*********************************************************/
209 { "envelope_to_remove", opt_bool, &envelope_to_remove },
210 { "errors_copy", opt_stringptr, &errors_copy },
211 { "errors_reply_to", opt_stringptr, &errors_reply_to },
212 { "exim_group", opt_gid, &exim_gid },
213 { "exim_path", opt_stringptr, &exim_path },
214 { "exim_user", opt_uid, &exim_uid },
215 { "extra_local_interfaces", opt_stringptr, &extra_local_interfaces },
216 { "extract_addresses_remove_arguments", opt_bool, &extract_addresses_remove_arguments },
217 { "finduser_retries", opt_int, &finduser_retries },
218 { "freeze_tell", opt_stringptr, &freeze_tell },
219 { "gecos_name", opt_stringptr, &gecos_name },
220 { "gecos_pattern", opt_stringptr, &gecos_pattern },
222 { "gnutls_require_kx", opt_stringptr, &gnutls_require_kx },
223 { "gnutls_require_mac", opt_stringptr, &gnutls_require_mac },
224 { "gnutls_require_protocols", opt_stringptr, &gnutls_require_proto },
226 { "header_line_maxsize", opt_int, &header_line_maxsize },
227 { "header_maxsize", opt_int, &header_maxsize },
228 { "headers_charset", opt_stringptr, &headers_charset },
229 { "helo_accept_junk_hosts", opt_stringptr, &helo_accept_junk_hosts },
230 { "helo_allow_chars", opt_stringptr, &helo_allow_chars },
231 { "helo_lookup_domains", opt_stringptr, &helo_lookup_domains },
232 { "helo_try_verify_hosts", opt_stringptr, &helo_try_verify_hosts },
233 { "helo_verify_hosts", opt_stringptr, &helo_verify_hosts },
234 { "hold_domains", opt_stringptr, &hold_domains },
235 { "host_lookup", opt_stringptr, &host_lookup },
236 { "host_lookup_order", opt_stringptr, &host_lookup_order },
237 { "host_reject_connection", opt_stringptr, &host_reject_connection },
238 { "hosts_connection_nolog", opt_stringptr, &hosts_connection_nolog },
239 { "hosts_treat_as_local", opt_stringptr, &hosts_treat_as_local },
241 { "ibase_servers", opt_stringptr, &ibase_servers },
243 { "ignore_bounce_errors_after", opt_time, &ignore_bounce_errors_after },
244 { "ignore_fromline_hosts", opt_stringptr, &ignore_fromline_hosts },
245 { "ignore_fromline_local", opt_bool, &ignore_fromline_local },
246 { "keep_malformed", opt_time, &keep_malformed },
248 { "ldap_default_servers", opt_stringptr, &eldap_default_servers },
249 { "ldap_version", opt_int, &eldap_version },
251 { "local_from_check", opt_bool, &local_from_check },
252 { "local_from_prefix", opt_stringptr, &local_from_prefix },
253 { "local_from_suffix", opt_stringptr, &local_from_suffix },
254 { "local_interfaces", opt_stringptr, &local_interfaces },
255 { "local_scan_timeout", opt_time, &local_scan_timeout },
256 { "local_sender_retain", opt_bool, &local_sender_retain },
257 { "localhost_number", opt_stringptr, &host_number_string },
258 { "log_file_path", opt_stringptr, &log_file_path },
259 { "log_selector", opt_stringptr, &log_selector_string },
260 { "log_timezone", opt_bool, &log_timezone },
261 { "lookup_open_max", opt_int, &lookup_open_max },
262 { "max_username_length", opt_int, &max_username_length },
263 { "message_body_visible", opt_mkint, &message_body_visible },
264 { "message_id_header_domain", opt_stringptr, &message_id_domain },
265 { "message_id_header_text", opt_stringptr, &message_id_text },
266 { "message_logs", opt_bool, &message_logs },
267 { "message_size_limit", opt_stringptr, &message_size_limit },
268 #ifdef SUPPORT_MOVE_FROZEN_MESSAGES
269 { "move_frozen_messages", opt_bool, &move_frozen_messages },
271 { "mua_wrapper", opt_bool, &mua_wrapper },
273 { "mysql_servers", opt_stringptr, &mysql_servers },
275 { "never_users", opt_uidlist, &never_users },
277 { "oracle_servers", opt_stringptr, &oracle_servers },
279 { "percent_hack_domains", opt_stringptr, &percent_hack_domains },
281 { "perl_at_start", opt_bool, &opt_perl_at_start },
282 { "perl_startup", opt_stringptr, &opt_perl_startup },
285 { "pgsql_servers", opt_stringptr, &pgsql_servers },
287 { "pid_file_path", opt_stringptr, &pid_file_path },
288 { "pipelining_advertise_hosts", opt_stringptr, &pipelining_advertise_hosts },
289 { "preserve_message_logs", opt_bool, &preserve_message_logs },
290 { "primary_hostname", opt_stringptr, &primary_hostname },
291 { "print_topbitchars", opt_bool, &print_topbitchars },
292 { "process_log_path", opt_stringptr, &process_log_path },
293 { "prod_requires_admin", opt_bool, &prod_requires_admin },
294 { "qualify_domain", opt_stringptr, &qualify_domain_sender },
295 { "qualify_recipient", opt_stringptr, &qualify_domain_recipient },
296 { "queue_domains", opt_stringptr, &queue_domains },
297 { "queue_list_requires_admin",opt_bool, &queue_list_requires_admin },
298 { "queue_only", opt_bool, &queue_only },
299 { "queue_only_file", opt_stringptr, &queue_only_file },
300 { "queue_only_load", opt_fixed, &queue_only_load },
301 { "queue_only_override", opt_bool, &queue_only_override },
302 { "queue_run_in_order", opt_bool, &queue_run_in_order },
303 { "queue_run_max", opt_int, &queue_run_max },
304 { "queue_smtp_domains", opt_stringptr, &queue_smtp_domains },
305 { "receive_timeout", opt_time, &receive_timeout },
306 { "received_header_text", opt_stringptr, &received_header_text },
307 { "received_headers_max", opt_int, &received_headers_max },
308 { "recipient_unqualified_hosts", opt_stringptr, &recipient_unqualified_hosts },
309 { "recipients_max", opt_int, &recipients_max },
310 { "recipients_max_reject", opt_bool, &recipients_max_reject },
311 { "remote_max_parallel", opt_int, &remote_max_parallel },
312 { "remote_sort_domains", opt_stringptr, &remote_sort_domains },
313 { "retry_data_expire", opt_time, &retry_data_expire },
314 { "retry_interval_max", opt_time, &retry_interval_max },
315 { "return_path_remove", opt_bool, &return_path_remove },
316 { "return_size_limit", opt_mkint|opt_hidden, &bounce_return_size_limit },
317 { "rfc1413_hosts", opt_stringptr, &rfc1413_hosts },
318 { "rfc1413_query_timeout", opt_time, &rfc1413_query_timeout },
319 { "sender_unqualified_hosts", opt_stringptr, &sender_unqualified_hosts },
320 { "smtp_accept_keepalive", opt_bool, &smtp_accept_keepalive },
321 { "smtp_accept_max", opt_int, &smtp_accept_max },
322 { "smtp_accept_max_nonmail", opt_int, &smtp_accept_max_nonmail },
323 { "smtp_accept_max_nonmail_hosts", opt_stringptr, &smtp_accept_max_nonmail_hosts },
324 { "smtp_accept_max_per_connection", opt_int, &smtp_accept_max_per_connection },
325 { "smtp_accept_max_per_host", opt_stringptr, &smtp_accept_max_per_host },
326 { "smtp_accept_queue", opt_int, &smtp_accept_queue },
327 { "smtp_accept_queue_per_connection", opt_int, &smtp_accept_queue_per_connection },
328 { "smtp_accept_reserve", opt_int, &smtp_accept_reserve },
329 { "smtp_active_hostname", opt_stringptr, &raw_active_hostname },
330 { "smtp_banner", opt_stringptr, &smtp_banner },
331 { "smtp_check_spool_space", opt_bool, &smtp_check_spool_space },
332 { "smtp_connect_backlog", opt_int, &smtp_connect_backlog },
333 { "smtp_enforce_sync", opt_bool, &smtp_enforce_sync },
334 { "smtp_etrn_command", opt_stringptr, &smtp_etrn_command },
335 { "smtp_etrn_serialize", opt_bool, &smtp_etrn_serialize },
336 { "smtp_load_reserve", opt_fixed, &smtp_load_reserve },
337 { "smtp_max_synprot_errors", opt_int, &smtp_max_synprot_errors },
338 { "smtp_max_unknown_commands",opt_int, &smtp_max_unknown_commands },
339 { "smtp_ratelimit_hosts", opt_stringptr, &smtp_ratelimit_hosts },
340 { "smtp_ratelimit_mail", opt_stringptr, &smtp_ratelimit_mail },
341 { "smtp_ratelimit_rcpt", opt_stringptr, &smtp_ratelimit_rcpt },
342 { "smtp_receive_timeout", opt_time, &smtp_receive_timeout },
343 { "smtp_reserve_hosts", opt_stringptr, &smtp_reserve_hosts },
344 { "smtp_return_error_details",opt_bool, &smtp_return_error_details },
345 #ifdef WITH_CONTENT_SCAN
346 { "spamd_address", opt_stringptr, &spamd_address },
348 { "split_spool_directory", opt_bool, &split_spool_directory },
349 { "spool_directory", opt_stringptr, &spool_directory },
351 { "sqlite_lock_timeout", opt_int, &sqlite_lock_timeout },
353 #ifdef EXPERIMENTAL_SRS
354 { "srs_config", opt_stringptr, &srs_config },
355 { "srs_hashlength", opt_int, &srs_hashlength },
356 { "srs_hashmin", opt_int, &srs_hashmin },
357 { "srs_maxage", opt_int, &srs_maxage },
358 { "srs_secrets", opt_stringptr, &srs_secrets },
359 { "srs_usehash", opt_bool, &srs_usehash },
360 { "srs_usetimestamp", opt_bool, &srs_usetimestamp },
362 { "strict_acl_vars", opt_bool, &strict_acl_vars },
363 { "strip_excess_angle_brackets", opt_bool, &strip_excess_angle_brackets },
364 { "strip_trailing_dot", opt_bool, &strip_trailing_dot },
365 { "syslog_duplication", opt_bool, &syslog_duplication },
366 { "syslog_facility", opt_stringptr, &syslog_facility_str },
367 { "syslog_processname", opt_stringptr, &syslog_processname },
368 { "syslog_timestamp", opt_bool, &syslog_timestamp },
369 { "system_filter", opt_stringptr, &system_filter },
370 { "system_filter_directory_transport", opt_stringptr,&system_filter_directory_transport },
371 { "system_filter_file_transport",opt_stringptr,&system_filter_file_transport },
372 { "system_filter_group", opt_gid, &system_filter_gid },
373 { "system_filter_pipe_transport",opt_stringptr,&system_filter_pipe_transport },
374 { "system_filter_reply_transport",opt_stringptr,&system_filter_reply_transport },
375 { "system_filter_user", opt_uid, &system_filter_uid },
376 { "tcp_nodelay", opt_bool, &tcp_nodelay },
377 { "timeout_frozen_after", opt_time, &timeout_frozen_after },
378 { "timezone", opt_stringptr, &timezone_string },
380 { "tls_advertise_hosts", opt_stringptr, &tls_advertise_hosts },
381 { "tls_certificate", opt_stringptr, &tls_certificate },
382 { "tls_crl", opt_stringptr, &tls_crl },
383 { "tls_dhparam", opt_stringptr, &tls_dhparam },
384 { "tls_on_connect_ports", opt_stringptr, &tls_on_connect_ports },
385 { "tls_privatekey", opt_stringptr, &tls_privatekey },
386 { "tls_remember_esmtp", opt_bool, &tls_remember_esmtp },
387 { "tls_require_ciphers", opt_stringptr, &tls_require_ciphers },
388 { "tls_try_verify_hosts", opt_stringptr, &tls_try_verify_hosts },
389 { "tls_verify_certificates", opt_stringptr, &tls_verify_certificates },
390 { "tls_verify_hosts", opt_stringptr, &tls_verify_hosts },
392 { "trusted_groups", opt_gidlist, &trusted_groups },
393 { "trusted_users", opt_uidlist, &trusted_users },
394 { "unknown_login", opt_stringptr, &unknown_login },
395 { "unknown_username", opt_stringptr, &unknown_username },
396 { "untrusted_set_sender", opt_stringptr, &untrusted_set_sender },
397 { "uucp_from_pattern", opt_stringptr, &uucp_from_pattern },
398 { "uucp_from_sender", opt_stringptr, &uucp_from_sender },
399 { "warn_message_file", opt_stringptr, &warn_message_file },
400 { "write_rejectlog", opt_bool, &write_rejectlog }
403 static int optionlist_config_size =
404 sizeof(optionlist_config)/sizeof(optionlist);
408 /*************************************************
409 * Find the name of an option *
410 *************************************************/
412 /* This function is to aid debugging. Various functions take arguments that are
413 pointer variables in the options table or in option tables for various drivers.
414 For debugging output, it is useful to be able to find the name of the option
415 which is currently being processed. This function finds it, if it exists, by
416 searching the table(s).
418 Arguments: a value that is presumed to be in the table above
419 Returns: the option name, or an empty string
423 readconf_find_option(void *p)
427 transport_instance *t;
429 for (i = 0; i < optionlist_config_size; i++)
430 if (p == optionlist_config[i].value) return US optionlist_config[i].name;
432 for (r = routers; r != NULL; r = r->next)
434 router_info *ri = r->info;
435 for (i = 0; i < ri->options_count[0]; i++)
437 if ((ri->options[i].type & opt_mask) != opt_stringptr) continue;
438 if (p == (char *)(r->options_block) + (long int)(ri->options[i].value))
439 return US ri->options[i].name;
443 for (t = transports; t != NULL; t = t->next)
445 transport_info *ti = t->info;
446 for (i = 0; i < ti->options_count[0]; i++)
448 if ((ti->options[i].type & opt_mask) != opt_stringptr) continue;
449 if (p == (char *)(t->options_block) + (long int)(ti->options[i].value))
450 return US ti->options[i].name;
460 /*************************************************
461 * Deal with an assignment to a macro *
462 *************************************************/
464 /* This function is called when a line that starts with an upper case letter is
465 encountered. The argument "line" should contain a complete logical line, and
466 start with the first letter of the macro name. The macro name and the
467 replacement text are extracted and stored. Redefinition of existing,
468 non-command line, macros is permitted using '==' instead of '='.
471 s points to the start of the logical line
477 read_macro_assignment(uschar *s)
483 macro_item *mlast = NULL;
485 while (isalnum(*s) || *s == '_')
487 if (namelen >= sizeof(name) - 1)
488 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
489 "macro name too long (maximum is %d characters)", sizeof(name) - 1);
490 name[namelen++] = *s++;
494 while (isspace(*s)) s++;
496 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "malformed macro definition");
503 while (isspace(*s)) s++;
505 /* If an existing macro of the same name was defined on the command line, we
506 just skip this definition. It's an error to attempt to redefine a macro without
507 redef set to TRUE, or to redefine a macro when it hasn't been defined earlier.
508 It is also an error to define a macro whose name begins with the name of a
509 previously defined macro. Note: it is documented that the other way round
512 for (m = macros; m != NULL; m = m->next)
514 int len = Ustrlen(m->name);
516 if (Ustrcmp(m->name, name) == 0)
518 if (!m->command_line && !redef)
519 log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "macro \"%s\" is already "
520 "defined (use \"==\" if you want to redefine it", name);
524 if (len < namelen && Ustrstr(name, m->name) != NULL)
525 log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "\"%s\" cannot be defined as "
526 "a macro because previously defined macro \"%s\" is a substring",
529 /* We cannot have this test, because it is documented that a substring
530 macro is permitted (there is even an example).
532 * if (len > namelen && Ustrstr(m->name, name) != NULL)
533 * log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "\"%s\" cannot be defined as "
534 * "a macro because it is a substring of previously defined macro \"%s\"",
541 /* Check for an overriding command-line definition. */
543 if (m != NULL && m->command_line) return;
545 /* Redefinition must refer to an existing macro. */
550 log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "can't redefine an undefined macro "
554 /* We have a new definition. The macro_item structure includes a final vector
555 called "name" which is one byte long. Thus, adding "namelen" gives us enough
556 room to store the "name" string. */
560 m = store_get(sizeof(macro_item) + namelen);
561 if (macros == NULL) macros = m; else mlast->next = m;
562 Ustrncpy(m->name, name, namelen);
563 m->name[namelen] = 0;
565 m->command_line = FALSE;
568 /* Set the value of the new or redefined macro */
570 m->replacement = string_copy(s);
577 /*************************************************
578 * Read configuration line *
579 *************************************************/
581 /* A logical line of text is read from the configuration file into the big
582 buffer, taking account of macros, .includes, and continuations. The size of
583 big_buffer is increased if necessary. The count of configuration lines is
584 maintained. Physical input lines starting with # (ignoring leading white space,
585 and after macro replacement) and empty logical lines are always ignored.
586 Leading and trailing spaces are removed.
588 If we hit a line of the form "begin xxxx", the xxxx is placed in the
589 next_section vector, and the function returns NULL, indicating the end of a
590 configuration section. On end-of-file, NULL is returned with next_section
595 Returns: a pointer to the first non-blank in the line,
596 or NULL if eof or end of section is reached
600 get_config_line(void)
602 int startoffset = 0; /* To first non-blank char in logical line */
603 int len = 0; /* Of logical line so far */
609 /* Loop for handling continuation lines, skipping comments, and dealing with
614 if (Ufgets(big_buffer+len, big_buffer_size-len, config_file) == NULL)
616 if (config_file_stack != NULL) /* EOF inside .include */
618 (void)fclose(config_file);
619 config_file = config_file_stack->file;
620 config_filename = config_file_stack->filename;
621 config_lineno = config_file_stack->lineno;
622 config_file_stack = config_file_stack->next;
626 /* EOF at top level */
628 if (cstate_stack_ptr >= 0)
629 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
630 "Unexpected end of configuration file: .endif missing");
632 if (len != 0) break; /* EOF after continuation */
633 next_section[0] = 0; /* EOF at start of logical line */
638 newlen = len + Ustrlen(big_buffer + len);
640 /* Handle pathologically long physical lines - yes, it did happen - by
641 extending big_buffer at this point. The code also copes with very long
644 while (newlen == big_buffer_size - 1 && big_buffer[newlen - 1] != '\n')
647 big_buffer_size += BIG_BUFFER_SIZE;
648 newbuffer = store_malloc(big_buffer_size);
650 /* This use of strcpy is OK because we know that the string in the old
651 buffer is shorter than the new buffer. */
653 Ustrcpy(newbuffer, big_buffer);
654 store_free(big_buffer);
655 big_buffer = newbuffer;
656 if (Ufgets(big_buffer+newlen, big_buffer_size-newlen, config_file) == NULL)
658 newlen += Ustrlen(big_buffer + newlen);
661 /* Find the true start of the physical line - leading spaces are always
664 ss = big_buffer + len;
665 while (isspace(*ss)) ss++;
667 /* Process the physical line for macros. If this is the start of the logical
668 line, skip over initial text at the start of the line if it starts with an
669 upper case character followed by a sequence of name characters and an equals
670 sign, because that is the definition of a new macro, and we don't do
671 replacement therein. */
674 if (len == 0 && isupper(*s))
676 while (isalnum(*s) || *s == '_') s++;
677 while (isspace(*s)) s++;
678 if (*s != '=') s = ss; /* Not a macro definition */
681 /* For each defined macro, scan the line (from after XXX= if present),
682 replacing all occurrences of the macro. */
685 for (m = macros; m != NULL; m = m->next)
690 while ((p = Ustrstr(t, m->name)) != NULL)
693 int namelen = Ustrlen(m->name);
694 int replen = Ustrlen(m->replacement);
696 /* Expand the buffer if necessary */
698 while (newlen - namelen + replen + 1 > big_buffer_size)
700 int newsize = big_buffer_size + BIG_BUFFER_SIZE;
701 uschar *newbuffer = store_malloc(newsize);
702 memcpy(newbuffer, big_buffer, newlen + 1);
703 p = newbuffer + (p - big_buffer);
704 s = newbuffer + (s - big_buffer);
705 ss = newbuffer + (ss - big_buffer);
706 t = newbuffer + (t - big_buffer);
707 big_buffer_size = newsize;
708 store_free(big_buffer);
709 big_buffer = newbuffer;
712 /* Shuffle the remaining characters up or down in the buffer before
713 copying in the replacement text. Don't rescan the replacement for this
717 moveby = replen - namelen;
720 memmove(p + replen, pp, (big_buffer + newlen) - pp + 1);
723 Ustrncpy(p, m->replacement, replen);
729 /* An empty macro replacement at the start of a line could mean that ss no
730 longer points to the first non-blank character. */
732 while (isspace(*ss)) ss++;
734 /* Check for comment lines - these are physical lines. */
736 if (*ss == '#') continue;
738 /* Handle conditionals, which are also applied to physical lines. Conditions
739 are of the form ".ifdef ANYTEXT" and are treated as true if any macro
740 expansion occured on the rest of the line. A preliminary test for the leading
741 '.' saves effort on most lines. */
747 /* Search the list of conditional directives */
749 for (i = 0; i < cond_list_size; i++)
752 cond_item *c = cond_list+i;
753 if (Ustrncmp(ss+1, c->name, c->namelen) != 0) continue;
755 /* The following character must be white space or end of string */
757 n = ss[1 + c->namelen];
758 if (n != ' ' && n != 't' && n != '\n' && n != 0) break;
760 /* .ifdef and .ifndef push the current state onto the stack, then set
761 a new one from the table. Stack overflow is an error */
765 if (cstate_stack_ptr >= CSTATE_STACK_SIZE - 1)
766 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
767 ".%s nested too deeply", c->name);
768 cstate_stack[++cstate_stack_ptr] = cstate;
769 cstate = next_cstate[cstate][macro_found? c->action1 : c->action2];
772 /* For any of the others, stack underflow is an error. The next state
773 comes either from the stack (.endif) or from the table. */
777 if (cstate_stack_ptr < 0)
778 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
779 ".%s without matching .ifdef", c->name);
780 cstate = (c->pushpop < 0)? cstate_stack[cstate_stack_ptr--] :
781 next_cstate[cstate][macro_found? c->action1 : c->action2];
784 /* Having dealt with a directive, break the loop */
789 /* If we have handled a conditional directive, continue with the next
790 physical line. Otherwise, fall through. */
792 if (i < cond_list_size) continue;
795 /* If the conditional state is not 0 (actively using these lines), ignore
798 if (cstate != 0) continue; /* Conditional skip */
800 /* Handle .include lines - these are also physical lines. */
802 if (Ustrncmp(ss, ".include", 8) == 0 &&
804 (Ustrncmp(ss+8, "_if_exists", 10) == 0 && isspace(ss[18]))))
807 int include_if_exists = isspace(ss[8])? 0 : 10;
808 config_file_item *save;
811 ss += 9 + include_if_exists;
812 while (isspace(*ss)) ss++;
813 t = ss + Ustrlen(ss);
814 while (t > ss && isspace(t[-1])) t--;
815 if (*ss == '\"' && t[-1] == '\"')
823 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, ".include specifies a non-"
824 "absolute path \"%s\"", ss);
826 if (include_if_exists != 0 && (Ustat(ss, &statbuf) != 0)) continue;
828 save = store_get(sizeof(config_file_item));
829 save->next = config_file_stack;
830 config_file_stack = save;
831 save->file = config_file;
832 save->filename = config_filename;
833 save->lineno = config_lineno;
835 config_file = Ufopen(ss, "rb");
836 if (config_file == NULL)
837 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to open included "
838 "configuration file %s", ss);
839 config_filename = string_copy(ss);
844 /* If this is the start of the logical line, remember where the non-blank
845 data starts. Otherwise shuffle down continuation lines to remove leading
849 startoffset = ss - big_buffer;
852 s = big_buffer + len;
855 memmove(s, ss, (newlen - len) - (ss - s) + 1);
860 /* Accept the new addition to the line. Remove trailing white space. */
863 while (len > 0 && isspace(big_buffer[len-1])) len--;
866 /* We are done if the line does not end in backslash and contains some data.
867 Empty logical lines are ignored. For continuations, remove the backslash and
868 go round the loop to read the continuation line. */
872 if (big_buffer[len-1] != '\\') break; /* End of logical line */
873 big_buffer[--len] = 0; /* Remove backslash */
875 } /* Loop for reading multiple physical lines */
877 /* We now have a logical line. Test for the end of a configuration section (or,
878 more accurately, for the start of the next section). Place the name of the next
879 section in next_section, and return NULL. If the name given is longer than
880 next_section, truncate it. It will be unrecognized later, because all the known
881 section names do fit. Leave space for pluralizing. */
883 s = big_buffer + startoffset; /* First non-space character */
884 if (strncmpic(s, US"begin ", 6) == 0)
887 while (isspace(*s)) s++;
888 if (big_buffer + len - s > sizeof(next_section) - 2)
889 s[sizeof(next_section) - 2] = 0;
890 Ustrcpy(next_section, s);
894 /* Return the first non-blank character. */
901 /*************************************************
903 *************************************************/
905 /* The yield is the pointer to the next uschar. Names longer than the
906 output space are silently truncated. This function is also used from acl.c when
910 name where to put the name
914 Returns: new input pointer
918 readconf_readname(uschar *name, int len, uschar *s)
921 while (isspace(*s)) s++;
924 while (isalnum(*s) || *s == '_')
926 if (p < len-1) name[p++] = *s;
931 while (isspace(*s)) s++;
938 /*************************************************
939 * Read a time value *
940 *************************************************/
942 /* This function is also called from outside, to read argument
943 time values. The format of a time value is:
945 [<n>w][<n>d][<n>h][<n>m][<n>s]
947 as long as at least one is present. If a format error is encountered,
948 return a negative value. The value must be terminated by the given
953 terminator required terminating character
954 return_msec if TRUE, allow fractional seconds and return milliseconds
956 Returns: the time value, or -1 on syntax error
957 value is seconds if return_msec is FALSE
958 value is milliseconds if return_msec is TRUE
962 readconf_readtime(uschar *s, int terminator, BOOL return_msec)
970 if (!isdigit(*s)) return -1;
971 (void)sscanf(CS s, "%d%n", &value, &count);
976 case 'w': value *= 7;
977 case 'd': value *= 24;
978 case 'h': value *= 60;
979 case 'm': value *= 60;
984 if (!return_msec) return -1;
985 (void)sscanf(CS s, "%lf%n", &fraction, &count);
987 if (*s++ != 's') return -1;
988 yield += (int)(fraction * 1000.0);
994 if (return_msec) value *= 1000;
996 if (*s == terminator) return yield;
998 /* Control never reaches here. */
1003 /*************************************************
1004 * Read a fixed point value *
1005 *************************************************/
1007 /* The value is returned *1000
1011 terminator required terminator
1013 Returns: the value, or -1 on error
1017 readconf_readfixed(uschar *s, int terminator)
1021 if (!isdigit(*s)) return -1;
1022 (void)sscanf(CS s, "%d%n", &value, &count);
1024 yield = value * 1000;
1028 while (isdigit((*(++s))))
1030 yield += (*s - '0') * m;
1035 return (*s == terminator)? yield : (-1);
1040 /*************************************************
1041 * Find option in list *
1042 *************************************************/
1044 /* The lists are always in order, so binary chop can be used.
1047 name the option name to search for
1048 ol the first entry in the option list
1049 last one more than the offset of the last entry in the option list
1051 Returns: pointer to an option entry, or NULL if not found
1055 find_option(uschar *name, optionlist *ol, int last)
1058 while (last > first)
1060 int middle = (first + last)/2;
1061 int c = Ustrcmp(name, ol[middle].name);
1062 if (c == 0) return ol + middle;
1063 else if (c > 0) first = middle + 1;
1071 /*************************************************
1072 * Find a set flag in option list *
1073 *************************************************/
1075 /* Because some versions of Unix make no restrictions on the values of uids and
1076 gids (even negative ones), we cannot represent "unset" by a special value.
1077 There is therefore a separate boolean variable for each one indicating whether
1078 a value is set or not. This function returns a pointer to the boolean, given
1079 the original option name. It is a major disaster if the flag cannot be found.
1082 name the name of the uid or gid option
1083 oltop points to the start of the relevant option list
1084 last one more than the offset of the last item in the option list
1085 data_block NULL when reading main options => data values in the option
1086 list are absolute addresses; otherwise they are byte offsets
1087 in data_block (used for driver options)
1089 Returns: a pointer to the boolean flag.
1093 get_set_flag(uschar *name, optionlist *oltop, int last, void *data_block)
1097 sprintf(CS name2, "*set_%.50s", name);
1098 ol = find_option(name2, oltop, last);
1099 if (ol == NULL) log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1100 "Exim internal error: missing set flag for %s", name);
1101 return (data_block == NULL)? (BOOL *)(ol->value) :
1102 (BOOL *)((uschar *)data_block + (long int)(ol->value));
1108 /*************************************************
1109 * Output extra characters message and die *
1110 *************************************************/
1112 /* Called when an option line has junk on the end. Sometimes this is because
1113 the sysadmin thinks comments are permitted.
1116 s points to the extra characters
1117 t1..t3 strings to insert in the log message
1119 Returns: doesn't return; dies
1123 extra_chars_error(uschar *s, uschar *t1, uschar *t2, uschar *t3)
1125 uschar *comment = US"";
1126 if (*s == '#') comment = US" (# is comment only at line start)";
1127 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1128 "extra characters follow %s%s%s%s", t1, t2, t3, comment);
1133 /*************************************************
1134 * Read rewrite information *
1135 *************************************************/
1137 /* Each line of rewrite information contains:
1139 . A complete address in the form user@domain, possibly with
1140 leading * for each part; or alternatively, a regex.
1142 . A replacement string (which will be expanded).
1144 . An optional sequence of one-letter flags, indicating which
1145 headers etc. to apply this rule to.
1147 All this is decoded and placed into a control block. The OR of the flags is
1148 maintained in a common word.
1151 p points to the string that makes up the rule
1152 existflags points to the overall flag word
1153 isglobal TRUE if reading global rewrite rules
1155 Returns: the control block for the parsed rule.
1158 static rewrite_rule *
1159 readconf_one_rewrite(uschar *p, int *existflags, BOOL isglobal)
1161 rewrite_rule *next = store_get(sizeof(rewrite_rule));
1164 next->key = string_dequote(&p);
1166 while (isspace(*p)) p++;
1168 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1169 "missing rewrite replacement string");
1172 next->replacement = string_dequote(&p);
1174 while (*p != 0) switch (*p++)
1176 case ' ': case '\t': break;
1178 case 'q': next->flags |= rewrite_quit; break;
1179 case 'w': next->flags |= rewrite_whole; break;
1181 case 'h': next->flags |= rewrite_all_headers; break;
1182 case 's': next->flags |= rewrite_sender; break;
1183 case 'f': next->flags |= rewrite_from; break;
1184 case 't': next->flags |= rewrite_to; break;
1185 case 'c': next->flags |= rewrite_cc; break;
1186 case 'b': next->flags |= rewrite_bcc; break;
1187 case 'r': next->flags |= rewrite_replyto; break;
1189 case 'E': next->flags |= rewrite_all_envelope; break;
1190 case 'F': next->flags |= rewrite_envfrom; break;
1191 case 'T': next->flags |= rewrite_envto; break;
1193 case 'Q': next->flags |= rewrite_qualify; break;
1194 case 'R': next->flags |= rewrite_repeat; break;
1197 next->flags |= rewrite_smtp;
1198 if (next->key[0] != '^' && Ustrncmp(next->key, "\\N^", 3) != 0)
1199 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1200 "rewrite rule has the S flag but is not a regular expression");
1204 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1205 "unknown rewrite flag character '%c' "
1206 "(could be missing quotes round replacement item)", p[-1]);
1210 /* If no action flags are set, set all the "normal" rewrites. */
1212 if ((next->flags & (rewrite_all | rewrite_smtp)) == 0)
1213 next->flags |= isglobal? rewrite_all : rewrite_all_headers;
1215 /* Remember which exist, for optimization, and return the rule */
1217 *existflags |= next->flags;
1224 /*************************************************
1225 * Read global rewrite information *
1226 *************************************************/
1228 /* Each line is a single rewrite rule; it is parsed into a control block
1229 by readconf_one_rewrite(), and its flags are ORed into the global flag
1230 word rewrite_existflags. */
1233 readconf_rewrites(void)
1235 rewrite_rule **chain = &global_rewrite_rules;
1238 while ((p = get_config_line()) != NULL)
1240 rewrite_rule *next = readconf_one_rewrite(p, &rewrite_existflags, TRUE);
1242 chain = &(next->next);
1248 /*************************************************
1250 *************************************************/
1252 /* Strings are read into the normal store pool. As long we aren't too
1253 near the end of the current block, the string will just use what is necessary
1254 on the top of the stacking pool, because string_cat() uses the extension
1258 s the rest of the input line
1259 name the option name (for errors)
1261 Returns: pointer to the string
1265 read_string(uschar *s, uschar *name)
1270 if (*s != '\"') return string_copy(s);
1273 yield = string_dequote(&s);
1275 if (s == ss+1 || s[-1] != '\"')
1276 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1277 "missing quote at end of string value for %s", name);
1279 if (*s != 0) extra_chars_error(s, US"string value for ", name, US"");
1285 /*************************************************
1286 * Handle option line *
1287 *************************************************/
1289 /* This function is called from several places to process a line containing the
1290 setting of an option. The first argument is the line to be decoded; it has been
1291 checked not to be empty and not to start with '#'. Trailing newlines and white
1292 space have been removed. The second argument is a pointer to the list of
1293 variable names that are to be recognized, together with their types and
1294 locations, and the third argument gives the number of entries in the list.
1296 The fourth argument is a pointer to a data block. If it is NULL, then the data
1297 values in the options list are absolute addresses. Otherwise, they are byte
1298 offsets in the data block.
1300 String option data may continue onto several lines; this function reads further
1301 data from config_file if necessary.
1303 The yield of this function is normally zero. If a string continues onto
1304 multiple lines, then the data value is permitted to be followed by a comma
1305 or a semicolon (for use in drivers) and the yield is that character.
1308 buffer contains the configuration line to be handled
1309 oltop points to the start of the relevant option list
1310 last one more than the offset of the last item in the option list
1311 data_block NULL when reading main options => data values in the option
1312 list are absolute addresses; otherwise they are byte offsets
1313 in data_block when they have opt_public set; otherwise
1314 they are byte offsets in data_block->options_block.
1315 unknown_txt format string to use in panic message for unknown option;
1316 must contain %s for option name
1317 if given as NULL, don't panic on unknown option
1319 Returns: TRUE if an option was read successfully,
1320 FALSE false for an unknown option if unknown_txt == NULL,
1321 otherwise panic and die on an unknown option
1325 readconf_handle_option(uschar *buffer, optionlist *oltop, int last,
1326 void *data_block, uschar *unknown_txt)
1330 int n, count, type, value;
1334 BOOL boolvalue = TRUE;
1335 BOOL freesptr = TRUE;
1336 optionlist *ol, *ol2;
1340 uschar *inttype = US"";
1346 /* There may be leading spaces; thereafter, we expect an option name starting
1349 while (isspace(*s)) s++;
1351 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option setting expected: %s", s);
1353 /* Read the name of the option, and skip any subsequent white space. If
1354 it turns out that what we read was "hide", set the flag indicating that
1355 this is a secure option, and loop to read the next word. */
1357 for (n = 0; n < 2; n++)
1359 while (isalnum(*s) || *s == '_')
1361 if (ptr < sizeof(name)-1) name[ptr++] = *s;
1365 while (isspace(*s)) s++;
1366 if (Ustrcmp(name, "hide") != 0) break;
1367 issecure = opt_secure;
1371 /* Deal with "no_" or "not_" here for booleans */
1373 if (Ustrncmp(name, "no_", 3) == 0)
1379 if (Ustrncmp(name, "not_", 4) == 0)
1385 /* Search the list for the given name. A non-existent name, or an option that
1386 is set twice, is a disaster. */
1388 ol = find_option(name + offset, oltop, last);
1392 if (unknown_txt == NULL) return FALSE;
1393 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, CS unknown_txt, name);
1396 if ((ol->type & opt_set) != 0)
1398 uschar *mname = name;
1399 if (Ustrncmp(mname, "no_", 3) == 0) mname += 3;
1400 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1401 "\"%s\" option set for the second time", mname);
1404 ol->type |= opt_set | issecure;
1405 type = ol->type & opt_mask;
1407 /* Types with data values must be followed by '='; the "no[t]_" prefix
1408 applies only to boolean values. */
1410 if (type < opt_bool || type > opt_bool_last)
1413 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1414 "negation prefix applied to a non-boolean option");
1416 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1417 "unexpected end of line (data missing) after %s", name);
1419 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing \"=\" after %s", name);
1422 /* If a boolean wasn't preceded by "no[t]_" it can be followed by = and
1423 true/false/yes/no, or, in the case of opt_expanded_bool, a general string that
1424 ultimately expands to one of those values. */
1426 else if (*s != 0 && (offset != 0 || *s != '='))
1427 extra_chars_error(s, US"boolean option ", name, US"");
1429 /* Skip white space after = */
1431 if (*s == '=') while (isspace((*(++s))));
1433 /* If there is a data block and the opt_public flag is not set, change
1434 the data block pointer to the private options block. */
1436 if (data_block != NULL && (ol->type & opt_public) == 0)
1437 data_block = (void *)(((driver_instance *)data_block)->options_block);
1439 /* Now get the data according to the type. */
1443 /* If a string value is not enclosed in quotes, it consists of
1444 the rest of the current line, verbatim. Otherwise, string escapes
1447 A transport is specified as a string, which is then looked up in the
1448 list of transports. A search type is specified as one of a number of
1451 A set or rewrite rules for a driver is specified as a string, which is
1452 then parsed into a suitable chain of control blocks.
1454 Uids and gids are specified as strings which are then looked up in the
1455 passwd file. Lists of uids and gids are similarly specified as colon-
1456 separated strings. */
1461 case opt_expand_uid:
1462 case opt_expand_gid:
1467 reset_point = sptr = read_string(s, name);
1469 /* Having read a string, we now have several different ways of using it,
1470 depending on the data type, so do another switch. If keeping the actual
1471 string is not required (because it is interpreted), freesptr is set TRUE,
1472 and at the end we reset the pool. */
1476 /* If this was a string, set the variable to point to the new string,
1477 and set the flag so its store isn't reclaimed. If it was a list of rewrite
1478 rules, we still keep the string (for printing), and parse the rules into a
1479 control block and flags word. */
1483 if (data_block == NULL)
1484 *((uschar **)(ol->value)) = sptr;
1486 *((uschar **)((uschar *)data_block + (long int)(ol->value))) = sptr;
1488 if (type == opt_rewrite)
1493 rewrite_rule **chain;
1496 sprintf(CS name2, "*%.50s_rules", name);
1497 ol2 = find_option(name2, oltop, last);
1498 sprintf(CS name2, "*%.50s_flags", name);
1499 ol3 = find_option(name2, oltop, last);
1501 if (ol2 == NULL || ol3 == NULL)
1502 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1503 "rewrite rules not available for driver");
1505 if (data_block == NULL)
1507 chain = (rewrite_rule **)(ol2->value);
1508 flagptr = (int *)(ol3->value);
1512 chain = (rewrite_rule **)((uschar *)data_block + (long int)(ol2->value));
1513 flagptr = (int *)((uschar *)data_block + (long int)(ol3->value));
1516 while ((p = string_nextinlist(&sptr, &sep, big_buffer, BIG_BUFFER_SIZE))
1519 rewrite_rule *next = readconf_one_rewrite(p, flagptr, FALSE);
1521 chain = &(next->next);
1524 if ((*flagptr & (rewrite_all_envelope | rewrite_smtp)) != 0)
1525 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "rewrite rule specifies a "
1526 "non-header rewrite - not allowed at transport time -");
1530 /* If it was an expanded uid, see if there is any expansion to be
1531 done by checking for the presence of a $ character. If there is, save it
1532 in the corresponding *expand_user option field. Otherwise, fall through
1533 to treat it as a fixed uid. Ensure mutual exclusivity of the two kinds
1536 case opt_expand_uid:
1537 sprintf(CS name2, "*expand_%.50s", name);
1538 ol2 = find_option(name2, oltop, last);
1541 uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
1543 if (data_block == NULL)
1544 *((uschar **)(ol2->value)) = ss;
1546 *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = ss;
1550 *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1556 /* Look up a fixed uid, and also make use of the corresponding gid
1557 if a passwd entry is returned and the gid has not been set. */
1560 if (!route_finduser(sptr, &pw, &uid))
1561 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found", sptr);
1562 if (data_block == NULL)
1563 *((uid_t *)(ol->value)) = uid;
1565 *((uid_t *)((uschar *)data_block + (long int)(ol->value))) = uid;
1567 /* Set the flag indicating a fixed value is set */
1569 *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1571 /* Handle matching gid if we have a passwd entry: done by finding the
1572 same name with terminating "user" changed to "group"; if not found,
1573 ignore. Also ignore if the value is already set. */
1575 if (pw == NULL) break;
1576 Ustrcpy(name+Ustrlen(name)-4, "group");
1577 ol2 = find_option(name, oltop, last);
1578 if (ol2 != NULL && ((ol2->type & opt_mask) == opt_gid ||
1579 (ol2->type & opt_mask) == opt_expand_gid))
1581 BOOL *set_flag = get_set_flag(name, oltop, last, data_block);
1584 if (data_block == NULL)
1585 *((gid_t *)(ol2->value)) = pw->pw_gid;
1587 *((gid_t *)((uschar *)data_block + (long int)(ol2->value))) = pw->pw_gid;
1593 /* If it was an expanded gid, see if there is any expansion to be
1594 done by checking for the presence of a $ character. If there is, save it
1595 in the corresponding *expand_user option field. Otherwise, fall through
1596 to treat it as a fixed gid. Ensure mutual exclusivity of the two kinds
1599 case opt_expand_gid:
1600 sprintf(CS name2, "*expand_%.50s", name);
1601 ol2 = find_option(name2, oltop, last);
1604 uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
1606 if (data_block == NULL)
1607 *((uschar **)(ol2->value)) = ss;
1609 *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = ss;
1613 *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1619 /* Handle freestanding gid */
1622 if (!route_findgroup(sptr, &gid))
1623 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found", sptr);
1624 if (data_block == NULL)
1625 *((gid_t *)(ol->value)) = gid;
1627 *((gid_t *)((uschar *)data_block + (long int)(ol->value))) = gid;
1628 *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1631 /* If it was a uid list, look up each individual entry, and build
1632 a vector of uids, with a count in the first element. Put the vector
1633 in malloc store so we can free the string. (We are reading into
1634 permanent store already.) */
1642 uschar *op = expand_string (sptr);
1645 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
1646 name, expand_string_message);
1649 if (*p != 0) count++;
1650 while (*p != 0) if (*p++ == ':' && *p != 0) count++;
1651 list = store_malloc(count*sizeof(uid_t));
1652 list[ptr++] = (uid_t)(count - 1);
1654 if (data_block == NULL)
1655 *((uid_t **)(ol->value)) = list;
1657 *((uid_t **)((uschar *)data_block + (long int)(ol->value))) = list;
1663 (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
1664 if (!route_finduser(big_buffer, NULL, &uid))
1665 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found",
1672 /* If it was a gid list, look up each individual entry, and build
1673 a vector of gids, with a count in the first element. Put the vector
1674 in malloc store so we can free the string. (We are reading into permanent
1683 uschar *op = expand_string (sptr);
1686 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
1687 name, expand_string_message);
1690 if (*p != 0) count++;
1691 while (*p != 0) if (*p++ == ':' && *p != 0) count++;
1692 list = store_malloc(count*sizeof(gid_t));
1693 list[ptr++] = (gid_t)(count - 1);
1695 if (data_block == NULL)
1696 *((gid_t **)(ol->value)) = list;
1698 *((gid_t **)((uschar *)data_block + (long int)(ol->value))) = list;
1704 (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
1705 if (!route_findgroup(big_buffer, &gid))
1706 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found",
1714 /* Release store if the value of the string doesn't need to be kept. */
1716 if (freesptr) store_reset(reset_point);
1719 /* Expanded boolean: if no characters follow, or if there are no dollar
1720 characters, this is a fixed-valued boolean, and we fall through. Otherwise,
1721 save the string for later expansion in the alternate place. */
1723 case opt_expand_bool:
1724 if (*s != 0 && Ustrchr(s, '$') != 0)
1726 sprintf(CS name2, "*expand_%.50s", name);
1727 ol2 = find_option(name2, oltop, last);
1730 reset_point = sptr = read_string(s, name);
1731 if (data_block == NULL)
1732 *((uschar **)(ol2->value)) = sptr;
1734 *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = sptr;
1741 /* Boolean: if no characters follow, the value is boolvalue. Otherwise
1742 look for yes/not/true/false. Some booleans are stored in a single bit in
1743 a single int. There's a special fudge for verify settings; without a suffix
1744 they set both xx_sender and xx_recipient. The table points to the sender
1745 value; search subsequently for the recipient. There's another special case:
1746 opt_bool_set also notes when a boolean has been set. */
1750 case opt_bool_verify:
1754 s = readconf_readname(name2, 64, s);
1755 if (strcmpic(name2, US"true") == 0 || strcmpic(name2, US"yes") == 0)
1757 else if (strcmpic(name2, US"false") == 0 || strcmpic(name2, US"no") == 0)
1759 else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1760 "\"%s\" is not a valid value for the \"%s\" option", name2, name);
1761 if (*s != 0) extra_chars_error(s, string_sprintf("\"%s\" ", name2),
1762 US"for boolean option ", name);
1765 /* Handle single-bit type. */
1767 if (type == opt_bit)
1769 int bit = 1 << ((ol->type >> 16) & 31);
1770 int *ptr = (data_block == NULL)?
1771 (int *)(ol->value) :
1772 (int *)((uschar *)data_block + (long int)ol->value);
1773 if (boolvalue) *ptr |= bit; else *ptr &= ~bit;
1777 /* Handle full BOOL types */
1779 if (data_block == NULL)
1780 *((BOOL *)(ol->value)) = boolvalue;
1782 *((BOOL *)((uschar *)data_block + (long int)(ol->value))) = boolvalue;
1786 if (type == opt_bool_verify)
1788 sprintf(CS name2, "%.50s_recipient", name + offset);
1789 ol2 = find_option(name2, oltop, last);
1792 if (data_block == NULL)
1793 *((BOOL *)(ol2->value)) = boolvalue;
1795 *((BOOL *)((uschar *)data_block + (long int)(ol2->value))) = boolvalue;
1799 /* Note that opt_bool_set type is set, if there is somewhere to do so */
1801 else if (type == opt_bool_set)
1803 sprintf(CS name2, "*set_%.50s", name + offset);
1804 ol2 = find_option(name2, oltop, last);
1807 if (data_block == NULL)
1808 *((BOOL *)(ol2->value)) = TRUE;
1810 *((BOOL *)((uschar *)data_block + (long int)(ol2->value))) = TRUE;
1819 inttype = US"octal ";
1821 /* Integer: a simple(ish) case; allow octal and hex formats, and
1822 suffixes K and M. The different types affect output, not input. */
1829 value = strtol(CS s, CSS &endptr, intbase);
1832 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
1835 if (errno != ERANGE)
1837 if (tolower(*endptr) == 'k')
1839 if (value > INT_MAX/1024 || value < INT_MIN/1024) errno = ERANGE;
1843 else if (tolower(*endptr) == 'm')
1845 if (value > INT_MAX/(1024*1024) || value < INT_MIN/(1024*1024))
1847 else value *= 1024*1024;
1852 if (errno == ERANGE) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1853 "absolute value of integer \"%s\" is too large (overflow)", s);
1855 while (isspace(*endptr)) endptr++;
1857 extra_chars_error(endptr, inttype, US"integer value for ", name);
1860 if (data_block == NULL)
1861 *((int *)(ol->value)) = value;
1863 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
1866 /* Integer held in K: again, allow octal and hex formats, and suffixes K and
1873 value = strtol(CS s, CSS &endptr, intbase);
1876 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
1879 if (errno != ERANGE)
1881 if (tolower(*endptr) == 'm')
1883 if (value > INT_MAX/1024 || value < INT_MIN/1024) errno = ERANGE;
1887 else if (tolower(*endptr) == 'k')
1893 value = (value + 512)/1024;
1897 if (errno == ERANGE) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1898 "absolute value of integer \"%s\" is too large (overflow)", s);
1900 while (isspace(*endptr)) endptr++;
1902 extra_chars_error(endptr, inttype, US"integer value for ", name);
1905 if (data_block == NULL)
1906 *((int *)(ol->value)) = value;
1908 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
1911 /* Fixed-point number: held to 3 decimal places. */
1914 if (sscanf(CS s, "%d%n", &value, &count) != 1)
1915 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1916 "fixed-point number expected for %s", name);
1918 if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1919 "integer \"%s\" is too large (overflow)", s);
1923 if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1924 "integer \"%s\" is too large (overflow)", s);
1926 if (s[count] == '.')
1929 while (isdigit(s[++count]))
1931 value += (s[count] - '0') * d;
1936 while (isspace(s[count])) count++;
1939 extra_chars_error(s+count, US"fixed-point value for ", name, US"");
1941 if (data_block == NULL)
1942 *((int *)(ol->value)) = value;
1944 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
1947 /* There's a special routine to read time values. */
1950 value = readconf_readtime(s, 0, FALSE);
1952 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
1954 if (data_block == NULL)
1955 *((int *)(ol->value)) = value;
1957 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
1960 /* A time list is a list of colon-separated times, with the first
1961 element holding the size of the list and the second the number of
1967 int *list = (data_block == NULL)?
1968 (int *)(ol->value) :
1969 (int *)((uschar *)data_block + (long int)(ol->value));
1971 if (*s != 0) for (count = 1; count <= list[0] - 2; count++)
1974 uschar *snext = Ustrchr(s, ':');
1978 while (ss > s && isspace(ss[-1])) ss--;
1981 value = readconf_readtime(s, terminator, FALSE);
1983 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
1985 if (count > 1 && value <= list[count])
1986 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1987 "time value out of order for %s", name);
1988 list[count+1] = value;
1989 if (snext == NULL) break;
1991 while (isspace(*s)) s++;
1994 if (count > list[0] - 2)
1995 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many time values for %s",
1997 if (count > 0 && list[2] == 0) count = 0;
2009 /*************************************************
2010 * Print a time value *
2011 *************************************************/
2014 Argument: a time value in seconds
2015 Returns: pointer to a fixed buffer containing the time as a string,
2016 in readconf_readtime() format
2020 readconf_printtime(int t)
2023 uschar *p = time_buffer;
2040 if (w > 0) { sprintf(CS p, "%dw", w); while (*p) p++; }
2041 if (d > 0) { sprintf(CS p, "%dd", d); while (*p) p++; }
2042 if (h > 0) { sprintf(CS p, "%dh", h); while (*p) p++; }
2043 if (m > 0) { sprintf(CS p, "%dm", m); while (*p) p++; }
2044 if (s > 0 || p == time_buffer) sprintf(CS p, "%ds", s);
2051 /*************************************************
2052 * Print an individual option value *
2053 *************************************************/
2055 /* This is used by the -bP option, so prints to the standard output.
2056 The entire options list is passed in as an argument, because some options come
2057 in pairs - typically uid/gid settings, which can either be explicit numerical
2058 values, or strings to be expanded later. If the numerical value is unset,
2059 search for "*expand_<name>" to see if there is a string equivalent.
2062 ol option entry, or NULL for an unknown option
2064 options_block NULL for main configuration options; otherwise points to
2065 a driver block; if the option doesn't have opt_public
2066 set, then options_block->options_block is where the item
2068 oltop points to the option list in which ol exists
2069 last one more than the offset of the last entry in optop
2075 print_ol(optionlist *ol, uschar *name, void *options_block,
2076 optionlist *oltop, int last)
2089 printf("%s is not a known option\n", name);
2093 /* Non-admin callers cannot see options that have been flagged secure by the
2096 if (!admin_user && (ol->type & opt_secure) != 0)
2098 printf("%s = <value not displayable>\n", name);
2102 /* Else show the value of the option */
2105 if (options_block != NULL)
2107 if ((ol->type & opt_public) == 0)
2108 options_block = (void *)(((driver_instance *)options_block)->options_block);
2109 value = (void *)((uschar *)options_block + (long int)value);
2112 switch(ol->type & opt_mask)
2115 case opt_rewrite: /* Show the text value */
2116 s = *((uschar **)value);
2117 printf("%s = %s\n", name, (s == NULL)? US"" : string_printing2(s, FALSE));
2121 printf("%s = %d\n", name, *((int *)value));
2126 int x = *((int *)value);
2127 if (x != 0 && (x & 1023) == 0)
2131 if ((x & 1023) == 0)
2136 printf("%s = %d%c\n", name, x, c);
2138 else printf("%s = %d\n", name, x);
2144 int x = *((int *)value);
2145 if (x == 0) printf("%s = 0\n", name);
2146 else if ((x & 1023) == 0) printf("%s = %dM\n", name, x >> 10);
2147 else printf("%s = %dK\n", name, x);
2152 printf("%s = %#o\n", name, *((int *)value));
2155 /* Can be negative only when "unset", in which case integer */
2159 int x = *((int *)value);
2162 if (x < 0) printf("%s =\n", name); else
2164 printf("%s = %d.", name, x/1000);
2177 /* If the numerical value is unset, try for the string value */
2179 case opt_expand_uid:
2180 if (! *get_set_flag(name, oltop, last, options_block))
2182 sprintf(CS name2, "*expand_%.50s", name);
2183 ol2 = find_option(name2, oltop, last);
2186 void *value2 = ol2->value;
2187 if (options_block != NULL)
2188 value2 = (void *)((uschar *)options_block + (long int)value2);
2189 s = *((uschar **)value2);
2190 printf("%s = %s\n", name, (s == NULL)? US"" : string_printing(s));
2195 /* Else fall through */
2198 if (! *get_set_flag(name, oltop, last, options_block))
2199 printf("%s =\n", name);
2202 pw = getpwuid(*((uid_t *)value));
2204 printf("%s = %ld\n", name, (long int)(*((uid_t *)value)));
2205 else printf("%s = %s\n", name, pw->pw_name);
2209 /* If the numerical value is unset, try for the string value */
2211 case opt_expand_gid:
2212 if (! *get_set_flag(name, oltop, last, options_block))
2214 sprintf(CS name2, "*expand_%.50s", name);
2215 ol2 = find_option(name2, oltop, last);
2216 if (ol2 != NULL && (ol2->type & opt_mask) == opt_stringptr)
2218 void *value2 = ol2->value;
2219 if (options_block != NULL)
2220 value2 = (void *)((uschar *)options_block + (long int)value2);
2221 s = *((uschar **)value2);
2222 printf("%s = %s\n", name, (s == NULL)? US"" : string_printing(s));
2227 /* Else fall through */
2230 if (! *get_set_flag(name, oltop, last, options_block))
2231 printf("%s =\n", name);
2234 gr = getgrgid(*((int *)value));
2236 printf("%s = %ld\n", name, (long int)(*((int *)value)));
2237 else printf("%s = %s\n", name, gr->gr_name);
2242 uidlist = *((uid_t **)value);
2243 printf("%s =", name);
2244 if (uidlist != NULL)
2248 for (i = 1; i <= (int)(uidlist[0]); i++)
2250 uschar *name = NULL;
2251 pw = getpwuid(uidlist[i]);
2252 if (pw != NULL) name = US pw->pw_name;
2253 if (name != NULL) printf("%c%s", sep, name);
2254 else printf("%c%ld", sep, (long int)(uidlist[i]));
2262 gidlist = *((gid_t **)value);
2263 printf("%s =", name);
2264 if (gidlist != NULL)
2268 for (i = 1; i <= (int)(gidlist[0]); i++)
2270 uschar *name = NULL;
2271 gr = getgrgid(gidlist[i]);
2272 if (gr != NULL) name = US gr->gr_name;
2273 if (name != NULL) printf("%c%s", sep, name);
2274 else printf("%c%ld", sep, (long int)(gidlist[i]));
2282 printf("%s = %s\n", name, readconf_printtime(*((int *)value)));
2288 int *list = (int *)value;
2289 printf("%s = ", name);
2290 for (i = 0; i < list[1]; i++)
2291 printf("%s%s", (i == 0)? "" : ":", readconf_printtime(list[i+2]));
2297 printf("%s%s\n", ((*((int *)value)) & (1 << ((ol->type >> 16) & 31)))?
2301 case opt_expand_bool:
2302 sprintf(CS name2, "*expand_%.50s", name);
2303 ol2 = find_option(name2, oltop, last);
2304 if (ol2 != NULL && ol2->value != NULL)
2306 void *value2 = ol2->value;
2307 if (options_block != NULL)
2308 value2 = (void *)((uschar *)options_block + (long int)value2);
2309 s = *((uschar **)value2);
2312 printf("%s = %s\n", name, string_printing(s));
2315 /* s == NULL => string not set; fall through */
2321 case opt_bool_verify:
2323 printf("%s%s\n", (*((BOOL *)value))? "" : "no_", name);
2330 /*************************************************
2331 * Print value from main configuration *
2332 *************************************************/
2334 /* This function, called as a result of encountering the -bP option,
2335 causes the value of any main configuration variable to be output if the
2336 second argument is NULL. There are some special values:
2338 all print all main configuration options
2339 configure_file print the name of the configuration file
2340 routers print the routers' configurations
2341 transports print the transports' configuration
2342 authenticators print the authenticators' configuration
2343 router_list print a list of router names
2344 transport_list print a list of transport names
2345 authenticator_list print a list of authentication mechanism names
2346 +name print a named list item
2347 local_scan print the local_scan options
2349 If the second argument is not NULL, it must be one of "router", "transport", or
2350 "authenticator" in which case the first argument identifies the driver whose
2351 options are to be printed.
2354 name option name if type == NULL; else driver name
2355 type NULL or driver type name, as described above
2361 readconf_print(uschar *name, uschar *type)
2363 BOOL names_only = FALSE;
2365 optionlist *ol2 = NULL;
2366 driver_instance *d = NULL;
2376 static uschar *types[] = { US"address", US"domain", US"host",
2378 static tree_node **anchors[] = { &addresslist_anchor, &domainlist_anchor,
2379 &hostlist_anchor, &localpartlist_anchor };
2381 for (i = 0; i < 4; i++)
2383 t = tree_search(*(anchors[i]), name+1);
2387 printf("%slist %s = %s\n", types[i], name+1,
2388 ((namedlist_block *)(t->data.ptr))->string);
2393 printf("no address, domain, host, or local part list called \"%s\" "
2394 "exists\n", name+1);
2399 if (Ustrcmp(name, "configure_file") == 0)
2401 printf("%s\n", CS config_main_filename);
2405 if (Ustrcmp(name, "all") == 0)
2407 for (ol = optionlist_config;
2408 ol < optionlist_config + optionlist_config_size; ol++)
2410 if ((ol->type & opt_hidden) == 0)
2411 print_ol(ol, US ol->name, NULL, optionlist_config, optionlist_config_size);
2416 if (Ustrcmp(name, "local_scan") == 0)
2418 #ifndef LOCAL_SCAN_HAS_OPTIONS
2419 printf("local_scan() options are not supported\n");
2421 for (ol = local_scan_options;
2422 ol < local_scan_options + local_scan_options_count; ol++)
2424 print_ol(ol, US ol->name, NULL, local_scan_options,
2425 local_scan_options_count);
2431 if (Ustrcmp(name, "routers") == 0)
2436 else if (Ustrcmp(name, "transports") == 0)
2438 type = US"transport";
2442 else if (Ustrcmp(name, "authenticators") == 0)
2444 type = US"authenticator";
2448 else if (Ustrcmp(name, "authenticator_list") == 0)
2450 type = US"authenticator";
2455 else if (Ustrcmp(name, "router_list") == 0)
2461 else if (Ustrcmp(name, "transport_list") == 0)
2463 type = US"transport";
2469 print_ol(find_option(name, optionlist_config, optionlist_config_size),
2470 name, NULL, optionlist_config, optionlist_config_size);
2475 /* Handle the options for a router or transport. Skip options that are flagged
2476 as hidden. Some of these are options with names starting with '*', used for
2477 internal alternative representations of other options (which the printing
2478 function will sort out). Others are synonyms kept for backward compatibility.
2481 if (Ustrcmp(type, "router") == 0)
2483 d = (driver_instance *)routers;
2484 ol2 = optionlist_routers;
2485 size = optionlist_routers_size;
2487 else if (Ustrcmp(type, "transport") == 0)
2489 d = (driver_instance *)transports;
2490 ol2 = optionlist_transports;
2491 size = optionlist_transports_size;
2493 else if (Ustrcmp(type, "authenticator") == 0)
2495 d = (driver_instance *)auths;
2496 ol2 = optionlist_auths;
2497 size = optionlist_auths_size;
2502 for (; d != NULL; d = d->next) printf("%s\n", CS d->name);
2506 /* Either search for a given driver, or print all of them */
2508 for (; d != NULL; d = d->next)
2511 printf("\n%s %s:\n", d->name, type);
2512 else if (Ustrcmp(d->name, name) != 0) continue;
2514 for (ol = ol2; ol < ol2 + size; ol++)
2516 if ((ol->type & opt_hidden) == 0)
2517 print_ol(ol, US ol->name, d, ol2, size);
2520 for (ol = d->info->options;
2521 ol < d->info->options + *(d->info->options_count); ol++)
2523 if ((ol->type & opt_hidden) == 0)
2524 print_ol(ol, US ol->name, d, d->info->options, *(d->info->options_count));
2526 if (name != NULL) return;
2528 if (name != NULL) printf("%s %s not found\n", type, name);
2533 /*************************************************
2534 * Read a named list item *
2535 *************************************************/
2537 /* This function reads a name and a list (i.e. string). The name is used to
2538 save the list in a tree, sorted by its name. Each entry also has a number,
2539 which can be used for caching tests, but if the string contains any expansion
2540 items other than $key, the number is set negative to inhibit caching. This
2541 mechanism is used for domain, host, and address lists that are referenced by
2545 anchorp points to the tree anchor
2546 numberp points to the current number for this tree
2547 max the maximum number permitted
2548 s the text of the option line, starting immediately after the name
2550 tname the name of the list type, for messages
2556 read_named_list(tree_node **anchorp, int *numberp, int max, uschar *s,
2559 BOOL forcecache = FALSE;
2562 namedlist_block *nb = store_get(sizeof(namedlist_block));
2564 if (Ustrncmp(s, "_cache", 6) == 0)
2571 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unrecognized configuration line");
2573 if (*numberp >= max)
2574 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many named %ss (max is %d)\n",
2577 while (isspace(*s)) s++;
2579 while (isalnum(*s) || *s == '_') s++;
2580 t = store_get(sizeof(tree_node) + s-ss);
2581 Ustrncpy(t->name, ss, s-ss);
2583 while (isspace(*s)) s++;
2585 if (!tree_insertnode(anchorp, t))
2586 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2587 "duplicate name \"%s\" for a named %s", t->name, tname);
2590 nb->number = *numberp;
2593 if (*s++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2594 "missing '=' after \"%s\"", t->name);
2595 while (isspace(*s)) s++;
2596 nb->string = read_string(s, t->name);
2597 nb->cache_data = NULL;
2599 /* Check the string for any expansions; if any are found, mark this list
2600 uncacheable unless the user has explicited forced caching. */
2602 if (!forcecache && Ustrchr(nb->string, '$') != NULL) nb->number = -1;
2608 /*************************************************
2609 * Unpick data for a rate limit *
2610 *************************************************/
2612 /* This function is called to unpick smtp_ratelimit_{mail,rcpt} into four
2616 s string, in the form t,b,f,l
2617 where t is the threshold (integer)
2618 b is the initial delay (time)
2619 f is the multiplicative factor (fixed point)
2620 k is the maximum time (time)
2621 threshold where to store threshold
2622 base where to store base in milliseconds
2623 factor where to store factor in milliseconds
2624 limit where to store limit
2626 Returns: nothing (panics on error)
2630 unpick_ratelimit(uschar *s, int *threshold, int *base, double *factor,
2633 uschar bstring[16], lstring[16];
2635 if (sscanf(CS s, "%d, %15[0123456789smhdw.], %lf, %15s", threshold, bstring,
2636 factor, lstring) == 4)
2638 *base = readconf_readtime(bstring, 0, TRUE);
2639 *limit = readconf_readtime(lstring, 0, TRUE);
2640 if (*base >= 0 && *limit >= 0) return;
2642 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "malformed ratelimit data: %s", s);
2648 /*************************************************
2649 * Read main configuration options *
2650 *************************************************/
2652 /* This function is the first to be called for configuration reading. It
2653 opens the configuration file and reads general configuration settings until
2654 it reaches the end of the configuration section. The file is then left open so
2655 that the remaining configuration data can subsequently be read if needed for
2658 The configuration file must be owned either by root or exim, and be writeable
2659 only by root or uid/gid exim. The values for Exim's uid and gid can be changed
2660 in the config file, so the test is done on the compiled in values. A slight
2661 anomaly, to be carefully documented.
2663 The name of the configuration file is taken from a list that is included in the
2664 binary of Exim. It can be altered from the command line, but if that is done,
2665 root privilege is immediately withdrawn unless the caller is root or exim.
2666 The first file on the list that exists is used.
2668 For use on multiple systems that share file systems, first look for a
2669 configuration file whose name has the current node name on the end. If that is
2670 not found, try the generic name. For really contorted configurations, that run
2671 multiple Exims with different uid settings, first try adding the effective uid
2672 before the node name. These complications are going to waste resources on most
2673 systems. Therefore they are available only when requested by compile-time
2680 struct stat statbuf;
2681 uschar *s, *filename;
2682 uschar *list = config_main_filelist;
2684 /* Loop through the possible file names */
2686 while((filename = string_nextinlist(&list, &sep, big_buffer, big_buffer_size))
2689 /* Cut out all the fancy processing unless specifically wanted */
2691 #if defined(CONFIGURE_FILE_USE_NODE) || defined(CONFIGURE_FILE_USE_EUID)
2692 uschar *suffix = filename + Ustrlen(filename);
2694 /* Try for the node-specific file if a node name exists */
2696 #ifdef CONFIGURE_FILE_USE_NODE
2698 if (uname(&uts) >= 0)
2700 #ifdef CONFIGURE_FILE_USE_EUID
2701 sprintf(CS suffix, ".%ld.%.256s", (long int)original_euid, uts.nodename);
2702 config_file = Ufopen(filename, "rb");
2703 if (config_file == NULL)
2704 #endif /* CONFIGURE_FILE_USE_EUID */
2706 sprintf(CS suffix, ".%.256s", uts.nodename);
2707 config_file = Ufopen(filename, "rb");
2710 #endif /* CONFIGURE_FILE_USE_NODE */
2712 /* Otherwise, try the generic name, possibly with the euid added */
2714 #ifdef CONFIGURE_FILE_USE_EUID
2715 if (config_file == NULL)
2717 sprintf(CS suffix, ".%ld", (long int)original_euid);
2718 config_file = Ufopen(filename, "rb");
2720 #endif /* CONFIGURE_FILE_USE_EUID */
2722 /* Finally, try the unadorned name */
2724 if (config_file == NULL)
2727 config_file = Ufopen(filename, "rb");
2729 #else /* if neither defined */
2731 /* This is the common case when the fancy processing is not included. */
2733 config_file = Ufopen(filename, "rb");
2736 /* If the file does not exist, continue to try any others. For any other
2737 error, break out (and die). */
2739 if (config_file != NULL || errno != ENOENT) break;
2742 /* On success, save the name for verification; config_filename is used when
2743 logging configuration errors (it changes for .included files) whereas
2744 config_main_filename is the name shown by -bP. Failure to open a configuration
2745 file is a serious disaster. */
2747 if (config_file != NULL)
2749 config_filename = config_main_filename = string_copy(filename);
2753 if (filename == NULL)
2754 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "non-existent configuration file(s): "
2755 "%s", config_main_filelist);
2757 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", string_open_failed(errno,
2758 "configuration file %s", filename));
2761 /* Check the status of the file we have opened, unless it was specified on
2762 the command line, in which case privilege was given away at the start. */
2764 if (!config_changed)
2766 if (fstat(fileno(config_file), &statbuf) != 0)
2767 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to stat configuration file %s",
2770 if ((statbuf.st_uid != root_uid && /* owner not root */
2771 statbuf.st_uid != exim_uid /* owner not exim */
2772 #ifdef CONFIGURE_OWNER
2773 && statbuf.st_uid != config_uid /* owner not the special one */
2776 (statbuf.st_gid != exim_gid /* group not exim & */
2777 #ifdef CONFIGURE_GROUP
2778 && statbuf.st_gid != config_gid /* group not the special one */
2780 && (statbuf.st_mode & 020) != 0) || /* group writeable */
2782 ((statbuf.st_mode & 2) != 0)) /* world writeable */
2784 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Exim configuration file %s has the "
2785 "wrong owner, group, or mode", big_buffer);
2788 /* Process the main configuration settings. They all begin with a lower case
2789 letter. If we see something starting with an upper case letter, it is taken as
2790 a macro definition. */
2792 while ((s = get_config_line()) != NULL)
2794 if (isupper(s[0])) read_macro_assignment(s);
2796 else if (Ustrncmp(s, "domainlist", 10) == 0)
2797 read_named_list(&domainlist_anchor, &domainlist_count,
2798 MAX_NAMED_LIST, s+10, US"domain list");
2800 else if (Ustrncmp(s, "hostlist", 8) == 0)
2801 read_named_list(&hostlist_anchor, &hostlist_count,
2802 MAX_NAMED_LIST, s+8, US"host list");
2804 else if (Ustrncmp(s, US"addresslist", 11) == 0)
2805 read_named_list(&addresslist_anchor, &addresslist_count,
2806 MAX_NAMED_LIST, s+11, US"address list");
2808 else if (Ustrncmp(s, US"localpartlist", 13) == 0)
2809 read_named_list(&localpartlist_anchor, &localpartlist_count,
2810 MAX_NAMED_LIST, s+13, US"local part list");
2813 (void) readconf_handle_option(s, optionlist_config, optionlist_config_size,
2814 NULL, US"main option \"%s\" unknown");
2818 /* If local_sender_retain is set, local_from_check must be unset. */
2820 if (local_sender_retain && local_from_check)
2821 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "both local_from_check and "
2822 "local_sender_retain are set; this combination is not allowed");
2824 /* If the timezone string is empty, set it to NULL, implying no TZ variable
2827 if (timezone_string != NULL && *timezone_string == 0) timezone_string = NULL;
2829 /* The max retry interval must not be greater than 24 hours. */
2831 if (retry_interval_max > 24*60*60) retry_interval_max = 24*60*60;
2833 /* remote_max_parallel must be > 0 */
2835 if (remote_max_parallel <= 0) remote_max_parallel = 1;
2837 /* Save the configured setting of freeze_tell, so we can re-instate it at the
2838 start of a new SMTP message. */
2840 freeze_tell_config = freeze_tell;
2842 /* The primary host name may be required for expansion of spool_directory
2843 and log_file_path, so make sure it is set asap. It is obtained from uname(),
2844 but if that yields an unqualified value, make a FQDN by using gethostbyname to
2845 canonize it. Some people like upper case letters in their host names, so we
2846 don't force the case. */
2848 if (primary_hostname == NULL)
2852 if (uname(&uts) < 0)
2853 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "uname() failed to yield host name");
2854 hostname = US uts.nodename;
2856 if (Ustrchr(hostname, '.') == NULL)
2859 struct hostent *hostdata;
2862 if (!disable_ipv6 && (dns_ipv4_lookup == NULL ||
2863 match_isinlist(hostname, &dns_ipv4_lookup, 0, NULL, NULL, MCL_DOMAIN,
2873 #if HAVE_GETIPNODEBYNAME
2875 hostdata = getipnodebyname(CS hostname, af, 0, &error_num);
2877 hostdata = gethostbyname2(CS hostname, af);
2880 hostdata = gethostbyname(CS hostname);
2883 if (hostdata != NULL)
2885 hostname = US hostdata->h_name;
2889 if (af == AF_INET) break;
2894 primary_hostname = string_copy(hostname);
2897 /* Set up default value for smtp_active_hostname */
2899 smtp_active_hostname = primary_hostname;
2901 /* If spool_directory wasn't set in the build-time configuration, it must have
2902 got set above. Of course, writing to the log may not work if log_file_path is
2903 not set, but it will at least get to syslog or somewhere, with any luck. */
2905 if (*spool_directory == 0)
2906 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "spool_directory undefined: cannot "
2909 /* Expand the spool directory name; it may, for example, contain the primary
2910 host name. Same comment about failure. */
2912 s = expand_string(spool_directory);
2914 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand spool_directory "
2915 "\"%s\": %s", spool_directory, expand_string_message);
2916 spool_directory = s;
2918 /* Expand log_file_path, which must contain "%s" in any component that isn't
2919 the null string or "syslog". It is also allowed to contain one instance of %D.
2920 However, it must NOT contain % followed by anything else. */
2922 if (*log_file_path != 0)
2925 int sep = ':'; /* Fixed for log file path */
2926 s = expand_string(log_file_path);
2928 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand log_file_path "
2929 "\"%s\": %s", log_file_path, expand_string_message);
2932 while ((sss = string_nextinlist(&ss,&sep,big_buffer,big_buffer_size)) != NULL)
2935 if (sss[0] == 0 || Ustrcmp(sss, "syslog") == 0) continue;
2936 t = Ustrstr(sss, "%s");
2938 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" does not "
2939 "contain \"%%s\"", sss);
2941 t = Ustrchr(sss, '%');
2944 if (t[1] != 'D' || Ustrchr(t+2, '%') != NULL)
2945 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" contains "
2946 "unexpected \"%%\" character", s);
2953 /* Interpret syslog_facility into an integer argument for 'ident' param to
2954 openlog(). Default is LOG_MAIL set in globals.c. Allow the user to omit the
2957 if (syslog_facility_str != NULL)
2960 uschar *s = syslog_facility_str;
2962 if ((Ustrlen(syslog_facility_str) >= 4) &&
2963 (strncmpic(syslog_facility_str, US"log_", 4) == 0))
2966 for (i = 0; i < syslog_list_size; i++)
2968 if (strcmpic(s, syslog_list[i].name) == 0)
2970 syslog_facility = syslog_list[i].value;
2975 if (i >= syslog_list_size)
2977 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
2978 "failed to interpret syslog_facility \"%s\"", syslog_facility_str);
2982 /* Expand pid_file_path */
2984 if (*pid_file_path != 0)
2986 s = expand_string(pid_file_path);
2988 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand pid_file_path "
2989 "\"%s\": %s", pid_file_path, expand_string_message);
2993 /* Compile the regex for matching a UUCP-style "From_" line in an incoming
2996 regex_From = regex_must_compile(uucp_from_pattern, FALSE, TRUE);
2998 /* Unpick the SMTP rate limiting options, if set */
3000 if (smtp_ratelimit_mail != NULL)
3002 unpick_ratelimit(smtp_ratelimit_mail, &smtp_rlm_threshold,
3003 &smtp_rlm_base, &smtp_rlm_factor, &smtp_rlm_limit);
3006 if (smtp_ratelimit_rcpt != NULL)
3008 unpick_ratelimit(smtp_ratelimit_rcpt, &smtp_rlr_threshold,
3009 &smtp_rlr_base, &smtp_rlr_factor, &smtp_rlr_limit);
3012 /* The qualify domains default to the primary host name */
3014 if (qualify_domain_sender == NULL)
3015 qualify_domain_sender = primary_hostname;
3016 if (qualify_domain_recipient == NULL)
3017 qualify_domain_recipient = qualify_domain_sender;
3019 /* Setting system_filter_user in the configuration sets the gid as well if a
3020 name is given, but a numerical value does not. */
3022 if (system_filter_uid_set && !system_filter_gid_set)
3024 struct passwd *pw = getpwuid(system_filter_uid);
3026 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to look up uid %ld",
3027 (long int)system_filter_uid);
3028 system_filter_gid = pw->pw_gid;
3029 system_filter_gid_set = TRUE;
3032 /* If the errors_reply_to field is set, check that it is syntactically valid
3033 and ensure it contains a domain. */
3035 if (errors_reply_to != NULL)
3038 int start, end, domain;
3039 uschar *recipient = parse_extract_address(errors_reply_to, &errmess,
3040 &start, &end, &domain, FALSE);
3042 if (recipient == NULL)
3043 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3044 "error in errors_reply_to (%s): %s", errors_reply_to, errmess);
3047 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3048 "errors_reply_to (%s) does not contain a domain", errors_reply_to);
3051 /* If smtp_accept_queue or smtp_accept_max_per_host is set, then
3052 smtp_accept_max must also be set. */
3054 if (smtp_accept_max == 0 &&
3055 (smtp_accept_queue > 0 || smtp_accept_max_per_host != NULL))
3056 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3057 "smtp_accept_max must be set if smtp_accept_queue or "
3058 "smtp_accept_max_per_host is set");
3060 /* Set up the host number if anything is specified. It is an expanded string
3061 so that it can be computed from the host name, for example. We do this last
3062 so as to ensure that everything else is set up before the expansion. */
3064 if (host_number_string != NULL)
3067 uschar *s = expand_string(host_number_string);
3068 long int n = Ustrtol(s, &end, 0);
3069 while (isspace(*end)) end++;
3071 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3072 "localhost_number value is not a number: %s", s);
3073 if (n > LOCALHOST_MAX)
3074 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3075 "localhost_number is greater than the maximum allowed value (%d)",
3081 /* If tls_verify_hosts is set, tls_verify_certificates must also be set */
3083 if ((tls_verify_hosts != NULL || tls_try_verify_hosts != NULL) &&
3084 tls_verify_certificates == NULL)
3085 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3086 "tls_%sverify_hosts is set, but tls_verify_certificates is not set",
3087 (tls_verify_hosts != NULL)? "" : "try_");
3093 /*************************************************
3094 * Initialize one driver *
3095 *************************************************/
3097 /* This is called once the driver's generic options, if any, have been read.
3098 We can now find the driver, set up defaults for the private options, and
3099 unset any "set" bits in the private options table (which might have been
3100 set by another incarnation of the same driver).
3103 d pointer to driver instance block, with generic
3105 drivers_available vector of available drivers
3106 size_of_info size of each block in drivers_available
3107 class class of driver, for error message
3109 Returns: pointer to the driver info block
3112 static driver_info *
3113 init_driver(driver_instance *d, driver_info *drivers_available,
3114 int size_of_info, uschar *class)
3118 for (dd = drivers_available; dd->driver_name[0] != 0;
3119 dd = (driver_info *)(((uschar *)dd) + size_of_info))
3121 if (Ustrcmp(d->driver_name, dd->driver_name) == 0)
3124 int len = dd->options_len;
3126 d->options_block = store_get(len);
3127 memcpy(d->options_block, dd->options_block, len);
3128 for (i = 0; i < *(dd->options_count); i++)
3129 dd->options[i].type &= ~opt_set;
3134 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3135 "%s %s: cannot find %s driver \"%s\"", class, d->name, class, d->driver_name);
3137 return NULL; /* never obeyed */
3143 /*************************************************
3144 * Initialize driver list *
3145 *************************************************/
3147 /* This function is called for routers, transports, and authentication
3148 mechanisms. It reads the data from the current point in the configuration file
3149 up to the end of the section, and sets up a chain of instance blocks according
3150 to the file's contents. The file will already have been opened by a call to
3151 readconf_main, and must be left open for subsequent reading of further data.
3153 Any errors cause a panic crash. Note that the blocks with names driver_info and
3154 driver_instance must map the first portions of all the _info and _instance
3155 blocks for this shared code to work.
3158 class "router", "transport", or "authenticator"
3159 anchor &routers, &transports, &auths
3160 drivers_available available drivers
3161 size_of_info size of each info block
3162 instance_default points to default data for an instance
3163 instance_size size of instance block
3164 driver_optionlist generic option list
3165 driver_optionlist_count count of generic option list
3171 readconf_driver_init(
3173 driver_instance **anchor,
3174 driver_info *drivers_available,
3176 void *instance_default,
3178 optionlist *driver_optionlist,
3179 int driver_optionlist_count)
3181 driver_instance **p = anchor;
3182 driver_instance *d = NULL;
3185 while ((buffer = get_config_line()) != NULL)
3190 /* Read the first name on the line and test for the start of a new driver. A
3191 macro definition indicates the end of the previous driver. If this isn't the
3192 start of a new driver, the line will be re-read. */
3194 s = readconf_readname(name, sizeof(name), buffer);
3196 /* Handle macro definition, first finishing off the initialization of the
3197 previous driver, if any. */
3199 if (isupper(*name) && *s == '=')
3203 if (d->driver_name == NULL)
3204 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3205 "no driver defined for %s \"%s\"", class, d->name);
3209 read_macro_assignment(buffer);
3213 /* If the line starts with a name terminated by a colon, we are at the
3214 start of the definition of a new driver. The rest of the line must be
3221 /* Finish off initializing the previous driver. */
3225 if (d->driver_name == NULL)
3226 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3227 "no driver defined for %s \"%s\"", class, d->name);
3231 /* Check that we haven't already got a driver of this name */
3233 for (d = *anchor; d != NULL; d = d->next)
3234 if (Ustrcmp(name, d->name) == 0)
3235 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3236 "there are two %ss called \"%s\"", class, name);
3238 /* Set up a new driver instance data block on the chain, with
3239 its default values installed. */
3241 d = store_get(instance_size);
3242 memcpy(d, instance_default, instance_size);
3245 d->name = string_copy(name);
3247 /* Clear out the "set" bits in the generic options */
3249 for (i = 0; i < driver_optionlist_count; i++)
3250 driver_optionlist[i].type &= ~opt_set;
3252 /* Check nothing more on this line, then do the next loop iteration. */
3254 while (isspace(*s)) s++;
3255 if (*s != 0) extra_chars_error(s, US"driver name ", name, US"");
3259 /* Not the start of a new driver. Give an error if we have not set up a
3260 current driver yet. */
3262 if (d == NULL) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3263 "%s name missing", class);
3265 /* First look to see if this is a generic option; if it is "driver",
3266 initialize the driver. If is it not a generic option, we can look for a
3267 private option provided that the driver has been previously set up. */
3269 if (readconf_handle_option(buffer, driver_optionlist,
3270 driver_optionlist_count, d, NULL))
3272 if (d->info == NULL && d->driver_name != NULL)
3273 init_driver(d, drivers_available, size_of_info, class);
3276 /* Handle private options - pass the generic block because some may
3277 live therein. A flag with each option indicates if it is in the public
3280 else if (d->info != NULL)
3282 readconf_handle_option(buffer, d->info->options,
3283 *(d->info->options_count), d, US"option \"%s\" unknown");
3286 /* The option is not generic and the driver name has not yet been given. */
3288 else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option \"%s\" unknown "
3289 "(\"driver\" must be specified before any private options)", name);
3292 /* Run the initialization function for the final driver. */
3296 if (d->driver_name == NULL)
3297 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3298 "no driver defined for %s \"%s\"", class, d->name);
3305 /*************************************************
3306 * Check driver dependency *
3307 *************************************************/
3309 /* This function is passed a driver instance and a string. It checks whether
3310 any of the string options for the driver contains the given string as an
3314 d points to a driver instance block
3315 s the string to search for
3317 Returns: TRUE if a dependency is found
3321 readconf_depends(driver_instance *d, uschar *s)
3323 int count = *(d->info->options_count);
3327 for (ol = d->info->options; ol < d->info->options + count; ol++)
3329 void *options_block;
3331 int type = ol->type & opt_mask;
3332 if (type != opt_stringptr) continue;
3333 options_block = ((ol->type & opt_public) == 0)? d->options_block : (void *)d;
3334 value = *(uschar **)((uschar *)options_block + (long int)(ol->value));
3335 if (value != NULL && (ss = Ustrstr(value, s)) != NULL)
3337 if (ss <= value || (ss[-1] != '$' && ss[-1] != '{') ||
3338 isalnum(ss[Ustrlen(s)])) continue;
3339 DEBUG(D_transport) debug_printf("driver %s: \"%s\" option depends on %s\n",
3340 d->name, ol->name, s);
3345 DEBUG(D_transport) debug_printf("driver %s does not depend on %s\n", d->name, s);
3352 /*************************************************
3353 * Decode an error type for retries *
3354 *************************************************/
3356 /* This function is global because it is also called from the main
3357 program when testing retry information. It decodes strings such as "quota_7d"
3358 into numerical error codes.
3361 pp points to start of text
3362 p points past end of text
3363 basic_errno points to an int to receive the main error number
3364 more_errno points to an int to receive the secondary error data
3366 Returns: NULL if decoded correctly; else points to error text
3370 readconf_retry_error(uschar *pp, uschar *p, int *basic_errno, int *more_errno)
3374 while (q < p && *q != '_') q++;
3377 if (len == 5 && strncmpic(pp, US"quota", len) == 0)
3379 *basic_errno = ERRNO_EXIMQUOTA;
3380 if (q != p && (*more_errno = readconf_readtime(q+1, *p, FALSE)) < 0)
3381 return US"bad time value";
3384 else if (len == 7 && strncmpic(pp, US"refused", len) == 0)
3386 *basic_errno = ECONNREFUSED;
3389 if (strncmpic(q+1, US"MX", p-q-1) == 0) *more_errno = 'M';
3390 else if (strncmpic(q+1, US"A", p-q-1) == 0) *more_errno = 'A';
3391 else return US"A or MX expected after \"refused\"";
3395 else if (len == 7 && strncmpic(pp, US"timeout", len) == 0)
3397 *basic_errno = ETIMEDOUT;
3401 int xlen = p - q - 1;
3404 static uschar *extras[] =
3405 { US"A", US"MX", US"connect", US"connect_A", US"connect_MX" };
3406 static int values[] =
3407 { 'A', 'M', RTEF_CTOUT, RTEF_CTOUT|'A', RTEF_CTOUT|'M' };
3409 for (i = 0; i < sizeof(extras)/sizeof(uschar *); i++)
3411 if (strncmpic(x, extras[i], xlen) == 0)
3413 *more_errno = values[i];
3418 if (i >= sizeof(extras)/sizeof(uschar *))
3420 if (strncmpic(x, US"DNS", xlen) == 0)
3422 log_write(0, LOG_MAIN|LOG_PANIC, "\"timeout_dns\" is no longer "
3423 "available in retry rules (it has never worked) - treated as "
3426 else return US"\"A\", \"MX\", or \"connect\" expected after \"timeout\"";
3431 else if (strncmpic(pp, US"mail_4", 6) == 0 ||
3432 strncmpic(pp, US"rcpt_4", 6) == 0 ||
3433 strncmpic(pp, US"data_4", 6) == 0)
3436 int x = 255; /* means "any 4xx code" */
3437 if (p != pp + 8) bad = TRUE; else
3439 int a = pp[6], b = pp[7];
3443 if (isdigit(b)) x += b - '0';
3444 else if (b == 'x') x += 100;
3447 else if (a != 'x' || b != 'x') bad = TRUE;
3451 return string_sprintf("%.4s_4 must be followed by xx, dx, or dd, where "
3452 "x is literal and d is any digit", pp);
3454 *basic_errno = (*pp == 'm')? ERRNO_MAIL4XX :
3455 (*pp == 'r')? ERRNO_RCPT4XX : ERRNO_DATA4XX;
3456 *more_errno = x << 8;
3459 else if (len == 4 && strncmpic(pp, US"auth", len) == 0 &&
3460 strncmpic(q+1, US"failed", p-q-1) == 0)
3461 *basic_errno = ERRNO_AUTHFAIL;
3463 else if (strncmpic(pp, US"lost_connection", p - pp) == 0)
3464 *basic_errno = ERRNO_SMTPCLOSED;
3466 else if (strncmpic(pp, US"tls_required", p - pp) == 0)
3467 *basic_errno = ERRNO_TLSREQUIRED;
3469 else if (len != 1 || Ustrncmp(pp, "*", 1) != 0)
3470 return string_sprintf("unknown or malformed retry error \"%.*s\"", p-pp, pp);
3478 /*************************************************
3479 * Read retry information *
3480 *************************************************/
3482 /* Each line of retry information contains:
3484 . A domain name pattern or an address pattern;
3486 . An error name, possibly with additional data, or *;
3488 . An optional sequence of retry items, each consisting of an identifying
3489 letter, a cutoff time, and optional parameters.
3491 All this is decoded and placed into a control block. */
3494 /* Subroutine to read an argument, preceded by a comma and terminated
3495 by comma, semicolon, whitespace, or newline. The types are: 0 = time value,
3496 1 = fixed point number (returned *1000).
3499 paddr pointer to pointer to current character; updated
3500 type 0 => read a time; 1 => read a fixed point number
3502 Returns: time in seconds or fixed point number * 1000
3506 retry_arg(uschar **paddr, int type)
3511 if (*p++ != ',') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma expected");
3513 while (isspace(*p)) p++;
3515 while (isalnum(*p) || (type == 1 && *p == '.')) p++;
3517 if (*p != 0 && !isspace(*p) && *p != ',' && *p != ';')
3518 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma or semicolon expected");
3524 return readconf_readtime(pp, *p, FALSE);
3526 return readconf_readfixed(pp, *p);
3528 return 0; /* Keep picky compilers happy */
3531 /* The function proper */
3534 readconf_retries(void)
3536 retry_config **chain = &retries;
3540 while ((p = get_config_line()) != NULL)
3542 retry_rule **rchain;
3545 next = store_get(sizeof(retry_config));
3548 chain = &(next->next);
3549 next->basic_errno = next->more_errno = 0;
3550 next->senders = NULL;
3552 rchain = &(next->rules);
3554 next->pattern = string_dequote(&p);
3555 while (isspace(*p)) p++;
3557 while (mac_isgraph(*p)) p++;
3558 if (p - pp <= 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3559 "missing error type");
3561 /* Test error names for things we understand. */
3563 if ((error = readconf_retry_error(pp, p, &(next->basic_errno),
3564 &(next->more_errno))) != NULL)
3565 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s", error);
3567 /* There may be an optional address list of senders to be used as another
3568 constraint on the rule. This was added later, so the syntax is a bit of a
3569 fudge. Anything that is not a retry rule starting "F," or "G," is treated as
3572 while (isspace(*p)) p++;
3573 if (Ustrncmp(p, "senders", 7) == 0)
3576 while (isspace(*p)) p++;
3577 if (*p++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3578 "\"=\" expected after \"senders\" in retry rule");
3579 while (isspace(*p)) p++;
3580 next->senders = string_dequote(&p);
3583 /* Now the retry rules. Keep the maximum timeout encountered. */
3585 while (isspace(*p)) p++;
3589 retry_rule *rule = store_get(sizeof(retry_rule));
3591 rchain = &(rule->next);
3593 rule->rule = toupper(*p++);
3594 rule->timeout = retry_arg(&p, 0);
3595 if (rule->timeout > retry_maximum_timeout)
3596 retry_maximum_timeout = rule->timeout;
3600 case 'F': /* Fixed interval */
3601 rule->p1 = retry_arg(&p, 0);
3604 case 'G': /* Geometrically increasing intervals */
3605 case 'H': /* Ditto, but with randomness */
3606 rule->p1 = retry_arg(&p, 0);
3607 rule->p2 = retry_arg(&p, 1);
3611 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unknown retry rule letter");
3615 if (rule->timeout <= 0 || rule->p1 <= 0 ||
3616 (rule->rule != 'F' && rule->p2 < 1000))
3617 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3618 "bad parameters for retry rule");
3620 while (isspace(*p)) p++;
3624 while (isspace(*p)) p++;
3627 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "semicolon expected");
3634 /*************************************************
3635 * Initialize authenticators *
3636 *************************************************/
3638 /* Read the authenticators section of the configuration file.
3647 auth_instance *au, *bu;
3648 readconf_driver_init(US"authenticator",
3649 (driver_instance **)(&auths), /* chain anchor */
3650 (driver_info *)auths_available, /* available drivers */
3651 sizeof(auth_info), /* size of info block */
3652 &auth_defaults, /* default values for generic options */
3653 sizeof(auth_instance), /* size of instance block */
3654 optionlist_auths, /* generic options */
3655 optionlist_auths_size);
3657 for (au = auths; au != NULL; au = au->next)
3659 if (au->public_name == NULL)
3660 log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "no public name specified for "
3661 "the %s authenticator", au->name);
3662 for (bu = au->next; bu != NULL; bu = bu->next)
3664 if (strcmpic(au->public_name, bu->public_name) == 0)
3666 if ((au->client && bu->client) || (au->server && bu->server))
3667 log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "two %s authenticators "
3668 "(%s and %s) have the same public name (%s)",
3669 (au->client)? US"client" : US"server", au->name, bu->name,
3679 /*************************************************
3680 * Read ACL information *
3681 *************************************************/
3683 /* If this run of Exim is not doing something that involves receiving a
3684 message, we can just skip over the ACL information. No need to parse it.
3686 First, we have a function for acl_read() to call back to get the next line. We
3687 need to remember the line we passed, because at the end it will contain the
3688 name of the next ACL. */
3690 static uschar *acl_line;
3695 acl_line = get_config_line();
3700 /* Now the main function:
3703 skip TRUE when this Exim process is doing something that will
3704 not need the ACL data
3710 readconf_acl(BOOL skip)
3714 /* Not receiving messages, don't need to parse the ACL data */
3718 DEBUG(D_acl) debug_printf("skipping ACL configuration - not needed\n");
3719 while ((p = get_config_line()) != NULL);
3723 /* Read each ACL and add it into the tree. Macro (re)definitions are allowed
3726 acl_line = get_config_line();
3728 while(acl_line != NULL)
3734 p = readconf_readname(name, sizeof(name), acl_line);
3735 if (isupper(*name) && *p == '=')
3737 read_macro_assignment(acl_line);
3738 acl_line = get_config_line();
3742 if (*p != ':' || name[0] == 0)
3743 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing or malformed ACL name");
3745 node = store_get(sizeof(tree_node) + Ustrlen(name));
3746 Ustrcpy(node->name, name);
3747 if (!tree_insertnode(&acl_anchor, node))
3748 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3749 "there are two ACLs called \"%s\"", name);
3751 node->data.ptr = acl_read(acl_callback, &error);
3753 if (node->data.ptr == NULL && error != NULL)
3754 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "error in ACL: %s", error);
3760 /*************************************************
3761 * Read configuration for local_scan() *
3762 *************************************************/
3764 /* This function is called after "begin local_scan" is encountered in the
3765 configuration file. If the local_scan() function allows for configuration
3766 options, we can process them. Otherwise, we expire in a panic.
3773 local_scan_init(void)
3775 #ifndef LOCAL_SCAN_HAS_OPTIONS
3776 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "local_scan() options not supported: "
3777 "(LOCAL_SCAN_HAS_OPTIONS not defined in Local/Makefile)");
3781 while ((p = get_config_line()) != NULL)
3783 (void) readconf_handle_option(p, local_scan_options, local_scan_options_count,
3784 NULL, US"local_scan option \"%s\" unknown");
3791 /*************************************************
3792 * Read rest of configuration (after main) *
3793 *************************************************/
3795 /* This function reads the rest of the runtime configuration, after the main
3796 configuration. It is called only when actually needed. Each subsequent section
3797 of the configuration starts with a line of the form
3801 where the name is "routers", "transports", etc. A section is terminated by
3802 hitting the next "begin" line, and the next name is left in next_section.
3803 Because it may confuse people as to whether the names are singular or plural,
3804 we add "s" if it's missing. There is always enough room in next_section for
3805 this. This function is basically just a switch.
3808 skip_acl TRUE if ACL information is not needed
3813 static uschar *section_list[] = {
3823 readconf_rest(BOOL skip_acl)
3827 while(next_section[0] != 0)
3831 int last = sizeof(section_list) / sizeof(uschar *);
3833 int n = Ustrlen(next_section);
3835 if (tolower(next_section[n-1]) != 's') Ustrcpy(next_section+n, "s");
3839 int c = strcmpic(next_section, section_list[mid]);
3841 if (c > 0) first = mid + 1; else last = mid;
3843 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3844 "\"%.*s\" is not a known configuration section name", n, next_section);
3845 mid = (last + first)/2;
3849 if (((had ^= bit) & bit) == 0)
3850 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3851 "\"%.*s\" section is repeated in the configuration file", n,
3856 case 0: readconf_acl(skip_acl); break;
3857 case 1: auths_init(); break;
3858 case 2: local_scan_init(); break;
3859 case 3: readconf_retries(); break;
3860 case 4: readconf_rewrites(); break;
3861 case 5: route_init(); break;
3862 case 6: transport_init(); break;
3866 (void)fclose(config_file);
3869 /* End of readconf.c */