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