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