chiark / gitweb /
Prep v233: Unmask now needed functions in src/basic
[elogind.git] / src / basic / signal-util.c
1 /***
2   This file is part of systemd.
3
4   Copyright 2015 Lennart Poettering
5
6   systemd is free software; you can redistribute it and/or modify it
7   under the terms of the GNU Lesser General Public License as published by
8   the Free Software Foundation; either version 2.1 of the License, or
9   (at your option) any later version.
10
11   systemd is distributed in the hope that it will be useful, but
12   WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14   Lesser General Public License for more details.
15
16   You should have received a copy of the GNU Lesser General Public License
17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
18 ***/
19
20 #include <errno.h>
21 #include <stdarg.h>
22 #include <stdio.h>
23
24 #include "macro.h"
25 #include "parse-util.h"
26 #include "signal-util.h"
27 #include "stdio-util.h"
28 #include "string-table.h"
29 #include "string-util.h"
30
31 int reset_all_signal_handlers(void) {
32         static const struct sigaction sa = {
33                 .sa_handler = SIG_DFL,
34                 .sa_flags = SA_RESTART,
35         };
36         int sig, r = 0;
37
38         for (sig = 1; sig < _NSIG; sig++) {
39
40                 /* These two cannot be caught... */
41                 if (sig == SIGKILL || sig == SIGSTOP)
42                         continue;
43
44                 /* On Linux the first two RT signals are reserved by
45                  * glibc, and sigaction() will return EINVAL for them. */
46                 if ((sigaction(sig, &sa, NULL) < 0))
47                         if (errno != EINVAL && r >= 0)
48                                 r = -errno;
49         }
50
51         return r;
52 }
53
54 int reset_signal_mask(void) {
55         sigset_t ss;
56
57         if (sigemptyset(&ss) < 0)
58                 return -errno;
59
60         if (sigprocmask(SIG_SETMASK, &ss, NULL) < 0)
61                 return -errno;
62
63         return 0;
64 }
65
66 static int sigaction_many_ap(const struct sigaction *sa, int sig, va_list ap) {
67         int r = 0;
68
69         /* negative signal ends the list. 0 signal is skipped. */
70
71         if (sig < 0)
72                 return 0;
73
74         if (sig > 0) {
75                 if (sigaction(sig, sa, NULL) < 0)
76                         r = -errno;
77         }
78
79         while ((sig = va_arg(ap, int)) >= 0) {
80
81                 if (sig == 0)
82                         continue;
83
84                 if (sigaction(sig, sa, NULL) < 0) {
85                         if (r >= 0)
86                                 r = -errno;
87                 }
88         }
89
90         return r;
91 }
92
93 #if 0 /// UNNEEDED by elogind
94 int sigaction_many(const struct sigaction *sa, ...) {
95         va_list ap;
96         int r;
97
98         va_start(ap, sa);
99         r = sigaction_many_ap(sa, 0, ap);
100         va_end(ap);
101
102         return r;
103 }
104 #endif // 0
105
106 int ignore_signals(int sig, ...) {
107
108         static const struct sigaction sa = {
109                 .sa_handler = SIG_IGN,
110                 .sa_flags = SA_RESTART,
111         };
112
113         va_list ap;
114         int r;
115
116         va_start(ap, sig);
117         r = sigaction_many_ap(&sa, sig, ap);
118         va_end(ap);
119
120         return r;
121 }
122
123 #if 0 /// UNNEEDED by elogind
124 int default_signals(int sig, ...) {
125
126         static const struct sigaction sa = {
127                 .sa_handler = SIG_DFL,
128                 .sa_flags = SA_RESTART,
129         };
130
131         va_list ap;
132         int r;
133
134         va_start(ap, sig);
135         r = sigaction_many_ap(&sa, sig, ap);
136         va_end(ap);
137
138         return r;
139 }
140 #endif // 0
141
142 static int sigset_add_many_ap(sigset_t *ss, va_list ap) {
143         int sig, r = 0;
144
145         assert(ss);
146
147         while ((sig = va_arg(ap, int)) >= 0) {
148
149                 if (sig == 0)
150                         continue;
151
152                 if (sigaddset(ss, sig) < 0) {
153                         if (r >= 0)
154                                 r = -errno;
155                 }
156         }
157
158         return r;
159 }
160
161 int sigset_add_many(sigset_t *ss, ...) {
162         va_list ap;
163         int r;
164
165         va_start(ap, ss);
166         r = sigset_add_many_ap(ss, ap);
167         va_end(ap);
168
169         return r;
170 }
171
172 int sigprocmask_many(int how, sigset_t *old, ...) {
173         va_list ap;
174         sigset_t ss;
175         int r;
176
177         if (sigemptyset(&ss) < 0)
178                 return -errno;
179
180         va_start(ap, old);
181         r = sigset_add_many_ap(&ss, ap);
182         va_end(ap);
183
184         if (r < 0)
185                 return r;
186
187         if (sigprocmask(how, &ss, old) < 0)
188                 return -errno;
189
190         return 0;
191 }
192
193 static const char *const __signal_table[] = {
194         [SIGHUP] = "HUP",
195         [SIGINT] = "INT",
196         [SIGQUIT] = "QUIT",
197         [SIGILL] = "ILL",
198         [SIGTRAP] = "TRAP",
199         [SIGABRT] = "ABRT",
200         [SIGBUS] = "BUS",
201         [SIGFPE] = "FPE",
202         [SIGKILL] = "KILL",
203         [SIGUSR1] = "USR1",
204         [SIGSEGV] = "SEGV",
205         [SIGUSR2] = "USR2",
206         [SIGPIPE] = "PIPE",
207         [SIGALRM] = "ALRM",
208         [SIGTERM] = "TERM",
209 #ifdef SIGSTKFLT
210         [SIGSTKFLT] = "STKFLT",  /* Linux on SPARC doesn't know SIGSTKFLT */
211 #endif
212         [SIGCHLD] = "CHLD",
213         [SIGCONT] = "CONT",
214         [SIGSTOP] = "STOP",
215         [SIGTSTP] = "TSTP",
216         [SIGTTIN] = "TTIN",
217         [SIGTTOU] = "TTOU",
218         [SIGURG] = "URG",
219         [SIGXCPU] = "XCPU",
220         [SIGXFSZ] = "XFSZ",
221         [SIGVTALRM] = "VTALRM",
222         [SIGPROF] = "PROF",
223         [SIGWINCH] = "WINCH",
224         [SIGIO] = "IO",
225         [SIGPWR] = "PWR",
226         [SIGSYS] = "SYS"
227 };
228
229 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(__signal, int);
230
231 const char *signal_to_string(int signo) {
232         static thread_local char buf[sizeof("RTMIN+")-1 + DECIMAL_STR_MAX(int) + 1];
233         const char *name;
234
235         name = __signal_to_string(signo);
236         if (name)
237                 return name;
238
239         if (signo >= SIGRTMIN && signo <= SIGRTMAX)
240                 xsprintf(buf, "RTMIN+%d", signo - SIGRTMIN);
241         else
242                 xsprintf(buf, "%d", signo);
243
244         return buf;
245 }
246
247 int signal_from_string(const char *s) {
248         int signo;
249         int offset = 0;
250         unsigned u;
251
252         signo = __signal_from_string(s);
253         if (signo > 0)
254                 return signo;
255
256         if (startswith(s, "RTMIN+")) {
257                 s += 6;
258                 offset = SIGRTMIN;
259         }
260         if (safe_atou(s, &u) >= 0) {
261                 signo = (int) u + offset;
262                 if (SIGNAL_VALID(signo))
263                         return signo;
264         }
265         return -EINVAL;
266 }
267
268 int signal_from_string_try_harder(const char *s) {
269         int signo;
270         assert(s);
271
272         signo = signal_from_string(s);
273         if (signo <= 0)
274                 if (startswith(s, "SIG"))
275                         return signal_from_string(s+3);
276
277         return signo;
278 }
279
280 #if 0 /// UNNEEDED by elogind
281 void nop_signal_handler(int sig) {
282         /* nothing here */
283 }
284 #endif // 0