1/* $NetBSD: func.c,v 1.45 2024/04/24 15:49:03 nia Exp $ */
2
3/*-
4 * Copyright (c) 1980, 1991, 1993
5 *	The Regents of the University of California.  All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the University nor the names of its contributors
16 *    may be used to endorse or promote products derived from this software
17 *    without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32#include <sys/cdefs.h>
33#ifndef lint
34#if 0
35static char sccsid[] = "@(#)func.c	8.1 (Berkeley) 5/31/93";
36#else
37__RCSID("$NetBSD: func.c,v 1.45 2024/04/24 15:49:03 nia Exp $");
38#endif
39#endif /* not lint */
40
41#include <sys/stat.h>
42#include <sys/types.h>
43
44#include <locale.h>
45#include <inttypes.h>
46#include <signal.h>
47#include <stdarg.h>
48#include <stdlib.h>
49#include <string.h>
50#include <unistd.h>
51#include <errno.h>
52
53#include "csh.h"
54#include "extern.h"
55#include "pathnames.h"
56
57extern char **environ;
58extern int progprintf(int, char **);
59
60static void islogin(void);
61static void reexecute(struct command *);
62static void preread(void);
63static void doagain(void);
64static void search(int, int, Char *);
65static int getword(Char *);
66static int keyword(Char *);
67static void toend(void);
68static void xecho(int, Char **);
69static void Unsetenv(Char *);
70static void wpfree(struct whyle *);
71
72struct biltins *
73isbfunc(struct command *t)
74{
75    static struct biltins label = {"", dozip, 0, 0};
76    static struct biltins foregnd = {"%job", dofg1, 0, 0};
77    static struct biltins backgnd = {"%job &", dobg1, 0, 0};
78    struct biltins *bp, *bp1, *bp2;
79    Char *cp;
80
81    cp = t->t_dcom[0];
82
83    if (lastchr(cp) == ':') {
84	label.bname = short2str(cp);
85	return (&label);
86    }
87    if (*cp == '%') {
88	if (t->t_dflg & F_AMPERSAND) {
89	    t->t_dflg &= ~F_AMPERSAND;
90	    backgnd.bname = short2str(cp);
91	    return (&backgnd);
92	}
93	foregnd.bname = short2str(cp);
94	return (&foregnd);
95    }
96    /*
97     * Binary search Bp1 is the beginning of the current search range. Bp2 is
98     * one past the end.
99     */
100    for (bp1 = bfunc, bp2 = bfunc + nbfunc; bp1 < bp2;) {
101	int i;
102
103	bp = bp1 + ((bp2 - bp1) >> 1);
104	if ((i = *cp - *bp->bname) == 0 &&
105	    (i = Strcmp(cp, str2short(bp->bname))) == 0)
106	    return bp;
107	if (i < 0)
108	    bp2 = bp;
109	else
110	    bp1 = bp + 1;
111    }
112    return (0);
113}
114
115void
116func(struct command *t, struct biltins *bp)
117{
118    int i;
119
120    xechoit(t->t_dcom);
121    setname(bp->bname);
122    i = blklen(t->t_dcom) - 1;
123    if (i < bp->minargs)
124	stderror(ERR_NAME | ERR_TOOFEW);
125    if (i > bp->maxargs)
126	stderror(ERR_NAME | ERR_TOOMANY);
127    (*bp->bfunct) (t->t_dcom, t);
128}
129
130void
131/*ARGSUSED*/
132doonintr(Char **v, struct command *t)
133{
134    Char *cp, *vv;
135    sigset_t nsigset;
136
137    vv = v[1];
138    if (parintr == SIG_IGN)
139	return;
140    if (setintr && intty)
141	stderror(ERR_NAME | ERR_TERMINAL);
142    cp = gointr;
143    gointr = 0;
144    free(cp);
145    if (vv == 0) {
146	if (setintr) {
147	    sigemptyset(&nsigset);
148	    (void)sigaddset(&nsigset, SIGINT);
149	    (void)sigprocmask(SIG_BLOCK, &nsigset, NULL);
150	} else
151	    (void)signal(SIGINT, SIG_DFL);
152	gointr = 0;
153    }
154    else if (eq((vv = strip(vv)), STRminus)) {
155	(void)signal(SIGINT, SIG_IGN);
156	gointr = Strsave(STRminus);
157    }
158    else {
159	gointr = Strsave(vv);
160	(void)signal(SIGINT, pintr);
161    }
162}
163
164void
165/*ARGSUSED*/
166donohup(Char **v, struct command *t)
167{
168    if (intty)
169	stderror(ERR_NAME | ERR_TERMINAL);
170    if (setintr == 0) {
171	(void) signal(SIGHUP, SIG_IGN);
172    }
173}
174
175void
176/*ARGSUSED*/
177dozip(Char **v, struct command *t)
178{
179    ;
180}
181
182void
183prvars(void)
184{
185    plist(&shvhed);
186}
187
188void
189/*ARGSUSED*/
190doalias(Char **v, struct command *t)
191{
192    struct varent *vp;
193    Char *p;
194
195    v++;
196    p = *v++;
197    if (p == 0)
198	plist(&aliases);
199    else if (*v == 0) {
200	vp = adrof1(strip(p), &aliases);
201	if (vp) {
202	    blkpr(cshout, vp->vec);
203	    (void) fputc('\n', cshout);
204	}
205    }
206    else {
207	if (eq(p, STRalias) || eq(p, STRunalias)) {
208	    setname(vis_str(p));
209	    stderror(ERR_NAME | ERR_DANGER);
210	}
211	set1(strip(p), saveblk(v), &aliases);
212    }
213}
214
215void
216/*ARGSUSED*/
217unalias(Char **v, struct command *t)
218{
219    unset1(v, &aliases);
220}
221
222void
223/*ARGSUSED*/
224dologout(Char **v, struct command *t)
225{
226    islogin();
227    goodbye();
228}
229
230void
231/*ARGSUSED*/
232dologin(Char **v, struct command *t)
233{
234    islogin();
235    rechist();
236    (void)signal(SIGTERM, parterm);
237    (void)execl(_PATH_LOGIN, "login", short2str(v[1]), NULL);
238    untty();
239    xexit(1);
240    /* NOTREACHED */
241}
242
243static void
244islogin(void)
245{
246    if (chkstop == 0 && setintr)
247	panystop(0);
248    if (loginsh)
249	return;
250    stderror(ERR_NOTLOGIN);
251    /* NOTREACHED */
252}
253
254void
255doif(Char **v, struct command *kp)
256{
257    Char **vv;
258    int i;
259
260    v++;
261    i = expr(&v);
262    vv = v;
263    if (*vv == NULL)
264	stderror(ERR_NAME | ERR_EMPTYIF);
265    if (eq(*vv, STRthen)) {
266	if (*++vv)
267	    stderror(ERR_NAME | ERR_IMPRTHEN);
268	setname(vis_str(STRthen));
269	/*
270	 * If expression was zero, then scan to else, otherwise just fall into
271	 * following code.
272	 */
273	if (!i)
274	    search(T_IF, 0, NULL);
275	return;
276    }
277    /*
278     * Simple command attached to this if. Left shift the node in this tree,
279     * munging it so we can reexecute it.
280     */
281    if (i) {
282	lshift(kp->t_dcom, (size_t)(vv - kp->t_dcom));
283	reexecute(kp);
284	donefds();
285    }
286}
287
288/*
289 * Reexecute a command, being careful not
290 * to redo i/o redirection, which is already set up.
291 */
292static void
293reexecute(struct command *kp)
294{
295    kp->t_dflg &= F_SAVE;
296    kp->t_dflg |= F_REPEAT;
297    /*
298     * If tty is still ours to arbitrate, arbitrate it; otherwise dont even set
299     * pgrp's as the jobs would then have no way to get the tty (we can't give
300     * it to them, and our parent wouldn't know their pgrp, etc.
301     */
302    execute(kp, (tpgrp > 0 ? tpgrp : -1), NULL, NULL);
303}
304
305void
306/*ARGSUSED*/
307doelse(Char **v, struct command *t)
308{
309    search(T_ELSE, 0, NULL);
310}
311
312void
313/*ARGSUSED*/
314dogoto(Char **v, struct command *t)
315{
316    Char *lp;
317
318    gotolab(lp = globone(v[1], G_ERROR));
319    free(lp);
320}
321
322void
323gotolab(Char *lab)
324{
325    struct whyle *wp;
326    /*
327     * While we still can, locate any unknown ends of existing loops. This
328     * obscure code is the WORST result of the fact that we don't really parse.
329     */
330    for (wp = whyles; wp; wp = wp->w_next)
331	if (wp->w_end.type == F_SEEK && wp->w_end.f_seek == 0) {
332	    search(T_BREAK, 0, NULL);
333	    btell(&wp->w_end);
334	}
335	else
336	    bseek(&wp->w_end);
337    search(T_GOTO, 0, lab);
338    /*
339     * Eliminate loops which were exited.
340     */
341    wfree();
342}
343
344void
345/*ARGSUSED*/
346doswitch(Char **v, struct command *t)
347{
348    Char *cp, *lp;
349
350    v++;
351    if (!*v || *(*v++) != '(')
352	stderror(ERR_SYNTAX);
353    cp = **v == ')' ? STRNULL : *v++;
354    if (*(*v++) != ')')
355	v--;
356    if (*v)
357	stderror(ERR_SYNTAX);
358    search(T_SWITCH, 0, lp = globone(cp, G_ERROR));
359    free(lp);
360}
361
362void
363/*ARGSUSED*/
364dobreak(Char **v, struct command *t)
365{
366    if (whyles)
367	toend();
368    else
369	stderror(ERR_NAME | ERR_NOTWHILE);
370}
371
372void
373/*ARGSUSED*/
374doexit(Char **v, struct command *t)
375{
376    if (chkstop == 0 && (intty || intact) && evalvec == 0)
377	panystop(0);
378    /*
379     * Don't DEMAND parentheses here either.
380     */
381    v++;
382    if (*v) {
383	set(STRstatus, putn(expr(&v)));
384	if (*v)
385	    stderror(ERR_NAME | ERR_EXPRESSION);
386    }
387    btoeof();
388    if (intty)
389	(void) close(SHIN);
390}
391
392void
393/*ARGSUSED*/
394doforeach(Char **v, struct command *t)
395{
396    struct whyle *nwp;
397    Char *cp, *sp;
398
399    v++;
400    sp = cp = strip(*v);
401    if (!letter(*sp))
402	stderror(ERR_NAME | ERR_VARBEGIN);
403    while (*cp && alnum(*cp))
404	cp++;
405    if (*cp)
406	stderror(ERR_NAME | ERR_VARALNUM);
407    if ((cp - sp) > MAXVARLEN)
408	stderror(ERR_NAME | ERR_VARTOOLONG);
409    cp = *v++;
410    if (v[0][0] != '(' || v[blklen(v) - 1][0] != ')')
411	stderror(ERR_NAME | ERR_NOPAREN);
412    v++;
413    gflag = 0, tglob(v);
414    v = globall(v);
415    if (v == 0)
416	stderror(ERR_NAME | ERR_NOMATCH);
417    nwp = xcalloc(1, sizeof *nwp);
418    nwp->w_fe = nwp->w_fe0 = v;
419    gargv = 0;
420    btell(&nwp->w_start);
421    nwp->w_fename = Strsave(cp);
422    nwp->w_next = whyles;
423    nwp->w_end.type = F_SEEK;
424    whyles = nwp;
425    /*
426     * Pre-read the loop so as to be more comprehensible to a terminal user.
427     */
428    if (intty)
429	preread();
430    doagain();
431}
432
433void
434/*ARGSUSED*/
435dowhile(Char **v, struct command *t)
436{
437    int status;
438    int again;
439
440    again = whyles != 0 && SEEKEQ(&whyles->w_start, &lineloc) &&
441        whyles->w_fename == 0;
442    v++;
443    /*
444     * Implement prereading here also, taking care not to evaluate the
445     * expression before the loop has been read up from a terminal.
446     */
447    if (intty && !again)
448	status = !exp0(&v, 1);
449    else
450	status = !expr(&v);
451    if (*v)
452	stderror(ERR_NAME | ERR_EXPRESSION);
453    if (!again) {
454	struct whyle *nwp =
455		xcalloc(1, sizeof(*nwp));
456
457	nwp->w_start = lineloc;
458	nwp->w_end.type = F_SEEK;
459	nwp->w_end.f_seek = 0;
460	nwp->w_next = whyles;
461	whyles = nwp;
462	if (intty) {
463	    /*
464	     * The tty preread
465	     */
466	    preread();
467	    doagain();
468	    return;
469	}
470    }
471    if (status)
472	/* We ain't gonna loop no more, no more! */
473	toend();
474}
475
476static void
477preread(void)
478{
479    sigset_t nsigset;
480
481    whyles->w_end.type = I_SEEK;
482    if (setintr) {
483	sigemptyset(&nsigset);
484	(void) sigaddset(&nsigset, SIGINT);
485	(void) sigprocmask(SIG_UNBLOCK, &nsigset, NULL);
486    }
487
488    search(T_BREAK, 0, NULL);		/* read the expression in */
489    if (setintr)
490	(void)sigprocmask(SIG_BLOCK, &nsigset, NULL);
491    btell(&whyles->w_end);
492}
493
494void
495/*ARGSUSED*/
496doend(Char **v, struct command *t)
497{
498    if (!whyles)
499	stderror(ERR_NAME | ERR_NOTWHILE);
500    btell(&whyles->w_end);
501    doagain();
502}
503
504void
505/*ARGSUSED*/
506docontin(Char **v, struct command *t)
507{
508    if (!whyles)
509	stderror(ERR_NAME | ERR_NOTWHILE);
510    doagain();
511}
512
513static void
514doagain(void)
515{
516    /* Repeating a while is simple */
517    if (whyles->w_fename == 0) {
518	bseek(&whyles->w_start);
519	return;
520    }
521    /*
522     * The foreach variable list actually has a spurious word ")" at the end of
523     * the w_fe list.  Thus we are at the of the list if one word beyond this
524     * is 0.
525     */
526    if (!whyles->w_fe[1]) {
527	dobreak(NULL, NULL);
528	return;
529    }
530    set(whyles->w_fename, Strsave(*whyles->w_fe++));
531    bseek(&whyles->w_start);
532}
533
534void
535dorepeat(Char **v, struct command *kp)
536{
537    int i;
538    sigset_t nsigset;
539
540    i = getn(v[1]);
541    if (setintr) {
542	sigemptyset(&nsigset);
543	(void)sigaddset(&nsigset, SIGINT);
544	(void)sigprocmask(SIG_BLOCK, &nsigset, NULL);
545    }
546    lshift(v, 2);
547    while (i > 0) {
548	if (setintr)
549	    (void)sigprocmask(SIG_UNBLOCK, &nsigset, NULL);
550	reexecute(kp);
551	--i;
552    }
553    donefds();
554    if (setintr)
555	(void) sigprocmask(SIG_UNBLOCK, &nsigset, NULL);
556}
557
558void
559/*ARGSUSED*/
560doswbrk(Char **v, struct command *t)
561{
562    search(T_BRKSW, 0, NULL);
563}
564
565int
566srchx(Char *cp)
567{
568    struct srch *sp, *sp1, *sp2;
569    int i;
570
571    /*
572     * Binary search Sp1 is the beginning of the current search range. Sp2 is
573     * one past the end.
574     */
575    for (sp1 = srchn, sp2 = srchn + nsrchn; sp1 < sp2;) {
576	sp = sp1 + ((sp2 - sp1) >> 1);
577	if ((i = *cp - *sp->s_name) == 0 &&
578	    (i = Strcmp(cp, str2short(sp->s_name))) == 0)
579	    return sp->s_value;
580	if (i < 0)
581	    sp2 = sp;
582	else
583	    sp1 = sp + 1;
584    }
585    return (-1);
586}
587
588static Char Stype;
589static Char *Sgoal;
590
591/*VARARGS2*/
592static void
593search(int type, int level, Char *goal)
594{
595    Char wordbuf[BUFSIZE];
596    Char *aword, *cp;
597    struct whyle *wp;
598    int wlevel = 0;
599
600    aword = wordbuf;
601    Stype = (Char)type;
602    Sgoal = goal;
603    if (type == T_GOTO) {
604	struct Ain a;
605	a.type = F_SEEK;
606	a.f_seek = 0;
607	bseek(&a);
608    }
609    do {
610	if (intty && fseekp == feobp && aret == F_SEEK)
611	    (void)fprintf(cshout, "? "), (void)fflush(cshout);
612	aword[0] = 0;
613	(void)getword(aword);
614	switch (srchx(aword)) {
615	case T_CASE:
616	    if (type != T_SWITCH || level != 0)
617		break;
618	    (void) getword(aword);
619	    if (lastchr(aword) == ':')
620		aword[Strlen(aword) - 1] = 0;
621	    cp = strip(Dfix1(aword));
622	    if (Gmatch(goal, cp))
623		level = -1;
624	    free(cp);
625	    break;
626	case T_DEFAULT:
627	    if (type == T_SWITCH && level == 0)
628		level = -1;
629	    break;
630	case T_ELSE:
631	    if (level == 0 && type == T_IF)
632		return;
633	    break;
634	case T_END:
635	    if (type == T_BRKSW) {
636		if (wlevel == 0) {
637		    wp = whyles;
638		    if (wp) {
639			whyles = wp->w_next;
640			wpfree(wp);
641		    }
642		}
643	    }
644	    if (type == T_BREAK)
645		level--;
646	    wlevel--;
647	    break;
648	case T_ENDIF:
649	    if (type == T_IF || type == T_ELSE)
650		level--;
651	    break;
652	case T_ENDSW:
653	    if (type == T_SWITCH || type == T_BRKSW)
654		level--;
655	    break;
656	case T_IF:
657	    while (getword(aword))
658		continue;
659	    if ((type == T_IF || type == T_ELSE) &&
660		eq(aword, STRthen))
661		level++;
662	    break;
663	case T_LABEL:
664	    if (type == T_GOTO && getword(aword) && eq(aword, goal))
665		level = -1;
666	    break;
667	case T_SWITCH:
668	    if (type == T_SWITCH || type == T_BRKSW)
669		level++;
670	    break;
671	case T_FOREACH:
672	case T_WHILE:
673	    wlevel++;
674	    if (type == T_BREAK)
675		level++;
676	    break;
677	default:
678	    if (type != T_GOTO && (type != T_SWITCH || level != 0))
679		break;
680	    if (lastchr(aword) != ':')
681		break;
682	    aword[Strlen(aword) - 1] = 0;
683	    if ((type == T_GOTO && eq(aword, goal)) ||
684		(type == T_SWITCH && eq(aword, STRdefault)))
685		level = -1;
686	    break;
687	}
688	(void) getword(NULL);
689    } while (level >= 0);
690}
691
692static void
693wpfree(struct whyle *wp)
694{
695    if (wp->w_fe0)
696	blkfree(wp->w_fe0);
697    if (wp->w_fename)
698	free(wp->w_fename);
699    free(wp);
700}
701
702static int
703getword(Char *wp)
704{
705    int c, d, found, kwd;
706    Char *owp;
707
708    c = readc(1);
709    d = 0;
710    found = 0;
711    kwd = 0;
712    owp = wp;
713    do {
714	while (c == ' ' || c == '\t')
715	    c = readc(1);
716	if (c == '#')
717	    do
718		c = readc(1);
719	    while (c >= 0 && c != '\n');
720	if (c < 0)
721	    goto past;
722	if (c == '\n') {
723	    if (wp)
724		break;
725	    return (0);
726	}
727	unreadc(c);
728	found = 1;
729	do {
730	    c = readc(1);
731	    if (c == '\\' && (c = readc(1)) == '\n')
732		c = ' ';
733	    if (c == '\'' || c == '"') {
734		if (d == 0)
735		    d = c;
736		else if (d == c)
737		    d = 0;
738	    }
739	    if (c < 0)
740		goto past;
741	    if (wp) {
742		*wp++ = (Char)c;
743		*wp = 0;	/* end the string b4 test */
744	    }
745	} while ((d || (!(kwd = keyword(owp)) && c != ' '
746		  && c != '\t')) && c != '\n');
747    } while (wp == 0);
748
749    /*
750     * if we have read a keyword ( "if", "switch" or "while" ) then we do not
751     * need to unreadc the look-ahead char
752     */
753    if (!kwd) {
754	unreadc(c);
755	if (found)
756	    *--wp = 0;
757    }
758
759    return (found);
760
761past:
762    switch (Stype) {
763    case T_BREAK:
764	stderror(ERR_NAME | ERR_NOTFOUND, "end");
765	/* NOTREACHED */
766    case T_ELSE:
767	stderror(ERR_NAME | ERR_NOTFOUND, "endif");
768	/* NOTREACHED */
769    case T_GOTO:
770	setname(vis_str(Sgoal));
771	stderror(ERR_NAME | ERR_NOTFOUND, "label");
772	/* NOTREACHED */
773    case T_IF:
774	stderror(ERR_NAME | ERR_NOTFOUND, "then/endif");
775	/* NOTREACHED */
776    case T_BRKSW:
777    case T_SWITCH:
778	stderror(ERR_NAME | ERR_NOTFOUND, "endsw");
779	/* NOTREACHED */
780    }
781    return (0);
782}
783
784/*
785 * keyword(wp) determines if wp is one of the built-n functions if,
786 * switch or while. It seems that when an if statement looks like
787 * "if(" then getword above sucks in the '(' and so the search routine
788 * never finds what it is scanning for. Rather than rewrite doword, I hack
789 * in a test to see if the string forms a keyword. Then doword stops
790 * and returns the word "if" -strike
791 */
792
793static int
794keyword(Char *wp)
795{
796    static Char STRswitch[] = {'s', 'w', 'i', 't', 'c', 'h', '\0'};
797    static Char STRwhile[] = {'w', 'h', 'i', 'l', 'e', '\0'};
798    static Char STRif[] = {'i', 'f', '\0'};
799
800    if (!wp)
801	return (0);
802
803    if ((Strcmp(wp, STRif) == 0) || (Strcmp(wp, STRwhile) == 0)
804	|| (Strcmp(wp, STRswitch) == 0))
805	return (1);
806
807    return (0);
808}
809
810static void
811toend(void)
812{
813    if (whyles->w_end.type == F_SEEK && whyles->w_end.f_seek == 0) {
814	search(T_BREAK, 0, NULL);
815	btell(&whyles->w_end);
816	whyles->w_end.f_seek--;
817    }
818    else
819	bseek(&whyles->w_end);
820    wfree();
821}
822
823void
824wfree(void)
825{
826    struct Ain o;
827    struct whyle *nwp;
828
829    btell(&o);
830
831    for (; whyles; whyles = nwp) {
832	struct whyle *wp = whyles;
833	nwp = wp->w_next;
834
835	/*
836	 * We free loops that have different seek types.
837	 */
838	if (wp->w_end.type != I_SEEK && wp->w_start.type == wp->w_end.type &&
839	    wp->w_start.type == o.type) {
840	    if (wp->w_end.type == F_SEEK) {
841		if (o.f_seek >= wp->w_start.f_seek &&
842		    (wp->w_end.f_seek == 0 || o.f_seek < wp->w_end.f_seek))
843		    break;
844	    }
845	    else {
846		if (o.a_seek >= wp->w_start.a_seek &&
847		    (wp->w_end.a_seek == 0 || o.a_seek < wp->w_end.a_seek))
848		    break;
849	    }
850	}
851
852	wpfree(wp);
853    }
854}
855
856void
857/*ARGSUSED*/
858doecho(Char **v, struct command *t)
859{
860    xecho(' ', v);
861}
862
863void
864/*ARGSUSED*/
865doglob(Char **v, struct command *t)
866{
867    xecho(0, v);
868    (void)fflush(cshout);
869}
870
871static void
872xecho(int sep, Char **v)
873{
874    Char *cp;
875    sigset_t nsigset;
876    int nonl;
877
878    nonl = 0;
879    if (setintr) {
880	sigemptyset(&nsigset);
881	(void)sigaddset(&nsigset, SIGINT);
882	(void)sigprocmask(SIG_UNBLOCK, &nsigset, NULL);
883    }
884    v++;
885    if (*v == 0)
886	goto done;
887    gflag = 0, tglob(v);
888    if (gflag) {
889	v = globall(v);
890	if (v == 0)
891	    stderror(ERR_NAME | ERR_NOMATCH);
892    }
893    else {
894	v = gargv = saveblk(v);
895	trim(v);
896    }
897    if (sep == ' ' && *v && eq(*v, STRmn))
898	nonl++, v++;
899    while ((cp = *v++) != NULL) {
900	int c;
901
902	while ((c = *cp++) != '\0')
903	    (void)vis_fputc(c | QUOTE, cshout);
904
905	if (*v)
906	    (void)vis_fputc(sep | QUOTE, cshout);
907    }
908done:
909    if (sep && nonl == 0)
910	(void)fputc('\n', cshout);
911    else
912	(void)fflush(cshout);
913    if (setintr)
914	(void)sigprocmask(SIG_BLOCK, &nsigset, NULL);
915    if (gargv)
916	blkfree(gargv), gargv = 0;
917}
918
919void
920/*ARGSUSED*/
921dosetenv(Char **v, struct command *t)
922{
923    Char *lp, *vp;
924    sigset_t nsigset;
925
926    v++;
927    if ((vp = *v++) == 0) {
928	Char **ep;
929
930	if (setintr) {
931	    sigemptyset(&nsigset);
932	    (void)sigaddset(&nsigset, SIGINT);
933	    (void)sigprocmask(SIG_UNBLOCK, &nsigset, NULL);
934	}
935	for (ep = STR_environ; *ep; ep++)
936	    (void)fprintf(cshout, "%s\n", vis_str(*ep));
937	return;
938    }
939    if ((lp = *v++) == 0)
940	lp = STRNULL;
941    Setenv(vp, lp = globone(lp, G_APPEND));
942    if (eq(vp, STRPATH)) {
943	importpath(lp);
944	dohash(NULL, NULL);
945    }
946    else if (eq(vp, STRLANG) || eq(vp, STRLC_CTYPE)) {
947#ifdef NLS
948	int k;
949
950	(void)setlocale(LC_ALL, "");
951	for (k = 0200; k <= 0377 && !Isprint(k); k++)
952		continue;
953	AsciiOnly = k > 0377;
954#else
955	AsciiOnly = 0;
956#endif				/* NLS */
957    }
958    free(lp);
959}
960
961void
962/*ARGSUSED*/
963dounsetenv(Char **v, struct command *t)
964{
965    static Char *name = NULL;
966    Char **ep, *p, *n;
967    int i, maxi;
968
969    if (name)
970	free(name);
971    /*
972     * Find the longest environment variable
973     */
974    for (maxi = 0, ep = STR_environ; *ep; ep++) {
975	for (i = 0, p = *ep; *p && *p != '='; p++, i++)
976	    continue;
977	if (i > maxi)
978	    maxi = i;
979    }
980
981    name = xreallocarray(NULL, (size_t)(maxi + 1), sizeof(Char));
982
983    while (++v && *v)
984	for (maxi = 1; maxi;)
985	    for (maxi = 0, ep = STR_environ; *ep; ep++) {
986		for (n = name, p = *ep; *p && *p != '='; *n++ = *p++)
987		    continue;
988		*n = '\0';
989		if (!Gmatch(name, *v))
990		    continue;
991		maxi = 1;
992		if (eq(name, STRLANG) || eq(name, STRLC_CTYPE)) {
993#ifdef NLS
994		    int     k;
995
996		    (void) setlocale(LC_ALL, "");
997		    for (k = 0200; k <= 0377 && !Isprint(k); k++)
998			continue;
999		    AsciiOnly = k > 0377;
1000#else
1001		    AsciiOnly = getenv("LANG") == NULL &&
1002			getenv("LC_CTYPE") == NULL;
1003#endif				/* NLS */
1004		}
1005		/*
1006		 * Delete name, and start again cause the environment changes
1007		 */
1008		Unsetenv(name);
1009		break;
1010	    }
1011    free(name);
1012    name = NULL;
1013}
1014
1015void
1016Setenv(Char *name, Char *val)
1017{
1018    Char *blk[2], *cp, *dp, **ep, **oep;
1019
1020    ep = STR_environ;
1021    oep = ep;
1022
1023    for (; *ep; ep++) {
1024	for (cp = name, dp = *ep; *cp && *cp == *dp; cp++, dp++)
1025	    continue;
1026	if (*cp != 0 || *dp != '=')
1027	    continue;
1028	cp = Strspl(STRequal, val);
1029	free(* ep);
1030	*ep = strip(Strspl(name, cp));
1031	free(cp);
1032	blkfree((Char **)environ);
1033	environ = short2blk(STR_environ);
1034	return;
1035    }
1036    cp = Strspl(name, STRequal);
1037    blk[0] = strip(Strspl(cp, val));
1038    free(cp);
1039    blk[1] = 0;
1040    STR_environ = blkspl(STR_environ, blk);
1041    blkfree((Char **)environ);
1042    environ = short2blk(STR_environ);
1043    free(oep);
1044}
1045
1046static void
1047Unsetenv(Char *name)
1048{
1049    Char *cp, *dp, **ep, **oep;
1050
1051    ep = STR_environ;
1052    oep = ep;
1053
1054    for (; *ep; ep++) {
1055	for (cp = name, dp = *ep; *cp && *cp == *dp; cp++, dp++)
1056	    continue;
1057	if (*cp != 0 || *dp != '=')
1058	    continue;
1059	cp = *ep;
1060	*ep = 0;
1061	STR_environ = blkspl(STR_environ, ep + 1);
1062	environ = short2blk(STR_environ);
1063	*ep = cp;
1064	free(cp);
1065	free(oep);
1066	return;
1067    }
1068}
1069
1070void
1071/*ARGSUSED*/
1072doumask(Char **v, struct command *t)
1073{
1074    Char *cp;
1075    mode_t i;
1076
1077    cp = v[1];
1078    if (cp == 0) {
1079	i = umask(0);
1080	(void)umask(i);
1081	(void)fprintf(cshout, "%o\n", i);
1082	return;
1083    }
1084    i = 0;
1085    while (Isdigit(*cp) && *cp != '8' && *cp != '9')
1086	i = i * 8 + (mode_t)(*cp++ - '0');
1087    if (*cp || i > 0777)
1088	stderror(ERR_NAME | ERR_MASK);
1089    (void)umask(i);
1090}
1091
1092typedef rlim_t RLIM_TYPE;
1093
1094static const struct limits {
1095    int     limconst;
1096    const   char *limname;
1097    int     limdiv;
1098    const   char *limscale;
1099}       limits[] = {
1100    { RLIMIT_CPU,	"cputime",	1,	"seconds" },
1101    { RLIMIT_FSIZE,	"filesize",	1024,	"kbytes" },
1102    { RLIMIT_DATA,	"datasize",	1024,	"kbytes" },
1103    { RLIMIT_STACK,	"stacksize",	1024,	"kbytes" },
1104    { RLIMIT_CORE,	"coredumpsize", 1024,	"kbytes" },
1105    { RLIMIT_RSS,	"memoryuse",	1024,	"kbytes" },
1106    { RLIMIT_MEMLOCK,	"memorylocked",	1024,	"kbytes" },
1107    { RLIMIT_NPROC,	"maxproc",	1,	"" },
1108    { RLIMIT_NTHR,	"maxthread",	1,	"" },
1109    { RLIMIT_NOFILE,	"openfiles",	1,	"" },
1110    { RLIMIT_SBSIZE,	"sbsize",	1,	"bytes" },
1111    { RLIMIT_AS,	"vmemoryuse",	1024,	"kbytes" },
1112    { -1,		NULL,		0,	NULL }
1113};
1114
1115static const struct limits *findlim(Char *);
1116static RLIM_TYPE getval(const struct limits *, Char **);
1117static void limtail(Char *, const char *);
1118static void plim(const struct limits *, Char);
1119static int setlim(const struct limits *, Char, RLIM_TYPE);
1120
1121static const struct limits *
1122findlim(Char *cp)
1123{
1124    const struct limits *lp, *res;
1125
1126    res = NULL;
1127    for (lp = limits; lp->limconst >= 0; lp++)
1128	if (prefix(cp, str2short(lp->limname))) {
1129	    if (res)
1130		stderror(ERR_NAME | ERR_AMBIG);
1131	    res = lp;
1132	}
1133    if (res)
1134	return (res);
1135    stderror(ERR_NAME | ERR_LIMIT);
1136    /* NOTREACHED */
1137}
1138
1139void
1140/*ARGSUSED*/
1141dolimit(Char **v, struct command *t)
1142{
1143    const struct limits *lp;
1144    RLIM_TYPE limit;
1145    char hard;
1146
1147    hard = 0;
1148    v++;
1149    if (*v && eq(*v, STRmh)) {
1150	hard = 1;
1151	v++;
1152    }
1153    if (*v == 0) {
1154	for (lp = limits; lp->limconst >= 0; lp++)
1155	    plim(lp, hard);
1156	return;
1157    }
1158    lp = findlim(v[0]);
1159    if (v[1] == 0) {
1160	plim(lp, hard);
1161	return;
1162    }
1163    limit = getval(lp, v + 1);
1164    if (setlim(lp, hard, limit) < 0)
1165	stderror(ERR_SILENT);
1166}
1167
1168static  RLIM_TYPE
1169getval(const struct limits *lp, Char **v)
1170{
1171    Char *cp;
1172    double d;
1173
1174    cp = *v++;
1175    d = atof(short2str(cp));
1176
1177    while (Isdigit(*cp) || *cp == '.' || *cp == 'e' || *cp == 'E')
1178	cp++;
1179    if (*cp == 0) {
1180	if (*v == 0)
1181	    return ((RLIM_TYPE)((d + 0.5) * lp->limdiv));
1182	cp = *v;
1183    }
1184    switch (*cp) {
1185    case ':':
1186	if (lp->limconst != RLIMIT_CPU)
1187	    goto badscal;
1188	return ((RLIM_TYPE)(d * 60.0 + atof(short2str(cp + 1))));
1189    case 'M':
1190	if (lp->limconst == RLIMIT_CPU)
1191	    goto badscal;
1192	*cp = 'm';
1193	limtail(cp, "megabytes");
1194	d *= 1024.0 * 1024.0;
1195	break;
1196    case 'h':
1197	if (lp->limconst != RLIMIT_CPU)
1198	    goto badscal;
1199	limtail(cp, "hours");
1200	d *= 3600.0;
1201	break;
1202    case 'k':
1203	if (lp->limconst == RLIMIT_CPU)
1204	    goto badscal;
1205	limtail(cp, "kbytes");
1206	d *= 1024.0;
1207	break;
1208    case 'm':
1209	if (lp->limconst == RLIMIT_CPU) {
1210	    limtail(cp, "minutes");
1211	    d *= 60.0;
1212	    break;
1213	}
1214	*cp = 'm';
1215	limtail(cp, "megabytes");
1216	d *= 1024.0 * 1024.0;
1217	break;
1218    case 's':
1219	if (lp->limconst != RLIMIT_CPU)
1220	    goto badscal;
1221	limtail(cp, "seconds");
1222	break;
1223    case 'u':
1224	limtail(cp, "unlimited");
1225	return (RLIM_INFINITY);
1226    default:
1227    badscal:
1228	stderror(ERR_NAME | ERR_SCALEF);
1229	/* NOTREACHED */
1230    }
1231    d += 0.5;
1232    if (d > (double) RLIM_INFINITY)
1233	return RLIM_INFINITY;
1234    else
1235	return ((RLIM_TYPE)d);
1236}
1237
1238static void
1239limtail(Char *cp, const char *str)
1240{
1241    while (*cp && *cp == *str)
1242	cp++, str++;
1243    if (*cp)
1244	stderror(ERR_BADSCALE, str);
1245}
1246
1247
1248/*ARGSUSED*/
1249static void
1250plim(const struct limits *lp, Char hard)
1251{
1252    struct rlimit rlim;
1253    RLIM_TYPE limit;
1254
1255    (void)fprintf(cshout, "%-13.13s", lp->limname);
1256
1257    (void)getrlimit(lp->limconst, &rlim);
1258    limit = hard ? rlim.rlim_max : rlim.rlim_cur;
1259
1260    if (limit == RLIM_INFINITY)
1261	(void)fprintf(cshout, "unlimited");
1262    else if (lp->limconst == RLIMIT_CPU)
1263	psecs((long) limit);
1264    else
1265	(void)fprintf(cshout, "%jd %s",
1266	    (intmax_t) (limit / (RLIM_TYPE)lp->limdiv), lp->limscale);
1267    (void)fputc('\n', cshout);
1268}
1269
1270void
1271/*ARGSUSED*/
1272dounlimit(Char **v, struct command *t)
1273{
1274    const struct limits *lp;
1275    int lerr;
1276    Char hard;
1277
1278    lerr = 0;
1279    hard = 0;
1280    v++;
1281    if (*v && eq(*v, STRmh)) {
1282	hard = 1;
1283	v++;
1284    }
1285    if (*v == 0) {
1286	for (lp = limits; lp->limconst >= 0; lp++)
1287	    if (setlim(lp, hard, (RLIM_TYPE)RLIM_INFINITY) < 0)
1288		lerr++;
1289	if (lerr)
1290	    stderror(ERR_SILENT);
1291	return;
1292    }
1293    while (*v) {
1294	lp = findlim(*v++);
1295	if (setlim(lp, hard, (RLIM_TYPE)RLIM_INFINITY) < 0)
1296	    stderror(ERR_SILENT);
1297    }
1298}
1299
1300static int
1301setlim(const struct limits *lp, Char hard, RLIM_TYPE limit)
1302{
1303    struct rlimit rlim;
1304
1305    (void)getrlimit(lp->limconst, &rlim);
1306
1307    if (hard)
1308	rlim.rlim_max = limit;
1309    else if (limit == RLIM_INFINITY && geteuid() != 0)
1310	rlim.rlim_cur = rlim.rlim_max;
1311    else
1312	rlim.rlim_cur = limit;
1313
1314    if (rlim.rlim_max < rlim.rlim_cur)
1315	rlim.rlim_max = rlim.rlim_cur;
1316
1317    if (setrlimit(lp->limconst, &rlim) < 0) {
1318	(void)fprintf(csherr, "%s: %s: Can't %s%s limit (%s)\n", bname,
1319	    lp->limname, limit == RLIM_INFINITY ? "remove" : "set",
1320	    hard ? " hard" : "", strerror(errno));
1321	return (-1);
1322    }
1323    return (0);
1324}
1325
1326void
1327/*ARGSUSED*/
1328dosuspend(Char **v, struct command *t)
1329{
1330    int     ctpgrp;
1331    void    (*old)(int);
1332
1333    if (loginsh)
1334	stderror(ERR_SUSPLOG);
1335    untty();
1336
1337    old = signal(SIGTSTP, SIG_DFL);
1338    (void)kill(0, SIGTSTP);
1339    /* the shell stops here */
1340    (void)signal(SIGTSTP, old);
1341
1342    if (tpgrp != -1) {
1343retry:
1344	ctpgrp = tcgetpgrp(FSHTTY);
1345	if  (ctpgrp != opgrp) {
1346	    old = signal(SIGTTIN, SIG_DFL);
1347	    (void)kill(0, SIGTTIN);
1348	    (void)signal(SIGTTIN, old);
1349	    goto retry;
1350	}
1351	(void)setpgid(0, shpgrp);
1352	(void)tcsetpgrp(FSHTTY, shpgrp);
1353    }
1354}
1355
1356/* This is the dreaded EVAL built-in.
1357 *   If you don't fiddle with file descriptors, and reset didfds,
1358 *   this command will either ignore redirection inside or outside
1359 *   its arguments, e.g. eval "date >x"  vs.  eval "date" >x
1360 *   The stuff here seems to work, but I did it by trial and error rather
1361 *   than really knowing what was going on.  If tpgrp is zero, we are
1362 *   probably a background eval, e.g. "eval date &", and we want to
1363 *   make sure that any processes we start stay in our pgrp.
1364 *   This is also the case for "time eval date" -- stay in same pgrp.
1365 *   Otherwise, under stty tostop, processes will stop in the wrong
1366 *   pgrp, with no way for the shell to get them going again.  -IAN!
1367 */
1368static Char **gv = NULL;
1369
1370void
1371/*ARGSUSED*/
1372doeval(Char **v, struct command *t)
1373{
1374    jmp_buf osetexit;
1375    Char *oevalp, **oevalvec, **savegv;
1376    int my_reenter, odidfds, oSHERR, oSHIN, oSHOUT, saveERR, saveIN, saveOUT;
1377
1378    savegv = gv;
1379    UNREGISTER(v);
1380
1381    oevalvec = evalvec;
1382    oevalp = evalp;
1383    odidfds = didfds;
1384    oSHIN = SHIN;
1385    oSHOUT = SHOUT;
1386    oSHERR = SHERR;
1387
1388    v++;
1389    if (*v == 0)
1390	return;
1391    gflag = 0, tglob(v);
1392    if (gflag) {
1393	gv = v = globall(v);
1394	gargv = 0;
1395	if (v == 0)
1396	    stderror(ERR_NOMATCH);
1397	v = copyblk(v);
1398    }
1399    else {
1400	gv = NULL;
1401	v = copyblk(v);
1402	trim(v);
1403    }
1404
1405    saveIN = dcopy(SHIN, -1);
1406    saveOUT = dcopy(SHOUT, -1);
1407    saveERR = dcopy(SHERR, -1);
1408
1409    getexit(osetexit);
1410
1411    if ((my_reenter = setexit()) == 0) {
1412	evalvec = v;
1413	evalp = 0;
1414	SHIN = dcopy(0, -1);
1415	SHOUT = dcopy(1, -1);
1416	SHERR = dcopy(2, -1);
1417	didfds = 0;
1418	process(0);
1419    }
1420
1421    evalvec = oevalvec;
1422    evalp = oevalp;
1423    doneinp = 0;
1424    didfds = odidfds;
1425    if (SHIN != -1)
1426	(void)close(SHIN);
1427    if (SHOUT != -1)
1428	(void)close(SHOUT);
1429    if (SHERR != -1)
1430	(void)close(SHERR);
1431    SHIN = dmove(saveIN, oSHIN);
1432    SHOUT = dmove(saveOUT, oSHOUT);
1433    SHERR = dmove(saveERR, oSHERR);
1434    if (gv)
1435	blkfree(gv), gv = NULL;
1436    resexit(osetexit);
1437    gv = savegv;
1438    if (my_reenter)
1439	stderror(ERR_SILENT);
1440}
1441
1442void
1443/*ARGSUSED*/
1444doprintf(Char **v, struct command *t)
1445{
1446    char **c;
1447    int ret;
1448
1449    ret = progprintf(blklen(v), c = short2blk(v));
1450    (void)fflush(cshout);
1451    (void)fflush(csherr);
1452
1453    blkfree((Char **)c);
1454    if (ret)
1455	stderror(ERR_SILENT);
1456}
1457