src/src/deliver.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 /* The main code for delivering a message. */
   9
  10
  11 #include "exim.h"
  12 #include <assert.h>
  13
  14
  15 /* Data block for keeping track of subprocesses for parallel remote
  16 delivery. */
  17
  18 typedef struct pardata {
  19   address_item *addrlist;      /* chain of addresses */
  20   address_item *addr;          /* next address data expected for */
  21   pid_t pid;                   /* subprocess pid */
  22   int fd;                      /* pipe fd for getting result from subprocess */
  23   int transport_count;         /* returned transport count value */
  24   BOOL done;                   /* no more data needed */
  25   uschar *msg;                 /* error message */
  26   uschar *return_path;         /* return_path for these addresses */
  27 } pardata;
  28
  29 /* Values for the process_recipients variable */
  30
  31 enum { RECIP_ACCEPT, RECIP_IGNORE, RECIP_DEFER,
  32        RECIP_FAIL, RECIP_FAIL_FILTER, RECIP_FAIL_TIMEOUT,
  33        RECIP_FAIL_LOOP};
  34
  35 /* Mutually recursive functions for marking addresses done. */
  36
  37 static void child_done(address_item *, uschar *);
  38 static void address_done(address_item *, uschar *);
  39
  40 /* Table for turning base-62 numbers into binary */
  41
  42 static uschar tab62[] =
  43           {0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0,     /* 0-9 */
  44            0,10,11,12,13,14,15,16,17,18,19,20,  /* A-K */
  45           21,22,23,24,25,26,27,28,29,30,31,32,  /* L-W */
  46           33,34,35, 0, 0, 0, 0, 0,              /* X-Z */
  47            0,36,37,38,39,40,41,42,43,44,45,46,  /* a-k */
  48           47,48,49,50,51,52,53,54,55,56,57,58,  /* l-w */
  49           59,60,61};                            /* x-z */
  50
  51
  52 /*************************************************
  53 *            Local static variables              *
  54 *************************************************/
  55
  56 /* addr_duplicate is global because it needs to be seen from the Envelope-To
  57 writing code. */
  58
  59 static address_item *addr_defer = NULL;
  60 static address_item *addr_failed = NULL;
  61 static address_item *addr_fallback = NULL;
  62 static address_item *addr_local = NULL;
  63 static address_item *addr_new = NULL;
  64 static address_item *addr_remote = NULL;
  65 static address_item *addr_route = NULL;
  66 static address_item *addr_succeed = NULL;
  67 static address_item *addr_dsntmp = NULL;
  68 static address_item *addr_senddsn = NULL;
  69
  70 static FILE *message_log = NULL;
  71 static BOOL update_spool;
  72 static BOOL remove_journal;
  73 static int  parcount = 0;
  74 static pardata *parlist = NULL;
  75 static int  return_count;
  76 static uschar *frozen_info = US"";
  77 static uschar *used_return_path = NULL;
  78
  79
  80
  81 /*************************************************
  82 *             Make a new address item            *
  83 *************************************************/
  84
  85 /* This function gets the store and initializes with default values. The
  86 transport_return value defaults to DEFER, so that any unexpected failure to
  87 deliver does not wipe out the message. The default unique string is set to a
  88 copy of the address, so that its domain can be lowercased.
  89
  90 Argument:
  91   address     the RFC822 address string
  92   copy        force a copy of the address
  93
  94 Returns:      a pointer to an initialized address_item
  95 */
  96
  97 address_item *
  98 deliver_make_addr(uschar *address, BOOL copy)
  99 {
 100 address_item *addr = store_get(sizeof(address_item));
 101 *addr = address_defaults;
 102 if (copy) address = string_copy(address);
 103 addr->address = address;
 104 addr->unique = string_copy(address);
 105 return addr;
 106 }
 107
 108
 109
 110
 111 /*************************************************
 112 *     Set expansion values for an address        *
 113 *************************************************/
 114
 115 /* Certain expansion variables are valid only when handling an address or
 116 address list. This function sets them up or clears the values, according to its
 117 argument.
 118
 119 Arguments:
 120   addr          the address in question, or NULL to clear values
 121 Returns:        nothing
 122 */
 123
 124 void
 125 deliver_set_expansions(address_item *addr)
 126 {
 127 if (!addr)
 128   {
 129   const uschar ***p = address_expansions;
 130   while (*p) **p++ = NULL;
 131   return;
 132   }
 133
 134 /* Exactly what gets set depends on whether there is one or more addresses, and
 135 what they contain. These first ones are always set, taking their values from
 136 the first address. */
 137
 138 if (!addr->host_list)
 139   {
 140   deliver_host = deliver_host_address = US"";
 141   deliver_host_port = 0;
 142   }
 143 else
 144   {
 145   deliver_host = addr->host_list->name;
 146   deliver_host_address = addr->host_list->address;
 147   deliver_host_port = addr->host_list->port;
 148   }
 149
 150 deliver_recipients = addr;
 151 deliver_address_data = addr->prop.address_data;
 152 deliver_domain_data = addr->prop.domain_data;
 153 deliver_localpart_data = addr->prop.localpart_data;
 154
 155 /* These may be unset for multiple addresses */
 156
 157 deliver_domain = addr->domain;
 158 self_hostname = addr->self_hostname;
 159
 160 #ifdef EXPERIMENTAL_BRIGHTMAIL
 161 bmi_deliver = 1;    /* deliver by default */
 162 bmi_alt_location = NULL;
 163 bmi_base64_verdict = NULL;
 164 bmi_base64_tracker_verdict = NULL;
 165 #endif
 166
 167 /* If there's only one address we can set everything. */
 168
 169 if (!addr->next)
 170   {
 171   address_item *addr_orig;
 172
 173   deliver_localpart = addr->local_part;
 174   deliver_localpart_prefix = addr->prefix;
 175   deliver_localpart_suffix = addr->suffix;
 176
 177   for (addr_orig = addr; addr_orig->parent; addr_orig = addr_orig->parent) ;
 178   deliver_domain_orig = addr_orig->domain;
 179
 180   /* Re-instate any prefix and suffix in the original local part. In all
 181   normal cases, the address will have a router associated with it, and we can
 182   choose the caseful or caseless version accordingly. However, when a system
 183   filter sets up a pipe, file, or autoreply delivery, no router is involved.
 184   In this case, though, there won't be any prefix or suffix to worry about. */
 185
 186   deliver_localpart_orig = !addr_orig->router
 187     ? addr_orig->local_part
 188     : addr_orig->router->caseful_local_part
 189     ? addr_orig->cc_local_part
 190     : addr_orig->lc_local_part;
 191
 192   /* If there's a parent, make its domain and local part available, and if
 193   delivering to a pipe or file, or sending an autoreply, get the local
 194   part from the parent. For pipes and files, put the pipe or file string
 195   into address_pipe and address_file. */
 196
 197   if (addr->parent)
 198     {
 199     deliver_domain_parent = addr->parent->domain;
 200     deliver_localpart_parent = !addr->parent->router
 201       ? addr->parent->local_part
 202       : addr->parent->router->caseful_local_part
 203       ? addr->parent->cc_local_part
 204       : addr->parent->lc_local_part;
 205
 206     /* File deliveries have their own flag because they need to be picked out
 207     as special more often. */
 208
 209     if (testflag(addr, af_pfr))
 210       {
 211       if (testflag(addr, af_file))          address_file = addr->local_part;
 212       else if (deliver_localpart[0] == '|') address_pipe = addr->local_part;
 213       deliver_localpart = addr->parent->local_part;
 214       deliver_localpart_prefix = addr->parent->prefix;
 215       deliver_localpart_suffix = addr->parent->suffix;
 216       }
 217     }
 218
 219 #ifdef EXPERIMENTAL_BRIGHTMAIL
 220     /* Set expansion variables related to Brightmail AntiSpam */
 221     bmi_base64_verdict = bmi_get_base64_verdict(deliver_localpart_orig, deliver_domain_orig);
 222     bmi_base64_tracker_verdict = bmi_get_base64_tracker_verdict(bmi_base64_verdict);
 223     /* get message delivery status (0 - don't deliver | 1 - deliver) */
 224     bmi_deliver = bmi_get_delivery_status(bmi_base64_verdict);
 225     /* if message is to be delivered, get eventual alternate location */
 226     if (bmi_deliver == 1)
 227       bmi_alt_location = bmi_get_alt_location(bmi_base64_verdict);
 228 #endif
 229
 230   }
 231
 232 /* For multiple addresses, don't set local part, and leave the domain and
 233 self_hostname set only if it is the same for all of them. It is possible to
 234 have multiple pipe and file addresses, but only when all addresses have routed
 235 to the same pipe or file. */
 236
 237 else
 238   {
 239   address_item *addr2;
 240   if (testflag(addr, af_pfr))
 241     {
 242     if (testflag(addr, af_file))         address_file = addr->local_part;
 243     else if (addr->local_part[0] == '|') address_pipe = addr->local_part;
 244     }
 245   for (addr2 = addr->next; addr2; addr2 = addr2->next)
 246     {
 247     if (deliver_domain && Ustrcmp(deliver_domain, addr2->domain) != 0)
 248       deliver_domain = NULL;
 249     if (  self_hostname
 250        && (  !addr2->self_hostname
 251           || Ustrcmp(self_hostname, addr2->self_hostname) != 0
 252        )  )
 253       self_hostname = NULL;
 254     if (!deliver_domain && !self_hostname) break;
 255     }
 256   }
 257 }
 258
 259
 260
 261
 262 /*************************************************
 263 *                Open a msglog file              *
 264 *************************************************/
 265
 266 /* This function is used both for normal message logs, and for files in the
 267 msglog directory that are used to catch output from pipes. Try to create the
 268 directory if it does not exist. From release 4.21, normal message logs should
 269 be created when the message is received.
 270
 271 Argument:
 272   filename  the file name
 273   mode      the mode required
 274   error     used for saying what failed
 275
 276 Returns:    a file descriptor, or -1 (with errno set)
 277 */
 278
 279 static int
 280 open_msglog_file(uschar *filename, int mode, uschar **error)
 281 {
 282 int fd = Uopen(filename, O_WRONLY|O_APPEND|O_CREAT, mode);
 283
 284 if (fd < 0 && errno == ENOENT)
 285   {
 286   (void)directory_make(spool_directory,
 287                         spool_sname(US"msglog", message_subdir),
 288                         MSGLOG_DIRECTORY_MODE, TRUE);
 289   fd = Uopen(filename, O_WRONLY|O_APPEND|O_CREAT, mode);
 290   }
 291
 292 /* Set the close-on-exec flag and change the owner to the exim uid/gid (this
 293 function is called as root). Double check the mode, because the group setting
 294 doesn't always get set automatically. */
 295
 296 if (fd >= 0)
 297   {
 298   (void)fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC);
 299   if (fchown(fd, exim_uid, exim_gid) < 0)
 300     {
 301     *error = US"chown";
 302     return -1;
 303     }
 304   if (fchmod(fd, mode) < 0)
 305     {
 306     *error = US"chmod";
 307     return -1;
 308     }
 309   }
 310 else *error = US"create";
 311
 312 return fd;
 313 }
 314
 315
 316
 317
 318 /*************************************************
 319 *           Write to msglog if required          *
 320 *************************************************/
 321
 322 /* Write to the message log, if configured. This function may also be called
 323 from transports.
 324
 325 Arguments:
 326   format       a string format
 327
 328 Returns:       nothing
 329 */
 330
 331 void
 332 deliver_msglog(const char *format, ...)
 333 {
 334 va_list ap;
 335 if (!message_logs) return;
 336 va_start(ap, format);
 337 vfprintf(message_log, format, ap);
 338 fflush(message_log);
 339 va_end(ap);
 340 }
 341
 342
 343
 344
 345 /*************************************************
 346 *            Replicate status for batch          *
 347 *************************************************/
 348
 349 /* When a transport handles a batch of addresses, it may treat them
 350 individually, or it may just put the status in the first one, and return FALSE,
 351 requesting that the status be copied to all the others externally. This is the
 352 replication function. As well as the status, it copies the transport pointer,
 353 which may have changed if appendfile passed the addresses on to a different
 354 transport.
 355
 356 Argument:    pointer to the first address in a chain
 357 Returns:     nothing
 358 */
 359
 360 static void
 361 replicate_status(address_item *addr)
 362 {
 363 address_item *addr2;
 364 for (addr2 = addr->next; addr2; addr2 = addr2->next)
 365   {
 366   addr2->transport =        addr->transport;
 367   addr2->transport_return = addr->transport_return;
 368   addr2->basic_errno =      addr->basic_errno;
 369   addr2->more_errno =       addr->more_errno;
 370   addr2->special_action =   addr->special_action;
 371   addr2->message =          addr->message;
 372   addr2->user_message =     addr->user_message;
 373   }
 374 }
 375
 376
 377
 378 /*************************************************
 379 *              Compare lists of hosts            *
 380 *************************************************/
 381
 382 /* This function is given two pointers to chains of host items, and it yields
 383 TRUE if the lists refer to the same hosts in the same order, except that
 384
 385 (1) Multiple hosts with the same non-negative MX values are permitted to appear
 386     in different orders. Round-robinning nameservers can cause this to happen.
 387
 388 (2) Multiple hosts with the same negative MX values less than MX_NONE are also
 389     permitted to appear in different orders. This is caused by randomizing
 390     hosts lists.
 391
 392 This enables Exim to use a single SMTP transaction for sending to two entirely
 393 different domains that happen to end up pointing at the same hosts.
 394
 395 Arguments:
 396   one       points to the first host list
 397   two       points to the second host list
 398
 399 Returns:    TRUE if the lists refer to the same host set
 400 */
 401
 402 static BOOL
 403 same_hosts(host_item *one, host_item *two)
 404 {
 405 while (one && two)
 406   {
 407   if (Ustrcmp(one->name, two->name) != 0)
 408     {
 409     int mx = one->mx;
 410     host_item *end_one = one;
 411     host_item *end_two = two;
 412
 413     /* Batch up only if there was no MX and the list was not randomized */
 414
 415     if (mx == MX_NONE) return FALSE;
 416
 417     /* Find the ends of the shortest sequence of identical MX values */
 418
 419     while (  end_one->next && end_one->next->mx == mx
 420           && end_two->next && end_two->next->mx == mx)
 421       {
 422       end_one = end_one->next;
 423       end_two = end_two->next;
 424       }
 425
 426     /* If there aren't any duplicates, there's no match. */
 427
 428     if (end_one == one) return FALSE;
 429
 430     /* For each host in the 'one' sequence, check that it appears in the 'two'
 431     sequence, returning FALSE if not. */
 432
 433     for (;;)
 434       {
 435       host_item *hi;
 436       for (hi = two; hi != end_two->next; hi = hi->next)
 437         if (Ustrcmp(one->name, hi->name) == 0) break;
 438       if (hi == end_two->next) return FALSE;
 439       if (one == end_one) break;
 440       one = one->next;
 441       }
 442
 443     /* All the hosts in the 'one' sequence were found in the 'two' sequence.
 444     Ensure both are pointing at the last host, and carry on as for equality. */
 445
 446     two = end_two;
 447     }
 448
 449   /* if the names matched but ports do not, mismatch */
 450   else if (one->port != two->port)
 451     return FALSE;
 452
 453   /* Hosts matched */
 454
 455   one = one->next;
 456   two = two->next;
 457   }
 458
 459 /* True if both are NULL */
 460
 461 return (one == two);
 462 }
 463
 464
 465
 466 /*************************************************
 467 *              Compare header lines              *
 468 *************************************************/
 469
 470 /* This function is given two pointers to chains of header items, and it yields
 471 TRUE if they are the same header texts in the same order.
 472
 473 Arguments:
 474   one       points to the first header list
 475   two       points to the second header list
 476
 477 Returns:    TRUE if the lists refer to the same header set
 478 */
 479
 480 static BOOL
 481 same_headers(header_line *one, header_line *two)
 482 {
 483 for (;; one = one->next, two = two->next)
 484   {
 485   if (one == two) return TRUE;   /* Includes the case where both NULL */
 486   if (!one || !two) return FALSE;
 487   if (Ustrcmp(one->text, two->text) != 0) return FALSE;
 488   }
 489 }
 490
 491
 492
 493 /*************************************************
 494 *            Compare string settings             *
 495 *************************************************/
 496
 497 /* This function is given two pointers to strings, and it returns
 498 TRUE if they are the same pointer, or if the two strings are the same.
 499
 500 Arguments:
 501   one       points to the first string
 502   two       points to the second string
 503
 504 Returns:    TRUE or FALSE
 505 */
 506
 507 static BOOL
 508 same_strings(uschar *one, uschar *two)
 509 {
 510 if (one == two) return TRUE;   /* Includes the case where both NULL */
 511 if (!one || !two) return FALSE;
 512 return (Ustrcmp(one, two) == 0);
 513 }
 514
 515
 516
 517 /*************************************************
 518 *        Compare uid/gid for addresses           *
 519 *************************************************/
 520
 521 /* This function is given a transport and two addresses. It yields TRUE if the
 522 uid/gid/initgroups settings for the two addresses are going to be the same when
 523 they are delivered.
 524
 525 Arguments:
 526   tp            the transort
 527   addr1         the first address
 528   addr2         the second address
 529
 530 Returns:        TRUE or FALSE
 531 */
 532
 533 static BOOL
 534 same_ugid(transport_instance *tp, address_item *addr1, address_item *addr2)
 535 {
 536 if (  !tp->uid_set && !tp->expand_uid
 537    && !tp->deliver_as_creator
 538    && (  testflag(addr1, af_uid_set) != testflag(addr2, af_gid_set)
 539       || (  testflag(addr1, af_uid_set)
 540          && (  addr1->uid != addr2->uid
 541             || testflag(addr1, af_initgroups) != testflag(addr2, af_initgroups)
 542    )  )  )  )
 543   return FALSE;
 544
 545 if (  !tp->gid_set && !tp->expand_gid
 546    && (  testflag(addr1, af_gid_set) != testflag(addr2, af_gid_set)
 547       || (  testflag(addr1, af_gid_set)
 548          && addr1->gid != addr2->gid
 549    )  )  )
 550   return FALSE;
 551
 552 return TRUE;
 553 }
 554
 555
 556
 557
 558 /*************************************************
 559 *      Record that an address is complete        *
 560 *************************************************/
 561
 562 /* This function records that an address is complete. This is straightforward
 563 for most addresses, where the unique address is just the full address with the
 564 domain lower cased. For homonyms (addresses that are the same as one of their
 565 ancestors) their are complications. Their unique addresses have \x\ prepended
 566 (where x = 0, 1, 2...), so that de-duplication works correctly for siblings and
 567 cousins.
 568
 569 Exim used to record the unique addresses of homonyms as "complete". This,
 570 however, fails when the pattern of redirection varies over time (e.g. if taking
 571 unseen copies at only some times of day) because the prepended numbers may vary
 572 from one delivery run to the next. This problem is solved by never recording
 573 prepended unique addresses as complete. Instead, when a homonymic address has
 574 actually been delivered via a transport, we record its basic unique address
 575 followed by the name of the transport. This is checked in subsequent delivery
 576 runs whenever an address is routed to a transport.
 577
 578 If the completed address is a top-level one (has no parent, which means it
 579 cannot be homonymic) we also add the original address to the non-recipients
 580 tree, so that it gets recorded in the spool file and therefore appears as
 581 "done" in any spool listings. The original address may differ from the unique
 582 address in the case of the domain.
 583
 584 Finally, this function scans the list of duplicates, marks as done any that
 585 match this address, and calls child_done() for their ancestors.
 586
 587 Arguments:
 588   addr        address item that has been completed
 589   now         current time as a string
 590
 591 Returns:      nothing
 592 */
 593
 594 static void
 595 address_done(address_item *addr, uschar *now)
 596 {
 597 address_item *dup;
 598
 599 update_spool = TRUE;        /* Ensure spool gets updated */
 600
 601 /* Top-level address */
 602
 603 if (!addr->parent)
 604   {
 605   tree_add_nonrecipient(addr->unique);
 606   tree_add_nonrecipient(addr->address);
 607   }
 608
 609 /* Homonymous child address */
 610
 611 else if (testflag(addr, af_homonym))
 612   {
 613   if (addr->transport)
 614     tree_add_nonrecipient(
 615       string_sprintf("%s/%s", addr->unique + 3, addr->transport->name));
 616   }
 617
 618 /* Non-homonymous child address */
 619
 620 else tree_add_nonrecipient(addr->unique);
 621
 622 /* Check the list of duplicate addresses and ensure they are now marked
 623 done as well. */
 624
 625 for (dup = addr_duplicate; dup; dup = dup->next)
 626   if (Ustrcmp(addr->unique, dup->unique) == 0)
 627     {
 628     tree_add_nonrecipient(dup->unique);
 629     child_done(dup, now);
 630     }
 631 }
 632
 633
 634
 635
 636 /*************************************************
 637 *      Decrease counts in parents and mark done  *
 638 *************************************************/
 639
 640 /* This function is called when an address is complete. If there is a parent
 641 address, its count of children is decremented. If there are still other
 642 children outstanding, the function exits. Otherwise, if the count has become
 643 zero, address_done() is called to mark the parent and its duplicates complete.
 644 Then loop for any earlier ancestors.
 645
 646 Arguments:
 647   addr      points to the completed address item
 648   now       the current time as a string, for writing to the message log
 649
 650 Returns:    nothing
 651 */
 652
 653 static void
 654 child_done(address_item *addr, uschar *now)
 655 {
 656 address_item *aa;
 657 while (addr->parent)
 658   {
 659   addr = addr->parent;
 660   if ((addr->child_count -= 1) > 0) return;   /* Incomplete parent */
 661   address_done(addr, now);
 662
 663   /* Log the completion of all descendents only when there is no ancestor with
 664   the same original address. */
 665
 666   for (aa = addr->parent; aa; aa = aa->parent)
 667     if (Ustrcmp(aa->address, addr->address) == 0) break;
 668   if (aa) continue;
 669
 670   deliver_msglog("%s %s: children all complete\n", now, addr->address);
 671   DEBUG(D_deliver) debug_printf("%s: children all complete\n", addr->address);
 672   }
 673 }
 674
 675
 676
 677 /*************************************************
 678 *      Delivery logging support functions        *
 679 *************************************************/
 680
 681 /* The LOGGING() checks in d_log_interface() are complicated for backwards
 682 compatibility. When outgoing interface logging was originally added, it was
 683 conditional on just incoming_interface (which is off by default). The
 684 outgoing_interface option is on by default to preserve this behaviour, but
 685 you can enable incoming_interface and disable outgoing_interface to get I=
 686 fields on incoming lines only.
 687
 688 Arguments:
 689   s         The log line buffer
 690   sizep     Pointer to the buffer size
 691   ptrp      Pointer to current index into buffer
 692   addr      The address to be logged
 693
 694 Returns:    New value for s
 695 */
 696
 697 static uschar *
 698 d_log_interface(uschar *s, int *sizep, int *ptrp)
 699 {
 700 if (LOGGING(incoming_interface) && LOGGING(outgoing_interface)
 701     && sending_ip_address)
 702   {
 703   s = string_append(s, sizep, ptrp, 2, US" I=[", sending_ip_address);
 704   s = LOGGING(outgoing_port)
 705     ? string_append(s, sizep, ptrp, 2, US"]:",
 706         string_sprintf("%d", sending_port))
 707     : string_catn(s, sizep, ptrp, US"]", 1);
 708   }
 709 return s;
 710 }
 711
 712
 713
 714 static uschar *
 715 d_hostlog(uschar * s, int * sp, int * pp, address_item * addr)
 716 {
 717 host_item * h = addr->host_used;
 718
 719 s = string_append(s, sp, pp, 2, US" H=", h->name);
 720
 721 if (LOGGING(dnssec) && h->dnssec == DS_YES)
 722   s = string_catn(s, sp, pp, US" DS", 3);
 723
 724 s = string_append(s, sp, pp, 3, US" [", h->address, US"]");
 725
 726 if (LOGGING(outgoing_port))
 727   s = string_append(s, sp, pp, 2, US":", string_sprintf("%d", h->port));
 728
 729 #ifdef SUPPORT_SOCKS
 730 if (LOGGING(proxy) && proxy_local_address)
 731   {
 732   s = string_append(s, sp, pp, 3, US" PRX=[", proxy_local_address, US"]");
 733   if (LOGGING(outgoing_port))
 734     s = string_append(s, sp, pp, 2, US":", string_sprintf("%d",
 735       proxy_local_port));
 736   }
 737 #endif
 738
 739 return d_log_interface(s, sp, pp);
 740 }
 741
 742
 743
 744
 745
 746 #ifdef SUPPORT_TLS
 747 static uschar *
 748 d_tlslog(uschar * s, int * sizep, int * ptrp, address_item * addr)
 749 {
 750 if (LOGGING(tls_cipher) && addr->cipher)
 751   s = string_append(s, sizep, ptrp, 2, US" X=", addr->cipher);
 752 if (LOGGING(tls_certificate_verified) && addr->cipher)
 753   s = string_append(s, sizep, ptrp, 2, US" CV=",
 754     testflag(addr, af_cert_verified)
 755     ?
 756 #ifdef EXPERIMENTAL_DANE
 757       testflag(addr, af_dane_verified)
 758     ? "dane"
 759     :
 760 #endif
 761       "yes"
 762     : "no");
 763 if (LOGGING(tls_peerdn) && addr->peerdn)
 764   s = string_append(s, sizep, ptrp, 3, US" DN=\"",
 765     string_printing(addr->peerdn), US"\"");
 766 return s;
 767 }
 768 #endif
 769
 770
 771
 772
 773 #ifndef DISABLE_EVENT
 774 uschar *
 775 event_raise(uschar * action, const uschar * event, uschar * ev_data)
 776 {
 777 uschar * s;
 778 if (action)
 779   {
 780   DEBUG(D_deliver)
 781     debug_printf("Event(%s): event_action=|%s| delivery_IP=%s\n",
 782       event,
 783       action, deliver_host_address);
 784
 785   event_name = event;
 786   event_data = ev_data;
 787
 788   if (!(s = expand_string(action)) && *expand_string_message)
 789     log_write(0, LOG_MAIN|LOG_PANIC,
 790       "failed to expand event_action %s in %s: %s\n",
 791       event, transport_name, expand_string_message);
 792
 793   event_name = event_data = NULL;
 794
 795   /* If the expansion returns anything but an empty string, flag for
 796   the caller to modify his normal processing
 797   */
 798   if (s && *s)
 799     {
 800     DEBUG(D_deliver)
 801       debug_printf("Event(%s): event_action returned \"%s\"\n", event, s);
 802     return s;
 803     }
 804   }
 805 return NULL;
 806 }
 807
 808 void
 809 msg_event_raise(const uschar * event, const address_item * addr)
 810 {
 811 const uschar * save_domain = deliver_domain;
 812 uschar * save_local =  deliver_localpart;
 813 const uschar * save_host = deliver_host;
 814 const uschar * save_address = deliver_host_address;
 815 const int      save_port =   deliver_host_port;
 816
 817 if (!addr->transport)
 818   return;
 819
 820 router_name =    addr->router ? addr->router->name : NULL;
 821 transport_name = addr->transport->name;
 822 deliver_domain = addr->domain;
 823 deliver_localpart = addr->local_part;
 824 deliver_host =   addr->host_used ? addr->host_used->name : NULL;
 825
 826 (void) event_raise(addr->transport->event_action, event,
 827           addr->host_used
 828           || Ustrcmp(addr->transport->driver_name, "smtp") == 0
 829           || Ustrcmp(addr->transport->driver_name, "lmtp") == 0
 830          ? addr->message : NULL);
 831
 832 deliver_host_port =    save_port;
 833 deliver_host_address = save_address;
 834 deliver_host =      save_host;
 835 deliver_localpart = save_local;
 836 deliver_domain =    save_domain;
 837 router_name = transport_name = NULL;
 838 }
 839 #endif  /*DISABLE_EVENT*/
 840
 841
 842
 843 /******************************************************************************/
 844
 845
 846 /*************************************************
 847 *        Generate local prt for logging          *
 848 *************************************************/
 849
 850 /* This function is a subroutine for use in string_log_address() below.
 851
 852 Arguments:
 853   addr        the address being logged
 854   yield       the current dynamic buffer pointer
 855   sizeptr     points to current size
 856   ptrptr      points to current insert pointer
 857
 858 Returns:      the new value of the buffer pointer
 859 */
 860
 861 static uschar *
 862 string_get_localpart(address_item *addr, uschar *yield, int *sizeptr,
 863   int *ptrptr)
 864 {
 865 uschar * s;
 866
 867 s = addr->prefix;
 868 if (testflag(addr, af_include_affixes) && s)
 869   {
 870 #ifdef SUPPORT_I18N
 871   if (testflag(addr, af_utf8_downcvt))
 872     s = string_localpart_utf8_to_alabel(s, NULL);
 873 #endif
 874   yield = string_cat(yield, sizeptr, ptrptr, s);
 875   }
 876
 877 s = addr->local_part;
 878 #ifdef SUPPORT_I18N
 879 if (testflag(addr, af_utf8_downcvt))
 880   s = string_localpart_utf8_to_alabel(s, NULL);
 881 #endif
 882 yield = string_cat(yield, sizeptr, ptrptr, s);
 883
 884 s = addr->suffix;
 885 if (testflag(addr, af_include_affixes) && s)
 886   {
 887 #ifdef SUPPORT_I18N
 888   if (testflag(addr, af_utf8_downcvt))
 889     s = string_localpart_utf8_to_alabel(s, NULL);
 890 #endif
 891   yield = string_cat(yield, sizeptr, ptrptr, s);
 892   }
 893
 894 return yield;
 895 }
 896
 897
 898 /*************************************************
 899 *          Generate log address list             *
 900 *************************************************/
 901
 902 /* This function generates a list consisting of an address and its parents, for
 903 use in logging lines. For saved onetime aliased addresses, the onetime parent
 904 field is used. If the address was delivered by a transport with rcpt_include_
 905 affixes set, the af_include_affixes bit will be set in the address. In that
 906 case, we include the affixes here too.
 907
 908 Arguments:
 909   str           points to start of growing string, or NULL
 910   size          points to current allocation for string
 911   ptr           points to offset for append point; updated on exit
 912   addr          bottom (ultimate) address
 913   all_parents   if TRUE, include all parents
 914   success       TRUE for successful delivery
 915
 916 Returns:        a growable string in dynamic store
 917 */
 918
 919 static uschar *
 920 string_log_address(uschar * str, int * size, int * ptr,
 921   address_item *addr, BOOL all_parents, BOOL success)
 922 {
 923 BOOL add_topaddr = TRUE;
 924 address_item *topaddr;
 925
 926 /* Find the ultimate parent */
 927
 928 for (topaddr = addr; topaddr->parent; topaddr = topaddr->parent) ;
 929
 930 /* We start with just the local part for pipe, file, and reply deliveries, and
 931 for successful local deliveries from routers that have the log_as_local flag
 932 set. File deliveries from filters can be specified as non-absolute paths in
 933 cases where the transport is goin to complete the path. If there is an error
 934 before this happens (expansion failure) the local part will not be updated, and
 935 so won't necessarily look like a path. Add extra text for this case. */
 936
 937 if (  testflag(addr, af_pfr)
 938    || (  success
 939       && addr->router && addr->router->log_as_local
 940       && addr->transport && addr->transport->info->local
 941    )  )
 942   {
 943   if (testflag(addr, af_file) && addr->local_part[0] != '/')
 944     str = string_catn(str, size, ptr, CUS"save ", 5);
 945   str = string_get_localpart(addr, str, size, ptr);
 946   }
 947
 948 /* Other deliveries start with the full address. It we have split it into local
 949 part and domain, use those fields. Some early failures can happen before the
 950 splitting is done; in those cases use the original field. */
 951
 952 else
 953   {
 954   uschar * cmp = str + *ptr;
 955
 956   if (addr->local_part)
 957     {
 958     const uschar * s;
 959     str = string_get_localpart(addr, str, size, ptr);
 960     str = string_catn(str, size, ptr, US"@", 1);
 961     s = addr->domain;
 962 #ifdef SUPPORT_I18N
 963     if (testflag(addr, af_utf8_downcvt))
 964       s = string_localpart_utf8_to_alabel(s, NULL);
 965 #endif
 966     str = string_cat(str, size, ptr, s);
 967     }
 968   else
 969     str = string_cat(str, size, ptr, addr->address);
 970
 971   /* If the address we are going to print is the same as the top address,
 972   and all parents are not being included, don't add on the top address. First
 973   of all, do a caseless comparison; if this succeeds, do a caseful comparison
 974   on the local parts. */
 975
 976   str[*ptr] = 0;
 977   if (  strcmpic(cmp, topaddr->address) == 0
 978      && Ustrncmp(cmp, topaddr->address, Ustrchr(cmp, '@') - cmp) == 0
 979      && !addr->onetime_parent
 980      && (!all_parents || !addr->parent || addr->parent == topaddr)
 981      )
 982     add_topaddr = FALSE;
 983   }
 984
 985 /* If all parents are requested, or this is a local pipe/file/reply, and
 986 there is at least one intermediate parent, show it in brackets, and continue
 987 with all of them if all are wanted. */
 988
 989 if (  (all_parents || testflag(addr, af_pfr))
 990    && addr->parent
 991    && addr->parent != topaddr)
 992   {
 993   uschar *s = US" (";
 994   address_item *addr2;
 995   for (addr2 = addr->parent; addr2 != topaddr; addr2 = addr2->parent)
 996     {
 997     str = string_catn(str, size, ptr, s, 2);
 998     str = string_cat (str, size, ptr, addr2->address);
 999     if (!all_parents) break;
1000     s = US", ";
1001     }
1002   str = string_catn(str, size, ptr, US")", 1);
1003   }
1004
1005 /* Add the top address if it is required */
1006
1007 if (add_topaddr)
1008   str = string_append(str, size, ptr, 3,
1009     US" <",
1010     addr->onetime_parent ? addr->onetime_parent : topaddr->address,
1011     US">");
1012
1013 return str;
1014 }
1015
1016
1017 /******************************************************************************/
1018
1019
1020
1021 /* If msg is NULL this is a delivery log and logchar is used. Otherwise
1022 this is a nonstandard call; no two-character delivery flag is written
1023 but sender-host and sender are prefixed and "msg" is inserted in the log line.
1024
1025 Arguments:
1026   flags         passed to log_write()
1027 */
1028 void
1029 delivery_log(int flags, address_item * addr, int logchar, uschar * msg)
1030 {
1031 int size = 256;         /* Used for a temporary, */
1032 int ptr = 0;            /* expanding buffer, for */
1033 uschar * s;             /* building log lines;   */
1034 void * reset_point;     /* released afterwards.  */
1035
1036 /* Log the delivery on the main log. We use an extensible string to build up
1037 the log line, and reset the store afterwards. Remote deliveries should always
1038 have a pointer to the host item that succeeded; local deliveries can have a
1039 pointer to a single host item in their host list, for use by the transport. */
1040
1041 #ifndef DISABLE_EVENT
1042   /* presume no successful remote delivery */
1043   lookup_dnssec_authenticated = NULL;
1044 #endif
1045
1046 s = reset_point = store_get(size);
1047
1048 if (msg)
1049   s = string_append(s, &size, &ptr, 2, host_and_ident(TRUE), US" ");
1050 else
1051   {
1052   s[ptr++] = logchar;
1053   s = string_catn(s, &size, &ptr, US"> ", 2);
1054   }
1055 s = string_log_address(s, &size, &ptr, addr, LOGGING(all_parents), TRUE);
1056
1057 if (LOGGING(sender_on_delivery) || msg)
1058   s = string_append(s, &size, &ptr, 3, US" F=<",
1059 #ifdef SUPPORT_I18N
1060     testflag(addr, af_utf8_downcvt)
1061     ? string_address_utf8_to_alabel(sender_address, NULL)
1062     :
1063 #endif
1064       sender_address,
1065   US">");
1066
1067 if (*queue_name)
1068   s = string_append(s, &size, &ptr, 2, US" Q=", queue_name);
1069
1070 #ifdef EXPERIMENTAL_SRS
1071 if(addr->prop.srs_sender)
1072   s = string_append(s, &size, &ptr, 3, US" SRS=<", addr->prop.srs_sender, US">");
1073 #endif
1074
1075 /* You might think that the return path must always be set for a successful
1076 delivery; indeed, I did for some time, until this statement crashed. The case
1077 when it is not set is for a delivery to /dev/null which is optimised by not
1078 being run at all. */
1079
1080 if (used_return_path && LOGGING(return_path_on_delivery))
1081   s = string_append(s, &size, &ptr, 3, US" P=<", used_return_path, US">");
1082
1083 if (msg)
1084   s = string_append(s, &size, &ptr, 2, US" ", msg);
1085
1086 /* For a delivery from a system filter, there may not be a router */
1087 if (addr->router)
1088   s = string_append(s, &size, &ptr, 2, US" R=", addr->router->name);
1089
1090 s = string_append(s, &size, &ptr, 2, US" T=", addr->transport->name);
1091
1092 if (LOGGING(delivery_size))
1093   s = string_append(s, &size, &ptr, 2, US" S=",
1094     string_sprintf("%d", transport_count));
1095
1096 /* Local delivery */
1097
1098 if (addr->transport->info->local)
1099   {
1100   if (addr->host_list)
1101     s = string_append(s, &size, &ptr, 2, US" H=", addr->host_list->name);
1102   s = d_log_interface(s, &size, &ptr);
1103   if (addr->shadow_message)
1104     s = string_cat(s, &size, &ptr, addr->shadow_message);
1105   }
1106
1107 /* Remote delivery */
1108
1109 else
1110   {
1111   if (addr->host_used)
1112     {
1113     s = d_hostlog(s, &size, &ptr, addr);
1114     if (continue_sequence > 1)
1115       s = string_catn(s, &size, &ptr, US"*", 1);
1116
1117 #ifndef DISABLE_EVENT
1118     deliver_host_address = addr->host_used->address;
1119     deliver_host_port =    addr->host_used->port;
1120     deliver_host =         addr->host_used->name;
1121
1122     /* DNS lookup status */
1123     lookup_dnssec_authenticated = addr->host_used->dnssec==DS_YES ? US"yes"
1124                               : addr->host_used->dnssec==DS_NO ? US"no"
1125                               : NULL;
1126 #endif
1127     }
1128
1129 #ifdef SUPPORT_TLS
1130   s = d_tlslog(s, &size, &ptr, addr);
1131 #endif
1132
1133   if (addr->authenticator)
1134     {
1135     s = string_append(s, &size, &ptr, 2, US" A=", addr->authenticator);
1136     if (addr->auth_id)
1137       {
1138       s = string_append(s, &size, &ptr, 2, US":", addr->auth_id);
1139       if (LOGGING(smtp_mailauth) && addr->auth_sndr)
1140         s = string_append(s, &size, &ptr, 2, US":", addr->auth_sndr);
1141       }
1142     }
1143
1144 #ifndef DISABLE_PRDR
1145   if (addr->flags & af_prdr_used)
1146     s = string_catn(s, &size, &ptr, US" PRDR", 5);
1147 #endif
1148
1149   if (addr->flags & af_chunking_used)
1150     s = string_catn(s, &size, &ptr, US" K", 2);
1151   }
1152
1153 /* confirmation message (SMTP (host_used) and LMTP (driver_name)) */
1154
1155 if (  LOGGING(smtp_confirmation)
1156    && addr->message
1157    && (addr->host_used || Ustrcmp(addr->transport->driver_name, "lmtp") == 0)
1158    )
1159   {
1160   unsigned i;
1161   unsigned lim = big_buffer_size < 1024 ? big_buffer_size : 1024;
1162   uschar *p = big_buffer;
1163   uschar *ss = addr->message;
1164   *p++ = '\"';
1165   for (i = 0; i < lim && ss[i] != 0; i++)       /* limit logged amount */
1166     {
1167     if (ss[i] == '\"' || ss[i] == '\\') *p++ = '\\'; /* quote \ and " */
1168     *p++ = ss[i];
1169     }
1170   *p++ = '\"';
1171   *p = 0;
1172   s = string_append(s, &size, &ptr, 2, US" C=", big_buffer);
1173   }
1174
1175 /* Time on queue and actual time taken to deliver */
1176
1177 if (LOGGING(queue_time))
1178   s = string_append(s, &size, &ptr, 2, US" QT=",
1179     readconf_printtime( (int) ((long)time(NULL) - (long)received_time)) );
1180
1181 if (LOGGING(deliver_time))
1182   s = string_append(s, &size, &ptr, 2, US" DT=",
1183     readconf_printtime(addr->more_errno));
1184
1185 /* string_cat() always leaves room for the terminator. Release the
1186 store we used to build the line after writing it. */
1187
1188 s[ptr] = 0;
1189 log_write(0, flags, "%s", s);
1190
1191 #ifndef DISABLE_EVENT
1192 if (!msg) msg_event_raise(US"msg:delivery", addr);
1193 #endif
1194
1195 store_reset(reset_point);
1196 return;
1197 }
1198
1199
1200
1201 static void
1202 deferral_log(address_item * addr, uschar * now,
1203   int logflags, uschar * driver_name, uschar * driver_kind)
1204 {
1205 int size = 256;         /* Used for a temporary, */
1206 int ptr = 0;            /* expanding buffer, for */
1207 uschar * s;             /* building log lines;   */
1208 void * reset_point;     /* released afterwards.  */
1209
1210 uschar ss[32];
1211
1212 /* Build up the line that is used for both the message log and the main
1213 log. */
1214
1215 s = reset_point = store_get(size);
1216
1217 /* Create the address string for logging. Must not do this earlier, because
1218 an OK result may be changed to FAIL when a pipe returns text. */
1219
1220 s = string_log_address(s, &size, &ptr, addr, LOGGING(all_parents), FALSE);
1221
1222 if (*queue_name)
1223   s = string_append(s, &size, &ptr, 2, US" Q=", queue_name);
1224
1225 /* Either driver_name contains something and driver_kind contains
1226 " router" or " transport" (note the leading space), or driver_name is
1227 a null string and driver_kind contains "routing" without the leading
1228 space, if all routing has been deferred. When a domain has been held,
1229 so nothing has been done at all, both variables contain null strings. */
1230
1231 if (driver_name)
1232   {
1233   if (driver_kind[1] == 't' && addr->router)
1234     s = string_append(s, &size, &ptr, 2, US" R=", addr->router->name);
1235   Ustrcpy(ss, " ?=");
1236   ss[1] = toupper(driver_kind[1]);
1237   s = string_append(s, &size, &ptr, 2, ss, driver_name);
1238   }
1239 else if (driver_kind)
1240   s = string_append(s, &size, &ptr, 2, US" ", driver_kind);
1241
1242 /*XXX need an s+s+p sprintf */
1243 sprintf(CS ss, " defer (%d)", addr->basic_errno);
1244 s = string_cat(s, &size, &ptr, ss);
1245
1246 if (addr->basic_errno > 0)
1247   s = string_append(s, &size, &ptr, 2, US": ",
1248     US strerror(addr->basic_errno));
1249
1250 if (addr->host_used)
1251   {
1252   s = string_append(s, &size, &ptr, 5,
1253                     US" H=", addr->host_used->name,
1254                     US" [",  addr->host_used->address, US"]");
1255   if (LOGGING(outgoing_port))
1256     {
1257     int port = addr->host_used->port;
1258     s = string_append(s, &size, &ptr, 2,
1259           US":", port == PORT_NONE ? US"25" : string_sprintf("%d", port));
1260     }
1261   }
1262
1263 if (addr->message)
1264   s = string_append(s, &size, &ptr, 2, US": ", addr->message);
1265
1266 s[ptr] = 0;
1267
1268 /* Log the deferment in the message log, but don't clutter it
1269 up with retry-time defers after the first delivery attempt. */
1270
1271 if (deliver_firsttime || addr->basic_errno > ERRNO_RETRY_BASE)
1272   deliver_msglog("%s %s\n", now, s);
1273
1274 /* Write the main log and reset the store.
1275 For errors of the type "retry time not reached" (also remotes skipped
1276 on queue run), logging is controlled by L_retry_defer. Note that this kind
1277 of error number is negative, and all the retry ones are less than any
1278 others. */
1279
1280
1281 log_write(addr->basic_errno <= ERRNO_RETRY_BASE ? L_retry_defer : 0, logflags,
1282   "== %s", s);
1283
1284 store_reset(reset_point);
1285 return;
1286 }
1287
1288
1289
1290 static void
1291 failure_log(address_item * addr, uschar * driver_kind, uschar * now)
1292 {
1293 int size = 256;         /* Used for a temporary, */
1294 int ptr = 0;            /* expanding buffer, for */
1295 uschar * s;             /* building log lines;   */
1296 void * reset_point;     /* released afterwards.  */
1297
1298 /* Build up the log line for the message and main logs */
1299
1300 s = reset_point = store_get(size);
1301
1302 /* Create the address string for logging. Must not do this earlier, because
1303 an OK result may be changed to FAIL when a pipe returns text. */
1304
1305 s = string_log_address(s, &size, &ptr, addr, LOGGING(all_parents), FALSE);
1306
1307 if (LOGGING(sender_on_delivery))
1308   s = string_append(s, &size, &ptr, 3, US" F=<", sender_address, US">");
1309
1310 if (*queue_name)
1311   s = string_append(s, &size, &ptr, 2, US" Q=", queue_name);
1312
1313 /* Return path may not be set if no delivery actually happened */
1314
1315 if (used_return_path && LOGGING(return_path_on_delivery))
1316   s = string_append(s, &size, &ptr, 3, US" P=<", used_return_path, US">");
1317
1318 if (addr->router)
1319   s = string_append(s, &size, &ptr, 2, US" R=", addr->router->name);
1320 if (addr->transport)
1321   s = string_append(s, &size, &ptr, 2, US" T=", addr->transport->name);
1322
1323 if (addr->host_used)
1324   s = d_hostlog(s, &size, &ptr, addr);
1325
1326 #ifdef SUPPORT_TLS
1327 s = d_tlslog(s, &size, &ptr, addr);
1328 #endif
1329
1330 if (addr->basic_errno > 0)
1331   s = string_append(s, &size, &ptr, 2, US": ", US strerror(addr->basic_errno));
1332
1333 if (addr->message)
1334   s = string_append(s, &size, &ptr, 2, US": ", addr->message);
1335
1336 s[ptr] = 0;
1337
1338 /* Do the logging. For the message log, "routing failed" for those cases,
1339 just to make it clearer. */
1340
1341 if (driver_kind)
1342   deliver_msglog("%s %s failed for %s\n", now, driver_kind, s);
1343 else
1344   deliver_msglog("%s %s\n", now, s);
1345
1346 log_write(0, LOG_MAIN, "** %s", s);
1347
1348 #ifndef DISABLE_EVENT
1349 msg_event_raise(US"msg:fail:delivery", addr);
1350 #endif
1351
1352 store_reset(reset_point);
1353 return;
1354 }
1355
1356
1357
1358 /*************************************************
1359 *    Actions at the end of handling an address   *
1360 *************************************************/
1361
1362 /* This is a function for processing a single address when all that can be done
1363 with it has been done.
1364
1365 Arguments:
1366   addr         points to the address block
1367   result       the result of the delivery attempt
1368   logflags     flags for log_write() (LOG_MAIN and/or LOG_PANIC)
1369   driver_type  indicates which type of driver (transport, or router) was last
1370                  to process the address
1371   logchar      '=' or '-' for use when logging deliveries with => or ->
1372
1373 Returns:       nothing
1374 */
1375
1376 static void
1377 post_process_one(address_item *addr, int result, int logflags, int driver_type,
1378   int logchar)
1379 {
1380 uschar *now = tod_stamp(tod_log);
1381 uschar *driver_kind = NULL;
1382 uschar *driver_name = NULL;
1383
1384 DEBUG(D_deliver) debug_printf("post-process %s (%d)\n", addr->address, result);
1385
1386 /* Set up driver kind and name for logging. Disable logging if the router or
1387 transport has disabled it. */
1388
1389 if (driver_type == DTYPE_TRANSPORT)
1390   {
1391   if (addr->transport)
1392     {
1393     driver_name = addr->transport->name;
1394     driver_kind = US" transport";
1395     disable_logging = addr->transport->disable_logging;
1396     }
1397   else driver_kind = US"transporting";
1398   }
1399 else if (driver_type == DTYPE_ROUTER)
1400   {
1401   if (addr->router)
1402     {
1403     driver_name = addr->router->name;
1404     driver_kind = US" router";
1405     disable_logging = addr->router->disable_logging;
1406     }
1407   else driver_kind = US"routing";
1408   }
1409
1410 /* If there's an error message set, ensure that it contains only printing
1411 characters - it should, but occasionally things slip in and this at least
1412 stops the log format from getting wrecked. We also scan the message for an LDAP
1413 expansion item that has a password setting, and flatten the password. This is a
1414 fudge, but I don't know a cleaner way of doing this. (If the item is badly
1415 malformed, it won't ever have gone near LDAP.) */
1416
1417 if (addr->message)
1418   {
1419   const uschar * s = string_printing(addr->message);
1420
1421   /* deconst cast ok as string_printing known to have alloc'n'copied */
1422   addr->message = expand_hide_passwords(US s);
1423   }
1424
1425 /* If we used a transport that has one of the "return_output" options set, and
1426 if it did in fact generate some output, then for return_output we treat the
1427 message as failed if it was not already set that way, so that the output gets
1428 returned to the sender, provided there is a sender to send it to. For
1429 return_fail_output, do this only if the delivery failed. Otherwise we just
1430 unlink the file, and remove the name so that if the delivery failed, we don't
1431 try to send back an empty or unwanted file. The log_output options operate only
1432 on a non-empty file.
1433
1434 In any case, we close the message file, because we cannot afford to leave a
1435 file-descriptor for one address while processing (maybe very many) others. */
1436
1437 if (addr->return_file >= 0 && addr->return_filename)
1438   {
1439   BOOL return_output = FALSE;
1440   struct stat statbuf;
1441   (void)EXIMfsync(addr->return_file);
1442
1443   /* If there is no output, do nothing. */
1444
1445   if (fstat(addr->return_file, &statbuf) == 0 && statbuf.st_size > 0)
1446     {
1447     transport_instance *tb = addr->transport;
1448
1449     /* Handle logging options */
1450
1451     if (  tb->log_output
1452        || result == FAIL  && tb->log_fail_output
1453        || result == DEFER && tb->log_defer_output
1454        )
1455       {
1456       uschar *s;
1457       FILE *f = Ufopen(addr->return_filename, "rb");
1458       if (!f)
1459         log_write(0, LOG_MAIN|LOG_PANIC, "failed to open %s to log output "
1460           "from %s transport: %s", addr->return_filename, tb->name,
1461           strerror(errno));
1462       else
1463         if ((s = US Ufgets(big_buffer, big_buffer_size, f)))
1464           {
1465           uschar *p = big_buffer + Ustrlen(big_buffer);
1466           const uschar * sp;
1467           while (p > big_buffer && isspace(p[-1])) p--;
1468           *p = 0;
1469           sp = string_printing(big_buffer);
1470           log_write(0, LOG_MAIN, "<%s>: %s transport output: %s",
1471             addr->address, tb->name, sp);
1472           }
1473         (void)fclose(f);
1474       }
1475
1476     /* Handle returning options, but only if there is an address to return
1477     the text to. */
1478
1479     if (sender_address[0] != 0 || addr->prop.errors_address)
1480       if (tb->return_output)
1481         {
1482         addr->transport_return = result = FAIL;
1483         if (addr->basic_errno == 0 && !addr->message)
1484           addr->message = US"return message generated";
1485         return_output = TRUE;
1486         }
1487       else
1488         if (tb->return_fail_output && result == FAIL) return_output = TRUE;
1489     }
1490
1491   /* Get rid of the file unless it might be returned, but close it in
1492   all cases. */
1493
1494   if (!return_output)
1495     {
1496     Uunlink(addr->return_filename);
1497     addr->return_filename = NULL;
1498     addr->return_file = -1;
1499     }
1500
1501   (void)close(addr->return_file);
1502   }
1503
1504 /* The success case happens only after delivery by a transport. */
1505
1506 if (result == OK)
1507   {
1508   addr->next = addr_succeed;
1509   addr_succeed = addr;
1510
1511   /* Call address_done() to ensure that we don't deliver to this address again,
1512   and write appropriate things to the message log. If it is a child address, we
1513   call child_done() to scan the ancestors and mark them complete if this is the
1514   last child to complete. */
1515
1516   address_done(addr, now);
1517   DEBUG(D_deliver) debug_printf("%s delivered\n", addr->address);
1518
1519   if (!addr->parent)
1520     deliver_msglog("%s %s: %s%s succeeded\n", now, addr->address,
1521       driver_name, driver_kind);
1522   else
1523     {
1524     deliver_msglog("%s %s <%s>: %s%s succeeded\n", now, addr->address,
1525       addr->parent->address, driver_name, driver_kind);
1526     child_done(addr, now);
1527     }
1528
1529   /* Certificates for logging (via events) */
1530 #ifdef SUPPORT_TLS
1531   tls_out.ourcert = addr->ourcert;
1532   addr->ourcert = NULL;
1533   tls_out.peercert = addr->peercert;
1534   addr->peercert = NULL;
1535
1536   tls_out.cipher = addr->cipher;
1537   tls_out.peerdn = addr->peerdn;
1538   tls_out.ocsp = addr->ocsp;
1539 # ifdef EXPERIMENTAL_DANE
1540   tls_out.dane_verified = testflag(addr, af_dane_verified);
1541 # endif
1542 #endif
1543
1544   delivery_log(LOG_MAIN, addr, logchar, NULL);
1545
1546 #ifdef SUPPORT_TLS
1547   tls_free_cert(&tls_out.ourcert);
1548   tls_free_cert(&tls_out.peercert);
1549   tls_out.cipher = NULL;
1550   tls_out.peerdn = NULL;
1551   tls_out.ocsp = OCSP_NOT_REQ;
1552 # ifdef EXPERIMENTAL_DANE
1553   tls_out.dane_verified = FALSE;
1554 # endif
1555 #endif
1556   }
1557
1558
1559 /* Soft failure, or local delivery process failed; freezing may be
1560 requested. */
1561
1562 else if (result == DEFER || result == PANIC)
1563   {
1564   if (result == PANIC) logflags |= LOG_PANIC;
1565
1566   /* This puts them on the chain in reverse order. Do not change this, because
1567   the code for handling retries assumes that the one with the retry
1568   information is last. */
1569
1570   addr->next = addr_defer;
1571   addr_defer = addr;
1572
1573   /* The only currently implemented special action is to freeze the
1574   message. Logging of this is done later, just before the -H file is
1575   updated. */
1576
1577   if (addr->special_action == SPECIAL_FREEZE)
1578     {
1579     deliver_freeze = TRUE;
1580     deliver_frozen_at = time(NULL);
1581     update_spool = TRUE;
1582     }
1583
1584   /* If doing a 2-stage queue run, we skip writing to either the message
1585   log or the main log for SMTP defers. */
1586
1587   if (!queue_2stage || addr->basic_errno != 0)
1588     deferral_log(addr, now, logflags, driver_name, driver_kind);
1589   }
1590
1591
1592 /* Hard failure. If there is an address to which an error message can be sent,
1593 put this address on the failed list. If not, put it on the deferred list and
1594 freeze the mail message for human attention. The latter action can also be
1595 explicitly requested by a router or transport. */
1596
1597 else
1598   {
1599   /* If this is a delivery error, or a message for which no replies are
1600   wanted, and the message's age is greater than ignore_bounce_errors_after,
1601   force the af_ignore_error flag. This will cause the address to be discarded
1602   later (with a log entry). */
1603
1604   if (!*sender_address && message_age >= ignore_bounce_errors_after)
1605     setflag(addr, af_ignore_error);
1606
1607   /* Freeze the message if requested, or if this is a bounce message (or other
1608   message with null sender) and this address does not have its own errors
1609   address. However, don't freeze if errors are being ignored. The actual code
1610   to ignore occurs later, instead of sending a message. Logging of freezing
1611   occurs later, just before writing the -H file. */
1612
1613   if (  !testflag(addr, af_ignore_error)
1614      && (  addr->special_action == SPECIAL_FREEZE
1615         || (sender_address[0] == 0 && !addr->prop.errors_address)
1616      )  )
1617     {
1618     frozen_info = addr->special_action == SPECIAL_FREEZE
1619       ? US""
1620       : sender_local && !local_error_message
1621       ? US" (message created with -f <>)"
1622       : US" (delivery error message)";
1623     deliver_freeze = TRUE;
1624     deliver_frozen_at = time(NULL);
1625     update_spool = TRUE;
1626
1627     /* The address is put on the defer rather than the failed queue, because
1628     the message is being retained. */
1629
1630     addr->next = addr_defer;
1631     addr_defer = addr;
1632     }
1633
1634   /* Don't put the address on the nonrecipients tree yet; wait until an
1635   error message has been successfully sent. */
1636
1637   else
1638     {
1639     addr->next = addr_failed;
1640     addr_failed = addr;
1641     }
1642
1643   failure_log(addr, driver_name ? NULL : driver_kind, now);
1644   }
1645
1646 /* Ensure logging is turned on again in all cases */
1647
1648 disable_logging = FALSE;
1649 }
1650
1651
1652
1653
1654 /*************************************************
1655 *            Address-independent error           *
1656 *************************************************/
1657
1658 /* This function is called when there's an error that is not dependent on a
1659 particular address, such as an expansion string failure. It puts the error into
1660 all the addresses in a batch, logs the incident on the main and panic logs, and
1661 clears the expansions. It is mostly called from local_deliver(), but can be
1662 called for a remote delivery via findugid().
1663
1664 Arguments:
1665   logit        TRUE if (MAIN+PANIC) logging required
1666   addr         the first of the chain of addresses
1667   code         the error code
1668   format       format string for error message, or NULL if already set in addr
1669   ...          arguments for the format
1670
1671 Returns:       nothing
1672 */
1673
1674 static void
1675 common_error(BOOL logit, address_item *addr, int code, uschar *format, ...)
1676 {
1677 address_item *addr2;
1678 addr->basic_errno = code;
1679
1680 if (format)
1681   {
1682   va_list ap;
1683   uschar buffer[512];
1684   va_start(ap, format);
1685   if (!string_vformat(buffer, sizeof(buffer), CS format, ap))
1686     log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1687       "common_error expansion was longer than " SIZE_T_FMT, sizeof(buffer));
1688   va_end(ap);
1689   addr->message = string_copy(buffer);
1690   }
1691
1692 for (addr2 = addr->next; addr2; addr2 = addr2->next)
1693   {
1694   addr2->basic_errno = code;
1695   addr2->message = addr->message;
1696   }
1697
1698 if (logit) log_write(0, LOG_MAIN|LOG_PANIC, "%s", addr->message);
1699 deliver_set_expansions(NULL);
1700 }
1701
1702
1703
1704
1705 /*************************************************
1706 *         Check a "never users" list             *
1707 *************************************************/
1708
1709 /* This function is called to check whether a uid is on one of the two "never
1710 users" lists.
1711
1712 Arguments:
1713   uid         the uid to be checked
1714   nusers      the list to be scanned; the first item in the list is the count
1715
1716 Returns:      TRUE if the uid is on the list
1717 */
1718
1719 static BOOL
1720 check_never_users(uid_t uid, uid_t *nusers)
1721 {
1722 int i;
1723 if (!nusers) return FALSE;
1724 for (i = 1; i <= (int)(nusers[0]); i++) if (nusers[i] == uid) return TRUE;
1725 return FALSE;
1726 }
1727
1728
1729
1730 /*************************************************
1731 *          Find uid and gid for a transport      *
1732 *************************************************/
1733
1734 /* This function is called for both local and remote deliveries, to find the
1735 uid/gid under which to run the delivery. The values are taken preferentially
1736 from the transport (either explicit or deliver_as_creator), then from the
1737 address (i.e. the router), and if nothing is set, the exim uid/gid are used. If
1738 the resulting uid is on the "never_users" or the "fixed_never_users" list, a
1739 panic error is logged, and the function fails (which normally leads to delivery
1740 deferral).
1741
1742 Arguments:
1743   addr         the address (possibly a chain)
1744   tp           the transport
1745   uidp         pointer to uid field
1746   gidp         pointer to gid field
1747   igfp         pointer to the use_initgroups field
1748
1749 Returns:       FALSE if failed - error has been set in address(es)
1750 */
1751
1752 static BOOL
1753 findugid(address_item *addr, transport_instance *tp, uid_t *uidp, gid_t *gidp,
1754   BOOL *igfp)
1755 {
1756 uschar *nuname;
1757 BOOL gid_set = FALSE;
1758
1759 /* Default initgroups flag comes from the transport */
1760
1761 *igfp = tp->initgroups;
1762
1763 /* First see if there's a gid on the transport, either fixed or expandable.
1764 The expanding function always logs failure itself. */
1765
1766 if (tp->gid_set)
1767   {
1768   *gidp = tp->gid;
1769   gid_set = TRUE;
1770   }
1771 else if (tp->expand_gid)
1772   {
1773   if (!route_find_expanded_group(tp->expand_gid, tp->name, US"transport", gidp,
1774     &(addr->message)))
1775     {
1776     common_error(FALSE, addr, ERRNO_GIDFAIL, NULL);
1777     return FALSE;
1778     }
1779   gid_set = TRUE;
1780   }
1781
1782 /* If the transport did not set a group, see if the router did. */
1783
1784 if (!gid_set && testflag(addr, af_gid_set))
1785   {
1786   *gidp = addr->gid;
1787   gid_set = TRUE;
1788   }
1789
1790 /* Pick up a uid from the transport if one is set. */
1791
1792 if (tp->uid_set) *uidp = tp->uid;
1793
1794 /* Otherwise, try for an expandable uid field. If it ends up as a numeric id,
1795 it does not provide a passwd value from which a gid can be taken. */
1796
1797 else if (tp->expand_uid)
1798   {
1799   struct passwd *pw;
1800   if (!route_find_expanded_user(tp->expand_uid, tp->name, US"transport", &pw,
1801        uidp, &(addr->message)))
1802     {
1803     common_error(FALSE, addr, ERRNO_UIDFAIL, NULL);
1804     return FALSE;
1805     }
1806   if (!gid_set && pw)
1807     {
1808     *gidp = pw->pw_gid;
1809     gid_set = TRUE;
1810     }
1811   }
1812
1813 /* If the transport doesn't set the uid, test the deliver_as_creator flag. */
1814
1815 else if (tp->deliver_as_creator)
1816   {
1817   *uidp = originator_uid;
1818   if (!gid_set)
1819     {
1820     *gidp = originator_gid;
1821     gid_set = TRUE;
1822     }
1823   }
1824
1825 /* Otherwise see if the address specifies the uid and if so, take it and its
1826 initgroups flag. */
1827
1828 else if (testflag(addr, af_uid_set))
1829   {
1830   *uidp = addr->uid;
1831   *igfp = testflag(addr, af_initgroups);
1832   }
1833
1834 /* Nothing has specified the uid - default to the Exim user, and group if the
1835 gid is not set. */
1836
1837 else
1838   {
1839   *uidp = exim_uid;
1840   if (!gid_set)
1841     {
1842     *gidp = exim_gid;
1843     gid_set = TRUE;
1844     }
1845   }
1846
1847 /* If no gid is set, it is a disaster. We default to the Exim gid only if
1848 defaulting to the Exim uid. In other words, if the configuration has specified
1849 a uid, it must also provide a gid. */
1850
1851 if (!gid_set)
1852   {
1853   common_error(TRUE, addr, ERRNO_GIDFAIL, US"User set without group for "
1854     "%s transport", tp->name);
1855   return FALSE;
1856   }
1857
1858 /* Check that the uid is not on the lists of banned uids that may not be used
1859 for delivery processes. */
1860
1861 nuname = check_never_users(*uidp, never_users)
1862   ? US"never_users"
1863   : check_never_users(*uidp, fixed_never_users)
1864   ? US"fixed_never_users"
1865   : NULL;
1866 if (nuname)
1867   {
1868   common_error(TRUE, addr, ERRNO_UIDFAIL, US"User %ld set for %s transport "
1869     "is on the %s list", (long int)(*uidp), tp->name, nuname);
1870   return FALSE;
1871   }
1872
1873 /* All is well */
1874
1875 return TRUE;
1876 }
1877
1878
1879
1880
1881 /*************************************************
1882 *   Check the size of a message for a transport  *
1883 *************************************************/
1884
1885 /* Checks that the message isn't too big for the selected transport.
1886 This is called only when it is known that the limit is set.
1887
1888 Arguments:
1889   tp          the transport
1890   addr        the (first) address being delivered
1891
1892 Returns:      OK
1893               DEFER   expansion failed or did not yield an integer
1894               FAIL    message too big
1895 */
1896
1897 int
1898 check_message_size(transport_instance *tp, address_item *addr)
1899 {
1900 int rc = OK;
1901 int size_limit;
1902
1903 deliver_set_expansions(addr);
1904 size_limit = expand_string_integer(tp->message_size_limit, TRUE);
1905 deliver_set_expansions(NULL);
1906
1907 if (expand_string_message)
1908   {
1909   rc = DEFER;
1910   addr->message = size_limit == -1
1911     ? string_sprintf("failed to expand message_size_limit "
1912       "in %s transport: %s", tp->name, expand_string_message)
1913     : string_sprintf("invalid message_size_limit "
1914       "in %s transport: %s", tp->name, expand_string_message);
1915   }
1916 else if (size_limit > 0 && message_size > size_limit)
1917   {
1918   rc = FAIL;
1919   addr->message =
1920     string_sprintf("message is too big (transport limit = %d)",
1921       size_limit);
1922   }
1923
1924 return rc;
1925 }
1926
1927
1928
1929 /*************************************************
1930 *  Transport-time check for a previous delivery  *
1931 *************************************************/
1932
1933 /* Check that this base address hasn't previously been delivered to its routed
1934 transport. If it has been delivered, mark it done. The check is necessary at
1935 delivery time in order to handle homonymic addresses correctly in cases where
1936 the pattern of redirection changes between delivery attempts (so the unique
1937 fields change). Non-homonymic previous delivery is detected earlier, at routing
1938 time (which saves unnecessary routing).
1939
1940 Arguments:
1941   addr      the address item
1942   testing   TRUE if testing wanted only, without side effects
1943
1944 Returns:    TRUE if previously delivered by the transport
1945 */
1946
1947 static BOOL
1948 previously_transported(address_item *addr, BOOL testing)
1949 {
1950 (void)string_format(big_buffer, big_buffer_size, "%s/%s",
1951   addr->unique + (testflag(addr, af_homonym)? 3:0), addr->transport->name);
1952
1953 if (tree_search(tree_nonrecipients, big_buffer) != 0)
1954   {
1955   DEBUG(D_deliver|D_route|D_transport)
1956     debug_printf("%s was previously delivered (%s transport): discarded\n",
1957     addr->address, addr->transport->name);
1958   if (!testing) child_done(addr, tod_stamp(tod_log));
1959   return TRUE;
1960   }
1961
1962 return FALSE;
1963 }
1964
1965
1966
1967 /******************************************************
1968 *      Check for a given header in a header string    *
1969 ******************************************************/
1970
1971 /* This function is used when generating quota warnings. The configuration may
1972 specify any header lines it likes in quota_warn_message. If certain of them are
1973 missing, defaults are inserted, so we need to be able to test for the presence
1974 of a given header.
1975
1976 Arguments:
1977   hdr         the required header name
1978   hstring     the header string
1979
1980 Returns:      TRUE  the header is in the string
1981               FALSE the header is not in the string
1982 */
1983
1984 static BOOL
1985 contains_header(uschar *hdr, uschar *hstring)
1986 {
1987 int len = Ustrlen(hdr);
1988 uschar *p = hstring;
1989 while (*p != 0)
1990   {
1991   if (strncmpic(p, hdr, len) == 0)
1992     {
1993     p += len;
1994     while (*p == ' ' || *p == '\t') p++;
1995     if (*p == ':') return TRUE;
1996     }
1997   while (*p != 0 && *p != '\n') p++;
1998   if (*p == '\n') p++;
1999   }
2000 return FALSE;
2001 }
2002
2003
2004
2005
2006 /*************************************************
2007 *           Perform a local delivery             *
2008 *************************************************/
2009
2010 /* Each local delivery is performed in a separate process which sets its
2011 uid and gid as specified. This is a safer way than simply changing and
2012 restoring using seteuid(); there is a body of opinion that seteuid() cannot be
2013 used safely. From release 4, Exim no longer makes any use of it. Besides, not
2014 all systems have seteuid().
2015
2016 If the uid/gid are specified in the transport_instance, they are used; the
2017 transport initialization must ensure that either both or neither are set.
2018 Otherwise, the values associated with the address are used. If neither are set,
2019 it is a configuration error.
2020
2021 The transport or the address may specify a home directory (transport over-
2022 rides), and if they do, this is set as $home. If neither have set a working
2023 directory, this value is used for that as well. Otherwise $home is left unset
2024 and the cwd is set to "/" - a directory that should be accessible to all users.
2025
2026 Using a separate process makes it more complicated to get error information
2027 back. We use a pipe to pass the return code and also an error code and error
2028 text string back to the parent process.
2029
2030 Arguments:
2031   addr       points to an address block for this delivery; for "normal" local
2032              deliveries this is the only address to be delivered, but for
2033              pseudo-remote deliveries (e.g. by batch SMTP to a file or pipe)
2034              a number of addresses can be handled simultaneously, and in this
2035              case addr will point to a chain of addresses with the same
2036              characteristics.
2037
2038   shadowing  TRUE if running a shadow transport; this causes output from pipes
2039              to be ignored.
2040
2041 Returns:     nothing
2042 */
2043
2044 static void
2045 deliver_local(address_item *addr, BOOL shadowing)
2046 {
2047 BOOL use_initgroups;
2048 uid_t uid;
2049 gid_t gid;
2050 int status, len, rc;
2051 int pfd[2];
2052 pid_t pid;
2053 uschar *working_directory;
2054 address_item *addr2;
2055 transport_instance *tp = addr->transport;
2056
2057 /* Set up the return path from the errors or sender address. If the transport
2058 has its own return path setting, expand it and replace the existing value. */
2059
2060 if(addr->prop.errors_address)
2061   return_path = addr->prop.errors_address;
2062 #ifdef EXPERIMENTAL_SRS
2063 else if (addr->prop.srs_sender)
2064   return_path = addr->prop.srs_sender;
2065 #endif
2066 else
2067   return_path = sender_address;
2068
2069 if (tp->return_path)
2070   {
2071   uschar *new_return_path = expand_string(tp->return_path);
2072   if (!new_return_path)
2073     {
2074     if (!expand_string_forcedfail)
2075       {
2076       common_error(TRUE, addr, ERRNO_EXPANDFAIL,
2077         US"Failed to expand return path \"%s\" in %s transport: %s",
2078         tp->return_path, tp->name, expand_string_message);
2079       return;
2080       }
2081     }
2082   else return_path = new_return_path;
2083   }
2084
2085 /* For local deliveries, one at a time, the value used for logging can just be
2086 set directly, once and for all. */
2087
2088 used_return_path = return_path;
2089
2090 /* Sort out the uid, gid, and initgroups flag. If an error occurs, the message
2091 gets put into the address(es), and the expansions are unset, so we can just
2092 return. */
2093
2094 if (!findugid(addr, tp, &uid, &gid, &use_initgroups)) return;
2095
2096 /* See if either the transport or the address specifies a home directory. A
2097 home directory set in the address may already be expanded; a flag is set to
2098 indicate that. In other cases we must expand it. */
2099
2100 if (  (deliver_home = tp->home_dir)             /* Set in transport, or */
2101    || (  (deliver_home = addr->home_dir)        /* Set in address and */
2102       && !testflag(addr, af_home_expanded)      /*   not expanded */
2103    )  )
2104   {
2105   uschar *rawhome = deliver_home;
2106   deliver_home = NULL;                      /* in case it contains $home */
2107   if (!(deliver_home = expand_string(rawhome)))
2108     {
2109     common_error(TRUE, addr, ERRNO_EXPANDFAIL, US"home directory \"%s\" failed "
2110       "to expand for %s transport: %s", rawhome, tp->name,
2111       expand_string_message);
2112     return;
2113     }
2114   if (*deliver_home != '/')
2115     {
2116     common_error(TRUE, addr, ERRNO_NOTABSOLUTE, US"home directory path \"%s\" "
2117       "is not absolute for %s transport", deliver_home, tp->name);
2118     return;
2119     }
2120   }
2121
2122 /* See if either the transport or the address specifies a current directory,
2123 and if so, expand it. If nothing is set, use the home directory, unless it is
2124 also unset in which case use "/", which is assumed to be a directory to which
2125 all users have access. It is necessary to be in a visible directory for some
2126 operating systems when running pipes, as some commands (e.g. "rm" under Solaris
2127 2.5) require this. */
2128
2129 working_directory = tp->current_dir ? tp->current_dir : addr->current_dir;
2130 if (working_directory)
2131   {
2132   uschar *raw = working_directory;
2133   if (!(working_directory = expand_string(raw)))
2134     {
2135     common_error(TRUE, addr, ERRNO_EXPANDFAIL, US"current directory \"%s\" "
2136       "failed to expand for %s transport: %s", raw, tp->name,
2137       expand_string_message);
2138     return;
2139     }
2140   if (*working_directory != '/')
2141     {
2142     common_error(TRUE, addr, ERRNO_NOTABSOLUTE, US"current directory path "
2143       "\"%s\" is not absolute for %s transport", working_directory, tp->name);
2144     return;
2145     }
2146   }
2147 else working_directory = deliver_home ? deliver_home : US"/";
2148
2149 /* If one of the return_output flags is set on the transport, create and open a
2150 file in the message log directory for the transport to write its output onto.
2151 This is mainly used by pipe transports. The file needs to be unique to the
2152 address. This feature is not available for shadow transports. */
2153
2154 if (  !shadowing
2155    && (  tp->return_output || tp->return_fail_output
2156       || tp->log_output || tp->log_fail_output || tp->log_defer_output
2157    )  )
2158   {
2159   uschar * error;
2160
2161   addr->return_filename =
2162     spool_fname(US"msglog", message_subdir, message_id,
2163       string_sprintf("-%d-%d", getpid(), return_count++));
2164
2165   if ((addr->return_file = open_msglog_file(addr->return_filename, 0400, &error)) < 0)
2166     {
2167     common_error(TRUE, addr, errno, US"Unable to %s file for %s transport "
2168       "to return message: %s", error, tp->name, strerror(errno));
2169     return;
2170     }
2171   }
2172
2173 /* Create the pipe for inter-process communication. */
2174
2175 if (pipe(pfd) != 0)
2176   {
2177   common_error(TRUE, addr, ERRNO_PIPEFAIL, US"Creation of pipe failed: %s",
2178     strerror(errno));
2179   return;
2180   }
2181
2182 /* Now fork the process to do the real work in the subprocess, but first
2183 ensure that all cached resources are freed so that the subprocess starts with
2184 a clean slate and doesn't interfere with the parent process. */
2185
2186 search_tidyup();
2187
2188 if ((pid = fork()) == 0)
2189   {
2190   BOOL replicate = TRUE;
2191
2192   /* Prevent core dumps, as we don't want them in users' home directories.
2193   HP-UX doesn't have RLIMIT_CORE; I don't know how to do this in that
2194   system. Some experimental/developing systems (e.g. GNU/Hurd) may define
2195   RLIMIT_CORE but not support it in setrlimit(). For such systems, do not
2196   complain if the error is "not supported".
2197
2198   There are two scenarios where changing the max limit has an effect.  In one,
2199   the user is using a .forward and invoking a command of their choice via pipe;
2200   for these, we do need the max limit to be 0 unless the admin chooses to
2201   permit an increased limit.  In the other, the command is invoked directly by
2202   the transport and is under administrator control, thus being able to raise
2203   the limit aids in debugging.  So there's no general always-right answer.
2204
2205   Thus we inhibit core-dumps completely but let individual transports, while
2206   still root, re-raise the limits back up to aid debugging.  We make the
2207   default be no core-dumps -- few enough people can use core dumps in
2208   diagnosis that it's reasonable to make them something that has to be explicitly requested.
2209   */
2210
2211 #ifdef RLIMIT_CORE
2212   struct rlimit rl;
2213   rl.rlim_cur = 0;
2214   rl.rlim_max = 0;
2215   if (setrlimit(RLIMIT_CORE, &rl) < 0)
2216     {
2217 # ifdef SETRLIMIT_NOT_SUPPORTED
2218     if (errno != ENOSYS && errno != ENOTSUP)
2219 # endif
2220       log_write(0, LOG_MAIN|LOG_PANIC, "setrlimit(RLIMIT_CORE) failed: %s",
2221         strerror(errno));
2222     }
2223 #endif
2224
2225   /* Reset the random number generator, so different processes don't all
2226   have the same sequence. */
2227
2228   random_seed = 0;
2229
2230   /* If the transport has a setup entry, call this first, while still
2231   privileged. (Appendfile uses this to expand quota, for example, while
2232   able to read private files.) */
2233
2234   if (addr->transport->setup)
2235     switch((addr->transport->setup)(addr->transport, addr, NULL, uid, gid,
2236            &(addr->message)))
2237       {
2238       case DEFER:
2239         addr->transport_return = DEFER;
2240         goto PASS_BACK;
2241
2242       case FAIL:
2243         addr->transport_return = PANIC;
2244         goto PASS_BACK;
2245       }
2246
2247   /* Ignore SIGINT and SIGTERM during delivery. Also ignore SIGUSR1, as
2248   when the process becomes unprivileged, it won't be able to write to the
2249   process log. SIGHUP is ignored throughout exim, except when it is being
2250   run as a daemon. */
2251
2252   signal(SIGINT, SIG_IGN);
2253   signal(SIGTERM, SIG_IGN);
2254   signal(SIGUSR1, SIG_IGN);
2255
2256   /* Close the unwanted half of the pipe, and set close-on-exec for the other
2257   half - for transports that exec things (e.g. pipe). Then set the required
2258   gid/uid. */
2259
2260   (void)close(pfd[pipe_read]);
2261   (void)fcntl(pfd[pipe_write], F_SETFD, fcntl(pfd[pipe_write], F_GETFD) |
2262     FD_CLOEXEC);
2263   exim_setugid(uid, gid, use_initgroups,
2264     string_sprintf("local delivery to %s <%s> transport=%s", addr->local_part,
2265       addr->address, addr->transport->name));
2266
2267   DEBUG(D_deliver)
2268     {
2269     address_item *batched;
2270     debug_printf("  home=%s current=%s\n", deliver_home, working_directory);
2271     for (batched = addr->next; batched; batched = batched->next)
2272       debug_printf("additional batched address: %s\n", batched->address);
2273     }
2274
2275   /* Set an appropriate working directory. */
2276
2277   if (Uchdir(working_directory) < 0)
2278     {
2279     addr->transport_return = DEFER;
2280     addr->basic_errno = errno;
2281     addr->message = string_sprintf("failed to chdir to %s", working_directory);
2282     }
2283
2284   /* If successful, call the transport */
2285
2286   else
2287     {
2288     BOOL ok = TRUE;
2289     set_process_info("delivering %s to %s using %s", message_id,
2290      addr->local_part, addr->transport->name);
2291
2292     /* Setting this global in the subprocess means we need never clear it */
2293     transport_name = addr->transport->name;
2294
2295     /* If a transport filter has been specified, set up its argument list.
2296     Any errors will get put into the address, and FALSE yielded. */
2297
2298     if (addr->transport->filter_command)
2299       {
2300       ok = transport_set_up_command(&transport_filter_argv,
2301         addr->transport->filter_command,
2302         TRUE, PANIC, addr, US"transport filter", NULL);
2303       transport_filter_timeout = addr->transport->filter_timeout;
2304       }
2305     else transport_filter_argv = NULL;
2306
2307     if (ok)
2308       {
2309       debug_print_string(addr->transport->debug_string);
2310       replicate = !(addr->transport->info->code)(addr->transport, addr);
2311       }
2312     }
2313
2314   /* Pass the results back down the pipe. If necessary, first replicate the
2315   status in the top address to the others in the batch. The label is the
2316   subject of a goto when a call to the transport's setup function fails. We
2317   pass the pointer to the transport back in case it got changed as a result of
2318   file_format in appendfile. */
2319
2320   PASS_BACK:
2321
2322   if (replicate) replicate_status(addr);
2323   for (addr2 = addr; addr2; addr2 = addr2->next)
2324     {
2325     int i;
2326     int local_part_length = Ustrlen(addr2->local_part);
2327     uschar *s;
2328     int ret;
2329
2330     if(  (ret = write(pfd[pipe_write], &addr2->transport_return, sizeof(int))) != sizeof(int)
2331       || (ret = write(pfd[pipe_write], &transport_count, sizeof(transport_count))) != sizeof(transport_count)
2332       || (ret = write(pfd[pipe_write], &addr2->flags, sizeof(addr2->flags))) != sizeof(addr2->flags)
2333       || (ret = write(pfd[pipe_write], &addr2->basic_errno,    sizeof(int))) != sizeof(int)
2334       || (ret = write(pfd[pipe_write], &addr2->more_errno,     sizeof(int))) != sizeof(int)
2335       || (ret = write(pfd[pipe_write], &addr2->special_action, sizeof(int))) != sizeof(int)
2336       || (ret = write(pfd[pipe_write], &addr2->transport,
2337         sizeof(transport_instance *))) != sizeof(transport_instance *)
2338
2339     /* For a file delivery, pass back the local part, in case the original
2340     was only part of the final delivery path. This gives more complete
2341     logging. */
2342
2343       || (testflag(addr2, af_file)
2344           && (  (ret = write(pfd[pipe_write], &local_part_length, sizeof(int))) != sizeof(int)
2345              || (ret = write(pfd[pipe_write], addr2->local_part, local_part_length)) != local_part_length
2346              )
2347          )
2348       )
2349       log_write(0, LOG_MAIN|LOG_PANIC, "Failed writing transport results to pipe: %s\n",
2350         ret == -1 ? strerror(errno) : "short write");
2351
2352     /* Now any messages */
2353
2354     for (i = 0, s = addr2->message; i < 2; i++, s = addr2->user_message)
2355       {
2356       int message_length = s ? Ustrlen(s) + 1 : 0;
2357       if(  (ret = write(pfd[pipe_write], &message_length, sizeof(int))) != sizeof(int)
2358         || message_length > 0  && (ret = write(pfd[pipe_write], s, message_length)) != message_length
2359         )
2360         log_write(0, LOG_MAIN|LOG_PANIC, "Failed writing transport results to pipe: %s\n",
2361           ret == -1 ? strerror(errno) : "short write");
2362       }
2363     }
2364
2365   /* OK, this process is now done. Free any cached resources that it opened,
2366   and close the pipe we were writing down before exiting. */
2367
2368   (void)close(pfd[pipe_write]);
2369   search_tidyup();
2370   exit(EXIT_SUCCESS);
2371   }
2372
2373 /* Back in the main process: panic if the fork did not succeed. This seems
2374 better than returning an error - if forking is failing it is probably best
2375 not to try other deliveries for this message. */
2376
2377 if (pid < 0)
2378   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Fork failed for local delivery to %s",
2379     addr->address);
2380
2381 /* Read the pipe to get the delivery status codes and error messages. Our copy
2382 of the writing end must be closed first, as otherwise read() won't return zero
2383 on an empty pipe. We check that a status exists for each address before
2384 overwriting the address structure. If data is missing, the default DEFER status
2385 will remain. Afterwards, close the reading end. */
2386
2387 (void)close(pfd[pipe_write]);
2388
2389 for (addr2 = addr; addr2; addr2 = addr2->next)
2390   {
2391   len = read(pfd[pipe_read], &status, sizeof(int));
2392   if (len > 0)
2393     {
2394     int i;
2395     uschar **sptr;
2396
2397     addr2->transport_return = status;
2398     len = read(pfd[pipe_read], &transport_count,
2399       sizeof(transport_count));
2400     len = read(pfd[pipe_read], &addr2->flags, sizeof(addr2->flags));
2401     len = read(pfd[pipe_read], &addr2->basic_errno,    sizeof(int));
2402     len = read(pfd[pipe_read], &addr2->more_errno,     sizeof(int));
2403     len = read(pfd[pipe_read], &addr2->special_action, sizeof(int));
2404     len = read(pfd[pipe_read], &addr2->transport,
2405       sizeof(transport_instance *));
2406
2407     if (testflag(addr2, af_file))
2408       {
2409       int local_part_length;
2410       len = read(pfd[pipe_read], &local_part_length, sizeof(int));
2411       len = read(pfd[pipe_read], big_buffer, local_part_length);
2412       big_buffer[local_part_length] = 0;
2413       addr2->local_part = string_copy(big_buffer);
2414       }
2415
2416     for (i = 0, sptr = &addr2->message; i < 2; i++, sptr = &addr2->user_message)
2417       {
2418       int message_length;
2419       len = read(pfd[pipe_read], &message_length, sizeof(int));
2420       if (message_length > 0)
2421         {
2422         len = read(pfd[pipe_read], big_buffer, message_length);
2423         big_buffer[big_buffer_size-1] = '\0';           /* guard byte */
2424         if (len > 0) *sptr = string_copy(big_buffer);
2425         }
2426       }
2427     }
2428
2429   else
2430     {
2431     log_write(0, LOG_MAIN|LOG_PANIC, "failed to read delivery status for %s "
2432       "from delivery subprocess", addr2->unique);
2433     break;
2434     }
2435   }
2436
2437 (void)close(pfd[pipe_read]);
2438
2439 /* Unless shadowing, write all successful addresses immediately to the journal
2440 file, to ensure they are recorded asap. For homonymic addresses, use the base
2441 address plus the transport name. Failure to write the journal is panic-worthy,
2442 but don't stop, as it may prove possible subsequently to update the spool file
2443 in order to record the delivery. */
2444
2445 if (!shadowing)
2446   {
2447   for (addr2 = addr; addr2; addr2 = addr2->next)
2448     if (addr2->transport_return == OK)
2449       {
2450       if (testflag(addr2, af_homonym))
2451         sprintf(CS big_buffer, "%.500s/%s\n", addr2->unique + 3, tp->name);
2452       else
2453         sprintf(CS big_buffer, "%.500s\n", addr2->unique);
2454
2455       /* In the test harness, wait just a bit to let the subprocess finish off
2456       any debug output etc first. */
2457
2458       if (running_in_test_harness) millisleep(300);
2459
2460       DEBUG(D_deliver) debug_printf("journalling %s", big_buffer);
2461       len = Ustrlen(big_buffer);
2462       if (write(journal_fd, big_buffer, len) != len)
2463         log_write(0, LOG_MAIN|LOG_PANIC, "failed to update journal for %s: %s",
2464           big_buffer, strerror(errno));
2465       }
2466
2467   /* Ensure the journal file is pushed out to disk. */
2468
2469   if (EXIMfsync(journal_fd) < 0)
2470     log_write(0, LOG_MAIN|LOG_PANIC, "failed to fsync journal: %s",
2471       strerror(errno));
2472   }
2473
2474 /* Wait for the process to finish. If it terminates with a non-zero code,
2475 freeze the message (except for SIGTERM, SIGKILL and SIGQUIT), but leave the
2476 status values of all the addresses as they are. Take care to handle the case
2477 when the subprocess doesn't seem to exist. This has been seen on one system
2478 when Exim was called from an MUA that set SIGCHLD to SIG_IGN. When that
2479 happens, wait() doesn't recognize the termination of child processes. Exim now
2480 resets SIGCHLD to SIG_DFL, but this code should still be robust. */
2481
2482 while ((rc = wait(&status)) != pid)
2483   if (rc < 0 && errno == ECHILD)      /* Process has vanished */
2484     {
2485     log_write(0, LOG_MAIN, "%s transport process vanished unexpectedly",
2486       addr->transport->driver_name);
2487     status = 0;
2488     break;
2489     }
2490
2491 if ((status & 0xffff) != 0)
2492   {
2493   int msb = (status >> 8) & 255;
2494   int lsb = status & 255;
2495   int code = (msb == 0)? (lsb & 0x7f) : msb;
2496   if (msb != 0 || (code != SIGTERM && code != SIGKILL && code != SIGQUIT))
2497     addr->special_action = SPECIAL_FREEZE;
2498   log_write(0, LOG_MAIN|LOG_PANIC, "%s transport process returned non-zero "
2499     "status 0x%04x: %s %d",
2500     addr->transport->driver_name,
2501     status,
2502     msb == 0 ? "terminated by signal" : "exit code",
2503     code);
2504   }
2505
2506 /* If SPECIAL_WARN is set in the top address, send a warning message. */
2507
2508 if (addr->special_action == SPECIAL_WARN && addr->transport->warn_message)
2509   {
2510   int fd;
2511   uschar *warn_message;
2512   pid_t pid;
2513
2514   DEBUG(D_deliver) debug_printf("Warning message requested by transport\n");
2515
2516   if (!(warn_message = expand_string(addr->transport->warn_message)))
2517     log_write(0, LOG_MAIN|LOG_PANIC, "Failed to expand \"%s\" (warning "
2518       "message for %s transport): %s", addr->transport->warn_message,
2519       addr->transport->name, expand_string_message);
2520
2521   else if ((pid = child_open_exim(&fd)) > 0)
2522     {
2523     FILE *f = fdopen(fd, "wb");
2524     if (errors_reply_to && !contains_header(US"Reply-To", warn_message))
2525       fprintf(f, "Reply-To: %s\n", errors_reply_to);
2526     fprintf(f, "Auto-Submitted: auto-replied\n");
2527     if (!contains_header(US"From", warn_message))
2528       moan_write_from(f);
2529     fprintf(f, "%s", CS warn_message);
2530
2531     /* Close and wait for child process to complete, without a timeout. */
2532
2533     (void)fclose(f);
2534     (void)child_close(pid, 0);
2535     }
2536
2537   addr->special_action = SPECIAL_NONE;
2538   }
2539 }
2540
2541
2542
2543
2544 /* Check transport for the given concurrency limit.  Return TRUE if over
2545 the limit (or an expansion failure), else FALSE and if there was a limit,
2546 the key for the hints database used for the concurrency count. */
2547
2548 static BOOL
2549 tpt_parallel_check(transport_instance * tp, address_item * addr, uschar ** key)
2550 {
2551 unsigned max_parallel;
2552
2553 if (!tp->max_parallel) return FALSE;
2554
2555 max_parallel = (unsigned) expand_string_integer(tp->max_parallel, TRUE);
2556 if (expand_string_message)
2557   {
2558   log_write(0, LOG_MAIN|LOG_PANIC, "Failed to expand max_parallel option "
2559         "in %s transport (%s): %s", tp->name, addr->address,
2560         expand_string_message);
2561   return TRUE;
2562   }
2563
2564 if (max_parallel > 0)
2565   {
2566   uschar * serialize_key = string_sprintf("tpt-serialize-%s", tp->name);
2567   if (!enq_start(serialize_key, max_parallel))
2568     {
2569     address_item * next;
2570     DEBUG(D_transport)
2571       debug_printf("skipping tpt %s because concurrency limit %u reached\n",
2572                   tp->name, max_parallel);
2573     do
2574       {
2575       next = addr->next;
2576       addr->message = US"concurrency limit reached for transport";
2577       addr->basic_errno = ERRNO_TRETRY;
2578       post_process_one(addr, DEFER, LOG_MAIN, DTYPE_TRANSPORT, 0);
2579       } while ((addr = next));
2580     return TRUE;
2581     }
2582   *key = serialize_key;
2583   }
2584 return FALSE;
2585 }
2586
2587
2588
2589 /*************************************************
2590 *              Do local deliveries               *
2591 *************************************************/
2592
2593 /* This function processes the list of addresses in addr_local. True local
2594 deliveries are always done one address at a time. However, local deliveries can
2595 be batched up in some cases. Typically this is when writing batched SMTP output
2596 files for use by some external transport mechanism, or when running local
2597 deliveries over LMTP.
2598
2599 Arguments:   None
2600 Returns:     Nothing
2601 */
2602
2603 static void
2604 do_local_deliveries(void)
2605 {
2606 open_db dbblock;
2607 open_db *dbm_file = NULL;
2608 time_t now = time(NULL);
2609
2610 /* Loop until we have exhausted the supply of local deliveries */
2611
2612 while (addr_local)
2613   {
2614   time_t delivery_start;
2615   int deliver_time;
2616   address_item *addr2, *addr3, *nextaddr;
2617   int logflags = LOG_MAIN;
2618   int logchar = dont_deliver? '*' : '=';
2619   transport_instance *tp;
2620   uschar * serialize_key = NULL;
2621
2622   /* Pick the first undelivered address off the chain */
2623
2624   address_item *addr = addr_local;
2625   addr_local = addr->next;
2626   addr->next = NULL;
2627
2628   DEBUG(D_deliver|D_transport)
2629     debug_printf("--------> %s <--------\n", addr->address);
2630
2631   /* An internal disaster if there is no transport. Should not occur! */
2632
2633   if (!(tp = addr->transport))
2634     {
2635     logflags |= LOG_PANIC;
2636     disable_logging = FALSE;  /* Jic */
2637     addr->message = addr->router
2638       ? string_sprintf("No transport set by %s router", addr->router->name)
2639       : string_sprintf("No transport set by system filter");
2640     post_process_one(addr, DEFER, logflags, DTYPE_TRANSPORT, 0);
2641     continue;
2642     }
2643
2644   /* Check that this base address hasn't previously been delivered to this
2645   transport. The check is necessary at this point to handle homonymic addresses
2646   correctly in cases where the pattern of redirection changes between delivery
2647   attempts. Non-homonymic previous delivery is detected earlier, at routing
2648   time. */
2649
2650   if (previously_transported(addr, FALSE)) continue;
2651
2652   /* There are weird cases where logging is disabled */
2653
2654   disable_logging = tp->disable_logging;
2655
2656   /* Check for batched addresses and possible amalgamation. Skip all the work
2657   if either batch_max <= 1 or there aren't any other addresses for local
2658   delivery. */
2659
2660   if (tp->batch_max > 1 && addr_local)
2661     {
2662     int batch_count = 1;
2663     BOOL uses_dom = readconf_depends((driver_instance *)tp, US"domain");
2664     BOOL uses_lp = (  testflag(addr, af_pfr)
2665                    && (testflag(addr, af_file) || addr->local_part[0] == '|')
2666                    )
2667                 || readconf_depends((driver_instance *)tp, US"local_part");
2668     uschar *batch_id = NULL;
2669     address_item **anchor = &addr_local;
2670     address_item *last = addr;
2671     address_item *next;
2672
2673     /* Expand the batch_id string for comparison with other addresses.
2674     Expansion failure suppresses batching. */
2675
2676     if (tp->batch_id)
2677       {
2678       deliver_set_expansions(addr);
2679       batch_id = expand_string(tp->batch_id);
2680       deliver_set_expansions(NULL);
2681       if (!batch_id)
2682         {
2683         log_write(0, LOG_MAIN|LOG_PANIC, "Failed to expand batch_id option "
2684           "in %s transport (%s): %s", tp->name, addr->address,
2685           expand_string_message);
2686         batch_count = tp->batch_max;
2687         }
2688       }
2689
2690     /* Until we reach the batch_max limit, pick off addresses which have the
2691     same characteristics. These are:
2692
2693       same transport
2694       not previously delivered (see comment about 50 lines above)
2695       same local part if the transport's configuration contains $local_part
2696         or if this is a file or pipe delivery from a redirection
2697       same domain if the transport's configuration contains $domain
2698       same errors address
2699       same additional headers
2700       same headers to be removed
2701       same uid/gid for running the transport
2702       same first host if a host list is set
2703     */
2704
2705     while ((next = *anchor) && batch_count < tp->batch_max)
2706       {
2707       BOOL ok =
2708            tp == next->transport
2709         && !previously_transported(next, TRUE)
2710         && (addr->flags & (af_pfr|af_file)) == (next->flags & (af_pfr|af_file))
2711         && (!uses_lp  || Ustrcmp(next->local_part, addr->local_part) == 0)
2712         && (!uses_dom || Ustrcmp(next->domain, addr->domain) == 0)
2713         && same_strings(next->prop.errors_address, addr->prop.errors_address)
2714         && same_headers(next->prop.extra_headers, addr->prop.extra_headers)
2715         && same_strings(next->prop.remove_headers, addr->prop.remove_headers)
2716         && same_ugid(tp, addr, next)
2717         && (  !addr->host_list && !next->host_list
2718            ||    addr->host_list
2719               && next->host_list
2720               && Ustrcmp(addr->host_list->name, next->host_list->name) == 0
2721            );
2722
2723       /* If the transport has a batch_id setting, batch_id will be non-NULL
2724       from the expansion outside the loop. Expand for this address and compare.
2725       Expansion failure makes this address ineligible for batching. */
2726
2727       if (ok && batch_id)
2728         {
2729         uschar *bid;
2730         address_item *save_nextnext = next->next;
2731         next->next = NULL;            /* Expansion for a single address */
2732         deliver_set_expansions(next);
2733         next->next = save_nextnext;
2734         bid = expand_string(tp->batch_id);
2735         deliver_set_expansions(NULL);
2736         if (!bid)
2737           {
2738           log_write(0, LOG_MAIN|LOG_PANIC, "Failed to expand batch_id option "
2739             "in %s transport (%s): %s", tp->name, next->address,
2740             expand_string_message);
2741           ok = FALSE;
2742           }
2743         else ok = (Ustrcmp(batch_id, bid) == 0);
2744         }
2745
2746       /* Take address into batch if OK. */
2747
2748       if (ok)
2749         {
2750         *anchor = next->next;           /* Include the address */
2751         next->next = NULL;
2752         last->next = next;
2753         last = next;
2754         batch_count++;
2755         }
2756       else anchor = &next->next;        /* Skip the address */
2757       }
2758     }
2759
2760   /* We now have one or more addresses that can be delivered in a batch. Check
2761   whether the transport is prepared to accept a message of this size. If not,
2762   fail them all forthwith. If the expansion fails, or does not yield an
2763   integer, defer delivery. */
2764
2765   if (tp->message_size_limit)
2766     {
2767     int rc = check_message_size(tp, addr);
2768     if (rc != OK)
2769       {
2770       replicate_status(addr);
2771       while (addr)
2772         {
2773         addr2 = addr->next;
2774         post_process_one(addr, rc, logflags, DTYPE_TRANSPORT, 0);
2775         addr = addr2;
2776         }
2777       continue;    /* With next batch of addresses */
2778       }
2779     }
2780
2781   /* If we are not running the queue, or if forcing, all deliveries will be
2782   attempted. Otherwise, we must respect the retry times for each address. Even
2783   when not doing this, we need to set up the retry key string, and determine
2784   whether a retry record exists, because after a successful delivery, a delete
2785   retry item must be set up. Keep the retry database open only for the duration
2786   of these checks, rather than for all local deliveries, because some local
2787   deliveries (e.g. to pipes) can take a substantial time. */
2788
2789   if (!(dbm_file = dbfn_open(US"retry", O_RDONLY, &dbblock, FALSE)))
2790     {
2791     DEBUG(D_deliver|D_retry|D_hints_lookup)
2792       debug_printf("no retry data available\n");
2793     }
2794
2795   addr2 = addr;
2796   addr3 = NULL;
2797   while (addr2)
2798     {
2799     BOOL ok = TRUE;   /* to deliver this address */
2800     uschar *retry_key;
2801
2802     /* Set up the retry key to include the domain or not, and change its
2803     leading character from "R" to "T". Must make a copy before doing this,
2804     because the old key may be pointed to from a "delete" retry item after
2805     a routing delay. */
2806
2807     retry_key = string_copy(
2808       tp->retry_use_local_part ? addr2->address_retry_key :
2809         addr2->domain_retry_key);
2810     *retry_key = 'T';
2811
2812     /* Inspect the retry data. If there is no hints file, delivery happens. */
2813
2814     if (dbm_file)
2815       {
2816       dbdata_retry *retry_record = dbfn_read(dbm_file, retry_key);
2817
2818       /* If there is no retry record, delivery happens. If there is,
2819       remember it exists so it can be deleted after a successful delivery. */
2820
2821       if (retry_record)
2822         {
2823         setflag(addr2, af_lt_retry_exists);
2824
2825         /* A retry record exists for this address. If queue running and not
2826         forcing, inspect its contents. If the record is too old, or if its
2827         retry time has come, or if it has passed its cutoff time, delivery
2828         will go ahead. */
2829
2830         DEBUG(D_retry)
2831           {
2832           debug_printf("retry record exists: age=%s ",
2833             readconf_printtime(now - retry_record->time_stamp));
2834           debug_printf("(max %s)\n", readconf_printtime(retry_data_expire));
2835           debug_printf("  time to retry = %s expired = %d\n",
2836             readconf_printtime(retry_record->next_try - now),
2837             retry_record->expired);
2838           }
2839
2840         if (queue_running && !deliver_force)
2841           {
2842           ok = (now - retry_record->time_stamp > retry_data_expire)
2843             || (now >= retry_record->next_try)
2844             || retry_record->expired;
2845
2846           /* If we haven't reached the retry time, there is one more check
2847           to do, which is for the ultimate address timeout. */
2848
2849           if (!ok)
2850             ok = retry_ultimate_address_timeout(retry_key, addr2->domain,
2851                 retry_record, now);
2852           }
2853         }
2854       else DEBUG(D_retry) debug_printf("no retry record exists\n");
2855       }
2856
2857     /* This address is to be delivered. Leave it on the chain. */
2858
2859     if (ok)
2860       {
2861       addr3 = addr2;
2862       addr2 = addr2->next;
2863       }
2864
2865     /* This address is to be deferred. Take it out of the chain, and
2866     post-process it as complete. Must take it out of the chain first,
2867     because post processing puts it on another chain. */
2868
2869     else
2870       {
2871       address_item *this = addr2;
2872       this->message = US"Retry time not yet reached";
2873       this->basic_errno = ERRNO_LRETRY;
2874       addr2 = addr3 ? (addr3->next = addr2->next)
2875                     : (addr = addr2->next);
2876       post_process_one(this, DEFER, logflags, DTYPE_TRANSPORT, 0);
2877       }
2878     }
2879
2880   if (dbm_file) dbfn_close(dbm_file);
2881
2882   /* If there are no addresses left on the chain, they all deferred. Loop
2883   for the next set of addresses. */
2884
2885   if (!addr) continue;
2886
2887   /* If the transport is limited for parallellism, enforce that here.
2888   We use a hints DB entry, incremented here and decremented after
2889   the transport (and any shadow transport) completes. */
2890
2891   if (tpt_parallel_check(tp, addr, &serialize_key))
2892     {
2893     if (expand_string_message)
2894       {
2895       logflags |= LOG_PANIC;
2896       do
2897         {
2898         addr = addr->next;
2899         post_process_one(addr, DEFER, logflags, DTYPE_TRANSPORT, 0);
2900         } while ((addr = addr2));
2901       }
2902     continue;                   /* Loop for the next set of addresses. */
2903     }
2904
2905
2906   /* So, finally, we do have some addresses that can be passed to the
2907   transport. Before doing so, set up variables that are relevant to a
2908   single delivery. */
2909
2910   deliver_set_expansions(addr);
2911   delivery_start = time(NULL);
2912   deliver_local(addr, FALSE);
2913   deliver_time = (int)(time(NULL) - delivery_start);
2914
2915   /* If a shadow transport (which must perforce be another local transport), is
2916   defined, and its condition is met, we must pass the message to the shadow
2917   too, but only those addresses that succeeded. We do this by making a new
2918   chain of addresses - also to keep the original chain uncontaminated. We must
2919   use a chain rather than doing it one by one, because the shadow transport may
2920   batch.
2921
2922   NOTE: if the condition fails because of a lookup defer, there is nothing we
2923   can do! */
2924
2925   if (  tp->shadow
2926      && (  !tp->shadow_condition
2927         || expand_check_condition(tp->shadow_condition, tp->name, US"transport")
2928      )  )
2929     {
2930     transport_instance *stp;
2931     address_item *shadow_addr = NULL;
2932     address_item **last = &shadow_addr;
2933
2934     for (stp = transports; stp; stp = stp->next)
2935       if (Ustrcmp(stp->name, tp->shadow) == 0) break;
2936
2937     if (!stp)
2938       log_write(0, LOG_MAIN|LOG_PANIC, "shadow transport \"%s\" not found ",
2939         tp->shadow);
2940
2941     /* Pick off the addresses that have succeeded, and make clones. Put into
2942     the shadow_message field a pointer to the shadow_message field of the real
2943     address. */
2944
2945     else for (addr2 = addr; addr2; addr2 = addr2->next)
2946       if (addr2->transport_return == OK)
2947         {
2948         addr3 = store_get(sizeof(address_item));
2949         *addr3 = *addr2;
2950         addr3->next = NULL;
2951         addr3->shadow_message = (uschar *) &(addr2->shadow_message);
2952         addr3->transport = stp;
2953         addr3->transport_return = DEFER;
2954         addr3->return_filename = NULL;
2955         addr3->return_file = -1;
2956         *last = addr3;
2957         last = &(addr3->next);
2958         }
2959
2960     /* If we found any addresses to shadow, run the delivery, and stick any
2961     message back into the shadow_message field in the original. */
2962
2963     if (shadow_addr)
2964       {
2965       int save_count = transport_count;
2966
2967       DEBUG(D_deliver|D_transport)
2968         debug_printf(">>>>>>>>>>>>>>>> Shadow delivery >>>>>>>>>>>>>>>>\n");
2969       deliver_local(shadow_addr, TRUE);
2970
2971       for(; shadow_addr; shadow_addr = shadow_addr->next)
2972         {
2973         int sresult = shadow_addr->transport_return;
2974         *(uschar **)shadow_addr->shadow_message =
2975           sresult == OK
2976           ? string_sprintf(" ST=%s", stp->name)
2977           : string_sprintf(" ST=%s (%s%s%s)", stp->name,
2978               shadow_addr->basic_errno <= 0
2979               ? US""
2980               : US strerror(shadow_addr->basic_errno),
2981               shadow_addr->basic_errno <= 0 || !shadow_addr->message
2982               ? US""
2983               : US": ",
2984               shadow_addr->message
2985               ? shadow_addr->message
2986               : shadow_addr->basic_errno <= 0
2987               ? US"unknown error"
2988               : US"");
2989
2990         DEBUG(D_deliver|D_transport)
2991           debug_printf("%s shadow transport returned %s for %s\n",
2992             stp->name,
2993             sresult == OK ?    "OK" :
2994             sresult == DEFER ? "DEFER" :
2995             sresult == FAIL ?  "FAIL" :
2996             sresult == PANIC ? "PANIC" : "?",
2997             shadow_addr->address);
2998         }
2999
3000       DEBUG(D_deliver|D_transport)
3001         debug_printf(">>>>>>>>>>>>>>>> End shadow delivery >>>>>>>>>>>>>>>>\n");
3002
3003       transport_count = save_count;   /* Restore original transport count */
3004       }
3005     }
3006
3007   /* Cancel the expansions that were set up for the delivery. */
3008
3009   deliver_set_expansions(NULL);
3010
3011   /* If the transport was parallelism-limited, decrement the hints DB record. */
3012
3013   if (serialize_key) enq_end(serialize_key);
3014
3015   /* Now we can process the results of the real transport. We must take each
3016   address off the chain first, because post_process_one() puts it on another
3017   chain. */
3018
3019   for (addr2 = addr; addr2; addr2 = nextaddr)
3020     {
3021     int result = addr2->transport_return;
3022     nextaddr = addr2->next;
3023
3024     DEBUG(D_deliver|D_transport)
3025       debug_printf("%s transport returned %s for %s\n",
3026         tp->name,
3027         result == OK ?    "OK" :
3028         result == DEFER ? "DEFER" :
3029         result == FAIL ?  "FAIL" :
3030         result == PANIC ? "PANIC" : "?",
3031         addr2->address);
3032
3033     /* If there is a retry_record, or if delivery is deferred, build a retry
3034     item for setting a new retry time or deleting the old retry record from
3035     the database. These items are handled all together after all addresses
3036     have been handled (so the database is open just for a short time for
3037     updating). */
3038
3039     if (result == DEFER || testflag(addr2, af_lt_retry_exists))
3040       {
3041       int flags = result == DEFER ? 0 : rf_delete;
3042       uschar *retry_key = string_copy(tp->retry_use_local_part
3043         ? addr2->address_retry_key : addr2->domain_retry_key);
3044       *retry_key = 'T';
3045       retry_add_item(addr2, retry_key, flags);
3046       }
3047
3048     /* Done with this address */
3049
3050     if (result == OK) addr2->more_errno = deliver_time;
3051     post_process_one(addr2, result, logflags, DTYPE_TRANSPORT, logchar);
3052
3053     /* If a pipe delivery generated text to be sent back, the result may be
3054     changed to FAIL, and we must copy this for subsequent addresses in the
3055     batch. */
3056
3057     if (addr2->transport_return != result)
3058       {
3059       for (addr3 = nextaddr; addr3; addr3 = addr3->next)
3060         {
3061         addr3->transport_return = addr2->transport_return;
3062         addr3->basic_errno = addr2->basic_errno;
3063         addr3->message = addr2->message;
3064         }
3065       result = addr2->transport_return;
3066       }
3067
3068     /* Whether or not the result was changed to FAIL, we need to copy the
3069     return_file value from the first address into all the addresses of the
3070     batch, so they are all listed in the error message. */
3071
3072     addr2->return_file = addr->return_file;
3073
3074     /* Change log character for recording successful deliveries. */
3075
3076     if (result == OK) logchar = '-';
3077     }
3078   }        /* Loop back for next batch of addresses */
3079 }
3080
3081
3082
3083
3084 /*************************************************
3085 *           Sort remote deliveries               *
3086 *************************************************/
3087
3088 /* This function is called if remote_sort_domains is set. It arranges that the
3089 chain of addresses for remote deliveries is ordered according to the strings
3090 specified. Try to make this shuffling reasonably efficient by handling
3091 sequences of addresses rather than just single ones.
3092
3093 Arguments:  None
3094 Returns:    Nothing
3095 */
3096
3097 static void
3098 sort_remote_deliveries(void)
3099 {
3100 int sep = 0;
3101 address_item **aptr = &addr_remote;
3102 const uschar *listptr = remote_sort_domains;
3103 uschar *pattern;
3104 uschar patbuf[256];
3105
3106 while (  *aptr
3107       && (pattern = string_nextinlist(&listptr, &sep, patbuf, sizeof(patbuf)))
3108       )
3109   {
3110   address_item *moved = NULL;
3111   address_item **bptr = &moved;
3112
3113   while (*aptr)
3114     {
3115     address_item **next;
3116     deliver_domain = (*aptr)->domain;   /* set $domain */
3117     if (match_isinlist(deliver_domain, (const uschar **)&pattern, UCHAR_MAX+1,
3118           &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) == OK)
3119       {
3120       aptr = &(*aptr)->next;
3121       continue;
3122       }
3123
3124     next = &(*aptr)->next;
3125     while (  *next
3126           && (deliver_domain = (*next)->domain,  /* Set $domain */
3127             match_isinlist(deliver_domain, (const uschar **)&pattern, UCHAR_MAX+1,
3128               &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL)) != OK
3129           )
3130       next = &(*next)->next;
3131
3132     /* If the batch of non-matchers is at the end, add on any that were
3133     extracted further up the chain, and end this iteration. Otherwise,
3134     extract them from the chain and hang on the moved chain. */
3135
3136     if (!*next)
3137       {
3138       *next = moved;
3139       break;
3140       }
3141
3142     *bptr = *aptr;
3143     *aptr = *next;
3144     *next = NULL;
3145     bptr = next;
3146     aptr = &(*aptr)->next;
3147     }
3148
3149   /* If the loop ended because the final address matched, *aptr will
3150   be NULL. Add on to the end any extracted non-matching addresses. If
3151   *aptr is not NULL, the loop ended via "break" when *next is null, that
3152   is, there was a string of non-matching addresses at the end. In this
3153   case the extracted addresses have already been added on the end. */
3154
3155   if (!*aptr) *aptr = moved;
3156   }
3157
3158 DEBUG(D_deliver)
3159   {
3160   address_item *addr;
3161   debug_printf("remote addresses after sorting:\n");
3162   for (addr = addr_remote; addr; addr = addr->next)
3163     debug_printf("  %s\n", addr->address);
3164   }
3165 }
3166
3167
3168
3169 /*************************************************
3170 *  Read from pipe for remote delivery subprocess *
3171 *************************************************/
3172
3173 /* This function is called when the subprocess is complete, but can also be
3174 called before it is complete, in order to empty a pipe that is full (to prevent
3175 deadlock). It must therefore keep track of its progress in the parlist data
3176 block.
3177
3178 We read the pipe to get the delivery status codes and a possible error message
3179 for each address, optionally preceded by unusability data for the hosts and
3180 also by optional retry data.
3181
3182 Read in large chunks into the big buffer and then scan through, interpreting
3183 the data therein. In most cases, only a single read will be necessary. No
3184 individual item will ever be anywhere near 2500 bytes in length, so by ensuring
3185 that we read the next chunk when there is less than 2500 bytes left in the
3186 non-final chunk, we can assume each item is complete in the buffer before
3187 handling it. Each item is written using a single write(), which is atomic for
3188 small items (less than PIPE_BUF, which seems to be at least 512 in any Unix and
3189 often bigger) so even if we are reading while the subprocess is still going, we
3190 should never have only a partial item in the buffer.
3191
3192 Argument:
3193   poffset     the offset of the parlist item
3194   eop         TRUE if the process has completed
3195
3196 Returns:      TRUE if the terminating 'Z' item has been read,
3197               or there has been a disaster (i.e. no more data needed);
3198               FALSE otherwise
3199 */
3200
3201 static BOOL
3202 par_read_pipe(int poffset, BOOL eop)
3203 {
3204 host_item *h;
3205 pardata *p = parlist + poffset;
3206 address_item *addrlist = p->addrlist;
3207 address_item *addr = p->addr;
3208 pid_t pid = p->pid;
3209 int fd = p->fd;
3210 uschar *endptr = big_buffer;
3211 uschar *ptr = endptr;
3212 uschar *msg = p->msg;
3213 BOOL done = p->done;
3214 BOOL unfinished = TRUE;
3215 /* minimum size to read is header size including id, subid and length */
3216 int required = PIPE_HEADER_SIZE;
3217
3218 /* Loop through all items, reading from the pipe when necessary. The pipe
3219 is set up to be non-blocking, but there are two different Unix mechanisms in
3220 use. Exim uses O_NONBLOCK if it is defined. This returns 0 for end of file,
3221 and EAGAIN for no more data. If O_NONBLOCK is not defined, Exim uses O_NDELAY,
3222 which returns 0 for both end of file and no more data. We distinguish the
3223 two cases by taking 0 as end of file only when we know the process has
3224 completed.
3225
3226 Each separate item is written to the pipe in a single write(), and as they are
3227 all short items, the writes will all be atomic and we should never find
3228 ourselves in the position of having read an incomplete item. "Short" in this
3229 case can mean up to about 1K in the case when there is a long error message
3230 associated with an address. */
3231
3232 DEBUG(D_deliver) debug_printf("reading pipe for subprocess %d (%s)\n",
3233   (int)p->pid, eop? "ended" : "not ended");
3234
3235 while (!done)
3236   {
3237   retry_item *r, **rp;
3238   int remaining = endptr - ptr;
3239   uschar header[PIPE_HEADER_SIZE + 1];
3240   uschar id, subid;
3241   uschar *endc;
3242
3243   /* Read (first time) or top up the chars in the buffer if necessary.
3244   There will be only one read if we get all the available data (i.e. don't
3245   fill the buffer completely). */
3246
3247   if (remaining < required && unfinished)
3248     {
3249     int len;
3250     int available = big_buffer_size - remaining;
3251
3252     if (remaining > 0) memmove(big_buffer, ptr, remaining);
3253
3254     ptr = big_buffer;
3255     endptr = big_buffer + remaining;
3256     len = read(fd, endptr, available);
3257
3258     DEBUG(D_deliver) debug_printf("read() yielded %d\n", len);
3259
3260     /* If the result is EAGAIN and the process is not complete, just
3261     stop reading any more and process what we have already. */
3262
3263     if (len < 0)
3264       {
3265       if (!eop && errno == EAGAIN) len = 0; else
3266         {
3267         msg = string_sprintf("failed to read pipe from transport process "
3268           "%d for transport %s: %s", pid, addr->transport->driver_name,
3269           strerror(errno));
3270         break;
3271         }
3272       }
3273
3274     /* If the length is zero (eof or no-more-data), just process what we
3275     already have. Note that if the process is still running and we have
3276     read all the data in the pipe (but less that "available") then we
3277     won't read any more, as "unfinished" will get set FALSE. */
3278
3279     endptr += len;
3280     remaining += len;
3281     unfinished = len == available;
3282     }
3283
3284   /* If we are at the end of the available data, exit the loop. */
3285   if (ptr >= endptr) break;
3286
3287   /* copy and read header */
3288   memcpy(header, ptr, PIPE_HEADER_SIZE);
3289   header[PIPE_HEADER_SIZE] = '\0';
3290   id = header[0];
3291   subid = header[1];
3292   required = Ustrtol(header + 2, &endc, 10) + PIPE_HEADER_SIZE;     /* header + data */
3293   if (*endc)
3294     {
3295     msg = string_sprintf("failed to read pipe from transport process "
3296       "%d for transport %s: error reading size from header", pid, addr->transport->driver_name);
3297     done = TRUE;
3298     break;
3299     }
3300
3301   DEBUG(D_deliver)
3302     debug_printf("header read  id:%c,subid:%c,size:%s,required:%d,remaining:%d,unfinished:%d\n",
3303                     id, subid, header+2, required, remaining, unfinished);
3304
3305   /* is there room for the dataset we want to read ? */
3306   if (required > big_buffer_size - PIPE_HEADER_SIZE)
3307     {
3308     msg = string_sprintf("failed to read pipe from transport process "
3309       "%d for transport %s: big_buffer too small! required size=%d buffer size=%d", pid, addr->transport->driver_name,
3310       required, big_buffer_size - PIPE_HEADER_SIZE);
3311     done = TRUE;
3312     break;
3313     }
3314
3315   /* we wrote all datasets with atomic write() calls
3316      remaining < required only happens if big_buffer was too small
3317      to get all available data from pipe. unfinished has to be true
3318      as well. */
3319   if (remaining < required)
3320     {
3321     if (unfinished)
3322       continue;
3323     msg = string_sprintf("failed to read pipe from transport process "
3324       "%d for transport %s: required size=%d > remaining size=%d and unfinished=false",
3325       pid, addr->transport->driver_name, required, remaining);
3326     done = TRUE;
3327     break;
3328     }
3329
3330   /* step behind the header */
3331   ptr += PIPE_HEADER_SIZE;
3332
3333   /* Handle each possible type of item, assuming the complete item is
3334   available in store. */
3335
3336   switch (id)
3337     {
3338     /* Host items exist only if any hosts were marked unusable. Match
3339     up by checking the IP address. */
3340
3341     case 'H':
3342     for (h = addrlist->host_list; h; h = h->next)
3343       {
3344       if (!h->address || Ustrcmp(h->address, ptr+2) != 0) continue;
3345       h->status = ptr[0];
3346       h->why = ptr[1];
3347       }
3348     ptr += 2;
3349     while (*ptr++);
3350     break;
3351
3352     /* Retry items are sent in a preceding R item for each address. This is
3353     kept separate to keep each message short enough to guarantee it won't
3354     be split in the pipe. Hopefully, in the majority of cases, there won't in
3355     fact be any retry items at all.
3356
3357     The complete set of retry items might include an item to delete a
3358     routing retry if there was a previous routing delay. However, routing
3359     retries are also used when a remote transport identifies an address error.
3360     In that case, there may also be an "add" item for the same key. Arrange
3361     that a "delete" item is dropped in favour of an "add" item. */
3362
3363     case 'R':
3364     if (!addr) goto ADDR_MISMATCH;
3365
3366     DEBUG(D_deliver|D_retry)
3367       debug_printf("reading retry information for %s from subprocess\n",
3368         ptr+1);
3369
3370     /* Cut out any "delete" items on the list. */
3371
3372     for (rp = &(addr->retries); (r = *rp); rp = &r->next)
3373       if (Ustrcmp(r->key, ptr+1) == 0)           /* Found item with same key */
3374         {
3375         if ((r->flags & rf_delete) == 0) break;  /* It was not "delete" */
3376         *rp = r->next;                           /* Excise a delete item */
3377         DEBUG(D_deliver|D_retry)
3378           debug_printf("  existing delete item dropped\n");
3379         }
3380
3381     /* We want to add a delete item only if there is no non-delete item;
3382     however we still have to step ptr through the data. */
3383
3384     if (!r || (*ptr & rf_delete) == 0)
3385       {
3386       r = store_get(sizeof(retry_item));
3387       r->next = addr->retries;
3388       addr->retries = r;
3389       r->flags = *ptr++;
3390       r->key = string_copy(ptr);
3391       while (*ptr++);
3392       memcpy(&(r->basic_errno), ptr, sizeof(r->basic_errno));
3393       ptr += sizeof(r->basic_errno);
3394       memcpy(&(r->more_errno), ptr, sizeof(r->more_errno));
3395       ptr += sizeof(r->more_errno);
3396       r->message = (*ptr)? string_copy(ptr) : NULL;
3397       DEBUG(D_deliver|D_retry)
3398         debug_printf("  added %s item\n",
3399           ((r->flags & rf_delete) == 0)? "retry" : "delete");
3400       }
3401
3402     else
3403       {
3404       DEBUG(D_deliver|D_retry)
3405         debug_printf("  delete item not added: non-delete item exists\n");
3406       ptr++;
3407       while(*ptr++);
3408       ptr += sizeof(r->basic_errno) + sizeof(r->more_errno);
3409       }
3410
3411     while(*ptr++);
3412     break;
3413
3414     /* Put the amount of data written into the parlist block */
3415
3416     case 'S':
3417     memcpy(&(p->transport_count), ptr, sizeof(transport_count));
3418     ptr += sizeof(transport_count);
3419     break;
3420
3421     /* Address items are in the order of items on the address chain. We
3422     remember the current address value in case this function is called
3423     several times to empty the pipe in stages. Information about delivery
3424     over TLS is sent in a preceding X item for each address. We don't put
3425     it in with the other info, in order to keep each message short enough to
3426     guarantee it won't be split in the pipe. */
3427
3428 #ifdef SUPPORT_TLS
3429     case 'X':
3430     if (!addr) goto ADDR_MISMATCH;          /* Below, in 'A' handler */
3431     switch (subid)
3432       {
3433       case '1':
3434       addr->cipher = NULL;
3435       addr->peerdn = NULL;
3436
3437       if (*ptr)
3438         addr->cipher = string_copy(ptr);
3439       while (*ptr++);
3440       if (*ptr)
3441         addr->peerdn = string_copy(ptr);
3442       break;
3443
3444       case '2':
3445       if (*ptr)
3446         (void) tls_import_cert(ptr, &addr->peercert);
3447       else
3448         addr->peercert = NULL;
3449       break;
3450
3451       case '3':
3452       if (*ptr)
3453         (void) tls_import_cert(ptr, &addr->ourcert);
3454       else
3455         addr->ourcert = NULL;
3456       break;
3457
3458 # ifndef DISABLE_OCSP
3459       case '4':
3460       addr->ocsp = OCSP_NOT_REQ;
3461       if (*ptr)
3462         addr->ocsp = *ptr - '0';
3463       break;
3464 # endif
3465       }
3466     while (*ptr++);
3467     break;
3468 #endif  /*SUPPORT_TLS*/
3469
3470     case 'C':   /* client authenticator information */
3471     switch (subid)
3472       {
3473       case '1':
3474         addr->authenticator = (*ptr)? string_copy(ptr) : NULL;
3475         break;
3476       case '2':
3477         addr->auth_id = (*ptr)? string_copy(ptr) : NULL;
3478         break;
3479       case '3':
3480         addr->auth_sndr = (*ptr)? string_copy(ptr) : NULL;
3481         break;
3482       }
3483     while (*ptr++);
3484     break;
3485
3486 #ifndef DISABLE_PRDR
3487     case 'P':
3488     addr->flags |= af_prdr_used;
3489     break;
3490 #endif
3491
3492     case 'K':
3493     addr->flags |= af_chunking_used;
3494     break;
3495
3496     case 'D':
3497     if (!addr) goto ADDR_MISMATCH;
3498     memcpy(&(addr->dsn_aware), ptr, sizeof(addr->dsn_aware));
3499     ptr += sizeof(addr->dsn_aware);
3500     DEBUG(D_deliver) debug_printf("DSN read: addr->dsn_aware = %d\n", addr->dsn_aware);
3501     break;
3502
3503     case 'A':
3504     if (!addr)
3505       {
3506       ADDR_MISMATCH:
3507       msg = string_sprintf("address count mismatch for data read from pipe "
3508         "for transport process %d for transport %s", pid,
3509           addrlist->transport->driver_name);
3510       done = TRUE;
3511       break;
3512       }
3513
3514     switch (subid)
3515       {
3516 #ifdef SUPPORT_SOCKS
3517       case '2': /* proxy information; must arrive before A0 and applies to that addr XXX oops*/
3518         proxy_session = TRUE;   /*XXX shouod this be cleared somewhere? */
3519         if (*ptr == 0)
3520           ptr++;
3521         else
3522           {
3523           proxy_local_address = string_copy(ptr);
3524           while(*ptr++);
3525           memcpy(&proxy_local_port, ptr, sizeof(proxy_local_port));
3526           ptr += sizeof(proxy_local_port);
3527           }
3528         break;
3529 #endif
3530
3531 #ifdef EXPERIMENTAL_DSN_INFO
3532       case '1': /* must arrive before A0, and applies to that addr */
3533                 /* Two strings: smtp_greeting and helo_response */
3534         addr->smtp_greeting = string_copy(ptr);
3535         while(*ptr++);
3536         addr->helo_response = string_copy(ptr);
3537         while(*ptr++);
3538         break;
3539 #endif
3540
3541       case '0':
3542         addr->transport_return = *ptr++;
3543         addr->special_action = *ptr++;
3544         memcpy(&(addr->basic_errno), ptr, sizeof(addr->basic_errno));
3545         ptr += sizeof(addr->basic_errno);
3546         memcpy(&(addr->more_errno), ptr, sizeof(addr->more_errno));
3547         ptr += sizeof(addr->more_errno);
3548         memcpy(&(addr->flags), ptr, sizeof(addr->flags));
3549         ptr += sizeof(addr->flags);
3550         addr->message = (*ptr)? string_copy(ptr) : NULL;
3551         while(*ptr++);
3552         addr->user_message = (*ptr)? string_copy(ptr) : NULL;
3553         while(*ptr++);
3554
3555         /* Always two strings for host information, followed by the port number and DNSSEC mark */
3556
3557         if (*ptr != 0)
3558           {
3559           h = store_get(sizeof(host_item));
3560           h->name = string_copy(ptr);
3561           while (*ptr++);
3562           h->address = string_copy(ptr);
3563           while(*ptr++);
3564           memcpy(&(h->port), ptr, sizeof(h->port));
3565           ptr += sizeof(h->port);
3566           h->dnssec = *ptr == '2' ? DS_YES
3567                     : *ptr == '1' ? DS_NO
3568                     : DS_UNK;
3569           ptr++;
3570           addr->host_used = h;
3571           }
3572         else ptr++;
3573
3574         /* Finished with this address */
3575
3576         addr = addr->next;
3577         break;
3578       }
3579     break;
3580
3581     /* Local interface address/port */
3582     case 'I':
3583     if (*ptr) sending_ip_address = string_copy(ptr);
3584     while (*ptr++) ;
3585     if (*ptr) sending_port = atoi(CS ptr);
3586     while (*ptr++) ;
3587     break;
3588
3589     /* Z marks the logical end of the data. It is followed by '0' if
3590     continue_transport was NULL at the end of transporting, otherwise '1'.
3591     We need to know when it becomes NULL during a delivery down a passed SMTP
3592     channel so that we don't try to pass anything more down it. Of course, for
3593     most normal messages it will remain NULL all the time. */
3594
3595     case 'Z':
3596     if (*ptr == '0')
3597       {
3598       continue_transport = NULL;
3599       continue_hostname = NULL;
3600       }
3601     done = TRUE;
3602     DEBUG(D_deliver) debug_printf("Z0%c item read\n", *ptr);
3603     break;
3604
3605     /* Anything else is a disaster. */
3606
3607     default:
3608     msg = string_sprintf("malformed data (%d) read from pipe for transport "
3609       "process %d for transport %s", ptr[-1], pid,
3610         addr->transport->driver_name);
3611     done = TRUE;
3612     break;
3613     }
3614   }
3615
3616 /* The done flag is inspected externally, to determine whether or not to
3617 call the function again when the process finishes. */
3618
3619 p->done = done;
3620
3621 /* If the process hadn't finished, and we haven't seen the end of the data
3622 or suffered a disaster, update the rest of the state, and return FALSE to
3623 indicate "not finished". */
3624
3625 if (!eop && !done)
3626   {
3627   p->addr = addr;
3628   p->msg = msg;
3629   return FALSE;
3630   }
3631
3632 /* Close our end of the pipe, to prevent deadlock if the far end is still
3633 pushing stuff into it. */
3634
3635 (void)close(fd);
3636 p->fd = -1;
3637
3638 /* If we have finished without error, but haven't had data for every address,
3639 something is wrong. */
3640
3641 if (!msg && addr)
3642   msg = string_sprintf("insufficient address data read from pipe "
3643     "for transport process %d for transport %s", pid,
3644       addr->transport->driver_name);
3645
3646 /* If an error message is set, something has gone wrong in getting back
3647 the delivery data. Put the message into each address and freeze it. */
3648
3649 if (msg)
3650   for (addr = addrlist; addr; addr = addr->next)
3651     {
3652     addr->transport_return = DEFER;
3653     addr->special_action = SPECIAL_FREEZE;
3654     addr->message = msg;
3655     }
3656
3657 /* Return TRUE to indicate we have got all we need from this process, even
3658 if it hasn't actually finished yet. */
3659
3660 return TRUE;
3661 }
3662
3663
3664
3665 /*************************************************
3666 *   Post-process a set of remote addresses       *
3667 *************************************************/
3668
3669 /* Do what has to be done immediately after a remote delivery for each set of
3670 addresses, then re-write the spool if necessary. Note that post_process_one
3671 puts the address on an appropriate queue; hence we must fish off the next
3672 one first. This function is also called if there is a problem with setting
3673 up a subprocess to do a remote delivery in parallel. In this case, the final
3674 argument contains a message, and the action must be forced to DEFER.
3675
3676 Argument:
3677    addr      pointer to chain of address items
3678    logflags  flags for logging
3679    msg       NULL for normal cases; -> error message for unexpected problems
3680    fallback  TRUE if processing fallback hosts
3681
3682 Returns:     nothing
3683 */
3684
3685 static void
3686 remote_post_process(address_item *addr, int logflags, uschar *msg,
3687   BOOL fallback)
3688 {
3689 host_item *h;
3690
3691 /* If any host addresses were found to be unusable, add them to the unusable
3692 tree so that subsequent deliveries don't try them. */
3693
3694 for (h = addr->host_list; h; h = h->next)
3695   if (h->address)
3696     if (h->status >= hstatus_unusable) tree_add_unusable(h);
3697
3698 /* Now handle each address on the chain. The transport has placed '=' or '-'
3699 into the special_action field for each successful delivery. */
3700
3701 while (addr)
3702   {
3703   address_item *next = addr->next;
3704
3705   /* If msg == NULL (normal processing) and the result is DEFER and we are
3706   processing the main hosts and there are fallback hosts available, put the
3707   address on the list for fallback delivery. */
3708
3709   if (  addr->transport_return == DEFER
3710      && addr->fallback_hosts
3711      && !fallback
3712      && !msg
3713      )
3714     {
3715     addr->host_list = addr->fallback_hosts;
3716     addr->next = addr_fallback;
3717     addr_fallback = addr;
3718     DEBUG(D_deliver) debug_printf("%s queued for fallback host(s)\n", addr->address);
3719     }
3720
3721   /* If msg is set (=> unexpected problem), set it in the address before
3722   doing the ordinary post processing. */
3723
3724   else
3725     {
3726     if (msg)
3727       {
3728       addr->message = msg;
3729       addr->transport_return = DEFER;
3730       }
3731     (void)post_process_one(addr, addr->transport_return, logflags,
3732       DTYPE_TRANSPORT, addr->special_action);
3733     }
3734
3735   /* Next address */
3736
3737   addr = next;
3738   }
3739
3740 /* If we have just delivered down a passed SMTP channel, and that was
3741 the last address, the channel will have been closed down. Now that
3742 we have logged that delivery, set continue_sequence to 1 so that
3743 any subsequent deliveries don't get "*" incorrectly logged. */
3744
3745 if (!continue_transport) continue_sequence = 1;
3746 }
3747
3748
3749
3750 /*************************************************
3751 *     Wait for one remote delivery subprocess    *
3752 *************************************************/
3753
3754 /* This function is called while doing remote deliveries when either the
3755 maximum number of processes exist and we need one to complete so that another
3756 can be created, or when waiting for the last ones to complete. It must wait for
3757 the completion of one subprocess, empty the control block slot, and return a
3758 pointer to the address chain.
3759
3760 Arguments:    none
3761 Returns:      pointer to the chain of addresses handled by the process;
3762               NULL if no subprocess found - this is an unexpected error
3763 */
3764
3765 static address_item *
3766 par_wait(void)
3767 {
3768 int poffset, status;
3769 address_item *addr, *addrlist;
3770 pid_t pid;
3771
3772 set_process_info("delivering %s: waiting for a remote delivery subprocess "
3773   "to finish", message_id);
3774
3775 /* Loop until either a subprocess completes, or there are no subprocesses in
3776 existence - in which case give an error return. We cannot proceed just by
3777 waiting for a completion, because a subprocess may have filled up its pipe, and
3778 be waiting for it to be emptied. Therefore, if no processes have finished, we
3779 wait for one of the pipes to acquire some data by calling select(), with a
3780 timeout just in case.
3781
3782 The simple approach is just to iterate after reading data from a ready pipe.
3783 This leads to non-ideal behaviour when the subprocess has written its final Z
3784 item, closed the pipe, and is in the process of exiting (the common case). A
3785 call to waitpid() yields nothing completed, but select() shows the pipe ready -
3786 reading it yields EOF, so you end up with busy-waiting until the subprocess has
3787 actually finished.
3788
3789 To avoid this, if all the data that is needed has been read from a subprocess
3790 after select(), an explicit wait() for it is done. We know that all it is doing
3791 is writing to the pipe and then exiting, so the wait should not be long.
3792
3793 The non-blocking waitpid() is to some extent just insurance; if we could
3794 reliably detect end-of-file on the pipe, we could always know when to do a
3795 blocking wait() for a completed process. However, because some systems use
3796 NDELAY, which doesn't distinguish between EOF and pipe empty, it is easier to
3797 use code that functions without the need to recognize EOF.
3798
3799 There's a double loop here just in case we end up with a process that is not in
3800 the list of remote delivery processes. Something has obviously gone wrong if
3801 this is the case. (For example, a process that is incorrectly left over from
3802 routing or local deliveries might be found.) The damage can be minimized by
3803 looping back and looking for another process. If there aren't any, the error
3804 return will happen. */
3805
3806 for (;;)   /* Normally we do not repeat this loop */
3807   {
3808   while ((pid = waitpid(-1, &status, WNOHANG)) <= 0)
3809     {
3810     struct timeval tv;
3811     fd_set select_pipes;
3812     int maxpipe, readycount;
3813
3814     /* A return value of -1 can mean several things. If errno != ECHILD, it
3815     either means invalid options (which we discount), or that this process was
3816     interrupted by a signal. Just loop to try the waitpid() again.
3817
3818     If errno == ECHILD, waitpid() is telling us that there are no subprocesses
3819     in existence. This should never happen, and is an unexpected error.
3820     However, there is a nasty complication when running under Linux. If "strace
3821     -f" is being used under Linux to trace this process and its children,
3822     subprocesses are "stolen" from their parents and become the children of the
3823     tracing process. A general wait such as the one we've just obeyed returns
3824     as if there are no children while subprocesses are running. Once a
3825     subprocess completes, it is restored to the parent, and waitpid(-1) finds
3826     it. Thanks to Joachim Wieland for finding all this out and suggesting a
3827     palliative.
3828
3829     This does not happen using "truss" on Solaris, nor (I think) with other
3830     tracing facilities on other OS. It seems to be specific to Linux.
3831
3832     What we do to get round this is to use kill() to see if any of our
3833     subprocesses are still in existence. If kill() gives an OK return, we know
3834     it must be for one of our processes - it can't be for a re-use of the pid,
3835     because if our process had finished, waitpid() would have found it. If any
3836     of our subprocesses are in existence, we proceed to use select() as if
3837     waitpid() had returned zero. I think this is safe. */
3838
3839     if (pid < 0)
3840       {
3841       if (errno != ECHILD) continue;   /* Repeats the waitpid() */
3842
3843       DEBUG(D_deliver)
3844         debug_printf("waitpid() returned -1/ECHILD: checking explicitly "
3845           "for process existence\n");
3846
3847       for (poffset = 0; poffset < remote_max_parallel; poffset++)
3848         {
3849         if ((pid = parlist[poffset].pid) != 0 && kill(pid, 0) == 0)
3850           {
3851           DEBUG(D_deliver) debug_printf("process %d still exists: assume "
3852             "stolen by strace\n", (int)pid);
3853           break;   /* With poffset set */
3854           }
3855         }
3856
3857       if (poffset >= remote_max_parallel)
3858         {
3859         DEBUG(D_deliver) debug_printf("*** no delivery children found\n");
3860         return NULL;   /* This is the error return */
3861         }
3862       }
3863
3864     /* A pid value greater than 0 breaks the "while" loop. A negative value has
3865     been handled above. A return value of zero means that there is at least one
3866     subprocess, but there are no completed subprocesses. See if any pipes are
3867     ready with any data for reading. */
3868
3869     DEBUG(D_deliver) debug_printf("selecting on subprocess pipes\n");
3870
3871     maxpipe = 0;
3872     FD_ZERO(&select_pipes);
3873     for (poffset = 0; poffset < remote_max_parallel; poffset++)
3874       {
3875       if (parlist[poffset].pid != 0)
3876         {
3877         int fd = parlist[poffset].fd;
3878         FD_SET(fd, &select_pipes);
3879         if (fd > maxpipe) maxpipe = fd;
3880         }
3881       }
3882
3883     /* Stick in a 60-second timeout, just in case. */
3884
3885     tv.tv_sec = 60;
3886     tv.tv_usec = 0;
3887
3888     readycount = select(maxpipe + 1, (SELECT_ARG2_TYPE *)&select_pipes,
3889          NULL, NULL, &tv);
3890
3891     /* Scan through the pipes and read any that are ready; use the count
3892     returned by select() to stop when there are no more. Select() can return
3893     with no processes (e.g. if interrupted). This shouldn't matter.
3894
3895     If par_read_pipe() returns TRUE, it means that either the terminating Z was
3896     read, or there was a disaster. In either case, we are finished with this
3897     process. Do an explicit wait() for the process and break the main loop if
3898     it succeeds.
3899
3900     It turns out that we have to deal with the case of an interrupted system
3901     call, which can happen on some operating systems if the signal handling is
3902     set up to do that by default. */
3903
3904     for (poffset = 0;
3905          readycount > 0 && poffset < remote_max_parallel;
3906          poffset++)
3907       {
3908       if (  (pid = parlist[poffset].pid) != 0
3909          && FD_ISSET(parlist[poffset].fd, &select_pipes)
3910          )
3911         {
3912         readycount--;
3913         if (par_read_pipe(poffset, FALSE))    /* Finished with this pipe */
3914           {
3915           for (;;)                            /* Loop for signals */
3916             {
3917             pid_t endedpid = waitpid(pid, &status, 0);
3918             if (endedpid == pid) goto PROCESS_DONE;
3919             if (endedpid != (pid_t)(-1) || errno != EINTR)
3920               log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Unexpected error return "
3921                 "%d (errno = %d) from waitpid() for process %d",
3922                 (int)endedpid, errno, (int)pid);
3923             }
3924           }
3925         }
3926       }
3927
3928     /* Now go back and look for a completed subprocess again. */
3929     }
3930
3931   /* A completed process was detected by the non-blocking waitpid(). Find the
3932   data block that corresponds to this subprocess. */
3933
3934   for (poffset = 0; poffset < remote_max_parallel; poffset++)
3935     if (pid == parlist[poffset].pid) break;
3936
3937   /* Found the data block; this is a known remote delivery process. We don't
3938   need to repeat the outer loop. This should be what normally happens. */
3939
3940   if (poffset < remote_max_parallel) break;
3941
3942   /* This situation is an error, but it's probably better to carry on looking
3943   for another process than to give up (as we used to do). */
3944
3945   log_write(0, LOG_MAIN|LOG_PANIC, "Process %d finished: not found in remote "
3946     "transport process list", pid);
3947   }  /* End of the "for" loop */
3948
3949 /* Come here when all the data was completely read after a select(), and
3950 the process in pid has been wait()ed for. */
3951
3952 PROCESS_DONE:
3953
3954 DEBUG(D_deliver)
3955   {
3956   if (status == 0)
3957     debug_printf("remote delivery process %d ended\n", (int)pid);
3958   else
3959     debug_printf("remote delivery process %d ended: status=%04x\n", (int)pid,
3960       status);
3961   }
3962
3963 set_process_info("delivering %s", message_id);
3964
3965 /* Get the chain of processed addresses */
3966
3967 addrlist = parlist[poffset].addrlist;
3968
3969 /* If the process did not finish cleanly, record an error and freeze (except
3970 for SIGTERM, SIGKILL and SIGQUIT), and also ensure the journal is not removed,
3971 in case the delivery did actually happen. */
3972
3973 if ((status & 0xffff) != 0)
3974   {
3975   uschar *msg;
3976   int msb = (status >> 8) & 255;
3977   int lsb = status & 255;
3978   int code = (msb == 0)? (lsb & 0x7f) : msb;
3979
3980   msg = string_sprintf("%s transport process returned non-zero status 0x%04x: "
3981     "%s %d",
3982     addrlist->transport->driver_name,
3983     status,
3984     (msb == 0)? "terminated by signal" : "exit code",
3985     code);
3986
3987   if (msb != 0 || (code != SIGTERM && code != SIGKILL && code != SIGQUIT))
3988     addrlist->special_action = SPECIAL_FREEZE;
3989
3990   for (addr = addrlist; addr; addr = addr->next)
3991     {
3992     addr->transport_return = DEFER;
3993     addr->message = msg;
3994     }
3995
3996   remove_journal = FALSE;
3997   }
3998
3999 /* Else complete reading the pipe to get the result of the delivery, if all
4000 the data has not yet been obtained. */
4001
4002 else if (!parlist[poffset].done) (void)par_read_pipe(poffset, TRUE);
4003
4004 /* Put the data count and return path into globals, mark the data slot unused,
4005 decrement the count of subprocesses, and return the address chain. */
4006
4007 transport_count = parlist[poffset].transport_count;
4008 used_return_path = parlist[poffset].return_path;
4009 parlist[poffset].pid = 0;
4010 parcount--;
4011 return addrlist;
4012 }
4013
4014
4015
4016 /*************************************************
4017 *      Wait for subprocesses and post-process    *
4018 *************************************************/
4019
4020 /* This function waits for subprocesses until the number that are still running
4021 is below a given threshold. For each complete subprocess, the addresses are
4022 post-processed. If we can't find a running process, there is some shambles.
4023 Better not bomb out, as that might lead to multiple copies of the message. Just
4024 log and proceed as if all done.
4025
4026 Arguments:
4027   max         maximum number of subprocesses to leave running
4028   fallback    TRUE if processing fallback hosts
4029
4030 Returns:      nothing
4031 */
4032
4033 static void
4034 par_reduce(int max, BOOL fallback)
4035 {
4036 while (parcount > max)
4037   {
4038   address_item *doneaddr = par_wait();
4039   if (!doneaddr)
4040     {
4041     log_write(0, LOG_MAIN|LOG_PANIC,
4042       "remote delivery process count got out of step");
4043     parcount = 0;
4044     }
4045   else
4046     {
4047     transport_instance * tp = doneaddr->transport;
4048     if (tp->max_parallel)
4049       enq_end(string_sprintf("tpt-serialize-%s", tp->name));
4050
4051     remote_post_process(doneaddr, LOG_MAIN, NULL, fallback);
4052     }
4053   }
4054 }
4055
4056
4057
4058
4059 static void
4060 rmt_dlv_checked_write(int fd, char id, char subid, void * buf, int size)
4061 {
4062 uschar  writebuffer[PIPE_HEADER_SIZE + BIG_BUFFER_SIZE];
4063 int header_length;
4064 int ret;
4065
4066 /* we assume that size can't get larger then BIG_BUFFER_SIZE which currently is set to 16k */
4067 /* complain to log if someone tries with buffer sizes we can't handle*/
4068
4069 if (size > 99999)
4070   {
4071   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
4072     "Failed writing transport result to pipe: can't handle buffers > 99999 bytes. truncating!\n");
4073   size = 99999;
4074   }
4075
4076 /* to keep the write() atomic we build header in writebuffer and copy buf behind */
4077 /* two write() calls would increase the complexity of reading from pipe */
4078
4079 /* convert size to human readable string prepended by id and subid */
4080 header_length = snprintf(CS writebuffer, PIPE_HEADER_SIZE+1, "%c%c%05d", id, subid, size);
4081 if (header_length != PIPE_HEADER_SIZE)
4082   {
4083   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "header snprintf failed\n");
4084   writebuffer[0] = '\0';
4085   }
4086
4087 DEBUG(D_deliver) debug_printf("header write id:%c,subid:%c,size:%d,final:%s\n",
4088                                  id, subid, size, writebuffer);
4089
4090 if (buf && size > 0)
4091   memcpy(writebuffer + PIPE_HEADER_SIZE, buf, size);
4092
4093 size += PIPE_HEADER_SIZE;
4094 if ((ret = write(fd, writebuffer, size)) != size)
4095   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed writing transport result to pipe: %s\n",
4096     ret == -1 ? strerror(errno) : "short write");
4097 }
4098
4099 /*************************************************
4100 *           Do remote deliveries                 *
4101 *************************************************/
4102
4103 /* This function is called to process the addresses in addr_remote. We must
4104 pick off the queue all addresses that have the same transport, remote
4105 destination, and errors address, and hand them to the transport in one go,
4106 subject to some configured limitations. If this is a run to continue delivering
4107 to an existing delivery channel, skip all but those addresses that can go to
4108 that channel. The skipped addresses just get deferred.
4109
4110 If mua_wrapper is set, all addresses must be able to be sent in a single
4111 transaction. If not, this function yields FALSE.
4112
4113 In Exim 4, remote deliveries are always done in separate processes, even
4114 if remote_max_parallel = 1 or if there's only one delivery to do. The reason
4115 is so that the base process can retain privilege. This makes the
4116 implementation of fallback transports feasible (though not initially done.)
4117
4118 We create up to the configured number of subprocesses, each of which passes
4119 back the delivery state via a pipe. (However, when sending down an existing
4120 connection, remote_max_parallel is forced to 1.)
4121
4122 Arguments:
4123   fallback  TRUE if processing fallback hosts
4124
4125 Returns:    TRUE normally
4126             FALSE if mua_wrapper is set and the addresses cannot all be sent
4127               in one transaction
4128 */
4129
4130 static BOOL
4131 do_remote_deliveries(BOOL fallback)
4132 {
4133 int parmax;
4134 int delivery_count;
4135 int poffset;
4136
4137 parcount = 0;    /* Number of executing subprocesses */
4138
4139 /* When sending down an existing channel, only do one delivery at a time.
4140 We use a local variable (parmax) to hold the maximum number of processes;
4141 this gets reduced from remote_max_parallel if we can't create enough pipes. */
4142
4143 if (continue_transport) remote_max_parallel = 1;
4144 parmax = remote_max_parallel;
4145
4146 /* If the data for keeping a list of processes hasn't yet been
4147 set up, do so. */
4148
4149 if (!parlist)
4150   {
4151   parlist = store_get(remote_max_parallel * sizeof(pardata));
4152   for (poffset = 0; poffset < remote_max_parallel; poffset++)
4153     parlist[poffset].pid = 0;
4154   }
4155
4156 /* Now loop for each remote delivery */
4157
4158 for (delivery_count = 0; addr_remote; delivery_count++)
4159   {
4160   pid_t pid;
4161   uid_t uid;
4162   gid_t gid;
4163   int pfd[2];
4164   int address_count = 1;
4165   int address_count_max;
4166   BOOL multi_domain;
4167   BOOL use_initgroups;
4168   BOOL pipe_done = FALSE;
4169   transport_instance *tp;
4170   address_item **anchor = &addr_remote;
4171   address_item *addr = addr_remote;
4172   address_item *last = addr;
4173   address_item *next;
4174   uschar * panicmsg;
4175   uschar * serialize_key = NULL;
4176
4177   /* Pull the first address right off the list. */
4178
4179   addr_remote = addr->next;
4180   addr->next = NULL;
4181
4182   DEBUG(D_deliver|D_transport)
4183     debug_printf("--------> %s <--------\n", addr->address);
4184
4185   /* If no transport has been set, there has been a big screw-up somewhere. */
4186
4187   if (!(tp = addr->transport))
4188     {
4189     disable_logging = FALSE;  /* Jic */
4190     panicmsg = US"No transport set by router";
4191     goto panic_continue;
4192     }
4193
4194   /* Check that this base address hasn't previously been delivered to this
4195   transport. The check is necessary at this point to handle homonymic addresses
4196   correctly in cases where the pattern of redirection changes between delivery
4197   attempts. Non-homonymic previous delivery is detected earlier, at routing
4198   time. */
4199
4200   if (previously_transported(addr, FALSE)) continue;
4201
4202   /* Force failure if the message is too big. */
4203
4204   if (tp->message_size_limit)
4205     {
4206     int rc = check_message_size(tp, addr);
4207     if (rc != OK)
4208       {
4209       addr->transport_return = rc;
4210       remote_post_process(addr, LOG_MAIN, NULL, fallback);
4211       continue;
4212       }
4213     }
4214
4215   /* Get the flag which specifies whether the transport can handle different
4216   domains that nevertheless resolve to the same set of hosts. If it needs
4217   expanding, get variables set: $address_data, $domain_data, $localpart_data,
4218   $host, $host_address, $host_port. */
4219   if (tp->expand_multi_domain)
4220     deliver_set_expansions(addr);
4221
4222   if (exp_bool(addr, US"transport", tp->name, D_transport,
4223                 US"multi_domain", tp->multi_domain, tp->expand_multi_domain,
4224                 &multi_domain) != OK)
4225     {
4226     deliver_set_expansions(NULL);
4227     panicmsg = addr->message;
4228     goto panic_continue;
4229     }
4230
4231   /* Get the maximum it can handle in one envelope, with zero meaning
4232   unlimited, which is forced for the MUA wrapper case. */
4233
4234   address_count_max = tp->max_addresses;
4235   if (address_count_max == 0 || mua_wrapper) address_count_max = 999999;
4236
4237
4238   /************************************************************************/
4239   /*****    This is slightly experimental code, but should be safe.   *****/
4240
4241   /* The address_count_max value is the maximum number of addresses that the
4242   transport can send in one envelope. However, the transport must be capable of
4243   dealing with any number of addresses. If the number it gets exceeds its
4244   envelope limitation, it must send multiple copies of the message. This can be
4245   done over a single connection for SMTP, so uses less resources than making
4246   multiple connections. On the other hand, if remote_max_parallel is greater
4247   than one, it is perhaps a good idea to use parallel processing to move the
4248   message faster, even if that results in multiple simultaneous connections to
4249   the same host.
4250
4251   How can we come to some compromise between these two ideals? What we do is to
4252   limit the number of addresses passed to a single instance of a transport to
4253   the greater of (a) its address limit (rcpt_max for SMTP) and (b) the total
4254   number of addresses routed to remote transports divided by
4255   remote_max_parallel. For example, if the message has 100 remote recipients,
4256   remote max parallel is 2, and rcpt_max is 10, we'd never send more than 50 at
4257   once. But if rcpt_max is 100, we could send up to 100.
4258
4259   Of course, not all the remotely addresses in a message are going to go to the
4260   same set of hosts (except in smarthost configurations), so this is just a
4261   heuristic way of dividing up the work.
4262
4263   Furthermore (1), because this may not be wanted in some cases, and also to
4264   cope with really pathological cases, there is also a limit to the number of
4265   messages that are sent over one connection. This is the same limit that is
4266   used when sending several different messages over the same connection.
4267   Continue_sequence is set when in this situation, to the number sent so
4268   far, including this message.
4269
4270   Furthermore (2), when somebody explicitly sets the maximum value to 1, it
4271   is probably because they are using VERP, in which case they want to pass only
4272   one address at a time to the transport, in order to be able to use
4273   $local_part and $domain in constructing a new return path. We could test for
4274   the use of these variables, but as it is so likely they will be used when the
4275   maximum is 1, we don't bother. Just leave the value alone. */
4276
4277   if (  address_count_max != 1
4278      && address_count_max < remote_delivery_count/remote_max_parallel
4279      )
4280     {
4281     int new_max = remote_delivery_count/remote_max_parallel;
4282     int message_max = tp->connection_max_messages;
4283     if (connection_max_messages >= 0) message_max = connection_max_messages;
4284     message_max -= continue_sequence - 1;
4285     if (message_max > 0 && new_max > address_count_max * message_max)
4286       new_max = address_count_max * message_max;
4287     address_count_max = new_max;
4288     }
4289
4290   /************************************************************************/
4291
4292
4293   /* Pick off all addresses which have the same transport, errors address,
4294   destination, and extra headers. In some cases they point to the same host
4295   list, but we also need to check for identical host lists generated from
4296   entirely different domains. The host list pointers can be NULL in the case
4297   where the hosts are defined in the transport. There is also a configured
4298   maximum limit of addresses that can be handled at once (see comments above
4299   for how it is computed).
4300   If the transport does not handle multiple domains, enforce that also,
4301   and if it might need a per-address check for this, re-evaluate it.
4302   */
4303
4304   while ((next = *anchor) && address_count < address_count_max)
4305     {
4306     BOOL md;
4307     if (  (multi_domain || Ustrcmp(next->domain, addr->domain) == 0)
4308        && tp == next->transport
4309        && same_hosts(next->host_list, addr->host_list)
4310        && same_strings(next->prop.errors_address, addr->prop.errors_address)
4311        && same_headers(next->prop.extra_headers, addr->prop.extra_headers)
4312        && same_ugid(tp, next, addr)
4313        && (  next->prop.remove_headers == addr->prop.remove_headers
4314           || (  next->prop.remove_headers
4315              && addr->prop.remove_headers
4316              && Ustrcmp(next->prop.remove_headers, addr->prop.remove_headers) == 0
4317           )  )
4318        && (  !multi_domain
4319           || (  (
4320                 !tp->expand_multi_domain || (deliver_set_expansions(next), 1),
4321                 exp_bool(addr,
4322                     US"transport", next->transport->name, D_transport,
4323                     US"multi_domain", next->transport->multi_domain,
4324                     next->transport->expand_multi_domain, &md) == OK
4325                 )
4326              && md
4327        )  )  )
4328       {
4329       *anchor = next->next;
4330       next->next = NULL;
4331       next->first = addr;  /* remember top one (for retry processing) */
4332       last->next = next;
4333       last = next;
4334       address_count++;
4335       }
4336     else anchor = &(next->next);
4337     deliver_set_expansions(NULL);
4338     }
4339
4340   /* If we are acting as an MUA wrapper, all addresses must go in a single
4341   transaction. If not, put them back on the chain and yield FALSE. */
4342
4343   if (mua_wrapper && addr_remote)
4344     {
4345     last->next = addr_remote;
4346     addr_remote = addr;
4347     return FALSE;
4348     }
4349
4350   /* If the transport is limited for parallellism, enforce that here.
4351   The hints DB entry is decremented in par_reduce(), when we reap the
4352   transport process. */
4353
4354   if (tpt_parallel_check(tp, addr, &serialize_key))
4355     if ((panicmsg = expand_string_message))
4356       goto panic_continue;
4357     else
4358       continue;                 /* Loop for the next set of addresses. */
4359
4360   /* Set up the expansion variables for this set of addresses */
4361
4362   deliver_set_expansions(addr);
4363
4364   /* Ensure any transport-set auth info is fresh */
4365   addr->authenticator = addr->auth_id = addr->auth_sndr = NULL;
4366
4367   /* Compute the return path, expanding a new one if required. The old one
4368   must be set first, as it might be referred to in the expansion. */
4369
4370   if(addr->prop.errors_address)
4371     return_path = addr->prop.errors_address;
4372 #ifdef EXPERIMENTAL_SRS
4373   else if(addr->prop.srs_sender)
4374     return_path = addr->prop.srs_sender;
4375 #endif
4376   else
4377     return_path = sender_address;
4378
4379   if (tp->return_path)
4380     {
4381     uschar *new_return_path = expand_string(tp->return_path);
4382     if (new_return_path)
4383       return_path = new_return_path;
4384     else if (!expand_string_forcedfail)
4385       {
4386       panicmsg = string_sprintf("Failed to expand return path \"%s\": %s",
4387         tp->return_path, expand_string_message);
4388       goto enq_continue;
4389       }
4390     }
4391
4392   /* Find the uid, gid, and use_initgroups setting for this transport. Failure
4393   logs and sets up error messages, so we just post-process and continue with
4394   the next address. */
4395
4396   if (!findugid(addr, tp, &uid, &gid, &use_initgroups))
4397     {
4398     panicmsg = NULL;
4399     goto enq_continue;
4400     }
4401
4402   /* If this transport has a setup function, call it now so that it gets
4403   run in this process and not in any subprocess. That way, the results of
4404   any setup that are retained by the transport can be reusable. One of the
4405   things the setup does is to set the fallback host lists in the addresses.
4406   That is why it is called at this point, before the continue delivery
4407   processing, because that might use the fallback hosts. */
4408
4409   if (tp->setup)
4410     (void)((tp->setup)(addr->transport, addr, NULL, uid, gid, NULL));
4411
4412   /* If this is a run to continue delivery down an already-established
4413   channel, check that this set of addresses matches the transport and
4414   the channel. If it does not, defer the addresses. If a host list exists,
4415   we must check that the continue host is on the list. Otherwise, the
4416   host is set in the transport. */
4417
4418   continue_more = FALSE;           /* In case got set for the last lot */
4419   if (continue_transport)
4420     {
4421     BOOL ok = Ustrcmp(continue_transport, tp->name) == 0;
4422     if (ok && addr->host_list)
4423       {
4424       host_item *h;
4425       ok = FALSE;
4426       for (h = addr->host_list; h; h = h->next)
4427         if (Ustrcmp(h->name, continue_hostname) == 0)
4428 /*XXX should also check port here */
4429           { ok = TRUE; break; }
4430       }
4431
4432     /* Addresses not suitable; defer or queue for fallback hosts (which
4433     might be the continue host) and skip to next address. */
4434
4435     if (!ok)
4436       {
4437       DEBUG(D_deliver) debug_printf("not suitable for continue_transport\n");
4438       if (serialize_key) enq_end(serialize_key);
4439
4440       if (addr->fallback_hosts && !fallback)
4441         {
4442         for (next = addr; ; next = next->next)
4443           {
4444           next->host_list = next->fallback_hosts;
4445           DEBUG(D_deliver) debug_printf("%s queued for fallback host(s)\n", next->address);
4446           if (!next->next) break;
4447           }
4448         next->next = addr_fallback;
4449         addr_fallback = addr;
4450         }
4451
4452       else
4453         {
4454         for (next = addr; ; next = next->next)
4455           {
4456           DEBUG(D_deliver) debug_printf(" %s to def list\n", next->address);
4457           if (!next->next) break;
4458           }
4459         next->next = addr_defer;
4460         addr_defer = addr;
4461         }
4462
4463       continue;
4464       }
4465
4466     /* Set a flag indicating whether there are further addresses that list
4467     the continued host. This tells the transport to leave the channel open,
4468     but not to pass it to another delivery process. */
4469
4470     for (next = addr_remote; next; next = next->next)
4471       {
4472       host_item *h;
4473       for (h = next->host_list; h; h = h->next)
4474         if (Ustrcmp(h->name, continue_hostname) == 0)
4475           { continue_more = TRUE; break; }
4476       }
4477     }
4478
4479   /* The transports set up the process info themselves as they may connect
4480   to more than one remote machine. They also have to set up the filter
4481   arguments, if required, so that the host name and address are available
4482   for expansion. */
4483
4484   transport_filter_argv = NULL;
4485
4486   /* Create the pipe for inter-process communication. If pipe creation
4487   fails, it is probably because the value of remote_max_parallel is so
4488   large that too many file descriptors for pipes have been created. Arrange
4489   to wait for a process to finish, and then try again. If we still can't
4490   create a pipe when all processes have finished, break the retry loop. */
4491
4492   while (!pipe_done)
4493     {
4494     if (pipe(pfd) == 0) pipe_done = TRUE;
4495       else if (parcount > 0) parmax = parcount;
4496         else break;
4497
4498     /* We need to make the reading end of the pipe non-blocking. There are
4499     two different options for this. Exim is cunningly (I hope!) coded so
4500     that it can use either of them, though it prefers O_NONBLOCK, which
4501     distinguishes between EOF and no-more-data. */
4502
4503 #ifdef O_NONBLOCK
4504     (void)fcntl(pfd[pipe_read], F_SETFL, O_NONBLOCK);
4505 #else
4506     (void)fcntl(pfd[pipe_read], F_SETFL, O_NDELAY);
4507 #endif
4508
4509     /* If the maximum number of subprocesses already exist, wait for a process
4510     to finish. If we ran out of file descriptors, parmax will have been reduced
4511     from its initial value of remote_max_parallel. */
4512
4513     par_reduce(parmax - 1, fallback);
4514     }
4515
4516   /* If we failed to create a pipe and there were no processes to wait
4517   for, we have to give up on this one. Do this outside the above loop
4518   so that we can continue the main loop. */
4519
4520   if (!pipe_done)
4521     {
4522     panicmsg = string_sprintf("unable to create pipe: %s", strerror(errno));
4523     goto enq_continue;
4524     }
4525
4526   /* Find a free slot in the pardata list. Must do this after the possible
4527   waiting for processes to finish, because a terminating process will free
4528   up a slot. */
4529
4530   for (poffset = 0; poffset < remote_max_parallel; poffset++)
4531     if (parlist[poffset].pid == 0)
4532       break;
4533
4534   /* If there isn't one, there has been a horrible disaster. */
4535
4536   if (poffset >= remote_max_parallel)
4537     {
4538     (void)close(pfd[pipe_write]);
4539     (void)close(pfd[pipe_read]);
4540     panicmsg = US"Unexpectedly no free subprocess slot";
4541     goto enq_continue;
4542     }
4543
4544   /* Now fork a subprocess to do the remote delivery, but before doing so,
4545   ensure that any cached resourses are released so as not to interfere with
4546   what happens in the subprocess. */
4547
4548   search_tidyup();
4549
4550   if ((pid = fork()) == 0)
4551     {
4552     int fd = pfd[pipe_write];
4553     host_item *h;
4554
4555     /* Setting this global in the subprocess means we need never clear it */
4556     transport_name = tp->name;
4557
4558     /* There are weird circumstances in which logging is disabled */
4559     disable_logging = tp->disable_logging;
4560
4561     /* Show pids on debug output if parallelism possible */
4562
4563     if (parmax > 1 && (parcount > 0 || addr_remote))
4564       {
4565       DEBUG(D_any|D_v) debug_selector |= D_pid;
4566       DEBUG(D_deliver) debug_printf("Remote delivery process started\n");
4567       }
4568
4569     /* Reset the random number generator, so different processes don't all
4570     have the same sequence. In the test harness we want different, but
4571     predictable settings for each delivery process, so do something explicit
4572     here rather they rely on the fixed reset in the random number function. */
4573
4574     random_seed = running_in_test_harness? 42 + 2*delivery_count : 0;
4575
4576     /* Set close-on-exec on the pipe so that it doesn't get passed on to
4577     a new process that may be forked to do another delivery down the same
4578     SMTP connection. */
4579
4580     (void)fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC);
4581
4582     /* Close open file descriptors for the pipes of other processes
4583     that are running in parallel. */
4584
4585     for (poffset = 0; poffset < remote_max_parallel; poffset++)
4586       if (parlist[poffset].pid != 0) (void)close(parlist[poffset].fd);
4587
4588     /* This process has inherited a copy of the file descriptor
4589     for the data file, but its file pointer is shared with all the
4590     other processes running in parallel. Therefore, we have to re-open
4591     the file in order to get a new file descriptor with its own
4592     file pointer. We don't need to lock it, as the lock is held by
4593     the parent process. There doesn't seem to be any way of doing
4594     a dup-with-new-file-pointer. */
4595
4596     (void)close(deliver_datafile);
4597     {
4598     uschar * fname = spool_fname(US"input", message_subdir, message_id, US"-D");
4599
4600     if ((deliver_datafile = Uopen(fname, O_RDWR | O_APPEND, 0)) < 0)
4601       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to reopen %s for remote "
4602         "parallel delivery: %s", fname, strerror(errno));
4603     }
4604
4605     /* Set the close-on-exec flag */
4606
4607     (void)fcntl(deliver_datafile, F_SETFD, fcntl(deliver_datafile, F_GETFD) |
4608       FD_CLOEXEC);
4609
4610     /* Set the uid/gid of this process; bombs out on failure. */
4611
4612     exim_setugid(uid, gid, use_initgroups,
4613       string_sprintf("remote delivery to %s with transport=%s",
4614         addr->address, tp->name));
4615
4616     /* Close the unwanted half of this process' pipe, set the process state,
4617     and run the transport. Afterwards, transport_count will contain the number
4618     of bytes written. */
4619
4620     (void)close(pfd[pipe_read]);
4621     set_process_info("delivering %s using %s", message_id, tp->name);
4622     debug_print_string(tp->debug_string);
4623     if (!(tp->info->code)(addr->transport, addr)) replicate_status(addr);
4624
4625     set_process_info("delivering %s (just run %s for %s%s in subprocess)",
4626       message_id, tp->name, addr->address, addr->next ? ", ..." : "");
4627
4628     /* Ensure any cached resources that we used are now released */
4629
4630     search_tidyup();
4631
4632     /* Pass the result back down the pipe. This is a lot more information
4633     than is needed for a local delivery. We have to send back the error
4634     status for each address, the usability status for each host that is
4635     flagged as unusable, and all the retry items. When TLS is in use, we
4636     send also the cipher and peerdn information. Each type of information
4637     is flagged by an identifying byte, and is then in a fixed format (with
4638     strings terminated by zeros), and there is a final terminator at the
4639     end. The host information and retry information is all attached to
4640     the first address, so that gets sent at the start. */
4641
4642     /* Host unusability information: for most success cases this will
4643     be null. */
4644
4645     for (h = addr->host_list; h; h = h->next)
4646       {
4647       if (!h->address || h->status < hstatus_unusable) continue;
4648       sprintf(CS big_buffer, "%c%c%s", h->status, h->why, h->address);
4649       rmt_dlv_checked_write(fd, 'H', '0', big_buffer, Ustrlen(big_buffer+2) + 3);
4650       }
4651
4652     /* The number of bytes written. This is the same for each address. Even
4653     if we sent several copies of the message down the same connection, the
4654     size of each one is the same, and it's that value we have got because
4655     transport_count gets reset before calling transport_write_message(). */
4656
4657     memcpy(big_buffer, &transport_count, sizeof(transport_count));
4658     rmt_dlv_checked_write(fd, 'S', '0', big_buffer, sizeof(transport_count));
4659
4660     /* Information about what happened to each address. Four item types are
4661     used: an optional 'X' item first, for TLS information, then an optional "C"
4662     item for any client-auth info followed by 'R' items for any retry settings,
4663     and finally an 'A' item for the remaining data. */
4664
4665     for(; addr; addr = addr->next)
4666       {
4667       uschar *ptr;
4668       retry_item *r;
4669
4670       /* The certificate verification status goes into the flags */
4671       if (tls_out.certificate_verified) setflag(addr, af_cert_verified);
4672 #ifdef EXPERIMENTAL_DANE
4673       if (tls_out.dane_verified)        setflag(addr, af_dane_verified);
4674 #endif
4675
4676       /* Use an X item only if there's something to send */
4677 #ifdef SUPPORT_TLS
4678       if (addr->cipher)
4679         {
4680         ptr = big_buffer + sprintf(CS big_buffer, "%.128s", addr->cipher) + 1;
4681         if (!addr->peerdn)
4682           *ptr++ = 0;
4683         else
4684           {
4685           ptr += sprintf(CS ptr, "%.512s", addr->peerdn);
4686           ptr++;
4687           }
4688
4689         rmt_dlv_checked_write(fd, 'X', '1', big_buffer, ptr - big_buffer);
4690         }
4691       if (addr->peercert)
4692         {
4693         ptr = big_buffer;
4694         if (!tls_export_cert(ptr, big_buffer_size-2, addr->peercert))
4695           while(*ptr++);
4696         else
4697           *ptr++ = 0;
4698         rmt_dlv_checked_write(fd, 'X', '2', big_buffer, ptr - big_buffer);
4699         }
4700       if (addr->ourcert)
4701         {
4702         ptr = big_buffer;
4703         if (!tls_export_cert(ptr, big_buffer_size-2, addr->ourcert))
4704           while(*ptr++);
4705         else
4706           *ptr++ = 0;
4707         rmt_dlv_checked_write(fd, 'X', '3', big_buffer, ptr - big_buffer);
4708         }
4709 # ifndef DISABLE_OCSP
4710       if (addr->ocsp > OCSP_NOT_REQ)
4711         {
4712         ptr = big_buffer + sprintf(CS big_buffer, "%c", addr->ocsp + '0') + 1;
4713         rmt_dlv_checked_write(fd, 'X', '4', big_buffer, ptr - big_buffer);
4714         }
4715 # endif
4716 #endif  /*SUPPORT_TLS*/
4717
4718       if (client_authenticator)
4719         {
4720         ptr = big_buffer + sprintf(CS big_buffer, "%.64s", client_authenticator) + 1;
4721         rmt_dlv_checked_write(fd, 'C', '1', big_buffer, ptr - big_buffer);
4722         }
4723       if (client_authenticated_id)
4724         {
4725         ptr = big_buffer + sprintf(CS big_buffer, "%.64s", client_authenticated_id) + 1;
4726         rmt_dlv_checked_write(fd, 'C', '2', big_buffer, ptr - big_buffer);
4727         }
4728       if (client_authenticated_sender)
4729         {
4730         ptr = big_buffer + sprintf(CS big_buffer, "%.64s", client_authenticated_sender) + 1;
4731         rmt_dlv_checked_write(fd, 'C', '3', big_buffer, ptr - big_buffer);
4732         }
4733
4734 #ifndef DISABLE_PRDR
4735       if (addr->flags & af_prdr_used)
4736         rmt_dlv_checked_write(fd, 'P', '0', NULL, 0);
4737 #endif
4738
4739       if (addr->flags & af_chunking_used)
4740         rmt_dlv_checked_write(fd, 'K', '0', NULL, 0);
4741
4742       memcpy(big_buffer, &addr->dsn_aware, sizeof(addr->dsn_aware));
4743       rmt_dlv_checked_write(fd, 'D', '0', big_buffer, sizeof(addr->dsn_aware));
4744       DEBUG(D_deliver) debug_printf("DSN write: addr->dsn_aware = %d\n", addr->dsn_aware);
4745
4746       /* Retry information: for most success cases this will be null. */
4747
4748       for (r = addr->retries; r; r = r->next)
4749         {
4750         sprintf(CS big_buffer, "%c%.500s", r->flags, r->key);
4751         ptr = big_buffer + Ustrlen(big_buffer+2) + 3;
4752         memcpy(ptr, &(r->basic_errno), sizeof(r->basic_errno));
4753         ptr += sizeof(r->basic_errno);
4754         memcpy(ptr, &(r->more_errno), sizeof(r->more_errno));
4755         ptr += sizeof(r->more_errno);
4756         if (!r->message) *ptr++ = 0; else
4757           {
4758           sprintf(CS ptr, "%.512s", r->message);
4759           while(*ptr++);
4760           }
4761         rmt_dlv_checked_write(fd, 'R', '0', big_buffer, ptr - big_buffer);
4762         }
4763
4764 #ifdef SUPPORT_SOCKS
4765       if (LOGGING(proxy) && proxy_session)
4766         {
4767         ptr = big_buffer;
4768         if (proxy_local_address)
4769           {
4770           DEBUG(D_deliver) debug_printf("proxy_local_address '%s'\n", proxy_local_address);
4771           ptr = big_buffer + sprintf(CS ptr, "%.128s", proxy_local_address) + 1;
4772           DEBUG(D_deliver) debug_printf("proxy_local_port %d\n", proxy_local_port);
4773           memcpy(ptr, &proxy_local_port, sizeof(proxy_local_port));
4774           ptr += sizeof(proxy_local_port);
4775           }
4776         else
4777           *ptr++ = '\0';
4778         rmt_dlv_checked_write(fd, 'A', '2', big_buffer, ptr - big_buffer);
4779         }
4780 #endif
4781
4782 #ifdef EXPERIMENTAL_DSN_INFO
4783 /*um, are they really per-addr?  Other per-conn stuff is not (auth, tls).  But host_used is! */
4784       if (addr->smtp_greeting)
4785         {
4786         DEBUG(D_deliver) debug_printf("smtp_greeting '%s'\n", addr->smtp_greeting);
4787         ptr = big_buffer + sprintf(CS big_buffer, "%.128s", addr->smtp_greeting) + 1;
4788         if (addr->helo_response)
4789           {
4790           DEBUG(D_deliver) debug_printf("helo_response '%s'\n", addr->helo_response);
4791           ptr += sprintf(CS ptr, "%.128s", addr->helo_response) + 1;
4792           }
4793         else
4794           *ptr++ = '\0';
4795         rmt_dlv_checked_write(fd, 'A', '1', big_buffer, ptr - big_buffer);
4796         }
4797 #endif
4798
4799       /* The rest of the information goes in an 'A0' item. */
4800
4801       sprintf(CS big_buffer, "%c%c", addr->transport_return, addr->special_action);
4802       ptr = big_buffer + 2;
4803       memcpy(ptr, &(addr->basic_errno), sizeof(addr->basic_errno));
4804       ptr += sizeof(addr->basic_errno);
4805       memcpy(ptr, &(addr->more_errno), sizeof(addr->more_errno));
4806       ptr += sizeof(addr->more_errno);
4807       memcpy(ptr, &(addr->flags), sizeof(addr->flags));
4808       ptr += sizeof(addr->flags);
4809
4810       if (!addr->message) *ptr++ = 0; else
4811         ptr += sprintf(CS ptr, "%.1024s", addr->message) + 1;
4812
4813       if (!addr->user_message) *ptr++ = 0; else
4814         ptr += sprintf(CS ptr, "%.1024s", addr->user_message) + 1;
4815
4816       if (!addr->host_used) *ptr++ = 0; else
4817         {
4818         ptr += sprintf(CS ptr, "%.256s", addr->host_used->name) + 1;
4819         ptr += sprintf(CS ptr, "%.64s", addr->host_used->address) + 1;
4820         memcpy(ptr, &(addr->host_used->port), sizeof(addr->host_used->port));
4821         ptr += sizeof(addr->host_used->port);
4822
4823         /* DNS lookup status */
4824         *ptr++ = addr->host_used->dnssec==DS_YES ? '2'
4825                : addr->host_used->dnssec==DS_NO ? '1' : '0';
4826
4827         }
4828       rmt_dlv_checked_write(fd, 'A', '0', big_buffer, ptr - big_buffer);
4829       }
4830
4831     /* Local interface address/port */
4832 #ifdef EXPERIMENTAL_DSN_INFO
4833     if (sending_ip_address)
4834 #else
4835     if (LOGGING(incoming_interface) && sending_ip_address)
4836 #endif
4837       {
4838       uschar * ptr;
4839       ptr = big_buffer + sprintf(CS big_buffer, "%.128s", sending_ip_address) + 1;
4840       ptr += sprintf(CS ptr, "%d", sending_port) + 1;
4841       rmt_dlv_checked_write(fd, 'I', '0', big_buffer, ptr - big_buffer);
4842       }
4843
4844     /* Add termination flag, close the pipe, and that's it. The character
4845     after 'Z' indicates whether continue_transport is now NULL or not.
4846     A change from non-NULL to NULL indicates a problem with a continuing
4847     connection. */
4848
4849     big_buffer[0] = continue_transport ? '1' : '0';
4850     rmt_dlv_checked_write(fd, 'Z', '0', big_buffer, 1);
4851     (void)close(fd);
4852     exit(EXIT_SUCCESS);
4853     }
4854
4855   /* Back in the mainline: close the unwanted half of the pipe. */
4856
4857   (void)close(pfd[pipe_write]);
4858
4859   /* Fork failed; defer with error message */
4860
4861   if (pid < 0)
4862     {
4863     (void)close(pfd[pipe_read]);
4864     panicmsg = string_sprintf("fork failed for remote delivery to %s: %s",
4865         addr->domain, strerror(errno));
4866     goto enq_continue;
4867     }
4868
4869   /* Fork succeeded; increment the count, and remember relevant data for
4870   when the process finishes. */
4871
4872   parcount++;
4873   parlist[poffset].addrlist = parlist[poffset].addr = addr;
4874   parlist[poffset].pid = pid;
4875   parlist[poffset].fd = pfd[pipe_read];
4876   parlist[poffset].done = FALSE;
4877   parlist[poffset].msg = NULL;
4878   parlist[poffset].return_path = return_path;
4879
4880   /* If the process we've just started is sending a message down an existing
4881   channel, wait for it now. This ensures that only one such process runs at
4882   once, whatever the value of remote_max parallel. Otherwise, we might try to
4883   send two or more messages simultaneously down the same channel. This could
4884   happen if there are different domains that include the same host in otherwise
4885   different host lists.
4886
4887   Also, if the transport closes down the channel, this information gets back
4888   (continue_transport gets set to NULL) before we consider any other addresses
4889   in this message. */
4890
4891   if (continue_transport) par_reduce(0, fallback);
4892
4893   /* Otherwise, if we are running in the test harness, wait a bit, to let the
4894   newly created process get going before we create another process. This should
4895   ensure repeatability in the tests. We only need to wait a tad. */
4896
4897   else if (running_in_test_harness) millisleep(500);
4898
4899   continue;
4900
4901 enq_continue:
4902   if (serialize_key) enq_end(serialize_key);
4903 panic_continue:
4904   remote_post_process(addr, LOG_MAIN|LOG_PANIC, panicmsg, fallback);
4905   continue;
4906   }
4907
4908 /* Reached the end of the list of addresses. Wait for all the subprocesses that
4909 are still running and post-process their addresses. */
4910
4911 par_reduce(0, fallback);
4912 return TRUE;
4913 }
4914
4915
4916
4917
4918 /*************************************************
4919 *   Split an address into local part and domain  *
4920 *************************************************/
4921
4922 /* This function initializes an address for routing by splitting it up into a
4923 local part and a domain. The local part is set up twice - once in its original
4924 casing, and once in lower case, and it is dequoted. We also do the "percent
4925 hack" for configured domains. This may lead to a DEFER result if a lookup
4926 defers. When a percent-hacking takes place, we insert a copy of the original
4927 address as a new parent of this address, as if we have had a redirection.
4928
4929 Argument:
4930   addr      points to an addr_item block containing the address
4931
4932 Returns:    OK
4933             DEFER   - could not determine if domain is %-hackable
4934 */
4935
4936 int
4937 deliver_split_address(address_item * addr)
4938 {
4939 uschar * address = addr->address;
4940 uschar * domain;
4941 uschar * t;
4942 int len;
4943
4944 if (!(domain = Ustrrchr(address, '@')))
4945   return DEFER;         /* should always have a domain, but just in case... */
4946
4947 len = domain - address;
4948 addr->domain = string_copylc(domain+1);    /* Domains are always caseless */
4949
4950 /* The implication in the RFCs (though I can't say I've seen it spelled out
4951 explicitly) is that quoting should be removed from local parts at the point
4952 where they are locally interpreted. [The new draft "821" is more explicit on
4953 this, Jan 1999.] We know the syntax is valid, so this can be done by simply
4954 removing quoting backslashes and any unquoted doublequotes. */
4955
4956 t = addr->cc_local_part = store_get(len+1);
4957 while(len-- > 0)
4958   {
4959   int c = *address++;
4960   if (c == '\"') continue;
4961   if (c == '\\')
4962     {
4963     *t++ = *address++;
4964     len--;
4965     }
4966   else *t++ = c;
4967   }
4968 *t = 0;
4969
4970 /* We do the percent hack only for those domains that are listed in
4971 percent_hack_domains. A loop is required, to copy with multiple %-hacks. */
4972
4973 if (percent_hack_domains)
4974   {
4975   int rc;
4976   uschar *new_address = NULL;
4977   uschar *local_part = addr->cc_local_part;
4978
4979   deliver_domain = addr->domain;  /* set $domain */
4980
4981   while (  (rc = match_isinlist(deliver_domain, (const uschar **)&percent_hack_domains, 0,
4982                &domainlist_anchor, addr->domain_cache, MCL_DOMAIN, TRUE, NULL))
4983              == OK
4984         && (t = Ustrrchr(local_part, '%')) != NULL
4985         )
4986     {
4987     new_address = string_copy(local_part);
4988     new_address[t - local_part] = '@';
4989     deliver_domain = string_copylc(t+1);
4990     local_part = string_copyn(local_part, t - local_part);
4991     }
4992
4993   if (rc == DEFER) return DEFER;   /* lookup deferred */
4994
4995   /* If hackery happened, set up new parent and alter the current address. */
4996
4997   if (new_address)
4998     {
4999     address_item *new_parent = store_get(sizeof(address_item));
5000     *new_parent = *addr;
5001     addr->parent = new_parent;
5002     addr->address = new_address;
5003     addr->unique = string_copy(new_address);
5004     addr->domain = deliver_domain;
5005     addr->cc_local_part = local_part;
5006     DEBUG(D_deliver) debug_printf("%%-hack changed address to: %s\n",
5007       addr->address);
5008     }
5009   }
5010
5011 /* Create the lowercased version of the final local part, and make that the
5012 default one to be used. */
5013
5014 addr->local_part = addr->lc_local_part = string_copylc(addr->cc_local_part);
5015 return OK;
5016 }
5017
5018
5019
5020
5021 /*************************************************
5022 *      Get next error message text               *
5023 *************************************************/
5024
5025 /* If f is not NULL, read the next "paragraph", from a customized error message
5026 text file, terminated by a line containing ****, and expand it.
5027
5028 Arguments:
5029   f          NULL or a file to read from
5030   which      string indicating which string (for errors)
5031
5032 Returns:     NULL or an expanded string
5033 */
5034
5035 static uschar *
5036 next_emf(FILE *f, uschar *which)
5037 {
5038 int size = 256;
5039 int ptr = 0;
5040 uschar *para, *yield;
5041 uschar buffer[256];
5042
5043 if (!f) return NULL;
5044
5045 if (!Ufgets(buffer, sizeof(buffer), f) || Ustrcmp(buffer, "****\n") == 0)
5046   return NULL;
5047
5048 para = store_get(size);
5049 for (;;)
5050   {
5051   para = string_cat(para, &size, &ptr, buffer);
5052   if (!Ufgets(buffer, sizeof(buffer), f) || Ustrcmp(buffer, "****\n") == 0)
5053     break;
5054   }
5055 para[ptr] = 0;
5056
5057 if ((yield = expand_string(para)))
5058   return yield;
5059
5060 log_write(0, LOG_MAIN|LOG_PANIC, "Failed to expand string from "
5061   "bounce_message_file or warn_message_file (%s): %s", which,
5062   expand_string_message);
5063 return NULL;
5064 }
5065
5066
5067
5068
5069 /*************************************************
5070 *      Close down a passed transport channel     *
5071 *************************************************/
5072
5073 /* This function is called when a passed transport channel cannot be used.
5074 It attempts to close it down tidily. The yield is always DELIVER_NOT_ATTEMPTED
5075 so that the function call can be the argument of a "return" statement.
5076
5077 Arguments:  None
5078 Returns:    DELIVER_NOT_ATTEMPTED
5079 */
5080
5081 static int
5082 continue_closedown(void)
5083 {
5084 if (continue_transport)
5085   {
5086   transport_instance *t;
5087   for (t = transports; t; t = t->next)
5088     if (Ustrcmp(t->name, continue_transport) == 0)
5089       {
5090       if (t->info->closedown) (t->info->closedown)(t);
5091       break;
5092       }
5093   }
5094 return DELIVER_NOT_ATTEMPTED;
5095 }
5096
5097
5098
5099
5100 /*************************************************
5101 *           Print address information            *
5102 *************************************************/
5103
5104 /* This function is called to output an address, or information about an
5105 address, for bounce or defer messages. If the hide_child flag is set, all we
5106 output is the original ancestor address.
5107
5108 Arguments:
5109   addr         points to the address
5110   f            the FILE to print to
5111   si           an initial string
5112   sc           a continuation string for before "generated"
5113   se           an end string
5114
5115 Returns:       TRUE if the address is not hidden
5116 */
5117
5118 static BOOL
5119 print_address_information(address_item *addr, FILE *f, uschar *si, uschar *sc,
5120   uschar *se)
5121 {
5122 BOOL yield = TRUE;
5123 uschar *printed = US"";
5124 address_item *ancestor = addr;
5125 while (ancestor->parent) ancestor = ancestor->parent;
5126
5127 fprintf(f, "%s", CS si);
5128
5129 if (addr->parent && testflag(addr, af_hide_child))
5130   {
5131   printed = US"an undisclosed address";
5132   yield = FALSE;
5133   }
5134 else if (!testflag(addr, af_pfr) || !addr->parent)
5135   printed = addr->address;
5136
5137 else
5138   {
5139   uschar *s = addr->address;
5140   uschar *ss;
5141
5142   if (addr->address[0] == '>') { ss = US"mail"; s++; }
5143   else if (addr->address[0] == '|') ss = US"pipe";
5144   else ss = US"save";
5145
5146   fprintf(f, "%s to %s%sgenerated by ", ss, s, sc);
5147   printed = addr->parent->address;
5148   }
5149
5150 fprintf(f, "%s", CS string_printing(printed));
5151
5152 if (ancestor != addr)
5153   {
5154   uschar *original = ancestor->onetime_parent;
5155   if (!original) original= ancestor->address;
5156   if (strcmpic(original, printed) != 0)
5157     fprintf(f, "%s(%sgenerated from %s)", sc,
5158       ancestor != addr->parent ? "ultimately " : "",
5159       string_printing(original));
5160   }
5161
5162 if (addr->host_used)
5163   fprintf(f, "\n    host %s [%s]",
5164           addr->host_used->name, addr->host_used->address);
5165
5166 fprintf(f, "%s", CS se);
5167 return yield;
5168 }
5169
5170
5171
5172
5173
5174 /*************************************************
5175 *         Print error for an address             *
5176 *************************************************/
5177
5178 /* This function is called to print the error information out of an address for
5179 a bounce or a warning message. It tries to format the message reasonably by
5180 introducing newlines. All lines are indented by 4; the initial printing
5181 position must be set before calling.
5182
5183 This function used always to print the error. Nowadays we want to restrict it
5184 to cases such as LMTP/SMTP errors from a remote host, and errors from :fail:
5185 and filter "fail". We no longer pass other information willy-nilly in bounce
5186 and warning messages. Text in user_message is always output; text in message
5187 only if the af_pass_message flag is set.
5188
5189 Arguments:
5190   addr         the address
5191   f            the FILE to print on
5192   t            some leading text
5193
5194 Returns:       nothing
5195 */
5196
5197 static void
5198 print_address_error(address_item *addr, FILE *f, uschar *t)
5199 {
5200 int count = Ustrlen(t);
5201 uschar *s = testflag(addr, af_pass_message)? addr->message : NULL;
5202
5203 if (!s && !(s = addr->user_message))
5204   return;
5205
5206 fprintf(f, "\n    %s", t);
5207
5208 while (*s)
5209   if (*s == '\\' && s[1] == 'n')
5210     {
5211     fprintf(f, "\n    ");
5212     s += 2;
5213     count = 0;
5214     }
5215   else
5216     {
5217     fputc(*s, f);
5218     count++;
5219     if (*s++ == ':' && isspace(*s) && count > 45)
5220       {
5221       fprintf(f, "\n   ");  /* sic (because space follows) */
5222       count = 0;
5223       }
5224     }
5225 }
5226
5227
5228 /***********************************************************
5229 *         Print Diagnostic-Code for an address             *
5230 ************************************************************/
5231
5232 /* This function is called to print the error information out of an address for
5233 a bounce or a warning message. It tries to format the message reasonably as
5234 required by RFC 3461 by adding a space after each newline
5235
5236 it uses the same logic as print_address_error() above. if af_pass_message is true
5237 and addr->message is set it uses the remote host answer. if not addr->user_message
5238 is used instead if available.
5239
5240 Arguments:
5241   addr         the address
5242   f            the FILE to print on
5243
5244 Returns:       nothing
5245 */
5246
5247 static void
5248 print_dsn_diagnostic_code(const address_item *addr, FILE *f)
5249 {
5250 uschar *s = testflag(addr, af_pass_message) ? addr->message : NULL;
5251
5252 /* af_pass_message and addr->message set ? print remote host answer */
5253 if (s)
5254   {
5255   DEBUG(D_deliver)
5256     debug_printf("DSN Diagnostic-Code: addr->message = %s\n", addr->message);
5257
5258   /* search first ": ". we assume to find the remote-MTA answer there */
5259   if (!(s = Ustrstr(addr->message, ": ")))
5260     return;                             /* not found, bail out */
5261   s += 2;  /* skip ": " */
5262   fprintf(f, "Diagnostic-Code: smtp; ");
5263   }
5264 /* no message available. do nothing */
5265 else return;
5266
5267 while (*s)
5268   if (*s == '\\' && s[1] == 'n')
5269     {
5270     fputs("\n ", f);    /* as defined in RFC 3461 */
5271     s += 2;
5272     }
5273   else
5274     fputc(*s++, f);
5275
5276 fputc('\n', f);
5277 }
5278
5279
5280 /*************************************************
5281 *     Check list of addresses for duplication    *
5282 *************************************************/
5283
5284 /* This function was introduced when the test for duplicate addresses that are
5285 not pipes, files, or autoreplies was moved from the middle of routing to when
5286 routing was complete. That was to fix obscure cases when the routing history
5287 affects the subsequent routing of identical addresses. This function is called
5288 after routing, to check that the final routed addresses are not duplicates.
5289
5290 If we detect a duplicate, we remember what it is a duplicate of. Note that
5291 pipe, file, and autoreply de-duplication is handled during routing, so we must
5292 leave such "addresses" alone here, as otherwise they will incorrectly be
5293 discarded.
5294
5295 Argument:     address of list anchor
5296 Returns:      nothing
5297 */
5298
5299 static void
5300 do_duplicate_check(address_item **anchor)
5301 {
5302 address_item *addr;
5303 while ((addr = *anchor))
5304   {
5305   tree_node *tnode;
5306   if (testflag(addr, af_pfr))
5307     {
5308     anchor = &(addr->next);
5309     }
5310   else if ((tnode = tree_search(tree_duplicates, addr->unique)))
5311     {
5312     DEBUG(D_deliver|D_route)
5313       debug_printf("%s is a duplicate address: discarded\n", addr->unique);
5314     *anchor = addr->next;
5315     addr->dupof = tnode->data.ptr;
5316     addr->next = addr_duplicate;
5317     addr_duplicate = addr;
5318     }
5319   else
5320     {
5321     tree_add_duplicate(addr->unique, addr);
5322     anchor = &(addr->next);
5323     }
5324   }
5325 }
5326
5327
5328
5329
5330 /*************************************************
5331 *              Deliver one message               *
5332 *************************************************/
5333
5334 /* This is the function which is called when a message is to be delivered. It
5335 is passed the id of the message. It is possible that the message no longer
5336 exists, if some other process has delivered it, and it is also possible that
5337 the message is being worked on by another process, in which case the data file
5338 will be locked.
5339
5340 If no delivery is attempted for any of the above reasons, the function returns
5341 DELIVER_NOT_ATTEMPTED.
5342
5343 If the give_up flag is set true, do not attempt any deliveries, but instead
5344 fail all outstanding addresses and return the message to the sender (or
5345 whoever).
5346
5347 A delivery operation has a process all to itself; we never deliver more than
5348 one message in the same process. Therefore we needn't worry too much about
5349 store leakage.
5350
5351 Arguments:
5352   id          the id of the message to be delivered
5353   forced      TRUE if delivery was forced by an administrator; this overrides
5354               retry delays and causes a delivery to be tried regardless
5355   give_up     TRUE if an administrator has requested that delivery attempts
5356               be abandoned
5357
5358 Returns:      When the global variable mua_wrapper is FALSE:
5359                 DELIVER_ATTEMPTED_NORMAL   if a delivery attempt was made
5360                 DELIVER_NOT_ATTEMPTED      otherwise (see comment above)
5361               When the global variable mua_wrapper is TRUE:
5362                 DELIVER_MUA_SUCCEEDED      if delivery succeeded
5363                 DELIVER_MUA_FAILED         if delivery failed
5364                 DELIVER_NOT_ATTEMPTED      if not attempted (should not occur)
5365 */
5366
5367 int
5368 deliver_message(uschar *id, BOOL forced, BOOL give_up)
5369 {
5370 int i, rc;
5371 int final_yield = DELIVER_ATTEMPTED_NORMAL;
5372 time_t now = time(NULL);
5373 address_item *addr_last = NULL;
5374 uschar *filter_message = NULL;
5375 FILE *jread;
5376 int process_recipients = RECIP_ACCEPT;
5377 open_db dbblock;
5378 open_db *dbm_file;
5379 extern int acl_where;
5380
5381 uschar *info = queue_run_pid == (pid_t)0
5382   ? string_sprintf("delivering %s", id)
5383   : string_sprintf("delivering %s (queue run pid %d)", id, queue_run_pid);
5384
5385 /* If the D_process_info bit is on, set_process_info() will output debugging
5386 information. If not, we want to show this initial information if D_deliver or
5387 D_queue_run is set or in verbose mode. */
5388
5389 set_process_info("%s", info);
5390
5391 if (  !(debug_selector & D_process_info)
5392    && (debug_selector & (D_deliver|D_queue_run|D_v))
5393    )
5394   debug_printf("%s\n", info);
5395
5396 /* Ensure that we catch any subprocesses that are created. Although Exim
5397 sets SIG_DFL as its initial default, some routes through the code end up
5398 here with it set to SIG_IGN - cases where a non-synchronous delivery process
5399 has been forked, but no re-exec has been done. We use sigaction rather than
5400 plain signal() on those OS where SA_NOCLDWAIT exists, because we want to be
5401 sure it is turned off. (There was a problem on AIX with this.) */
5402
5403 #ifdef SA_NOCLDWAIT
5404   {
5405   struct sigaction act;
5406   act.sa_handler = SIG_DFL;
5407   sigemptyset(&(act.sa_mask));
5408   act.sa_flags = 0;
5409   sigaction(SIGCHLD, &act, NULL);
5410   }
5411 #else
5412 signal(SIGCHLD, SIG_DFL);
5413 #endif
5414
5415 /* Make the forcing flag available for routers and transports, set up the
5416 global message id field, and initialize the count for returned files and the
5417 message size. This use of strcpy() is OK because the length id is checked when
5418 it is obtained from a command line (the -M or -q options), and otherwise it is
5419 known to be a valid message id. */
5420
5421 Ustrcpy(message_id, id);
5422 deliver_force = forced;
5423 return_count = 0;
5424 message_size = 0;
5425
5426 /* Initialize some flags */
5427
5428 update_spool = FALSE;
5429 remove_journal = TRUE;
5430
5431 /* Set a known context for any ACLs we call via expansions */
5432 acl_where = ACL_WHERE_DELIVERY;
5433
5434 /* Reset the random number generator, so that if several delivery processes are
5435 started from a queue runner that has already used random numbers (for sorting),
5436 they don't all get the same sequence. */
5437
5438 random_seed = 0;
5439
5440 /* Open and lock the message's data file. Exim locks on this one because the
5441 header file may get replaced as it is re-written during the delivery process.
5442 Any failures cause messages to be written to the log, except for missing files
5443 while queue running - another process probably completed delivery. As part of
5444 opening the data file, message_subdir gets set. */
5445
5446 if ((deliver_datafile = spool_open_datafile(id)) < 0)
5447   return continue_closedown();  /* yields DELIVER_NOT_ATTEMPTED */
5448
5449 /* The value of message_size at this point has been set to the data length,
5450 plus one for the blank line that notionally precedes the data. */
5451
5452 /* Now read the contents of the header file, which will set up the headers in
5453 store, and also the list of recipients and the tree of non-recipients and
5454 assorted flags. It updates message_size. If there is a reading or format error,
5455 give up; if the message has been around for sufficiently long, remove it. */
5456
5457   {
5458   uschar * spoolname = string_sprintf("%s-H", id);
5459   if ((rc = spool_read_header(spoolname, TRUE, TRUE)) != spool_read_OK)
5460     {
5461     if (errno == ERRNO_SPOOLFORMAT)
5462       {
5463       struct stat statbuf;
5464       if (Ustat(spool_fname(US"input", message_subdir, spoolname, US""),
5465                 &statbuf) == 0)
5466         log_write(0, LOG_MAIN, "Format error in spool file %s: "
5467           "size=" OFF_T_FMT, spoolname, statbuf.st_size);
5468       else
5469         log_write(0, LOG_MAIN, "Format error in spool file %s", spoolname);
5470       }
5471     else
5472       log_write(0, LOG_MAIN, "Error reading spool file %s: %s", spoolname,
5473         strerror(errno));
5474
5475     /* If we managed to read the envelope data, received_time contains the
5476     time the message was received. Otherwise, we can calculate it from the
5477     message id. */
5478
5479     if (rc != spool_read_hdrerror)
5480       {
5481       received_time = 0;
5482       for (i = 0; i < 6; i++)
5483         received_time = received_time * BASE_62 + tab62[id[i] - '0'];
5484       }
5485
5486     /* If we've had this malformed message too long, sling it. */
5487
5488     if (now - received_time > keep_malformed)
5489       {
5490       Uunlink(spool_fname(US"msglog", message_subdir, id, US""));
5491       Uunlink(spool_fname(US"input", message_subdir, id, US"-D"));
5492       Uunlink(spool_fname(US"input", message_subdir, id, US"-H"));
5493       Uunlink(spool_fname(US"input", message_subdir, id, US"-J"));
5494       log_write(0, LOG_MAIN, "Message removed because older than %s",
5495         readconf_printtime(keep_malformed));
5496       }
5497
5498     (void)close(deliver_datafile);
5499     deliver_datafile = -1;
5500     return continue_closedown();   /* yields DELIVER_NOT_ATTEMPTED */
5501     }
5502   }
5503
5504 /* The spool header file has been read. Look to see if there is an existing
5505 journal file for this message. If there is, it means that a previous delivery
5506 attempt crashed (program or host) before it could update the spool header file.
5507 Read the list of delivered addresses from the journal and add them to the
5508 nonrecipients tree. Then update the spool file. We can leave the journal in
5509 existence, as it will get further successful deliveries added to it in this
5510 run, and it will be deleted if this function gets to its end successfully.
5511 Otherwise it might be needed again. */
5512
5513   {
5514   uschar * fname = spool_fname(US"input", message_subdir, id, US"-J");
5515
5516   if ((jread = Ufopen(fname, "rb")))
5517     {
5518     while (Ufgets(big_buffer, big_buffer_size, jread))
5519       {
5520       int n = Ustrlen(big_buffer);
5521       big_buffer[n-1] = 0;
5522       tree_add_nonrecipient(big_buffer);
5523       DEBUG(D_deliver) debug_printf("Previously delivered address %s taken from "
5524         "journal file\n", big_buffer);
5525       }
5526     (void)fclose(jread);
5527     /* Panic-dies on error */
5528     (void)spool_write_header(message_id, SW_DELIVERING, NULL);
5529     }
5530   else if (errno != ENOENT)
5531     {
5532     log_write(0, LOG_MAIN|LOG_PANIC, "attempt to open journal for reading gave: "
5533       "%s", strerror(errno));
5534     return continue_closedown();   /* yields DELIVER_NOT_ATTEMPTED */
5535     }
5536
5537   /* A null recipients list indicates some kind of disaster. */
5538
5539   if (!recipients_list)
5540     {
5541     (void)close(deliver_datafile);
5542     deliver_datafile = -1;
5543     log_write(0, LOG_MAIN, "Spool error: no recipients for %s", fname);
5544     return continue_closedown();   /* yields DELIVER_NOT_ATTEMPTED */
5545     }
5546   }
5547
5548
5549 /* Handle a message that is frozen. There are a number of different things that
5550 can happen, but in the default situation, unless forced, no delivery is
5551 attempted. */
5552
5553 if (deliver_freeze)
5554   {
5555 #ifdef SUPPORT_MOVE_FROZEN_MESSAGES
5556   /* Moving to another directory removes the message from Exim's view. Other
5557   tools must be used to deal with it. Logging of this action happens in
5558   spool_move_message() and its subfunctions. */
5559
5560   if (  move_frozen_messages
5561      && spool_move_message(id, message_subdir, US"", US"F")
5562      )
5563     return continue_closedown();   /* yields DELIVER_NOT_ATTEMPTED */
5564 #endif
5565
5566   /* For all frozen messages (bounces or not), timeout_frozen_after sets the
5567   maximum time to keep messages that are frozen. Thaw if we reach it, with a
5568   flag causing all recipients to be failed. The time is the age of the
5569   message, not the time since freezing. */
5570
5571   if (timeout_frozen_after > 0 && message_age >= timeout_frozen_after)
5572     {
5573     log_write(0, LOG_MAIN, "cancelled by timeout_frozen_after");
5574     process_recipients = RECIP_FAIL_TIMEOUT;
5575     }
5576
5577   /* For bounce messages (and others with no sender), thaw if the error message
5578   ignore timer is exceeded. The message will be discarded if this delivery
5579   fails. */
5580
5581   else if (!*sender_address && message_age >= ignore_bounce_errors_after)
5582     log_write(0, LOG_MAIN, "Unfrozen by errmsg timer");
5583
5584   /* If this is a bounce message, or there's no auto thaw, or we haven't
5585   reached the auto thaw time yet, and this delivery is not forced by an admin
5586   user, do not attempt delivery of this message. Note that forced is set for
5587   continuing messages down the same channel, in order to skip load checking and
5588   ignore hold domains, but we don't want unfreezing in that case. */
5589
5590   else
5591     {
5592     if (  (  sender_address[0] == 0
5593           || auto_thaw <= 0
5594           || now <= deliver_frozen_at + auto_thaw
5595           )
5596        && (  !forced || !deliver_force_thaw
5597           || !admin_user || continue_hostname
5598        )  )
5599       {
5600       (void)close(deliver_datafile);
5601       deliver_datafile = -1;
5602       log_write(L_skip_delivery, LOG_MAIN, "Message is frozen");
5603       return continue_closedown();   /* yields DELIVER_NOT_ATTEMPTED */
5604       }
5605
5606     /* If delivery was forced (by an admin user), assume a manual thaw.
5607     Otherwise it's an auto thaw. */
5608
5609     if (forced)
5610       {
5611       deliver_manual_thaw = TRUE;
5612       log_write(0, LOG_MAIN, "Unfrozen by forced delivery");
5613       }
5614     else log_write(0, LOG_MAIN, "Unfrozen by auto-thaw");
5615     }
5616
5617   /* We get here if any of the rules for unfreezing have triggered. */
5618
5619   deliver_freeze = FALSE;
5620   update_spool = TRUE;
5621   }
5622
5623
5624 /* Open the message log file if we are using them. This records details of
5625 deliveries, deferments, and failures for the benefit of the mail administrator.
5626 The log is not used by exim itself to track the progress of a message; that is
5627 done by rewriting the header spool file. */
5628
5629 if (message_logs)
5630   {
5631   uschar * fname = spool_fname(US"msglog", message_subdir, id, US"");
5632   uschar * error;
5633   int fd;
5634
5635   if ((fd = open_msglog_file(fname, SPOOL_MODE, &error)) < 0)
5636     {
5637     log_write(0, LOG_MAIN|LOG_PANIC, "Couldn't %s message log %s: %s", error,
5638       fname, strerror(errno));
5639     return continue_closedown();   /* yields DELIVER_NOT_ATTEMPTED */
5640     }
5641
5642   /* Make a C stream out of it. */
5643
5644   if (!(message_log = fdopen(fd, "a")))
5645     {
5646     log_write(0, LOG_MAIN|LOG_PANIC, "Couldn't fdopen message log %s: %s",
5647       fname, strerror(errno));
5648     return continue_closedown();   /* yields DELIVER_NOT_ATTEMPTED */
5649     }
5650   }
5651
5652
5653 /* If asked to give up on a message, log who did it, and set the action for all
5654 the addresses. */
5655
5656 if (give_up)
5657   {
5658   struct passwd *pw = getpwuid(real_uid);
5659   log_write(0, LOG_MAIN, "cancelled by %s",
5660       pw ? US pw->pw_name : string_sprintf("uid %ld", (long int)real_uid));
5661   process_recipients = RECIP_FAIL;
5662   }
5663
5664 /* Otherwise, if there are too many Received: headers, fail all recipients. */
5665
5666 else if (received_count > received_headers_max)
5667   process_recipients = RECIP_FAIL_LOOP;
5668
5669 /* Otherwise, if a system-wide, address-independent message filter is
5670 specified, run it now, except in the case when we are failing all recipients as
5671 a result of timeout_frozen_after. If the system filter yields "delivered", then
5672 ignore the true recipients of the message. Failure of the filter file is
5673 logged, and the delivery attempt fails. */
5674
5675 else if (system_filter && process_recipients != RECIP_FAIL_TIMEOUT)
5676   {
5677   int rc;
5678   int filtertype;
5679   ugid_block ugid;
5680   redirect_block redirect;
5681
5682   if (system_filter_uid_set)
5683     {
5684     ugid.uid = system_filter_uid;
5685     ugid.gid = system_filter_gid;
5686     ugid.uid_set = ugid.gid_set = TRUE;
5687     }
5688   else
5689     {
5690     ugid.uid_set = ugid.gid_set = FALSE;
5691     }
5692
5693   return_path = sender_address;
5694   enable_dollar_recipients = TRUE;   /* Permit $recipients in system filter */
5695   system_filtering = TRUE;
5696
5697   /* Any error in the filter file causes a delivery to be abandoned. */
5698
5699   redirect.string = system_filter;
5700   redirect.isfile = TRUE;
5701   redirect.check_owner = redirect.check_group = FALSE;
5702   redirect.owners = NULL;
5703   redirect.owngroups = NULL;
5704   redirect.pw = NULL;
5705   redirect.modemask = 0;
5706
5707   DEBUG(D_deliver|D_filter) debug_printf("running system filter\n");
5708
5709   rc = rda_interpret(
5710     &redirect,              /* Where the data is */
5711     RDO_DEFER |             /* Turn on all the enabling options */
5712       RDO_FAIL |            /* Leave off all the disabling options */
5713       RDO_FILTER |
5714       RDO_FREEZE |
5715       RDO_REALLOG |
5716       RDO_REWRITE,
5717     NULL,                   /* No :include: restriction (not used in filter) */
5718     NULL,                   /* No sieve vacation directory (not sieve!) */
5719     NULL,                   /* No sieve enotify mailto owner (not sieve!) */
5720     NULL,                   /* No sieve user address (not sieve!) */
5721     NULL,                   /* No sieve subaddress (not sieve!) */
5722     &ugid,                  /* uid/gid data */
5723     &addr_new,              /* Where to hang generated addresses */
5724     &filter_message,        /* Where to put error message */
5725     NULL,                   /* Don't skip syntax errors */
5726     &filtertype,            /* Will always be set to FILTER_EXIM for this call */
5727     US"system filter");     /* For error messages */
5728
5729   DEBUG(D_deliver|D_filter) debug_printf("system filter returned %d\n", rc);
5730
5731   if (rc == FF_ERROR || rc == FF_NONEXIST)
5732     {
5733     (void)close(deliver_datafile);
5734     deliver_datafile = -1;
5735     log_write(0, LOG_MAIN|LOG_PANIC, "Error in system filter: %s",
5736       string_printing(filter_message));
5737     return continue_closedown();   /* yields DELIVER_NOT_ATTEMPTED */
5738     }
5739
5740   /* Reset things. If the filter message is an empty string, which can happen
5741   for a filter "fail" or "freeze" command with no text, reset it to NULL. */
5742
5743   system_filtering = FALSE;
5744   enable_dollar_recipients = FALSE;
5745   if (filter_message && filter_message[0] == 0) filter_message = NULL;
5746
5747   /* Save the values of the system filter variables so that user filters
5748   can use them. */
5749
5750   memcpy(filter_sn, filter_n, sizeof(filter_sn));
5751
5752   /* The filter can request that delivery of the original addresses be
5753   deferred. */
5754
5755   if (rc == FF_DEFER)
5756     {
5757     process_recipients = RECIP_DEFER;
5758     deliver_msglog("Delivery deferred by system filter\n");
5759     log_write(0, LOG_MAIN, "Delivery deferred by system filter");
5760     }
5761
5762   /* The filter can request that a message be frozen, but this does not
5763   take place if the message has been manually thawed. In that case, we must
5764   unset "delivered", which is forced by the "freeze" command to make -bF
5765   work properly. */
5766
5767   else if (rc == FF_FREEZE && !deliver_manual_thaw)
5768     {
5769     deliver_freeze = TRUE;
5770     deliver_frozen_at = time(NULL);
5771     process_recipients = RECIP_DEFER;
5772     frozen_info = string_sprintf(" by the system filter%s%s",
5773       filter_message ? US": " : US"",
5774       filter_message ? filter_message : US"");
5775     }
5776
5777   /* The filter can request that a message be failed. The error message may be
5778   quite long - it is sent back to the sender in the bounce - but we don't want
5779   to fill up the log with repetitions of it. If it starts with << then the text
5780   between << and >> is written to the log, with the rest left for the bounce
5781   message. */
5782
5783   else if (rc == FF_FAIL)
5784     {
5785     uschar *colon = US"";
5786     uschar *logmsg = US"";
5787     int loglen = 0;
5788
5789     process_recipients = RECIP_FAIL_FILTER;
5790
5791     if (filter_message)
5792       {
5793       uschar *logend;
5794       colon = US": ";
5795       if (  filter_message[0] == '<'
5796          && filter_message[1] == '<'
5797          && (logend = Ustrstr(filter_message, ">>"))
5798          )
5799         {
5800         logmsg = filter_message + 2;
5801         loglen = logend - logmsg;
5802         filter_message = logend + 2;
5803         if (filter_message[0] == 0) filter_message = NULL;
5804         }
5805       else
5806         {
5807         logmsg = filter_message;
5808         loglen = Ustrlen(filter_message);
5809         }
5810       }
5811
5812     log_write(0, LOG_MAIN, "cancelled by system filter%s%.*s", colon, loglen,
5813       logmsg);
5814     }
5815
5816   /* Delivery can be restricted only to those recipients (if any) that the
5817   filter specified. */
5818
5819   else if (rc == FF_DELIVERED)
5820     {
5821     process_recipients = RECIP_IGNORE;
5822     if (addr_new)
5823       log_write(0, LOG_MAIN, "original recipients ignored (system filter)");
5824     else
5825       log_write(0, LOG_MAIN, "=> discarded (system filter)");
5826     }
5827
5828   /* If any new addresses were created by the filter, fake up a "parent"
5829   for them. This is necessary for pipes, etc., which are expected to have
5830   parents, and it also gives some sensible logging for others. Allow
5831   pipes, files, and autoreplies, and run them as the filter uid if set,
5832   otherwise as the current uid. */
5833
5834   if (addr_new)
5835     {
5836     int uid = (system_filter_uid_set)? system_filter_uid : geteuid();
5837     int gid = (system_filter_gid_set)? system_filter_gid : getegid();
5838
5839     /* The text "system-filter" is tested in transport_set_up_command() and in
5840     set_up_shell_command() in the pipe transport, to enable them to permit
5841     $recipients, so don't change it here without also changing it there. */
5842
5843     address_item *p = addr_new;
5844     address_item *parent = deliver_make_addr(US"system-filter", FALSE);
5845
5846     parent->domain = string_copylc(qualify_domain_recipient);
5847     parent->local_part = US"system-filter";
5848
5849     /* As part of this loop, we arrange for addr_last to end up pointing
5850     at the final address. This is used if we go on to add addresses for the
5851     original recipients. */
5852
5853     while (p)
5854       {
5855       if (parent->child_count == SHRT_MAX)
5856         log_write(0, LOG_MAIN|LOG_PANIC_DIE, "system filter generated more "
5857           "than %d delivery addresses", SHRT_MAX);
5858       parent->child_count++;
5859       p->parent = parent;
5860
5861       if (testflag(p, af_pfr))
5862         {
5863         uschar *tpname;
5864         uschar *type;
5865         p->uid = uid;
5866         p->gid = gid;
5867         setflag(p, af_uid_set |
5868                    af_gid_set |
5869                    af_allow_file |
5870                    af_allow_pipe |
5871                    af_allow_reply);
5872
5873         /* Find the name of the system filter's appropriate pfr transport */
5874
5875         if (p->address[0] == '|')
5876           {
5877           type = US"pipe";
5878           tpname = system_filter_pipe_transport;
5879           address_pipe = p->address;
5880           }
5881         else if (p->address[0] == '>')
5882           {
5883           type = US"reply";
5884           tpname = system_filter_reply_transport;
5885           }
5886         else
5887           {
5888           if (p->address[Ustrlen(p->address)-1] == '/')
5889             {
5890             type = US"directory";
5891             tpname = system_filter_directory_transport;
5892             }
5893           else
5894             {
5895             type = US"file";
5896             tpname = system_filter_file_transport;
5897             }
5898           address_file = p->address;
5899           }
5900
5901         /* Now find the actual transport, first expanding the name. We have
5902         set address_file or address_pipe above. */
5903
5904         if (tpname)
5905           {
5906           uschar *tmp = expand_string(tpname);
5907           address_file = address_pipe = NULL;
5908           if (!tmp)
5909             p->message = string_sprintf("failed to expand \"%s\" as a "
5910               "system filter transport name", tpname);
5911           tpname = tmp;
5912           }
5913         else
5914           {
5915           p->message = string_sprintf("system_filter_%s_transport is unset",
5916             type);
5917           }
5918
5919         if (tpname)
5920           {
5921           transport_instance *tp;
5922           for (tp = transports; tp; tp = tp->next)
5923             {
5924             if (Ustrcmp(tp->name, tpname) == 0)
5925               {
5926               p->transport = tp;
5927               break;
5928               }
5929             }
5930           if (!tp)
5931             p->message = string_sprintf("failed to find \"%s\" transport "
5932               "for system filter delivery", tpname);
5933           }
5934
5935         /* If we couldn't set up a transport, defer the delivery, putting the
5936         error on the panic log as well as the main log. */
5937
5938         if (!p->transport)
5939           {
5940           address_item *badp = p;
5941           p = p->next;
5942           if (!addr_last) addr_new = p; else addr_last->next = p;
5943           badp->local_part = badp->address;   /* Needed for log line */
5944           post_process_one(badp, DEFER, LOG_MAIN|LOG_PANIC, DTYPE_ROUTER, 0);
5945           continue;
5946           }
5947         }    /* End of pfr handling */
5948
5949       /* Either a non-pfr delivery, or we found a transport */
5950
5951       DEBUG(D_deliver|D_filter)
5952         debug_printf("system filter added %s\n", p->address);
5953
5954       addr_last = p;
5955       p = p->next;
5956       }    /* Loop through all addr_new addresses */
5957     }
5958   }
5959
5960
5961 /* Scan the recipients list, and for every one that is not in the non-
5962 recipients tree, add an addr item to the chain of new addresses. If the pno
5963 value is non-negative, we must set the onetime parent from it. This which
5964 points to the relevant entry in the recipients list.
5965
5966 This processing can be altered by the setting of the process_recipients
5967 variable, which is changed if recipients are to be ignored, failed, or
5968 deferred. This can happen as a result of system filter activity, or if the -Mg
5969 option is used to fail all of them.
5970
5971 Duplicate addresses are handled later by a different tree structure; we can't
5972 just extend the non-recipients tree, because that will be re-written to the
5973 spool if the message is deferred, and in any case there are casing
5974 complications for local addresses. */
5975
5976 if (process_recipients != RECIP_IGNORE)
5977   {
5978   for (i = 0; i < recipients_count; i++)
5979     {
5980     if (!tree_search(tree_nonrecipients, recipients_list[i].address))
5981       {
5982       recipient_item *r = recipients_list + i;
5983       address_item *new = deliver_make_addr(r->address, FALSE);
5984       new->prop.errors_address = r->errors_to;
5985 #ifdef SUPPORT_I18N
5986       if ((new->prop.utf8_msg = message_smtputf8))
5987         {
5988         new->prop.utf8_downcvt =       message_utf8_downconvert == 1;
5989         new->prop.utf8_downcvt_maybe = message_utf8_downconvert == -1;
5990         DEBUG(D_deliver) debug_printf("utf8, downconvert %s\n",
5991           new->prop.utf8_downcvt ? "yes"
5992           : new->prop.utf8_downcvt_maybe ? "ifneeded"
5993           : "no");
5994         }
5995 #endif
5996
5997       if (r->pno >= 0)
5998         new->onetime_parent = recipients_list[r->pno].address;
5999
6000       /* If DSN support is enabled, set the dsn flags and the original receipt
6001          to be passed on to other DSN enabled MTAs */
6002       new->dsn_flags = r->dsn_flags & rf_dsnflags;
6003       new->dsn_orcpt = r->orcpt;
6004       DEBUG(D_deliver) debug_printf("DSN: set orcpt: %s  flags: %d\n",
6005         new->dsn_orcpt, new->dsn_flags);
6006
6007       switch (process_recipients)
6008         {
6009         /* RECIP_DEFER is set when a system filter freezes a message. */
6010
6011         case RECIP_DEFER:
6012         new->next = addr_defer;
6013         addr_defer = new;
6014         break;
6015
6016
6017         /* RECIP_FAIL_FILTER is set when a system filter has obeyed a "fail"
6018         command. */
6019
6020         case RECIP_FAIL_FILTER:
6021         new->message =
6022           filter_message ? filter_message : US"delivery cancelled";
6023         setflag(new, af_pass_message);
6024         goto RECIP_QUEUE_FAILED;   /* below */
6025
6026
6027         /* RECIP_FAIL_TIMEOUT is set when a message is frozen, but is older
6028         than the value in timeout_frozen_after. Treat non-bounce messages
6029         similarly to -Mg; for bounce messages we just want to discard, so
6030         don't put the address on the failed list. The timeout has already
6031         been logged. */
6032
6033         case RECIP_FAIL_TIMEOUT:
6034         new->message  = US"delivery cancelled; message timed out";
6035         goto RECIP_QUEUE_FAILED;   /* below */
6036
6037
6038         /* RECIP_FAIL is set when -Mg has been used. */
6039
6040         case RECIP_FAIL:
6041         new->message  = US"delivery cancelled by administrator";
6042         /* Fall through */
6043
6044         /* Common code for the failure cases above. If this is not a bounce
6045         message, put the address on the failed list so that it is used to
6046         create a bounce. Otherwise do nothing - this just discards the address.
6047         The incident has already been logged. */
6048
6049         RECIP_QUEUE_FAILED:
6050         if (sender_address[0] != 0)
6051           {
6052           new->next = addr_failed;
6053           addr_failed = new;
6054           }
6055         break;
6056
6057
6058         /* RECIP_FAIL_LOOP is set when there are too many Received: headers
6059         in the message. Process each address as a routing failure; if this
6060         is a bounce message, it will get frozen. */
6061
6062         case RECIP_FAIL_LOOP:
6063         new->message = US"Too many \"Received\" headers - suspected mail loop";
6064         post_process_one(new, FAIL, LOG_MAIN, DTYPE_ROUTER, 0);
6065         break;
6066
6067
6068         /* Value should be RECIP_ACCEPT; take this as the safe default. */
6069
6070         default:
6071         if (!addr_new) addr_new = new; else addr_last->next = new;
6072         addr_last = new;
6073         break;
6074         }
6075
6076 #ifndef DISABLE_EVENT
6077       if (process_recipients != RECIP_ACCEPT)
6078         {
6079         uschar * save_local =  deliver_localpart;
6080         const uschar * save_domain = deliver_domain;
6081
6082         deliver_localpart = expand_string(
6083                       string_sprintf("${local_part:%s}", new->address));
6084         deliver_domain =    expand_string(
6085                       string_sprintf("${domain:%s}", new->address));
6086
6087         (void) event_raise(event_action,
6088                       US"msg:fail:internal", new->message);
6089
6090         deliver_localpart = save_local;
6091         deliver_domain =    save_domain;
6092         }
6093 #endif
6094       }
6095     }
6096   }
6097
6098 DEBUG(D_deliver)
6099   {
6100   address_item *p;
6101   debug_printf("Delivery address list:\n");
6102   for (p = addr_new; p; p = p->next)
6103     debug_printf("  %s %s\n", p->address,
6104       p->onetime_parent ? p->onetime_parent : US"");
6105   }
6106
6107 /* Set up the buffers used for copying over the file when delivering. */
6108
6109 deliver_in_buffer = store_malloc(DELIVER_IN_BUFFER_SIZE);
6110 deliver_out_buffer = store_malloc(DELIVER_OUT_BUFFER_SIZE);
6111
6112
6113
6114 /* Until there are no more new addresses, handle each one as follows:
6115
6116  . If this is a generated address (indicated by the presence of a parent
6117    pointer) then check to see whether it is a pipe, file, or autoreply, and
6118    if so, handle it directly here. The router that produced the address will
6119    have set the allow flags into the address, and also set the uid/gid required.
6120    Having the routers generate new addresses and then checking them here at
6121    the outer level is tidier than making each router do the checking, and
6122    means that routers don't need access to the failed address queue.
6123
6124  . Break up the address into local part and domain, and make lowercased
6125    versions of these strings. We also make unquoted versions of the local part.
6126
6127  . Handle the percent hack for those domains for which it is valid.
6128
6129  . For child addresses, determine if any of the parents have the same address.
6130    If so, generate a different string for previous delivery checking. Without
6131    this code, if the address spqr generates spqr via a forward or alias file,
6132    delivery of the generated spqr stops further attempts at the top level spqr,
6133    which is not what is wanted - it may have generated other addresses.
6134
6135  . Check on the retry database to see if routing was previously deferred, but
6136    only if in a queue run. Addresses that are to be routed are put on the
6137    addr_route chain. Addresses that are to be deferred are put on the
6138    addr_defer chain. We do all the checking first, so as not to keep the
6139    retry database open any longer than necessary.
6140
6141  . Now we run the addresses through the routers. A router may put the address
6142    on either the addr_local or the addr_remote chain for local or remote
6143    delivery, respectively, or put it on the addr_failed chain if it is
6144    undeliveable, or it may generate child addresses and put them on the
6145    addr_new chain, or it may defer an address. All the chain anchors are
6146    passed as arguments so that the routers can be called for verification
6147    purposes as well.
6148
6149  . If new addresses have been generated by the routers, da capo.
6150 */
6151
6152 header_rewritten = FALSE;          /* No headers rewritten yet */
6153 while (addr_new)           /* Loop until all addresses dealt with */
6154   {
6155   address_item *addr, *parent;
6156
6157   /* Failure to open the retry database is treated the same as if it does
6158   not exist. In both cases, dbm_file is NULL. */
6159
6160   if (!(dbm_file = dbfn_open(US"retry", O_RDONLY, &dbblock, FALSE)))
6161     {
6162     DEBUG(D_deliver|D_retry|D_route|D_hints_lookup)
6163       debug_printf("no retry data available\n");
6164     }
6165
6166   /* Scan the current batch of new addresses, to handle pipes, files and
6167   autoreplies, and determine which others are ready for routing. */
6168
6169   while (addr_new)
6170     {
6171     int rc;
6172     uschar *p;
6173     tree_node *tnode;
6174     dbdata_retry *domain_retry_record;
6175     dbdata_retry *address_retry_record;
6176
6177     addr = addr_new;
6178     addr_new = addr->next;
6179
6180     DEBUG(D_deliver|D_retry|D_route)
6181       {
6182       debug_printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
6183       debug_printf("Considering: %s\n", addr->address);
6184       }
6185
6186     /* Handle generated address that is a pipe or a file or an autoreply. */
6187
6188     if (testflag(addr, af_pfr))
6189       {
6190       /* If an autoreply in a filter could not generate a syntactically valid
6191       address, give up forthwith. Set af_ignore_error so that we don't try to
6192       generate a bounce. */
6193
6194       if (testflag(addr, af_bad_reply))
6195         {
6196         addr->basic_errno = ERRNO_BADADDRESS2;
6197         addr->local_part = addr->address;
6198         addr->message =
6199           US"filter autoreply generated syntactically invalid recipient";
6200         setflag(addr, af_ignore_error);
6201         (void)post_process_one(addr, FAIL, LOG_MAIN, DTYPE_ROUTER, 0);
6202         continue;   /* with the next new address */
6203         }
6204
6205       /* If two different users specify delivery to the same pipe or file or
6206       autoreply, there should be two different deliveries, so build a unique
6207       string that incorporates the original address, and use this for
6208       duplicate testing and recording delivery, and also for retrying. */
6209
6210       addr->unique =
6211         string_sprintf("%s:%s", addr->address, addr->parent->unique +
6212           (testflag(addr->parent, af_homonym)? 3:0));
6213
6214       addr->address_retry_key = addr->domain_retry_key =
6215         string_sprintf("T:%s", addr->unique);
6216
6217       /* If a filter file specifies two deliveries to the same pipe or file,
6218       we want to de-duplicate, but this is probably not wanted for two mail
6219       commands to the same address, where probably both should be delivered.
6220       So, we have to invent a different unique string in that case. Just
6221       keep piling '>' characters on the front. */
6222
6223       if (addr->address[0] == '>')
6224         {
6225         while (tree_search(tree_duplicates, addr->unique))
6226           addr->unique = string_sprintf(">%s", addr->unique);
6227         }
6228
6229       else if ((tnode = tree_search(tree_duplicates, addr->unique)))
6230         {
6231         DEBUG(D_deliver|D_route)
6232           debug_printf("%s is a duplicate address: discarded\n", addr->address);
6233         addr->dupof = tnode->data.ptr;
6234         addr->next = addr_duplicate;
6235         addr_duplicate = addr;
6236         continue;
6237         }
6238
6239       DEBUG(D_deliver|D_route) debug_printf("unique = %s\n", addr->unique);
6240
6241       /* Check for previous delivery */
6242
6243       if (tree_search(tree_nonrecipients, addr->unique))
6244         {
6245         DEBUG(D_deliver|D_route)
6246           debug_printf("%s was previously delivered: discarded\n", addr->address);
6247         child_done(addr, tod_stamp(tod_log));
6248         continue;
6249         }
6250
6251       /* Save for checking future duplicates */
6252
6253       tree_add_duplicate(addr->unique, addr);
6254
6255       /* Set local part and domain */
6256
6257       addr->local_part = addr->address;
6258       addr->domain = addr->parent->domain;
6259
6260       /* Ensure that the delivery is permitted. */
6261
6262       if (testflag(addr, af_file))
6263         {
6264         if (!testflag(addr, af_allow_file))
6265           {
6266           addr->basic_errno = ERRNO_FORBIDFILE;
6267           addr->message = US"delivery to file forbidden";
6268           (void)post_process_one(addr, FAIL, LOG_MAIN, DTYPE_ROUTER, 0);
6269           continue;   /* with the next new address */
6270           }
6271         }
6272       else if (addr->address[0] == '|')
6273         {
6274         if (!testflag(addr, af_allow_pipe))
6275           {
6276           addr->basic_errno = ERRNO_FORBIDPIPE;
6277           addr->message = US"delivery to pipe forbidden";
6278           (void)post_process_one(addr, FAIL, LOG_MAIN, DTYPE_ROUTER, 0);
6279           continue;   /* with the next new address */
6280           }
6281         }
6282       else if (!testflag(addr, af_allow_reply))
6283         {
6284         addr->basic_errno = ERRNO_FORBIDREPLY;
6285         addr->message = US"autoreply forbidden";
6286         (void)post_process_one(addr, FAIL, LOG_MAIN, DTYPE_ROUTER, 0);
6287         continue;     /* with the next new address */
6288         }
6289
6290       /* If the errno field is already set to BADTRANSPORT, it indicates
6291       failure to expand a transport string, or find the associated transport,
6292       or an unset transport when one is required. Leave this test till now so
6293       that the forbid errors are given in preference. */
6294
6295       if (addr->basic_errno == ERRNO_BADTRANSPORT)
6296         {
6297         (void)post_process_one(addr, DEFER, LOG_MAIN, DTYPE_ROUTER, 0);
6298         continue;
6299         }
6300
6301       /* Treat /dev/null as a special case and abandon the delivery. This
6302       avoids having to specify a uid on the transport just for this case.
6303       Arrange for the transport name to be logged as "**bypassed**". */
6304
6305       if (Ustrcmp(addr->address, "/dev/null") == 0)
6306         {
6307         uschar *save = addr->transport->name;
6308         addr->transport->name = US"**bypassed**";
6309         (void)post_process_one(addr, OK, LOG_MAIN, DTYPE_TRANSPORT, '=');
6310         addr->transport->name = save;
6311         continue;   /* with the next new address */
6312         }
6313
6314       /* Pipe, file, or autoreply delivery is to go ahead as a normal local
6315       delivery. */
6316
6317       DEBUG(D_deliver|D_route)
6318         debug_printf("queued for %s transport\n", addr->transport->name);
6319       addr->next = addr_local;
6320       addr_local = addr;
6321       continue;       /* with the next new address */
6322       }
6323
6324     /* Handle normal addresses. First, split up into local part and domain,
6325     handling the %-hack if necessary. There is the possibility of a defer from
6326     a lookup in percent_hack_domains. */
6327
6328     if ((rc = deliver_split_address(addr)) == DEFER)
6329       {
6330       addr->message = US"cannot check percent_hack_domains";
6331       addr->basic_errno = ERRNO_LISTDEFER;
6332       (void)post_process_one(addr, DEFER, LOG_MAIN, DTYPE_NONE, 0);
6333       continue;
6334       }
6335
6336     /* Check to see if the domain is held. If so, proceed only if the
6337     delivery was forced by hand. */
6338
6339     deliver_domain = addr->domain;  /* set $domain */
6340     if (  !forced && hold_domains
6341        && (rc = match_isinlist(addr->domain, (const uschar **)&hold_domains, 0,
6342            &domainlist_anchor, addr->domain_cache, MCL_DOMAIN, TRUE,
6343            NULL)) != FAIL
6344        )
6345       {
6346       if (rc == DEFER)
6347         {
6348         addr->message = US"hold_domains lookup deferred";
6349         addr->basic_errno = ERRNO_LISTDEFER;
6350         }
6351       else
6352         {
6353         addr->message = US"domain is held";
6354         addr->basic_errno = ERRNO_HELD;
6355         }
6356       (void)post_process_one(addr, DEFER, LOG_MAIN, DTYPE_NONE, 0);
6357       continue;
6358       }
6359
6360     /* Now we can check for duplicates and previously delivered addresses. In
6361     order to do this, we have to generate a "unique" value for each address,
6362     because there may be identical actual addresses in a line of descendents.
6363     The "unique" field is initialized to the same value as the "address" field,
6364     but gets changed here to cope with identically-named descendents. */
6365
6366     for (parent = addr->parent; parent; parent = parent->parent)
6367       if (strcmpic(addr->address, parent->address) == 0) break;
6368
6369     /* If there's an ancestor with the same name, set the homonym flag. This
6370     influences how deliveries are recorded. Then add a prefix on the front of
6371     the unique address. We use \n\ where n starts at 0 and increases each time.
6372     It is unlikely to pass 9, but if it does, it may look odd but will still
6373     work. This means that siblings or cousins with the same names are treated
6374     as duplicates, which is what we want. */
6375
6376     if (parent)
6377       {
6378       setflag(addr, af_homonym);
6379       if (parent->unique[0] != '\\')
6380         addr->unique = string_sprintf("\\0\\%s", addr->address);
6381       else
6382         addr->unique = string_sprintf("\\%c\\%s", parent->unique[1] + 1,
6383           addr->address);
6384       }
6385
6386     /* Ensure that the domain in the unique field is lower cased, because
6387     domains are always handled caselessly. */
6388
6389     p = Ustrrchr(addr->unique, '@');
6390     while (*p != 0) { *p = tolower(*p); p++; }
6391
6392     DEBUG(D_deliver|D_route) debug_printf("unique = %s\n", addr->unique);
6393
6394     if (tree_search(tree_nonrecipients, addr->unique))
6395       {
6396       DEBUG(D_deliver|D_route)
6397         debug_printf("%s was previously delivered: discarded\n", addr->unique);
6398       child_done(addr, tod_stamp(tod_log));
6399       continue;
6400       }
6401
6402     /* Get the routing retry status, saving the two retry keys (with and
6403     without the local part) for subsequent use. If there is no retry record for
6404     the standard address routing retry key, we look for the same key with the
6405     sender attached, because this form is used by the smtp transport after a
6406     4xx response to RCPT when address_retry_include_sender is true. */
6407
6408     addr->domain_retry_key = string_sprintf("R:%s", addr->domain);
6409     addr->address_retry_key = string_sprintf("R:%s@%s", addr->local_part,
6410       addr->domain);
6411
6412     if (dbm_file)
6413       {
6414       domain_retry_record = dbfn_read(dbm_file, addr->domain_retry_key);
6415       if (  domain_retry_record
6416          && now - domain_retry_record->time_stamp > retry_data_expire
6417          )
6418         domain_retry_record = NULL;    /* Ignore if too old */
6419
6420       address_retry_record = dbfn_read(dbm_file, addr->address_retry_key);
6421       if (  address_retry_record
6422          && now - address_retry_record->time_stamp > retry_data_expire
6423          )
6424         address_retry_record = NULL;   /* Ignore if too old */
6425
6426       if (!address_retry_record)
6427         {
6428         uschar *altkey = string_sprintf("%s:<%s>", addr->address_retry_key,
6429           sender_address);
6430         address_retry_record = dbfn_read(dbm_file, altkey);
6431         if (  address_retry_record
6432            && now - address_retry_record->time_stamp > retry_data_expire)
6433           address_retry_record = NULL;   /* Ignore if too old */
6434         }
6435       }
6436     else
6437       domain_retry_record = address_retry_record = NULL;
6438
6439     DEBUG(D_deliver|D_retry)
6440       {
6441       if (!domain_retry_record)
6442         debug_printf("no domain retry record\n");
6443       if (!address_retry_record)
6444         debug_printf("no address retry record\n");
6445       }
6446
6447     /* If we are sending a message down an existing SMTP connection, we must
6448     assume that the message which created the connection managed to route
6449     an address to that connection. We do not want to run the risk of taking
6450     a long time over routing here, because if we do, the server at the other
6451     end of the connection may time it out. This is especially true for messages
6452     with lots of addresses. For this kind of delivery, queue_running is not
6453     set, so we would normally route all addresses. We take a pragmatic approach
6454     and defer routing any addresses that have any kind of domain retry record.
6455     That is, we don't even look at their retry times. It doesn't matter if this
6456     doesn't work occasionally. This is all just an optimization, after all.
6457
6458     The reason for not doing the same for address retries is that they normally
6459     arise from 4xx responses, not DNS timeouts. */
6460
6461     if (continue_hostname && domain_retry_record)
6462       {
6463       addr->message = US"reusing SMTP connection skips previous routing defer";
6464       addr->basic_errno = ERRNO_RRETRY;
6465       (void)post_process_one(addr, DEFER, LOG_MAIN, DTYPE_ROUTER, 0);
6466       }
6467
6468     /* If we are in a queue run, defer routing unless there is no retry data or
6469     we've passed the next retry time, or this message is forced. In other
6470     words, ignore retry data when not in a queue run.
6471
6472     However, if the domain retry time has expired, always allow the routing
6473     attempt. If it fails again, the address will be failed. This ensures that
6474     each address is routed at least once, even after long-term routing
6475     failures.
6476
6477     If there is an address retry, check that too; just wait for the next
6478     retry time. This helps with the case when the temporary error on the
6479     address was really message-specific rather than address specific, since
6480     it allows other messages through.
6481
6482     We also wait for the next retry time if this is a message sent down an
6483     existing SMTP connection (even though that will be forced). Otherwise there
6484     will be far too many attempts for an address that gets a 4xx error. In
6485     fact, after such an error, we should not get here because, the host should
6486     not be remembered as one this message needs. However, there was a bug that
6487     used to cause this to  happen, so it is best to be on the safe side.
6488
6489     Even if we haven't reached the retry time in the hints, there is one more
6490     check to do, which is for the ultimate address timeout. We only do this
6491     check if there is an address retry record and there is not a domain retry
6492     record; this implies that previous attempts to handle the address had the
6493     retry_use_local_parts option turned on. We use this as an approximation
6494     for the destination being like a local delivery, for example delivery over
6495     LMTP to an IMAP message store. In this situation users are liable to bump
6496     into their quota and thereby have intermittently successful deliveries,
6497     which keep the retry record fresh, which can lead to us perpetually
6498     deferring messages. */
6499
6500     else if (  (  queue_running && !deliver_force
6501                || continue_hostname
6502                )
6503             && (  (  domain_retry_record
6504                   && now < domain_retry_record->next_try
6505                   && !domain_retry_record->expired
6506                   )
6507                || (  address_retry_record
6508                   && now < address_retry_record->next_try
6509                )  )
6510             && (  domain_retry_record
6511                || !address_retry_record
6512                || !retry_ultimate_address_timeout(addr->address_retry_key,
6513                                  addr->domain, address_retry_record, now)
6514             )  )
6515       {
6516       addr->message = US"retry time not reached";
6517       addr->basic_errno = ERRNO_RRETRY;
6518       (void)post_process_one(addr, DEFER, LOG_MAIN, DTYPE_ROUTER, 0);
6519       }
6520
6521     /* The domain is OK for routing. Remember if retry data exists so it
6522     can be cleaned up after a successful delivery. */
6523
6524     else
6525       {
6526       if (domain_retry_record || address_retry_record)
6527         setflag(addr, af_dr_retry_exists);
6528       addr->next = addr_route;
6529       addr_route = addr;
6530       DEBUG(D_deliver|D_route)
6531         debug_printf("%s: queued for routing\n", addr->address);
6532       }
6533     }
6534
6535   /* The database is closed while routing is actually happening. Requests to
6536   update it are put on a chain and all processed together at the end. */
6537
6538   if (dbm_file) dbfn_close(dbm_file);
6539
6540   /* If queue_domains is set, we don't even want to try routing addresses in
6541   those domains. During queue runs, queue_domains is forced to be unset.
6542   Optimize by skipping this pass through the addresses if nothing is set. */
6543
6544   if (!deliver_force && queue_domains)
6545     {
6546     address_item *okaddr = NULL;
6547     while (addr_route)
6548       {
6549       address_item *addr = addr_route;
6550       addr_route = addr->next;
6551
6552       deliver_domain = addr->domain;  /* set $domain */
6553       if ((rc = match_isinlist(addr->domain, (const uschar **)&queue_domains, 0,
6554             &domainlist_anchor, addr->domain_cache, MCL_DOMAIN, TRUE, NULL))
6555               != OK)
6556         {
6557         if (rc == DEFER)
6558           {
6559           addr->basic_errno = ERRNO_LISTDEFER;
6560           addr->message = US"queue_domains lookup deferred";
6561           (void)post_process_one(addr, DEFER, LOG_MAIN, DTYPE_ROUTER, 0);
6562           }
6563         else
6564           {
6565           addr->next = okaddr;
6566           okaddr = addr;
6567           }
6568         }
6569       else
6570         {
6571         addr->basic_errno = ERRNO_QUEUE_DOMAIN;
6572         addr->message = US"domain is in queue_domains";
6573         (void)post_process_one(addr, DEFER, LOG_MAIN, DTYPE_ROUTER, 0);
6574         }
6575       }
6576
6577     addr_route = okaddr;
6578     }
6579
6580   /* Now route those addresses that are not deferred. */
6581
6582   while (addr_route)
6583     {
6584     int rc;
6585     address_item *addr = addr_route;
6586     const uschar *old_domain = addr->domain;
6587     uschar *old_unique = addr->unique;
6588     addr_route = addr->next;
6589     addr->next = NULL;
6590
6591     /* Just in case some router parameter refers to it. */
6592
6593     if (!(return_path = addr->prop.errors_address))
6594       return_path = sender_address;
6595
6596     /* If a router defers an address, add a retry item. Whether or not to
6597     use the local part in the key is a property of the router. */
6598
6599     if ((rc = route_address(addr, &addr_local, &addr_remote, &addr_new,
6600          &addr_succeed, v_none)) == DEFER)
6601       retry_add_item(addr,
6602         addr->router->retry_use_local_part
6603         ?  string_sprintf("R:%s@%s", addr->local_part, addr->domain)
6604         : string_sprintf("R:%s", addr->domain),
6605         0);
6606
6607     /* Otherwise, if there is an existing retry record in the database, add
6608     retry items to delete both forms. We must also allow for the possibility
6609     of a routing retry that includes the sender address. Since the domain might
6610     have been rewritten (expanded to fully qualified) as a result of routing,
6611     ensure that the rewritten form is also deleted. */
6612
6613     else if (testflag(addr, af_dr_retry_exists))
6614       {
6615       uschar *altkey = string_sprintf("%s:<%s>", addr->address_retry_key,
6616         sender_address);
6617       retry_add_item(addr, altkey, rf_delete);
6618       retry_add_item(addr, addr->address_retry_key, rf_delete);
6619       retry_add_item(addr, addr->domain_retry_key, rf_delete);
6620       if (Ustrcmp(addr->domain, old_domain) != 0)
6621         retry_add_item(addr, string_sprintf("R:%s", old_domain), rf_delete);
6622       }
6623
6624     /* DISCARD is given for :blackhole: and "seen finish". The event has been
6625     logged, but we need to ensure the address (and maybe parents) is marked
6626     done. */
6627
6628     if (rc == DISCARD)
6629       {
6630       address_done(addr, tod_stamp(tod_log));
6631       continue;  /* route next address */
6632       }
6633
6634     /* The address is finished with (failed or deferred). */
6635
6636     if (rc != OK)
6637       {
6638       (void)post_process_one(addr, rc, LOG_MAIN, DTYPE_ROUTER, 0);
6639       continue;  /* route next address */
6640       }
6641
6642     /* The address has been routed. If the router changed the domain, it will
6643     also have changed the unique address. We have to test whether this address
6644     has already been delivered, because it's the unique address that finally
6645     gets recorded. */
6646
6647     if (  addr->unique != old_unique
6648        && tree_search(tree_nonrecipients, addr->unique) != 0
6649        )
6650       {
6651       DEBUG(D_deliver|D_route) debug_printf("%s was previously delivered: "
6652         "discarded\n", addr->address);
6653       if (addr_remote == addr) addr_remote = addr->next;
6654       else if (addr_local == addr) addr_local = addr->next;
6655       }
6656
6657     /* If the router has same_domain_copy_routing set, we are permitted to copy
6658     the routing for any other addresses with the same domain. This is an
6659     optimisation to save repeated DNS lookups for "standard" remote domain
6660     routing. The option is settable only on routers that generate host lists.
6661     We play it very safe, and do the optimization only if the address is routed
6662     to a remote transport, there are no header changes, and the domain was not
6663     modified by the router. */
6664
6665     if (  addr_remote == addr
6666        && addr->router->same_domain_copy_routing
6667        && !addr->prop.extra_headers
6668        && !addr->prop.remove_headers
6669        && old_domain == addr->domain
6670        )
6671       {
6672       address_item **chain = &addr_route;
6673       while (*chain)
6674         {
6675         address_item *addr2 = *chain;
6676         if (Ustrcmp(addr2->domain, addr->domain) != 0)
6677           {
6678           chain = &(addr2->next);
6679           continue;
6680           }
6681
6682         /* Found a suitable address; take it off the routing list and add it to
6683         the remote delivery list. */
6684
6685         *chain = addr2->next;
6686         addr2->next = addr_remote;
6687         addr_remote = addr2;
6688
6689         /* Copy the routing data */
6690
6691         addr2->domain = addr->domain;
6692         addr2->router = addr->router;
6693         addr2->transport = addr->transport;
6694         addr2->host_list = addr->host_list;
6695         addr2->fallback_hosts = addr->fallback_hosts;
6696         addr2->prop.errors_address = addr->prop.errors_address;
6697         copyflag(addr2, addr, af_hide_child | af_local_host_removed);
6698
6699         DEBUG(D_deliver|D_route)
6700           {
6701           debug_printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n"
6702                        "routing %s\n"
6703                        "Routing for %s copied from %s\n",
6704             addr2->address, addr2->address, addr->address);
6705           }
6706         }
6707       }
6708     }  /* Continue with routing the next address. */
6709   }    /* Loop to process any child addresses that the routers created, and
6710           any rerouted addresses that got put back on the new chain. */
6711
6712
6713 /* Debugging: show the results of the routing */
6714
6715 DEBUG(D_deliver|D_retry|D_route)
6716   {
6717   address_item *p;
6718   debug_printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
6719   debug_printf("After routing:\n  Local deliveries:\n");
6720   for (p = addr_local; p; p = p->next)
6721     debug_printf("    %s\n", p->address);
6722
6723   debug_printf("  Remote deliveries:\n");
6724   for (p = addr_remote; p; p = p->next)
6725     debug_printf("    %s\n", p->address);
6726
6727   debug_printf("  Failed addresses:\n");
6728   for (p = addr_failed; p; p = p->next)
6729     debug_printf("    %s\n", p->address);
6730
6731   debug_printf("  Deferred addresses:\n");
6732   for (p = addr_defer; p; p = p->next)
6733     debug_printf("    %s\n", p->address);
6734   }
6735
6736 /* Free any resources that were cached during routing. */
6737
6738 search_tidyup();
6739 route_tidyup();
6740
6741 /* These two variables are set only during routing, after check_local_user.
6742 Ensure they are not set in transports. */
6743
6744 local_user_gid = (gid_t)(-1);
6745 local_user_uid = (uid_t)(-1);
6746
6747 /* Check for any duplicate addresses. This check is delayed until after
6748 routing, because the flexibility of the routing configuration means that
6749 identical addresses with different parentage may end up being redirected to
6750 different addresses. Checking for duplicates too early (as we previously used
6751 to) makes this kind of thing not work. */
6752
6753 do_duplicate_check(&addr_local);
6754 do_duplicate_check(&addr_remote);
6755
6756 /* When acting as an MUA wrapper, we proceed only if all addresses route to a
6757 remote transport. The check that they all end up in one transaction happens in
6758 the do_remote_deliveries() function. */
6759
6760 if (  mua_wrapper
6761    && (addr_local || addr_failed || addr_defer)
6762    )
6763   {
6764   address_item *addr;
6765   uschar *which, *colon, *msg;
6766
6767   if (addr_local)
6768     {
6769     addr = addr_local;
6770     which = US"local";
6771     }
6772   else if (addr_defer)
6773     {
6774     addr = addr_defer;
6775     which = US"deferred";
6776     }
6777   else
6778     {
6779     addr = addr_failed;
6780     which = US"failed";
6781     }
6782
6783   while (addr->parent) addr = addr->parent;
6784
6785   if (addr->message)
6786     {
6787     colon = US": ";
6788     msg = addr->message;
6789     }
6790   else colon = msg = US"";
6791
6792   /* We don't need to log here for a forced failure as it will already
6793   have been logged. Defer will also have been logged, but as a defer, so we do
6794   need to do the failure logging. */
6795
6796   if (addr != addr_failed)
6797     log_write(0, LOG_MAIN, "** %s routing yielded a %s delivery",
6798       addr->address, which);
6799
6800   /* Always write an error to the caller */
6801
6802   fprintf(stderr, "routing %s yielded a %s delivery%s%s\n", addr->address,
6803     which, colon, msg);
6804
6805   final_yield = DELIVER_MUA_FAILED;
6806   addr_failed = addr_defer = NULL;   /* So that we remove the message */
6807   goto DELIVERY_TIDYUP;
6808   }
6809
6810
6811 /* If this is a run to continue deliveries to an external channel that is
6812 already set up, defer any local deliveries. */
6813
6814 if (continue_transport)
6815   {
6816   if (addr_defer)
6817     {
6818     address_item *addr = addr_defer;
6819     while (addr->next) addr = addr->next;
6820     addr->next = addr_local;
6821     }
6822   else
6823     addr_defer = addr_local;
6824   addr_local = NULL;
6825   }
6826
6827
6828 /* Because address rewriting can happen in the routers, we should not really do
6829 ANY deliveries until all addresses have been routed, so that all recipients of
6830 the message get the same headers. However, this is in practice not always
6831 possible, since sometimes remote addresses give DNS timeouts for days on end.
6832 The pragmatic approach is to deliver what we can now, saving any rewritten
6833 headers so that at least the next lot of recipients benefit from the rewriting
6834 that has already been done.
6835
6836 If any headers have been rewritten during routing, update the spool file to
6837 remember them for all subsequent deliveries. This can be delayed till later if
6838 there is only address to be delivered - if it succeeds the spool write need not
6839 happen. */
6840
6841 if (  header_rewritten
6842    && (  (  addr_local
6843          && (addr_local->next || addr_remote)
6844          )
6845       || (addr_remote && addr_remote->next)
6846    )  )
6847   {
6848   /* Panic-dies on error */
6849   (void)spool_write_header(message_id, SW_DELIVERING, NULL);
6850   header_rewritten = FALSE;
6851   }
6852
6853
6854 /* If there are any deliveries to be done, open the journal file. This is used
6855 to record successful deliveries as soon as possible after each delivery is
6856 known to be complete. A file opened with O_APPEND is used so that several
6857 processes can run simultaneously.
6858
6859 The journal is just insurance against crashes. When the spool file is
6860 ultimately updated at the end of processing, the journal is deleted. If a
6861 journal is found to exist at the start of delivery, the addresses listed
6862 therein are added to the non-recipients. */
6863
6864 if (addr_local || addr_remote)
6865   {
6866   uschar * fname = spool_fname(US"input", message_subdir, id, US"-J");
6867
6868   if ((journal_fd = Uopen(fname, O_WRONLY|O_APPEND|O_CREAT, SPOOL_MODE)) <0)
6869     {
6870     log_write(0, LOG_MAIN|LOG_PANIC, "Couldn't open journal file %s: %s",
6871       fname, strerror(errno));
6872     return DELIVER_NOT_ATTEMPTED;
6873     }
6874
6875   /* Set the close-on-exec flag, make the file owned by Exim, and ensure
6876   that the mode is correct - the group setting doesn't always seem to get
6877   set automatically. */
6878
6879   if(  fcntl(journal_fd, F_SETFD, fcntl(journal_fd, F_GETFD) | FD_CLOEXEC)
6880     || fchown(journal_fd, exim_uid, exim_gid)
6881     || fchmod(journal_fd, SPOOL_MODE)
6882     )
6883     {
6884     int ret = Uunlink(fname);
6885     log_write(0, LOG_MAIN|LOG_PANIC, "Couldn't set perms on journal file %s: %s",
6886       fname, strerror(errno));
6887     if(ret  &&  errno != ENOENT)
6888       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to unlink %s: %s",
6889         fname, strerror(errno));
6890     return DELIVER_NOT_ATTEMPTED;
6891     }
6892   }
6893
6894
6895
6896 /* Now we can get down to the business of actually doing deliveries. Local
6897 deliveries are done first, then remote ones. If ever the problems of how to
6898 handle fallback transports are figured out, this section can be put into a loop
6899 for handling fallbacks, though the uid switching will have to be revised. */
6900
6901 /* Precompile a regex that is used to recognize a parameter in response
6902 to an LHLO command, if is isn't already compiled. This may be used on both
6903 local and remote LMTP deliveries. */
6904
6905 if (!regex_IGNOREQUOTA)
6906   regex_IGNOREQUOTA =
6907     regex_must_compile(US"\\n250[\\s\\-]IGNOREQUOTA(\\s|\\n|$)", FALSE, TRUE);
6908
6909 /* Handle local deliveries */
6910
6911 if (addr_local)
6912   {
6913   DEBUG(D_deliver|D_transport)
6914     debug_printf(">>>>>>>>>>>>>>>> Local deliveries >>>>>>>>>>>>>>>>\n");
6915   do_local_deliveries();
6916   disable_logging = FALSE;
6917   }
6918
6919 /* If queue_run_local is set, we do not want to attempt any remote deliveries,
6920 so just queue them all. */
6921
6922 if (queue_run_local)
6923   while (addr_remote)
6924     {
6925     address_item *addr = addr_remote;
6926     addr_remote = addr->next;
6927     addr->next = NULL;
6928     addr->basic_errno = ERRNO_LOCAL_ONLY;
6929     addr->message = US"remote deliveries suppressed";
6930     (void)post_process_one(addr, DEFER, LOG_MAIN, DTYPE_TRANSPORT, 0);
6931     }
6932
6933 /* Handle remote deliveries */
6934
6935 if (addr_remote)
6936   {
6937   DEBUG(D_deliver|D_transport)
6938     debug_printf(">>>>>>>>>>>>>>>> Remote deliveries >>>>>>>>>>>>>>>>\n");
6939
6940   /* Precompile some regex that are used to recognize parameters in response
6941   to an EHLO command, if they aren't already compiled. */
6942
6943   deliver_init();
6944
6945   /* Now sort the addresses if required, and do the deliveries. The yield of
6946   do_remote_deliveries is FALSE when mua_wrapper is set and all addresses
6947   cannot be delivered in one transaction. */
6948
6949   if (remote_sort_domains) sort_remote_deliveries();
6950   if (!do_remote_deliveries(FALSE))
6951     {
6952     log_write(0, LOG_MAIN, "** mua_wrapper is set but recipients cannot all "
6953       "be delivered in one transaction");
6954     fprintf(stderr, "delivery to smarthost failed (configuration problem)\n");
6955
6956     final_yield = DELIVER_MUA_FAILED;
6957     addr_failed = addr_defer = NULL;   /* So that we remove the message */
6958     goto DELIVERY_TIDYUP;
6959     }
6960
6961   /* See if any of the addresses that failed got put on the queue for delivery
6962   to their fallback hosts. We do it this way because often the same fallback
6963   host is used for many domains, so all can be sent in a single transaction
6964   (if appropriately configured). */
6965
6966   if (addr_fallback && !mua_wrapper)
6967     {
6968     DEBUG(D_deliver) debug_printf("Delivering to fallback hosts\n");
6969     addr_remote = addr_fallback;
6970     addr_fallback = NULL;
6971     if (remote_sort_domains) sort_remote_deliveries();
6972     do_remote_deliveries(TRUE);
6973     }
6974   disable_logging = FALSE;
6975   }
6976
6977
6978 /* All deliveries are now complete. Ignore SIGTERM during this tidying up
6979 phase, to minimize cases of half-done things. */
6980
6981 DEBUG(D_deliver)
6982   debug_printf(">>>>>>>>>>>>>>>> deliveries are done >>>>>>>>>>>>>>>>\n");
6983
6984 /* Root privilege is no longer needed */
6985
6986 exim_setugid(exim_uid, exim_gid, FALSE, US"post-delivery tidying");
6987
6988 set_process_info("tidying up after delivering %s", message_id);
6989 signal(SIGTERM, SIG_IGN);
6990
6991 /* When we are acting as an MUA wrapper, the smtp transport will either have
6992 succeeded for all addresses, or failed them all in normal cases. However, there
6993 are some setup situations (e.g. when a named port does not exist) that cause an
6994 immediate exit with deferral of all addresses. Convert those into failures. We
6995 do not ever want to retry, nor do we want to send a bounce message. */
6996
6997 if (mua_wrapper)
6998   {
6999   if (addr_defer)
7000     {
7001     address_item *addr, *nextaddr;
7002     for (addr = addr_defer; addr; addr = nextaddr)
7003       {
7004       log_write(0, LOG_MAIN, "** %s mua_wrapper forced failure for deferred "
7005         "delivery", addr->address);
7006       nextaddr = addr->next;
7007       addr->next = addr_failed;
7008       addr_failed = addr;
7009       }
7010     addr_defer = NULL;
7011     }
7012
7013   /* Now all should either have succeeded or failed. */
7014
7015   if (!addr_failed)
7016     final_yield = DELIVER_MUA_SUCCEEDED;
7017   else
7018     {
7019     host_item * host;
7020     uschar *s = addr_failed->user_message;
7021
7022     if (!s) s = addr_failed->message;
7023
7024     fprintf(stderr, "Delivery failed: ");
7025     if (addr_failed->basic_errno > 0)
7026       {
7027       fprintf(stderr, "%s", strerror(addr_failed->basic_errno));
7028       if (s) fprintf(stderr, ": ");
7029       }
7030     if ((host = addr_failed->host_used))
7031       fprintf(stderr, "H=%s [%s]: ", host->name, host->address);
7032     if (s)
7033       fprintf(stderr, "%s", CS s);
7034     else if (addr_failed->basic_errno <= 0)
7035       fprintf(stderr, "unknown error");
7036     fprintf(stderr, "\n");
7037
7038     final_yield = DELIVER_MUA_FAILED;
7039     addr_failed = NULL;
7040     }
7041   }
7042
7043 /* In a normal configuration, we now update the retry database. This is done in
7044 one fell swoop at the end in order not to keep opening and closing (and
7045 locking) the database. The code for handling retries is hived off into a
7046 separate module for convenience. We pass it the addresses of the various
7047 chains, because deferred addresses can get moved onto the failed chain if the
7048 retry cutoff time has expired for all alternative destinations. Bypass the
7049 updating of the database if the -N flag is set, which is a debugging thing that
7050 prevents actual delivery. */
7051
7052 else if (!dont_deliver)
7053   retry_update(&addr_defer, &addr_failed, &addr_succeed);
7054
7055 /* Send DSN for successful messages if requested */
7056 addr_senddsn = NULL;
7057
7058 for (addr_dsntmp = addr_succeed; addr_dsntmp; addr_dsntmp = addr_dsntmp->next)
7059   {
7060   /* af_ignore_error not honored here. it's not an error */
7061   DEBUG(D_deliver) debug_printf("DSN: processing router : %s\n"
7062       "DSN: processing successful delivery address: %s\n"
7063       "DSN: Sender_address: %s\n"
7064       "DSN: orcpt: %s  flags: %d\n"
7065       "DSN: envid: %s  ret: %d\n"
7066       "DSN: Final recipient: %s\n"
7067       "DSN: Remote SMTP server supports DSN: %d\n",
7068       addr_dsntmp->router->name,
7069       addr_dsntmp->address,
7070       sender_address,
7071       addr_dsntmp->dsn_orcpt, addr_dsntmp->dsn_flags,
7072       dsn_envid, dsn_ret,
7073       addr_dsntmp->address,
7074       addr_dsntmp->dsn_aware
7075       );
7076
7077   /* send report if next hop not DSN aware or a router flagged "last DSN hop"
7078      and a report was requested */
7079   if (  (  addr_dsntmp->dsn_aware != dsn_support_yes
7080         || addr_dsntmp->dsn_flags & rf_dsnlasthop
7081         )
7082      && addr_dsntmp->dsn_flags & rf_dsnflags
7083      && addr_dsntmp->dsn_flags & rf_notify_success
7084      )
7085     {
7086     /* copy and relink address_item and send report with all of them at once later */
7087     address_item *addr_next;
7088     addr_next = addr_senddsn;
7089     addr_senddsn = store_get(sizeof(address_item));
7090     memcpy(addr_senddsn, addr_dsntmp, sizeof(address_item));
7091     addr_senddsn->next = addr_next;
7092     }
7093   else
7094     DEBUG(D_deliver) debug_printf("DSN: not sending DSN success message\n");
7095   }
7096
7097 if (addr_senddsn)
7098   {
7099   pid_t pid;
7100   int fd;
7101
7102   /* create exim process to send message */
7103   pid = child_open_exim(&fd);
7104
7105   DEBUG(D_deliver) debug_printf("DSN: child_open_exim returns: %d\n", pid);
7106
7107   if (pid < 0)  /* Creation of child failed */
7108     {
7109     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Process %d (parent %d) failed to "
7110       "create child process to send failure message: %s", getpid(),
7111       getppid(), strerror(errno));
7112
7113     DEBUG(D_deliver) debug_printf("DSN: child_open_exim failed\n");
7114     }
7115   else  /* Creation of child succeeded */
7116     {
7117     FILE *f = fdopen(fd, "wb");
7118     /* header only as required by RFC. only failure DSN needs to honor RET=FULL */
7119     uschar * bound;
7120     transport_ctx tctx = {0};
7121
7122     DEBUG(D_deliver)
7123       debug_printf("sending error message to: %s\n", sender_address);
7124
7125     /* build unique id for MIME boundary */
7126     bound = string_sprintf(TIME_T_FMT "-eximdsn-%d", time(NULL), rand());
7127     DEBUG(D_deliver) debug_printf("DSN: MIME boundary: %s\n", bound);
7128
7129     if (errors_reply_to)
7130       fprintf(f, "Reply-To: %s\n", errors_reply_to);
7131
7132     fprintf(f, "Auto-Submitted: auto-generated\n"
7133         "From: Mail Delivery System <Mailer-Daemon@%s>\n"
7134         "To: %s\n"
7135         "Subject: Delivery Status Notification\n"
7136         "Content-Type: multipart/report; report-type=delivery-status; boundary=%s\n"
7137         "MIME-Version: 1.0\n\n"
7138
7139         "--%s\n"
7140         "Content-type: text/plain; charset=us-ascii\n\n"
7141
7142         "This message was created automatically by mail delivery software.\n"
7143         " ----- The following addresses had successful delivery notifications -----\n",
7144       qualify_domain_sender, sender_address, bound, bound);
7145
7146     for (addr_dsntmp = addr_senddsn; addr_dsntmp;
7147          addr_dsntmp = addr_dsntmp->next)
7148       fprintf(f, "<%s> (relayed %s)\n\n",
7149         addr_dsntmp->address,
7150         (addr_dsntmp->dsn_flags & rf_dsnlasthop) == 1
7151           ? "via non DSN router"
7152           : addr_dsntmp->dsn_aware == dsn_support_no
7153           ? "to non-DSN-aware mailer"
7154           : "via non \"Remote SMTP\" router"
7155         );
7156
7157     fprintf(f, "--%s\n"
7158         "Content-type: message/delivery-status\n\n"
7159         "Reporting-MTA: dns; %s\n",
7160       bound, smtp_active_hostname);
7161
7162     if (dsn_envid)
7163       {                 /* must be decoded from xtext: see RFC 3461:6.3a */
7164       uschar *xdec_envid;
7165       if (auth_xtextdecode(dsn_envid, &xdec_envid) > 0)
7166         fprintf(f, "Original-Envelope-ID: %s\n", dsn_envid);
7167       else
7168         fprintf(f, "X-Original-Envelope-ID: error decoding xtext formatted ENVID\n");
7169       }
7170     fputc('\n', f);
7171
7172     for (addr_dsntmp = addr_senddsn;
7173          addr_dsntmp;
7174          addr_dsntmp = addr_dsntmp->next)
7175       {
7176       if (addr_dsntmp->dsn_orcpt)
7177         fprintf(f,"Original-Recipient: %s\n", addr_dsntmp->dsn_orcpt);
7178
7179       fprintf(f, "Action: delivered\n"
7180           "Final-Recipient: rfc822;%s\n"
7181           "Status: 2.0.0\n",
7182         addr_dsntmp->address);
7183
7184       if (addr_dsntmp->host_used && addr_dsntmp->host_used->name)
7185         fprintf(f, "Remote-MTA: dns; %s\nDiagnostic-Code: smtp; 250 Ok\n\n",
7186           addr_dsntmp->host_used->name);
7187       else
7188         fprintf(f, "Diagnostic-Code: X-Exim; relayed via non %s router\n\n",
7189           (addr_dsntmp->dsn_flags & rf_dsnlasthop) == 1 ? "DSN" : "SMTP");
7190       }
7191
7192     fprintf(f, "--%s\nContent-type: text/rfc822-headers\n\n", bound);
7193
7194     fflush(f);
7195     transport_filter_argv = NULL;   /* Just in case */
7196     return_path = sender_address;   /* In case not previously set */
7197
7198     /* Write the original email out */
7199
7200     tctx.options = topt_add_return_path | topt_no_body;
7201     transport_write_message(fileno(f), &tctx, 0);
7202     fflush(f);
7203
7204     fprintf(f,"\n--%s--\n", bound);
7205
7206     fflush(f);
7207     fclose(f);
7208     rc = child_close(pid, 0);     /* Waits for child to close, no timeout */
7209     }
7210   }
7211
7212 /* If any addresses failed, we must send a message to somebody, unless
7213 af_ignore_error is set, in which case no action is taken. It is possible for
7214 several messages to get sent if there are addresses with different
7215 requirements. */
7216
7217 while (addr_failed)
7218   {
7219   pid_t pid;
7220   int fd;
7221   uschar *logtod = tod_stamp(tod_log);
7222   address_item *addr;
7223   address_item *handled_addr = NULL;
7224   address_item **paddr;
7225   address_item *msgchain = NULL;
7226   address_item **pmsgchain = &msgchain;
7227
7228   /* There are weird cases when logging is disabled in the transport. However,
7229   there may not be a transport (address failed by a router). */
7230
7231   disable_logging = FALSE;
7232   if (addr_failed->transport)
7233     disable_logging = addr_failed->transport->disable_logging;
7234
7235   DEBUG(D_deliver)
7236     debug_printf("processing failed address %s\n", addr_failed->address);
7237
7238   /* There are only two ways an address in a bounce message can get here:
7239
7240   (1) When delivery was initially deferred, but has now timed out (in the call
7241       to retry_update() above). We can detect this by testing for
7242       af_retry_timedout. If the address does not have its own errors address,
7243       we arrange to ignore the error.
7244
7245   (2) If delivery failures for bounce messages are being ignored. We can detect
7246       this by testing for af_ignore_error. This will also be set if a bounce
7247       message has been autothawed and the ignore_bounce_errors_after time has
7248       passed. It might also be set if a router was explicitly configured to
7249       ignore errors (errors_to = "").
7250
7251   If neither of these cases obtains, something has gone wrong. Log the
7252   incident, but then ignore the error. */
7253
7254   if (sender_address[0] == 0 && !addr_failed->prop.errors_address)
7255     {
7256     if (  !testflag(addr_failed, af_retry_timedout)
7257        && !testflag(addr_failed, af_ignore_error))
7258       {
7259       log_write(0, LOG_MAIN|LOG_PANIC, "internal error: bounce message "
7260         "failure is neither frozen nor ignored (it's been ignored)");
7261       }
7262     setflag(addr_failed, af_ignore_error);
7263     }
7264
7265   /* If the first address on the list has af_ignore_error set, just remove
7266   it from the list, throw away any saved message file, log it, and
7267   mark the recipient done. */
7268
7269   if (  testflag(addr_failed, af_ignore_error)
7270      || (  addr_failed->dsn_flags & rf_dsnflags
7271         && (addr_failed->dsn_flags & rf_notify_failure) != rf_notify_failure
7272      )  )
7273     {
7274     addr = addr_failed;
7275     addr_failed = addr->next;
7276     if (addr->return_filename) Uunlink(addr->return_filename);
7277
7278     log_write(0, LOG_MAIN, "%s%s%s%s: error ignored",
7279       addr->address,
7280       !addr->parent ? US"" : US" <",
7281       !addr->parent ? US"" : addr->parent->address,
7282       !addr->parent ? US"" : US">");
7283
7284     address_done(addr, logtod);
7285     child_done(addr, logtod);
7286     /* Panic-dies on error */
7287     (void)spool_write_header(message_id, SW_DELIVERING, NULL);
7288     }
7289
7290   /* Otherwise, handle the sending of a message. Find the error address for
7291   the first address, then send a message that includes all failed addresses
7292   that have the same error address. Note the bounce_recipient is a global so
7293   that it can be accesssed by $bounce_recipient while creating a customized
7294   error message. */
7295
7296   else
7297     {
7298     if (!(bounce_recipient = addr_failed->prop.errors_address))
7299       bounce_recipient = sender_address;
7300
7301     /* Make a subprocess to send a message */
7302
7303     if ((pid = child_open_exim(&fd)) < 0)
7304       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Process %d (parent %d) failed to "
7305         "create child process to send failure message: %s", getpid(),
7306         getppid(), strerror(errno));
7307
7308     /* Creation of child succeeded */
7309
7310     else
7311       {
7312       int ch, rc;
7313       int filecount = 0;
7314       int rcount = 0;
7315       uschar *bcc, *emf_text;
7316       FILE *f = fdopen(fd, "wb");
7317       FILE *emf = NULL;
7318       BOOL to_sender = strcmpic(sender_address, bounce_recipient) == 0;
7319       int max = (bounce_return_size_limit/DELIVER_IN_BUFFER_SIZE + 1) *
7320         DELIVER_IN_BUFFER_SIZE;
7321       uschar * bound;
7322       uschar *dsnlimitmsg;
7323       uschar *dsnnotifyhdr;
7324       int topt;
7325
7326       DEBUG(D_deliver)
7327         debug_printf("sending error message to: %s\n", bounce_recipient);
7328
7329       /* Scan the addresses for all that have the same errors address, removing
7330       them from the addr_failed chain, and putting them on msgchain. */
7331
7332       paddr = &addr_failed;
7333       for (addr = addr_failed; addr; addr = *paddr)
7334         if (Ustrcmp(bounce_recipient, addr->prop.errors_address
7335               ? addr->prop.errors_address : sender_address) == 0)
7336           {                          /* The same - dechain */
7337           *paddr = addr->next;
7338           *pmsgchain = addr;
7339           addr->next = NULL;
7340           pmsgchain = &(addr->next);
7341           }
7342         else
7343           paddr = &addr->next;        /* Not the same; skip */
7344
7345       /* Include X-Failed-Recipients: for automatic interpretation, but do
7346       not let any one header line get too long. We do this by starting a
7347       new header every 50 recipients. Omit any addresses for which the
7348       "hide_child" flag is set. */
7349
7350       for (addr = msgchain; addr; addr = addr->next)
7351         {
7352         if (testflag(addr, af_hide_child)) continue;
7353         if (rcount >= 50)
7354           {
7355           fprintf(f, "\n");
7356           rcount = 0;
7357           }
7358         fprintf(f, "%s%s",
7359           rcount++ == 0
7360           ? "X-Failed-Recipients: "
7361           : ",\n  ",
7362           testflag(addr, af_pfr) && addr->parent
7363           ? string_printing(addr->parent->address)
7364           : string_printing(addr->address));
7365         }
7366       if (rcount > 0) fprintf(f, "\n");
7367
7368       /* Output the standard headers */
7369
7370       if (errors_reply_to)
7371         fprintf(f, "Reply-To: %s\n", errors_reply_to);
7372       fprintf(f, "Auto-Submitted: auto-replied\n");
7373       moan_write_from(f);
7374       fprintf(f, "To: %s\n", bounce_recipient);
7375
7376       /* generate boundary string and output MIME-Headers */
7377       bound = string_sprintf(TIME_T_FMT "-eximdsn-%d", time(NULL), rand());
7378
7379       fprintf(f, "Content-Type: multipart/report;"
7380             " report-type=delivery-status; boundary=%s\n"
7381           "MIME-Version: 1.0\n",
7382         bound);
7383
7384       /* Open a template file if one is provided. Log failure to open, but
7385       carry on - default texts will be used. */
7386
7387       if (bounce_message_file)
7388         if (!(emf = Ufopen(bounce_message_file, "rb")))
7389           log_write(0, LOG_MAIN|LOG_PANIC, "Failed to open %s for error "
7390             "message texts: %s", bounce_message_file, strerror(errno));
7391
7392       /* Quietly copy to configured additional addresses if required. */
7393
7394       if ((bcc = moan_check_errorcopy(bounce_recipient)))
7395         fprintf(f, "Bcc: %s\n", bcc);
7396
7397       /* The texts for the message can be read from a template file; if there
7398       isn't one, or if it is too short, built-in texts are used. The first
7399       emf text is a Subject: and any other headers. */
7400
7401       if ((emf_text = next_emf(emf, US"header")))
7402         fprintf(f, "%s\n", emf_text);
7403       else
7404         fprintf(f, "Subject: Mail delivery failed%s\n\n",
7405           to_sender? ": returning message to sender" : "");
7406
7407       /* output human readable part as text/plain section */
7408       fprintf(f, "--%s\n"
7409           "Content-type: text/plain; charset=us-ascii\n\n",
7410         bound);
7411
7412       if ((emf_text = next_emf(emf, US"intro")))
7413         fprintf(f, "%s", CS emf_text);
7414       else
7415         {
7416         fprintf(f,
7417 /* This message has been reworded several times. It seems to be confusing to
7418 somebody, however it is worded. I have retreated to the original, simple
7419 wording. */
7420 "This message was created automatically by mail delivery software.\n");
7421
7422         if (bounce_message_text)
7423           fprintf(f, "%s", CS bounce_message_text);
7424         if (to_sender)
7425           fprintf(f,
7426 "\nA message that you sent could not be delivered to one or more of its\n"
7427 "recipients. This is a permanent error. The following address(es) failed:\n");
7428         else
7429           fprintf(f,
7430 "\nA message sent by\n\n  <%s>\n\n"
7431 "could not be delivered to one or more of its recipients. The following\n"
7432 "address(es) failed:\n", sender_address);
7433         }
7434       fputc('\n', f);
7435
7436       /* Process the addresses, leaving them on the msgchain if they have a
7437       file name for a return message. (There has already been a check in
7438       post_process_one() for the existence of data in the message file.) A TRUE
7439       return from print_address_information() means that the address is not
7440       hidden. */
7441
7442       paddr = &msgchain;
7443       for (addr = msgchain; addr; addr = *paddr)
7444         {
7445         if (print_address_information(addr, f, US"  ", US"\n    ", US""))
7446           print_address_error(addr, f, US"");
7447
7448         /* End the final line for the address */
7449
7450         fputc('\n', f);
7451
7452         /* Leave on msgchain if there's a return file. */
7453
7454         if (addr->return_file >= 0)
7455           {
7456           paddr = &(addr->next);
7457           filecount++;
7458           }
7459
7460         /* Else save so that we can tick off the recipient when the
7461         message is sent. */
7462
7463         else
7464           {
7465           *paddr = addr->next;
7466           addr->next = handled_addr;
7467           handled_addr = addr;
7468           }
7469         }
7470
7471       fputc('\n', f);
7472
7473       /* Get the next text, whether we need it or not, so as to be
7474       positioned for the one after. */
7475
7476       emf_text = next_emf(emf, US"generated text");
7477
7478       /* If there were any file messages passed by the local transports,
7479       include them in the message. Then put the address on the handled chain.
7480       In the case of a batch of addresses that were all sent to the same
7481       transport, the return_file field in all of them will contain the same
7482       fd, and the return_filename field in the *last* one will be set (to the
7483       name of the file). */
7484
7485       if (msgchain)
7486         {
7487         address_item *nextaddr;
7488
7489         if (emf_text)
7490           fprintf(f, "%s", CS emf_text);
7491         else
7492           fprintf(f,
7493             "The following text was generated during the delivery "
7494             "attempt%s:\n", (filecount > 1)? "s" : "");
7495
7496         for (addr = msgchain; addr; addr = nextaddr)
7497           {
7498           FILE *fm;
7499           address_item *topaddr = addr;
7500
7501           /* List all the addresses that relate to this file */
7502
7503           fputc('\n', f);
7504           while(addr)                   /* Insurance */
7505             {
7506             print_address_information(addr, f, US"------ ",  US"\n       ",
7507               US" ------\n");
7508             if (addr->return_filename) break;
7509             addr = addr->next;
7510             }
7511           fputc('\n', f);
7512
7513           /* Now copy the file */
7514
7515           if (!(fm = Ufopen(addr->return_filename, "rb")))
7516             fprintf(f, "    +++ Exim error... failed to open text file: %s\n",
7517               strerror(errno));
7518           else
7519             {
7520             while ((ch = fgetc(fm)) != EOF) fputc(ch, f);
7521             (void)fclose(fm);
7522             }
7523           Uunlink(addr->return_filename);
7524
7525           /* Can now add to handled chain, first fishing off the next
7526           address on the msgchain. */
7527
7528           nextaddr = addr->next;
7529           addr->next = handled_addr;
7530           handled_addr = topaddr;
7531           }
7532         fputc('\n', f);
7533         }
7534
7535       /* output machine readable part */
7536 #ifdef SUPPORT_I18N
7537       if (message_smtputf8)
7538         fprintf(f, "--%s\n"
7539             "Content-type: message/global-delivery-status\n\n"
7540             "Reporting-MTA: dns; %s\n",
7541           bound, smtp_active_hostname);
7542       else
7543 #endif
7544         fprintf(f, "--%s\n"
7545             "Content-type: message/delivery-status\n\n"
7546             "Reporting-MTA: dns; %s\n",
7547           bound, smtp_active_hostname);
7548
7549       if (dsn_envid)
7550         {
7551         /* must be decoded from xtext: see RFC 3461:6.3a */
7552         uschar *xdec_envid;
7553         if (auth_xtextdecode(dsn_envid, &xdec_envid) > 0)
7554           fprintf(f, "Original-Envelope-ID: %s\n", dsn_envid);
7555         else
7556           fprintf(f, "X-Original-Envelope-ID: error decoding xtext formatted ENVID\n");
7557         }
7558       fputc('\n', f);
7559
7560       for (addr = handled_addr; addr; addr = addr->next)
7561         {
7562         host_item * hu;
7563         fprintf(f, "Action: failed\n"
7564             "Final-Recipient: rfc822;%s\n"
7565             "Status: 5.0.0\n",
7566             addr->address);
7567         if ((hu = addr->host_used) && hu->name)
7568           {
7569           const uschar * s;
7570           fprintf(f, "Remote-MTA: dns; %s\n", hu->name);
7571 #ifdef EXPERIMENTAL_DSN_INFO
7572           if (hu->address)
7573             {
7574             uschar * p = hu->port == 25
7575               ? US"" : string_sprintf(":%d", hu->port);
7576             fprintf(f, "Remote-MTA: X-ip; [%s]%s\n", hu->address, p);
7577             }
7578           if ((s = addr->smtp_greeting) && *s)
7579             fprintf(f, "X-Remote-MTA-smtp-greeting: X-str; %s\n", s);
7580           if ((s = addr->helo_response) && *s)
7581             fprintf(f, "X-Remote-MTA-helo-response: X-str; %s\n", s);
7582           if ((s = addr->message) && *s)
7583             fprintf(f, "X-Exim-Diagnostic: X-str; %s\n", s);
7584 #endif
7585           print_dsn_diagnostic_code(addr, f);
7586           }
7587         fputc('\n', f);
7588         }
7589
7590       /* Now copy the message, trying to give an intelligible comment if
7591       it is too long for it all to be copied. The limit isn't strictly
7592       applied because of the buffering. There is, however, an option
7593       to suppress copying altogether. */
7594
7595       emf_text = next_emf(emf, US"copy");
7596
7597       /* add message body
7598          we ignore the intro text from template and add
7599          the text for bounce_return_size_limit at the end.
7600
7601          bounce_return_message is ignored
7602          in case RET= is defined we honor these values
7603          otherwise bounce_return_body is honored.
7604
7605          bounce_return_size_limit is always honored.
7606       */
7607
7608       fprintf(f, "--%s\n", bound);
7609
7610       dsnlimitmsg = US"X-Exim-DSN-Information: Due to administrative limits only headers are returned";
7611       dsnnotifyhdr = NULL;
7612       topt = topt_add_return_path;
7613
7614       /* RET=HDRS? top priority */
7615       if (dsn_ret == dsn_ret_hdrs)
7616         topt |= topt_no_body;
7617       else
7618         {
7619         struct stat statbuf;
7620
7621         /* no full body return at all? */
7622         if (!bounce_return_body)
7623           {
7624           topt |= topt_no_body;
7625           /* add header if we overrule RET=FULL */
7626           if (dsn_ret == dsn_ret_full)
7627             dsnnotifyhdr = dsnlimitmsg;
7628           }
7629         /* line length limited... return headers only if oversize */
7630         /* size limited ... return headers only if limit reached */
7631         else if (  max_received_linelength > bounce_return_linesize_limit
7632                 || (  bounce_return_size_limit > 0
7633                    && fstat(deliver_datafile, &statbuf) == 0
7634                    && statbuf.st_size > max
7635                 )  )
7636           {
7637           topt |= topt_no_body;
7638           dsnnotifyhdr = dsnlimitmsg;
7639           }
7640         }
7641
7642 #ifdef SUPPORT_I18N
7643       if (message_smtputf8)
7644         fputs(topt & topt_no_body ? "Content-type: message/global-headers\n\n"
7645                                   : "Content-type: message/global\n\n",
7646               f);
7647       else
7648 #endif
7649         fputs(topt & topt_no_body ? "Content-type: text/rfc822-headers\n\n"
7650                                   : "Content-type: message/rfc822\n\n",
7651               f);
7652
7653       fflush(f);
7654       transport_filter_argv = NULL;   /* Just in case */
7655       return_path = sender_address;   /* In case not previously set */
7656         {                             /* Dummy transport for headers add */
7657         transport_ctx tctx = {0};
7658         transport_instance tb = {0};
7659
7660         tctx.tblock = &tb;
7661         tctx.options = topt;
7662         tb.add_headers = dsnnotifyhdr;
7663
7664         transport_write_message(fileno(f), &tctx, 0);
7665         }
7666       fflush(f);
7667
7668       /* we never add the final text. close the file */
7669       if (emf)
7670         (void)fclose(emf);
7671
7672       fprintf(f, "\n--%s--\n", bound);
7673
7674       /* Close the file, which should send an EOF to the child process
7675       that is receiving the message. Wait for it to finish. */
7676
7677       (void)fclose(f);
7678       rc = child_close(pid, 0);     /* Waits for child to close, no timeout */
7679
7680       /* In the test harness, let the child do it's thing first. */
7681
7682       if (running_in_test_harness) millisleep(500);
7683
7684       /* If the process failed, there was some disaster in setting up the
7685       error message. Unless the message is very old, ensure that addr_defer
7686       is non-null, which will have the effect of leaving the message on the
7687       spool. The failed addresses will get tried again next time. However, we
7688       don't really want this to happen too often, so freeze the message unless
7689       there are some genuine deferred addresses to try. To do this we have
7690       to call spool_write_header() here, because with no genuine deferred
7691       addresses the normal code below doesn't get run. */
7692
7693       if (rc != 0)
7694         {
7695         uschar *s = US"";
7696         if (now - received_time < retry_maximum_timeout && !addr_defer)
7697           {
7698           addr_defer = (address_item *)(+1);
7699           deliver_freeze = TRUE;
7700           deliver_frozen_at = time(NULL);
7701           /* Panic-dies on error */
7702           (void)spool_write_header(message_id, SW_DELIVERING, NULL);
7703           s = US" (frozen)";
7704           }
7705         deliver_msglog("Process failed (%d) when writing error message "
7706           "to %s%s", rc, bounce_recipient, s);
7707         log_write(0, LOG_MAIN, "Process failed (%d) when writing error message "
7708           "to %s%s", rc, bounce_recipient, s);
7709         }
7710
7711       /* The message succeeded. Ensure that the recipients that failed are
7712       now marked finished with on the spool and their parents updated. */
7713
7714       else
7715         {
7716         for (addr = handled_addr; addr; addr = addr->next)
7717           {
7718           address_done(addr, logtod);
7719           child_done(addr, logtod);
7720           }
7721         /* Panic-dies on error */
7722         (void)spool_write_header(message_id, SW_DELIVERING, NULL);
7723         }
7724       }
7725     }
7726   }
7727
7728 disable_logging = FALSE;  /* In case left set */
7729
7730 /* Come here from the mua_wrapper case if routing goes wrong */
7731
7732 DELIVERY_TIDYUP:
7733
7734 /* If there are now no deferred addresses, we are done. Preserve the
7735 message log if so configured, and we are using them. Otherwise, sling it.
7736 Then delete the message itself. */
7737
7738 if (!addr_defer)
7739   {
7740   uschar * fname;
7741
7742   if (message_logs)
7743     {
7744     fname = spool_fname(US"msglog", message_subdir, id, US"");
7745     if (preserve_message_logs)
7746       {
7747       int rc;
7748       uschar * moname = spool_fname(US"msglog.OLD", US"", id, US"");
7749
7750       if ((rc = Urename(fname, moname)) < 0)
7751         {
7752         (void)directory_make(spool_directory,
7753                               spool_sname(US"msglog.OLD", US""),
7754                               MSGLOG_DIRECTORY_MODE, TRUE);
7755         rc = Urename(fname, moname);
7756         }
7757       if (rc < 0)
7758         log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to move %s to the "
7759           "msglog.OLD directory", fname);
7760       }
7761     else
7762       if (Uunlink(fname) < 0)
7763         log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to unlink %s: %s",
7764                   fname, strerror(errno));
7765     }
7766
7767   /* Remove the two message files. */
7768
7769   fname = spool_fname(US"input", message_subdir, id, US"-D");
7770   if (Uunlink(fname) < 0)
7771     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to unlink %s: %s",
7772       fname, strerror(errno));
7773   fname = spool_fname(US"input", message_subdir, id, US"-H");
7774   if (Uunlink(fname) < 0)
7775     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to unlink %s: %s",
7776       fname, strerror(errno));
7777
7778   /* Log the end of this message, with queue time if requested. */
7779
7780   if (LOGGING(queue_time_overall))
7781     log_write(0, LOG_MAIN, "Completed QT=%s",
7782       readconf_printtime( (int) ((long)time(NULL) - (long)received_time)) );
7783   else
7784     log_write(0, LOG_MAIN, "Completed");
7785
7786   /* Unset deliver_freeze so that we won't try to move the spool files further down */
7787   deliver_freeze = FALSE;
7788
7789 #ifndef DISABLE_EVENT
7790   (void) event_raise(event_action, US"msg:complete", NULL);
7791 #endif
7792   }
7793
7794 /* If there are deferred addresses, we are keeping this message because it is
7795 not yet completed. Lose any temporary files that were catching output from
7796 pipes for any of the deferred addresses, handle one-time aliases, and see if
7797 the message has been on the queue for so long that it is time to send a warning
7798 message to the sender, unless it is a mailer-daemon. If all deferred addresses
7799 have the same domain, we can set deliver_domain for the expansion of
7800 delay_warning_ condition - if any of them are pipes, files, or autoreplies, use
7801 the parent's domain.
7802
7803 If all the deferred addresses have an error number that indicates "retry time
7804 not reached", skip sending the warning message, because it won't contain the
7805 reason for the delay. It will get sent at the next real delivery attempt.
7806 However, if at least one address has tried, we'd better include all of them in
7807 the message.
7808
7809 If we can't make a process to send the message, don't worry.
7810
7811 For mailing list expansions we want to send the warning message to the
7812 mailing list manager. We can't do a perfect job here, as some addresses may
7813 have different errors addresses, but if we take the errors address from
7814 each deferred address it will probably be right in most cases.
7815
7816 If addr_defer == +1, it means there was a problem sending an error message
7817 for failed addresses, and there were no "real" deferred addresses. The value
7818 was set just to keep the message on the spool, so there is nothing to do here.
7819 */
7820
7821 else if (addr_defer != (address_item *)(+1))
7822   {
7823   address_item *addr;
7824   uschar *recipients = US"";
7825   BOOL delivery_attempted = FALSE;
7826
7827   deliver_domain = testflag(addr_defer, af_pfr)
7828     ? addr_defer->parent->domain : addr_defer->domain;
7829
7830   for (addr = addr_defer; addr; addr = addr->next)
7831     {
7832     address_item *otaddr;
7833
7834     if (addr->basic_errno > ERRNO_RETRY_BASE) delivery_attempted = TRUE;
7835
7836     if (deliver_domain)
7837       {
7838       const uschar *d = testflag(addr, af_pfr)
7839         ? addr->parent->domain : addr->domain;
7840
7841       /* The domain may be unset for an address that has never been routed
7842       because the system filter froze the message. */
7843
7844       if (!d || Ustrcmp(d, deliver_domain) != 0)
7845         deliver_domain = NULL;
7846       }
7847
7848     if (addr->return_filename) Uunlink(addr->return_filename);
7849
7850     /* Handle the case of one-time aliases. If any address in the ancestry
7851     of this one is flagged, ensure it is in the recipients list, suitably
7852     flagged, and that its parent is marked delivered. */
7853
7854     for (otaddr = addr; otaddr; otaddr = otaddr->parent)
7855       if (otaddr->onetime_parent) break;
7856
7857     if (otaddr)
7858       {
7859       int i;
7860       int t = recipients_count;
7861
7862       for (i = 0; i < recipients_count; i++)
7863         {
7864         uschar *r = recipients_list[i].address;
7865         if (Ustrcmp(otaddr->onetime_parent, r) == 0) t = i;
7866         if (Ustrcmp(otaddr->address, r) == 0) break;
7867         }
7868
7869       /* Didn't find the address already in the list, and did find the
7870       ultimate parent's address in the list. After adding the recipient,
7871       update the errors address in the recipients list. */
7872
7873       if (i >= recipients_count && t < recipients_count)
7874         {
7875         DEBUG(D_deliver) debug_printf("one_time: adding %s in place of %s\n",
7876           otaddr->address, otaddr->parent->address);
7877         receive_add_recipient(otaddr->address, t);
7878         recipients_list[recipients_count-1].errors_to = otaddr->prop.errors_address;
7879         tree_add_nonrecipient(otaddr->parent->address);
7880         update_spool = TRUE;
7881         }
7882       }
7883
7884     /* Except for error messages, ensure that either the errors address for
7885     this deferred address or, if there is none, the sender address, is on the
7886     list of recipients for a warning message. */
7887
7888     if (sender_address[0] != 0)
7889       if (addr->prop.errors_address)
7890         {
7891         if (Ustrstr(recipients, addr->prop.errors_address) == NULL)
7892           recipients = string_sprintf("%s%s%s", recipients,
7893             (recipients[0] == 0)? "" : ",", addr->prop.errors_address);
7894         }
7895       else
7896         {
7897         if (Ustrstr(recipients, sender_address) == NULL)
7898           recipients = string_sprintf("%s%s%s", recipients,
7899             (recipients[0] == 0)? "" : ",", sender_address);
7900         }
7901     }
7902
7903   /* Send a warning message if the conditions are right. If the condition check
7904   fails because of a lookup defer, there is nothing we can do. The warning
7905   is not sent. Another attempt will be made at the next delivery attempt (if
7906   it also defers). */
7907
7908   if (  !queue_2stage
7909      && delivery_attempted
7910      && (  ((addr_defer->dsn_flags & rf_dsnflags) == 0)
7911         || (addr_defer->dsn_flags & rf_notify_delay) == rf_notify_delay
7912         )
7913      && delay_warning[1] > 0
7914      && sender_address[0] != 0
7915      && (  !delay_warning_condition
7916         || expand_check_condition(delay_warning_condition,
7917             US"delay_warning", US"option")
7918         )
7919      )
7920     {
7921     int count;
7922     int show_time;
7923     int queue_time = time(NULL) - received_time;
7924
7925     /* When running in the test harness, there's an option that allows us to
7926     fudge this time so as to get repeatability of the tests. Take the first
7927     time off the list. In queue runs, the list pointer gets updated in the
7928     calling process. */
7929
7930     if (running_in_test_harness && fudged_queue_times[0] != 0)
7931       {
7932       int qt = readconf_readtime(fudged_queue_times, '/', FALSE);
7933       if (qt >= 0)
7934         {
7935         DEBUG(D_deliver) debug_printf("fudged queue_times = %s\n",
7936           fudged_queue_times);
7937         queue_time = qt;
7938         }
7939       }
7940
7941     /* See how many warnings we should have sent by now */
7942
7943     for (count = 0; count < delay_warning[1]; count++)
7944       if (queue_time < delay_warning[count+2]) break;
7945
7946     show_time = delay_warning[count+1];
7947
7948     if (count >= delay_warning[1])
7949       {
7950       int extra;
7951       int last_gap = show_time;
7952       if (count > 1) last_gap -= delay_warning[count];
7953       extra = (queue_time - delay_warning[count+1])/last_gap;
7954       show_time += last_gap * extra;
7955       count += extra;
7956       }
7957
7958     DEBUG(D_deliver)
7959       {
7960       debug_printf("time on queue = %s\n", readconf_printtime(queue_time));
7961       debug_printf("warning counts: required %d done %d\n", count,
7962         warning_count);
7963       }
7964
7965     /* We have computed the number of warnings there should have been by now.
7966     If there haven't been enough, send one, and up the count to what it should
7967     have been. */
7968
7969     if (warning_count < count)
7970       {
7971       header_line *h;
7972       int fd;
7973       pid_t pid = child_open_exim(&fd);
7974
7975       if (pid > 0)
7976         {
7977         uschar *wmf_text;
7978         FILE *wmf = NULL;
7979         FILE *f = fdopen(fd, "wb");
7980         uschar * bound;
7981         transport_ctx tctx = {0};
7982
7983         if (warn_message_file)
7984           if (!(wmf = Ufopen(warn_message_file, "rb")))
7985             log_write(0, LOG_MAIN|LOG_PANIC, "Failed to open %s for warning "
7986               "message texts: %s", warn_message_file, strerror(errno));
7987
7988         warnmsg_recipients = recipients;
7989         warnmsg_delay = queue_time < 120*60
7990           ? string_sprintf("%d minutes", show_time/60)
7991           : string_sprintf("%d hours", show_time/3600);
7992
7993         if (errors_reply_to)
7994           fprintf(f, "Reply-To: %s\n", errors_reply_to);
7995         fprintf(f, "Auto-Submitted: auto-replied\n");
7996         moan_write_from(f);
7997         fprintf(f, "To: %s\n", recipients);
7998
7999         /* generated boundary string and output MIME-Headers */
8000         bound = string_sprintf(TIME_T_FMT "-eximdsn-%d", time(NULL), rand());
8001
8002         fprintf(f, "Content-Type: multipart/report;"
8003             " report-type=delivery-status; boundary=%s\n"
8004             "MIME-Version: 1.0\n",
8005           bound);
8006
8007         if ((wmf_text = next_emf(wmf, US"header")))
8008           fprintf(f, "%s\n", wmf_text);
8009         else
8010           fprintf(f, "Subject: Warning: message %s delayed %s\n\n",
8011             message_id, warnmsg_delay);
8012
8013         /* output human readable part as text/plain section */
8014         fprintf(f, "--%s\n"
8015             "Content-type: text/plain; charset=us-ascii\n\n",
8016           bound);
8017
8018         if ((wmf_text = next_emf(wmf, US"intro")))
8019           fprintf(f, "%s", CS wmf_text);
8020         else
8021           {
8022           fprintf(f,
8023 "This message was created automatically by mail delivery software.\n");
8024
8025           if (Ustrcmp(recipients, sender_address) == 0)
8026             fprintf(f,
8027 "A message that you sent has not yet been delivered to one or more of its\n"
8028 "recipients after more than ");
8029
8030           else
8031             fprintf(f,
8032 "A message sent by\n\n  <%s>\n\n"
8033 "has not yet been delivered to one or more of its recipients after more than \n",
8034               sender_address);
8035
8036           fprintf(f, "%s on the queue on %s.\n\n"
8037               "The message identifier is:     %s\n",
8038             warnmsg_delay, primary_hostname, message_id);
8039
8040           for (h = header_list; h; h = h->next)
8041             if (strncmpic(h->text, US"Subject:", 8) == 0)
8042               fprintf(f, "The subject of the message is: %s", h->text + 9);
8043             else if (strncmpic(h->text, US"Date:", 5) == 0)
8044               fprintf(f, "The date of the message is:    %s", h->text + 6);
8045           fputc('\n', f);
8046
8047           fprintf(f, "The address%s to which the message has not yet been "
8048             "delivered %s:\n",
8049             !addr_defer->next ? "" : "es",
8050             !addr_defer->next ? "is": "are");
8051           }
8052
8053         /* List the addresses, with error information if allowed */
8054
8055         /* store addr_defer for machine readable part */
8056         address_item *addr_dsndefer = addr_defer;
8057         fputc('\n', f);
8058         while (addr_defer)
8059           {
8060           address_item *addr = addr_defer;
8061           addr_defer = addr->next;
8062           if (print_address_information(addr, f, US"  ", US"\n    ", US""))
8063             print_address_error(addr, f, US"Delay reason: ");
8064           fputc('\n', f);
8065           }
8066         fputc('\n', f);
8067
8068         /* Final text */
8069
8070         if (wmf)
8071           {
8072           if ((wmf_text = next_emf(wmf, US"final")))
8073             fprintf(f, "%s", CS wmf_text);
8074           (void)fclose(wmf);
8075           }
8076         else
8077           {
8078           fprintf(f,
8079 "No action is required on your part. Delivery attempts will continue for\n"
8080 "some time, and this warning may be repeated at intervals if the message\n"
8081 "remains undelivered. Eventually the mail delivery software will give up,\n"
8082 "and when that happens, the message will be returned to you.\n");
8083           }
8084
8085         /* output machine readable part */
8086         fprintf(f, "\n--%s\n"
8087             "Content-type: message/delivery-status\n\n"
8088             "Reporting-MTA: dns; %s\n",
8089           bound,
8090           smtp_active_hostname);
8091
8092
8093         if (dsn_envid)
8094           {
8095           /* must be decoded from xtext: see RFC 3461:6.3a */
8096           uschar *xdec_envid;
8097           if (auth_xtextdecode(dsn_envid, &xdec_envid) > 0)
8098             fprintf(f,"Original-Envelope-ID: %s\n", dsn_envid);
8099           else
8100             fprintf(f,"X-Original-Envelope-ID: error decoding xtext formatted ENVID\n");
8101           }
8102         fputc('\n', f);
8103
8104         for ( ; addr_dsndefer; addr_dsndefer = addr_dsndefer->next)
8105           {
8106           if (addr_dsndefer->dsn_orcpt)
8107             fprintf(f, "Original-Recipient: %s\n", addr_dsndefer->dsn_orcpt);
8108
8109           fprintf(f, "Action: delayed\n"
8110               "Final-Recipient: rfc822;%s\n"
8111               "Status: 4.0.0\n",
8112             addr_dsndefer->address);
8113           if (addr_dsndefer->host_used && addr_dsndefer->host_used->name)
8114             {
8115             fprintf(f, "Remote-MTA: dns; %s\n",
8116                     addr_dsndefer->host_used->name);
8117             print_dsn_diagnostic_code(addr_dsndefer, f);
8118             }
8119           fputc('\n', f);
8120           }
8121
8122         fprintf(f, "--%s\n"
8123             "Content-type: text/rfc822-headers\n\n",
8124           bound);
8125
8126         fflush(f);
8127         /* header only as required by RFC. only failure DSN needs to honor RET=FULL */
8128         tctx.options = topt_add_return_path | topt_no_body;
8129         transport_filter_argv = NULL;   /* Just in case */
8130         return_path = sender_address;   /* In case not previously set */
8131
8132         /* Write the original email out */
8133         transport_write_message(fileno(f), &tctx, 0);
8134         fflush(f);
8135
8136         fprintf(f,"\n--%s--\n", bound);
8137
8138         fflush(f);
8139
8140         /* Close and wait for child process to complete, without a timeout.
8141         If there's an error, don't update the count. */
8142
8143         (void)fclose(f);
8144         if (child_close(pid, 0) == 0)
8145           {
8146           warning_count = count;
8147           update_spool = TRUE;    /* Ensure spool rewritten */
8148           }
8149         }
8150       }
8151     }
8152
8153   /* Clear deliver_domain */
8154
8155   deliver_domain = NULL;
8156
8157   /* If this was a first delivery attempt, unset the first time flag, and
8158   ensure that the spool gets updated. */
8159
8160   if (deliver_firsttime)
8161     {
8162     deliver_firsttime = FALSE;
8163     update_spool = TRUE;
8164     }
8165
8166   /* If delivery was frozen and freeze_tell is set, generate an appropriate
8167   message, unless the message is a local error message (to avoid loops). Then
8168   log the freezing. If the text in "frozen_info" came from a system filter,
8169   it has been escaped into printing characters so as not to mess up log lines.
8170   For the "tell" message, we turn \n back into newline. Also, insert a newline
8171   near the start instead of the ": " string. */
8172
8173   if (deliver_freeze)
8174     {
8175     if (freeze_tell && freeze_tell[0] != 0 && !local_error_message)
8176       {
8177       uschar *s = string_copy(frozen_info);
8178       uschar *ss = Ustrstr(s, " by the system filter: ");
8179
8180       if (ss != NULL)
8181         {
8182         ss[21] = '.';
8183         ss[22] = '\n';
8184         }
8185
8186       ss = s;
8187       while (*ss != 0)
8188         {
8189         if (*ss == '\\' && ss[1] == 'n')
8190           {
8191           *ss++ = ' ';
8192           *ss++ = '\n';
8193           }
8194         else ss++;
8195         }
8196       moan_tell_someone(freeze_tell, addr_defer, US"Message frozen",
8197         "Message %s has been frozen%s.\nThe sender is <%s>.\n", message_id,
8198         s, sender_address);
8199       }
8200
8201     /* Log freezing just before we update the -H file, to minimize the chance
8202     of a race problem. */
8203
8204     deliver_msglog("*** Frozen%s\n", frozen_info);
8205     log_write(0, LOG_MAIN, "Frozen%s", frozen_info);
8206     }
8207
8208   /* If there have been any updates to the non-recipients list, or other things
8209   that get written to the spool, we must now update the spool header file so
8210   that it has the right information for the next delivery attempt. If there
8211   was more than one address being delivered, the header_change update is done
8212   earlier, in case one succeeds and then something crashes. */
8213
8214   DEBUG(D_deliver)
8215     debug_printf("delivery deferred: update_spool=%d header_rewritten=%d\n",
8216       update_spool, header_rewritten);
8217
8218   if (update_spool || header_rewritten)
8219     /* Panic-dies on error */
8220     (void)spool_write_header(message_id, SW_DELIVERING, NULL);
8221   }
8222
8223 /* Finished with the message log. If the message is complete, it will have
8224 been unlinked or renamed above. */
8225
8226 if (message_logs) (void)fclose(message_log);
8227
8228 /* Now we can close and remove the journal file. Its only purpose is to record
8229 successfully completed deliveries asap so that this information doesn't get
8230 lost if Exim (or the machine) crashes. Forgetting about a failed delivery is
8231 not serious, as trying it again is not harmful. The journal might not be open
8232 if all addresses were deferred at routing or directing. Nevertheless, we must
8233 remove it if it exists (may have been lying around from a crash during the
8234 previous delivery attempt). We don't remove the journal if a delivery
8235 subprocess failed to pass back delivery information; this is controlled by
8236 the remove_journal flag. When the journal is left, we also don't move the
8237 message off the main spool if frozen and the option is set. It should get moved
8238 at the next attempt, after the journal has been inspected. */
8239
8240 if (journal_fd >= 0) (void)close(journal_fd);
8241
8242 if (remove_journal)
8243   {
8244   uschar * fname = spool_fname(US"input", message_subdir, id, US"-J");
8245
8246   if (Uunlink(fname) < 0 && errno != ENOENT)
8247     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to unlink %s: %s", fname,
8248       strerror(errno));
8249
8250   /* Move the message off the spool if reqested */
8251
8252 #ifdef SUPPORT_MOVE_FROZEN_MESSAGES
8253   if (deliver_freeze && move_frozen_messages)
8254     (void)spool_move_message(id, message_subdir, US"", US"F");
8255 #endif
8256   }
8257
8258 /* Closing the data file frees the lock; if the file has been unlinked it
8259 will go away. Otherwise the message becomes available for another process
8260 to try delivery. */
8261
8262 (void)close(deliver_datafile);
8263 deliver_datafile = -1;
8264 DEBUG(D_deliver) debug_printf("end delivery of %s\n", id);
8265
8266 /* It is unlikely that there will be any cached resources, since they are
8267 released after routing, and in the delivery subprocesses. However, it's
8268 possible for an expansion for something afterwards (for example,
8269 expand_check_condition) to do a lookup. We must therefore be sure everything is
8270 released. */
8271
8272 search_tidyup();
8273 acl_where = ACL_WHERE_UNKNOWN;
8274 return final_yield;
8275 }
8276
8277
8278
8279 void
8280 deliver_init(void)
8281 {
8282 if (!regex_PIPELINING) regex_PIPELINING =
8283   regex_must_compile(US"\\n250[\\s\\-]PIPELINING(\\s|\\n|$)", FALSE, TRUE);
8284
8285 if (!regex_SIZE) regex_SIZE =
8286   regex_must_compile(US"\\n250[\\s\\-]SIZE(\\s|\\n|$)", FALSE, TRUE);
8287
8288 if (!regex_AUTH) regex_AUTH =
8289   regex_must_compile(US"\\n250[\\s\\-]AUTH\\s+([\\-\\w\\s]+)(?:\\n|$)",
8290     FALSE, TRUE);
8291
8292 #ifdef SUPPORT_TLS
8293 if (!regex_STARTTLS) regex_STARTTLS =
8294   regex_must_compile(US"\\n250[\\s\\-]STARTTLS(\\s|\\n|$)", FALSE, TRUE);
8295 #endif
8296
8297 if (!regex_CHUNKING) regex_CHUNKING =
8298   regex_must_compile(US"\\n250[\\s\\-]CHUNKING(\\s|\\n|$)", FALSE, TRUE);
8299
8300 #ifndef DISABLE_PRDR
8301 if (!regex_PRDR) regex_PRDR =
8302   regex_must_compile(US"\\n250[\\s\\-]PRDR(\\s|\\n|$)", FALSE, TRUE);
8303 #endif
8304
8305 #ifdef SUPPORT_I18N
8306 if (!regex_UTF8) regex_UTF8 =
8307   regex_must_compile(US"\\n250[\\s\\-]SMTPUTF8(\\s|\\n|$)", FALSE, TRUE);
8308 #endif
8309
8310 if (!regex_DSN) regex_DSN  =
8311   regex_must_compile(US"\\n250[\\s\\-]DSN(\\s|\\n|$)", FALSE, TRUE);
8312
8313 if (!regex_IGNOREQUOTA) regex_IGNOREQUOTA =
8314   regex_must_compile(US"\\n250[\\s\\-]IGNOREQUOTA(\\s|\\n|$)", FALSE, TRUE);
8315 }
8316
8317
8318 uschar *
8319 deliver_get_sender_address (uschar * id)
8320 {
8321 int rc;
8322 uschar * new_sender_address,
8323        * save_sender_address;
8324 BOOL save_qr = queue_running;
8325 uschar * spoolname;
8326
8327 /* make spool_open_datafile non-noisy on fail */
8328
8329 queue_running = TRUE;
8330
8331 /* Side effect: message_subdir is set for the (possibly split) spool directory */
8332
8333 deliver_datafile = spool_open_datafile(id);
8334 queue_running = save_qr;
8335 if (deliver_datafile < 0)
8336   return NULL;
8337
8338 /* Save and restore the global sender_address.  I'm not sure if we should
8339 not save/restore all the other global variables too, because
8340 spool_read_header() may change all of them. But OTOH, when this
8341 deliver_get_sender_address() gets called, the current message is done
8342 already and nobody needs the globals anymore. (HS12, 2015-08-21) */
8343
8344 spoolname = string_sprintf("%s-H", id);
8345 save_sender_address = sender_address;
8346
8347 rc = spool_read_header(spoolname, TRUE, TRUE);
8348
8349 new_sender_address = sender_address;
8350 sender_address = save_sender_address;
8351
8352 if (rc != spool_read_OK)
8353   return NULL;
8354
8355 assert(new_sender_address);
8356
8357 (void)close(deliver_datafile);
8358 deliver_datafile = -1;
8359
8360 return new_sender_address;
8361 }
8362
8363 /* vi: aw ai sw=2
8364 */
8365 /* End of deliver.c */