--- a/src/execmd.cpp
+++ b/src/execmd.cpp
@@ -15,7 +15,11 @@
  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  */
 #ifndef TEST_EXECMD
+#ifdef BUILDING_RECOLL
+#include "autoconfig.h"
+#else
 #include "config.h"
+#endif
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -24,6 +28,8 @@
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <sys/select.h>
+#include <sys/time.h>
+#include <sys/resource.h>
 #include <fcntl.h>
 #include <errno.h>
 #include <signal.h>
@@ -31,21 +37,30 @@
 
 #include <vector>
 #include <string>
+#include <stdexcept>
+#ifdef HAVE_SPAWN_H
+#ifndef __USE_GNU
+#define __USE_GNU
+#define undef__USE_GNU
+#endif
+#include <spawn.h>
+#ifdef undef__USE_GNU
+#undef __USE_GNU
+#endif
+#endif
 
 #include "execmd.h"
 
 #include "netcon.h"
 #include "closefrom.h"
+#include "smallut.h"
 
 using namespace std;
 
 extern char **environ;
 
-bool ExecCmd::o_useVfork = false;
-
-#ifdef RECOLL_DATADIR
+#ifdef BUILDING_RECOLL
 #include "debuglog.h"
-#include "smallut.h"
 
 #else
 // If compiling outside of recoll, make the file as standalone as reasonable.
@@ -60,43 +75,97 @@
 #define LOGDEB3(X)
 #define LOGDEB4(X)
 
-#ifndef MIN
-#define MIN(A,B) ((A) < (B) ? (A) : (B))
-#endif
-
-static void stringToTokens(const string &s, vector<string> &tokens, 
-                           const string &delims = " \t", bool skipinit=true);
-
-static void stringToTokens(const string& str, vector<string>& tokens,
-                           const string& delims, bool skipinit)
-{
-    string::size_type startPos = 0, pos;
-
-    // Skip initial delims, return empty if this eats all.
-    if (skipinit && 
-	(startPos = str.find_first_not_of(delims, 0)) == string::npos) {
-	return;
-    }
-    while (startPos < str.size()) { 
-        // Find next delimiter or end of string (end of token)
-        pos = str.find_first_of(delims, startPos);
-
-        // Add token to the vector and adjust start
-	if (pos == string::npos) {
-	    tokens.push_back(str.substr(startPos));
-	    break;
-	} else if (pos == startPos) {
-	    // Dont' push empty tokens after first
-	    if (tokens.empty())
-		tokens.push_back(string());
-	    startPos = ++pos;
-	} else {
-	    tokens.push_back(str.substr(startPos, pos - startPos));
-	    startPos = ++pos;
-	}
-    }
-}
-#endif // RECOLL_DATADIR
+#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(int)
+{
+    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();
+}
+
+bool ExecCmd::requestChildExit()
+{
+    if (m->m_pid > 0) {
+        if (kill(m->m_pid, SIGTERM) == 0) {
+            return true;
+        }
+    }
+    return false;
+}
 
 /* From FreeBSD's which command */
 static bool exec_is_there(const char *candidate)
@@ -105,57 +174,71 @@
 
     /* XXX work around access(2) false positives for superuser */
     if (access(candidate, X_OK) == 0 &&
-	stat(candidate, &fin) == 0 &&
-	S_ISREG(fin.st_mode) &&
-	(getuid() != 0 ||
-	 (fin.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) != 0)) {
-	return true;
+            stat(candidate, &fin) == 0 &&
+            S_ISREG(fin.st_mode) &&
+            (getuid() != 0 ||
+             (fin.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) != 0)) {
+        return true;
     }
     return false;
 }
 
 bool ExecCmd::which(const string& cmd, string& exepath, const char* path)
 {
-    if (cmd.empty()) 
-	return false;
+    if (cmd.empty()) {
+        return false;
+    }
     if (cmd[0] == '/') {
-	if (exec_is_there(cmd.c_str())) {
-	    exepath = cmd;
-	    return true;
-	} else {
-	    return false;
-	}
+        if (exec_is_there(cmd.c_str())) {
+            exepath = cmd;
+            return true;
+        } else {
+            return false;
+        }
     }
 
     const char *pp;
     if (path) {
-	pp = path;
+        pp = path;
     } else {
-	pp = getenv("PATH");
-    }
-    if (pp == 0)
-	return false;
+        pp = getenv("PATH");
+    }
+    if (pp == 0) {
+        return false;
+    }
 
     vector<string> pels;
     stringToTokens(pp, pels, ":");
     for (vector<string>::iterator it = pels.begin(); it != pels.end(); it++) {
-	if (it->empty())
-	    *it = ".";
-	string candidate = (it->empty() ? string(".") : *it) + "/" + cmd;
-	if (exec_is_there(candidate.c_str())) {
-	    exepath = candidate;
-	    return true;
-	}
+        if (it->empty()) {
+            *it = ".";
+        }
+        string candidate = (it->empty() ? string(".") : *it) + "/" + cmd;
+        if (exec_is_there(candidate.c_str())) {
+            exepath = candidate;
+            return true;
+        }
     }
     return false;
 }
 
-void  ExecCmd::putenv(const string &ea)
-{
-    m_env.push_back(ea);
-}
-
-void  ExecCmd::putenv(const string &name, const string& value)
+void ExecCmd::useVfork(bool on)
+{
+    // Just in case: there are competent people who believe that the
+    // 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;
     putenv(ea);
@@ -169,70 +252,83 @@
     nanosleep(&spec, 0);
 }
 
