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