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