summaryrefslogtreecommitdiffstats
path: root/Modules/signalmodule.c
blob: 9e7f2396442318aa884745836752d88ca34afbad (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
/***********************************************************
Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
The Netherlands.

                        All Rights Reserved

Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the names of Stichting Mathematisch
Centrum or CWI or Corporation for National Research Initiatives or
CNRI not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission.

While CWI is the initial source for this software, a modified version
is made available by the Corporation for National Research Initiatives
(CNRI) at the Internet address ftp://ftp.python.org.

STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.

******************************************************************/

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

#include "Python.h"
#include "intrcheck.h"

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

#include <signal.h>

#ifndef SIG_ERR
#define SIG_ERR ((RETSIGTYPE (*)())-1)
#endif

#ifndef NSIG
#define NSIG (_SIGMAX + 1)	/* For QNX */
#endif


/*
   NOTES ON THE INTERACTION BETWEEN SIGNALS AND THREADS

   When threads are supported, we want the following semantics:

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

   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 (an intermediate possibility would
   be to deliver it to the main thread -- POSIX?).  For now, we have
   a working implementation that works in all three cases -- the
   handler ignores signals if getpid() isn't the same as in the main
   thread.  XXX This is a hack.

*/

#ifdef WITH_THREAD
#include "thread.h"
static long main_thread;
static pid_t main_pid;
#endif

struct PySignal_SignalArrayStruct {
	int	tripped;
	PyObject *func;
};

static struct PySignal_SignalArrayStruct PySignal_SignalHandlerArray[NSIG];
static int PySignal_IsTripped = 0; /* Speed up sigcheck() when none tripped */

static PyObject *PySignal_SignalDefaultHandler;
static PyObject *PySignal_SignalIgnoreHandler;
static PyObject *PySignal_DefaultIntHandler;

static PyObject *
PySignal_CDefaultIntHandler(self, arg)
	PyObject *self;
	PyObject *arg;
{
	PyErr_SetNone(PyExc_KeyboardInterrupt);
	return (PyObject *)NULL;
}

void
PyErr_SetInterrupt()
{
	PySignal_IsTripped++;
	PySignal_SignalHandlerArray[SIGINT].tripped = 1;
}

static RETSIGTYPE
PySignal_Handler(sig_num)
	int sig_num;
{
#ifdef WITH_THREAD
	/* See NOTES section above */
	if (getpid() == main_pid) {
#endif
		PySignal_IsTripped++;
		PySignal_SignalHandlerArray[sig_num].tripped = 1;
#ifdef WITH_THREAD
	}
#endif
#ifdef SIGCHLD
	if (sig_num == SIGCHLD) {
		/* 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... */
		return;
	}
#endif
	(void *)signal(sig_num, &PySignal_Handler);
}


#ifndef DONT_HAVE_SIG_ALARM
static PyObject *
PySignal_Alarm(self, args)
	PyObject *self; /* Not used */
	PyObject *args;
{
	int t;
	if (!PyArg_Parse(args, "i", &t))
		return (PyObject *)NULL;
	/* alarm() returns the number of seconds remaining */
	return PyInt_FromLong(alarm(t));
}
#endif

#ifndef DONT_HAVE_SIG_PAUSE
static PyObject *
PySignal_Pause(self, args)
	PyObject *self; /* Not used */
	PyObject *args;
{
	if (!PyArg_NoArgs(args))
		return NULL;
	Py_BEGIN_ALLOW_THREADS
	pause();
	Py_END_ALLOW_THREADS
	Py_INCREF(Py_None);
	return Py_None;
}
#endif

static PyObject *
PySignal_Signal(self, args)
	PyObject *self; /* Not used */
	PyObject *args;
{
	PyObject *obj;
	int sig_num;
	PyObject *old_handler;
	RETSIGTYPE (*func)();
	if (!PyArg_Parse(args, "(iO)", &sig_num, &obj))
		return (PyObject *)NULL;
#ifdef WITH_THREAD
	if (get_thread_ident() != main_thread) {
		PyErr_SetString(PyExc_ValueError,
				"signal only works in main thread");
		return (PyObject *)NULL;
	}
#endif
	if (sig_num < 1 || sig_num >= NSIG) {
		PyErr_SetString(PyExc_ValueError,
				"signal number out of range");
		return (PyObject *)NULL;
	}
	if (obj == PySignal_SignalIgnoreHandler)
		func = SIG_IGN;
	else if (obj == PySignal_SignalDefaultHandler)
		func = SIG_DFL;
	else if (!PyCallable_Check(obj)) {
		PyErr_SetString(PyExc_TypeError,
"signal handler must be signal.SIG_IGN, signal.SIG_DFL, or a callable object");
		return (PyObject *)NULL;
	}
	else
		func = PySignal_Handler;
	if (signal(sig_num, func) == SIG_ERR) {
		PyErr_SetFromErrno(PyExc_RuntimeError);
		return (PyObject *)NULL;
	}
	old_handler = PySignal_SignalHandlerArray[sig_num].func;
	PySignal_SignalHandlerArray[sig_num].tripped = 0;
	Py_INCREF(obj);
	PySignal_SignalHandlerArray[sig_num].func = obj;
	return old_handler;
}

static PyObject *
PySignal_GetSignal(self, args)
	PyObject *self; /* Not used */
	PyObject *args;
{
	int sig_num;
	PyObject *old_handler;
	if (!PyArg_Parse(args, "i", &sig_num))
		return (PyObject *)NULL;
	if (sig_num < 1 || sig_num >= NSIG) {
		PyErr_SetString(PyExc_ValueError,
				"signal number out of range");
		return (PyObject *)NULL;
	}
	old_handler = PySignal_SignalHandlerArray[sig_num].func;
	Py_INCREF(old_handler);
	return old_handler;
}


/* List of functions defined in the module */

static PyMethodDef PySignal_methods[] = {
#ifndef DONT_HAVE_SIG_ALARM
	{"alarm",	PySignal_Alarm},
#endif
	{"signal",	PySignal_Signal},
	{"getsignal",	PySignal_GetSignal},
#ifndef DONT_HAVE_SIG_PAUSE
	{"pause",	PySignal_Pause},
#endif
	{"default_int_handler", PySignal_CDefaultIntHandler},
	{NULL,		NULL}		/* sentinel */
};

void
initsignal()
{
	PyObject *m, *d, *x;
	int i;

#ifdef WITH_THREAD
	main_thread = get_thread_ident();
	main_pid = getpid();
#endif

	/* Create the module and add the functions */
	m = Py_InitModule("signal", PySignal_methods);

	/* Add some symbolic constants to the module */
	d = PyModule_GetDict(m);

	PySignal_SignalDefaultHandler = PyInt_FromLong((long)SIG_DFL);
	PyDict_SetItemString(d, "SIG_DFL", PySignal_SignalDefaultHandler);
	PySignal_SignalIgnoreHandler = PyInt_FromLong((long)SIG_IGN);
	PyDict_SetItemString(d, "SIG_IGN", PySignal_SignalIgnoreHandler);
	PyDict_SetItemString(d, "NSIG", PyInt_FromLong((long)NSIG));
	PySignal_DefaultIntHandler =
		PyDict_GetItemString(d, "default_int_handler");

	PySignal_SignalHandlerArray[0].tripped = 0;
	for (i = 1; i < NSIG; i++) {
		RETSIGTYPE (*t)();
#ifdef HAVE_SIGACTION
		struct sigaction act;
		sigaction(i,  0, &act);
		t = act.sa_handler;
#else
		t = signal(i, SIG_IGN);
		signal(i, t);
#endif
		PySignal_SignalHandlerArray[i].tripped = 0;
		if (t == SIG_DFL)
			PySignal_SignalHandlerArray[i].func =
				PySignal_SignalDefaultHandler;
		else if (t == SIG_IGN)
			PySignal_SignalHandlerArray[i].func =
				PySignal_SignalIgnoreHandler;
		else
			PySignal_SignalHandlerArray[i].func =
				Py_None; /* None of our business */
		Py_INCREF(PySignal_SignalHandlerArray[i].func);
	}
	if (PySignal_SignalHandlerArray[SIGINT].func ==
	    PySignal_SignalDefaultHandler) {
		/* Install default int handler */
		Py_DECREF(PySignal_SignalHandlerArray[SIGINT].func);
		PySignal_SignalHandlerArray[SIGINT].func =
			PySignal_DefaultIntHandler;
		Py_INCREF(PySignal_DefaultIntHandler);
		signal(SIGINT, &PySignal_Handler);
	}

#ifdef SIGHUP
	x = PyInt_FromLong(SIGHUP);
	PyDict_SetItemString(d, "SIGHUP", x);
#endif
#ifdef SIGINT
	x = PyInt_FromLong(SIGINT);
	PyDict_SetItemString(d, "SIGINT", x);
#endif
#ifdef SIGQUIT
	x = PyInt_FromLong(SIGQUIT);
	PyDict_SetItemString(d, "SIGQUIT", x);
#endif
#ifdef SIGILL
	x = PyInt_FromLong(SIGILL);
	PyDict_SetItemString(d, "SIGILL", x);
#endif
#ifdef SIGTRAP
	x = PyInt_FromLong(SIGTRAP);
	PyDict_SetItemString(d, "SIGTRAP", x);
#endif
#ifdef SIGIOT
	x = PyInt_FromLong(SIGIOT);
	PyDict_SetItemString(d, "SIGIOT", x);
#endif
#ifdef SIGABRT
	x = PyInt_FromLong(SIGABRT);
	PyDict_SetItemString(d, "SIGABRT", x);
#endif
#ifdef SIGEMT
	x = PyInt_FromLong(SIGEMT);
	PyDict_SetItemString(d, "SIGEMT", x);
#endif
#ifdef SIGFPE
	x = PyInt_FromLong(SIGFPE);
	PyDict_SetItemString(d, "SIGFPE", x);
#endif
#ifdef SIGKILL
	x = PyInt_FromLong(SIGKILL);
	PyDict_SetItemString(d, "SIGKILL", x);
#endif
#ifdef SIGBUS
	x = PyInt_FromLong(SIGBUS);
	PyDict_SetItemString(d, "SIGBUS", x);
#endif
#ifdef SIGSEGV
	x = PyInt_FromLong(SIGSEGV);
	PyDict_SetItemString(d, "SIGSEGV", x);
#endif
#ifdef SIGSYS
	x = PyInt_FromLong(SIGSYS);
	PyDict_SetItemString(d, "SIGSYS", x);
#endif
#ifdef SIGPIPE
	x = PyInt_FromLong(SIGPIPE);
	PyDict_SetItemString(d, "SIGPIPE", x);
#endif
#ifdef SIGALRM
	x = PyInt_FromLong(SIGALRM);
	PyDict_SetItemString(d, "SIGALRM", x);
#endif
#ifdef SIGTERM
	x = PyInt_FromLong(SIGTERM);
	PyDict_SetItemString(d, "SIGTERM", x);
#endif
#ifdef SIGUSR1
	x = PyInt_FromLong(SIGUSR1);
	PyDict_SetItemString(d, "SIGUSR1", x);
#endif
#ifdef SIGUSR2
	x = PyInt_FromLong(SIGUSR2);
	PyDict_SetItemString(d, "SIGUSR2", x);
#endif
#ifdef SIGCLD
	x = PyInt_FromLong(SIGCLD);
	PyDict_SetItemString(d, "SIGCLD", x);
#endif
#ifdef SIGCHLD
	x = PyInt_FromLong(SIGCHLD);
	PyDict_SetItemString(d, "SIGCHLD", x);
#endif
#ifdef SIGPWR
	x = PyInt_FromLong(SIGPWR);
	PyDict_SetItemString(d, "SIGPWR", x);
#endif
#ifdef SIGIO
	x = PyInt_FromLong(SIGIO);
	PyDict_SetItemString(d, "SIGIO", x);
#endif
#ifdef SIGURG
	x = PyInt_FromLong(SIGURG);
	PyDict_SetItemString(d, "SIGURG", x);
#endif
#ifdef SIGWINCH
	x = PyInt_FromLong(SIGWINCH);
	PyDict_SetItemString(d, "SIGWINCH", x);
#endif
#ifdef SIGPOLL
	x = PyInt_FromLong(SIGPOLL);
	PyDict_SetItemString(d, "SIGPOLL", x);
#endif
#ifdef SIGSTOP
	x = PyInt_FromLong(SIGSTOP);
	PyDict_SetItemString(d, "SIGSTOP", x);
#endif
#ifdef SIGTSTP
	x = PyInt_FromLong(SIGTSTP);
	PyDict_SetItemString(d, "SIGTSTP", x);
#endif
#ifdef SIGCONT
	x = PyInt_FromLong(SIGCONT);
	PyDict_SetItemString(d, "SIGCONT", x);
#endif
#ifdef SIGTTIN
	x = PyInt_FromLong(SIGTTIN);
	PyDict_SetItemString(d, "SIGTTIN", x);
#endif
#ifdef SIGTTOU
	x = PyInt_FromLong(SIGTTOU);
	PyDict_SetItemString(d, "SIGTTOU", x);
#endif
#ifdef SIGVTALRM
	x = PyInt_FromLong(SIGVTALRM);
	PyDict_SetItemString(d, "SIGVTALRM", x);
#endif
#ifdef SIGPROF
	x = PyInt_FromLong(SIGPROF);
	PyDict_SetItemString(d, "SIGPROF", x);
#endif
#ifdef SIGCPU
	x = PyInt_FromLong(SIGCPU);
	PyDict_SetItemString(d, "SIGCPU", x);
#endif
#ifdef SIGFSZ
	x = PyInt_FromLong(SIGFSZ);
	PyDict_SetItemString(d, "SIGFSZ", x);
#endif
	/* Check for errors */
	if (PyErr_Occurred())
		Py_FatalError("can't initialize module signal");
}

int
PyErr_CheckSignals()
{
	int i;
	PyObject *f;
	if (!PySignal_IsTripped)
		return 0;
#ifdef WITH_THREAD
	if (get_thread_ident() != main_thread)
		return 0;
#endif
	f = PyEval_GetFrame();
	if (f == (PyObject *)NULL)
		f = Py_None;
	for (i = 1; i < NSIG; i++) {
		if (PySignal_SignalHandlerArray[i].tripped) {
			PyObject *arglist, *result;
			PySignal_SignalHandlerArray[i].tripped = 0;
			arglist = Py_BuildValue("(iO)", i, f);
			if (arglist == (PyObject *)NULL)
				result = (PyObject *)NULL;
			else {
				result = PyEval_CallObject(
				 PySignal_SignalHandlerArray[i].func, arglist);
				Py_DECREF(arglist);
			}
			if (result == (PyObject *)NULL) {
				return 1;
			} else {
				Py_DECREF(result);
			}
		}
	}
	PySignal_IsTripped = 0;
	return 0;
}

/* Replacement for intrcheck.c functionality */

void
PyOS_InitInterrupts ()
{
	initsignal();
}

int
PyOS_InterruptOccurred ()
{
	if (PySignal_SignalHandlerArray[SIGINT].tripped) {
#ifdef WITH_THREAD
		if (get_thread_ident() != main_thread)
			return 0;
#endif
		PySignal_SignalHandlerArray[SIGINT].tripped = 0;
		return 1;
	}
	return 0;
}