signalmodule.c

/* Signal module -- many thanks to Lance Ellinghaus */

/* XXX Signals should be recorded per thread, now we have thread state. */

#include"Python.h"
#include"pycore_call.h"// _PyObject_Call()
#include"pycore_ceval.h"// _PyEval_SignalReceived()
#include"pycore_emscripten_signal.h"// _Py_CHECK_EMSCRIPTEN_SIGNALS
#include"pycore_fileutils.h"// _Py_BEGIN_SUPPRESS_IPH
#include"pycore_interpframe.h"// _PyThreadState_GetFrame()
#include"pycore_moduleobject.h"// _PyModule_GetState()
#include"pycore_pyerrors.h"// _PyErr_SetString()
#include"pycore_pystate.h"// _PyThreadState_GET()
#include"pycore_signal.h"// _Py_RestoreSignals()
#include"pycore_time.h"// _PyTime_FromSecondsObject()

#ifndefMS_WINDOWS
# include"posixmodule.h"// _PyLong_FromUid()
#endif
#ifdefMS_WINDOWS
# include"socketmodule.h"// SOCKET_T
#endif

#ifdefHAVE_UNISTD_H
# include<unistd.h>// alarm()
#endif
#ifdefMS_WINDOWS
# ifdefHAVE_PROCESS_H
# include<process.h>
# endif
#endif

#ifdefHAVE_SIGNAL_H
# include<signal.h>// sigaction()
#endif
#ifdefHAVE_SYS_SYSCALL_H
# include<sys/syscall.h>// __NR_pidfd_send_signal
#endif
#ifdefHAVE_SYS_STAT_H
# include<sys/stat.h>
#endif
#ifdefHAVE_SYS_TIME_H
# include<sys/time.h>// setitimer()
#endif

#if defined(HAVE_PTHREAD_SIGMASK) && !defined(HAVE_BROKEN_PTHREAD_SIGMASK)
# definePYPTHREAD_SIGMASK
#endif

#if defined(PYPTHREAD_SIGMASK) && defined(HAVE_PTHREAD_H)
# include<pthread.h>
#endif

#ifndefSIG_ERR
# defineSIG_ERR ((PyOS_sighandler_t)(-1))
#endif

#include"clinic/signalmodule.c.h"

/*[clinic input]
module signal
[clinic start generated code]*/
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=b0301a3bde5fe9d3]*/

#ifdefHAVE_SETSIG_T

/*[python input]

class sigset_t_converter(CConverter):
 type = 'sigset_t'
 converter = '_Py_Sigset_Converter'

[python start generated code]*/
/*[python end generated code: output=da39a3ee5e6b4b0d input=b5689d14466b6823]*/
#endif

/*
 NOTES ON THE INTERACTION BETWEEN SIGNALS AND THREADS

 We want the following semantics:

 - only the main thread can set a signal handler
 - only the main thread runs the signal handler
 - signals can be delivered to any thread
 - any thread can get a signal handler

 I.e. we don't support "synchronous signals" like SIGFPE (catching
 this doesn't make much sense in Python anyway) nor do we support
 signals as a means of inter-thread communication, since not all
 thread implementations support that (at least our thread library
 doesn't).

 We still have the problem that in some implementations signals
 generated by the keyboard (e.g. SIGINT) are delivered to all
 threads (e.g. SGI), while in others (e.g. Solaris) such signals are
 delivered to one random thread. On Linux, signals are delivered to
 the main thread (unless the main thread is blocking the signal, for
 example because it's already handling the same signal). Since we
 allow signals to be delivered to any thread, this works fine. The
 only oddity is that the thread executing the Python signal handler
 may not be the thread that received the signal.
*/

#defineHandlers _PyRuntime.signals.handlers
#definewakeup _PyRuntime.signals.wakeup
#defineis_tripped _PyRuntime.signals.is_tripped

// State shared by all Python interpreters
typedefstruct_signals_runtime_statesignal_state_t;
#definesignal_global_state _PyRuntime.signals

