/*

 * signal.c -- Signal Handler Library for Lua

 *

 * Version: 1.000+changes

 *

 * Copyright (C) 2007  Patrick J. Donnelly (batrick@batbytes.com)

 *

 * This software is distributed under the same license as Lua 5.0:

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

 * and/or sell copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included

 * in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR

 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

 * OTHER DEALINGS IN THE SOFTWARE.

*/

#ifndef _GNU_SOURCE

#define _GNU_SOURCE

#endif

#include <signal.h>

#include <stdlib.h>

#ifdef __linux__

#include <unistd.h>

#include <sys/signalfd.h>

#endif

#include "lua.h"

#include "lauxlib.h"

#if (LUA_VERSION_NUM < 503)

#define lua_isinteger(L, n) lua_isnumber(L, n)

#endif

#ifndef lsig

#define lsig

struct lua_signal {

	char *name; /* name of the signal */

	int sig; /* the signal */

};

#endif

#define MAX_PENDING_SIGNALS 32

#define LUA_SIGNAL "lua_signal"

static const struct lua_signal lua_signals[] = {

	/* ANSI C signals */

#ifdef SIGABRT

	{"SIGABRT", SIGABRT},

#endif

#ifdef SIGFPE

	{"SIGFPE", SIGFPE},

#endif

#ifdef SIGILL

	{"SIGILL", SIGILL},

#endif

#ifdef SIGINT

	{"SIGINT", SIGINT},

#endif

#ifdef SIGSEGV

	{"SIGSEGV", SIGSEGV},

#endif

#ifdef SIGTERM

	{"SIGTERM", SIGTERM},

#endif

	/* posix signals */

#ifdef SIGHUP

	{"SIGHUP", SIGHUP},

#endif

#ifdef SIGQUIT

	{"SIGQUIT", SIGQUIT},

#endif

#ifdef SIGTRAP

	{"SIGTRAP", SIGTRAP},

#endif

#ifdef SIGKILL

	{"SIGKILL", SIGKILL},

#endif

#ifdef SIGUSR1

	{"SIGUSR1", SIGUSR1},

#endif

#ifdef SIGUSR2

	{"SIGUSR2", SIGUSR2},

#endif

#ifdef SIGPIPE

	{"SIGPIPE", SIGPIPE},

#endif

#ifdef SIGALRM

	{"SIGALRM", SIGALRM},

#endif

#ifdef SIGCHLD

	{"SIGCHLD", SIGCHLD},

#endif

#ifdef SIGCONT

	{"SIGCONT", SIGCONT},

#endif

#ifdef SIGSTOP

	{"SIGSTOP", SIGSTOP},

#endif

#ifdef SIGTTIN

	{"SIGTTIN", SIGTTIN},

#endif

#ifdef SIGTTOU

	{"SIGTTOU", SIGTTOU},

#endif

	/* some BSD signals */

#ifdef SIGIOT

	{"SIGIOT", SIGIOT},

#endif

#ifdef SIGBUS

	{"SIGBUS", SIGBUS},

#endif

#ifdef SIGCLD

	{"SIGCLD", SIGCLD},

#endif

#ifdef SIGURG

	{"SIGURG", SIGURG},

#endif

#ifdef SIGXCPU

	{"SIGXCPU", SIGXCPU},

#endif

#ifdef SIGXFSZ

	{"SIGXFSZ", SIGXFSZ},

#endif

#ifdef SIGVTALRM

	{"SIGVTALRM", SIGVTALRM},

#endif

#ifdef SIGPROF

	{"SIGPROF", SIGPROF},

#endif

#ifdef SIGWINCH

	{"SIGWINCH", SIGWINCH},

#endif

#ifdef SIGPOLL

	{"SIGPOLL", SIGPOLL},

#endif

#ifdef SIGIO

	{"SIGIO", SIGIO},

#endif

	/* add odd signals */

#ifdef SIGSTKFLT

	{"SIGSTKFLT", SIGSTKFLT}, /* stack fault */

#endif

#ifdef SIGSYS

	{"SIGSYS", SIGSYS},

#endif

	{NULL, 0}

};

static lua_State *Lsig = NULL;

static lua_Hook Hsig = NULL;

static int Hmask = 0;

static int Hcount = 0;

static int signals[MAX_PENDING_SIGNALS];

static int nsig = 0;

static void sighook(lua_State *L, lua_Debug *ar) {

	(void)ar;

	/* restore the old hook */

	lua_sethook(L, Hsig, Hmask, Hcount);

	lua_pushstring(L, LUA_SIGNAL);

	lua_gettable(L, LUA_REGISTRYINDEX);

	for(int i = 0; i < nsig; i++) {

		lua_pushinteger(L, signals[i]);

		lua_gettable(L, -2);

		lua_call(L, 0, 0);

	};

	nsig = 0;

	lua_pop(L, 1); /* pop lua_signal table */

}

static void handle(int sig) {

	if(nsig == 0) {

		/* Store the existing debug hook (if any) and its parameters */

		Hsig = lua_gethook(Lsig);

		Hmask = lua_gethookmask(Lsig);

		Hcount = lua_gethookcount(Lsig);

		/* Set our new debug hook */

		lua_sethook(Lsig, sighook, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1);

	}

	if(nsig < MAX_PENDING_SIGNALS) {

		signals[nsig++] = sig;

	}

}

/*

 * l_signal == signal(signal [, func [, chook]])

 *

 * signal = signal number or string

 * func = Lua function to call

 * chook = catch within C functions

 *         if caught, Lua function _must_

 *         exit, as the stack is most likely

 *         in an unstable state.

*/

