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