/home/vlg/develop/libASSA/libassa/assa/SigHandler.cpp

Go to the documentation of this file.

// -*- c++ -*-
//---------------------------------------------------------------------------
//                            SigHandler.cpp
//---------------------------------------------------------------------------
//  Copyright (C) 1997-2002  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.
//---------------------------------------------------------------------------
#include <signal.h>

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

using namespace ASSA;

#if !defined(WIN32)

/*--- static variables ---*/

EventHandler* SigHandler::m_signal_handlers [NSIG];

int
SigHandler::
in_range (int signum_)
{
    trace_with_mask("SigHandler::in_range", SIGHAND);

    if ( signum_ >= 1 && signum_ < NSIG) {
        return 0;
    }
    else {
        DL((SIGHAND,"signum_ %d is out of range [1;%d]\n", NSIG));
        return -1;
    }
}

EventHandler *
SigHandler::
handler (int signum_, EventHandler* newh_)
{
    trace_with_mask("SigHandler::handler(int, EH*)", SIGHAND);
    

    if (in_range(signum_) == -1)
        return 0;

    EventHandler* oh = m_signal_handlers[signum_];
    m_signal_handlers[signum_] = newh_;

    return oh;
}

EventHandler *
SigHandler::
handler (int signum_)
{
    trace_with_mask("SigHandler::handler", SIGHAND);

    if ( in_range (signum_) == -1 ) 
        return 0;

    return m_signal_handlers[signum_];
}

int 
SigHandler::
install (int signum_, EventHandler *new_hand_, SigAction *new_disp_,
         EventHandler **old_hand_, SigAction *old_disp_)
{
    trace_with_mask("SigHandler::install", SIGHAND);

    if (in_range (signum_) == -1) 
        return -1;

    /*--- replace old Event Handler ptr with new one in my internal 
      dispatch table, returning the old one.
      ---*/
    EventHandler* eh = handler(signum_, new_hand_);
    
    /*--- if I am given place to store, save old handler ---*/
    if (old_hand_ != 0) 
        *old_hand_ = eh;
    
    /*--- retrieve old disposition ---*/
    if (old_disp_ != 0) {
        old_disp_->retrieve_action (signum_);
        old_disp_->handler ((C_SIG_HANDLER) SIG_DFL);
    }
    
    /*--- if new disposition is NULL, use null action instead ---*/
    SigAction null_sa;  
    
    if (new_disp_ == 0) 
        new_disp_ = &null_sa;
    
    /*--- install my dispatcher ---*/
    new_disp_->handler((C_SIG_HANDLER) SigHandler::dispatch);
    
    return new_disp_->register_action(signum_, old_disp_);
}

int
SigHandler::
remove (int signum_, EventHandler* /* eh_ */,
        SigAction *new_disp_,  SigAction *old_disp_)
{
    trace_with_mask("SigHandler::remove", SIGHAND);

    if (in_range(signum_) == -1) 
        return -1;
    /*--- 
      We need default disposition here if user forgot to give us one.
      ---*/
    SigAction sa ((C_SIG_HANDLER) SIG_DFL);

    if (new_disp_ == 0) {
        new_disp_ = &sa;
    }

    m_signal_handlers[signum_] = 0;
    
    return new_disp_->register_action (signum_, old_disp_);
}

void 
SigHandler::
dispatch (int signum_)
{
    trace_with_mask("SigHandler::dispatch", SIGHAND);
  
    /*--- save errno ---*/
    int my_errno = errno;

    EventHandler *eh = m_signal_handlers[signum_];

    if (eh != 0 && eh->handle_signal(signum_) == -1) {
        /*--- 
          we are in trouble, fall back to defaults 
          ---*/
        SigAction defact((C_SIG_HANDLER) SIG_DFL);
        m_signal_handlers[signum_] = 0;
        defact.register_action(signum_);
    }
    /*--- restore errno ---*/
    errno = my_errno;
}

#endif // !defined(WIN32)

---