ACE/ace/Signal.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file    Signal.h
   6  *
   7  *  @author Douglas C. Schmidt <d.schmidt@vanderbilt.edu>
   8  */
   9 //=============================================================================
  10
  11 #ifndef ACE_SIGNAL_H
  12 #define ACE_SIGNAL_H
  13 #include /**/ "ace/pre.h"
  14
  15 #include /**/ "ace/config-lite.h"
  16
  17 #if defined (ACE_DONT_INCLUDE_ACE_SIGNAL_H)
  18 # error ace/Signal.h was #included instead of signal.h by ace/OS_NS_signal.h:  fix!!!!
  19 #endif /* ACE_DONT_INCLUDE_ACE_SIGNAL_H */
  20
  21 #include /**/ "ace/ACE_export.h"
  22
  23 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  24 # pragma once
  25 #endif /* ACE_LACKS_PRAGMA_ONCE */
  26
  27 #include "ace/OS_NS_signal.h"
  28
  29 /// Type of the extended signal handler.
  30 using ACE_Sig_Handler_Ex = void (*) (int, siginfo_t *siginfo, ucontext_t *ucontext);
  31
  32 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  33
  34 /**
  35  * @class ACE_Sig_Set
  36  *
  37  * @brief Provide a C++ wrapper for the C sigset_t interface.
  38  *
  39  * Handle signals via a more elegant C++ interface (e.g.,
  40  * doesn't require the use of global variables or global
  41  * functions in an application).
  42  */
  43 class ACE_Export ACE_Sig_Set
  44 {
  45 public:
  46   /// Initialize sigset_ with @a sigset.  If @a sigset == 0 then fill
  47   /// the set.
  48   ACE_Sig_Set (sigset_t *sigset);
  49
  50   /// Initialize sigset_ with @a sigset.  If @a sigset == 0 then fill
  51   /// the set.
  52   ACE_Sig_Set (ACE_Sig_Set *sigset);
  53
  54   /// If @a fill == false then initialize the sigset_ to be empty, else
  55   /// full.
  56   ACE_Sig_Set (bool fill = false);
  57
  58   ~ACE_Sig_Set ();
  59
  60   /// Create a set that excludes all signals defined by the system.
  61   int empty_set ();
  62
  63   /// Create a set that includes all signals defined by the system.
  64   int fill_set ();
  65
  66   /// Adds the individual signal specified by @a signo to the set.
  67   int sig_add (int signo);
  68
  69   /// Deletes the individual signal specified by @a signo from the set.
  70   int sig_del (int signo);
  71
  72   /// Checks whether the signal specified by @a signo is in the set.
  73   int is_member (int signo) const;
  74
  75   /// Returns a pointer to the underlying @c sigset_t.
  76   operator sigset_t *();
  77
  78   /// Returns a copy of the underlying @c sigset_t.
  79   sigset_t sigset () const;
  80
  81   /// Dump the state of an object.
  82   void dump () const;
  83
  84   /// Declare the dynamic allocation hooks.
  85   ACE_ALLOC_HOOK_DECLARE;
  86
  87 private:
  88   /// Set of signals.
  89   sigset_t sigset_;
  90 };
  91
  92 /**
  93  * @class ACE_Sig_Action
  94  *
  95  * @brief C++ wrapper facade for the @c sigaction struct.
  96  */
  97 class ACE_Export ACE_Sig_Action
  98 {
  99 public:
 100   /// Default constructor.  Initializes everything to 0.
 101   ACE_Sig_Action ();
 102
 103   /// Assigns the various fields of a @c sigaction struct but doesn't
 104   /// register for signal handling via the @c sigaction function.
 105   ACE_Sig_Action (ACE_SignalHandler handler,
 106                   sigset_t *sigmask = nullptr,
 107                   int flags = 0);
 108
 109   /// Assigns the various fields of a @c sigaction struct but doesn't
 110   /// register for signal handling via the @c sigaction function.
 111   ACE_Sig_Action (ACE_SignalHandler handler,
 112                   const ACE_Sig_Set &sigmask,
 113                   int flags = 0);
 114
 115   /**
 116    * Assigns the various fields of a @c sigaction struct and registers
 117    * the @a handler to process signal @a signum via the @c sigaction
 118    * function.
 119    */
 120   ACE_Sig_Action (ACE_SignalHandler handler,
 121                   int signum,
 122                   sigset_t *sigmask = nullptr,
 123                   int flags = 0);
 124
 125   /**
 126    * Assigns the various fields of a @c sigaction struct and registers
 127    * the @a handler to process signal @a signum via the @c sigaction
 128    * function.
 129    */
 130   ACE_Sig_Action (ACE_SignalHandler handler,
 131                   int signum,
 132                   const ACE_Sig_Set &sigmask,
 133                   int flags = 0);
 134
 135   /**
 136    * Assigns the various fields of a @c sigaction struct and registers
 137    * the @a handler to process all @a signalss via the @c sigaction
 138    * function.
 139    */
 140   ACE_Sig_Action (const ACE_Sig_Set &signalss,
 141                   ACE_SignalHandler handler,
 142                   const ACE_Sig_Set &sigmask,
 143                   int flags = 0);
 144
 145   /**
 146    * Assigns the various fields of a @c sigaction struct and registers
 147    * the @a handler to process all @a signalss via the @c sigaction
 148    * function.
 149    */
 150   ACE_Sig_Action (const ACE_Sig_Set &signalss,
 151                   ACE_SignalHandler handler,
 152                   sigset_t *sigmask = nullptr,
 153                   int flags = 0);
 154
 155   ACE_Sig_Action (const ACE_Sig_Action&) = default;
 156   ACE_Sig_Action (ACE_Sig_Action&&) = default;
 157   ACE_Sig_Action& operator = (ACE_Sig_Action const &) = default;
 158   ACE_Sig_Action &operator = (ACE_Sig_Action&&)  = default;
 159
 160   /// Default dtor.
 161   ~ACE_Sig_Action ();
 162
 163   // = Signal action management.
 164   /// Register @c this as the current disposition and store old
 165   /// disposition into @a oaction if it is non-NULL.
 166   int register_action (int signum,
 167                        ACE_Sig_Action *oaction = nullptr);
 168
 169   /// Assign the value of @a oaction to @c this and make it become the
 170   /// new signal disposition.
 171   int restore_action (int signum,
 172                       ACE_Sig_Action &oaction);
 173
 174   /// Retrieve the current disposition into @c this.
 175   int retrieve_action (int signum);
 176
 177   /// Set current signal action.
 178   void set (struct sigaction *);
 179
 180   /// Get current signal action.
 181   struct sigaction *get ();
 182   operator struct sigaction *();
 183
 184   /// Set current signal flags.
 185   void flags (int);
 186
 187   /// Get current signal flags.
 188   int flags ();
 189
 190   /// Set current signal mask.
 191   void mask (sigset_t *);
 192   void mask (ACE_Sig_Set &);
 193
 194   /// Get current signal mask.
 195   sigset_t *mask ();
 196
 197   /// Set current signal handler (pointer to function).
 198   void handler (ACE_SignalHandler);
 199
 200   /// Get current signal handler (pointer to function).
 201   ACE_SignalHandler handler ();
 202
 203   /// Dump the state of an object.
 204   void dump () const;
 205
 206   /// Declare the dynamic allocation hooks.
 207   ACE_ALLOC_HOOK_DECLARE;
 208
 209 private:
 210   /// Controls signal behavior.
 211   struct sigaction sa_;
 212 };
 213
 214 /**
 215  * @class ACE_Sig_Guard
 216  *
 217  * @brief Hold signals in MASK for duration of a C++ statement block.
 218  * Note that a "0" for mask causes all signals to be held.
 219  */
 220 class ACE_Export ACE_Sig_Guard
 221 {
 222 public:
 223   /// This is kind of conditional Guard, needed when guard should be
 224   /// activated only when a specific condition met. When condition ==
 225   /// true (default), Guard is activated
 226   ACE_Sig_Guard (ACE_Sig_Set *mask = nullptr, bool condition = true);
 227
 228   /// Restore blocked signals.
 229   ~ACE_Sig_Guard ();
 230
 231   /// Dump the state of an object.
 232   void dump () const;
 233
 234   /// Declare the dynamic allocation hooks.
 235   ACE_ALLOC_HOOK_DECLARE;
 236
 237 private:
 238   /// Original signal mask.
 239   ACE_Sig_Set omask_;
 240
 241   /// Guard Condition
 242   bool const condition_;
 243 };
 244
 245 ACE_END_VERSIONED_NAMESPACE_DECL
 246
 247 #if defined (__ACE_INLINE__)
 248 #include "ace/Signal.inl"
 249 #endif /* __ACE_INLINE__ */
 250
 251 #include /**/ "ace/post.h"
 252 #endif /* ACE_SIGNAL_HANDLER_H */