07cbb96f114f2a88827308e6bd38ba63b1f6453a
[users/jgh/exim.git] / src / src / rda.c
1 /* $Cambridge: exim/src/src/rda.c,v 1.16 2009/11/16 19:50:37 nm4 Exp $ */
2
3 /*************************************************
4 *     Exim - an Internet mail transport agent    *
5 *************************************************/
6
7 /* Copyright (c) University of Cambridge 1995 - 2009 */
8 /* See the file NOTICE for conditions of use and distribution. */
9
10 /* This module contains code for extracting addresses from a forwarding list
11 (from an alias or forward file) or by running the filter interpreter. It may do
12 this in a sub-process if a uid/gid are supplied. */
13
14
15 #include "exim.h"
16
17 enum { FILE_EXIST, FILE_NOT_EXIST, FILE_EXIST_UNCLEAR };
18
19 #define REPLY_EXISTS    0x01
20 #define REPLY_EXPAND    0x02
21 #define REPLY_RETURN    0x04
22
23
24 /*************************************************
25 *         Check string for filter program        *
26 *************************************************/
27
28 /* This function checks whether a string is actually a filter program. The rule
29 is that it must start with "# Exim filter ..." (any capitalization, spaces
30 optional). It is envisaged that in future, other kinds of filter may be
31 implemented. That's why it is implemented the way it is. The function is global
32 because it is also called from filter.c when checking filters.
33
34 Argument:  the string
35
36 Returns:   FILTER_EXIM    if it starts with "# Exim filter"
37            FILTER_SIEVE   if it starts with "# Sieve filter"
38            FILTER_FORWARD otherwise
39 */
40
41 /* This is an auxiliary function for matching a tag. */
42
43 static BOOL
44 match_tag(const uschar *s, const uschar *tag)
45 {
46 for (; *tag != 0; s++, tag++)
47   {
48   if (*tag == ' ')
49     {
50     while (*s == ' ' || *s == '\t') s++;
51     s--;
52     }
53   else if (tolower(*s) != tolower(*tag)) break;
54   }
55 return (*tag == 0);
56 }
57
58 /* This is the real function. It should be easy to add checking different
59 tags for other types of filter. */
60
61 int
62 rda_is_filter(const uschar *s)
63 {
64 while (isspace(*s)) s++;     /* Skips initial blank lines */
65 if (match_tag(s, CUS"# exim filter")) return FILTER_EXIM;
66   else if (match_tag(s, CUS"# sieve filter")) return FILTER_SIEVE;
67     else return FILTER_FORWARD;
68 }
69
70
71
72
73 /*************************************************
74 *         Check for existence of file            *
75 *************************************************/
76
77 /* First of all, we stat the file. If this fails, we try to stat the enclosing
78 directory, because a file in an unmounted NFS directory will look the same as a
79 non-existent file. It seems that in Solaris 2.6, statting an entry in an
80 indirect map that is currently unmounted does not cause the mount to happen.
81 Instead, dummy data is returned, which defeats the whole point of this test.
82 However, if a stat() is done on some object inside the directory, such as the
83 "." back reference to itself, then the mount does occur. If an NFS host is
84 taken offline, it is possible for the stat() to get stuck until it comes back.
85 To guard against this, stick a timer round it. If we can't access the "."
86 inside the directory, try the plain directory, just in case that helps.
87
88 Argument:
89   filename   the file name
90   error      for message on error
91
92 Returns:     FILE_EXIST          the file exists
93              FILE_NOT_EXIST      the file does not exist
94              FILE_EXIST_UNCLEAR  cannot determine existence
95 */
96
97 static int
98 rda_exists(uschar *filename, uschar **error)
99 {
100 int rc, saved_errno;
101 uschar *slash;
102 struct stat statbuf;
103
104 if ((rc = Ustat(filename, &statbuf)) >= 0) return FILE_EXIST;
105 saved_errno = errno;
106
107 Ustrncpy(big_buffer, filename, big_buffer_size - 3);
108 sigalrm_seen = FALSE;
109
110 if (saved_errno == ENOENT)
111   {
112   slash = Ustrrchr(big_buffer, '/');
113   Ustrcpy(slash+1, ".");
114
115   alarm(30);
116   rc = Ustat(big_buffer, &statbuf);
117   if (rc != 0 && errno == EACCES && !sigalrm_seen)
118     {
119     *slash = 0;
120     rc = Ustat(big_buffer, &statbuf);
121     }
122   saved_errno = errno;
123   alarm(0);
124
125   DEBUG(D_route) debug_printf("stat(%s)=%d\n", big_buffer, rc);
126   }
127
128 if (sigalrm_seen || rc != 0)
129   {
130   *error = string_sprintf("failed to stat %s (%s)", big_buffer,
131     sigalrm_seen? "timeout" : strerror(saved_errno));
132   return FILE_EXIST_UNCLEAR;
133   }
134
135 *error = string_sprintf("%s does not exist", filename);
136 DEBUG(D_route) debug_printf("%s\n", *error);
137 return FILE_NOT_EXIST;
138 }
139
140
141
142 /*************************************************
143 *     Get forwarding list from a file            *
144 *************************************************/
145
146 /* Open a file and read its entire contents into a block of memory. Certain
147 opening errors are optionally treated the same as "file does not exist".
148
149 ENOTDIR means that something along the line is not a directory: there are
150 installations that set home directories to be /dev/null for non-login accounts
151 but in normal circumstances this indicates some kind of configuration error.
152
153 EACCES means there's a permissions failure. Some users turn off read permission
154 on a .forward file to suspend forwarding, but this is probably an error in any
155 kind of mailing list processing.
156
157 The redirect block that contains the file name also contains constraints such
158 as who may own the file, and mode bits that must not be set. This function is
159
160 Arguments:
161   rdata       rdirect block, containing file name and constraints
162   options     for the RDO_ENOTDIR and RDO_EACCES options
163   error       where to put an error message
164   yield       what to return from rda_interpret on error
165
166 Returns:      pointer to string in store; NULL on error
167 */
168
169 static uschar *
170 rda_get_file_contents(redirect_block *rdata, int options, uschar **error,
171   int *yield)
172 {
173 FILE *fwd;
174 uschar *filebuf;
175 uschar *filename = rdata->string;
176 BOOL uid_ok = !rdata->check_owner;
177 BOOL gid_ok = !rdata->check_group;
178 struct stat statbuf;
179
180 /* Attempt to open the file. If it appears not to exist, check up on the
181 containing directory by statting it. If the directory does not exist, we treat
182 this situation as an error (which will cause delivery to defer); otherwise we
183 pass back FF_NONEXIST, which causes the redirect router to decline.
184
185 However, if the ignore_enotdir option is set (to ignore "something on the
186 path is not a directory" errors), the right behaviour seems to be not to do the
187 directory test. */
188
189 fwd = Ufopen(filename, "rb");
190 if (fwd == NULL)
191   {
192   switch(errno)
193     {
194     case ENOENT:          /* File does not exist */
195     DEBUG(D_route) debug_printf("%s does not exist\n%schecking parent directory\n",
196       filename,
197       ((options & RDO_ENOTDIR) != 0)? "ignore_enotdir set => skip " : "");
198     *yield = (((options & RDO_ENOTDIR) != 0) ||
199               rda_exists(filename, error) == FILE_NOT_EXIST)?
200       FF_NONEXIST : FF_ERROR;
201     return NULL;
202
203     case ENOTDIR:         /* Something on the path isn't a directory */
204     if ((options & RDO_ENOTDIR) == 0) goto DEFAULT_ERROR;
205     DEBUG(D_route) debug_printf("non-directory on path %s: file assumed not to "
206       "exist\n", filename);
207     *yield = FF_NONEXIST;
208     return NULL;
209
210     case EACCES:           /* Permission denied */
211     if ((options & RDO_EACCES) == 0) goto DEFAULT_ERROR;
212     DEBUG(D_route) debug_printf("permission denied for %s: file assumed not to "
213       "exist\n", filename);
214     *yield = FF_NONEXIST;
215     return NULL;
216
217     DEFAULT_ERROR:
218     default:
219     *error = string_open_failed(errno, "%s", filename);
220     *yield = FF_ERROR;
221     return NULL;
222     }
223   }
224
225 /* Check that we have a regular file. */
226
227 if (fstat(fileno(fwd), &statbuf) != 0)
228   {
229   *error = string_sprintf("failed to stat %s: %s", filename, strerror(errno));
230   goto ERROR_RETURN;
231   }
232
233 if ((statbuf.st_mode & S_IFMT) != S_IFREG)
234   {
235   *error = string_sprintf("%s is not a regular file", filename);
236   goto ERROR_RETURN;
237   }
238
239 /* Check for unwanted mode bits */
240
241 if ((statbuf.st_mode & rdata->modemask) != 0)
242   {
243   *error = string_sprintf("bad mode (0%o) for %s: 0%o bit(s) unexpected",
244     statbuf.st_mode, filename, statbuf.st_mode & rdata->modemask);
245   goto ERROR_RETURN;
246   }
247
248 /* Check the file owner and file group if required to do so. */
249
250 if (!uid_ok)
251   {
252   if (rdata->pw != NULL && statbuf.st_uid == rdata->pw->pw_uid)
253     uid_ok = TRUE;
254   else if (rdata->owners != NULL)
255     {
256     int i;
257     for (i = 1; i <= (int)(rdata->owners[0]); i++)
258       if (rdata->owners[i] == statbuf.st_uid) { uid_ok = TRUE; break; }
259     }
260   }
261
262 if (!gid_ok)
263   {
264   if (rdata->pw != NULL && statbuf.st_gid == rdata->pw->pw_gid)
265     gid_ok = TRUE;
266   else if (rdata->owngroups != NULL)
267     {
268     int i;
269     for (i = 1; i <= (int)(rdata->owngroups[0]); i++)
270       if (rdata->owngroups[i] == statbuf.st_gid) { gid_ok = TRUE; break; }
271     }
272   }
273
274 if (!uid_ok || !gid_ok)
275   {
276   *error = string_sprintf("bad %s for %s", uid_ok? "group" : "owner", filename);
277   goto ERROR_RETURN;
278   }
279
280 /* Put an upper limit on the size of the file, just to stop silly people
281 feeding in ridiculously large files, which can easily be created by making
282 files that have holes in them. */
283
284 if (statbuf.st_size > MAX_FILTER_SIZE)
285   {
286   *error = string_sprintf("%s is too big (max %d)", filename, MAX_FILTER_SIZE);
287   goto ERROR_RETURN;
288   }
289
290 /* Read the file in one go in order to minimize the time we have it open. */
291
292 filebuf = store_get(statbuf.st_size + 1);
293
294 if (fread(filebuf, 1, statbuf.st_size, fwd) != statbuf.st_size)
295   {
296   *error = string_sprintf("error while reading %s: %s",
297     filename, strerror(errno));
298   goto ERROR_RETURN;
299   }
300 filebuf[statbuf.st_size] = 0;
301
302 DEBUG(D_route)
303   debug_printf(OFF_T_FMT " bytes read from %s\n", statbuf.st_size, filename);
304
305 (void)fclose(fwd);
306 return filebuf;
307
308 /* Return an error: the string is already set up. */
309
310 ERROR_RETURN:
311 *yield = FF_ERROR;
312 (void)fclose(fwd);
313 return NULL;
314 }
315
316
317
318 /*************************************************
319 *      Extract info from list or filter          *
320 *************************************************/
321
322 /* This function calls the appropriate function to extract addresses from a
323 forwarding list, or to run a filter file and get addresses from there.
324
325 Arguments:
326   rdata                     the redirection block
327   options                   the options bits
328   include_directory         restrain to this directory
329   sieve_vacation_directory  passed to sieve_interpret
330   sieve_enotify_mailto_owner passed to sieve_interpret
331   sieve_useraddress         passed to sieve_interpret
332   sieve_subaddress          passed to sieve_interpret
333   generated                 where to hang generated addresses
334   error                     for error messages
335   eblockp                   for details of skipped syntax errors
336                               (NULL => no skip)
337   filtertype                set to the filter type:
338                               FILTER_FORWARD => a traditional .forward file
339                               FILTER_EXIM    => an Exim filter file
340                               FILTER_SIEVE   => a Sieve filter file
341                             a system filter is always forced to be FILTER_EXIM
342
343 Returns:                    a suitable return for rda_interpret()
344 */
345
346 static int
347 rda_extract(redirect_block *rdata, int options, uschar *include_directory,
348   uschar *sieve_vacation_directory, uschar *sieve_enotify_mailto_owner,
349   uschar *sieve_useraddress, uschar *sieve_subaddress,
350   address_item **generated, uschar **error, error_block **eblockp,
351   int *filtertype)
352 {
353 uschar *data;
354
355 if (rdata->isfile)
356   {
357   int yield = 0;
358   data = rda_get_file_contents(rdata, options, error, &yield);
359   if (data == NULL) return yield;
360   }
361 else data = rdata->string;
362
363 *filtertype = system_filtering? FILTER_EXIM : rda_is_filter(data);
364
365 /* Filter interpretation is done by a general function that is also called from
366 the filter testing option (-bf). There are two versions: one for Exim filtering
367 and one for Sieve filtering. Several features of string expansion may be locked
368 out at sites that don't trust users. This is done by setting flags in
369 expand_forbid that the expander inspects. */
370
371 if (*filtertype != FILTER_FORWARD)
372   {
373   int frc;
374   int old_expand_forbid = expand_forbid;
375
376   DEBUG(D_route) debug_printf("data is %s filter program\n",
377     (*filtertype == FILTER_EXIM)? "an Exim" : "a Sieve");
378
379   /* RDO_FILTER is an "allow" bit */
380
381   if ((options & RDO_FILTER) == 0)
382     {
383     *error = US"filtering not enabled";
384     return FF_ERROR;
385     }
386
387   expand_forbid =
388     (expand_forbid & ~RDO_FILTER_EXPANSIONS) |
389     (options & RDO_FILTER_EXPANSIONS);
390
391   /* RDO_{EXIM,SIEVE}_FILTER are forbid bits */
392
393   if (*filtertype == FILTER_EXIM)
394     {
395     if ((options & RDO_EXIM_FILTER) != 0)
396       {
397       *error = US"Exim filtering not enabled";
398       return FF_ERROR;
399       }
400     frc = filter_interpret(data, options, generated, error);
401     }
402   else
403     {
404     if ((options & RDO_SIEVE_FILTER) != 0)
405       {
406       *error = US"Sieve filtering not enabled";
407       return FF_ERROR;
408       }
409     frc = sieve_interpret(data, options, sieve_vacation_directory,
410       sieve_enotify_mailto_owner, sieve_useraddress, sieve_subaddress,
411       generated, error);
412     }
413
414   expand_forbid = old_expand_forbid;
415   return frc;
416   }
417
418 /* Not a filter script */
419
420 DEBUG(D_route) debug_printf("file is not a filter file\n");
421
422 return parse_forward_list(data,
423   options,                           /* specials that are allowed */
424   generated,                         /* where to hang them */
425   error,                             /* for errors */
426   deliver_domain,                    /* to qualify \name */
427   include_directory,                 /* restrain to directory */
428   eblockp);                          /* for skipped syntax errors */
429 }
430
431
432
433
434 /*************************************************
435 *         Write string down pipe                 *
436 *************************************************/
437
438 /* This function is used for tranferring a string down a pipe between
439 processes. If the pointer is NULL, a length of zero is written.
440
441 Arguments:
442   fd         the pipe
443   s          the string
444
445 Returns:     nothing
446 */
447
448 static void
449 rda_write_string(int fd, uschar *s)
450 {
451 int len = (s == NULL)? 0 : Ustrlen(s) + 1;
452 (void)write(fd, &len, sizeof(int));
453 if (s != NULL) (void)write(fd, s, len);
454 }
455
456
457
458 /*************************************************
459 *          Read string from pipe                 *
460 *************************************************/
461
462 /* This function is used for receiving a string from a pipe.
463
464 Arguments:
465   fd         the pipe
466   sp         where to put the string
467
468 Returns:     FALSE if data missing
469 */
470
471 static BOOL
472 rda_read_string(int fd, uschar **sp)
473 {
474 int len;
475
476 if (read(fd, &len, sizeof(int)) != sizeof(int)) return FALSE;
477 if (len == 0) *sp = NULL; else
478   {
479   *sp = store_get(len);
480   if (read(fd, *sp, len) != len) return FALSE;
481   }
482 return TRUE;
483 }
484
485
486
487 /*************************************************
488 *         Interpret forward list or filter       *
489 *************************************************/
490
491 /* This function is passed a forward list string (unexpanded) or the name of a
492 file (unexpanded) whose contents are the forwarding list. The list may in fact
493 be a filter program if it starts with "#Exim filter" or "#Sieve filter". Other
494 types of filter, with different inital tag strings, may be introduced in due
495 course.
496
497 The job of the function is to process the forwarding list or filter. It is
498 pulled out into this separate function, because it is used for system filter
499 files as well as from the redirect router.
500
501 If the function is given a uid/gid, it runs a subprocess that passes the
502 results back via a pipe. This provides security for things like :include:s in
503 users' .forward files, and "logwrite" calls in users' filter files. A
504 sub-process is NOT used when:
505
506   . No uid/gid is provided
507   . The input is a string which is not a filter string, and does not contain
508     :include:
509   . The input is a file whose non-existence can be detected in the main
510     process (which is usually running as root).
511
512 Arguments:
513   rdata                     redirect data (file + constraints, or data string)
514   options                   options to pass to the extraction functions,
515                               plus ENOTDIR and EACCES handling bits
516   include_directory         restrain :include: to this directory
517   sieve_vacation_directory  directory passed to sieve_interpret
518   sieve_enotify_mailto_owner passed to sieve_interpret
519   sieve_useraddress         passed to sieve_interpret
520   sieve_subaddress          passed to sieve_interpret
521   ugid                      uid/gid to run under - if NULL, no change
522   generated                 where to hang generated addresses, initially NULL
523   error                     pointer for error message
524   eblockp                   for skipped syntax errors; NULL if no skipping
525   filtertype                set to the type of file:
526                               FILTER_FORWARD => traditional .forward file
527                               FILTER_EXIM    => an Exim filter file
528                               FILTER_SIEVE   => a Sieve filter file
529                             a system filter is always forced to be FILTER_EXIM
530   rname                     router name for error messages in the format
531                               "xxx router" or "system filter"
532
533 Returns:        values from extraction function, or FF_NONEXIST:
534                   FF_DELIVERED     success, a significant action was taken
535                   FF_NOTDELIVERED  success, no significant action
536                   FF_BLACKHOLE     :blackhole:
537                   FF_DEFER         defer requested
538                   FF_FAIL          fail requested
539                   FF_INCLUDEFAIL   some problem with :include:
540                   FF_FREEZE        freeze requested
541                   FF_ERROR         there was a problem
542                   FF_NONEXIST      the file does not exist
543 */
544
545 int
546 rda_interpret(redirect_block *rdata, int options, uschar *include_directory,
547   uschar *sieve_vacation_directory, uschar *sieve_enotify_mailto_owner,
548   uschar *sieve_useraddress, uschar *sieve_subaddress, ugid_block *ugid,
549   address_item **generated, uschar **error, error_block **eblockp,
550   int *filtertype, uschar *rname)
551 {
552 int fd, rc, pfd[2];
553 int yield, status;
554 BOOL had_disaster = FALSE;
555 pid_t pid;
556 uschar *data;
557 uschar *readerror = US"";
558 void (*oldsignal)(int);
559
560 DEBUG(D_route) debug_printf("rda_interpret (%s): %s\n",
561   (rdata->isfile)? "file" : "string", rdata->string);
562
563 /* Do the expansions of the file name or data first, while still privileged. */
564
565 data = expand_string(rdata->string);
566 if (data == NULL)
567   {
568   if (expand_string_forcedfail) return FF_NOTDELIVERED;
569   *error = string_sprintf("failed to expand \"%s\": %s", rdata->string,
570     expand_string_message);
571   return FF_ERROR;
572   }
573 rdata->string = data;
574
575 DEBUG(D_route) debug_printf("expanded: %s\n", data);
576
577 if (rdata->isfile && data[0] != '/')
578   {
579   *error = string_sprintf("\"%s\" is not an absolute path", data);
580   return FF_ERROR;
581   }
582
583 /* If no uid/gid are supplied, or if we have a data string which does not start
584 with #Exim filter or #Sieve filter, and does not contain :include:, do all the
585 work in this process. Note that for a system filter, we always have a file, so
586 the work is done in this process only if no user is supplied. */
587
588 if (!ugid->uid_set ||                         /* Either there's no uid, or */
589     (!rdata->isfile &&                        /* We've got the data, and */
590      rda_is_filter(data) == FILTER_FORWARD && /* It's not a filter script, */
591      Ustrstr(data, ":include:") == NULL))     /* and there's no :include: */
592   {
593   return rda_extract(rdata, options, include_directory,
594     sieve_vacation_directory, sieve_enotify_mailto_owner, sieve_useraddress,
595     sieve_subaddress, generated, error, eblockp, filtertype);
596   }
597
598 /* We need to run the processing code in a sub-process. However, if we can
599 determine the non-existence of a file first, we can decline without having to
600 create the sub-process. */
601
602 if (rdata->isfile && rda_exists(data, error) == FILE_NOT_EXIST)
603   return FF_NONEXIST;
604
605 /* If the file does exist, or we can't tell (non-root mounted NFS directory)
606 we have to create the subprocess to do everything as the given user. The
607 results of processing are passed back via a pipe. */
608
609 if (pipe(pfd) != 0)
610   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "creation of pipe for filter or "
611     ":include: failed for %s: %s", rname, strerror(errno));
612
613 /* Ensure that SIGCHLD is set to SIG_DFL before forking, so that the child
614 process can be waited for. We sometimes get here with it set otherwise. Save
615 the old state for resetting on the wait. Ensure that all cached resources are
616 freed so that the subprocess starts with a clean slate and doesn't interfere
617 with the parent process. */
618
619 oldsignal = signal(SIGCHLD, SIG_DFL);
620 search_tidyup();
621
622 if ((pid = fork()) == 0)
623   {
624   header_line *waslast = header_last;   /* Save last header */
625
626   fd = pfd[pipe_write];
627   (void)close(pfd[pipe_read]);
628   exim_setugid(ugid->uid, ugid->gid, FALSE, rname);
629
630   /* Addresses can get rewritten in filters; if we are not root or the exim
631   user (and we probably are not), turn off rewrite logging, because we cannot
632   write to the log now. */
633
634   if (ugid->uid != root_uid && ugid->uid != exim_uid)
635     {
636     DEBUG(D_rewrite) debug_printf("turned off address rewrite logging (not "
637       "root or exim in this process)\n");
638     log_write_selector &= ~L_address_rewrite;
639     }
640
641   /* Now do the business */
642
643   yield = rda_extract(rdata, options, include_directory,
644     sieve_vacation_directory, sieve_enotify_mailto_owner, sieve_useraddress,
645     sieve_subaddress, generated, error, eblockp, filtertype);
646
647   /* Pass back whether it was a filter, and the return code and any overall
648   error text via the pipe. */
649
650   (void)write(fd, filtertype, sizeof(int));
651   (void)write(fd, &yield, sizeof(int));
652   rda_write_string(fd, *error);
653
654   /* Pass back the contents of any syntax error blocks if we have a pointer */
655
656   if (eblockp != NULL)
657     {
658     error_block *ep;
659     for (ep = *eblockp; ep != NULL; ep = ep->next)
660       {
661       rda_write_string(fd, ep->text1);
662       rda_write_string(fd, ep->text2);
663       }
664     rda_write_string(fd, NULL);    /* Indicates end of eblocks */
665     }
666
667   /* If this is a system filter, we have to pass back the numbers of any
668   original header lines that were removed, and then any header lines that were
669   added but not subsequently removed. */
670
671   if (system_filtering)
672     {
673     int i = 0;
674     header_line *h;
675     for (h = header_list; h != waslast->next; i++, h = h->next)
676       {
677       if (h->type == htype_old) (void)write(fd, &i, sizeof(i));
678       }
679     i = -1;
680     (void)write(fd, &i, sizeof(i));
681
682     while (waslast != header_last)
683       {
684       waslast = waslast->next;
685       if (waslast->type != htype_old)
686         {
687         rda_write_string(fd, waslast->text);
688         (void)write(fd, &(waslast->type), sizeof(waslast->type));
689         }
690       }
691     rda_write_string(fd, NULL);    /* Indicates end of added headers */
692     }
693
694   /* Write the contents of the $n variables */
695
696   (void)write(fd, filter_n, sizeof(filter_n));
697
698   /* If the result was DELIVERED or NOTDELIVERED, we pass back the generated
699   addresses, and their associated information, through the pipe. This is
700   just tedious, but it seems to be the only safe way. We do this also for
701   FAIL and FREEZE, because a filter is allowed to set up deliveries that
702   are honoured before freezing or failing. */
703
704   if (yield == FF_DELIVERED || yield == FF_NOTDELIVERED ||
705       yield == FF_FAIL || yield == FF_FREEZE)
706     {
707     address_item *addr;
708     for (addr = *generated; addr != NULL; addr = addr->next)
709       {
710       int reply_options = 0;
711
712       rda_write_string(fd, addr->address);
713       (void)write(fd, &(addr->mode), sizeof(addr->mode));
714       (void)write(fd, &(addr->flags), sizeof(addr->flags));
715       rda_write_string(fd, addr->p.errors_address);
716
717       if (addr->pipe_expandn != NULL)
718         {
719         uschar **pp;
720         for (pp = addr->pipe_expandn; *pp != NULL; pp++)
721           rda_write_string(fd, *pp);
722         }
723       rda_write_string(fd, NULL);
724
725       if (addr->reply == NULL)
726         (void)write(fd, &reply_options, sizeof(int));    /* 0 means no reply */
727       else
728         {
729         reply_options |= REPLY_EXISTS;
730         if (addr->reply->file_expand) reply_options |= REPLY_EXPAND;
731         if (addr->reply->return_message) reply_options |= REPLY_RETURN;
732         (void)write(fd, &reply_options, sizeof(int));
733         (void)write(fd, &(addr->reply->expand_forbid), sizeof(int));
734         (void)write(fd, &(addr->reply->once_repeat), sizeof(time_t));
735         rda_write_string(fd, addr->reply->to);
736         rda_write_string(fd, addr->reply->cc);
737         rda_write_string(fd, addr->reply->bcc);
738         rda_write_string(fd, addr->reply->from);
739         rda_write_string(fd, addr->reply->reply_to);
740         rda_write_string(fd, addr->reply->subject);
741         rda_write_string(fd, addr->reply->headers);
742         rda_write_string(fd, addr->reply->text);
743         rda_write_string(fd, addr->reply->file);
744         rda_write_string(fd, addr->reply->logfile);
745         rda_write_string(fd, addr->reply->oncelog);
746         }
747       }
748
749     rda_write_string(fd, NULL);   /* Marks end of addresses */
750     }
751
752   /* OK, this process is now done. Free any cached resources. Must use _exit()
753   and not exit() !! */
754
755   (void)close(fd);
756   search_tidyup();
757   _exit(0);
758   }
759
760 /* Back in the main process: panic if the fork did not succeed. */
761
762 if (pid < 0)
763   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "fork failed for %s", rname);
764
765 /* Read the pipe to get the data from the filter/forward. Our copy of the
766 writing end must be closed first, as otherwise read() won't return zero on an
767 empty pipe. Afterwards, close the reading end. */
768
769 (void)close(pfd[pipe_write]);
770
771 /* Read initial data, including yield and contents of *error */
772
773 fd = pfd[pipe_read];
774 if (read(fd, filtertype, sizeof(int)) != sizeof(int) ||
775     read(fd, &yield, sizeof(int)) != sizeof(int) ||
776     !rda_read_string(fd, error)) goto DISASTER;
777
778 /* Read the contents of any syntax error blocks if we have a pointer */
779
780 if (eblockp != NULL)
781   {
782   uschar *s;
783   error_block *e;
784   error_block **p = eblockp;
785   for (;;)
786     {
787     if (!rda_read_string(fd, &s)) goto DISASTER;
788     if (s == NULL) break;
789     e = store_get(sizeof(error_block));
790     e->next = NULL;
791     e->text1 = s;
792     if (!rda_read_string(fd, &s)) goto DISASTER;
793     e->text2 = s;
794     *p = e;
795     p = &(e->next);
796     }
797   }
798
799 /* If this is a system filter, read the identify of any original header lines
800 that were removed, and then read data for any new ones that were added. */
801
802 if (system_filtering)
803   {
804   int hn = 0;
805   header_line *h = header_list;
806
807   for (;;)
808     {
809     int n;
810     if (read(fd, &n, sizeof(int)) != sizeof(int)) goto DISASTER;
811     if (n < 0) break;
812     while (hn < n)
813       {
814       hn++;
815       h = h->next;
816       if (h == NULL) goto DISASTER_NO_HEADER;
817       }
818     h->type = htype_old;
819     }
820
821   for (;;)
822     {
823     uschar *s;
824     int type;
825     if (!rda_read_string(fd, &s)) goto DISASTER;
826     if (s == NULL) break;
827     if (read(fd, &type, sizeof(type)) != sizeof(type)) goto DISASTER;
828     header_add(type, "%s", s);
829     }
830   }
831
832 /* Read the values of the $n variables */
833
834 if (read(fd, filter_n, sizeof(filter_n)) != sizeof(filter_n)) goto DISASTER;
835
836 /* If the yield is DELIVERED, NOTDELIVERED, FAIL, or FREEZE there may follow
837 addresses and data to go with them. Keep them in the same order in the
838 generated chain. */
839
840 if (yield == FF_DELIVERED || yield == FF_NOTDELIVERED ||
841     yield == FF_FAIL || yield == FF_FREEZE)
842   {
843   address_item **nextp = generated;
844
845   for (;;)
846     {
847     int i, reply_options;
848     address_item *addr;
849     uschar *recipient;
850     uschar *expandn[EXPAND_MAXN + 2];
851
852     /* First string is the address; NULL => end of addresses */
853
854     if (!rda_read_string(fd, &recipient)) goto DISASTER;
855     if (recipient == NULL) break;
856
857     /* Hang on the end of the chain */
858
859     addr = deliver_make_addr(recipient, FALSE);
860     *nextp = addr;
861     nextp = &(addr->next);
862
863     /* Next comes the mode and the flags fields */
864
865     if (read(fd, &(addr->mode), sizeof(addr->mode)) != sizeof(addr->mode) ||
866         read(fd, &(addr->flags), sizeof(addr->flags)) != sizeof(addr->flags) ||
867         !rda_read_string(fd, &(addr->p.errors_address))) goto DISASTER;
868
869     /* Next comes a possible setting for $thisaddress and any numerical
870     variables for pipe expansion, terminated by a NULL string. The maximum
871     number of numericals is EXPAND_MAXN. Note that we put filter_thisaddress
872     into the zeroth item in the vector - this is sorted out inside the pipe
873     transport. */
874
875     for (i = 0; i < EXPAND_MAXN + 1; i++)
876       {
877       uschar *temp;
878       if (!rda_read_string(fd, &temp)) goto DISASTER;
879       if (i == 0) filter_thisaddress = temp;           /* Just in case */
880       expandn[i] = temp;
881       if (temp == NULL) break;
882       }
883
884     if (i > 0)
885       {
886       addr->pipe_expandn = store_get((i+1) * sizeof(uschar **));
887       addr->pipe_expandn[i] = NULL;
888       while (--i >= 0) addr->pipe_expandn[i] = expandn[i];
889       }
890
891     /* Then an int containing reply options; zero => no reply data. */
892
893     if (read(fd, &reply_options, sizeof(int)) != sizeof(int)) goto DISASTER;
894     if ((reply_options & REPLY_EXISTS) != 0)
895       {
896       addr->reply = store_get(sizeof(reply_item));
897
898       addr->reply->file_expand = (reply_options & REPLY_EXPAND) != 0;
899       addr->reply->return_message = (reply_options & REPLY_RETURN) != 0;
900
901       if (read(fd,&(addr->reply->expand_forbid),sizeof(int)) !=
902             sizeof(int) ||
903           read(fd,&(addr->reply->once_repeat),sizeof(time_t)) !=
904             sizeof(time_t) ||
905           !rda_read_string(fd, &(addr->reply->to)) ||
906           !rda_read_string(fd, &(addr->reply->cc)) ||
907           !rda_read_string(fd, &(addr->reply->bcc)) ||
908           !rda_read_string(fd, &(addr->reply->from)) ||
909           !rda_read_string(fd, &(addr->reply->reply_to)) ||
910           !rda_read_string(fd, &(addr->reply->subject)) ||
911           !rda_read_string(fd, &(addr->reply->headers)) ||
912           !rda_read_string(fd, &(addr->reply->text)) ||
913           !rda_read_string(fd, &(addr->reply->file)) ||
914           !rda_read_string(fd, &(addr->reply->logfile)) ||
915           !rda_read_string(fd, &(addr->reply->oncelog)))
916         goto DISASTER;
917       }
918     }
919   }
920
921 /* All data has been transferred from the sub-process. Reap it, close the
922 reading end of the pipe, and we are done. */
923
924 WAIT_EXIT:
925 while ((rc = wait(&status)) != pid)
926   {
927   if (rc < 0 && errno == ECHILD)      /* Process has vanished */
928     {
929     log_write(0, LOG_MAIN, "redirection process %d vanished unexpectedly", pid);
930     goto FINAL_EXIT;
931     }
932   }
933
934 DEBUG(D_route)
935   debug_printf("rda_interpret: subprocess yield=%d error=%s\n", yield, *error);
936
937 if (had_disaster)
938   {
939   *error = string_sprintf("internal problem in %s: failure to transfer "
940     "data from subprocess: status=%04x%s%s%s", rname,
941     status, readerror,
942     (*error == NULL)? US"" : US": error=",
943     (*error == NULL)? US"" : *error);
944   log_write(0, LOG_MAIN|LOG_PANIC, "%s", *error);
945   }
946 else if (status != 0)
947   {
948   log_write(0, LOG_MAIN|LOG_PANIC, "internal problem in %s: unexpected status "
949     "%04x from redirect subprocess (but data correctly received)", rname,
950     status);
951   }
952
953 FINAL_EXIT:
954 (void)close(fd);
955 signal(SIGCHLD, oldsignal);   /* restore */
956 return yield;
957
958
959 /* Come here if the data indicates removal of a header that we can't find */
960
961 DISASTER_NO_HEADER:
962 readerror = US" readerror=bad header identifier";
963 had_disaster = TRUE;
964 yield = FF_ERROR;
965 goto WAIT_EXIT;
966
967 /* Come here is there's a shambles in transferring the data over the pipe. The
968 value of errno should still be set. */
969
970 DISASTER:
971 readerror = string_sprintf(" readerror='%s'", strerror(errno));
972 had_disaster = TRUE;
973 yield = FF_ERROR;
974 goto WAIT_EXIT;
975 }
976
977 /* End of rda.c */