![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sh.func.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / bin / csh|
Return to sh.func.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / bin / csh |
1.1 ! root 1: /* ! 2: * Copyright (c) 1980 Regents of the University of California. ! 3: * All rights reserved. The Berkeley Software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: */ ! 6: ! 7: #ifndef lint ! 8: static char *sccsid = "@(#)sh.func.c 5.5 (Berkeley) 5/19/88"; ! 9: #endif ! 10: ! 11: #include "sh.h" ! 12: #include <sys/ioctl.h> ! 13: ! 14: /* ! 15: * C shell ! 16: */ ! 17: ! 18: struct biltins * ! 19: isbfunc(t) ! 20: struct command *t; ! 21: { ! 22: register char *cp = t->t_dcom[0]; ! 23: register struct biltins *bp, *bp1, *bp2; ! 24: int dolabel(), dofg1(), dobg1(); ! 25: static struct biltins label = { "", dolabel, 0, 0 }; ! 26: static struct biltins foregnd = { "%job", dofg1, 0, 0 }; ! 27: static struct biltins backgnd = { "%job &", dobg1, 0, 0 }; ! 28: ! 29: if (lastchr(cp) == ':') { ! 30: label.bname = cp; ! 31: return (&label); ! 32: } ! 33: if (*cp == '%') { ! 34: if (t->t_dflg & FAND) { ! 35: t->t_dflg &= ~FAND; ! 36: backgnd.bname = cp; ! 37: return (&backgnd); ! 38: } ! 39: foregnd.bname = cp; ! 40: return (&foregnd); ! 41: } ! 42: /* ! 43: * Binary search ! 44: * Bp1 is the beginning of the current search range. ! 45: * Bp2 is one past the end. ! 46: */ ! 47: for (bp1 = bfunc, bp2 = bfunc + nbfunc; bp1 < bp2;) { ! 48: register i; ! 49: ! 50: bp = bp1 + (bp2 - bp1 >> 1); ! 51: if ((i = *cp - *bp->bname) == 0 && ! 52: (i = strcmp(cp, bp->bname)) == 0) ! 53: return bp; ! 54: if (i < 0) ! 55: bp2 = bp; ! 56: else ! 57: bp1 = bp + 1; ! 58: } ! 59: return (0); ! 60: } ! 61: ! 62: func(t, bp) ! 63: register struct command *t; ! 64: register struct biltins *bp; ! 65: { ! 66: int i; ! 67: ! 68: xechoit(t->t_dcom); ! 69: setname(bp->bname); ! 70: i = blklen(t->t_dcom) - 1; ! 71: if (i < bp->minargs) ! 72: bferr("Too few arguments"); ! 73: if (i > bp->maxargs) ! 74: bferr("Too many arguments"); ! 75: (*bp->bfunct)(t->t_dcom, t); ! 76: } ! 77: ! 78: dolabel() ! 79: { ! 80: ! 81: } ! 82: ! 83: doonintr(v) ! 84: char **v; ! 85: { ! 86: register char *cp; ! 87: register char *vv = v[1]; ! 88: ! 89: if (parintr == SIG_IGN) ! 90: return; ! 91: if (setintr && intty) ! 92: bferr("Can't from terminal"); ! 93: cp = gointr, gointr = 0, xfree(cp); ! 94: if (vv == 0) { ! 95: if (setintr) ! 96: (void) sigblock(sigmask(SIGINT)); ! 97: else ! 98: (void) signal(SIGINT, SIG_DFL); ! 99: gointr = 0; ! 100: } else if (eq((vv = strip(vv)), "-")) { ! 101: (void) signal(SIGINT, SIG_IGN); ! 102: gointr = "-"; ! 103: } else { ! 104: gointr = savestr(vv); ! 105: (void) signal(SIGINT, pintr); ! 106: } ! 107: } ! 108: ! 109: donohup() ! 110: { ! 111: ! 112: if (intty) ! 113: bferr("Can't from terminal"); ! 114: if (setintr == 0) { ! 115: (void) signal(SIGHUP, SIG_IGN); ! 116: #ifdef CC ! 117: submit(getpid()); ! 118: #endif ! 119: } ! 120: } ! 121: ! 122: dozip() ! 123: { ! 124: ! 125: ; ! 126: } ! 127: ! 128: prvars() ! 129: { ! 130: ! 131: plist(&shvhed); ! 132: } ! 133: ! 134: doalias(v) ! 135: register char **v; ! 136: { ! 137: register struct varent *vp; ! 138: register char *p; ! 139: ! 140: v++; ! 141: p = *v++; ! 142: if (p == 0) ! 143: plist(&aliases); ! 144: else if (*v == 0) { ! 145: vp = adrof1(strip(p), &aliases); ! 146: if (vp) ! 147: blkpr(vp->vec), printf("\n"); ! 148: } else { ! 149: if (eq(p, "alias") || eq(p, "unalias")) { ! 150: setname(p); ! 151: bferr("Too dangerous to alias that"); ! 152: } ! 153: set1(strip(p), saveblk(v), &aliases); ! 154: } ! 155: } ! 156: ! 157: unalias(v) ! 158: char **v; ! 159: { ! 160: ! 161: unset1(v, &aliases); ! 162: } ! 163: ! 164: dologout() ! 165: { ! 166: ! 167: islogin(); ! 168: goodbye(); ! 169: } ! 170: ! 171: dologin(v) ! 172: char **v; ! 173: { ! 174: ! 175: islogin(); ! 176: rechist(); ! 177: (void) signal(SIGTERM, parterm); ! 178: execl("/bin/login", "login", v[1], 0); ! 179: untty(); ! 180: exit(1); ! 181: } ! 182: ! 183: #ifdef NEWGRP ! 184: donewgrp(v) ! 185: char **v; ! 186: { ! 187: ! 188: if (chkstop == 0 && setintr) ! 189: panystop(0); ! 190: (void) signal(SIGTERM, parterm); ! 191: execl("/bin/newgrp", "newgrp", v[1], 0); ! 192: execl("/usr/bin/newgrp", "newgrp", v[1], 0); ! 193: untty(); ! 194: exit(1); ! 195: } ! 196: #endif ! 197: ! 198: islogin() ! 199: { ! 200: ! 201: if (chkstop == 0 && setintr) ! 202: panystop(0); ! 203: if (loginsh) ! 204: return; ! 205: error("Not login shell"); ! 206: } ! 207: ! 208: doif(v, kp) ! 209: char **v; ! 210: struct command *kp; ! 211: { ! 212: register int i; ! 213: register char **vv; ! 214: ! 215: v++; ! 216: i = exp(&v); ! 217: vv = v; ! 218: if (*vv == NOSTR) ! 219: bferr("Empty if"); ! 220: if (eq(*vv, "then")) { ! 221: if (*++vv) ! 222: bferr("Improper then"); ! 223: setname("then"); ! 224: /* ! 225: * If expression was zero, then scan to else, ! 226: * otherwise just fall into following code. ! 227: */ ! 228: if (!i) ! 229: search(ZIF, 0); ! 230: return; ! 231: } ! 232: /* ! 233: * Simple command attached to this if. ! 234: * Left shift the node in this tree, munging it ! 235: * so we can reexecute it. ! 236: */ ! 237: if (i) { ! 238: lshift(kp->t_dcom, vv - kp->t_dcom); ! 239: reexecute(kp); ! 240: donefds(); ! 241: } ! 242: } ! 243: ! 244: /* ! 245: * Reexecute a command, being careful not ! 246: * to redo i/o redirection, which is already set up. ! 247: */ ! 248: reexecute(kp) ! 249: register struct command *kp; ! 250: { ! 251: ! 252: kp->t_dflg &= FSAVE; ! 253: kp->t_dflg |= FREDO; ! 254: /* ! 255: * If tty is still ours to arbitrate, arbitrate it; ! 256: * otherwise dont even set pgrp's as the jobs would ! 257: * then have no way to get the tty (we can't give it ! 258: * to them, and our parent wouldn't know their pgrp, etc. ! 259: */ ! 260: execute(kp, tpgrp > 0 ? tpgrp : -1); ! 261: } ! 262: ! 263: doelse() ! 264: { ! 265: ! 266: search(ZELSE, 0); ! 267: } ! 268: ! 269: dogoto(v) ! 270: char **v; ! 271: { ! 272: register struct whyle *wp; ! 273: char *lp; ! 274: ! 275: /* ! 276: * While we still can, locate any unknown ends of existing loops. ! 277: * This obscure code is the WORST result of the fact that we ! 278: * don't really parse. ! 279: */ ! 280: for (wp = whyles; wp; wp = wp->w_next) ! 281: if (wp->w_end == 0) { ! 282: search(ZBREAK, 0); ! 283: wp->w_end = btell(); ! 284: } else ! 285: bseek(wp->w_end); ! 286: search(ZGOTO, 0, lp = globone(v[1])); ! 287: xfree(lp); ! 288: /* ! 289: * Eliminate loops which were exited. ! 290: */ ! 291: wfree(); ! 292: } ! 293: ! 294: doswitch(v) ! 295: register char **v; ! 296: { ! 297: register char *cp, *lp; ! 298: ! 299: v++; ! 300: if (!*v || *(*v++) != '(') ! 301: goto syntax; ! 302: cp = **v == ')' ? "" : *v++; ! 303: if (*(*v++) != ')') ! 304: v--; ! 305: if (*v) ! 306: syntax: ! 307: error("Syntax error"); ! 308: search(ZSWITCH, 0, lp = globone(cp)); ! 309: xfree(lp); ! 310: } ! 311: ! 312: dobreak() ! 313: { ! 314: ! 315: if (whyles) ! 316: toend(); ! 317: else ! 318: bferr("Not in while/foreach"); ! 319: } ! 320: ! 321: doexit(v) ! 322: char **v; ! 323: { ! 324: ! 325: if (chkstop == 0) ! 326: panystop(0); ! 327: /* ! 328: * Don't DEMAND parentheses here either. ! 329: */ ! 330: v++; ! 331: if (*v) { ! 332: set("status", putn(exp(&v))); ! 333: if (*v) ! 334: bferr("Expression syntax"); ! 335: } ! 336: btoeof(); ! 337: if (intty) ! 338: (void) close(SHIN); ! 339: } ! 340: ! 341: doforeach(v) ! 342: register char **v; ! 343: { ! 344: register char *cp; ! 345: register struct whyle *nwp; ! 346: ! 347: v++; ! 348: cp = strip(*v); ! 349: while (*cp && letter(*cp)) ! 350: cp++; ! 351: if (*cp || strlen(*v) >= 20) ! 352: bferr("Invalid variable"); ! 353: cp = *v++; ! 354: if (v[0][0] != '(' || v[blklen(v) - 1][0] != ')') ! 355: bferr("Words not ()'ed"); ! 356: v++; ! 357: gflag = 0, tglob(v); ! 358: v = glob(v); ! 359: if (v == 0) ! 360: bferr("No match"); ! 361: nwp = (struct whyle *) calloc(1, sizeof *nwp); ! 362: nwp->w_fe = nwp->w_fe0 = v; gargv = 0; ! 363: nwp->w_start = btell(); ! 364: nwp->w_fename = savestr(cp); ! 365: nwp->w_next = whyles; ! 366: whyles = nwp; ! 367: /* ! 368: * Pre-read the loop so as to be more ! 369: * comprehensible to a terminal user. ! 370: */ ! 371: if (intty) ! 372: preread(); ! 373: doagain(); ! 374: } ! 375: ! 376: dowhile(v) ! 377: char **v; ! 378: { ! 379: register int status; ! 380: register bool again = whyles != 0 && whyles->w_start == lineloc && ! 381: whyles->w_fename == 0; ! 382: ! 383: v++; ! 384: /* ! 385: * Implement prereading here also, taking care not to ! 386: * evaluate the expression before the loop has been read up ! 387: * from a terminal. ! 388: */ ! 389: if (intty && !again) ! 390: status = !exp0(&v, 1); ! 391: else ! 392: status = !exp(&v); ! 393: if (*v) ! 394: bferr("Expression syntax"); ! 395: if (!again) { ! 396: register struct whyle *nwp = (struct whyle *) calloc(1, sizeof (*nwp)); ! 397: ! 398: nwp->w_start = lineloc; ! 399: nwp->w_end = 0; ! 400: nwp->w_next = whyles; ! 401: whyles = nwp; ! 402: if (intty) { ! 403: /* ! 404: * The tty preread ! 405: */ ! 406: preread(); ! 407: doagain(); ! 408: return; ! 409: } ! 410: } ! 411: if (status) ! 412: /* We ain't gonna loop no more, no more! */ ! 413: toend(); ! 414: } ! 415: ! 416: preread() ! 417: { ! 418: ! 419: whyles->w_end = -1; ! 420: if (setintr) ! 421: (void) sigsetmask(sigblock(0L) & ~sigmask(SIGINT)); ! 422: search(ZBREAK, 0); ! 423: if (setintr) ! 424: (void) sigblock(sigmask(SIGINT)); ! 425: whyles->w_end = btell(); ! 426: } ! 427: ! 428: doend() ! 429: { ! 430: ! 431: if (!whyles) ! 432: bferr("Not in while/foreach"); ! 433: whyles->w_end = btell(); ! 434: doagain(); ! 435: } ! 436: ! 437: docontin() ! 438: { ! 439: ! 440: if (!whyles) ! 441: bferr("Not in while/foreach"); ! 442: doagain(); ! 443: } ! 444: ! 445: doagain() ! 446: { ! 447: ! 448: /* Repeating a while is simple */ ! 449: if (whyles->w_fename == 0) { ! 450: bseek(whyles->w_start); ! 451: return; ! 452: } ! 453: /* ! 454: * The foreach variable list actually has a spurious word ! 455: * ")" at the end of the w_fe list. Thus we are at the ! 456: * of the list if one word beyond this is 0. ! 457: */ ! 458: if (!whyles->w_fe[1]) { ! 459: dobreak(); ! 460: return; ! 461: } ! 462: set(whyles->w_fename, savestr(*whyles->w_fe++)); ! 463: bseek(whyles->w_start); ! 464: } ! 465: ! 466: dorepeat(v, kp) ! 467: char **v; ! 468: struct command *kp; ! 469: { ! 470: register int i; ! 471: register long omask; ! 472: ! 473: i = getn(v[1]); ! 474: if (setintr) ! 475: omask = sigblock(sigmask(SIGINT)) & ~sigmask(SIGINT); ! 476: lshift(v, 2); ! 477: while (i > 0) { ! 478: if (setintr) ! 479: (void) sigsetmask(omask); ! 480: reexecute(kp); ! 481: --i; ! 482: } ! 483: donefds(); ! 484: if (setintr) ! 485: (void) sigsetmask(omask); ! 486: } ! 487: ! 488: doswbrk() ! 489: { ! 490: ! 491: search(ZBRKSW, 0); ! 492: } ! 493: ! 494: srchx(cp) ! 495: register char *cp; ! 496: { ! 497: register struct srch *sp, *sp1, *sp2; ! 498: register i; ! 499: ! 500: /* ! 501: * Binary search ! 502: * Sp1 is the beginning of the current search range. ! 503: * Sp2 is one past the end. ! 504: */ ! 505: for (sp1 = srchn, sp2 = srchn + nsrchn; sp1 < sp2;) { ! 506: sp = sp1 + (sp2 - sp1 >> 1); ! 507: if ((i = *cp - *sp->s_name) == 0 && ! 508: (i = strcmp(cp, sp->s_name)) == 0) ! 509: return sp->s_value; ! 510: if (i < 0) ! 511: sp2 = sp; ! 512: else ! 513: sp1 = sp + 1; ! 514: } ! 515: return (-1); ! 516: } ! 517: ! 518: char Stype; ! 519: char *Sgoal; ! 520: ! 521: /*VARARGS2*/ ! 522: search(type, level, goal) ! 523: int type; ! 524: register int level; ! 525: char *goal; ! 526: { ! 527: char wordbuf[BUFSIZ]; ! 528: register char *aword = wordbuf; ! 529: register char *cp; ! 530: ! 531: Stype = type; Sgoal = goal; ! 532: if (type == ZGOTO) ! 533: bseek((off_t)0); ! 534: do { ! 535: if (intty && fseekp == feobp) ! 536: printf("? "), flush(); ! 537: aword[0] = 0; ! 538: (void) getword(aword); ! 539: switch (srchx(aword)) { ! 540: ! 541: case ZELSE: ! 542: if (level == 0 && type == ZIF) ! 543: return; ! 544: break; ! 545: ! 546: case ZIF: ! 547: while (getword(aword)) ! 548: continue; ! 549: if ((type == ZIF || type == ZELSE) && eq(aword, "then")) ! 550: level++; ! 551: break; ! 552: ! 553: case ZENDIF: ! 554: if (type == ZIF || type == ZELSE) ! 555: level--; ! 556: break; ! 557: ! 558: case ZFOREACH: ! 559: case ZWHILE: ! 560: if (type == ZBREAK) ! 561: level++; ! 562: break; ! 563: ! 564: case ZEND: ! 565: if (type == ZBREAK) ! 566: level--; ! 567: break; ! 568: ! 569: case ZSWITCH: ! 570: if (type == ZSWITCH || type == ZBRKSW) ! 571: level++; ! 572: break; ! 573: ! 574: case ZENDSW: ! 575: if (type == ZSWITCH || type == ZBRKSW) ! 576: level--; ! 577: break; ! 578: ! 579: case ZLABEL: ! 580: if (type == ZGOTO && getword(aword) && eq(aword, goal)) ! 581: level = -1; ! 582: break; ! 583: ! 584: default: ! 585: if (type != ZGOTO && (type != ZSWITCH || level != 0)) ! 586: break; ! 587: if (lastchr(aword) != ':') ! 588: break; ! 589: aword[strlen(aword) - 1] = 0; ! 590: if (type == ZGOTO && eq(aword, goal) || type == ZSWITCH && eq(aword, "default")) ! 591: level = -1; ! 592: break; ! 593: ! 594: case ZCASE: ! 595: if (type != ZSWITCH || level != 0) ! 596: break; ! 597: (void) getword(aword); ! 598: if (lastchr(aword) == ':') ! 599: aword[strlen(aword) - 1] = 0; ! 600: cp = strip(Dfix1(aword)); ! 601: if (Gmatch(goal, cp)) ! 602: level = -1; ! 603: xfree(cp); ! 604: break; ! 605: ! 606: case ZDEFAULT: ! 607: if (type == ZSWITCH && level == 0) ! 608: level = -1; ! 609: break; ! 610: } ! 611: (void) getword(NOSTR); ! 612: } while (level >= 0); ! 613: } ! 614: ! 615: getword(wp) ! 616: register char *wp; ! 617: { ! 618: register int found = 0; ! 619: register int c, d; ! 620: ! 621: c = readc(1); ! 622: d = 0; ! 623: do { ! 624: while (c == ' ' || c == '\t') ! 625: c = readc(1); ! 626: if (c == '#') ! 627: do ! 628: c = readc(1); ! 629: while (c >= 0 && c != '\n'); ! 630: if (c < 0) ! 631: goto past; ! 632: if (c == '\n') { ! 633: if (wp) ! 634: break; ! 635: return (0); ! 636: } ! 637: unreadc(c); ! 638: found = 1; ! 639: do { ! 640: c = readc(1); ! 641: if (c == '\\' && (c = readc(1)) == '\n') ! 642: c = ' '; ! 643: if (c == '\'' || c == '"') ! 644: if (d == 0) ! 645: d = c; ! 646: else if (d == c) ! 647: d = 0; ! 648: if (c < 0) ! 649: goto past; ! 650: if (wp) ! 651: *wp++ = c; ! 652: } while ((d || c != ' ' && c != '\t') && c != '\n'); ! 653: } while (wp == 0); ! 654: unreadc(c); ! 655: if (found) ! 656: *--wp = 0; ! 657: return (found); ! 658: ! 659: past: ! 660: switch (Stype) { ! 661: ! 662: case ZIF: ! 663: bferr("then/endif not found"); ! 664: ! 665: case ZELSE: ! 666: bferr("endif not found"); ! 667: ! 668: case ZBRKSW: ! 669: case ZSWITCH: ! 670: bferr("endsw not found"); ! 671: ! 672: case ZBREAK: ! 673: bferr("end not found"); ! 674: ! 675: case ZGOTO: ! 676: setname(Sgoal); ! 677: bferr("label not found"); ! 678: } ! 679: /*NOTREACHED*/ ! 680: } ! 681: ! 682: toend() ! 683: { ! 684: ! 685: if (whyles->w_end == 0) { ! 686: search(ZBREAK, 0); ! 687: whyles->w_end = btell() - 1; ! 688: } else ! 689: bseek(whyles->w_end); ! 690: wfree(); ! 691: } ! 692: ! 693: wfree() ! 694: { ! 695: long o = btell(); ! 696: ! 697: while (whyles) { ! 698: register struct whyle *wp = whyles; ! 699: register struct whyle *nwp = wp->w_next; ! 700: ! 701: if (o >= wp->w_start && (wp->w_end == 0 || o < wp->w_end)) ! 702: break; ! 703: if (wp->w_fe0) ! 704: blkfree(wp->w_fe0); ! 705: if (wp->w_fename) ! 706: xfree(wp->w_fename); ! 707: xfree((char *)wp); ! 708: whyles = nwp; ! 709: } ! 710: } ! 711: ! 712: doecho(v) ! 713: char **v; ! 714: { ! 715: ! 716: echo(' ', v); ! 717: } ! 718: ! 719: doglob(v) ! 720: char **v; ! 721: { ! 722: ! 723: echo(0, v); ! 724: flush(); ! 725: } ! 726: ! 727: echo(sep, v) ! 728: char sep; ! 729: register char **v; ! 730: { ! 731: register char *cp; ! 732: int nonl = 0; ! 733: ! 734: if (setintr) ! 735: (void) sigsetmask(sigblock(0L) & ~sigmask(SIGINT)); ! 736: v++; ! 737: if (*v == 0) ! 738: return; ! 739: gflag = 0, tglob(v); ! 740: if (gflag) { ! 741: v = glob(v); ! 742: if (v == 0) ! 743: bferr("No match"); ! 744: } else ! 745: trim(v); ! 746: if (sep == ' ' && *v && !strcmp(*v, "-n")) ! 747: nonl++, v++; ! 748: while (cp = *v++) { ! 749: register int c; ! 750: ! 751: while (c = *cp++) ! 752: cshputchar(c | QUOTE); ! 753: if (*v) ! 754: cshputchar(sep | QUOTE); ! 755: } ! 756: if (sep && nonl == 0) ! 757: cshputchar('\n'); ! 758: else ! 759: flush(); ! 760: if (setintr) ! 761: (void) sigblock(sigmask(SIGINT)); ! 762: if (gargv) ! 763: blkfree(gargv), gargv = 0; ! 764: } ! 765: ! 766: char **environ; ! 767: ! 768: dosetenv(v) ! 769: register char **v; ! 770: { ! 771: char *vp, *lp; ! 772: ! 773: v++; ! 774: if ((vp = *v++) == 0) { ! 775: register char **ep; ! 776: ! 777: if (setintr) ! 778: (void) sigsetmask(sigblock(0L) & ~ sigmask(SIGINT)); ! 779: for (ep = environ; *ep; ep++) ! 780: printf("%s\n", *ep); ! 781: return; ! 782: } ! 783: if ((lp = *v++) == 0) ! 784: lp = ""; ! 785: setenv(vp, lp = globone(lp)); ! 786: if (eq(vp, "PATH")) { ! 787: importpath(lp); ! 788: dohash(); ! 789: } ! 790: xfree(lp); ! 791: } ! 792: ! 793: dounsetenv(v) ! 794: register char **v; ! 795: { ! 796: ! 797: v++; ! 798: do ! 799: unsetenv(*v++); ! 800: while (*v); ! 801: } ! 802: ! 803: setenv(name, val) ! 804: char *name, *val; ! 805: { ! 806: register char **ep = environ; ! 807: register char *cp, *dp; ! 808: char *blk[2], **oep = ep; ! 809: ! 810: for (; *ep; ep++) { ! 811: for (cp = name, dp = *ep; *cp && *cp == *dp; cp++, dp++) ! 812: continue; ! 813: if (*cp != 0 || *dp != '=') ! 814: continue; ! 815: cp = strspl("=", val); ! 816: xfree(*ep); ! 817: *ep = strspl(name, cp); ! 818: xfree(cp); ! 819: trim(ep); ! 820: return; ! 821: } ! 822: blk[0] = strspl(name, "="); blk[1] = 0; ! 823: environ = blkspl(environ, blk); ! 824: xfree((char *)oep); ! 825: setenv(name, val); ! 826: } ! 827: ! 828: unsetenv(name) ! 829: char *name; ! 830: { ! 831: register char **ep = environ; ! 832: register char *cp, *dp; ! 833: char **oep = ep; ! 834: ! 835: for (; *ep; ep++) { ! 836: for (cp = name, dp = *ep; *cp && *cp == *dp; cp++, dp++) ! 837: continue; ! 838: if (*cp != 0 || *dp != '=') ! 839: continue; ! 840: cp = *ep; ! 841: *ep = 0; ! 842: environ = blkspl(environ, ep+1); ! 843: *ep = cp; ! 844: xfree(cp); ! 845: xfree((char *)oep); ! 846: return; ! 847: } ! 848: } ! 849: ! 850: doumask(v) ! 851: register char **v; ! 852: { ! 853: register char *cp = v[1]; ! 854: register int i; ! 855: ! 856: if (cp == 0) { ! 857: i = umask(0); ! 858: (void) umask(i); ! 859: printf("%o\n", i); ! 860: return; ! 861: } ! 862: i = 0; ! 863: while (digit(*cp) && *cp != '8' && *cp != '9') ! 864: i = i * 8 + *cp++ - '0'; ! 865: if (*cp || i < 0 || i > 0777) ! 866: bferr("Improper mask"); ! 867: (void) umask(i); ! 868: } ! 869: ! 870: ! 871: struct limits { ! 872: int limconst; ! 873: char *limname; ! 874: int limdiv; ! 875: char *limscale; ! 876: } limits[] = { ! 877: RLIMIT_CPU, "cputime", 1, "seconds", ! 878: RLIMIT_FSIZE, "filesize", 1024, "kbytes", ! 879: RLIMIT_DATA, "datasize", 1024, "kbytes", ! 880: RLIMIT_STACK, "stacksize", 1024, "kbytes", ! 881: RLIMIT_CORE, "coredumpsize", 1024, "kbytes", ! 882: RLIMIT_RSS, "memoryuse", 1024, "kbytes", ! 883: -1, 0, ! 884: }; ! 885: ! 886: struct limits * ! 887: findlim(cp) ! 888: char *cp; ! 889: { ! 890: register struct limits *lp, *res; ! 891: ! 892: res = 0; ! 893: for (lp = limits; lp->limconst >= 0; lp++) ! 894: if (prefix(cp, lp->limname)) { ! 895: if (res) ! 896: bferr("Ambiguous"); ! 897: res = lp; ! 898: } ! 899: if (res) ! 900: return (res); ! 901: bferr("No such limit"); ! 902: /*NOTREACHED*/ ! 903: } ! 904: ! 905: dolimit(v) ! 906: register char **v; ! 907: { ! 908: register struct limits *lp; ! 909: register int limit; ! 910: char hard = 0; ! 911: ! 912: v++; ! 913: if (*v && eq(*v, "-h")) { ! 914: hard = 1; ! 915: v++; ! 916: } ! 917: if (*v == 0) { ! 918: for (lp = limits; lp->limconst >= 0; lp++) ! 919: plim(lp, hard); ! 920: return; ! 921: } ! 922: lp = findlim(v[0]); ! 923: if (v[1] == 0) { ! 924: plim(lp, hard); ! 925: return; ! 926: } ! 927: limit = getval(lp, v+1); ! 928: if (setlim(lp, hard, limit) < 0) ! 929: error(NOSTR); ! 930: } ! 931: ! 932: getval(lp, v) ! 933: register struct limits *lp; ! 934: char **v; ! 935: { ! 936: register float f; ! 937: double atof(); ! 938: char *cp = *v++; ! 939: ! 940: f = atof(cp); ! 941: while (digit(*cp) || *cp == '.' || *cp == 'e' || *cp == 'E') ! 942: cp++; ! 943: if (*cp == 0) { ! 944: if (*v == 0) ! 945: return ((int)(f+0.5) * lp->limdiv); ! 946: cp = *v; ! 947: } ! 948: switch (*cp) { ! 949: ! 950: case ':': ! 951: if (lp->limconst != RLIMIT_CPU) ! 952: goto badscal; ! 953: return ((int)(f * 60.0 + atof(cp+1))); ! 954: ! 955: case 'h': ! 956: if (lp->limconst != RLIMIT_CPU) ! 957: goto badscal; ! 958: limtail(cp, "hours"); ! 959: f *= 3600.; ! 960: break; ! 961: ! 962: case 'm': ! 963: if (lp->limconst == RLIMIT_CPU) { ! 964: limtail(cp, "minutes"); ! 965: f *= 60.; ! 966: break; ! 967: } ! 968: case 'M': ! 969: if (lp->limconst == RLIMIT_CPU) ! 970: goto badscal; ! 971: *cp = 'm'; ! 972: limtail(cp, "megabytes"); ! 973: f *= 1024.*1024.; ! 974: break; ! 975: ! 976: case 's': ! 977: if (lp->limconst != RLIMIT_CPU) ! 978: goto badscal; ! 979: limtail(cp, "seconds"); ! 980: break; ! 981: ! 982: case 'k': ! 983: if (lp->limconst == RLIMIT_CPU) ! 984: goto badscal; ! 985: limtail(cp, "kbytes"); ! 986: f *= 1024; ! 987: break; ! 988: ! 989: case 'u': ! 990: limtail(cp, "unlimited"); ! 991: return (RLIM_INFINITY); ! 992: ! 993: default: ! 994: badscal: ! 995: bferr("Improper or unknown scale factor"); ! 996: } ! 997: return ((int)(f+0.5)); ! 998: } ! 999: ! 1000: limtail(cp, str0) ! 1001: char *cp, *str0; ! 1002: { ! 1003: register char *str = str0; ! 1004: ! 1005: while (*cp && *cp == *str) ! 1006: cp++, str++; ! 1007: if (*cp) ! 1008: error("Bad scaling; did you mean ``%s''?", str0); ! 1009: } ! 1010: ! 1011: plim(lp, hard) ! 1012: register struct limits *lp; ! 1013: char hard; ! 1014: { ! 1015: struct rlimit rlim; ! 1016: int limit; ! 1017: ! 1018: printf("%s \t", lp->limname); ! 1019: (void) getrlimit(lp->limconst, &rlim); ! 1020: limit = hard ? rlim.rlim_max : rlim.rlim_cur; ! 1021: if (limit == RLIM_INFINITY) ! 1022: printf("unlimited"); ! 1023: else if (lp->limconst == RLIMIT_CPU) ! 1024: psecs((long)limit); ! 1025: else ! 1026: printf("%d %s", limit / lp->limdiv, lp->limscale); ! 1027: printf("\n"); ! 1028: } ! 1029: ! 1030: dounlimit(v) ! 1031: register char **v; ! 1032: { ! 1033: register struct limits *lp; ! 1034: int err = 0; ! 1035: char hard = 0; ! 1036: ! 1037: v++; ! 1038: if (*v && eq(*v, "-h")) { ! 1039: hard = 1; ! 1040: v++; ! 1041: } ! 1042: if (*v == 0) { ! 1043: for (lp = limits; lp->limconst >= 0; lp++) ! 1044: if (setlim(lp, hard, (int)RLIM_INFINITY) < 0) ! 1045: err++; ! 1046: if (err) ! 1047: error(NOSTR); ! 1048: return; ! 1049: } ! 1050: while (*v) { ! 1051: lp = findlim(*v++); ! 1052: if (setlim(lp, hard, (int)RLIM_INFINITY) < 0) ! 1053: error(NOSTR); ! 1054: } ! 1055: } ! 1056: ! 1057: setlim(lp, hard, limit) ! 1058: register struct limits *lp; ! 1059: char hard; ! 1060: { ! 1061: struct rlimit rlim; ! 1062: ! 1063: (void) getrlimit(lp->limconst, &rlim); ! 1064: if (hard) ! 1065: rlim.rlim_max = limit; ! 1066: else if (limit == RLIM_INFINITY && geteuid() != 0) ! 1067: rlim.rlim_cur = rlim.rlim_max; ! 1068: else ! 1069: rlim.rlim_cur = limit; ! 1070: if (setrlimit(lp->limconst, &rlim) < 0) { ! 1071: printf("%s: %s: Can't %s%s limit\n", bname, lp->limname, ! 1072: limit == RLIM_INFINITY ? "remove" : "set", ! 1073: hard ? " hard" : ""); ! 1074: return (-1); ! 1075: } ! 1076: return (0); ! 1077: } ! 1078: ! 1079: dosuspend() ! 1080: { ! 1081: int ldisc, ctpgrp; ! 1082: int (*old)(); ! 1083: ! 1084: if (loginsh) ! 1085: error("Can't suspend a login shell (yet)"); ! 1086: untty(); ! 1087: old = signal(SIGTSTP, SIG_DFL); ! 1088: (void) kill(0, SIGTSTP); ! 1089: /* the shell stops here */ ! 1090: (void) signal(SIGTSTP, old); ! 1091: if (tpgrp != -1) { ! 1092: retry: ! 1093: (void) ioctl(FSHTTY, TIOCGPGRP, (char *)&ctpgrp); ! 1094: if (ctpgrp != opgrp) { ! 1095: old = signal(SIGTTIN, SIG_DFL); ! 1096: (void) kill(0, SIGTTIN); ! 1097: (void) signal(SIGTTIN, old); ! 1098: goto retry; ! 1099: } ! 1100: (void) ioctl(FSHTTY, TIOCSPGRP, (char *)&shpgrp); ! 1101: (void) setpgrp(0, shpgrp); ! 1102: } ! 1103: (void) ioctl(FSHTTY, TIOCGETD, (char *)&oldisc); ! 1104: if (oldisc != NTTYDISC) { ! 1105: printf("Switching to new tty driver...\n"); ! 1106: ldisc = NTTYDISC; ! 1107: (void) ioctl(FSHTTY, TIOCSETD, (char *)&ldisc); ! 1108: } ! 1109: } ! 1110: ! 1111: doeval(v) ! 1112: char **v; ! 1113: { ! 1114: char **oevalvec = evalvec; ! 1115: char *oevalp = evalp; ! 1116: jmp_buf osetexit; ! 1117: int reenter; ! 1118: char **gv = 0; ! 1119: ! 1120: v++; ! 1121: if (*v == 0) ! 1122: return; ! 1123: gflag = 0, tglob(v); ! 1124: if (gflag) { ! 1125: gv = v = glob(v); ! 1126: gargv = 0; ! 1127: if (v == 0) ! 1128: error("No match"); ! 1129: v = copyblk(v); ! 1130: } else ! 1131: trim(v); ! 1132: getexit(osetexit); ! 1133: reenter = 0; ! 1134: setexit(); ! 1135: reenter++; ! 1136: if (reenter == 1) { ! 1137: evalvec = v; ! 1138: evalp = 0; ! 1139: process(0); ! 1140: } ! 1141: evalvec = oevalvec; ! 1142: evalp = oevalp; ! 1143: doneinp = 0; ! 1144: if (gv) ! 1145: blkfree(gv); ! 1146: resexit(osetexit); ! 1147: if (reenter >= 2) ! 1148: error(NOSTR); ! 1149: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.