redir.c

   1 /* redir.c -- Functions to perform input and output redirection. */
   2
   3 /* Copyright (C) 1997-2002 Free Software Foundation, Inc.
   4
   5    This file is part of GNU Bash, the Bourne Again SHell.
   6
   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)
  10    any later version.
  11
  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.
  16
  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. */
  20 #include "config.h"
  21
  22 #if !defined (__GNUC__) && !defined (HAVE_ALLOCA_H) && defined (_AIX)
  23   #pragma alloca
  24 #endif /* _AIX && RISC6000 && !__GNUC__ */
  25
  26 #include <stdio.h>
  27 #include "bashtypes.h"
  28 #if !defined (_MINIX) && defined (HAVE_SYS_FILE_H)
  29 #  include <sys/file.h>
  30 #endif
  31 #include "filecntl.h"
  32 #include "posixstat.h"
  33
  34 #if defined (HAVE_UNISTD_H)
  35 #  include <unistd.h>
  36 #endif
  37
  38 #include <errno.h>
  39
  40 #if !defined (errno)
  41 extern int errno;
  42 #endif
  43
  44 #include "bashansi.h"
  45 #include "bashintl.h"
  46
  47 #include "memalloc.h"
  48 #include "shell.h"
  49 #include "flags.h"
  50 #include "execute_cmd.h"
  51 #include "redir.h"
  52
  53 #if defined (BUFFERED_INPUT)
  54 #  include "input.h"
  55 #endif
  56
  57 int expanding_redir;
  58
  59 extern int posixly_correct;
  60 extern REDIRECT *redirection_undo_list;
  61 extern REDIRECT *exec_redirection_undo_list;
  62
  63 /* Static functions defined and used in this file. */
  64 static void add_undo_close_redirect __P((int));
  65 static void add_exec_redirect __P((REDIRECT *));
  66 static int add_undo_redirect __P((int));
  67 static int expandable_redirection_filename __P((REDIRECT *));
  68 static int stdin_redirection __P((enum r_instruction, int));
  69 static int do_redirection_internal __P((REDIRECT *, int));
  70
  71 static int write_here_document __P((int, WORD_DESC *));
  72 static int write_here_string __P((int, WORD_DESC *));
  73 static int here_document_to_fd __P((WORD_DESC *, enum r_instruction));
  74
  75 static int redir_special_open __P((int, char *, int, int, enum r_instruction));
  76 static int noclobber_open __P((char *, int, int, enum r_instruction));
  77 static int redir_open __P((char *, int, int, enum r_instruction));
  78
  79 /* Spare redirector used when translating [N]>&WORD[-] or [N]<&WORD[-] to
  80    a new redirection and when creating the redirection undo list. */
  81 static REDIRECTEE rd;
  82
  83 /* Set to errno when a here document cannot be created for some reason.
  84    Used to print a reasonable error message. */
  85 static int heredoc_errno;
  86
  87 void
  88 redirection_error (temp, error)
  89      REDIRECT *temp;
  90      int error;
  91 {
  92   char *filename, *allocname;
  93   int oflags;
  94
  95   allocname = 0;
  96   if (temp->redirector < 0)
  97     /* This can happen when read_token_word encounters overflow, like in
  98        exec 4294967297>x */
  99     filename = _("file descriptor out of range");
 100 #ifdef EBADF
 101   else if (temp->redirector >= 0 && errno == EBADF)
 102     {
 103       /* If we're dealing with two file descriptors, we have to guess about
 104          which one is invalid; in the cases of r_{duplicating,move}_input and
 105          r_{duplicating,move}_output we're here because dup2() failed. */
 106       switch (temp->instruction)
 107         {
 108         case r_duplicating_input:
 109         case r_duplicating_output:
 110         case r_move_input:
 111         case r_move_output:
 112           filename = allocname = itos (temp->redirectee.dest);
 113           break;
 114         default:
 115           filename = allocname = itos (temp->redirector);
 116           break;
 117         }
 118     }
 119 #endif
 120   else if (expandable_redirection_filename (temp))
 121     {
 122       if (posixly_correct && interactive_shell == 0)
 123         {
 124           oflags = temp->redirectee.filename->flags;
 125           temp->redirectee.filename->flags |= W_NOGLOB;
 126         }
 127       filename = allocname = redirection_expand (temp->redirectee.filename);
 128       if (posixly_correct && interactive_shell == 0)
 129         temp->redirectee.filename->flags = oflags;
 130       if (filename == 0)
 131         filename = temp->redirectee.filename->word;
 132     }
 133   else if (temp->redirectee.dest < 0)
 134     filename = "file descriptor out of range";
 135   else
 136     filename = allocname = itos (temp->redirectee.dest);
 137
 138   switch (error)
 139     {
 140     case AMBIGUOUS_REDIRECT:
 141       internal_error (_("%s: ambiguous redirect"), filename);
 142       break;
 143
 144     case NOCLOBBER_REDIRECT:
 145       internal_error (_("%s: cannot overwrite existing file"), filename);
 146       break;
 147
 148 #if defined (RESTRICTED_SHELL)
 149     case RESTRICTED_REDIRECT:
 150       internal_error (_("%s: restricted: cannot redirect output"), filename);
 151       break;
 152 #endif /* RESTRICTED_SHELL */
 153
 154     case HEREDOC_REDIRECT:
 155       internal_error (_("cannot create temp file for here document: %s"), strerror (heredoc_errno));
 156       break;
 157
 158     default:
 159       internal_error ("%s: %s", filename, strerror (error));
 160       break;
 161     }
 162
 163   FREE (allocname);
 164 }
 165
 166 /* Perform the redirections on LIST.  If flags & RX_ACTIVE, then actually
 167    make input and output file descriptors, otherwise just do whatever is
 168    neccessary for side effecting.  flags & RX_UNDOABLE says to remember
 169    how to undo the redirections later, if non-zero.  If flags & RX_CLEXEC
 170    is non-zero, file descriptors opened in do_redirection () have their
 171    close-on-exec flag set. */
 172 int
 173 do_redirections (list, flags)
 174      REDIRECT *list;
 175      int flags;
 176 {
 177   int error;
 178   REDIRECT *temp;
 179
 180   if (flags & RX_UNDOABLE)
 181     {
 182       if (redirection_undo_list)
 183         {
 184           dispose_redirects (redirection_undo_list);
 185           redirection_undo_list = (REDIRECT *)NULL;
 186         }
 187       if (exec_redirection_undo_list)
 188         dispose_exec_redirects ();
 189     }
 190
 191   for (temp = list; temp; temp = temp->next)
 192     {
 193       error = do_redirection_internal (temp, flags);
 194       if (error)
 195         {
 196           redirection_error (temp, error);
 197           return (error);
 198         }
 199     }
 200   return (0);
 201 }
 202
 203 /* Return non-zero if the redirection pointed to by REDIRECT has a
 204    redirectee.filename that can be expanded. */
 205 static int
 206 expandable_redirection_filename (redirect)
 207      REDIRECT *redirect;
 208 {
 209   switch (redirect->instruction)
 210     {
 211     case r_output_direction:
 212     case r_appending_to:
 213     case r_input_direction:
 214     case r_inputa_direction:
 215     case r_err_and_out:
 216     case r_input_output:
 217     case r_output_force:
 218     case r_duplicating_input_word:
 219     case r_duplicating_output_word:
 220     case r_move_input_word:
 221     case r_move_output_word:
 222       return 1;
 223
 224     default:
 225       return 0;
 226     }
 227 }
 228
 229 /* Expand the word in WORD returning a string.  If WORD expands to
 230    multiple words (or no words), then return NULL. */
 231 char *
 232 redirection_expand (word)
 233      WORD_DESC *word;
 234 {
 235   char *result;
 236   WORD_LIST *tlist1, *tlist2;
 237   WORD_DESC *w;
 238
 239   w = copy_word (word);
 240   if (posixly_correct)
 241     w->flags |= W_NOSPLIT;
 242
 243   tlist1 = make_word_list (w, (WORD_LIST *)NULL);
 244   expanding_redir = 1;
 245   tlist2 = expand_words_no_vars (tlist1);
 246   expanding_redir = 0;
 247   dispose_words (tlist1);
 248
 249   if (!tlist2 || tlist2->next)
 250     {
 251       /* We expanded to no words, or to more than a single word.
 252          Dispose of the word list and return NULL. */
 253       if (tlist2)
 254         dispose_words (tlist2);
 255       return ((char *)NULL);
 256     }
 257   result = string_list (tlist2);  /* XXX savestring (tlist2->word->word)? */
 258   dispose_words (tlist2);
 259   return (result);
 260 }
 261
 262 static int
 263 write_here_string (fd, redirectee)
 264      int fd;
 265      WORD_DESC *redirectee;
 266 {
 267   char *herestr;
 268   int herelen, n, e;
 269
 270   herestr = expand_string_to_string (redirectee->word, 0);
 271   herelen = STRLEN (herestr);
 272
 273   n = write (fd, herestr, herelen);
 274   if (n == herelen)
 275     {
 276       n = write (fd, "\n", 1);
 277       herelen = 1;
 278     }
 279   e = errno;
 280   FREE (herestr);
 281   if (n != herelen)
 282     {
 283       if (e == 0)
 284         e = ENOSPC;
 285       return e;
 286     }
 287   return 0;
 288 }
 289
 290 /* Write the text of the here document pointed to by REDIRECTEE to the file
 291    descriptor FD, which is already open to a temp file.  Return 0 if the
 292    write is successful, otherwise return errno. */
 293 static int
 294 write_here_document (fd, redirectee)
 295      int fd;
 296      WORD_DESC *redirectee;
 297 {
 298   char *document;
 299   int document_len, fd2;
 300   FILE *fp;
 301   register WORD_LIST *t, *tlist;
 302
 303   /* Expand the text if the word that was specified had
 304      no quoting.  The text that we expand is treated
 305      exactly as if it were surrounded by double quotes. */
 306
 307   if (redirectee->flags & W_QUOTED)
 308     {
 309       document = redirectee->word;
 310       document_len = strlen (document);
 311       /* Set errno to something reasonable if the write fails. */
 312       if (write (fd, document, document_len) < document_len)
 313         {
 314           if (errno == 0)
 315             errno = ENOSPC;
 316           return (errno);
 317         }
 318       else
 319         return 0;
 320     }
 321
 322   tlist = expand_string (redirectee->word, Q_HERE_DOCUMENT);
 323   if (tlist)
 324     {
 325       /* Try using buffered I/O (stdio) and writing a word
 326          at a time, letting stdio do the work of buffering
 327          for us rather than managing our own strings.  Most
 328          stdios are not particularly fast, however -- this
 329          may need to be reconsidered later. */
 330       if ((fd2 = dup (fd)) < 0 || (fp = fdopen (fd2, "w")) == NULL)
 331         {
 332           if (fd2 >= 0)
 333             close (fd2);
 334           return (errno);
 335         }
 336       errno = 0;
 337       for (t = tlist; t; t = t->next)
 338         {
 339           /* This is essentially the body of
 340              string_list_internal expanded inline. */
 341           document = t->word->word;
 342           document_len = strlen (document);
 343           if (t != tlist)
 344             putc (' ', fp);     /* separator */
 345           fwrite (document, document_len, 1, fp);
 346           if (ferror (fp))
 347             {
 348               if (errno == 0)
 349                 errno = ENOSPC;
 350               fd2 = errno;
 351               fclose(fp);
 352               dispose_words (tlist);
 353               return (fd2);
 354             }
 355         }
 356       dispose_words (tlist);
 357       if (fclose (fp) != 0)
 358         {
 359           if (errno == 0)
 360             errno = ENOSPC;
 361           return (errno);
 362         }
 363     }
 364   return 0;
 365 }
 366
 367 /* Create a temporary file holding the text of the here document pointed to
 368    by REDIRECTEE, and return a file descriptor open for reading to the temp
 369    file.  Return -1 on any error, and make sure errno is set appropriately. */
 370 static int
 371 here_document_to_fd (redirectee, ri)
 372      WORD_DESC *redirectee;
 373      enum r_instruction ri;
 374 {
 375   char *filename;
 376   int r, fd, fd2;
 377
 378   fd = sh_mktmpfd ("sh-thd", MT_USERANDOM, &filename);
 379
 380   /* If we failed for some reason other than the file existing, abort */
 381   if (fd < 0)
 382     {
 383       FREE (filename);
 384       return (fd);
 385     }
 386
 387   errno = r = 0;                /* XXX */
 388   /* write_here_document returns 0 on success, errno on failure. */
 389   if (redirectee->word)
 390     r = (ri != r_reading_string) ? write_here_document (fd, redirectee)
 391                                  : write_here_string (fd, redirectee);
 392
 393   if (r)
 394     {
 395       close (fd);
 396       unlink (filename);
 397       free (filename);
 398       errno = r;
 399       return (-1);
 400     }
 401
 402   /* In an attempt to avoid races, we close the first fd only after opening
 403      the second. */
 404   /* Make the document really temporary.  Also make it the input. */
 405   fd2 = open (filename, O_RDONLY, 0600);
 406
 407   if (fd2 < 0)
 408     {
 409       r = errno;
 410       unlink (filename);
 411       free (filename);
 412       close (fd);
 413       errno = r;
 414       return -1;
 415     }
 416
 417   close (fd);
 418   if (unlink (filename) < 0)
 419     {
 420       r = errno;
 421 #if defined (__CYGWIN__)
 422       /* Under CygWin 1.1.0, the unlink will fail if the file is
 423          open. This hack will allow the previous action of silently
 424          ignoring the error, but will still leave the file there. This
 425          needs some kind of magic. */
 426       if (r == EACCES)
 427         return (fd2);
 428 #endif /* __CYGWIN__ */
 429       close (fd2);
 430       free (filename);
 431       errno = r;
 432       return (-1);
 433     }
 434
 435   free (filename);
 436   return (fd2);
 437 }
 438
 439 #define RF_DEVFD        1
 440 #define RF_DEVSTDERR    2
 441 #define RF_DEVSTDIN     3
 442 #define RF_DEVSTDOUT    4
 443 #define RF_DEVTCP       5
 444 #define RF_DEVUDP       6
 445
 446 /* A list of pattern/value pairs for filenames that the redirection
 447    code handles specially. */
 448 static STRING_INT_ALIST _redir_special_filenames[] = {
 449 #if !defined (HAVE_DEV_FD)
 450   { "/dev/fd/[0-9]*", RF_DEVFD },
 451 #endif
 452 #if !defined (HAVE_DEV_STDIN)
 453   { "/dev/stderr", RF_DEVSTDERR },
 454   { "/dev/stdin", RF_DEVSTDIN },
 455   { "/dev/stdout", RF_DEVSTDOUT },
 456 #endif
 457 #if defined (NETWORK_REDIRECTIONS)
 458   { "/dev/tcp/*/*", RF_DEVTCP },
 459   { "/dev/udp/*/*", RF_DEVUDP },
 460 #endif
 461   { (char *)NULL, -1 }
 462 };
 463
 464 static int
 465 redir_special_open (spec, filename, flags, mode, ri)
 466      int spec;
 467      char *filename;
 468      int flags, mode;
 469      enum r_instruction ri;
 470 {
 471   int fd;
 472 #if !defined (HAVE_DEV_FD)
 473   intmax_t lfd;
 474 #endif
 475
 476   fd = -1;
 477   switch (spec)
 478     {
 479 #if !defined (HAVE_DEV_FD)
 480     case RF_DEVFD:
 481       if (all_digits (filename+8) && legal_number (filename+8, &lfd) && lfd == (int)lfd)
 482         {
 483           fd = lfd;
 484           fd = fcntl (fd, F_DUPFD, 10);
 485         }
 486       else
 487         fd = AMBIGUOUS_REDIRECT;
 488       break;
 489 #endif
 490
 491 #if !defined (HAVE_DEV_STDIN)
 492     case RF_DEVSTDIN:
 493       fd = fcntl (0, F_DUPFD, 10);
 494       break;
 495     case RF_DEVSTDOUT:
 496       fd = fcntl (1, F_DUPFD, 10);
 497       break;
 498     case RF_DEVSTDERR:
 499       fd = fcntl (2, F_DUPFD, 10);
 500       break;
 501 #endif
 502
 503 #if defined (NETWORK_REDIRECTIONS)
 504     case RF_DEVTCP:
 505     case RF_DEVUDP:
 506 #if defined (HAVE_NETWORK)
 507       fd = netopen (filename);
 508 #else
 509       internal_warning (_("/dev/(tcp|udp)/host/port not supported without networking"));
 510       fd = open (filename, flags, mode);
 511 #endif
 512       break;
 513 #endif /* NETWORK_REDIRECTIONS */
 514     }
 515
 516   return fd;
 517 }
 518
 519 /* Open FILENAME with FLAGS in noclobber mode, hopefully avoiding most
 520    race conditions and avoiding the problem where the file is replaced
 521    between the stat(2) and open(2). */
 522 static int
 523 noclobber_open (filename, flags, mode, ri)
 524      char *filename;
 525      int flags, mode;
 526      enum r_instruction ri;
 527 {
 528   int r, fd;
 529   struct stat finfo, finfo2;
 530
 531   /* If the file exists and is a regular file, return an error
 532      immediately. */
 533   r = stat (filename, &finfo);
 534   if (r == 0 && (S_ISREG (finfo.st_mode)))
 535     return (NOCLOBBER_REDIRECT);
 536
 537   /* If the file was not present (r != 0), make sure we open it
 538      exclusively so that if it is created before we open it, our open
 539      will fail.  Make sure that we do not truncate an existing file.
 540      Note that we don't turn on O_EXCL unless the stat failed -- if
 541      the file was not a regular file, we leave O_EXCL off. */
 542   flags &= ~O_TRUNC;
 543   if (r != 0)
 544     {
 545       fd = open (filename, flags|O_EXCL, mode);
 546       return ((fd < 0 && errno == EEXIST) ? NOCLOBBER_REDIRECT : fd);
 547     }
 548   fd = open (filename, flags, mode);
 549
 550   /* If the open failed, return the file descriptor right away. */
 551   if (fd < 0)
 552     return (errno == EEXIST ? NOCLOBBER_REDIRECT : fd);
 553
 554   /* OK, the open succeeded, but the file may have been changed from a
 555      non-regular file to a regular file between the stat and the open.
 556      We are assuming that the O_EXCL open handles the case where FILENAME
 557      did not exist and is symlinked to an existing file between the stat
 558      and open. */
 559
 560   /* If we can open it and fstat the file descriptor, and neither check
 561      revealed that it was a regular file, and the file has not been replaced,
 562      return the file descriptor. */
 563   if ((fstat (fd, &finfo2) == 0) && (S_ISREG (finfo2.st_mode) == 0) &&
 564       r == 0 && (S_ISREG (finfo.st_mode) == 0) &&
 565       same_file (filename, filename, &finfo, &finfo2))
 566     return fd;
 567
 568   /* The file has been replaced.  badness. */
 569   close (fd);
 570   errno = EEXIST;
 571   return (NOCLOBBER_REDIRECT);
 572 }
 573
 574 static int
 575 redir_open (filename, flags, mode, ri)
 576      char *filename;
 577      int flags, mode;
 578      enum r_instruction ri;
 579 {
 580   int fd, r;
 581
 582   r = find_string_in_alist (filename, _redir_special_filenames, 1);
 583   if (r >= 0)
 584     return (redir_special_open (r, filename, flags, mode, ri));
 585
 586   /* If we are in noclobber mode, you are not allowed to overwrite
 587      existing files.  Check before opening. */
 588   if (noclobber && CLOBBERING_REDIRECT (ri))
 589     {
 590       fd = noclobber_open (filename, flags, mode, ri);
 591       if (fd == NOCLOBBER_REDIRECT)
 592         return (NOCLOBBER_REDIRECT);
 593     }
 594   else
 595     {
 596       fd = open (filename, flags, mode);
 597 #if defined (AFS)
 598       if ((fd < 0) && (errno == EACCES))
 599         fd = open (filename, flags & ~O_CREAT, mode);
 600 #endif /* AFS */
 601     }
 602
 603   return fd;
 604 }
 605
 606 /* Do the specific redirection requested.  Returns errno or one of the
 607    special redirection errors (*_REDIRECT) in case of error, 0 on success.
 608    If flags & RX_ACTIVE is zero, then just do whatever is neccessary to
 609    produce the appropriate side effects.   flags & RX_UNDOABLE, if non-zero,
 610    says to remember how to undo each redirection.  If flags & RX_CLEXEC is
 611    non-zero, then we set all file descriptors > 2 that we open to be
 612    close-on-exec.  */
 613 static int
 614 do_redirection_internal (redirect, flags)
 615      REDIRECT *redirect;
 616      int flags;
 617 {
 618   WORD_DESC *redirectee;
 619   int redir_fd, fd, redirector, r, oflags;
 620   intmax_t lfd;
 621   char *redirectee_word;
 622   enum r_instruction ri;
 623   REDIRECT *new_redirect;
 624
 625   redirectee = redirect->redirectee.filename;
 626   redir_fd = redirect->redirectee.dest;
 627   redirector = redirect->redirector;
 628   ri = redirect->instruction;
 629
 630   if (TRANSLATE_REDIRECT (ri))
 631     {
 632       /* We have [N]>&WORD[-] or [N]<&WORD[-].  Expand WORD, then translate
 633          the redirection into a new one and continue. */
 634       redirectee_word = redirection_expand (redirectee);
 635
 636       /* XXX - what to do with [N]<&$w- where w is unset or null?  ksh93
 637                closes N. */
 638       if (redirectee_word == 0)
 639         return (AMBIGUOUS_REDIRECT);
 640       else if (redirectee_word[0] == '-' && redirectee_word[1] == '\0')
 641         {
 642           rd.dest = 0;
 643           new_redirect = make_redirection (redirector, r_close_this, rd);
 644         }
 645       else if (all_digits (redirectee_word))
 646         {
 647           if (legal_number (redirectee_word, &lfd) && (int)lfd == lfd)
 648             rd.dest = lfd;
 649           else
 650             rd.dest = -1;       /* XXX */
 651           switch (ri)
 652             {
 653             case r_duplicating_input_word:
 654               new_redirect = make_redirection (redirector, r_duplicating_input, rd);
 655               break;
 656             case r_duplicating_output_word:
 657               new_redirect = make_redirection (redirector, r_duplicating_output, rd);
 658               break;
 659             case r_move_input_word:
 660               new_redirect = make_redirection (redirector, r_move_input, rd);
 661               break;
 662             case r_move_output_word:
 663               new_redirect = make_redirection (redirector, r_move_output, rd);
 664               break;
 665             }
 666         }
 667       else if (ri == r_duplicating_output_word && redirector == 1)
 668         {
 669           rd.filename = make_bare_word (redirectee_word);
 670           new_redirect = make_redirection (1, r_err_and_out, rd);
 671         }
 672       else
 673         {
 674           free (redirectee_word);
 675           return (AMBIGUOUS_REDIRECT);
 676         }
 677
 678       free (redirectee_word);
 679
 680       /* Set up the variables needed by the rest of the function from the
 681          new redirection. */
 682       if (new_redirect->instruction == r_err_and_out)
 683         {
 684           char *alloca_hack;
 685
 686           /* Copy the word without allocating any memory that must be
 687              explicitly freed. */
 688           redirectee = (WORD_DESC *)alloca (sizeof (WORD_DESC));
 689           xbcopy ((char *)new_redirect->redirectee.filename,
 690                  (char *)redirectee, sizeof (WORD_DESC));
 691
 692           alloca_hack = (char *)
 693             alloca (1 + strlen (new_redirect->redirectee.filename->word));
 694           redirectee->word = alloca_hack;
 695           strcpy (redirectee->word, new_redirect->redirectee.filename->word);
 696         }
 697       else
 698         /* It's guaranteed to be an integer, and shouldn't be freed. */
 699         redirectee = new_redirect->redirectee.filename;
 700
 701       redir_fd = new_redirect->redirectee.dest;
 702       redirector = new_redirect->redirector;
 703       ri = new_redirect->instruction;
 704
 705       /* Overwrite the flags element of the old redirect with the new value. */
 706       redirect->flags = new_redirect->flags;
 707       dispose_redirects (new_redirect);
 708     }
 709
 710   switch (ri)
 711     {
 712     case r_output_direction:
 713     case r_appending_to:
 714     case r_input_direction:
 715     case r_inputa_direction:
 716     case r_err_and_out:         /* command &>filename */
 717     case r_input_output:
 718     case r_output_force:
 719       if (posixly_correct && interactive_shell == 0)
 720         {
 721           oflags = redirectee->flags;
 722           redirectee->flags |= W_NOGLOB;
 723         }
 724       redirectee_word = redirection_expand (redirectee);
 725       if (posixly_correct && interactive_shell == 0)
 726         redirectee->flags = oflags;
 727
 728       if (redirectee_word == 0)
 729         return (AMBIGUOUS_REDIRECT);
 730
 731 #if defined (RESTRICTED_SHELL)
 732       if (restricted && (WRITE_REDIRECT (ri)))
 733         {
 734           free (redirectee_word);
 735           return (RESTRICTED_REDIRECT);
 736         }
 737 #endif /* RESTRICTED_SHELL */
 738
 739       fd = redir_open (redirectee_word, redirect->flags, 0666, ri);
 740       free (redirectee_word);
 741
 742       if (fd == NOCLOBBER_REDIRECT)
 743         return (fd);
 744
 745       if (fd < 0)
 746         return (errno);
 747
 748       if (flags & RX_ACTIVE)
 749         {
 750           if (flags & RX_UNDOABLE)
 751             {
 752               /* Only setup to undo it if the thing to undo is active. */
 753               if ((fd != redirector) && (fcntl (redirector, F_GETFD, 0) != -1))
 754                 add_undo_redirect (redirector);
 755               else
 756                 add_undo_close_redirect (redirector);
 757             }
 758
 759 #if defined (BUFFERED_INPUT)
 760           check_bash_input (redirector);
 761 #endif
 762
 763           if ((fd != redirector) && (dup2 (fd, redirector) < 0))
 764             return (errno);
 765
 766 #if defined (BUFFERED_INPUT)
 767           /* Do not change the buffered stream for an implicit redirection
 768              of /dev/null to fd 0 for asynchronous commands without job
 769              control (r_inputa_direction). */
 770           if (ri == r_input_direction || ri == r_input_output)
 771             duplicate_buffered_stream (fd, redirector);
 772 #endif /* BUFFERED_INPUT */
 773
 774           /*
 775            * If we're remembering, then this is the result of a while, for
 776            * or until loop with a loop redirection, or a function/builtin
 777            * executing in the parent shell with a redirection.  In the
 778            * function/builtin case, we want to set all file descriptors > 2
 779            * to be close-on-exec to duplicate the effect of the old
 780            * for i = 3 to NOFILE close(i) loop.  In the case of the loops,
 781            * both sh and ksh leave the file descriptors open across execs.
 782            * The Posix standard mentions only the exec builtin.
 783            */
 784           if ((flags & RX_CLEXEC) && (redirector > 2))
 785             SET_CLOSE_ON_EXEC (redirector);
 786         }
 787
 788       if (fd != redirector)
 789         {
 790 #if defined (BUFFERED_INPUT)
 791           if (INPUT_REDIRECT (ri))
 792             close_buffered_fd (fd);
 793           else
 794 #endif /* !BUFFERED_INPUT */
 795             close (fd);         /* Don't close what we just opened! */
 796         }
 797
 798       /* If we are hacking both stdout and stderr, do the stderr
 799          redirection here. */
 800       if (ri == r_err_and_out)
 801         {
 802           if (flags & RX_ACTIVE)
 803             {
 804               if (flags & RX_UNDOABLE)
 805                 add_undo_redirect (2);
 806               if (dup2 (1, 2) < 0)
 807                 return (errno);
 808             }
 809         }
 810       break;
 811
 812     case r_reading_until:
 813     case r_deblank_reading_until:
 814     case r_reading_string:
 815       /* REDIRECTEE is a pointer to a WORD_DESC containing the text of
 816          the new input.  Place it in a temporary file. */
 817       if (redirectee)
 818         {
 819           fd = here_document_to_fd (redirectee, ri);
 820
 821           if (fd < 0)
 822             {
 823               heredoc_errno = errno;
 824               return (HEREDOC_REDIRECT);
 825             }
 826
 827           if (flags & RX_ACTIVE)
 828             {
 829               if (flags & RX_UNDOABLE)
 830                 {
 831                   /* Only setup to undo it if the thing to undo is active. */
 832                   if ((fd != redirector) && (fcntl (redirector, F_GETFD, 0) != -1))
 833                     add_undo_redirect (redirector);
 834                   else
 835                     add_undo_close_redirect (redirector);
 836                 }
 837
 838 #if defined (BUFFERED_INPUT)
 839               check_bash_input (redirector);
 840 #endif
 841               if (fd != redirector && dup2 (fd, redirector) < 0)
 842                 {
 843                   r = errno;
 844                   close (fd);
 845                   return (r);
 846                 }
 847
 848 #if defined (BUFFERED_INPUT)
 849               duplicate_buffered_stream (fd, redirector);
 850 #endif
 851
 852               if ((flags & RX_CLEXEC) && (redirector > 2))
 853                 SET_CLOSE_ON_EXEC (redirector);
 854             }
 855
 856           if (fd != redirector)
 857 #if defined (BUFFERED_INPUT)
 858             close_buffered_fd (fd);
 859 #else
 860             close (fd);
 861 #endif
 862         }
 863       break;
 864
 865     case r_duplicating_input:
 866     case r_duplicating_output:
 867     case r_move_input:
 868     case r_move_output:
 869       if ((flags & RX_ACTIVE) && (redir_fd != redirector))
 870         {
 871           if (flags & RX_UNDOABLE)
 872             {
 873               /* Only setup to undo it if the thing to undo is active. */
 874               if (fcntl (redirector, F_GETFD, 0) != -1)
 875                 add_undo_redirect (redirector);
 876               else
 877                 add_undo_close_redirect (redirector);
 878             }
 879
 880 #if defined (BUFFERED_INPUT)
 881           check_bash_input (redirector);
 882 #endif
 883           /* This is correct.  2>&1 means dup2 (1, 2); */
 884           if (dup2 (redir_fd, redirector) < 0)
 885             return (errno);
 886
 887 #if defined (BUFFERED_INPUT)
 888           if (ri == r_duplicating_input || ri == r_move_input)
 889             duplicate_buffered_stream (redir_fd, redirector);
 890 #endif /* BUFFERED_INPUT */
 891
 892           /* First duplicate the close-on-exec state of redirectee.  dup2
 893              leaves the flag unset on the new descriptor, which means it
 894              stays open.  Only set the close-on-exec bit for file descriptors
 895              greater than 2 in any case, since 0-2 should always be open
 896              unless closed by something like `exec 2<&-'. */
 897           /* if ((already_set || set_unconditionally) && (ok_to_set))
 898                 set_it () */
 899           if (((fcntl (redir_fd, F_GETFD, 0) == 1) || (flags & RX_CLEXEC)) &&
 900                (redirector > 2))
 901             SET_CLOSE_ON_EXEC (redirector);
 902
 903           /* dup-and-close redirection */
 904           if (ri == r_move_input || ri == r_move_output)
 905             close (redir_fd);
 906         }
 907       break;
 908
 909     case r_close_this:
 910       if (flags & RX_ACTIVE)
 911         {
 912           if ((flags & RX_UNDOABLE) && (fcntl (redirector, F_GETFD, 0) != -1))
 913             add_undo_redirect (redirector);
 914
 915 #if defined (BUFFERED_INPUT)
 916           check_bash_input (redirector);
 917           close_buffered_fd (redirector);
 918 #else /* !BUFFERED_INPUT */
 919           close (redirector);
 920 #endif /* !BUFFERED_INPUT */
 921         }
 922       break;
 923
 924     case r_duplicating_input_word:
 925     case r_duplicating_output_word:
 926       break;
 927     }
 928   return (0);
 929 }
 930
 931 #define SHELL_FD_BASE   10
 932
 933 /* Remember the file descriptor associated with the slot FD,
 934    on REDIRECTION_UNDO_LIST.  Note that the list will be reversed
 935    before it is executed.  Any redirections that need to be undone
 936    even if REDIRECTION_UNDO_LIST is discarded by the exec builtin
 937    are also saved on EXEC_REDIRECTION_UNDO_LIST. */
 938 static int
 939 add_undo_redirect (fd)
 940      int fd;
 941 {
 942   int new_fd, clexec_flag;
 943   REDIRECT *new_redirect, *closer, *dummy_redirect;
 944
 945   new_fd = fcntl (fd, F_DUPFD, SHELL_FD_BASE);
 946
 947   if (new_fd < 0)
 948     {
 949       sys_error (_("redirection error: cannot duplicate fd"));
 950       return (-1);
 951     }
 952
 953   clexec_flag = fcntl (fd, F_GETFD, 0);
 954
 955   rd.dest = 0;
 956   closer = make_redirection (new_fd, r_close_this, rd);
 957   dummy_redirect = copy_redirects (closer);
 958
 959   rd.dest = new_fd;
 960   if (fd == 0)
 961     new_redirect = make_redirection (fd, r_duplicating_input, rd);
 962   else
 963     new_redirect = make_redirection (fd, r_duplicating_output, rd);
 964   new_redirect->next = closer;
 965
 966   closer->next = redirection_undo_list;
 967   redirection_undo_list = new_redirect;
 968
 969   /* Save redirections that need to be undone even if the undo list
 970      is thrown away by the `exec' builtin. */
 971   add_exec_redirect (dummy_redirect);
 972
 973   /* File descriptors used only for saving others should always be
 974      marked close-on-exec.  Unfortunately, we have to preserve the
 975      close-on-exec state of the file descriptor we are saving, since
 976      fcntl (F_DUPFD) sets the new file descriptor to remain open
 977      across execs.  If, however, the file descriptor whose state we
 978      are saving is <= 2, we can just set the close-on-exec flag,
 979      because file descriptors 0-2 should always be open-on-exec,
 980      and the restore above in do_redirection() will take care of it. */
 981   if (clexec_flag || fd < 3)
 982     SET_CLOSE_ON_EXEC (new_fd);
 983
 984   return (0);
 985 }
 986
 987 /* Set up to close FD when we are finished with the current command
 988    and its redirections. */
 989 static void
 990 add_undo_close_redirect (fd)
 991      int fd;
 992 {
 993   REDIRECT *closer;
 994
 995   rd.dest = 0;
 996   closer = make_redirection (fd, r_close_this, rd);
 997   closer->next = redirection_undo_list;
 998   redirection_undo_list = closer;
 999 }
