Branch data Line data Source code
1 : : /*[clinic input]
2 : : preserve
3 : : [clinic start generated code]*/
4 : :
5 : : PyDoc_STRVAR(signal_default_int_handler__doc__,
6 : : "default_int_handler($module, signalnum, frame, /)\n"
7 : : "--\n"
8 : : "\n"
9 : : "The default handler for SIGINT installed by Python.\n"
10 : : "\n"
11 : : "It raises KeyboardInterrupt.");
12 : :
13 : : #define SIGNAL_DEFAULT_INT_HANDLER_METHODDEF \
14 : : {"default_int_handler", _PyCFunction_CAST(signal_default_int_handler), METH_FASTCALL, signal_default_int_handler__doc__},
15 : :
16 : : static PyObject *
17 : : signal_default_int_handler_impl(PyObject *module, int signalnum,
18 : : PyObject *frame);
19 : :
20 : : static PyObject *
21 : 105 : signal_default_int_handler(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
22 : : {
23 : 105 : PyObject *return_value = NULL;
24 : : int signalnum;
25 : : PyObject *frame;
26 : :
27 [ + - - + : 105 : if (!_PyArg_CheckPositional("default_int_handler", nargs, 2, 2)) {
- - ]
28 : 0 : goto exit;
29 : : }
30 : 105 : signalnum = _PyLong_AsInt(args[0]);
31 [ - + - - ]: 105 : if (signalnum == -1 && PyErr_Occurred()) {
32 : 0 : goto exit;
33 : : }
34 : 105 : frame = args[1];
35 : 105 : return_value = signal_default_int_handler_impl(module, signalnum, frame);
36 : :
37 : 105 : exit:
38 : 105 : return return_value;
39 : : }
40 : :
41 : : #if defined(HAVE_ALARM)
42 : :
43 : : PyDoc_STRVAR(signal_alarm__doc__,
44 : : "alarm($module, seconds, /)\n"
45 : : "--\n"
46 : : "\n"
47 : : "Arrange for SIGALRM to arrive after the given number of seconds.");
48 : :
49 : : #define SIGNAL_ALARM_METHODDEF \
50 : : {"alarm", (PyCFunction)signal_alarm, METH_O, signal_alarm__doc__},
51 : :
52 : : static long
53 : : signal_alarm_impl(PyObject *module, int seconds);
54 : :
55 : : static PyObject *
56 : 126 : signal_alarm(PyObject *module, PyObject *arg)
57 : : {
58 : 126 : PyObject *return_value = NULL;
59 : : int seconds;
60 : : long _return_value;
61 : :
62 : 126 : seconds = _PyLong_AsInt(arg);
63 [ - + - - ]: 126 : if (seconds == -1 && PyErr_Occurred()) {
64 : 0 : goto exit;
65 : : }
66 : 126 : _return_value = signal_alarm_impl(module, seconds);
67 [ - + - - ]: 126 : if ((_return_value == -1) && PyErr_Occurred()) {
68 : 0 : goto exit;
69 : : }
70 : 126 : return_value = PyLong_FromLong(_return_value);
71 : :
72 : 126 : exit:
73 : 126 : return return_value;
74 : : }
75 : :
76 : : #endif /* defined(HAVE_ALARM) */
77 : :
78 : : #if defined(HAVE_PAUSE)
79 : :
80 : : PyDoc_STRVAR(signal_pause__doc__,
81 : : "pause($module, /)\n"
82 : : "--\n"
83 : : "\n"
84 : : "Wait until a signal arrives.");
85 : :
86 : : #define SIGNAL_PAUSE_METHODDEF \
87 : : {"pause", (PyCFunction)signal_pause, METH_NOARGS, signal_pause__doc__},
88 : :
89 : : static PyObject *
90 : : signal_pause_impl(PyObject *module);
91 : :
92 : : static PyObject *
93 : 2 : signal_pause(PyObject *module, PyObject *Py_UNUSED(ignored))
94 : : {
95 : 2 : return signal_pause_impl(module);
96 : : }
97 : :
98 : : #endif /* defined(HAVE_PAUSE) */
99 : :
100 : : PyDoc_STRVAR(signal_raise_signal__doc__,
101 : : "raise_signal($module, signalnum, /)\n"
102 : : "--\n"
103 : : "\n"
104 : : "Send a signal to the executing process.");
105 : :
106 : : #define SIGNAL_RAISE_SIGNAL_METHODDEF \
107 : : {"raise_signal", (PyCFunction)signal_raise_signal, METH_O, signal_raise_signal__doc__},
108 : :
109 : : static PyObject *
110 : : signal_raise_signal_impl(PyObject *module, int signalnum);
111 : :
112 : : static PyObject *
113 : 512843 : signal_raise_signal(PyObject *module, PyObject *arg)
114 : : {
115 : 512843 : PyObject *return_value = NULL;
116 : : int signalnum;
117 : :
118 : 512843 : signalnum = _PyLong_AsInt(arg);
119 [ - + - - ]: 512843 : if (signalnum == -1 && PyErr_Occurred()) {
120 : 0 : goto exit;
121 : : }
122 : 512843 : return_value = signal_raise_signal_impl(module, signalnum);
123 : :
124 : 512843 : exit:
125 : 512843 : return return_value;
126 : : }
127 : :
128 : : PyDoc_STRVAR(signal_signal__doc__,
129 : : "signal($module, signalnum, handler, /)\n"
130 : : "--\n"
131 : : "\n"
132 : : "Set the action for the given signal.\n"
133 : : "\n"
134 : : "The action can be SIG_DFL, SIG_IGN, or a callable Python object.\n"
135 : : "The previous action is returned. See getsignal() for possible return values.\n"
136 : : "\n"
137 : : "*** IMPORTANT NOTICE ***\n"
138 : : "A signal handler function is called with two arguments:\n"
139 : : "the first is the signal number, the second is the interrupted stack frame.");
140 : :
141 : : #define SIGNAL_SIGNAL_METHODDEF \
142 : : {"signal", _PyCFunction_CAST(signal_signal), METH_FASTCALL, signal_signal__doc__},
143 : :
144 : : static PyObject *
145 : : signal_signal_impl(PyObject *module, int signalnum, PyObject *handler);
146 : :
147 : : static PyObject *
148 : 47321 : signal_signal(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
149 : : {
150 : 47321 : PyObject *return_value = NULL;
151 : : int signalnum;
152 : : PyObject *handler;
153 : :
154 [ + - - + : 47321 : if (!_PyArg_CheckPositional("signal", nargs, 2, 2)) {
- - ]
155 : 0 : goto exit;
156 : : }
157 : 47321 : signalnum = _PyLong_AsInt(args[0]);
158 [ - + - - ]: 47321 : if (signalnum == -1 && PyErr_Occurred()) {
159 : 0 : goto exit;
160 : : }
161 : 47321 : handler = args[1];
162 : 47321 : return_value = signal_signal_impl(module, signalnum, handler);
163 : :
164 : 47321 : exit:
165 : 47321 : return return_value;
166 : : }
167 : :
168 : : PyDoc_STRVAR(signal_getsignal__doc__,
169 : : "getsignal($module, signalnum, /)\n"
170 : : "--\n"
171 : : "\n"
172 : : "Return the current action for the given signal.\n"
173 : : "\n"
174 : : "The return value can be:\n"
175 : : " SIG_IGN -- if the signal is being ignored\n"
176 : : " SIG_DFL -- if the default action for the signal is in effect\n"
177 : : " None -- if an unknown handler is in effect\n"
178 : : " anything else -- the callable Python object used as a handler");
179 : :
180 : : #define SIGNAL_GETSIGNAL_METHODDEF \
181 : : {"getsignal", (PyCFunction)signal_getsignal, METH_O, signal_getsignal__doc__},
182 : :
183 : : static PyObject *
184 : : signal_getsignal_impl(PyObject *module, int signalnum);
185 : :
186 : : static PyObject *
187 : 6491 : signal_getsignal(PyObject *module, PyObject *arg)
188 : : {
189 : 6491 : PyObject *return_value = NULL;
190 : : int signalnum;
191 : :
192 : 6491 : signalnum = _PyLong_AsInt(arg);
193 [ - + - - ]: 6491 : if (signalnum == -1 && PyErr_Occurred()) {
194 : 0 : goto exit;
195 : : }
196 : 6491 : return_value = signal_getsignal_impl(module, signalnum);
197 : :
198 : 6491 : exit:
199 : 6491 : return return_value;
200 : : }
201 : :
202 : : PyDoc_STRVAR(signal_strsignal__doc__,
203 : : "strsignal($module, signalnum, /)\n"
204 : : "--\n"
205 : : "\n"
206 : : "Return the system description of the given signal.\n"
207 : : "\n"
208 : : "The return values can be such as \"Interrupt\", \"Segmentation fault\", etc.\n"
209 : : "Returns None if the signal is not recognized.");
210 : :
211 : : #define SIGNAL_STRSIGNAL_METHODDEF \
212 : : {"strsignal", (PyCFunction)signal_strsignal, METH_O, signal_strsignal__doc__},
213 : :
214 : : static PyObject *
215 : : signal_strsignal_impl(PyObject *module, int signalnum);
216 : :
217 : : static PyObject *
218 : 4 : signal_strsignal(PyObject *module, PyObject *arg)
219 : : {
220 : 4 : PyObject *return_value = NULL;
221 : : int signalnum;
222 : :
223 : 4 : signalnum = _PyLong_AsInt(arg);
224 [ - + - - ]: 4 : if (signalnum == -1 && PyErr_Occurred()) {
225 : 0 : goto exit;
226 : : }
227 : 4 : return_value = signal_strsignal_impl(module, signalnum);
228 : :
229 : 4 : exit:
230 : 4 : return return_value;
231 : : }
232 : :
233 : : #if defined(HAVE_SIGINTERRUPT)
234 : :
235 : : PyDoc_STRVAR(signal_siginterrupt__doc__,
236 : : "siginterrupt($module, signalnum, flag, /)\n"
237 : : "--\n"
238 : : "\n"
239 : : "Change system call restart behaviour.\n"
240 : : "\n"
241 : : "If flag is False, system calls will be restarted when interrupted by\n"
242 : : "signal sig, else system calls will be interrupted.");
243 : :
244 : : #define SIGNAL_SIGINTERRUPT_METHODDEF \
245 : : {"siginterrupt", _PyCFunction_CAST(signal_siginterrupt), METH_FASTCALL, signal_siginterrupt__doc__},
246 : :
247 : : static PyObject *
248 : : signal_siginterrupt_impl(PyObject *module, int signalnum, int flag);
249 : :
250 : : static PyObject *
251 : 284 : signal_siginterrupt(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
252 : : {
253 : 284 : PyObject *return_value = NULL;
254 : : int signalnum;
255 : : int flag;
256 : :
257 [ + - - + : 284 : if (!_PyArg_CheckPositional("siginterrupt", nargs, 2, 2)) {
- - ]
258 : 0 : goto exit;
259 : : }
260 : 284 : signalnum = _PyLong_AsInt(args[0]);
261 [ - + - - ]: 284 : if (signalnum == -1 && PyErr_Occurred()) {
262 : 0 : goto exit;
263 : : }
264 : 284 : flag = _PyLong_AsInt(args[1]);
265 [ - + - - ]: 284 : if (flag == -1 && PyErr_Occurred()) {
266 : 0 : goto exit;
267 : : }
268 : 284 : return_value = signal_siginterrupt_impl(module, signalnum, flag);
269 : :
270 : 284 : exit:
271 : 284 : return return_value;
272 : : }
273 : :
274 : : #endif /* defined(HAVE_SIGINTERRUPT) */
275 : :
276 : : #if defined(HAVE_SETITIMER)
277 : :
278 : : PyDoc_STRVAR(signal_setitimer__doc__,
279 : : "setitimer($module, which, seconds, interval=0.0, /)\n"
280 : : "--\n"
281 : : "\n"
282 : : "Sets given itimer (one of ITIMER_REAL, ITIMER_VIRTUAL or ITIMER_PROF).\n"
283 : : "\n"
284 : : "The timer will fire after value seconds and after that every interval seconds.\n"
285 : : "The itimer can be cleared by setting seconds to zero.\n"
286 : : "\n"
287 : : "Returns old values as a tuple: (delay, interval).");
288 : :
289 : : #define SIGNAL_SETITIMER_METHODDEF \
290 : : {"setitimer", _PyCFunction_CAST(signal_setitimer), METH_FASTCALL, signal_setitimer__doc__},
291 : :
292 : : static PyObject *
293 : : signal_setitimer_impl(PyObject *module, int which, PyObject *seconds,
294 : : PyObject *interval);
295 : :
296 : : static PyObject *
297 : 25476 : signal_setitimer(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
298 : : {
299 : 25476 : PyObject *return_value = NULL;
300 : : int which;
301 : : PyObject *seconds;
302 : 25476 : PyObject *interval = NULL;
303 : :
304 [ + - - + : 25476 : if (!_PyArg_CheckPositional("setitimer", nargs, 2, 3)) {
- - ]
305 : 0 : goto exit;
306 : : }
307 : 25476 : which = _PyLong_AsInt(args[0]);
308 [ + + - + ]: 25476 : if (which == -1 && PyErr_Occurred()) {
309 : 0 : goto exit;
310 : : }
311 : 25476 : seconds = args[1];
312 [ + + ]: 25476 : if (nargs < 3) {
313 : 25418 : goto skip_optional;
314 : : }
315 : 58 : interval = args[2];
316 : 25476 : skip_optional:
317 : 25476 : return_value = signal_setitimer_impl(module, which, seconds, interval);
318 : :
319 : 25476 : exit:
320 : 25476 : return return_value;
321 : : }
322 : :
323 : : #endif /* defined(HAVE_SETITIMER) */
324 : :
325 : : #if defined(HAVE_GETITIMER)
326 : :
327 : : PyDoc_STRVAR(signal_getitimer__doc__,
328 : : "getitimer($module, which, /)\n"
329 : : "--\n"
330 : : "\n"
331 : : "Returns current value of given itimer.");
332 : :
333 : : #define SIGNAL_GETITIMER_METHODDEF \
334 : : {"getitimer", (PyCFunction)signal_getitimer, METH_O, signal_getitimer__doc__},
335 : :
336 : : static PyObject *
337 : : signal_getitimer_impl(PyObject *module, int which);
338 : :
339 : : static PyObject *
340 : 19804 : signal_getitimer(PyObject *module, PyObject *arg)
341 : : {
342 : 19804 : PyObject *return_value = NULL;
343 : : int which;
344 : :
345 : 19804 : which = _PyLong_AsInt(arg);
346 [ - + - - ]: 19804 : if (which == -1 && PyErr_Occurred()) {
347 : 0 : goto exit;
348 : : }
349 : 19804 : return_value = signal_getitimer_impl(module, which);
350 : :
351 : 19804 : exit:
352 : 19804 : return return_value;
353 : : }
354 : :
355 : : #endif /* defined(HAVE_GETITIMER) */
356 : :
357 : : #if defined(HAVE_SIGSET_T) && defined(PYPTHREAD_SIGMASK)
358 : :
359 : : PyDoc_STRVAR(signal_pthread_sigmask__doc__,
360 : : "pthread_sigmask($module, how, mask, /)\n"
361 : : "--\n"
362 : : "\n"
363 : : "Fetch and/or change the signal mask of the calling thread.");
364 : :
365 : : #define SIGNAL_PTHREAD_SIGMASK_METHODDEF \
366 : : {"pthread_sigmask", _PyCFunction_CAST(signal_pthread_sigmask), METH_FASTCALL, signal_pthread_sigmask__doc__},
367 : :
368 : : static PyObject *
369 : : signal_pthread_sigmask_impl(PyObject *module, int how, sigset_t mask);
370 : :
371 : : static PyObject *
372 : 216 : signal_pthread_sigmask(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
373 : : {
374 : 216 : PyObject *return_value = NULL;
375 : : int how;
376 : : sigset_t mask;
377 : :
378 [ + - - + : 216 : if (!_PyArg_CheckPositional("pthread_sigmask", nargs, 2, 2)) {
- - ]
379 : 0 : goto exit;
380 : : }
381 : 216 : how = _PyLong_AsInt(args[0]);
382 [ - + - - ]: 216 : if (how == -1 && PyErr_Occurred()) {
383 : 0 : goto exit;
384 : : }
385 [ + + ]: 216 : if (!_Py_Sigset_Converter(args[1], &mask)) {
386 : 3 : goto exit;
387 : : }
388 : 213 : return_value = signal_pthread_sigmask_impl(module, how, mask);
389 : :
390 : 216 : exit:
391 : 216 : return return_value;
392 : : }
393 : :
394 : : #endif /* defined(HAVE_SIGSET_T) && defined(PYPTHREAD_SIGMASK) */
395 : :
396 : : #if defined(HAVE_SIGSET_T) && defined(HAVE_SIGPENDING)
397 : :
398 : : PyDoc_STRVAR(signal_sigpending__doc__,
399 : : "sigpending($module, /)\n"
400 : : "--\n"
401 : : "\n"
402 : : "Examine pending signals.\n"
403 : : "\n"
404 : : "Returns a set of signal numbers that are pending for delivery to\n"
405 : : "the calling thread.");
406 : :
407 : : #define SIGNAL_SIGPENDING_METHODDEF \
408 : : {"sigpending", (PyCFunction)signal_sigpending, METH_NOARGS, signal_sigpending__doc__},
409 : :
410 : : static PyObject *
411 : : signal_sigpending_impl(PyObject *module);
412 : :
413 : : static PyObject *
414 : 2 : signal_sigpending(PyObject *module, PyObject *Py_UNUSED(ignored))
415 : : {
416 : 2 : return signal_sigpending_impl(module);
417 : : }
418 : :
419 : : #endif /* defined(HAVE_SIGSET_T) && defined(HAVE_SIGPENDING) */
420 : :
421 : : #if defined(HAVE_SIGSET_T) && defined(HAVE_SIGWAIT)
422 : :
423 : : PyDoc_STRVAR(signal_sigwait__doc__,
424 : : "sigwait($module, sigset, /)\n"
425 : : "--\n"
426 : : "\n"
427 : : "Wait for a signal.\n"
428 : : "\n"
429 : : "Suspend execution of the calling thread until the delivery of one of the\n"
430 : : "signals specified in the signal set sigset. The function accepts the signal\n"
431 : : "and returns the signal number.");
432 : :
433 : : #define SIGNAL_SIGWAIT_METHODDEF \
434 : : {"sigwait", (PyCFunction)signal_sigwait, METH_O, signal_sigwait__doc__},
435 : :
436 : : static PyObject *
437 : : signal_sigwait_impl(PyObject *module, sigset_t sigset);
438 : :
439 : : static PyObject *
440 : 2 : signal_sigwait(PyObject *module, PyObject *arg)
441 : : {
442 : 2 : PyObject *return_value = NULL;
443 : : sigset_t sigset;
444 : :
445 [ - + ]: 2 : if (!_Py_Sigset_Converter(arg, &sigset)) {
446 : 0 : goto exit;
447 : : }
448 : 2 : return_value = signal_sigwait_impl(module, sigset);
449 : :
450 : 2 : exit:
451 : 2 : return return_value;
452 : : }
453 : :
454 : : #endif /* defined(HAVE_SIGSET_T) && defined(HAVE_SIGWAIT) */
455 : :
456 : : #if ((defined(HAVE_SIGFILLSET) && defined(HAVE_SIGSET_T)) || defined(MS_WINDOWS))
457 : :
458 : : PyDoc_STRVAR(signal_valid_signals__doc__,
459 : : "valid_signals($module, /)\n"
460 : : "--\n"
461 : : "\n"
462 : : "Return a set of valid signal numbers on this platform.\n"
463 : : "\n"
464 : : "The signal numbers returned by this function can be safely passed to\n"
465 : : "functions like `pthread_sigmask`.");
466 : :
467 : : #define SIGNAL_VALID_SIGNALS_METHODDEF \
468 : : {"valid_signals", (PyCFunction)signal_valid_signals, METH_NOARGS, signal_valid_signals__doc__},
469 : :
470 : : static PyObject *
471 : : signal_valid_signals_impl(PyObject *module);
472 : :
473 : : static PyObject *
474 : 697 : signal_valid_signals(PyObject *module, PyObject *Py_UNUSED(ignored))
475 : : {
476 : 697 : return signal_valid_signals_impl(module);
477 : : }
478 : :
479 : : #endif /* ((defined(HAVE_SIGFILLSET) && defined(HAVE_SIGSET_T)) || defined(MS_WINDOWS)) */
480 : :
481 : : #if defined(HAVE_SIGSET_T) && defined(HAVE_SIGWAITINFO)
482 : :
483 : : PyDoc_STRVAR(signal_sigwaitinfo__doc__,
484 : : "sigwaitinfo($module, sigset, /)\n"
485 : : "--\n"
486 : : "\n"
487 : : "Wait synchronously until one of the signals in *sigset* is delivered.\n"
488 : : "\n"
489 : : "Returns a struct_siginfo containing information about the signal.");
490 : :
491 : : #define SIGNAL_SIGWAITINFO_METHODDEF \
492 : : {"sigwaitinfo", (PyCFunction)signal_sigwaitinfo, METH_O, signal_sigwaitinfo__doc__},
493 : :
494 : : static PyObject *
495 : : signal_sigwaitinfo_impl(PyObject *module, sigset_t sigset);
496 : :
497 : : static PyObject *
498 : 2 : signal_sigwaitinfo(PyObject *module, PyObject *arg)
499 : : {
500 : 2 : PyObject *return_value = NULL;
501 : : sigset_t sigset;
502 : :
503 [ - + ]: 2 : if (!_Py_Sigset_Converter(arg, &sigset)) {
504 : 0 : goto exit;
505 : : }
506 : 2 : return_value = signal_sigwaitinfo_impl(module, sigset);
507 : :
508 : 2 : exit:
509 : 2 : return return_value;
510 : : }
511 : :
512 : : #endif /* defined(HAVE_SIGSET_T) && defined(HAVE_SIGWAITINFO) */
513 : :
514 : : #if defined(HAVE_SIGSET_T) && defined(HAVE_SIGTIMEDWAIT)
515 : :
516 : : PyDoc_STRVAR(signal_sigtimedwait__doc__,
517 : : "sigtimedwait($module, sigset, timeout, /)\n"
518 : : "--\n"
519 : : "\n"
520 : : "Like sigwaitinfo(), but with a timeout.\n"
521 : : "\n"
522 : : "The timeout is specified in seconds, with floating point numbers allowed.");
523 : :
524 : : #define SIGNAL_SIGTIMEDWAIT_METHODDEF \
525 : : {"sigtimedwait", _PyCFunction_CAST(signal_sigtimedwait), METH_FASTCALL, signal_sigtimedwait__doc__},
526 : :
527 : : static PyObject *
528 : : signal_sigtimedwait_impl(PyObject *module, sigset_t sigset,
529 : : PyObject *timeout_obj);
530 : :
531 : : static PyObject *
532 : 5 : signal_sigtimedwait(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
533 : : {
534 : 5 : PyObject *return_value = NULL;
535 : : sigset_t sigset;
536 : : PyObject *timeout_obj;
537 : :
538 [ + - - + : 5 : if (!_PyArg_CheckPositional("sigtimedwait", nargs, 2, 2)) {
- - ]
539 : 0 : goto exit;
540 : : }
541 [ - + ]: 5 : if (!_Py_Sigset_Converter(args[0], &sigset)) {
542 : 0 : goto exit;
543 : : }
544 : 5 : timeout_obj = args[1];
545 : 5 : return_value = signal_sigtimedwait_impl(module, sigset, timeout_obj);
546 : :
547 : 5 : exit:
548 : 5 : return return_value;
549 : : }
550 : :
551 : : #endif /* defined(HAVE_SIGSET_T) && defined(HAVE_SIGTIMEDWAIT) */
552 : :
553 : : #if defined(HAVE_PTHREAD_KILL)
554 : :
555 : : PyDoc_STRVAR(signal_pthread_kill__doc__,
556 : : "pthread_kill($module, thread_id, signalnum, /)\n"
557 : : "--\n"
558 : : "\n"
559 : : "Send a signal to a thread.");
560 : :
561 : : #define SIGNAL_PTHREAD_KILL_METHODDEF \
562 : : {"pthread_kill", _PyCFunction_CAST(signal_pthread_kill), METH_FASTCALL, signal_pthread_kill__doc__},
563 : :
564 : : static PyObject *
565 : : signal_pthread_kill_impl(PyObject *module, unsigned long thread_id,
566 : : int signalnum);
567 : :
568 : : static PyObject *
569 : 4 : signal_pthread_kill(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
570 : : {
571 : 4 : PyObject *return_value = NULL;
572 : : unsigned long thread_id;
573 : : int signalnum;
574 : :
575 [ + - - + : 4 : if (!_PyArg_CheckPositional("pthread_kill", nargs, 2, 2)) {
- - ]
576 : 0 : goto exit;
577 : : }
578 [ - + ]: 4 : if (!PyLong_Check(args[0])) {
579 : 0 : _PyArg_BadArgument("pthread_kill", "argument 1", "int", args[0]);
580 : 0 : goto exit;
581 : : }
582 : 4 : thread_id = PyLong_AsUnsignedLongMask(args[0]);
583 : 4 : signalnum = _PyLong_AsInt(args[1]);
584 [ - + - - ]: 4 : if (signalnum == -1 && PyErr_Occurred()) {
585 : 0 : goto exit;
586 : : }
587 : 4 : return_value = signal_pthread_kill_impl(module, thread_id, signalnum);
588 : :
589 : 4 : exit:
590 : 4 : return return_value;
591 : : }
592 : :
593 : : #endif /* defined(HAVE_PTHREAD_KILL) */
594 : :
595 : : #if (defined(__linux__) && defined(__NR_pidfd_send_signal))
596 : :
597 : : PyDoc_STRVAR(signal_pidfd_send_signal__doc__,
598 : : "pidfd_send_signal($module, pidfd, signalnum, siginfo=None, flags=0, /)\n"
599 : : "--\n"
600 : : "\n"
601 : : "Send a signal to a process referred to by a pid file descriptor.");
602 : :
603 : : #define SIGNAL_PIDFD_SEND_SIGNAL_METHODDEF \
604 : : {"pidfd_send_signal", _PyCFunction_CAST(signal_pidfd_send_signal), METH_FASTCALL, signal_pidfd_send_signal__doc__},
605 : :
606 : : static PyObject *
607 : : signal_pidfd_send_signal_impl(PyObject *module, int pidfd, int signalnum,
608 : : PyObject *siginfo, int flags);
609 : :
610 : : static PyObject *
611 : 3 : signal_pidfd_send_signal(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
612 : : {
613 : 3 : PyObject *return_value = NULL;
614 : : int pidfd;
615 : : int signalnum;
616 : 3 : PyObject *siginfo = Py_None;
617 : 3 : int flags = 0;
618 : :
619 [ + - - + : 3 : if (!_PyArg_CheckPositional("pidfd_send_signal", nargs, 2, 4)) {
- - ]
620 : 0 : goto exit;
621 : : }
622 : 3 : pidfd = _PyLong_AsInt(args[0]);
623 [ - + - - ]: 3 : if (pidfd == -1 && PyErr_Occurred()) {
624 : 0 : goto exit;
625 : : }
626 : 3 : signalnum = _PyLong_AsInt(args[1]);
627 [ - + - - ]: 3 : if (signalnum == -1 && PyErr_Occurred()) {
628 : 0 : goto exit;
629 : : }
630 [ + + ]: 3 : if (nargs < 3) {
631 : 2 : goto skip_optional;
632 : : }
633 : 1 : siginfo = args[2];
634 [ - + ]: 1 : if (nargs < 4) {
635 : 0 : goto skip_optional;
636 : : }
637 : 1 : flags = _PyLong_AsInt(args[3]);
638 [ - + - - ]: 1 : if (flags == -1 && PyErr_Occurred()) {
639 : 0 : goto exit;
640 : : }
641 : 1 : skip_optional:
642 : 3 : return_value = signal_pidfd_send_signal_impl(module, pidfd, signalnum, siginfo, flags);
643 : :
644 : 3 : exit:
645 : 3 : return return_value;
646 : : }
647 : :
648 : : #endif /* (defined(__linux__) && defined(__NR_pidfd_send_signal)) */
649 : :
650 : : #ifndef SIGNAL_ALARM_METHODDEF
651 : : #define SIGNAL_ALARM_METHODDEF
652 : : #endif /* !defined(SIGNAL_ALARM_METHODDEF) */
653 : :
654 : : #ifndef SIGNAL_PAUSE_METHODDEF
655 : : #define SIGNAL_PAUSE_METHODDEF
656 : : #endif /* !defined(SIGNAL_PAUSE_METHODDEF) */
657 : :
658 : : #ifndef SIGNAL_SIGINTERRUPT_METHODDEF
659 : : #define SIGNAL_SIGINTERRUPT_METHODDEF
660 : : #endif /* !defined(SIGNAL_SIGINTERRUPT_METHODDEF) */
661 : :
662 : : #ifndef SIGNAL_SETITIMER_METHODDEF
663 : : #define SIGNAL_SETITIMER_METHODDEF
664 : : #endif /* !defined(SIGNAL_SETITIMER_METHODDEF) */
665 : :
666 : : #ifndef SIGNAL_GETITIMER_METHODDEF
667 : : #define SIGNAL_GETITIMER_METHODDEF
668 : : #endif /* !defined(SIGNAL_GETITIMER_METHODDEF) */
669 : :
670 : : #ifndef SIGNAL_PTHREAD_SIGMASK_METHODDEF
671 : : #define SIGNAL_PTHREAD_SIGMASK_METHODDEF
672 : : #endif /* !defined(SIGNAL_PTHREAD_SIGMASK_METHODDEF) */
673 : :
674 : : #ifndef SIGNAL_SIGPENDING_METHODDEF
675 : : #define SIGNAL_SIGPENDING_METHODDEF
676 : : #endif /* !defined(SIGNAL_SIGPENDING_METHODDEF) */
677 : :
678 : : #ifndef SIGNAL_SIGWAIT_METHODDEF
679 : : #define SIGNAL_SIGWAIT_METHODDEF
680 : : #endif /* !defined(SIGNAL_SIGWAIT_METHODDEF) */
681 : :
682 : : #ifndef SIGNAL_VALID_SIGNALS_METHODDEF
683 : : #define SIGNAL_VALID_SIGNALS_METHODDEF
684 : : #endif /* !defined(SIGNAL_VALID_SIGNALS_METHODDEF) */
685 : :
686 : : #ifndef SIGNAL_SIGWAITINFO_METHODDEF
687 : : #define SIGNAL_SIGWAITINFO_METHODDEF
688 : : #endif /* !defined(SIGNAL_SIGWAITINFO_METHODDEF) */
689 : :
690 : : #ifndef SIGNAL_SIGTIMEDWAIT_METHODDEF
691 : : #define SIGNAL_SIGTIMEDWAIT_METHODDEF
692 : : #endif /* !defined(SIGNAL_SIGTIMEDWAIT_METHODDEF) */
693 : :
694 : : #ifndef SIGNAL_PTHREAD_KILL_METHODDEF
695 : : #define SIGNAL_PTHREAD_KILL_METHODDEF
696 : : #endif /* !defined(SIGNAL_PTHREAD_KILL_METHODDEF) */
697 : :
698 : : #ifndef SIGNAL_PIDFD_SEND_SIGNAL_METHODDEF
699 : : #define SIGNAL_PIDFD_SEND_SIGNAL_METHODDEF
700 : : #endif /* !defined(SIGNAL_PIDFD_SEND_SIGNAL_METHODDEF) */
701 : : /*[clinic end generated code: output=6ca1b70310eecdba input=a9049054013a1b77]*/
|
