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