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

Go to the documentation of this file.

// -*- c++ -*-
//------------------------------------------------------------------------------
//                            Handlers.h
//------------------------------------------------------------------------------
//  Copyright (c) 2000,2005 by 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 _Handlers_h
#define _Handlers_h

#include <sys/types.h>

#if !defined(WIN32)
#    include <sys/wait.h>
#endif

#include "assa/EventHandler.h"
#include "assa/Assure.h"

namespace ASSA {

#if !defined(WIN32)

#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__) || defined (__NetBSD__)
#   define ASSAIOSIG SIGIO
#else
#   define ASSAIOSIG SIGPOLL
#endif

class SIGINTHandler : public EventHandler
{
public:
    SIGINTHandler();

    int handle_signal (int signum_);

    sig_atomic_t graceful_quit();

    void resetState();

private:
    sig_atomic_t m_graceful_quit;
};
 
inline
SIGINTHandler::
SIGINTHandler ()
    : m_graceful_quit (0)
{
    trace_with_mask("SIGINTHandler::SIGINTHandler", SIGHAND);
}

inline int
SIGINTHandler::
handle_signal (int signum_)
{
    trace_with_mask("SIGINTHandler::handle_signal", SIGHAND);

    if (signum_ == SIGINT) {
        m_graceful_quit = 1;
        return 0;
    }
    return -1;
}

inline sig_atomic_t
SIGINTHandler::
graceful_quit ()
{
    return m_graceful_quit;
}

inline void
SIGINTHandler::
resetState()
{
    trace_with_mask("SIGINTHandler::resetState", SIGHAND);

    m_graceful_quit = 0;
}

class SIGUSR1Handler : public EventHandler
{
public:
    SIGUSR1Handler() : m_count(0) {
        trace_with_mask("SIGUSR1Handler::SIGUSR1Handler", SIGHAND);
    }
    
    int handle_signal(int signum_) {
        trace_with_mask("SIGUSR1Handler::handle_signal()", SIGHAND);
        
        if (signum_ == SIGUSR1) { 
            m_count++; 
            DL((TRACE, "signal count = %d\n", m_count));
            return 0; 
        }
        return -1;
    }
    
    sig_atomic_t received_count() const { return m_count; }
    
    void resetState() { m_count = 0; }

private:
    sig_atomic_t m_count;
};


class SIGUSR2Handler : public EventHandler
{
public:
    SIGUSR2Handler() : m_count(0) {
        trace_with_mask("SIGUSR2Handler::SIGUSR2Handler", SIGHAND);
    }
    
    int handle_signal(int signum_) {
        trace_with_mask("SIGUSR2Handler::handle_signal()", SIGHAND);
        
        if (signum_ == SIGUSR2) { 
            m_count++; 
            DL((TRACE, "signal count = %d\n", m_count));
            return 0; 
        }
        return -1;
    }
    
    sig_atomic_t received_count() const { return m_count; }
    
    void resetState() { m_count = 0; }

private:
    sig_atomic_t m_count;
};

class SIGCHLDHandler : public EventHandler
{
public:
    SIGCHLDHandler() : m_child_exit_flag(0) {
        trace_with_mask("SIGCHLDHandler::SIGCHLDHandler", SIGHAND);
    }

    int handle_signal(int signum_) {
        trace_with_mask("SIGCHLDHandler::handle_signal", SIGHAND);

        if (signum_ == SIGCHLD && wait(NULL) != -1) { 
            m_child_exit_flag = 1;
            return 0;
        }
        return -1;
    }
    sig_atomic_t child_exited() { return m_child_exit_flag; }

    void resetState() { m_child_exit_flag = 0; }

private:
    sig_atomic_t m_child_exit_flag;
};

class SIGALRMHandler : public EventHandler
{
public:
    SIGALRMHandler() : m_alarm_flag(0) {
        trace_with_mask("SIGALRMHandler::SIGALRMHandler", SIGHAND);
    }

    int handle_signal(int signum_) {
        trace_with_mask("SIGALRMHandler::handle_signal", SIGHAND);

        if (signum_ == SIGALRM) {
            m_alarm_flag = 1; // notice that we have seen alarm
            return 0;
        }
        return -1;
    }

    sig_atomic_t alarmed () { return m_alarm_flag; }

    void resetState () { m_alarm_flag = 0; }

private:
    sig_atomic_t m_alarm_flag;
};


class SIGPOLLHandler : public EventHandler
{
public:
    SIGPOLLHandler () {
        trace_with_mask("SIGPOLLHandler", SIGHAND);
    }
    int handle_signal ( int signum_ ) { 
        trace_with_mask("SIGPOLLHandler::handle_signal", SIGHAND);
            
        return (signum_ == ASSAIOSIG) ? 0 : -1; 
    }
};

#endif // !defined(WIN32)

} // end namespace ASSA

#endif

---