1 /* $NetBSD: exec.c,v 1.15 2012/03/25 17:23:48 christos Exp $ */
2
3 /*
4 * execute command tree
5 */
6 #include <sys/cdefs.h>
7
8 #ifndef lint
9 __RCSID("$NetBSD: exec.c,v 1.15 2012/03/25 17:23:48 christos Exp $");
10 #endif
11
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
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));
31 #ifdef KSH
32 static char *do_selectargs ARGS((char **, bool_t));
33 #endif /* KSH */
34 #ifdef KSH
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 *));
40 #endif /* KSH */
41 #ifdef OS2
42 static int search_access1 ARGS((const char *, int, int *));
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
fd_clexec(fd)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
execute(t,flags)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);
109
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("%s", 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);
238 if (pv[0] != 0) {
239 ksh_dup2(pv[0], 0, FALSE);
240 close(pv[0]);
241 }
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
comexec(t,tp,ap,flags)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;
460 int leave = LLEAVE;
461 volatile int rv = 0;
462 register char *cp;
463 register char **lastp;
464 static struct op texec; /* Must be static (XXX but why?) */
465 int type_flags;
466 int keepasn_ok;
467 int fcflags = FC_BI|FC_FUNC|FC_PATH;
468 int bourne_function_call = 0;
469
470 #ifdef KSH
471 /* snag the last argument for $_ XXX not the same as at&t ksh,
472 * which only seems to set $_ after a newline (but not in
473 * functions/dot scripts, but in interactive and script) -
474 * perhaps save last arg here and set it in shell()?.
475 */
476 if (Flag(FTALKING) && *(lastp = ap)) {
477 while (*++lastp)
478 ;
479 /* setstr() can't fail here */
480 setstr(typeset("_", LOCAL, 0, INTEGER, 0), *--lastp,
481 KSH_RETURN_ERROR);
482 }
483 #endif /* KSH */
484
485 /* Deal with the shell builtins builtin, exec and command since
486 * they can be followed by other commands. This must be done before
487 * we know if we should create a local block, which must be done
488 * before we can do a path search (in case the assignments change
489 * PATH).
490 * Odd cases:
491 * FOO=bar exec > /dev/null FOO is kept but not exported
492 * FOO=bar exec foobar FOO is exported
493 * FOO=bar command exec > /dev/null FOO is neither kept nor exported
494 * FOO=bar command FOO is neither kept nor exported
495 * PATH=... foobar use new PATH in foobar search
496 */
497 keepasn_ok = 1;
498 while (tp && tp->type == CSHELL) {
499 fcflags = FC_BI|FC_FUNC|FC_PATH;/* undo effects of command */
500 if (tp->val.f == c_builtin) {
501 if ((cp = *++ap) == NULL) {
502 tp = NULL;
503 break;
504 }
505 tp = findcom(cp, FC_BI);
506 if (tp == NULL)
507 errorf("builtin: %s: not a builtin", cp);
508 continue;
509 } else if (tp->val.f == c_exec) {
510 if (ap[1] == NULL)
511 break;
512 ap++;
513 flags |= XEXEC;
514 } else if (tp->val.f == c_command) {
515 int optc, saw_p = 0;
516
517 /* Ugly dealing with options in two places (here and
518 * in c_command(), but such is life)
519 */
520 ksh_getopt_reset(&builtin_opt, 0);
521 while ((optc = ksh_getopt(ap, &builtin_opt, ":p"))
522 == 'p')
523 saw_p = 1;
524 if (optc != EOF)
525 break; /* command -vV or something */
526 /* don't look for functions */
527 fcflags = FC_BI|FC_PATH;
528 if (saw_p) {
529 if (Flag(FRESTRICTED)) {
530 warningf(TRUE,
531 "command -p: restricted");
532 rv = 1;
533 goto Leave;
534 }
535 fcflags |= FC_DEFPATH;
536 }
537 ap += builtin_opt.optind;
538 /* POSIX says special builtins lose their status
539 * if accessed using command.
540 */
541 keepasn_ok = 0;
542 if (!ap[0]) {
543 /* ensure command with no args exits with 0 */
544 subst_exstat = 0;
545 break;
546 }
547 } else
548 break;
549 tp = findcom(ap[0], fcflags & (FC_BI|FC_FUNC));
550 }
551 if (keepasn_ok && (!ap[0] || (tp && (tp->flag & KEEPASN))))
552 type_flags = 0;
553 else {
554 /* create new variable/function block */
555 newblock();
556 /* ksh functions don't keep assignments, POSIX functions do. */
557 if (keepasn_ok && tp && tp->type == CFUNC
558 && !(tp->flag & FKSH)) {
559 bourne_function_call = 1;
560 type_flags = 0;
561 } else
562 type_flags = LOCAL|LOCAL_COPY|EXPORT;
563 }
564 if (Flag(FEXPORT))
565 type_flags |= EXPORT;
566 for (i = 0; t->vars[i]; i++) {
567 cp = evalstr(t->vars[i], DOASNTILDE);
568 if (Flag(FXTRACE)) {
569 if (i == 0)
570 shf_fprintf(shl_out, "%s",
571 PS4_SUBSTITUTE(str_val(global("PS4"))));
572 shf_fprintf(shl_out, "%s%s", cp,
573 t->vars[i + 1] ? space : newline);
574 if (!t->vars[i + 1])
575 shf_flush(shl_out);
576 }
577 typeset(cp, type_flags, 0, 0, 0);
578 if (bourne_function_call && !(type_flags & EXPORT))
579 typeset(cp, LOCAL|LOCAL_COPY|EXPORT, 0, 0, 0);
580 }
581
582 if ((cp = *ap) == NULL) {
583 rv = subst_exstat;
584 goto Leave;
585 } else if (!tp) {
586 if (Flag(FRESTRICTED) && ksh_strchr_dirsep(cp)) {
587 warningf(TRUE, "%s: restricted", cp);
588 rv = 1;
589 goto Leave;
590 }
591 tp = findcom(cp, fcflags);
592 }
593
594 switch (tp->type) {
595 case CSHELL: /* shell built-in */
596 rv = call_builtin(tp, ap);
597 break;
598
599 case CFUNC: /* function call */
600 {
601 volatile int old_xflag;
602 volatile Tflag old_inuse;
603 const char *volatile old_kshname;
604
605 if (!(tp->flag & ISSET)) {
606 struct tbl *ftp;
607
608 if (!tp->u.fpath) {
609 if (tp->u2.errno_) {
610 warningf(TRUE,
611 "%s: can't find function definition file - %s",
612 cp, strerror(tp->u2.errno_));
613 rv = 126;
614 } else {
615 warningf(TRUE,
616 "%s: can't find function definition file", cp);
617 rv = 127;
618 }
619 break;
620 }
621 if (include(tp->u.fpath, 0, (char **) 0, 0) < 0) {
622 warningf(TRUE,
623 "%s: can't open function definition file %s - %s",
624 cp, tp->u.fpath, strerror(errno));
625 rv = 127;
626 break;
627 }
628 if (!(ftp = findfunc(cp, hash(cp), FALSE))
629 || !(ftp->flag & ISSET))
630 {
631 warningf(TRUE,
632 "%s: function not defined by %s",
633 cp, tp->u.fpath);
634 rv = 127;
635 break;
636 }
637 tp = ftp;
638 }
639
640 /* ksh functions set $0 to function name, POSIX functions leave
641 * $0 unchanged.
642 */
643 old_kshname = kshname;
644 if (tp->flag & FKSH)
645 kshname = ap[0];
646 else
647 ap[0] = (char *) __UNCONST(kshname);
648 e->loc->argv = ap;
649 for (i = 0; *ap++ != NULL; i++)
650 ;
651 e->loc->argc = i - 1;
652 /* ksh-style functions handle getopts sanely,
653 * bourne/posix functions are insane...
654 */
655 if (tp->flag & FKSH) {
656 e->loc->flags |= BF_DOGETOPTS;
657 e->loc->getopts_state = user_opt;
658 getopts_reset(1);
659 }
660
661 old_xflag = Flag(FXTRACE);
662 Flag(FXTRACE) = tp->flag & TRACE ? TRUE : FALSE;
663
664 old_inuse = tp->flag & FINUSE;
665 tp->flag |= FINUSE;
666
667 e->type = E_FUNC;
668 i = ksh_sigsetjmp(e->jbuf, 0);
669 if (i == 0) {
670 /* seems odd to pass XERROK here, but at&t ksh does */
671 exstat = execute(tp->val.t, flags & XERROK);
672 i = LRETURN;
673 }
674 kshname = old_kshname;
675 Flag(FXTRACE) = old_xflag;
676 tp->flag = (tp->flag & ~FINUSE) | old_inuse;
677 /* Were we deleted while executing? If so, free the execution
678 * tree. todo: Unfortunately, the table entry is never re-used
679 * until the lookup table is expanded.
680 */
681 if ((tp->flag & (FDELETE|FINUSE)) == FDELETE) {
682 if (tp->flag & ALLOC) {
683 tp->flag &= ~ALLOC;
684 tfree(tp->val.t, tp->areap);
685 }
686 tp->flag = 0;
687 }
688 switch (i) {
689 case LRETURN:
690 case LERROR:
691 rv = exstat;
692 break;
693 case LINTR:
694 case LEXIT:
695 case LLEAVE:
696 case LSHELL:
697 quitenv();
698 unwind(i);
699 /*NOTREACHED*/
700 default:
701 quitenv();
702 internal_errorf(1, "CFUNC %d", i);
703 }
704 break;
705 }
706
707 case CEXEC: /* executable command */
708 case CTALIAS: /* tracked alias */
709 if (!(tp->flag&ISSET)) {
710 /* errno_ will be set if the named command was found
711 * but could not be executed (permissions, no execute
712 * bit, directory, etc). Print out a (hopefully)
713 * useful error message and set the exit status to 126.
714 */
715 if (tp->u2.errno_) {
716 warningf(TRUE, "%s: cannot execute - %s", cp,
717 strerror(tp->u2.errno_));
718 rv = 126; /* POSIX */
719 } else {
720 warningf(TRUE, "%s: not found", cp);
721 rv = 127;
722 }
723 break;
724 }
725
726 #ifdef KSH
727 /* set $_ to program's full path */
728 /* setstr() can't fail here */
729 setstr(typeset("_", LOCAL|EXPORT, 0, INTEGER, 0),
730 tp->val.s, KSH_RETURN_ERROR);
731 #endif /* KSH */
732
733 if (flags&XEXEC) {
734 j_exit();
735 if (!(flags&XBGND) || Flag(FMONITOR)) {
736 setexecsig(&sigtraps[SIGINT], SS_RESTORE_ORIG);
737 setexecsig(&sigtraps[SIGQUIT], SS_RESTORE_ORIG);
738 }
739 }
740
741 /* to fork we set up a TEXEC node and call execute */
742 texec.type = TEXEC;
743 texec.left = t; /* for tprint */
744 texec.str = tp->val.s;
745 texec.args = ap;
746 rv = exchild(&texec, flags, -1);
747 break;
748 }
749 leave = LEXIT;
750 Leave:
751 if (flags & XEXEC) {
752 exstat = rv;
753 unwind(leave);
754 }
755 return rv;
756 }
757
758 static void
scriptexec(tp,ap)759 scriptexec(tp, ap)
760 register struct op *tp;
761 register char **ap;
762 {
763 char *shellv;
764
765 shellv = str_val(global(EXECSHELL_STR));
766 if (shellv && *shellv)
767 shellv = search(shellv, path, X_OK, (int *) 0);
768 if (!shellv || !*shellv)
769 shellv = __UNCONST(EXECSHELL);
770
771 *tp->args-- = tp->str;
772 #ifdef SHARPBANG
773 {
774 char buf[LINE];
775 register char *cp;
776 register int fd, n;
777
778 buf[0] = '\0';
779 if ((fd = open(tp->str, O_RDONLY)) >= 0) {
780 if ((n = read(fd, buf, LINE - 1)) > 0)
781 buf[n] = '\0';
782 (void) close(fd);
783 }
784 if ((buf[0] == '#' && buf[1] == '!' && (cp = &buf[2]))
785 # ifdef OS2
786 || (strncmp(buf, "extproc", 7) == 0 && isspace((unsigned char)buf[7])
787 && (cp = &buf[7]))
788 # endif /* OS2 */
789 )
790 {
791 while (*cp && (*cp == ' ' || *cp == '\t'))
792 cp++;
793 if (*cp && *cp != '\n') {
794 char *a0 = cp, *a1 = (char *) 0;
795 # ifdef OS2
796 char *a2 = cp;
797 # endif /* OS2 */
798
799 while (*cp && *cp != '\n' && *cp != ' '
800 && *cp != '\t')
801 {
802 # ifdef OS2
803 /* Allow shell search without prepended path
804 * if shell with / in pathname cannot be found.
805 * Use / explicitly so \ can be used if explicit
806 * needs to be forced.
807 */
808 if (*cp == '/')
809 a2 = cp + 1;
810 # endif /* OS2 */
811 cp++;
812 }
813 if (*cp && *cp != '\n') {
814 *cp++ = '\0';
815 while (*cp
816 && (*cp == ' ' || *cp == '\t'))
817 cp++;
818 if (*cp && *cp != '\n') {
819 a1 = cp;
820 /* all one argument */
821 while (*cp && *cp != '\n')
822 cp++;
823 }
824 }
825 if (*cp == '\n') {
826 *cp = '\0';
827 if (a1)
828 *tp->args-- = a1;
829 # ifdef OS2
830 if (a0 != a2) {
831 char *tmp_a0 = str_nsave(a0,
832 strlen(a0) + 5, ATEMP);
833 if (search_access(tmp_a0, X_OK,
834 (int *) 0))
835 a0 = a2;
836 afree(tmp_a0, ATEMP);
837 }
838 # endif /* OS2 */
839 shellv = a0;
840 }
841 }
842 # ifdef OS2
843 } else {
844 /* Use ksh documented shell default if present
845 * else use OS2_SHELL which is assumed to need
846 * the /c option and '\' as dir separator.
847 */
848 char *p = shellv;
849
850 shellv = str_val(global("EXECSHELL"));
851 if (shellv && *shellv)
852 shellv = search(shellv, path, X_OK, (int *) 0);
853 if (!shellv || !*shellv) {
854 shellv = p;
855 *tp->args-- = "/c";
856 for (p = tp->str; *p; p++)
857 if (*p == '/')
858 *p = '\\';
859 }
860 # endif /* OS2 */
861 }
862 }
863 #endif /* SHARPBANG */
864 *tp->args = shellv;
865
866 ksh_execve(tp->args[0], tp->args, ap, 0);
867
868 /* report both the program that was run and the bogus shell */
869 errorf("%s: %s: %s", tp->str, shellv, strerror(errno));
870 }
871
872 int
shcomexec(wp)873 shcomexec(wp)
874 register char **wp;
875 {
876 register struct tbl *tp;
877
878 tp = tsearch(&builtins, *wp, hash(*wp));
879 if (tp == NULL)
880 internal_errorf(1, "shcomexec: %s", *wp);
881 return call_builtin(tp, wp);
882 }
883
884 /*
885 * Search function tables for a function. If create set, a table entry
886 * is created if none is found.
887 */
888 struct tbl *
findfunc(name,h,create)889 findfunc(name, h, create)
890 const char *name;
891 unsigned int h;
892 int create;
893 {
894 struct block *l;
895 struct tbl *tp = (struct tbl *) 0;
896
897 for (l = e->loc; l; l = l->next) {
898 tp = tsearch(&l->funs, name, h);
899 if (tp)
900 break;
901 if (!l->next && create) {
902 tp = tenter(&l->funs, name, h);
903 tp->flag = DEFINED;
904 tp->type = CFUNC;
905 tp->val.t = (struct op *) 0;
906 break;
907 }
908 }
909 return tp;
910 }
911
912 /*
913 * define function. Returns 1 if function is being undefined (t == 0) and
914 * function did not exist, returns 0 otherwise.
915 */
916 int
define(name,t)917 define(name, t)
918 const char *name;
919 struct op *t;
920 {
921 struct tbl *tp;
922 int was_set = 0;
923
924 while (1) {
925 tp = findfunc(name, hash(name), TRUE);
926
927 if (tp->flag & ISSET)
928 was_set = 1;
929 /* If this function is currently being executed, we zap this
930 * table entry so findfunc() won't see it
931 */
932 if (tp->flag & FINUSE) {
933 tp->name[0] = '\0';
934 tp->flag &= ~DEFINED; /* ensure it won't be found */
935 tp->flag |= FDELETE;
936 } else
937 break;
938 }
939
940 if (tp->flag & ALLOC) {
941 tp->flag &= ~(ISSET|ALLOC);
942 tfree(tp->val.t, tp->areap);
943 }
944
945 if (t == NULL) { /* undefine */
946 tdelete(tp);
947 return was_set ? 0 : 1;
948 }
949
950 tp->val.t = tcopy(t->left, tp->areap);
951 tp->flag |= (ISSET|ALLOC);
952 if (t->u.ksh_func)
953 tp->flag |= FKSH;
954
955 return 0;
956 }
957
958 /*
959 * add builtin
960 */
961 void
builtin(name,func)962 builtin(name, func)
963 const char *name;
964 int (*func) ARGS((char **));
965 {
966 register struct tbl *tp;
967 Tflag flag;
968
969 /* see if any flags should be set for this builtin */
970 for (flag = 0; ; name++) {
971 if (*name == '=') /* command does variable assignment */
972 flag |= KEEPASN;
973 else if (*name == '*') /* POSIX special builtin */
974 flag |= SPEC_BI;
975 else if (*name == '+') /* POSIX regular builtin */
976 flag |= REG_BI;
977 else
978 break;
979 }
980
981 tp = tenter(&builtins, name, hash(name));
982 tp->flag = DEFINED | flag;
983 tp->type = CSHELL;
984 tp->val.f = func;
985 }
986
987 /*
988 * find command
989 * either function, hashed command, or built-in (in that order)
990 */
991 struct tbl *
findcom(name,flags)992 findcom(name, flags)
993 const char *name;
994 int flags; /* FC_* */
995 {
996 static struct tbl temp;
997 unsigned int h = hash(name);
998 struct tbl *tp = NULL, *tbi;
999 int insert = Flag(FTRACKALL); /* insert if not found */
1000 char *fpath; /* for function autoloading */
1001 char *npath;
1002
1003 if (ksh_strchr_dirsep(name) != NULL) {
1004 insert = 0;
1005 /* prevent FPATH search below */
1006 flags &= ~FC_FUNC;
1007 goto Search;
1008 }
1009 tbi = (flags & FC_BI) ? tsearch(&builtins, name, h) : NULL;
1010 /* POSIX says special builtins first, then functions, then
1011 * POSIX regular builtins, then search path...
1012 */
1013 if ((flags & FC_SPECBI) && tbi && (tbi->flag & SPEC_BI))
1014 tp = tbi;
1015 if (!tp && (flags & FC_FUNC)) {
1016 tp = findfunc(name, h, FALSE);
1017 if (tp && !(tp->flag & ISSET)) {
1018 if ((fpath = str_val(global("FPATH"))) == null) {
1019 tp->u.fpath = (char *) 0;
1020 tp->u2.errno_ = 0;
1021 } else
1022 tp->u.fpath = search(name, fpath, R_OK,
1023 &tp->u2.errno_);
1024 }
1025 }
1026 if (!tp && (flags & FC_REGBI) && tbi && (tbi->flag & REG_BI))
1027 tp = tbi;
1028 /* todo: posix says non-special/non-regular builtins must
1029 * be triggered by some user-controllable means like a
1030 * special directory in PATH. Requires modifications to
1031 * the search() function. Tracked aliases should be
1032 * modified to allow tracking of builtin commands.
1033 * This should be under control of the FPOSIX flag.
1034 * If this is changed, also change c_whence...
1035 */
1036 if (!tp && (flags & FC_UNREGBI) && tbi)
1037 tp = tbi;
1038 if (!tp && (flags & FC_PATH) && !(flags & FC_DEFPATH)) {
1039 tp = tsearch(&taliases, name, h);
1040 if (tp && (tp->flag & ISSET) && eaccess(tp->val.s, X_OK) != 0) {
1041 if (tp->flag & ALLOC) {
1042 tp->flag &= ~ALLOC;
1043 afree(tp->val.s, APERM);
1044 }
1045 tp->flag &= ~ISSET;
1046 }
1047 }
1048
1049 Search:
1050 if ((!tp || (tp->type == CTALIAS && !(tp->flag&ISSET)))
1051 && (flags & FC_PATH))
1052 {
1053 if (!tp) {
1054 if (insert && !(flags & FC_DEFPATH)) {
1055 tp = tenter(&taliases, name, h);
1056 tp->type = CTALIAS;
1057 } else {
1058 tp = &temp;
1059 tp->type = CEXEC;
1060 }
1061 tp->flag = DEFINED; /* make ~ISSET */
1062 }
1063 npath = search(name, flags & FC_DEFPATH ? def_path : path,
1064 X_OK, &tp->u2.errno_);
1065 if (npath) {
1066 if (tp == &temp) {
1067 tp->val.s = npath;
1068 } else {
1069 tp->val.s = str_save(npath, APERM);
1070 afree(npath, ATEMP);
1071 }
1072 tp->flag |= ISSET|ALLOC;
1073 } else if ((flags & FC_FUNC)
1074 && (fpath = str_val(global("FPATH"))) != null
1075 && (npath = search(name, fpath, R_OK,
1076 &tp->u2.errno_)) != (char *) 0)
1077 {
1078 /* An undocumented feature of at&t ksh is that it
1079 * searches FPATH if a command is not found, even
1080 * if the command hasn't been set up as an autoloaded
1081 * function (ie, no typeset -uf).
1082 */
1083 tp = &temp;
1084 tp->type = CFUNC;
1085 tp->flag = DEFINED; /* make ~ISSET */
1086 tp->u.fpath = npath;
1087 }
1088 }
1089 return tp;
1090 }
1091
1092 /*
1093 * flush executable commands with relative paths
1094 */
1095 void
flushcom(all)1096 flushcom(all)
1097 int all; /* just relative or all */
1098 {
1099 struct tbl *tp;
1100 struct tstate ts;
1101
1102 for (twalk(&ts, &taliases); (tp = tnext(&ts)) != NULL; )
1103 if ((tp->flag&ISSET) && (all || !ISDIRSEP(tp->val.s[0]))) {
1104 if (tp->flag&ALLOC) {
1105 tp->flag &= ~(ALLOC|ISSET);
1106 afree(tp->val.s, APERM);
1107 }
1108 tp->flag &= ~ISSET;
1109 }
1110 }
1111
1112 /* Check if path is something we want to find. Returns -1 for failure. */
1113 int
search_access(pathx,mode,errnop)1114 search_access(pathx, mode, errnop)
1115 const char *pathx;
1116 int mode;
1117 int *errnop; /* set if candidate found, but not suitable */
1118 {
1119 #ifndef OS2
1120 int ret, err = 0;
1121 struct stat statb;
1122
1123 if (stat(pathx, &statb) < 0)
1124 return -1;
1125 ret = eaccess(pathx, mode);
1126 if (ret < 0)
1127 err = errno; /* File exists, but we can't access it */
1128 else if (mode == X_OK
1129 && (!S_ISREG(statb.st_mode)
1130 /* This 'cause access() says root can execute everything */
1131 || !(statb.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH))))
1132 {
1133 ret = -1;
1134 err = S_ISDIR(statb.st_mode) ? EISDIR : EACCES;
1135 }
1136 if (err && errnop && !*errnop)
1137 *errnop = err;
1138 return ret;
1139 #else /* !OS2 */
1140 /*
1141 * NOTE: ASSUMES path can be modified and has enough room at the
1142 * end of the string for a suffix (ie, 4 extra characters).
1143 * Certain code knows this (eg, eval.c(globit()),
1144 * exec.c(search())).
1145 */
1146 static char *xsuffixes[] = { ".ksh", ".exe", ".", ".sh", ".cmd",
1147 ".com", ".bat", (char *) 0
1148 };
1149 static char *rsuffixes[] = { ".ksh", ".", ".sh", ".cmd", ".bat",
1150 (char *) 0
1151 };
1152 int i;
1153 char *mpath = (char *) pathx;
1154 char *tp = mpath + strlen(mpath);
1155 char *p;
1156 char **sfx;
1157
1158 /* If a suffix has been specified, check if it is one of the
1159 * suffixes that indicate the file is executable - if so, change
1160 * the access test to R_OK...
1161 * This code assumes OS/2 files can have only one suffix...
1162 */
1163 if ((p = strrchr((p = ksh_strrchr_dirsep(mpath)) ? p : mpath, '.'))) {
1164 if (mode == X_OK)
1165 mode = R_OK;
1166 return search_access1(mpath, mode, errnop);
1167 }
1168 /* Try appending the various suffixes. Different suffixes for
1169 * read and execute 'cause we don't want to read an executable...
1170 */
1171 sfx = mode == R_OK ? rsuffixes : xsuffixes;
1172 for (i = 0; sfx[i]; i++) {
1173 strcpy(tp, p = sfx[i]);
1174 if (search_access1(mpath, R_OK, errnop) == 0)
1175 return 0;
1176 *tp = '\0';
1177 }
1178 return -1;
1179 #endif /* !OS2 */
1180 }
1181
1182 #ifdef OS2
1183 static int
search_access1(pathx,mode,errnop)1184 search_access1(pathx, mode, errnop)
1185 const char *pathx;
1186 int mode;
1187 int *errnop; /* set if candidate found, but not suitable */
1188 {
1189 int ret, err = 0;
1190 struct stat statb;
1191
1192 if (stat(pathx, &statb) < 0)
1193 return -1;
1194 ret = eaccess(pathx, mode);
1195 if (ret < 0)
1196 err = errno; /* File exists, but we can't access it */
1197 else if (!S_ISREG(statb.st_mode)) {
1198 ret = -1;
1199 err = S_ISDIR(statb.st_mode) ? EISDIR : EACCES;
1200 }
1201 if (err && errnop && !*errnop)
1202 *errnop = err;
1203 return ret;
1204 }
1205 #endif /* OS2 */
1206
1207 /*
1208 * search for command with PATH
1209 */
1210 char *
search(name,pathx,mode,errnop)1211 search(name, pathx, mode, errnop)
1212 const char *name;
1213 const char *pathx;
1214 int mode; /* R_OK or X_OK */
1215 int *errnop; /* set if candidate found, but not suitable */
1216 {
1217 const char *sp, *p;
1218 char *xp;
1219 XString xs;
1220 int namelen;
1221
1222 if (errnop)
1223 *errnop = 0;
1224 #ifdef OS2
1225 /* Xinit() allocates 8 additional bytes, so appended suffixes won't
1226 * overflow the memory.
1227 */
1228 namelen = strlen(name) + 1;
1229 Xinit(xs, xp, namelen, ATEMP);
1230 memcpy(Xstring(xs, xp), name, namelen);
1231
1232 if (ksh_strchr_dirsep(name)) {
1233 if (search_access(Xstring(xs, xp), mode, errnop) >= 0)
1234 return Xstring(xs, xp); /* not Xclose() - see above */
1235 Xfree(xs, xp);
1236 return NULL;
1237 }
1238
1239 /* Look in current context always. (os2 style) */
1240 if (search_access(Xstring(xs, xp), mode, errnop) == 0)
1241 return Xstring(xs, xp); /* not Xclose() - xp may be wrong */
1242 #else /* OS2 */
1243 if (ksh_strchr_dirsep(name)) {
1244 if (search_access(name, mode, errnop) == 0)
1245 return (char *)__UNCONST(name);
1246 return NULL;
1247 }
1248
1249 namelen = strlen(name) + 1;
1250 Xinit(xs, xp, 128, ATEMP);
1251 #endif /* OS2 */
1252
1253 sp = pathx;
1254 while (sp != NULL) {
1255 xp = Xstring(xs, xp);
1256 if (!(p = strchr(sp, PATHSEP)))
1257 p = sp + strlen(sp);
1258 if (p != sp) {
1259 XcheckN(xs, xp, p - sp);
1260 memcpy(xp, sp, p - sp);
1261 xp += p - sp;
1262 *xp++ = DIRSEP;
1263 }
1264 sp = p;
1265 XcheckN(xs, xp, namelen);
1266 memcpy(xp, name, namelen);
1267 if (search_access(Xstring(xs, xp), mode, errnop) == 0)
1268 #ifdef OS2
1269 return Xstring(xs, xp); /* Not Xclose() - see above */
1270 #else /* OS2 */
1271 return Xclose(xs, xp + namelen);
1272 #endif /* OS2 */
1273 if (*sp++ == '\0')
1274 sp = NULL;
1275 }
1276 Xfree(xs, xp);
1277 return NULL;
1278 }
1279
1280 static int
call_builtin(tp,wp)1281 call_builtin(tp, wp)
1282 struct tbl *tp;
1283 char **wp;
1284 {
1285 int rv;
1286
1287 builtin_argv0 = wp[0];
1288 builtin_flag = tp->flag;
1289 shf_reopen(1, SHF_WR, shl_stdout);
1290 shl_stdout_ok = 1;
1291 ksh_getopt_reset(&builtin_opt, GF_ERROR);
1292 rv = (*tp->val.f)(wp);
1293 shf_flush(shl_stdout);
1294 shl_stdout_ok = 0;
1295 builtin_flag = 0;
1296 builtin_argv0 = (char *) 0;
1297 return rv;
1298 }
1299
1300 /*
1301 * set up redirection, saving old fd's in e->savefd
1302 */
1303 static int
iosetup(iop,tp)1304 iosetup(iop, tp)
1305 register struct ioword *iop;
1306 struct tbl *tp;
1307 {
1308 register int u = -1;
1309 char *cp = iop->name;
1310 int iotype = iop->flag & IOTYPE;
1311 int do_open = 1, do_close = 0, UNINITIALIZED(flags);
1312 struct ioword iotmp;
1313 struct stat statb;
1314
1315 if (iotype != IOHERE)
1316 cp = evalonestr(cp, DOTILDE|(Flag(FTALKING_I) ? DOGLOB : 0));
1317
1318 /* Used for tracing and error messages to print expanded cp */
1319 iotmp = *iop;
1320 iotmp.name = (iotype == IOHERE) ? (char *) 0 : cp;
1321 iotmp.flag |= IONAMEXP;
1322
1323 if (Flag(FXTRACE))
1324 shellf("%s%s\n",
1325 PS4_SUBSTITUTE(str_val(global("PS4"))),
1326 snptreef((char *) 0, 32, "%R", &iotmp));
1327
1328 switch (iotype) {
1329 case IOREAD:
1330 flags = O_RDONLY;
1331 break;
1332
1333 case IOCAT:
1334 flags = O_WRONLY | O_APPEND | O_CREAT;
1335 break;
1336
1337 case IOWRITE:
1338 flags = O_WRONLY | O_CREAT | O_TRUNC;
1339 /* The stat() is here to allow redirections to
1340 * things like /dev/null without error.
1341 */
1342 if (Flag(FNOCLOBBER) && !(iop->flag & IOCLOB)
1343 && (stat(cp, &statb) < 0 || S_ISREG(statb.st_mode)))
1344 flags |= O_EXCL;
1345 break;
1346
1347 case IORDWR:
1348 flags = O_RDWR | O_CREAT;
1349 break;
1350
1351 case IOHERE:
1352 do_open = 0;
1353 /* herein() returns -2 if error has been printed */
1354 u = herein(iop->heredoc, iop->flag & IOEVAL);
1355 /* cp may have wrong name */
1356 break;
1357
1358 case IODUP:
1359 {
1360 const char *emsg;
1361
1362 do_open = 0;
1363 if (*cp == '-' && !cp[1]) {
1364 u = 1009; /* prevent error return below */
1365 do_close = 1;
1366 } else if ((u = check_fd(cp,
1367 X_OK | ((iop->flag & IORDUP) ? R_OK : W_OK),
1368 &emsg)) < 0)
1369 {
1370 warningf(TRUE, "%s: %s",
1371 snptreef((char *) 0, 32, "%R", &iotmp), emsg);
1372 return -1;
1373 }
1374 if (u == iop->unit)
1375 return 0; /* "dup from" == "dup to" */
1376 break;
1377 }
1378 }
1379 if (do_open) {
1380 if (Flag(FRESTRICTED) && (flags & O_CREAT)) {
1381 warningf(TRUE, "%s: restricted", cp);
1382 return -1;
1383 }
1384 u = open(cp, flags, 0666);
1385 #ifdef OS2
1386 if (u < 0 && strcmp(cp, "/dev/null") == 0)
1387 u = open("nul", flags, 0666);
1388 #endif /* OS2 */
1389 }
1390 if (u < 0) {
1391 /* herein() may already have printed message */
1392 if (u == -1)
1393 warningf(TRUE, "cannot %s %s: %s",
1394 iotype == IODUP ? "dup"
1395 : (iotype == IOREAD || iotype == IOHERE) ?
1396 "open" : "create", cp, strerror(errno));
1397 return -1;
1398 }
1399 /* Do not save if it has already been redirected (i.e. "cat >x >y"). */
1400 if (e->savefd[iop->unit] == 0) {
1401 /* If these are the same, it means unit was previously closed */
1402 if (u == iop->unit)
1403 e->savefd[iop->unit] = -1;
1404 else
1405 /* c_exec() assumes e->savefd[fd] set for any
1406 * redirections. Ask savefd() not to close iop->unit;
1407 * this allows error messages to be seen if iop->unit
1408 * is 2; also means we can't lose the fd (eg, both
1409 * dup2 below and dup2 in restfd() failing).
1410 */
1411 e->savefd[iop->unit] = savefd(iop->unit, 1);
1412 }
1413
1414 if (do_close)
1415 close(iop->unit);
1416 else if (u != iop->unit) {
1417 if (ksh_dup2(u, iop->unit, TRUE) < 0) {
1418 warningf(TRUE,
1419 "could not finish (dup) redirection %s: %s",
1420 snptreef((char *) 0, 32, "%R", &iotmp),
1421 strerror(errno));
1422 if (iotype != IODUP)
1423 close(u);
1424 return -1;
1425 }
1426 if (iotype != IODUP)
1427 close(u);
1428 #ifdef KSH
1429 /* Touching any co-process fd in an empty exec
1430 * causes the shell to close its copies
1431 */
1432 else if (tp && tp->type == CSHELL && tp->val.f == c_exec) {
1433 if (iop->flag & IORDUP) /* possible exec <&p */
1434 coproc_read_close(u);
1435 else /* possible exec >&p */
1436 coproc_write_close(u);
1437 }
1438 #endif /* KSH */
1439 }
1440 if (u == 2) /* Clear any write errors */
1441 shf_reopen(2, SHF_WR, shl_out);
1442 return 0;
1443 }
1444
1445 /*
1446 * open here document temp file.
1447 * if unquoted here, expand here temp file into second temp file.
1448 */
1449 static int
herein(content,sub)1450 herein(content, sub)
1451 const char *content;
1452 int sub;
1453 {
1454 volatile int fd = -1;
1455 struct source *s, *volatile osource;
1456 struct shf *volatile shf;
1457 struct temp *h;
1458 int i;
1459
1460 /* ksh -c 'cat << EOF' can cause this... */
1461 if (content == (char *) 0) {
1462 warningf(TRUE, "here document missing");
1463 return -2; /* special to iosetup(): don't print error */
1464 }
1465
1466 /* Create temp file to hold content (done before newenv so temp
1467 * doesn't get removed too soon).
1468 */
1469 h = maketemp(ATEMP, TT_HEREDOC_EXP, &e->temps);
1470 if (!(shf = h->shf) || (fd = open(h->name, O_RDONLY, 0)) < 0) {
1471 warningf(TRUE, "can't %s temporary file %s: %s",
1472 !shf ? "create" : "open",
1473 h->name, strerror(errno));
1474 if (shf)
1475 shf_close(shf);
1476 return -2 /* special to iosetup(): don't print error */;
1477 }
1478
1479 osource = source;
1480 newenv(E_ERRH);
1481 i = ksh_sigsetjmp(e->jbuf, 0);
1482 if (i) {
1483 source = osource;
1484 quitenv();
1485 shf_close(shf); /* after quitenv */
1486 close(fd);
1487 return -2; /* special to iosetup(): don't print error */
1488 }
1489 if (sub) {
1490 /* Do substitutions on the content of heredoc */
1491 s = pushs(SSTRING, ATEMP);
1492 s->start = s->str = content;
1493 source = s;
1494 if (yylex(ONEWORD|HEREDOC) != LWORD)
1495 internal_errorf(1, "herein: yylex");
1496 source = osource;
1497 shf_puts(evalstr(yylval.cp, 0), shf);
1498 } else
1499 shf_puts(content, shf);
1500
1501 quitenv();
1502
1503 if (shf_close(shf) == EOF) {
1504 close(fd);
1505 warningf(TRUE, "error writing %s: %s", h->name,
1506 strerror(errno));
1507 return -2; /* special to iosetup(): don't print error */
1508 }
1509
1510 return fd;
1511 }
1512
1513 #ifdef KSH
1514 /*
1515 * ksh special - the select command processing section
1516 * print the args in column form - assuming that we can
1517 */
1518 static char *
do_selectargs(ap,print_menu)1519 do_selectargs(ap, print_menu)
1520 register char **ap;
1521 bool_t print_menu;
1522 {
1523 static const char *const read_args[] = {
1524 "read", "-r", "REPLY", (char *) 0
1525 };
1526 char *s;
1527 int i, argct;
1528
1529 for (argct = 0; ap[argct]; argct++)
1530 ;
1531 while (1) {
1532 /* Menu is printed if
1533 * - this is the first time around the select loop
1534 * - the user enters a blank line
1535 * - the REPLY parameter is empty
1536 */
1537 if (print_menu || !*str_val(global("REPLY")))
1538 pr_menu(ap);
1539 shellf("%s", str_val(global("PS3")));
1540 if (call_builtin(findcom("read", FC_BI),
1541 (char **) __UNCONST(read_args)))
1542 return (char *) 0;
1543 s = str_val(global("REPLY"));
1544 if (*s) {
1545 i = atoi(s);
1546 return (i >= 1 && i <= argct) ? ap[i - 1] : null;
1547 }
1548 print_menu = 1;
1549 }
1550 }
1551
1552 struct select_menu_info {
1553 char *const *args;
1554 int arg_width;
1555 int num_width;
1556 } info;
1557
1558 static char *select_fmt_entry ARGS((void *arg, int i, char *buf, int buflen));
1559
1560 /* format a single select menu item */
1561 static char *
select_fmt_entry(arg,i,buf,buflen)1562 select_fmt_entry(arg, i, buf, buflen)
1563 void *arg;
1564 int i;
1565 char *buf;
1566 int buflen;
1567 {
1568 struct select_menu_info *smi = (struct select_menu_info *) arg;
1569
1570 shf_snprintf(buf, buflen, "%*d) %s",
1571 smi->num_width, i + 1, smi->args[i]);
1572 return buf;
1573 }
1574
1575 /*
1576 * print a select style menu
1577 */
1578 int
pr_menu(ap)1579 pr_menu(ap)
1580 char *const *ap;
1581 {
1582 struct select_menu_info smi;
1583 char *const *pp;
1584 int nwidth, dwidth;
1585 int i, n;
1586
1587 /* Width/column calculations were done once and saved, but this
1588 * means select can't be used recursively so we re-calculate each
1589 * time (could save in a structure that is returned, but its probably
1590 * not worth the bother).
1591 */
1592
1593 /*
1594 * get dimensions of the list
1595 */
1596 for (n = 0, nwidth = 0, pp = ap; *pp; n++, pp++) {
1597 i = strlen(*pp);
1598 nwidth = (i > nwidth) ? i : nwidth;
1599 }
1600 /*
1601 * we will print an index of the form
1602 * %d)
1603 * in front of each entry
1604 * get the max width of this
1605 */
1606 for (i = n, dwidth = 1; i >= 10; i /= 10)
1607 dwidth++;
1608
1609 smi.args = ap;
1610 smi.arg_width = nwidth;
1611 smi.num_width = dwidth;
1612 print_columns(shl_out, n, select_fmt_entry, (void *) &smi,
1613 dwidth + nwidth + 2, 1);
1614
1615 return n;
1616 }
1617
1618 /* XXX: horrible kludge to fit within the framework */
1619
1620 static char *plain_fmt_entry ARGS((void *arg, int i, char *buf, int buflen));
1621
1622 static char *
plain_fmt_entry(arg,i,buf,buflen)1623 plain_fmt_entry(arg, i, buf, buflen)
1624 void *arg;
1625 int i;
1626 char *buf;
1627 int buflen;
1628 {
1629 shf_snprintf(buf, buflen, "%s", ((char *const *)arg)[i]);
1630 return buf;
1631 }
1632
1633 int
pr_list(ap)1634 pr_list(ap)
1635 char *const *ap;
1636 {
1637 char *const *pp;
1638 int nwidth;
1639 int i, n;
1640
1641 for (n = 0, nwidth = 0, pp = ap; *pp; n++, pp++) {
1642 i = strlen(*pp);
1643 nwidth = (i > nwidth) ? i : nwidth;
1644 }
1645 print_columns(shl_out, n, plain_fmt_entry, (void *)__UNCONST(ap),
1646 nwidth + 1, 0);
1647
1648 return n;
1649 }
1650 #endif /* KSH */
1651 #ifdef KSH
1652
1653 /*
1654 * [[ ... ]] evaluation routines
1655 */
1656
1657 extern const char *const dbtest_tokens[];
1658 extern const char db_close[];
1659
1660 /* Test if the current token is a whatever. Accepts the current token if
1661 * it is. Returns 0 if it is not, non-zero if it is (in the case of
1662 * TM_UNOP and TM_BINOP, the returned value is a Test_op).
1663 */
1664 static int
dbteste_isa(te,meta)1665 dbteste_isa(te, meta)
1666 Test_env *te;
1667 Test_meta meta;
1668 {
1669 int ret = 0;
1670 int uqword;
1671 char *p;
1672
1673 if (!*te->pos.wp)
1674 return meta == TM_END;
1675
1676 /* unquoted word? */
1677 for (p = *te->pos.wp; *p == CHAR; p += 2)
1678 ;
1679 uqword = *p == EOS;
1680
1681 if (meta == TM_UNOP || meta == TM_BINOP) {
1682 if (uqword) {
1683 char buf[8]; /* longer than the longest operator */
1684 char *q = buf;
1685 for (p = *te->pos.wp; *p == CHAR
1686 && q < &buf[sizeof(buf) - 1];
1687 p += 2)
1688 *q++ = p[1];
1689 *q = '\0';
1690 ret = (int) test_isop(te, meta, buf);
1691 }
1692 } else if (meta == TM_END)
1693 ret = 0;
1694 else
1695 ret = uqword
1696 && strcmp(*te->pos.wp, dbtest_tokens[(int) meta]) == 0;
1697
1698 /* Accept the token? */
1699 if (ret)
1700 te->pos.wp++;
1701
1702 return ret;
1703 }
1704
1705 static const char *
dbteste_getopnd(te,op,do_eval)1706 dbteste_getopnd(te, op, do_eval)
1707 Test_env *te;
1708 Test_op op;
1709 int do_eval;
1710 {
1711 char *s = *te->pos.wp;
1712
1713 if (!s)
1714 return (char *) 0;
1715
1716 te->pos.wp++;
1717
1718 if (!do_eval)
1719 return null;
1720
1721 if (op == TO_STEQL || op == TO_STNEQ)
1722 s = evalstr(s, DOTILDE | DOPAT);
1723 else
1724 s = evalstr(s, DOTILDE);
1725
1726 return s;
1727 }
1728
1729 static int
dbteste_eval(te,op,opnd1,opnd2,do_eval)1730 dbteste_eval(te, op, opnd1, opnd2, do_eval)
1731 Test_env *te;
1732 Test_op op;
1733 const char *opnd1;
1734 const char *opnd2;
1735 int do_eval;
1736 {
1737 return test_eval(te, op, opnd1, opnd2, do_eval);
1738 }
1739
1740 static void
dbteste_error(te,offset,msg)1741 dbteste_error(te, offset, msg)
1742 Test_env *te;
1743 int offset;
1744 const char *msg;
1745 {
1746 te->flags |= TEF_ERROR;
1747 internal_errorf(0, "dbteste_error: %s (offset %d)", msg, offset);
1748 }
1749 #endif /* KSH */
1750