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