recoll / Code / Diff of /src/utils/execmd.cpp

Diff of /src/utils/execmd.cpp [c7fb85] .. [533068]

Switch to unified view


...
 *   along with this program; if not, write to the
 *   Free Software Foundation, Inc.,
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
#ifndef TEST_EXECMD
#ifdef BUILDING_RECOLL
#include "autoconfig.h"
#else
#include "config.h"
#endif

...

using namespace std;

extern char **environ;

#ifdef BUILDING_RECOLL


#include "debuglog.h"
#include "smallut.h"

#else
// If compiling outside of recoll, make the file as standalone as reasonable.
...
        tokens.push_back(str.substr(startPos, pos - startPos));
        startPos = ++pos;
    }
    }
}
#endif // BUILDING_RECOLL

class ExecCmd::Internal {
public:
    Internal()
    : m_advise(0), m_provide(0), m_timeoutMs(1000), 
      m_rlimit_as_mbytes(0) {
    }

    static bool      o_useVfork;

    std::vector<std::string>   m_env;
    ExecCmdAdvise   *m_advise;
    ExecCmdProvide  *m_provide;
    bool             m_killRequest;
    int              m_timeoutMs;
    int              m_rlimit_as_mbytes;
    string           m_stderrFile;
    // Pipe for data going to the command
    int              m_pipein[2];
    STD_SHARED_PTR<NetconCli> m_tocmd;
    // Pipe for data coming out
    int              m_pipeout[2];
    STD_SHARED_PTR<NetconCli> m_fromcmd;
    // Subprocess id
    pid_t            m_pid;
    // Saved sigmask
    sigset_t         m_blkcld;

    // Reset internal state indicators. Any resources should have been
    // previously freed
    void reset() {
  m_killRequest = false;
  m_pipein[0] = m_pipein[1] = m_pipeout[0] = m_pipeout[1] = -1;
  m_pid = -1;
  sigemptyset(&m_blkcld);
    }
    // Child process code
    inline void dochild(const std::string &cmd, const char **argv, 
          const char **envv, bool has_input, bool has_output);
};
bool ExecCmd::Internal::o_useVfork = false;

ExecCmd::ExecCmd()
{
    m = new Internal();
    if (m)
        m->reset();
}
void ExecCmd::setAdvise(ExecCmdAdvise *adv) 
{
    m->m_advise = adv;
}
void ExecCmd::setProvide(ExecCmdProvide *p) 
{
    m->m_provide = p;
}
void ExecCmd::setTimeout(int mS) 
{
    if (mS > 30) 
        m->m_timeoutMs = mS;
}
void ExecCmd::setStderr(const std::string &stderrFile) 
{
    m->m_stderrFile = stderrFile;
}
pid_t ExecCmd::getChildPid() 
{
    return m->m_pid;
}
void ExecCmd::setKill() 
{
    m->m_killRequest = true;
}
void ExecCmd::zapChild() 
{
    setKill(); 
    (void)wait();
}


/* From FreeBSD's which command */
static bool exec_is_there(const char *candidate)
{
    struct stat fin;
...
    // dynamic linker can sometimes deadlock if execve() is resolved
    // inside the vfork/exec window. Make sure it's done now. If "/" is
    // an executable file, we have a problem.
    const char *argv[] = {"/", 0};
    execve("/", (char *const *)argv, environ);
    Internal::o_useVfork  = on;
}

void ExecCmd::putenv(const string &ea)
{
    m->m_env.push_back(ea);
}

