src/jobs.c

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