1 /* $Cambridge: exim/src/src/routers/redirect.c,v 1.23 2009/11/16 19:50:38 nm4 Exp $ */
3 /*************************************************
4 * Exim - an Internet mail transport agent *
5 *************************************************/
7 /* Copyright (c) University of Cambridge 1995 - 2009 */
8 /* See the file NOTICE for conditions of use and distribution. */
12 #include "rf_functions.h"
17 /* Options specific to the redirect router. */
19 optionlist redirect_router_options[] = {
20 { "allow_defer", opt_bit | (RDON_DEFER << 16),
21 (void *)offsetof(redirect_router_options_block, bit_options) },
22 { "allow_fail", opt_bit | (RDON_FAIL << 16),
23 (void *)offsetof(redirect_router_options_block, bit_options) },
24 { "allow_filter", opt_bit | (RDON_FILTER << 16),
25 (void *)offsetof(redirect_router_options_block, bit_options) },
26 { "allow_freeze", opt_bit | (RDON_FREEZE << 16),
27 (void *)offsetof(redirect_router_options_block, bit_options) },
28 { "check_ancestor", opt_bool,
29 (void *)offsetof(redirect_router_options_block, check_ancestor) },
30 { "check_group", opt_bool,
31 (void *)offsetof(redirect_router_options_block, check_group) },
32 { "check_owner", opt_bool,
33 (void *)offsetof(redirect_router_options_block, check_owner) },
34 { "data", opt_stringptr,
35 (void *)offsetof(redirect_router_options_block, data) },
36 { "directory_transport",opt_stringptr,
37 (void *)offsetof(redirect_router_options_block, directory_transport_name) },
38 { "file", opt_stringptr,
39 (void *)offsetof(redirect_router_options_block, file) },
40 { "file_transport", opt_stringptr,
41 (void *)offsetof(redirect_router_options_block, file_transport_name) },
42 { "filter_prepend_home",opt_bit | (RDON_PREPEND_HOME << 16),
43 (void *)offsetof(redirect_router_options_block, bit_options) },
44 { "forbid_blackhole", opt_bit | (RDON_BLACKHOLE << 16),
45 (void *)offsetof(redirect_router_options_block, bit_options) },
46 { "forbid_exim_filter", opt_bit | (RDON_EXIM_FILTER << 16),
47 (void *)offsetof(redirect_router_options_block, bit_options) },
48 { "forbid_file", opt_bool,
49 (void *)offsetof(redirect_router_options_block, forbid_file) },
50 { "forbid_filter_dlfunc", opt_bit | (RDON_DLFUNC << 16),
51 (void *)offsetof(redirect_router_options_block, bit_options) },
52 { "forbid_filter_existstest", opt_bit | (RDON_EXISTS << 16),
53 (void *)offsetof(redirect_router_options_block, bit_options) },
54 { "forbid_filter_logwrite",opt_bit | (RDON_LOG << 16),
55 (void *)offsetof(redirect_router_options_block, bit_options) },
56 { "forbid_filter_lookup", opt_bit | (RDON_LOOKUP << 16),
57 (void *)offsetof(redirect_router_options_block, bit_options) },
58 { "forbid_filter_perl", opt_bit | (RDON_PERL << 16),
59 (void *)offsetof(redirect_router_options_block, bit_options) },
60 { "forbid_filter_readfile", opt_bit | (RDON_READFILE << 16),
61 (void *)offsetof(redirect_router_options_block, bit_options) },
62 { "forbid_filter_readsocket", opt_bit | (RDON_READSOCK << 16),
63 (void *)offsetof(redirect_router_options_block, bit_options) },
64 { "forbid_filter_reply",opt_bool,
65 (void *)offsetof(redirect_router_options_block, forbid_filter_reply) },
66 { "forbid_filter_run", opt_bit | (RDON_RUN << 16),
67 (void *)offsetof(redirect_router_options_block, bit_options) },
68 { "forbid_include", opt_bit | (RDON_INCLUDE << 16),
69 (void *)offsetof(redirect_router_options_block, bit_options) },
70 { "forbid_pipe", opt_bool,
71 (void *)offsetof(redirect_router_options_block, forbid_pipe) },
72 { "forbid_sieve_filter",opt_bit | (RDON_SIEVE_FILTER << 16),
73 (void *)offsetof(redirect_router_options_block, bit_options) },
74 { "forbid_smtp_code", opt_bool,
75 (void *)offsetof(redirect_router_options_block, forbid_smtp_code) },
76 { "hide_child_in_errmsg", opt_bool,
77 (void *)offsetof(redirect_router_options_block, hide_child_in_errmsg) },
78 { "ignore_eacces", opt_bit | (RDON_EACCES << 16),
79 (void *)offsetof(redirect_router_options_block, bit_options) },
80 { "ignore_enotdir", opt_bit | (RDON_ENOTDIR << 16),
81 (void *)offsetof(redirect_router_options_block, bit_options) },
82 { "include_directory", opt_stringptr,
83 (void *)offsetof(redirect_router_options_block, include_directory) },
84 { "modemask", opt_octint,
85 (void *)offsetof(redirect_router_options_block, modemask) },
86 { "one_time", opt_bool,
87 (void *)offsetof(redirect_router_options_block, one_time) },
88 { "owners", opt_uidlist,
89 (void *)offsetof(redirect_router_options_block, owners) },
90 { "owngroups", opt_gidlist,
91 (void *)offsetof(redirect_router_options_block, owngroups) },
92 { "pipe_transport", opt_stringptr,
93 (void *)offsetof(redirect_router_options_block, pipe_transport_name) },
94 { "qualify_domain", opt_stringptr,
95 (void *)offsetof(redirect_router_options_block, qualify_domain) },
96 { "qualify_preserve_domain", opt_bool,
97 (void *)offsetof(redirect_router_options_block, qualify_preserve_domain) },
98 { "repeat_use", opt_bool | opt_public,
99 (void *)offsetof(router_instance, repeat_use) },
100 { "reply_transport", opt_stringptr,
101 (void *)offsetof(redirect_router_options_block, reply_transport_name) },
102 { "rewrite", opt_bit | (RDON_REWRITE << 16),
103 (void *)offsetof(redirect_router_options_block, bit_options) },
104 { "sieve_enotify_mailto_owner", opt_stringptr,
105 (void *)offsetof(redirect_router_options_block, sieve_enotify_mailto_owner) },
106 { "sieve_subaddress", opt_stringptr,
107 (void *)offsetof(redirect_router_options_block, sieve_subaddress) },
108 { "sieve_useraddress", opt_stringptr,
109 (void *)offsetof(redirect_router_options_block, sieve_useraddress) },
110 { "sieve_vacation_directory", opt_stringptr,
111 (void *)offsetof(redirect_router_options_block, sieve_vacation_directory) },
112 { "skip_syntax_errors", opt_bool,
113 (void *)offsetof(redirect_router_options_block, skip_syntax_errors) },
114 #ifdef EXPERIMENTAL_SRS
115 { "srs", opt_stringptr,
116 (void *)offsetof(redirect_router_options_block, srs) },
117 { "srs_alias", opt_stringptr,
118 (void *)offsetof(redirect_router_options_block, srs_alias) },
119 { "srs_condition", opt_stringptr,
120 (void *)offsetof(redirect_router_options_block, srs_condition) },
121 { "srs_dbinsert", opt_stringptr,
122 (void *)offsetof(redirect_router_options_block, srs_dbinsert) },
123 { "srs_dbselect", opt_stringptr,
124 (void *)offsetof(redirect_router_options_block, srs_dbselect) },
126 { "syntax_errors_text", opt_stringptr,
127 (void *)offsetof(redirect_router_options_block, syntax_errors_text) },
128 { "syntax_errors_to", opt_stringptr,
129 (void *)offsetof(redirect_router_options_block, syntax_errors_to) }
132 /* Size of the options list. An extern variable has to be used so that its
133 address can appear in the tables drtables.c. */
135 int redirect_router_options_count =
136 sizeof(redirect_router_options)/sizeof(optionlist);
138 /* Default private options block for the redirect router. */
140 redirect_router_options_block redirect_router_option_defaults = {
141 NULL, /* directory_transport */
142 NULL, /* file_transport */
143 NULL, /* pipe_transport */
144 NULL, /* reply_transport */
146 NULL, /* directory_transport_name */
149 NULL, /* file_transport_name */
150 NULL, /* include_directory */
151 NULL, /* pipe_transport_name */
152 NULL, /* reply_transport_name */
153 NULL, /* sieve_subaddress */
154 NULL, /* sieve_useraddress */
155 NULL, /* sieve_vacation_directory */
156 NULL, /* sieve_enotify_mailto_owner */
157 NULL, /* syntax_errors_text */
158 NULL, /* syntax_errors_to */
159 NULL, /* qualify_domain */
161 NULL, /* owngroups */
162 #ifdef EXPERIMENTAL_SRS
164 NULL, /* srs_alias */
165 NULL, /* srs_condition */
166 NULL, /* srs_dbinsert */
167 NULL, /* srs_dbselect */
170 RDO_REWRITE | RDO_PREPEND_HOME, /* bit_options */
171 FALSE, /* check_ancestor */
172 TRUE_UNSET, /* check_owner */
173 TRUE_UNSET, /* check_group */
174 FALSE, /* forbid_file */
175 FALSE, /* forbid_filter_reply */
176 FALSE, /* forbid_pipe */
177 FALSE, /* forbid_smtp_code */
178 FALSE, /* hide_child_in_errmsg */
179 FALSE, /* one_time */
180 FALSE, /* qualify_preserve_domain */
181 FALSE /* skip_syntax_errors */
186 /*************************************************
187 * Initialization entry point *
188 *************************************************/
190 /* Called for each instance, after its options have been read, to enable
191 consistency checks to be done, or anything else that needs to be set up. */
193 void redirect_router_init(router_instance *rblock)
195 redirect_router_options_block *ob =
196 (redirect_router_options_block *)(rblock->options_block);
198 /* Either file or data must be set, but not both */
200 if ((ob->file == NULL) == (ob->data == NULL))
201 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
202 "%sone of \"file\" or \"data\" must be specified",
203 rblock->name, (ob->file == NULL)? "" : "only ");
205 /* Onetime aliases can only be real addresses. Headers can't be manipulated.
206 The combination of one_time and unseen is not allowed. We can't check the
207 expansion of "unseen" here, but we assume that if it is set to anything other
208 than false, there is likely to be a problem. */
212 ob->forbid_pipe = ob->forbid_file = ob->forbid_filter_reply = TRUE;
213 if (rblock->extra_headers != NULL || rblock->remove_headers != NULL)
214 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
215 "\"headers_add\" and \"headers_remove\" are not permitted with "
216 "\"one_time\"", rblock->name);
217 if (rblock->unseen || rblock->expand_unseen != NULL)
218 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
219 "\"unseen\" may not be used with \"one_time\"", rblock->name);
222 /* The defaults for check_owner and check_group depend on other settings. The
223 defaults are: Check the owner if check_local_user or owners is set; check the
224 group if check_local_user is set without a restriction on the group write bit,
225 or if owngroups is set. */
227 if (ob->check_owner == TRUE_UNSET)
228 ob->check_owner = rblock->check_local_user ||
229 (ob->owners != NULL && ob->owners[0] != 0);
231 if (ob->check_group == TRUE_UNSET)
232 ob->check_group = (rblock->check_local_user && (ob->modemask & 020) == 0) ||
233 (ob->owngroups != NULL && ob->owngroups[0] != 0);
235 /* If explicit qualify domain set, the preserve option is locked out */
237 if (ob->qualify_domain != NULL && ob->qualify_preserve_domain)
238 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
239 "only one of \"qualify_domain\" or \"qualify_preserve_domain\" must be set",
242 /* If allow_filter is set, either user or check_local_user must be set. */
244 if (!rblock->check_local_user &&
246 rblock->expand_uid == NULL &&
247 (ob->bit_options & RDO_FILTER) != 0)
248 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
249 "\"user\" or \"check_local_user\" must be set with \"allow_filter\"",
255 /*************************************************
256 * Get errors address and header mods *
257 *************************************************/
259 /* This function is called when new addresses are generated, in order to
260 sort out errors address and header modifications. We put the errors address
261 into the parent address (even though it is never used from there because that
262 address is never transported) so that it can be retrieved if any of the
263 children gets routed by an "unseen" router. The clone of the child that is
264 passed on must have the original errors_address value.
267 rblock the router control block
268 addr the address being routed
269 verify v_none/v_recipient/v_sender/v_expn
270 addr_prop point to the propagated block, which is where the
271 new values are to be placed
273 Returns: the result of rf_get_errors_address() or rf_get_munge_headers(),
274 which is either OK or DEFER
278 sort_errors_and_headers(router_instance *rblock, address_item *addr,
279 int verify, address_item_propagated *addr_prop)
281 int frc = rf_get_errors_address(addr, rblock, verify,
282 &(addr_prop->errors_address));
283 if (frc != OK) return frc;
284 addr->p.errors_address = addr_prop->errors_address;
285 return rf_get_munge_headers(addr, rblock, &(addr_prop->extra_headers),
286 &(addr_prop->remove_headers));
291 /*************************************************
292 * Process a set of generated new addresses *
293 *************************************************/
295 /* This function sets up a set of newly generated child addresses and puts them
296 on the new address chain. Copy in the uid, gid and permission flags for use by
297 pipes and files, set the parent, and "or" its af_ignore_error flag. Also record
298 the setting for any starting router.
300 If the generated address is the same as one of its ancestors, and the
301 check_ancestor flag is set, do not use this generated address, but replace it
302 with a copy of the input address. This is to cope with cases where A is aliased
303 to B and B has a .forward file pointing to A, though it is usually set on the
304 forwardfile rather than the aliasfile. We can't just pass on the old
305 address by returning FAIL, because it must act as a general parent for
306 generated addresses, and only get marked "done" when all its children are
311 addr_new new address chain
312 addr original address
313 generated list of generated addresses
314 addr_prop the propagated block, containing the errors_address,
315 header modification stuff, and address_data
316 ugidptr points to uid/gid data for files, pipes, autoreplies
317 pw password entry, set if ob->check_local_user is TRUE
323 add_generated(router_instance *rblock, address_item **addr_new,
324 address_item *addr, address_item *generated,
325 address_item_propagated *addr_prop, ugid_block *ugidptr, struct passwd *pw)
327 redirect_router_options_block *ob =
328 (redirect_router_options_block *)(rblock->options_block);
330 while (generated != NULL)
332 address_item *parent;
333 address_item *next = generated;
334 uschar *errors_address = next->p.errors_address;
336 generated = next->next;
338 orflag(next, addr, af_ignore_error);
339 next->start_router = rblock->redirect_router;
340 if (addr->child_count == SHRT_MAX)
341 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s router generated more than %d "
342 "child addresses for <%s>", rblock->name, SHRT_MAX, addr->address);
345 next->next = *addr_new;
348 /* Don't do the "one_time" thing for the first pass of a 2-stage queue run. */
350 if (ob->one_time && !queue_2stage)
352 for (parent = addr; parent->parent != NULL; parent = parent->parent);
353 next->onetime_parent = parent->address;
356 if (ob->hide_child_in_errmsg) setflag(next, af_hide_child);
358 /* If check_ancestor is set, we want to know if any ancestor of this address
359 is the address we are about to generate. The check must be done caselessly
360 unless the ancestor was routed by a case-sensitive router. */
362 if (ob->check_ancestor)
364 for (parent = addr; parent != NULL; parent = parent->parent)
366 if (((parent->router != NULL && parent->router->caseful_local_part)?
367 Ustrcmp(next->address, parent->address)
369 strcmpic(next->address, parent->address)
372 DEBUG(D_route) debug_printf("generated parent replaced by child\n");
373 next->address = string_copy(addr->address);
379 /* A user filter may, under some circumstances, set up an errors address.
380 If so, we must take care to re-instate it when we copy in the propagated
381 data so that it overrides any errors_to setting on the router. */
383 next->p = *addr_prop;
384 if (errors_address != NULL) next->p.errors_address = errors_address;
386 /* For pipes, files, and autoreplies, record this router as handling them,
387 because they don't go through the routing process again. Then set up uid,
388 gid, home and current directories for transporting. */
390 if (testflag(next, af_pfr))
392 next->router = rblock;
393 rf_set_ugid(next, ugidptr); /* Will contain pw values if not overridden */
395 /* When getting the home directory out of the password information, wrap it
396 in \N...\N to avoid expansion later. In Cygwin, home directories can
397 contain $ characters. */
399 if (rblock->home_directory != NULL)
400 next->home_dir = rblock->home_directory;
401 else if (rblock->check_local_user)
402 next->home_dir = string_sprintf("\\N%s\\N", pw->pw_dir);
403 else if (rblock->router_home_directory != NULL &&
404 testflag(addr, af_home_expanded))
406 next->home_dir = deliver_home;
407 setflag(next, af_home_expanded);
410 next->current_dir = rblock->current_directory;
412 /* Permission options */
414 if (!ob->forbid_pipe) setflag(next, af_allow_pipe);
415 if (!ob->forbid_file) setflag(next, af_allow_file);
416 if (!ob->forbid_filter_reply) setflag(next, af_allow_reply);
418 /* If the transport setting fails, the error gets picked up at the outer
419 level from the setting of basic_errno in the address. */
421 if (next->address[0] == '|')
423 address_pipe = next->address;
424 if (rf_get_transport(ob->pipe_transport_name, &(ob->pipe_transport),
425 next, rblock->name, US"pipe_transport"))
426 next->transport = ob->pipe_transport;
429 else if (next->address[0] == '>')
431 if (rf_get_transport(ob->reply_transport_name, &(ob->reply_transport),
432 next, rblock->name, US"reply_transport"))
433 next->transport = ob->reply_transport;
435 else /* must be file or directory */
437 int len = Ustrlen(next->address);
438 address_file = next->address;
439 if (next->address[len-1] == '/')
441 if (rf_get_transport(ob->directory_transport_name,
442 &(ob->directory_transport), next, rblock->name,
443 US"directory_transport"))
444 next->transport = ob->directory_transport;
448 if (rf_get_transport(ob->file_transport_name, &(ob->file_transport),
449 next, rblock->name, US"file_transport"))
450 next->transport = ob->file_transport;
458 debug_printf("%s router generated %s\n %serrors_to=%s transport=%s\n",
461 testflag(next, af_pfr)? "pipe, file, or autoreply\n " : "",
462 next->p.errors_address,
463 (next->transport == NULL)? US"NULL" : next->transport->name);
465 if (testflag(next, af_uid_set))
466 debug_printf(" uid=%ld ", (long int)(next->uid));
468 debug_printf(" uid=unset ");
470 if (testflag(next, af_gid_set))
471 debug_printf("gid=%ld ", (long int)(next->gid));
473 debug_printf("gid=unset ");
475 debug_printf("home=%s\n", next->home_dir);
481 /*************************************************
483 *************************************************/
485 /* See local README for interface description. This router returns:
488 . empty address list, or filter did nothing significant
491 . verifying the errors address caused a deferment or a big disaster such
492 as an expansion failure (rf_get_errors_address)
493 . expanding a headers_{add,remove} string caused a deferment or another
494 expansion error (rf_get_munge_headers)
495 . :defer: or "freeze" in a filter
496 . error in address list or filter
497 . skipped syntax errors, but failed to send the message
500 . address was :blackhole:d or "seen finish"ed
506 . new addresses added to addr_new
509 int redirect_router_entry(
510 router_instance *rblock, /* data for this instantiation */
511 address_item *addr, /* address we are working on */
512 struct passwd *pw, /* passwd entry after check_local_user */
513 int verify, /* v_none/v_recipient/v_sender/v_expn */
514 address_item **addr_local, /* add it to this if it's local */
515 address_item **addr_remote, /* add it to this if it's remote */
516 address_item **addr_new, /* put new addresses on here */
517 address_item **addr_succeed) /* put old address here on success */
519 redirect_router_options_block *ob =
520 (redirect_router_options_block *)(rblock->options_block);
521 address_item *generated = NULL;
522 uschar *save_qualify_domain_recipient = qualify_domain_recipient;
523 uschar *discarded = US"discarded";
524 address_item_propagated addr_prop;
525 error_block *eblock = NULL;
527 redirect_block redirect;
528 int filtertype = FILTER_UNSET;
530 int options = ob->bit_options;
534 addr_local = addr_local; /* Keep picky compilers happy */
535 addr_remote = addr_remote;
537 /* Initialize the data to be propagated to the children */
539 addr_prop.address_data = deliver_address_data;
540 addr_prop.domain_data = deliver_domain_data;
541 addr_prop.localpart_data = deliver_localpart_data;
542 addr_prop.errors_address = NULL;
543 addr_prop.extra_headers = NULL;
544 addr_prop.remove_headers = NULL;
546 #ifdef EXPERIMENTAL_SRS
547 addr_prop.srs_sender = NULL;
550 /* When verifying and testing addresses, the "logwrite" command in filters
553 if (verify == v_none && !address_test_mode) options |= RDO_REALLOG;
555 /* Sort out the fixed or dynamic uid/gid. This uid is used (a) for reading the
556 file (and interpreting a filter) and (b) for running the transports for
557 generated file and pipe addresses. It is not (necessarily) the same as the uids
558 that may own the file. Exim panics if an expanded string is not a number and
559 can't be found in the password file. Other errors set the freezing bit. */
561 if (!rf_get_ugid(rblock, addr, &ugid)) return DEFER;
563 if (!ugid.uid_set && pw != NULL)
565 ugid.uid = pw->pw_uid;
569 if (!ugid.gid_set && pw != NULL)
571 ugid.gid = pw->pw_gid;
575 #ifdef EXPERIMENTAL_SRS
576 /* Perform SRS on recipient/return-path as required */
582 if(ob->srs_condition != NULL)
583 usesrs = expand_check_condition(ob->srs_condition, "srs_condition expansion failed", NULL);
587 int srs_action = 0, n_srs;
591 /* What are we doing? */
592 if(Ustrcmp(ob->srs, "forward") == 0)
594 else if(Ustrcmp(ob->srs, "reverseandforward") == 0)
598 if((ob->srs_dbinsert == NULL) ^ (ob->srs_dbselect == NULL))
601 else if(Ustrcmp(ob->srs, "reverse") == 0)
607 srs_orig_recipient = addr->address;
611 eximsrs_db_set(TRUE, ob->srs_dbselect);
612 /* Comment this out for now...
614 // eximsrs_db_set(TRUE, NULL);
617 if((n_srs = eximsrs_reverse(&res, addr->address)) == OK)
621 debug_printf("SRS (reverse): Recipient '%s' rewritten to '%s'\n", srs_orig_recipient, srs_recipient);
631 /* No point in actually performing SRS if we are just verifying a recipient */
632 if((srs_action & 1) && verify == v_none &&
633 (sender_address ? sender_address[0] != 0 : FALSE))
636 srs_orig_sender = sender_address;
639 eximsrs_db_set(FALSE, ob->srs_dbinsert);
640 /* Comment this out for now...
642 // eximsrs_db_set(FALSE, NULL);
645 if(ob->srs_alias != NULL ? (usedomain = expand_string(ob->srs_alias)) == NULL : 1)
646 usedomain = deliver_domain;
648 if((n_srs = eximsrs_forward(&res, sender_address, usedomain)) == OK)
650 addr_prop.srs_sender = res;
652 debug_printf("SRS (forward): Sender '%s' rewritten to '%s'\n", srs_orig_sender, res);
664 /* Call the function that interprets redirection data, either inline or from a
665 file. This is a separate function so that the system filter can use it. It will
666 run the function in a subprocess if necessary. If qualify_preserve_domain is
667 set, temporarily reset qualify_domain_recipient to the current domain so that
668 any unqualified addresses get qualified with the same domain as the incoming
669 address. Otherwise, if a local qualify_domain is provided, set that up. */
671 if (ob->qualify_preserve_domain)
672 qualify_domain_recipient = addr->domain;
673 else if (ob->qualify_domain != NULL)
675 uschar *new_qdr = rf_expand_data(addr, ob->qualify_domain, &xrc);
676 if (new_qdr == NULL) return xrc;
677 qualify_domain_recipient = new_qdr;
680 redirect.owners = ob->owners;
681 redirect.owngroups = ob->owngroups;
682 redirect.modemask = ob->modemask;
683 redirect.check_owner = ob->check_owner;
684 redirect.check_group = ob->check_group;
687 if (ob->file != NULL)
689 redirect.string = ob->file;
690 redirect.isfile = TRUE;
694 redirect.string = ob->data;
695 redirect.isfile = FALSE;
698 frc = rda_interpret(&redirect, options, ob->include_directory,
699 ob->sieve_vacation_directory, ob->sieve_enotify_mailto_owner,
700 ob->sieve_useraddress, ob->sieve_subaddress, &ugid, &generated,
701 &(addr->message), ob->skip_syntax_errors? &eblock : NULL, &filtertype,
702 string_sprintf("%s router (recipient is %s)", rblock->name, addr->address));
704 qualify_domain_recipient = save_qualify_domain_recipient;
706 /* Handle exceptional returns from filtering or processing an address list.
707 For FAIL and FREEZE we honour any previously set up deliveries by a filter. */
712 addr->message = addr->user_message = NULL;
716 DEBUG(D_route) debug_printf("address :blackhole:d\n");
718 discarded = US":blackhole:";
722 /* FF_DEFER and FF_FAIL can arise only as a result of explicit commands
723 (:defer: or :fail: in an alias file or "fail" in a filter). If a configured
724 message was supplied, allow it to be included in an SMTP response after
725 verifying. Remove any SMTP code if it is not allowed. */
732 if ((xrc = sort_errors_and_headers(rblock, addr, verify, &addr_prop)) != OK)
734 add_generated(rblock, addr_new, addr, generated, &addr_prop, &ugid, pw);
738 if (addr->message == NULL)
739 addr->message = (yield == FAIL)? US"forced rejection" : US"forced defer";
743 if (ob->forbid_smtp_code &&
744 pcre_exec(regex_smtp_code, NULL, CS addr->message,
745 Ustrlen(addr->message), 0, PCRE_EOPT,
746 ovector, sizeof(ovector)/sizeof(int)) >= 0)
748 DEBUG(D_route) debug_printf("SMTP code at start of error message "
749 "is ignored because forbid_smtp_code is set\n");
750 addr->message += ovector[1];
752 addr->user_message = addr->message;
753 setflag(addr, af_pass_message);
757 /* As in the case of a system filter, a freeze does not happen after a manual
758 thaw. In case deliveries were set up by the filter, we set the child count
759 high so that their completion does not mark the original address done. */
762 if (!deliver_manual_thaw)
764 if ((xrc = sort_errors_and_headers(rblock, addr, verify, &addr_prop))
766 add_generated(rblock, addr_new, addr, generated, &addr_prop, &ugid, pw);
767 if (addr->message == NULL) addr->message = US"frozen by filter";
768 addr->special_action = SPECIAL_FREEZE;
769 addr->child_count = 9999;
772 frc = FF_NOTDELIVERED;
775 /* Handle syntax errors and :include: failures and lookup defers */
780 /* If filtertype is still FILTER_UNSET, it means that the redirection data
781 was never inspected, so the error was an expansion failure or failure to open
782 the file, or whatever. In these cases, the existing error message is probably
785 if (filtertype == FILTER_UNSET) return DEFER;
787 /* If it was a filter and skip_syntax_errors is set, we want to set up
788 the error message so that it can be logged and mailed to somebody. */
790 if (filtertype != FILTER_FORWARD && ob->skip_syntax_errors)
792 eblock = store_get(sizeof(error_block));
794 eblock->text1 = addr->message;
795 eblock->text2 = NULL;
796 addr->message = addr->user_message = NULL;
799 /* Otherwise set up the error for the address and defer. */
803 addr->basic_errno = ERRNO_BADREDIRECT;
804 addr->message = string_sprintf("error in %s %s: %s",
805 (filtertype != FILTER_FORWARD)? "filter" : "redirect",
806 (ob->data == NULL)? "file" : "data",
813 /* Yield is either FF_DELIVERED (significant action) or FF_NOTDELIVERED (no
814 significant action). Before dealing with these, however, we must handle the
815 effect of skip_syntax_errors.
817 If skip_syntax_errors was set and there were syntax errors in an address list,
818 error messages will be present in eblock. Log them and send a message if so
819 configured. We cannot do this earlier, because the error message must not be
820 sent as the local user. If there were no valid addresses, generated will be
821 NULL. In this case, the router declines.
823 For a filter file, the error message has been fudged into an eblock. After
824 dealing with it, the router declines. */
828 if (!moan_skipped_syntax_errors(
829 rblock->name, /* For message content */
831 (verify != v_none || address_test_mode)?
832 NULL : ob->syntax_errors_to, /* Who to mail */
833 generated != NULL, /* True if not all failed */
834 ob->syntax_errors_text)) /* Custom message */
837 if (filtertype != FILTER_FORWARD || generated == NULL)
839 addr->message = US"syntax error in redirection data";
844 /* Sort out the errors address and any header modifications, and handle the
845 generated addresses, if any. If there are no generated addresses, we must avoid
846 calling sort_errors_and_headers() in case this router declines - that function
847 may modify the errors_address field in the current address, and we don't want
848 to do that for a decline. */
850 if (generated != NULL)
852 if ((xrc = sort_errors_and_headers(rblock, addr, verify, &addr_prop)) != OK)
854 add_generated(rblock, addr_new, addr, generated, &addr_prop, &ugid, pw);
857 /* FF_DELIVERED with no generated addresses is what we get when an address list
858 contains :blackhole: or a filter contains "seen finish" without having
859 generated anything. Log what happened to this address, and return DISCARD. */
861 if (frc == FF_DELIVERED)
863 if (generated == NULL && verify == v_none && !address_test_mode)
865 log_write(0, LOG_MAIN, "=> %s <%s> R=%s", discarded, addr->address,
871 /* For an address list, FF_NOTDELIVERED always means that no addresses were
872 generated. For a filter, addresses may or may not have been generated. If none
873 were, it's the same as an empty address list, and the router declines. However,
874 if addresses were generated, we can't just decline because successful delivery
875 of the base address gets it marked "done", so deferred generated addresses
876 never get tried again. We have to generate a new version of the base address,
877 as if there were a "deliver" command in the filter file, with the original
878 address as parent. */
884 if (generated == NULL) return DECLINE;
886 next = deliver_make_addr(addr->address, FALSE);
889 next->next = *addr_new;
892 /* Copy relevant flags (af_propagate is a name for the set), and set the
893 data that propagates. */
895 copyflag(next, addr, af_propagate);
898 DEBUG(D_route) debug_printf("%s router autogenerated %s\n%s%s%s",
901 (addr_prop.errors_address != NULL)? " errors to " : "",
902 (addr_prop.errors_address != NULL)? addr_prop.errors_address : US"",
903 (addr_prop.errors_address != NULL)? "\n" : "");
906 /* Control gets here only when the address has been completely handled. Put the
907 original address onto the succeed queue so that any retry items that get
908 attached to it get processed. */
910 addr->next = *addr_succeed;
911 *addr_succeed = addr;
916 /* End of routers/redirect.c */