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