1 /* $Cambridge: exim/src/src/routers/redirect.c,v 1.10 2005/04/28 13:06:32 ph10 Exp $ */
3 /*************************************************
4 * Exim - an Internet mail transport agent *
5 *************************************************/
7 /* Copyright (c) University of Cambridge 1995 - 2005 */
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 { "forbid_blackhole", opt_bit
| (RDON_BLACKHOLE
<< 16),
43 (void *)offsetof(redirect_router_options_block
, bit_options
) },
44 { "forbid_exim_filter", opt_bit
| (RDON_EXIM_FILTER
<< 16),
45 (void *)offsetof(redirect_router_options_block
, bit_options
) },
46 { "forbid_file", opt_bool
,
47 (void *)offsetof(redirect_router_options_block
, forbid_file
) },
48 { "forbid_filter_dlfunc", opt_bit
| (RDON_DLFUNC
<< 16),
49 (void *)offsetof(redirect_router_options_block
, bit_options
) },
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
) },
56 { "forbid_filter_perl", opt_bit
| (RDON_PERL
<< 16),
57 (void *)offsetof(redirect_router_options_block
, bit_options
) },
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
) },
70 { "forbid_sieve_filter",opt_bit
| (RDON_SIEVE_FILTER
<< 16),
71 (void *)offsetof(redirect_router_options_block
, bit_options
) },
72 { "hide_child_in_errmsg", opt_bool
,
73 (void *)offsetof(redirect_router_options_block
, hide_child_in_errmsg
) },
74 { "ignore_eacces", opt_bit
| (RDON_EACCES
<< 16),
75 (void *)offsetof(redirect_router_options_block
, bit_options
) },
76 { "ignore_enotdir", opt_bit
| (RDON_ENOTDIR
<< 16),
77 (void *)offsetof(redirect_router_options_block
, bit_options
) },
78 { "include_directory", opt_stringptr
,
79 (void *)offsetof(redirect_router_options_block
, include_directory
) },
80 { "modemask", opt_octint
,
81 (void *)offsetof(redirect_router_options_block
, modemask
) },
82 { "one_time", opt_bool
,
83 (void *)offsetof(redirect_router_options_block
, one_time
) },
84 { "owners", opt_uidlist
,
85 (void *)offsetof(redirect_router_options_block
, owners
) },
86 { "owngroups", opt_gidlist
,
87 (void *)offsetof(redirect_router_options_block
, owngroups
) },
88 { "pipe_transport", opt_stringptr
,
89 (void *)offsetof(redirect_router_options_block
, pipe_transport_name
) },
90 { "qualify_domain", opt_stringptr
,
91 (void *)offsetof(redirect_router_options_block
, qualify_domain
) },
92 { "qualify_preserve_domain", opt_bool
,
93 (void *)offsetof(redirect_router_options_block
, qualify_preserve_domain
) },
94 { "repeat_use", opt_bool
| opt_public
,
95 (void *)offsetof(router_instance
, repeat_use
) },
96 { "reply_transport", opt_stringptr
,
97 (void *)offsetof(redirect_router_options_block
, reply_transport_name
) },
98 { "rewrite", opt_bit
| (RDON_REWRITE
<< 16),
99 (void *)offsetof(redirect_router_options_block
, bit_options
) },
100 { "sieve_subaddress", opt_stringptr
,
101 (void *)offsetof(redirect_router_options_block
, sieve_subaddress
) },
102 { "sieve_useraddress", opt_stringptr
,
103 (void *)offsetof(redirect_router_options_block
, sieve_useraddress
) },
104 { "sieve_vacation_directory", opt_stringptr
,
105 (void *)offsetof(redirect_router_options_block
, sieve_vacation_directory
) },
106 { "skip_syntax_errors", opt_bool
,
107 (void *)offsetof(redirect_router_options_block
, skip_syntax_errors
) },
108 #ifdef EXPERIMENTAL_SRS
109 { "srs", opt_stringptr
,
110 (void *)offsetof(redirect_router_options_block
, srs
) },
111 { "srs_alias", opt_stringptr
,
112 (void *)offsetof(redirect_router_options_block
, srs_alias
) },
113 { "srs_condition", opt_stringptr
,
114 (void *)offsetof(redirect_router_options_block
, srs_condition
) },
115 { "srs_db", opt_stringptr
,
116 (void *)offsetof(redirect_router_options_block
, srs_db
) },
118 { "syntax_errors_text", opt_stringptr
,
119 (void *)offsetof(redirect_router_options_block
, syntax_errors_text
) },
120 { "syntax_errors_to", opt_stringptr
,
121 (void *)offsetof(redirect_router_options_block
, syntax_errors_to
) }
124 /* Size of the options list. An extern variable has to be used so that its
125 address can appear in the tables drtables.c. */
127 int redirect_router_options_count
=
128 sizeof(redirect_router_options
)/sizeof(optionlist
);
130 /* Default private options block for the redirect router. */
132 redirect_router_options_block redirect_router_option_defaults
= {
133 NULL
, /* directory_transport */
134 NULL
, /* file_transport */
135 NULL
, /* pipe_transport */
136 NULL
, /* reply_transport */
138 NULL
, /* directory_transport_name */
141 NULL
, /* file_transport_name */
142 NULL
, /* include_directory */
143 NULL
, /* pipe_transport_name */
144 NULL
, /* reply_transport_name */
145 NULL
, /* sieve_subaddress */
146 NULL
, /* sieve_useraddress */
147 NULL
, /* sieve_vacation_directory */
148 NULL
, /* syntax_errors_text */
149 NULL
, /* syntax_errors_to */
150 NULL
, /* qualify_domain */
152 NULL
, /* owngroups */
153 #ifdef EXPERIMENTAL_SRS
155 NULL
, /* srs_condition */
157 NULL
, /* srs_alias */
160 RDO_REWRITE
, /* bit_options */
161 FALSE
, /* check_ancestor */
162 TRUE_UNSET
, /* check_owner */
163 TRUE_UNSET
, /* check_group */
164 FALSE
, /* forbid_file */
165 FALSE
, /* forbid_filter_reply */
166 FALSE
, /* forbid_pipe */
167 FALSE
, /* hide_child_in_errmsg */
168 FALSE
, /* one_time */
169 FALSE
, /* qualify_preserve_domain */
170 FALSE
/* skip_syntax_errors */
175 /*************************************************
176 * Initialization entry point *
177 *************************************************/
179 /* Called for each instance, after its options have been read, to enable
180 consistency checks to be done, or anything else that needs to be set up. */
182 void redirect_router_init(router_instance
*rblock
)
184 redirect_router_options_block
*ob
=
185 (redirect_router_options_block
*)(rblock
->options_block
);
187 /* Either file or data must be set, but not both */
189 if ((ob
->file
== NULL
) == (ob
->data
== NULL
))
190 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_FOR
, "%s router:\n "
191 "%sone of \"file\" or \"data\" must be specified",
192 rblock
->name
, (ob
->file
== NULL
)? "" : "only ");
194 /* Onetime aliases can only be real addresses. Headers can't be manipulated.
195 The combination of one_time and unseen is not allowed. We can't check the
196 expansion of "unseen" here, but we assume that if it is set to anything other
197 than false, there is likely to be a problem. */
201 ob
->forbid_pipe
= ob
->forbid_file
= ob
->forbid_filter_reply
= TRUE
;
202 if (rblock
->extra_headers
!= NULL
|| rblock
->remove_headers
!= NULL
)
203 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_FOR
, "%s router:\n "
204 "\"headers_add\" and \"headers_remove\" are not permitted with "
205 "\"one_time\"", rblock
->name
);
206 if (rblock
->unseen
|| rblock
->expand_unseen
!= NULL
)
207 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_FOR
, "%s router:\n "
208 "\"unseen\" may not be used with \"one_time\"", rblock
->name
);
211 /* The defaults for check_owner and check_group depend on other settings. The
212 defaults are: Check the owner if check_local_user or owners is set; check the
213 group if check_local_user is set without a restriction on the group write bit,
214 or if owngroups is set. */
216 if (ob
->check_owner
== TRUE_UNSET
)
217 ob
->check_owner
= rblock
->check_local_user
||
218 (ob
->owners
!= NULL
&& ob
->owners
[0] != 0);
220 if (ob
->check_group
== TRUE_UNSET
)
221 ob
->check_group
= (rblock
->check_local_user
&& (ob
->modemask
& 020) == 0) ||
222 (ob
->owngroups
!= NULL
&& ob
->owngroups
[0] != 0);
224 /* If explicit qualify domain set, the preserve option is locked out */
226 if (ob
->qualify_domain
!= NULL
&& ob
->qualify_preserve_domain
)
227 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_FOR
, "%s router:\n "
228 "only one of \"qualify_domain\" or \"qualify_preserve_domain\" must be set",
231 /* If allow_filter is set, either user or check_local_user must be set. */
233 if (!rblock
->check_local_user
&&
235 rblock
->expand_uid
== NULL
&&
236 (ob
->bit_options
& RDO_FILTER
) != 0)
237 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_FOR
, "%s router:\n "
238 "\"user\" or \"check_local_user\" must be set with \"allow_filter\"",
244 /*************************************************
245 * Get errors address and header mods *
246 *************************************************/
248 /* This function is called when new addresses are generated, in order to
249 sort out errors address and header modifications. We put the errors address
250 into the parent address (even though it is never used from there because that
251 address is never transported) so that it can be retrieved if any of the
252 children gets routed by an "unseen" router. The clone of the child that is
253 passed on must have the original errors_address value.
256 rblock the router control block
257 addr the address being routed
258 verify true if verifying
259 addr_prop point to the propagated block, which is where the
260 new values are to be placed
262 Returns: the result of rf_get_errors_address() or rf_get_munge_headers(),
263 which is either OK or DEFER
267 sort_errors_and_headers(router_instance
*rblock
, address_item
*addr
,
268 BOOL verify
, address_item_propagated
*addr_prop
)
270 int frc
= rf_get_errors_address(addr
, rblock
, verify
,
271 &(addr_prop
->errors_address
));
272 if (frc
!= OK
) return frc
;
273 addr
->p
.errors_address
= addr_prop
->errors_address
;
274 return rf_get_munge_headers(addr
, rblock
, &(addr_prop
->extra_headers
),
275 &(addr_prop
->remove_headers
));
280 /*************************************************
281 * Process a set of generated new addresses *
282 *************************************************/
284 /* This function sets up a set of newly generated child addresses and puts them
285 on the new address chain. Copy in the uid, gid and permission flags for use by
286 pipes and files, set the parent, and "or" its af_ignore_error flag. Also record
287 the setting for any starting router.
289 If the generated address is the same as one of its ancestors, and the
290 check_ancestor flag is set, do not use this generated address, but replace it
291 with a copy of the input address. This is to cope with cases where A is aliased
292 to B and B has a .forward file pointing to A, though it is usually set on the
293 forwardfile rather than the aliasfile. We can't just pass on the old
294 address by returning FAIL, because it must act as a general parent for
295 generated addresses, and only get marked "done" when all its children are
300 addr_new new address chain
301 addr original address
302 generated list of generated addresses
303 addr_prop the propagated block, containing the errors_address,
304 header modification stuff, and address_data
305 ugidptr points to uid/gid data for files, pipes, autoreplies
306 pw password entry, set if ob->check_local_user is TRUE
312 add_generated(router_instance
*rblock
, address_item
**addr_new
,
313 address_item
*addr
, address_item
*generated
,
314 address_item_propagated
*addr_prop
, ugid_block
*ugidptr
, struct passwd
*pw
)
316 redirect_router_options_block
*ob
=
317 (redirect_router_options_block
*)(rblock
->options_block
);
319 while (generated
!= NULL
)
321 address_item
*parent
;
322 address_item
*next
= generated
;
323 uschar
*errors_address
= next
->p
.errors_address
;
325 generated
= next
->next
;
327 orflag(next
, addr
, af_ignore_error
);
328 next
->start_router
= rblock
->redirect_router
;
331 next
->next
= *addr_new
;
334 /* Don't do the "one_time" thing for the first pass of a 2-stage queue run. */
336 if (ob
->one_time
&& !queue_2stage
)
338 for (parent
= addr
; parent
->parent
!= NULL
; parent
= parent
->parent
);
339 next
->onetime_parent
= parent
->address
;
342 if (ob
->hide_child_in_errmsg
) setflag(next
, af_hide_child
);
344 /* If check_ancestor is set, we want to know if any ancestor of this address
345 is the address we are about to generate. The check must be done caselessly
346 unless the ancestor was routed by a case-sensitive router. */
348 if (ob
->check_ancestor
)
350 for (parent
= addr
; parent
!= NULL
; parent
= parent
->parent
)
352 if (((parent
->router
!= NULL
&& parent
->router
->caseful_local_part
)?
353 Ustrcmp(next
->address
, parent
->address
)
355 strcmpic(next
->address
, parent
->address
)
358 DEBUG(D_route
) debug_printf("generated parent replaced by child\n");
359 next
->address
= string_copy(addr
->address
);
365 /* A user filter may, under some circumstances, set up an errors address.
366 If so, we must take care to re-instate it when we copy in the propagated
367 data so that it overrides any errors_to setting on the router. */
369 next
->p
= *addr_prop
;
370 if (errors_address
!= NULL
) next
->p
.errors_address
= errors_address
;
372 /* For pipes, files, and autoreplies, record this router as handling them,
373 because they don't go through the routing process again. Then set up uid,
374 gid, home and current directories for transporting. */
376 if (testflag(next
, af_pfr
))
378 next
->router
= rblock
;
379 rf_set_ugid(next
, ugidptr
); /* Will contain pw values if not overridden */
381 /* When getting the home directory out of the password information, wrap it
382 in \N...\N to avoid expansion later. In Cygwin, home directories can
383 contain $ characters. */
385 if (rblock
->home_directory
!= NULL
)
386 next
->home_dir
= rblock
->home_directory
;
387 else if (rblock
->check_local_user
)
388 next
->home_dir
= string_sprintf("\\N%s\\N", pw
->pw_dir
);
389 else if (rblock
->router_home_directory
!= NULL
&&
390 testflag(addr
, af_home_expanded
))
392 next
->home_dir
= deliver_home
;
393 setflag(next
, af_home_expanded
);
396 next
->current_dir
= rblock
->current_directory
;
398 /* Permission options */
400 if (!ob
->forbid_pipe
) setflag(next
, af_allow_pipe
);
401 if (!ob
->forbid_file
) setflag(next
, af_allow_file
);
402 if (!ob
->forbid_filter_reply
) setflag(next
, af_allow_reply
);
404 /* If the transport setting fails, the error gets picked up at the outer
405 level from the setting of basic_errno in the address. */
407 if (next
->address
[0] == '|')
409 address_pipe
= next
->address
;
410 if (rf_get_transport(ob
->pipe_transport_name
, &(ob
->pipe_transport
),
411 next
, rblock
->name
, US
"pipe_transport"))
412 next
->transport
= ob
->pipe_transport
;
415 else if (next
->address
[0] == '>')
417 if (rf_get_transport(ob
->reply_transport_name
, &(ob
->reply_transport
),
418 next
, rblock
->name
, US
"reply_transport"))
419 next
->transport
= ob
->reply_transport
;
421 else /* must be file or directory */
423 int len
= Ustrlen(next
->address
);
424 address_file
= next
->address
;
425 if (next
->address
[len
-1] == '/')
427 if (rf_get_transport(ob
->directory_transport_name
,
428 &(ob
->directory_transport
), next
, rblock
->name
,
429 US
"directory_transport"))
430 next
->transport
= ob
->directory_transport
;
434 if (rf_get_transport(ob
->file_transport_name
, &(ob
->file_transport
),
435 next
, rblock
->name
, US
"file_transport"))
436 next
->transport
= ob
->file_transport
;
444 debug_printf("%s router generated %s\n %serrors_to=%s transport=%s\n",
447 testflag(next
, af_pfr
)? "pipe, file, or autoreply\n " : "",
448 next
->p
.errors_address
,
449 (next
->transport
== NULL
)? US
"NULL" : next
->transport
->name
);
451 if (testflag(next
, af_uid_set
))
452 debug_printf(" uid=%ld ", (long int)(next
->uid
));
454 debug_printf(" uid=unset ");
456 if (testflag(next
, af_gid_set
))
457 debug_printf("gid=%ld ", (long int)(next
->gid
));
459 debug_printf("gid=unset ");
461 debug_printf("home=%s\n", next
->home_dir
);
467 /*************************************************
469 *************************************************/
471 /* See local README for interface description. This router returns:
474 . empty address list, or filter did nothing significant
477 . verifying the errors address caused a deferment or a big disaster such
478 as an expansion failure (rf_get_errors_address)
479 . expanding a headers_{add,remove} string caused a deferment or another
480 expansion error (rf_get_munge_headers)
481 . :defer: or "freeze" in a filter
482 . error in address list or filter
483 . skipped syntax errors, but failed to send the message
486 . address was :blackhole:d or "seen finish"ed
492 . new addresses added to addr_new
495 int redirect_router_entry(
496 router_instance
*rblock
, /* data for this instantiation */
497 address_item
*addr
, /* address we are working on */
498 struct passwd
*pw
, /* passwd entry after check_local_user */
499 BOOL verify
, /* TRUE when verifying */
500 address_item
**addr_local
, /* add it to this if it's local */
501 address_item
**addr_remote
, /* add it to this if it's remote */
502 address_item
**addr_new
, /* put new addresses on here */
503 address_item
**addr_succeed
) /* put old address here on success */
505 redirect_router_options_block
*ob
=
506 (redirect_router_options_block
*)(rblock
->options_block
);
507 address_item
*generated
= NULL
;
508 uschar
*save_qualify_domain_recipient
= qualify_domain_recipient
;
509 uschar
*discarded
= US
"discarded";
510 address_item_propagated addr_prop
;
511 error_block
*eblock
= NULL
;
513 redirect_block redirect
;
514 int filtertype
= FILTER_UNSET
;
516 int options
= ob
->bit_options
;
520 addr_local
= addr_local
; /* Keep picky compilers happy */
521 addr_remote
= addr_remote
;
523 /* Initialize the data to be propagated to the children */
525 addr_prop
.address_data
= deliver_address_data
;
526 addr_prop
.domain_data
= deliver_domain_data
;
527 addr_prop
.localpart_data
= deliver_localpart_data
;
528 addr_prop
.errors_address
= NULL
;
529 addr_prop
.extra_headers
= NULL
;
530 addr_prop
.remove_headers
= NULL
;
532 /* When verifying and testing addresses, the "logwrite" command in filters
535 if (!verify
&& !address_test_mode
) options
|= RDO_REALLOG
;
537 /* Sort out the fixed or dynamic uid/gid. This uid is used (a) for reading the
538 file (and interpreting a filter) and (b) for running the transports for
539 generated file and pipe addresses. It is not (necessarily) the same as the uids
540 that may own the file. Exim panics if an expanded string is not a number and
541 can't be found in the password file. Other errors set the freezing bit. */
543 if (!rf_get_ugid(rblock
, addr
, &ugid
)) return DEFER
;
545 if (!ugid
.uid_set
&& pw
!= NULL
)
547 ugid
.uid
= pw
->pw_uid
;
551 if (!ugid
.gid_set
&& pw
!= NULL
)
553 ugid
.gid
= pw
->pw_gid
;
557 #ifdef EXPERIMENTAL_SRS
558 /* For reverse SRS, fill the srs_recipient expandsion variable,
559 on failure, return decline/fail as relevant */
564 if(ob
->srs_condition
!= NULL
)
565 usesrs
= expand_check_condition(ob
->srs_condition
, "srs_condition expansion failed", NULL
);
568 if(Ustrcmp(ob
->srs
, "reverse") == 0 || Ustrcmp(ob
->srs
, "reverseandforward") == 0)
573 srs_orig_recipient
= addr
->address
;
576 eximsrs_db_set(TRUE
, ob
->srs_db
);
577 if((n_srs
= eximsrs_reverse(&res
, addr
->address
)) != OK
)
582 debug_printf("SRS: Recipient '%s' rewritten to '%s'\n", srs_orig_recipient
, srs_recipient
);
587 /* Call the function that interprets redirection data, either inline or from a
588 file. This is a separate function so that the system filter can use it. It will
589 run the function in a subprocess if necessary. If qualify_preserve_domain is
590 set, temporarily reset qualify_domain_recipient to the current domain so that
591 any unqualified addresses get qualified with the same domain as the incoming
592 address. Otherwise, if a local qualify_domain is provided, set that up. */
594 if (ob
->qualify_preserve_domain
)
595 qualify_domain_recipient
= addr
->domain
;
596 else if (ob
->qualify_domain
!= NULL
)
598 uschar
*new_qdr
= rf_expand_data(addr
, ob
->qualify_domain
, &xrc
);
599 if (new_qdr
== NULL
) return xrc
;
600 qualify_domain_recipient
= new_qdr
;
603 redirect
.owners
= ob
->owners
;
604 redirect
.owngroups
= ob
->owngroups
;
605 redirect
.modemask
= ob
->modemask
;
606 redirect
.check_owner
= ob
->check_owner
;
607 redirect
.check_group
= ob
->check_group
;
610 if (ob
->file
!= NULL
)
612 redirect
.string
= ob
->file
;
613 redirect
.isfile
= TRUE
;
617 redirect
.string
= ob
->data
;
618 redirect
.isfile
= FALSE
;
621 frc
= rda_interpret(&redirect
, options
, ob
->include_directory
,
622 ob
->sieve_vacation_directory
, ob
->sieve_useraddress
, ob
->sieve_subaddress
,
623 &ugid
, &generated
, &(addr
->message
), ob
->skip_syntax_errors
? &eblock
: NULL
,
624 &filtertype
, string_sprintf("%s router (recipient is %s)", rblock
->name
,
627 qualify_domain_recipient
= save_qualify_domain_recipient
;
629 /* Handle exceptional returns from filtering or processing an address list.
630 For FAIL and FREEZE we honour any previously set up deliveries by a filter. */
635 addr
->message
= addr
->user_message
= NULL
;
639 DEBUG(D_route
) debug_printf("address :blackhole:d\n");
641 discarded
= US
":blackhole:";
645 /* FF_DEFER and FF_FAIL can arise only as a result of explicit commands
646 (:fail: in an alias file or "fail" in a filter). If a configured message was
647 supplied, allow it to be included in an SMTP response after verifying. */
650 if (addr
->message
== NULL
) addr
->message
= US
"forced defer";
651 else addr
->user_message
= addr
->message
;
655 if ((xrc
= sort_errors_and_headers(rblock
, addr
, verify
, &addr_prop
)) != OK
)
657 add_generated(rblock
, addr_new
, addr
, generated
, &addr_prop
, &ugid
, pw
);
658 if (addr
->message
== NULL
)
659 addr
->message
= US
"forced rejection";
662 addr
->user_message
= addr
->message
;
663 setflag(addr
, af_pass_message
);
667 /* As in the case of a system filter, a freeze does not happen after a manual
668 thaw. In case deliveries were set up by the filter, we set the child count
669 high so that their completion does not mark the original address done. */
672 if (!deliver_manual_thaw
)
674 if ((xrc
= sort_errors_and_headers(rblock
, addr
, verify
, &addr_prop
))
676 add_generated(rblock
, addr_new
, addr
, generated
, &addr_prop
, &ugid
, pw
);
677 if (addr
->message
== NULL
) addr
->message
= US
"frozen by filter";
678 addr
->special_action
= SPECIAL_FREEZE
;
679 addr
->child_count
= 9999;
682 frc
= FF_NOTDELIVERED
;
685 /* Handle syntax errors and :include: failures and lookup defers */
690 /* If filtertype is still FILTER_UNSET, it means that the redirection data
691 was never inspected, so the error was an expansion failure or failure to open
692 the file, or whatever. In these cases, the existing error message is probably
695 if (filtertype
== FILTER_UNSET
) return DEFER
;
697 /* If it was a filter and skip_syntax_errors is set, we want to set up
698 the error message so that it can be logged and mailed to somebody. */
700 if (filtertype
!= FILTER_FORWARD
&& ob
->skip_syntax_errors
)
702 eblock
= store_get(sizeof(error_block
));
704 eblock
->text1
= addr
->message
;
705 eblock
->text2
= NULL
;
706 addr
->message
= addr
->user_message
= NULL
;
709 /* Otherwise set up the error for the address and defer. */
713 addr
->basic_errno
= ERRNO_BADREDIRECT
;
714 addr
->message
= string_sprintf("error in %s %s: %s",
715 (filtertype
!= FILTER_FORWARD
)? "filter" : "redirect",
716 (ob
->data
== NULL
)? "file" : "data",
723 /* Yield is either FF_DELIVERED (significant action) or FF_NOTDELIVERED (no
724 significant action). Before dealing with these, however, we must handle the
725 effect of skip_syntax_errors.
727 If skip_syntax_errors was set and there were syntax errors in an address list,
728 error messages will be present in eblock. Log them and send a message if so
729 configured. We cannot do this earlier, because the error message must not be
730 sent as the local user. If there were no valid addresses, generated will be
731 NULL. In this case, the router declines.
733 For a filter file, the error message has been fudged into an eblock. After
734 dealing with it, the router declines. */
738 if (!moan_skipped_syntax_errors(
739 rblock
->name
, /* For message content */
741 (verify
|| address_test_mode
)?
742 NULL
: ob
->syntax_errors_to
, /* Who to mail */
743 generated
!= NULL
, /* True if not all failed */
744 ob
->syntax_errors_text
)) /* Custom message */
747 if (filtertype
!= FILTER_FORWARD
|| generated
== NULL
)
749 addr
->message
= US
"syntax error in redirection data";
754 /* Sort out the errors address and any header modifications, and handle the
755 generated addresses, if any. If there are no generated addresses, we must avoid
756 calling sort_errors_and_headers() in case this router declines - that function
757 may modify the errors_address field in the current address, and we don't want
758 to do that for a decline. */
760 if (generated
!= NULL
)
762 if ((xrc
= sort_errors_and_headers(rblock
, addr
, verify
, &addr_prop
)) != OK
)
764 add_generated(rblock
, addr_new
, addr
, generated
, &addr_prop
, &ugid
, pw
);
767 /* FF_DELIVERED with no generated addresses is what we get when an address list
768 contains :blackhole: or a filter contains "seen finish" without having
769 generated anything. Log what happened to this address, and return DISCARD. */
771 if (frc
== FF_DELIVERED
)
773 if (generated
== NULL
&& !verify
&& !address_test_mode
)
775 log_write(0, LOG_MAIN
, "=> %s <%s> R=%s", discarded
, addr
->address
,
781 /* For an address list, FF_NOTDELIVERED always means that no addresses were
782 generated. For a filter, addresses may or may not have been generated. If none
783 were, it's the same as an empty address list, and the router declines. However,
784 if addresses were generated, we can't just decline because successful delivery
785 of the base address gets it marked "done", so deferred generated addresses
786 never get tried again. We have to generate a new version of the base address,
787 as if there were a "deliver" command in the filter file, with the original
788 address as parent. */
794 if (generated
== NULL
) return DECLINE
;
796 next
= deliver_make_addr(addr
->address
, FALSE
);
799 next
->next
= *addr_new
;
802 /* Copy relevant flags (af_propagate is a name for the set), and set the
803 data that propagates. */
805 copyflag(next
, addr
, af_propagate
);
808 DEBUG(D_route
) debug_printf("%s router autogenerated %s\n%s%s%s",
811 (addr_prop
.errors_address
!= NULL
)? " errors to " : "",
812 (addr_prop
.errors_address
!= NULL
)? addr_prop
.errors_address
: US
"",
813 (addr_prop
.errors_address
!= NULL
)? "\n" : "");
816 #ifdef EXPERIMENTAL_SRS
817 /* On successful redirection, check for SRS forwarding and adjust sender */
822 if(ob
->srs_condition
!= NULL
)
823 usesrs
= expand_check_condition(ob
->srs_condition
, "srs_condition expansion failed", NULL
);
826 if((Ustrcmp(ob
->srs
, "forward") == 0 || Ustrcmp(ob
->srs
, "reverseandforward") == 0) && !verify
)
832 srs_orig_sender
= sender_address
;
835 eximsrs_db_set(FALSE
, ob
->srs_db
);
837 if(ob
->srs_alias
!= NULL
? (usedomain
= expand_string(ob
->srs_alias
)) == NULL
: 1)
838 usedomain
= deliver_domain
;
840 if((n_srs
= eximsrs_forward(&res
, sender_address
, usedomain
)) != OK
)
842 sender_address
= res
;
844 debug_printf("SRS: Sender '%s' rewritten to '%s'\n", srs_orig_sender
, sender_address
);
849 /* Control gets here only when the address has been completely handled. Put the
850 original address onto the succeed queue so that any retry items that get
851 attached to it get processed. */
853 addr
->next
= *addr_succeed
;
854 *addr_succeed
= addr
;
859 /* End of routers/redirect.c */