1000
1001 static void
1002 add_exec_redirect (dummy_redirect)
1003      REDIRECT *dummy_redirect;
1004 {
1005   dummy_redirect->next = exec_redirection_undo_list;
1006   exec_redirection_undo_list = dummy_redirect;
1007 }
1008
1009 /* Return 1 if the redirection specified by RI and REDIRECTOR alters the
1010    standard input. */
1011 static int
1012 stdin_redirection (ri, redirector)
1013      enum r_instruction ri;
1014      int redirector;
1015 {
1016   switch (ri)
1017     {
1018     case r_input_direction:
1019     case r_inputa_direction:
1020     case r_input_output:
1021     case r_reading_until:
1022     case r_deblank_reading_until:
1023     case r_reading_string:
1024       return (1);
1025     case r_duplicating_input:
1026     case r_duplicating_input_word:
1027     case r_close_this:
1028       return (redirector == 0);
1029     case r_output_direction:
1030     case r_appending_to:
1031     case r_duplicating_output:
1032     case r_err_and_out:
1033     case r_output_force:
1034     case r_duplicating_output_word:
1035       return (0);
1036     }
1037   return (0);
1038 }
1039
1040 /* Return non-zero if any of the redirections in REDIRS alter the standard
1041    input. */
1042 int
1043 stdin_redirects (redirs)
1044      REDIRECT *redirs;
1045 {
1046   REDIRECT *rp;
1047   int n;
1048
1049   for (n = 0, rp = redirs; rp; rp = rp->next)
1050     n += stdin_redirection (rp->instruction, rp->redirector);
1051   return n;
1052 }