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 int default_signals(int sig, ...) {
 124
 125         static const struct sigaction sa = {
 126                 .sa_handler = SIG_DFL,
 127                 .sa_flags = SA_RESTART,
 128         };
 129
 130         va_list ap;
 131         int r;
 132
 133         va_start(ap, sig);
 134         r = sigaction_many_ap(&sa, sig, ap);
 135         va_end(ap);
 136
 137         return r;
 138 }
 139
 140 static int sigset_add_many_ap(sigset_t *ss, va_list ap) {
 141         int sig, r = 0;
 142
 143         assert(ss);
 144
 145         while ((sig = va_arg(ap, int)) >= 0) {
 146
 147                 if (sig == 0)
 148                         continue;
 149
 150                 if (sigaddset(ss, sig) < 0) {
 151                         if (r >= 0)
 152                                 r = -errno;
 153                 }
 154         }
 155
 156         return r;
 157 }
 158
 159 int sigset_add_many(sigset_t *ss, ...) {
 160         va_list ap;
 161         int r;
 162
 163         va_start(ap, ss);
 164         r = sigset_add_many_ap(ss, ap);
 165         va_end(ap);
 166
 167         return r;
 168 }
 169
 170 int sigprocmask_many(int how, sigset_t *old, ...) {
 171         va_list ap;
 172         sigset_t ss;
 173         int r;
 174
 175         if (sigemptyset(&ss) < 0)
 176                 return -errno;
 177
 178         va_start(ap, old);
 179         r = sigset_add_many_ap(&ss, ap);
 180         va_end(ap);
 181
 182         if (r < 0)
 183                 return r;
 184
 185         if (sigprocmask(how, &ss, old) < 0)
 186                 return -errno;
 187
 188         return 0;
 189 }
 190
 191 static const char *const __signal_table[] = {
 192         [SIGHUP] = "HUP",
 193         [SIGINT] = "INT",
 194         [SIGQUIT] = "QUIT",
 195         [SIGILL] = "ILL",
 196         [SIGTRAP] = "TRAP",
 197         [SIGABRT] = "ABRT",
 198         [SIGBUS] = "BUS",
 199         [SIGFPE] = "FPE",
 200         [SIGKILL] = "KILL",
 201         [SIGUSR1] = "USR1",
 202         [SIGSEGV] = "SEGV",
 203         [SIGUSR2] = "USR2",
 204         [SIGPIPE] = "PIPE",
 205         [SIGALRM] = "ALRM",
 206         [SIGTERM] = "TERM",
 207 #ifdef SIGSTKFLT
 208         [SIGSTKFLT] = "STKFLT",  /* Linux on SPARC doesn't know SIGSTKFLT */
 209 #endif
 210         [SIGCHLD] = "CHLD",
 211         [SIGCONT] = "CONT",
 212         [SIGSTOP] = "STOP",
 213         [SIGTSTP] = "TSTP",
 214         [SIGTTIN] = "TTIN",
 215         [SIGTTOU] = "TTOU",
 216         [SIGURG] = "URG",
 217         [SIGXCPU] = "XCPU",
 218         [SIGXFSZ] = "XFSZ",
 219         [SIGVTALRM] = "VTALRM",
 220         [SIGPROF] = "PROF",
 221         [SIGWINCH] = "WINCH",
 222         [SIGIO] = "IO",
 223         [SIGPWR] = "PWR",
 224         [SIGSYS] = "SYS"
 225 };
 226
 227 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(__signal, int);
 228
 229 const char *signal_to_string(int signo) {
 230         static thread_local char buf[sizeof("RTMIN+")-1 + DECIMAL_STR_MAX(int) + 1];
 231         const char *name;
 232
 233         name = __signal_to_string(signo);
 234         if (name)
 235                 return name;
 236
 237         if (signo >= SIGRTMIN && signo <= SIGRTMAX)
 238                 xsprintf(buf, "RTMIN+%d", signo - SIGRTMIN);
 239         else
 240                 xsprintf(buf, "%d", signo);
 241
 242         return buf;
 243 }
 244
 245 int signal_from_string(const char *s) {
 246         int signo;
 247         int offset = 0;
 248         unsigned u;
 249
 250         signo = __signal_from_string(s);
 251         if (signo > 0)
 252                 return signo;
 253
 254         if (startswith(s, "RTMIN+")) {
 255                 s += 6;
 256                 offset = SIGRTMIN;
 257         }
 258         if (safe_atou(s, &u) >= 0) {
 259                 signo = (int) u + offset;
 260                 if (SIGNAL_VALID(signo))
 261                         return signo;
 262         }
 263         return -EINVAL;
 264 }
 265
 266 int signal_from_string_try_harder(const char *s) {
 267         int signo;
 268         assert(s);
 269
 270         signo = signal_from_string(s);
 271         if (signo <= 0)
 272                 if (startswith(s, "SIG"))
 273                         return signal_from_string(s+3);
 274
 275         return signo;
 276 }
 277
 278 #if 0 /// UNNEEDED by elogind
 279 void nop_signal_handler(int sig) {
 280         /* nothing here */
 281 }
 282 #endif // 0