src/jobs.c

   1 /*      $OpenBSD: jobs.c,v 1.38 2009/12/12 04:28:44 deraadt Exp $       */
   2
   3 /*-
   4  * Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2011
   5  *      Thorsten Glaser <tg@mirbsd.org>
   6  *
   7  * Provided that these terms and disclaimer and all copyright notices
   8  * are retained or reproduced in an accompanying document, permission
   9  * is granted to deal in this work without restriction, including un-
  10  * limited rights to use, publicly perform, distribute, sell, modify,
  11  * merge, give away, or sublicence.
  12  *
  13  * This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to
  14  * the utmost extent permitted by applicable law, neither express nor
  15  * implied; without malicious intent or gross negligence. In no event
  16  * may a licensor, author or contributor be held liable for indirect,
  17  * direct, other damage, loss, or other issues arising in any way out
  18  * of dealing in the work, even if advised of the possibility of such
  19  * damage or existence of a defect, except proven that it results out
  20  * of said person's immediate fault when using the work as intended.
  21  */
  22
  23 #include "sh.h"
  24
  25 __RCSID("$MirOS: src/bin/mksh/jobs.c,v 1.81 2011/08/27 18:06:46 tg Exp $");
  26
  27 #if HAVE_KILLPG
  28 #define mksh_killpg             killpg
  29 #else
  30 /* cross fingers and hope kill is killpg-endowed */
  31 #define mksh_killpg(p,s)        kill(-(p), (s))
  32 #endif
  33
  34 /* Order important! */
  35 #define PRUNNING        0
  36 #define PEXITED         1
  37 #define PSIGNALLED      2
  38 #define PSTOPPED        3
  39
  40 typedef struct proc     Proc;
  41 struct proc {
  42         Proc *next;             /* next process in pipeline (if any) */
  43         pid_t pid;              /* process id */
  44         int state;
  45         int status;             /* wait status */
  46         char command[48];       /* process command string */
  47 };
  48
  49 /* Notify/print flag - j_print() argument */
  50 #define JP_NONE         0       /* don't print anything */
  51 #define JP_SHORT        1       /* print signals processes were killed by */
  52 #define JP_MEDIUM       2       /* print [job-num] -/+ command */
  53 #define JP_LONG         3       /* print [job-num] -/+ pid command */
  54 #define JP_PGRP         4       /* print pgrp */
  55
  56 /* put_job() flags */
  57 #define PJ_ON_FRONT     0       /* at very front */
  58 #define PJ_PAST_STOPPED 1       /* just past any stopped jobs */
  59
  60 /* Job.flags values */
  61 #define JF_STARTED      0x001   /* set when all processes in job are started */
  62 #define JF_WAITING      0x002   /* set if j_waitj() is waiting on job */
  63 #define JF_W_ASYNCNOTIFY 0x004  /* set if waiting and async notification ok */
  64 #define JF_XXCOM        0x008   /* set for $(command) jobs */
  65 #define JF_FG           0x010   /* running in foreground (also has tty pgrp) */
  66 #define JF_SAVEDTTY     0x020   /* j->ttystat is valid */
  67 #define JF_CHANGED      0x040   /* process has changed state */
  68 #define JF_KNOWN        0x080   /* $! referenced */
  69 #define JF_ZOMBIE       0x100   /* known, unwaited process */
  70 #define JF_REMOVE       0x200   /* flagged for removal (j_jobs()/j_noityf()) */
  71 #define JF_USETTYMODE   0x400   /* tty mode saved if process exits normally */
  72 #define JF_SAVEDTTYPGRP 0x800   /* j->saved_ttypgrp is valid */
  73
  74 typedef struct job Job;
  75 struct job {
  76         Job *next;              /* next job in list */
  77         Proc *proc_list;        /* process list */
  78         Proc *last_proc;        /* last process in list */
  79         struct timeval systime; /* system time used by job */
  80         struct timeval usrtime; /* user time used by job */
  81         pid_t pgrp;             /* process group of job */
  82         pid_t ppid;             /* pid of process that forked job */
  83         int job;                /* job number: %n */
  84         int flags;              /* see JF_* */
  85         volatile int state;     /* job state */
  86         int status;             /* exit status of last process */
  87         int32_t age;            /* number of jobs started */
  88         Coproc_id coproc_id;    /* 0 or id of coprocess output pipe */
  89 #ifndef MKSH_UNEMPLOYED
  90         struct termios ttystat; /* saved tty state for stopped jobs */
  91         pid_t saved_ttypgrp;    /* saved tty process group for stopped jobs */
  92 #endif
  93 };
  94
  95 /* Flags for j_waitj() */
  96 #define JW_NONE         0x00
  97 #define JW_INTERRUPT    0x01    /* ^C will stop the wait */
  98 #define JW_ASYNCNOTIFY  0x02    /* asynchronous notification during wait ok */
  99 #define JW_STOPPEDWAIT  0x04    /* wait even if job stopped */
 100 #define JW_PIPEST       0x08    /* want PIPESTATUS */
 101
 102 /* Error codes for j_lookup() */
 103 #define JL_OK           0
 104 #define JL_NOSUCH       1       /* no such job */
 105 #define JL_AMBIG        2       /* %foo or %?foo is ambiguous */
 106 #define JL_INVALID      3       /* non-pid, non-% job id */
 107
 108 static const char *const lookup_msgs[] = {
 109         null,
 110         "no such job",
 111         "ambiguous",
 112         "argument must be %job or process id",
 113         NULL
 114 };
 115
 116 static Job *job_list;           /* job list */
 117 static Job *last_job;
 118 static Job *async_job;
 119 static pid_t async_pid;
 120
 121 static int nzombie;             /* # of zombies owned by this process */
 122 static int32_t njobs;           /* # of jobs started */
 123
 124 #ifndef CHILD_MAX
 125 #define CHILD_MAX       25
 126 #endif
 127
 128 #ifndef MKSH_NOPROSPECTOFWORK
 129 /* held_sigchld is set if sigchld occurs before a job is completely started */
 130 static volatile sig_atomic_t held_sigchld;
 131 #endif
 132
 133 #ifndef MKSH_UNEMPLOYED
 134 static struct shf       *shl_j;
 135 static bool             ttypgrp_ok;     /* set if can use tty pgrps */
 136 static pid_t            restore_ttypgrp = -1;
 137 static int const        tt_sigs[] = { SIGTSTP, SIGTTIN, SIGTTOU };
 138 #endif
 139
 140 static void             j_set_async(Job *);
 141 static void             j_startjob(Job *);
 142 static int              j_waitj(Job *, int, const char *);
 143 static void             j_sigchld(int);
 144 static void             j_print(Job *, int, struct shf *);
 145 static Job              *j_lookup(const char *, int *);
 146 static Job              *new_job(void);
 147 static Proc             *new_proc(void);
 148 static void             check_job(Job *);
 149 static void             put_job(Job *, int);
 150 static void             remove_job(Job *, const char *);
 151 static int              kill_job(Job *, int);
 152
 153 /* initialise job control */
 154 void
 155 j_init(void)
 156 {
 157 #ifndef MKSH_UNEMPLOYED
 158         bool mflagset = Flag(FMONITOR) != 127;
 159
 160         Flag(FMONITOR) = 0;
 161 #endif
 162
 163 #ifndef MKSH_NOPROSPECTOFWORK
 164         (void)sigemptyset(&sm_default);
 165         sigprocmask(SIG_SETMASK, &sm_default, NULL);
 166
 167         (void)sigemptyset(&sm_sigchld);
 168         (void)sigaddset(&sm_sigchld, SIGCHLD);
 169
 170         setsig(&sigtraps[SIGCHLD], j_sigchld,
 171             SS_RESTORE_ORIG|SS_FORCE|SS_SHTRAP);
 172 #else
 173         /* Make sure SIGCHLD isn't ignored - can do odd things under SYSV */
 174         setsig(&sigtraps[SIGCHLD], SIG_DFL, SS_RESTORE_ORIG|SS_FORCE);
 175 #endif
 176
 177 #ifndef MKSH_UNEMPLOYED
 178         if (!mflagset && Flag(FTALKING))
 179                 Flag(FMONITOR) = 1;
 180
 181         /*
 182          * shl_j is used to do asynchronous notification (used in
 183          * an interrupt handler, so need a distinct shf)
 184          */
 185         shl_j = shf_fdopen(2, SHF_WR, NULL);
 186
 187         if (Flag(FMONITOR) || Flag(FTALKING)) {
 188                 int i;
 189
 190                 /*
 191                  * the TF_SHELL_USES test is a kludge that lets us know if
 192                  * if the signals have been changed by the shell.
 193                  */
 194                 for (i = NELEM(tt_sigs); --i >= 0; ) {
 195                         sigtraps[tt_sigs[i]].flags |= TF_SHELL_USES;
 196                         /* j_change() sets this to SS_RESTORE_DFL if FMONITOR */
 197                         setsig(&sigtraps[tt_sigs[i]], SIG_IGN,
 198                             SS_RESTORE_IGN|SS_FORCE);
 199                 }
 200         }
 201
 202         /* j_change() calls tty_init() */
 203         if (Flag(FMONITOR))
 204                 j_change();
 205         else
 206 #endif
 207           if (Flag(FTALKING))
 208                 tty_init(true, true);
 209 }
 210
 211 static int
 212 proc_errorlevel(Proc *p)
 213 {
 214         switch (p->state) {
 215         case PEXITED:
 216                 return (WEXITSTATUS(p->status));
 217         case PSIGNALLED:
 218                 return (128 + WTERMSIG(p->status));
 219         default:
 220                 return (0);
 221         }
 222 }
 223
 224 /* job cleanup before shell exit */
 225 void
 226 j_exit(void)
 227 {
 228         /* kill stopped, and possibly running, jobs */
 229         Job *j;
 230         bool killed = false;
 231
 232         for (j = job_list; j != NULL; j = j->next) {
 233                 if (j->ppid == procpid &&
 234                     (j->state == PSTOPPED ||
 235                     (j->state == PRUNNING &&
 236                     ((j->flags & JF_FG) ||
 237                     (Flag(FLOGIN) && !Flag(FNOHUP) && procpid == kshpid))))) {
 238                         killed = true;
 239                         if (j->pgrp == 0)
 240                                 kill_job(j, SIGHUP);
 241                         else
 242                                 mksh_killpg(j->pgrp, SIGHUP);
 243 #ifndef MKSH_UNEMPLOYED
 244                         if (j->state == PSTOPPED) {
 245                                 if (j->pgrp == 0)
 246                                         kill_job(j, SIGCONT);
 247                                 else
 248                                         mksh_killpg(j->pgrp, SIGCONT);
 249                         }
 250 #endif
 251                 }
 252         }
 253         if (killed)
 254                 sleep(1);
 255         j_notify();
 256
 257 #ifndef MKSH_UNEMPLOYED
 258         if (kshpid == procpid && restore_ttypgrp >= 0) {
 259                 /*
 260                  * Need to restore the tty pgrp to what it was when the
 261                  * shell started up, so that the process that started us
 262                  * will be able to access the tty when we are done.
 263                  * Also need to restore our process group in case we are
 264                  * about to do an exec so that both our parent and the
 265                  * process we are to become will be able to access the tty.
 266                  */
 267                 tcsetpgrp(tty_fd, restore_ttypgrp);
 268                 setpgid(0, restore_ttypgrp);
 269         }
 270         if (Flag(FMONITOR)) {
 271                 Flag(FMONITOR) = 0;
 272                 j_change();
 273         }
 274 #endif
 275 }
 276
 277 #ifndef MKSH_UNEMPLOYED
 278 /* turn job control on or off according to Flag(FMONITOR) */
 279 void
 280 j_change(void)
 281 {
 282         int i;
 283
 284         if (Flag(FMONITOR)) {
 285                 bool use_tty = Flag(FTALKING);
 286
 287                 /* Don't call tcgetattr() 'til we own the tty process group */
 288                 if (use_tty)
 289                         tty_init(false, true);
 290
 291                 /* no controlling tty, no SIGT* */
 292                 if ((ttypgrp_ok = use_tty && tty_fd >= 0 && tty_devtty)) {
 293                         setsig(&sigtraps[SIGTTIN], SIG_DFL,
 294                             SS_RESTORE_ORIG|SS_FORCE);
 295                         /* wait to be given tty (POSIX.1, B.2, job control) */
 296                         while (/* CONSTCOND */ 1) {
 297                                 pid_t ttypgrp;
 298
 299                                 if ((ttypgrp = tcgetpgrp(tty_fd)) < 0) {
 300                                         warningf(false, "%s: %s %s: %s",
 301                                             "j_init", "tcgetpgrp", "failed",
 302                                             strerror(errno));
 303                                         ttypgrp_ok = false;
 304                                         break;
 305                                 }
 306                                 if (ttypgrp == kshpgrp)
 307                                         break;
 308                                 kill(0, SIGTTIN);
 309                         }
 310                 }
 311                 for (i = NELEM(tt_sigs); --i >= 0; )
 312                         setsig(&sigtraps[tt_sigs[i]], SIG_IGN,
 313                             SS_RESTORE_DFL|SS_FORCE);
 314                 if (ttypgrp_ok && kshpgrp != kshpid) {
 315                         if (setpgid(0, kshpid) < 0) {
 316                                 warningf(false, "%s: %s %s: %s", "j_init",
 317                                     "setpgid", "failed", strerror(errno));
 318                                 ttypgrp_ok = false;
 319                         } else {
 320                                 if (tcsetpgrp(tty_fd, kshpid) < 0) {
 321                                         warningf(false, "%s: %s %s: %s",
 322                                             "j_init", "tcsetpgrp", "failed",
 323                                             strerror(errno));
 324                                         ttypgrp_ok = false;
 325                                 } else
 326                                         restore_ttypgrp = kshpgrp;
 327                                 kshpgrp = kshpid;
 328                         }
 329                 }
 330                 if (use_tty && !ttypgrp_ok)
 331                         warningf(false, "%s: %s", "warning",
 332                             "won't have full job control");
 333                 if (tty_fd >= 0)
 334                         tcgetattr(tty_fd, &tty_state);
 335         } else {
 336                 ttypgrp_ok = false;
 337                 if (Flag(FTALKING))
 338                         for (i = NELEM(tt_sigs); --i >= 0; )
 339                                 setsig(&sigtraps[tt_sigs[i]], SIG_IGN,
 340                                     SS_RESTORE_IGN|SS_FORCE);
 341                 else
 342                         for (i = NELEM(tt_sigs); --i >= 0; ) {
 343                                 if (sigtraps[tt_sigs[i]].flags &
 344                                     (TF_ORIG_IGN | TF_ORIG_DFL))
 345                                         setsig(&sigtraps[tt_sigs[i]],
 346                                             (sigtraps[tt_sigs[i]].flags & TF_ORIG_IGN) ?
 347                                             SIG_IGN : SIG_DFL,
 348                                             SS_RESTORE_ORIG|SS_FORCE);
 349                         }
 350                 if (!Flag(FTALKING))
 351                         tty_close();
 352         }
 353 }
 354 #endif
 355
 356 #if HAVE_NICE
 357 /* run nice(3) and ignore the result */
 358 static void
 359 ksh_nice(int ness)
 360 {
 361 #if defined(__USE_FORTIFY_LEVEL) && (__USE_FORTIFY_LEVEL > 0)
 362         int e;
 363
 364         errno = 0;
 365         /* this is gonna annoy users; complain to your distro, people! */
 366         if (nice(ness) == -1 && (e = errno) != 0)
 367                 warningf(false, "%s: %s", "bgnice", strerror(e));
 368 #else
 369         (void)nice(ness);
 370 #endif
 371 }
 372 #endif
 373
 374 /* execute tree in child subprocess */
 375 int
 376 exchild(struct op *t, int flags,
 377     volatile int *xerrok,
 378     /* used if XPCLOSE or XCCLOSE */
 379     int close_fd)
 380 {
 381         /* for pipelines */
 382         static Proc *last_proc;
 383
 384         int rv = 0, forksleep, jwflags = JW_NONE;
 385 #ifndef MKSH_NOPROSPECTOFWORK
 386         sigset_t omask;
 387 #endif
 388         Proc *p;
 389         Job *j;
 390         pid_t cldpid;
 391
 392         if (flags & XPIPEST) {
 393                 flags &= ~XPIPEST;
 394                 jwflags |= JW_PIPEST;
 395         }
 396
 397         if (flags & XEXEC)
 398                 /*
 399                  * Clear XFORK|XPCLOSE|XCCLOSE|XCOPROC|XPIPEO|XPIPEI|XXCOM|XBGND
 400                  * (also done in another execute() below)
 401                  */
 402                 return (execute(t, flags & (XEXEC | XERROK), xerrok));
 403
 404 #ifndef MKSH_NOPROSPECTOFWORK
 405         /* no SIGCHLDs while messing with job and process lists */
 406         sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
 407 #endif
 408
 409         p = new_proc();
 410         p->next = NULL;
 411         p->state = PRUNNING;
 412         p->status = 0;
 413         p->pid = 0;
 414
 415         /* link process into jobs list */
 416         if (flags & XPIPEI) {
 417                 /* continuing with a pipe */
 418                 if (!last_job)
 419                         internal_errorf("%s %d",
 420                             "exchild: XPIPEI and no last_job - pid",
 421                             (int)procpid);
 422                 j = last_job;
 423                 if (last_proc)
 424                         last_proc->next = p;
 425                 last_proc = p;
 426         } else {
 427                 /* fills in j->job */
 428                 j = new_job();
 429                 /*
 430                  * we don't consider XXCOMs foreground since they don't get
 431                  * tty process group and we don't save or restore tty modes.
 432                  */
 433                 j->flags = (flags & XXCOM) ? JF_XXCOM :
 434                     ((flags & XBGND) ? 0 : (JF_FG|JF_USETTYMODE));
 435                 timerclear(&j->usrtime);
 436                 timerclear(&j->systime);
 437                 j->state = PRUNNING;
 438                 j->pgrp = 0;
 439                 j->ppid = procpid;
 440                 j->age = ++njobs;
 441                 j->proc_list = p;
 442                 j->coproc_id = 0;
 443                 last_job = j;
 444                 last_proc = p;
 445                 put_job(j, PJ_PAST_STOPPED);
 446         }
 447
 448         vistree(p->command, sizeof(p->command), t);
 449
 450         /* create child process */
 451         forksleep = 1;
 452         while ((cldpid = fork()) < 0 && errno == EAGAIN && forksleep < 32) {
 453                 if (intrsig)
 454                         /* allow user to ^C out... */
 455                         break;
 456                 sleep(forksleep);
 457                 forksleep <<= 1;
 458         }
 459         /* ensure $RANDOM changes between parent and child */
 460         rndset((long)cldpid);
 461         /* fork failed? */
 462         if (cldpid < 0) {
 463                 kill_job(j, SIGKILL);
 464                 remove_job(j, "fork failed");
 465 #ifndef MKSH_NOPROSPECTOFWORK
 466                 sigprocmask(SIG_SETMASK, &omask, NULL);
 467 #endif
 468                 errorf("can't fork - try again");
 469         }
 470         p->pid = cldpid ? cldpid : (procpid = getpid());
 471
 472 #ifndef MKSH_UNEMPLOYED
 473         /* job control set up */
 474         if (Flag(FMONITOR) && !(flags&XXCOM)) {
 475                 bool dotty = false;
 476                 if (j->pgrp == 0) {
 477                         /* First process */
 478                         j->pgrp = p->pid;
 479                         dotty = true;
 480                 }
 481
 482                 /*
 483                  * set pgrp in both parent and child to deal with race
 484                  * condition
 485                  */
 486                 setpgid(p->pid, j->pgrp);
 487                 if (ttypgrp_ok && dotty && !(flags & XBGND))
 488                         tcsetpgrp(tty_fd, j->pgrp);
 489         }
 490 #endif
 491
 492         /* used to close pipe input fd */
 493         if (close_fd >= 0 && (((flags & XPCLOSE) && cldpid) ||
 494             ((flags & XCCLOSE) && !cldpid)))
 495                 close(close_fd);
 496         if (!cldpid) {
 497                 /* child */
 498
 499                 /* Do this before restoring signal */
 500                 if (flags & XCOPROC)
 501                         coproc_cleanup(false);
 502 #ifndef MKSH_NOPROSPECTOFWORK
 503                 sigprocmask(SIG_SETMASK, &omask, NULL);
 504 #endif
 505                 cleanup_parents_env();
 506 #ifndef MKSH_UNEMPLOYED
 507                 /*
 508                  * If FMONITOR or FTALKING is set, these signals are ignored,
 509                  * if neither FMONITOR nor FTALKING are set, the signals have
 510                  * their inherited values.
 511                  */
 512                 if (Flag(FMONITOR) && !(flags & XXCOM)) {
 513                         for (forksleep = NELEM(tt_sigs); --forksleep >= 0; )
 514                                 setsig(&sigtraps[tt_sigs[forksleep]], SIG_DFL,
 515                                     SS_RESTORE_DFL|SS_FORCE);
 516                 }
 517 #endif
 518 #if HAVE_NICE
 519                 if (Flag(FBGNICE) && (flags & XBGND))
 520                         ksh_nice(4);
 521 #endif
 522                 if ((flags & XBGND)
 523 #ifndef MKSH_UNEMPLOYED
 524                     && !Flag(FMONITOR)
 525 #endif
 526                     ) {
 527                         setsig(&sigtraps[SIGINT], SIG_IGN,
 528                             SS_RESTORE_IGN|SS_FORCE);
 529                         setsig(&sigtraps[SIGQUIT], SIG_IGN,
 530                             SS_RESTORE_IGN|SS_FORCE);
 531                         if ((!(flags & (XPIPEI | XCOPROC))) &&
 532                             ((forksleep = open("/dev/null", 0)) > 0)) {
 533                                 (void)ksh_dup2(forksleep, 0, true);
 534                                 close(forksleep);
 535                         }
 536                 }
 537                 /* in case of $(jobs) command */
 538                 remove_job(j, "child");
 539                 nzombie = 0;
 540 #ifndef MKSH_UNEMPLOYED
 541                 ttypgrp_ok = false;
 542                 Flag(FMONITOR) = 0;
 543 #endif
 544                 Flag(FTALKING) = 0;
 545                 tty_close();
 546                 cleartraps();
 547                 /* no return */
 548                 execute(t, (flags & XERROK) | XEXEC, NULL);
 549 #ifndef MKSH_SMALL
 550                 if (t->type == TPIPE)
 551                         unwind(LLEAVE);
 552                 internal_warningf("%s: %s", "exchild", "execute() returned");
 553                 fptreef(shl_out, 8, "%s: tried to execute {\n\t%T\n}\n",
 554                     "exchild", t);
 555                 shf_flush(shl_out);
 556 #endif
 557                 unwind(LLEAVE);
 558                 /* NOTREACHED */
 559         }
 560
 561         /* shell (parent) stuff */
 562         if (!(flags & XPIPEO)) {
 563                 /* last process in a job */
 564                 j_startjob(j);
 565                 if (flags & XCOPROC) {
 566                         j->coproc_id = coproc.id;
 567                         /* n jobs using co-process output */
 568                         coproc.njobs++;
 569                         /* j using co-process input */
 570                         coproc.job = (void *)j;
 571                 }
 572                 if (flags & XBGND) {
 573                         j_set_async(j);
 574                         if (Flag(FTALKING)) {
 575                                 shf_fprintf(shl_out, "[%d]", j->job);
 576                                 for (p = j->proc_list; p; p = p->next)
 577                                         shf_fprintf(shl_out, " %d",
 578                                             (int)p->pid);
 579                                 shf_putchar('\n', shl_out);
 580                                 shf_flush(shl_out);
 581                         }
 582                 } else
 583                         rv = j_waitj(j, jwflags, "jw:last proc");
 584         }
 585
 586 #ifndef MKSH_NOPROSPECTOFWORK
 587         sigprocmask(SIG_SETMASK, &omask, NULL);
 588 #endif
 589
 590         return (rv);
 591 }
 592
 593 /* start the last job: only used for $(command) jobs */
 594 void
 595 startlast(void)
 596 {
 597 #ifndef MKSH_NOPROSPECTOFWORK
 598         sigset_t omask;
 599
 600         sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
 601 #endif
 602
 603         /* no need to report error - waitlast() will do it */
 604         if (last_job) {
 605                 /* ensure it isn't removed by check_job() */
 606                 last_job->flags |= JF_WAITING;
 607                 j_startjob(last_job);
 608         }
 609 #ifndef MKSH_NOPROSPECTOFWORK
 610         sigprocmask(SIG_SETMASK, &omask, NULL);
 611 #endif
 612 }
 613
 614 /* wait for last job: only used for $(command) jobs */
 615 int
 616 waitlast(void)
 617 {
 618         int rv;
 619         Job *j;
 620 #ifndef MKSH_NOPROSPECTOFWORK
 621         sigset_t omask;
 622
 623         sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
 624 #endif
 625
 626         j = last_job;
 627         if (!j || !(j->flags & JF_STARTED)) {
 628                 if (!j)
 629                         warningf(true, "%s: %s", "waitlast", "no last job");
 630                 else
 631                         internal_warningf("%s: %s", "waitlast", "not started");
 632 #ifndef MKSH_NOPROSPECTOFWORK
 633                 sigprocmask(SIG_SETMASK, &omask, NULL);
 634 #endif
 635                 /* not so arbitrary, non-zero value */
 636                 return (125);
 637         }
 638
 639         rv = j_waitj(j, JW_NONE, "waitlast");
 640
 641 #ifndef MKSH_NOPROSPECTOFWORK
 642         sigprocmask(SIG_SETMASK, &omask, NULL);
 643 #endif
 644
 645         return (rv);
 646 }
 647
 648 /* wait for child, interruptable. */
 649 int
 650 waitfor(const char *cp, int *sigp)
 651 {
 652         int rv, ecode, flags = JW_INTERRUPT|JW_ASYNCNOTIFY;
 653         Job *j;
 654 #ifndef MKSH_NOPROSPECTOFWORK
 655         sigset_t omask;
 656
 657         sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
 658 #endif
 659
 660         *sigp = 0;
 661
 662         if (cp == NULL) {
 663                 /*
 664                  * wait for an unspecified job - always returns 0, so
 665                  * don't have to worry about exited/signaled jobs
 666                  */
 667                 for (j = job_list; j; j = j->next)
 668                         /* AT&T ksh will wait for stopped jobs - we don't */
 669                         if (j->ppid == procpid && j->state == PRUNNING)
 670                                 break;
 671                 if (!j) {
 672 #ifndef MKSH_NOPROSPECTOFWORK
 673                         sigprocmask(SIG_SETMASK, &omask, NULL);
 674 #endif
 675                         return (-1);
 676                 }
 677         } else if ((j = j_lookup(cp, &ecode))) {
 678                 /* don't report normal job completion */
 679                 flags &= ~JW_ASYNCNOTIFY;
 680                 if (j->ppid != procpid) {
 681 #ifndef MKSH_NOPROSPECTOFWORK
 682                         sigprocmask(SIG_SETMASK, &omask, NULL);
 683 #endif
 684                         return (-1);
 685                 }
 686         } else {
 687 #ifndef MKSH_NOPROSPECTOFWORK
 688                 sigprocmask(SIG_SETMASK, &omask, NULL);
 689 #endif
 690                 if (ecode != JL_NOSUCH)
 691                         bi_errorf("%s: %s", cp, lookup_msgs[ecode]);
 692                 return (-1);
 693         }
 694
 695         /* AT&T ksh will wait for stopped jobs - we don't */
 696         rv = j_waitj(j, flags, "jw:waitfor");
 697
 698 #ifndef MKSH_NOPROSPECTOFWORK
 699         sigprocmask(SIG_SETMASK, &omask, NULL);
 700 #endif
 701
 702         if (rv < 0)
 703                 /* we were interrupted */
 704                 *sigp = 128 + -rv;
 705
 706         return (rv);
 707 }
 708
 709 /* kill (built-in) a job */
 710 int
 711 j_kill(const char *cp, int sig)
 712 {
 713         Job *j;
 714         int rv = 0, ecode;
 715 #ifndef MKSH_NOPROSPECTOFWORK
 716         sigset_t omask;
 717
 718         sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
 719 #endif
 720
 721         if ((j = j_lookup(cp, &ecode)) == NULL) {
 722 #ifndef MKSH_NOPROSPECTOFWORK
 723                 sigprocmask(SIG_SETMASK, &omask, NULL);
 724 #endif
 725                 bi_errorf("%s: %s", cp, lookup_msgs[ecode]);
 726                 return (1);
 727         }
 728
 729         if (j->pgrp == 0) {
 730                 /* started when !Flag(FMONITOR) */
 731                 if (kill_job(j, sig) < 0) {
 732                         bi_errorf("%s: %s", cp, strerror(errno));
 733                         rv = 1;
 734                 }
 735         } else {
 736 #ifndef MKSH_UNEMPLOYED
 737                 if (j->state == PSTOPPED && (sig == SIGTERM || sig == SIGHUP))
 738                         mksh_killpg(j->pgrp, SIGCONT);
 739 #endif
 740                 if (mksh_killpg(j->pgrp, sig) < 0) {
 741                         bi_errorf("%s: %s", cp, strerror(errno));
 742                         rv = 1;
 743                 }
 744         }
 745
 746 #ifndef MKSH_NOPROSPECTOFWORK
 747         sigprocmask(SIG_SETMASK, &omask, NULL);
 748 #endif
 749
 750         return (rv);
 751 }
 752
 753 #ifndef MKSH_UNEMPLOYED
 754 /* fg and bg built-ins: called only if Flag(FMONITOR) set */
 755 int
 756 j_resume(const char *cp, int bg)
 757 {
 758         Job *j;
 759         Proc *p;
 760         int ecode, rv = 0;
 761         bool running;
 762         sigset_t omask;
 763
 764         sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
 765
 766         if ((j = j_lookup(cp, &ecode)) == NULL) {
 767                 sigprocmask(SIG_SETMASK, &omask, NULL);
 768                 bi_errorf("%s: %s", cp, lookup_msgs[ecode]);
 769                 return (1);
 770         }
 771
 772         if (j->pgrp == 0) {
 773                 sigprocmask(SIG_SETMASK, &omask, NULL);
 774                 bi_errorf("job not job-controlled");
 775                 return (1);
 776         }
 777
 778         if (bg)
 779                 shprintf("[%d] ", j->job);
 780
 781         running = false;
 782         for (p = j->proc_list; p != NULL; p = p->next) {
 783                 if (p->state == PSTOPPED) {
 784                         p->state = PRUNNING;
 785                         p->status = 0;
 786                         running = true;
 787                 }
 788                 shf_puts(p->command, shl_stdout);
 789                 if (p->next)
 790                         shf_puts("| ", shl_stdout);
 791         }
 792         shf_putc('\n', shl_stdout);
 793         shf_flush(shl_stdout);
 794         if (running)
 795                 j->state = PRUNNING;
 796
 797         put_job(j, PJ_PAST_STOPPED);
 798         if (bg)
 799                 j_set_async(j);
 800         else {
 801                 /* attach tty to job */
 802                 if (j->state == PRUNNING) {
 803                         if (ttypgrp_ok && (j->flags & JF_SAVEDTTY))
 804                                 tcsetattr(tty_fd, TCSADRAIN, &j->ttystat);
 805                         /* See comment in j_waitj regarding saved_ttypgrp. */
 806                         if (ttypgrp_ok &&
 807                             tcsetpgrp(tty_fd, (j->flags & JF_SAVEDTTYPGRP) ?
 808                             j->saved_ttypgrp : j->pgrp) < 0) {
 809                                 rv = errno;
 810                                 if (j->flags & JF_SAVEDTTY)
 811                                         tcsetattr(tty_fd, TCSADRAIN, &tty_state);
 812                                 sigprocmask(SIG_SETMASK, &omask, NULL);
 813                                 bi_errorf("%s %s(%d, %ld) %s: %s",
 814                                     "1st", "tcsetpgrp", tty_fd,
 815                                     (long)((j->flags & JF_SAVEDTTYPGRP) ?
 816                                     j->saved_ttypgrp : j->pgrp), "failed",
 817                                     strerror(rv));
 818                                 return (1);
 819                         }
 820                 }
 821                 j->flags |= JF_FG;
 822                 j->flags &= ~JF_KNOWN;
 823                 if (j == async_job)
 824                         async_job = NULL;
 825         }
 826
 827         if (j->state == PRUNNING && mksh_killpg(j->pgrp, SIGCONT) < 0) {
 828                 int err = errno;
 829
 830                 if (!bg) {
 831                         j->flags &= ~JF_FG;
 832                         if (ttypgrp_ok && (j->flags & JF_SAVEDTTY))
 833                                 tcsetattr(tty_fd, TCSADRAIN, &tty_state);
 834                         if (ttypgrp_ok && tcsetpgrp(tty_fd, kshpgrp) < 0)
 835                                 warningf(true, "%s %s(%d, %ld) %s: %s",
 836                                     "fg: 2nd", "tcsetpgrp", tty_fd,
 837                                     (long)kshpgrp, "failed", strerror(errno));
 838                 }
 839                 sigprocmask(SIG_SETMASK, &omask, NULL);
 840                 bi_errorf("%s %s %s", "can't continue job",
 841                     cp, strerror(err));
 842                 return (1);
 843         }
 844         if (!bg) {
 845                 if (ttypgrp_ok) {
 846                         j->flags &= ~(JF_SAVEDTTY | JF_SAVEDTTYPGRP);
 847                 }
 848                 rv = j_waitj(j, JW_NONE, "jw:resume");
 849         }
 850         sigprocmask(SIG_SETMASK, &omask, NULL);
 851         return (rv);
 852 }
 853 #endif
 854
 855 /* are there any running or stopped jobs ? */
 856 int
 857 j_stopped_running(void)
 858 {
 859         Job *j;
 860         int which = 0;
 861
 862         for (j = job_list; j != NULL; j = j->next) {
 863 #ifndef MKSH_UNEMPLOYED
 864                 if (j->ppid == procpid && j->state == PSTOPPED)
 865                         which |= 1;
 866 #endif
 867                 if (Flag(FLOGIN) && !Flag(FNOHUP) && procpid == kshpid &&
 868                     j->ppid == procpid && j->state == PRUNNING)
 869                         which |= 2;
 870         }
 871         if (which) {
 872                 shellf("You have %s%s%s jobs\n",
 873                     which & 1 ? "stopped" : "",
 874                     which == 3 ? " and " : "",
 875                     which & 2 ? "running" : "");
 876                 return (1);
 877         }
 878
 879         return (0);
 880 }
 881
 882
 883 /* list jobs for jobs built-in */
 884 int
 885 j_jobs(const char *cp, int slp,
 886     /* 0: short, 1: long, 2: pgrp */
 887     int nflag)
 888 {
 889         Job *j, *tmp;
 890         int how, zflag = 0;
 891 #ifndef MKSH_NOPROSPECTOFWORK
 892         sigset_t omask;
 893
 894         sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
 895 #endif
 896
 897         if (nflag < 0) {
 898                 /* kludge: print zombies */
 899                 nflag = 0;
 900                 zflag = 1;
 901         }
 902         if (cp) {
 903                 int     ecode;
 904
 905                 if ((j = j_lookup(cp, &ecode)) == NULL) {
 906 #ifndef MKSH_NOPROSPECTOFWORK
 907                         sigprocmask(SIG_SETMASK, &omask, NULL);
 908 #endif
 909                         bi_errorf("%s: %s", cp, lookup_msgs[ecode]);
 910                         return (1);
 911                 }
 912         } else
 913                 j = job_list;
 914         how = slp == 0 ? JP_MEDIUM : (slp == 1 ? JP_LONG : JP_PGRP);
 915         for (; j; j = j->next) {
 916                 if ((!(j->flags & JF_ZOMBIE) || zflag) &&
 917                     (!nflag || (j->flags & JF_CHANGED))) {
 918                         j_print(j, how, shl_stdout);
 919                         if (j->state == PEXITED || j->state == PSIGNALLED)
 920                                 j->flags |= JF_REMOVE;
 921                 }
 922                 if (cp)
 923                         break;
 924         }
 925         /* Remove jobs after printing so there won't be multiple + or - jobs */
 926         for (j = job_list; j; j = tmp) {
 927                 tmp = j->next;
 928                 if (j->flags & JF_REMOVE)
 929                         remove_job(j, "jobs");
 930         }
 931 #ifndef MKSH_NOPROSPECTOFWORK
 932         sigprocmask(SIG_SETMASK, &omask, NULL);
 933 #endif
 934         return (0);
 935 }
 936
 937 /* list jobs for top-level notification */
 938 void
 939 j_notify(void)
 940 {
 941         Job *j, *tmp;
 942 #ifndef MKSH_NOPROSPECTOFWORK
 943         sigset_t omask;
 944
 945         sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
 946 #endif
 947         for (j = job_list; j; j = j->next) {
 948 #ifndef MKSH_UNEMPLOYED
 949                 if (Flag(FMONITOR) && (j->flags & JF_CHANGED))
 950                         j_print(j, JP_MEDIUM, shl_out);
 951 #endif
 952                 /*
 953                  * Remove job after doing reports so there aren't
 954                  * multiple +/- jobs.
 955                  */
 956                 if (j->state == PEXITED || j->state == PSIGNALLED)
 957                         j->flags |= JF_REMOVE;
 958         }
 959         for (j = job_list; j; j = tmp) {
 960                 tmp = j->next;
 961                 if (j->flags & JF_REMOVE)
 962                         remove_job(j, "notify");
 963         }
 964         shf_flush(shl_out);
 965 #ifndef MKSH_NOPROSPECTOFWORK
 966         sigprocmask(SIG_SETMASK, &omask, NULL);
 967 #endif
 968 }
 969
 970 /* Return pid of last process in last asynchronous job */
 971 pid_t
 972 j_async(void)
 973 {
 974 #ifndef MKSH_NOPROSPECTOFWORK
 975         sigset_t omask;
 976
 977         sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
 978 #endif
 979
 980         if (async_job)
 981                 async_job->flags |= JF_KNOWN;
 982
 983 #ifndef MKSH_NOPROSPECTOFWORK
 984         sigprocmask(SIG_SETMASK, &omask, NULL);
 985 #endif
 986
 987         return (async_pid);
 988 }
 989
 990 /*
 991  * Make j the last async process
 992  *
 993  * If jobs are compiled in then this routine expects sigchld to be blocked.
 994  */
 995 static void
 996 j_set_async(Job *j)
 997 {
 998         Job     *jl, *oldest;
 999
1000         if (async_job && (async_job->flags & (JF_KNOWN|JF_ZOMBIE)) == JF_ZOMBIE)
1001                 remove_job(async_job, "async");
1002         if (!(j->flags & JF_STARTED)) {
1003                 internal_warningf("%s: %s", "j_async", "job not started");
1004                 return;
1005         }
1006         async_job = j;
1007         async_pid = j->last_proc->pid;
1008         while (nzombie > CHILD_MAX) {
1009                 oldest = NULL;
1010                 for (jl = job_list; jl; jl = jl->next)
1011                         if (jl != async_job && (jl->flags & JF_ZOMBIE) &&
1012                             (!oldest || jl->age < oldest->age))
1013                                 oldest = jl;
1014                 if (!oldest) {
1015                         /* XXX debugging */
1016                         if (!(async_job->flags & JF_ZOMBIE) || nzombie != 1) {
1017                                 internal_warningf("%s: bad nzombie (%d)",
1018                                     "j_async", nzombie);
1019                                 nzombie = 0;
1020                         }
1021                         break;
1022                 }
1023                 remove_job(oldest, "zombie");
1024         }
1025 }
1026
1027 /*
1028  * Start a job: set STARTED, check for held signals and set j->last_proc
1029  *
1030  * If jobs are compiled in then this routine expects sigchld to be blocked.
1031  */
1032 static void
1033 j_startjob(Job *j)
1034 {
1035         Proc    *p;
1036
1037         j->flags |= JF_STARTED;
1038         for (p = j->proc_list; p->next; p = p->next)
1039                 ;
1040         j->last_proc = p;
1041
1042 #ifndef MKSH_NOPROSPECTOFWORK
1043         if (held_sigchld) {
1044                 held_sigchld = 0;
1045                 /* Don't call j_sigchld() as it may remove job... */
1046                 kill(procpid, SIGCHLD);
1047         }
1048 #endif
1049 }
1050
1051 /*
1052  * wait for job to complete or change state
1053  *
1054  * If jobs are compiled in then this routine expects sigchld to be blocked.
1055  */
1056 static int
1057 j_waitj(Job *j,
1058     /* see JW_* */
1059     int flags,
1060     const char *where)
1061 {
1062         int rv;
1063
1064         /*
1065          * No auto-notify on the job we are waiting on.
1066          */
1067         j->flags |= JF_WAITING;
1068         if (flags & JW_ASYNCNOTIFY)
1069                 j->flags |= JF_W_ASYNCNOTIFY;
1070
1071 #ifndef MKSH_UNEMPLOYED
1072         if (!Flag(FMONITOR))
1073 #endif
1074                 flags |= JW_STOPPEDWAIT;
1075
1076         while (j->state == PRUNNING ||
1077             ((flags & JW_STOPPEDWAIT) && j->state == PSTOPPED)) {
1078 #ifndef MKSH_NOPROSPECTOFWORK
1079                 sigsuspend(&sm_default);
1080 #else
1081                 j_sigchld(SIGCHLD);
1082 #endif
1083                 if (fatal_trap) {
1084                         int oldf = j->flags & (JF_WAITING|JF_W_ASYNCNOTIFY);
1085                         j->flags &= ~(JF_WAITING|JF_W_ASYNCNOTIFY);
1086                         runtraps(TF_FATAL);
1087                         /* not reached... */
1088                         j->flags |= oldf;
1089                 }
1090                 if ((flags & JW_INTERRUPT) && (rv = trap_pending())) {
1091                         j->flags &= ~(JF_WAITING|JF_W_ASYNCNOTIFY);
1092                         return (-rv);
1093                 }
1094         }
1095         j->flags &= ~(JF_WAITING|JF_W_ASYNCNOTIFY);
1096
1097         if (j->flags & JF_FG) {
1098                 j->flags &= ~JF_FG;
1099 #ifndef MKSH_UNEMPLOYED
1100                 if (Flag(FMONITOR) && ttypgrp_ok && j->pgrp) {
1101                         /*
1102                          * Save the tty's current pgrp so it can be restored
1103                          * when the job is foregrounded. This is to
1104                          * deal with things like the GNU su which does
1105                          * a fork/exec instead of an exec (the fork means
1106                          * the execed shell gets a different pid from its
1107                          * pgrp, so naturally it sets its pgrp and gets hosed
1108                          * when it gets foregrounded by the parent shell which
1109                          * has restored the tty's pgrp to that of the su
1110                          * process).
1111                          */
1112                         if (j->state == PSTOPPED &&
1113                             (j->saved_ttypgrp = tcgetpgrp(tty_fd)) >= 0)
1114                                 j->flags |= JF_SAVEDTTYPGRP;
1115                         if (tcsetpgrp(tty_fd, kshpgrp) < 0)
1116                                 warningf(true, "%s %s(%d, %ld) %s: %s",
1117                                     "j_waitj:", "tcsetpgrp", tty_fd,
1118                                     (long)kshpgrp, "failed", strerror(errno));
1119                         if (j->state == PSTOPPED) {
1120                                 j->flags |= JF_SAVEDTTY;
1121                                 tcgetattr(tty_fd, &j->ttystat);
1122                         }
1123                 }
1124 #endif
1125                 if (tty_fd >= 0) {
1126                         /*
1127                          * Only restore tty settings if job was originally
1128                          * started in the foreground. Problems can be
1129                          * caused by things like 'more foobar &' which will
1130                          * typically get and save the shell's vi/emacs tty
1131                          * settings before setting up the tty for itself;
1132                          * when more exits, it restores the 'original'
1133                          * settings, and things go down hill from there...
1134                          */
1135                         if (j->state == PEXITED && j->status == 0 &&
1136                             (j->flags & JF_USETTYMODE)) {
1137                                 tcgetattr(tty_fd, &tty_state);
1138                         } else {
1139                                 tcsetattr(tty_fd, TCSADRAIN, &tty_state);
1140                                 /*-
1141                                  * Don't use tty mode if job is stopped and
1142                                  * later restarted and exits. Consider
1143                                  * the sequence:
1144                                  *      vi foo (stopped)
1145                                  *      ...
1146                                  *      stty something
1147                                  *      ...
1148                                  *      fg (vi; ZZ)
1149                                  * mode should be that of the stty, not what
1150                                  * was before the vi started.
1151                                  */
1152                                 if (j->state == PSTOPPED)
1153                                         j->flags &= ~JF_USETTYMODE;
1154                         }
1155                 }
1156 #ifndef MKSH_UNEMPLOYED
1157                 /*
1158                  * If it looks like user hit ^C to kill a job, pretend we got
1159                  * one too to break out of for loops, etc. (AT&T ksh does this
1160                  * even when not monitoring, but this doesn't make sense since
1161                  * a tty generated ^C goes to the whole process group)
1162                  */
1163                 {
1164                         int status;
1165
1166                         status = j->last_proc->status;
1167                         if (Flag(FMONITOR) && j->state == PSIGNALLED &&
1168                             WIFSIGNALED(status) &&
1169                             (sigtraps[WTERMSIG(status)].flags & TF_TTY_INTR))
1170                                 trapsig(WTERMSIG(status));
1171                 }
1172 #endif
1173         }
1174
1175         j_usrtime = j->usrtime;
1176         j_systime = j->systime;
1177         rv = j->status;
1178
1179         if ((flags & JW_PIPEST) && (j->proc_list != NULL)) {
1180                 uint32_t num = 0;
1181                 Proc *p = j->proc_list;
1182                 struct tbl *vp;
1183
1184                 unset(vp_pipest, 1);
1185                 vp = vp_pipest;
1186                 vp->flag = DEFINED | ISSET | INTEGER | RDONLY | ARRAY | INT_U;
1187                 goto got_array;
1188
1189                 while (p != NULL) {
1190                         {
1191                                 struct tbl *vq;
1192
1193                                 /* strlen(vp_pipest->name) == 10 */
1194                                 vq = alloc(offsetof(struct tbl, name[0]) + 11,
1195                                     vp_pipest->areap);
1196                                 memset(vq, 0, offsetof(struct tbl, name[0]));
1197                                 memcpy(vq->name, vp_pipest->name, 11);
1198                                 vp->u.array = vq;
1199                                 vp = vq;
1200                         }
1201                         vp->areap = vp_pipest->areap;
1202                         vp->ua.index = ++num;
1203                         vp->flag = DEFINED | ISSET | INTEGER | RDONLY |
1204                             ARRAY | INT_U | AINDEX;
1205  got_array:
1206                         vp->val.i = proc_errorlevel(p);
1207                         p = p->next;
1208                 }
1209         }
1210
1211         if (!(flags & JW_ASYNCNOTIFY)
1212 #ifndef MKSH_UNEMPLOYED
1213             && (!Flag(FMONITOR) || j->state != PSTOPPED)
1214 #endif
1215             ) {
1216                 j_print(j, JP_SHORT, shl_out);
1217                 shf_flush(shl_out);
1218         }
1219         if (j->state != PSTOPPED
1220 #ifndef MKSH_UNEMPLOYED
1221             && (!Flag(FMONITOR) || !(flags & JW_ASYNCNOTIFY))
1222 #endif
1223             )
1224                 remove_job(j, where);
1225
1226         return (rv);
1227 }
1228
1229 /*
1230  * SIGCHLD handler to reap children and update job states
1231  *
1232  * If jobs are compiled in then this routine expects sigchld to be blocked.
1233  */
1234 /* ARGSUSED */
1235 static void
1236 j_sigchld(int sig MKSH_A_UNUSED)
1237 {
1238         /* this runs inside interrupt context, with errno saved */
1239
1240         Job *j;
1241         Proc *p = NULL;
1242         pid_t pid;
1243         int status;
1244         struct rusage ru0, ru1;
1245
1246 #ifndef MKSH_NOPROSPECTOFWORK
1247         /*
1248          * Don't wait for any processes if a job is partially started.
1249          * This is so we don't do away with the process group leader
1250          * before all the processes in a pipe line are started (so the
1251          * setpgid() won't fail)
1252          */
1253         for (j = job_list; j; j = j->next)
1254                 if (j->ppid == procpid && !(j->flags & JF_STARTED)) {
1255                         held_sigchld = 1;
1256                         return;
1257                 }
1258 #endif
1259
1260         getrusage(RUSAGE_CHILDREN, &ru0);
1261         do {
1262 #ifndef MKSH_NOPROSPECTOFWORK
1263                 pid = waitpid(-1, &status, (WNOHANG|WUNTRACED));
1264 #else
1265                 pid = wait(&status);
1266 #endif
1267
1268                 /*
1269                  * return if this would block (0) or no children
1270                  * or interrupted (-1)
1271                  */
1272                 if (pid <= 0)
1273                         return;
1274
1275                 getrusage(RUSAGE_CHILDREN, &ru1);
1276
1277                 /* find job and process structures for this pid */
1278                 for (j = job_list; j != NULL; j = j->next)
1279                         for (p = j->proc_list; p != NULL; p = p->next)
1280                                 if (p->pid == pid)
1281                                         goto found;
1282  found:
1283                 if (j == NULL) {
1284                         /* Can occur if process has kids, then execs shell
1285                         warningf(true, "bad process waited for (pid = %d)",
1286                                 pid);
1287                          */
1288                         ru0 = ru1;
1289                         continue;
1290                 }
1291
1292                 timeradd(&j->usrtime, &ru1.ru_utime, &j->usrtime);
1293                 timersub(&j->usrtime, &ru0.ru_utime, &j->usrtime);
1294                 timeradd(&j->systime, &ru1.ru_stime, &j->systime);
1295                 timersub(&j->systime, &ru0.ru_stime, &j->systime);
1296                 ru0 = ru1;
1297                 p->status = status;
1298 #ifndef MKSH_UNEMPLOYED
1299                 if (WIFSTOPPED(status))
1300                         p->state = PSTOPPED;
1301                 else
1302 #endif
1303                   if (WIFSIGNALED(status))
1304                         p->state = PSIGNALLED;
1305                 else
1306                         p->state = PEXITED;
1307
1308                 /* check to see if entire job is done */
1309                 check_job(j);
1310         }
1311 #ifndef MKSH_NOPROSPECTOFWORK
1312             while (/* CONSTCOND */ 1);
1313 #else
1314             while (/* CONSTCOND */ 0);
1315 #endif
1316 }
1317
1318 /*
1319  * Called only when a process in j has exited/stopped (ie, called only
1320  * from j_sigchld()). If no processes are running, the job status
1321  * and state are updated, asynchronous job notification is done and,
1322  * if unneeded, the job is removed.
1323  *
1324  * If jobs are compiled in then this routine expects sigchld to be blocked.
1325  */
1326 static void
1327 check_job(Job *j)
1328 {
1329         int     jstate;
1330         Proc    *p;
1331
1332         /* XXX debugging (nasty - interrupt routine using shl_out) */
1333         if (!(j->flags & JF_STARTED)) {
1334                 internal_warningf("check_job: job started (flags 0x%x)",
1335                     j->flags);
1336                 return;
1337         }
1338
1339         jstate = PRUNNING;
1340         for (p=j->proc_list; p != NULL; p = p->next) {
1341                 if (p->state == PRUNNING)
1342                         /* some processes still running */
1343                         return;
1344                 if (p->state > jstate)
1345                         jstate = p->state;
1346         }
1347         j->state = jstate;
1348         j->status = proc_errorlevel(j->last_proc);
1349
1350         /*
1351          * Note when co-process dies: can't be done in j_wait() nor
1352          * remove_job() since neither may be called for non-interactive
1353          * shells.
1354          */
1355         if (j->state == PEXITED || j->state == PSIGNALLED) {
1356                 /*
1357                  * No need to keep co-process input any more
1358                  * (at least, this is what ksh93d thinks)
1359                  */
1360                 if (coproc.job == j) {
1361                         coproc.job = NULL;
1362                         /*
1363                          * XXX would be nice to get the closes out of here
1364                          * so they aren't done in the signal handler.
1365                          * Would mean a check in coproc_getfd() to
1366                          * do "if job == 0 && write >= 0, close write".
1367                          */
1368                         coproc_write_close(coproc.write);
1369                 }
1370                 /* Do we need to keep the output? */
1371                 if (j->coproc_id && j->coproc_id == coproc.id &&
1372                     --coproc.njobs == 0)
1373                         coproc_readw_close(coproc.read);
1374         }
1375
1376         j->flags |= JF_CHANGED;
1377 #ifndef MKSH_UNEMPLOYED
1378         if (Flag(FMONITOR) && !(j->flags & JF_XXCOM)) {
1379                 /*
1380                  * Only put stopped jobs at the front to avoid confusing
1381                  * the user (don't want finished jobs effecting %+ or %-)
1382                  */
1383                 if (j->state == PSTOPPED)
1384                         put_job(j, PJ_ON_FRONT);
1385                 if (Flag(FNOTIFY) &&
1386                     (j->flags & (JF_WAITING|JF_W_ASYNCNOTIFY)) != JF_WAITING) {
1387                         /* Look for the real file descriptor 2 */
1388                         {
1389                                 struct env *ep;
1390                                 int fd = 2;
1391
1392                                 for (ep = e; ep; ep = ep->oenv)
1393                                         if (ep->savefd && ep->savefd[2])
1394                                                 fd = ep->savefd[2];
1395                                 shf_reopen(fd, SHF_WR, shl_j);
1396                         }
1397                         /*
1398                          * Can't call j_notify() as it removes jobs. The job
1399                          * must stay in the job list as j_waitj() may be
1400                          * running with this job.
1401                          */
1402                         j_print(j, JP_MEDIUM, shl_j);
1403                         shf_flush(shl_j);
1404                         if (!(j->flags & JF_WAITING) && j->state != PSTOPPED)
1405                                 remove_job(j, "notify");
1406                 }
1407         }
1408 #endif
1409         if (
1410 #ifndef MKSH_UNEMPLOYED
1411             !Flag(FMONITOR) &&
1412 #endif
1413             !(j->flags & (JF_WAITING|JF_FG)) &&
1414             j->state != PSTOPPED) {
1415                 if (j == async_job || (j->flags & JF_KNOWN)) {
1416                         j->flags |= JF_ZOMBIE;
1417                         j->job = -1;
1418                         nzombie++;
1419                 } else
1420                         remove_job(j, "checkjob");
1421         }
1422 }
1423
1424 /*
1425  * Print job status in either short, medium or long format.
1426  *
1427  * If jobs are compiled in then this routine expects sigchld to be blocked.
1428  */
1429 static void
1430 j_print(Job *j, int how, struct shf *shf)
1431 {
1432         Proc    *p;
1433         int     state;
1434         int     status;
1435         int     coredumped;
1436         char    jobchar = ' ';
1437         char    buf[64];
1438         const char *filler;
1439         int     output = 0;
1440
1441         if (how == JP_PGRP) {
1442                 /*
1443                  * POSIX doesn't say what to do it there is no process
1444                  * group leader (ie, !FMONITOR). We arbitrarily return
1445                  * last pid (which is what $! returns).
1446                  */
1447                 shf_fprintf(shf, "%d\n", (int)(j->pgrp ? j->pgrp :
1448                     (j->last_proc ? j->last_proc->pid : 0)));
1449                 return;
1450         }
1451         j->flags &= ~JF_CHANGED;
1452         filler = j->job > 10 ? "\n       " : "\n      ";
1453         if (j == job_list)
1454                 jobchar = '+';
1455         else if (j == job_list->next)
1456                 jobchar = '-';
1457
1458         for (p = j->proc_list; p != NULL;) {
1459                 coredumped = 0;
1460                 switch (p->state) {
1461                 case PRUNNING:
1462                         memcpy(buf, "Running", 8);
1463                         break;
1464                 case PSTOPPED:
1465                         strlcpy(buf, sigtraps[WSTOPSIG(p->status)].mess,
1466                             sizeof(buf));
1467                         break;
1468                 case PEXITED:
1469                         if (how == JP_SHORT)
1470                                 buf[0] = '\0';
1471                         else if (WEXITSTATUS(p->status) == 0)
1472                                 memcpy(buf, "Done", 5);
1473                         else
1474                                 shf_snprintf(buf, sizeof(buf), "Done (%d)",
1475                                     WEXITSTATUS(p->status));
1476                         break;
1477                 case PSIGNALLED:
1478 #ifdef WCOREDUMP
1479                         if (WCOREDUMP(p->status))
1480                                 coredumped = 1;
1481 #endif
1482                         /*
1483                          * kludge for not reporting 'normal termination
1484                          * signals' (i.e. SIGINT, SIGPIPE)
1485                          */
1486                         if (how == JP_SHORT && !coredumped &&
1487                             (WTERMSIG(p->status) == SIGINT ||
1488                             WTERMSIG(p->status) == SIGPIPE)) {
1489                                 buf[0] = '\0';
1490                         } else
1491                                 strlcpy(buf, sigtraps[WTERMSIG(p->status)].mess,
1492                                     sizeof(buf));
1493                         break;
1494                 }
1495
1496                 if (how != JP_SHORT) {
1497                         if (p == j->proc_list)
1498                                 shf_fprintf(shf, "[%d] %c ", j->job, jobchar);
1499                         else
1500                                 shf_puts(filler, shf);
1501                 }
1502
1503                 if (how == JP_LONG)
1504                         shf_fprintf(shf, "%5d ", (int)p->pid);
1505
1506                 if (how == JP_SHORT) {
1507                         if (buf[0]) {
1508                                 output = 1;
1509                                 shf_fprintf(shf, "%s%s ",
1510                                     buf, coredumped ? " (core dumped)" : null);
1511                         }
1512                 } else {
1513                         output = 1;
1514                         shf_fprintf(shf, "%-20s %s%s%s", buf, p->command,
1515                             p->next ? "|" : null,
1516                             coredumped ? " (core dumped)" : null);
1517                 }
1518
1519                 state = p->state;
1520                 status = p->status;
1521                 p = p->next;
1522                 while (p && p->state == state && p->status == status) {
1523                         if (how == JP_LONG)
1524                                 shf_fprintf(shf, "%s%5d %-20s %s%s", filler,
1525                                     (int)p->pid, " ", p->command,
1526                                     p->next ? "|" : null);
1527                         else if (how == JP_MEDIUM)
1528                                 shf_fprintf(shf, " %s%s", p->command,
1529                                     p->next ? "|" : null);
1530                         p = p->next;
1531                 }
1532         }
1533         if (output)
1534                 shf_putc('\n', shf);
1535 }
1536
1537 /*
1538  * Convert % sequence to job
1539  *
1540  * If jobs are compiled in then this routine expects sigchld to be blocked.
1541  */
1542 static Job *
1543 j_lookup(const char *cp, int *ecodep)
1544 {
1545         Job *j, *last_match;
1546         Proc *p;
1547         size_t len;
1548         int job = 0;
1549
1550         if (ksh_isdigit(*cp)) {
1551                 getn(cp, &job);
1552                 /* Look for last_proc->pid (what $! returns) first... */
1553                 for (j = job_list; j != NULL; j = j->next)
1554                         if (j->last_proc && j->last_proc->pid == job)
1555                                 return (j);
1556                 /*
1557                  * ...then look for process group (this is non-POSIX,
1558                  * but should not break anything
1559                  */
1560                 for (j = job_list; j != NULL; j = j->next)
1561                         if (j->pgrp && j->pgrp == job)
1562                                 return (j);
1563                 if (ecodep)
1564                         *ecodep = JL_NOSUCH;
1565                 return (NULL);
1566         }
1567         if (*cp != '%') {
1568                 if (ecodep)
1569                         *ecodep = JL_INVALID;
1570                 return (NULL);
1571         }
1572         switch (*++cp) {
1573         case '\0': /* non-standard */
1574         case '+':
1575         case '%':
1576                 if (job_list != NULL)
1577                         return (job_list);
1578                 break;
1579
1580         case '-':
1581                 if (job_list != NULL && job_list->next)
1582                         return (job_list->next);
1583                 break;
1584
1585         case '0': case '1': case '2': case '3': case '4':
1586         case '5': case '6': case '7': case '8': case '9':
1587                 getn(cp, &job);
1588                 for (j = job_list; j != NULL; j = j->next)
1589                         if (j->job == job)
1590                                 return (j);
1591                 break;
1592
1593         /* %?string */
1594         case '?':
1595                 last_match = NULL;
1596                 for (j = job_list; j != NULL; j = j->next)
1597                         for (p = j->proc_list; p != NULL; p = p->next)
1598                                 if (strstr(p->command, cp+1) != NULL) {
1599                                         if (last_match) {
1600                                                 if (ecodep)
1601                                                         *ecodep = JL_AMBIG;
1602                                                 return (NULL);
1603                                         }
1604                                         last_match = j;
1605                                 }
1606                 if (last_match)
1607                         return (last_match);
1608                 break;
1609
1610         /* %string */
1611         default:
1612                 len = strlen(cp);
1613                 last_match = NULL;
1614                 for (j = job_list; j != NULL; j = j->next)
1615                         if (strncmp(cp, j->proc_list->command, len) == 0) {
1616                                 if (last_match) {
1617                                         if (ecodep)
1618                                                 *ecodep = JL_AMBIG;
1619                                         return (NULL);
1620                                 }
1621                                 last_match = j;
1622                         }
1623                 if (last_match)
1624                         return (last_match);
1625                 break;
1626         }
1627         if (ecodep)
1628                 *ecodep = JL_NOSUCH;
1629         return (NULL);
1630 }
1631
1632 static Job      *free_jobs;
1633 static Proc     *free_procs;
1634
1635 /*
1636  * allocate a new job and fill in the job number.
1637  *
1638  * If jobs are compiled in then this routine expects sigchld to be blocked.
1639  */
1640 static Job *
1641 new_job(void)
1642 {
1643         int     i;
1644         Job     *newj, *j;
1645
1646         if (free_jobs != NULL) {
1647                 newj = free_jobs;
1648                 free_jobs = free_jobs->next;
1649         } else
1650                 newj = alloc(sizeof(Job), APERM);
1651
1652         /* brute force method */
1653         for (i = 1; ; i++) {
1654                 for (j = job_list; j && j->job != i; j = j->next)
1655                         ;
1656                 if (j == NULL)
1657                         break;
1658         }
1659         newj->job = i;
1660
1661         return (newj);
1662 }
1663
1664 /*
1665  * Allocate new process struct
1666  *
1667  * If jobs are compiled in then this routine expects sigchld to be blocked.
1668  */
1669 static Proc *
1670 new_proc(void)
1671 {
1672         Proc    *p;
1673
1674         if (free_procs != NULL) {
1675                 p = free_procs;
1676                 free_procs = free_procs->next;
1677         } else
1678                 p = alloc(sizeof(Proc), APERM);
1679
1680         return (p);
1681 }
1682
1683 /*
1684  * Take job out of job_list and put old structures into free list.
1685  * Keeps nzombies, last_job and async_job up to date.
1686  *
1687  * If jobs are compiled in then this routine expects sigchld to be blocked.
1688  */
1689 static void
1690 remove_job(Job *j, const char *where)
1691 {
1692         Proc    *p, *tmp;
1693         Job     **prev, *curr;
1694
1695         prev = &job_list;
1696         curr = *prev;
1697         for (; curr != NULL && curr != j; prev = &curr->next, curr = *prev)
1698                 ;
1699         if (curr != j) {
1700                 internal_warningf("remove_job: job %s (%s)", "not found", where);
1701                 return;
1702         }
1703         *prev = curr->next;
1704
1705         /* free up proc structures */
1706         for (p = j->proc_list; p != NULL; ) {
1707                 tmp = p;
1708                 p = p->next;
1709                 tmp->next = free_procs;
1710                 free_procs = tmp;
1711         }
1712
1713         if ((j->flags & JF_ZOMBIE) && j->ppid == procpid)
1714                 --nzombie;
1715         j->next = free_jobs;
1716         free_jobs = j;
1717
1718         if (j == last_job)
1719                 last_job = NULL;
1720         if (j == async_job)
1721                 async_job = NULL;
1722 }
1723
1724 /*
1725  * put j in a particular location (taking it out job_list if it is there
1726  * already)
1727  *
1728  * If jobs are compiled in then this routine expects sigchld to be blocked.
1729  */
1730 static void
1731 put_job(Job *j, int where)
1732 {
1733         Job     **prev, *curr;
1734
1735         /* Remove job from list (if there) */
1736         prev = &job_list;
1737         curr = job_list;
1738         for (; curr && curr != j; prev = &curr->next, curr = *prev)
1739                 ;
1740         if (curr == j)
1741                 *prev = curr->next;
1742
1743         switch (where) {
1744         case PJ_ON_FRONT:
1745                 j->next = job_list;
1746                 job_list = j;
1747                 break;
1748
1749         case PJ_PAST_STOPPED:
1750                 prev = &job_list;
1751                 curr = job_list;
1752                 for (; curr && curr->state == PSTOPPED; prev = &curr->next,
1753                     curr = *prev)
1754                         ;
1755                 j->next = curr;
1756                 *prev = j;
1757                 break;
1758         }
1759 }
1760
1761 /*
1762  * nuke a job (called when unable to start full job).
1763  *
1764  * If jobs are compiled in then this routine expects sigchld to be blocked.
1765  */
1766 static int
1767 kill_job(Job *j, int sig)
1768 {
1769         Proc    *p;
1770         int     rval = 0;
1771
1772         for (p = j->proc_list; p != NULL; p = p->next)
1773                 if (p->pid != 0)
1774                         if (kill(p->pid, sig) < 0)
1775                                 rval = -1;
1776         return (rval);
1777 }