-/** A resource manager to ensure that execcmd cleans up if an exception is 
+/** 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 *parent) : m_parent(parent), m_active(true) {}
-    void inactivate() {m_active = false;}
+    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()));
-
-	// Better to close the descs first in case the child is waiting in read
-	if (m_parent->m_pipein[0] >= 0)
-	    close(m_parent->m_pipein[0]);
-	if (m_parent->m_pipein[1] >= 0)
-	    close(m_parent->m_pipein[1]);
-	if (m_parent->m_pipeout[0] >= 0)
-	    close(m_parent->m_pipeout[0]);
-	if (m_parent->m_pipeout[1] >= 0)
-	    close(m_parent->m_pipeout[1]);
-
-	// It's apparently possible for m_pid to be > 0 and getpgid to fail. In
-	// this case, we have to conclude that the child process does 
-	// not exist. Not too sure what causes this, but the previous code
-	// definitely tried to call killpg(-1,) from time to time.
-	pid_t grp;
-	if (m_parent->m_pid > 0 && (grp = getpgid(m_parent->m_pid)) > 0) {
-	    LOGDEB(("ExecCmd: killpg(%d, SIGTERM)\n", grp));
+        if (!m_active || !m_parent) {
+            return;
+        }
+        LOGDEB1(("~ExecCmdRsrc: working. mypid: %d\n", (int)getpid()));
+
+        // Better to close the descs first in case the child is waiting in read
+        if (m_parent->m_pipein[0] >= 0) {
+            close(m_parent->m_pipein[0]);
+        }
+        if (m_parent->m_pipein[1] >= 0) {
+            close(m_parent->m_pipein[1]);
+        }
+        if (m_parent->m_pipeout[0] >= 0) {
+            close(m_parent->m_pipeout[0]);
+        }
+        if (m_parent->m_pipeout[1] >= 0) {
+            close(m_parent->m_pipeout[1]);
+        }
+
+        // It's apparently possible for m_pid to be > 0 and getpgid to fail. In
+        // this case, we have to conclude that the child process does
+        // not exist. Not too sure what causes this, but the previous code
+        // definitely tried to call killpg(-1,) from time to time.
+        pid_t grp;
+        if (m_parent->m_pid > 0 && (grp = getpgid(m_parent->m_pid)) > 0) {
+            LOGDEB(("ExecCmd: killpg(%d, SIGTERM)\n", grp));
             int ret = killpg(grp, SIGTERM);
-	    if (ret == 0) {
-		for (int i = 0; i < 3; i++) {
-		    msleep(i == 0 ? 5 : (i == 1 ? 100 : 2000));
-		    int status;
-		    (void)waitpid(m_parent->m_pid, &status, WNOHANG);
-		    if (kill(m_parent->m_pid, 0) != 0)
-			break;
-		    if (i == 2) {
-			LOGDEB(("ExecCmd: killpg(%d, SIGKILL)\n", grp));
-			killpg(grp, SIGKILL);
-			(void)waitpid(m_parent->m_pid, &status, WNOHANG);
-		    }
-		}
-	    } else {
+            if (ret == 0) {
+                for (int i = 0; i < 3; i++) {
+                    msleep(i == 0 ? 5 : (i == 1 ? 100 : 2000));
+                    int status;
+                    (void)waitpid(m_parent->m_pid, &status, WNOHANG);
+                    if (kill(m_parent->m_pid, 0) != 0) {
+                        break;
+                    }
+                    if (i == 2) {
+                        LOGDEB(("ExecCmd: killpg(%d, SIGKILL)\n", grp));
+                        killpg(grp, SIGKILL);
+                        (void)waitpid(m_parent->m_pid, &status, WNOHANG);
+                    }
+                }
+            } else {
                 LOGERR(("ExecCmd: error killing process group %d: %d\n",
                         grp, errno));
             }
-	}
-	m_parent->m_tocmd.reset();
-	m_parent->m_fromcmd.reset();
-	pthread_sigmask(SIG_UNBLOCK, &m_parent->m_blkcld, 0);
-	m_parent->reset();
+        }
+        m_parent->m_tocmd.reset();
+        m_parent->m_fromcmd.reset();
+        pthread_sigmask(SIG_UNBLOCK, &m_parent->m_blkcld, 0);
+        m_parent->reset();
     }
 private:
-    ExecCmd *m_parent;
+    ExecCmd::Internal *m_parent;
     bool    m_active;
 };
 
 ExecCmd::~ExecCmd()
 {
-    ExecCmdRsrc(this);
-}
-
-// In child process. Set up pipes and exec command. 
+    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
 //     process memory at all is allowed ***
@@ -240,104 +336,150 @@
 // errors, which we would most definitely want to have a hint about.
 //
 // Note that any of the LOGXX calls could block on a mutex set in the
-// father process, so that only absolutely exceptional conditions, 
+// 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::dochild(const string &cmd, const char **argv,
-			     const char **envv,
-			     bool has_input, bool has_output)
+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));
+        LOGINFO(("ExecCmd::DOCHILD: setpgid(0, %d) failed: errno %d\n",
+                 getpid(), errno));
     }
 
     // Restore SIGTERM to default. Really, signal handling should be
-    // specified when creating the execmd. Help Recoll get rid of its
-    // filter children though. To be fixed one day... Not sure that
-    // all of this is needed. But an ignored sigterm and the masks are
-    // normally inherited.
+    // specified when creating the execmd, there might be other
+    // signals to reset. Resetting SIGTERM helps Recoll get rid of its
+    // filter children for now though. To be fixed one day...
+    // Note that resetting to SIG_DFL is a portable use of
+    // signal(). No need for sigaction() here.
+
+    // There is supposedely a risk of problems if another thread was
+    // calling a signal-affecting function when vfork was called. This
+    // seems acceptable though as no self-respecting thread is going
+    // to mess with the global process signal disposition.
+
     if (signal(SIGTERM, SIG_DFL) == SIG_ERR) {
-	//LOGERR(("ExecCmd::DOCHILD: signal() failed, errno %d\n", errno));
+        //LOGERR(("ExecCmd::DOCHILD: signal() failed, errno %d\n", errno));
     }
     sigset_t sset;
     sigfillset(&sset);
     pthread_sigmask(SIG_UNBLOCK, &sset, 0);
     sigprocmask(SIG_UNBLOCK, &sset, 0);
 
+#ifdef HAVE_SETRLIMIT
+#if defined RLIMIT_AS || defined RLIMIT_VMEM || defined RLIMIT_DATA
+    if (m_rlimit_as_mbytes > 2000 && sizeof(rlim_t) < 8) {
+        // Impossible limit, don't use it
+        m_rlimit_as_mbytes = 0;
+    }
+    if (m_rlimit_as_mbytes > 0) {
+        struct rlimit ram_limit = {
+            static_cast<rlim_t>(m_rlimit_as_mbytes * 1024 * 1024),
+            RLIM_INFINITY
+        };
+        int resource;
+
+        // RLIMIT_AS and RLIMIT_VMEM are usually synonyms when VMEM is
+        // defined. RLIMIT_AS is Posix. Both don't really do what we
+        // want, because they count e.g. shared lib mappings, which we
+        // don't really care about.
+        // RLIMIT_DATA only limits the data segment. Modern mallocs
+        // use mmap and will not be bound. (Otoh if we only have this,
+        // we're probably not modern).
+        // So we're unsatisfied either way.
+#ifdef RLIMIT_AS
+        resource = RLIMIT_AS;
+#elif defined RLIMIT_VMEM
+        resource = RLIMIT_VMEM;
+#else
+        resource = RLIMIT_DATA;
+#endif
+        setrlimit(resource, &ram_limit);
+    }
+#endif
+#endif // have_setrlimit
+
     if (has_input) {
-	close(m_pipein[1]);
-	if (m_pipein[0] != 0) {
-	    dup2(m_pipein[0], 0);
-	    close(m_pipein[0]);
-	}
+        close(m_pipein[1]);
+        if (m_pipein[0] != 0) {
+            dup2(m_pipein[0], 0);
+            close(m_pipein[0]);
+        }
     }
     if (has_output) {
-	close(m_pipeout[0]);
-	if (m_pipeout[1] != 1) {
-	    if (dup2(m_pipeout[1], 1) < 0) {
-		LOGERR(("ExecCmd::DOCHILD: dup2() failed. errno %d\n", errno));
-	    }
-	    if (close(m_pipeout[1]) < 0) {
-		LOGERR(("ExecCmd::DOCHILD: close() failed. errno %d\n", errno));
-	    }
-	}
+        close(m_pipeout[0]);
+        if (m_pipeout[1] != 1) {
+            if (dup2(m_pipeout[1], 1) < 0) {
+                LOGERR(("ExecCmd::DOCHILD: dup2() failed. errno %d\n", errno));
+            }
+            if (close(m_pipeout[1]) < 0) {
+                LOGERR(("ExecCmd::DOCHILD: close() failed. errno %d\n", errno));
+            }
+        }
     }
     // Do we need to redirect stderr ?
     if (!m_stderrFile.empty()) {
-	int fd = open(m_stderrFile.c_str(), O_WRONLY|O_CREAT
+        int fd = open(m_stderrFile.c_str(), O_WRONLY | O_CREAT
 #ifdef O_APPEND
-		      |O_APPEND
+                      | O_APPEND
 #endif
-		      , 0600);
-	if (fd < 0) {
-	    close(2);
-	} else {
-	    if (fd != 2) {
-		dup2(fd, 2);
-	    }
-	    lseek(2, 0, 2);
-	}
+                      , 0600);
+        if (fd < 0) {
+            close(2);
+        } else {
+            if (fd != 2) {
+                dup2(fd, 2);
+            }
+            lseek(2, 0, 2);
+        }
     }
 
     // Close all descriptors except 0,1,2
     libclf_closefrom(3);
 
     execve(cmd.c_str(), (char *const*)argv, (char *const*)envv);
-    // Hu ho. This should never happened as we checked the existence of the
-    // executable before calling dochild... Until we did this, this was 
-    // the chief cause of LOG mutex deadlock
+    // Hu ho. This should never have happened as we checked the
+    // existence of the executable before calling dochild... Until we
+    // did this check, this was the chief cause of LOG mutex deadlock
     LOGERR(("ExecCmd::DOCHILD: execve(%s) failed. errno %d\n", cmd.c_str(),
-	    errno));
+            errno));
     _exit(127);
 }
 
-int ExecCmd::startExec(const string &cmd, const vector<string>& args,
-		       bool has_input, bool has_output)
-{
-    { // Debug and logging
-	string command = cmd + " ";
-	for (vector<string>::const_iterator it = args.begin();
-             it != args.end(); it++) {
-	    command += "{" + *it + "} ";
-	}
-	LOGDEB(("ExecCmd::startExec: (%d|%d) %s\n", 
-		has_input, has_output, command.c_str()));
+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)
+{
+    {
+        // Debug and logging
+        string command = cmd + " ";
+        for (vector<string>::const_iterator it = args.begin();
+                it != args.end(); it++) {
+            command += "{" + *it + "} ";
+        }
+        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);
-
-    if (has_input && pipe(m_pipein) < 0) {
-	LOGERR(("ExecCmd::startExec: pipe(2) failed. errno %d\n", errno));
-	return -1;
-    }
-    if (has_output && pipe(m_pipeout) < 0) {
-	LOGERR(("ExecCmd::startExec: pipe(2) failed. errno %d\n", errno));
-	return -1;
+    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;
     }
 
 
@@ -350,9 +492,9 @@
     // Allocate arg vector (2 more for arg0 + final 0)
     typedef const char *Ccharp;
     Ccharp *argv;
-    argv = (Ccharp *)malloc((args.size()+2) * sizeof(char *));
+    argv = (Ccharp *)malloc((args.size() + 2) * sizeof(char *));
     if (argv == 0) {
-	LOGERR(("ExecCmd::doexec: malloc() failed. errno %d\n",	errno));
+        LOGERR(("ExecCmd::doexec: malloc() failed. errno %d\n", errno));
         return -1;
     }
     // Fill up argv
@@ -360,27 +502,29 @@
     int i = 1;
     vector<string>::const_iterator it;
     for (it = args.begin(); it != args.end(); it++) {
-	argv[i++] = it->c_str();
+        argv[i++] = it->c_str();
     }
     argv[i] = 0;
 
     Ccharp *envv;
     int envsize;
-    for (envsize = 0; ; envsize++) 
-	if (environ[envsize] == 0)
-	    break;
-    envv = (Ccharp *)malloc((envsize + m_env.size() + 2) * sizeof(char *));
+    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));
+        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_env.begin(); 
-	 it != m_env.end(); it++) {
-	envv[eidx++] = it->c_str();
+    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;
 
@@ -392,25 +536,101 @@
         free(envv);
         return -1;
     }
-////////////////////////////////
-
-    if (o_useVfork) {
-	m_pid = vfork();
+//////////////////////////////// End vfork child prepare section.
+
+#if HAVE_POSIX_SPAWN && USE_POSIX_SPAWN
+    // Note that posix_spawn provides no way to setrlimit() the child.
+    {
+        posix_spawnattr_t attrs;
+        posix_spawnattr_init(&attrs);
+        short flags;
+        posix_spawnattr_getflags(&attrs, &flags);
+
+        flags |=  POSIX_SPAWN_USEVFORK;
+
+        posix_spawnattr_setpgroup(&attrs, 0);
+        flags |= POSIX_SPAWN_SETPGROUP;
+
+        sigset_t sset;
+        sigemptyset(&sset);
+        posix_spawnattr_setsigmask(&attrs, &sset);
+        flags |= POSIX_SPAWN_SETSIGMASK;
+
+        sigemptyset(&sset);
+        sigaddset(&sset, SIGTERM);
+        posix_spawnattr_setsigdefault(&attrs, &sset);
+        flags |= POSIX_SPAWN_SETSIGDEF;
+
+        posix_spawnattr_setflags(&attrs, flags);
+
+        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
+        // calling closefrom(). Afaik there is a solaris extension for this,
+        // 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",
+                    ret));
+            return -1;
+        }
+    }
+
+#else
+    if (Internal::o_useVfork) {
+        LOGDEB1(("using VFORK\n"));
+        m->m_pid = vfork();
     } else {
-	m_pid = fork();
-    }
-    if (m_pid < 0) {
-	LOGERR(("ExecCmd::startExec: fork(2) failed. errno %d\n", errno));
-	return -1;
-    }
-    if (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.
-	dochild(exe, argv, envv, has_input, has_output);
-	// dochild does not return. Just in case...
-	_exit(1);
-    }
+        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
 
     // Father process
 
@@ -422,30 +642,30 @@
 
     // Set the process group for the child. This is also done in the
     // child process see wikipedia(Process_group)
-    if (setpgid(m_pid, m_pid)) {
-        // This can fail with EACCES if the son has already done execve 
+    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_pid, m_pid, errno));
-    }
-
-    sigemptyset(&m_blkcld);
-    sigaddset(&m_blkcld, SIGCHLD);
-    pthread_sigmask(SIG_BLOCK, &m_blkcld, 0);
+                 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_pipein[0]);
-	m_pipein[0] = -1;
-	NetconCli *iclicon = new NetconCli();
-	iclicon->setconn(m_pipein[1]);
-	m_tocmd = NetconP(iclicon);
+        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_pipeout[1]);
-	m_pipeout[1] = -1;
-	NetconCli *oclicon = new NetconCli();
-	oclicon->setconn(m_pipeout[0]);
-	m_fromcmd = NetconP(oclicon);
+        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 ! */
@@ -457,40 +677,51 @@
 // Netcon callback. Send data to the command's input
 class ExecWriter : public NetconWorker {
 public:
-    ExecWriter(const string *input, ExecCmdProvide *provide) 
-	: m_input(input), m_cnt(0), m_provide(provide)
-    {}				    
-    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.
-	    if (m_provide) {
-		m_provide->newData();
-		if (m_input->empty()) {
-		    return 0;
-		} else {
-		    m_cnt = 0;
-		}
-		LOGDEB2(("ExecWriter: provide m_cnt %d input length %d\n", 
-			 m_cnt, m_input->length()));
-	    } else {
-		return 0;
-	    }
-	}
-	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) {
-	    LOGERR(("ExecWriter: data: can't write\n"));
-	    return -1;
-	}
-	m_cnt += ret;
-	return ret;
+    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) {
+            LOGERR(("ExecWriter: data: can't write\n"));
+            return -1;
+        }
+        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;
@@ -499,22 +730,22 @@
 // Netcon callback. Get data from the command output.
 class ExecReader : public NetconWorker {
 public:
-    ExecReader(string *output, ExecCmdAdvise *advise) 
-	: m_output(output), m_advise(advise)
-    {}				    
-    virtual int data(NetconData *con, Netcon::Event reason)
-    {
-	char buf[8192];
-	int n = con->receive(buf, 8192);
-	LOGDEB1(("ExecReader: got %d from command\n", n));
-	if (n < 0) {
-	    LOGERR(("ExecCmd::doexec: receive failed. errno %d\n", errno));
-	} else if (n > 0) {
-	    m_output->append(buf, n);
-	    if (m_advise)
-		m_advise->newData(n);
-	} // else n == 0, just return
-	return n;
+    ExecReader(string *output, ExecCmdAdvise *advise)
+        : m_output(output), m_advise(advise) {
+    }
+    virtual int data(NetconData *con, Netcon::Event reason) {
+        char buf[8192];
+        int n = con->receive(buf, 8192);
+        LOGDEB1(("ExecReader: got %d from command\n", n));
+        if (n < 0) {
+            LOGERR(("ExecCmd::doexec: receive failed. errno %d\n", errno));
+        } else if (n > 0) {
+            m_output->append(buf, n);
+            if (m_advise) {
+                m_advise->newData(n);
+            }
+        } // else n == 0, just return
+        return n;
     }
 private:
     string        *m_output;
@@ -522,72 +753,74 @@
 };
 
 
-int ExecCmd::doexec(const string &cmd, const vector<string>& args,
-		    const string *input, string *output)
+int ExecCmd::doexec(const string& cmd, const vector<string>& args,
+                    const string *input, string *output)
 {
 
     if (startExec(cmd, args, input != 0, output != 0) < 0) {
-	return -1;
+        return -1;
     }
 
     // Cleanup in case we return early
-    ExecCmdRsrc e(this);
+    ExecCmdRsrc e(this->m);
     SelectLoop myloop;
     int ret = 0;
     if (input || output) {
         // Setup output
-	if (output) {
-	    NetconCli *oclicon = dynamic_cast<NetconCli *>(m_fromcmd.get());
-	    if (!oclicon) {
-		LOGERR(("ExecCmd::doexec: no connection from command\n"));
-		return -1;
-	    }
-	    oclicon->setcallback(make_shared<ExecReader>
-				 (ExecReader(output, m_advise)));
-	    myloop.addselcon(m_fromcmd, Netcon::NETCONPOLL_READ);
-	    // Give up ownership 
-	    m_fromcmd.reset();
-	} 
+        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 = dynamic_cast<NetconCli *>(m_tocmd.get());
-	    if (!iclicon) {
-		LOGERR(("ExecCmd::doexec: no connection from command\n"));
-		return -1;
-	    }
-	    iclicon->setcallback(make_shared<ExecWriter>
-				 (ExecWriter(input, m_provide)));
-	    myloop.addselcon(m_tocmd, Netcon::NETCONPOLL_WRITE);
-	    // Give up ownership 
-	    m_tocmd.reset();
-	}
+        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_timeoutMs);
-	while ((ret = myloop.doLoop()) > 0) {
-	    LOGDEB(("ExecCmd::doexec: selectloop returned %d\n", ret));
-	    if (m_advise)
-		m_advise->newData(0);
-	    if (m_killRequest) {
-		LOGINFO(("ExecCmd::doexec: cancel request\n"));
-		break;
-	    }
-	}
-	LOGDEB0(("ExecCmd::doexec: selectloop returned %d\n", ret));
+        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_advise)
-            m_advise->newData(0);
+        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 
+        // (have to do it before wait, this may be the signal the child is
         // waiting for exiting).
         if (input) {
-            close(m_pipein[1]);
-            m_pipein[1] = -1;
+            close(m->m_pipein[1]);
+            m->m_pipein[1] = -1;
         }
         if (output) {
-            close(m_pipeout[0]);
-            m_pipeout[0] = -1;
+            close(m->m_pipeout[0]);
+            m->m_pipeout[0] = -1;
         }
     }
 