void  ExecCmd::putenv(const string &name, const string& value)
{
    string ea = name + "=" + value;
...
/** A resource manager to ensure that execcmd cleans up if an exception is 
 *  raised in the callback, or at different places on errors occurring
 *  during method executions */
class ExecCmdRsrc {
public:
    ExecCmdRsrc(ExecCmd::Internal *parent) 
        : m_parent(parent), m_active(true) {
    }
    void inactivate() {
        m_active = false;
    }
    ~ExecCmdRsrc() {
    if (!m_active || !m_parent)
        return;
    LOGDEB1(("~ExecCmdRsrc: working. mypid: %d\n", (int)getpid()));

...
    m_parent->m_fromcmd.reset();
    pthread_sigmask(SIG_UNBLOCK, &m_parent->m_blkcld, 0);
    m_parent->reset();
    }
private:
    ExecCmd::Internal *m_parent;
    bool    m_active;
};

ExecCmd::~ExecCmd()
{
    ExecCmdRsrc(this->m);
    if (m)
        delete m;
}

// In child process. Set up pipes and exec command. 
// This must not return. _exit() on error.
// *** This can be called after a vfork, so no modification of the
...
// father process, so that only absolutely exceptional conditions, 
// should be logged, for debugging and post-mortem purposes
// If one of the calls block, the problem manifests itself by 20mn
// (filter timeout) of looping on "ExecCmd::doexec: selectloop
// returned 1', because the father is waiting on the read descriptor
inline void ExecCmd::Internal::dochild(const string &cmd, const char **argv,
                                       const char **envv,
                                       bool has_input, bool has_output)
{
    // Start our own process group
    if (setpgid(0, getpid())) {
    LOGINFO(("ExecCmd::DOCHILD: setpgid(0, %d) failed: errno %d\n",
         getpid(), errno));
...
    _exit(127);
}

void ExecCmd::setrlimit_as(int mbytes)
{
    m->m_rlimit_as_mbytes = mbytes;
}

int ExecCmd::startExec(const string &cmd, const vector<string>& args,
               bool has_input, bool has_output)
{
...
    LOGDEB(("ExecCmd::startExec: (%d|%d) %s\n", 
        has_input, has_output, command.c_str()));
    }

    // The resource manager ensures resources are freed if we return early
    ExecCmdRsrc e(this->m);

    if (has_input && pipe(m->m_pipein) < 0) {
    LOGERR(("ExecCmd::startExec: pipe(2) failed. errno %d\n", errno));
    return -1;
    }
    if (has_output && pipe(m->m_pipeout) < 0) {
    LOGERR(("ExecCmd::startExec: pipe(2) failed. errno %d\n", errno));
    return -1;
    }


...
    Ccharp *envv;
    int envsize;
    for (envsize = 0; ; envsize++) 
    if (environ[envsize] == 0)
        break;
    envv = (Ccharp *)malloc((envsize + m->m_env.size() + 2) * sizeof(char *));
    if (envv == 0) {
    LOGERR(("ExecCmd::doexec: malloc() failed. errno %d\n", errno));
        free(argv);
        return -1;
    }
    int eidx;
    for (eidx = 0; eidx < envsize; eidx++)
    envv[eidx] = environ[eidx];
    for (vector<string>::const_iterator it = m->m_env.begin(); 
     it != m->m_env.end(); it++) {
    envv[eidx++] = it->c_str();
    }
    envv[eidx] = 0;

    // As we are going to use execve, not execvp, do the PATH thing.
...

        posix_spawn_file_actions_t facts;
        posix_spawn_file_actions_init(&facts);

        if (has_input) {
            posix_spawn_file_actions_addclose(&facts, m->m_pipein[1]);
            if (m->m_pipein[0] != 0) {
                posix_spawn_file_actions_adddup2(&facts, m->m_pipein[0], 0);
                posix_spawn_file_actions_addclose(&facts, m->m_pipein[0]);
            }
        }
        if (has_output) {
            posix_spawn_file_actions_addclose(&facts, m->m_pipeout[0]);
            if (m->m_pipeout[1] != 1) {
                posix_spawn_file_actions_adddup2(&facts, m->m_pipeout[1], 1);
                posix_spawn_file_actions_addclose(&facts, m->m_pipeout[1]);
            }
        }

        // Do we need to redirect stderr ?
        if (!m->m_stderrFile.empty()) {
            int oflags = O_WRONLY|O_CREAT;
#ifdef O_APPEND
            oflags |= O_APPEND;
#endif
            posix_spawn_file_actions_addopen(&facts, 2, m->m_stderrFile.c_str(), 
                                             oflags, 0600);
        }
        LOGDEB1(("using SPAWN\n"));

        // posix_spawn() does not have any standard way to ask for
...
        // but let's just add all fds
        for (int i = 3; i < libclf_maxfd(); i++) {
            posix_spawn_file_actions_addclose(&facts, i);
        }

        int ret = posix_spawn(&m->m_pid, exe.c_str(), &facts, &attrs, 
                              (char *const *)argv, (char *const *)envv);
        posix_spawnattr_destroy(&attrs);
        posix_spawn_file_actions_destroy(&facts);
        if (ret) {
            LOGERR(("ExecCmd::startExec: posix_spawn() failed. errno %d\n", 
...
            return -1;
        }
    }

#else
    if (Internal::o_useVfork) {
        LOGDEB1(("using VFORK\n"));
    m->m_pid = vfork();
    } else {
        LOGDEB1(("using FORK\n"));
    m->m_pid = fork();
    }
    if (m->m_pid < 0) {
    LOGERR(("ExecCmd::startExec: fork(2) failed. errno %d\n", errno));
    return -1;
    }
    if (m->m_pid == 0) {
    // e.inactivate() is not needed. As we do not return, the call
    // stack won't be unwound and destructors of local objects
    // won't be called.
    m->dochild(exe, argv, envv, has_input, has_output);
    // dochild does not return. Just in case...
    _exit(1);
    }
#endif

...
    free(envv);
///////////////////

    // Set the process group for the child. This is also done in the
    // child process see wikipedia(Process_group)
    if (setpgid(m->m_pid, m->m_pid)) {
        // This can fail with EACCES if the son has already done execve 
        // (linux at least)
        LOGDEB2(("ExecCmd: father setpgid(son)(%d,%d) errno %d (ok)\n",
                 m->m_pid, m->m_pid, errno));
    }

    sigemptyset(&m->m_blkcld);
    sigaddset(&m->m_blkcld, SIGCHLD);
    pthread_sigmask(SIG_BLOCK, &m->m_blkcld, 0);

    if (has_input) {
    close(m->m_pipein[0]);
    m->m_pipein[0] = -1;
    NetconCli *iclicon = new NetconCli();
    iclicon->setconn(m->m_pipein[1]);
  m->m_tocmd = STD_SHARED_PTR<NetconCli>(iclicon);
    }
    if (has_output) {
    close(m->m_pipeout[1]);
    m->m_pipeout[1] = -1;
    NetconCli *oclicon = new NetconCli();
    oclicon->setconn(m->m_pipeout[0]);
  m->m_fromcmd = STD_SHARED_PTR<NetconCli>(oclicon);
    }

    /* Don't want to undo what we just did ! */
    e.inactivate();

...
}

// Netcon callback. Send data to the command's input
class ExecWriter : public NetconWorker {
public:
    ExecWriter(const string *input, ExecCmdProvide *provide, 
               ExecCmd::Internal *parent)
    : m_cmd(parent), m_input(input), m_cnt(0), m_provide(provide) {
    }
    void shutdown() {
        close(m_cmd->m_pipein[1]);
        m_cmd->m_pipein[1] = -1;
  m_cmd->m_tocmd.reset();
    }
    virtual int data(NetconData *con, Netcon::Event reason)
    {
    if (!m_input) 
            return -1;
    LOGDEB1(("ExecWriter: input m_cnt %d input length %d\n", m_cnt, 
         m_input->length()));
    if (m_cnt >= m_input->length()) {
        // Fd ready for more but we got none. Try to get data, else
            // shutdown;
        if (!m_provide) {
                shutdown();








        return 0;
            }
            m_provide->newData();
            if (m_input->empty()) {
                shutdown();
                return 0;
            } else {
                // Ready with new buffer, reset use count
                m_cnt = 0;
            }
            LOGDEB2(("ExecWriter: provide m_cnt %d input length %d\n", 
                     m_cnt, m_input->length()));
    }
    int ret = con->send(m_input->c_str() + m_cnt, 
                m_input->length() - m_cnt);
    LOGDEB2(("ExecWriter: wrote %d to command\n", ret));
    if (ret <= 0) {
...
    }
    m_cnt += ret;
    return ret;
    }
private:
    ExecCmd::Internal *m_cmd;
    const string   *m_input;
    unsigned int    m_cnt; // Current offset inside m_input
    ExecCmdProvide *m_provide;
};

...
    if (startExec(cmd, args, input != 0, output != 0) < 0) {
    return -1;
    }

    // Cleanup in case we return early
    ExecCmdRsrc e(this->m);
    SelectLoop myloop;
    int ret = 0;
    if (input || output) {
        // Setup output
    if (output) {
        NetconCli *oclicon = m->m_fromcmd.get();
        if (!oclicon) {
        LOGERR(("ExecCmd::doexec: no connection from command\n"));
        return -1;
        }
        oclicon->setcallback(STD_SHARED_PTR<NetconWorker>
                 (new ExecReader(output, m->m_advise)));
        myloop.addselcon(m->m_fromcmd, Netcon::NETCONPOLL_READ);
        // Give up ownership 
        m->m_fromcmd.reset();
    } 
        // Setup input
    if (input) {
        NetconCli *iclicon = m->m_tocmd.get();
        if (!iclicon) {
        LOGERR(("ExecCmd::doexec: no connection from command\n"));
        return -1;
        }
        iclicon->setcallback(STD_SHARED_PTR<NetconWorker>
                 (new ExecWriter(input, m->m_provide, m)));
        myloop.addselcon(m->m_tocmd, Netcon::NETCONPOLL_WRITE);
        // Give up ownership 
        m->m_tocmd.reset();
    }

        // Do the actual reading/writing/waiting
    myloop.setperiodichandler(0, 0, m->m_timeoutMs);
    while ((ret = myloop.doLoop()) > 0) {
        LOGDEB(("ExecCmd::doexec: selectloop returned %d\n", ret));
        if (m->m_advise)
        m->m_advise->newData(0);
        if (m->m_killRequest) {
        LOGINFO(("ExecCmd::doexec: cancel request\n"));
        break;
        }
    }
    LOGDEB0(("ExecCmd::doexec: selectloop returned %d\n", ret));
        // Check for interrupt request: we won't want to waitpid()
        if (m->m_advise)
            m->m_advise->newData(0);

        // The netcons don't take ownership of the fds: we have to close them
        // (have to do it before wait, this may be the signal the child is 
        // waiting for exiting).
        if (input) {
            close(m->m_pipein[1]);
            m->m_pipein[1] = -1;
        }
        if (output) {
            close(m->m_pipeout[0]);
            m->m_pipeout[0] = -1;
        }
    }

    // Normal return: deactivate cleaner, wait() will do the cleanup
    e.inactivate();
...
    return ret1;
}

int ExecCmd::send(const string& data)
{
    NetconCli *con = m->m_tocmd.get();
    if (con == 0) {
    LOGERR(("ExecCmd::send: outpipe is closed\n"));
    return -1;
    }
    unsigned int nwritten = 0;
    while (nwritten < data.length()) {
    if (m->m_killRequest)
        break;
    int n = con->send(data.c_str() + nwritten, data.length() - nwritten);
    if (n < 0) {
        LOGERR(("ExecCmd::send: send failed\n"));
        return -1;
...
    return nwritten;
}

int ExecCmd::receive(string& data, int cnt)
{
    NetconCli *con = m->m_fromcmd.get();
    if (con == 0) {
    LOGERR(("ExecCmd::receive: inpipe is closed\n"));
    return -1;
    }
    const int BS = 4096;
...
    return ntot;
}

int ExecCmd::getline(string& data)
{
    NetconCli *con = m->m_fromcmd.get();
    if (con == 0) {
    LOGERR(("ExecCmd::receive: inpipe is closed\n"));
    return -1;
    }
    const int BS = 1024;
...
    }
    return n;
}

// Wait for command status and clean up all resources.
// We would like to avoid blocking here too, but there is no simple
// way to do this. The 2 possible approaches would be to:
//  - Use signals (alarm), waitpid() is interruptible. but signals and
//    threads... This would need a specialized thread, inter-thread comms etc.
//  - Use an intermediary process when starting the command. The
//    process forks a timer process, and the real command, then calls
//    a blocking waitpid on all at the end, and is guaranteed to get
//    at least the timer process status, thus yielding a select()
//    equivalent. This is bad too, because the timeout is on the whole
//    exec, not just the wait
// Just calling waitpid() with WNOHANG with a sleep() between tries
// does not work: the first waitpid() usually comes too early and
// reaps nothing, resulting in almost always one sleep() or more.
// 
// So no timeout here. This has not been a problem in practise inside recoll.
// In case of need, using a semi-busy loop with short sleeps
// increasing from a few mS might work without creating too much
// overhead.
int ExecCmd::wait()
{
    ExecCmdRsrc e(this->m);
    int status = -1;
    if (!m->m_killRequest && m->m_pid > 0) {
    if (waitpid(m->m_pid, &status, 0) < 0) {
        LOGERR(("ExecCmd::waitpid: returned -1 errno %d\n", errno));
        status = -1;
    }
        LOGDEB(("ExecCmd::wait: got status 0x%x\n", status));
    m->m_pid = -1;
    }
    // Let the ExecCmdRsrc cleanup, it will do the killing/waiting if needed
    return status;
}

bool ExecCmd::maybereap(int *status)
{
    ExecCmdRsrc e(this->m);
    *status = -1;

    if (m->m_pid <= 0) {
    // Already waited for ??
    return true;
    }

    pid_t pid = waitpid(m->m_pid, status, WNOHANG);
    if (pid < 0) {
        LOGERR(("ExecCmd::maybereap: returned -1 errno %d\n", errno));
    m->m_pid = -1;
    return true;
    } else if (pid == 0) {
    LOGDEB1(("ExecCmd::maybereap: not exited yet\n"));
    e.inactivate();
    return false;
    } else {
        LOGDEB(("ExecCmd::maybereap: got status 0x%x\n", status));
    m->m_pid = -1;
    return true;
    }
}

// Static
...

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>

#include <string>
#include <iostream>
#include <sstream>
#include <vector>


#include "debuglog.h"
#include "cancelcheck.h"
#include "execmd.h"
#include "smallut.h"

using namespace std;


// Testing the rclexecm protocol outside of recoll. Here we use the
// rcldoc.py filter, you can try with rclaudio too, adjust the file arg
// accordingly
bool exercise_mhexecm(const string& cmdstr, const string& mimetype, 
                      vector<string>& files)
{
    ExecCmd cmd;

    vector<string> myparams; 

    if (cmd.startExec(cmdstr, myparams, 1, 1) < 0) {
    cerr << "startExec " << cmdstr << " failed. Missing command?\n";
    return false;
    }

    for (vector<string>::const_iterator it = files.begin();
         it != files.end(); it++) {
        // Build request message
        ostringstream obuf;
        obuf << "Filename: " << (*it).length() << "\n" << (*it);
        obuf << "Mimetype: " << mimetype.length() << "\n" << mimetype;
        // Bogus parameter should be skipped by filter
        obuf << "BogusParam: " << string("bogus").length() << "\n" << "bogus";
        obuf << "\n";
        cerr << "SENDING: [" << obuf.str() << "]\n";
        // Send it 
        if (cmd.send(obuf.str()) < 0) {
            // The real code calls zapchild here, but we don't need it as
            // this will be handled by ~ExecCmd
            //cmd.zapChild();
            cerr << "send error\n";
            return false;
        }

        // Read answer
        for (int loop=0;;loop++) {
            string name, data;

            // Code from mh_execm.cpp: readDataElement
            string ibuf;
            // Read name and length
            if (cmd.getline(ibuf) <= 0) {
                cerr << "getline error\n";
                return false;
            }
            // Empty line (end of message)
            if (!ibuf.compare("\n")) {
                cerr << "Got empty line\n";
                name.clear();
                break;
            }

            // Filters will sometimes abort before entering the real
            // protocol, ie if a module can't be loaded. Check the
            // special filter error first word:
            if (ibuf.find("RECFILTERROR ") == 0) {
                cerr << "Got RECFILTERROR\n";
                return false;
            }

            // We're expecting something like Name: len\n
            vector<string> tokens;
            stringToTokens(ibuf, tokens);
            if (tokens.size() != 2) {
                cerr << "bad line in filter output: [" << ibuf << "]\n";
                return false;
            }
            vector<string>::iterator it = tokens.begin();
            name = *it++;
            string& slen = *it;
            int len;
            if (sscanf(slen.c_str(), "%d", &len) != 1) {
                cerr << "bad line in filter output (no len): [" << 
                    ibuf << "]\n";
                return false;
            }
            // Read element data
            data.erase();
            if (len > 0 && cmd.receive(data, len) != len) {
                cerr << "MHExecMultiple: expected " << len << 
                    " bytes of data, got " << data.length() << endl;
                return false;
            }

            // Empty element: end of message
            if (name.empty())
                break;
            cerr << "Got name: [" << name << "] data [" << data << "]\n";
        }
    }
    return true;
}

static char *thisprog;
static char usage [] =
"trexecmd [-c -r -i -o] cmd [arg1 arg2 ...]\n" 
"   -c : test cancellation (ie: trexecmd -c sleep 1000)\n"
"   -r : run reexec. Must be separate option.\n"
"   -i : command takes input\n"
"   -o : command produces output\n"
"    If -i is set, we send /etc/group contents to whatever command is run\n"
"    If -o is set, we print whatever comes out\n"
"trexecmd -m <filter> <mimetype> <file> [file ...]: test execm:\n"
"     <filter> should be the path to an execm filter\n"
"     <mimetype> the type of the file parameters\n"
"trexecmd -w cmd : do the 'which' thing\n"
;

static void Usage(void)
{
    fprintf(stderr, "%s: usage:\n%s", thisprog, usage);
    exit(1);
}

static int     op_flags;
#define OPT_MOINS 0x1
#define OPT_i     0x4
#define OPT_w     0x8
#define OPT_c     0x10
#define OPT_r     0x20
#define OPT_m     0x40
#define OPT_o     0x80

// Data sink for data coming out of the command. We also use it to set
// a cancellation after a moment.
class MEAdv : public ExecCmdAdvise {
public:

    void newData(int cnt) {
    if (op_flags & OPT_c) {
        static int  callcnt;
        if (callcnt++ == 10) {
                // Just sets the cancellation flag
      CancelCheck::instance().setCancel();
                // Would be called from somewhere else and throws an
                // exception. We call it here for simplicity
                CancelCheck::instance().checkCancel();
        }
    }
    cerr << "newData(" << cnt << ")" << endl;



    }
};

// Data provider, used if the -i flag is set
class MEPv : public ExecCmdProvide {
public:
    FILE *m_fp;
    string *m_input;
    MEPv(string *i) 
...
    }
    }
};
















