src/src/routers/redirect.c

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