@@ -595,38 +828,40 @@
     e.inactivate();
 
     int ret1 = ExecCmd::wait();
-    if (ret)
-	return -1;
+    if (ret) {
+        return -1;
+    }
     return ret1;
 }
 
 int ExecCmd::send(const string& data)
 {
-    NetconCli *con = dynamic_cast<NetconCli *>(m_tocmd.get());
+    NetconCli *con = m->m_tocmd.get();
     if (con == 0) {
-	LOGERR(("ExecCmd::send: outpipe is closed\n"));
-	return -1;
+        LOGERR(("ExecCmd::send: outpipe is closed\n"));
+        return -1;
     }
     unsigned int nwritten = 0;
     while (nwritten < data.length()) {
-	if (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;
-	}
-	nwritten += n;
+        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;
+        }
+        nwritten += n;
     }
     return nwritten;
 }
 
 int ExecCmd::receive(string& data, int cnt)
 {
-    NetconCli *con = dynamic_cast<NetconCli *>(m_fromcmd.get());
+    NetconCli *con = m->m_fromcmd.get();
     if (con == 0) {
-	LOGERR(("ExecCmd::receive: inpipe is closed\n"));
-	return -1;
+        LOGERR(("ExecCmd::receive: inpipe is closed\n"));
+        return -1;
     }
     const int BS = 4096;
     char buf[BS];
@@ -648,66 +883,124 @@
     return ntot;
 }
 
