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