ASSA::SigHandler Class Reference

#include <SigHandler.h>

Inheritance diagram for ASSA::SigHandler:

ASSA::SigHandlers List of all members.

Public Member Functions

virtual int install (int signum_, EventHandler *new_hand_, SigAction *new_disp_=0, EventHandler **old_hand_=0, SigAction *old_disp_=0)
 Add new signal handler and new disposition for the signal.
virtual int remove (int signum_, EventHandler *eh_=0, SigAction *new_disp_=0, SigAction *old_disp_=0)
 Remove EventHandler associated with signum_.
EventHandlerhandler (int signum_, EventHandler *new_)
 Set new event handler for signal signum_ and return an existing one.
EventHandlerhandler (int signum_)
 Retrieve current event handler for signum_.

Static Public Member Functions

static void dispatch (int signum_)
 Here is the heart of SigHandler class.

Protected Member Functions

int in_range (int signum_)
 Check that signum_ is in valid range.

Static Private Attributes

static EventHandlerm_signal_handlers [NSIG]
 Static array that stores one user-defined event handler pointer for every signal.

Detailed Description

Definition at line 47 of file SigHandler.h.


Member Function Documentation

void SigHandler::dispatch int  signum_  )  [static]
 

Here is the heart of SigHandler class.

This callback function is really registered with OS to catch all of the signals EventHandlers have been installed for. dispatch () catches the signal and then calls sends the signal to the appropriate EventHandler object.

Parameters:
signum_ signal delivered by OS.
Returns:
0 on success, -1 on error

Reimplemented in ASSA::SigHandlers.

Definition at line 128 of file SigHandler.cpp.

References ASSA::EventHandler::handle_signal(), m_signal_handlers, ASSA::SIGHAND, and trace_with_mask.

Referenced by install().

00129 {
00130     trace_with_mask("SigHandler::dispatch", SIGHAND);
00131   
00132     /*--- save errno ---*/
00133     int my_errno = errno;
00134 
00135     EventHandler *eh = m_signal_handlers[signum_];
00136 
00137     if (eh != 0 && eh->handle_signal(signum_) == -1) {
00138         /*--- 
00139           we are in trouble, fall back to defaults 
00140           ---*/
00141         SigAction defact((C_SIG_HANDLER) SIG_DFL);
00142         m_signal_handlers[signum_] = 0;
00143         defact.register_action(signum_);
00144     }
00145     /*--- restore errno ---*/
00146     errno = my_errno;
00147 }

EventHandler * SigHandler::handler int  signum_  ) 
 

Retrieve current event handler for signum_.

Definition at line 56 of file SigHandler.cpp.

References in_range(), m_signal_handlers, ASSA::SIGHAND, and trace_with_mask.

00057 {
00058     trace_with_mask("SigHandler::handler", SIGHAND);
00059 
00060     if ( in_range (signum_) == -1 ) 
00061         return 0;
00062 
00063     return m_signal_handlers[signum_];
00064 }

EventHandler * SigHandler::handler int  signum_,
EventHandler new_
 

Set new event handler for signal signum_ and return an existing one.

Returns:
Pointer to the old event handler, or 0 if signum_ is out of range.

Definition at line 40 of file SigHandler.cpp.

References in_range(), m_signal_handlers, ASSA::SIGHAND, and trace_with_mask.

Referenced by install().

00041 {
00042     trace_with_mask("SigHandler::handler(int, EH*)", SIGHAND);
00043     
00044 
00045     if (in_range(signum_) == -1)
00046         return 0;
00047 
00048     EventHandler* oh = m_signal_handlers[signum_];
00049     m_signal_handlers[signum_] = newh_;
00050 
00051     return oh;
00052 }

int SigHandler::in_range int  signum_  )  [protected]
 

Check that signum_ is in valid range.

Returns:
0 if in range; -1 otherwise.

Definition at line 25 of file SigHandler.cpp.

References DL, ASSA::SIGHAND, and trace_with_mask.

Referenced by handler(), ASSA::SigHandlers::install(), install(), ASSA::SigHandlers::remove(), and remove().

00026 {
00027     trace_with_mask("SigHandler::in_range", SIGHAND);
00028 
00029     if ( signum_ >= 1 && signum_ < NSIG) {
00030         return 0;
00031     }
00032     else {
00033         DL((SIGHAND,"signum_ %d is out of range [1;%d]\n", NSIG));
00034         return -1;
00035     }
00036 }

