Compiler quietening: C fn ptrs are officially not intercastable with object pointers
[exim.git] / src / src / routers / redirect.c
CommitLineData
0756eb3c
PH
1/*************************************************
2* Exim - an Internet mail transport agent *
3*************************************************/
4
f9ba5e22 5/* Copyright (c) University of Cambridge 1995 - 2018 */
0756eb3c
PH
6/* See the file NOTICE for conditions of use and distribution. */
7
8
9#include "../exim.h"
10#include "rf_functions.h"
11#include "redirect.h"
12
13
14
15/* Options specific to the redirect router. */
16
17optionlist redirect_router_options[] = {
18 { "allow_defer", opt_bit | (RDON_DEFER << 16),
19 (void *)offsetof(redirect_router_options_block, bit_options) },
20 { "allow_fail", opt_bit | (RDON_FAIL << 16),
21 (void *)offsetof(redirect_router_options_block, bit_options) },
22 { "allow_filter", opt_bit | (RDON_FILTER << 16),
23 (void *)offsetof(redirect_router_options_block, bit_options) },
24 { "allow_freeze", opt_bit | (RDON_FREEZE << 16),
25 (void *)offsetof(redirect_router_options_block, bit_options) },
26 { "check_ancestor", opt_bool,
27 (void *)offsetof(redirect_router_options_block, check_ancestor) },
28 { "check_group", opt_bool,
29 (void *)offsetof(redirect_router_options_block, check_group) },
30 { "check_owner", opt_bool,
31 (void *)offsetof(redirect_router_options_block, check_owner) },
32 { "data", opt_stringptr,
33 (void *)offsetof(redirect_router_options_block, data) },
34 { "directory_transport",opt_stringptr,
35 (void *)offsetof(redirect_router_options_block, directory_transport_name) },
36 { "file", opt_stringptr,
37 (void *)offsetof(redirect_router_options_block, file) },
38 { "file_transport", opt_stringptr,
39 (void *)offsetof(redirect_router_options_block, file_transport_name) },
4608d683
PH
40 { "filter_prepend_home",opt_bit | (RDON_PREPEND_HOME << 16),
41 (void *)offsetof(redirect_router_options_block, bit_options) },
0756eb3c
PH
42 { "forbid_blackhole", opt_bit | (RDON_BLACKHOLE << 16),
43 (void *)offsetof(redirect_router_options_block, bit_options) },
23c7ff99
PH
44 { "forbid_exim_filter", opt_bit | (RDON_EXIM_FILTER << 16),
45 (void *)offsetof(redirect_router_options_block, bit_options) },
0756eb3c
PH
46 { "forbid_file", opt_bool,
47 (void *)offsetof(redirect_router_options_block, forbid_file) },
1a46a8c5
PH
48 { "forbid_filter_dlfunc", opt_bit | (RDON_DLFUNC << 16),
49 (void *)offsetof(redirect_router_options_block, bit_options) },
0756eb3c
PH
50 { "forbid_filter_existstest", opt_bit | (RDON_EXISTS << 16),
51 (void *)offsetof(redirect_router_options_block, bit_options) },
52 { "forbid_filter_logwrite",opt_bit | (RDON_LOG << 16),
53 (void *)offsetof(redirect_router_options_block, bit_options) },
54 { "forbid_filter_lookup", opt_bit | (RDON_LOOKUP << 16),
55 (void *)offsetof(redirect_router_options_block, bit_options) },
0756eb3c
PH
56 { "forbid_filter_perl", opt_bit | (RDON_PERL << 16),
57 (void *)offsetof(redirect_router_options_block, bit_options) },
0756eb3c
PH
58 { "forbid_filter_readfile", opt_bit | (RDON_READFILE << 16),
59 (void *)offsetof(redirect_router_options_block, bit_options) },
60 { "forbid_filter_readsocket", opt_bit | (RDON_READSOCK << 16),
61 (void *)offsetof(redirect_router_options_block, bit_options) },
62 { "forbid_filter_reply",opt_bool,
63 (void *)offsetof(redirect_router_options_block, forbid_filter_reply) },
64 { "forbid_filter_run", opt_bit | (RDON_RUN << 16),
65 (void *)offsetof(redirect_router_options_block, bit_options) },
66 { "forbid_include", opt_bit | (RDON_INCLUDE << 16),
67 (void *)offsetof(redirect_router_options_block, bit_options) },
68 { "forbid_pipe", opt_bool,
69 (void *)offsetof(redirect_router_options_block, forbid_pipe) },
23c7ff99
PH
70 { "forbid_sieve_filter",opt_bit | (RDON_SIEVE_FILTER << 16),
71 (void *)offsetof(redirect_router_options_block, bit_options) },
a5bd321b
PH
72 { "forbid_smtp_code", opt_bool,
73 (void *)offsetof(redirect_router_options_block, forbid_smtp_code) },
0756eb3c
PH
74 { "hide_child_in_errmsg", opt_bool,
75 (void *)offsetof(redirect_router_options_block, hide_child_in_errmsg) },
76 { "ignore_eacces", opt_bit | (RDON_EACCES << 16),
77 (void *)offsetof(redirect_router_options_block, bit_options) },
78 { "ignore_enotdir", opt_bit | (RDON_ENOTDIR << 16),
79 (void *)offsetof(redirect_router_options_block, bit_options) },
80 { "include_directory", opt_stringptr,
81 (void *)offsetof(redirect_router_options_block, include_directory) },
82 { "modemask", opt_octint,
83 (void *)offsetof(redirect_router_options_block, modemask) },
84 { "one_time", opt_bool,
85 (void *)offsetof(redirect_router_options_block, one_time) },
86 { "owners", opt_uidlist,
87 (void *)offsetof(redirect_router_options_block, owners) },
88 { "owngroups", opt_gidlist,
89 (void *)offsetof(redirect_router_options_block, owngroups) },
90 { "pipe_transport", opt_stringptr,
91 (void *)offsetof(redirect_router_options_block, pipe_transport_name) },
92 { "qualify_domain", opt_stringptr,
93 (void *)offsetof(redirect_router_options_block, qualify_domain) },
94 { "qualify_preserve_domain", opt_bool,
95 (void *)offsetof(redirect_router_options_block, qualify_preserve_domain) },
96 { "repeat_use", opt_bool | opt_public,
97 (void *)offsetof(router_instance, repeat_use) },
98 { "reply_transport", opt_stringptr,
99 (void *)offsetof(redirect_router_options_block, reply_transport_name) },
100 { "rewrite", opt_bit | (RDON_REWRITE << 16),
101 (void *)offsetof(redirect_router_options_block, bit_options) },
9683a68f
MH
102 { "sieve_enotify_mailto_owner", opt_stringptr,
103 (void *)offsetof(redirect_router_options_block, sieve_enotify_mailto_owner) },
e4a89c47
PH
104 { "sieve_subaddress", opt_stringptr,
105 (void *)offsetof(redirect_router_options_block, sieve_subaddress) },
106 { "sieve_useraddress", opt_stringptr,
107 (void *)offsetof(redirect_router_options_block, sieve_useraddress) },
0756eb3c
PH
108 { "sieve_vacation_directory", opt_stringptr,
109 (void *)offsetof(redirect_router_options_block, sieve_vacation_directory) },
110 { "skip_syntax_errors", opt_bool,
111 (void *)offsetof(redirect_router_options_block, skip_syntax_errors) },
8523533c
TK
112#ifdef EXPERIMENTAL_SRS
113 { "srs", opt_stringptr,
114 (void *)offsetof(redirect_router_options_block, srs) },
115 { "srs_alias", opt_stringptr,
116 (void *)offsetof(redirect_router_options_block, srs_alias) },
117 { "srs_condition", opt_stringptr,
118 (void *)offsetof(redirect_router_options_block, srs_condition) },
384152a6
TK
119 { "srs_dbinsert", opt_stringptr,
120 (void *)offsetof(redirect_router_options_block, srs_dbinsert) },
121 { "srs_dbselect", opt_stringptr,
122 (void *)offsetof(redirect_router_options_block, srs_dbselect) },
8523533c 123#endif
0756eb3c
PH
124 { "syntax_errors_text", opt_stringptr,
125 (void *)offsetof(redirect_router_options_block, syntax_errors_text) },
126 { "syntax_errors_to", opt_stringptr,
127 (void *)offsetof(redirect_router_options_block, syntax_errors_to) }
128};
129
130/* Size of the options list. An extern variable has to be used so that its
131address can appear in the tables drtables.c. */
132
133int redirect_router_options_count =
134 sizeof(redirect_router_options)/sizeof(optionlist);
135
d185889f
JH
136
137#ifdef MACRO_PREDEF
138
139/* Dummy entries */
140redirect_router_options_block redirect_router_option_defaults = {0};
141void redirect_router_init(router_instance *rblock) {}
142int redirect_router_entry(router_instance *rblock, address_item *addr,
143 struct passwd *pw, int verify, address_item **addr_local,
144 address_item **addr_remote, address_item **addr_new,
cab0c277 145 address_item **addr_succeed) {return 0;}
d185889f
JH
146
147#else /*!MACRO_PREDEF*/
148
149
150
0756eb3c
PH
151/* Default private options block for the redirect router. */
152
153redirect_router_options_block redirect_router_option_defaults = {
154 NULL, /* directory_transport */
155 NULL, /* file_transport */
156 NULL, /* pipe_transport */
157 NULL, /* reply_transport */
158 NULL, /* data */
159 NULL, /* directory_transport_name */
160 NULL, /* file */
161 NULL, /* file_dir */
162 NULL, /* file_transport_name */
163 NULL, /* include_directory */
164 NULL, /* pipe_transport_name */
165 NULL, /* reply_transport_name */
e4a89c47
PH
166 NULL, /* sieve_subaddress */
167 NULL, /* sieve_useraddress */
0756eb3c 168 NULL, /* sieve_vacation_directory */
efd9a422 169 NULL, /* sieve_enotify_mailto_owner */
0756eb3c
PH
170 NULL, /* syntax_errors_text */
171 NULL, /* syntax_errors_to */
172 NULL, /* qualify_domain */
173 NULL, /* owners */
174 NULL, /* owngroups */
8523533c
TK
175#ifdef EXPERIMENTAL_SRS
176 NULL, /* srs */
8523533c 177 NULL, /* srs_alias */
384152a6
TK
178 NULL, /* srs_condition */
179 NULL, /* srs_dbinsert */
180 NULL, /* srs_dbselect */
8523533c 181#endif
0756eb3c 182 022, /* modemask */
4608d683 183 RDO_REWRITE | RDO_PREPEND_HOME, /* bit_options */
0756eb3c
PH
184 FALSE, /* check_ancestor */
185 TRUE_UNSET, /* check_owner */
186 TRUE_UNSET, /* check_group */
187 FALSE, /* forbid_file */
188 FALSE, /* forbid_filter_reply */
189 FALSE, /* forbid_pipe */
a5bd321b 190 FALSE, /* forbid_smtp_code */
0756eb3c
PH
191 FALSE, /* hide_child_in_errmsg */
192 FALSE, /* one_time */
193 FALSE, /* qualify_preserve_domain */
194 FALSE /* skip_syntax_errors */
195};
196
197
198
199/*************************************************
200* Initialization entry point *
201*************************************************/
202
203/* Called for each instance, after its options have been read, to enable
204consistency checks to be done, or anything else that needs to be set up. */
205
206void redirect_router_init(router_instance *rblock)
207{
208redirect_router_options_block *ob =
209 (redirect_router_options_block *)(rblock->options_block);
210
211/* Either file or data must be set, but not both */
212
213if ((ob->file == NULL) == (ob->data == NULL))
214 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
215 "%sone of \"file\" or \"data\" must be specified",
216 rblock->name, (ob->file == NULL)? "" : "only ");
217
7f45268c
PH
218/* Onetime aliases can only be real addresses. Headers can't be manipulated.
219The combination of one_time and unseen is not allowed. We can't check the
220expansion of "unseen" here, but we assume that if it is set to anything other
221than false, there is likely to be a problem. */
0756eb3c
PH
222
223if (ob->one_time)
224 {
225 ob->forbid_pipe = ob->forbid_file = ob->forbid_filter_reply = TRUE;
acec9514 226 if (rblock->extra_headers || rblock->remove_headers)
0756eb3c
PH
227 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
228 "\"headers_add\" and \"headers_remove\" are not permitted with "
229 "\"one_time\"", rblock->name);
acec9514 230 if (rblock->unseen || rblock->expand_unseen)
7f45268c
PH
231 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
232 "\"unseen\" may not be used with \"one_time\"", rblock->name);
0756eb3c
PH
233 }
234
235/* The defaults for check_owner and check_group depend on other settings. The
236defaults are: Check the owner if check_local_user or owners is set; check the
237group if check_local_user is set without a restriction on the group write bit,
238or if owngroups is set. */
239
240if (ob->check_owner == TRUE_UNSET)
241 ob->check_owner = rblock->check_local_user ||
acec9514 242 (ob->owners && ob->owners[0] != 0);
0756eb3c
PH
243
244if (ob->check_group == TRUE_UNSET)
245 ob->check_group = (rblock->check_local_user && (ob->modemask & 020) == 0) ||
246 (ob->owngroups != NULL && ob->owngroups[0] != 0);
247
248/* If explicit qualify domain set, the preserve option is locked out */
249
acec9514 250if (ob->qualify_domain && ob->qualify_preserve_domain)
0756eb3c
PH
251 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
252 "only one of \"qualify_domain\" or \"qualify_preserve_domain\" must be set",
253 rblock->name);
254
255/* If allow_filter is set, either user or check_local_user must be set. */
256
257if (!rblock->check_local_user &&
258 !rblock->uid_set &&
259 rblock->expand_uid == NULL &&
260 (ob->bit_options & RDO_FILTER) != 0)
261 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
262 "\"user\" or \"check_local_user\" must be set with \"allow_filter\"",
263 rblock->name);
264}
265
266
267
268/*************************************************
269* Get errors address and header mods *
270*************************************************/
271
272/* This function is called when new addresses are generated, in order to
273sort out errors address and header modifications. We put the errors address
274into the parent address (even though it is never used from there because that
275address is never transported) so that it can be retrieved if any of the
276children gets routed by an "unseen" router. The clone of the child that is
277passed on must have the original errors_address value.
278
279Arguments:
280 rblock the router control block
281 addr the address being routed
fd6de02e 282 verify v_none/v_recipient/v_sender/v_expn
0756eb3c
PH
283 addr_prop point to the propagated block, which is where the
284 new values are to be placed
285
286Returns: the result of rf_get_errors_address() or rf_get_munge_headers(),
287 which is either OK or DEFER
288*/
289
290static int
291sort_errors_and_headers(router_instance *rblock, address_item *addr,
fd6de02e 292 int verify, address_item_propagated *addr_prop)
0756eb3c
PH
293{
294int frc = rf_get_errors_address(addr, rblock, verify,
d43cbe25 295 &addr_prop->errors_address);
0756eb3c 296if (frc != OK) return frc;
d43cbe25
JH
297addr->prop.errors_address = addr_prop->errors_address;
298return rf_get_munge_headers(addr, rblock, &addr_prop->extra_headers,
299 &addr_prop->remove_headers);
0756eb3c
PH
300}
301
302
303
304/*************************************************
305* Process a set of generated new addresses *
306*************************************************/
307
308/* This function sets up a set of newly generated child addresses and puts them
309on the new address chain. Copy in the uid, gid and permission flags for use by
310pipes and files, set the parent, and "or" its af_ignore_error flag. Also record
311the setting for any starting router.
312
313If the generated address is the same as one of its ancestors, and the
314check_ancestor flag is set, do not use this generated address, but replace it
315with a copy of the input address. This is to cope with cases where A is aliased
316to B and B has a .forward file pointing to A, though it is usually set on the
317forwardfile rather than the aliasfile. We can't just pass on the old
318address by returning FAIL, because it must act as a general parent for
319generated addresses, and only get marked "done" when all its children are
320delivered.
321
322Arguments:
323 rblock router block
324 addr_new new address chain
325 addr original address
326 generated list of generated addresses
327 addr_prop the propagated block, containing the errors_address,
328 header modification stuff, and address_data
329 ugidptr points to uid/gid data for files, pipes, autoreplies
330 pw password entry, set if ob->check_local_user is TRUE
331
332Returns: nothing
333*/
334
335static void
336add_generated(router_instance *rblock, address_item **addr_new,
337 address_item *addr, address_item *generated,
338 address_item_propagated *addr_prop, ugid_block *ugidptr, struct passwd *pw)
339{
340redirect_router_options_block *ob =
341 (redirect_router_options_block *)(rblock->options_block);
342
d1f9fb42 343while (generated)
0756eb3c
PH
344 {
345 address_item *parent;
346 address_item *next = generated;
d43cbe25 347 uschar *errors_address = next->prop.errors_address;
0756eb3c
PH
348
349 generated = next->next;
350 next->parent = addr;
0756eb3c 351 next->start_router = rblock->redirect_router;
82f90600 352 if (addr->child_count == USHRT_MAX)
4362ff0d 353 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s router generated more than %d "
82f90600 354 "child addresses for <%s>", rblock->name, USHRT_MAX, addr->address);
0756eb3c
PH
355 addr->child_count++;
356
357 next->next = *addr_new;
358 *addr_new = next;
359
360 /* Don't do the "one_time" thing for the first pass of a 2-stage queue run. */
361
8768d548 362 if (ob->one_time && !f.queue_2stage)
0756eb3c 363 {
d1f9fb42 364 for (parent = addr; parent->parent; parent = parent->parent) ;
0756eb3c
PH
365 next->onetime_parent = parent->address;
366 }
367
368 if (ob->hide_child_in_errmsg) setflag(next, af_hide_child);
369
370 /* If check_ancestor is set, we want to know if any ancestor of this address
371 is the address we are about to generate. The check must be done caselessly
372 unless the ancestor was routed by a case-sensitive router. */
373
374 if (ob->check_ancestor)
d1f9fb42
JH
375 for (parent = addr; parent; parent = parent->parent)
376 if ((parent->router && parent->router->caseful_local_part
377 ? Ustrcmp(next->address, parent->address)
378 : strcmpic(next->address, parent->address)
0756eb3c
PH
379 ) == 0)
380 {
381 DEBUG(D_route) debug_printf("generated parent replaced by child\n");
382 next->address = string_copy(addr->address);
383 break;
384 }
0756eb3c
PH
385
386 /* A user filter may, under some circumstances, set up an errors address.
387 If so, we must take care to re-instate it when we copy in the propagated
388 data so that it overrides any errors_to setting on the router. */
389
7eb0e5d2
JH
390 {
391 BOOL ignore_error = next->prop.ignore_error;
392 next->prop = *addr_prop;
a5853d7c 393 next->prop.ignore_error = ignore_error || addr->prop.ignore_error;
7eb0e5d2
JH
394 }
395 if (errors_address) next->prop.errors_address = errors_address;
0756eb3c
PH
396
397 /* For pipes, files, and autoreplies, record this router as handling them,
398 because they don't go through the routing process again. Then set up uid,
399 gid, home and current directories for transporting. */
400
401 if (testflag(next, af_pfr))
402 {
403 next->router = rblock;
404 rf_set_ugid(next, ugidptr); /* Will contain pw values if not overridden */
405
406 /* When getting the home directory out of the password information, wrap it
407 in \N...\N to avoid expansion later. In Cygwin, home directories can
408 contain $ characters. */
409
410 if (rblock->home_directory != NULL)
411 next->home_dir = rblock->home_directory;
412 else if (rblock->check_local_user)
413 next->home_dir = string_sprintf("\\N%s\\N", pw->pw_dir);
414 else if (rblock->router_home_directory != NULL &&
415 testflag(addr, af_home_expanded))
416 {
417 next->home_dir = deliver_home;
418 setflag(next, af_home_expanded);
419 }
420
421 next->current_dir = rblock->current_directory;
422
423 /* Permission options */
424
425 if (!ob->forbid_pipe) setflag(next, af_allow_pipe);
426 if (!ob->forbid_file) setflag(next, af_allow_file);
427 if (!ob->forbid_filter_reply) setflag(next, af_allow_reply);
428
429 /* If the transport setting fails, the error gets picked up at the outer
430 level from the setting of basic_errno in the address. */
431
432 if (next->address[0] == '|')
433 {
434 address_pipe = next->address;
435 if (rf_get_transport(ob->pipe_transport_name, &(ob->pipe_transport),
436 next, rblock->name, US"pipe_transport"))
437 next->transport = ob->pipe_transport;
438 address_pipe = NULL;
439 }
440 else if (next->address[0] == '>')
441 {
442 if (rf_get_transport(ob->reply_transport_name, &(ob->reply_transport),
443 next, rblock->name, US"reply_transport"))
444 next->transport = ob->reply_transport;
445 }
446 else /* must be file or directory */
447 {
448 int len = Ustrlen(next->address);
449 address_file = next->address;
450 if (next->address[len-1] == '/')
451 {
452 if (rf_get_transport(ob->directory_transport_name,
453 &(ob->directory_transport), next, rblock->name,
454 US"directory_transport"))
455 next->transport = ob->directory_transport;
456 }
457 else
458 {
459 if (rf_get_transport(ob->file_transport_name, &(ob->file_transport),
460 next, rblock->name, US"file_transport"))
461 next->transport = ob->file_transport;
462 }
463 address_file = NULL;
464 }
465 }
466
8c5d388a 467#ifdef SUPPORT_I18N
e6532c4a
JH
468 if (!next->prop.utf8_msg)
469 next->prop.utf8_msg = string_is_utf8(next->address)
470 || (sender_address && string_is_utf8(sender_address));
f923454a
JH
471#endif
472
0756eb3c
PH
473 DEBUG(D_route)
474 {
475 debug_printf("%s router generated %s\n %serrors_to=%s transport=%s\n",
476 rblock->name,
477 next->address,
478 testflag(next, af_pfr)? "pipe, file, or autoreply\n " : "",
d43cbe25 479 next->prop.errors_address,
0756eb3c
PH
480 (next->transport == NULL)? US"NULL" : next->transport->name);
481
482 if (testflag(next, af_uid_set))
483 debug_printf(" uid=%ld ", (long int)(next->uid));
484 else
485 debug_printf(" uid=unset ");
486
487 if (testflag(next, af_gid_set))
488 debug_printf("gid=%ld ", (long int)(next->gid));
489 else
490 debug_printf("gid=unset ");
491
8c5d388a 492#ifdef SUPPORT_I18N
3c8b3577 493 if (next->prop.utf8_msg) debug_printf("utf8 ");
f923454a
JH
494#endif
495
0756eb3c
PH
496 debug_printf("home=%s\n", next->home_dir);
497 }
498 }
499}
500
501
502/*************************************************
503* Main entry point *
504*************************************************/
505
506/* See local README for interface description. This router returns:
507
508DECLINE
509 . empty address list, or filter did nothing significant
510
511DEFER
512 . verifying the errors address caused a deferment or a big disaster such
513 as an expansion failure (rf_get_errors_address)
514 . expanding a headers_{add,remove} string caused a deferment or another
515 expansion error (rf_get_munge_headers)
516 . :defer: or "freeze" in a filter
517 . error in address list or filter
518 . skipped syntax errors, but failed to send the message
519
520DISCARD
521 . address was :blackhole:d or "seen finish"ed
522
523FAIL
524 . :fail:
525
526OK
527 . new addresses added to addr_new
528*/
529
530int redirect_router_entry(
531 router_instance *rblock, /* data for this instantiation */
532 address_item *addr, /* address we are working on */
533 struct passwd *pw, /* passwd entry after check_local_user */
fd6de02e 534 int verify, /* v_none/v_recipient/v_sender/v_expn */
0756eb3c
PH
535 address_item **addr_local, /* add it to this if it's local */
536 address_item **addr_remote, /* add it to this if it's remote */
537 address_item **addr_new, /* put new addresses on here */
538 address_item **addr_succeed) /* put old address here on success */
539{
540redirect_router_options_block *ob =
541 (redirect_router_options_block *)(rblock->options_block);
542address_item *generated = NULL;
55414b25 543const uschar *save_qualify_domain_recipient = qualify_domain_recipient;
0756eb3c
PH
544uschar *discarded = US"discarded";
545address_item_propagated addr_prop;
546error_block *eblock = NULL;
547ugid_block ugid;
548redirect_block redirect;
549int filtertype = FILTER_UNSET;
550int yield = OK;
551int options = ob->bit_options;
552int frc = 0;
553int xrc = 0;
554
555addr_local = addr_local; /* Keep picky compilers happy */
556addr_remote = addr_remote;
557
558/* Initialize the data to be propagated to the children */
559
560addr_prop.address_data = deliver_address_data;
561addr_prop.domain_data = deliver_domain_data;
562addr_prop.localpart_data = deliver_localpart_data;
563addr_prop.errors_address = NULL;
564addr_prop.extra_headers = NULL;
565addr_prop.remove_headers = NULL;
b4f579d1
JH
566addr_prop.variables = NULL;
567tree_dup((tree_node **)&addr_prop.variables, addr->prop.variables);
0756eb3c 568
384152a6
TK
569#ifdef EXPERIMENTAL_SRS
570addr_prop.srs_sender = NULL;
571#endif
cb570b5e 572#ifdef SUPPORT_I18N
e6532c4a
JH
573addr_prop.utf8_msg = addr->prop.utf8_msg;
574addr_prop.utf8_downcvt = addr->prop.utf8_downcvt;
575addr_prop.utf8_downcvt_maybe = addr->prop.utf8_downcvt_maybe;
cb570b5e
JH
576#endif
577
384152a6 578
0756eb3c
PH
579/* When verifying and testing addresses, the "logwrite" command in filters
580must be bypassed. */
581
8768d548 582if (verify == v_none && !f.address_test_mode) options |= RDO_REALLOG;
0756eb3c
PH
583
584/* Sort out the fixed or dynamic uid/gid. This uid is used (a) for reading the
585file (and interpreting a filter) and (b) for running the transports for
586generated file and pipe addresses. It is not (necessarily) the same as the uids
587that may own the file. Exim panics if an expanded string is not a number and
588can't be found in the password file. Other errors set the freezing bit. */
589
590if (!rf_get_ugid(rblock, addr, &ugid)) return DEFER;
591
592if (!ugid.uid_set && pw != NULL)
593 {
594 ugid.uid = pw->pw_uid;
595 ugid.uid_set = TRUE;
596 }
597
598if (!ugid.gid_set && pw != NULL)
599 {
600 ugid.gid = pw->pw_gid;
601 ugid.gid_set = TRUE;
602 }
603
8523533c 604#ifdef EXPERIMENTAL_SRS
384152a6
TK
605 /* Perform SRS on recipient/return-path as required */
606
8523533c
TK
607 if(ob->srs != NULL)
608 {
609 BOOL usesrs = TRUE;
8e669ac1 610
8523533c
TK
611 if(ob->srs_condition != NULL)
612 usesrs = expand_check_condition(ob->srs_condition, "srs_condition expansion failed", NULL);
8e669ac1 613
8523533c 614 if(usesrs)
384152a6 615 {
5614ee86 616 int srs_action = 0, n_srs;
384152a6
TK
617 uschar *res;
618 uschar *usedomain;
619
620 /* What are we doing? */
621 if(Ustrcmp(ob->srs, "forward") == 0)
622 srs_action = 1;
623 else if(Ustrcmp(ob->srs, "reverseandforward") == 0)
8523533c 624 {
384152a6 625 srs_action = 3;
8e669ac1 626
384152a6
TK
627 if((ob->srs_dbinsert == NULL) ^ (ob->srs_dbselect == NULL))
628 return DEFER;
629 }
630 else if(Ustrcmp(ob->srs, "reverse") == 0)
631 srs_action = 2;
632
633 /* Reverse SRS */
634 if(srs_action & 2)
635 {
8523533c 636 srs_orig_recipient = addr->address;
384152a6 637
8523533c 638 eximsrs_init();
384152a6
TK
639 if(ob->srs_dbselect)
640 eximsrs_db_set(TRUE, ob->srs_dbselect);
130e9641 641/* Comment this out for now...
384152a6
TK
642// else
643// eximsrs_db_set(TRUE, NULL);
130e9641 644*/
384152a6
TK
645
646 if((n_srs = eximsrs_reverse(&res, addr->address)) == OK)
647 {
648 srs_recipient = res;
649 DEBUG(D_any)
650 debug_printf("SRS (reverse): Recipient '%s' rewritten to '%s'\n", srs_orig_recipient, srs_recipient);
651 }
652
653 eximsrs_done();
654
655 if(n_srs != OK)
8523533c 656 return n_srs;
384152a6
TK
657 }
658
659 /* Forward SRS */
660 /* No point in actually performing SRS if we are just verifying a recipient */
fd6de02e
PH
661 if((srs_action & 1) && verify == v_none &&
662 (sender_address ? sender_address[0] != 0 : FALSE))
384152a6
TK
663 {
664
665 srs_orig_sender = sender_address;
666 eximsrs_init();
667 if(ob->srs_dbinsert)
668 eximsrs_db_set(FALSE, ob->srs_dbinsert);
130e9641 669/* Comment this out for now...
384152a6
TK
670// else
671// eximsrs_db_set(FALSE, NULL);
130e9641 672*/
384152a6 673
dc8091e7
JH
674 if (!(usedomain = ob->srs_alias ? expand_string(ob->srs_alias) : NULL))
675 usedomain = string_copy(deliver_domain);
384152a6
TK
676
677 if((n_srs = eximsrs_forward(&res, sender_address, usedomain)) == OK)
678 {
679 addr_prop.srs_sender = res;
680 DEBUG(D_any)
681 debug_printf("SRS (forward): Sender '%s' rewritten to '%s'\n", srs_orig_sender, res);
682 }
683
8523533c 684 eximsrs_done();
384152a6
TK
685
686 if(n_srs != OK)
687 return n_srs;
8523533c 688 }
384152a6 689 }
8523533c
TK
690 }
691#endif
692
0756eb3c
PH
693/* Call the function that interprets redirection data, either inline or from a
694file. This is a separate function so that the system filter can use it. It will
695run the function in a subprocess if necessary. If qualify_preserve_domain is
696set, temporarily reset qualify_domain_recipient to the current domain so that
697any unqualified addresses get qualified with the same domain as the incoming
698address. Otherwise, if a local qualify_domain is provided, set that up. */
699
700if (ob->qualify_preserve_domain)
701 qualify_domain_recipient = addr->domain;
f3ebb786 702else if (ob->qualify_domain)
0756eb3c
PH
703 {
704 uschar *new_qdr = rf_expand_data(addr, ob->qualify_domain, &xrc);
f3ebb786 705 if (!new_qdr) return xrc;
0756eb3c
PH
706 qualify_domain_recipient = new_qdr;
707 }
708
709redirect.owners = ob->owners;
710redirect.owngroups = ob->owngroups;
711redirect.modemask = ob->modemask;
712redirect.check_owner = ob->check_owner;
713redirect.check_group = ob->check_group;
714redirect.pw = pw;
715
f3ebb786
JH
716redirect.string = (redirect.isfile = (ob->file != NULL))
717 ? ob->file : ob->data;
0756eb3c
PH
718
719frc = rda_interpret(&redirect, options, ob->include_directory,
efd9a422
MH
720 ob->sieve_vacation_directory, ob->sieve_enotify_mailto_owner,
721 ob->sieve_useraddress, ob->sieve_subaddress, &ugid, &generated,
722 &(addr->message), ob->skip_syntax_errors? &eblock : NULL, &filtertype,
723 string_sprintf("%s router (recipient is %s)", rblock->name, addr->address));
0756eb3c
PH
724
725qualify_domain_recipient = save_qualify_domain_recipient;
726
727/* Handle exceptional returns from filtering or processing an address list.
728For FAIL and FREEZE we honour any previously set up deliveries by a filter. */
729
730switch (frc)
731 {
732 case FF_NONEXIST:
f3ebb786
JH
733 addr->message = addr->user_message = NULL;
734 return DECLINE;
0756eb3c
PH
735
736 case FF_BLACKHOLE:
f3ebb786
JH
737 DEBUG(D_route) debug_printf("address :blackhole:d\n");
738 generated = NULL;
739 discarded = US":blackhole:";
740 frc = FF_DELIVERED;
741 break;
0756eb3c 742
f3ebb786
JH
743 /* FF_DEFER and FF_FAIL can arise only as a result of explicit commands
744 (:defer: or :fail: in an alias file or "fail" in a filter). If a configured
745 message was supplied, allow it to be included in an SMTP response after
746 verifying. Remove any SMTP code if it is not allowed. */
0756eb3c
PH
747
748 case FF_DEFER:
f3ebb786
JH
749 yield = DEFER;
750 goto SORT_MESSAGE;
0756eb3c
PH
751
752 case FF_FAIL:
f3ebb786
JH
753 if ((xrc = sort_errors_and_headers(rblock, addr, verify, &addr_prop)) != OK)
754 return xrc;
755 add_generated(rblock, addr_new, addr, generated, &addr_prop, &ugid, pw);
756 yield = FAIL;
757
758 SORT_MESSAGE:
759 if (!addr->message)
760 addr->message = yield == FAIL ? US"forced rejection" : US"forced defer";
761 else
a5bd321b 762 {
f3ebb786
JH
763 int ovector[3];
764 if (ob->forbid_smtp_code &&
765 pcre_exec(regex_smtp_code, NULL, CS addr->message,
766 Ustrlen(addr->message), 0, PCRE_EOPT,
767 ovector, sizeof(ovector)/sizeof(int)) >= 0)
768 {
769 DEBUG(D_route) debug_printf("SMTP code at start of error message "
770 "is ignored because forbid_smtp_code is set\n");
771 addr->message += ovector[1];
772 }
773 addr->user_message = addr->message;
774 setflag(addr, af_pass_message);
a5bd321b 775 }
f3ebb786 776 return yield;
0756eb3c 777
f3ebb786
JH
778 /* As in the case of a system filter, a freeze does not happen after a manual
779 thaw. In case deliveries were set up by the filter, we set the child count
780 high so that their completion does not mark the original address done. */
0756eb3c
PH
781
782 case FF_FREEZE:
f3ebb786
JH
783 if (!f.deliver_manual_thaw)
784 {
785 if ((xrc = sort_errors_and_headers(rblock, addr, verify, &addr_prop))
786 != OK) return xrc;
787 add_generated(rblock, addr_new, addr, generated, &addr_prop, &ugid, pw);
788 if (addr->message == NULL) addr->message = US"frozen by filter";
789 addr->special_action = SPECIAL_FREEZE;
790 addr->child_count = 9999;
791 return DEFER;
792 }
793 frc = FF_NOTDELIVERED;
794 break;
0756eb3c 795
f3ebb786 796 /* Handle syntax errors and :include: failures and lookup defers */
0756eb3c
PH
797
798 case FF_ERROR:
799 case FF_INCLUDEFAIL:
800
f3ebb786
JH
801 /* If filtertype is still FILTER_UNSET, it means that the redirection data
802 was never inspected, so the error was an expansion failure or failure to open
803 the file, or whatever. In these cases, the existing error message is probably
804 sufficient. */
0756eb3c 805
f3ebb786 806 if (filtertype == FILTER_UNSET) return DEFER;
0756eb3c 807
f3ebb786
JH
808 /* If it was a filter and skip_syntax_errors is set, we want to set up
809 the error message so that it can be logged and mailed to somebody. */
0756eb3c 810
f3ebb786
JH
811 if (filtertype != FILTER_FORWARD && ob->skip_syntax_errors)
812 {
813 eblock = store_get(sizeof(error_block), FALSE);
814 eblock->next = NULL;
815 eblock->text1 = addr->message;
816 eblock->text2 = NULL;
817 addr->message = addr->user_message = NULL;
818 }
0756eb3c 819
f3ebb786 820 /* Otherwise set up the error for the address and defer. */
0756eb3c 821
f3ebb786
JH
822 else
823 {
824 addr->basic_errno = ERRNO_BADREDIRECT;
825 addr->message = string_sprintf("error in %s %s: %s",
826 filtertype == FILTER_FORWARD ? "redirect" : "filter",
827 ob->data ? "data" : "file",
828 addr->message);
829 return DEFER;
830 }
0756eb3c
PH
831 }
832
833
834/* Yield is either FF_DELIVERED (significant action) or FF_NOTDELIVERED (no
835significant action). Before dealing with these, however, we must handle the
836effect of skip_syntax_errors.
837
838If skip_syntax_errors was set and there were syntax errors in an address list,
839error messages will be present in eblock. Log them and send a message if so
840configured. We cannot do this earlier, because the error message must not be
841sent as the local user. If there were no valid addresses, generated will be
842NULL. In this case, the router declines.
843
844For a filter file, the error message has been fudged into an eblock. After
845dealing with it, the router declines. */
846
847if (eblock != NULL)
848 {
849 if (!moan_skipped_syntax_errors(
fd6de02e
PH
850 rblock->name, /* For message content */
851 eblock, /* Ditto */
8768d548 852 (verify != v_none || f.address_test_mode)?
fd6de02e
PH
853 NULL : ob->syntax_errors_to, /* Who to mail */
854 generated != NULL, /* True if not all failed */
855 ob->syntax_errors_text)) /* Custom message */
0756eb3c
PH
856 return DEFER;
857
858 if (filtertype != FILTER_FORWARD || generated == NULL)
859 {
860 addr->message = US"syntax error in redirection data";
861 return DECLINE;
862 }
863 }
864
865/* Sort out the errors address and any header modifications, and handle the
866generated addresses, if any. If there are no generated addresses, we must avoid
867calling sort_errors_and_headers() in case this router declines - that function
868may modify the errors_address field in the current address, and we don't want
869to do that for a decline. */
870
871if (generated != NULL)
872 {
873 if ((xrc = sort_errors_and_headers(rblock, addr, verify, &addr_prop)) != OK)
874 return xrc;
875 add_generated(rblock, addr_new, addr, generated, &addr_prop, &ugid, pw);
876 }
877
878/* FF_DELIVERED with no generated addresses is what we get when an address list
879contains :blackhole: or a filter contains "seen finish" without having
880generated anything. Log what happened to this address, and return DISCARD. */
881
882if (frc == FF_DELIVERED)
883 {
8768d548 884 if (generated == NULL && verify == v_none && !f.address_test_mode)
0756eb3c
PH
885 {
886 log_write(0, LOG_MAIN, "=> %s <%s> R=%s", discarded, addr->address,
887 rblock->name);
888 yield = DISCARD;
889 }
890 }
891
892/* For an address list, FF_NOTDELIVERED always means that no addresses were
893generated. For a filter, addresses may or may not have been generated. If none
894were, it's the same as an empty address list, and the router declines. However,
895if addresses were generated, we can't just decline because successful delivery
896of the base address gets it marked "done", so deferred generated addresses
897never get tried again. We have to generate a new version of the base address,
898as if there were a "deliver" command in the filter file, with the original
899address as parent. */
900
901else
902 {
903 address_item *next;
904
905 if (generated == NULL) return DECLINE;
906
907 next = deliver_make_addr(addr->address, FALSE);
908 next->parent = addr;
909 addr->child_count++;
910 next->next = *addr_new;
911 *addr_new = next;
912
7eb0e5d2 913 /* Set the data that propagates. */
0756eb3c 914
d43cbe25 915 next->prop = addr_prop;
0756eb3c
PH
916
917 DEBUG(D_route) debug_printf("%s router autogenerated %s\n%s%s%s",
918 rblock->name,
919 next->address,
920 (addr_prop.errors_address != NULL)? " errors to " : "",
921 (addr_prop.errors_address != NULL)? addr_prop.errors_address : US"",
922 (addr_prop.errors_address != NULL)? "\n" : "");
923 }
924
925/* Control gets here only when the address has been completely handled. Put the
926original address onto the succeed queue so that any retry items that get
927attached to it get processed. */
928
929addr->next = *addr_succeed;
930*addr_succeed = addr;
931
932return yield;
933}
934
d185889f 935#endif /*!MACRO_PREDEF*/
0756eb3c 936/* End of routers/redirect.c */