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