#if defined(HAVE_GETITIMER) || defined(HAVE_SETITIMER)
# definePYHAVE_ITIMER_ERROR
#endif

typedefstruct {
PyObject*default_handler; // borrowed ref (signal_global_state)
PyObject*ignore_handler; // borrowed ref (signal_global_state)
#ifdefPYHAVE_ITIMER_ERROR
PyObject*itimer_error;
#endif
PyTypeObject*siginfo_type;
} _signal_module_state;


Py_LOCAL_INLINE(PyObject*)
get_handler(inti)
{
return (PyObject*)_Py_atomic_load_ptr(&Handlers[i].func);
}

Py_LOCAL_INLINE(void)
set_handler(inti, PyObject*func)
{
/* Store func with atomic operation to ensure
 that PyErr_SetInterrupt is async-signal-safe. */
_Py_atomic_store_ptr(&Handlers[i].func, func);
}


staticinline_signal_module_state*
get_signal_state(PyObject*module)
{
void*state=_PyModule_GetState(module);
assert(state!=NULL);
return (_signal_module_state*)state;
}


staticinlineint
compare_handler(PyObject*func, PyObject*dfl_ign_handler)
{
// See https://github.com/python/cpython/pull/102399
if (func==NULL||dfl_ign_handler==NULL) {
return0;
 }
assert(PyLong_CheckExact(dfl_ign_handler));
if (!PyLong_CheckExact(func)) {
return0;
 }
// Assume that comparison of two PyLong objects will never fail.
returnPyObject_RichCompareBool(func, dfl_ign_handler, Py_EQ) ==1;
}

#ifdefHAVE_SETITIMER
/* auxiliary function for setitimer */
staticint
timeval_from_double(PyObject*obj, structtimeval*tv)
{
if (obj==NULL) {
tv->tv_sec=0;
tv->tv_usec=0;
return0;
 }

PyTime_tt;
if (_PyTime_FromSecondsObject(&t, obj, _PyTime_ROUND_CEILING) <0) {
return-1;
 }
return_PyTime_AsTimeval(t, tv, _PyTime_ROUND_CEILING);
}
#endif

#if defined(HAVE_SETITIMER) || defined(HAVE_GETITIMER)
/* auxiliary functions for get/setitimer */
Py_LOCAL_INLINE(double)
double_from_timeval(structtimeval*tv)
{
returntv->tv_sec+ (double)(tv->tv_usec / 1000000.0);
}

staticPyObject*
itimer_retval(structitimerval*iv)
{
PyObject*r, *v;

r=PyTuple_New(2);
if (r==NULL)
returnNULL;

if(!(v=PyFloat_FromDouble(double_from_timeval(&iv->it_value)))) {
Py_DECREF(r);
returnNULL;
 }

PyTuple_SET_ITEM(r, 0, v);

if(!(v=PyFloat_FromDouble(double_from_timeval(&iv->it_interval)))) {
Py_DECREF(r);
returnNULL;
 }

PyTuple_SET_ITEM(r, 1, v);

returnr;
}
#endif

/*[clinic input]
signal.default_int_handler
 signalnum: int
 frame: object
 /

The default handler for SIGINT installed by Python.

It raises KeyboardInterrupt.
[clinic start generated code]*/

staticPyObject*
signal_default_int_handler_impl(PyObject*module, intsignalnum,
PyObject*frame)
/*[clinic end generated code: output=bb11c2eb115ace4e input=efcd4a56a207acfd]*/
{
PyErr_SetNone(PyExc_KeyboardInterrupt);
returnNULL;
}


staticint
report_wakeup_write_error(void*data)
{
intsave_errno=errno;
errno= (int) (intptr_t) data;
PyObject*exc=PyErr_GetRaisedException();
PyErr_SetFromErrno(PyExc_OSError);
PyErr_FormatUnraisable("Exception ignored while "
"trying to write to the signal wakeup fd");
PyErr_SetRaisedException(exc);
errno=save_errno;
return0;
}

