diff options
Diffstat (limited to 'usr/src/cmd/csh/sh.c')
| -rw-r--r-- | usr/src/cmd/csh/sh.c | 1398 |
1 files changed, 1398 insertions, 0 deletions
diff --git a/usr/src/cmd/csh/sh.c b/usr/src/cmd/csh/sh.c new file mode 100644 index 0000000000..9d3e30860a --- /dev/null +++ b/usr/src/cmd/csh/sh.c @@ -0,0 +1,1398 @@ +/* + * Copyright 2004 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +/* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */ +/* All Rights Reserved */ + +/* + * Copyright (c) 1980 Regents of the University of California. + * All rights reserved. The Berkeley Software License Agreement + * specifies the terms and conditions for redistribution. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <locale.h> +#include "sh.h" +/* #include <sys/ioctl.h> */ +#include <fcntl.h> +#include <sys/filio.h> +#include "sh.tconst.h" +#include <pwd.h> +#include <stdlib.h> +#include "sh_policy.h" /* for pfcsh */ + +/* + * We use these csh(1) private versions of the select macros, (see select(3C)) + * so as not to be limited by the size of struct fd_set (ie 1024). + */ +#define CSH_FD_SET(n, p) ((*((p) + ((n)/NFDBITS))) |= (1 << ((n) % NFDBITS))) +#define CSH_FD_CLR(n, p) ((*((p) + ((n)/NFDBITS))) &= ~(1 << ((n) % NFDBITS))) +#define CSH_FD_ISSET(n, p) ((*((p) + ((n)/NFDBITS))) & (1 << ((n) % NFDBITS))) +#define CSH_FD_ZERO(p, n) memset((void *)(p), 0, (n)) + +tchar *pathlist[] = { S_usrbin/*"/usr/bin"*/, S_DOT /*"."*/, 0 }; +tchar *dumphist[] = { S_history /*"history"*/, S_h /*"-h"*/, 0, 0 }; +tchar *loadhist[] = { S_source /*"source"*/, S_h /*"-h"*/, S_NDOThistory /*"~/.history"*/, 0 }; +tchar HIST = '!'; +tchar HISTSUB = '^'; +int nofile; +bool reenter; +bool nverbose; +bool nexececho; +bool quitit; +bool fast; +bool batch; +bool prompt = 1; +bool enterhist = 0; + +extern gid_t getegid(), getgid(); +extern uid_t geteuid(), getuid(); +extern tchar **strblktotsblk(/* char **, int */); + +int siglwp(); +int sigwaiting(); + +main(c, av) + int c; + char **av; +{ + register tchar **v, *cp, *p, *q, *r; + register int f; + struct sigvec osv; + struct sigaction sa; + tchar s_prompt[MAXHOSTNAMELEN+3]; + + pfcshflag = 0; + + /* + * set up the error exit, if there is an error before + * this is done, it will core dump, and we don't + * tolerate core dumps + */ + haderr = 0; + setexit(); + if ( haderr ) { + /* + * if were here, there was an error in the csh + * startup so just punt + */ + printf("csh startup error, csh exiting...\n"); + flush(); + exitstat(); + } + + + (void) setlocale(LC_ALL, ""); +#if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ +#define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */ +#endif + (void) textdomain(TEXT_DOMAIN); + + /* + * This is a profile shell if the simple name of argv[0] is + * pfcsh or -pfcsh + */ + p = strtots(NOSTR, "pfcsh"); + r = strtots(NOSTR, "-pfcsh"); + if ((p != NOSTR) && (r != NOSTR) && + ((q = strtots(NOSTR, *av)) != NOSTR)) { + if (c > 0 && (eq(p, simple(q)) || eq(r, simple(q)))) { + pfcshflag = 1; + } + XFREE(q); + } + + if (p != NOSTR) + XFREE(p); + if (r != NOSTR) + XFREE(r); + + if (pfcshflag == 1) { + secpolicy_init(); + } + + /* Copy arguments */ + v = strblktotsblk(av, c); + + /* + * Initialize paraml list + */ + paraml.next = paraml.prev = ¶ml; + + settimes(); /* Immed. estab. timing base */ + + if (eq(v[0], S_aout/*"a.out"*/)) /* A.out's are quittable */ + quitit = 1; + uid = getuid(); + loginsh = **v == '-'; + if (loginsh) + (void) time(&chktim); + + /* + * Move the descriptors to safe places. + * The variable didfds is 0 while we have only FSH* to work with. + * When didfds is true, we have 0,1,2 and prefer to use these. + * + * Also, setup data for csh internal file descriptor book keeping. + */ + initdesc(c, av); + + /* + * Initialize the shell variables. + * ARGV and PROMPT are initialized later. + * STATUS is also munged in several places. + * CHILD is munged when forking/waiting + */ + + /* don't do globbing here, just set exact copies */ + setNS(S_noglob); + + set(S_status /* "status" */, S_0 /* "0" */); + dinit(cp = getenvs_("HOME")); /* dinit thinks that HOME==cwd in a */ + /* login shell */ + if (cp == NOSTR) + fast++; /* No home -> can't read scripts */ + else { + if (strlen_(cp) >= BUFSIZ - 10) { + cp = NOSTR; + fast++; + printf("%s\n", gettext("Pathname too long")); + set(S_home /* "home" */, savestr(cp)); + local_setenv(S_HOME, savestr(cp)); + } + set(S_home /* "home" */, savestr(cp)); + } + /* + * Grab other useful things from the environment. + * Should we grab everything?? + */ + if ((cp = getenvs_("USER")) != NOSTR) + set(S_user/*"user"*/, savestr(cp)); + else { + /* + * If USER is not defined, set it here. + */ + struct passwd *pw; + pw = getpwuid(getuid()); + + if (pw != NULL) { + set(S_user, strtots((tchar *)0, pw->pw_name )); + local_setenv(S_USER, strtots((tchar *)0, pw->pw_name)); + } + else if (loginsh) { /* Give up setting USER variable. */ + printf("Warning: USER environment variable could not be set.\n"); + } + } + if ((cp = getenvs_("TERM")) != NOSTR) + set(S_term/*"term"*/, savestr(cp)); + /* + * Re-initialize path if set in environment + */ + if ((cp = getenvs_("PATH")) == NOSTR) + set1(S_path/*"path"*/, saveblk(pathlist), &shvhed); + else + importpath(cp); + set(S_shell/*"shell"*/, S_SHELLPATH); + + doldol = putn(getpid()); /* For $$ */ + + /* restore globbing until the user says otherwise */ + unsetv(S_noglob); + + /* + * Record the interrupt states from the parent process. + * If the parent is non-interruptible our hand must be forced + * or we (and our children) won't be either. + * Our children inherit termination from our parent. + * We catch it only if we are the login shell. + */ + /* parents interruptibility */ + (void) sigvec(SIGINT, (struct sigvec *)0, &osv); + parintr = osv.sv_handler; + /* parents terminability */ + (void) sigvec(SIGTERM, (struct sigvec *)0, &osv); + parterm = osv.sv_handler; + + _signal(SIGLWP, siglwp); + _signal(SIGWAITING, sigwaiting); + if (loginsh) { + (void) signal(SIGHUP, phup); /* exit processing on HUP */ + (void) signal(SIGXCPU, phup); /* ...and on XCPU */ + (void) signal(SIGXFSZ, phup); /* ...and on XFSZ */ + } + + /* + * Process the arguments. + * + * Note that processing of -v/-x is actually delayed till after + * script processing. + */ + c--, v++; + while (c > 0 && (cp = v[0])[0] == '-' && *++cp != '\0' && !batch) { + do switch (*cp++) { + + case 'b': /* -b Next arg is input file */ + batch++; + break; + + case 'c': /* -c Command input from arg */ + if (c == 1) + exit(0); + c--, v++; + arginp = v[0]; + prompt = 0; + nofile++; + cflg++; + break; + + case 'e': /* -e Exit on any error */ + exiterr++; + break; + + case 'f': /* -f Fast start */ + fast++; + break; + + case 'i': /* -i Interactive, even if !intty */ + intact++; + nofile++; + break; + + case 'n': /* -n Don't execute */ + noexec++; + break; + + case 'q': /* -q (Undoc'd) ... die on quit */ + quitit = 1; + break; + + case 's': /* -s Read from std input */ + nofile++; + break; + + case 't': /* -t Read one line from input */ + onelflg = 2; + prompt = 0; + nofile++; + break; +#ifdef TRACE + case 'T': /* -T trace switch on */ + trace_init(); + break; +#endif + + case 'v': /* -v Echo hist expanded input */ + nverbose = 1; /* ... later */ + break; + + case 'x': /* -x Echo just before execution */ + nexececho = 1; /* ... later */ + break; + + case 'V': /* -V Echo hist expanded input */ + setNS(S_verbose/*"verbose"*/); /* NOW! */ + break; + + case 'X': /* -X Echo just before execution */ + setNS(S_echo/*"echo"*/); /* NOW! */ + break; + + } while (*cp); + v++, c--; + } + + if (quitit) /* With all due haste, for debugging */ + (void) signal(SIGQUIT, SIG_DFL); + + /* + * Unless prevented by -c, -i, -s, or -t, if there + * are remaining arguments the first of them is the name + * of a shell file from which to read commands. + */ + if (!batch && (uid != geteuid() || getgid() != getegid())) { + errno = EACCES; + child++; /* So this ... */ + Perror(S_csh/*"csh"*/); /* ... doesn't return */ + } + + if (nofile == 0 && c > 0) { + nofile = open_(v[0], 0); + if (nofile < 0) { + child++; /* So this ... */ + Perror(v[0]); /* ... doesn't return */ + } + file = v[0]; + SHIN = dmove(nofile, FSHIN); /* Replace FSHIN */ + (void) fcntl(SHIN, F_SETFD, 1); + prompt = 0; + c--, v++; + } + + /* + * Consider input a tty if it really is or we are interactive. + */ + intty = intact || isatty(SHIN); + + /* + * Decide whether we should play with signals or not. + * If we are explicitly told (via -i, or -) or we are a login + * shell (arg0 starts with -) or the input and output are both + * the ttys("csh", or "csh</dev/ttyx>/dev/ttyx") + * Note that in only the login shell is it likely that parent + * may have set signals to be ignored + */ + if (loginsh || intact || intty && isatty(SHOUT)) + setintr = 1; +#ifdef TELL + settell(); +#endif + /* + * Save the remaining arguments in argv. + */ + setq(S_argv/*"argv"*/, v, &shvhed); + + /* + * Set up the prompt. + */ + if (prompt) { + gethostname_(s_prompt, MAXHOSTNAMELEN); + strcat_(s_prompt, uid == 0 ? S_SHARPSP/*"# "*/ : S_PERSENTSP/*"% "*/); + set(S_prompt/*"prompt"*/, s_prompt); + } + + /* + * If we are an interactive shell, then start fiddling + * with the signals; this is a tricky game. + */ + shpgrp = getpgid(0); + opgrp = tpgrp = -1; + if (setintr) { + **av = '-'; + if (!quitit) /* Wary! */ + (void) signal(SIGQUIT, SIG_IGN); + (void) signal(SIGINT, pintr); + (void) sigblock(sigmask(SIGINT)); + (void) signal(SIGTERM, SIG_IGN); + if (quitit == 0 && arginp == 0) { + (void) signal(SIGTSTP, SIG_IGN); + (void) signal(SIGTTIN, SIG_IGN); + (void) signal(SIGTTOU, SIG_IGN); + /* + * Wait till in foreground, in case someone + * stupidly runs + * csh & + * dont want to try to grab away the tty. + */ + if (isatty(FSHDIAG)) + f = FSHDIAG; + else if (isatty(FSHOUT)) + f = FSHOUT; + else if (isatty(OLDSTD)) + f = OLDSTD; + else + f = -1; +retry: + if (ioctl(f, TIOCGPGRP, (char *)&tpgrp) == 0 && + tpgrp != -1) { + if (tpgrp != shpgrp) { + void (*old)() = (void (*)())signal(SIGTTIN, SIG_DFL); + (void) kill(0, SIGTTIN); + (void) signal(SIGTTIN, old); + goto retry; + } + opgrp = shpgrp; + shpgrp = getpid(); + tpgrp = shpgrp; + (void) setpgid(0, shpgrp); + (void) ioctl(f, TIOCSPGRP, (char *)&shpgrp); + (void) fcntl(dcopy(f, FSHTTY), F_SETFD, 1); + } else { +notty: + printf("Warning: no access to tty; thus no job control in this shell...\n"); + tpgrp = -1; + } + } + } + if (setintr == 0 && parintr == SIG_DFL) + setintr++; + + /* + * Set SIGCHLD handler, making sure that reads restart after it runs. + */ + sigemptyset(&sa.sa_mask); + sa.sa_handler = pchild; + sa.sa_flags = SA_RESTART; + (void) sigaction(SIGCHLD, &sa, (struct sigaction *) NULL); + + /* + * Set an exit here in case of an interrupt or error reading + * the shell start-up scripts. + */ + setexit(); + haderr = 0; /* In case second time through */ + if (!fast && reenter == 0) { + reenter++; + + /* + * If this is a login csh, and /etc/.login exists, + * source /etc/.login first. + */ + if (loginsh) { + tchar tmp_etc[4+1]; /*strlen("/etc")+1 */ + tchar tmp_login[7+1]; /*strlen("/.login")+1*/ + + strtots(tmp_etc, "/etc"); + strtots(tmp_login, "/.login"); + srccat_inlogin(tmp_etc, tmp_login); + } + + /* Will have value("home") here because set fast if don't */ + srccat(value(S_home/*"home"*/), S_SLADOTcshrc/*"/.cshrc"*/); + + /*Hash path*/ + if (!fast && !arginp && !onelflg && !havhash) + dohash(xhash); + + + /* + * Reconstruct the history list now, so that it's + * available from within .login. + */ + dosource(loadhist); + if (loginsh) { + srccat_inlogin(value(S_home/*"home"*/), S_SLADOTlogin/*"/.login"*/); + } + + /* + * To get cdpath hashing $cdpath must have a + * value, not $CDPATH. So if after reading + * the startup files ( .cshrc ), and + * user has specified a value for cdpath, then + * cache $cdpath paths. xhash2 is global array + * for $cdpath caching. + */ + if (!fast && !arginp && !onelflg && !havhash2 ) + dohash(xhash2); + } + + /* + * Now are ready for the -v and -x flags + */ + if (nverbose) + setNS(S_verbose/*"verbose"*/); + if (nexececho) + setNS(S_echo/*"echo"*/); + + /* + * All the rest of the world is inside this call. + * The argument to process indicates whether it should + * catch "error unwinds". Thus if we are a interactive shell + * our call here will never return by being blown past on an error. + */ + process(setintr); + + /* + * Mop-up. + */ + if (loginsh) { + printf("logout\n"); + (void) close(SHIN); /* No need for unsetfd(). */ + child++; + goodbye(); + } + rechist(); + exitstat(); +} + +untty() +{ + + if (tpgrp > 0) { + (void) setpgid(0, opgrp); + (void) ioctl(FSHTTY, TIOCSPGRP, (char *)&opgrp); + } +} + +importpath(cp) + tchar *cp; +{ + register int i = 0; + register tchar *dp; + register tchar **pv; + int c; + static tchar dot[2] = {'.', 0}; + + for (dp = cp; *dp; dp++) + if (*dp == ':') + i++; + /* + * i+2 where i is the number of colons in the path. + * There are i+1 directories in the path plus we need + * room for a zero terminator. + */ + pv = (tchar **) calloc((unsigned) (i + 2), sizeof (tchar **)); + dp = cp; + i = 0; + if (*dp) + for (;;) { + if ((c = *dp) == ':' || c == 0) { + *dp = 0; + pv[i++] = savestr(*cp ? cp : dot); + if (c) { + cp = dp + 1; + *dp = ':'; + } else + break; + } + dp++; + } + pv[i] = 0; + set1(S_path /*"path"*/, pv, &shvhed); +} + +/* + * Source to the file which is the catenation of the argument names. + */ +srccat(cp, dp) + tchar *cp, *dp; +{ + register tchar *ep = strspl(cp, dp); + register int unit = dmove(open_(ep, 0), -1); + + (void) fcntl(unit, F_SETFD, 1); + xfree(ep); +#ifdef INGRES + srcunit(unit, 0, 0); +#else + srcunit(unit, 1, 0); +#endif +} + +/* + * Source to the file which is the catenation of the argument names. + * This one does not check the ownership. + */ +srccat_inlogin(cp, dp) + tchar *cp, *dp; +{ + register tchar *ep = strspl(cp, dp); + register int unit = dmove(open_(ep, 0), -1); + + (void) fcntl(unit, F_SETFD, 1); + xfree(ep); + srcunit(unit, 0, 0); +} + +/* + * Source to a unit. If onlyown it must be our file or our group or + * we don't chance it. This occurs on ".cshrc"s and the like. + */ +srcunit(unit, onlyown, hflg) + register int unit; + bool onlyown; + bool hflg; +{ + /* We have to push down a lot of state here */ + /* All this could go into a structure */ + int oSHIN = -1, oldintty = intty; + struct whyle *oldwhyl = whyles; + tchar *ogointr = gointr, *oarginp = arginp; + tchar *oevalp = evalp, **oevalvec = evalvec; + int oonelflg = onelflg; + bool oenterhist = enterhist; + tchar OHIST = HIST; +#ifdef TELL + bool otell = cantell; +#endif + struct Bin saveB; + + /* The (few) real local variables */ + jmp_buf oldexit; + int reenter, omask; + + if (unit < 0) + return; + if (didfds) + donefds(); + if (onlyown) { + struct stat stb; + + if (fstat(unit, &stb) < 0 || + (stb.st_uid != uid && stb.st_gid != getgid())) { + (void) close(unit); + unsetfd(unit); + return; + } + } + + /* + * There is a critical section here while we are pushing down the + * input stream since we have stuff in different structures. + * If we weren't careful an interrupt could corrupt SHIN's Bin + * structure and kill the shell. + * + * We could avoid the critical region by grouping all the stuff + * in a single structure and pointing at it to move it all at + * once. This is less efficient globally on many variable references + * however. + */ + getexit(oldexit); + reenter = 0; + if (setintr) + omask = sigblock(sigmask(SIGINT)); + setexit(); + reenter++; + if (reenter == 1) { + /* Setup the new values of the state stuff saved above */ + copy( (char *)&saveB, (char *)&B, sizeof saveB); + fbuf = (tchar **) 0; + fseekp = feobp = fblocks = 0; + oSHIN = SHIN, SHIN = unit, arginp = 0, onelflg = 0; + intty = isatty(SHIN), whyles = 0, gointr = 0; + evalvec = 0; evalp = 0; + enterhist = hflg; + if (enterhist) + HIST = '\0'; + /* + * Now if we are allowing commands to be interrupted, + * we let ourselves be interrupted. + */ + if (setintr) + (void) sigsetmask(omask); +#ifdef TELL + settell(); +#endif + process(0); /* 0 -> blow away on errors */ + } + if (setintr) + (void) sigsetmask(omask); + if (oSHIN >= 0) { + register int i; + + /* We made it to the new state... free up its storage */ + /* This code could get run twice but xfree doesn't care */ + for (i = 0; i < fblocks; i++) + xfree(fbuf[i]); + xfree( (char *)fbuf); + + /* Reset input arena */ + copy( (char *)&B, (char *)&saveB, sizeof B); + + (void) close(SHIN), SHIN = oSHIN; + unsetfd(SHIN); + arginp = oarginp, onelflg = oonelflg; + evalp = oevalp, evalvec = oevalvec; + intty = oldintty, whyles = oldwhyl, gointr = ogointr; + if (enterhist) + HIST = OHIST; + enterhist = oenterhist; +#ifdef TELL + cantell = otell; +#endif + } + + resexit(oldexit); + /* + * If process reset() (effectively an unwind) then + * we must also unwind. + */ + if (reenter >= 2) + error(NULL); +} + +rechist() +{ + tchar buf[BUFSIZ]; + int fp, ftmp, oldidfds; + + if (!fast) { + if (value(S_savehist/*"savehist"*/)[0] == '\0') + return; + (void) strcpy_(buf, value(S_home/*"home"*/)); + (void) strcat_(buf, S_SLADOThistory/*"/.history"*/); + fp = creat_(buf, 0666); + if (fp == -1) + return; + oldidfds = didfds; + didfds = 0; + ftmp = SHOUT; + SHOUT = fp; + (void) strcpy_(buf, value(S_savehist/*"savehist"*/)); + dumphist[2] = buf; + dohist(dumphist); + (void) close(fp); + unsetfd(fp); + SHOUT = ftmp; + didfds = oldidfds; + } +} + +goodbye() +{ + if (loginsh) { + (void) signal(SIGQUIT, SIG_IGN); + (void) signal(SIGINT, SIG_IGN); + (void) signal(SIGTERM, SIG_IGN); + setintr = 0; /* No interrupts after "logout" */ + if (adrof(S_home/*"home"*/)) + srccat(value(S_home/*"home"*/), S_SLADOTlogout/*"/.logout"*/); + } + rechist(); + exitstat(); +} + +exitstat() +{ + +#ifdef PROF + monitor(0); +#endif + /* + * Note that if STATUS is corrupted (i.e. getn bombs) + * then error will exit directly because we poke child here. + * Otherwise we might continue unwarrantedly (sic). + */ + child++; + untty(); + exit(getn(value(S_status/*"status"*/))); +} + +/* + * in the event of a HUP we want to save the history + */ +void +phup() +{ + rechist(); + exit(1); +} + +tchar *jobargv[2] = { S_jobs/*"jobs"*/, 0 }; +/* + * Catch an interrupt, e.g. during lexical input. + * If we are an interactive shell, we reset the interrupt catch + * immediately. In any case we drain the shell output, + * and finally go through the normal error mechanism, which + * gets a chance to make the shell go away. + */ +void +pintr() +{ + pintr1(1); +} + +pintr1(wantnl) + bool wantnl; +{ + register tchar **v; + int omask; + + omask = sigblock(0); + if (setintr) { + (void) sigsetmask(omask & ~sigmask(SIGINT)); + if (pjobs) { + pjobs = 0; + printf("\n"); + dojobs(jobargv); + bferr("Interrupted"); + } + } + (void) sigsetmask(omask & ~sigmask(SIGCHLD)); + draino(); + + /* + * If we have an active "onintr" then we search for the label. + * Note that if one does "onintr -" then we shan't be interruptible + * so we needn't worry about that here. + */ + if (gointr) { + search(ZGOTO, 0, gointr); + timflg = 0; + if (v = pargv) + pargv = 0, blkfree(v); + if (v = gargv) + gargv = 0, blkfree(v); + reset(); + } else if (intty && wantnl) + printf("\n"); /* Some like this, others don't */ + error(NULL); +} + +/* + * Process is the main driving routine for the shell. + * It runs all command processing, except for those within { ... } + * in expressions (which is run by a routine evalav in sh.exp.c which + * is a stripped down process), and `...` evaluation which is run + * also by a subset of this code in sh.glob.c in the routine backeval. + * + * The code here is a little strange because part of it is interruptible + * and hence freeing of structures appears to occur when none is necessary + * if this is ignored. + * + * Note that if catch is not set then we will unwind on any error. + * If an end-of-file occurs, we return. + */ +process(catch) + bool catch; +{ + jmp_buf osetexit; + register struct command *t; + + getexit(osetexit); + for (;;) { + pendjob(); + paraml.next = paraml.prev = ¶ml; + paraml.word = S_ /*""*/; + t = 0; + setexit(); + justpr = enterhist; /* execute if not entering history */ + + /* + * Interruptible during interactive reads + */ + if (setintr) + (void) sigsetmask(sigblock(0) & ~sigmask(SIGINT)); + + /* + * For the sake of reset() + */ + freelex(¶ml), freesyn(t), t = 0; + + if (haderr) { + if (!catch) { + /* unwind */ + doneinp = 0; + resexit(osetexit); + reset(); + } + haderr = 0; + /* + * Every error is eventually caught here or + * the shell dies. It is at this + * point that we clean up any left-over open + * files, by closing all but a fixed number + * of pre-defined files. Thus routines don't + * have to worry about leaving files open due + * to deeper errors... they will get closed here. + */ + closem(); + continue; + } + if (doneinp) { + doneinp = 0; + break; + } + if (chkstop) + chkstop--; + if (neednote) + pnote(); + if (intty && prompt && evalvec == 0) { + mailchk(); + /* + * If we are at the end of the input buffer + * then we are going to read fresh stuff. + * Otherwise, we are rereading input and don't + * need or want to prompt. + */ + if (fseekp == feobp) + printprompt(); + } + err = 0; + + /* + * Echo not only on VERBOSE, but also with history expansion. + */ + if (lex(¶ml) && intty || + adrof(S_verbose /*"verbose"*/)) { + haderr = 1; + prlex(¶ml); + haderr = 0; + } + + /* + * The parser may lose space if interrupted. + */ + if (setintr) + (void) sigblock(sigmask(SIGINT)); + + /* + * Save input text on the history list if + * reading in old history, or it + * is from the terminal at the top level and not + * in a loop. + */ + if (enterhist || catch && intty && !whyles) + savehist(¶ml); + + /* + * Print lexical error messages, except when sourcing + * history lists. + */ + if (!enterhist && err) + error("%s", gettext(err)); + + /* + * If had a history command :p modifier then + * this is as far as we should go + */ + if (justpr) + reset(); + + alias(¶ml); + + /* + * Parse the words of the input into a parse tree. + */ + t = syntax(paraml.next, ¶ml, 0); + if (err) + error("%s", gettext(err)); + + /* + * Execute the parse tree + */ + { + /* + * POSIX requires SIGCHLD to be held + * until all processes have joined the + * process group in order to avoid race + * condition. + */ + int omask; + + omask = sigblock(sigmask(SIGCHLD)); + execute(t, tpgrp); + (void)sigsetmask(omask &~ sigmask(SIGCHLD)); + } + + if (err) + error("%s", gettext(err)); + /* + * Made it! + */ + freelex(¶ml), freesyn(t); + } + resexit(osetexit); +} + +dosource(t) + register tchar **t; +{ + register tchar *f; + register int u; + bool hflg = 0; + tchar buf[BUFSIZ]; + + t++; + if (*t && eq(*t, S_h /*"-h"*/)) { + if (*++t == NOSTR) + bferr("Too few arguments."); + hflg++; + } + (void) strcpy_(buf, *t); + f = globone(buf); + u = dmove(open_(f, 0), -1); + xfree(f); + freelex(¶ml); + if (u < 0 && !hflg) + Perror(f); + (void) fcntl(u, F_SETFD, 1); + srcunit(u, 0, hflg); +} + +/* + * Check for mail. + * If we are a login shell, then we don't want to tell + * about any mail file unless its been modified + * after the time we started. + * This prevents us from telling the user things he already + * knows, since the login program insists on saying + * "You have mail." + */ +mailchk() +{ + register struct varent *v; + register tchar **vp; + time_t t; + int intvl, cnt; + struct stat stb; + bool new; + + v = adrof(S_mail /*"mail"*/); + if (v == 0) + return; + (void) time(&t); + vp = v->vec; + cnt = blklen(vp); + intvl = (cnt && number(*vp)) ? (--cnt, getn(*vp++)) : MAILINTVL; + if (intvl < 1) + intvl = 1; + if (chktim + intvl > t) + return; + for (; *vp; vp++) { + if (stat_(*vp, &stb) < 0) + continue; + new = stb.st_mtime > time0.tv_sec; + if (stb.st_size == 0 || stb.st_atime >= stb.st_mtime || + (stb.st_atime <= chktim && stb.st_mtime <= chktim) || + loginsh && !new) + continue; + if (cnt == 1) + printf("You have %smail.\n", new ? "new " : ""); + else + printf("%s in %t.\n", new ? "New mail" : "Mail", *vp); + } + chktim = t; +} + +/* + * Extract a home directory from the password file + * The argument points to a buffer where the name of the + * user whose home directory is sought is currently. + * We write the home directory of the user back there. + */ +gethdir(home) + tchar *home; +{ + /* getpwname will not be modified, so we need temp. buffer */ + char home_str[BUFSIZ]; + tchar home_ts[BUFSIZ]; + register struct passwd *pp /*= getpwnam(home)*/; + + pp = getpwnam(tstostr(home_str, home)); + if (pp == 0) + return (1); + (void) strcpy_(home, strtots(home_ts, pp->pw_dir)); + return (0); +} + + +/* +#ifdef PROF +done(i) +#else +exit(i) +#endif + int i; +{ + + untty(); + _exit(i); +} +*/ + +printprompt() +{ + register tchar *cp; + + if (!whyles) { + /* + * Print the prompt string + */ + for (cp = value(S_prompt /*"prompt"*/); *cp; cp++) + if (*cp == HIST) + printf("%d", eventno + 1); + else { + if (*cp == '\\' && cp[1] == HIST) + cp++; + Putchar(*cp | QUOTE); + } + } else + /* + * Prompt for forward reading loop + * body content. + */ + printf("? "); + flush(); +} + +/* + * Save char * block. + */ +tchar ** +strblktotsblk(v, num) + register char **v; + int num; +{ + register tchar **newv = + (tchar **) calloc((unsigned) (num+ 1), sizeof (tchar **)); + tchar **onewv = newv; + + while (*v && num--) + *newv++ = strtots(NOSTR,*v++); + *newv = 0; + return (onewv); +} + + +sigwaiting() +{ + _signal(SIGWAITING, sigwaiting); +} + +siglwp() +{ + _signal(SIGLWP, siglwp); +} + + +/* + * Following functions and data are used for csh to do its + * file descriptors book keeping. + */ + +static int *fdinuse = NULL; /* The list of files opened by csh */ +static int nbytesused = 0; /* no of bytes allocated to fdinuse */ +static int max_fd = 0; /* The maximum descriptor in fdinuse */ +static int my_pid; /* The process id set in initdesc() */ +static int NoFile = NOFILE; /* The number of files I can use. */ + +/* + * Get the number of files this csh can use. + * + * Move the initial descriptors to their eventual + * resting places, closing all other units. + * + * Also, reserve 0/1/2, so NIS+ routines do not get + * hold of them. And initialize fdinuse list and set + * the current process id. + * + * If this csh was invoked from setuid'ed script file, + * do not close the third argument passed. The file + * must be one of /dev/fd/0,1,2,,, + * (execv() always passes three arguments when it execs a script + * file in a form of #! /bin/csh -b.) + * + * If is_reinit is set in initdesc_x(), then we only close the file + * descriptors that we actually opened (as recorded in fdinuse). + */ +initdesc(argc, argv) + int argc; + char *argv[]; +{ + initdesc_x(argc, argv, 0); +} + +reinitdesc(argc, argv) + int argc; + char *argv[]; +{ + initdesc_x(argc, argv, 1); +} + +/* + * Callback functions for closing all file descriptors. + */ +static int +close_except(void *cd, int fd) +{ + int script_fd = *(int *)cd; + + if (fd >= 3 && fd < NoFile && fd != script_fd) + (void) close(fd); + return (0); +} + +static int +close_inuse(void *cd, int fd) +{ + int script_fd = *(int *)cd; + + if (fd >= 3 && fd < NoFile && fd != script_fd && + CSH_FD_ISSET(fd, fdinuse)) { + (void) close(fd); + unsetfd(fd); + } + return (0); +} + +initdesc_x(argc, argv, is_reinit) + int argc; + char *argv[]; + int is_reinit; +{ + + int script_fd = -1; + struct stat buf; + struct rlimit rlp; + + /* + * Get pid of this shell + */ + my_pid = getpid(); + + /* + * Get the hard limit numbers of descriptors + * this csh can use. + */ + if (getrlimit(RLIMIT_NOFILE, &rlp) == 0) + NoFile = rlp.rlim_cur; + + /* + * If this csh was invoked for executing setuid script file, + * the third argument passed is the special file name + * which should not be closed. This special file name is + * in the form /dev/fd/X. + */ + if (argc >= 3) + if (sscanf(argv[2], "/dev/fd/%d", &script_fd) != 1) + script_fd = -1; + else + fcntl(script_fd, F_SETFD, 1); /* Make sure to close + * this file on exec. + */ + + if (fdinuse == NULL) { + nbytesused = sizeof(int) * howmany(NoFile, sizeof(int) * NBBY); + fdinuse = (int *) xalloc(nbytesused); + } + + /* + * Close all files except 0/1/2 to get a clean + * file descritor space. + */ + if (!is_reinit) + (void) fdwalk(close_except, &script_fd); + else + (void) fdwalk(close_inuse, &script_fd); + + didfds = 0; /* 0, 1, 2 aren't set up */ + + if (fstat(0, &buf) < 0) + open("/dev/null", 0); + + (void) fcntl(SHIN = dcopy(0, FSHIN), F_SETFD, 1); + (void) fcntl(SHOUT = dcopy(1, FSHOUT), F_SETFD, 1); + (void) fcntl(SHDIAG = dcopy(2, FSHDIAG), F_SETFD, 1); + (void) fcntl(OLDSTD = dcopy(SHIN, FOLDSTD), F_SETFD, 1); + + /* + * Open 0/1/2 to avoid Nis+ functions to pick them up. + * Now, 0/1/2 are saved, close them and open them. + */ + close(0); close(1); close(2); + open("/dev/null", 0); + dup(0); + dup(0); + + /* + * Clear fd_set mask + */ + if ( ! is_reinit) + CSH_FD_ZERO(fdinuse, nbytesused); +} + +/* + * This routine is called after an error to close up + * any units which may have been left open accidentally. + * + * You only need to remove files in fdinuse list. + * After you have removed the files, you can clear the + * list and max_fd. + */ +closem() +{ + register int f; + + for (f = 3; f <= max_fd; f++) { + if (CSH_FD_ISSET(f, fdinuse) && + f != SHIN && f != SHOUT && f != SHDIAG && + f != OLDSTD && f != FSHTTY) + close(f); + } + CSH_FD_ZERO(fdinuse, nbytesused); + max_fd = 0; +} + +/* + * Reset my_pid when a new process is created. Only call this + * if you want the process to affect fdinuse (e.g., fork, but + * not vfork). + */ +new_process() +{ + my_pid = getpid(); +} + + +/* + * Whenever Csh open/create/dup/pipe a file or files, + * Csh keeps track of its open files. The open files + * are kept in "fdinuse, Fd In Use" list. + * + * When a file descriptor is newly allocated, setfd() is + * used to mark the fact in "fdinuse" list. + * For example, + * fd = open("newfile", 0); + * setfd(fd); + * + * When a file is freed by close() function, unsetfd() is + * used to remove the fd from "fdinuse" list. + * For example, + * close(fd); + * unsetfd(fd); + */ +setfd(fd) + int fd; +{ + /* + * Because you want to avoid + * conflict due to vfork(). + */ + if (my_pid != getpid()) + return; + + if (fd >= NoFile || fd < 0) + return; + + if (fd > max_fd) + max_fd = fd; + CSH_FD_SET(fd, fdinuse); +} + +unsetfd(fd) + int fd; +{ + register int i; + + /* + * Because you want to avoid + * conflict due to vfork(). + */ + if (my_pid != getpid()) + return; + + if (fd >= NoFile || fd < 0) + return; + + CSH_FD_CLR(fd, fdinuse); + if (fd == max_fd) { + for (i = max_fd-1; i >= 3; i--) + if (CSH_FD_ISSET(i, fdinuse)) { + max_fd = i; + return; + } + max_fd = 0; + } +} + +/* + * A generic call back routine to output error messages from the + * policy backing functions called by pfcsh. + */ +void +secpolicy_print(int level, const char *msg) +{ + switch (level) { + case SECPOLICY_WARN: + default: + haderr = 1; + printf("%s: ", msg); /* printf() does gettext() */ + break; + case SECPOLICY_ERROR: + bferr(msg); /* bferr() does gettext() */ + break; + } +} |