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