AppPkg/Applications/Python/Python-2.7.10/Modules/signalmodule.c

   1
   2 /* Signal module -- many thanks to Lance Ellinghaus */
   3
   4 /* XXX Signals should be recorded per thread, now we have thread state. */
   5
   6 #include "Python.h"
   7 #include "intrcheck.h"
   8
   9 #ifdef MS_WINDOWS
  10 #include <Windows.h>
  11 #ifdef HAVE_PROCESS_H
  12 #include <process.h>
  13 #endif
  14 #endif
  15
  16 #ifdef HAVE_SIGNAL_H
  17 #include <signal.h>
  18 #endif
  19 #ifdef HAVE_SYS_STAT_H
  20 #include <sys/stat.h>
  21 #endif
  22 #ifdef HAVE_SYS_TIME_H
  23 #include <sys/time.h>
  24 #endif
  25
  26 #ifndef SIG_ERR
  27 #define SIG_ERR ((PyOS_sighandler_t)(-1))
  28 #endif
  29
  30 #if defined(PYOS_OS2) && !defined(PYCC_GCC)
  31 #define NSIG 12
  32 #include <process.h>
  33 #endif
  34
  35 #ifndef NSIG
  36 # if defined(_NSIG)
  37 #  define NSIG _NSIG            /* For BSD/SysV */
  38 # elif defined(_SIGMAX)
  39 #  define NSIG (_SIGMAX + 1)    /* For QNX */
  40 # elif defined(SIGMAX)
  41 #  define NSIG (SIGMAX + 1)     /* For djgpp */
  42 # else
  43 #  define NSIG 64               /* Use a reasonable default value */
  44 # endif
  45 #endif
  46
  47
  48 /*
  49    NOTES ON THE INTERACTION BETWEEN SIGNALS AND THREADS
  50
  51    When threads are supported, we want the following semantics:
  52
  53    - only the main thread can set a signal handler
  54    - any thread can get a signal handler
  55    - signals are only delivered to the main thread
  56
  57    I.e. we don't support "synchronous signals" like SIGFPE (catching
  58    this doesn't make much sense in Python anyway) nor do we support
  59    signals as a means of inter-thread communication, since not all
  60    thread implementations support that (at least our thread library
  61    doesn't).
  62
  63    We still have the problem that in some implementations signals
  64    generated by the keyboard (e.g. SIGINT) are delivered to all
  65    threads (e.g. SGI), while in others (e.g. Solaris) such signals are
  66    delivered to one random thread (an intermediate possibility would
  67    be to deliver it to the main thread -- POSIX?).  For now, we have
  68    a working implementation that works in all three cases -- the
  69    handler ignores signals if getpid() isn't the same as in the main
  70    thread.  XXX This is a hack.
  71
  72    GNU pth is a user-space threading library, and as such, all threads
  73    run within the same process. In this case, if the currently running
  74    thread is not the main_thread, send the signal to the main_thread.
  75 */
  76
  77 #ifdef WITH_THREAD
  78 #include <sys/types.h> /* For pid_t */
  79 #include "pythread.h"
  80 static long main_thread;
  81 static pid_t main_pid;
  82 #endif
  83
  84 static struct {
  85     int tripped;
  86     PyObject *func;
  87 } Handlers[NSIG];
  88
  89 static sig_atomic_t wakeup_fd = -1;
  90
  91 /* Speed up sigcheck() when none tripped */
  92 static volatile sig_atomic_t is_tripped = 0;
  93
  94 static PyObject *DefaultHandler;
  95 static PyObject *IgnoreHandler;
  96 static PyObject *IntHandler;
  97
  98 /* On Solaris 8, gcc will produce a warning that the function
  99    declaration is not a prototype. This is caused by the definition of
 100    SIG_DFL as (void (*)())0; the correct declaration would have been
 101    (void (*)(int))0. */
 102
 103 static PyOS_sighandler_t old_siginthandler = SIG_DFL;
 104
 105 #ifdef HAVE_GETITIMER
 106 static PyObject *ItimerError;
 107
 108 /* auxiliary functions for setitimer/getitimer */
 109 static void
 110 timeval_from_double(double d, struct timeval *tv)
 111 {
 112     tv->tv_sec = floor(d);
 113     tv->tv_usec = fmod(d, 1.0) * 1000000.0;
 114 }
 115
 116 Py_LOCAL_INLINE(double)
 117 double_from_timeval(struct timeval *tv)
 118 {
 119     return tv->tv_sec + (double)(tv->tv_usec / 1000000.0);
 120 }
 121
 122 static PyObject *
 123 itimer_retval(struct itimerval *iv)
 124 {
 125     PyObject *r, *v;
 126
 127     r = PyTuple_New(2);
 128     if (r == NULL)
 129     return NULL;
 130
 131     if(!(v = PyFloat_FromDouble(double_from_timeval(&iv->it_value)))) {
 132     Py_DECREF(r);
 133     return NULL;
 134     }
 135
 136     PyTuple_SET_ITEM(r, 0, v);
 137
 138     if(!(v = PyFloat_FromDouble(double_from_timeval(&iv->it_interval)))) {
 139     Py_DECREF(r);
 140     return NULL;
 141     }
 142
 143     PyTuple_SET_ITEM(r, 1, v);
 144
 145     return r;
 146 }
 147 #endif
 148
 149 static PyObject *
 150 signal_default_int_handler(PyObject *self, PyObject *args)
 151 {
 152     PyErr_SetNone(PyExc_KeyboardInterrupt);
 153     return NULL;
 154 }
 155
 156 PyDoc_STRVAR(default_int_handler_doc,
 157 "default_int_handler(...)\n\
 158 \n\
 159 The default handler for SIGINT installed by Python.\n\
 160 It raises KeyboardInterrupt.");
 161
 162
 163 static int
 164 checksignals_witharg(void * unused)
 165 {
 166     return PyErr_CheckSignals();
 167 }
 168
 169 static void
 170 trip_signal(int sig_num)
 171 {
 172     Handlers[sig_num].tripped = 1;
 173     if (is_tripped)
 174         return;
 175     /* Set is_tripped after setting .tripped, as it gets
 176        cleared in PyErr_CheckSignals() before .tripped. */
 177     is_tripped = 1;
 178     Py_AddPendingCall(checksignals_witharg, NULL);
 179     if (wakeup_fd != -1)
 180         write(wakeup_fd, "\0", 1);
 181 }
 182
 183 static void
 184 signal_handler(int sig_num)
 185 {
 186     int save_errno = errno;
 187
 188 #if defined(WITH_THREAD) && defined(WITH_PTH)
 189     if (PyThread_get_thread_ident() != main_thread) {
 190         pth_raise(*(pth_t *) main_thread, sig_num);
 191     }
 192     else
 193 #endif
 194     {
 195 #ifdef WITH_THREAD
 196     /* See NOTES section above */
 197     if (getpid() == main_pid)
 198 #endif
 199     {
 200         trip_signal(sig_num);
 201     }
 202
 203 #ifndef HAVE_SIGACTION
 204 #ifdef SIGCHLD
 205     /* To avoid infinite recursion, this signal remains
 206        reset until explicit re-instated.
 207        Don't clear the 'func' field as it is our pointer
 208        to the Python handler... */
 209     if (sig_num != SIGCHLD)
 210 #endif
 211     /* If the handler was not set up with sigaction, reinstall it.  See
 212      * Python/pythonrun.c for the implementation of PyOS_setsig which
 213      * makes this true.  See also issue8354. */
 214     PyOS_setsig(sig_num, signal_handler);
 215 #endif
 216     }
 217
 218     /* Issue #10311: asynchronously executing signal handlers should not
 219        mutate errno under the feet of unsuspecting C code. */
 220     errno = save_errno;
 221 }
 222
 223
 224 #ifdef HAVE_ALARM
 225 static PyObject *
 226 signal_alarm(PyObject *self, PyObject *args)
 227 {
 228     int t;
 229     if (!PyArg_ParseTuple(args, "i:alarm", &t))
 230         return NULL;
 231     /* alarm() returns the number of seconds remaining */
 232     return PyInt_FromLong((long)alarm(t));
 233 }
 234
 235 PyDoc_STRVAR(alarm_doc,
 236 "alarm(seconds)\n\
 237 \n\
 238 Arrange for SIGALRM to arrive after the given number of seconds.");
 239 #endif
 240
 241 #ifdef HAVE_PAUSE
 242 static PyObject *
 243 signal_pause(PyObject *self)
 244 {
 245     Py_BEGIN_ALLOW_THREADS
 246     (void)pause();
 247     Py_END_ALLOW_THREADS
 248     /* make sure that any exceptions that got raised are propagated
 249      * back into Python
 250      */
 251     if (PyErr_CheckSignals())
 252         return NULL;
 253
 254     Py_INCREF(Py_None);
 255     return Py_None;
 256 }
 257 PyDoc_STRVAR(pause_doc,
 258 "pause()\n\
 259 \n\
 260 Wait until a signal arrives.");
 261
 262 #endif
 263
 264
 265 static PyObject *
 266 signal_signal(PyObject *self, PyObject *args)
 267 {
 268     PyObject *obj;
 269     int sig_num;
 270     PyObject *old_handler;
 271     void (*func)(int);
 272     if (!PyArg_ParseTuple(args, "iO:signal", &sig_num, &obj))
 273         return NULL;
 274 #ifdef MS_WINDOWS
 275     /* Validate that sig_num is one of the allowable signals */
 276     switch (sig_num) {
 277         case SIGABRT: break;
 278 #ifdef SIGBREAK
 279         /* Issue #10003: SIGBREAK is not documented as permitted, but works
 280            and corresponds to CTRL_BREAK_EVENT. */
 281         case SIGBREAK: break;
 282 #endif
 283         case SIGFPE: break;
 284         case SIGILL: break;
 285         case SIGINT: break;
 286         case SIGSEGV: break;
 287         case SIGTERM: break;
 288         default:
 289             PyErr_SetString(PyExc_ValueError, "invalid signal value");
 290             return NULL;
 291     }
 292 #endif
 293 #ifdef WITH_THREAD
 294     if (PyThread_get_thread_ident() != main_thread) {
 295         PyErr_SetString(PyExc_ValueError,
 296                         "signal only works in main thread");
 297         return NULL;
 298     }
 299 #endif
 300     if (sig_num < 1 || sig_num >= NSIG) {
 301         PyErr_SetString(PyExc_ValueError,
 302                         "signal number out of range");
 303         return NULL;
 304     }
 305     if (obj == IgnoreHandler)
 306         func = SIG_IGN;
 307     else if (obj == DefaultHandler)
 308         func = SIG_DFL;
 309     else if (!PyCallable_Check(obj)) {
 310         PyErr_SetString(PyExc_TypeError,
 311 "signal handler must be signal.SIG_IGN, signal.SIG_DFL, or a callable object");
 312                 return NULL;
 313     }
 314     else
 315         func = signal_handler;
 316     if (PyOS_setsig(sig_num, func) == SIG_ERR) {
 317         PyErr_SetFromErrno(PyExc_RuntimeError);
 318         return NULL;
 319     }
 320     old_handler = Handlers[sig_num].func;
 321     Handlers[sig_num].tripped = 0;
 322     Py_INCREF(obj);
 323     Handlers[sig_num].func = obj;
 324     if (old_handler != NULL)
 325         return old_handler;
 326     else
 327         Py_RETURN_NONE;
 328 }
 329
 330 PyDoc_STRVAR(signal_doc,
 331 "signal(sig, action) -> action\n\
 332 \n\
 333 Set the action for the given signal.  The action can be SIG_DFL,\n\
 334 SIG_IGN, or a callable Python object.  The previous action is\n\
 335 returned.  See getsignal() for possible return values.\n\
 336 \n\
 337 *** IMPORTANT NOTICE ***\n\
 338 A signal handler function is called with two arguments:\n\
 339 the first is the signal number, the second is the interrupted stack frame.");
 340
 341
 342 static PyObject *
 343 signal_getsignal(PyObject *self, PyObject *args)
 344 {
 345     int sig_num;
 346     PyObject *old_handler;
 347     if (!PyArg_ParseTuple(args, "i:getsignal", &sig_num))
 348         return NULL;
 349     if (sig_num < 1 || sig_num >= NSIG) {
 350         PyErr_SetString(PyExc_ValueError,
 351                         "signal number out of range");
 352         return NULL;
 353     }
 354     old_handler = Handlers[sig_num].func;
 355     if (old_handler != NULL) {
 356         Py_INCREF(old_handler);
 357         return old_handler;
 358     }
 359     else {
 360         Py_RETURN_NONE;
 361     }
 362 }
 363
 364 PyDoc_STRVAR(getsignal_doc,
 365 "getsignal(sig) -> action\n\
 366 \n\
 367 Return the current action for the given signal.  The return value can be:\n\
 368 SIG_IGN -- if the signal is being ignored\n\
 369 SIG_DFL -- if the default action for the signal is in effect\n\
 370 None -- if an unknown handler is in effect\n\
 371 anything else -- the callable Python object used as a handler");
 372
 373 #ifdef HAVE_SIGINTERRUPT
 374 PyDoc_STRVAR(siginterrupt_doc,
 375 "siginterrupt(sig, flag) -> None\n\
 376 change system call restart behaviour: if flag is False, system calls\n\
 377 will be restarted when interrupted by signal sig, else system calls\n\
 378 will be interrupted.");
 379
 380 static PyObject *
 381 signal_siginterrupt(PyObject *self, PyObject *args)
 382 {
 383     int sig_num;
 384     int flag;
 385
 386     if (!PyArg_ParseTuple(args, "ii:siginterrupt", &sig_num, &flag))
 387         return NULL;
 388     if (sig_num < 1 || sig_num >= NSIG) {
 389         PyErr_SetString(PyExc_ValueError,
 390                         "signal number out of range");
 391         return NULL;
 392     }
 393     if (siginterrupt(sig_num, flag)<0) {
 394         PyErr_SetFromErrno(PyExc_RuntimeError);
 395         return NULL;
 396     }
 397
 398     Py_INCREF(Py_None);
 399     return Py_None;
 400 }
 401
 402 #endif
 403
 404 static PyObject *
 405 signal_set_wakeup_fd(PyObject *self, PyObject *args)
 406 {
 407     struct stat buf;
 408     int fd, old_fd;
 409     if (!PyArg_ParseTuple(args, "i:set_wakeup_fd", &fd))
 410         return NULL;
 411 #ifdef WITH_THREAD
 412     if (PyThread_get_thread_ident() != main_thread) {
 413         PyErr_SetString(PyExc_ValueError,
 414                         "set_wakeup_fd only works in main thread");
 415         return NULL;
 416     }
 417 #endif
 418     if (fd != -1 && (!_PyVerify_fd(fd) || fstat(fd, &buf) != 0)) {
 419         PyErr_SetString(PyExc_ValueError, "invalid fd");
 420         return NULL;
 421     }
 422     old_fd = wakeup_fd;
 423     wakeup_fd = fd;
 424     return PyLong_FromLong(old_fd);
 425 }
 426
 427 PyDoc_STRVAR(set_wakeup_fd_doc,
 428 "set_wakeup_fd(fd) -> fd\n\
 429 \n\
 430 Sets the fd to be written to (with '\\0') when a signal\n\
 431 comes in.  A library can use this to wakeup select or poll.\n\
 432 The previous fd is returned.\n\
 433 \n\
 434 The fd must be non-blocking.");
 435
 436 /* C API for the same, without all the error checking */
 437 int
 438 PySignal_SetWakeupFd(int fd)
 439 {
 440     int old_fd = wakeup_fd;
 441     if (fd < 0)
 442         fd = -1;
 443     wakeup_fd = fd;
 444     return old_fd;
 445 }
 446
 447
 448 #ifdef HAVE_SETITIMER
 449 static PyObject *
 450 signal_setitimer(PyObject *self, PyObject *args)
 451 {
 452     double first;
 453     double interval = 0;
 454     int which;
 455     struct itimerval new, old;
 456
 457     if(!PyArg_ParseTuple(args, "id|d:setitimer", &which, &first, &interval))
 458     return NULL;
 459
 460     timeval_from_double(first, &new.it_value);
 461     timeval_from_double(interval, &new.it_interval);
 462     /* Let OS check "which" value */
 463     if (setitimer(which, &new, &old) != 0) {
 464     PyErr_SetFromErrno(ItimerError);
 465     return NULL;
 466     }
 467
 468     return itimer_retval(&old);
 469 }
 470
 471 PyDoc_STRVAR(setitimer_doc,
 472 "setitimer(which, seconds[, interval])\n\
 473 \n\
 474 Sets given itimer (one of ITIMER_REAL, ITIMER_VIRTUAL\n\
 475 or ITIMER_PROF) to fire after value seconds and after\n\
 476 that every interval seconds.\n\
 477 The itimer can be cleared by setting seconds to zero.\n\
 478 \n\
 479 Returns old values as a tuple: (delay, interval).");
 480 #endif
 481
 482
 483 #ifdef HAVE_GETITIMER
 484 static PyObject *
 485 signal_getitimer(PyObject *self, PyObject *args)
 486 {
 487     int which;
 488     struct itimerval old;
 489
 490     if (!PyArg_ParseTuple(args, "i:getitimer", &which))
 491     return NULL;
 492
 493     if (getitimer(which, &old) != 0) {
 494     PyErr_SetFromErrno(ItimerError);
 495     return NULL;
 496     }
 497
 498     return itimer_retval(&old);
 499 }
 500
 501 PyDoc_STRVAR(getitimer_doc,
 502 "getitimer(which)\n\
 503 \n\
 504 Returns current value of given itimer.");
 505 #endif
 506
 507
 508 /* List of functions defined in the module */
 509 static PyMethodDef signal_methods[] = {
 510 #ifdef HAVE_ALARM
 511     {"alarm",                   signal_alarm, METH_VARARGS, alarm_doc},
 512 #endif
 513 #ifdef HAVE_SETITIMER
 514     {"setitimer",       signal_setitimer, METH_VARARGS, setitimer_doc},
 515 #endif
 516 #ifdef HAVE_GETITIMER
 517     {"getitimer",       signal_getitimer, METH_VARARGS, getitimer_doc},
 518 #endif
 519     {"signal",                  signal_signal, METH_VARARGS, signal_doc},
 520     {"getsignal",               signal_getsignal, METH_VARARGS, getsignal_doc},
 521     {"set_wakeup_fd",           signal_set_wakeup_fd, METH_VARARGS, set_wakeup_fd_doc},
 522 #ifdef HAVE_SIGINTERRUPT
 523     {"siginterrupt",            signal_siginterrupt, METH_VARARGS, siginterrupt_doc},
 524 #endif
 525 #ifdef HAVE_PAUSE
 526     {"pause",                   (PyCFunction)signal_pause,
 527      METH_NOARGS,pause_doc},
 528 #endif
 529     {"default_int_handler", signal_default_int_handler,
 530      METH_VARARGS, default_int_handler_doc},
 531     {NULL,                      NULL}           /* sentinel */
 532 };
 533
 534
 535 PyDoc_STRVAR(module_doc,
 536 "This module provides mechanisms to use signal handlers in Python.\n\
 537 \n\
 538 Functions:\n\
 539 \n\
 540 alarm() -- cause SIGALRM after a specified time [Unix only]\n\
 541 setitimer() -- cause a signal (described below) after a specified\n\
 542                float time and the timer may restart then [Unix only]\n\
 543 getitimer() -- get current value of timer [Unix only]\n\
 544 signal() -- set the action for a given signal\n\
 545 getsignal() -- get the signal action for a given signal\n\
 546 pause() -- wait until a signal arrives [Unix only]\n\
 547 default_int_handler() -- default SIGINT handler\n\
 548 \n\
 549 signal constants:\n\
 550 SIG_DFL -- used to refer to the system default handler\n\
 551 SIG_IGN -- used to ignore the signal\n\
 552 NSIG -- number of defined signals\n\
 553 SIGINT, SIGTERM, etc. -- signal numbers\n\
 554 \n\
 555 itimer constants:\n\
 556 ITIMER_REAL -- decrements in real time, and delivers SIGALRM upon\n\
 557                expiration\n\
 558 ITIMER_VIRTUAL -- decrements only when the process is executing,\n\
 559                and delivers SIGVTALRM upon expiration\n\
 560 ITIMER_PROF -- decrements both when the process is executing and\n\
 561                when the system is executing on behalf of the process.\n\
 562                Coupled with ITIMER_VIRTUAL, this timer is usually\n\
 563                used to profile the time spent by the application\n\
 564                in user and kernel space. SIGPROF is delivered upon\n\
 565                expiration.\n\
 566 \n\n\
 567 *** IMPORTANT NOTICE ***\n\
 568 A signal handler function is called with two arguments:\n\
 569 the first is the signal number, the second is the interrupted stack frame.");
 570
 571 PyMODINIT_FUNC
 572 initsignal(void)
 573 {
 574     PyObject *m, *d, *x;
 575     int i;
 576
 577 #ifdef WITH_THREAD
 578     main_thread = PyThread_get_thread_ident();
 579     main_pid = getpid();
 580 #endif
 581
 582     /* Create the module and add the functions */
 583     m = Py_InitModule3("signal", signal_methods, module_doc);
 584     if (m == NULL)
 585         return;
 586
 587     /* Add some symbolic constants to the module */
 588     d = PyModule_GetDict(m);
 589
 590     x = DefaultHandler = PyLong_FromVoidPtr((void *)SIG_DFL);
 591     if (!x || PyDict_SetItemString(d, "SIG_DFL", x) < 0)
 592         goto finally;
 593
 594     x = IgnoreHandler = PyLong_FromVoidPtr((void *)SIG_IGN);
 595     if (!x || PyDict_SetItemString(d, "SIG_IGN", x) < 0)
 596         goto finally;
 597
 598     x = PyInt_FromLong((long)NSIG);
 599     if (!x || PyDict_SetItemString(d, "NSIG", x) < 0)
 600         goto finally;
 601     Py_DECREF(x);
 602
 603     x = IntHandler = PyDict_GetItemString(d, "default_int_handler");
 604     if (!x)
 605         goto finally;
 606     Py_INCREF(IntHandler);
 607
 608     Handlers[0].tripped = 0;
 609     for (i = 1; i < NSIG; i++) {
 610         void (*t)(int);
 611         t = PyOS_getsig(i);
 612         Handlers[i].tripped = 0;
 613         if (t == SIG_DFL)
 614             Handlers[i].func = DefaultHandler;
 615         else if (t == SIG_IGN)
 616             Handlers[i].func = IgnoreHandler;
 617         else
 618             Handlers[i].func = Py_None; /* None of our business */
 619         Py_INCREF(Handlers[i].func);
 620     }
 621     if (Handlers[SIGINT].func == DefaultHandler) {
 622         /* Install default int handler */
 623         Py_INCREF(IntHandler);
 624         Py_DECREF(Handlers[SIGINT].func);
 625         Handlers[SIGINT].func = IntHandler;
 626         old_siginthandler = PyOS_setsig(SIGINT, signal_handler);
 627     }
 628
 629 #ifdef SIGHUP
 630     x = PyInt_FromLong(SIGHUP);
 631     PyDict_SetItemString(d, "SIGHUP", x);
 632     Py_XDECREF(x);
 633 #endif
 634 #ifdef SIGINT
 635     x = PyInt_FromLong(SIGINT);
 636     PyDict_SetItemString(d, "SIGINT", x);
 637     Py_XDECREF(x);
 638 #endif
 639 #ifdef SIGBREAK
 640     x = PyInt_FromLong(SIGBREAK);
 641     PyDict_SetItemString(d, "SIGBREAK", x);
 642     Py_XDECREF(x);
 643 #endif
 644 #ifdef SIGQUIT
 645     x = PyInt_FromLong(SIGQUIT);
 646     PyDict_SetItemString(d, "SIGQUIT", x);
 647     Py_XDECREF(x);
 648 #endif
 649 #ifdef SIGILL
 650     x = PyInt_FromLong(SIGILL);
 651     PyDict_SetItemString(d, "SIGILL", x);
 652     Py_XDECREF(x);
 653 #endif
 654 #ifdef SIGTRAP
 655     x = PyInt_FromLong(SIGTRAP);
 656     PyDict_SetItemString(d, "SIGTRAP", x);
 657     Py_XDECREF(x);
 658 #endif
 659 #ifdef SIGIOT
 660     x = PyInt_FromLong(SIGIOT);
 661     PyDict_SetItemString(d, "SIGIOT", x);
 662     Py_XDECREF(x);
 663 #endif
 664 #ifdef SIGABRT
 665     x = PyInt_FromLong(SIGABRT);
 666     PyDict_SetItemString(d, "SIGABRT", x);
 667     Py_XDECREF(x);
 668 #endif
 669 #ifdef SIGEMT
 670     x = PyInt_FromLong(SIGEMT);
 671     PyDict_SetItemString(d, "SIGEMT", x);
 672     Py_XDECREF(x);
 673 #endif
 674 #ifdef SIGFPE
 675     x = PyInt_FromLong(SIGFPE);
 676     PyDict_SetItemString(d, "SIGFPE", x);
 677     Py_XDECREF(x);
 678 #endif
 679 #ifdef SIGKILL
 680     x = PyInt_FromLong(SIGKILL);
 681     PyDict_SetItemString(d, "SIGKILL", x);
 682     Py_XDECREF(x);
 683 #endif
 684 #ifdef SIGBUS
 685     x = PyInt_FromLong(SIGBUS);
 686     PyDict_SetItemString(d, "SIGBUS", x);
 687     Py_XDECREF(x);
 688 #endif
 689 #ifdef SIGSEGV
 690     x = PyInt_FromLong(SIGSEGV);
 691     PyDict_SetItemString(d, "SIGSEGV", x);
 692     Py_XDECREF(x);
 693 #endif
 694 #ifdef SIGSYS
 695     x = PyInt_FromLong(SIGSYS);
 696     PyDict_SetItemString(d, "SIGSYS", x);
 697     Py_XDECREF(x);
 698 #endif
 699 #ifdef SIGPIPE
 700     x = PyInt_FromLong(SIGPIPE);
 701     PyDict_SetItemString(d, "SIGPIPE", x);
 702     Py_XDECREF(x);
 703 #endif
 704 #ifdef SIGALRM
 705     x = PyInt_FromLong(SIGALRM);
 706     PyDict_SetItemString(d, "SIGALRM", x);
 707     Py_XDECREF(x);
 708 #endif
 709 #ifdef SIGTERM
 710     x = PyInt_FromLong(SIGTERM);
 711     PyDict_SetItemString(d, "SIGTERM", x);
 712     Py_XDECREF(x);
 713 #endif
 714 #ifdef SIGUSR1
 715     x = PyInt_FromLong(SIGUSR1);
 716     PyDict_SetItemString(d, "SIGUSR1", x);
 717     Py_XDECREF(x);
 718 #endif
 719 #ifdef SIGUSR2
 720     x = PyInt_FromLong(SIGUSR2);
 721     PyDict_SetItemString(d, "SIGUSR2", x);
 722     Py_XDECREF(x);
 723 #endif
 724 #ifdef SIGCLD
 725     x = PyInt_FromLong(SIGCLD);
 726     PyDict_SetItemString(d, "SIGCLD", x);
 727     Py_XDECREF(x);
 728 #endif
 729 #ifdef SIGCHLD
 730     x = PyInt_FromLong(SIGCHLD);
 731     PyDict_SetItemString(d, "SIGCHLD", x);
 732     Py_XDECREF(x);
 733 #endif
 734 #ifdef SIGPWR
 735     x = PyInt_FromLong(SIGPWR);
 736     PyDict_SetItemString(d, "SIGPWR", x);
 737     Py_XDECREF(x);
 738 #endif
 739 #ifdef SIGIO
 740     x = PyInt_FromLong(SIGIO);
 741     PyDict_SetItemString(d, "SIGIO", x);
 742     Py_XDECREF(x);
 743 #endif
 744 #ifdef SIGURG
 745     x = PyInt_FromLong(SIGURG);
 746     PyDict_SetItemString(d, "SIGURG", x);
 747     Py_XDECREF(x);
 748 #endif
 749 #ifdef SIGWINCH
 750     x = PyInt_FromLong(SIGWINCH);
 751     PyDict_SetItemString(d, "SIGWINCH", x);
 752     Py_XDECREF(x);
 753 #endif
 754 #ifdef SIGPOLL
 755     x = PyInt_FromLong(SIGPOLL);
 756     PyDict_SetItemString(d, "SIGPOLL", x);
 757     Py_XDECREF(x);
 758 #endif
 759 #ifdef SIGSTOP
 760     x = PyInt_FromLong(SIGSTOP);
 761     PyDict_SetItemString(d, "SIGSTOP", x);
 762     Py_XDECREF(x);
 763 #endif
 764 #ifdef SIGTSTP
 765     x = PyInt_FromLong(SIGTSTP);
 766     PyDict_SetItemString(d, "SIGTSTP", x);
 767     Py_XDECREF(x);
 768 #endif
 769 #ifdef SIGCONT
 770     x = PyInt_FromLong(SIGCONT);
 771     PyDict_SetItemString(d, "SIGCONT", x);
 772     Py_XDECREF(x);
 773 #endif
 774 #ifdef SIGTTIN
 775     x = PyInt_FromLong(SIGTTIN);
 776     PyDict_SetItemString(d, "SIGTTIN", x);
 777     Py_XDECREF(x);
 778 #endif
 779 #ifdef SIGTTOU
 780     x = PyInt_FromLong(SIGTTOU);
 781     PyDict_SetItemString(d, "SIGTTOU", x);
 782     Py_XDECREF(x);
 783 #endif
 784 #ifdef SIGVTALRM
 785     x = PyInt_FromLong(SIGVTALRM);
 786     PyDict_SetItemString(d, "SIGVTALRM", x);
 787     Py_XDECREF(x);
 788 #endif
 789 #ifdef SIGPROF
 790     x = PyInt_FromLong(SIGPROF);
 791     PyDict_SetItemString(d, "SIGPROF", x);
 792     Py_XDECREF(x);
 793 #endif
 794 #ifdef SIGXCPU
 795     x = PyInt_FromLong(SIGXCPU);
 796     PyDict_SetItemString(d, "SIGXCPU", x);
 797     Py_XDECREF(x);
 798 #endif
 799 #ifdef SIGXFSZ
 800     x = PyInt_FromLong(SIGXFSZ);
 801     PyDict_SetItemString(d, "SIGXFSZ", x);
 802     Py_XDECREF(x);
 803 #endif
 804 #ifdef SIGRTMIN
 805     x = PyInt_FromLong(SIGRTMIN);
 806     PyDict_SetItemString(d, "SIGRTMIN", x);
 807     Py_XDECREF(x);
 808 #endif
 809 #ifdef SIGRTMAX
 810     x = PyInt_FromLong(SIGRTMAX);
 811     PyDict_SetItemString(d, "SIGRTMAX", x);
 812     Py_XDECREF(x);
 813 #endif
 814 #ifdef SIGINFO
 815     x = PyInt_FromLong(SIGINFO);
 816     PyDict_SetItemString(d, "SIGINFO", x);
 817     Py_XDECREF(x);
 818 #endif
 819
 820 #ifdef ITIMER_REAL
 821     x = PyLong_FromLong(ITIMER_REAL);
 822     PyDict_SetItemString(d, "ITIMER_REAL", x);
 823     Py_DECREF(x);
 824 #endif
 825 #ifdef ITIMER_VIRTUAL
 826     x = PyLong_FromLong(ITIMER_VIRTUAL);
 827     PyDict_SetItemString(d, "ITIMER_VIRTUAL", x);
 828     Py_DECREF(x);
 829 #endif
 830 #ifdef ITIMER_PROF
 831     x = PyLong_FromLong(ITIMER_PROF);
 832     PyDict_SetItemString(d, "ITIMER_PROF", x);
 833     Py_DECREF(x);
 834 #endif
 835
 836 #if defined (HAVE_SETITIMER) || defined (HAVE_GETITIMER)
 837     ItimerError = PyErr_NewException("signal.ItimerError",
 838      PyExc_IOError, NULL);
 839     if (ItimerError != NULL)
 840     PyDict_SetItemString(d, "ItimerError", ItimerError);
 841 #endif
 842
 843 #ifdef CTRL_C_EVENT
 844     x = PyInt_FromLong(CTRL_C_EVENT);
 845     PyDict_SetItemString(d, "CTRL_C_EVENT", x);
 846     Py_DECREF(x);
 847 #endif
 848
 849 #ifdef CTRL_BREAK_EVENT
 850     x = PyInt_FromLong(CTRL_BREAK_EVENT);
 851     PyDict_SetItemString(d, "CTRL_BREAK_EVENT", x);
 852     Py_DECREF(x);
 853 #endif
 854
 855     if (!PyErr_Occurred())
 856         return;
 857
 858     /* Check for errors */
 859   finally:
 860     return;
 861 }
 862
 863 static void
 864 finisignal(void)
 865 {
 866     int i;
 867     PyObject *func;
 868
 869     PyOS_setsig(SIGINT, old_siginthandler);
 870     old_siginthandler = SIG_DFL;
 871
 872     for (i = 1; i < NSIG; i++) {
 873         func = Handlers[i].func;
 874         Handlers[i].tripped = 0;
 875         Handlers[i].func = NULL;
 876         if (i != SIGINT && func != NULL && func != Py_None &&
 877             func != DefaultHandler && func != IgnoreHandler)
 878             PyOS_setsig(i, SIG_DFL);
 879         Py_XDECREF(func);
 880     }
 881
 882     Py_XDECREF(IntHandler);
 883     IntHandler = NULL;
 884     Py_XDECREF(DefaultHandler);
 885     DefaultHandler = NULL;
 886     Py_XDECREF(IgnoreHandler);
 887     IgnoreHandler = NULL;
 888 }
 889
 890
 891 /* Declared in pyerrors.h */
 892 int
 893 PyErr_CheckSignals(void)
 894 {
 895     int i;
 896     PyObject *f;
 897
 898     if (!is_tripped)
 899         return 0;
 900
 901 #ifdef WITH_THREAD
 902     if (PyThread_get_thread_ident() != main_thread)
 903         return 0;
 904 #endif
 905
 906     /*
 907      * The is_tripped variable is meant to speed up the calls to
 908      * PyErr_CheckSignals (both directly or via pending calls) when no
 909      * signal has arrived. This variable is set to 1 when a signal arrives
 910      * and it is set to 0 here, when we know some signals arrived. This way
 911      * we can run the registered handlers with no signals blocked.
 912      *
 913      * NOTE: with this approach we can have a situation where is_tripped is
 914      *       1 but we have no more signals to handle (Handlers[i].tripped
 915      *       is 0 for every signal i). This won't do us any harm (except
 916      *       we're gonna spent some cycles for nothing). This happens when
 917      *       we receive a signal i after we zero is_tripped and before we
 918      *       check Handlers[i].tripped.
 919      */
 920     is_tripped = 0;
 921
 922     if (!(f = (PyObject *)PyEval_GetFrame()))
 923         f = Py_None;
 924
 925     for (i = 1; i < NSIG; i++) {
 926         if (Handlers[i].tripped) {
 927             PyObject *result = NULL;
 928             PyObject *arglist = Py_BuildValue("(iO)", i, f);
 929             Handlers[i].tripped = 0;
 930
 931             if (arglist) {
 932                 result = PyEval_CallObject(Handlers[i].func,
 933                                            arglist);
 934                 Py_DECREF(arglist);
 935             }
 936             if (!result)
 937                 return -1;
 938
 939             Py_DECREF(result);
 940         }
 941     }
 942
 943     return 0;
 944 }
 945
 946
 947 /* Replacements for intrcheck.c functionality
 948  * Declared in pyerrors.h
 949  */
 950 void
 951 PyErr_SetInterrupt(void)
 952 {
 953     trip_signal(SIGINT);
 954 }
 955
 956 void
 957 PyOS_InitInterrupts(void)
 958 {
 959     initsignal();
 960     _PyImport_FixupExtension("signal", "signal");
 961 }
 962
 963 void
 964 PyOS_FiniInterrupts(void)
 965 {
 966     finisignal();
 967 }
 968
 969 int
 970 PyOS_InterruptOccurred(void)
 971 {
 972     if (Handlers[SIGINT].tripped) {
 973 #ifdef WITH_THREAD
 974         if (PyThread_get_thread_ident() != main_thread)
 975             return 0;
 976 #endif
 977         Handlers[SIGINT].tripped = 0;
 978         return 1;
 979     }
 980     return 0;
 981 }
 982
 983 static void
 984 _clear_pending_signals(void)
 985 {
 986     int i;
 987     if (!is_tripped)
 988         return;
 989     is_tripped = 0;
 990     for (i = 1; i < NSIG; ++i) {
 991         Handlers[i].tripped = 0;
 992     }
 993 }
 994
 995 void
 996 PyOS_AfterFork(void)
 997 {
 998     /* Clear the signal flags after forking so that they aren't handled
 999      * in both processes if they came in just before the fork() but before
1000      * the interpreter had an opportunity to call the handlers.  issue9535. */
1001     _clear_pending_signals();
1002 #ifdef WITH_THREAD
1003     /* PyThread_ReInitTLS() must be called early, to make sure that the TLS API
1004      * can be called safely. */
1005     PyThread_ReInitTLS();
1006     PyEval_ReInitThreads();
1007     main_thread = PyThread_get_thread_ident();
1008     main_pid = getpid();
1009     _PyImport_ReInitLock();
1010 #endif
1011 }