1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 1989, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #if defined(LIBC_SCCS) && !defined(lint) 33 static char sccsid[] = "@(#)sigcompat.c 8.1 (Berkeley) 6/2/93"; 34 #endif /* LIBC_SCCS and not lint */ 35 #include <sys/cdefs.h> 36 __FBSDID("$FreeBSD$"); 37 38 #include "namespace.h" 39 #include <sys/param.h> 40 #include <errno.h> 41 #include <signal.h> 42 #include <string.h> 43 #include "un-namespace.h" 44 #include "libc_private.h" 45 46 int 47 sigvec(int signo, struct sigvec *sv, struct sigvec *osv) 48 { 49 struct sigaction sa, osa; 50 struct sigaction *sap, *osap; 51 int ret; 52 53 if (sv != NULL) { 54 sa.sa_handler = sv->sv_handler; 55 sa.sa_flags = sv->sv_flags ^ SV_INTERRUPT; 56 sigemptyset(&sa.sa_mask); 57 sa.sa_mask.__bits[0] = sv->sv_mask; 58 sap = &sa; 59 } else 60 sap = NULL; 61 osap = osv != NULL ? &osa : NULL; 62 ret = __libc_sigaction(signo, sap, osap); 63 if (ret == 0 && osv != NULL) { 64 osv->sv_handler = osa.sa_handler; 65 osv->sv_flags = osa.sa_flags ^ SV_INTERRUPT; 66 osv->sv_mask = osa.sa_mask.__bits[0]; 67 } 68 return (ret); 69 } 70 71 int 72 sigsetmask(int mask) 73 { 74 sigset_t set, oset; 75 int n; 76 77 sigemptyset(&set); 78 set.__bits[0] = mask; 79 n = __libc_sigprocmask(SIG_SETMASK, &set, &oset); 80 if (n) 81 return (n); 82 return (oset.__bits[0]); 83 } 84 85 int 86 sigblock(int mask) 87 { 88 sigset_t set, oset; 89 int n; 90 91 sigemptyset(&set); 92 set.__bits[0] = mask; 93 n = __libc_sigprocmask(SIG_BLOCK, &set, &oset); 94 if (n) 95 return (n); 96 return (oset.__bits[0]); 97 } 98 99 int 100 sigpause(int mask) 101 { 102 sigset_t set; 103 104 sigemptyset(&set); 105 set.__bits[0] = mask; 106 return (__libc_sigsuspend(&set)); 107 } 108 109 int 110 xsi_sigpause(int sig) 111 { 112 sigset_t set; 113 114 if (__libc_sigprocmask(SIG_BLOCK, NULL, &set) == -1) 115 return (-1); 116 if (sigdelset(&set, sig) == -1) 117 return (-1); 118 return (__libc_sigsuspend(&set)); 119 } 120 121 int 122 sighold(int sig) 123 { 124 sigset_t set; 125 126 sigemptyset(&set); 127 if (sigaddset(&set, sig) == -1) 128 return (-1); 129 return (__libc_sigprocmask(SIG_BLOCK, &set, NULL)); 130 } 131 132 int 133 sigignore(int sig) 134 { 135 struct sigaction sa; 136 137 bzero(&sa, sizeof(sa)); 138 sa.sa_handler = SIG_IGN; 139 return (__libc_sigaction(sig, &sa, NULL)); 140 } 141 142 int 143 sigrelse(int sig) 144 { 145 sigset_t set; 146 147 sigemptyset(&set); 148 if (sigaddset(&set, sig) == -1) 149 return (-1); 150 return (__libc_sigprocmask(SIG_UNBLOCK, &set, NULL)); 151 } 152 153 void 154 (*sigset(int sig, void (*disp)(int)))(int) 155 { 156 sigset_t set, pset; 157 struct sigaction sa, psa; 158 159 sigemptyset(&set); 160 if (sigaddset(&set, sig) == -1) 161 return (SIG_ERR); 162 if (__libc_sigprocmask(SIG_BLOCK, NULL, &pset) == -1) 163 return (SIG_ERR); 164 if ((__sighandler_t *)disp == SIG_HOLD) { 165 if (__libc_sigprocmask(SIG_BLOCK, &set, &pset) == -1) 166 return (SIG_ERR); 167 if (sigismember(&pset, sig)) 168 return (SIG_HOLD); 169 else { 170 if (__libc_sigaction(sig, NULL, &psa) == -1) 171 return (SIG_ERR); 172 return (psa.sa_handler); 173 } 174 } else { 175 if (__libc_sigprocmask(SIG_UNBLOCK, &set, &pset) == -1) 176 return (SIG_ERR); 177 } 178 179 bzero(&sa, sizeof(sa)); 180 sa.sa_handler = disp; 181 if (__libc_sigaction(sig, &sa, &psa) == -1) 182 return (SIG_ERR); 183 if (sigismember(&pset, sig)) 184 return (SIG_HOLD); 185 else 186 return (psa.sa_handler); 187 } 188