Commit | Line | Data |
---|---|---|
2a84b02d | 1 | /* POSIX compatible signal blocking. |
caf8a9b2 | 2 | Copyright (C) 2006-2012 Free Software Foundation, Inc. |
2a84b02d PE |
3 | Written by Bruno Haible <bruno@clisp.org>, 2006. |
4 | ||
5 | This program is free software: you can redistribute it and/or modify | |
6 | it under the terms of the GNU General Public License as published by | |
7 | the Free Software Foundation; either version 3 of the License, or | |
8 | (at your option) any later version. | |
9 | ||
10 | This program is distributed in the hope that it will be useful, | |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | GNU General Public License for more details. | |
14 | ||
15 | You should have received a copy of the GNU General Public License | |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ | |
17 | ||
18 | #include <config.h> | |
19 | ||
20 | /* Specification. */ | |
21 | #include <signal.h> | |
22 | ||
23 | #include <errno.h> | |
24 | #include <stdint.h> | |
25 | #include <stdlib.h> | |
26 | ||
316f8af0 PE |
27 | #if HAVE_MSVC_INVALID_PARAMETER_HANDLER |
28 | # include "msvc-inval.h" | |
29 | #endif | |
30 | ||
2a84b02d PE |
31 | /* We assume that a platform without POSIX signal blocking functions |
32 | also does not have the POSIX sigaction() function, only the | |
33 | signal() function. We also assume signal() has SysV semantics, | |
34 | where any handler is uninstalled prior to being invoked. This is | |
caf8a9b2 | 35 | true for native Windows platforms. */ |
2a84b02d PE |
36 | |
37 | /* We use raw signal(), but also provide a wrapper rpl_signal() so | |
38 | that applications can query or change a blocked signal. */ | |
39 | #undef signal | |
40 | ||
41 | /* Provide invalid signal numbers as fallbacks if the uncatchable | |
42 | signals are not defined. */ | |
43 | #ifndef SIGKILL | |
44 | # define SIGKILL (-1) | |
45 | #endif | |
46 | #ifndef SIGSTOP | |
47 | # define SIGSTOP (-1) | |
48 | #endif | |
49 | ||
50 | /* On native Windows, as of 2008, the signal SIGABRT_COMPAT is an alias | |
51 | for the signal SIGABRT. Only one signal handler is stored for both | |
52 | SIGABRT and SIGABRT_COMPAT. SIGABRT_COMPAT is not a signal of its own. */ | |
53 | #if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__ | |
54 | # undef SIGABRT_COMPAT | |
55 | # define SIGABRT_COMPAT 6 | |
56 | #endif | |
57 | #ifdef SIGABRT_COMPAT | |
58 | # define SIGABRT_COMPAT_MASK (1U << SIGABRT_COMPAT) | |
59 | #else | |
60 | # define SIGABRT_COMPAT_MASK 0 | |
61 | #endif | |
62 | ||
63 | typedef void (*handler_t) (int); | |
64 | ||
316f8af0 PE |
65 | #if HAVE_MSVC_INVALID_PARAMETER_HANDLER |
66 | static inline handler_t | |
67 | signal_nothrow (int sig, handler_t handler) | |
68 | { | |
69 | handler_t result; | |
70 | ||
71 | TRY_MSVC_INVAL | |
72 | { | |
73 | result = signal (sig, handler); | |
74 | } | |
75 | CATCH_MSVC_INVAL | |
76 | { | |
77 | result = SIG_ERR; | |
78 | errno = EINVAL; | |
79 | } | |
80 | DONE_MSVC_INVAL; | |
81 | ||
82 | return result; | |
83 | } | |
84 | # define signal signal_nothrow | |
85 | #endif | |
86 | ||
2a84b02d PE |
87 | /* Handling of gnulib defined signals. */ |
88 | ||
89 | #if GNULIB_defined_SIGPIPE | |
90 | static handler_t SIGPIPE_handler = SIG_DFL; | |
91 | #endif | |
92 | ||
93 | #if GNULIB_defined_SIGPIPE | |
94 | static handler_t | |
95 | ext_signal (int sig, handler_t handler) | |
96 | { | |
97 | switch (sig) | |
98 | { | |
99 | case SIGPIPE: | |
100 | { | |
101 | handler_t old_handler = SIGPIPE_handler; | |
102 | SIGPIPE_handler = handler; | |
103 | return old_handler; | |
104 | } | |
105 | default: /* System defined signal */ | |
106 | return signal (sig, handler); | |
107 | } | |
108 | } | |
316f8af0 | 109 | # undef signal |
2a84b02d PE |
110 | # define signal ext_signal |
111 | #endif | |
112 | ||
113 | int | |
114 | sigismember (const sigset_t *set, int sig) | |
115 | { | |
116 | if (sig >= 0 && sig < NSIG) | |
117 | { | |
118 | #ifdef SIGABRT_COMPAT | |
119 | if (sig == SIGABRT_COMPAT) | |
120 | sig = SIGABRT; | |
121 | #endif | |
122 | ||
123 | return (*set >> sig) & 1; | |
124 | } | |
125 | else | |
126 | return 0; | |
127 | } | |
128 | ||
129 | int | |
130 | sigemptyset (sigset_t *set) | |
131 | { | |
132 | *set = 0; | |
133 | return 0; | |
134 | } | |
135 | ||
136 | int | |
137 | sigaddset (sigset_t *set, int sig) | |
138 | { | |
139 | if (sig >= 0 && sig < NSIG) | |
140 | { | |
141 | #ifdef SIGABRT_COMPAT | |
142 | if (sig == SIGABRT_COMPAT) | |
143 | sig = SIGABRT; | |
144 | #endif | |
145 | ||
146 | *set |= 1U << sig; | |
147 | return 0; | |
148 | } | |
149 | else | |
150 | { | |
151 | errno = EINVAL; | |
152 | return -1; | |
153 | } | |
154 | } | |
155 | ||
156 | int | |
157 | sigdelset (sigset_t *set, int sig) | |
158 | { | |
159 | if (sig >= 0 && sig < NSIG) | |
160 | { | |
161 | #ifdef SIGABRT_COMPAT | |
162 | if (sig == SIGABRT_COMPAT) | |
163 | sig = SIGABRT; | |
164 | #endif | |
165 | ||
166 | *set &= ~(1U << sig); | |
167 | return 0; | |
168 | } | |
169 | else | |
170 | { | |
171 | errno = EINVAL; | |
172 | return -1; | |
173 | } | |
174 | } | |
175 | ||
176 | ||
177 | int | |
178 | sigfillset (sigset_t *set) | |
179 | { | |
180 | *set = ((2U << (NSIG - 1)) - 1) & ~ SIGABRT_COMPAT_MASK; | |
181 | return 0; | |
182 | } | |
183 | ||
184 | /* Set of currently blocked signals. */ | |
185 | static volatile sigset_t blocked_set /* = 0 */; | |
186 | ||
187 | /* Set of currently blocked and pending signals. */ | |
188 | static volatile sig_atomic_t pending_array[NSIG] /* = { 0 } */; | |
189 | ||
190 | /* Signal handler that is installed for blocked signals. */ | |
191 | static void | |
192 | blocked_handler (int sig) | |
193 | { | |
194 | /* Reinstall the handler, in case the signal occurs multiple times | |
195 | while blocked. There is an inherent race where an asynchronous | |
196 | signal in between when the kernel uninstalled the handler and | |
197 | when we reinstall it will trigger the default handler; oh | |
198 | well. */ | |
199 | signal (sig, blocked_handler); | |
200 | if (sig >= 0 && sig < NSIG) | |
201 | pending_array[sig] = 1; | |
202 | } | |
203 | ||
204 | int | |
205 | sigpending (sigset_t *set) | |
206 | { | |
207 | sigset_t pending = 0; | |
208 | int sig; | |
209 | ||
210 | for (sig = 0; sig < NSIG; sig++) | |
211 | if (pending_array[sig]) | |
212 | pending |= 1U << sig; | |
213 | *set = pending; | |
214 | return 0; | |
215 | } | |
216 | ||
217 | /* The previous signal handlers. | |
218 | Only the array elements corresponding to blocked signals are relevant. */ | |
219 | static volatile handler_t old_handlers[NSIG]; | |
220 | ||
221 | int | |
222 | sigprocmask (int operation, const sigset_t *set, sigset_t *old_set) | |
223 | { | |
224 | if (old_set != NULL) | |
225 | *old_set = blocked_set; | |
226 | ||
227 | if (set != NULL) | |
228 | { | |
229 | sigset_t new_blocked_set; | |
230 | sigset_t to_unblock; | |
231 | sigset_t to_block; | |
232 | ||
233 | switch (operation) | |
234 | { | |
235 | case SIG_BLOCK: | |
236 | new_blocked_set = blocked_set | *set; | |
237 | break; | |
238 | case SIG_SETMASK: | |
239 | new_blocked_set = *set; | |
240 | break; | |
241 | case SIG_UNBLOCK: | |
242 | new_blocked_set = blocked_set & ~*set; | |
243 | break; | |
244 | default: | |
245 | errno = EINVAL; | |
246 | return -1; | |
247 | } | |
248 | to_unblock = blocked_set & ~new_blocked_set; | |
249 | to_block = new_blocked_set & ~blocked_set; | |
250 | ||
251 | if (to_block != 0) | |
252 | { | |
253 | int sig; | |
254 | ||
255 | for (sig = 0; sig < NSIG; sig++) | |
256 | if ((to_block >> sig) & 1) | |
257 | { | |
258 | pending_array[sig] = 0; | |
259 | if ((old_handlers[sig] = signal (sig, blocked_handler)) != SIG_ERR) | |
260 | blocked_set |= 1U << sig; | |
261 | } | |
262 | } | |
263 | ||
264 | if (to_unblock != 0) | |
265 | { | |
266 | sig_atomic_t received[NSIG]; | |
267 | int sig; | |
268 | ||
269 | for (sig = 0; sig < NSIG; sig++) | |
270 | if ((to_unblock >> sig) & 1) | |
271 | { | |
272 | if (signal (sig, old_handlers[sig]) != blocked_handler) | |
273 | /* The application changed a signal handler while the signal | |
274 | was blocked, bypassing our rpl_signal replacement. | |
275 | We don't support this. */ | |
276 | abort (); | |
277 | received[sig] = pending_array[sig]; | |
278 | blocked_set &= ~(1U << sig); | |
279 | pending_array[sig] = 0; | |
280 | } | |
281 | else | |
282 | received[sig] = 0; | |
283 | ||
284 | for (sig = 0; sig < NSIG; sig++) | |
285 | if (received[sig]) | |
286 | raise (sig); | |
287 | } | |
288 | } | |
289 | return 0; | |
290 | } | |
291 | ||
292 | /* Install the handler FUNC for signal SIG, and return the previous | |
293 | handler. */ | |
294 | handler_t | |
295 | rpl_signal (int sig, handler_t handler) | |
296 | { | |
297 | /* We must provide a wrapper, so that a user can query what handler | |
298 | they installed even if that signal is currently blocked. */ | |
299 | if (sig >= 0 && sig < NSIG && sig != SIGKILL && sig != SIGSTOP | |
300 | && handler != SIG_ERR) | |
301 | { | |
302 | #ifdef SIGABRT_COMPAT | |
303 | if (sig == SIGABRT_COMPAT) | |
304 | sig = SIGABRT; | |
305 | #endif | |
306 | ||
307 | if (blocked_set & (1U << sig)) | |
308 | { | |
309 | /* POSIX states that sigprocmask and signal are both | |
310 | async-signal-safe. This is not true of our | |
311 | implementation - there is a slight data race where an | |
312 | asynchronous interrupt on signal A can occur after we | |
313 | install blocked_handler but before we have updated | |
314 | old_handlers for signal B, such that handler A can see | |
315 | stale information if it calls signal(B). Oh well - | |
316 | signal handlers really shouldn't try to manipulate the | |
317 | installed handlers of unrelated signals. */ | |
318 | handler_t result = old_handlers[sig]; | |
319 | old_handlers[sig] = handler; | |
320 | return result; | |
321 | } | |
322 | else | |
323 | return signal (sig, handler); | |
324 | } | |
325 | else | |
326 | { | |
327 | errno = EINVAL; | |
328 | return SIG_ERR; | |
329 | } | |
330 | } | |
331 | ||
332 | #if GNULIB_defined_SIGPIPE | |
d47439a3 | 333 | /* Raise the signal SIGPIPE. */ |
2a84b02d | 334 | int |
d47439a3 | 335 | _gl_raise_SIGPIPE (void) |
2a84b02d | 336 | { |
d47439a3 PE |
337 | if (blocked_set & (1U << SIGPIPE)) |
338 | pending_array[SIGPIPE] = 1; | |
339 | else | |
2a84b02d | 340 | { |
d47439a3 PE |
341 | handler_t handler = SIGPIPE_handler; |
342 | if (handler == SIG_DFL) | |
343 | exit (128 + SIGPIPE); | |
344 | else if (handler != SIG_IGN) | |
345 | (*handler) (SIGPIPE); | |
2a84b02d | 346 | } |
caf8a9b2 | 347 | return 0; |
2a84b02d PE |
348 | } |
349 | #endif |