src/src/routers/redirect.c

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