?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / cmd / sh / xec.c
blob2d3d6ebaf32b8615c29efb1efa501f86b78e5fd0
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
28 /* All Rights Reserved */
29
30 /*
31 *
32 * UNIX shell
33 *
34 */
35
36
37 #include "defs.h"
38 #include <errno.h>
39 #include "sym.h"
40 #include "hash.h"
41 #include <sys/types.h>
42 #include <sys/times.h>
43
44 pid_t parent;
45
46 void execprint(unsigned char **);
47
48 /* ======== command execution ======== */
49
50 /*VARARGS3*/
51 int
52 execute(argt, xflags, errorflg, pf1, pf2)
53 struct trenod *argt;
54 int xflags, errorflg;
55 int *pf1, *pf2;
56 {
57 /*
58 * `stakbot' is preserved by this routine
59 */
60 struct trenod *t;
61 unsigned char *sav = savstak();
62
63 sigchk();
64 if (!errorflg)
65 flags &= ~errflg;
66
67 if ((t = argt) && execbrk == 0) {
68 int treeflgs;
69 unsigned char **com;
70 int type;
71 short pos;
72
73 treeflgs = t->tretyp;
74 type = treeflgs & COMMSK;
75
76 switch (type)
77 {
78 case TFND:
79 {
80 struct fndnod *f = fndptr(t);
81 struct namnod *n = lookup(f->fndnam);
82
83 exitval = 0;
84
85 if (n->namflg & N_RDONLY)
86 failed(n->namid, wtfailed);
87
88 if (flags & rshflg && (n == &pathnod ||
89 eq(n->namid, "SHELL")))
90 failed(n->namid, restricted);
91 /*
92 * If function of same name is previously
93 * defined, it will no longer be used.
94 */
95 if (n->namflg & N_FUNCTN) {
96 freefunc(n);
97 } else {
98 free(n->namval);
99 free(n->namenv);
100
101 n->namval = 0;
102 n->namflg &= ~(N_EXPORT | N_ENVCHG);
103 }
104 /*
105 * If function is defined within function,
106 * we don't want to free it along with the
107 * free of the defining function. If we are
108 * in a loop, fndnod may be reused, so it
109 * should never be freed.
110 */
111 if (funcnt != 0 || loopcnt != 0)
112 f->fndref++;
113
114 /*
115 * We hang a fndnod on the namenv so that
116 * ref cnt(fndref) can be increased while
117 * running in the function.
118 */
119 n->namenv = (unsigned char *)f;
120 attrib(n, N_FUNCTN);
121 hash_func(n->namid);
122 break;
123 }
124
125 case TCOM:
126 {
127 unsigned char *a1, *name;
128 int argn, internal;
129 struct argnod *schain = gchain;
130 struct ionod *io = t->treio;
131 short cmdhash;
132 short comtype;
133
134 exitval = 0;
135
136 gchain = 0;
137 argn = getarg(t);
138 com = scan(argn);
139 a1 = com[1];
140 gchain = schain;
141
142 if (argn != 0)
143 cmdhash = pathlook(com[0], 1, comptr(t)->comset);
144
145 if (argn == 0 || (comtype = hashtype(cmdhash)) == BUILTIN) {
146 setlist(comptr(t)->comset, 0);
147 }
148
149 if (argn && (flags&noexec) == 0)
150 {
151
152 /* print command if execpr */
153 if (flags & execpr)
154 execprint(com);
155
156 if (comtype == NOTFOUND)
157 {
158 pos = hashdata(cmdhash);
159 if (pos == 1)
160 failure(*com, notfound);
161 else if (pos == 2)
162 failure(*com, badexec);
163 else
164 failure(*com, badperm);
165 break;
166 }
167
168 else if (comtype == PATH_COMMAND)
169 {
170 pos = -1;
171 }
172
173 else if (comtype & (COMMAND | REL_COMMAND))
174 {
175 pos = hashdata(cmdhash);
176 }
177
178 else if (comtype == BUILTIN) {
179 builtin(hashdata(cmdhash),argn,com,t);
180 freejobs();
181 break;
182 }
183 else if (comtype == FUNCTION)
184 {
185 struct dolnod *olddolh;
186 struct namnod *n, *opt;
187 struct fndnod *f;
188 short index;
189 unsigned char **olddolv = dolv;
190 int olddolc = dolc;
191
192 n = findnam(com[0]);
193 f = fndptr(n->namenv);
194 /* just in case */
195 if (f == NULL)
196 break;
197 /* save current positional parameters */
198 olddolh = (struct dolnod *)savargs(funcnt);
199 f->fndref++;
200 funcnt++;
201 index = initio(io, 1);
202 setargs(com);
203 execute(f->fndval, xflags,
204 errorflg, pf1, pf2);
205 execbrk = 0;
206 restore(index);
207 (void) restorargs(olddolh, funcnt);
208 dolv = olddolv;
209 dolc = olddolc;
210 funcnt--;
211 /*
212 * n->namenv may have been
213 * pointing different func.
214 * Therefore, we can't use
215 * freefunc(n).
216 */
217 freetree((struct trenod *)f);
218
219 break;
220 }
221 }
222 else if (t->treio == 0)
223 {
224 chktrap();
225 break;
226 }
227
228 }
229
230 case TFORK:
231 {
232 int monitor = 0;
233 int linked = 0;
234
235 exitval = 0;
236
237 if (!(xflags & XEC_EXECED) || treeflgs&(FPOU|FAMP))
238 {
239
240 int forkcnt = 1;
241
242 if (!(treeflgs&FPOU))
243 {
244 monitor = (!(xflags & XEC_NOSTOP)
245 && (flags&(monitorflg|jcflg|jcoff))
246 == (monitorflg|jcflg));
247 if (monitor) {
248 int savefd;
249 unsigned char *savebot;
250 savefd = setb(-1);
251 savebot = stakbot;
252 prcmd(t);
253 (void)setb(savefd);
254 allocjob(savebot, cwdget(), monitor);
255 } else
256 allocjob("", "", 0);
257
258 }
259
260 if (treeflgs & (FPOU|FAMP)) {
261 link_iodocs(iotemp);
262 linked = 1;
263 }
264
265 while ((parent = fork()) == -1)
266 {
267 /*
268 * FORKLIM is the max period between forks -
269 * power of 2 usually. Currently shell tries
270 * after 2,4,8,16, and 32 seconds and then quits
271 */
272
273 if ((forkcnt = (forkcnt * 2)) > FORKLIM)
274 {
275 switch (errno)
276 {
277 case ENOMEM:
278 deallocjob();
279 error(noswap);
280 break;
281 default:
282 deallocjob();
283 error(nofork);
284 break;
285 }
286 } else if (errno == EPERM) {
287 deallocjob();
288 error(eacces);
289 break;
290 }
291 sigchk();
292 sh_sleep(forkcnt);
293 }
294
295 if (parent) {
296 if (monitor)
297 setpgid(parent, 0);
298 if (treeflgs & FPIN)
299 closepipe(pf1);
300 if (!(treeflgs&FPOU)) {
301 postjob(parent,!(treeflgs&FAMP));
302 freejobs();
303 }
304 chktrap();
305 break;
306 }
307 mypid = getpid();
308 }
309
310 /*
311 * Forked process: assume it is not a subshell for
312 * now. If it is, the presence of a left parenthesis
313 * will trigger the jcoff flag to be turned off.
314 * When jcoff is turned on, monitoring is not going on
315 * and waitpid will not look for WUNTRACED.
316 */
317
318 flags |= (forked|jcoff);
319
320 fiotemp = 0;
321
322 if (linked == 1) {
323 swap_iodoc_nm(iotemp);
324 xflags |= XEC_LINKED;
325 } else if (!(xflags & XEC_LINKED))
326 iotemp = 0;
327 #ifdef ACCT
328 suspacct();
329 #endif
330 settmp();
331 oldsigs();
332
333 if (!(treeflgs & FPOU))
334 makejob(monitor, !(treeflgs & FAMP));
335
336 /*
337 * pipe in or out
338 */
339 if (treeflgs & FPIN)
340 {
341 renamef(pf1[INPIPE], 0);
342 close(pf1[OTPIPE]);
343 }
344
345 if (treeflgs & FPOU)
346 {
347 close(pf2[INPIPE]);
348 renamef(pf2[OTPIPE], 1);
349 }
350
351 /*
352 * io redirection
353 */
354 initio(t->treio, 0);
355
356 if (type == TFORK)
357 execute(forkptr(t)->forktre, xflags | XEC_EXECED, errorflg);
358 else if (com[0] != ENDARGS)
359 {
360 eflag = 0;
361 setlist(comptr(t)->comset, N_EXPORT);
362 rmtemp(0);
363 clearjobs();
364 execa(com, pos);
365 }
366 done(0);
367 }
368
369 case TPAR:
370 /* Forked process is subshell: may want job control */
371 flags &= ~jcoff;
372 clearjobs();
373 execute(parptr(t)->partre, xflags, errorflg);
374 done(0);
375
376 case TFIL:
377 {
378 int pv[2];
379
380 chkpipe(pv);
381 if (execute(lstptr(t)->lstlef, xflags & XEC_NOSTOP, errorflg, pf1, pv) == 0)
382 execute(lstptr(t)->lstrit, xflags, errorflg, pv, pf2);
383 else
384 closepipe(pv);
385 }
386 break;
387
388 case TLST:
389 execute(lstptr(t)->lstlef, xflags&XEC_NOSTOP, errorflg);
390 /* Update errorflg if set -e is invoked in the sub-sh*/
391 execute(lstptr(t)->lstrit, xflags, (errorflg | (eflag & errflg)));
392 break;
393
394 case TAND:
395 case TORF:
396 {
397 int xval;
398 xval = execute(lstptr(t)->lstlef, XEC_NOSTOP, 0);
399 if ((xval == 0) == (type == TAND))
400 execute(lstptr(t)->lstrit, xflags|XEC_NOSTOP, errorflg);
401 break;
402 }
403
404 case TFOR:
405 {
406 struct namnod *n = lookup(forptr(t)->fornam);
407 unsigned char **args;
408 struct dolnod *argsav = 0;
409
410 if (forptr(t)->forlst == 0)
411 {
412 args = dolv + 1;
413 argsav = useargs();
414 }
415 else
416 {
417 struct argnod *schain = gchain;
418
419 gchain = 0;
420 args = scan(getarg(forptr(t)->forlst));
421 gchain = schain;
422 }
423 loopcnt++;
424 while (*args != ENDARGS && execbrk == 0)
425 {
426 assign(n, *args++);
427 execute(forptr(t)->fortre, XEC_NOSTOP, errorflg);
428 if (breakcnt < 0)
429 execbrk = (++breakcnt != 0);
430 }
431 if (breakcnt > 0)
432 execbrk = (--breakcnt != 0);
433
434 loopcnt--;
435 if(argsav)
436 argfor = (struct dolnod *)freeargs(argsav);
437 }
438 break;
439
440 case TWH:
441 case TUN:
442 {
443 int i = 0;
444
445 loopcnt++;
446 while (execbrk == 0 && (execute(whptr(t)->whtre,
447 XEC_NOSTOP, 0) == 0) == (type == TWH) &&
448 (flags&noexec) == 0)
449 {
450 i = execute(whptr(t)->dotre, XEC_NOSTOP, errorflg);
451 if (breakcnt < 0)
452 execbrk = (++breakcnt != 0);
453 }
454 if (breakcnt > 0)
455 execbrk = (--breakcnt != 0);
456
457 loopcnt--;
458 exitval = i;
459 }
460 break;
461
462 case TIF:
463 if (execute(ifptr(t)->iftre, XEC_NOSTOP, 0) == 0)
464 execute(ifptr(t)->thtre, xflags|XEC_NOSTOP, errorflg);
465 else if (ifptr(t)->eltre)
466 execute(ifptr(t)->eltre, xflags|XEC_NOSTOP, errorflg);
467 else
468 exitval = 0; /* force zero exit for if-then-fi */
469 break;
470
471 case TSW:
472 {
473 unsigned char *r = mactrim(swptr(t)->swarg);
474 struct regnod *regp;
475
476 regp = swptr(t)->swlst;
477 while (regp)
478 {
479 struct argnod *rex = regp->regptr;
480
481 while (rex)
482 {
483 unsigned char *s;
484
485 if (gmatch(r, s = macro(rex->argval)) || (trim(s), eq(r, s)))
486 {
487 execute(regp->regcom, XEC_NOSTOP, errorflg);
488 regp = 0;
489 break;
490 }
491 else
492 rex = rex->argnxt;
493 }
494 if (regp)
495 regp = regp->regnxt;
496 }
497 }
498 break;
499 }
500 exitset();
501 }
502 sigchk();
503 tdystak(sav);
504 flags |= eflag;
505 return(exitval);
506 }
507
508 void
509 execexp(unsigned char *s, int f)
510 {
511 struct fileblk fb;
512
513 push(&fb);
514 if (s)
515 {
516 estabf(s);
517 fb.feval = (unsigned char **)(f);
518 }
519 else if (f >= 0)
520 initf(f);
521 execute(cmd(NL, NLFLG | MTFLG), 0, (int)(flags & errflg));
522 pop();
523 }
524
525 void
526 execprint(unsigned char **com)
527 {
528 int argn = 0;
529 unsigned char *s;
530
531 prs(_gettext(execpmsg));
532 while(com[argn] != ENDARGS)
533 {
534 s = com[argn++];
535 write(output, s, length(s) - 1);
536 blank();
537 }
538
539 newline();
540 }
unleashed repo fork