int SigHandler::install int  signum_,
EventHandler new_hand_,
SigAction new_disp_ = 0,
EventHandler **  old_hand_ = 0,
SigAction old_disp_ = 0
[virtual]
 

Add new signal handler and new disposition for the signal.

Note that although new_disp_ might keep C-like handler for the action, new_hand_ will really be handling delivered signal. In other words, new_disp_.sa_handler is ignored.

Parameters:
signum_ signal number new disposition is installed for.
new_hand_ pointer to new EventHandler that will be handling the signal
new_disp_ new disposition to use in handling the signal
old_hand_ return old handler for the signal
old_disp_ return old disposition for the signal
Returns:
0 on success, -1 on error

Reimplemented in ASSA::SigHandlers.

Definition at line 68 of file SigHandler.cpp.

References dispatch(), ASSA::SigAction::handler(), handler(), in_range(), ASSA::SigAction::register_action(), ASSA::SigAction::retrieve_action(), ASSA::SIGHAND, and trace_with_mask.

Referenced by ASSA::Fork::Fork().

00070 {
00071     trace_with_mask("SigHandler::install", SIGHAND);
00072 
00073     if (in_range (signum_) == -1) 
00074         return -1;
00075 
00076     /*--- replace old Event Handler ptr with new one in my internal 
00077       dispatch table, returning the old one.
00078       ---*/
00079     EventHandler* eh = handler(signum_, new_hand_);
00080     
00081     /*--- if I am given place to store, save old handler ---*/
00082     if (old_hand_ != 0) 
00083         *old_hand_ = eh;
00084     
00085     /*--- retrieve old disposition ---*/
00086     if (old_disp_ != 0) {
00087         old_disp_->retrieve_action (signum_);
00088         old_disp_->handler ((C_SIG_HANDLER) SIG_DFL);
00089     }
00090     
00091     /*--- if new disposition is NULL, use null action instead ---*/
00092     SigAction null_sa;  
00093     
00094     if (new_disp_ == 0) 
00095         new_disp_ = &null_sa;
00096     
00097     /*--- install my dispatcher ---*/
00098     new_disp_->handler((C_SIG_HANDLER) SigHandler::dispatch);
00099     
00100     return new_disp_->register_action(signum_, old_disp_);
00101 }

int SigHandler::remove int  signum_,
EventHandler eh_ = 0,
SigAction new_disp_ = 0,
SigAction old_disp_ = 0
[virtual]
 

Remove EventHandler associated with signum_.

Also, install new disposition and return an old one (if given).

Parameters:
signum_ signal number new disposition is installed for.
eh_ pointer to EventHandler that is uninstalled. If eh_ is 0 (by default), all event handlers associated with signum_ will be removed.
new_disp_ new disposition to use in handling the signal
old_disp_ return old disposition for the signal
Returns:
0 on success, -1 on error

Reimplemented in ASSA::SigHandlers.

Definition at line 105 of file SigHandler.cpp.

References in_range(), m_signal_handlers, ASSA::SigAction::register_action(), ASSA::SIGHAND, and trace_with_mask.

Referenced by ASSA::Fork::Fork().

00107 {
00108     trace_with_mask("SigHandler::remove", SIGHAND);
00109 
00110     if (in_range(signum_) == -1) 
00111         return -1;
00112     /*--- 
00113       We need default disposition here if user forgot to give us one.
00114       ---*/
00115     SigAction sa ((C_SIG_HANDLER) SIG_DFL);
00116 
00117     if (new_disp_ == 0) {
00118         new_disp_ = &sa;
00119     }
00120 
00121     m_signal_handlers[signum_] = 0;
00122     
00123     return new_disp_->register_action (signum_, old_disp_);
00124 }


Member Data Documentation

EventHandler * SigHandler::m_signal_handlers [static, private]
 

Static array that stores one user-defined event handler pointer for every signal.

Definition at line 121 of file SigHandler.h.

Referenced by dispatch(), handler(), and remove().


The documentation for this class was generated from the following files:
Generated on Tue Jun 20 10:36:22 2006 for libassa by  doxygen 1.4.6