summaryrefslogtreecommitdiffstats
path: root/contrib/tcsh/tc.func.c
diff options
context:
space:
mode:
Diffstat (limited to 'contrib/tcsh/tc.func.c')
-rw-r--r--contrib/tcsh/tc.func.c2125
1 files changed, 2125 insertions, 0 deletions
diff --git a/contrib/tcsh/tc.func.c b/contrib/tcsh/tc.func.c
new file mode 100644
index 0000000..2dcb03f
--- /dev/null
+++ b/contrib/tcsh/tc.func.c
@@ -0,0 +1,2125 @@
+/* $Header: /src/pub/tcsh/tc.func.c,v 3.87 1999/08/14 21:24:13 christos Exp $ */
+/*
+ * tc.func.c: New tcsh builtins.
+ */
+/*-
+ * Copyright (c) 1980, 1991 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. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. 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 "sh.h"
+
+RCSID("$Id: tc.func.c,v 3.87 1999/08/14 21:24:13 christos Exp $")
+
+#include "ed.h"
+#include "ed.defns.h" /* for the function names */
+#include "tw.h"
+#include "tc.h"
+#ifdef WINNT
+#include "nt.const.h"
+#endif /* WINNT */
+
+#ifdef AFS
+#define PASSMAX 16
+#include <afs/stds.h>
+#include <afs/kautils.h>
+long ka_UserAuthenticateGeneral();
+#else
+#ifndef PASSMAX
+#define PASSMAX 8
+#endif
+#endif /* AFS */
+
+#ifdef TESLA
+extern int do_logout;
+#endif /* TESLA */
+extern time_t t_period;
+extern int just_signaled;
+static bool precmd_active = 0;
+static bool postcmd_active = 0;
+static bool periodic_active = 0;
+static bool cwdcmd_active = 0; /* PWP: for cwd_cmd */
+static bool beepcmd_active = 0;
+static signalfun_t alm_fun = NULL;
+
+static void auto_logout __P((int));
+static char *xgetpass __P((char *));
+static void auto_lock __P((int));
+#ifdef BSDJOBS
+static void insert __P((struct wordent *, bool));
+static void insert_we __P((struct wordent *, struct wordent *));
+static int inlist __P((Char *, Char *));
+#endif /* BSDJOBS */
+struct tildecache;
+static int tildecompare __P((struct tildecache *, struct tildecache *));
+static Char *gethomedir __P((Char *));
+#ifdef REMOTEHOST
+static sigret_t palarm __P((int));
+static void getremotehost __P((void));
+#endif /* REMOTEHOST */
+
+/*
+ * Tops-C shell
+ */
+
+/*
+ * expand_lex: Take the given lex and put an expanded version of it in the
+ * string buf. First guy in lex list is ignored; last guy is ^J which we
+ * ignore Only take lex'es from position from to position to inclusive Note:
+ * csh sometimes sets bit 8 in characters which causes all kinds of problems
+ * if we don't mask it here. Note: excl's in lexes have been un-back-slashed
+ * and must be re-back-slashed
+ * (PWP: NOTE: this returns a pointer to the END of the string expanded
+ * (in other words, where the NUL is).)
+ */
+/* PWP: this is a combination of the old sprlex() and the expand_lex from
+ the magic-space stuff */
+
+Char *
+expand_lex(buf, bufsiz, sp0, from, to)
+ Char *buf;
+ size_t bufsiz;
+ struct wordent *sp0;
+ int from, to;
+{
+ register struct wordent *sp;
+ register Char *s, *d, *e;
+ register Char prev_c;
+ register int i;
+
+ buf[0] = '\0';
+ prev_c = '\0';
+ d = buf;
+ e = &buf[bufsiz]; /* for bounds checking */
+
+ if (!sp0)
+ return (buf); /* null lex */
+ if ((sp = sp0->next) == sp0)
+ return (buf); /* nada */
+ if (sp == (sp0 = sp0->prev))
+ return (buf); /* nada */
+
+ for (i = 0; i < NCARGS; i++) {
+ if ((i >= from) && (i <= to)) { /* if in range */
+ for (s = sp->word; *s && d < e; s++) {
+ /*
+ * bugfix by Michael Bloom: anything but the current history
+ * character {(PWP) and backslash} seem to be dealt with
+ * elsewhere.
+ */
+ if ((*s & QUOTE)
+ && (((*s & TRIM) == HIST) ||
+ (((*s & TRIM) == '\'') && (prev_c != '\\')) ||
+ (((*s & TRIM) == '\"') && (prev_c != '\\')) ||
+ (((*s & TRIM) == '\\') && (prev_c != '\\')))) {
+ *d++ = '\\';
+ }
+ if (d < e)
+ *d++ = (*s & TRIM);
+ prev_c = *s;
+ }
+ if (d < e)
+ *d++ = ' ';
+ }
+ sp = sp->next;
+ if (sp == sp0)
+ break;
+ }
+ if (d > buf)
+ d--; /* get rid of trailing space */
+
+ return (d);
+}
+
+Char *
+sprlex(buf, bufsiz, sp0)
+ Char *buf;
+ size_t bufsiz;
+ struct wordent *sp0;
+{
+ Char *cp;
+
+ cp = expand_lex(buf, bufsiz, sp0, 0, NCARGS);
+ *cp = '\0';
+ return (buf);
+}
+
+
+Char *
+Itoa(n, s, min_digits, attributes)
+ int n;
+ Char *s;
+ int min_digits, attributes;
+{
+ /*
+ * The array size here is derived from
+ * log8(UINT_MAX)
+ * which is guaranteed to be enough for a decimal
+ * representation. We add 1 because integer divide
+ * rounds down.
+ */
+#ifndef CHAR_BIT
+# define CHAR_BIT 8
+#endif
+ Char buf[CHAR_BIT * sizeof(int) / 3 + 1];
+ Char *p;
+ unsigned int un; /* handle most negative # too */
+ int pad = (min_digits != 0);
+
+ if (sizeof(buf) - 1 < min_digits)
+ min_digits = sizeof(buf) - 1;
+
+ un = n;
+ if (n < 0) {
+ un = -n;
+ *s++ = '-';
+ }
+
+ p = buf;
+ do {
+ *p++ = un % 10 + '0';
+ un /= 10;
+ } while ((pad && --min_digits > 0) || un != 0);
+
+ while (p > buf)
+ *s++ = *--p | attributes;
+
+ *s = '\0';
+ return s;
+}
+
+
+/*ARGSUSED*/
+void
+dolist(v, c)
+ register Char **v;
+ struct command *c;
+{
+ int i, k;
+ struct stat st;
+#if defined(KANJI) && defined(SHORT_STRINGS) && defined(DSPMBYTE)
+ extern bool dspmbyte_ls;
+#endif
+#ifdef COLOR_LS_F
+ extern bool color_context_ls;
+#endif /* COLOR_LS_F */
+
+ USE(c);
+ if (*++v == NULL) {
+ (void) t_search(STRNULL, NULL, LIST, 0, TW_ZERO, 0, STRNULL, 0);
+ return;
+ }
+ gflag = 0;
+ tglob(v);
+ if (gflag) {
+ v = globall(v);
+ if (v == 0)
+ stderror(ERR_NAME | ERR_NOMATCH);
+ }
+ else
+ v = gargv = saveblk(v);
+ trim(v);
+ for (k = 0; v[k] != NULL && v[k][0] != '-'; k++)
+ continue;
+ if (v[k]) {
+ /*
+ * We cannot process a flag therefore we let ls do it right.
+ */
+ static Char STRls[] = {'l', 's', '\0'};
+ static Char STRmCF[] = {'-', 'C', 'F', '\0', '\0' };
+ Char *lspath;
+ struct command *t;
+ struct wordent cmd, *nextword, *lastword;
+ Char *cp;
+ struct varent *vp;
+
+#ifdef BSDSIGS
+ sigmask_t omask = 0;
+
+ if (setintr)
+ omask = sigblock(sigmask(SIGINT)) & ~sigmask(SIGINT);
+#else /* !BSDSIGS */
+ (void) sighold(SIGINT);
+#endif /* BSDSIGS */
+ if (seterr) {
+ xfree((ptr_t) seterr);
+ seterr = NULL;
+ }
+
+ lspath = STRls;
+ STRmCF[1] = 'C';
+ STRmCF[3] = '\0';
+ /* Look at listflags, to add -A to the flags, to get a path
+ of ls if necessary */
+ if ((vp = adrof(STRlistflags)) != NULL && vp->vec[0] != STRNULL) {
+ if (vp->vec[1] != NULL && vp->vec[1][0] != '\0')
+ lspath = vp->vec[1];
+ for (cp = vp->vec[0]; *cp; cp++)
+ switch (*cp) {
+ case 'x':
+ STRmCF[1] = 'x';
+ break;
+ case 'a':
+ STRmCF[3] = 'a';
+ break;
+ case 'A':
+ STRmCF[3] = 'A';
+ break;
+ default:
+ break;
+ }
+ }
+
+ cmd.word = STRNULL;
+ lastword = &cmd;
+ nextword = (struct wordent *) xcalloc(1, sizeof cmd);
+ nextword->word = Strsave(lspath);
+ lastword->next = nextword;
+ nextword->prev = lastword;
+ lastword = nextword;
+ nextword = (struct wordent *) xcalloc(1, sizeof cmd);
+ nextword->word = Strsave(STRmCF);
+ lastword->next = nextword;
+ nextword->prev = lastword;
+#if defined(KANJI) && defined(SHORT_STRINGS) && defined(DSPMBYTE)
+ if (dspmbyte_ls) {
+ lastword = nextword;
+ nextword = (struct wordent *) xcalloc(1, sizeof cmd);
+ nextword->word = Strsave(STRmmliteral);
+ lastword->next = nextword;
+ nextword->prev = lastword;
+ }
+#endif
+#ifdef COLOR_LS_F
+ if (color_context_ls) {
+ lastword = nextword;
+ nextword = (struct wordent *) xcalloc(1, sizeof cmd);
+ nextword->word = Strsave(STRmmcolormauto);
+ lastword->next = nextword;
+ nextword->prev = lastword;
+ }
+#endif /* COLOR_LS_F */
+ lastword = nextword;
+ for (cp = *v; cp; cp = *++v) {
+ nextword = (struct wordent *) xcalloc(1, sizeof cmd);
+ nextword->word = Strsave(cp);
+ lastword->next = nextword;
+ nextword->prev = lastword;
+ lastword = nextword;
+ }
+ lastword->next = &cmd;
+ cmd.prev = lastword;
+
+ /* build a syntax tree for the command. */
+ t = syntax(cmd.next, &cmd, 0);
+ if (seterr)
+ stderror(ERR_OLD);
+ /* expand aliases like process() does */
+ /* alias(&cmd); */
+ /* execute the parse tree. */
+ execute(t, tpgrp > 0 ? tpgrp : -1, NULL, NULL);
+ /* done. free the lex list and parse tree. */
+ freelex(&cmd), freesyn(t);
+ if (setintr)
+#ifdef BSDSIGS
+ (void) sigsetmask(omask);
+#else /* !BSDSIGS */
+ (void) sigrelse(SIGINT);
+#endif /* BSDSIGS */
+ }
+ else {
+ Char *dp, *tmp, buf[MAXPATHLEN];
+
+ for (k = 0, i = 0; v[k] != NULL; k++) {
+ tmp = dnormalize(v[k], symlinks == SYM_IGNORE);
+ dp = &tmp[Strlen(tmp) - 1];
+ if (*dp == '/' && dp != tmp)
+#ifdef apollo
+ if (dp != &tmp[1])
+#endif /* apollo */
+ *dp = '\0';
+ if (stat(short2str(tmp), &st) == -1) {
+ if (k != i) {
+ if (i != 0)
+ xputchar('\n');
+ print_by_column(STRNULL, &v[i], k - i, FALSE);
+ }
+ xprintf("%S: %s.\n", tmp, strerror(errno));
+ i = k + 1;
+ }
+ else if (S_ISDIR(st.st_mode)) {
+ Char *cp;
+
+ if (k != i) {
+ if (i != 0)
+ xputchar('\n');
+ print_by_column(STRNULL, &v[i], k - i, FALSE);
+ }
+ if (k != 0 && v[1] != NULL)
+ xputchar('\n');
+ xprintf("%S:\n", tmp);
+ for (cp = tmp, dp = buf; *cp; *dp++ = (*cp++ | QUOTE))
+ continue;
+ if (
+#ifdef WINNT
+ (dp[-1] != (Char) (':' | QUOTE)) &&
+#endif /* WINNT */
+ (dp[-1] != (Char) ('/' | QUOTE)))
+ *dp++ = '/';
+ else
+ dp[-1] &= TRIM;
+ *dp = '\0';
+ (void) t_search(buf, NULL, LIST, 0, TW_ZERO, 0, STRNULL, 0);
+ i = k + 1;
+ }
+ xfree((ptr_t) tmp);
+ }
+ if (k != i) {
+ if (i != 0)
+ xputchar('\n');
+ print_by_column(STRNULL, &v[i], k - i, FALSE);
+ }
+ }
+
+ if (gargv) {
+ blkfree(gargv);
+ gargv = 0;
+ }
+}
+
+static char *defaulttell = "ALL";
+extern bool GotTermCaps;
+
+/*ARGSUSED*/
+void
+dotelltc(v, c)
+ register Char **v;
+ struct command *c;
+{
+ USE(c);
+ if (!GotTermCaps)
+ GetTermCaps();
+
+ /*
+ * Avoid a compiler bug on hpux 9.05
+ * Writing the following as func(a ? b : c) breaks
+ */
+ if (v[1])
+ TellTC(short2str(v[1]));
+ else
+ TellTC(defaulttell);
+}
+
+/*ARGSUSED*/
+void
+doechotc(v, c)
+ register Char **v;
+ struct command *c;
+{
+ if (!GotTermCaps)
+ GetTermCaps();
+ EchoTC(++v);
+}
+
+/*ARGSUSED*/
+void
+dosettc(v, c)
+ Char **v;
+ struct command *c;
+{
+ char tv[2][BUFSIZE];
+
+ if (!GotTermCaps)
+ GetTermCaps();
+
+ (void) strcpy(tv[0], short2str(v[1]));
+ (void) strcpy(tv[1], short2str(v[2]));
+ SetTC(tv[0], tv[1]);
+}
+
+/* The dowhich() is by:
+ * Andreas Luik <luik@isaak.isa.de>
+ * I S A GmbH - Informationssysteme fuer computerintegrierte Automatisierung
+ * Azenberstr. 35
+ * D-7000 Stuttgart 1
+ * West-Germany
+ * Thanks!!
+ */
+int
+cmd_expand(cmd, str)
+ Char *cmd;
+ Char *str;
+{
+ struct wordent lexp[3];
+ struct varent *vp;
+ int rv = TRUE;
+
+ lexp[0].next = &lexp[1];
+ lexp[1].next = &lexp[2];
+ lexp[2].next = &lexp[0];
+
+ lexp[0].prev = &lexp[2];
+ lexp[1].prev = &lexp[0];
+ lexp[2].prev = &lexp[1];
+
+ lexp[0].word = STRNULL;
+ lexp[2].word = STRret;
+
+ if ((vp = adrof1(cmd, &aliases)) != NULL) {
+ if (str == NULL) {
+ xprintf(CGETS(22, 1, "%S: \t aliased to "), cmd);
+ blkpr(vp->vec);
+ xputchar('\n');
+ }
+ else
+ blkexpand(vp->vec, str);
+ }
+ else {
+ lexp[1].word = cmd;
+ rv = tellmewhat(lexp, str);
+ }
+ return rv;
+}
+
+
+/*ARGSUSED*/
+void
+dowhich(v, c)
+ register Char **v;
+ struct command *c;
+{
+ int rv = TRUE;
+ USE(c);
+
+#ifdef notdef
+ /*
+ * We don't want to glob dowhich args because we lose quoteing
+ * E.g. which \ls if ls is aliased will not work correctly if
+ * we glob here.
+ */
+ gflag = 0, tglob(v);
+ if (gflag) {
+ v = globall(v);
+ if (v == 0)
+ stderror(ERR_NAME | ERR_NOMATCH);
+ }
+ else {
+ v = gargv = saveblk(v);
+ trim(v);
+ }
+#endif
+
+ while (*++v)
+ rv &= cmd_expand(*v, NULL);
+
+ if (!rv)
+ set(STRstatus, Strsave(STR1), VAR_READWRITE);
+
+#ifdef notdef
+ /* Again look at the comment above; since we don't glob, we don't free */
+ if (gargv)
+ blkfree(gargv), gargv = 0;
+#endif
+}
+
+/* PWP: a hack to start up your stopped editor on a single keystroke */
+/* jbs - fixed hack so it worked :-) 3/28/89 */
+
+struct process *
+find_stop_ed()
+{
+ register struct process *pp, *retp;
+ register char *ep, *vp, *cp, *p;
+ int epl, vpl, pstatus;
+
+ if ((ep = getenv("EDITOR")) != NULL) { /* if we have a value */
+ if ((p = strrchr(ep, '/')) != NULL) /* if it has a path */
+ ep = p + 1; /* then we want only the last part */
+ }
+ else
+ ep = "ed";
+
+ if ((vp = getenv("VISUAL")) != NULL) { /* if we have a value */
+ if ((p = strrchr(vp, '/')) != NULL) /* and it has a path */
+ vp = p + 1; /* then we want only the last part */
+ }
+ else
+ vp = "vi";
+
+ for (vpl = 0; vp[vpl] && !Isspace(vp[vpl]); vpl++)
+ continue;
+ for (epl = 0; ep[epl] && !Isspace(ep[epl]); epl++)
+ continue;
+
+ if (pcurrent == NULL) /* see if we have any jobs */
+ return NULL; /* nope */
+
+ retp = NULL;
+ for (pp = proclist.p_next; pp; pp = pp->p_next)
+ if (pp->p_procid == pp->p_jobid) {
+
+ /*
+ * Only foreground an edit session if it is suspended. Some GUI
+ * editors have may be happily running in a separate window, no
+ * point in foregrounding these if they're already running - webb
+ */
+ pstatus = (int) (pp->p_flags & PALLSTATES);
+ if (pstatus != PINTERRUPTED && pstatus != PSTOPPED &&
+ pstatus != PSIGNALED)
+ continue;
+
+ p = short2str(pp->p_command);
+ /* get the first word */
+ for (cp = p; *cp && !isspace((unsigned char) *cp); cp++)
+ continue;
+ *cp = '\0';
+
+ if ((cp = strrchr(p, '/')) != NULL) /* and it has a path */
+ cp = cp + 1; /* then we want only the last part */
+ else
+ cp = p; /* else we get all of it */
+
+ /* if we find either in the current name, fg it */
+ if (strncmp(ep, cp, (size_t) epl) == 0 ||
+ strncmp(vp, cp, (size_t) vpl) == 0) {
+
+ /*
+ * If there is a choice, then choose the current process if
+ * available, or the previous process otherwise, or else
+ * anything will do - Robert Webb (robertw@mulga.cs.mu.oz.au).
+ */
+ if (pp == pcurrent)
+ return pp;
+ else if (retp == NULL || pp == pprevious)
+ retp = pp;
+ }
+ }
+
+ return retp; /* Will be NULL if we didn't find a job */
+}
+
+void
+fg_proc_entry(pp)
+ register struct process *pp;
+{
+#ifdef BSDSIGS
+ sigmask_t omask;
+#endif
+ jmp_buf_t osetexit;
+ bool ohaderr;
+ Char oGettingInput;
+
+ getexit(osetexit);
+
+#ifdef BSDSIGS
+ omask = sigblock(sigmask(SIGINT));
+#else
+ (void) sighold(SIGINT);
+#endif
+ oGettingInput = GettingInput;
+ GettingInput = 0;
+
+ ohaderr = haderr; /* we need to ignore setting of haderr due to
+ * process getting stopped by a signal */
+ if (setexit() == 0) { /* come back here after pjwait */
+ pendjob();
+ (void) alarm(0); /* No autologout */
+ if (!pstart(pp, 1)) {
+ pp->p_procid = 0;
+ stderror(ERR_BADJOB, pp->p_command, strerror(errno));
+ }
+ pjwait(pp);
+ }
+ setalarm(1); /* Autologout back on */
+ resexit(osetexit);
+ haderr = ohaderr;
+ GettingInput = oGettingInput;
+
+#ifdef BSDSIGS
+ (void) sigsetmask(omask);
+#else /* !BSDSIGS */
+ (void) sigrelse(SIGINT);
+#endif /* BSDSIGS */
+
+}
+
+static char *
+xgetpass(prm)
+ char *prm;
+{
+ static char pass[PASSMAX + 1];
+ int fd, i;
+ signalfun_t sigint;
+
+ sigint = (signalfun_t) sigset(SIGINT, SIG_IGN);
+ (void) Rawmode(); /* Make sure, cause we want echo off */
+ if ((fd = open("/dev/tty", O_RDWR)) == -1)
+ fd = SHIN;
+
+ xprintf("%s", prm); flush();
+ for (i = 0;;) {
+ if (read(fd, &pass[i], 1) < 1 || pass[i] == '\n')
+ break;
+ if (i < PASSMAX)
+ i++;
+ }
+
+ pass[i] = '\0';
+
+ if (fd != SHIN)
+ (void) close(fd);
+ (void) sigset(SIGINT, sigint);
+
+ return(pass);
+}
+
+/*
+ * Ask the user for his login password to continue working
+ * On systems that have a shadow password, this will only
+ * work for root, but what can we do?
+ *
+ * If we fail to get the password, then we log the user out
+ * immediately
+ */
+/*ARGSUSED*/
+static void
+auto_lock(n)
+ int n;
+{
+#ifndef NO_CRYPT
+
+ int i;
+ char *srpp = NULL;
+ struct passwd *pw;
+#ifdef POSIX
+ extern char *crypt __P((const char *, const char *));
+#else
+ extern char *crypt __P(());
+#endif
+
+#undef XCRYPT
+
+#if defined(PW_AUTH) && !defined(XCRYPT)
+
+ struct authorization *apw;
+ extern char *crypt16 __P((const char *, const char *));
+
+# define XCRYPT(a, b) crypt16(a, b)
+
+ if ((pw = getpwuid(euid)) != NULL && /* effective user passwd */
+ (apw = getauthuid(euid)) != NULL) /* enhanced ultrix passwd */
+ srpp = apw->a_password;
+
+#endif /* PW_AUTH && !XCRYPT */
+
+#if defined(PW_SHADOW) && !defined(XCRYPT)
+
+ struct spwd *spw;
+
+# define XCRYPT(a, b) crypt(a, b)
+
+ if ((pw = getpwuid(euid)) != NULL && /* effective user passwd */
+ (spw = getspnam(pw->pw_name)) != NULL) /* shadowed passwd */
+ srpp = spw->sp_pwdp;
+
+#endif /* PW_SHADOW && !XCRYPT */
+
+#ifndef XCRYPT
+
+#define XCRYPT(a, b) crypt(a, b)
+
+ if ((pw = getpwuid(euid)) != NULL) /* effective user passwd */
+ srpp = pw->pw_passwd;
+
+#endif /* !XCRYPT */
+
+ if (srpp == NULL) {
+ auto_logout(0);
+ /*NOTREACHED*/
+ return;
+ }
+
+ setalarm(0); /* Not for locking any more */
+#ifdef BSDSIGS
+ (void) sigsetmask(sigblock(0) & ~(sigmask(SIGALRM)));
+#else /* !BSDSIGS */
+ (void) sigrelse(SIGALRM);
+#endif /* BSDSIGS */
+ xputchar('\n');
+ for (i = 0; i < 5; i++) {
+ const char *crpp;
+ char *pp;
+#ifdef AFS
+ char *afsname;
+ Char *safs;
+
+ if ((safs = varval(STRafsuser)) != STRNULL)
+ afsname = short2str(safs);
+ else
+ if ((afsname = getenv("AFSUSER")) == NULL)
+ afsname = pw->pw_name;
+#endif
+ pp = xgetpass("Password:");
+
+ crpp = XCRYPT(pp, srpp);
+ if ((strcmp(crpp, srpp) == 0)
+#ifdef AFS
+ || (ka_UserAuthenticateGeneral(KA_USERAUTH_VERSION,
+ afsname, /* name */
+ NULL, /* instance */
+ NULL, /* realm */
+ pp, /* password */
+ 0, /* lifetime */
+ 0, 0, /* spare */
+ NULL) /* reason */
+ == 0)
+#endif /* AFS */
+ ) {
+ (void) memset(pp, 0, PASSMAX);
+ if (GettingInput && !just_signaled) {
+ (void) Rawmode();
+ ClearLines();
+ ClearDisp();
+ Refresh();
+ }
+ just_signaled = 0;
+ return;
+ }
+ xprintf(CGETS(22, 2, "\nIncorrect passwd for %s\n"), pw->pw_name);
+ }
+#endif /* NO_CRYPT */
+ auto_logout(0);
+ USE(n);
+}
+
+
+static void
+auto_logout(n)
+ int n;
+{
+ USE(n);
+ xprintf("auto-logout\n");
+ /* Don't leave the tty in raw mode */
+ if (editing)
+ (void) Cookedmode();
+ (void) close(SHIN);
+ set(STRlogout, Strsave(STRautomatic), VAR_READWRITE);
+ child = 1;
+#ifdef TESLA
+ do_logout = 1;
+#endif /* TESLA */
+ GettingInput = FALSE; /* make flush() work to write hist files. Huber*/
+ goodbye(NULL, NULL);
+}
+
+sigret_t
+/*ARGSUSED*/
+alrmcatch(snum)
+int snum;
+{
+#ifdef UNRELSIGS
+ if (snum)
+ (void) sigset(SIGALRM, alrmcatch);
+#endif /* UNRELSIGS */
+
+ (*alm_fun)(0);
+
+ setalarm(1);
+#ifndef SIGVOID
+ return (snum);
+#endif /* !SIGVOID */
+}
+
+/*
+ * Karl Kleinpaste, 21oct1983.
+ * Added precmd(), which checks for the alias
+ * precmd in aliases. If it's there, the alias
+ * is executed as a command. This is done
+ * after mailchk() and just before print-
+ * ing the prompt. Useful for things like printing
+ * one's current directory just before each command.
+ */
+void
+precmd()
+{
+#ifdef BSDSIGS
+ sigmask_t omask;
+
+ omask = sigblock(sigmask(SIGINT));
+#else /* !BSDSIGS */
+ (void) sighold(SIGINT);
+#endif /* BSDSIGS */
+ if (precmd_active) { /* an error must have been caught */
+ aliasrun(2, STRunalias, STRprecmd);
+ xprintf(CGETS(22, 3, "Faulty alias 'precmd' removed.\n"));
+ goto leave;
+ }
+ precmd_active = 1;
+ if (!whyles && adrof1(STRprecmd, &aliases))
+ aliasrun(1, STRprecmd, NULL);
+leave:
+ precmd_active = 0;
+#ifdef BSDSIGS
+ (void) sigsetmask(omask);
+#else /* !BSDSIGS */
+ (void) sigrelse(SIGINT);
+#endif /* BSDSIGS */
+}
+
+void
+postcmd()
+{
+#ifdef BSDSIGS
+ sigmask_t omask;
+
+ omask = sigblock(sigmask(SIGINT));
+#else /* !BSDSIGS */
+ (void) sighold(SIGINT);
+#endif /* BSDSIGS */
+ if (postcmd_active) { /* an error must have been caught */
+ aliasrun(2, STRunalias, STRpostcmd);
+ xprintf(CGETS(22, 3, "Faulty alias 'postcmd' removed.\n"));
+ goto leave;
+ }
+ postcmd_active = 1;
+ if (!whyles && adrof1(STRpostcmd, &aliases))
+ aliasrun(1, STRpostcmd, NULL);
+leave:
+ postcmd_active = 0;
+#ifdef BSDSIGS
+ (void) sigsetmask(omask);
+#else /* !BSDSIGS */
+ (void) sigrelse(SIGINT);
+#endif /* BSDSIGS */
+}
+
+/*
+ * Paul Placeway 11/24/87 Added cwd_cmd by hacking precmd() into
+ * submission... Run every time $cwd is set (after it is set). Useful
+ * for putting your machine and cwd (or anything else) in an xterm title
+ * space.
+ */
+void
+cwd_cmd()
+{
+#ifdef BSDSIGS
+ sigmask_t omask;
+
+ omask = sigblock(sigmask(SIGINT));
+#else /* !BSDSIGS */
+ (void) sighold(SIGINT);
+#endif /* BSDSIGS */
+ if (cwdcmd_active) { /* an error must have been caught */
+ aliasrun(2, STRunalias, STRcwdcmd);
+ xprintf(CGETS(22, 4, "Faulty alias 'cwdcmd' removed.\n"));
+ goto leave;
+ }
+ cwdcmd_active = 1;
+ if (!whyles && adrof1(STRcwdcmd, &aliases))
+ aliasrun(1, STRcwdcmd, NULL);
+leave:
+ cwdcmd_active = 0;
+#ifdef BSDSIGS
+ (void) sigsetmask(omask);
+#else /* !BSDSIGS */
+ (void) sigrelse(SIGINT);
+#endif /* BSDSIGS */
+}
+
+/*
+ * Joachim Hoenig 07/16/91 Added beep_cmd, run every time tcsh wishes
+ * to beep the terminal bell. Useful for playing nice sounds instead.
+ */
+void
+beep_cmd()
+{
+#ifdef BSDSIGS
+ sigmask_t omask;
+
+ omask = sigblock(sigmask(SIGINT));
+#else /* !BSDSIGS */
+ (void) sighold(SIGINT);
+#endif /* BSDSIGS */
+ if (beepcmd_active) { /* an error must have been caught */
+ aliasrun(2, STRunalias, STRbeepcmd);
+ xprintf(CGETS(22, 5, "Faulty alias 'beepcmd' removed.\n"));
+ }
+ else {
+ beepcmd_active = 1;
+ if (!whyles && adrof1(STRbeepcmd, &aliases))
+ aliasrun(1, STRbeepcmd, NULL);
+ }
+ beepcmd_active = 0;
+#ifdef BSDSIGS
+ (void) sigsetmask(omask);
+#else /* !BSDSIGS */
+ (void) sigrelse(SIGINT);
+#endif /* BSDSIGS */
+}
+
+
+/*
+ * Karl Kleinpaste, 18 Jan 1984.
+ * Added period_cmd(), which executes the alias "periodic" every
+ * $tperiod minutes. Useful for occasional checking of msgs and such.
+ */
+void
+period_cmd()
+{
+ register Char *vp;
+ time_t t, interval;
+#ifdef BSDSIGS
+ sigmask_t omask;
+
+ omask = sigblock(sigmask(SIGINT));
+#else /* !BSDSIGS */
+ (void) sighold(SIGINT);
+#endif /* BSDSIGS */
+ if (periodic_active) { /* an error must have been caught */
+ aliasrun(2, STRunalias, STRperiodic);
+ xprintf(CGETS(22, 6, "Faulty alias 'periodic' removed.\n"));
+ goto leave;
+ }
+ periodic_active = 1;
+ if (!whyles && adrof1(STRperiodic, &aliases)) {
+ vp = varval(STRtperiod);
+ if (vp == STRNULL) {
+ aliasrun(1, STRperiodic, NULL);
+ goto leave;
+ }
+ interval = getn(vp);
+ (void) time(&t);
+ if (t - t_period >= interval * 60) {
+ t_period = t;
+ aliasrun(1, STRperiodic, NULL);
+ }
+ }
+leave:
+ periodic_active = 0;
+#ifdef BSDSIGS
+ (void) sigsetmask(omask);
+#else /* !BSDSIGS */
+ (void) sigrelse(SIGINT);
+#endif /* BSDSIGS */
+}
+
+/*
+ * Karl Kleinpaste, 21oct1983.
+ * Set up a one-word alias command, for use for special things.
+ * This code is based on the mainline of process().
+ */
+void
+aliasrun(cnt, s1, s2)
+ int cnt;
+ Char *s1, *s2;
+{
+ struct wordent w, *new1, *new2; /* for holding alias name */
+ struct command *t = NULL;
+ jmp_buf_t osetexit;
+ int status;
+
+ getexit(osetexit);
+ if (seterr) {
+ xfree((ptr_t) seterr);
+ seterr = NULL; /* don't repeatedly print err msg. */
+ }
+ w.word = STRNULL;
+ new1 = (struct wordent *) xcalloc(1, sizeof w);
+ new1->word = Strsave(s1);
+ if (cnt == 1) {
+ /* build a lex list with one word. */
+ w.next = w.prev = new1;
+ new1->next = new1->prev = &w;
+ }
+ else {
+ /* build a lex list with two words. */
+ new2 = (struct wordent *) xcalloc(1, sizeof w);
+ new2->word = Strsave(s2);
+ w.next = new2->prev = new1;
+ new1->next = w.prev = new2;
+ new1->prev = new2->next = &w;
+ }
+
+ /* Save the old status */
+ status = getn(varval(STRstatus));
+
+ /* expand aliases like process() does. */
+ alias(&w);
+ /* build a syntax tree for the command. */
+ t = syntax(w.next, &w, 0);
+ if (seterr)
+ stderror(ERR_OLD);
+
+ psavejob();
+
+
+ /* catch any errors here */
+ if (setexit() == 0)
+ /* execute the parse tree. */
+ /*
+ * From: Michael Schroeder <mlschroe@immd4.informatik.uni-erlangen.de>
+ * was execute(t, tpgrp);
+ */
+ execute(t, tpgrp > 0 ? tpgrp : -1, NULL, NULL);
+ /* done. free the lex list and parse tree. */
+ freelex(&w), freesyn(t);
+ if (haderr) {
+ haderr = 0;
+ /*
+ * Either precmd, or cwdcmd, or periodic had an error. Call it again so
+ * that it is removed
+ */
+ if (precmd_active)
+ precmd();
+ if (postcmd_active)
+ postcmd();
+#ifdef notdef
+ /*
+ * XXX: On the other hand, just interrupting them causes an error too.
+ * So if we hit ^C in the middle of cwdcmd or periodic the alias gets
+ * removed. We don't want that. Note that we want to remove precmd
+ * though, cause that could lead into an infinite loop. This should be
+ * fixed correctly, but then haderr should give us the whole exit
+ * status not just true or false.
+ */
+ else if (cwdcmd_active)
+ cwd_cmd();
+ else if (beepcmd_active)
+ beep_cmd();
+ else if (periodic_active)
+ period_cmd();
+#endif /* notdef */
+ }
+ /* reset the error catcher to the old place */
+ resexit(osetexit);
+ prestjob();
+ pendjob();
+ /* Restore status */
+ set(STRstatus, putn(status), VAR_READWRITE);
+}
+
+void
+setalarm(lck)
+ int lck;
+{
+ struct varent *vp;
+ Char *cp;
+ unsigned alrm_time = 0, logout_time, lock_time;
+ time_t cl, nl, sched_dif;
+
+ if ((vp = adrof(STRautologout)) != NULL) {
+ if ((cp = vp->vec[0]) != 0) {
+ if ((logout_time = (unsigned) atoi(short2str(cp)) * 60) > 0) {
+ alrm_time = logout_time;
+ alm_fun = auto_logout;
+ }
+ }
+ if ((cp = vp->vec[1]) != 0) {
+ if ((lock_time = (unsigned) atoi(short2str(cp)) * 60) > 0) {
+ if (lck) {
+ if (alrm_time == 0 || lock_time < alrm_time) {
+ alrm_time = lock_time;
+ alm_fun = auto_lock;
+ }
+ }
+ else /* lock_time always < alrm_time */
+ if (alrm_time)
+ alrm_time -= lock_time;
+ }
+ }
+ }
+ if ((nl = sched_next()) != -1) {
+ (void) time(&cl);
+ sched_dif = nl > cl ? nl - cl : 0;
+ if ((alrm_time == 0) || ((unsigned) sched_dif < alrm_time)) {
+ alrm_time = ((unsigned) sched_dif) + 1;
+ alm_fun = sched_run;
+ }
+ }
+ (void) alarm(alrm_time); /* Autologout ON */
+}
+
+#undef RMDEBUG /* For now... */
+
+void
+rmstar(cp)
+ struct wordent *cp;
+{
+ struct wordent *we, *args;
+ register struct wordent *tmp, *del;
+
+#ifdef RMDEBUG
+ static Char STRrmdebug[] = {'r', 'm', 'd', 'e', 'b', 'u', 'g', '\0'};
+ Char *tag;
+#endif /* RMDEBUG */
+ Char *charac;
+ char c;
+ int ask, doit, star = 0, silent = 0;
+
+ if (!adrof(STRrmstar))
+ return;
+#ifdef RMDEBUG
+ tag = varval(STRrmdebug);
+#endif /* RMDEBUG */
+ we = cp->next;
+ while (*we->word == ';' && we != cp)
+ we = we->next;
+ while (we != cp) {
+#ifdef RMDEBUG
+ if (*tag)
+ xprintf(CGETS(22, 7, "parsing command line\n"));
+#endif /* RMDEBUG */
+ if (!Strcmp(we->word, STRrm)) {
+ args = we->next;
+ ask = (*args->word != '-');
+ while (*args->word == '-' && !silent) { /* check options */
+ for (charac = (args->word + 1); *charac && !silent; charac++)
+ silent = (*charac == 'i' || *charac == 'f');
+ args = args->next;
+ }
+ ask = (ask || (!ask && !silent));
+ if (ask) {
+ for (; !star && *args->word != ';'
+ && args != cp; args = args->next)
+ if (!Strcmp(args->word, STRstar))
+ star = 1;
+ if (ask && star) {
+ xprintf(CGETS(22, 8,
+ "Do you really want to delete all files? [n/y] "));
+ flush();
+ (void) force_read(SHIN, &c, 1);
+ /*
+ * Perhaps we should use the yesexpr from the
+ * actual locale
+ */
+ doit = (strchr(CGETS(22, 14, "Yy"), c) != NULL);
+ while (c != '\n' && force_read(SHIN, &c, 1) == 1)
+ continue;
+ if (!doit) {
+ /* remove the command instead */
+#ifdef RMDEBUG
+ if (*tag)
+ xprintf(CGETS(22, 9,
+ "skipping deletion of files!\n"));
+#endif /* RMDEBUG */
+ for (tmp = we;
+ *tmp->word != '\n' &&
+ *tmp->word != ';' && tmp != cp;) {
+ tmp->prev->next = tmp->next;
+ tmp->next->prev = tmp->prev;
+ xfree((ptr_t) tmp->word);
+ del = tmp;
+ tmp = tmp->next;
+ xfree((ptr_t) del);
+ }
+ if (*tmp->word == ';') {
+ tmp->prev->next = tmp->next;
+ tmp->next->prev = tmp->prev;
+ xfree((ptr_t) tmp->word);
+ del = tmp;
+ xfree((ptr_t) del);
+ }
+ }
+ }
+ }
+ }
+ for (we = we->next;
+ *we->word != ';' && we != cp;
+ we = we->next)
+ continue;
+ if (*we->word == ';')
+ we = we->next;
+ }
+#ifdef RMDEBUG
+ if (*tag) {
+ xprintf(CGETS(22, 10, "command line now is:\n"));
+ for (we = cp->next; we != cp; we = we->next)
+ xprintf("%S ", we->word);
+ }
+#endif /* RMDEBUG */
+ return;
+}
+
+#ifdef BSDJOBS
+/* Check if command is in continue list
+ and do a "aliasing" if it exists as a job in background */
+
+#undef CNDEBUG /* For now */
+void
+continue_jobs(cp)
+ struct wordent *cp;
+{
+ struct wordent *we;
+ register struct process *pp, *np;
+ Char *cmd, *continue_list, *continue_args_list;
+
+#ifdef CNDEBUG
+ Char *tag;
+ static Char STRcndebug[] =
+ {'c', 'n', 'd', 'e', 'b', 'u', 'g', '\0'};
+#endif /* CNDEBUG */
+ bool in_cont_list, in_cont_arg_list;
+
+
+#ifdef CNDEBUG
+ tag = varval(STRcndebug);
+#endif /* CNDEBUG */
+ continue_list = varval(STRcontinue);
+ continue_args_list = varval(STRcontinue_args);
+ if (*continue_list == '\0' && *continue_args_list == '\0')
+ return;
+
+ we = cp->next;
+ while (*we->word == ';' && we != cp)
+ we = we->next;
+ while (we != cp) {
+#ifdef CNDEBUG
+ if (*tag)
+ xprintf(CGETS(22, 11, "parsing command line\n"));
+#endif /* CNDEBUG */
+ cmd = we->word;
+ in_cont_list = inlist(continue_list, cmd);
+ in_cont_arg_list = inlist(continue_args_list, cmd);
+ if (in_cont_list || in_cont_arg_list) {
+#ifdef CNDEBUG
+ if (*tag)
+ xprintf(CGETS(22, 12, "in one of the lists\n"));
+#endif /* CNDEBUG */
+ np = NULL;
+ for (pp = proclist.p_next; pp; pp = pp->p_next) {
+ if (prefix(cmd, pp->p_command)) {
+ if (pp->p_index) {
+ np = pp;
+ break;
+ }
+ }
+ }
+ if (np) {
+ insert(we, in_cont_arg_list);
+ }
+ }
+ for (we = we->next;
+ *we->word != ';' && we != cp;
+ we = we->next)
+ continue;
+ if (*we->word == ';')
+ we = we->next;
+ }
+#ifdef CNDEBUG
+ if (*tag) {
+ xprintf(CGETS(22, 13, "command line now is:\n"));
+ for (we = cp->next; we != cp; we = we->next)
+ xprintf("%S ", we->word);
+ }
+#endif /* CNDEBUG */
+ return;
+}
+
+/* The actual "aliasing" of for backgrounds() is done here
+ with the aid of insert_we(). */
+static void
+insert(pl, file_args)
+ struct wordent *pl;
+ bool file_args;
+{
+ struct wordent *now, *last;
+ Char *cmd, *bcmd, *cp1, *cp2;
+ int cmd_len;
+ Char *pause = STRunderpause;
+ int p_len = (int) Strlen(pause);
+
+ cmd_len = (int) Strlen(pl->word);
+ cmd = (Char *) xcalloc(1, (size_t) ((cmd_len + 1) * sizeof(Char)));
+ (void) Strcpy(cmd, pl->word);
+/* Do insertions at beginning, first replace command word */
+
+ if (file_args) {
+ now = pl;
+ xfree((ptr_t) now->word);
+ now->word = (Char *) xcalloc(1, (size_t) (5 * sizeof(Char)));
+ (void) Strcpy(now->word, STRecho);
+
+ now = (struct wordent *) xcalloc(1, (size_t) sizeof(struct wordent));
+ now->word = (Char *) xcalloc(1, (size_t) (6 * sizeof(Char)));
+ (void) Strcpy(now->word, STRbackqpwd);
+ insert_we(now, pl);
+
+ for (last = now; *last->word != '\n' && *last->word != ';';
+ last = last->next)
+ continue;
+
+ now = (struct wordent *) xcalloc(1, (size_t) sizeof(struct wordent));
+ now->word = (Char *) xcalloc(1, (size_t) (2 * sizeof(Char)));
+ (void) Strcpy(now->word, STRgt);
+ insert_we(now, last->prev);
+
+ now = (struct wordent *) xcalloc(1, (size_t) sizeof(struct wordent));
+ now->word = (Char *) xcalloc(1, (size_t) (2 * sizeof(Char)));
+ (void) Strcpy(now->word, STRbang);
+ insert_we(now, last->prev);
+
+ now = (struct wordent *) xcalloc(1, (size_t) sizeof(struct wordent));
+ now->word = (Char *) xcalloc(1, (size_t) cmd_len + p_len + 4);
+ cp1 = now->word;
+ cp2 = cmd;
+ *cp1++ = '~';
+ *cp1++ = '/';
+ *cp1++ = '.';
+ while ((*cp1++ = *cp2++) != '\0')
+ continue;
+ cp1--;
+ cp2 = pause;
+ while ((*cp1++ = *cp2++) != '\0')
+ continue;
+ insert_we(now, last->prev);
+
+ now = (struct wordent *) xcalloc(1, (size_t) sizeof(struct wordent));
+ now->word = (Char *) xcalloc(1, (size_t) (2 * sizeof(Char)));
+ (void) Strcpy(now->word, STRsemi);
+ insert_we(now, last->prev);
+ bcmd = (Char *) xcalloc(1, (size_t) ((cmd_len + 2) * sizeof(Char)));
+ cp1 = bcmd;
+ cp2 = cmd;
+ *cp1++ = '%';
+ while ((*cp1++ = *cp2++) != '\0')
+ continue;
+ now = (struct wordent *) xcalloc(1, (size_t) (sizeof(struct wordent)));
+ now->word = bcmd;
+ insert_we(now, last->prev);
+ }
+ else {
+ struct wordent *del;
+
+ now = pl;
+ xfree((ptr_t) now->word);
+ now->word = (Char *) xcalloc(1,
+ (size_t) ((cmd_len + 2) * sizeof(Char)));
+ cp1 = now->word;
+ cp2 = cmd;
+ *cp1++ = '%';
+ while ((*cp1++ = *cp2++) != '\0')
+ continue;
+ for (now = now->next;
+ *now->word != '\n' && *now->word != ';' && now != pl;) {
+ now->prev->next = now->next;
+ now->next->prev = now->prev;
+ xfree((ptr_t) now->word);
+ del = now;
+ now = now->next;
+ xfree((ptr_t) del);
+ }
+ }
+}
+
+static void
+insert_we(new, where)
+ struct wordent *new, *where;
+{
+
+ new->prev = where;
+ new->next = where->next;
+ where->next = new;
+ new->next->prev = new;
+}
+
+static int
+inlist(list, name)
+ Char *list, *name;
+{
+ register Char *l, *n;
+
+ l = list;
+ n = name;
+
+ while (*l && *n) {
+ if (*l == *n) {
+ l++;
+ n++;
+ if (*n == '\0' && (*l == ' ' || *l == '\0'))
+ return (1);
+ else
+ continue;
+ }
+ else {
+ while (*l && *l != ' ')
+ l++; /* skip to blank */
+ while (*l && *l == ' ')
+ l++; /* and find first nonblank character */
+ n = name;
+ }
+ }
+ return (0);
+}
+
+#endif /* BSDJOBS */
+
+
+/*
+ * Implement a small cache for tilde names. This is used primarily
+ * to expand tilde names to directories, but also
+ * we can find users from their home directories for the tilde
+ * prompt, on machines where yp lookup is slow this can be a big win...
+ * As with any cache this can run out of sync, rehash can sync it again.
+ */
+static struct tildecache {
+ Char *user;
+ Char *home;
+ int hlen;
+} *tcache = NULL;
+
+#define TILINCR 10
+int tlength = 0;
+static int tsize = TILINCR;
+
+static int
+tildecompare(p1, p2)
+ struct tildecache *p1, *p2;
+{
+ return Strcmp(p1->user, p2->user);
+}
+
+static Char *
+gethomedir(us)
+ Char *us;
+{
+ register struct passwd *pp;
+#ifdef HESIOD
+ char **res, **res1, *cp;
+ Char *rp;
+#endif /* HESIOD */
+
+ pp = getpwnam(short2str(us));
+#ifdef YPBUGS
+ fix_yp_bugs();
+#endif /* YPBUGS */
+ if (pp != NULL)
+ return Strsave(str2short(pp->pw_dir));
+#ifdef HESIOD
+ res = hes_resolve(short2str(us), "filsys");
+ rp = 0;
+ if (res != 0) {
+ extern char *strtok();
+ if ((*res) != 0) {
+ /*
+ * Look at the first token to determine how to interpret
+ * the rest of it.
+ * Yes, strtok is evil (it's not thread-safe), but it's also
+ * easy to use.
+ */
+ cp = strtok(*res, " ");
+ if (strcmp(cp, "AFS") == 0) {
+ /* next token is AFS pathname.. */
+ cp = strtok(NULL, " ");
+ if (cp != NULL)
+ rp = Strsave(str2short(cp));
+ } else if (strcmp(cp, "NFS") == 0) {
+ cp = NULL;
+ if ((strtok(NULL, " ")) && /* skip remote pathname */
+ (strtok(NULL, " ")) && /* skip host */
+ (strtok(NULL, " ")) && /* skip mode */
+ (cp = strtok(NULL, " "))) {
+ rp = Strsave(str2short(cp));
+ }
+ }
+ }
+ for (res1 = res; *res1; res1++)
+ free(*res1);
+ return rp;
+ }
+#endif /* HESIOD */
+ return NULL;
+}
+
+Char *
+gettilde(us)
+ Char *us;
+{
+ struct tildecache *bp1, *bp2, *bp;
+ Char *hd;
+
+ /* Ignore NIS special names */
+ if (*us == '+' || *us == '-')
+ return NULL;
+
+ if (tcache == NULL)
+ tcache = (struct tildecache *) xmalloc((size_t) (TILINCR *
+ sizeof(struct tildecache)));
+ /*
+ * Binary search
+ */
+ for (bp1 = tcache, bp2 = tcache + tlength; bp1 < bp2;) {
+ register int i;
+
+ bp = bp1 + ((bp2 - bp1) >> 1);
+ if ((i = *us - *bp->user) == 0 && (i = Strcmp(us, bp->user)) == 0)
+ return (bp->home);
+ if (i < 0)
+ bp2 = bp;
+ else
+ bp1 = bp + 1;
+ }
+ /*
+ * Not in the cache, try to get it from the passwd file
+ */
+ hd = gethomedir(us);
+ if (hd == NULL)
+ return NULL;
+
+ /*
+ * Update the cache
+ */
+ tcache[tlength].user = Strsave(us);
+ tcache[tlength].home = hd;
+ tcache[tlength++].hlen = (int) Strlen(hd);
+
+ qsort((ptr_t) tcache, (size_t) tlength, sizeof(struct tildecache),
+ (int (*) __P((const void *, const void *))) tildecompare);
+
+ if (tlength == tsize) {
+ tsize += TILINCR;
+ tcache = (struct tildecache *) xrealloc((ptr_t) tcache,
+ (size_t) (tsize *
+ sizeof(struct tildecache)));
+ }
+ return (hd);
+}
+
+/*
+ * Return the username if the directory path passed contains a
+ * user's home directory in the tilde cache, otherwise return NULL
+ * hm points to the place where the path became different.
+ * Special case: Our own home directory.
+ * If we are passed a null pointer, then we flush the cache.
+ */
+Char *
+getusername(hm)
+ Char **hm;
+{
+ Char *h, *p;
+ int i, j;
+
+ if (hm == NULL) {
+ for (i = 0; i < tlength; i++) {
+ xfree((ptr_t) tcache[i].home);
+ xfree((ptr_t) tcache[i].user);
+ }
+ xfree((ptr_t) tcache);
+ tlength = 0;
+ tsize = TILINCR;
+ tcache = NULL;
+ return NULL;
+ }
+ if (((h = varval(STRhome)) != STRNULL) &&
+ (Strncmp(p = *hm, h, (size_t) (j = (int) Strlen(h))) == 0) &&
+ (p[j] == '/' || p[j] == '\0')) {
+ *hm = &p[j];
+ return STRNULL;
+ }
+ for (i = 0; i < tlength; i++)
+ if ((Strncmp(p = *hm, tcache[i].home, (size_t)
+ (j = tcache[i].hlen)) == 0) && (p[j] == '/' || p[j] == '\0')) {
+ *hm = &p[j];
+ return tcache[i].user;
+ }
+ return NULL;
+}
+
+#ifdef OBSOLETE
+/*
+ * PWP: read a bunch of aliases out of a file QUICKLY. The format
+ * is almost the same as the result of saying "alias > FILE", except
+ * that saying "aliases > FILE" does not expand non-letters to printable
+ * sequences.
+ */
+/*ARGSUSED*/
+void
+doaliases(v, c)
+ Char **v;
+ struct command *c;
+{
+ jmp_buf_t oldexit;
+ Char **vec, *lp;
+ int fd;
+ Char buf[BUFSIZE], line[BUFSIZE];
+ char tbuf[BUFSIZE + 1], *tmp;
+ extern bool output_raw; /* PWP: in sh.print.c */
+
+ USE(c);
+ v++;
+ if (*v == 0) {
+ output_raw = 1;
+ plist(&aliases, VAR_ALL);
+ output_raw = 0;
+ return;
+ }
+
+ 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 ((fd = open(tmp = short2str(*v), O_RDONLY)) < 0)
+ stderror(ERR_NAME | ERR_SYSTEM, tmp, strerror(errno));
+
+ getexit(oldexit);
+ if (setexit() == 0) {
+ for (;;) {
+ Char *p = NULL;
+ int n = 0;
+ lp = line;
+ for (;;) {
+ if (n <= 0) {
+ int i;
+
+ if ((n = read(fd, tbuf, BUFSIZE)) <= 0) {
+#ifdef convex
+ stderror(ERR_SYSTEM, progname, strerror(errno));
+#endif /* convex */
+ goto eof;
+ }
+ for (i = 0; i < n; i++)
+ buf[i] = (Char) tbuf[i];
+ p = buf;
+ }
+ n--;
+ if ((*lp++ = *p++) == '\n') {
+ lp[-1] = '\0';
+ break;
+ }
+ }
+ for (lp = line; *lp; lp++) {
+ if (isspc(*lp)) {
+ *lp++ = '\0';
+ while (isspc(*lp))
+ lp++;
+ vec = (Char **) xmalloc((size_t)
+ (2 * sizeof(Char **)));
+ vec[0] = Strsave(lp);
+ vec[1] = NULL;
+ setq(strip(line), vec, &aliases, VAR_READWRITE);
+ break;
+ }
+ }
+ }
+ }
+
+eof:
+ (void) close(fd);
+ tw_cmd_free();
+ if (gargv)
+ blkfree(gargv), gargv = 0;
+ resexit(oldexit);
+}
+#endif /* OBSOLETE */
+
+
+/*
+ * set the shell-level var to 1 or apply change to it.
+ */
+void
+shlvl(val)
+ int val;
+{
+ char *cp;
+
+ if ((cp = getenv("SHLVL")) != NULL) {
+
+ if (loginsh)
+ val = 1;
+ else
+ val += atoi(cp);
+
+ if (val <= 0) {
+ if (adrof(STRshlvl) != NULL)
+ unsetv(STRshlvl);
+ Unsetenv(STRKSHLVL);
+ }
+ else {
+ Char buff[BUFSIZE];
+
+ (void) Itoa(val, buff, 0, 0);
+ set(STRshlvl, Strsave(buff), VAR_READWRITE);
+ tsetenv(STRKSHLVL, buff);
+ }
+ }
+ else {
+ set(STRshlvl, SAVE("1"), VAR_READWRITE);
+ tsetenv(STRKSHLVL, str2short("1"));
+ }
+}
+
+
+/* fixio():
+ * Try to recover from a read error
+ */
+int
+fixio(fd, e)
+ int fd, e;
+{
+ switch (e) {
+ case -1: /* Make sure that the code is reachable */
+
+#ifdef EWOULDBLOCK
+ case EWOULDBLOCK:
+# define FDRETRY
+#endif /* EWOULDBLOCK */
+
+#if defined(POSIX) && defined(EAGAIN)
+# if !defined(EWOULDBLOCK) || EWOULDBLOCK != EAGAIN
+ case EAGAIN:
+# define FDRETRY
+# endif /* !EWOULDBLOCK || EWOULDBLOCK != EAGAIN */
+#endif /* POSIX && EAGAIN */
+
+ e = 0;
+#ifdef FDRETRY
+# ifdef F_SETFL
+/*
+ * Great! we have on suns 3 flavors and 5 names...
+ * I hope that will cover everything.
+ * I added some more defines... many systems have different defines.
+ * Rather than dealing with getting the right includes, we'll just
+ * cover all the known possibilities here. -- sterling@netcom.com
+ */
+# ifndef O_NONBLOCK
+# define O_NONBLOCK 0
+# endif /* O_NONBLOCK */
+# ifndef O_NDELAY
+# define O_NDELAY 0
+# endif /* O_NDELAY */
+# ifndef FNBIO
+# define FNBIO 0
+# endif /* FNBIO */
+# ifndef _FNBIO
+# define _FNBIO 0
+# endif /* _FNBIO */
+# ifndef FNONBIO
+# define FNONBIO 0
+# endif /* FNONBIO */
+# ifndef FNONBLOCK
+# define FNONBLOCK 0
+# endif /* FNONBLOCK */
+# ifndef _FNONBLOCK
+# define _FNONBLOCK 0
+# endif /* _FNONBLOCK */
+# ifndef FNDELAY
+# define FNDELAY 0
+# endif /* FNDELAY */
+# ifndef _FNDELAY
+# define _FNDELAY 0
+# endif /* _FNDELAY */
+# ifndef FNDLEAY /* Some linux versions have this typo */
+# define FNDLEAY 0
+# endif /* FNDLEAY */
+ if ((e = fcntl(fd, F_GETFL, 0)) == -1)
+ return -1;
+
+ e &= ~(O_NDELAY|O_NONBLOCK|FNBIO|_FNBIO|FNONBIO|FNONBLOCK|_FNONBLOCK|
+ FNDELAY|_FNDELAY|FNDLEAY); /* whew! */
+ if (fcntl(fd, F_SETFL, e) == -1)
+ return -1;
+ else
+ e = 1;
+# endif /* F_SETFL */
+
+# ifdef FIONBIO
+ e = 0;
+ if (ioctl(fd, FIONBIO, (ioctl_t) &e) == -1)
+ return -1;
+ else
+ e = 1;
+# endif /* FIONBIO */
+
+#endif /* FDRETRY */
+ return e ? 0 : -1;
+
+ case EINTR:
+ return 0;
+
+ default:
+ return -1;
+ }
+}
+
+/* collate():
+ * String collation
+ */
+int
+collate(a, b)
+ const Char *a;
+ const Char *b;
+{
+ int rv;
+#ifdef SHORT_STRINGS
+ /* This strips the quote bit as a side effect */
+ char *sa = strsave(short2str(a));
+ char *sb = strsave(short2str(b));
+#else
+ char *sa = strip(strsave(a));
+ char *sb = strip(strsave(b));
+#endif /* SHORT_STRINGS */
+
+#if defined(NLS) && !defined(NOSTRCOLL)
+ errno = 0; /* strcoll sets errno, another brain-damage */
+
+ rv = strcoll(sa, sb);
+
+ /*
+ * We should be checking for errno != 0, but some systems
+ * forget to reset errno to 0. So we only check for the
+ * only documented valid errno value for strcoll [EINVAL]
+ */
+ if (errno == EINVAL) {
+ xfree((ptr_t) sa);
+ xfree((ptr_t) sb);
+ stderror(ERR_SYSTEM, "strcoll", strerror(errno));
+ }
+#else
+ rv = strcmp(sa, sb);
+#endif /* NLS && !NOSTRCOLL */
+
+ xfree((ptr_t) sa);
+ xfree((ptr_t) sb);
+
+ return rv;
+}
+
+#ifdef HASHBANG
+/*
+ * From: peter@zeus.dialix.oz.au (Peter Wemm)
+ * If exec() fails look first for a #! [word] [word] ....
+ * If it is, splice the header into the argument list and retry.
+ */
+#define HACKBUFSZ 1024 /* Max chars in #! vector */
+#define HACKVECSZ 128 /* Max words in #! vector */
+int
+hashbang(fd, vp)
+ int fd;
+ Char ***vp;
+{
+ unsigned char lbuf[HACKBUFSZ];
+ char *sargv[HACKVECSZ];
+ unsigned char *p, *ws;
+ int sargc = 0;
+#ifdef WINNT
+ int fw = 0; /* found at least one word */
+ int first_word = 0;
+#endif /* WINNT */
+
+ if (read(fd, (char *) lbuf, HACKBUFSZ) <= 0)
+ return -1;
+
+ ws = 0; /* word started = 0 */
+
+ for (p = lbuf; p < &lbuf[HACKBUFSZ]; )
+ switch (*p) {
+ case ' ':
+ case '\t':
+#ifdef WINNT
+ case '\r':
+#endif /* WINNT */
+ if (ws) { /* a blank after a word.. save it */
+ *p = '\0';
+#ifndef WINNT
+ if (sargc < HACKVECSZ - 1)
+ sargv[sargc++] = ws;
+ ws = NULL;
+#else /* WINNT */
+ if (sargc < HACKVECSZ - 1) {
+ sargv[sargc] = first_word ? NULL: hb_subst(ws);
+ if (sargv[sargc] == NULL)
+ sargv[sargc] = ws;
+ sargc++;
+ }
+ ws = NULL;
+ fw = 1;
+ first_word = 1;
+#endif /* WINNT */
+ }
+ p++;
+ continue;
+
+ case '\0': /* Whoa!! what the hell happened */
+ return -1;
+
+ case '\n': /* The end of the line. */
+ if (
+#ifdef WINNT
+ fw ||
+#endif /* WINNT */
+ ws) { /* terminate the last word */
+ *p = '\0';
+#ifndef WINNT
+ if (sargc < HACKVECSZ - 1)
+ sargv[sargc++] = ws;
+#else /* WINNT */
+ if (sargc < HACKVECSZ - 1) { /* deal with the 1-word case */
+ sargv[sargc] = first_word? NULL : hb_subst(ws);
+ if (sargv[sargc] == NULL)
+ sargv[sargc] = ws;
+ sargc++;
+ }
+#endif /* !WINNT */
+ }
+ sargv[sargc] = NULL;
+ ws = NULL;
+ if (sargc > 0) {
+ *vp = blk2short(sargv);
+ return 0;
+ }
+ else
+ return -1;
+
+ default:
+ if (!ws) /* Start a new word? */
+ ws = p;
+ p++;
+ break;
+ }
+ return -1;
+}
+#endif /* HASHBANG */
+
+#ifdef REMOTEHOST
+
+static sigret_t
+palarm(snum)
+ int snum;
+{
+ USE(snum);
+#ifdef UNRELSIGS
+ if (snum)
+ (void) sigset(snum, SIG_IGN);
+#endif /* UNRELSIGS */
+ (void) alarm(0);
+ reset();
+
+#ifndef SIGVOID
+ return (snum);
+#endif
+}
+
+
+static void
+getremotehost()
+{
+ const char *host = NULL;
+ struct hostent* hp;
+ struct sockaddr_in saddr;
+ int len = sizeof(struct sockaddr_in);
+#if defined(UTHOST) && !defined(HAVENOUTMP)
+ char *sptr = NULL;
+#endif
+
+ if (getpeername(SHIN, (struct sockaddr *) &saddr, &len) != -1) {
+#if 0
+ if ((hp = gethostbyaddr((char *)&saddr.sin_addr, sizeof(struct in_addr),
+ AF_INET)) != NULL)
+ host = hp->h_name;
+ else
+#endif
+ host = inet_ntoa(saddr.sin_addr);
+ }
+#if defined(UTHOST) && !defined(HAVENOUTMP)
+ else {
+ char *ptr;
+ char *name = utmphost();
+ /* Avoid empty names and local X displays */
+ if (name != NULL && *name != '\0' && *name != ':') {
+ /* Look for host:display.screen */
+ if ((sptr = strchr(name, ':')) != NULL)
+ *sptr = '\0';
+ /* Leave IP address as is */
+ if (isdigit(*name))
+ host = name;
+ else {
+ if (sptr != name) {
+ if ((hp = gethostbyname(name)) == NULL) {
+ /* Try again eliminating the trailing domain */
+ if ((ptr = strchr(name, '.')) != NULL) {
+ *ptr = '\0';
+ if ((hp = gethostbyname(name)) != NULL)
+ host = hp->h_name;
+ *ptr = '.';
+ }
+ }
+ else
+ host = hp->h_name;
+ }
+ }
+ }
+ }
+#endif
+
+ if (host)
+ tsetenv(STRREMOTEHOST, str2short(host));
+
+#if defined(UTHOST) && !defined(HAVENOUTMP)
+ if (sptr)
+ *sptr = ':';
+#endif
+}
+
+
+/*
+ * From: <lesv@ppvku.ericsson.se> (Lennart Svensson)
+ */
+void
+remotehost()
+{
+ /* Don't get stuck if the resolver does not work! */
+ signalfun_t osig = sigset(SIGALRM, palarm);
+
+ jmp_buf_t osetexit;
+ getexit(osetexit);
+
+ (void) alarm(2);
+
+ if (setexit() == 0)
+ getremotehost();
+
+ resexit(osetexit);
+
+ (void) alarm(0);
+ (void) sigset(SIGALRM, osig);
+
+#ifdef YPBUGS
+ /* From: casper@fwi.uva.nl (Casper H.S. Dik), for Solaris 2.3 */
+ fix_yp_bugs();
+#endif /* YPBUGS */
+
+}
+#endif /* REMOTEHOST */
OpenPOWER on IntegriCloud