d2aad542a1a855ab98ac571f65611f34abd6bc7d
[exim.git] / src / src / transports / autoreply.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2015 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8
9 #include "../exim.h"
10 #include "autoreply.h"
11
12
13
14 /* Options specific to the autoreply transport. They must be in alphabetic
15 order (note that "_" comes before the lower case letters). Those starting
16 with "*" are not settable by the user but are used by the option-reading
17 software for alternative value types. Some options are publicly visible and so
18 are stored in the driver instance block. These are flagged with opt_public. */
19
20 optionlist autoreply_transport_options[] = {
21   { "bcc",               opt_stringptr,
22       (void *)offsetof(autoreply_transport_options_block, bcc) },
23   { "cc",                opt_stringptr,
24       (void *)offsetof(autoreply_transport_options_block, cc) },
25   { "file",              opt_stringptr,
26       (void *)offsetof(autoreply_transport_options_block, file) },
27   { "file_expand",     opt_bool,
28       (void *)offsetof(autoreply_transport_options_block, file_expand) },
29   { "file_optional",     opt_bool,
30       (void *)offsetof(autoreply_transport_options_block, file_optional) },
31   { "from",              opt_stringptr,
32       (void *)offsetof(autoreply_transport_options_block, from) },
33   { "headers",           opt_stringptr,
34       (void *)offsetof(autoreply_transport_options_block, headers) },
35   { "log",               opt_stringptr,
36       (void *)offsetof(autoreply_transport_options_block, logfile) },
37   { "mode",              opt_octint,
38       (void *)offsetof(autoreply_transport_options_block, mode) },
39   { "never_mail",        opt_stringptr,
40       (void *)offsetof(autoreply_transport_options_block, never_mail) },
41   { "once",              opt_stringptr,
42       (void *)offsetof(autoreply_transport_options_block, oncelog) },
43   { "once_file_size",    opt_int,
44       (void *)offsetof(autoreply_transport_options_block, once_file_size) },
45   { "once_repeat",       opt_stringptr,
46       (void *)offsetof(autoreply_transport_options_block, once_repeat) },
47   { "reply_to",          opt_stringptr,
48       (void *)offsetof(autoreply_transport_options_block, reply_to) },
49   { "return_message",    opt_bool,
50       (void *)offsetof(autoreply_transport_options_block, return_message) },
51   { "subject",           opt_stringptr,
52       (void *)offsetof(autoreply_transport_options_block, subject) },
53   { "text",              opt_stringptr,
54       (void *)offsetof(autoreply_transport_options_block, text) },
55   { "to",                opt_stringptr,
56       (void *)offsetof(autoreply_transport_options_block, to) },
57 };
58
59 /* Size of the options list. An extern variable has to be used so that its
60 address can appear in the tables drtables.c. */
61
62 int autoreply_transport_options_count =
63   sizeof(autoreply_transport_options)/sizeof(optionlist);
64
65 /* Default private options block for the autoreply transport. */
66
67 autoreply_transport_options_block autoreply_transport_option_defaults = {
68   NULL,           /* from */
69   NULL,           /* reply_to */
70   NULL,           /* to */
71   NULL,           /* cc */
72   NULL,           /* bcc */
73   NULL,           /* subject */
74   NULL,           /* headers */
75   NULL,           /* text */
76   NULL,           /* file */
77   NULL,           /* logfile */
78   NULL,           /* oncelog */
79   NULL,           /* once_repeat */
80   NULL,           /* never_mail */
81   0600,           /* mode */
82   0,              /* once_file_size */
83   FALSE,          /* file_expand */
84   FALSE,          /* file_optional */
85   FALSE           /* return message */
86 };
87
88
89
90 /* Type of text for the checkexpand() function */
91
92 enum { cke_text, cke_hdr, cke_file };
93
94
95
96 /*************************************************
97 *          Initialization entry point            *
98 *************************************************/
99
100 /* Called for each instance, after its options have been read, to
101 enable consistency checks to be done, or anything else that needs
102 to be set up. */
103
104 void
105 autoreply_transport_init(transport_instance *tblock)
106 {
107 /*
108 autoreply_transport_options_block *ob =
109   (autoreply_transport_options_block *)(tblock->options_block);
110 */
111
112 /* If a fixed uid field is set, then a gid field must also be set. */
113
114 if (tblock->uid_set && !tblock->gid_set && tblock->expand_gid == NULL)
115   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
116     "user set without group for the %s transport", tblock->name);
117 }
118
119
120
121
122 /*************************************************
123 *          Expand string and check               *
124 *************************************************/
125
126 /* If the expansion fails, the error is set up in the address. Expanded
127 strings must be checked to ensure they contain only printing characters
128 and white space. If not, the function fails.
129
130 Arguments:
131    s         string to expand
132    addr      address that is being worked on
133    name      transport name, for error text
134    type      type, for checking content:
135                cke_text => no check
136                cke_hdr  => header, allow \n + whitespace
137                cke_file => file name, no non-printers allowed
138
139 Returns:     expanded string if expansion succeeds;
140              NULL otherwise
141 */
142
143 static uschar *
144 checkexpand(uschar *s, address_item *addr, uschar *name, int type)
145 {
146 uschar *t;
147 uschar *ss = expand_string(s);
148
149 if (ss == NULL)
150   {
151   addr->transport_return = FAIL;
152   addr->message = string_sprintf("Expansion of \"%s\" failed in %s transport: "
153     "%s", s, name, expand_string_message);
154   return NULL;
155   }
156
157 if (type != cke_text) for (t = ss; *t != 0; t++)
158   {
159   int c = *t;
160   const uschar * sp;
161   if (mac_isprint(c)) continue;
162   if (type == cke_hdr && c == '\n' && (t[1] == ' ' || t[1] == '\t')) continue;
163   sp = string_printing(s);
164   addr->transport_return = FAIL;
165   addr->message = string_sprintf("Expansion of \"%s\" in %s transport "
166     "contains non-printing character %d", sp, name, c);
167   return NULL;
168   }
169
170 return ss;
171 }
172
173
174
175
176 /*************************************************
177 *          Check a header line for never_mail    *
178 *************************************************/
179
180 /* This is called to check to, cc, and bcc for addresses in the never_mail
181 list. Any that are found are removed.
182
183 Arguments:
184   listptr     points to the list of addresses
185   never_mail  an address list, already expanded
186
187 Returns:      nothing
188 */
189
190 static void
191 check_never_mail(uschar **listptr, const uschar *never_mail)
192 {
193 uschar *s = *listptr;
194
195 while (*s != 0)
196   {
197   uschar *error, *next;
198   uschar *e = parse_find_address_end(s, FALSE);
199   int terminator = *e;
200   int start, end, domain, rc;
201
202   /* Temporarily terminate the string at the address end while extracting
203   the operative address within. */
204
205   *e = 0;
206   next = parse_extract_address(s, &error, &start, &end, &domain, FALSE);
207   *e = terminator;
208
209   /* If there is some kind of syntax error, just give up on this header
210   line. */
211
212   if (next == NULL) break;
213
214   /* See if the address is on the never_mail list */
215
216   rc = match_address_list(next,         /* address to check */
217                           TRUE,         /* start caseless */
218                           FALSE,        /* don't expand the list */
219                           &never_mail,  /* the list */
220                           NULL,         /* no caching */
221                           -1,           /* no expand setup */
222                           0,            /* separator from list */
223                           NULL);        /* no lookup value return */
224
225   if (rc == OK)                         /* Remove this address */
226     {
227     DEBUG(D_transport)
228       debug_printf("discarding recipient %s (matched never_mail)\n", next);
229     if (terminator == ',') e++;
230     memmove(s, e, Ustrlen(e) + 1);
231     }
232   else                                  /* Skip over this address */
233     {
234     s = e;
235     if (terminator == ',') s++;
236     }
237   }
238
239 /* Check to see if we removed the last address, leaving a terminating comma
240 that needs to be removed */
241
242 s = *listptr + Ustrlen(*listptr);
243 while (s > *listptr && (isspace(s[-1]) || s[-1] == ',')) s--;
244 *s = 0;
245
246 /* Check to see if there any addresses left; if not, set NULL */
247
248 s = *listptr;
249 while (s != 0 && isspace(*s)) s++;
250 if (*s == 0) *listptr = NULL;
251 }
252
253
254
255 /*************************************************
256 *              Main entry point                  *
257 *************************************************/
258
259 /* See local README for interface details. This transport always returns
260 FALSE, indicating that the top address has the status for all - though in fact
261 this transport can handle only one address at at time anyway. */
262
263 BOOL
264 autoreply_transport_entry(
265   transport_instance *tblock,      /* data for this instantiation */
266   address_item *addr)              /* address we are working on */
267 {
268 int fd, pid, rc;
269 int cache_fd = -1;
270 int log_fd = -1;
271 int cache_size = 0;
272 int add_size = 0;
273 EXIM_DB *dbm_file = NULL;
274 BOOL file_expand, return_message;
275 uschar *from, *reply_to, *to, *cc, *bcc, *subject, *headers, *text, *file;
276 uschar *logfile, *oncelog;
277 uschar *cache_buff = NULL;
278 uschar *cache_time = NULL;
279 uschar *message_id = NULL;
280 header_line *h;
281 time_t now = time(NULL);
282 time_t once_repeat_sec = 0;
283 FILE *f;
284 FILE *ff = NULL;
285
286 autoreply_transport_options_block *ob =
287   (autoreply_transport_options_block *)(tblock->options_block);
288
289 DEBUG(D_transport) debug_printf("%s transport entered\n", tblock->name);
290
291 /* Set up for the good case */
292
293 addr->transport_return = OK;
294 addr->basic_errno = 0;
295
296 /* If the address is pointing to a reply block, then take all the data
297 from that block. It has typically been set up by a mail filter processing
298 router. Otherwise, the data must be supplied by this transport, and
299 it has to be expanded here. */
300
301 if (addr->reply != NULL)
302   {
303   DEBUG(D_transport) debug_printf("taking data from address\n");
304   from = addr->reply->from;
305   reply_to = addr->reply->reply_to;
306   to = addr->reply->to;
307   cc = addr->reply->cc;
308   bcc = addr->reply->bcc;
309   subject = addr->reply->subject;
310   headers = addr->reply->headers;
311   text = addr->reply->text;
312   file = addr->reply->file;
313   logfile = addr->reply->logfile;
314   oncelog = addr->reply->oncelog;
315   once_repeat_sec = addr->reply->once_repeat;
316   file_expand = addr->reply->file_expand;
317   expand_forbid = addr->reply->expand_forbid;
318   return_message = addr->reply->return_message;
319   }
320 else
321   {
322   uschar *oncerepeat = ob->once_repeat;
323
324   DEBUG(D_transport) debug_printf("taking data from transport\n");
325   from = ob->from;
326   reply_to = ob->reply_to;
327   to = ob->to;
328   cc = ob->cc;
329   bcc = ob->bcc;
330   subject = ob->subject;
331   headers = ob->headers;
332   text = ob->text;
333   file = ob->file;
334   logfile = ob->logfile;
335   oncelog = ob->oncelog;
336   file_expand = ob->file_expand;
337   return_message = ob->return_message;
338
339   if ((from  != NULL &&
340         (from = checkexpand(from, addr, tblock->name, cke_hdr)) == NULL) ||
341       (reply_to    != NULL &&
342         (reply_to = checkexpand(reply_to, addr, tblock->name, cke_hdr)) == NULL) ||
343       (to    != NULL &&
344         (to = checkexpand(to, addr, tblock->name, cke_hdr)) == NULL) ||
345       (cc    != NULL &&
346         (cc = checkexpand(cc, addr, tblock->name, cke_hdr)) == NULL) ||
347       (bcc   != NULL &&
348         (bcc = checkexpand(bcc, addr, tblock->name, cke_hdr)) == NULL) ||
349       (subject   != NULL &&
350         (subject = checkexpand(subject, addr, tblock->name, cke_hdr)) == NULL) ||
351       (headers != NULL &&
352         (headers = checkexpand(headers, addr, tblock->name, cke_text)) == NULL) ||
353       (text  != NULL &&
354         (text = checkexpand(text, addr, tblock->name, cke_text)) == NULL) ||
355       (file  != NULL &&
356         (file = checkexpand(file, addr, tblock->name, cke_file)) == NULL) ||
357       (logfile != NULL &&
358         (logfile = checkexpand(logfile, addr, tblock->name, cke_file)) == NULL) ||
359       (oncelog != NULL &&
360         (oncelog = checkexpand(oncelog, addr, tblock->name, cke_file)) == NULL) ||
361       (oncerepeat != NULL &&
362         (oncerepeat = checkexpand(oncerepeat, addr, tblock->name, cke_file)) == NULL))
363     return FALSE;
364
365   if (oncerepeat != NULL)
366     {
367     once_repeat_sec = readconf_readtime(oncerepeat, 0, FALSE);
368     if (once_repeat_sec < 0)
369       {
370       addr->transport_return = FAIL;
371       addr->message = string_sprintf("Invalid time value \"%s\" for "
372         "\"once_repeat\" in %s transport", oncerepeat, tblock->name);
373       return FALSE;
374       }
375     }
376   }
377
378 /* If the never_mail option is set, we have to scan all the recipients and
379 remove those that match. */
380
381 if (ob->never_mail != NULL)
382   {
383   const uschar *never_mail = expand_string(ob->never_mail);
384
385   if (never_mail == NULL)
386     {
387     addr->transport_return = FAIL;
388     addr->message = string_sprintf("Failed to expand \"%s\" for "
389       "\"never_mail\" in %s transport", ob->never_mail, tblock->name);
390     return FALSE;
391     }
392
393   if (to != NULL) check_never_mail(&to, never_mail);
394   if (cc != NULL) check_never_mail(&cc, never_mail);
395   if (bcc != NULL) check_never_mail(&bcc, never_mail);
396
397   if (to == NULL && cc == NULL && bcc == NULL)
398     {
399     DEBUG(D_transport)
400       debug_printf("*** all recipients removed by never_mail\n");
401     return OK;
402     }
403   }
404
405 /* If the -N option is set, can't do any more. */
406
407 if (dont_deliver)
408   {
409   DEBUG(D_transport)
410     debug_printf("*** delivery by %s transport bypassed by -N option\n",
411       tblock->name);
412   return FALSE;
413   }
414
415
416 /* If the oncelog field is set, we send want to send only one message to the
417 given recipient(s). This works only on the "To" field. If there is no "To"
418 field, the message is always sent. If the To: field contains more than one
419 recipient, the effect might not be quite as envisaged. If once_file_size is
420 set, instead of a dbm file, we use a regular file containing a circular buffer
421 recipient cache. */
422
423 if (oncelog != NULL && *oncelog != 0 && to != NULL)
424   {
425   time_t then = 0;
426
427   /* Handle fixed-size cache file. */
428
429   if (ob->once_file_size > 0)
430     {
431     uschar *p;
432     struct stat statbuf;
433     cache_fd = Uopen(oncelog, O_CREAT|O_RDWR, ob->mode);
434
435     if (cache_fd < 0 || fstat(cache_fd, &statbuf) != 0)
436       {
437       addr->transport_return = DEFER;
438       addr->message = string_sprintf("Failed to %s \"once\" file %s when "
439         "sending message from %s transport: %s",
440         (cache_fd < 0)? "open" : "stat", oncelog, tblock->name,
441           strerror(errno));
442       goto END_OFF;
443       }
444
445     /* Get store in the temporary pool and read the entire file into it. We get
446     an amount of store that is big enough to add the new entry on the end if we
447     need to do that. */
448
449     cache_size = statbuf.st_size;
450     add_size = sizeof(time_t) + Ustrlen(to) + 1;
451     cache_buff = store_get(cache_size + add_size);
452
453     if (read(cache_fd, cache_buff, cache_size) != cache_size)
454       {
455       addr->transport_return = DEFER;
456       addr->basic_errno = errno;
457       addr->message = US"error while reading \"once\" file";
458       goto END_OFF;
459       }
460
461     DEBUG(D_transport) debug_printf("%d bytes read from %s\n", cache_size, oncelog);
462
463     /* Scan the data for this recipient. Each entry in the file starts with
464     a time_t sized time value, followed by the address, followed by a binary
465     zero. If we find a match, put the time into "then", and the place where it
466     was found into "cache_time". Otherwise, "then" is left at zero. */
467
468     p = cache_buff;
469     while (p < cache_buff + cache_size)
470       {
471       uschar *s = p + sizeof(time_t);
472       uschar *nextp = s + Ustrlen(s) + 1;
473       if (Ustrcmp(to, s) == 0)
474         {
475         memcpy(&then, p, sizeof(time_t));
476         cache_time = p;
477         break;
478         }
479       p = nextp;
480       }
481     }
482
483   /* Use a DBM file for the list of previous recipients. */
484
485   else
486     {
487     EXIM_DATUM key_datum, result_datum;
488     EXIM_DBOPEN(oncelog, O_RDWR|O_CREAT, ob->mode, &dbm_file);
489     if (dbm_file == NULL)
490       {
491       addr->transport_return = DEFER;
492       addr->message = string_sprintf("Failed to open %s file %s when sending "
493         "message from %s transport: %s", EXIM_DBTYPE, oncelog, tblock->name,
494         strerror(errno));
495       goto END_OFF;
496       }
497
498     EXIM_DATUM_INIT(key_datum);        /* Some DBM libraries need datums */
499     EXIM_DATUM_INIT(result_datum);     /* to be cleared */
500     EXIM_DATUM_DATA(key_datum) = CS to;
501     EXIM_DATUM_SIZE(key_datum) = Ustrlen(to) + 1;
502
503     if (EXIM_DBGET(dbm_file, key_datum, result_datum))
504       {
505       /* If the datum size is that of a binary time, we are in the new world
506       where messages are sent periodically. Otherwise the file is an old one,
507       where the datum was filled with a tod_log time, which is assumed to be
508       different in size. For that, only one message is ever sent. This change
509       introduced at Exim 3.00. In a couple of years' time the test on the size
510       can be abolished. */
511
512       if (EXIM_DATUM_SIZE(result_datum) == sizeof(time_t))
513         {
514         memcpy(&then, EXIM_DATUM_DATA(result_datum), sizeof(time_t));
515         }
516       else then = now;
517       }
518     }
519
520   /* Either "then" is set zero, if no message has yet been sent, or it
521   is set to the time of the last sending. */
522
523   if (then != 0 && (once_repeat_sec <= 0 || now - then < once_repeat_sec))
524     {
525     DEBUG(D_transport) debug_printf("message previously sent to %s%s\n", to,
526       (once_repeat_sec > 0)? " and repeat time not reached" : "");
527     log_fd = Uopen(logfile, O_WRONLY|O_APPEND|O_CREAT, ob->mode);
528     if (log_fd >= 0)
529       {
530       uschar *ptr = log_buffer;
531       sprintf(CS ptr, "%s\n  previously sent to %.200s\n", tod_stamp(tod_log), to);
532       while(*ptr) ptr++;
533       if(write(log_fd, log_buffer, ptr - log_buffer) != ptr-log_buffer
534         || close(log_fd))
535         DEBUG(D_transport) debug_printf("Problem writing log file %s for %s "
536           "transport\n", logfile, tblock->name);
537       }
538     goto END_OFF;
539     }
540
541   DEBUG(D_transport) debug_printf("%s %s\n", (then <= 0)?
542     "no previous message sent to" : "repeat time reached for", to);
543   }
544
545 /* We are going to send a message. Ensure any requested file is available. */
546
547 if (file != NULL)
548   {
549   ff = Ufopen(file, "rb");
550   if (ff == NULL && !ob->file_optional)
551     {
552     addr->transport_return = DEFER;
553     addr->message = string_sprintf("Failed to open file %s when sending "
554       "message from %s transport: %s", file, tblock->name, strerror(errno));
555     return FALSE;
556     }
557   }
558
559 /* Make a subprocess to send the message */
560
561 pid = child_open_exim(&fd);
562
563 /* Creation of child failed; defer this delivery. */
564
565 if (pid < 0)
566   {
567   addr->transport_return = DEFER;
568   addr->message = string_sprintf("Failed to create child process to send "
569     "message from %s transport: %s", tblock->name, strerror(errno));
570   DEBUG(D_transport) debug_printf("%s\n", addr->message);
571   return FALSE;
572   }
573
574 /* Create the message to be sent - recipients are taken from the headers,
575 as the -t option is used. The "headers" stuff *must* be last in case there
576 are newlines in it which might, if placed earlier, screw up other headers. */
577
578 f = fdopen(fd, "wb");
579
580 if (from != NULL) fprintf(f, "From: %s\n", from);
581 if (reply_to != NULL) fprintf(f, "Reply-To: %s\n", reply_to);
582 if (to != NULL) fprintf(f, "To: %s\n", to);
583 if (cc != NULL) fprintf(f, "Cc: %s\n", cc);
584 if (bcc != NULL) fprintf(f, "Bcc: %s\n", bcc);
585 if (subject != NULL) fprintf(f, "Subject: %s\n", subject);
586
587 /* Generate In-Reply-To from the message_id header; there should
588 always be one, but code defensively. */
589
590 for (h = header_list; h != NULL; h = h->next)
591   if (h->type == htype_id) break;
592
593 if (h != NULL)
594   {
595   message_id = Ustrchr(h->text, ':') + 1;
596   while (isspace(*message_id)) message_id++;
597   fprintf(f, "In-Reply-To: %s", message_id);
598   }
599
600 /* Generate a References header if there is at least one of Message-ID:,
601 References:, or In-Reply-To: (see RFC 2822). */
602
603 for (h = header_list; h != NULL; h = h->next)
604   if (h->type != htype_old && strncmpic(US"References:", h->text, 11) == 0)
605     break;
606
607 if (h == NULL)
608   for (h = header_list; h != NULL; h = h->next)
609     if (h->type != htype_old && strncmpic(US"In-Reply-To:", h->text, 12) == 0)
610       break;
611
612 /* We limit the total length of references.  Although there is no fixed
613 limit, some systems do not like headers growing beyond recognition.
614 Keep the first message ID for the thread root and the last few for
615 the position inside the thread, up to a maximum of 12 altogether. */
616
617 if (h != NULL || message_id != NULL)
618   {
619   fprintf(f, "References:");
620   if (h != NULL)
621     {
622     uschar *s, *id, *error;
623     uschar *referenced_ids[12];
624     int reference_count = 0;
625     int i;
626
627     s = Ustrchr(h->text, ':') + 1;
628     parse_allow_group = FALSE;
629     while (*s != 0 && (s = parse_message_id(s, &id, &error)) != NULL)
630       {
631       if (reference_count == sizeof(referenced_ids)/sizeof(uschar *))
632         {
633         memmove(referenced_ids + 1, referenced_ids + 2,
634            sizeof(referenced_ids) - 2*sizeof(uschar *));
635         referenced_ids[reference_count - 1] = id;
636         }
637       else referenced_ids[reference_count++] = id;
638       }
639     for (i = 0; i < reference_count; ++i) fprintf(f, " %s", referenced_ids[i]);
640     }
641
642   /* The message id will have a newline on the end of it. */
643
644   if (message_id != NULL) fprintf(f, " %s", message_id);
645     else fprintf(f, "\n");
646   }
647
648 /* Add an Auto-Submitted: header */
649
650 fprintf(f, "Auto-Submitted: auto-replied\n");
651
652 /* Add any specially requested headers */
653
654 if (headers != NULL) fprintf(f, "%s\n", headers);
655 fprintf(f, "\n");
656
657 if (text != NULL)
658   {
659   fprintf(f, "%s", CS text);
660   if (text[Ustrlen(text)-1] != '\n') fprintf(f, "\n");
661   }
662
663 if (ff != NULL)
664   {
665   while (Ufgets(big_buffer, big_buffer_size, ff) != NULL)
666     {
667     if (file_expand)
668       {
669       uschar *s = expand_string(big_buffer);
670       DEBUG(D_transport)
671         {
672         if (s == NULL)
673           debug_printf("error while expanding line from file:\n  %s\n  %s\n",
674             big_buffer, expand_string_message);
675         }
676       fprintf(f, "%s", (s == NULL)? CS big_buffer : CS s);
677       }
678     else fprintf(f, "%s", CS big_buffer);
679     }
680   (void) fclose(ff);
681   }
682
683 /* Copy the original message if required, observing the return size
684 limit if we are returning the body. */
685
686 if (return_message)
687   {
688   uschar *rubric = (tblock->headers_only)?
689     US"------ This is a copy of the message's header lines.\n"
690     : (tblock->body_only)?
691     US"------ This is a copy of the body of the message, without the headers.\n"
692     :
693     US"------ This is a copy of the message, including all the headers.\n";
694
695   if (bounce_return_size_limit > 0 && !tblock->headers_only)
696     {
697     struct stat statbuf;
698     int max = (bounce_return_size_limit/DELIVER_IN_BUFFER_SIZE + 1) *
699       DELIVER_IN_BUFFER_SIZE;
700     if (fstat(deliver_datafile, &statbuf) == 0 && statbuf.st_size > max)
701       {
702       fprintf(f, "\n%s"
703 "------ The body of the message is " OFF_T_FMT " characters long; only the first\n"
704 "------ %d or so are included here.\n\n", rubric, statbuf.st_size,
705         (max/1000)*1000);
706       }
707     else fprintf(f, "\n%s\n", rubric);
708     }
709   else fprintf(f, "\n%s\n", rubric);
710
711   fflush(f);
712   transport_count = 0;
713   transport_write_message(addr, fileno(f),
714     (tblock->body_only? topt_no_headers : 0) |
715     (tblock->headers_only? topt_no_body : 0) |
716     (tblock->return_path_add? topt_add_return_path : 0) |
717     (tblock->delivery_date_add? topt_add_delivery_date : 0) |
718     (tblock->envelope_to_add? topt_add_envelope_to : 0),
719     bounce_return_size_limit, tblock->add_headers, tblock->remove_headers,
720     NULL, NULL, tblock->rewrite_rules, tblock->rewrite_existflags);
721   }
722
723 /* End the message and wait for the child process to end; no timeout. */
724
725 (void)fclose(f);
726 rc = child_close(pid, 0);
727
728 /* Update the "sent to" log whatever the yield. This errs on the side of
729 missing out a message rather than risking sending more than one. We either have
730 cache_fd set to a fixed size, circular buffer file, or dbm_file set to an open
731 DBM file (or neither, if "once" is not set). */
732
733 /* Update fixed-size cache file. If cache_time is set, we found a previous
734 entry; that is the spot into which to put the current time. Otherwise we have
735 to add a new record; remove the first one in the file if the file is too big.
736 We always rewrite the entire file in a single write operation. This is
737 (hopefully) going to be the safest thing because there is no interlocking
738 between multiple simultaneous deliveries. */
739
740 if (cache_fd >= 0)
741   {
742   uschar *from = cache_buff;
743   int size = cache_size;
744   (void)lseek(cache_fd, 0, SEEK_SET);
745
746   if (cache_time == NULL)
747     {
748     cache_time = from + size;
749     memcpy(cache_time + sizeof(time_t), to, add_size - sizeof(time_t));
750     size += add_size;
751
752     if (cache_size > 0 && size > ob->once_file_size)
753       {
754       from += sizeof(time_t) + Ustrlen(from + sizeof(time_t)) + 1;
755       size -= (from - cache_buff);
756       }
757     }
758
759   memcpy(cache_time, &now, sizeof(time_t));
760   if(write(cache_fd, from, size) != size)
761     DEBUG(D_transport) debug_printf("Problem writing cache file %s for %s "
762       "transport\n", oncelog, tblock->name);
763   }
764
765 /* Update DBM file */
766
767 else if (dbm_file != NULL)
768   {
769   EXIM_DATUM key_datum, value_datum;
770   EXIM_DATUM_INIT(key_datum);          /* Some DBM libraries need to have */
771   EXIM_DATUM_INIT(value_datum);        /* cleared datums. */
772   EXIM_DATUM_DATA(key_datum) = CS to;
773   EXIM_DATUM_SIZE(key_datum) = Ustrlen(to) + 1;
774
775   /* Many OS define the datum value, sensibly, as a void *. However, there
776   are some which still have char *. By casting this address to a char * we
777   can avoid warning messages from the char * systems. */
778
779   EXIM_DATUM_DATA(value_datum) = CS (&now);
780   EXIM_DATUM_SIZE(value_datum) = (int)sizeof(time_t);
781   EXIM_DBPUT(dbm_file, key_datum, value_datum);
782   }
783
784 /* If sending failed, defer to try again - but if once is set the next
785 try will skip, of course. However, if there were no recipients in the
786 message, we do not fail. */
787
788 if (rc != 0)
789   {
790   if (rc == EXIT_NORECIPIENTS)
791     {
792     DEBUG(D_any) debug_printf("%s transport: message contained no recipients\n",
793       tblock->name);
794     }
795   else
796     {
797     addr->transport_return = DEFER;
798     addr->message = string_sprintf("Failed to send message from %s "
799       "transport (%d)", tblock->name, rc);
800     goto END_OFF;
801     }
802   }
803
804 /* Log the sending of the message if successful and required. If the file
805 fails to open, it's hard to know what to do. We cannot write to the Exim
806 log from here, since we may be running under an unprivileged uid. We don't
807 want to fail the delivery, since the message has been successfully sent. For
808 the moment, ignore open failures. Write the log entry as a single write() to a
809 file opened for appending, in order to avoid interleaving of output from
810 different processes. The log_buffer can be used exactly as for main log
811 writing. */
812
813 if (logfile != NULL)
814   {
815   int log_fd = Uopen(logfile, O_WRONLY|O_APPEND|O_CREAT, ob->mode);
816   if (log_fd >= 0)
817     {
818     uschar *ptr = log_buffer;
819     DEBUG(D_transport) debug_printf("logging message details\n");
820     sprintf(CS ptr, "%s\n", tod_stamp(tod_log));
821     while(*ptr) ptr++;
822     if (from != NULL)
823       {
824       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
825         "  From: %s\n", from);
826       while(*ptr) ptr++;
827       }
828     if (to != NULL)
829       {
830       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
831         "  To: %s\n", to);
832       while(*ptr) ptr++;
833       }
834     if (cc != NULL)
835       {
836       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
837         "  Cc: %s\n", cc);
838       while(*ptr) ptr++;
839       }
840     if (bcc != NULL)
841       {
842       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
843         "  Bcc: %s\n", bcc);
844       while(*ptr) ptr++;
845       }
846     if (subject != NULL)
847       {
848       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
849         "  Subject: %s\n", subject);
850       while(*ptr) ptr++;
851       }
852     if (headers != NULL)
853       {
854       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
855         "  %s\n", headers);
856       while(*ptr) ptr++;
857       }
858     if(write(log_fd, log_buffer, ptr - log_buffer) != ptr-log_buffer
859       || close(log_fd))
860       DEBUG(D_transport) debug_printf("Problem writing log file %s for %s "
861         "transport\n", logfile, tblock->name);
862     }
863   else DEBUG(D_transport) debug_printf("Failed to open log file %s for %s "
864     "transport: %s\n", logfile, tblock->name, strerror(errno));
865   }
866
867 END_OFF:
868 if (dbm_file != NULL) EXIM_DBCLOSE(dbm_file);
869 if (cache_fd > 0) (void)close(cache_fd);
870
871 DEBUG(D_transport) debug_printf("%s transport succeeded\n", tblock->name);
872
873 return FALSE;
874 }
875
876 /* End of transport/autoreply.c */