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