[unix-history] / usr / src / cmd / csh / sh.sem.c

static	char *sccsid = "@(#)sh.sem.c 4.1 10/9/80";

#include "sh.h"
#include "sh.proc.h"
#include <sys/ioctl.h>

/*
 * C shell
 */

/*VARARGS 1*/
execute(t, wanttty, pipein, pipeout)
	register struct command *t;
	int wanttty, *pipein, *pipeout;
{
	bool forked = 0;
	struct biltins *bifunc;
	int pid = 0;
	int pv[2];

	if (t == 0)
		return;
	if ((t->t_dflg & FAND) && wanttty > 0)
		wanttty = 0;
	switch (t->t_dtyp) {

	case TCOM:
		if ((t->t_dcom[0][0] & (QUOTE|TRIM)) == QUOTE)
			strcpy(t->t_dcom[0], t->t_dcom[0] + 1);
		if ((t->t_dflg & FREDO) == 0)
			Dfix(t);		/* $ " ' \ */
		if (t->t_dcom[0] == 0)
			return;
		/* fall into... */

	case TPAR:
		if (t->t_dflg & FPOU)
			mypipe(pipeout);
		/*
		 * Must do << early so parent will know
		 * where input pointer should be.
		 * If noexec then this is all we do.
		 */
		if (t->t_dflg & FHERE) {
			close(0);
			heredoc(t->t_dlef);
			if (noexec)
				close(0);
		}
		if (noexec)
			break;

		set("status", "0");

		/*
		 * This mess is the necessary kludge to handle the prefix
		 * builtins: nice, nohup, time.  These commands can also
		 * be used by themselves, and this is not handled here.
		 * This will also work when loops are parsed.
		 */
		while (t->t_dtyp == TCOM)
			if (eq(t->t_dcom[0], "nice"))
				if (t->t_dcom[1])
					if (any(t->t_dcom[1][0], "+-"))
						if (t->t_dcom[2]) {
							setname("nice");
							t->t_nice = getn(t->t_dcom[1]);
							lshift(t->t_dcom, 2);
							t->t_dflg |= FNICE;
						} else
							break;
					else {
						t->t_nice = 4;
						lshift(t->t_dcom, 1);
						t->t_dflg |= FNICE;
					}
				else
					break;
			else if (eq(t->t_dcom[0], "nohup"))
				if (t->t_dcom[1]) {
					t->t_dflg |= FNOHUP;
					lshift(t->t_dcom, 1);
				} else
					break;
			else if (eq(t->t_dcom[0], "time"))
				if (t->t_dcom[1]) {
					t->t_dflg |= FTIME;
					lshift(t->t_dcom, 1);
				} else
					break;
			else
				break;
		/*
		 * Check if we have a builtin function and remember which one.
		 */
		bifunc = t->t_dtyp == TCOM ? isbfunc(t) : (struct biltins *) 0;

		/*
		 * We fork only if we are timed, or are not the end of
		 * a parenthesized list and not a simple builtin function.
		 * Simple meaning one that is not pipedout, niced, nohupped,
		 * or &'d.
		 * It would be nice(?) to not fork in some of these cases.
		 */
		if (((t->t_dflg & FTIME) || (t->t_dflg & FPAR) == 0 &&
		     (!bifunc || t->t_dflg & (FPOU|FAND|FNICE|FNOHUP))))
#ifdef VFORK
		    if (t->t_dtyp == TPAR || t->t_dflg&(FREDO|FAND) || bifunc)
#endif
			{ forked++; pid = pfork(t, wanttty); }
#ifdef VFORK
		    else {
			int vffree();
			int ochild, osetintr, ohaderr, odidfds, odidcch;
			int oSHIN, oSHOUT, oSHDIAG, oOLDSTD, otpgrp;

			sighold(SIGCHLD);
			ochild = child; osetintr = setintr;
			ohaderr = haderr; odidfds = didfds; odidcch = didcch;
			oSHIN = SHIN; oSHOUT = SHOUT;
			oSHDIAG = SHDIAG; oOLDSTD = OLDSTD; otpgrp = tpgrp;
			Vsav = Vdp = 0; Vav = 0;
			pid = vfork();
			if (pid < 0) {
				sigrelse(SIGCHLD);
				error("No more processes");
			}
			forked++;
			if (pid) {
				child = ochild; setintr = osetintr;
				haderr = ohaderr; didfds = odidfds;
				didcch = odidcch; SHIN = oSHIN;
				SHOUT = oSHOUT; SHDIAG = oSHDIAG;
				OLDSTD = oOLDSTD; tpgrp = otpgrp;
				xfree(Vsav); Vsav = 0;
				xfree(Vdp); Vdp = 0;
				xfree(Vav); Vav = 0;
				/* this is from pfork() */
				palloc(pid, t);
				sigrelse(SIGCHLD);
			} else {
				/* this is from pfork() */
				int pgrp;
				bool ignint = 0;

				if (setintr)
					ignint =
					    (tpgrp == -1 && (t->t_dflg&FINT))
					    || gointr && eq(gointr, "-");
				pgrp = pcurrjob ? pcurrjob->p_jobid : getpid();
				child++;
				if (setintr) {
					setintr = 0;
					sigsys(SIGCHLD, SIG_DFL);
					sigsys(SIGINT, ignint ? SIG_IGN : vffree);
					sigsys(SIGQUIT, ignint ? SIG_IGN : SIG_DFL);
					if (wanttty >= 0) {
						sigsys(SIGTSTP, SIG_DFL);
						sigsys(SIGTTIN, SIG_DFL);
						sigsys(SIGTTOU, SIG_DFL);
					}
					sigsys(SIGTERM, parterm);
				} else if (tpgrp == -1 && (t->t_dflg&FINT)) {
					sigsys(SIGINT, SIG_IGN);
					sigsys(SIGQUIT, SIG_IGN);
				}
				if (wanttty > 0)
					ioctl(FSHTTY, TIOCSPGRP, &pgrp);
				if (wanttty >= 0 && tpgrp >= 0)
					setpgrp(0, pgrp);
				if (tpgrp > 0)
					tpgrp = 0;
				if (t->t_dflg & FNOHUP)
					sigsys(SIGHUP, SIG_IGN);
				if (t->t_dflg & FNICE)
					nice(t->t_nice);
			}

		}
#endif
		if (pid != 0) {
			/*
			 * It would be better if we could wait for the
			 * whole job when we knew the last process
			 * had been started.  Pwait, in fact, does
			 * wait for the whole job anyway, but this test
			 * doesn't really express our intentions.
			 */
			if (didfds==0 && t->t_dflg&FPIN)
				close(pipein[0]), close(pipein[1]);
			if ((t->t_dflg & (FPOU|FAND)) == 0)
				pwait();
			break;
		}
		doio(t, pipein, pipeout);
		if (t->t_dflg & FPOU)
			close(pipeout[0]), close(pipeout[1]);

		/*
		 * Perform a builtin function.
		 * If we are not forked, arrange for possible stopping
		 */
		if (bifunc) {
			func(t, bifunc);
			if (forked)
				exitstat();
			break;
		}
		if (t->t_dtyp != TPAR) {
			doexec(t);
			/*NOTREACHED*/
		}
		/*
		 * For () commands must put new 0,1,2 in FSH* and recurse
		 */
		OLDSTD = dcopy(0, FOLDSTD);
		SHOUT = dcopy(1, FSHOUT);
		SHDIAG = dcopy(2, FSHDIAG);
		close(SHIN), SHIN = -1;
		didcch = 0, didfds = 0;
		wanttty = -1;
		t->t_dspr->t_dflg |= t->t_dflg & FINT;
		execute(t->t_dspr, wanttty);
		exitstat();

	case TFIL:
		t->t_dcar->t_dflg |= FPOU |
		    (t->t_dflg & (FPIN|FAND|FDIAG|FINT));
		execute(t->t_dcar, wanttty, pipein, pv);
		t->t_dcdr->t_dflg |= FPIN |
		    (t->t_dflg & (FPOU|FAND|FPAR|FINT));
		if (wanttty > 0)
			wanttty = 0;		/* got tty already */
		execute(t->t_dcdr, wanttty, pv, pipeout);
		break;

	case TLST:
		if (t->t_dcar) {
			t->t_dcar->t_dflg |= t->t_dflg & FINT;
			execute(t->t_dcar, wanttty);
			/*
			 * In strange case of A&B make a new job after A
			 */
			if (t->t_dcar->t_dflg&FAND && t->t_dcdr &&
			    (t->t_dcdr->t_dflg&FAND) == 0)
				pendjob();
		}
		if (t->t_dcdr) {
			t->t_dcdr->t_dflg |= t->t_dflg & (FPAR|FINT);
			execute(t->t_dcdr, wanttty);
		}
		break;

	case TOR:
	case TAND:
		if (t->t_dcar) {
			t->t_dcar->t_dflg |= t->t_dflg & FINT;
			execute(t->t_dcar, wanttty);
			if ((getn(value("status")) == 0) != (t->t_dtyp == TAND))
				return;
		}
		if (t->t_dcdr) {
			t->t_dcdr->t_dflg |= t->t_dflg & (FPAR|FINT);
			execute(t->t_dcdr, wanttty);
		}
		break;
	}
	/*
	 * Fall through for all breaks from switch
	 *
	 * If there will be no more executions of this
	 * command, flush all file descriptors.
	 * Places that turn on the FREDO bit are responsible
	 * for doing donefds after the last re-execution
	 */
	if (didfds && !(t->t_dflg & FREDO))
		donefds();
}

