4d7b51b9a8bbbabc4ee2928d4b2e6d76fef6da84
[users/jgh/exim.git] / src / src / moan.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2014 */
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 != NULL) 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 != NULL)
198     {
199     fprintf(f,
200     " The following error was given:\n\n  %s", eblock->text1);
201     }
202   fprintf(f, "\n");
203   break;
204
205 #ifdef EXPERIMENTAL_DMARC
206   case ERRMESS_DMARC_FORENSIC:
207   bounce_return_message = TRUE;
208   bounce_return_body    = FALSE;
209   fprintf(f,
210           "Subject: DMARC Forensic Report for %s from IP %s\n\n",
211           ((eblock == NULL) ? US"Unknown" : eblock->text2),
212           sender_host_address);
213   fprintf(f,
214   "A message claiming to be from you has failed the published DMARC\n"
215   "policy for your domain.\n\n");
216   while (eblock != NULL)
217     {
218     fprintf(f, "  %s: %s\n", eblock->text1, eblock->text2);
219     count++;
220     eblock = eblock->next;
221     }
222   break;
223 #endif
224
225   default:
226   fprintf(f, "Subject: Mail failure\n\n");
227   fprintf(f,
228   "A message that you sent has caused the error routine to be entered with\n"
229   "an unknown error number (%d).\n", ident);
230   break;
231   }
232
233 /* Now, if configured, copy the message; first the headers and then the rest of
234 the input if available, up to the configured limit, if the option for including
235 message bodies in bounces is set. */
236
237 if (bounce_return_message)
238   {
239   if (bounce_return_body)
240     {
241     fprintf(f, "\n"
242       "------ This is a copy of your message, including all the headers.");
243     if (size_limit == 0 || size_limit > thismessage_size_limit)
244       size_limit = thismessage_size_limit;
245     if (size_limit > 0 && size_limit < message_size)
246       {
247       int x = size_limit;
248       uschar *k = US"";
249       if ((x & 1023) == 0)
250         {
251         k = US"K";
252         x >>= 10;
253         }
254       fprintf(f, "\n"
255         "------ No more than %d%s characters of the body are included.\n\n",
256           x, k);
257       }
258     else fprintf(f, " ------\n\n");
259     }
260   else
261     {
262     fprintf(f, "\n"
263       "------ This is a copy of the headers that were received before the "
264       "error\n       was detected.\n\n");
265     }
266
267   /* If the error occurred before the Received: header was created, its text
268   field will still be NULL; just omit such a header line. */
269
270   while (headers != NULL)
271     {
272     if (headers->text != NULL) fprintf(f, "%s", CS headers->text);
273     headers = headers->next;
274     }
275
276   if (ident != ERRMESS_VLONGHEADER && ident != ERRMESS_VLONGHDRLINE)
277     fputc('\n', f);
278
279   /* After early detection of an error, the message file may be STDIN,
280   in which case we might have to terminate on a line containing just "."
281   as well as on EOF. We may already have the first line in memory. */
282
283   if (bounce_return_body && message_file != NULL)
284     {
285     int ch;
286     int state = 1;
287     BOOL enddot = dot_ends && message_file == stdin;
288     if (firstline != NULL) fprintf(f, "%s", CS firstline);
289     while ((ch = fgetc(message_file)) != EOF)
290       {
291       fputc(ch, f);
292       if (size_limit > 0 && ++written > size_limit) break;
293       if (enddot)
294         {
295         if (state == 0) { if (ch == '\n') state = 1; }
296         else if (state == 1)
297           { if (ch == '.') state = 2; else if (ch != '\n') state = 0; }
298         else
299           { if (ch == '\n') break; else state = 0; }
300         }
301       }
302     }
303 #ifdef EXPERIMENTAL_DMARC
304   /* Overkill, but use exact test in case future code gets inserted */
305   else if (bounce_return_body && message_file == NULL)
306     {
307     /* This doesn't print newlines, disable until can parse and fix
308      * output to be legible.  */
309     fprintf(f, "%s", expand_string(US"$message_body"));
310     }
311 #endif
312   }
313 /* Close the file, which should send an EOF to the child process
314 that is receiving the message. Wait for it to finish, without a timeout. */
315
316 (void)fclose(f);
317 status = child_close(pid, 0);  /* Waits for child to close */
318 if (status != 0)
319   {
320   uschar *msg = US"Child mail process returned status";
321   if (status == -257)
322     log_write(0, LOG_MAIN, "%s %d: errno=%d: %s", msg, status, errno,
323       strerror(errno));
324   else
325     log_write(0, LOG_MAIN, "%s %d", msg, status);
326   return FALSE;
327   }
328
329 return TRUE;
330 }
331
332
333
334 /*************************************************
335 *          Send message to sender                *
336 *************************************************/
337
338 /* This function is called when errors are detected during the receipt of a
339 message. Delivery failures are handled separately in deliver.c.
340
341 If there is a valid sender_address, and the failing message is not a local
342 error message, then this function calls moan_send_message to send a message to
343 that person. If the sender's address is null, then an error has occurred with a
344 message that was generated by a mailer daemon. All we can do is to write
345 information to log files. The same action is taken if local_error_message is
346 set - this can happen for non null-senders in certain configurations where exim
347 doesn't run setuid root.
348
349 Arguments:
350   ident         identifies the particular error
351   eblock        chain of error_blocks containing data about the error
352   headers       message's headers (chain)
353   message_file  a FILE where the body of the message can be read
354   check_sender  if TRUE, read the first line of the file for a possible
355                   "From " sender (if a trusted caller)
356
357 Returns:        FALSE if there is no sender_address to send to;
358                 else the return from moan_send_message()
359 */
360
361 BOOL
362 moan_to_sender(int ident, error_block *eblock, header_line *headers,
363   FILE *message_file, BOOL check_sender)
364 {
365 uschar *firstline = NULL;
366 uschar *msg = US"Error while reading message with no usable sender address";
367
368 if (message_reference != NULL)
369   msg = string_sprintf("%s (R=%s)", msg, message_reference);
370
371 /* Find the sender from a From line if permitted and possible */
372
373 if (check_sender && message_file != NULL && trusted_caller &&
374     Ufgets(big_buffer, BIG_BUFFER_SIZE, message_file) != NULL)
375   {
376   uschar *new_sender = NULL;
377   if (regex_match_and_setup(regex_From, big_buffer, 0, -1))
378     new_sender = expand_string(uucp_from_sender);
379   if (new_sender != NULL) sender_address = new_sender;
380     else firstline = big_buffer;
381   }
382
383 /* If viable sender address, send a message */
384
385 if (sender_address != NULL && sender_address[0] != 0 && !local_error_message)
386   return moan_send_message(sender_address, ident, eblock, headers,
387     message_file, firstline);
388
389 /* Otherwise, we can only log */
390
391 switch(ident)
392   {
393   case ERRMESS_BADARGADDRESS:
394   case ERRMESS_BADNOADDRESS:
395   case ERRMESS_BADADDRESS:
396   log_write(0, LOG_MAIN, "%s: at least one malformed recipient address: "
397     "%s - %s", msg, eblock->text1, eblock->text2);
398   break;
399
400   case ERRMESS_IGADDRESS:
401   case ERRMESS_NOADDRESS:
402   log_write(0, LOG_MAIN, "%s: no recipient addresses", msg);
403   break;
404
405   /* This error has already been logged. */
406   case ERRMESS_IOERR:
407   break;
408
409   case ERRMESS_VLONGHEADER:
410   log_write(0, LOG_MAIN, "%s: excessively long message header section read "
411     "(more than %d characters)", msg, header_maxsize);
412   break;
413
414   case ERRMESS_VLONGHDRLINE:
415   log_write(0, LOG_MAIN, "%s: excessively long message header line read "
416     "(more than %d characters)", msg, header_line_maxsize);
417   break;
418
419   case ERRMESS_TOOBIG:
420   log_write(0, LOG_MAIN, "%s: message too big (limit set to %d)", msg,
421     thismessage_size_limit);
422   break;
423
424   case ERRMESS_TOOMANYRECIP:
425   log_write(0, LOG_MAIN, "%s: too many recipients (max set to %d)", msg,
426     recipients_max);
427   break;
428
429   case ERRMESS_LOCAL_SCAN:
430   log_write(0, LOG_MAIN, "%s: rejected by local_scan: %s", msg, eblock->text1);
431   break;
432
433   case ERRMESS_LOCAL_ACL:
434   log_write(0, LOG_MAIN, "%s: rejected by non-SMTP ACL: %s", msg, eblock->text1);
435   break;
436
437   default:
438   log_write(0, LOG_MAIN|LOG_PANIC, "%s: unknown error number %d", msg,
439     ident);
440   break;
441   }
442
443 return FALSE;
444 }
445
446
447
448 /*************************************************
449 *            Send message to someone             *
450 *************************************************/
451
452 /* This is called when exim is configured to tell someone (often the
453 mailmaster) about some incident.
454
455 Arguments:
456   who           address to send mail to
457   addr          chain of deferred addresses whose details are to be included
458   subject       subject text for the message
459   format        a printf() format for the body of the message
460   ...           arguments for the format
461
462 Returns:        nothing
463 */
464
465 void
466 moan_tell_someone(uschar *who, address_item *addr,
467   const uschar *subject, const char *format, ...)
468 {
469 FILE *f;
470 va_list ap;
471 int fd;
472 int pid = child_open_exim(&fd);
473
474 if (pid < 0)
475   {
476   DEBUG(D_any) debug_printf("Failed to create child to send message: %s\n",
477     strerror(errno));
478   return;
479   }
480
481 f = fdopen(fd, "wb");
482 fprintf(f, "Auto-Submitted: auto-replied\n");
483 moan_write_from(f);
484 fprintf(f, "To: %s\n", who);
485 fprintf(f, "Subject: %s\n\n", subject);
486 va_start(ap, format);
487 vfprintf(f, format, ap);
488 va_end(ap);
489
490 if (addr != NULL)
491   {
492   fprintf(f, "\nThe following address(es) have yet to be delivered:\n");
493   for (; addr != NULL; addr = addr->next)
494     {
495     uschar *parent = (addr->parent == NULL)? NULL : addr->parent->address;
496     fprintf(f, "  %s", addr->address);
497     if (parent != NULL) fprintf(f, " <%s>", parent);
498     if (addr->basic_errno > 0) fprintf(f, ": %s", strerror(addr->basic_errno));
499     if (addr->message != NULL) fprintf(f, ": %s", addr->message);
500     fprintf(f, "\n");
501     }
502   }
503
504 (void)fclose(f);
505 child_close(pid, 0);  /* Waits for child to close; no timeout */
506 }
507
508
509
510 /*************************************************
511 *            Handle SMTP batch error             *
512 *************************************************/
513
514 /* This is called when something goes wrong in batched (-bS) SMTP input.
515 Information is written to stdout and/or stderr, and Exim exits with a non-zero
516 completion code. BSMTP is almost always called by some other program, so it is
517 up to that program to interpret the return code and do something with the error
518 information, and also to preserve the batch input file for human analysis.
519
520 Formerly, Exim used to attempt to continue after some errors, but this strategy
521 has been abandoned as it can lead to loss of messages.
522
523 Arguments:
524   cmd_buffer   the command causing the error, or NULL
525   format       a printf() format
526   ...          arguments for the format
527
528 Returns:       does not return; exits from the program
529                exit code = 1 if some messages were accepted
530                exit code = 2 if no messages were accepted
531 */
532
533 void
534 moan_smtp_batch(uschar *cmd_buffer, const char *format, ...)
535 {
536 va_list ap;
537 int yield = (receive_messagecount > 0)? 1 : 2;
538
539 DEBUG(D_any) debug_printf("Handling error in batched SMTP input\n");
540
541 /* On stdout, write stuff that a program could parse fairly easily. */
542
543 va_start(ap, format);
544 vfprintf(stdout, format, ap);
545 va_end(ap);
546
547 fprintf(stdout, "\nTransaction started in line %d\n",
548   bsmtp_transaction_linecount);
549 fprintf(stdout,   "Error detected in line %d\n", receive_linecount);
550 if (cmd_buffer != NULL) fprintf(stdout, "%s\n", cmd_buffer);
551
552 /* On stderr, write stuff for human consumption */
553
554 fprintf(stderr,
555   "An error was detected while processing a file of BSMTP input.\n"
556   "The error message was:\n\n  ");
557
558 va_start(ap, format);
559 vfprintf(stderr, format, ap);
560 va_end(ap);
561
562 fprintf(stderr,
563   "\n\nThe SMTP transaction started in line %d.\n"
564       "The error was detected in line %d.\n",
565   bsmtp_transaction_linecount, receive_linecount);
566
567 if (cmd_buffer != NULL)
568   {
569   fprintf(stderr, "The SMTP command at fault was:\n\n   %s\n\n",
570     cmd_buffer);
571   }
572
573 fprintf(stderr, "%d previous message%s successfully processed.\n",
574   receive_messagecount, (receive_messagecount == 1)? " was" : "s were");
575
576 fprintf(stderr, "The rest of the batch was abandoned.\n");
577
578 exim_exit(yield);
579 }
580
581
582
583
584 /*************************************************
585 *         Check for error copies                 *
586 *************************************************/
587
588 /* This function is passed the recipient of an error message, and must check
589 the error_copies string to see whether there is an additional recipient list to
590 which errors for this recipient must be bcc'd. The incoming recipient is always
591 fully qualified.
592
593 Argument:   recipient address
594 Returns:    additional recipient list or NULL
595 */
596
597 uschar *
598 moan_check_errorcopy(uschar *recipient)
599 {
600 uschar *item, *localpart, *domain;
601 uschar *listptr = errors_copy;
602 uschar *yield = NULL;
603 uschar buffer[256];
604 int sep = 0;
605 int llen;
606
607 if (errors_copy == NULL) return NULL;
608
609 /* Set up pointer to the local part and domain, and compute the
610 length of the local part. */
611
612 localpart = recipient;
613 domain = Ustrrchr(recipient, '@');
614 if (domain == NULL) return NULL;  /* should not occur, but avoid crash */
615 llen = domain++ - recipient;
616
617 /* Scan through the configured items */
618
619 while ((item = string_nextinlist(&listptr, &sep, buffer, sizeof(buffer)))
620        != NULL)
621   {
622   uschar *newaddress = item;
623   uschar *pattern = string_dequote(&newaddress);
624
625   /* If no new address found, just skip this item. */
626
627   while (isspace(*newaddress)) newaddress++;
628   if (*newaddress == 0) continue;
629
630   /* We now have an item to match as an address in item, and the additional
631   address in newaddress. If the pattern matches, expand the new address string
632   and return it. During expansion, make local part and domain available for
633   insertion. This requires a copy to be made; we can't just temporarily
634   terminate it, as the whole address is required for $0. */
635
636   if (match_address_list(recipient, TRUE, TRUE, &pattern, NULL, 0, UCHAR_MAX+1,
637         NULL) == OK)
638     {
639     deliver_localpart = string_copyn(localpart, llen);
640     deliver_domain = domain;
641     yield = expand_string_copy(newaddress);
642     deliver_domain = deliver_localpart = NULL;
643     if (yield == NULL)
644       log_write(0, LOG_MAIN|LOG_PANIC, "Failed to expand %s when processing "
645         "errors_copy: %s", newaddress, expand_string_message);
646     break;
647     }
648   }
649
650 DEBUG(D_any) debug_printf("errors_copy check returned %s\n",
651   (yield == NULL)? US"NULL" : yield);
652
653 expand_nmax = -1;
654 return yield;
655 }
656
657
658
659 /************************************************
660 *        Handle skipped syntax errors           *
661 ************************************************/
662
663 /* This function is called by the redirect router when it has skipped over one
664 or more syntax errors in the list of addresses. If there is an address to mail
665 to, send a message, and always write the information to the log. In the case of
666 a filter file, a "syntax error" might actually be something else, such as the
667 inability to open a log file. Thus, the wording of the error message is
668 general.
669
670 Arguments:
671   rname             the router name
672   eblock            chain of error blocks
673   syntax_errors_to  address to send mail to, or NULL
674   some              TRUE if some addresses were generated; FALSE if none were
675   custom            custom message text
676
677 Returns:            FALSE if string expansion failed; TRUE otherwise
678 */
679
680 BOOL
681 moan_skipped_syntax_errors(uschar *rname, error_block *eblock,
682   uschar *syntax_errors_to, BOOL some, uschar *custom)
683 {
684 int pid, fd;
685 uschar *s, *t;
686 FILE *f;
687 error_block *e;
688
689 for (e = eblock; e != NULL; e = e->next)
690   {
691   if (e->text2 != NULL)
692     log_write(0, LOG_MAIN, "%s router: skipped error: %s in \"%s\"",
693       rname, e->text1, e->text2);
694   else
695     log_write(0, LOG_MAIN, "%s router: skipped error: %s", rname,
696       e->text1);
697   }
698
699 if (syntax_errors_to == NULL) return TRUE;
700
701 s = expand_string(syntax_errors_to);
702 if (s == NULL)
703   {
704   log_write(0, LOG_MAIN, "%s router failed to expand %s: %s", rname,
705     syntax_errors_to, expand_string_message);
706   return FALSE;
707   }
708
709 /* If we can't create a process to send the message, just forget about
710 it. */
711
712 pid = child_open_exim(&fd);
713
714 if (pid < 0)
715   {
716   DEBUG(D_any) debug_printf("Failed to create child to send message: %s\n",
717     strerror(errno));
718   return TRUE;
719   }
720
721 f = fdopen(fd, "wb");
722 fprintf(f, "Auto-Submitted: auto-replied\n");
723 moan_write_from(f);
724 fprintf(f, "To: %s\n", s);
725 fprintf(f, "Subject: error(s) in forwarding or filtering\n\n");
726
727 if (custom != NULL)
728   {
729   t = expand_string(custom);
730   if (t == NULL)
731     {
732     log_write(0, LOG_MAIN, "%s router failed to expand %s: %s", rname,
733       custom, expand_string_message);
734     return FALSE;
735     }
736   fprintf(f, "%s\n\n", t);
737   }
738
739 fprintf(f, "The %s router encountered the following error(s):\n\n",
740   rname);
741
742 for (e = eblock; e != NULL; e = e->next)
743   {
744   fprintf(f, "  %s", e->text1);
745   if (e->text2 != NULL)
746     fprintf(f, " in the address\n  \"%s\"", e->text2);
747   fprintf(f, "\n\n");
748   }
749
750 if (some)
751   fprintf(f, "Other addresses were processed normally.\n");
752 else
753   fprintf(f, "No valid addresses were generated.\n");
754
755 (void)fclose(f);
756 child_close(pid, 0);  /* Waits for child to close; no timeout */
757
758 return TRUE;
759 }
760
761 /* End of moan.c */