bin/sh/jobs.c

   1 /*-
   2  * Copyright (c) 1991, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * This code is derived from software contributed to Berkeley by
   6  * Kenneth Almquist.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *      This product includes software developed by the University of
  19  *      California, Berkeley and its contributors.
  20  * 4. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  *
  36  * @(#)jobs.c   8.5 (Berkeley) 5/4/95
  37  * $FreeBSD: head/bin/sh/jobs.c 248349 2013-03-15 20:29:31Z jilles $
  38  */
  39
  40 #include <sys/ioctl.h>
  41 #include <sys/param.h>
  42 #include <sys/resource.h>
  43 #include <sys/time.h>
  44 #include <sys/wait.h>
  45 #include <errno.h>
  46 #include <fcntl.h>
  47 #include <paths.h>
  48 #include <signal.h>
  49 #include <stddef.h>
  50 #include <stdlib.h>
  51 #include <unistd.h>
  52
  53 #include "shell.h"
  54 #if JOBS
  55 #include <termios.h>
  56 #undef CEOF                     /* syntax.h redefines this */
  57 #endif
  58 #include "redir.h"
  59 #include "exec.h"
  60 #include "show.h"
  61 #include "main.h"
  62 #include "parser.h"
  63 #include "nodes.h"
  64 #include "jobs.h"
  65 #include "options.h"
  66 #include "trap.h"
  67 #include "syntax.h"
  68 #include "input.h"
  69 #include "output.h"
  70 #include "memalloc.h"
  71 #include "error.h"
  72 #include "mystring.h"
  73 #include "var.h"
  74 #include "builtins.h"
  75
  76
  77 static struct job *jobtab;      /* array of jobs */
  78 static int njobs;               /* size of array */
  79 MKINIT pid_t backgndpid = -1;   /* pid of last background process */
  80 MKINIT struct job *bgjob = NULL; /* last background process */
  81 #if JOBS
  82 static struct job *jobmru;      /* most recently used job list */
  83 static pid_t initialpgrp;       /* pgrp of shell on invocation */
  84 #endif
  85 int in_waitcmd = 0;             /* are we in waitcmd()? */
  86 volatile sig_atomic_t breakwaitcmd = 0; /* should wait be terminated? */
  87 static int ttyfd = -1;
  88
  89 /* mode flags for dowait */
  90 #define DOWAIT_BLOCK    0x1 /* wait until a child exits */
  91 #define DOWAIT_SIG      0x2 /* if DOWAIT_BLOCK, abort on signals */
  92
  93 #if JOBS
  94 static void restartjob(struct job *);
  95 #endif
  96 static void freejob(struct job *);
  97 static struct job *getjob(char *);
  98 static pid_t dowait(int, struct job *);
  99 static void checkzombies(void);
 100 static void cmdtxt(union node *);
 101 static void cmdputs(const char *);
 102 #if JOBS
 103 static void setcurjob(struct job *);
 104 static void deljob(struct job *);
 105 static struct job *getcurjob(struct job *);
 106 #endif
 107 static void printjobcmd(struct job *);
 108 static void showjob(struct job *, int);
 109
 110
 111 /*
 112  * Turn job control on and off.
 113  */
 114
 115 MKINIT int jobctl;
 116
 117 #if JOBS
 118 void
 119 setjobctl(int on)
 120 {
 121         int i;
 122
 123         if (on == jobctl || rootshell == 0)
 124                 return;
 125         if (on) {
 126                 if (ttyfd != -1)
 127                         close(ttyfd);
 128                 if ((ttyfd = open(_PATH_TTY, O_RDWR)) < 0) {
 129                         i = 0;
 130                         while (i <= 2 && !isatty(i))
 131                                 i++;
 132                         if (i > 2 || (ttyfd = fcntl(i, F_DUPFD, 10)) < 0)
 133                                 goto out;
 134                 }
 135                 if (ttyfd < 10) {
 136                         /*
 137                          * Keep our TTY file descriptor out of the way of
 138                          * the user's redirections.
 139                          */
 140                         if ((i = fcntl(ttyfd, F_DUPFD, 10)) < 0) {
 141                                 close(ttyfd);
 142                                 ttyfd = -1;
 143                                 goto out;
 144                         }
 145                         close(ttyfd);
 146                         ttyfd = i;
 147                 }
 148                 if (fcntl(ttyfd, F_SETFD, FD_CLOEXEC) < 0) {
 149                         close(ttyfd);
 150                         ttyfd = -1;
 151                         goto out;
 152                 }
 153                 do { /* while we are in the background */
 154                         initialpgrp = tcgetpgrp(ttyfd);
 155                         if (initialpgrp < 0) {
 156 out:                            out2fmt_flush("sh: can't access tty; job control turned off\n");
 157                                 mflag = 0;
 158                                 return;
 159                         }
 160                         if (initialpgrp != getpgrp()) {
 161                                 kill(0, SIGTTIN);
 162                                 continue;
 163                         }
 164                 } while (0);
 165                 setsignal(SIGTSTP);
 166                 setsignal(SIGTTOU);
 167                 setsignal(SIGTTIN);
 168                 setpgid(0, rootpid);
 169                 tcsetpgrp(ttyfd, rootpid);
 170         } else { /* turning job control off */
 171                 setpgid(0, initialpgrp);
 172                 tcsetpgrp(ttyfd, initialpgrp);
 173                 close(ttyfd);
 174                 ttyfd = -1;
 175                 setsignal(SIGTSTP);
 176                 setsignal(SIGTTOU);
 177                 setsignal(SIGTTIN);
 178         }
 179         jobctl = on;
 180 }
 181 #endif
 182
 183
 184 #if JOBS
 185 int
 186 fgcmd(int argc __unused, char **argv)
 187 {
 188         struct job *jp;
 189         pid_t pgrp;
 190         int status;
 191
 192         jp = getjob(argv[1]);
 193         if (jp->jobctl == 0)
 194                 error("job not created under job control");
 195         printjobcmd(jp);
 196         flushout(&output);
 197         pgrp = jp->ps[0].pid;
 198         tcsetpgrp(ttyfd, pgrp);
 199         restartjob(jp);
 200         jp->foreground = 1;
 201         INTOFF;
 202         status = waitforjob(jp, NULL);
 203         INTON;
 204         return status;
 205 }
 206
 207
 208 int
 209 bgcmd(int argc, char **argv)
 210 {
 211         struct job *jp;
 212
 213         do {
 214                 jp = getjob(*++argv);
 215                 if (jp->jobctl == 0)
 216                         error("job not created under job control");
 217                 if (jp->state == JOBDONE)
 218                         continue;
 219                 restartjob(jp);
 220                 jp->foreground = 0;
 221                 out1fmt("[%td] ", jp - jobtab + 1);
 222                 printjobcmd(jp);
 223         } while (--argc > 1);
 224         return 0;
 225 }
 226
 227
 228 static void
 229 restartjob(struct job *jp)
 230 {
 231         struct procstat *ps;
 232         int i;
 233
 234         if (jp->state == JOBDONE)
 235                 return;
 236         setcurjob(jp);
 237         INTOFF;
 238         kill(-jp->ps[0].pid, SIGCONT);
 239         for (ps = jp->ps, i = jp->nprocs ; --i >= 0 ; ps++) {
 240                 if (WIFSTOPPED(ps->status)) {
 241                         ps->status = -1;
 242                         jp->state = 0;
 243                 }
 244         }
 245         INTON;
 246 }
 247 #endif
 248
 249
 250 int
 251 jobscmd(int argc __unused, char *argv[] __unused)
 252 {
 253         char *id;
 254         int ch, mode;
 255
 256         mode = SHOWJOBS_DEFAULT;
 257         while ((ch = nextopt("lps")) != '\0') {
 258                 switch (ch) {
 259                 case 'l':
 260                         mode = SHOWJOBS_VERBOSE;
 261                         break;
 262                 case 'p':
 263                         mode = SHOWJOBS_PGIDS;
 264                         break;
 265                 case 's':
 266                         mode = SHOWJOBS_PIDS;
 267                         break;
 268                 }
 269         }
 270
 271         if (*argptr == NULL)
 272                 showjobs(0, mode);
 273         else
 274                 while ((id = *argptr++) != NULL)
 275                         showjob(getjob(id), mode);
 276
 277         return (0);
 278 }
 279
 280 static void
 281 printjobcmd(struct job *jp)
 282 {
 283         struct procstat *ps;
 284         int i;
 285
 286         for (ps = jp->ps, i = jp->nprocs ; --i >= 0 ; ps++) {
 287                 out1str(ps->cmd);
 288                 if (i > 0)
 289                         out1str(" | ");
 290         }
 291         out1c('\n');
 292 }
 293
 294 static void
 295 showjob(struct job *jp, int mode)
 296 {
 297         char s[64];
 298         char statestr[64];
 299         const char *sigstr;
 300         struct procstat *ps;
 301         struct job *j;
 302         int col, curr, i, jobno, prev, procno;
 303         char c;
 304
 305         procno = (mode == SHOWJOBS_PGIDS) ? 1 : jp->nprocs;
 306         jobno = jp - jobtab + 1;
 307         curr = prev = 0;
 308 #if JOBS
 309         if ((j = getcurjob(NULL)) != NULL) {
 310                 curr = j - jobtab + 1;
 311                 if ((j = getcurjob(j)) != NULL)
 312                         prev = j - jobtab + 1;
 313         }
 314 #endif
 315         ps = jp->ps + jp->nprocs - 1;
 316         if (jp->state == 0) {
 317                 strcpy(statestr, "Running");
 318 #if JOBS
 319         } else if (jp->state == JOBSTOPPED) {
 320                 while (!WIFSTOPPED(ps->status) && ps > jp->ps)
 321                         ps--;
 322                 if (WIFSTOPPED(ps->status))
 323                         i = WSTOPSIG(ps->status);
 324                 else
 325                         i = -1;
 326                 sigstr = strsignal(i);
 327                 if (sigstr != NULL)
 328                         strcpy(statestr, sigstr);
 329                 else
 330                         strcpy(statestr, "Suspended");
 331 #endif
 332         } else if (WIFEXITED(ps->status)) {
 333                 if (WEXITSTATUS(ps->status) == 0)
 334                         strcpy(statestr, "Done");
 335                 else
 336                         fmtstr(statestr, 64, "Done(%d)",
 337                             WEXITSTATUS(ps->status));
 338         } else {
 339                 i = WTERMSIG(ps->status);
 340                 sigstr = strsignal(i);
 341                 if (sigstr != NULL)
 342                         strcpy(statestr, sigstr);
 343                 else
 344                         strcpy(statestr, "Unknown signal");
 345                 if (WCOREDUMP(ps->status))
 346                         strcat(statestr, " (core dumped)");
 347         }
 348
 349         for (ps = jp->ps ; ; ps++) {    /* for each process */
 350                 if (mode == SHOWJOBS_PIDS || mode == SHOWJOBS_PGIDS) {
 351                         out1fmt("%d\n", (int)ps->pid);
 352                         goto skip;
 353                 }
 354                 if (mode != SHOWJOBS_VERBOSE && ps != jp->ps)
 355                         goto skip;
 356                 if (jobno == curr && ps == jp->ps)
 357                         c = '+';
 358                 else if (jobno == prev && ps == jp->ps)
 359                         c = '-';
 360                 else
 361                         c = ' ';
 362                 if (ps == jp->ps)
 363                         fmtstr(s, 64, "[%d] %c ", jobno, c);
 364                 else
 365                         fmtstr(s, 64, "    %c ", c);
 366                 out1str(s);
 367                 col = strlen(s);
 368                 if (mode == SHOWJOBS_VERBOSE) {
 369                         fmtstr(s, 64, "%d ", (int)ps->pid);
 370                         out1str(s);
 371                         col += strlen(s);
 372                 }
 373                 if (ps == jp->ps) {
 374                         out1str(statestr);
 375                         col += strlen(statestr);
 376                 }
 377                 do {
 378                         out1c(' ');
 379                         col++;
 380                 } while (col < 30);
 381                 if (mode == SHOWJOBS_VERBOSE) {
 382                         out1str(ps->cmd);
 383                         out1c('\n');
 384                 } else
 385                         printjobcmd(jp);
 386 skip:           if (--procno <= 0)
 387                         break;
 388         }
 389 }
 390
 391 /*
 392  * Print a list of jobs.  If "change" is nonzero, only print jobs whose
 393  * statuses have changed since the last call to showjobs.
 394  *
 395  * If the shell is interrupted in the process of creating a job, the
 396  * result may be a job structure containing zero processes.  Such structures
 397  * will be freed here.
 398  */
 399
 400 void
 401 showjobs(int change, int mode)
 402 {
 403         int jobno;
 404         struct job *jp;
 405
 406         TRACE(("showjobs(%d) called\n", change));
 407         checkzombies();
 408         for (jobno = 1, jp = jobtab ; jobno <= njobs ; jobno++, jp++) {
 409                 if (! jp->used)
 410                         continue;
 411                 if (jp->nprocs == 0) {
 412                         freejob(jp);
 413                         continue;
 414                 }
 415                 if (change && ! jp->changed)
 416                         continue;
 417                 showjob(jp, mode);
 418                 jp->changed = 0;
 419                 /* Hack: discard jobs for which $! has not been referenced
 420                  * in interactive mode when they terminate.
 421                  */
 422                 if (jp->state == JOBDONE && !jp->remembered &&
 423                                 (iflag || jp != bgjob)) {
 424                         freejob(jp);
 425                 }
 426         }
 427 }
 428
 429
 430 /*
 431  * Mark a job structure as unused.
 432  */
 433
 434 static void
 435 freejob(struct job *jp)
 436 {
 437         struct procstat *ps;
 438         int i;
 439
 440         INTOFF;
 441         if (bgjob == jp)
 442                 bgjob = NULL;
 443         for (i = jp->nprocs, ps = jp->ps ; --i >= 0 ; ps++) {
 444                 if (ps->cmd != nullstr)
 445                         ckfree(ps->cmd);
 446         }
 447         if (jp->ps != &jp->ps0)
 448                 ckfree(jp->ps);
 449         jp->used = 0;
 450 #if JOBS
 451         deljob(jp);
 452 #endif
 453         INTON;
 454 }
 455
 456
 457
 458 int
 459 waitcmd(int argc, char **argv)
 460 {
 461         struct job *job;
 462         int status, retval;
 463         struct job *jp;
 464
 465         if (argc > 1) {
 466                 job = getjob(argv[1]);
 467         } else {
 468                 job = NULL;
 469         }
 470
 471         /*
 472          * Loop until a process is terminated or stopped, or a SIGINT is
 473          * received.
 474          */
 475
 476         in_waitcmd++;
 477         do {
 478                 if (job != NULL) {
 479                         if (job->state) {
 480                                 status = job->ps[job->nprocs - 1].status;
 481                                 if (WIFEXITED(status))
 482                                         retval = WEXITSTATUS(status);
 483 #if JOBS
 484                                 else if (WIFSTOPPED(status))
 485                                         retval = WSTOPSIG(status) + 128;
 486 #endif
 487                                 else
 488                                         retval = WTERMSIG(status) + 128;
 489                                 if (! iflag || ! job->changed)
 490                                         freejob(job);
 491                                 else {
 492                                         job->remembered = 0;
 493                                         if (job == bgjob)
 494                                                 bgjob = NULL;
 495                                 }
 496                                 in_waitcmd--;
 497                                 return retval;
 498                         }
 499                 } else {
 500                         for (jp = jobtab ; jp < jobtab + njobs; jp++)
 501                                 if (jp->used && jp->state == JOBDONE) {
 502                                         if (! iflag || ! jp->changed)
 503                                                 freejob(jp);
 504                                         else {
 505                                                 jp->remembered = 0;
 506                                                 if (jp == bgjob)
 507                                                         bgjob = NULL;
 508                                         }
 509                                 }
 510                         for (jp = jobtab ; ; jp++) {
 511                                 if (jp >= jobtab + njobs) {     /* no running procs */
 512                                         in_waitcmd--;
 513                                         return 0;
 514                                 }
 515                                 if (jp->used && jp->state == 0)
 516                                         break;
 517                         }
 518                 }
 519         } while (dowait(DOWAIT_BLOCK | DOWAIT_SIG, NULL) != -1);
 520         in_waitcmd--;
 521
 522         return pendingsig + 128;
 523 }
 524
 525
 526
 527 int
 528 jobidcmd(int argc __unused, char **argv)
 529 {
 530         struct job *jp;
 531         int i;
 532
 533         jp = getjob(argv[1]);
 534         for (i = 0 ; i < jp->nprocs ; ) {
 535                 out1fmt("%d", (int)jp->ps[i].pid);
 536                 out1c(++i < jp->nprocs? ' ' : '\n');
 537         }
 538         return 0;
 539 }
 540
 541
 542
 543 /*
 544  * Convert a job name to a job structure.
 545  */
 546
 547 static struct job *
 548 getjob(char *name)
 549 {
 550         int jobno;
 551         struct job *found, *jp;
 552         pid_t pid;
 553         int i;
 554
 555         if (name == NULL) {
 556 #if JOBS
 557 currentjob:     if ((jp = getcurjob(NULL)) == NULL)
 558                         error("No current job");
 559                 return (jp);
 560 #else
 561                 error("No current job");
 562 #endif
 563         } else if (name[0] == '%') {
 564                 if (is_digit(name[1])) {
 565                         jobno = number(name + 1);
 566                         if (jobno > 0 && jobno <= njobs
 567                          && jobtab[jobno - 1].used != 0)
 568                                 return &jobtab[jobno - 1];
 569 #if JOBS
 570                 } else if (name[1] == '%' && name[2] == '\0') {
 571                         goto currentjob;
 572                 } else if (name[1] == '+' && name[2] == '\0') {
 573                         goto currentjob;
 574                 } else if (name[1] == '-' && name[2] == '\0') {
 575                         if ((jp = getcurjob(NULL)) == NULL ||
 576                             (jp = getcurjob(jp)) == NULL)
 577                                 error("No previous job");
 578                         return (jp);
 579 #endif
 580                 } else if (name[1] == '?') {
 581                         found = NULL;
 582                         for (jp = jobtab, i = njobs ; --i >= 0 ; jp++) {
 583                                 if (jp->used && jp->nprocs > 0
 584                                  && strstr(jp->ps[0].cmd, name + 2) != NULL) {
 585                                         if (found)
 586                                                 error("%s: ambiguous", name);
 587                                         found = jp;
 588                                 }
 589                         }
 590                         if (found != NULL)
 591                                 return (found);
 592                 } else {
 593                         found = NULL;
 594                         for (jp = jobtab, i = njobs ; --i >= 0 ; jp++) {
 595                                 if (jp->used && jp->nprocs > 0
 596                                  && prefix(name + 1, jp->ps[0].cmd)) {
 597                                         if (found)
 598                                                 error("%s: ambiguous", name);
 599                                         found = jp;
 600                                 }
 601                         }
 602                         if (found)
 603                                 return found;
 604                 }
 605         } else if (is_number(name)) {
 606                 pid = (pid_t)number(name);
 607                 for (jp = jobtab, i = njobs ; --i >= 0 ; jp++) {
 608                         if (jp->used && jp->nprocs > 0
 609                          && jp->ps[jp->nprocs - 1].pid == pid)
 610                                 return jp;
 611                 }
 612         }
 613         error("No such job: %s", name);
 614         /*NOTREACHED*/
 615         return NULL;
 616 }
 617
 618
 619 pid_t
 620 getjobpgrp(char *name)
 621 {
 622         struct job *jp;
 623
 624         jp = getjob(name);
 625         return -jp->ps[0].pid;
 626 }
 627
 628 /*
 629  * Return a new job structure,
 630  */
 631
 632 struct job *
 633 makejob(union node *node __unused, int nprocs)
 634 {
 635         int i;
 636         struct job *jp;
 637
 638         for (i = njobs, jp = jobtab ; ; jp++) {
 639                 if (--i < 0) {
 640                         INTOFF;
 641                         if (njobs == 0) {
 642                                 jobtab = ckmalloc(4 * sizeof jobtab[0]);
 643 #if JOBS
 644                                 jobmru = NULL;
 645 #endif
 646                         } else {
 647                                 jp = ckmalloc((njobs + 4) * sizeof jobtab[0]);
 648                                 memcpy(jp, jobtab, njobs * sizeof jp[0]);
 649 #if JOBS
 650                                 /* Relocate `next' pointers and list head */
 651                                 if (jobmru != NULL)
 652                                         jobmru = &jp[jobmru - jobtab];
 653                                 for (i = 0; i < njobs; i++)
 654                                         if (jp[i].next != NULL)
 655                                                 jp[i].next = &jp[jp[i].next -
 656                                                     jobtab];
 657 #endif
 658                                 if (bgjob != NULL)
 659                                         bgjob = &jp[bgjob - jobtab];
 660                                 /* Relocate `ps' pointers */
 661                                 for (i = 0; i < njobs; i++)
 662                                         if (jp[i].ps == &jobtab[i].ps0)
 663                                                 jp[i].ps = &jp[i].ps0;
 664                                 ckfree(jobtab);
 665                                 jobtab = jp;
 666                         }
 667                         jp = jobtab + njobs;
 668                         for (i = 4 ; --i >= 0 ; jobtab[njobs++].used = 0);
 669                         INTON;
 670                         break;
 671                 }
 672                 if (jp->used == 0)
 673                         break;
 674         }
 675         INTOFF;
 676         jp->state = 0;
 677         jp->used = 1;
 678         jp->changed = 0;
 679         jp->nprocs = 0;
 680         jp->foreground = 0;
 681         jp->remembered = 0;
 682 #if JOBS
 683         jp->jobctl = jobctl;
 684         jp->next = NULL;
 685 #endif
 686         if (nprocs > 1) {
 687                 jp->ps = ckmalloc(nprocs * sizeof (struct procstat));
 688         } else {
 689                 jp->ps = &jp->ps0;
 690         }
 691         INTON;
 692         TRACE(("makejob(%p, %d) returns %%%td\n", (void *)node, nprocs,
 693             jp - jobtab + 1));
 694         return jp;
 695 }
 696
 697 #if JOBS
 698 static void
 699 setcurjob(struct job *cj)
 700 {
 701         struct job *jp, *prev;
 702
 703         for (prev = NULL, jp = jobmru; jp != NULL; prev = jp, jp = jp->next) {
 704                 if (jp == cj) {
 705                         if (prev != NULL)
 706                                 prev->next = jp->next;
 707                         else
 708                                 jobmru = jp->next;
 709                         jp->next = jobmru;
 710                         jobmru = cj;
 711                         return;
 712                 }
 713         }
 714         cj->next = jobmru;
 715         jobmru = cj;
 716 }
 717
 718 static void
 719 deljob(struct job *j)
 720 {
 721         struct job *jp, *prev;
 722
 723         for (prev = NULL, jp = jobmru; jp != NULL; prev = jp, jp = jp->next) {
 724                 if (jp == j) {
 725                         if (prev != NULL)
 726                                 prev->next = jp->next;
 727                         else
 728                                 jobmru = jp->next;
 729                         return;
 730                 }
 731         }
 732 }
 733
 734 /*
 735  * Return the most recently used job that isn't `nj', and preferably one
 736  * that is stopped.
 737  */
 738 static struct job *
 739 getcurjob(struct job *nj)
 740 {
 741         struct job *jp;
 742
 743         /* Try to find a stopped one.. */
 744         for (jp = jobmru; jp != NULL; jp = jp->next)
 745                 if (jp->used && jp != nj && jp->state == JOBSTOPPED)
 746                         return (jp);
 747         /* Otherwise the most recently used job that isn't `nj' */
 748         for (jp = jobmru; jp != NULL; jp = jp->next)
 749                 if (jp->used && jp != nj)
 750                         return (jp);
 751
 752         return (NULL);
 753 }
 754
 755 #endif
 756
 757 /*
 758  * Fork of a subshell.  If we are doing job control, give the subshell its
 759  * own process group.  Jp is a job structure that the job is to be added to.
 760  * N is the command that will be evaluated by the child.  Both jp and n may
 761  * be NULL.  The mode parameter can be one of the following:
 762  *      FORK_FG - Fork off a foreground process.
 763  *      FORK_BG - Fork off a background process.
 764  *      FORK_NOJOB - Like FORK_FG, but don't give the process its own
 765  *                   process group even if job control is on.
 766  *
 767  * When job control is turned off, background processes have their standard
 768  * input redirected to /dev/null (except for the second and later processes
 769  * in a pipeline).
 770  */
 771
 772 pid_t
 773 forkshell(struct job *jp, union node *n, int mode)
 774 {
 775         pid_t pid;
 776         pid_t pgrp;
 777
 778         TRACE(("forkshell(%%%td, %p, %d) called\n", jp - jobtab, (void *)n,
 779             mode));
 780         INTOFF;
 781         if (mode == FORK_BG && (jp == NULL || jp->nprocs == 0))
 782                 checkzombies();
 783         flushall();
 784         pid = fork();
 785         if (pid == -1) {
 786                 TRACE(("Fork failed, errno=%d\n", errno));
 787                 INTON;
 788                 error("Cannot fork: %s", strerror(errno));
 789         }
 790         if (pid == 0) {
 791                 struct job *p;
 792                 int wasroot;
 793                 int i;
 794
 795                 TRACE(("Child shell %d\n", (int)getpid()));
 796                 wasroot = rootshell;
 797                 rootshell = 0;
 798                 handler = &main_handler;
 799                 closescript();
 800                 INTON;
 801                 forcelocal = 0;
 802                 clear_traps();
 803 #if JOBS
 804                 jobctl = 0;             /* do job control only in root shell */
 805                 if (wasroot && mode != FORK_NOJOB && mflag) {
 806                         if (jp == NULL || jp->nprocs == 0)
 807                                 pgrp = getpid();
 808                         else
 809                                 pgrp = jp->ps[0].pid;
 810                         if (setpgid(0, pgrp) == 0 && mode == FORK_FG) {
 811                                 /*** this causes superfluous TIOCSPGRPS ***/
 812                                 if (tcsetpgrp(ttyfd, pgrp) < 0)
 813                                         error("tcsetpgrp failed, errno=%d", errno);
 814                         }
 815                         setsignal(SIGTSTP);
 816                         setsignal(SIGTTOU);
 817                 } else if (mode == FORK_BG) {
 818                         ignoresig(SIGINT);
 819                         ignoresig(SIGQUIT);
 820                         if ((jp == NULL || jp->nprocs == 0) &&
 821                             ! fd0_redirected_p ()) {
 822                                 close(0);
 823                                 if (open(_PATH_DEVNULL, O_RDONLY) != 0)
 824                                         error("cannot open %s: %s",
 825                                             _PATH_DEVNULL, strerror(errno));
 826                         }
 827                 }
 828 #else
 829                 if (mode == FORK_BG) {
 830                         ignoresig(SIGINT);
 831                         ignoresig(SIGQUIT);
 832                         if ((jp == NULL || jp->nprocs == 0) &&
 833                             ! fd0_redirected_p ()) {
 834                                 close(0);
 835                                 if (open(_PATH_DEVNULL, O_RDONLY) != 0)
 836                                         error("cannot open %s: %s",
 837                                             _PATH_DEVNULL, strerror(errno));
 838                         }
 839                 }
 840 #endif
 841                 INTOFF;
 842                 for (i = njobs, p = jobtab ; --i >= 0 ; p++)
 843                         if (p->used)
 844                                 freejob(p);
 845                 INTON;
 846                 if (wasroot && iflag) {
 847                         setsignal(SIGINT);
 848                         setsignal(SIGQUIT);
 849                         setsignal(SIGTERM);
 850                 }
 851                 return pid;
 852         }
 853         if (rootshell && mode != FORK_NOJOB && mflag) {
 854                 if (jp == NULL || jp->nprocs == 0)
 855                         pgrp = pid;
 856                 else
 857                         pgrp = jp->ps[0].pid;
 858                 setpgid(pid, pgrp);
 859         }
 860         if (mode == FORK_BG) {
 861                 if (bgjob != NULL && bgjob->state == JOBDONE &&
 862                     !bgjob->remembered && !iflag)
 863                         freejob(bgjob);
 864                 backgndpid = pid;               /* set $! */
 865                 bgjob = jp;
 866         }
 867         if (jp) {
 868                 struct procstat *ps = &jp->ps[jp->nprocs++];
 869                 ps->pid = pid;
 870                 ps->status = -1;
 871                 ps->cmd = nullstr;
 872                 if (iflag && rootshell && n)
 873                         ps->cmd = commandtext(n);
 874                 jp->foreground = mode == FORK_FG;
 875 #if JOBS
 876                 setcurjob(jp);
 877 #endif
 878         }
 879         INTON;
 880         TRACE(("In parent shell:  child = %d\n", (int)pid));
 881         return pid;
 882 }
 883
 884
 885 pid_t
 886 vforkexecshell(struct job *jp, char **argv, char **envp, const char *path, int idx, int pip[2])
 887 {
 888         pid_t pid;
 889         struct jmploc jmploc;
 890         struct jmploc *savehandler;
 891
 892         TRACE(("vforkexecshell(%%%td, %s, %p) called\n", jp - jobtab, argv[0],
 893             (void *)pip));
 894         INTOFF;
 895         flushall();
 896         savehandler = handler;
 897         pid = vfork();
 898         if (pid == -1) {
 899                 TRACE(("Vfork failed, errno=%d\n", errno));
 900                 INTON;
 901                 error("Cannot fork: %s", strerror(errno));
 902         }
 903         if (pid == 0) {
 904                 TRACE(("Child shell %d\n", (int)getpid()));
 905                 if (setjmp(jmploc.loc))
 906                         _exit(exception == EXEXEC ? exerrno : 2);
 907                 if (pip != NULL) {
 908                         close(pip[0]);
 909                         if (pip[1] != 1) {
 910                                 dup2(pip[1], 1);
 911                                 close(pip[1]);
 912                         }
 913                 }
 914                 handler = &jmploc;
 915                 shellexec(argv, envp, path, idx);
 916         }
 917         handler = savehandler;
 918         if (jp) {
 919                 struct procstat *ps = &jp->ps[jp->nprocs++];
 920                 ps->pid = pid;
 921                 ps->status = -1;
 922                 ps->cmd = nullstr;
 923                 jp->foreground = 1;
 924 #if JOBS
 925                 setcurjob(jp);
 926 #endif
 927         }
 928         INTON;
 929         TRACE(("In parent shell:  child = %d\n", (int)pid));
 930         return pid;
 931 }
 932
 933
 934 /*
 935  * Wait for job to finish.
 936  *
 937  * Under job control we have the problem that while a child process is
 938  * running interrupts generated by the user are sent to the child but not
 939  * to the shell.  This means that an infinite loop started by an inter-
 940  * active user may be hard to kill.  With job control turned off, an
 941  * interactive user may place an interactive program inside a loop.  If
 942  * the interactive program catches interrupts, the user doesn't want
 943  * these interrupts to also abort the loop.  The approach we take here
 944  * is to have the shell ignore interrupt signals while waiting for a
 945  * foreground process to terminate, and then send itself an interrupt
 946  * signal if the child process was terminated by an interrupt signal.
 947  * Unfortunately, some programs want to do a bit of cleanup and then
 948  * exit on interrupt; unless these processes terminate themselves by
 949  * sending a signal to themselves (instead of calling exit) they will
 950  * confuse this approach.
 951  */
 952
 953 int
 954 waitforjob(struct job *jp, int *origstatus)
 955 {
 956 #if JOBS
 957         pid_t mypgrp = getpgrp();
 958         int propagate_int = jp->jobctl && jp->foreground;
 959 #endif
 960         int status;
 961         int st;
 962
 963         INTOFF;
 964         TRACE(("waitforjob(%%%td) called\n", jp - jobtab + 1));
 965         while (jp->state == 0)
 966                 if (dowait(DOWAIT_BLOCK | (Tflag ? DOWAIT_SIG : 0), jp) == -1)
 967                         dotrap();
 968 #if JOBS
 969         if (jp->jobctl) {
 970                 if (tcsetpgrp(ttyfd, mypgrp) < 0)
 971                         error("tcsetpgrp failed, errno=%d\n", errno);
 972         }
 973         if (jp->state == JOBSTOPPED)
 974                 setcurjob(jp);
 975 #endif
 976         status = jp->ps[jp->nprocs - 1].status;
 977         if (origstatus != NULL)
 978                 *origstatus = status;
 979         /* convert to 8 bits */
 980         if (WIFEXITED(status))
 981                 st = WEXITSTATUS(status);
 982 #if JOBS
 983         else if (WIFSTOPPED(status))
 984                 st = WSTOPSIG(status) + 128;
 985 #endif
 986         else
 987                 st = WTERMSIG(status) + 128;
 988         if (! JOBS || jp->state == JOBDONE)
 989                 freejob(jp);
 990         if (int_pending()) {
 991                 if (!WIFSIGNALED(status) || WTERMSIG(status) != SIGINT)
 992                         CLEAR_PENDING_INT;
 993         }
 994 #if JOBS
 995         else if (rootshell && iflag && propagate_int &&
 996                         WIFSIGNALED(status) && WTERMSIG(status) == SIGINT)
 997                 kill(getpid(), SIGINT);
 998 #endif
 999         INTON;
1000         return st;
1001 }
1002
1003
1004 static void
1005 dummy_handler(int sig __unused)
1006 {
1007 }
1008
1009 /*
1010  * Wait for a process to terminate.
1011  */
1012
1013 static pid_t
1014 dowait(int mode, struct job *job)
1015 {
1016         struct sigaction sa, osa;
1017         sigset_t mask, omask;
1018         pid_t pid;
1019         int status;
1020         struct procstat *sp;
1021         struct job *jp;
1022         struct job *thisjob;
1023         const char *sigstr;
1024         int done;
1025         int stopped;
1026         int sig;
1027         int coredump;
1028         int wflags;
1029         int restore_sigchld;
1030
1031         TRACE(("dowait(%d, %p) called\n", mode, job));
1032         restore_sigchld = 0;
1033         if ((mode & DOWAIT_SIG) != 0) {
1034                 sigfillset(&mask);
1035                 sigprocmask(SIG_BLOCK, &mask, &omask);
1036                 INTOFF;
1037                 if (!issigchldtrapped()) {
1038                         restore_sigchld = 1;
1039                         sa.sa_handler = dummy_handler;
1040                         sa.sa_flags = 0;
1041                         sigemptyset(&sa.sa_mask);
1042                         sigaction(SIGCHLD, &sa, &osa);
1043                 }
1044         }
1045         do {
1046 #if JOBS
1047                 if (iflag)
1048                         wflags = WUNTRACED | WCONTINUED;
1049                 else
1050 #endif
1051                         wflags = 0;
1052                 if ((mode & (DOWAIT_BLOCK | DOWAIT_SIG)) != DOWAIT_BLOCK)
1053                         wflags |= WNOHANG;
1054                 pid = wait3(&status, wflags, NULL);
1055                 TRACE(("wait returns %d, status=%d\n", (int)pid, status));
1056                 if (pid == 0 && (mode & DOWAIT_SIG) != 0) {
1057                         sigsuspend(&omask);
1058                         pid = -1;
1059                         if (int_pending())
1060                                 break;
1061                 }
1062         } while (pid == -1 && errno == EINTR && breakwaitcmd == 0);
1063         if (pid == -1 && errno == ECHILD && job != NULL)
1064                 job->state = JOBDONE;
1065         if ((mode & DOWAIT_SIG) != 0) {
1066                 if (restore_sigchld)
1067                         sigaction(SIGCHLD, &osa, NULL);
1068                 sigprocmask(SIG_SETMASK, &omask, NULL);
1069                 INTON;
1070         }
1071         if (breakwaitcmd != 0) {
1072                 breakwaitcmd = 0;
1073                 /*
1074                  * Do not early terminate if the pid is positive, else the
1075                  * job will not be properly recorded.
1076                  */
1077                 if (pid <= 0)
1078                         return -1;
1079         }
1080         if (pid <= 0)
1081                 return pid;
1082         INTOFF;
1083         thisjob = NULL;
1084         for (jp = jobtab ; jp < jobtab + njobs ; jp++) {
1085                 if (jp->used && jp->nprocs > 0) {
1086                         done = 1;
1087                         stopped = 1;
1088                         for (sp = jp->ps ; sp < jp->ps + jp->nprocs ; sp++) {
1089                                 if (sp->pid == -1)
1090                                         continue;
1091                                 if (sp->pid == pid) {
1092                                         TRACE(("Changing status of proc %d from 0x%x to 0x%x\n",
1093                                                    (int)pid, sp->status,
1094                                                    status));
1095                                         if (WIFCONTINUED(status)) {
1096                                                 sp->status = -1;
1097                                                 jp->state = 0;
1098                                         } else
1099                                                 sp->status = status;
1100                                         thisjob = jp;
1101                                 }
1102                                 if (sp->status == -1)
1103                                         stopped = 0;
1104                                 else if (WIFSTOPPED(sp->status))
1105                                         done = 0;
1106                         }
1107                         if (stopped) {          /* stopped or done */
1108                                 int state = done? JOBDONE : JOBSTOPPED;
1109                                 if (jp->state != state) {
1110                                         TRACE(("Job %td: changing state from %d to %d\n", jp - jobtab + 1, jp->state, state));
1111                                         jp->state = state;
1112                                         if (jp != job) {
1113                                                 if (done && !jp->remembered &&
1114                                                     !iflag && jp != bgjob)
1115                                                         freejob(jp);
1116 #if JOBS
1117                                                 else if (done)
1118                                                         deljob(jp);
1119 #endif
1120                                         }
1121                                 }
1122                         }
1123                 }
1124         }
1125         INTON;
1126         if (!thisjob || thisjob->state == 0)
1127                 ;
1128         else if ((!rootshell || !iflag || thisjob == job) &&
1129             thisjob->foreground && thisjob->state != JOBSTOPPED) {
1130                 sig = 0;
1131                 coredump = 0;
1132                 for (sp = thisjob->ps; sp < thisjob->ps + thisjob->nprocs; sp++)
1133                         if (WIFSIGNALED(sp->status)) {
1134                                 sig = WTERMSIG(sp->status);
1135                                 coredump = WCOREDUMP(sp->status);
1136                         }
1137                 if (sig > 0 && sig != SIGINT && sig != SIGPIPE) {
1138                         sigstr = strsignal(sig);
1139                         if (sigstr != NULL)
1140                                 out2str(sigstr);
1141                         else
1142                                 out2str("Unknown signal");
1143                         if (coredump)
1144                                 out2str(" (core dumped)");
1145                         out2c('\n');
1146                         flushout(out2);
1147                 }
1148         } else {
1149                 TRACE(("Not printing status, rootshell=%d, job=%p\n", rootshell, job));
1150                 thisjob->changed = 1;
1151         }
1152         return pid;
1153 }
1154
1155
1156
1157 /*
1158  * return 1 if there are stopped jobs, otherwise 0
1159  */
1160 int job_warning = 0;
1161 int
1162 stoppedjobs(void)
1163 {
1164         int jobno;
1165         struct job *jp;
1166
1167         if (job_warning)
1168                 return (0);
1169         for (jobno = 1, jp = jobtab; jobno <= njobs; jobno++, jp++) {
1170                 if (jp->used == 0)
1171                         continue;
1172                 if (jp->state == JOBSTOPPED) {
1173                         out2fmt_flush("You have stopped jobs.\n");
1174                         job_warning = 2;
1175                         return (1);
1176                 }
1177         }
1178
1179         return (0);
1180 }
1181
1182
1183 static void
1184 checkzombies(void)
1185 {
1186         while (njobs > 0 && dowait(0, NULL) > 0)
1187                 ;
1188 }
1189
1190
1191 int
1192 backgndpidset(void)
1193 {
1194         return backgndpid != -1;
1195 }
1196
1197
1198 pid_t
1199 backgndpidval(void)
1200 {
1201         if (bgjob != NULL && !forcelocal)
1202                 bgjob->remembered = 1;
1203         return backgndpid;
1204 }
1205
1206 /*
1207  * Return a string identifying a command (to be printed by the
1208  * jobs command.
1209  */
1210
1211 static char *cmdnextc;
1212 static int cmdnleft;
1213 #define MAXCMDTEXT      200
1214
1215 char *
1216 commandtext(union node *n)
1217 {
1218         char *name;
1219
1220         cmdnextc = name = ckmalloc(MAXCMDTEXT);
1221         cmdnleft = MAXCMDTEXT - 4;
1222         cmdtxt(n);
1223         *cmdnextc = '\0';
1224         return name;
1225 }
1226
1227
1228 static void
1229 cmdtxt(union node *n)
1230 {
1231         union node *np;
1232         struct nodelist *lp;
1233         const char *p;
1234         int i;
1235         char s[2];
1236
1237         if (n == NULL)
1238                 return;
1239         switch (n->type) {
1240         case NSEMI:
1241                 cmdtxt(n->nbinary.ch1);
1242                 cmdputs("; ");
1243                 cmdtxt(n->nbinary.ch2);
1244                 break;
1245         case NAND:
1246                 cmdtxt(n->nbinary.ch1);
1247                 cmdputs(" && ");
1248                 cmdtxt(n->nbinary.ch2);
1249                 break;
1250         case NOR:
1251                 cmdtxt(n->nbinary.ch1);
1252                 cmdputs(" || ");
1253                 cmdtxt(n->nbinary.ch2);
1254                 break;
1255         case NPIPE:
1256                 for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
1257                         cmdtxt(lp->n);
1258                         if (lp->next)
1259                                 cmdputs(" | ");
1260                 }
1261                 break;
1262         case NSUBSHELL:
1263                 cmdputs("(");
1264                 cmdtxt(n->nredir.n);
1265                 cmdputs(")");
1266                 break;
1267         case NREDIR:
1268         case NBACKGND:
1269                 cmdtxt(n->nredir.n);
1270                 break;
1271         case NIF:
1272                 cmdputs("if ");
1273                 cmdtxt(n->nif.test);
1274                 cmdputs("; then ");
1275                 cmdtxt(n->nif.ifpart);
1276                 cmdputs("...");
1277                 break;
1278         case NWHILE:
1279                 cmdputs("while ");
1280                 goto until;
1281         case NUNTIL:
1282                 cmdputs("until ");
1283 until:
1284                 cmdtxt(n->nbinary.ch1);
1285                 cmdputs("; do ");
1286                 cmdtxt(n->nbinary.ch2);
1287                 cmdputs("; done");
1288                 break;
1289         case NFOR:
1290                 cmdputs("for ");
1291                 cmdputs(n->nfor.var);
1292                 cmdputs(" in ...");
1293                 break;
1294         case NCASE:
1295                 cmdputs("case ");
1296                 cmdputs(n->ncase.expr->narg.text);
1297                 cmdputs(" in ...");
1298                 break;
1299         case NDEFUN:
1300                 cmdputs(n->narg.text);
1301                 cmdputs("() ...");
1302                 break;
1303         case NNOT:
1304                 cmdputs("! ");
1305                 cmdtxt(n->nnot.com);
1306                 break;
1307         case NCMD:
1308                 for (np = n->ncmd.args ; np ; np = np->narg.next) {
1309                         cmdtxt(np);
1310                         if (np->narg.next)
1311                                 cmdputs(" ");
1312                 }
1313                 for (np = n->ncmd.redirect ; np ; np = np->nfile.next) {
1314                         cmdputs(" ");
1315                         cmdtxt(np);
1316                 }
1317                 break;
1318         case NARG:
1319                 cmdputs(n->narg.text);
1320                 break;
1321         case NTO:
1322                 p = ">";  i = 1;  goto redir;
1323         case NAPPEND:
1324                 p = ">>";  i = 1;  goto redir;
1325         case NTOFD:
1326                 p = ">&";  i = 1;  goto redir;
1327         case NCLOBBER:
1328                 p = ">|"; i = 1; goto redir;
1329         case NFROM:
1330                 p = "<";  i = 0;  goto redir;
1331         case NFROMTO:
1332                 p = "<>";  i = 0;  goto redir;
1333         case NFROMFD:
1334                 p = "<&";  i = 0;  goto redir;
1335 redir:
1336                 if (n->nfile.fd != i) {
1337                         s[0] = n->nfile.fd + '0';
1338                         s[1] = '\0';
1339                         cmdputs(s);
1340                 }
1341                 cmdputs(p);
1342                 if (n->type == NTOFD || n->type == NFROMFD) {
1343                         if (n->ndup.dupfd >= 0)
1344                                 s[0] = n->ndup.dupfd + '0';
1345                         else
1346                                 s[0] = '-';
1347                         s[1] = '\0';
1348                         cmdputs(s);
1349                 } else {
1350                         cmdtxt(n->nfile.fname);
1351                 }
1352                 break;
1353         case NHERE:
1354         case NXHERE:
1355                 cmdputs("<<...");
1356                 break;
1357         default:
1358                 cmdputs("???");
1359                 break;
1360         }
1361 }
1362
1363
1364
1365 static void
1366 cmdputs(const char *s)
1367 {
1368         const char *p;
1369         char *q;
1370         char c;
1371         int subtype = 0;
1372
1373         if (cmdnleft <= 0)
1374                 return;
1375         p = s;
1376         q = cmdnextc;
1377         while ((c = *p++) != '\0') {
1378                 if (c == CTLESC)
1379                         *q++ = *p++;
1380                 else if (c == CTLVAR) {
1381                         *q++ = '$';
1382                         if (--cmdnleft > 0)
1383                                 *q++ = '{';
1384                         subtype = *p++;
1385                         if ((subtype & VSTYPE) == VSLENGTH && --cmdnleft > 0)
1386                                 *q++ = '#';
1387                 } else if (c == '=' && subtype != 0) {
1388                         *q = "}-+?=##%%\0X"[(subtype & VSTYPE) - VSNORMAL];
1389                         if (*q)
1390                                 q++;
1391                         else
1392                                 cmdnleft++;
1393                         if (((subtype & VSTYPE) == VSTRIMLEFTMAX ||
1394                             (subtype & VSTYPE) == VSTRIMRIGHTMAX) &&
1395                             --cmdnleft > 0)
1396                                 *q = q[-1], q++;
1397                         subtype = 0;
1398                 } else if (c == CTLENDVAR) {
1399                         *q++ = '}';
1400                 } else if (c == CTLBACKQ || c == CTLBACKQ+CTLQUOTE) {
1401                         cmdnleft -= 5;
1402                         if (cmdnleft > 0) {
1403                                 *q++ = '$';
1404                                 *q++ = '(';
1405                                 *q++ = '.';
1406                                 *q++ = '.';
1407                                 *q++ = '.';
1408                                 *q++ = ')';
1409                         }
1410                 } else if (c == CTLARI) {
1411                         cmdnleft -= 2;
1412                         if (cmdnleft > 0) {
1413                                 *q++ = '$';
1414                                 *q++ = '(';
1415                                 *q++ = '(';
1416                         }
1417                         p++;
1418                 } else if (c == CTLENDARI) {
1419                         if (--cmdnleft > 0) {
1420                                 *q++ = ')';
1421                                 *q++ = ')';
1422                         }
1423                 } else if (c == CTLQUOTEMARK || c == CTLQUOTEEND)
1424                         cmdnleft++; /* ignore */
1425                 else
1426                         *q++ = c;
1427                 if (--cmdnleft <= 0) {
1428                         *q++ = '.';
1429                         *q++ = '.';
1430                         *q++ = '.';
1431                         break;
1432                 }
1433         }
1434         cmdnextc = q;
1435 }