-int ExecCmd::getline(string& data, int timeo)
-{
-    NetconCli *con = dynamic_cast<NetconCli *>(m_fromcmd.get());
+int ExecCmd::getline(string& data)
+{
+    NetconCli *con = m->m_fromcmd.get();
     if (con == 0) {
-	LOGERR(("ExecCmd::receive: inpipe is closed\n"));
-	return -1;
+        LOGERR(("ExecCmd::receive: inpipe is closed\n"));
+        return -1;
     }
     const int BS = 1024;
     char buf[BS];
-    int n = con->getline(buf, BS, timeo);
+    int timeosecs = m->m_timeoutMs / 1000;
+    if (timeosecs == 0) {
+        timeosecs = 1;
+    }
+
+    // Note that we only go once through here, except in case of
+    // timeout, which is why I think that the goto is more expressive
+    // than a loop
+again:
+    int n = con->getline(buf, BS, timeosecs);
     if (n < 0) {
-	LOGERR(("ExecCmd::getline: error\n"));
+        if (con->timedout()) {
+            LOGDEB(("ExecCmd::getline: timeout\n"));
+            if (m->m_advise) {
+                m->m_advise->newData(0);
+            }
+            goto again;
+        }
+        LOGERR(("ExecCmd::getline: error\n"));
     } else if (n > 0) {
-	data.append(buf, n);
+        data.append(buf, n);
     } else {
-	LOGDEB(("ExecCmd::getline: got 0\n"));
+        LOGDEB(("ExecCmd::getline: got 0\n"));
     }
     return n;
 }
 
+class GetlineWatchdog : public ExecCmdAdvise {
+public:
+    GetlineWatchdog(int secs) : m_secs(secs), tstart(time(0)) {}
+    void newData(int cnt) {
+        if (time(0) - tstart >= m_secs) {
+            throw std::runtime_error("getline timeout");
+        }
+    }
+    int m_secs;
+    time_t tstart;
+};
+
+int ExecCmd::getline(string& data, int timeosecs)
+{
+    GetlineWatchdog gwd(timeosecs);
+    setAdvise(&gwd);
+    try {
+        return getline(data);
+    } catch (...) {
+        return -1;
+    }
+}
+
+
 // 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);
+    ExecCmdRsrc e(this->m);
     int status = -1;
-    if (!m_killRequest && m_pid > 0) {
-	if (waitpid(m_pid, &status, 0) < 0) {
-	    LOGERR(("ExecCmd::waitpid: returned -1 errno %d\n", errno));
-	    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_pid = -1;
-    }
-    // Let the ExecCmdRsrc cleanup
+        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);
+    ExecCmdRsrc e(this->m);
     *status = -1;
 
-    if (m_pid <= 0) {
-	// Already waited for ??
-	return true;
-    }
-
-    pid_t pid = waitpid(m_pid, status, WNOHANG);
+    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_pid = -1;
-	return true;
+        m->m_pid = -1;
+        return true;
     } else if (pid == 0) {
-	LOGDEB1(("ExecCmd::maybereap: not exited yet\n"));
-	e.inactivate();
-	return false;
+        LOGDEB1(("ExecCmd::maybereap: not exited yet\n"));
+        e.inactivate();
+        return false;
     } else {
         LOGDEB(("ExecCmd::maybereap: got status 0x%x\n", status));
-	m_pid = -1;
-	return true;
+        m->m_pid = -1;
+        return true;
     }
 }
 
