compat-43/sigcompat.c

   1 /*
   2  * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23 /*
  24  * Copyright (c) 1989, 1993
  25  *      The Regents of the University of California.  All rights reserved.
  26  *
  27  * Redistribution and use in source and binary forms, with or without
  28  * modification, are permitted provided that the following conditions
  29  * are met:
  30  * 1. Redistributions of source code must retain the above copyright
  31  *    notice, this list of conditions and the following disclaimer.
  32  * 2. Redistributions in binary form must reproduce the above copyright
  33  *    notice, this list of conditions and the following disclaimer in the
  34  *    documentation and/or other materials provided with the distribution.
  35  * 3. All advertising materials mentioning features or use of this software
  36  *    must display the following acknowledgement:
  37  *      This product includes software developed by the University of
  38  *      California, Berkeley and its contributors.
  39  * 4. Neither the name of the University nor the names of its contributors
  40  *    may be used to endorse or promote products derived from this software
  41  *    without specific prior written permission.
  42  *
  43  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  44  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  45  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  46  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  47  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  48  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  49  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  50  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  51  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  52  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  53  * SUCH DAMAGE.
  54  */
  55
  56 #if __DARWIN_UNIX03
  57 #ifdef VARIANT_CANCELABLE
  58 #include <pthread.h>
  59
  60 extern void _pthread_testcancel(pthread_t thread, int isconforming);
  61 #endif /* VARIANT_CANCELABLE */
  62 extern int __unix_conforming;
  63 #endif /* __DARWIN_UNIX03 */
  64
  65 #include <sys/param.h>
  66 #include <signal.h>
  67 #include <errno.h>
  68
  69 #ifndef BUILDING_VARIANT
  70 #if defined(__DYNAMIC__)
  71 extern int _sigaction_nobind (int sig, const struct sigaction *nsv, struct sigaction *osv);
  72 #endif
  73
  74 static int
  75 sigvec__(signo, sv, osv, bind)
  76         int signo;
  77         struct sigvec *sv, *osv;
  78         int bind;
  79 {
  80         int ret;
  81
  82         if (sv)
  83                 sv->sv_flags ^= SV_INTERRUPT;   /* !SA_INTERRUPT */
  84 #if defined(__DYNAMIC__)
  85         if (bind) {
  86 #endif
  87             ret = sigaction(signo, (struct sigaction *)sv, (struct sigaction *)osv);
  88 #if defined(__DYNAMIC__)
  89         } else {
  90             ret = _sigaction_nobind(signo, (struct sigaction *)sv, (struct sigaction *)osv);
  91         }
  92 #endif
  93         if (ret == 0 && osv)
  94                 osv->sv_flags ^= SV_INTERRUPT;  /* !SA_INTERRUPT */
  95         return (ret);
  96 }
  97
  98 int
  99 sigvec(signo, sv, osv)
 100         int signo;
 101         struct sigvec *sv, *osv;
 102 {
 103     return sigvec__(signo, sv, osv, 1);
 104 }
 105
 106 #if defined(__DYNAMIC__)
 107 int
 108 _sigvec_nobind(signo, sv, osv)
 109         int signo;
 110         struct sigvec *sv, *osv;
 111 {
 112     return sigvec__(signo, sv, osv, 0);
 113 }
 114 #endif
 115
 116 int
 117 sigsetmask(mask)
 118         int mask;
 119 {
 120         int omask, n;
 121
 122         n = sigprocmask(SIG_SETMASK, (sigset_t *) &mask, (sigset_t *) &omask);
 123         if (n)
 124                 return (n);
 125         return (omask);
 126 }
 127
 128 int
 129 sigblock(mask)
 130         int mask;
 131 {
 132         int omask, n;
 133
 134         n = sigprocmask(SIG_BLOCK, (sigset_t *) &mask, (sigset_t *) &omask);
 135         if (n)
 136                 return (n);
 137         return (omask);
 138 }
 139 #endif /* !BUILDING_VARIANT */
 140
 141 #if __DARWIN_UNIX03
 142 int
 143 sigpause(sig)
 144         int sig;
 145 {
 146         sigset_t mask;
 147
 148         if (__unix_conforming == 0)
 149                 __unix_conforming = 1;
 150 #ifdef VARIANT_CANCELABLE
 151         _pthread_testcancel(pthread_self(), 1);
 152 #endif /* VARIANT_CANCELABLE */
 153
 154         if ((sig <= 0) || (sig >= NSIG)) {
 155                 errno = EINVAL;
 156                 return(-1);
 157         }
 158         if (sigprocmask(SIG_BLOCK, (sigset_t *) 0, (sigset_t *) &mask) < 0) {
 159                 return(-1);
 160         }
 161         sigdelset(&mask, sig);
 162         return (sigsuspend(&mask));
 163 }
 164 #else
 165 int
 166 sigpause(mask)
 167         int mask;
 168 {
 169         return (sigsuspend((sigset_t *)&mask));
 170 }
 171 #endif /* __DARWIN_UNIX03 */
 172
 173 #ifndef BUILDING_VARIANT
 174 int
 175 sighold(sig)
 176         int sig;
 177 {
 178         sigset_t mask;
 179
 180         if ((sig <= 0) || (sig >= NSIG)) {
 181                 errno = EINVAL;
 182                 return(-1);
 183         }
 184         sigemptyset(&mask);
 185         sigaddset(&mask, sig);
 186         return(sigprocmask(SIG_BLOCK, &mask,(sigset_t *)0));
 187 }
 188
 189 int
 190 sigrelse(sig)
 191         int sig;
 192 {
 193         sigset_t mask;
 194
 195         if ((sig <= 0) || (sig >= NSIG)) {
 196                 errno = EINVAL;
 197                 return(-1);
 198         }
 199         sigemptyset(&mask);
 200         sigaddset(&mask, sig);
 201         return(sigprocmask(SIG_UNBLOCK, &mask,(sigset_t *)0));
 202 }
 203
 204
 205 int
 206 sigignore(sig)
 207         int sig;
 208 {
 209         return (signal(sig, SIG_IGN) == SIG_ERR ? -1 : 0);
 210 }
 211
 212 void (*sigset(int sig, void (*disp)(int)))(int) {
 213         sigset_t omask;
 214         int blocked;
 215         struct sigaction oact;
 216
 217         if ((sig <= 0) || (sig >= NSIG)) {
 218                 errno = EINVAL;
 219                 return (SIG_ERR);
 220         }
 221         if (-1 == sigprocmask(0, NULL, &omask))
 222                 return (SIG_ERR);
 223         blocked = sigismember(&omask, sig);
 224         if (disp == SIG_HOLD) {
 225                 if (blocked)
 226                         return (SIG_HOLD);
 227                 if ((-1 == sigaction(sig, NULL, &oact)) ||
 228                     (-1 == sighold(sig)))
 229                         return (SIG_ERR);
 230                 return (sig_t)oact.sa_handler;
 231         } else {
 232                 if (blocked) {
 233                         if (-1 == sigrelse(sig))
 234                                 return (SIG_ERR);
 235                 }
 236                 sig_t rv = signal(sig, disp);
 237                 if (rv != SIG_ERR)
 238                         return blocked ? SIG_HOLD : rv;
 239                 else
 240                         return (rv);
 241         }
 242 }
 243 #endif /* !BUILDING_VARIANT */