1 /* redir.c -- Functions to perform input and output redirection. */
3 /* Copyright (C) 1997-2009 Free Software Foundation, Inc.
5 This file is part of GNU Bash, the Bourne Again SHell.
7 Bash is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 Bash is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with Bash. If not, see <http://www.gnu.org/licenses/>.
23 #if !defined (__GNUC__) && !defined (HAVE_ALLOCA_H) && defined (_AIX)
25 #endif /* _AIX && RISC6000 && !__GNUC__ */
28 #include "bashtypes.h"
29 #if !defined (_MINIX) && defined (HAVE_SYS_FILE_H)
30 # include <sys/file.h>
33 #include "posixstat.h"
35 #if defined (HAVE_UNISTD_H)
49 #define NEED_FPURGE_DECL
53 #include "execute_cmd.h"
56 #if defined (BUFFERED_INPUT)
60 #define SHELL_FD_BASE 10
64 extern int posixly_correct;
65 extern REDIRECT *redirection_undo_list;
66 extern REDIRECT *exec_redirection_undo_list;
68 /* Static functions defined and used in this file. */
69 static void add_undo_close_redirect __P((int));
70 static void add_exec_redirect __P((REDIRECT *));
71 static int add_undo_redirect __P((int, enum r_instruction, int));
72 static int expandable_redirection_filename __P((REDIRECT *));
73 static int stdin_redirection __P((enum r_instruction, int));
74 static int undoablefd __P((int));
75 static int do_redirection_internal __P((REDIRECT *, int));
77 static int write_here_document __P((int, WORD_DESC *));
78 static int write_here_string __P((int, WORD_DESC *));
79 static int here_document_to_fd __P((WORD_DESC *, enum r_instruction));
81 static int redir_special_open __P((int, char *, int, int, enum r_instruction));
82 static int noclobber_open __P((char *, int, int, enum r_instruction));
83 static int redir_open __P((char *, int, int, enum r_instruction));
85 /* Spare redirector used when translating [N]>&WORD[-] or [N]<&WORD[-] to
86 a new redirection and when creating the redirection undo list. */
89 /* Set to errno when a here document cannot be created for some reason.
90 Used to print a reasonable error message. */
91 static int heredoc_errno;
94 redirection_error (temp, error)
98 char *filename, *allocname;
102 if (temp->redirector < 0)
103 /* This can happen when read_token_word encounters overflow, like in
105 filename = _("file descriptor out of range");
107 /* This error can never involve NOCLOBBER */
108 else if (error != NOCLOBBER_REDIRECT && temp->redirector >= 0 && error == EBADF)
110 /* If we're dealing with two file descriptors, we have to guess about
111 which one is invalid; in the cases of r_{duplicating,move}_input and
112 r_{duplicating,move}_output we're here because dup2() failed. */
113 switch (temp->instruction)
115 case r_duplicating_input:
116 case r_duplicating_output:
119 filename = allocname = itos (temp->redirectee.dest);
122 filename = allocname = itos (temp->redirector);
127 else if (expandable_redirection_filename (temp))
129 if (posixly_correct && interactive_shell == 0)
131 oflags = temp->redirectee.filename->flags;
132 temp->redirectee.filename->flags |= W_NOGLOB;
134 filename = allocname = redirection_expand (temp->redirectee.filename);
135 if (posixly_correct && interactive_shell == 0)
136 temp->redirectee.filename->flags = oflags;
138 filename = temp->redirectee.filename->word;
140 else if (temp->redirectee.dest < 0)
141 filename = "file descriptor out of range";
143 filename = allocname = itos (temp->redirectee.dest);
147 case AMBIGUOUS_REDIRECT:
148 internal_error (_("%s: ambiguous redirect"), filename);
151 case NOCLOBBER_REDIRECT:
152 internal_error (_("%s: cannot overwrite existing file"), filename);
155 #if defined (RESTRICTED_SHELL)
156 case RESTRICTED_REDIRECT:
157 internal_error (_("%s: restricted: cannot redirect output"), filename);
159 #endif /* RESTRICTED_SHELL */
161 case HEREDOC_REDIRECT:
162 internal_error (_("cannot create temp file for here-document: %s"), strerror (heredoc_errno));
166 internal_error ("%s: %s", filename, strerror (error));
173 /* Perform the redirections on LIST. If flags & RX_ACTIVE, then actually
174 make input and output file descriptors, otherwise just do whatever is
175 neccessary for side effecting. flags & RX_UNDOABLE says to remember
176 how to undo the redirections later, if non-zero. If flags & RX_CLEXEC
177 is non-zero, file descriptors opened in do_redirection () have their
178 close-on-exec flag set. */
180 do_redirections (list, flags)
187 if (flags & RX_UNDOABLE)
189 if (redirection_undo_list)
191 dispose_redirects (redirection_undo_list);
192 redirection_undo_list = (REDIRECT *)NULL;
194 if (exec_redirection_undo_list)
195 dispose_exec_redirects ();
198 for (temp = list; temp; temp = temp->next)
200 error = do_redirection_internal (temp, flags);
203 redirection_error (temp, error);
210 /* Return non-zero if the redirection pointed to by REDIRECT has a
211 redirectee.filename that can be expanded. */
213 expandable_redirection_filename (redirect)
216 switch (redirect->instruction)
218 case r_output_direction:
220 case r_input_direction:
221 case r_inputa_direction:
223 case r_append_err_and_out:
226 case r_duplicating_input_word:
227 case r_duplicating_output_word:
228 case r_move_input_word:
229 case r_move_output_word:
237 /* Expand the word in WORD returning a string. If WORD expands to
238 multiple words (or no words), then return NULL. */
240 redirection_expand (word)
244 WORD_LIST *tlist1, *tlist2;
247 w = copy_word (word);
249 w->flags |= W_NOSPLIT;
251 tlist1 = make_word_list (w, (WORD_LIST *)NULL);
253 tlist2 = expand_words_no_vars (tlist1);
255 dispose_words (tlist1);
257 if (!tlist2 || tlist2->next)
259 /* We expanded to no words, or to more than a single word.
260 Dispose of the word list and return NULL. */
262 dispose_words (tlist2);
263 return ((char *)NULL);
265 result = string_list (tlist2); /* XXX savestring (tlist2->word->word)? */
266 dispose_words (tlist2);
271 write_here_string (fd, redirectee)
273 WORD_DESC *redirectee;
278 herestr = expand_string_to_string (redirectee->word, 0);
279 herelen = STRLEN (herestr);
281 n = write (fd, herestr, herelen);
284 n = write (fd, "\n", 1);
298 /* Write the text of the here document pointed to by REDIRECTEE to the file
299 descriptor FD, which is already open to a temp file. Return 0 if the
300 write is successful, otherwise return errno. */
302 write_here_document (fd, redirectee)
304 WORD_DESC *redirectee;
307 int document_len, fd2;
309 register WORD_LIST *t, *tlist;
311 /* Expand the text if the word that was specified had
312 no quoting. The text that we expand is treated
313 exactly as if it were surrounded by double quotes. */
315 if (redirectee->flags & W_QUOTED)
317 document = redirectee->word;
318 document_len = strlen (document);
319 /* Set errno to something reasonable if the write fails. */
320 if (write (fd, document, document_len) < document_len)
330 tlist = expand_string (redirectee->word, Q_HERE_DOCUMENT);
333 /* Try using buffered I/O (stdio) and writing a word
334 at a time, letting stdio do the work of buffering
335 for us rather than managing our own strings. Most
336 stdios are not particularly fast, however -- this
337 may need to be reconsidered later. */
338 if ((fd2 = dup (fd)) < 0 || (fp = fdopen (fd2, "w")) == NULL)
345 for (t = tlist; t; t = t->next)
347 /* This is essentially the body of
348 string_list_internal expanded inline. */
349 document = t->word->word;
350 document_len = strlen (document);
352 putc (' ', fp); /* separator */
353 fwrite (document, document_len, 1, fp);
360 dispose_words (tlist);
364 dispose_words (tlist);
365 if (fclose (fp) != 0)
375 /* Create a temporary file holding the text of the here document pointed to
376 by REDIRECTEE, and return a file descriptor open for reading to the temp
377 file. Return -1 on any error, and make sure errno is set appropriately. */
379 here_document_to_fd (redirectee, ri)
380 WORD_DESC *redirectee;
381 enum r_instruction ri;
386 fd = sh_mktmpfd ("sh-thd", MT_USERANDOM|MT_USETMPDIR, &filename);
388 /* If we failed for some reason other than the file existing, abort */
395 errno = r = 0; /* XXX */
396 /* write_here_document returns 0 on success, errno on failure. */
397 if (redirectee->word)
398 r = (ri != r_reading_string) ? write_here_document (fd, redirectee)
399 : write_here_string (fd, redirectee);
410 /* In an attempt to avoid races, we close the first fd only after opening
412 /* Make the document really temporary. Also make it the input. */
413 fd2 = open (filename, O_RDONLY, 0600);
426 if (unlink (filename) < 0)
429 #if defined (__CYGWIN__)
430 /* Under CygWin 1.1.0, the unlink will fail if the file is
431 open. This hack will allow the previous action of silently
432 ignoring the error, but will still leave the file there. This
433 needs some kind of magic. */
436 #endif /* __CYGWIN__ */
448 #define RF_DEVSTDERR 2
449 #define RF_DEVSTDIN 3
450 #define RF_DEVSTDOUT 4
454 /* A list of pattern/value pairs for filenames that the redirection
455 code handles specially. */
456 static STRING_INT_ALIST _redir_special_filenames[] = {
457 #if !defined (HAVE_DEV_FD)
458 { "/dev/fd/[0-9]*", RF_DEVFD },
460 #if !defined (HAVE_DEV_STDIN)
461 { "/dev/stderr", RF_DEVSTDERR },
462 { "/dev/stdin", RF_DEVSTDIN },
463 { "/dev/stdout", RF_DEVSTDOUT },
465 #if defined (NETWORK_REDIRECTIONS)
466 { "/dev/tcp/*/*", RF_DEVTCP },
467 { "/dev/udp/*/*", RF_DEVUDP },
473 redir_special_open (spec, filename, flags, mode, ri)
477 enum r_instruction ri;
480 #if !defined (HAVE_DEV_FD)
487 #if !defined (HAVE_DEV_FD)
489 if (all_digits (filename+8) && legal_number (filename+8, &lfd) && lfd == (int)lfd)
492 fd = fcntl (fd, F_DUPFD, SHELL_FD_BASE);
495 fd = AMBIGUOUS_REDIRECT;
499 #if !defined (HAVE_DEV_STDIN)
501 fd = fcntl (0, F_DUPFD, SHELL_FD_BASE);
504 fd = fcntl (1, F_DUPFD, SHELL_FD_BASE);
507 fd = fcntl (2, F_DUPFD, SHELL_FD_BASE);
511 #if defined (NETWORK_REDIRECTIONS)
514 #if defined (HAVE_NETWORK)
515 fd = netopen (filename);
517 internal_warning (_("/dev/(tcp|udp)/host/port not supported without networking"));
518 fd = open (filename, flags, mode);
521 #endif /* NETWORK_REDIRECTIONS */
527 /* Open FILENAME with FLAGS in noclobber mode, hopefully avoiding most
528 race conditions and avoiding the problem where the file is replaced
529 between the stat(2) and open(2). */
531 noclobber_open (filename, flags, mode, ri)
534 enum r_instruction ri;
537 struct stat finfo, finfo2;
539 /* If the file exists and is a regular file, return an error
541 r = stat (filename, &finfo);
542 if (r == 0 && (S_ISREG (finfo.st_mode)))
543 return (NOCLOBBER_REDIRECT);
545 /* If the file was not present (r != 0), make sure we open it
546 exclusively so that if it is created before we open it, our open
547 will fail. Make sure that we do not truncate an existing file.
548 Note that we don't turn on O_EXCL unless the stat failed -- if
549 the file was not a regular file, we leave O_EXCL off. */
553 fd = open (filename, flags|O_EXCL, mode);
554 return ((fd < 0 && errno == EEXIST) ? NOCLOBBER_REDIRECT : fd);
556 fd = open (filename, flags, mode);
558 /* If the open failed, return the file descriptor right away. */
560 return (errno == EEXIST ? NOCLOBBER_REDIRECT : fd);
562 /* OK, the open succeeded, but the file may have been changed from a
563 non-regular file to a regular file between the stat and the open.
564 We are assuming that the O_EXCL open handles the case where FILENAME
565 did not exist and is symlinked to an existing file between the stat
568 /* If we can open it and fstat the file descriptor, and neither check
569 revealed that it was a regular file, and the file has not been replaced,
570 return the file descriptor. */
571 if ((fstat (fd, &finfo2) == 0) && (S_ISREG (finfo2.st_mode) == 0) &&
572 r == 0 && (S_ISREG (finfo.st_mode) == 0) &&
573 same_file (filename, filename, &finfo, &finfo2))
576 /* The file has been replaced. badness. */
579 return (NOCLOBBER_REDIRECT);
583 redir_open (filename, flags, mode, ri)
586 enum r_instruction ri;
590 r = find_string_in_alist (filename, _redir_special_filenames, 1);
592 return (redir_special_open (r, filename, flags, mode, ri));
594 /* If we are in noclobber mode, you are not allowed to overwrite
595 existing files. Check before opening. */
596 if (noclobber && CLOBBERING_REDIRECT (ri))
598 fd = noclobber_open (filename, flags, mode, ri);
599 if (fd == NOCLOBBER_REDIRECT)
600 return (NOCLOBBER_REDIRECT);
604 fd = open (filename, flags, mode);
606 if ((fd < 0) && (errno == EACCES))
608 fd = open (filename, flags & ~O_CREAT, mode);
609 errno = EACCES; /* restore errno */
623 clexec = fcntl (fd, F_GETFD, 0);
624 if (clexec == -1 || (fd >= SHELL_FD_BASE && clexec == 1))
629 /* Do the specific redirection requested. Returns errno or one of the
630 special redirection errors (*_REDIRECT) in case of error, 0 on success.
631 If flags & RX_ACTIVE is zero, then just do whatever is neccessary to
632 produce the appropriate side effects. flags & RX_UNDOABLE, if non-zero,
633 says to remember how to undo each redirection. If flags & RX_CLEXEC is
634 non-zero, then we set all file descriptors > 2 that we open to be
637 do_redirection_internal (redirect, flags)
641 WORD_DESC *redirectee;
642 int redir_fd, fd, redirector, r, oflags;
644 char *redirectee_word;
645 enum r_instruction ri;
646 REDIRECT *new_redirect;
648 redirectee = redirect->redirectee.filename;
649 redir_fd = redirect->redirectee.dest;
650 redirector = redirect->redirector;
651 ri = redirect->instruction;
653 if (redirect->flags & RX_INTERNAL)
654 flags |= RX_INTERNAL;
656 if (TRANSLATE_REDIRECT (ri))
658 /* We have [N]>&WORD[-] or [N]<&WORD[-]. Expand WORD, then translate
659 the redirection into a new one and continue. */
660 redirectee_word = redirection_expand (redirectee);
662 /* XXX - what to do with [N]<&$w- where w is unset or null? ksh93
664 if (redirectee_word == 0)
665 return (AMBIGUOUS_REDIRECT);
666 else if (redirectee_word[0] == '-' && redirectee_word[1] == '\0')
669 new_redirect = make_redirection (redirector, r_close_this, rd);
671 else if (all_digits (redirectee_word))
673 if (legal_number (redirectee_word, &lfd) && (int)lfd == lfd)
676 rd.dest = -1; /* XXX */
679 case r_duplicating_input_word:
680 new_redirect = make_redirection (redirector, r_duplicating_input, rd);
682 case r_duplicating_output_word:
683 new_redirect = make_redirection (redirector, r_duplicating_output, rd);
685 case r_move_input_word:
686 new_redirect = make_redirection (redirector, r_move_input, rd);
688 case r_move_output_word:
689 new_redirect = make_redirection (redirector, r_move_output, rd);
693 else if (ri == r_duplicating_output_word && redirector == 1)
695 rd.filename = make_bare_word (redirectee_word);
696 new_redirect = make_redirection (1, r_err_and_out, rd);
700 free (redirectee_word);
701 return (AMBIGUOUS_REDIRECT);
704 free (redirectee_word);
706 /* Set up the variables needed by the rest of the function from the
708 if (new_redirect->instruction == r_err_and_out)
712 /* Copy the word without allocating any memory that must be
714 redirectee = (WORD_DESC *)alloca (sizeof (WORD_DESC));
715 xbcopy ((char *)new_redirect->redirectee.filename,
716 (char *)redirectee, sizeof (WORD_DESC));
718 alloca_hack = (char *)
719 alloca (1 + strlen (new_redirect->redirectee.filename->word));
720 redirectee->word = alloca_hack;
721 strcpy (redirectee->word, new_redirect->redirectee.filename->word);
724 /* It's guaranteed to be an integer, and shouldn't be freed. */
725 redirectee = new_redirect->redirectee.filename;
727 redir_fd = new_redirect->redirectee.dest;
728 redirector = new_redirect->redirector;
729 ri = new_redirect->instruction;
731 /* Overwrite the flags element of the old redirect with the new value. */
732 redirect->flags = new_redirect->flags;
733 dispose_redirects (new_redirect);
738 case r_output_direction:
740 case r_input_direction:
741 case r_inputa_direction:
742 case r_err_and_out: /* command &>filename */
743 case r_append_err_and_out: /* command &>> filename */
746 if (posixly_correct && interactive_shell == 0)
748 oflags = redirectee->flags;
749 redirectee->flags |= W_NOGLOB;
751 redirectee_word = redirection_expand (redirectee);
752 if (posixly_correct && interactive_shell == 0)
753 redirectee->flags = oflags;
755 if (redirectee_word == 0)
756 return (AMBIGUOUS_REDIRECT);
758 #if defined (RESTRICTED_SHELL)
759 if (restricted && (WRITE_REDIRECT (ri)))
761 free (redirectee_word);
762 return (RESTRICTED_REDIRECT);
764 #endif /* RESTRICTED_SHELL */
766 fd = redir_open (redirectee_word, redirect->flags, 0666, ri);
767 free (redirectee_word);
769 if (fd == NOCLOBBER_REDIRECT)
775 if (flags & RX_ACTIVE)
777 if (flags & RX_UNDOABLE)
779 /* Only setup to undo it if the thing to undo is active. */
780 if ((fd != redirector) && (fcntl (redirector, F_GETFD, 0) != -1))
781 add_undo_redirect (redirector, ri, -1);
783 add_undo_close_redirect (redirector);
786 #if defined (BUFFERED_INPUT)
787 check_bash_input (redirector);
790 /* Make sure there is no pending output before we change the state
791 of the underlying file descriptor, since the builtins use stdio
793 if (redirector == 1 && fileno (stdout) == redirector)
798 else if (redirector == 2 && fileno (stderr) == redirector)
804 if ((fd != redirector) && (dup2 (fd, redirector) < 0))
807 #if defined (BUFFERED_INPUT)
808 /* Do not change the buffered stream for an implicit redirection
809 of /dev/null to fd 0 for asynchronous commands without job
810 control (r_inputa_direction). */
811 if (ri == r_input_direction || ri == r_input_output)
812 duplicate_buffered_stream (fd, redirector);
813 #endif /* BUFFERED_INPUT */
816 * If we're remembering, then this is the result of a while, for
817 * or until loop with a loop redirection, or a function/builtin
818 * executing in the parent shell with a redirection. In the
819 * function/builtin case, we want to set all file descriptors > 2
820 * to be close-on-exec to duplicate the effect of the old
821 * for i = 3 to NOFILE close(i) loop. In the case of the loops,
822 * both sh and ksh leave the file descriptors open across execs.
823 * The Posix standard mentions only the exec builtin.
825 if ((flags & RX_CLEXEC) && (redirector > 2))
826 SET_CLOSE_ON_EXEC (redirector);
829 if (fd != redirector)
831 #if defined (BUFFERED_INPUT)
832 if (INPUT_REDIRECT (ri))
833 close_buffered_fd (fd);
835 #endif /* !BUFFERED_INPUT */
836 close (fd); /* Don't close what we just opened! */
839 /* If we are hacking both stdout and stderr, do the stderr
841 if (ri == r_err_and_out || ri == r_append_err_and_out)
843 if (flags & RX_ACTIVE)
845 if (flags & RX_UNDOABLE)
846 add_undo_redirect (2, ri, -1);
853 case r_reading_until:
854 case r_deblank_reading_until:
855 case r_reading_string:
856 /* REDIRECTEE is a pointer to a WORD_DESC containing the text of
857 the new input. Place it in a temporary file. */
860 fd = here_document_to_fd (redirectee, ri);
864 heredoc_errno = errno;
865 return (HEREDOC_REDIRECT);
868 if (flags & RX_ACTIVE)
870 if (flags & RX_UNDOABLE)
872 /* Only setup to undo it if the thing to undo is active. */
873 if ((fd != redirector) && (fcntl (redirector, F_GETFD, 0) != -1))
874 add_undo_redirect (redirector, ri, -1);
876 add_undo_close_redirect (redirector);
879 #if defined (BUFFERED_INPUT)
880 check_bash_input (redirector);
882 if (fd != redirector && dup2 (fd, redirector) < 0)
889 #if defined (BUFFERED_INPUT)
890 duplicate_buffered_stream (fd, redirector);
893 if ((flags & RX_CLEXEC) && (redirector > 2))
894 SET_CLOSE_ON_EXEC (redirector);
897 if (fd != redirector)
898 #if defined (BUFFERED_INPUT)
899 close_buffered_fd (fd);
906 case r_duplicating_input:
907 case r_duplicating_output:
910 if ((flags & RX_ACTIVE) && (redir_fd != redirector))
912 if (flags & RX_UNDOABLE)
914 /* Only setup to undo it if the thing to undo is active. */
915 if (fcntl (redirector, F_GETFD, 0) != -1)
916 add_undo_redirect (redirector, ri, redir_fd);
918 add_undo_close_redirect (redirector);
920 #if defined (BUFFERED_INPUT)
921 check_bash_input (redirector);
923 /* This is correct. 2>&1 means dup2 (1, 2); */
924 if (dup2 (redir_fd, redirector) < 0)
927 #if defined (BUFFERED_INPUT)
928 if (ri == r_duplicating_input || ri == r_move_input)
929 duplicate_buffered_stream (redir_fd, redirector);
930 #endif /* BUFFERED_INPUT */
932 /* First duplicate the close-on-exec state of redirectee. dup2
933 leaves the flag unset on the new descriptor, which means it
934 stays open. Only set the close-on-exec bit for file descriptors
935 greater than 2 in any case, since 0-2 should always be open
936 unless closed by something like `exec 2<&-'. It should always
937 be safe to set fds > 2 to close-on-exec if they're being used to
938 save file descriptors < 2, since we don't need to preserve the
939 state of the close-on-exec flag for those fds -- they should
941 /* if ((already_set || set_unconditionally) && (ok_to_set))
944 if (((fcntl (redir_fd, F_GETFD, 0) == 1) || redir_fd < 2 || (flags & RX_CLEXEC)) &&
947 if (((fcntl (redir_fd, F_GETFD, 0) == 1) || (redir_fd < 2 && (flags & RX_INTERNAL)) || (flags & RX_CLEXEC)) &&
950 SET_CLOSE_ON_EXEC (redirector);
952 /* When undoing saving of non-standard file descriptors (>=3) using
953 file descriptors >= SHELL_FD_BASE, we set the saving fd to be
954 close-on-exec and use a flag to decide how to set close-on-exec
955 when the fd is restored. */
956 if ((redirect->flags & RX_INTERNAL) && (redirect->flags & RX_SAVCLEXEC) && redirector >= 3 && redir_fd >= SHELL_FD_BASE)
957 SET_OPEN_ON_EXEC (redirector);
959 /* dup-and-close redirection */
960 if (ri == r_move_input || ri == r_move_output)
963 #if defined (COPROCESS_SUPPORT)
964 coproc_fdchk (redir_fd); /* XXX - loses coproc fds */
971 if (flags & RX_ACTIVE)
973 if ((flags & RX_UNDOABLE) && (fcntl (redirector, F_GETFD, 0) != -1))
974 add_undo_redirect (redirector, ri, -1);
976 #if defined (COPROCESS_SUPPORT)
977 coproc_fdchk (redirector);
980 #if defined (BUFFERED_INPUT)
981 check_bash_input (redirector);
982 close_buffered_fd (redirector);
983 #else /* !BUFFERED_INPUT */
985 #endif /* !BUFFERED_INPUT */
989 case r_duplicating_input_word:
990 case r_duplicating_output_word:
996 /* Remember the file descriptor associated with the slot FD,
997 on REDIRECTION_UNDO_LIST. Note that the list will be reversed
998 before it is executed. Any redirections that need to be undone
999 even if REDIRECTION_UNDO_LIST is discarded by the exec builtin
1000 are also saved on EXEC_REDIRECTION_UNDO_LIST. FDBASE says where to
1001 start the duplicating. If it's less than SHELL_FD_BASE, we're ok,
1002 and can use SHELL_FD_BASE (-1 == don't care). If it's >= SHELL_FD_BASE,
1003 we have to make sure we don't use fdbase to save a file descriptor,
1004 since we're going to use it later (e.g., make sure we don't save fd 0
1005 to fd 10 if we have a redirection like 0<&10). If the value of fdbase
1006 puts the process over its fd limit, causing fcntl to fail, we try
1007 again with SHELL_FD_BASE. */
1009 add_undo_redirect (fd, ri, fdbase)
1011 enum r_instruction ri;
1014 int new_fd, clexec_flag;
1015 REDIRECT *new_redirect, *closer, *dummy_redirect;
1017 new_fd = fcntl (fd, F_DUPFD, (fdbase < SHELL_FD_BASE) ? SHELL_FD_BASE : fdbase+1);
1019 new_fd = fcntl (fd, F_DUPFD, SHELL_FD_BASE);
1023 sys_error (_("redirection error: cannot duplicate fd"));
1027 clexec_flag = fcntl (fd, F_GETFD, 0);
1030 closer = make_redirection (new_fd, r_close_this, rd);
1031 closer->flags |= RX_INTERNAL;
1032 dummy_redirect = copy_redirects (closer);
1036 new_redirect = make_redirection (fd, r_duplicating_input, rd);
1038 new_redirect = make_redirection (fd, r_duplicating_output, rd);
1039 new_redirect->flags |= RX_INTERNAL;
1040 if (clexec_flag == 0 && fd >= 3 && new_fd >= SHELL_FD_BASE)
1041 new_redirect->flags |= RX_SAVCLEXEC;
1042 new_redirect->next = closer;
1044 closer->next = redirection_undo_list;
1045 redirection_undo_list = new_redirect;
1047 /* Save redirections that need to be undone even if the undo list
1048 is thrown away by the `exec' builtin. */
1049 add_exec_redirect (dummy_redirect);
1051 /* experimental: if we're saving a redirection to undo for a file descriptor
1052 above SHELL_FD_BASE, add a redirection to be undone if the exec builtin
1053 causes redirections to be discarded. There needs to be a difference
1054 between fds that are used to save other fds and then are the target of
1055 user redirctions and fds that are just the target of user redirections.
1056 We use the close-on-exec flag to tell the difference; fds > SHELL_FD_BASE
1057 that have the close-on-exec flag set are assumed to be fds used internally
1059 if (fd >= SHELL_FD_BASE && ri != r_close_this && clexec_flag)
1062 new_redirect = make_redirection (fd, r_duplicating_output, rd);
1063 new_redirect->flags |= RX_INTERNAL;
1065 add_exec_redirect (new_redirect);
1068 /* File descriptors used only for saving others should always be
1069 marked close-on-exec. Unfortunately, we have to preserve the
1070 close-on-exec state of the file descriptor we are saving, since
1071 fcntl (F_DUPFD) sets the new file descriptor to remain open
1072 across execs. If, however, the file descriptor whose state we
1073 are saving is <= 2, we can just set the close-on-exec flag,
1074 because file descriptors 0-2 should always be open-on-exec,
1075 and the restore above in do_redirection() will take care of it. */
1076 if (clexec_flag || fd < 3)
1077 SET_CLOSE_ON_EXEC (new_fd);
1078 else if (redirection_undo_list->flags & RX_SAVCLEXEC)
1079 SET_CLOSE_ON_EXEC (new_fd);
1084 /* Set up to close FD when we are finished with the current command
1085 and its redirections. */
1087 add_undo_close_redirect (fd)
1093 closer = make_redirection (fd, r_close_this, rd);
1094 closer->flags |= RX_INTERNAL;
1095 closer->next = redirection_undo_list;
1096 redirection_undo_list = closer;
1100 add_exec_redirect (dummy_redirect)
1101 REDIRECT *dummy_redirect;
1103 dummy_redirect->next = exec_redirection_undo_list;
1104 exec_redirection_undo_list = dummy_redirect;
1107 /* Return 1 if the redirection specified by RI and REDIRECTOR alters the
1110 stdin_redirection (ri, redirector)
1111 enum r_instruction ri;
1116 case r_input_direction:
1117 case r_inputa_direction:
1118 case r_input_output:
1119 case r_reading_until:
1120 case r_deblank_reading_until:
1121 case r_reading_string:
1123 case r_duplicating_input:
1124 case r_duplicating_input_word:
1126 return (redirector == 0);
1127 case r_output_direction:
1128 case r_appending_to:
1129 case r_duplicating_output:
1131 case r_append_err_and_out:
1132 case r_output_force:
1133 case r_duplicating_output_word:
1139 /* Return non-zero if any of the redirections in REDIRS alter the standard
1142 stdin_redirects (redirs)
1148 for (n = 0, rp = redirs; rp; rp = rp->next)
1149 n += stdin_redirection (rp->instruction, rp->redirector);