contrib/tcsh-6/sh.c

   1 /* $Header: /p/tcsh/cvsroot/tcsh/sh.c,v 3.185 2015/05/10 13:28:54 christos Exp $ */
   2 /*
   3  * sh.c: Main shell routines
   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 #define EXTERN  /* Intern */
  34 #include "sh.h"
  35
  36 #ifndef lint
  37 char    copyright[] =
  38 "@(#) Copyright (c) 1991 The Regents of the University of California.\n\
  39  All rights reserved.\n";
  40 #endif /* not lint */
  41
  42 RCSID("$tcsh: sh.c,v 3.185 2015/05/10 13:28:54 christos Exp $")
  43
  44 #include "tc.h"
  45 #include "ed.h"
  46 #include "tw.h"
  47
  48 extern int MapsAreInited;
  49 extern int NLSMapsAreInited;
  50
  51 /*
  52  * C Shell
  53  *
  54  * Bill Joy, UC Berkeley, California, USA
  55  * October 1978, May 1980
  56  *
  57  * Jim Kulp, IIASA, Laxenburg, Austria
  58  * April 1980
  59  *
  60  * Filename recognition added:
  61  * Ken Greer, Ind. Consultant, Palo Alto CA
  62  * October 1983.
  63  *
  64  * Karl Kleinpaste, Computer Consoles, Inc.
  65  * Added precmd, periodic/tperiod, prompt changes,
  66  * directory stack hack, and login watch.
  67  * Sometime March 1983 - Feb 1984.
  68  *
  69  * Added scheduled commands, including the "sched" command,
  70  * plus the call to sched_run near the precmd et al
  71  * routines.
  72  * Upgraded scheduled events for running events while
  73  * sitting idle at command input.
  74  *
  75  * Paul Placeway, Ohio State
  76  * added stuff for running with twenex/inputl  9 Oct 1984.
  77  *
  78  * ported to Apple Unix (TM) (OREO)  26 -- 29 Jun 1987
  79  */
  80
  81 jmp_buf_t reslab IZERO_STRUCT;
  82 struct wordent paraml IZERO_STRUCT;
  83
  84 static const char tcshstr[] = "tcsh";
  85
  86 struct sigaction parintr;       /* Parents interrupt catch */
  87 struct sigaction parterm;       /* Parents terminate catch */
  88
  89 #ifdef TESLA
  90 int do_logout = 0;
  91 #endif /* TESLA */
  92
  93
  94 int    use_fork = 0;            /* use fork() instead of vfork()? */
  95
  96 /*
  97  * Magic pointer values. Used to specify other invalid conditions aside
  98  * from null.
  99  */
 100 static Char     INVCHAR;
 101 Char    *INVPTR = &INVCHAR;
 102 Char    **INVPPTR = &INVPTR;
 103
 104 static int    fast = 0;
 105 static int    mflag = 0;
 106 static int    prompt = 1;
 107 int     enterhist = 0;
 108 int    tellwhat = 0;
 109 time_t  t_period;
 110 Char  *ffile = NULL;
 111 int     dolzero = 0;
 112 int     insource = 0;
 113 int     exitset = 0;
 114 static time_t  chktim;          /* Time mail last checked */
 115 char *progname;
 116 int tcsh;
 117
 118 /*
 119  * This preserves the input state of the shell. It is used by
 120  * st_save and st_restore to manupulate shell state.
 121  */
 122 struct saved_state {
 123     int           insource;
 124     int           OLDSTD;
 125     int           SHIN;
 126     int           SHOUT;
 127     int           SHDIAG;
 128     int           intty;
 129     struct whyle *whyles;
 130     Char         *gointr;
 131     Char         *arginp;
 132     Char         *evalp;
 133     Char        **evalvec;
 134     Char         *alvecp;
 135     Char        **alvec;
 136     int           onelflg;
 137     int   enterhist;
 138     Char        **argv;
 139     Char        **av;
 140     Char          HIST;
 141     int   cantell;
 142     struct Bin    B;
 143     int           justpr;
 144 };
 145
 146 static  int               srccat        (Char *, Char *);
 147 #ifndef WINNT_NATIVE
 148 static  int               srcfile       (const char *, int, int, Char **);
 149 #else
 150 int               srcfile       (const char *, int, int, Char **);
 151 #endif /*WINNT_NATIVE*/
 152 static  void              srcunit       (int, int, int, Char **);
 153 static  void              mailchk       (void);
 154 #ifndef _PATH_DEFPATH
 155 static  Char            **defaultpath   (void);
 156 #endif
 157 static  void              record        (void);
 158 static  void              st_save       (struct saved_state *, int, int,
 159                                          Char **, Char **);
 160 static  void              st_restore    (void *);
 161
 162         int               main          (int, char **);
 163
 164 #ifndef LOCALEDIR
 165 #define LOCALEDIR "/usr/share/locale"
 166 #endif
 167
 168 #ifdef NLS_CATALOGS
 169 static void
 170 add_localedir_to_nlspath(const char *path)
 171 {
 172     static const char msgs_LOC[] = "/%L/LC_MESSAGES/%N.cat";
 173     static const char msgs_lang[] = "/%l/LC_MESSAGES/%N.cat";
 174     char *old;
 175     char *new, *new_p;
 176     size_t len;
 177     int add_LOC = 1;
 178     int add_lang = 1;
 179     char trypath[MAXPATHLEN];
 180     struct stat st;
 181
 182     if (path == NULL)
 183         return;
 184
 185     (void) xsnprintf(trypath, sizeof(trypath), "%s/en/LC_MESSAGES/tcsh.cat",
 186         path);
 187     if (stat(trypath, &st) == -1)
 188         return;
 189
 190     if ((old = getenv("NLSPATH")) != NULL)
 191         len = strlen(old) + 1;  /* don't forget the colon. */
 192     else
 193         len = 0;
 194
 195     len += 2 * strlen(path) +
 196            sizeof(msgs_LOC) + sizeof(msgs_lang); /* includes the extra colon */
 197
 198     new = new_p = xcalloc(len, 1);
 199
 200     if (old != NULL) {
 201         size_t pathlen = strlen(path);
 202         char *old_p;
 203
 204         (void) xsnprintf(new_p, len, "%s", old);
 205         new_p += strlen(new_p);
 206         len -= new_p - new;
 207
 208         /* Check if the paths we try to add are already present in NLSPATH.
 209            If so, note it by setting the appropriate flag to 0. */
 210         for (old_p = old; old_p; old_p = strchr(old_p, ':'),
 211                                  old_p = old_p ? old_p + 1 : NULL) {
 212             if (strncmp(old_p, path, pathlen) != 0)
 213                 continue;
 214             if (strncmp(old_p + pathlen, msgs_LOC, sizeof(msgs_LOC) - 1) == 0)
 215                 add_LOC = 0;
 216             else if (strncmp(old_p + pathlen, msgs_lang,
 217                               sizeof(msgs_lang) - 1) == 0)
 218                 add_lang = 0;
 219         }
 220     }
 221
 222     /* Add the message catalog paths not already present to NLSPATH. */
 223     if (add_LOC || add_lang)
 224         (void) xsnprintf(new_p, len, "%s%s%s%s%s%s",
 225                          old ? ":" : "",
 226                          add_LOC ? path : "", add_LOC ? msgs_LOC : "",
 227                          add_LOC && add_lang ? ":" : "",
 228                          add_lang ? path : "", add_lang ? msgs_lang : "");
 229
 230     tsetenv(STRNLSPATH, str2short(new));
 231     free(new);
 232 }
 233 #endif
 234
 235 int
 236 main(int argc, char **argv)
 237 {
 238     int batch = 0;
 239     volatile int nexececho = 0;
 240     int nofile = 0;
 241     volatile int nverbose = 0;
 242     volatile int rdirs = 0;
 243     int quitit = 0;
 244     Char *cp;
 245 #ifdef AUTOLOGOUT
 246     Char *cp2;
 247 #endif
 248     char *tcp, *ttyn;
 249     int f, reenter;
 250     char **tempv;
 251     int osetintr;
 252     struct sigaction oparintr;
 253
 254 #ifdef WINNT_NATIVE
 255     nt_init();
 256 #endif /* WINNT_NATIVE */
 257
 258     (void)memset(&reslab, 0, sizeof(reslab));
 259 #if defined(NLS_CATALOGS) && defined(LC_MESSAGES)
 260     (void) setlocale(LC_MESSAGES, "");
 261 #endif /* NLS_CATALOGS && LC_MESSAGES */
 262
 263 #ifdef NLS
 264 # ifdef LC_CTYPE
 265     (void) setlocale(LC_CTYPE, ""); /* for iscntrl */
 266 # endif /* LC_CTYPE */
 267 #endif /* NLS */
 268
 269     STR_environ = blk2short(environ);
 270     environ = short2blk(STR_environ);   /* So that we can free it */
 271
 272 #ifdef NLS_CATALOGS
 273     add_localedir_to_nlspath(LOCALEDIR);
 274 #endif
 275
 276     nlsinit();
 277
 278 #ifdef MALLOC_TRACE
 279     mal_setstatsfile(fdopen(dmove(xopen("/tmp/tcsh.trace",
 280         O_WRONLY|O_CREAT|O_LARGEFILE, 0666), 25), "w"));
 281     mal_trace(1);
 282 #endif /* MALLOC_TRACE */
 283
 284 #if !(defined(BSDTIMES) || defined(_SEQUENT_)) && defined(POSIX)
 285 # ifdef _SC_CLK_TCK
 286     clk_tck = (clock_t) sysconf(_SC_CLK_TCK);
 287 # else /* ! _SC_CLK_TCK */
 288 #  ifdef CLK_TCK
 289     clk_tck = CLK_TCK;
 290 #  else /* !CLK_TCK */
 291     clk_tck = HZ;
 292 #  endif /* CLK_TCK */
 293 # endif /* _SC_CLK_TCK */
 294 #endif /* !BSDTIMES && POSIX */
 295
 296     settimes();                 /* Immed. estab. timing base */
 297 #ifdef TESLA
 298     do_logout = 0;
 299 #endif /* TESLA */
 300
 301     /*
 302      * Make sure we have 0, 1, 2 open
 303      * Otherwise `` jobs will not work... (From knaff@poly.polytechnique.fr)
 304      */
 305     {
 306         do
 307             if ((f = xopen(_PATH_DEVNULL, O_RDONLY|O_LARGEFILE)) == -1 &&
 308                 (f = xopen("/", O_RDONLY|O_LARGEFILE)) == -1)
 309                 exit(1);
 310         while (f < 3);
 311         xclose(f);
 312     }
 313
 314     osinit();                   /* Os dependent initialization */
 315
 316
 317     {
 318         char *t;
 319
 320         t = strrchr(argv[0], '/');
 321 #ifdef WINNT_NATIVE
 322         {
 323             char *s = strrchr(argv[0], '\\');
 324             if (s)
 325                 t = s;
 326         }
 327 #endif /* WINNT_NATIVE */
 328         t = t ? t + 1 : argv[0];
 329         if (*t == '-') t++;
 330         progname = strsave((t && *t) ? t : tcshstr);    /* never want a null */
 331         tcsh = strncmp(progname, tcshstr, sizeof(tcshstr) - 1) == 0;
 332     }
 333
 334     /*
 335      * Initialize non constant strings
 336      */
 337 #ifdef _PATH_BSHELL
 338     STR_BSHELL = SAVE(_PATH_BSHELL);
 339 #endif
 340 #ifdef _PATH_TCSHELL
 341     STR_SHELLPATH = SAVE(_PATH_TCSHELL);
 342 #else
 343 # ifdef _PATH_CSHELL
 344     STR_SHELLPATH = SAVE(_PATH_CSHELL);
 345 # endif
 346 #endif
 347     STR_WORD_CHARS = SAVE(WORD_CHARS);
 348
 349     HIST = '!';
 350     HISTSUB = '^';
 351     PRCH = tcsh ? '>' : '%';    /* to replace %# in $prompt for normal users */
 352     PRCHROOT = '#';             /* likewise for root */
 353     word_chars = STR_WORD_CHARS;
 354     bslash_quote = 0;           /* PWP: do tcsh-style backslash quoting? */
 355     anyerror = 1;               /* for compatibility */
 356     setcopy(STRanyerror, STRNULL, VAR_READWRITE);
 357
 358     /* Default history size to 100 */
 359     setcopy(STRhistory, str2short("100"), VAR_READWRITE);
 360     sethistory(100);
 361
 362     tempv = argv;
 363     ffile = SAVE(tempv[0]);
 364     dolzero = 0;
 365     if (eq(ffile, STRaout))     /* A.out's are quittable */
 366         quitit = 1;
 367     uid = getuid();
 368     gid = getgid();
 369     euid = geteuid();
 370     egid = getegid();
 371     /*
 372      * We are a login shell if: 1. we were invoked as -<something> with
 373      * optional arguments 2. or we were invoked only with the -l flag
 374      */
 375     loginsh = (**tempv == '-') || (argc == 2 &&
 376                                    tempv[1][0] == '-' && tempv[1][1] == 'l' &&
 377                                                 tempv[1][2] == '\0');
 378 #ifdef _VMS_POSIX
 379     /* No better way to find if we are a login shell */
 380     if (!loginsh) {
 381         loginsh = (argc == 1 && getppid() == 1);
 382         **tempv = '-';  /* Avoid giving VMS an acidic stomach */
 383     }
 384 #endif /* _VMS_POSIX */
 385
 386     if (loginsh && **tempv != '-') {
 387         char *argv0;
 388
 389         /*
 390          * Mangle the argv space
 391          */
 392         tempv[1][0] = '\0';
 393         tempv[1][1] = '\0';
 394         tempv[1] = NULL;
 395         argv0 = strspl("-", *tempv);
 396         *tempv = argv0;
 397         argc--;
 398     }
 399     if (loginsh) {
 400         (void) time(&chktim);
 401         setNS(STRloginsh);
 402     }
 403
 404     NoNLSRebind = getenv("NOREBIND") != NULL;
 405 #ifdef NLS
 406 # ifdef SETLOCALEBUG
 407     dont_free = 1;
 408 # endif /* SETLOCALEBUG */
 409     (void) setlocale(LC_ALL, "");
 410 # ifdef LC_COLLATE
 411     (void) setlocale(LC_COLLATE, "");
 412 # endif
 413 # ifdef SETLOCALEBUG
 414     dont_free = 0;
 415 # endif /* SETLOCALEBUG */
 416 # ifdef STRCOLLBUG
 417     fix_strcoll_bug();
 418 # endif /* STRCOLLBUG */
 419
 420     /*
 421      * On solaris ISO8859-1 contains no printable characters in the upper half
 422      * so we need to test only for MB_CUR_MAX == 1, otherwise for multi-byte
 423      * locales we are always AsciiOnly == 0.
 424      */
 425     if (MB_CUR_MAX == 1) {
 426         int     k;
 427
 428         for (k = 0200; k <= 0377 && !isprint(CTL_ESC(k)); k++)
 429             continue;
 430         AsciiOnly = k > 0377;
 431     } else
 432         AsciiOnly = 0;
 433 #else
 434     AsciiOnly = getenv("LANG") == NULL && getenv("LC_CTYPE") == NULL;
 435 #endif                          /* NLS */
 436     if (MapsAreInited && !NLSMapsAreInited)
 437         ed_InitNLSMaps();
 438     ResetArrowKeys();
 439
 440     /*
 441      * Initialize for periodic command intervals. Also, initialize the dummy
 442      * tty list for login-watch.
 443      */
 444     (void) time(&t_period);
 445 #ifndef HAVENOUTMP
 446     initwatch();
 447 #endif /* !HAVENOUTMP */
 448
 449 #if defined(alliant)
 450     /*
 451      * From:  Jim Pace <jdp@research.att.com>
 452      * tcsh does not work properly on the alliants through an rlogin session.
 453      * The shell generally hangs.  Also, reference to the controlling terminal
 454      * does not work ( ie: echo foo > /dev/tty ).
 455      *
 456      * A security feature was added to rlogind affecting FX/80's Concentrix
 457      * from revision 5.5.xx upwards (through 5.7 where this fix was implemented)
 458      * This security change also affects the FX/2800 series.
 459      * The security change to rlogind requires the process group of an rlogin
 460      * session become disassociated with the tty in rlogind.
 461      *
 462      * The changes needed are:
 463      * 1. set the process group
 464      * 2. reenable the control terminal
 465      */
 466      if (loginsh && isatty(SHIN)) {
 467          ttyn = ttyname(SHIN);
 468          xclose(SHIN);
 469          SHIN = xopen(ttyn, O_RDWR|O_LARGEFILE);
 470          shpgrp = getpid();
 471          (void) ioctl (SHIN, TIOCSPGRP, (ioctl_t) &shpgrp);
 472          (void) setpgid(0, shpgrp);
 473      }
 474 #endif /* alliant */
 475
 476     /*
 477      * Move the descriptors to safe places. The variable didfds is 0 while we
 478      * have only FSH* to work with. When didfds is true, we have 0,1,2 and
 479      * prefer to use these.
 480      */
 481     initdesc();
 482
 483     cdtohome = 1;
 484     setv(STRcdtohome, SAVE(""), VAR_READWRITE);
 485
 486     /*
 487      * Get and set the tty now
 488      */
 489     if ((ttyn = ttyname(SHIN)) != NULL) {
 490         /*
 491          * Could use rindex to get rid of other possible path components, but
 492          * hpux preserves the subdirectory /pty/ when storing the tty name in
 493          * utmp, so we keep it too.
 494          */
 495         if (strncmp(ttyn, "/dev/", 5) == 0)
 496             setv(STRtty, cp = SAVE(ttyn + 5), VAR_READWRITE);
 497         else
 498             setv(STRtty, cp = SAVE(ttyn), VAR_READWRITE);
 499     }
 500     else
 501         setv(STRtty, cp = SAVE(""), VAR_READWRITE);
 502
 503     /*
 504      * Initialize the shell variables. ARGV and PROMPT are initialized later.
 505      * STATUS is also munged in several places. CHILD is munged when
 506      * forking/waiting
 507      */
 508
 509     /*
 510      * 7-10-87 Paul Placeway autologout should be set ONLY on login shells and
 511      * on shells running as root.  Out of these, autologout should NOT be set
 512      * for any psudo-terminals (this catches most window systems) and not for
 513      * any terminal running X windows.
 514      *
 515      * At Ohio State, we have had problems with a user having his X session
 516      * drop out from under him (on a Sun) because the shell in his master
 517      * xterm timed out and exited.
 518      *
 519      * Really, this should be done with a program external to the shell, that
 520      * watches for no activity (and NO running programs, such as dump) on a
 521      * terminal for a long peroid of time, and then SIGHUPS the shell on that
 522      * terminal.
 523      *
 524      * bugfix by Rich Salz <rsalz@PINEAPPLE.BBN.COM>: For root rsh things
 525      * allways first check to see if loginsh or really root, then do things
 526      * with ttyname()
 527      *
 528      * Also by Jean-Francois Lamy <lamy%ai.toronto.edu@RELAY.CS.NET>: check the
 529      * value of cp before using it! ("root can rsh too")
 530      *
 531      * PWP: keep the nested ifs; the order of the tests matters and a good
 532      * (smart) C compiler might re-arange things wrong.
 533      */
 534 #ifdef AUTOLOGOUT
 535 # ifdef convex
 536     if (uid == 0)
 537         /*  root always has a 15 minute autologout  */
 538         setcopy(STRautologout, STRrootdefautologout, VAR_READWRITE);
 539     else
 540         if (loginsh)
 541             /*  users get autologout set to 0  */
 542             setcopy(STRautologout, STR0, VAR_READWRITE);
 543 # else /* convex */
 544     if (loginsh || (uid == 0)) {
 545         if (*cp) {
 546             /* only for login shells or root and we must have a tty */
 547             if (((cp2 = Strrchr(cp, (Char) '/')) != NULL) &&
 548                 (Strncmp(cp, STRptssl, 3) != 0)) {
 549                 cp2 = cp2 + 1;
 550             }
 551             else
 552                 cp2 = cp;
 553             if (!(((Strncmp(cp2, STRtty, 3) == 0) && Isalpha(cp2[3])) ||
 554                   Strstr(cp, STRptssl) != NULL)) {
 555                 if (getenv("DISPLAY") == NULL) {
 556                     /* NOT on X window shells */
 557                     setcopy(STRautologout, STRdefautologout, VAR_READWRITE);
 558                 }
 559             }
 560         }
 561     }
 562 # endif /* convex */
 563 #endif /* AUTOLOGOUT */
 564
 565     sigset_interrupting(SIGALRM, queue_alrmcatch);
 566
 567     setcopy(STRstatus, STR0, VAR_READWRITE);
 568
 569     /*
 570      * get and set machine specific environment variables
 571      */
 572     getmachine();
 573
 574
 575     /*
 576      * Publish the selected echo style
 577      */
 578 #if ECHO_STYLE != BSD_ECHO
 579     if (tcsh) {
 580 # if ECHO_STYLE == NONE_ECHO
 581         setcopy(STRecho_style, STRnone, VAR_READWRITE);
 582 # endif /* ECHO_STYLE == NONE_ECHO */
 583 # if ECHO_STYLE == SYSV_ECHO
 584         setcopy(STRecho_style, STRsysv, VAR_READWRITE);
 585 # endif /* ECHO_STYLE == SYSV_ECHO */
 586 # if ECHO_STYLE == BOTH_ECHO
 587         setcopy(STRecho_style, STRboth, VAR_READWRITE);
 588 # endif /* ECHO_STYLE == BOTH_ECHO */
 589     } else
 590 #endif /* ECHO_STYLE != BSD_ECHO */
 591         setcopy(STRecho_style, STRbsd, VAR_READWRITE);
 592
 593     /*
 594      * increment the shell level.
 595      */
 596     shlvl(1);
 597
 598     if ((tcp = getenv("HOME")) != NULL)
 599         cp = quote(SAVE(tcp));
 600     else
 601 #ifdef __ANDROID__
 602         /* On Android, $HOME usually isn't set, so we can't load user RC files.
 603            Check for the environment variable EXTERNAL_STORAGE, which contains
 604            the mount point of the external storage (SD card, mostly).  If
 605            EXTERNAL_STORAGE isn't set fall back to "/sdcard". */
 606     if ((tcp = getenv("EXTERNAL_STORAGE")) != NULL)
 607         cp = quote(SAVE(tcp));
 608     else
 609         cp = quote(SAVE("/sdcard"));
 610 #else
 611         cp = NULL;
 612 #endif
 613
 614     if (cp == NULL)
 615         fast = 1;               /* No home -> can't read scripts */
 616     else
 617         setv(STRhome, cp, VAR_READWRITE);
 618
 619     dinit(cp);                  /* dinit thinks that HOME == cwd in a login
 620                                  * shell */
 621     /*
 622      * Grab other useful things from the environment. Should we grab
 623      * everything??
 624      */
 625     {
 626         char *cln, *cus, *cgr;
 627         struct passwd *pw;
 628         struct group *gr;
 629
 630
 631 #ifdef apollo
 632         int     oid = getoid();
 633
 634         setv(STRoid, Itoa(oid, 0, 0), VAR_READWRITE);
 635 #endif /* apollo */
 636
 637         setv(STReuid, Itoa(euid, 0, 0), VAR_READWRITE);
 638         if ((pw = xgetpwuid(euid)) == NULL)
 639             setcopy(STReuser, STRunknown, VAR_READWRITE);
 640         else
 641             setcopy(STReuser, str2short(pw->pw_name), VAR_READWRITE);
 642
 643         setv(STRuid, Itoa(uid, 0, 0), VAR_READWRITE);
 644
 645         setv(STRgid, Itoa(gid, 0, 0), VAR_READWRITE);
 646
 647         cln = getenv("LOGNAME");
 648         cus = getenv("USER");
 649         if (cus != NULL)
 650             setv(STRuser, quote(SAVE(cus)), VAR_READWRITE);
 651         else if (cln != NULL)
 652             setv(STRuser, quote(SAVE(cln)), VAR_READWRITE);
 653         else if ((pw = xgetpwuid(uid)) == NULL)
 654             setcopy(STRuser, STRunknown, VAR_READWRITE);
 655         else
 656             setcopy(STRuser, str2short(pw->pw_name), VAR_READWRITE);
 657         if (cln == NULL)
 658             tsetenv(STRLOGNAME, varval(STRuser));
 659         if (cus == NULL)
 660             tsetenv(STRKUSER, varval(STRuser));
 661
 662         cgr = getenv("GROUP");
 663         if (cgr != NULL)
 664             setv(STRgroup, quote(SAVE(cgr)), VAR_READWRITE);
 665         else if ((gr = xgetgrgid(gid)) == NULL)
 666             setcopy(STRgroup, STRunknown, VAR_READWRITE);
 667         else
 668             setcopy(STRgroup, str2short(gr->gr_name), VAR_READWRITE);
 669         if (cgr == NULL)
 670             tsetenv(STRKGROUP, varval(STRgroup));
 671     }
 672
 673     /*
 674      * HOST may be wrong, since rexd transports the entire environment on sun
 675      * 3.x Just set it again
 676      */
 677     {
 678         char    cbuff[MAXHOSTNAMELEN];
 679
 680         if (gethostname(cbuff, sizeof(cbuff)) >= 0) {
 681             cbuff[sizeof(cbuff) - 1] = '\0';    /* just in case */
 682             tsetenv(STRHOST, str2short(cbuff));
 683         }
 684         else
 685             tsetenv(STRHOST, STRunknown);
 686     }
 687
 688
 689 #ifdef REMOTEHOST
 690     /*
 691      * Try to determine the remote host we were logged in from.
 692      */
 693     remotehost();
 694 #endif /* REMOTEHOST */
 695
 696 #ifdef apollo
 697     if ((tcp = getenv("SYSTYPE")) == NULL)
 698         tcp = "bsd4.3";
 699     tsetenv(STRSYSTYPE, quote(str2short(tcp)));
 700 #endif /* apollo */
 701
 702     /*
 703      * set editing on by default, unless running under Emacs as an inferior
 704      * shell.
 705      * We try to do this intelligently. If $TERM is available, then it
 706      * should determine if we should edit or not. $TERM is preserved
 707      * across rlogin sessions, so we will not get confused if we rlogin
 708      * under an emacs shell. Another advantage is that if we run an
 709      * xterm under an emacs shell, then the $TERM will be set to
 710      * xterm, so we are going to want to edit. Unfortunately emacs
 711      * does not restore all the tty modes, so xterm is not very well
 712      * set up. But this is not the shell's fault.
 713      * Also don't edit if $TERM == wm, for when we're running under an ATK app.
 714      * Finally, emacs compiled under terminfo, sets the terminal to dumb,
 715      * so disable editing for that too.
 716      *
 717      * Unfortunately, in some cases the initial $TERM setting is "unknown",
 718      * "dumb", or "network" which is then changed in the user's startup files.
 719      * We fix this by setting noediting here if $TERM is unknown/dumb and
 720      * if noediting is set, we switch on editing if $TERM is changed.
 721      */
 722     if ((tcp = getenv("TERM")) != NULL) {
 723         setv(STRterm, quote(SAVE(tcp)), VAR_READWRITE);
 724         noediting = strcmp(tcp, "unknown") == 0 || strcmp(tcp, "dumb") == 0 ||
 725                     strcmp(tcp, "network") == 0;
 726         editing = strcmp(tcp, "emacs") != 0 && strcmp(tcp, "wm") != 0 &&
 727                   !noediting;
 728     }
 729     else {
 730         noediting = 0;
 731         editing = ((tcp = getenv("EMACS")) == NULL || strcmp(tcp, "t") != 0);
 732     }
 733
 734     /*
 735      * The 'edit' variable is either set or unset.  It doesn't
 736      * need a value.  Making it 'emacs' might be confusing.
 737      */
 738     if (editing)
 739         setNS(STRedit);
 740
 741
 742     /*
 743      * still more mutability: make the complete routine automatically add the
 744      * suffix of file names...
 745      */
 746     setNS(STRaddsuffix);
 747
 748     /*
 749      * Compatibility with tcsh >= 6.12 by default
 750      */
 751     setNS(STRcsubstnonl);
 752
 753     /*
 754      * Random default kill ring size
 755      */
 756     setcopy(STRkillring, str2short("30"), VAR_READWRITE);
 757
 758     /*
 759      * Re-initialize path if set in environment
 760      */
 761     if ((tcp = getenv("PATH")) == NULL)
 762 #ifdef _PATH_DEFPATH
 763         importpath(str2short(_PATH_DEFPATH));
 764 #else /* !_PATH_DEFPATH */
 765         setq(STRpath, defaultpath(), &shvhed, VAR_READWRITE);
 766 #endif /* _PATH_DEFPATH */
 767     else
 768         /* Importpath() allocates memory for the path, and the
 769          * returned pointer from SAVE() was discarded, so
 770          * this was a memory leak.. (sg)
 771          *
 772          * importpath(SAVE(tcp));
 773          */
 774         importpath(str2short(tcp));
 775
 776
 777     {
 778         /* If the SHELL environment variable ends with "tcsh", set
 779          * STRshell to the same path.  This is to facilitate using
 780          * the executable in environments where the compiled-in
 781          * default isn't appropriate (sg).
 782          */
 783
 784         size_t sh_len = 0;
 785
 786         if ((tcp = getenv("SHELL")) != NULL) {
 787             sh_len = strlen(tcp);
 788             if ((sh_len >= 5 && strcmp(tcp + (sh_len - 5), "/tcsh") == 0) ||
 789                 (!tcsh && sh_len >= 4 && strcmp(tcp + (sh_len - 4), "/csh") == 0))
 790                 setv(STRshell, quote(SAVE(tcp)), VAR_READWRITE);
 791             else
 792                 sh_len = 0;
 793         }
 794         if (sh_len == 0)
 795             setcopy(STRshell, STR_SHELLPATH, VAR_READWRITE);
 796     }
 797
 798 #ifdef _OSD_POSIX  /* BS2000 needs this variable set to "SHELL" */
 799     if ((tcp = getenv("PROGRAM_ENVIRONMENT")) == NULL)
 800         tcp = "SHELL";
 801     tsetenv(STRPROGRAM_ENVIRONMENT, quote(str2short(tcp)));
 802 #endif /* _OSD_POSIX */
 803
 804 #ifdef COLOR_LS_F
 805     if ((tcp = getenv("LS_COLORS")) != NULL)
 806         parseLS_COLORS(str2short(tcp));
 807     if ((tcp = getenv("LSCOLORS")) != NULL)
 808         parseLSCOLORS(str2short(tcp));
 809 #endif /* COLOR_LS_F */
 810
 811     doldol = putn((tcsh_number_t)getpid());     /* For $$ */
 812 #ifdef WINNT_NATIVE
 813     {
 814         char *tmp;
 815         Char *tmp2;
 816         if ((tmp = getenv("TMP")) != NULL) {
 817             tmp = xasprintf("%s/%s", tmp, "sh");
 818             tmp2 = SAVE(tmp);
 819             xfree(tmp);
 820         }
 821         else {
 822             tmp2 = SAVE("");
 823         }
 824         shtemp = Strspl(tmp2, doldol);  /* For << */
 825         xfree(tmp2);
 826     }
 827 #else /* !WINNT_NATIVE */
 828 #ifdef HAVE_MKSTEMP
 829     {
 830         const char *tmpdir = getenv ("TMPDIR");
 831         if (!tmpdir)
 832             tmpdir = "/tmp";
 833         shtemp = Strspl(SAVE(tmpdir), SAVE("/sh" TMP_TEMPLATE)); /* For << */
 834     }
 835 #else /* !HAVE_MKSTEMP */
 836     shtemp = Strspl(STRtmpsh, doldol);  /* For << */
 837 #endif /* HAVE_MKSTEMP */
 838 #endif /* WINNT_NATIVE */
 839
 840     /*
 841      * Record the interrupt states from the parent process. If the parent is
 842      * non-interruptible our hand must be forced or we (and our children) won't
 843      * be either. Our children inherit termination from our parent. We catch it
 844      * only if we are the login shell.
 845      */
 846     sigaction(SIGINT, NULL, &parintr);
 847     sigaction(SIGTERM, NULL, &parterm);
 848
 849
 850 #ifdef TCF
 851     /* Enable process migration on ourselves and our progeny */
 852     (void) signal(SIGMIGRATE, SIG_DFL);
 853 #endif /* TCF */
 854
 855     /*
 856      * dspkanji/dspmbyte autosetting
 857      */
 858     /* PATCH IDEA FROM Issei.Suzuki VERY THANKS */
 859 #if defined(DSPMBYTE)
 860 #if defined(NLS) && defined(LC_CTYPE)
 861     if (((tcp = setlocale(LC_CTYPE, NULL)) != NULL || (tcp = getenv("LANG")) != NULL) && !adrof(CHECK_MBYTEVAR))
 862 #else
 863     if ((tcp = getenv("LANG")) != NULL && !adrof(CHECK_MBYTEVAR))
 864 #endif
 865     {
 866         autoset_dspmbyte(str2short(tcp));
 867     }
 868 #if defined(WINNT_NATIVE)
 869     else if (!adrof(CHECK_MBYTEVAR))
 870       nt_autoset_dspmbyte();
 871 #endif /* WINNT_NATIVE */
 872 #endif
 873 #if defined(AUTOSET_KANJI)
 874 # if defined(NLS) && defined(LC_CTYPE)
 875     if (setlocale(LC_CTYPE, NULL) != NULL || getenv("LANG") != NULL)
 876 # else
 877     if (getenv("LANG") != NULL)
 878 # endif
 879         autoset_kanji();
 880 #endif /* AUTOSET_KANJI */
 881     fix_version();              /* publish the shell version */
 882
 883     if (argc > 1 && strcmp(argv[1], "--version") == 0) {
 884         xprintf("%S\n", varval(STRversion));
 885         xexit(0);
 886     }
 887     if (argc > 1 && strcmp(argv[1], "--help") == 0) {
 888         xprintf("%S\n\n", varval(STRversion));
 889         xprintf("%s", CGETS(11, 8, HELP_STRING));
 890         xexit(0);
 891     }
 892     /*
 893      * Process the arguments.
 894      *
 895      * Note that processing of -v/-x is actually delayed till after script
 896      * processing.
 897      *
 898      * We set the first character of our name to be '-' if we are a shell
 899      * running interruptible commands.  Many programs which examine ps'es
 900      * use this to filter such shells out.
 901      */
 902     argc--, tempv++;
 903     while (argc > 0 && (tcp = tempv[0])[0] == '-' &&
 904            *++tcp != '\0' && !batch) {
 905         do
 906             switch (*tcp++) {
 907
 908             case 0:             /* -    Interruptible, no prompt */
 909                 prompt = 0;
 910                 setintr = 1;
 911                 nofile = 1;
 912                 break;
 913
 914             case 'b':           /* -b   Next arg is input file */
 915                 batch = 1;
 916                 break;
 917
 918             case 'c':           /* -c   Command input from arg */
 919                 if (argc == 1)
 920                     xexit(0);
 921                 argc--, tempv++;
 922 #ifdef M_XENIX
 923                 /* Xenix Vi bug:
 924                    it relies on a 7 bit environment (/bin/sh), so it
 925                    pass ascii arguments with the 8th bit set */
 926                 if (!strcmp(argv[0], "sh"))
 927                   {
 928                     char *p;
 929
 930                     for (p = tempv[0]; *p; ++p)
 931                       *p &= ASCII;
 932                   }
 933 #endif
 934                 arginp = SAVE(tempv[0]);
 935
 936                 /*
 937                  * we put the command into a variable
 938                  */
 939                 if (arginp != NULL)
 940                     setv(STRcommand, quote(Strsave(arginp)), VAR_READWRITE);
 941
 942                 /*
 943                  * * Give an error on -c arguments that end in * backslash to
 944                  * ensure that you don't make * nonportable csh scripts.
 945                  */
 946                 {
 947                     int count;
 948
 949                     cp = Strend(arginp);
 950                     count = 0;
 951                     while (cp > arginp && *--cp == '\\')
 952                         ++count;
 953                     if ((count & 1) != 0) {
 954                         exiterr = 1;
 955                         stderror(ERR_ARGC);
 956                     }
 957                 }
 958                 prompt = 0;
 959                 nofile = 1;
 960                 break;
 961             case 'd':           /* -d   Load directory stack from file */
 962                 rdirs = 1;
 963                 break;
 964
 965 #ifdef apollo
 966             case 'D':           /* -D   Define environment variable */
 967                 {
 968                     Char *dp;
 969
 970                     cp = str2short(tcp);
 971                     if (dp = Strchr(cp, '=')) {
 972                         *dp++ = '\0';
 973                         tsetenv(cp, dp);
 974                     }
 975                     else
 976                         tsetenv(cp, STRNULL);
 977                 }
 978                 *tcp = '\0';    /* done with this argument */
 979                 break;
 980 #endif /* apollo */
 981
 982             case 'e':           /* -e   Exit on any error */
 983                 exiterr = 1;
 984                 break;
 985
 986             case 'f':           /* -f   Fast start */
 987                 fast = 1;
 988                 break;
 989
 990             case 'i':           /* -i   Interactive, even if !intty */
 991                 intact = 1;
 992                 nofile = 1;
 993                 break;
 994
 995             case 'm':           /* -m   read .cshrc (from su) */
 996                 mflag = 1;
 997                 break;
 998
 999             case 'n':           /* -n   Don't execute */
1000                 noexec = 1;
1001                 break;
1002
1003             case 'q':           /* -q   (Undoc'd) ... die on quit */
1004                 quitit = 1;
1005                 break;
1006
1007             case 's':           /* -s   Read from std input */
1008                 nofile = 1;
1009                 break;
1010
1011             case 't':           /* -t   Read one line from input */
1012                 onelflg = 2;
1013                 prompt = 0;
1014                 nofile = 1;
1015                 break;
1016
1017             case 'v':           /* -v   Echo hist expanded input */
1018                 nverbose = 1;   /* ... later */
1019                 break;
1020
1021             case 'x':           /* -x   Echo just before execution */
1022                 nexececho = 1;  /* ... later */
1023                 break;
1024
1025             case 'V':           /* -V   Echo hist expanded input */
1026                 setNS(STRverbose);      /* NOW! */
1027                 break;
1028
1029             case 'X':           /* -X   Echo just before execution */
1030                 setNS(STRecho); /* NOW! */
1031                 break;
1032
1033             case 'F':
1034                 /*
1035                  * This will cause children to be created using fork instead of
1036                  * vfork.
1037                  */
1038                 use_fork = 1;
1039                 break;
1040
1041             case ' ':
1042             case '\t':
1043             case '\r':
1044             case '\n':
1045                 /*
1046                  * for O/S's that don't do the argument parsing right in
1047                  * "#!/foo -f " scripts
1048                  */
1049                 break;
1050
1051             default:            /* Unknown command option */
1052                 exiterr = 1;
1053                 stderror(ERR_TCSHUSAGE, tcp-1, progname);
1054                 break;
1055
1056         } while (*tcp);
1057         tempv++, argc--;
1058     }
1059
1060     if (quitit)                 /* With all due haste, for debugging */
1061         (void) signal(SIGQUIT, SIG_DFL);
1062
1063     /*
1064      * Unless prevented by -, -c, -i, -s, or -t, if there are remaining
1065      * arguments the first of them is the name of a shell file from which to
1066      * read commands.
1067      */
1068     if (nofile == 0 && argc > 0) {
1069         nofile = xopen(tempv[0], O_RDONLY|O_LARGEFILE);
1070         if (nofile < 0) {
1071             child = 1;          /* So this ... */
1072             /* ... doesn't return */
1073             stderror(ERR_SYSTEM, tempv[0], strerror(errno));
1074         }
1075         xfree(ffile);
1076         dolzero = 1;
1077         ffile = SAVE(tempv[0]);
1078         /*
1079          * Replace FSHIN. Handle /dev/std{in,out,err} specially
1080          * since once they are closed we cannot open them again.
1081          * In that case we use our own saved descriptors
1082          */
1083         if ((SHIN = dmove(nofile, FSHIN)) < 0)
1084             switch(nofile) {
1085             case 0:
1086                 SHIN = FSHIN;
1087                 break;
1088             case 1:
1089                 SHIN = FSHOUT;
1090                 break;
1091             case 2:
1092                 SHIN = FSHDIAG;
1093                 break;
1094             default:
1095                 stderror(ERR_SYSTEM, tempv[0], strerror(errno));
1096                 break;
1097             }
1098         (void) close_on_exec(SHIN, 1);
1099         prompt = 0;
1100          /* argc not used any more */ tempv++;
1101     }
1102
1103     /*
1104      * Call to closem() used to be part of initdesc(). Now called below where
1105      * the script name argument has become stdin. Kernel may have used a file
1106      * descriptor to hold the name of the script (setuid case) and this name
1107      * mustn't be lost by closing the fd too soon.
1108      */
1109     closem();
1110
1111     /*
1112      * Consider input a tty if it really is or we are interactive. but not for
1113      * editing (christos)
1114      */
1115     if (!(intty = isatty(SHIN))) {
1116         if (adrof(STRedit))
1117             unsetv(STRedit);
1118         editing = 0;
1119     }
1120     intty |= intact;
1121 #ifndef convex
1122     if (intty || (intact && isatty(SHOUT))) {
1123         if (!batch && (uid != euid || gid != egid)) {
1124             errno = EACCES;
1125             child = 1;          /* So this ... */
1126             /* ... doesn't return */
1127             stderror(ERR_SYSTEM, progname, strerror(errno));
1128         }
1129     }
1130 #endif /* convex */
1131     isoutatty = isatty(SHOUT);
1132     isdiagatty = isatty(SHDIAG);
1133     /*
1134      * Decide whether we should play with signals or not. If we are explicitly
1135      * told (via -i, or -) or we are a login shell (arg0 starts with -) or the
1136      * input and output are both the ttys("csh", or "csh</dev/ttyx>/dev/ttyx")
1137      * Note that in only the login shell is it likely that parent may have set
1138      * signals to be ignored
1139      */
1140     if (loginsh || intact || (intty && isatty(SHOUT)))
1141         setintr = 1;
1142     settell();
1143     /*
1144      * Save the remaining arguments in argv.
1145      */
1146     setq(STRargv, blk2short(tempv), &shvhed, VAR_READWRITE);
1147
1148     /*
1149      * Set up the prompt.
1150      */
1151     if (prompt) {
1152         setcopy(STRprompt, STRdefprompt, VAR_READWRITE);
1153         /* that's a meta-questionmark */
1154         setcopy(STRprompt2, STRmquestion, VAR_READWRITE);
1155         setcopy(STRprompt3, STRKCORRECT, VAR_READWRITE);
1156     }
1157
1158     /*
1159      * If we are an interactive shell, then start fiddling with the signals;
1160      * this is a tricky game.
1161      */
1162     shpgrp = mygetpgrp();
1163     opgrp = tpgrp = -1;
1164     if (setintr) {
1165         struct sigaction osig;
1166
1167         **argv = '-';
1168         if (!quitit)            /* Wary! */
1169             (void) signal(SIGQUIT, SIG_IGN);
1170         pintr_disabled = 1;
1171         sigset_interrupting(SIGINT, queue_pintr);
1172         (void) signal(SIGTERM, SIG_IGN);
1173
1174         /*
1175          * No reason I can see not to save history on all these events..
1176          * Most usual occurrence is in a window system, where we're not a login
1177          * shell, but might as well be... (sg)
1178          * But there might be races when lots of shells exit together...
1179          * [this is also incompatible].
1180          * We have to be mre careful here. If the parent wants to
1181          * ignore the signals then we leave them untouched...
1182          * We also only setup the handlers for shells that are trully
1183          * interactive.
1184          */
1185         sigaction(SIGHUP, NULL, &osig);
1186         if (loginsh || osig.sa_handler != SIG_IGN)
1187             /* exit processing on HUP */
1188             sigset_interrupting(SIGHUP, queue_phup);
1189 #ifdef SIGXCPU
1190         sigaction(SIGXCPU, NULL, &osig);
1191         if (loginsh || osig.sa_handler != SIG_IGN)
1192             /* exit processing on XCPU */
1193             sigset_interrupting(SIGXCPU, queue_phup);
1194 #endif
1195 #ifdef SIGXFSZ
1196         sigaction(SIGXFSZ, NULL, &osig);
1197         if (loginsh || osig.sa_handler != SIG_IGN)
1198             /* exit processing on XFSZ */
1199             sigset_interrupting(SIGXFSZ, queue_phup);
1200 #endif
1201
1202         if (quitit == 0 && arginp == 0) {
1203 #ifdef SIGTSTP
1204             (void) signal(SIGTSTP, SIG_IGN);
1205 #endif
1206 #ifdef SIGTTIN
1207             (void) signal(SIGTTIN, SIG_IGN);
1208 #endif
1209 #ifdef SIGTTOU
1210             (void) signal(SIGTTOU, SIG_IGN);
1211 #endif
1212             /*
1213              * Wait till in foreground, in case someone stupidly runs csh &
1214              * dont want to try to grab away the tty.
1215              */
1216             if (isatty(FSHDIAG))
1217                 f = FSHDIAG;
1218             else if (isatty(FSHOUT))
1219                 f = FSHOUT;
1220             else if (isatty(OLDSTD))
1221                 f = OLDSTD;
1222             else
1223                 f = -1;
1224
1225 #ifdef NeXT
1226             /* NeXT 2.0 /usr/etc/rlogind, does not set our process group! */
1227             if (f != -1 && shpgrp == 0) {
1228                 shpgrp = getpid();
1229                 (void) setpgid(0, shpgrp);
1230                 (void) tcsetpgrp(f, shpgrp);
1231             }
1232 #endif /* NeXT */
1233 #ifdef BSDJOBS                  /* if we have tty job control */
1234             if (f != -1 && grabpgrp(f, shpgrp) != -1) {
1235                 /*
1236                  * Thanks to Matt Day for the POSIX references, and to
1237                  * Paul Close for the SGI clarification.
1238                  */
1239                 if (setdisc(f) != -1) {
1240                     opgrp = shpgrp;
1241                     shpgrp = getpid();
1242                     tpgrp = shpgrp;
1243                     if (tcsetpgrp(f, shpgrp) == -1) {
1244                         /*
1245                          * On hpux 7.03 this fails with EPERM. This happens on
1246                          * the 800 when opgrp != shpgrp at this point. (we were
1247                          * forked from a non job control shell)
1248                          * POSIX 7.2.4, says we failed because the process
1249                          * group specified did not belong to a process
1250                          * in the same session with the tty. So we set our
1251                          * process group and try again.
1252                          */
1253                         if (setpgid(0, shpgrp) == -1) {
1254                             xprintf("setpgid:");
1255                             goto notty;
1256                         }
1257                         if (tcsetpgrp(f, shpgrp) == -1) {
1258                             xprintf("tcsetpgrp:");
1259                             goto notty;
1260                         }
1261                     }
1262                     /*
1263                      * We check the process group now. If it is the same, then
1264                      * we don't need to set it again. On hpux 7.0 on the 300's
1265                      * if we set it again it fails with EPERM. This is the
1266                      * correct behavior according to POSIX 4.3.3 if the process
1267                      * was a session leader .
1268                      */
1269                     else if (shpgrp != mygetpgrp()) {
1270                         if(setpgid(0, shpgrp) == -1) {
1271                             xprintf("setpgid:");
1272                             goto notty;
1273                         }
1274                     }
1275 #ifdef IRIS4D
1276                     /*
1277                      * But on irix 3.3 we need to set it again, even if it is
1278                      * the same. We do that to tell the system that we
1279                      * need BSD process group compatibility.
1280                      */
1281                     else
1282                         (void) setpgid(0, shpgrp);
1283 #endif
1284                     (void) close_on_exec(dcopy(f, FSHTTY), 1);
1285                 }
1286                 else
1287                     tpgrp = -1;
1288             }
1289             if (tpgrp == -1) {
1290         notty:
1291                 xprintf(CGETS(11, 1, "Warning: no access to tty (%s).\n"),
1292                     strerror(errno));
1293                 xprintf("%s",
1294                     CGETS(11, 2, "Thus no job control in this shell.\n"));
1295                 /*
1296                  * Fix from:Sakari Jalovaara <sja@sirius.hut.fi> if we don't
1297                  * have access to tty, disable editing too
1298                  */
1299                 if (adrof(STRedit))
1300                     unsetv(STRedit);
1301                 editing = 0;
1302             }
1303 #else   /* BSDJOBS */           /* don't have job control, so frotz it */
1304             tpgrp = -1;
1305 #endif                          /* BSDJOBS */
1306         }
1307     }
1308     if (setintr == 0 && parintr.sa_handler == SIG_DFL)
1309         setintr = 1;
1310
1311 /*
1312  * SVR4 doesn't send a SIGCHLD when a child is stopped or continued if the
1313  * handler is installed with signal(2) or sigset(2).  sigaction(2) must
1314  * be used instead.
1315  *
1316  * David Dawes (dawes@physics.su.oz.au) Sept 1991
1317  */
1318     sigset_interrupting(SIGCHLD, queue_pchild);
1319
1320     if (intty && !arginp)
1321         (void) ed_Setup(editing);/* Get the tty state, and set defaults */
1322                                  /* Only alter the tty state if editing */
1323
1324     /*
1325      * Set an exit here in case of an interrupt or error reading the shell
1326      * start-up scripts.
1327      */
1328     osetintr = setintr;
1329     oparintr = parintr;
1330     (void)cleanup_push_mark(); /* There is no outer handler */
1331     if (setexit() != 0) /* PWP */
1332         reenter = 1;
1333     else
1334         reenter = 0;
1335     exitset++;
1336     haderr = 0;                 /* In case second time through */
1337     if (!fast && reenter == 0) {
1338         /* Will have varval(STRhome) here because set fast if don't */
1339         {
1340             pintr_disabled++;
1341             cleanup_push(&pintr_disabled, disabled_cleanup);
1342             setintr = 0;/*FIXRESET:cleanup*/
1343             /* onintr in /etc/ files has no effect */
1344             parintr.sa_handler = SIG_IGN;/*FIXRESET: cleanup*/
1345 #ifdef LOGINFIRST
1346 #ifdef _PATH_DOTLOGIN
1347             if (loginsh)
1348                 (void) srcfile(_PATH_DOTLOGIN, 0, 0, NULL);
1349 #endif
1350 #endif
1351
1352 #ifdef _PATH_DOTCSHRC
1353             (void) srcfile(_PATH_DOTCSHRC, 0, 0, NULL);
1354 #endif
1355             if (!arginp && !onelflg && !havhash)
1356                 dohash(NULL,NULL);
1357 #ifndef LOGINFIRST
1358 #ifdef _PATH_DOTLOGIN
1359             if (loginsh)
1360                 (void) srcfile(_PATH_DOTLOGIN, 0, 0, NULL);
1361 #endif
1362 #endif
1363             cleanup_until(&pintr_disabled);
1364             setintr = osetintr;
1365             parintr = oparintr;
1366         }
1367 #ifdef LOGINFIRST
1368         if (loginsh)
1369             (void) srccat(varval(STRhome), STRsldotlogin);
1370 #endif
1371         /* upward compat. */
1372         if (!srccat(varval(STRhome), STRsldottcshrc))
1373             (void) srccat(varval(STRhome), STRsldotcshrc);
1374
1375         if (!arginp && !onelflg && !havhash)
1376             dohash(NULL,NULL);
1377
1378         /*
1379          * Source history before .login so that it is available in .login
1380          */
1381         loadhist(NULL, 0);
1382 #ifndef LOGINFIRST
1383         if (loginsh)
1384             (void) srccat(varval(STRhome), STRsldotlogin);
1385 #endif
1386         if (loginsh || rdirs)
1387             loaddirs(NULL);
1388     }
1389     /* Reset interrupt flag */
1390     setintr = osetintr;
1391     parintr = oparintr;
1392     exitset--;
1393
1394     /* Initing AFTER .cshrc is the Right Way */
1395     if (intty && !arginp) {     /* PWP setup stuff */
1396         ed_Init();              /* init the new line editor */
1397 #ifdef SIG_WINDOW
1398         check_window_size(1);   /* mung environment */
1399 #endif                          /* SIG_WINDOW */
1400     }
1401
1402     /*
1403      * Now are ready for the -v and -x flags
1404      */
1405     if (nverbose)
1406         setNS(STRverbose);
1407     if (nexececho)
1408         setNS(STRecho);
1409
1410     /*
1411      * All the rest of the world is inside this call. The argument to process
1412      * indicates whether it should catch "error unwinds".  Thus if we are a
1413      * interactive shell our call here will never return by being blown past on
1414      * an error.
1415      */
1416     process(setintr);
1417
1418     /*
1419      * Mop-up.
1420      */
1421     /* Take care of these (especially HUP) here instead of inside flush. */
1422     handle_pending_signals();
1423     if (intty) {
1424         if (loginsh) {
1425             xprintf("logout\n");
1426             xclose(SHIN);
1427             child = 1;
1428 #ifdef TESLA
1429             do_logout = 1;
1430 #endif                          /* TESLA */
1431             goodbye(NULL, NULL);
1432         }
1433         else {
1434             xprintf("exit\n");
1435         }
1436     }
1437     record();
1438     exitstat();
1439     return (0);
1440 }
1441
1442 void
1443 untty(void)
1444 {
1445 #ifdef BSDJOBS
1446     if (tpgrp > 0 && opgrp != shpgrp) {
1447         (void) setpgid(0, opgrp);
1448         (void) tcsetpgrp(FSHTTY, opgrp);
1449         (void) resetdisc(FSHTTY);
1450     }
1451 #endif /* BSDJOBS */
1452 }
1453
1454 void
1455 importpath(Char *cp)
1456 {
1457     size_t i = 0;
1458     Char *dp;
1459     Char **pv;
1460     int     c;
1461
1462     for (dp = cp; *dp; dp++)
1463         if (*dp == PATHSEP)
1464             i++;
1465     /*
1466      * i+2 where i is the number of colons in the path. There are i+1
1467      * directories in the path plus we need room for a zero terminator.
1468      */
1469     pv = xcalloc(i + 2, sizeof(Char *));
1470     dp = cp;
1471     i = 0;
1472     if (*dp)
1473         for (;;) {
1474             if ((c = *dp) == PATHSEP || c == 0) {
1475                 *dp = 0;
1476                 pv[i++] = Strsave(*cp ? cp : STRdot);
1477                 if (c) {
1478                     cp = dp + 1;
1479                     *dp = PATHSEP;
1480                 }
1481                 else
1482                     break;
1483             }
1484 #ifdef WINNT_NATIVE
1485             else if (*dp == '\\')
1486                 *dp = '/';
1487 #endif /* WINNT_NATIVE */
1488             dp++;
1489         }
1490     pv[i] = 0;
1491     cleanup_push(pv, blk_cleanup);
1492     setq(STRpath, pv, &shvhed, VAR_READWRITE);
1493     cleanup_ignore(pv);
1494     cleanup_until(pv);
1495 }
1496
1497 /*
1498  * Source to the file which is the catenation of the argument names.
1499  */
1500 static int
1501 srccat(Char *cp, Char *dp)
1502 {
1503     if (cp[0] == '/' && cp[1] == '\0')
1504         return srcfile(short2str(dp), (mflag ? 0 : 1), 0, NULL);
1505     else {
1506         Char *ep;
1507         char   *ptr;
1508         int rv;
1509
1510 #ifdef WINNT_NATIVE
1511         ep = Strend(cp);
1512         if (ep != cp && ep[-1] == '/' && dp[0] == '/') /* silly win95 */
1513             dp++;
1514 #endif /* WINNT_NATIVE */
1515
1516         ep = Strspl(cp, dp);
1517         cleanup_push(ep, xfree);
1518         ptr = short2str(ep);
1519
1520         rv = srcfile(ptr, (mflag ? 0 : 1), 0, NULL);
1521         cleanup_until(ep);
1522         return rv;
1523     }
1524 }
1525
1526 /*
1527  * Source to a file putting the file descriptor in a safe place (> 2).
1528  */
1529 #ifndef WINNT_NATIVE
1530 static int
1531 #else
1532 int
1533 #endif /*WINNT_NATIVE*/
1534 srcfile(const char *f, int onlyown, int flag, Char **av)
1535 {
1536     int unit;
1537
1538     if ((unit = xopen(f, O_RDONLY|O_LARGEFILE)) == -1)
1539         return 0;
1540     cleanup_push(&unit, open_cleanup);
1541     unit = dmove(unit, -1);
1542     cleanup_ignore(&unit);
1543     cleanup_until(&unit);
1544
1545     (void) close_on_exec(unit, 1);
1546     srcunit(unit, onlyown, flag, av);
1547     return 1;
1548 }
1549
1550
1551 /*
1552  * Save the shell state, and establish new argument vector, and new input
1553  * fd.
1554  */
1555 static void
1556 st_save(struct saved_state *st, int unit, int hflg, Char **al, Char **av)
1557 {
1558     st->insource        = insource;
1559     st->SHIN            = SHIN;
1560     /* Want to preserve the meaning of "source file >output".
1561      * Save old descriptors, move new 0,1,2 to safe places and assign
1562      * them to SH* and let process() redo 0,1,2 from them.
1563      *
1564      * The macro returns true if d1 and d2 are good and they point to
1565      * different things.  If you don't avoid saving duplicate
1566      * descriptors, you really limit the depth of "source" recursion
1567      * you can do because of all the open file descriptors.  -IAN!
1568      */
1569 #define NEED_SAVE_FD(d1,d2) \
1570     (fstat(d1, &s1) != -1 && fstat(d2, &s2) != -1 \
1571         && (s1.st_ino != s2.st_ino || s1.st_dev != s2.st_dev) )
1572
1573     st->OLDSTD = st->SHOUT = st->SHDIAG = -1;/* test later to restore these */
1574     if (didfds) {
1575             struct stat s1, s2;
1576             if (NEED_SAVE_FD(0,OLDSTD)) {
1577                     st->OLDSTD = OLDSTD;
1578                     OLDSTD = dmove(0, -1);
1579                     (void)close_on_exec(OLDSTD, 1);
1580             }
1581             if (NEED_SAVE_FD(1,SHOUT)) {
1582                     st->SHOUT = SHOUT;
1583                     SHOUT = dmove(1, -1);
1584                     (void)close_on_exec(SHOUT, 1);
1585             }
1586             if (NEED_SAVE_FD(2,SHDIAG)) {
1587                     st->SHDIAG = SHDIAG;
1588                     SHDIAG = dmove(2, -1);
1589                     (void)close_on_exec(SHDIAG, 1);
1590             }
1591             donefds();
1592     }
1593
1594     st->intty           = intty;
1595     st->whyles          = whyles;
1596     st->gointr          = gointr;
1597     st->arginp          = arginp;
1598     st->evalp           = evalp;
1599     st->evalvec         = evalvec;
1600     st->alvecp          = alvecp;
1601     st->alvec           = alvec;
1602     st->onelflg         = onelflg;
1603     st->enterhist       = enterhist;
1604     st->justpr          = justpr;
1605     if (hflg)
1606         st->HIST        = HIST;
1607     else
1608         st->HIST        = '\0';
1609     st->cantell         = cantell;
1610     cpybin(st->B, B);
1611
1612     /*
1613      * we can now pass arguments to source.
1614      * For compatibility we do that only if arguments were really
1615      * passed, otherwise we keep the old, global $argv like before.
1616      */
1617     if (av != NULL && *av != NULL) {
1618         struct varent *vp;
1619         if ((vp = adrof(STRargv)) != NULL && vp->vec != NULL)
1620             st->argv = saveblk(vp->vec);
1621         else
1622             st->argv = NULL;
1623         setq(STRargv, saveblk(av), &shvhed, VAR_READWRITE);
1624     }
1625     else
1626         st->argv = NULL;
1627     st->av = av;
1628
1629     SHIN        = unit; /* Do this first */
1630
1631     /* Establish new input arena */
1632     {
1633         fbuf = NULL;
1634         fseekp = feobp = fblocks = 0;
1635         settell();
1636     }
1637
1638     arginp      = 0;
1639     onelflg     = 0;
1640     intty       = isatty(SHIN);
1641     whyles      = 0;
1642     gointr      = 0;
1643     evalvec     = 0;
1644     evalp       = 0;
1645     alvec       = al;
1646     alvecp      = 0;
1647     enterhist   = hflg;
1648     if (enterhist)
1649         HIST    = '\0';
1650     insource    = 1;
1651 }
1652
1653
1654 /*
1655  * Restore the shell to a saved state
1656  */
1657 static void
1658 st_restore(void *xst)
1659 {
1660     struct saved_state *st;
1661
1662     st = xst;
1663     if (st->SHIN == -1)
1664         return;
1665
1666     /* Reset input arena */
1667     {
1668         int i;
1669         Char** nfbuf = fbuf;
1670         int nfblocks = fblocks;
1671
1672         fblocks = 0;
1673         fbuf = NULL;
1674         for (i = 0; i < nfblocks; i++)
1675             xfree(nfbuf[i]);
1676         xfree(nfbuf);
1677     }
1678     cpybin(B, st->B);
1679
1680     xclose(SHIN);
1681
1682     insource    = st->insource;
1683     SHIN        = st->SHIN;
1684     if (st->OLDSTD != -1)
1685         xclose(OLDSTD), OLDSTD = st->OLDSTD;
1686     if (st->SHOUT != -1)
1687         xclose(SHOUT),  SHOUT = st->SHOUT;
1688     if (st->SHDIAG != -1)
1689         xclose(SHDIAG), SHDIAG = st->SHDIAG;
1690     arginp      = st->arginp;
1691     onelflg     = st->onelflg;
1692     evalp       = st->evalp;
1693     evalvec     = st->evalvec;
1694     alvecp      = st->alvecp;
1695     alvec       = st->alvec;
1696     intty       = st->intty;
1697     whyles      = st->whyles;
1698     gointr      = st->gointr;
1699     if (st->HIST != '\0')
1700         HIST    = st->HIST;
1701     enterhist   = st->enterhist;
1702     cantell     = st->cantell;
1703     justpr      = st->justpr;
1704
1705     if (st->argv != NULL)
1706         setq(STRargv, st->argv, &shvhed, VAR_READWRITE);
1707     else if (st->av != NULL  && *st->av != NULL && adrof(STRargv) != NULL)
1708         unsetv(STRargv);
1709 }
1710
1711 /*
1712  * Source to a unit.  If onlyown it must be our file or our group or
1713  * we don't chance it.  This occurs on ".cshrc"s and the like.
1714  */
1715 static void
1716 srcunit(int unit, int onlyown, int hflg, Char **av)
1717 {
1718     struct saved_state st;
1719
1720     st.SHIN = -1;       /* st_restore checks this */
1721
1722     if (unit < 0)
1723         return;
1724
1725     if (onlyown) {
1726         struct stat stb;
1727
1728         if (fstat(unit, &stb) < 0) {
1729             xclose(unit);
1730             return;
1731         }
1732     }
1733
1734     /* Does nothing before st_save() because st.SHIN == -1 */
1735     cleanup_push(&st, st_restore);
1736     if (setintr) {
1737         pintr_disabled++;
1738         cleanup_push(&pintr_disabled, disabled_cleanup);
1739     }
1740
1741     /* Save the current state and move us to a new state */
1742     st_save(&st, unit, hflg, NULL, av);
1743
1744     /*
1745      * Now if we are allowing commands to be interrupted, we let ourselves be
1746      * interrupted.
1747      */
1748     if (setintr) {
1749         cleanup_until(&pintr_disabled);
1750         pintr_disabled++;
1751         cleanup_push(&pintr_disabled, disabled_cleanup);
1752     }
1753
1754     process(0);         /* 0 -> blow away on errors */
1755
1756     /* Restore the old state */
1757     cleanup_until(&st);
1758 }
1759
1760
1761 /*ARGSUSED*/
1762 void
1763 goodbye(Char **v, struct command *c)
1764 {
1765     USE(v);
1766     USE(c);
1767     record();
1768
1769     if (loginsh) {
1770         size_t omark;
1771         sigset_t set;
1772
1773         sigemptyset(&set);
1774         signal(SIGQUIT, SIG_IGN);
1775         sigaddset(&set, SIGQUIT);
1776         sigprocmask(SIG_UNBLOCK, &set, NULL);
1777         signal(SIGINT, SIG_IGN);
1778         sigaddset(&set, SIGINT);
1779         signal(SIGTERM, SIG_IGN);
1780         sigaddset(&set, SIGTERM);
1781         signal(SIGHUP, SIG_IGN);
1782         sigaddset(&set, SIGHUP);
1783         sigprocmask(SIG_UNBLOCK, &set, NULL);
1784         phup_disabled = 1;
1785         setintr = 0;            /* No interrupts after "logout" */
1786         /* Trap errors inside .logout */
1787         omark = cleanup_push_mark();
1788         if (setexit() == 0) {
1789             if (!(adrof(STRlogout)))
1790                 setcopy(STRlogout, STRnormal, VAR_READWRITE);
1791 #ifdef _PATH_DOTLOGOUT
1792             (void) srcfile(_PATH_DOTLOGOUT, 0, 0, NULL);
1793 #endif
1794             if (adrof(STRhome))
1795                 (void) srccat(varval(STRhome), STRsldtlogout);
1796 #ifdef TESLA
1797             do_logout = 1;
1798 #endif /* TESLA */
1799         }
1800         cleanup_pop_mark(omark);
1801     }
1802     exitstat();
1803 }
1804
1805 void
1806 exitstat(void)
1807 {
1808 #ifdef PROF
1809     _mcleanup();
1810 #endif
1811     /*
1812      * Note that if STATUS is corrupted (i.e. getn bombs) then error will exit
1813      * directly because we poke child here. Otherwise we might continue
1814      * unwarrantedly (sic).
1815      */
1816     child = 1;
1817
1818     xexit(getn(varval(STRstatus)));
1819 }
1820
1821 /*
1822  * in the event of a HUP we want to save the history
1823  */
1824 void
1825 phup(void)
1826 {
1827     if (loginsh) {
1828         setcopy(STRlogout, STRhangup, VAR_READWRITE);
1829 #ifdef _PATH_DOTLOGOUT
1830         (void) srcfile(_PATH_DOTLOGOUT, 0, 0, NULL);
1831 #endif
1832         if (adrof(STRhome))
1833             (void) srccat(varval(STRhome), STRsldtlogout);
1834     }
1835
1836     record();
1837
1838 #ifdef POSIXJOBS
1839     /*
1840      * We kill the last foreground process group. It then becomes
1841      * responsible to propagate the SIGHUP to its progeny.
1842      */
1843     {
1844         struct process *pp, *np;
1845
1846         for (pp = proclist.p_next; pp; pp = pp->p_next) {
1847             np = pp;
1848             /*
1849              * Find if this job is in the foreground. It could be that
1850              * the process leader has exited and the foreground flag
1851              * is cleared for it.
1852              */
1853             do
1854                 /*
1855                  * If a process is in the foreground we try to kill
1856                  * it's process group. If we succeed, then the
1857                  * whole job is gone. Otherwise we keep going...
1858                  * But avoid sending HUP to the shell again.
1859                  */
1860                 if (((np->p_flags & PFOREGND) != 0) && np->p_jobid != shpgrp) {
1861                     np->p_flags &= ~PHUP;
1862                     if (killpg(np->p_jobid, SIGHUP) != -1) {
1863                         /* In case the job was suspended... */
1864 #ifdef SIGCONT
1865                         (void) killpg(np->p_jobid, SIGCONT);
1866 #endif
1867                         break;
1868                     }
1869                 }
1870             while ((np = np->p_friends) != pp);
1871         }
1872     }
1873 #endif /* POSIXJOBS */
1874
1875     xexit(SIGHUP);
1876 }
1877
1878 static Char   *jobargv[2] = {STRjobs, 0};
1879
1880 /*
1881  * Catch an interrupt, e.g. during lexical input.
1882  * If we are an interactive shell, we reset the interrupt catch
1883  * immediately.  In any case we drain the shell output,
1884  * and finally go through the normal error mechanism, which
1885  * gets a chance to make the shell go away.
1886  */
1887 int just_signaled;              /* bugfix by Michael Bloom (mg@ttidca.TTI.COM) */
1888
1889 void
1890 pintr(void)
1891 {
1892     just_signaled = 1;
1893     pintr1(1);
1894 }
1895
1896 void
1897 pintr1(int wantnl)
1898 {
1899     if (setintr) {
1900         if (pjobs) {
1901             pjobs = 0;
1902             xputchar('\n');
1903             dojobs(jobargv, NULL);
1904             stderror(ERR_NAME | ERR_INTR);
1905         }
1906     }
1907     /* MH - handle interrupted completions specially */
1908     {
1909         if (InsideCompletion)
1910             stderror(ERR_SILENT);
1911     }
1912     /* JV - Make sure we shut off inputl */
1913     {
1914         (void) Cookedmode();
1915         GettingInput = 0;
1916         if (evalvec)
1917             doneinp = 1;
1918     }
1919     drainoline();
1920 #ifdef HAVE_GETPWENT
1921     (void) endpwent();
1922 #endif
1923
1924     /*
1925      * If we have an active "onintr" then we search for the label. Note that if
1926      * one does "onintr -" then we shan't be interruptible so we needn't worry
1927      * about that here.
1928      */
1929     if (gointr) {
1930         gotolab(gointr);
1931         reset();
1932     }
1933     else if (intty && wantnl) {
1934         if (editing) {
1935             /*
1936              * If we are editing a multi-line input command, and move to
1937              * the beginning of the line, we don't want to trash it when
1938              * we hit ^C
1939              */
1940             PastBottom();
1941             ClearLines();
1942             ClearDisp();
1943         }
1944         else {
1945             /* xputchar('\n'); *//* Some like this, others don't */
1946             (void) putraw('\r');
1947             (void) putraw('\n');
1948         }
1949     }
1950     stderror(ERR_SILENT);
1951 }
1952
1953 /*
1954  * Process is the main driving routine for the shell.
1955  * It runs all command processing, except for those within { ... }
1956  * in expressions (which is run by a routine evalav in sh.exp.c which
1957  * is a stripped down process), and `...` evaluation which is run
1958  * also by a subset of this code in sh.glob.c in the routine backeval.
1959  *
1960  * The code here is a little strange because part of it is interruptible
1961  * and hence freeing of structures appears to occur when none is necessary
1962  * if this is ignored.
1963  *
1964  * Note that if catch is not set then we will unwind on any error.
1965  * If an end-of-file occurs, we return.
1966  */
1967 void
1968 process(int catch)
1969 {
1970     jmp_buf_t osetexit;
1971     /* PWP: This might get nuked by longjmp so don't make it a register var */
1972     size_t omark;
1973     volatile int didexitset = 0;
1974
1975     getexit(osetexit);
1976     omark = cleanup_push_mark();
1977     for (;;) {
1978         struct command *t;
1979         int hadhist, old_pintr_disabled;
1980
1981         (void)setexit();
1982         if (didexitset == 0) {
1983             exitset++;
1984             didexitset++;
1985         }
1986         pendjob();
1987
1988         justpr = enterhist;     /* execute if not entering history */
1989
1990         if (haderr) {
1991             if (!catch) {
1992                 /* unwind */
1993                 doneinp = 0;
1994                 cleanup_pop_mark(omark);
1995                 resexit(osetexit);
1996                 reset();
1997             }
1998             haderr = 0;
1999             /*
2000              * Every error is eventually caught here or the shell dies.  It is
2001              * at this point that we clean up any left-over open files, by
2002              * closing all but a fixed number of pre-defined files.  Thus
2003              * routines don't have to worry about leaving files open due to
2004              * deeper errors... they will get closed here.
2005              */
2006             closem();
2007             continue;
2008         }
2009         if (doneinp) {
2010             doneinp = 0;
2011             break;
2012         }
2013         if (chkstop)
2014             chkstop--;
2015         if (neednote)
2016             pnote();
2017         if (intty && prompt && evalvec == 0) {
2018             just_signaled = 0;
2019             mailchk();
2020             /*
2021              * Watch for logins/logouts. Next is scheduled commands stored
2022              * previously using "sched." Then execute periodic commands.
2023              * Following that, the prompt precmd is run.
2024              */
2025 #ifndef HAVENOUTMP
2026             watch_login(0);
2027 #endif /* !HAVENOUTMP */
2028             sched_run();
2029             period_cmd();
2030             precmd();
2031             /*
2032              * If we are at the end of the input buffer then we are going to
2033              * read fresh stuff. Otherwise, we are rereading input and don't
2034              * need or want to prompt.
2035              */
2036             if (fseekp == feobp && aret == TCSH_F_SEEK)
2037                 printprompt(0, NULL);
2038             flush();
2039             setalarm(1);
2040         }
2041         if (seterr) {
2042             xfree(seterr);
2043             seterr = NULL;
2044         }
2045
2046         /*
2047          * Interruptible during interactive reads
2048          */
2049         if (setintr)
2050             pintr_push_enable(&old_pintr_disabled);
2051         hadhist = lex(&paraml);
2052         if (setintr)
2053             cleanup_until(&old_pintr_disabled);
2054         cleanup_push(&paraml, lex_cleanup);
2055
2056         /*
2057          * Echo not only on VERBOSE, but also with history expansion. If there
2058          * is a lexical error then we forego history echo.
2059          * Do not echo if we're only entering history (source -h).
2060          */
2061         if ((hadhist && !seterr && intty && !tellwhat && !Expand && !whyles) ||
2062             (!enterhist && adrof(STRverbose)))
2063         {
2064             int odidfds = didfds;
2065             haderr = 1;
2066             didfds = 0;
2067             prlex(&paraml);
2068             flush();
2069             haderr = 0;
2070             didfds = odidfds;
2071         }
2072         (void) alarm(0);        /* Autologout OFF */
2073         alrmcatch_disabled = 1;
2074
2075         /*
2076          * Save input text on the history list if reading in old history, or it
2077          * is from the terminal at the top level and not in a loop.
2078          *
2079          * PWP: entry of items in the history list while in a while loop is done
2080          * elsewhere...
2081          */
2082         if (enterhist || (catch && intty && !whyles && !tellwhat && !arun))
2083             savehist(&paraml, enterhist > 1);
2084
2085         if (Expand && seterr)
2086             Expand = 0;
2087
2088         /*
2089          * Print lexical error messages, except when sourcing history lists.
2090          */
2091         if (!enterhist && seterr)
2092             stderror(ERR_OLD);
2093
2094         /*
2095          * If had a history command :p modifier then this is as far as we
2096          * should go
2097          */
2098         if (justpr)
2099             goto cmd_done;
2100
2101         /*
2102          * If had a tellwhat from twenex() then do
2103          */
2104         if (tellwhat) {
2105             (void) tellmewhat(&paraml, NULL);
2106             goto cmd_done;
2107         }
2108
2109         alias(&paraml);
2110
2111 #ifdef BSDJOBS
2112         /*
2113          * If we are interactive, try to continue jobs that we have stopped
2114          */
2115         if (prompt)
2116             continue_jobs(&paraml);
2117 #endif                          /* BSDJOBS */
2118
2119         /*
2120          * Check to see if the user typed "rm * .o" or something
2121          */
2122         if (prompt)
2123             rmstar(&paraml);
2124         /*
2125          * Parse the words of the input into a parse tree.
2126          */
2127         t = syntax(paraml.next, &paraml, 0);
2128         /*
2129          * We cannot cleanup push here, because cd /blah; echo foo
2130          * would rewind t on the chdir error, and free the rest of the command
2131          */
2132         if (seterr) {
2133             freesyn(t);
2134             stderror(ERR_OLD);
2135         }
2136
2137         postcmd();
2138         /*
2139          * Execute the parse tree From: Michael Schroeder
2140          * <mlschroe@immd4.informatik.uni-erlangen.de> was execute(t, tpgrp);
2141          */
2142         execute(t, (tpgrp > 0 ? tpgrp : -1), NULL, NULL, TRUE);
2143         freesyn(t);
2144
2145         /*
2146          * Made it!
2147          */
2148 #ifdef SIG_WINDOW
2149         if (windowchg || (catch && intty && !whyles && !tellwhat)) {
2150             (void) check_window_size(0);        /* for window systems */
2151         }
2152 #endif /* SIG_WINDOW */
2153         setcopy(STR_, InputBuf, VAR_READWRITE | VAR_NOGLOB);
2154     cmd_done:
2155         if (cleanup_reset())
2156             cleanup_until(&paraml);
2157         else
2158             haderr = 1;
2159     }
2160     cleanup_pop_mark(omark);
2161     resexit(osetexit);
2162     exitset--;
2163     handle_pending_signals();
2164 }
2165
2166 /*ARGSUSED*/
2167 void
2168 dosource(Char **t, struct command *c)
2169 {
2170     Char *f;
2171     int    hflg = 0;
2172     char *file;
2173
2174     USE(c);
2175     t++;
2176     if (*t && eq(*t, STRmh)) {
2177         if (*++t == NULL)
2178             stderror(ERR_NAME | ERR_HFLAG);
2179         hflg++;
2180     }
2181     else if (*t && eq(*t, STRmm)) {
2182         if (*++t == NULL)
2183             stderror(ERR_NAME | ERR_MFLAG);
2184         hflg = 2;
2185     }
2186
2187     f = globone(*t++, G_ERROR);
2188     file = strsave(short2str(f));
2189     cleanup_push(file, xfree);
2190     xfree(f);
2191     t = glob_all_or_error(t);
2192     cleanup_push(t, blk_cleanup);
2193     if ((!srcfile(file, 0, hflg, t)) && (!hflg) && (!bequiet))
2194         stderror(ERR_SYSTEM, file, strerror(errno));
2195     cleanup_until(file);
2196 }
2197
2198 /*
2199  * Check for mail.
2200  * If we are a login shell, then we don't want to tell
2201  * about any mail file unless its been modified
2202  * after the time we started.
2203  * This prevents us from telling the user things he already
2204  * knows, since the login program insists on saying
2205  * "You have mail."
2206  */
2207
2208 /*
2209  * The AMS version.
2210  * This version checks if the file is a directory, and if so,
2211  * tells you the number of files in it, otherwise do the old thang.
2212  * The magic "+1" in the time calculation is to compensate for
2213  * an AFS bug where directory mtimes are set to 1 second in
2214  * the future.
2215  */
2216
2217 static void
2218 mailchk(void)
2219 {
2220     struct varent *v;
2221     Char **vp;
2222     time_t  t;
2223     int     intvl, cnt;
2224     struct stat stb;
2225     int    new;
2226
2227     v = adrof(STRmail);
2228     if (v == NULL || v->vec == NULL)
2229         return;
2230     (void) time(&t);
2231     vp = v->vec;
2232     cnt = blklen(vp);
2233     intvl = (cnt && number(*vp)) ? (--cnt, getn(*vp++)) : MAILINTVL;
2234     if (intvl < 1)
2235         intvl = 1;
2236     if (chktim + intvl > t)
2237         return;
2238     for (; *vp; vp++) {
2239         char *filename = short2str(*vp);
2240         char *mboxdir = filename;
2241
2242         if (stat(filename, &stb) < 0)
2243             continue;
2244 #if defined(BSDTIMES) || defined(_SEQUENT_)
2245         new = stb.st_mtime > time0.tv_sec;
2246 #else
2247         new = stb.st_mtime > seconds0;
2248 #endif
2249         if (S_ISDIR(stb.st_mode)) {
2250             DIR *mailbox;
2251             int mailcount = 0;
2252             char *tempfilename;
2253             struct stat stc;
2254
2255             tempfilename = xasprintf("%s/new", filename);
2256
2257             if (stat(tempfilename, &stc) != -1 && S_ISDIR(stc.st_mode)) {
2258                 /*
2259                  * "filename/new" exists and is a directory; you are
2260                  * using Qmail.
2261                  */
2262                 stb = stc;
2263 #if defined(BSDTIMES) || defined(_SEQUENT_)
2264                 new = stb.st_mtime > time0.tv_sec;
2265 #else
2266                 new = stb.st_mtime > seconds0;
2267 #endif
2268                 mboxdir = tempfilename;
2269             }
2270
2271             if (stb.st_mtime <= chktim + 1 || (loginsh && !new)) {
2272                 xfree(tempfilename);
2273                 continue;
2274             }
2275
2276             mailbox = opendir(mboxdir);
2277             xfree(tempfilename);
2278             if (mailbox == NULL)
2279                 continue;
2280
2281             /* skip . and .. */
2282             if (!readdir(mailbox) || !readdir(mailbox)) {
2283                 (void)closedir(mailbox);
2284                 continue;
2285             }
2286
2287             while (readdir(mailbox))
2288                 mailcount++;
2289
2290             (void)closedir(mailbox);
2291             if (mailcount == 0)
2292                 continue;
2293
2294             if (cnt == 1)
2295                 xprintf(CGETS(11, 3, "You have %d mail messages.\n"),
2296                         mailcount);
2297             else
2298                 xprintf(CGETS(11, 4, "You have %d mail messages in %s.\n"),
2299                         mailcount, filename);
2300         }
2301         else {
2302             char *type;
2303
2304             if (stb.st_size == 0 || stb.st_atime >= stb.st_mtime ||
2305                 (stb.st_atime <= chktim && stb.st_mtime <= chktim) ||
2306                 (loginsh && !new))
2307                 continue;
2308             type = strsave(new ? CGETS(11, 6, "new ") : "");
2309             cleanup_push(type, xfree);
2310             if (cnt == 1)
2311                 xprintf(CGETS(11, 5, "You have %smail.\n"), type);
2312             else
2313                 xprintf(CGETS(11, 7, "You have %smail in %s.\n"), type, filename);
2314             cleanup_until(type);
2315         }
2316     }
2317     chktim = t;
2318 }
2319
2320 /*
2321  * Extract a home directory from the password file
2322  * The argument points to a buffer where the name of the
2323  * user whose home directory is sought is currently.
2324  * We return home directory of the user, or NULL.
2325  */
2326 Char *
2327 gethdir(const Char *home)
2328 {
2329     Char   *h;
2330
2331     /*
2332      * Is it us?
2333      */
2334     if (*home == '\0') {
2335         if ((h = varval(STRhome)) != STRNULL)
2336             return Strsave(h);
2337         else
2338             return NULL;
2339     }
2340
2341     /*
2342      * Look in the cache
2343      */
2344     if ((h = gettilde(home)) == NULL)
2345         return NULL;
2346     else
2347         return Strsave(h);
2348 }
2349
2350 /*
2351  * Move the initial descriptors to their eventual
2352  * resting places, closing all other units.
2353  */
2354 void
2355 initdesc(void)
2356 {
2357 #ifdef NLS_BUGS
2358 #ifdef NLS_CATALOGS
2359     nlsclose();
2360 #endif /* NLS_CATALOGS */
2361 #endif /* NLS_BUGS */
2362
2363
2364     didfds = 0;                 /* 0, 1, 2 aren't set up */
2365     (void) close_on_exec(SHIN = dcopy(0, FSHIN), 1);
2366     (void) close_on_exec(SHOUT = dcopy(1, FSHOUT), 1);
2367     (void) close_on_exec(SHDIAG = dcopy(2, FSHDIAG), 1);
2368     (void) close_on_exec(OLDSTD = dcopy(SHIN, FOLDSTD), 1);
2369 #ifndef CLOSE_ON_EXEC
2370     didcch = 0;                 /* Havent closed for child */
2371 #endif /* CLOSE_ON_EXEC */
2372     if (SHDIAG >= 0)
2373         isdiagatty = isatty(SHDIAG);
2374     else
2375         isdiagatty = 0;
2376     if (SHDIAG >= 0)
2377         isoutatty = isatty(SHOUT);
2378     else
2379         isoutatty = 0;
2380 #ifdef NLS_BUGS
2381 #ifdef NLS_CATALOGS
2382     nlsinit();
2383 #endif /* NLS_CATALOGS */
2384 #endif /* NLS_BUGS */
2385 }
2386
2387
2388 void
2389 #ifdef PROF
2390 done(int i)
2391 #else
2392 xexit(int i)
2393 #endif
2394 {
2395 #ifdef TESLA
2396     if (loginsh && do_logout) {
2397         /* this is to send hangup signal to the develcon */
2398         /* we toggle DTR. clear dtr - sleep 1 - set dtr */
2399         /* ioctl will return ENOTTY for pty's but we ignore it   */
2400         /* exitstat will run after disconnect */
2401         /* we sleep for 2 seconds to let things happen in */
2402         /* .logout and rechist() */
2403 #ifdef TIOCCDTR
2404         (void) sleep(2);
2405         (void) ioctl(FSHTTY, TIOCCDTR, NULL);
2406         (void) sleep(1);
2407         (void) ioctl(FSHTTY, TIOCSDTR, NULL);
2408 #endif /* TIOCCDTR */
2409     }
2410 #endif /* TESLA */
2411
2412     {
2413         struct process *pp, *np;
2414         pid_t mypid = getpid();
2415         /* Kill all processes marked for hup'ing */
2416         for (pp = proclist.p_next; pp; pp = pp->p_next) {
2417             np = pp;
2418             do
2419                 if ((np->p_flags & PHUP) && np->p_jobid != shpgrp &&
2420                     np->p_parentid == mypid) {
2421                     if (killpg(np->p_jobid, SIGHUP) != -1) {
2422                         /* In case the job was suspended... */
2423 #ifdef SIGCONT
2424                         (void) killpg(np->p_jobid, SIGCONT);
2425 #endif
2426                         break;
2427                     }
2428                 }
2429             while ((np = np->p_friends) != pp);
2430         }
2431     }
2432     untty();
2433 #ifdef NLS_CATALOGS
2434     /*
2435      * We need to call catclose, because SVR4 leaves symlinks behind otherwise
2436      * in the catalog directories. We cannot close on a vforked() child,
2437      * because messages will stop working on the parent too.
2438      */
2439     if (child == 0)
2440         nlsclose();
2441 #endif /* NLS_CATALOGS */
2442 #ifdef WINNT_NATIVE
2443     nt_cleanup();
2444 #endif /* WINNT_NATIVE */
2445     _exit(i);
2446 }
2447
2448 #ifndef _PATH_DEFPATH
2449 static Char **
2450 defaultpath(void)
2451 {
2452     char   *ptr;
2453     Char  **blk, **blkp;
2454     struct stat stb;
2455
2456     blkp = blk = xmalloc(sizeof(Char *) * 10);
2457
2458 #ifndef NODOT
2459 # ifndef DOTLAST
2460     *blkp++ = Strsave(STRdot);
2461 # endif
2462 #endif
2463
2464 #define DIRAPPEND(a)  \
2465         if (stat(ptr = a, &stb) == 0 && S_ISDIR(stb.st_mode)) \
2466                 *blkp++ = SAVE(ptr)
2467
2468 #ifdef _PATH_LOCAL
2469     DIRAPPEND(_PATH_LOCAL);
2470 #endif
2471
2472 #ifdef _PATH_USRUCB
2473     DIRAPPEND(_PATH_USRUCB);
2474 #endif
2475
2476 #ifdef _PATH_USRBSD
2477     DIRAPPEND(_PATH_USRBSD);
2478 #endif
2479
2480 #ifdef _PATH_BIN
2481     DIRAPPEND(_PATH_BIN);
2482 #endif
2483
2484 #ifdef _PATH_USRBIN
2485     DIRAPPEND(_PATH_USRBIN);
2486 #endif
2487
2488 #undef DIRAPPEND
2489
2490 #ifndef NODOT
2491 # ifdef DOTLAST
2492     *blkp++ = Strsave(STRdot);
2493 # endif
2494 #endif
2495     *blkp = NULL;
2496     return (blk);
2497 }
2498 #endif
2499
2500 static void
2501 record(void)
2502 {
2503     if (!fast) {
2504         recdirs(NULL, adrof(STRsavedirs) != NULL);
2505         rechist(NULL, adrof(STRsavehist) != NULL);
2506     }
2507     displayHistStats("Exiting");        /* no-op unless DEBUG_HIST */
2508 }
2509
2510 /*
2511  * Grab the tty repeatedly, and give up if we are not in the correct
2512  * tty process group.
2513  */
2514 int
2515 grabpgrp(int fd, pid_t desired)
2516 {
2517     struct sigaction old;
2518     pid_t pgrp;
2519     size_t i;
2520
2521     for (i = 0; i < 100; i++) {
2522         if ((pgrp = tcgetpgrp(fd)) == -1)
2523             return -1;
2524         if (pgrp == desired)
2525             return 0;
2526         (void)sigaction(SIGTTIN, NULL, &old);
2527         (void)signal(SIGTTIN, SIG_DFL);
2528         (void)kill(0, SIGTTIN);
2529         (void)sigaction(SIGTTIN, &old, NULL);
2530     }
2531     errno = EPERM;
2532     return -1;
2533 }