#include <Sig_Handler.h>
Inheritance diagram for ACE_Sig_Handler:


Public Member Functions | |
| ACE_Sig_Handler (void) | |
| Default ctor/dtor. | |
| virtual | ~ACE_Sig_Handler (void) |
| virtual int | register_handler (int signum, ACE_Event_Handler *new_sh, ACE_Sig_Action *new_disp=0, ACE_Event_Handler **old_sh=0, ACE_Sig_Action *old_disp=0) |
| virtual int | remove_handler (int signum, ACE_Sig_Action *new_disp=0, ACE_Sig_Action *old_disp=0, int sigkey=-1) |
| virtual ACE_Event_Handler * | handler (int signum) |
| Return the <ACE_Sig_Handler> associated with <signum>. | |
| virtual ACE_Event_Handler * | handler (int signum, ACE_Event_Handler *) |
| void | dump (void) const |
| Dump the state of an object. | |
Static Public Member Functions | |
| static int | sig_pending (void) |
| True if there is a pending signal. | |
| static void | sig_pending (int) |
| Reset the value of <sig_pending_> so that no signal is pending. | |
| static void | dispatch (int, siginfo_t *, ucontext_t *) |
Public Attributes | |
| ACE_ALLOC_HOOK_DECLARE | |
| Declare the dynamic allocation hooks. | |
Static Protected Member Functions | |
| static ACE_Event_Handler * | handler_i (int signum, ACE_Event_Handler *) |
| static int | register_handler_i (int signum, ACE_Event_Handler *new_sh, ACE_Sig_Action *new_disp=0, ACE_Event_Handler **old_sh=0, ACE_Sig_Action *old_disp=0) |
| static int | in_range (int signum) |
| Check whether the SIGNUM is within the legal range of signals. | |
Static Protected Attributes | |
| static sig_atomic_t | sig_pending_ = 0 |
| Keeps track of whether a signal is pending. | |
Static Private Attributes | |
| static ACE_Event_Handler * | signal_handlers_ [ACE_NSIG] |
Using this class a program can register an <ACE_Event_Handler> with the <ACE_Sig_Handler> in order to handle a designated <signum>. When a signal occurs that corresponds to this <signum>, the <handle_signal> method of the registered <ACE_Event_Handler> is invoked automatically.
| ACE_INLINE ACE_Sig_Handler::ACE_Sig_Handler | ( | void | ) |
Default ctor/dtor.
| ACE_Sig_Handler::~ACE_Sig_Handler | ( | void | ) | [virtual] |
| void ACE_Sig_Handler::dispatch | ( | int | , | |
| siginfo_t * | , | |||
| ucontext_t * | ||||
| ) | [static] |
Callback routine registered with sigaction(2) that dispatches the <handle_signal> method of the appropriate pre-registered ACE_Event_Handler.
Reimplemented in ACE_Sig_Handlers.
| void ACE_Sig_Handler::dump | ( | void | ) | const |
| ACE_Event_Handler * ACE_Sig_Handler::handler | ( | int | signum, | |
| ACE_Event_Handler * | ||||
| ) | [virtual] |
Set a new <ACE_Event_Handler> that is associated with <signum>. Return the existing handler.
Reimplemented in ACE_Sig_Handlers.
| ACE_Event_Handler * ACE_Sig_Handler::handler | ( | int | signum | ) | [virtual] |
| ACE_Event_Handler * ACE_Sig_Handler::handler_i | ( | int | signum, | |
| ACE_Event_Handler * | ||||
| ) | [static, protected] |
Set a new <ACE_Event_Handler> that is associated with <signum>. Return the existing handler. Does not acquire any locks so that it can be called from a signal handler, such as <dispatch>.
| ACE_INLINE int ACE_Sig_Handler::in_range | ( | int | signum | ) | [static, protected] |
Check whether the SIGNUM is within the legal range of signals.
| int ACE_Sig_Handler::register_handler | ( | int | signum, | |
| ACE_Event_Handler * | new_sh, | |||
| ACE_Sig_Action * | new_disp = 0, |
|||
| ACE_Event_Handler ** | old_sh = 0, |
|||
| ACE_Sig_Action * | old_disp = 0 | |||
| ) | [virtual] |
Add a new <ACE_Event_Handler> and a new sigaction associated with <signum>. Passes back the existing <ACE_Event_Handler> and its sigaction if pointers are non-zero. Returns -1 on failure and >= 0 on success.
Reimplemented in ACE_Sig_Handlers.
| int ACE_Sig_Handler::register_handler_i | ( | int | signum, | |
| ACE_Event_Handler * | new_sh, | |||
| ACE_Sig_Action * | new_disp = 0, |
|||
| ACE_Event_Handler ** | old_sh = 0, |
|||
| ACE_Sig_Action * | old_disp = 0 | |||
| ) | [static, protected] |
This implementation method is called by <register_handler> and <dispatch>. It doesn't do any locking so that it can be called within a signal handler, such as <dispatch>. It adds a new <ACE_Event_Handler> and a new sigaction associated with <signum>. Passes back the existing <ACE_Event_Handler> and its sigaction if pointers are non-zero. Returns -1 on failure and >= 0 on success.
| int ACE_Sig_Handler::remove_handler | ( | int | signum, | |
| ACE_Sig_Action * | new_disp = 0, |
|||
| ACE_Sig_Action * | old_disp = 0, |
|||
| int | sigkey = -1 | |||
| ) | [virtual] |
Remove the <ACE_Event_Handler> currently associated with <signum>. <sigkey> is ignored in this implementation since there is only one instance of a signal handler. Install the new disposition (if given) and return the previous disposition (if desired by the caller). Returns 0 on success and -1 if <signum> is invalid.
Reimplemented in ACE_Sig_Handlers.
| void ACE_Sig_Handler::sig_pending | ( | int | ) | [static] |
Reset the value of <sig_pending_> so that no signal is pending.
| int ACE_Sig_Handler::sig_pending | ( | void | ) | [static] |
True if there is a pending signal.
sig_atomic_t ACE_Sig_Handler::sig_pending_ = 0 [static, protected] |
Keeps track of whether a signal is pending.
ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_Event_Handler * ACE_Sig_Handler::signal_handlers_ [static, private] |
Array used to store one user-defined Event_Handler for every signal.
1.4.7-1