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