Bash-4.3 distribution sources and documentation
[platform/upstream/bash.git] / jobs.c
1 /* jobs.c - functions that make children, remember them, and handle their termination. */
2
3 /* This file works with both POSIX and BSD systems.  It implements job
4    control. */
5
6 /* Copyright (C) 1989-2013 Free Software Foundation, Inc.
7
8    This file is part of GNU Bash, the Bourne Again SHell.
9
10    Bash is free software: you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation, either version 3 of the License, or
13    (at your option) any later version.
14
15    Bash is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19
20    You should have received a copy of the GNU General Public License
21    along with Bash.  If not, see <http://www.gnu.org/licenses/>.
22 */
23
24 #include "config.h"
25
26 #include "bashtypes.h"
27 #include "trap.h"
28 #include <stdio.h>
29 #include <signal.h>
30 #include <errno.h>
31
32 #if defined (HAVE_UNISTD_H)
33 #  include <unistd.h>
34 #endif
35
36 #include "posixtime.h"
37
38 #if defined (HAVE_SYS_RESOURCE_H) && defined (HAVE_WAIT3) && !defined (_POSIX_VERSION) && !defined (RLIMTYPE)
39 #  include <sys/resource.h>
40 #endif /* !_POSIX_VERSION && HAVE_SYS_RESOURCE_H && HAVE_WAIT3 && !RLIMTYPE */
41
42 #if defined (HAVE_SYS_FILE_H)
43 #  include <sys/file.h>
44 #endif
45
46 #include "filecntl.h"
47 #include <sys/ioctl.h>
48 #if defined (HAVE_SYS_PARAM_H)
49 #include <sys/param.h>
50 #endif
51
52 #if defined (BUFFERED_INPUT)
53 #  include "input.h"
54 #endif
55
56 /* Need to include this up here for *_TTY_DRIVER definitions. */
57 #include "shtty.h"
58
59 /* Define this if your output is getting swallowed.  It's a no-op on
60    machines with the termio or termios tty drivers. */
61 /* #define DRAIN_OUTPUT */
62
63 /* For the TIOCGPGRP and TIOCSPGRP ioctl parameters on HP-UX */
64 #if defined (hpux) && !defined (TERMIOS_TTY_DRIVER)
65 #  include <bsdtty.h>
66 #endif /* hpux && !TERMIOS_TTY_DRIVER */
67
68 #include "bashansi.h"
69 #include "bashintl.h"
70 #include "shell.h"
71 #include "jobs.h"
72 #include "execute_cmd.h"
73 #include "flags.h"
74
75 #include "builtins/builtext.h"
76 #include "builtins/common.h"
77
78 #if !defined (errno)
79 extern int errno;
80 #endif /* !errno */
81
82 #if !defined (HAVE_KILLPG)
83 extern int killpg __P((pid_t, int));
84 #endif
85
86 #if !DEFAULT_CHILD_MAX
87 #  define DEFAULT_CHILD_MAX 32
88 #endif
89
90 #if !MAX_CHILD_MAX
91 #  define MAX_CHILD_MAX 8192
92 #endif
93
94 #if !defined (DEBUG)
95 #define MAX_JOBS_IN_ARRAY 4096          /* production */
96 #else
97 #define MAX_JOBS_IN_ARRAY 128           /* testing */
98 #endif
99
100 /* Flag values for second argument to delete_job */
101 #define DEL_WARNSTOPPED         1       /* warn about deleting stopped jobs */
102 #define DEL_NOBGPID             2       /* don't add pgrp leader to bgpids */
103
104 /* Take care of system dependencies that must be handled when waiting for
105    children.  The arguments to the WAITPID macro match those to the Posix.1
106    waitpid() function. */
107
108 #if defined (ultrix) && defined (mips) && defined (_POSIX_VERSION)
109 #  define WAITPID(pid, statusp, options) \
110         wait3 ((union wait *)statusp, options, (struct rusage *)0)
111 #else
112 #  if defined (_POSIX_VERSION) || defined (HAVE_WAITPID)
113 #    define WAITPID(pid, statusp, options) \
114         waitpid ((pid_t)pid, statusp, options)
115 #  else
116 #    if defined (HAVE_WAIT3)
117 #      define WAITPID(pid, statusp, options) \
118         wait3 (statusp, options, (struct rusage *)0)
119 #    else
120 #      define WAITPID(pid, statusp, options) \
121         wait3 (statusp, options, (int *)0)
122 #    endif /* HAVE_WAIT3 */
123 #  endif /* !_POSIX_VERSION && !HAVE_WAITPID*/
124 #endif /* !(Ultrix && mips && _POSIX_VERSION) */
125
126 /* getpgrp () varies between systems.  Even systems that claim to be
127    Posix.1 compatible lie sometimes (Ultrix, SunOS4, apollo). */
128 #if defined (GETPGRP_VOID)
129 #  define getpgid(p) getpgrp ()
130 #else
131 #  define getpgid(p) getpgrp (p)
132 #endif /* !GETPGRP_VOID */
133
134 /* If the system needs it, REINSTALL_SIGCHLD_HANDLER will reinstall the
135    handler for SIGCHLD. */
136 #if defined (MUST_REINSTALL_SIGHANDLERS)
137 #  define REINSTALL_SIGCHLD_HANDLER signal (SIGCHLD, sigchld_handler)
138 #else
139 #  define REINSTALL_SIGCHLD_HANDLER
140 #endif /* !MUST_REINSTALL_SIGHANDLERS */
141
142 /* Some systems let waitpid(2) tell callers about stopped children. */
143 #if !defined (WCONTINUED) || defined (WCONTINUED_BROKEN)
144 #  undef WCONTINUED
145 #  define WCONTINUED 0
146 #endif
147 #if !defined (WIFCONTINUED)
148 #  define WIFCONTINUED(s)       (0)
149 #endif
150
151 /* The number of additional slots to allocate when we run out. */
152 #define JOB_SLOTS 8
153
154 typedef int sh_job_map_func_t __P((JOB *, int, int, int));
155
156 /* Variables used here but defined in other files. */
157 extern int subshell_environment, line_number;
158 extern int posixly_correct, shell_level;
159 extern int last_command_exit_value, last_command_exit_signal;
160 extern int loop_level, breaking;
161 extern int executing_list;
162 extern int sourcelevel;
163 extern int running_trap;
164 extern sh_builtin_func_t *this_shell_builtin;
165 extern char *shell_name, *this_command_name;
166 extern sigset_t top_level_mask;
167 extern procenv_t wait_intr_buf;
168 extern int wait_signal_received;
169 extern WORD_LIST *subst_assign_varlist;
170
171 static struct jobstats zerojs = { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB, NO_JOB, 0, 0 };
172 struct jobstats js = { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB, NO_JOB, 0, 0 };
173
174 struct bgpids bgpids = { 0, 0, 0 };
175
176 /* The array of known jobs. */
177 JOB **jobs = (JOB **)NULL;
178
179 #if 0
180 /* The number of slots currently allocated to JOBS. */
181 int job_slots = 0;
182 #endif
183
184 /* The controlling tty for this shell. */
185 int shell_tty = -1;
186
187 /* The shell's process group. */
188 pid_t shell_pgrp = NO_PID;
189
190 /* The terminal's process group. */
191 pid_t terminal_pgrp = NO_PID;
192
193 /* The process group of the shell's parent. */
194 pid_t original_pgrp = NO_PID;
195
196 /* The process group of the pipeline currently being made. */
197 pid_t pipeline_pgrp = (pid_t)0;
198
199 #if defined (PGRP_PIPE)
200 /* Pipes which each shell uses to communicate with the process group leader
201    until all of the processes in a pipeline have been started.  Then the
202    process leader is allowed to continue. */
203 int pgrp_pipe[2] = { -1, -1 };
204 #endif
205
206 #if 0
207 /* The job which is current; i.e. the one that `%+' stands for. */
208 int current_job = NO_JOB;
209
210 /* The previous job; i.e. the one that `%-' stands for. */
211 int previous_job = NO_JOB;
212 #endif
213
214 /* Last child made by the shell.  */
215 volatile pid_t last_made_pid = NO_PID;
216
217 /* Pid of the last asynchronous child. */
218 volatile pid_t last_asynchronous_pid = NO_PID;
219
220 /* The pipeline currently being built. */
221 PROCESS *the_pipeline = (PROCESS *)NULL;
222
223 /* If this is non-zero, do job control. */
224 int job_control = 1;
225
226 /* Call this when you start making children. */
227 int already_making_children = 0;
228
229 /* If this is non-zero, $LINES and $COLUMNS are reset after every process
230    exits from get_tty_state(). */
231 int check_window_size = CHECKWINSIZE_DEFAULT;
232
233 /* Functions local to this file. */
234
235 static sighandler wait_sigint_handler __P((int));
236 static sighandler sigchld_handler __P((int));
237 static sighandler sigcont_sighandler __P((int));
238 static sighandler sigstop_sighandler __P((int));
239
240 static int waitchld __P((pid_t, int));
241
242 static PROCESS *find_pipeline __P((pid_t, int, int *));
243 static PROCESS *find_process __P((pid_t, int, int *));
244
245 static char *current_working_directory __P((void));
246 static char *job_working_directory __P((void));
247 static char *j_strsignal __P((int));
248 static char *printable_job_status __P((int, PROCESS *, int));
249
250 static PROCESS *find_last_proc __P((int, int));
251 static pid_t find_last_pid __P((int, int));
252
253 static int set_new_line_discipline __P((int));
254 static int map_over_jobs __P((sh_job_map_func_t *, int, int));
255 static int job_last_stopped __P((int));
256 static int job_last_running __P((int));
257 static int most_recent_job_in_state __P((int, JOB_STATE));
258 static int find_job __P((pid_t, int, PROCESS **));
259 static int print_job __P((JOB *, int, int, int));
260 static int process_exit_status __P((WAIT));
261 static int process_exit_signal __P((WAIT));
262 static int set_job_status_and_cleanup __P((int));
263
264 static WAIT job_signal_status __P((int));
265 static WAIT raw_job_exit_status __P((int));
266
267 static void notify_of_job_status __P((void));
268 static void reset_job_indices __P((void));
269 static void cleanup_dead_jobs __P((void));
270 static int processes_in_job __P((int));
271 static void realloc_jobs_list __P((void));
272 static int compact_jobs_list __P((int));
273 static int discard_pipeline __P((PROCESS *));
274 static void add_process __P((char *, pid_t));
275 static void print_pipeline __P((PROCESS *, int, int, FILE *));
276 static void pretty_print_job __P((int, int, FILE *));
277 static void set_current_job __P((int));
278 static void reset_current __P((void));
279 static void set_job_running __P((int));
280 static void setjstatus __P((int));
281 static int maybe_give_terminal_to __P((pid_t, pid_t, int));
282 static void mark_all_jobs_as_dead __P((void));
283 static void mark_dead_jobs_as_notified __P((int));
284 static void restore_sigint_handler __P((void));
285 #if defined (PGRP_PIPE)
286 static void pipe_read __P((int *));
287 #endif
288
289 static struct pidstat *bgp_alloc __P((pid_t, int));
290 static struct pidstat *bgp_add __P((pid_t, int));
291 static int bgp_delete __P((pid_t));
292 static void bgp_clear __P((void));
293 static int bgp_search __P((pid_t));
294 static void bgp_prune __P((void));
295
296 #if defined (ARRAY_VARS)
297 static int *pstatuses;          /* list of pipeline statuses */
298 static int statsize;
299 #endif
300
301 /* Used to synchronize between wait_for and other functions and the SIGCHLD
302    signal handler. */
303 static int sigchld;
304 static int queue_sigchld;
305
306 #define QUEUE_SIGCHLD(os)       (os) = sigchld, queue_sigchld++
307
308 #define UNQUEUE_SIGCHLD(os) \
309         do { \
310           queue_sigchld--; \
311           if (queue_sigchld == 0 && os != sigchld) \
312             waitchld (-1, 0); \
313         } while (0)
314
315 static SigHandler *old_tstp, *old_ttou, *old_ttin;
316 static SigHandler *old_cont = (SigHandler *)SIG_DFL;
317
318 /* A place to temporarily save the current pipeline. */
319 static PROCESS *saved_pipeline;
320 static int saved_already_making_children;
321
322 /* Set this to non-zero whenever you don't want the jobs list to change at
323    all: no jobs deleted and no status change notifications.  This is used,
324    for example, when executing SIGCHLD traps, which may run arbitrary
325    commands. */
326 static int jobs_list_frozen;
327
328 static char retcode_name_buffer[64];
329
330 #if !defined (_POSIX_VERSION)
331
332 /* These are definitions to map POSIX 1003.1 functions onto existing BSD
333    library functions and system calls. */
334 #define setpgid(pid, pgrp)      setpgrp (pid, pgrp)
335 #define tcsetpgrp(fd, pgrp)     ioctl ((fd), TIOCSPGRP, &(pgrp))
336
337 pid_t
338 tcgetpgrp (fd)
339      int fd;
340 {
341   pid_t pgrp;
342
343   /* ioctl will handle setting errno correctly. */
344   if (ioctl (fd, TIOCGPGRP, &pgrp) < 0)
345     return (-1);
346   return (pgrp);
347 }
348
349 #endif /* !_POSIX_VERSION */
350
351 /* Initialize the global job stats structure and other bookkeeping variables */
352 void
353 init_job_stats ()
354 {
355   js = zerojs;
356 }
357
358 /* Return the working directory for the current process.  Unlike
359    job_working_directory, this does not call malloc (), nor do any
360    of the functions it calls.  This is so that it can safely be called
361    from a signal handler. */
362 static char *
363 current_working_directory ()
364 {
365   char *dir;
366   static char d[PATH_MAX];
367
368   dir = get_string_value ("PWD");
369
370   if (dir == 0 && the_current_working_directory && no_symbolic_links)
371     dir = the_current_working_directory;
372
373   if (dir == 0)
374     {
375       dir = getcwd (d, sizeof(d));
376       if (dir)
377         dir = d;
378     }
379
380   return (dir == 0) ? "<unknown>" : dir;
381 }
382
383 /* Return the working directory for the current process. */
384 static char *
385 job_working_directory ()
386 {
387   char *dir;
388
389   dir = get_string_value ("PWD");
390   if (dir)
391     return (savestring (dir));
392
393   dir = get_working_directory ("job-working-directory");
394   if (dir)
395     return (dir);
396
397   return (savestring ("<unknown>"));
398 }
399
400 void
401 making_children ()
402 {
403   if (already_making_children)
404     return;
405
406   already_making_children = 1;
407   start_pipeline ();
408 }
409
410 void
411 stop_making_children ()
412 {
413   already_making_children = 0;
414 }
415
416 void
417 cleanup_the_pipeline ()
418 {
419   PROCESS *disposer;
420   sigset_t set, oset;
421
422   BLOCK_CHILD (set, oset);
423   disposer = the_pipeline;
424   the_pipeline = (PROCESS *)NULL;
425   UNBLOCK_CHILD (oset);
426
427   if (disposer)
428     discard_pipeline (disposer);
429 }
430
431 void
432 save_pipeline (clear)
433      int clear;
434 {
435   saved_pipeline = the_pipeline;
436   if (clear)
437     the_pipeline = (PROCESS *)NULL;
438   saved_already_making_children = already_making_children;
439 }
440
441 void
442 restore_pipeline (discard)
443      int discard;
444 {
445   PROCESS *old_pipeline;
446
447   old_pipeline = the_pipeline;
448   the_pipeline = saved_pipeline;
449   already_making_children = saved_already_making_children;
450   if (discard && old_pipeline)
451     discard_pipeline (old_pipeline);
452 }
453
454 /* Start building a pipeline.  */
455 void
456 start_pipeline ()
457 {
458   if (the_pipeline)
459     {
460       cleanup_the_pipeline ();
461       pipeline_pgrp = 0;
462 #if defined (PGRP_PIPE)
463       sh_closepipe (pgrp_pipe);
464 #endif
465     }
466
467 #if defined (PGRP_PIPE)
468   if (job_control)
469     {
470       if (pipe (pgrp_pipe) == -1)
471         sys_error (_("start_pipeline: pgrp pipe"));
472     }
473 #endif
474 }
475
476 /* Stop building a pipeline.  Install the process list in the job array.
477    This returns the index of the newly installed job.
478    DEFERRED is a command structure to be executed upon satisfactory
479    execution exit of this pipeline. */
480 int
481 stop_pipeline (async, deferred)
482      int async;
483      COMMAND *deferred;
484 {
485   register int i, j;
486   JOB *newjob;
487   sigset_t set, oset;
488
489   BLOCK_CHILD (set, oset);
490
491 #if defined (PGRP_PIPE)
492   /* The parent closes the process group synchronization pipe. */
493   sh_closepipe (pgrp_pipe);
494 #endif
495
496   cleanup_dead_jobs ();
497
498   if (js.j_jobslots == 0)
499     {
500       js.j_jobslots = JOB_SLOTS;
501       jobs = (JOB **)xmalloc (js.j_jobslots * sizeof (JOB *));
502
503       /* Now blank out these new entries. */
504       for (i = 0; i < js.j_jobslots; i++)
505         jobs[i] = (JOB *)NULL;
506
507       js.j_firstj = js.j_lastj = js.j_njobs = 0;
508     }
509
510   /* Scan from the last slot backward, looking for the next free one. */
511   /* XXX - revisit this interactive assumption */
512   /* XXX - this way for now */
513   if (interactive)
514     {
515       for (i = js.j_jobslots; i; i--)
516         if (jobs[i - 1])
517           break;
518     }
519   else
520     {
521 #if 0
522       /* This wraps around, but makes it inconvenient to extend the array */
523       for (i = js.j_lastj+1; i != js.j_lastj; i++)
524         {
525           if (i >= js.j_jobslots)
526             i = 0;
527           if (jobs[i] == 0)
528             break;
529         }       
530       if (i == js.j_lastj)
531         i = js.j_jobslots;
532 #else
533       /* This doesn't wrap around yet. */
534       for (i = js.j_lastj ? js.j_lastj + 1 : js.j_lastj; i < js.j_jobslots; i++)
535         if (jobs[i] == 0)
536           break;
537 #endif
538     }
539
540   /* Do we need more room? */
541
542   /* First try compaction */
543   if ((interactive_shell == 0 || subshell_environment) && i == js.j_jobslots && js.j_jobslots >= MAX_JOBS_IN_ARRAY)
544     i = compact_jobs_list (0);
545
546   /* If we can't compact, reallocate */
547   if (i == js.j_jobslots)
548     {
549       js.j_jobslots += JOB_SLOTS;
550       jobs = (JOB **)xrealloc (jobs, (js.j_jobslots * sizeof (JOB *)));
551
552       for (j = i; j < js.j_jobslots; j++)
553         jobs[j] = (JOB *)NULL;
554     }
555
556   /* Add the current pipeline to the job list. */
557   if (the_pipeline)
558     {
559       register PROCESS *p;
560       int any_running, any_stopped, n;
561
562       newjob = (JOB *)xmalloc (sizeof (JOB));
563
564       for (n = 1, p = the_pipeline; p->next != the_pipeline; n++, p = p->next)
565         ;
566       p->next = (PROCESS *)NULL;
567       newjob->pipe = REVERSE_LIST (the_pipeline, PROCESS *);
568       for (p = newjob->pipe; p->next; p = p->next)
569         ;
570       p->next = newjob->pipe;
571
572       the_pipeline = (PROCESS *)NULL;
573       newjob->pgrp = pipeline_pgrp;
574       pipeline_pgrp = 0;
575
576       newjob->flags = 0;
577
578       /* Flag to see if in another pgrp. */
579       if (job_control)
580         newjob->flags |= J_JOBCONTROL;
581
582       /* Set the state of this pipeline. */
583       p = newjob->pipe;
584       any_running = any_stopped = 0;
585       do
586         {
587           any_running |= PRUNNING (p);
588           any_stopped |= PSTOPPED (p);
589           p = p->next;
590         }
591       while (p != newjob->pipe);
592
593       newjob->state = any_running ? JRUNNING : (any_stopped ? JSTOPPED : JDEAD);
594       newjob->wd = job_working_directory ();
595       newjob->deferred = deferred;
596
597       newjob->j_cleanup = (sh_vptrfunc_t *)NULL;
598       newjob->cleanarg = (PTR_T) NULL;
599
600       jobs[i] = newjob;
601       if (newjob->state == JDEAD && (newjob->flags & J_FOREGROUND))
602         setjstatus (i);
603       if (newjob->state == JDEAD)
604         {
605           js.c_reaped += n;     /* wouldn't have been done since this was not part of a job */
606           js.j_ndead++;
607         }
608       js.c_injobs += n;
609
610       js.j_lastj = i;
611       js.j_njobs++;
612     }
613   else
614     newjob = (JOB *)NULL;
615
616   if (newjob)
617     js.j_lastmade = newjob;
618
619   if (async)
620     {
621       if (newjob)
622         {
623           newjob->flags &= ~J_FOREGROUND;
624           newjob->flags |= J_ASYNC;
625           js.j_lastasync = newjob;
626         }
627       reset_current ();
628     }
629   else
630     {
631       if (newjob)
632         {
633           newjob->flags |= J_FOREGROUND;
634           /*
635            *            !!!!! NOTE !!!!!  (chet@ins.cwru.edu)
636            *
637            * The currently-accepted job control wisdom says to set the
638            * terminal's process group n+1 times in an n-step pipeline:
639            * once in the parent and once in each child.  This is where
640            * the parent gives it away.
641            *
642            * Don't give the terminal away if this shell is an asynchronous
643            * subshell.
644            *
645            */
646           if (job_control && newjob->pgrp && (subshell_environment&SUBSHELL_ASYNC) == 0)
647             maybe_give_terminal_to (shell_pgrp, newjob->pgrp, 0);
648         }
649     }
650
651   stop_making_children ();
652   UNBLOCK_CHILD (oset);
653   return (newjob ? i : js.j_current);
654 }
655
656 /* Functions to manage the list of exited background pids whose status has
657    been saved. */
658
659 static struct pidstat *
660 bgp_alloc (pid, status)
661      pid_t pid;
662      int status;
663 {
664   struct pidstat *ps;
665
666   ps = (struct pidstat *)xmalloc (sizeof (struct pidstat));
667   ps->pid = pid;
668   ps->status = status;
669   ps->next = (struct pidstat *)0;
670   return ps;
671 }
672
673 static struct pidstat *
674 bgp_add (pid, status)
675      pid_t pid;
676      int status;
677 {
678   struct pidstat *ps;
679
680   ps = bgp_alloc (pid, status);
681
682   if (bgpids.list == 0)
683     {
684       bgpids.list = bgpids.end = ps;
685       bgpids.npid = 0;                  /* just to make sure */
686     }
687   else
688     {
689       bgpids.end->next = ps;
690       bgpids.end = ps;
691     }
692   bgpids.npid++;
693
694   if (bgpids.npid > js.c_childmax)
695     bgp_prune ();
696
697   return ps;
698 }
699
700 static int
701 bgp_delete (pid)
702      pid_t pid;
703 {
704   struct pidstat *prev, *p;
705
706   for (prev = p = bgpids.list; p; prev = p, p = p->next)
707     if (p->pid == pid)
708       {
709         prev->next = p->next;   /* remove from list */
710         break;
711       }
712
713   if (p == 0)
714     return 0;           /* not found */
715
716 #if defined (DEBUG)
717   itrace("bgp_delete: deleting %d", pid);
718 #endif
719
720   /* Housekeeping in the border cases. */
721   if (p == bgpids.list)
722     bgpids.list = bgpids.list->next;
723   else if (p == bgpids.end)
724     bgpids.end = prev;
725
726   bgpids.npid--;
727   if (bgpids.npid == 0)
728     bgpids.list = bgpids.end = 0;
729   else if (bgpids.npid == 1)
730     bgpids.end = bgpids.list;           /* just to make sure */
731
732   free (p);
733   return 1;
734 }
735
736 /* Clear out the list of saved statuses */
737 static void
738 bgp_clear ()
739 {
740   struct pidstat *ps, *p;
741
742   for (ps = bgpids.list; ps; )
743     {
744       p = ps;
745       ps = ps->next;
746       free (p);
747     }
748   bgpids.list = bgpids.end = 0;
749   bgpids.npid = 0;
750 }
751
752 /* Search for PID in the list of saved background pids; return its status if
753    found.  If not found, return -1. */
754 static int
755 bgp_search (pid)
756      pid_t pid;
757 {
758   struct pidstat *ps;
759
760   for (ps = bgpids.list ; ps; ps = ps->next)
761     if (ps->pid == pid)
762       return ps->status;
763   return -1;
764 }
765
766 static void
767 bgp_prune ()
768 {
769   struct pidstat *ps;
770
771   while (bgpids.npid > js.c_childmax)
772     {
773       ps = bgpids.list;
774       bgpids.list = bgpids.list->next;
775       free (ps);
776       bgpids.npid--;
777     }
778 }
779
780 /* Reset the values of js.j_lastj and js.j_firstj after one or both have
781    been deleted.  The caller should check whether js.j_njobs is 0 before
782    calling this.  This wraps around, but the rest of the code does not.  At
783    this point, it should not matter. */
784 static void
785 reset_job_indices ()
786 {
787   int old;
788
789   if (jobs[js.j_firstj] == 0)
790     {
791       old = js.j_firstj++;
792       if (old >= js.j_jobslots)
793         old = js.j_jobslots - 1;
794       while (js.j_firstj != old)
795         {
796           if (js.j_firstj >= js.j_jobslots)
797             js.j_firstj = 0;
798           if (jobs[js.j_firstj] || js.j_firstj == old)  /* needed if old == 0 */
799             break;
800           js.j_firstj++;
801         }
802       if (js.j_firstj == old)
803         js.j_firstj = js.j_lastj = js.j_njobs = 0;
804     }
805   if (jobs[js.j_lastj] == 0)
806     {
807       old = js.j_lastj--;
808       if (old < 0)
809         old = 0;
810       while (js.j_lastj != old)
811         {
812           if (js.j_lastj < 0)
813             js.j_lastj = js.j_jobslots - 1;
814           if (jobs[js.j_lastj] || js.j_lastj == old)    /* needed if old == js.j_jobslots */
815             break;
816           js.j_lastj--;
817         }
818       if (js.j_lastj == old)
819         js.j_firstj = js.j_lastj = js.j_njobs = 0;
820     }
821 }
822       
823 /* Delete all DEAD jobs that the user had received notification about. */
824 static void
825 cleanup_dead_jobs ()
826 {
827   register int i;
828   int os;
829
830   if (js.j_jobslots == 0 || jobs_list_frozen)
831     return;
832
833   QUEUE_SIGCHLD(os);
834
835   /* XXX could use js.j_firstj and js.j_lastj here */
836   for (i = 0; i < js.j_jobslots; i++)
837     {
838 #if defined (DEBUG)
839       if (i < js.j_firstj && jobs[i])
840         itrace("cleanup_dead_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
841       if (i > js.j_lastj && jobs[i])
842         itrace("cleanup_dead_jobs: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
843 #endif
844
845       if (jobs[i] && DEADJOB (i) && IS_NOTIFIED (i))
846         delete_job (i, 0);
847     }
848
849 #if defined (COPROCESS_SUPPORT)
850   coproc_reap ();
851 #endif
852
853   UNQUEUE_SIGCHLD(os);
854 }
855
856 static int
857 processes_in_job (job)
858      int job;
859 {
860   int nproc;
861   register PROCESS *p;
862
863   nproc = 0;
864   p = jobs[job]->pipe;
865   do
866     {
867       p = p->next;
868       nproc++;
869     }
870   while (p != jobs[job]->pipe);
871
872   return nproc;
873 }
874
875 static void
876 delete_old_job (pid)
877      pid_t pid;
878 {
879   PROCESS *p;
880   int job;
881
882   job = find_job (pid, 0, &p);
883   if (job != NO_JOB)
884     {
885 #ifdef DEBUG
886       itrace ("delete_old_job: found pid %d in job %d with state %d", pid, job, jobs[job]->state);
887 #endif
888       if (JOBSTATE (job) == JDEAD)
889         delete_job (job, DEL_NOBGPID);
890       else
891         {
892 #ifdef DEBUG
893           internal_warning (_("forked pid %d appears in running job %d"), pid, job+1);
894 #endif
895           if (p)
896             p->pid = 0;
897         }
898     }
899 }
900
901 /* Reallocate and compress the jobs list.  This returns with a jobs array
902    whose size is a multiple of JOB_SLOTS and can hold the current number of
903    jobs.  Heuristics are used to minimize the number of new reallocs. */
904 static void
905 realloc_jobs_list ()
906 {
907   sigset_t set, oset;
908   int nsize, i, j, ncur, nprev;
909   JOB **nlist;
910
911   ncur = nprev = NO_JOB;
912   nsize = ((js.j_njobs + JOB_SLOTS - 1) / JOB_SLOTS);
913   nsize *= JOB_SLOTS;
914   i = js.j_njobs % JOB_SLOTS;
915   if (i == 0 || i > (JOB_SLOTS >> 1))
916     nsize += JOB_SLOTS;
917
918   BLOCK_CHILD (set, oset);
919   nlist = (js.j_jobslots == nsize) ? jobs : (JOB **) xmalloc (nsize * sizeof (JOB *));
920
921   js.c_reaped = js.j_ndead = 0;
922   for (i = j = 0; i < js.j_jobslots; i++)
923     if (jobs[i])
924       {
925         if (i == js.j_current)
926           ncur = j;
927         if (i == js.j_previous)
928           nprev = j;
929         nlist[j++] = jobs[i];
930         if (jobs[i]->state == JDEAD)
931           {
932             js.j_ndead++;
933             js.c_reaped += processes_in_job (i);
934           }
935       }
936
937 #if 0
938   itrace ("realloc_jobs_list: resize jobs list from %d to %d", js.j_jobslots, nsize);
939   itrace ("realloc_jobs_list: j_lastj changed from %d to %d", js.j_lastj, (j > 0) ? j - 1 : 0);
940   itrace ("realloc_jobs_list: j_njobs changed from %d to %d", js.j_njobs, j);
941   itrace ("realloc_jobs_list: js.j_ndead %d js.c_reaped %d", js.j_ndead, js.c_reaped);
942 #endif
943
944   js.j_firstj = 0;
945   js.j_lastj = (j > 0) ? j - 1 : 0;
946   js.j_njobs = j;
947   js.j_jobslots = nsize;
948
949   /* Zero out remaining slots in new jobs list */
950   for ( ; j < nsize; j++)
951     nlist[j] = (JOB *)NULL;
952
953   if (jobs != nlist)
954     {
955       free (jobs);
956       jobs = nlist;
957     }
958
959   if (ncur != NO_JOB)
960     js.j_current = ncur;
961   if (nprev != NO_JOB)
962     js.j_previous = nprev;
963
964   /* Need to reset these */
965   if (js.j_current == NO_JOB || js.j_previous == NO_JOB || js.j_current > js.j_lastj || js.j_previous > js.j_lastj)
966     reset_current ();
967
968 #if 0
969   itrace ("realloc_jobs_list: reset js.j_current (%d) and js.j_previous (%d)", js.j_current, js.j_previous);
970 #endif
971
972   UNBLOCK_CHILD (oset);
973 }
974
975 /* Compact the jobs list by removing dead jobs.  Assume that we have filled
976    the jobs array to some predefined maximum.  Called when the shell is not
977    the foreground process (subshell_environment != 0).  Returns the first
978    available slot in the compacted list.  If that value is js.j_jobslots, then
979    the list needs to be reallocated.  The jobs array may be in new memory if
980    this returns > 0 and < js.j_jobslots.  FLAGS is reserved for future use. */
981 static int
982 compact_jobs_list (flags)
983      int flags;
984 {
985   if (js.j_jobslots == 0 || jobs_list_frozen)
986     return js.j_jobslots;
987
988   reap_dead_jobs ();
989   realloc_jobs_list ();
990
991 #if 0
992   itrace("compact_jobs_list: returning %d", (js.j_lastj || jobs[js.j_lastj]) ? js.j_lastj + 1 : 0);
993 #endif
994
995   return ((js.j_lastj || jobs[js.j_lastj]) ? js.j_lastj + 1 : 0);
996 }
997
998 /* Delete the job at INDEX from the job list.  Must be called
999    with SIGCHLD blocked. */
1000 void
1001 delete_job (job_index, dflags)
1002      int job_index, dflags;
1003 {
1004   register JOB *temp;
1005   PROCESS *proc;
1006   int ndel;
1007
1008   if (js.j_jobslots == 0 || jobs_list_frozen)
1009     return;
1010
1011   if ((dflags & DEL_WARNSTOPPED) && subshell_environment == 0 && STOPPED (job_index))
1012     internal_warning (_("deleting stopped job %d with process group %ld"), job_index+1, (long)jobs[job_index]->pgrp);
1013   temp = jobs[job_index];
1014   if (temp == 0)
1015     return;
1016
1017   if ((dflags & DEL_NOBGPID) == 0)
1018     {
1019       proc = find_last_proc (job_index, 0);
1020       /* Could do this just for J_ASYNC jobs, but we save all. */
1021       if (proc)
1022         bgp_add (proc->pid, process_exit_status (proc->status));
1023     }
1024
1025   jobs[job_index] = (JOB *)NULL;
1026   if (temp == js.j_lastmade)
1027     js.j_lastmade = 0;
1028   else if (temp == js.j_lastasync)
1029     js.j_lastasync = 0;
1030
1031   free (temp->wd);
1032   ndel = discard_pipeline (temp->pipe);
1033
1034   js.c_injobs -= ndel;
1035   if (temp->state == JDEAD)
1036     {
1037       js.c_reaped -= ndel;
1038       js.j_ndead--;
1039       if (js.c_reaped < 0)
1040         {
1041 #ifdef DEBUG
1042           itrace("delete_job (%d pgrp %d): js.c_reaped (%d) < 0 ndel = %d js.j_ndead = %d", job_index, temp->pgrp, js.c_reaped, ndel, js.j_ndead);
1043 #endif
1044           js.c_reaped = 0;
1045         }
1046     }
1047
1048   if (temp->deferred)
1049     dispose_command (temp->deferred);
1050
1051   free (temp);
1052
1053   js.j_njobs--;
1054   if (js.j_njobs == 0)
1055     js.j_firstj = js.j_lastj = 0;
1056   else if (jobs[js.j_firstj] == 0 || jobs[js.j_lastj] == 0)
1057     reset_job_indices ();
1058
1059   if (job_index == js.j_current || job_index == js.j_previous)
1060     reset_current ();
1061 }
1062
1063 /* Must be called with SIGCHLD blocked. */
1064 void
1065 nohup_job (job_index)
1066      int job_index;
1067 {
1068   register JOB *temp;
1069
1070   if (js.j_jobslots == 0)
1071     return;
1072
1073   if (temp = jobs[job_index])
1074     temp->flags |= J_NOHUP;
1075 }
1076
1077 /* Get rid of the data structure associated with a process chain. */
1078 static int
1079 discard_pipeline (chain)
1080      register PROCESS *chain;
1081 {
1082   register PROCESS *this, *next;
1083   int n;
1084
1085   this = chain;
1086   n = 0;
1087   do
1088     {
1089       next = this->next;
1090       FREE (this->command);
1091       free (this);
1092       n++;
1093       this = next;
1094     }
1095   while (this != chain);
1096
1097   return n;
1098 }
1099
1100 /* Add this process to the chain being built in the_pipeline.
1101    NAME is the command string that will be exec'ed later.
1102    PID is the process id of the child. */
1103 static void
1104 add_process (name, pid)
1105      char *name;
1106      pid_t pid;
1107 {
1108   PROCESS *t, *p;
1109
1110 #if defined (RECYCLES_PIDS)
1111   int j;
1112   p = find_process (pid, 0, &j);
1113   if (p)
1114     {
1115 #  ifdef DEBUG
1116       if (j == NO_JOB)
1117         internal_warning (_("add_process: process %5ld (%s) in the_pipeline"), (long)p->pid, p->command);
1118 #  endif
1119       if (PALIVE (p))
1120         internal_warning (_("add_process: pid %5ld (%s) marked as still alive"), (long)p->pid, p->command);
1121       p->running = PS_RECYCLED;         /* mark as recycled */
1122     }
1123 #endif
1124
1125   t = (PROCESS *)xmalloc (sizeof (PROCESS));
1126   t->next = the_pipeline;
1127   t->pid = pid;
1128   WSTATUS (t->status) = 0;
1129   t->running = PS_RUNNING;
1130   t->command = name;
1131   the_pipeline = t;
1132
1133   if (t->next == 0)
1134     t->next = t;
1135   else
1136     {
1137       p = t->next;
1138       while (p->next != t->next)
1139         p = p->next;
1140       p->next = t;
1141     }
1142 }
1143
1144 /* Create a (dummy) PROCESS with NAME, PID, and STATUS, and make it the last
1145    process in jobs[JID]->pipe.  Used by the lastpipe code. */
1146 void
1147 append_process (name, pid, status, jid)
1148      char *name;
1149      pid_t pid;
1150      int status;
1151      int jid;
1152 {
1153   PROCESS *t, *p;
1154
1155   t = (PROCESS *)xmalloc (sizeof (PROCESS));
1156   t->next = (PROCESS *)NULL;
1157   t->pid = pid;
1158   /* set process exit status using offset discovered by configure */
1159   t->status = (status & 0xff) << WEXITSTATUS_OFFSET;
1160   t->running = PS_DONE;
1161   t->command = name;
1162
1163   js.c_reaped++;        /* XXX */
1164
1165   for (p = jobs[jid]->pipe; p->next != jobs[jid]->pipe; p = p->next)
1166     ;
1167   p->next = t;
1168   t->next = jobs[jid]->pipe;
1169 }
1170
1171 #if 0
1172 /* Take the last job and make it the first job.  Must be called with
1173    SIGCHLD blocked. */
1174 int
1175 rotate_the_pipeline ()
1176 {
1177   PROCESS *p;
1178
1179   if (the_pipeline->next == the_pipeline)
1180     return;
1181   for (p = the_pipeline; p->next != the_pipeline; p = p->next)
1182     ;
1183   the_pipeline = p;
1184 }
1185
1186 /* Reverse the order of the processes in the_pipeline.  Must be called with
1187    SIGCHLD blocked. */
1188 int
1189 reverse_the_pipeline ()
1190 {
1191   PROCESS *p, *n;
1192
1193   if (the_pipeline->next == the_pipeline)
1194     return;
1195
1196   for (p = the_pipeline; p->next != the_pipeline; p = p->next)
1197     ;
1198   p->next = (PROCESS *)NULL;
1199
1200   n = REVERSE_LIST (the_pipeline, PROCESS *);
1201
1202   the_pipeline = n;
1203   for (p = the_pipeline; p->next; p = p->next)
1204     ;
1205   p->next = the_pipeline;
1206 }
1207 #endif
1208
1209 /* Map FUNC over the list of jobs.  If FUNC returns non-zero,
1210    then it is time to stop mapping, and that is the return value
1211    for map_over_jobs.  FUNC is called with a JOB, arg1, arg2,
1212    and INDEX. */
1213 static int
1214 map_over_jobs (func, arg1, arg2)
1215      sh_job_map_func_t *func;
1216      int arg1, arg2;
1217 {
1218   register int i;
1219   int result;
1220   sigset_t set, oset;
1221
1222   if (js.j_jobslots == 0)
1223     return 0;
1224
1225   BLOCK_CHILD (set, oset);
1226
1227   /* XXX could use js.j_firstj here */
1228   for (i = result = 0; i < js.j_jobslots; i++)
1229     {
1230 #if defined (DEBUG)
1231       if (i < js.j_firstj && jobs[i])
1232         itrace("map_over_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
1233       if (i > js.j_lastj && jobs[i])
1234         itrace("map_over_jobs: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
1235 #endif
1236       if (jobs[i])
1237         {
1238           result = (*func)(jobs[i], arg1, arg2, i);
1239           if (result)
1240             break;
1241         }
1242     }
1243
1244   UNBLOCK_CHILD (oset);
1245
1246   return (result);
1247 }
1248
1249 /* Cause all the jobs in the current pipeline to exit. */
1250 void
1251 terminate_current_pipeline ()
1252 {
1253   if (pipeline_pgrp && pipeline_pgrp != shell_pgrp)
1254     {
1255       killpg (pipeline_pgrp, SIGTERM);
1256       killpg (pipeline_pgrp, SIGCONT);
1257     }
1258 }
1259
1260 /* Cause all stopped jobs to exit. */
1261 void
1262 terminate_stopped_jobs ()
1263 {
1264   register int i;
1265
1266   /* XXX could use js.j_firstj here */
1267   for (i = 0; i < js.j_jobslots; i++)
1268     {
1269       if (jobs[i] && STOPPED (i))
1270         {
1271           killpg (jobs[i]->pgrp, SIGTERM);
1272           killpg (jobs[i]->pgrp, SIGCONT);
1273         }
1274     }
1275 }
1276
1277 /* Cause all jobs, running or stopped, to receive a hangup signal.  If
1278    a job is marked J_NOHUP, don't send the SIGHUP. */
1279 void
1280 hangup_all_jobs ()
1281 {
1282   register int i;
1283
1284   /* XXX could use js.j_firstj here */
1285   for (i = 0; i < js.j_jobslots; i++)
1286     {
1287       if (jobs[i])
1288         {
1289           if  (jobs[i]->flags & J_NOHUP)
1290             continue;
1291           killpg (jobs[i]->pgrp, SIGHUP);
1292           if (STOPPED (i))
1293             killpg (jobs[i]->pgrp, SIGCONT);
1294         }
1295     }
1296 }
1297
1298 void
1299 kill_current_pipeline ()
1300 {
1301   stop_making_children ();
1302   start_pipeline ();
1303 }
1304
1305 /* Return the pipeline that PID belongs to.  Note that the pipeline
1306    doesn't have to belong to a job.  Must be called with SIGCHLD blocked.
1307    If JOBP is non-null, return the index of the job containing PID.  */
1308 static PROCESS *
1309 find_pipeline (pid, alive_only, jobp)
1310      pid_t pid;
1311      int alive_only;
1312      int *jobp;         /* index into jobs list or NO_JOB */
1313 {
1314   int job;
1315   PROCESS *p;
1316
1317   /* See if this process is in the pipeline that we are building. */
1318   if (jobp)
1319     *jobp = NO_JOB;
1320   if (the_pipeline)
1321     {
1322       p = the_pipeline;
1323       do
1324         {
1325           /* Return it if we found it.  Don't ever return a recycled pid. */
1326           if (p->pid == pid && ((alive_only == 0 && PRECYCLED(p) == 0) || PALIVE(p)))
1327             return (p);
1328
1329           p = p->next;
1330         }
1331       while (p != the_pipeline);
1332     }
1333
1334   job = find_job (pid, alive_only, &p);
1335   if (jobp)
1336     *jobp = job;
1337   return (job == NO_JOB) ? (PROCESS *)NULL : jobs[job]->pipe;
1338 }
1339
1340 /* Return the PROCESS * describing PID.  If JOBP is non-null return the index
1341    into the jobs array of the job containing PID.  Must be called with
1342    SIGCHLD blocked. */
1343 static PROCESS *
1344 find_process (pid, alive_only, jobp)
1345      pid_t pid;
1346      int alive_only;
1347      int *jobp;         /* index into jobs list or NO_JOB */
1348 {
1349   PROCESS *p;
1350
1351   p = find_pipeline (pid, alive_only, jobp);
1352   while (p && p->pid != pid)
1353     p = p->next;
1354   return p;
1355 }
1356
1357 /* Return the job index that PID belongs to, or NO_JOB if it doesn't
1358    belong to any job.  Must be called with SIGCHLD blocked. */
1359 static int
1360 find_job (pid, alive_only, procp)
1361      pid_t pid;
1362      int alive_only;
1363      PROCESS **procp;
1364 {
1365   register int i;
1366   PROCESS *p;
1367
1368   /* XXX could use js.j_firstj here, and should check js.j_lastj */
1369   for (i = 0; i < js.j_jobslots; i++)
1370     {
1371 #if defined (DEBUG)
1372       if (i < js.j_firstj && jobs[i])
1373         itrace("find_job: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
1374       if (i > js.j_lastj && jobs[i])
1375         itrace("find_job: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
1376 #endif
1377       if (jobs[i])
1378         {
1379           p = jobs[i]->pipe;
1380
1381           do
1382             {
1383               if (p->pid == pid && ((alive_only == 0 && PRECYCLED(p) == 0) || PALIVE(p)))
1384                 {
1385                   if (procp)
1386                     *procp = p;
1387                   return (i);
1388                 }
1389
1390               p = p->next;
1391             }
1392           while (p != jobs[i]->pipe);
1393         }
1394     }
1395
1396   return (NO_JOB);
1397 }
1398
1399 /* Find a job given a PID.  If BLOCK is non-zero, block SIGCHLD as
1400    required by find_job. */
1401 int
1402 get_job_by_pid (pid, block)
1403      pid_t pid;
1404      int block;
1405 {
1406   int job;
1407   sigset_t set, oset;
1408
1409   if (block)
1410     BLOCK_CHILD (set, oset);
1411
1412   job = find_job (pid, 0, NULL);
1413
1414   if (block)
1415     UNBLOCK_CHILD (oset);
1416
1417   return job;
1418 }
1419
1420 /* Print descriptive information about the job with leader pid PID. */
1421 void
1422 describe_pid (pid)
1423      pid_t pid;
1424 {
1425   int job;
1426   sigset_t set, oset;
1427
1428   BLOCK_CHILD (set, oset);
1429
1430   job = find_job (pid, 0, NULL);
1431
1432   if (job != NO_JOB)
1433     fprintf (stderr, "[%d] %ld\n", job + 1, (long)pid);
1434   else
1435     programming_error (_("describe_pid: %ld: no such pid"), (long)pid);
1436
1437   UNBLOCK_CHILD (oset);
1438 }
1439
1440 static char *
1441 j_strsignal (s)
1442      int s;
1443 {
1444   char *x;
1445
1446   x = strsignal (s);
1447   if (x == 0)
1448     {
1449       x = retcode_name_buffer;
1450       sprintf (x, _("Signal %d"), s);
1451     }
1452   return x;
1453 }
1454
1455 static char *
1456 printable_job_status (j, p, format)
1457      int j;
1458      PROCESS *p;
1459      int format;
1460 {
1461   static char *temp;
1462   int es;
1463
1464   temp = _("Done");
1465
1466   if (STOPPED (j) && format == 0)
1467     {
1468       if (posixly_correct == 0 || p == 0 || (WIFSTOPPED (p->status) == 0))
1469         temp = _("Stopped");
1470       else
1471         {
1472           temp = retcode_name_buffer;
1473           sprintf (temp, _("Stopped(%s)"), signal_name (WSTOPSIG (p->status)));
1474         }
1475     }
1476   else if (RUNNING (j))
1477     temp = _("Running");
1478   else
1479     {
1480       if (WIFSTOPPED (p->status))
1481         temp = j_strsignal (WSTOPSIG (p->status));
1482       else if (WIFSIGNALED (p->status))
1483         temp = j_strsignal (WTERMSIG (p->status));
1484       else if (WIFEXITED (p->status))
1485         {
1486           temp = retcode_name_buffer;
1487           es = WEXITSTATUS (p->status);
1488           if (es == 0)
1489             strcpy (temp, _("Done"));
1490           else if (posixly_correct)
1491             sprintf (temp, _("Done(%d)"), es);
1492           else
1493             sprintf (temp, _("Exit %d"), es);
1494         }
1495       else
1496         temp = _("Unknown status");
1497     }
1498
1499   return temp;
1500 }
1501
1502 /* This is the way to print out information on a job if you
1503    know the index.  FORMAT is:
1504
1505     JLIST_NORMAL)   [1]+ Running           emacs
1506     JLIST_LONG  )   [1]+ 2378 Running      emacs
1507     -1    )   [1]+ 2378       emacs
1508
1509     JLIST_NORMAL)   [1]+ Stopped           ls | more
1510     JLIST_LONG  )   [1]+ 2369 Stopped      ls
1511                          2367       | more
1512     JLIST_PID_ONLY)
1513         Just list the pid of the process group leader (really
1514         the process group).
1515     JLIST_CHANGED_ONLY)
1516         Use format JLIST_NORMAL, but list only jobs about which
1517         the user has not been notified. */
1518
1519 /* Print status for pipeline P.  If JOB_INDEX is >= 0, it is the index into
1520    the JOBS array corresponding to this pipeline.  FORMAT is as described
1521    above.  Must be called with SIGCHLD blocked.
1522
1523    If you're printing a pipeline that's not in the jobs array, like the
1524    current pipeline as it's being created, pass -1 for JOB_INDEX */
1525 static void
1526 print_pipeline (p, job_index, format, stream)
1527      PROCESS *p;
1528      int job_index, format;
1529      FILE *stream;
1530 {
1531   PROCESS *first, *last, *show;
1532   int es, name_padding;
1533   char *temp;
1534
1535   if (p == 0)
1536     return;
1537
1538   first = last = p;
1539   while (last->next != first)
1540     last = last->next;
1541
1542   for (;;)
1543     {
1544       if (p != first)
1545         fprintf (stream, format ? "     " : " |");
1546
1547       if (format != JLIST_STANDARD)
1548         fprintf (stream, "%5ld", (long)p->pid);
1549
1550       fprintf (stream, " ");
1551
1552       if (format > -1 && job_index >= 0)
1553         {
1554           show = format ? p : last;
1555           temp = printable_job_status (job_index, show, format);
1556
1557           if (p != first)
1558             {
1559               if (format)
1560                 {
1561                   if (show->running == first->running &&
1562                       WSTATUS (show->status) == WSTATUS (first->status))
1563                     temp = "";
1564                 }
1565               else
1566                 temp = (char *)NULL;
1567             }
1568
1569           if (temp)
1570             {
1571               fprintf (stream, "%s", temp);
1572
1573               es = STRLEN (temp);
1574               if (es == 0)
1575                 es = 2; /* strlen ("| ") */
1576               name_padding = LONGEST_SIGNAL_DESC - es;
1577
1578               fprintf (stream, "%*s", name_padding, "");
1579
1580               if ((WIFSTOPPED (show->status) == 0) &&
1581                   (WIFCONTINUED (show->status) == 0) &&
1582                   WIFCORED (show->status))
1583                 fprintf (stream, _("(core dumped) "));
1584             }
1585         }
1586
1587       if (p != first && format)
1588         fprintf (stream, "| ");
1589
1590       if (p->command)
1591         fprintf (stream, "%s", p->command);
1592
1593       if (p == last && job_index >= 0)
1594         {
1595           temp = current_working_directory ();
1596
1597           if (RUNNING (job_index) && (IS_FOREGROUND (job_index) == 0))
1598             fprintf (stream, " &");
1599
1600           if (strcmp (temp, jobs[job_index]->wd) != 0)
1601             fprintf (stream,
1602               _("  (wd: %s)"), polite_directory_format (jobs[job_index]->wd));
1603         }
1604
1605       if (format || (p == last))
1606         {
1607           /* We need to add a CR only if this is an interactive shell, and
1608              we're reporting the status of a completed job asynchronously.
1609              We can't really check whether this particular job is being
1610              reported asynchronously, so just add the CR if the shell is
1611              currently interactive and asynchronous notification is enabled. */
1612           if (asynchronous_notification && interactive)
1613             fprintf (stream, "\r\n");
1614           else
1615             fprintf (stream, "\n");
1616         }
1617
1618       if (p == last)
1619         break;
1620       p = p->next;
1621     }
1622   fflush (stream);
1623 }
1624
1625 /* Print information to STREAM about jobs[JOB_INDEX] according to FORMAT.
1626    Must be called with SIGCHLD blocked or queued with queue_sigchld */
1627 static void
1628 pretty_print_job (job_index, format, stream)
1629      int job_index, format;
1630      FILE *stream;
1631 {
1632   register PROCESS *p;
1633
1634   /* Format only pid information about the process group leader? */
1635   if (format == JLIST_PID_ONLY)
1636     {
1637       fprintf (stream, "%ld\n", (long)jobs[job_index]->pipe->pid);
1638       return;
1639     }
1640
1641   if (format == JLIST_CHANGED_ONLY)
1642     {
1643       if (IS_NOTIFIED (job_index))
1644         return;
1645       format = JLIST_STANDARD;
1646     }
1647
1648   if (format != JLIST_NONINTERACTIVE)
1649     fprintf (stream, "[%d]%c ", job_index + 1,
1650               (job_index == js.j_current) ? '+':
1651                 (job_index == js.j_previous) ? '-' : ' ');
1652
1653   if (format == JLIST_NONINTERACTIVE)
1654     format = JLIST_LONG;
1655
1656   p = jobs[job_index]->pipe;
1657
1658   print_pipeline (p, job_index, format, stream);
1659
1660   /* We have printed information about this job.  When the job's
1661      status changes, waitchld () sets the notification flag to 0. */
1662   jobs[job_index]->flags |= J_NOTIFIED;
1663 }
1664
1665 static int
1666 print_job (job, format, state, job_index)
1667      JOB *job;
1668      int format, state, job_index;
1669 {
1670   if (state == -1 || (JOB_STATE)state == job->state)
1671     pretty_print_job (job_index, format, stdout);
1672   return (0);
1673 }
1674
1675 void
1676 list_one_job (job, format, ignore, job_index)
1677      JOB *job;
1678      int format, ignore, job_index;
1679 {
1680   pretty_print_job (job_index, format, stdout);
1681 }
1682
1683 void
1684 list_stopped_jobs (format)
1685      int format;
1686 {
1687   cleanup_dead_jobs ();
1688   map_over_jobs (print_job, format, (int)JSTOPPED);
1689 }
1690
1691 void
1692 list_running_jobs (format)
1693      int format;
1694 {
1695   cleanup_dead_jobs ();
1696   map_over_jobs (print_job, format, (int)JRUNNING);
1697 }
1698
1699 /* List jobs.  If FORMAT is non-zero, then the long form of the information
1700    is printed, else just a short version. */
1701 void
1702 list_all_jobs (format)
1703      int format;
1704 {
1705   cleanup_dead_jobs ();
1706   map_over_jobs (print_job, format, -1);
1707 }
1708
1709 /* Fork, handling errors.  Returns the pid of the newly made child, or 0.
1710    COMMAND is just for remembering the name of the command; we don't do
1711    anything else with it.  ASYNC_P says what to do with the tty.  If
1712    non-zero, then don't give it away. */
1713 pid_t
1714 make_child (command, async_p)
1715      char *command;
1716      int async_p;
1717 {
1718   int forksleep;
1719   sigset_t set, oset;
1720   pid_t pid;
1721
1722   /* XXX - block SIGTERM here and unblock in child after fork resets the
1723      set of pending signals? */
1724   sigemptyset (&set);
1725   sigaddset (&set, SIGCHLD);
1726   sigaddset (&set, SIGINT);
1727   sigemptyset (&oset);
1728   sigprocmask (SIG_BLOCK, &set, &oset);
1729
1730   making_children ();
1731
1732   forksleep = 1;
1733
1734 #if defined (BUFFERED_INPUT)
1735   /* If default_buffered_input is active, we are reading a script.  If
1736      the command is asynchronous, we have already duplicated /dev/null
1737      as fd 0, but have not changed the buffered stream corresponding to
1738      the old fd 0.  We don't want to sync the stream in this case. */
1739   if (default_buffered_input != -1 &&
1740       (!async_p || default_buffered_input > 0))
1741     sync_buffered_stream (default_buffered_input);
1742 #endif /* BUFFERED_INPUT */
1743
1744   RESET_SIGTERM;
1745
1746   /* Create the child, handle severe errors.  Retry on EAGAIN. */
1747   while ((pid = fork ()) < 0 && errno == EAGAIN && forksleep < FORKSLEEP_MAX)
1748     {
1749       /* bash-4.2 */
1750       /* If we can't create any children, try to reap some dead ones. */
1751       waitchld (-1, 0);
1752
1753       sys_error ("fork: retry");
1754       RESET_SIGTERM;
1755
1756       if (sleep (forksleep) != 0)
1757         break;
1758       forksleep <<= 1;
1759     }
1760
1761   if (pid != 0)
1762     RESET_SIGTERM;
1763
1764   if (pid < 0)
1765     {
1766       sys_error ("fork");
1767
1768       /* Kill all of the processes in the current pipeline. */
1769       terminate_current_pipeline ();
1770
1771       /* Discard the current pipeline, if any. */
1772       if (the_pipeline)
1773         kill_current_pipeline ();
1774
1775       last_command_exit_value = EX_NOEXEC;
1776       throw_to_top_level ();    /* Reset signals, etc. */
1777     }
1778
1779   if (pid == 0)
1780     {
1781       /* In the child.  Give this child the right process group, set the
1782          signals to the default state for a new process. */
1783       pid_t mypid;
1784
1785       mypid = getpid ();
1786 #if defined (BUFFERED_INPUT)
1787       /* Close default_buffered_input if it's > 0.  We don't close it if it's
1788          0 because that's the file descriptor used when redirecting input,
1789          and it's wrong to close the file in that case. */
1790       unset_bash_input (0);
1791 #endif /* BUFFERED_INPUT */
1792
1793       /* Restore top-level signal mask. */
1794       sigprocmask (SIG_SETMASK, &top_level_mask, (sigset_t *)NULL);
1795
1796       if (job_control)
1797         {
1798           /* All processes in this pipeline belong in the same
1799              process group. */
1800
1801           if (pipeline_pgrp == 0)       /* This is the first child. */
1802             pipeline_pgrp = mypid;
1803
1804           /* Check for running command in backquotes. */
1805           if (pipeline_pgrp == shell_pgrp)
1806             ignore_tty_job_signals ();
1807           else
1808             default_tty_job_signals ();
1809
1810           /* Set the process group before trying to mess with the terminal's
1811              process group.  This is mandated by POSIX. */
1812           /* This is in accordance with the Posix 1003.1 standard,
1813              section B.7.2.4, which says that trying to set the terminal
1814              process group with tcsetpgrp() to an unused pgrp value (like
1815              this would have for the first child) is an error.  Section
1816              B.4.3.3, p. 237 also covers this, in the context of job control
1817              shells. */
1818           if (setpgid (mypid, pipeline_pgrp) < 0)
1819             sys_error (_("child setpgid (%ld to %ld)"), (long)mypid, (long)pipeline_pgrp);
1820
1821           /* By convention (and assumption above), if
1822              pipeline_pgrp == shell_pgrp, we are making a child for
1823              command substitution.
1824              In this case, we don't want to give the terminal to the
1825              shell's process group (we could be in the middle of a
1826              pipeline, for example). */
1827           if (async_p == 0 && pipeline_pgrp != shell_pgrp && ((subshell_environment&SUBSHELL_ASYNC) == 0))
1828             give_terminal_to (pipeline_pgrp, 0);
1829
1830 #if defined (PGRP_PIPE)
1831           if (pipeline_pgrp == mypid)
1832             pipe_read (pgrp_pipe);
1833 #endif
1834         }
1835       else                      /* Without job control... */
1836         {
1837           if (pipeline_pgrp == 0)
1838             pipeline_pgrp = shell_pgrp;
1839
1840           /* If these signals are set to SIG_DFL, we encounter the curious
1841              situation of an interactive ^Z to a running process *working*
1842              and stopping the process, but being unable to do anything with
1843              that process to change its state.  On the other hand, if they
1844              are set to SIG_IGN, jobs started from scripts do not stop when
1845              the shell running the script gets a SIGTSTP and stops. */
1846
1847           default_tty_job_signals ();
1848         }
1849
1850 #if defined (PGRP_PIPE)
1851       /* Release the process group pipe, since our call to setpgid ()
1852          is done.  The last call to sh_closepipe is done in stop_pipeline. */
1853       sh_closepipe (pgrp_pipe);
1854 #endif /* PGRP_PIPE */
1855
1856 #if 0
1857       /* Don't set last_asynchronous_pid in the child */
1858       if (async_p)
1859         last_asynchronous_pid = mypid;          /* XXX */
1860       else
1861 #endif
1862 #if defined (RECYCLES_PIDS)
1863       if (last_asynchronous_pid == mypid)
1864         /* Avoid pid aliasing.  1 seems like a safe, unusual pid value. */
1865         last_asynchronous_pid = 1;
1866 #endif
1867     }
1868   else
1869     {
1870       /* In the parent.  Remember the pid of the child just created
1871          as the proper pgrp if this is the first child. */
1872
1873       if (job_control)
1874         {
1875           if (pipeline_pgrp == 0)
1876             {
1877               pipeline_pgrp = pid;
1878               /* Don't twiddle terminal pgrps in the parent!  This is the bug,
1879                  not the good thing of twiddling them in the child! */
1880               /* give_terminal_to (pipeline_pgrp, 0); */
1881             }
1882           /* This is done on the recommendation of the Rationale section of
1883              the POSIX 1003.1 standard, where it discusses job control and
1884              shells.  It is done to avoid possible race conditions. (Ref.
1885              1003.1 Rationale, section B.4.3.3, page 236). */
1886           setpgid (pid, pipeline_pgrp);
1887         }
1888       else
1889         {
1890           if (pipeline_pgrp == 0)
1891             pipeline_pgrp = shell_pgrp;
1892         }
1893
1894       /* Place all processes into the jobs array regardless of the
1895          state of job_control. */
1896       add_process (command, pid);
1897
1898       if (async_p)
1899         last_asynchronous_pid = pid;
1900 #if defined (RECYCLES_PIDS)
1901       else if (last_asynchronous_pid == pid)
1902         /* Avoid pid aliasing.  1 seems like a safe, unusual pid value. */
1903         last_asynchronous_pid = 1;
1904 #endif
1905
1906       /* Delete the saved status for any job containing this PID in case it's
1907          been reused. */
1908       delete_old_job (pid);
1909
1910       /* Perform the check for pid reuse unconditionally.  Some systems reuse
1911          PIDs before giving a process CHILD_MAX/_SC_CHILD_MAX unique ones. */
1912       bgp_delete (pid);         /* new process, discard any saved status */
1913
1914       last_made_pid = pid;
1915
1916       /* keep stats */
1917       js.c_totforked++;
1918       js.c_living++;
1919
1920       /* Unblock SIGINT and SIGCHLD unless creating a pipeline, in which case
1921          SIGCHLD remains blocked until all commands in the pipeline have been
1922          created. */
1923       sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
1924     }
1925
1926   return (pid);
1927 }
1928
1929 /* These two functions are called only in child processes. */
1930 void
1931 ignore_tty_job_signals ()
1932 {
1933   set_signal_handler (SIGTSTP, SIG_IGN);
1934   set_signal_handler (SIGTTIN, SIG_IGN);
1935   set_signal_handler (SIGTTOU, SIG_IGN);
1936 }
1937
1938 void
1939 default_tty_job_signals ()
1940 {
1941   set_signal_handler (SIGTSTP, SIG_DFL);
1942   set_signal_handler (SIGTTIN, SIG_DFL);
1943   set_signal_handler (SIGTTOU, SIG_DFL);
1944 }
1945
1946 /* When we end a job abnormally, or if we stop a job, we set the tty to the
1947    state kept in here.  When a job ends normally, we set the state in here
1948    to the state of the tty. */
1949
1950 static TTYSTRUCT shell_tty_info;
1951
1952 #if defined (NEW_TTY_DRIVER)
1953 static struct tchars shell_tchars;
1954 static struct ltchars shell_ltchars;
1955 #endif /* NEW_TTY_DRIVER */
1956
1957 #if defined (NEW_TTY_DRIVER) && defined (DRAIN_OUTPUT)
1958 /* Since the BSD tty driver does not allow us to change the tty modes
1959    while simultaneously waiting for output to drain and preserving
1960    typeahead, we have to drain the output ourselves before calling
1961    ioctl.  We cheat by finding the length of the output queue, and
1962    using select to wait for an appropriate length of time.  This is
1963    a hack, and should be labeled as such (it's a hastily-adapted
1964    mutation of a `usleep' implementation).  It's only reason for
1965    existing is the flaw in the BSD tty driver. */
1966
1967 static int ttspeeds[] =
1968 {
1969   0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
1970   1800, 2400, 4800, 9600, 19200, 38400
1971 };
1972
1973 static void
1974 draino (fd, ospeed)
1975      int fd, ospeed;
1976 {
1977   register int delay = ttspeeds[ospeed];
1978   int n;
1979
1980   if (!delay)
1981     return;
1982
1983   while ((ioctl (fd, TIOCOUTQ, &n) == 0) && n)
1984     {
1985       if (n > (delay / 100))
1986         {
1987           struct timeval tv;
1988
1989           n *= 10;              /* 2 bits more for conservativeness. */
1990           tv.tv_sec = n / delay;
1991           tv.tv_usec = ((n % delay) * 1000000) / delay;
1992           select (fd, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv);
1993         }
1994       else
1995         break;
1996     }
1997 }
1998 #endif /* NEW_TTY_DRIVER && DRAIN_OUTPUT */
1999
2000 /* Return the fd from which we are actually getting input. */
2001 #define input_tty() (shell_tty != -1) ? shell_tty : fileno (stderr)
2002
2003 /* Fill the contents of shell_tty_info with the current tty info. */
2004 int
2005 get_tty_state ()
2006 {
2007   int tty;
2008
2009   tty = input_tty ();
2010   if (tty != -1)
2011     {
2012 #if defined (NEW_TTY_DRIVER)
2013       ioctl (tty, TIOCGETP, &shell_tty_info);
2014       ioctl (tty, TIOCGETC, &shell_tchars);
2015       ioctl (tty, TIOCGLTC, &shell_ltchars);
2016 #endif /* NEW_TTY_DRIVER */
2017
2018 #if defined (TERMIO_TTY_DRIVER)
2019       ioctl (tty, TCGETA, &shell_tty_info);
2020 #endif /* TERMIO_TTY_DRIVER */
2021
2022 #if defined (TERMIOS_TTY_DRIVER)
2023       if (tcgetattr (tty, &shell_tty_info) < 0)
2024         {
2025 #if 0
2026           /* Only print an error message if we're really interactive at
2027              this time. */
2028           if (interactive)
2029             sys_error ("[%ld: %d (%d)] tcgetattr", (long)getpid (), shell_level, tty);
2030 #endif
2031           return -1;
2032         }
2033 #endif /* TERMIOS_TTY_DRIVER */
2034       if (check_window_size)
2035         get_new_window_size (0, (int *)0, (int *)0);
2036     }
2037   return 0;
2038 }
2039
2040 /* Make the current tty use the state in shell_tty_info. */
2041 int
2042 set_tty_state ()
2043 {
2044   int tty;
2045
2046   tty = input_tty ();
2047   if (tty != -1)
2048     {
2049 #if defined (NEW_TTY_DRIVER)
2050 #  if defined (DRAIN_OUTPUT)
2051       draino (tty, shell_tty_info.sg_ospeed);
2052 #  endif /* DRAIN_OUTPUT */
2053       ioctl (tty, TIOCSETN, &shell_tty_info);
2054       ioctl (tty, TIOCSETC, &shell_tchars);
2055       ioctl (tty, TIOCSLTC, &shell_ltchars);
2056 #endif /* NEW_TTY_DRIVER */
2057
2058 #if defined (TERMIO_TTY_DRIVER)
2059       ioctl (tty, TCSETAW, &shell_tty_info);
2060 #endif /* TERMIO_TTY_DRIVER */
2061
2062 #if defined (TERMIOS_TTY_DRIVER)
2063       if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0)
2064         {
2065           /* Only print an error message if we're really interactive at
2066              this time. */
2067           if (interactive)
2068             sys_error ("[%ld: %d (%d)] tcsetattr", (long)getpid (), shell_level, tty);
2069           return -1;
2070         }
2071 #endif /* TERMIOS_TTY_DRIVER */
2072     }
2073   return 0;
2074 }
2075
2076 /* Given an index into the jobs array JOB, return the PROCESS struct of the last
2077    process in that job's pipeline.  This is the one whose exit status
2078    counts.  Must be called with SIGCHLD blocked or queued. */
2079 static PROCESS *
2080 find_last_proc (job, block)
2081      int job;
2082      int block;
2083 {
2084   register PROCESS *p;
2085   sigset_t set, oset;
2086
2087   if (block)
2088     BLOCK_CHILD (set, oset);
2089
2090   p = jobs[job]->pipe;
2091   while (p && p->next != jobs[job]->pipe)
2092     p = p->next;
2093
2094   if (block)
2095     UNBLOCK_CHILD (oset);
2096
2097   return (p);
2098 }
2099
2100 static pid_t
2101 find_last_pid (job, block)
2102      int job;
2103      int block;
2104 {
2105   PROCESS *p;
2106
2107   p = find_last_proc (job, block);
2108   /* Possible race condition here. */
2109   return p->pid;
2110 }     
2111
2112 /* Wait for a particular child of the shell to finish executing.
2113    This low-level function prints an error message if PID is not
2114    a child of this shell.  It returns -1 if it fails, or whatever
2115    wait_for returns otherwise.  If the child is not found in the
2116    jobs table, it returns 127. */
2117 int
2118 wait_for_single_pid (pid)
2119      pid_t pid;
2120 {
2121   register PROCESS *child;
2122   sigset_t set, oset;
2123   int r, job;
2124
2125   BLOCK_CHILD (set, oset);
2126   child = find_pipeline (pid, 0, (int *)NULL);
2127   UNBLOCK_CHILD (oset);
2128
2129   if (child == 0)
2130     {
2131       r = bgp_search (pid);
2132       if (r >= 0)
2133         return r;
2134     }
2135
2136   if (child == 0)
2137     {
2138       internal_error (_("wait: pid %ld is not a child of this shell"), (long)pid);
2139       return (127);
2140     }
2141
2142   r = wait_for (pid);
2143
2144   /* POSIX.2: if we just waited for a job, we can remove it from the jobs
2145      table. */
2146   BLOCK_CHILD (set, oset);
2147   job = find_job (pid, 0, NULL);
2148   if (job != NO_JOB && jobs[job] && DEADJOB (job))
2149     jobs[job]->flags |= J_NOTIFIED;
2150   UNBLOCK_CHILD (oset);
2151
2152   /* If running in posix mode, remove the job from the jobs table immediately */
2153   if (posixly_correct)
2154     {
2155       cleanup_dead_jobs ();
2156       bgp_delete (pid);
2157     }
2158
2159   return r;
2160 }
2161
2162 /* Wait for all of the background processes started by this shell to finish. */
2163 void
2164 wait_for_background_pids ()
2165 {
2166   register int i, r, waited_for;
2167   sigset_t set, oset;
2168   pid_t pid;
2169
2170   for (waited_for = 0;;)
2171     {
2172       BLOCK_CHILD (set, oset);
2173
2174       /* find first running job; if none running in foreground, break */
2175       /* XXX could use js.j_firstj and js.j_lastj here */
2176       for (i = 0; i < js.j_jobslots; i++)
2177         {
2178 #if defined (DEBUG)
2179           if (i < js.j_firstj && jobs[i])
2180             itrace("wait_for_background_pids: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
2181           if (i > js.j_lastj && jobs[i])
2182             itrace("wait_for_background_pids: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
2183 #endif
2184           if (jobs[i] && RUNNING (i) && IS_FOREGROUND (i) == 0)
2185             break;
2186         }
2187       if (i == js.j_jobslots)
2188         {
2189           UNBLOCK_CHILD (oset);
2190           break;
2191         }
2192
2193       /* now wait for the last pid in that job. */
2194       pid = find_last_pid (i, 0);
2195       UNBLOCK_CHILD (oset);
2196       QUIT;
2197       errno = 0;                /* XXX */
2198       r = wait_for_single_pid (pid);
2199       if (r == -1)
2200         {
2201           /* If we're mistaken about job state, compensate. */
2202           if (errno == ECHILD)
2203             mark_all_jobs_as_dead ();
2204         }
2205       else
2206         waited_for++;
2207     }
2208
2209   /* POSIX.2 says the shell can discard the statuses of all completed jobs if
2210      `wait' is called with no arguments. */
2211   mark_dead_jobs_as_notified (1);
2212   cleanup_dead_jobs ();
2213   bgp_clear ();
2214 }
2215
2216 /* Make OLD_SIGINT_HANDLER the SIGINT signal handler. */
2217 #define INVALID_SIGNAL_HANDLER (SigHandler *)wait_for_background_pids
2218 static SigHandler *old_sigint_handler = INVALID_SIGNAL_HANDLER;
2219
2220 static int wait_sigint_received;
2221 static int child_caught_sigint;
2222 static int waiting_for_child;
2223
2224 static void
2225 restore_sigint_handler ()
2226 {
2227   if (old_sigint_handler != INVALID_SIGNAL_HANDLER)
2228     {
2229       set_signal_handler (SIGINT, old_sigint_handler);
2230       old_sigint_handler = INVALID_SIGNAL_HANDLER;
2231       waiting_for_child = 0;
2232     }
2233 }
2234
2235 /* Handle SIGINT while we are waiting for children in a script to exit.
2236    The `wait' builtin should be interruptible, but all others should be
2237    effectively ignored (i.e. not cause the shell to exit). */
2238 static sighandler
2239 wait_sigint_handler (sig)
2240      int sig;
2241 {
2242   SigHandler *sigint_handler;
2243
2244   if (interrupt_immediately ||
2245       (this_shell_builtin && this_shell_builtin == wait_builtin))
2246     {
2247       last_command_exit_value = 128+SIGINT;
2248       restore_sigint_handler ();
2249       /* If we got a SIGINT while in `wait', and SIGINT is trapped, do
2250          what POSIX.2 says (see builtins/wait.def for more info). */
2251       if (this_shell_builtin && this_shell_builtin == wait_builtin &&
2252           signal_is_trapped (SIGINT) &&
2253           ((sigint_handler = trap_to_sighandler (SIGINT)) == trap_handler))
2254         {
2255           trap_handler (SIGINT);        /* set pending_traps[SIGINT] */
2256           wait_signal_received = SIGINT;
2257           if (interrupt_immediately)
2258             {
2259               interrupt_immediately = 0;
2260               longjmp (wait_intr_buf, 1);
2261             }
2262           else
2263             /* Let CHECK_WAIT_INTR handle it in wait_for/waitchld */
2264             SIGRETURN (0);
2265         }
2266       else if (interrupt_immediately)
2267         {
2268           ADDINTERRUPT;
2269           QUIT;
2270         }
2271       else /* wait_builtin but signal not trapped, treat as interrupt */
2272         kill (getpid (), SIGINT);
2273     }
2274
2275   /* XXX - should this be interrupt_state?  If it is, the shell will act
2276      as if it got the SIGINT interrupt. */
2277   if (waiting_for_child)
2278     wait_sigint_received = 1;
2279   else
2280     {
2281       last_command_exit_value = 128+SIGINT;
2282       restore_sigint_handler ();
2283       kill (getpid (), SIGINT);
2284     }
2285
2286   /* Otherwise effectively ignore the SIGINT and allow the running job to
2287      be killed. */
2288   SIGRETURN (0);
2289 }
2290
2291 static int
2292 process_exit_signal (status)
2293      WAIT status;
2294 {
2295   return (WIFSIGNALED (status) ? WTERMSIG (status) : 0);
2296 }
2297
2298 static int
2299 process_exit_status (status)
2300      WAIT status;
2301 {
2302   if (WIFSIGNALED (status))
2303     return (128 + WTERMSIG (status));
2304   else if (WIFSTOPPED (status) == 0)
2305     return (WEXITSTATUS (status));
2306   else
2307     return (EXECUTION_SUCCESS);
2308 }
2309
2310 static WAIT
2311 job_signal_status (job)
2312      int job;
2313 {
2314   register PROCESS *p;
2315   WAIT s;
2316
2317   p = jobs[job]->pipe;
2318   do
2319     {
2320       s = p->status;
2321       if (WIFSIGNALED(s) || WIFSTOPPED(s))
2322         break;
2323       p = p->next;
2324     }
2325   while (p != jobs[job]->pipe);
2326
2327   return s;
2328 }
2329   
2330 /* Return the exit status of the last process in the pipeline for job JOB.
2331    This is the exit status of the entire job. */
2332 static WAIT
2333 raw_job_exit_status (job)
2334      int job;
2335 {
2336   register PROCESS *p;
2337   int fail;
2338   WAIT ret;
2339
2340   if (pipefail_opt)
2341     {
2342       fail = 0;
2343       p = jobs[job]->pipe;
2344       do
2345         {
2346           if (WSTATUS (p->status) != EXECUTION_SUCCESS)
2347             fail = WSTATUS(p->status);
2348           p = p->next;
2349         }
2350       while (p != jobs[job]->pipe);
2351       WSTATUS (ret) = fail;
2352       return ret;
2353     }
2354
2355   for (p = jobs[job]->pipe; p->next != jobs[job]->pipe; p = p->next)
2356     ;
2357   return (p->status);
2358 }
2359
2360 /* Return the exit status of job JOB.  This is the exit status of the last
2361    (rightmost) process in the job's pipeline, modified if the job was killed
2362    by a signal or stopped. */
2363 int
2364 job_exit_status (job)
2365      int job;
2366 {
2367   return (process_exit_status (raw_job_exit_status (job)));
2368 }
2369
2370 int
2371 job_exit_signal (job)
2372      int job;
2373 {
2374   return (process_exit_signal (raw_job_exit_status (job)));
2375 }
2376
2377 #define FIND_CHILD(pid, child) \
2378   do \
2379     { \
2380       child = find_pipeline (pid, 0, (int *)NULL); \
2381       if (child == 0) \
2382         { \
2383           give_terminal_to (shell_pgrp, 0); \
2384           UNBLOCK_CHILD (oset); \
2385           internal_error (_("wait_for: No record of process %ld"), (long)pid); \
2386           restore_sigint_handler (); \
2387           return (termination_state = 127); \
2388         } \
2389     } \
2390   while (0)
2391
2392 /* Wait for pid (one of our children) to terminate, then
2393    return the termination state.  Returns 127 if PID is not found in
2394    the jobs table.  Returns -1 if waitchld() returns -1, indicating
2395    that there are no unwaited-for child processes. */
2396 int
2397 wait_for (pid)
2398      pid_t pid;
2399 {
2400   int job, termination_state, r;
2401   WAIT s;
2402   register PROCESS *child;
2403   sigset_t set, oset;
2404
2405   /* In the case that this code is interrupted, and we longjmp () out of it,
2406      we are relying on the code in throw_to_top_level () to restore the
2407      top-level signal mask. */
2408   child = 0;
2409   BLOCK_CHILD (set, oset);
2410
2411   /* Ignore interrupts while waiting for a job run without job control
2412      to finish.  We don't want the shell to exit if an interrupt is
2413      received, only if one of the jobs run is killed via SIGINT.  If
2414      job control is not set, the job will be run in the same pgrp as
2415      the shell, and the shell will see any signals the job gets.  In
2416      fact, we want this set every time the waiting shell and the waited-
2417      for process are in the same process group, including command
2418      substitution. */
2419
2420   /* This is possibly a race condition -- should it go in stop_pipeline? */
2421   wait_sigint_received = child_caught_sigint = 0;
2422   if (job_control == 0 || (subshell_environment&SUBSHELL_COMSUB))
2423     {
2424       old_sigint_handler = set_signal_handler (SIGINT, wait_sigint_handler);
2425       waiting_for_child = 0;
2426       if (old_sigint_handler == SIG_IGN)
2427         set_signal_handler (SIGINT, old_sigint_handler);
2428     }
2429
2430   termination_state = last_command_exit_value;
2431
2432   if (interactive && job_control == 0)
2433     QUIT;
2434   /* Check for terminating signals and exit the shell if we receive one */
2435   CHECK_TERMSIG;
2436
2437   /* Check for a trapped signal interrupting the wait builtin and jump out */
2438   CHECK_WAIT_INTR;
2439
2440   /* If we say wait_for (), then we have a record of this child somewhere.
2441      If it and none of its peers are running, don't call waitchld(). */
2442
2443   job = NO_JOB;
2444   do
2445     {
2446       if (pid != ANY_PID)
2447         FIND_CHILD (pid, child);
2448
2449       /* If this child is part of a job, then we are really waiting for the
2450          job to finish.  Otherwise, we are waiting for the child to finish.
2451          We check for JDEAD in case the job state has been set by waitchld
2452          after receipt of a SIGCHLD. */
2453       if (job == NO_JOB)
2454         job = find_job (pid, 0, NULL);
2455
2456       /* waitchld() takes care of setting the state of the job.  If the job
2457          has already exited before this is called, sigchld_handler will have
2458          called waitchld and the state will be set to JDEAD. */
2459
2460       if (pid == ANY_PID || PRUNNING(child) || (job != NO_JOB && RUNNING (job)))
2461         {
2462 #if defined (WAITPID_BROKEN)    /* SCOv4 */
2463           sigset_t suspend_set;
2464           sigemptyset (&suspend_set);
2465           sigsuspend (&suspend_set);
2466 #else /* !WAITPID_BROKEN */
2467 #  if defined (MUST_UNBLOCK_CHLD)
2468           struct sigaction act, oact;
2469           sigset_t nullset, chldset;
2470
2471           sigemptyset (&nullset);
2472           sigemptyset (&chldset);
2473           sigprocmask (SIG_SETMASK, &nullset, &chldset);
2474           act.sa_handler = SIG_DFL;
2475           sigemptyset (&act.sa_mask);
2476           sigemptyset (&oact.sa_mask);
2477           act.sa_flags = 0;
2478 #  if defined (SA_RESTART)
2479           act.sa_flags |= SA_RESTART;
2480 #  endif
2481           sigaction (SIGCHLD, &act, &oact);
2482 #  endif /* MUST_UNBLOCK_CHLD */
2483           queue_sigchld = 1;
2484           waiting_for_child++;
2485           r = waitchld (pid, 1);        /* XXX */
2486           waiting_for_child--;
2487 #if 0
2488 itrace("wait_for: blocking wait for %d returns %d child = %p", (int)pid, r, child);
2489 #endif
2490 #  if defined (MUST_UNBLOCK_CHLD)
2491           sigaction (SIGCHLD, &oact, (struct sigaction *)NULL);
2492           sigprocmask (SIG_SETMASK, &chldset, (sigset_t *)NULL);
2493 #  endif
2494           queue_sigchld = 0;
2495           if (r == -1 && errno == ECHILD && this_shell_builtin == wait_builtin)
2496             {
2497               termination_state = -1;
2498               /* XXX - restore sigint handler here? */
2499               goto wait_for_return;
2500             }
2501
2502           /* If child is marked as running, but waitpid() returns -1/ECHILD,
2503              there is something wrong.  Somewhere, wait should have returned
2504              that child's pid.  Mark the child as not running and the job,
2505              if it exists, as JDEAD. */
2506           if (r == -1 && errno == ECHILD)
2507             {
2508               if (child)
2509                 {
2510                   child->running = PS_DONE;
2511                   WSTATUS (child->status) = 0;  /* XXX -- can't find true status */
2512                 }
2513               js.c_living = 0;          /* no living child processes */
2514               if (job != NO_JOB)
2515                 {
2516                   jobs[job]->state = JDEAD;
2517                   js.c_reaped++;
2518                   js.j_ndead++;
2519                 }
2520               if (pid == ANY_PID)
2521                 {
2522                   termination_state = -1;
2523                   break;
2524                 }
2525             }
2526 #endif /* WAITPID_BROKEN */
2527         }
2528
2529       /* If the shell is interactive, and job control is disabled, see
2530          if the foreground process has died due to SIGINT and jump out
2531          of the wait loop if it has.  waitchld has already restored the
2532          old SIGINT signal handler. */
2533       if (interactive && job_control == 0)
2534         QUIT;
2535       /* Check for terminating signals and exit the shell if we receive one */
2536       CHECK_TERMSIG;
2537
2538       /* Check for a trapped signal interrupting the wait builtin and jump out */
2539       CHECK_WAIT_INTR;
2540
2541       if (pid == ANY_PID)
2542         /* XXX - could set child but we don't have a handle on what waitchld
2543            reaps.  Leave termination_state alone. */
2544         goto wait_for_return;
2545     }
2546   while (PRUNNING (child) || (job != NO_JOB && RUNNING (job)));
2547
2548   /* Restore the original SIGINT signal handler before we return. */
2549   restore_sigint_handler ();
2550
2551   /* The exit state of the command is either the termination state of the
2552      child, or the termination state of the job.  If a job, the status
2553      of the last child in the pipeline is the significant one.  If the command
2554      or job was terminated by a signal, note that value also. */
2555   termination_state = (job != NO_JOB) ? job_exit_status (job)
2556                                       : process_exit_status (child->status);
2557   last_command_exit_signal = (job != NO_JOB) ? job_exit_signal (job)
2558                                              : process_exit_signal (child->status);
2559
2560   /* XXX */
2561   if ((job != NO_JOB && JOBSTATE (job) == JSTOPPED) || WIFSTOPPED (child->status))
2562     termination_state = 128 + WSTOPSIG (child->status);
2563
2564   if (job == NO_JOB || IS_JOBCONTROL (job))
2565     {
2566       /* XXX - under what circumstances is a job not present in the jobs
2567          table (job == NO_JOB)?
2568                 1.  command substitution
2569
2570          In the case of command substitution, at least, it's probably not
2571          the right thing to give the terminal to the shell's process group,
2572          even though there is code in subst.c:command_substitute to work
2573          around it.
2574
2575          Things that don't:
2576                 $PROMPT_COMMAND execution
2577                 process substitution
2578        */
2579 #if 0
2580 if (job == NO_JOB)
2581   itrace("wait_for: job == NO_JOB, giving the terminal to shell_pgrp (%ld)", (long)shell_pgrp);
2582 #endif
2583       give_terminal_to (shell_pgrp, 0);
2584     }
2585
2586   /* If the command did not exit cleanly, or the job is just
2587      being stopped, then reset the tty state back to what it
2588      was before this command.  Reset the tty state and notify
2589      the user of the job termination only if the shell is
2590      interactive.  Clean up any dead jobs in either case. */
2591   if (job != NO_JOB)
2592     {
2593       if (interactive_shell && subshell_environment == 0)
2594         {
2595           /* This used to use `child->status'.  That's wrong, however, for
2596              pipelines.  `child' is the first process in the pipeline.  It's
2597              likely that the process we want to check for abnormal termination
2598              or stopping is the last process in the pipeline, especially if
2599              it's long-lived and the first process is short-lived.  Since we
2600              know we have a job here, we can check all the processes in this
2601              job's pipeline and see if one of them stopped or terminated due
2602              to a signal.  We might want to change this later to just check
2603              the last process in the pipeline.  If no process exits due to a
2604              signal, S is left as the status of the last job in the pipeline. */
2605           s = job_signal_status (job);
2606
2607           if (WIFSIGNALED (s) || WIFSTOPPED (s))
2608             {
2609               set_tty_state ();
2610
2611               /* If the current job was stopped or killed by a signal, and
2612                  the user has requested it, get a possibly new window size */
2613               if (check_window_size && (job == js.j_current || IS_FOREGROUND (job)))
2614                 get_new_window_size (0, (int *)0, (int *)0);
2615             }
2616           else
2617             get_tty_state ();
2618
2619           /* If job control is enabled, the job was started with job
2620              control, the job was the foreground job, and it was killed
2621              by SIGINT, then print a newline to compensate for the kernel
2622              printing the ^C without a trailing newline. */
2623           if (job_control && IS_JOBCONTROL (job) && IS_FOREGROUND (job) &&
2624                 WIFSIGNALED (s) && WTERMSIG (s) == SIGINT)
2625             {
2626               /* If SIGINT is not trapped and the shell is in a for, while,
2627                  or until loop, act as if the shell received SIGINT as
2628                  well, so the loop can be broken.  This doesn't call the
2629                  SIGINT signal handler; maybe it should. */
2630               if (signal_is_trapped (SIGINT) == 0 && (loop_level || (shell_compatibility_level > 32 && executing_list)))
2631                 ADDINTERRUPT;
2632               else
2633                 {
2634                   putchar ('\n');
2635                   fflush (stdout);
2636                 }
2637             }
2638         }
2639       else if ((subshell_environment & (SUBSHELL_COMSUB|SUBSHELL_PIPE)) && wait_sigint_received)
2640         {
2641           /* If waiting for a job in a subshell started to do command
2642              substitution or to run a pipeline element that consists of
2643              something like a while loop or a for loop, simulate getting
2644              and being killed by the SIGINT to pass the status back to our
2645              parent. */
2646           s = job_signal_status (job);
2647
2648           if (child_caught_sigint == 0 && signal_is_trapped (SIGINT) == 0)
2649             {
2650               UNBLOCK_CHILD (oset);
2651               old_sigint_handler = set_signal_handler (SIGINT, SIG_DFL);
2652               if (old_sigint_handler == SIG_IGN)
2653                 restore_sigint_handler ();
2654               else
2655                 kill (getpid (), SIGINT);
2656             }
2657         }
2658       else if (interactive_shell == 0 && IS_FOREGROUND (job) && check_window_size)
2659         get_new_window_size (0, (int *)0, (int *)0);
2660
2661       /* Moved here from set_job_status_and_cleanup, which is in the SIGCHLD
2662          signal handler path */
2663       if (DEADJOB (job) && IS_FOREGROUND (job) /*&& subshell_environment == 0*/)
2664         setjstatus (job);
2665
2666       /* If this job is dead, notify the user of the status.  If the shell
2667          is interactive, this will display a message on the terminal.  If
2668          the shell is not interactive, make sure we turn on the notify bit
2669          so we don't get an unwanted message about the job's termination,
2670          and so delete_job really clears the slot in the jobs table. */
2671       notify_and_cleanup ();
2672     }
2673
2674 wait_for_return:
2675
2676   UNBLOCK_CHILD (oset);
2677
2678   return (termination_state);
2679 }
2680
2681 /* Wait for the last process in the pipeline for JOB.  Returns whatever
2682    wait_for returns: the last process's termination state or -1 if there
2683    are no unwaited-for child processes or an error occurs. */
2684 int
2685 wait_for_job (job)
2686      int job;
2687 {
2688   pid_t pid;
2689   int r;
2690   sigset_t set, oset;
2691
2692   BLOCK_CHILD(set, oset);
2693   if (JOBSTATE (job) == JSTOPPED)
2694     internal_warning (_("wait_for_job: job %d is stopped"), job+1);
2695
2696   pid = find_last_pid (job, 0);
2697   UNBLOCK_CHILD(oset);
2698   r = wait_for (pid);
2699
2700   /* POSIX.2: we can remove the job from the jobs table if we just waited
2701      for it. */
2702   BLOCK_CHILD (set, oset);
2703   if (job != NO_JOB && jobs[job] && DEADJOB (job))
2704     jobs[job]->flags |= J_NOTIFIED;
2705   UNBLOCK_CHILD (oset);
2706
2707   return r;
2708 }
2709
2710 /* Wait for any background job started by this shell to finish.  Very
2711    similar to wait_for_background_pids().  Returns the exit status of
2712    the next exiting job, -1 if there are no background jobs.  The caller
2713    is responsible for translating -1 into the right return value. */
2714 int
2715 wait_for_any_job ()
2716 {
2717   pid_t pid;
2718   int i, r, waited_for;
2719   sigset_t set, oset;
2720
2721   if (jobs_list_frozen)
2722     return -1;
2723
2724   /* First see if there are any unnotified dead jobs that we can report on */
2725   BLOCK_CHILD (set, oset);
2726   for (i = 0; i < js.j_jobslots; i++)
2727     {
2728       if (jobs[i] && DEADJOB (i) && IS_NOTIFIED (i) == 0)
2729         {
2730 return_job:
2731           r = job_exit_status (i);
2732           notify_of_job_status ();              /* XXX */
2733           delete_job (i, 0);
2734 #if defined (COPROCESS_SUPPORT)
2735           coproc_reap ();
2736 #endif
2737           UNBLOCK_CHILD (oset);
2738           return r;
2739         }
2740     }
2741   UNBLOCK_CHILD (oset);
2742
2743   /* At this point, we have no dead jobs in the jobs table.  Wait until we
2744      get one, even if it takes multiple pids exiting. */
2745   for (waited_for = 0;;)
2746     {
2747       /* Make sure there is a background job to wait for */
2748       BLOCK_CHILD (set, oset);
2749       for (i = 0; i < js.j_jobslots; i++)
2750         if (jobs[i] && RUNNING (i) && IS_FOREGROUND (i) == 0)
2751           break;
2752       if (i == js.j_jobslots)
2753         {
2754           UNBLOCK_CHILD (oset);
2755           return -1;
2756         }
2757
2758       UNBLOCK_CHILD (oset);
2759
2760       QUIT;
2761       CHECK_TERMSIG;
2762       CHECK_WAIT_INTR;
2763
2764       errno = 0;
2765       r = wait_for (ANY_PID);   /* special sentinel value for wait_for */
2766       if (r == -1 && errno == ECHILD)
2767         mark_all_jobs_as_dead ();
2768         
2769       /* Now we see if we have any dead jobs and return the first one */
2770       BLOCK_CHILD (set, oset);
2771       for (i = 0; i < js.j_jobslots; i++)
2772         if (jobs[i] && DEADJOB (i))
2773           goto return_job;
2774       UNBLOCK_CHILD (oset);
2775     }
2776
2777   return -1;
2778 }
2779
2780 /* Print info about dead jobs, and then delete them from the list
2781    of known jobs.  This does not actually delete jobs when the
2782    shell is not interactive, because the dead jobs are not marked
2783    as notified. */
2784 void
2785 notify_and_cleanup ()
2786 {
2787   if (jobs_list_frozen)
2788     return;
2789
2790   if (interactive || interactive_shell == 0 || sourcelevel)
2791     notify_of_job_status ();
2792
2793   cleanup_dead_jobs ();
2794 }
2795
2796 /* Make dead jobs disappear from the jobs array without notification.
2797    This is used when the shell is not interactive. */
2798 void
2799 reap_dead_jobs ()
2800 {
2801   mark_dead_jobs_as_notified (0);
2802   cleanup_dead_jobs ();
2803 }
2804
2805 /* Return the next closest (chronologically) job to JOB which is in
2806    STATE.  STATE can be JSTOPPED, JRUNNING.  NO_JOB is returned if
2807    there is no next recent job. */
2808 static int
2809 most_recent_job_in_state (job, state)
2810      int job;
2811      JOB_STATE state;
2812 {
2813   register int i, result;
2814   sigset_t set, oset;
2815
2816   BLOCK_CHILD (set, oset);
2817
2818   for (result = NO_JOB, i = job - 1; i >= 0; i--)
2819     {
2820       if (jobs[i] && (JOBSTATE (i) == state))
2821         {
2822           result = i;
2823           break;
2824         }
2825     }
2826
2827   UNBLOCK_CHILD (oset);
2828
2829   return (result);
2830 }
2831
2832 /* Return the newest *stopped* job older than JOB, or NO_JOB if not
2833    found. */
2834 static int
2835 job_last_stopped (job)
2836      int job;
2837 {
2838   return (most_recent_job_in_state (job, JSTOPPED));
2839 }
2840
2841 /* Return the newest *running* job older than JOB, or NO_JOB if not
2842    found. */
2843 static int
2844 job_last_running (job)
2845      int job;
2846 {
2847   return (most_recent_job_in_state (job, JRUNNING));
2848 }
2849
2850 /* Make JOB be the current job, and make previous be useful.  Must be
2851    called with SIGCHLD blocked. */
2852 static void
2853 set_current_job (job)
2854      int job;
2855 {
2856   int candidate;
2857
2858   if (js.j_current != job)
2859     {
2860       js.j_previous = js.j_current;
2861       js.j_current = job;
2862     }
2863
2864   /* First choice for previous job is the old current job. */
2865   if (js.j_previous != js.j_current &&
2866       js.j_previous != NO_JOB &&
2867       jobs[js.j_previous] &&
2868       STOPPED (js.j_previous))
2869     return;
2870
2871   /* Second choice:  Newest stopped job that is older than
2872      the current job. */
2873   candidate = NO_JOB;
2874   if (STOPPED (js.j_current))
2875     {
2876       candidate = job_last_stopped (js.j_current);
2877
2878       if (candidate != NO_JOB)
2879         {
2880           js.j_previous = candidate;
2881           return;
2882         }
2883     }
2884
2885   /* If we get here, there is either only one stopped job, in which case it is
2886      the current job and the previous job should be set to the newest running
2887      job, or there are only running jobs and the previous job should be set to
2888      the newest running job older than the current job.  We decide on which
2889      alternative to use based on whether or not JOBSTATE(js.j_current) is
2890      JSTOPPED. */
2891
2892   candidate = RUNNING (js.j_current) ? job_last_running (js.j_current)
2893                                     : job_last_running (js.j_jobslots);
2894
2895   if (candidate != NO_JOB)
2896     {
2897       js.j_previous = candidate;
2898       return;
2899     }
2900
2901   /* There is only a single job, and it is both `+' and `-'. */
2902   js.j_previous = js.j_current;
2903 }
2904
2905 /* Make current_job be something useful, if it isn't already. */
2906
2907 /* Here's the deal:  The newest non-running job should be `+', and the
2908    next-newest non-running job should be `-'.  If there is only a single
2909    stopped job, the js.j_previous is the newest non-running job.  If there
2910    are only running jobs, the newest running job is `+' and the
2911    next-newest running job is `-'.  Must be called with SIGCHLD blocked. */
2912
2913 static void
2914 reset_current ()
2915 {
2916   int candidate;
2917
2918   if (js.j_jobslots && js.j_current != NO_JOB && jobs[js.j_current] && STOPPED (js.j_current))
2919     candidate = js.j_current;
2920   else
2921     {
2922       candidate = NO_JOB;
2923
2924       /* First choice: the previous job. */
2925       if (js.j_previous != NO_JOB && jobs[js.j_previous] && STOPPED (js.j_previous))
2926         candidate = js.j_previous;
2927
2928       /* Second choice: the most recently stopped job. */
2929       if (candidate == NO_JOB)
2930         candidate = job_last_stopped (js.j_jobslots);
2931
2932       /* Third choice: the newest running job. */
2933       if (candidate == NO_JOB)
2934         candidate = job_last_running (js.j_jobslots);
2935     }
2936
2937   /* If we found a job to use, then use it.  Otherwise, there
2938      are no jobs period. */
2939   if (candidate != NO_JOB)
2940     set_current_job (candidate);
2941   else
2942     js.j_current = js.j_previous = NO_JOB;
2943 }
2944
2945 /* Set up the job structures so we know the job and its processes are
2946    all running. */
2947 static void
2948 set_job_running (job)
2949      int job;
2950 {
2951   register PROCESS *p;
2952
2953   /* Each member of the pipeline is now running. */
2954   p = jobs[job]->pipe;
2955
2956   do
2957     {
2958       if (WIFSTOPPED (p->status))
2959         p->running = PS_RUNNING;        /* XXX - could be PS_STOPPED */
2960       p = p->next;
2961     }
2962   while (p != jobs[job]->pipe);
2963
2964   /* This means that the job is running. */
2965   JOBSTATE (job) = JRUNNING;
2966 }
2967
2968 /* Start a job.  FOREGROUND if non-zero says to do that.  Otherwise,
2969    start the job in the background.  JOB is a zero-based index into
2970    JOBS.  Returns -1 if it is unable to start a job, and the return
2971    status of the job otherwise. */
2972 int
2973 start_job (job, foreground)
2974      int job, foreground;
2975 {
2976   register PROCESS *p;
2977   int already_running;
2978   sigset_t set, oset;
2979   char *wd, *s;
2980   static TTYSTRUCT save_stty;
2981
2982   BLOCK_CHILD (set, oset);
2983
2984   if (DEADJOB (job))
2985     {
2986       internal_error (_("%s: job has terminated"), this_command_name);
2987       UNBLOCK_CHILD (oset);
2988       return (-1);
2989     }
2990
2991   already_running = RUNNING (job);
2992
2993   if (foreground == 0 && already_running)
2994     {
2995       internal_error (_("%s: job %d already in background"), this_command_name, job + 1);
2996       UNBLOCK_CHILD (oset);
2997       return (0);               /* XPG6/SUSv3 says this is not an error */
2998     }
2999
3000   wd = current_working_directory ();
3001
3002   /* You don't know about the state of this job.  Do you? */
3003   jobs[job]->flags &= ~J_NOTIFIED;
3004
3005   if (foreground)
3006     {
3007       set_current_job (job);
3008       jobs[job]->flags |= J_FOREGROUND;
3009     }
3010
3011   /* Tell the outside world what we're doing. */
3012   p = jobs[job]->pipe;
3013
3014   if (foreground == 0)
3015     {
3016       /* POSIX.2 says `bg' doesn't give any indication about current or
3017          previous job. */
3018       if (posixly_correct == 0)
3019         s = (job == js.j_current) ? "+ ": ((job == js.j_previous) ? "- " : " ");       
3020       else
3021         s = " ";
3022       printf ("[%d]%s", job + 1, s);
3023     }
3024
3025   do
3026     {
3027       printf ("%s%s",
3028                p->command ? p->command : "",
3029                p->next != jobs[job]->pipe? " | " : "");
3030       p = p->next;
3031     }
3032   while (p != jobs[job]->pipe);
3033
3034   if (foreground == 0)
3035     printf (" &");
3036
3037   if (strcmp (wd, jobs[job]->wd) != 0)
3038     printf ("   (wd: %s)", polite_directory_format (jobs[job]->wd));
3039
3040   printf ("\n");
3041
3042   /* Run the job. */
3043   if (already_running == 0)
3044     set_job_running (job);
3045
3046   /* Save the tty settings before we start the job in the foreground. */
3047   if (foreground)
3048     {
3049       get_tty_state ();
3050       save_stty = shell_tty_info;
3051       /* Give the terminal to this job. */
3052       if (IS_JOBCONTROL (job))
3053         give_terminal_to (jobs[job]->pgrp, 0);
3054     }
3055   else
3056     jobs[job]->flags &= ~J_FOREGROUND;
3057
3058   /* If the job is already running, then don't bother jump-starting it. */
3059   if (already_running == 0)
3060     {
3061       jobs[job]->flags |= J_NOTIFIED;
3062       killpg (jobs[job]->pgrp, SIGCONT);
3063     }
3064
3065   if (foreground)
3066     {
3067       pid_t pid;
3068       int st;
3069
3070       pid = find_last_pid (job, 0);
3071       UNBLOCK_CHILD (oset);
3072       st = wait_for (pid);
3073       shell_tty_info = save_stty;
3074       set_tty_state ();
3075       return (st);
3076     }
3077   else
3078     {
3079       reset_current ();
3080       UNBLOCK_CHILD (oset);
3081       return (0);
3082     }
3083 }
3084
3085 /* Give PID SIGNAL.  This determines what job the pid belongs to (if any).
3086    If PID does belong to a job, and the job is stopped, then CONTinue the
3087    job after giving it SIGNAL.  Returns -1 on failure.  If GROUP is non-null,
3088    then kill the process group associated with PID. */
3089 int
3090 kill_pid (pid, sig, group)
3091      pid_t pid;
3092      int sig, group;
3093 {
3094   register PROCESS *p;
3095   int job, result, negative;
3096   sigset_t set, oset;
3097
3098   if (pid < -1)
3099     {
3100       pid = -pid;
3101       group = negative = 1;
3102     }
3103   else
3104     negative = 0;
3105
3106   result = EXECUTION_SUCCESS;
3107   if (group)
3108     {
3109       BLOCK_CHILD (set, oset);
3110       p = find_pipeline (pid, 0, &job);
3111
3112       if (job != NO_JOB)
3113         {
3114           jobs[job]->flags &= ~J_NOTIFIED;
3115
3116           /* Kill process in backquotes or one started without job control? */
3117
3118           /* If we're passed a pid < -1, just call killpg and see what happens  */
3119           if (negative && jobs[job]->pgrp == shell_pgrp)
3120             result = killpg (pid, sig);
3121           /* If we're killing using job control notification, for example,
3122              without job control active, we have to do things ourselves. */
3123           else if (jobs[job]->pgrp == shell_pgrp)
3124             {
3125               p = jobs[job]->pipe;
3126               do
3127                 {
3128                   if (PALIVE (p) == 0)
3129                     continue;           /* avoid pid recycling problem */
3130                   kill (p->pid, sig);
3131                   if (PEXITED (p) && (sig == SIGTERM || sig == SIGHUP))
3132                     kill (p->pid, SIGCONT);
3133                   p = p->next;
3134                 }
3135               while  (p != jobs[job]->pipe);
3136             }
3137           else
3138             {
3139               result = killpg (jobs[job]->pgrp, sig);
3140               if (p && STOPPED (job) && (sig == SIGTERM || sig == SIGHUP))
3141                 killpg (jobs[job]->pgrp, SIGCONT);
3142               /* If we're continuing a stopped job via kill rather than bg or
3143                  fg, emulate the `bg' behavior. */
3144               if (p && STOPPED (job) && (sig == SIGCONT))
3145                 {
3146                   set_job_running (job);
3147                   jobs[job]->flags &= ~J_FOREGROUND;
3148                   jobs[job]->flags |= J_NOTIFIED;
3149                 }
3150             }
3151         }
3152       else
3153         result = killpg (pid, sig);
3154
3155       UNBLOCK_CHILD (oset);
3156     }
3157   else
3158     result = kill (pid, sig);
3159
3160   return (result);
3161 }
3162
3163 /* sigchld_handler () flushes at least one of the children that we are
3164    waiting for.  It gets run when we have gotten a SIGCHLD signal. */
3165 static sighandler
3166 sigchld_handler (sig)
3167      int sig;
3168 {
3169   int n, oerrno;
3170
3171   oerrno = errno;
3172   REINSTALL_SIGCHLD_HANDLER;
3173   sigchld++;
3174   n = 0;
3175   if (queue_sigchld == 0)
3176     n = waitchld (-1, 0);
3177   errno = oerrno;
3178   SIGRETURN (n);
3179 }
3180
3181 /* waitchld() reaps dead or stopped children.  It's called by wait_for and
3182    sigchld_handler, and runs until there aren't any children terminating any
3183    more.
3184    If BLOCK is 1, this is to be a blocking wait for a single child, although
3185    an arriving SIGCHLD could cause the wait to be non-blocking.  It returns
3186    the number of children reaped, or -1 if there are no unwaited-for child
3187    processes. */
3188 static int
3189 waitchld (wpid, block)
3190      pid_t wpid;
3191      int block;
3192 {
3193   WAIT status;
3194   PROCESS *child;
3195   pid_t pid;
3196
3197   int call_set_current, last_stopped_job, job, children_exited, waitpid_flags;
3198   static int wcontinued = WCONTINUED;   /* run-time fix for glibc problem */
3199
3200   call_set_current = children_exited = 0;
3201   last_stopped_job = NO_JOB;
3202
3203   do
3204     {
3205       /* We don't want to be notified about jobs stopping if job control
3206          is not active.  XXX - was interactive_shell instead of job_control */
3207       waitpid_flags = (job_control && subshell_environment == 0)
3208                         ? (WUNTRACED|wcontinued)
3209                         : 0;
3210       if (sigchld || block == 0)
3211         waitpid_flags |= WNOHANG;
3212
3213       /* Check for terminating signals and exit the shell if we receive one */
3214       CHECK_TERMSIG;
3215       /* Check for a trapped signal interrupting the wait builtin and jump out */
3216       CHECK_WAIT_INTR;
3217
3218       if (block == 1 && queue_sigchld == 0 && (waitpid_flags & WNOHANG) == 0)
3219         {
3220           internal_warning (_("waitchld: turning on WNOHANG to avoid indefinite block"));
3221           waitpid_flags |= WNOHANG;
3222         }
3223
3224       pid = WAITPID (-1, &status, waitpid_flags);
3225
3226 #if 0
3227 if (wpid != -1 && block)
3228   itrace("waitchld: blocking waitpid returns %d", pid);
3229 #endif
3230       /* WCONTINUED may be rejected by waitpid as invalid even when defined */
3231       if (wcontinued && pid < 0 && errno == EINVAL)
3232         {
3233           wcontinued = 0;
3234           continue;     /* jump back to the test and retry without WCONTINUED */
3235         }
3236
3237       /* The check for WNOHANG is to make sure we decrement sigchld only
3238          if it was non-zero before we called waitpid. */
3239       if (sigchld > 0 && (waitpid_flags & WNOHANG))
3240         sigchld--;
3241
3242       /* If waitpid returns -1 with errno == ECHILD, there are no more
3243          unwaited-for child processes of this shell. */
3244       if (pid < 0 && errno == ECHILD)
3245         {
3246           if (children_exited == 0)
3247             return -1;
3248           else
3249             break;
3250         }
3251
3252 #if 0
3253 itrace("waitchld: waitpid returns %d block = %d", pid, block);
3254 #endif
3255       /* If waitpid returns 0, there are running children.  If it returns -1,
3256          the only other error POSIX says it can return is EINTR. */
3257       CHECK_TERMSIG;
3258       CHECK_WAIT_INTR;
3259
3260       /* If waitpid returns -1/EINTR and the shell saw a SIGINT, then we
3261          assume the child has blocked or handled SIGINT.  In that case, we
3262          require the child to actually die due to SIGINT to act on the
3263          SIGINT we received; otherwise we assume the child handled it and
3264          let it go. */
3265       if (pid < 0 && errno == EINTR && wait_sigint_received)
3266         child_caught_sigint = 1;
3267
3268       if (pid <= 0)
3269         continue;       /* jumps right to the test */
3270
3271       /* If the child process did die due to SIGINT, forget our assumption
3272          that it caught or otherwise handled it. */
3273       if (WIFSIGNALED (status) && WTERMSIG (status) == SIGINT)
3274         child_caught_sigint = 0;
3275
3276       /* children_exited is used to run traps on SIGCHLD.  We don't want to
3277          run the trap if a process is just being continued. */
3278       if (WIFCONTINUED(status) == 0)
3279         {
3280           children_exited++;
3281           js.c_living--;
3282         }
3283
3284       /* Locate our PROCESS for this pid. */
3285       child = find_process (pid, 1, &job);      /* want living procs only */
3286
3287 #if defined (COPROCESS_SUPPORT)
3288       coproc_pidchk (pid, WSTATUS(status));
3289 #endif
3290
3291       /* It is not an error to have a child terminate that we did
3292          not have a record of.  This child could have been part of
3293          a pipeline in backquote substitution.  Even so, I'm not
3294          sure child is ever non-zero. */
3295       if (child == 0)
3296         {
3297           if (WIFEXITED (status) || WIFSIGNALED (status))
3298             js.c_reaped++;
3299           continue;
3300         }
3301
3302       /* Remember status, and whether or not the process is running. */
3303       child->status = status;
3304       child->running = WIFCONTINUED(status) ? PS_RUNNING : PS_DONE;
3305
3306       if (PEXITED (child))
3307         {
3308           js.c_totreaped++;
3309           if (job != NO_JOB)
3310             js.c_reaped++;
3311         }
3312         
3313       if (job == NO_JOB)
3314         continue;
3315
3316       call_set_current += set_job_status_and_cleanup (job);
3317
3318       if (STOPPED (job))
3319         last_stopped_job = job;
3320       else if (DEADJOB (job) && last_stopped_job == job)
3321         last_stopped_job = NO_JOB;
3322     }
3323   while ((sigchld || block == 0) && pid > (pid_t)0);
3324
3325   /* If a job was running and became stopped, then set the current
3326      job.  Otherwise, don't change a thing. */
3327   if (call_set_current)
3328     {
3329       if (last_stopped_job != NO_JOB)
3330         set_current_job (last_stopped_job);
3331       else
3332         reset_current ();
3333     }
3334
3335   /* Call a SIGCHLD trap handler for each child that exits, if one is set. */
3336   if (job_control && signal_is_trapped (SIGCHLD) && children_exited &&
3337       trap_list[SIGCHLD] != (char *)IGNORE_SIG)
3338     {
3339       if (posixly_correct && this_shell_builtin && this_shell_builtin == wait_builtin)
3340         {
3341           interrupt_immediately = 0;
3342           trap_handler (SIGCHLD);       /* set pending_traps[SIGCHLD] */
3343           wait_signal_received = SIGCHLD;
3344           /* If we're in a signal handler, let CHECK_WAIT_INTR pick it up;
3345              run_pending_traps will call run_sigchld_trap later  */
3346           if (sigchld == 0)
3347             longjmp (wait_intr_buf, 1);
3348         }
3349       /* If not in posix mode and not executing the wait builtin, queue the
3350          signal for later handling.  Run the trap immediately if we are
3351          executing the wait builtin, but don't break out of `wait'. */
3352       else if (sigchld) /* called from signal handler */
3353         queue_sigchld_trap (children_exited);
3354       else if (running_trap)
3355         queue_sigchld_trap (children_exited);
3356       else if (this_shell_builtin == wait_builtin)
3357         run_sigchld_trap (children_exited);     /* XXX */
3358       else
3359         queue_sigchld_trap (children_exited);
3360     }
3361
3362   /* We have successfully recorded the useful information about this process
3363      that has just changed state.  If we notify asynchronously, and the job
3364      that this process belongs to is no longer running, then notify the user
3365      of that fact now. */
3366   if (asynchronous_notification && interactive)
3367     notify_of_job_status ();
3368
3369   return (children_exited);
3370 }
3371
3372 /* Set the status of JOB and perform any necessary cleanup if the job is
3373    marked as JDEAD.
3374
3375    Currently, the cleanup activity is restricted to handling any SIGINT
3376    received while waiting for a foreground job to finish. */
3377 static int
3378 set_job_status_and_cleanup (job)
3379      int job;
3380 {
3381   PROCESS *child;
3382   int tstatus, job_state, any_stopped, any_tstped, call_set_current;
3383   SigHandler *temp_handler;
3384
3385   child = jobs[job]->pipe;
3386   jobs[job]->flags &= ~J_NOTIFIED;
3387
3388   call_set_current = 0;
3389
3390   /*
3391    * COMPUTE JOB STATUS
3392    */
3393
3394   /* If all children are not running, but any of them is  stopped, then
3395      the job is stopped, not dead. */
3396   job_state = any_stopped = any_tstped = 0;
3397   do
3398     {
3399       job_state |= PRUNNING (child);
3400 #if 0
3401       if (PEXITED (child) && (WIFSTOPPED (child->status)))
3402 #else
3403       /* Only checking for WIFSTOPPED now, not for PS_DONE */
3404       if (PSTOPPED (child))
3405 #endif
3406         {
3407           any_stopped = 1;
3408           any_tstped |= job_control && (WSTOPSIG (child->status) == SIGTSTP);
3409         }
3410       child = child->next;
3411     }
3412   while (child != jobs[job]->pipe);
3413
3414   /* If job_state != 0, the job is still running, so don't bother with
3415      setting the process exit status and job state unless we're
3416      transitioning from stopped to running. */
3417   if (job_state != 0 && JOBSTATE(job) != JSTOPPED)
3418     return 0;
3419
3420   /*
3421    * SET JOB STATUS
3422    */
3423
3424   /* The job is either stopped or dead.  Set the state of the job accordingly. */
3425   if (any_stopped)
3426     {
3427       jobs[job]->state = JSTOPPED;
3428       jobs[job]->flags &= ~J_FOREGROUND;
3429       call_set_current++;
3430       /* Suspending a job with SIGTSTP breaks all active loops. */
3431       if (any_tstped && loop_level)
3432         breaking = loop_level;
3433     }
3434   else if (job_state != 0)      /* was stopped, now running */
3435     {
3436       jobs[job]->state = JRUNNING;
3437       call_set_current++;
3438     }
3439   else
3440     {
3441       jobs[job]->state = JDEAD;
3442       js.j_ndead++;
3443
3444 #if 0
3445       if (IS_FOREGROUND (job))
3446         setjstatus (job);
3447 #endif
3448
3449       /* If this job has a cleanup function associated with it, call it
3450          with `cleanarg' as the single argument, then set the function
3451          pointer to NULL so it is not inadvertently called twice.  The
3452          cleanup function is responsible for deallocating cleanarg. */
3453       if (jobs[job]->j_cleanup)
3454         {
3455           (*jobs[job]->j_cleanup) (jobs[job]->cleanarg);
3456           jobs[job]->j_cleanup = (sh_vptrfunc_t *)NULL;
3457         }
3458     }
3459
3460   /*
3461    * CLEANUP
3462    *
3463    * Currently, we just do special things if we got a SIGINT while waiting
3464    * for a foreground job to complete
3465    */
3466
3467   if (JOBSTATE (job) == JDEAD)
3468     {
3469       /* If we're running a shell script and we get a SIGINT with a
3470          SIGINT trap handler, but the foreground job handles it and
3471          does not exit due to SIGINT, run the trap handler but do not
3472          otherwise act as if we got the interrupt. */
3473       if (wait_sigint_received && interactive_shell == 0 &&
3474           child_caught_sigint && IS_FOREGROUND (job) &&
3475           signal_is_trapped (SIGINT))
3476         {
3477           int old_frozen;
3478           wait_sigint_received = 0;
3479           last_command_exit_value = process_exit_status (child->status);
3480
3481           old_frozen = jobs_list_frozen;
3482           jobs_list_frozen = 1;
3483           tstatus = maybe_call_trap_handler (SIGINT);
3484           jobs_list_frozen = old_frozen;
3485         }
3486
3487       /* If the foreground job is killed by SIGINT when job control is not
3488          active, we need to perform some special handling.
3489
3490          The check of wait_sigint_received is a way to determine if the
3491          SIGINT came from the keyboard (in which case the shell has already
3492          seen it, and wait_sigint_received is non-zero, because keyboard
3493          signals are sent to process groups) or via kill(2) to the foreground
3494          process by another process (or itself).  If the shell did receive the
3495          SIGINT, it needs to perform normal SIGINT processing. */
3496       else if (wait_sigint_received &&
3497               child_caught_sigint == 0 &&
3498               IS_FOREGROUND (job) && IS_JOBCONTROL (job) == 0)
3499         {
3500           int old_frozen;
3501
3502           wait_sigint_received = 0;
3503
3504           /* If SIGINT is trapped, set the exit status so that the trap
3505              handler can see it. */
3506           if (signal_is_trapped (SIGINT))
3507             last_command_exit_value = process_exit_status (child->status);
3508
3509           /* If the signal is trapped, let the trap handler get it no matter
3510              what and simply return if the trap handler returns.
3511             maybe_call_trap_handler() may cause dead jobs to be removed from
3512             the job table because of a call to execute_command.  We work
3513             around this by setting JOBS_LIST_FROZEN. */
3514           old_frozen = jobs_list_frozen;
3515           jobs_list_frozen = 1;
3516           tstatus = maybe_call_trap_handler (SIGINT);
3517           jobs_list_frozen = old_frozen;
3518           if (tstatus == 0 && old_sigint_handler != INVALID_SIGNAL_HANDLER)
3519             {
3520               /* wait_sigint_handler () has already seen SIGINT and
3521                  allowed the wait builtin to jump out.  We need to
3522                  call the original SIGINT handler, if necessary.  If
3523                  the original handler is SIG_DFL, we need to resend
3524                  the signal to ourselves. */
3525
3526               temp_handler = old_sigint_handler;
3527
3528               /* Bogus.  If we've reset the signal handler as the result
3529                  of a trap caught on SIGINT, then old_sigint_handler
3530                  will point to trap_handler, which now knows nothing about
3531                  SIGINT (if we reset the sighandler to the default).
3532                  In this case, we have to fix things up.  What a crock. */
3533               if (temp_handler == trap_handler && signal_is_trapped (SIGINT) == 0)
3534                   temp_handler = trap_to_sighandler (SIGINT);
3535                 restore_sigint_handler ();
3536               if (temp_handler == SIG_DFL)
3537                 termsig_handler (SIGINT);       /* XXX */
3538               else if (temp_handler != SIG_IGN)
3539                 (*temp_handler) (SIGINT);
3540             }
3541         }
3542     }
3543
3544   return call_set_current;
3545 }
3546
3547 /* Build the array of values for the $PIPESTATUS variable from the set of
3548    exit statuses of all processes in the job J. */
3549 static void
3550 setjstatus (j)
3551      int j;
3552 {
3553 #if defined (ARRAY_VARS)
3554   register int i;
3555   register PROCESS *p;
3556
3557   for (i = 1, p = jobs[j]->pipe; p->next != jobs[j]->pipe; p = p->next, i++)
3558     ;
3559   i++;
3560   if (statsize < i)
3561     {
3562       pstatuses = (int *)xrealloc (pstatuses, i * sizeof (int));
3563       statsize = i;
3564     }
3565   i = 0;
3566   p = jobs[j]->pipe;
3567   do
3568     {
3569       pstatuses[i++] = process_exit_status (p->status);
3570       p = p->next;
3571     }
3572   while (p != jobs[j]->pipe);
3573
3574   pstatuses[i] = -1;    /* sentinel */
3575   set_pipestatus_array (pstatuses, i);
3576 #endif
3577 }
3578
3579 void
3580 run_sigchld_trap (nchild)
3581      int nchild;
3582 {
3583   char *trap_command;
3584   int i;
3585
3586   /* Turn off the trap list during the call to parse_and_execute ()
3587      to avoid potentially infinite recursive calls.  Preserve the
3588      values of last_command_exit_value, last_made_pid, and the_pipeline
3589      around the execution of the trap commands. */
3590   trap_command = savestring (trap_list[SIGCHLD]);
3591
3592   begin_unwind_frame ("SIGCHLD trap");
3593   unwind_protect_int (last_command_exit_value);
3594   unwind_protect_int (last_command_exit_signal);
3595   unwind_protect_var (last_made_pid);
3596   unwind_protect_int (interrupt_immediately);
3597   unwind_protect_int (jobs_list_frozen);
3598   unwind_protect_pointer (the_pipeline);
3599   unwind_protect_pointer (subst_assign_varlist);
3600
3601   /* We have to add the commands this way because they will be run
3602      in reverse order of adding.  We don't want maybe_set_sigchld_trap ()
3603      to reference freed memory. */
3604   add_unwind_protect (xfree, trap_command);
3605   add_unwind_protect (maybe_set_sigchld_trap, trap_command);
3606
3607   subst_assign_varlist = (WORD_LIST *)NULL;
3608   the_pipeline = (PROCESS *)NULL;
3609
3610   running_trap = SIGCHLD + 1;
3611
3612   set_impossible_sigchld_trap ();
3613   jobs_list_frozen = 1;
3614   for (i = 0; i < nchild; i++)
3615     {
3616 #if 0
3617       interrupt_immediately = 1;
3618 #endif
3619       parse_and_execute (savestring (trap_command), "trap", SEVAL_NOHIST|SEVAL_RESETLINE);
3620     }
3621
3622   run_unwind_frame ("SIGCHLD trap");
3623   running_trap = 0;
3624 }
3625
3626 /* Function to call when you want to notify people of changes
3627    in job status.  This prints out all jobs which are pending
3628    notification to stderr, and marks those printed as already
3629    notified, thus making them candidates for cleanup. */
3630 static void
3631 notify_of_job_status ()
3632 {
3633   register int job, termsig;
3634   char *dir;
3635   sigset_t set, oset;
3636   WAIT s;
3637
3638   if (jobs == 0 || js.j_jobslots == 0)
3639     return;
3640
3641   if (old_ttou != 0)
3642     {
3643       sigemptyset (&set);
3644       sigaddset (&set, SIGCHLD);
3645       sigaddset (&set, SIGTTOU);
3646       sigemptyset (&oset);
3647       sigprocmask (SIG_BLOCK, &set, &oset);
3648     }
3649   else
3650     queue_sigchld++;
3651
3652   /* XXX could use js.j_firstj here */
3653   for (job = 0, dir = (char *)NULL; job < js.j_jobslots; job++)
3654     {
3655       if (jobs[job] && IS_NOTIFIED (job) == 0)
3656         {
3657           s = raw_job_exit_status (job);
3658           termsig = WTERMSIG (s);
3659
3660           /* POSIX.2 says we have to hang onto the statuses of at most the
3661              last CHILD_MAX background processes if the shell is running a
3662              script.  If the shell is running a script, either from a file
3663              or standard input, don't print anything unless the job was
3664              killed by a signal. */
3665           if (startup_state == 0 && WIFSIGNALED (s) == 0 &&
3666                 ((DEADJOB (job) && IS_FOREGROUND (job) == 0) || STOPPED (job)))
3667             continue;
3668           
3669 #if 0
3670           /* If job control is disabled, don't print the status messages.
3671              Mark dead jobs as notified so that they get cleaned up.  If
3672              startup_state == 2, we were started to run `-c command', so
3673              don't print anything. */
3674           if ((job_control == 0 && interactive_shell) || startup_state == 2)
3675 #else
3676           /* If job control is disabled, don't print the status messages.
3677              Mark dead jobs as notified so that they get cleaned up.  If
3678              startup_state == 2 and subshell_environment has the
3679              SUBSHELL_COMSUB bit turned on, we were started to run a command
3680              substitution, so don't print anything. */
3681           if ((job_control == 0 && interactive_shell) ||
3682               (startup_state == 2 && (subshell_environment & SUBSHELL_COMSUB)))
3683 #endif
3684             {
3685               /* POSIX.2 compatibility:  if the shell is not interactive,
3686                  hang onto the job corresponding to the last asynchronous
3687                  pid until the user has been notified of its status or does
3688                  a `wait'. */
3689               if (DEADJOB (job) && (interactive_shell || (find_last_pid (job, 0) != last_asynchronous_pid)))
3690                 jobs[job]->flags |= J_NOTIFIED;
3691               continue;
3692             }
3693
3694           /* Print info on jobs that are running in the background,
3695              and on foreground jobs that were killed by anything
3696              except SIGINT (and possibly SIGPIPE). */
3697           switch (JOBSTATE (job))
3698             {
3699             case JDEAD:
3700               if (interactive_shell == 0 && termsig && WIFSIGNALED (s) &&
3701                   termsig != SIGINT &&
3702 #if defined (DONT_REPORT_SIGTERM)
3703                   termsig != SIGTERM &&
3704 #endif
3705 #if defined (DONT_REPORT_SIGPIPE)
3706                   termsig != SIGPIPE &&
3707 #endif
3708                   signal_is_trapped (termsig) == 0)
3709                 {
3710                   /* Don't print `0' for a line number. */
3711                   fprintf (stderr, _("%s: line %d: "), get_name_for_error (), (line_number == 0) ? 1 : line_number);
3712                   pretty_print_job (job, JLIST_NONINTERACTIVE, stderr);
3713                 }
3714               else if (IS_FOREGROUND (job))
3715                 {
3716 #if !defined (DONT_REPORT_SIGPIPE)
3717                   if (termsig && WIFSIGNALED (s) && termsig != SIGINT)
3718 #else
3719                   if (termsig && WIFSIGNALED (s) && termsig != SIGINT && termsig != SIGPIPE)
3720 #endif
3721                     {
3722                       fprintf (stderr, "%s", j_strsignal (termsig));
3723
3724                       if (WIFCORED (s))
3725                         fprintf (stderr, _(" (core dumped)"));
3726
3727                       fprintf (stderr, "\n");
3728                     }
3729                 }
3730               else if (job_control)     /* XXX job control test added */
3731                 {
3732                   if (dir == 0)
3733                     dir = current_working_directory ();
3734                   pretty_print_job (job, JLIST_STANDARD, stderr);
3735                   if (dir && strcmp (dir, jobs[job]->wd) != 0)
3736                     fprintf (stderr,
3737                              _("(wd now: %s)\n"), polite_directory_format (dir));
3738                 }
3739
3740               jobs[job]->flags |= J_NOTIFIED;
3741               break;
3742
3743             case JSTOPPED:
3744               fprintf (stderr, "\n");
3745               if (dir == 0)
3746                 dir = current_working_directory ();
3747               pretty_print_job (job, JLIST_STANDARD, stderr);
3748               if (dir && (strcmp (dir, jobs[job]->wd) != 0))
3749                 fprintf (stderr,
3750                          _("(wd now: %s)\n"), polite_directory_format (dir));
3751               jobs[job]->flags |= J_NOTIFIED;
3752               break;
3753
3754             case JRUNNING:
3755             case JMIXED:
3756               break;
3757
3758             default:
3759               programming_error ("notify_of_job_status");
3760             }
3761         }
3762     }
3763   if (old_ttou != 0)
3764     sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
3765   else
3766     queue_sigchld--;
3767 }
3768
3769 /* Initialize the job control mechanism, and set up the tty stuff. */
3770 int
3771 initialize_job_control (force)
3772      int force;
3773 {
3774   pid_t t;
3775   int t_errno;
3776
3777   t_errno = -1;
3778   shell_pgrp = getpgid (0);
3779
3780   if (shell_pgrp == -1)
3781     {
3782       sys_error (_("initialize_job_control: getpgrp failed"));
3783       exit (1);
3784     }
3785
3786   /* We can only have job control if we are interactive unless we force it. */
3787   if (interactive == 0 && force == 0)
3788     {
3789       job_control = 0;
3790       original_pgrp = NO_PID;
3791       shell_tty = fileno (stderr);
3792     }
3793   else
3794     {
3795       shell_tty = -1;
3796
3797       /* If forced_interactive is set, we skip the normal check that stderr
3798          is attached to a tty, so we need to check here.  If it's not, we
3799          need to see whether we have a controlling tty by opening /dev/tty,
3800          since trying to use job control tty pgrp manipulations on a non-tty
3801          is going to fail. */
3802       if (forced_interactive && isatty (fileno (stderr)) == 0)
3803         shell_tty = open ("/dev/tty", O_RDWR|O_NONBLOCK);
3804
3805       /* Get our controlling terminal.  If job_control is set, or
3806          interactive is set, then this is an interactive shell no
3807          matter where fd 2 is directed. */
3808       if (shell_tty == -1)
3809         shell_tty = dup (fileno (stderr));      /* fd 2 */
3810
3811       if (shell_tty != -1)
3812         shell_tty = move_to_high_fd (shell_tty, 1, -1);
3813
3814       /* Compensate for a bug in systems that compiled the BSD
3815          rlogind with DEBUG defined, like NeXT and Alliant. */
3816       if (shell_pgrp == 0)
3817         {
3818           shell_pgrp = getpid ();
3819           setpgid (0, shell_pgrp);
3820           tcsetpgrp (shell_tty, shell_pgrp);
3821         }
3822
3823       while ((terminal_pgrp = tcgetpgrp (shell_tty)) != -1)
3824         {
3825           if (shell_pgrp != terminal_pgrp)
3826             {
3827               SigHandler *ottin;
3828
3829               ottin = set_signal_handler(SIGTTIN, SIG_DFL);
3830               kill (0, SIGTTIN);
3831               set_signal_handler (SIGTTIN, ottin);
3832               continue;
3833             }
3834           break;
3835         }
3836
3837       if (terminal_pgrp == -1)
3838         t_errno = errno;
3839
3840       /* Make sure that we are using the new line discipline. */
3841       if (set_new_line_discipline (shell_tty) < 0)
3842         {
3843           sys_error (_("initialize_job_control: line discipline"));
3844           job_control = 0;
3845         }
3846       else
3847         {
3848           original_pgrp = shell_pgrp;
3849           shell_pgrp = getpid ();
3850
3851           if ((original_pgrp != shell_pgrp) && (setpgid (0, shell_pgrp) < 0))
3852             {
3853               sys_error (_("initialize_job_control: setpgid"));
3854               shell_pgrp = original_pgrp;
3855             }
3856
3857           job_control = 1;
3858
3859           /* If (and only if) we just set our process group to our pid,
3860              thereby becoming a process group leader, and the terminal
3861              is not in the same process group as our (new) process group,
3862              then set the terminal's process group to our (new) process
3863              group.  If that fails, set our process group back to what it
3864              was originally (so we can still read from the terminal) and
3865              turn off job control.  */
3866           if (shell_pgrp != original_pgrp && shell_pgrp != terminal_pgrp)
3867             {
3868               if (give_terminal_to (shell_pgrp, 0) < 0)
3869                 {
3870                   t_errno = errno;
3871                   setpgid (0, original_pgrp);
3872                   shell_pgrp = original_pgrp;
3873                   errno = t_errno;
3874                   sys_error (_("cannot set terminal process group (%d)"), shell_pgrp);
3875                   job_control = 0;
3876                 }
3877             }
3878
3879           if (job_control && ((t = tcgetpgrp (shell_tty)) == -1 || t != shell_pgrp))
3880             {
3881               if (t_errno != -1)
3882                 errno = t_errno;
3883               sys_error (_("cannot set terminal process group (%d)"), t);
3884               job_control = 0;
3885             }
3886         }
3887       if (job_control == 0)
3888         internal_error (_("no job control in this shell"));
3889     }
3890
3891   if (shell_tty != fileno (stderr))
3892     SET_CLOSE_ON_EXEC (shell_tty);
3893
3894   set_signal_handler (SIGCHLD, sigchld_handler);
3895
3896   change_flag ('m', job_control ? '-' : '+');
3897
3898   if (interactive)
3899     get_tty_state ();
3900
3901   if (js.c_childmax < 0)
3902     js.c_childmax = getmaxchild ();
3903   if (js.c_childmax < 0)
3904     js.c_childmax = DEFAULT_CHILD_MAX;
3905
3906   return job_control;
3907 }
3908
3909 #ifdef DEBUG
3910 void
3911 debug_print_pgrps ()
3912 {
3913   itrace("original_pgrp = %ld shell_pgrp = %ld terminal_pgrp = %ld",
3914          (long)original_pgrp, (long)shell_pgrp, (long)terminal_pgrp);
3915   itrace("tcgetpgrp(%d) -> %ld, getpgid(0) -> %ld",
3916          shell_tty, (long)tcgetpgrp (shell_tty), (long)getpgid(0));
3917 }
3918 #endif
3919
3920 /* Set the line discipline to the best this system has to offer.
3921    Return -1 if this is not possible. */
3922 static int
3923 set_new_line_discipline (tty)
3924      int tty;
3925 {
3926 #if defined (NEW_TTY_DRIVER)
3927   int ldisc;
3928
3929   if (ioctl (tty, TIOCGETD, &ldisc) < 0)
3930     return (-1);
3931
3932   if (ldisc != NTTYDISC)
3933     {
3934       ldisc = NTTYDISC;
3935
3936       if (ioctl (tty, TIOCSETD, &ldisc) < 0)
3937         return (-1);
3938     }
3939   return (0);
3940 #endif /* NEW_TTY_DRIVER */
3941
3942 #if defined (TERMIO_TTY_DRIVER)
3943 #  if defined (TERMIO_LDISC) && (NTTYDISC)
3944   if (ioctl (tty, TCGETA, &shell_tty_info) < 0)
3945     return (-1);
3946
3947   if (shell_tty_info.c_line != NTTYDISC)
3948     {
3949       shell_tty_info.c_line = NTTYDISC;
3950       if (ioctl (tty, TCSETAW, &shell_tty_info) < 0)
3951         return (-1);
3952     }
3953 #  endif /* TERMIO_LDISC && NTTYDISC */
3954   return (0);
3955 #endif /* TERMIO_TTY_DRIVER */
3956
3957 #if defined (TERMIOS_TTY_DRIVER)
3958 #  if defined (TERMIOS_LDISC) && defined (NTTYDISC)
3959   if (tcgetattr (tty, &shell_tty_info) < 0)
3960     return (-1);
3961
3962   if (shell_tty_info.c_line != NTTYDISC)
3963     {
3964       shell_tty_info.c_line = NTTYDISC;
3965       if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0)
3966         return (-1);
3967     }
3968 #  endif /* TERMIOS_LDISC && NTTYDISC */
3969   return (0);
3970 #endif /* TERMIOS_TTY_DRIVER */
3971
3972 #if !defined (NEW_TTY_DRIVER) && !defined (TERMIO_TTY_DRIVER) && !defined (TERMIOS_TTY_DRIVER)
3973   return (-1);
3974 #endif
3975 }
3976
3977 /* Setup this shell to handle C-C, etc. */
3978 void
3979 initialize_job_signals ()
3980 {
3981   if (interactive)
3982     {
3983       set_signal_handler (SIGINT, sigint_sighandler);
3984       set_signal_handler (SIGTSTP, SIG_IGN);
3985       set_signal_handler (SIGTTOU, SIG_IGN);
3986       set_signal_handler (SIGTTIN, SIG_IGN);
3987     }
3988   else if (job_control)
3989     {
3990       old_tstp = set_signal_handler (SIGTSTP, sigstop_sighandler);
3991       old_ttin = set_signal_handler (SIGTTIN, sigstop_sighandler);
3992       old_ttou = set_signal_handler (SIGTTOU, sigstop_sighandler);
3993     }
3994   /* Leave these things alone for non-interactive shells without job
3995      control. */
3996 }
3997
3998 /* Here we handle CONT signals. */
3999 static sighandler
4000 sigcont_sighandler (sig)
4001      int sig;
4002 {
4003   initialize_job_signals ();
4004   set_signal_handler (SIGCONT, old_cont);
4005   kill (getpid (), SIGCONT);
4006
4007   SIGRETURN (0);
4008 }
4009
4010 /* Here we handle stop signals while we are running not as a login shell. */
4011 static sighandler
4012 sigstop_sighandler (sig)
4013      int sig;
4014 {
4015   set_signal_handler (SIGTSTP, old_tstp);
4016   set_signal_handler (SIGTTOU, old_ttou);
4017   set_signal_handler (SIGTTIN, old_ttin);
4018
4019   old_cont = set_signal_handler (SIGCONT, sigcont_sighandler);
4020
4021   give_terminal_to (shell_pgrp, 0);
4022
4023   kill (getpid (), sig);
4024
4025   SIGRETURN (0);
4026 }
4027
4028 /* Give the terminal to PGRP.  */
4029 int
4030 give_terminal_to (pgrp, force)
4031      pid_t pgrp;
4032      int force;
4033 {
4034   sigset_t set, oset;
4035   int r, e;
4036
4037   r = 0;
4038   if (job_control || force)
4039     {
4040       sigemptyset (&set);
4041       sigaddset (&set, SIGTTOU);
4042       sigaddset (&set, SIGTTIN);
4043       sigaddset (&set, SIGTSTP);
4044       sigaddset (&set, SIGCHLD);
4045       sigemptyset (&oset);
4046       sigprocmask (SIG_BLOCK, &set, &oset);
4047
4048       if (tcsetpgrp (shell_tty, pgrp) < 0)
4049         {
4050           /* Maybe we should print an error message? */
4051 #if 0
4052           sys_error ("tcsetpgrp(%d) failed: pid %ld to pgrp %ld",
4053             shell_tty, (long)getpid(), (long)pgrp);
4054 #endif
4055           r = -1;
4056           e = errno;
4057         }
4058       else
4059         terminal_pgrp = pgrp;
4060       sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
4061     }
4062
4063   if (r == -1)
4064     errno = e;
4065
4066   return r;
4067 }
4068
4069 /* Give terminal to NPGRP iff it's currently owned by OPGRP.  FLAGS are the
4070    flags to pass to give_terminal_to(). */
4071 static int
4072 maybe_give_terminal_to (opgrp, npgrp, flags)
4073      pid_t opgrp, npgrp;
4074      int flags;
4075 {
4076   int tpgrp;
4077
4078   tpgrp = tcgetpgrp (shell_tty);
4079   if (tpgrp < 0 && errno == ENOTTY)
4080     return -1;
4081   if (tpgrp == npgrp)
4082     {
4083       terminal_pgrp = npgrp;
4084       return 0;
4085     }
4086   else if (tpgrp != opgrp)
4087     {
4088 #if defined (DEBUG)
4089       internal_warning ("maybe_give_terminal_to: terminal pgrp == %d shell pgrp = %d new pgrp = %d", tpgrp, opgrp, npgrp);
4090 #endif
4091       return -1;
4092     }
4093   else
4094     return (give_terminal_to (npgrp, flags));     
4095 }
4096
4097 /* Clear out any jobs in the job array.  This is intended to be used by
4098    children of the shell, who should not have any job structures as baggage
4099    when they start executing (forking subshells for parenthesized execution
4100    and functions with pipes are the two that spring to mind).  If RUNNING_ONLY
4101    is nonzero, only running jobs are removed from the table. */
4102 void
4103 delete_all_jobs (running_only)
4104      int running_only;
4105 {
4106   register int i;
4107   sigset_t set, oset;
4108
4109   BLOCK_CHILD (set, oset);
4110
4111   /* XXX - need to set j_lastj, j_firstj appropriately if running_only != 0. */
4112   if (js.j_jobslots)
4113     {
4114       js.j_current = js.j_previous = NO_JOB;
4115
4116       /* XXX could use js.j_firstj here */
4117       for (i = 0; i < js.j_jobslots; i++)
4118         {
4119 #if defined (DEBUG)
4120           if (i < js.j_firstj && jobs[i])
4121             itrace("delete_all_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
4122           if (i > js.j_lastj && jobs[i])
4123             itrace("delete_all_jobs: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
4124 #endif
4125           if (jobs[i] && (running_only == 0 || (running_only && RUNNING(i))))
4126             delete_job (i, DEL_WARNSTOPPED);
4127         }
4128       if (running_only == 0)
4129         {
4130           free ((char *)jobs);
4131           js.j_jobslots = 0;
4132           js.j_firstj = js.j_lastj = js.j_njobs = 0;
4133         }
4134     }
4135
4136   if (running_only == 0)
4137     bgp_clear ();
4138
4139   UNBLOCK_CHILD (oset);
4140 }
4141
4142 /* Mark all jobs in the job array so that they don't get a SIGHUP when the
4143    shell gets one.  If RUNNING_ONLY is nonzero, mark only running jobs. */
4144 void
4145 nohup_all_jobs (running_only)
4146      int running_only;
4147 {
4148   register int i;
4149   sigset_t set, oset;
4150
4151   BLOCK_CHILD (set, oset);
4152
4153   if (js.j_jobslots)
4154     {
4155       /* XXX could use js.j_firstj here */
4156       for (i = 0; i < js.j_jobslots; i++)
4157         if (jobs[i] && (running_only == 0 || (running_only && RUNNING(i))))
4158           nohup_job (i);
4159     }
4160
4161   UNBLOCK_CHILD (oset);
4162 }
4163
4164 int
4165 count_all_jobs ()
4166 {
4167   int i, n;
4168   sigset_t set, oset;
4169
4170   /* This really counts all non-dead jobs. */
4171   BLOCK_CHILD (set, oset);
4172   /* XXX could use js.j_firstj here */
4173   for (i = n = 0; i < js.j_jobslots; i++)
4174     {
4175 #if defined (DEBUG)
4176       if (i < js.j_firstj && jobs[i])
4177         itrace("count_all_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
4178       if (i > js.j_lastj && jobs[i])
4179         itrace("count_all_jobs: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
4180 #endif
4181       if (jobs[i] && DEADJOB(i) == 0)
4182         n++;
4183     }
4184   UNBLOCK_CHILD (oset);
4185   return n;
4186 }
4187
4188 static void
4189 mark_all_jobs_as_dead ()
4190 {
4191   register int i;
4192   sigset_t set, oset;
4193
4194   if (js.j_jobslots == 0)
4195     return;
4196
4197   BLOCK_CHILD (set, oset);
4198
4199   /* XXX could use js.j_firstj here */
4200   for (i = 0; i < js.j_jobslots; i++)
4201     if (jobs[i])
4202       {
4203         jobs[i]->state = JDEAD;
4204         js.j_ndead++;
4205       }
4206
4207   UNBLOCK_CHILD (oset);
4208 }
4209
4210 /* Mark all dead jobs as notified, so delete_job () cleans them out
4211    of the job table properly.  POSIX.2 says we need to save the
4212    status of the last CHILD_MAX jobs, so we count the number of dead
4213    jobs and mark only enough as notified to save CHILD_MAX statuses. */
4214 static void
4215 mark_dead_jobs_as_notified (force)
4216      int force;
4217 {
4218   register int i, ndead, ndeadproc;
4219   sigset_t set, oset;
4220
4221   if (js.j_jobslots == 0)
4222     return;
4223
4224   BLOCK_CHILD (set, oset);
4225
4226   /* If FORCE is non-zero, we don't have to keep CHILD_MAX statuses
4227      around; just run through the array. */
4228   if (force)
4229     {
4230     /* XXX could use js.j_firstj here */
4231       for (i = 0; i < js.j_jobslots; i++)
4232         {
4233           if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid)))
4234             jobs[i]->flags |= J_NOTIFIED;
4235         }
4236       UNBLOCK_CHILD (oset);
4237       return;
4238     }
4239
4240   /* Mark enough dead jobs as notified to keep CHILD_MAX processes left in the
4241      array with the corresponding not marked as notified.  This is a better
4242      way to avoid pid aliasing and reuse problems than keeping the POSIX-
4243      mandated CHILD_MAX jobs around.  delete_job() takes care of keeping the
4244      bgpids list regulated. */
4245           
4246   /* Count the number of dead jobs */
4247   /* XXX could use js.j_firstj here */
4248   for (i = ndead = ndeadproc = 0; i < js.j_jobslots; i++)
4249     {
4250 #if defined (DEBUG)
4251       if (i < js.j_firstj && jobs[i])
4252         itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
4253       if (i > js.j_lastj && jobs[i])
4254         itrace("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
4255 #endif
4256       if (jobs[i] && DEADJOB (i))
4257         {
4258           ndead++;
4259           ndeadproc += processes_in_job (i);
4260         }
4261     }
4262
4263 #ifdef DEBUG
4264 # if 0
4265   if (ndeadproc != js.c_reaped)
4266     itrace("mark_dead_jobs_as_notified: ndeadproc (%d) != js.c_reaped (%d)", ndeadproc, js.c_reaped);
4267 # endif
4268   if (ndead != js.j_ndead)
4269     itrace("mark_dead_jobs_as_notified: ndead (%d) != js.j_ndead (%d)", ndead, js.j_ndead);
4270 #endif
4271
4272   if (js.c_childmax < 0)
4273     js.c_childmax = getmaxchild ();
4274   if (js.c_childmax < 0)
4275     js.c_childmax = DEFAULT_CHILD_MAX;
4276
4277   /* Don't do anything if the number of dead processes is less than CHILD_MAX
4278      and we're not forcing a cleanup. */
4279   if (ndeadproc <= js.c_childmax)
4280     {
4281       UNBLOCK_CHILD (oset);
4282       return;
4283     }
4284
4285 #if 0
4286 itrace("mark_dead_jobs_as_notified: child_max = %d ndead = %d ndeadproc = %d", js.c_childmax, ndead, ndeadproc);
4287 #endif
4288
4289   /* Mark enough dead jobs as notified that we keep CHILD_MAX jobs in
4290      the list.  This isn't exactly right yet; changes need to be made
4291      to stop_pipeline so we don't mark the newer jobs after we've
4292      created CHILD_MAX slots in the jobs array.  This needs to be
4293      integrated with a way to keep the jobs array from growing without
4294      bound.  Maybe we wrap back around to 0 after we reach some max
4295      limit, and there are sufficient job slots free (keep track of total
4296      size of jobs array (js.j_jobslots) and running count of number of jobs
4297      in jobs array.  Then keep a job index corresponding to the `oldest job'
4298      and start this loop there, wrapping around as necessary.  In effect,
4299      we turn the list into a circular buffer. */
4300   /* XXX could use js.j_firstj here */
4301   for (i = 0; i < js.j_jobslots; i++)
4302     {
4303       if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid)))
4304         {
4305 #if defined (DEBUG)
4306           if (i < js.j_firstj && jobs[i])
4307             itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
4308           if (i > js.j_lastj && jobs[i])
4309             itrace("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
4310 #endif
4311           /* If marking this job as notified would drop us down below
4312              child_max, don't mark it so we can keep at least child_max
4313              statuses.  XXX -- need to check what Posix actually says
4314              about keeping statuses. */
4315           if ((ndeadproc -= processes_in_job (i)) <= js.c_childmax)
4316             break;
4317           jobs[i]->flags |= J_NOTIFIED;
4318         }
4319     }
4320
4321   UNBLOCK_CHILD (oset);
4322 }
4323
4324 /* Here to allow other parts of the shell (like the trap stuff) to
4325    freeze and unfreeze the jobs list. */
4326 void
4327 freeze_jobs_list ()
4328 {
4329   jobs_list_frozen = 1;
4330 }
4331
4332 void
4333 unfreeze_jobs_list ()
4334 {
4335   jobs_list_frozen = 0;
4336 }
4337
4338 /* Allow or disallow job control to take place.  Returns the old value
4339    of job_control. */
4340 int
4341 set_job_control (arg)
4342      int arg;
4343 {
4344   int old;
4345
4346   old = job_control;
4347   job_control = arg;
4348
4349   /* If we're turning on job control, reset pipeline_pgrp so make_child will
4350      put new child processes into the right pgrp */
4351   if (job_control != old && job_control)
4352     pipeline_pgrp = 0;
4353
4354   return (old);
4355 }
4356
4357 /* Turn off all traces of job control.  This is run by children of the shell
4358    which are going to do shellsy things, like wait (), etc. */
4359 void
4360 without_job_control ()
4361 {
4362   stop_making_children ();
4363   start_pipeline ();
4364 #if defined (PGRP_PIPE)
4365   sh_closepipe (pgrp_pipe);
4366 #endif
4367   delete_all_jobs (0);
4368   set_job_control (0);
4369 }
4370
4371 /* If this shell is interactive, terminate all stopped jobs and
4372    restore the original terminal process group.  This is done
4373    before the `exec' builtin calls shell_execve. */
4374 void
4375 end_job_control ()
4376 {
4377   if (interactive_shell)                /* XXX - should it be interactive? */
4378     {
4379       terminate_stopped_jobs ();
4380
4381       if (original_pgrp >= 0)
4382         give_terminal_to (original_pgrp, 1);
4383     }
4384
4385   if (original_pgrp >= 0)
4386     setpgid (0, original_pgrp);
4387 }
4388
4389 /* Restart job control by closing shell tty and reinitializing.  This is
4390    called after an exec fails in an interactive shell and we do not exit. */
4391 void
4392 restart_job_control ()
4393 {
4394   if (shell_tty != -1)
4395     close (shell_tty);
4396   initialize_job_control (0);
4397 }
4398
4399 void
4400 set_maxchild (nchild)
4401      int nchild;
4402 {
4403   static int lmaxchild = -1;
4404
4405   if (lmaxchild < 0)
4406     lmaxchild = getmaxchild ();
4407   if (lmaxchild < 0)
4408     lmaxchild = DEFAULT_CHILD_MAX;
4409
4410   /* Clamp value we set.  Minimum is what Posix requires, maximum is defined
4411      above as MAX_CHILD_MAX. */
4412   if (nchild < lmaxchild)
4413     nchild = lmaxchild;
4414   else if (nchild > MAX_CHILD_MAX)
4415     nchild = MAX_CHILD_MAX;
4416
4417   js.c_childmax = nchild;
4418 }
4419
4420 /* Set the handler to run when the shell receives a SIGCHLD signal. */
4421 void
4422 set_sigchld_handler ()
4423 {
4424   set_signal_handler (SIGCHLD, sigchld_handler);
4425 }
4426
4427 #if defined (PGRP_PIPE)
4428 /* Read from the read end of a pipe.  This is how the process group leader
4429    blocks until all of the processes in a pipeline have been made. */
4430 static void
4431 pipe_read (pp)
4432      int *pp;
4433 {
4434   char ch;
4435
4436   if (pp[1] >= 0)
4437     {
4438       close (pp[1]);
4439       pp[1] = -1;
4440     }
4441
4442   if (pp[0] >= 0)
4443     {
4444       while (read (pp[0], &ch, 1) == -1 && errno == EINTR)
4445         ;
4446     }
4447 }
4448
4449 /* Functional interface closes our local-to-job-control pipes. */
4450 void
4451 close_pgrp_pipe ()
4452 {
4453   sh_closepipe (pgrp_pipe);
4454 }
4455
4456 void
4457 save_pgrp_pipe (p, clear)
4458      int *p;
4459      int clear;
4460 {
4461   p[0] = pgrp_pipe[0];
4462   p[1] = pgrp_pipe[1];
4463   if (clear)
4464     pgrp_pipe[0] = pgrp_pipe[1] = -1;
4465 }
4466
4467 void
4468 restore_pgrp_pipe (p)
4469      int *p;
4470 {
4471   pgrp_pipe[0] = p[0];
4472   pgrp_pipe[1] = p[1];
4473 }
4474
4475 #endif /* PGRP_PIPE */