1 /* redir.c -- Functions to perform input and output redirection. */
3 /* Copyright (C) 1997-2012 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 int last_command_exit_value;
66 extern int executing_builtin;
67 extern REDIRECT *redirection_undo_list;
68 extern REDIRECT *exec_redirection_undo_list;
70 /* Static functions defined and used in this file. */
71 static void add_exec_redirect __P((REDIRECT *));
72 static int add_undo_redirect __P((int, enum r_instruction, int));
73 static int add_undo_close_redirect __P((int));
74 static int expandable_redirection_filename __P((REDIRECT *));
75 static int stdin_redirection __P((enum r_instruction, int));
76 static int undoablefd __P((int));
77 static int do_redirection_internal __P((REDIRECT *, int));
79 static int write_here_document __P((int, WORD_DESC *));
80 static int write_here_string __P((int, WORD_DESC *));
81 static int here_document_to_fd __P((WORD_DESC *, enum r_instruction));
83 static int redir_special_open __P((int, char *, int, int, enum r_instruction));
84 static int noclobber_open __P((char *, int, int, enum r_instruction));
85 static int redir_open __P((char *, int, int, enum r_instruction));
87 static int redir_varassign __P((REDIRECT *, int));
88 static int redir_varvalue __P((REDIRECT *));
90 /* Spare redirector used when translating [N]>&WORD[-] or [N]<&WORD[-] to
91 a new redirection and when creating the redirection undo list. */
94 /* Set to errno when a here document cannot be created for some reason.
95 Used to print a reasonable error message. */
96 static int heredoc_errno;
98 #define REDIRECTION_ERROR(r, e, fd) \
104 last_command_exit_value = EXECUTION_FAILURE;\
105 return ((e) == 0 ? EINVAL : (e));\
110 redirection_error (temp, error)
114 char *filename, *allocname;
118 if (temp->rflags & REDIR_VARASSIGN)
119 filename = allocname = savestring (temp->redirector.filename->word);
120 else if (temp->redirector.dest < 0)
121 /* This can happen when read_token_word encounters overflow, like in
123 filename = _("file descriptor out of range");
125 /* This error can never involve NOCLOBBER */
126 else if (error != NOCLOBBER_REDIRECT && temp->redirector.dest >= 0 && error == EBADF)
128 /* If we're dealing with two file descriptors, we have to guess about
129 which one is invalid; in the cases of r_{duplicating,move}_input and
130 r_{duplicating,move}_output we're here because dup2() failed. */
131 switch (temp->instruction)
133 case r_duplicating_input:
134 case r_duplicating_output:
137 filename = allocname = itos (temp->redirectee.dest);
139 case r_duplicating_input_word:
140 if (temp->redirector.dest == 0) /* Guess */
141 filename = temp->redirectee.filename->word; /* XXX */
143 filename = allocname = itos (temp->redirector.dest);
145 case r_duplicating_output_word:
146 if (temp->redirector.dest == 1) /* Guess */
147 filename = temp->redirectee.filename->word; /* XXX */
149 filename = allocname = itos (temp->redirector.dest);
152 filename = allocname = itos (temp->redirector.dest);
157 else if (expandable_redirection_filename (temp))
160 oflags = temp->redirectee.filename->flags;
161 if (posixly_correct && interactive_shell == 0)
162 temp->redirectee.filename->flags |= W_NOGLOB;
163 temp->redirectee.filename->flags |= W_NOCOMSUB;
164 filename = allocname = redirection_expand (temp->redirectee.filename);
165 temp->redirectee.filename->flags = oflags;
167 filename = temp->redirectee.filename->word;
169 else if (temp->redirectee.dest < 0)
170 filename = _("file descriptor out of range");
172 filename = allocname = itos (temp->redirectee.dest);
176 case AMBIGUOUS_REDIRECT:
177 internal_error (_("%s: ambiguous redirect"), filename);
180 case NOCLOBBER_REDIRECT:
181 internal_error (_("%s: cannot overwrite existing file"), filename);
184 #if defined (RESTRICTED_SHELL)
185 case RESTRICTED_REDIRECT:
186 internal_error (_("%s: restricted: cannot redirect output"), filename);
188 #endif /* RESTRICTED_SHELL */
190 case HEREDOC_REDIRECT:
191 internal_error (_("cannot create temp file for here-document: %s"), strerror (heredoc_errno));
194 case BADVAR_REDIRECT:
195 internal_error (_("%s: cannot assign fd to variable"), filename);
199 internal_error ("%s: %s", filename, strerror (error));
206 /* Perform the redirections on LIST. If flags & RX_ACTIVE, then actually
207 make input and output file descriptors, otherwise just do whatever is
208 necessary for side effecting. flags & RX_UNDOABLE says to remember
209 how to undo the redirections later, if non-zero. If flags & RX_CLEXEC
210 is non-zero, file descriptors opened in do_redirection () have their
211 close-on-exec flag set. */
213 do_redirections (list, flags)
220 if (flags & RX_UNDOABLE)
222 if (redirection_undo_list)
224 dispose_redirects (redirection_undo_list);
225 redirection_undo_list = (REDIRECT *)NULL;
227 if (exec_redirection_undo_list)
228 dispose_exec_redirects ();
231 for (temp = list; temp; temp = temp->next)
233 error = do_redirection_internal (temp, flags);
236 redirection_error (temp, error);
243 /* Return non-zero if the redirection pointed to by REDIRECT has a
244 redirectee.filename that can be expanded. */
246 expandable_redirection_filename (redirect)
249 switch (redirect->instruction)
251 case r_output_direction:
253 case r_input_direction:
254 case r_inputa_direction:
256 case r_append_err_and_out:
259 case r_duplicating_input_word:
260 case r_duplicating_output_word:
261 case r_move_input_word:
262 case r_move_output_word:
270 /* Expand the word in WORD returning a string. If WORD expands to
271 multiple words (or no words), then return NULL. */
273 redirection_expand (word)
277 WORD_LIST *tlist1, *tlist2;
281 w = copy_word (word);
283 w->flags |= W_NOSPLIT;
285 tlist1 = make_word_list (w, (WORD_LIST *)NULL);
287 /* Now that we've changed the variable search order to ignore the temp
288 environment, see if we need to change the cached IFS values. */
290 tlist2 = expand_words_no_vars (tlist1);
292 /* Now we need to change the variable search order back to include the temp
293 environment. We force the temp environment search by forcing
294 executing_builtin to 1. This is what makes `read' get the right values
295 for the IFS-related cached variables, for example. */
296 old = executing_builtin;
297 executing_builtin = 1;
299 executing_builtin = old;
300 dispose_words (tlist1);
302 if (tlist2 == 0 || tlist2->next)
304 /* We expanded to no words, or to more than a single word.
305 Dispose of the word list and return NULL. */
307 dispose_words (tlist2);
308 return ((char *)NULL);
310 result = string_list (tlist2); /* XXX savestring (tlist2->word->word)? */
311 dispose_words (tlist2);
316 write_here_string (fd, redirectee)
318 WORD_DESC *redirectee;
321 int herelen, n, e, old;
324 /* Now that we've changed the variable search order to ignore the temp
325 environment, see if we need to change the cached IFS values. */
327 herestr = expand_string_to_string (redirectee->word, 0);
329 /* Now we need to change the variable search order back to include the temp
330 environment. We force the temp environment search by forcing
331 executing_builtin to 1. This is what makes `read' get the right values
332 for the IFS-related cached variables, for example. */
333 old = executing_builtin;
334 executing_builtin = 1;
336 executing_builtin = old;
338 herelen = STRLEN (herestr);
340 n = write (fd, herestr, herelen);
343 n = write (fd, "\n", 1);
357 /* Write the text of the here document pointed to by REDIRECTEE to the file
358 descriptor FD, which is already open to a temp file. Return 0 if the
359 write is successful, otherwise return errno. */
361 write_here_document (fd, redirectee)
363 WORD_DESC *redirectee;
366 int document_len, fd2, old;
368 register WORD_LIST *t, *tlist;
370 /* Expand the text if the word that was specified had
371 no quoting. The text that we expand is treated
372 exactly as if it were surrounded by double quotes. */
374 if (redirectee->flags & W_QUOTED)
376 document = redirectee->word;
377 document_len = strlen (document);
378 /* Set errno to something reasonable if the write fails. */
379 if (write (fd, document, document_len) < document_len)
390 /* Now that we've changed the variable search order to ignore the temp
391 environment, see if we need to change the cached IFS values. */
393 tlist = expand_string (redirectee->word, Q_HERE_DOCUMENT);
395 /* Now we need to change the variable search order back to include the temp
396 environment. We force the temp environment search by forcing
397 executing_builtin to 1. This is what makes `read' get the right values
398 for the IFS-related cached variables, for example. */
399 old = executing_builtin;
400 executing_builtin = 1;
402 executing_builtin = old;
406 /* Try using buffered I/O (stdio) and writing a word
407 at a time, letting stdio do the work of buffering
408 for us rather than managing our own strings. Most
409 stdios are not particularly fast, however -- this
410 may need to be reconsidered later. */
411 if ((fd2 = dup (fd)) < 0 || (fp = fdopen (fd2, "w")) == NULL)
418 for (t = tlist; t; t = t->next)
420 /* This is essentially the body of
421 string_list_internal expanded inline. */
422 document = t->word->word;
423 document_len = strlen (document);
425 putc (' ', fp); /* separator */
426 fwrite (document, document_len, 1, fp);
433 dispose_words (tlist);
437 dispose_words (tlist);
438 if (fclose (fp) != 0)
448 /* Create a temporary file holding the text of the here document pointed to
449 by REDIRECTEE, and return a file descriptor open for reading to the temp
450 file. Return -1 on any error, and make sure errno is set appropriately. */
452 here_document_to_fd (redirectee, ri)
453 WORD_DESC *redirectee;
454 enum r_instruction ri;
459 fd = sh_mktmpfd ("sh-thd", MT_USERANDOM|MT_USETMPDIR, &filename);
461 /* If we failed for some reason other than the file existing, abort */
468 errno = r = 0; /* XXX */
469 /* write_here_document returns 0 on success, errno on failure. */
470 if (redirectee->word)
471 r = (ri != r_reading_string) ? write_here_document (fd, redirectee)
472 : write_here_string (fd, redirectee);
483 /* In an attempt to avoid races, we close the first fd only after opening
485 /* Make the document really temporary. Also make it the input. */
486 fd2 = open (filename, O_RDONLY|O_BINARY, 0600);
499 if (unlink (filename) < 0)
513 #define RF_DEVSTDERR 2
514 #define RF_DEVSTDIN 3
515 #define RF_DEVSTDOUT 4
519 /* A list of pattern/value pairs for filenames that the redirection
520 code handles specially. */
521 static STRING_INT_ALIST _redir_special_filenames[] = {
522 #if !defined (HAVE_DEV_FD)
523 { "/dev/fd/[0-9]*", RF_DEVFD },
525 #if !defined (HAVE_DEV_STDIN)
526 { "/dev/stderr", RF_DEVSTDERR },
527 { "/dev/stdin", RF_DEVSTDIN },
528 { "/dev/stdout", RF_DEVSTDOUT },
530 #if defined (NETWORK_REDIRECTIONS)
531 { "/dev/tcp/*/*", RF_DEVTCP },
532 { "/dev/udp/*/*", RF_DEVUDP },
538 redir_special_open (spec, filename, flags, mode, ri)
542 enum r_instruction ri;
545 #if !defined (HAVE_DEV_FD)
552 #if !defined (HAVE_DEV_FD)
554 if (all_digits (filename+8) && legal_number (filename+8, &lfd) && lfd == (int)lfd)
557 fd = fcntl (fd, F_DUPFD, SHELL_FD_BASE);
560 fd = AMBIGUOUS_REDIRECT;
564 #if !defined (HAVE_DEV_STDIN)
566 fd = fcntl (0, F_DUPFD, SHELL_FD_BASE);
569 fd = fcntl (1, F_DUPFD, SHELL_FD_BASE);
572 fd = fcntl (2, F_DUPFD, SHELL_FD_BASE);
576 #if defined (NETWORK_REDIRECTIONS)
579 #if defined (HAVE_NETWORK)
580 fd = netopen (filename);
582 internal_warning (_("/dev/(tcp|udp)/host/port not supported without networking"));
583 fd = open (filename, flags, mode);
586 #endif /* NETWORK_REDIRECTIONS */
592 /* Open FILENAME with FLAGS in noclobber mode, hopefully avoiding most
593 race conditions and avoiding the problem where the file is replaced
594 between the stat(2) and open(2). */
596 noclobber_open (filename, flags, mode, ri)
599 enum r_instruction ri;
602 struct stat finfo, finfo2;
604 /* If the file exists and is a regular file, return an error
606 r = stat (filename, &finfo);
607 if (r == 0 && (S_ISREG (finfo.st_mode)))
608 return (NOCLOBBER_REDIRECT);
610 /* If the file was not present (r != 0), make sure we open it
611 exclusively so that if it is created before we open it, our open
612 will fail. Make sure that we do not truncate an existing file.
613 Note that we don't turn on O_EXCL unless the stat failed -- if
614 the file was not a regular file, we leave O_EXCL off. */
618 fd = open (filename, flags|O_EXCL, mode);
619 return ((fd < 0 && errno == EEXIST) ? NOCLOBBER_REDIRECT : fd);
621 fd = open (filename, flags, mode);
623 /* If the open failed, return the file descriptor right away. */
625 return (errno == EEXIST ? NOCLOBBER_REDIRECT : fd);
627 /* OK, the open succeeded, but the file may have been changed from a
628 non-regular file to a regular file between the stat and the open.
629 We are assuming that the O_EXCL open handles the case where FILENAME
630 did not exist and is symlinked to an existing file between the stat
633 /* If we can open it and fstat the file descriptor, and neither check
634 revealed that it was a regular file, and the file has not been replaced,
635 return the file descriptor. */
636 if ((fstat (fd, &finfo2) == 0) && (S_ISREG (finfo2.st_mode) == 0) &&
637 r == 0 && (S_ISREG (finfo.st_mode) == 0) &&
638 same_file (filename, filename, &finfo, &finfo2))
641 /* The file has been replaced. badness. */
644 return (NOCLOBBER_REDIRECT);
648 redir_open (filename, flags, mode, ri)
651 enum r_instruction ri;
655 r = find_string_in_alist (filename, _redir_special_filenames, 1);
657 return (redir_special_open (r, filename, flags, mode, ri));
659 /* If we are in noclobber mode, you are not allowed to overwrite
660 existing files. Check before opening. */
661 if (noclobber && CLOBBERING_REDIRECT (ri))
663 fd = noclobber_open (filename, flags, mode, ri);
664 if (fd == NOCLOBBER_REDIRECT)
665 return (NOCLOBBER_REDIRECT);
671 fd = open (filename, flags, mode);
673 if (fd < 0 && e == EINTR)
677 while (fd < 0 && errno == EINTR);
680 if ((fd < 0) && (errno == EACCES))
682 fd = open (filename, flags & ~O_CREAT, mode);
683 errno = EACCES; /* restore errno */
697 clexec = fcntl (fd, F_GETFD, 0);
698 if (clexec == -1 || (fd >= SHELL_FD_BASE && clexec == 1))
703 /* Do the specific redirection requested. Returns errno or one of the
704 special redirection errors (*_REDIRECT) in case of error, 0 on success.
705 If flags & RX_ACTIVE is zero, then just do whatever is necessary to
706 produce the appropriate side effects. flags & RX_UNDOABLE, if non-zero,
707 says to remember how to undo each redirection. If flags & RX_CLEXEC is
708 non-zero, then we set all file descriptors > 2 that we open to be
711 do_redirection_internal (redirect, flags)
715 WORD_DESC *redirectee;
716 int redir_fd, fd, redirector, r, oflags;
718 char *redirectee_word;
719 enum r_instruction ri;
720 REDIRECT *new_redirect;
723 redirectee = redirect->redirectee.filename;
724 redir_fd = redirect->redirectee.dest;
725 redirector = redirect->redirector.dest;
726 ri = redirect->instruction;
728 if (redirect->flags & RX_INTERNAL)
729 flags |= RX_INTERNAL;
731 if (TRANSLATE_REDIRECT (ri))
733 /* We have [N]>&WORD[-] or [N]<&WORD[-] (or {V}>&WORD[-] or {V}<&WORD-).
734 and WORD, then translate the redirection into a new one and
736 redirectee_word = redirection_expand (redirectee);
738 /* XXX - what to do with [N]<&$w- where w is unset or null? ksh93
740 if (redirectee_word == 0)
741 return (AMBIGUOUS_REDIRECT);
742 else if (redirectee_word[0] == '-' && redirectee_word[1] == '\0')
744 sd = redirect->redirector;
746 new_redirect = make_redirection (sd, r_close_this, rd, 0);
748 else if (all_digits (redirectee_word))
750 sd = redirect->redirector;
751 if (legal_number (redirectee_word, &lfd) && (int)lfd == lfd)
754 rd.dest = -1; /* XXX */
757 case r_duplicating_input_word:
758 new_redirect = make_redirection (sd, r_duplicating_input, rd, 0);
760 case r_duplicating_output_word:
761 new_redirect = make_redirection (sd, r_duplicating_output, rd, 0);
763 case r_move_input_word:
764 new_redirect = make_redirection (sd, r_move_input, rd, 0);
766 case r_move_output_word:
767 new_redirect = make_redirection (sd, r_move_output, rd, 0);
771 else if (ri == r_duplicating_output_word && (redirect->rflags & REDIR_VARASSIGN) == 0 && redirector == 1)
773 sd = redirect->redirector;
774 rd.filename = make_bare_word (redirectee_word);
775 new_redirect = make_redirection (sd, r_err_and_out, rd, 0);
779 free (redirectee_word);
780 return (AMBIGUOUS_REDIRECT);
783 free (redirectee_word);
785 /* Set up the variables needed by the rest of the function from the
787 if (new_redirect->instruction == r_err_and_out)
791 /* Copy the word without allocating any memory that must be
793 redirectee = (WORD_DESC *)alloca (sizeof (WORD_DESC));
794 xbcopy ((char *)new_redirect->redirectee.filename,
795 (char *)redirectee, sizeof (WORD_DESC));
797 alloca_hack = (char *)
798 alloca (1 + strlen (new_redirect->redirectee.filename->word));
799 redirectee->word = alloca_hack;
800 strcpy (redirectee->word, new_redirect->redirectee.filename->word);
803 /* It's guaranteed to be an integer, and shouldn't be freed. */
804 redirectee = new_redirect->redirectee.filename;
806 redir_fd = new_redirect->redirectee.dest;
807 redirector = new_redirect->redirector.dest;
808 ri = new_redirect->instruction;
810 /* Overwrite the flags element of the old redirect with the new value. */
811 redirect->flags = new_redirect->flags;
812 dispose_redirects (new_redirect);
817 case r_output_direction:
819 case r_input_direction:
820 case r_inputa_direction:
821 case r_err_and_out: /* command &>filename */
822 case r_append_err_and_out: /* command &>> filename */
825 if (posixly_correct && interactive_shell == 0)
827 oflags = redirectee->flags;
828 redirectee->flags |= W_NOGLOB;
830 redirectee_word = redirection_expand (redirectee);
831 if (posixly_correct && interactive_shell == 0)
832 redirectee->flags = oflags;
834 if (redirectee_word == 0)
835 return (AMBIGUOUS_REDIRECT);
837 #if defined (RESTRICTED_SHELL)
838 if (restricted && (WRITE_REDIRECT (ri)))
840 free (redirectee_word);
841 return (RESTRICTED_REDIRECT);
843 #endif /* RESTRICTED_SHELL */
845 fd = redir_open (redirectee_word, redirect->flags, 0666, ri);
846 free (redirectee_word);
848 if (fd == NOCLOBBER_REDIRECT)
854 if (flags & RX_ACTIVE)
856 if (redirect->rflags & REDIR_VARASSIGN)
858 redirector = fcntl (fd, F_DUPFD, SHELL_FD_BASE); /* XXX try this for now */
861 sys_error (_("redirection error: cannot duplicate fd"));
862 REDIRECTION_ERROR (redirector, r, fd);
865 if ((flags & RX_UNDOABLE) && (redirect->rflags & REDIR_VARASSIGN) == 0)
867 /* Only setup to undo it if the thing to undo is active. */
868 if ((fd != redirector) && (fcntl (redirector, F_GETFD, 0) != -1))
869 r = add_undo_redirect (redirector, ri, -1);
871 r = add_undo_close_redirect (redirector);
872 REDIRECTION_ERROR (r, errno, fd);
875 #if defined (BUFFERED_INPUT)
876 /* inhibit call to sync_buffered_stream() for async processes */
877 if (redirector != 0 || (subshell_environment & SUBSHELL_ASYNC) == 0)
878 check_bash_input (redirector);
881 /* Make sure there is no pending output before we change the state
882 of the underlying file descriptor, since the builtins use stdio
884 if (redirector == 1 && fileno (stdout) == redirector)
889 else if (redirector == 2 && fileno (stderr) == redirector)
895 if (redirect->rflags & REDIR_VARASSIGN)
897 if ((r = redir_varassign (redirect, redirector)) < 0)
901 return (r); /* XXX */
904 else if ((fd != redirector) && (dup2 (fd, redirector) < 0))
907 #if defined (BUFFERED_INPUT)
908 /* Do not change the buffered stream for an implicit redirection
909 of /dev/null to fd 0 for asynchronous commands without job
910 control (r_inputa_direction). */
911 if (ri == r_input_direction || ri == r_input_output)
912 duplicate_buffered_stream (fd, redirector);
913 #endif /* BUFFERED_INPUT */
916 * If we're remembering, then this is the result of a while, for
917 * or until loop with a loop redirection, or a function/builtin
918 * executing in the parent shell with a redirection. In the
919 * function/builtin case, we want to set all file descriptors > 2
920 * to be close-on-exec to duplicate the effect of the old
921 * for i = 3 to NOFILE close(i) loop. In the case of the loops,
922 * both sh and ksh leave the file descriptors open across execs.
923 * The Posix standard mentions only the exec builtin.
925 if ((flags & RX_CLEXEC) && (redirector > 2))
926 SET_CLOSE_ON_EXEC (redirector);
929 if (fd != redirector)
931 #if defined (BUFFERED_INPUT)
932 if (INPUT_REDIRECT (ri))
933 close_buffered_fd (fd);
935 #endif /* !BUFFERED_INPUT */
936 close (fd); /* Don't close what we just opened! */
939 /* If we are hacking both stdout and stderr, do the stderr
940 redirection here. XXX - handle {var} here? */
941 if (ri == r_err_and_out || ri == r_append_err_and_out)
943 if (flags & RX_ACTIVE)
945 if (flags & RX_UNDOABLE)
946 add_undo_redirect (2, ri, -1);
953 case r_reading_until:
954 case r_deblank_reading_until:
955 case r_reading_string:
956 /* REDIRECTEE is a pointer to a WORD_DESC containing the text of
957 the new input. Place it in a temporary file. */
960 fd = here_document_to_fd (redirectee, ri);
964 heredoc_errno = errno;
965 return (HEREDOC_REDIRECT);
968 if (redirect->rflags & REDIR_VARASSIGN)
970 redirector = fcntl (fd, F_DUPFD, SHELL_FD_BASE); /* XXX try this for now */
973 sys_error (_("redirection error: cannot duplicate fd"));
974 REDIRECTION_ERROR (redirector, r, fd);
977 if (flags & RX_ACTIVE)
979 if ((flags & RX_UNDOABLE) && (redirect->rflags & REDIR_VARASSIGN) == 0)
981 /* Only setup to undo it if the thing to undo is active. */
982 if ((fd != redirector) && (fcntl (redirector, F_GETFD, 0) != -1))
983 r = add_undo_redirect (redirector, ri, -1);
985 r = add_undo_close_redirect (redirector);
986 REDIRECTION_ERROR (r, errno, fd);
989 #if defined (BUFFERED_INPUT)
990 check_bash_input (redirector);
992 if (redirect->rflags & REDIR_VARASSIGN)
994 if ((r = redir_varassign (redirect, redirector)) < 0)
998 return (r); /* XXX */
1001 else if (fd != redirector && dup2 (fd, redirector) < 0)
1008 #if defined (BUFFERED_INPUT)
1009 duplicate_buffered_stream (fd, redirector);
1012 if ((flags & RX_CLEXEC) && (redirector > 2))
1013 SET_CLOSE_ON_EXEC (redirector);
1016 if (fd != redirector)
1017 #if defined (BUFFERED_INPUT)
1018 close_buffered_fd (fd);
1025 case r_duplicating_input:
1026 case r_duplicating_output:
1029 if ((flags & RX_ACTIVE) && (redirect->rflags & REDIR_VARASSIGN))
1031 redirector = fcntl (redir_fd, F_DUPFD, SHELL_FD_BASE); /* XXX try this for now */
1034 sys_error (_("redirection error: cannot duplicate fd"));
1035 REDIRECTION_ERROR (redirector, r, -1);
1038 if ((flags & RX_ACTIVE) && (redir_fd != redirector))
1040 if ((flags & RX_UNDOABLE) && (redirect->rflags & REDIR_VARASSIGN) == 0)
1042 /* Only setup to undo it if the thing to undo is active. */
1043 if (fcntl (redirector, F_GETFD, 0) != -1)
1044 r = add_undo_redirect (redirector, ri, redir_fd);
1046 r = add_undo_close_redirect (redirector);
1047 REDIRECTION_ERROR (r, errno, -1);
1049 if ((flags & RX_UNDOABLE) && (ri == r_move_input || ri == r_move_output))
1051 /* r_move_input and r_move_output add an additional close()
1052 that needs to be undone */
1053 if (fcntl (redirector, F_GETFD, 0) != -1)
1055 r = add_undo_redirect (redir_fd, r_close_this, -1);
1056 REDIRECTION_ERROR (r, errno, -1);
1059 #if defined (BUFFERED_INPUT)
1060 /* inhibit call to sync_buffered_stream() for async processes */
1061 if (redirector != 0 || (subshell_environment & SUBSHELL_ASYNC) == 0)
1062 check_bash_input (redirector);
1064 if (redirect->rflags & REDIR_VARASSIGN)
1066 if ((r = redir_varassign (redirect, redirector)) < 0)
1069 return (r); /* XXX */
1072 /* This is correct. 2>&1 means dup2 (1, 2); */
1073 else if (dup2 (redir_fd, redirector) < 0)
1076 #if defined (BUFFERED_INPUT)
1077 if (ri == r_duplicating_input || ri == r_move_input)
1078 duplicate_buffered_stream (redir_fd, redirector);
1079 #endif /* BUFFERED_INPUT */
1081 /* First duplicate the close-on-exec state of redirectee. dup2
1082 leaves the flag unset on the new descriptor, which means it
1083 stays open. Only set the close-on-exec bit for file descriptors
1084 greater than 2 in any case, since 0-2 should always be open
1085 unless closed by something like `exec 2<&-'. It should always
1086 be safe to set fds > 2 to close-on-exec if they're being used to
1087 save file descriptors < 2, since we don't need to preserve the
1088 state of the close-on-exec flag for those fds -- they should
1090 /* if ((already_set || set_unconditionally) && (ok_to_set))
1093 if (((fcntl (redir_fd, F_GETFD, 0) == 1) || redir_fd < 2 || (flags & RX_CLEXEC)) &&
1096 if (((fcntl (redir_fd, F_GETFD, 0) == 1) || (redir_fd < 2 && (flags & RX_INTERNAL)) || (flags & RX_CLEXEC)) &&
1099 SET_CLOSE_ON_EXEC (redirector);
1101 /* When undoing saving of non-standard file descriptors (>=3) using
1102 file descriptors >= SHELL_FD_BASE, we set the saving fd to be
1103 close-on-exec and use a flag to decide how to set close-on-exec
1104 when the fd is restored. */
1105 if ((redirect->flags & RX_INTERNAL) && (redirect->flags & RX_SAVCLEXEC) && redirector >= 3 && (redir_fd >= SHELL_FD_BASE || (redirect->flags & RX_SAVEFD)))
1106 SET_OPEN_ON_EXEC (redirector);
1108 /* dup-and-close redirection */
1109 if (ri == r_move_input || ri == r_move_output)
1111 xtrace_fdchk (redir_fd);
1114 #if defined (COPROCESS_SUPPORT)
1115 coproc_fdchk (redir_fd); /* XXX - loses coproc fds */
1122 if (flags & RX_ACTIVE)
1124 if (redirect->rflags & REDIR_VARASSIGN)
1126 redirector = redir_varvalue (redirect);
1128 return AMBIGUOUS_REDIRECT;
1132 /* XXX - only if REDIR_VARASSIGN not set? */
1133 if ((flags & RX_UNDOABLE) && (fcntl (redirector, F_GETFD, 0) != -1))
1135 r = add_undo_redirect (redirector, ri, -1);
1136 REDIRECTION_ERROR (r, errno, redirector);
1139 #if defined (COPROCESS_SUPPORT)
1140 coproc_fdchk (redirector);
1142 xtrace_fdchk (redirector);
1144 #if defined (BUFFERED_INPUT)
1145 /* inhibit call to sync_buffered_stream() for async processes */
1146 if (redirector != 0 || (subshell_environment & SUBSHELL_ASYNC) == 0)
1147 check_bash_input (redirector);
1148 r = close_buffered_fd (redirector);
1149 #else /* !BUFFERED_INPUT */
1150 r = close (redirector);
1151 #endif /* !BUFFERED_INPUT */
1153 if (r < 0 && (flags & RX_INTERNAL) && (errno == EIO || errno == ENOSPC))
1154 REDIRECTION_ERROR (r, errno, -1);
1158 case r_duplicating_input_word:
1159 case r_duplicating_output_word:
1165 /* Remember the file descriptor associated with the slot FD,
1166 on REDIRECTION_UNDO_LIST. Note that the list will be reversed
1167 before it is executed. Any redirections that need to be undone
1168 even if REDIRECTION_UNDO_LIST is discarded by the exec builtin
1169 are also saved on EXEC_REDIRECTION_UNDO_LIST. FDBASE says where to
1170 start the duplicating. If it's less than SHELL_FD_BASE, we're ok,
1171 and can use SHELL_FD_BASE (-1 == don't care). If it's >= SHELL_FD_BASE,
1172 we have to make sure we don't use fdbase to save a file descriptor,
1173 since we're going to use it later (e.g., make sure we don't save fd 0
1174 to fd 10 if we have a redirection like 0<&10). If the value of fdbase
1175 puts the process over its fd limit, causing fcntl to fail, we try
1176 again with SHELL_FD_BASE. Return 0 on success, -1 on error. */
1178 add_undo_redirect (fd, ri, fdbase)
1180 enum r_instruction ri;
1183 int new_fd, clexec_flag, savefd_flag;
1184 REDIRECT *new_redirect, *closer, *dummy_redirect;
1188 new_fd = fcntl (fd, F_DUPFD, (fdbase < SHELL_FD_BASE) ? SHELL_FD_BASE : fdbase+1);
1190 new_fd = fcntl (fd, F_DUPFD, SHELL_FD_BASE);
1193 new_fd = fcntl (fd, F_DUPFD, 0);
1199 sys_error (_("redirection error: cannot duplicate fd"));
1203 clexec_flag = fcntl (fd, F_GETFD, 0);
1207 closer = make_redirection (sd, r_close_this, rd, 0);
1208 closer->flags |= RX_INTERNAL;
1209 dummy_redirect = copy_redirects (closer);
1214 new_redirect = make_redirection (sd, r_duplicating_input, rd, 0);
1216 new_redirect = make_redirection (sd, r_duplicating_output, rd, 0);
1217 new_redirect->flags |= RX_INTERNAL;
1219 new_redirect->flags |= RX_SAVEFD;
1220 if (clexec_flag == 0 && fd >= 3 && (new_fd >= SHELL_FD_BASE || savefd_flag))
1221 new_redirect->flags |= RX_SAVCLEXEC;
1222 new_redirect->next = closer;
1224 closer->next = redirection_undo_list;
1225 redirection_undo_list = new_redirect;
1227 /* Save redirections that need to be undone even if the undo list
1228 is thrown away by the `exec' builtin. */
1229 add_exec_redirect (dummy_redirect);
1231 /* experimental: if we're saving a redirection to undo for a file descriptor
1232 above SHELL_FD_BASE, add a redirection to be undone if the exec builtin
1233 causes redirections to be discarded. There needs to be a difference
1234 between fds that are used to save other fds and then are the target of
1235 user redirections and fds that are just the target of user redirections.
1236 We use the close-on-exec flag to tell the difference; fds > SHELL_FD_BASE
1237 that have the close-on-exec flag set are assumed to be fds used internally
1239 if (fd >= SHELL_FD_BASE && ri != r_close_this && clexec_flag)
1243 new_redirect = make_redirection (sd, r_duplicating_output, rd, 0);
1244 new_redirect->flags |= RX_INTERNAL;
1246 add_exec_redirect (new_redirect);
1249 /* File descriptors used only for saving others should always be
1250 marked close-on-exec. Unfortunately, we have to preserve the
1251 close-on-exec state of the file descriptor we are saving, since
1252 fcntl (F_DUPFD) sets the new file descriptor to remain open
1253 across execs. If, however, the file descriptor whose state we
1254 are saving is <= 2, we can just set the close-on-exec flag,
1255 because file descriptors 0-2 should always be open-on-exec,
1256 and the restore above in do_redirection() will take care of it. */
1257 if (clexec_flag || fd < 3)
1258 SET_CLOSE_ON_EXEC (new_fd);
1259 else if (redirection_undo_list->flags & RX_SAVCLEXEC)
1260 SET_CLOSE_ON_EXEC (new_fd);
1265 /* Set up to close FD when we are finished with the current command
1266 and its redirections. Return 0 on success, -1 on error. */
1268 add_undo_close_redirect (fd)
1276 closer = make_redirection (sd, r_close_this, rd, 0);
1277 closer->flags |= RX_INTERNAL;
1278 closer->next = redirection_undo_list;
1279 redirection_undo_list = closer;
1285 add_exec_redirect (dummy_redirect)
1286 REDIRECT *dummy_redirect;
1288 dummy_redirect->next = exec_redirection_undo_list;
1289 exec_redirection_undo_list = dummy_redirect;
1292 /* Return 1 if the redirection specified by RI and REDIRECTOR alters the
1295 stdin_redirection (ri, redirector)
1296 enum r_instruction ri;
1301 case r_input_direction:
1302 case r_inputa_direction:
1303 case r_input_output:
1304 case r_reading_until:
1305 case r_deblank_reading_until:
1306 case r_reading_string:
1308 case r_duplicating_input:
1309 case r_duplicating_input_word:
1311 return (redirector == 0);
1312 case r_output_direction:
1313 case r_appending_to:
1314 case r_duplicating_output:
1316 case r_append_err_and_out:
1317 case r_output_force:
1318 case r_duplicating_output_word:
1324 /* Return non-zero if any of the redirections in REDIRS alter the standard
1327 stdin_redirects (redirs)
1333 for (n = 0, rp = redirs; rp; rp = rp->next)
1334 if ((rp->rflags & REDIR_VARASSIGN) == 0)
1335 n += stdin_redirection (rp->instruction, rp->redirector.dest);
1338 /* bind_var_to_int handles array references */
1340 redir_varassign (redir, fd)
1347 w = redir->redirector.filename;
1348 v = bind_var_to_int (w->word, fd);
1349 if (v == 0 || readonly_p (v) || noassign_p (v))
1350 return BADVAR_REDIRECT;
1352 stupidly_hack_special_variables (w->word);
1356 /* Handles {array[ind]} for redirection words */
1358 redir_varvalue (redir)
1365 #if defined (ARRAY_VARS)
1370 w = redir->redirector.filename->word; /* shorthand */
1371 /* XXX - handle set -u here? */
1372 #if defined (ARRAY_VARS)
1373 if (vr = valid_array_reference (w))
1374 v = array_variable_part (w, &sub, &len);
1377 v = find_variable (w);
1378 if (v == 0 || invisible_p (v))
1381 #if defined (ARRAY_VARS)
1382 /* get_variable_value handles references to array variables without
1384 if (vr && (array_p (v) || assoc_p (v)))
1385 val = get_array_value (w, 0, (int *)NULL, (arrayind_t *)0);
1388 val = get_variable_value (v);
1389 if (val == 0 || *val == 0)
1392 if (legal_number (val, &vmax) < 0)
1395 i = vmax; /* integer truncation */