contrib/tcsh/tc.func.c

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