src/process.cpp

Go to the documentation of this file.

#include <sys/wait.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <fcntl.h>
#include <poll.h>
#include <signal.h>
#include <sys/ioctl.h>
#include <errno.h>
#include <string.h>
#include "process.h"

Process::Process()
{
        for(int i = 0; i < 3; i++)
        {
                if(pipe(pipes[i]) == -1)
                        fprintf(stderr, "Unable to call pipe: %s\n", strerror(errno));
        }
        pid = 0;
        last_socket_read = 0;
        exit_code = -1;
        // Init the socket set:
        memset(&sock_set, 0, sizeof(sock_set));
        FD_ZERO(&sock_set);
};

Process::~Process()
{
        for(std::map<int, int>::iterator it = output_sock_list.begin(); it != output_sock_list.end(); ++it)
                FD_CLR(it->first, &sock_set);
        FD_ZERO(&sock_set);
        close(pipes[0][1]);
        close(pipes[1][0]);
        close(pipes[2][0]);
}

std::string Process::Start(char* file, char** argv)
{
        if(pid != 0)
                return std::string("A process has already been started");

        pid = fork();
        if(pid == -1)
        {
                pid = 0;
                return std::string("Fork failed: ") + std::string(strerror(errno));
        }

        if (pid == 0)
        {
                /* child */
                close(pipes[0][1]); /* close unused pipe ends */
                close(pipes[1][0]);
                close(pipes[2][0]);
                
                dup2(pipes[0][0], 0); /* patch up stdin/out/err */
                dup2(pipes[1][1], 1);
                dup2(pipes[2][1], 2);

                ChildOnFork();

                if(execvp(file, argv) == -1)
                        return std::string("Execvp failed: ") + std::string(strerror(errno));
        }
        else
        { /* parent */
                close(pipes[0][0]); /* close unused pipe ends */
                close(pipes[1][1]);
                close(pipes[2][1]);
                output_sock_list.insert(std::make_pair(pipes[1][0], 1));
                output_sock_list.insert(std::make_pair(pipes[2][0], 2));
                for(std::map<int, int>::iterator it = output_sock_list.begin(); it != output_sock_list.end(); ++it)
                        FD_SET(it->first, &sock_set);
                ParentOnFork();
        }
        return "";
}

std::string Process::Fork()
{
        pid = fork();
        if(pid == -1)
        {
                pid = 0;
                return std::string("Fork failed: ") + std::string(strerror(errno));
        }

        if (pid == 0)
                ChildOnFork();
        else
                ParentOnFork();
        return "";
}

int Process::GetPID()
{
        return pid;
}

std::string Process::GetOutput(char* buf, unsigned int &len, int& active_socket)
{
        if(!pid)
                return std::string("No process running");

        std::string err = HandleEvents();
        if(err != "")
                return err;
        
        active_socket = -1;

        struct timeval timeout;
        memset(&timeout, 0, sizeof(struct timeval));
        timeout.tv_sec = 0;
        timeout.tv_usec = 1;

        fd_set acting_socket = sock_set;
        // Lock the process until activity is detected
        if ( select(FD_SETSIZE, &acting_socket, NULL, NULL, &timeout) < 0)
        {
                if(timeout.tv_sec != 0 && timeout.tv_usec != 0)
                        return std::string("Select failed: ") + std::string(strerror(errno));
        }

        for(std::map<int, int>::iterator it = output_sock_list.begin(); it != output_sock_list.end(); ++it)
        {
                if(FD_ISSET(it->first, &acting_socket))
                {
                        active_socket = it->first;
                        break;
                }
        }

        if(active_socket == -1)
        {
                len = 0;
                return std::string("");
        }
        
        ssize_t read_len;
        if((read_len = read(active_socket, buf, len)) == -1)
        {
                len = 0;
                std::string err = std::string("Read failed: ") + std::string(strerror(errno));
                FD_CLR(active_socket, &sock_set);
                std::map<int, int>::iterator sock_to_delete;
                sock_to_delete = output_sock_list.find(active_socket);
                output_sock_list.erase(sock_to_delete);
                active_socket = -1;
                return err;
        }
        
        if(read_len == 0)
        {
                FD_CLR(active_socket, &sock_set);
                std::map<int, int>::iterator sock_to_delete;
                sock_to_delete = output_sock_list.find(active_socket);
                active_socket = sock_to_delete->second;
                output_sock_list.erase(sock_to_delete);
        }
        else
        {
                std::map<int, int>::iterator sock_active;
                sock_active = output_sock_list.find(active_socket);
                active_socket = sock_active->second;
        }

        len = (unsigned int)read_len;
        return std::string("");
}

int Process::GetExitCode()
{
        return exit_code;
}

std::string Process::SendStdin(char* buf, int len)
{
        if(!pid)
                return std::string("No process running");
        std::string err = HandleEvents();
        if(err != "")
                return err;
        if(write(pipes[0][1], buf, len) == -1)
                return std::string("Error during write: ") + std::string(strerror(errno));
        return "";
}

void Process::SendStdinClose()
{
        close(pipes[0][1]);
}

std::string Process::HandleEvents()
{
        if(GetExitCode() != -1)
                return std::string("");
        int status = 0;

        int r = waitpid(GetPID(), &status, WNOHANG);
        if(r == -1)
                return std::string("waitpid failed: ") + std::string(strerror(errno));
        if(r == 0)
                return std::string("");

        if(WIFEXITED(status))
                exit_code = WEXITSTATUS(status);
        return "";
}

---