proc.h

Go to the documentation of this file.

/*
 *              proc.h
 *
 *      Copyright 2001 - 2018 Brenton Ross
 *
 *      This file is part of VICI.
 *
 *   VICI is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   VICI is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with VICI.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef CFI_PROC_H
#define CFI_PROC_H

#include <string>
#include <map>
#include <vector>
#include <signal.h>
#include <mutex>
#include <thread>

namespace VICI
{

namespace cfi
{


class AbstractChildProcess
{
public:
        virtual ~AbstractChildProcess(){}

        virtual int getId() = 0;

        virtual void kill() = 0;

        virtual bool done() = 0;

        virtual void finished( int exit_status ) = 0;
};


class ChildProcess : public AbstractChildProcess
{
private:
        pid_t pid;                                                      
        std::string name;                                       
        std::vector< std::string> params;       
        int *fdin;                                                      
        int *fdout;                                                     
        int *fderr;                                                     
        int killSignal;                                         
        void createProcess();                           
        void execProcess();                                     
        int exitSignal, exitStatus;                     
        bool ended;                                                     
        bool showExitStatus;                            

        ChildProcess( const ChildProcess & ) = delete;
        void operator = ( const ChildProcess & ) = delete;

public:

        ChildProcess( const std::string &cmnd, int *fdin = nullptr, int *fdout = nullptr, int *fderr = nullptr );

        ChildProcess();

        virtual ~ChildProcess();


        virtual void setArgs( const std::vector< std::string> &args );

        virtual void run();

        virtual void kill();

        virtual int signal( int sig );


        virtual void finished( int result );

        bool done() { return ended; }

        virtual int getId() { return (int)pid; }

        int getExitSignal() { return exitSignal; }

        int getExitStatus() { return exitStatus; }

        void reportExitErrors( bool x) { showExitStatus = x; }
};

// -----------------------------------------------------------------


class ProcessOwner
{
public:
        virtual ~ProcessOwner() {}


        virtual void processTerminated( AbstractChildProcess *cp ) = 0;
};

// -----------------------------------------------------------------


class ChildProcessMgr
{
private:
        // these are for insulating the signal handler
        std::unique_ptr<std::thread> thread;
        bool terminating;
        int fds[2];

        void threadFn();
        struct EndChild
        {
                int stat_val;
                AbstractChildProcess * kid;
                bool gotSignal;
        };

private:
        ChildProcessMgr();

        ~ChildProcessMgr();

        void installSignalHandler();

        static void childDiedSignalHandler( int sig );
        static void childDiedSignalAction( int sig, siginfo_t *, void *);

        std::map< pid_t, AbstractChildProcess * > children;             // references

        void (*otherHandler)(int);
        void (*otherAction)(int, siginfo_t *, void *);

        std::vector< ProcessOwner * > owners;
        mutable std::mutex accessMx;

        void notify( int stat_val, AbstractChildProcess * );

public:
        static ChildProcessMgr & instance();

        void registerOwner( ProcessOwner * );


        void registerChild( AbstractChildProcess *cp );


        void deregisterChild( AbstractChildProcess *cp );


        int  numberOfChildren() const { return children.size(); }


        int numberOfLiveChildren() const;

        void shutDown();
};

} // namespace cfi
} // namespace vici

#endif /* PROC_H_ */