src/exec.c

   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@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 }