static int l_signal(lua_State *L) {

	int args = lua_gettop(L);

	int t, sig; /* type, signal */

	/* get type of signal */

	luaL_checkany(L, 1);

	t = lua_type(L, 1);

	if(t == LUA_TNUMBER) {

		sig = (int) lua_tointeger(L, 1);

	} else if(t == LUA_TSTRING) {

		lua_pushstring(L, LUA_SIGNAL);

		lua_gettable(L, LUA_REGISTRYINDEX);

		lua_pushvalue(L, 1);

		lua_gettable(L, -2);

		if(!lua_isinteger(L, -1)) {

			return luaL_error(L, "invalid signal string");

		}

		sig = (int) lua_tointeger(L, -1);

		lua_pop(L, 1); /* get rid of number we pushed */

	} else {

		luaL_checknumber(L, 1);    /* will always error, with good error msg */

		return luaL_error(L, "unreachable: invalid number was accepted");

	}

	/* set handler */

	if(args == 1 || lua_isnil(L, 2)) { /* clear handler */

		lua_pushstring(L, LUA_SIGNAL);

		lua_gettable(L, LUA_REGISTRYINDEX);

		lua_pushinteger(L, sig);

		lua_gettable(L, -2); /* return old handler */

		lua_pushinteger(L, sig);

		lua_pushnil(L);

		lua_settable(L, -4);

		lua_remove(L, -2); /* remove LUA_SIGNAL table */

		signal(sig, SIG_DFL);

	} else {

		luaL_checktype(L, 2, LUA_TFUNCTION);

		lua_pushstring(L, LUA_SIGNAL);

		lua_gettable(L, LUA_REGISTRYINDEX);

		lua_pushinteger(L, sig);

		lua_pushvalue(L, 2);

		lua_settable(L, -3);

		/* Set the state for the handler */

		Lsig = L;

		if(lua_toboolean(L, 3)) { /* c hook? */

			if(signal(sig, handle) == SIG_ERR) {

				lua_pushboolean(L, 0);

			} else {

				lua_pushboolean(L, 1);

			}

		} else { /* lua_hook */

			if(signal(sig, handle) == SIG_ERR) {

				lua_pushboolean(L, 0);

			} else {

				lua_pushboolean(L, 1);

			}

		}

	}

	return 1;

}

/*

 * l_raise == raise(signal)

 *

 * signal = signal number or string

*/

static int l_raise(lua_State *L) {

	/* int args = lua_gettop(L); */

	int t = 0; /* type */

	lua_Integer ret;

	luaL_checkany(L, 1);

	t = lua_type(L, 1);

	if(t == LUA_TNUMBER) {

		ret = (lua_Integer) raise((int) lua_tointeger(L, 1));

		lua_pushinteger(L, ret);

	} else if(t == LUA_TSTRING) {

		lua_pushstring(L, LUA_SIGNAL);

		lua_gettable(L, LUA_REGISTRYINDEX);

		lua_pushvalue(L, 1);

		lua_gettable(L, -2);

		if(!lua_isnumber(L, -1)) {

			return luaL_error(L, "invalid signal string");

		}

		ret = (lua_Integer) raise((int) lua_tointeger(L, -1));

		lua_pop(L, 1); /* get rid of number we pushed */

		lua_pushinteger(L, ret);

	} else {

		luaL_checknumber(L, 1);    /* will always error, with good error msg */

	}

	return 1;

}

#if defined(__unix__) || defined(__APPLE__)

/* define some posix only functions */

/*

 * l_kill == kill(pid, signal)

 *

 * pid = process id

 * signal = signal number or string

*/

static int l_kill(lua_State *L) {

	int t; /* type */

	lua_Integer ret; /* return value */

	luaL_checknumber(L, 1); /* must be int for pid */

	luaL_checkany(L, 2); /* check for a second arg */

	t = lua_type(L, 2);

	if(t == LUA_TNUMBER) {

		ret = (lua_Integer) kill((int) lua_tointeger(L, 1),

		                         (int) lua_tointeger(L, 2));

		lua_pushinteger(L, ret);

	} else if(t == LUA_TSTRING) {

		lua_pushstring(L, LUA_SIGNAL);

		lua_gettable(L, LUA_REGISTRYINDEX);

		lua_pushvalue(L, 2);

		lua_gettable(L, -2);

		if(!lua_isnumber(L, -1)) {

			return luaL_error(L, "invalid signal string");

		}

		ret = (lua_Integer) kill((int) lua_tointeger(L, 1),

		                         (int) lua_tointeger(L, -1));

		lua_pop(L, 1); /* get rid of number we pushed */

		lua_pushinteger(L, ret);

	} else {

		luaL_checknumber(L, 2);    /* will always error, with good error msg */

	}

	return 1;

}

#endif

#ifdef __linux__

struct lsignalfd {

	int fd;

	sigset_t mask;

};

static int l_signalfd(lua_State *L) {

	struct lsignalfd *sfd = lua_newuserdata(L, sizeof(struct lsignalfd));

	sigemptyset(&sfd->mask);

	sigaddset(&sfd->mask, luaL_checkinteger(L, 1));

	if (sigprocmask(SIG_BLOCK, &sfd->mask, NULL) != 0) {

		lua_pushnil(L);

		return 1;

	};

	sfd->fd = signalfd(-1, &sfd->mask, SFD_NONBLOCK);

	if(sfd->fd == -1) {

		lua_pushnil(L);

		return 1;

	}

	luaL_setmetatable(L, "signalfd");

	return 1;

}

static int l_signalfd_getfd(lua_State *L) {

	struct lsignalfd *sfd = luaL_checkudata(L, 1, "signalfd");

	if (sfd->fd == -1) {

		lua_pushnil(L);

		return 1;