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