xref: /titanic_41/usr/src/cmd/csh/sh.h (revision 70a587dd392ff1dbaa2875c6c33921f08ea85273)
1 /*
2  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
3  * Use is subject to license terms.
4  */
5 
6 /*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
7 /*	  All Rights Reserved  	*/
8 
9 /*
10  * Copyright (c) 1980 Regents of the University of California.
11  * All rights reserved.  The Berkeley Software License Agreement
12  * specifies the terms and conditions for redistribution.
13  */
14 
15 #pragma ident	"%Z%%M%	%I%	%E% SMI"
16 
17 #include <stdlib.h>	 /* MB_xxx, mbxxx(), wcxxx() etc. */
18 #include <limits.h>
19 #include <sys/time.h>
20 #include <sys/types.h>
21 #include <sys/siginfo.h>
22 #include <sys/ucontext.h>
23 #include <sys/param.h>
24 #include <sys/stat.h>
25 #include <sys/termios.h>
26 #include <sys/ttold.h>
27 #include <errno.h>
28 #include <signal.h>	/* std sysV signal.h */
29 #include <setjmp.h>
30 #include <sys/resource.h>
31 #include <netdb.h> /* for MAXHOSTNAMELEN */
32 #include "signal.h"	/* mainly BSD related signal.h */
33 #include "sh.local.h"
34 #include "sh.char.h"
35 
36 
37 #ifdef MBCHAR
38 #if !defined(MB_LEN_MAX) || !defined(MB_CUR_MAX)
39 	Error: I need both ANSI macros!
40 #endif
41 #else
42 #if !defined(MB_LEN_MAX)
43 #define	MB_LEN_MAX	1
44 #endif
45 #if !defined(MB_CUR_MAX)
46 #define	MB_CUR_MAX	1
47 #endif
48 #endif
49 
50 #ifndef MBCHAR /* Let's replace the ANSI functions with our own macro
51 		* for efficiency!
52 		*/
53 #define	mbtowc(pwc, pmb, n_is_ignored)	((*(pwc) = *(pmb)), 1)
54 #define	wctomb(pmb, wc)			((*(pmb) = ((char)wc)), 1)
55 #endif /* !MBCHAR */
56 
57 /*
58  * C shell
59  *
60  * Bill Joy, UC Berkeley
61  * October, 1978; May 1980
62  *
63  * Jim Kulp, IIASA, Laxenburg Austria
64  * April, 1980
65  */
66 
67 /*
68  * If we are setting the $cwd variable becuz we did a
69  * cd, chdir, pushd, popd command, then set didchdir to
70  * 1.  This prevents globbing down when setting $cwd.
71  * However, if the user set $cwd, we want the globbing
72  * done; so, didchdir would be equal to 0 in that case.
73  */
74 int didchdir;
75 
76 #define	isdir(d)	((d.st_mode & S_IFMT) == S_IFDIR)
77 
78 typedef	char	bool;
79 
80 /*
81  * tchar (Tagged CHARacter) is a place holder to keep a QUOTE bit and
82  * a character.
83  * For European language handling, lower 8 bits of tchar is used
84  * to store a character.  For other languages, especially Asian, 16 bits
85  * are used to store a character.
86  * Following typedef's assume short int is a 16-bit entity and long int is
87  * a 32-bit entity.
88  * The QUOTE bit tells whether the character is subject to further
89  * interpretation such as history substitution, file mathing, command
90  * subsitution.  TRIM is a mask to strip off the QUOTE bit.
91  */
92 #ifdef MBCHAR		/* For multibyte character handling. */
93 typedef long int	tchar;
94 #define	QUOTE	0x80000000
95 #define	TRIM	0x7fffffff
96 #else /* !MBCHAR */	/* European language requires only 8 bits. */
97 typedef unsigned short int	tchar;
98 #define	QUOTE	0x8000
99 #define	TRIM	0x00ff
100 #endif /* !MBCHAR */
101 #define	eq(a, b)	(strcmp_(a, b) == 0)
102 
103 
104 /*
105  * Global flags
106  */
107 bool	chkstop;		/* Warned of stopped jobs... allow exit */
108 bool	didfds;			/* Have setup i/o fd's for child */
109 bool	doneinp;		/* EOF indicator after reset from readc */
110 bool	exiterr;		/* Exit if error or non-zero exit status */
111 bool	child;			/* Child shell ... errors cause exit */
112 bool	haderr;			/* Reset was because of an error */
113 bool	intty;			/* Input is a tty */
114 bool	cflg;			/* invoked with -c option */
115 bool	intact;			/* We are interactive... therefore prompt */
116 bool	justpr;			/* Just print because of :p hist mod */
117 bool	loginsh;		/* We are a loginsh -> .login/.logout */
118 bool	neednote;		/* Need to pnotify() */
119 bool	noexec;			/* Don't execute, just syntax check */
120 bool	pjobs;			/* want to print jobs if interrupted */
121 bool	pfcshflag;		/* set to 0 for pfcsh */
122 bool	setintr;		/* Set interrupts on/off -> Wait intr... */
123 bool	timflg;			/* Time the next waited for command */
124 bool	havhash;		/* path hashing is available */
125 bool	havhash2;		/* cdpath hashing is available */
126 #ifdef FILEC
127 bool	filec;			/* doing filename expansion */
128 #endif
129 
130 /*
131  * Global i/o info
132  */
133 tchar	*arginp;		/* Argument input for sh -c and internal `xx` */
134 int	onelflg;		/* 2 -> need line for -t, 1 -> exit on read */
135 tchar	*file;			/* Name of shell file for $0 */
136 
137 char	*err;			/* Error message from scanner/parser */
138 struct	timeval time0;		/* Time at which the shell started */
139 struct	rusage ru0;
140 
141 /*
142  * Miscellany
143  */
144 tchar	*doldol;		/* Character pid for $$ */
145 int	uid;			/* Invokers uid */
146 time_t	chktim;			/* Time mail last checked */
147 int	shpgrp;			/* Pgrp of shell */
148 int	tpgrp;			/* Terminal process group */
149 /* If tpgrp is -1, leave tty alone! */
150 int	opgrp;			/* Initial pgrp and tty pgrp */
151 int	oldisc;			/* Initial line discipline or -1 */
152 
153 /*
154  * These are declared here because they want to be
155  * initialized in sh.init.c (to allow them to be made readonly)
156  */
157 
158 extern struct	biltins {
159 	tchar	*bname;
160 	int	(*bfunct)();
161 	short	minargs, maxargs;
162 } bfunc[];
163 extern int nbfunc;
164 
165 extern struct srch {
166 	tchar	*s_name;
167 	short	s_value;
168 } srchn[];
169 extern int nsrchn;
170 
171 /*
172  * To be able to redirect i/o for builtins easily, the shell moves the i/o
173  * descriptors it uses away from 0,1,2.
174  * Ideally these should be in units which are closed across exec's
175  * (this saves work) but for version 6, this is not usually possible.
176  * The desired initial values for these descriptors are defined in
177  * sh.local.h.
178  */
179 short	SHIN;			/* Current shell input (script) */
180 short	SHOUT;			/* Shell output */
181 short	SHDIAG;			/* Diagnostic output... shell errs go here */
182 short	OLDSTD;			/* Old standard input (def for cmds) */
183 
184 /*
185  * Error control
186  *
187  * Errors in scanning and parsing set up an error message to be printed
188  * at the end and complete.  Other errors always cause a reset.
189  * Because of source commands and .cshrc we need nested error catches.
190  */
191 
192 jmp_buf	reslab;
193 
194 #define	setexit()	((void) setjmp(reslab))
195 #define	reset()		longjmp(reslab, 0)
196 	/* Should use structure assignment here */
197 #define	getexit(a)	copy((void *)(a), (void *)reslab, sizeof reslab)
198 #define	resexit(a)	copy((void *)reslab, ((void *)(a)), sizeof reslab)
199 
200 tchar	*gointr;		/* Label for an onintr transfer */
201 void	(*parintr)();		/* Parents interrupt catch */
202 void	(*parterm)();		/* Parents terminate catch */
203 
204 
205 /*
206  * Each level of input has a buffered input structure.
207  * There are one or more blocks of buffered input for each level,
208  * exactly one if the input is seekable and tell is available.
209  * In other cases, the shell buffers enough blocks to keep all loops
210  * in the buffer.
211  */
212 struct	Bin {
213 	off_t	Bfseekp;		/* Seek pointer */
214 	off_t	Bfbobp;			/* Seekp of beginning of buffers */
215 	off_t	Bfeobp;			/* Seekp of end of buffers */
216 	short	Bfblocks;		/* Number of buffer blocks */
217 	tchar	**Bfbuf;		/* The array of buffer blocks */
218 } B;
219 
220 #define	fseekp	B.Bfseekp
221 #define	fbobp	B.Bfbobp
222 #define	feobp	B.Bfeobp
223 #define	fblocks	B.Bfblocks
224 #define	fbuf	B.Bfbuf
225 
226 #define	btell()	fseekp
227 
228 #ifndef btell
229 off_t	btell(void);
230 #endif
231 
232 /*
233  * The shell finds commands in loops by reseeking the input
234  * For whiles, in particular, it reseeks to the beginning of the
235  * line the while was on; hence the while placement restrictions.
236  */
237 off_t	lineloc;
238 
239 #ifdef	TELL
240 bool	cantell;			/* Is current source tellable ? */
241 #endif
242 
243 /*
244  * Input lines are parsed into doubly linked circular
245  * lists of words of the following form.
246  */
247 struct	wordent {
248 	tchar	*word;
249 	struct	wordent *prev;
250 	struct	wordent *next;
251 };
252 
253 /*
254  * During word building, both in the initial lexical phase and
255  * when expanding $ variable substitutions, expansion by `!' and `$'
256  * must be inhibited when reading ahead in routines which are themselves
257  * processing `!' and `$' expansion or after characters such as `\' or in
258  * quotations.  The following flags are passed to the getC routines
259  * telling them which of these substitutions are appropriate for the
260  * next character to be returned.
261  */
262 #define	DODOL	1
263 #define	DOEXCL	2
264 #define	DOALL	DODOL|DOEXCL
265 
266 /*
267  * Labuf implements a general buffer for lookahead during lexical operations.
268  * Text which is to be placed in the input stream can be stuck here.
269  * We stick parsed ahead $ constructs during initial input,
270  * process id's from `$$', and modified variable values (from qualifiers
271  * during expansion in sh.dol.c) here.
272  */
273 tchar	*labuf;
274 
275 tchar	*lap;
276 
277 /*
278  * Parser structure
279  *
280  * Each command is parsed to a tree of command structures and
281  * flags are set bottom up during this process, to be propagated down
282  * as needed during the semantics/exeuction pass (sh.sem.c).
283  */
284 struct	command {
285 	short	t_dtyp;				/* Type of node */
286 	short	t_dflg;				/* Flags, e.g. FAND|... */
287 	union {
288 		tchar	*T_dlef;		/* Input redirect word */
289 		struct	command *T_dcar;	/* Left part of list/pipe */
290 	} L;
291 	union {
292 		tchar	*T_drit;		/* Output redirect word */
293 		struct	command *T_dcdr;	/* Right part of list/pipe */
294 	} R;
295 #define	t_dlef	L.T_dlef
296 #define	t_dcar	L.T_dcar
297 #define	t_drit	R.T_drit
298 #define	t_dcdr	R.T_dcdr
299 	tchar	**t_dcom;			/* Command/argument vector */
300 	char	*cfname;			/* char pathname for execv */
301 	char	**cargs;			/* char arg vec  for execv */
302 	struct	command *t_dspr;		/* Pointer to ()'d subtree */
303 	short	t_nice;
304 };
305 
306 #define	TCOM	1		/* t_dcom <t_dlef >t_drit	*/
307 #define	TPAR	2		/* ( t_dspr ) <t_dlef >t_drit	*/
308 #define	TFIL	3		/* t_dlef | t_drit		*/
309 #define	TLST	4		/* t_dlef ; t_drit		*/
310 #define	TOR	5		/* t_dlef || t_drit		*/
311 #define	TAND	6		/* t_dlef && t_drit		*/
312 
313 #define	FSAVE	(FNICE|FTIME|FNOHUP)	/* save these when re-doing */
314 
315 #define	FAND	(1<<0)		/* executes in background	*/
316 #define	FCAT	(1<<1)		/* output is redirected >>	*/
317 #define	FPIN	(1<<2)		/* input is a pipe		*/
318 #define	FPOU	(1<<3)		/* output is a pipe		*/
319 #define	FPAR	(1<<4)		/* don't fork, last ()ized cmd	*/
320 #define	FINT	(1<<5)		/* should be immune from intr's */
321 /* spare */
322 #define	FDIAG	(1<<7)		/* redirect unit 2 with unit 1	*/
323 #define	FANY	(1<<8)		/* output was !			*/
324 #define	FHERE	(1<<9)		/* input redirection is <<	*/
325 #define	FREDO	(1<<10)		/* reexec aft if, repeat,...	*/
326 #define	FNICE	(1<<11)		/* t_nice is meaningful */
327 #define	FNOHUP	(1<<12)		/* nohup this command */
328 #define	FTIME	(1<<13)		/* time this command */
329 
330 /*
331  * The keywords for the parser
332  */
333 #define	ZBREAK		0
334 #define	ZBRKSW		1
335 #define	ZCASE		2
336 #define	ZDEFAULT 	3
337 #define	ZELSE		4
338 #define	ZEND		5
339 #define	ZENDIF		6
340 #define	ZENDSW		7
341 #define	ZEXIT		8
342 #define	ZFOREACH	9
343 #define	ZGOTO		10
344 #define	ZIF		11
345 #define	ZLABEL		12
346 #define	ZLET		13
347 #define	ZSET		14
348 #define	ZSWITCH		15
349 #define	ZTEST		16
350 #define	ZTHEN		17
351 #define	ZWHILE		18
352 
353 /*
354  * Structure defining the existing while/foreach loops at this
355  * source level.  Loops are implemented by seeking back in the
356  * input.  For foreach (fe), the word list is attached here.
357  */
358 struct	whyle {
359 	off_t	w_start;		/* Point to restart loop */
360 	off_t	w_end;			/* End of loop (0 if unknown) */
361 	tchar	**w_fe, **w_fe0;	/* Current/initial wordlist for fe */
362 	tchar	*w_fename;		/* Name for fe */
363 	struct	whyle *w_next;		/* Next (more outer) loop */
364 } *whyles;
365 
366 /*
367  * Variable structure
368  *
369  * Aliases and variables are stored in AVL balanced binary trees.
370  */
371 struct	varent {
372 	tchar	**vec;		/* Array of words which is the value */
373 	tchar	*v_name;	/* Name of variable/alias */
374 	struct	varent *v_link[3];	/* The links, see below */
375 	int	v_bal;		/* Balance factor */
376 } shvhed, aliases;
377 #define	v_left		v_link[0]
378 #define	v_right		v_link[1]
379 #define	v_parent	v_link[2]
380 
381 struct varent *adrof1();
382 #define	adrof(v)	adrof1(v, &shvhed)
383 #define	value(v)	value1(v, &shvhed)
384 
385 /*
386  * MAX_VAR_LEN - maximum variable name defined by csh man page to be 128
387  */
388 #define	MAX_VAR_LEN	128
389 
390 /*
391  * MAX_VREF_LEN - maximum variable reference $name[...]
392  * it can be as big as a csh word, which is 1024
393  */
394 #define	MAX_VREF_LEN	1024
395 
396 
397 /*
398  * The following are for interfacing redo substitution in
399  * aliases to the lexical routines.
400  */
401 struct	wordent *alhistp;		/* Argument list (first) */
402 struct	wordent *alhistt;		/* Node after last in arg list */
403 tchar	**alvec;			/* The (remnants of) alias vector */
404 
405 /*
406  * Filename/command name expansion variables
407  */
408 short	gflag;				/* After tglob -> is globbing needed? */
409 
410 /*
411  * A reasonable limit on number of arguments would seem to be
412  * the maximum number of characters in an arg list / 6.
413  *
414  * XXX:	With the new VM system, NCARGS has become enormous, making
415  *	it impractical to allocate arrays with NCARGS / 6 entries on
416  *	the stack.  The proper fix is to revamp code elsewhere (in
417  *	sh.dol.c and sh.glob.c) to use a different technique for handling
418  *	command line arguments.  In the meantime, we simply fall back
419  *	on using the old value of NCARGS.
420  */
421 #ifdef	notyet
422 #define	GAVSIZ	(NCARGS / 6)
423 #else	/* notyet */
424 #define	GAVSIZ	(10240 / 6)
425 #endif	/* notyet */
426 
427 /*
428  * Variables for filename expansion
429  */
430 tchar	**gargv;			/* Pointer to the (stack) arglist */
431 long	gargc;				/* Number args in gargv */
432 long	gnleft;
433 
434 /*
435  * Variables for command expansion.
436  */
437 tchar	**pargv;			/* Pointer to the argv list space */
438 tchar	*pargs;				/* Pointer to start current word */
439 long	pargc;				/* Count of arguments in pargv */
440 long	pnleft;				/* Number of chars left in pargs */
441 tchar	*pargcp;			/* Current index into pargs */
442 
443 /*
444  * History list
445  *
446  * Each history list entry contains an embedded wordlist
447  * from the scanner, a number for the event, and a reference count
448  * to aid in discarding old entries.
449  *
450  * Essentially "invisible" entries are put on the history list
451  * when history substitution includes modifiers, and thrown away
452  * at the next discarding since their event numbers are very negative.
453  */
454 struct	Hist {
455 	struct	wordent Hlex;
456 	int	Hnum;
457 	int	Href;
458 	struct	Hist *Hnext;
459 } Histlist;
460 
461 struct	wordent	paraml;			/* Current lexical word list */
462 int	eventno;			/* Next events number */
463 int	lastev;				/* Last event reference (default) */
464 
465 tchar	HIST;				/* history invocation character */
466 tchar	HISTSUB;			/* auto-substitute character */
467 
468 extern void	*xalloc(size_t);
469 extern void	*xcalloc(size_t, size_t);
470 extern void	*xrealloc(void *, size_t);
471 extern void	xfree(void *);
472 
473 extern void	Putchar(tchar);
474 extern void	bferr(char *)	__NORETURN;
475 extern void	error()	__NORETURN;
476 extern void	exitstat(void)	__NORETURN;
477 extern tchar	*Dfix1(tchar *);
478 extern tchar	**blkcpy(tchar **, tchar **);
479 extern tchar	**blkspl(tchar **, tchar **);
480 extern char	**blkspl_(char **, char **);
481 extern tchar	**copyblk(tchar **);
482 extern tchar	**dobackp(tchar *, bool);
483 extern tchar	*domod(tchar *, int);
484 extern struct	Hist *enthist(int, struct wordent *, bool);
485 extern tchar	*getenv_(tchar *);
486 extern tchar	*getenvs_(char *);
487 extern tchar	*getwd_(tchar *);
488 extern tchar	**glob(tchar **);
489 extern tchar	*globone(tchar *);
490 extern tchar	*index_(tchar *, tchar);
491 extern struct biltins	*isbfunc(struct command *);
492 extern void	pintr(void);
493 extern void	pchild(void);
494 extern tchar	*putn(int);
495 extern tchar	*rindex_(tchar *, tchar);
496 extern tchar	**saveblk(tchar **);
497 extern tchar	*savestr(tchar *);
498 extern tchar	*strcat_(tchar *, tchar *);
499 extern int	strlen_(tchar *);
500 extern tchar	*strcpy_(tchar *, tchar *);
501 extern tchar	*strend(tchar *);
502 extern tchar	*strip(tchar *);
503 extern tchar	*strspl(tchar *, tchar *);
504 extern struct command	*syntax(struct wordent *, struct wordent *, int);
505 extern tchar	*value1(tchar *, struct varent *);
506 
507 #define	NOSTR	((tchar *) 0)
508 
509 /*
510  * setname is a macro to copy the path in bname. (see sh.err.c)
511  * Here we are dynamically reallocating the bname to the new length
512  * to store the new path
513  */
514 tchar	*bname;
515 #define	setname(a)	 { \
516 	bname = xrealloc(bname, (strlen_(a)+1) * sizeof (tchar)); \
517 	strcpy_(bname, a); \
518 	bname[strlen_(a)] = '\0'; \
519 }
520 
521 #ifdef VFORK
522 tchar	*Vsav;
523 tchar	**Vav;
524 tchar	*Vdp;
525 #endif
526 
527 tchar	**evalvec;
528 tchar	*evalp;
529 
530 /* Conversion functions between char and tchar strings. */
531 tchar	*strtots(/* tchar * , char * */);
532 char	*tstostr(/* char *  , tchar * */);
533 
534 #ifndef NULL
535 #define	NULL	0
536 #endif
537 
538 
539 /*
540  * Xhash is an array of HSHSIZ bits (HSHSIZ / 8 chars), which are used
541  * to hash execs.  If it is allocated (havhash true), then to tell
542  * whether ``name'' is (possibly) present in the i'th component
543  * of the variable path, you look at the bit in xhash indexed by
544  * hash(hashname("name"), i).  This is setup automatically
545  * after .login is executed, and recomputed whenever ``path'' is
546  * changed.
547  * The two part hash function is designed to let texec() call the
548  * more expensive hashname() only once and the simple hash() several
549  * times (once for each path component checked).
550  * Byte size is assumed to be 8.
551  */
552 #define	HSHSIZ		(32*1024)	/* 4k bytes */
553 #define	HSHMASK		(HSHSIZ - 1)
554 #define	HSHMUL		243
555 
556 /*
557  * The following two arrays are used for caching.  xhash
558  * is for caching path variable and xhash2 is for cdpath
559  * variable.
560  */
561 
562 char xhash[HSHSIZ / 8];
563 char xhash2[HSHSIZ / 8];
564 #define	hash(a, b)	((a) * HSHMUL + (b) & HSHMASK)
565 #define	bit(h, b)	((h)[(b) >> 3] & 1 << ((b) & 7))	/* bit test */
566 #define	bis(h, b)	((h)[(b) >> 3] |= 1 << ((b) & 7))	/* bit set */
567 #ifdef VFORK
568 int	hits, misses;
569 #endif
570