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