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