pfopen.c

Go to the documentation of this file.

/*--------------------------------------------------------------------------

   Copyright (c) 2006-2007, Intellectual Reserve, Inc. All rights reserved.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2 as
   published by the Free Software Foundation.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  --------------------------------------------------------------------------*/

#include "pfopen.h"

#include "dnxDebug.h"

#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/wait.h>
#include <assert.h>

#define elemcount(x) (sizeof(x)/sizeof(*(x)))

//----------------------------------------------------------------------------

PFILE * pfopen(const char * cmdstring, const char * type)
{
   PFILE * pfile;
   int pid, eno, i, pfd[6];

   // only allow "r" or "w"
   assert((type[0] == 'r' || type[0] == 'w') &&  type[1] == 0);

   // Allocate a PFILE structure
   if ((pfile = (PFILE *)xcalloc(1, sizeof *pfile)) == 0)
   {
      errno = ENOMEM;
      return 0;
   }

   // set all descriptors to unallocated state and open pipes
   memset(pfd, -1, sizeof pfd);
   if (pipe(pfd) < 0 || pipe(pfd+2) < 0
         || (*type == 'w' && pipe(pfd+4) < 0))
      goto errout;

   // create buffered channels for parent ends of pipes
   if ((pfile->fp[0] = fdopen(pfd[0], "r")) == 0
         || (pfile->fp[1] = fdopen(pfd[2], "r")) == 0
         || (*type == 'w' && (pfile->fp[2] = fdopen(pfd[5], "w")) == 0))
      goto errout;

   // fork and check for error
   if ((pid = fork()) < 0) 
      goto errout;

   // child process?
   if (pid == 0)
   {
      // make child its own process group so parent can signal child subtree
      setpgid(0, 0);

      // close parent (read) ends, dup child (write) ends (if needed)
      fclose(pfile->fp[0]);
      fclose(pfile->fp[1]);
      if (pfd[1] != STDOUT_FILENO) 
      {
         dup2(pfd[1], STDOUT_FILENO);
         close(pfd[1]);
      }
      if (pfd[3] != STDERR_FILENO) 
      {
         dup2(pfd[3], STDERR_FILENO);
         close(pfd[3]);
      }

      // if also sending input from parent to child...
      if (*type == 'w')
      {
         // close parent (write) end, dup child (read) end (if needed)
         fclose(pfile->fp[2]);
         if (pfd[4] != STDIN_FILENO) 
         {
            dup2(pfd[4], STDIN_FILENO);
            close(pfd[4]);
         }
      } 

      execl("/bin/sh", "/bin/sh", "-c", cmdstring, (char *)0);

      _exit(127); // if we get here, we got an exec error
   }

   // parent continues in this process...

   // close child ends of pipes
   close(pfd[1]);
   close(pfd[3]);
   if (*type == 'w')
      close(pfd[4]);

   // save child process pid
   pfile->pid = pid;

   return pfile;

errout:
   eno = errno;  // save errno (close changes it)

   // close buffered parent FILEs (also closes descriptors)
   if (pfile->fp[0] != 0)
      fclose(pfile->fp[0]), pfd[0] = -1;
   if (pfile->fp[1] != 0)
      fclose(pfile->fp[1]), pfd[2] = -1;
   if (pfile->fp[2] != 0)
      fclose(pfile->fp[2]), pfd[5] = -1;

   // close any remaining unbuffered descriptors
   for (i = 0; i < elemcount(pfd); i++)
      if (pfd[i] >= 0)
         close(pfd[i]);

   xfree(pfile);
   errno = eno;
   return 0;
}

//----------------------------------------------------------------------------

int pfclose(PFILE * pfile)
{
   int stat;

   if (pfile == 0)
   {
      errno = EINVAL;
      return -1;     /* popen() has never been called */
   }

   if (pfile->fp[0] != 0)
      fclose(pfile->fp[0]);
   if (pfile->fp[1] != 0)
      fclose(pfile->fp[1]);
   if (pfile->fp[2] != 0)
      fclose(pfile->fp[2]);
   
   xfree(pfile);

   while (waitpid(pfile->pid, &stat, 0) < 0)
      if (errno != EINTR)
         return -1;  /* error other than EINTR from waitpid() */
   
   return stat;      /* return child's termination status */
}

//----------------------------------------------------------------------------

int pfkill(PFILE * pfile, int sig)
{
   assert(pfile);

   /* send specified signal to child process group */
   return kill(-(pfile->pid), sig);
}

/*--------------------------------------------------------------------------
                                 TEST MAIN

   From within dnx/client, compile with GNU tools using this command line:

      gcc -DDEBUG -DPFOPEN_TEST -g -O0 -o pfopenTest -I../common \
         ../common/dnxError.c pfopen.c

   Alternatively, a heap check may be done with the following command line:

      gcc -DDEBUG -DDEBUG_HEAP -DPFOPEN_TEST -g -O0 -o pfopenTest \
         -I../common ../common/dnxError.c pfopen.c

  --------------------------------------------------------------------------*/

#ifdef PFOPEN_TEST

#include "utesthelp.h"
#include "dnxError.h"

// Implementation Note: m4 echos back on STDOUT whatever it reads on
// STDIN; when killed (SIGTERM), it writes "Terminated\n" to STDERR.

char * program = "m4";
char * text = "This is a test\n";
char * errtext = "Terminated\n";
int verbose;

int main(int argc, char ** argv)
{
   PFILE * pf;
   FILE * fin, * fout, * ferr;
   char buf[128];

   verbose = argc > 1 ? 1 : 0;

   CHECK_NONZERO(pf = pfopen(program, "w"));

   fin  = PF_IN(pf);
   fout = PF_OUT(pf);
   ferr = PF_ERR(pf);

   fprintf(fin, text);
   fflush(fin);
   close(fileno(fin));

   fgets(buf, sizeof buf, fout);

   CHECK_ZERO(strcmp(text, buf));

   CHECK_ZERO(pfclose(pf));

#ifdef DEBUG_HEAP
   CHECK_ZERO(dnxCheckHeap());
#endif

   return 0;
}

#endif   /* PFOPEN_TEST */

/*--------------------------------------------------------------------------*/