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