@@ -731,43 +1024,45 @@
 void ReExec::init(int argc, char *args[])
 {
     for (int i = 0; i < argc; i++) {
-	m_argv.push_back(args[i]);
+        m_argv.push_back(args[i]);
     }
     m_cfd = open(".", 0);
     char *cd = getcwd(0, 0);
-    if (cd) 
-	m_curdir = cd;
+    if (cd) {
+        m_curdir = cd;
+    }
     free(cd);
 }
 
 void ReExec::insertArgs(const vector<string>& args, int idx)
 {
     vector<string>::iterator it, cit;
-    unsigned int cmpoffset = (unsigned int)-1;
+    unsigned int cmpoffset = (unsigned int) - 1;
 
     if (idx == -1 || string::size_type(idx) >= m_argv.size()) {
-	it = m_argv.end();
-	if (m_argv.size() >= args.size()) {
-	    cmpoffset = m_argv.size() - args.size();
-	}
+        it = m_argv.end();
+        if (m_argv.size() >= args.size()) {
+            cmpoffset = m_argv.size() - args.size();
+        }
     } else {
-	it = m_argv.begin() + idx;
-	if (idx + args.size() <= m_argv.size()) {
-	    cmpoffset = idx;
-	}
+        it = m_argv.begin() + idx;
+        if (idx + args.size() <= m_argv.size()) {
+            cmpoffset = idx;
+        }
     }
 
     // Check that the option is not already there
-    if (cmpoffset != (unsigned int)-1) {
-	bool allsame = true;
-	for (unsigned int i = 0; i < args.size(); i++) {
-	    if (m_argv[cmpoffset + i] != args[i]) {
-		allsame = false;
-		break;
-	    }
-	}
-	if (allsame)
-	    return;
+    if (cmpoffset != (unsigned int) - 1) {
+        bool allsame = true;
+        for (unsigned int i = 0; i < args.size(); i++) {
+            if (m_argv[cmpoffset + i] != args[i]) {
+                allsame = false;
+                break;
+            }
+        }
+        if (allsame) {
+            return;
+        }
     }
 
     m_argv.insert(it, args.begin(), args.end());
@@ -775,10 +1070,11 @@
 
 void ReExec::removeArg(const string& arg)
 {
-    for (vector<string>::iterator it = m_argv.begin(); 
-	 it != m_argv.end(); it++) {
-	if (*it == arg)
-	    it = m_argv.erase(it);
+    for (vector<string>::iterator it = m_argv.begin();
+            it != m_argv.end(); it++) {
+        if (*it == arg) {
+            it = m_argv.erase(it);
+        }
     }
 }
 
@@ -788,30 +1084,30 @@
 
 #if 0
     char *cwd;
-    cwd = getcwd(0,0);
+    cwd = getcwd(0, 0);
     FILE *fp = stdout; //fopen("/tmp/exectrace", "w");
     if (fp) {
-	fprintf(fp, "reexec: pwd: [%s] args: ", cwd?cwd:"getcwd failed");
-	for (vector<string>::const_iterator it = m_argv.begin();
-	     it != m_argv.end(); it++) {
-	    fprintf(fp, "[%s] ", it->c_str());
-	}
-	fprintf(fp, "\n");
+        fprintf(fp, "reexec: pwd: [%s] args: ", cwd ? cwd : "getcwd failed");
+        for (vector<string>::const_iterator it = m_argv.begin();
+                it != m_argv.end(); it++) {
+            fprintf(fp, "[%s] ", it->c_str());
+        }
+        fprintf(fp, "\n");
     }
 #endif
 
     // Execute the atexit funcs
     while (!m_atexitfuncs.empty()) {
-	(m_atexitfuncs.top())();
-	m_atexitfuncs.pop();
+        (m_atexitfuncs.top())();
+        m_atexitfuncs.pop();
     }
 
     // Try to get back to the initial working directory
     if (m_cfd < 0 || fchdir(m_cfd) < 0) {
-	LOGINFO(("ReExec::reexec: fchdir failed, trying chdir\n"));
-	if (!m_curdir.empty() && chdir(m_curdir.c_str())) {
-	    LOGERR(("ReExec::reexec: chdir failed\n"));
-	}
+        LOGINFO(("ReExec::reexec: fchdir failed, trying chdir\n"));
+        if (!m_curdir.empty() && chdir(m_curdir.c_str())) {
+            LOGERR(("ReExec::reexec: chdir failed\n"));
+        }
     }
 
     // Close all descriptors except 0,1,2
@@ -820,17 +1116,17 @@
     // Allocate arg vector (1 more for final 0)
     typedef const char *Ccharp;
     Ccharp *argv;
-    argv = (Ccharp *)malloc((m_argv.size()+1) * sizeof(char *));
+    argv = (Ccharp *)malloc((m_argv.size() + 1) * sizeof(char *));
     if (argv == 0) {
-	LOGERR(("ExecCmd::doexec: malloc() failed. errno %d\n",	errno));
-	return;
-    }
-	
+        LOGERR(("ExecCmd::doexec: malloc() failed. errno %d\n", errno));
+        return;
+    }
+
     // Fill up argv
     int i = 0;
     vector<string>::const_iterator it;
     for (it = m_argv.begin(); it != m_argv.end(); it++) {
-	argv[i++] = it->c_str();
+        argv[i++] = it->c_str();
     }
     argv[i] = 0;
     execvp(m_argv[0].c_str(), (char *const*)argv);
@@ -839,169 +1135,369 @@
 
 ////////////////////////////////////////////////////////////////////
 #else // TEST
+
 #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 "execmd.h"
+#ifdef BUILDING_RECOLL
+#include "smallut.h"
+#include "cancelcheck.h"
+#endif
+
 using namespace std;
 
-#include "execmd.h"
+#ifdef BUILDING_RECOLL
+// 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;
+}
+#endif
+
+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"
+    "trexecmd -l cmd test getline\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_b	  0x4 
+#define OPT_i     0x4
 #define OPT_w     0x8
 #define OPT_c     0x10
 #define OPT_r     0x20
-
-const char *data = "Une ligne de donnees\n";
-class CancelExcept {};
+#define OPT_m     0x40
+#define OPT_o     0x80
+#define OPT_l     0x100
+
+// 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:
-    ExecCmd *cmd;
     void newData(int cnt) {
-	if (op_flags & OPT_c) {
-	    static int  callcnt;
-	    if (callcnt++ == 3) {
-		throw CancelExcept();
-	    }
-	}
-	cerr << "newData(" << cnt << ")" << endl;
-	//	CancelCheck::instance().setCancel();
-	//	CancelCheck::instance().checkCancel();
-	//	cmd->setCancel();
+        if (op_flags & OPT_c) {
+#ifdef BUILDING_RECOLL
+            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();
+            }
+#endif
+        }
+        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) 
-	: m_input(i)
-    {
-	m_fp = fopen("/etc/group", "r");
+    MEPv(string *i)
+        : m_input(i) {
+        m_fp = fopen("/etc/group", "r");
     }
     ~MEPv() {
-	if (m_fp)
-	    fclose(m_fp);
+        if (m_fp) {
+            fclose(m_fp);
+        }
     }
     void newData() {
-	char line[1024];
-	if (m_fp && fgets(line, 1024, m_fp)) {
-	    m_input->assign((const char *)line);
-	} else {
-	    m_input->erase();
-	}
+        char line[1024];
+        if (m_fp && fgets(line, 1024, m_fp)) {
+            m_input->assign((const char *)line);
+        } else {
+            m_input->erase();
+        }
     }
 };
 
 
