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