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