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