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

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

#include "Python.h"

#include "intrcheck.h"

#ifdef MS_WINDOWS

#include <process.h>

#endif

#include <signal.h>

#include <sys/stat.h>

#ifdef HAVE_SYS_TIME_H

#include <sys/time.h>

#endif

#ifndef SIG_ERR

#define SIG_ERR ((PyOS_sighandler_t)(-1))

#endif

#if defined(PYOS_OS2) && !defined(PYCC_GCC)

#define NSIG 12

#include <process.h>

#endif

#ifndef NSIG

# if defined(_NSIG)

#  define NSIG _NSIG		/* For BSD/SysV */

# elif defined(_SIGMAX)

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

# elif defined(SIGMAX)

#  define NSIG (SIGMAX + 1)	/* For djgpp */

# else

#  define NSIG 64		/* Use a reasonable default value */

# endif

#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.

   GNU pth is a user-space threading library, and as such, all threads

   run within the same process. In this case, if the currently running

   thread is not the main_thread, send the signal to the main_thread.

*/

#ifdef WITH_THREAD

#include <sys/types.h> /* For pid_t */

#include "pythread.h"

static long main_thread;

static pid_t main_pid;

#endif

static struct {

        int tripped;

        PyObject *func;

} Handlers[NSIG];

static sig_atomic_t wakeup_fd = -1;

/* Speed up sigcheck() when none tripped */

static volatile sig_atomic_t is_tripped = 0;

static PyObject *DefaultHandler;

static PyObject *IgnoreHandler;

static PyObject *IntHandler;

/* On Solaris 8, gcc will produce a warning that the function

   declaration is not a prototype. This is caused by the definition of

   SIG_DFL as (void (*)())0; the correct declaration would have been

   (void (*)(int))0. */

static PyOS_sighandler_t old_siginthandler = SIG_DFL;

#ifdef HAVE_GETITIMER

static PyObject *ItimerError;

/* auxiliary functions for setitimer/getitimer */

static void

timeval_from_double(double d, struct timeval *tv)

{

    tv->tv_sec = floor(d);

    tv->tv_usec = fmod(d, 1.0) * 1000000.0;

}

Py_LOCAL_INLINE(double)

double_from_timeval(struct timeval *tv)

{

    return tv->tv_sec + (double)(tv->tv_usec / 1000000.0);

}

static PyObject *

itimer_retval(struct itimerval *iv)

{

    PyObject *r, *v;

    r = PyTuple_New(2);

    if (r == NULL)

        return NULL;

    if(!(v = PyFloat_FromDouble(double_from_timeval(&iv->it_value)))) {

        Py_DECREF(r);   

        return NULL;

    }

    PyTuple_SET_ITEM(r, 0, v);

    if(!(v = PyFloat_FromDouble(double_from_timeval(&iv->it_interval)))) {

        Py_DECREF(r);

        return NULL;

    }

    PyTuple_SET_ITEM(r, 1, v);

    return r;

}

#endif

static PyObject *

signal_default_int_handler(PyObject *self, PyObject *args)

{

	PyErr_SetNone(PyExc_KeyboardInterrupt);

	return NULL;

}