#ifdef VFORK
vffree()
{
	register char **v;

	if (v = gargv)
		gargv = 0, xfree(gargv);
	if (v = pargv)
		pargv = 0, xfree(pargv);
	_exit(1);
}
#endif

/*
 * Perform io redirection.
 * We may or maynot be forked here.
 */
doio(t, pipein, pipeout)
	register struct command *t;
	int *pipein, *pipeout;
{
	register char *cp;
	register int flags = t->t_dflg;

	if (didfds || (flags & FREDO))
		return;
	if ((flags & FHERE) == 0) {	/* FHERE already done */
		close(0);
		if (cp = t->t_dlef) {
			cp = globone(Dfix1(cp));
			xfree(cp);
			if (open(cp, 0) < 0)
				Perror(cp);
		} else if (flags & FPIN)
			dup(pipein[0]), close(pipein[0]), close(pipein[1]);
		else if ((flags & FINT) && tpgrp == -1)
			close(0), open("/dev/null", 0);
		else
			dup(OLDSTD);
	}
	close(1);
	if (cp = t->t_drit) {
		cp = globone(Dfix1(cp));
		xfree(cp);
		if ((flags & FCAT) && open(cp, 1) >= 0)
			lseek(1, 0l, 2);
		else {
			if (!(flags & FANY) && adrof("noclobber")) {
				if (flags & FCAT)
					Perror(cp);
				chkclob(cp);
			}
			if (creat(cp, 0666) < 0)
				Perror(cp);
		}
	} else if (flags & FPOU)
		dup(pipeout[1]);
	else
		dup(SHOUT);

	close(2);
	dup((flags & FDIAG) ? 1 : SHDIAG);
	didfds = 1;
}

