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