Annotation of pkgsrc/shells/pdksh/files/exec.c, revision 1.2
1.2 ! tnn 1: /* $NetBSD: exec.c,v 1.13 2006/04/24 19:58:20 christos Exp $ */
! 2:
1.1 tnn 3: /*
4: * execute command tree
5: */
1.2 ! tnn 6: #include <sys/cdefs.h>
! 7:
! 8: #ifndef lint
! 9: __RCSID("$NetBSD: exec.c,v 1.13 2006/04/24 19:58:20 christos Exp $");
! 10: #endif
! 11:
1.1 tnn 12:
13: #include "sh.h"
14: #include "c_test.h"
15: #include <ctype.h>
16: #include "ksh_stat.h"
17:
18: /* Does ps4 get parameter substitutions done? */
19: #ifdef KSH
20: # define PS4_SUBSTITUTE(s) substitute((s), 0)
21: #else
22: # define PS4_SUBSTITUTE(s) (s)
23: #endif /* KSH */
24:
1.2 ! tnn 25: static int comexec ARGS((struct op *, struct tbl *volatile, char **,
! 26: int volatile));
! 27: static void scriptexec ARGS((struct op *, char **));
! 28: static int call_builtin ARGS((struct tbl *, char **));
! 29: static int iosetup ARGS((struct ioword *, struct tbl *));
! 30: static int herein ARGS((const char *, int));
1.1 tnn 31: #ifdef KSH
1.2 ! tnn 32: static char *do_selectargs ARGS((char **, bool_t));
1.1 tnn 33: #endif /* KSH */
34: #ifdef KSH
1.2 ! tnn 35: static int dbteste_isa ARGS((Test_env *, Test_meta));
! 36: static const char *dbteste_getopnd ARGS((Test_env *, Test_op, int));
! 37: static int dbteste_eval ARGS((Test_env *, Test_op, const char *,
! 38: const char *, int));
! 39: static void dbteste_error ARGS((Test_env *, int, const char *));
1.1 tnn 40: #endif /* KSH */
41: #ifdef OS2
1.2 ! tnn 42: static int search_access1 ARGS((const char *, int, int *));
1.1 tnn 43: #endif /* OS2 */
44:
45:
46: /*
47: * handle systems that don't have F_SETFD
48: */
49: #ifndef F_SETFD
50: # ifndef MAXFD
51: # define MAXFD 64
52: # endif
53: /* a bit field would be smaller, but this will work */
54: static char clexec_tab[MAXFD+1];
55: #endif
56:
57: /*
58: * we now use this function always.
59: */
60: int
61: fd_clexec(fd)
62: int fd;
63: {
64: #ifndef F_SETFD
65: if (fd >= 0 && fd < sizeof(clexec_tab)) {
66: clexec_tab[fd] = 1;
67: return 0;
68: }
69: return -1;
70: #else
71: return fcntl(fd, F_SETFD, 1);
72: #endif
73: }
74:
75:
76: /*
77: * execute command tree
78: */
79: int
80: execute(t, flags)
81: struct op * volatile t;
82: volatile int flags; /* if XEXEC don't fork */
83: {
84: int i;
85: volatile int rv = 0;
86: int pv[2];
87: char ** volatile ap;
88: char *s, *cp;
89: struct ioword **iowp;
90: struct tbl *tp = NULL;
91:
92: if (t == NULL)
93: return 0;
94:
95: /* Is this the end of a pipeline? If so, we want to evaluate the
96: * command arguments
97: bool_t eval_done = FALSE;
98: if ((flags&XFORK) && !(flags&XEXEC) && (flags&XPCLOSE)) {
99: eval_done = TRUE;
100: tp = eval_execute_args(t, &ap);
101: }
102: */
103: if ((flags&XFORK) && !(flags&XEXEC) && t->type != TPIPE)
104: return exchild(t, flags & ~XTIME, -1); /* run in sub-process */
105:
106: newenv(E_EXEC);
107: if (trap)
108: runtraps(0);
1.2 ! tnn 109:
1.1 tnn 110: if (t->type == TCOM) {
111: /* Clear subst_exstat before argument expansion. Used by
112: * null commands (see comexec() and c_eval()) and by c_set().
113: */
114: subst_exstat = 0;
115:
116: current_lineno = t->lineno; /* for $LINENO */
117:
118: /* POSIX says expand command words first, then redirections,
119: * and assignments last..
120: */
121: ap = eval(t->args, t->u.evalflags | DOBLANK | DOGLOB | DOTILDE);
122: if (flags & XTIME)
123: /* Allow option parsing (bizarre, but POSIX) */
124: timex_hook(t, &ap);
125: if (Flag(FXTRACE) && ap[0]) {
126: shf_fprintf(shl_out, "%s",
127: PS4_SUBSTITUTE(str_val(global("PS4"))));
128: for (i = 0; ap[i]; i++)
129: shf_fprintf(shl_out, "%s%s", ap[i],
130: ap[i + 1] ? space : newline);
131: shf_flush(shl_out);
132: }
133: if (ap[0])
134: tp = findcom(ap[0], FC_BI|FC_FUNC);
135: }
136: flags &= ~XTIME;
137:
138: if (t->ioact != NULL || t->type == TPIPE || t->type == TCOPROC) {
139: e->savefd = (short *) alloc(sizeofN(short, NUFILE), ATEMP);
140: /* initialize to not redirected */
141: memset(e->savefd, 0, sizeofN(short, NUFILE));
142: }
143:
144: /* do redirection, to be restored in quitenv() */
145: if (t->ioact != NULL)
146: for (iowp = t->ioact; *iowp != NULL; iowp++) {
147: if (iosetup(*iowp, tp) < 0) {
148: exstat = rv = 1;
149: /* Redirection failures for special commands
150: * cause (non-interactive) shell to exit.
151: */
152: if (tp && tp->type == CSHELL
153: && (tp->flag & SPEC_BI))
154: errorf(null);
155: /* Deal with FERREXIT, quitenv(), etc. */
156: goto Break;
157: }
158: }
159:
160: switch(t->type) {
161: case TCOM:
162: rv = comexec(t, tp, ap, flags);
163: break;
164:
165: case TPAREN:
166: rv = execute(t->left, flags|XFORK);
167: break;
168:
169: case TPIPE:
170: flags |= XFORK;
171: flags &= ~XEXEC;
172: e->savefd[0] = savefd(0, 0);
173: (void) ksh_dup2(e->savefd[0], 0, FALSE); /* stdin of first */
174: e->savefd[1] = savefd(1, 0);
175: while (t->type == TPIPE) {
176: openpipe(pv);
177: (void) ksh_dup2(pv[1], 1, FALSE); /* stdout of curr */
178: /* Let exchild() close pv[0] in child
179: * (if this isn't done, commands like
180: * (: ; cat /etc/termcap) | sleep 1
181: * will hang forever).
182: */
183: exchild(t->left, flags|XPIPEO|XCCLOSE, pv[0]);
184: (void) ksh_dup2(pv[0], 0, FALSE); /* stdin of next */
185: closepipe(pv);
186: flags |= XPIPEI;
187: t = t->right;
188: }
189: restfd(1, e->savefd[1]); /* stdout of last */
190: e->savefd[1] = 0; /* no need to re-restore this */
191: /* Let exchild() close 0 in parent, after fork, before wait */
192: i = exchild(t, flags|XPCLOSE, 0);
193: if (!(flags&XBGND) && !(flags&XXCOM))
194: rv = i;
195: break;
196:
197: case TLIST:
198: while (t->type == TLIST) {
199: execute(t->left, flags & XERROK);
200: t = t->right;
201: }
202: rv = execute(t, flags & XERROK);
203: break;
204:
205: #ifdef KSH
206: case TCOPROC:
207: {
208: # ifdef JOB_SIGS
209: sigset_t omask;
210: # endif /* JOB_SIGS */
211:
212: # ifdef JOB_SIGS
213: /* Block sigchild as we are using things changed in the
214: * signal handler
215: */
216: sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
217: e->type = E_ERRH;
218: i = ksh_sigsetjmp(e->jbuf, 0);
219: if (i) {
220: sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0);
221: quitenv();
222: unwind(i);
223: /*NOTREACHED*/
224: }
225: # endif /* JOB_SIGS */
226: /* Already have a (live) co-process? */
227: if (coproc.job && coproc.write >= 0)
228: errorf("coprocess already exists");
229:
230: /* Can we re-use the existing co-process pipe? */
231: coproc_cleanup(TRUE);
232:
233: /* do this before opening pipes, in case these fail */
234: e->savefd[0] = savefd(0, 0);
235: e->savefd[1] = savefd(1, 0);
236:
237: openpipe(pv);
1.2 ! tnn 238: if (pv[0] != 0) {
! 239: ksh_dup2(pv[0], 0, FALSE);
! 240: close(pv[0]);
! 241: }
1.1 tnn 242: coproc.write = pv[1];
243: coproc.job = (void *) 0;
244:
245: if (coproc.readw >= 0)
246: ksh_dup2(coproc.readw, 1, FALSE);
247: else {
248: openpipe(pv);
249: coproc.read = pv[0];
250: ksh_dup2(pv[1], 1, FALSE);
251: coproc.readw = pv[1]; /* closed before first read */
252: coproc.njobs = 0;
253: /* create new coprocess id */
254: ++coproc.id;
255: }
256: # ifdef JOB_SIGS
257: sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0);
258: e->type = E_EXEC; /* no more need for error handler */
259: # endif /* JOB_SIGS */
260:
261: /* exchild() closes coproc.* in child after fork,
262: * will also increment coproc.njobs when the
263: * job is actually created.
264: */
265: flags &= ~XEXEC;
266: exchild(t->left, flags|XBGND|XFORK|XCOPROC|XCCLOSE,
267: coproc.readw);
268: break;
269: }
270: #endif /* KSH */
271:
272: case TASYNC:
273: /* XXX non-optimal, I think - "(foo &)", forks for (),
274: * forks again for async... parent should optimize
275: * this to "foo &"...
276: */
277: rv = execute(t->left, (flags&~XEXEC)|XBGND|XFORK);
278: break;
279:
280: case TOR:
281: case TAND:
282: rv = execute(t->left, XERROK);
283: if (t->right != NULL && (rv == 0) == (t->type == TAND))
284: rv = execute(t->right, flags & XERROK);
285: else
286: flags |= XERROK;
287: break;
288:
289: case TBANG:
290: rv = !execute(t->right, XERROK);
291: break;
292:
293: #ifdef KSH
294: case TDBRACKET:
295: {
296: Test_env te;
297:
298: te.flags = TEF_DBRACKET;
299: te.pos.wp = t->args;
300: te.isa = dbteste_isa;
301: te.getopnd = dbteste_getopnd;
302: te.eval = dbteste_eval;
303: te.error = dbteste_error;
304:
305: rv = test_parse(&te);
306: break;
307: }
308: #endif /* KSH */
309:
310: case TFOR:
311: #ifdef KSH
312: case TSELECT:
313: {
314: volatile bool_t is_first = TRUE;
315: #endif /* KSH */
316: ap = (t->vars != NULL) ?
317: eval(t->vars, DOBLANK|DOGLOB|DOTILDE)
318: : e->loc->argv + 1;
319: e->type = E_LOOP;
320: while (1) {
321: i = ksh_sigsetjmp(e->jbuf, 0);
322: if (!i)
323: break;
324: if ((e->flags&EF_BRKCONT_PASS)
325: || (i != LBREAK && i != LCONTIN))
326: {
327: quitenv();
328: unwind(i);
329: } else if (i == LBREAK) {
330: rv = 0;
331: goto Break;
332: }
333: }
334: rv = 0; /* in case of a continue */
335: if (t->type == TFOR) {
336: while (*ap != NULL) {
337: setstr(global(t->str), *ap++, KSH_UNWIND_ERROR);
338: rv = execute(t->left, flags & XERROK);
339: }
340: }
341: #ifdef KSH
342: else { /* TSELECT */
343: for (;;) {
344: if (!(cp = do_selectargs(ap, is_first))) {
345: rv = 1;
346: break;
347: }
348: is_first = FALSE;
349: setstr(global(t->str), cp, KSH_UNWIND_ERROR);
350: rv = execute(t->left, flags & XERROK);
351: }
352: }
353: }
354: #endif /* KSH */
355: break;
356:
357: case TWHILE:
358: case TUNTIL:
359: e->type = E_LOOP;
360: while (1) {
361: i = ksh_sigsetjmp(e->jbuf, 0);
362: if (!i)
363: break;
364: if ((e->flags&EF_BRKCONT_PASS)
365: || (i != LBREAK && i != LCONTIN))
366: {
367: quitenv();
368: unwind(i);
369: } else if (i == LBREAK) {
370: rv = 0;
371: goto Break;
372: }
373: }
374: rv = 0; /* in case of a continue */
375: while ((execute(t->left, XERROK) == 0) == (t->type == TWHILE))
376: rv = execute(t->right, flags & XERROK);
377: break;
378:
379: case TIF:
380: case TELIF:
381: if (t->right == NULL)
382: break; /* should be error */
383: rv = execute(t->left, XERROK) == 0 ?
384: execute(t->right->left, flags & XERROK) :
385: execute(t->right->right, flags & XERROK);
386: break;
387:
388: case TCASE:
389: cp = evalstr(t->str, DOTILDE);
390: for (t = t->left; t != NULL && t->type == TPAT; t = t->right)
391: for (ap = t->vars; *ap; ap++)
392: if ((s = evalstr(*ap, DOTILDE|DOPAT))
393: && gmatch(cp, s, FALSE))
394: goto Found;
395: break;
396: Found:
397: rv = execute(t->left, flags & XERROK);
398: break;
399:
400: case TBRACE:
401: rv = execute(t->left, flags & XERROK);
402: break;
403:
404: case TFUNCT:
405: rv = define(t->str, t);
406: break;
407:
408: case TTIME:
409: /* Clear XEXEC so nested execute() call doesn't exit
410: * (allows "ls -l | time grep foo").
411: */
412: rv = timex(t, flags & ~XEXEC);
413: break;
414:
415: case TEXEC: /* an eval'd TCOM */
416: s = t->args[0];
417: ap = makenv();
418: #ifndef F_SETFD
419: for (i = 0; i < sizeof(clexec_tab); i++)
420: if (clexec_tab[i]) {
421: close(i);
422: clexec_tab[i] = 0;
423: }
424: #endif
425: restoresigs();
426: cleanup_proc_env();
427: /* XINTACT bit is for OS2 */
428: ksh_execve(t->str, t->args, ap, (flags & XINTACT) ? 1 : 0);
429: if (errno == ENOEXEC)
430: scriptexec(t, ap);
431: else
432: errorf("%s: %s", s, strerror(errno));
433: }
434: Break:
435: exstat = rv;
436:
437: quitenv(); /* restores IO */
438: if ((flags&XEXEC))
439: unwind(LEXIT); /* exit child */
440: if (rv != 0 && !(flags & XERROK)) {
441: if (Flag(FERREXIT))
442: unwind(LERROR);
443: trapsig(SIGERR_);
444: }
445: return rv;
446: }
447:
448: /*
449: * execute simple command
450: */
451:
452: static int
453: comexec(t, tp, ap, flags)
454: struct op *t;
455: struct tbl *volatile tp;
456: register char **ap;
457: int volatile flags;
458: {
459: int i;
1.2 ! tnn 460: volatile int rv = 0;
1.1 tnn 461: register char *cp;
462: register char **lastp;
463: static struct op texec; /* Must be static (XXX but why?) */
464: int type_flags;
465: int keepasn_ok;
466: int fcflags = FC_BI|FC_FUNC|FC_PATH;
1.2 ! tnn 467: int bourne_function_call = 0;
1.1 tnn 468:
469: #ifdef KSH
470: /* snag the last argument for $_ XXX not the same as at&t ksh,
471: * which only seems to set $_ after a newline (but not in
1.2 ! tnn 472: * functions/dot scripts, but in interactive and script) -
1.1 tnn 473: * perhaps save last arg here and set it in shell()?.
474: */
475: if (Flag(FTALKING) && *(lastp = ap)) {
476: while (*++lastp)
477: ;
478: /* setstr() can't fail here */
479: setstr(typeset("_", LOCAL, 0, INTEGER, 0), *--lastp,
480: KSH_RETURN_ERROR);
481: }
482: #endif /* KSH */
483:
484: /* Deal with the shell builtins builtin, exec and command since
485: * they can be followed by other commands. This must be done before
486: * we know if we should create a local block, which must be done
487: * before we can do a path search (in case the assignments change
488: * PATH).
489: * Odd cases:
490: * FOO=bar exec > /dev/null FOO is kept but not exported
491: * FOO=bar exec foobar FOO is exported
492: * FOO=bar command exec > /dev/null FOO is neither kept nor exported
493: * FOO=bar command FOO is neither kept nor exported
494: * PATH=... foobar use new PATH in foobar search
495: */
496: keepasn_ok = 1;
497: while (tp && tp->type == CSHELL) {
498: fcflags = FC_BI|FC_FUNC|FC_PATH;/* undo effects of command */
499: if (tp->val.f == c_builtin) {
500: if ((cp = *++ap) == NULL) {
501: tp = NULL;
502: break;
503: }
504: tp = findcom(cp, FC_BI);
505: if (tp == NULL)
506: errorf("builtin: %s: not a builtin", cp);
507: continue;
508: } else if (tp->val.f == c_exec) {
509: if (ap[1] == NULL)
510: break;
511: ap++;
512: flags |= XEXEC;
513: } else if (tp->val.f == c_command) {
514: int optc, saw_p = 0;
515:
516: /* Ugly dealing with options in two places (here and
517: * in c_command(), but such is life)
518: */
519: ksh_getopt_reset(&builtin_opt, 0);
520: while ((optc = ksh_getopt(ap, &builtin_opt, ":p"))
521: == 'p')
522: saw_p = 1;
523: if (optc != EOF)
524: break; /* command -vV or something */
525: /* don't look for functions */
526: fcflags = FC_BI|FC_PATH;
527: if (saw_p) {
528: if (Flag(FRESTRICTED)) {
529: warningf(TRUE,
530: "command -p: restricted");
531: rv = 1;
532: goto Leave;
533: }
534: fcflags |= FC_DEFPATH;
535: }
536: ap += builtin_opt.optind;
537: /* POSIX says special builtins lose their status
538: * if accessed using command.
539: */
540: keepasn_ok = 0;
541: if (!ap[0]) {
542: /* ensure command with no args exits with 0 */
543: subst_exstat = 0;
544: break;
545: }
546: } else
547: break;
548: tp = findcom(ap[0], fcflags & (FC_BI|FC_FUNC));
549: }
550: if (keepasn_ok && (!ap[0] || (tp && (tp->flag & KEEPASN))))
551: type_flags = 0;
552: else {
553: /* create new variable/function block */
554: newblock();
555: /* ksh functions don't keep assignments, POSIX functions do. */
556: if (keepasn_ok && tp && tp->type == CFUNC
1.2 ! tnn 557: && !(tp->flag & FKSH)) {
! 558: bourne_function_call = 1;
1.1 tnn 559: type_flags = 0;
1.2 ! tnn 560: } else
1.1 tnn 561: type_flags = LOCAL|LOCAL_COPY|EXPORT;
562: }
563: if (Flag(FEXPORT))
564: type_flags |= EXPORT;
565: for (i = 0; t->vars[i]; i++) {
566: cp = evalstr(t->vars[i], DOASNTILDE);
567: if (Flag(FXTRACE)) {
568: if (i == 0)
569: shf_fprintf(shl_out, "%s",
570: PS4_SUBSTITUTE(str_val(global("PS4"))));
571: shf_fprintf(shl_out, "%s%s", cp,
572: t->vars[i + 1] ? space : newline);
573: if (!t->vars[i + 1])
574: shf_flush(shl_out);
575: }
576: typeset(cp, type_flags, 0, 0, 0);
1.2 ! tnn 577: if (bourne_function_call && !(type_flags & EXPORT))
! 578: typeset(cp, LOCAL|LOCAL_COPY|EXPORT, 0, 0, 0);
1.1 tnn 579: }
580:
581: if ((cp = *ap) == NULL) {
582: rv = subst_exstat;
583: goto Leave;
584: } else if (!tp) {
585: if (Flag(FRESTRICTED) && ksh_strchr_dirsep(cp)) {
586: warningf(TRUE, "%s: restricted", cp);
587: rv = 1;
588: goto Leave;
589: }
590: tp = findcom(cp, fcflags);
591: }
592:
593: switch (tp->type) {
594: case CSHELL: /* shell built-in */
595: rv = call_builtin(tp, ap);
596: break;
597:
598: case CFUNC: /* function call */
599: {
600: volatile int old_xflag;
601: volatile Tflag old_inuse;
602: const char *volatile old_kshname;
603:
604: if (!(tp->flag & ISSET)) {
605: struct tbl *ftp;
606:
607: if (!tp->u.fpath) {
608: if (tp->u2.errno_) {
609: warningf(TRUE,
610: "%s: can't find function definition file - %s",
611: cp, strerror(tp->u2.errno_));
612: rv = 126;
613: } else {
614: warningf(TRUE,
615: "%s: can't find function definition file", cp);
616: rv = 127;
617: }
618: break;
619: }
620: if (include(tp->u.fpath, 0, (char **) 0, 0) < 0) {
621: warningf(TRUE,
622: "%s: can't open function definition file %s - %s",
623: cp, tp->u.fpath, strerror(errno));
624: rv = 127;
625: break;
626: }
627: if (!(ftp = findfunc(cp, hash(cp), FALSE))
628: || !(ftp->flag & ISSET))
629: {
630: warningf(TRUE,
631: "%s: function not defined by %s",
632: cp, tp->u.fpath);
633: rv = 127;
634: break;
635: }
636: tp = ftp;
637: }
638:
639: /* ksh functions set $0 to function name, POSIX functions leave
640: * $0 unchanged.
641: */
642: old_kshname = kshname;
643: if (tp->flag & FKSH)
644: kshname = ap[0];
645: else
1.2 ! tnn 646: ap[0] = (char *) __UNCONST(kshname);
1.1 tnn 647: e->loc->argv = ap;
648: for (i = 0; *ap++ != NULL; i++)
649: ;
650: e->loc->argc = i - 1;
651: /* ksh-style functions handle getopts sanely,
652: * bourne/posix functions are insane...
653: */
654: if (tp->flag & FKSH) {
655: e->loc->flags |= BF_DOGETOPTS;
656: e->loc->getopts_state = user_opt;
657: getopts_reset(1);
658: }
659:
660: old_xflag = Flag(FXTRACE);
661: Flag(FXTRACE) = tp->flag & TRACE ? TRUE : FALSE;
662:
663: old_inuse = tp->flag & FINUSE;
664: tp->flag |= FINUSE;
665:
666: e->type = E_FUNC;
667: i = ksh_sigsetjmp(e->jbuf, 0);
668: if (i == 0) {
669: /* seems odd to pass XERROK here, but at&t ksh does */
670: exstat = execute(tp->val.t, flags & XERROK);
671: i = LRETURN;
672: }
673: kshname = old_kshname;
674: Flag(FXTRACE) = old_xflag;
675: tp->flag = (tp->flag & ~FINUSE) | old_inuse;
676: /* Were we deleted while executing? If so, free the execution
677: * tree. todo: Unfortunately, the table entry is never re-used
678: * until the lookup table is expanded.
679: */
680: if ((tp->flag & (FDELETE|FINUSE)) == FDELETE) {
681: if (tp->flag & ALLOC) {
682: tp->flag &= ~ALLOC;
683: tfree(tp->val.t, tp->areap);
684: }
685: tp->flag = 0;
686: }
687: switch (i) {
688: case LRETURN:
689: case LERROR:
690: rv = exstat;
691: break;
692: case LINTR:
693: case LEXIT:
694: case LLEAVE:
695: case LSHELL:
696: quitenv();
697: unwind(i);
698: /*NOTREACHED*/
699: default:
700: quitenv();
701: internal_errorf(1, "CFUNC %d", i);
702: }
703: break;
704: }
705:
706: case CEXEC: /* executable command */
707: case CTALIAS: /* tracked alias */
708: if (!(tp->flag&ISSET)) {
709: /* errno_ will be set if the named command was found
710: * but could not be executed (permissions, no execute
711: * bit, directory, etc). Print out a (hopefully)
712: * useful error message and set the exit status to 126.
713: */
714: if (tp->u2.errno_) {
715: warningf(TRUE, "%s: cannot execute - %s", cp,
716: strerror(tp->u2.errno_));
717: rv = 126; /* POSIX */
718: } else {
719: warningf(TRUE, "%s: not found", cp);
720: rv = 127;
721: }
722: break;
723: }
724:
725: #ifdef KSH
726: /* set $_ to program's full path */
727: /* setstr() can't fail here */
1.2 ! tnn 728: setstr(typeset("_", LOCAL|EXPORT, 0, INTEGER, 0),
! 729: tp->val.s, KSH_RETURN_ERROR);
1.1 tnn 730: #endif /* KSH */
731:
732: if (flags&XEXEC) {
733: j_exit();
734: if (!(flags&XBGND) || Flag(FMONITOR)) {
735: setexecsig(&sigtraps[SIGINT], SS_RESTORE_ORIG);
736: setexecsig(&sigtraps[SIGQUIT], SS_RESTORE_ORIG);
737: }
738: }
739:
740: /* to fork we set up a TEXEC node and call execute */
741: texec.type = TEXEC;
742: texec.left = t; /* for tprint */
743: texec.str = tp->val.s;
744: texec.args = ap;
745: rv = exchild(&texec, flags, -1);
746: break;
747: }
748: Leave:
749: if (flags & XEXEC) {
750: exstat = rv;
751: unwind(LLEAVE);
752: }
753: return rv;
754: }
755:
756: static void
757: scriptexec(tp, ap)
758: register struct op *tp;
759: register char **ap;
760: {
1.2 ! tnn 761: char *shellv;
1.1 tnn 762:
1.2 ! tnn 763: shellv = str_val(global(EXECSHELL_STR));
! 764: if (shellv && *shellv)
! 765: shellv = search(shellv, path, X_OK, (int *) 0);
! 766: if (!shellv || !*shellv)
! 767: shellv = __UNCONST(EXECSHELL);
1.1 tnn 768:
769: *tp->args-- = tp->str;
770: #ifdef SHARPBANG
771: {
772: char buf[LINE];
773: register char *cp;
774: register int fd, n;
775:
776: buf[0] = '\0';
777: if ((fd = open(tp->str, O_RDONLY)) >= 0) {
778: if ((n = read(fd, buf, LINE - 1)) > 0)
779: buf[n] = '\0';
780: (void) close(fd);
781: }
782: if ((buf[0] == '#' && buf[1] == '!' && (cp = &buf[2]))
783: # ifdef OS2
1.2 ! tnn 784: || (strncmp(buf, "extproc", 7) == 0 && isspace((unsigned char)buf[7])
1.1 tnn 785: && (cp = &buf[7]))
786: # endif /* OS2 */
787: )
788: {
789: while (*cp && (*cp == ' ' || *cp == '\t'))
790: cp++;
791: if (*cp && *cp != '\n') {
792: char *a0 = cp, *a1 = (char *) 0;
793: # ifdef OS2
794: char *a2 = cp;
795: # endif /* OS2 */
796:
797: while (*cp && *cp != '\n' && *cp != ' '
798: && *cp != '\t')
799: {
800: # ifdef OS2
801: /* Allow shell search without prepended path
802: * if shell with / in pathname cannot be found.
803: * Use / explicitly so \ can be used if explicit
804: * needs to be forced.
805: */
806: if (*cp == '/')
807: a2 = cp + 1;
808: # endif /* OS2 */
809: cp++;
810: }
811: if (*cp && *cp != '\n') {
812: *cp++ = '\0';
813: while (*cp
814: && (*cp == ' ' || *cp == '\t'))
815: cp++;
816: if (*cp && *cp != '\n') {
817: a1 = cp;
818: /* all one argument */
819: while (*cp && *cp != '\n')
820: cp++;
821: }
822: }
823: if (*cp == '\n') {
824: *cp = '\0';
825: if (a1)
826: *tp->args-- = a1;
827: # ifdef OS2
828: if (a0 != a2) {
829: char *tmp_a0 = str_nsave(a0,
830: strlen(a0) + 5, ATEMP);
831: if (search_access(tmp_a0, X_OK,
832: (int *) 0))
833: a0 = a2;
834: afree(tmp_a0, ATEMP);
835: }
836: # endif /* OS2 */
1.2 ! tnn 837: shellv = a0;
1.1 tnn 838: }
839: }
840: # ifdef OS2
841: } else {
842: /* Use ksh documented shell default if present
843: * else use OS2_SHELL which is assumed to need
1.2 ! tnn 844: * the /c option and '\' as dir separator.
1.1 tnn 845: */
1.2 ! tnn 846: char *p = shellv;
1.1 tnn 847:
1.2 ! tnn 848: shellv = str_val(global("EXECSHELL"));
! 849: if (shellv && *shellv)
! 850: shellv = search(shellv, path, X_OK, (int *) 0);
! 851: if (!shellv || !*shellv) {
! 852: shellv = p;
1.1 tnn 853: *tp->args-- = "/c";
854: for (p = tp->str; *p; p++)
855: if (*p == '/')
856: *p = '\\';
857: }
858: # endif /* OS2 */
859: }
860: }
861: #endif /* SHARPBANG */
1.2 ! tnn 862: *tp->args = shellv;
1.1 tnn 863:
864: ksh_execve(tp->args[0], tp->args, ap, 0);
865:
866: /* report both the program that was run and the bogus shell */
1.2 ! tnn 867: errorf("%s: %s: %s", tp->str, shellv, strerror(errno));
1.1 tnn 868: }
869:
870: int
871: shcomexec(wp)
872: register char **wp;
873: {
874: register struct tbl *tp;
875:
876: tp = tsearch(&builtins, *wp, hash(*wp));
877: if (tp == NULL)
878: internal_errorf(1, "shcomexec: %s", *wp);
879: return call_builtin(tp, wp);
880: }
881:
882: /*
883: * Search function tables for a function. If create set, a table entry
884: * is created if none is found.
885: */
886: struct tbl *
887: findfunc(name, h, create)
888: const char *name;
889: unsigned int h;
890: int create;
891: {
892: struct block *l;
893: struct tbl *tp = (struct tbl *) 0;
894:
895: for (l = e->loc; l; l = l->next) {
896: tp = tsearch(&l->funs, name, h);
897: if (tp)
898: break;
899: if (!l->next && create) {
900: tp = tenter(&l->funs, name, h);
901: tp->flag = DEFINED;
902: tp->type = CFUNC;
903: tp->val.t = (struct op *) 0;
904: break;
905: }
906: }
907: return tp;
908: }
909:
910: /*
911: * define function. Returns 1 if function is being undefined (t == 0) and
912: * function did not exist, returns 0 otherwise.
913: */
914: int
915: define(name, t)
916: const char *name;
917: struct op *t;
918: {
919: struct tbl *tp;
920: int was_set = 0;
921:
922: while (1) {
923: tp = findfunc(name, hash(name), TRUE);
924:
925: if (tp->flag & ISSET)
926: was_set = 1;
927: /* If this function is currently being executed, we zap this
928: * table entry so findfunc() won't see it
929: */
930: if (tp->flag & FINUSE) {
931: tp->name[0] = '\0';
932: tp->flag &= ~DEFINED; /* ensure it won't be found */
933: tp->flag |= FDELETE;
934: } else
935: break;
936: }
937:
938: if (tp->flag & ALLOC) {
939: tp->flag &= ~(ISSET|ALLOC);
940: tfree(tp->val.t, tp->areap);
941: }
942:
943: if (t == NULL) { /* undefine */
944: tdelete(tp);
945: return was_set ? 0 : 1;
946: }
947:
948: tp->val.t = tcopy(t->left, tp->areap);
949: tp->flag |= (ISSET|ALLOC);
950: if (t->u.ksh_func)
951: tp->flag |= FKSH;
952:
953: return 0;
954: }
955:
956: /*
957: * add builtin
958: */
959: void
960: builtin(name, func)
961: const char *name;
962: int (*func) ARGS((char **));
963: {
964: register struct tbl *tp;
965: Tflag flag;
966:
967: /* see if any flags should be set for this builtin */
968: for (flag = 0; ; name++) {
969: if (*name == '=') /* command does variable assignment */
970: flag |= KEEPASN;
971: else if (*name == '*') /* POSIX special builtin */
972: flag |= SPEC_BI;
973: else if (*name == '+') /* POSIX regular builtin */
974: flag |= REG_BI;
975: else
976: break;
977: }
978:
979: tp = tenter(&builtins, name, hash(name));
980: tp->flag = DEFINED | flag;
981: tp->type = CSHELL;
982: tp->val.f = func;
983: }
984:
985: /*
986: * find command
987: * either function, hashed command, or built-in (in that order)
988: */
989: struct tbl *
990: findcom(name, flags)
991: const char *name;
992: int flags; /* FC_* */
993: {
994: static struct tbl temp;
995: unsigned int h = hash(name);
996: struct tbl *tp = NULL, *tbi;
997: int insert = Flag(FTRACKALL); /* insert if not found */
998: char *fpath; /* for function autoloading */
999: char *npath;
1000:
1001: if (ksh_strchr_dirsep(name) != NULL) {
1002: insert = 0;
1003: /* prevent FPATH search below */
1004: flags &= ~FC_FUNC;
1005: goto Search;
1006: }
1007: tbi = (flags & FC_BI) ? tsearch(&builtins, name, h) : NULL;
1008: /* POSIX says special builtins first, then functions, then
1009: * POSIX regular builtins, then search path...
1010: */
1011: if ((flags & FC_SPECBI) && tbi && (tbi->flag & SPEC_BI))
1012: tp = tbi;
1013: if (!tp && (flags & FC_FUNC)) {
1014: tp = findfunc(name, h, FALSE);
1015: if (tp && !(tp->flag & ISSET)) {
1016: if ((fpath = str_val(global("FPATH"))) == null) {
1017: tp->u.fpath = (char *) 0;
1018: tp->u2.errno_ = 0;
1019: } else
1020: tp->u.fpath = search(name, fpath, R_OK,
1021: &tp->u2.errno_);
1022: }
1023: }
1024: if (!tp && (flags & FC_REGBI) && tbi && (tbi->flag & REG_BI))
1025: tp = tbi;
1026: /* todo: posix says non-special/non-regular builtins must
1027: * be triggered by some user-controllable means like a
1028: * special directory in PATH. Requires modifications to
1029: * the search() function. Tracked aliases should be
1030: * modified to allow tracking of builtin commands.
1031: * This should be under control of the FPOSIX flag.
1032: * If this is changed, also change c_whence...
1033: */
1034: if (!tp && (flags & FC_UNREGBI) && tbi)
1035: tp = tbi;
1036: if (!tp && (flags & FC_PATH) && !(flags & FC_DEFPATH)) {
1037: tp = tsearch(&taliases, name, h);
1038: if (tp && (tp->flag & ISSET) && eaccess(tp->val.s, X_OK) != 0) {
1039: if (tp->flag & ALLOC) {
1040: tp->flag &= ~ALLOC;
1041: afree(tp->val.s, APERM);
1042: }
1043: tp->flag &= ~ISSET;
1044: }
1045: }
1046:
1047: Search:
1048: if ((!tp || (tp->type == CTALIAS && !(tp->flag&ISSET)))
1049: && (flags & FC_PATH))
1050: {
1051: if (!tp) {
1052: if (insert && !(flags & FC_DEFPATH)) {
1053: tp = tenter(&taliases, name, h);
1054: tp->type = CTALIAS;
1055: } else {
1056: tp = &temp;
1057: tp->type = CEXEC;
1058: }
1059: tp->flag = DEFINED; /* make ~ISSET */
1060: }
1061: npath = search(name, flags & FC_DEFPATH ? def_path : path,
1062: X_OK, &tp->u2.errno_);
1063: if (npath) {
1.2 ! tnn 1064: if (tp == &temp) {
! 1065: tp->val.s = npath;
! 1066: } else {
! 1067: tp->val.s = str_save(npath, APERM);
! 1068: afree(npath, ATEMP);
! 1069: }
1.1 tnn 1070: tp->flag |= ISSET|ALLOC;
1071: } else if ((flags & FC_FUNC)
1072: && (fpath = str_val(global("FPATH"))) != null
1073: && (npath = search(name, fpath, R_OK,
1074: &tp->u2.errno_)) != (char *) 0)
1075: {
1076: /* An undocumented feature of at&t ksh is that it
1077: * searches FPATH if a command is not found, even
1078: * if the command hasn't been set up as an autoloaded
1079: * function (ie, no typeset -uf).
1080: */
1081: tp = &temp;
1082: tp->type = CFUNC;
1083: tp->flag = DEFINED; /* make ~ISSET */
1084: tp->u.fpath = npath;
1085: }
1086: }
1087: return tp;
1088: }
1089:
1090: /*
1091: * flush executable commands with relative paths
1092: */
1093: void
1094: flushcom(all)
1095: int all; /* just relative or all */
1096: {
1097: struct tbl *tp;
1098: struct tstate ts;
1099:
1100: for (twalk(&ts, &taliases); (tp = tnext(&ts)) != NULL; )
1101: if ((tp->flag&ISSET) && (all || !ISDIRSEP(tp->val.s[0]))) {
1102: if (tp->flag&ALLOC) {
1103: tp->flag &= ~(ALLOC|ISSET);
1104: afree(tp->val.s, APERM);
1105: }
1106: tp->flag &= ~ISSET;
1107: }
1108: }
1109:
1110: /* Check if path is something we want to find. Returns -1 for failure. */
1111: int
1.2 ! tnn 1112: search_access(pathx, mode, errnop)
! 1113: const char *pathx;
1.1 tnn 1114: int mode;
1115: int *errnop; /* set if candidate found, but not suitable */
1116: {
1117: #ifndef OS2
1118: int ret, err = 0;
1119: struct stat statb;
1120:
1.2 ! tnn 1121: if (stat(pathx, &statb) < 0)
1.1 tnn 1122: return -1;
1.2 ! tnn 1123: ret = eaccess(pathx, mode);
1.1 tnn 1124: if (ret < 0)
1125: err = errno; /* File exists, but we can't access it */
1126: else if (mode == X_OK
1127: && (!S_ISREG(statb.st_mode)
1128: /* This 'cause access() says root can execute everything */
1129: || !(statb.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH))))
1130: {
1131: ret = -1;
1132: err = S_ISDIR(statb.st_mode) ? EISDIR : EACCES;
1133: }
1134: if (err && errnop && !*errnop)
1135: *errnop = err;
1136: return ret;
1137: #else /* !OS2 */
1138: /*
1139: * NOTE: ASSUMES path can be modified and has enough room at the
1140: * end of the string for a suffix (ie, 4 extra characters).
1141: * Certain code knows this (eg, eval.c(globit()),
1142: * exec.c(search())).
1143: */
1144: static char *xsuffixes[] = { ".ksh", ".exe", ".", ".sh", ".cmd",
1145: ".com", ".bat", (char *) 0
1146: };
1147: static char *rsuffixes[] = { ".ksh", ".", ".sh", ".cmd", ".bat",
1148: (char *) 0
1149: };
1150: int i;
1.2 ! tnn 1151: char *mpath = (char *) pathx;
1.1 tnn 1152: char *tp = mpath + strlen(mpath);
1153: char *p;
1154: char **sfx;
1.2 ! tnn 1155:
1.1 tnn 1156: /* If a suffix has been specified, check if it is one of the
1157: * suffixes that indicate the file is executable - if so, change
1158: * the access test to R_OK...
1159: * This code assumes OS/2 files can have only one suffix...
1160: */
1161: if ((p = strrchr((p = ksh_strrchr_dirsep(mpath)) ? p : mpath, '.'))) {
1.2 ! tnn 1162: if (mode == X_OK)
1.1 tnn 1163: mode = R_OK;
1164: return search_access1(mpath, mode, errnop);
1165: }
1166: /* Try appending the various suffixes. Different suffixes for
1167: * read and execute 'cause we don't want to read an executable...
1168: */
1169: sfx = mode == R_OK ? rsuffixes : xsuffixes;
1170: for (i = 0; sfx[i]; i++) {
1171: strcpy(tp, p = sfx[i]);
1172: if (search_access1(mpath, R_OK, errnop) == 0)
1173: return 0;
1174: *tp = '\0';
1175: }
1176: return -1;
1177: #endif /* !OS2 */
1178: }
1179:
1180: #ifdef OS2
1181: static int
1.2 ! tnn 1182: search_access1(pathx, mode, errnop)
! 1183: const char *pathx;
1.1 tnn 1184: int mode;
1185: int *errnop; /* set if candidate found, but not suitable */
1186: {
1187: int ret, err = 0;
1188: struct stat statb;
1189:
1.2 ! tnn 1190: if (stat(pathx, &statb) < 0)
1.1 tnn 1191: return -1;
1.2 ! tnn 1192: ret = eaccess(pathx, mode);
1.1 tnn 1193: if (ret < 0)
1194: err = errno; /* File exists, but we can't access it */
1195: else if (!S_ISREG(statb.st_mode)) {
1196: ret = -1;
1197: err = S_ISDIR(statb.st_mode) ? EISDIR : EACCES;
1198: }
1199: if (err && errnop && !*errnop)
1200: *errnop = err;
1201: return ret;
1202: }
1203: #endif /* OS2 */
1204:
1205: /*
1206: * search for command with PATH
1207: */
1208: char *
1.2 ! tnn 1209: search(name, pathx, mode, errnop)
1.1 tnn 1210: const char *name;
1.2 ! tnn 1211: const char *pathx;
1.1 tnn 1212: int mode; /* R_OK or X_OK */
1213: int *errnop; /* set if candidate found, but not suitable */
1214: {
1215: const char *sp, *p;
1216: char *xp;
1217: XString xs;
1218: int namelen;
1219:
1220: if (errnop)
1221: *errnop = 0;
1222: #ifdef OS2
1223: /* Xinit() allocates 8 additional bytes, so appended suffixes won't
1224: * overflow the memory.
1225: */
1226: namelen = strlen(name) + 1;
1227: Xinit(xs, xp, namelen, ATEMP);
1228: memcpy(Xstring(xs, xp), name, namelen);
1229:
1230: if (ksh_strchr_dirsep(name)) {
1231: if (search_access(Xstring(xs, xp), mode, errnop) >= 0)
1232: return Xstring(xs, xp); /* not Xclose() - see above */
1233: Xfree(xs, xp);
1234: return NULL;
1235: }
1236:
1237: /* Look in current context always. (os2 style) */
1.2 ! tnn 1238: if (search_access(Xstring(xs, xp), mode, errnop) == 0)
1.1 tnn 1239: return Xstring(xs, xp); /* not Xclose() - xp may be wrong */
1240: #else /* OS2 */
1241: if (ksh_strchr_dirsep(name)) {
1242: if (search_access(name, mode, errnop) == 0)
1.2 ! tnn 1243: return (char *)__UNCONST(name);
1.1 tnn 1244: return NULL;
1245: }
1246:
1247: namelen = strlen(name) + 1;
1248: Xinit(xs, xp, 128, ATEMP);
1249: #endif /* OS2 */
1250:
1.2 ! tnn 1251: sp = pathx;
1.1 tnn 1252: while (sp != NULL) {
1253: xp = Xstring(xs, xp);
1254: if (!(p = strchr(sp, PATHSEP)))
1255: p = sp + strlen(sp);
1256: if (p != sp) {
1257: XcheckN(xs, xp, p - sp);
1258: memcpy(xp, sp, p - sp);
1259: xp += p - sp;
1260: *xp++ = DIRSEP;
1261: }
1262: sp = p;
1263: XcheckN(xs, xp, namelen);
1264: memcpy(xp, name, namelen);
1265: if (search_access(Xstring(xs, xp), mode, errnop) == 0)
1266: #ifdef OS2
1267: return Xstring(xs, xp); /* Not Xclose() - see above */
1268: #else /* OS2 */
1269: return Xclose(xs, xp + namelen);
1270: #endif /* OS2 */
1271: if (*sp++ == '\0')
1272: sp = NULL;
1273: }
1274: Xfree(xs, xp);
1275: return NULL;
1276: }
1277:
1278: static int
1279: call_builtin(tp, wp)
1280: struct tbl *tp;
1281: char **wp;
1282: {
1283: int rv;
1284:
1285: builtin_argv0 = wp[0];
1286: builtin_flag = tp->flag;
1287: shf_reopen(1, SHF_WR, shl_stdout);
1288: shl_stdout_ok = 1;
1289: ksh_getopt_reset(&builtin_opt, GF_ERROR);
1290: rv = (*tp->val.f)(wp);
1291: shf_flush(shl_stdout);
1292: shl_stdout_ok = 0;
1293: builtin_flag = 0;
1294: builtin_argv0 = (char *) 0;
1295: return rv;
1296: }
1297:
1298: /*
1299: * set up redirection, saving old fd's in e->savefd
1300: */
1301: static int
1302: iosetup(iop, tp)
1303: register struct ioword *iop;
1304: struct tbl *tp;
1305: {
1306: register int u = -1;
1307: char *cp = iop->name;
1308: int iotype = iop->flag & IOTYPE;
1309: int do_open = 1, do_close = 0, UNINITIALIZED(flags);
1310: struct ioword iotmp;
1311: struct stat statb;
1312:
1313: if (iotype != IOHERE)
1314: cp = evalonestr(cp, DOTILDE|(Flag(FTALKING_I) ? DOGLOB : 0));
1315:
1316: /* Used for tracing and error messages to print expanded cp */
1317: iotmp = *iop;
1318: iotmp.name = (iotype == IOHERE) ? (char *) 0 : cp;
1319: iotmp.flag |= IONAMEXP;
1320:
1321: if (Flag(FXTRACE))
1322: shellf("%s%s\n",
1323: PS4_SUBSTITUTE(str_val(global("PS4"))),
1324: snptreef((char *) 0, 32, "%R", &iotmp));
1325:
1326: switch (iotype) {
1327: case IOREAD:
1328: flags = O_RDONLY;
1329: break;
1330:
1331: case IOCAT:
1332: flags = O_WRONLY | O_APPEND | O_CREAT;
1333: break;
1334:
1335: case IOWRITE:
1336: flags = O_WRONLY | O_CREAT | O_TRUNC;
1337: /* The stat() is here to allow redirections to
1338: * things like /dev/null without error.
1339: */
1340: if (Flag(FNOCLOBBER) && !(iop->flag & IOCLOB)
1341: && (stat(cp, &statb) < 0 || S_ISREG(statb.st_mode)))
1342: flags |= O_EXCL;
1343: break;
1344:
1345: case IORDWR:
1346: flags = O_RDWR | O_CREAT;
1347: break;
1348:
1349: case IOHERE:
1350: do_open = 0;
1351: /* herein() returns -2 if error has been printed */
1352: u = herein(iop->heredoc, iop->flag & IOEVAL);
1353: /* cp may have wrong name */
1354: break;
1355:
1356: case IODUP:
1357: {
1358: const char *emsg;
1359:
1360: do_open = 0;
1361: if (*cp == '-' && !cp[1]) {
1362: u = 1009; /* prevent error return below */
1363: do_close = 1;
1364: } else if ((u = check_fd(cp,
1365: X_OK | ((iop->flag & IORDUP) ? R_OK : W_OK),
1366: &emsg)) < 0)
1367: {
1368: warningf(TRUE, "%s: %s",
1369: snptreef((char *) 0, 32, "%R", &iotmp), emsg);
1370: return -1;
1371: }
1.2 ! tnn 1372: if (u == iop->unit)
! 1373: return 0; /* "dup from" == "dup to" */
1.1 tnn 1374: break;
1375: }
1376: }
1377: if (do_open) {
1378: if (Flag(FRESTRICTED) && (flags & O_CREAT)) {
1379: warningf(TRUE, "%s: restricted", cp);
1380: return -1;
1381: }
1382: u = open(cp, flags, 0666);
1383: #ifdef OS2
1384: if (u < 0 && strcmp(cp, "/dev/null") == 0)
1385: u = open("nul", flags, 0666);
1386: #endif /* OS2 */
1387: }
1388: if (u < 0) {
1389: /* herein() may already have printed message */
1390: if (u == -1)
1391: warningf(TRUE, "cannot %s %s: %s",
1392: iotype == IODUP ? "dup"
1393: : (iotype == IOREAD || iotype == IOHERE) ?
1394: "open" : "create", cp, strerror(errno));
1395: return -1;
1396: }
1397: /* Do not save if it has already been redirected (i.e. "cat >x >y"). */
1.2 ! tnn 1398: if (e->savefd[iop->unit] == 0) {
! 1399: /* If these are the same, it means unit was previously closed */
! 1400: if (u == iop->unit)
! 1401: e->savefd[iop->unit] = -1;
! 1402: else
! 1403: /* c_exec() assumes e->savefd[fd] set for any
! 1404: * redirections. Ask savefd() not to close iop->unit;
! 1405: * this allows error messages to be seen if iop->unit
! 1406: * is 2; also means we can't lose the fd (eg, both
! 1407: * dup2 below and dup2 in restfd() failing).
! 1408: */
! 1409: e->savefd[iop->unit] = savefd(iop->unit, 1);
! 1410: }
1.1 tnn 1411:
1412: if (do_close)
1413: close(iop->unit);
1414: else if (u != iop->unit) {
1415: if (ksh_dup2(u, iop->unit, TRUE) < 0) {
1416: warningf(TRUE,
1417: "could not finish (dup) redirection %s: %s",
1418: snptreef((char *) 0, 32, "%R", &iotmp),
1419: strerror(errno));
1420: if (iotype != IODUP)
1421: close(u);
1422: return -1;
1423: }
1424: if (iotype != IODUP)
1425: close(u);
1426: #ifdef KSH
1427: /* Touching any co-process fd in an empty exec
1428: * causes the shell to close its copies
1429: */
1430: else if (tp && tp->type == CSHELL && tp->val.f == c_exec) {
1431: if (iop->flag & IORDUP) /* possible exec <&p */
1432: coproc_read_close(u);
1433: else /* possible exec >&p */
1434: coproc_write_close(u);
1435: }
1436: #endif /* KSH */
1437: }
1438: if (u == 2) /* Clear any write errors */
1439: shf_reopen(2, SHF_WR, shl_out);
1440: return 0;
1441: }
1442:
1443: /*
1444: * open here document temp file.
1445: * if unquoted here, expand here temp file into second temp file.
1446: */
1447: static int
1448: herein(content, sub)
1449: const char *content;
1450: int sub;
1451: {
1452: volatile int fd = -1;
1453: struct source *s, *volatile osource;
1454: struct shf *volatile shf;
1455: struct temp *h;
1456: int i;
1457:
1458: /* ksh -c 'cat << EOF' can cause this... */
1459: if (content == (char *) 0) {
1460: warningf(TRUE, "here document missing");
1461: return -2; /* special to iosetup(): don't print error */
1462: }
1463:
1464: /* Create temp file to hold content (done before newenv so temp
1465: * doesn't get removed too soon).
1466: */
1467: h = maketemp(ATEMP, TT_HEREDOC_EXP, &e->temps);
1468: if (!(shf = h->shf) || (fd = open(h->name, O_RDONLY, 0)) < 0) {
1469: warningf(TRUE, "can't %s temporary file %s: %s",
1470: !shf ? "create" : "open",
1471: h->name, strerror(errno));
1472: if (shf)
1473: shf_close(shf);
1474: return -2 /* special to iosetup(): don't print error */;
1475: }
1476:
1477: osource = source;
1478: newenv(E_ERRH);
1479: i = ksh_sigsetjmp(e->jbuf, 0);
1480: if (i) {
1481: source = osource;
1482: quitenv();
1483: shf_close(shf); /* after quitenv */
1484: close(fd);
1485: return -2; /* special to iosetup(): don't print error */
1486: }
1487: if (sub) {
1488: /* Do substitutions on the content of heredoc */
1489: s = pushs(SSTRING, ATEMP);
1490: s->start = s->str = content;
1491: source = s;
1.2 ! tnn 1492: if (yylex(ONEWORD|HEREDOC) != LWORD)
1.1 tnn 1493: internal_errorf(1, "herein: yylex");
1494: source = osource;
1495: shf_puts(evalstr(yylval.cp, 0), shf);
1496: } else
1497: shf_puts(content, shf);
1498:
1499: quitenv();
1500:
1501: if (shf_close(shf) == EOF) {
1502: close(fd);
1503: warningf(TRUE, "error writing %s: %s", h->name,
1504: strerror(errno));
1505: return -2; /* special to iosetup(): don't print error */
1506: }
1507:
1508: return fd;
1509: }
1510:
1511: #ifdef KSH
1512: /*
1513: * ksh special - the select command processing section
1514: * print the args in column form - assuming that we can
1515: */
1516: static char *
1517: do_selectargs(ap, print_menu)
1518: register char **ap;
1519: bool_t print_menu;
1520: {
1521: static const char *const read_args[] = {
1522: "read", "-r", "REPLY", (char *) 0
1523: };
1524: char *s;
1525: int i, argct;
1526:
1527: for (argct = 0; ap[argct]; argct++)
1528: ;
1529: while (1) {
1530: /* Menu is printed if
1531: * - this is the first time around the select loop
1532: * - the user enters a blank line
1533: * - the REPLY parameter is empty
1534: */
1535: if (print_menu || !*str_val(global("REPLY")))
1536: pr_menu(ap);
1537: shellf("%s", str_val(global("PS3")));
1.2 ! tnn 1538: if (call_builtin(findcom("read", FC_BI),
! 1539: (char **) __UNCONST(read_args)))
1.1 tnn 1540: return (char *) 0;
1541: s = str_val(global("REPLY"));
1542: if (*s) {
1543: i = atoi(s);
1544: return (i >= 1 && i <= argct) ? ap[i - 1] : null;
1545: }
1546: print_menu = 1;
1547: }
1548: }
1549:
1550: struct select_menu_info {
1551: char *const *args;
1552: int arg_width;
1553: int num_width;
1554: } info;
1555:
1556: static char *select_fmt_entry ARGS((void *arg, int i, char *buf, int buflen));
1557:
1558: /* format a single select menu item */
1559: static char *
1560: select_fmt_entry(arg, i, buf, buflen)
1561: void *arg;
1562: int i;
1563: char *buf;
1564: int buflen;
1565: {
1566: struct select_menu_info *smi = (struct select_menu_info *) arg;
1567:
1568: shf_snprintf(buf, buflen, "%*d) %s",
1569: smi->num_width, i + 1, smi->args[i]);
1570: return buf;
1571: }
1572:
1573: /*
1574: * print a select style menu
1575: */
1576: int
1577: pr_menu(ap)
1578: char *const *ap;
1579: {
1580: struct select_menu_info smi;
1581: char *const *pp;
1582: int nwidth, dwidth;
1583: int i, n;
1584:
1585: /* Width/column calculations were done once and saved, but this
1586: * means select can't be used recursively so we re-calculate each
1587: * time (could save in a structure that is returned, but its probably
1588: * not worth the bother).
1589: */
1590:
1591: /*
1592: * get dimensions of the list
1593: */
1594: for (n = 0, nwidth = 0, pp = ap; *pp; n++, pp++) {
1595: i = strlen(*pp);
1596: nwidth = (i > nwidth) ? i : nwidth;
1597: }
1598: /*
1599: * we will print an index of the form
1600: * %d)
1601: * in front of each entry
1602: * get the max width of this
1603: */
1604: for (i = n, dwidth = 1; i >= 10; i /= 10)
1605: dwidth++;
1606:
1607: smi.args = ap;
1608: smi.arg_width = nwidth;
1609: smi.num_width = dwidth;
1610: print_columns(shl_out, n, select_fmt_entry, (void *) &smi,
1.2 ! tnn 1611: dwidth + nwidth + 2, 1);
! 1612:
! 1613: return n;
! 1614: }
! 1615:
! 1616: /* XXX: horrible kludge to fit within the framework */
! 1617:
! 1618: static char *plain_fmt_entry ARGS((void *arg, int i, char *buf, int buflen));
! 1619:
! 1620: static char *
! 1621: plain_fmt_entry(arg, i, buf, buflen)
! 1622: void *arg;
! 1623: int i;
! 1624: char *buf;
! 1625: int buflen;
! 1626: {
! 1627: shf_snprintf(buf, buflen, "%s", ((char *const *)arg)[i]);
! 1628: return buf;
! 1629: }
! 1630:
! 1631: int
! 1632: pr_list(ap)
! 1633: char *const *ap;
! 1634: {
! 1635: char *const *pp;
! 1636: int nwidth;
! 1637: int i, n;
! 1638:
! 1639: for (n = 0, nwidth = 0, pp = ap; *pp; n++, pp++) {
! 1640: i = strlen(*pp);
! 1641: nwidth = (i > nwidth) ? i : nwidth;
! 1642: }
! 1643: print_columns(shl_out, n, plain_fmt_entry, (void *)__UNCONST(ap),
! 1644: nwidth + 1, 0);
1.1 tnn 1645:
1646: return n;
1647: }
1648: #endif /* KSH */
1649: #ifdef KSH
1650:
1651: /*
1652: * [[ ... ]] evaluation routines
1653: */
1654:
1655: extern const char *const dbtest_tokens[];
1656: extern const char db_close[];
1657:
1658: /* Test if the current token is a whatever. Accepts the current token if
1659: * it is. Returns 0 if it is not, non-zero if it is (in the case of
1660: * TM_UNOP and TM_BINOP, the returned value is a Test_op).
1661: */
1662: static int
1663: dbteste_isa(te, meta)
1664: Test_env *te;
1665: Test_meta meta;
1666: {
1667: int ret = 0;
1668: int uqword;
1669: char *p;
1670:
1671: if (!*te->pos.wp)
1672: return meta == TM_END;
1673:
1674: /* unquoted word? */
1675: for (p = *te->pos.wp; *p == CHAR; p += 2)
1676: ;
1677: uqword = *p == EOS;
1678:
1679: if (meta == TM_UNOP || meta == TM_BINOP) {
1680: if (uqword) {
1681: char buf[8]; /* longer than the longest operator */
1682: char *q = buf;
1683: for (p = *te->pos.wp; *p == CHAR
1684: && q < &buf[sizeof(buf) - 1];
1685: p += 2)
1686: *q++ = p[1];
1687: *q = '\0';
1688: ret = (int) test_isop(te, meta, buf);
1689: }
1690: } else if (meta == TM_END)
1691: ret = 0;
1692: else
1693: ret = uqword
1694: && strcmp(*te->pos.wp, dbtest_tokens[(int) meta]) == 0;
1695:
1696: /* Accept the token? */
1697: if (ret)
1698: te->pos.wp++;
1699:
1700: return ret;
1701: }
1702:
1703: static const char *
1704: dbteste_getopnd(te, op, do_eval)
1705: Test_env *te;
1706: Test_op op;
1707: int do_eval;
1708: {
1709: char *s = *te->pos.wp;
1710:
1711: if (!s)
1712: return (char *) 0;
1713:
1714: te->pos.wp++;
1715:
1716: if (!do_eval)
1717: return null;
1718:
1719: if (op == TO_STEQL || op == TO_STNEQ)
1720: s = evalstr(s, DOTILDE | DOPAT);
1721: else
1722: s = evalstr(s, DOTILDE);
1723:
1724: return s;
1725: }
1726:
1727: static int
1728: dbteste_eval(te, op, opnd1, opnd2, do_eval)
1729: Test_env *te;
1730: Test_op op;
1731: const char *opnd1;
1732: const char *opnd2;
1733: int do_eval;
1734: {
1735: return test_eval(te, op, opnd1, opnd2, do_eval);
1736: }
1737:
1738: static void
1739: dbteste_error(te, offset, msg)
1740: Test_env *te;
1741: int offset;
1742: const char *msg;
1743: {
1744: te->flags |= TEF_ERROR;
1745: internal_errorf(0, "dbteste_error: %s (offset %d)", msg, offset);
1746: }
1747: #endif /* KSH */
CVSweb <webmaster@jp.NetBSD.org>