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