#include <uwsgi.h>

#include <lua.h>

#include <lualib.h>

#include <lauxlib.h>

#if LUA_VERSION_NUM < 502

# define lua_rawlen lua_objlen

extern struct uwsgi_server uwsgi;

struct uwsgi_lua {

} ulua;

struct ulua_websocket_handler {

};

#define ULUA_STATE ulua.state

#define ULUA_THREAD(i) (ULUA_STATE ? ULUA_STATE[i] : NULL)

#define ULUA_LOG_HEADER "[uwsgi-lua]"

#define ULUA_MULE_MSG_GET_BUFFER_SIZE 65536

#define ULUA_RECV_BUFFER_SIZE 4096

#define ULUA_LOG_STACK_BUFFER_SIZE 2047 // plus 1 zero char for term

#define ULUA_QUEUE_PUSH_STACK_SIZE 0x80

#define ULUA_WSAPI_REF 1

#define ULUA_SIGNAL_REF 2

#define ULUA_RPC_REF 3

#define ULUA_WEBSOCKET_META_REF 4

#define ULUA_MULE_MSG_REF 5

#define ULUA_ASYNC_THREADS_REF 6

#define ULUA_OPTDEF_GC_FREQ 1

#define ULUA_LOCK_LOCK 0

#define ULUA_LOCK_UNLOCK 1

#define ULUA_LOCK_CHECK 2

#define ulua_log(c, ar...) uwsgi_log(ULUA_LOG_HEADER" "c"\n", ##ar)

#define ULUA_TYPE_ISUTABLE(type) (type == LUA_TTABLE || type == LUA_TUSERDATA)

#define ULUA_WORKER_ANYAPP (ulua.wsapi_load ||\

#define ULUA_INITSTATE_ANYAPP (ULUA_WORKER_ANYAPP ||\

ulua.postforkmule ||\

ulua.postforkspooler)

#define ULUA_IS_MULE (uwsgi.muleid > 0)

#define ULUA_IS_WORKER (uwsgi.mywid > 0)

#define ULUA_IS_SPOOLER (uwsgi.i_am_a_spooler)

#define uwsgi_lua_tostring(l, o) uwsgi_lua_tolstring(l, o, NULL)

#define uwsgi_lua_checkstring(l, o) uwsgi_lua_checklstring(l, o, NULL)

struct uwsgi_plugin lua_plugin;

static void uwsgi_opt_luashell(char *opt, char *value, void *foobar) {

uwsgi.honour_stdin = 1;

ulua.shell = 1;

}

static void uwsgi_opt_luashell_oneshot(char *opt, char *value, void *foobar) {

// enable shell

uwsgi_opt_luashell(NULL, NULL, NULL);

ulua.shell_oneshot = 1;

}

static struct uwsgi_option uwsgi_lua_options[] = {

{"lua", required_argument, 0, "load lua wsapi app", uwsgi_opt_set_str, &ulua.wsapi_load, 0},

{"lua-load", required_argument, 0, "load a lua file before wsapi app (in non-lazy mode) or before --lua-postload (in lazy mode), but always first", uwsgi_opt_add_string_list, &ulua.load, 0},

{"lua-postload", required_argument, 0, "load a lua file after wsapi app (in non-lazy mode) or after --lua-load (in lazy mode), but always before forking (--lua-postfork)", uwsgi_opt_add_string_list, &ulua.postload, 0},

{"lua-postfork-worker", required_argument, 0, "load a lua file after worker fork() (only for workers)", uwsgi_opt_add_string_list, &ulua.postforkworker, 0},

{"lua-postfork-mule", required_argument, 0, "load a lua file after mule fork() (only for mules)", uwsgi_opt_add_string_list, &ulua.postforkmule, 0},

{"lua-postfork-spooler", required_argument, 0, "load a lua file after mule fork() (only for spoolers)", uwsgi_opt_add_string_list, &ulua.postforkspooler, 0},

{"lua-shell", no_argument, 0, "run the lua interactive shell (debug.debug())", uwsgi_opt_luashell, NULL, 0},

{"luashell", no_argument, 0, "run the lua interactive shell (debug.debug())", uwsgi_opt_luashell, NULL, 0},

{"lua-shell-oneshot", no_argument, 0, "run the lua interactive shell (debug.debug(), one-shot variant)", uwsgi_opt_luashell_oneshot, NULL, 0},

{"luashell-oneshot", no_argument, 0, "run the lua interactive shell (debug.debug(), one-shot variant)", uwsgi_opt_luashell_oneshot, NULL, 0},

{"lua-gc-freq", required_argument, 0, "set the lua gc frequency (default: 1, runs after every request)", uwsgi_opt_set_int, &ulua.gc_freq, 0},

{"lua-gc-full", no_argument, 0, "set the lua gc to perform a full garbage-collection cycle (default: 0, gc performs an incremental step of garbage collection)", uwsgi_opt_set_int, &ulua.gc_perform, 0},

{0, 0, 0, 0},

};

