filter.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdbool.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
#include "filter.h"
#include "signal2.h"

pid_t filter_create_fd(const char *cmd, FILE **fp_in, FILE **fp_out, FILE **fp_err,
                       int fdin, int fdout, int fderr, char **envlist)
{
  int pin[2], pout[2], perr[2], pid;
 
  /* Create pipes for each requested I/O stream (stdin, stdout, stderr).
   * On failure, clean up any already-created pipes before returning. */
  if (fp_in)
  {
    *fp_in = NULL;
    if (pipe(pin) == -1)
      return -1;
  }
 
  if (fp_out)
  {
    *fp_out = NULL;
    if (pipe(pout) == -1)
    {
      if (fp_in)
      {
        close(pin[0]);
        close(pin[1]);
      }
      return -1;
    }
  }
 
  if (fp_err)
  {
    *fp_err = NULL;
    if (pipe(perr) == -1)
    {
      if (fp_in)
      {
        close(pin[0]);
        close(pin[1]);
      }
      if (fp_out)
      {
        close(pout[0]);
        close(pout[1]);
      }
      return -1;
    }
  }
 
  /* Block signals around fork to prevent child from inheriting pending signals */
  mutt_sig_block_system();
 
  pid = fork();
  if (pid == 0)
  {
    /* Child process: redirect pipe ends to stdin/stdout/stderr via dup2(),
     * or use the caller-supplied file descriptors as fallback */
    mutt_sig_unblock_system(false);
    mutt_sig_reset_child_signals();
 
    if (fp_in)
    {
      close(pin[1]);
      dup2(pin[0], 0);
      close(pin[0]);
    }
    else if (fdin != -1)
    {
      dup2(fdin, 0);
      close(fdin);
    }
 
    if (fp_out)
    {
      close(pout[0]);
      dup2(pout[1], 1);
      close(pout[1]);
    }
    else if (fdout != -1)
    {
      dup2(fdout, 1);
      close(fdout);
    }
 
    if (fp_err)
    {
      close(perr[0]);
      dup2(perr[1], 2);
      close(perr[1]);
    }
    else if (fderr != -1)
    {
      dup2(fderr, 2);
      close(fderr);
    }
 
    execle(EXEC_SHELL, "sh", "-c", cmd, NULL, envlist);
    _exit(127);
  }
  else if (pid == -1)
  {
    /* Fork failed: clean up all pipe file descriptors */
    mutt_sig_unblock_system(true);
 
    if (fp_in)
    {
      close(pin[0]);
      close(pin[1]);
    }
 
    if (fp_out)
    {
      close(pout[0]);
      close(pout[1]);
    }
 
    if (fp_err)
    {
      close(perr[0]);
      close(perr[1]);
    }
 
    return -1;
  }
 
  /* Parent process: close the child's end of each pipe and wrap
   * the parent's end in a FILE stream for the caller */
  if (fp_out)
  {
    close(pout[1]);
    *fp_out = fdopen(pout[0], "r");
  }
 
  if (fp_in)
  {
    close(pin[0]);
    *fp_in = fdopen(pin[1], "w");
  }
 
  if (fp_err)
  {
    close(perr[1]);
    *fp_err = fdopen(perr[0], "r");
  }
 
  return pid;
}

pid_t filter_create(const char *cmd, FILE **fp_in, FILE **fp_out, FILE **fp_err, char **envlist)
{
  return filter_create_fd(cmd, fp_in, fp_out, fp_err, -1, -1, -1, envlist);
}

int filter_wait(pid_t pid)
{
  int rc = 0;
 
  waitpid(pid, &rc, 0);
  mutt_sig_unblock_system(true);
  rc = WIFEXITED(rc) ? WEXITSTATUS(rc) : -1;
 
  return rc;
}