vos/corelibs/typehelper/typehelper.cc

Go to the documentation of this file.

/* $Id: typehelper.cc,v 1.19 2003/07/24 05:46:04 tetron Exp $ */

/*
    This file is part of the Virtual Object System of
    the Interreality project (http://interreality.org).

    Copyright (C) 2001-2003 Peter Amstutz <tetron@interreality.org>

    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
*/

#if defined(_WIN32) && defined(_MSC_VER)
# include <vos/corelibs/vosconfig-vc7.h>
#else
# include <vos/corelibs/vosconfig.h>
#endif

#include <iostream>
#include <fstream>
#include <errno.h>
#include <sys/types.h>
#include <stdarg.h>

#ifdef HAVE_SYS_WAIT_H
#include <sys/wait.h>
#endif

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

#ifdef WIN32
#include <windows.h>
#include <process.h>
#endif

#include <string.h>
#include <stdio.h>

#include "typehelper.hh"

#ifdef HAVE_GNOME_VFS
#include <libgnomevfs/gnome-vfs-application-registry.h>
#endif

multimap<string, TypeHelper> helpers;
multimap<int, ProcessEndCallback*> callbacks;
set<int> processes;

void TypeHelper::addHelper(const string& line)
{
    string objtype;
    string command;
    TypeHelper th;

    // skip comments and empty lines
    if(line == "" || line[0] == '#')
        return;

    // split each half around '='
    string::size_type sep = line.find('=');
    if(sep == line.npos) {
        //LOG("terangreal", 1, "Warning: syntax error in \"" << filename << "\" on line " << lineno << ".");
        return;
    }

    objtype = line.substr(0, sep);
    command = line.substr(sep+1);

    // is command null?
    if(command == "") return;

    // remove whitespace from objtype
    string::size_type sp;
    while( (sp = objtype.find(" ")) != objtype.npos) objtype.erase(sp, 1);
    while( (sp = objtype.find("\t")) != objtype.npos) objtype.erase(sp, 1);

    // remove leading whitespace from command
    string::size_type nsp = command.find_first_not_of(" \t");
    if(nsp != command.npos) {
        command.erase(0, nsp);
    }

    // set type
    string::size_type c = objtype.find_first_of('(');
    if(c != string::npos) th.type = objtype.substr(c, objtype.size() - c - 1);

    // set command
    th.setCommand(command);

    // add to map
    helpers.insert(pair<string, TypeHelper>(objtype, th));
}

void TypeHelper::init(string filename)
{
    bool error = true;
    ifstream input;
    input.open(filename.c_str());
    if(input.is_open()) {
        error = false;
    }
    if(error) {
        cerr << "libtypehelper: Warning: could not find helper apps config file " << filename << endl;
        return;
    }


    char s[256];
    for(int lineno = 0; input.getline(s, sizeof(s)); lineno++) {
        addHelper(s);
    }
}

deque<TypeHelper> TypeHelper::findDataHelpers(const string& datatype, const string& tempfile) {
    string type = "property(";
    type += datatype + ")";
    pair<multimap<string, TypeHelper>::iterator, multimap<string, TypeHelper>::iterator> i =  helpers.equal_range(type);
    deque<TypeHelper> ret;
    for(; i.first != i.second; i.first++) {
        ret.push_back((*(i.first)).second);
        ret.back().runFunc = DATA;
        ret.back().target = tempfile;
    }

#ifdef HAVE_GNOME_VFS
    GList* gl = gnome_vfs_application_registry_get_applications(datatype.c_str());
    GList* gliter;

    for(gliter = gl; gliter; gliter = gliter->next) {
        TypeHelper th;
        th.type = datatype;
        th.parameters.push_back((char*)gliter->data);
        th.parameters.push_back("%f");
        th.target = tempfile;
        th.runFunc = DATA;
        ret.push_back(th);
    }
#endif


    return ret;
}

deque<TypeHelper> TypeHelper::findVobjectHelpers(const set<string>& types, const string& path) {
    deque<TypeHelper> ret;
    for(set<string>::const_iterator t = types.begin(); t != types.end(); t++) {
        string type = "vobject(";
        type += *t + ")";
        pair<multimap<string, TypeHelper>::iterator, multimap<string, TypeHelper>::iterator> i =  helpers.equal_range(type);
        for(; i.first != i.second; i.first++) {
            ret.push_back((*(i.first)).second);
            ret.back().runFunc = VOBJECT;
            ret.back().target = path;
        }
    }
    return ret;
}

