1 /* $NetBSD: jobs.c,v 1.75 2015/08/22 12:12:47 christos Exp $ */
2
3 /*-
4 * Copyright (c) 1991, 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * This code is derived from software contributed to Berkeley by
8 * Kenneth Almquist.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. Neither the name of the University nor the names of its contributors
19 * may be used to endorse or promote products derived from this software
20 * without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
34
35 #include <sys/cdefs.h>
36 #ifndef lint
37 #if 0
38 static char sccsid[] = "@(#)jobs.c 8.5 (Berkeley) 5/4/95";
39 #else
40 __RCSID("$NetBSD: jobs.c,v 1.75 2015/08/22 12:12:47 christos Exp $");
41 #endif
42 #endif /* not lint */
43
44 #include <fcntl.h>
45 #include <signal.h>
46 #include <errno.h>
47 #include <unistd.h>
48 #include <stdlib.h>
49 #include <paths.h>
50 #include <sys/types.h>
51 #include <sys/param.h>
52 #ifdef BSD
53 #include <sys/wait.h>
54 #include <sys/time.h>
55 #include <sys/resource.h>
56 #endif
57 #include <sys/ioctl.h>
58
59 #include "shell.h"
60 #if JOBS
61 #if OLD_TTY_DRIVER
62 #include "sgtty.h"
63 #else
64 #include <termios.h>
65 #endif
66 #undef CEOF /* syntax.h redefines this */
67 #endif
68 #include "redir.h"
69 #include "show.h"
70 #include "main.h"
71 #include "parser.h"
72 #include "nodes.h"
73 #include "jobs.h"
74 #include "options.h"
75 #include "builtins.h"
76 #include "trap.h"
77 #include "syntax.h"
78 #include "input.h"
79 #include "output.h"
80 #include "memalloc.h"
81 #include "error.h"
82 #include "mystring.h"
83
84
85 static struct job *jobtab; /* array of jobs */
86 static int njobs; /* size of array */
87 static int jobs_invalid; /* set in child */
88 MKINIT pid_t backgndpid = -1; /* pid of last background process */
89 #if JOBS
90 int initialpgrp; /* pgrp of shell on invocation */
91 static int curjob = -1; /* current job */
92 #endif
93 #if JOBS && defined(__minix)
94 static int ttyfd = -1;
95 #endif /* JOBS && defined(__minix) */
96
97 STATIC void restartjob(struct job *);
98 STATIC void freejob(struct job *);
99 STATIC struct job *getjob(const char *, int);
100 STATIC int dowait(int, struct job *);
101 #define WBLOCK 1
102 #define WNOFREE 2
103 STATIC int waitproc(int, struct job *, int *);
104 STATIC void cmdtxt(union node *);
105 STATIC void cmdlist(union node *, int);
106 STATIC void cmdputs(const char *);
107
108 #ifdef SYSV
109 STATIC int onsigchild(void);
110 #endif
111
112 #ifdef OLD_TTY_DRIVER
113 static pid_t tcgetpgrp(int fd);
114 static int tcsetpgrp(int fd, pid_t pgrp);
115
116 static pid_t
tcgetpgrp(int fd)117 tcgetpgrp(int fd)
118 {
119 pid_t pgrp;
120 if (ioctl(fd, TIOCGPGRP, (char *)&pgrp) == -1)
121 return -1;
122 else
123 return pgrp;
124 }
125
126 static int
tcsetpgrp(int fd,pid_tpgrp)127 tcsetpgrp(int fd, pid_tpgrp)
128 {
129 return ioctl(fd, TIOCSPGRP, (char *)&pgrp);
130 }
131 #endif
132
133 /*
134 * Turn job control on and off.
135 *
136 * Note: This code assumes that the third arg to ioctl is a character
137 * pointer, which is true on Berkeley systems but not System V. Since
138 * System V doesn't have job control yet, this isn't a problem now.
139 */
140
141 MKINIT int jobctl;
142
143 #if JOBS /* Minix setjobctl is defined to empty, compilation error */
144 void
setjobctl(int on)145 setjobctl(int on)
146 {
147 #ifdef OLD_TTY_DRIVER
148 int ldisc;
149 #endif
150
151 if (on == jobctl || rootshell == 0)
152 return;
153 if (on) {
154 #if defined(FIOCLEX) || defined(FD_CLOEXEC)
155 int err;
156 int i;
157 if (ttyfd != -1)
158 close(ttyfd);
159 if ((ttyfd = open("/dev/tty", O_RDWR)) == -1) {
160 for (i = 0; i < 3; i++) {
161 if (isatty(i) && (ttyfd = dup(i)) != -1)
162 break;
163 }
164 if (i == 3)
165 goto out;
166 }
167 /* Move to a high fd */
168 for (i = 10; i > 2; i--) {
169 if ((err = fcntl(ttyfd, F_DUPFD, (1 << i) - 1)) != -1)
170 break;
171 }
172 if (err != -1) {
173 close(ttyfd);
174 ttyfd = err;
175 }
176 #ifdef FIOCLEX
177 err = ioctl(ttyfd, FIOCLEX, 0);
178 #elif FD_CLOEXEC
179 err = fcntl(ttyfd, F_SETFD,
180 fcntl(ttyfd, F_GETFD, 0) | FD_CLOEXEC);
181 #endif
182 if (err == -1) {
183 close(ttyfd);
184 ttyfd = -1;
185 goto out;
186 }
187 #else
188 out2str("sh: Need FIOCLEX or FD_CLOEXEC to support job control");
189 goto out;
190 #endif
191 do { /* while we are in the background */
192 if ((initialpgrp = tcgetpgrp(ttyfd)) < 0) {
193 out:
194 out2str("sh: can't access tty; job control turned off\n");
195 mflag = 0;
196 return;
197 }
198 if (initialpgrp == -1)
199 initialpgrp = getpgrp();
200 else if (initialpgrp != getpgrp()) {
201 killpg(0, SIGTTIN);
202 continue;
203 }
204 } while (0);
205
206 #ifdef OLD_TTY_DRIVER
207 if (ioctl(ttyfd, TIOCGETD, (char *)&ldisc) < 0
208 || ldisc != NTTYDISC) {
209 out2str("sh: need new tty driver to run job control; job control turned off\n");
210 mflag = 0;
211 return;
212 }
213 #endif
214 setsignal(SIGTSTP, 0);
215 setsignal(SIGTTOU, 0);
216 setsignal(SIGTTIN, 0);
217 if (getpgrp() != rootpid && setpgid(0, rootpid) == -1)
218 error("Cannot set process group (%s) at %d",
219 strerror(errno), __LINE__);
220 if (tcsetpgrp(ttyfd, rootpid) == -1)
221 error("Cannot set tty process group (%s) at %d",
222 strerror(errno), __LINE__);
223 } else { /* turning job control off */
224 if (getpgrp() != initialpgrp && setpgid(0, initialpgrp) == -1)
225 error("Cannot set process group (%s) at %d",
226 strerror(errno), __LINE__);
227 if (tcsetpgrp(ttyfd, initialpgrp) == -1)
228 error("Cannot set tty process group (%s) at %d",
229 strerror(errno), __LINE__);
230 close(ttyfd);
231 ttyfd = -1;
232 setsignal(SIGTSTP, 0);
233 setsignal(SIGTTOU, 0);
234 setsignal(SIGTTIN, 0);
235 }
236 jobctl = on;
237 }
238 #endif /* JOBS */
239
240
241 #ifdef mkinit
242 INCLUDE <stdlib.h>
243
244 SHELLPROC {
245 backgndpid = -1;
246 #if JOBS
247 jobctl = 0;
248 #endif
249 }
250
251 #endif
252
253
254
255 #if JOBS
256 static int
do_fgcmd(const char * arg_ptr)257 do_fgcmd(const char *arg_ptr)
258 {
259 struct job *jp;
260 int i;
261 int status;
262
263 jp = getjob(arg_ptr, 0);
264 if (jp->jobctl == 0)
265 error("job not created under job control");
266 out1fmt("%s", jp->ps[0].cmd);
267 for (i = 1; i < jp->nprocs; i++)
268 out1fmt(" | %s", jp->ps[i].cmd );
269 out1c('\n');
270 flushall();
271
272 for (i = 0; i < jp->nprocs; i++)
273 if (tcsetpgrp(ttyfd, jp->ps[i].pid) != -1)
274 break;
275
276 if (i >= jp->nprocs) {
277 error("Cannot set tty process group (%s) at %d",
278 strerror(errno), __LINE__);
279 }
280 restartjob(jp);
281 INTOFF;
282 status = waitforjob(jp);
283 INTON;
284 return status;
285 }
286
287 int
fgcmd(int argc,char ** argv)288 fgcmd(int argc, char **argv)
289 {
290 nextopt("");
291 return do_fgcmd(*argptr);
292 }
293
294 int
fgcmd_percent(int argc,char ** argv)295 fgcmd_percent(int argc, char **argv)
296 {
297 nextopt("");
298 return do_fgcmd(*argv);
299 }
300
301 static void
set_curjob(struct job * jp,int mode)302 set_curjob(struct job *jp, int mode)
303 {
304 struct job *jp1, *jp2;
305 int i, ji;
306
307 ji = jp - jobtab;
308
309 /* first remove from list */
310 if (ji == curjob)
311 curjob = jp->prev_job;
312 else {
313 for (i = 0; i < njobs; i++) {
314 if (jobtab[i].prev_job != ji)
315 continue;
316 jobtab[i].prev_job = jp->prev_job;
317 break;
318 }
319 }
320
321 /* Then re-insert in correct position */
322 switch (mode) {
323 case 0: /* job being deleted */
324 jp->prev_job = -1;
325 break;
326 case 1: /* newly created job or backgrounded job,
327 put after all stopped jobs. */
328 if (curjob != -1 && jobtab[curjob].state == JOBSTOPPED) {
329 for (jp1 = jobtab + curjob; ; jp1 = jp2) {
330 if (jp1->prev_job == -1)
331 break;
332 jp2 = jobtab + jp1->prev_job;
333 if (jp2->state != JOBSTOPPED)
334 break;
335 }
336 jp->prev_job = jp1->prev_job;
337 jp1->prev_job = ji;
338 break;
339 }
340 /* FALLTHROUGH */
341 case 2: /* newly stopped job - becomes curjob */
342 jp->prev_job = curjob;
343 curjob = ji;
344 break;
345 }
346 }
347
348 int
bgcmd(int argc,char ** argv)349 bgcmd(int argc, char **argv)
350 {
351 struct job *jp;
352 int i;
353
354 nextopt("");
355 do {
356 jp = getjob(*argptr, 0);
357 if (jp->jobctl == 0)
358 error("job not created under job control");
359 set_curjob(jp, 1);
360 out1fmt("[%ld] %s", (long)(jp - jobtab + 1), jp->ps[0].cmd);
361 for (i = 1; i < jp->nprocs; i++)
362 out1fmt(" | %s", jp->ps[i].cmd );
363 out1c('\n');
364 flushall();
365 restartjob(jp);
366 } while (*argptr && *++argptr);
367 return 0;
368 }
369
370
371 STATIC void
restartjob(struct job * jp)372 restartjob(struct job *jp)
373 {
374 struct procstat *ps;
375 int i;
376
377 if (jp->state == JOBDONE)
378 return;
379 INTOFF;
380 for (i = 0; i < jp->nprocs; i++)
381 if (killpg(jp->ps[i].pid, SIGCONT) != -1)
382 break;
383 if (i >= jp->nprocs)
384 error("Cannot continue job (%s)", strerror(errno));
385 for (ps = jp->ps, i = jp->nprocs ; --i >= 0 ; ps++) {
386 if (WIFSTOPPED(ps->status)) {
387 ps->status = -1;
388 jp->state = JOBRUNNING;
389 }
390 }
391 INTON;
392 }
393 #else
394 /* LSC: For Minix add dummy functions. */
395 int
fgcmd(int argc,char ** argv)396 fgcmd(int argc, char **argv)
397 {
398 error("no job control in this shell.");
399 return 1;
400 }
401
402 int
fgcmd_percent(int argc,char ** argv)403 fgcmd_percent(int argc, char **argv)
404 {
405 error("no job control in this shell.");
406 return 1;
407 }
408
409
410 int
bgcmd(int argc,char ** argv)411 bgcmd(int argc, char **argv)
412 {
413 error("no job control in this shell.");
414 return 1;
415 }
416 #endif
417
418 static void
showjob(struct output * out,struct job * jp,int mode)419 showjob(struct output *out, struct job *jp, int mode)
420 {
421 int procno;
422 int st;
423 struct procstat *ps;
424 int col;
425 char s[64];
426
427 #if JOBS
428 if (mode & SHOW_PGID) {
429 /* just output process (group) id of pipeline */
430 outfmt(out, "%ld\n", (long)jp->ps->pid);
431 return;
432 }
433 #endif
434
435 procno = jp->nprocs;
436 if (!procno)
437 return;
438
439 if (mode & SHOW_PID)
440 mode |= SHOW_MULTILINE;
441
442 if ((procno > 1 && !(mode & SHOW_MULTILINE))
443 || (mode & SHOW_SIGNALLED)) {
444 /* See if we have more than one status to report */
445 ps = jp->ps;
446 st = ps->status;
447 do {
448 int st1 = ps->status;
449 if (st1 != st)
450 /* yes - need multi-line output */
451 mode |= SHOW_MULTILINE;
452 if (st1 == -1 || !(mode & SHOW_SIGNALLED) || WIFEXITED(st1))
453 continue;
454 if (WIFSTOPPED(st1) || ((st1 = WTERMSIG(st1) & 0x7f)
455 && st1 != SIGINT && st1 != SIGPIPE))
456 mode |= SHOW_ISSIG;
457
458 } while (ps++, --procno);
459 procno = jp->nprocs;
460 }
461
462 if (mode & SHOW_SIGNALLED && !(mode & SHOW_ISSIG)) {
463 if (jp->state == JOBDONE && !(mode & SHOW_NO_FREE)) {
464 TRACE(("showjob: freeing job %d\n", jp - jobtab + 1));
465 freejob(jp);
466 }
467 return;
468 }
469
470 for (ps = jp->ps; --procno >= 0; ps++) { /* for each process */
471 if (ps == jp->ps)
472 fmtstr(s, 16, "[%ld] %c ",
473 (long)(jp - jobtab + 1),
474 #if JOBS
475 jp == jobtab + curjob ? '+' :
476 curjob != -1 && jp == jobtab +
477 jobtab[curjob].prev_job ? '-' :
478 #endif
479 ' ');
480 else
481 fmtstr(s, 16, " " );
482 col = strlen(s);
483 if (mode & SHOW_PID) {
484 fmtstr(s + col, 16, "%ld ", (long)ps->pid);
485 col += strlen(s + col);
486 }
487 if (ps->status == -1) {
488 scopy("Running", s + col);
489 } else if (WIFEXITED(ps->status)) {
490 st = WEXITSTATUS(ps->status);
491 if (st)
492 fmtstr(s + col, 16, "Done(%d)", st);
493 else
494 fmtstr(s + col, 16, "Done");
495 } else {
496 #if JOBS
497 if (WIFSTOPPED(ps->status))
498 st = WSTOPSIG(ps->status);
499 else /* WIFSIGNALED(ps->status) */
500 #endif
501 st = WTERMSIG(ps->status);
502 st &= 0x7f;
503 if (st < NSIG && sys_siglist[st])
504 scopyn(sys_siglist[st], s + col, 32);
505 else
506 fmtstr(s + col, 16, "Signal %d", st);
507 if (WCOREDUMP(ps->status)) {
508 col += strlen(s + col);
509 scopyn(" (core dumped)", s + col, 64 - col);
510 }
511 }
512 col += strlen(s + col);
513 outstr(s, out);
514 do {
515 outc(' ', out);
516 col++;
517 } while (col < 30);
518 outstr(ps->cmd, out);
519 if (mode & SHOW_MULTILINE) {
520 if (procno > 0) {
521 outc(' ', out);
522 outc('|', out);
523 }
524 } else {
525 while (--procno >= 0)
526 outfmt(out, " | %s", (++ps)->cmd );
527 }
528 outc('\n', out);
529 }
530 flushout(out);
531 jp->changed = 0;
532 if (jp->state == JOBDONE && !(mode & SHOW_NO_FREE))
533 freejob(jp);
534 }
535
536
537 int
jobscmd(int argc,char ** argv)538 jobscmd(int argc, char **argv)
539 {
540 int mode, m;
541 int sv = jobs_invalid;
542
543 jobs_invalid = 0;
544 mode = 0;
545 while ((m = nextopt("lp")))
546 if (m == 'l')
547 mode = SHOW_PID;
548 else
549 mode = SHOW_PGID;
550 if (*argptr)
551 do
552 showjob(out1, getjob(*argptr,0), mode);
553 while (*++argptr);
554 else
555 showjobs(out1, mode);
556 jobs_invalid = sv;
557 return 0;
558 }
559
560
561 /*
562 * Print a list of jobs. If "change" is nonzero, only print jobs whose
563 * statuses have changed since the last call to showjobs.
564 *
565 * If the shell is interrupted in the process of creating a job, the
566 * result may be a job structure containing zero processes. Such structures
567 * will be freed here.
568 */
569
570 void
showjobs(struct output * out,int mode)571 showjobs(struct output *out, int mode)
572 {
573 int jobno;
574 struct job *jp;
575 #if JOBS /* MINIX: gotpid. */
576 int silent = 0, gotpid;
577 #else
578 int silent = 0;
579 #endif
580
581 TRACE(("showjobs(%x) called\n", mode));
582
583 /* If not even one one job changed, there is nothing to do */
584 #if JOBS /* MINIX: gotpid. */
585 gotpid = dowait(0, NULL);
586 #endif
587 while (dowait(0, NULL) > 0)
588 continue;
589 #if JOBS /* MINIX: #ifdef fails when JOBS = 0 */
590 /*
591 * Check if we are not in our foreground group, and if not
592 * put us in it.
593 */
594 if (mflag && gotpid != -1 && tcgetpgrp(ttyfd) != getpid()) {
595 if (tcsetpgrp(ttyfd, getpid()) == -1)
596 error("Cannot set tty process group (%s) at %d",
597 strerror(errno), __LINE__);
598 TRACE(("repaired tty process group\n"));
599 silent = 1;
600 }
601 #endif
602 if (jobs_invalid)
603 return;
604
605 for (jobno = 1, jp = jobtab ; jobno <= njobs ; jobno++, jp++) {
606 if (!jp->used)
607 continue;
608 if (jp->nprocs == 0) {
609 freejob(jp);
610 continue;
611 }
612 if ((mode & SHOW_CHANGED) && !jp->changed)
613 continue;
614 if (silent && jp->changed) {
615 jp->changed = 0;
616 continue;
617 }
618 showjob(out, jp, mode);
619 }
620 }
621
622 /*
623 * Mark a job structure as unused.
624 */
625
626 STATIC void
freejob(struct job * jp)627 freejob(struct job *jp)
628 {
629 INTOFF;
630 if (jp->ps != &jp->ps0) {
631 ckfree(jp->ps);
632 jp->ps = &jp->ps0;
633 }
634 jp->nprocs = 0;
635 jp->used = 0;
636 #if JOBS
637 set_curjob(jp, 0);
638 #endif
639 INTON;
640 }
641
642
643
644 int
waitcmd(int argc,char ** argv)645 waitcmd(int argc, char **argv)
646 {
647 struct job *job;
648 int status, retval;
649 struct job *jp;
650
651 nextopt("");
652
653 if (!*argptr) {
654 /* wait for all jobs */
655 jp = jobtab;
656 if (jobs_invalid)
657 return 0;
658 for (;;) {
659 if (jp >= jobtab + njobs) {
660 /* no running procs */
661 return 0;
662 }
663 if (!jp->used || jp->state != JOBRUNNING) {
664 jp++;
665 continue;
666 }
667 if (dowait(WBLOCK, NULL) == -1)
668 return 128 + lastsig();
669 jp = jobtab;
670 }
671 }
672
673 retval = 127; /* XXXGCC: -Wuninitialized */
674 for (; *argptr; argptr++) {
675 job = getjob(*argptr, 1);
676 if (!job) {
677 retval = 127;
678 continue;
679 }
680 /* loop until process terminated or stopped */
681 while (job->state == JOBRUNNING) {
682 if (dowait(WBLOCK|WNOFREE, job) == -1)
683 return 128 + lastsig();
684 }
685 status = job->ps[job->nprocs ? job->nprocs - 1 : 0].status;
686 if (WIFEXITED(status))
687 retval = WEXITSTATUS(status);
688 #if JOBS
689 else if (WIFSTOPPED(status))
690 retval = WSTOPSIG(status) + 128;
691 #endif
692 else {
693 /* XXX: limits number of signals */
694 retval = WTERMSIG(status) + 128;
695 }
696 if (!iflag)
697 freejob(job);
698 }
699 return retval;
700 }
701
702
703
704 int
jobidcmd(int argc,char ** argv)705 jobidcmd(int argc, char **argv)
706 {
707 struct job *jp;
708 int i;
709
710 nextopt("");
711 jp = getjob(*argptr, 0);
712 for (i = 0 ; i < jp->nprocs ; ) {
713 out1fmt("%ld", (long)jp->ps[i].pid);
714 out1c(++i < jp->nprocs ? ' ' : '\n');
715 }
716 return 0;
717 }
718
719 int
getjobpgrp(const char * name)720 getjobpgrp(const char *name)
721 {
722 struct job *jp;
723
724 jp = getjob(name, 1);
725 if (jp == 0)
726 return 0;
727 return -jp->ps[0].pid;
728 }
729
730 /*
731 * Convert a job name to a job structure.
732 */
733
734 STATIC struct job *
getjob(const char * name,int noerror)735 getjob(const char *name, int noerror)
736 {
737 int jobno = -1;
738 struct job *jp;
739 int pid;
740 int i;
741 const char *err_msg = "No such job: %s";
742
743 if (name == NULL) {
744 #if JOBS
745 jobno = curjob;
746 #endif
747 err_msg = "No current job";
748 } else if (name[0] == '%') {
749 if (is_number(name + 1)) {
750 jobno = number(name + 1) - 1;
751 } else if (!name[2]) {
752 switch (name[1]) {
753 #if JOBS
754 case 0:
755 case '+':
756 case '%':
757 jobno = curjob;
758 err_msg = "No current job";
759 break;
760 case '-':
761 jobno = curjob;
762 if (jobno != -1)
763 jobno = jobtab[jobno].prev_job;
764 err_msg = "No previous job";
765 break;
766 #endif
767 default:
768 goto check_pattern;
769 }
770 } else {
771 struct job *found;
772 check_pattern:
773 found = NULL;
774 for (jp = jobtab, i = njobs ; --i >= 0 ; jp++) {
775 if (!jp->used || jp->nprocs <= 0)
776 continue;
777 if ((name[1] == '?'
778 && strstr(jp->ps[0].cmd, name + 2))
779 || prefix(name + 1, jp->ps[0].cmd)) {
780 if (found) {
781 err_msg = "%s: ambiguous";
782 found = 0;
783 break;
784 }
785 found = jp;
786 }
787 }
788 if (found)
789 return found;
790 }
791
792 } else if (is_number(name)) {
793 pid = number(name);
794 for (jp = jobtab, i = njobs ; --i >= 0 ; jp++) {
795 if (jp->used && jp->nprocs > 0
796 && jp->ps[jp->nprocs - 1].pid == pid)
797 return jp;
798 }
799 }
800
801 if (!jobs_invalid && jobno >= 0 && jobno < njobs) {
802 jp = jobtab + jobno;
803 if (jp->used)
804 return jp;
805 }
806 if (!noerror)
807 error(err_msg, name);
808 return 0;
809 }
810
811
812
813 /*
814 * Return a new job structure,
815 */
816
817 struct job *
makejob(union node * node,int nprocs)818 makejob(union node *node, int nprocs)
819 {
820 int i;
821 struct job *jp;
822
823 if (jobs_invalid) {
824 for (i = njobs, jp = jobtab ; --i >= 0 ; jp++) {
825 if (jp->used)
826 freejob(jp);
827 }
828 jobs_invalid = 0;
829 }
830
831 for (i = njobs, jp = jobtab ; ; jp++) {
832 if (--i < 0) {
833 INTOFF;
834 if (njobs == 0) {
835 jobtab = ckmalloc(4 * sizeof jobtab[0]);
836 } else {
837 jp = ckmalloc((njobs + 4) * sizeof jobtab[0]);
838 memcpy(jp, jobtab, njobs * sizeof jp[0]);
839 /* Relocate `ps' pointers */
840 for (i = 0; i < njobs; i++)
841 if (jp[i].ps == &jobtab[i].ps0)
842 jp[i].ps = &jp[i].ps0;
843 ckfree(jobtab);
844 jobtab = jp;
845 }
846 jp = jobtab + njobs;
847 for (i = 4 ; --i >= 0 ; )
848 jobtab[njobs++].used = 0;
849 INTON;
850 break;
851 }
852 if (jp->used == 0)
853 break;
854 }
855 INTOFF;
856 jp->state = JOBRUNNING;
857 jp->used = 1;
858 jp->changed = 0;
859 jp->nprocs = 0;
860 #if JOBS
861 jp->jobctl = jobctl;
862 set_curjob(jp, 1);
863 #endif
864 if (nprocs > 1) {
865 jp->ps = ckmalloc(nprocs * sizeof (struct procstat));
866 } else {
867 jp->ps = &jp->ps0;
868 }
869 INTON;
870 TRACE(("makejob(0x%lx, %d) returns %%%d\n", (long)node, nprocs,
871 jp - jobtab + 1));
872 return jp;
873 }
874
875
876 /*
877 * Fork off a subshell. If we are doing job control, give the subshell its
878 * own process group. Jp is a job structure that the job is to be added to.
879 * N is the command that will be evaluated by the child. Both jp and n may
880 * be NULL. The mode parameter can be one of the following:
881 * FORK_FG - Fork off a foreground process.
882 * FORK_BG - Fork off a background process.
883 * FORK_NOJOB - Like FORK_FG, but don't give the process its own
884 * process group even if job control is on.
885 *
886 * When job control is turned off, background processes have their standard
887 * input redirected to /dev/null (except for the second and later processes
888 * in a pipeline).
889 */
890
891 int
forkshell(struct job * jp,union node * n,int mode)892 forkshell(struct job *jp, union node *n, int mode)
893 {
894 pid_t pid;
895 int serrno;
896
897 TRACE(("forkshell(%%%d, %p, %d) called\n", jp - jobtab, n, mode));
898 switch ((pid = fork())) {
899 case -1:
900 serrno = errno;
901 TRACE(("Fork failed, errno=%d\n", serrno));
902 INTON;
903 error("Cannot fork (%s)", strerror(serrno));
904 break;
905 case 0:
906 forkchild(jp, n, mode, 0);
907 return 0;
908 default:
909 return forkparent(jp, n, mode, pid);
910 }
911 }
912
913 int
forkparent(struct job * jp,union node * n,int mode,pid_t pid)914 forkparent(struct job *jp, union node *n, int mode, pid_t pid)
915 {
916 int pgrp;
917
918 if (rootshell && mode != FORK_NOJOB && mflag) {
919 if (jp == NULL || jp->nprocs == 0)
920 pgrp = pid;
921 else
922 pgrp = jp->ps[0].pid;
923 /* This can fail because we are doing it in the child also */
924 (void)setpgid(pid, pgrp);
925 }
926 if (mode == FORK_BG)
927 backgndpid = pid; /* set $! */
928 if (jp) {
929 struct procstat *ps = &jp->ps[jp->nprocs++];
930 ps->pid = pid;
931 ps->status = -1;
932 ps->cmd[0] = 0;
933 if (/* iflag && rootshell && */ n)
934 commandtext(ps, n);
935 }
936 TRACE(("In parent shell: child = %d\n", pid));
937 return pid;
938 }
939
940 void
forkchild(struct job * jp,union node * n,int mode,int vforked)941 forkchild(struct job *jp, union node *n, int mode, int vforked)
942 {
943 int wasroot;
944 #if JOBS /* LSC: for proper compilation with JOBS == 0 */
945 int pgrp;
946 #endif
947 const char *devnull = _PATH_DEVNULL;
948 const char *nullerr = "Can't open %s";
949
950 wasroot = rootshell;
951 TRACE(("Child shell %d\n", getpid()));
952 if (!vforked)
953 rootshell = 0;
954
955 closescript(vforked);
956 clear_traps(vforked);
957 #if JOBS
958 if (!vforked)
959 jobctl = 0; /* do job control only in root shell */
960 if (wasroot && mode != FORK_NOJOB && mflag) {
961 if (jp == NULL || jp->nprocs == 0)
962 pgrp = getpid();
963 else
964 pgrp = jp->ps[0].pid;
965 /* This can fail because we are doing it in the parent also */
966 (void)setpgid(0, pgrp);
967 if (mode == FORK_FG) {
968 if (tcsetpgrp(ttyfd, pgrp) == -1)
969 error("Cannot set tty process group (%s) at %d",
970 strerror(errno), __LINE__);
971 }
972 setsignal(SIGTSTP, vforked);
973 setsignal(SIGTTOU, vforked);
974 } else if (mode == FORK_BG) {
975 ignoresig(SIGINT, vforked);
976 ignoresig(SIGQUIT, vforked);
977 if ((jp == NULL || jp->nprocs == 0) &&
978 ! fd0_redirected_p ()) {
979 close(0);
980 if (open(devnull, O_RDONLY) != 0)
981 error(nullerr, devnull);
982 }
983 }
984 #else
985 if (mode == FORK_BG) {
986 ignoresig(SIGINT, vforked);
987 ignoresig(SIGQUIT, vforked);
988 if ((jp == NULL || jp->nprocs == 0) &&
989 ! fd0_redirected_p ()) {
990 close(0);
991 if (open(devnull, O_RDONLY) != 0)
992 error(nullerr, devnull);
993 }
994 }
995 #endif
996 if (wasroot && iflag) {
997 setsignal(SIGINT, vforked);
998 setsignal(SIGQUIT, vforked);
999 setsignal(SIGTERM, vforked);
1000 }
1001
1002 if (!vforked)
1003 jobs_invalid = 1;
1004 }
1005
1006 /*
1007 * Wait for job to finish.
1008 *
1009 * Under job control we have the problem that while a child process is
1010 * running interrupts generated by the user are sent to the child but not
1011 * to the shell. This means that an infinite loop started by an inter-
1012 * active user may be hard to kill. With job control turned off, an
1013 * interactive user may place an interactive program inside a loop. If
1014 * the interactive program catches interrupts, the user doesn't want
1015 * these interrupts to also abort the loop. The approach we take here
1016 * is to have the shell ignore interrupt signals while waiting for a
1017 * forground process to terminate, and then send itself an interrupt
1018 * signal if the child process was terminated by an interrupt signal.
1019 * Unfortunately, some programs want to do a bit of cleanup and then
1020 * exit on interrupt; unless these processes terminate themselves by
1021 * sending a signal to themselves (instead of calling exit) they will
1022 * confuse this approach.
1023 */
1024
1025 int
waitforjob(struct job * jp)1026 waitforjob(struct job *jp)
1027 {
1028 #if JOBS
1029 int mypgrp = getpgrp();
1030 #endif
1031 int status;
1032 int st;
1033
1034 INTOFF;
1035 TRACE(("waitforjob(%%%d) called\n", jp - jobtab + 1));
1036 while (jp->state == JOBRUNNING) {
1037 dowait(WBLOCK, jp);
1038 }
1039 #if JOBS
1040 if (jp->jobctl) {
1041 if (tcsetpgrp(ttyfd, mypgrp) == -1)
1042 error("Cannot set tty process group (%s) at %d",
1043 strerror(errno), __LINE__);
1044 }
1045 if (jp->state == JOBSTOPPED && curjob != jp - jobtab)
1046 set_curjob(jp, 2);
1047 #endif
1048 status = jp->ps[jp->nprocs - 1].status;
1049 /* convert to 8 bits */
1050 if (WIFEXITED(status))
1051 st = WEXITSTATUS(status);
1052 #if JOBS
1053 else if (WIFSTOPPED(status))
1054 st = WSTOPSIG(status) + 128;
1055 #endif
1056 else
1057 st = WTERMSIG(status) + 128;
1058 TRACE(("waitforjob: job %d, nproc %d, status %x, st %x\n",
1059 jp - jobtab + 1, jp->nprocs, status, st ));
1060 #if JOBS
1061 if (jp->jobctl) {
1062 /*
1063 * This is truly gross.
1064 * If we're doing job control, then we did a TIOCSPGRP which
1065 * caused us (the shell) to no longer be in the controlling
1066 * session -- so we wouldn't have seen any ^C/SIGINT. So, we
1067 * intuit from the subprocess exit status whether a SIGINT
1068 * occurred, and if so interrupt ourselves. Yuck. - mycroft
1069 */
1070 if (WIFSIGNALED(status) && WTERMSIG(status) == SIGINT)
1071 raise(SIGINT);
1072 }
1073 #endif
1074 if (! JOBS || jp->state == JOBDONE)
1075 freejob(jp);
1076 INTON;
1077 return st;
1078 }
1079
1080
1081
1082 /*
1083 * Wait for a process to terminate.
1084 */
1085
1086 STATIC int
dowait(int flags,struct job * job)1087 dowait(int flags, struct job *job)
1088 {
1089 int pid;
1090 int status;
1091 struct procstat *sp;
1092 struct job *jp;
1093 struct job *thisjob;
1094 int done;
1095 int stopped;
1096
1097 TRACE(("dowait(%x) called\n", flags));
1098 do {
1099 pid = waitproc(flags & WBLOCK, job, &status);
1100 TRACE(("wait returns pid %d, status %d\n", pid, status));
1101 } while (pid == -1 && errno == EINTR && pendingsigs == 0);
1102 if (pid <= 0)
1103 return pid;
1104 INTOFF;
1105 thisjob = NULL;
1106 for (jp = jobtab ; jp < jobtab + njobs ; jp++) {
1107 if (jp->used) {
1108 done = 1;
1109 stopped = 1;
1110 for (sp = jp->ps ; sp < jp->ps + jp->nprocs ; sp++) {
1111 if (sp->pid == -1)
1112 continue;
1113 if (sp->pid == pid) {
1114 TRACE(("Job %d: changing status of proc %d from 0x%x to 0x%x\n", jp - jobtab + 1, pid, sp->status, status));
1115 sp->status = status;
1116 thisjob = jp;
1117 }
1118 if (sp->status == -1)
1119 stopped = 0;
1120 else if (WIFSTOPPED(sp->status))
1121 done = 0;
1122 }
1123 if (stopped) { /* stopped or done */
1124 int state = done ? JOBDONE : JOBSTOPPED;
1125 if (jp->state != state) {
1126 TRACE(("Job %d: changing state from %d to %d\n", jp - jobtab + 1, jp->state, state));
1127 jp->state = state;
1128 #if JOBS
1129 if (done)
1130 set_curjob(jp, 0);
1131 #endif
1132 }
1133 }
1134 }
1135 }
1136
1137 if (thisjob && thisjob->state != JOBRUNNING) {
1138 int mode = 0;
1139 if (!rootshell || !iflag)
1140 mode = SHOW_SIGNALLED;
1141 if ((job == thisjob && (flags & WNOFREE) == 0) ||
1142 (job != thisjob && (flags & WNOFREE) != 0))
1143 mode = SHOW_SIGNALLED | SHOW_NO_FREE;
1144 if (mode)
1145 showjob(out2, thisjob, mode);
1146 else {
1147 TRACE(("Not printing status, rootshell=%d, job=%p\n",
1148 rootshell, job));
1149 thisjob->changed = 1;
1150 }
1151 }
1152
1153 INTON;
1154 return pid;
1155 }
1156
1157
1158
1159 /*
1160 * Do a wait system call. If job control is compiled in, we accept
1161 * stopped processes. If block is zero, we return a value of zero
1162 * rather than blocking.
1163 *
1164 * System V doesn't have a non-blocking wait system call. It does
1165 * have a SIGCLD signal that is sent to a process when one of its
1166 * children dies. The obvious way to use SIGCLD would be to install
1167 * a handler for SIGCLD which simply bumped a counter when a SIGCLD
1168 * was received, and have waitproc bump another counter when it got
1169 * the status of a process. Waitproc would then know that a wait
1170 * system call would not block if the two counters were different.
1171 * This approach doesn't work because if a process has children that
1172 * have not been waited for, System V will send it a SIGCLD when it
1173 * installs a signal handler for SIGCLD. What this means is that when
1174 * a child exits, the shell will be sent SIGCLD signals continuously
1175 * until is runs out of stack space, unless it does a wait call before
1176 * restoring the signal handler. The code below takes advantage of
1177 * this (mis)feature by installing a signal handler for SIGCLD and
1178 * then checking to see whether it was called. If there are any
1179 * children to be waited for, it will be.
1180 *
1181 * If neither SYSV nor BSD is defined, we don't implement nonblocking
1182 * waits at all. In this case, the user will not be informed when
1183 * a background process until the next time she runs a real program
1184 * (as opposed to running a builtin command or just typing return),
1185 * and the jobs command may give out of date information.
1186 */
1187
1188 #ifdef SYSV
1189 STATIC int gotsigchild;
1190
onsigchild()1191 STATIC int onsigchild() {
1192 gotsigchild = 1;
1193 }
1194 #endif
1195
1196
1197 STATIC int
waitproc(int block,struct job * jp,int * status)1198 waitproc(int block, struct job *jp, int *status)
1199 {
1200 #ifdef BSD
1201 int flags = 0;
1202
1203 #if JOBS
1204 if (jp != NULL && jp->jobctl)
1205 flags |= WUNTRACED;
1206 #endif
1207 if (block == 0)
1208 flags |= WNOHANG;
1209 return waitpid(-1, status, flags);
1210 #else
1211 #ifdef SYSV
1212 int (*save)();
1213
1214 if (block == 0) {
1215 gotsigchild = 0;
1216 save = signal(SIGCLD, onsigchild);
1217 signal(SIGCLD, save);
1218 if (gotsigchild == 0)
1219 return 0;
1220 }
1221 return wait(status);
1222 #else
1223 if (block == 0)
1224 return 0;
1225 return wait(status);
1226 #endif
1227 #endif
1228 }
1229
1230 /*
1231 * return 1 if there are stopped jobs, otherwise 0
1232 */
1233 int job_warning = 0;
1234 int
stoppedjobs(void)1235 stoppedjobs(void)
1236 {
1237 int jobno;
1238 struct job *jp;
1239
1240 if (job_warning || jobs_invalid)
1241 return (0);
1242 for (jobno = 1, jp = jobtab; jobno <= njobs; jobno++, jp++) {
1243 if (jp->used == 0)
1244 continue;
1245 if (jp->state == JOBSTOPPED) {
1246 out2str("You have stopped jobs.\n");
1247 job_warning = 2;
1248 return (1);
1249 }
1250 }
1251
1252 return (0);
1253 }
1254
1255 /*
1256 * Return a string identifying a command (to be printed by the
1257 * jobs command).
1258 */
1259
1260 STATIC char *cmdnextc;
1261 STATIC int cmdnleft;
1262
1263 void
commandtext(struct procstat * ps,union node * n)1264 commandtext(struct procstat *ps, union node *n)
1265 {
1266 int len;
1267
1268 cmdnextc = ps->cmd;
1269 if (iflag || mflag || sizeof ps->cmd < 100)
1270 len = sizeof(ps->cmd);
1271 else
1272 len = sizeof(ps->cmd) / 10;
1273 cmdnleft = len;
1274 cmdtxt(n);
1275 if (cmdnleft <= 0) {
1276 char *p = ps->cmd + len - 4;
1277 p[0] = '.';
1278 p[1] = '.';
1279 p[2] = '.';
1280 p[3] = 0;
1281 } else
1282 *cmdnextc = '\0';
1283 TRACE(("commandtext: ps->cmd %x, end %x, left %d\n\t\"%s\"\n",
1284 ps->cmd, cmdnextc, cmdnleft, ps->cmd));
1285 }
1286
1287
1288 STATIC void
cmdtxt(union node * n)1289 cmdtxt(union node *n)
1290 {
1291 union node *np;
1292 struct nodelist *lp;
1293 const char *p;
1294 int i;
1295 char s[2];
1296
1297 if (n == NULL || cmdnleft <= 0)
1298 return;
1299 switch (n->type) {
1300 case NSEMI:
1301 cmdtxt(n->nbinary.ch1);
1302 cmdputs("; ");
1303 cmdtxt(n->nbinary.ch2);
1304 break;
1305 case NAND:
1306 cmdtxt(n->nbinary.ch1);
1307 cmdputs(" && ");
1308 cmdtxt(n->nbinary.ch2);
1309 break;
1310 case NOR:
1311 cmdtxt(n->nbinary.ch1);
1312 cmdputs(" || ");
1313 cmdtxt(n->nbinary.ch2);
1314 break;
1315 case NPIPE:
1316 for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
1317 cmdtxt(lp->n);
1318 if (lp->next)
1319 cmdputs(" | ");
1320 }
1321 break;
1322 case NSUBSHELL:
1323 cmdputs("(");
1324 cmdtxt(n->nredir.n);
1325 cmdputs(")");
1326 break;
1327 case NREDIR:
1328 case NBACKGND:
1329 cmdtxt(n->nredir.n);
1330 break;
1331 case NIF:
1332 cmdputs("if ");
1333 cmdtxt(n->nif.test);
1334 cmdputs("; then ");
1335 cmdtxt(n->nif.ifpart);
1336 if (n->nif.elsepart) {
1337 cmdputs("; else ");
1338 cmdtxt(n->nif.elsepart);
1339 }
1340 cmdputs("; fi");
1341 break;
1342 case NWHILE:
1343 cmdputs("while ");
1344 goto until;
1345 case NUNTIL:
1346 cmdputs("until ");
1347 until:
1348 cmdtxt(n->nbinary.ch1);
1349 cmdputs("; do ");
1350 cmdtxt(n->nbinary.ch2);
1351 cmdputs("; done");
1352 break;
1353 case NFOR:
1354 cmdputs("for ");
1355 cmdputs(n->nfor.var);
1356 cmdputs(" in ");
1357 cmdlist(n->nfor.args, 1);
1358 cmdputs("; do ");
1359 cmdtxt(n->nfor.body);
1360 cmdputs("; done");
1361 break;
1362 case NCASE:
1363 cmdputs("case ");
1364 cmdputs(n->ncase.expr->narg.text);
1365 cmdputs(" in ");
1366 for (np = n->ncase.cases; np; np = np->nclist.next) {
1367 cmdtxt(np->nclist.pattern);
1368 cmdputs(") ");
1369 cmdtxt(np->nclist.body);
1370 cmdputs(";; ");
1371 }
1372 cmdputs("esac");
1373 break;
1374 case NDEFUN:
1375 cmdputs(n->narg.text);
1376 cmdputs("() { ... }");
1377 break;
1378 case NCMD:
1379 cmdlist(n->ncmd.args, 1);
1380 cmdlist(n->ncmd.redirect, 0);
1381 break;
1382 case NARG:
1383 cmdputs(n->narg.text);
1384 break;
1385 case NTO:
1386 p = ">"; i = 1; goto redir;
1387 case NCLOBBER:
1388 p = ">|"; i = 1; goto redir;
1389 case NAPPEND:
1390 p = ">>"; i = 1; goto redir;
1391 case NTOFD:
1392 p = ">&"; i = 1; goto redir;
1393 case NFROM:
1394 p = "<"; i = 0; goto redir;
1395 case NFROMFD:
1396 p = "<&"; i = 0; goto redir;
1397 case NFROMTO:
1398 p = "<>"; i = 0; goto redir;
1399 redir:
1400 if (n->nfile.fd != i) {
1401 s[0] = n->nfile.fd + '0';
1402 s[1] = '\0';
1403 cmdputs(s);
1404 }
1405 cmdputs(p);
1406 if (n->type == NTOFD || n->type == NFROMFD) {
1407 s[0] = n->ndup.dupfd + '0';
1408 s[1] = '\0';
1409 cmdputs(s);
1410 } else {
1411 cmdtxt(n->nfile.fname);
1412 }
1413 break;
1414 case NHERE:
1415 case NXHERE:
1416 cmdputs("<<...");
1417 break;
1418 default:
1419 cmdputs("???");
1420 break;
1421 }
1422 }
1423
1424 STATIC void
cmdlist(union node * np,int sep)1425 cmdlist(union node *np, int sep)
1426 {
1427 for (; np; np = np->narg.next) {
1428 if (!sep)
1429 cmdputs(" ");
1430 cmdtxt(np);
1431 if (sep && np->narg.next)
1432 cmdputs(" ");
1433 }
1434 }
1435
1436
1437 STATIC void
cmdputs(const char * s)1438 cmdputs(const char *s)
1439 {
1440 const char *p, *str = 0;
1441 char c, cc[2] = " ";
1442 char *nextc;
1443 int nleft;
1444 int subtype = 0;
1445 int quoted = 0;
1446 static char vstype[16][4] = { "", "}", "-", "+", "?", "=",
1447 "#", "##", "%", "%%" };
1448
1449 p = s;
1450 nextc = cmdnextc;
1451 nleft = cmdnleft;
1452 while (nleft > 0 && (c = *p++) != 0) {
1453 switch (c) {
1454 case CTLESC:
1455 c = *p++;
1456 break;
1457 case CTLVAR:
1458 subtype = *p++;
1459 if ((subtype & VSTYPE) == VSLENGTH)
1460 str = "${#";
1461 else
1462 str = "${";
1463 if (!(subtype & VSQUOTE) != !(quoted & 1)) {
1464 quoted ^= 1;
1465 c = '"';
1466 } else
1467 c = *str++;
1468 break;
1469 case CTLENDVAR:
1470 if (quoted & 1) {
1471 c = '"';
1472 str = "}";
1473 } else
1474 c = '}';
1475 quoted >>= 1;
1476 subtype = 0;
1477 break;
1478 case CTLBACKQ:
1479 c = '$';
1480 str = "(...)";
1481 break;
1482 case CTLBACKQ+CTLQUOTE:
1483 c = '"';
1484 str = "$(...)\"";
1485 break;
1486 case CTLARI:
1487 c = '$';
1488 str = "((";
1489 break;
1490 case CTLENDARI:
1491 c = ')';
1492 str = ")";
1493 break;
1494 case CTLQUOTEMARK:
1495 quoted ^= 1;
1496 c = '"';
1497 break;
1498 case '=':
1499 if (subtype == 0)
1500 break;
1501 str = vstype[subtype & VSTYPE];
1502 if (subtype & VSNUL)
1503 c = ':';
1504 else
1505 c = *str++;
1506 if (c != '}')
1507 quoted <<= 1;
1508 break;
1509 case '\'':
1510 case '\\':
1511 case '"':
1512 case '$':
1513 /* These can only happen inside quotes */
1514 cc[0] = c;
1515 str = cc;
1516 c = '\\';
1517 break;
1518 default:
1519 break;
1520 }
1521 do {
1522 *nextc++ = c;
1523 } while (--nleft > 0 && str && (c = *str++));
1524 str = 0;
1525 }
1526 if ((quoted & 1) && nleft) {
1527 *nextc++ = '"';
1528 nleft--;
1529 }
1530 cmdnleft = nleft;
1531 cmdnextc = nextc;
1532 }
1533