Home | History | Annotate | Line # | Download | only in sh
redir.c revision 1.24
      1  1.24  christos /*	$NetBSD: redir.c,v 1.24 2002/09/27 18:56:55 christos Exp $	*/
      2  1.11       cgd 
      3   1.1       cgd /*-
      4   1.7       jtc  * Copyright (c) 1991, 1993
      5   1.7       jtc  *	The Regents of the University of California.  All rights reserved.
      6   1.1       cgd  *
      7   1.1       cgd  * This code is derived from software contributed to Berkeley by
      8   1.1       cgd  * Kenneth Almquist.
      9   1.1       cgd  *
     10   1.1       cgd  * Redistribution and use in source and binary forms, with or without
     11   1.1       cgd  * modification, are permitted provided that the following conditions
     12   1.1       cgd  * are met:
     13   1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     14   1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     15   1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     16   1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     17   1.1       cgd  *    documentation and/or other materials provided with the distribution.
     18   1.1       cgd  * 3. All advertising materials mentioning features or use of this software
     19   1.1       cgd  *    must display the following acknowledgement:
     20   1.1       cgd  *	This product includes software developed by the University of
     21   1.1       cgd  *	California, Berkeley and its contributors.
     22   1.1       cgd  * 4. Neither the name of the University nor the names of its contributors
     23   1.1       cgd  *    may be used to endorse or promote products derived from this software
     24   1.1       cgd  *    without specific prior written permission.
     25   1.1       cgd  *
     26   1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     27   1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     28   1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     29   1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     30   1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     31   1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     32   1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     33   1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     34   1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     35   1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     36   1.1       cgd  * SUCH DAMAGE.
     37   1.1       cgd  */
     38   1.1       cgd 
     39  1.16  christos #include <sys/cdefs.h>
     40   1.1       cgd #ifndef lint
     41  1.11       cgd #if 0
     42  1.12  christos static char sccsid[] = "@(#)redir.c	8.2 (Berkeley) 5/4/95";
     43  1.11       cgd #else
     44  1.24  christos __RCSID("$NetBSD: redir.c,v 1.24 2002/09/27 18:56:55 christos Exp $");
     45  1.11       cgd #endif
     46   1.1       cgd #endif /* not lint */
     47   1.1       cgd 
     48  1.12  christos #include <sys/types.h>
     49  1.17  christos #include <sys/param.h>	/* PIPE_BUF */
     50  1.12  christos #include <signal.h>
     51  1.12  christos #include <string.h>
     52  1.12  christos #include <fcntl.h>
     53  1.12  christos #include <errno.h>
     54  1.12  christos #include <unistd.h>
     55  1.12  christos #include <stdlib.h>
     56  1.12  christos 
     57   1.1       cgd /*
     58   1.1       cgd  * Code for dealing with input/output redirection.
     59   1.1       cgd  */
     60   1.1       cgd 
     61   1.1       cgd #include "shell.h"
     62   1.1       cgd #include "nodes.h"
     63   1.1       cgd #include "jobs.h"
     64  1.23  christos #include "options.h"
     65   1.1       cgd #include "expand.h"
     66   1.1       cgd #include "redir.h"
     67   1.1       cgd #include "output.h"
     68   1.1       cgd #include "memalloc.h"
     69   1.1       cgd #include "error.h"
     70   1.1       cgd 
     71   1.1       cgd 
     72   1.1       cgd #define EMPTY -2		/* marks an unused slot in redirtab */
     73  1.17  christos #ifndef PIPE_BUF
     74  1.17  christos # define PIPESIZE 4096		/* amount of buffering in a pipe */
     75  1.17  christos #else
     76  1.17  christos # define PIPESIZE PIPE_BUF
     77  1.17  christos #endif
     78   1.1       cgd 
     79   1.1       cgd 
     80   1.1       cgd MKINIT
     81   1.1       cgd struct redirtab {
     82   1.1       cgd 	struct redirtab *next;
     83   1.1       cgd 	short renamed[10];
     84   1.1       cgd };
     85   1.1       cgd 
     86   1.1       cgd 
     87   1.1       cgd MKINIT struct redirtab *redirlist;
     88   1.1       cgd 
     89  1.13  christos /*
     90   1.7       jtc  * We keep track of whether or not fd0 has been redirected.  This is for
     91   1.7       jtc  * background commands, where we want to redirect fd0 to /dev/null only
     92  1.13  christos  * if it hasn't already been redirected.
     93   1.7       jtc */
     94   1.4       sef int fd0_redirected = 0;
     95   1.1       cgd 
     96  1.12  christos STATIC void openredirect __P((union node *, char[10 ]));
     97  1.12  christos STATIC int openhere __P((union node *));
     98   1.1       cgd 
     99   1.1       cgd 
    100   1.1       cgd /*
    101   1.1       cgd  * Process a list of redirection commands.  If the REDIR_PUSH flag is set,
    102   1.1       cgd  * old file descriptors are stashed away so that the redirection can be
    103   1.1       cgd  * undone by calling popredir.  If the REDIR_BACKQ flag is set, then the
    104   1.1       cgd  * standard output, and the standard error if it becomes a duplicate of
    105   1.1       cgd  * stdout, is saved in memory.
    106   1.1       cgd  */
    107   1.1       cgd 
    108   1.1       cgd void
    109   1.1       cgd redirect(redir, flags)
    110   1.1       cgd 	union node *redir;
    111   1.1       cgd 	int flags;
    112   1.1       cgd 	{
    113   1.1       cgd 	union node *n;
    114  1.16  christos 	struct redirtab *sv = NULL;
    115   1.1       cgd 	int i;
    116   1.1       cgd 	int fd;
    117  1.15  christos 	int try;
    118  1.13  christos 	char memory[10];	/* file descriptors to write to memory */
    119   1.1       cgd 
    120   1.1       cgd 	for (i = 10 ; --i >= 0 ; )
    121   1.1       cgd 		memory[i] = 0;
    122   1.1       cgd 	memory[1] = flags & REDIR_BACKQ;
    123   1.1       cgd 	if (flags & REDIR_PUSH) {
    124  1.24  christos 		/* We don't have to worry about REDIR_VFORK here, as
    125  1.24  christos 		 * flags & REDIR_PUSH is never true if REDIR_VFORK is set.
    126  1.24  christos 		 */
    127   1.1       cgd 		sv = ckmalloc(sizeof (struct redirtab));
    128   1.1       cgd 		for (i = 0 ; i < 10 ; i++)
    129   1.1       cgd 			sv->renamed[i] = EMPTY;
    130   1.1       cgd 		sv->next = redirlist;
    131   1.1       cgd 		redirlist = sv;
    132   1.1       cgd 	}
    133   1.1       cgd 	for (n = redir ; n ; n = n->nfile.next) {
    134   1.1       cgd 		fd = n->nfile.fd;
    135  1.15  christos 		try = 0;
    136  1.13  christos 		if ((n->nfile.type == NTOFD || n->nfile.type == NFROMFD) &&
    137  1.13  christos 		    n->ndup.dupfd == fd)
    138  1.13  christos 			continue; /* redirect from/to same file descriptor */
    139  1.15  christos 
    140   1.1       cgd 		if ((flags & REDIR_PUSH) && sv->renamed[fd] == EMPTY) {
    141   1.1       cgd 			INTOFF;
    142  1.15  christos again:
    143  1.15  christos 			if ((i = fcntl(fd, F_DUPFD, 10)) == -1) {
    144  1.15  christos 				switch (errno) {
    145  1.15  christos 				case EBADF:
    146  1.15  christos 					if (!try) {
    147  1.15  christos 						openredirect(n, memory);
    148  1.15  christos 						try++;
    149  1.15  christos 						goto again;
    150  1.15  christos 					}
    151  1.15  christos 					/* FALLTHROUGH*/
    152  1.15  christos 				default:
    153  1.15  christos 					INTON;
    154  1.15  christos 					error("%d: %s", fd, strerror(errno));
    155  1.19   mycroft 					/* NOTREACHED */
    156  1.15  christos 				}
    157  1.15  christos 			}
    158  1.15  christos 			if (!try) {
    159   1.1       cgd 				sv->renamed[fd] = i;
    160   1.1       cgd 				close(fd);
    161   1.1       cgd 			}
    162   1.1       cgd 			INTON;
    163   1.1       cgd 		} else {
    164   1.1       cgd 			close(fd);
    165   1.1       cgd 		}
    166   1.7       jtc                 if (fd == 0)
    167   1.7       jtc                         fd0_redirected++;
    168  1.15  christos 		if (!try)
    169  1.15  christos 			openredirect(n, memory);
    170   1.1       cgd 	}
    171   1.1       cgd 	if (memory[1])
    172   1.1       cgd 		out1 = &memout;
    173   1.1       cgd 	if (memory[2])
    174   1.1       cgd 		out2 = &memout;
    175   1.1       cgd }
    176   1.1       cgd 
    177   1.1       cgd 
    178   1.1       cgd STATIC void
    179   1.1       cgd openredirect(redir, memory)
    180   1.1       cgd 	union node *redir;
    181   1.1       cgd 	char memory[10];
    182   1.1       cgd 	{
    183   1.1       cgd 	int fd = redir->nfile.fd;
    184   1.1       cgd 	char *fname;
    185   1.1       cgd 	int f;
    186  1.23  christos 	int flags = O_WRONLY|O_CREAT|O_TRUNC;
    187   1.1       cgd 
    188   1.1       cgd 	/*
    189   1.1       cgd 	 * We suppress interrupts so that we won't leave open file
    190   1.1       cgd 	 * descriptors around.  This may not be such a good idea because
    191   1.1       cgd 	 * an open of a device or a fifo can block indefinitely.
    192   1.1       cgd 	 */
    193   1.1       cgd 	INTOFF;
    194   1.1       cgd 	memory[fd] = 0;
    195   1.1       cgd 	switch (redir->nfile.type) {
    196   1.1       cgd 	case NFROM:
    197   1.1       cgd 		fname = redir->nfile.expfname;
    198   1.1       cgd 		if ((f = open(fname, O_RDONLY)) < 0)
    199  1.20  christos 			goto eopen;
    200  1.20  christos 		break;
    201  1.20  christos 	case NFROMTO:
    202  1.20  christos 		fname = redir->nfile.expfname;
    203  1.20  christos 		if ((f = open(fname, O_RDWR|O_CREAT|O_TRUNC, 0666)) < 0)
    204  1.20  christos 			goto ecreate;
    205   1.1       cgd 		break;
    206   1.1       cgd 	case NTO:
    207  1.23  christos 		if (Cflag)
    208  1.23  christos 			flags |= O_EXCL;
    209  1.23  christos 		/* FALLTHROUGH */
    210  1.23  christos 	case NCLOBBER:
    211   1.1       cgd 		fname = redir->nfile.expfname;
    212  1.23  christos 		if ((f = open(fname, flags, 0666)) < 0)
    213  1.20  christos 			goto ecreate;
    214  1.20  christos 		break;
    215   1.1       cgd 	case NAPPEND:
    216   1.1       cgd 		fname = redir->nfile.expfname;
    217   1.1       cgd 		if ((f = open(fname, O_WRONLY|O_CREAT|O_APPEND, 0666)) < 0)
    218  1.20  christos 			goto ecreate;
    219  1.20  christos 		break;
    220   1.1       cgd 	case NTOFD:
    221   1.1       cgd 	case NFROMFD:
    222   1.1       cgd 		if (redir->ndup.dupfd >= 0) {	/* if not ">&-" */
    223   1.1       cgd 			if (memory[redir->ndup.dupfd])
    224   1.1       cgd 				memory[fd] = 1;
    225   1.1       cgd 			else
    226   1.1       cgd 				copyfd(redir->ndup.dupfd, fd);
    227   1.1       cgd 		}
    228  1.20  christos 		INTON;
    229  1.20  christos 		return;
    230   1.1       cgd 	case NHERE:
    231   1.1       cgd 	case NXHERE:
    232   1.1       cgd 		f = openhere(redir);
    233  1.20  christos 		break;
    234   1.1       cgd 	default:
    235   1.1       cgd 		abort();
    236   1.1       cgd 	}
    237  1.20  christos 
    238  1.20  christos 	if (f != fd) {
    239  1.20  christos 		copyfd(f, fd);
    240  1.20  christos 		close(f);
    241  1.20  christos 	}
    242   1.1       cgd 	INTON;
    243  1.20  christos 	return;
    244  1.20  christos ecreate:
    245  1.20  christos 	error("cannot create %s: %s", fname, errmsg(errno, E_CREAT));
    246  1.20  christos eopen:
    247  1.20  christos 	error("cannot open %s: %s", fname, errmsg(errno, E_OPEN));
    248   1.1       cgd }
    249   1.1       cgd 
    250   1.1       cgd 
    251   1.1       cgd /*
    252   1.1       cgd  * Handle here documents.  Normally we fork off a process to write the
    253   1.1       cgd  * data to a pipe.  If the document is short, we can stuff the data in
    254   1.1       cgd  * the pipe without forking.
    255   1.1       cgd  */
    256   1.1       cgd 
    257   1.1       cgd STATIC int
    258   1.1       cgd openhere(redir)
    259   1.1       cgd 	union node *redir;
    260   1.1       cgd 	{
    261   1.1       cgd 	int pip[2];
    262  1.12  christos 	int len = 0;
    263   1.1       cgd 
    264   1.1       cgd 	if (pipe(pip) < 0)
    265   1.1       cgd 		error("Pipe call failed");
    266   1.1       cgd 	if (redir->type == NHERE) {
    267   1.1       cgd 		len = strlen(redir->nhere.doc->narg.text);
    268   1.1       cgd 		if (len <= PIPESIZE) {
    269   1.1       cgd 			xwrite(pip[1], redir->nhere.doc->narg.text, len);
    270   1.1       cgd 			goto out;
    271   1.1       cgd 		}
    272   1.1       cgd 	}
    273   1.1       cgd 	if (forkshell((struct job *)NULL, (union node *)NULL, FORK_NOJOB) == 0) {
    274   1.1       cgd 		close(pip[0]);
    275   1.1       cgd 		signal(SIGINT, SIG_IGN);
    276   1.1       cgd 		signal(SIGQUIT, SIG_IGN);
    277   1.1       cgd 		signal(SIGHUP, SIG_IGN);
    278   1.1       cgd #ifdef SIGTSTP
    279   1.1       cgd 		signal(SIGTSTP, SIG_IGN);
    280   1.1       cgd #endif
    281   1.1       cgd 		signal(SIGPIPE, SIG_DFL);
    282   1.1       cgd 		if (redir->type == NHERE)
    283   1.1       cgd 			xwrite(pip[1], redir->nhere.doc->narg.text, len);
    284   1.1       cgd 		else
    285   1.1       cgd 			expandhere(redir->nhere.doc, pip[1]);
    286   1.1       cgd 		_exit(0);
    287   1.1       cgd 	}
    288   1.1       cgd out:
    289   1.1       cgd 	close(pip[1]);
    290   1.1       cgd 	return pip[0];
    291   1.1       cgd }
    292   1.1       cgd 
    293   1.1       cgd 
    294   1.1       cgd 
    295   1.1       cgd /*
    296   1.1       cgd  * Undo the effects of the last redirection.
    297   1.1       cgd  */
    298   1.1       cgd 
    299   1.1       cgd void
    300   1.1       cgd popredir() {
    301  1.14       tls 	struct redirtab *rp = redirlist;
    302   1.1       cgd 	int i;
    303   1.1       cgd 
    304   1.1       cgd 	for (i = 0 ; i < 10 ; i++) {
    305   1.1       cgd 		if (rp->renamed[i] != EMPTY) {
    306   1.7       jtc                         if (i == 0)
    307   1.7       jtc                                 fd0_redirected--;
    308   1.1       cgd 			close(i);
    309   1.1       cgd 			if (rp->renamed[i] >= 0) {
    310   1.1       cgd 				copyfd(rp->renamed[i], i);
    311   1.1       cgd 				close(rp->renamed[i]);
    312   1.1       cgd 			}
    313   1.1       cgd 		}
    314   1.1       cgd 	}
    315   1.1       cgd 	INTOFF;
    316   1.1       cgd 	redirlist = rp->next;
    317   1.1       cgd 	ckfree(rp);
    318   1.1       cgd 	INTON;
    319   1.1       cgd }
    320   1.1       cgd 
    321   1.1       cgd /*
    322   1.1       cgd  * Undo all redirections.  Called on error or interrupt.
    323   1.1       cgd  */
    324   1.1       cgd 
    325   1.1       cgd #ifdef mkinit
    326   1.1       cgd 
    327   1.1       cgd INCLUDE "redir.h"
    328   1.1       cgd 
    329   1.1       cgd RESET {
    330   1.1       cgd 	while (redirlist)
    331   1.1       cgd 		popredir();
    332   1.1       cgd }
    333   1.1       cgd 
    334   1.1       cgd SHELLPROC {
    335  1.24  christos 	clearredir(0);
    336   1.1       cgd }
    337   1.1       cgd 
    338   1.1       cgd #endif
    339   1.1       cgd 
    340   1.7       jtc /* Return true if fd 0 has already been redirected at least once.  */
    341   1.7       jtc int
    342   1.7       jtc fd0_redirected_p () {
    343   1.7       jtc         return fd0_redirected != 0;
    344   1.7       jtc }
    345   1.1       cgd 
    346   1.1       cgd /*
    347   1.1       cgd  * Discard all saved file descriptors.
    348   1.1       cgd  */
    349   1.1       cgd 
    350   1.1       cgd void
    351  1.24  christos clearredir(vforked)
    352  1.24  christos 	int vforked;
    353  1.24  christos {
    354  1.14       tls 	struct redirtab *rp;
    355   1.1       cgd 	int i;
    356   1.1       cgd 
    357   1.1       cgd 	for (rp = redirlist ; rp ; rp = rp->next) {
    358   1.1       cgd 		for (i = 0 ; i < 10 ; i++) {
    359   1.1       cgd 			if (rp->renamed[i] >= 0) {
    360   1.1       cgd 				close(rp->renamed[i]);
    361   1.1       cgd 			}
    362  1.24  christos 			if (!vforked)
    363  1.24  christos 				rp->renamed[i] = EMPTY;
    364   1.1       cgd 		}
    365   1.1       cgd 	}
    366   1.1       cgd }
    367   1.1       cgd 
    368   1.1       cgd 
    369   1.1       cgd 
    370   1.1       cgd /*
    371   1.7       jtc  * Copy a file descriptor to be >= to.  Returns -1
    372   1.1       cgd  * if the source file descriptor is closed, EMPTY if there are no unused
    373   1.1       cgd  * file descriptors left.
    374   1.1       cgd  */
    375   1.1       cgd 
    376   1.1       cgd int
    377  1.13  christos copyfd(from, to)
    378   1.9       cgd 	int from;
    379   1.9       cgd 	int to;
    380   1.9       cgd {
    381   1.1       cgd 	int newfd;
    382   1.1       cgd 
    383   1.1       cgd 	newfd = fcntl(from, F_DUPFD, to);
    384  1.13  christos 	if (newfd < 0) {
    385  1.13  christos 		if (errno == EMFILE)
    386  1.13  christos 			return EMPTY;
    387  1.13  christos 		else
    388  1.13  christos 			error("%d: %s", from, strerror(errno));
    389  1.13  christos 	}
    390   1.1       cgd 	return newfd;
    391   1.1       cgd }
    392