static inline int uwsgi_lua_metatable_tostring(lua_State *L, int obj) {

if (luaL_callmeta(L, obj, "__tostring")) {

lua_replace(L, obj < 0 ? (obj - 1) : obj);

return 1;

}

return 0;

}

static inline int uwsgi_lua_metatable_tostring_protected(lua_State *L, int obj) {

// replace table with __tostring result, or do nothing in case of fail

if (luaL_getmetafield(L, obj, "__tostring")) {

lua_pushvalue(L, obj < 0 ? (obj - 1) : obj);

if (lua_pcall(L, 1, 1, 0)) {

ulua_log("%s", lua_tostring(L, -1));

lua_pop(L, 1);

return -1; // runtime error

}

lua_replace(L, obj < 0 ? (obj - 1) : obj);

return 1;

}

return 0;

}

static inline const char *uwsgi_lua_tolstring(lua_State *L, int obj, size_t *len) { // unprotected !!

const char *str = lua_tolstring(L, obj, len);

if (!str && uwsgi_lua_metatable_tostring(L, obj)) {

str = lua_tolstring(L, obj, len);

}

return str;

}

static inline const char *uwsgi_lua_checklstring(lua_State *L, int obj, size_t *len) { // unprotected !!

const char *str = lua_tolstring(L, obj, len);

if (str) {

return str;

}

uwsgi_lua_metatable_tostring(L, obj);

return uwsgi_lua_checklstring(L, obj, len);

}

static inline int uwsgi_lua_metatable_call(lua_State *L, int obj) {

// get __call attr and place it before table, or do nothing in case of fail

if (luaL_getmetafield(L, obj, "__call")) {

lua_insert(L, obj < 0 ? (obj - 1) : obj);

return 1;

}

return 0;

}

static inline int uwsgi_lua_mptolstring(lua_State *L, int obj, const char **str, size_t *len) {

int e = uwsgi_lua_metatable_tostring_protected(L, obj);

if (e > 0) {

*str = lua_tolstring(L, obj, len);

} else {

*str = NULL;

if (len) *len = 0;

}

return e;

}

static int uwsgi_lua_killsig(lua_State *L, pid_t pid, uint8_t signal) {

if (kill(pid, signal)) {

uwsgi_error("kill()");

lua_pushnil(L);

} else {

lua_pushboolean(L, 1);

}

return 1;

}

static int uwsgi_api_reload(lua_State *L) {

return uwsgi_lua_killsig(L, uwsgi.workers[0].pid, SIGHUP);

}

static int uwsgi_api_stop(lua_State *L) {

return uwsgi_lua_killsig(L, uwsgi.workers[0].pid, SIGQUIT);

}

static int uwsgi_api_micros(lua_State *L) {

lua_pushnumber(L, uwsgi_micros());

return 1;

}

static int uwsgi_api_request_id(lua_State *L) {

struct wsgi_request *wsgi_req = current_wsgi_req();

lua_pushnumber(L, uwsgi.workers[uwsgi.mywid].cores[wsgi_req->async_id].requests);

return 1;

}

static int uwsgi_api_metric_get(lua_State *L) {

if (!(lua_gettop(L)) || !(lua_isstring(L, 1))) {

return 0;

}

lua_pushnumber(L, uwsgi_metric_get((char *) uwsgi_lua_tostring(L, 1), NULL));

return 1;

}

static int uwsgi_api_metric_set(lua_State *L) {

int64_t val = lua_tonumber(L, 2);

char * key = (char *) uwsgi_lua_tostring(L, 1);

if (!key || (!val && !lua_isnumber(L, 2)) ||

uwsgi_metric_set((char *) uwsgi_lua_tostring(L, 1), NULL, lua_tonumber(L, 2)))

{

return 0;

}

lua_pushboolean(L, 1);

return 1;

}