ReExec reexec;

int main(int argc, char *argv[])
{
    reexec.init(argc, argv);

    if (0) {
...
        switch (*(*argv)++) {
        case 'c':   op_flags |= OPT_c; break;
        case 'r':   op_flags |= OPT_r; break;
        case 'w':   op_flags |= OPT_w; break;
        case 'm':   op_flags |= OPT_m; break;
      case 'i':   op_flags |= OPT_i; break;
      case 'o':   op_flags |= OPT_o; break;
        default: Usage();   break;
        }
    b1: argc--; argv++;
    }

...
    string arg1 = *argv++; argc--;
    vector<string> l;
    while (argc > 0) {
    l.push_back(*argv++); argc--;
    }

    DebugLog::getdbl()->setloglevel(DEBDEB1);
    DebugLog::setfilename("stderr");
    signal(SIGPIPE, SIG_IGN);

    if (op_flags & OPT_r) {
  // Test reexec. Normally only once, next time we fall through
        // because we remove the -r option (only works if it was isolated, not like -rc
    chdir("/");
        argv[0] = strdup("");
    sleep(1);
        cerr << "Calling reexec\n";
        // We remove the -r arg from list, otherwise we are going to
        // loop (which you can try by commenting out the following
        // line)
        reexec.removeArg("-r");
        reexec.reexec();
    }

    if (op_flags & OPT_w) {
    // Test "which" method
    string path;
    if (ExecCmd::which(arg1, path)) {
        cout << path << endl;
            return 0;
    } 
  return 1;


    } else if (op_flags & OPT_m) {
        if (l.size() < 2)
            Usage();
        string mimetype = l[0];
        l.erase(l.begin());
    return exercise_mhexecm(arg1, mimetype, l) ? 0 : 1;
    } else {


        // Default: execute command line arguments
        ExecCmd mexec;

        // Set callback to be called whenever there is new data
        // available and at a periodic interval, to check for
        // cancellation
        MEAdv adv;

        mexec.setAdvise(&adv);
        mexec.setTimeout(5);

        // Stderr output goes there
        mexec.setStderr("/tmp/trexecStderr");
        
        // A few environment variables. Check with trexecmd env
        mexec.putenv("TESTVARIABLE1=TESTVALUE1");
        mexec.putenv("TESTVARIABLE2=TESTVALUE2");
        mexec.putenv("TESTVARIABLE3=TESTVALUE3");

        string input, output;




        MEPv  pv(&input);
        
        string *ip = 0;
        if (op_flags  & OPT_i) {
            ip = &input;
            mexec.setProvide(&pv);
        }
        string *op = 0;
        if (op_flags & OPT_o) {
            op = &output;
        }

        int status = -1;
        try {
            status = mexec.doexec(arg1, l, ip, op);
        } catch (CancelExcept) {
            cerr << "CANCELLED" << endl;
        }

        fprintf(stderr, "Status: 0x%x\n", status);
        if (op_flags & OPT_o) {
            cout << output;
        }
        exit (status >> 8);
    }
}
#endif // TEST

	a/src/utils/execmd.cpp		b/src/utils/execmd.cpp
	...		...
