jim-signal.c

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