-static char *thisprog;
-static char usage [] =
-"trexecmd [-c|-r] cmd [arg1 arg2 ...]\n" 
-" -c : test cancellation (ie: trexecmd -c sleep 1000)\n"
-" -r : test reexec\n"
-"trexecmd -w cmd : do the which thing\n"
-;
-static void Usage(void)
-{
-    fprintf(stderr, "%s: usage:\n%s", thisprog, usage);
-    exit(1);
-}
 
 ReExec reexec;
-
 int main(int argc, char *argv[])
 {
     reexec.init(argc, argv);
 
     if (0) {
-	vector<string> newargs;
-	newargs.push_back("newarg");
-	newargs.push_back("newarg1");
-	newargs.push_back("newarg2");
-	newargs.push_back("newarg3");
-	newargs.push_back("newarg4");
-	reexec.insertArgs(newargs, 2);
+        // Disabled: For testing reexec arg handling
+        vector<string> newargs;
+        newargs.push_back("newarg");
+        newargs.push_back("newarg1");
+        newargs.push_back("newarg2");
+        newargs.push_back("newarg3");
+        newargs.push_back("newarg4");
+        reexec.insertArgs(newargs, 2);
     }
 
     thisprog = argv[0];
-    argc--; argv++;
+    argc--;
+    argv++;
 
     while (argc > 0 && **argv == '-') {
-	(*argv)++;
-	if (!(**argv))
-	    /* Cas du "adb - core" */
-	    Usage();
-	while (**argv)
-	    switch (*(*argv)++) {
-	    case 'c':	op_flags |= OPT_c; break;
-	    case 'r':	op_flags |= OPT_r; break;
-	    case 'w':	op_flags |= OPT_w; break;
-	    default: Usage();	break;
-	    }
-        argc--; argv++;
-    }
-
-    if (argc < 1)
-	Usage();
-
-    string cmd = *argv++; argc--;
+        (*argv)++;
+        if (!(**argv))
+            /* Cas du "adb - core" */
+        {
+            Usage();
+        }
+        while (**argv)
+            switch (*(*argv)++) {
+            case 'c':
+                op_flags |= OPT_c;
+                break;
+            case 'r':
+                op_flags |= OPT_r;
+                break;
+            case 'w':
+                op_flags |= OPT_w;
+                break;
+#ifdef BUILDING_RECOLL
+            case 'm':
+                op_flags |= OPT_m;
+                break;
+#endif
+            case 'i':
+                op_flags |= OPT_i;
+                break;
+            case 'l':
+                op_flags |= OPT_l;
+                break;
+            case 'o':
+                op_flags |= OPT_o;
+                break;
+            default:
+                Usage();
+                break;
+            }
+        argc--;
+        argv++;
+    }
+
+    if (argc < 1) {
+        Usage();
+    }
+
+    string arg1 = *argv++;
+    argc--;
     vector<string> l;
     while (argc > 0) {
-	l.push_back(*argv++); argc--;
-    }
-    //DebugLog::getdbl()->setloglevel(DEBDEB1);
-    //DebugLog::setfilename("stderr");
+        l.push_back(*argv++);
+        argc--;
+    }
+
+#ifdef BUILDING_RECOLL
+    DebugLog::getdbl()->setloglevel(DEBDEB1);
+    DebugLog::setfilename("stderr");
+#endif
     signal(SIGPIPE, SIG_IGN);
 
     if (op_flags & OPT_r) {
-	chdir("/");
+        // 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);
+        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) {
-	string path;
-	if (ExecCmd::which(cmd, path)) {
-	    cout << path << endl;
-	    exit(0);
-	} 
-	exit(1);
-    }
-    ExecCmd mexec;
-    MEAdv adv;
-    adv.cmd = &mexec;
-    mexec.setAdvise(&adv);
-    mexec.setTimeout(5);
-    mexec.setStderr("/tmp/trexecStderr");
-    mexec.putenv("TESTVARIABLE1=TESTVALUE1");
-    mexec.putenv("TESTVARIABLE2=TESTVALUE2");
-    mexec.putenv("TESTVARIABLE3=TESTVALUE3");
-
-    string input, output;
-    //    input = data;
-    string *ip = 0;
-    ip = &input;
-
-    MEPv  pv(&input);
-    mexec.setProvide(&pv);
-
-    int status = -1;
-    try {
-	status = mexec.doexec(cmd, l, ip, &output);
-    } catch (CancelExcept) {
-	cerr << "CANCELLED" << endl;
-    }
-
-    fprintf(stderr, "Status: 0x%x\n", status);
-    cout << output;
-    exit (status >> 8);
+        // Test "which" method
+        string path;
+        if (ExecCmd::which(arg1, path)) {
+            cout << path << endl;
+            return 0;
+        }
+        return 1;
+#ifdef BUILDING_RECOLL
+    } 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;
+#endif
+    } else if (op_flags & OPT_l) {
+        ExecCmd mexec;
+
+        if (mexec.startExec(arg1, l, false, true) < 0) {
+            cerr << "Startexec failed\n";
+            exit(1);
+        }
+        string output;
+        int ret = mexec.getline(output, 2);
+        cerr << "Got ret " << ret << " output " << output << endl;
+        cerr << "Waiting\n";
+        int status = mexec.wait();
+        cerr << "Got status " << status << endl;
+        exit(status);
+    } 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 (...) {
+            cerr << "CANCELLED" << endl;
+        }
+
+        fprintf(stderr, "Status: 0x%x\n", status);
+        if (op_flags & OPT_o) {
+            cout << output;
+        }
+        exit(status >> 8);
+    }
 }
 #endif // TEST