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