OS_NS_signal.inl

Go to the documentation of this file.
00001 // -*- C++ -*-
00002 //
00003 // OS_NS_signal.inl,v 1.15 2006/05/30 13:15:25 schmidt Exp
00004 
00005 #include "ace/OS_NS_macros.h"
00006 #include "ace/OS_NS_errno.h"
00007 
00008 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00009 
00010 namespace ACE_OS
00011 {
00012 
00013 ACE_INLINE int
00014 kill (pid_t pid, int signum)
00015 {
00016   ACE_OS_TRACE ("ACE_OS::kill");
00017 #if defined (ACE_LACKS_KILL)
00018   ACE_UNUSED_ARG (pid);
00019   ACE_UNUSED_ARG (signum);
00020   ACE_NOTSUP_RETURN (-1);
00021 #else
00022   ACE_OSCALL_RETURN (::kill (pid, signum), int, -1);
00023 #endif /* ACE_LACKS_KILL */
00024 }
00025 
00026 ACE_INLINE int
00027 pthread_sigmask (int how, const sigset_t *nsp, sigset_t *osp)
00028 {
00029 #if defined (ACE_HAS_PTHREADS_STD) && !defined (ACE_LACKS_PTHREAD_SIGMASK)
00030   int result;
00031   ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_sigmask (how, nsp, osp),
00032                                        result),
00033                      int,
00034                      -1);
00035 #else /* !ACE_HAS_PTHREADS_STD && !ACE_LACKS_PTHREAD_SIGMASK */
00036   ACE_UNUSED_ARG (how);
00037   ACE_UNUSED_ARG (nsp);
00038   ACE_UNUSED_ARG (osp);
00039   ACE_NOTSUP_RETURN (-1);
00040 #endif /* ACE_HAS_PTHREADS_STD && !ACE_LACKS_PTHREAD_SIGMASK */
00041 }
00042 
00043 ACE_INLINE int
00044 sigaction (int signum, const ACE_SIGACTION *nsa, ACE_SIGACTION *osa)
00045 {
00046   ACE_OS_TRACE ("ACE_OS::sigaction");
00047   if (signum == 0)
00048     return 0;
00049 #if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)
00050   struct sigaction sa;
00051 
00052   if (osa == 0)
00053     osa = &sa;
00054 
00055   if (nsa == 0)
00056     {
00057       osa->sa_handler = ::signal (signum, SIG_IGN);
00058       ::signal (signum, osa->sa_handler);
00059     }
00060   else
00061     osa->sa_handler = ::signal (signum, nsa->sa_handler);
00062   return osa->sa_handler == SIG_ERR ? -1 : 0;
00063 #elif defined (ACE_LACKS_SIGACTION)
00064   ACE_UNUSED_ARG (nsa);
00065   ACE_UNUSED_ARG (osa);
00066   ACE_NOTSUP_RETURN (-1);
00067 #elif !defined (ACE_HAS_SIGACTION_CONSTP2)
00068   ACE_OSCALL_RETURN (::sigaction (signum,
00069                                   const_cast<struct sigaction*> (nsa),
00070                                   osa),
00071                      int, -1);
00072 #else
00073   ACE_OSCALL_RETURN (::sigaction (signum, nsa, osa), int, -1);
00074 #endif /* ACE_WIN32 !ACE_HAS_WINCE */
00075 }
00076 
00077 ACE_INLINE int
00078 sigaddset (sigset_t *s, int signum)
00079 {
00080   ACE_OS_TRACE ("ACE_OS::sigaddset");
00081 #if defined (ACE_LACKS_SIGSET) || defined (ACE_LACKS_SIGSET_DEFINITIONS)
00082   if (s == 0)
00083     {
00084       errno = EFAULT;
00085       return -1;
00086     }
00087   else if (signum < 1 || signum >= ACE_NSIG)
00088     {
00089       errno = EINVAL;
00090       return -1;                 // Invalid signum, return error
00091     }
00092   *s |= (1 << (signum - 1)) ;
00093   return 0 ;
00094 #else
00095   ACE_OSCALL_RETURN (::sigaddset (s, signum), int, -1);
00096 #endif /* ACE_LACKS_SIGSET || ACE_LACKS_SIGSET_DEFINITIONS */
00097 }
00098 
00099 ACE_INLINE int
00100 sigdelset (sigset_t *s, int signum)
00101 {
00102 #if defined (ACE_LACKS_SIGSET) || defined (ACE_LACKS_SIGSET_DEFINITIONS)
00103   if (s == 0)
00104     {
00105       errno = EFAULT;
00106       return -1;
00107     }
00108   else if (signum < 1 || signum >= ACE_NSIG)
00109     {
00110       errno = EINVAL;
00111       return -1;                 // Invalid signum, return error
00112     }
00113   *s &= ~(1 << (signum - 1)) ;
00114   return 0;
00115 #else
00116   ACE_OSCALL_RETURN (::sigdelset (s, signum), int, -1);
00117 #endif /* ACE_LACKS_SIGSET || ACE_LACKS_SIGSET_DEFINITIONS */
00118 }
00119 
00120 ACE_INLINE int
00121 sigemptyset (sigset_t *s)
00122 {
00123 #if defined (ACE_LACKS_SIGSET) || defined (ACE_LACKS_SIGSET_DEFINITIONS)
00124   if (s == 0)
00125     {
00126       errno = EFAULT;
00127       return -1;
00128     }
00129   *s = 0 ;
00130   return 0 ;
00131 #else
00132   ACE_OSCALL_RETURN (::sigemptyset (s), int, -1);
00133 #endif /* ACE_LACKS_SIGSET || ACE_LACKS_SIGSET_DEFINITIONS */
00134 }
00135 
00136 ACE_INLINE int
00137 sigfillset (sigset_t *s)
00138 {
00139 #if defined (ACE_LACKS_SIGSET) || defined (ACE_LACKS_SIGSET_DEFINITIONS)
00140   if (s == 0)
00141     {
00142       errno = EFAULT;
00143       return -1;
00144     }
00145   *s = ~(sigset_t) 0;
00146   return 0 ;
00147 #else
00148   ACE_OSCALL_RETURN (::sigfillset (s), int, -1);
00149 #endif /* ACE_LACKS_SIGSET || ACE_LACKS_SIGSET_DEFINITIONS */
00150 }
00151 
00152 ACE_INLINE int
00153 sigismember (sigset_t *s, int signum)
00154 {
00155 #if defined (ACE_LACKS_SIGSET) || defined (ACE_LACKS_SIGSET_DEFINITIONS)
00156   if (s == 0)
00157     {
00158       errno = EFAULT;
00159       return -1;
00160     }
00161   else if (signum < 1 || signum >= ACE_NSIG)
00162     {
00163       errno = EINVAL;
00164       return -1;                 // Invalid signum, return error
00165     }
00166   return ((*s & (1 << (signum - 1))) != 0) ;
00167 #else
00168 #  if defined (ACE_HAS_SIGISMEMBER_BUG)
00169   if (signum < 1 || signum >= ACE_NSIG)
00170     {
00171       errno = EINVAL;
00172       return -1;                 // Invalid signum, return error
00173     }
00174 #  endif /* ACE_HAS_SIGISMEMBER_BUG */
00175   ACE_OSCALL_RETURN (::sigismember (s, signum), int, -1);
00176 #endif /* ACE_LACKS_SIGSET || ACE_LACKS_SIGSET_DEFINITIONS */
00177 }
00178 
00179 ACE_INLINE ACE_SignalHandler
00180 signal (int signum, ACE_SignalHandler func)
00181 {
00182   if (signum == 0)
00183     return 0;
00184   else
00185 # if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE) || !defined (ACE_LACKS_UNIX_SIGNALS)
00186 #  if !defined (ACE_HAS_TANDEM_SIGNALS) && !defined (ACE_HAS_LYNXOS_SIGNALS)
00187     return ::signal (signum, func);
00188 #  else
00189     return (ACE_SignalHandler) ::signal (signum, (void (*)(int)) func);
00190 #  endif /* !ACE_HAS_TANDEM_SIGNALS */
00191 #else
00192     // @@ WINCE: Don't know how to implement signal on WinCE (yet.)
00193     ACE_UNUSED_ARG (signum);
00194     ACE_UNUSED_ARG (func);
00195     ACE_NOTSUP_RETURN (0);     // Should return SIG_ERR but it is not defined on WinCE.
00196 #endif /* defined (ACE_WIN32) && !defined (ACE_HAS_WINCE) || !defined (ACE_LACKS_UNIX_SIGNALS) */
00197 }
00198 
00199 ACE_INLINE int
00200 sigprocmask (int how, const sigset_t *nsp, sigset_t *osp)
00201 {
00202 #if defined (ACE_LACKS_SIGSET) || defined (ACE_LACKS_SIGSET_DEFINITIONS)
00203   ACE_UNUSED_ARG (how);
00204   ACE_UNUSED_ARG (nsp);
00205   ACE_UNUSED_ARG (osp);
00206   ACE_NOTSUP_RETURN (-1);
00207 #else
00208   ACE_OSCALL_RETURN (::sigprocmask (how, nsp, osp), int, -1);
00209 #endif /* ACE_LACKS_SIGSET || ACE_LACKS_SIGSET_DEFINITIONS */
00210 }
00211 
00212 ACE_INLINE int
00213 sigsuspend (const sigset_t *sigset)
00214 {
00215 #if defined (ACE_HAS_SIGSUSPEND)
00216   sigset_t s;
00217 
00218   if (sigset == 0)
00219     {
00220       sigset = &s;
00221       ACE_OS::sigemptyset (&s);
00222     }
00223   ACE_OSCALL_RETURN (::sigsuspend (sigset), int, -1);
00224 #else
00225   ACE_UNUSED_ARG (sigset);
00226   ACE_NOTSUP_RETURN (-1);
00227 #endif /* ACE_HAS_SIGSUSPEND */
00228 }
00229 
00230 }  /* end namespace ACE_OS */
00231 
00232 ACE_END_VERSIONED_NAMESPACE_DECL

Generated on Thu Nov 9 09:41:57 2006 for ACE by doxygen 1.3.6