static int uwsgi_lua_metric_do(lua_State *L, int metric_do(char*, char*, int64_t)) {

int64_t value = 1;

char *key = (char *) uwsgi_lua_tostring(L, 1);

if (!key) {

return 0;

}

if (lua_gettop(L) > 1) {

value = lua_tonumber(L, 2);

if (!value && !lua_isnumber(L, 2)) {

value = 1;

}

}

if (metric_do((char *) uwsgi_lua_tostring(L, 1), NULL, value)) {

return 0;

}

lua_pushboolean(L, 1);

return 1;

}

static int uwsgi_api_metric_inc(lua_State *L) {

return uwsgi_lua_metric_do(L, uwsgi_metric_inc);

}

static int uwsgi_api_metric_div(lua_State *L) {

return uwsgi_lua_metric_do(L, uwsgi_metric_div);

}

static int uwsgi_api_metric_mul(lua_State *L) {

return uwsgi_lua_metric_do(L, uwsgi_metric_mul);

}

static int uwsgi_api_metric_dec(lua_State *L) {

return uwsgi_lua_metric_do(L, uwsgi_metric_dec);

}

static const char *uwsgi_lua_log_tostring(lua_State *L, int obj, size_t *len) {

int type = lua_type(L, obj);

const void *point;

switch(type) {

case LUA_TNIL: if (len) *len = 3; return "nil";

case LUA_TNONE: if (len) *len = 4; return "none";

case LUA_TBOOLEAN:

if (lua_toboolean(L, obj)) {

if (len) *len = 4;

return "true";

}

if (len) *len = 5;

return "false";

case LUA_TSTRING:

case LUA_TNUMBER: break;

default:

case LUA_TUSERDATA:

case LUA_TTABLE: if (uwsgi_lua_metatable_tostring(L, obj)) break;

point = lua_topointer(L, obj);

if (point) {

lua_pushfstring(L, "<%s: %p>", lua_typename(L, type), point);

} else {

lua_pushfstring(L, "<%s>", lua_typename(L, type));

}

lua_replace(L, obj < 0 ? (obj - 1) : obj);

}

return lua_tolstring(L, obj, len);

}

static int uwsgi_api_log(lua_State *L) {

struct uwsgi_buffer *ub = NULL;

uint16_t argc = lua_gettop(L);

char buff[ULUA_LOG_STACK_BUFFER_SIZE + 1];

size_t buff_size = 0;

const char *str;

size_t len;

int i;

if (argc > 1) {

for (i = 2; i <= argc; i++) {

str = uwsgi_lua_log_tostring(L, i, &len);

if (!ub) {

if ((ULUA_LOG_STACK_BUFFER_SIZE - buff_size) < (len + 1)) {

ub = uwsgi_buffer_new(0);

} else {

buff[buff_size] = ' ';

memcpy(&buff[buff_size + 1], str, len * sizeof(char));

buff_size+= (len + 1);

}

}

if (ub) {

if (uwsgi_buffer_ensure(ub, len + 2)) break;

if (uwsgi_buffer_byte(ub, ' ')) break;

if (uwsgi_buffer_append(ub, (char *) str, len)) break;

}

}

buff[buff_size] = 0;

if (ub) {

if (!uwsgi_buffer_byte(ub, 0))

ulua_log("%s%s%s", uwsgi_lua_log_tostring(L, 1, NULL), buff, ub->buf);

uwsgi_buffer_destroy(ub);

} else {

ulua_log("%s%s", uwsgi_lua_log_tostring(L, 1, NULL), buff);

}

} else if (argc) {

ulua_log("%s", uwsgi_lua_log_tostring(L, -argc, NULL));

}

return 0;

}

static int uwsgi_api_rpc(lua_State *L) {

uint16_t argc = lua_gettop(L);

uint8_t argnum;

uint8_t i;

uint64_t len;

// take first 255

argnum = (argc < (0xff + 2)) ? (argc - 2) : 0xff;

char *argv[0xff];

uint16_t argvs[0xff];

char *func = (char *) uwsgi_lua_checkstring(L, 2);

size_t alen;

for(i = 0; i < argnum; i++) {

argv[i] = (char *) uwsgi_lua_tolstring(L, i + 3, &alen);

argvs[i] = alen < 0x10000 ? alen : 0;

}

char *str = uwsgi_do_rpc((char *) uwsgi_lua_tostring(L, 1), func, argnum, argv, argvs, &len);

if (!str) { // fail??

lua_pushnil(L);

} else {

lua_pushlstring(L, str, len);

free(str);

}

return 1;

}

