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