Modules/signalmodule.c

   1 /***********************************************************
   2 Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
   3 The Netherlands.
   4
   5                         All Rights Reserved
   6
   7 Permission to use, copy, modify, and distribute this software and its
   8 documentation for any purpose and without fee is hereby granted,
   9 provided that the above copyright notice appear in all copies and that
  10 both that copyright notice and this permission notice appear in
  11 supporting documentation, and that the names of Stichting Mathematisch
  12 Centrum or CWI or Corporation for National Research Initiatives or
  13 CNRI not be used in advertising or publicity pertaining to
  14 distribution of the software without specific, written prior
  15 permission.
  16
  17 While CWI is the initial source for this software, a modified version
  18 is made available by the Corporation for National Research Initiatives
  19 (CNRI) at the Internet address ftp://ftp.python.org.
  20
  21 STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
  22 REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
  23 MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
  24 CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  25 DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  26 PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  27 TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  28 PERFORMANCE OF THIS SOFTWARE.
  29
  30 ******************************************************************/
  31
  32 /* Signal module -- many thanks to Lance Ellinghaus */
  33
  34 /* XXX Signals should be recorded per thread, now we have thread state. */
  35
  36 #include "Python.h"
  37 #include "intrcheck.h"
  38
  39 #ifdef MS_WIN32
  40 #include <process.h>
  41 #endif
  42
  43 #ifdef HAVE_UNISTD_H
  44 #include <unistd.h>
  45 #endif
  46
  47 #include <signal.h>
  48
  49 #ifndef SIG_ERR
  50 #define SIG_ERR ((RETSIGTYPE (*)())-1)
  51 #endif
  52
  53 #if defined(PYOS_OS2)
  54 #define NSIG 12
  55 #include <process.h>
  56 #endif
  57
  58 #ifndef NSIG
  59 #ifdef _SIGMAX
  60 #define NSIG (_SIGMAX + 1)      /* For QNX */
  61 #else
  62 #define NSIG (SIGMAX + 1)       /* for djgpp */
  63 #endif
  64 #endif
  65
  66
  67 \f
  68 /*
  69    NOTES ON THE INTERACTION BETWEEN SIGNALS AND THREADS
  70
  71    When threads are supported, we want the following semantics:
  72
  73    - only the main thread can set a signal handler
  74    - any thread can get a signal handler
  75    - signals are only delivered to the main thread
  76
  77    I.e. we don't support "synchronous signals" like SIGFPE (catching
  78    this doesn't make much sense in Python anyway) nor do we support
  79    signals as a means of inter-thread communication, since not all
  80    thread implementations support that (at least our thread library
  81    doesn't).
  82
  83    We still have the problem that in some implementations signals
  84    generated by the keyboard (e.g. SIGINT) are delivered to all
  85    threads (e.g. SGI), while in others (e.g. Solaris) such signals are
  86    delivered to one random thread (an intermediate possibility would
  87    be to deliver it to the main thread -- POSIX?).  For now, we have
  88    a working implementation that works in all three cases -- the
  89    handler ignores signals if getpid() isn't the same as in the main
  90    thread.  XXX This is a hack.
  91
  92 */
  93
  94 #ifdef WITH_THREAD
  95 #include <sys/types.h> /* For pid_t */
  96 #include "pythread.h"
  97 static long main_thread;
  98 static pid_t main_pid;
  99 #endif
 100
 101 static struct {
 102         int tripped;
 103         PyObject *func;
 104 } Handlers[NSIG];
 105
 106 static int is_tripped = 0; /* Speed up sigcheck() when none tripped */
 107
 108 static PyObject *DefaultHandler;
 109 static PyObject *IgnoreHandler;
 110 static PyObject *IntHandler;
 111
 112 static RETSIGTYPE (*old_siginthandler)() = SIG_DFL;
 113
 114
 115 \f
 116 static PyObject *
 117 signal_default_int_handler(self, arg)
 118         PyObject *self;
 119         PyObject *arg;
 120 {
 121         PyErr_SetNone(PyExc_KeyboardInterrupt);
 122         return NULL;
 123 }
 124
 125 static char default_int_handler_doc[] =
 126 "default_int_handler(...)\n\
 127 \n\
 128 The default handler for SIGINT instated by Python.\n\
 129 It raises KeyboardInterrupt.";
 130
 131 \f
 132 static RETSIGTYPE
 133 signal_handler(sig_num)
 134         int sig_num;
 135 {
 136 #ifdef WITH_THREAD
 137         /* See NOTES section above */
 138         if (getpid() == main_pid) {
 139 #endif
 140                 is_tripped++;
 141                 Handlers[sig_num].tripped = 1;
 142                 Py_AddPendingCall(
 143                         (int (*) Py_PROTO((ANY *)))PyErr_CheckSignals, NULL);
 144 #ifdef WITH_THREAD
 145         }
 146 #endif
 147 #ifdef SIGCHLD
 148         if (sig_num == SIGCHLD) {
 149                 /* To avoid infinite recursion, this signal remains
 150                    reset until explicit re-instated.
 151                    Don't clear the 'func' field as it is our pointer
 152                    to the Python handler... */
 153                 return;
 154         }
 155 #endif
 156 #ifdef HAVE_SIGINTERRUPT
 157         siginterrupt(sig_num, 1);
 158 #endif
 159         (void)signal(sig_num, &signal_handler);
 160 }
 161
 162
 163 \f
 164 #ifdef HAVE_ALARM
 165 static PyObject *
 166 signal_alarm(self, args)
 167         PyObject *self; /* Not used */
 168         PyObject *args;
 169 {
 170         int t;
 171         if (!PyArg_Parse(args, "i", &t))
 172                 return NULL;
 173         /* alarm() returns the number of seconds remaining */
 174         return PyInt_FromLong(alarm(t));
 175 }
 176
 177 static char alarm_doc[] =
 178 "alarm(seconds)\n\
 179 \n\
 180 Arrange for SIGALRM to arrive after the given number of seconds.";
 181 #endif
 182
 183 #ifdef HAVE_PAUSE
 184 static PyObject *
 185 signal_pause(self, args)
 186         PyObject *self; /* Not used */
 187         PyObject *args;
 188 {
 189         if (!PyArg_NoArgs(args))
 190                 return NULL;
 191
 192         Py_BEGIN_ALLOW_THREADS
 193         (void)pause();
 194         Py_END_ALLOW_THREADS
 195         /* make sure that any exceptions that got raised are propagated
 196          * back into Python
 197          */
 198         if (PyErr_CheckSignals())
 199                 return NULL;
 200
 201         Py_INCREF(Py_None);
 202         return Py_None;
 203 }
 204 static char pause_doc[] =
 205 "pause()\n\
 206 \n\
 207 Wait until a signal arrives.";
 208
 209 #endif
 210
 211 \f
 212 static PyObject *
 213 signal_signal(self, args)
 214         PyObject *self; /* Not used */
 215         PyObject *args;
 216 {
 217         PyObject *obj;
 218         int sig_num;
 219         PyObject *old_handler;
 220         RETSIGTYPE (*func)();
 221         if (!PyArg_Parse(args, "(iO)", &sig_num, &obj))
 222                 return NULL;
 223 #ifdef WITH_THREAD
 224         if (PyThread_get_thread_ident() != main_thread) {
 225                 PyErr_SetString(PyExc_ValueError,
 226                                 "signal only works in main thread");
 227                 return NULL;
 228         }
 229 #endif
 230         if (sig_num < 1 || sig_num >= NSIG) {
 231                 PyErr_SetString(PyExc_ValueError,
 232                                 "signal number out of range");
 233                 return NULL;
 234         }
 235         if (obj == IgnoreHandler)
 236                 func = SIG_IGN;
 237         else if (obj == DefaultHandler)
 238                 func = SIG_DFL;
 239         else if (!PyCallable_Check(obj)) {
 240                 PyErr_SetString(PyExc_TypeError,
 241 "signal handler must be signal.SIG_IGN, signal.SIG_DFL, or a callable object");
 242                 return NULL;
 243         }
 244         else
 245                 func = signal_handler;
 246 #ifdef HAVE_SIGINTERRUPT
 247         siginterrupt(sig_num, 1);
 248 #endif
 249         if (signal(sig_num, func) == SIG_ERR) {
 250                 PyErr_SetFromErrno(PyExc_RuntimeError);
 251                 return NULL;
 252         }
 253         old_handler = Handlers[sig_num].func;
 254         Handlers[sig_num].tripped = 0;
 255         Py_INCREF(obj);
 256         Handlers[sig_num].func = obj;
 257         return old_handler;
 258 }
 259
 260 static char signal_doc[] =
 261 "signal(sig, action) -> action\n\
 262 \n\
 263 Set the action for the given signal.  The action can be SIG_DFL,\n\
 264 SIG_IGN, or a callable Python object.  The previous action is\n\
 265 returned.  See getsignal() for possible return values.\n\
 266 \n\
 267 *** IMPORTANT NOTICE ***\n\
 268 A signal handler function is called with two arguments:\n\
 269 the first is the signal number, the second is the interrupted stack frame.";
 270
 271 \f
 272 static PyObject *
 273 signal_getsignal(self, args)
 274         PyObject *self; /* Not used */
 275         PyObject *args;
 276 {
 277         int sig_num;
 278         PyObject *old_handler;
 279         if (!PyArg_Parse(args, "i", &sig_num))
 280                 return NULL;
 281         if (sig_num < 1 || sig_num >= NSIG) {
 282                 PyErr_SetString(PyExc_ValueError,
 283                                 "signal number out of range");
 284                 return NULL;
 285         }
 286         old_handler = Handlers[sig_num].func;
 287         Py_INCREF(old_handler);
 288         return old_handler;
 289 }
 290
 291 static char getsignal_doc[] =
 292 "getsignal(sig) -> action\n\
 293 \n\
 294 Return the current action for the given signal.  The return value can be:\n\
 295 SIG_IGN -- if the signal is being ignored\n\
 296 SIG_DFL -- if the default action for the signal is in effect\n\
 297 None -- if an unknown handler is in effect\n\
 298 anything else -- the callable Python object used as a handler\n\
 299 ";
 300
 301 \f
 302 /* List of functions defined in the module */
 303 static PyMethodDef signal_methods[] = {
 304 #ifdef HAVE_ALARM
 305         {"alarm",               signal_alarm, 0, alarm_doc},
 306 #endif
 307         {"signal",              signal_signal, 0, signal_doc},
 308         {"getsignal",           signal_getsignal, 0, getsignal_doc},
 309 #ifdef HAVE_PAUSE
 310         {"pause",               signal_pause, 0, pause_doc},
 311 #endif
 312         {"default_int_handler", signal_default_int_handler, 0,
 313                                 default_int_handler_doc},
 314         {NULL,                  NULL}           /* sentinel */
 315 };
 316
 317
 318 \f
 319 static char module_doc[] =
 320 "This module provides mechanisms to use signal handlers in Python.\n\
 321 \n\
 322 Functions:\n\
 323 \n\
 324 alarm() -- cause SIGALRM after a specified time [Unix only]\n\
 325 signal() -- set the action for a given signal\n\
 326 getsignal() -- get the signal action for a given signal\n\
 327 pause() -- wait until a signal arrives [Unix only]\n\
 328 default_int_handler() -- default SIGINT handler\n\
 329 \n\
 330 Constants:\n\
 331 \n\
 332 SIG_DFL -- used to refer to the system default handler\n\
 333 SIG_IGN -- used to ignore the signal\n\
 334 NSIG -- number of defined signals\n\
 335 \n\
 336 SIGINT, SIGTERM, etc. -- signal numbers\n\
 337 \n\
 338 *** IMPORTANT NOTICE ***\n\
 339 A signal handler function is called with two arguments:\n\
 340 the first is the signal number, the second is the interrupted stack frame.";
 341
 342 DL_EXPORT(void)
 343 initsignal()
 344 {
 345         PyObject *m, *d, *x;
 346         int i;
 347
 348 #ifdef WITH_THREAD
 349         main_thread = PyThread_get_thread_ident();
 350         main_pid = getpid();
 351 #endif
 352
 353         /* Create the module and add the functions */
 354         m = Py_InitModule3("signal", signal_methods, module_doc);
 355
 356         /* Add some symbolic constants to the module */
 357         d = PyModule_GetDict(m);
 358
 359         x = DefaultHandler = PyInt_FromLong((long)SIG_DFL);
 360         if (!x || PyDict_SetItemString(d, "SIG_DFL", x) < 0)
 361                 goto finally;
 362
 363         x = IgnoreHandler = PyInt_FromLong((long)SIG_IGN);
 364         if (!x || PyDict_SetItemString(d, "SIG_IGN", x) < 0)
 365                 goto finally;
 366
 367         x = PyInt_FromLong((long)NSIG);
 368         if (!x || PyDict_SetItemString(d, "NSIG", x) < 0)
 369                 goto finally;
 370         Py_DECREF(x);
 371
 372         x = IntHandler = PyDict_GetItemString(d, "default_int_handler");
 373         if (!x)
 374                 goto finally;
 375         Py_INCREF(IntHandler);
 376
 377         Handlers[0].tripped = 0;
 378         for (i = 1; i < NSIG; i++) {
 379                 RETSIGTYPE (*t)();
 380 #ifdef HAVE_SIGACTION
 381                 struct sigaction act;
 382                 sigaction(i,  0, &act);
 383                 t = act.sa_handler;
 384 #else
 385                 t = signal(i, SIG_IGN);
 386                 signal(i, t);
 387 #endif
 388                 Handlers[i].tripped = 0;
 389                 if (t == SIG_DFL)
 390                         Handlers[i].func = DefaultHandler;
 391                 else if (t == SIG_IGN)
 392                         Handlers[i].func = IgnoreHandler;
 393                 else
 394                         Handlers[i].func = Py_None; /* None of our business */
 395                 Py_INCREF(Handlers[i].func);
 396         }
 397         if (Handlers[SIGINT].func == DefaultHandler) {
 398                 /* Install default int handler */
 399                 Py_INCREF(IntHandler);
 400                 Py_DECREF(Handlers[SIGINT].func);
 401                 Handlers[SIGINT].func = IntHandler;
 402                 old_siginthandler = signal(SIGINT, &signal_handler);
 403         }
 404
 405 #ifdef SIGHUP
 406         x = PyInt_FromLong(SIGHUP);
 407         PyDict_SetItemString(d, "SIGHUP", x);
 408         Py_XDECREF(x);
 409 #endif
 410 #ifdef SIGINT
 411         x = PyInt_FromLong(SIGINT);
 412         PyDict_SetItemString(d, "SIGINT", x);
 413         Py_XDECREF(x);
 414 #endif
 415 #ifdef SIGQUIT
 416         x = PyInt_FromLong(SIGQUIT);
 417         PyDict_SetItemString(d, "SIGQUIT", x);
 418         Py_XDECREF(x);
 419 #endif
 420 #ifdef SIGILL
 421         x = PyInt_FromLong(SIGILL);
 422         PyDict_SetItemString(d, "SIGILL", x);
 423         Py_XDECREF(x);
 424 #endif
 425 #ifdef SIGTRAP
 426         x = PyInt_FromLong(SIGTRAP);
 427         PyDict_SetItemString(d, "SIGTRAP", x);
 428         Py_XDECREF(x);
 429 #endif
 430 #ifdef SIGIOT
 431         x = PyInt_FromLong(SIGIOT);
 432         PyDict_SetItemString(d, "SIGIOT", x);
 433         Py_XDECREF(x);
 434 #endif
 435 #ifdef SIGABRT
 436         x = PyInt_FromLong(SIGABRT);
 437         PyDict_SetItemString(d, "SIGABRT", x);
 438         Py_XDECREF(x);
 439 #endif
 440 #ifdef SIGEMT
 441         x = PyInt_FromLong(SIGEMT);
 442         PyDict_SetItemString(d, "SIGEMT", x);
 443         Py_XDECREF(x);
 444 #endif
 445 #ifdef SIGFPE
 446         x = PyInt_FromLong(SIGFPE);
 447         PyDict_SetItemString(d, "SIGFPE", x);
 448         Py_XDECREF(x);
 449 #endif
 450 #ifdef SIGKILL
 451         x = PyInt_FromLong(SIGKILL);
 452         PyDict_SetItemString(d, "SIGKILL", x);
 453         Py_XDECREF(x);
 454 #endif
 455 #ifdef SIGBUS
 456         x = PyInt_FromLong(SIGBUS);
 457         PyDict_SetItemString(d, "SIGBUS", x);
 458         Py_XDECREF(x);
 459 #endif
 460 #ifdef SIGSEGV
 461         x = PyInt_FromLong(SIGSEGV);
 462         PyDict_SetItemString(d, "SIGSEGV", x);
 463         Py_XDECREF(x);
 464 #endif
 465 #ifdef SIGSYS
 466         x = PyInt_FromLong(SIGSYS);
 467         PyDict_SetItemString(d, "SIGSYS", x);
 468         Py_XDECREF(x);
 469 #endif
 470 #ifdef SIGPIPE
 471         x = PyInt_FromLong(SIGPIPE);
 472         PyDict_SetItemString(d, "SIGPIPE", x);
 473         Py_XDECREF(x);
 474 #endif
 475 #ifdef SIGALRM
 476         x = PyInt_FromLong(SIGALRM);
 477         PyDict_SetItemString(d, "SIGALRM", x);
 478         Py_XDECREF(x);
 479 #endif
 480 #ifdef SIGTERM
 481         x = PyInt_FromLong(SIGTERM);
 482         PyDict_SetItemString(d, "SIGTERM", x);
 483         Py_XDECREF(x);
 484 #endif
 485 #ifdef SIGUSR1
 486         x = PyInt_FromLong(SIGUSR1);
 487         PyDict_SetItemString(d, "SIGUSR1", x);
 488         Py_XDECREF(x);
 489 #endif
 490 #ifdef SIGUSR2
 491         x = PyInt_FromLong(SIGUSR2);
 492         PyDict_SetItemString(d, "SIGUSR2", x);
 493         Py_XDECREF(x);
 494 #endif
 495 #ifdef SIGCLD
 496         x = PyInt_FromLong(SIGCLD);
 497         PyDict_SetItemString(d, "SIGCLD", x);
 498         Py_XDECREF(x);
 499 #endif
 500 #ifdef SIGCHLD
 501         x = PyInt_FromLong(SIGCHLD);
 502         PyDict_SetItemString(d, "SIGCHLD", x);
 503         Py_XDECREF(x);
 504 #endif
 505 #ifdef SIGPWR
 506         x = PyInt_FromLong(SIGPWR);
 507         PyDict_SetItemString(d, "SIGPWR", x);
 508         Py_XDECREF(x);
 509 #endif
 510 #ifdef SIGIO
 511         x = PyInt_FromLong(SIGIO);
 512         PyDict_SetItemString(d, "SIGIO", x);
 513         Py_XDECREF(x);
 514 #endif
 515 #ifdef SIGURG
 516         x = PyInt_FromLong(SIGURG);
 517         PyDict_SetItemString(d, "SIGURG", x);
 518         Py_XDECREF(x);
 519 #endif
 520 #ifdef SIGWINCH
 521         x = PyInt_FromLong(SIGWINCH);
 522         PyDict_SetItemString(d, "SIGWINCH", x);
 523         Py_XDECREF(x);
 524 #endif
 525 #ifdef SIGPOLL
 526         x = PyInt_FromLong(SIGPOLL);
 527         PyDict_SetItemString(d, "SIGPOLL", x);
 528         Py_XDECREF(x);
 529 #endif
 530 #ifdef SIGSTOP
 531         x = PyInt_FromLong(SIGSTOP);
 532         PyDict_SetItemString(d, "SIGSTOP", x);
 533         Py_XDECREF(x);
 534 #endif
 535 #ifdef SIGTSTP
 536         x = PyInt_FromLong(SIGTSTP);
 537         PyDict_SetItemString(d, "SIGTSTP", x);
 538         Py_XDECREF(x);
 539 #endif
 540 #ifdef SIGCONT
 541         x = PyInt_FromLong(SIGCONT);
 542         PyDict_SetItemString(d, "SIGCONT", x);
 543         Py_XDECREF(x);
 544 #endif
 545 #ifdef SIGTTIN
 546         x = PyInt_FromLong(SIGTTIN);
 547         PyDict_SetItemString(d, "SIGTTIN", x);
 548         Py_XDECREF(x);
 549 #endif
 550 #ifdef SIGTTOU
 551         x = PyInt_FromLong(SIGTTOU);
 552         PyDict_SetItemString(d, "SIGTTOU", x);
 553         Py_XDECREF(x);
 554 #endif
 555 #ifdef SIGVTALRM
 556         x = PyInt_FromLong(SIGVTALRM);
 557         PyDict_SetItemString(d, "SIGVTALRM", x);
 558         Py_XDECREF(x);
 559 #endif
 560 #ifdef SIGPROF
 561         x = PyInt_FromLong(SIGPROF);
 562         PyDict_SetItemString(d, "SIGPROF", x);
 563         Py_XDECREF(x);
 564 #endif
 565 #ifdef SIGXCPU
 566         x = PyInt_FromLong(SIGXCPU);
 567         PyDict_SetItemString(d, "SIGXCPU", x);
 568         Py_XDECREF(x);
 569 #endif
 570 #ifdef SIGXFSZ
 571         x = PyInt_FromLong(SIGXFSZ);
 572         PyDict_SetItemString(d, "SIGXFSZ", x);
 573         Py_XDECREF(x);
 574 #endif
 575         if (!PyErr_Occurred())
 576                 return;
 577
 578         /* Check for errors */
 579   finally:
 580         return;
 581 }
 582
 583 static void
 584 finisignal()
 585 {
 586         int i;
 587         PyObject *func;
 588
 589         signal(SIGINT, old_siginthandler);
 590         old_siginthandler = SIG_DFL;
 591
 592         for (i = 1; i < NSIG; i++) {
 593                 func = Handlers[i].func;
 594                 Handlers[i].tripped = 0;
 595                 Handlers[i].func = NULL;
 596                 if (i != SIGINT && func != NULL && func != Py_None &&
 597                     func != DefaultHandler && func != IgnoreHandler)
 598                         signal(i, SIG_DFL);
 599                 Py_XDECREF(func);
 600         }
 601
 602         Py_XDECREF(IntHandler);
 603         IntHandler = NULL;
 604         Py_XDECREF(DefaultHandler);
 605         DefaultHandler = NULL;
 606         Py_XDECREF(IgnoreHandler);
 607         IgnoreHandler = NULL;
 608 }
 609
 610
 611 \f
 612 /* Declared in pyerrors.h */
 613 int
 614 PyErr_CheckSignals()
 615 {
 616         int i;
 617         PyObject *f;
 618
 619         if (!is_tripped)
 620                 return 0;
 621 #ifdef WITH_THREAD
 622         if (PyThread_get_thread_ident() != main_thread)
 623                 return 0;
 624 #endif
 625         if (!(f = PyEval_GetFrame()))
 626                 f = Py_None;
 627
 628         for (i = 1; i < NSIG; i++) {
 629                 if (Handlers[i].tripped) {
 630                         PyObject *result = NULL;
 631                         PyObject *arglist = Py_BuildValue("(iO)", i, f);
 632                         Handlers[i].tripped = 0;
 633
 634                         if (arglist) {
 635                                 result = PyEval_CallObject(Handlers[i].func,
 636                                                            arglist);
 637                                 Py_DECREF(arglist);
 638                         }
 639                         if (!result)
 640                                 return -1;
 641
 642                         Py_DECREF(result);
 643                 }
 644         }
 645         is_tripped = 0;
 646         return 0;
 647 }
 648
 649 \f
 650 /* Replacements for intrcheck.c functionality
 651  * Declared in pyerrors.h
 652  */
 653 void
 654 PyErr_SetInterrupt()
 655 {
 656         is_tripped++;
 657         Handlers[SIGINT].tripped = 1;
 658         Py_AddPendingCall((int (*) Py_PROTO((ANY *)))PyErr_CheckSignals, NULL);
 659 }
 660
 661 void
 662 PyOS_InitInterrupts()
 663 {
 664         initsignal();
 665         _PyImport_FixupExtension("signal", "signal");
 666 }
 667
 668 void
 669 PyOS_FiniInterrupts()
 670 {
 671         finisignal();
 672 }
 673
 674 int
 675 PyOS_InterruptOccurred()
 676 {
 677         if (Handlers[SIGINT].tripped) {
 678 #ifdef WITH_THREAD
 679                 if (PyThread_get_thread_ident() != main_thread)
 680                         return 0;
 681 #endif
 682                 Handlers[SIGINT].tripped = 0;
 683                 return 1;
 684         }
 685         return 0;
 686 }
 687
 688 void
 689 PyOS_AfterFork()
 690 {
 691 #ifdef WITH_THREAD
 692         main_thread = PyThread_get_thread_ident();
 693         main_pid = getpid();
 694 #endif
 695 }