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