src/src/moan.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2015 */
   6 /* See the file NOTICE for conditions of use and distribution. */
   7
   8 /* Functions for sending messages to sender or to mailmaster. */
   9
  10
  11 #include "exim.h"
  12
  13
  14
  15 /*************************************************
  16 *            Write From: line for DSN            *
  17 *************************************************/
  18
  19 /* This function is called to write the From: line in automatically generated
  20 messages - bounces, warnings, etc. It expands a configuration item in order to
  21 get the text. If the expansion fails, a panic is logged and the default value
  22 for the option is used.
  23
  24 Argument:   the FILE to write to
  25 Returns:    nothing
  26 */
  27
  28 void
  29 moan_write_from(FILE *f)
  30 {
  31 uschar *s = expand_string(dsn_from);
  32 if (s == NULL)
  33   {
  34   log_write(0, LOG_MAIN|LOG_PANIC,
  35     "Failed to expand dsn_from (using default): %s", expand_string_message);
  36   s = expand_string(US DEFAULT_DSN_FROM);
  37   }
  38 fprintf(f, "From: %s\n", s);
  39 }
  40
  41
  42
  43 /*************************************************
  44 *              Send error message                *
  45 *************************************************/
  46
  47 /* This function sends an error message by opening a pipe to a new process
  48 running Exim, and writing a message to it using the "-t" option. This is not
  49 used for delivery failures, which have their own code for handing failed
  50 addresses.
  51
  52 Arguments:
  53   recipient      addressee for the message
  54   ident          identifies the type of error
  55   eblock         chain of error_blocks containing data about the error
  56   headers        the message's headers
  57   message_file   FILE containing the body of the message
  58   firstline      contains first line of file, if it was read to check for
  59                    "From ", but it turned out not to be
  60
  61 Returns:         TRUE if message successfully sent
  62 */
  63
  64 static BOOL
  65 moan_send_message(uschar *recipient, int ident, error_block *eblock,
  66   header_line *headers, FILE *message_file, uschar *firstline)
  67 {
  68 int written = 0;
  69 int fd;
  70 int status;
  71 int count = 0;
  72 int size_limit = bounce_return_size_limit;
  73 FILE *f;
  74 int pid = child_open_exim(&fd);
  75
  76 /* Creation of child failed */
  77
  78 if (pid < 0)
  79   {
  80   DEBUG(D_any) debug_printf("Failed to create child to send message: %s\n",
  81     strerror(errno));
  82   return FALSE;
  83   }
  84 else DEBUG(D_any) debug_printf("Child process %d for sending message\n", pid);
  85
  86 /* Creation of child succeeded */
  87
  88 f = fdopen(fd, "wb");
  89 if (errors_reply_to) fprintf(f, "Reply-To: %s\n", errors_reply_to);
  90 fprintf(f, "Auto-Submitted: auto-replied\n");
  91 moan_write_from(f);
  92 fprintf(f, "To: %s\n", recipient);
  93
  94 switch(ident)
  95   {
  96   case ERRMESS_BADARGADDRESS:
  97     fprintf(f,
  98       "Subject: Mail failure - malformed recipient address\n\n");
  99     fprintf(f,
 100       "A message that you sent contained a recipient address that was incorrectly\n"
 101       "constructed:\n\n");
 102     fprintf(f, "  %s  %s\n", eblock->text1, eblock->text2);
 103     count = Ustrlen(eblock->text1);
 104     if (count > 0 && eblock->text1[count-1] == '.')
 105       fprintf(f,
 106         "\nRecipient addresses must not end with a '.' character.\n");
 107     fprintf(f,
 108       "\nThe message has not been delivered to any recipients.\n");
 109     break;
 110
 111   case ERRMESS_BADNOADDRESS:
 112   case ERRMESS_BADADDRESS:
 113     fprintf(f,
 114       "Subject: Mail failure - malformed recipient address\n\n");
 115     fprintf(f,
 116       "A message that you sent contained one or more recipient addresses that were\n"
 117       "incorrectly constructed:\n\n");
 118
 119     while (eblock != NULL)
 120       {
 121       fprintf(f, "  %s: %s\n", eblock->text1, eblock->text2);
 122       count++;
 123       eblock = eblock->next;
 124       }
 125
 126     fprintf(f, (count == 1)? "\nThis address has been ignored. " :
 127       "\nThese addresses have been ignored. ");
 128
 129     fprintf(f, (ident == ERRMESS_BADADDRESS)?
 130       "The other addresses in the message were\n"
 131       "syntactically valid and have been passed on for an attempt at delivery.\n" :
 132
 133       "There were no other addresses in your\n"
 134       "message, and so no attempt at delivery was possible.\n");
 135     break;
 136
 137   case ERRMESS_IGADDRESS:
 138     fprintf(f, "Subject: Mail failure - no recipient addresses\n\n");
 139     fprintf(f,
 140       "A message that you sent using the -t command line option contained no\n"
 141       "addresses that were not also on the command line, and were therefore\n"
 142       "suppressed. This left no recipient addresses, and so no delivery could\n"
 143       "be attempted.\n");
 144     break;
 145
 146   case ERRMESS_NOADDRESS:
 147     fprintf(f, "Subject: Mail failure - no recipient addresses\n\n");
 148     fprintf(f,
 149       "A message that you sent contained no recipient addresses, and therefore no\n"
 150       "delivery could be attempted.\n");
 151     break;
 152
 153   case ERRMESS_IOERR:
 154     fprintf(f, "Subject: Mail failure - system failure\n\n");
 155     fprintf(f,
 156       "A system failure was encountered while processing a message that you sent,\n"
 157       "so it has not been possible to deliver it. The error was:\n\n%s\n",
 158       eblock->text1);
 159     break;
 160
 161   case ERRMESS_VLONGHEADER:
 162     fprintf(f, "Subject: Mail failure - overlong header section\n\n");
 163     fprintf(f,
 164       "A message that you sent contained a header section that was excessively\n"
 165       "long and could not be handled by the mail transmission software. The\n"
 166       "message has not been delivered to any recipients.\n");
 167     break;
 168
 169   case ERRMESS_VLONGHDRLINE:
 170     fprintf(f, "Subject: Mail failure - overlong header line\n\n");
 171     fprintf(f,
 172       "A message that you sent contained a header line that was excessively\n"
 173       "long and could not be handled by the mail transmission software. The\n"
 174       "message has not been delivered to any recipients.\n");
 175     break;
 176
 177   case ERRMESS_TOOBIG:
 178     fprintf(f, "Subject: Mail failure - message too big\n\n");
 179     fprintf(f,
 180       "A message that you sent was longer than the maximum size allowed on this\n"
 181       "system. It was not delivered to any recipients.\n");
 182     break;
 183
 184   case ERRMESS_TOOMANYRECIP:
 185     fprintf(f, "Subject: Mail failure - too many recipients\n\n");
 186     fprintf(f,
 187       "A message that you sent contained more recipients than allowed on this\n"
 188       "system. It was not delivered to any recipients.\n");
 189     break;
 190
 191   case ERRMESS_LOCAL_SCAN:
 192   case ERRMESS_LOCAL_ACL:
 193     fprintf(f, "Subject: Mail failure - rejected by local scanning code\n\n");
 194     fprintf(f,
 195       "A message that you sent was rejected by the local scanning code that\n"
 196       "checks incoming messages on this system.");
 197       if (eblock->text1)
 198         fprintf(f, " The following error was given:\n\n  %s", eblock->text1);
 199   fprintf(f, "\n");
 200   break;
 201
 202 #ifdef EXPERIMENTAL_DMARC
 203   case ERRMESS_DMARC_FORENSIC:
 204     bounce_return_message = TRUE;
 205     bounce_return_body    = FALSE;
 206     fprintf(f,
 207           "Subject: DMARC Forensic Report for %s from IP %s\n\n",
 208           ((eblock == NULL) ? US"Unknown" : eblock->text2),
 209           sender_host_address);
 210     fprintf(f,
 211       "A message claiming to be from you has failed the published DMARC\n"
 212       "policy for your domain.\n\n");
 213     while (eblock != NULL)
 214       {
 215       fprintf(f, "  %s: %s\n", eblock->text1, eblock->text2);
 216       count++;
 217       eblock = eblock->next;
 218       }
 219   break;
 220 #endif
 221
 222   default:
 223     fprintf(f, "Subject: Mail failure\n\n");
 224     fprintf(f,
 225       "A message that you sent has caused the error routine to be entered with\n"
 226       "an unknown error number (%d).\n", ident);
 227     break;
 228   }
 229
 230 /* Now, if configured, copy the message; first the headers and then the rest of
 231 the input if available, up to the configured limit, if the option for including
 232 message bodies in bounces is set. */
 233
 234 if (bounce_return_message)
 235   {
 236   if (bounce_return_body)
 237     {
 238     fprintf(f, "\n"
 239       "------ This is a copy of your message, including all the headers.");
 240     if (size_limit == 0 || size_limit > thismessage_size_limit)
 241       size_limit = thismessage_size_limit;
 242     if (size_limit > 0 && size_limit < message_size)
 243       {
 244       int x = size_limit;
 245       uschar *k = US"";
 246       if ((x & 1023) == 0)
 247         {
 248         k = US"K";
 249         x >>= 10;
 250         }
 251       fprintf(f, "\n"
 252         "------ No more than %d%s characters of the body are included.\n\n",
 253           x, k);
 254       }
 255     else fprintf(f, " ------\n\n");
 256     }
 257   else
 258     {
 259     fprintf(f, "\n"
 260       "------ This is a copy of the headers that were received before the "
 261       "error\n       was detected.\n\n");
 262     }
 263
 264   /* If the error occurred before the Received: header was created, its text
 265   field will still be NULL; just omit such a header line. */
 266
 267   while (headers)
 268     {
 269     if (headers->text != NULL) fprintf(f, "%s", CS headers->text);
 270     headers = headers->next;
 271     }
 272
 273   if (ident != ERRMESS_VLONGHEADER && ident != ERRMESS_VLONGHDRLINE)
 274     fputc('\n', f);
 275
 276   /* After early detection of an error, the message file may be STDIN,
 277   in which case we might have to terminate on a line containing just "."
 278   as well as on EOF. We may already have the first line in memory. */
 279
 280   if (bounce_return_body && message_file)
 281     {
 282     int ch;
 283     enum {midline, beginline, haddot} state = beginline;
 284     BOOL enddot = dot_ends && message_file == stdin;
 285     uschar * buf = store_get(bounce_return_linesize_limit+2);
 286
 287     if (firstline) fprintf(f, "%s", CS firstline);
 288
 289     while (fgets(buf, bounce_return_linesize_limit+2, message_file))
 290       {
 291       int len;
 292
 293       if (enddot && *buf == '.' && buf[1] == '\n')
 294         {
 295         fputc('.', f);
 296         break;
 297         }
 298
 299       len = Ustrlen(buf);
 300       if (buf[len-1] != '\n')
 301         {       /* eat rest of partial line */
 302         int ch;
 303         while ((ch = fgetc(message_file)) != EOF && ch != '\n') ;
 304         }
 305
 306       if (size_limit > 0 && len > size_limit - written)
 307         {
 308         buf[size_limit - written] = '\0';
 309         fputs(buf, f);
 310         break;
 311         }
 312
 313       fputs(buf, f);
 314       }
 315     }
 316 #ifdef EXPERIMENTAL_DMARC
 317   /* Overkill, but use exact test in case future code gets inserted */
 318   else if (bounce_return_body && message_file == NULL)
 319     {
 320     /*XXX limit line length here? */
 321     /* This doesn't print newlines, disable until can parse and fix
 322      * output to be legible.  */
 323     fprintf(f, "%s", expand_string(US"$message_body"));
 324     }
 325 #endif
 326   }
 327 /* Close the file, which should send an EOF to the child process
 328 that is receiving the message. Wait for it to finish, without a timeout. */
 329
 330 (void)fclose(f);
 331 status = child_close(pid, 0);  /* Waits for child to close */
 332 if (status != 0)
 333   {
 334   uschar *msg = US"Child mail process returned status";
 335   if (status == -257)
 336     log_write(0, LOG_MAIN, "%s %d: errno=%d: %s", msg, status, errno,
 337       strerror(errno));
 338   else
 339     log_write(0, LOG_MAIN, "%s %d", msg, status);
 340   return FALSE;
 341   }
 342
 343 return TRUE;
 344 }
 345
 346
 347
 348 /*************************************************
 349 *          Send message to sender                *
 350 *************************************************/
 351
 352 /* This function is called when errors are detected during the receipt of a
 353 message. Delivery failures are handled separately in deliver.c.
 354
 355 If there is a valid sender_address, and the failing message is not a local
 356 error message, then this function calls moan_send_message to send a message to
 357 that person. If the sender's address is null, then an error has occurred with a
 358 message that was generated by a mailer daemon. All we can do is to write
 359 information to log files. The same action is taken if local_error_message is
 360 set - this can happen for non null-senders in certain configurations where exim
 361 doesn't run setuid root.
 362
 363 Arguments:
 364   ident         identifies the particular error
 365   eblock        chain of error_blocks containing data about the error
 366   headers       message's headers (chain)
 367   message_file  a FILE where the body of the message can be read
 368   check_sender  if TRUE, read the first line of the file for a possible
 369                   "From " sender (if a trusted caller)
 370
 371 Returns:        FALSE if there is no sender_address to send to;
 372                 else the return from moan_send_message()
 373 */
 374
 375 BOOL
 376 moan_to_sender(int ident, error_block *eblock, header_line *headers,
 377   FILE *message_file, BOOL check_sender)
 378 {
 379 uschar *firstline = NULL;
 380 uschar *msg = US"Error while reading message with no usable sender address";
 381
 382 if (message_reference)
 383   msg = string_sprintf("%s (R=%s)", msg, message_reference);
 384
 385 /* Find the sender from a From line if permitted and possible */
 386
 387 if (check_sender && message_file && trusted_caller &&
 388     Ufgets(big_buffer, BIG_BUFFER_SIZE, message_file) != NULL)
 389   {
 390   uschar *new_sender = NULL;
 391   if (regex_match_and_setup(regex_From, big_buffer, 0, -1))
 392     new_sender = expand_string(uucp_from_sender);
 393   if (new_sender) sender_address = new_sender;
 394     else firstline = big_buffer;
 395   }
 396
 397 /* If viable sender address, send a message */
 398
 399 if (sender_address && sender_address[0] && !local_error_message)
 400   return moan_send_message(sender_address, ident, eblock, headers,
 401     message_file, firstline);
 402
 403 /* Otherwise, we can only log */
 404
 405 switch(ident)
 406   {
 407   case ERRMESS_BADARGADDRESS:
 408   case ERRMESS_BADNOADDRESS:
 409   case ERRMESS_BADADDRESS:
 410   log_write(0, LOG_MAIN, "%s: at least one malformed recipient address: "
 411     "%s - %s", msg, eblock->text1, eblock->text2);
 412   break;
 413
 414   case ERRMESS_IGADDRESS:
 415   case ERRMESS_NOADDRESS:
 416   log_write(0, LOG_MAIN, "%s: no recipient addresses", msg);
 417   break;
 418
 419   /* This error has already been logged. */
 420   case ERRMESS_IOERR:
 421   break;
 422
 423   case ERRMESS_VLONGHEADER:
 424   log_write(0, LOG_MAIN, "%s: excessively long message header section read "
 425     "(more than %d characters)", msg, header_maxsize);
 426   break;
 427
 428   case ERRMESS_VLONGHDRLINE:
 429   log_write(0, LOG_MAIN, "%s: excessively long message header line read "
 430     "(more than %d characters)", msg, header_line_maxsize);
 431   break;
 432
 433   case ERRMESS_TOOBIG:
 434   log_write(0, LOG_MAIN, "%s: message too big (limit set to %d)", msg,
 435     thismessage_size_limit);
 436   break;
 437
 438   case ERRMESS_TOOMANYRECIP:
 439   log_write(0, LOG_MAIN, "%s: too many recipients (max set to %d)", msg,
 440     recipients_max);
 441   break;
 442
 443   case ERRMESS_LOCAL_SCAN:
 444   log_write(0, LOG_MAIN, "%s: rejected by local_scan: %s", msg, eblock->text1);
 445   break;
 446
 447   case ERRMESS_LOCAL_ACL:
 448   log_write(0, LOG_MAIN, "%s: rejected by non-SMTP ACL: %s", msg, eblock->text1);
 449   break;
 450
 451   default:
 452   log_write(0, LOG_MAIN|LOG_PANIC, "%s: unknown error number %d", msg,
 453     ident);
 454   break;
 455   }
 456
 457 return FALSE;
 458 }
 459
 460
 461
 462 /*************************************************
 463 *            Send message to someone             *
 464 *************************************************/
 465
 466 /* This is called when exim is configured to tell someone (often the
 467 mailmaster) about some incident.
 468
 469 Arguments:
 470   who           address to send mail to
 471   addr          chain of deferred addresses whose details are to be included
 472   subject       subject text for the message
 473   format        a printf() format for the body of the message
 474   ...           arguments for the format
 475
 476 Returns:        nothing
 477 */
 478
 479 void
 480 moan_tell_someone(uschar *who, address_item *addr,
 481   const uschar *subject, const char *format, ...)
 482 {
 483 FILE *f;
 484 va_list ap;
 485 int fd;
 486 int pid = child_open_exim(&fd);
 487
 488 if (pid < 0)
 489   {
 490   DEBUG(D_any) debug_printf("Failed to create child to send message: %s\n",
 491     strerror(errno));
 492   return;
 493   }
 494
 495 f = fdopen(fd, "wb");
 496 fprintf(f, "Auto-Submitted: auto-replied\n");
 497 moan_write_from(f);
 498 fprintf(f, "To: %s\n", who);
 499 fprintf(f, "Subject: %s\n\n", subject);
 500 va_start(ap, format);
 501 vfprintf(f, format, ap);
 502 va_end(ap);
 503
 504 if (addr != NULL)
 505   {
 506   fprintf(f, "\nThe following address(es) have yet to be delivered:\n");
 507   for (; addr != NULL; addr = addr->next)
 508     {
 509     uschar *parent = (addr->parent == NULL)? NULL : addr->parent->address;
 510     fprintf(f, "  %s", addr->address);
 511     if (parent != NULL) fprintf(f, " <%s>", parent);
 512     if (addr->basic_errno > 0) fprintf(f, ": %s", strerror(addr->basic_errno));
 513     if (addr->message != NULL) fprintf(f, ": %s", addr->message);
 514     fprintf(f, "\n");
 515     }
 516   }
 517
 518 (void)fclose(f);
 519 child_close(pid, 0);  /* Waits for child to close; no timeout */
 520 }
 521
 522
 523
 524 /*************************************************
 525 *            Handle SMTP batch error             *
 526 *************************************************/
 527
 528 /* This is called when something goes wrong in batched (-bS) SMTP input.
 529 Information is written to stdout and/or stderr, and Exim exits with a non-zero
 530 completion code. BSMTP is almost always called by some other program, so it is
 531 up to that program to interpret the return code and do something with the error
 532 information, and also to preserve the batch input file for human analysis.
 533
 534 Formerly, Exim used to attempt to continue after some errors, but this strategy
 535 has been abandoned as it can lead to loss of messages.
 536
 537 Arguments:
 538   cmd_buffer   the command causing the error, or NULL
 539   format       a printf() format
 540   ...          arguments for the format
 541
 542 Returns:       does not return; exits from the program
 543                exit code = 1 if some messages were accepted
 544                exit code = 2 if no messages were accepted
 545 */
 546
 547 void
 548 moan_smtp_batch(uschar *cmd_buffer, const char *format, ...)
 549 {
 550 va_list ap;
 551 int yield = (receive_messagecount > 0)? 1 : 2;
 552
 553 DEBUG(D_any) debug_printf("Handling error in batched SMTP input\n");
 554
 555 /* On stdout, write stuff that a program could parse fairly easily. */
 556
 557 va_start(ap, format);
 558 vfprintf(stdout, format, ap);
 559 va_end(ap);
 560
 561 fprintf(stdout, "\nTransaction started in line %d\n",
 562   bsmtp_transaction_linecount);
 563 fprintf(stdout,   "Error detected in line %d\n", receive_linecount);
 564 if (cmd_buffer != NULL) fprintf(stdout, "%s\n", cmd_buffer);
 565
 566 /* On stderr, write stuff for human consumption */
 567
 568 fprintf(stderr,
 569   "An error was detected while processing a file of BSMTP input.\n"
 570   "The error message was:\n\n  ");
 571
 572 va_start(ap, format);
 573 vfprintf(stderr, format, ap);
 574 va_end(ap);
 575
 576 fprintf(stderr,
 577   "\n\nThe SMTP transaction started in line %d.\n"
 578       "The error was detected in line %d.\n",
 579   bsmtp_transaction_linecount, receive_linecount);
 580
 581 if (cmd_buffer != NULL)
 582   {
 583   fprintf(stderr, "The SMTP command at fault was:\n\n   %s\n\n",
 584     cmd_buffer);
 585   }
 586
 587 fprintf(stderr, "%d previous message%s successfully processed.\n",
 588   receive_messagecount, (receive_messagecount == 1)? " was" : "s were");
 589
 590 fprintf(stderr, "The rest of the batch was abandoned.\n");
 591
 592 exim_exit(yield);
 593 }
 594
 595
 596
 597
 598 /*************************************************
 599 *         Check for error copies                 *
 600 *************************************************/
 601
 602 /* This function is passed the recipient of an error message, and must check
 603 the error_copies string to see whether there is an additional recipient list to
 604 which errors for this recipient must be bcc'd. The incoming recipient is always
 605 fully qualified.
 606
 607 Argument:   recipient address
 608 Returns:    additional recipient list or NULL
 609 */
 610
 611 uschar *
 612 moan_check_errorcopy(uschar *recipient)
 613 {
 614 uschar *item, *localpart, *domain;
 615 const uschar *listptr = errors_copy;
 616 uschar *yield = NULL;
 617 uschar buffer[256];
 618 int sep = 0;
 619 int llen;
 620
 621 if (errors_copy == NULL) return NULL;
 622
 623 /* Set up pointer to the local part and domain, and compute the
 624 length of the local part. */
 625
 626 localpart = recipient;
 627 domain = Ustrrchr(recipient, '@');
 628 if (domain == NULL) return NULL;  /* should not occur, but avoid crash */
 629 llen = domain++ - recipient;
 630
 631 /* Scan through the configured items */
 632
 633 while ((item = string_nextinlist(&listptr, &sep, buffer, sizeof(buffer)))
 634        != NULL)
 635   {
 636   const uschar *newaddress = item;
 637   const uschar *pattern = string_dequote(&newaddress);
 638
 639   /* If no new address found, just skip this item. */
 640
 641   while (isspace(*newaddress)) newaddress++;
 642   if (*newaddress == 0) continue;
 643
 644   /* We now have an item to match as an address in item, and the additional
 645   address in newaddress. If the pattern matches, expand the new address string
 646   and return it. During expansion, make local part and domain available for
 647   insertion. This requires a copy to be made; we can't just temporarily
 648   terminate it, as the whole address is required for $0. */
 649
 650   if (match_address_list(recipient, TRUE, TRUE, &pattern, NULL, 0, UCHAR_MAX+1,
 651         NULL) == OK)
 652     {
 653     deliver_localpart = string_copyn(localpart, llen);
 654     deliver_domain = domain;
 655     yield = expand_string_copy(newaddress);
 656     deliver_domain = deliver_localpart = NULL;
 657     if (yield == NULL)
 658       log_write(0, LOG_MAIN|LOG_PANIC, "Failed to expand %s when processing "
 659         "errors_copy: %s", newaddress, expand_string_message);
 660     break;
 661     }
 662   }
 663
 664 DEBUG(D_any) debug_printf("errors_copy check returned %s\n",
 665   (yield == NULL)? US"NULL" : yield);
 666
 667 expand_nmax = -1;
 668 return yield;
 669 }
 670
 671
 672
 673 /************************************************
 674 *        Handle skipped syntax errors           *
 675 ************************************************/
 676
 677 /* This function is called by the redirect router when it has skipped over one
 678 or more syntax errors in the list of addresses. If there is an address to mail
 679 to, send a message, and always write the information to the log. In the case of
 680 a filter file, a "syntax error" might actually be something else, such as the
 681 inability to open a log file. Thus, the wording of the error message is
 682 general.
 683
 684 Arguments:
 685   rname             the router name
 686   eblock            chain of error blocks
 687   syntax_errors_to  address to send mail to, or NULL
 688   some              TRUE if some addresses were generated; FALSE if none were
 689   custom            custom message text
 690
 691 Returns:            FALSE if string expansion failed; TRUE otherwise
 692 */
 693
 694 BOOL
 695 moan_skipped_syntax_errors(uschar *rname, error_block *eblock,
 696   uschar *syntax_errors_to, BOOL some, uschar *custom)
 697 {
 698 int pid, fd;
 699 uschar *s, *t;
 700 FILE *f;
 701 error_block *e;
 702
 703 for (e = eblock; e != NULL; e = e->next)
 704   {
 705   if (e->text2 != NULL)
 706     log_write(0, LOG_MAIN, "%s router: skipped error: %s in \"%s\"",
 707       rname, e->text1, e->text2);
 708   else
 709     log_write(0, LOG_MAIN, "%s router: skipped error: %s", rname,
 710       e->text1);
 711   }
 712
 713 if (syntax_errors_to == NULL) return TRUE;
 714
 715 s = expand_string(syntax_errors_to);
 716 if (s == NULL)
 717   {
 718   log_write(0, LOG_MAIN, "%s router failed to expand %s: %s", rname,
 719     syntax_errors_to, expand_string_message);
 720   return FALSE;
 721   }
 722
 723 /* If we can't create a process to send the message, just forget about
 724 it. */
 725
 726 pid = child_open_exim(&fd);
 727
 728 if (pid < 0)
 729   {
 730   DEBUG(D_any) debug_printf("Failed to create child to send message: %s\n",
 731     strerror(errno));
 732   return TRUE;
 733   }
 734
 735 f = fdopen(fd, "wb");
 736 fprintf(f, "Auto-Submitted: auto-replied\n");
 737 moan_write_from(f);
 738 fprintf(f, "To: %s\n", s);
 739 fprintf(f, "Subject: error(s) in forwarding or filtering\n\n");
 740
 741 if (custom != NULL)
 742   {
 743   t = expand_string(custom);
 744   if (t == NULL)
 745     {
 746     log_write(0, LOG_MAIN, "%s router failed to expand %s: %s", rname,
 747       custom, expand_string_message);
 748     return FALSE;
 749     }
 750   fprintf(f, "%s\n\n", t);
 751   }
 752
 753 fprintf(f, "The %s router encountered the following error(s):\n\n",
 754   rname);
 755
 756 for (e = eblock; e != NULL; e = e->next)
 757   {
 758   fprintf(f, "  %s", e->text1);
 759   if (e->text2 != NULL)
 760     fprintf(f, " in the address\n  \"%s\"", e->text2);
 761   fprintf(f, "\n\n");
 762   }
 763
 764 if (some)
 765   fprintf(f, "Other addresses were processed normally.\n");
 766 else
 767   fprintf(f, "No valid addresses were generated.\n");
 768
 769 (void)fclose(f);
 770 child_close(pid, 0);  /* Waits for child to close; no timeout */
 771
 772 return TRUE;
 773 }
 774
 775 /* End of moan.c */