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