ACE/ace/Signal.inl

   1 // -*- C++ -*-
   2 #include "ace/OS_NS_signal.h"
   3 #include "ace/config-all.h"
   4 #include "ace/Trace.h"
   5 #include "ace/Object_Manager_Base.h"
   6 #include "ace/OS_NS_Thread.h"
   7
   8 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   9
  10 ACE_INLINE
  11 ACE_Sig_Set::ACE_Sig_Set (sigset_t *ss)
  12   // : sigset_ ()
  13 {
  14   ACE_TRACE ("ACE_Sig_Set::ACE_Sig_Set");
  15
  16   if (ss == 0)
  17     ACE_OS::sigfillset (&this->sigset_);
  18   else
  19     // Structure assignment.
  20     this->sigset_ = *ss;
  21 }
  22
  23 ACE_INLINE
  24 ACE_Sig_Set::ACE_Sig_Set (int fill)
  25   // : sigset_ ()
  26 {
  27   ACE_TRACE ("ACE_Sig_Set::ACE_Sig_Set");
  28
  29   if (fill)
  30     ACE_OS::sigfillset (&this->sigset_);
  31   else
  32     ACE_OS::sigemptyset (&this->sigset_);
  33 }
  34
  35 ACE_INLINE
  36 ACE_Sig_Set::ACE_Sig_Set (ACE_Sig_Set *ss)
  37   // : sigset_ ()
  38 {
  39   ACE_TRACE ("ACE_Sig_Set::ACE_Sig_Set");
  40
  41   if (ss == 0)
  42     ACE_OS::sigfillset (&this->sigset_);
  43   else
  44     this->sigset_ = ss->sigset_;
  45 }
  46
  47 ACE_INLINE int
  48 ACE_Sig_Set::empty_set (void)
  49 {
  50   ACE_TRACE ("ACE_Sig_Set::empty_set");
  51   return ACE_OS::sigemptyset (&this->sigset_);
  52 }
  53
  54 ACE_INLINE int
  55 ACE_Sig_Set::fill_set (void)
  56 {
  57   ACE_TRACE ("ACE_Sig_Set::fill_set");
  58   return ACE_OS::sigfillset (&this->sigset_);
  59 }
  60
  61 ACE_INLINE int
  62 ACE_Sig_Set::sig_add (int signo)
  63 {
  64   ACE_TRACE ("ACE_Sig_Set::sig_add");
  65   return ACE_OS::sigaddset (&this->sigset_, signo);
  66 }
  67
  68 ACE_INLINE int
  69 ACE_Sig_Set::sig_del (int signo)
  70 {
  71   ACE_TRACE ("ACE_Sig_Set::sig_del");
  72   return ACE_OS::sigdelset (&this->sigset_, signo);
  73 }
  74
  75 ACE_INLINE int
  76 ACE_Sig_Set::is_member (int signo) const
  77 {
  78   ACE_TRACE ("ACE_Sig_Set::is_member");
  79   return ACE_OS::sigismember (const_cast<sigset_t *> (&this->sigset_), signo);
  80 }
  81
  82 ACE_INLINE
  83 ACE_Sig_Set::operator sigset_t *(void)
  84 {
  85   ACE_TRACE ("ACE_Sig_Set::operator sigset_t *");
  86   return &this->sigset_;
  87 }
  88
  89 ACE_INLINE sigset_t
  90 ACE_Sig_Set::sigset (void) const
  91 {
  92   ACE_TRACE ("ACE_Sig_Set::sigset");
  93   return this->sigset_;
  94 }
  95
  96 ACE_INLINE int
  97 ACE_Sig_Action::flags (void)
  98 {
  99   ACE_TRACE ("ACE_Sig_Action::flags");
 100   return this->sa_.sa_flags;
 101 }
 102
 103 ACE_INLINE void
 104 ACE_Sig_Action::flags (int flags)
 105 {
 106   ACE_TRACE ("ACE_Sig_Action::flags");
 107   this->sa_.sa_flags = flags;
 108 }
 109
 110 ACE_INLINE sigset_t *
 111 ACE_Sig_Action::mask (void)
 112 {
 113   ACE_TRACE ("ACE_Sig_Action::mask");
 114   return &this->sa_.sa_mask;
 115 }
 116
 117 ACE_INLINE void
 118 ACE_Sig_Action::mask (sigset_t *ss)
 119 {
 120   ACE_TRACE ("ACE_Sig_Action::mask");
 121   if (ss != 0)
 122     this->sa_.sa_mask = *ss; // Structure assignment
 123 }
 124
 125 ACE_INLINE void
 126 ACE_Sig_Action::mask (ACE_Sig_Set &ss)
 127 {
 128   ACE_TRACE ("ACE_Sig_Action::mask");
 129   this->sa_.sa_mask = ss.sigset (); // Structure assignment
 130 }
 131
 132 ACE_INLINE ACE_SignalHandler
 133 ACE_Sig_Action::handler (void)
 134 {
 135   ACE_TRACE ("ACE_Sig_Action::handler");
 136   return ACE_SignalHandler (this->sa_.sa_handler);
 137 }
 138
 139 ACE_INLINE void
 140 ACE_Sig_Action::handler (ACE_SignalHandler handler)
 141 {
 142   ACE_TRACE ("ACE_Sig_Action::handler");
 143 #if !defined(ACE_HAS_TANDEM_SIGNALS)
 144   this->sa_.sa_handler = ACE_SignalHandlerV (handler);
 145 #else
 146   this->sa_.sa_handler = (void (*)()) ACE_SignalHandlerV (handler);
 147 #endif /* !ACE_HAS_TANDEM_SIGNALS */
 148 }
 149
 150 ACE_INLINE void
 151 ACE_Sig_Action::set (struct sigaction *sa)
 152 {
 153   ACE_TRACE ("ACE_Sig_Action::set");
 154   this->sa_ = *sa; // Structure assignment.
 155 }
 156
 157 ACE_INLINE struct sigaction *
 158 ACE_Sig_Action::get (void)
 159 {
 160   ACE_TRACE ("ACE_Sig_Action::get");
 161   return &this->sa_;
 162 }
 163
 164 ACE_INLINE
 165 ACE_Sig_Action::operator struct sigaction * ()
 166 {
 167   ACE_TRACE ("ACE_Sig_Action::operator struct sigaction *");
 168   return &this->sa_;
 169 }
 170
 171 ACE_INLINE int
 172 ACE_Sig_Action::register_action (int signum, ACE_Sig_Action *oaction)
 173 {
 174   ACE_TRACE ("ACE_Sig_Action::register_action");
 175   struct sigaction *sa = oaction == 0 ? 0 : oaction->get ();
 176
 177   return ACE_OS::sigaction (signum, &this->sa_, sa);
 178 }
 179
 180 ACE_INLINE int
 181 ACE_Sig_Action::retrieve_action (int signum)
 182 {
 183   ACE_TRACE ("ACE_Sig_Action::retrieve_action");
 184   return ACE_OS::sigaction (signum, 0, &this->sa_);
 185 }
 186
 187 ACE_INLINE int
 188 ACE_Sig_Action::restore_action (int signum, ACE_Sig_Action &oaction)
 189 {
 190   ACE_TRACE ("ACE_Sig_Action::restore_action");
 191   this->sa_ = *oaction.get (); // Structure assignment
 192   return ACE_OS::sigaction (signum, &this->sa_, 0);
 193 }
 194
 195 // Block out the signal MASK until the destructor is called.
 196
 197 ACE_INLINE
 198 ACE_Sig_Guard::ACE_Sig_Guard (ACE_Sig_Set *mask,
 199                               bool condition)
 200   : omask_ ()
 201   , condition_ (condition)
 202 {
 203   //ACE_TRACE ("ACE_Sig_Guard::ACE_Sig_Guard");
 204   if (!this->condition_)
 205     return;
 206
 207 #if defined (ACE_LACKS_UNIX_SIGNALS)
 208   ACE_UNUSED_ARG (mask);
 209 #else
 210   // If MASK is 0 then block all signals!
 211   if (mask == 0)
 212     {
 213 #  if defined (ACE_LACKS_PTHREAD_THR_SIGSETMASK)
 214       ACE_OS::sigprocmask (SIG_BLOCK,
 215                            ACE_OS_Object_Manager::default_mask (),
 216                            (sigset_t *) this->omask_);
 217 #  else
 218       ACE_OS::thr_sigsetmask (SIG_BLOCK,
 219                               ACE_OS_Object_Manager::default_mask (),
 220                               (sigset_t *) this->omask_);
 221 #  endif /* ACE_LACKS_PTHREAD_THR_SIGSETMASK */
 222     }
 223   else
 224 #  if defined (ACE_LACKS_PTHREAD_THR_SIGSETMASK)
 225     ACE_OS::sigprocmask (SIG_BLOCK,
 226                          (sigset_t *) *mask,
 227                          (sigset_t *)
 228                          this->omask_);
 229 #  else
 230     ACE_OS::thr_sigsetmask (SIG_BLOCK,
 231                             (sigset_t *) *mask,
 232                             (sigset_t *)
 233                             this->omask_);
 234 #  endif /* ACE_LACKS_PTHREAD_THR_SIGSETMASK */
 235 #endif /* ACE_LACKS_UNIX_SIGNALS */
 236 }
 237
 238 ACE_END_VERSIONED_NAMESPACE_DECL