src/exec.c

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