usr/src/cmd/sh/jobs.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  28 /*        All Rights Reserved   */
  29
  30 /*
  31  * Job control for UNIX Shell
  32  */
  33
  34 #include        <sys/termio.h>
  35 #include        <sys/types.h>
  36 #include        <sys/wait.h>
  37 #include        <sys/param.h>
  38 #include        <fcntl.h>
  39 #include        <errno.h>
  40 #include        <signal.h>
  41 #include        "defs.h"
  42
  43 /*
  44  * one of these for each active job
  45  */
  46
  47 struct job
  48 {
  49         struct job *j_nxtp;     /* next job in job ID order */
  50         struct job *j_curp;     /* next job in job currency order */
  51         struct termios j_stty;  /* termio save area when job stops */
  52         pid_t   j_pid;          /* job leader's process ID */
  53         pid_t   j_pgid;         /* job's process group ID */
  54         pid_t   j_tgid;         /* job's foreground process group ID */
  55         uint_t  j_jid;          /* job ID */
  56         ushort_t j_xval;        /* exit code, or exit or stop signal */
  57         ushort_t j_flag;        /* various status flags defined below */
  58         char    *j_pwd;         /* job's working directory */
  59         char    *j_cmd;         /* cmd used to invoke this job */
  60 };
  61
  62 /* defines for j_flag */
  63
  64 #define J_DUMPED        0001    /* job has core dumped */
  65 #define J_NOTIFY        0002    /* job has changed status */
  66 #define J_SAVETTY       0004    /* job was stopped in foreground, and its */
  67                                 /*   termio settings were saved */
  68 #define J_STOPPED       0010    /* job has been stopped */
  69 #define J_SIGNALED      0020    /* job has received signal; j_xval has it */
  70 #define J_DONE          0040    /* job has finished */
  71 #define J_RUNNING       0100    /* job is currently running */
  72 #define J_FOREGND       0200    /* job was put in foreground by shell */
  73
  74 /* options to the printjob() function defined below */
  75
  76 #define PR_CUR          00001   /* print job currency ('+', '-', or ' ') */
  77 #define PR_JID          00002   /* print job ID                          */
  78 #define PR_PGID         00004   /* print job's process group ID          */
  79 #define PR_STAT         00010   /* print status obtained from wait       */
  80 #define PR_CMD          00020   /* print cmd that invoked job            */
  81 #define PR_AMP          00040   /* print a '&' if in the background      */
  82 #define PR_PWD          00100   /* print jobs present working directory  */
  83
  84 #define PR_DFL          (PR_CUR|PR_JID|PR_STAT|PR_CMD) /* default options */
  85 #define PR_LONG         (PR_DFL|PR_PGID|PR_PWD) /* long options */
  86
  87 static struct termios   mystty;  /* default termio settings              */
  88 static int              eofflg,
  89                         jobcnt,  /* number of active jobs                */
  90                         jobdone, /* number of active but finished jobs   */
  91                         jobnote; /* jobs requiring notification          */
  92 static pid_t            svpgid,  /* saved process group ID               */
  93                         svtgid;  /* saved foreground process group ID    */
  94 static struct job       *jobcur, /* active jobs listed in currency order */
  95                         **nextjob,
  96                         *thisjob,
  97                         *joblst; /* active jobs listed in job ID order   */
  98
  99 static void printjob(struct job *, int);
 100
 101 static struct job *
 102 pgid2job(pid_t pgid)
 103 {
 104         struct job *jp;
 105
 106         for (jp = joblst; jp != 0 && jp->j_pid != pgid; jp = jp->j_nxtp)
 107                 continue;
 108
 109         return (jp);
 110 }
 111
 112 static struct job *
 113 str2job(char *cmd, char *job, int mustbejob)
 114 {
 115         struct job *jp, *njp;
 116         int i;
 117
 118         if (*job != '%')
 119                 jp = pgid2job(stoi(job));
 120         else if (*++job == 0 || *job == '+' || *job == '%' || *job == '-') {
 121                 jp = jobcur;
 122                 if (*job == '-' && jp)
 123                         jp = jp->j_curp;
 124         } else if (*job >= '0' && *job <= '9') {
 125                 i = stoi(job);
 126                 for (jp = joblst; jp && jp->j_jid != i; jp = jp->j_nxtp)
 127                         continue;
 128         } else if (*job == '?') {
 129                 int j;
 130                 char *p;
 131                 i = strlen(++job);
 132                 jp = 0;
 133                 for (njp = jobcur; njp; njp = njp->j_curp) {
 134                         if (njp->j_jid == 0)
 135                                 continue;
 136                         for (p = njp->j_cmd, j = strlen(p); j >= i; p++, j--) {
 137                                 if (strncmp(job, p, i) == 0) {
 138                                         if (jp != 0)
 139                                                 failed((unsigned char *)cmd,
 140                                                     ambiguous);
 141                                         jp = njp;
 142                                         break;
 143                                 }
 144                         }
 145                 }
 146         } else {
 147                 i = strlen(job);
 148                 jp = 0;
 149                 for (njp = jobcur; njp; njp = njp->j_curp) {
 150                         if (njp->j_jid == 0)
 151                                 continue;
 152                         if (strncmp(job, njp->j_cmd, i) == 0) {
 153                                 if (jp != 0)
 154                                         failed((unsigned char *)cmd, ambiguous);
 155                                 jp = njp;
 156                         }
 157                 }
 158         }
 159
 160         if (mustbejob && (jp == 0 || jp->j_jid == 0))
 161                 failed((unsigned char *)cmd, nosuchjob);
 162
 163         return (jp);
 164 }
 165
 166 static void
 167 freejob(struct job *jp)
 168 {
 169         struct job **njp;
 170         struct job **cjp;
 171
 172         for (njp = &joblst; *njp != jp; njp = &(*njp)->j_nxtp)
 173                 continue;
 174
 175         for (cjp = &jobcur; *cjp != jp; cjp = &(*cjp)->j_curp)
 176                 continue;
 177
 178         *njp = jp->j_nxtp;
 179         *cjp = jp->j_curp;
 180         free(jp);
 181         jobcnt--;
 182         jobdone--;
 183 }
 184
 185 /*
 186  * Collect the foreground job.
 187  * Used in the case where the subshell wants
 188  * to exit, but needs to wait until the fg job
 189  * is done.
 190  */
 191 void
 192 collect_fg_job(void)
 193 {
 194         struct job *jp;
 195         pid_t pid;
 196         int stat;
 197
 198         for (jp = joblst; jp; jp = jp->j_nxtp)
 199                 if (jp->j_flag & J_FOREGND)
 200                         break;
 201
 202         if (!jp)
 203                 /* no foreground job */
 204                 return;
 205
 206         /*
 207          * Wait on fg job until wait succeeds
 208          * or it fails due to no waitable children.
 209          */
 210
 211         while (1) {
 212                 errno = 0;
 213                 pid = waitpid(jp->j_pid, &stat, 0);
 214                 if (pid == jp->j_pid || (pid == -1 && errno == ECHILD))
 215                         break;
 216         }
 217 }
 218
 219 /*
 220  * analyze the status of a job
 221  */
 222
 223 static int
 224 statjob(struct job *jp, int stat, int fg, int rc)
 225 {
 226         pid_t tgid;
 227         int done = 0;
 228
 229         if (WIFCONTINUED(stat)) {
 230                 if (jp->j_flag & J_STOPPED) {
 231                         jp->j_flag &= ~(J_STOPPED|J_SIGNALED|J_SAVETTY);
 232                         jp->j_flag |= J_RUNNING;
 233                         if (!fg && jp->j_jid) {
 234                                 jp->j_flag |= J_NOTIFY;
 235                                 jobnote++;
 236                         }
 237                 }
 238         } else if (WIFSTOPPED(stat)) {
 239                 jp->j_xval = WSTOPSIG(stat);
 240                 jp->j_flag &= ~J_RUNNING;
 241                 jp->j_flag |= (J_SIGNALED|J_STOPPED);
 242                 jp->j_pgid = getpgid(jp->j_pid);
 243                 jp->j_tgid = jp->j_pgid;
 244                 if (fg) {
 245                         if (tgid = settgid(mypgid, jp->j_pgid))
 246                                 jp->j_tgid = tgid;
 247                         else {
 248                                 jp->j_flag |= J_SAVETTY;
 249                                 tcgetattr(0, &jp->j_stty);
 250                                 (void) tcsetattr(0, TCSANOW, &mystty);
 251                         }
 252                 }
 253                 if (jp->j_jid) {
 254                         jp->j_flag |= J_NOTIFY;
 255                         jobnote++;
 256                 }
 257         } else {
 258                 jp->j_flag &= ~J_RUNNING;
 259                 jp->j_flag |= J_DONE;
 260                 done++;
 261                 jobdone++;
 262                 if (WIFSIGNALED(stat)) {
 263                         jp->j_xval = WTERMSIG(stat);
 264                         jp->j_flag |= J_SIGNALED;
 265                         if (WCOREDUMP(stat))
 266                                 jp->j_flag |= J_DUMPED;
 267                         if (!fg || jp->j_xval != SIGINT) {
 268                                 jp->j_flag |= J_NOTIFY;
 269                                 jobnote++;
 270                         }
 271                 } else { /* WIFEXITED */
 272                         jp->j_xval = WEXITSTATUS(stat);
 273                         jp->j_flag &= ~J_SIGNALED;
 274                         if (!fg && jp->j_jid) {
 275                                 jp->j_flag |= J_NOTIFY;
 276                                 jobnote++;
 277                         }
 278                 }
 279                 if (fg) {
 280                         if (!settgid(mypgid, jp->j_pgid) ||
 281                             !settgid(mypgid, getpgid(jp->j_pid)))
 282                                 tcgetattr(0, &mystty);
 283                 }
 284         }
 285         if (rc) {
 286                 exitval = jp->j_xval;
 287                 if (jp->j_flag & J_SIGNALED)
 288                         exitval |= SIGFLG;
 289                 exitset();
 290         }
 291         if (done && !(jp->j_flag & J_NOTIFY))
 292                 freejob(jp);
 293         return (done);
 294 }
 295
 296 /*
 297  * collect the status of jobs that have recently exited or stopped -
 298  * if wnohang == WNOHANG, wait until error, or all jobs are accounted for;
 299  *
 300  * called after each command is executed, with wnohang == 0, and as part
 301  * of "wait" builtin with wnohang == WNOHANG
 302  *
 303  * We do not need to call chktrap here if waitpid(2) is called with
 304  * wnohang == 0, because that only happens from syswait() which is called
 305  * from builtin() where chktrap() is already called.
 306  */
 307
 308 static void
 309 collectjobs(wnohang)
 310 {
 311         pid_t pid;
 312         struct job *jp;
 313         int stat, n;
 314         int wflags;
 315
 316         if ((flags & (monitorflg|jcflg|jcoff)) == (monitorflg|jcflg))
 317                 wflags = WUNTRACED|WCONTINUED;
 318         else
 319                 wflags = 0;
 320
 321         for (n = jobcnt - jobdone; n > 0; n--) {
 322                 if ((pid = waitpid(-1, &stat, wnohang|wflags)) <= 0)
 323                         break;
 324                 if (jp = pgid2job(pid))
 325                         (void) statjob(jp, stat, 0, 0);
 326         }
 327
 328 }
 329
 330 void
 331 freejobs()
 332 {
 333         struct job *jp;
 334
 335         collectjobs(WNOHANG);
 336
 337         if (jobnote) {
 338                 int savefd = setb(2);
 339                 for (jp = joblst; jp; jp = jp->j_nxtp) {
 340                         if (jp->j_flag & J_NOTIFY) {
 341                                 if (jp->j_jid)
 342                                         printjob(jp, PR_DFL);
 343                                 else if (jp->j_flag & J_FOREGND)
 344                                         printjob(jp, PR_STAT);
 345                                 else
 346                                         printjob(jp, PR_STAT|PR_PGID);
 347                         }
 348                 }
 349                 (void) setb(savefd);
 350         }
 351
 352         if (jobdone) {
 353                 for (jp = joblst; jp; jp = jp->j_nxtp) {
 354                         if (jp->j_flag & J_DONE)
 355                                 freejob(jp);
 356                 }
 357         }
 358 }
 359
 360 static void
 361 waitjob(struct job *jp)
 362 {
 363         int stat;
 364         int done;
 365         pid_t pid = jp->j_pid;
 366         int wflags;
 367         int ret = 0;
 368         int     err = 0;
 369
 370         if ((flags & (monitorflg|jcflg|jcoff)) == (monitorflg|jcflg))
 371                 wflags = WUNTRACED;
 372         else
 373                 wflags = 0;
 374         do {
 375                 errno = 0;
 376                 ret = waitpid(pid, &stat, wflags|WNOWAIT);
 377                 err = errno;
 378                 if (ret == -1 && err == ECHILD) {
 379                         stat = 0;
 380                         break;
 381                 }
 382         } while (ret != pid);
 383
 384         done = statjob(jp, stat, 1, 1);
 385         waitpid(pid, 0, wflags);
 386         if (done && exitval && (flags & errflg))
 387                 exitsh(exitval);
 388         flags |= eflag;
 389 }
 390
 391 /*
 392  * modify the foreground process group to *new* only if the
 393  * current foreground process group is equal to *expected*
 394  */
 395
 396 int
 397 settgid(new, expected)
 398 pid_t new, expected;
 399 {
 400         pid_t current = tcgetpgrp(0);
 401
 402         if (current != expected)
 403                 return (current);
 404
 405         if (new != current)
 406                 tcsetpgrp(0, new);
 407
 408         return (0);
 409 }
 410
 411 static void
 412 restartjob(struct job *jp, int fg)
 413 {
 414         if (jp != jobcur) {
 415                 struct job *t;
 416
 417                 for (t = jobcur; t->j_curp != jp; t = t->j_curp)
 418                         ;
 419                 t->j_curp = jp->j_curp;
 420                 jp->j_curp = jobcur;
 421                 jobcur = jp;
 422         }
 423         if (fg) {
 424                 if (jp->j_flag & J_SAVETTY) {
 425                         jp->j_stty.c_lflag &= ~TOSTOP;
 426                         jp->j_stty.c_lflag |= (mystty.c_lflag&TOSTOP);
 427                         jp->j_stty.c_cc[VSUSP] = mystty.c_cc[VSUSP];
 428                         jp->j_stty.c_cc[VDSUSP] = mystty.c_cc[VDSUSP];
 429                         (void) tcsetattr(0, TCSADRAIN, &jp->j_stty);
 430                 }
 431                 (void) settgid(jp->j_tgid, mypgid);
 432         }
 433         (void) kill(-(jp->j_pgid), SIGCONT);
 434         if (jp->j_tgid != jp->j_pgid)
 435                 (void) kill(-(jp->j_tgid), SIGCONT);
 436         jp->j_flag &= ~(J_STOPPED|J_SIGNALED|J_SAVETTY);
 437         jp->j_flag |= J_RUNNING;
 438         if (fg)  {
 439                 jp->j_flag |= J_FOREGND;
 440                 printjob(jp, PR_JID|PR_CMD);
 441                 waitjob(jp);
 442         } else {
 443                 jp->j_flag &= ~J_FOREGND;
 444                 printjob(jp, PR_JID|PR_CMD|PR_AMP);
 445         }
 446 }
 447
 448 static void
 449 printjob(struct job *jp, int propts)
 450 {
 451         int sp = 0;
 452
 453         if (jp->j_flag & J_NOTIFY) {
 454                 jobnote--;
 455                 jp->j_flag &= ~J_NOTIFY;
 456         }
 457
 458         if (propts & PR_JID) {
 459                 prc_buff('[');
 460                 prn_buff(jp->j_jid);
 461                 prc_buff(']');
 462                 sp = 1;
 463         }
 464
 465         if (propts & PR_CUR) {
 466                 while (sp-- > 0)
 467                         prc_buff(SPACE);
 468                 sp = 1;
 469                 if (jobcur == jp)
 470                         prc_buff('+');
 471                 else if (jobcur != 0 && jobcur->j_curp == jp)
 472                         prc_buff('-');
 473                 else
 474                         sp++;
 475         }
 476
 477         if (propts & PR_PGID) {
 478                 while (sp-- > 0)
 479                         prc_buff(SPACE);
 480                 prn_buff(jp->j_pid);
 481                 sp = 1;
 482         }
 483
 484         if (propts & PR_STAT) {
 485                 char    *gmsg;
 486                 while (sp-- > 0)
 487                         prc_buff(SPACE);
 488                 sp = 28;
 489                 if (jp->j_flag & J_SIGNALED) {
 490                         char *sigstr, *strsignal();
 491                         if ((sigstr = strsignal(jp->j_xval)) != NULL) {
 492                                 sp -= strlen(sigstr);
 493                                 prs_buff(sigstr);
 494                         } else {
 495                                 itos(jp->j_xval);
 496                                 gmsg = gettext(signalnum);
 497                                 sp -= strlen(numbuf) + strlen(gmsg);
 498                                 prs_buff((unsigned char *)gmsg);
 499                                 prs_buff(numbuf);
 500                         }
 501                         if (jp->j_flag & J_DUMPED) {
 502                                 gmsg = gettext(coredump);
 503                                 sp -= strlen(gmsg);
 504                                 prs_buff((unsigned char *)gmsg);
 505                         }
 506                 } else if (jp->j_flag & J_DONE) {
 507                         itos(jp->j_xval);
 508                         gmsg = gettext(exited);
 509                         sp -= strlen(gmsg) + strlen(numbuf) + 2;
 510                         prs_buff((unsigned char *)gmsg);
 511                         prc_buff('(');
 512                         itos(jp->j_xval);
 513                         prs_buff(numbuf);
 514                         prc_buff(')');
 515                 } else {
 516                         gmsg = gettext(running);
 517                         sp -= strlen(gmsg);
 518                         prs_buff((unsigned char *)gmsg);
 519                 }
 520                 if (sp < 1)
 521                         sp = 1;
 522         }
 523
 524         if (propts & PR_CMD) {
 525                 while (sp-- > 0)
 526                         prc_buff(SPACE);
 527                 prs_buff(jp->j_cmd);
 528                 sp = 1;
 529         }
 530
 531         if (propts & PR_AMP) {
 532                 while (sp-- > 0)
 533                         prc_buff(SPACE);
 534                 prc_buff('&');
 535                 sp = 1;
 536         }
 537
 538         if (propts & PR_PWD) {
 539                 while (sp-- > 0)
 540                         prc_buff(SPACE);
 541                 prs_buff("(wd: ");
 542                 prs_buff(jp->j_pwd);
 543                 prc_buff(')');
 544         }
 545
 546         prc_buff(NL);
 547         flushb();
 548
 549 }
 550
 551
 552 /*
 553  * called to initialize job control for each new input file to the shell,
 554  * and after the "exec" builtin
 555  */
 556
 557 void
 558 startjobs()
 559 {
 560         svpgid = mypgid;
 561
 562         if (tcgetattr(0, &mystty) == -1 || (svtgid = tcgetpgrp(0)) == -1) {
 563                 flags &= ~jcflg;
 564                 return;
 565         }
 566
 567         flags |= jcflg;
 568
 569         handle(SIGTTOU, SIG_IGN);
 570         handle(SIGTSTP, SIG_DFL);
 571
 572         if (mysid != mypgid) {
 573                 setpgid(0, 0);
 574                 mypgid = mypid;
 575                 (void) settgid(mypgid, svpgid);
 576         }
 577
 578 }
 579
 580 int
 581 endjobs(check_if)
 582 int check_if;
 583 {
 584         if ((flags & (jcoff|jcflg)) != jcflg)
 585                 return (1);
 586
 587         if (check_if && jobcnt && eofflg++ == 0) {
 588                 struct job *jp;
 589                 if (check_if & JOB_STOPPED) {
 590                         for (jp = joblst; jp; jp = jp->j_nxtp) {
 591                                 if (jp->j_jid && (jp->j_flag & J_STOPPED)) {
 592                                         prs(_gettext(jobsstopped));
 593                                         prc(NL);
 594                                         return (0);
 595                                 }
 596                         }
 597                 }
 598                 if (check_if & JOB_RUNNING) {
 599                         for (jp = joblst; jp; jp = jp->j_nxtp) {
 600                                 if (jp->j_jid && (jp->j_flag & J_RUNNING)) {
 601                                         prs(_gettext(jobsrunning));
 602                                         prc(NL);
 603                                         return (0);
 604                                 }
 605                         }
 606                 }
 607         }
 608
 609         if (svpgid != mypgid) {
 610                 (void) settgid(svtgid, mypgid);
 611                 setpgid(0, svpgid);
 612         }
 613
 614         return (1);
 615 }
 616
 617
 618 /*
 619  * called by the shell to reserve a job slot for a job about to be spawned
 620  */
 621
 622 void
 623 deallocjob()
 624 {
 625         free(thisjob);
 626         jobcnt--;
 627 }
 628
 629 void
 630 allocjob(char *cmd, uchar_t *cwd, int monitor)
 631 {
 632         struct job *jp, **jpp;
 633         int jid, cmdlen, cwdlen;
 634
 635         cmdlen = strlen(cmd) + 1;
 636         if (cmd[cmdlen-2] == '&') {
 637                 cmd[cmdlen-3] = 0;
 638                 cmdlen -= 2;
 639         }
 640         cwdlen = strlen(cwd) + 1;
 641         jp = (struct job *) alloc(sizeof (struct job) + cmdlen + cwdlen);
 642         if (jp == 0)
 643                 error(nostack);
 644         jobcnt++;
 645         jp->j_cmd = ((char *)jp) + sizeof (struct job);
 646         strcpy(jp->j_cmd, cmd);
 647         jp->j_pwd = jp->j_cmd + cmdlen;
 648         strcpy(jp->j_pwd, cwd);
 649
 650         jpp = &joblst;
 651
 652         if (monitor) {
 653                 for (; *jpp; jpp = &(*jpp)->j_nxtp)
 654                         if ((*jpp)->j_jid != 0)
 655                                 break;
 656                 for (jid = 1; *jpp; jpp = &(*jpp)->j_nxtp, jid++)
 657                         if ((*jpp)->j_jid != jid)
 658                                 break;
 659         } else
 660                 jid = 0;
 661
 662         jp->j_jid = jid;
 663         nextjob = jpp;
 664         thisjob = jp;
 665 }
 666
 667 void
 668 clearjobs(void)
 669 {
 670         struct job *jp, *sjp;
 671
 672         for (jp = joblst; jp; jp = sjp) {
 673                 sjp = jp->j_nxtp;
 674                 free(jp);
 675         }
 676         joblst = NULL;
 677         jobcnt = 0;
 678         jobnote = 0;
 679         jobdone = 0;
 680
 681 }
 682
 683 void
 684 makejob(int monitor, int fg)
 685 {
 686         if (monitor) {
 687                 mypgid = mypid;
 688                 setpgid(0, 0);
 689                 if (fg)
 690                         tcsetpgrp(0, mypid);
 691                 handle(SIGTTOU, SIG_DFL);
 692                 handle(SIGTSTP, SIG_DFL);
 693         } else if (!fg) {
 694 #ifdef NICE
 695                 nice(NICE);
 696 #endif
 697                 handle(SIGTTIN, SIG_IGN);
 698                 handle(SIGINT,  SIG_IGN);
 699                 handle(SIGQUIT, SIG_IGN);
 700                 if (!ioset)
 701                         renamef(chkopen(devnull, 0), 0);
 702         }
 703 }
 704
 705 /*
 706  * called by the shell after job has been spawned, to fill in the
 707  * job slot, and wait for the job if in the foreground
 708  */
 709
 710 void
 711 postjob(pid, fg)
 712 pid_t pid;
 713 int fg;
 714 {
 715
 716         int propts;
 717
 718         thisjob->j_nxtp = *nextjob;
 719         *nextjob = thisjob;
 720         thisjob->j_curp = jobcur;
 721         jobcur = thisjob;
 722
 723         if (thisjob->j_jid) {
 724                 thisjob->j_pgid = pid;
 725                 propts = PR_JID|PR_PGID;
 726         } else {
 727                 thisjob->j_pgid = mypgid;
 728                 propts = PR_PGID;
 729         }
 730
 731         thisjob->j_flag = J_RUNNING;
 732         thisjob->j_tgid = thisjob->j_pgid;
 733         thisjob->j_pid = pid;
 734         eofflg = 0;
 735
 736         if (fg) {
 737                 thisjob->j_flag |= J_FOREGND;
 738                 waitjob(thisjob);
 739         } else  {
 740                 if (flags & ttyflg)
 741                         printjob(thisjob, propts);
 742                 assnum(&pcsadr, (long)pid);
 743         }
 744 }
 745
 746 /*
 747  * the builtin "jobs" command
 748  */
 749
 750 void
 751 sysjobs(argc, argv)
 752 int argc;
 753 char *argv[];
 754 {
 755         char *cmd = *argv;
 756         struct job *jp;
 757         int propts, c;
 758         extern int opterr, i;
 759         int savoptind = optind;
 760         int loptind = -1;
 761         int savopterr = opterr;
 762         int savsp = _sp;
 763         char *savoptarg = optarg;
 764         optind = 1;
 765         opterr = 0;
 766         _sp = 1;
 767         propts = 0;
 768
 769         if ((flags & jcflg) == 0)
 770                 failed((unsigned char *)cmd, nojc);
 771
 772         while ((c = getopt(argc, argv, "lpx")) != -1) {
 773                 if (propts) {
 774                         gfailure(usage, jobsuse);
 775                         goto err;
 776                 }
 777                 switch (c) {
 778                         case 'x':
 779                                 propts = -1;
 780                                 break;
 781                         case 'p':
 782                                 propts = PR_PGID;
 783                                 break;
 784                         case 'l':
 785                                 propts = PR_LONG;
 786                                 break;
 787                         case '?':
 788                                 gfailure(usage, jobsuse);
 789                                 goto err;
 790                 }
 791         }
 792
 793         loptind = optind;
 794 err:
 795         optind = savoptind;
 796         optarg = savoptarg;
 797         opterr = savopterr;
 798         _sp = savsp;
 799         if (loptind == -1)
 800                 return;
 801
 802         if (propts == -1) {
 803                 unsigned char *bp;
 804                 char *cp;
 805                 unsigned char *savebp;
 806                 for (savebp = bp = locstak(); loptind < argc; loptind++) {
 807                         cp = argv[loptind];
 808                         if (*cp == '%') {
 809                                 jp = str2job(cmd, cp, 1);
 810                                 itos(jp->j_pid);
 811                                 cp = (char *)numbuf;
 812                         }
 813                         while (*cp) {
 814                                 if (bp >= brkend)
 815                                         growstak(bp);
 816                                 *bp++ = *cp++;
 817                         }
 818                         if (bp >= brkend)
 819                                 growstak(bp);
 820                         *bp++ = SPACE;
 821                 }
 822                 endstak(bp);
 823                 execexp(savebp, 0);
 824                 return;
 825         }
 826
 827         collectjobs(WNOHANG);
 828
 829         if (propts == 0)
 830                 propts = PR_DFL;
 831
 832         if (loptind == argc) {
 833                 for (jp = joblst; jp; jp = jp->j_nxtp) {
 834                         if (jp->j_jid)
 835                                 printjob(jp, propts);
 836                 }
 837         } else do
 838                 printjob(str2job(cmd, argv[loptind++], 1), propts);
 839         while (loptind < argc);
 840
 841 }
 842
 843 /*
 844  * the builtin "fg" and "bg" commands
 845  */
 846 void
 847 sysfgbg(int argc, char *argv[])
 848 {
 849         char *cmd = *argv;
 850         int fg;
 851
 852         if ((flags & jcflg) == 0)
 853                 failed((unsigned char *)cmd, nojc);
 854
 855         fg = eq("fg", cmd);
 856
 857         if (*++argv == 0) {
 858                 struct job *jp;
 859                 for (jp = jobcur; ; jp = jp->j_curp) {
 860                         if (jp == 0)
 861                                 failed((unsigned char *)cmd, nocurjob);
 862                         if (jp->j_jid)
 863                                 break;
 864                 }
 865                 restartjob(jp, fg);
 866         } else {
 867                 do {
 868                         restartjob(str2job(cmd, *argv, 1), fg);
 869                 } while (*++argv);
 870         }
 871 }
 872
 873 /*
 874  * the builtin "wait" commands
 875  */
 876
 877 void
 878 syswait(argc, argv)
 879 int argc;
 880 char *argv[];
 881 {
 882         char *cmd = *argv;
 883         struct job *jp;
 884         int stat;
 885         int wflags;
 886
 887         if ((flags & (monitorflg|jcflg|jcoff)) == (monitorflg|jcflg))
 888                 wflags = WUNTRACED;
 889         else
 890                 wflags = 0;
 891
 892         if (argc == 1)
 893                 collectjobs(0);
 894         else while (--argc) {
 895                 if ((jp = str2job(cmd, *++argv, 0)) == 0)
 896                         continue;
 897                 if (!(jp->j_flag & J_RUNNING))
 898                         continue;
 899                 if (waitpid(jp->j_pid, &stat, wflags) <= 0)
 900                         break;
 901                 (void) statjob(jp, stat, 0, 1);
 902         }
 903 }
 904
 905 static void
 906 sigv(char *cmd, int sig, char *args)
 907 {
 908         int pgrp = 0;
 909         int stopme = 0;
 910         pid_t id;
 911
 912         if (*args == '%') {
 913                 struct job *jp;
 914                 jp = str2job(cmd, args, 1);
 915                 id = jp->j_pgid;
 916                 pgrp++;
 917         } else {
 918                 if (*args == '-') {
 919                         pgrp++;
 920                         args++;
 921                 }
 922                 id = 0;
 923                 do {
 924                         if (*args < '0' || *args > '9') {
 925                                 failure(cmd, badid);
 926                                 return;
 927                         }
 928                         id = (id * 10) + (*args - '0');
 929                 } while (*++args);
 930                 if (id == 0) {
 931                         id = mypgid;
 932                         pgrp++;
 933                 }
 934         }
 935
 936         if (sig == SIGSTOP) {
 937                 if (id == mysid || id == mypid && mypgid == mysid) {
 938                         failure(cmd, loginsh);
 939                         return;
 940                 }
 941                 if (id == mypgid && mypgid != svpgid) {
 942                         (void) settgid(svtgid, mypgid);
 943                         setpgid(0, svpgid);
 944                         stopme++;
 945                 }
 946         }
 947
 948         if (pgrp)
 949                 id = -id;
 950
 951         if (kill(id, sig) < 0) {
 952
 953                 switch (errno) {
 954                         case EPERM:
 955                                 failure(cmd, eacces);
 956                                 break;
 957
 958                         case EINVAL:
 959                                 failure(cmd, badsig);
 960                                 break;
 961
 962                         default:
 963                                 if (pgrp)
 964                                         failure(cmd, nosuchpgid);
 965                                 else
 966                                         failure(cmd, nosuchpid);
 967                                 break;
 968                 }
 969
 970         } else if (sig == SIGTERM && pgrp)
 971                 (void) kill(id, SIGCONT);
 972
 973         if (stopme) {
 974                 setpgid(0, mypgid);
 975                 (void) settgid(mypgid, svpgid);
 976         }
 977
 978 }
 979
 980 void
 981 sysstop(int argc, char *argv[])
 982 {
 983         char *cmd = *argv;
 984         if (argc <= 1) {
 985                 gfailure(usage, stopuse);
 986                 return;
 987         }
 988         while (*++argv)
 989                 sigv(cmd, SIGSTOP, *argv);
 990 }
 991
 992 void
 993 syskill(int argc, char *argv[])
 994 {
 995         char *cmd = *argv;
 996         int sig = SIGTERM;
 997
 998         if (argc == 1) {
 999                 gfailure(usage, killuse);
1000                 return;
1001         }
1002
1003         if (argv[1][0] == '-') {
1004
1005                 if (argc == 2) {
1006
1007                         int i;
1008                         int cnt = 0;
1009                         char sep = 0;
1010                         char buf[12];
1011
1012                         if (!eq(argv[1], "-l")) {
1013                                 gfailure(usage, killuse);
1014                                 return;
1015                         }
1016
1017                         for (i = 1; i < MAXTRAP; i++) {
1018                                 if (sig2str(i, buf) < 0)
1019                                         continue;
1020                                 if (sep)
1021                                         prc_buff(sep);
1022                                 prs_buff(buf);
1023                                 if ((flags & ttyflg) && (++cnt % 10))
1024                                         sep = TAB;
1025                                 else
1026                                         sep = NL;
1027                         }
1028                         prc_buff(NL);
1029                         return;
1030                 }
1031
1032                 if (str2sig(&argv[1][1], &sig)) {
1033                         failure(cmd, badsig);
1034                         return;
1035                 }
1036                 argv++;
1037         }
1038
1039         while (*++argv)
1040                 sigv(cmd, sig, *argv);
1041
1042 }
1043
1044 void
1045 syssusp(int argc, char *argv[])
1046 {
1047         if (argc != 1)
1048                 failed((unsigned char *)argv[0], badopt);
1049         sigv(argv[0], SIGSTOP, "0");
1050 }
1051
1052 void
1053 hupforegnd(void)
1054 {
1055         struct job *jp;
1056
1057         (void) sighold(SIGCHLD);
1058         for (jp = joblst; jp != NULL; jp = jp->j_nxtp) {
1059                 if (jp->j_flag & J_FOREGND) {
1060                         (void) kill(jp->j_pid, SIGHUP);
1061                         break;
1062                 }
1063         }
1064         (void) sigrelse(SIGCHLD);
1065 }