8f972ca4ec4bc64e9002658f6fc61d81d6da8d2a
1 /* $Cambridge: exim/src/src/rda.c,v 1.6 2005/06/07 15:20:56 ph10 Exp $ */
3 /*************************************************
4 * Exim - an Internet mail transport agent *
5 *************************************************/
7 /* Copyright (c) University of Cambridge 1995 - 2005 */
8 /* See the file NOTICE for conditions of use and distribution. */
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. */
17 enum { FILE_EXIST
, FILE_NOT_EXIST
, FILE_EXIST_UNCLEAR
};
19 #define REPLY_EXISTS 0x01
20 #define REPLY_EXPAND 0x02
21 #define REPLY_RETURN 0x04
24 /*************************************************
25 * Check string for filter program *
26 *************************************************/
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.
36 Returns: FILTER_EXIM if it starts with "# Exim filter"
37 FILTER_SIEVE if it starts with "# Sieve filter"
38 FILTER_FORWARD otherwise
41 /* This is an auxiliary function for matching a tag. */
44 match_tag(const uschar
*s
, const uschar
*tag
)
46 for (; *tag
!= 0; s
++, tag
++)
50 while (*s
== ' ' || *s
== '\t') s
++;
53 else if (tolower(*s
) != tolower(*tag
)) break;
58 /* This is the real function. It should be easy to add checking different
59 tags for other types of filter. */
62 rda_is_filter(const uschar
*s
)
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
;
73 /*************************************************
74 * Check for existence of file *
75 *************************************************/
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.
89 filename the file name
90 error for message on error
92 Returns: FILE_EXIST the file exists
93 FILE_NOT_EXIST the file does not exist
94 FILE_EXIST_UNCLEAR cannot determine existence
98 rda_exists(uschar
*filename
, uschar
**error
)
104 if ((rc
= Ustat(filename
, &statbuf
)) >= 0) return FILE_EXIST
;
107 Ustrncpy(big_buffer
, filename
, big_buffer_size
- 3);
108 sigalrm_seen
= FALSE
;
110 if (saved_errno
== ENOENT
)
112 slash
= Ustrrchr(big_buffer
, '/');
113 Ustrcpy(slash
+1, ".");
116 rc
= Ustat(big_buffer
, &statbuf
);
117 if (rc
!= 0 && errno
== EACCES
&& !sigalrm_seen
)
120 rc
= Ustat(big_buffer
, &statbuf
);
125 DEBUG(D_route
) debug_printf("stat(%s)=%d\n", big_buffer
, rc
);
128 if (sigalrm_seen
|| rc
!= 0)
130 *error
= string_sprintf("failed to stat %s (%s)", big_buffer
,
131 sigalrm_seen
? "timeout" : strerror(saved_errno
));
132 return FILE_EXIST_UNCLEAR
;
135 *error
= string_sprintf("%s does not exist", filename
);
136 DEBUG(D_route
) debug_printf("%s\n", *error
);
137 return FILE_NOT_EXIST
;
142 /*************************************************
143 * Get forwarding list from a file *
144 *************************************************/
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".
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.
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.
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
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
166 Returns: pointer to string in store; NULL on error
170 rda_get_file_contents(redirect_block
*rdata
, int options
, uschar
**error
,
175 uschar
*filename
= rdata
->string
;
176 BOOL uid_ok
= !rdata
->check_owner
;
177 BOOL gid_ok
= !rdata
->check_group
;
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.
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
189 fwd
= Ufopen(filename
, "rb");
194 case ENOENT
: /* File does not exist */
195 DEBUG(D_route
) debug_printf("%s does not exist\n%schecking parent directory\n",
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
;
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
;
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
;
219 *error
= string_open_failed(errno
, "%s", filename
);
225 /* Check that we have a regular file. */
227 if (fstat(fileno(fwd
), &statbuf
) != 0)
229 *error
= string_sprintf("failed to stat %s: %s", filename
, strerror(errno
));
233 if ((statbuf
.st_mode
& S_IFMT
) != S_IFREG
)
235 *error
= string_sprintf("%s is not a regular file", filename
);
239 /* Check for unwanted mode bits */
241 if ((statbuf
.st_mode
& rdata
->modemask
) != 0)
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
);
248 /* Check the file owner and file group if required to do so. */
252 if (rdata
->pw
!= NULL
&& statbuf
.st_uid
== rdata
->pw
->pw_uid
)
254 else if (rdata
->owners
!= NULL
)
257 for (i
= 1; i
<= (int)(rdata
->owners
[0]); i
++)
258 if (rdata
->owners
[i
] == statbuf
.st_uid
) { uid_ok
= TRUE
; break; }
264 if (rdata
->pw
!= NULL
&& statbuf
.st_gid
== rdata
->pw
->pw_gid
)
266 else if (rdata
->owngroups
!= NULL
)
269 for (i
= 1; i
<= (int)(rdata
->owngroups
[0]); i
++)
270 if (rdata
->owngroups
[i
] == statbuf
.st_gid
) { gid_ok
= TRUE
; break; }
274 if (!uid_ok
|| !gid_ok
)
276 *error
= string_sprintf("bad %s for %s", uid_ok
? "group" : "owner", filename
);
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. */
284 if (statbuf
.st_size
> MAX_FILTER_SIZE
)
286 *error
= string_sprintf("%s is too big (max %d)", filename
, MAX_FILTER_SIZE
);
290 /* Read the file in one go in order to minimize the time we have it open. */
292 filebuf
= store_get(statbuf
.st_size
+ 1);
294 if (fread(filebuf
, 1, statbuf
.st_size
, fwd
) != statbuf
.st_size
)
296 *error
= string_sprintf("error while reading %s: %s",
297 filename
, strerror(errno
));
300 filebuf
[statbuf
.st_size
] = 0;
303 debug_printf("%.30g bytes read from %s\n", (double)statbuf
.st_size
, filename
);
308 /* Return an error: the string is already set up. */
318 /*************************************************
319 * Extract info from list or filter *
320 *************************************************/
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.
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_useraddress passed to sieve_interpret
331 sieve_subaddress passed to sieve_interpret
332 generated where to hang generated addresses
333 error for error messages
334 eblockp for details of skipped syntax errors
336 filtertype set to the filter type:
337 FILTER_FORWARD => a traditional .forward file
338 FILTER_EXIM => an Exim filter file
339 FILTER_SIEVE => a Sieve filter file
340 a system filter is always forced to be FILTER_EXIM
342 Returns: a suitable return for rda_interpret()
346 rda_extract(redirect_block
*rdata
, int options
, uschar
*include_directory
,
347 uschar
*sieve_vacation_directory
, uschar
*sieve_useraddress
,
348 uschar
*sieve_subaddress
, address_item
**generated
, uschar
**error
,
349 error_block
**eblockp
, int *filtertype
)
356 data
= rda_get_file_contents(rdata
, options
, error
, &yield
);
357 if (data
== NULL
) return yield
;
359 else data
= rdata
->string
;
361 *filtertype
= system_filtering
? FILTER_EXIM
: rda_is_filter(data
);
363 /* Filter interpretation is done by a general function that is also called from
364 the filter testing option (-bf). There are two versions: one for Exim filtering
365 and one for Sieve filtering. Several features of string expansion may be locked
366 out at sites that don't trust users. This is done by setting flags in
367 expand_forbid that the expander inspects. */
369 if (*filtertype
!= FILTER_FORWARD
)
372 int old_expand_forbid
= expand_forbid
;
374 DEBUG(D_route
) debug_printf("data is %s filter program\n",
375 (*filtertype
== FILTER_EXIM
)? "an Exim" : "a Sieve");
377 /* RDO_FILTER is an "allow" bit */
379 if ((options
& RDO_FILTER
) == 0)
381 *error
= US
"filtering not enabled";
386 (expand_forbid
& ~RDO_FILTER_EXPANSIONS
) |
387 (options
& RDO_FILTER_EXPANSIONS
);
389 /* RDO_{EXIM,SIEVE}_FILTER are forbid bits */
391 if (*filtertype
== FILTER_EXIM
)
393 if ((options
& RDO_EXIM_FILTER
) != 0)
395 *error
= US
"Exim filtering not enabled";
398 frc
= filter_interpret(data
, options
, generated
, error
);
402 if ((options
& RDO_SIEVE_FILTER
) != 0)
404 *error
= US
"Sieve filtering not enabled";
407 frc
= sieve_interpret(data
, options
, sieve_vacation_directory
,
408 sieve_useraddress
, sieve_subaddress
, generated
, error
);
411 expand_forbid
= old_expand_forbid
;
415 /* Not a filter script */
417 DEBUG(D_route
) debug_printf("file is not a filter file\n");
419 return parse_forward_list(data
,
420 options
, /* specials that are allowed */
421 generated
, /* where to hang them */
422 error
, /* for errors */
423 deliver_domain
, /* to qualify \name */
424 include_directory
, /* restrain to directory */
425 eblockp
); /* for skipped syntax errors */
431 /*************************************************
432 * Write string down pipe *
433 *************************************************/
435 /* This function is used for tranferring a string down a pipe between
436 processes. If the pointer is NULL, a length of zero is written.
446 rda_write_string(int fd
, uschar
*s
)
448 int len
= (s
== NULL
)? 0 : Ustrlen(s
) + 1;
449 write(fd
, &len
, sizeof(int));
450 if (s
!= NULL
) write(fd
, s
, len
);
455 /*************************************************
456 * Read string from pipe *
457 *************************************************/
459 /* This function is used for receiving a string from a pipe.
463 sp where to put the string
465 Returns: FALSE if data missing
469 rda_read_string(int fd
, uschar
**sp
)
473 if (read(fd
, &len
, sizeof(int)) != sizeof(int)) return FALSE
;
474 if (len
== 0) *sp
= NULL
; else
476 *sp
= store_get(len
);
477 if (read(fd
, *sp
, len
) != len
) return FALSE
;
484 /*************************************************
485 * Interpret forward list or filter *
486 *************************************************/
488 /* This function is passed a forward list string (unexpanded) or the name of a
489 file (unexpanded) whose contents are the forwarding list. The list may in fact
490 be a filter program if it starts with "#Exim filter" or "#Sieve filter". Other
491 types of filter, with different inital tag strings, may be introduced in due
494 The job of the function is to process the forwarding list or filter. It is
495 pulled out into this separate function, because it is used for system filter
496 files as well as from the redirect router.
498 If the function is given a uid/gid, it runs a subprocess that passes the
499 results back via a pipe. This provides security for things like :include:s in
500 users' .forward files, and "logwrite" calls in users' filter files. A
501 sub-process is NOT used when:
503 . No uid/gid is provided
504 . The input is a string which is not a filter string, and does not contain
506 . The input is a file whose non-existence can be detected in the main
507 process (which is usually running as root).
510 rdata redirect data (file + constraints, or data string)
511 options options to pass to the extraction functions,
512 plus ENOTDIR and EACCES handling bits
513 include_directory restrain :include: to this directory
514 sieve_vacation_directory directory passed to sieve_interpret()
515 sieve_useraddress passed to sieve_interpret
516 sieve_subaddress passed to sieve_interpret
517 ugid uid/gid to run under - if NULL, no change
518 generated where to hang generated addresses, initially NULL
519 error pointer for error message
520 eblockp for skipped syntax errors; NULL if no skipping
521 filtertype set to the type of file:
522 FILTER_FORWARD => traditional .forward file
523 FILTER_EXIM => an Exim filter file
524 FILTER_SIEVE => a Sieve filter file
525 a system filter is always forced to be FILTER_EXIM
526 rname router name for error messages in the format
527 "xxx router" or "system filter"
529 Returns: values from extraction function, or FF_NONEXIST:
530 FF_DELIVERED success, a significant action was taken
531 FF_NOTDELIVERED success, no significant action
532 FF_BLACKHOLE :blackhole:
533 FF_DEFER defer requested
534 FF_FAIL fail requested
535 FF_INCLUDEFAIL some problem with :include:
536 FF_FREEZE freeze requested
537 FF_ERROR there was a problem
538 FF_NONEXIST the file does not exist
542 rda_interpret(redirect_block
*rdata
, int options
, uschar
*include_directory
,
543 uschar
*sieve_vacation_directory
, uschar
*sieve_useraddress
,
544 uschar
*sieve_subaddress
, ugid_block
*ugid
, address_item
**generated
,
545 uschar
**error
, error_block
**eblockp
, int *filtertype
, uschar
*rname
)
549 BOOL had_disaster
= FALSE
;
552 uschar
*readerror
= US
"";
553 void (*oldsignal
)(int);
555 DEBUG(D_route
) debug_printf("rda_interpret (%s): %s\n",
556 (rdata
->isfile
)? "file" : "string", rdata
->string
);
558 /* Do the expansions of the file name or data first, while still privileged. */
560 data
= expand_string(rdata
->string
);
563 if (expand_string_forcedfail
) return FF_NOTDELIVERED
;
564 *error
= string_sprintf("failed to expand \"%s\": %s", rdata
->string
,
565 expand_string_message
);
568 rdata
->string
= data
;
570 DEBUG(D_route
) debug_printf("expanded: %s\n", data
);
572 if (rdata
->isfile
&& data
[0] != '/')
574 *error
= string_sprintf("\"%s\" is not an absolute path", data
);
578 /* If no uid/gid are supplied, or if we have a data string which does not start
579 with #Exim filter or #Sieve filter, and does not contain :include:, do all the
580 work in this process. Note that for a system filter, we always have a file, so
581 the work is done in this process only if no user is supplied. */
583 if (!ugid
->uid_set
|| /* Either there's no uid, or */
584 (!rdata
->isfile
&& /* We've got the data, and */
585 rda_is_filter(data
) == FILTER_FORWARD
&& /* It's not a filter script, */
586 Ustrstr(data
, ":include:") == NULL
)) /* and there's no :include: */
588 return rda_extract(rdata
, options
, include_directory
,
589 sieve_vacation_directory
, sieve_useraddress
, sieve_subaddress
,
590 generated
, error
, eblockp
, filtertype
);
593 /* We need to run the processing code in a sub-process. However, if we can
594 determine the non-existence of a file first, we can decline without having to
595 create the sub-process. */
597 if (rdata
->isfile
&& rda_exists(data
, error
) == FILE_NOT_EXIST
)
600 /* If the file does exist, or we can't tell (non-root mounted NFS directory)
601 we have to create the subprocess to do everything as the given user. The
602 results of processing are passed back via a pipe. */
605 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "creation of pipe for filter or "
606 ":include: failed for %s: %s", rname
, strerror(errno
));
608 /* Ensure that SIGCHLD is set to SIG_DFL before forking, so that the child
609 process can be waited for. We sometimes get here with it set otherwise. Save
610 the old state for resetting on the wait. */
612 oldsignal
= signal(SIGCHLD
, SIG_DFL
);
613 if ((pid
= fork()) == 0)
615 header_line
*waslast
= header_last
; /* Save last header */
617 fd
= pfd
[pipe_write
];
618 close(pfd
[pipe_read
]);
619 exim_setugid(ugid
->uid
, ugid
->gid
, FALSE
, rname
);
621 /* Addresses can get rewritten in filters; if we are not root or the exim
622 user (and we probably are not), turn off rewrite logging, because we cannot
623 write to the log now. */
625 if (ugid
->uid
!= root_uid
&& ugid
->uid
!= exim_uid
)
627 DEBUG(D_rewrite
) debug_printf("turned off address rewrite logging (not "
628 "root or exim in this process)\n");
629 log_write_selector
&= ~L_address_rewrite
;
632 /* Now do the business */
634 yield
= rda_extract(rdata
, options
, include_directory
,
635 sieve_vacation_directory
, sieve_useraddress
, sieve_subaddress
, generated
,
636 error
, eblockp
, filtertype
);
638 /* Pass back whether it was a filter, and the return code and any overall
639 error text via the pipe. */
641 write(fd
, filtertype
, sizeof(int));
642 write(fd
, &yield
, sizeof(int));
643 rda_write_string(fd
, *error
);
645 /* Pass back the contents of any syntax error blocks if we have a pointer */
650 for (ep
= *eblockp
; ep
!= NULL
; ep
= ep
->next
)
652 rda_write_string(fd
, ep
->text1
);
653 rda_write_string(fd
, ep
->text2
);
655 rda_write_string(fd
, NULL
); /* Indicates end of eblocks */
658 /* If this is a system filter, we have to pass back the numbers of any
659 original header lines that were removed, and then any header lines that were
660 added but not subsequently removed. */
662 if (system_filtering
)
666 for (h
= header_list
; h
!= waslast
->next
; i
++, h
= h
->next
)
668 if (h
->type
== htype_old
) write(fd
, &i
, sizeof(i
));
671 write(fd
, &i
, sizeof(i
));
673 while (waslast
!= header_last
)
675 waslast
= waslast
->next
;
676 if (waslast
->type
!= htype_old
)
678 rda_write_string(fd
, waslast
->text
);
679 write(fd
, &(waslast
->type
), sizeof(waslast
->type
));
682 rda_write_string(fd
, NULL
); /* Indicates end of added headers */
685 /* Write the contents of the $n variables */
687 write(fd
, filter_n
, sizeof(filter_n
));
689 /* If the result was DELIVERED or NOTDELIVERED, we pass back the generated
690 addresses, and their associated information, through the pipe. This is
691 just tedious, but it seems to be the only safe way. We do this also for
692 FAIL and FREEZE, because a filter is allowed to set up deliveries that
693 are honoured before freezing or failing. */
695 if (yield
== FF_DELIVERED
|| yield
== FF_NOTDELIVERED
||
696 yield
== FF_FAIL
|| yield
== FF_FREEZE
)
699 for (addr
= *generated
; addr
!= NULL
; addr
= addr
->next
)
701 int reply_options
= 0;
703 rda_write_string(fd
, addr
->address
);
704 write(fd
, &(addr
->mode
), sizeof(addr
->mode
));
705 write(fd
, &(addr
->flags
), sizeof(addr
->flags
));
706 rda_write_string(fd
, addr
->p
.errors_address
);
708 if (addr
->pipe_expandn
!= NULL
)
711 for (pp
= addr
->pipe_expandn
; *pp
!= NULL
; pp
++)
712 rda_write_string(fd
, *pp
);
714 rda_write_string(fd
, NULL
);
716 if (addr
->reply
== NULL
)
717 write(fd
, &reply_options
, sizeof(int)); /* 0 means no reply */
720 reply_options
|= REPLY_EXISTS
;
721 if (addr
->reply
->file_expand
) reply_options
|= REPLY_EXPAND
;
722 if (addr
->reply
->return_message
) reply_options
|= REPLY_RETURN
;
723 write(fd
, &reply_options
, sizeof(int));
724 write(fd
, &(addr
->reply
->expand_forbid
), sizeof(int));
725 write(fd
, &(addr
->reply
->once_repeat
), sizeof(time_t));
726 rda_write_string(fd
, addr
->reply
->to
);
727 rda_write_string(fd
, addr
->reply
->cc
);
728 rda_write_string(fd
, addr
->reply
->bcc
);
729 rda_write_string(fd
, addr
->reply
->from
);
730 rda_write_string(fd
, addr
->reply
->reply_to
);
731 rda_write_string(fd
, addr
->reply
->subject
);
732 rda_write_string(fd
, addr
->reply
->headers
);
733 rda_write_string(fd
, addr
->reply
->text
);
734 rda_write_string(fd
, addr
->reply
->file
);
735 rda_write_string(fd
, addr
->reply
->logfile
);
736 rda_write_string(fd
, addr
->reply
->oncelog
);
740 rda_write_string(fd
, NULL
); /* Marks end of addresses */
743 /* OK, this process is now done. Must use _exit() and not exit() !! */
749 /* Back in the main process: panic if the fork did not succeed. */
752 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "fork failed for %s", rname
);
754 /* Read the pipe to get the data from the filter/forward. Our copy of the
755 writing end must be closed first, as otherwise read() won't return zero on an
756 empty pipe. Afterwards, close the reading end. */
758 close(pfd
[pipe_write
]);
760 /* Read initial data, including yield and contents of *error */
763 if (read(fd
, filtertype
, sizeof(int)) != sizeof(int) ||
764 read(fd
, &yield
, sizeof(int)) != sizeof(int) ||
765 !rda_read_string(fd
, error
)) goto DISASTER
;
768 debug_printf("rda_interpret: subprocess yield=%d error=%s\n", yield
, *error
);
770 /* Read the contents of any syntax error blocks if we have a pointer */
776 error_block
**p
= eblockp
;
779 if (!rda_read_string(fd
, &s
)) goto DISASTER
;
780 if (s
== NULL
) break;
781 e
= store_get(sizeof(error_block
));
784 if (!rda_read_string(fd
, &s
)) goto DISASTER
;
791 /* If this is a system filter, read the identify of any original header lines
792 that were removed, and then read data for any new ones that were added. */
794 if (system_filtering
)
797 header_line
*h
= header_list
;
802 if (read(fd
, &n
, sizeof(int)) != sizeof(int)) goto DISASTER
;
808 if (h
== NULL
) goto DISASTER_NO_HEADER
;
817 if (!rda_read_string(fd
, &s
)) goto DISASTER
;
818 if (s
== NULL
) break;
819 if (read(fd
, &type
, sizeof(type
)) != sizeof(type
)) goto DISASTER
;
820 header_add(type
, "%s", s
);
824 /* Read the values of the $n variables */
826 if (read(fd
, filter_n
, sizeof(filter_n
)) != sizeof(filter_n
)) goto DISASTER
;
828 /* If the yield is DELIVERED, NOTDELIVERED, FAIL, or FREEZE there may follow
829 addresses and data to go with them. Keep them in the same order in the
832 if (yield
== FF_DELIVERED
|| yield
== FF_NOTDELIVERED
||
833 yield
== FF_FAIL
|| yield
== FF_FREEZE
)
835 address_item
**nextp
= generated
;
839 int i
, reply_options
;
842 uschar
*expandn
[EXPAND_MAXN
+ 2];
844 /* First string is the address; NULL => end of addresses */
846 if (!rda_read_string(fd
, &recipient
)) goto DISASTER
;
847 if (recipient
== NULL
) break;
849 /* Hang on the end of the chain */
851 addr
= deliver_make_addr(recipient
, FALSE
);
853 nextp
= &(addr
->next
);
855 /* Next comes the mode and the flags fields */
857 if (read(fd
, &(addr
->mode
), sizeof(addr
->mode
)) != sizeof(addr
->mode
) ||
858 read(fd
, &(addr
->flags
), sizeof(addr
->flags
)) != sizeof(addr
->flags
) ||
859 !rda_read_string(fd
, &(addr
->p
.errors_address
))) goto DISASTER
;
861 /* Next comes a possible setting for $thisaddress and any numerical
862 variables for pipe expansion, terminated by a NULL string. The maximum
863 number of numericals is EXPAND_MAXN. Note that we put filter_thisaddress
864 into the zeroth item in the vector - this is sorted out inside the pipe
867 for (i
= 0; i
< EXPAND_MAXN
+ 1; i
++)
870 if (!rda_read_string(fd
, &temp
)) goto DISASTER
;
871 if (i
== 0) filter_thisaddress
= temp
; /* Just in case */
873 if (temp
== NULL
) break;
878 addr
->pipe_expandn
= store_get((i
+1) * sizeof(uschar
**));
879 addr
->pipe_expandn
[i
] = NULL
;
880 while (--i
>= 0) addr
->pipe_expandn
[i
] = expandn
[i
];
883 /* Then an int containing reply options; zero => no reply data. */
885 if (read(fd
, &reply_options
, sizeof(int)) != sizeof(int)) goto DISASTER
;
886 if ((reply_options
& REPLY_EXISTS
) != 0)
888 addr
->reply
= store_get(sizeof(reply_item
));
890 addr
->reply
->file_expand
= (reply_options
& REPLY_EXPAND
) != 0;
891 addr
->reply
->return_message
= (reply_options
& REPLY_RETURN
) != 0;
893 if (read(fd
,&(addr
->reply
->expand_forbid
),sizeof(int)) !=
895 read(fd
,&(addr
->reply
->once_repeat
),sizeof(time_t)) !=
897 !rda_read_string(fd
, &(addr
->reply
->to
)) ||
898 !rda_read_string(fd
, &(addr
->reply
->cc
)) ||
899 !rda_read_string(fd
, &(addr
->reply
->bcc
)) ||
900 !rda_read_string(fd
, &(addr
->reply
->from
)) ||
901 !rda_read_string(fd
, &(addr
->reply
->reply_to
)) ||
902 !rda_read_string(fd
, &(addr
->reply
->subject
)) ||
903 !rda_read_string(fd
, &(addr
->reply
->headers
)) ||
904 !rda_read_string(fd
, &(addr
->reply
->text
)) ||
905 !rda_read_string(fd
, &(addr
->reply
->file
)) ||
906 !rda_read_string(fd
, &(addr
->reply
->logfile
)) ||
907 !rda_read_string(fd
, &(addr
->reply
->oncelog
)))
913 /* All data has been transferred from the sub-process. Reap it, close the
914 reading end of the pipe, and we are done. */
917 while ((rc
= wait(&status
)) != pid
)
919 if (rc
< 0 && errno
== ECHILD
) /* Process has vanished */
921 log_write(0, LOG_MAIN
, "redirection process %d vanished unexpectedly", pid
);
928 *error
= string_sprintf("internal problem in %s: failure to transfer "
929 "data from subprocess: status=%04x%s%s%s", rname
,
931 (*error
== NULL
)? US
"" : US
": error=",
932 (*error
== NULL
)? US
"" : *error
);
933 log_write(0, LOG_MAIN
|LOG_PANIC
, "%s", *error
);
935 else if (status
!= 0)
937 log_write(0, LOG_MAIN
|LOG_PANIC
, "internal problem in %s: unexpected status "
938 "%04x from redirect subprocess (but data correctly received)", rname
,
944 signal(SIGCHLD
, oldsignal
); /* restore */
948 /* Come here if the data indicates removal of a header that we can't find */
951 readerror
= US
" readerror=bad header identifier";
956 /* Come here is there's a shambles in transferring the data over the pipe. The
957 value of errno should still be set. */
960 readerror
= string_sprintf(" readerror='%s'", strerror(errno
));