xref: /original-bsd/bin/csh/csh.c (revision fb2be964)
1 /*-
2  * Copyright (c) 1980, 1991, 1993
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * %sccs.include.redist.c%
6  */
7 
8 #ifndef lint
9 static char copyright[] =
10 "@(#) Copyright (c) 1980, 1991, 1993\n\
11 	The Regents of the University of California.  All rights reserved.\n";
12 #endif /* not lint */
13 
14 #ifndef lint
15 static char sccsid[] = "@(#)csh.c	8.4 (Berkeley) 04/29/95";
16 #endif /* not lint */
17 
18 #include <sys/types.h>
19 #include <sys/ioctl.h>
20 #include <sys/stat.h>
21 #include <fcntl.h>
22 #include <errno.h>
23 #include <pwd.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <locale.h>
27 #include <unistd.h>
28 #include <vis.h>
29 #if __STDC__
30 # include <stdarg.h>
31 #else
32 # include <varargs.h>
33 #endif
34 
35 #include "csh.h"
36 #include "proc.h"
37 #include "extern.h"
38 #include "pathnames.h"
39 
40 extern bool MapsAreInited;
41 extern bool NLSMapsAreInited;
42 
43 /*
44  * C Shell
45  *
46  * Bill Joy, UC Berkeley, California, USA
47  * October 1978, May 1980
48  *
49  * Jim Kulp, IIASA, Laxenburg, Austria
50  * April 1980
51  *
52  * Christos Zoulas, Cornell University
53  * June, 1991
54  */
55 
56 Char   *dumphist[] = {STRhistory, STRmh, 0, 0};
57 Char   *loadhist[] = {STRsource, STRmh, STRtildothist, 0};
58 
59 int     nofile = 0;
60 bool    reenter = 0;
61 bool    nverbose = 0;
62 bool    nexececho = 0;
63 bool    quitit = 0;
64 bool    fast = 0;
65 bool    batch = 0;
66 bool    mflag = 0;
67 bool    prompt = 1;
68 bool    enterhist = 0;
69 bool    tellwhat = 0;
70 
71 extern char **environ;
72 
73 static int	readf __P((void *, char *, int));
74 static fpos_t	seekf __P((void *, fpos_t, int));
75 static int	writef __P((void *, const char *, int));
76 static int	closef __P((void *));
77 static int	srccat __P((Char *, Char *));
78 static int	srcfile __P((char *, bool, bool));
79 static void	phup __P((int));
80 static void	srcunit __P((int, bool, bool));
81 static void	mailchk __P((void));
82 static Char   **defaultpath __P((void));
83 
84 int
main(argc,argv)85 main(argc, argv)
86     int     argc;
87     char  **argv;
88 {
89     register Char *cp;
90     register char *tcp;
91     register int f;
92     register char **tempv;
93     struct sigaction oact;
94     sigset_t sigset;
95 
96     cshin = stdin;
97     cshout = stdout;
98     csherr = stderr;
99 
100     settimes();			/* Immed. estab. timing base */
101 
102     /*
103      * Initialize non constant strings
104      */
105 #ifdef _PATH_BSHELL
106     STR_BSHELL = SAVE(_PATH_BSHELL);
107 #endif
108 #ifdef _PATH_CSHELL
109     STR_SHELLPATH = SAVE(_PATH_CSHELL);
110 #endif
111     STR_environ = blk2short(environ);
112     environ = short2blk(STR_environ);	/* So that we can free it */
113     STR_WORD_CHARS = SAVE(WORD_CHARS);
114 
115     HIST = '!';
116     HISTSUB = '^';
117     word_chars = STR_WORD_CHARS;
118 
119     tempv = argv;
120     if (eq(str2short(tempv[0]), STRaout))	/* A.out's are quittable */
121 	quitit = 1;
122     uid = getuid();
123     gid = getgid();
124     euid = geteuid();
125     egid = getegid();
126     /*
127      * We are a login shell if: 1. we were invoked as -<something> and we had
128      * no arguments 2. or we were invoked only with the -l flag
129      */
130     loginsh = (**tempv == '-' && argc == 1) ||
131 	(argc == 2 && tempv[1][0] == '-' && tempv[1][1] == 'l' &&
132 	 tempv[1][2] == '\0');
133 
134     if (loginsh && **tempv != '-') {
135 	/*
136 	 * Mangle the argv space
137 	 */
138 	tempv[1][0] = '\0';
139 	tempv[1][1] = '\0';
140 	tempv[1] = NULL;
141 	for (tcp = *tempv; *tcp++;)
142 	    continue;
143 	for (tcp--; tcp >= *tempv; tcp--)
144 	    tcp[1] = tcp[0];
145 	*++tcp = '-';
146 	argc--;
147     }
148     if (loginsh)
149 	(void) time(&chktim);
150 
151     AsciiOnly = 1;
152 #ifdef NLS
153     (void) setlocale(LC_ALL, "");
154     {
155 	int     k;
156 
157 	for (k = 0200; k <= 0377 && !Isprint(k); k++)
158 	    continue;
159 	AsciiOnly = k > 0377;
160     }
161 #else
162     AsciiOnly = getenv("LANG") == NULL && getenv("LC_CTYPE") == NULL;
163 #endif				/* NLS */
164 
165     /*
166      * Move the descriptors to safe places. The variable didfds is 0 while we
167      * have only FSH* to work with. When didfds is true, we have 0,1,2 and
168      * prefer to use these.
169      */
170     initdesc();
171     /*
172      * XXX: This is to keep programs that use stdio happy.
173      *	    what we really want is freunopen() ....
174      *	    Closing cshin cshout and csherr (which are really stdin stdout
175      *	    and stderr at this point and then reopening them in the same order
176      *	    gives us again stdin == cshin stdout == cshout and stderr == csherr.
177      *	    If that was not the case builtins like printf that use stdio
178      *	    would break. But in any case we could fix that with memcpy and
179      *	    a bit of pointer manipulation...
180      *	    Fortunately this is not needed under the current implementation
181      *	    of stdio.
182      */
183     (void) fclose(cshin);
184     (void) fclose(cshout);
185     (void) fclose(csherr);
186     if (!(cshin  = funopen((void *) &SHIN,  readf, writef, seekf, closef)))
187 	exit(1);
188     if (!(cshout = funopen((void *) &SHOUT, readf, writef, seekf, closef)))
189 	exit(1);
190     if (!(csherr = funopen((void *) &SHERR, readf, writef, seekf, closef)))
191 	exit(1);
192     (void) setvbuf(cshin,  NULL, _IOLBF, 0);
193     (void) setvbuf(cshout, NULL, _IOLBF, 0);
194     (void) setvbuf(csherr, NULL, _IOLBF, 0);
195 
196     /*
197      * Initialize the shell variables. ARGV and PROMPT are initialized later.
198      * STATUS is also munged in several places. CHILD is munged when
199      * forking/waiting
200      */
201     set(STRstatus, Strsave(STR0));
202 
203     if ((tcp = getenv("HOME")) != NULL)
204 	cp = SAVE(tcp);
205     else
206 	cp = NULL;
207 
208     if (cp == NULL)
209 	fast = 1;		/* No home -> can't read scripts */
210     else
211 	set(STRhome, cp);
212     dinit(cp);			/* dinit thinks that HOME == cwd in a login
213 				 * shell */
214     /*
215      * Grab other useful things from the environment. Should we grab
216      * everything??
217      */
218     if ((tcp = getenv("LOGNAME")) != NULL ||
219 	(tcp = getenv("USER")) != NULL)
220 	set(STRuser, SAVE(tcp));
221     if ((tcp = getenv("TERM")) != NULL)
222 	set(STRterm, SAVE(tcp));
223 
224     /*
225      * Re-initialize path if set in environment
226      */
227     if ((tcp = getenv("PATH")) == NULL)
228 	set1(STRpath, defaultpath(), &shvhed);
229     else
230 	importpath(SAVE(tcp));
231 
232     set(STRshell, Strsave(STR_SHELLPATH));
233 
234     doldol = putn((int) getpid());	/* For $$ */
235     shtemp = Strspl(STRtmpsh, doldol);	/* For << */
236 
237     /*
238      * Record the interrupt states from the parent process. If the parent is
239      * non-interruptible our hand must be forced or we (and our children) won't
240      * be either. Our children inherit termination from our parent. We catch it
241      * only if we are the login shell.
242      */
243     /* parents interruptibility */
244     (void) sigaction(SIGINT, NULL, &oact);
245     parintr = oact.sa_handler;
246     (void) sigaction(SIGTERM, NULL, &oact);
247     parterm = oact.sa_handler;
248 
249     (void) signal(SIGHUP, phup);	/* exit processing on HUP */
250     (void) signal(SIGXCPU, phup);	/* ...and on XCPU */
251     (void) signal(SIGXFSZ, phup);	/* ...and on XFSZ */
252 
253     /*
254      * Process the arguments.
255      *
256      * Note that processing of -v/-x is actually delayed till after script
257      * processing.
258      *
259      * We set the first character of our name to be '-' if we are a shell
260      * running interruptible commands.  Many programs which examine ps'es
261      * use this to filter such shells out.
262      */
263     argc--, tempv++;
264     while (argc > 0 && (tcp = tempv[0])[0] == '-' && *++tcp != '\0' && !batch) {
265 	do
266 	    switch (*tcp++) {
267 
268 	    case 0:		/* -	Interruptible, no prompt */
269 		prompt = 0;
270 		setintr = 1;
271 		nofile = 1;
272 		break;
273 
274 	    case 'b':		/* -b	Next arg is input file */
275 		batch = 1;
276 		break;
277 
278 	    case 'c':		/* -c	Command input from arg */
279 		if (argc == 1)
280 		    xexit(0);
281 		argc--, tempv++;
282 		arginp = SAVE(tempv[0]);
283 		prompt = 0;
284 		nofile = 1;
285 		break;
286 
287 	    case 'e':		/* -e	Exit on any error */
288 		exiterr = 1;
289 		break;
290 
291 	    case 'f':		/* -f	Fast start */
292 		fast = 1;
293 		break;
294 
295 	    case 'i':		/* -i	Interactive, even if !intty */
296 		intact = 1;
297 		nofile = 1;
298 		break;
299 
300 	    case 'm':		/* -m	read .cshrc (from su) */
301 		mflag = 1;
302 		break;
303 
304 	    case 'n':		/* -n	Don't execute */
305 		noexec = 1;
306 		break;
307 
308 	    case 'q':		/* -q	(Undoc'd) ... die on quit */
309 		quitit = 1;
310 		break;
311 
312 	    case 's':		/* -s	Read from std input */
313 		nofile = 1;
314 		break;
315 
316 	    case 't':		/* -t	Read one line from input */
317 		onelflg = 2;
318 		prompt = 0;
319 		nofile = 1;
320 		break;
321 
322 	    case 'v':		/* -v	Echo hist expanded input */
323 		nverbose = 1;	/* ... later */
324 		break;
325 
326 	    case 'x':		/* -x	Echo just before execution */
327 		nexececho = 1;	/* ... later */
328 		break;
329 
330 	    case 'V':		/* -V	Echo hist expanded input */
331 		setNS(STRverbose);	/* NOW! */
332 		break;
333 
334 	    case 'X':		/* -X	Echo just before execution */
335 		setNS(STRecho);	/* NOW! */
336 		break;
337 
338 	} while (*tcp);
339 	tempv++, argc--;
340     }
341 
342     if (quitit)			/* With all due haste, for debugging */
343 	(void) signal(SIGQUIT, SIG_DFL);
344 
345     /*
346      * Unless prevented by -, -c, -i, -s, or -t, if there are remaining
347      * arguments the first of them is the name of a shell file from which to
348      * read commands.
349      */
350     if (nofile == 0 && argc > 0) {
351 	nofile = open(tempv[0], O_RDONLY);
352 	if (nofile < 0) {
353 	    child = 1;		/* So this doesn't return */
354 	    stderror(ERR_SYSTEM, tempv[0], strerror(errno));
355 	}
356 	ffile = SAVE(tempv[0]);
357 	/*
358 	 * Replace FSHIN. Handle /dev/std{in,out,err} specially
359 	 * since once they are closed we cannot open them again.
360 	 * In that case we use our own saved descriptors
361 	 */
362 	if ((SHIN = dmove(nofile, FSHIN)) < 0)
363 	    switch(nofile) {
364 	    case 0:
365 		SHIN = FSHIN;
366 		break;
367 	    case 1:
368 		SHIN = FSHOUT;
369 		break;
370 	    case 2:
371 		SHIN = FSHERR;
372 		break;
373 	    default:
374 		stderror(ERR_SYSTEM, tempv[0], strerror(errno));
375 		break;
376 	    }
377 	(void) ioctl(SHIN, FIOCLEX, NULL);
378 	prompt = 0;
379 	 /* argc not used any more */ tempv++;
380     }
381 
382     intty = isatty(SHIN);
383     intty |= intact;
384     if (intty || (intact && isatty(SHOUT))) {
385 	if (!batch && (uid != euid || gid != egid)) {
386 	    errno = EACCES;
387 	    child = 1;		/* So this doesn't return */
388 	    stderror(ERR_SYSTEM, "csh", strerror(errno));
389 	}
390     }
391     /*
392      * Decide whether we should play with signals or not. If we are explicitly
393      * told (via -i, or -) or we are a login shell (arg0 starts with -) or the
394      * input and output are both the ttys("csh", or "csh</dev/ttyx>/dev/ttyx")
395      * Note that in only the login shell is it likely that parent may have set
396      * signals to be ignored
397      */
398     if (loginsh || intact || (intty && isatty(SHOUT)))
399 	setintr = 1;
400     settell();
401     /*
402      * Save the remaining arguments in argv.
403      */
404     setq(STRargv, blk2short(tempv), &shvhed);
405 
406     /*
407      * Set up the prompt.
408      */
409     if (prompt) {
410 	set(STRprompt, Strsave(uid == 0 ? STRsymhash : STRsymcent));
411 	/* that's a meta-questionmark */
412 	set(STRprompt2, Strsave(STRmquestion));
413     }
414 
415     /*
416      * If we are an interactive shell, then start fiddling with the signals;
417      * this is a tricky game.
418      */
419     shpgrp = getpgrp();
420     opgrp = tpgrp = -1;
421     if (setintr) {
422 	**argv = '-';
423 	if (!quitit)		/* Wary! */
424 	    (void) signal(SIGQUIT, SIG_IGN);
425 	(void) signal(SIGINT, pintr);
426 	sigemptyset(&sigset);
427 	sigaddset(&sigset, SIGINT);
428 	sigprocmask(SIG_BLOCK, &sigset, NULL);
429 	(void) signal(SIGTERM, SIG_IGN);
430 	if (quitit == 0 && arginp == 0) {
431 	    (void) signal(SIGTSTP, SIG_IGN);
432 	    (void) signal(SIGTTIN, SIG_IGN);
433 	    (void) signal(SIGTTOU, SIG_IGN);
434 	    /*
435 	     * Wait till in foreground, in case someone stupidly runs csh &
436 	     * dont want to try to grab away the tty.
437 	     */
438 	    if (isatty(FSHERR))
439 		f = FSHERR;
440 	    else if (isatty(FSHOUT))
441 		f = FSHOUT;
442 	    else if (isatty(OLDSTD))
443 		f = OLDSTD;
444 	    else
445 		f = -1;
446     retry:
447 	    if ((tpgrp = tcgetpgrp(f)) != -1) {
448 		if (tpgrp != shpgrp) {
449 		    sig_t old = signal(SIGTTIN, SIG_DFL);
450 		    (void) kill(0, SIGTTIN);
451 		    (void) signal(SIGTTIN, old);
452 		    goto retry;
453 		}
454 		opgrp = shpgrp;
455 		shpgrp = getpid();
456 		tpgrp = shpgrp;
457 		/*
458 		 * Setpgid will fail if we are a session leader and
459 		 * mypid == mypgrp (POSIX 4.3.3)
460 		 */
461 		if (opgrp != shpgrp)
462 		    if (setpgid(0, shpgrp) == -1)
463 			goto notty;
464 		/*
465 		 * We do that after we set our process group, to make sure
466 		 * that the process group belongs to a process in the same
467 		 * session as the tty (our process and our group) (POSIX 7.2.4)
468 		 */
469 		if (tcsetpgrp(f, shpgrp) == -1)
470 		    goto notty;
471 		(void) ioctl(dcopy(f, FSHTTY), FIOCLEX, NULL);
472 	    }
473 	    if (tpgrp == -1) {
474 notty:
475 		(void) fprintf(csherr, "Warning: no access to tty (%s).\n",
476 			       strerror(errno));
477 		(void) fprintf(csherr, "Thus no job control in this shell.\n");
478 	    }
479 	}
480     }
481     if ((setintr == 0) && (parintr == SIG_DFL))
482 	setintr = 1;
483     (void) signal(SIGCHLD, pchild);	/* while signals not ready */
484 
485     /*
486      * Set an exit here in case of an interrupt or error reading the shell
487      * start-up scripts.
488      */
489     reenter = setexit();	/* PWP */
490     haderr = 0;			/* In case second time through */
491     if (!fast && reenter == 0) {
492 	/* Will have value(STRhome) here because set fast if don't */
493 	{
494 	    int     osetintr = setintr;
495 	    sig_t   oparintr = parintr;
496 	    sigset_t osigset;
497 
498 	    sigemptyset(&sigset);
499 	    sigaddset(&sigset, SIGINT);
500 	    sigprocmask(SIG_BLOCK, &sigset, &osigset);
501 
502 	    setintr = 0;
503 	    parintr = SIG_IGN;	/* Disable onintr */
504 #ifdef _PATH_DOTCSHRC
505 	    (void) srcfile(_PATH_DOTCSHRC, 0, 0);
506 #endif
507 	    if (!fast && !arginp && !onelflg)
508 		dohash(NULL, NULL);
509 #ifdef _PATH_DOTLOGIN
510 	    if (loginsh)
511 		(void) srcfile(_PATH_DOTLOGIN, 0, 0);
512 #endif
513 	    sigprocmask(SIG_SETMASK, &osigset, NULL);
514 	    setintr = osetintr;
515 	    parintr = oparintr;
516 	}
517 	(void) srccat(value(STRhome), STRsldotcshrc);
518 
519 	if (!fast && !arginp && !onelflg && !havhash)
520 	    dohash(NULL, NULL);
521 	/*
522 	 * Source history before .login so that it is available in .login
523 	 */
524 	if ((cp = value(STRhistfile)) != STRNULL)
525 	    loadhist[2] = cp;
526 	dosource(loadhist, NULL);
527         if (loginsh)
528 	      (void) srccat(value(STRhome), STRsldotlogin);
529     }
530 
531     /*
532      * Now are ready for the -v and -x flags
533      */
534     if (nverbose)
535 	setNS(STRverbose);
536     if (nexececho)
537 	setNS(STRecho);
538 
539     /*
540      * All the rest of the world is inside this call. The argument to process
541      * indicates whether it should catch "error unwinds".  Thus if we are a
542      * interactive shell our call here will never return by being blown past on
543      * an error.
544      */
545     process(setintr);
546 
547     /*
548      * Mop-up.
549      */
550     if (intty) {
551 	if (loginsh) {
552 	    (void) fprintf(cshout, "logout\n");
553 	    (void) close(SHIN);
554 	    child = 1;
555 	    goodbye();
556 	}
557 	else {
558 	    (void) fprintf(cshout, "exit\n");
559 	}
560     }
561     rechist();
562     exitstat();
563     return (0);
564 }
565 
566 void
untty()567 untty()
568 {
569     if (tpgrp > 0) {
570 	(void) setpgid(0, opgrp);
571 	(void) tcsetpgrp(FSHTTY, opgrp);
572     }
573 }
574 
575 void
importpath(cp)576 importpath(cp)
577     Char   *cp;
578 {
579     register int i = 0;
580     register Char *dp;
581     register Char **pv;
582     int     c;
583 
584     for (dp = cp; *dp; dp++)
585 	if (*dp == ':')
586 	    i++;
587     /*
588      * i+2 where i is the number of colons in the path. There are i+1
589      * directories in the path plus we need room for a zero terminator.
590      */
591     pv = (Char **) xcalloc((size_t) (i + 2), sizeof(Char **));
592     dp = cp;
593     i = 0;
594     if (*dp)
595 	for (;;) {
596 	    if ((c = *dp) == ':' || c == 0) {
597 		*dp = 0;
598 		if ((*cp != '/' || *cp == '\0') && (euid == 0 || uid == 0))
599 		    (void) fprintf(csherr,
600 	    "Warning: imported path contains relative components\n");
601 		pv[i++] = Strsave(*cp ? cp : STRdot);
602 		if (c) {
603 		    cp = dp + 1;
604 		    *dp = ':';
605 		}
606 		else
607 		    break;
608 	    }
609 	    dp++;
610 	}
611     pv[i] = 0;
612     set1(STRpath, pv, &shvhed);
613 }
614 
615 /*
616  * Source to the file which is the catenation of the argument names.
617  */
618 static int
srccat(cp,dp)619 srccat(cp, dp)
620     Char   *cp, *dp;
621 {
622     register Char *ep = Strspl(cp, dp);
623     char   *ptr = short2str(ep);
624 
625     xfree((ptr_t) ep);
626     return srcfile(ptr, mflag ? 0 : 1, 0);
627 }
628 
629 /*
630  * Source to a file putting the file descriptor in a safe place (> 2).
631  */
632 static int
srcfile(f,onlyown,flag)633 srcfile(f, onlyown, flag)
634     char   *f;
635     bool    onlyown, flag;
636 {
637     register int unit;
638 
639     if ((unit = open(f, O_RDONLY)) == -1)
640 	return 0;
641     unit = dmove(unit, -1);
642 
643     (void) ioctl(unit, FIOCLEX, NULL);
644     srcunit(unit, onlyown, flag);
645     return 1;
646 }
647 
648 /*
649  * Source to a unit.  If onlyown it must be our file or our group or
650  * we don't chance it.	This occurs on ".cshrc"s and the like.
651  */
652 int     insource;
653 static void
srcunit(unit,onlyown,hflg)654 srcunit(unit, onlyown, hflg)
655     register int unit;
656     bool    onlyown, hflg;
657 {
658     /* We have to push down a lot of state here */
659     /* All this could go into a structure */
660     int     oSHIN = -1, oldintty = intty, oinsource = insource;
661     struct whyle *oldwhyl = whyles;
662     Char   *ogointr = gointr, *oarginp = arginp;
663     Char   *oevalp = evalp, **oevalvec = evalvec;
664     int     oonelflg = onelflg;
665     bool    oenterhist = enterhist;
666     char    OHIST = HIST;
667     bool    otell = cantell;
668 
669     struct Bin saveB;
670     sigset_t sigset, osigset;
671     jmp_buf oldexit;
672 
673     /* The (few) real local variables */
674     int     my_reenter;
675 
676     if (unit < 0)
677 	return;
678     if (didfds)
679 	donefds();
680     if (onlyown) {
681 	struct stat stb;
682 
683 	if (fstat(unit, &stb) < 0) {
684 	    (void) close(unit);
685 	    return;
686 	}
687     }
688 
689     /*
690      * There is a critical section here while we are pushing down the input
691      * stream since we have stuff in different structures. If we weren't
692      * careful an interrupt could corrupt SHIN's Bin structure and kill the
693      * shell.
694      *
695      * We could avoid the critical region by grouping all the stuff in a single
696      * structure and pointing at it to move it all at once.  This is less
697      * efficient globally on many variable references however.
698      */
699     insource = 1;
700     getexit(oldexit);
701 
702     if (setintr) {
703 	sigemptyset(&sigset);
704 	sigaddset(&sigset, SIGINT);
705 	sigprocmask(SIG_BLOCK, &sigset, &osigset);
706     }
707     /* Setup the new values of the state stuff saved above */
708     memmove(&saveB, &B, sizeof(B));
709     fbuf = NULL;
710     fseekp = feobp = fblocks = 0;
711     oSHIN = SHIN, SHIN = unit, arginp = 0, onelflg = 0;
712     intty = isatty(SHIN), whyles = 0, gointr = 0;
713     evalvec = 0;
714     evalp = 0;
715     enterhist = hflg;
716     if (enterhist)
717 	HIST = '\0';
718 
719     /*
720      * Now if we are allowing commands to be interrupted, we let ourselves be
721      * interrupted.
722      */
723     if (setintr)
724 	sigprocmask(SIG_SETMASK, &osigset, NULL);
725     settell();
726 
727     if ((my_reenter = setexit()) == 0)
728 	process(0);		/* 0 -> blow away on errors */
729 
730     if (setintr)
731 	sigprocmask(SIG_SETMASK, &osigset, NULL);
732     if (oSHIN >= 0) {
733 	register int i;
734 
735 	/* We made it to the new state... free up its storage */
736 	/* This code could get run twice but xfree doesn't care */
737 	for (i = 0; i < fblocks; i++)
738 	    xfree((ptr_t) fbuf[i]);
739 	xfree((ptr_t) fbuf);
740 
741 	/* Reset input arena */
742 	memmove(&B, &saveB, sizeof(B));
743 
744 	(void) close(SHIN), SHIN = oSHIN;
745 	arginp = oarginp, onelflg = oonelflg;
746 	evalp = oevalp, evalvec = oevalvec;
747 	intty = oldintty, whyles = oldwhyl, gointr = ogointr;
748 	if (enterhist)
749 	    HIST = OHIST;
750 	enterhist = oenterhist;
751 	cantell = otell;
752     }
753 
754     resexit(oldexit);
755     /*
756      * If process reset() (effectively an unwind) then we must also unwind.
757      */
758     if (my_reenter)
759 	stderror(ERR_SILENT);
760     insource = oinsource;
761 }
762 
763 void
rechist()764 rechist()
765 {
766     Char    buf[BUFSIZ], hbuf[BUFSIZ], *hfile;
767     int     fp, ftmp, oldidfds;
768     struct  varent *shist;
769 
770     if (!fast) {
771 	/*
772 	 * If $savehist is just set, we use the value of $history
773 	 * else we use the value in $savehist
774 	 */
775 	if ((shist = adrof(STRsavehist)) != NULL) {
776 	    if (shist->vec[0][0] != '\0')
777 		(void) Strcpy(hbuf, shist->vec[0]);
778 	    else if ((shist = adrof(STRhistory)) && shist->vec[0][0] != '\0')
779 		(void) Strcpy(hbuf, shist->vec[0]);
780 	    else
781 		return;
782 	}
783 	else
784   	    return;
785 
786   	if ((hfile = value(STRhistfile)) == STRNULL) {
787   	    hfile = Strcpy(buf, value(STRhome));
788   	    (void) Strcat(buf, STRsldthist);
789   	}
790 
791   	if ((fp = open(short2str(hfile), O_WRONLY | O_CREAT | O_TRUNC,
792 	    0600)) == -1)
793   	    return;
794 
795 	oldidfds = didfds;
796 	didfds = 0;
797 	ftmp = SHOUT;
798 	SHOUT = fp;
799 	dumphist[2] = hbuf;
800 	dohist(dumphist, NULL);
801 	SHOUT = ftmp;
802 	(void) close(fp);
803 	didfds = oldidfds;
804     }
805 }
806 
807 void
goodbye()808 goodbye()
809 {
810     rechist();
811 
812     if (loginsh) {
813 	(void) signal(SIGQUIT, SIG_IGN);
814 	(void) signal(SIGINT, SIG_IGN);
815 	(void) signal(SIGTERM, SIG_IGN);
816 	setintr = 0;		/* No interrupts after "logout" */
817 	if (!(adrof(STRlogout)))
818 	    set(STRlogout, STRnormal);
819 #ifdef _PATH_DOTLOGOUT
820 	(void) srcfile(_PATH_DOTLOGOUT, 0, 0);
821 #endif
822 	if (adrof(STRhome))
823 	    (void) srccat(value(STRhome), STRsldtlogout);
824     }
825     exitstat();
826 }
827 
828 void
exitstat()829 exitstat()
830 {
831     Char *s;
832 #ifdef PROF
833     monitor(0);
834 #endif
835     /*
836      * Note that if STATUS is corrupted (i.e. getn bombs) then error will exit
837      * directly because we poke child here. Otherwise we might continue
838      * unwarrantedly (sic).
839      */
840     child = 1;
841     s = value(STRstatus);
842     xexit(s ? getn(s) : 0);
843 }
844 
845 /*
846  * in the event of a HUP we want to save the history
847  */
848 static void
phup(sig)849 phup(sig)
850 int sig;
851 {
852     rechist();
853 
854     /*
855      * We kill the last foreground process group. It then becomes
856      * responsible to propagate the SIGHUP to its progeny.
857      */
858     {
859 	struct process *pp, *np;
860 
861 	for (pp = proclist.p_next; pp; pp = pp->p_next) {
862 	    np = pp;
863 	    /*
864 	     * Find if this job is in the foreground. It could be that
865 	     * the process leader has exited and the foreground flag
866 	     * is cleared for it.
867 	     */
868 	    do
869 		/*
870 		 * If a process is in the foreground; we try to kill
871 		 * it's process group. If we succeed, then the
872 		 * whole job is gone. Otherwise we keep going...
873 		 * But avoid sending HUP to the shell again.
874 		 */
875 		if ((np->p_flags & PFOREGND) != 0 && np->p_jobid != shpgrp &&
876 		    killpg(np->p_jobid, SIGHUP) != -1) {
877 		    /* In case the job was suspended... */
878 		    (void) killpg(np->p_jobid, SIGCONT);
879 		    break;
880 		}
881 	    while ((np = np->p_friends) != pp);
882 	}
883     }
884     xexit(sig);
885 }
886 
887 Char   *jobargv[2] = {STRjobs, 0};
888 
889 /*
890  * Catch an interrupt, e.g. during lexical input.
891  * If we are an interactive shell, we reset the interrupt catch
892  * immediately.  In any case we drain the shell output,
893  * and finally go through the normal error mechanism, which
894  * gets a chance to make the shell go away.
895  */
896 /* ARGSUSED */
897 void
pintr(notused)898 pintr(notused)
899 	int notused;
900 {
901     pintr1(1);
902 }
903 
904 void
pintr1(wantnl)905 pintr1(wantnl)
906     bool    wantnl;
907 {
908     Char **v;
909     sigset_t sigset, osigset;
910 
911     sigemptyset(&sigset);
912     sigprocmask(SIG_BLOCK, &sigset, &osigset);
913     if (setintr) {
914 	sigset = osigset;
915 	sigdelset(&sigset, SIGINT);
916 	sigprocmask(SIG_SETMASK, &sigset, NULL);
917 	if (pjobs) {
918 	    pjobs = 0;
919 	    (void) fprintf(cshout, "\n");
920 	    dojobs(jobargv, NULL);
921 	    stderror(ERR_NAME | ERR_INTR);
922 	}
923     }
924     sigdelset(&osigset, SIGCHLD);
925     sigprocmask(SIG_SETMASK, &osigset, NULL);
926     (void) fpurge(cshout);
927     (void) endpwent();
928 
929     /*
930      * If we have an active "onintr" then we search for the label. Note that if
931      * one does "onintr -" then we shan't be interruptible so we needn't worry
932      * about that here.
933      */
934     if (gointr) {
935 	gotolab(gointr);
936 	timflg = 0;
937 	if ((v = pargv) != NULL)
938 	    pargv = 0, blkfree(v);
939 	if ((v = gargv) != NULL)
940 	    gargv = 0, blkfree(v);
941 	reset();
942     }
943     else if (intty && wantnl) {
944 	(void) fputc('\r', cshout);
945 	(void) fputc('\n', cshout);
946     }
947     stderror(ERR_SILENT);
948 }
949 
950 /*
951  * Process is the main driving routine for the shell.
952  * It runs all command processing, except for those within { ... }
953  * in expressions (which is run by a routine evalav in sh.exp.c which
954  * is a stripped down process), and `...` evaluation which is run
955  * also by a subset of this code in sh.glob.c in the routine backeval.
956  *
957  * The code here is a little strange because part of it is interruptible
958  * and hence freeing of structures appears to occur when none is necessary
959  * if this is ignored.
960  *
961  * Note that if catch is not set then we will unwind on any error.
962  * If an end-of-file occurs, we return.
963  */
964 static struct command *savet = NULL;
965 void
process(catch)966 process(catch)
967     bool    catch;
968 {
969     jmp_buf osetexit;
970     struct command *t = savet;
971     sigset_t sigset;
972 
973     savet = NULL;
974     getexit(osetexit);
975     for (;;) {
976 	pendjob();
977 	paraml.next = paraml.prev = &paraml;
978 	paraml.word = STRNULL;
979 	(void) setexit();
980 	justpr = enterhist;	/* execute if not entering history */
981 
982 	/*
983 	 * Interruptible during interactive reads
984 	 */
985 	if (setintr) {
986 	    sigemptyset(&sigset);
987 	    sigaddset(&sigset, SIGINT);
988 	    sigprocmask(SIG_UNBLOCK, &sigset, NULL);
989 	}
990 
991 	/*
992 	 * For the sake of reset()
993 	 */
994 	freelex(&paraml);
995 	if (savet)
996 	    freesyn(savet), savet = NULL;
997 
998 	if (haderr) {
999 	    if (!catch) {
1000 		/* unwind */
1001 		doneinp = 0;
1002 		resexit(osetexit);
1003 		savet = t;
1004 		reset();
1005 	    }
1006 	    haderr = 0;
1007 	    /*
1008 	     * Every error is eventually caught here or the shell dies.  It is
1009 	     * at this point that we clean up any left-over open files, by
1010 	     * closing all but a fixed number of pre-defined files.  Thus
1011 	     * routines don't have to worry about leaving files open due to
1012 	     * deeper errors... they will get closed here.
1013 	     */
1014 	    closem();
1015 	    continue;
1016 	}
1017 	if (doneinp) {
1018 	    doneinp = 0;
1019 	    break;
1020 	}
1021 	if (chkstop)
1022 	    chkstop--;
1023 	if (neednote)
1024 	    pnote();
1025 	if (intty && prompt && evalvec == 0) {
1026 	    mailchk();
1027 	    /*
1028 	     * If we are at the end of the input buffer then we are going to
1029 	     * read fresh stuff. Otherwise, we are rereading input and don't
1030 	     * need or want to prompt.
1031 	     */
1032 	    if (aret == F_SEEK && fseekp == feobp)
1033 		printprompt();
1034 	    (void) fflush(cshout);
1035 	}
1036 	if (seterr) {
1037 	    xfree((ptr_t) seterr);
1038 	    seterr = NULL;
1039 	}
1040 
1041 	/*
1042 	 * Echo not only on VERBOSE, but also with history expansion. If there
1043 	 * is a lexical error then we forego history echo.
1044 	 */
1045 	if ((lex(&paraml) && !seterr && intty) || adrof(STRverbose)) {
1046 	    prlex(csherr, &paraml);
1047 	}
1048 
1049 	/*
1050 	 * The parser may lose space if interrupted.
1051 	 */
1052 	if (setintr)
1053 	    sigprocmask(SIG_BLOCK, &sigset, NULL);
1054 
1055 	/*
1056 	 * Save input text on the history list if reading in old history, or it
1057 	 * is from the terminal at the top level and not in a loop.
1058 	 *
1059 	 * PWP: entry of items in the history list while in a while loop is done
1060 	 * elsewhere...
1061 	 */
1062 	if (enterhist || (catch && intty && !whyles))
1063 	    savehist(&paraml);
1064 
1065 	/*
1066 	 * Print lexical error messages, except when sourcing history lists.
1067 	 */
1068 	if (!enterhist && seterr)
1069 	    stderror(ERR_OLD);
1070 
1071 	/*
1072 	 * If had a history command :p modifier then this is as far as we
1073 	 * should go
1074 	 */
1075 	if (justpr)
1076 	    reset();
1077 
1078 	alias(&paraml);
1079 
1080 	/*
1081 	 * Parse the words of the input into a parse tree.
1082 	 */
1083 	savet = syntax(paraml.next, &paraml, 0);
1084 	if (seterr)
1085 	    stderror(ERR_OLD);
1086 
1087 	execute(savet, (tpgrp > 0 ? tpgrp : -1), NULL, NULL);
1088 
1089 	/*
1090 	 * Made it!
1091 	 */
1092 	freelex(&paraml);
1093 	freesyn((struct command *) savet), savet = NULL;
1094     }
1095     resexit(osetexit);
1096     savet = t;
1097 }
1098 
1099 void
1100 /*ARGSUSED*/
dosource(v,t)1101 dosource(v, t)
1102     Char **v;
1103     struct command *t;
1104 
1105 {
1106     register Char *f;
1107     bool    hflg = 0;
1108     Char    buf[BUFSIZ];
1109 
1110     v++;
1111     if (*v && eq(*v, STRmh)) {
1112 	if (*++v == NULL)
1113 	    stderror(ERR_NAME | ERR_HFLAG);
1114 	hflg++;
1115     }
1116     (void) Strcpy(buf, *v);
1117     f = globone(buf, G_ERROR);
1118     (void) strcpy((char *) buf, short2str(f));
1119     xfree((ptr_t) f);
1120     if (!srcfile((char *) buf, 0, hflg) && !hflg)
1121 	stderror(ERR_SYSTEM, (char *) buf, strerror(errno));
1122 }
1123 
1124 /*
1125  * Check for mail.
1126  * If we are a login shell, then we don't want to tell
1127  * about any mail file unless its been modified
1128  * after the time we started.
1129  * This prevents us from telling the user things he already
1130  * knows, since the login program insists on saying
1131  * "You have mail."
1132  */
1133 static void
mailchk()1134 mailchk()
1135 {
1136     register struct varent *v;
1137     register Char **vp;
1138     time_t  t;
1139     int     intvl, cnt;
1140     struct stat stb;
1141     bool    new;
1142 
1143     v = adrof(STRmail);
1144     if (v == 0)
1145 	return;
1146     (void) time(&t);
1147     vp = v->vec;
1148     cnt = blklen(vp);
1149     intvl = (cnt && number(*vp)) ? (--cnt, getn(*vp++)) : MAILINTVL;
1150     if (intvl < 1)
1151 	intvl = 1;
1152     if (chktim + intvl > t)
1153 	return;
1154     for (; *vp; vp++) {
1155 	if (stat(short2str(*vp), &stb) < 0)
1156 	    continue;
1157 	new = stb.st_mtime > time0.tv_sec;
1158 	if (stb.st_size == 0 || stb.st_atime > stb.st_mtime ||
1159 	    (stb.st_atime < chktim && stb.st_mtime < chktim) ||
1160 	    (loginsh && !new))
1161 	    continue;
1162 	if (cnt == 1)
1163 	    (void) fprintf(cshout, "You have %smail.\n", new ? "new " : "");
1164 	else
1165 	    (void) fprintf(cshout, "%s in %s.\n", new ? "New mail" : "Mail",
1166 			   vis_str(*vp));
1167     }
1168     chktim = t;
1169 }
1170 
1171 /*
1172  * Extract a home directory from the password file
1173  * The argument points to a buffer where the name of the
1174  * user whose home directory is sought is currently.
1175  * We write the home directory of the user back there.
1176  */
1177 int
gethdir(home)1178 gethdir(home)
1179     Char   *home;
1180 {
1181     Char   *h;
1182     struct passwd *pw;
1183 
1184     /*
1185      * Is it us?
1186      */
1187     if (*home == '\0') {
1188 	if ((h = value(STRhome)) != NULL) {
1189 	    (void) Strcpy(home, h);
1190 	    return 0;
1191 	}
1192 	else
1193 	    return 1;
1194     }
1195 
1196     if ((pw = getpwnam(short2str(home))) != NULL) {
1197 	(void) Strcpy(home, str2short(pw->pw_dir));
1198 	return 0;
1199     }
1200     else
1201 	return 1;
1202 }
1203 
1204 /*
1205  * When didfds is set, we do I/O from 0, 1, 2 otherwise from 15, 16, 17
1206  * We also check if the shell has already changed the decriptor to point to
1207  * 0, 1, 2 when didfds is set.
1208  */
1209 #define DESC(a) (*((int *) (a)) - (didfds && *((int *) a) >= FSHIN ? FSHIN : 0))
1210 
1211 static int
readf(oreo,buf,siz)1212 readf(oreo, buf, siz)
1213     void *oreo;
1214     char *buf;
1215     int siz;
1216 {
1217     return read(DESC(oreo), buf, siz);
1218 }
1219 
1220 
1221 static int
writef(oreo,buf,siz)1222 writef(oreo, buf, siz)
1223     void *oreo;
1224     const char *buf;
1225     int siz;
1226 {
1227     return write(DESC(oreo), buf, siz);
1228 }
1229 
1230 static fpos_t
seekf(oreo,off,whence)1231 seekf(oreo, off, whence)
1232     void *oreo;
1233     fpos_t off;
1234     int whence;
1235 {
1236     return lseek(DESC(oreo), off, whence);
1237 }
1238 
1239 
1240 static int
closef(oreo)1241 closef(oreo)
1242     void *oreo;
1243 {
1244     return close(DESC(oreo));
1245 }
1246 
1247 
1248 /*
1249  * Print the visible version of a string.
1250  */
1251 int
vis_fputc(ch,fp)1252 vis_fputc(ch, fp)
1253     int ch;
1254     FILE *fp;
1255 {
1256     char uenc[5];	/* 4 + NULL */
1257 
1258     if (ch & QUOTE)
1259 	return fputc(ch & TRIM, fp);
1260     /*
1261      * XXX: When we are in AsciiOnly we want all characters >= 0200 to
1262      * be encoded, but currently there is no way in vis to do that.
1263      */
1264     (void) vis(uenc, ch & TRIM, VIS_NOSLASH, 0);
1265     return fputs(uenc, fp);
1266 }
1267 
1268 /*
1269  * Move the initial descriptors to their eventual
1270  * resting places, closin all other units.
1271  */
1272 void
initdesc()1273 initdesc()
1274 {
1275 
1276     didfds = 0;			/* 0, 1, 2 aren't set up */
1277     (void) ioctl(SHIN = dcopy(0, FSHIN), FIOCLEX, NULL);
1278     (void) ioctl(SHOUT = dcopy(1, FSHOUT), FIOCLEX, NULL);
1279     (void) ioctl(SHERR = dcopy(2, FSHERR), FIOCLEX, NULL);
1280     (void) ioctl(OLDSTD = dcopy(SHIN, FOLDSTD), FIOCLEX, NULL);
1281     closem();
1282 }
1283 
1284 
1285 void
1286 #ifdef PROF
done(i)1287 done(i)
1288 #else
1289 xexit(i)
1290 #endif
1291     int     i;
1292 {
1293     untty();
1294     _exit(i);
1295 }
1296 
1297 static Char **
defaultpath()1298 defaultpath()
1299 {
1300     char   *ptr;
1301     Char  **blk, **blkp;
1302     struct stat stb;
1303 
1304     blkp = blk = (Char **) xmalloc((size_t) sizeof(Char *) * 10);
1305 
1306 #define DIRAPPEND(a)  \
1307 	if (stat(ptr = a, &stb) == 0 && (stb.st_mode & S_IFMT) == S_IFDIR) \
1308 		*blkp++ = SAVE(ptr)
1309 
1310     DIRAPPEND(_PATH_BIN);
1311     DIRAPPEND(_PATH_USRBIN);
1312 
1313 #undef DIRAPPEND
1314 
1315     if (euid != 0 && uid != 0)
1316 	*blkp++ = Strsave(STRdot);
1317     *blkp = NULL;
1318     return (blk);
1319 }
1320 
1321 void
printprompt()1322 printprompt()
1323 {
1324     register Char *cp;
1325 
1326     if (!whyles) {
1327 	for (cp = value(STRprompt); *cp; cp++)
1328 	    if (*cp == HIST)
1329 		(void) fprintf(cshout, "%d", eventno + 1);
1330 	    else {
1331 		if (*cp == '\\' && cp[1] == HIST)
1332 		    cp++;
1333 		(void) vis_fputc(*cp | QUOTE, cshout);
1334 	    }
1335     }
1336     else
1337 	/*
1338 	 * Prompt for forward reading loop body content.
1339 	 */
1340 	(void) fprintf(cshout, "? ");
1341     (void) fflush(cshout);
1342 }
1343