Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/bin/csh/func.c

1457 lines
29 KiB
C
Raw Permalink Blame History

/* $NetBSD: func.c,v 1.45 2024/04/24 15:49:03 nia Exp $ */
/*-
* Copyright (c) 1980, 1991, 1993
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/cdefs.h>
#ifndef lint
#if 0
static char sccsid[] = "@(#)func.c 8.1 (Berkeley) 5/31/93";
#else
__RCSID("$NetBSD: func.c,v 1.45 2024/04/24 15:49:03 nia Exp $");
#endif
#endif /* not lint */
#include <sys/stat.h>
#include <sys/types.h>
#include <locale.h>
#include <inttypes.h>
#include <signal.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include "csh.h"
#include "extern.h"
#include "pathnames.h"
extern char **environ;
extern int progprintf(int, char **);
static void islogin(void);
static void reexecute(struct command *);
static void preread(void);
static void doagain(void);
static void search(int, int, Char *);
static int getword(Char *);
static int keyword(Char *);
static void toend(void);
static void xecho(int, Char **);
static void Unsetenv(Char *);
static void wpfree(struct whyle *);
struct biltins *
isbfunc(struct command *t)
{
static struct biltins label = {"", dozip, 0, 0};
static struct biltins foregnd = {"%job", dofg1, 0, 0};
static struct biltins backgnd = {"%job &", dobg1, 0, 0};
struct biltins *bp, *bp1, *bp2;
Char *cp;
cp = t->t_dcom[0];
if (lastchr(cp) == ':') {
label.bname = short2str(cp);
return (&label);
}
if (*cp == '%') {
if (t->t_dflg & F_AMPERSAND) {
t->t_dflg &= ~F_AMPERSAND;
backgnd.bname = short2str(cp);
return (&backgnd);
}
foregnd.bname = short2str(cp);
return (&foregnd);
}
/*
* Binary search Bp1 is the beginning of the current search range. Bp2 is
* one past the end.
*/
for (bp1 = bfunc, bp2 = bfunc + nbfunc; bp1 < bp2;) {
int i;
bp = bp1 + ((bp2 - bp1) >> 1);
if ((i = *cp - *bp->bname) == 0 &&
(i = Strcmp(cp, str2short(bp->bname))) == 0)
return bp;
if (i < 0)
bp2 = bp;
else
bp1 = bp + 1;
}
return (0);
}
void
func(struct command *t, struct biltins *bp)
{
int i;
xechoit(t->t_dcom);
setname(bp->bname);
i = blklen(t->t_dcom) - 1;
if (i < bp->minargs)
stderror(ERR_NAME | ERR_TOOFEW);
if (i > bp->maxargs)
stderror(ERR_NAME | ERR_TOOMANY);
(*bp->bfunct) (t->t_dcom, t);
}
void
/*ARGSUSED*/
doonintr(Char **v, struct command *t)
{
Char *cp, *vv;
sigset_t nsigset;
vv = v[1];
if (parintr == SIG_IGN)
return;
if (setintr && intty)
stderror(ERR_NAME | ERR_TERMINAL);
cp = gointr;
gointr = 0;
free(cp);
if (vv == 0) {
if (setintr) {
sigemptyset(&nsigset);
(void)sigaddset(&nsigset, SIGINT);
(void)sigprocmask(SIG_BLOCK, &nsigset, NULL);
} else
(void)signal(SIGINT, SIG_DFL);
gointr = 0;
}
else if (eq((vv = strip(vv)), STRminus)) {
(void)signal(SIGINT, SIG_IGN);
gointr = Strsave(STRminus);
}
else {
gointr = Strsave(vv);
(void)signal(SIGINT, pintr);
}
}
void
/*ARGSUSED*/
donohup(Char **v, struct command *t)
{
if (intty)
stderror(ERR_NAME | ERR_TERMINAL);
if (setintr == 0) {
(void) signal(SIGHUP, SIG_IGN);
}
}
void
/*ARGSUSED*/
dozip(Char **v, struct command *t)
{
;
}
void
prvars(void)
{
plist(&shvhed);
}
void
/*ARGSUSED*/
doalias(Char **v, struct command *t)
{
struct varent *vp;
Char *p;
v++;
p = *v++;
if (p == 0)
plist(&aliases);
else if (*v == 0) {
vp = adrof1(strip(p), &aliases);
if (vp) {
blkpr(cshout, vp->vec);
(void) fputc('\n', cshout);
}
}
else {
if (eq(p, STRalias) || eq(p, STRunalias)) {
setname(vis_str(p));
stderror(ERR_NAME | ERR_DANGER);
}
set1(strip(p), saveblk(v), &aliases);
}
}
void
/*ARGSUSED*/
unalias(Char **v, struct command *t)
{
unset1(v, &aliases);
}
void
/*ARGSUSED*/
dologout(Char **v, struct command *t)
{
islogin();
goodbye();
}
void
/*ARGSUSED*/
dologin(Char **v, struct command *t)
{
islogin();
rechist();
(void)signal(SIGTERM, parterm);
(void)execl(_PATH_LOGIN, "login", short2str(v[1]), NULL);
untty();
xexit(1);
/* NOTREACHED */
}
static void
islogin(void)
{
if (chkstop == 0 && setintr)
panystop(0);
if (loginsh)
return;
stderror(ERR_NOTLOGIN);
/* NOTREACHED */
}
void
doif(Char **v, struct command *kp)
{
Char **vv;
int i;
v++;
i = expr(&v);
vv = v;
if (*vv == NULL)
stderror(ERR_NAME | ERR_EMPTYIF);
if (eq(*vv, STRthen)) {
if (*++vv)
stderror(ERR_NAME | ERR_IMPRTHEN);
setname(vis_str(STRthen));
/*
* If expression was zero, then scan to else, otherwise just fall into
* following code.
*/
if (!i)
search(T_IF, 0, NULL);
return;
}
/*
* Simple command attached to this if. Left shift the node in this tree,
* munging it so we can reexecute it.
*/
if (i) {
lshift(kp->t_dcom, (size_t)(vv - kp->t_dcom));
reexecute(kp);
donefds();
}
}
/*
* Reexecute a command, being careful not
* to redo i/o redirection, which is already set up.
*/
static void
reexecute(struct command *kp)
{
kp->t_dflg &= F_SAVE;
kp->t_dflg |= F_REPEAT;
/*
* If tty is still ours to arbitrate, arbitrate it; otherwise dont even set
* pgrp's as the jobs would then have no way to get the tty (we can't give
* it to them, and our parent wouldn't know their pgrp, etc.
*/
execute(kp, (tpgrp > 0 ? tpgrp : -1), NULL, NULL);
}
void
/*ARGSUSED*/
doelse(Char **v, struct command *t)
{
search(T_ELSE, 0, NULL);
}
void
/*ARGSUSED*/
dogoto(Char **v, struct command *t)
{
Char *lp;
gotolab(lp = globone(v[1], G_ERROR));
free(lp);
}
void
gotolab(Char *lab)
{
struct whyle *wp;
/*
* While we still can, locate any unknown ends of existing loops. This
* obscure code is the WORST result of the fact that we don't really parse.
*/
for (wp = whyles; wp; wp = wp->w_next)
if (wp->w_end.type == F_SEEK && wp->w_end.f_seek == 0) {
search(T_BREAK, 0, NULL);
btell(&wp->w_end);
}
else
bseek(&wp->w_end);
search(T_GOTO, 0, lab);
/*
* Eliminate loops which were exited.
*/
wfree();
}
void
/*ARGSUSED*/
doswitch(Char **v, struct command *t)
{
Char *cp, *lp;
v++;
if (!*v || *(*v++) != '(')
stderror(ERR_SYNTAX);
cp = **v == ')' ? STRNULL : *v++;
if (*(*v++) != ')')
v--;
if (*v)
stderror(ERR_SYNTAX);
search(T_SWITCH, 0, lp = globone(cp, G_ERROR));
free(lp);
}
void
/*ARGSUSED*/
dobreak(Char **v, struct command *t)
{
if (whyles)
toend();
else
stderror(ERR_NAME | ERR_NOTWHILE);
}
void
/*ARGSUSED*/
doexit(Char **v, struct command *t)
{
if (chkstop == 0 && (intty || intact) && evalvec == 0)
panystop(0);
/*
* Don't DEMAND parentheses here either.
*/
v++;
if (*v) {
set(STRstatus, putn(expr(&v)));
if (*v)
stderror(ERR_NAME | ERR_EXPRESSION);
}
btoeof();
if (intty)
(void) close(SHIN);
}
void
/*ARGSUSED*/
doforeach(Char **v, struct command *t)
{
struct whyle *nwp;
Char *cp, *sp;
v++;
sp = cp = strip(*v);
if (!letter(*sp))
stderror(ERR_NAME | ERR_VARBEGIN);
while (*cp && alnum(*cp))
cp++;
if (*cp)
stderror(ERR_NAME | ERR_VARALNUM);
if ((cp - sp) > MAXVARLEN)
stderror(ERR_NAME | ERR_VARTOOLONG);
cp = *v++;
if (v[0][0] != '(' || v[blklen(v) - 1][0] != ')')
stderror(ERR_NAME | ERR_NOPAREN);
v++;
gflag = 0, tglob(v);
v = globall(v);
if (v == 0)
stderror(ERR_NAME | ERR_NOMATCH);
nwp = xcalloc(1, sizeof *nwp);
nwp->w_fe = nwp->w_fe0 = v;
gargv = 0;
btell(&nwp->w_start);
nwp->w_fename = Strsave(cp);
nwp->w_next = whyles;
nwp->w_end.type = F_SEEK;
whyles = nwp;
/*
* Pre-read the loop so as to be more comprehensible to a terminal user.
*/
if (intty)
preread();
doagain();
}
void
/*ARGSUSED*/
dowhile(Char **v, struct command *t)
{
int status;
int again;
again = whyles != 0 && SEEKEQ(&whyles->w_start, &lineloc) &&
whyles->w_fename == 0;
v++;
/*
* Implement prereading here also, taking care not to evaluate the
* expression before the loop has been read up from a terminal.
*/
if (intty && !again)
status = !exp0(&v, 1);
else
status = !expr(&v);
if (*v)
stderror(ERR_NAME | ERR_EXPRESSION);
if (!again) {
struct whyle *nwp =
xcalloc(1, sizeof(*nwp));
nwp->w_start = lineloc;
nwp->w_end.type = F_SEEK;
nwp->w_end.f_seek = 0;
nwp->w_next = whyles;
whyles = nwp;
if (intty) {
/*
* The tty preread
*/
preread();
doagain();
return;
}
}
if (status)
/* We ain't gonna loop no more, no more! */
toend();
}
static void
preread(void)
{
sigset_t nsigset;
whyles->w_end.type = I_SEEK;
if (setintr) {
sigemptyset(&nsigset);
(void) sigaddset(&nsigset, SIGINT);
(void) sigprocmask(SIG_UNBLOCK, &nsigset, NULL);
}
search(T_BREAK, 0, NULL); /* read the expression in */
if (setintr)
(void)sigprocmask(SIG_BLOCK, &nsigset, NULL);
btell(&whyles->w_end);
}
void
/*ARGSUSED*/
doend(Char **v, struct command *t)
{
if (!whyles)
stderror(ERR_NAME | ERR_NOTWHILE);
btell(&whyles->w_end);
doagain();
}
void
/*ARGSUSED*/
docontin(Char **v, struct command *t)
{
if (!whyles)
stderror(ERR_NAME | ERR_NOTWHILE);
doagain();
}
static void
doagain(void)
{
/* Repeating a while is simple */
if (whyles->w_fename == 0) {
bseek(&whyles->w_start);
return;
}
/*
* The foreach variable list actually has a spurious word ")" at the end of
* the w_fe list. Thus we are at the of the list if one word beyond this
* is 0.
*/
if (!whyles->w_fe[1]) {
dobreak(NULL, NULL);
return;
}
set(whyles->w_fename, Strsave(*whyles->w_fe++));
bseek(&whyles->w_start);
}
void
dorepeat(Char **v, struct command *kp)
{
int i;
sigset_t nsigset;
i = getn(v[1]);
if (setintr) {
sigemptyset(&nsigset);
(void)sigaddset(&nsigset, SIGINT);
(void)sigprocmask(SIG_BLOCK, &nsigset, NULL);
}
lshift(v, 2);
while (i > 0) {
if (setintr)
(void)sigprocmask(SIG_UNBLOCK, &nsigset, NULL);
reexecute(kp);
--i;
}
donefds();
if (setintr)
(void) sigprocmask(SIG_UNBLOCK, &nsigset, NULL);
}
void
/*ARGSUSED*/
doswbrk(Char **v, struct command *t)
{
search(T_BRKSW, 0, NULL);
}
int
srchx(Char *cp)
{
struct srch *sp, *sp1, *sp2;
int i;
/*
* Binary search Sp1 is the beginning of the current search range. Sp2 is
* one past the end.
*/
for (sp1 = srchn, sp2 = srchn + nsrchn; sp1 < sp2;) {
sp = sp1 + ((sp2 - sp1) >> 1);
if ((i = *cp - *sp->s_name) == 0 &&
(i = Strcmp(cp, str2short(sp->s_name))) == 0)
return sp->s_value;
if (i < 0)
sp2 = sp;
else
sp1 = sp + 1;
}
return (-1);
}
static Char Stype;
static Char *Sgoal;
/*VARARGS2*/
static void
search(int type, int level, Char *goal)
{
Char wordbuf[BUFSIZE];
Char *aword, *cp;
struct whyle *wp;
int wlevel = 0;
aword = wordbuf;
Stype = (Char)type;
Sgoal = goal;
if (type == T_GOTO) {
struct Ain a;
a.type = F_SEEK;
a.f_seek = 0;
bseek(&a);
}
do {
if (intty && fseekp == feobp && aret == F_SEEK)
(void)fprintf(cshout, "? "), (void)fflush(cshout);
aword[0] = 0;
(void)getword(aword);
switch (srchx(aword)) {
case T_CASE:
if (type != T_SWITCH || level != 0)
break;
(void) getword(aword);
if (lastchr(aword) == ':')
aword[Strlen(aword) - 1] = 0;
cp = strip(Dfix1(aword));
if (Gmatch(goal, cp))
level = -1;
free(cp);
break;
case T_DEFAULT:
if (type == T_SWITCH && level == 0)
level = -1;
break;
case T_ELSE:
if (level == 0 && type == T_IF)
return;
break;
case T_END:
if (type == T_BRKSW) {
if (wlevel == 0) {
wp = whyles;
if (wp) {
whyles = wp->w_next;
wpfree(wp);
}
}
}
if (type == T_BREAK)
level--;
wlevel--;
break;
case T_ENDIF:
if (type == T_IF || type == T_ELSE)
level--;
break;
case T_ENDSW:
if (type == T_SWITCH || type == T_BRKSW)
level--;
break;
case T_IF:
while (getword(aword))
continue;
if ((type == T_IF || type == T_ELSE) &&
eq(aword, STRthen))
level++;
break;
case T_LABEL:
if (type == T_GOTO && getword(aword) && eq(aword, goal))
level = -1;
break;
case T_SWITCH:
if (type == T_SWITCH || type == T_BRKSW)
level++;
break;
case T_FOREACH:
case T_WHILE:
wlevel++;
if (type == T_BREAK)
level++;
break;
default:
if (type != T_GOTO && (type != T_SWITCH || level != 0))
break;
if (lastchr(aword) != ':')
break;
aword[Strlen(aword) - 1] = 0;
if ((type == T_GOTO && eq(aword, goal)) ||
(type == T_SWITCH && eq(aword, STRdefault)))
level = -1;
break;
}
(void) getword(NULL);
} while (level >= 0);
}
static void
wpfree(struct whyle *wp)
{
if (wp->w_fe0)
blkfree(wp->w_fe0);
if (wp->w_fename)
free(wp->w_fename);
free(wp);
}
static int
getword(Char *wp)
{
int c, d, found, kwd;
Char *owp;
c = readc(1);
d = 0;
found = 0;
kwd = 0;
owp = wp;
do {
while (c == ' ' || c == '\t')
c = readc(1);
if (c == '#')
do
c = readc(1);
while (c >= 0 && c != '\n');
if (c < 0)
goto past;
if (c == '\n') {
if (wp)
break;
return (0);
}
unreadc(c);
found = 1;
do {
c = readc(1);
if (c == '\\' && (c = readc(1)) == '\n')
c = ' ';
if (c == '\'' || c == '"') {
if (d == 0)
d = c;
else if (d == c)
d = 0;
}
if (c < 0)
goto past;
if (wp) {
*wp++ = (Char)c;
*wp = 0; /* end the string b4 test */
}
} while ((d || (!(kwd = keyword(owp)) && c != ' '
&& c != '\t')) && c != '\n');
} while (wp == 0);
/*
* if we have read a keyword ( "if", "switch" or "while" ) then we do not
* need to unreadc the look-ahead char
*/
if (!kwd) {
unreadc(c);
if (found)
*--wp = 0;
}
return (found);
past:
switch (Stype) {
case T_BREAK:
stderror(ERR_NAME | ERR_NOTFOUND, "end");
/* NOTREACHED */
case T_ELSE:
stderror(ERR_NAME | ERR_NOTFOUND, "endif");
/* NOTREACHED */
case T_GOTO:
setname(vis_str(Sgoal));
stderror(ERR_NAME | ERR_NOTFOUND, "label");
/* NOTREACHED */
case T_IF:
stderror(ERR_NAME | ERR_NOTFOUND, "then/endif");
/* NOTREACHED */
case T_BRKSW:
case T_SWITCH:
stderror(ERR_NAME | ERR_NOTFOUND, "endsw");
/* NOTREACHED */
}
return (0);
}
/*
* keyword(wp) determines if wp is one of the built-n functions if,
* switch or while. It seems that when an if statement looks like
* "if(" then getword above sucks in the '(' and so the search routine
* never finds what it is scanning for. Rather than rewrite doword, I hack
* in a test to see if the string forms a keyword. Then doword stops
* and returns the word "if" -strike
*/
static int
keyword(Char *wp)
{
static Char STRswitch[] = {'s', 'w', 'i', 't', 'c', 'h', '\0'};
static Char STRwhile[] = {'w', 'h', 'i', 'l', 'e', '\0'};
static Char STRif[] = {'i', 'f', '\0'};
if (!wp)
return (0);
if ((Strcmp(wp, STRif) == 0) || (Strcmp(wp, STRwhile) == 0)
|| (Strcmp(wp, STRswitch) == 0))
return (1);
return (0);
}
static void
toend(void)
{
if (whyles->w_end.type == F_SEEK && whyles->w_end.f_seek == 0) {
search(T_BREAK, 0, NULL);
btell(&whyles->w_end);
whyles->w_end.f_seek--;
}
else
bseek(&whyles->w_end);
wfree();
}
void
wfree(void)
{
struct Ain o;
struct whyle *nwp;
btell(&o);
for (; whyles; whyles = nwp) {
struct whyle *wp = whyles;
nwp = wp->w_next;
/*
* We free loops that have different seek types.
*/
if (wp->w_end.type != I_SEEK && wp->w_start.type == wp->w_end.type &&
wp->w_start.type == o.type) {
if (wp->w_end.type == F_SEEK) {
if (o.f_seek >= wp->w_start.f_seek &&
(wp->w_end.f_seek == 0 || o.f_seek < wp->w_end.f_seek))
break;
}
else {
if (o.a_seek >= wp->w_start.a_seek &&
(wp->w_end.a_seek == 0 || o.a_seek < wp->w_end.a_seek))
break;
}
}
wpfree(wp);
}
}
void
/*ARGSUSED*/
doecho(Char **v, struct command *t)
{
xecho(' ', v);
}
void
/*ARGSUSED*/
doglob(Char **v, struct command *t)
{
xecho(0, v);
(void)fflush(cshout);
}
static void
xecho(int sep, Char **v)
{
Char *cp;
sigset_t nsigset;
int nonl;
nonl = 0;
if (setintr) {
sigemptyset(&nsigset);
(void)sigaddset(&nsigset, SIGINT);
(void)sigprocmask(SIG_UNBLOCK, &nsigset, NULL);
}
v++;
if (*v == 0)
goto done;
gflag = 0, tglob(v);
if (gflag) {
v = globall(v);
if (v == 0)
stderror(ERR_NAME | ERR_NOMATCH);
}
else {
v = gargv = saveblk(v);
trim(v);
}
if (sep == ' ' && *v && eq(*v, STRmn))
nonl++, v++;
while ((cp = *v++) != NULL) {
int c;
while ((c = *cp++) != '\0')
(void)vis_fputc(c | QUOTE, cshout);
if (*v)
(void)vis_fputc(sep | QUOTE, cshout);
}
done:
if (sep && nonl == 0)
(void)fputc('\n', cshout);
else
(void)fflush(cshout);
if (setintr)
(void)sigprocmask(SIG_BLOCK, &nsigset, NULL);
if (gargv)
blkfree(gargv), gargv = 0;
}
void
/*ARGSUSED*/
dosetenv(Char **v, struct command *t)
{
Char *lp, *vp;
sigset_t nsigset;
v++;
if ((vp = *v++) == 0) {
Char **ep;
if (setintr) {
sigemptyset(&nsigset);
(void)sigaddset(&nsigset, SIGINT);
(void)sigprocmask(SIG_UNBLOCK, &nsigset, NULL);
}
for (ep = STR_environ; *ep; ep++)
(void)fprintf(cshout, "%s\n", vis_str(*ep));
return;
}
if ((lp = *v++) == 0)
lp = STRNULL;
Setenv(vp, lp = globone(lp, G_APPEND));
if (eq(vp, STRPATH)) {
importpath(lp);
dohash(NULL, NULL);
}
else if (eq(vp, STRLANG) || eq(vp, STRLC_CTYPE)) {
#ifdef NLS
int k;
(void)setlocale(LC_ALL, "");
for (k = 0200; k <= 0377 && !Isprint(k); k++)
continue;
AsciiOnly = k > 0377;
#else
AsciiOnly = 0;
#endif /* NLS */
}
free(lp);
}
void
/*ARGSUSED*/
dounsetenv(Char **v, struct command *t)
{
static Char *name = NULL;
Char **ep, *p, *n;
int i, maxi;
if (name)
free(name);
/*
* Find the longest environment variable
*/
for (maxi = 0, ep = STR_environ; *ep; ep++) {
for (i = 0, p = *ep; *p && *p != '='; p++, i++)
continue;
if (i > maxi)
maxi = i;
}
name = xreallocarray(NULL, (size_t)(maxi + 1), sizeof(Char));
while (++v && *v)
for (maxi = 1; maxi;)
for (maxi = 0, ep = STR_environ; *ep; ep++) {
for (n = name, p = *ep; *p && *p != '='; *n++ = *p++)
continue;
*n = '\0';
if (!Gmatch(name, *v))
continue;
maxi = 1;
if (eq(name, STRLANG) || eq(name, STRLC_CTYPE)) {
#ifdef NLS
int k;
(void) setlocale(LC_ALL, "");
for (k = 0200; k <= 0377 && !Isprint(k); k++)
continue;
AsciiOnly = k > 0377;
#else
AsciiOnly = getenv("LANG") == NULL &&
getenv("LC_CTYPE") == NULL;
#endif /* NLS */
}
/*
* Delete name, and start again cause the environment changes
*/
Unsetenv(name);
break;
}
free(name);
name = NULL;
}
void
Setenv(Char *name, Char *val)
{
Char *blk[2], *cp, *dp, **ep, **oep;
ep = STR_environ;
oep = ep;
for (; *ep; ep++) {
for (cp = name, dp = *ep; *cp && *cp == *dp; cp++, dp++)
continue;
if (*cp != 0 || *dp != '=')
continue;
cp = Strspl(STRequal, val);
free(* ep);
*ep = strip(Strspl(name, cp));
free(cp);
blkfree((Char **)environ);
environ = short2blk(STR_environ);
return;
}
cp = Strspl(name, STRequal);
blk[0] = strip(Strspl(cp, val));
free(cp);
blk[1] = 0;
STR_environ = blkspl(STR_environ, blk);
blkfree((Char **)environ);
environ = short2blk(STR_environ);
free(oep);
}
static void
Unsetenv(Char *name)
{
Char *cp, *dp, **ep, **oep;
ep = STR_environ;
oep = ep;
for (; *ep; ep++) {
for (cp = name, dp = *ep; *cp && *cp == *dp; cp++, dp++)
continue;
if (*cp != 0 || *dp != '=')
continue;
cp = *ep;
*ep = 0;
STR_environ = blkspl(STR_environ, ep + 1);
environ = short2blk(STR_environ);
*ep = cp;
free(cp);
free(oep);
return;
}
}
void
/*ARGSUSED*/
doumask(Char **v, struct command *t)
{
Char *cp;
mode_t i;
cp = v[1];
if (cp == 0) {
i = umask(0);
(void)umask(i);
(void)fprintf(cshout, "%o\n", i);
return;
}
i = 0;
while (Isdigit(*cp) && *cp != '8' && *cp != '9')
i = i * 8 + (mode_t)(*cp++ - '0');
if (*cp || i > 0777)
stderror(ERR_NAME | ERR_MASK);
(void)umask(i);
}
typedef rlim_t RLIM_TYPE;
static const struct limits {
int limconst;
const char *limname;
int limdiv;
const char *limscale;
} limits[] = {
{ RLIMIT_CPU, "cputime", 1, "seconds" },
{ RLIMIT_FSIZE, "filesize", 1024, "kbytes" },
{ RLIMIT_DATA, "datasize", 1024, "kbytes" },
{ RLIMIT_STACK, "stacksize", 1024, "kbytes" },
{ RLIMIT_CORE, "coredumpsize", 1024, "kbytes" },
{ RLIMIT_RSS, "memoryuse", 1024, "kbytes" },
{ RLIMIT_MEMLOCK, "memorylocked", 1024, "kbytes" },
{ RLIMIT_NPROC, "maxproc", 1, "" },
{ RLIMIT_NTHR, "maxthread", 1, "" },
{ RLIMIT_NOFILE, "openfiles", 1, "" },
{ RLIMIT_SBSIZE, "sbsize", 1, "bytes" },
{ RLIMIT_AS, "vmemoryuse", 1024, "kbytes" },
{ -1, NULL, 0, NULL }
};
static const struct limits *findlim(Char *);
static RLIM_TYPE getval(const struct limits *, Char **);
static void limtail(Char *, const char *);
static void plim(const struct limits *, Char);
static int setlim(const struct limits *, Char, RLIM_TYPE);
static const struct limits *
findlim(Char *cp)
{
const struct limits *lp, *res;
res = NULL;
for (lp = limits; lp->limconst >= 0; lp++)
if (prefix(cp, str2short(lp->limname))) {
if (res)
stderror(ERR_NAME | ERR_AMBIG);
res = lp;
}
if (res)
return (res);
stderror(ERR_NAME | ERR_LIMIT);
/* NOTREACHED */
}
void
/*ARGSUSED*/
dolimit(Char **v, struct command *t)
{
const struct limits *lp;
RLIM_TYPE limit;
char hard;
hard = 0;
v++;
if (*v && eq(*v, STRmh)) {
hard = 1;
v++;
}
if (*v == 0) {
for (lp = limits; lp->limconst >= 0; lp++)
plim(lp, hard);
return;
}
lp = findlim(v[0]);
if (v[1] == 0) {
plim(lp, hard);
return;
}
limit = getval(lp, v + 1);
if (setlim(lp, hard, limit) < 0)
stderror(ERR_SILENT);
}
static RLIM_TYPE
getval(const struct limits *lp, Char **v)
{
Char *cp;
double d;
cp = *v++;
d = atof(short2str(cp));
while (Isdigit(*cp) || *cp == '.' || *cp == 'e' || *cp == 'E')
cp++;
if (*cp == 0) {
if (*v == 0)
return ((RLIM_TYPE)((d + 0.5) * lp->limdiv));
cp = *v;
}
switch (*cp) {
case ':':
if (lp->limconst != RLIMIT_CPU)
goto badscal;
return ((RLIM_TYPE)(d * 60.0 + atof(short2str(cp + 1))));
case 'M':
if (lp->limconst == RLIMIT_CPU)
goto badscal;
*cp = 'm';
limtail(cp, "megabytes");
d *= 1024.0 * 1024.0;
break;
case 'h':
if (lp->limconst != RLIMIT_CPU)
goto badscal;
limtail(cp, "hours");
d *= 3600.0;
break;
case 'k':
if (lp->limconst == RLIMIT_CPU)
goto badscal;
limtail(cp, "kbytes");
d *= 1024.0;
break;
case 'm':
if (lp->limconst == RLIMIT_CPU) {
limtail(cp, "minutes");
d *= 60.0;
break;
}
*cp = 'm';
limtail(cp, "megabytes");
d *= 1024.0 * 1024.0;
break;
case 's':
if (lp->limconst != RLIMIT_CPU)
goto badscal;
limtail(cp, "seconds");
break;
case 'u':
limtail(cp, "unlimited");
return (RLIM_INFINITY);
default:
badscal:
stderror(ERR_NAME | ERR_SCALEF);
/* NOTREACHED */
}
d += 0.5;
if (d > (double) RLIM_INFINITY)
return RLIM_INFINITY;
else
return ((RLIM_TYPE)d);
}
static void
limtail(Char *cp, const char *str)
{
while (*cp && *cp == *str)
cp++, str++;
if (*cp)
stderror(ERR_BADSCALE, str);
}
/*ARGSUSED*/
static void
plim(const struct limits *lp, Char hard)
{
struct rlimit rlim;
RLIM_TYPE limit;
(void)fprintf(cshout, "%-13.13s", lp->limname);
(void)getrlimit(lp->limconst, &rlim);
limit = hard ? rlim.rlim_max : rlim.rlim_cur;
if (limit == RLIM_INFINITY)
(void)fprintf(cshout, "unlimited");
else if (lp->limconst == RLIMIT_CPU)
psecs((long) limit);
else
(void)fprintf(cshout, "%jd %s",
(intmax_t) (limit / (RLIM_TYPE)lp->limdiv), lp->limscale);
(void)fputc('\n', cshout);
}
void
/*ARGSUSED*/
dounlimit(Char **v, struct command *t)
{
const struct limits *lp;
int lerr;
Char hard;
lerr = 0;
hard = 0;
v++;
if (*v && eq(*v, STRmh)) {
hard = 1;
v++;
}
if (*v == 0) {
for (lp = limits; lp->limconst >= 0; lp++)
if (setlim(lp, hard, (RLIM_TYPE)RLIM_INFINITY) < 0)
lerr++;
if (lerr)
stderror(ERR_SILENT);
return;
}
while (*v) {
lp = findlim(*v++);
if (setlim(lp, hard, (RLIM_TYPE)RLIM_INFINITY) < 0)
stderror(ERR_SILENT);
}
}
static int
setlim(const struct limits *lp, Char hard, RLIM_TYPE limit)
{
struct rlimit rlim;
(void)getrlimit(lp->limconst, &rlim);
if (hard)
rlim.rlim_max = limit;
else if (limit == RLIM_INFINITY && geteuid() != 0)
rlim.rlim_cur = rlim.rlim_max;
else
rlim.rlim_cur = limit;
if (rlim.rlim_max < rlim.rlim_cur)
rlim.rlim_max = rlim.rlim_cur;
if (setrlimit(lp->limconst, &rlim) < 0) {
(void)fprintf(csherr, "%s: %s: Can't %s%s limit (%s)\n", bname,
lp->limname, limit == RLIM_INFINITY ? "remove" : "set",
hard ? " hard" : "", strerror(errno));
return (-1);
}
return (0);
}
void
/*ARGSUSED*/
dosuspend(Char **v, struct command *t)
{
int ctpgrp;
void (*old)(int);
if (loginsh)
stderror(ERR_SUSPLOG);
untty();
old = signal(SIGTSTP, SIG_DFL);
(void)kill(0, SIGTSTP);
/* the shell stops here */
(void)signal(SIGTSTP, old);
if (tpgrp != -1) {
retry:
ctpgrp = tcgetpgrp(FSHTTY);
if (ctpgrp != opgrp) {
old = signal(SIGTTIN, SIG_DFL);
(void)kill(0, SIGTTIN);
(void)signal(SIGTTIN, old);
goto retry;
}
(void)setpgid(0, shpgrp);
(void)tcsetpgrp(FSHTTY, shpgrp);
}
}
/* This is the dreaded EVAL built-in.
* If you don't fiddle with file descriptors, and reset didfds,
* this command will either ignore redirection inside or outside
* its arguments, e.g. eval "date >x" vs. eval "date" >x
* The stuff here seems to work, but I did it by trial and error rather
* than really knowing what was going on. If tpgrp is zero, we are
* probably a background eval, e.g. "eval date &", and we want to
* make sure that any processes we start stay in our pgrp.
* This is also the case for "time eval date" -- stay in same pgrp.
* Otherwise, under stty tostop, processes will stop in the wrong
* pgrp, with no way for the shell to get them going again. -IAN!
*/
static Char **gv = NULL;
void
/*ARGSUSED*/
doeval(Char **v, struct command *t)
{
jmp_buf osetexit;
Char *oevalp, **oevalvec, **savegv;
int my_reenter, odidfds, oSHERR, oSHIN, oSHOUT, saveERR, saveIN, saveOUT;
savegv = gv;
UNREGISTER(v);
oevalvec = evalvec;
oevalp = evalp;
odidfds = didfds;
oSHIN = SHIN;
oSHOUT = SHOUT;
oSHERR = SHERR;
v++;
if (*v == 0)
return;
gflag = 0, tglob(v);
if (gflag) {
gv = v = globall(v);
gargv = 0;
if (v == 0)
stderror(ERR_NOMATCH);
v = copyblk(v);
}
else {
gv = NULL;
v = copyblk(v);
trim(v);
}
saveIN = dcopy(SHIN, -1);
saveOUT = dcopy(SHOUT, -1);
saveERR = dcopy(SHERR, -1);
getexit(osetexit);
if ((my_reenter = setexit()) == 0) {
evalvec = v;
evalp = 0;
SHIN = dcopy(0, -1);
SHOUT = dcopy(1, -1);
SHERR = dcopy(2, -1);
didfds = 0;
process(0);
}
evalvec = oevalvec;
evalp = oevalp;
doneinp = 0;
didfds = odidfds;
if (SHIN != -1)
(void)close(SHIN);
if (SHOUT != -1)
(void)close(SHOUT);
if (SHERR != -1)
(void)close(SHERR);
SHIN = dmove(saveIN, oSHIN);
SHOUT = dmove(saveOUT, oSHOUT);
SHERR = dmove(saveERR, oSHERR);
if (gv)
blkfree(gv), gv = NULL;
resexit(osetexit);
gv = savegv;
if (my_reenter)
stderror(ERR_SILENT);
}
void
/*ARGSUSED*/
doprintf(Char **v, struct command *t)
{
char **c;
int ret;
ret = progprintf(blklen(v), c = short2blk(v));
(void)fflush(cshout);
(void)fflush(csherr);
blkfree((Char **)c);
if (ret)
stderror(ERR_SILENT);
}
Reference in New Issue View Git Blame Copy Permalink