xref: /freebsd/contrib/tcsh/tc.func.c (revision 13014ca04aad1931d41958b56f71a2c65b9a7a2c)
1 /* $Header: /p/tcsh/cvsroot/tcsh/tc.func.c,v 3.136 2006/09/01 12:51:35 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 
35 RCSID("$tcsh: tc.func.c,v 3.136 2006/09/01 12:51:35 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>
50 long ka_UserAuthenticateGeneral();
51 #endif /* AFS */
52 
53 #ifdef TESLA
54 extern int do_logout;
55 #endif /* TESLA */
56 extern time_t t_period;
57 extern int just_signaled;
58 static int precmd_active = 0;
59 static int jobcmd_active = 0; /* GrP */
60 static int postcmd_active = 0;
61 static int periodic_active = 0;
62 static int cwdcmd_active = 0;	/* PWP: for cwd_cmd */
63 static int beepcmd_active = 0;
64 static void (*alm_fun)(void) = NULL;
65 
66 static	void	 auto_logout	(void);
67 static	char	*xgetpass	(const char *);
68 static	void	 auto_lock	(void);
69 #ifdef BSDJOBS
70 static	void	 insert		(struct wordent *, int);
71 static	void	 insert_we	(struct wordent *, struct wordent *);
72 static	int	 inlist		(Char *, Char *);
73 #endif /* BSDJOBS */
74 static	int	 tildecompare	(const void *, const void *);
75 static  Char    *gethomedir	(const Char *);
76 #ifdef REMOTEHOST
77 static	void	 palarm		(int);
78 static	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 
98 Char   *
99 expand_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) ||
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 
142 Char   *
143 sprlex(const struct wordent *sp0)
144 {
145     return expand_lex(sp0, 0, INT_MAX);
146 }
147 
148 
149 Char *
150 Itoa(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 && --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*/
192 void
193 dolist(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 
380 extern int GotTermCaps;
381 
382 /*ARGSUSED*/
383 void
384 dotelltc(Char **v, struct command *c)
385 {
386     USE(v);
387     USE(c);
388     if (!GotTermCaps)
389 	GetTermCaps();
390     TellTC();
391 }
392 
393 /*ARGSUSED*/
394 void
395 doechotc(Char **v, struct command *c)
396 {
397     USE(c);
398     if (!GotTermCaps)
399 	GetTermCaps();
400     EchoTC(++v);
401 }
402 
403 /*ARGSUSED*/
404 void
405 dosettc(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  */
429 int
430 cmd_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*/
465 void
466 dowhich(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 
487 struct process *
488 find_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 
562 void
563 fg_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 
598 static char *
599 xgetpass(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*/
658 static void
659 auto_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(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(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 #define XCRYPT(a, b) crypt(a, b)
699 
700 #if !defined(__MVS__)
701     if ((pw = xgetpwuid(euid)) != NULL)	/* effective user passwd  */
702 	srpp = pw->pw_passwd;
703 #endif /* !MVS */
704 
705 #endif
706 
707     if (srpp == NULL) {
708 	auto_logout();
709 	/*NOTREACHED*/
710 	return;
711     }
712 
713     setalarm(0);		/* Not for locking any more */
714     xputchar('\n');
715     for (i = 0; i < 5; i++) {
716 	const char *crpp;
717 	char *pp;
718 #ifdef AFS
719 	char *afsname;
720 	Char *safs;
721 
722 	if ((safs = varval(STRafsuser)) != STRNULL)
723 	    afsname = short2str(safs);
724 	else
725 	    if ((afsname = getenv("AFSUSER")) == NULL)
726 	        afsname = pw->pw_name;
727 #endif
728 	pp = xgetpass("Password:");
729 
730 	crpp = XCRYPT(pp, srpp);
731 	if ((strcmp(crpp, srpp) == 0)
732 #ifdef AFS
733 	    || (ka_UserAuthenticateGeneral(KA_USERAUTH_VERSION,
734 					   afsname,     /* name */
735 					   NULL,        /* instance */
736 					   NULL,        /* realm */
737 					   pp,          /* password */
738 					   0,           /* lifetime */
739 					   0, 0,         /* spare */
740 					   NULL)        /* reason */
741 	    == 0)
742 #endif /* AFS */
743 	    ) {
744 	    (void) memset(pp, 0, strlen(pp));
745 	    if (GettingInput && !just_signaled) {
746 		(void) Rawmode();
747 		ClearLines();
748 		ClearDisp();
749 		Refresh();
750 	    }
751 	    just_signaled = 0;
752 	    return;
753 	}
754 	xprintf(CGETS(22, 2, "\nIncorrect passwd for %s\n"), pw->pw_name);
755     }
756 #endif /* NO_CRYPT */
757     auto_logout();
758 }
759 
760 
761 static void
762 auto_logout(void)
763 {
764     xprintf("auto-logout\n");
765     /* Don't leave the tty in raw mode */
766     if (editing)
767 	(void) Cookedmode();
768     xclose(SHIN);
769     setcopy(STRlogout, STRautomatic, VAR_READWRITE);
770     child = 1;
771 #ifdef TESLA
772     do_logout = 1;
773 #endif /* TESLA */
774     GettingInput = FALSE; /* make flush() work to write hist files. Huber*/
775     goodbye(NULL, NULL);
776 }
777 
778 void
779 alrmcatch(void)
780 {
781     (*alm_fun)();
782     setalarm(1);
783 }
784 
785 /*
786  * Karl Kleinpaste, 21oct1983.
787  * Added precmd(), which checks for the alias
788  * precmd in aliases.  If it's there, the alias
789  * is executed as a command.  This is done
790  * after mailchk() and just before print-
791  * ing the prompt.  Useful for things like printing
792  * one's current directory just before each command.
793  */
794 void
795 precmd(void)
796 {
797     pintr_disabled++;
798     cleanup_push(&pintr_disabled, disabled_cleanup);
799     if (precmd_active) {	/* an error must have been caught */
800 	aliasrun(2, STRunalias, STRprecmd);
801 	xprintf(CGETS(22, 3, "Faulty alias 'precmd' removed.\n"));
802 	goto leave;
803     }
804     precmd_active = 1;
805     if (!whyles && adrof1(STRprecmd, &aliases))
806 	aliasrun(1, STRprecmd, NULL);
807 leave:
808     precmd_active = 0;
809     cleanup_until(&pintr_disabled);
810 }
811 
812 void
813 postcmd(void)
814 {
815     pintr_disabled++;
816     cleanup_push(&pintr_disabled, disabled_cleanup);
817     if (postcmd_active) {	/* an error must have been caught */
818 	aliasrun(2, STRunalias, STRpostcmd);
819 	xprintf(CGETS(22, 3, "Faulty alias 'postcmd' removed.\n"));
820 	goto leave;
821     }
822     postcmd_active = 1;
823     if (!whyles && adrof1(STRpostcmd, &aliases))
824 	aliasrun(1, STRpostcmd, NULL);
825 leave:
826     postcmd_active = 0;
827     cleanup_until(&pintr_disabled);
828 }
829 
830 /*
831  * Paul Placeway  11/24/87  Added cwd_cmd by hacking precmd() into
832  * submission...  Run every time $cwd is set (after it is set).  Useful
833  * for putting your machine and cwd (or anything else) in an xterm title
834  * space.
835  */
836 void
837 cwd_cmd(void)
838 {
839     pintr_disabled++;
840     cleanup_push(&pintr_disabled, disabled_cleanup);
841     if (cwdcmd_active) {	/* an error must have been caught */
842 	aliasrun(2, STRunalias, STRcwdcmd);
843 	xprintf(CGETS(22, 4, "Faulty alias 'cwdcmd' removed.\n"));
844 	goto leave;
845     }
846     cwdcmd_active = 1;
847     if (!whyles && adrof1(STRcwdcmd, &aliases))
848 	aliasrun(1, STRcwdcmd, NULL);
849 leave:
850     cwdcmd_active = 0;
851     cleanup_until(&pintr_disabled);
852 }
853 
854 /*
855  * Joachim Hoenig  07/16/91  Added beep_cmd, run every time tcsh wishes
856  * to beep the terminal bell. Useful for playing nice sounds instead.
857  */
858 void
859 beep_cmd(void)
860 {
861     pintr_disabled++;
862     cleanup_push(&pintr_disabled, disabled_cleanup);
863     if (beepcmd_active) {	/* an error must have been caught */
864 	aliasrun(2, STRunalias, STRbeepcmd);
865 	xprintf(CGETS(22, 5, "Faulty alias 'beepcmd' removed.\n"));
866     }
867     else {
868 	beepcmd_active = 1;
869 	if (!whyles && adrof1(STRbeepcmd, &aliases))
870 	    aliasrun(1, STRbeepcmd, NULL);
871     }
872     beepcmd_active = 0;
873     cleanup_until(&pintr_disabled);
874 }
875 
876 
877 /*
878  * Karl Kleinpaste, 18 Jan 1984.
879  * Added period_cmd(), which executes the alias "periodic" every
880  * $tperiod minutes.  Useful for occasional checking of msgs and such.
881  */
882 void
883 period_cmd(void)
884 {
885     Char *vp;
886     time_t  t, interval;
887 
888     pintr_disabled++;
889     cleanup_push(&pintr_disabled, disabled_cleanup);
890     if (periodic_active) {	/* an error must have been caught */
891 	aliasrun(2, STRunalias, STRperiodic);
892 	xprintf(CGETS(22, 6, "Faulty alias 'periodic' removed.\n"));
893 	goto leave;
894     }
895     periodic_active = 1;
896     if (!whyles && adrof1(STRperiodic, &aliases)) {
897 	vp = varval(STRtperiod);
898 	if (vp == STRNULL) {
899 	    aliasrun(1, STRperiodic, NULL);
900 	    goto leave;
901 	}
902 	interval = getn(vp);
903 	(void) time(&t);
904 	if (t - t_period >= interval * 60) {
905 	    t_period = t;
906 	    aliasrun(1, STRperiodic, NULL);
907 	}
908     }
909 leave:
910     periodic_active = 0;
911     cleanup_until(&pintr_disabled);
912 }
913 
914 
915 /*
916  * GrP Greg Parker May 2001
917  * Added job_cmd(), which is run every time a job is started or
918  * foregrounded. The command is passed a single argument, the string
919  * used to start the job originally. With precmd, useful for setting
920  * xterm titles.
921  * Cloned from cwd_cmd().
922  */
923 void
924 job_cmd(Char *args)
925 {
926     pintr_disabled++;
927     cleanup_push(&pintr_disabled, disabled_cleanup);
928     if (jobcmd_active) {	/* an error must have been caught */
929 	aliasrun(2, STRunalias, STRjobcmd);
930 	xprintf(CGETS(22, 14, "Faulty alias 'jobcmd' removed.\n"));
931 	goto leave;
932     }
933     jobcmd_active = 1;
934     if (!whyles && adrof1(STRjobcmd, &aliases)) {
935 	struct process *pp = pcurrjob; /* put things back after the hook */
936 	aliasrun(2, STRjobcmd, args);
937 	pcurrjob = pp;
938     }
939 leave:
940     jobcmd_active = 0;
941     cleanup_until(&pintr_disabled);
942 }
943 
944 
945 /*
946  * Karl Kleinpaste, 21oct1983.
947  * Set up a one-word alias command, for use for special things.
948  * This code is based on the mainline of process().
949  */
950 void
951 aliasrun(int cnt, Char *s1, Char *s2)
952 {
953     struct wordent w, *new1, *new2;	/* for holding alias name */
954     struct command *t = NULL;
955     jmp_buf_t osetexit;
956     int status;
957     size_t omark;
958 
959     getexit(osetexit);
960     if (seterr) {
961 	xfree(seterr);
962 	seterr = NULL;	/* don't repeatedly print err msg. */
963     }
964     w.word = STRNULL;
965     new1 = xcalloc(1, sizeof w);
966     new1->word = Strsave(s1);
967     if (cnt == 1) {
968 	/* build a lex list with one word. */
969 	w.next = w.prev = new1;
970 	new1->next = new1->prev = &w;
971     }
972     else {
973 	/* build a lex list with two words. */
974 	new2 = xcalloc(1, sizeof w);
975 	new2->word = Strsave(s2);
976 	w.next = new2->prev = new1;
977 	new1->next = w.prev = new2;
978 	new1->prev = new2->next = &w;
979     }
980     cleanup_push(&w, lex_cleanup);
981 
982     /* Save the old status */
983     status = getn(varval(STRstatus));
984 
985     /* expand aliases like process() does. */
986     alias(&w);
987     /* build a syntax tree for the command. */
988     t = syntax(w.next, &w, 0);
989     cleanup_push(t, syntax_cleanup);
990     if (seterr)
991 	stderror(ERR_OLD);
992 
993     psavejob();
994     cleanup_push(&cnt, psavejob_cleanup); /* cnt is used only as a marker */
995 
996     /* catch any errors here */
997     omark = cleanup_push_mark();
998     if (setexit() == 0)
999 	/* execute the parse tree. */
1000 	/*
1001 	 * From: Michael Schroeder <mlschroe@immd4.informatik.uni-erlangen.de>
1002 	 * was execute(t, tpgrp);
1003 	 */
1004 	execute(t, tpgrp > 0 ? tpgrp : -1, NULL, NULL, TRUE);
1005     /* reset the error catcher to the old place */
1006     cleanup_pop_mark(omark);
1007     resexit(osetexit);
1008     if (haderr) {
1009 	haderr = 0;
1010 	/*
1011 	 * Either precmd, or cwdcmd, or periodic had an error. Call it again so
1012 	 * that it is removed
1013 	 */
1014 	if (precmd_active)
1015 	    precmd();
1016 	if (postcmd_active)
1017 	    postcmd();
1018 #ifdef notdef
1019 	/*
1020 	 * XXX: On the other hand, just interrupting them causes an error too.
1021 	 * So if we hit ^C in the middle of cwdcmd or periodic the alias gets
1022 	 * removed. We don't want that. Note that we want to remove precmd
1023 	 * though, cause that could lead into an infinite loop. This should be
1024 	 * fixed correctly, but then haderr should give us the whole exit
1025 	 * status not just true or false.
1026 	 */
1027 	else if (cwdcmd_active)
1028 	    cwd_cmd();
1029 	else if (beepcmd_active)
1030 	    beep_cmd();
1031 	else if (periodic_active)
1032 	    period_cmd();
1033 #endif /* notdef */
1034     }
1035     cleanup_until(&w);
1036     pendjob();
1037     /* Restore status */
1038     setv(STRstatus, putn(status), VAR_READWRITE);
1039 }
1040 
1041 void
1042 setalarm(int lck)
1043 {
1044     struct varent *vp;
1045     Char   *cp;
1046     unsigned alrm_time = 0, logout_time, lock_time;
1047     time_t cl, nl, sched_dif;
1048 
1049     if ((vp = adrof(STRautologout)) != NULL && vp->vec != NULL) {
1050 	if ((cp = vp->vec[0]) != 0) {
1051 	    if ((logout_time = (unsigned) atoi(short2str(cp)) * 60) > 0) {
1052 #ifdef SOLARIS2
1053 		/*
1054 		 * Solaris alarm(2) uses a timer based in clock ticks
1055 		 * internally so it multiplies our value with CLK_TCK...
1056 		 * Of course that can overflow leading to unexpected
1057 		 * results, so we clip it here. Grr. Where is that
1058 		 * documented folks?
1059 		 */
1060 		if (logout_time >= 0x7fffffff / CLK_TCK)
1061 			logout_time = 0x7fffffff / CLK_TCK;
1062 #endif /* SOLARIS2 */
1063 		alrm_time = logout_time;
1064 		alm_fun = auto_logout;
1065 	    }
1066 	}
1067 	if ((cp = vp->vec[1]) != 0) {
1068 	    if ((lock_time = (unsigned) atoi(short2str(cp)) * 60) > 0) {
1069 		if (lck) {
1070 		    if (alrm_time == 0 || lock_time < alrm_time) {
1071 			alrm_time = lock_time;
1072 			alm_fun = auto_lock;
1073 		    }
1074 		}
1075 		else /* lock_time always < alrm_time */
1076 		    if (alrm_time)
1077 			alrm_time -= lock_time;
1078 	    }
1079 	}
1080     }
1081     if ((nl = sched_next()) != -1) {
1082 	(void) time(&cl);
1083 	sched_dif = nl > cl ? nl - cl : 0;
1084 	if ((alrm_time == 0) || ((unsigned) sched_dif < alrm_time)) {
1085 	    alrm_time = ((unsigned) sched_dif) + 1;
1086 	    alm_fun = sched_run;
1087 	}
1088     }
1089     alrmcatch_disabled = 0;
1090     (void) alarm(alrm_time);	/* Autologout ON */
1091 }
1092 
1093 #undef RMDEBUG			/* For now... */
1094 
1095 void
1096 rmstar(struct wordent *cp)
1097 {
1098     struct wordent *we, *args;
1099     struct wordent *tmp, *del;
1100 
1101 #ifdef RMDEBUG
1102     static Char STRrmdebug[] = {'r', 'm', 'd', 'e', 'b', 'u', 'g', '\0'};
1103     Char   *tag;
1104 #endif /* RMDEBUG */
1105     Char   *charac;
1106     char    c;
1107     int     ask, doit, star = 0, silent = 0;
1108 
1109     if (!adrof(STRrmstar))
1110 	return;
1111 #ifdef RMDEBUG
1112     tag = varval(STRrmdebug);
1113 #endif /* RMDEBUG */
1114     we = cp->next;
1115     while (*we->word == ';' && we != cp)
1116 	we = we->next;
1117     while (we != cp) {
1118 #ifdef RMDEBUG
1119 	if (*tag)
1120 	    xprintf(CGETS(22, 7, "parsing command line\n"));
1121 #endif /* RMDEBUG */
1122 	if (!Strcmp(we->word, STRrm)) {
1123 	    args = we->next;
1124 	    ask = (*args->word != '-');
1125 	    while (*args->word == '-' && !silent) {	/* check options */
1126 		for (charac = (args->word + 1); *charac && !silent; charac++)
1127 		    silent = (*charac == 'i' || *charac == 'f');
1128 		args = args->next;
1129 	    }
1130 	    ask = (ask || (!ask && !silent));
1131 	    if (ask) {
1132 		for (; !star && *args->word != ';'
1133 		     && args != cp; args = args->next)
1134 		    if (!Strcmp(args->word, STRstar))
1135 			star = 1;
1136 		if (ask && star) {
1137 		    xprintf(CGETS(22, 8,
1138 			    "Do you really want to delete all files? [n/y] "));
1139 		    flush();
1140 		    (void) force_read(SHIN, &c, 1);
1141 		    /*
1142 		     * Perhaps we should use the yesexpr from the
1143 		     * actual locale
1144 		     */
1145 		    doit = (strchr(CGETS(22, 14, "Yy"), c) != NULL);
1146 		    while (c != '\n' && force_read(SHIN, &c, 1) == 1)
1147 			continue;
1148 		    if (!doit) {
1149 			/* remove the command instead */
1150 #ifdef RMDEBUG
1151 			if (*tag)
1152 			    xprintf(CGETS(22, 9,
1153 				    "skipping deletion of files!\n"));
1154 #endif /* RMDEBUG */
1155 			for (tmp = we;
1156 			     *tmp->word != '\n' &&
1157 			     *tmp->word != ';' && tmp != cp;) {
1158 			    tmp->prev->next = tmp->next;
1159 			    tmp->next->prev = tmp->prev;
1160 			    xfree(tmp->word);
1161 			    del = tmp;
1162 			    tmp = tmp->next;
1163 			    xfree(del);
1164 			}
1165 			if (*tmp->word == ';') {
1166 			    tmp->prev->next = tmp->next;
1167 			    tmp->next->prev = tmp->prev;
1168 			    xfree(tmp->word);
1169 			    del = tmp;
1170 			    tmp = tmp->next;
1171 			    xfree(del);
1172 			}
1173 			we = tmp;
1174 			continue;
1175 		    }
1176 		}
1177 	    }
1178 	}
1179 	for (we = we->next;
1180 	     *we->word != ';' && we != cp;
1181 	     we = we->next)
1182 	    continue;
1183 	if (*we->word == ';')
1184 	    we = we->next;
1185     }
1186 #ifdef RMDEBUG
1187     if (*tag) {
1188 	xprintf(CGETS(22, 10, "command line now is:\n"));
1189 	for (we = cp->next; we != cp; we = we->next)
1190 	    xprintf("%S ", we->word);
1191     }
1192 #endif /* RMDEBUG */
1193     return;
1194 }
1195 
1196 #ifdef BSDJOBS
1197 /* Check if command is in continue list
1198    and do a "aliasing" if it exists as a job in background */
1199 
1200 #undef CNDEBUG			/* For now */
1201 void
1202 continue_jobs(struct wordent *cp)
1203 {
1204     struct wordent *we;
1205     struct process *pp, *np;
1206     Char   *cmd, *continue_list, *continue_args_list;
1207 
1208 #ifdef CNDEBUG
1209     Char   *tag;
1210     static Char STRcndebug[] =
1211     {'c', 'n', 'd', 'e', 'b', 'u', 'g', '\0'};
1212 #endif /* CNDEBUG */
1213     int    in_cont_list, in_cont_arg_list;
1214 
1215 
1216 #ifdef CNDEBUG
1217     tag = varval(STRcndebug);
1218 #endif /* CNDEBUG */
1219     continue_list = varval(STRcontinue);
1220     continue_args_list = varval(STRcontinue_args);
1221     if (*continue_list == '\0' && *continue_args_list == '\0')
1222 	return;
1223 
1224     we = cp->next;
1225     while (*we->word == ';' && we != cp)
1226 	we = we->next;
1227     while (we != cp) {
1228 #ifdef CNDEBUG
1229 	if (*tag)
1230 	    xprintf(CGETS(22, 11, "parsing command line\n"));
1231 #endif /* CNDEBUG */
1232 	cmd = we->word;
1233 	in_cont_list = inlist(continue_list, cmd);
1234 	in_cont_arg_list = inlist(continue_args_list, cmd);
1235 	if (in_cont_list || in_cont_arg_list) {
1236 #ifdef CNDEBUG
1237 	    if (*tag)
1238 		xprintf(CGETS(22, 12, "in one of the lists\n"));
1239 #endif /* CNDEBUG */
1240 	    np = NULL;
1241 	    for (pp = proclist.p_next; pp; pp = pp->p_next) {
1242 		if (prefix(cmd, pp->p_command)) {
1243 		    if (pp->p_index) {
1244 			np = pp;
1245 			break;
1246 		    }
1247 		}
1248 	    }
1249 	    if (np) {
1250 		insert(we, in_cont_arg_list);
1251 	    }
1252 	}
1253 	for (we = we->next;
1254 	     *we->word != ';' && we != cp;
1255 	     we = we->next)
1256 	    continue;
1257 	if (*we->word == ';')
1258 	    we = we->next;
1259     }
1260 #ifdef CNDEBUG
1261     if (*tag) {
1262 	xprintf(CGETS(22, 13, "command line now is:\n"));
1263 	for (we = cp->next; we != cp; we = we->next)
1264 	    xprintf("%S ", we->word);
1265     }
1266 #endif /* CNDEBUG */
1267     return;
1268 }
1269 
1270 /* The actual "aliasing" of for backgrounds() is done here
1271    with the aid of insert_we().   */
1272 static void
1273 insert(struct wordent *pl, int file_args)
1274 {
1275     struct wordent *now, *last;
1276     Char   *cmd, *bcmd, *cp1, *cp2;
1277     size_t cmd_len;
1278     Char   *upause = STRunderpause;
1279     size_t p_len = Strlen(upause);
1280 
1281     cmd_len = Strlen(pl->word);
1282     cmd = xcalloc(1, (cmd_len + 1) * sizeof(Char));
1283     (void) Strcpy(cmd, pl->word);
1284 /* Do insertions at beginning, first replace command word */
1285 
1286     if (file_args) {
1287 	now = pl;
1288 	xfree(now->word);
1289 	now->word = xcalloc(1, 5 * sizeof(Char));
1290 	(void) Strcpy(now->word, STRecho);
1291 
1292 	now = xcalloc(1, sizeof(struct wordent));
1293 	now->word = xcalloc(1, 6 * sizeof(Char));
1294 	(void) Strcpy(now->word, STRbackqpwd);
1295 	insert_we(now, pl);
1296 
1297 	for (last = now; *last->word != '\n' && *last->word != ';';
1298 	     last = last->next)
1299 	    continue;
1300 
1301 	now = xcalloc(1, sizeof(struct wordent));
1302 	now->word = xcalloc(1, 2 * sizeof(Char));
1303 	(void) Strcpy(now->word, STRgt);
1304 	insert_we(now, last->prev);
1305 
1306 	now = xcalloc(1, sizeof(struct wordent));
1307 	now->word = xcalloc(1, 2 * sizeof(Char));
1308 	(void) Strcpy(now->word, STRbang);
1309 	insert_we(now, last->prev);
1310 
1311 	now = xcalloc(1, sizeof(struct wordent));
1312 	now->word = xcalloc(1, (cmd_len + p_len + 4) * sizeof(Char));
1313 	cp1 = now->word;
1314 	cp2 = cmd;
1315 	*cp1++ = '~';
1316 	*cp1++ = '/';
1317 	*cp1++ = '.';
1318 	while ((*cp1++ = *cp2++) != '\0')
1319 	    continue;
1320 	cp1--;
1321 	cp2 = upause;
1322 	while ((*cp1++ = *cp2++) != '\0')
1323 	    continue;
1324 	insert_we(now, last->prev);
1325 
1326 	now = xcalloc(1, sizeof(struct wordent));
1327 	now->word = xcalloc(1, 2 * sizeof(Char));
1328 	(void) Strcpy(now->word, STRsemi);
1329 	insert_we(now, last->prev);
1330 	bcmd = xcalloc(1, (cmd_len + 2) * sizeof(Char));
1331 	*bcmd = '%';
1332 	Strcpy(bcmd + 1, cmd);
1333 	now = xcalloc(1, sizeof(struct wordent));
1334 	now->word = bcmd;
1335 	insert_we(now, last->prev);
1336     }
1337     else {
1338 	struct wordent *del;
1339 
1340 	now = pl;
1341 	xfree(now->word);
1342 	now->word = xcalloc(1, (cmd_len + 2) * sizeof(Char));
1343 	*now->word = '%';
1344 	Strcpy(now->word + 1, cmd);
1345 	for (now = now->next;
1346 	     *now->word != '\n' && *now->word != ';' && now != pl;) {
1347 	    now->prev->next = now->next;
1348 	    now->next->prev = now->prev;
1349 	    xfree(now->word);
1350 	    del = now;
1351 	    now = now->next;
1352 	    xfree(del);
1353 	}
1354     }
1355 }
1356 
1357 static void
1358 insert_we(struct wordent *new, struct wordent *where)
1359 {
1360 
1361     new->prev = where;
1362     new->next = where->next;
1363     where->next = new;
1364     new->next->prev = new;
1365 }
1366 
1367 static int
1368 inlist(Char *list, Char *name)
1369 {
1370     Char *l, *n;
1371 
1372     l = list;
1373     n = name;
1374 
1375     while (*l && *n) {
1376 	if (*l == *n) {
1377 	    l++;
1378 	    n++;
1379 	    if (*n == '\0' && (*l == ' ' || *l == '\0'))
1380 		return (1);
1381 	    else
1382 		continue;
1383 	}
1384 	else {
1385 	    while (*l && *l != ' ')
1386 		l++;		/* skip to blank */
1387 	    while (*l && *l == ' ')
1388 		l++;		/* and find first nonblank character */
1389 	    n = name;
1390 	}
1391     }
1392     return (0);
1393 }
1394 
1395 #endif /* BSDJOBS */
1396 
1397 
1398 /*
1399  * Implement a small cache for tilde names. This is used primarily
1400  * to expand tilde names to directories, but also
1401  * we can find users from their home directories for the tilde
1402  * prompt, on machines where yp lookup is slow this can be a big win...
1403  * As with any cache this can run out of sync, rehash can sync it again.
1404  */
1405 static struct tildecache {
1406     Char   *user;
1407     Char   *home;
1408     size_t  hlen;
1409 }      *tcache = NULL;
1410 
1411 #define TILINCR 10
1412 size_t tlength = 0;
1413 static size_t tsize = TILINCR;
1414 
1415 static int
1416 tildecompare(const void *xp1, const void *xp2)
1417 {
1418     const struct tildecache *p1, *p2;
1419 
1420     p1 = xp1;
1421     p2 = xp2;
1422     return Strcmp(p1->user, p2->user);
1423 }
1424 
1425 static Char *
1426 gethomedir(const Char *us)
1427 {
1428     struct passwd *pp;
1429 #ifdef HESIOD
1430     char **res, **res1, *cp;
1431     Char *rp;
1432 #endif /* HESIOD */
1433 
1434     pp = xgetpwnam(short2str(us));
1435 #ifdef YPBUGS
1436     fix_yp_bugs();
1437 #endif /* YPBUGS */
1438     if (pp != NULL) {
1439 #if 0
1440 	/* Don't return if root */
1441 	if (pp->pw_dir[0] == '/' && pp->pw_dir[1] == '\0')
1442 	    return NULL;
1443 	else
1444 #endif
1445 	    return Strsave(str2short(pp->pw_dir));
1446     }
1447 #ifdef HESIOD
1448     res = hes_resolve(short2str(us), "filsys");
1449     rp = NULL;
1450     if (res != NULL) {
1451 	if ((*res) != NULL) {
1452 	    /*
1453 	     * Look at the first token to determine how to interpret
1454 	     * the rest of it.
1455 	     * Yes, strtok is evil (it's not thread-safe), but it's also
1456 	     * easy to use.
1457 	     */
1458 	    cp = strtok(*res, " ");
1459 	    if (strcmp(cp, "AFS") == 0) {
1460 		/* next token is AFS pathname.. */
1461 		cp = strtok(NULL, " ");
1462 		if (cp != NULL)
1463 		    rp = Strsave(str2short(cp));
1464 	    } else if (strcmp(cp, "NFS") == 0) {
1465 		cp = NULL;
1466 		if ((strtok(NULL, " ")) && /* skip remote pathname */
1467 		    (strtok(NULL, " ")) && /* skip host */
1468 		    (strtok(NULL, " ")) && /* skip mode */
1469 		    (cp = strtok(NULL, " "))) {
1470 		    rp = Strsave(str2short(cp));
1471 		}
1472 	    }
1473 	}
1474 	for (res1 = res; *res1; res1++)
1475 	    free(*res1);
1476 #if 0
1477 	/* Don't return if root */
1478 	if (rp != NULL && rp[0] == '/' && rp[1] == '\0') {
1479 	    xfree(rp);
1480 	    rp = NULL;
1481 	}
1482 #endif
1483 	return rp;
1484     }
1485 #endif /* HESIOD */
1486     return NULL;
1487 }
1488 
1489 Char   *
1490 gettilde(const Char *us)
1491 {
1492     struct tildecache *bp1, *bp2, *bp;
1493     Char *hd;
1494 
1495     /* Ignore NIS special names */
1496     if (*us == '+' || *us == '-')
1497 	return NULL;
1498 
1499     if (tcache == NULL)
1500 	tcache = xmalloc(TILINCR * sizeof(struct tildecache));
1501     /*
1502      * Binary search
1503      */
1504     for (bp1 = tcache, bp2 = tcache + tlength; bp1 < bp2;) {
1505 	int i;
1506 
1507 	bp = bp1 + ((bp2 - bp1) >> 1);
1508 	if ((i = *us - *bp->user) == 0 && (i = Strcmp(us, bp->user)) == 0)
1509 	    return (bp->home);
1510 	if (i < 0)
1511 	    bp2 = bp;
1512 	else
1513 	    bp1 = bp + 1;
1514     }
1515     /*
1516      * Not in the cache, try to get it from the passwd file
1517      */
1518     hd = gethomedir(us);
1519     if (hd == NULL)
1520 	return NULL;
1521 
1522     /*
1523      * Update the cache
1524      */
1525     tcache[tlength].user = Strsave(us);
1526     tcache[tlength].home = hd;
1527     tcache[tlength++].hlen = Strlen(hd);
1528 
1529     qsort(tcache, tlength, sizeof(struct tildecache), tildecompare);
1530 
1531     if (tlength == tsize) {
1532 	tsize += TILINCR;
1533 	tcache = xrealloc(tcache, tsize * sizeof(struct tildecache));
1534     }
1535     return (hd);
1536 }
1537 
1538 /*
1539  * Return the username if the directory path passed contains a
1540  * user's home directory in the tilde cache, otherwise return NULL
1541  * hm points to the place where the path became different.
1542  * Special case: Our own home directory.
1543  * If we are passed a null pointer, then we flush the cache.
1544  */
1545 Char   *
1546 getusername(Char **hm)
1547 {
1548     Char   *h, *p;
1549     size_t i, j;
1550 
1551     if (hm == NULL) {
1552 	for (i = 0; i < tlength; i++) {
1553 	    xfree(tcache[i].home);
1554 	    xfree(tcache[i].user);
1555 	}
1556 	xfree(tcache);
1557 	tlength = 0;
1558 	tsize = TILINCR;
1559 	tcache = NULL;
1560 	return NULL;
1561     }
1562     p = *hm;
1563     if (((h = varval(STRhome)) != STRNULL) &&
1564 	(Strncmp(p, h, j = Strlen(h)) == 0) &&
1565 	(p[j] == '/' || p[j] == '\0')) {
1566 	*hm = &p[j];
1567 	return STRNULL;
1568     }
1569     for (i = 0; i < tlength; i++)
1570 	if ((Strncmp(p, tcache[i].home, (j = tcache[i].hlen)) == 0) &&
1571 	    (p[j] == '/' || p[j] == '\0')) {
1572 	    *hm = &p[j];
1573 	    return tcache[i].user;
1574 	}
1575     return NULL;
1576 }
1577 
1578 
1579 /*
1580  * set the shell-level var to 1 or apply change to it.
1581  */
1582 void
1583 shlvl(int val)
1584 {
1585     char *cp;
1586 
1587     if ((cp = getenv("SHLVL")) != NULL) {
1588 
1589 	if (loginsh)
1590 	    val = 1;
1591 	else
1592 	    val += atoi(cp);
1593 
1594 	if (val <= 0) {
1595 	    if (adrof(STRshlvl) != NULL)
1596 		unsetv(STRshlvl);
1597 	    Unsetenv(STRKSHLVL);
1598 	}
1599 	else {
1600 	    Char *p;
1601 
1602 	    p = Itoa(val, 0, 0);
1603 	    cleanup_push(p, xfree);
1604 	    setv(STRshlvl, p, VAR_READWRITE);
1605 	    cleanup_ignore(p);
1606 	    cleanup_until(p);
1607 	    tsetenv(STRKSHLVL, p);
1608 	}
1609     }
1610     else {
1611 	setcopy(STRshlvl, STR1, VAR_READWRITE);
1612 	tsetenv(STRKSHLVL, STR1);
1613     }
1614 }
1615 
1616 
1617 /* fixio():
1618  *	Try to recover from a read error
1619  */
1620 int
1621 fixio(int fd, int e)
1622 {
1623     switch (e) {
1624     case -1:	/* Make sure that the code is reachable */
1625 
1626 #ifdef EWOULDBLOCK
1627     case EWOULDBLOCK:
1628 # define FDRETRY
1629 #endif /* EWOULDBLOCK */
1630 
1631 #if defined(POSIX) && defined(EAGAIN)
1632 # if !defined(EWOULDBLOCK) || EWOULDBLOCK != EAGAIN
1633     case EAGAIN:
1634 #  define FDRETRY
1635 # endif /* !EWOULDBLOCK || EWOULDBLOCK != EAGAIN */
1636 #endif /* POSIX && EAGAIN */
1637 
1638 	e = 0;
1639 #ifdef FDRETRY
1640 # ifdef F_SETFL
1641 /*
1642  * Great! we have on suns 3 flavors and 5 names...
1643  * I hope that will cover everything.
1644  * I added some more defines... many systems have different defines.
1645  * Rather than dealing with getting the right includes, we'll just
1646  * cover all the known possibilities here.  -- sterling@netcom.com
1647  */
1648 #  ifndef O_NONBLOCK
1649 #   define O_NONBLOCK 0
1650 #  endif /* O_NONBLOCK */
1651 #  ifndef O_NDELAY
1652 #   define O_NDELAY 0
1653 #  endif /* O_NDELAY */
1654 #  ifndef FNBIO
1655 #   define FNBIO 0
1656 #  endif /* FNBIO */
1657 #  ifndef _FNBIO
1658 #   define _FNBIO 0
1659 #  endif /* _FNBIO */
1660 #  ifndef FNONBIO
1661 #   define FNONBIO 0
1662 #  endif /* FNONBIO */
1663 #  ifndef FNONBLOCK
1664 #   define FNONBLOCK 0
1665 #  endif /* FNONBLOCK */
1666 #  ifndef _FNONBLOCK
1667 #   define _FNONBLOCK 0
1668 #  endif /* _FNONBLOCK */
1669 #  ifndef FNDELAY
1670 #   define FNDELAY 0
1671 #  endif /* FNDELAY */
1672 #  ifndef _FNDELAY
1673 #   define _FNDELAY 0
1674 #  endif /* _FNDELAY */
1675 #  ifndef FNDLEAY	/* Some linux versions have this typo */
1676 #   define FNDLEAY 0
1677 #  endif /* FNDLEAY */
1678 	if ((e = fcntl(fd, F_GETFL, 0)) == -1)
1679 	    return -1;
1680 
1681 	e &= ~(O_NDELAY|O_NONBLOCK|FNBIO|_FNBIO|FNONBIO|FNONBLOCK|_FNONBLOCK|
1682 	       FNDELAY|_FNDELAY|FNDLEAY);	/* whew! */
1683 	if (fcntl(fd, F_SETFL, e) == -1)
1684 	    return -1;
1685 	else
1686 	    e = 1;
1687 # endif /* F_SETFL */
1688 
1689 # ifdef FIONBIO
1690 	e = 0;
1691 	if (ioctl(fd, FIONBIO, (ioctl_t) &e) == -1)
1692 	    return -1;
1693 	else
1694 	    e = 1;
1695 # endif	/* FIONBIO */
1696 
1697 #endif /* FDRETRY */
1698 	return e ? 0 : -1;
1699 
1700     case EINTR:
1701 	return 0;
1702 
1703     default:
1704 	return -1;
1705     }
1706 }
1707 
1708 /* collate():
1709  *	String collation
1710  */
1711 int
1712 collate(const Char *a, const Char *b)
1713 {
1714     int rv;
1715 #ifdef SHORT_STRINGS
1716     /* This strips the quote bit as a side effect */
1717     char *sa = strsave(short2str(a));
1718     char *sb = strsave(short2str(b));
1719 #else
1720     char *sa = strip(strsave(a));
1721     char *sb = strip(strsave(b));
1722 #endif /* SHORT_STRINGS */
1723 
1724 #if defined(NLS) && defined(HAVE_STRCOLL)
1725     errno = 0;	/* strcoll sets errno, another brain-damage */
1726 
1727     rv = strcoll(sa, sb);
1728 
1729     /*
1730      * We should be checking for errno != 0, but some systems
1731      * forget to reset errno to 0. So we only check for the
1732      * only documented valid errno value for strcoll [EINVAL]
1733      */
1734     if (errno == EINVAL) {
1735 	xfree(sa);
1736 	xfree(sb);
1737 	stderror(ERR_SYSTEM, "strcoll", strerror(errno));
1738     }
1739 #else
1740     rv = strcmp(sa, sb);
1741 #endif /* NLS && HAVE_STRCOLL */
1742 
1743     xfree(sa);
1744     xfree(sb);
1745 
1746     return rv;
1747 }
1748 
1749 #ifdef HASHBANG
1750 /*
1751  * From: peter@zeus.dialix.oz.au (Peter Wemm)
1752  * If exec() fails look first for a #! [word] [word] ....
1753  * If it is, splice the header into the argument list and retry.
1754  */
1755 #define HACKBUFSZ 1024		/* Max chars in #! vector */
1756 int
1757 hashbang(int fd, Char ***vp)
1758 {
1759     struct blk_buf sarg = BLK_BUF_INIT;
1760     char lbuf[HACKBUFSZ], *p, *ws;
1761 #ifdef WINNT_NATIVE
1762     int fw = 0; 	/* found at least one word */
1763     int first_word = 1;
1764     char *real;
1765 #endif /* WINNT_NATIVE */
1766 
1767     if (xread(fd, lbuf, HACKBUFSZ) <= 0)
1768 	return -1;
1769 
1770     ws = 0;	/* word started = 0 */
1771 
1772     for (p = lbuf; p < &lbuf[HACKBUFSZ]; ) {
1773 	switch (*p) {
1774 	case ' ':
1775 	case '\t':
1776 #ifdef WINNT_NATIVE
1777 	case '\r':
1778 #endif /* WINNT_NATIVE */
1779 	    if (ws) {	/* a blank after a word.. save it */
1780 		*p = '\0';
1781 #ifdef WINNT_NATIVE
1782 		if (first_word) {
1783 		    real = hb_subst(ws);
1784 		    if (real != NULL)
1785 			ws = real;
1786 		}
1787 	    	fw = 1;
1788 		first_word = 0;
1789 #endif /* WINNT_NATIVE */
1790 		bb_append(&sarg, SAVE(ws));
1791 		ws = NULL;
1792 	    }
1793 	    p++;
1794 	    continue;
1795 
1796 	case '\0':	/* Whoa!! what the hell happened */
1797 	    goto err;
1798 
1799 	case '\n':	/* The end of the line. */
1800 	    if (
1801 #ifdef WINNT_NATIVE
1802 		fw ||
1803 #endif /* WINNT_NATIVE */
1804 		ws) {	/* terminate the last word */
1805 		*p = '\0';
1806 #ifdef WINNT_NATIVE
1807 		/* deal with the 1-word case */
1808 		if (first_word) {
1809 		    real = hb_subst(ws);
1810 		    if (real != NULL)
1811 			ws = real;
1812 		}
1813 #endif /* !WINNT_NATIVE */
1814 		if (ws)
1815 		    bb_append(&sarg, SAVE(ws));
1816 	    }
1817 	    if (sarg.len > 0) {
1818 		*vp = bb_finish(&sarg);
1819 		return 0;
1820 	    }
1821 	    else
1822 		goto err;
1823 
1824 	default:
1825 	    if (!ws)	/* Start a new word? */
1826 		ws = p;
1827 	    p++;
1828 	    break;
1829 	}
1830     }
1831  err:
1832     bb_cleanup(&sarg);
1833     return -1;
1834 }
1835 #endif /* HASHBANG */
1836 
1837 #ifdef REMOTEHOST
1838 
1839 static void
1840 palarm(int snum)
1841 {
1842     USE(snum);
1843     _exit(1);
1844 }
1845 
1846 static void
1847 getremotehost(int dest_fd)
1848 {
1849     const char *host = NULL;
1850 #ifdef INET6
1851     struct sockaddr_storage saddr;
1852     static char hbuf[NI_MAXHOST];
1853 #else
1854     struct hostent* hp;
1855     struct sockaddr_in saddr;
1856 #endif
1857     socklen_t len = sizeof(saddr);
1858 
1859 #ifdef INET6
1860     if (getpeername(SHIN, (struct sockaddr *) &saddr, &len) != -1 &&
1861 	(saddr.ss_family == AF_INET6 || saddr.ss_family == AF_INET)) {
1862 	int flag = NI_NUMERICHOST;
1863 
1864 #ifdef NI_WITHSCOPEID
1865 	flag |= NI_WITHSCOPEID;
1866 #endif
1867 	getnameinfo((struct sockaddr *)&saddr, len, hbuf, sizeof(hbuf),
1868 		    NULL, 0, flag);
1869 	host = hbuf;
1870 #else
1871     if (getpeername(SHIN, (struct sockaddr *) &saddr, &len) != -1 &&
1872 	saddr.sin_family == AF_INET) {
1873 #if 0
1874 	if ((hp = gethostbyaddr((char *)&saddr.sin_addr, sizeof(struct in_addr),
1875 				AF_INET)) != NULL)
1876 	    host = hp->h_name;
1877 	else
1878 #endif
1879 	    host = inet_ntoa(saddr.sin_addr);
1880 #endif
1881     }
1882 #ifdef HAVE_STRUCT_UTMP_UT_HOST
1883     else {
1884 	char *ptr;
1885 	char *name = utmphost();
1886 	/* Avoid empty names and local X displays */
1887 	if (name != NULL && *name != '\0' && *name != ':') {
1888 	    struct in_addr addr;
1889 	    char *sptr;
1890 
1891 	    /* Look for host:display.screen */
1892 	    /*
1893 	     * There is conflict with IPv6 address and X DISPLAY.  So,
1894 	     * we assume there is no IPv6 address in utmp and don't
1895 	     * touch here.
1896 	     */
1897 	    if ((sptr = strchr(name, ':')) != NULL)
1898 		*sptr = '\0';
1899 	    /* Leave IPv4 address as is */
1900 	    /*
1901 	     * we use inet_addr here, not inet_aton because many systems
1902 	     * have not caught up yet.
1903 	     */
1904 	    addr.s_addr = inet_addr(name);
1905 	    if (addr.s_addr != (unsigned int)~0)
1906 		host = name;
1907 	    else {
1908 		if (sptr != name) {
1909 #ifdef INET6
1910 		    char *s, *domain;
1911 		    char dbuf[MAXHOSTNAMELEN];
1912 		    struct addrinfo hints, *res = NULL;
1913 
1914 		    memset(&hints, 0, sizeof(hints));
1915 		    hints.ai_family = PF_UNSPEC;
1916 		    hints.ai_socktype = SOCK_STREAM;
1917 		    hints.ai_flags = AI_PASSIVE | AI_CANONNAME;
1918 		    if (strlen(name) < utmphostsize())
1919 		    {
1920 			if (getaddrinfo(name, NULL, &hints, &res) != 0)
1921 			    res = NULL;
1922 		    } else if (gethostname(dbuf, sizeof(dbuf)) == 0 &&
1923 			       (dbuf[sizeof(dbuf)-1] = '\0', /*FIXME: ugly*/
1924 				(domain = strchr(dbuf, '.')) != NULL)) {
1925 			for (s = strchr(name, '.');
1926 			     s != NULL; s = strchr(s + 1, '.')) {
1927 			    if (*(s + 1) != '\0' &&
1928 				(ptr = strstr(domain, s)) != NULL) {
1929 			        char *cbuf;
1930 
1931 				cbuf = strspl(name, ptr);
1932 				if (getaddrinfo(cbuf, NULL, &hints, &res) != 0)
1933 				    res = NULL;
1934 				xfree(cbuf);
1935 				break;
1936 			    }
1937 			}
1938 		    }
1939 		    if (res != NULL) {
1940 			if (res->ai_canonname != NULL) {
1941 			    strncpy(hbuf, res->ai_canonname, sizeof(hbuf));
1942 			    host = hbuf;
1943 			}
1944 			freeaddrinfo(res);
1945 		    }
1946 #else
1947 		    if ((hp = gethostbyname(name)) == NULL) {
1948 			/* Try again eliminating the trailing domain */
1949 			if ((ptr = strchr(name, '.')) != NULL) {
1950 			    *ptr = '\0';
1951 			    if ((hp = gethostbyname(name)) != NULL)
1952 				host = hp->h_name;
1953 			    *ptr = '.';
1954 			}
1955 		    }
1956 		    else
1957 			host = hp->h_name;
1958 #endif
1959 		}
1960 	    }
1961 	}
1962     }
1963 #endif
1964 
1965     if (host) {
1966 	size_t left;
1967 
1968 	left = strlen(host);
1969 	while (left != 0) {
1970 	    ssize_t res;
1971 
1972 	    res = xwrite(dest_fd, host, left);
1973 	    if (res < 0)
1974 		_exit(1);
1975 	    host += res;
1976 	    left -= res;
1977 	}
1978     }
1979     _exit(0);
1980 }
1981 
1982 /*
1983  * From: <lesv@ppvku.ericsson.se> (Lennart Svensson)
1984  */
1985 void
1986 remotehost(void)
1987 {
1988     struct sigaction sa;
1989     struct strbuf hostname = strbuf_INIT;
1990     int fds[2], wait_options, status;
1991     pid_t pid, wait_res;
1992 
1993     sa.sa_handler = SIG_DFL; /* Make sure a zombie is created */
1994     sigemptyset(&sa.sa_mask);
1995     sa.sa_flags = 0;
1996     sigaction(SIGCHLD, &sa, NULL);
1997     mypipe(fds);
1998     pid = fork();
1999     if (pid == 0) {
2000 	sigset_t set;
2001 	xclose(fds[0]);
2002 	/* Don't get stuck if the resolver does not work! */
2003 	signal(SIGALRM, palarm);
2004 	sigemptyset(&set);
2005 	sigaddset(&set, SIGALRM);
2006 	(void)sigprocmask(SIG_UNBLOCK, &set, NULL);
2007 	(void)alarm(2);
2008 	getremotehost(fds[1]);
2009 	/*NOTREACHED*/
2010     }
2011     xclose(fds[1]);
2012     for (;;) {
2013 	char buf[BUFSIZE];
2014 	ssize_t res;
2015 
2016 	res = xread(fds[0], buf, sizeof(buf));
2017 	if (res == -1) {
2018 	    hostname.len = 0;
2019 	    wait_options = WNOHANG;
2020 	    goto done;
2021 	}
2022 	if (res == 0)
2023 	    break;
2024 	strbuf_appendn(&hostname, buf, res);
2025     }
2026     wait_options = 0;
2027  done:
2028     xclose(fds[0]);
2029     while ((wait_res = waitpid(pid, &status, wait_options)) == -1
2030 	   && errno == EINTR)
2031 	handle_pending_signals();
2032     cleanup_push(&hostname, strbuf_cleanup);
2033     if (wait_res == pid && WIFEXITED(status) && WEXITSTATUS(status) == 0) {
2034 	strbuf_terminate(&hostname);
2035 	tsetenv(STRREMOTEHOST, str2short(hostname.s));
2036     }
2037     cleanup_until(&hostname);
2038 
2039 #ifdef YPBUGS
2040     /* From: casper@fwi.uva.nl (Casper H.S. Dik), for Solaris 2.3 */
2041     fix_yp_bugs();
2042 #endif /* YPBUGS */
2043 
2044 }
2045 #endif /* REMOTEHOST */
2046 
2047 #ifndef WINNT_NATIVE
2048 /*
2049  * indicate if a terminal type is defined in terminfo/termcap
2050  * (by default the current term type). This allows ppl to look
2051  * for a working term type automatically in their login scripts
2052  * when using a terminal known as different things on different
2053  * platforms
2054  */
2055 void
2056 dotermname(Char **v, struct command *c)
2057 {
2058     char *termtype;
2059     /*
2060      * Maximum size of a termcap record. We make it twice as large.
2061      */
2062     char termcap_buffer[2048];
2063 
2064     USE(c);
2065     /* try to find which entry we should be looking for */
2066     termtype = (v[1] == NULL ? getenv("TERM") : short2str(v[1]));
2067     if (termtype == NULL) {
2068 	/* no luck - the user didn't provide one and none is
2069 	 * specified in the environment
2070 	 */
2071 	setcopy(STRstatus, STR1, VAR_READWRITE);
2072 	return;
2073     }
2074 
2075     /*
2076      * we use the termcap function - if we are using terminfo we
2077      * will end up with it's compatibility function
2078      * terminfo/termcap will be initialized with the new
2079      * type but we don't care because tcsh has cached all the things
2080      * it needs.
2081      */
2082     if (tgetent(termcap_buffer, termtype) == 1) {
2083 	xprintf("%s\n", termtype);
2084 	setcopy(STRstatus, STR0, VAR_READWRITE);
2085     } else
2086 	setcopy(STRstatus, STR1, VAR_READWRITE);
2087 }
2088 #endif /* WINNT_NATIVE */
2089