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