Home | History | Annotate | Download | only in csh
      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