exit (1);
        }
      else
        {
          /* This is the parent process.  */
          p->pid = pid;
          if (shell_is_interactive)
            {
              if (!j->pgid)
                j->pgid = pid;
              setpgid (pid, j->pgid);
            }
        }

      /* Clean up after pipes.  */
      if (infile != j->stdin)
        close (infile);
      if (outfile != j->stdout)
        close (outfile);
      infile = mypipe[0];
    }
  
  format_job_info (j, "launched");

  if (!shell_is_interactive)
    wait_for_job (j);
  else if (foreground)
    put_job_in_foreground (j, 0);
  else
    put_job_in_background (j, 0);
}
</PRE>
<P>
<H3><A NAME="SEC421" HREF="library_toc.html#SEC421" tppabs="http://www.cs.utah.edu/dept/old/texinfo/glibc-manual-0.02/library_toc.html#SEC421">Foreground and Background</A></H3>
<P>
Now let's consider what actions must be taken by the shell when it
launches a job into the foreground, and how this differs from what
must be done when a background job is launched.
<A NAME="IDX1753"></A>
<P>
When a foreground job is launched, the shell must first give it access
to the controlling terminal by calling <CODE>tcsetpgrp</CODE>.  Then, the
shell should wait for processes in that process group to terminate or
stop.  This is discussed in more detail in section <A HREF="library_24.html#SEC422" tppabs="http://www.cs.utah.edu/dept/old/texinfo/glibc-manual-0.02/library_24.html#SEC422">Stopped and Terminated Jobs</A>.
<P>
When all of the processes in the group have either completed or stopped,
the shell should regain control of the terminal for its own process
group by calling <CODE>tcsetpgrp</CODE> again.  Since stop signals caused by
I/O from a background process or a SUSP character typed by the user
are sent to the process group, normally all the processes in the job
stop together.
<P>
The foreground job may have left the terminal in a strange state, so the
shell should restore its own saved terminal modes before continuing.  In
case the job is merely been stopped, the shell should first save the
current terminal modes so that it can restore them later if the job is
continued.  The functions for dealing with terminal modes are
<CODE>tcgetattr</CODE> and <CODE>tcsetattr</CODE>; these are described in
section <A HREF="library_16.html#SEC272" tppabs="http://www.cs.utah.edu/dept/old/texinfo/glibc-manual-0.02/library_16.html#SEC272">Terminal Modes</A>.
<P>
Here is the sample shell's function for doing all of this.
<P>
<PRE>
/* Put job <VAR>j</VAR> in the foreground.  If <VAR>cont</VAR> is nonzero,
   restore the saved terminal modes and send the process group a
   <CODE>SIGCONT</CODE> signal to wake it up before we block.  */

