xref: /freebsd/contrib/tcsh/sh.sem.c (revision 6560ac57ce879857203bc456cdc3849808dc0700)
1 /*
2  * sh.sem.c: I/O redirections and job forking. A touchy issue!
3  *	     Most stuff with builtins is incorrect
4  */
5 /*-
6  * Copyright (c) 1980, 1991 The Regents of the University of California.
7  * All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  * 3. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  */
33 #include "sh.h"
34 #include "tc.h"
35 #include "tw.h"
36 #ifdef WINNT_NATIVE
37 #include "nt.const.h"
38 #endif /*WINNT_NATIVE*/
39 
40 #ifdef CLOSE_ON_EXEC
41 # ifndef SUNOS4
42 #  ifndef CLEX_DUPS
43 #   define CLEX_DUPS
44 #  endif /* CLEX_DUPS */
45 # endif /* !SUNOS4 */
46 #endif /* CLOSE_ON_EXEC */
47 
48 #if defined(__sparc__) || defined(sparc)
49 # if !defined(MACH) && SYSVREL == 0 && !defined(Lynx) && !defined(BSD4_4) && !defined(__linux__) && !defined(__GNU__) && !defined(__GLIBC__)
50 #  include <vfork.h>
51 # endif /* !MACH && SYSVREL == 0 && !Lynx && !BSD4_4 && !glibc */
52 #endif /* __sparc__ || sparc */
53 
54 #ifdef VFORK
55 static	void		vffree		(int);
56 #endif
57 static	Char		*splicepipe	(struct command *, Char *);
58 static	void		 doio		(struct command *, int *, int *);
59 static	void		 chkclob	(const char *);
60 
61 /*
62  * C shell
63  */
64 
65 /*
66  * For SVR4, there are problems with pipelines having the first process as
67  * the group leader.  The problem occurs when the first process exits before
68  * the others have a chance to setpgid().  This is because in SVR4 you can't
69  * have a zombie as a group leader.  The solution I have used is to reverse
70  * the order in which pipelines are started, making the last process the
71  * group leader.  (Note I am not using 'pipeline' in the generic sense -- I
72  * mean processes connected by '|'.)  I don't know yet if this causes other
73  * problems.
74  *
75  * All the changes for this are in execute(), and are enclosed in
76  * '#ifdef BACKPIPE'
77  *
78  * David Dawes (dawes@physics.su.oz.au) Oct 1991
79  */
80 
81 /*VARARGS 1*/
82 void
execute(struct command * t,volatile int wanttty,int * pipein,int * pipeout,int do_glob)83 execute(struct command *t, volatile int wanttty, int *pipein, int *pipeout,
84     int do_glob)
85 {
86     int    forked = 0;
87     const struct biltins * volatile bifunc;
88     pid_t pid = 0;
89     int     pv[2];
90     sigset_t set;
91     static sigset_t csigset;
92 #ifdef VFORK
93     static int onosigchld = 0;
94 #endif /* VFORK */
95     static int nosigchld = 0;
96 
97     (void) &wanttty;
98     (void) &forked;
99     (void) &bifunc;
100 
101     if (t == 0)
102 	return;
103 
104 #ifdef WINNT_NATIVE
105     {
106         if ((varval(STRNTslowexec) == STRNULL) &&
107             !t->t_dcdr && !t->t_dcar && !t->t_dflg && !didfds &&
108             (intty || intact) && (t->t_dtyp == NODE_COMMAND) &&
109 	    !isbfunc(t)) {
110 	    if ((t->t_dcom[0][0] & (QUOTE | TRIM)) == QUOTE)
111 		(void) Strcpy(t->t_dcom[0], t->t_dcom[0] + 1);
112 	    Dfix(t);
113             if (nt_try_fast_exec(t) == 0)
114                 return;
115         }
116     }
117 #endif /* WINNT_NATIVE */
118 
119     /*
120      * Ed hutchins@sgi.com & Dominic dbg@sgi.com
121      * Sat Feb 25 03:13:11 PST 1995
122      * try implicit cd if we have a 1 word command
123      */
124     if (implicit_cd && (intty || intact) && t->t_dcom && t->t_dcom[0] &&
125 	 t->t_dcom[0][0] && (blklen(t->t_dcom) == 1) && !noexec) {
126 	Char *sCName;
127 	struct stat stbuf;
128 	char *pathname;
129 
130 	sCName = dollar(t->t_dcom[0]);
131 	if (sCName != NULL && sCName[0] == '~') {
132 	    struct Strbuf buf = Strbuf_INIT;
133 	    const Char *name_end;
134 
135 	    for (name_end = sCName + 1; *name_end != '\0' && *name_end != '/';
136 		 name_end++)
137 		continue;
138 	    if (name_end != sCName + 1) {
139 		Char *name, *home;
140 
141 		name = Strnsave(sCName + 1, name_end - (sCName + 1));
142 		home = gethdir(name);
143 		if (home != NULL) {
144 		    Strbuf_append(&buf, home);
145 		    xfree(home);
146 		} else
147 		    Strbuf_append(&buf, name);
148 		xfree(name);
149 	    } else
150 		Strbuf_append(&buf, varval(STRhome));
151 	    Strbuf_append(&buf, name_end);
152 	    xfree(sCName);
153 	    sCName = Strbuf_finish(&buf);
154 	}
155 
156 	pathname = short2str(sCName);
157 	xfree(sCName);
158 	/* if this is a dir, tack a "cd" on as the first arg */
159 	if (pathname != NULL &&
160 	    ((stat(pathname, &stbuf) != -1 && S_ISDIR(stbuf.st_mode))
161 #ifdef WINNT_NATIVE
162 	     || (pathname[0] && pathname[1] == ':' && pathname[2] == '\0')
163 #endif /* WINNT_NATIVE */
164 	     )) {
165 	    Char *vCD[2];
166 	    Char **ot_dcom = t->t_dcom;
167 
168 	    vCD[0] = Strsave(STRcd);
169 	    vCD[1] = NULL;
170 	    t->t_dcom = blkspl(vCD, ot_dcom);
171 	    xfree(ot_dcom);
172 	    if (implicit_cd > 1) {
173 		blkpr(t->t_dcom);
174 		xputchar( '\n' );
175 	    }
176 	}
177     }
178 
179     /*
180      * From: Michael Schroeder <mlschroe@immd4.informatik.uni-erlangen.de>
181      * Don't check for wantty > 0...
182      */
183     if (t->t_dflg & F_AMPERSAND)
184 	wanttty = 0;
185     switch (t->t_dtyp) {
186 
187     case NODE_COMMAND:
188 	if ((t->t_dcom[0][0] & (QUOTE | TRIM)) == QUOTE)
189 	    memmove(t->t_dcom[0], t->t_dcom[0] + 1,
190 		    (Strlen(t->t_dcom[0] + 1) + 1) * sizeof (*t->t_dcom[0]));
191 	if ((t->t_dflg & F_REPEAT) == 0)
192 	    Dfix(t);		/* $ " ' \ */
193 	if (t->t_dcom[0] == 0) {
194 	    return;
195 	}
196 	/*FALLTHROUGH*/
197 
198     case NODE_PAREN:
199 #ifdef BACKPIPE
200 	if (t->t_dflg & F_PIPEIN)
201 	    mypipe(pipein);
202 #else /* !BACKPIPE */
203 	if (t->t_dflg & F_PIPEOUT)
204 	    mypipe(pipeout);
205 #endif /* BACKPIPE */
206 	/*
207 	 * Must do << early so parent will know where input pointer should be.
208 	 * If noexec then this is all we do.
209 	 */
210 	if (t->t_dflg & F_READ) {
211 	    int old_pintr_disabled;
212 
213 	    xclose(0);
214 	    if (setintr)
215 		pintr_push_enable(&old_pintr_disabled);
216 	    heredoc(t->t_dlef);
217 	    if (setintr)
218 		cleanup_until(&old_pintr_disabled);
219 	    if (noexec)
220 		xclose(0);
221 	}
222 
223 	setcopy(STRstatus, STR0, VAR_READWRITE);
224 
225 	/*
226 	 * This mess is the necessary kludge to handle the prefix builtins:
227 	 * nice, nohup, time.  These commands can also be used by themselves,
228 	 * and this is not handled here. This will also work when loops are
229 	 * parsed.
230 	 */
231 	while (t->t_dtyp == NODE_COMMAND)
232 	    if (eq(t->t_dcom[0], STRnice)) {
233 		if (t->t_dcom[1]) {
234 		    if (strchr("+-", t->t_dcom[1][0])) {
235 			if (t->t_dcom[2]) {
236 			    setname("nice");
237 			    t->t_nice = (unsigned char)getn(t->t_dcom[1]);
238 			    lshift(t->t_dcom, 2);
239 			    t->t_dflg |= F_NICE;
240 			}
241 			else
242 			    break;
243 		    }
244 		    else {
245 			t->t_nice = 4;
246 			lshift(t->t_dcom, 1);
247 			t->t_dflg |= F_NICE;
248 		    }
249 		}
250 		else
251 		    break;
252 	    }
253 	    else if (eq(t->t_dcom[0], STRnohup)) {
254 		if (t->t_dcom[1]) {
255 		    t->t_dflg |= F_NOHUP;
256 		    lshift(t->t_dcom, 1);
257 		}
258 		else
259 		    break;
260 	    }
261 	    else if (eq(t->t_dcom[0], STRhup)) {
262 		if (t->t_dcom[1]) {
263 		    t->t_dflg |= F_HUP;
264 		    lshift(t->t_dcom, 1);
265 		}
266 		else
267 		    break;
268 	    }
269 	    else if (eq(t->t_dcom[0], STRtime)) {
270 		if (t->t_dcom[1]) {
271 		    t->t_dflg |= F_TIME;
272 		    lshift(t->t_dcom, 1);
273 		}
274 		else
275 		    break;
276 	    }
277 #ifdef F_VER
278 	    else if (eq(t->t_dcom[0], STRver))
279 		if (t->t_dcom[1] && t->t_dcom[2]) {
280 		    setname("ver");
281 		    t->t_systype = getv(t->t_dcom[1]);
282 		    lshift(t->t_dcom, 2);
283 		    t->t_dflg |= F_VER;
284 		}
285 		else
286 		    break;
287 #endif  /* F_VER */
288 	    else
289 		break;
290 
291 	/* is it a command */
292 	if (t->t_dtyp == NODE_COMMAND) {
293 	    /*
294 	     * Check if we have a builtin function and remember which one.
295 	     */
296 	    bifunc = isbfunc(t);
297  	    if (noexec) {
298 		/*
299 		 * Continue for builtins that are part of the scripting language
300 		 */
301 		if (bifunc == NULL)
302 		    break;
303 		if (bifunc->bfunct != (bfunc_t)dobreak	&&
304 		    bifunc->bfunct != (bfunc_t)docontin	&&
305 		    bifunc->bfunct != (bfunc_t)doelse	&&
306 		    bifunc->bfunct != (bfunc_t)doend	&&
307 		    bifunc->bfunct != (bfunc_t)doforeach&&
308 		    bifunc->bfunct != (bfunc_t)dogoto	&&
309 		    bifunc->bfunct != (bfunc_t)doif	&&
310 		    bifunc->bfunct != (bfunc_t)dorepeat	&&
311 		    bifunc->bfunct != (bfunc_t)doswbrk	&&
312 		    bifunc->bfunct != (bfunc_t)doswitch	&&
313 		    bifunc->bfunct != (bfunc_t)dowhile	&&
314 		    bifunc->bfunct != (bfunc_t)dozip)
315 		    break;
316 	    }
317 	}
318 	else {			/* not a command */
319 	    bifunc = NULL;
320 	    if (noexec)
321 		break;
322 	}
323 
324 	/*
325 	 * GrP Executing a command - run jobcmd hook
326 	 * Don't run for builtins
327 	 * Don't run if we're not in a tty
328 	 * Don't run if we're not really executing
329 	 */
330 	/*
331 	 * CR  -  Charles Ross Aug 2005
332 	 * added "isoutatty".
333 	 * The new behavior is that the jobcmd won't be executed
334 	 * if stdout (SHOUT) isnt attached to a tty.. IE when
335 	 * redirecting, or using backquotes etc..
336 	 */
337 	if (t->t_dtyp == NODE_COMMAND && !bifunc && !noexec && intty && isoutatty) {
338 	    Char *cmd = unparse(t);
339 
340 	    cleanup_push(cmd, xfree);
341 	    job_cmd(cmd);
342 	    cleanup_until(cmd);
343 	}
344 
345 	/*
346 	 * We fork only if we are timed, or are not the end of a parenthesized
347 	 * list and not a simple builtin function. Simple meaning one that is
348 	 * not pipedout, niced, nohupped, or &'d. It would be nice(?) to not
349 	 * fork in some of these cases.
350 	 */
351 #ifdef BACKPIPE
352 	/*
353 	 * Can't have NOFORK for the tail of a pipe - because it is not the
354 	 * last command spawned (even if it is at the end of a parenthesised
355 	 * list).
356 	 */
357 	if (t->t_dflg & F_PIPEIN)
358 	    t->t_dflg &= ~(F_NOFORK);
359 #else
360 	/*
361 	 * "command | builtin" may cause major misbehaviour as noted in
362 	 * in the BUGS file entry
363 	 * Subject: Redirected input to built-in functions misbehaves badly
364 	 * forking when the builtin is the end of the pipe corrects the
365 	 * problem.
366 	 */
367 	if (bifunc && (t->t_dflg & F_PIPEIN))
368 	    t->t_dflg &= ~(F_NOFORK);
369 #endif /* BACKPIPE */
370 	/*
371 	 * Prevent forking cd, pushd, popd, chdir cause this will cause the
372 	 * shell not to change dir! (XXX: but only for nice?)
373 	 */
374 	if (bifunc && (bifunc->bfunct == (bfunc_t)dochngd ||
375 		       bifunc->bfunct == (bfunc_t)dopushd ||
376 		       bifunc->bfunct == (bfunc_t)dopopd))
377 	    t->t_dflg &= ~(F_NICE);
378 
379 	if (((t->t_dflg & F_TIME) || ((t->t_dflg & F_NOFORK) == 0 &&
380 	     (!bifunc || t->t_dflg &
381 	      (F_PIPEOUT | F_AMPERSAND | F_NICE | F_NOHUP | F_HUP)))) ||
382 	/*
383 	 * We have to fork for eval too.
384 	 */
385 	    (bifunc && (t->t_dflg & F_PIPEIN) != 0 &&
386 	     bifunc->bfunct == (bfunc_t)doeval)) {
387 #ifdef VFORK
388 	    if (t->t_dtyp == NODE_PAREN ||
389 		t->t_dflg & (F_REPEAT | F_AMPERSAND) || bifunc)
390 #endif /* VFORK */
391 	    {
392 		forked++;
393 		/*
394 		 * We need to block SIGCHLD here, so that if the process does
395 		 * not die before we can set the process group
396 		 */
397 		if (wanttty >= 0 && !nosigchld) {
398 		    sigemptyset(&set);
399 		    sigaddset(&set, SIGCHLD);
400 		    (void)sigprocmask(SIG_BLOCK, &set, &csigset);
401 
402 		    nosigchld = 1;
403 		}
404 
405 		pid = pfork(t, wanttty);
406 		if (pid == 0 && nosigchld) {
407 		    sigprocmask(SIG_SETMASK, &csigset, NULL);
408 		    nosigchld = 0;
409 		}
410 		else if (pid != 0 && (t->t_dflg & F_AMPERSAND))
411 		    backpid = pid;
412 	    }
413 
414 #ifdef VFORK
415 	    else {
416 		int     ochild, osetintr, ohaderr, odidfds;
417 		int     oSHIN, oSHOUT, oSHDIAG, oOLDSTD, otpgrp;
418 		int     oisoutatty, oisdiagatty;
419 		sigset_t oset, ocsigset;
420 # ifndef CLOSE_ON_EXEC
421 		int     odidcch;
422 # endif  /* !CLOSE_ON_EXEC */
423 
424 		/*
425 		 * Prepare for the vfork by saving everything that the child
426 		 * corrupts before it exec's. Note that in some signal
427 		 * implementations which keep the signal info in user space
428 		 * (e.g. Sun's) it will also be necessary to save and restore
429 		 * the current sigvec's for the signals the child touches
430 		 * before it exec's.
431 		 */
432 
433 		/*
434 		 * Sooooo true... If this is a Sun, save the sigvec's. (Skip
435 		 * Gilbrech - 11/22/87)
436 		 */
437 # ifdef SAVESIGVEC
438 		struct sigaction savesv[NSIGSAVED];
439 		sigset_t savesm;
440 
441 # endif /* SAVESIGVEC */
442 		if (wanttty >= 0 && !nosigchld && !noexec) {
443 		    sigemptyset(&set);
444 		    sigaddset(&set, SIGCHLD);
445 		    (void)sigprocmask(SIG_BLOCK, &set, &csigset);
446 		    nosigchld = 1;
447 		}
448 		sigemptyset(&set);
449 		sigaddset(&set, SIGCHLD);
450 		sigaddset(&set, SIGINT);
451 		(void)sigprocmask(SIG_BLOCK, &set, &oset);
452 		ochild = child;
453 		osetintr = setintr;
454 		ohaderr = haderr;
455 		odidfds = didfds;
456 # ifndef CLOSE_ON_EXEC
457 		odidcch = didcch;
458 # endif /* !CLOSE_ON_EXEC */
459 		oSHIN = SHIN;
460 		oSHOUT = SHOUT;
461 		oSHDIAG = SHDIAG;
462 		oOLDSTD = OLDSTD;
463 		otpgrp = tpgrp;
464 		oisoutatty = isoutatty;
465 		oisdiagatty = isdiagatty;
466 		ocsigset = csigset;
467 		onosigchld = nosigchld;
468 		Vsav = Vdp = 0;
469 		Vexpath = 0;
470 		Vt = 0;
471 # ifdef SAVESIGVEC
472 		savesigvec(savesv, savesm);
473 # endif /* SAVESIGVEC */
474 		if (use_fork)
475 		    pid = fork();
476 		else
477 		    pid = vfork();
478 
479 		if (pid < 0) {
480 # ifdef SAVESIGVEC
481 		    restoresigvec(savesv, savesm);
482 # endif /* SAVESIGVEC */
483 		    sigprocmask(SIG_SETMASK, &oset, NULL);
484 		    stderror(ERR_NOPROC);
485 		}
486 		forked++;
487 		if (pid) {	/* parent */
488 # ifdef SAVESIGVEC
489 		    restoresigvec(savesv, savesm);
490 # endif /* SAVESIGVEC */
491 		    child = ochild;
492 		    setintr = osetintr;
493 		    haderr = ohaderr;
494 		    didfds = odidfds;
495 		    SHIN = oSHIN;
496 # ifndef CLOSE_ON_EXEC
497 		    didcch = odidcch;
498 # endif /* !CLOSE_ON_EXEC */
499 		    SHOUT = oSHOUT;
500 		    SHDIAG = oSHDIAG;
501 		    OLDSTD = oOLDSTD;
502 		    tpgrp = otpgrp;
503 		    isoutatty = oisoutatty;
504 		    isdiagatty = oisdiagatty;
505 		    csigset = ocsigset;
506 		    nosigchld = onosigchld;
507 
508 		    xfree(Vsav);
509 		    Vsav = 0;
510 		    xfree(Vdp);
511 		    Vdp = 0;
512 		    xfree(Vexpath);
513 		    Vexpath = 0;
514 		    blk_cleanup(Vt);
515 		    Vt = 0;
516 		    /* this is from pfork() */
517 		    palloc(pid, t);
518 		    sigprocmask(SIG_SETMASK, &oset, NULL);
519 		}
520 		else {		/* child */
521 		    /* this is from pfork() */
522 		    pid_t pgrp;
523 		    int    ignint = 0;
524 		    if (nosigchld) {
525 			sigprocmask(SIG_SETMASK, &csigset, NULL);
526 			nosigchld = 0;
527 		    }
528 
529 		    if (setintr)
530 			ignint = (tpgrp == -1 && (t->t_dflg & F_NOINTERRUPT))
531 				|| (gointr && eq(gointr, STRminus));
532 		    pgrp = pcurrjob ? pcurrjob->p_jobid : getpid();
533 		    child++;
534 		    if (setintr) {
535 			setintr = 0;
536 /*
537  * casts made right for SunOS 4.0 by Douglas C. Schmidt
538  * <schmidt%sunshine.ics.uci.edu@ROME.ICS.UCI.EDU>
539  * (thanks! -- PWP)
540  *
541  * ignint ifs cleaned by Johan Widen <mcvax!osiris.sics.se!jw@uunet.UU.NET>
542  * (thanks again)
543  */
544 			if (ignint) {
545 			    (void) signal(SIGINT, SIG_IGN);
546 			    (void) signal(SIGQUIT, SIG_IGN);
547 			}
548 			else {
549 			    (void) signal(SIGINT, vffree);
550 			    (void) signal(SIGQUIT, SIG_DFL);
551 			}
552 # ifdef BSDJOBS
553 			if (wanttty >= 0) {
554 			    (void) signal(SIGTSTP, SIG_DFL);
555 			    (void) signal(SIGTTIN, SIG_DFL);
556 			    (void) signal(SIGTTOU, SIG_DFL);
557 			}
558 # endif /* BSDJOBS */
559 
560 			sigaction(SIGTERM, &parterm, NULL);
561 		    }
562 		    else if (tpgrp == -1 &&
563 			     (t->t_dflg & F_NOINTERRUPT)) {
564 			(void) signal(SIGINT, SIG_IGN);
565 			(void) signal(SIGQUIT, SIG_IGN);
566 		    }
567 
568 		    pgetty(wanttty, pgrp);
569 
570 		    if (t->t_dflg & F_NOHUP)
571 			(void) signal(SIGHUP, SIG_IGN);
572 		    if (t->t_dflg & F_HUP)
573 			(void) signal(SIGHUP, SIG_DFL);
574 		    if (t->t_dflg & F_NICE) {
575 			int nval = SIGN_EXTEND_CHAR(t->t_nice);
576 # if defined(HAVE_SETPRIORITY) && defined(PRIO_PROCESS)
577 			if (setpriority(PRIO_PROCESS, 0, nval) == -1 && errno)
578 				stderror(ERR_SYSTEM, "setpriority",
579 				    strerror(errno));
580 # else /* !HAVE_SETPRIORITY || !PRIO_PROCESS */
581 			(void) nice(nval);
582 # endif /* HAVE_SETPRIORITY && PRIO_PROCESS */
583 		    }
584 # ifdef F_VER
585 		    if (t->t_dflg & F_VER) {
586 			tsetenv(STRSYSTYPE, t->t_systype ? STRbsd43 : STRsys53);
587 			dohash(NULL, NULL);
588 		    }
589 # endif /* F_VER */
590 		}
591 
592 	    }
593 #endif /* VFORK */
594 	}
595 	if (pid != 0) {
596 	    /*
597 	     * It would be better if we could wait for the whole job when we
598 	     * knew the last process had been started.  Pwait, in fact, does
599 	     * wait for the whole job anyway, but this test doesn't really
600 	     * express our intentions.
601 	     */
602 #ifdef BACKPIPE
603 	    if (didfds == 0 && t->t_dflg & F_PIPEOUT) {
604 		xclose(pipeout[0]);
605 		xclose(pipeout[1]);
606 	    }
607 	    if ((t->t_dflg & F_PIPEIN) != 0)
608 		break;
609 #else /* !BACKPIPE */
610 	    if (didfds == 0 && t->t_dflg & F_PIPEIN) {
611 		xclose(pipein[0]);
612 		xclose(pipein[1]);
613 	    }
614 	    if ((t->t_dflg & F_PIPEOUT) != 0)
615 		break;
616 #endif /* BACKPIPE */
617 
618 	    if (nosigchld) {
619 		sigprocmask(SIG_SETMASK, &csigset, NULL);
620 		nosigchld = 0;
621 	    }
622 	    if ((t->t_dflg & F_AMPERSAND) == 0)
623 		pwait();
624 	    break;
625 	}
626 
627 	doio(t, pipein, pipeout);
628 #ifdef BACKPIPE
629 	if (t->t_dflg & F_PIPEIN) {
630 	    xclose(pipein[0]);
631 	    xclose(pipein[1]);
632 	}
633 #else /* !BACKPIPE */
634 	if (t->t_dflg & F_PIPEOUT) {
635 	    xclose(pipeout[0]);
636 	    xclose(pipeout[1]);
637 	}
638 #endif /* BACKPIPE */
639 	/*
640 	 * Perform a builtin function. If we are not forked, arrange for
641 	 * possible stopping
642 	 */
643 	if (bifunc) {
644 	    if (forked) {
645 		func(t, bifunc);
646 		exitstat();
647 	    } else {
648 		jmp_buf_t oldexit;
649 		int ohaderr = haderr;
650 
651 		getexit(oldexit);
652 		if (setexit() == 0)
653 		    func(t, bifunc);
654 		resexit(oldexit);
655 		haderr = ohaderr;
656 
657 		if (adrof(STRprintexitvalue)) {
658 		    int rv = getn(varval(STRstatus));
659 		    if (rv != 0)
660 			xprintf(CGETS(17, 2, "Exit %d\n"), rv);
661 		}
662 	    }
663 	    break;
664 	}
665 	if (t->t_dtyp != NODE_PAREN) {
666 	    doexec(t, do_glob);
667 	    /* NOTREACHED */
668 	}
669 	/*
670 	 * For () commands must put new 0,1,2 in FSH* and recurse
671 	 */
672 	if ((OLDSTD = dcopy(0, FOLDSTD)) >= 0)
673 	    (void)close_on_exec(OLDSTD, 1);
674 	if ((SHOUT = dcopy(1, FSHOUT)) >= 0) {
675 	    (void)close_on_exec(SHOUT, 1);
676 	    isoutatty = isatty(SHOUT);
677 	}
678 	if ((SHDIAG = dcopy(2, FSHDIAG)) >= 0) {
679 	    (void)close_on_exec(SHDIAG, 1);
680 	    isdiagatty = isatty(SHDIAG);
681     	}
682 	xclose(SHIN);
683 	SHIN = -1;
684 #ifndef CLOSE_ON_EXEC
685 	didcch = 0;
686 #else
687 	(void) close_on_exec(FSHOUT, 1);
688 	(void) close_on_exec(FSHDIAG, 1);
689 	(void) close_on_exec(FOLDSTD, 1);
690 #endif /* !CLOSE_ON_EXEC */
691 	didfds = 0;
692 	wanttty = -1;
693 	t->t_dspr->t_dflg |= t->t_dflg & (F_NOINTERRUPT | F_BACKQ);
694 	execute(t->t_dspr, wanttty, NULL, NULL, do_glob);
695 	exitstat();
696 
697     case NODE_PIPE:
698 #ifdef BACKPIPE
699 	t->t_dcdr->t_dflg |= F_PIPEIN | (t->t_dflg &
700 	    (F_PIPEOUT | F_AMPERSAND | F_NOFORK | F_NOINTERRUPT | F_BACKQ));
701 	execute(t->t_dcdr, wanttty, pv, pipeout, do_glob);
702 	t->t_dcar->t_dflg |= F_PIPEOUT | (t->t_dflg &
703 	    (F_PIPEIN | F_AMPERSAND | F_STDERR | F_NOINTERRUPT | F_BACKQ));
704 	execute(t->t_dcar, wanttty, pipein, pv, do_glob);
705 #else /* !BACKPIPE */
706 	t->t_dcar->t_dflg |= F_PIPEOUT | (t->t_dflg &
707 	    (F_PIPEIN | F_AMPERSAND | F_STDERR | F_NOINTERRUPT | F_BACKQ));
708 	execute(t->t_dcar, wanttty, pipein, pv, do_glob);
709 	t->t_dcdr->t_dflg |= F_PIPEIN | (t->t_dflg &
710 	    (F_PIPEOUT | F_AMPERSAND | F_NOFORK | F_NOINTERRUPT | F_BACKQ));
711 	execute(t->t_dcdr, wanttty, pv, pipeout, do_glob);
712 #endif /* BACKPIPE */
713 	break;
714 
715     case NODE_LIST:
716 	if (t->t_dcar) {
717 	    t->t_dcar->t_dflg |= t->t_dflg & (F_NOINTERRUPT | F_BACKQ);
718 	    execute(t->t_dcar, wanttty, NULL, NULL, do_glob);
719 	    /*
720 	     * In strange case of A&B make a new job after A
721 	     */
722 	    if (t->t_dcar->t_dflg & F_AMPERSAND && t->t_dcdr &&
723 		(t->t_dcdr->t_dflg & F_AMPERSAND) == 0)
724 		pendjob();
725 	}
726 	if (t->t_dcdr) {
727 	    t->t_dcdr->t_dflg |= t->t_dflg &
728 		(F_NOFORK | F_NOINTERRUPT | F_BACKQ);
729 	    execute(t->t_dcdr, wanttty, NULL, NULL, do_glob);
730 	}
731 	break;
732 
733     case NODE_OR:
734     case NODE_AND:
735 	if (t->t_dcar) {
736 	    t->t_dcar->t_dflg |= t->t_dflg & (F_NOINTERRUPT | F_BACKQ);
737 	    execute(t->t_dcar, wanttty, NULL, NULL, do_glob);
738 	    if ((getn(varval(STRstatus)) == 0) !=
739 		(t->t_dtyp == NODE_AND)) {
740 		return;
741 	    }
742 	}
743 	if (t->t_dcdr) {
744 	    t->t_dcdr->t_dflg |= t->t_dflg &
745 		(F_NOFORK | F_NOINTERRUPT | F_BACKQ);
746 	    execute(t->t_dcdr, wanttty, NULL, NULL, do_glob);
747 	}
748 	break;
749 
750     default:
751 	break;
752     }
753     /*
754      * Fall through for all breaks from switch
755      *
756      * If there will be no more executions of this command, flush all file
757      * descriptors. Places that turn on the F_REPEAT bit are responsible for
758      * doing donefds after the last re-execution
759      */
760     if (didfds && !(t->t_dflg & F_REPEAT))
761 	donefds();
762 }
763 
764 #ifdef VFORK
765 static void
766 /*ARGSUSED*/
vffree(int snum)767 vffree(int snum)
768 {
769     USE(snum);
770 
771     _exit(1);
772 }
773 #endif /* VFORK */
774 
775 /*
776  * Expand and glob the words after an i/o redirection.
777  * If more than one word is generated, then update the command vector.
778  *
779  * This is done differently in all the shells:
780  * 1. in the bourne shell and ksh globbing is not performed
781  * 2. Bash/csh say ambiguous
782  * 3. zsh does i/o to/from all the files
783  * 4. itcsh concatenates the words.
784  *
785  * I don't know what is best to do. I think that Ambiguous is better
786  * than restructuring the command vector, because the user can get
787  * unexpected results. In any case, the command vector restructuring
788  * code is present and the user can choose it by setting noambiguous
789  */
790 static Char *
splicepipe(struct command * t,Char * cp)791 splicepipe(struct command *t, Char *cp)
792 {
793     Char *blk[2];
794 
795     if (adrof(STRnoambiguous)) {
796 	Char **pv;
797 	int gflag;
798 
799 	blk[0] = Dfix1(cp); /* expand $ */
800 	blk[1] = NULL;
801 
802 	gflag = tglob(blk);
803 	if (gflag) {
804 	    pv = globall(blk, gflag);
805 	    if (pv == NULL) {
806 		setname(short2str(blk[0]));
807 		xfree(blk[0]);
808 		stderror(ERR_NAME | ERR_NOMATCH);
809 	    }
810 	    if (pv[1] != NULL) { /* we need to fix the command vector */
811 		Char **av = blkspl(t->t_dcom, &pv[1]);
812 		xfree(t->t_dcom);
813 		t->t_dcom = av;
814 	    }
815 	    xfree(blk[0]);
816 	    blk[0] = pv[0];
817 	    xfree(pv);
818 	}
819     }
820     else {
821 	Char *buf;
822 
823 	buf = Dfix1(cp);
824 	cleanup_push(buf, xfree);
825 	blk[0] = globone(buf, G_ERROR);
826 	cleanup_until(buf);
827     }
828     return(blk[0]);
829 }
830 
831 /*
832  * Perform io redirection.
833  * We may or maynot be forked here.
834  */
835 static void
doio(struct command * t,int * pipein,int * pipeout)836 doio(struct command *t, int *pipein, int *pipeout)
837 {
838     int fd;
839     Char *cp;
840     unsigned long flags = t->t_dflg;
841 
842     if (didfds || (flags & F_REPEAT))
843 	return;
844     if ((flags & F_READ) == 0) {/* F_READ already done */
845 	if (t->t_dlef) {
846 	    char *tmp;
847 
848 	    /*
849 	     * so < /dev/std{in,out,err} work
850 	     */
851 	    (void) dcopy(SHIN, 0);
852 	    (void) dcopy(SHOUT, 1);
853 	    (void) dcopy(SHDIAG, 2);
854 	    cp = splicepipe(t, t->t_dlef);
855 	    tmp = strsave(short2str(cp));
856 	    xfree(cp);
857 	    cleanup_push(tmp, xfree);
858 	    if ((fd = xopen(tmp, O_RDONLY|O_LARGEFILE)) < 0)
859 		stderror(ERR_SYSTEM, tmp, strerror(errno));
860 	    cleanup_until(tmp);
861 	    /* allow input files larger than 2Gb  */
862 #ifndef WINNT_NATIVE
863 	    (void) fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_LARGEFILE);
864 #endif /*!WINNT_NATIVE*/
865 	    (void) dmove(fd, 0);
866 	}
867 	else if (flags & F_PIPEIN) {
868 	    xclose(0);
869 	    TCSH_IGNORE(dup(pipein[0]));
870 	    xclose(pipein[0]);
871 	    xclose(pipein[1]);
872 	}
873 	else if ((flags & F_NOINTERRUPT) && tpgrp == -1) {
874 	    xclose(0);
875 	    (void) xopen(_PATH_DEVNULL, O_RDONLY|O_LARGEFILE);
876 	}
877 	else {
878 	    xclose(0);
879 	    TCSH_IGNORE(dup(OLDSTD));
880 #if defined(CLOSE_ON_EXEC) && defined(CLEX_DUPS)
881 	    /*
882 	     * PWP: Unlike Bezerkeley 4.3, FIONCLEX for Pyramid is preserved
883 	     * across dup()s, so we have to UNSET it here or else we get a
884 	     * command with NO stdin, stdout, or stderr at all (a bad thing
885 	     * indeed)
886 	     */
887 	    (void) close_on_exec(0, 0);
888 #endif /* CLOSE_ON_EXEC && CLEX_DUPS */
889 	}
890     }
891     if (t->t_drit) {
892 	char *tmp;
893 
894 	cp = splicepipe(t, t->t_drit);
895 	tmp = strsave(short2str(cp));
896 	xfree(cp);
897 	cleanup_push(tmp, xfree);
898 	/*
899 	 * so > /dev/std{out,err} work
900 	 */
901 	(void) dcopy(SHOUT, 1);
902 	(void) dcopy(SHDIAG, 2);
903 	if ((flags & F_APPEND) != 0) {
904 #ifdef O_APPEND
905 	    fd = xopen(tmp, O_WRONLY|O_APPEND|O_LARGEFILE);
906 #else /* !O_APPEND */
907 	    fd = xopen(tmp, O_WRONLY|O_LARGEFILE);
908 	    (void) lseek(fd, (off_t) 0, L_XTND);
909 #endif /* O_APPEND */
910 	}
911 	else
912 	    fd = 0;
913 	if ((flags & F_APPEND) == 0 || fd == -1) {
914 	    if (!(flags & F_OVERWRITE) && no_clobber) {
915 		if (flags & F_APPEND)
916 		    stderror(ERR_SYSTEM, tmp, strerror(errno));
917 		chkclob(tmp);
918 	    }
919 	    if ((fd = xcreat(tmp, 0666)) < 0)
920 		stderror(ERR_SYSTEM, tmp, strerror(errno));
921 	    /* allow input files larger than 2Gb  */
922 #ifndef WINNT_NATIVE
923 	    (void) fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_LARGEFILE);
924 #endif /*!WINNT_NATIVE*/
925 	}
926 	cleanup_until(tmp);
927 	(void) dmove(fd, 1);
928 	is1atty = isatty(1);
929     }
930     else if (flags & F_PIPEOUT) {
931 	xclose(1);
932 	TCSH_IGNORE(dup(pipeout[1]));
933 	is1atty = 0;
934     }
935     else {
936 	xclose(1);
937 	TCSH_IGNORE(dup(SHOUT));
938 	is1atty = isoutatty;
939 # if defined(CLOSE_ON_EXEC) && defined(CLEX_DUPS)
940 	(void) close_on_exec(1, 0);
941 # endif /* CLOSE_ON_EXEC && CLEX_DUPS */
942     }
943 
944     xclose(2);
945     if (flags & F_STDERR) {
946 	TCSH_IGNORE(dup(1));
947 	is2atty = is1atty;
948     }
949     else {
950 	TCSH_IGNORE(dup(SHDIAG));
951 	is2atty = isdiagatty;
952 # if defined(CLOSE_ON_EXEC) && defined(CLEX_DUPS)
953 	(void) close_on_exec(2, 0);
954 # endif /* CLOSE_ON_EXEC && CLEX_DUPS */
955     }
956     didfds = 1;
957 }
958 
959 void
mypipe(int * pv)960 mypipe(int *pv)
961 {
962 
963     if (pipe(pv) < 0)
964 	goto oops;
965     (void)close_on_exec(pv[0] = dmove(pv[0], -1), 1);
966     (void)close_on_exec(pv[1] = dmove(pv[1], -1), 1);
967     if (pv[0] >= 0 && pv[1] >= 0)
968 	return;
969     if (pv[0] >= 0)
970 	xclose(pv[0]);
971     if (pv[1] >= 0)
972 	xclose(pv[1]);
973 oops:
974     stderror(ERR_PIPE);
975 }
976 
977 static void
chkclob(const char * cp)978 chkclob(const char *cp)
979 {
980     struct stat stb;
981 
982     if (stat(cp, &stb) < 0)
983 	return;
984     if (S_ISCHR(stb.st_mode))
985 	return;
986     if (no_clobber & NOCLOBBER_NOTEMPTY && stb.st_size == 0)
987 	return;
988     if (no_clobber & NOCLOBBER_ASK) {
989 	if (getYN(CGETS(22, 15,
990 	    "Do you really want to overwrite an existing file? [N/y] ")))
991 	    return;
992     }
993 
994     stderror(ERR_EXISTS, cp);
995 }
996