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 #ifdef HAVE_GETITIMER
99 static PyObject *ItimerError;
100
101 /* auxiliary functions for setitimer/getitimer */
102 static void
timeval_from_double(double d,struct timeval * tv)103 timeval_from_double(double d, struct timeval *tv)
104 {
105 tv->tv_sec = floor(d);
106 tv->tv_usec = fmod(d, 1.0) * 1000000.0;
107 /* Don't disable the timer if the computation above rounds down to zero. */
108 if (d > 0.0 && tv->tv_sec == 0 && tv->tv_usec == 0) {
109 tv->tv_usec = 1;
110 }
111 }
112
113 Py_LOCAL_INLINE(double)
double_from_timeval(struct timeval * tv)114 double_from_timeval(struct timeval *tv)
115 {
116 return tv->tv_sec + (double)(tv->tv_usec / 1000000.0);
117 }
118
119 static PyObject *
itimer_retval(struct itimerval * iv)120 itimer_retval(struct itimerval *iv)
121 {
122 PyObject *r, *v;
123
124 r = PyTuple_New(2);
125 if (r == NULL)
126 return NULL;
127
128 if(!(v = PyFloat_FromDouble(double_from_timeval(&iv->it_value)))) {
129 Py_DECREF(r);
130 return NULL;
131 }
132
133 PyTuple_SET_ITEM(r, 0, v);
134
135 if(!(v = PyFloat_FromDouble(double_from_timeval(&iv->it_interval)))) {
136 Py_DECREF(r);
137 return NULL;
138 }
139
140 PyTuple_SET_ITEM(r, 1, v);
141
142 return r;
143 }
144 #endif
145
146 static PyObject *
signal_default_int_handler(PyObject * self,PyObject * args)147 signal_default_int_handler(PyObject *self, PyObject *args)
148 {
149 PyErr_SetNone(PyExc_KeyboardInterrupt);
150 return NULL;
151 }
152
153 PyDoc_STRVAR(default_int_handler_doc,
154 "default_int_handler(...)\n\
155 \n\
156 The default handler for SIGINT installed by Python.\n\
157 It raises KeyboardInterrupt.");
158
159
160 static int
checksignals_witharg(void * unused)161 checksignals_witharg(void * unused)
162 {
163 return PyErr_CheckSignals();
164 }
165
166 static void
trip_signal(int sig_num)167 trip_signal(int sig_num)
168 {
169 Handlers[sig_num].tripped = 1;
170 if (is_tripped)
171 return;
172 /* Set is_tripped after setting .tripped, as it gets
173 cleared in PyErr_CheckSignals() before .tripped. */
174 is_tripped = 1;
175 Py_AddPendingCall(checksignals_witharg, NULL);
176 if (wakeup_fd != -1)
177 write(wakeup_fd, "\0", 1);
178 }
179
180 static void
signal_handler(int sig_num)181 signal_handler(int sig_num)
182 {
183 int save_errno = errno;
184
185 #if defined(WITH_THREAD) && defined(WITH_PTH)
186 if (PyThread_get_thread_ident() != main_thread) {
187 pth_raise(*(pth_t *) main_thread, sig_num);
188 }
189 else
190 #endif
191 {
192 #ifdef WITH_THREAD
193 /* See NOTES section above */
194 if (getpid() == main_pid)
195 #endif
196 {
197 trip_signal(sig_num);
198 }
199
200 #ifndef HAVE_SIGACTION
201 #ifdef SIGCHLD
202 /* To avoid infinite recursion, this signal remains
203 reset until explicit re-instated.
204 Don't clear the 'func' field as it is our pointer
205 to the Python handler... */
206 if (sig_num != SIGCHLD)
207 #endif
208 /* If the handler was not set up with sigaction, reinstall it. See
209 * Python/pythonrun.c for the implementation of PyOS_setsig which
210 * makes this true. See also issue8354. */
211 PyOS_setsig(sig_num, signal_handler);
212 #endif
213 }
214
215 /* Issue #10311: asynchronously executing signal handlers should not
216 mutate errno under the feet of unsuspecting C code. */
217 errno = save_errno;
218 }
219
220
221 #ifdef HAVE_ALARM
222 static PyObject *
signal_alarm(PyObject * self,PyObject * args)223 signal_alarm(PyObject *self, PyObject *args)
224 {
225 int t;
226 if (!PyArg_ParseTuple(args, "i:alarm", &t))
227 return NULL;
228 /* alarm() returns the number of seconds remaining */
229 return PyInt_FromLong((long)alarm(t));
230 }
231
232 PyDoc_STRVAR(alarm_doc,
233 "alarm(seconds)\n\
234 \n\
235 Arrange for SIGALRM to arrive after the given number of seconds.");
236 #endif
237
238 #ifdef HAVE_PAUSE
239 static PyObject *
signal_pause(PyObject * self)240 signal_pause(PyObject *self)
241 {
242 Py_BEGIN_ALLOW_THREADS
243 (void)pause();
244 Py_END_ALLOW_THREADS
245 /* make sure that any exceptions that got raised are propagated
246 * back into Python
247 */
248 if (PyErr_CheckSignals())
249 return NULL;
250
251 Py_INCREF(Py_None);
252 return Py_None;
253 }
254 PyDoc_STRVAR(pause_doc,
255 "pause()\n\
256 \n\
257 Wait until a signal arrives.");
258
259 #endif
260
261
262 static PyObject *
signal_signal(PyObject * self,PyObject * args)263 signal_signal(PyObject *self, PyObject *args)
264 {
265 PyObject *obj;
266 int sig_num;
267 PyObject *old_handler;
268 void (*func)(int);
269 if (!PyArg_ParseTuple(args, "iO:signal", &sig_num, &obj))
270 return NULL;
271 #ifdef MS_WINDOWS
272 /* Validate that sig_num is one of the allowable signals */
273 switch (sig_num) {
274 case SIGABRT: break;
275 #ifdef SIGBREAK
276 /* Issue #10003: SIGBREAK is not documented as permitted, but works
277 and corresponds to CTRL_BREAK_EVENT. */
278 case SIGBREAK: break;
279 #endif
280 case SIGFPE: break;
281 case SIGILL: break;
282 case SIGINT: break;
283 case SIGSEGV: break;
284 case SIGTERM: break;
285 default:
286 PyErr_SetString(PyExc_ValueError, "invalid signal value");
287 return NULL;
288 }
289 #endif
290 #ifdef WITH_THREAD
291 if (PyThread_get_thread_ident() != main_thread) {
292 PyErr_SetString(PyExc_ValueError,
293 "signal only works in main thread");
294 return NULL;
295 }
296 #endif
297 if (sig_num < 1 || sig_num >= NSIG) {
298 PyErr_SetString(PyExc_ValueError,
299 "signal number out of range");
300 return NULL;
301 }
302 if (obj == IgnoreHandler)
303 func = SIG_IGN;
304 else if (obj == DefaultHandler)
305 func = SIG_DFL;
306 else if (!PyCallable_Check(obj)) {
307 PyErr_SetString(PyExc_TypeError,
308 "signal handler must be signal.SIG_IGN, signal.SIG_DFL, or a callable object");
309 return NULL;
310 }
311 else
312 func = signal_handler;
313 /* Check for pending signals before changing signal handler */
314 if (PyErr_CheckSignals()) {
315 return NULL;
316 }
317 if (PyOS_setsig(sig_num, func) == SIG_ERR) {
318 PyErr_SetFromErrno(PyExc_RuntimeError);
319 return NULL;
320 }
321 old_handler = Handlers[sig_num].func;
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 *
signal_getsignal(PyObject * self,PyObject * args)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 *
signal_siginterrupt(PyObject * self,PyObject * args)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 *
signal_set_wakeup_fd(PyObject * self,PyObject * args)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
PySignal_SetWakeupFd(int fd)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 *
signal_setitimer(PyObject * self,PyObject * args)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 *
signal_getitimer(PyObject * self,PyObject * args)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
initsignal(void)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_SETREF(Handlers[SIGINT].func, IntHandler);
625 PyOS_setsig(SIGINT, signal_handler);
626 }
627
628 #ifdef SIGHUP
629 x = PyInt_FromLong(SIGHUP);
630 PyDict_SetItemString(d, "SIGHUP", x);
631 Py_XDECREF(x);
632 #endif
633 #ifdef SIGINT
634 x = PyInt_FromLong(SIGINT);
635 PyDict_SetItemString(d, "SIGINT", x);
636 Py_XDECREF(x);
637 #endif
638 #ifdef SIGBREAK
639 x = PyInt_FromLong(SIGBREAK);
640 PyDict_SetItemString(d, "SIGBREAK", x);
641 Py_XDECREF(x);
642 #endif
643 #ifdef SIGQUIT
644 x = PyInt_FromLong(SIGQUIT);
645 PyDict_SetItemString(d, "SIGQUIT", x);
646 Py_XDECREF(x);
647 #endif
648 #ifdef SIGILL
649 x = PyInt_FromLong(SIGILL);
650 PyDict_SetItemString(d, "SIGILL", x);
651 Py_XDECREF(x);
652 #endif
653 #ifdef SIGTRAP
654 x = PyInt_FromLong(SIGTRAP);
655 PyDict_SetItemString(d, "SIGTRAP", x);
656 Py_XDECREF(x);
657 #endif
658 #ifdef SIGIOT
659 x = PyInt_FromLong(SIGIOT);
660 PyDict_SetItemString(d, "SIGIOT", x);
661 Py_XDECREF(x);
662 #endif
663 #ifdef SIGABRT
664 x = PyInt_FromLong(SIGABRT);
665 PyDict_SetItemString(d, "SIGABRT", x);
666 Py_XDECREF(x);
667 #endif
668 #ifdef SIGEMT
669 x = PyInt_FromLong(SIGEMT);
670 PyDict_SetItemString(d, "SIGEMT", x);
671 Py_XDECREF(x);
672 #endif
673 #ifdef SIGFPE
674 x = PyInt_FromLong(SIGFPE);
675 PyDict_SetItemString(d, "SIGFPE", x);
676 Py_XDECREF(x);
677 #endif
678 #ifdef SIGKILL
679 x = PyInt_FromLong(SIGKILL);
680 PyDict_SetItemString(d, "SIGKILL", x);
681 Py_XDECREF(x);
682 #endif
683 #ifdef SIGBUS
684 x = PyInt_FromLong(SIGBUS);
685 PyDict_SetItemString(d, "SIGBUS", x);
686 Py_XDECREF(x);
687 #endif
688 #ifdef SIGSEGV
689 x = PyInt_FromLong(SIGSEGV);
690 PyDict_SetItemString(d, "SIGSEGV", x);
691 Py_XDECREF(x);
692 #endif
693 #ifdef SIGSYS
694 x = PyInt_FromLong(SIGSYS);
695 PyDict_SetItemString(d, "SIGSYS", x);
696 Py_XDECREF(x);
697 #endif
698 #ifdef SIGPIPE
699 x = PyInt_FromLong(SIGPIPE);
700 PyDict_SetItemString(d, "SIGPIPE", x);
701 Py_XDECREF(x);
702 #endif
703 #ifdef SIGALRM
704 x = PyInt_FromLong(SIGALRM);
705 PyDict_SetItemString(d, "SIGALRM", x);
706 Py_XDECREF(x);
707 #endif
708 #ifdef SIGTERM
709 x = PyInt_FromLong(SIGTERM);
710 PyDict_SetItemString(d, "SIGTERM", x);
711 Py_XDECREF(x);
712 #endif
713 #ifdef SIGUSR1
714 x = PyInt_FromLong(SIGUSR1);
715 PyDict_SetItemString(d, "SIGUSR1", x);
716 Py_XDECREF(x);
717 #endif
718 #ifdef SIGUSR2
719 x = PyInt_FromLong(SIGUSR2);
720 PyDict_SetItemString(d, "SIGUSR2", x);
721 Py_XDECREF(x);
722 #endif
723 #ifdef SIGCLD
724 x = PyInt_FromLong(SIGCLD);
725 PyDict_SetItemString(d, "SIGCLD", x);
726 Py_XDECREF(x);
727 #endif
728 #ifdef SIGCHLD
729 x = PyInt_FromLong(SIGCHLD);
730 PyDict_SetItemString(d, "SIGCHLD", x);
731 Py_XDECREF(x);
732 #endif
733 #ifdef SIGPWR
734 x = PyInt_FromLong(SIGPWR);
735 PyDict_SetItemString(d, "SIGPWR", x);
736 Py_XDECREF(x);
737 #endif
738 #ifdef SIGIO
739 x = PyInt_FromLong(SIGIO);
740 PyDict_SetItemString(d, "SIGIO", x);
741 Py_XDECREF(x);
742 #endif
743 #ifdef SIGURG
744 x = PyInt_FromLong(SIGURG);
745 PyDict_SetItemString(d, "SIGURG", x);
746 Py_XDECREF(x);
747 #endif
748 #ifdef SIGWINCH
749 x = PyInt_FromLong(SIGWINCH);
750 PyDict_SetItemString(d, "SIGWINCH", x);
751 Py_XDECREF(x);
752 #endif
753 #ifdef SIGPOLL
754 x = PyInt_FromLong(SIGPOLL);
755 PyDict_SetItemString(d, "SIGPOLL", x);
756 Py_XDECREF(x);
757 #endif
758 #ifdef SIGSTOP
759 x = PyInt_FromLong(SIGSTOP);
760 PyDict_SetItemString(d, "SIGSTOP", x);
761 Py_XDECREF(x);
762 #endif
763 #ifdef SIGTSTP
764 x = PyInt_FromLong(SIGTSTP);
765 PyDict_SetItemString(d, "SIGTSTP", x);
766 Py_XDECREF(x);
767 #endif
768 #ifdef SIGCONT
769 x = PyInt_FromLong(SIGCONT);
770 PyDict_SetItemString(d, "SIGCONT", x);
771 Py_XDECREF(x);
772 #endif
773 #ifdef SIGTTIN
774 x = PyInt_FromLong(SIGTTIN);
775 PyDict_SetItemString(d, "SIGTTIN", x);
776 Py_XDECREF(x);
777 #endif
778 #ifdef SIGTTOU
779 x = PyInt_FromLong(SIGTTOU);
780 PyDict_SetItemString(d, "SIGTTOU", x);
781 Py_XDECREF(x);
782 #endif
783 #ifdef SIGVTALRM
784 x = PyInt_FromLong(SIGVTALRM);
785 PyDict_SetItemString(d, "SIGVTALRM", x);
786 Py_XDECREF(x);
787 #endif
788 #ifdef SIGPROF
789 x = PyInt_FromLong(SIGPROF);
790 PyDict_SetItemString(d, "SIGPROF", x);
791 Py_XDECREF(x);
792 #endif
793 #ifdef SIGXCPU
794 x = PyInt_FromLong(SIGXCPU);
795 PyDict_SetItemString(d, "SIGXCPU", x);
796 Py_XDECREF(x);
797 #endif
798 #ifdef SIGXFSZ
799 x = PyInt_FromLong(SIGXFSZ);
800 PyDict_SetItemString(d, "SIGXFSZ", x);
801 Py_XDECREF(x);
802 #endif
803 #ifdef SIGRTMIN
804 x = PyInt_FromLong(SIGRTMIN);
805 PyDict_SetItemString(d, "SIGRTMIN", x);
806 Py_XDECREF(x);
807 #endif
808 #ifdef SIGRTMAX
809 x = PyInt_FromLong(SIGRTMAX);
810 PyDict_SetItemString(d, "SIGRTMAX", x);
811 Py_XDECREF(x);
812 #endif
813 #ifdef SIGINFO
814 x = PyInt_FromLong(SIGINFO);
815 PyDict_SetItemString(d, "SIGINFO", x);
816 Py_XDECREF(x);
817 #endif
818
819 #ifdef ITIMER_REAL
820 x = PyLong_FromLong(ITIMER_REAL);
821 PyDict_SetItemString(d, "ITIMER_REAL", x);
822 Py_DECREF(x);
823 #endif
824 #ifdef ITIMER_VIRTUAL
825 x = PyLong_FromLong(ITIMER_VIRTUAL);
826 PyDict_SetItemString(d, "ITIMER_VIRTUAL", x);
827 Py_DECREF(x);
828 #endif
829 #ifdef ITIMER_PROF
830 x = PyLong_FromLong(ITIMER_PROF);
831 PyDict_SetItemString(d, "ITIMER_PROF", x);
832 Py_DECREF(x);
833 #endif
834
835 #if defined (HAVE_SETITIMER) || defined (HAVE_GETITIMER)
836 ItimerError = PyErr_NewException("signal.ItimerError",
837 PyExc_IOError, NULL);
838 if (ItimerError != NULL)
839 PyDict_SetItemString(d, "ItimerError", ItimerError);
840 #endif
841
842 #ifdef CTRL_C_EVENT
843 x = PyInt_FromLong(CTRL_C_EVENT);
844 PyDict_SetItemString(d, "CTRL_C_EVENT", x);
845 Py_DECREF(x);
846 #endif
847
848 #ifdef CTRL_BREAK_EVENT
849 x = PyInt_FromLong(CTRL_BREAK_EVENT);
850 PyDict_SetItemString(d, "CTRL_BREAK_EVENT", x);
851 Py_DECREF(x);
852 #endif
853
854 if (!PyErr_Occurred())
855 return;
856
857 /* Check for errors */
858 finally:
859 return;
860 }
861
862 static void
finisignal(void)863 finisignal(void)
864 {
865 int i;
866 PyObject *func;
867
868 for (i = 1; i < NSIG; i++) {
869 func = Handlers[i].func;
870 Handlers[i].tripped = 0;
871 Handlers[i].func = NULL;
872 if (func != NULL && func != Py_None &&
873 func != DefaultHandler && func != IgnoreHandler)
874 PyOS_setsig(i, SIG_DFL);
875 Py_XDECREF(func);
876 }
877
878 Py_XDECREF(IntHandler);
879 IntHandler = NULL;
880 Py_XDECREF(DefaultHandler);
881 DefaultHandler = NULL;
882 Py_XDECREF(IgnoreHandler);
883 IgnoreHandler = NULL;
884 }
885
886
887 /* Declared in pyerrors.h */
888 int
PyErr_CheckSignals(void)889 PyErr_CheckSignals(void)
890 {
891 int i;
892 PyObject *f;
893
894 if (!is_tripped)
895 return 0;
896
897 #ifdef WITH_THREAD
898 if (PyThread_get_thread_ident() != main_thread)
899 return 0;
900 #endif
901
902 /*
903 * The is_tripped variable is meant to speed up the calls to
904 * PyErr_CheckSignals (both directly or via pending calls) when no
905 * signal has arrived. This variable is set to 1 when a signal arrives
906 * and it is set to 0 here, when we know some signals arrived. This way
907 * we can run the registered handlers with no signals blocked.
908 *
909 * NOTE: with this approach we can have a situation where is_tripped is
910 * 1 but we have no more signals to handle (Handlers[i].tripped
911 * is 0 for every signal i). This won't do us any harm (except
912 * we're gonna spent some cycles for nothing). This happens when
913 * we receive a signal i after we zero is_tripped and before we
914 * check Handlers[i].tripped.
915 */
916 is_tripped = 0;
917
918 if (!(f = (PyObject *)PyEval_GetFrame()))
919 f = Py_None;
920
921 for (i = 1; i < NSIG; i++) {
922 if (Handlers[i].tripped) {
923 PyObject *result = NULL;
924 PyObject *arglist = Py_BuildValue("(iO)", i, f);
925 Handlers[i].tripped = 0;
926
927 if (arglist) {
928 result = PyEval_CallObject(Handlers[i].func,
929 arglist);
930 Py_DECREF(arglist);
931 }
932 if (!result)
933 return -1;
934
935 Py_DECREF(result);
936 }
937 }
938
939 return 0;
940 }
941
942
943 /* Replacements for intrcheck.c functionality
944 * Declared in pyerrors.h
945 */
946 void
PyErr_SetInterrupt(void)947 PyErr_SetInterrupt(void)
948 {
949 trip_signal(SIGINT);
950 }
951
952 void
PyOS_InitInterrupts(void)953 PyOS_InitInterrupts(void)
954 {
955 initsignal();
956 _PyImport_FixupExtension("signal", "signal");
957 }
958
959 void
PyOS_FiniInterrupts(void)960 PyOS_FiniInterrupts(void)
961 {
962 finisignal();
963 }
964
965 int
PyOS_InterruptOccurred(void)966 PyOS_InterruptOccurred(void)
967 {
968 if (Handlers[SIGINT].tripped) {
969 #ifdef WITH_THREAD
970 if (PyThread_get_thread_ident() != main_thread)
971 return 0;
972 #endif
973 Handlers[SIGINT].tripped = 0;
974 return 1;
975 }
976 return 0;
977 }
978
979 static void
_clear_pending_signals(void)980 _clear_pending_signals(void)
981 {
982 int i;
983 if (!is_tripped)
984 return;
985 is_tripped = 0;
986 for (i = 1; i < NSIG; ++i) {
987 Handlers[i].tripped = 0;
988 }
989 }
990
991 void
PyOS_AfterFork(void)992 PyOS_AfterFork(void)
993 {
994 /* Clear the signal flags after forking so that they aren't handled
995 * in both processes if they came in just before the fork() but before
996 * the interpreter had an opportunity to call the handlers. issue9535. */
997 _clear_pending_signals();
998 #ifdef WITH_THREAD
999 /* PyThread_ReInitTLS() must be called early, to make sure that the TLS API
1000 * can be called safely. */
1001 PyThread_ReInitTLS();
1002 PyEval_ReInitThreads();
1003 main_thread = PyThread_get_thread_ident();
1004 main_pid = getpid();
1005 _PyImport_ReInitLock();
1006 #endif
1007 }
1008