PageRenderTime 127ms CodeModel.GetById 16ms app.highlight 97ms RepoModel.GetById 1ms app.codeStats 0ms

/contrib/tcsh/tc.func.c

https://bitbucket.org/freebsd/freebsd-head/
C | 2093 lines | 1594 code | 206 blank | 293 comment | 528 complexity | 7d47ad9d13582ffe2d054fc71282762f MD5 | raw file
   1/* $Header: /p/tcsh/cvsroot/tcsh/tc.func.c,v 3.148 2011/12/14 16:36:44 christos Exp $ */
   2/*
   3 * tc.func.c: New tcsh builtins.
   4 */
   5/*-
   6 * Copyright (c) 1980, 1991 The Regents of the University of California.
   7 * All rights reserved.
   8 *
   9 * Redistribution and use in source and binary forms, with or without
  10 * modification, are permitted provided that the following conditions
  11 * are met:
  12 * 1. Redistributions of source code must retain the above copyright
  13 *    notice, this list of conditions and the following disclaimer.
  14 * 2. Redistributions in binary form must reproduce the above copyright
  15 *    notice, this list of conditions and the following disclaimer in the
  16 *    documentation and/or other materials provided with the distribution.
  17 * 3. Neither the name of the University nor the names of its contributors
  18 *    may be used to endorse or promote products derived from this software
  19 *    without specific prior written permission.
  20 *
  21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31 * SUCH DAMAGE.
  32 */
  33#include "sh.h"
  34
  35RCSID("$tcsh: tc.func.c,v 3.148 2011/12/14 16:36:44 christos Exp $")
  36
  37#include "ed.h"
  38#include "ed.defns.h"		/* for the function names */
  39#include "tw.h"
  40#include "tc.h"
  41#ifdef WINNT_NATIVE
  42#include "nt.const.h"
  43#else /* WINNT_NATIVE */
  44#include <sys/wait.h>
  45#endif /* WINNT_NATIVE */
  46
  47#ifdef AFS
  48#include <afs/stds.h>
  49#include <afs/kautils.h>
  50long ka_UserAuthenticateGeneral();
  51#endif /* AFS */
  52
  53#ifdef TESLA
  54extern int do_logout;
  55#endif /* TESLA */
  56extern time_t t_period;
  57extern int just_signaled;
  58static int precmd_active = 0;
  59static int jobcmd_active = 0; /* GrP */
  60static int postcmd_active = 0;
  61static int periodic_active = 0;
  62static int cwdcmd_active = 0;	/* PWP: for cwd_cmd */
  63static int beepcmd_active = 0;
  64static void (*alm_fun)(void) = NULL;
  65
  66static	void	 auto_logout	(void);
  67static	char	*xgetpass	(const char *);
  68static	void	 auto_lock	(void);
  69#ifdef BSDJOBS
  70static	void	 insert		(struct wordent *, int);
  71static	void	 insert_we	(struct wordent *, struct wordent *);
  72static	int	 inlist		(Char *, Char *);
  73#endif /* BSDJOBS */
  74static	int	 tildecompare	(const void *, const void *);
  75static  Char    *gethomedir	(const Char *);
  76#ifdef REMOTEHOST
  77static	void	 palarm		(int);
  78static	void	 getremotehost	(int);
  79#endif /* REMOTEHOST */
  80
  81/*
  82 * Tops-C shell
  83 */
  84
  85/*
  86 * expand_lex: Take the given lex and return an expanded version of it.
  87 * First guy in lex list is ignored; last guy is ^J which we ignore.
  88 * Only take lex'es from position 'from' to position 'to' inclusive
  89 *
  90 * Note: csh sometimes sets bit 8 in characters which causes all kinds
  91 * of problems if we don't mask it here. Note: excl's in lexes have been
  92 * un-back-slashed and must be re-back-slashed
  93 *
  94 */
  95/* PWP: this is a combination of the old sprlex() and the expand_lex from
  96   the magic-space stuff */
  97
  98Char   *
  99expand_lex(const struct wordent *sp0, int from, int to)
 100{
 101    struct Strbuf buf = Strbuf_INIT;
 102    const struct wordent *sp;
 103    Char *s;
 104    Char prev_c;
 105    int i;
 106
 107    prev_c = '\0';
 108
 109    if (!sp0 || (sp = sp0->next) == sp0 || sp == (sp0 = sp0->prev))
 110	return Strbuf_finish(&buf); /* null lex */
 111
 112    for (i = 0; ; i++) {
 113	if ((i >= from) && (i <= to)) {	/* if in range */
 114	    for (s = sp->word; *s; s++) {
 115		/*
 116		 * bugfix by Michael Bloom: anything but the current history
 117		 * character {(PWP) and backslash} seem to be dealt with
 118		 * elsewhere.
 119		 */
 120		if ((*s & QUOTE)
 121		    && (((*s & TRIM) == HIST && HIST != '\0') ||
 122			(((*s & TRIM) == '\'') && (prev_c != '\\')) ||
 123			(((*s & TRIM) == '\"') && (prev_c != '\\')) ||
 124			(((*s & TRIM) == '\\') && (prev_c != '\\')))) {
 125		    Strbuf_append1(&buf, '\\');
 126		}
 127		Strbuf_append1(&buf, *s & TRIM);
 128		prev_c = *s;
 129	    }
 130	    Strbuf_append1(&buf, ' ');
 131	}
 132	sp = sp->next;
 133	if (sp == sp0)
 134	    break;
 135    }
 136    if (buf.len != 0)
 137	buf.len--;		/* get rid of trailing space */
 138
 139    return Strbuf_finish(&buf);
 140}
 141
 142Char   *
 143sprlex(const struct wordent *sp0)
 144{
 145    return expand_lex(sp0, 0, INT_MAX);
 146}
 147
 148
 149Char *
 150Itoa(int n, size_t min_digits, Char attributes)
 151{
 152    /*
 153     * The array size here is derived from
 154     *	log8(UINT_MAX)
 155     * which is guaranteed to be enough for a decimal
 156     * representation.  We add 1 because integer divide
 157     * rounds down.
 158     */
 159#ifndef CHAR_BIT
 160# define CHAR_BIT 8
 161#endif
 162    Char buf[CHAR_BIT * sizeof(int) / 3 + 1], *res, *p, *s;
 163    unsigned int un;	/* handle most negative # too */
 164    int pad = (min_digits != 0);
 165
 166    if (sizeof(buf) - 1 < min_digits)
 167	min_digits = sizeof(buf) - 1;
 168
 169    un = n;
 170    if (n < 0)
 171	un = -n;
 172
 173    p = buf;
 174    do {
 175	*p++ = un % 10 + '0';
 176	un /= 10;
 177    } while ((pad && (ssize_t)--min_digits > 0) || un != 0);
 178
 179    res = xmalloc((p - buf + 2) * sizeof(*res));
 180    s = res;
 181    if (n < 0)
 182	*s++ = '-';
 183    while (p > buf)
 184	*s++ = *--p | attributes;
 185
 186    *s = '\0';
 187    return res;
 188}
 189
 190
 191/*ARGSUSED*/
 192void
 193dolist(Char **v, struct command *c)
 194{
 195    Char **globbed;
 196    int     i, k;
 197    struct stat st;
 198
 199    USE(c);
 200    if (*++v == NULL) {
 201	struct Strbuf word = Strbuf_INIT;
 202
 203	Strbuf_terminate(&word);
 204	cleanup_push(&word, Strbuf_cleanup);
 205	(void) t_search(&word, LIST, TW_ZERO, 0, STRNULL, 0);
 206	cleanup_until(&word);
 207	return;
 208    }
 209    v = glob_all_or_error(v);
 210    globbed = v;
 211    cleanup_push(globbed, blk_cleanup);
 212    for (k = 0; v[k] != NULL && v[k][0] != '-'; k++)
 213	continue;
 214    if (v[k]) {
 215	/*
 216	 * We cannot process a flag therefore we let ls do it right.
 217	 */
 218	Char *lspath;
 219	struct command *t;
 220	struct wordent cmd, *nextword, *lastword;
 221	Char   *cp;
 222	struct varent *vp;
 223
 224	if (setintr) {
 225	    pintr_disabled++;
 226	    cleanup_push(&pintr_disabled, disabled_cleanup);
 227	}
 228	if (seterr) {
 229	    xfree(seterr);
 230	    seterr = NULL;
 231	}
 232
 233	lspath = STRls;
 234	STRmCF[1] = 'C';
 235	STRmCF[3] = '\0';
 236	/* Look at listflags, to add -A to the flags, to get a path
 237	   of ls if necessary */
 238	if ((vp = adrof(STRlistflags)) != NULL && vp->vec != NULL &&
 239	    vp->vec[0] != STRNULL) {
 240	    if (vp->vec[1] != NULL && vp->vec[1][0] != '\0')
 241		lspath = vp->vec[1];
 242	    for (cp = vp->vec[0]; *cp; cp++)
 243		switch (*cp) {
 244		case 'x':
 245		    STRmCF[1] = 'x';
 246		    break;
 247		case 'a':
 248		    STRmCF[3] = 'a';
 249		    break;
 250		case 'A':
 251		    STRmCF[3] = 'A';
 252		    break;
 253		default:
 254		    break;
 255		}
 256	}
 257
 258	cmd.word = STRNULL;
 259	lastword = &cmd;
 260	nextword = xcalloc(1, sizeof cmd);
 261	nextword->word = Strsave(lspath);
 262	lastword->next = nextword;
 263	nextword->prev = lastword;
 264	lastword = nextword;
 265	nextword = xcalloc(1, sizeof cmd);
 266	nextword->word = Strsave(STRmCF);
 267	lastword->next = nextword;
 268	nextword->prev = lastword;
 269#if defined(KANJI) && defined(SHORT_STRINGS) && defined(DSPMBYTE)
 270	if (dspmbyte_ls) {
 271	    lastword = nextword;
 272	    nextword = xcalloc(1, sizeof cmd);
 273	    nextword->word = Strsave(STRmmliteral);
 274	    lastword->next = nextword;
 275	    nextword->prev = lastword;
 276	}
 277#endif
 278#ifdef COLOR_LS_F
 279	if (color_context_ls) {
 280	    lastword = nextword;
 281	    nextword = xcalloc(1, sizeof cmd);
 282	    nextword->word = Strsave(STRmmcolormauto);
 283	    lastword->next = nextword;
 284	    nextword->prev = lastword;
 285	}
 286#endif /* COLOR_LS_F */
 287	lastword = nextword;
 288	for (cp = *v; cp; cp = *++v) {
 289	    nextword = xcalloc(1, sizeof cmd);
 290	    nextword->word = quote(Strsave(cp));
 291	    lastword->next = nextword;
 292	    nextword->prev = lastword;
 293	    lastword = nextword;
 294	}
 295	lastword->next = &cmd;
 296	cmd.prev = lastword;
 297	cleanup_push(&cmd, lex_cleanup);
 298
 299	/* build a syntax tree for the command. */
 300	t = syntax(cmd.next, &cmd, 0);
 301	cleanup_push(t, syntax_cleanup);
 302	if (seterr)
 303	    stderror(ERR_OLD);
 304	/* expand aliases like process() does */
 305	/* alias(&cmd); */
 306	/* execute the parse tree. */
 307	execute(t, tpgrp > 0 ? tpgrp : -1, NULL, NULL, FALSE);
 308	/* done. free the lex list and parse tree. */
 309	cleanup_until(&cmd);
 310	if (setintr)
 311	    cleanup_until(&pintr_disabled);
 312    }
 313    else {
 314	Char   *dp, *tmp;
 315	struct Strbuf buf = Strbuf_INIT;
 316
 317	cleanup_push(&buf, Strbuf_cleanup);
 318	for (k = 0, i = 0; v[k] != NULL; k++) {
 319	    tmp = dnormalize(v[k], symlinks == SYM_IGNORE);
 320	    cleanup_push(tmp, xfree);
 321	    dp = Strend(tmp) - 1;
 322	    if (*dp == '/' && dp != tmp)
 323#ifdef apollo
 324		if (dp != &tmp[1])
 325#endif /* apollo */
 326		*dp = '\0';
 327	    if (stat(short2str(tmp), &st) == -1) {
 328		int err;
 329
 330		err = errno;
 331		if (k != i) {
 332		    if (i != 0)
 333			xputchar('\n');
 334		    print_by_column(STRNULL, &v[i], k - i, FALSE);
 335		}
 336		xprintf("%S: %s.\n", tmp, strerror(err));
 337		i = k + 1;
 338	    }
 339	    else if (S_ISDIR(st.st_mode)) {
 340		Char   *cp;
 341
 342		if (k != i) {
 343		    if (i != 0)
 344			xputchar('\n');
 345		    print_by_column(STRNULL, &v[i], k - i, FALSE);
 346		}
 347		if (k != 0 && v[1] != NULL)
 348		    xputchar('\n');
 349		xprintf("%S:\n", tmp);
 350		buf.len = 0;
 351		for (cp = tmp; *cp; cp++)
 352		    Strbuf_append1(&buf, (*cp | QUOTE));
 353		Strbuf_terminate(&buf);
 354		dp = &buf.s[buf.len - 1];
 355		if (
 356#ifdef WINNT_NATIVE
 357		    (*dp != (Char) (':' | QUOTE)) &&
 358#endif /* WINNT_NATIVE */
 359		    (*dp != (Char) ('/' | QUOTE))) {
 360		    Strbuf_append1(&buf, '/');
 361		    Strbuf_terminate(&buf);
 362		} else 
 363		    *dp &= TRIM;
 364		(void) t_search(&buf, LIST, TW_ZERO, 0, STRNULL, 0);
 365		i = k + 1;
 366	    }
 367	    cleanup_until(tmp);
 368	}
 369	cleanup_until(&buf);
 370	if (k != i) {
 371	    if (i != 0)
 372		xputchar('\n');
 373	    print_by_column(STRNULL, &v[i], k - i, FALSE);
 374	}
 375    }
 376
 377    cleanup_until(globbed);
 378}
 379
 380extern int GotTermCaps;
 381
 382/*ARGSUSED*/
 383void
 384dotelltc(Char **v, struct command *c)
 385{
 386    USE(v);
 387    USE(c);
 388    if (!GotTermCaps)
 389	GetTermCaps();
 390    TellTC();
 391}
 392
 393/*ARGSUSED*/
 394void
 395doechotc(Char **v, struct command *c)
 396{
 397    USE(c);
 398    if (!GotTermCaps)
 399	GetTermCaps();
 400    EchoTC(++v);
 401}
 402
 403/*ARGSUSED*/
 404void
 405dosettc(Char **v, struct command *c)
 406{
 407    char    *tv[2];
 408
 409    USE(c);
 410    if (!GotTermCaps)
 411	GetTermCaps();
 412
 413    tv[0] = strsave(short2str(v[1]));
 414    cleanup_push(tv[0], xfree);
 415    tv[1] = strsave(short2str(v[2]));
 416    cleanup_push(tv[1], xfree);
 417    SetTC(tv[0], tv[1]);
 418    cleanup_until(tv[0]);
 419}
 420
 421/* The dowhich() is by:
 422 *  Andreas Luik <luik@isaak.isa.de>
 423 *  I S A  GmbH - Informationssysteme fuer computerintegrierte Automatisierung
 424 *  Azenberstr. 35
 425 *  D-7000 Stuttgart 1
 426 *  West-Germany
 427 * Thanks!!
 428 */
 429int
 430cmd_expand(Char *cmd, Char **str)
 431{
 432    struct wordent lexp[3];
 433    struct varent *vp;
 434    int rv = TRUE;
 435
 436    lexp[0].next = &lexp[1];
 437    lexp[1].next = &lexp[2];
 438    lexp[2].next = &lexp[0];
 439
 440    lexp[0].prev = &lexp[2];
 441    lexp[1].prev = &lexp[0];
 442    lexp[2].prev = &lexp[1];
 443
 444    lexp[0].word = STRNULL;
 445    lexp[2].word = STRret;
 446
 447    if ((vp = adrof1(cmd, &aliases)) != NULL && vp->vec != NULL) {
 448	if (str == NULL) {
 449	    xprintf(CGETS(22, 1, "%S: \t aliased to "), cmd);
 450	    blkpr(vp->vec);
 451	    xputchar('\n');
 452	}
 453	else
 454	    *str = blkexpand(vp->vec);
 455    }
 456    else {
 457	lexp[1].word = cmd;
 458	rv = tellmewhat(lexp, str);
 459    }
 460    return rv;
 461}
 462
 463
 464/*ARGSUSED*/
 465void
 466dowhich(Char **v, struct command *c)
 467{
 468    int rv = TRUE;
 469    USE(c);
 470
 471    /*
 472     * We don't want to glob dowhich args because we lose quoteing
 473     * E.g. which \ls if ls is aliased will not work correctly if
 474     * we glob here.
 475     */
 476
 477    while (*++v) 
 478	rv &= cmd_expand(*v, NULL);
 479
 480    if (!rv)
 481	setcopy(STRstatus, STR1, VAR_READWRITE);
 482}
 483
 484/* PWP: a hack to start up your stopped editor on a single keystroke */
 485/* jbs - fixed hack so it worked :-) 3/28/89 */
 486
 487struct process *
 488find_stop_ed(void)
 489{
 490    struct process *pp, *retp;
 491    const char *ep, *vp;
 492    char *cp, *p;
 493    size_t epl, vpl;
 494    int pstatus;
 495
 496    if ((ep = getenv("EDITOR")) != NULL) {	/* if we have a value */
 497	if ((p = strrchr(ep, '/')) != NULL) 	/* if it has a path */
 498	    ep = p + 1;		/* then we want only the last part */
 499    }
 500    else 
 501	ep = "ed";
 502
 503    if ((vp = getenv("VISUAL")) != NULL) {	/* if we have a value */
 504	if ((p = strrchr(vp, '/')) != NULL) 	/* and it has a path */
 505	    vp = p + 1;		/* then we want only the last part */
 506    }
 507    else 
 508	vp = "vi";
 509
 510    for (vpl = 0; vp[vpl] && !isspace((unsigned char)vp[vpl]); vpl++)
 511	continue;
 512    for (epl = 0; ep[epl] && !isspace((unsigned char)ep[epl]); epl++)
 513	continue;
 514
 515    if (pcurrent == NULL)	/* see if we have any jobs */
 516	return NULL;		/* nope */
 517
 518    retp = NULL;
 519    for (pp = proclist.p_next; pp; pp = pp->p_next)
 520	if (pp->p_procid == pp->p_jobid) {
 521
 522	    /*
 523	     * Only foreground an edit session if it is suspended.  Some GUI
 524	     * editors have may be happily running in a separate window, no
 525	     * point in foregrounding these if they're already running - webb
 526	     */
 527	    pstatus = (int) (pp->p_flags & PALLSTATES);
 528	    if (pstatus != PINTERRUPTED && pstatus != PSTOPPED &&
 529		pstatus != PSIGNALED)
 530		continue;
 531
 532	    p = short2str(pp->p_command);
 533	    /* get the first word */
 534	    for (cp = p; *cp && !isspace((unsigned char) *cp); cp++)
 535		continue;
 536	    *cp = '\0';
 537		
 538	    if ((cp = strrchr(p, '/')) != NULL)	/* and it has a path */
 539		cp = cp + 1;		/* then we want only the last part */
 540	    else
 541		cp = p;			/* else we get all of it */
 542
 543	    /* if we find either in the current name, fg it */
 544	    if (strncmp(ep, cp, epl) == 0 ||
 545		strncmp(vp, cp, vpl) == 0) {
 546
 547		/*
 548		 * If there is a choice, then choose the current process if
 549		 * available, or the previous process otherwise, or else
 550		 * anything will do - Robert Webb (robertw@mulga.cs.mu.oz.au).
 551		 */
 552		if (pp == pcurrent)
 553		    return pp;
 554		else if (retp == NULL || pp == pprevious)
 555		    retp = pp;
 556	    }
 557	}
 558
 559    return retp;		/* Will be NULL if we didn't find a job */
 560}
 561
 562void
 563fg_proc_entry(struct process *pp)
 564{
 565    jmp_buf_t osetexit;
 566    int    ohaderr;
 567    Char    oGettingInput;
 568    size_t omark;
 569
 570    getexit(osetexit);
 571
 572    pintr_disabled++;
 573    oGettingInput = GettingInput;
 574    GettingInput = 0;
 575
 576    ohaderr = haderr;		/* we need to ignore setting of haderr due to
 577				 * process getting stopped by a signal */
 578    omark = cleanup_push_mark();
 579    if (setexit() == 0) {	/* come back here after pjwait */
 580	pendjob();
 581	(void) alarm(0);	/* No autologout */
 582	alrmcatch_disabled = 1;
 583	if (!pstart(pp, 1)) {
 584	    pp->p_procid = 0;
 585	    stderror(ERR_BADJOB, pp->p_command, strerror(errno));
 586	}
 587	pjwait(pp);
 588    }
 589    setalarm(1);		/* Autologout back on */
 590    cleanup_pop_mark(omark);
 591    resexit(osetexit);
 592    haderr = ohaderr;
 593    GettingInput = oGettingInput;
 594
 595    disabled_cleanup(&pintr_disabled);
 596}
 597
 598static char *
 599xgetpass(const char *prm)
 600{
 601    static struct strbuf pass; /* = strbuf_INIT; */
 602    int fd;
 603    sigset_t oset, set;
 604    struct sigaction sa, osa;
 605
 606    sa.sa_handler = SIG_IGN;
 607    sigemptyset(&sa.sa_mask);
 608    sa.sa_flags = 0;
 609    (void)sigaction(SIGINT, &sa, &osa);
 610
 611    sigemptyset(&set);
 612    sigaddset(&set, SIGINT);
 613    (void)sigprocmask(SIG_UNBLOCK, &set, &oset);
 614
 615    cleanup_push(&osa, sigint_cleanup);
 616    cleanup_push(&oset, sigprocmask_cleanup);
 617    (void) Rawmode();	/* Make sure, cause we want echo off */
 618    fd = xopen("/dev/tty", O_RDWR|O_LARGEFILE);
 619    if (fd == -1)
 620	fd = SHIN;
 621    else
 622	cleanup_push(&fd, open_cleanup);
 623
 624    xprintf("%s", prm); flush();
 625    pass.len = 0;
 626    for (;;)  {
 627	char c;
 628
 629	if (xread(fd, &c, 1) < 1 || c == '\n') 
 630	    break;
 631	strbuf_append1(&pass, c);
 632    }
 633    strbuf_terminate(&pass);
 634
 635    cleanup_until(&osa);
 636
 637    return pass.s;
 638}
 639
 640#ifndef NO_CRYPT
 641#if !HAVE_DECL_CRYPT
 642    extern char *crypt ();
 643#endif
 644#ifdef HAVE_CRYPT_H
 645#include <crypt.h>
 646#endif
 647#endif
 648
 649/*
 650 * Ask the user for his login password to continue working
 651 * On systems that have a shadow password, this will only 
 652 * work for root, but what can we do?
 653 *
 654 * If we fail to get the password, then we log the user out
 655 * immediately
 656 */
 657/*ARGSUSED*/
 658static void
 659auto_lock(void)
 660{
 661#ifndef NO_CRYPT
 662
 663    int i;
 664    char *srpp = NULL;
 665    struct passwd *pw;
 666
 667#undef XCRYPT
 668
 669#if defined(HAVE_AUTH_H) && defined(HAVE_GETAUTHUID)
 670
 671    struct authorization *apw;
 672    extern char *crypt16 (const char *, const char *);
 673
 674# define XCRYPT(pw, a, b) crypt16(a, b)
 675
 676    if ((pw = xgetpwuid(euid)) != NULL &&	/* effective user passwd  */
 677        (apw = getauthuid(euid)) != NULL) 	/* enhanced ultrix passwd */
 678	srpp = apw->a_password;
 679
 680#elif defined(HAVE_SHADOW_H)
 681
 682    struct spwd *spw;
 683
 684# define XCRYPT(pw, a, b) crypt(a, b)
 685
 686    if ((pw = xgetpwuid(euid)) != NULL)	{	/* effective user passwd  */
 687	errno = 0;
 688	while ((spw = getspnam(pw->pw_name)) == NULL && errno == EINTR) {
 689	    handle_pending_signals();
 690	    errno = 0;
 691	}
 692	if (spw != NULL)			 /* shadowed passwd	  */
 693	    srpp = spw->sp_pwdp;
 694    }
 695
 696#else
 697
 698
 699#ifdef __CYGWIN__
 700# define XCRYPT(pw, a, b) cygwin_xcrypt(pw, a, b)
 701#else
 702# define XCRYPT(pw, a, b) crypt(a, b)
 703#endif
 704
 705#if !defined(__MVS__)
 706    if ((pw = xgetpwuid(euid)) != NULL)	/* effective user passwd  */
 707	srpp = pw->pw_passwd;
 708#endif /* !MVS */
 709
 710#endif
 711
 712    if (srpp == NULL) {
 713	auto_logout();
 714	/*NOTREACHED*/
 715	return;
 716    }
 717
 718    setalarm(0);		/* Not for locking any more */
 719    xputchar('\n');
 720    for (i = 0; i < 5; i++) {
 721	const char *crpp;
 722	char *pp;
 723#ifdef AFS
 724	char *afsname;
 725	Char *safs;
 726
 727	if ((safs = varval(STRafsuser)) != STRNULL)
 728	    afsname = short2str(safs);
 729	else
 730	    if ((afsname = getenv("AFSUSER")) == NULL)
 731	        afsname = pw->pw_name;
 732#endif
 733	pp = xgetpass("Password:");
 734
 735	crpp = XCRYPT(pw, pp, srpp);
 736	if ((strcmp(crpp, srpp) == 0)
 737#ifdef AFS
 738	    || (ka_UserAuthenticateGeneral(KA_USERAUTH_VERSION,
 739					   afsname,     /* name */
 740					   NULL,        /* instance */
 741					   NULL,        /* realm */
 742					   pp,          /* password */
 743					   0,           /* lifetime */
 744					   0, 0,         /* spare */
 745					   NULL)        /* reason */
 746	    == 0)
 747#endif /* AFS */
 748	    ) {
 749	    (void) memset(pp, 0, strlen(pp));
 750	    if (GettingInput && !just_signaled) {
 751		(void) Rawmode();
 752		ClearLines();
 753		ClearDisp();
 754		Refresh();
 755	    }
 756	    just_signaled = 0;
 757	    return;
 758	}
 759	xprintf(CGETS(22, 2, "\nIncorrect passwd for %s\n"), pw->pw_name);
 760    }
 761#endif /* NO_CRYPT */
 762    auto_logout();
 763}
 764
 765
 766static void
 767auto_logout(void)
 768{
 769    xprintf("auto-logout\n");
 770    /* Don't leave the tty in raw mode */
 771    if (editing)
 772	(void) Cookedmode();
 773    xclose(SHIN);
 774    setcopy(STRlogout, STRautomatic, VAR_READWRITE);
 775    child = 1;
 776#ifdef TESLA
 777    do_logout = 1;
 778#endif /* TESLA */
 779    GettingInput = FALSE; /* make flush() work to write hist files. Huber*/
 780    goodbye(NULL, NULL);
 781}
 782
 783void
 784alrmcatch(void)
 785{
 786    (*alm_fun)();
 787    setalarm(1);
 788}
 789
 790/*
 791 * Karl Kleinpaste, 21oct1983.
 792 * Added precmd(), which checks for the alias
 793 * precmd in aliases.  If it's there, the alias
 794 * is executed as a command.  This is done
 795 * after mailchk() and just before print-
 796 * ing the prompt.  Useful for things like printing
 797 * one's current directory just before each command.
 798 */
 799void
 800precmd(void)
 801{
 802    pintr_disabled++;
 803    cleanup_push(&pintr_disabled, disabled_cleanup);
 804    if (precmd_active) {	/* an error must have been caught */
 805	aliasrun(2, STRunalias, STRprecmd);
 806	xprintf("%s", CGETS(22, 3, "Faulty alias 'precmd' removed.\n"));
 807	goto leave;
 808    }
 809    precmd_active = 1;
 810    if (!whyles && adrof1(STRprecmd, &aliases))
 811	aliasrun(1, STRprecmd, NULL);
 812leave:
 813    precmd_active = 0;
 814    cleanup_until(&pintr_disabled);
 815}
 816
 817void
 818postcmd(void)
 819{
 820    pintr_disabled++;
 821    cleanup_push(&pintr_disabled, disabled_cleanup);
 822    if (postcmd_active) {	/* an error must have been caught */
 823	aliasrun(2, STRunalias, STRpostcmd);
 824	xprintf("%s", CGETS(22, 3, "Faulty alias 'postcmd' removed.\n"));
 825	goto leave;
 826    }
 827    postcmd_active = 1;
 828    if (!whyles && adrof1(STRpostcmd, &aliases))
 829	aliasrun(1, STRpostcmd, NULL);
 830leave:
 831    postcmd_active = 0;
 832    cleanup_until(&pintr_disabled);
 833}
 834
 835/*
 836 * Paul Placeway  11/24/87  Added cwd_cmd by hacking precmd() into
 837 * submission...  Run every time $cwd is set (after it is set).  Useful
 838 * for putting your machine and cwd (or anything else) in an xterm title
 839 * space.
 840 */
 841void
 842cwd_cmd(void)
 843{
 844    pintr_disabled++;
 845    cleanup_push(&pintr_disabled, disabled_cleanup);
 846    if (cwdcmd_active) {	/* an error must have been caught */
 847	aliasrun(2, STRunalias, STRcwdcmd);
 848	xprintf("%s", CGETS(22, 4, "Faulty alias 'cwdcmd' removed.\n"));
 849	goto leave;
 850    }
 851    cwdcmd_active = 1;
 852    if (!whyles && adrof1(STRcwdcmd, &aliases))
 853	aliasrun(1, STRcwdcmd, NULL);
 854leave:
 855    cwdcmd_active = 0;
 856    cleanup_until(&pintr_disabled);
 857}
 858
 859/*
 860 * Joachim Hoenig  07/16/91  Added beep_cmd, run every time tcsh wishes 
 861 * to beep the terminal bell. Useful for playing nice sounds instead.
 862 */
 863void
 864beep_cmd(void)
 865{
 866    pintr_disabled++;
 867    cleanup_push(&pintr_disabled, disabled_cleanup);
 868    if (beepcmd_active) {	/* an error must have been caught */
 869	aliasrun(2, STRunalias, STRbeepcmd);
 870	xprintf("%s", CGETS(22, 5, "Faulty alias 'beepcmd' removed.\n"));
 871    }
 872    else {
 873	beepcmd_active = 1;
 874	if (!whyles && adrof1(STRbeepcmd, &aliases))
 875	    aliasrun(1, STRbeepcmd, NULL);
 876    }
 877    beepcmd_active = 0;
 878    cleanup_until(&pintr_disabled);
 879}
 880
 881
 882/*
 883 * Karl Kleinpaste, 18 Jan 1984.
 884 * Added period_cmd(), which executes the alias "periodic" every
 885 * $tperiod minutes.  Useful for occasional checking of msgs and such.
 886 */
 887void
 888period_cmd(void)
 889{
 890    Char *vp;
 891    time_t  t, interval;
 892
 893    pintr_disabled++;
 894    cleanup_push(&pintr_disabled, disabled_cleanup);
 895    if (periodic_active) {	/* an error must have been caught */
 896	aliasrun(2, STRunalias, STRperiodic);
 897	xprintf("%s", CGETS(22, 6, "Faulty alias 'periodic' removed.\n"));
 898	goto leave;
 899    }
 900    periodic_active = 1;
 901    if (!whyles && adrof1(STRperiodic, &aliases)) {
 902	vp = varval(STRtperiod);
 903	if (vp == STRNULL) {
 904	    aliasrun(1, STRperiodic, NULL);
 905	    goto leave;
 906	}
 907	interval = getn(vp);
 908	(void) time(&t);
 909	if (t - t_period >= interval * 60) {
 910	    t_period = t;
 911	    aliasrun(1, STRperiodic, NULL);
 912	}
 913    }
 914leave:
 915    periodic_active = 0;
 916    cleanup_until(&pintr_disabled);
 917}
 918
 919
 920/* 
 921 * GrP Greg Parker May 2001
 922 * Added job_cmd(), which is run every time a job is started or 
 923 * foregrounded. The command is passed a single argument, the string 
 924 * used to start the job originally. With precmd, useful for setting 
 925 * xterm titles.
 926 * Cloned from cwd_cmd().
 927 */
 928void
 929job_cmd(Char *args)
 930{
 931    pintr_disabled++;
 932    cleanup_push(&pintr_disabled, disabled_cleanup);
 933    if (jobcmd_active) {	/* an error must have been caught */
 934	aliasrun(2, STRunalias, STRjobcmd);
 935	xprintf("%s", CGETS(22, 14, "Faulty alias 'jobcmd' removed.\n"));
 936	goto leave;
 937    }
 938    jobcmd_active = 1;
 939    if (!whyles && adrof1(STRjobcmd, &aliases)) {
 940	struct process *pp = pcurrjob; /* put things back after the hook */
 941	aliasrun(2, STRjobcmd, args);
 942	pcurrjob = pp;
 943    }
 944leave:
 945    jobcmd_active = 0;
 946    cleanup_until(&pintr_disabled);
 947}
 948
 949
 950/*
 951 * Karl Kleinpaste, 21oct1983.
 952 * Set up a one-word alias command, for use for special things.
 953 * This code is based on the mainline of process().
 954 */
 955void
 956aliasrun(int cnt, Char *s1, Char *s2)
 957{
 958    struct wordent w, *new1, *new2;	/* for holding alias name */
 959    struct command *t = NULL;
 960    jmp_buf_t osetexit;
 961    int status;
 962    size_t omark;
 963
 964    getexit(osetexit);
 965    if (seterr) {
 966	xfree(seterr);
 967	seterr = NULL;	/* don't repeatedly print err msg. */
 968    }
 969    w.word = STRNULL;
 970    new1 = xcalloc(1, sizeof w);
 971    new1->word = Strsave(s1);
 972    if (cnt == 1) {
 973	/* build a lex list with one word. */
 974	w.next = w.prev = new1;
 975	new1->next = new1->prev = &w;
 976    }
 977    else {
 978	/* build a lex list with two words. */
 979	new2 = xcalloc(1, sizeof w);
 980	new2->word = Strsave(s2);
 981	w.next = new2->prev = new1;
 982	new1->next = w.prev = new2;
 983	new1->prev = new2->next = &w;
 984    }
 985    cleanup_push(&w, lex_cleanup);
 986
 987    /* Save the old status */
 988    status = getn(varval(STRstatus));
 989
 990    /* expand aliases like process() does. */
 991    alias(&w);
 992    /* build a syntax tree for the command. */
 993    t = syntax(w.next, &w, 0);
 994    cleanup_push(t, syntax_cleanup);
 995    if (seterr)
 996	stderror(ERR_OLD);
 997
 998    psavejob();
 999    cleanup_push(&cnt, psavejob_cleanup); /* cnt is used only as a marker */
1000
1001    /* catch any errors here */
1002    omark = cleanup_push_mark();
1003    if (setexit() == 0)
1004	/* execute the parse tree. */
1005	/*
1006	 * From: Michael Schroeder <mlschroe@immd4.informatik.uni-erlangen.de>
1007	 * was execute(t, tpgrp);
1008	 */
1009	execute(t, tpgrp > 0 ? tpgrp : -1, NULL, NULL, TRUE);
1010    /* reset the error catcher to the old place */
1011    cleanup_pop_mark(omark);
1012    resexit(osetexit);
1013    if (haderr) {
1014	haderr = 0;
1015	/*
1016	 * Either precmd, or cwdcmd, or periodic had an error. Call it again so
1017	 * that it is removed
1018	 */
1019	if (precmd_active)
1020	    precmd();
1021	if (postcmd_active)
1022	    postcmd();
1023#ifdef notdef
1024	/*
1025	 * XXX: On the other hand, just interrupting them causes an error too.
1026	 * So if we hit ^C in the middle of cwdcmd or periodic the alias gets
1027	 * removed. We don't want that. Note that we want to remove precmd
1028	 * though, cause that could lead into an infinite loop. This should be
1029	 * fixed correctly, but then haderr should give us the whole exit
1030	 * status not just true or false.
1031	 */
1032	else if (cwdcmd_active)
1033	    cwd_cmd();
1034	else if (beepcmd_active)
1035	    beep_cmd();
1036	else if (periodic_active)
1037	    period_cmd();
1038#endif /* notdef */
1039    }
1040    cleanup_until(&w);
1041    pendjob();
1042    /* Restore status */
1043    setv(STRstatus, putn((tcsh_number_t)status), VAR_READWRITE);
1044}
1045
1046void
1047setalarm(int lck)
1048{
1049    struct varent *vp;
1050    Char   *cp;
1051    unsigned alrm_time = 0, logout_time, lock_time;
1052    time_t cl, nl, sched_dif;
1053
1054    if ((vp = adrof(STRautologout)) != NULL && vp->vec != NULL) {
1055	if ((cp = vp->vec[0]) != 0) {
1056	    if ((logout_time = (unsigned) atoi(short2str(cp)) * 60) > 0) {
1057#ifdef SOLARIS2
1058		/*
1059		 * Solaris alarm(2) uses a timer based in clock ticks
1060		 * internally so it multiplies our value with CLK_TCK...
1061		 * Of course that can overflow leading to unexpected
1062		 * results, so we clip it here. Grr. Where is that
1063		 * documented folks?
1064		 */
1065		if (logout_time >= 0x7fffffff / CLK_TCK)
1066			logout_time = 0x7fffffff / CLK_TCK;
1067#endif /* SOLARIS2 */
1068		alrm_time = logout_time;
1069		alm_fun = auto_logout;
1070	    }
1071	}
1072	if ((cp = vp->vec[1]) != 0) {
1073	    if ((lock_time = (unsigned) atoi(short2str(cp)) * 60) > 0) {
1074		if (lck) {
1075		    if (alrm_time == 0 || lock_time < alrm_time) {
1076			alrm_time = lock_time;
1077			alm_fun = auto_lock;
1078		    }
1079		}
1080		else /* lock_time always < alrm_time */
1081		    if (alrm_time)
1082			alrm_time -= lock_time;
1083	    }
1084	}
1085    }
1086    if ((nl = sched_next()) != -1) {
1087	(void) time(&cl);
1088	sched_dif = nl > cl ? nl - cl : 0;
1089	if ((alrm_time == 0) || ((unsigned) sched_dif < alrm_time)) {
1090	    alrm_time = ((unsigned) sched_dif) + 1;
1091	    alm_fun = sched_run;
1092	}
1093    }
1094    alrmcatch_disabled = 0;
1095    (void) alarm(alrm_time);	/* Autologout ON */
1096}
1097
1098#undef RMDEBUG			/* For now... */
1099
1100void
1101rmstar(struct wordent *cp)
1102{
1103    struct wordent *we, *args;
1104    struct wordent *tmp, *del;
1105
1106#ifdef RMDEBUG
1107    static Char STRrmdebug[] = {'r', 'm', 'd', 'e', 'b', 'u', 'g', '\0'};
1108    Char   *tag;
1109#endif /* RMDEBUG */
1110    Char   *charac;
1111    char    c;
1112    int     ask, doit, star = 0, silent = 0;
1113
1114    if (!adrof(STRrmstar))
1115	return;
1116#ifdef RMDEBUG
1117    tag = varval(STRrmdebug);
1118#endif /* RMDEBUG */
1119    we = cp->next;
1120    while (*we->word == ';' && we != cp)
1121	we = we->next;
1122    while (we != cp) {
1123#ifdef RMDEBUG
1124	if (*tag)
1125	    xprintf(CGETS(22, 7, "parsing command line\n"));
1126#endif /* RMDEBUG */
1127	if (!Strcmp(we->word, STRrm)) {
1128	    args = we->next;
1129	    ask = (*args->word != '-');
1130	    while (*args->word == '-' && !silent) {	/* check options */
1131		for (charac = (args->word + 1); *charac && !silent; charac++)
1132		    silent = (*charac == 'i' || *charac == 'f');
1133		args = args->next;
1134	    }
1135	    ask = (ask || (!ask && !silent));
1136	    if (ask) {
1137		for (; !star && *args->word != ';'
1138		     && args != cp; args = args->next)
1139		    if (!Strcmp(args->word, STRstar))
1140			star = 1;
1141		if (ask && star) {
1142		    xprintf("%s", CGETS(22, 8,
1143			    "Do you really want to delete all files? [n/y] "));
1144		    flush();
1145		    (void) force_read(SHIN, &c, 1);
1146		    /* 
1147		     * Perhaps we should use the yesexpr from the
1148		     * actual locale
1149		     */
1150		    doit = (strchr(CGETS(22, 14, "Yy"), c) != NULL);
1151		    while (c != '\n' && force_read(SHIN, &c, 1) == 1)
1152			continue;
1153		    if (!doit) {
1154			/* remove the command instead */
1155#ifdef RMDEBUG
1156			if (*tag)
1157			    xprintf(CGETS(22, 9,
1158				    "skipping deletion of files!\n"));
1159#endif /* RMDEBUG */
1160			for (tmp = we;
1161			     *tmp->word != '\n' &&
1162			     *tmp->word != ';' && tmp != cp;) {
1163			    tmp->prev->next = tmp->next;
1164			    tmp->next->prev = tmp->prev;
1165			    xfree(tmp->word);
1166			    del = tmp;
1167			    tmp = tmp->next;
1168			    xfree(del);
1169			}
1170			if (*tmp->word == ';') {
1171			    tmp->prev->next = tmp->next;
1172			    tmp->next->prev = tmp->prev;
1173			    xfree(tmp->word);
1174			    del = tmp;
1175			    tmp = tmp->next;
1176			    xfree(del);
1177			}
1178			we = tmp;
1179			continue;
1180		    }
1181		}
1182	    }
1183	}
1184	for (we = we->next;
1185	     *we->word != ';' && we != cp;
1186	     we = we->next)
1187	    continue;
1188	if (*we->word == ';')
1189	    we = we->next;
1190    }
1191#ifdef RMDEBUG
1192    if (*tag) {
1193	xprintf(CGETS(22, 10, "command line now is:\n"));
1194	for (we = cp->next; we != cp; we = we->next)
1195	    xprintf("%S ", we->word);
1196    }
1197#endif /* RMDEBUG */
1198    return;
1199}
1200
1201#ifdef BSDJOBS
1202/* Check if command is in continue list
1203   and do a "aliasing" if it exists as a job in background */
1204
1205#undef CNDEBUG			/* For now */
1206void
1207continue_jobs(struct wordent *cp)
1208{
1209    struct wordent *we;
1210    struct process *pp, *np;
1211    Char   *cmd, *continue_list, *continue_args_list;
1212
1213#ifdef CNDEBUG
1214    Char   *tag;
1215    static Char STRcndebug[] =
1216    {'c', 'n', 'd', 'e', 'b', 'u', 'g', '\0'};
1217#endif /* CNDEBUG */
1218    int    in_cont_list, in_cont_arg_list;
1219
1220
1221#ifdef CNDEBUG
1222    tag = varval(STRcndebug);
1223#endif /* CNDEBUG */
1224    continue_list = varval(STRcontinue);
1225    continue_args_list = varval(STRcontinue_args);
1226    if (*continue_list == '\0' && *continue_args_list == '\0')
1227	return;
1228
1229    we = cp->next;
1230    while (*we->word == ';' && we != cp)
1231	we = we->next;
1232    while (we != cp) {
1233#ifdef CNDEBUG
1234	if (*tag)
1235	    xprintf(CGETS(22, 11, "parsing command line\n"));
1236#endif /* CNDEBUG */
1237	cmd = we->word;
1238	in_cont_list = inlist(continue_list, cmd);
1239	in_cont_arg_list = inlist(continue_args_list, cmd);
1240	if (in_cont_list || in_cont_arg_list) {
1241#ifdef CNDEBUG
1242	    if (*tag)
1243		xprintf(CGETS(22, 12, "in one of the lists\n"));
1244#endif /* CNDEBUG */
1245	    np = NULL;
1246	    for (pp = proclist.p_next; pp; pp = pp->p_next) {
1247		if (prefix(cmd, pp->p_command)) {
1248		    if (pp->p_index) {
1249			np = pp;
1250			break;
1251		    }
1252		}
1253	    }
1254	    if (np) {
1255		insert(we, in_cont_arg_list);
1256	    }
1257	}
1258	for (we = we->next;
1259	     *we->word != ';' && we != cp;
1260	     we = we->next)
1261	    continue;
1262	if (*we->word == ';')
1263	    we = we->next;
1264    }
1265#ifdef CNDEBUG
1266    if (*tag) {
1267	xprintf(CGETS(22, 13, "command line now is:\n"));
1268	for (we = cp->next; we != cp; we = we->next)
1269	    xprintf("%S ", we->word);
1270    }
1271#endif /* CNDEBUG */
1272    return;
1273}
1274
1275/* The actual "aliasing" of for backgrounds() is done here
1276   with the aid of insert_we().   */
1277static void
1278insert(struct wordent *pl, int file_args)
1279{
1280    struct wordent *now, *last;
1281    Char   *cmd, *bcmd, *cp1, *cp2;
1282    size_t cmd_len;
1283    Char   *upause = STRunderpause;
1284    size_t p_len = Strlen(upause);
1285
1286    cmd_len = Strlen(pl->word);
1287    cmd = xcalloc(1, (cmd_len + 1) * sizeof(Char));
1288    (void) Strcpy(cmd, pl->word);
1289/* Do insertions at beginning, first replace command word */
1290
1291    if (file_args) {
1292	now = pl;
1293	xfree(now->word);
1294	now->word = xcalloc(1, 5 * sizeof(Char));
1295	(void) Strcpy(now->word, STRecho);
1296
1297	now = xcalloc(1, sizeof(struct wordent));
1298	now->word = xcalloc(1, 6 * sizeof(Char));
1299	(void) Strcpy(now->word, STRbackqpwd);
1300	insert_we(now, pl);
1301
1302	for (last = now; *last->word != '\n' && *last->word != ';';
1303	     last = last->next)
1304	    continue;
1305
1306	now = xcalloc(1, sizeof(struct wordent));
1307	now->word = xcalloc(1, 2 * sizeof(Char));
1308	(void) Strcpy(now->word, STRgt);
1309	insert_we(now, last->prev);
1310
1311	now = xcalloc(1, sizeof(struct wordent));
1312	now->word = xcalloc(1, 2 * sizeof(Char));
1313	(void) Strcpy(now->word, STRbang);
1314	insert_we(now, last->prev);
1315
1316	now = xcalloc(1, sizeof(struct wordent));
1317	now->word = xcalloc(1, (cmd_len + p_len + 4) * sizeof(Char));
1318	cp1 = now->word;
1319	cp2 = cmd;
1320	*cp1++ = '~';
1321	*cp1++ = '/';
1322	*cp1++ = '.';
1323	while ((*cp1++ = *cp2++) != '\0')
1324	    continue;
1325	cp1--;
1326	cp2 = upause;
1327	while ((*cp1++ = *cp2++) != '\0')
1328	    continue;
1329	insert_we(now, last->prev);
1330
1331	now = xcalloc(1, sizeof(struct wordent));
1332	now->word = xcalloc(1, 2 * sizeof(Char));
1333	(void) Strcpy(now->word, STRsemi);
1334	insert_we(now, last->prev);
1335	bcmd = xcalloc(1, (cmd_len + 2) * sizeof(Char));
1336	*bcmd = '%';
1337	Strcpy(bcmd + 1, cmd);
1338	now = xcalloc(1, sizeof(struct wordent));
1339	now->word = bcmd;
1340	insert_we(now, last->prev);
1341    }
1342    else {
1343	struct wordent *del;
1344
1345	now = pl;
1346	xfree(now->word);
1347	now->word = xcalloc(1, (cmd_len + 2) * sizeof(Char));
1348	*now->word = '%';
1349	Strcpy(now->word + 1, cmd);
1350	for (now = now->next;
1351	     *now->word != '\n' && *now->word != ';' && now != pl;) {
1352	    now->prev->next = now->next;
1353	    now->next->prev = now->prev;
1354	    xfree(now->word);
1355	    del = now;
1356	    now = now->next;
1357	    xfree(del);
1358	}
1359    }
1360}
1361
1362static void
1363insert_we(struct wordent *new, struct wordent *where)
1364{
1365
1366    new->prev = where;
1367    new->next = where->next;
1368    where->next = new;
1369    new->next->prev = new;
1370}
1371
1372static int
1373inlist(Char *list, Char *name)
1374{
1375    Char *l, *n;
1376
1377    l = list;
1378    n = name;
1379
1380    while (*l && *n) {
1381	if (*l == *n) {
1382	    l++;
1383	    n++;
1384	    if (*n == '\0' && (*l == ' ' || *l == '\0'))
1385		return (1);
1386	    else
1387		continue;
1388	}
1389	else {
1390	    while (*l && *l != ' ')
1391		l++;		/* skip to blank */
1392	    while (*l && *l == ' ')
1393		l++;		/* and find first nonblank character */
1394	    n = name;
1395	}
1396    }
1397    return (0);
1398}
1399
1400#endif /* BSDJOBS */
1401
1402
1403/*
1404 * Implement a small cache for tilde names. This is used primarily
1405 * to expand tilde names to directories, but also
1406 * we can find users from their home directories for the tilde
1407 * prompt, on machines where yp lookup is slow this can be a big win...
1408 * As with any cache this can run out of sync, rehash can sync it again.
1409 */
1410static struct tildecache {
1411    Char   *user;
1412    Char   *home;
1413    size_t  hlen;
1414}      *tcache = NULL;
1415
1416#define TILINCR 10
1417size_t tlength = 0;
1418static size_t tsize = TILINCR;
1419
1420static int
1421tildecompare(const void *xp1, const void *xp2)
1422{
1423    const struct tildecache *p1, *p2;
1424
1425    p1 = xp1;
1426    p2 = xp2;
1427    return Strcmp(p1->user, p2->user);
1428}
1429
1430static Char *
1431gethomedir(const Char *us)
1432{
1433    struct passwd *pp;
1434#ifdef HESIOD
1435    char **res, **res1, *cp;
1436    Char *rp;
1437#endif /* HESIOD */
1438    
1439    pp = xgetpwnam(short2str(us));
1440#ifdef YPBUGS
1441    fix_yp_bugs();
1442#endif /* YPBUGS */
1443    if (pp != NULL) {
1444#if 0
1445	/* Don't return if root */
1446	if (pp->pw_dir[0] == '/' && pp->pw_dir[1] == '\0')
1447	    return NULL;
1448	else
1449#endif
1450	    return Strsave(str2short(pp->pw_dir));
1451    }
1452#ifdef HESIOD
1453    res = hes_resolve(short2str(us), "filsys");
1454    rp = NULL;
1455    if (res != NULL) {
1456	if ((*res) != NULL) {
1457	    /*
1458	     * Look at the first token to determine how to interpret
1459	     * the rest of it.
1460	     * Yes, strtok is evil (it's not thread-safe), but it's also
1461	     * easy to use.
1462	     */
1463	    cp = strtok(*res, " ");
1464	    if (strcmp(cp, "AFS") == 0) {
1465		/* next token is AFS pathname.. */
1466		cp = strtok(NULL, " ");
1467		if (cp != NULL)
1468		    rp = Strsave(str2short(cp));
1469	    } else if (strcmp(cp, "NFS") == 0) {
1470		cp = NULL;
1471		if ((strtok(NULL, " ")) && /* skip remote pathname */
1472		    (strtok(NULL, " ")) && /* skip host */
1473		    (strtok(NULL, " ")) && /* skip mode */
1474		    (cp = strtok(NULL, " "))) {
1475		    rp = Strsave(str2short(cp));
1476		}
1477	    }
1478	}
1479	for (res1 = res; *res1; res1++)
1480	    free(*res1);
1481#if 0
1482	/* Don't return if root */
1483	if (rp != NULL && rp[0] == '/' && rp[1] == '\0') {
1484	    xfree(rp);
1485	    rp = NULL;
1486	}
1487#endif
1488	return rp;
1489    }
1490#endif /* HESIOD */
1491    return NULL;
1492}
1493
1494Char   *
1495gettilde(const Char *us)
1496{
1497    struct tildecache *bp1, *bp2, *bp;
1498    Char *hd;
1499
1500    /* Ignore NIS special names */
1501    if (*us == '+' || *us == '-')
1502	return NULL;
1503
1504    if (tcache == NULL)
1505	tcache = xmalloc(TILINCR * sizeof(struct tildecache));
1506    /*
1507     * Binary search
1508     */
1509    for (bp1 = tcache, bp2 = tcache + tlength; bp1 < bp2;) {
1510	int i;
1511
1512	bp = bp1 + ((bp2 - bp1) >> 1);
1513	if ((i = *us - *bp->user) == 0 && (i = Strcmp(us, bp->user)) == 0)
1514	    return (bp->home);
1515	if (i < 0)
1516	    bp2 = bp;
1517	else
1518	    bp1 = bp + 1;
1519    }
1520    /*
1521     * Not in the cache, try to get it from the passwd file
1522     */
1523    hd = gethomedir(us);
1524    if (hd == NULL)
1525	return NULL;
1526
1527    /*
1528     * Update the cache
1529     */
1530    tcache[tlength].user = Strsave(us);
1531    tcache[tlength].home = hd;
1532    tcache[tlength++].hlen = Strlen(hd);
1533
1534    qsort(tcache, tlength, sizeof(struct tildecache), tildecompare);
1535
1536    if (tlength == tsize) {
1537	tsize += TILINCR;
1538	tcache = xrealloc(tcache, tsize * sizeof(struct tildecache));
1539    }
1540    return (hd);
1541}
1542
1543/*
1544 * Return the username if the directory path passed contains a
1545 * user's home directory in the tilde cache, otherwise return NULL
1546 * hm points to the place where the path became different.
1547 * Special case: Our own home directory.
1548 * If we are passed a null pointer, then we flush the cache.
1549 */
1550Char   *
1551getusername(Char **hm)
1552{
1553    Char   *h, *p;
1554    size_t i, j;
1555
1556    if (hm == NULL) {
1557	for (i = 0; i < tlength; i++) {
1558	    xfree(tcache[i].home);
1559	    xfree(tcache[i].user);
1560	}
1561	xfree(tcache);
1562	tlength = 0;
1563	tsize = TILINCR;
1564	tcache = NULL;
1565	return NULL;
1566    }
1567    p = *hm;
1568    if (((h = varval(STRhome)) != STRNULL) &&
1569	(Strncmp(p, h, j = Strlen(h)) == 0) &&
1570	(p[j] == '/' || p[j] == '\0')) {
1571	*hm = &p[j];
1572	return STRNULL;
1573    }
1574    for (i = 0; i < tlength; i++)
1575	if ((Strncmp(p, tcache[i].home, (j = tcache[i].hlen)) == 0) &&
1576	    (p[j] == '/' || p[j] == '\0')) {
1577	    *hm = &p[j];
1578	    return tcache[i].user;
1579	}
1580    return NULL;
1581}
1582
1583
1584/*
1585 * set the shell-level var to 1 or apply change to it.
1586 */
1587void
1588shlvl(int val)
1589{
1590    char *cp;
1591
1592    if ((cp = getenv("SHLVL")) != NULL) {
1593
1594	if (loginsh)
1595	    val = 1;
1596	else
1597	    val += atoi(cp);
1598
1599	if (val <= 0) {
1600	    if (adrof(STRshlvl) != NULL)
1601		unsetv(STRshlvl);
1602	    Unsetenv(STRKSHLVL);
1603	}
1604	else {
1605	    Char *p;
1606
1607	    p = Itoa(val, 0, 0);
1608	    cleanup_push(p, xfree);
1609	    setv(STRshlvl, p, VAR_READWRITE);
1610	    cleanup_ignore(p);
1611	    cleanup_until(p);
1612	    tsetenv(STRKSHLVL, p);
1613	}
1614    }
1615    else {
1616	setcopy(STRshlvl, STR1, VAR_READWRITE);
1617	tsetenv(STRKSHLVL, STR1);
1618    }
1619}
1620
1621
1622/* fixio():
1623 *	Try to recover from a read error
1624 */
1625int
1626fixio(int fd, int e)
1627{
1628    switch (e) {
1629    case -1:	/* Make sure that the code is reachable */
1630
1631#ifdef EWOULDBLOCK
1632    case EWOULDBLOCK:
1633# define FDRETRY
1634#endif /* EWOULDBLOCK */
1635
1636#if defined(POSIX) && defined(EAGAIN)
1637# if !defined(EWOULDBLOCK) || EWOULDBLOCK != EAGAIN
1638    case EAGAIN:
1639#  define FDRETRY
1640# endif /* !EWOULDBLOCK || EWOULDBLOCK != EAGAIN */
1641#endif /* POSIX && EAGAIN */
1642
1643	e = -1;
1644#ifdef FDRETRY
1645# ifdef F_SETFL
1646/*
1647 * Great! we have on suns 3 flavors and 5 names...
1648 * I hope that will cover everything.
1649 * I added some more defines... many systems have different defines.
1650 * Rather than dealing with getting the right includes, we'll just
1651 * cover all the known possibilities here.  -- sterling@netcom.com
1652 */
1653#  ifndef O_NONBLOCK
1654#   define O_NONBLOCK 0
1655#  endif /* O_NONBLOCK */
1656#  ifndef O_NDELAY
1657#   define O_NDELAY 0
1658#  endif /* O_NDELAY */
1659#  ifndef FNBIO
1660#   define FNBIO 0
1661#  endif /* FNBIO */
1662#  ifndef _FNBIO
1663#   define _FNBIO 0
1664#  endif /* _FNBIO */
1665#  ifndef FNONBIO
1666#   define FNONBIO 0
1667#  endif /* FNONBIO */
1668#  ifndef FNONBLOCK
1669#   define FNONBLOCK 0
1670#  endif /* FNONBLOCK */
1671#  ifndef _FNONBLOCK
1672#   define _FNONBLOCK 0
1673#  endif /* _FNONBLOCK */
1674#  ifndef FNDELAY
1675#   define FNDELAY 0
1676#  endif /* FNDELAY */
1677#  ifndef _FNDELAY
1678#   define _FNDELAY 0
1679#  endif /* _FNDELAY */
1680#  ifndef FNDLEAY	/* Some linux versions have this typo */
1681#   define FNDLEAY 0
1682#  endif /* FNDLEAY */
1683	if ((e = fcntl(fd, F_GETFL, 0)) == -1)
1684	    return -1;
1685
1686	e &= ~(O_NDELAY|O_NONBLOCK|FNBIO|_FNBIO|FNONBIO|FNONBLOCK|_FNONBLOCK|
1687	       FNDELAY|_FNDELAY|FNDLEAY);	/* whew! */
1688	if (fcntl(fd, F_SETFL, e) == -1)
1689	    return -1;
1690	else 
1691	    e = 0;
1692# endif /* F_SETFL */
1693
1694# ifdef FIONBIO
1695	e = 0;
1696	if (ioctl(fd, FIONBIO, (ioctl_t) &e) == -1)
1697	    return -1;
1698# endif	/* FIONBIO */
1699
1700#endif /* FDRETRY */
1701	return e;
1702
1703    case EINTR:
1704	return 0;
1705
1706    default:
1707	return -1;
1708    }
1709}
1710
1711/* collate():
1712 *	String collation
1713 */
1714int
1715collate(const Char *a, const Char *b)
1716{
1717    int rv;
1718#ifdef SHORT_STRINGS
1719    /* This strips the quote bit as a side effect */
1720    char *sa = strsave(short2str(a));
1721    char *sb = strsave(short2str(b));
1722#else
1723    char *sa = strip(strsave(a));
1724    char *sb = strip(strsave(b));
1725#endif /* SHORT_STRINGS */
1726
1727#if defined(NLS) && defined(HAVE_STRCOLL)
1728    errno = 0;	/* strcoll sets errno, another brain-damage */
1729
1730    rv = strcoll(sa, sb);
1731
1732    /*
1733     * We should be checking for errno != 0, but some systems
1734     * forget to reset errno to 0. So we only check for the 
1735     * only documented valid errno value for strcoll [EINVAL]
1736     */
1737    if (errno == EINVAL) {
1738	xfree(sa);
1739	xfree(sb);
1740	stderror(ERR_SYSTEM, "strcoll", strerror(errno));
1741    }
1742#else
1743    rv = strcmp(sa, sb);
1744#endif /* NLS && HAVE_STRCOLL */
1745
1746    xfree(sa);
1747    xfree(sb);
1748
1749    return rv;
1750}
1751
1752#ifdef HASHBANG
1753/*
1754 * From: peter@zeus.dialix.oz.au (Peter Wemm)
1755 * If exec() fails look first for a #! [word] [word] ....
1756 * If it is, splice the header into the argument list and retry.
1757 */
1758#define HACKBUFSZ 1024		/* Max chars in #! vector */
1759int
1760hashbang(int fd, Char ***vp)
1761{
1762    struct blk_buf sarg = BLK_BUF_INIT;
1763    char lbuf[HACKBUFSZ], *p, *ws;
1764#ifdef WINNT_NATIVE
1765    int fw = 0; 	/* found at least one word */
1766    int first_word = 1;
1767    char *real;
1768#endif /* WINNT_NATIVE */
1769
1770    if (xread(fd, lbuf, HACKBUFSZ) <= 0)
1771	return -1;
1772
1773    ws = 0;	/* word started = 0 */
1774
1775    for (p = lbuf; p < &lbuf[HACKBUFSZ]; ) {
1776	switch (*p) {
1777	case ' ':
1778	case '\t':
1779#if defined(WINNT_NATIVE) || defined (__CYGWIN__)
1780	case '\r':
1781#endif /* WINNT_NATIVE || __CYGWIN__ */
1782	    if (ws) {	/* a blank after a word.. save it */
1783		*p = '\0';
1784#ifdef WINNT_NATIVE
1785		if (first_word) {
1786		    real = hb_subst(ws);
1787		    if (real != NULL)
1788			ws = real;
1789		}
1790	    	fw = 1;
1791		first_word = 0;
1792#endif /* WINNT_NATIVE */
1793		bb_append(&sarg, SAVE(ws));
1794		ws = NULL;
1795	    }
1796	    p++;
1797	    continue;
1798
1799	case '\0':	/* Whoa!! what the hell happened */
1800	    goto err;
1801
1802	case '\n':	/* The end of the line. */
1803	    if (
1804#ifdef WINNT_NATIVE
1805		fw ||
1806#endif /* WINNT_NATIVE */
1807		ws) {	/* terminate the last word */
1808		*p = '\0';
1809#ifdef WINNT_NATIVE
1810		/* deal with the 1-word case */
1811		if (first_word) {
1812		    real = hb_subst(ws);
1813		    if (real != NULL)
1814			ws = real;
1815		}
1816#endif /* !WINNT_NATIVE */
1817		if (ws)
1818		    bb_append(&sarg, SAVE(ws));
1819	    }
1820	    if (sarg.len > 0) {
1821		*vp = bb_finish(&sarg);
1822		return 0;
1823	    }
1824	    else
1825		goto err;
1826
1827	default:
1828	    if (!ws)	/* Start a new word? */
1829		ws = p; 
1830	    p++;
1831	    break;
1832	}
1833    }
1834 err:
1835    bb_cleanup(&sarg);
1836    return -1;
1837}
1838#endif /* HASHBANG */
1839
1840#ifdef REMOTEHOST
1841
1842static void
1843palarm(int snum)
1844{
1845    USE(snum);
1846    _exit(1);
1847}
1848
1849static void
1850getremotehost(int dest_fd)
1851{
1852    const char *host = NULL;
1853#ifdef INET6
1854    struct sockaddr_storage saddr;
1855    static char hbuf[NI_MAXHOST];
1856#else
1857    struct hostent* hp;
1858    struct sockaddr_in saddr;
1859#endif
1860    socklen_t len = sizeof(saddr);
1861
1862#ifdef INET6
1863    if (getpeername(SHIN, (struct sockaddr *) &saddr, &len) != -1 &&
1864	(saddr.ss_family == AF_INET6 || saddr.ss_family == AF_INET)) {
1865	int flag = NI_NUMERICHOST;
1866
1867#ifdef NI_WITHSCOPEID
1868	flag |= NI_WITHSCOPEID;
1869#endif
1870	getnameinfo((struct sockaddr *)&saddr, len, hbuf, sizeof(hbuf),
1871		    NULL, 0, flag);
1872	host = hbuf;
1873#else
1874    if (getpeername(SHIN, (struct sockaddr *) &saddr, &len) != -1 &&
1875	saddr.sin_family == AF_INET) {
1876#if 0
1877	if ((hp = gethostbyaddr((char *)&saddr.sin_addr, sizeof(struct in_addr),
1878				AF_INET)) != NULL)
1879	    host = hp->h_name;
1880	else
1881#endif
1882	    host = inet_ntoa(saddr.sin_addr);
1883#endif
1884    }
1885#ifdef HAVE_STRUCT_UTMP_UT_HOST
1886    else {
1887	char *ptr;
1888	char *name = utmphost();
1889	/* Avoid empty names and local X displays */
1890	if (name != NULL && *name != '\0' && *name != ':') {
1891	    struct in_addr addr;
1892	    char *sptr;
1893
1894	    /* Look for host:display.screen */
1895	    /*
1896	     * There is conflict with IPv6 address and X DISPLAY.  So,
1897	     * we assume there is no IPv6 address in utmp and don't
1898	     * touch here.
1899	     */
1900	    if ((sptr = strchr(name, ':')) != NULL)
1901		*sptr = '\0';
1902	    /* Leave IPv4 address as is */
1903	    /*
1904	     * we use inet_addr here, not inet_aton because many systems
1905	     * have not caught up yet.
1906	     */
1907	    addr.s_addr = inet_addr(name);
1908	    if (addr.s_addr != (unsigned int)~0)
1909		host = name;
1910	    else {
1911		if (sptr != name) {
1912#ifdef INET6
1913		    char *s, *domain;
1914		    char dbuf[MAXHOSTNAMELEN];
1915		    struct addrinfo hints, *res = NULL;
1916
1917		    memset(&hints, 0, sizeof(hints));
1918		    hints.ai_family = PF_UNSPEC;
1919		    hints.ai_socktype = SOCK_STREAM;
1920		    hints.ai_flags = AI_PASSIVE | AI_CANONNAME;
1921		    if (strlen(name) < utmphostsize())
1922		    {
1923			if (getaddrinfo(name, NULL, &hints, &res) != 0)
1924			    res = NULL;
1925		    } else if (gethostname(dbuf, sizeof(dbuf)) == 0 &&
1926			       (dbuf[sizeof(dbuf)-1] = '\0', /*FIXME: ugly*/
1927				(domain = strchr(dbuf, '.')) != NULL)) {
1928			for (s = strchr(name, '.');
1929			     s != NULL; s = strchr(s + 1, '.')) {
1930			    if (*(s + 1) != '\0' &&
1931				(ptr = strstr(domain, s)) != NULL) {
1932			        char *cbuf;
1933
1934				cbuf = strspl(name, ptr + strlen(s));
1935				if (getaddrinfo(cbuf, NULL, &hints, &res) != 0)
1936				    res = NULL;
1937				xfree(cbuf);
1938				break;
1939			    }
1940			}
1941		    }
1942		    if (res != NULL) {
1943			if (res->ai_canonname != NULL) {
1944			    strncpy(hbuf, res->ai_canonname, sizeof(hbuf));
1945			    hbuf[sizeof(hbuf) - 1] = '\0';
1946			    host = hbuf;
1947			}
1948			freeaddrinfo(res);
1949		    }
1950#else
1951		    if ((hp = gethostbyname(name)) == NULL) {
1952			/* Try again eliminating the trailing domain */
1953			if ((ptr = strchr(name, '.')) != NULL) {
1954			    *ptr = '\0';
1955			    if ((hp = gethostbyname(name)) != NULL)
1956				host = hp->h_name;
1957			    *ptr = '.';
1958			}
1959		    }
1960		    else
1961			host = hp->h_name;
1962#endif
1963		}
1964	    }
1965	}
1966    }
1967#endif
1968
1969    if (host) {
1970	size_t left;
1971
1972	left = strlen(host);
1973	while (left != 0) {
1974	    ssize_t res;
1975
1976	    res = xwrite(dest_fd, host, left);
1977	    if (res < 0)
1978		_exit(1);
1979	    host += res;
1980	    left -= res;
1981	}
1982    }
1983    _exit(0);
1984}
1985
1986/*
1987 * From: <lesv@ppvku.ericsson.se> (Lennart Svensson)
1988 */
1989void
1990remotehost(void)
1991{
1992    struct sigaction sa;
1993    struct strbuf hostname = strbuf_INIT;
1994    int fds[2], wait_options, status;
1995    pid_t pid, wait_res;
1996
1997    sa.sa_handler = SIG_DFL; /* Make sure a zombie is created */
1998    sigemptyset(&sa.sa_mask);
1999    sa.sa_flags = 0;
2000    sigaction(SIGCHLD, &sa, NULL);
2001    mypipe(fds);
2002    pid = fork();
2003    if (pid == 0) {
2004	sigset_t set;
2005	xclose(fds[0]);
2006	/* Don't get stuck if the resolver does not work! */
2007	signal(SIGALRM, palarm);
2008	sigemptyset(&set);
2009	sigaddset(&set, SIGALRM);
2010	(void)sigprocmask(SIG_UNBLOCK, &set, NULL);
2011	(void)alarm(2);
2012	getremotehost(fds[1]);
2013	/*NOTREACHED*/
2014    }
2015    xclose(fds[1]);
2016    for (;;) {
2017	char buf[BUFSIZE];
2018	ssize_t res;
2019
2020	res = xread(fds[0], buf, sizeof(buf));
2021	if (res == -1) {
2022	    hostname.len = 0;
2023	    wait_options = WNOHANG;
2024	    goto done;
2025	}
2026	if (res == 0)
2027	    break;
2028	strbuf_appendn(&hostname, buf, res);
2029    }
2030    wait_options = 0;
2031 done:
2032    cleanup_push(&hostname, strbuf_cleanup);
2033    xclose(fds[0]);
2034    while ((wait_res = waitpid(pid, &status, wait_options)) == -1
2035	   && errno == EINTR)
2036	handle_pending_signals();
2037    if (hostname.len > 0 && wait_res == pid && WIFEXITED(status)
2038	   && WEXITSTATUS(status) == 0) {
2039	strbuf_terminate(&hostname);
2040	tsetenv(STRREMOTEHOST, str2short(hostname.s));
2041    }
2042    cleanup_until(&hostname);
2043
2044#ifdef YPBUGS
2045    /* From: casper@fwi.uva.nl (Casper H.S. Dik), for Solaris 2.3 */
2046    fix_yp_bugs();
2047#endif /* YPBUGS */
2048
2049}
2050#endif /* REMOTEHOST */
2051
2052#ifndef WINNT_NATIVE
2053/*
2054 * indicate if a terminal type is defined in terminfo/termcap
2055 * (by default the current term type). This allows ppl to look
2056 * for a working term type automatically in their login scripts
2057 * when using a terminal known as different things on different
2058 * platforms
2059 */
2060void
2061dotermname(Char **v, struct command *c)
2062{
2063    char *termtype;
2064    /*
2065     * Maximum size of a termcap record. We make it twice as large.
2066     */
2067    char termcap_buffer[2048];
2068
2069    USE(c);
2070    /* try to find which entry we should be looking for */
2071    termtype = (v[1] == NULL ? getenv("TERM") : short2str(v[1]));
2072    if (termtype == NULL) {
2073	/* no luck - the user didn't provide one and none is 
2074	 * specified in the environment
2075	 */
2076	setcopy(STRstatus, STR1, VAR_READWRITE);
2077	return;
2078    }
2079
2080    /*
2081     * we use the termcap function - if we are using terminfo we 
2082     * will end up with it's compatibility function
2083     * terminfo/termcap will be initialized with the new
2084     * type but we don't care because tcsh has cached all the things
2085     * it needs.
2086     */
2087    if (tgetent(termcap_buffer, termtype) == 1) {
2088	xprintf("%s\n", termtype);
2089	setcopy(STRstatus, STR0, VAR_READWRITE);
2090    } else
2091	setcopy(STRstatus, STR1, VAR_READWRITE);
2092}
2093#endif /* WINNT_NATIVE */