void
put_job_in_foreground (job *j, int cont)
{
  /* Put the job into the foreground.  */
  tcsetpgrp (shell_terminal, j-&#62;pgid);

  /* Send the job a continue signal, if necessary.  */
  if (cont)
    {
      tcsetattr (shell_terminal, TCSADRAIN, &#38;j-&#62;tmodes);
      if (kill (- j-&#62;pgid, SIGCONT) &#60; 0)
        perror ("kill (SIGCONT)");
    }
  
  /* Wait for it to report.  */
  wait_for_job (j);
    
  /* Put the shell back in the foreground.  */
  tcsetpgrp (shell_terminal, shell_pgid);
    
  /* Restore the shell's terminal modes.  */
  tcgetattr (shell_terminal, &#38;j-&#62;tmodes);
  tcsetattr (shell_terminal, TCSADRAIN, &#38;shell_tmodes);
}
</PRE>
<A NAME="IDX1754"></A>
<P>
If the process group is launched as a background job, the shell should
remain in the foreground itself and continue to read commands from
the terminal.  
<P>
In the sample shell, there is not much that needs to be done to put
a job into the background.  Here is the function it uses:
<P>
<PRE>
/* Put a job in the background.  If the cont argument is true, send
   the process group a <CODE>SIGCONT</CODE> signal to wake it up.  */

void
put_job_in_background (job *j, int cont)
{
  /* Send the job a continue signal, if necessary.  */
  if (cont)
    if (kill (-j-&#62;pgid, SIGCONT) &#60; 0)
      perror ("kill (SIGCONT)");
}
</PRE>
<P>
<H3><A NAME="SEC422" HREF="library_toc.html#SEC422" tppabs="http://www.cs.utah.edu/dept/old/texinfo/glibc-manual-0.02/library_toc.html#SEC422">Stopped and Terminated Jobs</A></H3>
<A NAME="IDX1755"></A>
<A NAME="IDX1756"></A>
<P>
When a foreground process is launched, the shell must block until all of
the processes in that job have either terminated or stopped.  It can do
this by calling the <CODE>waitpid</CODE> function; see section <A HREF="library_23.html#SEC407" tppabs="http://www.cs.utah.edu/dept/old/texinfo/glibc-manual-0.02/library_23.html#SEC407">Process Completion</A>.  Use the <CODE>WUNTRACED</CODE> option so that status is reported
for processes that stop as well as processes that terminate.
<P>
The shell must also check on the status of background jobs so that it
can report terminated and stopped jobs to the user; this can be done by
calling <CODE>waitpid</CODE> with the <CODE>WNOHANG</CODE> option.  A good place to
put a such a check for terminated and stopped jobs is just before
prompting for a new command.
<A NAME="IDX1757"></A>
<P>
The shell can also receive asynchronous notification that there is
status information available for a child process by establishing a
handler for <CODE>SIGCHLD</CODE> signals.  See section <A HREF="library_21.html#SEC330" tppabs="http://www.cs.utah.edu/dept/old/texinfo/glibc-manual-0.02/library_21.html#SEC330">Signal Handling</A>.
<P>
In the sample shell program, the <CODE>SIGCHLD</CODE> signal is normally
ignored.  This is to avoid reentrancy problems involving the global data
structures the shell manipulates.  But at specific times when the shell
is not using these data structures--such as when it is waiting for
input on the terminal--it makes sense to enable a handler for
<CODE>SIGCHLD</CODE>.  The same function that is used to do the synchronous
status checks (<CODE>do_job_notification</CODE>, in this case) can also be
called from within this handler.
<P>
Here are the parts of the sample shell program that deal with checking
the status of jobs and reporting the information to the user.
<P>
<PRE>
/* Store the status of the process <VAR>pid</VAR> that was returned by waitpid.
   Return 0 if all went well, nonzero otherwise.  */

int
mark_process_status (pid_t pid, int status)
{
  job *j;
  process *p;

  if (pid &#62; 0)
    {
      /* Update the record for the process.  */
      for (j = first_job; j; j = j-&#62;next)
        for (p = j-&#62;first_process; p; p = p-&#62;next)
          if (p-&#62;pid == pid)
            {
              p-&#62;status = status;
              if (WIFSTOPPED (status))
                p-&#62;stopped = 1;
              else
                {
                  p-&#62;completed = 1;
                  if (WIFSIGNALED (status))
                    fprintf (stderr, "%d: Terminated by signal %d.\n",
                             (int) pid, WTERMSIG (p-&#62;status));
                }
              return 0;
             }
      fprintf (stderr, "No child process %d.\n", pid);
      return -1;
    }
  else if (pid == 0 || errno == ECHILD)
    /* No processes ready to report.  */
    return -1;
  else {
    /* Other weird errors.  */
    perror ("waitpid");
    return -1;
  }
}

/* Check for processes that have status information available,
   without blocking.  */

void
update_status (void)
{
  int status;
  pid_t pid;
  
  do
    pid = waitpid (WAIT_ANY, &#38;status, WUNTRACED|WNOHANG);
  while (!mark_process_status (pid, status));
}

/* Check for processes that have status information available,
   blocking until all processes in the given job have reported.  */

void
wait_for_job (job *j)
{
  int status;
  pid_t pid;
  
  do
    pid = waitpid (WAIT_ANY, &#38;status, WUNTRACED);
  while (!mark_process_status (pid, status) 
         &#38;&#38; !job_is_stopped (j) 
         &#38;&#38; !job_is_completed (j));
}

/* Format information about job status for the user to look at.  */

void
format_job_info (job *j, const char *status)
{
  fprintf (stderr, "%ld (%s): %s\n", (long)j-&#62;pgid, status, j-&#62;command);
}

/* Notify the user about stopped or terminated jobs.
   Delete terminated jobs from the active job list.  */

void
do_job_notification (void)
{
  job *j, *jlast, *jnext;
  process *p;

  /* Update status information for child processes.  */
  update_status ();
  
  jlast = NULL;
  for (j = first_job; j; j = jnext)
    {
      jnext = j-&#62;next;

      /* If all processes have completed, tell the user the job has
         completed and delete it from the list of active jobs.  */
      if (job_is_completed (j)) {
        format_job_info (j, "completed");
        if (jlast)
          jlast-&#62;next = jnext;
        else
          first_job = jnext;
        free_job (j);
      }

      /* Notify the user about stopped jobs,
         marking them so that we won't do this more than once.  */
      else if (job_is_stopped (j) &#38;&#38; !j-&#62;notified) {
        format_job_info (j, "stopped");
        j-&#62;notified = 1;
        jlast = j;
      }

      /* Don't say anything about jobs that are still running.  */
      else
        jlast = j;
    }
}
</PRE>
<P>
<H3><A NAME="SEC423" HREF="library_toc.html#SEC423" tppabs="http://www.cs.utah.edu/dept/old/texinfo/glibc-manual-0.02/library_toc.html#SEC423">Continuing Stopped Jobs</A></H3>
<A NAME="IDX1758"></A>
<P>
The shell can continue a stopped job by sending a <CODE>SIGCONT</CODE> signal
to its process group.  If the job is being continued in the foreground,
the shell should first invoke <CODE>tcsetpgrp</CODE> to give the job access to
the terminal, and restore the saved terminal settings.  After continuing
a job in the foreground, the shell should wait for the job to stop or
complete, as if the job had just been launched in the foreground.
<P>
The sample shell program uses the same set of
functions---<CODE>put_job_in_foreground</CODE> and
<CODE>put_job_in_background</CODE>---to handle both newly created and