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