src/src/routers/redirect.c

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