src/src/routers/redirect.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2015 */
   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 != NULL)
 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 == SHRT_MAX)
 339     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s router generated more than %d "
 340       "child addresses for <%s>", rblock->name, SHRT_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 != NULL; 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     {
 362     for (parent = addr; parent != NULL; parent = parent->parent)
 363       {
 364       if (((parent->router != NULL && parent->router->caseful_local_part)?
 365            Ustrcmp(next->address, parent->address)
 366            :
 367            strcmpic(next->address, parent->address)
 368           ) == 0)
 369         {
 370         DEBUG(D_route) debug_printf("generated parent replaced by child\n");
 371         next->address = string_copy(addr->address);
 372         break;
 373         }
 374       }
 375     }
 376
 377   /* A user filter may, under some circumstances, set up an errors address.
 378   If so, we must take care to re-instate it when we copy in the propagated
 379   data so that it overrides any errors_to setting on the router. */
 380
 381   next->prop = *addr_prop;
 382   if (errors_address != NULL) next->prop.errors_address = errors_address;
 383
 384   /* For pipes, files, and autoreplies, record this router as handling them,
 385   because they don't go through the routing process again. Then set up uid,
 386   gid, home and current directories for transporting. */
 387
 388   if (testflag(next, af_pfr))
 389     {
 390     next->router = rblock;
 391     rf_set_ugid(next, ugidptr);   /* Will contain pw values if not overridden */
 392
 393     /* When getting the home directory out of the password information, wrap it
 394     in \N...\N to avoid expansion later. In Cygwin, home directories can
 395     contain $ characters. */
 396
 397     if (rblock->home_directory != NULL)
 398       next->home_dir = rblock->home_directory;
 399     else if (rblock->check_local_user)
 400       next->home_dir = string_sprintf("\\N%s\\N", pw->pw_dir);
 401     else if (rblock->router_home_directory != NULL &&
 402              testflag(addr, af_home_expanded))
 403       {
 404       next->home_dir = deliver_home;
 405       setflag(next, af_home_expanded);
 406       }
 407
 408     next->current_dir = rblock->current_directory;
 409
 410     /* Permission options */
 411
 412     if (!ob->forbid_pipe) setflag(next, af_allow_pipe);
 413     if (!ob->forbid_file) setflag(next, af_allow_file);
 414     if (!ob->forbid_filter_reply) setflag(next, af_allow_reply);
 415
 416     /* If the transport setting fails, the error gets picked up at the outer
 417     level from the setting of basic_errno in the address. */
 418
 419     if (next->address[0] == '|')
 420       {
 421       address_pipe = next->address;
 422       if (rf_get_transport(ob->pipe_transport_name, &(ob->pipe_transport),
 423           next, rblock->name, US"pipe_transport"))
 424         next->transport = ob->pipe_transport;
 425       address_pipe = NULL;
 426       }
 427     else if (next->address[0] == '>')
 428       {
 429       if (rf_get_transport(ob->reply_transport_name, &(ob->reply_transport),
 430           next, rblock->name, US"reply_transport"))
 431         next->transport = ob->reply_transport;
 432       }
 433     else  /* must be file or directory */
 434       {
 435       int len = Ustrlen(next->address);
 436       address_file = next->address;
 437       if (next->address[len-1] == '/')
 438         {
 439         if (rf_get_transport(ob->directory_transport_name,
 440             &(ob->directory_transport), next, rblock->name,
 441             US"directory_transport"))
 442           next->transport = ob->directory_transport;
 443         }
 444       else
 445         {
 446         if (rf_get_transport(ob->file_transport_name, &(ob->file_transport),
 447             next, rblock->name, US"file_transport"))
 448           next->transport = ob->file_transport;
 449         }
 450       address_file = NULL;
 451       }
 452     }
 453
 454 #ifdef SUPPORT_I18N
 455     next->prop.utf8_msg = string_is_utf8(next->address)
 456       || (sender_address && string_is_utf8(sender_address));
 457 #endif
 458
 459   DEBUG(D_route)
 460     {
 461     debug_printf("%s router generated %s\n  %serrors_to=%s transport=%s\n",
 462       rblock->name,
 463       next->address,
 464       testflag(next, af_pfr)? "pipe, file, or autoreply\n  " : "",
 465       next->prop.errors_address,
 466       (next->transport == NULL)? US"NULL" : next->transport->name);
 467
 468     if (testflag(next, af_uid_set))
 469       debug_printf("  uid=%ld ", (long int)(next->uid));
 470     else
 471       debug_printf("  uid=unset ");
 472
 473     if (testflag(next, af_gid_set))
 474       debug_printf("gid=%ld ", (long int)(next->gid));
 475     else
 476       debug_printf("gid=unset ");
 477
 478 #ifdef SUPPORT_I18N
 479     if (next->prop.utf8_msg) debug_printf("utf8 ");
 480 #endif
 481
 482     debug_printf("home=%s\n", next->home_dir);
 483     }
 484   }
 485 }
 486
 487
 488 /*************************************************
 489 *              Main entry point                  *
 490 *************************************************/
 491
 492 /* See local README for interface description. This router returns:
 493
 494 DECLINE
 495   . empty address list, or filter did nothing significant
 496
 497 DEFER
 498   . verifying the errors address caused a deferment or a big disaster such
 499       as an expansion failure (rf_get_errors_address)
 500   . expanding a headers_{add,remove} string caused a deferment or another
 501       expansion error (rf_get_munge_headers)
 502   . :defer: or "freeze" in a filter
 503   . error in address list or filter
 504   . skipped syntax errors, but failed to send the message
 505
 506 DISCARD
 507   . address was :blackhole:d or "seen finish"ed
 508
 509 FAIL
 510   . :fail:
 511
 512 OK
 513   . new addresses added to addr_new
 514 */
 515
 516 int redirect_router_entry(
 517   router_instance *rblock,        /* data for this instantiation */
 518   address_item *addr,             /* address we are working on */
 519   struct passwd *pw,              /* passwd entry after check_local_user */
 520   int verify,                     /* v_none/v_recipient/v_sender/v_expn */
 521   address_item **addr_local,      /* add it to this if it's local */
 522   address_item **addr_remote,     /* add it to this if it's remote */
 523   address_item **addr_new,        /* put new addresses on here */
 524   address_item **addr_succeed)    /* put old address here on success */
 525 {
 526 redirect_router_options_block *ob =
 527   (redirect_router_options_block *)(rblock->options_block);
 528 address_item *generated = NULL;
 529 const uschar *save_qualify_domain_recipient = qualify_domain_recipient;
 530 uschar *discarded = US"discarded";
 531 address_item_propagated addr_prop;
 532 error_block *eblock = NULL;
 533 ugid_block ugid;
 534 redirect_block redirect;
 535 int filtertype = FILTER_UNSET;
 536 int yield = OK;
 537 int options = ob->bit_options;
 538 int frc = 0;
 539 int xrc = 0;
 540
 541 addr_local = addr_local;     /* Keep picky compilers happy */
 542 addr_remote = addr_remote;
 543
 544 /* Initialize the data to be propagated to the children */
 545
 546 addr_prop.address_data = deliver_address_data;
 547 addr_prop.domain_data = deliver_domain_data;
 548 addr_prop.localpart_data = deliver_localpart_data;
 549 addr_prop.errors_address = NULL;
 550 addr_prop.extra_headers = NULL;
 551 addr_prop.remove_headers = NULL;
 552
 553 #ifdef EXPERIMENTAL_SRS
 554 addr_prop.srs_sender = NULL;
 555 #endif
 556 #ifdef SUPPORT_I18N
 557 addr_prop.utf8_msg = FALSE;     /*XXX should we not copy this from the parent? */
 558 addr_prop.utf8_downcvt = FALSE;
 559 addr_prop.utf8_downcvt_maybe = FALSE;
 560 #endif
 561
 562
 563 /* When verifying and testing addresses, the "logwrite" command in filters
 564 must be bypassed. */
 565
 566 if (verify == v_none && !address_test_mode) options |= RDO_REALLOG;
 567
 568 /* Sort out the fixed or dynamic uid/gid. This uid is used (a) for reading the
 569 file (and interpreting a filter) and (b) for running the transports for
 570 generated file and pipe addresses. It is not (necessarily) the same as the uids
 571 that may own the file. Exim panics if an expanded string is not a number and
 572 can't be found in the password file. Other errors set the freezing bit. */
 573
 574 if (!rf_get_ugid(rblock, addr, &ugid)) return DEFER;
 575
 576 if (!ugid.uid_set && pw != NULL)
 577   {
 578   ugid.uid = pw->pw_uid;
 579   ugid.uid_set = TRUE;
 580   }
 581
 582 if (!ugid.gid_set && pw != NULL)
 583   {
 584   ugid.gid = pw->pw_gid;
 585   ugid.gid_set = TRUE;
 586   }
 587
 588 #ifdef EXPERIMENTAL_SRS
 589   /* Perform SRS on recipient/return-path as required  */
 590
 591   if(ob->srs != NULL)
 592   {
 593     BOOL usesrs = TRUE;
 594
 595     if(ob->srs_condition != NULL)
 596       usesrs = expand_check_condition(ob->srs_condition, "srs_condition expansion failed", NULL);
 597
 598     if(usesrs)
 599     {
 600       int srs_action = 0, n_srs;
 601       uschar *res;
 602       uschar *usedomain;
 603
 604       /* What are we doing? */
 605       if(Ustrcmp(ob->srs, "forward") == 0)
 606         srs_action = 1;
 607       else if(Ustrcmp(ob->srs, "reverseandforward") == 0)
 608       {
 609         srs_action = 3;
 610
 611         if((ob->srs_dbinsert == NULL) ^ (ob->srs_dbselect == NULL))
 612           return DEFER;
 613       }
 614       else if(Ustrcmp(ob->srs, "reverse") == 0)
 615         srs_action = 2;
 616
 617       /* Reverse SRS */
 618       if(srs_action & 2)
 619       {
 620         srs_orig_recipient = addr->address;
 621
 622         eximsrs_init();
 623         if(ob->srs_dbselect)
 624           eximsrs_db_set(TRUE, ob->srs_dbselect);
 625 /* Comment this out for now...
 626 //        else
 627 //          eximsrs_db_set(TRUE, NULL);
 628 */
 629
 630         if((n_srs = eximsrs_reverse(&res, addr->address)) == OK)
 631         {
 632           srs_recipient = res;
 633           DEBUG(D_any)
 634             debug_printf("SRS (reverse): Recipient '%s' rewritten to '%s'\n", srs_orig_recipient, srs_recipient);
 635         }
 636
 637         eximsrs_done();
 638
 639         if(n_srs != OK)
 640           return n_srs;
 641       }
 642
 643       /* Forward SRS */
 644       /* No point in actually performing SRS if we are just verifying a recipient */
 645       if((srs_action & 1) && verify == v_none &&
 646          (sender_address ? sender_address[0] != 0 : FALSE))
 647       {
 648
 649         srs_orig_sender = sender_address;
 650         eximsrs_init();
 651         if(ob->srs_dbinsert)
 652           eximsrs_db_set(FALSE, ob->srs_dbinsert);
 653 /* Comment this out for now...
 654 //        else
 655 //          eximsrs_db_set(FALSE, NULL);
 656 */
 657
 658         if (!(usedomain = ob->srs_alias ? expand_string(ob->srs_alias) : NULL))
 659           usedomain = string_copy(deliver_domain);
 660
 661         if((n_srs = eximsrs_forward(&res, sender_address, usedomain)) == OK)
 662         {
 663           addr_prop.srs_sender = res;
 664           DEBUG(D_any)
 665             debug_printf("SRS (forward): Sender '%s' rewritten to '%s'\n", srs_orig_sender, res);
 666         }
 667
 668         eximsrs_done();
 669
 670         if(n_srs != OK)
 671           return n_srs;
 672       }
 673     }
 674   }
 675 #endif
 676
 677 /* Call the function that interprets redirection data, either inline or from a
 678 file. This is a separate function so that the system filter can use it. It will
 679 run the function in a subprocess if necessary. If qualify_preserve_domain is
 680 set, temporarily reset qualify_domain_recipient to the current domain so that
 681 any unqualified addresses get qualified with the same domain as the incoming
 682 address. Otherwise, if a local qualify_domain is provided, set that up. */
 683
 684 if (ob->qualify_preserve_domain)
 685   qualify_domain_recipient = addr->domain;
 686 else if (ob->qualify_domain != NULL)
 687   {
 688   uschar *new_qdr = rf_expand_data(addr, ob->qualify_domain, &xrc);
 689   if (new_qdr == NULL) return xrc;
 690   qualify_domain_recipient = new_qdr;
 691   }
 692
 693 redirect.owners = ob->owners;
 694 redirect.owngroups = ob->owngroups;
 695 redirect.modemask = ob->modemask;
 696 redirect.check_owner = ob->check_owner;
 697 redirect.check_group = ob->check_group;
 698 redirect.pw = pw;
 699
 700 if (ob->file != NULL)
 701   {
 702   redirect.string = ob->file;
 703   redirect.isfile = TRUE;
 704   }
 705 else
 706   {
 707   redirect.string = ob->data;
 708   redirect.isfile = FALSE;
 709   }
 710
 711 frc = rda_interpret(&redirect, options, ob->include_directory,
 712   ob->sieve_vacation_directory, ob->sieve_enotify_mailto_owner,
 713   ob->sieve_useraddress, ob->sieve_subaddress, &ugid, &generated,
 714   &(addr->message), ob->skip_syntax_errors? &eblock : NULL, &filtertype,
 715   string_sprintf("%s router (recipient is %s)", rblock->name, addr->address));
 716
 717 qualify_domain_recipient = save_qualify_domain_recipient;
 718
 719 /* Handle exceptional returns from filtering or processing an address list.
 720 For FAIL and FREEZE we honour any previously set up deliveries by a filter. */
 721
 722 switch (frc)
 723   {
 724   case FF_NONEXIST:
 725   addr->message = addr->user_message = NULL;
 726   return DECLINE;
 727
 728   case FF_BLACKHOLE:
 729   DEBUG(D_route) debug_printf("address :blackhole:d\n");
 730   generated = NULL;
 731   discarded = US":blackhole:";
 732   frc = FF_DELIVERED;
 733   break;
 734
 735   /* FF_DEFER and FF_FAIL can arise only as a result of explicit commands
 736   (:defer: or :fail: in an alias file or "fail" in a filter). If a configured
 737   message was supplied, allow it to be included in an SMTP response after
 738   verifying. Remove any SMTP code if it is not allowed. */
 739
 740   case FF_DEFER:
 741   yield = DEFER;
 742   goto SORT_MESSAGE;
 743
 744   case FF_FAIL:
 745   if ((xrc = sort_errors_and_headers(rblock, addr, verify, &addr_prop)) != OK)
 746     return xrc;
 747   add_generated(rblock, addr_new, addr, generated, &addr_prop, &ugid, pw);
 748   yield = FAIL;
 749
 750   SORT_MESSAGE:
 751   if (addr->message == NULL)
 752     addr->message = (yield == FAIL)? US"forced rejection" : US"forced defer";
 753   else
 754     {
 755     int ovector[3];
 756     if (ob->forbid_smtp_code &&
 757         pcre_exec(regex_smtp_code, NULL, CS addr->message,
 758           Ustrlen(addr->message), 0, PCRE_EOPT,
 759           ovector, sizeof(ovector)/sizeof(int)) >= 0)
 760       {
 761       DEBUG(D_route) debug_printf("SMTP code at start of error message "
 762         "is ignored because forbid_smtp_code is set\n");
 763       addr->message += ovector[1];
 764       }
 765     addr->user_message = addr->message;
 766     setflag(addr, af_pass_message);
 767     }
 768   return yield;
 769
 770   /* As in the case of a system filter, a freeze does not happen after a manual
 771   thaw. In case deliveries were set up by the filter, we set the child count
 772   high so that their completion does not mark the original address done. */
 773
 774   case FF_FREEZE:
 775   if (!deliver_manual_thaw)
 776     {
 777     if ((xrc = sort_errors_and_headers(rblock, addr, verify, &addr_prop))
 778       != OK) return xrc;
 779     add_generated(rblock, addr_new, addr, generated, &addr_prop, &ugid, pw);
 780     if (addr->message == NULL) addr->message = US"frozen by filter";
 781     addr->special_action = SPECIAL_FREEZE;
 782     addr->child_count = 9999;
 783     return DEFER;
 784     }
 785   frc = FF_NOTDELIVERED;
 786   break;
 787
 788   /* Handle syntax errors and :include: failures and lookup defers */
 789
 790   case FF_ERROR:
 791   case FF_INCLUDEFAIL:
 792
 793   /* If filtertype is still FILTER_UNSET, it means that the redirection data
 794   was never inspected, so the error was an expansion failure or failure to open
 795   the file, or whatever. In these cases, the existing error message is probably
 796   sufficient. */
 797
 798   if (filtertype == FILTER_UNSET) return DEFER;
 799
 800   /* If it was a filter and skip_syntax_errors is set, we want to set up
 801   the error message so that it can be logged and mailed to somebody. */
 802
 803   if (filtertype != FILTER_FORWARD && ob->skip_syntax_errors)
 804     {
 805     eblock = store_get(sizeof(error_block));
 806     eblock->next = NULL;
 807     eblock->text1 = addr->message;
 808     eblock->text2 = NULL;
 809     addr->message = addr->user_message = NULL;
 810     }
 811
 812   /* Otherwise set up the error for the address and defer. */
 813
 814   else
 815     {
 816     addr->basic_errno = ERRNO_BADREDIRECT;
 817     addr->message = string_sprintf("error in %s %s: %s",
 818       (filtertype != FILTER_FORWARD)? "filter" : "redirect",
 819       (ob->data == NULL)? "file" : "data",
 820       addr->message);
 821     return DEFER;
 822     }
 823   }
 824
 825
 826 /* Yield is either FF_DELIVERED (significant action) or FF_NOTDELIVERED (no
 827 significant action). Before dealing with these, however, we must handle the
 828 effect of skip_syntax_errors.
 829
 830 If skip_syntax_errors was set and there were syntax errors in an address list,
 831 error messages will be present in eblock. Log them and send a message if so
 832 configured. We cannot do this earlier, because the error message must not be
 833 sent as the local user. If there were no valid addresses, generated will be
 834 NULL. In this case, the router declines.
 835
 836 For a filter file, the error message has been fudged into an eblock. After
 837 dealing with it, the router declines. */
 838
 839 if (eblock != NULL)
 840   {
 841   if (!moan_skipped_syntax_errors(
 842         rblock->name,                            /* For message content */
 843         eblock,                                  /* Ditto */
 844         (verify != v_none || address_test_mode)?
 845           NULL : ob->syntax_errors_to,           /* Who to mail */
 846         generated != NULL,                       /* True if not all failed */
 847         ob->syntax_errors_text))                 /* Custom message */
 848     return DEFER;
 849
 850   if (filtertype != FILTER_FORWARD || generated == NULL)
 851     {
 852     addr->message = US"syntax error in redirection data";
 853     return DECLINE;
 854     }
 855   }
 856
 857 /* Sort out the errors address and any header modifications, and handle the
 858 generated addresses, if any. If there are no generated addresses, we must avoid
 859 calling sort_errors_and_headers() in case this router declines - that function
 860 may modify the errors_address field in the current address, and we don't want
 861 to do that for a decline. */
 862
 863 if (generated != NULL)
 864   {
 865   if ((xrc = sort_errors_and_headers(rblock, addr, verify, &addr_prop)) != OK)
 866     return xrc;
 867   add_generated(rblock, addr_new, addr, generated, &addr_prop, &ugid, pw);
 868   }
 869
 870 /* FF_DELIVERED with no generated addresses is what we get when an address list
 871 contains :blackhole: or a filter contains "seen finish" without having
 872 generated anything. Log what happened to this address, and return DISCARD. */
 873
 874 if (frc == FF_DELIVERED)
 875   {
 876   if (generated == NULL && verify == v_none && !address_test_mode)
 877     {
 878     log_write(0, LOG_MAIN, "=> %s <%s> R=%s", discarded, addr->address,
 879       rblock->name);
 880     yield = DISCARD;
 881     }
 882   }
 883
 884 /* For an address list, FF_NOTDELIVERED always means that no addresses were
 885 generated. For a filter, addresses may or may not have been generated. If none
 886 were, it's the same as an empty address list, and the router declines. However,
 887 if addresses were generated, we can't just decline because successful delivery
 888 of the base address gets it marked "done", so deferred generated addresses
 889 never get tried again. We have to generate a new version of the base address,
 890 as if there were a "deliver" command in the filter file, with the original
 891 address as parent. */
 892
 893 else
 894   {
 895   address_item *next;
 896
 897   if (generated == NULL) return DECLINE;
 898
 899   next = deliver_make_addr(addr->address, FALSE);
 900   next->parent = addr;
 901   addr->child_count++;
 902   next->next = *addr_new;
 903   *addr_new = next;
 904
 905   /* Copy relevant flags (af_propagate is a name for the set), and set the
 906   data that propagates. */
 907
 908   copyflag(next, addr, af_propagate);
 909   next->prop = addr_prop;
 910
 911   DEBUG(D_route) debug_printf("%s router autogenerated %s\n%s%s%s",
 912     rblock->name,
 913     next->address,
 914     (addr_prop.errors_address != NULL)? "  errors to " : "",
 915     (addr_prop.errors_address != NULL)? addr_prop.errors_address : US"",
 916     (addr_prop.errors_address != NULL)? "\n" : "");
 917   }
 918
 919 /* Control gets here only when the address has been completely handled. Put the
 920 original address onto the succeed queue so that any retry items that get
 921 attached to it get processed. */
 922
 923 addr->next = *addr_succeed;
 924 *addr_succeed = addr;
 925
 926 return yield;
 927 }
 928
 929 /* End of routers/redirect.c */