?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update files for OpenSSH-6.7p1 import.
[dragonfly.git] / contrib / tcsh-6 / tc.func.c
blobb13fe04dd2d895ad5c6c89d5153e9a4c3fa5182b
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
35 RCSID("$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>
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 && 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
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 && (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*/
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(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
766 static void
767 auto_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
783 void
784 alrmcatch(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 */
799 void
800 precmd(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);
812 leave:
813 precmd_active = 0;
814 cleanup_until(&pintr_disabled);
815 }
816
817 void
818 postcmd(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);
830 leave:
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 */
841 void
842 cwd_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);
854 leave:
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 */
863 void
864 beep_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 */
887 void
888 period_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 }
914 leave:
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 */
928 void
929 job_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 }
944 leave:
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 */
955 void
956 aliasrun(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
1046 void
1047 setalarm(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
1100 void
1101 rmstar(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 */
1206 void
1207 continue_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(). */
1277 static void
1278 insert(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
1362 static void
1363 insert_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
1372 static int
1373 inlist(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 */
1410 static struct tildecache {
1411 Char *user;
1412 Char *home;
1413 size_t hlen;
1414 } *tcache = NULL;
1415
1416 #define TILINCR 10
1417 size_t tlength = 0;
1418 static size_t tsize = TILINCR;
1419
1420 static int
1421 tildecompare(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
1430 static Char *
1431 gethomedir(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
1494 Char *
1495 gettilde(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 */
1550 Char *
1551 getusername(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 */
1587 void
1588 shlvl(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 */
1625 int
1626 fixio(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 */
1714 int
1715 collate(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 */
1759 int
1760 hashbang(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
1842 static void
1843 palarm(int snum)
1844 {
1845 USE(snum);
1846 _exit(1);
1847 }
1848
1849 static void
1850 getremotehost(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 */
1989 void
1990 remotehost(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 */
2060 void
2061 dotermname(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 */
DragonFly BSD