02ac4f7b1da7dd9979987e32ad67ee4a58718345
[exim.git] / src / src / transports / autoreply.c
1 /* $Cambridge: exim/src/src/transports/autoreply.c,v 1.5 2005/06/27 14:29:44 ph10 Exp $ */
2
3 /*************************************************
4 *     Exim - an Internet mail transport agent    *
5 *************************************************/
6
7 /* Copyright (c) University of Cambridge 1995 - 2005 */
8 /* See the file NOTICE for conditions of use and distribution. */
9
10
11 #include "../exim.h"
12 #include "autoreply.h"
13
14
15
16 /* Options specific to the autoreply transport. They must be in alphabetic
17 order (note that "_" comes before the lower case letters). Those starting
18 with "*" are not settable by the user but are used by the option-reading
19 software for alternative value types. Some options are publicly visible and so
20 are stored in the driver instance block. These are flagged with opt_public. */
21
22 optionlist autoreply_transport_options[] = {
23   { "bcc",               opt_stringptr,
24       (void *)offsetof(autoreply_transport_options_block, bcc) },
25   { "cc",                opt_stringptr,
26       (void *)offsetof(autoreply_transport_options_block, cc) },
27   { "file",              opt_stringptr,
28       (void *)offsetof(autoreply_transport_options_block, file) },
29   { "file_expand",     opt_bool,
30       (void *)offsetof(autoreply_transport_options_block, file_expand) },
31   { "file_optional",     opt_bool,
32       (void *)offsetof(autoreply_transport_options_block, file_optional) },
33   { "from",              opt_stringptr,
34       (void *)offsetof(autoreply_transport_options_block, from) },
35   { "headers",           opt_stringptr,
36       (void *)offsetof(autoreply_transport_options_block, headers) },
37   { "log",               opt_stringptr,
38       (void *)offsetof(autoreply_transport_options_block, logfile) },
39   { "mode",              opt_octint,
40       (void *)offsetof(autoreply_transport_options_block, mode) },
41   { "never_mail",        opt_stringptr,
42       (void *)offsetof(autoreply_transport_options_block, never_mail) },
43   { "once",              opt_stringptr,
44       (void *)offsetof(autoreply_transport_options_block, oncelog) },
45   { "once_file_size",    opt_int,
46       (void *)offsetof(autoreply_transport_options_block, once_file_size) },
47   { "once_repeat",       opt_stringptr,
48       (void *)offsetof(autoreply_transport_options_block, once_repeat) },
49   { "reply_to",          opt_stringptr,
50       (void *)offsetof(autoreply_transport_options_block, reply_to) },
51   { "return_message",    opt_bool,
52       (void *)offsetof(autoreply_transport_options_block, return_message) },
53   { "subject",           opt_stringptr,
54       (void *)offsetof(autoreply_transport_options_block, subject) },
55   { "text",              opt_stringptr,
56       (void *)offsetof(autoreply_transport_options_block, text) },
57   { "to",                opt_stringptr,
58       (void *)offsetof(autoreply_transport_options_block, to) },
59 };
60
61 /* Size of the options list. An extern variable has to be used so that its
62 address can appear in the tables drtables.c. */
63
64 int autoreply_transport_options_count =
65   sizeof(autoreply_transport_options)/sizeof(optionlist);
66
67 /* Default private options block for the autoreply transport. */
68
69 autoreply_transport_options_block autoreply_transport_option_defaults = {
70   NULL,           /* from */
71   NULL,           /* reply_to */
72   NULL,           /* to */
73   NULL,           /* cc */
74   NULL,           /* bcc */
75   NULL,           /* subject */
76   NULL,           /* headers */
77   NULL,           /* text */
78   NULL,           /* file */
79   NULL,           /* logfile */
80   NULL,           /* oncelog */
81   NULL,           /* once_repeat */
82   NULL,           /* never_mail */
83   0600,           /* mode */
84   0,              /* once_file_size */
85   FALSE,          /* file_expand */
86   FALSE,          /* file_optional */
87   FALSE           /* return message */
88 };
89
90
91
92 /* Type of text for the checkexpand() function */
93
94 enum { cke_text, cke_hdr, cke_file };
95
96
97
98 /*************************************************
99 *          Initialization entry point            *
100 *************************************************/
101
102 /* Called for each instance, after its options have been read, to
103 enable consistency checks to be done, or anything else that needs
104 to be set up. */
105
106 void
107 autoreply_transport_init(transport_instance *tblock)
108 {
109 /*
110 autoreply_transport_options_block *ob =
111   (autoreply_transport_options_block *)(tblock->options_block);
112 */
113
114 /* If a fixed uid field is set, then a gid field must also be set. */
115
116 if (tblock->uid_set && !tblock->gid_set && tblock->expand_gid == NULL)
117   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
118     "user set without group for the %s transport", tblock->name);
119 }
120
121
122
123
124 /*************************************************
125 *          Expand string and check               *
126 *************************************************/
127
128 /* If the expansion fails, the error is set up in the address. Expanded
129 strings must be checked to ensure they contain only printing characters
130 and white space. If not, the function fails.
131
132 Arguments:
133    s         string to expand
134    addr      address that is being worked on
135    name      transport name, for error text
136    type      type, for checking content:
137                cke_text => no check
138                cke_hdr  => header, allow \n + whitespace
139                cke_file => file name, no non-printers allowed
140
141 Returns:     expanded string if expansion succeeds;
142              NULL otherwise
143 */
144
145 static uschar *
146 checkexpand(uschar *s, address_item *addr, uschar *name, int type)
147 {
148 uschar *t;
149 uschar *ss = expand_string(s);
150
151 if (ss == NULL)
152   {
153   addr->transport_return = FAIL;
154   addr->message = string_sprintf("Expansion of \"%s\" failed in %s transport: "
155     "%s", s, name, expand_string_message);
156   return NULL;
157   }
158
159 if (type != cke_text) for (t = ss; *t != 0; t++)
160   {
161   int c = *t;
162   if (mac_isprint(c)) continue;
163   if (type == cke_hdr && c == '\n' && (t[1] == ' ' || t[1] == '\t')) continue;
164   s = string_printing(s);
165   addr->transport_return = FAIL;
166   addr->message = string_sprintf("Expansion of \"%s\" in %s transport "
167     "contains non-printing character %d", s, name, c);
168   return NULL;
169   }
170
171 return ss;
172 }
173
174
175
176
177 /*************************************************
178 *          Check a header line for never_mail    *
179 *************************************************/
180
181 /* This is called to check to, cc, and bcc for addresses in the never_mail
182 list. Any that are found are removed.
183
184 Arguments:
185   listptr     points to the list of addresses
186   never_mail  an address list, already expanded
187
188 Returns:      nothing
189 */
190
191 static void
192 check_never_mail(uschar **listptr, uschar *never_mail)
193 {
194 uschar *s = *listptr;
195
196 while (*s != 0)
197   {
198   uschar *error, *next;
199   uschar *e = parse_find_address_end(s, FALSE);
200   int terminator = *e;
201   int start, end, domain, rc;
202
203   /* Temporarily terminate the string at the address end while extracting
204   the operative address within. */
205
206   *e = 0;
207   next = parse_extract_address(s, &error, &start, &end, &domain, FALSE);
208   *e = terminator;
209
210   /* If there is some kind of syntax error, just give up on this header
211   line. */
212
213   if (next == NULL) break;
214
215   /* See if the address is on the never_mail list */
216
217   rc = match_address_list(next,         /* address to check */
218                           TRUE,         /* start caseless */
219                           FALSE,        /* don't expand the list */
220                           &never_mail,  /* the list */
221                           NULL,         /* no caching */
222                           -1,           /* no expand setup */
223                           0,            /* separator from list */
224                           NULL);        /* no lookup value return */
225
226   if (rc == OK)                         /* Remove this address */
227     {
228     DEBUG(D_transport)
229       debug_printf("discarding recipient %s (matched never_mail)\n", next);
230     if (terminator == ',') e++;
231     memmove(s, e, Ustrlen(e) + 1);
232     }
233   else                                  /* Skip over this address */
234     {
235     s = e;
236     if (terminator == ',') s++;
237     }
238   }
239
240 /* Check to see if we removed the last address, leaving a terminating comma
241 that needs to be removed */
242
243 s = *listptr + Ustrlen(*listptr);
244 while (s > *listptr && (isspace(s[-1]) || s[-1] == ',')) s--;
245 *s = 0;
246
247 /* Check to see if there any addresses left; if not, set NULL */
248
249 s = *listptr;
250 while (s != 0 && isspace(*s)) s++;
251 if (*s == 0) *listptr = NULL;
252 }
253
254
255
256 /*************************************************
257 *              Main entry point                  *
258 *************************************************/
259
260 /* See local README for interface details. This transport always returns
261 FALSE, indicating that the top address has the status for all - though in fact
262 this transport can handle only one address at at time anyway. */
263
264 BOOL
265 autoreply_transport_entry(
266   transport_instance *tblock,      /* data for this instantiation */
267   address_item *addr)              /* address we are working on */
268 {
269 int fd, pid, rc;
270 int cache_fd = -1;
271 int log_fd = -1;
272 int cache_size = 0;
273 int add_size = 0;
274 EXIM_DB *dbm_file = NULL;
275 BOOL file_expand, return_message;
276 uschar *from, *reply_to, *to, *cc, *bcc, *subject, *headers, *text, *file;
277 uschar *logfile, *oncelog;
278 uschar *cache_buff = NULL;
279 uschar *cache_time = 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   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 && 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       (void)write(log_fd, log_buffer, ptr - log_buffer);
534       (void)close(log_fd);
535       }
536     goto END_OFF;
537     }
538
539   DEBUG(D_transport) debug_printf("%s %s\n", (then <= 0)?
540     "no previous message sent to" : "repeat time reached for", to);
541   }
542
543 /* We are going to send a message. Ensure any requested file is available. */
544
545 if (file != NULL)
546   {
547   ff = Ufopen(file, "rb");
548   if (ff == NULL && !ob->file_optional)
549     {
550     addr->transport_return = DEFER;
551     addr->message = string_sprintf("Failed to open file %s when sending "
552       "message from %s transport: %s", file, tblock->name, strerror(errno));
553     return FALSE;
554     }
555   }
556
557 /* Make a subprocess to send the message */
558
559 pid = child_open_exim(&fd);
560
561 /* Creation of child failed; defer this delivery. */
562
563 if (pid < 0)
564   {
565   addr->transport_return = DEFER;
566   addr->message = string_sprintf("Failed to create child process to send "
567     "message from %s transport: %s", tblock->name, strerror(errno));
568   DEBUG(D_transport) debug_printf("%s\n", addr->message);
569   return FALSE;
570   }
571
572 /* Create the message to be sent - recipients are taken from the headers,
573 as the -t option is used. The "headers" stuff *must* be last in case there
574 are newlines in it which might, if placed earlier, screw up other headers. */
575
576 f = fdopen(fd, "wb");
577
578 if (from != NULL) fprintf(f, "From: %s\n", from);
579 if (reply_to != NULL) fprintf(f, "Reply-To: %s\n", reply_to);
580 if (to != NULL) fprintf(f, "To: %s\n", to);
581 if (cc != NULL) fprintf(f, "Cc: %s\n", cc);
582 if (bcc != NULL) fprintf(f, "Bcc: %s\n", bcc);
583 if (subject != NULL) fprintf(f, "Subject: %s\n", subject);
584
585 /* Generate In-Reply-To from the message_id header; there should
586 always be one, but code defensively. */
587
588 for (h = header_list; h != NULL; h = h->next)
589   if (h->type == htype_id) break;
590
591 if (h != NULL)
592   {
593   uschar *s = Ustrchr(h->text, ':') + 1;
594   while (isspace(*s)) s++;
595   fprintf(f, "In-Reply-To: %s", s);
596   }
597
598 /* Add an Auto-Submitted: header */
599
600 fprintf(f, "Auto-Submitted: auto-replied\n");
601
602 /* Add any specially requested headers */
603
604 if (headers != NULL) fprintf(f, "%s\n", headers);
605 fprintf(f, "\n");
606
607 if (text != NULL)
608   {
609   fprintf(f, "%s", CS text);
610   if (text[Ustrlen(text)-1] != '\n') fprintf(f, "\n");
611   }
612
613 if (ff != NULL)
614   {
615   while (Ufgets(big_buffer, big_buffer_size, ff) != NULL)
616     {
617     if (file_expand)
618       {
619       uschar *s = expand_string(big_buffer);
620       DEBUG(D_transport)
621         {
622         if (s == NULL)
623           debug_printf("error while expanding line from file:\n  %s\n  %s\n",
624             big_buffer, expand_string_message);
625         }
626       fprintf(f, "%s", (s == NULL)? CS big_buffer : CS s);
627       }
628     else fprintf(f, "%s", CS big_buffer);
629     }
630   }
631
632 /* Copy the original message if required, observing the return size
633 limit. */
634
635 if (return_message)
636   {
637   if (bounce_return_size_limit > 0)
638     {
639     struct stat statbuf;
640     int max = (bounce_return_size_limit/DELIVER_IN_BUFFER_SIZE + 1) *
641       DELIVER_IN_BUFFER_SIZE;
642     if (fstat(deliver_datafile, &statbuf) == 0 && statbuf.st_size > max)
643       {
644       fprintf(f, "\n"
645 "------ This is a copy of the message, including all the headers.\n"
646 "------ The body of the message is " OFF_T_FMT " characters long; only the first\n"
647 "------ %d or so are included here.\n\n", statbuf.st_size,
648         (max/1000)*1000);
649       }
650     else fprintf(f, "\n"
651 "------ This is a copy of the message, including all the headers. ------\n\n");
652     }
653   else fprintf(f, "\n"
654 "------ This is a copy of the message, including all the headers. ------\n\n");
655
656   fflush(f);
657   transport_count = 0;
658   transport_write_message(addr, fileno(f),
659     (tblock->body_only? topt_no_headers : 0) |
660     (tblock->headers_only? topt_no_body : 0) |
661     (tblock->return_path_add? topt_add_return_path : 0) |
662     (tblock->delivery_date_add? topt_add_delivery_date : 0) |
663     (tblock->envelope_to_add? topt_add_envelope_to : 0),
664     bounce_return_size_limit, tblock->add_headers, tblock->remove_headers,
665     NULL, NULL, tblock->rewrite_rules, tblock->rewrite_existflags);
666   }
667
668 /* End the message and wait for the child process to end; no timeout. */
669
670 (void)fclose(f);
671 rc = child_close(pid, 0);
672
673 /* Update the "sent to" log whatever the yield. This errs on the side of
674 missing out a message rather than risking sending more than one. We either have
675 cache_fd set to a fixed size, circular buffer file, or dbm_file set to an open
676 DBM file (or neither, if "once" is not set). */
677
678 /* Update fixed-size cache file. If cache_time is set, we found a previous
679 entry; that is the spot into which to put the current time. Otherwise we have
680 to add a new record; remove the first one in the file if the file is too big.
681 We always rewrite the entire file in a single write operation. This is
682 (hopefully) going to be the safest thing because there is no interlocking
683 between multiple simultaneous deliveries. */
684
685 if (cache_fd >= 0)
686   {
687   uschar *from = cache_buff;
688   int size = cache_size;
689   (void)lseek(cache_fd, 0, SEEK_SET);
690
691   if (cache_time == NULL)
692     {
693     cache_time = from + size;
694     memcpy(cache_time + sizeof(time_t), to, add_size - sizeof(time_t));
695     size += add_size;
696
697     if (cache_size > 0 && size > ob->once_file_size)
698       {
699       from += sizeof(time_t) + Ustrlen(from + sizeof(time_t)) + 1;
700       size -= (from - cache_buff);
701       }
702     }
703
704   memcpy(cache_time, &now, sizeof(time_t));
705   (void)write(cache_fd, from, size);
706   }
707
708 /* Update DBM file */
709
710 else if (dbm_file != NULL)
711   {
712   EXIM_DATUM key_datum, value_datum;
713   EXIM_DATUM_INIT(key_datum);          /* Some DBM libraries need to have */
714   EXIM_DATUM_INIT(value_datum);        /* cleared datums. */
715   EXIM_DATUM_DATA(key_datum) = CS to;
716   EXIM_DATUM_SIZE(key_datum) = Ustrlen(to) + 1;
717
718   /* Many OS define the datum value, sensibly, as a void *. However, there
719   are some which still have char *. By casting this address to a char * we
720   can avoid warning messages from the char * systems. */
721
722   EXIM_DATUM_DATA(value_datum) = CS (&now);
723   EXIM_DATUM_SIZE(value_datum) = (int)sizeof(time_t);
724   EXIM_DBPUT(dbm_file, key_datum, value_datum);
725   }
726
727 /* If sending failed, defer to try again - but if once is set the next
728 try will skip, of course. However, if there were no recipients in the
729 message, we do not fail. */
730
731 if (rc != 0)
732   {
733   if (rc == EXIT_NORECIPIENTS)
734     {
735     DEBUG(D_any) debug_printf("%s transport: message contained no recipients\n",
736       tblock->name);
737     }
738   else
739     {
740     addr->transport_return = DEFER;
741     addr->message = string_sprintf("Failed to send message from %s "
742       "transport (%d)", tblock->name, rc);
743     goto END_OFF;
744     }
745   }
746
747 /* Log the sending of the message if successful and required. If the file
748 fails to open, it's hard to know what to do. We cannot write to the Exim
749 log from here, since we may be running under an unprivileged uid. We don't
750 want to fail the delivery, since the message has been successfully sent. For
751 the moment, ignore open failures. Write the log entry as a single write() to a
752 file opened for appending, in order to avoid interleaving of output from
753 different processes. The log_buffer can be used exactly as for main log
754 writing. */
755
756 if (logfile != NULL)
757   {
758   int log_fd = Uopen(logfile, O_WRONLY|O_APPEND|O_CREAT, ob->mode);
759   if (log_fd >= 0)
760     {
761     uschar *ptr = log_buffer;
762     DEBUG(D_transport) debug_printf("logging message details\n");
763     sprintf(CS ptr, "%s\n", tod_stamp(tod_log));
764     while(*ptr) ptr++;
765     if (from != NULL)
766       {
767       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
768         "  From: %s\n", from);
769       while(*ptr) ptr++;
770       }
771     if (to != NULL)
772       {
773       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
774         "  To: %s\n", to);
775       while(*ptr) ptr++;
776       }
777     if (cc != NULL)
778       {
779       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
780         "  Cc: %s\n", cc);
781       while(*ptr) ptr++;
782       }
783     if (bcc != NULL)
784       {
785       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
786         "  Bcc: %s\n", bcc);
787       while(*ptr) ptr++;
788       }
789     if (subject != NULL)
790       {
791       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
792         "  Subject: %s\n", subject);
793       while(*ptr) ptr++;
794       }
795     if (headers != NULL)
796       {
797       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
798         "  %s\n", headers);
799       while(*ptr) ptr++;
800       }
801     (void)write(log_fd, log_buffer, ptr - log_buffer);
802     (void)close(log_fd);
803     }
804   else DEBUG(D_transport) debug_printf("Failed to open log file %s for %s "
805     "transport: %s\n", logfile, tblock->name, strerror(errno));
806   }
807
808 END_OFF:
809 if (dbm_file != NULL) EXIM_DBCLOSE(dbm_file);
810 if (cache_fd > 0) (void)close(cache_fd);
811
812 DEBUG(D_transport) debug_printf("%s transport succeeded\n", tblock->name);
813
814 return FALSE;
815 }
816
817 /* End of transport/autoreply.c */