1 /* $OpenBSD: c_ksh.c,v 1.37 2015/09/10 22:48:58 nicm Exp $ */ 2 /* $OpenBSD: c_sh.c,v 1.46 2015/07/20 20:46:24 guenther Exp $ */ 3 /* $OpenBSD: c_test.c,v 1.18 2009/03/01 20:11:06 otto Exp $ */ 4 /* $OpenBSD: c_ulimit.c,v 1.19 2013/11/28 10:33:37 sobrado Exp $ */ 5 6 /*- 7 * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 8 * 2010, 2011, 2012, 2013, 2014, 2015, 2016 9 * mirabilos <m (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 #include "sh.h" 28 29 #if HAVE_SELECT 30 #if HAVE_SYS_BSDTYPES_H 31 #include <sys/bsdtypes.h> 32 #endif 33 #if HAVE_SYS_SELECT_H 34 #include <sys/select.h> 35 #endif 36 #if HAVE_BSTRING_H 37 #include <bstring.h> 38 #endif 39 #endif 40 41 __RCSID("$MirOS: src/bin/mksh/funcs.c,v 1.293 2016/01/20 21:34:11 tg Exp $"); 42 43 #if HAVE_KILLPG 44 /* 45 * use killpg if < -1 since -1 does special things 46 * for some non-killpg-endowed kills 47 */ 48 #define mksh_kill(p,s) ((p) < -1 ? killpg(-(p), (s)) : kill((p), (s))) 49 #else 50 /* cross fingers and hope kill is killpg-endowed */ 51 #define mksh_kill kill 52 #endif 53 54 /* XXX conditions correct? */ 55 #if !defined(RLIM_INFINITY) && !defined(MKSH_NO_LIMITS) 56 #define MKSH_NO_LIMITS 1 57 #endif 58 59 #ifdef MKSH_NO_LIMITS 60 #define c_ulimit c_true 61 #endif 62 63 #if !defined(MKSH_UNEMPLOYED) && HAVE_GETSID 64 static int c_suspend(const char **); 65 #endif 66 67 /* getn() that prints error */ 68 static int 69 bi_getn(const char *as, int *ai) 70 { 71 int rv; 72 73 if (!(rv = getn(as, ai))) 74 bi_errorf("%s: %s", as, "bad number"); 75 return (rv); 76 } 77 78 static int 79 c_true(const char **wp MKSH_A_UNUSED) 80 { 81 return (0); 82 } 83 84 static int 85 c_false(const char **wp MKSH_A_UNUSED) 86 { 87 return (1); 88 } 89 90 /* 91 * A leading = means assignments before command are kept. 92 * A leading * means a POSIX special builtin. 93 */ 94 const struct builtin mkshbuiltins[] = { 95 {"*=.", c_dot}, 96 {"*=:", c_true}, 97 {"[", c_test}, 98 /* no =: AT&T manual wrong */ 99 {Talias, c_alias}, 100 {"*=break", c_brkcont}, 101 {Tgbuiltin, c_builtin}, 102 {Tcat, c_cat}, 103 {"cd", c_cd}, 104 /* dash compatibility hack */ 105 {"chdir", c_cd}, 106 {Tcommand, c_command}, 107 {"*=continue", c_brkcont}, 108 {"echo", c_print}, 109 {"*=eval", c_eval}, 110 {"*=exec", c_exec}, 111 {"*=exit", c_exitreturn}, 112 {Tsgexport, c_typeset}, 113 {"false", c_false}, 114 {"fc", c_fc}, 115 {"getopts", c_getopts}, 116 {"=global", c_typeset}, 117 {"jobs", c_jobs}, 118 {"kill", c_kill}, 119 {"let", c_let}, 120 {"let]", c_let}, 121 {"print", c_print}, 122 {"pwd", c_pwd}, 123 {"read", c_read}, 124 {Tsgreadonly, c_typeset}, 125 {"realpath", c_realpath}, 126 {"rename", c_rename}, 127 {"*=return", c_exitreturn}, 128 {Tsgset, c_set}, 129 {"*=shift", c_shift}, 130 {"=source", c_dot}, 131 #if !defined(MKSH_UNEMPLOYED) && HAVE_GETSID 132 {"suspend", c_suspend}, 133 #endif 134 {"test", c_test}, 135 {"*=times", c_times}, 136 {"*=trap", c_trap}, 137 {"true", c_true}, 138 {T_typeset, c_typeset}, 139 {"ulimit", c_ulimit}, 140 {"umask", c_umask}, 141 {Tunalias, c_unalias}, 142 {"*=unset", c_unset}, 143 {"=wait", c_wait}, 144 {"whence", c_whence}, 145 #ifndef MKSH_UNEMPLOYED 146 {"bg", c_fgbg}, 147 {"fg", c_fgbg}, 148 #endif 149 #ifndef MKSH_NO_CMDLINE_EDITING 150 {"bind", c_bind}, 151 #endif 152 #if HAVE_MKNOD 153 {"mknod", c_mknod}, 154 #endif 155 #ifdef MKSH_PRINTF_BUILTIN 156 {Tprintf, c_printf}, 157 #endif 158 #if HAVE_SELECT 159 {"sleep", c_sleep}, 160 #endif 161 #ifdef __MirBSD__ 162 /* alias to "true" for historical reasons */ 163 {"domainname", c_true}, 164 #endif 165 #ifdef __OS2__ 166 {Textproc, c_true}, 167 #endif 168 {NULL, (int (*)(const char **))NULL} 169 }; 170 171 struct kill_info { 172 int num_width; 173 int name_width; 174 }; 175 176 static const struct t_op { 177 char op_text[4]; 178 Test_op op_num; 179 } u_ops[] = { 180 {"-a", TO_FILAXST }, 181 {"-b", TO_FILBDEV }, 182 {"-c", TO_FILCDEV }, 183 {"-d", TO_FILID }, 184 {"-e", TO_FILEXST }, 185 {"-f", TO_FILREG }, 186 {"-G", TO_FILGID }, 187 {"-g", TO_FILSETG }, 188 {"-h", TO_FILSYM }, 189 {"-H", TO_FILCDF }, 190 {"-k", TO_FILSTCK }, 191 {"-L", TO_FILSYM }, 192 {"-n", TO_STNZE }, 193 {"-O", TO_FILUID }, 194 {"-o", TO_OPTION }, 195 {"-p", TO_FILFIFO }, 196 {"-r", TO_FILRD }, 197 {"-s", TO_FILGZ }, 198 {"-S", TO_FILSOCK }, 199 {"-t", TO_FILTT }, 200 {"-u", TO_FILSETU }, 201 {"-w", TO_FILWR }, 202 {"-x", TO_FILEX }, 203 {"-z", TO_STZER }, 204 {"", TO_NONOP } 205 }; 206 static const struct t_op b_ops[] = { 207 {"=", TO_STEQL }, 208 {"==", TO_STEQL }, 209 {"!=", TO_STNEQ }, 210 {"<", TO_STLT }, 211 {">", TO_STGT }, 212 {"-eq", TO_INTEQ }, 213 {"-ne", TO_INTNE }, 214 {"-gt", TO_INTGT }, 215 {"-ge", TO_INTGE }, 216 {"-lt", TO_INTLT }, 217 {"-le", TO_INTLE }, 218 {"-ef", TO_FILEQ }, 219 {"-nt", TO_FILNT }, 220 {"-ot", TO_FILOT }, 221 {"", TO_NONOP } 222 }; 223 224 static int test_oexpr(Test_env *, bool); 225 static int test_aexpr(Test_env *, bool); 226 static int test_nexpr(Test_env *, bool); 227 static int test_primary(Test_env *, bool); 228 static Test_op ptest_isa(Test_env *, Test_meta); 229 static const char *ptest_getopnd(Test_env *, Test_op, bool); 230 static void ptest_error(Test_env *, int, const char *); 231 static void kill_fmt_entry(char *, size_t, unsigned int, const void *); 232 static void p_time(struct shf *, bool, long, int, int, 233 const char *, const char *); 234 235 int 236 c_pwd(const char **wp) 237 { 238 int optc; 239 bool physical = tobool(Flag(FPHYSICAL)); 240 char *p, *allocd = NULL; 241 242 while ((optc = ksh_getopt(wp, &builtin_opt, "LP")) != -1) 243 switch (optc) { 244 case 'L': 245 physical = false; 246 break; 247 case 'P': 248 physical = true; 249 break; 250 case '?': 251 return (1); 252 } 253 wp += builtin_opt.optind; 254 255 if (wp[0]) { 256 bi_errorf("too many arguments"); 257 return (1); 258 } 259 p = current_wd[0] ? (physical ? allocd = do_realpath(current_wd) : 260 current_wd) : NULL; 261 /* LINTED use of access */ 262 if (p && access(p, R_OK) < 0) 263 p = NULL; 264 if (!p && !(p = allocd = ksh_get_wd())) { 265 bi_errorf("%s: %s", "can't determine current directory", 266 cstrerror(errno)); 267 return (1); 268 } 269 shprintf("%s\n", p); 270 afree(allocd, ATEMP); 271 return (0); 272 } 273 274 static const char *s_ptr; 275 static int s_get(void); 276 static void s_put(int); 277 278 int 279 c_print(const char **wp) 280 { 281 int fd = 1, c; 282 const char *s; 283 XString xs; 284 char *xp; 285 /* print newline; expand backslash sequences */ 286 bool po_nl = true, po_exp = true; 287 /* print to history instead of file descriptor / stdout */ 288 bool po_hist = false; 289 290 if (wp[0][0] == 'e') { 291 /* "echo" builtin */ 292 ++wp; 293 #ifdef MKSH_MIDNIGHTBSD01ASH_COMPAT 294 if (Flag(FSH)) { 295 /* 296 * MidnightBSD /bin/sh needs a BSD echo, that is, 297 * one that supports -e but does not enable it by 298 * default 299 */ 300 po_exp = false; 301 } 302 #endif 303 if (Flag(FPOSIX) || 304 #ifndef MKSH_MIDNIGHTBSD01ASH_COMPAT 305 Flag(FSH) || 306 #endif 307 Flag(FAS_BUILTIN)) { 308 /* Debian Policy 10.4 compliant "echo" builtin */ 309 if (*wp && !strcmp(*wp, "-n")) { 310 /* recognise "-n" only as the first arg */ 311 po_nl = false; 312 ++wp; 313 } 314 /* print everything as-is */ 315 po_exp = false; 316 } else { 317 bool new_exp = po_exp, new_nl = po_nl; 318 319 /** 320 * a compromise between sysV and BSD echo commands: 321 * escape sequences are enabled by default, and -n, 322 * -e and -E are recognised if they appear in argu- 323 * ments with no illegal options (ie, echo -nq will 324 * print -nq). 325 * Different from sysV echo since options are reco- 326 * gnised, different from BSD echo since escape se- 327 * quences are enabled by default. 328 */ 329 330 print_tradparse_arg: 331 if ((s = *wp) && *s++ == '-' && *s) { 332 print_tradparse_ch: 333 switch ((c = *s++)) { 334 case 'E': 335 new_exp = false; 336 goto print_tradparse_ch; 337 case 'e': 338 new_exp = true; 339 goto print_tradparse_ch; 340 case 'n': 341 new_nl = false; 342 goto print_tradparse_ch; 343 case '\0': 344 po_exp = new_exp; 345 po_nl = new_nl; 346 ++wp; 347 goto print_tradparse_arg; 348 } 349 } 350 } 351 } else { 352 /* "print" builtin */ 353 const char *opts = "npRrsu,"; 354 const char *emsg; 355 /* print a "--" argument */ 356 bool po_pminusminus = false; 357 358 while ((c = ksh_getopt(wp, &builtin_opt, opts)) != -1) 359 switch (c) { 360 case 'e': 361 po_exp = true; 362 break; 363 case 'n': 364 po_nl = false; 365 break; 366 case 'p': 367 if ((fd = coproc_getfd(W_OK, &emsg)) < 0) { 368 bi_errorf("-p: %s", emsg); 369 return (1); 370 } 371 break; 372 case 'R': 373 /* fake BSD echo command */ 374 po_pminusminus = true; 375 po_exp = false; 376 opts = "en"; 377 break; 378 case 'r': 379 po_exp = false; 380 break; 381 case 's': 382 po_hist = true; 383 break; 384 case 'u': 385 if (!*(s = builtin_opt.optarg)) 386 fd = 0; 387 else if ((fd = check_fd(s, W_OK, &emsg)) < 0) { 388 bi_errorf("-u%s: %s", s, emsg); 389 return (1); 390 } 391 break; 392 case '?': 393 return (1); 394 } 395 396 if (!(builtin_opt.info & GI_MINUSMINUS)) { 397 /* treat a lone "-" like "--" */ 398 if (wp[builtin_opt.optind] && 399 ksh_isdash(wp[builtin_opt.optind])) 400 builtin_opt.optind++; 401 } else if (po_pminusminus) 402 builtin_opt.optind--; 403 wp += builtin_opt.optind; 404 } 405 406 Xinit(xs, xp, 128, ATEMP); 407 408 if (*wp != NULL) { 409 print_read_arg: 410 s = *wp; 411 while ((c = *s++) != '\0') { 412 Xcheck(xs, xp); 413 if (po_exp && c == '\\') { 414 s_ptr = s; 415 c = unbksl(false, s_get, s_put); 416 s = s_ptr; 417 if (c == -1) { 418 /* rejected by generic function */ 419 switch ((c = *s++)) { 420 case 'c': 421 po_nl = false; 422 /* AT&T brain damage */ 423 continue; 424 case '\0': 425 --s; 426 c = '\\'; 427 break; 428 default: 429 Xput(xs, xp, '\\'); 430 } 431 } else if ((unsigned int)c > 0xFF) { 432 /* generic function returned Unicode */ 433 char ts[4]; 434 435 ts[utf_wctomb(ts, c - 0x100)] = 0; 436 c = 0; 437 do { 438 Xput(xs, xp, ts[c]); 439 } while (ts[++c]); 440 continue; 441 } 442 } 443 Xput(xs, xp, c); 444 } 445 if (*++wp != NULL) { 446 Xput(xs, xp, ' '); 447 goto print_read_arg; 448 } 449 } 450 if (po_nl) 451 Xput(xs, xp, '\n'); 452 453 c = 0; 454 if (po_hist) { 455 Xput(xs, xp, '\0'); 456 histsave(&source->line, Xstring(xs, xp), HIST_STORE, false); 457 Xfree(xs, xp); 458 } else { 459 size_t len = Xlength(xs, xp); 460 bool po_coproc = false; 461 int opipe = 0; 462 463 /* 464 * Ensure we aren't killed by a SIGPIPE while writing to 465 * a coprocess. AT&T ksh doesn't seem to do this (seems 466 * to just check that the co-process is alive which is 467 * not enough). 468 */ 469 if (coproc.write >= 0 && coproc.write == fd) { 470 po_coproc = true; 471 opipe = block_pipe(); 472 } 473 474 s = Xstring(xs, xp); 475 while (len > 0) { 476 ssize_t nwritten; 477 478 if ((nwritten = write(fd, s, len)) < 0) { 479 if (errno == EINTR) { 480 if (po_coproc) 481 restore_pipe(opipe); 482 /* give the user a chance to ^C out */ 483 intrcheck(); 484 /* interrupted, try again */ 485 if (po_coproc) 486 opipe = block_pipe(); 487 continue; 488 } 489 c = 1; 490 break; 491 } 492 s += nwritten; 493 len -= nwritten; 494 } 495 if (po_coproc) 496 restore_pipe(opipe); 497 } 498 499 return (c); 500 } 501 502 static int 503 s_get(void) 504 { 505 return (*s_ptr++); 506 } 507 508 static void 509 s_put(int c MKSH_A_UNUSED) 510 { 511 --s_ptr; 512 } 513 514 int 515 c_whence(const char **wp) 516 { 517 struct tbl *tp; 518 const char *id; 519 bool pflag = false, vflag = false, Vflag = false; 520 int rv = 0, optc, fcflags; 521 bool iam_whence = wp[0][0] == 'w'; 522 const char *opts = iam_whence ? "pv" : "pvV"; 523 524 while ((optc = ksh_getopt(wp, &builtin_opt, opts)) != -1) 525 switch (optc) { 526 case 'p': 527 pflag = true; 528 break; 529 case 'v': 530 vflag = true; 531 break; 532 case 'V': 533 Vflag = true; 534 break; 535 case '?': 536 return (1); 537 } 538 wp += builtin_opt.optind; 539 540 fcflags = FC_BI | FC_PATH | FC_FUNC; 541 if (!iam_whence) { 542 /* Note that -p on its own is deal with in comexec() */ 543 if (pflag) 544 fcflags |= FC_DEFPATH; 545 /* 546 * Convert command options to whence options - note that 547 * command -pV uses a different path search than whence -v 548 * or whence -pv. This should be considered a feature. 549 */ 550 vflag = Vflag; 551 } 552 if (pflag) 553 fcflags &= ~(FC_BI | FC_FUNC); 554 555 while ((vflag || rv == 0) && (id = *wp++) != NULL) { 556 uint32_t h = 0; 557 558 tp = NULL; 559 if (!pflag) 560 tp = ktsearch(&keywords, id, h = hash(id)); 561 if (!tp && !pflag) { 562 tp = ktsearch(&aliases, id, h ? h : hash(id)); 563 if (tp && !(tp->flag & ISSET)) 564 tp = NULL; 565 } 566 if (!tp) 567 tp = findcom(id, fcflags); 568 if (vflag || (tp->type != CALIAS && tp->type != CEXEC && 569 tp->type != CTALIAS)) 570 shf_puts(id, shl_stdout); 571 if (vflag) { 572 switch (tp->type) { 573 case CKEYWD: 574 case CALIAS: 575 case CFUNC: 576 case CSHELL: 577 shf_puts(" is a", shl_stdout); 578 break; 579 } 580 switch (tp->type) { 581 case CKEYWD: 582 case CSHELL: 583 case CTALIAS: 584 case CEXEC: 585 shf_putc(' ', shl_stdout); 586 break; 587 } 588 } 589 590 switch (tp->type) { 591 case CKEYWD: 592 if (vflag) 593 shf_puts("reserved word", shl_stdout); 594 break; 595 case CALIAS: 596 if (vflag) 597 shprintf("n %s%s for ", 598 (tp->flag & EXPORT) ? "exported " : null, 599 Talias); 600 if (!iam_whence && !vflag) 601 shprintf("%s %s=", Talias, id); 602 print_value_quoted(shl_stdout, tp->val.s); 603 break; 604 case CFUNC: 605 if (vflag) { 606 if (tp->flag & EXPORT) 607 shf_puts("n exported", shl_stdout); 608 if (tp->flag & TRACE) 609 shf_puts(" traced", shl_stdout); 610 if (!(tp->flag & ISSET)) { 611 shf_puts(" undefined", shl_stdout); 612 if (tp->u.fpath) 613 shprintf(" (autoload from %s)", 614 tp->u.fpath); 615 } 616 shf_puts(T_function, shl_stdout); 617 } 618 break; 619 case CSHELL: 620 if (vflag) { 621 if (tp->flag & SPEC_BI) 622 shf_puts("special ", shl_stdout); 623 shprintf("%s %s", "shell", Tbuiltin); 624 } 625 break; 626 case CTALIAS: 627 case CEXEC: 628 if (tp->flag & ISSET) { 629 if (vflag) { 630 shf_puts("is ", shl_stdout); 631 if (tp->type == CTALIAS) 632 shprintf("a tracked %s%s for ", 633 (tp->flag & EXPORT) ? 634 "exported " : null, 635 Talias); 636 } 637 shf_puts(tp->val.s, shl_stdout); 638 } else { 639 if (vflag) 640 shf_puts("not found", shl_stdout); 641 rv = 1; 642 } 643 break; 644 default: 645 shf_puts(" is *GOK*", shl_stdout); 646 break; 647 } 648 if (vflag || !rv) 649 shf_putc('\n', shl_stdout); 650 } 651 return (rv); 652 } 653 654 /* Deal with command -vV - command -p dealt with in comexec() */ 655 int 656 c_command(const char **wp) 657 { 658 /* 659 * Let c_whence do the work. Note that c_command() must be 660 * a distinct function from c_whence() (tested in comexec()). 661 */ 662 return (c_whence(wp)); 663 } 664 665 /* typeset, global, export, and readonly */ 666 static void c_typeset_vardump(struct tbl *, uint32_t, int, bool, bool); 667 static void c_typeset_vardump_recursive(struct block *, uint32_t, int, bool, 668 bool); 669 int 670 c_typeset(const char **wp) 671 { 672 struct tbl *vp, **p; 673 uint32_t fset = 0, fclr = 0, flag; 674 int thing = 0, field = 0, base = 0, i; 675 struct block *l; 676 const char *opts; 677 const char *fieldstr = NULL, *basestr = NULL; 678 bool localv = false, func = false, pflag = false, istset = true; 679 enum namerefflag new_refflag = SRF_NOP; 680 681 switch (**wp) { 682 683 /* export */ 684 case 'e': 685 fset |= EXPORT; 686 istset = false; 687 break; 688 689 /* readonly */ 690 case 'r': 691 fset |= RDONLY; 692 istset = false; 693 break; 694 695 /* set */ 696 case 's': 697 /* called with 'typeset -' */ 698 break; 699 700 /* typeset */ 701 case 't': 702 localv = true; 703 break; 704 } 705 706 /* see comment below regarding possible opions */ 707 opts = istset ? "L#R#UZ#afi#lnprtux" : "p"; 708 709 builtin_opt.flags |= GF_PLUSOPT; 710 /* 711 * AT&T ksh seems to have 0-9 as options which are multiplied 712 * to get a number that is used with -L, -R, -Z or -i (eg, -1R2 713 * sets right justify in a field of 12). This allows options 714 * to be grouped in an order (eg, -Lu12), but disallows -i8 -L3 and 715 * does not allow the number to be specified as a separate argument 716 * Here, the number must follow the RLZi option, but is optional 717 * (see the # kludge in ksh_getopt()). 718 */ 719 while ((i = ksh_getopt(wp, &builtin_opt, opts)) != -1) { 720 flag = 0; 721 switch (i) { 722 case 'L': 723 flag = LJUST; 724 fieldstr = builtin_opt.optarg; 725 break; 726 case 'R': 727 flag = RJUST; 728 fieldstr = builtin_opt.optarg; 729 break; 730 case 'U': 731 /* 732 * AT&T ksh uses u, but this conflicts with 733 * upper/lower case. If this option is changed, 734 * need to change the -U below as well 735 */ 736 flag = INT_U; 737 break; 738 case 'Z': 739 flag = ZEROFIL; 740 fieldstr = builtin_opt.optarg; 741 break; 742 case 'a': 743 /* 744 * this is supposed to set (-a) or unset (+a) the 745 * indexed array attribute; it does nothing on an 746 * existing regular string or indexed array though 747 */ 748 break; 749 case 'f': 750 func = true; 751 break; 752 case 'i': 753 flag = INTEGER; 754 basestr = builtin_opt.optarg; 755 break; 756 case 'l': 757 flag = LCASEV; 758 break; 759 case 'n': 760 new_refflag = (builtin_opt.info & GI_PLUS) ? 761 SRF_DISABLE : SRF_ENABLE; 762 break; 763 /* export, readonly: POSIX -p flag */ 764 case 'p': 765 /* typeset: show values as well */ 766 pflag = true; 767 if (istset) 768 continue; 769 break; 770 case 'r': 771 flag = RDONLY; 772 break; 773 case 't': 774 flag = TRACE; 775 break; 776 case 'u': 777 /* upper case / autoload */ 778 flag = UCASEV_AL; 779 break; 780 case 'x': 781 flag = EXPORT; 782 break; 783 case '?': 784 return (1); 785 } 786 if (builtin_opt.info & GI_PLUS) { 787 fclr |= flag; 788 fset &= ~flag; 789 thing = '+'; 790 } else { 791 fset |= flag; 792 fclr &= ~flag; 793 thing = '-'; 794 } 795 } 796 797 if (fieldstr && !bi_getn(fieldstr, &field)) 798 return (1); 799 if (basestr) { 800 if (!getn(basestr, &base)) { 801 bi_errorf("%s: %s", "bad integer base", basestr); 802 return (1); 803 } 804 if (base < 1 || base > 36) 805 base = 10; 806 } 807 808 if (!(builtin_opt.info & GI_MINUSMINUS) && wp[builtin_opt.optind] && 809 (wp[builtin_opt.optind][0] == '-' || 810 wp[builtin_opt.optind][0] == '+') && 811 wp[builtin_opt.optind][1] == '\0') { 812 thing = wp[builtin_opt.optind][0]; 813 builtin_opt.optind++; 814 } 815 816 if (func && (((fset|fclr) & ~(TRACE|UCASEV_AL|EXPORT)) || 817 new_refflag != SRF_NOP)) { 818 bi_errorf("only -t, -u and -x options may be used with -f"); 819 return (1); 820 } 821 if (wp[builtin_opt.optind]) { 822 /* 823 * Take care of exclusions. 824 * At this point, flags in fset are cleared in fclr and vice 825 * versa. This property should be preserved. 826 */ 827 if (fset & LCASEV) 828 /* LCASEV has priority over UCASEV_AL */ 829 fset &= ~UCASEV_AL; 830 if (fset & LJUST) 831 /* LJUST has priority over RJUST */ 832 fset &= ~RJUST; 833 if ((fset & (ZEROFIL|LJUST)) == ZEROFIL) { 834 /* -Z implies -ZR */ 835 fset |= RJUST; 836 fclr &= ~RJUST; 837 } 838 /* 839 * Setting these attributes clears the others, unless they 840 * are also set in this command 841 */ 842 if ((fset & (LJUST | RJUST | ZEROFIL | UCASEV_AL | LCASEV | 843 INTEGER | INT_U | INT_L)) || new_refflag != SRF_NOP) 844 fclr |= ~fset & (LJUST | RJUST | ZEROFIL | UCASEV_AL | 845 LCASEV | INTEGER | INT_U | INT_L); 846 } 847 if (new_refflag != SRF_NOP) { 848 fclr &= ~(ARRAY | ASSOC); 849 fset &= ~(ARRAY | ASSOC); 850 fclr |= EXPORT; 851 fset |= ASSOC; 852 if (new_refflag == SRF_DISABLE) 853 fclr |= ASSOC; 854 } 855 856 /* set variables and attributes */ 857 if (wp[builtin_opt.optind] && 858 /* not "typeset -p varname" */ 859 !(!func && pflag && !(fset | fclr))) { 860 int rv = 0; 861 struct tbl *f; 862 863 if (localv && !func) 864 fset |= LOCAL; 865 for (i = builtin_opt.optind; wp[i]; i++) { 866 if (func) { 867 f = findfunc(wp[i], hash(wp[i]), 868 tobool(fset & UCASEV_AL)); 869 if (!f) { 870 /* AT&T ksh does ++rv: bogus */ 871 rv = 1; 872 continue; 873 } 874 if (fset | fclr) { 875 f->flag |= fset; 876 f->flag &= ~fclr; 877 } else { 878 fpFUNCTf(shl_stdout, 0, 879 tobool(f->flag & FKSH), 880 wp[i], f->val.t); 881 shf_putc('\n', shl_stdout); 882 } 883 } else if (!typeset(wp[i], fset, fclr, field, base)) { 884 bi_errorf("%s: %s", wp[i], "is not an identifier"); 885 return (1); 886 } 887 } 888 return (rv); 889 } 890 891 /* list variables and attributes */ 892 893 /* no difference at this point.. */ 894 flag = fset | fclr; 895 if (func) { 896 for (l = e->loc; l; l = l->next) { 897 for (p = ktsort(&l->funs); (vp = *p++); ) { 898 if (flag && (vp->flag & flag) == 0) 899 continue; 900 if (thing == '-') 901 fpFUNCTf(shl_stdout, 0, 902 tobool(vp->flag & FKSH), 903 vp->name, vp->val.t); 904 else 905 shf_puts(vp->name, shl_stdout); 906 shf_putc('\n', shl_stdout); 907 } 908 } 909 } else if (wp[builtin_opt.optind]) { 910 for (i = builtin_opt.optind; wp[i]; i++) { 911 varsearch(e->loc, &vp, wp[i], hash(wp[i])); 912 c_typeset_vardump(vp, flag, thing, pflag, istset); 913 } 914 } else 915 c_typeset_vardump_recursive(e->loc, flag, thing, pflag, istset); 916 return (0); 917 } 918 919 static void 920 c_typeset_vardump_recursive(struct block *l, uint32_t flag, int thing, 921 bool pflag, bool istset) 922 { 923 struct tbl **blockvars, *vp; 924 925 if (l->next) 926 c_typeset_vardump_recursive(l->next, flag, thing, pflag, istset); 927 blockvars = ktsort(&l->vars); 928 while ((vp = *blockvars++)) 929 c_typeset_vardump(vp, flag, thing, pflag, istset); 930 /*XXX doesnt this leak? */ 931 } 932 933 static void 934 c_typeset_vardump(struct tbl *vp, uint32_t flag, int thing, bool pflag, 935 bool istset) 936 { 937 struct tbl *tvp; 938 int any_set = 0; 939 char *s; 940 941 if (!vp) 942 return; 943 944 /* 945 * See if the parameter is set (for arrays, if any 946 * element is set). 947 */ 948 for (tvp = vp; tvp; tvp = tvp->u.array) 949 if (tvp->flag & ISSET) { 950 any_set = 1; 951 break; 952 } 953 954 /* 955 * Check attributes - note that all array elements 956 * have (should have?) the same attributes, so checking 957 * the first is sufficient. 958 * 959 * Report an unset param only if the user has 960 * explicitly given it some attribute (like export); 961 * otherwise, after "echo $FOO", we would report FOO... 962 */ 963 if (!any_set && !(vp->flag & USERATTRIB)) 964 return; 965 if (flag && (vp->flag & flag) == 0) 966 return; 967 if (!(vp->flag & ARRAY)) 968 /* optimise later conditionals */ 969 any_set = 0; 970 do { 971 /* 972 * Ignore array elements that aren't set unless there 973 * are no set elements, in which case the first is 974 * reported on 975 */ 976 if (any_set && !(vp->flag & ISSET)) 977 continue; 978 /* no arguments */ 979 if (!thing && !flag) { 980 if (any_set == 1) { 981 shprintf("%s %s %s\n", Tset, "-A", vp->name); 982 any_set = 2; 983 } 984 /* 985 * AT&T ksh prints things like export, integer, 986 * leftadj, zerofill, etc., but POSIX says must 987 * be suitable for re-entry... 988 */ 989 shprintf("%s %s", Ttypeset, ""); 990 if (((vp->flag & (ARRAY | ASSOC)) == ASSOC)) 991 shprintf("%s ", "-n"); 992 if ((vp->flag & INTEGER)) 993 shprintf("%s ", "-i"); 994 if ((vp->flag & EXPORT)) 995 shprintf("%s ", "-x"); 996 if ((vp->flag & RDONLY)) 997 shprintf("%s ", "-r"); 998 if ((vp->flag & TRACE)) 999 shprintf("%s ", "-t"); 1000 if ((vp->flag & LJUST)) 1001 shprintf("-L%d ", vp->u2.field); 1002 if ((vp->flag & RJUST)) 1003 shprintf("-R%d ", vp->u2.field); 1004 if ((vp->flag & ZEROFIL)) 1005 shprintf("%s ", "-Z"); 1006 if ((vp->flag & LCASEV)) 1007 shprintf("%s ", "-l"); 1008 if ((vp->flag & UCASEV_AL)) 1009 shprintf("%s ", "-u"); 1010 if ((vp->flag & INT_U)) 1011 shprintf("%s ", "-U"); 1012 } else if (pflag) { 1013 shprintf("%s %s", istset ? Ttypeset : 1014 (flag & EXPORT) ? Texport : Treadonly, ""); 1015 } 1016 if (any_set) 1017 shprintf("%s[%lu]", vp->name, arrayindex(vp)); 1018 else 1019 shf_puts(vp->name, shl_stdout); 1020 if ((!thing && !flag && pflag) || 1021 (thing == '-' && (vp->flag & ISSET))) { 1022 s = str_val(vp); 1023 shf_putc('=', shl_stdout); 1024 /* AT&T ksh can't have justified integers... */ 1025 if ((vp->flag & (INTEGER | LJUST | RJUST)) == INTEGER) 1026 shf_puts(s, shl_stdout); 1027 else 1028 print_value_quoted(shl_stdout, s); 1029 } 1030 shf_putc('\n', shl_stdout); 1031 1032 /* 1033 * Only report first 'element' of an array with 1034 * no set elements. 1035 */ 1036 if (!any_set) 1037 return; 1038 } while ((vp = vp->u.array)); 1039 } 1040 1041 int 1042 c_alias(const char **wp) 1043 { 1044 struct table *t = &aliases; 1045 int rv = 0, prefix = 0; 1046 bool rflag = false, tflag, Uflag = false, pflag = false; 1047 uint32_t xflag = 0; 1048 int optc; 1049 1050 builtin_opt.flags |= GF_PLUSOPT; 1051 while ((optc = ksh_getopt(wp, &builtin_opt, "dprtUx")) != -1) { 1052 prefix = builtin_opt.info & GI_PLUS ? '+' : '-'; 1053 switch (optc) { 1054 case 'd': 1055 #ifdef MKSH_NOPWNAM 1056 t = NULL; /* fix "alias -dt" */ 1057 #else 1058 t = &homedirs; 1059 #endif 1060 break; 1061 case 'p': 1062 pflag = true; 1063 break; 1064 case 'r': 1065 rflag = true; 1066 break; 1067 case 't': 1068 t = &taliases; 1069 break; 1070 case 'U': 1071 /* 1072 * kludge for tracked alias initialization 1073 * (don't do a path search, just make an entry) 1074 */ 1075 Uflag = true; 1076 break; 1077 case 'x': 1078 xflag = EXPORT; 1079 break; 1080 case '?': 1081 return (1); 1082 } 1083 } 1084 #ifdef MKSH_NOPWNAM 1085 if (t == NULL) 1086 return (0); 1087 #endif 1088 wp += builtin_opt.optind; 1089 1090 if (!(builtin_opt.info & GI_MINUSMINUS) && *wp && 1091 (wp[0][0] == '-' || wp[0][0] == '+') && wp[0][1] == '\0') { 1092 prefix = wp[0][0]; 1093 wp++; 1094 } 1095 1096 tflag = t == &taliases; 1097 1098 /* "hash -r" means reset all the tracked aliases.. */ 1099 if (rflag) { 1100 static const char *args[] = { 1101 Tunalias, "-ta", NULL 1102 }; 1103 1104 if (!tflag || *wp) { 1105 shprintf("%s: -r flag can only be used with -t" 1106 " and without arguments\n", Talias); 1107 return (1); 1108 } 1109 ksh_getopt_reset(&builtin_opt, GF_ERROR); 1110 return (c_unalias(args)); 1111 } 1112 1113 if (*wp == NULL) { 1114 struct tbl *ap, **p; 1115 1116 for (p = ktsort(t); (ap = *p++) != NULL; ) 1117 if ((ap->flag & (ISSET|xflag)) == (ISSET|xflag)) { 1118 if (pflag) 1119 shprintf("%s ", Talias); 1120 shf_puts(ap->name, shl_stdout); 1121 if (prefix != '+') { 1122 shf_putc('=', shl_stdout); 1123 print_value_quoted(shl_stdout, ap->val.s); 1124 } 1125 shf_putc('\n', shl_stdout); 1126 } 1127 } 1128 1129 for (; *wp != NULL; wp++) { 1130 const char *alias = *wp, *val, *newval; 1131 char *xalias = NULL; 1132 struct tbl *ap; 1133 uint32_t h; 1134 1135 if ((val = cstrchr(alias, '='))) { 1136 strndupx(xalias, alias, val++ - alias, ATEMP); 1137 alias = xalias; 1138 } 1139 h = hash(alias); 1140 if (val == NULL && !tflag && !xflag) { 1141 ap = ktsearch(t, alias, h); 1142 if (ap != NULL && (ap->flag&ISSET)) { 1143 if (pflag) 1144 shprintf("%s ", Talias); 1145 shf_puts(ap->name, shl_stdout); 1146 if (prefix != '+') { 1147 shf_putc('=', shl_stdout); 1148 print_value_quoted(shl_stdout, ap->val.s); 1149 } 1150 shf_putc('\n', shl_stdout); 1151 } else { 1152 shprintf("%s %s %s\n", alias, Talias, 1153 "not found"); 1154 rv = 1; 1155 } 1156 continue; 1157 } 1158 ap = ktenter(t, alias, h); 1159 ap->type = tflag ? CTALIAS : CALIAS; 1160 /* Are we setting the value or just some flags? */ 1161 if ((val && !tflag) || (!val && tflag && !Uflag)) { 1162 if (ap->flag&ALLOC) { 1163 ap->flag &= ~(ALLOC|ISSET); 1164 afree(ap->val.s, APERM); 1165 } 1166 /* ignore values for -t (AT&T ksh does this) */ 1167 newval = tflag ? 1168 search_path(alias, path, X_OK, NULL) : 1169 val; 1170 if (newval) { 1171 strdupx(ap->val.s, newval, APERM); 1172 ap->flag |= ALLOC|ISSET; 1173 } else 1174 ap->flag &= ~ISSET; 1175 } 1176 ap->flag |= DEFINED; 1177 if (prefix == '+') 1178 ap->flag &= ~xflag; 1179 else 1180 ap->flag |= xflag; 1181 afree(xalias, ATEMP); 1182 } 1183 1184 return (rv); 1185 } 1186 1187 int 1188 c_unalias(const char **wp) 1189 { 1190 struct table *t = &aliases; 1191 struct tbl *ap; 1192 int optc, rv = 0; 1193 bool all = false; 1194 1195 while ((optc = ksh_getopt(wp, &builtin_opt, "adt")) != -1) 1196 switch (optc) { 1197 case 'a': 1198 all = true; 1199 break; 1200 case 'd': 1201 #ifdef MKSH_NOPWNAM 1202 /* fix "unalias -dt" */ 1203 t = NULL; 1204 #else 1205 t = &homedirs; 1206 #endif 1207 break; 1208 case 't': 1209 t = &taliases; 1210 break; 1211 case '?': 1212 return (1); 1213 } 1214 #ifdef MKSH_NOPWNAM 1215 if (t == NULL) 1216 return (0); 1217 #endif 1218 wp += builtin_opt.optind; 1219 1220 for (; *wp != NULL; wp++) { 1221 ap = ktsearch(t, *wp, hash(*wp)); 1222 if (ap == NULL) { 1223 /* POSIX */ 1224 rv = 1; 1225 continue; 1226 } 1227 if (ap->flag&ALLOC) { 1228 ap->flag &= ~(ALLOC|ISSET); 1229 afree(ap->val.s, APERM); 1230 } 1231 ap->flag &= ~(DEFINED|ISSET|EXPORT); 1232 } 1233 1234 if (all) { 1235 struct tstate ts; 1236 1237 for (ktwalk(&ts, t); (ap = ktnext(&ts)); ) { 1238 if (ap->flag&ALLOC) { 1239 ap->flag &= ~(ALLOC|ISSET); 1240 afree(ap->val.s, APERM); 1241 } 1242 ap->flag &= ~(DEFINED|ISSET|EXPORT); 1243 } 1244 } 1245 1246 return (rv); 1247 } 1248 1249 int 1250 c_let(const char **wp) 1251 { 1252 int rv = 1; 1253 mksh_ari_t val; 1254 1255 if (wp[1] == NULL) 1256 /* AT&T ksh does this */ 1257 bi_errorf("no arguments"); 1258 else 1259 for (wp++; *wp; wp++) 1260 if (!evaluate(*wp, &val, KSH_RETURN_ERROR, true)) { 1261 /* distinguish error from zero result */ 1262 rv = 2; 1263 break; 1264 } else 1265 rv = val == 0; 1266 return (rv); 1267 } 1268 1269 int 1270 c_jobs(const char **wp) 1271 { 1272 int optc, flag = 0, nflag = 0, rv = 0; 1273 1274 while ((optc = ksh_getopt(wp, &builtin_opt, "lpnz")) != -1) 1275 switch (optc) { 1276 case 'l': 1277 flag = 1; 1278 break; 1279 case 'p': 1280 flag = 2; 1281 break; 1282 case 'n': 1283 nflag = 1; 1284 break; 1285 case 'z': 1286 /* debugging: print zombies */ 1287 nflag = -1; 1288 break; 1289 case '?': 1290 return (1); 1291 } 1292 wp += builtin_opt.optind; 1293 if (!*wp) { 1294 if (j_jobs(NULL, flag, nflag)) 1295 rv = 1; 1296 } else { 1297 for (; *wp; wp++) 1298 if (j_jobs(*wp, flag, nflag)) 1299 rv = 1; 1300 } 1301 return (rv); 1302 } 1303 1304 #ifndef MKSH_UNEMPLOYED 1305 int 1306 c_fgbg(const char **wp) 1307 { 1308 bool bg = strcmp(*wp, "bg") == 0; 1309 int rv = 0; 1310 1311 if (!Flag(FMONITOR)) { 1312 bi_errorf("job control not enabled"); 1313 return (1); 1314 } 1315 if (ksh_getopt(wp, &builtin_opt, null) == '?') 1316 return (1); 1317 wp += builtin_opt.optind; 1318 if (*wp) 1319 for (; *wp; wp++) 1320 rv = j_resume(*wp, bg); 1321 else 1322 rv = j_resume("%%", bg); 1323 /* fg returns $? of the job unless POSIX */ 1324 return ((bg | Flag(FPOSIX)) ? 0 : rv); 1325 } 1326 #endif 1327 1328 /* format a single kill item */ 1329 static void 1330 kill_fmt_entry(char *buf, size_t buflen, unsigned int i, const void *arg) 1331 { 1332 const struct kill_info *ki = (const struct kill_info *)arg; 1333 1334 i++; 1335 shf_snprintf(buf, buflen, "%*u %*s %s", 1336 ki->num_width, i, 1337 ki->name_width, sigtraps[i].name, 1338 sigtraps[i].mess); 1339 } 1340 1341 int 1342 c_kill(const char **wp) 1343 { 1344 Trap *t = NULL; 1345 const char *p; 1346 bool lflag = false; 1347 int i, n, rv, sig; 1348 1349 /* assume old style options if -digits or -UPPERCASE */ 1350 if ((p = wp[1]) && *p == '-' && (ksh_isdigit(p[1]) || 1351 ksh_isupper(p[1]))) { 1352 if (!(t = gettrap(p + 1, false, false))) { 1353 bi_errorf("bad signal '%s'", p + 1); 1354 return (1); 1355 } 1356 i = (wp[2] && strcmp(wp[2], "--") == 0) ? 3 : 2; 1357 } else { 1358 int optc; 1359 1360 while ((optc = ksh_getopt(wp, &builtin_opt, "ls:")) != -1) 1361 switch (optc) { 1362 case 'l': 1363 lflag = true; 1364 break; 1365 case 's': 1366 if (!(t = gettrap(builtin_opt.optarg, 1367 true, false))) { 1368 bi_errorf("bad signal '%s'", 1369 builtin_opt.optarg); 1370 return (1); 1371 } 1372 break; 1373 case '?': 1374 return (1); 1375 } 1376 i = builtin_opt.optind; 1377 } 1378 if ((lflag && t) || (!wp[i] && !lflag)) { 1379 #ifndef MKSH_SMALL 1380 shf_puts("usage:\tkill [-s signame | -signum | -signame]" 1381 " { job | pid | pgrp } ...\n" 1382 "\tkill -l [exit_status ...]\n", shl_out); 1383 #endif 1384 bi_errorfz(); 1385 return (1); 1386 } 1387 1388 if (lflag) { 1389 if (wp[i]) { 1390 for (; wp[i]; i++) { 1391 if (!bi_getn(wp[i], &n)) 1392 return (1); 1393 #if (ksh_NSIG <= 128) 1394 if (n > 128 && n < 128 + ksh_NSIG) 1395 n -= 128; 1396 #endif 1397 if (n > 0 && n < ksh_NSIG) 1398 shprintf("%s\n", sigtraps[n].name); 1399 else 1400 shprintf("%d\n", n); 1401 } 1402 } else if (Flag(FPOSIX)) { 1403 n = 1; 1404 while (n < ksh_NSIG) { 1405 shf_puts(sigtraps[n].name, shl_stdout); 1406 shf_putc(++n == ksh_NSIG ? '\n' : ' ', 1407 shl_stdout); 1408 } 1409 } else { 1410 ssize_t w, mess_cols = 0, mess_octs = 0; 1411 int j = ksh_NSIG - 1; 1412 struct kill_info ki = { 0, 0 }; 1413 1414 do { 1415 ki.num_width++; 1416 } while ((j /= 10)); 1417 1418 for (j = 1; j < ksh_NSIG; j++) { 1419 w = strlen(sigtraps[j].name); 1420 if (w > ki.name_width) 1421 ki.name_width = w; 1422 w = strlen(sigtraps[j].mess); 1423 if (w > mess_octs) 1424 mess_octs = w; 1425 w = utf_mbswidth(sigtraps[j].mess); 1426 if (w > mess_cols) 1427 mess_cols = w; 1428 } 1429 1430 print_columns(shl_stdout, (unsigned int)(ksh_NSIG - 1), 1431 kill_fmt_entry, (void *)&ki, 1432 ki.num_width + 1 + ki.name_width + 1 + mess_octs, 1433 ki.num_width + 1 + ki.name_width + 1 + mess_cols, 1434 true); 1435 } 1436 return (0); 1437 } 1438 rv = 0; 1439 sig = t ? t->signal : SIGTERM; 1440 for (; (p = wp[i]); i++) { 1441 if (*p == '%') { 1442 if (j_kill(p, sig)) 1443 rv = 1; 1444 } else if (!getn(p, &n)) { 1445 bi_errorf("%s: %s", p, 1446 "arguments must be jobs or process IDs"); 1447 rv = 1; 1448 } else { 1449 if (mksh_kill(n, sig) < 0) { 1450 bi_errorf("%s: %s", p, cstrerror(errno)); 1451 rv = 1; 1452 } 1453 } 1454 } 1455 return (rv); 1456 } 1457 1458 void 1459 getopts_reset(int val) 1460 { 1461 if (val >= 1) { 1462 ksh_getopt_reset(&user_opt, GF_NONAME | 1463 (Flag(FPOSIX) ? 0 : GF_PLUSOPT)); 1464 user_opt.optind = user_opt.uoptind = val; 1465 } 1466 } 1467 1468 int 1469 c_getopts(const char **wp) 1470 { 1471 int argc, optc, rv; 1472 const char *opts, *var; 1473 char buf[3]; 1474 struct tbl *vq, *voptarg; 1475 1476 if (ksh_getopt(wp, &builtin_opt, null) == '?') 1477 return (1); 1478 wp += builtin_opt.optind; 1479 1480 opts = *wp++; 1481 if (!opts) { 1482 bi_errorf("missing %s argument", "options"); 1483 return (1); 1484 } 1485 1486 var = *wp++; 1487 if (!var) { 1488 bi_errorf("missing %s argument", "name"); 1489 return (1); 1490 } 1491 if (!*var || *skip_varname(var, true)) { 1492 bi_errorf("%s: %s", var, "is not an identifier"); 1493 return (1); 1494 } 1495 1496 if (e->loc->next == NULL) { 1497 internal_warningf("%s: %s", "c_getopts", "no argv"); 1498 return (1); 1499 } 1500 /* Which arguments are we parsing... */ 1501 if (*wp == NULL) 1502 wp = e->loc->next->argv; 1503 else 1504 *--wp = e->loc->next->argv[0]; 1505 1506 /* Check that our saved state won't cause a core dump... */ 1507 for (argc = 0; wp[argc]; argc++) 1508 ; 1509 if (user_opt.optind > argc || 1510 (user_opt.p != 0 && 1511 user_opt.p > strlen(wp[user_opt.optind - 1]))) { 1512 bi_errorf("arguments changed since last call"); 1513 return (1); 1514 } 1515 1516 user_opt.optarg = NULL; 1517 optc = ksh_getopt(wp, &user_opt, opts); 1518 1519 if (optc >= 0 && optc != '?' && (user_opt.info & GI_PLUS)) { 1520 buf[0] = '+'; 1521 buf[1] = optc; 1522 buf[2] = '\0'; 1523 } else { 1524 /* 1525 * POSIX says var is set to ? at end-of-options, AT&T ksh 1526 * sets it to null - we go with POSIX... 1527 */ 1528 buf[0] = optc < 0 ? '?' : optc; 1529 buf[1] = '\0'; 1530 } 1531 1532 /* AT&T ksh93 in fact does change OPTIND for unknown options too */ 1533 user_opt.uoptind = user_opt.optind; 1534 1535 voptarg = global("OPTARG"); 1536 /* AT&T ksh clears ro and int */ 1537 voptarg->flag &= ~RDONLY; 1538 /* Paranoia: ensure no bizarre results. */ 1539 if (voptarg->flag & INTEGER) 1540 typeset("OPTARG", 0, INTEGER, 0, 0); 1541 if (user_opt.optarg == NULL) 1542 unset(voptarg, 1); 1543 else 1544 /* This can't fail (have cleared readonly/integer) */ 1545 setstr(voptarg, user_opt.optarg, KSH_RETURN_ERROR); 1546 1547 rv = 0; 1548 1549 vq = global(var); 1550 /* Error message already printed (integer, readonly) */ 1551 if (!setstr(vq, buf, KSH_RETURN_ERROR)) 1552 rv = 2; 1553 if (Flag(FEXPORT)) 1554 typeset(var, EXPORT, 0, 0, 0); 1555 1556 return (optc < 0 ? 1 : rv); 1557 } 1558 1559 #ifndef MKSH_NO_CMDLINE_EDITING 1560 int 1561 c_bind(const char **wp) 1562 { 1563 int optc, rv = 0; 1564 #ifndef MKSH_SMALL 1565 bool macro = false; 1566 #endif 1567 bool list = false; 1568 const char *cp; 1569 char *up; 1570 1571 while ((optc = ksh_getopt(wp, &builtin_opt, 1572 #ifndef MKSH_SMALL 1573 "lm" 1574 #else 1575 "l" 1576 #endif 1577 )) != -1) 1578 switch (optc) { 1579 case 'l': 1580 list = true; 1581 break; 1582 #ifndef MKSH_SMALL 1583 case 'm': 1584 macro = true; 1585 break; 1586 #endif 1587 case '?': 1588 return (1); 1589 } 1590 wp += builtin_opt.optind; 1591 1592 if (*wp == NULL) 1593 /* list all */ 1594 rv = x_bind(NULL, NULL, 1595 #ifndef MKSH_SMALL 1596 false, 1597 #endif 1598 list); 1599 1600 for (; *wp != NULL; wp++) { 1601 if ((cp = cstrchr(*wp, '=')) == NULL) 1602 up = NULL; 1603 else { 1604 strdupx(up, *wp, ATEMP); 1605 up[cp++ - *wp] = '\0'; 1606 } 1607 if (x_bind(up ? up : *wp, cp, 1608 #ifndef MKSH_SMALL 1609 macro, 1610 #endif 1611 false)) 1612 rv = 1; 1613 afree(up, ATEMP); 1614 } 1615 1616 return (rv); 1617 } 1618 #endif 1619 1620 int 1621 c_shift(const char **wp) 1622 { 1623 struct block *l = e->loc; 1624 int n; 1625 mksh_ari_t val; 1626 const char *arg; 1627 1628 if (ksh_getopt(wp, &builtin_opt, null) == '?') 1629 return (1); 1630 arg = wp[builtin_opt.optind]; 1631 1632 if (!arg) 1633 n = 1; 1634 else if (!evaluate(arg, &val, KSH_RETURN_ERROR, false)) { 1635 /* error already printed */ 1636 bi_errorfz(); 1637 return (1); 1638 } else if (!(n = val)) { 1639 /* nothing to do */ 1640 return (0); 1641 } else if (n < 0) { 1642 bi_errorf("%s: %s", arg, "bad number"); 1643 return (1); 1644 } 1645 if (l->argc < n) { 1646 bi_errorf("nothing to shift"); 1647 return (1); 1648 } 1649 l->argv[n] = l->argv[0]; 1650 l->argv += n; 1651 l->argc -= n; 1652 return (0); 1653 } 1654 1655 int 1656 c_umask(const char **wp) 1657 { 1658 int i, optc; 1659 const char *cp; 1660 bool symbolic = false; 1661 mode_t old_umask; 1662 1663 while ((optc = ksh_getopt(wp, &builtin_opt, "S")) != -1) 1664 switch (optc) { 1665 case 'S': 1666 symbolic = true; 1667 break; 1668 case '?': 1669 return (1); 1670 } 1671 cp = wp[builtin_opt.optind]; 1672 if (cp == NULL) { 1673 old_umask = umask((mode_t)0); 1674 umask(old_umask); 1675 if (symbolic) { 1676 char buf[18], *p; 1677 int j; 1678 1679 old_umask = ~old_umask; 1680 p = buf; 1681 for (i = 0; i < 3; i++) { 1682 *p++ = "ugo"[i]; 1683 *p++ = '='; 1684 for (j = 0; j < 3; j++) 1685 if (old_umask & (1 << (8 - (3*i + j)))) 1686 *p++ = "rwx"[j]; 1687 *p++ = ','; 1688 } 1689 p[-1] = '\0'; 1690 shprintf("%s\n", buf); 1691 } else 1692 shprintf("%#3.3o\n", (unsigned int)old_umask); 1693 } else { 1694 mode_t new_umask; 1695 1696 if (ksh_isdigit(*cp)) { 1697 new_umask = 0; 1698 while (*cp >= ord('0') && *cp <= ord('7')) { 1699 new_umask = new_umask * 8 + ksh_numdig(*cp); 1700 ++cp; 1701 } 1702 if (*cp) { 1703 bi_errorf("bad number"); 1704 return (1); 1705 } 1706 } else { 1707 /* symbolic format */ 1708 int positions, new_val; 1709 char op; 1710 1711 old_umask = umask((mode_t)0); 1712 /* in case of error */ 1713 umask(old_umask); 1714 old_umask = ~old_umask; 1715 new_umask = old_umask; 1716 positions = 0; 1717 while (*cp) { 1718 while (*cp && vstrchr("augo", *cp)) 1719 switch (*cp++) { 1720 case 'a': 1721 positions |= 0111; 1722 break; 1723 case 'u': 1724 positions |= 0100; 1725 break; 1726 case 'g': 1727 positions |= 0010; 1728 break; 1729 case 'o': 1730 positions |= 0001; 1731 break; 1732 } 1733 if (!positions) 1734 /* default is a */ 1735 positions = 0111; 1736 if (!vstrchr("=+-", op = *cp)) 1737 break; 1738 cp++; 1739 new_val = 0; 1740 while (*cp && vstrchr("rwxugoXs", *cp)) 1741 switch (*cp++) { 1742 case 'r': new_val |= 04; break; 1743 case 'w': new_val |= 02; break; 1744 case 'x': new_val |= 01; break; 1745 case 'u': 1746 new_val |= old_umask >> 6; 1747 break; 1748 case 'g': 1749 new_val |= old_umask >> 3; 1750 break; 1751 case 'o': 1752 new_val |= old_umask >> 0; 1753 break; 1754 case 'X': 1755 if (old_umask & 0111) 1756 new_val |= 01; 1757 break; 1758 case 's': 1759 /* ignored */ 1760 break; 1761 } 1762 new_val = (new_val & 07) * positions; 1763 switch (op) { 1764 case '-': 1765 new_umask &= ~new_val; 1766 break; 1767 case '=': 1768 new_umask = new_val | 1769 (new_umask & ~(positions * 07)); 1770 break; 1771 case '+': 1772 new_umask |= new_val; 1773 } 1774 if (*cp == ',') { 1775 positions = 0; 1776 cp++; 1777 } else if (!vstrchr("=+-", *cp)) 1778 break; 1779 } 1780 if (*cp) { 1781 bi_errorf("bad mask"); 1782 return (1); 1783 } 1784 new_umask = ~new_umask; 1785 } 1786 umask(new_umask); 1787 } 1788 return (0); 1789 } 1790 1791 int 1792 c_dot(const char **wp) 1793 { 1794 const char *file, *cp, **argv; 1795 int argc, i, errcode; 1796 1797 if (ksh_getopt(wp, &builtin_opt, null) == '?') 1798 return (1); 1799 1800 if ((cp = wp[builtin_opt.optind]) == NULL) { 1801 bi_errorf("missing argument"); 1802 return (1); 1803 } 1804 file = search_path(cp, path, R_OK, &errcode); 1805 if (!file && errcode == ENOENT && wp[0][0] == 's' && 1806 search_access(cp, R_OK) == 0) 1807 file = cp; 1808 if (!file) { 1809 bi_errorf("%s: %s", cp, cstrerror(errcode)); 1810 return (1); 1811 } 1812 1813 /* Set positional parameters? */ 1814 if (wp[builtin_opt.optind + 1]) { 1815 argv = wp + builtin_opt.optind; 1816 /* preserve $0 */ 1817 argv[0] = e->loc->argv[0]; 1818 for (argc = 0; argv[argc + 1]; argc++) 1819 ; 1820 } else { 1821 argc = 0; 1822 argv = NULL; 1823 } 1824 if ((i = include(file, argc, argv, false)) < 0) { 1825 /* should not happen */ 1826 bi_errorf("%s: %s", cp, cstrerror(errno)); 1827 return (1); 1828 } 1829 return (i); 1830 } 1831 1832 int 1833 c_wait(const char **wp) 1834 { 1835 int rv = 0, sig; 1836 1837 if (ksh_getopt(wp, &builtin_opt, null) == '?') 1838 return (1); 1839 wp += builtin_opt.optind; 1840 if (*wp == NULL) { 1841 while (waitfor(NULL, &sig) >= 0) 1842 ; 1843 rv = sig; 1844 } else { 1845 for (; *wp; wp++) 1846 rv = waitfor(*wp, &sig); 1847 if (rv < 0) 1848 /* magic exit code: bad job-id */ 1849 rv = sig ? sig : 127; 1850 } 1851 return (rv); 1852 } 1853 1854 static char REPLY[] = "REPLY"; 1855 int 1856 c_read(const char **wp) 1857 { 1858 #define is_ifsws(c) (ctype((c), C_IFS) && ctype((c), C_IFSWS)) 1859 int c, fd = 0, rv = 0; 1860 bool savehist = false, intoarray = false, aschars = false; 1861 bool rawmode = false, expanding = false; 1862 bool lastparmmode = false, lastparmused = false; 1863 enum { LINES, BYTES, UPTO, READALL } readmode = LINES; 1864 char delim = '\n'; 1865 size_t bytesleft = 128, bytesread; 1866 struct tbl *vp /* FU gcc */ = NULL, *vq = NULL; 1867 char *cp, *allocd = NULL, *xp; 1868 const char *ccp; 1869 XString xs; 1870 size_t xsave = 0; 1871 mksh_ttyst tios; 1872 bool restore_tios = false; 1873 /* to catch read -aN2 foo[i] */ 1874 bool subarray = false; 1875 #if HAVE_SELECT 1876 bool hastimeout = false; 1877 struct timeval tv, tvlim; 1878 #define c_read_opts "Aad:N:n:prst:u," 1879 #else 1880 #define c_read_opts "Aad:N:n:prsu," 1881 #endif 1882 1883 while ((c = ksh_getopt(wp, &builtin_opt, c_read_opts)) != -1) 1884 switch (c) { 1885 case 'a': 1886 aschars = true; 1887 /* FALLTHROUGH */ 1888 case 'A': 1889 intoarray = true; 1890 break; 1891 case 'd': 1892 delim = builtin_opt.optarg[0]; 1893 break; 1894 case 'N': 1895 case 'n': 1896 readmode = c == 'N' ? BYTES : UPTO; 1897 if (!bi_getn(builtin_opt.optarg, &c)) 1898 return (2); 1899 if (c == -1) { 1900 readmode = readmode == BYTES ? READALL : UPTO; 1901 bytesleft = 1024; 1902 } else 1903 bytesleft = (unsigned int)c; 1904 break; 1905 case 'p': 1906 if ((fd = coproc_getfd(R_OK, &ccp)) < 0) { 1907 bi_errorf("%s: %s", "-p", ccp); 1908 return (2); 1909 } 1910 break; 1911 case 'r': 1912 rawmode = true; 1913 break; 1914 case 's': 1915 savehist = true; 1916 break; 1917 #if HAVE_SELECT 1918 case 't': 1919 if (parse_usec(builtin_opt.optarg, &tv)) { 1920 bi_errorf("%s: %s '%s'", Tsynerr, cstrerror(errno), 1921 builtin_opt.optarg); 1922 return (2); 1923 } 1924 hastimeout = true; 1925 break; 1926 #endif 1927 case 'u': 1928 if (!builtin_opt.optarg[0]) 1929 fd = 0; 1930 else if ((fd = check_fd(builtin_opt.optarg, R_OK, &ccp)) < 0) { 1931 bi_errorf("%s: %s: %s", "-u", builtin_opt.optarg, ccp); 1932 return (2); 1933 } 1934 break; 1935 case '?': 1936 return (2); 1937 } 1938 wp += builtin_opt.optind; 1939 if (*wp == NULL) 1940 *--wp = REPLY; 1941 1942 if (intoarray && wp[1] != NULL) { 1943 bi_errorf("too many arguments"); 1944 return (2); 1945 } 1946 1947 if ((ccp = cstrchr(*wp, '?')) != NULL) { 1948 strdupx(allocd, *wp, ATEMP); 1949 allocd[ccp - *wp] = '\0'; 1950 *wp = allocd; 1951 if (isatty(fd)) { 1952 /* 1953 * AT&T ksh says it prints prompt on fd if it's open 1954 * for writing and is a tty, but it doesn't do it 1955 * (it also doesn't check the interactive flag, 1956 * as is indicated in the Korn Shell book). 1957 */ 1958 shf_puts(ccp + 1, shl_out); 1959 shf_flush(shl_out); 1960 } 1961 } 1962 1963 Xinit(xs, xp, bytesleft, ATEMP); 1964 1965 if (readmode == LINES) 1966 bytesleft = 1; 1967 else if (isatty(fd)) { 1968 x_mkraw(fd, &tios, true); 1969 restore_tios = true; 1970 } 1971 1972 #if HAVE_SELECT 1973 if (hastimeout) { 1974 mksh_TIME(tvlim); 1975 timeradd(&tvlim, &tv, &tvlim); 1976 } 1977 #endif 1978 1979 c_read_readloop: 1980 #if HAVE_SELECT 1981 if (hastimeout) { 1982 fd_set fdset; 1983 1984 FD_ZERO(&fdset); 1985 FD_SET((unsigned int)fd, &fdset); 1986 mksh_TIME(tv); 1987 timersub(&tvlim, &tv, &tv); 1988 if (tv.tv_sec < 0) { 1989 /* timeout expired globally */ 1990 rv = 1; 1991 goto c_read_out; 1992 } 1993 1994 switch (select(fd + 1, &fdset, NULL, NULL, &tv)) { 1995 case 1: 1996 break; 1997 case 0: 1998 /* timeout expired for this call */ 1999 bytesread = 0; 2000 /* fake EOF read; all cases return 1 */ 2001 goto c_read_didread; 2002 default: 2003 bi_errorf("%s: %s", Tselect, cstrerror(errno)); 2004 rv = 2; 2005 goto c_read_out; 2006 } 2007 } 2008 #endif 2009 2010 bytesread = blocking_read(fd, xp, bytesleft); 2011 if (bytesread == (size_t)-1) { 2012 /* interrupted */ 2013 if (errno == EINTR && fatal_trap_check()) { 2014 /* 2015 * Was the offending signal one that would 2016 * normally kill a process? If so, pretend 2017 * the read was killed. 2018 */ 2019 rv = 2; 2020 goto c_read_out; 2021 } 2022 /* just ignore the signal */ 2023 goto c_read_readloop; 2024 } 2025 2026 c_read_didread: 2027 switch (readmode) { 2028 case READALL: 2029 if (bytesread == 0) { 2030 /* end of file reached */ 2031 rv = 1; 2032 goto c_read_readdone; 2033 } 2034 xp += bytesread; 2035 XcheckN(xs, xp, bytesleft); 2036 break; 2037 2038 case UPTO: 2039 if (bytesread == 0) 2040 /* end of file reached */ 2041 rv = 1; 2042 xp += bytesread; 2043 goto c_read_readdone; 2044 2045 case BYTES: 2046 if (bytesread == 0) { 2047 /* end of file reached */ 2048 rv = 1; 2049 /* may be partial read: $? = 1, but content */ 2050 goto c_read_readdone; 2051 } 2052 xp += bytesread; 2053 if ((bytesleft -= bytesread) == 0) 2054 goto c_read_readdone; 2055 break; 2056 case LINES: 2057 if (bytesread == 0) { 2058 /* end of file reached */ 2059 rv = 1; 2060 goto c_read_readdone; 2061 } 2062 if ((c = *xp) == '\0' && !aschars && delim != '\0') { 2063 /* skip any read NULs unless delimiter */ 2064 break; 2065 } 2066 if (expanding) { 2067 expanding = false; 2068 if (c == delim) { 2069 if (Flag(FTALKING_I) && isatty(fd)) { 2070 /* 2071 * set prompt in case this is 2072 * called from .profile or $ENV 2073 */ 2074 set_prompt(PS2, NULL); 2075 pprompt(prompt, 0); 2076 } 2077 /* drop the backslash */ 2078 --xp; 2079 /* and the delimiter */ 2080 break; 2081 } 2082 } else if (c == delim) { 2083 goto c_read_readdone; 2084 } else if (!rawmode && c == '\\') { 2085 expanding = true; 2086 } 2087 Xcheck(xs, xp); 2088 ++xp; 2089 break; 2090 } 2091 goto c_read_readloop; 2092 2093 c_read_readdone: 2094 bytesread = Xlength(xs, xp); 2095 Xput(xs, xp, '\0'); 2096 2097 /*- 2098 * state: we finished reading the input and NUL terminated it 2099 * Xstring(xs, xp) -> xp-1 = input string without trailing delim 2100 * rv = 1 if EOF, 0 otherwise (errors handled already) 2101 */ 2102 2103 if (rv == 1) { 2104 /* clean up coprocess if needed, on EOF */ 2105 coproc_read_close(fd); 2106 if (readmode == READALL) 2107 /* EOF is no error here */ 2108 rv = 0; 2109 } 2110 2111 if (savehist) 2112 histsave(&source->line, Xstring(xs, xp), HIST_STORE, false); 2113 2114 ccp = cp = Xclose(xs, xp); 2115 expanding = false; 2116 XinitN(xs, 128, ATEMP); 2117 if (intoarray) { 2118 vp = global(*wp); 2119 subarray = last_lookup_was_array; 2120 if (vp->flag & RDONLY) { 2121 c_read_splitro: 2122 bi_errorf("read-only: %s", *wp); 2123 c_read_spliterr: 2124 rv = 2; 2125 afree(cp, ATEMP); 2126 goto c_read_out; 2127 } 2128 /* counter for array index */ 2129 c = subarray ? arrayindex(vp) : 0; 2130 /* exporting an array is currently pointless */ 2131 unset(vp, subarray ? 0 : 1); 2132 } 2133 if (!aschars) { 2134 /* skip initial IFS whitespace */ 2135 while (bytesread && is_ifsws(*ccp)) { 2136 ++ccp; 2137 --bytesread; 2138 } 2139 /* trim trailing IFS whitespace */ 2140 while (bytesread && is_ifsws(ccp[bytesread - 1])) { 2141 --bytesread; 2142 } 2143 } 2144 c_read_splitloop: 2145 xp = Xstring(xs, xp); 2146 /* generate next word */ 2147 if (!bytesread) { 2148 /* no more input */ 2149 if (intoarray) 2150 goto c_read_splitdone; 2151 /* zero out next parameters */ 2152 goto c_read_gotword; 2153 } 2154 if (aschars) { 2155 Xput(xs, xp, '1'); 2156 Xput(xs, xp, '#'); 2157 bytesleft = utf_ptradj(ccp); 2158 while (bytesleft && bytesread) { 2159 *xp++ = *ccp++; 2160 --bytesleft; 2161 --bytesread; 2162 } 2163 if (xp[-1] == '\0') { 2164 xp[-1] = '0'; 2165 xp[-3] = '2'; 2166 } 2167 goto c_read_gotword; 2168 } 2169 2170 if (!intoarray && wp[1] == NULL) 2171 lastparmmode = true; 2172 2173 c_read_splitlast: 2174 /* copy until IFS character */ 2175 while (bytesread) { 2176 char ch; 2177 2178 ch = *ccp; 2179 if (expanding) { 2180 expanding = false; 2181 goto c_read_splitcopy; 2182 } else if (ctype(ch, C_IFS)) { 2183 break; 2184 } else if (!rawmode && ch == '\\') { 2185 expanding = true; 2186 } else { 2187 c_read_splitcopy: 2188 Xcheck(xs, xp); 2189 Xput(xs, xp, ch); 2190 } 2191 ++ccp; 2192 --bytesread; 2193 } 2194 xsave = Xsavepos(xs, xp); 2195 /* copy word delimiter: IFSWS+IFS,IFSWS */ 2196 expanding = false; 2197 while (bytesread) { 2198 char ch; 2199 2200 ch = *ccp; 2201 if (!ctype(ch, C_IFS)) 2202 break; 2203 if (lastparmmode && !expanding && !rawmode && ch == '\\') { 2204 expanding = true; 2205 } else { 2206 Xcheck(xs, xp); 2207 Xput(xs, xp, ch); 2208 } 2209 ++ccp; 2210 --bytesread; 2211 if (expanding) 2212 continue; 2213 if (!ctype(ch, C_IFSWS)) 2214 break; 2215 } 2216 while (bytesread && is_ifsws(*ccp)) { 2217 Xcheck(xs, xp); 2218 Xput(xs, xp, *ccp); 2219 ++ccp; 2220 --bytesread; 2221 } 2222 /* if no more parameters, rinse and repeat */ 2223 if (lastparmmode && bytesread) { 2224 lastparmused = true; 2225 goto c_read_splitlast; 2226 } 2227 /* get rid of the delimiter unless we pack the rest */ 2228 if (!lastparmused) 2229 xp = Xrestpos(xs, xp, xsave); 2230 c_read_gotword: 2231 Xput(xs, xp, '\0'); 2232 if (intoarray) { 2233 if (subarray) { 2234 /* array element passed, accept first read */ 2235 if (vq) { 2236 bi_errorf("nested arrays not yet supported"); 2237 goto c_read_spliterr; 2238 } 2239 vq = vp; 2240 if (c) 2241 /* [0] doesn't */ 2242 vq->flag |= AINDEX; 2243 } else 2244 vq = arraysearch(vp, c++); 2245 } else { 2246 vq = global(*wp); 2247 /* must be checked before exporting */ 2248 if (vq->flag & RDONLY) 2249 goto c_read_splitro; 2250 if (Flag(FEXPORT)) 2251 typeset(*wp, EXPORT, 0, 0, 0); 2252 } 2253 if (!setstr(vq, Xstring(xs, xp), KSH_RETURN_ERROR)) 2254 goto c_read_spliterr; 2255 if (aschars) { 2256 setint_v(vq, vq, false); 2257 /* protect from UTFMODE changes */ 2258 vq->type = 0; 2259 } 2260 if (intoarray || *++wp != NULL) 2261 goto c_read_splitloop; 2262 2263 c_read_splitdone: 2264 /* free up */ 2265 afree(cp, ATEMP); 2266 2267 c_read_out: 2268 afree(allocd, ATEMP); 2269 Xfree(xs, xp); 2270 if (restore_tios) 2271 mksh_tcset(fd, &tios); 2272 return (rv); 2273 #undef is_ifsws 2274 } 2275 2276 int 2277 c_eval(const char **wp) 2278 { 2279 struct source *s, *saves = source; 2280 unsigned char savef; 2281 int rv; 2282 2283 if (ksh_getopt(wp, &builtin_opt, null) == '?') 2284 return (1); 2285 s = pushs(SWORDS, ATEMP); 2286 s->u.strv = wp + builtin_opt.optind; 2287 2288 /*- 2289 * The following code handles the case where the command is 2290 * empty due to failed command substitution, for example by 2291 * eval "$(false)" 2292 * This has historically returned 1 by AT&T ksh88. In this 2293 * case, shell() will not set or change exstat because the 2294 * compiled tree is empty, so it will use the value we pass 2295 * from subst_exstat, which is cleared in execute(), so it 2296 * should have been 0 if there were no substitutions. 2297 * 2298 * POSIX however says we don't do this, even though it is 2299 * traditionally done. AT&T ksh93 agrees with POSIX, so we 2300 * do. The following is an excerpt from SUSv4 [1003.2-2008]: 2301 * 2302 * 2.9.1: Simple Commands 2303 * ... If there is a command name, execution shall 2304 * continue as described in 2.9.1.1 [Command Search 2305 * and Execution]. If there is no command name, but 2306 * the command contained a command substitution, the 2307 * command shall complete with the exit status of the 2308 * last command substitution performed. 2309 * 2.9.1.1: Command Search and Execution 2310 * (1) a. If the command name matches the name of a 2311 * special built-in utility, that special built-in 2312 * utility shall be invoked. 2313 * 2.14.5: eval 2314 * If there are no arguments, or only null arguments, 2315 * eval shall return a zero exit status; ... 2316 */ 2317 /* AT&T ksh88: use subst_exstat */ 2318 /* exstat = subst_exstat; */ 2319 /* SUSv4: OR with a high value never written otherwise */ 2320 exstat |= 0x4000; 2321 2322 savef = Flag(FERREXIT); 2323 Flag(FERREXIT) |= 0x80; 2324 rv = shell(s, false); 2325 Flag(FERREXIT) = savef; 2326 source = saves; 2327 afree(s, ATEMP); 2328 if (exstat & 0x4000) 2329 /* detect old exstat, use 0 in that case */ 2330 rv = 0; 2331 return (rv); 2332 } 2333 2334 int 2335 c_trap(const char **wp) 2336 { 2337 Trap *p = sigtraps; 2338 int i = ksh_NSIG; 2339 const char *s; 2340 2341 if (ksh_getopt(wp, &builtin_opt, null) == '?') 2342 return (1); 2343 wp += builtin_opt.optind; 2344 2345 if (*wp == NULL) { 2346 do { 2347 if (p->trap) { 2348 shf_puts("trap -- ", shl_stdout); 2349 print_value_quoted(shl_stdout, p->trap); 2350 shprintf(" %s\n", p->name); 2351 } 2352 ++p; 2353 } while (i--); 2354 return (0); 2355 } 2356 2357 if (getn(*wp, &i)) { 2358 /* first argument is a signal number, reset them all */ 2359 s = NULL; 2360 } else { 2361 /* first argument must be a command, then */ 2362 s = *wp++; 2363 /* reset traps? */ 2364 if (ksh_isdash(s)) 2365 s = NULL; 2366 } 2367 2368 /* set/clear the traps */ 2369 i = 0; 2370 while (*wp) 2371 if (!(p = gettrap(*wp++, true, true))) { 2372 warningf(true, "%s: %s '%s'", builtin_argv0, 2373 "bad signal", wp[-1]); 2374 i = 1; 2375 } else 2376 settrap(p, s); 2377 return (i); 2378 } 2379 2380 int 2381 c_exitreturn(const char **wp) 2382 { 2383 int n, how = LEXIT; 2384 2385 if (wp[1]) { 2386 if (wp[2]) 2387 goto c_exitreturn_err; 2388 exstat = bi_getn(wp[1], &n) ? (n & 0xFF) : 1; 2389 } else if (trap_exstat != -1) 2390 exstat = trap_exstat; 2391 2392 if (wp[0][0] == 'r') { 2393 /* return */ 2394 struct env *ep; 2395 2396 /* 2397 * need to tell if this is exit or return so trap exit will 2398 * work right (POSIX) 2399 */ 2400 for (ep = e; ep; ep = ep->oenv) 2401 if (STOP_RETURN(ep->type)) { 2402 how = LRETURN; 2403 break; 2404 } 2405 } 2406 2407 if (how == LEXIT && !really_exit && j_stopped_running()) { 2408 really_exit = true; 2409 how = LSHELL; 2410 } 2411 2412 /* get rid of any I/O redirections */ 2413 quitenv(NULL); 2414 unwind(how); 2415 /* NOTREACHED */ 2416 2417 c_exitreturn_err: 2418 bi_errorf("too many arguments"); 2419 return (1); 2420 } 2421 2422 int 2423 c_brkcont(const char **wp) 2424 { 2425 unsigned int quit; 2426 int n; 2427 struct env *ep, *last_ep = NULL; 2428 const char *arg; 2429 2430 if (ksh_getopt(wp, &builtin_opt, null) == '?') 2431 goto c_brkcont_err; 2432 arg = wp[builtin_opt.optind]; 2433 2434 if (!arg) 2435 n = 1; 2436 else if (!bi_getn(arg, &n)) 2437 goto c_brkcont_err; 2438 if (n <= 0) { 2439 /* AT&T ksh does this for non-interactive shells only - weird */ 2440 bi_errorf("%s: %s", arg, "bad value"); 2441 goto c_brkcont_err; 2442 } 2443 quit = (unsigned int)n; 2444 2445 /* Stop at E_NONE, E_PARSE, E_FUNC, or E_INCL */ 2446 for (ep = e; ep && !STOP_BRKCONT(ep->type); ep = ep->oenv) 2447 if (ep->type == E_LOOP) { 2448 if (--quit == 0) 2449 break; 2450 ep->flags |= EF_BRKCONT_PASS; 2451 last_ep = ep; 2452 } 2453 2454 if (quit) { 2455 /* 2456 * AT&T ksh doesn't print a message - just does what it 2457 * can. We print a message 'cause it helps in debugging 2458 * scripts, but don't generate an error (ie, keep going). 2459 */ 2460 if ((unsigned int)n == quit) { 2461 warningf(true, "%s: %s %s", wp[0], "can't", wp[0]); 2462 return (0); 2463 } 2464 /* 2465 * POSIX says if n is too big, the last enclosing loop 2466 * shall be used. Doesn't say to print an error but we 2467 * do anyway 'cause the user messed up. 2468 */ 2469 if (last_ep) 2470 last_ep->flags &= ~EF_BRKCONT_PASS; 2471 warningf(true, "%s: can only %s %u level(s)", 2472 wp[0], wp[0], (unsigned int)n - quit); 2473 } 2474 2475 unwind(*wp[0] == 'b' ? LBREAK : LCONTIN); 2476 /* NOTREACHED */ 2477 2478 c_brkcont_err: 2479 return (1); 2480 } 2481 2482 int 2483 c_set(const char **wp) 2484 { 2485 int argi; 2486 bool setargs; 2487 struct block *l = e->loc; 2488 const char **owp; 2489 2490 if (wp[1] == NULL) { 2491 static const char *args[] = { Tset, "-", NULL }; 2492 return (c_typeset(args)); 2493 } 2494 2495 if ((argi = parse_args(wp, OF_SET, &setargs)) < 0) 2496 return (2); 2497 /* set $# and $* */ 2498 if (setargs) { 2499 wp += argi - 1; 2500 owp = wp; 2501 /* save $0 */ 2502 wp[0] = l->argv[0]; 2503 while (*++wp != NULL) 2504 strdupx(*wp, *wp, &l->area); 2505 l->argc = wp - owp - 1; 2506 l->argv = alloc2(l->argc + 2, sizeof(char *), &l->area); 2507 for (wp = l->argv; (*wp++ = *owp++) != NULL; ) 2508 ; 2509 } 2510 /*- 2511 * POSIX says set exit status is 0, but old scripts that use 2512 * getopt(1) use the construct 2513 * set -- $(getopt ab:c "$@") 2514 * which assumes the exit value set will be that of the $() 2515 * (subst_exstat is cleared in execute() so that it will be 0 2516 * if there are no command substitutions). 2517 */ 2518 #ifdef MKSH_LEGACY_MODE 2519 /* traditional behaviour, unless set -o posix */ 2520 return (Flag(FPOSIX) ? 0 : subst_exstat); 2521 #else 2522 /* conformant behaviour, unless set -o sh +o posix */ 2523 return (Flag(FSH) && !Flag(FPOSIX) ? subst_exstat : 0); 2524 #endif 2525 } 2526 2527 int 2528 c_unset(const char **wp) 2529 { 2530 const char *id; 2531 int optc, rv = 0; 2532 bool unset_var = true; 2533 2534 while ((optc = ksh_getopt(wp, &builtin_opt, "fv")) != -1) 2535 switch (optc) { 2536 case 'f': 2537 unset_var = false; 2538 break; 2539 case 'v': 2540 unset_var = true; 2541 break; 2542 case '?': 2543 /*XXX not reached due to GF_ERROR */ 2544 return (2); 2545 } 2546 wp += builtin_opt.optind; 2547 for (; (id = *wp) != NULL; wp++) 2548 if (unset_var) { 2549 /* unset variable */ 2550 struct tbl *vp; 2551 char *cp = NULL; 2552 size_t n; 2553 2554 n = strlen(id); 2555 if (n > 3 && id[n-3] == '[' && id[n-2] == '*' && 2556 id[n-1] == ']') { 2557 strndupx(cp, id, n - 3, ATEMP); 2558 id = cp; 2559 optc = 3; 2560 } else 2561 optc = vstrchr(id, '[') ? 0 : 1; 2562 2563 vp = global(id); 2564 afree(cp, ATEMP); 2565 2566 if ((vp->flag&RDONLY)) { 2567 warningf(true, "read-only: %s", vp->name); 2568 rv = 1; 2569 } else 2570 unset(vp, optc); 2571 } else 2572 /* unset function */ 2573 define(id, NULL); 2574 return (rv); 2575 } 2576 2577 static void 2578 p_time(struct shf *shf, bool posix, long tv_sec, int tv_usec, int width, 2579 const char *prefix, const char *suffix) 2580 { 2581 tv_usec /= 10000; 2582 if (posix) 2583 shf_fprintf(shf, "%s%*ld.%02d%s", prefix, width, 2584 tv_sec, tv_usec, suffix); 2585 else 2586 shf_fprintf(shf, "%s%*ldm%02d.%02ds%s", prefix, width, 2587 tv_sec / 60, (int)(tv_sec % 60), tv_usec, suffix); 2588 } 2589 2590 int 2591 c_times(const char **wp MKSH_A_UNUSED) 2592 { 2593 struct rusage usage; 2594 2595 getrusage(RUSAGE_SELF, &usage); 2596 p_time(shl_stdout, false, usage.ru_utime.tv_sec, 2597 usage.ru_utime.tv_usec, 0, null, " "); 2598 p_time(shl_stdout, false, usage.ru_stime.tv_sec, 2599 usage.ru_stime.tv_usec, 0, null, "\n"); 2600 2601 getrusage(RUSAGE_CHILDREN, &usage); 2602 p_time(shl_stdout, false, usage.ru_utime.tv_sec, 2603 usage.ru_utime.tv_usec, 0, null, " "); 2604 p_time(shl_stdout, false, usage.ru_stime.tv_sec, 2605 usage.ru_stime.tv_usec, 0, null, "\n"); 2606 2607 return (0); 2608 } 2609 2610 /* 2611 * time pipeline (really a statement, not a built-in command) 2612 */ 2613 int 2614 timex(struct op *t, int f, volatile int *xerrok) 2615 { 2616 #define TF_NOARGS BIT(0) 2617 #define TF_NOREAL BIT(1) /* don't report real time */ 2618 #define TF_POSIX BIT(2) /* report in POSIX format */ 2619 int rv = 0, tf = 0; 2620 struct rusage ru0, ru1, cru0, cru1; 2621 struct timeval usrtime, systime, tv0, tv1; 2622 2623 mksh_TIME(tv0); 2624 getrusage(RUSAGE_SELF, &ru0); 2625 getrusage(RUSAGE_CHILDREN, &cru0); 2626 if (t->left) { 2627 /* 2628 * Two ways of getting cpu usage of a command: just use t0 2629 * and t1 (which will get cpu usage from other jobs that 2630 * finish while we are executing t->left), or get the 2631 * cpu usage of t->left. AT&T ksh does the former, while 2632 * pdksh tries to do the later (the j_usrtime hack doesn't 2633 * really work as it only counts the last job). 2634 */ 2635 timerclear(&j_usrtime); 2636 timerclear(&j_systime); 2637 rv = execute(t->left, f | XTIME, xerrok); 2638 if (t->left->type == TCOM) 2639 tf |= t->left->str[0]; 2640 mksh_TIME(tv1); 2641 getrusage(RUSAGE_SELF, &ru1); 2642 getrusage(RUSAGE_CHILDREN, &cru1); 2643 } else 2644 tf = TF_NOARGS; 2645 2646 if (tf & TF_NOARGS) { 2647 /* ksh93 - report shell times (shell+kids) */ 2648 tf |= TF_NOREAL; 2649 timeradd(&ru0.ru_utime, &cru0.ru_utime, &usrtime); 2650 timeradd(&ru0.ru_stime, &cru0.ru_stime, &systime); 2651 } else { 2652 timersub(&ru1.ru_utime, &ru0.ru_utime, &usrtime); 2653 timeradd(&usrtime, &j_usrtime, &usrtime); 2654 timersub(&ru1.ru_stime, &ru0.ru_stime, &systime); 2655 timeradd(&systime, &j_systime, &systime); 2656 } 2657 2658 if (!(tf & TF_NOREAL)) { 2659 timersub(&tv1, &tv0, &tv1); 2660 if (tf & TF_POSIX) 2661 p_time(shl_out, true, tv1.tv_sec, tv1.tv_usec, 2662 5, "real ", "\n"); 2663 else 2664 p_time(shl_out, false, tv1.tv_sec, tv1.tv_usec, 2665 5, null, " real "); 2666 } 2667 if (tf & TF_POSIX) 2668 p_time(shl_out, true, usrtime.tv_sec, usrtime.tv_usec, 2669 5, "user ", "\n"); 2670 else 2671 p_time(shl_out, false, usrtime.tv_sec, usrtime.tv_usec, 2672 5, null, " user "); 2673 if (tf & TF_POSIX) 2674 p_time(shl_out, true, systime.tv_sec, systime.tv_usec, 2675 5, "sys ", "\n"); 2676 else 2677 p_time(shl_out, false, systime.tv_sec, systime.tv_usec, 2678 5, null, " system\n"); 2679 shf_flush(shl_out); 2680 2681 return (rv); 2682 } 2683 2684 void 2685 timex_hook(struct op *t, char **volatile *app) 2686 { 2687 char **wp = *app; 2688 int optc, i, j; 2689 Getopt opt; 2690 2691 ksh_getopt_reset(&opt, 0); 2692 /* start at the start */ 2693 opt.optind = 0; 2694 while ((optc = ksh_getopt((const char **)wp, &opt, ":p")) != -1) 2695 switch (optc) { 2696 case 'p': 2697 t->str[0] |= TF_POSIX; 2698 break; 2699 case '?': 2700 errorf("time: -%s %s", opt.optarg, 2701 "unknown option"); 2702 case ':': 2703 errorf("time: -%s %s", opt.optarg, 2704 "requires an argument"); 2705 } 2706 /* Copy command words down over options. */ 2707 if (opt.optind != 0) { 2708 for (i = 0; i < opt.optind; i++) 2709 afree(wp[i], ATEMP); 2710 for (i = 0, j = opt.optind; (wp[i] = wp[j]); i++, j++) 2711 ; 2712 } 2713 if (!wp[0]) 2714 t->str[0] |= TF_NOARGS; 2715 *app = wp; 2716 } 2717 2718 /* exec with no args - args case is taken care of in comexec() */ 2719 int 2720 c_exec(const char **wp MKSH_A_UNUSED) 2721 { 2722 int i; 2723 2724 /* make sure redirects stay in place */ 2725 if (e->savefd != NULL) { 2726 for (i = 0; i < NUFILE; i++) { 2727 if (e->savefd[i] > 0) 2728 close(e->savefd[i]); 2729 #ifndef MKSH_LEGACY_MODE 2730 /* 2731 * keep all file descriptors > 2 private for ksh, 2732 * but not for POSIX or legacy/kludge sh 2733 */ 2734 if (!Flag(FPOSIX) && !Flag(FSH) && i > 2 && 2735 e->savefd[i]) 2736 fcntl(i, F_SETFD, FD_CLOEXEC); 2737 #endif 2738 } 2739 e->savefd = NULL; 2740 } 2741 return (0); 2742 } 2743 2744 #if HAVE_MKNOD 2745 int 2746 c_mknod(const char **wp) 2747 { 2748 int argc, optc, rv = 0; 2749 bool ismkfifo = false; 2750 const char **argv; 2751 void *set = NULL; 2752 mode_t mode = 0, oldmode = 0; 2753 2754 while ((optc = ksh_getopt(wp, &builtin_opt, "m:")) != -1) { 2755 switch (optc) { 2756 case 'm': 2757 set = setmode(builtin_opt.optarg); 2758 if (set == NULL) { 2759 bi_errorf("invalid file mode"); 2760 return (1); 2761 } 2762 mode = getmode(set, (mode_t)(DEFFILEMODE)); 2763 free_ossetmode(set); 2764 break; 2765 default: 2766 goto c_mknod_usage; 2767 } 2768 } 2769 argv = &wp[builtin_opt.optind]; 2770 if (argv[0] == NULL) 2771 goto c_mknod_usage; 2772 for (argc = 0; argv[argc]; argc++) 2773 ; 2774 if (argc == 2 && argv[1][0] == 'p') 2775 ismkfifo = true; 2776 else if (argc != 4 || (argv[1][0] != 'b' && argv[1][0] != 'c')) 2777 goto c_mknod_usage; 2778 2779 if (set != NULL) 2780 oldmode = umask((mode_t)0); 2781 else 2782 mode = DEFFILEMODE; 2783 2784 mode |= (argv[1][0] == 'b') ? S_IFBLK : 2785 (argv[1][0] == 'c') ? S_IFCHR : 0; 2786 2787 if (!ismkfifo) { 2788 unsigned long majnum, minnum; 2789 dev_t dv; 2790 char *c; 2791 2792 majnum = strtoul(argv[2], &c, 0); 2793 if ((c == argv[2]) || (*c != '\0')) { 2794 bi_errorf("non-numeric %s %s '%s'", "device", "major", argv[2]); 2795 goto c_mknod_err; 2796 } 2797 minnum = strtoul(argv[3], &c, 0); 2798 if ((c == argv[3]) || (*c != '\0')) { 2799 bi_errorf("non-numeric %s %s '%s'", "device", "minor", argv[3]); 2800 goto c_mknod_err; 2801 } 2802 dv = makedev(majnum, minnum); 2803 if ((unsigned long)(major(dv)) != majnum) { 2804 bi_errorf("%s %s too large: %lu", "device", "major", majnum); 2805 goto c_mknod_err; 2806 } 2807 if ((unsigned long)(minor(dv)) != minnum) { 2808 bi_errorf("%s %s too large: %lu", "device", "minor", minnum); 2809 goto c_mknod_err; 2810 } 2811 if (mknod(argv[0], mode, dv)) 2812 goto c_mknod_failed; 2813 } else if (mkfifo(argv[0], mode)) { 2814 c_mknod_failed: 2815 bi_errorf("%s: %s", argv[0], cstrerror(errno)); 2816 c_mknod_err: 2817 rv = 1; 2818 } 2819 2820 if (set) 2821 umask(oldmode); 2822 return (rv); 2823 c_mknod_usage: 2824 bi_errorf("%s: %s", "usage", "mknod [-m mode] name b|c major minor"); 2825 bi_errorf("%s: %s", "usage", "mknod [-m mode] name p"); 2826 return (1); 2827 } 2828 #endif 2829 2830 /*- 2831 test(1) roughly accepts the following grammar: 2832 oexpr ::= aexpr | aexpr "-o" oexpr ; 2833 aexpr ::= nexpr | nexpr "-a" aexpr ; 2834 nexpr ::= primary | "!" nexpr ; 2835 primary ::= unary-operator operand 2836 | operand binary-operator operand 2837 | operand 2838 | "(" oexpr ")" 2839 ; 2840 2841 unary-operator ::= "-a"|"-r"|"-w"|"-x"|"-e"|"-f"|"-d"|"-c"|"-b"|"-p"| 2842 "-u"|"-g"|"-k"|"-s"|"-t"|"-z"|"-n"|"-o"|"-O"|"-G"| 2843 "-L"|"-h"|"-S"|"-H"; 2844 2845 binary-operator ::= "="|"=="|"!="|"-eq"|"-ne"|"-ge"|"-gt"|"-le"|"-lt"| 2846 "-nt"|"-ot"|"-ef"| 2847 "<"|">" # rules used for [[ ... ]] expressions 2848 ; 2849 operand ::= <anything> 2850 */ 2851 2852 /* POSIX says > 1 for errors */ 2853 #define T_ERR_EXIT 2 2854 2855 int 2856 c_test(const char **wp) 2857 { 2858 int argc, rv, invert = 0; 2859 Test_env te; 2860 Test_op op; 2861 const char *lhs, **swp; 2862 2863 te.flags = 0; 2864 te.isa = ptest_isa; 2865 te.getopnd = ptest_getopnd; 2866 te.eval = test_eval; 2867 te.error = ptest_error; 2868 2869 for (argc = 0; wp[argc]; argc++) 2870 ; 2871 2872 if (strcmp(wp[0], "[") == 0) { 2873 if (strcmp(wp[--argc], "]") != 0) { 2874 bi_errorf("missing ]"); 2875 return (T_ERR_EXIT); 2876 } 2877 } 2878 2879 te.pos.wp = wp + 1; 2880 te.wp_end = wp + argc; 2881 2882 /* 2883 * Attempt to conform to POSIX special cases. This is pretty 2884 * dumb code straight-forward from the 2008 spec, but unlike 2885 * the old pdksh code doesn't live from so many assumptions. 2886 * It does, though, inline some calls to '(*te.funcname)()'. 2887 */ 2888 switch (argc - 1) { 2889 case 0: 2890 return (1); 2891 case 1: 2892 ptest_one: 2893 op = TO_STNZE; 2894 goto ptest_unary; 2895 case 2: 2896 ptest_two: 2897 if (ptest_isa(&te, TM_NOT)) { 2898 ++invert; 2899 goto ptest_one; 2900 } 2901 if ((op = ptest_isa(&te, TM_UNOP))) { 2902 ptest_unary: 2903 rv = test_eval(&te, op, *te.pos.wp++, NULL, true); 2904 ptest_out: 2905 if (te.flags & TEF_ERROR) 2906 return (T_ERR_EXIT); 2907 return ((invert & 1) ? rv : !rv); 2908 } 2909 /* let the parser deal with anything else */ 2910 break; 2911 case 3: 2912 ptest_three: 2913 swp = te.pos.wp; 2914 /* use inside knowledge of ptest_getopnd inlined below */ 2915 lhs = *te.pos.wp++; 2916 if ((op = ptest_isa(&te, TM_BINOP))) { 2917 /* test lhs op rhs */ 2918 rv = test_eval(&te, op, lhs, *te.pos.wp++, true); 2919 goto ptest_out; 2920 } 2921 /* back up to lhs */ 2922 te.pos.wp = swp; 2923 if (ptest_isa(&te, TM_NOT)) { 2924 ++invert; 2925 goto ptest_two; 2926 } 2927 if (ptest_isa(&te, TM_OPAREN)) { 2928 swp = te.pos.wp; 2929 /* skip operand, without evaluation */ 2930 te.pos.wp++; 2931 /* check for closing parenthesis */ 2932 op = ptest_isa(&te, TM_CPAREN); 2933 /* back up to operand */ 2934 te.pos.wp = swp; 2935 /* if there was a closing paren, handle it */ 2936 if (op) 2937 goto ptest_one; 2938 /* backing up is done before calling the parser */ 2939 } 2940 /* let the parser deal with it */ 2941 break; 2942 case 4: 2943 if (ptest_isa(&te, TM_NOT)) { 2944 ++invert; 2945 goto ptest_three; 2946 } 2947 if (ptest_isa(&te, TM_OPAREN)) { 2948 swp = te.pos.wp; 2949 /* skip two operands, without evaluation */ 2950 te.pos.wp++; 2951 te.pos.wp++; 2952 /* check for closing parenthesis */ 2953 op = ptest_isa(&te, TM_CPAREN); 2954 /* back up to first operand */ 2955 te.pos.wp = swp; 2956 /* if there was a closing paren, handle it */ 2957 if (op) 2958 goto ptest_two; 2959 /* backing up is done before calling the parser */ 2960 } 2961 /* defer this to the parser */ 2962 break; 2963 } 2964 2965 /* "The results are unspecified." */ 2966 te.pos.wp = wp + 1; 2967 return (test_parse(&te)); 2968 } 2969 2970 /* 2971 * Generic test routines. 2972 */ 2973 2974 Test_op 2975 test_isop(Test_meta meta, const char *s) 2976 { 2977 char sc1; 2978 const struct t_op *tbl; 2979 2980 tbl = meta == TM_UNOP ? u_ops : b_ops; 2981 if (*s) { 2982 sc1 = s[1]; 2983 for (; tbl->op_text[0]; tbl++) 2984 if (sc1 == tbl->op_text[1] && !strcmp(s, tbl->op_text)) 2985 return (tbl->op_num); 2986 } 2987 return (TO_NONOP); 2988 } 2989 2990 int 2991 test_eval(Test_env *te, Test_op op, const char *opnd1, const char *opnd2, 2992 bool do_eval) 2993 { 2994 int i, s; 2995 size_t k; 2996 struct stat b1, b2; 2997 mksh_ari_t v1, v2; 2998 2999 if (!do_eval) 3000 return (0); 3001 3002 #ifdef DEBUG 3003 switch (op) { 3004 /* Binary operators */ 3005 case TO_STEQL: 3006 case TO_STNEQ: 3007 case TO_STLT: 3008 case TO_STGT: 3009 case TO_INTEQ: 3010 case TO_INTNE: 3011 case TO_INTGT: 3012 case TO_INTGE: 3013 case TO_INTLT: 3014 case TO_INTLE: 3015 case TO_FILEQ: 3016 case TO_FILNT: 3017 case TO_FILOT: 3018 /* consistency check, but does not happen in practice */ 3019 if (!opnd2) { 3020 te->flags |= TEF_ERROR; 3021 return (1); 3022 } 3023 break; 3024 default: 3025 /* for completeness of switch */ 3026 break; 3027 } 3028 #endif 3029 3030 switch (op) { 3031 3032 /* 3033 * Unary Operators 3034 */ 3035 3036 /* -n */ 3037 case TO_STNZE: 3038 return (*opnd1 != '\0'); 3039 3040 /* -z */ 3041 case TO_STZER: 3042 return (*opnd1 == '\0'); 3043 3044 /* -o */ 3045 case TO_OPTION: 3046 if ((i = *opnd1) == '!' || i == '?') 3047 opnd1++; 3048 if ((k = option(opnd1)) == (size_t)-1) 3049 return (0); 3050 return (i == '?' ? 1 : i == '!' ? !Flag(k) : Flag(k)); 3051 3052 /* -r */ 3053 case TO_FILRD: 3054 /* LINTED use of access */ 3055 return (access(opnd1, R_OK) == 0); 3056 3057 /* -w */ 3058 case TO_FILWR: 3059 /* LINTED use of access */ 3060 return (access(opnd1, W_OK) == 0); 3061 3062 /* -x */ 3063 case TO_FILEX: 3064 return (ksh_access(opnd1, X_OK) == 0); 3065 3066 /* -a */ 3067 case TO_FILAXST: 3068 /* -e */ 3069 case TO_FILEXST: 3070 return (stat(opnd1, &b1) == 0); 3071 3072 /* -r */ 3073 case TO_FILREG: 3074 return (stat(opnd1, &b1) == 0 && S_ISREG(b1.st_mode)); 3075 3076 /* -d */ 3077 case TO_FILID: 3078 return (stat(opnd1, &b1) == 0 && S_ISDIR(b1.st_mode)); 3079 3080 /* -c */ 3081 case TO_FILCDEV: 3082 return (stat(opnd1, &b1) == 0 && S_ISCHR(b1.st_mode)); 3083 3084 /* -b */ 3085 case TO_FILBDEV: 3086 return (stat(opnd1, &b1) == 0 && S_ISBLK(b1.st_mode)); 3087 3088 /* -p */ 3089 case TO_FILFIFO: 3090 return (stat(opnd1, &b1) == 0 && S_ISFIFO(b1.st_mode)); 3091 3092 /* -h or -L */ 3093 case TO_FILSYM: 3094 #ifdef MKSH__NO_SYMLINK 3095 return (0); 3096 #else 3097 return (lstat(opnd1, &b1) == 0 && S_ISLNK(b1.st_mode)); 3098 #endif 3099 3100 /* -S */ 3101 case TO_FILSOCK: 3102 return (stat(opnd1, &b1) == 0 && S_ISSOCK(b1.st_mode)); 3103 3104 /* -H => HP context dependent files (directories) */ 3105 case TO_FILCDF: 3106 #ifdef S_ISCDF 3107 { 3108 char *nv; 3109 3110 /* 3111 * Append a + to filename and check to see if result is 3112 * a setuid directory. CDF stuff in general is hookey, 3113 * since it breaks for, e.g., the following sequence: 3114 * echo hi >foo+; mkdir foo; echo bye >foo/default; 3115 * chmod u+s foo (foo+ refers to the file with hi in it, 3116 * there is no way to get at the file with bye in it; 3117 * please correct me if I'm wrong about this). 3118 */ 3119 3120 nv = shf_smprintf("%s+", opnd1); 3121 i = (stat(nv, &b1) == 0 && S_ISCDF(b1.st_mode)); 3122 afree(nv, ATEMP); 3123 return (i); 3124 } 3125 #else 3126 return (0); 3127 #endif 3128 3129 /* -u */ 3130 case TO_FILSETU: 3131 return (stat(opnd1, &b1) == 0 && 3132 (b1.st_mode & S_ISUID) == S_ISUID); 3133 3134 /* -g */ 3135 case TO_FILSETG: 3136 return (stat(opnd1, &b1) == 0 && 3137 (b1.st_mode & S_ISGID) == S_ISGID); 3138 3139 /* -k */ 3140 case TO_FILSTCK: 3141 #ifdef S_ISVTX 3142 return (stat(opnd1, &b1) == 0 && 3143 (b1.st_mode & S_ISVTX) == S_ISVTX); 3144 #else 3145 return (0); 3146 #endif 3147 3148 /* -s */ 3149 case TO_FILGZ: 3150 return (stat(opnd1, &b1) == 0 && (off_t)b1.st_size > (off_t)0); 3151 3152 /* -t */ 3153 case TO_FILTT: 3154 if (opnd1 && !bi_getn(opnd1, &i)) { 3155 te->flags |= TEF_ERROR; 3156 i = 0; 3157 } else 3158 i = isatty(opnd1 ? i : 0); 3159 return (i); 3160 3161 /* -O */ 3162 case TO_FILUID: 3163 return (stat(opnd1, &b1) == 0 && (uid_t)b1.st_uid == ksheuid); 3164 3165 /* -G */ 3166 case TO_FILGID: 3167 return (stat(opnd1, &b1) == 0 && (gid_t)b1.st_gid == getegid()); 3168 3169 /* 3170 * Binary Operators 3171 */ 3172 3173 /* = */ 3174 case TO_STEQL: 3175 if (te->flags & TEF_DBRACKET) 3176 return (gmatchx(opnd1, opnd2, false)); 3177 return (strcmp(opnd1, opnd2) == 0); 3178 3179 /* != */ 3180 case TO_STNEQ: 3181 if (te->flags & TEF_DBRACKET) 3182 return (!gmatchx(opnd1, opnd2, false)); 3183 return (strcmp(opnd1, opnd2) != 0); 3184 3185 /* < */ 3186 case TO_STLT: 3187 return (strcmp(opnd1, opnd2) < 0); 3188 3189 /* > */ 3190 case TO_STGT: 3191 return (strcmp(opnd1, opnd2) > 0); 3192 3193 /* -eq */ 3194 case TO_INTEQ: 3195 /* -ne */ 3196 case TO_INTNE: 3197 /* -ge */ 3198 case TO_INTGE: 3199 /* -gt */ 3200 case TO_INTGT: 3201 /* -le */ 3202 case TO_INTLE: 3203 /* -lt */ 3204 case TO_INTLT: 3205 if (!evaluate(opnd1, &v1, KSH_RETURN_ERROR, false) || 3206 !evaluate(opnd2, &v2, KSH_RETURN_ERROR, false)) { 3207 /* error already printed.. */ 3208 te->flags |= TEF_ERROR; 3209 return (1); 3210 } 3211 switch (op) { 3212 case TO_INTEQ: 3213 return (v1 == v2); 3214 case TO_INTNE: 3215 return (v1 != v2); 3216 case TO_INTGE: 3217 return (v1 >= v2); 3218 case TO_INTGT: 3219 return (v1 > v2); 3220 case TO_INTLE: 3221 return (v1 <= v2); 3222 case TO_INTLT: 3223 return (v1 < v2); 3224 default: 3225 /* NOTREACHED */ 3226 break; 3227 } 3228 /* NOTREACHED */ 3229 3230 /* -nt */ 3231 case TO_FILNT: 3232 /* 3233 * ksh88/ksh93 succeed if file2 can't be stated 3234 * (subtly different from 'does not exist'). 3235 */ 3236 return (stat(opnd1, &b1) == 0 && 3237 (((s = stat(opnd2, &b2)) == 0 && 3238 b1.st_mtime > b2.st_mtime) || s < 0)); 3239 3240 /* -ot */ 3241 case TO_FILOT: 3242 /* 3243 * ksh88/ksh93 succeed if file1 can't be stated 3244 * (subtly different from 'does not exist'). 3245 */ 3246 return (stat(opnd2, &b2) == 0 && 3247 (((s = stat(opnd1, &b1)) == 0 && 3248 b1.st_mtime < b2.st_mtime) || s < 0)); 3249 3250 /* -ef */ 3251 case TO_FILEQ: 3252 return (stat (opnd1, &b1) == 0 && stat (opnd2, &b2) == 0 && 3253 b1.st_dev == b2.st_dev && b1.st_ino == b2.st_ino); 3254 3255 /* all other cases */ 3256 case TO_NONOP: 3257 case TO_NONNULL: 3258 /* throw the error */ 3259 break; 3260 } 3261 (*te->error)(te, 0, "internal error: unknown op"); 3262 return (1); 3263 } 3264 3265 int 3266 test_parse(Test_env *te) 3267 { 3268 int rv; 3269 3270 rv = test_oexpr(te, 1); 3271 3272 if (!(te->flags & TEF_ERROR) && !(*te->isa)(te, TM_END)) 3273 (*te->error)(te, 0, "unexpected operator/operand"); 3274 3275 return ((te->flags & TEF_ERROR) ? T_ERR_EXIT : !rv); 3276 } 3277 3278 static int 3279 test_oexpr(Test_env *te, bool do_eval) 3280 { 3281 int rv; 3282 3283 if ((rv = test_aexpr(te, do_eval))) 3284 do_eval = false; 3285 if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_OR)) 3286 return (test_oexpr(te, do_eval) || rv); 3287 return (rv); 3288 } 3289 3290 static int 3291 test_aexpr(Test_env *te, bool do_eval) 3292 { 3293 int rv; 3294 3295 if (!(rv = test_nexpr(te, do_eval))) 3296 do_eval = false; 3297 if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_AND)) 3298 return (test_aexpr(te, do_eval) && rv); 3299 return (rv); 3300 } 3301 3302 static int 3303 test_nexpr(Test_env *te, bool do_eval) 3304 { 3305 if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_NOT)) 3306 return (!test_nexpr(te, do_eval)); 3307 return (test_primary(te, do_eval)); 3308 } 3309 3310 static int 3311 test_primary(Test_env *te, bool do_eval) 3312 { 3313 const char *opnd1, *opnd2; 3314 int rv; 3315 Test_op op; 3316 3317 if (te->flags & TEF_ERROR) 3318 return (0); 3319 if ((*te->isa)(te, TM_OPAREN)) { 3320 rv = test_oexpr(te, do_eval); 3321 if (te->flags & TEF_ERROR) 3322 return (0); 3323 if (!(*te->isa)(te, TM_CPAREN)) { 3324 (*te->error)(te, 0, "missing )"); 3325 return (0); 3326 } 3327 return (rv); 3328 } 3329 /* 3330 * Binary should have precedence over unary in this case 3331 * so that something like test \( -f = -f \) is accepted 3332 */ 3333 if ((te->flags & TEF_DBRACKET) || (&te->pos.wp[1] < te->wp_end && 3334 !test_isop(TM_BINOP, te->pos.wp[1]))) { 3335 if ((op = (*te->isa)(te, TM_UNOP))) { 3336 /* unary expression */ 3337 opnd1 = (*te->getopnd)(te, op, do_eval); 3338 if (!opnd1) { 3339 (*te->error)(te, -1, "missing argument"); 3340 return (0); 3341 } 3342 3343 return ((*te->eval)(te, op, opnd1, NULL, do_eval)); 3344 } 3345 } 3346 opnd1 = (*te->getopnd)(te, TO_NONOP, do_eval); 3347 if (!opnd1) { 3348 (*te->error)(te, 0, "expression expected"); 3349 return (0); 3350 } 3351 if ((op = (*te->isa)(te, TM_BINOP))) { 3352 /* binary expression */ 3353 opnd2 = (*te->getopnd)(te, op, do_eval); 3354 if (!opnd2) { 3355 (*te->error)(te, -1, "missing second argument"); 3356 return (0); 3357 } 3358 3359 return ((*te->eval)(te, op, opnd1, opnd2, do_eval)); 3360 } 3361 return ((*te->eval)(te, TO_STNZE, opnd1, NULL, do_eval)); 3362 } 3363 3364 /* 3365 * Plain test (test and [ .. ]) specific routines. 3366 */ 3367 3368 /* 3369 * Test if the current token is a whatever. Accepts the current token if 3370 * it is. Returns 0 if it is not, non-zero if it is (in the case of 3371 * TM_UNOP and TM_BINOP, the returned value is a Test_op). 3372 */ 3373 static Test_op 3374 ptest_isa(Test_env *te, Test_meta meta) 3375 { 3376 /* Order important - indexed by Test_meta values */ 3377 static const char * const tokens[] = { 3378 "-o", "-a", "!", "(", ")" 3379 }; 3380 Test_op rv; 3381 3382 if (te->pos.wp >= te->wp_end) 3383 return (meta == TM_END ? TO_NONNULL : TO_NONOP); 3384 3385 if (meta == TM_UNOP || meta == TM_BINOP) 3386 rv = test_isop(meta, *te->pos.wp); 3387 else if (meta == TM_END) 3388 rv = TO_NONOP; 3389 else 3390 rv = !strcmp(*te->pos.wp, tokens[(int)meta]) ? 3391 TO_NONNULL : TO_NONOP; 3392 3393 /* Accept the token? */ 3394 if (rv != TO_NONOP) 3395 te->pos.wp++; 3396 3397 return (rv); 3398 } 3399 3400 static const char * 3401 ptest_getopnd(Test_env *te, Test_op op, bool do_eval MKSH_A_UNUSED) 3402 { 3403 if (te->pos.wp >= te->wp_end) 3404 return (op == TO_FILTT ? "1" : NULL); 3405 return (*te->pos.wp++); 3406 } 3407 3408 static void 3409 ptest_error(Test_env *te, int ofs, const char *msg) 3410 { 3411 const char *op; 3412 3413 te->flags |= TEF_ERROR; 3414 if ((op = te->pos.wp + ofs >= te->wp_end ? NULL : te->pos.wp[ofs])) 3415 bi_errorf("%s: %s", op, msg); 3416 else 3417 bi_errorf("%s", msg); 3418 } 3419 3420 #ifndef MKSH_NO_LIMITS 3421 #define SOFT 0x1 3422 #define HARD 0x2 3423 3424 /* Magic to divine the 'm' and 'v' limits */ 3425 3426 #ifdef RLIMIT_AS 3427 #if !defined(RLIMIT_VMEM) || (RLIMIT_VMEM == RLIMIT_AS) || \ 3428 !defined(RLIMIT_RSS) || (RLIMIT_VMEM == RLIMIT_RSS) 3429 #define ULIMIT_V_IS_AS 3430 #elif defined(RLIMIT_VMEM) 3431 #if !defined(RLIMIT_RSS) || (RLIMIT_RSS == RLIMIT_AS) 3432 #define ULIMIT_V_IS_AS 3433 #else 3434 #define ULIMIT_V_IS_VMEM 3435 #endif 3436 #endif 3437 #endif 3438 3439 #ifdef RLIMIT_RSS 3440 #ifdef ULIMIT_V_IS_VMEM 3441 #define ULIMIT_M_IS_RSS 3442 #elif defined(RLIMIT_VMEM) && (RLIMIT_VMEM == RLIMIT_RSS) 3443 #define ULIMIT_M_IS_VMEM 3444 #else 3445 #define ULIMIT_M_IS_RSS 3446 #endif 3447 #if defined(ULIMIT_M_IS_RSS) && defined(RLIMIT_AS) && (RLIMIT_RSS == RLIMIT_AS) 3448 #undef ULIMIT_M_IS_RSS 3449 #endif 3450 #endif 3451 3452 #if !defined(RLIMIT_AS) && !defined(ULIMIT_M_IS_VMEM) && defined(RLIMIT_VMEM) 3453 #define ULIMIT_V_IS_VMEM 3454 #endif 3455 3456 #if !defined(ULIMIT_V_IS_VMEM) && defined(RLIMIT_VMEM) && \ 3457 (!defined(RLIMIT_RSS) || (defined(RLIMIT_AS) && (RLIMIT_RSS == RLIMIT_AS))) 3458 #define ULIMIT_M_IS_VMEM 3459 #endif 3460 3461 #if defined(ULIMIT_M_IS_VMEM) && defined(RLIMIT_AS) && \ 3462 (RLIMIT_VMEM == RLIMIT_AS) 3463 #undef ULIMIT_M_IS_VMEM 3464 #endif 3465 3466 #if defined(ULIMIT_M_IS_RSS) && defined(ULIMIT_M_IS_VMEM) 3467 # error nonsensical m ulimit 3468 #endif 3469 3470 #if defined(ULIMIT_V_IS_VMEM) && defined(ULIMIT_V_IS_AS) 3471 # error nonsensical v ulimit 3472 #endif 3473 3474 struct limits { 3475 /* limit resource */ 3476 int resource; 3477 /* multiply by to get rlim_{cur,max} values */ 3478 unsigned int factor; 3479 /* getopts char */ 3480 char optchar; 3481 /* limit name */ 3482 char name[1]; 3483 }; 3484 3485 #define RLIMITS_DEFNS 3486 #define FN(lname,lid,lfac,lopt) \ 3487 static const struct { \ 3488 int resource; \ 3489 unsigned int factor; \ 3490 char optchar; \ 3491 char name[sizeof(lname)]; \ 3492 } rlimits_ ## lid = { \ 3493 lid, lfac, lopt, lname \ 3494 }; 3495 #include "rlimits.gen" 3496 3497 static void print_ulimit(const struct limits *, int); 3498 static int set_ulimit(const struct limits *, const char *, int); 3499 3500 static const struct limits * const rlimits[] = { 3501 #define RLIMITS_ITEMS 3502 #include "rlimits.gen" 3503 }; 3504 3505 static const char rlimits_opts[] = 3506 #define RLIMITS_OPTCS 3507 #include "rlimits.gen" 3508 ; 3509 3510 int 3511 c_ulimit(const char **wp) 3512 { 3513 size_t i = 0; 3514 int how = SOFT | HARD, optc, what = 'f'; 3515 bool all = false; 3516 3517 while ((optc = ksh_getopt(wp, &builtin_opt, rlimits_opts)) != -1) 3518 switch (optc) { 3519 case 'H': 3520 how = HARD; 3521 break; 3522 case 'S': 3523 how = SOFT; 3524 break; 3525 case 'a': 3526 all = true; 3527 break; 3528 case '?': 3529 bi_errorf("usage: ulimit [-%s] [value]", rlimits_opts); 3530 return (1); 3531 default: 3532 what = optc; 3533 } 3534 3535 while (i < NELEM(rlimits)) { 3536 if (rlimits[i]->optchar == what) 3537 goto found; 3538 ++i; 3539 } 3540 internal_warningf("ulimit: %c", what); 3541 return (1); 3542 found: 3543 if (wp[builtin_opt.optind]) { 3544 if (all || wp[builtin_opt.optind + 1]) { 3545 bi_errorf("too many arguments"); 3546 return (1); 3547 } 3548 return (set_ulimit(rlimits[i], wp[builtin_opt.optind], how)); 3549 } 3550 if (!all) 3551 print_ulimit(rlimits[i], how); 3552 else for (i = 0; i < NELEM(rlimits); ++i) { 3553 shprintf("%-20s ", rlimits[i]->name); 3554 print_ulimit(rlimits[i], how); 3555 } 3556 return (0); 3557 } 3558 3559 static int 3560 set_ulimit(const struct limits *l, const char *v, int how) 3561 { 3562 rlim_t val = (rlim_t)0; 3563 struct rlimit limit; 3564 3565 if (strcmp(v, "unlimited") == 0) 3566 val = (rlim_t)RLIM_INFINITY; 3567 else { 3568 mksh_uari_t rval; 3569 3570 if (!evaluate(v, (mksh_ari_t *)&rval, KSH_RETURN_ERROR, false)) 3571 return (1); 3572 /* 3573 * Avoid problems caused by typos that evaluate misses due 3574 * to evaluating unset parameters to 0... 3575 * If this causes problems, will have to add parameter to 3576 * evaluate() to control if unset params are 0 or an error. 3577 */ 3578 if (!rval && !ksh_isdigit(v[0])) { 3579 bi_errorf("invalid %s limit: %s", l->name, v); 3580 return (1); 3581 } 3582 val = (rlim_t)((rlim_t)rval * l->factor); 3583 } 3584 3585 if (getrlimit(l->resource, &limit) < 0) { 3586 #ifndef MKSH_SMALL 3587 bi_errorf("limit %s could not be read, contact the mksh developers: %s", 3588 l->name, cstrerror(errno)); 3589 #endif 3590 /* some can't be read */ 3591 limit.rlim_cur = RLIM_INFINITY; 3592 limit.rlim_max = RLIM_INFINITY; 3593 } 3594 if (how & SOFT) 3595 limit.rlim_cur = val; 3596 if (how & HARD) 3597 limit.rlim_max = val; 3598 if (!setrlimit(l->resource, &limit)) 3599 return (0); 3600 if (errno == EPERM) 3601 bi_errorf("%s exceeds allowable %s limit", v, l->name); 3602 else 3603 bi_errorf("bad %s limit: %s", l->name, cstrerror(errno)); 3604 return (1); 3605 } 3606 3607 static void 3608 print_ulimit(const struct limits *l, int how) 3609 { 3610 rlim_t val = (rlim_t)0; 3611 struct rlimit limit; 3612 3613 if (getrlimit(l->resource, &limit)) { 3614 shf_puts("unknown\n", shl_stdout); 3615 return; 3616 } 3617 if (how & SOFT) 3618 val = limit.rlim_cur; 3619 else if (how & HARD) 3620 val = limit.rlim_max; 3621 if (val == (rlim_t)RLIM_INFINITY) 3622 shf_puts("unlimited\n", shl_stdout); 3623 else 3624 shprintf("%lu\n", (unsigned long)(val / l->factor)); 3625 } 3626 #endif 3627 3628 int 3629 c_rename(const char **wp) 3630 { 3631 int rv = 1; 3632 3633 /* skip argv[0] */ 3634 ++wp; 3635 if (wp[0] && !strcmp(wp[0], "--")) 3636 /* skip "--" (options separator) */ 3637 ++wp; 3638 3639 /* check for exactly two arguments */ 3640 if (wp[0] == NULL /* first argument */ || 3641 wp[1] == NULL /* second argument */ || 3642 wp[2] != NULL /* no further args please */) 3643 bi_errorf(Tsynerr); 3644 else if ((rv = rename(wp[0], wp[1])) != 0) { 3645 rv = errno; 3646 bi_errorf("%s: %s", "failed", cstrerror(rv)); 3647 } 3648 3649 return (rv); 3650 } 3651 3652 int 3653 c_realpath(const char **wp) 3654 { 3655 int rv = 1; 3656 char *buf; 3657 3658 /* skip argv[0] */ 3659 ++wp; 3660 if (wp[0] && !strcmp(wp[0], "--")) 3661 /* skip "--" (options separator) */ 3662 ++wp; 3663 3664 /* check for exactly one argument */ 3665 if (wp[0] == NULL || wp[1] != NULL) 3666 bi_errorf(Tsynerr); 3667 else if ((buf = do_realpath(wp[0])) == NULL) { 3668 rv = errno; 3669 bi_errorf("%s: %s", wp[0], cstrerror(rv)); 3670 if ((unsigned int)rv > 255) 3671 rv = 255; 3672 } else { 3673 shprintf("%s\n", buf); 3674 afree(buf, ATEMP); 3675 rv = 0; 3676 } 3677 3678 return (rv); 3679 } 3680 3681 int 3682 c_cat(const char **wp) 3683 { 3684 int fd = STDIN_FILENO, rv; 3685 ssize_t n, w; 3686 const char *fn = "<stdin>"; 3687 char *buf, *cp; 3688 int opipe = 0; 3689 #define MKSH_CAT_BUFSIZ 4096 3690 3691 /* parse options: POSIX demands we support "-u" as no-op */ 3692 while ((rv = ksh_getopt(wp, &builtin_opt, "u")) != -1) { 3693 switch (rv) { 3694 case 'u': 3695 /* we already operate unbuffered */ 3696 break; 3697 default: 3698 bi_errorf(Tsynerr); 3699 return (1); 3700 } 3701 } 3702 wp += builtin_opt.optind; 3703 rv = 0; 3704 3705 if ((buf = malloc_osfunc(MKSH_CAT_BUFSIZ)) == NULL) { 3706 bi_errorf(Toomem, (size_t)MKSH_CAT_BUFSIZ); 3707 return (1); 3708 } 3709 3710 /* catch SIGPIPE */ 3711 opipe = block_pipe(); 3712 3713 do { 3714 if (*wp) { 3715 fn = *wp++; 3716 if (ksh_isdash(fn)) 3717 fd = STDIN_FILENO; 3718 else if ((fd = binopen2(fn, O_RDONLY)) < 0) { 3719 bi_errorf("%s: %s", fn, cstrerror(errno)); 3720 rv = 1; 3721 continue; 3722 } 3723 } 3724 while (/* CONSTCOND */ 1) { 3725 if ((n = blocking_read(fd, (cp = buf), 3726 MKSH_CAT_BUFSIZ)) == -1) { 3727 if (errno == EINTR) { 3728 restore_pipe(opipe); 3729 /* give the user a chance to ^C out */ 3730 intrcheck(); 3731 /* interrupted, try again */ 3732 opipe = block_pipe(); 3733 continue; 3734 } 3735 /* an error occured during reading */ 3736 bi_errorf("%s: %s", fn, cstrerror(errno)); 3737 rv = 1; 3738 break; 3739 } else if (n == 0) 3740 /* end of file reached */ 3741 break; 3742 while (n) { 3743 if ((w = write(STDOUT_FILENO, cp, n)) != -1) { 3744 n -= w; 3745 cp += w; 3746 continue; 3747 } 3748 if (errno == EINTR) { 3749 restore_pipe(opipe); 3750 /* give the user a chance to ^C out */ 3751 intrcheck(); 3752 /* interrupted, try again */ 3753 opipe = block_pipe(); 3754 continue; 3755 } 3756 if (errno == EPIPE) { 3757 /* fake receiving signel */ 3758 rv = ksh_sigmask(SIGPIPE); 3759 } else { 3760 /* an error occured during writing */ 3761 bi_errorf("%s: %s", "<stdout>", 3762 cstrerror(errno)); 3763 rv = 1; 3764 } 3765 if (fd != STDIN_FILENO) 3766 close(fd); 3767 goto out; 3768 } 3769 } 3770 if (fd != STDIN_FILENO) 3771 close(fd); 3772 } while (*wp); 3773 3774 out: 3775 restore_pipe(opipe); 3776 free_osfunc(buf); 3777 return (rv); 3778 } 3779 3780 #if HAVE_SELECT 3781 int 3782 c_sleep(const char **wp) 3783 { 3784 struct timeval tv; 3785 int rv = 1; 3786 3787 /* skip argv[0] */ 3788 ++wp; 3789 if (wp[0] && !strcmp(wp[0], "--")) 3790 /* skip "--" (options separator) */ 3791 ++wp; 3792 3793 if (!wp[0] || wp[1]) 3794 bi_errorf(Tsynerr); 3795 else if (parse_usec(wp[0], &tv)) 3796 bi_errorf("%s: %s '%s'", Tsynerr, cstrerror(errno), wp[0]); 3797 else { 3798 #ifndef MKSH_NOPROSPECTOFWORK 3799 sigset_t omask, bmask; 3800 3801 /* block a number of signals from interrupting us, though */ 3802 (void)sigemptyset(&bmask); 3803 (void)sigaddset(&bmask, SIGPIPE); 3804 (void)sigaddset(&bmask, SIGCHLD); 3805 #ifdef SIGWINCH 3806 (void)sigaddset(&bmask, SIGWINCH); 3807 #endif 3808 #ifdef SIGINFO 3809 (void)sigaddset(&bmask, SIGINFO); 3810 #endif 3811 #ifdef SIGUSR1 3812 (void)sigaddset(&bmask, SIGUSR1); 3813 #endif 3814 #ifdef SIGUSR2 3815 (void)sigaddset(&bmask, SIGUSR2); 3816 #endif 3817 sigprocmask(SIG_BLOCK, &bmask, &omask); 3818 #endif 3819 if (select(1, NULL, NULL, NULL, &tv) == 0 || errno == EINTR) 3820 /* 3821 * strictly speaking only for SIGALRM, but the 3822 * execution may be interrupted by other signals 3823 */ 3824 rv = 0; 3825 else 3826 bi_errorf("%s: %s", Tselect, cstrerror(errno)); 3827 #ifndef MKSH_NOPROSPECTOFWORK 3828 /* this will re-schedule signal delivery */ 3829 sigprocmask(SIG_SETMASK, &omask, NULL); 3830 #endif 3831 } 3832 return (rv); 3833 } 3834 #endif 3835 3836 #if !defined(MKSH_UNEMPLOYED) && HAVE_GETSID 3837 static int 3838 c_suspend(const char **wp) 3839 { 3840 if (wp[1] != NULL) { 3841 bi_errorf("too many arguments"); 3842 return (1); 3843 } 3844 if (Flag(FLOGIN)) { 3845 /* Can't suspend an orphaned process group. */ 3846 if (getpgid(kshppid) == getpgid(0) || 3847 getsid(kshppid) != getsid(0)) { 3848 bi_errorf("can't suspend a login shell"); 3849 return (1); 3850 } 3851 } 3852 j_suspend(); 3853 return (0); 3854 } 3855 #endif 3856
