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