#ifdefMS_WINDOWS
staticint
report_wakeup_send_error(void*data)
{
intsend_errno= (int) (intptr_t) data;

PyObject*exc=PyErr_GetRaisedException();
/* PyErr_SetExcFromWindowsErr() invokes FormatMessage() which
 recognizes the error codes used by both GetLastError() and
 WSAGetLastError */
PyErr_SetExcFromWindowsErr(PyExc_OSError, send_errno);
PyErr_FormatUnraisable("Exception ignored while "
"trying to send to the signal wakeup fd");
PyErr_SetRaisedException(exc);
return0;
}
#endif/* MS_WINDOWS */

staticvoid
trip_signal(intsig_num)
{
_Py_atomic_store_int(&Handlers[sig_num].tripped, 1);

/* Set is_tripped after setting .tripped, as it gets
 cleared in PyErr_CheckSignals() before .tripped. */
_Py_atomic_store_int(&is_tripped, 1);

_PyEval_SignalReceived();

/* And then write to the wakeup fd *after* setting all the globals and
 doing the _PyEval_SignalReceived. We used to write to the wakeup fd
 and then set the flag, but this allowed the following sequence of events
 (especially on windows, where trip_signal may run in a new thread):

 - main thread blocks on select([wakeup.fd], ...)
 - signal arrives
 - trip_signal writes to the wakeup fd
 - the main thread wakes up
 - the main thread checks the signal flags, sees that they're unset
 - the main thread empties the wakeup fd
 - the main thread goes back to sleep
 - trip_signal sets the flags to request the Python-level signal handler
 be run
 - the main thread doesn't notice, because it's asleep

 See bpo-30038 for more details.
 */

intfd=wakeup.fd;
if (fd!=INVALID_FD) {
PyInterpreterState*interp=_PyInterpreterState_Main();
unsigned charbyte= (unsigned char)sig_num;
#ifdefMS_WINDOWS
if (wakeup.use_send) {
Py_ssize_trc=send(fd, &byte, 1, 0);

if (rc<0) {
intlast_error=GetLastError();
if (wakeup.warn_on_full_buffer||
last_error!=WSAEWOULDBLOCK)
 {
/* _PyEval_AddPendingCall() isn't signal-safe, but we
 still use it for this exceptional case. */
_PyEval_AddPendingCall(interp,
report_wakeup_send_error,
 (void*)(intptr_t) last_error,
_Py_PENDING_MAINTHREADONLY);
 }
 }
 }
else
#endif
 {
/* _Py_write_noraise() retries write() if write() is interrupted by
 a signal (fails with EINTR). */
Py_ssize_trc=_Py_write_noraise(fd, &byte, 1);

if (rc<0) {
if (wakeup.warn_on_full_buffer||
 (errno!=EWOULDBLOCK&&errno!=EAGAIN))
 {
/* _PyEval_AddPendingCall() isn't signal-safe, but we
 still use it for this exceptional case. */
_PyEval_AddPendingCall(interp,
report_wakeup_write_error,
 (void*)(intptr_t)errno,
_Py_PENDING_MAINTHREADONLY);
 }
 }
 }
 }
}

staticvoid
signal_handler(intsig_num)
{
intsave_errno=errno;

trip_signal(sig_num);

#ifndefHAVE_SIGACTION
#ifdefSIGCHLD
/* To avoid infinite recursion, this signal remains
 reset until explicit re-instated.
 Don't clear the 'func' field as it is our pointer
 to the Python handler... */
if (sig_num!=SIGCHLD)
#endif
/* If the handler was not set up with sigaction, reinstall it. See
 * Python/pylifecycle.c for the implementation of PyOS_setsig which
 * makes this true. See also issue8354. */
PyOS_setsig(sig_num, signal_handler);
#endif

/* Issue #10311: asynchronously executing signal handlers should not
 mutate errno under the feet of unsuspecting C code. */
errno=save_errno;

#ifdefMS_WINDOWS
if (sig_num==SIGINT) {
signal_state_t*state=&signal_global_state;
SetEvent((HANDLE)state->sigint_event);
 }
#endif
}


#ifdefHAVE_ALARM

