1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2016 */
6 /* See the file NOTICE for conditions of use and distribution. */
10 #include "autoreply.h"
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. */
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) },
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) },
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. */
62 int autoreply_transport_options_count =
63 sizeof(autoreply_transport_options)/sizeof(optionlist);
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;}
73 #else /*!MACRO_PREDEF*/
76 /* Default private options block for the autoreply transport. */
78 autoreply_transport_options_block autoreply_transport_option_defaults = {
90 NULL, /* once_repeat */
91 NULL, /* never_mail */
93 0, /* once_file_size */
94 FALSE, /* file_expand */
95 FALSE, /* file_optional */
96 FALSE /* return message */
101 /* Type of text for the checkexpand() function */
103 enum { cke_text, cke_hdr, cke_file };
107 /*************************************************
108 * Initialization entry point *
109 *************************************************/
111 /* Called for each instance, after its options have been read, to
112 enable consistency checks to be done, or anything else that needs
116 autoreply_transport_init(transport_instance *tblock)
119 autoreply_transport_options_block *ob =
120 (autoreply_transport_options_block *)(tblock->options_block);
123 /* If a fixed uid field is set, then a gid field must also be set. */
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);
133 /*************************************************
134 * Expand string and check *
135 *************************************************/
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.
143 addr address that is being worked on
144 name transport name, for error text
145 type type, for checking content:
147 cke_hdr => header, allow \n + whitespace
148 cke_file => file name, no non-printers allowed
150 Returns: expanded string if expansion succeeds;
155 checkexpand(uschar *s, address_item *addr, uschar *name, int type)
158 uschar *ss = expand_string(s);
162 addr->transport_return = FAIL;
163 addr->message = string_sprintf("Expansion of \"%s\" failed in %s transport: "
164 "%s", s, name, expand_string_message);
168 if (type != cke_text) for (t = ss; *t != 0; t++)
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);
187 /*************************************************
188 * Check a header line for never_mail *
189 *************************************************/
191 /* This is called to check to, cc, and bcc for addresses in the never_mail
192 list. Any that are found are removed.
195 listptr points to the list of addresses
196 never_mail an address list, already expanded
202 check_never_mail(uschar **listptr, const uschar *never_mail)
204 uschar *s = *listptr;
208 uschar *error, *next;
209 uschar *e = parse_find_address_end(s, FALSE);
211 int start, end, domain, rc;
213 /* Temporarily terminate the string at the address end while extracting
214 the operative address within. */
217 next = parse_extract_address(s, &error, &start, &end, &domain, FALSE);
220 /* If there is some kind of syntax error, just give up on this header
223 if (next == NULL) break;
225 /* See if the address is on the never_mail list */
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 */
236 if (rc == OK) /* Remove this address */
239 debug_printf("discarding recipient %s (matched never_mail)\n", next);
240 if (terminator == ',') e++;
241 memmove(s, e, Ustrlen(e) + 1);
243 else /* Skip over this address */
246 if (terminator == ',') s++;
250 /* Check to see if we removed the last address, leaving a terminating comma
251 that needs to be removed */
253 s = *listptr + Ustrlen(*listptr);
254 while (s > *listptr && (isspace(s[-1]) || s[-1] == ',')) s--;
257 /* Check to see if there any addresses left; if not, set NULL */
260 while (s != 0 && isspace(*s)) s++;
261 if (*s == 0) *listptr = NULL;
266 /*************************************************
268 *************************************************/
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. */
275 autoreply_transport_entry(
276 transport_instance *tblock, /* data for this instantiation */
277 address_item *addr) /* address we are working on */
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;
291 time_t now = time(NULL);
292 time_t once_repeat_sec = 0;
296 autoreply_transport_options_block *ob =
297 (autoreply_transport_options_block *)(tblock->options_block);
299 DEBUG(D_transport) debug_printf("%s transport entered\n", tblock->name);
301 /* Set up for the good case */
303 addr->transport_return = OK;
304 addr->basic_errno = 0;
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. */
311 if (addr->reply != NULL)
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;
332 uschar *oncerepeat = ob->once_repeat;
334 DEBUG(D_transport) debug_printf("taking data from transport\n");
336 reply_to = ob->reply_to;
340 subject = ob->subject;
341 headers = ob->headers;
344 logfile = ob->logfile;
345 oncelog = ob->oncelog;
346 file_expand = ob->file_expand;
347 return_message = ob->return_message;
350 (from = checkexpand(from, addr, tblock->name, cke_hdr)) == NULL) ||
352 (reply_to = checkexpand(reply_to, addr, tblock->name, cke_hdr)) == NULL) ||
354 (to = checkexpand(to, addr, tblock->name, cke_hdr)) == NULL) ||
356 (cc = checkexpand(cc, addr, tblock->name, cke_hdr)) == NULL) ||
358 (bcc = checkexpand(bcc, addr, tblock->name, cke_hdr)) == NULL) ||
360 (subject = checkexpand(subject, addr, tblock->name, cke_hdr)) == NULL) ||
362 (headers = checkexpand(headers, addr, tblock->name, cke_text)) == NULL) ||
364 (text = checkexpand(text, addr, tblock->name, cke_text)) == NULL) ||
366 (file = checkexpand(file, addr, tblock->name, cke_file)) == NULL) ||
368 (logfile = checkexpand(logfile, addr, tblock->name, cke_file)) == NULL) ||
370 (oncelog = checkexpand(oncelog, addr, tblock->name, cke_file)) == NULL) ||
371 (oncerepeat != NULL &&
372 (oncerepeat = checkexpand(oncerepeat, addr, tblock->name, cke_file)) == NULL))
375 if (oncerepeat != NULL)
377 once_repeat_sec = readconf_readtime(oncerepeat, 0, FALSE);
378 if (once_repeat_sec < 0)
380 addr->transport_return = FAIL;
381 addr->message = string_sprintf("Invalid time value \"%s\" for "
382 "\"once_repeat\" in %s transport", oncerepeat, tblock->name);
388 /* If the never_mail option is set, we have to scan all the recipients and
389 remove those that match. */
391 if (ob->never_mail != NULL)
393 const uschar *never_mail = expand_string(ob->never_mail);
395 if (never_mail == NULL)
397 addr->transport_return = FAIL;
398 addr->message = string_sprintf("Failed to expand \"%s\" for "
399 "\"never_mail\" in %s transport", ob->never_mail, tblock->name);
403 if (to != NULL) check_never_mail(&to, never_mail);
404 if (cc != NULL) check_never_mail(&cc, never_mail);
405 if (bcc != NULL) check_never_mail(&bcc, never_mail);
407 if (to == NULL && cc == NULL && bcc == NULL)
410 debug_printf("*** all recipients removed by never_mail\n");
415 /* If the -N option is set, can't do any more. */
420 debug_printf("*** delivery by %s transport bypassed by -N option\n",
426 /* If the oncelog field is set, we send want to send only one message to the
427 given recipient(s). This works only on the "To" field. If there is no "To"
428 field, the message is always sent. If the To: field contains more than one
429 recipient, the effect might not be quite as envisaged. If once_file_size is
430 set, instead of a dbm file, we use a regular file containing a circular buffer
433 if (oncelog != NULL && *oncelog != 0 && to != NULL)
437 /* Handle fixed-size cache file. */
439 if (ob->once_file_size > 0)
443 cache_fd = Uopen(oncelog, O_CREAT|O_RDWR, ob->mode);
445 if (cache_fd < 0 || fstat(cache_fd, &statbuf) != 0)
447 addr->transport_return = DEFER;
448 addr->message = string_sprintf("Failed to %s \"once\" file %s when "
449 "sending message from %s transport: %s",
450 (cache_fd < 0)? "open" : "stat", oncelog, tblock->name,
455 /* Get store in the temporary pool and read the entire file into it. We get
456 an amount of store that is big enough to add the new entry on the end if we
459 cache_size = statbuf.st_size;
460 add_size = sizeof(time_t) + Ustrlen(to) + 1;
461 cache_buff = store_get(cache_size + add_size);
463 if (read(cache_fd, cache_buff, cache_size) != cache_size)
465 addr->transport_return = DEFER;
466 addr->basic_errno = errno;
467 addr->message = US"error while reading \"once\" file";
471 DEBUG(D_transport) debug_printf("%d bytes read from %s\n", cache_size, oncelog);
473 /* Scan the data for this recipient. Each entry in the file starts with
474 a time_t sized time value, followed by the address, followed by a binary
475 zero. If we find a match, put the time into "then", and the place where it
476 was found into "cache_time". Otherwise, "then" is left at zero. */
479 while (p < cache_buff + cache_size)
481 uschar *s = p + sizeof(time_t);
482 uschar *nextp = s + Ustrlen(s) + 1;
483 if (Ustrcmp(to, s) == 0)
485 memcpy(&then, p, sizeof(time_t));
493 /* Use a DBM file for the list of previous recipients. */
497 EXIM_DATUM key_datum, result_datum;
498 EXIM_DBOPEN(oncelog, O_RDWR|O_CREAT, ob->mode, &dbm_file);
501 addr->transport_return = DEFER;
502 addr->message = string_sprintf("Failed to open %s file %s when sending "
503 "message from %s transport: %s", EXIM_DBTYPE, oncelog, tblock->name,
508 EXIM_DATUM_INIT(key_datum); /* Some DBM libraries need datums */
509 EXIM_DATUM_INIT(result_datum); /* to be cleared */
510 EXIM_DATUM_DATA(key_datum) = CS to;
511 EXIM_DATUM_SIZE(key_datum) = Ustrlen(to) + 1;
513 if (EXIM_DBGET(dbm_file, key_datum, result_datum))
515 /* If the datum size is that of a binary time, we are in the new world
516 where messages are sent periodically. Otherwise the file is an old one,
517 where the datum was filled with a tod_log time, which is assumed to be
518 different in size. For that, only one message is ever sent. This change
519 introduced at Exim 3.00. In a couple of years' time the test on the size
522 if (EXIM_DATUM_SIZE(result_datum) == sizeof(time_t))
524 memcpy(&then, EXIM_DATUM_DATA(result_datum), sizeof(time_t));
530 /* Either "then" is set zero, if no message has yet been sent, or it
531 is set to the time of the last sending. */
533 if (then != 0 && (once_repeat_sec <= 0 || now - then < once_repeat_sec))
536 DEBUG(D_transport) debug_printf("message previously sent to %s%s\n", to,
537 (once_repeat_sec > 0)? " and repeat time not reached" : "");
538 log_fd = logfile ? Uopen(logfile, O_WRONLY|O_APPEND|O_CREAT, ob->mode) : -1;
541 uschar *ptr = log_buffer;
542 sprintf(CS ptr, "%s\n previously sent to %.200s\n", tod_stamp(tod_log), to);
544 if(write(log_fd, log_buffer, ptr - log_buffer) != ptr-log_buffer
546 DEBUG(D_transport) debug_printf("Problem writing log file %s for %s "
547 "transport\n", logfile, tblock->name);
552 DEBUG(D_transport) debug_printf("%s %s\n", (then <= 0)?
553 "no previous message sent to" : "repeat time reached for", to);
556 /* We are going to send a message. Ensure any requested file is available. */
560 ff = Ufopen(file, "rb");
561 if (ff == NULL && !ob->file_optional)
563 addr->transport_return = DEFER;
564 addr->message = string_sprintf("Failed to open file %s when sending "
565 "message from %s transport: %s", file, tblock->name, strerror(errno));
570 /* Make a subprocess to send the message */
572 pid = child_open_exim(&fd);
574 /* Creation of child failed; defer this delivery. */
578 addr->transport_return = DEFER;
579 addr->message = string_sprintf("Failed to create child process to send "
580 "message from %s transport: %s", tblock->name, strerror(errno));
581 DEBUG(D_transport) debug_printf("%s\n", addr->message);
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. */
589 f = fdopen(fd, "wb");
591 if (from != NULL) fprintf(f, "From: %s\n", from);
592 if (reply_to != NULL) fprintf(f, "Reply-To: %s\n", reply_to);
593 if (to != NULL) fprintf(f, "To: %s\n", to);
594 if (cc != NULL) fprintf(f, "Cc: %s\n", cc);
595 if (bcc != NULL) fprintf(f, "Bcc: %s\n", bcc);
596 if (subject != NULL) fprintf(f, "Subject: %s\n", subject);
598 /* Generate In-Reply-To from the message_id header; there should
599 always be one, but code defensively. */
601 for (h = header_list; h != NULL; h = h->next)
602 if (h->type == htype_id) break;
606 message_id = Ustrchr(h->text, ':') + 1;
607 while (isspace(*message_id)) message_id++;
608 fprintf(f, "In-Reply-To: %s", message_id);
611 /* Generate a References header if there is at least one of Message-ID:,
612 References:, or In-Reply-To: (see RFC 2822). */
614 for (h = header_list; h != NULL; h = h->next)
615 if (h->type != htype_old && strncmpic(US"References:", h->text, 11) == 0)
619 for (h = header_list; h != NULL; h = h->next)
620 if (h->type != htype_old && strncmpic(US"In-Reply-To:", h->text, 12) == 0)
623 /* We limit the total length of references. Although there is no fixed
624 limit, some systems do not like headers growing beyond recognition.
625 Keep the first message ID for the thread root and the last few for
626 the position inside the thread, up to a maximum of 12 altogether. */
628 if (h != NULL || message_id != NULL)
630 fprintf(f, "References:");
633 uschar *s, *id, *error;
634 uschar *referenced_ids[12];
635 int reference_count = 0;
638 s = Ustrchr(h->text, ':') + 1;
639 parse_allow_group = FALSE;
640 while (*s != 0 && (s = parse_message_id(s, &id, &error)) != NULL)
642 if (reference_count == sizeof(referenced_ids)/sizeof(uschar *))
644 memmove(referenced_ids + 1, referenced_ids + 2,
645 sizeof(referenced_ids) - 2*sizeof(uschar *));
646 referenced_ids[reference_count - 1] = id;
648 else referenced_ids[reference_count++] = id;
650 for (i = 0; i < reference_count; ++i) fprintf(f, " %s", referenced_ids[i]);
653 /* The message id will have a newline on the end of it. */
655 if (message_id != NULL) fprintf(f, " %s", message_id);
656 else fprintf(f, "\n");
659 /* Add an Auto-Submitted: header */
661 fprintf(f, "Auto-Submitted: auto-replied\n");
663 /* Add any specially requested headers */
665 if (headers != NULL) fprintf(f, "%s\n", headers);
670 fprintf(f, "%s", CS text);
671 if (text[Ustrlen(text)-1] != '\n') fprintf(f, "\n");
676 while (Ufgets(big_buffer, big_buffer_size, ff) != NULL)
680 uschar *s = expand_string(big_buffer);
684 debug_printf("error while expanding line from file:\n %s\n %s\n",
685 big_buffer, expand_string_message);
687 fprintf(f, "%s", (s == NULL)? CS big_buffer : CS s);
689 else fprintf(f, "%s", CS big_buffer);
694 /* Copy the original message if required, observing the return size
695 limit if we are returning the body. */
699 uschar *rubric = (tblock->headers_only)?
700 US"------ This is a copy of the message's header lines.\n"
701 : (tblock->body_only)?
702 US"------ This is a copy of the body of the message, without the headers.\n"
704 US"------ This is a copy of the message, including all the headers.\n";
705 transport_ctx tctx = {
710 (tblock->body_only ? topt_no_headers : 0) |
711 (tblock->headers_only ? topt_no_body : 0) |
712 (tblock->return_path_add ? topt_add_return_path : 0) |
713 (tblock->delivery_date_add ? topt_add_delivery_date : 0) |
714 (tblock->envelope_to_add ? topt_add_envelope_to : 0)
717 if (bounce_return_size_limit > 0 && !tblock->headers_only)
720 int max = (bounce_return_size_limit/DELIVER_IN_BUFFER_SIZE + 1) *
721 DELIVER_IN_BUFFER_SIZE;
722 if (fstat(deliver_datafile, &statbuf) == 0 && statbuf.st_size > max)
725 "------ The body of the message is " OFF_T_FMT " characters long; only the first\n"
726 "------ %d or so are included here.\n\n", rubric, statbuf.st_size,
729 else fprintf(f, "\n%s\n", rubric);
731 else fprintf(f, "\n%s\n", rubric);
735 transport_write_message(&tctx, bounce_return_size_limit);
738 /* End the message and wait for the child process to end; no timeout. */
741 rc = child_close(pid, 0);
743 /* Update the "sent to" log whatever the yield. This errs on the side of
744 missing out a message rather than risking sending more than one. We either have
745 cache_fd set to a fixed size, circular buffer file, or dbm_file set to an open
746 DBM file (or neither, if "once" is not set). */
748 /* Update fixed-size cache file. If cache_time is set, we found a previous
749 entry; that is the spot into which to put the current time. Otherwise we have
750 to add a new record; remove the first one in the file if the file is too big.
751 We always rewrite the entire file in a single write operation. This is
752 (hopefully) going to be the safest thing because there is no interlocking
753 between multiple simultaneous deliveries. */
757 uschar *from = cache_buff;
758 int size = cache_size;
760 if (lseek(cache_fd, 0, SEEK_SET) == 0)
764 cache_time = from + size;
765 memcpy(cache_time + sizeof(time_t), to, add_size - sizeof(time_t));
768 if (cache_size > 0 && size > ob->once_file_size)
770 from += sizeof(time_t) + Ustrlen(from + sizeof(time_t)) + 1;
771 size -= (from - cache_buff);
775 memcpy(cache_time, &now, sizeof(time_t));
776 if(write(cache_fd, from, size) != size)
777 DEBUG(D_transport) debug_printf("Problem writing cache file %s for %s "
778 "transport\n", oncelog, tblock->name);
782 /* Update DBM file */
786 EXIM_DATUM key_datum, value_datum;
787 EXIM_DATUM_INIT(key_datum); /* Some DBM libraries need to have */
788 EXIM_DATUM_INIT(value_datum); /* cleared datums. */
789 EXIM_DATUM_DATA(key_datum) = CS to;
790 EXIM_DATUM_SIZE(key_datum) = Ustrlen(to) + 1;
792 /* Many OS define the datum value, sensibly, as a void *. However, there
793 are some which still have char *. By casting this address to a char * we
794 can avoid warning messages from the char * systems. */
796 EXIM_DATUM_DATA(value_datum) = CS (&now);
797 EXIM_DATUM_SIZE(value_datum) = (int)sizeof(time_t);
798 EXIM_DBPUT(dbm_file, key_datum, value_datum);
801 /* If sending failed, defer to try again - but if once is set the next
802 try will skip, of course. However, if there were no recipients in the
803 message, we do not fail. */
807 if (rc == EXIT_NORECIPIENTS)
809 DEBUG(D_any) debug_printf("%s transport: message contained no recipients\n",
814 addr->transport_return = DEFER;
815 addr->message = string_sprintf("Failed to send message from %s "
816 "transport (%d)", tblock->name, rc);
821 /* Log the sending of the message if successful and required. If the file
822 fails to open, it's hard to know what to do. We cannot write to the Exim
823 log from here, since we may be running under an unprivileged uid. We don't
824 want to fail the delivery, since the message has been successfully sent. For
825 the moment, ignore open failures. Write the log entry as a single write() to a
826 file opened for appending, in order to avoid interleaving of output from
827 different processes. The log_buffer can be used exactly as for main log
832 int log_fd = Uopen(logfile, O_WRONLY|O_APPEND|O_CREAT, ob->mode);
835 uschar *ptr = log_buffer;
836 DEBUG(D_transport) debug_printf("logging message details\n");
837 sprintf(CS ptr, "%s\n", tod_stamp(tod_log));
841 (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
842 " From: %s\n", from);
847 (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
853 (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
859 (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
865 (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
866 " Subject: %s\n", subject);
871 (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
875 if(write(log_fd, log_buffer, ptr - log_buffer) != ptr-log_buffer
877 DEBUG(D_transport) debug_printf("Problem writing log file %s for %s "
878 "transport\n", logfile, tblock->name);
880 else DEBUG(D_transport) debug_printf("Failed to open log file %s for %s "
881 "transport: %s\n", logfile, tblock->name, strerror(errno));
885 if (dbm_file) EXIM_DBCLOSE(dbm_file);
886 if (cache_fd > 0) (void)close(cache_fd);
888 DEBUG(D_transport) debug_printf("%s transport succeeded\n", tblock->name);
893 #endif /*!MACRO_PREDEF*/
894 /* End of transport/autoreply.c */