signal.c

   1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
   2  *@ Signal related stuff as well as NotYetDead functions.
   3  *
   4  * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
   5  * Copyright (c) 2012 - 2016 Steffen (Daode) Nurpmeso <steffen@sdaoden.eu>.
   6  */
   7 /*
   8  * Copyright (c) 1980, 1993
   9  *      The Regents of the University of California.  All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35 #undef n_FILE
  36 #define n_FILE signal
  37
  38 #ifndef HAVE_AMALGAMATION
  39 # include "nail.h"
  40 #endif
  41
  42 /*
  43  * TODO At the beginning of November 2015 -- for v14.9 -- i've tried for one
  44  * TODO and a half week to convert this codebase to SysV style signal handling,
  45  * TODO meaning no SA_RESTART and EINTR in a lot of places and error reporting
  46  * TODO up the chain.   I failed miserably, not only because S/MIME / SSL but
  47  * TODO also because of general frustration.  Directly after v14.9 i will strip
  48  * TODO ANYTHING off the codebase (socket stuff etc.) and keep only the very
  49  * TODO core, doing namespace and type cleanup and convert this core to a clean
  50  * TODO approach, from which i plan to start this thing anew.
  51  * TODO For now i introduced the n_sigman, yet another hack, to be used in a
  52  * TODO few places.
  53  * TODO The real solution:
  54  * TODO - No SA_RESTART.  Just like for my C++ library: encapsulate EINTR in
  55  * TODO   userspace at the systemcall (I/O rewrite: drop stdio), normal
  56  * TODO   interface auto-restarts, special _intr() series return EINTR.
  57  * TODO   Do n_sigman_poll()/peek()/whatever whenever desired for the former,
  58  * TODO   report errors up the call chain, have places where operations can be
  59  * TODO   "properly" aborted.
  60  * TODO - We save the initial signal settings upon program startup.
  61  * TODO - We register our sigman handlers once, at program startup.
  62  * TODO   Maximally, and most likely only due to lack of atomic CAS, ignore
  63  * TODO   or block some signals temporarily.  Best if not.
  64  * TODO   The signal handlers only set a flag.  Block all signals for handler
  65  * TODO   execution, like this we are safe to "set the first signal was x".
  66  * TODO - In interactive context, ignore SIGTERM.
  67  * TODO   I.e., see the POSIX standard for what a shell does.
  68  * TODO - In non-interactive context, don't know anything about job control!?!
  69  * TODO - Place child processes in their own process group.  Restore the signal
  70  * TODO   mask back to the saved original one for them, before exec.
  71  * TODO - Except for job control related (<-> interactive) ignore any signals
  72  * TODO   while we are "behind" a child that occupies the terminal.  For those,
  73  * TODO   perform proper terminal attribute handling.  For childs that don't
  74  * TODO   occupy the terminal we "are the shell" and should therefore manage
  75  * TODO   them accordingly, including termination request as necessary.
  76  * TODO   And if we have a worker in a pipeline, we need to manage it and deal
  77  * TODO   with it properly, WITHOUT temporary signal overwrites.
  78  * TODO - No more jumps.
  79  * TODO - (When sockets will be reintroduced, non-blocking.)
  80  * TODO - (When SSL is reintroduced, memory BIO.  It MAY be necessary to
  81  * TODO   temporarily block signals during a few SSL functions?  Read SSL docu!
  82  * TODO   But i prefer blocking since it's a single syscall, not temporary
  83  * TODO   SA_RESTART setting, since that has to be done for every signal.)
  84  */
  85
  86 #ifdef HAVE_NYD
  87 struct nyd_info {
  88    char const  *ni_file;
  89    char const  *ni_fun;
  90    ui32_t      ni_chirp_line;
  91    ui32_t      ni_level;
  92 };
  93 #endif
  94
  95 /* {hold,rele}_all_sigs() */
  96 static size_t           _alls_depth;
  97 static sigset_t         _alls_nset, _alls_oset;
  98
  99 /* {hold,rele}_sigs() */
 100 static size_t           _hold_sigdepth;
 101 static sigset_t         _hold_nset, _hold_oset;
 102
 103 /* NYD, memory pool debug */
 104 #ifdef HAVE_NYD
 105 static ui32_t           _nyd_curr, _nyd_level;
 106 static struct nyd_info  _nyd_infos[NYD_CALLS_MAX];
 107 #endif
 108
 109 /* */
 110 #ifdef HAVE_NYD
 111 static void    _nyd_print(int fd, struct nyd_info *nip);
 112 #endif
 113
 114 #ifdef HAVE_NYD
 115 static void
 116 _nyd_print(int fd, struct nyd_info *nip)
 117 {
 118    char buf[80];
 119    union {int i; size_t z;} u;
 120
 121    u.i = snprintf(buf, sizeof buf,
 122          "%c [%2" PRIu32 "] %.25s (%.16s:%" PRIu32 ")\n",
 123          "=><"[(nip->ni_chirp_line >> 29) & 0x3], nip->ni_level, nip->ni_fun,
 124          nip->ni_file, (nip->ni_chirp_line & 0x1FFFFFFFu));
 125    if (u.i > 0) {
 126       u.z = u.i;
 127       if (u.z > sizeof buf)
 128          u.z = sizeof buf - 1; /* (Skip \0) */
 129       write(fd, buf, u.z);
 130    }
 131 }
 132 #endif
 133
 134 FL void
 135 n_raise(int signo)
 136 {
 137    NYD2_ENTER;
 138    kill(getpid(), signo);
 139    NYD2_LEAVE;
 140 }
 141
 142 FL sighandler_type
 143 safe_signal(int signum, sighandler_type handler)
 144 {
 145    struct sigaction nact, oact;
 146    sighandler_type rv;
 147    NYD2_ENTER;
 148
 149    nact.sa_handler = handler;
 150    sigemptyset(&nact.sa_mask);
 151    nact.sa_flags = SA_RESTART;
 152    rv = (sigaction(signum, &nact, &oact) != 0) ? SIG_ERR : oact.sa_handler;
 153    NYD2_LEAVE;
 154    return rv;
 155 }
 156
 157 FL n_sighdl_t
 158 n_signal(int signo, n_sighdl_t hdl){
 159    struct sigaction nact, oact;
 160    NYD2_ENTER;
 161
 162    nact.sa_handler = hdl;
 163    sigemptyset(&nact.sa_mask);
 164    nact.sa_flags = 0;
 165    hdl = (sigaction(signo, &nact, &oact) != 0) ? SIG_ERR : oact.sa_handler;
 166    NYD2_LEAVE;
 167    return hdl;
 168 }
 169
 170 FL void
 171 hold_all_sigs(void)
 172 {
 173    NYD2_ENTER;
 174    if (_alls_depth++ == 0) {
 175       sigfillset(&_alls_nset);
 176       sigdelset(&_alls_nset, SIGABRT);
 177 #ifdef SIGBUS
 178       sigdelset(&_alls_nset, SIGBUS);
 179 #endif
 180       sigdelset(&_alls_nset, SIGCHLD);
 181       sigdelset(&_alls_nset, SIGFPE);
 182       sigdelset(&_alls_nset, SIGILL);
 183       sigdelset(&_alls_nset, SIGKILL);
 184       sigdelset(&_alls_nset, SIGSEGV);
 185       sigdelset(&_alls_nset, SIGSTOP);
 186       sigprocmask(SIG_BLOCK, &_alls_nset, &_alls_oset);
 187    }
 188    NYD2_LEAVE;
 189 }
 190
 191 FL void
 192 rele_all_sigs(void)
 193 {
 194    NYD2_ENTER;
 195    if (--_alls_depth == 0)
 196       sigprocmask(SIG_SETMASK, &_alls_oset, (sigset_t*)NULL);
 197    NYD2_LEAVE;
 198 }
 199
 200 FL void
 201 hold_sigs(void)
 202 {
 203    NYD2_ENTER;
 204    if (_hold_sigdepth++ == 0) {
 205       sigemptyset(&_hold_nset);
 206       sigaddset(&_hold_nset, SIGHUP);
 207       sigaddset(&_hold_nset, SIGINT);
 208       sigaddset(&_hold_nset, SIGQUIT);
 209       sigprocmask(SIG_BLOCK, &_hold_nset, &_hold_oset);
 210    }
 211    NYD2_LEAVE;
 212 }
 213
 214 FL void
 215 rele_sigs(void)
 216 {
 217    NYD2_ENTER;
 218    if (--_hold_sigdepth == 0)
 219       sigprocmask(SIG_SETMASK, &_hold_oset, NULL);
 220    NYD2_LEAVE;
 221 }
 222
 223 /* TODO This is temporary gracyness */
 224 static struct n_sigman *n__sigman;
 225 static void n__sigman_hdl(int signo);
 226 static void
 227 n__sigman_hdl(int signo){
 228    NYD_X; /* Signal handler */
 229    n__sigman->sm_signo = signo;
 230    siglongjmp(n__sigman->sm_jump, 1);
 231 }
 232
 233 FL int
 234 n__sigman_enter(struct n_sigman *self, int flags){
 235    /* TODO no error checking when installing sighdls */
 236    int rv;
 237    NYD2_ENTER;
 238
 239    if((int)flags >= 0){
 240       self->sm_flags = (enum n_sigman_flags)flags;
 241       self->sm_signo = 0;
 242       self->sm_outer = n__sigman;
 243       if(flags & n_SIGMAN_HUP)
 244          self->sm_ohup = safe_signal(SIGHUP, &n__sigman_hdl);
 245       if(flags & n_SIGMAN_INT)
 246          self->sm_oint = safe_signal(SIGINT, &n__sigman_hdl);
 247       if(flags & n_SIGMAN_QUIT)
 248          self->sm_oquit = safe_signal(SIGQUIT, &n__sigman_hdl);
 249       if(flags & n_SIGMAN_PIPE)
 250          self->sm_opipe = safe_signal(SIGPIPE, &n__sigman_hdl);
 251       n__sigman = self;
 252       rv = 0;
 253    }else{
 254       flags = self->sm_flags;
 255
 256       /* Just in case of a race (signal while holding and ignoring? really?) */
 257       if(!(flags & n__SIGMAN_PING)){
 258          if(flags & n_SIGMAN_HUP)
 259             safe_signal(SIGHUP, SIG_IGN);
 260          if(flags & n_SIGMAN_INT)
 261             safe_signal(SIGINT, SIG_IGN);
 262          if(flags & n_SIGMAN_QUIT)
 263             safe_signal(SIGQUIT, SIG_IGN);
 264          if(flags & n_SIGMAN_PIPE)
 265             safe_signal(SIGPIPE, SIG_IGN);
 266       }
 267       rv = self->sm_signo;
 268       /* The signal mask has been restored, but of course rele_sigs() has
 269        * already been called: account for restoration due to jump */
 270       ++_hold_sigdepth;
 271    }
 272    rele_sigs();
 273    NYD2_LEAVE;
 274    return rv;
 275 }
 276
 277 FL void
 278 n_sigman_cleanup_ping(struct n_sigman *self){
 279    ui32_t f;
 280    NYD2_ENTER;
 281
 282    hold_sigs();
 283
 284    f = self->sm_flags;
 285    f |= n__SIGMAN_PING;
 286    self->sm_flags = f;
 287
 288    if(f & n_SIGMAN_HUP)
 289       safe_signal(SIGHUP, SIG_IGN);
 290    if(f & n_SIGMAN_INT)
 291       safe_signal(SIGINT, SIG_IGN);
 292    if(f & n_SIGMAN_QUIT)
 293       safe_signal(SIGQUIT, SIG_IGN);
 294    if(f & n_SIGMAN_PIPE)
 295       safe_signal(SIGPIPE, SIG_IGN);
 296
 297    rele_sigs();
 298    NYD2_LEAVE;
 299 }
 300
 301 FL void
 302 n_sigman_leave(struct n_sigman *self,
 303       enum n_sigman_flags reraise_flags){
 304    ui32_t f;
 305    int sig;
 306    NYD2_ENTER;
 307
 308    hold_sigs();
 309    n__sigman = self->sm_outer;
 310
 311    f = self->sm_flags;
 312    if(f & n_SIGMAN_HUP)
 313       safe_signal(SIGHUP, self->sm_ohup);
 314    if(f & n_SIGMAN_INT)
 315       safe_signal(SIGINT, self->sm_oint);
 316    if(f & n_SIGMAN_QUIT)
 317       safe_signal(SIGQUIT, self->sm_oquit);
 318    if(f & n_SIGMAN_PIPE)
 319       safe_signal(SIGPIPE, self->sm_opipe);
 320
 321    rele_sigs();
 322
 323    sig = 0;
 324    switch(self->sm_signo){
 325    case SIGPIPE:
 326       if((reraise_flags & n_SIGMAN_PIPE) ||
 327             ((reraise_flags & n_SIGMAN_NTTYOUT_PIPE) &&
 328              !(options & OPT_TTYOUT)))
 329          sig = SIGPIPE;
 330       break;
 331    case SIGHUP:
 332       if(reraise_flags & n_SIGMAN_HUP)
 333          sig = SIGHUP;
 334       break;
 335    case SIGINT:
 336       if(reraise_flags & n_SIGMAN_INT)
 337          sig = SIGINT;
 338       break;
 339    case SIGQUIT:
 340       if(reraise_flags & n_SIGMAN_QUIT)
 341          sig = SIGQUIT;
 342       break;
 343    default:
 344       break;
 345    }
 346
 347    NYD2_LEAVE;
 348    if(sig != 0){
 349       sigset_t cset;
 350
 351       sigemptyset(&cset);
 352       sigaddset(&cset, sig);
 353       sigprocmask(SIG_UNBLOCK, &cset, NULL);
 354       n_raise(sig);
 355    }
 356 }
 357
 358 FL int
 359 n_sigman_peek(void){
 360    int rv;
 361    NYD2_ENTER;
 362    rv = 0;
 363    NYD2_LEAVE;
 364    return rv;
 365 }
 366
 367 FL void
 368 n_sigman_consume(void){
 369    NYD2_ENTER;
 370    NYD2_LEAVE;
 371 }
 372
 373 #ifdef HAVE_NYD
 374 FL void
 375 _nyd_chirp(ui8_t act, char const *file, ui32_t line, char const *fun)
 376 {
 377    struct nyd_info *nip = _nyd_infos;
 378
 379    if (_nyd_curr != n_NELEM(_nyd_infos))
 380       nip += _nyd_curr++;
 381    else
 382       _nyd_curr = 1;
 383    nip->ni_file = file;
 384    nip->ni_fun = fun;
 385    nip->ni_chirp_line = ((ui32_t)(act & 0x3) << 29) | (line & 0x1FFFFFFFu);
 386    nip->ni_level = ((act == 0) ? _nyd_level
 387          : (act == 1) ? ++_nyd_level : _nyd_level--);
 388 }
 389
 390 FL void
 391 _nyd_oncrash(int signo)
 392 {
 393    char pathbuf[PATH_MAX], s2ibuf[32], *cp;
 394    struct sigaction xact;
 395    sigset_t xset;
 396    struct nyd_info *nip;
 397    int fd;
 398    size_t i, fnl;
 399    char const *tmpdir;
 400
 401    n_LCTA(sizeof("./") -1 + sizeof(VAL_UAGENT) -1 + sizeof(".dat") < PATH_MAX,
 402       "System limits too low for fixed-size buffer operation");
 403
 404    xact.sa_handler = SIG_DFL;
 405    sigemptyset(&xact.sa_mask);
 406    xact.sa_flags = 0;
 407    sigaction(signo, &xact, NULL);
 408
 409    i = strlen(tmpdir = ok_vlook(TMPDIR));
 410    fnl = sizeof(VAL_UAGENT) -1;
 411
 412    if (i + 1 + fnl + 1 + sizeof(".dat") > sizeof(pathbuf)) {
 413       (cp = pathbuf)[0] = '.';
 414       i = 1;
 415    } else
 416       memcpy(cp = pathbuf, tmpdir, i);
 417    cp[i++] = '/'; /* xxx pathsep */
 418    memcpy(cp += i, VAL_UAGENT, fnl);
 419    i += fnl;
 420    memcpy(cp += fnl, ".dat", sizeof(".dat"));
 421    fnl = i + sizeof(".dat") -1;
 422
 423    if ((fd = open(pathbuf, O_WRONLY | O_CREAT | O_EXCL, 0666)) == -1)
 424       fd = STDERR_FILENO;
 425
 426 # undef _X
 427 # define _X(X) (X), sizeof(X) -1
 428    write(fd, _X("\n\nNYD: program dying due to signal "));
 429
 430    cp = s2ibuf + sizeof(s2ibuf) -1;
 431    *cp = '\0';
 432    i = signo;
 433    do {
 434       *--cp = "0123456789"[i % 10];
 435       i /= 10;
 436    } while (i != 0);
 437    write(fd, cp, PTR2SIZE((s2ibuf + sizeof(s2ibuf) -1) - cp));
 438
 439    write(fd, _X(":\n"));
 440
 441    if (_nyd_infos[n_NELEM(_nyd_infos) - 1].ni_file != NULL)
 442       for (i = _nyd_curr, nip = _nyd_infos + i; i < n_NELEM(_nyd_infos); ++i)
 443          _nyd_print(fd, nip++);
 444    for (i = 0, nip = _nyd_infos; i < _nyd_curr; ++i)
 445       _nyd_print(fd, nip++);
 446
 447    write(fd, _X("----------\nCome up to the lab and see what's on the slab\n"));
 448
 449    if (fd != STDERR_FILENO) {
 450       write(STDERR_FILENO, _X("Crash NYD listing written to "));
 451       write(STDERR_FILENO, pathbuf, fnl);
 452       write(STDERR_FILENO, _X("\n"));
 453 # undef _X
 454
 455       close(fd);
 456    }
 457
 458    sigemptyset(&xset);
 459    sigaddset(&xset, signo);
 460    sigprocmask(SIG_UNBLOCK, &xset, NULL);
 461    n_raise(signo);
 462    for (;;)
 463       _exit(EXIT_ERR);
 464 }
 465 #endif /* HAVE_NYD */
 466
 467 /* s-it-mode */