/*[clinic input]
signal.alarm -> long

 seconds: int
 /

Arrange for SIGALRM to arrive after the given number of seconds.
[clinic start generated code]*/

staticlong
signal_alarm_impl(PyObject*module, intseconds)
/*[clinic end generated code: output=144232290814c298 input=0d5e97e0e6f39e86]*/
{
/* alarm() returns the number of seconds remaining */
return (long)alarm(seconds);
}

#endif

#ifdefHAVE_PAUSE

/*[clinic input]
signal.pause

Wait until a signal arrives.
[clinic start generated code]*/

staticPyObject*
signal_pause_impl(PyObject*module)
/*[clinic end generated code: output=391656788b3c3929 input=f03de0f875752062]*/
{
Py_BEGIN_ALLOW_THREADS
 (void)pause();
Py_END_ALLOW_THREADS
/* make sure that any exceptions that got raised are propagated
 * back into Python
 */
if (PyErr_CheckSignals())
returnNULL;

Py_RETURN_NONE;
}

#endif

/*[clinic input]
signal.raise_signal

 signalnum: int
 /

Send a signal to the executing process.
[clinic start generated code]*/

staticPyObject*
signal_raise_signal_impl(PyObject*module, intsignalnum)
/*[clinic end generated code: output=e2b014220aa6111d input=e90c0f9a42358de6]*/
{
interr;
Py_BEGIN_ALLOW_THREADS
_Py_BEGIN_SUPPRESS_IPH
err=raise(signalnum);
_Py_END_SUPPRESS_IPH
Py_END_ALLOW_THREADS

if (err) {
returnPyErr_SetFromErrno(PyExc_OSError);
 }

// If the current thread can handle signals, handle immediately
// the raised signal.
if (PyErr_CheckSignals()) {
returnNULL;
 }

Py_RETURN_NONE;
}

/*[clinic input]
signal.signal

 signalnum: int
 handler: object
 /

Set the action for the given signal.

The action can be SIG_DFL, SIG_IGN, or a callable Python object.
The previous action is returned. See getsignal() for possible return values.

*** IMPORTANT NOTICE ***
A signal handler function is called with two arguments:
the first is the signal number, the second is the interrupted stack frame.
[clinic start generated code]*/

staticPyObject*
signal_signal_impl(PyObject*module, intsignalnum, PyObject*handler)
/*[clinic end generated code: output=b44cfda43780f3a1 input=deee84af5fa0432c]*/
{
_signal_module_state*modstate=get_signal_state(module);
PyObject*old_handler;
void (*func)(int);
#ifdefMS_WINDOWS
/* Validate that signalnum is one of the allowable signals */
switch (signalnum) {
caseSIGABRT: break;
#ifdefSIGBREAK
/* Issue #10003: SIGBREAK is not documented as permitted, but works
 and corresponds to CTRL_BREAK_EVENT. */
caseSIGBREAK: break;
#endif
caseSIGFPE: break;
caseSIGILL: break;
caseSIGINT: break;
caseSIGSEGV: break;
caseSIGTERM: break;
default:
PyErr_SetString(PyExc_ValueError, "invalid signal value");
returnNULL;
 }
#endif

PyThreadState*tstate=_PyThreadState_GET();
if (!_Py_ThreadCanHandleSignals(tstate->interp)) {
_PyErr_SetString(tstate, PyExc_ValueError,
"signal only works in main thread "
"of the main interpreter");
returnNULL;
 }
if (signalnum<1||signalnum >= Py_NSIG) {
_PyErr_SetString(tstate, PyExc_ValueError,
"signal number out of range");
returnNULL;
 }
if (PyCallable_Check(handler)) {
func=signal_handler;
 } elseif (compare_handler(handler, modstate->ignore_handler)) {
func=SIG_IGN;
 } elseif (compare_handler(handler, modstate->default_handler)) {
func=SIG_DFL;
 } else {
_PyErr_SetString(tstate, PyExc_TypeError,
"signal handler must be signal.SIG_IGN, "
"signal.SIG_DFL, or a callable object");
returnNULL;
 }

/* Check for pending signals before changing signal handler */
if (_PyErr_CheckSignalsTstate(tstate)) {
returnNULL;
 }
if (PyOS_setsig(signalnum, func) ==SIG_ERR) {
PyErr_SetFromErrno(PyExc_OSError);
returnNULL;
 }

old_handler=get_handler(signalnum);
set_handler(signalnum, Py_NewRef(handler));

if (old_handler!=NULL) {
returnold_handler;
 }
else {
Py_RETURN_NONE;
 }
}


