bin/ksh/exec.c

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