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