static int uwsgi_api_rpc_register_key(const char *key, size_t len) {

// exists??

size_t i;

int offset = uwsgi.mywid * uwsgi.rpc_max;

if (!len) {

return 0;

}

for(i = 0; i < uwsgi.shared->rpc_count[uwsgi.mywid]; i++) {

if (!strcmp(key, (&uwsgi.rpc_table[offset + i])->name)) {

if ((&uwsgi.rpc_table[offset + i])->plugin == &lua_plugin) {

return 1;

}

break;

}

}

// no

char *name = (char *) uwsgi_malloc(sizeof(char) * len);

memcpy(name, key, sizeof(char) * len);

if (uwsgi_register_rpc(name, &lua_plugin, 0, name)) {

// error

free(name);

return 0;

}

return 1;

}

static int uwsgi_api_register_rpc_newindex(lua_State *L) {

// 3 args: table, key(string or number), value(not nil)

uint16_t argc = lua_gettop(L);

size_t len;

if (argc > 3) {

lua_pop(L, argc - 3);

}

if (!lua_isnoneornil(L, -1) && lua_istable(L, 1)) {

const char *key = uwsgi_lua_checklstring(L, -2, &len);

if (!uwsgi_api_rpc_register_key(key, len + 1)) {

luaL_error(L, "unable to register rpc function %s", key);

}

lua_rawset(L, 1);

}

return 0;

}

static int uwsgi_api_register_rpc(lua_State *L) {

// legacy rpc register func

size_t len;

const char *key = uwsgi_lua_checklstring(L, 1, &len);

if (!uwsgi_api_rpc_register_key(key, len + 1)) {

luaL_error(L, "unable to register rpc function %s", key);

}

if (lua_gettop(L) > 1 && !(lua_isnil(L, 2))) {

lua_rawgeti(L, LUA_REGISTRYINDEX, ULUA_RPC_REF);

lua_pushvalue(L, 1);

lua_pushvalue(L, 2);

lua_rawset(L, -3);

}

return 0;

}

static int uwsgi_lua_cache_magic_set_value(lua_State *L, uint16_t argc, uint8_t isnum, uint64_t flag) {

char *cache = NULL;

uint64_t expires = 0;

char *key;

size_t keylen;

char *value;

size_t valuelen;

int64_t valuenum;

if (argc > 2) {

expires = lua_tonumber(L, 3);

if (argc > 3) {

cache = (char *) uwsgi_lua_tostring(L, 4);

}

}

// key

key = (char *) uwsgi_lua_tolstring(L, 1, &keylen);

// value

if (isnum) {

valuenum = lua_tonumber(L, 2);

if (!valuenum && !lua_isnumber(L, 2)) {

if (flag & UWSGI_CACHE_FLAG_MATH) {

valuenum = 1;

} else {

return 0; // skip

}

}

if (uwsgi_cache_magic_set(key, keylen, (char *) &valuenum, 8, expires, flag, cache)) return 0;

} else {

value = (char *) uwsgi_lua_tolstring(L, 2, &valuelen);

if (uwsgi_cache_magic_set(key, keylen, value, valuelen, expires, flag, cache)) return 0;

}

lua_pushboolean(L, 1);

return 1;

}

static int uwsgi_lua_cache_magic_set_table(lua_State *L, uint16_t argc, uint8_t isnum, uint64_t flag) {

size_t error = 0;

char *cache = NULL;

uint64_t expires = 0;

char *key;

size_t keylen;

char *value;

size_t valuelen;

int64_t valuenum;

if (argc > 1) {

expires = lua_tonumber(L, 2);

if (argc > 2) {

cache = (char *) uwsgi_lua_tostring(L, 3);

}

}

lua_pushnil(L);

while(lua_next(L, 1)) {

lua_pushvalue(L, -2);

//key

key = (char *) uwsgi_lua_tolstring(L, -1, &keylen);

//value

if (isnum) {

valuenum = lua_tonumber(L, -2);

if (!valuenum && !lua_isnumber(L, -2)) {

if (flag & UWSGI_CACHE_FLAG_MATH) {

valuenum = 1;

} else {

++error; lua_pop(L, 2); continue; // skip

}

}

if (uwsgi_cache_magic_set(key, keylen, (char *) &valuenum, 8, expires, flag, cache)) ++error;

} else {

value = (char *) uwsgi_lua_tolstring(L, -2, &valuelen);

if (uwsgi_cache_magic_set(key, keylen, value, valuelen, expires, flag, cache)) ++error;

}

lua_pop(L, 2);

}

if (!error) {

lua_pushboolean(L, 1);

return 1;

}

lua_pushnil(L);

lua_pushnumber(L, error);

return 2;

}

