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 ((NSIG < MAX_SIGNALS_WIDE) ? NSIG : MAX_SIGNALS_WIDE)
  20 #else
  21     #define MAX_SIGNALS MAX_SIGNALS_WIDE
  22 #endif
  23
  24 static jim_wide *sigloc;
  25 static jim_wide sigsblocked;
  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     /* We just remember which signals occurred. Jim_Eval() will
  38      * 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     /* We just remember which signals occurred */
  46     sigsblocked |= 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 const char *Jim_SignalName(int sig)
 132 {
 133 #ifdef HAVE_SYS_SIGLIST
 134     if (sig >= 0 && sig < NSIG) {
 135         return sys_siglist[sig];
 136     }
 137 #endif
 138     return Jim_SignalId(sig);
 139 }
 140
 141 /**
 142  * Given the name of a signal, returns the signal value if found,
 143  * or returns -1 (and sets an error) if not found.
 144  * We accept -SIGINT, SIGINT, INT or any lowercase version or a number,
 145  * either positive or negative.
 146  */
 147 static int find_signal_by_name(Jim_Interp *interp, const char *name)
 148 {
 149     int i;
 150     const char *pt = name;
 151
 152     /* Remove optional - and SIG from the front of the name */
 153     if (*pt == '-') {
 154         pt++;
 155     }
 156     if (strncasecmp(name, "sig", 3) == 0) {
 157         pt += 3;
 158     }
 159     if (isdigit(UCHAR(pt[0]))) {
 160         i = atoi(pt);
 161         if (i > 0 && i < MAX_SIGNALS) {
 162             return i;
 163         }
 164     }
 165     else {
 166         for (i = 1; i < MAX_SIGNALS; i++) {
 167             /* Jim_SignalId() returns names such as SIGINT, and
 168              * returns "unknown signal" if unknown, so this will work
 169              */
 170             if (strcasecmp(Jim_SignalId(i) + 3, pt) == 0) {
 171                 return i;
 172             }
 173         }
 174     }
 175     Jim_SetResultFormatted(interp, "unknown signal %s", name);
 176
 177     return -1;
 178 }
 179
 180 #define SIGNAL_ACTION_HANDLE 1
 181 #define SIGNAL_ACTION_IGNORE -1
 182 #define SIGNAL_ACTION_DEFAULT 0
 183
 184 static int do_signal_cmd(Jim_Interp *interp, int action, int argc, Jim_Obj *const *argv)
 185 {
 186     struct sigaction sa;
 187     int i;
 188
 189     if (argc == 0) {
 190         Jim_SetResult(interp, Jim_NewListObj(interp, NULL, 0));
 191         for (i = 1; i < MAX_SIGNALS; i++) {
 192             if (siginfo[i].status == action) {
 193                 /* Add signal name to the list  */
 194                 Jim_ListAppendElement(interp, Jim_GetResult(interp),
 195                     Jim_NewStringObj(interp, Jim_SignalId(i), -1));
 196             }
 197         }
 198         return JIM_OK;
 199     }
 200
 201     /* Catch all the signals we care about */
 202     if (action != SIGNAL_ACTION_DEFAULT) {
 203         memset(&sa, 0, sizeof(sa));
 204         if (action == SIGNAL_ACTION_HANDLE) {
 205             sa.sa_handler = signal_handler;
 206         }
 207         else {
 208             sa.sa_handler = signal_ignorer;
 209         }
 210     }
 211
 212     /* Iterate through the provided signals */
 213     for (i = 0; i < argc; i++) {
 214         int sig = find_signal_by_name(interp, Jim_String(argv[i]));
 215
 216         if (sig < 0) {
 217             return JIM_ERR;
 218         }
 219         if (action != siginfo[sig].status) {
 220             /* Need to change the action for this signal */
 221             switch (action) {
 222                 case SIGNAL_ACTION_HANDLE:
 223                 case SIGNAL_ACTION_IGNORE:
 224                     if (siginfo[sig].status == SIGNAL_ACTION_DEFAULT) {
 225                         if (!sa_old) {
 226                             /* Allocate the structure the first time through */
 227                             sa_old = Jim_Alloc(sizeof(*sa_old) * MAX_SIGNALS);
 228                         }
 229                         sigaction(sig, &sa, &sa_old[sig]);
 230                     }
 231                     else {
 232                         sigaction(sig, &sa, 0);
 233                     }
 234                     break;
 235
 236                 case SIGNAL_ACTION_DEFAULT:
 237                     /* Restore old handler */
 238                     if (sa_old) {
 239                         sigaction(sig, &sa_old[sig], 0);
 240                     }
 241             }
 242             siginfo[sig].status = action;
 243         }
 244     }
 245
 246     return JIM_OK;
 247 }
 248
 249 static int signal_cmd_handle(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 250 {
 251     return do_signal_cmd(interp, SIGNAL_ACTION_HANDLE, argc, argv);
 252 }
 253
 254 static int signal_cmd_ignore(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 255 {
 256     return do_signal_cmd(interp, SIGNAL_ACTION_IGNORE, argc, argv);
 257 }
 258
 259 static int signal_cmd_default(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 260 {
 261     return do_signal_cmd(interp, SIGNAL_ACTION_DEFAULT, argc, argv);
 262 }
 263
 264 static int signal_set_sigmask_result(Jim_Interp *interp, jim_wide sigmask)
 265 {
 266     int i;
 267     Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0);
 268
 269     for (i = 0; i < MAX_SIGNALS; i++) {
 270         if (sigmask & sig_to_bit(i)) {
 271             Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, Jim_SignalId(i), -1));
 272         }
 273     }
 274     Jim_SetResult(interp, listObj);
 275     return JIM_OK;
 276 }
 277
 278 static int signal_cmd_check(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 279 {
 280     int clear = 0;
 281     jim_wide mask = 0;
 282     jim_wide blocked;
 283
 284     if (argc > 0 && Jim_CompareStringImmediate(interp, argv[0], "-clear")) {
 285         clear++;
 286     }
 287     if (argc > clear) {
 288         int i;
 289
 290         /* Signals specified */
 291         for (i = clear; i < argc; i++) {
 292             int sig = find_signal_by_name(interp, Jim_String(argv[i]));
 293
 294             if (sig < 0 || sig >= MAX_SIGNALS) {
 295                 return -1;
 296             }
 297             mask |= sig_to_bit(sig);
 298         }
 299     }
 300     else {
 301         /* No signals specified, so check/clear all */
 302         mask = ~mask;
 303     }
 304
 305     if ((sigsblocked & mask) == 0) {
 306         /* No matching signals, so empty result and nothing to do */
 307         return JIM_OK;
 308     }
 309     /* Be careful we don't have a race condition where signals are cleared but not returned */
 310     blocked = sigsblocked & mask;
 311     if (clear) {
 312         sigsblocked &= ~blocked;
 313     }
 314     /* Set the result */
 315     signal_set_sigmask_result(interp, blocked);
 316     return JIM_OK;
 317 }
 318
 319 static int signal_cmd_throw(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 320 {
 321     int sig = SIGINT;
 322
 323     if (argc == 1) {
 324         if ((sig = find_signal_by_name(interp, Jim_String(argv[0]))) < 0) {
 325             return JIM_ERR;
 326         }
 327     }
 328
 329     /* If the signal is ignored (blocked) ... */
 330     if (siginfo[sig].status == SIGNAL_ACTION_IGNORE) {
 331         sigsblocked |= sig_to_bit(sig);
 332         return JIM_OK;
 333     }
 334
 335     /* Just set the signal */
 336     interp->sigmask |= sig_to_bit(sig);
 337
 338     /* Set the canonical name of the signal as the result */
 339     Jim_SetResultString(interp, Jim_SignalId(sig), -1);
 340
 341     /* And simply say we caught the signal */
 342     return JIM_SIGNAL;
 343 }
 344
 345 /*
 346  *-----------------------------------------------------------------------------
 347  *
 348  * Jim_SignalCmd --
 349  *     Implements the TCL signal command:
 350  *         signal handle|ignore|default|throw ?signals ...?
 351  *         signal throw signal
 352  *
 353  *     Specifies which signals are handled by Tcl code.
 354  *     If the one of the given signals is caught, it causes a JIM_SIGNAL
 355  *     exception to be thrown which can be caught by catch.
 356  *
 357  *     Use 'signal ignore' to ignore the signal(s)
 358  *     Use 'signal default' to go back to the default behaviour
 359  *     Use 'signal throw signal' to raise the given signal
 360  *
 361  *     If no arguments are given, returns the list of signals which are being handled
 362  *
 363  * Results:
 364  *      Standard TCL results.
 365  *
 366  *-----------------------------------------------------------------------------
 367  */
 368 static const jim_subcmd_type signal_command_table[] = {
 369     {   "handle",
 370         "?signals ...?",
 371         signal_cmd_handle,
 372         0,
 373         -1,
 374         /* Description: Lists handled signals, or adds to handled signals */
 375     },
 376     {   "ignore",
 377         "?signals ...?",
 378         signal_cmd_ignore,
 379         0,
 380         -1,
 381         /* Description: Lists ignored signals, or adds to ignored signals */
 382     },
 383     {   "default",
 384         "?signals ...?",
 385         signal_cmd_default,
 386         0,
 387         -1,
 388         /* Description: Lists defaulted signals, or adds to defaulted signals */
 389     },
 390     {   "check",
 391         "?-clear? ?signals ...?",
 392         signal_cmd_check,
 393         0,
 394         -1,
 395         /* Description: Returns ignored signals which have occurred, and optionally clearing them */
 396     },
 397     {   "throw",
 398         "?signal?",
 399         signal_cmd_throw,
 400         0,
 401         1,
 402         /* Description: Raises the given signal (default SIGINT) */
 403     },
 404     { NULL }
 405 };
 406
 407 static int Jim_AlarmCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 408 {
 409     int ret;
 410
 411     if (argc != 2) {
 412         Jim_WrongNumArgs(interp, 1, argv, "seconds");
 413         return JIM_ERR;
 414     }
 415     else {
 416 #ifdef HAVE_UALARM
 417         double t;
 418
 419         ret = Jim_GetDouble(interp, argv[1], &t);
 420         if (ret == JIM_OK) {
 421             if (t < 1) {
 422                 ualarm(t * 1e6, 0);
 423             }
 424             else {
 425                 alarm(t);
 426             }
 427         }
 428 #else
 429         long t;
 430
 431         ret = Jim_GetLong(interp, argv[1], &t);
 432         if (ret == JIM_OK) {
 433             alarm(t);
 434         }
 435 #endif
 436     }
 437
 438     return ret;
 439 }
 440
 441 static int Jim_SleepCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 442 {
 443     int ret;
 444
 445     if (argc != 2) {
 446         Jim_WrongNumArgs(interp, 1, argv, "seconds");
 447         return JIM_ERR;
 448     }
 449     else {
 450         double t;
 451
 452         ret = Jim_GetDouble(interp, argv[1], &t);
 453         if (ret == JIM_OK) {
 454 #ifdef HAVE_USLEEP
 455             usleep((int)((t - (int)t) * 1e6));
 456 #endif
 457             sleep(t);
 458         }
 459     }
 460
 461     return ret;
 462 }
 463
 464 static int Jim_KillCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 465 {
 466     int sig;
 467     long pid;
 468     Jim_Obj *pidObj;
 469     const char *signame;
 470
 471     if (argc != 2 && argc != 3) {
 472         Jim_WrongNumArgs(interp, 1, argv, "?SIG|-0? pid");
 473         return JIM_ERR;
 474     }
 475
 476     if (argc == 2) {
 477         sig = SIGTERM;
 478         pidObj = argv[1];
 479     }
 480     else {
 481         signame = Jim_String(argv[1]);
 482         pidObj = argv[2];
 483
 484         /* Special 'kill -0 pid' to determine if a pid exists */
 485         if (strcmp(signame, "-0") == 0 || strcmp(signame, "0") == 0) {
 486             sig = 0;
 487         }
 488         else {
 489             sig = find_signal_by_name(interp, signame);
 490             if (sig < 0) {
 491                 return JIM_ERR;
 492             }
 493         }
 494     }
 495
 496     if (Jim_GetLong(interp, pidObj, &pid) != JIM_OK) {
 497         return JIM_ERR;
 498     }
 499
 500     if (kill(pid, sig) == 0) {
 501         return JIM_OK;
 502     }
 503
 504     Jim_SetResultString(interp, "kill: Failed to deliver signal", -1);
 505     return JIM_ERR;
 506 }
 507
 508 int Jim_signalInit(Jim_Interp *interp)
 509 {
 510     if (Jim_PackageProvide(interp, "signal", "1.0", JIM_ERRMSG))
 511         return JIM_ERR;
 512
 513     signal_init_names();
 514
 515     /* Teach the jim core how to set a result from a sigmask */
 516     interp->signal_set_result = signal_set_sigmask_result;
 517
 518     /* Make sure we know where to store the signals which occur */
 519     sigloc = &interp->sigmask;
 520
 521     Jim_CreateCommand(interp, "signal", Jim_SubCmdProc, (void *)signal_command_table, NULL);
 522     Jim_CreateCommand(interp, "alarm", Jim_AlarmCmd, 0, 0);
 523     Jim_CreateCommand(interp, "kill", Jim_KillCmd, 0, 0);
 524
 525     /* Sleep is slightly dubious here */
 526     Jim_CreateCommand(interp, "sleep", Jim_SleepCmd, 0, 0);
 527     return JIM_OK;
 528 }