add support for asynchronous processes

[opensuse:smpppd.git] / smpppd / process.cc

/*
 *  Author: Arvin Schnell <arvin@suse.de>
 */


#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <paths.h>

#include <csignal>
#include <cerrno>
#include <cstdarg>
#include <cstdio>
#include <cstdlib>
#include <cstring>

#include "process.h"
#include "utils.h"

// SIGCHLD is blocked anyways
#define sigprocmask(x, y, z)

Processes processes;


Process::Process ()
{
    dprintf ("%s\n", __PRETTY_FUNCTION__);

    sigemptyset (&block_chld);
    sigaddset (&block_chld, SIGCHLD);

    clear ();

    processes.push_back (this);
}


Process::~Process ()
{
    dprintf ("%s\n", __PRETTY_FUNCTION__);
    processes.remove (this);
    delete exitcallback;
}


void
Process::clear ()
{
    pid = 0;

    running = false;
    has_died_flag = false;

    status = 0;
    args.clear ();
    fd_notclose.clear ();
}


bool
Process::start ()
{
    const unsigned int nargs = args.size ();

    if (nargs < 1)
        return false;

    // We have to block the child signal, otherwise the signal can
    // arrive before the fork return and the pid is set. Then our
    // signal handler would not work.
    sigprocmask (SIG_BLOCK, &block_chld, 0);
    running = true;
    has_died_flag = false;
    pid = fork ();
    sigprocmask (SIG_UNBLOCK, &block_chld, 0);

    if (pid == 0)
    {
        if(!debug_level)
        {
            for (int fd = 0; fd < 3; fd++) {
                int null_fd = open (_PATH_DEVNULL, O_RDONLY);
                dup2 (null_fd, fd);
                close (null_fd);
            }
        }

        for (int tty = 3; tty < 256; tty++) {
            bool doit = true;
            for (unsigned int i = 0; i < fd_notclose.size (); i++)
                if (tty == fd_notclose[i])
                    doit = false;
            if (doit)
                close (tty);
        }

        char** ptr = new char* [nargs + 1];
        for (unsigned int i = 0; i < nargs; i++)
            ptr[i] = strdup (args[i].c_str ());
        ptr[nargs] = 0;

        // pppd may call kill (0, SIGTERM), but I don't want to die.
        setsid ();

        execvp (ptr[0], ptr);
        _exit (EXIT_FAILURE);
    }

    if (pid < 0)
    {
        pid = 0;
        running = false;
        return false;
    }

    return true;
}


void
Process::close_stuff ()
{
    for (unsigned int i = 0; i < fd_notclose.size (); i++)
        close (fd_notclose[i]);
}


void
Process::sigterm ()
{
    if (!running)
        return;

    pid_t ret = waitpid (pid, &status, WNOHANG);

    if (ret == pid) {
        running = false;
        has_died_flag = true;
        close_stuff ();
    }
}


void
Process::kill (int timeout, bool group)
{
    sigprocmask (SIG_BLOCK, &block_chld, 0);
    if (running)
        ::kill (!group ? pid : -pid, SIGTERM);
    sigprocmask (SIG_UNBLOCK, &block_chld, 0);

    if (!running)
        return;

    for (int i = 0; i < timeout; i++) {
        if (!running)
            return;
        sleep (1);
    }

    sigprocmask (SIG_BLOCK, &block_chld, 0);
    if (running)
        ::kill (!group ? pid : -pid, SIGKILL);
    sigprocmask (SIG_UNBLOCK, &block_chld, 0);
}


void
Process::wait_for_dead ()
{
    sigprocmask (SIG_BLOCK, &block_chld, 0);
    if (running) {
        pid_t ret = waitpid (pid, &status, 0);
        if (ret == pid) {
            running = false;
            has_died_flag = true;
            close_stuff ();
        }
    }
    sigprocmask (SIG_UNBLOCK, &block_chld, 0);
}


bool
Process::has_died ()
{
    if (has_died_flag) {
        has_died_flag = false;
        return true;
    } else {
        return false;
    }
}


bool
Process::normal_exit ()
{
    int tmp = status;
    return WIFEXITED (tmp);
}


int
Process::exit_status ()
{
    int tmp = status;
    return WEXITSTATUS (tmp);
}


Process&
Process::operator << (const char* arg)
{
    args.push_back (arg);
    return *this;
}


Process&
Process::operator << (const string& arg)
{
    args.push_back (arg);
    return *this;
}


Process&
Process::operator << (const vector <string>& arg)
{
    for (vector <string>::const_iterator it = arg.begin ();
         it != arg.end (); it++)
        args.push_back (*it);
    return *this;
}


Process&
Process::operator << (int num)
{
    char buffer[32];
    snprintf (buffer, 32, "%d", num);
    args.push_back (buffer);
    return *this;
}


void
Process::add_fd_notclose (int fd)
{
    fd_notclose.push_back (fd);
}


string
Process::dump_args () const
{
    string ret;

    for (std::vector <string>::const_iterator it = args.begin ();
         it != args.end (); it++) {
        if (it != args.begin ())
            ret += ' ';
        ret += '"';
        ret += (*it);
        ret += '"';
    }

    return ret;
}


void
Processes::sigterm ()
{
    // waitpid changes errno, so save it.

    int saved_errno = errno;

    for (const_iterator it = begin (); it != end (); it++)
        (*it)->sigterm ();

    errno = saved_errno;
}


void
Processes::terminated (pid_t pid)
{
    for (const_iterator it = begin (); it != end (); it++)
    {
        if(pid == (*it)->pid)
        {
            dprintf("pid %d found\n", pid);
            if ((*it)->exitcallback)
                (*(*it)->exitcallback)(*it);

            return;
        }
    }
    dprintf("pid %d NOT found\n", pid);
}

void
Process::set_exitcallback(ProcessExit* handler)
{
    exitcallback = handler;
}