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