1 /* redir.c -- Functions to perform input and output redirection. */
3 /* Copyright (C) 1997 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 it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 Bash is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
15 License for more details.
17 You should have received a copy of the GNU General Public License
18 along with Bash; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
22 #if !defined (__GNUC__) && !defined (HAVE_ALLOCA_H) && defined (_AIX)
24 #endif /* _AIX && RISC6000 && !__GNUC__ */
27 #include "bashtypes.h"
29 # include <sys/file.h>
32 #include "posixstat.h"
34 #if defined (HAVE_UNISTD_H)
49 #include "execute_cmd.h"
52 #if defined (BUFFERED_INPUT)
56 extern int posixly_correct;
57 extern REDIRECT *redirection_undo_list;
58 extern REDIRECT *exec_redirection_undo_list;
60 /* Static functions defined and used in this file. */
61 static void add_undo_close_redirect __P((int));
62 static void add_exec_redirect __P((REDIRECT *));
63 static int add_undo_redirect __P((int));
64 static int expandable_redirection_filename __P((REDIRECT *));
65 static int stdin_redirection __P((enum r_instruction, int));
66 static int do_redirection_internal __P((REDIRECT *, int, int, int));
68 static int write_here_document __P((int, WORD_DESC *));
69 static int here_document_to_fd __P((WORD_DESC *));
71 static int redir_special_open __P((int, char *, int, int, enum r_instruction));
72 static int noclobber_open __P((char *, int, int, enum r_instruction));
73 static int redir_open __P((char *, int, int, enum r_instruction));
75 /* Spare redirector used when translating [N]>&WORD or [N]<&WORD to a new
76 redirection and when creating the redirection undo list. */
79 /* Set to errno when a here document cannot be created for some reason.
80 Used to print a reasonable error message. */
81 static int heredoc_errno;
84 redirection_error (temp, error)
88 char *filename, *allocname;
92 if (temp->redirector < 0)
93 /* This can happen when read_token_word encounters overflow, like in
95 filename = "file descriptor out of range";
97 else if (temp->redirector >= 0 && errno == EBADF)
98 filename = allocname = itos (temp->redirector);
100 else if (expandable_redirection_filename (temp))
102 if (posixly_correct && interactive_shell == 0)
104 oflags = temp->redirectee.filename->flags;
105 temp->redirectee.filename->flags |= W_NOGLOB;
107 filename = allocname = redirection_expand (temp->redirectee.filename);
108 if (posixly_correct && interactive_shell == 0)
109 temp->redirectee.filename->flags = oflags;
111 filename = temp->redirectee.filename->word;
113 else if (temp->redirectee.dest < 0)
114 filename = "file descriptor out of range";
116 filename = allocname = itos (temp->redirectee.dest);
120 case AMBIGUOUS_REDIRECT:
121 internal_error ("%s: ambiguous redirect", filename);
124 case NOCLOBBER_REDIRECT:
125 internal_error ("%s: cannot overwrite existing file", filename);
128 #if defined (RESTRICTED_SHELL)
129 case RESTRICTED_REDIRECT:
130 internal_error ("%s: restricted: cannot redirect output", filename);
132 #endif /* RESTRICTED_SHELL */
134 case HEREDOC_REDIRECT:
135 internal_error ("cannot create temp file for here document: %s", strerror (heredoc_errno));
139 internal_error ("%s: %s", filename, strerror (error));
146 /* Perform the redirections on LIST. If FOR_REAL, then actually make
147 input and output file descriptors, otherwise just do whatever is
148 neccessary for side effecting. INTERNAL says to remember how to
149 undo the redirections later, if non-zero. If SET_CLEXEC is non-zero,
150 file descriptors opened in do_redirection () have their close-on-exec
153 do_redirections (list, for_real, internal, set_clexec)
155 int for_real, internal, set_clexec;
162 if (redirection_undo_list)
164 dispose_redirects (redirection_undo_list);
165 redirection_undo_list = (REDIRECT *)NULL;
167 if (exec_redirection_undo_list)
168 dispose_exec_redirects ();
171 for (temp = list; temp; temp = temp->next)
173 error = do_redirection_internal (temp, for_real, internal, set_clexec);
176 redirection_error (temp, error);
183 /* Return non-zero if the redirection pointed to by REDIRECT has a
184 redirectee.filename that can be expanded. */
186 expandable_redirection_filename (redirect)
189 switch (redirect->instruction)
191 case r_output_direction:
193 case r_input_direction:
194 case r_inputa_direction:
198 case r_duplicating_input_word:
199 case r_duplicating_output_word:
207 /* Expand the word in WORD returning a string. If WORD expands to
208 multiple words (or no words), then return NULL. */
210 redirection_expand (word)
214 WORD_LIST *tlist1, *tlist2;
217 w = copy_word (word);
219 w->flags |= W_NOSPLIT;
221 tlist1 = make_word_list (w, (WORD_LIST *)NULL);
222 tlist2 = expand_words_no_vars (tlist1);
223 dispose_words (tlist1);
225 if (!tlist2 || tlist2->next)
227 /* We expanded to no words, or to more than a single word.
228 Dispose of the word list and return NULL. */
230 dispose_words (tlist2);
231 return ((char *)NULL);
233 result = string_list (tlist2); /* XXX savestring (tlist2->word->word)? */
234 dispose_words (tlist2);
238 /* Write the text of the here document pointed to by REDIRECTEE to the file
239 descriptor FD, which is already open to a temp file. Return 0 if the
240 write is successful, otherwise return errno. */
242 write_here_document (fd, redirectee)
244 WORD_DESC *redirectee;
247 int document_len, fd2;
249 register WORD_LIST *t, *tlist;
251 /* Expand the text if the word that was specified had
252 no quoting. The text that we expand is treated
253 exactly as if it were surrounded by double quotes. */
255 if (redirectee->flags & W_QUOTED)
257 document = redirectee->word;
258 document_len = strlen (document);
259 /* Set errno to something reasonable if the write fails. */
260 if (write (fd, document, document_len) < document_len)
270 tlist = expand_string (redirectee->word, Q_HERE_DOCUMENT);
273 /* Try using buffered I/O (stdio) and writing a word
274 at a time, letting stdio do the work of buffering
275 for us rather than managing our own strings. Most
276 stdios are not particularly fast, however -- this
277 may need to be reconsidered later. */
278 if ((fd2 = dup (fd)) < 0 || (fp = fdopen (fd2, "w")) == NULL)
285 for (t = tlist; t; t = t->next)
287 /* This is essentially the body of
288 string_list_internal expanded inline. */
289 document = t->word->word;
290 document_len = strlen (document);
292 putc (' ', fp); /* separator */
293 fwrite (document, document_len, 1, fp);
300 dispose_words (tlist);
304 dispose_words (tlist);
305 if (fclose (fp) != 0)
315 /* Create a temporary file holding the text of the here document pointed to
316 by REDIRECTEE, and return a file descriptor open for reading to the temp
317 file. Return -1 on any error, and make sure errno is set appropriately. */
319 here_document_to_fd (redirectee)
320 WORD_DESC *redirectee;
325 fd = sh_mktmpfd ("sh-thd", MT_USERANDOM, &filename);
327 /* If we failed for some reason other than the file existing, abort */
334 errno = r = 0; /* XXX */
335 /* write_here_document returns 0 on success, errno on failure. */
336 if (redirectee->word)
337 r = write_here_document (fd, redirectee);
348 /* In an attempt to avoid races, we close the first fd only after opening
350 /* Make the document really temporary. Also make it the input. */
351 fd2 = open (filename, O_RDONLY, 0600);
364 if (unlink (filename) < 0)
367 #if defined (__CYGWIN__)
368 /* Under CygWin 1.1.0, the unlink will fail if the file is
369 open. This hack will allow the previous action of silently
370 ignoring the error, but will still leave the file there. This
371 needs some kind of magic. */
374 #endif /* __CYGWIN__ */
386 #define RF_DEVSTDERR 2
387 #define RF_DEVSTDIN 3
388 #define RF_DEVSTDOUT 4
392 /* A list of pattern/value pairs for filenames that the redirection
393 code handles specially. */
394 static STRING_INT_ALIST _redir_special_filenames[] = {
395 #if !defined (HAVE_DEV_FD)
396 { "/dev/fd/[0-9]*", RF_DEVFD },
398 #if !defined (HAVE_DEV_STDIN)
399 { "/dev/stderr", RF_DEVSTDERR },
400 { "/dev/stdin", RF_DEVSTDIN },
401 { "/dev/stdout", RF_DEVSTDOUT },
403 #if defined (NETWORK_REDIRECTIONS)
404 { "/dev/tcp/*/*", RF_DEVTCP },
405 { "/dev/udp/*/*", RF_DEVUDP },
411 redir_special_open (spec, filename, flags, mode, ri)
415 enum r_instruction ri;
418 #if !defined (HAVE_DEV_FD)
425 #if !defined (HAVE_DEV_FD)
427 if (all_digits (filename+8) && legal_number (filename+8, &lfd) && lfd == (int)lfd)
430 fd = fcntl (fd, F_DUPFD, 10);
433 fd = AMBIGUOUS_REDIRECT;
437 #if !defined (HAVE_DEV_STDIN)
439 fd = fcntl (0, F_DUPFD, 10);
442 fd = fcntl (1, F_DUPFD, 10);
445 fd = fcntl (2, F_DUPFD, 10);
449 #if defined (NETWORK_REDIRECTIONS)
452 #if defined (HAVE_NETWORK)
453 fd = netopen (filename);
455 internal_warning ("/dev/(tcp|udp)/host/port not supported without networking");
456 fd = open (filename, flags, mode);
459 #endif /* NETWORK_REDIRECTIONS */
465 /* Open FILENAME with FLAGS in noclobber mode, hopefully avoiding most
466 race conditions and avoiding the problem where the file is replaced
467 between the stat(2) and open(2). */
469 noclobber_open (filename, flags, mode, ri)
472 enum r_instruction ri;
475 struct stat finfo, finfo2;
477 /* If the file exists and is a regular file, return an error
479 r = stat (filename, &finfo);
480 if (r == 0 && (S_ISREG (finfo.st_mode)))
481 return (NOCLOBBER_REDIRECT);
483 /* If the file was not present (r != 0), make sure we open it
484 exclusively so that if it is created before we open it, our open
485 will fail. Make sure that we do not truncate an existing file.
486 Note that we don't turn on O_EXCL unless the stat failed -- if
487 the file was not a regular file, we leave O_EXCL off. */
491 fd = open (filename, flags|O_EXCL, mode);
492 return ((fd < 0 && errno == EEXIST) ? NOCLOBBER_REDIRECT : fd);
494 fd = open (filename, flags, mode);
496 /* If the open failed, return the file descriptor right away. */
498 return (errno == EEXIST ? NOCLOBBER_REDIRECT : fd);
500 /* OK, the open succeeded, but the file may have been changed from a
501 non-regular file to a regular file between the stat and the open.
502 We are assuming that the O_EXCL open handles the case where FILENAME
503 did not exist and is symlinked to an existing file between the stat
506 /* If we can open it and fstat the file descriptor, and neither check
507 revealed that it was a regular file, and the file has not been replaced,
508 return the file descriptor. */
509 if ((fstat (fd, &finfo2) == 0) && (S_ISREG (finfo2.st_mode) == 0) &&
510 r == 0 && (S_ISREG (finfo.st_mode) == 0) &&
511 same_file (filename, filename, &finfo, &finfo2))
514 /* The file has been replaced. badness. */
517 return (NOCLOBBER_REDIRECT);
521 redir_open (filename, flags, mode, ri)
524 enum r_instruction ri;
528 r = find_string_in_alist (filename, _redir_special_filenames, 1);
530 return (redir_special_open (r, filename, flags, mode, ri));
532 /* If we are in noclobber mode, you are not allowed to overwrite
533 existing files. Check before opening. */
534 if (noclobber && CLOBBERING_REDIRECT (ri))
536 fd = noclobber_open (filename, flags, mode, ri);
537 if (fd == NOCLOBBER_REDIRECT)
538 return (NOCLOBBER_REDIRECT);
542 fd = open (filename, flags, mode);
544 if ((fd < 0) && (errno == EACCES))
545 fd = open (filename, flags & ~O_CREAT, mode);
552 /* Do the specific redirection requested. Returns errno or one of the
553 special redirection errors (*_REDIRECT) in case of error, 0 on success.
554 If FOR_REAL is zero, then just do whatever is neccessary to produce the
555 appropriate side effects. REMEMBERING, if non-zero, says to remember
556 how to undo each redirection. If SET_CLEXEC is non-zero, then
557 we set all file descriptors > 2 that we open to be close-on-exec. */
559 do_redirection_internal (redirect, for_real, remembering, set_clexec)
561 int for_real, remembering, set_clexec;
563 WORD_DESC *redirectee;
564 int redir_fd, fd, redirector, r, oflags;
566 char *redirectee_word;
567 enum r_instruction ri;
568 REDIRECT *new_redirect;
570 redirectee = redirect->redirectee.filename;
571 redir_fd = redirect->redirectee.dest;
572 redirector = redirect->redirector;
573 ri = redirect->instruction;
575 if (ri == r_duplicating_input_word || ri == r_duplicating_output_word)
577 /* We have [N]>&WORD or [N]<&WORD. Expand WORD, then translate
578 the redirection into a new one and continue. */
579 redirectee_word = redirection_expand (redirectee);
581 if (redirectee_word == 0)
582 return (AMBIGUOUS_REDIRECT);
583 else if (redirectee_word[0] == '-' && redirectee_word[1] == '\0')
586 new_redirect = make_redirection (redirector, r_close_this, rd);
588 else if (all_digits (redirectee_word))
590 if (legal_number (redirectee_word, &lfd) && (int)lfd == lfd)
593 rd.dest = -1; /* XXX */
594 new_redirect = make_redirection (redirector,
595 (ri == r_duplicating_input_word
596 ? r_duplicating_input
597 : r_duplicating_output),
600 else if (ri == r_duplicating_output_word && redirector == 1)
602 rd.filename = make_bare_word (redirectee_word);
603 new_redirect = make_redirection (1, r_err_and_out, rd);
607 free (redirectee_word);
608 return (AMBIGUOUS_REDIRECT);
611 free (redirectee_word);
613 /* Set up the variables needed by the rest of the function from the
615 if (new_redirect->instruction == r_err_and_out)
619 /* Copy the word without allocating any memory that must be
621 redirectee = (WORD_DESC *)alloca (sizeof (WORD_DESC));
622 xbcopy ((char *)new_redirect->redirectee.filename,
623 (char *)redirectee, sizeof (WORD_DESC));
625 alloca_hack = (char *)
626 alloca (1 + strlen (new_redirect->redirectee.filename->word));
627 redirectee->word = alloca_hack;
628 strcpy (redirectee->word, new_redirect->redirectee.filename->word);
631 /* It's guaranteed to be an integer, and shouldn't be freed. */
632 redirectee = new_redirect->redirectee.filename;
634 redir_fd = new_redirect->redirectee.dest;
635 redirector = new_redirect->redirector;
636 ri = new_redirect->instruction;
638 /* Overwrite the flags element of the old redirect with the new value. */
639 redirect->flags = new_redirect->flags;
640 dispose_redirects (new_redirect);
645 case r_output_direction:
647 case r_input_direction:
648 case r_inputa_direction:
649 case r_err_and_out: /* command &>filename */
652 if (posixly_correct && interactive_shell == 0)
654 oflags = redirectee->flags;
655 redirectee->flags |= W_NOGLOB;
657 redirectee_word = redirection_expand (redirectee);
658 if (posixly_correct && interactive_shell == 0)
659 redirectee->flags = oflags;
661 if (redirectee_word == 0)
662 return (AMBIGUOUS_REDIRECT);
664 #if defined (RESTRICTED_SHELL)
665 if (restricted && (WRITE_REDIRECT (ri)))
667 free (redirectee_word);
668 return (RESTRICTED_REDIRECT);
670 #endif /* RESTRICTED_SHELL */
672 fd = redir_open (redirectee_word, redirect->flags, 0666, ri);
673 free (redirectee_word);
675 if (fd == NOCLOBBER_REDIRECT)
685 /* Only setup to undo it if the thing to undo is active. */
686 if ((fd != redirector) && (fcntl (redirector, F_GETFD, 0) != -1))
687 add_undo_redirect (redirector);
689 add_undo_close_redirect (redirector);
692 #if defined (BUFFERED_INPUT)
693 check_bash_input (redirector);
696 if ((fd != redirector) && (dup2 (fd, redirector) < 0))
699 #if defined (BUFFERED_INPUT)
700 /* Do not change the buffered stream for an implicit redirection
701 of /dev/null to fd 0 for asynchronous commands without job
702 control (r_inputa_direction). */
703 if (ri == r_input_direction || ri == r_input_output)
704 duplicate_buffered_stream (fd, redirector);
705 #endif /* BUFFERED_INPUT */
708 * If we're remembering, then this is the result of a while, for
709 * or until loop with a loop redirection, or a function/builtin
710 * executing in the parent shell with a redirection. In the
711 * function/builtin case, we want to set all file descriptors > 2
712 * to be close-on-exec to duplicate the effect of the old
713 * for i = 3 to NOFILE close(i) loop. In the case of the loops,
714 * both sh and ksh leave the file descriptors open across execs.
715 * The Posix standard mentions only the exec builtin.
717 if (set_clexec && (redirector > 2))
718 SET_CLOSE_ON_EXEC (redirector);
721 if (fd != redirector)
723 #if defined (BUFFERED_INPUT)
724 if (INPUT_REDIRECT (ri))
725 close_buffered_fd (fd);
727 #endif /* !BUFFERED_INPUT */
728 close (fd); /* Don't close what we just opened! */
731 /* If we are hacking both stdout and stderr, do the stderr
733 if (ri == r_err_and_out)
738 add_undo_redirect (2);
745 case r_reading_until:
746 case r_deblank_reading_until:
747 /* REDIRECTEE is a pointer to a WORD_DESC containing the text of
748 the new input. Place it in a temporary file. */
751 fd = here_document_to_fd (redirectee);
755 heredoc_errno = errno;
756 return (HEREDOC_REDIRECT);
763 /* Only setup to undo it if the thing to undo is active. */
764 if ((fd != redirector) && (fcntl (redirector, F_GETFD, 0) != -1))
765 add_undo_redirect (redirector);
767 add_undo_close_redirect (redirector);
770 #if defined (BUFFERED_INPUT)
771 check_bash_input (redirector);
773 if (fd != redirector && dup2 (fd, redirector) < 0)
780 #if defined (BUFFERED_INPUT)
781 duplicate_buffered_stream (fd, redirector);
784 if (set_clexec && (redirector > 2))
785 SET_CLOSE_ON_EXEC (redirector);
788 if (fd != redirector)
789 #if defined (BUFFERED_INPUT)
790 close_buffered_fd (fd);
797 case r_duplicating_input:
798 case r_duplicating_output:
799 if (for_real && (redir_fd != redirector))
803 /* Only setup to undo it if the thing to undo is active. */
804 if (fcntl (redirector, F_GETFD, 0) != -1)
805 add_undo_redirect (redirector);
807 add_undo_close_redirect (redirector);
810 #if defined (BUFFERED_INPUT)
811 check_bash_input (redirector);
813 /* This is correct. 2>&1 means dup2 (1, 2); */
814 if (dup2 (redir_fd, redirector) < 0)
817 #if defined (BUFFERED_INPUT)
818 if (ri == r_duplicating_input)
819 duplicate_buffered_stream (redir_fd, redirector);
820 #endif /* BUFFERED_INPUT */
822 /* First duplicate the close-on-exec state of redirectee. dup2
823 leaves the flag unset on the new descriptor, which means it
824 stays open. Only set the close-on-exec bit for file descriptors
825 greater than 2 in any case, since 0-2 should always be open
826 unless closed by something like `exec 2<&-'. */
827 /* if ((already_set || set_unconditionally) && (ok_to_set))
829 if (((fcntl (redir_fd, F_GETFD, 0) == 1) || set_clexec) &&
831 SET_CLOSE_ON_EXEC (redirector);
838 if (remembering && (fcntl (redirector, F_GETFD, 0) != -1))
839 add_undo_redirect (redirector);
841 #if defined (BUFFERED_INPUT)
842 check_bash_input (redirector);
843 close_buffered_fd (redirector);
844 #else /* !BUFFERED_INPUT */
846 #endif /* !BUFFERED_INPUT */
850 case r_duplicating_input_word:
851 case r_duplicating_output_word:
857 #define SHELL_FD_BASE 10
859 /* Remember the file descriptor associated with the slot FD,
860 on REDIRECTION_UNDO_LIST. Note that the list will be reversed
861 before it is executed. Any redirections that need to be undone
862 even if REDIRECTION_UNDO_LIST is discarded by the exec builtin
863 are also saved on EXEC_REDIRECTION_UNDO_LIST. */
865 add_undo_redirect (fd)
868 int new_fd, clexec_flag;
869 REDIRECT *new_redirect, *closer, *dummy_redirect;
871 new_fd = fcntl (fd, F_DUPFD, SHELL_FD_BASE);
875 sys_error ("redirection error: cannot duplicate fd");
879 clexec_flag = fcntl (fd, F_GETFD, 0);
882 closer = make_redirection (new_fd, r_close_this, rd);
883 dummy_redirect = copy_redirects (closer);
887 new_redirect = make_redirection (fd, r_duplicating_input, rd);
889 new_redirect = make_redirection (fd, r_duplicating_output, rd);
890 new_redirect->next = closer;
892 closer->next = redirection_undo_list;
893 redirection_undo_list = new_redirect;
895 /* Save redirections that need to be undone even if the undo list
896 is thrown away by the `exec' builtin. */
897 add_exec_redirect (dummy_redirect);
899 /* File descriptors used only for saving others should always be
900 marked close-on-exec. Unfortunately, we have to preserve the
901 close-on-exec state of the file descriptor we are saving, since
902 fcntl (F_DUPFD) sets the new file descriptor to remain open
903 across execs. If, however, the file descriptor whose state we
904 are saving is <= 2, we can just set the close-on-exec flag,
905 because file descriptors 0-2 should always be open-on-exec,
906 and the restore above in do_redirection() will take care of it. */
907 if (clexec_flag || fd < 3)
908 SET_CLOSE_ON_EXEC (new_fd);
913 /* Set up to close FD when we are finished with the current command
914 and its redirections. */
916 add_undo_close_redirect (fd)
922 closer = make_redirection (fd, r_close_this, rd);
923 closer->next = redirection_undo_list;
924 redirection_undo_list = closer;
928 add_exec_redirect (dummy_redirect)
929 REDIRECT *dummy_redirect;
931 dummy_redirect->next = exec_redirection_undo_list;
932 exec_redirection_undo_list = dummy_redirect;
935 /* Return 1 if the redirection specified by RI and REDIRECTOR alters the
938 stdin_redirection (ri, redirector)
939 enum r_instruction ri;
944 case r_input_direction:
945 case r_inputa_direction:
947 case r_reading_until:
948 case r_deblank_reading_until:
950 case r_duplicating_input:
951 case r_duplicating_input_word:
953 return (redirector == 0);
954 case r_output_direction:
956 case r_duplicating_output:
959 case r_duplicating_output_word:
965 /* Return non-zero if any of the redirections in REDIRS alter the standard
968 stdin_redirects (redirs)
974 for (n = 0, rp = redirs; rp; rp = rp->next)
975 n += stdin_redirection (rp->instruction, rp->redirector);