static int uwsgi_lua_cache_magic_set(lua_State *L, uint8_t isnum, uint64_t flag) {

uint16_t argc = lua_gettop(L);

if (argc > 0 && lua_istable(L, 1)) {

return uwsgi_lua_cache_magic_set_table(L, argc, isnum, flag);

} else if (argc > 1 || (flag & UWSGI_CACHE_FLAG_MATH && argc)) {

return uwsgi_lua_cache_magic_set_value(L, argc, isnum, flag);

}

return 0;

}

static int uwsgi_api_cache_set(lua_State *L) {

return uwsgi_lua_cache_magic_set(L, 0, 0);

}

static int uwsgi_api_cache_setnum(lua_State *L) {

return uwsgi_lua_cache_magic_set(L, 1, 0);

}

static int uwsgi_api_cache_update(lua_State *L) {

return uwsgi_lua_cache_magic_set(L, 0, UWSGI_CACHE_FLAG_UPDATE);

}

static int uwsgi_api_cache_updatenum(lua_State *L) {

return uwsgi_lua_cache_magic_set(L, 1, UWSGI_CACHE_FLAG_UPDATE);

}

static int uwsgi_api_cache_inc(lua_State *L) {

return uwsgi_lua_cache_magic_set(L, 1, UWSGI_CACHE_FLAG_UPDATE|UWSGI_CACHE_FLAG_MATH|UWSGI_CACHE_FLAG_FIXEXPIRE|UWSGI_CACHE_FLAG_INC);

}

static int uwsgi_api_cache_dec(lua_State *L) {

return uwsgi_lua_cache_magic_set(L, 1, UWSGI_CACHE_FLAG_UPDATE|UWSGI_CACHE_FLAG_MATH|UWSGI_CACHE_FLAG_FIXEXPIRE|UWSGI_CACHE_FLAG_DEC);

}

static int uwsgi_api_cache_mul(lua_State *L) {

return uwsgi_lua_cache_magic_set(L, 1, UWSGI_CACHE_FLAG_UPDATE|UWSGI_CACHE_FLAG_MATH|UWSGI_CACHE_FLAG_FIXEXPIRE|UWSGI_CACHE_FLAG_MUL);

}

static int uwsgi_api_cache_div(lua_State *L) {

return uwsgi_lua_cache_magic_set(L, 1, UWSGI_CACHE_FLAG_UPDATE|UWSGI_CACHE_FLAG_MATH|UWSGI_CACHE_FLAG_FIXEXPIRE|UWSGI_CACHE_FLAG_DIV);

}

static int uwsgi_lua_cache_magic_set_multi(lua_State *L, uint8_t isnum, uint64_t flag) {

uint16_t argc = lua_gettop(L);

uint16_t error = 0;

uint16_t i;

char *cache;

uint64_t expires;

char *key;

size_t keylen;

char *value;

size_t valuelen;

int64_t valuenum;

if (argc < 3) {

return 0;

}

expires = lua_tonumber(L, 1);

cache = (char *) uwsgi_lua_tostring(L, 2);

for (i = 4, ++argc; i <= argc; i+=2) {

// key

key = (char *) uwsgi_lua_tolstring(L, i - 1, &keylen);

// value

if (isnum) {

valuenum = lua_tonumber(L, i);

if (!valuenum && !lua_isnumber(L, i)) {

if (flag & UWSGI_CACHE_FLAG_MATH) {

valuenum = 1;

} else {

++error; continue; //skip

}

}

if (uwsgi_cache_magic_set(key, keylen, (char *) &valuenum, 8, expires, flag, cache)) ++error;

} else {

value = (char *) uwsgi_lua_tolstring(L, i, &valuelen);

if (uwsgi_cache_magic_set(key, keylen, value, valuelen, expires, flag, cache)) ++error;

}

}

if(!error) {

lua_pushboolean(L, 1);

return 1;

}

lua_pushnil(L);

lua_pushnumber(L, error);

return 2;

}