mypipe(pv)
	register int *pv;
{

	if (pipe(pv) < 0)
		goto oops;
	pv[0] = dmove(pv[0], -1);
	pv[1] = dmove(pv[1], -1);
	if (pv[0] >= 0 && pv[1] >= 0)
		return;
oops:
	error("Can't make pipe");
}

chkclob(cp)
	register char *cp;
{
	struct stat stb;

	if (stat(cp, &stb) < 0)
		return;
	if ((stb.st_mode & S_IFMT) == S_IFCHR)
		return;
	error("%s: File exists", cp);
}
Commit	Line	Data
31cef89c	1	static char *sccsid = "@(#)sh.sem.c 4.1 10/9/80";
e0cb907a BJ	2
	3	#include "sh.h"
	4	#include "sh.proc.h"
	5	#include <sys/ioctl.h>
	6
	7	/*
	8	* C shell
	9	*/
	10
	11	/VARARGS 1/
	12	execute(t, wanttty, pipein, pipeout)
	13	register struct command *t;
	14	int wanttty, pipein, pipeout;
	15	{
	16	bool forked = 0;
	17	struct biltins *bifunc;
	18	int pid = 0;
	19	int pv[2];
	20
	21	if (t == 0)
	22	return;
	23	if ((t->t_dflg & FAND) && wanttty > 0)
	24	wanttty = 0;
	25	switch (t->t_dtyp) {
	26
	27	case TCOM:
	28	if ((t->t_dcom[0][0] & (QUOTE\|TRIM)) == QUOTE)
	29	strcpy(t->t_dcom[0], t->t_dcom[0] + 1);
	30	if ((t->t_dflg & FREDO) == 0)
	31	Dfix(t); /* $ " ' \ */
	32	if (t->t_dcom[0] == 0)
	33	return;
	34	/* fall into... */
	35
	36	case TPAR:
	37	if (t->t_dflg & FPOU)
	38	mypipe(pipeout);
	39	/*
	40	* Must do << early so parent will know
	41	* where input pointer should be.
	42	* If noexec then this is all we do.
	43	*/
	44	if (t->t_dflg & FHERE) {
	45	close(0);
	46	heredoc(t->t_dlef);
	47	if (noexec)
	48	close(0);
	49	}
	50	if (noexec)
	51	break;
	52
	53	set("status", "0");
	54
	55	/*
	56	* This mess is the necessary kludge to handle the prefix
	57	* builtins: nice, nohup, time. These commands can also
	58	* be used by themselves, and this is not handled here.
	59	* This will also work when loops are parsed.
	60	*/
	61	while (t->t_dtyp == TCOM)
	62	if (eq(t->t_dcom[0], "nice"))
	63	if (t->t_dcom[1])
	64	if (any(t->t_dcom[1][0], "+-"))
	65	if (t->t_dcom[2]) {
66	setname("nice");
67	t->t_nice = getn(t->t_dcom[1]);
68	lshift(t->t_dcom, 2);
69	t->t_dflg \|= FNICE;
70	} else
71	break;
72	else {
73	t->t_nice = 4;
74	lshift(t->t_dcom, 1);
75	t->t_dflg \|= FNICE;
76	}
77	else
78	break;
79	else if (eq(t->t_dcom[0], "nohup"))
80	if (t->t_dcom[1]) {
81	t->t_dflg \|= FNOHUP;
82	lshift(t->t_dcom, 1);
83	} else
84	break;
85	else if (eq(t->t_dcom[0], "time"))
86	if (t->t_dcom[1]) {
87	t->t_dflg \|= FTIME;
88	lshift(t->t_dcom, 1);
89	} else
90	break;
91	else
92	break;
93	/*
94	* Check if we have a builtin function and remember which one.
95	*/
96	bifunc = t->t_dtyp == TCOM ? isbfunc(t) : (struct biltins *) 0;
97
98	/*
99	* We fork only if we are timed, or are not the end of
100	* a parenthesized list and not a simple builtin function.
101	* Simple meaning one that is not pipedout, niced, nohupped,
102	* or &'d.
103	* It would be nice(?) to not fork in some of these cases.
104	*/
105	if (((t->t_dflg & FTIME) \|\| (t->t_dflg & FPAR) == 0 &&
106	(!bifunc \|\| t->t_dflg & (FPOU\|FAND\|FNICE\|FNOHUP))))
107	#ifdef VFORK
108	if (t->t_dtyp == TPAR \|\| t->t_dflg&(FREDO\|FAND) \|\| bifunc)
109	#endif
110	{ forked++; pid = pfork(t, wanttty); }
111	#ifdef VFORK
112	else {
113	int vffree();
114	int ochild, osetintr, ohaderr, odidfds, odidcch;
115	int oSHIN, oSHOUT, oSHDIAG, oOLDSTD, otpgrp;
116
117	sighold(SIGCHLD);
118	ochild = child; osetintr = setintr;
119	ohaderr = haderr; odidfds = didfds; odidcch = didcch;
120	oSHIN = SHIN; oSHOUT = SHOUT;
121	oSHDIAG = SHDIAG; oOLDSTD = OLDSTD; otpgrp = tpgrp;
122	Vsav = Vdp = 0; Vav = 0;
123	pid = vfork();
124	if (pid < 0) {
125	sigrelse(SIGCHLD);
126	error("No more processes");
127	}
128	forked++;
129	if (pid) {
130	child = ochild; setintr = osetintr;
131	haderr = ohaderr; didfds = odidfds;
132	didcch = odidcch; SHIN = oSHIN;
133	SHOUT = oSHOUT; SHDIAG = oSHDIAG;
134	OLDSTD = oOLDSTD; tpgrp = otpgrp;
135	xfree(Vsav); Vsav = 0;
136	xfree(Vdp); Vdp = 0;
137	xfree(Vav); Vav = 0;
138	/* this is from pfork() */
139	palloc(pid, t);
140	sigrelse(SIGCHLD);
141	} else {
142	/* this is from pfork() */
143	int pgrp;
144	bool ignint = 0;
145
146	if (setintr)
147	ignint =
148	(tpgrp == -1 && (t->t_dflg&FINT))
149	\|\| gointr && eq(gointr, "-");
150	pgrp = pcurrjob ? pcurrjob->p_jobid : getpid();
151	child++;
152	if (setintr) {
153	setintr = 0;
154	sigsys(SIGCHLD, SIG_DFL);
155	sigsys(SIGINT, ignint ? SIG_IGN : vffree);
156	sigsys(SIGQUIT, ignint ? SIG_IGN : SIG_DFL);
157	if (wanttty >= 0) {
158	sigsys(SIGTSTP, SIG_DFL);
159	sigsys(SIGTTIN, SIG_DFL);
160	sigsys(SIGTTOU, SIG_DFL);
161	}
162	sigsys(SIGTERM, parterm);
163	} else if (tpgrp == -1 && (t->t_dflg&FINT)) {
164	sigsys(SIGINT, SIG_IGN);
165	sigsys(SIGQUIT, SIG_IGN);
166	}
167	if (wanttty > 0)
168	ioctl(FSHTTY, TIOCSPGRP, &pgrp);
169	if (wanttty >= 0 && tpgrp >= 0)
170	setpgrp(0, pgrp);
171	if (tpgrp > 0)
172	tpgrp = 0;
173	if (t->t_dflg & FNOHUP)
174	sigsys(SIGHUP, SIG_IGN);
175	if (t->t_dflg & FNICE)
176	nice(t->t_nice);
177	}
178
179	}
180	#endif
181	if (pid != 0) {
182	/*
183	* It would be better if we could wait for the
184	* whole job when we knew the last process
185	* had been started. Pwait, in fact, does
186	* wait for the whole job anyway, but this test
187	* doesn't really express our intentions.
188	*/
189	if (didfds==0 && t->t_dflg&FPIN)
190	close(pipein[0]), close(pipein[1]);
191	if ((t->t_dflg & (FPOU\|FAND)) == 0)
192	pwait();
193	break;
194	}
195	doio(t, pipein, pipeout);
196	if (t->t_dflg & FPOU)
197	close(pipeout[0]), close(pipeout[1]);
198
199	/*
200	* Perform a builtin function.
201	* If we are not forked, arrange for possible stopping
202	*/
203	if (bifunc) {
204	func(t, bifunc);
205	if (forked)
206	exitstat();
207	break;
208	}
209	if (t->t_dtyp != TPAR) {
210	doexec(t);
211	/NOTREACHED/
212	}
213	/*
214	* For () commands must put new 0,1,2 in FSH* and recurse
215	*/
216	OLDSTD = dcopy(0, FOLDSTD);
217	SHOUT = dcopy(1, FSHOUT);
218	SHDIAG = dcopy(2, FSHDIAG);
219	close(SHIN), SHIN = -1;
220	didcch = 0, didfds = 0;
221	wanttty = -1;
222	t->t_dspr->t_dflg \|= t->t_dflg & FINT;
223	execute(t->t_dspr, wanttty);
224	exitstat();
225
226	case TFIL:
227	t->t_dcar->t_dflg \|= FPOU \|
228	(t->t_dflg & (FPIN\|FAND\|FDIAG\|FINT));
229	execute(t->t_dcar, wanttty, pipein, pv);
230	t->t_dcdr->t_dflg \|= FPIN \|
231	(t->t_dflg & (FPOU\|FAND\|FPAR\|FINT));
232	if (wanttty > 0)
233	wanttty = 0; /* got tty already */
234	execute(t->t_dcdr, wanttty, pv, pipeout);
235	break;
236
237	case TLST:
238	if (t->t_dcar) {
239	t->t_dcar->t_dflg \|= t->t_dflg & FINT;
240	execute(t->t_dcar, wanttty);
241	/*
242	* In strange case of A&B make a new job after A
243	*/
244	if (t->t_dcar->t_dflg&FAND && t->t_dcdr &&
245	(t->t_dcdr->t_dflg&FAND) == 0)
246	pendjob();
247	}
248	if (t->t_dcdr) {
249	t->t_dcdr->t_dflg \|= t->t_dflg & (FPAR\|FINT);
250	execute(t->t_dcdr, wanttty);
251	}
252	break;
253
254	case TOR:
255	case TAND:
256	if (t->t_dcar) {
257	t->t_dcar->t_dflg \|= t->t_dflg & FINT;
258	execute(t->t_dcar, wanttty);
259	if ((getn(value("status")) == 0) != (t->t_dtyp == TAND))
260	return;
261	}
262	if (t->t_dcdr) {
263	t->t_dcdr->t_dflg \|= t->t_dflg & (FPAR\|FINT);
264	execute(t->t_dcdr, wanttty);
265	}
266	break;
267	}
268	/*
269	* Fall through for all breaks from switch
270	*
271	* If there will be no more executions of this
272	* command, flush all file descriptors.
273	* Places that turn on the FREDO bit are responsible
274	* for doing donefds after the last re-execution
275	*/
276	if (didfds && !(t->t_dflg & FREDO))
277	donefds();
278	}
279
280	#ifdef VFORK
281	vffree()
282	{
283	register char **v;
284
285	if (v = gargv)
286	gargv = 0, xfree(gargv);
287	if (v = pargv)
288	pargv = 0, xfree(pargv);
289	_exit(1);
290	}
291	#endif
292
293	/*
294	* Perform io redirection.
295	* We may or maynot be forked here.
296	*/
297	doio(t, pipein, pipeout)
298	register struct command *t;
299	int pipein, pipeout;
300	{
301	register char *cp;
302	register int flags = t->t_dflg;
303
304	if (didfds \|\| (flags & FREDO))
305	return;
306	if ((flags & FHERE) == 0) { /* FHERE already done */
307	close(0);
308	if (cp = t->t_dlef) {
309	cp = globone(Dfix1(cp));
310	xfree(cp);
311	if (open(cp, 0) < 0)
312	Perror(cp);
313	} else if (flags & FPIN)
314	dup(pipein[0]), close(pipein[0]), close(pipein[1]);
315	else if ((flags & FINT) && tpgrp == -1)
316	close(0), open("/dev/null", 0);
317	else
318	dup(OLDSTD);
319	}
320	close(1);
321	if (cp = t->t_drit) {
322	cp = globone(Dfix1(cp));
323	xfree(cp);
324	if ((flags & FCAT) && open(cp, 1) >= 0)
325	lseek(1, 0l, 2);
326	else {
327	if (!(flags & FANY) && adrof("noclobber")) {
328	if (flags & FCAT)
329	Perror(cp);
330	chkclob(cp);
331	}
332	if (creat(cp, 0666) < 0)
333	Perror(cp);
334	}
335	} else if (flags & FPOU)
336	dup(pipeout[1]);
337	else
338	dup(SHOUT);
339
340	close(2);
341	dup((flags & FDIAG) ? 1 : SHDIAG);
342	didfds = 1;
343	}
344
345	mypipe(pv)
346	register int *pv;
347	{
348
349	if (pipe(pv) < 0)
350	goto oops;
351	pv[0] = dmove(pv[0], -1);
352	pv[1] = dmove(pv[1], -1);
353	if (pv[0] >= 0 && pv[1] >= 0)
354	return;
355	oops:
356	error("Can't make pipe");
357	}
358
359	chkclob(cp)
360	register char *cp;
361	{
362	struct stat stb;
363
364	if (stat(cp, &stb) < 0)
365	return;
366	if ((stb.st_mode & S_IFMT) == S_IFCHR)
367	return;
368	error("%s: File exists", cp);
369	}