1 /* $OpenBSD: exec.c,v 1.52 2015/09/10 22:48:58 nicm Exp $ */
2
3 /*-
4 * Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
5 * 2011, 2012, 2013, 2014, 2015, 2016
6 * mirabilos <m@mirbsd.org>
7 *
8 * Provided that these terms and disclaimer and all copyright notices
9 * are retained or reproduced in an accompanying document, permission
10 * is granted to deal in this work without restriction, including un-
11 * limited rights to use, publicly perform, distribute, sell, modify,
12 * merge, give away, or sublicence.
13 *
14 * This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to
15 * the utmost extent permitted by applicable law, neither express nor
16 * implied; without malicious intent or gross negligence. In no event
17 * may a licensor, author or contributor be held liable for indirect,
18 * direct, other damage, loss, or other issues arising in any way out
19 * of dealing in the work, even if advised of the possibility of such
20 * damage or existence of a defect, except proven that it results out
21 * of said person's immediate fault when using the work as intended.
22 */
23
24 #include "sh.h"
25
26 __RCSID("$MirOS: src/bin/mksh/exec.c,v 1.186 2016/11/11 23:31:34 tg Exp $");
27
28 #ifndef MKSH_DEFAULT_EXECSHELL
29 #define MKSH_DEFAULT_EXECSHELL MKSH_UNIXROOT "/bin/sh"
30 #endif
31
32 static int comexec(struct op *, struct tbl * volatile, const char **,
33 int volatile, volatile int *);
34 static void scriptexec(struct op *, const char **) MKSH_A_NORETURN;
35 static int call_builtin(struct tbl *, const char **, const char *, bool);
36 static int iosetup(struct ioword *, struct tbl *);
37 static const char *do_selectargs(const char **, bool);
38 static Test_op dbteste_isa(Test_env *, Test_meta);
39 static const char *dbteste_getopnd(Test_env *, Test_op, bool);
40 static void dbteste_error(Test_env *, int, const char *);
41 /* XXX: horrible kludge to fit within the framework */
42 static void plain_fmt_entry(char *, size_t, unsigned int, const void *);
43 static void select_fmt_entry(char *, size_t, unsigned int, const void *);
44
45 /*
46 * execute command tree
47 */
48 int
execute(struct op * volatile t,volatile int flags,volatile int * volatile xerrok)49 execute(struct op * volatile t,
50 /* if XEXEC don't fork */
51 volatile int flags,
52 volatile int * volatile xerrok)
53 {
54 int i;
55 volatile int rv = 0, dummy = 0;
56 int pv[2];
57 const char ** volatile ap = NULL;
58 char ** volatile up;
59 const char *s, *ccp;
60 struct ioword **iowp;
61 struct tbl *tp = NULL;
62
63 if (t == NULL)
64 return (0);
65
66 /* Caller doesn't care if XERROK should propagate. */
67 if (xerrok == NULL)
68 xerrok = &dummy;
69
70 if ((flags&XFORK) && !(flags&XEXEC) && t->type != TPIPE)
71 /* run in sub-process */
72 return (exchild(t, flags & ~XTIME, xerrok, -1));
73
74 newenv(E_EXEC);
75 if (trap)
76 runtraps(0);
77
78 /* we want to run an executable, do some variance checks */
79 if (t->type == TCOM) {
80 /*
81 * Clear subst_exstat before argument expansion. Used by
82 * null commands (see comexec() and c_eval()) and by c_set().
83 */
84 subst_exstat = 0;
85
86 /* for $LINENO */
87 current_lineno = t->lineno;
88
89 /* check if this is 'var=<<EOF' */
90 if (
91 /* we have zero arguments, i.e. no program to run */
92 t->args[0] == NULL &&
93 /* we have exactly one variable assignment */
94 t->vars[0] != NULL && t->vars[1] == NULL &&
95 /* we have exactly one I/O redirection */
96 t->ioact != NULL && t->ioact[0] != NULL &&
97 t->ioact[1] == NULL &&
98 /* of type "here document" (or "here string") */
99 (t->ioact[0]->ioflag & IOTYPE) == IOHERE &&
100 /* the variable assignment begins with a valid varname */
101 (ccp = skip_wdvarname(t->vars[0], true)) != t->vars[0] &&
102 /* and has no right-hand side (i.e. "varname=") */
103 ccp[0] == CHAR && ((ccp[1] == '=' && ccp[2] == EOS) ||
104 /* or "varname+=" */ (ccp[1] == '+' && ccp[2] == CHAR &&
105 ccp[3] == '=' && ccp[4] == EOS))) {
106 char *cp, *dp;
107
108 if ((rv = herein(t->ioact[0], &cp) /*? 1 : 0*/))
109 cp = NULL;
110 dp = shf_smprintf(Tf_ss, evalstr(t->vars[0],
111 DOASNTILDE | DOSCALAR), rv ? null : cp);
112 typeset(dp, Flag(FEXPORT) ? EXPORT : 0, 0, 0, 0);
113 /* free the expanded value */
114 afree(cp, APERM);
115 afree(dp, ATEMP);
116 goto Break;
117 }
118
119 /*
120 * POSIX says expand command words first, then redirections,
121 * and assignments last..
122 */
123 up = eval(t->args, t->u.evalflags | DOBLANK | DOGLOB | DOTILDE);
124 if (flags & XTIME)
125 /* Allow option parsing (bizarre, but POSIX) */
126 timex_hook(t, &up);
127 ap = (const char **)up;
128 if (ap[0])
129 tp = findcom(ap[0], FC_BI|FC_FUNC);
130 }
131 flags &= ~XTIME;
132
133 if (t->ioact != NULL || t->type == TPIPE || t->type == TCOPROC) {
134 e->savefd = alloc2(NUFILE, sizeof(short), ATEMP);
135 /* initialise to not redirected */
136 memset(e->savefd, 0, NUFILE * sizeof(short));
137 }
138
139 /* mark for replacement later (unless TPIPE) */
140 vp_pipest->flag |= INT_L;
141
142 /* do redirection, to be restored in quitenv() */
143 if (t->ioact != NULL)
144 for (iowp = t->ioact; *iowp != NULL; iowp++) {
145 if (iosetup(*iowp, tp) < 0) {
146 exstat = rv = 1;
147 /*
148 * Redirection failures for special commands
149 * cause (non-interactive) shell to exit.
150 */
151 if (tp && tp->type == CSHELL &&
152 (tp->flag & SPEC_BI))
153 errorfz();
154 /* Deal with FERREXIT, quitenv(), etc. */
155 goto Break;
156 }
157 }
158
159 switch (t->type) {
160 case TCOM:
161 rv = comexec(t, tp, (const char **)ap, flags, xerrok);
162 break;
163
164 case TPAREN:
165 rv = execute(t->left, flags | XFORK, xerrok);
166 break;
167
168 case TPIPE:
169 flags |= XFORK;
170 flags &= ~XEXEC;
171 e->savefd[0] = savefd(0);
172 e->savefd[1] = savefd(1);
173 while (t->type == TPIPE) {
174 openpipe(pv);
175 /* stdout of curr */
176 ksh_dup2(pv[1], 1, false);
177 /**
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,
184 NULL, pv[0]);
185 /* stdin of next */
186 ksh_dup2(pv[0], 0, false);
187 closepipe(pv);
188 flags |= XPIPEI;
189 t = t->right;
190 }
191 /* stdout of last */
192 restfd(1, e->savefd[1]);
193 /* no need to re-restore this */
194 e->savefd[1] = 0;
195 /* Let exchild() close 0 in parent, after fork, before wait */
196 i = exchild(t, flags | XPCLOSE | XPIPEST, xerrok, 0);
197 if (!(flags&XBGND) && !(flags&XXCOM))
198 rv = i;
199 break;
200
201 case TLIST:
202 while (t->type == TLIST) {
203 execute(t->left, flags & XERROK, NULL);
204 t = t->right;
205 }
206 rv = execute(t, flags & XERROK, xerrok);
207 break;
208
209 case TCOPROC: {
210 #ifndef MKSH_NOPROSPECTOFWORK
211 sigset_t omask;
212
213 /*
214 * Block sigchild as we are using things changed in the
215 * signal handler
216 */
217 sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
218 e->type = E_ERRH;
219 if ((i = kshsetjmp(e->jbuf))) {
220 sigprocmask(SIG_SETMASK, &omask, NULL);
221 quitenv(NULL);
222 unwind(i);
223 /* NOTREACHED */
224 }
225 #endif
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);
235 e->savefd[1] = savefd(1);
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 = NULL;
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 /* closed before first read */
252 coproc.readw = pv[1];
253 coproc.njobs = 0;
254 /* create new coprocess id */
255 ++coproc.id;
256 }
257 #ifndef MKSH_NOPROSPECTOFWORK
258 sigprocmask(SIG_SETMASK, &omask, NULL);
259 /* no more need for error handler */
260 e->type = E_EXEC;
261 #endif
262
263 /*
264 * exchild() closes coproc.* in child after fork,
265 * will also increment coproc.njobs when the
266 * job is actually created.
267 */
268 flags &= ~XEXEC;
269 exchild(t->left, flags | XBGND | XFORK | XCOPROC | XCCLOSE,
270 NULL, coproc.readw);
271 break;
272 }
273
274 case TASYNC:
275 /*
276 * XXX non-optimal, I think - "(foo &)", forks for (),
277 * forks again for async... parent should optimise
278 * this to "foo &"...
279 */
280 rv = execute(t->left, (flags&~XEXEC)|XBGND|XFORK, xerrok);
281 break;
282
283 case TOR:
284 case TAND:
285 rv = execute(t->left, XERROK, NULL);
286 if ((rv == 0) == (t->type == TAND))
287 rv = execute(t->right, flags & XERROK, xerrok);
288 else {
289 flags |= XERROK;
290 if (xerrok)
291 *xerrok = 1;
292 }
293 break;
294
295 case TBANG:
296 rv = !execute(t->right, XERROK, xerrok);
297 flags |= XERROK;
298 if (xerrok)
299 *xerrok = 1;
300 break;
301
302 case TDBRACKET: {
303 Test_env te;
304
305 te.flags = TEF_DBRACKET;
306 te.pos.wp = t->args;
307 te.isa = dbteste_isa;
308 te.getopnd = dbteste_getopnd;
309 te.eval = test_eval;
310 te.error = dbteste_error;
311
312 rv = test_parse(&te);
313 break;
314 }
315
316 case TFOR:
317 case TSELECT: {
318 volatile bool is_first = true;
319
320 ap = (t->vars == NULL) ? e->loc->argv + 1 :
321 (const char **)eval((const char **)t->vars,
322 DOBLANK | DOGLOB | DOTILDE);
323 e->type = E_LOOP;
324 while ((i = kshsetjmp(e->jbuf))) {
325 if ((e->flags&EF_BRKCONT_PASS) ||
326 (i != LBREAK && i != LCONTIN)) {
327 quitenv(NULL);
328 unwind(i);
329 } else if (i == LBREAK) {
330 rv = 0;
331 goto Break;
332 }
333 }
334 /* in case of a continue */
335 rv = 0;
336 if (t->type == TFOR) {
337 while (*ap != NULL) {
338 setstr(global(t->str), *ap++, KSH_UNWIND_ERROR);
339 rv = execute(t->left, flags & XERROK, xerrok);
340 }
341 } else {
342 do_TSELECT:
343 if ((ccp = do_selectargs(ap, is_first))) {
344 is_first = false;
345 setstr(global(t->str), ccp, KSH_UNWIND_ERROR);
346 execute(t->left, flags & XERROK, xerrok);
347 goto do_TSELECT;
348 }
349 rv = 1;
350 }
351 break;
352 }
353
354 case TWHILE:
355 case TUNTIL:
356 e->type = E_LOOP;
357 while ((i = kshsetjmp(e->jbuf))) {
358 if ((e->flags&EF_BRKCONT_PASS) ||
359 (i != LBREAK && i != LCONTIN)) {
360 quitenv(NULL);
361 unwind(i);
362 } else if (i == LBREAK) {
363 rv = 0;
364 goto Break;
365 }
366 }
367 /* in case of a continue */
368 rv = 0;
369 while ((execute(t->left, XERROK, NULL) == 0) ==
370 (t->type == TWHILE))
371 rv = execute(t->right, flags & XERROK, xerrok);
372 break;
373
374 case TIF:
375 case TELIF:
376 if (t->right == NULL)
377 /* should be error */
378 break;
379 rv = execute(t->left, XERROK, NULL) == 0 ?
380 execute(t->right->left, flags & XERROK, xerrok) :
381 execute(t->right->right, flags & XERROK, xerrok);
382 break;
383
384 case TCASE:
385 i = 0;
386 ccp = evalstr(t->str, DOTILDE | DOSCALAR);
387 for (t = t->left; t != NULL && t->type == TPAT; t = t->right) {
388 for (ap = (const char **)t->vars; *ap; ap++) {
389 if (i || ((s = evalstr(*ap, DOTILDE|DOPAT)) &&
390 gmatchx(ccp, s, false))) {
391 record_match(ccp);
392 rv = execute(t->left, flags & XERROK,
393 xerrok);
394 i = 0;
395 switch (t->u.charflag) {
396 case '&':
397 i = 1;
398 /* FALLTHROUGH */
399 case '|':
400 goto TCASE_next;
401 }
402 goto TCASE_out;
403 }
404 }
405 i = 0;
406 TCASE_next:
407 /* empty */;
408 }
409 TCASE_out:
410 break;
411
412 case TBRACE:
413 rv = execute(t->left, flags & XERROK, xerrok);
414 break;
415
416 case TFUNCT:
417 rv = define(t->str, t);
418 break;
419
420 case TTIME:
421 /*
422 * Clear XEXEC so nested execute() call doesn't exit
423 * (allows "ls -l | time grep foo").
424 */
425 rv = timex(t, flags & ~XEXEC, xerrok);
426 break;
427
428 case TEXEC:
429 /* an eval'd TCOM */
430 up = makenv();
431 restoresigs();
432 cleanup_proc_env();
433 {
434 union mksh_ccphack cargs;
435
436 cargs.ro = t->args;
437 execve(t->str, cargs.rw, up);
438 rv = errno;
439 }
440 if (rv == ENOEXEC)
441 scriptexec(t, (const char **)up);
442 else
443 errorf(Tf_sD_s, t->str, cstrerror(rv));
444 }
445 Break:
446 exstat = rv & 0xFF;
447 if (vp_pipest->flag & INT_L) {
448 unset(vp_pipest, 1);
449 vp_pipest->flag = DEFINED | ISSET | INTEGER | RDONLY |
450 ARRAY | INT_U | INT_L;
451 vp_pipest->val.i = rv;
452 }
453
454 /* restores IO */
455 quitenv(NULL);
456 if ((flags&XEXEC))
457 /* exit child */
458 unwind(LEXIT);
459 if (rv != 0 && !(flags & XERROK) &&
460 (xerrok == NULL || !*xerrok)) {
461 if (Flag(FERREXIT) & 0x80) {
462 /* inside eval */
463 Flag(FERREXIT) = 0;
464 } else {
465 trapsig(ksh_SIGERR);
466 if (Flag(FERREXIT))
467 unwind(LERROR);
468 }
469 }
470 return (rv);
471 }
472
473 /*
474 * execute simple command
475 */
476
477 static int
comexec(struct op * t,struct tbl * volatile tp,const char ** ap,volatile int flags,volatile int * xerrok)478 comexec(struct op *t, struct tbl * volatile tp, const char **ap,
479 volatile int flags, volatile int *xerrok)
480 {
481 int i;
482 volatile int rv = 0;
483 const char *cp;
484 const char **lastp;
485 /* Must be static (XXX but why?) */
486 static struct op texec;
487 int type_flags;
488 bool resetspec;
489 int fcflags = FC_BI|FC_FUNC|FC_PATH;
490 struct block *l_expand, *l_assign;
491 int optc;
492 const char *exec_argv0 = NULL;
493 bool exec_clrenv = false;
494
495 /* snag the last argument for $_ */
496 if (Flag(FTALKING) && *(lastp = ap)) {
497 /*
498 * XXX not the same as AT&T ksh, which only seems to set $_
499 * after a newline (but not in functions/dot scripts, but in
500 * interactive and script) - perhaps save last arg here and
501 * set it in shell()?.
502 */
503 while (*++lastp)
504 ;
505 /* setstr() can't fail here */
506 setstr(typeset("_", LOCAL, 0, INTEGER, 0), *--lastp,
507 KSH_RETURN_ERROR);
508 }
509
510 /**
511 * Deal with the shell builtins builtin, exec and command since
512 * they can be followed by other commands. This must be done before
513 * we know if we should create a local block which must be done
514 * before we can do a path search (in case the assignments change
515 * PATH).
516 * Odd cases:
517 * FOO=bar exec >/dev/null FOO is kept but not exported
518 * FOO=bar exec foobar FOO is exported
519 * FOO=bar command exec >/dev/null FOO is neither kept nor exported
520 * FOO=bar command FOO is neither kept nor exported
521 * PATH=... foobar use new PATH in foobar search
522 */
523 resetspec = false;
524 while (tp && tp->type == CSHELL) {
525 /* undo effects of command */
526 fcflags = FC_BI|FC_FUNC|FC_PATH;
527 if (tp->val.f == c_builtin) {
528 if ((cp = *++ap) == NULL ||
529 (!strcmp(cp, "--") && (cp = *++ap) == NULL)) {
530 tp = NULL;
531 break;
532 }
533 if ((tp = findcom(cp, FC_BI)) == NULL)
534 errorf(Tf_sD_sD_s, Tbuiltin, cp, Tnot_found);
535 if (tp->type == CSHELL && (tp->flag & LOW_BI))
536 break;
537 continue;
538 } else if (tp->val.f == c_exec) {
539 if (ap[1] == NULL)
540 break;
541 ksh_getopt_reset(&builtin_opt, GF_ERROR);
542 while ((optc = ksh_getopt(ap, &builtin_opt, "a:c")) != -1)
543 switch (optc) {
544 case 'a':
545 exec_argv0 = builtin_opt.optarg;
546 break;
547 case 'c':
548 exec_clrenv = true;
549 /* ensure we can actually do this */
550 resetspec = true;
551 break;
552 default:
553 rv = 2;
554 goto Leave;
555 }
556 ap += builtin_opt.optind;
557 flags |= XEXEC;
558 } else if (tp->val.f == c_command) {
559 bool saw_p = false;
560
561 /*
562 * Ugly dealing with options in two places (here
563 * and in c_command(), but such is life)
564 */
565 ksh_getopt_reset(&builtin_opt, 0);
566 while ((optc = ksh_getopt(ap, &builtin_opt, ":p")) == 'p')
567 saw_p = true;
568 if (optc != -1)
569 /* command -vV or something */
570 break;
571 /* don't look for functions */
572 fcflags = FC_BI|FC_PATH;
573 if (saw_p) {
574 if (Flag(FRESTRICTED)) {
575 warningf(true, Tf_sD_s,
576 "command -p", "restricted");
577 rv = 1;
578 goto Leave;
579 }
580 fcflags |= FC_DEFPATH;
581 }
582 ap += builtin_opt.optind;
583 /*
584 * POSIX says special builtins lose their status
585 * if accessed using command.
586 */
587 resetspec = true;
588 if (!ap[0]) {
589 /* ensure command with no args exits with 0 */
590 subst_exstat = 0;
591 break;
592 }
593 } else if (tp->flag & LOW_BI) {
594 /* if we have any flags, do not use the builtin */
595 if ((ap[1] && ap[1][0] == '-' && ap[1][1] != '\0' &&
596 /* argument, begins with -, is not - or -- */
597 (ap[1][1] != '-' || ap[1][2] != '\0')) ||
598 /* always prefer the external utility */
599 (tp->flag & LOWER_BI)) {
600 struct tbl *ext_cmd;
601
602 ext_cmd = findcom(tp->name, FC_PATH | FC_FUNC);
603 if (ext_cmd && (ext_cmd->type != CTALIAS ||
604 (ext_cmd->flag & ISSET)))
605 tp = ext_cmd;
606 }
607 break;
608 } else if (tp->val.f == c_trap) {
609 t->u.evalflags &= ~DOTCOMEXEC;
610 break;
611 } else
612 break;
613 tp = findcom(ap[0], fcflags & (FC_BI|FC_FUNC));
614 }
615 if (t->u.evalflags & DOTCOMEXEC)
616 flags |= XEXEC;
617 l_expand = e->loc;
618 if (!resetspec && (!ap[0] || (tp && (tp->flag & KEEPASN))))
619 type_flags = 0;
620 else {
621 /* create new variable/function block */
622 newblock();
623 /* ksh functions don't keep assignments, POSIX functions do. */
624 if (!resetspec && tp && tp->type == CFUNC &&
625 !(tp->flag & FKSH))
626 type_flags = EXPORT;
627 else
628 type_flags = LOCAL|LOCAL_COPY|EXPORT;
629 }
630 l_assign = e->loc;
631 if (exec_clrenv)
632 l_assign->flags |= BF_STOPENV;
633 if (Flag(FEXPORT))
634 type_flags |= EXPORT;
635 if (Flag(FXTRACE))
636 change_xtrace(2, false);
637 for (i = 0; t->vars[i]; i++) {
638 /* do NOT lookup in the new var/fn block just created */
639 e->loc = l_expand;
640 cp = evalstr(t->vars[i], DOASNTILDE | DOSCALAR);
641 e->loc = l_assign;
642 if (Flag(FXTRACE)) {
643 const char *ccp;
644
645 ccp = skip_varname(cp, true);
646 if (*ccp == '+')
647 ++ccp;
648 if (*ccp == '=')
649 ++ccp;
650 shf_write(cp, ccp - cp, shl_xtrace);
651 print_value_quoted(shl_xtrace, ccp);
652 shf_putc(' ', shl_xtrace);
653 }
654 /* but assign in there as usual */
655 typeset(cp, type_flags, 0, 0, 0);
656 }
657
658 if (Flag(FXTRACE)) {
659 change_xtrace(2, false);
660 if (ap[rv = 0]) {
661 xtrace_ap_loop:
662 print_value_quoted(shl_xtrace, ap[rv]);
663 if (ap[++rv]) {
664 shf_putc(' ', shl_xtrace);
665 goto xtrace_ap_loop;
666 }
667 }
668 change_xtrace(1, false);
669 }
670
671 if ((cp = *ap) == NULL) {
672 rv = subst_exstat;
673 goto Leave;
674 } else if (!tp) {
675 if (Flag(FRESTRICTED) && mksh_vdirsep(cp)) {
676 warningf(true, Tf_sD_s, cp, "restricted");
677 rv = 1;
678 goto Leave;
679 }
680 tp = findcom(cp, fcflags);
681 }
682
683 switch (tp->type) {
684
685 /* shell built-in */
686 case CSHELL:
687 do_call_builtin:
688 rv = call_builtin(tp, (const char **)ap, null, resetspec);
689 if (resetspec && tp->val.f == c_shift) {
690 l_expand->argc = l_assign->argc;
691 l_expand->argv = l_assign->argv;
692 }
693 break;
694
695 /* function call */
696 case CFUNC: {
697 volatile uint32_t old_inuse;
698 const char * volatile old_kshname;
699 volatile uint8_t old_flags[FNFLAGS];
700
701 if (!(tp->flag & ISSET)) {
702 struct tbl *ftp;
703
704 if (!tp->u.fpath) {
705 fpath_error:
706 rv = (tp->u2.errnov == ENOENT) ? 127 : 126;
707 warningf(true, Tf_sD_s_sD_s, cp,
708 Tcant_find, Tfile_fd,
709 cstrerror(tp->u2.errnov));
710 break;
711 }
712 errno = 0;
713 if (include(tp->u.fpath, 0, NULL, false) < 0 ||
714 !(ftp = findfunc(cp, hash(cp), false)) ||
715 !(ftp->flag & ISSET)) {
716 rv = errno;
717 if ((ftp = findcom(cp, FC_BI)) &&
718 (ftp->type == CSHELL) &&
719 (ftp->flag & LOW_BI)) {
720 tp = ftp;
721 goto do_call_builtin;
722 }
723 if (rv) {
724 tp->u2.errnov = rv;
725 cp = tp->u.fpath;
726 goto fpath_error;
727 }
728 warningf(true, Tf_sD_s_s, cp,
729 "function not defined by", tp->u.fpath);
730 rv = 127;
731 break;
732 }
733 tp = ftp;
734 }
735
736 /*
737 * ksh functions set $0 to function name, POSIX
738 * functions leave $0 unchanged.
739 */
740 old_kshname = kshname;
741 if (tp->flag & FKSH)
742 kshname = ap[0];
743 else
744 ap[0] = kshname;
745 e->loc->argv = ap;
746 for (i = 0; *ap++ != NULL; i++)
747 ;
748 e->loc->argc = i - 1;
749 /*
750 * ksh-style functions handle getopts sanely,
751 * Bourne/POSIX functions are insane...
752 */
753 if (tp->flag & FKSH) {
754 e->loc->flags |= BF_DOGETOPTS;
755 e->loc->getopts_state = user_opt;
756 getopts_reset(1);
757 }
758
759 for (type_flags = 0; type_flags < FNFLAGS; ++type_flags)
760 old_flags[type_flags] = shell_flags[type_flags];
761 change_xtrace((Flag(FXTRACEREC) ? Flag(FXTRACE) : 0) |
762 ((tp->flag & TRACE) ? 1 : 0), false);
763 old_inuse = tp->flag & FINUSE;
764 tp->flag |= FINUSE;
765
766 e->type = E_FUNC;
767 if (!(i = kshsetjmp(e->jbuf))) {
768 execute(tp->val.t, flags & XERROK, NULL);
769 i = LRETURN;
770 }
771
772 kshname = old_kshname;
773 change_xtrace(old_flags[(int)FXTRACE], false);
774 #ifndef MKSH_LEGACY_MODE
775 if (tp->flag & FKSH) {
776 /* Korn style functions restore Flags on return */
777 old_flags[(int)FXTRACE] = Flag(FXTRACE);
778 for (type_flags = 0; type_flags < FNFLAGS; ++type_flags)
779 shell_flags[type_flags] = old_flags[type_flags];
780 }
781 #endif
782 tp->flag = (tp->flag & ~FINUSE) | old_inuse;
783
784 /*
785 * Were we deleted while executing? If so, free the
786 * execution tree.
787 */
788 if ((tp->flag & (FDELETE|FINUSE)) == FDELETE) {
789 if (tp->flag & ALLOC) {
790 tp->flag &= ~ALLOC;
791 tfree(tp->val.t, tp->areap);
792 }
793 tp->flag = 0;
794 }
795 switch (i) {
796 case LRETURN:
797 case LERROR:
798 rv = exstat & 0xFF;
799 break;
800 case LINTR:
801 case LEXIT:
802 case LLEAVE:
803 case LSHELL:
804 quitenv(NULL);
805 unwind(i);
806 /* NOTREACHED */
807 default:
808 quitenv(NULL);
809 internal_errorf(Tf_sd, "CFUNC", i);
810 }
811 break;
812 }
813
814 /* executable command */
815 case CEXEC:
816 /* tracked alias */
817 case CTALIAS:
818 if (!(tp->flag&ISSET)) {
819 if (tp->u2.errnov == ENOENT) {
820 rv = 127;
821 warningf(true, Tf_sD_s, cp, Tnot_found);
822 } else {
823 rv = 126;
824 warningf(true, Tf_sD_sD_s, cp, "can't execute",
825 cstrerror(tp->u2.errnov));
826 }
827 break;
828 }
829
830 /* set $_ to program's full path */
831 /* setstr() can't fail here */
832 setstr(typeset("_", LOCAL | EXPORT, 0, INTEGER, 0),
833 tp->val.s, KSH_RETURN_ERROR);
834
835 /* to fork, we set up a TEXEC node and call execute */
836 texec.type = TEXEC;
837 /* for vistree/dumptree */
838 texec.left = t;
839 texec.str = tp->val.s;
840 texec.args = ap;
841
842 /* in this case we do not fork, of course */
843 if (flags & XEXEC) {
844 if (exec_argv0)
845 texec.args[0] = exec_argv0;
846 j_exit();
847 if (!(flags & XBGND)
848 #ifndef MKSH_UNEMPLOYED
849 || Flag(FMONITOR)
850 #endif
851 ) {
852 setexecsig(&sigtraps[SIGINT], SS_RESTORE_ORIG);
853 setexecsig(&sigtraps[SIGQUIT], SS_RESTORE_ORIG);
854 }
855 }
856
857 rv = exchild(&texec, flags, xerrok, -1);
858 break;
859 }
860 Leave:
861 if (flags & XEXEC) {
862 exstat = rv & 0xFF;
863 unwind(LLEAVE);
864 }
865 return (rv);
866 }
867
868 static void
scriptexec(struct op * tp,const char ** ap)869 scriptexec(struct op *tp, const char **ap)
870 {
871 const char *sh;
872 #ifndef MKSH_SMALL
873 int fd;
874 unsigned char buf[68];
875 #endif
876 union mksh_ccphack args, cap;
877
878 sh = str_val(global(TEXECSHELL));
879 if (sh && *sh)
880 sh = search_path(sh, path, X_OK, NULL);
881 if (!sh || !*sh)
882 sh = MKSH_DEFAULT_EXECSHELL;
883
884 *tp->args-- = tp->str;
885
886 #ifndef MKSH_SMALL
887 if ((fd = binopen2(tp->str, O_RDONLY)) >= 0) {
888 unsigned char *cp;
889 unsigned short m;
890 ssize_t n;
891
892 /* read first couple of octets from file */
893 n = read(fd, buf, sizeof(buf) - 1);
894 close(fd);
895 /* read error or short read? */
896 if (n < 5)
897 goto nomagic;
898 /* terminate buffer */
899 buf[n] = '\0';
900
901 /* skip UTF-8 Byte Order Mark, if present */
902 cp = buf + (n = ((buf[0] == 0xEF) && (buf[1] == 0xBB) &&
903 (buf[2] == 0xBF)) ? 3 : 0);
904
905 /* scan for newline or NUL (end of buffer) */
906 while (*cp && *cp != '\n')
907 ++cp;
908 /* if the shebang line is longer than MAXINTERP, bail out */
909 if (!*cp)
910 goto noshebang;
911 /* replace newline by NUL */
912 *cp = '\0';
913
914 /* restore start of shebang position (buf+0 or buf+3) */
915 cp = buf + n;
916 /* bail out if no shebang magic found */
917 if (cp[0] == '#' && cp[1] == '!')
918 cp += 2;
919 #ifdef __OS2__
920 else if (!strncmp(cp, Textproc, 7) &&
921 (cp[7] == ' ' || cp[7] == '\t'))
922 cp += 8;
923 #endif
924 else
925 goto noshebang;
926 /* skip whitespace before shell name */
927 while (*cp == ' ' || *cp == '\t')
928 ++cp;
929 /* just whitespace on the line? */
930 if (*cp == '\0')
931 goto noshebang;
932 /* no, we actually found an interpreter name */
933 sh = (char *)cp;
934 /* look for end of shell/interpreter name */
935 while (*cp != ' ' && *cp != '\t' && *cp != '\0')
936 ++cp;
937 /* any arguments? */
938 if (*cp) {
939 *cp++ = '\0';
940 /* skip spaces before arguments */
941 while (*cp == ' ' || *cp == '\t')
942 ++cp;
943 /* pass it all in ONE argument (historic reasons) */
944 if (*cp)
945 *tp->args-- = (char *)cp;
946 }
947 goto nomagic;
948 noshebang:
949 m = buf[0] << 8 | buf[1];
950 if (m == 0x7F45 && buf[2] == 'L' && buf[3] == 'F')
951 errorf("%s: not executable: %d-bit ELF file", tp->str,
952 32 * buf[4]);
953 if ((m == /* OMAGIC */ 0407) ||
954 (m == /* NMAGIC */ 0410) ||
955 (m == /* ZMAGIC */ 0413) ||
956 (m == /* QMAGIC */ 0314) ||
957 (m == /* ECOFF_I386 */ 0x4C01) ||
958 (m == /* ECOFF_M68K */ 0x0150 || m == 0x5001) ||
959 (m == /* ECOFF_SH */ 0x0500 || m == 0x0005) ||
960 (m == /* bzip */ 0x425A) || (m == /* "MZ" */ 0x4D5A) ||
961 (m == /* "NE" */ 0x4E45) || (m == /* "LX" */ 0x4C58) ||
962 (m == /* ksh93 */ 0x0B13) || (m == /* LZIP */ 0x4C5A) ||
963 (m == /* xz */ 0xFD37 && buf[2] == 'z' && buf[3] == 'X' &&
964 buf[4] == 'Z') || (m == /* 7zip */ 0x377A) ||
965 (m == /* gzip */ 0x1F8B) || (m == /* .Z */ 0x1F9D))
966 errorf("%s: not executable: magic %04X", tp->str, m);
967 nomagic:
968 ;
969 }
970 #endif
971 args.ro = tp->args;
972 *args.ro = sh;
973
974 cap.ro = ap;
975 execve(args.rw[0], args.rw, cap.rw);
976
977 /* report both the programme that was run and the bogus interpreter */
978 errorf(Tf_sD_sD_s, tp->str, sh, cstrerror(errno));
979 }
980
981 int
shcomexec(const char ** wp)982 shcomexec(const char **wp)
983 {
984 struct tbl *tp;
985
986 tp = ktsearch(&builtins, *wp, hash(*wp));
987 return (call_builtin(tp, wp, "shcomexec", false));
988 }
989
990 /*
991 * Search function tables for a function. If create set, a table entry
992 * is created if none is found.
993 */
994 struct tbl *
findfunc(const char * name,uint32_t h,bool create)995 findfunc(const char *name, uint32_t h, bool create)
996 {
997 struct block *l;
998 struct tbl *tp = NULL;
999
1000 for (l = e->loc; l; l = l->next) {
1001 tp = ktsearch(&l->funs, name, h);
1002 if (tp)
1003 break;
1004 if (!l->next && create) {
1005 tp = ktenter(&l->funs, name, h);
1006 tp->flag = DEFINED;
1007 tp->type = CFUNC;
1008 tp->val.t = NULL;
1009 break;
1010 }
1011 }
1012 return (tp);
1013 }
1014
1015 /*
1016 * define function. Returns 1 if function is being undefined (t == 0) and
1017 * function did not exist, returns 0 otherwise.
1018 */
1019 int
define(const char * name,struct op * t)1020 define(const char *name, struct op *t)
1021 {
1022 uint32_t nhash;
1023 struct tbl *tp;
1024 bool was_set = false;
1025
1026 nhash = hash(name);
1027
1028 while (/* CONSTCOND */ 1) {
1029 tp = findfunc(name, nhash, true);
1030
1031 if (tp->flag & ISSET)
1032 was_set = true;
1033 /*
1034 * If this function is currently being executed, we zap
1035 * this table entry so findfunc() won't see it
1036 */
1037 if (tp->flag & FINUSE) {
1038 tp->name[0] = '\0';
1039 /* ensure it won't be found */
1040 tp->flag &= ~DEFINED;
1041 tp->flag |= FDELETE;
1042 } else
1043 break;
1044 }
1045
1046 if (tp->flag & ALLOC) {
1047 tp->flag &= ~(ISSET|ALLOC|FKSH);
1048 tfree(tp->val.t, tp->areap);
1049 }
1050
1051 if (t == NULL) {
1052 /* undefine */
1053 ktdelete(tp);
1054 return (was_set ? 0 : 1);
1055 }
1056
1057 tp->val.t = tcopy(t->left, tp->areap);
1058 tp->flag |= (ISSET|ALLOC);
1059 if (t->u.ksh_func)
1060 tp->flag |= FKSH;
1061
1062 return (0);
1063 }
1064
1065 /*
1066 * add builtin
1067 */
1068 const char *
builtin(const char * name,int (* func)(const char **))1069 builtin(const char *name, int (*func) (const char **))
1070 {
1071 struct tbl *tp;
1072 uint32_t flag = DEFINED;
1073
1074 /* see if any flags should be set for this builtin */
1075 flags_loop:
1076 switch (*name) {
1077 case '=':
1078 /* command does variable assignment */
1079 flag |= KEEPASN;
1080 break;
1081 case '*':
1082 /* POSIX special builtin */
1083 flag |= SPEC_BI;
1084 break;
1085 case '~':
1086 /* external utility overrides built-in utility, always */
1087 flag |= LOWER_BI;
1088 /* FALLTHROUGH */
1089 case '!':
1090 /* external utility overrides built-in utility, with flags */
1091 flag |= LOW_BI;
1092 break;
1093 default:
1094 goto flags_seen;
1095 }
1096 ++name;
1097 goto flags_loop;
1098 flags_seen:
1099
1100 /* enter into the builtins hash table */
1101 tp = ktenter(&builtins, name, hash(name));
1102 tp->flag = flag;
1103 tp->type = CSHELL;
1104 tp->val.f = func;
1105
1106 /* return name, for direct builtin call check in main.c */
1107 return (name);
1108 }
1109
1110 /*
1111 * find command
1112 * either function, hashed command, or built-in (in that order)
1113 */
1114 struct tbl *
findcom(const char * name,int flags)1115 findcom(const char *name, int flags)
1116 {
1117 static struct tbl temp;
1118 uint32_t h = hash(name);
1119 struct tbl *tp = NULL, *tbi;
1120 /* insert if not found */
1121 unsigned char insert = Flag(FTRACKALL);
1122 /* for function autoloading */
1123 char *fpath;
1124 union mksh_cchack npath;
1125
1126 if (mksh_vdirsep(name)) {
1127 insert = 0;
1128 /* prevent FPATH search below */
1129 flags &= ~FC_FUNC;
1130 goto Search;
1131 }
1132 tbi = (flags & FC_BI) ? ktsearch(&builtins, name, h) : NULL;
1133 /*
1134 * POSIX says special builtins first, then functions, then
1135 * regular builtins, then search path...
1136 */
1137 if ((flags & FC_SPECBI) && tbi && (tbi->flag & SPEC_BI))
1138 tp = tbi;
1139 if (!tp && (flags & FC_FUNC)) {
1140 tp = findfunc(name, h, false);
1141 if (tp && !(tp->flag & ISSET)) {
1142 if ((fpath = str_val(global(TFPATH))) == null) {
1143 tp->u.fpath = NULL;
1144 tp->u2.errnov = ENOENT;
1145 } else
1146 tp->u.fpath = search_path(name, fpath, R_OK,
1147 &tp->u2.errnov);
1148 }
1149 }
1150 if (!tp && (flags & FC_NORMBI) && tbi)
1151 tp = tbi;
1152 if (!tp && (flags & FC_PATH) && !(flags & FC_DEFPATH)) {
1153 tp = ktsearch(&taliases, name, h);
1154 if (tp && (tp->flag & ISSET) &&
1155 ksh_access(tp->val.s, X_OK) != 0) {
1156 if (tp->flag & ALLOC) {
1157 tp->flag &= ~ALLOC;
1158 afree(tp->val.s, APERM);
1159 }
1160 tp->flag &= ~ISSET;
1161 }
1162 }
1163
1164 Search:
1165 if ((!tp || (tp->type == CTALIAS && !(tp->flag&ISSET))) &&
1166 (flags & FC_PATH)) {
1167 if (!tp) {
1168 if (insert && !(flags & FC_DEFPATH)) {
1169 tp = ktenter(&taliases, name, h);
1170 tp->type = CTALIAS;
1171 } else {
1172 tp = &temp;
1173 tp->type = CEXEC;
1174 }
1175 /* make ~ISSET */
1176 tp->flag = DEFINED;
1177 }
1178 npath.ro = search_path(name,
1179 (flags & FC_DEFPATH) ? def_path : path,
1180 X_OK, &tp->u2.errnov);
1181 if (npath.ro) {
1182 strdupx(tp->val.s, npath.ro, APERM);
1183 if (npath.ro != name)
1184 afree(npath.rw, ATEMP);
1185 tp->flag |= ISSET|ALLOC;
1186 } else if ((flags & FC_FUNC) &&
1187 (fpath = str_val(global(TFPATH))) != null &&
1188 (npath.ro = search_path(name, fpath, R_OK,
1189 &tp->u2.errnov)) != NULL) {
1190 /*
1191 * An undocumented feature of AT&T ksh is that
1192 * it searches FPATH if a command is not found,
1193 * even if the command hasn't been set up as an
1194 * autoloaded function (ie, no typeset -uf).
1195 */
1196 tp = &temp;
1197 tp->type = CFUNC;
1198 /* make ~ISSET */
1199 tp->flag = DEFINED;
1200 tp->u.fpath = npath.ro;
1201 }
1202 }
1203 return (tp);
1204 }
1205
1206 /*
1207 * flush executable commands with relative paths
1208 * (just relative or all?)
1209 */
1210 void
flushcom(bool all)1211 flushcom(bool all)
1212 {
1213 struct tbl *tp;
1214 struct tstate ts;
1215
1216 for (ktwalk(&ts, &taliases); (tp = ktnext(&ts)) != NULL; )
1217 if ((tp->flag&ISSET) && (all || !mksh_abspath(tp->val.s))) {
1218 if (tp->flag&ALLOC) {
1219 tp->flag &= ~(ALLOC|ISSET);
1220 afree(tp->val.s, APERM);
1221 }
1222 tp->flag &= ~ISSET;
1223 }
1224 }
1225
1226 /* check if path is something we want to find */
1227 int
search_access(const char * fn,int mode)1228 search_access(const char *fn, int mode)
1229 {
1230 struct stat sb;
1231
1232 if (stat(fn, &sb) < 0)
1233 /* file does not exist */
1234 return (ENOENT);
1235 /* LINTED use of access */
1236 if (access(fn, mode) < 0) {
1237 /* file exists, but we can't access it */
1238 int eno;
1239
1240 eno = errno;
1241 return (eno ? eno : EACCES);
1242 }
1243 #ifdef __OS2__
1244 /* treat all files as executable on OS/2 */
1245 sb.st_mode &= S_IXUSR | S_IXGRP | S_IXOTH;
1246 #endif
1247 if (mode == X_OK && (!S_ISREG(sb.st_mode) ||
1248 !(sb.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))))
1249 /* access(2) may say root can execute everything */
1250 return (S_ISDIR(sb.st_mode) ? EISDIR : EACCES);
1251 return (0);
1252 }
1253
1254 /*
1255 * search for command with PATH
1256 */
1257 const char *
search_path(const char * name,const char * lpath,int mode,int * errnop)1258 search_path(const char *name, const char *lpath,
1259 /* R_OK or X_OK */
1260 int mode,
1261 /* set if candidate found, but not suitable */
1262 int *errnop)
1263 {
1264 const char *sp, *p;
1265 char *xp;
1266 XString xs;
1267 size_t namelen;
1268 int ec = 0, ev;
1269
1270 if (mksh_vdirsep(name)) {
1271 if ((ec = search_access(name, mode)) == 0) {
1272 search_path_ok:
1273 if (errnop)
1274 *errnop = 0;
1275 return (name);
1276 }
1277 goto search_path_err;
1278 }
1279
1280 namelen = strlen(name) + 1;
1281 Xinit(xs, xp, 128, ATEMP);
1282
1283 sp = lpath;
1284 while (sp != NULL) {
1285 xp = Xstring(xs, xp);
1286 if (!(p = cstrchr(sp, MKSH_PATHSEPC)))
1287 p = sp + strlen(sp);
1288 if (p != sp) {
1289 XcheckN(xs, xp, p - sp);
1290 memcpy(xp, sp, p - sp);
1291 xp += p - sp;
1292 *xp++ = '/';
1293 }
1294 sp = p;
1295 XcheckN(xs, xp, namelen);
1296 memcpy(xp, name, namelen);
1297 if ((ev = search_access(Xstring(xs, xp), mode)) == 0) {
1298 name = Xclose(xs, xp + namelen);
1299 goto search_path_ok;
1300 }
1301 /* accumulate non-ENOENT errors only */
1302 if (ev != ENOENT && ec == 0)
1303 ec = ev;
1304 if (*sp++ == '\0')
1305 sp = NULL;
1306 }
1307 Xfree(xs, xp);
1308 search_path_err:
1309 if (errnop)
1310 *errnop = ec ? ec : ENOENT;
1311 return (NULL);
1312 }
1313
1314 static int
call_builtin(struct tbl * tp,const char ** wp,const char * where,bool resetspec)1315 call_builtin(struct tbl *tp, const char **wp, const char *where, bool resetspec)
1316 {
1317 int rv;
1318
1319 if (!tp)
1320 internal_errorf(Tf_sD_s, where, wp[0]);
1321 builtin_argv0 = wp[0];
1322 builtin_spec = tobool(!resetspec &&
1323 /*XXX odd use of KEEPASN */
1324 ((tp->flag & SPEC_BI) || (Flag(FPOSIX) && (tp->flag & KEEPASN))));
1325 shf_reopen(1, SHF_WR, shl_stdout);
1326 shl_stdout_ok = true;
1327 ksh_getopt_reset(&builtin_opt, GF_ERROR);
1328 rv = (*tp->val.f)(wp);
1329 shf_flush(shl_stdout);
1330 shl_stdout_ok = false;
1331 builtin_argv0 = NULL;
1332 builtin_spec = false;
1333 return (rv);
1334 }
1335
1336 /*
1337 * set up redirection, saving old fds in e->savefd
1338 */
1339 static int
iosetup(struct ioword * iop,struct tbl * tp)1340 iosetup(struct ioword *iop, struct tbl *tp)
1341 {
1342 int u = -1;
1343 char *cp = iop->ioname;
1344 int iotype = iop->ioflag & IOTYPE;
1345 bool do_open = true, do_close = false, do_fstat = false;
1346 int flags = 0;
1347 struct ioword iotmp;
1348 struct stat statb;
1349
1350 if (iotype != IOHERE)
1351 cp = evalonestr(cp, DOTILDE|(Flag(FTALKING_I) ? DOGLOB : 0));
1352
1353 /* Used for tracing and error messages to print expanded cp */
1354 iotmp = *iop;
1355 iotmp.ioname = (iotype == IOHERE) ? NULL : cp;
1356 iotmp.ioflag |= IONAMEXP;
1357
1358 if (Flag(FXTRACE)) {
1359 change_xtrace(2, false);
1360 fptreef(shl_xtrace, 0, Tft_R, &iotmp);
1361 change_xtrace(1, false);
1362 }
1363
1364 switch (iotype) {
1365 case IOREAD:
1366 flags = O_RDONLY;
1367 break;
1368
1369 case IOCAT:
1370 flags = O_WRONLY | O_APPEND | O_CREAT;
1371 break;
1372
1373 case IOWRITE:
1374 if (Flag(FNOCLOBBER) && !(iop->ioflag & IOCLOB)) {
1375 /* >file under set -C */
1376 if (stat(cp, &statb)) {
1377 /* nonexistent file */
1378 flags = O_WRONLY | O_CREAT | O_EXCL;
1379 } else if (S_ISREG(statb.st_mode)) {
1380 /* regular file, refuse clobbering */
1381 goto clobber_refused;
1382 } else {
1383 /*
1384 * allow redirections to things
1385 * like /dev/null without error
1386 */
1387 flags = O_WRONLY;
1388 /* but check again after opening */
1389 do_fstat = true;
1390 }
1391 } else {
1392 /* >|file or set +C */
1393 flags = O_WRONLY | O_CREAT | O_TRUNC;
1394 }
1395 break;
1396
1397 case IORDWR:
1398 flags = O_RDWR | O_CREAT;
1399 break;
1400
1401 case IOHERE:
1402 do_open = false;
1403 /* herein() returns -2 if error has been printed */
1404 u = herein(iop, NULL);
1405 /* cp may have wrong name */
1406 break;
1407
1408 case IODUP: {
1409 const char *emsg;
1410
1411 do_open = false;
1412 if (ksh_isdash(cp)) {
1413 /* prevent error return below */
1414 u = 1009;
1415 do_close = true;
1416 } else if ((u = check_fd(cp,
1417 X_OK | ((iop->ioflag & IORDUP) ? R_OK : W_OK),
1418 &emsg)) < 0) {
1419 char *sp;
1420
1421 warningf(true, Tf_sD_s,
1422 (sp = snptreef(NULL, 32, Tft_R, &iotmp)), emsg);
1423 afree(sp, ATEMP);
1424 return (-1);
1425 }
1426 if (u == (int)iop->unit)
1427 /* "dup from" == "dup to" */
1428 return (0);
1429 break;
1430 }
1431 }
1432
1433 if (do_open) {
1434 if (Flag(FRESTRICTED) && (flags & O_CREAT)) {
1435 warningf(true, Tf_sD_s, cp, "restricted");
1436 return (-1);
1437 }
1438 u = binopen3(cp, flags, 0666);
1439 if (do_fstat && u >= 0) {
1440 /* prevent race conditions */
1441 if (fstat(u, &statb) || S_ISREG(statb.st_mode)) {
1442 close(u);
1443 clobber_refused:
1444 u = -1;
1445 errno = EEXIST;
1446 }
1447 }
1448 }
1449 if (u < 0) {
1450 /* herein() may already have printed message */
1451 if (u == -1) {
1452 u = errno;
1453 warningf(true, Tf_cant,
1454 iotype == IODUP ? "dup" :
1455 (iotype == IOREAD || iotype == IOHERE) ?
1456 Topen : Tcreate, cp, cstrerror(u));
1457 }
1458 return (-1);
1459 }
1460 /* Do not save if it has already been redirected (i.e. "cat >x >y"). */
1461 if (e->savefd[iop->unit] == 0) {
1462 /* If these are the same, it means unit was previously closed */
1463 if (u == (int)iop->unit)
1464 e->savefd[iop->unit] = -1;
1465 else
1466 /*
1467 * c_exec() assumes e->savefd[fd] set for any
1468 * redirections. Ask savefd() not to close iop->unit;
1469 * this allows error messages to be seen if iop->unit
1470 * is 2; also means we can't lose the fd (eg, both
1471 * dup2 below and dup2 in restfd() failing).
1472 */
1473 e->savefd[iop->unit] = savefd(iop->unit);
1474 }
1475
1476 if (do_close)
1477 close(iop->unit);
1478 else if (u != (int)iop->unit) {
1479 if (ksh_dup2(u, iop->unit, true) < 0) {
1480 int eno;
1481 char *sp;
1482
1483 eno = errno;
1484 warningf(true, Tf_s_sD_s, Tredirection_dup,
1485 (sp = snptreef(NULL, 32, Tft_R, &iotmp)),
1486 cstrerror(eno));
1487 afree(sp, ATEMP);
1488 if (iotype != IODUP)
1489 close(u);
1490 return (-1);
1491 }
1492 if (iotype != IODUP)
1493 close(u);
1494 /*
1495 * Touching any co-process fd in an empty exec
1496 * causes the shell to close its copies
1497 */
1498 else if (tp && tp->type == CSHELL && tp->val.f == c_exec) {
1499 if (iop->ioflag & IORDUP)
1500 /* possible exec <&p */
1501 coproc_read_close(u);
1502 else
1503 /* possible exec >&p */
1504 coproc_write_close(u);
1505 }
1506 }
1507 if (u == 2)
1508 /* Clear any write errors */
1509 shf_reopen(2, SHF_WR, shl_out);
1510 return (0);
1511 }
1512
1513 /*
1514 * Process here documents by providing the content, either as
1515 * result (globally allocated) string or in a temp file; if
1516 * unquoted, the string is expanded first.
1517 */
1518 static int
hereinval(struct ioword * iop,int sub,char ** resbuf,struct shf * shf)1519 hereinval(struct ioword *iop, int sub, char **resbuf, struct shf *shf)
1520 {
1521 const char * volatile ccp = iop->heredoc;
1522 struct source *s, *osource;
1523
1524 osource = source;
1525 newenv(E_ERRH);
1526 if (kshsetjmp(e->jbuf)) {
1527 source = osource;
1528 quitenv(shf);
1529 /* special to iosetup(): don't print error */
1530 return (-2);
1531 }
1532 if (iop->ioflag & IOHERESTR) {
1533 ccp = evalstr(iop->delim, DOHERESTR | DOSCALAR | DOHEREDOC);
1534 } else if (sub) {
1535 /* do substitutions on the content of heredoc */
1536 s = pushs(SSTRING, ATEMP);
1537 s->start = s->str = ccp;
1538 source = s;
1539 if (yylex(sub) != LWORD)
1540 internal_errorf("herein: yylex");
1541 source = osource;
1542 ccp = evalstr(yylval.cp, DOSCALAR | DOHEREDOC);
1543 }
1544
1545 if (resbuf == NULL)
1546 shf_puts(ccp, shf);
1547 else
1548 strdupx(*resbuf, ccp, APERM);
1549
1550 quitenv(NULL);
1551 return (0);
1552 }
1553
1554 int
herein(struct ioword * iop,char ** resbuf)1555 herein(struct ioword *iop, char **resbuf)
1556 {
1557 int fd = -1;
1558 struct shf *shf;
1559 struct temp *h;
1560 int i;
1561
1562 /* lexer substitution flags */
1563 i = (iop->ioflag & IOEVAL) ? (ONEWORD | HEREDOC) : 0;
1564
1565 /* skip all the fd setup if we just want the value */
1566 if (resbuf != NULL)
1567 return (hereinval(iop, i, resbuf, NULL));
1568
1569 /*
1570 * Create temp file to hold content (done before newenv
1571 * so temp doesn't get removed too soon).
1572 */
1573 h = maketemp(ATEMP, TT_HEREDOC_EXP, &e->temps);
1574 if (!(shf = h->shf) || (fd = binopen3(h->tffn, O_RDONLY, 0)) < 0) {
1575 i = errno;
1576 warningf(true, Tf_temp,
1577 !shf ? Tcreate : Topen, h->tffn, cstrerror(i));
1578 if (shf)
1579 shf_close(shf);
1580 /* special to iosetup(): don't print error */
1581 return (-2);
1582 }
1583
1584 if (hereinval(iop, i, NULL, shf) == -2) {
1585 close(fd);
1586 /* special to iosetup(): don't print error */
1587 return (-2);
1588 }
1589
1590 if (shf_close(shf) == -1) {
1591 i = errno;
1592 close(fd);
1593 warningf(true, Tf_temp,
1594 Twrite, h->tffn, cstrerror(i));
1595 /* special to iosetup(): don't print error */
1596 return (-2);
1597 }
1598
1599 return (fd);
1600 }
1601
1602 /*
1603 * ksh special - the select command processing section
1604 * print the args in column form - assuming that we can
1605 */
1606 static const char *
do_selectargs(const char ** ap,bool print_menu)1607 do_selectargs(const char **ap, bool print_menu)
1608 {
1609 static const char *read_args[] = {
1610 Tread, "-r", "REPLY", NULL
1611 };
1612 char *s;
1613 int i, argct;
1614
1615 for (argct = 0; ap[argct]; argct++)
1616 ;
1617 while (/* CONSTCOND */ 1) {
1618 /*-
1619 * Menu is printed if
1620 * - this is the first time around the select loop
1621 * - the user enters a blank line
1622 * - the REPLY parameter is empty
1623 */
1624 if (print_menu || !*str_val(global("REPLY")))
1625 pr_menu(ap);
1626 shellf(Tf_s, str_val(global("PS3")));
1627 if (call_builtin(findcom(Tread, FC_BI), read_args, Tselect,
1628 false))
1629 return (NULL);
1630 if (*(s = str_val(global("REPLY"))))
1631 return ((getn(s, &i) && i >= 1 && i <= argct) ?
1632 ap[i - 1] : null);
1633 print_menu = true;
1634 }
1635 }
1636
1637 struct select_menu_info {
1638 const char * const *args;
1639 int num_width;
1640 };
1641
1642 /* format a single select menu item */
1643 static void
select_fmt_entry(char * buf,size_t buflen,unsigned int i,const void * arg)1644 select_fmt_entry(char *buf, size_t buflen, unsigned int i, const void *arg)
1645 {
1646 const struct select_menu_info *smi =
1647 (const struct select_menu_info *)arg;
1648
1649 shf_snprintf(buf, buflen, "%*u) %s",
1650 smi->num_width, i + 1, smi->args[i]);
1651 }
1652
1653 /*
1654 * print a select style menu
1655 */
1656 void
pr_menu(const char * const * ap)1657 pr_menu(const char * const *ap)
1658 {
1659 struct select_menu_info smi;
1660 const char * const *pp;
1661 size_t acols = 0, aocts = 0, i;
1662 unsigned int n;
1663 struct columnise_opts co;
1664
1665 /*
1666 * width/column calculations were done once and saved, but this
1667 * means select can't be used recursively so we re-calculate
1668 * each time (could save in a structure that is returned, but
1669 * it's probably not worth the bother)
1670 */
1671
1672 /*
1673 * get dimensions of the list
1674 */
1675 for (n = 0, pp = ap; *pp; n++, pp++) {
1676 i = strlen(*pp);
1677 if (i > aocts)
1678 aocts = i;
1679 i = utf_mbswidth(*pp);
1680 if (i > acols)
1681 acols = i;
1682 }
1683
1684 /*
1685 * we will print an index of the form "%d) " in front of
1686 * each entry, so get the maximum width of this
1687 */
1688 for (i = n, smi.num_width = 1; i >= 10; i /= 10)
1689 smi.num_width++;
1690
1691 smi.args = ap;
1692 co.shf = shl_out;
1693 co.linesep = '\n';
1694 co.prefcol = co.do_last = true;
1695 print_columns(&co, n, select_fmt_entry, (void *)&smi,
1696 smi.num_width + 2 + aocts, smi.num_width + 2 + acols);
1697 }
1698
1699 static void
plain_fmt_entry(char * buf,size_t buflen,unsigned int i,const void * arg)1700 plain_fmt_entry(char *buf, size_t buflen, unsigned int i, const void *arg)
1701 {
1702 strlcpy(buf, ((const char * const *)arg)[i], buflen);
1703 }
1704
1705 void
pr_list(struct columnise_opts * cop,char * const * ap)1706 pr_list(struct columnise_opts *cop, char * const *ap)
1707 {
1708 size_t acols = 0, aocts = 0, i;
1709 unsigned int n;
1710 char * const *pp;
1711
1712 for (n = 0, pp = ap; *pp; n++, pp++) {
1713 i = strlen(*pp);
1714 if (i > aocts)
1715 aocts = i;
1716 i = utf_mbswidth(*pp);
1717 if (i > acols)
1718 acols = i;
1719 }
1720
1721 print_columns(cop, n, plain_fmt_entry, (const void *)ap,
1722 aocts, acols);
1723 }
1724
1725 /*
1726 * [[ ... ]] evaluation routines
1727 */
1728
1729 /*
1730 * Test if the current token is a whatever. Accepts the current token if
1731 * it is. Returns 0 if it is not, non-zero if it is (in the case of
1732 * TM_UNOP and TM_BINOP, the returned value is a Test_op).
1733 */
1734 static Test_op
dbteste_isa(Test_env * te,Test_meta meta)1735 dbteste_isa(Test_env *te, Test_meta meta)
1736 {
1737 Test_op ret = TO_NONOP;
1738 bool uqword;
1739 const char *p;
1740
1741 if (!*te->pos.wp)
1742 return (meta == TM_END ? TO_NONNULL : TO_NONOP);
1743
1744 /* unquoted word? */
1745 for (p = *te->pos.wp; *p == CHAR; p += 2)
1746 ;
1747 uqword = *p == EOS;
1748
1749 if (meta == TM_UNOP || meta == TM_BINOP) {
1750 if (uqword) {
1751 /* longer than the longest operator */
1752 char buf[8];
1753 char *q = buf;
1754
1755 p = *te->pos.wp;
1756 while (*p++ == CHAR &&
1757 (size_t)(q - buf) < sizeof(buf) - 1)
1758 *q++ = *p++;
1759 *q = '\0';
1760 ret = test_isop(meta, buf);
1761 }
1762 } else if (meta == TM_END)
1763 ret = TO_NONOP;
1764 else
1765 ret = (uqword && !strcmp(*te->pos.wp,
1766 dbtest_tokens[(int)meta])) ? TO_NONNULL : TO_NONOP;
1767
1768 /* Accept the token? */
1769 if (ret != TO_NONOP)
1770 te->pos.wp++;
1771
1772 return (ret);
1773 }
1774
1775 static const char *
dbteste_getopnd(Test_env * te,Test_op op,bool do_eval)1776 dbteste_getopnd(Test_env *te, Test_op op, bool do_eval)
1777 {
1778 const char *s = *te->pos.wp;
1779 int flags = DOTILDE | DOSCALAR;
1780
1781 if (!s)
1782 return (NULL);
1783
1784 te->pos.wp++;
1785
1786 if (!do_eval)
1787 return (null);
1788
1789 if (op == TO_STEQL || op == TO_STNEQ)
1790 flags |= DOPAT;
1791
1792 return (evalstr(s, flags));
1793 }
1794
1795 static void
dbteste_error(Test_env * te,int offset,const char * msg)1796 dbteste_error(Test_env *te, int offset, const char *msg)
1797 {
1798 te->flags |= TEF_ERROR;
1799 internal_warningf("dbteste_error: %s (offset %d)", msg, offset);
1800 }
1801