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