/*[clinic input]
signal.getsignal

 signalnum: int
 /

Return the current action for the given signal.

The return value can be:
 SIG_IGN -- if the signal is being ignored
 SIG_DFL -- if the default action for the signal is in effect
 None -- if an unknown handler is in effect
 anything else -- the callable Python object used as a handler
[clinic start generated code]*/

staticPyObject*
signal_getsignal_impl(PyObject*module, intsignalnum)
/*[clinic end generated code: output=35b3e0e796fd555e input=ac23a00f19dfa509]*/
{
PyObject*old_handler;
if (signalnum<1||signalnum >= Py_NSIG) {
PyErr_SetString(PyExc_ValueError,
"signal number out of range");
returnNULL;
 }
old_handler=get_handler(signalnum);
if (old_handler!=NULL) {
returnPy_NewRef(old_handler);
 }
else {
Py_RETURN_NONE;
 }
}


/*[clinic input]
signal.strsignal

 signalnum: int
 /

Return the system description of the given signal.

Returns the description of signal *signalnum*, such as "Interrupt"
for :const:`SIGINT`. Returns :const:`None` if *signalnum* has no
description. Raises :exc:`ValueError` if *signalnum* is invalid.
[clinic start generated code]*/

staticPyObject*
signal_strsignal_impl(PyObject*module, intsignalnum)
/*[clinic end generated code: output=44e12e1e3b666261 input=238b335847778bc0]*/
{
constchar*res;

if (signalnum<1||signalnum >= Py_NSIG) {
PyErr_SetString(PyExc_ValueError,
"signal number out of range");
returnNULL;
 }

#ifndefHAVE_STRSIGNAL
switch (signalnum) {
/* Though being a UNIX, HP-UX does not provide strsignal(3). */
#ifndefMS_WINDOWS
caseSIGHUP:
res="Hangup";
break;
caseSIGALRM:
res="Alarm clock";
break;
caseSIGPIPE:
res="Broken pipe";
break;
caseSIGQUIT:
res="Quit";
break;
caseSIGCHLD:
res="Child exited";
break;
#endif
/* Custom redefinition of POSIX signals allowed on Windows. */
caseSIGINT:
res="Interrupt";
break;
caseSIGILL:
res="Illegal instruction";
break;
caseSIGABRT:
res="Aborted";
break;
caseSIGFPE:
res="Floating-point exception";
break;
caseSIGSEGV:
res="Segmentation fault";
break;
caseSIGTERM:
res="Terminated";
break;
default:
Py_RETURN_NONE;
 }
#else
errno=0;
res=strsignal(signalnum);

if (errno||res==NULL||strstr(res, "Unknown signal") !=NULL)
Py_RETURN_NONE;
#endif

returnPyUnicode_FromString(res);
}

#ifdefHAVE_SIGINTERRUPT

/*[clinic input]
signal.siginterrupt

 signalnum: int
 flag: int
 /

Change system call restart behaviour.

If flag is False, system calls will be restarted when interrupted by
signal sig, else system calls will be interrupted.
[clinic start generated code]*/

