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 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) 117 double_from_timeval(struct timeval *tv) 118 { 119 return tv->tv_sec + (double)(tv->tv_usec / 1000000.0); 120 } 121 122 static PyObject * 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 * 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 164 checksignals_witharg(void * unused) 165 { 166 return PyErr_CheckSignals(); 167 } 168 169 static void 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 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 * 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 * 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 * 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 * 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 * 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 * 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 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 * 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 * 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 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 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 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 951 PyErr_SetInterrupt(void) 952 { 953 trip_signal(SIGINT); 954 } 955 956 void 957 PyOS_InitInterrupts(void) 958 { 959 initsignal(); 960 _PyImport_FixupExtension("signal", "signal"); 961 } 962 963 void 964 PyOS_FiniInterrupts(void) 965 { 966 finisignal(); 967 } 968 969 int 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 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 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
