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_DECREF(Handlers[SIGINT].func);
625 Handlers[SIGINT].func = IntHandler;
626 old_siginthandler = PyOS_setsig(SIGINT, signal_handler);
627 }
628
629 #ifdef SIGHUP
630 x = PyInt_FromLong(SIGHUP);
631 PyDict_SetItemString(d, "SIGHUP", x);
632 Py_XDECREF(x);
633 #endif
634 #ifdef SIGINT
635 x = PyInt_FromLong(SIGINT);
636 PyDict_SetItemString(d, "SIGINT", x);
637 Py_XDECREF(x);
638 #endif
639 #ifdef SIGBREAK
640 x = PyInt_FromLong(SIGBREAK);
641 PyDict_SetItemString(d, "SIGBREAK", x);
642 Py_XDECREF(x);
643 #endif
644 #ifdef SIGQUIT
645 x = PyInt_FromLong(SIGQUIT);
646 PyDict_SetItemString(d, "SIGQUIT", x);
647 Py_XDECREF(x);
648 #endif
649 #ifdef SIGILL
650 x = PyInt_FromLong(SIGILL);
651 PyDict_SetItemString(d, "SIGILL", x);
652 Py_XDECREF(x);
653 #endif
654 #ifdef SIGTRAP
655 x = PyInt_FromLong(SIGTRAP);
656 PyDict_SetItemString(d, "SIGTRAP", x);
657 Py_XDECREF(x);
658 #endif
659 #ifdef SIGIOT
660 x = PyInt_FromLong(SIGIOT);
661 PyDict_SetItemString(d, "SIGIOT", x);
662 Py_XDECREF(x);
663 #endif
664 #ifdef SIGABRT
665 x = PyInt_FromLong(SIGABRT);
666 PyDict_SetItemString(d, "SIGABRT", x);
667 Py_XDECREF(x);
668 #endif
669 #ifdef SIGEMT
670 x = PyInt_FromLong(SIGEMT);
671 PyDict_SetItemString(d, "SIGEMT", x);
672 Py_XDECREF(x);
673 #endif
674 #ifdef SIGFPE
675 x = PyInt_FromLong(SIGFPE);
676 PyDict_SetItemString(d, "SIGFPE", x);
677 Py_XDECREF(x);
678 #endif
679 #ifdef SIGKILL
680 x = PyInt_FromLong(SIGKILL);
681 PyDict_SetItemString(d, "SIGKILL", x);
682 Py_XDECREF(x);
683 #endif
684 #ifdef SIGBUS
685 x = PyInt_FromLong(SIGBUS);
686 PyDict_SetItemString(d, "SIGBUS", x);
687 Py_XDECREF(x);
688 #endif
689 #ifdef SIGSEGV
690 x = PyInt_FromLong(SIGSEGV);
691 PyDict_SetItemString(d, "SIGSEGV", x);
692 Py_XDECREF(x);
693 #endif
694 #ifdef SIGSYS
695 x = PyInt_FromLong(SIGSYS);
696 PyDict_SetItemString(d, "SIGSYS", x);
697 Py_XDECREF(x);
698 #endif
699 #ifdef SIGPIPE
700 x = PyInt_FromLong(SIGPIPE);
701 PyDict_SetItemString(d, "SIGPIPE", x);
702 Py_XDECREF(x);
703 #endif
704 #ifdef SIGALRM
705 x = PyInt_FromLong(SIGALRM);
706 PyDict_SetItemString(d, "SIGALRM", x);
707 Py_XDECREF(x);
708 #endif
709 #ifdef SIGTERM
710 x = PyInt_FromLong(SIGTERM);
711 PyDict_SetItemString(d, "SIGTERM", x);
712 Py_XDECREF(x);
713 #endif
714 #ifdef SIGUSR1
715 x = PyInt_FromLong(SIGUSR1);
716 PyDict_SetItemString(d, "SIGUSR1", x);
717 Py_XDECREF(x);
718 #endif
719 #ifdef SIGUSR2
720 x = PyInt_FromLong(SIGUSR2);
721 PyDict_SetItemString(d, "SIGUSR2", x);
722 Py_XDECREF(x);
723 #endif
724 #ifdef SIGCLD
725 x = PyInt_FromLong(SIGCLD);
726 PyDict_SetItemString(d, "SIGCLD", x);
727 Py_XDECREF(x);
728 #endif
729 #ifdef SIGCHLD
730 x = PyInt_FromLong(SIGCHLD);
731 PyDict_SetItemString(d, "SIGCHLD", x);
732 Py_XDECREF(x);
733 #endif
734 #ifdef SIGPWR
735 x = PyInt_FromLong(SIGPWR);
736 PyDict_SetItemString(d, "SIGPWR", x);
737 Py_XDECREF(x);
738 #endif
739 #ifdef SIGIO
740 x = PyInt_FromLong(SIGIO);
741 PyDict_SetItemString(d, "SIGIO", x);
742 Py_XDECREF(x);
743 #endif
744 #ifdef SIGURG
745 x = PyInt_FromLong(SIGURG);
746 PyDict_SetItemString(d, "SIGURG", x);
747 Py_XDECREF(x);
748 #endif
749 #ifdef SIGWINCH
750 x = PyInt_FromLong(SIGWINCH);
751 PyDict_SetItemString(d, "SIGWINCH", x);
752 Py_XDECREF(x);
753 #endif
754 #ifdef SIGPOLL
755 x = PyInt_FromLong(SIGPOLL);
756 PyDict_SetItemString(d, "SIGPOLL", x);
757 Py_XDECREF(x);
758 #endif
759 #ifdef SIGSTOP
760 x = PyInt_FromLong(SIGSTOP);
761 PyDict_SetItemString(d, "SIGSTOP", x);
762 Py_XDECREF(x);
763 #endif
764 #ifdef SIGTSTP
765 x = PyInt_FromLong(SIGTSTP);
766 PyDict_SetItemString(d, "SIGTSTP", x);
767 Py_XDECREF(x);
768 #endif
769 #ifdef SIGCONT
770 x = PyInt_FromLong(SIGCONT);
771 PyDict_SetItemString(d, "SIGCONT", x);
772 Py_XDECREF(x);
773 #endif
774 #ifdef SIGTTIN
775 x = PyInt_FromLong(SIGTTIN);
776 PyDict_SetItemString(d, "SIGTTIN", x);
777 Py_XDECREF(x);
778 #endif
779 #ifdef SIGTTOU
780 x = PyInt_FromLong(SIGTTOU);
781 PyDict_SetItemString(d, "SIGTTOU", x);
782 Py_XDECREF(x);
783 #endif
784 #ifdef SIGVTALRM
785 x = PyInt_FromLong(SIGVTALRM);
786 PyDict_SetItemString(d, "SIGVTALRM", x);
787 Py_XDECREF(x);
788 #endif
789 #ifdef SIGPROF
790 x = PyInt_FromLong(SIGPROF);
791 PyDict_SetItemString(d, "SIGPROF", x);
792 Py_XDECREF(x);
793 #endif
794 #ifdef SIGXCPU
795 x = PyInt_FromLong(SIGXCPU);
796 PyDict_SetItemString(d, "SIGXCPU", x);
797 Py_XDECREF(x);
798 #endif
799 #ifdef SIGXFSZ
800 x = PyInt_FromLong(SIGXFSZ);
801 PyDict_SetItemString(d, "SIGXFSZ", x);
802 Py_XDECREF(x);
803 #endif
804 #ifdef SIGRTMIN
805 x = PyInt_FromLong(SIGRTMIN);
806 PyDict_SetItemString(d, "SIGRTMIN", x);
807 Py_XDECREF(x);
808 #endif
809 #ifdef SIGRTMAX
810 x = PyInt_FromLong(SIGRTMAX);
811 PyDict_SetItemString(d, "SIGRTMAX", x);
812 Py_XDECREF(x);
813 #endif
814 #ifdef SIGINFO
815 x = PyInt_FromLong(SIGINFO);
816 PyDict_SetItemString(d, "SIGINFO", x);
817 Py_XDECREF(x);
818 #endif
819
820 #ifdef ITIMER_REAL
821 x = PyLong_FromLong(ITIMER_REAL);
822 PyDict_SetItemString(d, "ITIMER_REAL", x);
823 Py_DECREF(x);
824 #endif
825 #ifdef ITIMER_VIRTUAL
826 x = PyLong_FromLong(ITIMER_VIRTUAL);
827 PyDict_SetItemString(d, "ITIMER_VIRTUAL", x);
828 Py_DECREF(x);
829 #endif
830 #ifdef ITIMER_PROF
831 x = PyLong_FromLong(ITIMER_PROF);
832 PyDict_SetItemString(d, "ITIMER_PROF", x);
833 Py_DECREF(x);
834 #endif
835
836 #if defined (HAVE_SETITIMER) || defined (HAVE_GETITIMER)
837 ItimerError = PyErr_NewException("signal.ItimerError",
838 PyExc_IOError, NULL);
839 if (ItimerError != NULL)
840 PyDict_SetItemString(d, "ItimerError", ItimerError);
841 #endif
842
843 #ifdef CTRL_C_EVENT
844 x = PyInt_FromLong(CTRL_C_EVENT);
845 PyDict_SetItemString(d, "CTRL_C_EVENT", x);
846 Py_DECREF(x);
847 #endif
848
849 #ifdef CTRL_BREAK_EVENT
850 x = PyInt_FromLong(CTRL_BREAK_EVENT);
851 PyDict_SetItemString(d, "CTRL_BREAK_EVENT", x);
852 Py_DECREF(x);
853 #endif
854
855 if (!PyErr_Occurred())
856 return;
857
858 /* Check for errors */
859 finally:
860 return;
861 }
862
863 static void
finisignal(void)864 finisignal(void)
865 {
866 int i;
867 PyObject *func;
868
869 PyOS_setsig(SIGINT, old_siginthandler);
870 old_siginthandler = SIG_DFL;
871
872 for (i = 1; i < NSIG; i++) {
873 func = Handlers[i].func;
874 Handlers[i].tripped = 0;
875 Handlers[i].func = NULL;
876 if (i != SIGINT && func != NULL && func != Py_None &&
877 func != DefaultHandler && func != IgnoreHandler)
878 PyOS_setsig(i, SIG_DFL);
879 Py_XDECREF(func);
880 }
881
882 Py_XDECREF(IntHandler);
883 IntHandler = NULL;
884 Py_XDECREF(DefaultHandler);
885 DefaultHandler = NULL;
886 Py_XDECREF(IgnoreHandler);
887 IgnoreHandler = NULL;
888 }
889
890
891 /* Declared in pyerrors.h */
892 int
PyErr_CheckSignals(void)893 PyErr_CheckSignals(void)
894 {
895 int i;
896 PyObject *f;
897
898 if (!is_tripped)
899 return 0;
900
901 #ifdef WITH_THREAD
902 if (PyThread_get_thread_ident() != main_thread)
903 return 0;
904 #endif
905
906 /*
907 * The is_tripped variable is meant to speed up the calls to
908 * PyErr_CheckSignals (both directly or via pending calls) when no
909 * signal has arrived. This variable is set to 1 when a signal arrives
910 * and it is set to 0 here, when we know some signals arrived. This way
911 * we can run the registered handlers with no signals blocked.
912 *
913 * NOTE: with this approach we can have a situation where is_tripped is
914 * 1 but we have no more signals to handle (Handlers[i].tripped
915 * is 0 for every signal i). This won't do us any harm (except
916 * we're gonna spent some cycles for nothing). This happens when
917 * we receive a signal i after we zero is_tripped and before we
918 * check Handlers[i].tripped.
919 */
920 is_tripped = 0;
921
922 if (!(f = (PyObject *)PyEval_GetFrame()))
923 f = Py_None;
924
925 for (i = 1; i < NSIG; i++) {
926 if (Handlers[i].tripped) {
927 PyObject *result = NULL;
928 PyObject *arglist = Py_BuildValue("(iO)", i, f);
929 Handlers[i].tripped = 0;
930
931 if (arglist) {
932 result = PyEval_CallObject(Handlers[i].func,
933 arglist);
934 Py_DECREF(arglist);
935 }
936 if (!result)
937 return -1;
938
939 Py_DECREF(result);
940 }
941 }
942
943 return 0;
944 }
945
946
947 /* Replacements for intrcheck.c functionality
948 * Declared in pyerrors.h
949 */
950 void
PyErr_SetInterrupt(void)951 PyErr_SetInterrupt(void)
952 {
953 trip_signal(SIGINT);
954 }
955
956 void
PyOS_InitInterrupts(void)957 PyOS_InitInterrupts(void)
958 {
959 initsignal();
960 _PyImport_FixupExtension("signal", "signal");
961 }
962
963 void
PyOS_FiniInterrupts(void)964 PyOS_FiniInterrupts(void)
965 {
966 finisignal();
967 }
968
969 int
PyOS_InterruptOccurred(void)970 PyOS_InterruptOccurred(void)
971 {
972 if (Handlers[SIGINT].tripped) {
973 #ifdef WITH_THREAD
974 if (PyThread_get_thread_ident() != main_thread)
975 return 0;
976 #endif
977 Handlers[SIGINT].tripped = 0;
978 return 1;
979 }
980 return 0;
981 }
982
983 static void
_clear_pending_signals(void)984 _clear_pending_signals(void)
985 {
986 int i;
987 if (!is_tripped)
988 return;
989 is_tripped = 0;
990 for (i = 1; i < NSIG; ++i) {
991 Handlers[i].tripped = 0;
992 }
993 }
994
995 void
PyOS_AfterFork(void)996 PyOS_AfterFork(void)
997 {
998 /* Clear the signal flags after forking so that they aren't handled
999 * in both processes if they came in just before the fork() but before
1000 * the interpreter had an opportunity to call the handlers. issue9535. */
1001 _clear_pending_signals();
1002 #ifdef WITH_THREAD
1003 /* PyThread_ReInitTLS() must be called early, to make sure that the TLS API
1004 * can be called safely. */
1005 PyThread_ReInitTLS();
1006 PyEval_ReInitThreads();
1007 main_thread = PyThread_get_thread_ident();
1008 main_pid = getpid();
1009 _PyImport_ReInitLock();
1010 #endif
1011 }
1012