contrib/tcsh/sh.proc.c

   1 /* $Header: /src/pub/tcsh/sh.proc.c,v 3.81 2003/11/09 03:02:46 christos Exp $ */
   2 /*
   3  * sh.proc.c: Job manipulations
   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
  35 RCSID("$Id: sh.proc.c,v 3.81 2003/11/09 03:02:46 christos Exp $")
  36
  37 #include "ed.h"
  38 #include "tc.h"
  39 #include "tc.wait.h"
  40
  41 #ifdef WINNT_NATIVE
  42 #undef POSIX
  43 #define POSIX
  44 #endif /* WINNT_NATIVE */
  45 #ifdef aiws
  46 # undef HZ
  47 # define HZ 16
  48 #endif /* aiws */
  49
  50 #if defined(_BSD) || (defined(IRIS4D) && __STDC__) || defined(__lucid) || defined(linux)
  51 # define BSDWAIT
  52 #endif /* _BSD || (IRIS4D && __STDC__) || __lucid || linux */
  53 #ifndef WTERMSIG
  54 # define WTERMSIG(w)    (((union wait *) &(w))->w_termsig)
  55 # ifndef BSDWAIT
  56 #  define BSDWAIT
  57 # endif /* !BSDWAIT */
  58 #endif /* !WTERMSIG */
  59 #ifndef WEXITSTATUS
  60 # define WEXITSTATUS(w) (((union wait *) &(w))->w_retcode)
  61 #endif /* !WEXITSTATUS */
  62 #ifndef WSTOPSIG
  63 # define WSTOPSIG(w)    (((union wait *) &(w))->w_stopsig)
  64 #endif /* !WSTOPSIG */
  65
  66 #ifdef __osf__
  67 # ifndef WCOREDUMP
  68 #  define WCOREDUMP(x) (_W_INT(x) & WCOREFLAG)
  69 # endif
  70 #endif
  71
  72 #ifndef WCOREDUMP
  73 # ifdef BSDWAIT
  74 #  define WCOREDUMP(w)  (((union wait *) &(w))->w_coredump)
  75 # else /* !BSDWAIT */
  76 #  define WCOREDUMP(w)  ((w) & 0200)
  77 # endif /* !BSDWAIT */
  78 #endif /* !WCOREDUMP */
  79
  80 /*
  81  * C Shell - functions that manage processes, handling hanging, termination
  82  */
  83
  84 #define BIGINDEX        9       /* largest desirable job index */
  85
  86 #ifdef BSDTIMES
  87 # ifdef convex
  88 /* use 'cvxrusage' to get parallel statistics */
  89 static struct cvxrusage zru = {{0L, 0L}, {0L, 0L}, 0L, 0L, 0L, 0L,
  90                                 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
  91                                 {0L, 0L}, 0LL, 0LL, 0LL, 0LL, 0L, 0L, 0L,
  92                                 0LL, 0LL, {0L, 0L, 0L, 0L, 0L}};
  93 # else
  94 #  if defined(SUNOS4) || defined(hp9000) || (defined(__alpha) && defined(__osf__))
  95 static struct rusage zru = {{0L, 0L}, {0L, 0L}, 0L, 0L, 0L, 0L,
  96                             0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L};
  97
  98 #  else /* !SUNOS4 && !hp9000 && !(__alpha && __osf__) */
  99 #   ifdef masscomp
 100 /*
 101  * Initialization of this structure under RTU 4.1A & RTU 5.0 is problematic
 102  * because the first two elements are unions of a time_t and a struct timeval.
 103  * So we'll just have to trust the loader to do the "right thing", DAS DEC-90.
 104  */
 105 static struct rusage zru;
 106 #   else        /* masscomp */
 107 static struct rusage zru = {{0L, 0L}, {0L, 0L}, 0, 0, 0, 0, 0, 0, 0,
 108                             0, 0, 0, 0, 0, 0};
 109 #   endif /* masscomp */
 110 #  endif        /* SUNOS4 || hp9000 || (__alpha && __osf__) */
 111 # endif /* convex */
 112 #else /* !BSDTIMES */
 113 # ifdef _SEQUENT_
 114 static struct process_stats zru = {{0L, 0L}, {0L, 0L}, 0, 0, 0, 0, 0, 0, 0,
 115                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 116 # else /* !_SEQUENT_ */
 117 #  ifdef _SX
 118 static struct tms zru = {0, 0, 0, 0}, lru = {0, 0, 0, 0};
 119 #  else /* !_SX */
 120 static struct tms zru = {0L, 0L, 0L, 0L}, lru = {0L, 0L, 0L, 0L};
 121 #  endif        /* !_SX */
 122 # endif /* !_SEQUENT_ */
 123 #endif /* !BSDTIMES */
 124
 125 #ifndef RUSAGE_CHILDREN
 126 # define        RUSAGE_CHILDREN -1
 127 #endif /* RUSAGE_CHILDREN */
 128
 129 static  void             pflushall      __P((void));
 130 static  void             pflush         __P((struct process *));
 131 static  void             pfree          __P((struct process *));
 132 static  void             pclrcurr       __P((struct process *));
 133 static  void             padd           __P((struct command *));
 134 static  int              pprint         __P((struct process *, int));
 135 static  void             ptprint        __P((struct process *));
 136 static  void             pads           __P((Char *));
 137 static  void             pkill          __P((Char **, int));
 138 static  struct process  *pgetcurr       __P((struct process *));
 139 static  void             okpcntl        __P((void));
 140 static  void             setttypgrp     __P((int));
 141
 142 /*
 143  * pchild - called at interrupt level by the SIGCHLD signal
 144  *      indicating that at least one child has terminated or stopped
 145  *      thus at least one wait system call will definitely return a
 146  *      childs status.  Top level routines (like pwait) must be sure
 147  *      to mask interrupts when playing with the proclist data structures!
 148  */
 149 sigret_t
 150 /*ARGSUSED*/
 151 pchild(snum)
 152 int snum;
 153 {
 154     register struct process *pp;
 155     register struct process *fp;
 156     register int pid;
 157 #if defined(BSDJOBS) || (!defined(BSDTIMES) && (defined(ODT) || defined(aiws) || defined(uts)))
 158     extern int insource;
 159 #endif /* BSDJOBS || (!BSDTIMES && (ODT || aiws || uts)) */
 160 #ifdef BSDWAIT
 161     union wait w;
 162 #else /* !BSDWAIT */
 163     int     w;
 164 #endif /* !BSDWAIT */
 165     int     jobflags;
 166 #ifdef BSDTIMES
 167     struct sysrusage ru;
 168 #else /* !BSDTIMES */
 169 # ifdef _SEQUENT_
 170     struct process_stats ru;
 171     struct process_stats cpst1, cpst2;
 172     timeval_t tv;
 173 # else /* !_SEQUENT_ */
 174     struct tms proctimes;
 175
 176     USE(snum);
 177     if (!timesdone) {
 178         timesdone++;
 179         (void) times(&shtimes);
 180     }
 181 # endif /* !_SEQUENT_ */
 182 #endif /* !BSDTIMES */
 183
 184 #ifdef JOBDEBUG
 185     xprintf("pchild()\n");
 186 #endif  /* JOBDEBUG */
 187
 188 /* Christos on where the signal(SIGCHLD, pchild) shoud be:
 189  *
 190  * I think that it should go *after* the wait, unlike most signal handlers.
 191  *
 192  * In release two (for which I have manuals), it says that wait will remove
 193  * the first child from the queue of dead children.
 194  * All the rest of the children that die while in the signal handler of the
 195  * SIGC(H)LD, will be placed in the queue. If signal is called to re-establish
 196  * the signal handler, and there are items in the queue, the process will
 197  * receive another SIGC(H)LD before signal returns. BTW this is from the
 198  * manual page on comp-sim... Maybe it is not applicable to the hp's, but
 199  * I read on the news in comp.unix.wizards or comp.unix.questions yesterday
 200  * that another person was claiming the the signal() call should be after
 201  * the wait().
 202  */
 203
 204 loop:
 205     errno = 0;                  /* reset, just in case */
 206 #ifdef JOBDEBUG
 207     xprintf("Waiting...\n");
 208     flush();
 209 #endif /* JOBDEBUG */
 210 #ifndef WINNT_NATIVE
 211 # ifdef BSDJOBS
 212 #  ifdef BSDTIMES
 213 #   ifdef convex
 214     /* use 'cvxwait' to get parallel statistics */
 215     pid = cvxwait(&w,
 216         (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG), &ru);
 217 #   else
 218     /* both a wait3 and rusage */
 219 #    if !defined(BSDWAIT) || defined(NeXT) || defined(MACH) || defined(linux) || (defined(IRIS4D) && (__STDC__ || defined(FUNCPROTO)) && SYSVREL <= 3) || defined(__lucid) || defined(__osf__)
 220     pid = wait3(&w,
 221        (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG), &ru);
 222 #    else /* BSDWAIT */
 223     pid = wait3(&w.w_status,
 224        (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG), &ru);
 225 #    endif /* BSDWAIT */
 226 #   endif /* convex */
 227 #  else /* !BSDTIMES */
 228 #   ifdef _SEQUENT_
 229     (void) get_process_stats(&tv, PS_SELF, 0, &cpst1);
 230     pid = waitpid(-1, &w,
 231             (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG));
 232     (void) get_process_stats(&tv, PS_SELF, 0, &cpst2);
 233     pr_stat_sub(&cpst2, &cpst1, &ru);
 234 #   else        /* !_SEQUENT_ */
 235 #    ifndef POSIX
 236     /* we have a wait3, but no rusage stuff */
 237     pid = wait3(&w.w_status,
 238          (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG), 0);
 239 #    else /* POSIX */
 240     pid = waitpid(-1, &w,
 241             (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG));
 242 #    endif /* POSIX */
 243 #   endif /* !_SEQUENT_ */
 244 #  endif        /* !BSDTIMES */
 245 # else /* !BSDJOBS */
 246 #  ifdef BSDTIMES
 247 #   define HAVEwait3
 248     /* both a wait3 and rusage */
 249 #   ifdef hpux
 250     pid = wait3(&w.w_status, WNOHANG, 0);
 251 #   else        /* !hpux */
 252     pid = wait3(&w.w_status, WNOHANG, &ru);
 253 #   endif /* !hpux */
 254 #  else /* !BSDTIMES */
 255 #   ifdef ODT  /* For Sco Unix 3.2.0 or ODT 1.0 */
 256 #    define HAVEwait3
 257      pid = waitpid(-1, &w,
 258             (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG));
 259 #   endif /* ODT */
 260 #   if defined(aiws) || defined(uts)
 261 #    define HAVEwait3
 262     pid = wait3(&w.w_status,
 263         (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG), 0);
 264 #   endif /* aiws || uts */
 265 #   ifndef HAVEwait3
 266 #    ifdef UNRELSIGS
 267      /* no wait3, therefore no rusage */
 268      /* on Sys V, this may hang.  I hope it's not going to be a problem */
 269 #     ifdef _MINIX
 270       pid = wait(&w);
 271 #     else /* !_MINIX */
 272       pid = ourwait(&w.w_status);
 273 #     endif /* _MINIX */
 274 #    else /* !UNRELSIGS */
 275      /*
 276       * XXX: for greater than 3 we should use waitpid().
 277       * but then again, SVR4 falls into the POSIX/BSDJOBS category.
 278       */
 279      pid = wait(&w.w_status);
 280 #    endif /* !UNRELSIGS */
 281 #   endif /* !HAVEwait3 */
 282 #  endif        /* !BSDTIMES */
 283 #  ifndef BSDSIGS
 284     (void) sigset(SIGCHLD, pchild);
 285 #  endif /* !BSDSIGS */
 286 # endif /* !BSDJOBS */
 287 #else /* WINNT_NATIVE */
 288     {
 289         extern int insource;
 290         pid = waitpid(-1, &w,
 291             (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG));
 292     }
 293 #endif /* WINNT_NATIVE */
 294
 295 #ifdef JOBDEBUG
 296     xprintf("parent %d pid %d, retval %x termsig %x retcode %x\n",
 297             getpid(), pid, w, WTERMSIG(w), WEXITSTATUS(w));
 298     flush();
 299 #endif /* JOBDEBUG */
 300
 301     if ((pid == 0) || (pid == -1)) {
 302 #ifdef JOBDEBUG
 303         xprintf("errno == %d\n", errno);
 304 #endif /* JOBDEBUG */
 305         if (errno == EINTR) {
 306             errno = 0;
 307             goto loop;
 308         }
 309         pnoprocesses = pid == -1;
 310 #ifndef SIGVOID
 311         return (0);
 312 #else /* !SIGVOID */
 313         return;
 314 #endif /* !SIGVOID */
 315     }
 316     for (pp = proclist.p_next; pp != NULL; pp = pp->p_next)
 317         if (pid == pp->p_procid)
 318             goto found;
 319 #if !defined(BSDJOBS) && !defined(WINNT_NATIVE)
 320     /* this should never have happened */
 321     stderror(ERR_SYNC, pid);
 322     xexit(0);
 323 #else /* BSDJOBS || WINNT_NATIVE */
 324     goto loop;
 325 #endif /* !BSDJOBS && !WINNT_NATIVE */
 326 found:
 327     pp->p_flags &= ~(PRUNNING | PSTOPPED | PREPORTED);
 328     if (WIFSTOPPED(w)) {
 329         pp->p_flags |= PSTOPPED;
 330         pp->p_reason = WSTOPSIG(w);
 331     }
 332     else {
 333         if (pp->p_flags & (PTIME | PPTIME) || adrof(STRtime))
 334 #ifndef BSDTIMES
 335 # ifdef _SEQUENT_
 336             (void) get_process_stats(&pp->p_etime, PS_SELF, NULL, NULL);
 337 # else  /* !_SEQUENT_ */
 338 #  ifndef COHERENT
 339             pp->p_etime = times(&proctimes);
 340 #  else /* COHERENT */
 341             pp->p_etime = HZ * time(NULL);
 342             times(&proctimes);
 343 #  endif /* COHERENT */
 344 # endif /* !_SEQUENT_ */
 345 #else /* BSDTIMES */
 346             (void) gettimeofday(&pp->p_etime, NULL);
 347 #endif /* BSDTIMES */
 348
 349
 350 #if defined(BSDTIMES) || defined(_SEQUENT_)
 351         pp->p_rusage = ru;
 352 #else /* !BSDTIMES && !_SEQUENT_ */
 353         (void) times(&proctimes);
 354         pp->p_utime = proctimes.tms_cutime - shtimes.tms_cutime;
 355         pp->p_stime = proctimes.tms_cstime - shtimes.tms_cstime;
 356         shtimes = proctimes;
 357 #endif /* !BSDTIMES && !_SEQUENT_ */
 358         if (WIFSIGNALED(w)) {
 359             if (WTERMSIG(w) == SIGINT)
 360                 pp->p_flags |= PINTERRUPTED;
 361             else
 362                 pp->p_flags |= PSIGNALED;
 363             if (WCOREDUMP(w))
 364                 pp->p_flags |= PDUMPED;
 365             pp->p_reason = WTERMSIG(w);
 366         }
 367         else {
 368             pp->p_reason = WEXITSTATUS(w);
 369             if (pp->p_reason != 0)
 370                 pp->p_flags |= PAEXITED;
 371             else
 372                 pp->p_flags |= PNEXITED;
 373         }
 374     }
 375     jobflags = 0;
 376     fp = pp;
 377     do {
 378         if ((fp->p_flags & (PPTIME | PRUNNING | PSTOPPED)) == 0 &&
 379             !child && adrof(STRtime) &&
 380 #ifdef BSDTIMES
 381             fp->p_rusage.ru_utime.tv_sec + fp->p_rusage.ru_stime.tv_sec
 382 #else /* !BSDTIMES */
 383 # ifdef _SEQUENT_
 384             fp->p_rusage.ps_utime.tv_sec + fp->p_rusage.ps_stime.tv_sec
 385 # else /* !_SEQUENT_ */
 386 #  ifndef POSIX
 387             (fp->p_utime + fp->p_stime) / HZ
 388 #  else /* POSIX */
 389             (fp->p_utime + fp->p_stime) / clk_tck
 390 #  endif /* POSIX */
 391 # endif /* !_SEQUENT_ */
 392 #endif /* !BSDTIMES */
 393             >= atoi(short2str(varval(STRtime))))
 394             fp->p_flags |= PTIME;
 395         jobflags |= fp->p_flags;
 396     } while ((fp = fp->p_friends) != pp);
 397     pp->p_flags &= ~PFOREGND;
 398     if (pp == pp->p_friends && (pp->p_flags & PPTIME)) {
 399         pp->p_flags &= ~PPTIME;
 400         pp->p_flags |= PTIME;
 401     }
 402     if ((jobflags & (PRUNNING | PREPORTED)) == 0) {
 403         fp = pp;
 404         do {
 405             if (fp->p_flags & PSTOPPED)
 406                 fp->p_flags |= PREPORTED;
 407         } while ((fp = fp->p_friends) != pp);
 408         while (fp->p_procid != fp->p_jobid)
 409             fp = fp->p_friends;
 410         if (jobflags & PSTOPPED) {
 411             if (pcurrent && pcurrent != fp)
 412                 pprevious = pcurrent;
 413             pcurrent = fp;
 414         }
 415         else
 416             pclrcurr(fp);
 417         if (jobflags & PFOREGND) {
 418             if (!(jobflags & (PSIGNALED | PSTOPPED | PPTIME) ||
 419 #ifdef notdef
 420                 jobflags & PAEXITED ||
 421 #endif /* notdef */
 422                 !eq(dcwd->di_name, fp->p_cwd->di_name))) {
 423             /* PWP: print a newline after ^C */
 424                 if (jobflags & PINTERRUPTED) {
 425 #ifdef SHORT_STRINGS
 426                     xputchar('\r' | QUOTE), xputchar('\n');
 427 #else /* !SHORT_STRINGS */
 428                     xprintf("\215\n");  /* \215 is a quoted ^M */
 429 #endif /* !SHORT_STRINGS */
 430                 }
 431 #ifdef notdef
 432                 else if ((jobflags & (PTIME|PSTOPPED)) == PTIME)
 433                     ptprint(fp);
 434 #endif /* notdef */
 435             }
 436         }
 437         else {
 438             if (jobflags & PNOTIFY || adrof(STRnotify)) {
 439 #ifdef SHORT_STRINGS
 440                 xputchar('\r' | QUOTE), xputchar('\n');
 441 #else /* !SHORT_STRINGS */
 442                 xprintf("\215\n");      /* \215 is a quoted ^M */
 443 #endif /* !SHORT_STRINGS */
 444                 (void) pprint(pp, NUMBER | NAME | REASON);
 445                 if ((jobflags & PSTOPPED) == 0)
 446                     pflush(pp);
 447                 {
 448                     extern Char GettingInput;
 449
 450                     if (GettingInput) {
 451                         errno = 0;
 452                         (void) Rawmode();
 453 #ifdef notdef
 454                         /*
 455                          * don't really want to do that, because it
 456                          * will erase our message in case of multi-line
 457                          * input
 458                          */
 459                         ClearLines();
 460 #endif /* notdef */
 461                         ClearDisp();
 462                         Refresh();
 463                     }
 464                 }
 465             }
 466             else {
 467                 fp->p_flags |= PNEEDNOTE;
 468                 neednote++;
 469             }
 470         }
 471     }
 472 #if defined(BSDJOBS) || defined(HAVEwait3)
 473     goto loop;
 474 #endif /* BSDJOBS || HAVEwait3 */
 475 }
 476
 477 void
 478 pnote()
 479 {
 480     register struct process *pp;
 481     int     flags;
 482 #ifdef BSDSIGS
 483     sigmask_t omask;
 484 #endif /* BSDSIGS */
 485
 486     neednote = 0;
 487     for (pp = proclist.p_next; pp != NULL; pp = pp->p_next) {
 488         if (pp->p_flags & PNEEDNOTE) {
 489 #ifdef BSDSIGS
 490             omask = sigblock(sigmask(SIGCHLD));
 491 #else /* !BSDSIGS */
 492             (void) sighold(SIGCHLD);
 493 #endif /* !BSDSIGS */
 494             pp->p_flags &= ~PNEEDNOTE;
 495             flags = pprint(pp, NUMBER | NAME | REASON);
 496             if ((flags & (PRUNNING | PSTOPPED)) == 0)
 497                 pflush(pp);
 498 #ifdef BSDSIGS
 499             (void) sigsetmask(omask);
 500 #else /* !BSDSIGS */
 501             (void) sigrelse(SIGCHLD);
 502 #endif /* !BSDSIGS */
 503         }
 504     }
 505 }
 506
 507
 508 static void
 509 pfree(pp)
 510     struct process *pp;
 511 {
 512     xfree((ptr_t) pp->p_command);
 513     if (pp->p_cwd && --pp->p_cwd->di_count == 0)
 514         if (pp->p_cwd->di_next == 0)
 515             dfree(pp->p_cwd);
 516     xfree((ptr_t) pp);
 517 }
 518
 519
 520 /*
 521  * pwait - wait for current job to terminate, maintaining integrity
 522  *      of current and previous job indicators.
 523  */
 524 void
 525 pwait()
 526 {
 527     register struct process *fp, *pp;
 528 #ifdef BSDSIGS
 529     sigmask_t omask;
 530 #endif /* BSDSIGS */
 531
 532     /*
 533      * Here's where dead procs get flushed.
 534      */
 535 #ifdef BSDSIGS
 536     omask = sigblock(sigmask(SIGCHLD));
 537 #else /* !BSDSIGS */
 538     (void) sighold(SIGCHLD);
 539 #endif /* !BSDSIGS */
 540     for (pp = (fp = &proclist)->p_next; pp != NULL; pp = (fp = pp)->p_next)
 541         if (pp->p_procid == 0) {
 542             fp->p_next = pp->p_next;
 543             pfree(pp);
 544             pp = fp;
 545         }
 546 #ifdef BSDSIGS
 547     (void) sigsetmask(omask);
 548 #else /* !BSDSIGS */
 549     (void) sigrelse(SIGCHLD);
 550 # ifdef notdef
 551     if (setintr)
 552         sigignore(SIGINT);
 553 # endif /* notdef */
 554 #endif /* !BSDSIGS */
 555     pjwait(pcurrjob);
 556 }
 557
 558
 559 /*
 560  * pjwait - wait for a job to finish or become stopped
 561  *      It is assumed to be in the foreground state (PFOREGND)
 562  */
 563 void
 564 pjwait(pp)
 565     register struct process *pp;
 566 {
 567     register struct process *fp;
 568     int     jobflags, reason;
 569 #ifdef BSDSIGS
 570     sigmask_t omask;
 571 #endif /* BSDSIGS */
 572 #ifdef UNRELSIGS
 573     signalfun_t inthandler;
 574 #endif /* UNRELSIGS */
 575     while (pp->p_procid != pp->p_jobid)
 576         pp = pp->p_friends;
 577     fp = pp;
 578
 579     do {
 580         if ((fp->p_flags & (PFOREGND | PRUNNING)) == PRUNNING)
 581             xprintf(CGETS(17, 1, "BUG: waiting for background job!\n"));
 582     } while ((fp = fp->p_friends) != pp);
 583     /*
 584      * Now keep pausing as long as we are not interrupted (SIGINT), and the
 585      * target process, or any of its friends, are running
 586      */
 587     fp = pp;
 588 #ifdef BSDSIGS
 589     omask = sigblock(sigmask(SIGCHLD));
 590 #endif /* BSDSIGS */
 591 #ifdef UNRELSIGS
 592     if (setintr)
 593         inthandler = signal(SIGINT, SIG_IGN);
 594 #endif /* UNRELSIGS */
 595     for (;;) {
 596 #ifndef BSDSIGS
 597         (void) sighold(SIGCHLD);
 598 #endif /* !BSDSIGS */
 599         jobflags = 0;
 600         do
 601             jobflags |= fp->p_flags;
 602         while ((fp = (fp->p_friends)) != pp);
 603         if ((jobflags & PRUNNING) == 0)
 604             break;
 605 #ifdef JOBDEBUG
 606         xprintf("%d starting to sigpause for SIGCHLD on %d\n",
 607                 getpid(), fp->p_procid);
 608 #endif /* JOBDEBUG */
 609 #ifdef BSDSIGS
 610         /* (void) sigpause(sigblock((sigmask_t) 0) &~ sigmask(SIGCHLD)); */
 611         (void) sigpause(omask & ~sigmask(SIGCHLD));
 612 #else /* !BSDSIGS */
 613         (void) sigpause(SIGCHLD);
 614 #endif /* !BSDSIGS */
 615     }
 616 #ifdef JOBDEBUG
 617         xprintf("%d returned from sigpause loop\n", getpid());
 618 #endif /* JOBDEBUG */
 619 #ifdef BSDSIGS
 620     (void) sigsetmask(omask);
 621 #else /* !BSDSIGS */
 622     (void) sigrelse(SIGCHLD);
 623 #endif /* !BSDSIGS */
 624 #ifdef UNRELSIGS
 625     if (setintr)
 626         (void) signal(SIGINT, inthandler);
 627 #endif /* UNRELSIGS */
 628 #ifdef BSDJOBS
 629     if (tpgrp > 0)              /* get tty back */
 630         (void) tcsetpgrp(FSHTTY, tpgrp);
 631 #endif /* BSDJOBS */
 632     if ((jobflags & (PSIGNALED | PSTOPPED | PTIME)) ||
 633         !eq(dcwd->di_name, fp->p_cwd->di_name)) {
 634         if (jobflags & PSTOPPED) {
 635             xputchar('\n');
 636             if (adrof(STRlistjobs)) {
 637                 Char   *jobcommand[3];
 638
 639                 jobcommand[0] = STRjobs;
 640                 if (eq(varval(STRlistjobs), STRlong))
 641                     jobcommand[1] = STRml;
 642                 else
 643                     jobcommand[1] = NULL;
 644                 jobcommand[2] = NULL;
 645
 646                 dojobs(jobcommand, NULL);
 647                 (void) pprint(pp, SHELLDIR);
 648             }
 649             else
 650                 (void) pprint(pp, AREASON | SHELLDIR);
 651         }
 652         else
 653             (void) pprint(pp, AREASON | SHELLDIR);
 654     }
 655     if ((jobflags & (PINTERRUPTED | PSTOPPED)) && setintr &&
 656         (!gointr || !eq(gointr, STRminus))) {
 657         if ((jobflags & PSTOPPED) == 0)
 658             pflush(pp);
 659         pintr1(0);
 660         /* NOTREACHED */
 661     }
 662     reason = 0;
 663     fp = pp;
 664     do {
 665         if (fp->p_reason)
 666             reason = fp->p_flags & (PSIGNALED | PINTERRUPTED) ?
 667                 fp->p_reason | META : fp->p_reason;
 668     } while ((fp = fp->p_friends) != pp);
 669     /*
 670      * Don't report on backquoted jobs, cause it will mess up
 671      * their output.
 672      */
 673     if ((reason != 0) && (adrof(STRprintexitvalue)) &&
 674         (pp->p_flags & PBACKQ) == 0)
 675         xprintf(CGETS(17, 2, "Exit %d\n"), reason);
 676     set(STRstatus, putn(reason), VAR_READWRITE);
 677     if (reason && exiterr)
 678         exitstat();
 679     pflush(pp);
 680 }
 681
 682 /*
 683  * dowait - wait for all processes to finish
 684  */
 685
 686 /*ARGSUSED*/
 687 void
 688 dowait(v, c)
 689     Char **v;
 690     struct command *c;
 691 {
 692     register struct process *pp;
 693 #ifdef BSDSIGS
 694     sigmask_t omask;
 695 #endif /* BSDSIGS */
 696
 697     USE(c);
 698     USE(v);
 699     pjobs++;
 700 #ifdef BSDSIGS
 701     omask = sigblock(sigmask(SIGCHLD));
 702 loop:
 703 #else /* !BSDSIGS */
 704     if (setintr)
 705         (void) sigrelse(SIGINT);
 706 loop:
 707     (void) sighold(SIGCHLD);
 708 #endif /* !BSDSIGS */
 709     for (pp = proclist.p_next; pp; pp = pp->p_next)
 710         if (pp->p_procid &&     /* pp->p_procid == pp->p_jobid && */
 711             pp->p_flags & PRUNNING) {
 712 #ifdef BSDSIGS
 713             (void) sigpause((sigmask_t) 0);
 714 #else /* !BSDSIGS */
 715             (void) sigpause(SIGCHLD);
 716 #endif /* !BSDSIGS */
 717             goto loop;
 718         }
 719 #ifdef BSDSIGS
 720     (void) sigsetmask(omask);
 721 #else /* !BSDSIGS */
 722     (void) sigrelse(SIGCHLD);
 723 #endif /* !BSDSIGS */
 724     pjobs = 0;
 725 }
 726
 727 /*
 728  * pflushall - flush all jobs from list (e.g. at fork())
 729  */
 730 static void
 731 pflushall()
 732 {
 733     register struct process *pp;
 734
 735     for (pp = proclist.p_next; pp != NULL; pp = pp->p_next)
 736         if (pp->p_procid)
 737             pflush(pp);
 738 }
 739
 740 /*
 741  * pflush - flag all process structures in the same job as the
 742  *      the argument process for deletion.  The actual free of the
 743  *      space is not done here since pflush is called at interrupt level.
 744  */
 745 static void
 746 pflush(pp)
 747     register struct process *pp;
 748 {
 749     register struct process *np;
 750     register int idx;
 751
 752     if (pp->p_procid == 0) {
 753         xprintf(CGETS(17, 3, "BUG: process flushed twice"));
 754         return;
 755     }
 756     while (pp->p_procid != pp->p_jobid)
 757         pp = pp->p_friends;
 758     pclrcurr(pp);
 759     if (pp == pcurrjob)
 760         pcurrjob = 0;
 761     idx = pp->p_index;
 762     np = pp;
 763     do {
 764         np->p_index = np->p_procid = 0;
 765         np->p_flags &= ~PNEEDNOTE;
 766     } while ((np = np->p_friends) != pp);
 767     if (idx == pmaxindex) {
 768         for (np = proclist.p_next, idx = 0; np; np = np->p_next)
 769             if (np->p_index > idx)
 770                 idx = np->p_index;
 771         pmaxindex = idx;
 772     }
 773 }
 774
 775 /*
 776  * pclrcurr - make sure the given job is not the current or previous job;
 777  *      pp MUST be the job leader
 778  */
 779 static void
 780 pclrcurr(pp)
 781     register struct process *pp;
 782 {
 783     if (pp == pcurrent) {
 784         if (pprevious != NULL) {
 785             pcurrent = pprevious;
 786             pprevious = pgetcurr(pp);
 787         }
 788         else {
 789             pcurrent = pgetcurr(pp);
 790             pprevious = pgetcurr(pp);
 791         }
 792     }
 793     else if (pp == pprevious)
 794         pprevious = pgetcurr(pp);
 795 }
 796
 797 /* +4 here is 1 for '\0', 1 ea for << >& >> */
 798 static Char command[PMAXLEN + 4];
 799 static int cmdlen;
 800 static Char *cmdp;
 801
 802 /* GrP
 803  * unparse - Export padd() functionality
 804  */
 805 Char *
 806 unparse(t)
 807     register struct command *t;
 808 {
 809     cmdp = command;
 810     cmdlen = 0;
 811     padd(t);
 812     *cmdp++ = '\0';
 813     return Strsave(command);
 814 }
 815
 816
 817 /*
 818  * palloc - allocate a process structure and fill it up.
 819  *      an important assumption is made that the process is running.
 820  */
 821 void
 822 palloc(pid, t)
 823     int     pid;
 824     register struct command *t;
 825 {
 826     register struct process *pp;
 827     int     i;
 828
 829     pp = (struct process *) xcalloc(1, (size_t) sizeof(struct process));
 830     pp->p_procid = pid;
 831     pp->p_flags = ((t->t_dflg & F_AMPERSAND) ? 0 : PFOREGND) | PRUNNING;
 832     if (t->t_dflg & F_TIME)
 833         pp->p_flags |= PPTIME;
 834     if (t->t_dflg & F_BACKQ)
 835         pp->p_flags |= PBACKQ;
 836     if (t->t_dflg & F_HUP)
 837         pp->p_flags |= PHUP;
 838     cmdp = command;
 839     cmdlen = 0;
 840     padd(t);
 841     *cmdp++ = 0;
 842     if (t->t_dflg & F_PIPEOUT) {
 843         pp->p_flags |= PPOU;
 844         if (t->t_dflg & F_STDERR)
 845             pp->p_flags |= PDIAG;
 846     }
 847     pp->p_command = Strsave(command);
 848     if (pcurrjob) {
 849         struct process *fp;
 850
 851         /* careful here with interrupt level */
 852         pp->p_cwd = 0;
 853         pp->p_index = pcurrjob->p_index;
 854         pp->p_friends = pcurrjob;
 855         pp->p_jobid = pcurrjob->p_procid;
 856         for (fp = pcurrjob; fp->p_friends != pcurrjob; fp = fp->p_friends)
 857             continue;
 858         fp->p_friends = pp;
 859     }
 860     else {
 861         pcurrjob = pp;
 862         pp->p_jobid = pid;
 863         pp->p_friends = pp;
 864         pp->p_cwd = dcwd;
 865         dcwd->di_count++;
 866         if (pmaxindex < BIGINDEX)
 867             pp->p_index = ++pmaxindex;
 868         else {
 869             struct process *np;
 870
 871             for (i = 1;; i++) {
 872                 for (np = proclist.p_next; np; np = np->p_next)
 873                     if (np->p_index == i)
 874                         goto tryagain;
 875                 pp->p_index = i;
 876                 if (i > pmaxindex)
 877                     pmaxindex = i;
 878                 break;
 879         tryagain:;
 880             }
 881         }
 882         if (pcurrent == NULL)
 883             pcurrent = pp;
 884         else if (pprevious == NULL)
 885             pprevious = pp;
 886     }
 887     pp->p_next = proclist.p_next;
 888     proclist.p_next = pp;
 889 #ifdef BSDTIMES
 890     (void) gettimeofday(&pp->p_btime, NULL);
 891 #else /* !BSDTIMES */
 892 # ifdef _SEQUENT_
 893     (void) get_process_stats(&pp->p_btime, PS_SELF, NULL, NULL);
 894 # else /* !_SEQUENT_ */
 895     {
 896         struct tms tmptimes;
 897
 898 #  ifndef COHERENT
 899         pp->p_btime = times(&tmptimes);
 900 #  else /* !COHERENT */
 901         pp->p_btime = HZ * time(NULL);
 902         times(&tmptimes);
 903 #  endif /* !COHERENT */
 904     }
 905 # endif /* !_SEQUENT_ */
 906 #endif /* !BSDTIMES */
 907 }
 908
 909 static void
 910 padd(t)
 911     register struct command *t;
 912 {
 913     Char  **argp;
 914
 915     if (t == 0)
 916         return;
 917     switch (t->t_dtyp) {
 918
 919     case NODE_PAREN:
 920         pads(STRLparensp);
 921         padd(t->t_dspr);
 922         pads(STRspRparen);
 923         break;
 924
 925     case NODE_COMMAND:
 926         for (argp = t->t_dcom; *argp; argp++) {
 927             pads(*argp);
 928             if (argp[1])
 929                 pads(STRspace);
 930         }
 931         break;
 932
 933     case NODE_OR:
 934     case NODE_AND:
 935     case NODE_PIPE:
 936     case NODE_LIST:
 937         padd(t->t_dcar);
 938         switch (t->t_dtyp) {
 939         case NODE_OR:
 940             pads(STRspor2sp);
 941             break;
 942         case NODE_AND:
 943             pads(STRspand2sp);
 944             break;
 945         case NODE_PIPE:
 946             pads(STRsporsp);
 947             break;
 948         case NODE_LIST:
 949             pads(STRsemisp);
 950             break;
 951         default:
 952             break;
 953         }
 954         padd(t->t_dcdr);
 955         return;
 956
 957     default:
 958         break;
 959     }
 960     if ((t->t_dflg & F_PIPEIN) == 0 && t->t_dlef) {
 961         pads((t->t_dflg & F_READ) ? STRspLarrow2sp : STRspLarrowsp);
 962         pads(t->t_dlef);
 963     }
 964     if ((t->t_dflg & F_PIPEOUT) == 0 && t->t_drit) {
 965         pads((t->t_dflg & F_APPEND) ? STRspRarrow2 : STRspRarrow);
 966         if (t->t_dflg & F_STDERR)
 967             pads(STRand);
 968         pads(STRspace);
 969         pads(t->t_drit);
 970     }
 971 }
 972
 973 static void
 974 pads(cp)
 975     Char   *cp;
 976 {
 977     register int i;
 978
 979     /*
 980      * Avoid the Quoted Space alias hack! Reported by:
 981      * sam@john-bigboote.ICS.UCI.EDU (Sam Horrocks)
 982      */
 983     if (cp[0] == STRQNULL[0])
 984         cp++;
 985
 986     i = (int) Strlen(cp);
 987
 988     if (cmdlen >= PMAXLEN)
 989         return;
 990     if (cmdlen + i >= PMAXLEN) {
 991         (void) Strcpy(cmdp, STRsp3dots);
 992         cmdlen = PMAXLEN;
 993         cmdp += 4;
 994         return;
 995     }
 996     (void) Strcpy(cmdp, cp);
 997     cmdp += i;
 998     cmdlen += i;
 999 }
1000
1001 /*
1002  * psavejob - temporarily save the current job on a one level stack
1003  *      so another job can be created.  Used for { } in exp6
1004  *      and `` in globbing.
1005  */
1006 void
1007 psavejob()
1008 {
1009     pholdjob = pcurrjob;
1010     pcurrjob = NULL;
1011 }
1012
1013 /*
1014  * prestjob - opposite of psavejob.  This may be missed if we are interrupted
1015  *      somewhere, but pendjob cleans up anyway.
1016  */
1017 void
1018 prestjob()
1019 {
1020     pcurrjob = pholdjob;
1021     pholdjob = NULL;
1022 }
1023
1024 /*
1025  * pendjob - indicate that a job (set of commands) has been completed
1026  *      or is about to begin.
1027  */
1028 void
1029 pendjob()
1030 {
1031     register struct process *pp, *tp;
1032
1033     if (pcurrjob && (pcurrjob->p_flags & (PFOREGND | PSTOPPED)) == 0) {
1034         pp = pcurrjob;
1035         while (pp->p_procid != pp->p_jobid)
1036             pp = pp->p_friends;
1037         xprintf("[%d]", pp->p_index);
1038         tp = pp;
1039         do {
1040             xprintf(" %d", pp->p_procid);
1041             pp = pp->p_friends;
1042         } while (pp != tp);
1043         xputchar('\n');
1044     }
1045     pholdjob = pcurrjob = 0;
1046 }
1047
1048 /*
1049  * pprint - print a job
1050  */
1051
1052 /*
1053  * Hacks have been added for SVR4 to deal with pipe's being spawned in
1054  * reverse order
1055  *
1056  * David Dawes (dawes@physics.su.oz.au) Oct 1991
1057  */
1058
1059 static int
1060 pprint(pp, flag)
1061     register struct process *pp;
1062     bool    flag;
1063 {
1064     int status, reason;
1065     struct process *tp;
1066     extern char *linp, linbuf[];
1067     int     jobflags, pstatus, pcond;
1068     char   *format;
1069
1070 #ifdef BACKPIPE
1071     struct process *pipehead = NULL, *pipetail = NULL, *pmarker = NULL;
1072     int inpipe = 0;
1073 #endif /* BACKPIPE */
1074
1075     while (pp->p_procid != pp->p_jobid)
1076         pp = pp->p_friends;
1077     if (pp == pp->p_friends && (pp->p_flags & PPTIME)) {
1078         pp->p_flags &= ~PPTIME;
1079         pp->p_flags |= PTIME;
1080     }
1081     tp = pp;
1082     status = reason = -1;
1083     jobflags = 0;
1084     do {
1085 #ifdef BACKPIPE
1086         /*
1087          * The pipeline is reversed, so locate the real head of the pipeline
1088          * if pp is at the tail of a pipe (and not already in a pipeline)
1089          */
1090         if ((pp->p_friends->p_flags & PPOU) && !inpipe && (flag & NAME)) {
1091             inpipe = 1;
1092             pipetail = pp;
1093             do
1094                 pp = pp->p_friends;
1095             while (pp->p_friends->p_flags & PPOU);
1096             pipehead = pp;
1097             pmarker = pp;
1098         /*
1099          * pmarker is used to hold the place of the proc being processed, so
1100          * we can search for the next one downstream later.
1101          */
1102         }
1103         pcond = (int) (tp != pp || (inpipe && tp == pp));
1104 #else /* !BACKPIPE */
1105         pcond = (int) (tp != pp);
1106 #endif /* BACKPIPE */
1107
1108         jobflags |= pp->p_flags;
1109         pstatus = (int) (pp->p_flags & PALLSTATES);
1110         if (pcond && linp != linbuf && !(flag & FANCY) &&
1111             ((pstatus == status && pp->p_reason == reason) ||
1112              !(flag & REASON)))
1113             xputchar(' ');
1114         else {
1115             if (pcond && linp != linbuf)
1116                 xputchar('\n');
1117             if (flag & NUMBER) {
1118 #ifdef BACKPIPE
1119                 pcond = ((pp == tp && !inpipe) ||
1120                          (inpipe && pipetail == tp && pp == pipehead));
1121 #else /* BACKPIPE */
1122                 pcond = (pp == tp);
1123 #endif /* BACKPIPE */
1124                 if (pcond)
1125                     xprintf("[%d]%s %c ", pp->p_index,
1126                             pp->p_index < 10 ? " " : "",
1127                             pp == pcurrent ? '+' :
1128                             (pp == pprevious ? '-' : ' '));
1129                 else
1130                     xprintf("       ");
1131             }
1132             if (flag & FANCY) {
1133 #ifdef TCF
1134                 extern char *sitename();
1135
1136 #endif /* TCF */
1137                 xprintf("%5d ", pp->p_procid);
1138 #ifdef TCF
1139                 xprintf("%11s ", sitename(pp->p_procid));
1140 #endif /* TCF */
1141             }
1142             if (flag & (REASON | AREASON)) {
1143                 if (flag & NAME)
1144                     format = "%-30s";
1145                 else
1146                     format = "%s";
1147                 if (pstatus == status) {
1148                     if (pp->p_reason == reason) {
1149                         xprintf(format, "");
1150                         goto prcomd;
1151                     }
1152                     else
1153                         reason = (int) pp->p_reason;
1154                 }
1155                 else {
1156                     status = pstatus;
1157                     reason = (int) pp->p_reason;
1158                 }
1159                 switch (status) {
1160
1161                 case PRUNNING:
1162                     xprintf(format, CGETS(17, 4, "Running "));
1163                     break;
1164
1165                 case PINTERRUPTED:
1166                 case PSTOPPED:
1167                 case PSIGNALED:
1168                     /*
1169                      * tell what happened to the background job
1170                      * From: Michael Schroeder
1171                      * <mlschroe@immd4.informatik.uni-erlangen.de>
1172                      */
1173                     if ((flag & REASON)
1174                         || ((flag & AREASON)
1175                             && reason != SIGINT
1176                             && (reason != SIGPIPE
1177                                 || (pp->p_flags & PPOU) == 0))) {
1178                         char *ptr;
1179                         char buf[1024];
1180
1181                         if ((ptr = mesg[pp->p_reason & ASCII].pname) == NULL)
1182                             xsnprintf(ptr = buf, sizeof(buf), "%s %d",
1183                                 CGETS(17, 5, "Signal"), pp->p_reason & ASCII);
1184                         xprintf(format, ptr);
1185                     }
1186                     else
1187                         reason = -1;
1188                     break;
1189
1190                 case PNEXITED:
1191                 case PAEXITED:
1192                     if (flag & REASON) {
1193                         if (pp->p_reason)
1194                             xprintf(CGETS(17, 6, "Exit %-25d"), pp->p_reason);
1195                         else
1196                             xprintf(format, CGETS(17, 7, "Done"));
1197                     }
1198                     break;
1199
1200                 default:
1201                     xprintf(CGETS(17, 8, "BUG: status=%-9o"),
1202                             status);
1203                 }
1204             }
1205         }
1206 prcomd:
1207         if (flag & NAME) {
1208             xprintf("%S", pp->p_command);
1209             if (pp->p_flags & PPOU)
1210                 xprintf(" |");
1211             if (pp->p_flags & PDIAG)
1212                 xprintf("&");
1213         }
1214         if (flag & (REASON | AREASON) && pp->p_flags & PDUMPED)
1215             xprintf(CGETS(17, 9, " (core dumped)"));
1216         if (tp == pp->p_friends) {
1217             if (flag & AMPERSAND)
1218                 xprintf(" &");
1219             if (flag & JOBDIR &&
1220                 !eq(tp->p_cwd->di_name, dcwd->di_name)) {
1221                 xprintf(CGETS(17, 10, " (wd: "));
1222                 dtildepr(tp->p_cwd->di_name);
1223                 xprintf(")");
1224             }
1225         }
1226         if (pp->p_flags & PPTIME && !(status & (PSTOPPED | PRUNNING))) {
1227             if (linp != linbuf)
1228                 xprintf("\n\t");
1229 #if defined(BSDTIMES) || defined(_SEQUENT_)
1230             prusage(&zru, &pp->p_rusage, &pp->p_etime,
1231                     &pp->p_btime);
1232 #else /* !BSDTIMES && !SEQUENT */
1233             lru.tms_utime = pp->p_utime;
1234             lru.tms_stime = pp->p_stime;
1235             lru.tms_cutime = 0;
1236             lru.tms_cstime = 0;
1237             prusage(&zru, &lru, pp->p_etime,
1238                     pp->p_btime);
1239 #endif /* !BSDTIMES && !SEQUENT */
1240
1241         }
1242 #ifdef BACKPIPE
1243         pcond = ((tp == pp->p_friends && !inpipe) ||
1244                  (inpipe && pipehead->p_friends == tp && pp == pipetail));
1245 #else  /* !BACKPIPE */
1246         pcond = (tp == pp->p_friends);
1247 #endif /* BACKPIPE */
1248         if (pcond) {
1249             if (linp != linbuf)
1250                 xputchar('\n');
1251             if (flag & SHELLDIR && !eq(tp->p_cwd->di_name, dcwd->di_name)) {
1252                 xprintf(CGETS(17, 11, "(wd now: "));
1253                 dtildepr(dcwd->di_name);
1254                 xprintf(")\n");
1255             }
1256         }
1257 #ifdef BACKPIPE
1258         if (inpipe) {
1259             /*
1260              * if pmaker == pipetail, we are finished that pipeline, and
1261              * can now skip to past the head
1262              */
1263             if (pmarker == pipetail) {
1264                 inpipe = 0;
1265                 pp = pipehead;
1266             }
1267             else {
1268             /*
1269              * set pp to one before the one we want next, so the while below
1270              * increments to the correct spot.
1271              */
1272                 do
1273                     pp = pp->p_friends;
1274                 while (pp->p_friends->p_friends != pmarker);
1275                 pmarker = pp->p_friends;
1276             }
1277         }
1278         pcond = ((pp = pp->p_friends) != tp || inpipe);
1279 #else /* !BACKPIPE */
1280         pcond = ((pp = pp->p_friends) != tp);
1281 #endif /* BACKPIPE */
1282     } while (pcond);
1283
1284     if (jobflags & PTIME && (jobflags & (PSTOPPED | PRUNNING)) == 0) {
1285         if (jobflags & NUMBER)
1286             xprintf("       ");
1287         ptprint(tp);
1288     }
1289     return (jobflags);
1290 }
1291
1292 /*
1293  * All 4.3 BSD derived implementations are buggy and I've had enough.
1294  * The following implementation produces similar code and works in all
1295  * cases. The 4.3BSD one works only for <, >, !=
1296  */
1297 # undef timercmp
1298 #  define timercmp(tvp, uvp, cmp) \
1299       (((tvp)->tv_sec == (uvp)->tv_sec) ? \
1300            ((tvp)->tv_usec cmp (uvp)->tv_usec) : \
1301            ((tvp)->tv_sec  cmp (uvp)->tv_sec))
1302
1303 static void
1304 ptprint(tp)
1305     register struct process *tp;
1306 {
1307 #ifdef BSDTIMES
1308     struct timeval tetime, diff;
1309     static struct timeval ztime;
1310     struct sysrusage ru;
1311     register struct process *pp = tp;
1312
1313     ru = zru;
1314     tetime = ztime;
1315     do {
1316         ruadd(&ru, &pp->p_rusage);
1317         tvsub(&diff, &pp->p_etime, &pp->p_btime);
1318         if (timercmp(&diff, &tetime, >))
1319             tetime = diff;
1320     } while ((pp = pp->p_friends) != tp);
1321     prusage(&zru, &ru, &tetime, &ztime);
1322 #else /* !BSDTIMES */
1323 # ifdef _SEQUENT_
1324     timeval_t tetime, diff;
1325     static timeval_t ztime;
1326     struct process_stats ru;
1327     register struct process *pp = tp;
1328
1329     ru = zru;
1330     tetime = ztime;
1331     do {
1332         ruadd(&ru, &pp->p_rusage);
1333         tvsub(&diff, &pp->p_etime, &pp->p_btime);
1334         if (timercmp(&diff, &tetime, >))
1335             tetime = diff;
1336     } while ((pp = pp->p_friends) != tp);
1337     prusage(&zru, &ru, &tetime, &ztime);
1338 # else /* !_SEQUENT_ */
1339 #  ifndef POSIX
1340     static time_t ztime = 0;
1341     static time_t zu_time = 0;
1342     static time_t zs_time = 0;
1343     time_t  tetime, diff;
1344     time_t  u_time, s_time;
1345
1346 #  else /* POSIX */
1347     static clock_t ztime = 0;
1348     static clock_t zu_time = 0;
1349     static clock_t zs_time = 0;
1350     clock_t tetime, diff;
1351     clock_t u_time, s_time;
1352
1353 #  endif /* POSIX */
1354     struct tms zts, rts;
1355     register struct process *pp = tp;
1356
1357     u_time = zu_time;
1358     s_time = zs_time;
1359     tetime = ztime;
1360     do {
1361         u_time += pp->p_utime;
1362         s_time += pp->p_stime;
1363         diff = pp->p_etime - pp->p_btime;
1364         if (diff > tetime)
1365             tetime = diff;
1366     } while ((pp = pp->p_friends) != tp);
1367     zts.tms_utime = zu_time;
1368     zts.tms_stime = zs_time;
1369     zts.tms_cutime = 0;
1370     zts.tms_cstime = 0;
1371     rts.tms_utime = u_time;
1372     rts.tms_stime = s_time;
1373     rts.tms_cutime = 0;
1374     rts.tms_cstime = 0;
1375     prusage(&zts, &rts, tetime, ztime);
1376 # endif /* !_SEQUENT_ */
1377 #endif  /* !BSDTIMES */
1378 }
1379
1380 /*
1381  * dojobs - print all jobs
1382  */
1383 /*ARGSUSED*/
1384 void
1385 dojobs(v, c)
1386     Char  **v;
1387     struct command *c;
1388 {
1389     register struct process *pp;
1390     register int flag = NUMBER | NAME | REASON;
1391     int     i;
1392
1393     USE(c);
1394     if (chkstop)
1395         chkstop = 2;
1396     if (*++v) {
1397         if (v[1] || !eq(*v, STRml))
1398             stderror(ERR_JOBS);
1399         flag |= FANCY | JOBDIR;
1400     }
1401     for (i = 1; i <= pmaxindex; i++)
1402         for (pp = proclist.p_next; pp; pp = pp->p_next)
1403             if (pp->p_index == i && pp->p_procid == pp->p_jobid) {
1404                 pp->p_flags &= ~PNEEDNOTE;
1405                 if (!(pprint(pp, flag) & (PRUNNING | PSTOPPED)))
1406                     pflush(pp);
1407                 break;
1408             }
1409 }
1410
1411 /*
1412  * dofg - builtin - put the job into the foreground
1413  */
1414 /*ARGSUSED*/
1415 void
1416 dofg(v, c)
1417     Char  **v;
1418     struct command *c;
1419 {
1420     register struct process *pp;
1421
1422     USE(c);
1423     okpcntl();
1424     ++v;
1425     do {
1426         pp = pfind(*v);
1427         if (!pstart(pp, 1)) {
1428             pp->p_procid = 0;
1429             stderror(ERR_NAME|ERR_BADJOB, pp->p_command, strerror(errno));
1430             continue;
1431         }
1432 #ifndef BSDSIGS
1433 # ifdef notdef
1434         if (setintr)
1435             sigignore(SIGINT);
1436 # endif
1437 #endif /* !BSDSIGS */
1438         pjwait(pp);
1439     } while (*v && *++v);
1440 }
1441
1442 /*
1443  * %... - builtin - put the job into the foreground
1444  */
1445 /*ARGSUSED*/
1446 void
1447 dofg1(v, c)
1448     Char  **v;
1449     struct command *c;
1450 {
1451     register struct process *pp;
1452
1453     USE(c);
1454     okpcntl();
1455     pp = pfind(v[0]);
1456     if (!pstart(pp, 1)) {
1457         pp->p_procid = 0;
1458         stderror(ERR_NAME|ERR_BADJOB, pp->p_command, strerror(errno));
1459         return;
1460     }
1461 #ifndef BSDSIGS
1462 # ifdef notdef
1463     if (setintr)
1464         sigignore(SIGINT);
1465 # endif
1466 #endif /* !BSDSIGS */
1467     pjwait(pp);
1468 }
1469
1470 /*
1471  * dobg - builtin - put the job into the background
1472  */
1473 /*ARGSUSED*/
1474 void
1475 dobg(v, c)
1476     Char  **v;
1477     struct command *c;
1478 {
1479     register struct process *pp;
1480
1481     USE(c);
1482     okpcntl();
1483     ++v;
1484     do {
1485         pp = pfind(*v);
1486         if (!pstart(pp, 0)) {
1487             pp->p_procid = 0;
1488             stderror(ERR_NAME|ERR_BADJOB, pp->p_command, strerror(errno));
1489         }
1490     } while (*v && *++v);
1491 }
1492
1493 /*
1494  * %... & - builtin - put the job into the background
1495  */
1496 /*ARGSUSED*/
1497 void
1498 dobg1(v, c)
1499     Char  **v;
1500     struct command *c;
1501 {
1502     register struct process *pp;
1503
1504     USE(c);
1505     pp = pfind(v[0]);
1506     if (!pstart(pp, 0)) {
1507         pp->p_procid = 0;
1508         stderror(ERR_NAME|ERR_BADJOB, pp->p_command, strerror(errno));
1509     }
1510 }
1511
1512 /*
1513  * dostop - builtin - stop the job
1514  */
1515 /*ARGSUSED*/
1516 void
1517 dostop(v, c)
1518     Char  **v;
1519     struct command *c;
1520 {
1521     USE(c);
1522 #ifdef BSDJOBS
1523     pkill(++v, SIGSTOP);
1524 #endif /* BSDJOBS */
1525 }
1526
1527 /*
1528  * dokill - builtin - superset of kill (1)
1529  */
1530 /*ARGSUSED*/
1531 void
1532 dokill(v, c)
1533     Char  **v;
1534     struct command *c;
1535 {
1536     register int signum, len = 0;
1537     register char *name;
1538     Char *sigptr;
1539     extern int T_Cols;
1540     extern int nsig;
1541
1542     USE(c);
1543     v++;
1544     if (v[0] && v[0][0] == '-') {
1545         if (v[0][1] == 'l') {
1546             for (signum = 0; signum <= nsig; signum++) {
1547                 if ((name = mesg[signum].iname) != NULL) {
1548                     len += strlen(name) + 1;
1549                     if (len >= T_Cols - 1) {
1550                         xputchar('\n');
1551                         len = strlen(name) + 1;
1552                     }
1553                     xprintf("%s ", name);
1554                 }
1555             }
1556             xputchar('\n');
1557             return;
1558         }
1559         sigptr = &v[0][1];
1560         if (v[0][1] == 's') {
1561             if (v[1]) {
1562                 v++;
1563                 sigptr = &v[0][0];
1564             } else {
1565                 stderror(ERR_NAME | ERR_TOOFEW);
1566             }
1567         }
1568         if (Isdigit(*sigptr)) {
1569             char *ep;
1570             signum = strtoul(short2str(sigptr), &ep, 0);
1571             if (*ep || signum < 0 || signum > (MAXSIG-1))
1572                 stderror(ERR_NAME | ERR_BADSIG);
1573         }
1574         else {
1575             for (signum = 0; signum <= nsig; signum++)
1576                 if (mesg[signum].iname &&
1577                     eq(sigptr, str2short(mesg[signum].iname)))
1578                     goto gotsig;
1579             setname(short2str(sigptr));
1580             stderror(ERR_NAME | ERR_UNKSIG);
1581         }
1582 gotsig:
1583         v++;
1584     }
1585     else
1586         signum = SIGTERM;
1587     pkill(v, signum);
1588 }
1589
1590 static void
1591 pkill(v, signum)
1592     Char  **v;
1593     int     signum;
1594 {
1595     register struct process *pp, *np;
1596     int jobflags = 0, err1 = 0;
1597     pid_t     pid;
1598 #ifdef BSDSIGS
1599     sigmask_t omask;
1600 #endif /* BSDSIGS */
1601     Char   *cp, **vp;
1602
1603 #ifdef BSDSIGS
1604     omask = sigmask(SIGCHLD);
1605     if (setintr)
1606         omask |= sigmask(SIGINT);
1607     omask = sigblock(omask) & ~omask;
1608 #else /* !BSDSIGS */
1609     if (setintr)
1610         (void) sighold(SIGINT);
1611     (void) sighold(SIGCHLD);
1612 #endif /* !BSDSIGS */
1613
1614     /* Avoid globbing %?x patterns */
1615     for (vp = v; vp && *vp; vp++)
1616         if (**vp == '%')
1617             (void) quote(*vp);
1618
1619     gflag = 0, tglob(v);
1620     if (gflag) {
1621         v = globall(v);
1622         if (v == 0)
1623             stderror(ERR_NAME | ERR_NOMATCH);
1624     }
1625     else {
1626         v = gargv = saveblk(v);
1627         trim(v);
1628     }
1629
1630
1631     while (v && (cp = *v)) {
1632         if (*cp == '%') {
1633             np = pp = pfind(cp);
1634             do
1635                 jobflags |= np->p_flags;
1636             while ((np = np->p_friends) != pp);
1637 #ifdef BSDJOBS
1638             switch (signum) {
1639
1640             case SIGSTOP:
1641             case SIGTSTP:
1642             case SIGTTIN:
1643             case SIGTTOU:
1644                 if ((jobflags & PRUNNING) == 0) {
1645 # ifdef SUSPENDED
1646                     xprintf(CGETS(17, 12, "%S: Already suspended\n"), cp);
1647 # else /* !SUSPENDED */
1648                     xprintf(CGETS(17, 13, "%S: Already stopped\n"), cp);
1649 # endif /* !SUSPENDED */
1650                     err1++;
1651                     goto cont;
1652                 }
1653                 break;
1654                 /*
1655                  * suspend a process, kill -CONT %, then type jobs; the shell
1656                  * says it is suspended, but it is running; thanks jaap..
1657                  */
1658             case SIGCONT:
1659                 if (!pstart(pp, 0)) {
1660                     pp->p_procid = 0;
1661                     stderror(ERR_NAME|ERR_BADJOB, pp->p_command,
1662                              strerror(errno));
1663                 }
1664                 goto cont;
1665             default:
1666                 break;
1667             }
1668 #endif /* BSDJOBS */
1669             if (killpg(pp->p_jobid, signum) < 0) {
1670                 xprintf("%S: %s\n", cp, strerror(errno));
1671                 err1++;
1672             }
1673 #ifdef BSDJOBS
1674             if (signum == SIGTERM || signum == SIGHUP)
1675                 (void) killpg(pp->p_jobid, SIGCONT);
1676 #endif /* BSDJOBS */
1677         }
1678         else if (!(Isdigit(*cp) || *cp == '-'))
1679             stderror(ERR_NAME | ERR_JOBARGS);
1680         else {
1681             char *ep;
1682 #ifndef WINNT_NATIVE
1683             pid = strtol(short2str(cp), &ep, 10);
1684 #else
1685             pid = strtoul(short2str(cp), &ep, 0);
1686 #endif /* WINNT_NATIVE */
1687             if (*ep)
1688                 stderror(ERR_NAME | ERR_JOBARGS);
1689             else if (kill(pid, signum) < 0) {
1690                 xprintf("%d: %s\n", pid, strerror(errno));
1691                 err1++;
1692                 goto cont;
1693             }
1694 #ifdef BSDJOBS
1695             if (signum == SIGTERM || signum == SIGHUP)
1696                 (void) kill(pid, SIGCONT);
1697 #endif /* BSDJOBS */
1698         }
1699 cont:
1700         v++;
1701     }
1702     if (gargv)
1703         blkfree(gargv), gargv = 0;
1704 #ifdef BSDSIGS
1705     (void) sigsetmask(omask);
1706 #else /* !BSDSIGS */
1707     (void) sigrelse(SIGCHLD);
1708     if (setintr)
1709         (void) sigrelse(SIGINT);
1710 #endif /* !BSDSIGS */
1711     if (err1)
1712         stderror(ERR_SILENT);
1713 }
1714
1715 /*
1716  * pstart - start the job in foreground/background
1717  */
1718 int
1719 pstart(pp, foregnd)
1720     register struct process *pp;
1721     int     foregnd;
1722 {
1723     int rv = 0;
1724     register struct process *np;
1725 #ifdef BSDSIGS
1726     sigmask_t omask;
1727 #endif /* BSDSIGS */
1728     /* We don't use jobflags in this function right now (see below) */
1729     /* long    jobflags = 0; */
1730
1731 #ifdef BSDSIGS
1732     omask = sigblock(sigmask(SIGCHLD));
1733 #else /* !BSDSIGS */
1734     (void) sighold(SIGCHLD);
1735 #endif
1736     np = pp;
1737     do {
1738         /* We don't use jobflags in this function right now (see below) */
1739         /* jobflags |= np->p_flags; */
1740         if (np->p_flags & (PRUNNING | PSTOPPED)) {
1741             np->p_flags |= PRUNNING;
1742             np->p_flags &= ~PSTOPPED;
1743             if (foregnd)
1744                 np->p_flags |= PFOREGND;
1745             else
1746                 np->p_flags &= ~PFOREGND;
1747         }
1748     } while ((np = np->p_friends) != pp);
1749     if (!foregnd)
1750         pclrcurr(pp);
1751     (void) pprint(pp, foregnd ? NAME | JOBDIR : NUMBER | NAME | AMPERSAND);
1752
1753     /* GrP run jobcmd hook if foregrounding */
1754     if (foregnd) {
1755         job_cmd(pp->p_command);
1756     }
1757
1758 #ifdef BSDJOBS
1759     if (foregnd) {
1760         rv = tcsetpgrp(FSHTTY, pp->p_jobid);
1761     }
1762     /*
1763      * 1. child process of csh (shell script) receives SIGTTIN/SIGTTOU
1764      * 2. parent process (csh) receives SIGCHLD
1765      * 3. The "csh" signal handling function pchild() is invoked
1766      *    with a SIGCHLD signal.
1767      * 4. pchild() calls wait3(WNOHANG) which returns 0.
1768      *    The child process is NOT ready to be waited for at this time.
1769      *    pchild() returns without picking-up the correct status
1770      *    for the child process which generated the SIGCHILD.
1771      * 5. CONSEQUENCE : csh is UNaware that the process is stopped
1772      * 6. THIS LINE HAS BEEN COMMENTED OUT : if (jobflags&PSTOPPED)
1773      *    (beto@aixwiz.austin.ibm.com - aug/03/91)
1774      * 7. I removed the line completely and added extra checks for
1775      *    pstart, so that if a job gets attached to and dies inside
1776      *    a debugger it does not confuse the shell. [christos]
1777      * 8. on the nec sx-4 there seems to be a problem, which requires
1778      *    a syscall(151, getpid(), getpid()) in osinit. Don't ask me
1779      *    what this is doing. [schott@rzg.mpg.de]
1780      */
1781
1782     if (rv != -1)
1783         rv = killpg(pp->p_jobid, SIGCONT);
1784 #endif /* BSDJOBS */
1785 #ifdef BSDSIGS
1786     (void) sigsetmask(omask);
1787 #else /* !BSDSIGS */
1788     (void) sigrelse(SIGCHLD);
1789 #endif /* !BSDSIGS */
1790     return rv != -1;
1791 }
1792
1793 void
1794 panystop(neednl)
1795     bool    neednl;
1796 {
1797     register struct process *pp;
1798
1799     chkstop = 2;
1800     for (pp = proclist.p_next; pp; pp = pp->p_next)
1801         if (pp->p_flags & PSTOPPED)
1802             stderror(ERR_STOPPED, neednl ? "\n" : "");
1803 }
1804
1805 struct process *
1806 pfind(cp)
1807     Char   *cp;
1808 {
1809     register struct process *pp, *np;
1810
1811     if (cp == 0 || cp[1] == 0 || eq(cp, STRcent2) || eq(cp, STRcentplus)) {
1812         if (pcurrent == NULL)
1813             stderror(ERR_NAME | ERR_JOBCUR);
1814         return (pcurrent);
1815     }
1816     if (eq(cp, STRcentminus) || eq(cp, STRcenthash)) {
1817         if (pprevious == NULL)
1818             stderror(ERR_NAME | ERR_JOBPREV);
1819         return (pprevious);
1820     }
1821     if (Isdigit(cp[1])) {
1822         int     idx = atoi(short2str(cp + 1));
1823
1824         for (pp = proclist.p_next; pp; pp = pp->p_next)
1825             if (pp->p_index == idx && pp->p_procid == pp->p_jobid)
1826                 return (pp);
1827         stderror(ERR_NAME | ERR_NOSUCHJOB);
1828     }
1829     np = NULL;
1830     for (pp = proclist.p_next; pp; pp = pp->p_next)
1831         if (pp->p_procid == pp->p_jobid) {
1832             if (cp[1] == '?') {
1833                 register Char *dp;
1834
1835                 for (dp = pp->p_command; *dp; dp++) {
1836                     if (*dp != cp[2])
1837                         continue;
1838                     if (prefix(cp + 2, dp))
1839                         goto match;
1840                 }
1841             }
1842             else if (prefix(cp + 1, pp->p_command)) {
1843         match:
1844                 if (np)
1845                     stderror(ERR_NAME | ERR_AMBIG);
1846                 np = pp;
1847             }
1848         }
1849     if (np)
1850         return (np);
1851     stderror(ERR_NAME | (cp[1] == '?' ? ERR_JOBPAT : ERR_NOSUCHJOB));
1852     /* NOTREACHED */
1853     return (0);
1854 }
1855
1856
1857 /*
1858  * pgetcurr - find most recent job that is not pp, preferably stopped
1859  */
1860 static struct process *
1861 pgetcurr(pp)
1862     register struct process *pp;
1863 {
1864     register struct process *np;
1865     register struct process *xp = NULL;
1866
1867     for (np = proclist.p_next; np; np = np->p_next)
1868         if (np != pcurrent && np != pp && np->p_procid &&
1869             np->p_procid == np->p_jobid) {
1870             if (np->p_flags & PSTOPPED)
1871                 return (np);
1872             if (xp == NULL)
1873                 xp = np;
1874         }
1875     return (xp);
1876 }
1877
1878 /*
1879  * donotify - flag the job so as to report termination asynchronously
1880  */
1881 /*ARGSUSED*/
1882 void
1883 donotify(v, c)
1884     Char  **v;
1885     struct command *c;
1886 {
1887     register struct process *pp;
1888
1889     USE(c);
1890     pp = pfind(*++v);
1891     pp->p_flags |= PNOTIFY;
1892 }
1893
1894 /*
1895  * Do the fork and whatever should be done in the child side that
1896  * should not be done if we are not forking at all (like for simple builtin's)
1897  * Also do everything that needs any signals fiddled with in the parent side
1898  *
1899  * Wanttty tells whether process and/or tty pgrps are to be manipulated:
1900  *      -1:     leave tty alone; inherit pgrp from parent
1901  *       0:     already have tty; manipulate process pgrps only
1902  *       1:     want to claim tty; manipulate process and tty pgrps
1903  * It is usually just the value of tpgrp.
1904  */
1905
1906 int
1907 pfork(t, wanttty)
1908     struct command *t;          /* command we are forking for */
1909     int     wanttty;
1910 {
1911     register int pid;
1912     bool    ignint = 0;
1913     int     pgrp;
1914 #ifdef BSDSIGS
1915     sigmask_t omask = 0;
1916 #endif /* BSDSIGS */
1917 #ifdef SIGSYNCH
1918     sigvec_t osv;
1919     static sigvec_t nsv = {synch_handler, (sigset_t) ~0, 0};
1920 #endif /* SIGSYNCH */
1921
1922     /*
1923      * A child will be uninterruptible only under very special conditions.
1924      * Remember that the semantics of '&' is implemented by disconnecting the
1925      * process from the tty so signals do not need to ignored just for '&'.
1926      * Thus signals are set to default action for children unless: we have had
1927      * an "onintr -" (then specifically ignored) we are not playing with
1928      * signals (inherit action)
1929      */
1930     if (setintr)
1931         ignint = (tpgrp == -1 && (t->t_dflg & F_NOINTERRUPT))
1932             || (gointr && eq(gointr, STRminus));
1933
1934 #ifdef COHERENT
1935     ignint |= gointr && eq(gointr, STRminus);
1936 #endif /* COHERENT */
1937
1938     /*
1939      * Check for maximum nesting of 16 processes to avoid Forking loops
1940      */
1941     if (child == 16)
1942         stderror(ERR_NESTING, 16);
1943 #ifdef SIGSYNCH
1944     if (mysigvec(SIGSYNCH, &nsv, &osv))
1945         stderror(ERR_SYSTEM, "pfork: sigvec set", strerror(errno));
1946 #endif /* SIGSYNCH */
1947     /*
1948      * Hold SIGCHLD until we have the process installed in our table.
1949      */
1950     if (wanttty < 0) {
1951 #ifdef BSDSIGS
1952         omask = sigblock(sigmask(SIGCHLD));
1953 #else /* !BSDSIGS */
1954         (void) sighold(SIGCHLD);
1955 #endif /* !BSDSIGS */
1956     }
1957     while ((pid = fork()) == -1)
1958         if (setintr == 0)
1959             (void) sleep(FORKSLEEP);
1960         else {
1961             if (wanttty < 0)
1962 #ifdef BSDSIGS
1963                 (void) sigsetmask(omask);
1964 #else /* !BSDSIGS */
1965                 (void) sigrelse(SIGCHLD);
1966             (void) sigrelse(SIGINT);
1967 #endif /* !BSDSIGS */
1968             stderror(ERR_NOPROC);
1969         }
1970     if (pid == 0) {
1971         settimes();
1972         pgrp = pcurrjob ? pcurrjob->p_jobid : getpid();
1973         pflushall();
1974         pcurrjob = NULL;
1975 #if !defined(BSDTIMES) && !defined(_SEQUENT_)
1976         timesdone = 0;
1977 #endif /* !defined(BSDTIMES) && !defined(_SEQUENT_) */
1978         child++;
1979         if (setintr) {
1980             setintr = 0;        /* until I think otherwise */
1981 #ifndef BSDSIGS
1982             if (wanttty < 0)
1983                 (void) sigrelse(SIGCHLD);
1984 #endif /* !BSDSIGS */
1985             /*
1986              * Children just get blown away on SIGINT, SIGQUIT unless "onintr
1987              * -" seen.
1988              */
1989             (void) signal(SIGINT, ignint ? SIG_IGN : SIG_DFL);
1990             (void) signal(SIGQUIT, ignint ? SIG_IGN : SIG_DFL);
1991 #ifdef BSDJOBS
1992             if (wanttty >= 0) {
1993                 /* make stoppable */
1994                 (void) signal(SIGTSTP, SIG_DFL);
1995                 (void) signal(SIGTTIN, SIG_DFL);
1996                 (void) signal(SIGTTOU, SIG_DFL);
1997             }
1998 #endif /* BSDJOBS */
1999             (void) signal(SIGTERM, parterm);
2000         }
2001         else if (tpgrp == -1 && (t->t_dflg & F_NOINTERRUPT)) {
2002             (void) signal(SIGINT, SIG_IGN);
2003             (void) signal(SIGQUIT, SIG_IGN);
2004         }
2005 #ifdef OREO
2006         sigignore(SIGIO);       /* ignore SIGIO in child too */
2007 #endif /* OREO */
2008
2009         pgetty(wanttty, pgrp);
2010         /*
2011          * Nohup and nice apply only to NODE_COMMAND's but it would be nice
2012          * (?!?) if you could say "nohup (foo;bar)" Then the parser would have
2013          * to know about nice/nohup/time
2014          */
2015         if (t->t_dflg & F_NOHUP)
2016             (void) signal(SIGHUP, SIG_IGN);
2017         if (t->t_dflg & F_NICE) {
2018             int nval = SIGN_EXTEND_CHAR(t->t_nice);
2019 #ifdef BSDNICE
2020             if (setpriority(PRIO_PROCESS, 0, nval) == -1 && errno)
2021                     stderror(ERR_SYSTEM, "setpriority", strerror(errno));
2022 #else /* !BSDNICE */
2023             (void) nice(nval);
2024 #endif /* !BSDNICE */
2025         }
2026 #ifdef F_VER
2027         if (t->t_dflg & F_VER) {
2028             tsetenv(STRSYSTYPE, t->t_systype ? STRbsd43 : STRsys53);
2029             dohash(NULL, NULL);
2030         }
2031 #endif /* F_VER */
2032 #ifdef SIGSYNCH
2033         /* rfw 8/89 now parent can continue */
2034         if (kill(getppid(), SIGSYNCH))
2035             stderror(ERR_SYSTEM, "pfork child: kill", strerror(errno));
2036 #endif /* SIGSYNCH */
2037
2038     }
2039     else {
2040 #ifdef POSIXJOBS
2041         if (wanttty >= 0) {
2042             /*
2043              * `Walking' process group fix from Beto Appleton.
2044              * (beto@aixwiz.austin.ibm.com)
2045              * If setpgid fails at this point that means that
2046              * our process leader has died. We flush the current
2047              * job and become the process leader ourselves.
2048              * The parent will figure that out later.
2049              */
2050             pgrp = pcurrjob ? pcurrjob->p_jobid : pid;
2051             if (setpgid(pid, pgrp) == -1 && errno == EPERM) {
2052                 pcurrjob = NULL;
2053                 /*
2054                  * We don't care if this causes an error here;
2055                  * then we are already in the right process group
2056                  */
2057                 (void) setpgid(pid, pgrp = pid);
2058             }
2059         }
2060 #endif /* POSIXJOBS */
2061         palloc(pid, t);
2062 #ifdef SIGSYNCH
2063         /*
2064          * rfw 8/89 Wait for child to own terminal.  Solves half of ugly
2065          * synchronization problem.  With this change, we know that the only
2066          * reason setpgrp to a previous process in a pipeline can fail is that
2067          * the previous process has already exited. Without this hack, he may
2068          * either have exited or not yet started to run.  Two uglies become
2069          * one.
2070          */
2071         (void) sigpause(omask & ~SYNCHMASK);
2072         if (mysigvec(SIGSYNCH, &osv, NULL))
2073             stderror(ERR_SYSTEM, "pfork parent: sigvec restore",
2074                      strerror(errno));
2075 #endif /* SIGSYNCH */
2076
2077         if (wanttty < 0) {
2078 #ifdef BSDSIGS
2079             (void) sigsetmask(omask);
2080 #else /* !BSDSIGS */
2081             (void) sigrelse(SIGCHLD);
2082 #endif /* !BSDSIGS */
2083         }
2084     }
2085     return (pid);
2086 }
2087
2088 static void
2089 okpcntl()
2090 {
2091     if (tpgrp == -1)
2092         stderror(ERR_JOBCONTROL);
2093     if (tpgrp == 0)
2094         stderror(ERR_JOBCTRLSUB);
2095 }
2096
2097
2098 static void
2099 setttypgrp(pgrp)
2100     int pgrp;
2101 {
2102     /*
2103      * If we are piping out a builtin, eg. 'echo | more' things can go
2104      * out of sequence, i.e. the more can run before the echo. This
2105      * can happen even if we have vfork, since the echo will be forked
2106      * with the regular fork. In this case, we need to set the tty
2107      * pgrp ourselves. If that happens, then the process will be still
2108      * alive. And the tty process group will already be set.
2109      * This should fix the famous sequent problem as a side effect:
2110      *    The controlling terminal is lost if all processes in the
2111      *    terminal process group are zombies. In this case tcgetpgrp()
2112      *    returns 0. If this happens we must set the terminal process
2113      *    group again.
2114      */
2115     if (tcgetpgrp(FSHTTY) != pgrp) {
2116 #ifdef POSIXJOBS
2117         /*
2118          * tcsetpgrp will set SIGTTOU to all the the processes in
2119          * the background according to POSIX... We ignore this here.
2120          */
2121         signalfun_t old = sigset(SIGTTOU, SIG_IGN);
2122 #endif
2123         (void) tcsetpgrp(FSHTTY, pgrp);
2124 # ifdef POSIXJOBS
2125         (void) sigset(SIGTTOU, old);
2126 # endif
2127
2128     }
2129 }
2130
2131
2132 /*
2133  * if we don't have vfork(), things can still go in the wrong order
2134  * resulting in the famous 'Stopped (tty output)'. But some systems
2135  * don't permit the setpgid() call, (these are more recent secure
2136  * systems such as ibm's aix), when they do. Then we'd rather print
2137  * an error message than hang the shell!
2138  * I am open to suggestions how to fix that.
2139  */
2140 void
2141 pgetty(wanttty, pgrp)
2142     int     wanttty, pgrp;
2143 {
2144 #ifdef BSDJOBS
2145 # if defined(BSDSIGS) && defined(POSIXJOBS)
2146     sigmask_t omask = 0;
2147 # endif /* BSDSIGS && POSIXJOBS */
2148
2149 # ifdef JOBDEBUG
2150     xprintf("wanttty %d pid %d opgrp%d pgrp %d tpgrp %d\n",
2151             wanttty, getpid(), pgrp, mygetpgrp(), tcgetpgrp(FSHTTY));
2152 # endif /* JOBDEBUG */
2153 # ifdef POSIXJOBS
2154     /*
2155      * christos: I am blocking the tty signals till I've set things
2156      * correctly....
2157      */
2158     if (wanttty > 0)
2159 #  ifdef BSDSIGS
2160         omask = sigblock(sigmask(SIGTSTP)|sigmask(SIGTTIN));
2161 #  else /* !BSDSIGS */
2162     {
2163         (void) sighold(SIGTSTP);
2164         (void) sighold(SIGTTIN);
2165     }
2166 #  endif /* !BSDSIGS */
2167 # endif /* POSIXJOBS */
2168
2169 # ifndef POSIXJOBS
2170     if (wanttty > 0)
2171         setttypgrp(pgrp);
2172 # endif /* !POSIXJOBS */
2173
2174     /*
2175      * From: Michael Schroeder <mlschroe@immd4.informatik.uni-erlangen.de>
2176      * Don't check for tpgrp >= 0 so even non-interactive shells give
2177      * background jobs process groups Same for the comparison in the other part
2178      * of the #ifdef
2179      */
2180     if (wanttty >= 0) {
2181         if (setpgid(0, pgrp) == -1) {
2182 # ifdef POSIXJOBS
2183             /* Walking process group fix; see above */
2184             if (setpgid(0, pgrp = getpid()) == -1) {
2185 # endif /* POSIXJOBS */
2186                 stderror(ERR_SYSTEM, "setpgid child:\n", strerror(errno));
2187                 xexit(0);
2188 # ifdef POSIXJOBS
2189             }
2190             wanttty = pgrp;  /* Now we really want the tty, since we became the
2191                               * the process group leader
2192                               */
2193 # endif /* POSIXJOBS */
2194         }
2195     }
2196
2197 # ifdef POSIXJOBS
2198     if (wanttty > 0)
2199         setttypgrp(pgrp);
2200 #  ifdef BSDSIGS
2201     (void) sigsetmask(omask);
2202 #  else /* BSDSIGS */
2203     (void) sigrelse(SIGTSTP);
2204     (void) sigrelse(SIGTTIN);
2205 #  endif /* !BSDSIGS */
2206 # endif /* POSIXJOBS */
2207
2208 # ifdef JOBDEBUG
2209     xprintf("wanttty %d pid %d pgrp %d tpgrp %d\n",
2210             wanttty, getpid(), mygetpgrp(), tcgetpgrp(FSHTTY));
2211 # endif /* JOBDEBUG */
2212
2213     if (tpgrp > 0)
2214         tpgrp = 0;              /* gave tty away */
2215 #endif /* BSDJOBS */
2216 }