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