int TypeHelper::run()
    // XXX TODO: on MacOSX, check if target command is a .app bundle
{
    switch(runFunc) {
    case DATA:
        break;
    case VOBJECT:
        char* env = (char*)malloc(strlen("VOS_STARTING_OBJECT=") + target.size() + 1);
        strcpy(env, "VOS_STARTING_OBJECT=");
        strcat(env, target.c_str());
        putenv(env);
        break;
    }
    char** args = (char**)malloc(sizeof(char*) * (parameters.size() + 1));
    unsigned int i;
    for(i = 0; i < parameters.size(); i++) {
        unsigned int p = parameters[i].find("%f");
        if(p != string::npos) parameters[i].replace(p, 2, target);

        p = parameters[i].find("%d");
        if(p != string::npos) {
            string data;
            if(FILE* fl = fopen(target.c_str(), "r")) {
                char buf[256];
                int r;
                while(!feof(fl) && (r = fread(buf, 1, sizeof(buf), fl))) data.append(buf, r);
                fclose(fl);
                parameters[i].replace(p, 2, data);
            }
        }
        args[i] = (char*)parameters[i].c_str();
    }
    args[i] = 0;

    int childpid;
#ifdef WIN32
    if((childpid = _spawnvp(_P_NOWAIT, args[0], args)) < 0)
#else
    if ((childpid = fork()) < 0)
#endif
    {
        fprintf(stderr, "libtypehelper: error creating child process!: %s\n", strerror(errno));
        free(args);
        return -1;
    }
    if (childpid > 0) {   // we are the parent
        processes.insert(childpid);
        free(args);
        return childpid;
    }
#ifndef WIN32
    else {
        // we are the child. exec.
        if (execvp(args[0], args)) {
            fprintf(stderr, "libtypehelper: error executing \"%s\": %s\n", getCommand().c_str(), strerror(errno));
        }
        /* If exec was successful, this half never returns */
        exit(-1);
    }
#endif
    return -1;
}

string TypeHelper::getCommand()
{
    string ret;
    for(deque<string>::iterator i = parameters.begin(); i != parameters.end(); i++) {
        ret += *i;
        ret += " ";
    }
    return ret;
}

void TypeHelper::setCommand(const string& command) {
    //cerr << "TypeHelper: setting command to " << command << endl;
    parameters.clear();
    unsigned int s = 0, e = 0;
    do {
        while(e < command.size() && (command[e] == ' ' || command[e] == '\t')) e++;
        s = e;
        while(e < command.size() && (command[e] != ' ' && command[e] != '\t')) e++;
        //cerr << "TypeHelper: adding command parameter: " << command.substr(s, e-s) << endl;
        parameters.push_back(command.substr(s, e-s));
        s = e;
    } while(s < command.size());
}



void TypeHelper::addProcessEndCallback(int pid, ProcessEndCallback* cb)
{
   if(processes.count(pid)) {
        callbacks.insert(pair<int, ProcessEndCallback*>(pid, cb));
    }
}

void TypeHelper::removeProcessEndCallback(int pid, ProcessEndCallback* call)
{
    pair<multimap<int, ProcessEndCallback*>::iterator, multimap<int, ProcessEndCallback*>::iterator> cb
        = callbacks.equal_range(pid);
    while(cb.first != cb.second) {
        multimap<int, ProcessEndCallback*>::iterator d = cb.first;
        cb.first++;
        if((*d).second == call) callbacks.erase(d);
    }
}

void TypeHelper::checkProcesses()
{
    for(set<int>::iterator i = processes.begin(); i != processes.end(); ) {
#ifdef WIN32
        HANDLE hd = OpenProcess(PROCESS_QUERY_INFORMATION, false, *i);
        DWORD retval;
        GetExitCodeProcess(hd, &retval);
        CloseHandle(hd);
        if(retval != STILL_ACTIVE)
#else
        if(waitpid(*i, 0, WNOHANG) > 0)
#endif
        {
            pair<multimap<int, ProcessEndCallback*>::iterator, multimap<int, ProcessEndCallback*>::iterator> cb
                = callbacks.equal_range(*i);
            while(cb.first != cb.second) {
                (*cb.first).second->notifyProcessTerminate(*i);
                multimap<int, ProcessEndCallback*>::iterator d = cb.first;
                cb.first++;
                callbacks.erase(d);
            }

            set<int>::iterator n = i;
            i++;
            processes.erase(n);
        } else i++;
    }
}

DeleteTempFile::DeleteTempFile(const string& f) : file(f), other_pids(0)
{ }

DeleteTempFile::DeleteTempFile(const string& f, set<int>* pidset) : file(f), other_pids(pidset)
{ }

DeleteTempFile::~DeleteTempFile()
{ }

void DeleteTempFile::notifyProcessTerminate(int pid)
{
    if(other_pids) {
        other_pids->erase(pid);
        if(other_pids->empty()) {
            unlink(file.c_str());
            delete other_pids;
        }
        delete this;
    } else {
        unlink(file.c_str());
        delete this;
    }
}

---