ACE/ace/Signal.cpp

   1 #include "ace/Signal.h"
   2
   3 #if defined (ACE_HAS_ALLOC_HOOKS)
   4 # include "ace/Malloc_Base.h"
   5 #endif /* ACE_HAS_ALLOC_HOOKS */
   6
   7 #if !defined (__ACE_INLINE__)
   8 #include "ace/Signal.inl"
   9 #endif /* __ACE_INLINE__ */
  10
  11 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  12
  13 ACE_ALLOC_HOOK_DEFINE(ACE_Sig_Action)
  14
  15 void
  16 ACE_Sig_Action::dump () const
  17 {
  18 #if defined (ACE_HAS_DUMP)
  19   ACE_TRACE ("ACE_Sig_Action::dump");
  20 #endif /* ACE_HAS_DUMP */
  21 }
  22
  23 ACE_ALLOC_HOOK_DEFINE(ACE_Sig_Set)
  24
  25 ACE_Sig_Set::~ACE_Sig_Set ()
  26 {
  27   ACE_TRACE ("ACE_Sig_Set::~ACE_Sig_Set");
  28   ACE_OS::sigemptyset (&this->sigset_);
  29 }
  30
  31 ACE_Sig_Action::~ACE_Sig_Action ()
  32 {
  33   ACE_TRACE ("ACE_Sig_Action::~ACE_Sig_Action");
  34 }
  35
  36 /// Restore the signal mask.
  37 ACE_Sig_Guard::~ACE_Sig_Guard ()
  38 {
  39   //ACE_TRACE ("ACE_Sig_Guard::~ACE_Sig_Guard");
  40   if (!this->condition_)
  41     return;
  42
  43 #if !defined (ACE_LACKS_UNIX_SIGNALS)
  44 #if defined (ACE_LACKS_PTHREAD_THR_SIGSETMASK)
  45   ACE_OS::sigprocmask (SIG_SETMASK,
  46                        (sigset_t *) this->omask_,
  47                        0);
  48 #else
  49   ACE_OS::thr_sigsetmask (SIG_SETMASK,
  50                           (sigset_t *) this->omask_,
  51                           0);
  52 #endif /* ACE_LACKS_PTHREAD_THR_SIGSETMASK */
  53 #endif /* !ACE_LACKS_UNIX_SIGNALS */
  54 }
  55
  56 void
  57 ACE_Sig_Set::dump () const
  58 {
  59 #if defined (ACE_HAS_DUMP)
  60   ACE_TRACE ("ACE_Sig_Set::dump");
  61 #endif /* ACE_HAS_DUMP */
  62 }
  63
  64 ACE_ALLOC_HOOK_DEFINE(ACE_Sig_Guard)
  65
  66 void
  67 ACE_Sig_Guard::dump () const
  68 {
  69 #if defined (ACE_HAS_DUMP)
  70   ACE_TRACE ("ACE_Sig_Guard::dump");
  71 #endif /* ACE_HAS_DUMP */
  72 }
  73
  74 ACE_Sig_Action::ACE_Sig_Action ()
  75 {
  76   // ACE_TRACE ("ACE_Sig_Action::ACE_Sig_Action");
  77   this->sa_.sa_flags = 0;
  78
  79   // Since Service_Config::signal_handler_ is static and has an
  80   // ACE_Sig_Action instance, Win32 will get errno set unless this is
  81   // commented out.
  82 #if !defined (ACE_WIN32)
  83   ACE_OS::sigemptyset (&this->sa_.sa_mask);
  84 #endif /* ACE_WIN32 */
  85   this->sa_.sa_handler = 0;
  86 }
  87
  88 ACE_Sig_Action::ACE_Sig_Action (ACE_SignalHandler sig_handler,
  89                                 sigset_t *sig_mask,
  90                                 int sig_flags)
  91 {
  92   // ACE_TRACE ("ACE_Sig_Action::ACE_Sig_Action");
  93   this->sa_.sa_flags = sig_flags;
  94
  95   if (sig_mask == nullptr)
  96     ACE_OS::sigemptyset (&this->sa_.sa_mask);
  97   else
  98     this->sa_.sa_mask = *sig_mask; // Structure assignment...
  99
 100   this->sa_.sa_handler = ACE_SignalHandlerV (sig_handler);
 101 }
 102
 103 ACE_Sig_Action::ACE_Sig_Action (ACE_SignalHandler sig_handler,
 104                                 const ACE_Sig_Set &sig_mask,
 105                                 int sig_flags)
 106 {
 107   // ACE_TRACE ("ACE_Sig_Action::ACE_Sig_Action");
 108   this->sa_.sa_flags = sig_flags;
 109
 110   // Structure assignment...
 111   this->sa_.sa_mask = sig_mask.sigset ();
 112   this->sa_.sa_handler = ACE_SignalHandlerV (sig_handler);
 113 }
 114
 115 ACE_Sig_Action::ACE_Sig_Action (ACE_SignalHandler sig_handler,
 116                                 int signum,
 117                                 sigset_t *sig_mask,
 118                                 int sig_flags)
 119 {
 120   // ACE_TRACE ("ACE_Sig_Action::ACE_Sig_Action");
 121   this->sa_.sa_flags = sig_flags;
 122
 123   if (sig_mask == nullptr)
 124     ACE_OS::sigemptyset (&this->sa_.sa_mask);
 125   else
 126     this->sa_.sa_mask = *sig_mask; // Structure assignment...
 127
 128   this->sa_.sa_handler = ACE_SignalHandlerV (sig_handler);
 129   ACE_OS::sigaction (signum, &this->sa_, 0);
 130 }
 131
 132 ACE_Sig_Action::ACE_Sig_Action (ACE_SignalHandler sig_handler,
 133                                 int signum,
 134                                 const ACE_Sig_Set &sig_mask,
 135                                 int sig_flags)
 136 {
 137   // ACE_TRACE ("ACE_Sig_Action::ACE_Sig_Action");
 138   this->sa_.sa_flags = sig_flags;
 139
 140   // Structure assignment...
 141   this->sa_.sa_mask = sig_mask.sigset ();
 142   this->sa_.sa_handler = ACE_SignalHandlerV (sig_handler);
 143   ACE_OS::sigaction (signum, &this->sa_, 0);
 144 }
 145
 146 ACE_Sig_Action::ACE_Sig_Action (const ACE_Sig_Set &signals,
 147                                 ACE_SignalHandler sig_handler,
 148                                 const ACE_Sig_Set &sig_mask,
 149                                 int sig_flags)
 150 {
 151   // ACE_TRACE ("ACE_Sig_Action::ACE_Sig_Action");
 152   this->sa_.sa_flags = sig_flags;
 153
 154   // Structure assignment...
 155   this->sa_.sa_mask = sig_mask.sigset ();
 156   this->sa_.sa_handler = ACE_SignalHandlerV (sig_handler);
 157
 158 #if (ACE_NSIG > 0)
 159   for (int s = 1; s < ACE_NSIG; s++)
 160     if ((signals.is_member (s)) == 1)
 161       ACE_OS::sigaction (s, &this->sa_, 0);
 162 #else  /* ACE_NSIG <= 0  */
 163   ACE_UNUSED_ARG (signals);
 164 #endif /* ACE_NSIG <= 0  */
 165 }
 166
 167 ACE_Sig_Action::ACE_Sig_Action (const ACE_Sig_Set &signals,
 168                                 ACE_SignalHandler sig_handler,
 169                                 sigset_t *sig_mask,
 170                                 int sig_flags)
 171 {
 172   // ACE_TRACE ("ACE_Sig_Action::ACE_Sig_Action");
 173   this->sa_.sa_flags = sig_flags;
 174
 175   if (sig_mask == 0)
 176     ACE_OS::sigemptyset (&this->sa_.sa_mask);
 177   else
 178     this->sa_.sa_mask = *sig_mask; // Structure assignment...
 179
 180   this->sa_.sa_handler = ACE_SignalHandlerV (sig_handler);
 181
 182 #if (ACE_NSIG > 0)
 183   for (int s = 1; s < ACE_NSIG; s++)
 184     if ((signals.is_member (s)) == 1)
 185       ACE_OS::sigaction (s, &this->sa_, 0);
 186 #else  /* ACE_NSIG <= 0  */
 187   ACE_UNUSED_ARG (signals);
 188 #endif /* ACE_NSIG <= 0  */
 189 }
 190
 191 ACE_END_VERSIONED_NAMESPACE_DECL