/home/vlg/develop/libASSA/libassa/assa/Fork.h

Go to the documentation of this file.

// -*- c++ -*-
//------------------------------------------------------------------------------
//                             Fork.h
//------------------------------------------------------------------------------
//  Copyright (C) 1997-2002,2005  Vladislav Grinchenko
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Library General Public
//  License as published by the Free Software Foundation; either
//  version 2 of the License, or (at your option) any later version.
//------------------------------------------------------------------------------
#ifndef IS_FORK_H
#define IS_FORK_H

#include <unistd.h>     // fork
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <signal.h>

#ifndef WIN32
#    include <sys/wait.h>
#endif

#include <list>
using std::list;

/* Sun Solaris 2.6 has wait4(3C) function definition missing
 * from its header files. The function, however, is in the 
 * standard library. Testing this scenario would require
 * writing custom m4 macro. 
 */
#if defined(__sun) 
#include <sys/time.h>
#include <sys/resource.h>
extern "C" pid_t 
wait4(pid_t pid, int *statusp, int options, struct rusage *rusage);
#endif


#include "assa/Assure.h"
#include "assa/Singleton.h"
#include "assa/EventHandler.h"
#include "assa/SigHandler.h"
#include "assa/SigAction.h"

namespace ASSA {

class ChildStatusHandler : public EventHandler
{
public:
    ChildStatusHandler () 
        : m_exit_status (-1), m_caught (false) { /* no-op */ }

    int handle_signal (int signum_);

    int exit_status () const { return m_exit_status; }
    
    bool caught () const { return m_caught; }

private:
    int m_exit_status;
    bool m_caught;
};

class Fork {
public:
    enum state_t { 
        KILL_ON_EXIT,           
        WAIT_ON_EXIT,           
        LEAVE_ALONE             
    };

    enum wait4status_t {
        IGNORE_STATUS,          
        COLLECT_STATUS          
    };
    
#if !defined(WIN32)

    Fork (state_t exit_action_ = WAIT_ON_EXIT,  
          wait4status_t catch_status_ = COLLECT_STATUS);
    
    ~Fork() { trace_with_mask("Fork::~Fork",FORK); }

    bool isParent() const { return m_pid ? true : false; }

    bool isChild() const { return !m_pid ? true : false; }

    pid_t getChildPID() const {
        trace_with_mask("Fork::getChildPID",FORK);
        return m_pid;
    }

    int get_exit_status () const { return m_chstath.exit_status (); }
    
#endif // !defined(WIN32)

    static int fork_exec (const string& cmd_, 
                          const string& args_,  
                          wait4status_t wait_for_completion_,
                          bool ignore_output_ = false);
                          
#if !defined(WIN32)
private:
    pid_t m_pid;

    SigHandler m_local_sh;

    ChildStatusHandler m_chstath;

    SigAction m_old_disp;
    
#endif // !defined(WIN32)

};

class fnode_t {
public:
    fnode_t (pid_t pid_, Fork::state_t state_)
        : m_pid(pid_), m_state(state_)
        {
            trace_with_mask("fnode_t::fnode_t",FORK);
        }

    pid_t getPID() const
        {
            trace_with_mask("fnode_t::getPID",FORK);
            return m_pid;
        }

    bool needKill() const
        {
            trace_with_mask("fnode_t::needKill",FORK);
            return  m_state == Fork::KILL_ON_EXIT ? true : false;
        }
private:
    pid_t m_pid;

    Fork::state_t m_state;
};

class ForkList : public Singleton < ForkList > 
{
public:
    ForkList () { trace_with_mask("ForkList::ForkList",FORK); }

    ~ForkList();

    list< fnode_t* > m_list;
};

} // end namespace ASSA

#endif // IS_FORK_H

---