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