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