[boost] Child processes

From: Angus Leeming (angus.leeming_at_[hidden])
Date: 2004-06-22 12:34:47

I am in the process of writing a little library to control the interaction
of a parent program with any child processes that it spawns. Would there
be any interest in such a library here?

Assuming that there would, please excuse me diving in at the deep end. I'm
currently mulling over how best to ensure that system resources are
cleaned up automatically when the child exits and would value some
advice.

Under unix, I've defined a handler for SIGCHLD signals. The handler does
two things only:
* reaps the zombie
* stores the return status in a 
        std::map<pid_t, int> completed_children;
variable. Each time a new child is spawned, the pid of the child process
is registered in the map, so the handler needs do nothing other than find
the entry.

namespace {

std::map<pid_t, int> completed_children;

int status;
sig_atomic_t pid;

}

extern "C"
void child_handler(int)
{
        pid = wait(&status);
        std::map<pid_t, int>::iterator it = completed_children.find(pid);
        if (it != completed_children.end())
                it->second = status;
}

I'm pretty sure that the above is safe code. It does the absolute minimum
in the handler routine. wait() is guaranteed to be async-safe. Moreover,
the handler receives only SIGCHLD signals and so cannot receive multiple
calls simultaneaously. However, I'm unsure whether it Ok to search the
map like this. Any advice?

My one other worry is that the SIGCHLD handler could be redefined
elsewhere in the code, but AFAICS there's nothing that I can do about
that. Furthermore, it means only that the user of my Child library won't
be able to ascertain the exit status of child processes launched using
it. 

(If the zombie is reaped elsewhere then a subsequent call to
        waitpid(pid, &status, WNOHANG);
will result in errno being set to ECHILD. Ie, I'll know that the child
process has ended but just won't know its exit status.)

Under windows, I'm proposing to use a separate thread to wait() for each
child process. This seems to be the standard way of dealing with the
problem, but I'm a total novice when it comes to Windows programming so
know only what I've read. Again, any advice would be greatly appreciated.

Regards,
Angus