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