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