static int uwsgi_api_cache_set_multi(lua_State *L) {

return uwsgi_lua_cache_magic_set_multi(L, 0, 0);

}

static int uwsgi_api_cache_setnum_multi(lua_State *L) {

return uwsgi_lua_cache_magic_set_multi(L, 1, 0);

}

static int uwsgi_api_cache_update_multi(lua_State *L) {

return uwsgi_lua_cache_magic_set_multi(L, 0, UWSGI_CACHE_FLAG_UPDATE);

}

static int uwsgi_api_cache_updatenum_multi(lua_State *L) {

return uwsgi_lua_cache_magic_set_multi(L, 1, UWSGI_CACHE_FLAG_UPDATE);

}

static int uwsgi_api_cache_inc_multi(lua_State *L) {

return uwsgi_lua_cache_magic_set_multi(L, 1, UWSGI_CACHE_FLAG_UPDATE|UWSGI_CACHE_FLAG_MATH|UWSGI_CACHE_FLAG_FIXEXPIRE|UWSGI_CACHE_FLAG_INC);

}

static int uwsgi_api_cache_dec_multi(lua_State *L) {

return uwsgi_lua_cache_magic_set_multi(L, 1, UWSGI_CACHE_FLAG_UPDATE|UWSGI_CACHE_FLAG_MATH|UWSGI_CACHE_FLAG_FIXEXPIRE|UWSGI_CACHE_FLAG_DEC);

}

static int uwsgi_api_cache_mul_multi(lua_State *L) {

return uwsgi_lua_cache_magic_set_multi(L, 1, UWSGI_CACHE_FLAG_UPDATE|UWSGI_CACHE_FLAG_MATH|UWSGI_CACHE_FLAG_FIXEXPIRE|UWSGI_CACHE_FLAG_MUL);

}

static int uwsgi_api_cache_div_multi(lua_State *L) {

return uwsgi_lua_cache_magic_set_multi(L, 1, UWSGI_CACHE_FLAG_UPDATE|UWSGI_CACHE_FLAG_MATH|UWSGI_CACHE_FLAG_FIXEXPIRE|UWSGI_CACHE_FLAG_DIV);

}

static int uwsgi_api_cache_clear(lua_State *L) {

char *cache = NULL;

if (lua_gettop(L)) {

cache = (char *) uwsgi_lua_tostring(L, 1);

}

if (!uwsgi_cache_magic_clear(cache)) {

lua_pushboolean(L, 1);

return 1;

}

return 0;

}

static int uwsgi_api_cache_keys(lua_State *L) {

char *cache = NULL;

if (lua_gettop(L)) {

cache = (char *) uwsgi_lua_tostring(L, 1);

}

struct uwsgi_cache *uc = uwsgi_cache_by_name(cache);

struct uwsgi_cache_item *uci = NULL;

uint64_t pos = 0;

uint64_t i = 0;

if (!uc) {

ulua_log("uWSGI cache '%s' is not available!", cache != NULL ? cache : "default");

return 0;

}

lua_newtable(L);

uwsgi_rlock(uc->lock);

do {

uci = uwsgi_cache_keys(uc, &pos, &uci);

if (uci) {

lua_pushlstring(L, uci->key, uci->keysize);

lua_rawseti(L, -2, ++i);

}

} while (uci);

uwsgi_rwunlock(uc->lock);

return 1;

}

static int uwsgi_lua_cache_del_exists(lua_State *L, int cache_do(char *, uint16_t, char *), uint8_t reverse) {

size_t keylen;

char *key;

char *cache = NULL;

size_t i, tlen;

size_t error = 0;

uint16_t argc = lua_gettop(L);

if (!(argc)) {

return 0;

}

if (argc > 1) {

cache = (char *) uwsgi_lua_tostring(L, 2);

}

// get the key

if (lua_istable(L, 1)) {

tlen = lua_rawlen(L, 1);

for(i = 1; i <= tlen; i++) {

lua_rawgeti(L, 1, i);

key = (char *) uwsgi_lua_tolstring(L, -1, &keylen);

if (!keylen || (cache_do(key, keylen, cache) - reverse)) {

++error;

}

lua_pop(L, 1);

}

} else {

key = (char *) uwsgi_lua_tolstring(L, 1, &keylen);

if (!keylen || (cache_do(key, keylen, cache) - reverse)) {

lua_pushnil(L);

return 1;

}

}

if (!error) {

lua_pushboolean(L, 1);

return 1;

}

lua_pushnil(L);

lua_pushnumber(L, error);

return 2;

}

