contrib/tcsh-6/tc.func.c

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