PyDoc_STRVAR(default_int_handler_doc,

"default_int_handler(...)\n\

\n\

The default handler for SIGINT installed by Python.\n\

It raises KeyboardInterrupt.");

static int

checksignals_witharg(void * unused)

{

	return PyErr_CheckSignals();

}

static void

signal_handler(int sig_num)

{

#ifdef WITH_THREAD

#ifdef WITH_PTH

	if (PyThread_get_thread_ident() != main_thread) {

		pth_raise(*(pth_t *) main_thread, sig_num);

		return;

	}

#endif

	/* See NOTES section above */

	if (getpid() == main_pid) {

#endif

		Handlers[sig_num].tripped = 1;

                /* Set is_tripped after setting .tripped, as it gets

                   cleared in PyErr_CheckSignals() before .tripped. */

		is_tripped = 1;

		Py_AddPendingCall(checksignals_witharg, NULL);

		if (wakeup_fd != -1)

			write(wakeup_fd, "\0", 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

	PyOS_setsig(sig_num, signal_handler);

}

#ifdef HAVE_ALARM

static PyObject *

signal_alarm(PyObject *self, PyObject *args)

{

	int t;

	if (!PyArg_ParseTuple(args, "i:alarm", &t))

		return NULL;

	/* alarm() returns the number of seconds remaining */

	return PyInt_FromLong((long)alarm(t));

}

PyDoc_STRVAR(alarm_doc,

"alarm(seconds)\n\

\n\

Arrange for SIGALRM to arrive after the given number of seconds.");

#endif

#ifdef HAVE_PAUSE

static PyObject *

signal_pause(PyObject *self)

{

	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())

		return NULL;

	Py_INCREF(Py_None);

	return Py_None;

}

PyDoc_STRVAR(pause_doc,

"pause()\n\

\n\

Wait until a signal arrives.");

#endif

static PyObject *

signal_signal(PyObject *self, PyObject *args)

{

	PyObject *obj;

	int sig_num;

	PyObject *old_handler;

	void (*func)(int);

	if (!PyArg_ParseTuple(args, "iO:signal", &sig_num, &obj))

		return NULL;

#ifdef WITH_THREAD

	if (PyThread_get_thread_ident() != main_thread) {

		PyErr_SetString(PyExc_ValueError,

				"signal only works in main thread");

		return NULL;

	}

#endif

	if (sig_num < 1 || sig_num >= NSIG) {

		PyErr_SetString(PyExc_ValueError,

				"signal number out of range");

		return NULL;

	}

	if (obj == IgnoreHandler)

		func = SIG_IGN;

	else if (obj == DefaultHandler)

		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 NULL;

	}

	else

		func = signal_handler;

	if (PyOS_setsig(sig_num, func) == SIG_ERR) {

		PyErr_SetFromErrno(PyExc_RuntimeError);

		return NULL;

	}

	old_handler = Handlers[sig_num].func;

	Handlers[sig_num].tripped = 0;

	Py_INCREF(obj);

	Handlers[sig_num].func = obj;

	return old_handler;

}

PyDoc_STRVAR(signal_doc,

"signal(sig, action) -> action\n\

\n\

Set the action for the given signal.  The action can be SIG_DFL,\n\

SIG_IGN, or a callable Python object.  The previous action is\n\

returned.  See getsignal() for possible return values.\n\

\n\

*** IMPORTANT NOTICE ***\n\

A signal handler function is called with two arguments:\n\

the first is the signal number, the second is the interrupted stack frame.");

static PyObject *

signal_getsignal(PyObject *self, PyObject *args)

{

	int sig_num;

	PyObject *old_handler;

	if (!PyArg_ParseTuple(args, "i:getsignal", &sig_num))

		return NULL;

	if (sig_num < 1 || sig_num >= NSIG) {

		PyErr_SetString(PyExc_ValueError,

				"signal number out of range");

		return NULL;

	}

	old_handler = Handlers[sig_num].func;

	Py_INCREF(old_handler);

	return old_handler;

}

PyDoc_STRVAR(getsignal_doc,

"getsignal(sig) -> action\n\

\n\

Return the current action for the given signal.  The return value can be:\n\

SIG_IGN -- if the signal is being ignored\n\

SIG_DFL -- if the default action for the signal is in effect\n\

None -- if an unknown handler is in effect\n\

anything else -- the callable Python object used as a handler");

#ifdef HAVE_SIGINTERRUPT

PyDoc_STRVAR(siginterrupt_doc,

"siginterrupt(sig, flag) -> None\n\

change system call restart behaviour: if flag is False, system calls\n\

will be restarted when interrupted by signal sig, else system calls\n\

will be interrupted.");

static PyObject *

signal_siginterrupt(PyObject *self, PyObject *args)

{

	int sig_num;

	int flag;

	if (!PyArg_ParseTuple(args, "ii:siginterrupt", &sig_num, &flag))

		return NULL;

	if (sig_num < 1 || sig_num >= NSIG) {

		PyErr_SetString(PyExc_ValueError,

				"signal number out of range");

		return NULL;

	}

	if (siginterrupt(sig_num, flag)<0) {

		PyErr_SetFromErrno(PyExc_RuntimeError);

		return NULL;

	}

	Py_INCREF(Py_None);

	return Py_None;

}

#endif

static PyObject *

signal_set_wakeup_fd(PyObject *self, PyObject *args)

{

	struct stat buf;

	int fd, old_fd;

	if (!PyArg_ParseTuple(args, "i:set_wakeup_fd", &fd))

		return NULL;

#ifdef WITH_THREAD

	if (PyThread_get_thread_ident() != main_thread) {

		PyErr_SetString(PyExc_ValueError,

				"set_wakeup_fd only works in main thread");

		return NULL;

	}

#endif

	if (fd != -1 && fstat(fd, &buf) != 0) {

		PyErr_SetString(PyExc_ValueError, "invalid fd");

		return NULL;

	}

	old_fd = wakeup_fd;

	wakeup_fd = fd;

	return PyLong_FromLong(old_fd);

}

PyDoc_STRVAR(set_wakeup_fd_doc,

"set_wakeup_fd(fd) -> fd\n\

\n\

Sets the fd to be written to (with '\\0') when a signal\n\

comes in.  A library can use this to wakeup select or poll.\n\

The previous fd is returned.\n\

\n\

The fd must be non-blocking.");

/* C API for the same, without all the error checking */

int

PySignal_SetWakeupFd(int fd)

{

	int old_fd = wakeup_fd;

	if (fd < 0)

		fd = -1;

	wakeup_fd = fd;

	return old_fd;

}

#ifdef HAVE_SETITIMER

static PyObject *

signal_setitimer(PyObject *self, PyObject *args)

{

    double first;

    double interval = 0;

    int which;

    struct itimerval new, old;

    if(!PyArg_ParseTuple(args, "id|d:setitimer", &which, &first, &interval))

        return NULL;

    timeval_from_double(first, &new.it_value);

    timeval_from_double(interval, &new.it_interval);

    /* Let OS check "which" value */

    if (setitimer(which, &new, &old) != 0) {

        PyErr_SetFromErrno(ItimerError);

        return NULL;

    }

    return itimer_retval(&old);

}

PyDoc_STRVAR(setitimer_doc,

"setitimer(which, seconds[, interval])\n\

\n\

Sets given itimer (one of ITIMER_REAL, ITIMER_VIRTUAL\n\

or ITIMER_PROF) to fire after value seconds and after\n\

that every interval seconds.\n\

The itimer can be cleared by setting seconds to zero.\n\

\n\

Returns old values as a tuple: (delay, interval).");

#endif

#ifdef HAVE_GETITIMER

static PyObject *

signal_getitimer(PyObject *self, PyObject *args)

{

    int which;

    struct itimerval old;

    if (!PyArg_ParseTuple(args, "i:getitimer", &which))

        return NULL;

    if (getitimer(which, &old) != 0) {

        PyErr_SetFromErrno(ItimerError);

        return NULL;

    }

    return itimer_retval(&old);

}

PyDoc_STRVAR(getitimer_doc,

"getitimer(which)\n\

\n\

Returns current value of given itimer.");

#endif

/* List of functions defined in the module */

static PyMethodDef signal_methods[] = {

#ifdef HAVE_ALARM

	{"alarm",	        signal_alarm, METH_VARARGS, alarm_doc},

#endif

#ifdef HAVE_SETITIMER

    {"setitimer",       signal_setitimer, METH_VARARGS, setitimer_doc},

#endif

#ifdef HAVE_GETITIMER

	{"getitimer",       signal_getitimer, METH_VARARGS, getitimer_doc},

#endif

	{"signal",	        signal_signal, METH_VARARGS, signal_doc},

	{"getsignal",	        signal_getsignal, METH_VARARGS, getsignal_doc},

	{"set_wakeup_fd",	signal_set_wakeup_fd, METH_VARARGS, set_wakeup_fd_doc},

#ifdef HAVE_SIGINTERRUPT

 	{"siginterrupt",	signal_siginterrupt, METH_VARARGS, siginterrupt_doc},

#endif

#ifdef HAVE_PAUSE

	{"pause",	        (PyCFunction)signal_pause,

	 METH_NOARGS,pause_doc},

#endif

	{"default_int_handler", signal_default_int_handler,

	 METH_VARARGS, default_int_handler_doc},

	{NULL,			NULL}		/* sentinel */

};

PyDoc_STRVAR(module_doc,

"This module provides mechanisms to use signal handlers in Python.\n\

\n\

Functions:\n\

\n\

alarm() -- cause SIGALRM after a specified time [Unix only]\n\

setitimer() -- cause a signal (described below) after a specified\n\

               float time and the timer may restart then [Unix only]\n\

getitimer() -- get current value of timer [Unix only]\n\

signal() -- set the action for a given signal\n\

getsignal() -- get the signal action for a given signal\n\

pause() -- wait until a signal arrives [Unix only]\n\

default_int_handler() -- default SIGINT handler\n\

\n\

signal constants:\n\

SIG_DFL -- used to refer to the system default handler\n\

SIG_IGN -- used to ignore the signal\n\

NSIG -- number of defined signals\n\

SIGINT, SIGTERM, etc. -- signal numbers\n\

\n\

itimer constants:\n\

ITIMER_REAL -- decrements in real time, and delivers SIGALRM upon\n\

               expiration\n\

ITIMER_VIRTUAL -- decrements only when the process is executing,\n\

               and delivers SIGVTALRM upon expiration\n\

ITIMER_PROF -- decrements both when the process is executing and\n\

               when the system is executing on behalf of the process.\n\

               Coupled with ITIMER_VIRTUAL, this timer is usually\n\

               used to profile the time spent by the application\n\

               in user and kernel space. SIGPROF is delivered upon\n\

               expiration.\n\

\n\n\

*** IMPORTANT NOTICE ***\n\

A signal handler function is called with two arguments:\n\

the first is the signal number, the second is the interrupted stack frame.");

PyMODINIT_FUNC

initsignal(void)

{

	PyObject *m, *d, *x;

	int i;

#ifdef WITH_THREAD

	main_thread = PyThread_get_thread_ident();

	main_pid = getpid();

#endif