1
2 /* Signal module -- many thanks to Lance Ellinghaus */
3
4 /* XXX Signals should be recorded per thread, now we have thread state. */
5
6 #include "Python.h"
7 #include "intrcheck.h"
8
9 #ifdef MS_WINDOWS
10 #include <Windows.h>
11 #ifdef HAVE_PROCESS_H
12 #include <process.h>
13 #endif
14 #endif
15
16 #ifdef HAVE_SIGNAL_H
17 #include <signal.h>
18 #endif
19 #ifdef HAVE_SYS_STAT_H
20 #include <sys/stat.h>
21 #endif
22 #ifdef HAVE_SYS_TIME_H
23 #include <sys/time.h>
24 #endif
25
26 #ifndef SIG_ERR
27 #define SIG_ERR ((PyOS_sighandler_t)(-1))
28 #endif
29
30 #if defined(PYOS_OS2) && !defined(PYCC_GCC)
31 #define NSIG 12
32 #include <process.h>
33 #endif
34
35 #ifndef NSIG
36 # if defined(_NSIG)
37 # define NSIG _NSIG /* For BSD/SysV */
38 # elif defined(_SIGMAX)
39 # define NSIG (_SIGMAX + 1) /* For QNX */
40 # elif defined(SIGMAX)
41 # define NSIG (SIGMAX + 1) /* For djgpp */
42 # else
43 # define NSIG 64 /* Use a reasonable default value */
44 # endif
45 #endif
46
47
48 /*
49 NOTES ON THE INTERACTION BETWEEN SIGNALS AND THREADS
50
51 When threads are supported, we want the following semantics:
52
53 - only the main thread can set a signal handler
54 - any thread can get a signal handler
55 - signals are only delivered to the main thread
56
57 I.e. we don't support "synchronous signals" like SIGFPE (catching
58 this doesn't make much sense in Python anyway) nor do we support
59 signals as a means of inter-thread communication, since not all
60 thread implementations support that (at least our thread library
61 doesn't).
62
63 We still have the problem that in some implementations signals
64 generated by the keyboard (e.g. SIGINT) are delivered to all
65 threads (e.g. SGI), while in others (e.g. Solaris) such signals are
66 delivered to one random thread (an intermediate possibility would
67 be to deliver it to the main thread -- POSIX?). For now, we have
68 a working implementation that works in all three cases -- the
69 handler ignores signals if getpid() isn't the same as in the main
70 thread. XXX This is a hack.
71
72 GNU pth is a user-space threading library, and as such, all threads
73 run within the same process. In this case, if the currently running
74 thread is not the main_thread, send the signal to the main_thread.
75 */
76
77 #ifdef WITH_THREAD
78 #include <sys/types.h> /* For pid_t */
79 #include "pythread.h"
80 static long main_thread;
81 static pid_t main_pid;
82 #endif
83
84 static struct {
85 int tripped;
86 PyObject *func;
87 } Handlers[NSIG];
88
89 static sig_atomic_t wakeup_fd = -1;
90
91 /* Speed up sigcheck() when none tripped */
92 static volatile sig_atomic_t is_tripped = 0;
93
94 static PyObject *DefaultHandler;
95 static PyObject *IgnoreHandler;
96 static PyObject *IntHandler;
97
98 /* On Solaris 8, gcc will produce a warning that the function
99 declaration is not a prototype. This is caused by the definition of
100 SIG_DFL as (void (*)())0; the correct declaration would have been
101 (void (*)(int))0. */
102
103 static PyOS_sighandler_t old_siginthandler = SIG_DFL;
104
105 #ifdef HAVE_GETITIMER
106 static PyObject *ItimerError;
107
108 /* auxiliary functions for setitimer/getitimer */
109 static void
timeval_from_double(double d,struct timeval * tv)110 timeval_from_double(double d, struct timeval *tv)
111 {
112 tv->tv_sec = floor(d);
113 tv->tv_usec = fmod(d, 1.0) * 1000000.0;
114 }
115
116 Py_LOCAL_INLINE(double)
double_from_timeval(struct timeval * tv)117 double_from_timeval(struct timeval *tv)
118 {
119 return tv->tv_sec + (double)(tv->tv_usec / 1000000.0);
120 }
121
122 static PyObject *
itimer_retval(struct itimerval * iv)123 itimer_retval(struct itimerval *iv)
124 {
125 PyObject *r, *v;
126
127 r = PyTuple_New(2);
128 if (r == NULL)
129 return NULL;
130
131 if(!(v = PyFloat_FromDouble(double_from_timeval(&iv->it_value)))) {
132 Py_DECREF(r);
133 return NULL;
134 }
135
136 PyTuple_SET_ITEM(r, 0, v);
137
138 if(!(v = PyFloat_FromDouble(double_from_timeval(&iv->it_interval)))) {
139 Py_DECREF(r);
140 return NULL;
141 }
142
143 PyTuple_SET_ITEM(r, 1, v);
144
145 return r;
146 }
147 #endif
148
149 static PyObject *
signal_default_int_handler(PyObject * self,PyObject * args)150 signal_default_int_handler(PyObject *self, PyObject *args)
151 {
152 PyErr_SetNone(PyExc_KeyboardInterrupt);
153 return NULL;
154 }
155
156 PyDoc_STRVAR(default_int_handler_doc,
157 "default_int_handler(...)\n\
158 \n\
159 The default handler for SIGINT installed by Python.\n\
160 It raises KeyboardInterrupt.");
161
162
163 static int
checksignals_witharg(void * unused)164 checksignals_witharg(void * unused)
165 {
166 return PyErr_CheckSignals();
167 }
168
169 static void
trip_signal(int sig_num)170 trip_signal(int sig_num)
171 {
172 Handlers[sig_num].tripped = 1;
173 if (is_tripped)
174 return;
175 /* Set is_tripped after setting .tripped, as it gets
176 cleared in PyErr_CheckSignals() before .tripped. */
177 is_tripped = 1;
178 Py_AddPendingCall(checksignals_witharg, NULL);
179 if (wakeup_fd != -1)
180 write(wakeup_fd, "\0", 1);
181 }
182
183 static void
signal_handler(int sig_num)184 signal_handler(int sig_num)
185 {
186 int save_errno = errno;
187
188 #if defined(WITH_THREAD) && defined(WITH_PTH)
189 if (PyThread_get_thread_ident() != main_thread) {
190 pth_raise(*(pth_t *) main_thread, sig_num);
191 }
192 else
193 #endif
194 {
195 #ifdef WITH_THREAD
196 /* See NOTES section above */
197 if (getpid() == main_pid)
198 #endif
199 {
200 trip_signal(sig_num);
201 }
202
203 #ifndef HAVE_SIGACTION
204 #ifdef SIGCHLD
205 /* To avoid infinite recursion, this signal remains
206 reset until explicit re-instated.
207 Don't clear the 'func' field as it is our pointer
208 to the Python handler... */
209 if (sig_num != SIGCHLD)
210 #endif
211 /* If the handler was not set up with sigaction, reinstall it. See
212 * Python/pythonrun.c for the implementation of PyOS_setsig which
213 * makes this true. See also issue8354. */
214 PyOS_setsig(sig_num, signal_handler);
215 #endif
216 }
217
218 /* Issue #10311: asynchronously executing signal handlers should not
219 mutate errno under the feet of unsuspecting C code. */
220 errno = save_errno;
221 }
222
223
224 #ifdef HAVE_ALARM
225 static PyObject *
signal_alarm(PyObject * self,PyObject * args)226 signal_alarm(PyObject *self, PyObject *args)
227 {
228 int t;
229 if (!PyArg_ParseTuple(args, "i:alarm", &t))
230 return NULL;
231 /* alarm() returns the number of seconds remaining */
232 return PyInt_FromLong((long)alarm(t));
233 }
234
235 PyDoc_STRVAR(alarm_doc,
236 "alarm(seconds)\n\
237 \n\
238 Arrange for SIGALRM to arrive after the given number of seconds.");
239 #endif
240
241 #ifdef HAVE_PAUSE
242 static PyObject *
signal_pause(PyObject * self)243 signal_pause(PyObject *self)
244 {
245 Py_BEGIN_ALLOW_THREADS
246 (void)pause();
247 Py_END_ALLOW_THREADS
248 /* make sure that any exceptions that got raised are propagated
249 * back into Python
250 */
251 if (PyErr_CheckSignals())
252 return NULL;
253
254 Py_INCREF(Py_None);
255 return Py_None;
256 }
257 PyDoc_STRVAR(pause_doc,
258 "pause()\n\
259 \n\
260 Wait until a signal arrives.");
261
262 #endif
263
264
265 static PyObject *
signal_signal(PyObject * self,PyObject * args)266 signal_signal(PyObject *self, PyObject *args)
267 {
268 PyObject *obj;
269 int sig_num;
270 PyObject *old_handler;
271 void (*func)(int);
272 if (!PyArg_ParseTuple(args, "iO:signal", &sig_num, &obj))
273 return NULL;
274 #ifdef MS_WINDOWS
275 /* Validate that sig_num is one of the allowable signals */
276 switch (sig_num) {
277 case SIGABRT: break;
278 #ifdef SIGBREAK
279 /* Issue #10003: SIGBREAK is not documented as permitted, but works
280 and corresponds to CTRL_BREAK_EVENT. */
281 case SIGBREAK: break;
282 #endif
283 case SIGFPE: break;
284 case SIGILL: break;
285 case SIGINT: break;
286 case SIGSEGV: break;
287 case SIGTERM: break;
288 default:
289 PyErr_SetString(PyExc_ValueError, "invalid signal value");
290 return NULL;
291 }
292 #endif
293 #ifdef WITH_THREAD
294 if (PyThread_get_thread_ident() != main_thread) {
295 PyErr_SetString(PyExc_ValueError,
296 "signal only works in main thread");
297 return NULL;
298 }
299 #endif
300 if (sig_num < 1 || sig_num >= NSIG) {
301 PyErr_SetString(PyExc_ValueError,
302 "signal number out of range");
303 return NULL;
304 }
305 if (obj == IgnoreHandler)
306 func = SIG_IGN;
307 else if (obj == DefaultHandler)
308 func = SIG_DFL;
309 else if (!PyCallable_Check(obj)) {
310 PyErr_SetString(PyExc_TypeError,
311 "signal handler must be signal.SIG_IGN, signal.SIG_DFL, or a callable object");
312 return NULL;
313 }
314 else
315 func = signal_handler;
316 if (PyOS_setsig(sig_num, func) == SIG_ERR) {
317 PyErr_SetFromErrno(PyExc_RuntimeError);
318 return NULL;
319 }
320 old_handler = Handlers[sig_num].func;
321 Handlers[sig_num].tripped = 0;
322 Py_INCREF(obj);
323 Handlers[sig_num].func = obj;
324 if (old_handler != NULL)
325 return old_handler;
326 else
327 Py_RETURN_NONE;
328 }
329
330 PyDoc_STRVAR(signal_doc,
331 "signal(sig, action) -> action\n\
332 \n\
333 Set the action for the given signal. The action can be SIG_DFL,\n\
334 SIG_IGN, or a callable Python object. The previous action is\n\
335 returned. See getsignal() for possible return values.\n\
336 \n\
337 *** IMPORTANT NOTICE ***\n\
338 A signal handler function is called with two arguments:\n\
339 the first is the signal number, the second is the interrupted stack frame.");
340
341
342 static PyObject *
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 old_siginthandler = 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 PyOS_setsig(SIGINT, old_siginthandler);
869 old_siginthandler = SIG_DFL;
870
871 for (i = 1; i < NSIG; i++) {
872 func = Handlers[i].func;
873 Handlers[i].tripped = 0;
874 Handlers[i].func = NULL;
875 if (i != SIGINT && func != NULL && func != Py_None &&
876 func != DefaultHandler && func != IgnoreHandler)
877 PyOS_setsig(i, SIG_DFL);
878 Py_XDECREF(func);
879 }
880
881 Py_XDECREF(IntHandler);
882 IntHandler = NULL;
883 Py_XDECREF(DefaultHandler);
884 DefaultHandler = NULL;
885 Py_XDECREF(IgnoreHandler);
886 IgnoreHandler = NULL;
887 }
888
889
890 /* Declared in pyerrors.h */
891 int
PyErr_CheckSignals(void)892 PyErr_CheckSignals(void)
893 {
894 int i;
895 PyObject *f;
896
897 if (!is_tripped)
898 return 0;
899
900 #ifdef WITH_THREAD
901 if (PyThread_get_thread_ident() != main_thread)
902 return 0;
903 #endif
904
905 /*
906 * The is_tripped variable is meant to speed up the calls to
907 * PyErr_CheckSignals (both directly or via pending calls) when no
908 * signal has arrived. This variable is set to 1 when a signal arrives
909 * and it is set to 0 here, when we know some signals arrived. This way
910 * we can run the registered handlers with no signals blocked.
911 *
912 * NOTE: with this approach we can have a situation where is_tripped is
913 * 1 but we have no more signals to handle (Handlers[i].tripped
914 * is 0 for every signal i). This won't do us any harm (except
915 * we're gonna spent some cycles for nothing). This happens when
916 * we receive a signal i after we zero is_tripped and before we
917 * check Handlers[i].tripped.
918 */
919 is_tripped = 0;
920
921 if (!(f = (PyObject *)PyEval_GetFrame()))
922 f = Py_None;
923
924 for (i = 1; i < NSIG; i++) {
925 if (Handlers[i].tripped) {
926 PyObject *result = NULL;
927 PyObject *arglist = Py_BuildValue("(iO)", i, f);
928 Handlers[i].tripped = 0;
929
930 if (arglist) {
931 result = PyEval_CallObject(Handlers[i].func,
932 arglist);
933 Py_DECREF(arglist);
934 }
935 if (!result)
936 return -1;
937
938 Py_DECREF(result);
939 }
940 }
941
942 return 0;
943 }
944
945
946 /* Replacements for intrcheck.c functionality
947 * Declared in pyerrors.h
948 */
949 void
PyErr_SetInterrupt(void)950 PyErr_SetInterrupt(void)
951 {
952 trip_signal(SIGINT);
953 }
954
955 void
PyOS_InitInterrupts(void)956 PyOS_InitInterrupts(void)
957 {
958 initsignal();
959 _PyImport_FixupExtension("signal", "signal");
960 }
961
962 void
PyOS_FiniInterrupts(void)963 PyOS_FiniInterrupts(void)
964 {
965 finisignal();
966 }
967
968 int
PyOS_InterruptOccurred(void)969 PyOS_InterruptOccurred(void)
970 {
971 if (Handlers[SIGINT].tripped) {
972 #ifdef WITH_THREAD
973 if (PyThread_get_thread_ident() != main_thread)
974 return 0;
975 #endif
976 Handlers[SIGINT].tripped = 0;
977 return 1;
978 }
979 return 0;
980 }
981
982 static void
_clear_pending_signals(void)983 _clear_pending_signals(void)
984 {
985 int i;
986 if (!is_tripped)
987 return;
988 is_tripped = 0;
989 for (i = 1; i < NSIG; ++i) {
990 Handlers[i].tripped = 0;
991 }
992 }
993
994 void
PyOS_AfterFork(void)995 PyOS_AfterFork(void)
996 {
997 /* Clear the signal flags after forking so that they aren't handled
998 * in both processes if they came in just before the fork() but before
999 * the interpreter had an opportunity to call the handlers. issue9535. */
1000 _clear_pending_signals();
1001 #ifdef WITH_THREAD
1002 /* PyThread_ReInitTLS() must be called early, to make sure that the TLS API
1003 * can be called safely. */
1004 PyThread_ReInitTLS();
1005 PyEval_ReInitThreads();
1006 main_thread = PyThread_get_thread_ident();
1007 main_pid = getpid();
1008 _PyImport_ReInitLock();
1009 #endif
1010 }
1011