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
)
676 run_pending_traps ();
680 while (fd
< 0 && errno
== EINTR
);
683 if ((fd
< 0) && (errno
== EACCES
))
685 fd
= open (filename
, flags
& ~O_CREAT
, mode
);
686 errno
= EACCES
; /* restore errno */
700 clexec
= fcntl (fd
, F_GETFD
, 0);
701 if (clexec
== -1 || (fd
>= SHELL_FD_BASE
&& clexec
== 1))
706 /* Do the specific redirection requested. Returns errno or one of the
707 special redirection errors (*_REDIRECT) in case of error, 0 on success.
708 If flags & RX_ACTIVE is zero, then just do whatever is necessary to
709 produce the appropriate side effects. flags & RX_UNDOABLE, if non-zero,
710 says to remember how to undo each redirection. If flags & RX_CLEXEC is
711 non-zero, then we set all file descriptors > 2 that we open to be
714 do_redirection_internal (redirect
, flags
)
718 WORD_DESC
*redirectee
;
719 int redir_fd
, fd
, redirector
, r
, oflags
;
721 char *redirectee_word
;
722 enum r_instruction ri
;
723 REDIRECT
*new_redirect
;
726 redirectee
= redirect
->redirectee
.filename
;
727 redir_fd
= redirect
->redirectee
.dest
;
728 redirector
= redirect
->redirector
.dest
;
729 ri
= redirect
->instruction
;
731 if (redirect
->flags
& RX_INTERNAL
)
732 flags
|= RX_INTERNAL
;
734 if (TRANSLATE_REDIRECT (ri
))
736 /* We have [N]>&WORD[-] or [N]<&WORD[-] (or {V}>&WORD[-] or {V}<&WORD-).
737 and WORD, then translate the redirection into a new one and
739 redirectee_word
= redirection_expand (redirectee
);
741 /* XXX - what to do with [N]<&$w- where w is unset or null? ksh93
743 if (redirectee_word
== 0)
744 return (AMBIGUOUS_REDIRECT
);
745 else if (redirectee_word
[0] == '-' && redirectee_word
[1] == '\0')
747 sd
= redirect
->redirector
;
749 new_redirect
= make_redirection (sd
, r_close_this
, rd
, 0);
751 else if (all_digits (redirectee_word
))
753 sd
= redirect
->redirector
;
754 if (legal_number (redirectee_word
, &lfd
) && (int)lfd
== lfd
)
757 rd
.dest
= -1; /* XXX */
760 case r_duplicating_input_word
:
761 new_redirect
= make_redirection (sd
, r_duplicating_input
, rd
, 0);
763 case r_duplicating_output_word
:
764 new_redirect
= make_redirection (sd
, r_duplicating_output
, rd
, 0);
766 case r_move_input_word
:
767 new_redirect
= make_redirection (sd
, r_move_input
, rd
, 0);
769 case r_move_output_word
:
770 new_redirect
= make_redirection (sd
, r_move_output
, rd
, 0);
774 else if (ri
== r_duplicating_output_word
&& (redirect
->rflags
& REDIR_VARASSIGN
) == 0 && redirector
== 1)
776 sd
= redirect
->redirector
;
777 rd
.filename
= make_bare_word (redirectee_word
);
778 new_redirect
= make_redirection (sd
, r_err_and_out
, rd
, 0);
782 free (redirectee_word
);
783 return (AMBIGUOUS_REDIRECT
);
786 free (redirectee_word
);
788 /* Set up the variables needed by the rest of the function from the
790 if (new_redirect
->instruction
== r_err_and_out
)
794 /* Copy the word without allocating any memory that must be
796 redirectee
= (WORD_DESC
*)alloca (sizeof (WORD_DESC
));
797 xbcopy ((char *)new_redirect
->redirectee
.filename
,
798 (char *)redirectee
, sizeof (WORD_DESC
));
800 alloca_hack
= (char *)
801 alloca (1 + strlen (new_redirect
->redirectee
.filename
->word
));
802 redirectee
->word
= alloca_hack
;
803 strcpy (redirectee
->word
, new_redirect
->redirectee
.filename
->word
);
806 /* It's guaranteed to be an integer, and shouldn't be freed. */
807 redirectee
= new_redirect
->redirectee
.filename
;
809 redir_fd
= new_redirect
->redirectee
.dest
;
810 redirector
= new_redirect
->redirector
.dest
;
811 ri
= new_redirect
->instruction
;
813 /* Overwrite the flags element of the old redirect with the new value. */
814 redirect
->flags
= new_redirect
->flags
;
815 dispose_redirects (new_redirect
);
820 case r_output_direction
:
822 case r_input_direction
:
823 case r_inputa_direction
:
824 case r_err_and_out
: /* command &>filename */
825 case r_append_err_and_out
: /* command &>> filename */
828 if (posixly_correct
&& interactive_shell
== 0)
830 oflags
= redirectee
->flags
;
831 redirectee
->flags
|= W_NOGLOB
;
833 redirectee_word
= redirection_expand (redirectee
);
834 if (posixly_correct
&& interactive_shell
== 0)
835 redirectee
->flags
= oflags
;
837 if (redirectee_word
== 0)
838 return (AMBIGUOUS_REDIRECT
);
840 #if defined (RESTRICTED_SHELL)
841 if (restricted
&& (WRITE_REDIRECT (ri
)))
843 free (redirectee_word
);
844 return (RESTRICTED_REDIRECT
);
846 #endif /* RESTRICTED_SHELL */
848 fd
= redir_open (redirectee_word
, redirect
->flags
, 0666, ri
);
849 free (redirectee_word
);
851 if (fd
== NOCLOBBER_REDIRECT
)
857 if (flags
& RX_ACTIVE
)
859 if (redirect
->rflags
& REDIR_VARASSIGN
)
861 redirector
= fcntl (fd
, F_DUPFD
, SHELL_FD_BASE
); /* XXX try this for now */
864 sys_error (_("redirection error: cannot duplicate fd"));
865 REDIRECTION_ERROR (redirector
, r
, fd
);
868 if ((flags
& RX_UNDOABLE
) && (redirect
->rflags
& REDIR_VARASSIGN
) == 0)
870 /* Only setup to undo it if the thing to undo is active. */
871 if ((fd
!= redirector
) && (fcntl (redirector
, F_GETFD
, 0) != -1))
872 r
= add_undo_redirect (redirector
, ri
, -1);
874 r
= add_undo_close_redirect (redirector
);
875 REDIRECTION_ERROR (r
, errno
, fd
);
878 #if defined (BUFFERED_INPUT)
879 /* inhibit call to sync_buffered_stream() for async processes */
880 if (redirector
!= 0 || (subshell_environment
& SUBSHELL_ASYNC
) == 0)
881 check_bash_input (redirector
);
884 /* Make sure there is no pending output before we change the state
885 of the underlying file descriptor, since the builtins use stdio
887 if (redirector
== 1 && fileno (stdout
) == redirector
)
892 else if (redirector
== 2 && fileno (stderr
) == redirector
)
898 if (redirect
->rflags
& REDIR_VARASSIGN
)
900 if ((r
= redir_varassign (redirect
, redirector
)) < 0)
904 return (r
); /* XXX */
907 else if ((fd
!= redirector
) && (dup2 (fd
, redirector
) < 0))
910 #if defined (BUFFERED_INPUT)
911 /* Do not change the buffered stream for an implicit redirection
912 of /dev/null to fd 0 for asynchronous commands without job
913 control (r_inputa_direction). */
914 if (ri
== r_input_direction
|| ri
== r_input_output
)
915 duplicate_buffered_stream (fd
, redirector
);
916 #endif /* BUFFERED_INPUT */
919 * If we're remembering, then this is the result of a while, for
920 * or until loop with a loop redirection, or a function/builtin
921 * executing in the parent shell with a redirection. In the
922 * function/builtin case, we want to set all file descriptors > 2
923 * to be close-on-exec to duplicate the effect of the old
924 * for i = 3 to NOFILE close(i) loop. In the case of the loops,
925 * both sh and ksh leave the file descriptors open across execs.
926 * The Posix standard mentions only the exec builtin.
928 if ((flags
& RX_CLEXEC
) && (redirector
> 2))
929 SET_CLOSE_ON_EXEC (redirector
);
932 if (fd
!= redirector
)
934 #if defined (BUFFERED_INPUT)
935 if (INPUT_REDIRECT (ri
))
936 close_buffered_fd (fd
);
938 #endif /* !BUFFERED_INPUT */
939 close (fd
); /* Don't close what we just opened! */
942 /* If we are hacking both stdout and stderr, do the stderr
943 redirection here. XXX - handle {var} here? */
944 if (ri
== r_err_and_out
|| ri
== r_append_err_and_out
)
946 if (flags
& RX_ACTIVE
)
948 if (flags
& RX_UNDOABLE
)
949 add_undo_redirect (2, ri
, -1);
956 case r_reading_until
:
957 case r_deblank_reading_until
:
958 case r_reading_string
:
959 /* REDIRECTEE is a pointer to a WORD_DESC containing the text of
960 the new input. Place it in a temporary file. */
963 fd
= here_document_to_fd (redirectee
, ri
);
967 heredoc_errno
= errno
;
968 return (HEREDOC_REDIRECT
);
971 if (redirect
->rflags
& REDIR_VARASSIGN
)
973 redirector
= fcntl (fd
, F_DUPFD
, SHELL_FD_BASE
); /* XXX try this for now */
976 sys_error (_("redirection error: cannot duplicate fd"));
977 REDIRECTION_ERROR (redirector
, r
, fd
);
980 if (flags
& RX_ACTIVE
)
982 if ((flags
& RX_UNDOABLE
) && (redirect
->rflags
& REDIR_VARASSIGN
) == 0)
984 /* Only setup to undo it if the thing to undo is active. */
985 if ((fd
!= redirector
) && (fcntl (redirector
, F_GETFD
, 0) != -1))
986 r
= add_undo_redirect (redirector
, ri
, -1);
988 r
= add_undo_close_redirect (redirector
);
989 REDIRECTION_ERROR (r
, errno
, fd
);
992 #if defined (BUFFERED_INPUT)
993 check_bash_input (redirector
);
995 if (redirect
->rflags
& REDIR_VARASSIGN
)
997 if ((r
= redir_varassign (redirect
, redirector
)) < 0)
1001 return (r
); /* XXX */
1004 else if (fd
!= redirector
&& dup2 (fd
, redirector
) < 0)
1011 #if defined (BUFFERED_INPUT)
1012 duplicate_buffered_stream (fd
, redirector
);
1015 if ((flags
& RX_CLEXEC
) && (redirector
> 2))
1016 SET_CLOSE_ON_EXEC (redirector
);
1019 if (fd
!= redirector
)
1020 #if defined (BUFFERED_INPUT)
1021 close_buffered_fd (fd
);
1028 case r_duplicating_input
:
1029 case r_duplicating_output
:
1032 if ((flags
& RX_ACTIVE
) && (redirect
->rflags
& REDIR_VARASSIGN
))
1034 redirector
= fcntl (redir_fd
, F_DUPFD
, SHELL_FD_BASE
); /* XXX try this for now */
1037 sys_error (_("redirection error: cannot duplicate fd"));
1038 REDIRECTION_ERROR (redirector
, r
, -1);
1041 if ((flags
& RX_ACTIVE
) && (redir_fd
!= redirector
))
1043 if ((flags
& RX_UNDOABLE
) && (redirect
->rflags
& REDIR_VARASSIGN
) == 0)
1045 /* Only setup to undo it if the thing to undo is active. */
1046 if (fcntl (redirector
, F_GETFD
, 0) != -1)
1047 r
= add_undo_redirect (redirector
, ri
, redir_fd
);
1049 r
= add_undo_close_redirect (redirector
);
1050 REDIRECTION_ERROR (r
, errno
, -1);
1052 if ((flags
& RX_UNDOABLE
) && (ri
== r_move_input
|| ri
== r_move_output
))
1054 /* r_move_input and r_move_output add an additional close()
1055 that needs to be undone */
1056 if (fcntl (redirector
, F_GETFD
, 0) != -1)
1058 r
= add_undo_redirect (redir_fd
, r_close_this
, -1);
1059 REDIRECTION_ERROR (r
, errno
, -1);
1062 #if defined (BUFFERED_INPUT)
1063 /* inhibit call to sync_buffered_stream() for async processes */
1064 if (redirector
!= 0 || (subshell_environment
& SUBSHELL_ASYNC
) == 0)
1065 check_bash_input (redirector
);
1067 if (redirect
->rflags
& REDIR_VARASSIGN
)
1069 if ((r
= redir_varassign (redirect
, redirector
)) < 0)
1072 return (r
); /* XXX */
1075 /* This is correct. 2>&1 means dup2 (1, 2); */
1076 else if (dup2 (redir_fd
, redirector
) < 0)
1079 #if defined (BUFFERED_INPUT)
1080 if (ri
== r_duplicating_input
|| ri
== r_move_input
)
1081 duplicate_buffered_stream (redir_fd
, redirector
);
1082 #endif /* BUFFERED_INPUT */
1084 /* First duplicate the close-on-exec state of redirectee. dup2
1085 leaves the flag unset on the new descriptor, which means it
1086 stays open. Only set the close-on-exec bit for file descriptors
1087 greater than 2 in any case, since 0-2 should always be open
1088 unless closed by something like `exec 2<&-'. It should always
1089 be safe to set fds > 2 to close-on-exec if they're being used to
1090 save file descriptors < 2, since we don't need to preserve the
1091 state of the close-on-exec flag for those fds -- they should
1093 /* if ((already_set || set_unconditionally) && (ok_to_set))
1096 if (((fcntl (redir_fd
, F_GETFD
, 0) == 1) || redir_fd
< 2 || (flags
& RX_CLEXEC
)) &&
1099 if (((fcntl (redir_fd
, F_GETFD
, 0) == 1) || (redir_fd
< 2 && (flags
& RX_INTERNAL
)) || (flags
& RX_CLEXEC
)) &&
1102 SET_CLOSE_ON_EXEC (redirector
);
1104 /* When undoing saving of non-standard file descriptors (>=3) using
1105 file descriptors >= SHELL_FD_BASE, we set the saving fd to be
1106 close-on-exec and use a flag to decide how to set close-on-exec
1107 when the fd is restored. */
1108 if ((redirect
->flags
& RX_INTERNAL
) && (redirect
->flags
& RX_SAVCLEXEC
) && redirector
>= 3 && (redir_fd
>= SHELL_FD_BASE
|| (redirect
->flags
& RX_SAVEFD
)))
1109 SET_OPEN_ON_EXEC (redirector
);
1111 /* dup-and-close redirection */
1112 if (ri
== r_move_input
|| ri
== r_move_output
)
1114 xtrace_fdchk (redir_fd
);
1117 #if defined (COPROCESS_SUPPORT)
1118 coproc_fdchk (redir_fd
); /* XXX - loses coproc fds */
1125 if (flags
& RX_ACTIVE
)
1127 if (redirect
->rflags
& REDIR_VARASSIGN
)
1129 redirector
= redir_varvalue (redirect
);
1131 return AMBIGUOUS_REDIRECT
;
1135 /* XXX - only if REDIR_VARASSIGN not set? */
1136 if ((flags
& RX_UNDOABLE
) && (fcntl (redirector
, F_GETFD
, 0) != -1))
1138 r
= add_undo_redirect (redirector
, ri
, -1);
1139 REDIRECTION_ERROR (r
, errno
, redirector
);
1142 #if defined (COPROCESS_SUPPORT)
1143 coproc_fdchk (redirector
);
1145 xtrace_fdchk (redirector
);
1147 #if defined (BUFFERED_INPUT)
1148 /* inhibit call to sync_buffered_stream() for async processes */
1149 if (redirector
!= 0 || (subshell_environment
& SUBSHELL_ASYNC
) == 0)
1150 check_bash_input (redirector
);
1151 r
= close_buffered_fd (redirector
);
1152 #else /* !BUFFERED_INPUT */
1153 r
= close (redirector
);
1154 #endif /* !BUFFERED_INPUT */
1156 if (r
< 0 && (flags
& RX_INTERNAL
) && (errno
== EIO
|| errno
== ENOSPC
))
1157 REDIRECTION_ERROR (r
, errno
, -1);
1161 case r_duplicating_input_word
:
1162 case r_duplicating_output_word
:
1168 /* Remember the file descriptor associated with the slot FD,
1169 on REDIRECTION_UNDO_LIST. Note that the list will be reversed
1170 before it is executed. Any redirections that need to be undone
1171 even if REDIRECTION_UNDO_LIST is discarded by the exec builtin
1172 are also saved on EXEC_REDIRECTION_UNDO_LIST. FDBASE says where to
1173 start the duplicating. If it's less than SHELL_FD_BASE, we're ok,
1174 and can use SHELL_FD_BASE (-1 == don't care). If it's >= SHELL_FD_BASE,
1175 we have to make sure we don't use fdbase to save a file descriptor,
1176 since we're going to use it later (e.g., make sure we don't save fd 0
1177 to fd 10 if we have a redirection like 0<&10). If the value of fdbase
1178 puts the process over its fd limit, causing fcntl to fail, we try
1179 again with SHELL_FD_BASE. Return 0 on success, -1 on error. */
1181 add_undo_redirect (fd
, ri
, fdbase
)
1183 enum r_instruction ri
;
1186 int new_fd
, clexec_flag
, savefd_flag
;
1187 REDIRECT
*new_redirect
, *closer
, *dummy_redirect
;
1191 new_fd
= fcntl (fd
, F_DUPFD
, (fdbase
< SHELL_FD_BASE
) ? SHELL_FD_BASE
: fdbase
+1);
1193 new_fd
= fcntl (fd
, F_DUPFD
, SHELL_FD_BASE
);
1196 new_fd
= fcntl (fd
, F_DUPFD
, 0);
1202 sys_error (_("redirection error: cannot duplicate fd"));
1206 clexec_flag
= fcntl (fd
, F_GETFD
, 0);
1210 closer
= make_redirection (sd
, r_close_this
, rd
, 0);
1211 closer
->flags
|= RX_INTERNAL
;
1212 dummy_redirect
= copy_redirects (closer
);
1217 new_redirect
= make_redirection (sd
, r_duplicating_input
, rd
, 0);
1219 new_redirect
= make_redirection (sd
, r_duplicating_output
, rd
, 0);
1220 new_redirect
->flags
|= RX_INTERNAL
;
1222 new_redirect
->flags
|= RX_SAVEFD
;
1223 if (clexec_flag
== 0 && fd
>= 3 && (new_fd
>= SHELL_FD_BASE
|| savefd_flag
))
1224 new_redirect
->flags
|= RX_SAVCLEXEC
;
1225 new_redirect
->next
= closer
;
1227 closer
->next
= redirection_undo_list
;
1228 redirection_undo_list
= new_redirect
;
1230 /* Save redirections that need to be undone even if the undo list
1231 is thrown away by the `exec' builtin. */
1232 add_exec_redirect (dummy_redirect
);
1234 /* experimental: if we're saving a redirection to undo for a file descriptor
1235 above SHELL_FD_BASE, add a redirection to be undone if the exec builtin
1236 causes redirections to be discarded. There needs to be a difference
1237 between fds that are used to save other fds and then are the target of
1238 user redirections and fds that are just the target of user redirections.
1239 We use the close-on-exec flag to tell the difference; fds > SHELL_FD_BASE
1240 that have the close-on-exec flag set are assumed to be fds used internally
1242 if (fd
>= SHELL_FD_BASE
&& ri
!= r_close_this
&& clexec_flag
)
1246 new_redirect
= make_redirection (sd
, r_duplicating_output
, rd
, 0);
1247 new_redirect
->flags
|= RX_INTERNAL
;
1249 add_exec_redirect (new_redirect
);
1252 /* File descriptors used only for saving others should always be
1253 marked close-on-exec. Unfortunately, we have to preserve the
1254 close-on-exec state of the file descriptor we are saving, since
1255 fcntl (F_DUPFD) sets the new file descriptor to remain open
1256 across execs. If, however, the file descriptor whose state we
1257 are saving is <= 2, we can just set the close-on-exec flag,
1258 because file descriptors 0-2 should always be open-on-exec,
1259 and the restore above in do_redirection() will take care of it. */
1260 if (clexec_flag
|| fd
< 3)
1261 SET_CLOSE_ON_EXEC (new_fd
);
1262 else if (redirection_undo_list
->flags
& RX_SAVCLEXEC
)
1263 SET_CLOSE_ON_EXEC (new_fd
);
1268 /* Set up to close FD when we are finished with the current command
1269 and its redirections. Return 0 on success, -1 on error. */
1271 add_undo_close_redirect (fd
)
1279 closer
= make_redirection (sd
, r_close_this
, rd
, 0);
1280 closer
->flags
|= RX_INTERNAL
;
1281 closer
->next
= redirection_undo_list
;
1282 redirection_undo_list
= closer
;
1288 add_exec_redirect (dummy_redirect
)
1289 REDIRECT
*dummy_redirect
;
1291 dummy_redirect
->next
= exec_redirection_undo_list
;
1292 exec_redirection_undo_list
= dummy_redirect
;
1295 /* Return 1 if the redirection specified by RI and REDIRECTOR alters the
1298 stdin_redirection (ri
, redirector
)
1299 enum r_instruction ri
;
1304 case r_input_direction
:
1305 case r_inputa_direction
:
1306 case r_input_output
:
1307 case r_reading_until
:
1308 case r_deblank_reading_until
:
1309 case r_reading_string
:
1311 case r_duplicating_input
:
1312 case r_duplicating_input_word
:
1314 return (redirector
== 0);
1315 case r_output_direction
:
1316 case r_appending_to
:
1317 case r_duplicating_output
:
1319 case r_append_err_and_out
:
1320 case r_output_force
:
1321 case r_duplicating_output_word
:
1327 /* Return non-zero if any of the redirections in REDIRS alter the standard
1330 stdin_redirects (redirs
)
1336 for (n
= 0, rp
= redirs
; rp
; rp
= rp
->next
)
1337 if ((rp
->rflags
& REDIR_VARASSIGN
) == 0)
1338 n
+= stdin_redirection (rp
->instruction
, rp
->redirector
.dest
);
1341 /* bind_var_to_int handles array references */
1343 redir_varassign (redir
, fd
)
1350 w
= redir
->redirector
.filename
;
1351 v
= bind_var_to_int (w
->word
, fd
);
1352 if (v
== 0 || readonly_p (v
) || noassign_p (v
))
1353 return BADVAR_REDIRECT
;
1355 stupidly_hack_special_variables (w
->word
);
1359 /* Handles {array[ind]} for redirection words */
1361 redir_varvalue (redir
)
1368 #if defined (ARRAY_VARS)
1373 w
= redir
->redirector
.filename
->word
; /* shorthand */
1374 /* XXX - handle set -u here? */
1375 #if defined (ARRAY_VARS)
1376 if (vr
= valid_array_reference (w
))
1377 v
= array_variable_part (w
, &sub
, &len
);
1380 v
= find_variable (w
);
1381 if (v
== 0 || invisible_p (v
))
1384 #if defined (ARRAY_VARS)
1385 /* get_variable_value handles references to array variables without
1387 if (vr
&& (array_p (v
) || assoc_p (v
)))
1388 val
= get_array_value (w
, 0, (int *)NULL
, (arrayind_t
*)0);
1391 val
= get_variable_value (v
);
1392 if (val
== 0 || *val
== 0)
1395 if (legal_number (val
, &vmax
) < 0)
1398 i
= vmax
; /* integer truncation */