static int uwsgi_api_cache_del(lua_State *L) {

return uwsgi_lua_cache_del_exists(L, uwsgi_cache_magic_del, 0);

}

static int uwsgi_api_cache_exists(lua_State *L) {

return uwsgi_lua_cache_del_exists(L, uwsgi_cache_magic_exists, 1);

}

static int uwsgi_api_cache_del_multi(lua_State *L) {

size_t keylen;

char *key;

char *cache;

uint16_t argc = lua_gettop(L);

uint16_t error = 0;

uint16_t i;

if (argc < 1) {

return 0;

}

cache = (char *) uwsgi_lua_tostring(L, 1);

for (i = 2; i <= argc; i++) {

key = (char *) uwsgi_lua_tolstring(L, i, &keylen);

if (!keylen || uwsgi_cache_magic_del(key, keylen, cache)) {

++error;

}

}

if (!error) {

lua_pushboolean(L, 1);

return 1;

}

lua_pushnil(L);

lua_pushnumber(L, error);

return 2;

}

static int uwsgi_api_cache_exists_multi(lua_State *L) {

size_t keylen;

char *key;

char *cache;

uint16_t argc = lua_gettop(L);

uint16_t i;

if (argc < 2) {

return 0;

}

cache = (char *) uwsgi_lua_tostring(L, 1);

if (!lua_checkstack(L, argc - 1)) {

luaL_error(L, "too many items (%u) in the stack", argc - 1);

return 0;

}

for (i = 2; i <= argc; i++) {

key = (char *) uwsgi_lua_tolstring(L, i, &keylen);

if (keylen && uwsgi_cache_magic_exists(key, keylen, cache)) {

lua_pushboolean(L, 1);

} else {

lua_pushnil(L);

}

}

return argc - 1;

}

static uint8_t uwsgi_lua_tosignal(lua_State *L, int obj) {

long sig = (long) luaL_checknumber(L, obj);

if (sig > 255 || sig < 0) {

luaL_error(L, "signal number (%ld) is out of range [0,255]", sig);

}

return (uint8_t) sig;

}

static int uwsgi_api_signal(lua_State *L) {

uint8_t sig = uwsgi_lua_tosignal(L, 1);

if (lua_gettop(L) > 1 && lua_isstring(L, 2)) {

char *node = (char *) uwsgi_lua_tostring(L, 2);

switch(uwsgi_remote_signal_send(node, sig)) {

case -1: luaL_error(L, "unable to deliver signal %u to node %s", sig, node); break;

case 0: luaL_error(L, "node %s rejected signal %d", sig, node); break;

}

} else {

uwsgi_signal_send(uwsgi.signal_socket, sig);

}

return 0;

}

static int uwsgi_api_signal_wait(lua_State *L) {

struct wsgi_request *wsgi_req = current_wsgi_req();

int received_signal;

wsgi_req->signal_received = -1;

if (lua_gettop(L) > 0) {

received_signal = uwsgi_signal_wait(wsgi_req, uwsgi_lua_tosignal(L, 1));

} else {

received_signal = uwsgi_signal_wait(wsgi_req, -1);

}

if (received_signal < 0) {

luaL_error(L, "error waiting for signal");

return 0;

}

wsgi_req->signal_received = received_signal;

lua_pushnumber(L, received_signal);

return 1;

}

static int uwsgi_api_signal_received(lua_State *L) {

struct wsgi_request *wsgi_req = current_wsgi_req();

lua_pushnumber(L, wsgi_req->signal_received);

return 1;

}

static int uwsgi_api_signal_registered(lua_State *L) {

struct uwsgi_signal_entry *use;

uint8_t sig;

sig = uwsgi_lua_tosignal(L, 1);

use = &uwsgi.shared->signal_table[sig];

lua_pushboolean(L, use->handler ? 1 : 0);

lua_pushstring(L, use->receiver);

if (uwsgi.mywid > 0) {

use = &uwsgi.shared->signal_table[sig + uwsgi.mywid*256];

}

lua_pushnumber(L, use->modifier1);

return 3;