jim-signal.c

   1 /*
   2  * jim-signal.c
   3  *
   4  */
   5
   6 #include <signal.h>
   7 #include <string.h>
   8 #include <ctype.h>
   9
  10 #include "jimautoconf.h"
  11 #ifdef HAVE_UNISTD_H
  12     #include <unistd.h>
  13 #endif
  14 #include <jim-subcmd.h>
  15 #include <jim-signal.h>
  16
  17 #define MAX_SIGNALS_WIDE (sizeof(jim_wide) * 8)
  18 #if defined(NSIG)
  19     #define MAX_SIGNALS (int)((NSIG < MAX_SIGNALS_WIDE) ? NSIG : MAX_SIGNALS_WIDE)
  20 #else
  21     #define MAX_SIGNALS (int)MAX_SIGNALS_WIDE
  22 #endif
  23
  24 static jim_wide *sigloc;
  25 static jim_wide sigsignored;
  26 static struct sigaction *sa_old;
  27 static struct {
  28     int status;
  29     const char *name;
  30 } siginfo[MAX_SIGNALS];
  31
  32 /* Make sure to do this as a wide, not int */
  33 #define sig_to_bit(SIG) ((jim_wide)1 << (SIG))
  34
  35 static void signal_handler(int sig)
  36 {
  37     /* Remember which signals occurred and store in *sigloc.
  38      * Jim_Eval() will notice this as soon as it can and throw an error
  39      */
  40     *sigloc |= sig_to_bit(sig);
  41 }
  42
  43 static void signal_ignorer(int sig)
  44 {
  45     /* Remember which signals occurred for access by 'signal check' */
  46     sigsignored |= sig_to_bit(sig);
  47 }
  48
  49 static void signal_init_names(void)
  50 {
  51 #define SET_SIG_NAME(SIG) siginfo[SIG].name = #SIG
  52
  53     SET_SIG_NAME(SIGABRT);
  54     SET_SIG_NAME(SIGALRM);
  55     SET_SIG_NAME(SIGBUS);
  56     SET_SIG_NAME(SIGCHLD);
  57     SET_SIG_NAME(SIGCONT);
  58     SET_SIG_NAME(SIGFPE);
  59     SET_SIG_NAME(SIGHUP);
  60     SET_SIG_NAME(SIGILL);
  61     SET_SIG_NAME(SIGINT);
  62 #ifdef SIGIO
  63     SET_SIG_NAME(SIGIO);
  64 #endif
  65     SET_SIG_NAME(SIGKILL);
  66     SET_SIG_NAME(SIGPIPE);
  67     SET_SIG_NAME(SIGPROF);
  68     SET_SIG_NAME(SIGQUIT);
  69     SET_SIG_NAME(SIGSEGV);
  70     SET_SIG_NAME(SIGSTOP);
  71     SET_SIG_NAME(SIGSYS);
  72     SET_SIG_NAME(SIGTERM);
  73     SET_SIG_NAME(SIGTRAP);
  74     SET_SIG_NAME(SIGTSTP);
  75     SET_SIG_NAME(SIGTTIN);
  76     SET_SIG_NAME(SIGTTOU);
  77     SET_SIG_NAME(SIGURG);
  78     SET_SIG_NAME(SIGUSR1);
  79     SET_SIG_NAME(SIGUSR2);
  80     SET_SIG_NAME(SIGVTALRM);
  81     SET_SIG_NAME(SIGWINCH);
  82     SET_SIG_NAME(SIGXCPU);
  83     SET_SIG_NAME(SIGXFSZ);
  84 #ifdef SIGPWR
  85     SET_SIG_NAME(SIGPWR);
  86 #endif
  87 #ifdef SIGCLD
  88     SET_SIG_NAME(SIGCLD);
  89 #endif
  90 #ifdef SIGEMT
  91     SET_SIG_NAME(SIGEMT);
  92 #endif
  93 #ifdef SIGLOST
  94     SET_SIG_NAME(SIGLOST);
  95 #endif
  96 #ifdef SIGPOLL
  97     SET_SIG_NAME(SIGPOLL);
  98 #endif
  99 #ifdef SIGINFO
 100     SET_SIG_NAME(SIGINFO);
 101 #endif
 102 }
 103
 104 /*
 105  *----------------------------------------------------------------------
 106  *
 107  * Tcl_SignalId --
 108  *
 109  *      Return a textual identifier for a signal number.
 110  *
 111  * Results:
 112  *      This procedure returns a machine-readable textual identifier
 113  *      that corresponds to sig.  The identifier is the same as the
 114  *      #define name in signal.h.
 115  *
 116  * Side effects:
 117  *      None.
 118  *
 119  *----------------------------------------------------------------------
 120  */
 121 const char *Jim_SignalId(int sig)
 122 {
 123     if (sig >=0 && sig < MAX_SIGNALS) {
 124         if (siginfo[sig].name) {
 125             return siginfo[sig].name;
 126         }
 127     }
 128     return "unknown signal";
 129 }
 130
 131 /**
 132  * Given the name of a signal, returns the signal value if found,
 133  * or returns -1 (and sets an error) if not found.
 134  * We accept -SIGINT, SIGINT, INT or any lowercase version or a number,
 135  * either positive or negative.
 136  */
 137 static int find_signal_by_name(Jim_Interp *interp, const char *name)
 138 {
 139     int i;
 140     const char *pt = name;
 141
 142     /* Remove optional - and SIG from the front of the name */
 143     if (*pt == '-') {
 144         pt++;
 145     }
 146     if (strncasecmp(name, "sig", 3) == 0) {
 147         pt += 3;
 148     }
 149     if (isdigit(UCHAR(pt[0]))) {
 150         i = atoi(pt);
 151         if (i > 0 && i < MAX_SIGNALS) {
 152             return i;
 153         }
 154     }
 155     else {
 156         for (i = 1; i < MAX_SIGNALS; i++) {
 157             /* Jim_SignalId() returns names such as SIGINT, and
 158              * returns "unknown signal" if unknown, so this will work
 159              */
 160             if (strcasecmp(Jim_SignalId(i) + 3, pt) == 0) {
 161                 return i;
 162             }
 163         }
 164     }
 165     Jim_SetResultFormatted(interp, "unknown signal %s", name);
 166
 167     return -1;
 168 }
 169
 170 #define SIGNAL_ACTION_HANDLE 1
 171 #define SIGNAL_ACTION_IGNORE -1
 172 #define SIGNAL_ACTION_BLOCK -2
 173 #define SIGNAL_ACTION_DEFAULT 0
 174
 175 static int do_signal_cmd(Jim_Interp *interp, int action, int argc, Jim_Obj *const *argv)
 176 {
 177     struct sigaction sa;
 178     int i;
 179
 180     if (argc == 0) {
 181         Jim_SetResult(interp, Jim_NewListObj(interp, NULL, 0));
 182         for (i = 1; i < MAX_SIGNALS; i++) {
 183             if (siginfo[i].status == action) {
 184                 /* Add signal name to the list  */
 185                 Jim_ListAppendElement(interp, Jim_GetResult(interp),
 186                     Jim_NewStringObj(interp, Jim_SignalId(i), -1));
 187             }
 188         }
 189         return JIM_OK;
 190     }
 191
 192     /* Catch all the signals we care about */
 193     if (action != SIGNAL_ACTION_DEFAULT) {
 194         memset(&sa, 0, sizeof(sa));
 195         if (action == SIGNAL_ACTION_HANDLE) {
 196             sa.sa_handler = signal_handler;
 197         }
 198         else if (action == SIGNAL_ACTION_IGNORE) {
 199             sa.sa_handler = signal_ignorer;
 200         }
 201         else {
 202             /* SIGNAL_ACTION_BLOCK */
 203             sa.sa_handler = SIG_IGN;
 204         }
 205     }
 206
 207     /* Iterate through the provided signals */
 208     for (i = 0; i < argc; i++) {
 209         int sig = find_signal_by_name(interp, Jim_String(argv[i]));
 210
 211         if (sig < 0) {
 212             return JIM_ERR;
 213         }
 214         if (action != siginfo[sig].status) {
 215             /* Need to change the action for this signal */
 216             switch (action) {
 217                 case SIGNAL_ACTION_BLOCK:
 218                 case SIGNAL_ACTION_HANDLE:
 219                 case SIGNAL_ACTION_IGNORE:
 220                     if (siginfo[sig].status == SIGNAL_ACTION_DEFAULT) {
 221                         if (!sa_old) {
 222                             /* Allocate the structure the first time through */
 223                             sa_old = Jim_Alloc(sizeof(*sa_old) * MAX_SIGNALS);
 224                         }
 225                         sigaction(sig, &sa, &sa_old[sig]);
 226                     }
 227                     else {
 228                         sigaction(sig, &sa, 0);
 229                     }
 230                     break;
 231
 232                 case SIGNAL_ACTION_DEFAULT:
 233                     /* Restore old handler */
 234                     if (sa_old) {
 235                         sigaction(sig, &sa_old[sig], 0);
 236                     }
 237             }
 238             siginfo[sig].status = action;
 239         }
 240     }
 241
 242     return JIM_OK;
 243 }
 244
 245 static int signal_cmd_handle(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 246 {
 247     return do_signal_cmd(interp, SIGNAL_ACTION_HANDLE, argc, argv);
 248 }
 249
 250 static int signal_cmd_ignore(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 251 {
 252     return do_signal_cmd(interp, SIGNAL_ACTION_IGNORE, argc, argv);
 253 }
 254
 255 static int signal_cmd_block(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 256 {
 257     return do_signal_cmd(interp, SIGNAL_ACTION_BLOCK, argc, argv);
 258 }
 259
 260 static int signal_cmd_default(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 261 {
 262     return do_signal_cmd(interp, SIGNAL_ACTION_DEFAULT, argc, argv);
 263 }
 264
 265 static int signal_set_sigmask_result(Jim_Interp *interp, jim_wide sigmask)
 266 {
 267     int i;
 268     Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0);
 269
 270     for (i = 0; i < MAX_SIGNALS; i++) {
 271         if (sigmask & sig_to_bit(i)) {
 272             Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, Jim_SignalId(i), -1));
 273         }
 274     }
 275     Jim_SetResult(interp, listObj);
 276     return JIM_OK;
 277 }
 278
 279 static int signal_cmd_check(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 280 {
 281     int clear = 0;
 282     jim_wide mask = 0;
 283     jim_wide ignored;
 284
 285     if (argc > 0 && Jim_CompareStringImmediate(interp, argv[0], "-clear")) {
 286         clear++;
 287     }
 288     if (argc > clear) {
 289         int i;
 290
 291         /* Signals specified */
 292         for (i = clear; i < argc; i++) {
 293             int sig = find_signal_by_name(interp, Jim_String(argv[i]));
 294
 295             if (sig < 0 || sig >= MAX_SIGNALS) {
 296                 return JIM_ERR;
 297             }
 298             mask |= sig_to_bit(sig);
 299         }
 300     }
 301     else {
 302         /* No signals specified, so check/clear all */
 303         mask = ~mask;
 304     }
 305
 306     /* Be careful we don't have a race condition where signals are cleared but not returned */
 307     ignored = sigsignored & mask;
 308     if (clear) {
 309         sigsignored &= ~ignored;
 310     }
 311     /* Set the result */
 312     signal_set_sigmask_result(interp, ignored);
 313     return JIM_OK;
 314 }
 315
 316 static int signal_cmd_throw(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 317 {
 318     int sig = SIGINT;
 319
 320     if (argc == 1) {
 321         if ((sig = find_signal_by_name(interp, Jim_String(argv[0]))) < 0) {
 322             return JIM_ERR;
 323         }
 324     }
 325
 326     /* If the signal is ignored ... */
 327     if (siginfo[sig].status == SIGNAL_ACTION_IGNORE) {
 328         sigsignored |= sig_to_bit(sig);
 329         return JIM_OK;
 330     }
 331
 332     /* Just set the signal */
 333     interp->sigmask |= sig_to_bit(sig);
 334
 335     /* Set the canonical name of the signal as the result */
 336     Jim_SetResultString(interp, Jim_SignalId(sig), -1);
 337
 338     /* And simply say we caught the signal */
 339     return JIM_SIGNAL;
 340 }
 341
 342 /*
 343  *-----------------------------------------------------------------------------
 344  *
 345  * Jim_SignalCmd --
 346  *     Implements the TCL signal command:
 347  *         signal handle|ignore|default|throw ?signals ...?
 348  *         signal throw signal
 349  *
 350  *     Specifies which signals are handled by Tcl code.
 351  *     If the one of the given signals is caught, it causes a JIM_SIGNAL
 352  *     exception to be thrown which can be caught by catch.
 353  *
 354  *     Use 'signal ignore' to ignore the signal(s)
 355  *     Use 'signal default' to go back to the default behaviour
 356  *     Use 'signal throw signal' to raise the given signal
 357  *
 358  *     If no arguments are given, returns the list of signals which are being handled
 359  *
 360  * Results:
 361  *      Standard TCL results.
 362  *
 363  *-----------------------------------------------------------------------------
 364  */
 365 static const jim_subcmd_type signal_command_table[] = {
 366     {   "handle",
 367         "?signals ...?",
 368         signal_cmd_handle,
 369         0,
 370         -1,
 371         /* Description: Lists handled signals, or adds to handled signals */
 372     },
 373     {   "ignore",
 374         "?signals ...?",
 375         signal_cmd_ignore,
 376         0,
 377         -1,
 378         /* Description: Lists ignored signals, or adds to ignored signals */
 379     },
 380     {   "block",
 381         "?signals ...?",
 382         signal_cmd_block,
 383         0,
 384         -1,
 385         /* Description: Lists blocked signals, or adds to blocked signals */
 386     },
 387     {   "default",
 388         "?signals ...?",
 389         signal_cmd_default,
 390         0,
 391         -1,
 392         /* Description: Lists defaulted signals, or adds to defaulted signals */
 393     },
 394     {   "check",
 395         "?-clear? ?signals ...?",
 396         signal_cmd_check,
 397         0,
 398         -1,
 399         /* Description: Returns ignored signals which have occurred, and optionally clearing them */
 400     },
 401     {   "throw",
 402         "?signal?",
 403         signal_cmd_throw,
 404         0,
 405         1,
 406         /* Description: Raises the given signal (default SIGINT) */
 407     },
 408     { NULL }
 409 };
 410
 411 /**
 412  * Restore default signal handling.
 413  */
 414 static void JimSignalCmdDelete(Jim_Interp *interp, void *privData)
 415 {
 416     int i;
 417     if (sa_old) {
 418         for (i = 1; i < MAX_SIGNALS; i++) {
 419             if (siginfo[i].status != SIGNAL_ACTION_DEFAULT) {
 420                 sigaction(i, &sa_old[i], 0);
 421                 siginfo[i].status = SIGNAL_ACTION_DEFAULT;
 422             }
 423         }
 424     }
 425     Jim_Free(sa_old);
 426     sa_old = NULL;
 427     sigloc = NULL;
 428 }
 429
 430 static int Jim_AlarmCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 431 {
 432     int ret;
 433
 434     if (argc != 2) {
 435         Jim_WrongNumArgs(interp, 1, argv, "seconds");
 436         return JIM_ERR;
 437     }
 438     else {
 439 #ifdef HAVE_UALARM
 440         double t;
 441
 442         ret = Jim_GetDouble(interp, argv[1], &t);
 443         if (ret == JIM_OK) {
 444             if (t < 1) {
 445                 ualarm(t * 1e6, 0);
 446             }
 447             else {
 448                 alarm(t);
 449             }
 450         }
 451 #else
 452         long t;
 453
 454         ret = Jim_GetLong(interp, argv[1], &t);
 455         if (ret == JIM_OK) {
 456             alarm(t);
 457         }
 458 #endif
 459     }
 460
 461     return ret;
 462 }
 463
 464 static int Jim_SleepCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 465 {
 466     int ret;
 467
 468     if (argc != 2) {
 469         Jim_WrongNumArgs(interp, 1, argv, "seconds");
 470         return JIM_ERR;
 471     }
 472     else {
 473         double t;
 474
 475         ret = Jim_GetDouble(interp, argv[1], &t);
 476         if (ret == JIM_OK) {
 477 #ifdef HAVE_USLEEP
 478             usleep((int)((t - (int)t) * 1e6));
 479 #endif
 480             sleep(t);
 481         }
 482     }
 483
 484     return ret;
 485 }
 486
 487 static int Jim_KillCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 488 {
 489     int sig;
 490     long pid;
 491     Jim_Obj *pidObj;
 492     const char *signame;
 493
 494     if (argc != 2 && argc != 3) {
 495         Jim_WrongNumArgs(interp, 1, argv, "?SIG|-0? pid");
 496         return JIM_ERR;
 497     }
 498
 499     if (argc == 2) {
 500         sig = SIGTERM;
 501         pidObj = argv[1];
 502     }
 503     else {
 504         signame = Jim_String(argv[1]);
 505         pidObj = argv[2];
 506
 507         /* Special 'kill -0 pid' to determine if a pid exists */
 508         if (strcmp(signame, "-0") == 0 || strcmp(signame, "0") == 0) {
 509             sig = 0;
 510         }
 511         else {
 512             sig = find_signal_by_name(interp, signame);
 513             if (sig < 0) {
 514                 return JIM_ERR;
 515             }
 516         }
 517     }
 518
 519     if (Jim_GetLong(interp, pidObj, &pid) != JIM_OK) {
 520         return JIM_ERR;
 521     }
 522
 523     if (kill(pid, sig) == 0) {
 524         return JIM_OK;
 525     }
 526
 527     Jim_SetResultString(interp, "kill: Failed to deliver signal", -1);
 528     return JIM_ERR;
 529 }
 530
 531 int Jim_signalInit(Jim_Interp *interp)
 532 {
 533     if (Jim_PackageProvide(interp, "signal", "1.0", JIM_ERRMSG))
 534         return JIM_ERR;
 535
 536     Jim_CreateCommand(interp, "alarm", Jim_AlarmCmd, 0, 0);
 537     Jim_CreateCommand(interp, "kill", Jim_KillCmd, 0, 0);
 538     /* Sleep is slightly dubious here */
 539     Jim_CreateCommand(interp, "sleep", Jim_SleepCmd, 0, 0);
 540
 541     /* Teach the jim core how to set a result from a sigmask */
 542     interp->signal_set_result = signal_set_sigmask_result;
 543
 544     /* Currently only the top level interp supports signals */
 545     if (!sigloc) {
 546         signal_init_names();
 547
 548         /* Make sure we know where to store the signals which occur */
 549         sigloc = &interp->sigmask;
 550
 551         Jim_CreateCommand(interp, "signal", Jim_SubCmdProc, (void *)signal_command_table, JimSignalCmdDelete);
 552     }
 553
 554     return JIM_OK;
 555 }