src/main.c

   1 /*      $OpenBSD: main.c,v 1.47 2011/09/07 11:33:25 otto Exp $  */
   2 /*      $OpenBSD: tty.c,v 1.9 2006/03/14 22:08:01 deraadt Exp $ */
   3 /*      $OpenBSD: io.c,v 1.22 2006/03/17 16:30:13 millert Exp $ */
   4 /*      $OpenBSD: table.c,v 1.13 2009/01/17 22:06:44 millert Exp $      */
   5
   6 /*-
   7  * Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   8  *      Thorsten Glaser <tg@mirbsd.org>
   9  *
  10  * Provided that these terms and disclaimer and all copyright notices
  11  * are retained or reproduced in an accompanying document, permission
  12  * is granted to deal in this work without restriction, including un-
  13  * limited rights to use, publicly perform, distribute, sell, modify,
  14  * merge, give away, or sublicence.
  15  *
  16  * This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to
  17  * the utmost extent permitted by applicable law, neither express nor
  18  * implied; without malicious intent or gross negligence. In no event
  19  * may a licensor, author or contributor be held liable for indirect,
  20  * direct, other damage, loss, or other issues arising in any way out
  21  * of dealing in the work, even if advised of the possibility of such
  22  * damage or existence of a defect, except proven that it results out
  23  * of said person's immediate fault when using the work as intended.
  24  */
  25
  26 #define EXTERN
  27 #include "sh.h"
  28
  29 #if HAVE_LANGINFO_CODESET
  30 #include <langinfo.h>
  31 #endif
  32 #if HAVE_SETLOCALE_CTYPE
  33 #include <locale.h>
  34 #endif
  35
  36 __RCSID("$MirOS: src/bin/mksh/main.c,v 1.200 2011/10/07 19:51:28 tg Exp $");
  37
  38 extern char **environ;
  39
  40 #ifndef MKSHRC_PATH
  41 #define MKSHRC_PATH     "~/.mkshrc"
  42 #endif
  43
  44 #ifndef MKSH_DEFAULT_TMPDIR
  45 #define MKSH_DEFAULT_TMPDIR     "/tmp"
  46 #endif
  47
  48 void chvt_reinit(void);
  49 static void reclaim(void);
  50 static void remove_temps(struct temp *);
  51 static mksh_uari_t rndsetup(void);
  52 #ifdef SIGWINCH
  53 static void x_sigwinch(int);
  54 #endif
  55
  56 static const char initifs[] = "IFS= \t\n";
  57
  58 static const char initsubs[] =
  59     "${PS2=> } ${PS3=#? } ${PS4=+ } ${SECONDS=0} ${TMOUT=0}";
  60
  61 static const char *initcoms[] = {
  62         Ttypeset, "-r", initvsn, NULL,
  63         Ttypeset, "-x", "HOME", "PATH", "RANDOM", "SHELL", NULL,
  64         Ttypeset, "-i10", "SECONDS", "TMOUT", NULL,
  65         Talias,
  66         "integer=typeset -i",
  67         Tlocal_typeset,
  68         /* not "alias -t --": hash -r needs to work */
  69         "hash=alias -t",
  70         "type=whence -v",
  71 #if !defined(ANDROID) && !defined(MKSH_UNEMPLOYED)
  72         /* not in Android for political reasons */
  73         /* not in ARGE mksh due to no job control */
  74         "stop=kill -STOP",
  75         "suspend=kill -STOP $$",
  76 #endif
  77         "autoload=typeset -fu",
  78         "functions=typeset -f",
  79         "history=fc -l",
  80         "nameref=typeset -n",
  81         "nohup=nohup ",
  82         Tr_fc_e_dash,
  83         "source=PATH=$PATH:. command .",
  84         "login=exec login",
  85         NULL,
  86          /* this is what AT&T ksh seems to track, with the addition of emacs */
  87         Talias, "-tU",
  88         "cat", "cc", "chmod", "cp", "date", "ed", "emacs", "grep", "ls",
  89         "make", "mv", "pr", "rm", "sed", "sh", "vi", "who", NULL,
  90         NULL
  91 };
  92
  93 static const char *restr_com[] = {
  94         Ttypeset, "-r", "PATH", "ENV", "SHELL", NULL
  95 };
  96
  97 static int initio_done;
  98
  99 /* top-level parsing and execution environment */
 100 static struct env env;
 101 struct env *e = &env;
 102
 103 static mksh_uari_t
 104 rndsetup(void)
 105 {
 106         register uint32_t h;
 107         struct {
 108                 ALLOC_ITEM alloc_INT;
 109                 void *dataptr, *stkptr, *mallocptr;
 110                 sigjmp_buf jbuf;
 111                 struct timeval tv;
 112                 struct timezone tz;
 113         } *bufptr;
 114         char *cp;
 115
 116         cp = alloc(sizeof(*bufptr) - ALLOC_SIZE, APERM);
 117 #ifdef DEBUG
 118         /* clear the allocated space, for valgrind */
 119         memset(cp, 0, sizeof(*bufptr) - ALLOC_SIZE);
 120 #endif
 121         /* undo what alloc() did to the malloc result address */
 122         bufptr = (void *)(cp - ALLOC_SIZE);
 123         /* PIE or something similar provides us with deltas here */
 124         bufptr->dataptr = &rndsetupstate;
 125         /* ASLR in at least Windows, Linux, some BSDs */
 126         bufptr->stkptr = &bufptr;
 127         /* randomised malloc in BSD (and possibly others) */
 128         bufptr->mallocptr = bufptr;
 129         /* glibc pointer guard */
 130         sigsetjmp(bufptr->jbuf, 1);
 131         /* introduce variation */
 132         gettimeofday(&bufptr->tv, &bufptr->tz);
 133
 134         NZATInit(h);
 135         /* variation through pid, ppid, and the works */
 136         NZATUpdateMem(h, &rndsetupstate, sizeof(rndsetupstate));
 137         /* some variation, some possibly entropy, depending on OE */
 138         NZATUpdateMem(h, bufptr, sizeof(*bufptr));
 139         NZAATFinish(h);
 140
 141         afree(cp, APERM);
 142         return ((mksh_uari_t)h);
 143 }
 144
 145 void
 146 chvt_reinit(void)
 147 {
 148         kshpid = procpid = getpid();
 149         ksheuid = geteuid();
 150         kshpgrp = getpgrp();
 151         kshppid = getppid();
 152 }
 153
 154 static const char *empty_argv[] = {
 155         "mksh", NULL
 156 };
 157
 158 int
 159 main(int argc, const char *argv[])
 160 {
 161         int argi, i;
 162         Source *s = NULL;
 163         struct block *l;
 164         unsigned char restricted, errexit, utf_flag;
 165         char *cp;
 166         const char *ccp, **wp;
 167         struct tbl *vp;
 168         struct stat s_stdin;
 169 #if !defined(_PATH_DEFPATH) && defined(_CS_PATH)
 170         ssize_t k;
 171 #endif
 172
 173         /* do things like getpgrp() et al. */
 174         chvt_reinit();
 175
 176         /* make sure argv[] is sane */
 177         if (!*argv) {
 178                 argv = empty_argv;
 179                 argc = 1;
 180         }
 181         kshname = argv[0];
 182
 183         /* initialise permanent Area */
 184         ainit(&aperm);
 185
 186         /* set up base environment */
 187         env.type = E_NONE;
 188         ainit(&env.area);
 189         /* set up global l->vars and l->funs */
 190         newblock();
 191
 192         /* Do this first so output routines (eg, errorf, shellf) can work */
 193         initio();
 194
 195         /* determine the basename (without '-' or path) of the executable */
 196         ccp = kshname;
 197         goto begin_parse_kshname;
 198         while ((i = ccp[argi++])) {
 199                 if (i == '/') {
 200                         ccp += argi;
 201  begin_parse_kshname:
 202                         argi = 0;
 203                         if (*ccp == '-')
 204                                 ++ccp;
 205                 }
 206         }
 207         if (!*ccp)
 208                 ccp = empty_argv[0];
 209
 210         /* define built-in commands and see if we were called as one */
 211         ktinit(APERM, &builtins,
 212             /* currently 50 builtins -> 80% of 64 (2^6) */
 213             6);
 214         for (i = 0; mkshbuiltins[i].name != NULL; i++)
 215                 if (!strcmp(ccp, builtin(mkshbuiltins[i].name,
 216                     mkshbuiltins[i].func)))
 217                         Flag(FAS_BUILTIN) = 1;
 218
 219         if (!Flag(FAS_BUILTIN)) {
 220                 /* check for -T option early */
 221                 argi = parse_args(argv, OF_FIRSTTIME, NULL);
 222                 if (argi < 0)
 223                         return (1);
 224
 225 #ifdef MKSH_BINSHREDUCED
 226                 /* set FSH if we're called as -sh or /bin/sh or so */
 227                 if (!strcmp(ccp, "sh"))
 228                         change_flag(FSH, OF_FIRSTTIME, 1);
 229 #endif
 230         }
 231
 232         initvar();
 233
 234         initctypes();
 235
 236         inittraps();
 237
 238         coproc_init();
 239
 240         /* set up variable and command dictionaries */
 241         ktinit(APERM, &taliases, 0);
 242         ktinit(APERM, &aliases, 0);
 243 #ifndef MKSH_NOPWNAM
 244         ktinit(APERM, &homedirs, 0);
 245 #endif
 246
 247         /* define shell keywords */
 248         initkeywords();
 249
 250         init_histvec();
 251
 252 #ifdef _PATH_DEFPATH
 253         def_path = _PATH_DEFPATH;
 254 #else
 255 #ifdef _CS_PATH
 256         if ((k = confstr(_CS_PATH, NULL, 0)) > 0 &&
 257             confstr(_CS_PATH, cp = alloc(k + 1, APERM), k + 1) == k + 1)
 258                 def_path = cp;
 259         else
 260 #endif
 261                 /*
 262                  * this is uniform across all OSes unless it
 263                  * breaks somewhere; don't try to optimise,
 264                  * e.g. add stuff for Interix or remove /usr
 265                  * for HURD, because e.g. Debian GNU/HURD is
 266                  * "keeping a regular /usr"; this is supposed
 267                  * to be a sane 'basic' default PATH
 268                  */
 269                 def_path = "/bin:/usr/bin:/sbin:/usr/sbin";
 270 #endif
 271
 272         /*
 273          * Set PATH to def_path (will set the path global variable).
 274          * (import of environment below will probably change this setting).
 275          */
 276         vp = global("PATH");
 277         /* setstr can't fail here */
 278         setstr(vp, def_path, KSH_RETURN_ERROR);
 279
 280         /*
 281          * Turn on nohup by default for now - will change to off
 282          * by default once people are aware of its existence
 283          * (AT&T ksh does not have a nohup option - it always sends
 284          * the hup).
 285          */
 286         Flag(FNOHUP) = 1;
 287
 288         /*
 289          * Turn on brace expansion by default. AT&T kshs that have
 290          * alternation always have it on.
 291          */
 292         Flag(FBRACEEXPAND) = 1;
 293
 294         /*
 295          * Set edit mode to emacs by default, may be overridden
 296          * by the environment or the user. Also, we want tab completion
 297          * on in vi by default.
 298          */
 299         change_flag(FEMACS, OF_SPECIAL, 1);
 300 #if !MKSH_S_NOVI
 301         Flag(FVITABCOMPLETE) = 1;
 302 #endif
 303
 304         /* import environment */
 305         if (environ != NULL)
 306                 for (wp = (const char **)environ; *wp != NULL; wp++)
 307                         typeset(*wp, IMPORT | EXPORT, 0, 0, 0);
 308
 309         /* for security */
 310         typeset(initifs, 0, 0, 0, 0);
 311
 312         /* assign default shell variable values */
 313         substitute(initsubs, 0);
 314
 315         /* Figure out the current working directory and set $PWD */
 316         vp = global("PWD");
 317         cp = str_val(vp);
 318         /* Try to use existing $PWD if it is valid */
 319         set_current_wd((cp[0] == '/' && test_eval(NULL, TO_FILEQ, cp, ".",
 320             true)) ? cp : NULL);
 321         if (current_wd[0])
 322                 simplify_path(current_wd);
 323         /* Only set pwd if we know where we are or if it had a bogus value */
 324         if (current_wd[0] || *cp)
 325                 /* setstr can't fail here */
 326                 setstr(vp, current_wd, KSH_RETURN_ERROR);
 327
 328         for (wp = initcoms; *wp != NULL; wp++) {
 329                 shcomexec(wp);
 330                 while (*wp != NULL)
 331                         wp++;
 332         }
 333         setint_n(global("COLUMNS"), 0);
 334         setint_n(global("LINES"), 0);
 335         setint_n(global("OPTIND"), 1);
 336
 337         kshuid = getuid();
 338         kshgid = getgid();
 339         kshegid = getegid();
 340
 341         safe_prompt = ksheuid ? "$ " : "# ";
 342         vp = global("PS1");
 343         /* Set PS1 if unset or we are root and prompt doesn't contain a # */
 344         if (!(vp->flag & ISSET) ||
 345             (!ksheuid && !strchr(str_val(vp), '#')))
 346                 /* setstr can't fail here */
 347                 setstr(vp, safe_prompt, KSH_RETURN_ERROR);
 348         setint_n((vp = global("PGRP")), (mksh_uari_t)kshpgrp);
 349         vp->flag |= INT_U;
 350         setint_n((vp = global("PPID")), (mksh_uari_t)kshppid);
 351         vp->flag |= INT_U;
 352         setint_n((vp = global("USER_ID")), (mksh_uari_t)ksheuid);
 353         vp->flag |= INT_U;
 354         setint_n((vp = global("KSHUID")), (mksh_uari_t)kshuid);
 355         vp->flag |= INT_U;
 356         setint_n((vp = global("KSHEGID")), (mksh_uari_t)kshegid);
 357         vp->flag |= INT_U;
 358         setint_n((vp = global("KSHGID")), (mksh_uari_t)kshgid);
 359         vp->flag |= INT_U;
 360         setint_n((vp = global("RANDOM")), rndsetup());
 361         vp->flag |= INT_U;
 362         setint_n((vp_pipest = global("PIPESTATUS")), 0);
 363
 364         /* Set this before parsing arguments */
 365         Flag(FPRIVILEGED) = kshuid != ksheuid || kshgid != kshegid;
 366
 367         /* this to note if monitor is set on command line (see below) */
 368 #ifndef MKSH_UNEMPLOYED
 369         Flag(FMONITOR) = 127;
 370 #endif
 371         /* this to note if utf-8 mode is set on command line (see below) */
 372         UTFMODE = 2;
 373
 374         if (!Flag(FAS_BUILTIN)) {
 375                 argi = parse_args(argv, OF_CMDLINE, NULL);
 376                 if (argi < 0)
 377                         return (1);
 378         }
 379
 380 #ifdef DEBUG
 381         /* test wraparound of arithmetic types */
 382         {
 383                 volatile long xl;
 384                 volatile unsigned long xul;
 385                 volatile int xi;
 386                 volatile unsigned int xui;
 387                 volatile mksh_ari_t xa;
 388                 volatile mksh_uari_t xua, xua2;
 389                 volatile uint8_t xc;
 390
 391                 xa = 2147483647;
 392                 xua = 2147483647;
 393                 ++xa;
 394                 ++xua;
 395                 xua2 = xa;
 396                 xl = xa;
 397                 xul = xua;
 398                 xa = 0;
 399                 xua = 0;
 400                 --xa;
 401                 --xua;
 402                 xi = xa;
 403                 xui = xua;
 404                 xa = -1;
 405                 xua = xa;
 406                 ++xa;
 407                 ++xua;
 408                 xc = 0;
 409                 --xc;
 410                 if ((xua2 != 2147483648UL) ||
 411                     (xl != -2147483648L) || (xul != 2147483648UL) ||
 412                     (xi != -1) || (xui != 4294967295U) ||
 413                     (xa != 0) || (xua != 0) || (xc != 255))
 414                         errorf("integer wraparound test failed");
 415         }
 416 #endif
 417
 418         /* process this later only, default to off (hysterical raisins) */
 419         utf_flag = UTFMODE;
 420         UTFMODE = 0;
 421
 422         if (Flag(FAS_BUILTIN)) {
 423                 /* auto-detect from environment variables, always */
 424                 utf_flag = 3;
 425         } else if (Flag(FCOMMAND)) {
 426                 s = pushs(SSTRING, ATEMP);
 427                 if (!(s->start = s->str = argv[argi++]))
 428                         errorf("%s %s", "-c", "requires an argument");
 429 #ifdef MKSH_MIDNIGHTBSD01ASH_COMPAT
 430                 /* compatibility to MidnightBSD 0.1 /bin/sh (kludge) */
 431                 if (Flag(FSH) && argv[argi] && !strcmp(argv[argi], "--"))
 432                         ++argi;
 433 #endif
 434                 if (argv[argi])
 435                         kshname = argv[argi++];
 436         } else if (argi < argc && !Flag(FSTDIN)) {
 437                 s = pushs(SFILE, ATEMP);
 438                 s->file = argv[argi++];
 439                 s->u.shf = shf_open(s->file, O_RDONLY, 0,
 440                     SHF_MAPHI | SHF_CLEXEC);
 441                 if (s->u.shf == NULL) {
 442                         shl_stdout_ok = false;
 443                         warningf(true, "%s: %s", s->file, strerror(errno));
 444                         /* mandated by SUSv4 */
 445                         exstat = 127;
 446                         unwind(LERROR);
 447                 }
 448                 kshname = s->file;
 449         } else {
 450                 Flag(FSTDIN) = 1;
 451                 s = pushs(SSTDIN, ATEMP);
 452                 s->file = "<stdin>";
 453                 s->u.shf = shf_fdopen(0, SHF_RD | can_seek(0),
 454                     NULL);
 455                 if (isatty(0) && isatty(2)) {
 456                         Flag(FTALKING) = Flag(FTALKING_I) = 1;
 457                         /* The following only if isatty(0) */
 458                         s->flags |= SF_TTY;
 459                         s->u.shf->flags |= SHF_INTERRUPT;
 460                         s->file = NULL;
 461                 }
 462         }
 463
 464         /* this bizarreness is mandated by POSIX */
 465         if (fstat(0, &s_stdin) >= 0 && S_ISCHR(s_stdin.st_mode) &&
 466             Flag(FTALKING))
 467                 reset_nonblock(0);
 468
 469         /* initialise job control */
 470         j_init();
 471         /* Do this after j_init(), as tty_fd is not initialised until then */
 472         if (Flag(FTALKING)) {
 473                 if (utf_flag == 2) {
 474 #ifndef MKSH_ASSUME_UTF8
 475                         /* auto-detect from locale or environment */
 476                         utf_flag = 4;
 477 #elif MKSH_ASSUME_UTF8
 478                         utf_flag = 1;
 479 #else
 480                         /* always disable UTF-8 (for interactive) */
 481                         utf_flag = 0;
 482 #endif
 483                 }
 484                 x_init();
 485         }
 486
 487 #ifdef SIGWINCH
 488         sigtraps[SIGWINCH].flags |= TF_SHELL_USES;
 489         setsig(&sigtraps[SIGWINCH], x_sigwinch,
 490             SS_RESTORE_ORIG|SS_FORCE|SS_SHTRAP);
 491 #endif
 492
 493         l = e->loc;
 494         if (Flag(FAS_BUILTIN)) {
 495                 l->argc = argc;
 496                 l->argv = argv;
 497                 l->argv[0] = ccp;
 498         } else {
 499                 l->argc = argc - argi;
 500                 l->argv = &argv[argi - 1];
 501                 l->argv[0] = kshname;
 502                 getopts_reset(1);
 503         }
 504
 505         /* divine the initial state of the utf8-mode Flag */
 506 #define isuc(x) (((x) != NULL) && \
 507             (stristr((x), "UTF-8") || stristr((x), "utf8")))
 508         ccp = null;
 509         switch (utf_flag) {
 510
 511         /* auto-detect from locale or environment */
 512         case 4:
 513 #if HAVE_SETLOCALE_CTYPE
 514                 ccp = setlocale(LC_CTYPE, "");
 515 #if HAVE_LANGINFO_CODESET
 516                 if (!isuc(ccp))
 517                         ccp = nl_langinfo(CODESET);
 518 #endif
 519                 if (!isuc(ccp))
 520                         ccp = null;
 521                 /* FALLTHROUGH */
 522 #endif
 523
 524         /* auto-detect from environment */
 525         case 3:
 526                 /* these were imported from environ earlier */
 527                 if (ccp == null)
 528                         ccp = str_val(global("LC_ALL"));
 529                 if (ccp == null)
 530                         ccp = str_val(global("LC_CTYPE"));
 531                 if (ccp == null)
 532                         ccp = str_val(global("LANG"));
 533                 UTFMODE = isuc(ccp);
 534                 break;
 535
 536         /* not set on command line, not FTALKING */
 537         case 2:
 538         /* unknown values */
 539         default:
 540                 utf_flag = 0;
 541                 /* FALLTHROUGH */
 542
 543         /* known values */
 544         case 1:
 545         case 0:
 546                 UTFMODE = utf_flag;
 547                 break;
 548         }
 549 #undef isuc
 550
 551         /* Disable during .profile/ENV reading */
 552         restricted = Flag(FRESTRICTED);
 553         Flag(FRESTRICTED) = 0;
 554         errexit = Flag(FERREXIT);
 555         Flag(FERREXIT) = 0;
 556
 557         /*
 558          * Do this before profile/$ENV so that if it causes problems in them,
 559          * user will know why things broke.
 560          */
 561         if (!current_wd[0] && Flag(FTALKING))
 562                 warningf(false, "can't determine current directory");
 563
 564         if (Flag(FLOGIN)) {
 565                 include(MKSH_SYSTEM_PROFILE, 0, NULL, 1);
 566                 if (!Flag(FPRIVILEGED))
 567                         include(substitute("$HOME/.profile", 0), 0,
 568                             NULL, 1);
 569         }
 570         if (Flag(FPRIVILEGED))
 571                 include(MKSH_SUID_PROFILE, 0, NULL, 1);
 572         else if (Flag(FTALKING)) {
 573                 char *env_file;
 574
 575                 /* include $ENV */
 576                 env_file = substitute(substitute("${ENV:-" MKSHRC_PATH "}", 0),
 577                     DOTILDE);
 578                 if (*env_file != '\0')
 579                         include(env_file, 0, NULL, 1);
 580         }
 581
 582         if (restricted) {
 583                 shcomexec(restr_com);
 584                 /* After typeset command... */
 585                 Flag(FRESTRICTED) = 1;
 586         }
 587         Flag(FERREXIT) = errexit;
 588
 589         if (Flag(FTALKING))
 590                 hist_init(s);
 591         else
 592                 /* set after ENV */
 593                 Flag(FTRACKALL) = 1;
 594
 595         alarm_init();
 596
 597         if (Flag(FAS_BUILTIN))
 598                 return (shcomexec(l->argv));
 599
 600         /* doesn't return */
 601         shell(s, true);
 602         /* NOTREACHED */
 603         return (0);
 604 }
 605
 606 int
 607 include(const char *name, int argc, const char **argv, int intr_ok)
 608 {
 609         Source *volatile s = NULL;
 610         struct shf *shf;
 611         const char **volatile old_argv;
 612         volatile int old_argc;
 613         int i;
 614
 615         shf = shf_open(name, O_RDONLY, 0, SHF_MAPHI | SHF_CLEXEC);
 616         if (shf == NULL)
 617                 return (-1);
 618
 619         if (argv) {
 620                 old_argv = e->loc->argv;
 621                 old_argc = e->loc->argc;
 622         } else {
 623                 old_argv = NULL;
 624                 old_argc = 0;
 625         }
 626         newenv(E_INCL);
 627         i = sigsetjmp(e->jbuf, 0);
 628         if (i) {
 629                 quitenv(s ? s->u.shf : NULL);
 630                 if (old_argv) {
 631                         e->loc->argv = old_argv;
 632                         e->loc->argc = old_argc;
 633                 }
 634                 switch (i) {
 635                 case LRETURN:
 636                 case LERROR:
 637                         /* see below */
 638                         return (exstat & 0xFF);
 639                 case LINTR:
 640                         /*
 641                          * intr_ok is set if we are including .profile or $ENV.
 642                          * If user ^Cs out, we don't want to kill the shell...
 643                          */
 644                         if (intr_ok && (exstat - 128) != SIGTERM)
 645                                 return (1);
 646                         /* FALLTHROUGH */
 647                 case LEXIT:
 648                 case LLEAVE:
 649                 case LSHELL:
 650                         unwind(i);
 651                         /* NOTREACHED */
 652                 default:
 653                         internal_errorf("%s %d", "include", i);
 654                         /* NOTREACHED */
 655                 }
 656         }
 657         if (argv) {
 658                 e->loc->argv = argv;
 659                 e->loc->argc = argc;
 660         }
 661         s = pushs(SFILE, ATEMP);
 662         s->u.shf = shf;
 663         strdupx(s->file, name, ATEMP);
 664         i = shell(s, false);
 665         quitenv(s->u.shf);
 666         if (old_argv) {
 667                 e->loc->argv = old_argv;
 668                 e->loc->argc = old_argc;
 669         }
 670         /* & 0xff to ensure value not -1 */
 671         return (i & 0xFF);
 672 }
 673
 674 /* spawn a command into a shell optionally keeping track of the line number */
 675 int
 676 command(const char *comm, int line)
 677 {
 678         Source *s;
 679
 680         s = pushs(SSTRING, ATEMP);
 681         s->start = s->str = comm;
 682         s->line = line;
 683         return (shell(s, false));
 684 }
 685
 686 /*
 687  * run the commands from the input source, returning status.
 688  */
 689 int
 690 shell(Source * volatile s, volatile int toplevel)
 691 {
 692         struct op *t;
 693         volatile int wastty = s->flags & SF_TTY;
 694         volatile int attempts = 13;
 695         volatile int interactive = Flag(FTALKING) && toplevel;
 696         volatile bool sfirst = true;
 697         Source *volatile old_source = source;
 698         int i;
 699
 700         newenv(E_PARSE);
 701         if (interactive)
 702                 really_exit = 0;
 703         i = sigsetjmp(e->jbuf, 0);
 704         if (i) {
 705                 switch (i) {
 706                 case LINTR:
 707                         /* we get here if SIGINT not caught or ignored */
 708                 case LERROR:
 709                 case LSHELL:
 710                         if (interactive) {
 711                                 if (i == LINTR)
 712                                         shellf("\n");
 713                                 /*
 714                                  * Reset any eof that was read as part of a
 715                                  * multiline command.
 716                                  */
 717                                 if (Flag(FIGNOREEOF) && s->type == SEOF &&
 718                                     wastty)
 719                                         s->type = SSTDIN;
 720                                 /*
 721                                  * Used by exit command to get back to
 722                                  * top level shell. Kind of strange since
 723                                  * interactive is set if we are reading from
 724                                  * a tty, but to have stopped jobs, one only
 725                                  * needs FMONITOR set (not FTALKING/SF_TTY)...
 726                                  */
 727                                 /* toss any input we have so far */
 728                                 s->start = s->str = null;
 729                                 break;
 730                         }
 731                         /* FALLTHROUGH */
 732                 case LEXIT:
 733                 case LLEAVE:
 734                 case LRETURN:
 735                         source = old_source;
 736                         quitenv(NULL);
 737                         /* keep on going */
 738                         unwind(i);
 739                         /* NOTREACHED */
 740                 default:
 741                         source = old_source;
 742                         quitenv(NULL);
 743                         internal_errorf("%s %d", "shell", i);
 744                         /* NOTREACHED */
 745                 }
 746         }
 747         while (/* CONSTCOND */ 1) {
 748                 if (trap)
 749                         runtraps(0);
 750
 751                 if (s->next == NULL) {
 752                         if (Flag(FVERBOSE))
 753                                 s->flags |= SF_ECHO;
 754                         else
 755                                 s->flags &= ~SF_ECHO;
 756                 }
 757                 if (interactive) {
 758                         j_notify();
 759                         set_prompt(PS1, s);
 760                 }
 761                 t = compile(s, sfirst);
 762                 sfirst = false;
 763                 if (t != NULL && t->type == TEOF) {
 764                         if (wastty && Flag(FIGNOREEOF) && --attempts > 0) {
 765                                 shellf("Use 'exit' to leave mksh\n");
 766                                 s->type = SSTDIN;
 767                         } else if (wastty && !really_exit &&
 768                             j_stopped_running()) {
 769                                 really_exit = 1;
 770                                 s->type = SSTDIN;
 771                         } else {
 772                                 /*
 773                                  * this for POSIX which says EXIT traps
 774                                  * shall be taken in the environment
 775                                  * immediately after the last command
 776                                  * executed.
 777                                  */
 778                                 if (toplevel)
 779                                         unwind(LEXIT);
 780                                 break;
 781                         }
 782                 }
 783                 if (t && (!Flag(FNOEXEC) || (s->flags & SF_TTY)))
 784                         exstat = execute(t, 0, NULL);
 785
 786                 if (t != NULL && t->type != TEOF && interactive && really_exit)
 787                         really_exit = 0;
 788
 789                 reclaim();
 790         }
 791         quitenv(NULL);
 792         source = old_source;
 793         return (exstat);
 794 }
 795
 796 /* return to closest error handler or shell(), exit if none found */
 797 void
 798 unwind(int i)
 799 {
 800         /* ordering for EXIT vs ERR is a bit odd (this is what AT&T ksh does) */
 801         if (i == LEXIT || (Flag(FERREXIT) && (i == LERROR || i == LINTR) &&
 802             sigtraps[ksh_SIGEXIT].trap)) {
 803                 ++trap_nested;
 804                 runtrap(&sigtraps[ksh_SIGEXIT], trap_nested == 1);
 805                 --trap_nested;
 806                 i = LLEAVE;
 807         } else if (Flag(FERREXIT) && (i == LERROR || i == LINTR)) {
 808                 ++trap_nested;
 809                 runtrap(&sigtraps[ksh_SIGERR], trap_nested == 1);
 810                 --trap_nested;
 811                 i = LLEAVE;
 812         }
 813         while (/* CONSTCOND */ 1) {
 814                 switch (e->type) {
 815                 case E_PARSE:
 816                 case E_FUNC:
 817                 case E_INCL:
 818                 case E_LOOP:
 819                 case E_ERRH:
 820                         siglongjmp(e->jbuf, i);
 821                         /* NOTREACHED */
 822                 case E_NONE:
 823                         if (i == LINTR)
 824                                 e->flags |= EF_FAKE_SIGDIE;
 825                         /* FALLTHROUGH */
 826                 default:
 827                         quitenv(NULL);
 828                 }
 829         }
 830 }
 831
 832 void
 833 newenv(int type)
 834 {
 835         struct env *ep;
 836         char *cp;
 837
 838         /*
 839          * struct env includes ALLOC_ITEM for alignment constraints
 840          * so first get the actually used memory, then assign it
 841          */
 842         cp = alloc(sizeof(struct env) - ALLOC_SIZE, ATEMP);
 843         /* undo what alloc() did to the malloc result address */
 844         ep = (void *)(cp - ALLOC_SIZE);
 845         /* initialise public members of struct env (not the ALLOC_ITEM) */
 846         ainit(&ep->area);
 847         ep->oenv = e;
 848         ep->loc = e->loc;
 849         ep->savefd = NULL;
 850         ep->temps = NULL;
 851         ep->type = type;
 852         ep->flags = 0;
 853         /* jump buffer is invalid because flags == 0 */
 854         e = ep;
 855 }
 856
 857 void
 858 quitenv(struct shf *shf)
 859 {
 860         struct env *ep = e;
 861         char *cp;
 862         int fd;
 863
 864         if (ep->oenv && ep->oenv->loc != ep->loc)
 865                 popblock();
 866         if (ep->savefd != NULL) {
 867                 for (fd = 0; fd < NUFILE; fd++)
 868                         /* if ep->savefd[fd] < 0, means fd was closed */
 869                         if (ep->savefd[fd])
 870                                 restfd(fd, ep->savefd[fd]);
 871                 if (ep->savefd[2])
 872                         /* Clear any write errors */
 873                         shf_reopen(2, SHF_WR, shl_out);
 874         }
 875         /*
 876          * Bottom of the stack.
 877          * Either main shell is exiting or cleanup_parents_env() was called.
 878          */
 879         if (ep->oenv == NULL) {
 880                 if (ep->type == E_NONE) {
 881                         /* Main shell exiting? */
 882 #if HAVE_PERSISTENT_HISTORY
 883                         if (Flag(FTALKING))
 884                                 hist_finish();
 885 #endif
 886                         j_exit();
 887                         if (ep->flags & EF_FAKE_SIGDIE) {
 888                                 int sig = exstat - 128;
 889
 890                                 /*
 891                                  * ham up our death a bit (AT&T ksh
 892                                  * only seems to do this for SIGTERM)
 893                                  * Don't do it for SIGQUIT, since we'd
 894                                  * dump a core..
 895                                  */
 896                                 if ((sig == SIGINT || sig == SIGTERM) &&
 897                                     (kshpgrp == kshpid)) {
 898                                         setsig(&sigtraps[sig], SIG_DFL,
 899                                             SS_RESTORE_CURR | SS_FORCE);
 900                                         kill(0, sig);
 901                                 }
 902                         }
 903                 }
 904                 if (shf)
 905                         shf_close(shf);
 906                 reclaim();
 907                 exit(exstat);
 908         }
 909         if (shf)
 910                 shf_close(shf);
 911         reclaim();
 912
 913         e = e->oenv;
 914
 915         /* free the struct env - tricky due to the ALLOC_ITEM inside */
 916         cp = (void *)ep;
 917         afree(cp + ALLOC_SIZE, ATEMP);
 918 }
 919
 920 /* Called after a fork to cleanup stuff left over from parents environment */
 921 void
 922 cleanup_parents_env(void)
 923 {
 924         struct env *ep;
 925         int fd;
 926
 927         mkssert(e != NULL);
 928
 929         /*
 930          * Don't clean up temporary files - parent will probably need them.
 931          * Also, can't easily reclaim memory since variables, etc. could be
 932          * anywhere.
 933          */
 934
 935         /* close all file descriptors hiding in savefd */
 936         for (ep = e; ep; ep = ep->oenv) {
 937                 if (ep->savefd) {
 938                         for (fd = 0; fd < NUFILE; fd++)
 939                                 if (ep->savefd[fd] > 0)
 940                                         close(ep->savefd[fd]);
 941                         afree(ep->savefd, &ep->area);
 942                         ep->savefd = NULL;
 943                 }
 944         }
 945         e->oenv = NULL;
 946 }
 947
 948 /* Called just before an execve cleanup stuff temporary files */
 949 void
 950 cleanup_proc_env(void)
 951 {
 952         struct env *ep;
 953
 954         for (ep = e; ep; ep = ep->oenv)
 955                 remove_temps(ep->temps);
 956 }
 957
 958 /* remove temp files and free ATEMP Area */
 959 static void
 960 reclaim(void)
 961 {
 962         remove_temps(e->temps);
 963         e->temps = NULL;
 964         afreeall(&e->area);
 965 }
 966
 967 static void
 968 remove_temps(struct temp *tp)
 969 {
 970         for (; tp != NULL; tp = tp->next)
 971                 if (tp->pid == procpid)
 972                         unlink(tp->name);
 973 }
 974
 975 /*
 976  * Initialise tty_fd. Used for saving/reseting tty modes upon
 977  * foreground job completion and for setting up tty process group.
 978  */
 979 void
 980 tty_init(bool init_ttystate, bool need_tty)
 981 {
 982         bool do_close = true;
 983         int tfd;
 984
 985         if (tty_fd >= 0) {
 986                 close(tty_fd);
 987                 tty_fd = -1;
 988         }
 989         tty_devtty = true;
 990
 991 #ifdef _UWIN
 992         /*XXX imake style */
 993         if (isatty(3)) {
 994                 /* fd 3 on UWIN _is_ /dev/tty (or our controlling tty) */
 995                 tfd = 3;
 996                 do_close = false;
 997         } else
 998 #endif
 999           if ((tfd = open("/dev/tty", O_RDWR, 0)) < 0) {
1000                 tty_devtty = false;
1001                 if (need_tty)
1002                         warningf(false, "%s: %s %s: %s",
1003                             "No controlling tty", "open", "/dev/tty",
1004                             strerror(errno));
1005         }
1006         if (tfd < 0) {
1007                 do_close = false;
1008                 if (isatty(0))
1009                         tfd = 0;
1010                 else if (isatty(2))
1011                         tfd = 2;
1012                 else {
1013                         if (need_tty)
1014                                 warningf(false, "can't find tty fd");
1015                         return;
1016                 }
1017         }
1018         if ((tty_fd = fcntl(tfd, F_DUPFD, FDBASE)) < 0) {
1019                 if (need_tty)
1020                         warningf(false, "%s: %s %s: %s", "j_ttyinit",
1021                             "dup of tty fd", "failed", strerror(errno));
1022         } else if (fcntl(tty_fd, F_SETFD, FD_CLOEXEC) < 0) {
1023                 if (need_tty)
1024                         warningf(false, "%s: %s: %s", "j_ttyinit",
1025                             "can't set close-on-exec flag", strerror(errno));
1026                 close(tty_fd);
1027                 tty_fd = -1;
1028         } else if (init_ttystate)
1029                 tcgetattr(tty_fd, &tty_state);
1030         if (do_close)
1031                 close(tfd);
1032 }
1033
1034 void
1035 tty_close(void)
1036 {
1037         if (tty_fd >= 0) {
1038                 close(tty_fd);
1039                 tty_fd = -1;
1040         }
1041 }
1042
1043 /* A shell error occurred (eg, syntax error, etc.) */
1044
1045 #define VWARNINGF_ERRORPREFIX   1
1046 #define VWARNINGF_FILELINE      2
1047 #define VWARNINGF_BUILTIN       4
1048 #define VWARNINGF_INTERNAL      8
1049
1050 static void vwarningf(unsigned int, const char *, va_list)
1051     MKSH_A_FORMAT(__printf__, 2, 0);
1052
1053 static void
1054 vwarningf(unsigned int flags, const char *fmt, va_list ap)
1055 {
1056         if (*fmt != 1) {
1057                 if (flags & VWARNINGF_INTERNAL)
1058                         shf_fprintf(shl_out, "internal error: ");
1059                 if (flags & VWARNINGF_ERRORPREFIX)
1060                         error_prefix(tobool(flags & VWARNINGF_FILELINE));
1061                 if ((flags & VWARNINGF_BUILTIN) &&
1062                     /* not set when main() calls parse_args() */
1063                     builtin_argv0 && builtin_argv0 != kshname)
1064                         shf_fprintf(shl_out, "%s: ", builtin_argv0);
1065                 shf_vfprintf(shl_out, fmt, ap);
1066                 shf_putchar('\n', shl_out);
1067         }
1068         shf_flush(shl_out);
1069 }
1070
1071 void
1072 errorfx(int rc, const char *fmt, ...)
1073 {
1074         va_list va;
1075
1076         exstat = rc;
1077
1078         /* debugging: note that stdout not valid */
1079         shl_stdout_ok = false;
1080
1081         va_start(va, fmt);
1082         vwarningf(VWARNINGF_ERRORPREFIX | VWARNINGF_FILELINE, fmt, va);
1083         va_end(va);
1084         unwind(LERROR);
1085 }
1086
1087 void
1088 errorf(const char *fmt, ...)
1089 {
1090         va_list va;
1091
1092         exstat = 1;
1093
1094         /* debugging: note that stdout not valid */
1095         shl_stdout_ok = false;
1096
1097         va_start(va, fmt);
1098         vwarningf(VWARNINGF_ERRORPREFIX | VWARNINGF_FILELINE, fmt, va);
1099         va_end(va);
1100         unwind(LERROR);
1101 }
1102
1103 /* like errorf(), but no unwind is done */
1104 void
1105 warningf(bool fileline, const char *fmt, ...)
1106 {
1107         va_list va;
1108
1109         va_start(va, fmt);
1110         vwarningf(VWARNINGF_ERRORPREFIX | (fileline ? VWARNINGF_FILELINE : 0),
1111             fmt, va);
1112         va_end(va);
1113 }
1114
1115 /*
1116  * Used by built-in utilities to prefix shell and utility name to message
1117  * (also unwinds environments for special builtins).
1118  */
1119 void
1120 bi_errorf(const char *fmt, ...)
1121 {
1122         va_list va;
1123
1124         /* debugging: note that stdout not valid */
1125         shl_stdout_ok = false;
1126
1127         exstat = 1;
1128
1129         va_start(va, fmt);
1130         vwarningf(VWARNINGF_ERRORPREFIX | VWARNINGF_FILELINE |
1131             VWARNINGF_BUILTIN, fmt, va);
1132         va_end(va);
1133
1134         /*
1135          * POSIX special builtins and ksh special builtins cause
1136          * non-interactive shells to exit.
1137          * XXX odd use of KEEPASN; also may not want LERROR here
1138          */
1139         if (builtin_flag & SPEC_BI) {
1140                 builtin_argv0 = NULL;
1141                 unwind(LERROR);
1142         }
1143 }
1144
1145 /* Called when something that shouldn't happen does */
1146 void
1147 internal_errorf(const char *fmt, ...)
1148 {
1149         va_list va;
1150
1151         va_start(va, fmt);
1152         vwarningf(VWARNINGF_INTERNAL, fmt, va);
1153         va_end(va);
1154         unwind(LERROR);
1155 }
1156
1157 void
1158 internal_warningf(const char *fmt, ...)
1159 {
1160         va_list va;
1161
1162         va_start(va, fmt);
1163         vwarningf(VWARNINGF_INTERNAL, fmt, va);
1164         va_end(va);
1165 }
1166
1167 /* used by error reporting functions to print "ksh: .kshrc[25]: " */
1168 void
1169 error_prefix(bool fileline)
1170 {
1171         /* Avoid foo: foo[2]: ... */
1172         if (!fileline || !source || !source->file ||
1173             strcmp(source->file, kshname) != 0)
1174                 shf_fprintf(shl_out, "%s: ", kshname + (*kshname == '-'));
1175         if (fileline && source && source->file != NULL) {
1176                 shf_fprintf(shl_out, "%s[%d]: ", source->file,
1177                     source->errline > 0 ? source->errline : source->line);
1178                 source->errline = 0;
1179         }
1180 }
1181
1182 /* printf to shl_out (stderr) with flush */
1183 void
1184 shellf(const char *fmt, ...)
1185 {
1186         va_list va;
1187
1188         if (!initio_done)
1189                 /* shl_out may not be set up yet... */
1190                 return;
1191         va_start(va, fmt);
1192         shf_vfprintf(shl_out, fmt, va);
1193         va_end(va);
1194         shf_flush(shl_out);
1195 }
1196
1197 /* printf to shl_stdout (stdout) */
1198 void
1199 shprintf(const char *fmt, ...)
1200 {
1201         va_list va;
1202
1203         if (!shl_stdout_ok)
1204                 internal_errorf("shl_stdout not valid");
1205         va_start(va, fmt);
1206         shf_vfprintf(shl_stdout, fmt, va);
1207         va_end(va);
1208 }
1209
1210 /* test if we can seek backwards fd (returns 0 or SHF_UNBUF) */
1211 int
1212 can_seek(int fd)
1213 {
1214         struct stat statb;
1215
1216         return (fstat(fd, &statb) == 0 && !S_ISREG(statb.st_mode) ?
1217             SHF_UNBUF : 0);
1218 }
1219
1220 struct shf shf_iob[3];
1221
1222 void
1223 initio(void)
1224 {
1225         /* force buffer allocation */
1226         shf_fdopen(1, SHF_WR, shl_stdout);
1227         shf_fdopen(2, SHF_WR, shl_out);
1228         /* force buffer allocation */
1229         shf_fdopen(2, SHF_WR, shl_spare);
1230         initio_done = 1;
1231 }
1232
1233 /* A dup2() with error checking */
1234 int
1235 ksh_dup2(int ofd, int nfd, bool errok)
1236 {
1237         int rv;
1238
1239         if (((rv = dup2(ofd, nfd)) < 0) && !errok && (errno != EBADF))
1240                 errorf("too many files open in shell");
1241
1242 #ifdef __ultrix
1243         /*XXX imake style */
1244         if (rv >= 0)
1245                 fcntl(nfd, F_SETFD, 0);
1246 #endif
1247
1248         return (rv);
1249 }
1250
1251 /*
1252  * Move fd from user space (0 <= fd < 10) to shell space (fd >= 10),
1253  * set close-on-exec flag. See FDBASE in sh.h, maybe 24 not 10 here.
1254  */
1255 short
1256 savefd(int fd)
1257 {
1258         int nfd = fd;
1259
1260         if (fd < FDBASE && (nfd = fcntl(fd, F_DUPFD, FDBASE)) < 0 &&
1261             errno == EBADF)
1262                 return (-1);
1263         if (nfd < 0 || nfd > SHRT_MAX)
1264                 errorf("too many files open in shell");
1265         fcntl(nfd, F_SETFD, FD_CLOEXEC);
1266         return ((short)nfd);
1267 }
1268
1269 void
1270 restfd(int fd, int ofd)
1271 {
1272         if (fd == 2)
1273                 shf_flush(&shf_iob[fd]);
1274         if (ofd < 0)
1275                 /* original fd closed */
1276                 close(fd);
1277         else if (fd != ofd) {
1278                 /*XXX: what to do if this dup fails? */
1279                 ksh_dup2(ofd, fd, true);
1280                 close(ofd);
1281         }
1282 }
1283
1284 void
1285 openpipe(int *pv)
1286 {
1287         int lpv[2];
1288
1289         if (pipe(lpv) < 0)
1290                 errorf("can't create pipe - try again");
1291         pv[0] = savefd(lpv[0]);
1292         if (pv[0] != lpv[0])
1293                 close(lpv[0]);
1294         pv[1] = savefd(lpv[1]);
1295         if (pv[1] != lpv[1])
1296                 close(lpv[1]);
1297 }
1298
1299 void
1300 closepipe(int *pv)
1301 {
1302         close(pv[0]);
1303         close(pv[1]);
1304 }
1305
1306 /*
1307  * Called by iosetup() (deals with 2>&4, etc.), c_read, c_print to turn
1308  * a string (the X in 2>&X, read -uX, print -uX) into a file descriptor.
1309  */
1310 int
1311 check_fd(const char *name, int mode, const char **emsgp)
1312 {
1313         int fd, fl;
1314
1315         if (name[0] == 'p' && !name[1])
1316                 return (coproc_getfd(mode, emsgp));
1317         for (fd = 0; ksh_isdigit(*name); ++name)
1318                 fd = (fd * 10) + *name - '0';
1319         if (*name || fd >= FDBASE) {
1320                 if (emsgp)
1321                         *emsgp = "illegal file descriptor name";
1322                 return (-1);
1323         }
1324         if ((fl = fcntl(fd, F_GETFL, 0)) < 0) {
1325                 if (emsgp)
1326                         *emsgp = "bad file descriptor";
1327                 return (-1);
1328         }
1329         fl &= O_ACCMODE;
1330         /*
1331          * X_OK is a kludge to disable this check for dups (x<&1):
1332          * historical shells never did this check (XXX don't know what
1333          * POSIX has to say).
1334          */
1335         if (!(mode & X_OK) && fl != O_RDWR && (
1336             ((mode & R_OK) && fl != O_RDONLY) ||
1337             ((mode & W_OK) && fl != O_WRONLY))) {
1338                 if (emsgp)
1339                         *emsgp = (fl == O_WRONLY) ?
1340                             "fd not open for reading" :
1341                             "fd not open for writing";
1342                 return (-1);
1343         }
1344         return (fd);
1345 }
1346
1347 /* Called once from main */
1348 void
1349 coproc_init(void)
1350 {
1351         coproc.read = coproc.readw = coproc.write = -1;
1352         coproc.njobs = 0;
1353         coproc.id = 0;
1354 }
1355
1356 /* Called by c_read() when eof is read - close fd if it is the co-process fd */
1357 void
1358 coproc_read_close(int fd)
1359 {
1360         if (coproc.read >= 0 && fd == coproc.read) {
1361                 coproc_readw_close(fd);
1362                 close(coproc.read);
1363                 coproc.read = -1;
1364         }
1365 }
1366
1367 /*
1368  * Called by c_read() and by iosetup() to close the other side of the
1369  * read pipe, so reads will actually terminate.
1370  */
1371 void
1372 coproc_readw_close(int fd)
1373 {
1374         if (coproc.readw >= 0 && coproc.read >= 0 && fd == coproc.read) {
1375                 close(coproc.readw);
1376                 coproc.readw = -1;
1377         }
1378 }
1379
1380 /*
1381  * Called by c_print when a write to a fd fails with EPIPE and by iosetup
1382  * when co-process input is dup'd
1383  */
1384 void
1385 coproc_write_close(int fd)
1386 {
1387         if (coproc.write >= 0 && fd == coproc.write) {
1388                 close(coproc.write);
1389                 coproc.write = -1;
1390         }
1391 }
1392
1393 /*
1394  * Called to check for existence of/value of the co-process file descriptor.
1395  * (Used by check_fd() and by c_read/c_print to deal with -p option).
1396  */
1397 int
1398 coproc_getfd(int mode, const char **emsgp)
1399 {
1400         int fd = (mode & R_OK) ? coproc.read : coproc.write;
1401
1402         if (fd >= 0)
1403                 return (fd);
1404         if (emsgp)
1405                 *emsgp = "no coprocess";
1406         return (-1);
1407 }
1408
1409 /*
1410  * called to close file descriptors related to the coprocess (if any)
1411  * Should be called with SIGCHLD blocked.
1412  */
1413 void
1414 coproc_cleanup(int reuse)
1415 {
1416         /* This to allow co-processes to share output pipe */
1417         if (!reuse || coproc.readw < 0 || coproc.read < 0) {
1418                 if (coproc.read >= 0) {
1419                         close(coproc.read);
1420                         coproc.read = -1;
1421                 }
1422                 if (coproc.readw >= 0) {
1423                         close(coproc.readw);
1424                         coproc.readw = -1;
1425                 }
1426         }
1427         if (coproc.write >= 0) {
1428                 close(coproc.write);
1429                 coproc.write = -1;
1430         }
1431 }
1432
1433 struct temp *
1434 maketemp(Area *ap, Temp_type type, struct temp **tlist)
1435 {
1436         struct temp *tp;
1437         size_t len;
1438         int fd;
1439         char *pathname;
1440         const char *dir;
1441
1442         dir = tmpdir ? tmpdir : MKSH_DEFAULT_TMPDIR;
1443 #if HAVE_MKSTEMP
1444         len = strlen(dir) + 6 + 10 + 1;
1445 #else
1446         pathname = tempnam(dir, "mksh.");
1447         len = ((pathname == NULL) ? 0 : strlen(pathname)) + 1;
1448 #endif
1449         /* reasonably sure that this will not overflow */
1450         tp = alloc(sizeof(struct temp) + len, ap);
1451         tp->name = (char *)&tp[1];
1452 #if !HAVE_MKSTEMP
1453         if (pathname == NULL)
1454                 tp->name[0] = '\0';
1455         else {
1456                 memcpy(tp->name, pathname, len);
1457                 free_ostempnam(pathname);
1458         }
1459 #endif
1460         pathname = tp->name;
1461         tp->shf = NULL;
1462         tp->type = type;
1463 #if HAVE_MKSTEMP
1464         shf_snprintf(pathname, len, "%s%s", dir, "/mksh.XXXXXXXXXX");
1465         if ((fd = mkstemp(pathname)) >= 0)
1466 #else
1467         if (tp->name[0] && (fd = open(tp->name, O_CREAT | O_RDWR, 0600)) >= 0)
1468 #endif
1469                 tp->shf = shf_fdopen(fd, SHF_WR, NULL);
1470         tp->pid = procpid;
1471
1472         tp->next = *tlist;
1473         *tlist = tp;
1474         return (tp);
1475 }
1476
1477 /*
1478  * We use a similar collision resolution algorithm as Python 2.5.4
1479  * but with a slightly tweaked implementation written from scratch.
1480  */
1481
1482 #define INIT_TBLSHIFT   3       /* initial table shift (2^3 = 8) */
1483 #define PERTURB_SHIFT   5       /* see Python 2.5.4 Objects/dictobject.c */
1484
1485 static void tgrow(struct table *);
1486 static int tnamecmp(const void *, const void *);
1487
1488 static void
1489 tgrow(struct table *tp)
1490 {
1491         size_t i, j, osize, mask, perturb;
1492         struct tbl *tblp, **pp;
1493         struct tbl **ntblp, **otblp = tp->tbls;
1494
1495         if (tp->tshift > 29)
1496                 internal_errorf("hash table size limit reached");
1497
1498         /* calculate old size, new shift and new size */
1499         osize = (size_t)1 << (tp->tshift++);
1500         i = osize << 1;
1501
1502         ntblp = alloc2(i, sizeof(struct tbl *), tp->areap);
1503         /* multiplication cannot overflow: alloc2 checked that */
1504         memset(ntblp, 0, i * sizeof(struct tbl *));
1505
1506         /* table can get 80% full except when reaching its limit */
1507         tp->nfree = (tp->tshift == 30) ? 0x3FFF0000UL : ((i * 4) / 5);
1508         tp->tbls = ntblp;
1509         if (otblp == NULL)
1510                 return;
1511
1512         mask = i - 1;
1513         for (i = 0; i < osize; i++)
1514                 if ((tblp = otblp[i]) != NULL) {
1515                         if ((tblp->flag & DEFINED)) {
1516                                 /* search for free hash table slot */
1517                                 j = (perturb = tblp->ua.hval) & mask;
1518                                 goto find_first_empty_slot;
1519  find_next_empty_slot:
1520                                 j = (j << 2) + j + perturb + 1;
1521                                 perturb >>= PERTURB_SHIFT;
1522  find_first_empty_slot:
1523                                 pp = &ntblp[j & mask];
1524                                 if (*pp != NULL)
1525                                         goto find_next_empty_slot;
1526                                 /* found an empty hash table slot */
1527                                 *pp = tblp;
1528                                 tp->nfree--;
1529                         } else if (!(tblp->flag & FINUSE)) {
1530                                 afree(tblp, tp->areap);
1531                         }
1532                 }
1533         afree(otblp, tp->areap);
1534 }
1535
1536 void
1537 ktinit(Area *ap, struct table *tp, uint8_t initshift)
1538 {
1539         tp->areap = ap;
1540         tp->tbls = NULL;
1541         tp->tshift = ((initshift > INIT_TBLSHIFT) ?
1542             initshift : INIT_TBLSHIFT) - 1;
1543         tgrow(tp);
1544 }
1545
1546 /* table, name (key) to search for, hash(name), rv pointer to tbl ptr */
1547 struct tbl *
1548 ktscan(struct table *tp, const char *name, uint32_t h, struct tbl ***ppp)
1549 {
1550         size_t j, perturb, mask;
1551         struct tbl **pp, *p;
1552
1553         mask = ((size_t)1 << (tp->tshift)) - 1;
1554         /* search for hash table slot matching name */
1555         j = (perturb = h) & mask;
1556         goto find_first_slot;
1557  find_next_slot:
1558         j = (j << 2) + j + perturb + 1;
1559         perturb >>= PERTURB_SHIFT;
1560  find_first_slot:
1561         pp = &tp->tbls[j & mask];
1562         if ((p = *pp) != NULL && (p->ua.hval != h || !(p->flag & DEFINED) ||
1563             strcmp(p->name, name)))
1564                 goto find_next_slot;
1565         /* p == NULL if not found, correct found entry otherwise */
1566         if (ppp)
1567                 *ppp = pp;
1568         return (p);
1569 }
1570
1571 /* table, name (key) to enter, hash(n) */
1572 struct tbl *
1573 ktenter(struct table *tp, const char *n, uint32_t h)
1574 {
1575         struct tbl **pp, *p;
1576         size_t len;
1577
1578  Search:
1579         if ((p = ktscan(tp, n, h, &pp)))
1580                 return (p);
1581
1582         if (tp->nfree == 0) {
1583                 /* too full */
1584                 tgrow(tp);
1585                 goto Search;
1586         }
1587
1588         /* create new tbl entry */
1589         len = strlen(n);
1590         checkoktoadd(len, offsetof(struct tbl, name[0]) + 1);
1591         p = alloc(offsetof(struct tbl, name[0]) + ++len, tp->areap);
1592         p->flag = 0;
1593         p->type = 0;
1594         p->areap = tp->areap;
1595         p->ua.hval = h;
1596         p->u2.field = 0;
1597         p->u.array = NULL;
1598         memcpy(p->name, n, len);
1599
1600         /* enter in tp->tbls */
1601         tp->nfree--;
1602         *pp = p;
1603         return (p);
1604 }
1605
1606 void
1607 ktwalk(struct tstate *ts, struct table *tp)
1608 {
1609         ts->left = (size_t)1 << (tp->tshift);
1610         ts->next = tp->tbls;
1611 }
1612
1613 struct tbl *
1614 ktnext(struct tstate *ts)
1615 {
1616         while (--ts->left >= 0) {
1617                 struct tbl *p = *ts->next++;
1618                 if (p != NULL && (p->flag & DEFINED))
1619                         return (p);
1620         }
1621         return (NULL);
1622 }
1623
1624 static int
1625 tnamecmp(const void *p1, const void *p2)
1626 {
1627         const struct tbl *a = *((const struct tbl * const *)p1);
1628         const struct tbl *b = *((const struct tbl * const *)p2);
1629
1630         return (strcmp(a->name, b->name));
1631 }
1632
1633 struct tbl **
1634 ktsort(struct table *tp)
1635 {
1636         size_t i;
1637         struct tbl **p, **sp, **dp;
1638
1639         /*
1640          * since the table is never entirely full, no need to reserve
1641          * additional space for the trailing NULL appended below
1642          */
1643         i = (size_t)1 << (tp->tshift);
1644         p = alloc2(i, sizeof(struct tbl *), ATEMP);
1645         sp = tp->tbls;          /* source */
1646         dp = p;                 /* dest */
1647         while (i--)
1648                 if ((*dp = *sp++) != NULL && (((*dp)->flag & DEFINED) ||
1649                     ((*dp)->flag & ARRAY)))
1650                         dp++;
1651         qsort(p, (i = dp - p), sizeof(struct tbl *), tnamecmp);
1652         p[i] = NULL;
1653         return (p);
1654 }
1655
1656 #ifdef SIGWINCH
1657 static void
1658 x_sigwinch(int sig MKSH_A_UNUSED)
1659 {
1660         /* this runs inside interrupt context, with errno saved */
1661
1662         got_winch = 1;
1663 }
1664 #endif