staticPyObject*
signal_siginterrupt_impl(PyObject*module, intsignalnum, intflag)
/*[clinic end generated code: output=063816243d85dd19 input=4160acacca3e2099]*/
{
if (signalnum<1||signalnum >= Py_NSIG) {
PyErr_SetString(PyExc_ValueError,
"signal number out of range");
returnNULL;
 }
#ifdefHAVE_SIGACTION
structsigactionact;
 (void) sigaction(signalnum, NULL, &act);
if (flag) {
act.sa_flags &= ~SA_RESTART;
 }
else {
act.sa_flags |= SA_RESTART;
 }
if (sigaction(signalnum, &act, NULL) <0) {
#else
if (siginterrupt(signalnum, flag) <0) {
#endif
PyErr_SetFromErrno(PyExc_OSError);
returnNULL;
 }
Py_RETURN_NONE;
}

#endif


/*[clinic input]
signal.set_wakeup_fd

 fd as fdobj: object
 /
 *
 warn_on_full_buffer: bool = True

Sets the fd to be written to (with the signal number) when a signal comes in.

A library can use this to wakeup select or poll.
The previous fd or -1 is returned.

The fd must be non-blocking.
[clinic start generated code]*/

staticPyObject*
signal_set_wakeup_fd_impl(PyObject*module, PyObject*fdobj,
intwarn_on_full_buffer)
/*[clinic end generated code: output=2280d72dd2a54c4f input=5b545946a28b8339]*/
{
struct_Py_stat_structstatus;
#ifdefMS_WINDOWS
SOCKET_Tsockfd, old_sockfd;
intres;
intres_size=sizeofres;
PyObject*mod;
intis_socket;

sockfd=PyLong_AsSocket_t(fdobj);
if (sockfd== (SOCKET_T)(-1) &&PyErr_Occurred())
returnNULL;
#else
intfd=PyLong_AsInt(fdobj);
if (fd==-1&&PyErr_Occurred()) {
returnNULL;
 }
#endif

PyThreadState*tstate=_PyThreadState_GET();
if (!_Py_ThreadCanHandleSignals(tstate->interp)) {
_PyErr_SetString(tstate, PyExc_ValueError,
"set_wakeup_fd only works in main thread "
"of the main interpreter");
returnNULL;
 }

#ifdefMS_WINDOWS
is_socket=0;
if (sockfd!=INVALID_FD) {
/* Import the _socket module to call WSAStartup() */
mod=PyImport_ImportModule("_socket");
if (mod==NULL)
returnNULL;
Py_DECREF(mod);

/* test the socket */
if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR,
 (char*)&res, &res_size) !=0) {
intfd, err;

err=WSAGetLastError();
if (err!=WSAENOTSOCK) {
PyErr_SetExcFromWindowsErr(PyExc_OSError, err);
returnNULL;
 }

fd= (int)sockfd;
if ((SOCKET_T)fd!=sockfd) {
_PyErr_SetString(tstate, PyExc_ValueError, "invalid fd");
returnNULL;
 }

if (_Py_fstat(fd, &status) !=0) {
returnNULL;
 }

/* on Windows, a file cannot be set to non-blocking mode */
 }
else {
is_socket=1;

/* Windows does not provide a function to test if a socket
 is in non-blocking mode */
 }
 }

old_sockfd=wakeup.fd;
wakeup.fd=Py_SAFE_DOWNCAST(sockfd, SOCKET_T, int);
wakeup.warn_on_full_buffer=warn_on_full_buffer;
wakeup.use_send=is_socket;

if (old_sockfd!=INVALID_FD)
returnPyLong_FromSocket_t(old_sockfd);
else
returnPyLong_FromLong(-1);
#else
if (fd!=-1) {
intblocking;

if (_Py_fstat(fd, &status) !=0)
returnNULL;

blocking=_Py_get_blocking(fd);
if (blocking<0)
returnNULL;
if (blocking) {
_PyErr_Format(tstate, PyExc_ValueError,
"the fd %i must be in non-blocking mode",
fd);
returnNULL;
 }
 }

intold_fd=wakeup.fd;
wakeup.fd=fd;
wakeup.warn_on_full_buffer=warn_on_full_buffer;

returnPyLong_FromLong(old_fd);
#endif
}

/* C API for the same, without all the error checking */
int
PySignal_SetWakeupFd(intfd)
{
if (fd<0) {
fd=-1;
 }

intold_fd=wakeup.fd;
wakeup.fd=fd;
wakeup.warn_on_full_buffer=1;
returnold_fd;
}


