ACE/ace/OS_NS_signal.inl

   1 // -*- C++ -*-
   2 #include "ace/OS_NS_macros.h"
   3 #include "ace/OS_NS_errno.h"
   4 #include "ace/os_include/os_pthread.h"
   5
   6 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   7
   8 namespace ACE_OS
   9 {
  10
  11 ACE_INLINE int
  12 kill (pid_t pid, int signum)
  13 {
  14   ACE_OS_TRACE ("ACE_OS::kill");
  15 #if defined (ACE_LACKS_KILL)
  16   ACE_UNUSED_ARG (pid);
  17   ACE_UNUSED_ARG (signum);
  18   ACE_NOTSUP_RETURN (-1);
  19 #elif defined (ACE_VXWORKS)
  20   /*
  21    * The VxWorks kill interface is not really POSIX
  22    * since they use a task id in place of a pid type.
  23    * This only becomes an issue when using the 64bit compiler
  24    * as the TASK_ID is no longer defined as an int.
  25    */
  26   return ::kill ((ACE_VX_TASK_ID)pid, signum);
  27 #else
  28   return ::kill (pid, signum);
  29 #endif /* ACE_LACKS_KILL */
  30 }
  31
  32 ACE_INLINE int
  33 pthread_sigmask (int how, const sigset_t *nsp, sigset_t *osp)
  34 {
  35 #if defined (ACE_HAS_PTHREADS) && !defined (ACE_LACKS_PTHREAD_SIGMASK)
  36   int result;
  37 # ifdef ACE_PTHREAD_SIGMASK_MACRO
  38   ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (ACE_PTHREAD_SIGMASK_MACRO (how, nsp, osp), result), int);
  39 # elif defined (ACE_HAS_NONCONST_PTHREAD_SIGMASK)
  40   sigset_t *ncnsp = const_cast<sigset_t *>(nsp);
  41   ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_sigmask (how, ncnsp, osp), result), int);
  42 # else
  43   ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_sigmask (how, nsp, osp), result), int);
  44 # endif /* ACE_HAS_NONCONST__PTHREAD_SIGMASK */
  45 #else /* !ACE_HAS_PTHREADS && !ACE_LACKS_PTHREAD_SIGMASK */
  46   ACE_UNUSED_ARG (how);
  47   ACE_UNUSED_ARG (nsp);
  48   ACE_UNUSED_ARG (osp);
  49   ACE_NOTSUP_RETURN (-1);
  50 #endif /* ACE_HAS_PTHREADS && !ACE_LACKS_PTHREAD_SIGMASK */
  51 }
  52
  53 ACE_INLINE int
  54 sigaction (int signum, const ACE_SIGACTION *nsa, ACE_SIGACTION *osa)
  55 {
  56   ACE_OS_TRACE ("ACE_OS::sigaction");
  57   if (signum == 0)
  58     return 0;
  59 #if defined (ACE_WIN32)
  60   struct sigaction sa;
  61
  62   if (osa == 0)
  63     osa = &sa;
  64
  65   if (nsa == 0)
  66     {
  67       osa->sa_handler = ::signal (signum, SIG_IGN);
  68       ::signal (signum, osa->sa_handler);
  69     }
  70   else
  71     osa->sa_handler = ::signal (signum, nsa->sa_handler);
  72   return osa->sa_handler == SIG_ERR ? -1 : 0;
  73 #elif defined (ACE_LACKS_SIGACTION)
  74   ACE_UNUSED_ARG (nsa);
  75   ACE_UNUSED_ARG (osa);
  76   ACE_NOTSUP_RETURN (-1);
  77 #elif !defined (ACE_HAS_SIGACTION_CONSTP2)
  78   return ::sigaction (signum, const_cast<ACE_SIGACTION*> (nsa), osa);
  79 #else
  80   return ::sigaction (signum, nsa, osa);
  81 #endif /* ACE_WIN32 */
  82 }
  83
  84 ACE_INLINE int
  85 sigaddset (sigset_t *s, int signum)
  86 {
  87   ACE_OS_TRACE ("ACE_OS::sigaddset");
  88 #if defined (ACE_LACKS_SIGSET)
  89   if (s == 0)
  90     {
  91       errno = EFAULT;
  92       return -1;
  93     }
  94   else if (signum < 1 || signum >= ACE_NSIG)
  95     {
  96       errno = EINVAL;
  97       return -1;                 // Invalid signum, return error
  98     }
  99   *s |= (1 << (signum - 1)) ;
 100   return 0 ;
 101 #else
 102   return ace_sigaddset_helper (s, signum);
 103 #endif /* ACE_LACKS_SIGSET */
 104 }
 105
 106 ACE_INLINE int
 107 sigdelset (sigset_t *s, int signum)
 108 {
 109 #if defined (ACE_LACKS_SIGSET)
 110   if (s == 0)
 111     {
 112       errno = EFAULT;
 113       return -1;
 114     }
 115   else if (signum < 1 || signum >= ACE_NSIG)
 116     {
 117       errno = EINVAL;
 118       return -1;                 // Invalid signum, return error
 119     }
 120   *s &= ~(1 << (signum - 1)) ;
 121   return 0;
 122 #else
 123   return ace_sigdelset_helper (s, signum);
 124 #endif /* ACE_LACKS_SIGSET */
 125 }
 126
 127 ACE_INLINE int
 128 sigemptyset (sigset_t *s)
 129 {
 130 #if defined (ACE_LACKS_SIGSET)
 131   if (s == 0)
 132     {
 133       errno = EFAULT;
 134       return -1;
 135     }
 136   *s = 0 ;
 137   return 0;
 138 #else
 139   return ace_sigemptyset_helper (s);
 140 #endif /* ACE_LACKS_SIGSET */
 141 }
 142
 143 ACE_INLINE int
 144 sigfillset (sigset_t *s)
 145 {
 146 #if defined (ACE_LACKS_SIGSET)
 147   if (s == 0)
 148     {
 149       errno = EFAULT;
 150       return -1;
 151     }
 152   *s = ~(sigset_t) 0;
 153   return 0 ;
 154 #else
 155   return ace_sigfillset_helper (s);
 156 #endif /* ACE_LACKS_SIGSET */
 157 }
 158
 159 ACE_INLINE int
 160 sigismember (sigset_t *s, int signum)
 161 {
 162 #if defined (ACE_LACKS_SIGSET)
 163   if (s == 0)
 164     {
 165       errno = EFAULT;
 166       return -1;
 167     }
 168   else if (signum < 1 || signum >= ACE_NSIG)
 169     {
 170       errno = EINVAL;
 171       return -1;                 // Invalid signum, return error
 172     }
 173   return ((*s & (1 << (signum - 1))) != 0) ;
 174 #else
 175 #  if defined (ACE_HAS_SIGISMEMBER_BUG)
 176   if (signum < 1 || signum >= ACE_NSIG)
 177     {
 178       errno = EINVAL;
 179       return -1;                 // Invalid signum, return error
 180     }
 181 #  endif /* ACE_HAS_SIGISMEMBER_BUG */
 182   return ace_sigismember_helper (s, signum);
 183 #endif /* ACE_LACKS_SIGSET */
 184 }
 185
 186 ACE_INLINE ACE_SignalHandler
 187 signal (int signum, ACE_SignalHandler func)
 188 {
 189   if (signum == 0)
 190     return 0;
 191   else
 192     {
 193 #if (defined ACE_WIN32) || \
 194     (!defined ACE_LACKS_UNIX_SIGNALS && !defined ACE_LACKS_SIGNAL)
 195       return ::signal (signum, func);
 196 #else
 197       ACE_UNUSED_ARG (signum);
 198       ACE_UNUSED_ARG (func);
 199       ACE_NOTSUP_RETURN (0);     // Should return SIG_ERR but maybe not defined on all platforms
 200 #endif /* defined (ACE_WIN32) || !defined (ACE_LACKS_UNIX_SIGNALS) */
 201     }
 202 }
 203
 204 ACE_INLINE int
 205 sigprocmask (int how, const sigset_t *nsp, sigset_t *osp)
 206 {
 207 #if defined (ACE_LACKS_SIGSET) || defined (ACE_LACKS_SIGSET_DEFINITIONS) || defined (ACE_LACKS_SIGPROCMASK)
 208   ACE_UNUSED_ARG (how);
 209   ACE_UNUSED_ARG (nsp);
 210   ACE_UNUSED_ARG (osp);
 211   ACE_NOTSUP_RETURN (-1);
 212 #else
 213   return ::sigprocmask (how, nsp, osp);
 214 #endif /* ACE_LACKS_SIGSET || ACE_LACKS_SIGSET_DEFINITIONS || ACE_LACKS_SIGPROCMASK */
 215 }
 216
 217 ACE_INLINE int
 218 sigsuspend (const sigset_t *s)
 219 {
 220 #if defined (ACE_HAS_SIGSUSPEND)
 221   sigset_t sigset;
 222
 223   if (s == 0)
 224     {
 225       ACE_OS::sigemptyset (&sigset);
 226       s = &sigset;
 227     }
 228   return ace_sigsuspend_helper (s);
 229 #else
 230   ACE_UNUSED_ARG (s);
 231   ACE_NOTSUP_RETURN (-1);
 232 #endif /* ACE_HAS_SIGSUSPEND */
 233 }
 234
 235 ACE_INLINE int
 236 raise (const int signum)
 237 {
 238 #if defined (ACE_LACKS_RAISE)
 239   ACE_UNUSED_ARG (signum);
 240   ACE_NOTSUP_RETURN (-1);
 241 #else
 242   return ::raise (signum);
 243 #endif /* ACE_LACKS_RAISE */
 244 }
 245
 246 }  /* end namespace ACE_OS */
 247
 248 ACE_END_VERSIONED_NAMESPACE_DECL