39dba1929b86886ed13e78fc32aaca5585cba05a
[dragonfly.git] / 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: src/bin/sh/jobs.c,v 1.94 2011/06/12 23:06:04 jilles Exp $
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 "show.h"
60 #include "main.h"
61 #include "parser.h"
62 #include "nodes.h"
63 #include "jobs.h"
64 #include "options.h"
65 #include "trap.h"
66 #include "syntax.h"
67 #include "input.h"
68 #include "output.h"
69 #include "memalloc.h"
70 #include "error.h"
71 #include "mystring.h"
72 #include "var.h"
73
74
75 static struct job *jobtab;      /* array of jobs */
76 static int njobs;               /* size of array */
77 MKINIT pid_t backgndpid = -1;   /* pid of last background process */
78 MKINIT struct job *bgjob = NULL; /* last background process */
79 #if JOBS
80 static struct job *jobmru;      /* most recently used job list */
81 static pid_t initialpgrp;       /* pgrp of shell on invocation */
82 #endif
83 int in_waitcmd = 0;             /* are we in waitcmd()? */
84 int in_dowait = 0;              /* are we in dowait()? */
85 volatile sig_atomic_t breakwaitcmd = 0; /* should wait be terminated? */
86 static int ttyfd = -1;
87
88 #if JOBS
89 static void restartjob(struct job *);
90 #endif
91 static void freejob(struct job *);
92 static struct job *getjob(char *);
93 static pid_t dowait(int, struct job *);
94 static pid_t waitproc(int, int *);
95 static void checkzombies(void);
96 static void cmdtxt(union node *);
97 static void cmdputs(const char *);
98 #if JOBS
99 static void setcurjob(struct job *);
100 static void deljob(struct job *);
101 static struct job *getcurjob(struct job *);
102 #endif
103 static void printjobcmd(struct job *);
104 static void showjob(struct job *, int);
105
106
107 /*
108  * Turn job control on and off.
109  */
110
111 MKINIT int jobctl;
112
113 #if JOBS
114 void
115 setjobctl(int on)
116 {
117         int i;
118
119         if (on == jobctl || rootshell == 0)
120                 return;
121         if (on) {
122                 if (ttyfd != -1)
123                         close(ttyfd);
124                 if ((ttyfd = open(_PATH_TTY, O_RDWR)) < 0) {
125                         i = 0;
126                         while (i <= 2 && !isatty(i))
127                                 i++;
128                         if (i > 2 || (ttyfd = fcntl(i, F_DUPFD, 10)) < 0)
129                                 goto out;
130                 }
131                 if (ttyfd < 10) {
132                         /*
133                          * Keep our TTY file descriptor out of the way of
134                          * the user's redirections.
135                          */
136                         if ((i = fcntl(ttyfd, F_DUPFD, 10)) < 0) {
137                                 close(ttyfd);
138                                 ttyfd = -1;
139                                 goto out;
140                         }
141                         close(ttyfd);
142                         ttyfd = i;
143                 }
144                 if (fcntl(ttyfd, F_SETFD, FD_CLOEXEC) < 0) {
145                         close(ttyfd);
146                         ttyfd = -1;
147                         goto out;
148                 }
149                 do { /* while we are in the background */
150                         initialpgrp = tcgetpgrp(ttyfd);
151                         if (initialpgrp < 0) {
152 out:                            out2fmt_flush("sh: can't access tty; job control turned off\n");
153                                 mflag = 0;
154                                 return;
155                         }
156                         if (initialpgrp != getpgrp()) {
157                                 kill(0, SIGTTIN);
158                                 continue;
159                         }
160                 } while (0);
161                 setsignal(SIGTSTP);
162                 setsignal(SIGTTOU);
163                 setsignal(SIGTTIN);
164                 setpgid(0, rootpid);
165                 tcsetpgrp(ttyfd, rootpid);
166         } else { /* turning job control off */
167                 setpgid(0, initialpgrp);
168                 tcsetpgrp(ttyfd, initialpgrp);
169                 close(ttyfd);
170                 ttyfd = -1;
171                 setsignal(SIGTSTP);
172                 setsignal(SIGTTOU);
173                 setsignal(SIGTTIN);
174         }
175         jobctl = on;
176 }
177 #endif
178
179
180 #if JOBS
181 int
182 fgcmd(int argc __unused, char **argv)
183 {
184         struct job *jp;
185         pid_t pgrp;
186         int status;
187
188         jp = getjob(argv[1]);
189         if (jp->jobctl == 0)
190                 error("job not created under job control");
191         printjobcmd(jp);
192         flushout(&output);
193         pgrp = jp->ps[0].pid;
194         tcsetpgrp(ttyfd, pgrp);
195         restartjob(jp);
196         jp->foreground = 1;
197         INTOFF;
198         status = waitforjob(jp, NULL);
199         INTON;
200         return status;
201 }
202
203
204 int
205 bgcmd(int argc, char **argv)
206 {
207         struct job *jp;
208
209         do {
210                 jp = getjob(*++argv);
211                 if (jp->jobctl == 0)
212                         error("job not created under job control");
213                 if (jp->state == JOBDONE)
214                         continue;
215                 restartjob(jp);
216                 jp->foreground = 0;
217                 out1fmt("[%td] ", jp - jobtab + 1);
218                 printjobcmd(jp);
219         } while (--argc > 1);
220         return 0;
221 }
222
223
224 static void
225 restartjob(struct job *jp)
226 {
227         struct procstat *ps;
228         int i;
229
230         if (jp->state == JOBDONE)
231                 return;
232         setcurjob(jp);
233         INTOFF;
234         kill(-jp->ps[0].pid, SIGCONT);
235         for (ps = jp->ps, i = jp->nprocs ; --i >= 0 ; ps++) {
236                 if (WIFSTOPPED(ps->status)) {
237                         ps->status = -1;
238                         jp->state = 0;
239                 }
240         }
241         INTON;
242 }
243 #endif
244
245
246 int
247 jobscmd(int argc, char *argv[])
248 {
249         char *id;
250         int ch, mode;
251
252         optind = optreset = 1;
253         opterr = 0;
254         mode = SHOWJOBS_DEFAULT;
255         while ((ch = getopt(argc, argv, "lps")) != -1) {
256                 switch (ch) {
257                 case 'l':
258                         mode = SHOWJOBS_VERBOSE;
259                         break;
260                 case 'p':
261                         mode = SHOWJOBS_PGIDS;
262                         break;
263                 case 's':
264                         mode = SHOWJOBS_PIDS;
265                         break;
266                 case '?':
267                 default:
268                         error("unknown option: -%c", optopt);
269                 }
270         }
271         argc -= optind;
272         argv += optind;
273
274         if (argc == 0)
275                 showjobs(0, mode);
276         else
277                 while ((id = *argv++) != NULL)
278                         showjob(getjob(id), mode);
279
280         return (0);
281 }
282
283 static void
284 printjobcmd(struct job *jp)
285 {
286         struct procstat *ps;
287         int i;
288
289         for (ps = jp->ps, i = jp->nprocs ; --i >= 0 ; ps++) {
290                 out1str(ps->cmd);
291                 if (i > 0)
292                         out1str(" | ");
293         }
294         out1c('\n');
295 }
296
297 static void
298 showjob(struct job *jp, int mode)
299 {
300         char s[64];
301         char statestr[64];
302         struct procstat *ps;
303         struct job *j;
304         int col, curr, i, jobno, prev, procno;
305         char c;
306
307         procno = (mode == SHOWJOBS_PGIDS) ? 1 : jp->nprocs;
308         jobno = jp - jobtab + 1;
309         curr = prev = 0;
310 #if JOBS
311         if ((j = getcurjob(NULL)) != NULL) {
312                 curr = j - jobtab + 1;
313                 if ((j = getcurjob(j)) != NULL)
314                         prev = j - jobtab + 1;
315         }
316 #endif
317         ps = jp->ps + jp->nprocs - 1;
318         if (jp->state == 0) {
319                 strcpy(statestr, "Running");
320 #if JOBS
321         } else if (jp->state == JOBSTOPPED) {
322                 while (!WIFSTOPPED(ps->status) && ps > jp->ps)
323                         ps--;
324                 if (WIFSTOPPED(ps->status))
325                         i = WSTOPSIG(ps->status);
326                 else
327                         i = -1;
328                 if (i > 0 && i < sys_nsig && sys_siglist[i])
329                         strcpy(statestr, sys_siglist[i]);
330                 else
331                         strcpy(statestr, "Suspended");
332 #endif
333         } else if (WIFEXITED(ps->status)) {
334                 if (WEXITSTATUS(ps->status) == 0)
335                         strcpy(statestr, "Done");
336                 else
337                         fmtstr(statestr, 64, "Done(%d)",
338                             WEXITSTATUS(ps->status));
339         } else {
340                 i = WTERMSIG(ps->status);
341                 if (i > 0 && i < sys_nsig && sys_siglist[i])
342                         strcpy(statestr, sys_siglist[i]);
343                 else
344                         fmtstr(statestr, 64, "Signal %d", i);
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(1, NULL) != -1);
520         in_waitcmd--;
521
522         return 0;
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
886 /*
887  * Wait for job to finish.
888  *
889  * Under job control we have the problem that while a child process is
890  * running interrupts generated by the user are sent to the child but not
891  * to the shell.  This means that an infinite loop started by an inter-
892  * active user may be hard to kill.  With job control turned off, an
893  * interactive user may place an interactive program inside a loop.  If
894  * the interactive program catches interrupts, the user doesn't want
895  * these interrupts to also abort the loop.  The approach we take here
896  * is to have the shell ignore interrupt signals while waiting for a
897  * foreground process to terminate, and then send itself an interrupt
898  * signal if the child process was terminated by an interrupt signal.
899  * Unfortunately, some programs want to do a bit of cleanup and then
900  * exit on interrupt; unless these processes terminate themselves by
901  * sending a signal to themselves (instead of calling exit) they will
902  * confuse this approach.
903  */
904
905 int
906 waitforjob(struct job *jp, int *origstatus)
907 {
908 #if JOBS
909         pid_t mypgrp = getpgrp();
910         int propagate_int = jp->jobctl && jp->foreground;
911 #endif
912         int status;
913         int st;
914
915         INTOFF;
916         TRACE(("waitforjob(%%%td) called\n", jp - jobtab + 1));
917         while (jp->state == 0)
918                 if (dowait(1, jp) == -1)
919                         dotrap();
920 #if JOBS
921         if (jp->jobctl) {
922                 if (tcsetpgrp(ttyfd, mypgrp) < 0)
923                         error("tcsetpgrp failed, errno=%d\n", errno);
924         }
925         if (jp->state == JOBSTOPPED)
926                 setcurjob(jp);
927 #endif
928         status = jp->ps[jp->nprocs - 1].status;
929         if (origstatus != NULL)
930                 *origstatus = status;
931         /* convert to 8 bits */
932         if (WIFEXITED(status))
933                 st = WEXITSTATUS(status);
934 #if JOBS
935         else if (WIFSTOPPED(status))
936                 st = WSTOPSIG(status) + 128;
937 #endif
938         else
939                 st = WTERMSIG(status) + 128;
940         if (! JOBS || jp->state == JOBDONE)
941                 freejob(jp);
942         if (int_pending()) {
943                 if (!WIFSIGNALED(status) || WTERMSIG(status) != SIGINT)
944                         CLEAR_PENDING_INT;
945         }
946 #if JOBS
947         else if (rootshell && iflag && propagate_int &&
948                         WIFSIGNALED(status) && WTERMSIG(status) == SIGINT)
949                 kill(getpid(), SIGINT);
950 #endif
951         INTON;
952         return st;
953 }
954
955
956
957 /*
958  * Wait for a process to terminate.
959  */
960
961 static pid_t
962 dowait(int block, struct job *job)
963 {
964         pid_t pid;
965         int status;
966         struct procstat *sp;
967         struct job *jp;
968         struct job *thisjob;
969         int done;
970         int stopped;
971         int sig;
972         int coredump;
973
974         in_dowait++;
975         TRACE(("dowait(%d) called\n", block));
976         do {
977                 pid = waitproc(block, &status);
978                 TRACE(("wait returns %d, status=%d\n", (int)pid, status));
979         } while ((pid == -1 && errno == EINTR && breakwaitcmd == 0) ||
980                  (pid > 0 && WIFSTOPPED(status) && !iflag));
981         in_dowait--;
982         if (pid == -1 && errno == ECHILD && job != NULL)
983                 job->state = JOBDONE;
984         if (breakwaitcmd != 0) {
985                 breakwaitcmd = 0;
986                 /*
987                  * Do not early terminate if the pid is positive, else the
988                  * job will not be properly recorded.
989                  */
990                 if (pid <= 0)
991                         return -1;
992         }
993         if (pid <= 0)
994                 return pid;
995         INTOFF;
996         thisjob = NULL;
997         for (jp = jobtab ; jp < jobtab + njobs ; jp++) {
998                 if (jp->used && jp->nprocs > 0) {
999                         done = 1;
1000                         stopped = 1;
1001                         for (sp = jp->ps ; sp < jp->ps + jp->nprocs ; sp++) {
1002                                 if (sp->pid == -1)
1003                                         continue;
1004                                 if (sp->pid == pid) {
1005                                         TRACE(("Changing status of proc %d from 0x%x to 0x%x\n",
1006                                                    (int)pid, sp->status,
1007                                                    status));
1008                                         sp->status = status;
1009                                         thisjob = jp;
1010                                 }
1011                                 if (sp->status == -1)
1012                                         stopped = 0;
1013                                 else if (WIFSTOPPED(sp->status))
1014                                         done = 0;
1015                         }
1016                         if (stopped) {          /* stopped or done */
1017                                 int state = done? JOBDONE : JOBSTOPPED;
1018                                 if (jp->state != state) {
1019                                         TRACE(("Job %td: changing state from %d to %d\n", jp - jobtab + 1, jp->state, state));
1020                                         jp->state = state;
1021                                         if (jp != job) {
1022                                                 if (done && !jp->remembered &&
1023                                                     !iflag && jp != bgjob)
1024                                                         freejob(jp);
1025 #if JOBS
1026                                                 else if (done)
1027                                                         deljob(jp);
1028 #endif
1029                                         }
1030                                 }
1031                         }
1032                 }
1033         }
1034         INTON;
1035         if (!thisjob || thisjob->state == 0)
1036                 ;
1037         else if ((!rootshell || !iflag || thisjob == job) &&
1038             thisjob->foreground && thisjob->state != JOBSTOPPED) {
1039                 sig = 0;
1040                 coredump = 0;
1041                 for (sp = thisjob->ps; sp < thisjob->ps + thisjob->nprocs; sp++)
1042                         if (WIFSIGNALED(sp->status)) {
1043                                 sig = WTERMSIG(sp->status);
1044                                 coredump = WCOREDUMP(sp->status);
1045                         }
1046                 if (sig > 0 && sig != SIGINT && sig != SIGPIPE) {
1047                         if (sig < sys_nsig && sys_siglist[sig])
1048                                 out2str(sys_siglist[sig]);
1049                         else
1050                                 outfmt(out2, "Signal %d", sig);
1051                         if (coredump)
1052                                 out2str(" (core dumped)");
1053                         out2c('\n');
1054                         flushout(out2);
1055                 }
1056         } else {
1057                 TRACE(("Not printing status, rootshell=%d, job=%p\n", rootshell, job));
1058                 thisjob->changed = 1;
1059         }
1060         return pid;
1061 }
1062
1063
1064
1065 /*
1066  * Do a wait system call.  If job control is compiled in, we accept
1067  * stopped processes.  If block is zero, we return a value of zero
1068  * rather than blocking.
1069  */
1070 static pid_t
1071 waitproc(int block, int *status)
1072 {
1073         int flags;
1074
1075 #if JOBS
1076         flags = WUNTRACED;
1077 #else
1078         flags = 0;
1079 #endif
1080         if (block == 0)
1081                 flags |= WNOHANG;
1082         return wait3(status, flags, NULL);
1083 }
1084
1085 /*
1086  * return 1 if there are stopped jobs, otherwise 0
1087  */
1088 int job_warning = 0;
1089 int
1090 stoppedjobs(void)
1091 {
1092         int jobno;
1093         struct job *jp;
1094
1095         if (job_warning)
1096                 return (0);
1097         for (jobno = 1, jp = jobtab; jobno <= njobs; jobno++, jp++) {
1098                 if (jp->used == 0)
1099                         continue;
1100                 if (jp->state == JOBSTOPPED) {
1101                         out2fmt_flush("You have stopped jobs.\n");
1102                         job_warning = 2;
1103                         return (1);
1104                 }
1105         }
1106
1107         return (0);
1108 }
1109
1110
1111 static void
1112 checkzombies(void)
1113 {
1114         while (njobs > 0 && dowait(0, NULL) > 0)
1115                 ;
1116 }
1117
1118
1119 int
1120 backgndpidset(void)
1121 {
1122         return backgndpid != -1;
1123 }
1124
1125
1126 pid_t
1127 backgndpidval(void)
1128 {
1129         if (bgjob != NULL && !forcelocal)
1130                 bgjob->remembered = 1;
1131         return backgndpid;
1132 }
1133
1134 /*
1135  * Return a string identifying a command (to be printed by the
1136  * jobs command.
1137  */
1138
1139 static char *cmdnextc;
1140 static int cmdnleft;
1141 #define MAXCMDTEXT      200
1142
1143 char *
1144 commandtext(union node *n)
1145 {
1146         char *name;
1147
1148         cmdnextc = name = ckmalloc(MAXCMDTEXT);
1149         cmdnleft = MAXCMDTEXT - 4;
1150         cmdtxt(n);
1151         *cmdnextc = '\0';
1152         return name;
1153 }
1154
1155
1156 static void
1157 cmdtxt(union node *n)
1158 {
1159         union node *np;
1160         struct nodelist *lp;
1161         const char *p;
1162         int i;
1163         char s[2];
1164
1165         if (n == NULL)
1166                 return;
1167         switch (n->type) {
1168         case NSEMI:
1169                 cmdtxt(n->nbinary.ch1);
1170                 cmdputs("; ");
1171                 cmdtxt(n->nbinary.ch2);
1172                 break;
1173         case NAND:
1174                 cmdtxt(n->nbinary.ch1);
1175                 cmdputs(" && ");
1176                 cmdtxt(n->nbinary.ch2);
1177                 break;
1178         case NOR:
1179                 cmdtxt(n->nbinary.ch1);
1180                 cmdputs(" || ");
1181                 cmdtxt(n->nbinary.ch2);
1182                 break;
1183         case NPIPE:
1184                 for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
1185                         cmdtxt(lp->n);
1186                         if (lp->next)
1187                                 cmdputs(" | ");
1188                 }
1189                 break;
1190         case NSUBSHELL:
1191                 cmdputs("(");
1192                 cmdtxt(n->nredir.n);
1193                 cmdputs(")");
1194                 break;
1195         case NREDIR:
1196         case NBACKGND:
1197                 cmdtxt(n->nredir.n);
1198                 break;
1199         case NIF:
1200                 cmdputs("if ");
1201                 cmdtxt(n->nif.test);
1202                 cmdputs("; then ");
1203                 cmdtxt(n->nif.ifpart);
1204                 cmdputs("...");
1205                 break;
1206         case NWHILE:
1207                 cmdputs("while ");
1208                 goto until;
1209         case NUNTIL:
1210                 cmdputs("until ");
1211 until:
1212                 cmdtxt(n->nbinary.ch1);
1213                 cmdputs("; do ");
1214                 cmdtxt(n->nbinary.ch2);
1215                 cmdputs("; done");
1216                 break;
1217         case NFOR:
1218                 cmdputs("for ");
1219                 cmdputs(n->nfor.var);
1220                 cmdputs(" in ...");
1221                 break;
1222         case NCASE:
1223                 cmdputs("case ");
1224                 cmdputs(n->ncase.expr->narg.text);
1225                 cmdputs(" in ...");
1226                 break;
1227         case NDEFUN:
1228                 cmdputs(n->narg.text);
1229                 cmdputs("() ...");
1230                 break;
1231         case NCMD:
1232                 for (np = n->ncmd.args ; np ; np = np->narg.next) {
1233                         cmdtxt(np);
1234                         if (np->narg.next)
1235                                 cmdputs(" ");
1236                 }
1237                 for (np = n->ncmd.redirect ; np ; np = np->nfile.next) {
1238                         cmdputs(" ");
1239                         cmdtxt(np);
1240                 }
1241                 break;
1242         case NARG:
1243                 cmdputs(n->narg.text);
1244                 break;
1245         case NTO:
1246                 p = ">";  i = 1;  goto redir;
1247         case NAPPEND:
1248                 p = ">>";  i = 1;  goto redir;
1249         case NTOFD:
1250                 p = ">&";  i = 1;  goto redir;
1251         case NCLOBBER:
1252                 p = ">|"; i = 1; goto redir;
1253         case NFROM:
1254                 p = "<";  i = 0;  goto redir;
1255         case NFROMTO:
1256                 p = "<>";  i = 0;  goto redir;
1257         case NFROMFD:
1258                 p = "<&";  i = 0;  goto redir;
1259 redir:
1260                 if (n->nfile.fd != i) {
1261                         s[0] = n->nfile.fd + '0';
1262                         s[1] = '\0';
1263                         cmdputs(s);
1264                 }
1265                 cmdputs(p);
1266                 if (n->type == NTOFD || n->type == NFROMFD) {
1267                         if (n->ndup.dupfd >= 0)
1268                                 s[0] = n->ndup.dupfd + '0';
1269                         else
1270                                 s[0] = '-';
1271                         s[1] = '\0';
1272                         cmdputs(s);
1273                 } else {
1274                         cmdtxt(n->nfile.fname);
1275                 }
1276                 break;
1277         case NHERE:
1278         case NXHERE:
1279                 cmdputs("<<...");
1280                 break;
1281         default:
1282                 cmdputs("???");
1283                 break;
1284         }
1285 }
1286
1287
1288
1289 static void
1290 cmdputs(const char *s)
1291 {
1292         const char *p;
1293         char *q;
1294         char c;
1295         int subtype = 0;
1296
1297         if (cmdnleft <= 0)
1298                 return;
1299         p = s;
1300         q = cmdnextc;
1301         while ((c = *p++) != '\0') {
1302                 if (c == CTLESC)
1303                         *q++ = *p++;
1304                 else if (c == CTLVAR) {
1305                         *q++ = '$';
1306                         if (--cmdnleft > 0)
1307                                 *q++ = '{';
1308                         subtype = *p++;
1309                         if ((subtype & VSTYPE) == VSLENGTH && --cmdnleft > 0)
1310                                 *q++ = '#';
1311                 } else if (c == '=' && subtype != 0) {
1312                         *q = "}-+?=##%%\0X"[(subtype & VSTYPE) - VSNORMAL];
1313                         if (*q)
1314                                 q++;
1315                         else
1316                                 cmdnleft++;
1317                         if (((subtype & VSTYPE) == VSTRIMLEFTMAX ||
1318                             (subtype & VSTYPE) == VSTRIMRIGHTMAX) &&
1319                             --cmdnleft > 0)
1320                                 *q = q[-1], q++;
1321                         subtype = 0;
1322                 } else if (c == CTLENDVAR) {
1323                         *q++ = '}';
1324                 } else if (c == CTLBACKQ || c == CTLBACKQ+CTLQUOTE) {
1325                         cmdnleft -= 5;
1326                         if (cmdnleft > 0) {
1327                                 *q++ = '$';
1328                                 *q++ = '(';
1329                                 *q++ = '.';
1330                                 *q++ = '.';
1331                                 *q++ = '.';
1332                                 *q++ = ')';
1333                         }
1334                 } else if (c == CTLARI) {
1335                         cmdnleft -= 2;
1336                         if (cmdnleft > 0) {
1337                                 *q++ = '$';
1338                                 *q++ = '(';
1339                                 *q++ = '(';
1340                         }
1341                         p++;
1342                 } else if (c == CTLENDARI) {
1343                         if (--cmdnleft > 0) {
1344                                 *q++ = ')';
1345                                 *q++ = ')';
1346                         }
1347                 } else if (c == CTLQUOTEMARK || c == CTLQUOTEEND)
1348                         cmdnleft++; /* ignore */
1349                 else
1350                         *q++ = c;
1351                 if (--cmdnleft <= 0) {
1352                         *q++ = '.';
1353                         *q++ = '.';
1354                         *q++ = '.';
1355                         break;
1356                 }
1357         }
1358         cmdnextc = q;
1359 }