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