#ifdefHAVE_SETITIMER
/*[clinic input]
signal.setitimer

 which: int
 seconds: object
 interval: object(c_default="NULL") = 0.0
 /

Sets given itimer (one of ITIMER_REAL, ITIMER_VIRTUAL or ITIMER_PROF).

The timer will fire after value seconds and after that every interval seconds.
The itimer can be cleared by setting seconds to zero.

Returns old values as a tuple: (delay, interval).
[clinic start generated code]*/

staticPyObject*
signal_setitimer_impl(PyObject*module, intwhich, PyObject*seconds,
PyObject*interval)
/*[clinic end generated code: output=65f9dcbddc35527b input=de43daf194e6f66f]*/
{
_signal_module_state*modstate=get_signal_state(module);

structitimervalnew;
if (timeval_from_double(seconds, &new.it_value) <0) {
returnNULL;
 }
if (timeval_from_double(interval, &new.it_interval) <0) {
returnNULL;
 }

/* Let OS check "which" value */
structitimervalold;
if (setitimer(which, &new, &old) !=0) {
PyErr_SetFromErrno(modstate->itimer_error);
returnNULL;
 }

returnitimer_retval(&old);
}
#endif// HAVE_SETITIMER


#ifdefHAVE_GETITIMER
/*[clinic input]
signal.getitimer

 which: int
 /

Returns current value of given itimer.
[clinic start generated code]*/

staticPyObject*
signal_getitimer_impl(PyObject*module, intwhich)
/*[clinic end generated code: output=9e053175d517db40 input=f7d21d38f3490627]*/
{
_signal_module_state*modstate=get_signal_state(module);

structitimervalold;
if (getitimer(which, &old) !=0) {
PyErr_SetFromErrno(modstate->itimer_error);
returnNULL;
 }

returnitimer_retval(&old);
}
#endif// HAVE_GETITIMER


#ifdefHAVE_SIGSET_T
#if defined(PYPTHREAD_SIGMASK) || defined(HAVE_SIGPENDING)
staticPyObject*
sigset_to_set(sigset_tmask)
{
PyObject*signum, *result;
intsig;

result=PySet_New(0);
if (result==NULL)
returnNULL;

for (sig=1; sig<Py_NSIG; sig++) {
if (sigismember(&mask, sig) !=1)
continue;

/* Handle the case where it is a member by adding the signal to
 the result list. Ignore the other cases because they mean the
 signal isn't a member of the mask or the signal was invalid,
 and an invalid signal must have been our fault in constructing
 the loop boundaries. */
signum=PyLong_FromLong(sig);
if (signum==NULL) {
Py_DECREF(result);
returnNULL;
 }
if (PySet_Add(result, signum) ==-1) {
Py_DECREF(signum);
Py_DECREF(result);
returnNULL;
 }
Py_DECREF(signum);
 }
returnresult;
}
#endif

#ifdefPYPTHREAD_SIGMASK

/*[clinic input]
signal.pthread_sigmask

 how: int
 mask: sigset_t
 /

Fetch and/or change the signal mask of the calling thread.
[clinic start generated code]*/

staticPyObject*
signal_pthread_sigmask_impl(PyObject*module, inthow, sigset_tmask)
/*[clinic end generated code: output=0562c0fb192981a8 input=85bcebda442fa77f]*/
{
sigset_tprevious;
interr;

err=pthread_sigmask(how, &mask, &previous);
if (err!=0) {
errno=err;
PyErr_SetFromErrno(PyExc_OSError);
returnNULL;
 }

/* if signals was unblocked, signal handlers have been called */
if (PyErr_CheckSignals())
returnNULL;

returnsigset_to_set(previous);
}

#endif/* #ifdef PYPTHREAD_SIGMASK */


#ifdefHAVE_SIGPENDING

/*[clinic input]
signal.sigpending

Examine pending signals.

Returns a set of signal numbers that are pending for delivery to
the calling thread.