vos/corelibs/typechain/handlers/externaltypehandler.cc

Go to the documentation of this file.

/* $Id: externaltypehandler.cc,v 1.9 2003/05/29 23:24:47 reed Exp $ */

/*

    Copyright (C) 2001, 2002 Reed Hedges <reed@zerohour.net>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library 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
    Lesser General Public License for more details.

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

*/

#include "../typehandler.hh"
#include "externaltypehandler.hh"

#ifdef WIN32 // we don't have that forking stuff...


int ExternalTypeHandler::exec_child_io(char *cmd, char **argv, FILE **readpipe, FILE **writepipe)
{
   return (-1);
}

ExternalTypeHandler::ExternalTypeHandler(string name, char **decmd, char **encmd, string file_ext) : TypeHandler(name, file_ext) {
    encoder_command = 0;
}

ExternalTypeHandler::ExternalTypeHandler(string name, char *decmd, char *encmd, string file_ext) : TypeHandler(name, file_ext)  {
    encoder_command = 0;
}

ExternalTypeHandler::~ExternalTypeHandler() {
}

void ExternalTypeHandler::run_external(string& data, char **command) {
   throw TypeChain::DecodeError( "ExternalTypeHandler not supported on this platform", "(external)" );
}


#else

/* for spawning program & piping data to and fro. */
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <errno.h>

/* exec_child_io, a private method of ExternalTypeHandler:
   Exec the named cmd as a child process, setting two pipes to communicate
   with the process, and returning the child's process ID.
   argv is a NULL-terminated list of arguments to pass to the command.  If
   there are no arguments, you can pass NULL. (this is the point of having
   both cmd and argv.)
   argv[0] is (by convention) the name of the command itself.
   I/O is block buffered by default (use setvbuf to change it).
   Use *readpipe  for reading the output of cmd, and *writepipe to write input
    to it.
   Uses execvp(), so you don't need to specify the full path: the PATH
   environment variable will be searched. Uses vfork() to fork, to conserve
   memory.

   example usage:
       childpid = exec_child_io("rot13", NULL, &in, &out);
       fputs("hello, world\n", out);
       fflush(out);
       fgets( buff, 50, in);
       printf("rot13(hello, world): %s\n", buff);
       fputc(EOF, out);
       waitpid(childpid);
*/

int ExternalTypeHandler::exec_child_io(char *cmd, char **argv, FILE **readpipe, FILE **writepipe)
{
   int childpid, pipe1[2], pipe2[2];


   /* create two pipes. */
   if ((pipe(pipe1) < 0) || (pipe(pipe2) < 0)) {
       fprintf(stderr, "error creating pipes: %s\n", strerror(errno));
       return -1;
   }

   /* fork. */
   if ((childpid = vfork()) < 0) {
       fprintf(stderr, "error forking!: %s\n", strerror(errno));
       return -1;
   } else if (childpid > 0) {

       /* We are parent. */

        // XXX TODO: waitpid(childpid, status, WNOHANG) and then check status??

       /* close reading half of pipe1, writing half of pipe2 */
       close(pipe1[0]);
       close(pipe2[1]);


       /* Write to child is pipe1[1], read from child is pipe2[0].  */

       *readpipe = fdopen(pipe2[0],"r");
       *writepipe = fdopen(pipe1[1],"w");

       /* set buffering mode on writepipe */
       //setlinebuf(*writepipe);

       return childpid;

   } else {

       /* We are the child. close writing half of pipe1, reading half of pipe2. */
       close(pipe1[1]);
       close(pipe2[0]);

       /* Read from parent is pipe1[0], write to  parent is pipe2[1].  the dup2
        * calls make the proper parts of the two pipes the same as this
        * process' stdin and stdout. when we exec, this will make the piping
        * work the way we want.*/

       dup2(pipe1[0],0);
       dup2(pipe2[1],1);
       close(pipe1[0]);
       close(pipe2[1]);

       /* exec  the command */


       if (execvp(cmd, argv) < 0) {
           //perror("execvp");
           fprintf(stderr, "external type handler: error executing command: %s\n", strerror(errno));
           close(pipe1[0]);
           close(pipe1[1]);
           close(pipe2[0]);
           close(pipe2[1]);

           // BUG: this will cause a SIGPIPE in the parent process!
           fprintf(stderr, "exiting.\n");
           exit(-1);
        }

       /* This half Never returns: send kill signal or EOF or something, and waitpid() for it in the parent. */
       return(-1);
   }

   return (-1);
}



ExternalTypeHandler::ExternalTypeHandler(string name, char **decmd, char **encmd, string file_ext) : TypeHandler(name, file_ext) {


   // duplicate decmd.
   int n = 0;
   int i;
   for(n = 0; decmd[n] != 0; n++);
   decoder_command = (char**)malloc(n * sizeof(char*) + 1);
   for(i = 0; i < n; i++) {
       decoder_command[i] = strdup(decmd[i]);
   }

   if(encmd != 0) {
       // duplicate encmd
       for(n = 0; encmd[n] != 0; n++);
       encoder_command = (char**)malloc(n * sizeof(char*) + 1);
       for(i = 0; i < n; i++) {
       encoder_command[i] = strdup(encmd[i]);
       }
   }
   else
       encoder_command = 0;
}

ExternalTypeHandler::ExternalTypeHandler(string name, char *decmd, char *encmd, string file_ext) : TypeHandler(name, file_ext)  {
   decoder_command = (char **)malloc(2 * sizeof(char*));
   decoder_command[0] = strdup(decmd);
   decoder_command[1] = 0;
   if(encmd != 0) {
       encoder_command = (char **)malloc(2 * sizeof(char*));
       encoder_command[0] = strdup(encmd);
       encoder_command[1] = 0;
   } else {
       encoder_command = 0;
   }
   needtofreecommands = true;
}

ExternalTypeHandler::~ExternalTypeHandler() {
   if(needtofreecommands) {
       if(decoder_command != 0) {
           while(*decoder_command != 0)
               free(*(decoder_command++));
           free(decoder_command);
           }
           if(encoder_command != 0) {
           while(*encoder_command != 0)
               free(*(encoder_command++));
           free(encoder_command);
       }
   }
}

void ExternalTypeHandler::run_external(string& data, char **command) {

   int child_pid;
   FILE* out;
   FILE* in;
   int c;

   printf("ExternalTypeHandler: running %s...\n", command[0]);
   child_pid = exec_child_io(command[0], command, &in, &out);

   if (child_pid < 0) {
       fprintf(stderr, "error executing external program '%s': %s\n", command[0], strerror(errno));
       throw TypeChain::DecodeError( string("Error executing external program ") + command[0] + ": " + strerror(errno), "(external)" );
   }
    else {
       fputs(data.c_str(), out);
       fclose(out);
       waitpid(child_pid, NULL, WNOHANG);
       data = "";
       while( (c = getc(in)) != EOF ) {
           data += c;
       }
       fclose(in);
   }
}

#endif


void ExternalTypeHandler::decode(string& data, TypeParams& params) {
   run_external(data, decoder_command);
}

void ExternalTypeHandler::encode(string& data, TypeParams& params) {
    run_external(data, encoder_command);
}

---