13	* along with this program; if not, write to the	13	* along with this program; if not, write to the
14	* Free Software Foundation, Inc.,	14	* Free Software Foundation, Inc.,
15	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.	15	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
16	*/	16	*/
17	#ifndef TEST_EXECMD	17	#ifndef TEST_EXECMD
18	#ifdef RECOLL_DATADIR	18	#ifdef BUILDING_RECOLL
19	#include "autoconfig.h"	19	#include "autoconfig.h"
20	#else	20	#else
21	#include "config.h"	21	#include "config.h"
22	#endif	22	#endif
23		23
	...		...
55		55
56	using namespace std;	56	using namespace std;
57		57
58	extern char **environ;	58	extern char **environ;
59		59
60	bool ExecCmd::o_useVfork = false;	60	#ifdef BUILDING_RECOLL
61
62	#ifdef RECOLL_DATADIR
63	#include "debuglog.h"	61	#include "debuglog.h"
64	#include "smallut.h"	62	#include "smallut.h"
65		63
66	#else	64	#else
67	// If compiling outside of recoll, make the file as standalone as reasonable.	65	// If compiling outside of recoll, make the file as standalone as reasonable.
	...		...
110	tokens.push_back(str.substr(startPos, pos - startPos));	108	tokens.push_back(str.substr(startPos, pos - startPos));
111	startPos = ++pos;	109	startPos = ++pos;
112	}	110	}
113	}	111	}
114	}	112	}
115	#endif // RECOLL_DATADIR	113	#endif // BUILDING_RECOLL
		114
		115	class ExecCmd::Internal {
		116	public:
		117	Internal()
		118	: m_advise(0), m_provide(0), m_timeoutMs(1000),
		119	m_rlimit_as_mbytes(0) {
		120	}
		121
		122	static bool o_useVfork;
		123
		124	std::vector<std::string> m_env;
		125	ExecCmdAdvise *m_advise;
		126	ExecCmdProvide *m_provide;
		127	bool m_killRequest;
		128	int m_timeoutMs;
		129	int m_rlimit_as_mbytes;
		130	string m_stderrFile;
		131	// Pipe for data going to the command
		132	int m_pipein[2];
		133	STD_SHARED_PTR<NetconCli> m_tocmd;
		134	// Pipe for data coming out
		135	int m_pipeout[2];
		136	STD_SHARED_PTR<NetconCli> m_fromcmd;
		137	// Subprocess id
		138	pid_t m_pid;
		139	// Saved sigmask
		140	sigset_t m_blkcld;
		141
		142	// Reset internal state indicators. Any resources should have been
		143	// previously freed
		144	void reset() {
		145	m_killRequest = false;
		146	m_pipein[0] = m_pipein[1] = m_pipeout[0] = m_pipeout[1] = -1;
		147	m_pid = -1;
		148	sigemptyset(&m_blkcld);
		149	}
		150	// Child process code
		151	inline void dochild(const std::string &cmd, const char **argv,
		152	const char **envv, bool has_input, bool has_output);
		153	};
		154	bool ExecCmd::Internal::o_useVfork = false;
		155
		156	ExecCmd::ExecCmd()
		157	{
		158	m = new Internal();
		159	if (m)
		160	m->reset();
		161	}
		162	void ExecCmd::setAdvise(ExecCmdAdvise *adv)
		163	{
		164	m->m_advise = adv;
		165	}
		166	void ExecCmd::setProvide(ExecCmdProvide *p)
		167	{
		168	m->m_provide = p;
		169	}
		170	void ExecCmd::setTimeout(int mS)
		171	{
		172	if (mS > 30)
		173	m->m_timeoutMs = mS;
		174	}
		175	void ExecCmd::setStderr(const std::string &stderrFile)
		176	{
		177	m->m_stderrFile = stderrFile;
		178	}
		179	pid_t ExecCmd::getChildPid()
		180	{
		181	return m->m_pid;
		182	}
		183	void ExecCmd::setKill()
		184	{
		185	m->m_killRequest = true;
		186	}
		187	void ExecCmd::zapChild()
		188	{
		189	setKill();
		190	(void)wait();
		191	}
		192
