libassa  3.5.1
Public Member Functions | Static Public Member Functions | Protected Member Functions | Static Private Attributes | List of all members
ASSA::SigHandler Class Reference

#include <SigHandler.h>

Inheritance diagram for ASSA::SigHandler:
ASSA::SigHandlers

Public Member Functions

virtual ~SigHandler ()
 No-op virtual destructor. More...
 
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. More...
 
virtual int remove (int signum_, EventHandler *eh_=0, SigAction *new_disp_=0, SigAction *old_disp_=0)
 Remove EventHandler associated with signum_. More...
 
EventHandlerhandler (int signum_, EventHandler *new_)
 Set new event handler for signal signum_ and return an existing one. More...
 
EventHandlerhandler (int signum_)
 Retrieve current event handler for signum_. More...
 

Static Public Member Functions

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

Protected Member Functions

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

Static Private Attributes

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

Detailed Description

Definition at line 49 of file SigHandler.h.

Constructor & Destructor Documentation

◆ ~SigHandler()

virtual ASSA::SigHandler::~SigHandler ( )
inlinevirtual

No-op virtual destructor.

Definition at line 54 of file SigHandler.h.

54 { /* no-op */ }

Member Function Documentation

◆ dispatch()

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

Definition at line 129 of file SigHandler.cpp.

131 {
132  trace_with_mask("SigHandler::dispatch", SIGHAND);
133 
134  /*--- save errno ---*/
135  int my_errno = errno;
136 
137  EventHandler *eh = m_signal_handlers[signum_];
138 
139  if (eh != 0 && eh->handle_signal(signum_) == -1) {
140  /*---
141  we are in trouble, fall back to defaults
142  ---*/
143  SigAction defact((C_SIG_HANDLER) SIG_DFL);
144  m_signal_handlers[signum_] = 0;
145  defact.register_action(signum_);
146  }
147  /*--- restore errno ---*/
148  errno = my_errno;
149 }
#define trace_with_mask(s, m)
trace_with_mask() is used to trace function call chain in C++ program.
Definition: Logger.h:437
void(* C_SIG_HANDLER)(int)
Definition: SigAction.h:28
EventHandler class.
Definition: EventHandler.h:103
virtual int handle_signal(int signum_)
Signal handler callback.
Definition: EventHandler.h:204
static EventHandler * m_signal_handlers[NSIG]
Static array that stores one user-defined event handler pointer for every signal.
Definition: SigHandler.h:127
@ SIGHAND
Class SigHandler(s) messages
Definition: LogMask.h:38

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

Referenced by install().

◆ handler() [1/2]

EventHandler * SigHandler::handler ( int  signum_)

Retrieve current event handler for signum_.

Definition at line 57 of file SigHandler.cpp.

59 {
60  trace_with_mask("SigHandler::handler", SIGHAND);
61 
62  if ( in_range (signum_) == -1 )
63  return 0;
64 
65  return m_signal_handlers[signum_];
66 }
int in_range(int signum_)
Check that signum_ is in valid range.
Definition: SigHandler.cpp:27

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

◆ handler() [2/2]

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 41 of file SigHandler.cpp.

43 {
44  trace_with_mask("SigHandler::handler(int, EH*)", SIGHAND);
45 
46 
47  if (in_range(signum_) == -1)
48  return 0;
49 
50  EventHandler* oh = m_signal_handlers[signum_];
51  m_signal_handlers[signum_] = newh_;
52 
53  return oh;
54 }

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

Referenced by install().

◆ in_range()

int SigHandler::in_range ( int  signum_)
protected

Check that signum_ is in valid range.

Returns
0 if in range; -1 otherwise.

Definition at line 26 of file SigHandler.cpp.

28 {
29  trace_with_mask("SigHandler::in_range", SIGHAND);
30 
31  if ( signum_ >= 1 && signum_ < NSIG) {
32  return 0;
33  }
34  else {
35  DL((SIGHAND,"signum_ %d is out of range [1;%d]\n", NSIG));
36  return -1;
37  }
38 }
#define DL(X)
A macro for writing debug message to the Logger.
Definition: Logger.h:273

References DL, ASSA::SIGHAND, and trace_with_mask.

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

◆ install()

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 69 of file SigHandler.cpp.

72 {
73  trace_with_mask("SigHandler::install", SIGHAND);
74 
75  if (in_range (signum_) == -1)
76  return -1;
77 
78  /*--- replace old Event Handler ptr with new one in my internal
79  dispatch table, returning the old one.
80  ---*/
81  EventHandler* eh = handler(signum_, new_hand_);
82 
83  /*--- if I am given place to store, save old handler ---*/
84  if (old_hand_ != 0)
85  *old_hand_ = eh;
86 
87  /*--- retrieve old disposition ---*/
88  if (old_disp_ != 0) {
89  old_disp_->retrieve_action (signum_);
90  old_disp_->handler ((C_SIG_HANDLER) SIG_DFL);
91  }
92 
93  /*--- if new disposition is NULL, use null action instead ---*/
94  SigAction null_sa;
95 
96  if (new_disp_ == 0)
97  new_disp_ = &null_sa;
98 
99  /*--- install my dispatcher ---*/
101 
102  return new_disp_->register_action(signum_, old_disp_);
103 }
void handler(C_SIG_HANDLER sha_)
Set new signal handler to function pointer sha_.
Definition: SigAction.h:334
int retrieve_action(int signum_)
Retrieve current disposition for the signal signum_ into this object.
Definition: SigAction.h:381
int register_action(int signum_, SigAction *oaction_=0)
Register this object as current disposition for signal signum_, and store old disposition in oaction_...
Definition: SigAction.h:360
static void dispatch(int signum_)
Here is the heart of SigHandler class.
Definition: SigHandler.cpp:130
EventHandler * handler(int signum_, EventHandler *new_)
Set new event handler for signal signum_ and return an existing one.
Definition: SigHandler.cpp:42

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().

◆ remove()

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 106 of file SigHandler.cpp.

109 {
110  trace_with_mask("SigHandler::remove", SIGHAND);
111 
112  if (in_range(signum_) == -1)
113  return -1;
114  /*---
115  We need default disposition here if user forgot to give us one.
116  ---*/
117  SigAction sa ((C_SIG_HANDLER) SIG_DFL);
118 
119  if (new_disp_ == 0) {
120  new_disp_ = &sa;
121  }
122 
123  m_signal_handlers[signum_] = 0;
124 
125  return new_disp_->register_action (signum_, old_disp_);
126 }

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

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

Member Data Documentation

◆ m_signal_handlers

EventHandler * SigHandler::m_signal_handlers
staticprivate

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

Definition at line 127 of file SigHandler.h.

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


The documentation for this class was generated from the following files: