src/src/moan.c

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