116		193
117	/* From FreeBSD's which command */	194	/* From FreeBSD's which command */
118	static bool exec_is_there(const char *candidate)	195	static bool exec_is_there(const char *candidate)
119	{	196	{
120	struct stat fin;	197	struct stat fin;
	...		...
172	// dynamic linker can sometimes deadlock if execve() is resolved	249	// dynamic linker can sometimes deadlock if execve() is resolved
173	// inside the vfork/exec window. Make sure it's done now. If "/" is	250	// inside the vfork/exec window. Make sure it's done now. If "/" is
174	// an executable file, we have a problem.	251	// an executable file, we have a problem.
175	const char *argv[] = {"/", 0};	252	const char *argv[] = {"/", 0};
176	execve("/", (char const )argv, environ);	253	execve("/", (char const )argv, environ);
177	o_useVfork = on;	254	Internal::o_useVfork = on;
178	}	255	}
179		256
180	void ExecCmd::putenv(const string &ea)	257	void ExecCmd::putenv(const string &ea)
181	{	258	{
182	m_env.push_back(ea);	259	m->m_env.push_back(ea);
183	}	260	}
184		261
185	void ExecCmd::putenv(const string &name, const string& value)	262	void ExecCmd::putenv(const string &name, const string& value)
186	{	263	{
187	string ea = name + "=" + value;	264	string ea = name + "=" + value;
	...		...
199	/** A resource manager to ensure that execcmd cleans up if an exception is	276	/** A resource manager to ensure that execcmd cleans up if an exception is
200	* raised in the callback, or at different places on errors occurring	277	* raised in the callback, or at different places on errors occurring
201	* during method executions */	278	* during method executions */
202	class ExecCmdRsrc {	279	class ExecCmdRsrc {
203	public:	280	public:
204	ExecCmdRsrc(ExecCmd *parent) : m_parent(parent), m_active(true) {}	281	ExecCmdRsrc(ExecCmd::Internal *parent)
205	void inactivate() {m_active = false;}	282	: m_parent(parent), m_active(true) {
		283	}
		284	void inactivate() {
		285	m_active = false;
		286	}
206	~ExecCmdRsrc() {	287	~ExecCmdRsrc() {
207	if (!m_active \|\| !m_parent)	288	if (!m_active \|\| !m_parent)
208	return;	289	return;
209	LOGDEB1(("~ExecCmdRsrc: working. mypid: %d\n", (int)getpid()));	290	LOGDEB1(("~ExecCmdRsrc: working. mypid: %d\n", (int)getpid()));
210		291
	...		...
248	m_parent->m_fromcmd.reset();	329	m_parent->m_fromcmd.reset();
249	pthread_sigmask(SIG_UNBLOCK, &m_parent->m_blkcld, 0);	330	pthread_sigmask(SIG_UNBLOCK, &m_parent->m_blkcld, 0);
250	m_parent->reset();	331	m_parent->reset();
251	}	332	}
252	private:	333	private:
253	ExecCmd *m_parent;	334	ExecCmd::Internal *m_parent;
254	bool m_active;	335	bool m_active;
255	};	336	};
256		337
257	ExecCmd::~ExecCmd()	338	ExecCmd::~ExecCmd()
258	{	339	{
259	ExecCmdRsrc(this);	340	ExecCmdRsrc(this->m);
		341	if (m)
		342	delete m;
260	}	343	}
261		344
262	// In child process. Set up pipes and exec command.	345	// In child process. Set up pipes and exec command.
263	// This must not return. _exit() on error.	346	// This must not return. _exit() on error.
264	// *** This can be called after a vfork, so no modification of the	347	// *** This can be called after a vfork, so no modification of the
	...		...
270	// father process, so that only absolutely exceptional conditions,	353	// father process, so that only absolutely exceptional conditions,
271	// should be logged, for debugging and post-mortem purposes	354	// should be logged, for debugging and post-mortem purposes
272	// If one of the calls block, the problem manifests itself by 20mn	355	// If one of the calls block, the problem manifests itself by 20mn
273	// (filter timeout) of looping on "ExecCmd::doexec: selectloop	356	// (filter timeout) of looping on "ExecCmd::doexec: selectloop
274	// returned 1', because the father is waiting on the read descriptor	357	// returned 1', because the father is waiting on the read descriptor
275	inline void ExecCmd::dochild(const string &cmd, const char **argv,	358	inline void ExecCmd::Internal::dochild(const string &cmd, const char **argv,
276	const char **envv,	359	const char **envv,
277	bool has_input, bool has_output)	360	bool has_input, bool has_output)
278	{	361	{
279	// Start our own process group	362	// Start our own process group
280	if (setpgid(0, getpid())) {	363	if (setpgid(0, getpid())) {
281	LOGINFO(("ExecCmd::DOCHILD: setpgid(0, %d) failed: errno %d\n",	364	LOGINFO(("ExecCmd::DOCHILD: setpgid(0, %d) failed: errno %d\n",
282	getpid(), errno));	365	getpid(), errno));
	...		...
382	_exit(127);	465	_exit(127);
383	}	466	}
384		467
385	void ExecCmd::setrlimit_as(int mbytes)	468	void ExecCmd::setrlimit_as(int mbytes)
386	{	469	{
387	m_rlimit_as_mbytes = mbytes;	470	m->m_rlimit_as_mbytes = mbytes;
388	}	471	}
389		472
390	int ExecCmd::startExec(const string &cmd, const vector<string>& args,	473	int ExecCmd::startExec(const string &cmd, const vector<string>& args,
391	bool has_input, bool has_output)	474	bool has_input, bool has_output)
392	{	475	{
	...		...
399	LOGDEB(("ExecCmd::startExec: (%d\|%d) %s\n",	482	LOGDEB(("ExecCmd::startExec: (%d\|%d) %s\n",
400	has_input, has_output, command.c_str()));	483	has_input, has_output, command.c_str()));
401	}	484	}
402		485
403	// The resource manager ensures resources are freed if we return early	486	// The resource manager ensures resources are freed if we return early
404	ExecCmdRsrc e(this);	487	ExecCmdRsrc e(this->m);
405		488
406	if (has_input && pipe(m_pipein) < 0) {	489	if (has_input && pipe(m->m_pipein) < 0) {
407	LOGERR(("ExecCmd::startExec: pipe(2) failed. errno %d\n", errno));	490	LOGERR(("ExecCmd::startExec: pipe(2) failed. errno %d\n", errno));
408	return -1;	491	return -1;
409	}	492	}
410	if (has_output && pipe(m_pipeout) < 0) {	493	if (has_output && pipe(m->m_pipeout) < 0) {
411	LOGERR(("ExecCmd::startExec: pipe(2) failed. errno %d\n", errno));	494	LOGERR(("ExecCmd::startExec: pipe(2) failed. errno %d\n", errno));
412	return -1;	495	return -1;
413	}	496	}
414		497
415		498
	...		...
439	Ccharp *envv;	522	Ccharp *envv;
440	int envsize;	523	int envsize;
441	for (envsize = 0; ; envsize++)	524	for (envsize = 0; ; envsize++)
442	if (environ[envsize] == 0)	525	if (environ[envsize] == 0)
443	break;	526	break;
444	envv = (Ccharp )malloc((envsize + m_env.size() + 2) sizeof(char *));	527	envv = (Ccharp )malloc((envsize + m->m_env.size() + 2) sizeof(char *));
445	if (envv == 0) {	528	if (envv == 0) {
446	LOGERR(("ExecCmd::doexec: malloc() failed. errno %d\n", errno));	529	LOGERR(("ExecCmd::doexec: malloc() failed. errno %d\n", errno));
447	free(argv);	530	free(argv);
448	return -1;	531	return -1;
449	}	532	}
450	int eidx;	533	int eidx;
451	for (eidx = 0; eidx < envsize; eidx++)	534	for (eidx = 0; eidx < envsize; eidx++)
452	envv[eidx] = environ[eidx];	535	envv[eidx] = environ[eidx];
453	for (vector<string>::const_iterator it = m_env.begin();	536	for (vector<string>::const_iterator it = m->m_env.begin();
454	it != m_env.end(); it++) {	537	it != m->m_env.end(); it++) {
455	envv[eidx++] = it->c_str();	538	envv[eidx++] = it->c_str();
456	}	539	}
457	envv[eidx] = 0;	540	envv[eidx] = 0;
458		541
459	// As we are going to use execve, not execvp, do the PATH thing.	542	// As we are going to use execve, not execvp, do the PATH thing.
	...		...
493		576
494	posix_spawn_file_actions_t facts;	577	posix_spawn_file_actions_t facts;
495	posix_spawn_file_actions_init(&facts);	578	posix_spawn_file_actions_init(&facts);
496		579
497	if (has_input) {	580	if (has_input) {
498	posix_spawn_file_actions_addclose(&facts, m_pipein[1]);	581	posix_spawn_file_actions_addclose(&facts, m->m_pipein[1]);
499	if (m_pipein[0] != 0) {	582	if (m->m_pipein[0] != 0) {
500	posix_spawn_file_actions_adddup2(&facts, m_pipein[0], 0);	583	posix_spawn_file_actions_adddup2(&facts, m->m_pipein[0], 0);
501	posix_spawn_file_actions_addclose(&facts, m_pipein[0]);	584	posix_spawn_file_actions_addclose(&facts, m->m_pipein[0]);
502	}	585	}
503	}	586	}
504	if (has_output) {	587	if (has_output) {
505	posix_spawn_file_actions_addclose(&facts, m_pipeout[0]);	588	posix_spawn_file_actions_addclose(&facts, m->m_pipeout[0]);
506	if (m_pipeout[1] != 1) {	589	if (m->m_pipeout[1] != 1) {
507	posix_spawn_file_actions_adddup2(&facts, m_pipeout[1], 1);	590	posix_spawn_file_actions_adddup2(&facts, m->m_pipeout[1], 1);
508	posix_spawn_file_actions_addclose(&facts, m_pipeout[1]);	591	posix_spawn_file_actions_addclose(&facts, m->m_pipeout[1]);
509	}	592	}
510	}	593	}
511		594
512	// Do we need to redirect stderr ?	595	// Do we need to redirect stderr ?
513	if (!m_stderrFile.empty()) {	596	if (!m->m_stderrFile.empty()) {
514	int oflags = O_WRONLY\|O_CREAT;	597	int oflags = O_WRONLY\|O_CREAT;
515	#ifdef O_APPEND	598	#ifdef O_APPEND
516	oflags \|= O_APPEND;	599	oflags \|= O_APPEND;
517	#endif	600	#endif
518	posix_spawn_file_actions_addopen(&facts, 2, m_stderrFile.c_str(),	601	posix_spawn_file_actions_addopen(&facts, 2, m->m_stderrFile.c_str(),
519	oflags, 0600);	602	oflags, 0600);
520	}	603	}
521	LOGDEB1(("using SPAWN\n"));	604	LOGDEB1(("using SPAWN\n"));
522		605
523	// posix_spawn() does not have any standard way to ask for	606	// posix_spawn() does not have any standard way to ask for
	...		...
525	// but let's just add all fds	608	// but let's just add all fds
526	for (int i = 3; i < libclf_maxfd(); i++) {	609	for (int i = 3; i < libclf_maxfd(); i++) {
527	posix_spawn_file_actions_addclose(&facts, i);	610	posix_spawn_file_actions_addclose(&facts, i);
528	}	611	}
529		612
530	int ret = posix_spawn(&m_pid, exe.c_str(), &facts, &attrs,	613	int ret = posix_spawn(&m->m_pid, exe.c_str(), &facts, &attrs,
531	(char const )argv, (char const )envv);	614	(char const )argv, (char const )envv);
532	posix_spawnattr_destroy(&attrs);	615	posix_spawnattr_destroy(&attrs);
533	posix_spawn_file_actions_destroy(&facts);	616	posix_spawn_file_actions_destroy(&facts);
534	if (ret) {	617	if (ret) {
535	LOGERR(("ExecCmd::startExec: posix_spawn() failed. errno %d\n",	618	LOGERR(("ExecCmd::startExec: posix_spawn() failed. errno %d\n",
	...		...
537	return -1;	620	return -1;
538	}	621	}
539	}	622	}
540		623
541	#else	624	#else
542	if (o_useVfork) {	625	if (Internal::o_useVfork) {
543	LOGDEB1(("using VFORK\n"));	626	LOGDEB1(("using VFORK\n"));
544	m_pid = vfork();	627	m->m_pid = vfork();
545	} else {	628	} else {
546	LOGDEB1(("using FORK\n"));	629	LOGDEB1(("using FORK\n"));
547	m_pid = fork();	630	m->m_pid = fork();
548	}	631	}
549	if (m_pid < 0) {	632	if (m->m_pid < 0) {
550	LOGERR(("ExecCmd::startExec: fork(2) failed. errno %d\n", errno));	633	LOGERR(("ExecCmd::startExec: fork(2) failed. errno %d\n", errno));
551	return -1;	634	return -1;
552	}	635	}
553	if (m_pid == 0) {	636	if (m->m_pid == 0) {
554	// e.inactivate() is not needed. As we do not return, the call	637	// e.inactivate() is not needed. As we do not return, the call
555	// stack won't be unwound and destructors of local objects	638	// stack won't be unwound and destructors of local objects
556	// won't be called.	639	// won't be called.
557	dochild(exe, argv, envv, has_input, has_output);	640	m->dochild(exe, argv, envv, has_input, has_output);
558	// dochild does not return. Just in case...	641	// dochild does not return. Just in case...
559	_exit(1);	642	_exit(1);
560	}	643	}
561	#endif	644	#endif
562		645
	...		...
568	free(envv);	651	free(envv);
569	///////////////////	652	///////////////////
570		653
571	// Set the process group for the child. This is also done in the	654	// Set the process group for the child. This is also done in the
572	// child process see wikipedia(Process_group)	655	// child process see wikipedia(Process_group)
573	if (setpgid(m_pid, m_pid)) {	656	if (setpgid(m->m_pid, m->m_pid)) {
574	// This can fail with EACCES if the son has already done execve	657	// This can fail with EACCES if the son has already done execve
575	// (linux at least)	658	// (linux at least)
576	LOGDEB2(("ExecCmd: father setpgid(son)(%d,%d) errno %d (ok)\n",	659	LOGDEB2(("ExecCmd: father setpgid(son)(%d,%d) errno %d (ok)\n",
577	m_pid, m_pid, errno));	660	m->m_pid, m->m_pid, errno));
578	}	661	}
579		662
580	sigemptyset(&m_blkcld);	663	sigemptyset(&m->m_blkcld);
581	sigaddset(&m_blkcld, SIGCHLD);	664	sigaddset(&m->m_blkcld, SIGCHLD);
582	pthread_sigmask(SIG_BLOCK, &m_blkcld, 0);	665	pthread_sigmask(SIG_BLOCK, &m->m_blkcld, 0);
583		666
584	if (has_input) {	667	if (has_input) {
585	close(m_pipein[0]);	668	close(m->m_pipein[0]);
586	m_pipein[0] = -1;	669	m->m_pipein[0] = -1;
587	NetconCli *iclicon = new NetconCli();	670	NetconCli *iclicon = new NetconCli();
588	iclicon->setconn(m_pipein[1]);	671	iclicon->setconn(m->m_pipein[1]);
589	m_tocmd = NetconP(iclicon);	672	m->m_tocmd = STD_SHARED_PTR<NetconCli>(iclicon);
590	}	673	}
591	if (has_output) {	674	if (has_output) {
592	close(m_pipeout[1]);	675	close(m->m_pipeout[1]);
593	m_pipeout[1] = -1;	676	m->m_pipeout[1] = -1;
594	NetconCli *oclicon = new NetconCli();	677	NetconCli *oclicon = new NetconCli();
595	oclicon->setconn(m_pipeout[0]);	678	oclicon->setconn(m->m_pipeout[0]);
596	m_fromcmd = NetconP(oclicon);	679	m->m_fromcmd = STD_SHARED_PTR<NetconCli>(oclicon);
597	}	680	}
598		681
599	/* Don't want to undo what we just did ! */	682	/* Don't want to undo what we just did ! */
600	e.inactivate();	683	e.inactivate();
601		684
	...		...
603	}	686	}
604		687
605	// Netcon callback. Send data to the command's input	688	// Netcon callback. Send data to the command's input
606	class ExecWriter : public NetconWorker {	689	class ExecWriter : public NetconWorker {
607	public:	690	public:
608	ExecWriter(const string input, ExecCmdProvide provide)	691	ExecWriter(const string input, ExecCmdProvide provide,
		692	ExecCmd::Internal *parent)
609	: m_input(input), m_cnt(0), m_provide(provide)	693	: m_cmd(parent), m_input(input), m_cnt(0), m_provide(provide) {
610	{}	694	}
		695	void shutdown() {
		696	close(m_cmd->m_pipein[1]);
		697	m_cmd->m_pipein[1] = -1;
		698	m_cmd->m_tocmd.reset();
		699	}
611	virtual int data(NetconData *con, Netcon::Event reason)	700	virtual int data(NetconData *con, Netcon::Event reason)
612	{	701	{
613	if (!m_input) return -1;	702	if (!m_input)
		703	return -1;
614	LOGDEB1(("ExecWriter: input m_cnt %d input length %d\n", m_cnt,	704	LOGDEB1(("ExecWriter: input m_cnt %d input length %d\n", m_cnt,
615	m_input->length()));	705	m_input->length()));
616	if (m_cnt >= m_input->length()) {	706	if (m_cnt >= m_input->length()) {
617	// Fd ready for more but we got none.	707	// Fd ready for more but we got none. Try to get data, else
		708	// shutdown;
618	if (m_provide) {	709	if (!m_provide) {
619	m_provide->newData();	710	shutdown();
620	if (m_input->empty()) {
621	return 0;
622	} else {
623	m_cnt = 0;
624	}
625	LOGDEB2(("ExecWriter: provide m_cnt %d input length %d\n",
626	m_cnt, m_input->length()));
627	} else {
628	return 0;	711	return 0;
629	}	712	}
		713	m_provide->newData();
		714	if (m_input->empty()) {
		715	shutdown();
		716	return 0;
		717	} else {
		718	// Ready with new buffer, reset use count
		719	m_cnt = 0;
		720	}
		721	LOGDEB2(("ExecWriter: provide m_cnt %d input length %d\n",
		722	m_cnt, m_input->length()));
630	}	723	}
631	int ret = con->send(m_input->c_str() + m_cnt,	724	int ret = con->send(m_input->c_str() + m_cnt,
632	m_input->length() - m_cnt);	725	m_input->length() - m_cnt);
633	LOGDEB2(("ExecWriter: wrote %d to command\n", ret));	726	LOGDEB2(("ExecWriter: wrote %d to command\n", ret));
634	if (ret <= 0) {	727	if (ret <= 0) {
	...		...
637	}	730	}
638	m_cnt += ret;	731	m_cnt += ret;
639	return ret;	732	return ret;
640	}	733	}
641	private:	734	private:
		735	ExecCmd::Internal *m_cmd;
642	const string *m_input;	736	const string *m_input;
643	unsigned int m_cnt; // Current offset inside m_input	737	unsigned int m_cnt; // Current offset inside m_input
644	ExecCmdProvide *m_provide;	738	ExecCmdProvide *m_provide;
645	};	739	};
646		740
	...		...
677	if (startExec(cmd, args, input != 0, output != 0) < 0) {	771	if (startExec(cmd, args, input != 0, output != 0) < 0) {
678	return -1;	772	return -1;
679	}	773	}
680		774
681	// Cleanup in case we return early	775	// Cleanup in case we return early
682	ExecCmdRsrc e(this);	776	ExecCmdRsrc e(this->m);
683	SelectLoop myloop;	777	SelectLoop myloop;
684	int ret = 0;	778	int ret = 0;
685	if (input \|\| output) {	779	if (input \|\| output) {
686	// Setup output	780	// Setup output
687	if (output) {	781	if (output) {
688	NetconCli oclicon = dynamic_cast<NetconCli >(m_fromcmd.get());	782	NetconCli *oclicon = m->m_fromcmd.get();
689	if (!oclicon) {	783	if (!oclicon) {
690	LOGERR(("ExecCmd::doexec: no connection from command\n"));	784	LOGERR(("ExecCmd::doexec: no connection from command\n"));
691	return -1;	785	return -1;
692	}	786	}
693	oclicon->setcallback(STD_SHARED_PTR<NetconWorker>	787	oclicon->setcallback(STD_SHARED_PTR<NetconWorker>
694	(new ExecReader(output, m_advise)));	788	(new ExecReader(output, m->m_advise)));
695	myloop.addselcon(m_fromcmd, Netcon::NETCONPOLL_READ);	789	myloop.addselcon(m->m_fromcmd, Netcon::NETCONPOLL_READ);
696	// Give up ownership	790	// Give up ownership
697	m_fromcmd.reset();	791	m->m_fromcmd.reset();
698	}	792	}
699	// Setup input	793	// Setup input
700	if (input) {	794	if (input) {
701	NetconCli iclicon = dynamic_cast<NetconCli >(m_tocmd.get());	795	NetconCli *iclicon = m->m_tocmd.get();
702	if (!iclicon) {	796	if (!iclicon) {
703	LOGERR(("ExecCmd::doexec: no connection from command\n"));	797	LOGERR(("ExecCmd::doexec: no connection from command\n"));
704	return -1;	798	return -1;
705	}	799	}
706	iclicon->setcallback(STD_SHARED_PTR<NetconWorker>	800	iclicon->setcallback(STD_SHARED_PTR<NetconWorker>
707	(new ExecWriter(input, m_provide)));	801	(new ExecWriter(input, m->m_provide, m)));
708	myloop.addselcon(m_tocmd, Netcon::NETCONPOLL_WRITE);	802	myloop.addselcon(m->m_tocmd, Netcon::NETCONPOLL_WRITE);
709	// Give up ownership	803	// Give up ownership
710	m_tocmd.reset();	804	m->m_tocmd.reset();
711	}	805	}
712		806
713	// Do the actual reading/writing/waiting	807	// Do the actual reading/writing/waiting
714	myloop.setperiodichandler(0, 0, m_timeoutMs);	808	myloop.setperiodichandler(0, 0, m->m_timeoutMs);
715	while ((ret = myloop.doLoop()) > 0) {	809	while ((ret = myloop.doLoop()) > 0) {
716	LOGDEB(("ExecCmd::doexec: selectloop returned %d\n", ret));	810	LOGDEB(("ExecCmd::doexec: selectloop returned %d\n", ret));
717	if (m_advise)	811	if (m->m_advise)
718	m_advise->newData(0);	812	m->m_advise->newData(0);
719	if (m_killRequest) {	813	if (m->m_killRequest) {
720	LOGINFO(("ExecCmd::doexec: cancel request\n"));	814	LOGINFO(("ExecCmd::doexec: cancel request\n"));
721	break;	815	break;
722	}	816	}
723	}	817	}
724	LOGDEB0(("ExecCmd::doexec: selectloop returned %d\n", ret));	818	LOGDEB0(("ExecCmd::doexec: selectloop returned %d\n", ret));
725	// Check for interrupt request: we won't want to waitpid()	819	// Check for interrupt request: we won't want to waitpid()
726	if (m_advise)	820	if (m->m_advise)
727	m_advise->newData(0);	821	m->m_advise->newData(0);
728		822
729	// The netcons don't take ownership of the fds: we have to close them	823	// The netcons don't take ownership of the fds: we have to close them
730	// (have to do it before wait, this may be the signal the child is	824	// (have to do it before wait, this may be the signal the child is
731	// waiting for exiting).	825	// waiting for exiting).
732	if (input) {	826	if (input) {
733	close(m_pipein[1]);	827	close(m->m_pipein[1]);
734	m_pipein[1] = -1;	828	m->m_pipein[1] = -1;
735	}	829	}
736	if (output) {	830	if (output) {
737	close(m_pipeout[0]);	831	close(m->m_pipeout[0]);
738	m_pipeout[0] = -1;	832	m->m_pipeout[0] = -1;
739	}	833	}
740	}	834	}
741		835
742	// Normal return: deactivate cleaner, wait() will do the cleanup	836	// Normal return: deactivate cleaner, wait() will do the cleanup
743	e.inactivate();	837	e.inactivate();
	...		...
748	return ret1;	842	return ret1;
749	}	843	}
750		844
751	int ExecCmd::send(const string& data)	845	int ExecCmd::send(const string& data)
752	{	846	{
753	NetconCli con = dynamic_cast<NetconCli >(m_tocmd.get());	847	NetconCli *con = m->m_tocmd.get();
754	if (con == 0) {	848	if (con == 0) {
755	LOGERR(("ExecCmd::send: outpipe is closed\n"));	849	LOGERR(("ExecCmd::send: outpipe is closed\n"));
756	return -1;	850	return -1;
757	}	851	}
758	unsigned int nwritten = 0;	852	unsigned int nwritten = 0;
759	while (nwritten < data.length()) {	853	while (nwritten < data.length()) {
760	if (m_killRequest)	854	if (m->m_killRequest)
761	break;	855	break;
762	int n = con->send(data.c_str() + nwritten, data.length() - nwritten);	856	int n = con->send(data.c_str() + nwritten, data.length() - nwritten);
763	if (n < 0) {	857	if (n < 0) {
764	LOGERR(("ExecCmd::send: send failed\n"));	858	LOGERR(("ExecCmd::send: send failed\n"));
765	return -1;	859	return -1;
	...		...
769	return nwritten;	863	return nwritten;
770	}	864	}
771		865
772	int ExecCmd::receive(string& data, int cnt)	866	int ExecCmd::receive(string& data, int cnt)
773	{	867	{
774	NetconCli con = dynamic_cast<NetconCli >(m_fromcmd.get());	868	NetconCli *con = m->m_fromcmd.get();