00001
00002
00003
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
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
00036 ACE_UNUSED_ARG (how);
00037 ACE_UNUSED_ARG (nsp);
00038 ACE_UNUSED_ARG (osp);
00039 ACE_NOTSUP_RETURN (-1);
00040 #endif
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<ACE_SIGACTION*> (nsa),
00070 osa),
00071 int, -1);
00072 #else
00073 ACE_OSCALL_RETURN (::sigaction (signum, nsa, osa), int, -1);
00074 #endif
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;
00091 }
00092 *s |= (1 << (signum - 1)) ;
00093 return 0 ;
00094 #else
00095 ACE_OSCALL_RETURN (::sigaddset (s, signum), int, -1);
00096 #endif
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;
00112 }
00113 *s &= ~(1 << (signum - 1)) ;
00114 return 0;
00115 #else
00116 ACE_OSCALL_RETURN (::sigdelset (s, signum), int, -1);
00117 #endif
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
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
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;
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;
00173 }
00174 # endif
00175 ACE_OSCALL_RETURN (::sigismember (s, signum), int, -1);
00176 #endif
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
00191 #else
00192
00193 ACE_UNUSED_ARG (signum);
00194 ACE_UNUSED_ARG (func);
00195 ACE_NOTSUP_RETURN (0);
00196 #endif
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
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
00228 }
00229
00230 }
00231
00232 ACE_END_VERSIONED_NAMESPACE_DECL