1 /* 2 * sh.sem.c: I/O redirections and job forking. A touchy issue! 3 * Most stuff with builtins is incorrect 4 */ 5 /*- 6 * Copyright (c) 1980, 1991 The Regents of the University of California. 7 * All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. Neither the name of the University nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 */ 33 #include "sh.h" 34 #include "tc.h" 35 #include "tw.h" 36 #ifdef WINNT_NATIVE 37 #include "nt.const.h" 38 #endif /*WINNT_NATIVE*/ 39 40 #ifdef CLOSE_ON_EXEC 41 # ifndef SUNOS4 42 # ifndef CLEX_DUPS 43 # define CLEX_DUPS 44 # endif /* CLEX_DUPS */ 45 # endif /* !SUNOS4 */ 46 #endif /* CLOSE_ON_EXEC */ 47 48 #if defined(__sparc__) || defined(sparc) 49 # if !defined(MACH) && SYSVREL == 0 && !defined(Lynx) && !defined(BSD4_4) && !defined(__linux__) && !defined(__GNU__) && !defined(__GLIBC__) 50 # include <vfork.h> 51 # endif /* !MACH && SYSVREL == 0 && !Lynx && !BSD4_4 && !glibc */ 52 #endif /* __sparc__ || sparc */ 53 54 #ifdef VFORK 55 static void vffree (int); 56 #endif 57 static Char *splicepipe (struct command *, Char *); 58 static void doio (struct command *, int *, int *); 59 static void chkclob (const char *); 60 61 /* 62 * C shell 63 */ 64 65 /* 66 * For SVR4, there are problems with pipelines having the first process as 67 * the group leader. The problem occurs when the first process exits before 68 * the others have a chance to setpgid(). This is because in SVR4 you can't 69 * have a zombie as a group leader. The solution I have used is to reverse 70 * the order in which pipelines are started, making the last process the 71 * group leader. (Note I am not using 'pipeline' in the generic sense -- I 72 * mean processes connected by '|'.) I don't know yet if this causes other 73 * problems. 74 * 75 * All the changes for this are in execute(), and are enclosed in 76 * '#ifdef BACKPIPE' 77 * 78 * David Dawes (dawes@physics.su.oz.au) Oct 1991 79 */ 80 81 /*VARARGS 1*/ 82 void 83 execute(struct command *t, volatile int wanttty, int *pipein, int *pipeout, 84 int do_glob) 85 { 86 int forked = 0; 87 const struct biltins * volatile bifunc; 88 pid_t pid = 0; 89 int pv[2]; 90 sigset_t set; 91 static sigset_t csigset; 92 #ifdef VFORK 93 static int onosigchld = 0; 94 #endif /* VFORK */ 95 static int nosigchld = 0; 96 97 (void) &wanttty; 98 (void) &forked; 99 (void) &bifunc; 100 101 if (t == 0) 102 return; 103 104 #ifdef WINNT_NATIVE 105 { 106 if ((varval(STRNTslowexec) == STRNULL) && 107 !t->t_dcdr && !t->t_dcar && !t->t_dflg && !didfds && 108 (intty || intact) && (t->t_dtyp == NODE_COMMAND) && 109 !isbfunc(t)) { 110 if ((t->t_dcom[0][0] & (QUOTE | TRIM)) == QUOTE) 111 (void) Strcpy(t->t_dcom[0], t->t_dcom[0] + 1); 112 Dfix(t); 113 if (nt_try_fast_exec(t) == 0) 114 return; 115 } 116 } 117 #endif /* WINNT_NATIVE */ 118 119 /* 120 * Ed hutchins@sgi.com & Dominic dbg@sgi.com 121 * Sat Feb 25 03:13:11 PST 1995 122 * try implicit cd if we have a 1 word command 123 */ 124 if (implicit_cd && (intty || intact) && t->t_dcom && t->t_dcom[0] && 125 t->t_dcom[0][0] && (blklen(t->t_dcom) == 1) && !noexec) { 126 Char *sCName; 127 struct stat stbuf; 128 char *pathname; 129 130 sCName = dollar(t->t_dcom[0]); 131 if (sCName != NULL && sCName[0] == '~') { 132 struct Strbuf buf = Strbuf_INIT; 133 const Char *name_end; 134 135 for (name_end = sCName + 1; *name_end != '\0' && *name_end != '/'; 136 name_end++) 137 continue; 138 if (name_end != sCName + 1) { 139 Char *name, *home; 140 141 name = Strnsave(sCName + 1, name_end - (sCName + 1)); 142 home = gethdir(name); 143 if (home != NULL) { 144 Strbuf_append(&buf, home); 145 xfree(home); 146 } else 147 Strbuf_append(&buf, name); 148 xfree(name); 149 } else 150 Strbuf_append(&buf, varval(STRhome)); 151 Strbuf_append(&buf, name_end); 152 xfree(sCName); 153 sCName = Strbuf_finish(&buf); 154 } 155 156 pathname = short2str(sCName); 157 xfree(sCName); 158 /* if this is a dir, tack a "cd" on as the first arg */ 159 if (pathname != NULL && 160 ((stat(pathname, &stbuf) != -1 && S_ISDIR(stbuf.st_mode)) 161 #ifdef WINNT_NATIVE 162 || (pathname[0] && pathname[1] == ':' && pathname[2] == '\0') 163 #endif /* WINNT_NATIVE */ 164 )) { 165 Char *vCD[2]; 166 Char **ot_dcom = t->t_dcom; 167 168 vCD[0] = Strsave(STRcd); 169 vCD[1] = NULL; 170 t->t_dcom = blkspl(vCD, ot_dcom); 171 xfree(ot_dcom); 172 if (implicit_cd > 1) { 173 blkpr(t->t_dcom); 174 xputchar( '\n' ); 175 } 176 } 177 } 178 179 /* 180 * From: Michael Schroeder <mlschroe@immd4.informatik.uni-erlangen.de> 181 * Don't check for wantty > 0... 182 */ 183 if (t->t_dflg & F_AMPERSAND) 184 wanttty = 0; 185 switch (t->t_dtyp) { 186 187 case NODE_COMMAND: 188 if ((t->t_dcom[0][0] & (QUOTE | TRIM)) == QUOTE) 189 memmove(t->t_dcom[0], t->t_dcom[0] + 1, 190 (Strlen(t->t_dcom[0] + 1) + 1) * sizeof (*t->t_dcom[0])); 191 if ((t->t_dflg & F_REPEAT) == 0) 192 Dfix(t); /* $ " ' \ */ 193 if (t->t_dcom[0] == 0) { 194 return; 195 } 196 /*FALLTHROUGH*/ 197 198 case NODE_PAREN: 199 #ifdef BACKPIPE 200 if (t->t_dflg & F_PIPEIN) 201 mypipe(pipein); 202 #else /* !BACKPIPE */ 203 if (t->t_dflg & F_PIPEOUT) 204 mypipe(pipeout); 205 #endif /* BACKPIPE */ 206 /* 207 * Must do << early so parent will know where input pointer should be. 208 * If noexec then this is all we do. 209 */ 210 if (t->t_dflg & F_READ) { 211 int old_pintr_disabled; 212 213 xclose(0); 214 if (setintr) 215 pintr_push_enable(&old_pintr_disabled); 216 heredoc(t->t_dlef); 217 if (setintr) 218 cleanup_until(&old_pintr_disabled); 219 if (noexec) 220 xclose(0); 221 } 222 223 setstatus(0); 224 225 /* 226 * This mess is the necessary kludge to handle the prefix builtins: 227 * nice, nohup, time. These commands can also be used by themselves, 228 * and this is not handled here. This will also work when loops are 229 * parsed. 230 */ 231 while (t->t_dtyp == NODE_COMMAND) 232 if (eq(t->t_dcom[0], STRnice)) { 233 if (t->t_dcom[1]) { 234 if (strchr("+-", t->t_dcom[1][0])) { 235 if (t->t_dcom[2]) { 236 setname("nice"); 237 t->t_nice = (unsigned char)getn(t->t_dcom[1]); 238 lshift(t->t_dcom, 2); 239 t->t_dflg |= F_NICE; 240 } 241 else 242 break; 243 } 244 else { 245 t->t_nice = 4; 246 lshift(t->t_dcom, 1); 247 t->t_dflg |= F_NICE; 248 } 249 } 250 else 251 break; 252 } 253 else if (eq(t->t_dcom[0], STRnohup)) { 254 if (t->t_dcom[1]) { 255 t->t_dflg |= F_NOHUP; 256 lshift(t->t_dcom, 1); 257 } 258 else 259 break; 260 } 261 else if (eq(t->t_dcom[0], STRhup)) { 262 if (t->t_dcom[1]) { 263 t->t_dflg |= F_HUP; 264 lshift(t->t_dcom, 1); 265 } 266 else 267 break; 268 } 269 else if (eq(t->t_dcom[0], STRtime)) { 270 if (t->t_dcom[1]) { 271 t->t_dflg |= F_TIME; 272 lshift(t->t_dcom, 1); 273 } 274 else 275 break; 276 } 277 #ifdef F_VER 278 else if (eq(t->t_dcom[0], STRver)) 279 if (t->t_dcom[1] && t->t_dcom[2]) { 280 setname("ver"); 281 t->t_systype = getv(t->t_dcom[1]); 282 lshift(t->t_dcom, 2); 283 t->t_dflg |= F_VER; 284 } 285 else 286 break; 287 #endif /* F_VER */ 288 else 289 break; 290 291 /* is it a command */ 292 if (t->t_dtyp == NODE_COMMAND) { 293 /* 294 * Check if we have a builtin function and remember which one. 295 */ 296 bifunc = isbfunc(t); 297 if (noexec) { 298 /* 299 * Continue for builtins that are part of the scripting language 300 */ 301 if (bifunc == NULL) 302 break; 303 if (bifunc->bfunct != (bfunc_t)dobreak && 304 bifunc->bfunct != (bfunc_t)docontin && 305 bifunc->bfunct != (bfunc_t)doelse && 306 bifunc->bfunct != (bfunc_t)doend && 307 bifunc->bfunct != (bfunc_t)doforeach&& 308 bifunc->bfunct != (bfunc_t)dogoto && 309 bifunc->bfunct != (bfunc_t)doif && 310 bifunc->bfunct != (bfunc_t)dorepeat && 311 bifunc->bfunct != (bfunc_t)doswbrk && 312 bifunc->bfunct != (bfunc_t)doswitch && 313 bifunc->bfunct != (bfunc_t)dowhile && 314 bifunc->bfunct != (bfunc_t)dozip) 315 break; 316 } 317 } 318 else { /* not a command */ 319 bifunc = NULL; 320 if (noexec) 321 break; 322 } 323 324 /* 325 * GrP Executing a command - run jobcmd hook 326 * Don't run for builtins 327 * Don't run if we're not in a tty 328 * Don't run if we're not really executing 329 */ 330 /* 331 * CR - Charles Ross Aug 2005 332 * added "isoutatty". 333 * The new behavior is that the jobcmd won't be executed 334 * if stdout (SHOUT) isnt attached to a tty.. IE when 335 * redirecting, or using backquotes etc.. 336 */ 337 if (t->t_dtyp == NODE_COMMAND && !bifunc && !noexec && intty && isoutatty) { 338 Char *cmd = unparse(t); 339 340 cleanup_push(cmd, xfree); 341 job_cmd(cmd); 342 cleanup_until(cmd); 343 } 344 345 /* 346 * We fork only if we are timed, or are not the end of a parenthesized 347 * list and not a simple builtin function. Simple meaning one that is 348 * not pipedout, niced, nohupped, or &'d. It would be nice(?) to not 349 * fork in some of these cases. 350 */ 351 #ifdef BACKPIPE 352 /* 353 * Can't have NOFORK for the tail of a pipe - because it is not the 354 * last command spawned (even if it is at the end of a parenthesised 355 * list). 356 */ 357 if (t->t_dflg & F_PIPEIN) 358 t->t_dflg &= ~(F_NOFORK); 359 #else 360 /* 361 * "command | builtin" may cause major misbehaviour as noted in 362 * in the BUGS file entry 363 * Subject: Redirected input to built-in functions misbehaves badly 364 * forking when the builtin is the end of the pipe corrects the 365 * problem. 366 */ 367 if (bifunc && (t->t_dflg & F_PIPEIN)) 368 t->t_dflg &= ~(F_NOFORK); 369 #endif /* BACKPIPE */ 370 /* 371 * Prevent forking cd, pushd, popd, chdir cause this will cause the 372 * shell not to change dir! (XXX: but only for nice?) 373 */ 374 if (bifunc && (bifunc->bfunct == (bfunc_t)dochngd || 375 bifunc->bfunct == (bfunc_t)dopushd || 376 bifunc->bfunct == (bfunc_t)dopopd)) 377 t->t_dflg &= ~(F_NICE); 378 379 if (((t->t_dflg & F_TIME) || ((t->t_dflg & F_NOFORK) == 0 && 380 (!bifunc || t->t_dflg & 381 (F_PIPEOUT | F_AMPERSAND | F_NICE | F_NOHUP | F_HUP)))) || 382 /* 383 * We have to fork for eval too. 384 */ 385 (bifunc && (t->t_dflg & F_PIPEIN) != 0 && 386 bifunc->bfunct == (bfunc_t)doeval)) { 387 #ifdef VFORK 388 if (t->t_dtyp == NODE_PAREN || 389 t->t_dflg & (F_REPEAT | F_AMPERSAND) || bifunc) 390 #endif /* VFORK */ 391 { 392 forked++; 393 /* 394 * We need to block SIGCHLD here, so that if the process does 395 * not die before we can set the process group 396 */ 397 if (wanttty >= 0 && !nosigchld) { 398 sigemptyset(&set); 399 sigaddset(&set, SIGCHLD); 400 (void)sigprocmask(SIG_BLOCK, &set, &csigset); 401 402 nosigchld = 1; 403 } 404 405 pid = pfork(t, wanttty); 406 if (pid == 0 && nosigchld) { 407 sigprocmask(SIG_SETMASK, &csigset, NULL); 408 nosigchld = 0; 409 } 410 else if (pid != 0 && (t->t_dflg & F_AMPERSAND)) 411 backpid = pid; 412 } 413 414 #ifdef VFORK 415 else { 416 int ochild, osetintr, ohaderr, odidfds; 417 int oSHIN, oSHOUT, oSHDIAG, oOLDSTD, otpgrp; 418 int oisoutatty, oisdiagatty; 419 sigset_t oset, ocsigset; 420 # ifndef CLOSE_ON_EXEC 421 int odidcch; 422 # endif /* !CLOSE_ON_EXEC */ 423 424 /* 425 * Prepare for the vfork by saving everything that the child 426 * corrupts before it exec's. Note that in some signal 427 * implementations which keep the signal info in user space 428 * (e.g. Sun's) it will also be necessary to save and restore 429 * the current sigvec's for the signals the child touches 430 * before it exec's. 431 */ 432 433 /* 434 * Sooooo true... If this is a Sun, save the sigvec's. (Skip 435 * Gilbrech - 11/22/87) 436 */ 437 # ifdef SAVESIGVEC 438 struct sigaction savesv[NSIGSAVED]; 439 sigset_t savesm; 440 441 # endif /* SAVESIGVEC */ 442 if (wanttty >= 0 && !nosigchld && !noexec) { 443 sigemptyset(&set); 444 sigaddset(&set, SIGCHLD); 445 (void)sigprocmask(SIG_BLOCK, &set, &csigset); 446 nosigchld = 1; 447 } 448 sigemptyset(&set); 449 sigaddset(&set, SIGCHLD); 450 sigaddset(&set, SIGINT); 451 (void)sigprocmask(SIG_BLOCK, &set, &oset); 452 ochild = child; 453 osetintr = setintr; 454 ohaderr = haderr; 455 odidfds = didfds; 456 # ifndef CLOSE_ON_EXEC 457 odidcch = didcch; 458 # endif /* !CLOSE_ON_EXEC */ 459 oSHIN = SHIN; 460 oSHOUT = SHOUT; 461 oSHDIAG = SHDIAG; 462 oOLDSTD = OLDSTD; 463 otpgrp = tpgrp; 464 oisoutatty = isoutatty; 465 oisdiagatty = isdiagatty; 466 ocsigset = csigset; 467 onosigchld = nosigchld; 468 Vsav = Vdp = 0; 469 Vexpath = 0; 470 Vt = 0; 471 # ifdef SAVESIGVEC 472 savesigvec(savesv, savesm); 473 # endif /* SAVESIGVEC */ 474 if (use_fork) 475 pid = fork(); 476 else 477 pid = vfork(); 478 479 if (pid < 0) { 480 # ifdef SAVESIGVEC 481 restoresigvec(savesv, savesm); 482 # endif /* SAVESIGVEC */ 483 sigprocmask(SIG_SETMASK, &oset, NULL); 484 stderror(ERR_NOPROC); 485 } 486 forked++; 487 if (pid) { /* parent */ 488 # ifdef SAVESIGVEC 489 restoresigvec(savesv, savesm); 490 # endif /* SAVESIGVEC */ 491 child = ochild; 492 setintr = osetintr; 493 haderr = ohaderr; 494 didfds = odidfds; 495 SHIN = oSHIN; 496 # ifndef CLOSE_ON_EXEC 497 didcch = odidcch; 498 # endif /* !CLOSE_ON_EXEC */ 499 SHOUT = oSHOUT; 500 SHDIAG = oSHDIAG; 501 OLDSTD = oOLDSTD; 502 tpgrp = otpgrp; 503 isoutatty = oisoutatty; 504 isdiagatty = oisdiagatty; 505 csigset = ocsigset; 506 nosigchld = onosigchld; 507 508 xfree(Vsav); 509 Vsav = 0; 510 xfree(Vdp); 511 Vdp = 0; 512 xfree(Vexpath); 513 Vexpath = 0; 514 blk_cleanup(Vt); 515 Vt = 0; 516 /* this is from pfork() */ 517 palloc(pid, t); 518 sigprocmask(SIG_SETMASK, &oset, NULL); 519 } 520 else { /* child */ 521 /* this is from pfork() */ 522 pid_t pgrp; 523 int ignint = 0; 524 if (nosigchld) { 525 sigprocmask(SIG_SETMASK, &csigset, NULL); 526 nosigchld = 0; 527 } 528 529 if (setintr) 530 ignint = (tpgrp == -1 && (t->t_dflg & F_NOINTERRUPT)) 531 || (gointr && eq(gointr, STRminus)); 532 pgrp = pcurrjob ? pcurrjob->p_jobid : getpid(); 533 child++; 534 if (setintr) { 535 setintr = 0; 536 /* 537 * casts made right for SunOS 4.0 by Douglas C. Schmidt 538 * <schmidt%sunshine.ics.uci.edu@ROME.ICS.UCI.EDU> 539 * (thanks! -- PWP) 540 * 541 * ignint ifs cleaned by Johan Widen <mcvax!osiris.sics.se!jw@uunet.UU.NET> 542 * (thanks again) 543 */ 544 if (ignint) { 545 (void) signal(SIGINT, SIG_IGN); 546 (void) signal(SIGQUIT, SIG_IGN); 547 } 548 else { 549 (void) signal(SIGINT, vffree); 550 (void) signal(SIGQUIT, SIG_DFL); 551 } 552 # ifdef BSDJOBS 553 if (wanttty >= 0) { 554 (void) signal(SIGTSTP, SIG_DFL); 555 (void) signal(SIGTTIN, SIG_DFL); 556 (void) signal(SIGTTOU, SIG_DFL); 557 } 558 # endif /* BSDJOBS */ 559 560 sigaction(SIGTERM, &parterm, NULL); 561 } 562 else if (tpgrp == -1 && 563 (t->t_dflg & F_NOINTERRUPT)) { 564 (void) signal(SIGINT, SIG_IGN); 565 (void) signal(SIGQUIT, SIG_IGN); 566 } 567 568 pgetty(wanttty, pgrp); 569 570 if (t->t_dflg & F_NOHUP) 571 (void) signal(SIGHUP, SIG_IGN); 572 if (t->t_dflg & F_HUP) 573 (void) signal(SIGHUP, SIG_DFL); 574 if (t->t_dflg & F_NICE) { 575 int nval = SIGN_EXTEND_CHAR(t->t_nice); 576 # if defined(HAVE_SETPRIORITY) && defined(PRIO_PROCESS) 577 if (setpriority(PRIO_PROCESS, 0, nval) == -1 && errno) 578 stderror(ERR_SYSTEM, "setpriority", 579 strerror(errno)); 580 # else /* !HAVE_SETPRIORITY || !PRIO_PROCESS */ 581 (void) nice(nval); 582 # endif /* HAVE_SETPRIORITY && PRIO_PROCESS */ 583 } 584 # ifdef F_VER 585 if (t->t_dflg & F_VER) { 586 tsetenv(STRSYSTYPE, t->t_systype ? STRbsd43 : STRsys53); 587 dohash(NULL, NULL); 588 } 589 # endif /* F_VER */ 590 } 591 592 } 593 #endif /* VFORK */ 594 } 595 if (pid != 0) { 596 /* 597 * It would be better if we could wait for the whole job when we 598 * knew the last process had been started. Pwait, in fact, does 599 * wait for the whole job anyway, but this test doesn't really 600 * express our intentions. 601 */ 602 #ifdef BACKPIPE 603 if (didfds == 0 && t->t_dflg & F_PIPEOUT) { 604 xclose(pipeout[0]); 605 xclose(pipeout[1]); 606 } 607 if ((t->t_dflg & F_PIPEIN) != 0) 608 break; 609 #else /* !BACKPIPE */ 610 if (didfds == 0 && t->t_dflg & F_PIPEIN) { 611 xclose(pipein[0]); 612 xclose(pipein[1]); 613 } 614 if ((t->t_dflg & F_PIPEOUT) != 0) 615 break; 616 #endif /* BACKPIPE */ 617 618 if (nosigchld) { 619 sigprocmask(SIG_SETMASK, &csigset, NULL); 620 nosigchld = 0; 621 } 622 if ((t->t_dflg & F_AMPERSAND) == 0) 623 pwait(); 624 break; 625 } 626 627 doio(t, pipein, pipeout); 628 #ifdef BACKPIPE 629 if (t->t_dflg & F_PIPEIN) { 630 xclose(pipein[0]); 631 xclose(pipein[1]); 632 } 633 #else /* !BACKPIPE */ 634 if (t->t_dflg & F_PIPEOUT) { 635 xclose(pipeout[0]); 636 xclose(pipeout[1]); 637 } 638 #endif /* BACKPIPE */ 639 /* 640 * Perform a builtin function. If we are not forked, arrange for 641 * possible stopping 642 */ 643 if (bifunc) { 644 if (forked) { 645 func(t, bifunc); 646 exitstat(); 647 } else { 648 jmp_buf_t oldexit; 649 int ohaderr = haderr; 650 651 getexit(oldexit); 652 if (setexit() == 0) 653 func(t, bifunc); 654 resexit(oldexit); 655 haderr = ohaderr; 656 657 if (adrof(STRprintexitvalue)) { 658 int rv = getstatus(); 659 if (rv != 0) 660 xprintf(CGETS(17, 2, "Exit %d\n"), rv); 661 } 662 } 663 break; 664 } 665 if (t->t_dtyp != NODE_PAREN) { 666 doexec(t, do_glob); 667 /* NOTREACHED */ 668 } 669 /* 670 * For () commands must put new 0,1,2 in FSH* and recurse 671 */ 672 if ((OLDSTD = dcopy(0, FOLDSTD)) >= 0) 673 (void)close_on_exec(OLDSTD, 1); 674 if ((SHOUT = dcopy(1, FSHOUT)) >= 0) { 675 (void)close_on_exec(SHOUT, 1); 676 isoutatty = isatty(SHOUT); 677 } 678 if ((SHDIAG = dcopy(2, FSHDIAG)) >= 0) { 679 (void)close_on_exec(SHDIAG, 1); 680 isdiagatty = isatty(SHDIAG); 681 } 682 xclose(SHIN); 683 SHIN = -1; 684 #ifndef CLOSE_ON_EXEC 685 didcch = 0; 686 #else 687 (void) close_on_exec(FSHOUT, 1); 688 (void) close_on_exec(FSHDIAG, 1); 689 (void) close_on_exec(FOLDSTD, 1); 690 #endif /* !CLOSE_ON_EXEC */ 691 didfds = 0; 692 wanttty = -1; 693 t->t_dspr->t_dflg |= t->t_dflg & (F_NOINTERRUPT | F_BACKQ); 694 execute(t->t_dspr, wanttty, NULL, NULL, do_glob); 695 exitstat(); 696 697 case NODE_PIPE: 698 #ifdef BACKPIPE 699 t->t_dcdr->t_dflg |= F_PIPEIN | (t->t_dflg & 700 (F_PIPEOUT | F_AMPERSAND | F_NOFORK | F_NOINTERRUPT | F_BACKQ)); 701 execute(t->t_dcdr, wanttty, pv, pipeout, do_glob); 702 t->t_dcar->t_dflg |= F_PIPEOUT | (t->t_dflg & 703 (F_PIPEIN | F_AMPERSAND | F_STDERR | F_NOINTERRUPT | F_BACKQ)); 704 execute(t->t_dcar, wanttty, pipein, pv, do_glob); 705 #else /* !BACKPIPE */ 706 t->t_dcar->t_dflg |= F_PIPEOUT | (t->t_dflg & 707 (F_PIPEIN | F_AMPERSAND | F_STDERR | F_NOINTERRUPT | F_BACKQ)); 708 execute(t->t_dcar, wanttty, pipein, pv, do_glob); 709 t->t_dcdr->t_dflg |= F_PIPEIN | (t->t_dflg & 710 (F_PIPEOUT | F_AMPERSAND | F_NOFORK | F_NOINTERRUPT | F_BACKQ)); 711 execute(t->t_dcdr, wanttty, pv, pipeout, do_glob); 712 #endif /* BACKPIPE */ 713 break; 714 715 case NODE_LIST: 716 if (t->t_dcar) { 717 t->t_dcar->t_dflg |= t->t_dflg & (F_NOINTERRUPT | F_BACKQ); 718 execute(t->t_dcar, wanttty, NULL, NULL, do_glob); 719 /* 720 * In strange case of A&B make a new job after A 721 */ 722 if (t->t_dcar->t_dflg & F_AMPERSAND && t->t_dcdr && 723 (t->t_dcdr->t_dflg & F_AMPERSAND) == 0) 724 pendjob(); 725 } 726 if (t->t_dcdr) { 727 t->t_dcdr->t_dflg |= t->t_dflg & 728 (F_NOFORK | F_NOINTERRUPT | F_BACKQ); 729 execute(t->t_dcdr, wanttty, NULL, NULL, do_glob); 730 } 731 break; 732 733 case NODE_OR: 734 case NODE_AND: 735 if (t->t_dcar) { 736 t->t_dcar->t_dflg |= t->t_dflg & (F_NOINTERRUPT | F_BACKQ); 737 execute(t->t_dcar, wanttty, NULL, NULL, do_glob); 738 if ((getstatus() == 0) != (t->t_dtyp == NODE_AND)) { 739 return; 740 } 741 } 742 if (t->t_dcdr) { 743 t->t_dcdr->t_dflg |= t->t_dflg & 744 (F_NOFORK | F_NOINTERRUPT | F_BACKQ); 745 execute(t->t_dcdr, wanttty, NULL, NULL, do_glob); 746 } 747 break; 748 749 default: 750 break; 751 } 752 /* 753 * Fall through for all breaks from switch 754 * 755 * If there will be no more executions of this command, flush all file 756 * descriptors. Places that turn on the F_REPEAT bit are responsible for 757 * doing donefds after the last re-execution 758 */ 759 if (didfds && !(t->t_dflg & F_REPEAT)) 760 donefds(); 761 } 762 763 #ifdef VFORK 764 static void 765 /*ARGSUSED*/ 766 vffree(int snum) 767 { 768 USE(snum); 769 770 _exit(1); 771 } 772 #endif /* VFORK */ 773 774 /* 775 * Expand and glob the words after an i/o redirection. 776 * If more than one word is generated, then update the command vector. 777 * 778 * This is done differently in all the shells: 779 * 1. in the bourne shell and ksh globbing is not performed 780 * 2. Bash/csh say ambiguous 781 * 3. zsh does i/o to/from all the files 782 * 4. itcsh concatenates the words. 783 * 784 * I don't know what is best to do. I think that Ambiguous is better 785 * than restructuring the command vector, because the user can get 786 * unexpected results. In any case, the command vector restructuring 787 * code is present and the user can choose it by setting noambiguous 788 */ 789 static Char * 790 splicepipe(struct command *t, Char *cp) 791 { 792 Char *blk[2]; 793 794 if (adrof(STRnoambiguous)) { 795 Char **pv; 796 int gflag; 797 798 blk[0] = Dfix1(cp); /* expand $ */ 799 blk[1] = NULL; 800 801 gflag = tglob(blk); 802 if (gflag) { 803 pv = globall(blk, gflag); 804 if (pv == NULL) { 805 setname(short2str(blk[0])); 806 xfree(blk[0]); 807 stderror(ERR_NAME | ERR_NOMATCH); 808 } 809 if (pv[1] != NULL) { /* we need to fix the command vector */ 810 Char **av = blkspl(t->t_dcom, &pv[1]); 811 xfree(t->t_dcom); 812 t->t_dcom = av; 813 } 814 xfree(blk[0]); 815 blk[0] = pv[0]; 816 xfree(pv); 817 } 818 } 819 else { 820 Char *buf; 821 822 buf = Dfix1(cp); 823 cleanup_push(buf, xfree); 824 blk[0] = globone(buf, G_ERROR); 825 cleanup_until(buf); 826 } 827 return(blk[0]); 828 } 829 830 /* 831 * Perform io redirection. 832 * We may or maynot be forked here. 833 */ 834 static void 835 doio(struct command *t, int *pipein, int *pipeout) 836 { 837 int fd; 838 Char *cp; 839 unsigned long flags = t->t_dflg; 840 841 if (didfds || (flags & F_REPEAT)) 842 return; 843 if ((flags & F_READ) == 0) {/* F_READ already done */ 844 if (t->t_dlef) { 845 char *tmp; 846 847 /* 848 * so < /dev/std{in,out,err} work 849 */ 850 (void) dcopy(SHIN, 0); 851 (void) dcopy(SHOUT, 1); 852 (void) dcopy(SHDIAG, 2); 853 cp = splicepipe(t, t->t_dlef); 854 tmp = strsave(short2str(cp)); 855 xfree(cp); 856 cleanup_push(tmp, xfree); 857 if ((fd = xopen(tmp, O_RDONLY|O_LARGEFILE)) < 0) 858 stderror(ERR_SYSTEM, tmp, strerror(errno)); 859 cleanup_until(tmp); 860 /* allow input files larger than 2Gb */ 861 #ifndef WINNT_NATIVE 862 (void) fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_LARGEFILE); 863 #endif /*!WINNT_NATIVE*/ 864 (void) dmove(fd, 0); 865 } 866 else if (flags & F_PIPEIN) { 867 xclose(0); 868 TCSH_IGNORE(dup(pipein[0])); 869 xclose(pipein[0]); 870 xclose(pipein[1]); 871 } 872 else if ((flags & F_NOINTERRUPT) && tpgrp == -1) { 873 xclose(0); 874 (void) xopen(_PATH_DEVNULL, O_RDONLY|O_LARGEFILE); 875 } 876 else { 877 xclose(0); 878 TCSH_IGNORE(dup(OLDSTD)); 879 #if defined(CLOSE_ON_EXEC) && defined(CLEX_DUPS) 880 /* 881 * PWP: Unlike Bezerkeley 4.3, FIONCLEX for Pyramid is preserved 882 * across dup()s, so we have to UNSET it here or else we get a 883 * command with NO stdin, stdout, or stderr at all (a bad thing 884 * indeed) 885 */ 886 (void) close_on_exec(0, 0); 887 #endif /* CLOSE_ON_EXEC && CLEX_DUPS */ 888 } 889 } 890 if (t->t_drit) { 891 char *tmp; 892 893 cp = splicepipe(t, t->t_drit); 894 tmp = strsave(short2str(cp)); 895 xfree(cp); 896 cleanup_push(tmp, xfree); 897 /* 898 * so > /dev/std{out,err} work 899 */ 900 (void) dcopy(SHOUT, 1); 901 (void) dcopy(SHDIAG, 2); 902 if ((flags & F_APPEND) != 0) { 903 #ifdef O_APPEND 904 fd = xopen(tmp, O_WRONLY|O_APPEND|O_LARGEFILE); 905 #else /* !O_APPEND */ 906 fd = xopen(tmp, O_WRONLY|O_LARGEFILE); 907 (void) lseek(fd, (off_t) 0, L_XTND); 908 #endif /* O_APPEND */ 909 } 910 else 911 fd = 0; 912 if ((flags & F_APPEND) == 0 || fd == -1) { 913 if (!(flags & F_OVERWRITE) && no_clobber) { 914 if (flags & F_APPEND) 915 stderror(ERR_SYSTEM, tmp, strerror(errno)); 916 chkclob(tmp); 917 } 918 if ((fd = xcreat(tmp, 0666)) < 0) 919 stderror(ERR_SYSTEM, tmp, strerror(errno)); 920 /* allow input files larger than 2Gb */ 921 #ifndef WINNT_NATIVE 922 (void) fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_LARGEFILE); 923 #endif /*!WINNT_NATIVE*/ 924 } 925 cleanup_until(tmp); 926 (void) dmove(fd, 1); 927 is1atty = isatty(1); 928 } 929 else if (flags & F_PIPEOUT) { 930 xclose(1); 931 TCSH_IGNORE(dup(pipeout[1])); 932 is1atty = 0; 933 } 934 else { 935 xclose(1); 936 TCSH_IGNORE(dup(SHOUT)); 937 is1atty = isoutatty; 938 # if defined(CLOSE_ON_EXEC) && defined(CLEX_DUPS) 939 (void) close_on_exec(1, 0); 940 # endif /* CLOSE_ON_EXEC && CLEX_DUPS */ 941 } 942 943 xclose(2); 944 if (flags & F_STDERR) { 945 TCSH_IGNORE(dup(1)); 946 is2atty = is1atty; 947 } 948 else { 949 TCSH_IGNORE(dup(SHDIAG)); 950 is2atty = isdiagatty; 951 # if defined(CLOSE_ON_EXEC) && defined(CLEX_DUPS) 952 (void) close_on_exec(2, 0); 953 # endif /* CLOSE_ON_EXEC && CLEX_DUPS */ 954 } 955 didfds = 1; 956 } 957 958 void 959 mypipe(int *pv) 960 { 961 962 if (pipe(pv) < 0) 963 goto oops; 964 (void)close_on_exec(pv[0] = dmove(pv[0], -1), 1); 965 (void)close_on_exec(pv[1] = dmove(pv[1], -1), 1); 966 if (pv[0] >= 0 && pv[1] >= 0) 967 return; 968 if (pv[0] >= 0) 969 xclose(pv[0]); 970 if (pv[1] >= 0) 971 xclose(pv[1]); 972 oops: 973 stderror(ERR_PIPE); 974 } 975 976 static void 977 chkclob(const char *cp) 978 { 979 struct stat stb; 980 981 if (stat(cp, &stb) < 0) 982 return; 983 if (S_ISCHR(stb.st_mode)) 984 return; 985 if (no_clobber & NOCLOBBER_NOTEMPTY && stb.st_size == 0) 986 return; 987 if (no_clobber & NOCLOBBER_ASK) { 988 if (getYN(CGETS(22, 15, 989 "Do you really want to overwrite an existing file? [N/y] "))) 990 return; 991 } 992 993 stderror(ERR_EXISTS, cp); 994 } 995