/*

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

*/

#include <signal.h>

#include <stdlib.h>

#include "lua.h"

#include "lauxlib.h"

#ifndef lsig

#define lsig

struct lua_signal

{

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

  int sig; /* the signal */

};

#endif

#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 struct signal_event

{

	int Nsig;

	struct signal_event *next_event;

} *signal_queue = NULL;

static struct signal_event *last_event = NULL;

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

{

  /* restore the old hook */

  lua_sethook(L, Hsig, Hmask, Hcount);

  lua_pushstring(L, LUA_SIGNAL);

  lua_gettable(L, LUA_REGISTRYINDEX);

  struct signal_event *event;

  while((event = signal_queue))

  {

    lua_pushnumber(L, event->Nsig);

    lua_gettable(L, -2);

    lua_call(L, 0, 0);

    signal_queue = event->next_event;

    free(event);

  };

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

}

static void handle(int sig)

{

  if(!signal_queue)

  {

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

    Hsig = lua_gethook(Lsig);

    Hmask = lua_gethookmask(Lsig);

    Hcount = lua_gethookcount(Lsig);

    signal_queue = malloc(sizeof(struct signal_event));

    signal_queue->Nsig = sig;

    signal_queue->next_event = NULL;

    last_event = signal_queue;

    /* Set our new debug hook */

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

  }

  else

  {

    last_event->next_event = malloc(sizeof(struct signal_event));

    last_event->next_event->Nsig = sig;

    last_event->next_event->next_event = NULL;

    last_event = last_event->next_event;

  }

}

/*

 * 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_tonumber(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_isnumber(L, -1))

      luaL_error(L, "invalid signal string");

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

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

  } else

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

  /* set handler */

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

  {

    lua_pushstring(L, LUA_SIGNAL);

    lua_gettable(L, LUA_REGISTRYINDEX);

    lua_pushnumber(L, sig);

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

    lua_pushnumber(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_pushnumber(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_Number ret;

  luaL_checkany(L, 1);

  t = lua_type(L, 1);

  if (t == LUA_TNUMBER)

  {

    ret = (lua_Number) raise((int) lua_tonumber(L, 1));

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

      luaL_error(L, "invalid signal string");

    ret = (lua_Number) raise((int) lua_tonumber(L, -1));

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

    lua_pushnumber(L, ret);

  } else

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

  return 1;

}

/* 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_Number 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_Number) kill((int) lua_tonumber(L, 1),

        (int) lua_tonumber(L, 2));

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

      luaL_error(L, "invalid signal string");

    ret = (lua_Number) kill((int) lua_tonumber(L, 1),

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

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

    lua_pushnumber(L, ret);

  } else

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

  return 1;

}

#endif

static const struct luaL_Reg lsignal_lib[] = {

  {"signal", l_signal},

  {"raise", l_raise},

  {"kill", l_kill},

#endif

  {NULL, NULL}

};

int luaopen_util_signal(lua_State *L)

{

  int i = 0;

  /* add the library */

  luaL_register(L, "signal", lsignal_lib);

  /* push lua_signals table into the registry */

  /* put the signals inside the library table too,

   * they are only a reference */

  lua_pushstring(L, LUA_SIGNAL);

  lua_createtable(L, 0, 0);

  while (lua_signals[i].name != NULL)

  {

    /* registry table */

    lua_pushstring(L, lua_signals[i].name);

    lua_pushnumber(L, lua_signals[i].sig);

    lua_settable(L, -3);

    /* signal table */

    lua_pushstring(L, lua_signals[i].name);

    lua_pushnumber(L, lua_signals[i].sig);

    lua_settable(L, -5);

    i++;

  }

  /* add newtable to the registry */

  lua_settable(L, LUA_REGISTRYINDEX);

  return 1;

}