static int vlclua_sd_add_item( lua_State *L )
{
services_discovery_t *p_sd = (services_discovery_t *)vlclua_get_this( L );
if( lua_istable( L, -1 ) )
{
lua_getfield( L, -1, "path" );
if( lua_isstring( L, -1 ) )
{
const char *psz_path = lua_tostring( L, -1 );
lua_getfield( L, -2, "title" );
const char *psz_title = luaL_checkstring( L, -1 ) ? luaL_checkstring( L, -1 ) : psz_path;
/* The table must be at the top of the stack when calling
* vlclua_read_options() */
char **ppsz_options = NULL;
int i_options = 0;
lua_pushvalue( L, -3 );
vlclua_read_options( p_sd, L, &i_options, &ppsz_options );
input_item_t *p_input = input_item_NewExt( psz_path, psz_title,
i_options,
(const char **)ppsz_options,
VLC_INPUT_OPTION_TRUSTED, -1 );
lua_pop( L, 3 );
if( p_input )
{
vlclua_read_meta_data( p_sd, L, p_input );
/* This one is to be tested... */
vlclua_read_custom_meta_data( p_sd, L, p_input );
/* The duration is given in seconds, convert to microseconds */
lua_getfield( L, -1, "duration" );
if( lua_isnumber( L, -1 ) )
input_item_SetDuration( p_input, (lua_tonumber( L, -1 )*1e6) );
else if( !lua_isnil( L, -1 ) )
msg_Warn( p_sd, "Item duration should be a number (in seconds)." );
lua_pop( L, 1 );
lua_getfield( L, -1, "category" );
if( lua_isstring( L, -1 ) )
services_discovery_AddItem( p_sd, p_input, luaL_checkstring( L, -1 ) );
else
services_discovery_AddItem( p_sd, p_input, NULL );
lua_pop( L, 1 );
/* string to build the input item uid */
lua_getfield( L, -1, "uiddata" );
if( lua_isstring( L, -1 ) )
{
char *s = strdup( luaL_checkstring( L, -1 ) );
if ( s )
{
struct md5_s md5;
InitMD5( &md5 );
AddMD5( &md5, s, strlen( s ) );
EndMD5( &md5 );
free( s );
s = psz_md5_hash( &md5 );
if ( s )
input_item_AddInfo( p_input, "uid", "md5", "%s", s );
free( s );
}
}
lua_pop( L, 1 );
input_item_t **udata = (input_item_t **)
lua_newuserdata( L, sizeof( input_item_t * ) );
*udata = p_input;
if( luaL_newmetatable( L, "input_item_t" ) )
{
lua_newtable( L );
luaL_register( L, NULL, vlclua_item_reg );
lua_setfield( L, -2, "__index" );
lua_pushliteral( L, "none of your business" );
lua_setfield( L, -2, "__metatable" );
}
lua_setmetatable( L, -2 );
vlc_gc_decref( p_input );
}
while( i_options > 0 )
free( ppsz_options[--i_options] );
free( ppsz_options );
}
else
msg_Err( p_sd, "vlc.sd.add_item: the \"path\" parameter can't be empty" );
}
else
msg_Err( p_sd, "Error parsing add_item arguments" );
return 1;
}
// Lua table full of data -> states[] (set the values all at once! :D :D)
static int lib_setState(lua_State *L)
{
state_t *state;
lua_remove(L, 1); // don't care about states[] userdata.
state = &states[luaL_checkinteger(L, 1)]; // get the state to assign to.
luaL_checktype(L, 2, LUA_TTABLE); // check that we've been passed a table.
lua_remove(L, 1); // pop state num, don't need it any more.
lua_settop(L, 1); // cut the stack here. the only thing left now is the table of data we're assigning to the state.
if (hud_running)
return luaL_error(L, "Do not alter states in HUD rendering code!");
// clear the state to start with, in case of missing table elements
memset(state,0,sizeof(state_t));
state->tics = -1;
lua_pushnil(L);
while (lua_next(L, 1)) {
lua_Integer i = 0;
const char *str = NULL;
lua_Integer value;
if (lua_isnumber(L, 2))
i = lua_tointeger(L, 2);
else
str = luaL_checkstring(L, 2);
if (i == 1 || (str && fastcmp(str, "sprite"))) {
value = luaL_checkinteger(L, 3);
if (value < SPR_NULL || value >= NUMSPRITES)
return luaL_error(L, "sprite number %d is invalid.", value);
state->sprite = (spritenum_t)value;
} else if (i == 2 || (str && fastcmp(str, "frame"))) {
state->frame = (UINT32)luaL_checkinteger(L, 3);
} else if (i == 3 || (str && fastcmp(str, "tics"))) {
state->tics = (INT32)luaL_checkinteger(L, 3);
} else if (i == 4 || (str && fastcmp(str, "action"))) {
switch(lua_type(L, 3))
{
case LUA_TNIL: // Null? Set the action to nothing, then.
state->action.acp1 = NULL;
break;
case LUA_TSTRING: // It's a string, expect the name of a built-in action
LUA_SetActionByName(state, lua_tostring(L, 3));
break;
case LUA_TFUNCTION: // It's a function (a Lua function or a C function? either way!)
lua_getfield(L, LUA_REGISTRYINDEX, LREG_STATEACTION);
I_Assert(lua_istable(L, -1));
lua_pushlightuserdata(L, state); // We'll store this function by the state's pointer in the registry.
lua_pushvalue(L, 3); // Bring it to the top of the stack
lua_rawset(L, -3); // Set it in the registry
lua_pop(L, 1); // pop LREG_STATEACTION
state->action.acp1 = (actionf_p1)A_Lua; // Set the action for the userdata.
break;
default: // ?!
return luaL_typerror(L, 3, "function");
}
} else if (i == 5 || (str && fastcmp(str, "var1"))) {
state->var1 = (INT32)luaL_checkinteger(L, 3);
} else if (i == 6 || (str && fastcmp(str, "var2"))) {
state->var2 = (INT32)luaL_checkinteger(L, 3);
} else if (i == 7 || (str && fastcmp(str, "nextstate"))) {
value = luaL_checkinteger(L, 3);
if (value < S_NULL || value >= NUMSTATES)
return luaL_error(L, "nextstate number %d is invalid.", value);
state->nextstate = (statenum_t)value;
}
lua_pop(L, 1);
}
return 0;
}
/**
* walk through the content array
*
* content = { "<pre>", { file = "/content" } , "</pre>" }
*
* header["Content-Type"] = "text/html"
*
* return 200
*/
static int
magnet_attach_content(server * srv, connection * con, plugin_data * p,
lua_State * L)
{
UNUSED(p);
/**
* get the environment of the function
*/
assert(lua_isfunction(L, -1));
lua_getfenv(L, -1); /* -1 is the function */
lua_getfield(L, -1, "lighty"); /* lighty.* from the env */
assert(lua_istable(L, -1));
lua_getfield(L, -1, "content"); /* lighty.content */
if (lua_istable(L, -1))
{
int i;
/*
* header is found, and is a table
*/
for (i = 1;; i++)
{
lua_rawgeti(L, -1, i);
/*
* -1 is the value and should be the value ... aka a table
*/
if (lua_isstring(L, -1))
{
size_t s_len = 0;
const char *s = lua_tolstring(L, -1, &s_len);
chunkqueue_append_mem(con->write_queue, s, s_len + 1);
} else if (lua_istable(L, -1))
{
lua_getfield(L, -1, "filename");
lua_getfield(L, -2, "length");
lua_getfield(L, -3, "offset");
if (lua_isstring(L, -3))
{ /* filename has to be a string */
buffer *fn = buffer_init();
stat_cache_entry *sce;
buffer_copy_string(fn, lua_tostring(L, -3));
if (HANDLER_GO_ON ==
stat_cache_get_entry(srv, con, fn, &sce))
{
off_t off = 0;
off_t len = 0;
if (lua_isnumber(L, -1))
{
off = lua_tonumber(L, -1);
}
if (lua_isnumber(L, -2))
{
len = lua_tonumber(L, -2);
} else
{
len = sce->st.st_size;
}
if (off < 0)
{
return luaL_error(L,
"offset for '%s' is negative",
fn->ptr);
}
if (len < off)
{
return luaL_error(L,
"offset > length for '%s'",
fn->ptr);
}
chunkqueue_append_file(con->write_queue,
fn, off, len - off);
}
buffer_free(fn);
} else
{
lua_pop(L, 3 + 2); /* correct the stack */
return luaL_error(L,
"content[%d] is a table and requires the field \"filename\"",
i);
}
lua_pop(L, 3);
} else if (lua_isnil(L, -1))
{
/*
* oops, end of list
*/
lua_pop(L, 1);
break;
} else
{
lua_pop(L, 4);
return luaL_error(L,
"content[%d] is neither a string nor a table: ",
i);
}
lua_pop(L, 1); /* pop the content[...] table */
}
} else
{
return luaL_error(L, "lighty.content has to be a table");
}
lua_pop(L, 1); /* pop the header-table */
lua_pop(L, 1); /* pop the lighty-table */
lua_pop(L, 1); /* php the function env */
return 0;
}
/*
=================
G_RunLuaFunction
=================
*/
void G_RunLuaFunction(const char *func, const char *sig, ...)
{
va_list vl;
int narg, nres; // number of arguments and results
lua_State *L = g_luaState;
if(!func || !func[0])
return;
va_start(vl, sig);
lua_getglobal(L, func); // get function
// push arguments
narg = 0;
while(*sig)
{
switch (*sig++)
{
case 'd':
// double argument
lua_pushnumber(L, va_arg(vl, double));
break;
case 'i':
// int argument
lua_pushnumber(L, va_arg(vl, int));
break;
case 's':
// string argument
lua_pushstring(L, va_arg(vl, char *));
break;
case 'e':
// entity argument
lua_pushentity(L, va_arg(vl, gentity_t *));
break;
case 'v':
// vector argument
lua_pushvector(L, va_arg(vl, vec_t *));
break;
case '>':
goto endwhile;
default:
G_Printf("G_RunLuaFunction: invalid option (%c)\n", *(sig - 1));
}
narg++;
luaL_checkstack(L, 1, "too many arguments");
}
endwhile:
// do the call
nres = strlen(sig); // number of expected results
if(lua_pcall(L, narg, nres, 0) != 0) // do the call
G_Printf("G_RunLuaFunction: error running function `%s': %s\n", func, lua_tostring(L, -1));
// retrieve results
nres = -nres; // stack index of first result
while(*sig)
{ // get results
switch (*sig++)
{
case 'd':
// double result
if(!lua_isnumber(L, nres))
G_Printf("G_RunLuaFunction: wrong result type\n");
*va_arg(vl, double *) = lua_tonumber(L, nres);
break;
case 'i':
// int result
if(!lua_isnumber(L, nres))
G_Printf("G_RunLuaFunction: wrong result type\n");
*va_arg(vl, int *) = (int)lua_tonumber(L, nres);
break;
case 's':
// string result
if(!lua_isstring(L, nres))
G_Printf("G_RunLuaFunction: wrong result type\n");
*va_arg(vl, const char **) = lua_tostring(L, nres);
break;
default:
G_Printf("G_RunLuaFunction: invalid option (%c)\n", *(sig - 1));
}
nres++;
}
va_end(vl);
}
void CLuaRules::Cob2Lua(const LuaHashString& name, const CUnit* unit,
int& argsCount, int args[MAX_LUA_COB_ARGS])
{
static int callDepth = 0;
if (callDepth >= 16) {
logOutput.Print("CLuaRules::Cob2Lua() call overflow: %s\n",
name.GetString().c_str());
args[0] = 0; // failure
return;
}
LUA_CALL_IN_CHECK(L);
const int top = lua_gettop(L);
if (!lua_checkstack(L, top + 1 + 3 + argsCount)) {
logOutput.Print("CLuaRules::Cob2Lua() lua_checkstack() error: %s\n",
name.GetString().c_str());
args[0] = 0; // failure
lua_settop(L, top);
return;
}
if (!name.GetGlobalFunc(L)) {
logOutput.Print("CLuaRules::Cob2Lua() missing function: %s\n",
name.GetString().c_str());
args[0] = 0; // failure
lua_settop(L, top);
return;
}
lua_pushnumber(L, unit->id);
lua_pushnumber(L, unit->unitDef->id);
lua_pushnumber(L, unit->team);
for (int a = 0; a < argsCount; a++) {
lua_pushnumber(L, args[a]);
}
// call the routine
callDepth++;
const int* oldArgs = currentCobArgs;
currentCobArgs = args;
const bool error = !RunCallIn(name, 3 + argsCount, LUA_MULTRET);
currentCobArgs = oldArgs;
callDepth--;
// bail on error
if (error) {
args[0] = 0; // failure
lua_settop(L, top);
return;
}
// get the results
const int retArgs = std::min(lua_gettop(L) - top, (MAX_LUA_COB_ARGS - 1));
for (int a = 1; a <= retArgs; a++) {
const int index = (a + top);
if (lua_isnumber(L, index)) {
args[a] = lua_toint(L, index);
}
else if (lua_isboolean(L, index)) {
args[a] = lua_toboolean(L, index) ? 1 : 0;
}
else if (lua_istable(L, index)) {
lua_rawgeti(L, index, 1);
lua_rawgeti(L, index, 2);
if (lua_isnumber(L, -2) && lua_isnumber(L, -1)) {
const int x = lua_toint(L, -2);
const int z = lua_toint(L, -1);
args[a] = PACKXZ(x, z);
} else {
args[a] = 0;
}
lua_pop(L, 2);
}
else {
args[a] = 0;
}
}
args[0] = 1; // success
lua_settop(L, top);
return;
}
int luas_call(luas_state* s, const char* mod, const char* func, const char* sig, ...) {
lua_State* L = s->l;
if (_get_function(L, mod, func) != 0) {
LOG_ERROR("lua call function [%s.%s] error : no function", mod, func);
return -1;
}
int top = lua_gettop(L);
int res;
int residx;
int r;
va_list ap;
va_start(ap, sig);
int args = 0;
while(*sig) {
switch(*sig++) {
case 'b':
lua_pushboolean(L, va_arg(ap, int));
break;
case 'd':
lua_pushnumber(L, va_arg(ap, int));
break;
case 'u':
lua_pushnumber(L, va_arg(ap, unsigned int));
break;
case 'f':
lua_pushnumber(L, va_arg(ap, double));
break;
case 's':
lua_pushstring(L, va_arg(ap, const char*));
break;
case 'P':
lua_pushlightuserdata(L, va_arg(ap, void*));
break;
case 'p':
luas_push_obj(L, va_arg(ap, void*), va_arg(ap, const char*));
break;
case ':':
goto call;
default:
goto err_exit;
}
++args;
}
call:
res = strlen(sig);
residx = -res;
r = lua_pcall(L, args, res, s->traceback);
if (r != LUA_OK) {
LOG_ERROR("lua call function [%s.%s] error : %s", mod, func, lua_tostring(L, -1));
goto err_exit;
}
while (*sig) {
switch (*sig++) {
case 'b':
if (!lua_isboolean(L, residx))
goto err_res;
*va_arg(ap, int*) = (int)lua_toboolean(L, residx);
break;
case 'd':
if (!lua_isnumber(L, residx))
goto err_res;
*va_arg(ap, int*) = (int)lua_tointeger(L, residx);
break;
case 'u':
if (!lua_isnumber(L, residx))
goto err_res;
*va_arg(ap, unsigned int*) = (unsigned int)lua_tounsigned(L, residx);
break;
case 'f':
if (!lua_isnumber(L, residx))
goto err_res;
*va_arg(ap, double*) = (double)lua_tonumber(L, residx);
break;
case 's':
if (!lua_isstring(L, residx))
goto err_res;
*va_arg(ap, const char**) = lua_tostring(L, residx);
break;
default:
goto err_exit;
}
++residx;
}
return 0;
err_res:
LOG_ERROR("lua call function [%s.%s] error : return need '%c'#%d",
mod, func, *(sig-1), res + residx + 1);
err_exit:
lua_settop(L, top);
return -1;
}
template<> unsigned long long Eluna::CHECKVAL<unsigned long long>(lua_State* luastate, int narg)
{
if (lua_isnumber(luastate, narg))
return static_cast<unsigned long long>(CHECKVAL<uint32>(luastate, narg));
return *(Eluna::CHECKOBJ<unsigned long long>(luastate, narg, true));
}
static int db_getinfo (lua_State *L) {
lua_Debug ar;
int arg;
//add by cuiwei 07.8.30
int i;
char aparms[1024] = {0};
//add end
lua_State *L1 = getthread(L, &arg);
const char *options = luaL_optstring(L, arg+2, "flnSu");
if (lua_isnumber(L, arg+1)) {
if (!lua_getstack(L1, (int)lua_tointeger(L, arg+1), &ar)) {
lua_pushnil(L); /* level out of range */
return 1;
}
}
else if (lua_isfunction(L, arg+1)) {
lua_pushfstring(L, ">%s", options);
options = lua_tostring(L, -1);
lua_pushvalue(L, arg+1);
lua_xmove(L, L1, 1);
}
else
return luaL_argerror(L, arg+1, "function or level expected");
if (!lua_getinfo(L1, options, &ar))
return luaL_argerror(L, arg+2, "invalid option");
lua_createtable(L, 0, 2);
if (strchr(options, 'S')) {
settabss(L, "source", ar.source);
settabss(L, "short_src", ar.short_src);
settabsi(L, "linedefined", ar.linedefined);
settabsi(L, "lastlinedefined", ar.lastlinedefined);
settabss(L, "what", ar.what);
}
if (strchr(options, 'l'))
settabsi(L, "currentline", ar.currentline);
if (strchr(options, 'u'))
{
settabsi(L, "nups", ar.nups);
//add by cuiwei 07.8.30
if (ar.what != "C" )
{
settabsi(L, "npars", ar.npars);
settabsi(L, "has3dot", ar.has3dot?1:0);
for ( i = 1; i <= ar.npars; i++ )
{
strcat(aparms, ar.parms[i-1]);
if ( i != ar.npars || ar.has3dot)
{
strcat(aparms, ",");
}
}
if ( ar.has3dot )
{
strcat(aparms, "...");
} settabss(L, "strparms", aparms);
}
//add end
}
if (strchr(options, 'n')) {
settabss(L, "name", ar.name);
settabss(L, "namewhat", ar.namewhat);
}
if (strchr(options, 'L'))
treatstackoption(L, L1, "activelines");
if (strchr(options, 'f'))
treatstackoption(L, L1, "func");
return 1; /* return table */
}
/**
* @brief Mods player using the power of Lua.
*/
static void faction_modPlayerLua( int f, double mod, const char *source, int secondary )
{
Faction *faction;
lua_State *L;
int errf;
double old, delta;
HookParam hparam[3];
faction = &faction_stack[f];
/* Make sure it's not static. */
if (faction_isFlag(faction, FACTION_STATIC))
return;
L = faction->state;
old = faction->player;
if (L == NULL)
faction->player += mod;
else {
#if DEBUGGING
lua_pushcfunction(L, nlua_errTrace);
errf = -6;
#else /* DEBUGGING */
errf = 0;
#endif /* DEBUGGING */
/* Set up the function:
* faction_hit( current, amount, source, secondary ) */
lua_getglobal( L, "faction_hit" );
lua_pushnumber( L, faction->player );
lua_pushnumber( L, mod );
lua_pushstring( L, source );
lua_pushboolean( L, secondary );
/* Call function. */
if (lua_pcall( L, 4, 1, errf )) { /* An error occurred. */
WARN("Faction '%s': %s", faction->name, lua_tostring(L,-1));
#if DEBUGGING
lua_pop( L, 2 );
#else /* DEBUGGING */
lua_pop( L, 1 );
#endif /* DEBUGGING */
return;
}
/* Parse return. */
if (!lua_isnumber( L, -1 ))
WARN( "Lua script for faction '%s' did not return a number from 'faction_hit(...)'.", faction->name );
else
faction->player = lua_tonumber( L, -1 );
#if DEBUGGING
lua_pop( L, 2 );
#else /* DEBUGGING */
lua_pop( L, 1 );
#endif /* DEBUGGING */
}
/* Sanitize just in case. */
faction_sanitizePlayer( faction );
/* Run hook if necessary. */
delta = faction->player - old;
if (fabs(delta) > 1e-10) {
hparam[0].type = HOOK_PARAM_FACTION;
hparam[0].u.lf = f;
hparam[1].type = HOOK_PARAM_NUMBER;
hparam[1].u.num = delta;
hparam[2].type = HOOK_PARAM_SENTINEL;
hooks_runParam( "standing", hparam );
/* Tell space the faction changed. */
space_factionChange();
}
}
/**
* puts a table with content of a xavp
*/
static int lua_sr_xavp_get(lua_State *L)
{
str xavp_name;
int indx = 0;
sr_lua_env_t *env_L;
sr_xavp_t *avp;
int num_param = 0;
int param = -1;
int all_flag = 0;
int simple_flag = 0;
lua_Number elem = 1;
int xavp_size = 0;
env_L = sr_lua_env_get();
num_param = lua_gettop(L);
if(num_param<2 && num_param>3)
{
LM_ERR("wrong number of parameters [%d]\n", num_param);
return 0;
}
if(num_param==3)
{
if(!lua_isnumber(L, param))
{
LM_ERR("invalid int parameter\n");
return 0;
}
simple_flag = lua_tointeger(L, param);
param = param - 1;
}
if(!lua_isnumber(L, param))
{
if(lua_isnil(L, param))
{
all_flag = 1;
}
else
{
LM_ERR("invalid parameter, must be int or nil\n");
return 0;
}
}
else
{
indx = lua_tointeger(L, param);
}
param = param - 1;
xavp_name.s = (char*)lua_tostring(L, param);
if(xavp_name.s==NULL || env_L->msg==NULL)
{
LM_ERR("No xavp name in %d param\n", param);
return 0;
}
xavp_name.len = strlen(xavp_name.s);
if(all_flag>0) {
indx = 0;
lua_newtable(L);
}
xavp_size = xavp_count(&xavp_name, NULL);
if(indx<0)
{
if((indx*-1)>xavp_size)
{
LM_ERR("can't get xavp:%.*s index:%d\n", xavp_name.len, xavp_name.s, indx);
lua_pushnil(L);
return 1;
}
indx = xavp_size + indx;
}
avp = xavp_get_by_index(&xavp_name, indx, NULL);
do
{
if(avp==NULL){
LM_ERR("can't get xavp:%.*s index:%d\n", xavp_name.len, xavp_name.s, indx);
lua_pushnil(L);
return 1;
}
if(all_flag!=0) {
lua_pushnumber(L, elem);
elem = elem + 1;
}
lua_sr_push_xavp_table(L, avp, simple_flag);
if(all_flag!=0) {
lua_rawset(L, -3);
indx = indx + 1;
avp = xavp_get_by_index(&xavp_name, indx, NULL);
}
else return 1;
}while(avp!=NULL);
return 1;
}
int create_class::stage1(lua_State* L)
{
#ifndef LUABIND_NO_ERROR_CHECKING
if (lua_gettop(L) != 1 || lua_type(L, 1) != LUA_TSTRING || lua_isnumber(L, 1))
{
lua_pushstring(L, "invalid construct, expected class name");
lua_error(L);
}
if (std::strlen(lua_tostring(L, 1)) != lua_strlen(L, 1))
{
lua_pushstring(L, "luabind does not support class names with extra nulls");
lua_error(L);
}
#endif
const char* name = lua_tostring(L, 1);
int stack_level = lua_gettop(L);
//////////////////////////////////////////////////////////////////////////
// Here we are trying to add the class to the namespace in the local variable "this" if exist
//////////////////////////////////////////////////////////////////////////
int index = LUA_GLOBALSINDEX;
lua_Debug ar;
if ( lua_getstack (L, 1, &ar) )
{
int i = 1;
const char *name;
while ((name = lua_getlocal(L, &ar, i++)) != NULL) {
if (!strcmp("this",name)) {
if (lua_istable(L,-1))
index = lua_gettop(L);
else
lua_pop(L, 1);
break;
}
lua_pop(L, 1); /* remove variable value */
}
}
//////////////////////////////////////////////////////////////////////////
// End of change
//////////////////////////////////////////////////////////////////////////
void* c = lua_newuserdata(L, sizeof(class_rep));
new(c) class_rep(L, name);
// make the class globally available
lua_pushstring(L, name);
lua_pushvalue(L, -2);
lua_settable(L, index);
if (index != LUA_GLOBALSINDEX)
lua_remove(L,index);
// also add it to the closure as return value
lua_pushcclosure(L, &stage2, 1);
int stack_level2 = lua_gettop(L);
return 1;
}
int pklua_lua_socket_recv(lua_State *L)
{
pk_log(PK_LOG_LUA_DEBUG, "pklua_lua_socket_recv(%p)", L);
pklua_buffer read_buffer;
int sockfd = _pklua_lua_socket_get_sockfd(L);
unsigned int wantbytes = 0;
unsigned int maxbytes = 8*1024;
char sock_input[4096];
if (lua_gettop(L) > 1 && lua_isnumber(L, 2))
wantbytes = lua_tointeger(L, 2);
if (lua_gettop(L) > 2 && lua_isnumber(L, 3))
maxbytes = lua_tointeger(L, 3);
if (maxbytes < wantbytes)
maxbytes = wantbytes;
_pklua_lua_socket_get_buffer(L, "_read_buffer", &read_buffer);
int buffer_pos = lua_gettop(L);
size_t i = 0;
while (1) {
/* Check if we have a line in our buffer, return if so! */
for (; i < read_buffer.length; i++) {
if (((wantbytes < 1) && (read_buffer.bytes[i] == '\n')) ||
((wantbytes > 0) && (i >= wantbytes)) ||
(i >= maxbytes)) {
/* Copy the line/chunk... */
size_t eol = i;
if (wantbytes < 1)
while (eol && (read_buffer.bytes[eol] == '\r' ||
read_buffer.bytes[eol] == '\n')) eol--;
lua_pushlstring(L, read_buffer.bytes, eol+1);
/* Adjust the read_buffer and pop from the stack */
_pklua_lua_socket_shift_buffer(L, "_read_buffer", i+1, &read_buffer);
_pklua_lua_socket_free_buffer(L, buffer_pos);
/* Return line! */
return 1;
}
}
/* Only have partial line, read more data from socket */
int read_bytes = wantbytes ? (wantbytes - read_buffer.length) : 4096;
if (read_bytes > 4096) read_bytes = 4096;
while ((read_bytes = PKS_read(sockfd, sock_input, read_bytes)) < 0) {
/* Is this really an error? */
if ((errno != 0) && (errno != EINTR) && (errno != EAGAIN)) break;
}
/* If EOF, return buffer contents */
if (read_bytes <= 0) {
lua_pushlstring(L, read_buffer.bytes, read_buffer.length);
/* Adjust the read_buffer and pop from the stack */
_pklua_lua_socket_shift_buffer(L, "_read_buffer", i+1, &read_buffer);
_pklua_lua_socket_free_buffer(L, buffer_pos);
/* Return line! */
return 1;
}
/* Else, append to buffer, keep looping */
else {
_pklua_lua_socket_free_buffer(L, buffer_pos);
_pklua_lua_socket_append_buffer(L, "_read_buffer",
sock_input, read_bytes);
_pklua_lua_socket_get_buffer(L, "_read_buffer", &read_buffer);
buffer_pos = lua_gettop(L);
}
}
_pklua_lua_socket_free_buffer(L, buffer_pos);
return 0;
}
void read_object_properties(lua_State *L, int index,
ObjectProperties *prop)
{
if(index < 0)
index = lua_gettop(L) + 1 + index;
if(!lua_istable(L, index))
return;
prop->hp_max = getintfield_default(L, -1, "hp_max", 10);
getboolfield(L, -1, "physical", prop->physical);
getboolfield(L, -1, "collide_with_objects", prop->collideWithObjects);
getfloatfield(L, -1, "weight", prop->weight);
lua_getfield(L, -1, "collisionbox");
if(lua_istable(L, -1))
prop->collisionbox = read_aabb3f(L, -1, 1.0);
lua_pop(L, 1);
getstringfield(L, -1, "visual", prop->visual);
getstringfield(L, -1, "mesh", prop->mesh);
lua_getfield(L, -1, "visual_size");
if(lua_istable(L, -1))
prop->visual_size = read_v2f(L, -1);
lua_pop(L, 1);
lua_getfield(L, -1, "textures");
if(lua_istable(L, -1)){
prop->textures.clear();
int table = lua_gettop(L);
lua_pushnil(L);
while(lua_next(L, table) != 0){
// key at index -2 and value at index -1
if(lua_isstring(L, -1))
prop->textures.push_back(lua_tostring(L, -1));
else
prop->textures.push_back("");
// removes value, keeps key for next iteration
lua_pop(L, 1);
}
}
lua_pop(L, 1);
lua_getfield(L, -1, "colors");
if (lua_istable(L, -1)) {
int table = lua_gettop(L);
prop->colors.clear();
for (lua_pushnil(L); lua_next(L, table); lua_pop(L, 1)) {
video::SColor color(255, 255, 255, 255);
read_color(L, -1, &color);
prop->colors.push_back(color);
}
}
lua_pop(L, 1);
lua_getfield(L, -1, "spritediv");
if(lua_istable(L, -1))
prop->spritediv = read_v2s16(L, -1);
lua_pop(L, 1);
lua_getfield(L, -1, "initial_sprite_basepos");
if(lua_istable(L, -1))
prop->initial_sprite_basepos = read_v2s16(L, -1);
lua_pop(L, 1);
getboolfield(L, -1, "is_visible", prop->is_visible);
getboolfield(L, -1, "makes_footstep_sound", prop->makes_footstep_sound);
getfloatfield(L, -1, "automatic_rotate", prop->automatic_rotate);
if (getfloatfield(L, -1, "stepheight", prop->stepheight))
prop->stepheight *= BS;
lua_getfield(L, -1, "automatic_face_movement_dir");
if (lua_isnumber(L, -1)) {
prop->automatic_face_movement_dir = true;
prop->automatic_face_movement_dir_offset = luaL_checknumber(L, -1);
} else if (lua_isboolean(L, -1)) {
prop->automatic_face_movement_dir = lua_toboolean(L, -1);
prop->automatic_face_movement_dir_offset = 0.0;
}
lua_pop(L, 1);
getboolfield(L, -1, "backface_culling", prop->backface_culling);
getstringfield(L, -1, "nametag", prop->nametag);
lua_getfield(L, -1, "nametag_color");
if (!lua_isnil(L, -1)) {
video::SColor color = prop->nametag_color;
if (read_color(L, -1, &color))
prop->nametag_color = color;
}
lua_pop(L, 1);
lua_getfield(L, -1, "automatic_face_movement_max_rotation_per_sec");
if (lua_isnumber(L, -1)) {
prop->automatic_face_movement_max_rotation_per_sec = luaL_checknumber(L, -1);
}
lua_pop(L, 1);
getstringfield(L, -1, "infotext", prop->infotext);
}
static int vlclua_node_add_subitem( lua_State *L )
{
services_discovery_t *p_sd = (services_discovery_t *)vlclua_get_this( L );
input_item_t **pp_node = (input_item_t **)luaL_checkudata( L, 1, "node" );
if( *pp_node )
{
if( lua_istable( L, -1 ) )
{
lua_getfield( L, -1, "path" );
if( lua_isstring( L, -1 ) )
{
const char *psz_path = lua_tostring( L, -1 );
/* The table must be at the top of the stack when calling
* vlclua_read_options() */
char **ppsz_options = NULL;
int i_options = 0;
lua_pushvalue( L, -2 );
vlclua_read_options( p_sd, L, &i_options, &ppsz_options );
input_item_t *p_input = input_item_NewExt( psz_path,
psz_path, i_options,
(const char **)ppsz_options,
VLC_INPUT_OPTION_TRUSTED, -1 );
lua_pop( L, 2 );
if( p_input )
{
input_item_node_t *p_input_node = input_item_node_Create( *pp_node );
vlclua_read_meta_data( p_sd, L, p_input );
/* This one is to be tested... */
vlclua_read_custom_meta_data( p_sd, L, p_input );
lua_getfield( L, -1, "duration" );
if( lua_isnumber( L, -1 ) )
input_item_SetDuration( p_input, (lua_tonumber( L, -1 )*1e6) );
else if( !lua_isnil( L, -1 ) )
msg_Warn( p_sd, "Item duration should be a number (in seconds)." );
lua_pop( L, 1 );
input_item_node_AppendItem( p_input_node, p_input );
input_item_node_PostAndDelete( p_input_node );
input_item_t **udata = (input_item_t **)
lua_newuserdata( L, sizeof( input_item_t * ) );
*udata = p_input;
if( luaL_newmetatable( L, "input_item_t" ) )
{
lua_newtable( L );
luaL_register( L, NULL, vlclua_item_reg );
lua_setfield( L, -2, "__index" );
lua_pushliteral( L, "none of your business" );
lua_setfield( L, -2, "__metatable" );
}
lua_setmetatable( L, -2 );
vlc_gc_decref( p_input );
}
while( i_options > 0 )
free( ppsz_options[--i_options] );
free( ppsz_options );
}
else
msg_Err( p_sd, "node:add_subitem: the \"path\" parameter can't be empty" );
}
else
msg_Err( p_sd, "Error parsing add_subitem arguments" );
}
return 1;
}
inline void _SaveTableValue(lua::NativeState hLua,lua::Table *table,T key)
{
// ... [value]
int type = lua_type(hLua, -1);
if ( type==LUA_TSTRING )
{
lua::Str _value;
CheckVarFromLua(hLua,&_value,-1);
lua::Var value(_value);
(*table)[key] = value;
}
else if ( type==LUA_TTABLE )
{
lua::Table subTable;
_VisitTable(hLua,&subTable);
lua::Var value = subTable;
(*table)[key] = value;
}
// Just in case.
else if ( type==LUA_TNIL )
{
// This element is not exist.
}
else if ( type==LUA_TNONE )
{
lua::Log<<"error:No one know what type is it"<<lua::End;
}
else if ( type==LUA_TLIGHTUSERDATA )
{
lua::Ptr value;
CheckVarFromLua(hLua,&value,-1);
(*table)[key] = value;
}
else if ( type==LUA_TBOOLEAN )
{
lua::Bool value;
CheckVarFromLua(hLua,&value,-1);
(*table)[key] = value;
}
#ifndef _LUAPP_KEEP_LOCAL_LUA_VARIABLE_
else if ( type==LUA_TFUNCTION )
{
lua::Func value;
(*table)[key] = value;
}
else if ( type==LUA_TTHREAD )
{
lua::Task value;
(*table)[key] = value;
}
else if ( type==LUA_TUSERDATA )
{
lua::User value;
(*table)[key] = value;
}
#endif
else if ( lua_isinteger(hLua, -1) )
{
lua::Int value;
CheckVarFromLua(hLua,&value,-1);
(*table)[key] = value;
}
else if ( lua_isnumber(hLua, -1) )
{
lua::Num value;
CheckVarFromLua(hLua,&value,-1);
(*table)[key] = value;
}
else
{
// drop else value.
}
// ... [value]
}
static void interror (lua_State *L, int arg) {
if (lua_isnumber(L, arg))
luaL_argerror(L, arg, "number has no integer representation");
else
tag_error(L, arg, LUA_TNUMBER);
}
void sinsp_chisel::parse_view_column(lua_State *ls, OUT chisel_desc* cd, OUT void* columns)
{
vector<sinsp_view_column_info>* cols = (vector<sinsp_view_column_info>*)columns;
lua_pushnil(ls);
string tmpstr;
string name;
string description;
string field;
string filterfield;
uint32_t colsize = 0xffffffff;
uint32_t flags = TEF_NONE;
sinsp_field_aggregation aggregation = A_NONE;
sinsp_field_aggregation groupby_aggregation = A_NONE;
vector<string> tags;
while(lua_next(ls, -2) != 0)
{
string fldname = lua_tostring(ls, -2);
if(fldname == "name")
{
name = lua_tostring(ls, -1);
}
else if(fldname == "description")
{
description = lua_tostring(ls, -1);
}
else if(fldname == "field")
{
field = lua_tostring(ls, -1);
}
else if(fldname == "filterfield")
{
filterfield = lua_tostring(ls, -1);
}
else if(fldname == "colsize")
{
if(lua_isnumber(ls, -1))
{
colsize = (uint32_t)lua_tonumber(ls, -1);
}
else
{
throw sinsp_exception(string(lua_tostring(ls, -2)) + " must be a number");
}
}
else if(fldname == "is_key")
{
if(lua_isboolean(ls, -1))
{
bool ik = (lua_toboolean(ls, -1) != 0);
if(ik)
{
flags |= TEF_IS_KEY;
}
}
else
{
throw sinsp_exception(string(lua_tostring(ls, -2)) + " must be a boolean value");
}
}
else if(fldname == "filter_in_child_only")
{
if(lua_isboolean(ls, -1))
{
bool ik = (lua_toboolean(ls, -1) != 0);
if(ik)
{
flags |= TEF_FILTER_IN_CHILD_ONLY;
}
}
else
{
throw sinsp_exception(string(lua_tostring(ls, -2)) + " must be a boolean value");
}
}
else if(fldname == "is_groupby_key")
{
if(lua_isboolean(ls, -1))
{
bool ik = (lua_toboolean(ls, -1) != 0);
if(ik)
{
flags |= TEF_IS_GROUPBY_KEY;
}
}
else
{
throw sinsp_exception(string(lua_tostring(ls, -2)) + " must be a boolean value");
}
}
else if(fldname == "is_sorting")
{
if(lua_isboolean(ls, -1))
{
bool ik = (lua_toboolean(ls, -1) != 0);
if(ik)
{
flags |= TEF_IS_SORT_COLUMN;
}
}
else
{
throw sinsp_exception(string(lua_tostring(ls, -2)) + " must be a boolean value");
}
}
else if(fldname == "aggregation")
{
if(lua_isstring(ls, -1))
{
string ag = lua_tostring(ls, -1);
aggregation = string_to_aggregation(ag);
}
}
else if(fldname == "groupby_aggregation")
{
if(lua_isstring(ls, -1))
{
string ag = lua_tostring(ls, -1);
groupby_aggregation = string_to_aggregation(ag);
}
}
else if(fldname == "tags")
{
if(lua_istable(ls, -1))
{
lua_pushnil(ls);
while(lua_next(ls, -2) != 0)
{
if(lua_isstring(ls, -1))
{
tmpstr = lua_tostring(ls, -1);
tags.push_back(tmpstr);
}
else
{
throw sinsp_exception("tags column entries must be strings");
}
lua_pop(ls, 1);
}
}
else
{
throw sinsp_exception(string(lua_tostring(ls, -2)) + " is not a table");
}
}
lua_pop(ls, 1);
}
if(filterfield != "" && ((flags & TEF_IS_KEY) == 0) && ((flags & TEF_IS_GROUPBY_KEY) == 0))
{
throw sinsp_exception("wrong view column syntax: filterfield specified for a non key column");
}
cols->push_back(sinsp_view_column_info(field,
name,
description,
colsize,
(uint32_t)flags,
aggregation,
groupby_aggregation,
tags,
filterfield));
}
float luaL_check_number(int32 numArg) {
lua_Object o = lua_getparam(numArg);
luaL_arg_check(lua_isnumber(o), numArg, "number expected");
return lua_getnumber(o);
}
template<> long long Eluna::CHECKVAL<long long>(lua_State* luastate, int narg)
{
if (lua_isnumber(luastate, narg))
return static_cast<long long>(CHECKVAL<double>(luastate, narg));
return *(Eluna::CHECKOBJ<long long>(luastate, narg, true));
}
// Lua: mqtt:lwt( topic, message, qos, retain, function(client) )
static int mqtt_socket_lwt( lua_State* L )
{
NODE_DBG("enter mqtt_socket_lwt.\n");
uint8_t stack = 1;
size_t topicSize, msgSize;
NODE_DBG("mqtt_socket_lwt.\n");
lmqtt_userdata *mud = NULL;
const char *lwtTopic, *lwtMsg;
uint8_t lwtQoS, lwtRetain;
mud = (lmqtt_userdata *)luaL_checkudata( L, stack, "mqtt.socket" );
luaL_argcheck( L, mud, stack, "mqtt.socket expected" );
if(mud == NULL)
return 0;
stack++;
lwtTopic = luaL_checklstring( L, stack, &topicSize );
if (lwtTopic == NULL)
{
return luaL_error( L, "need lwt topic");
}
stack++;
lwtMsg = luaL_checklstring( L, stack, &msgSize );
if (lwtMsg == NULL)
{
return luaL_error( L, "need lwt message");
}
if(mud->connect_info.will_topic){ // free the previous one if there is any
c_free(mud->connect_info.will_topic);
mud->connect_info.will_topic = NULL;
}
if(mud->connect_info.will_message){
c_free(mud->connect_info.will_message);
mud->connect_info.will_message = NULL;
}
mud->connect_info.will_topic = (uint8_t*) c_zalloc( topicSize + 1 );
mud->connect_info.will_message = (uint8_t*) c_zalloc( msgSize + 1 );
if(!mud->connect_info.will_topic || !mud->connect_info.will_message){
if(mud->connect_info.will_topic){
c_free(mud->connect_info.will_topic);
mud->connect_info.will_topic = NULL;
}
if(mud->connect_info.will_message){
c_free(mud->connect_info.will_message);
mud->connect_info.will_message = NULL;
}
return luaL_error( L, "not enough memory");
}
c_memcpy(mud->connect_info.will_topic, lwtTopic, topicSize);
mud->connect_info.will_topic[topicSize] = 0;
c_memcpy(mud->connect_info.will_message, lwtMsg, msgSize);
mud->connect_info.will_message[msgSize] = 0;
if ( lua_isnumber(L, stack) )
{
mud->connect_info.will_qos = lua_tointeger(L, stack);
stack++;
}
if ( lua_isnumber(L, stack) )
{
mud->connect_info.will_retain = lua_tointeger(L, stack);
stack++;
}
NODE_DBG("mqtt_socket_lwt: topic: %s, message: %s, qos: %d, retain: %d\n",
mud->connect_info.will_topic,
mud->connect_info.will_message,
mud->connect_info.will_qos,
mud->connect_info.will_retain);
NODE_DBG("leave mqtt_socket_lwt.\n");
return 0;
}
LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int narg) {
lua_Integer d = lua_tointeger(L, narg);
if (d == 0 && !lua_isnumber(L, narg)) /* avoid extra test when d is not 0 */
tag_error(L, narg, LUA_TNUMBER);
return d;
}
// Lua: mqtt.Client(clientid, keepalive, user, pass)
static int mqtt_socket_client( lua_State* L )
{
NODE_DBG("enter mqtt_socket_client.\n");
lmqtt_userdata *mud;
char tempid[20] = {0};
c_sprintf(tempid, "%s%x", "NodeMCU_", system_get_chip_id() );
NODE_DBG_(tempid);
NODE_DBG("\n");
const char *clientId = tempid, *username = NULL, *password = NULL;
size_t idl = c_strlen(tempid);
size_t unl = 0, pwl = 0;
int keepalive = 0;
int stack = 1;
unsigned secure = 0;
int top = lua_gettop(L);
// create a object
mud = (lmqtt_userdata *)lua_newuserdata(L, sizeof(lmqtt_userdata));
// pre-initialize it, in case of errors
mud->L = NULL;
mud->self_ref = LUA_NOREF;
mud->cb_connect_ref = LUA_NOREF;
mud->cb_disconnect_ref = LUA_NOREF;
mud->cb_message_ref = LUA_NOREF;
mud->cb_suback_ref = LUA_NOREF;
mud->cb_puback_ref = LUA_NOREF;
mud->pesp_conn = NULL;
mud->secure = 0;
mud->keep_alive_tick = 0;
mud->event_timeout = 0;
mud->connState = MQTT_INIT;
mud->connected = false;
c_memset(&mud->mqttTimer, 0, sizeof(ETSTimer));
c_memset(&mud->mqtt_state, 0, sizeof(mqtt_state_t));
c_memset(&mud->connect_info, 0, sizeof(mqtt_connect_info_t));
// set its metatable
luaL_getmetatable(L, "mqtt.socket");
lua_setmetatable(L, -2);
mud->L = L; // L for mqtt module.
if( lua_isstring(L,stack) ) // deal with the clientid string
{
clientId = luaL_checklstring( L, stack, &idl );
stack++;
}
if(lua_isnumber( L, stack ))
{
keepalive = luaL_checkinteger( L, stack);
stack++;
}
if(keepalive == 0){
keepalive = MQTT_DEFAULT_KEEPALIVE;
}
if(lua_isstring( L, stack )){
username = luaL_checklstring( L, stack, &unl );
stack++;
}
if(username == NULL)
unl = 0;
NODE_DBG("lengh username: %d\r\n", unl);
if(lua_isstring( L, stack )){
password = luaL_checklstring( L, stack, &pwl );
stack++;
}
if(password == NULL)
pwl = 0;
NODE_DBG("lengh password: %d\r\n", pwl);
// TODO: check the zalloc result.
mud->connect_info.client_id = (uint8_t *)c_zalloc(idl+1);
mud->connect_info.username = (uint8_t *)c_zalloc(unl + 1);
mud->connect_info.password = (uint8_t *)c_zalloc(pwl + 1);
if(!mud->connect_info.client_id || !mud->connect_info.username || !mud->connect_info.password){
if(mud->connect_info.client_id) {
c_free(mud->connect_info.client_id);
mud->connect_info.client_id = NULL;
}
if(mud->connect_info.username) {
c_free(mud->connect_info.username);
mud->connect_info.username = NULL;
}
if(mud->connect_info.password) {
c_free(mud->connect_info.password);
mud->connect_info.password = NULL;
}
return luaL_error(L, "not enough memory");
}
c_memcpy(mud->connect_info.client_id, clientId, idl);
mud->connect_info.client_id[idl] = 0;
c_memcpy(mud->connect_info.username, username, unl);
mud->connect_info.username[unl] = 0;
c_memcpy(mud->connect_info.password, password, pwl);
mud->connect_info.password[pwl] = 0;
NODE_DBG("MQTT: Init info: %s, %s, %s\r\n", mud->connect_info.client_id, mud->connect_info.username, mud->connect_info.password);
mud->connect_info.clean_session = 1;
mud->connect_info.will_qos = 0;
mud->connect_info.will_retain = 0;
mud->connect_info.keepalive = keepalive;
mud->mqtt_state.pending_msg_q = NULL;
mud->mqtt_state.auto_reconnect = 0;
mud->mqtt_state.port = 1883;
mud->mqtt_state.connect_info = &mud->connect_info;
NODE_DBG("leave mqtt_socket_client.\n");
return 1;
}
int CLuaVector4Defs::Create ( lua_State* luaVM )
{
CVector4D vector;
CScriptArgReader argStream ( luaVM );
if ( argStream.NextIsTable () )
{
lua_pushvalue ( luaVM, 1 );
lua_pushstring ( luaVM, "x" );
lua_rawget ( luaVM, -2 );
if ( lua_isnumber ( luaVM, -1 ) )
{
vector.fX = ( float ) lua_tonumber ( luaVM, -1 );
lua_pop ( luaVM, 1 );
}
else
{
lua_pop ( luaVM, 1 );
lua_rawgeti ( luaVM, -1, 1 );
if ( lua_isnumber ( luaVM, -1 ) )
vector.fX = ( float ) lua_tonumber ( luaVM, -1 );
lua_pop ( luaVM, 1 );
}
lua_pushstring ( luaVM, "y" );
lua_rawget ( luaVM, -2 );
if ( lua_isnumber ( luaVM, -1 ) )
{
vector.fY = ( float ) lua_tonumber ( luaVM, -1 );
lua_pop ( luaVM, 1 );
}
else
{
lua_pop ( luaVM, 1 );
lua_rawgeti ( luaVM, -1, 2 );
if ( lua_isnumber ( luaVM, -1 ) )
vector.fY = ( float ) lua_tonumber ( luaVM, -1 );
lua_pop ( luaVM, 1 );
}
lua_pushstring ( luaVM, "z" );
lua_rawget ( luaVM, -2 );
if ( lua_isnumber ( luaVM, -1 ) )
{
vector.fZ = ( float ) lua_tonumber ( luaVM, -1 );
lua_pop ( luaVM, 1 );
}
else
{
lua_pop ( luaVM, 1 );
lua_rawgeti ( luaVM, -1, 3 );
if ( lua_isnumber ( luaVM, -1 ) )
vector.fZ = ( float ) lua_tonumber ( luaVM, -1 );
lua_pop ( luaVM, 1 );
}
lua_pushstring ( luaVM, "w" );
lua_rawget ( luaVM, -2 );
if ( lua_isnumber ( luaVM, -1 ) )
{
vector.fW = ( float ) lua_tonumber ( luaVM, -1 );
lua_pop ( luaVM, 1 );
}
else
{
lua_pop ( luaVM, 1 );
lua_rawgeti ( luaVM, -1, 4 );
if ( lua_isnumber ( luaVM, -1 ) )
vector.fW = ( float ) lua_tonumber ( luaVM, -1 );
lua_pop ( luaVM, 1 );
}
}
else if ( argStream.NextIsNumber () )
{
argStream.ReadNumber ( vector.fX );
if ( argStream.NextIsNumber () )
{
argStream.ReadNumber ( vector.fY );
if ( argStream.NextIsNumber () )
argStream.ReadNumber ( vector.fZ );
if ( argStream.NextIsNumber () )
argStream.ReadNumber ( vector.fW );
}
}
else if ( argStream.NextIsVector4D () )
{
argStream.ReadVector4D ( vector );
}
lua_pushvector ( luaVM, vector );
return 1;
}
// Lua: mqtt:connect( host, port, secure, auto_reconnect, function(client) )
static int mqtt_socket_connect( lua_State* L )
{
NODE_DBG("enter mqtt_socket_connect.\n");
lmqtt_userdata *mud = NULL;
unsigned port = 1883;
size_t il;
ip_addr_t ipaddr;
const char *domain;
int stack = 1;
unsigned secure = 0, auto_reconnect = 0;
int top = lua_gettop(L);
mud = (lmqtt_userdata *)luaL_checkudata(L, stack, "mqtt.socket");
luaL_argcheck(L, mud, stack, "mqtt.socket expected");
stack++;
if(mud == NULL)
return 0;
if(mud->connected){
return luaL_error(L, "already connected");
}
if(mud->pesp_conn){ //TODO: should I free tcp struct directly or ask user to call close()???
mud->pesp_conn->reverse = NULL;
if(mud->pesp_conn->proto.tcp)
c_free(mud->pesp_conn->proto.tcp);
mud->pesp_conn->proto.tcp = NULL;
c_free(mud->pesp_conn);
mud->pesp_conn = NULL;
}
struct espconn *pesp_conn = NULL;
pesp_conn = mud->pesp_conn = (struct espconn *)c_zalloc(sizeof(struct espconn));
if(!pesp_conn)
return luaL_error(L, "not enough memory");
pesp_conn->proto.udp = NULL;
pesp_conn->proto.tcp = (esp_tcp *)c_zalloc(sizeof(esp_tcp));
if(!pesp_conn->proto.tcp){
c_free(pesp_conn);
pesp_conn = mud->pesp_conn = NULL;
return luaL_error(L, "not enough memory");
}
// reverse is for the callback function
pesp_conn->reverse = mud;
pesp_conn->type = ESPCONN_TCP;
pesp_conn->state = ESPCONN_NONE;
mud->connected = false;
if( (stack<=top) && lua_isstring(L,stack) ) // deal with the domain string
{
domain = luaL_checklstring( L, stack, &il );
stack++;
if (domain == NULL)
{
domain = "127.0.0.1";
}
ipaddr.addr = ipaddr_addr(domain);
c_memcpy(pesp_conn->proto.tcp->remote_ip, &ipaddr.addr, 4);
NODE_DBG("TCP ip is set: ");
NODE_DBG(IPSTR, IP2STR(&ipaddr.addr));
NODE_DBG("\n");
}
if ( (stack<=top) && lua_isnumber(L, stack) )
{
port = lua_tointeger(L, stack);
stack++;
NODE_DBG("TCP port is set: %d.\n", port);
}
pesp_conn->proto.tcp->remote_port = port;
pesp_conn->proto.tcp->local_port = espconn_port();
mud->mqtt_state.port = port;
if ( (stack<=top) && lua_isnumber(L, stack) )
{
secure = lua_tointeger(L, stack);
stack++;
if ( secure != 0 && secure != 1 ){
secure = 0; // default to 0
}
} else {
secure = 0; // default to 0
}
mud->secure = secure; // save
if ( (stack<=top) && lua_isnumber(L, stack) )
{
auto_reconnect = lua_tointeger(L, stack);
stack++;
if ( auto_reconnect != 0 && auto_reconnect != 1 ){
auto_reconnect = 0; // default to 0
}
} else {
auto_reconnect = 0; // default to 0
}
mud->mqtt_state.auto_reconnect = auto_reconnect;
// call back function when a connection is obtained, tcp only
if ((stack<=top) && (lua_type(L, stack) == LUA_TFUNCTION || lua_type(L, stack) == LUA_TLIGHTFUNCTION)){
lua_pushvalue(L, stack); // copy argument (func) to the top of stack
if(mud->cb_connect_ref != LUA_NOREF)
luaL_unref(L, LUA_REGISTRYINDEX, mud->cb_connect_ref);
mud->cb_connect_ref = luaL_ref(L, LUA_REGISTRYINDEX);
stack++;
}
lua_pushvalue(L, 1); // copy userdata to the top of stack
if(mud->self_ref != LUA_NOREF)
luaL_unref(L, LUA_REGISTRYINDEX, mud->self_ref);
mud->self_ref = luaL_ref(L, LUA_REGISTRYINDEX);
espconn_regist_connectcb(pesp_conn, mqtt_socket_connected);
espconn_regist_reconcb(pesp_conn, mqtt_socket_reconnected);
os_timer_disarm(&mud->mqttTimer);
os_timer_setfn(&mud->mqttTimer, (os_timer_func_t *)mqtt_socket_timer, mud);
// timer started in socket_connect()
if((ipaddr.addr == IPADDR_NONE) && (c_memcmp(domain,"255.255.255.255",16) != 0))
{
host_ip.addr = 0;
dns_reconn_count = 0;
if(ESPCONN_OK == espconn_gethostbyname(pesp_conn, domain, &host_ip, socket_dns_found)){
socket_dns_found(domain, &host_ip, pesp_conn); // ip is returned in host_ip.
}
}
else
{
socket_connect(pesp_conn);
}
NODE_DBG("leave mqtt_socket_connect.\n");
return 0;
}
//////////////////////////////////////////////////////////////////////
// Constructor:
static int ar_write(lua_State *L) {
struct archive** self_ref;
static struct {
const char *name;
int (*setter)(struct archive *);
} names[] = {
/* Copied from archive_write_set_format_by_name.c */
{ "ar", archive_write_set_format_ar_bsd },
{ "arbsd", archive_write_set_format_ar_bsd },
{ "argnu", archive_write_set_format_ar_svr4 },
{ "arsvr4", archive_write_set_format_ar_svr4 },
{ "cpio", archive_write_set_format_cpio },
{ "mtree", archive_write_set_format_mtree },
{ "newc", archive_write_set_format_cpio_newc },
{ "odc", archive_write_set_format_cpio },
{ "pax", archive_write_set_format_pax },
{ "posix", archive_write_set_format_pax },
{ "shar", archive_write_set_format_shar },
{ "shardump", archive_write_set_format_shar_dump },
{ "ustar", archive_write_set_format_ustar },
/* New ones to more closely match the C API */
{ "ar_bsd", archive_write_set_format_ar_bsd },
{ "ar_svr4", archive_write_set_format_ar_svr4 },
{ "cpio_newc", archive_write_set_format_cpio_newc },
{ "pax_restricted", archive_write_set_format_pax_restricted },
{ "shar_dump", archive_write_set_format_shar_dump },
{ NULL, NULL }
};
int idx = 0;
const char* name;
luaL_checktype(L, 1, LUA_TTABLE);
self_ref = (struct archive**)
lua_newuserdata(L, sizeof(struct archive*)); // {ud}
luaL_getmetatable(L, AR_WRITE); // {ud}, [write]
lua_setmetatable(L, -2); // {ud}
__ref_count++;
*self_ref = archive_write_new();
// Register it in the weak metatable:
ar_registry_set(L, *self_ref);
// Create an environment to store a reference to the writer:
lua_createtable(L, 1, 0); // {ud}, {}
lua_pushliteral(L, "writer"); // {ud}, {}, "writer"
lua_rawget(L, 1); // {ud}, {}, fn
if ( ! lua_isfunction(L, -1) ) {
err("MissingArgument: required parameter 'writer' must be a function");
}
lua_setfield(L, -2, "writer");
lua_setfenv(L, -2); // {ud}
// Extract various fields and prepare the archive:
lua_getfield(L, 1, "bytes_per_block");
if ( ! lua_isnil(L, -1) &&
ARCHIVE_OK != archive_write_set_bytes_per_block(*self_ref, lua_tointeger(L, -1)) )
{
err("archive_write_set_bytes_per_block: %s", archive_error_string(*self_ref));
}
lua_pop(L, 1);
lua_getfield(L, 1, "bytes_in_last_block");
if ( ! lua_isnil(L, -1) &&
ARCHIVE_OK != archive_write_set_bytes_in_last_block(*self_ref, lua_tointeger(L, -1)) )
{
err("archive_write_set_bytes_in_last_block: %s", archive_error_string(*self_ref));
}
lua_pop(L, 1);
lua_getfield(L, 1, "skip_file");
if ( ! lua_isnil(L, -1) ) {
dev_t dev;
ino_t ino;
if ( LUA_TTABLE != lua_type(L, -1) ) {
err("skip_file member must be a table object");
}
lua_getfield(L, -1, "dev");
if ( ! lua_isnumber(L, -1) ) {
err("skip_file.dev member must be a number");
}
dev = (dev_t)lua_tonumber(L, -1);
lua_pop(L, 1);
lua_getfield(L, -1, "ino");
if ( ! lua_isnumber(L, -1) ) {
err("skip_file.ino member must be a number");
}
ino = (ino_t)lua_tonumber(L, -1);
lua_pop(L, 1);
if ( ARCHIVE_OK != archive_write_set_skip_file(*self_ref, dev, ino) ) {
err("archive_write_set_skip_file: %s", archive_error_string(*self_ref));
}
}
lua_pop(L, 1);
lua_getfield(L, 1, "format");
if ( lua_isnil(L, -1) ) {
lua_pop(L, 1);
lua_pushliteral(L, "posix");
}
name = lua_tostring(L, -1);
for ( ;; idx++ ) {
if ( names[idx].name == NULL ) {
err("archive_write_set_format_*: No such format '%s'", name);
}
if ( strcmp(name, names[idx].name) == 0 ) break;
}
if ( ARCHIVE_OK != (names[idx].setter)(*self_ref) ) {
err("archive_write_set_format_%s: %s", name, archive_error_string(*self_ref));
}
lua_pop(L, 1);
lua_getfield(L, 1, "compression");
if ( ! lua_isnil(L, -1) ) {
static struct {
const char *name;
int (*setter)(struct archive *);
} names[] = {
{ "bzip2", archive_write_add_filter_bzip2 },
{ "compress", archive_write_add_filter_compress },
{ "gzip", archive_write_add_filter_gzip },
{ "lzma", archive_write_add_filter_lzma },
{ "xz", archive_write_add_filter_xz },
{ NULL, NULL }
};
int idx = 0;
const char* name = lua_tostring(L, -1);
for ( ;; idx++ ) {
if ( names[idx].name == NULL ) {
err("archive_write_set_compression_*: No such compression '%s'", name);
}
if ( strcmp(name, names[idx].name) == 0 ) break;
}
if ( ARCHIVE_OK != (names[idx].setter)(*self_ref) ) {
err("archive_write_set_compression_%s: %s", name, archive_error_string(*self_ref));
}
}
lua_pop(L, 1);
lua_getfield(L, 1, "options");
if ( ! lua_isnil(L, -1) &&
ARCHIVE_OK != archive_write_set_options(*self_ref, lua_tostring(L, -1)) )
{
err("archive_write_set_options: %s", archive_error_string(*self_ref));
}
lua_pop(L, 1);
if ( ARCHIVE_OK != archive_write_open(*self_ref, L, NULL, &ar_write_cb, NULL) ) {
err("archive_write_open: %s", archive_error_string(*self_ref));
}
return 1;
}
// hud_change(self, id, stat, data)
int ObjectRef::l_hud_change(lua_State *L)
{
ObjectRef *ref = checkobject(L, 1);
Player *player = getplayer(ref);
if (player == NULL)
return 0;
u32 id = lua_isnumber(L, 2) ? lua_tonumber(L, 2) : -1;
HudElement *e = player->getHud(id);
if (!e)
return 0;
HudElementStat stat = HUD_STAT_NUMBER;
if (lua_isstring(L, 3)) {
int statint;
std::string statstr = lua_tostring(L, 3);
stat = string_to_enum(es_HudElementStat, statint, statstr) ?
(HudElementStat)statint : HUD_STAT_NUMBER;
}
void *value = NULL;
switch (stat) {
case HUD_STAT_POS:
e->pos = read_v2f(L, 4);
value = &e->pos;
break;
case HUD_STAT_NAME:
e->name = luaL_checkstring(L, 4);
value = &e->name;
break;
case HUD_STAT_SCALE:
e->scale = read_v2f(L, 4);
value = &e->scale;
break;
case HUD_STAT_TEXT:
e->text = luaL_checkstring(L, 4);
value = &e->text;
break;
case HUD_STAT_NUMBER:
e->number = luaL_checknumber(L, 4);
value = &e->number;
break;
case HUD_STAT_ITEM:
e->item = luaL_checknumber(L, 4);
value = &e->item;
break;
case HUD_STAT_DIR:
e->dir = luaL_checknumber(L, 4);
value = &e->dir;
break;
case HUD_STAT_ALIGN:
e->align = read_v2f(L, 4);
value = &e->align;
break;
case HUD_STAT_OFFSET:
e->offset = read_v2f(L, 4);
value = &e->offset;
break;
case HUD_STAT_WORLD_POS:
e->world_pos = read_v3f(L, 4);
value = &e->world_pos;
break;
case HUD_STAT_SIZE:
e->size = read_v2s32(L, 4);
value = &e->size;
break;
}
getServer(L)->hudChange(player, id, stat, value);
lua_pushboolean(L, true);
return 1;
}
// Lua table full of data -> mobjinfo[]
static int lib_setMobjInfo(lua_State *L)
{
mobjinfo_t *info;
lua_remove(L, 1); // don't care about mobjinfo[] userdata.
info = &mobjinfo[luaL_checkinteger(L, 1)]; // get the mobjinfo to assign to.
luaL_checktype(L, 2, LUA_TTABLE); // check that we've been passed a table.
lua_remove(L, 1); // pop mobjtype num, don't need it any more.
lua_settop(L, 1); // cut the stack here. the only thing left now is the table of data we're assigning to the mobjinfo.
if (hud_running)
return luaL_error(L, "Do not alter mobjinfo in HUD rendering code!");
// clear the mobjinfo to start with, in case of missing table elements
memset(info,0,sizeof(mobjinfo_t));
info->doomednum = -1; // default to no editor value
info->spawnhealth = 1; // avoid 'dead' noclip behaviors
lua_pushnil(L);
while (lua_next(L, 1)) {
lua_Integer i = 0;
const char *str = NULL;
lua_Integer value;
if (lua_isnumber(L, 2))
i = lua_tointeger(L, 2);
else
str = luaL_checkstring(L, 2);
if (i == 1 || (str && fastcmp(str,"doomednum")))
info->doomednum = (INT32)luaL_checkinteger(L, 3);
else if (i == 2 || (str && fastcmp(str,"spawnstate"))) {
value = luaL_checkinteger(L, 3);
if (value < S_NULL || value >= NUMSTATES)
return luaL_error(L, "spawnstate number %d is invalid.", value);
info->spawnstate = (statenum_t)value;
} else if (i == 3 || (str && fastcmp(str,"spawnhealth")))
info->spawnhealth = (INT32)luaL_checkinteger(L, 3);
else if (i == 4 || (str && fastcmp(str,"seestate"))) {
value = luaL_checkinteger(L, 3);
if (value < S_NULL || value >= NUMSTATES)
return luaL_error(L, "seestate number %d is invalid.", value);
info->seestate = (statenum_t)value;
} else if (i == 5 || (str && fastcmp(str,"seesound"))) {
value = luaL_checkinteger(L, 3);
if (value < sfx_None || value >= NUMSFX)
return luaL_error(L, "seesound number %d is invalid.", value);
info->seesound = (sfxenum_t)value;
} else if (i == 6 || (str && fastcmp(str,"reactiontime")))
info->reactiontime = (INT32)luaL_checkinteger(L, 3);
else if (i == 7 || (str && fastcmp(str,"attacksound")))
info->attacksound = luaL_checkinteger(L, 3);
else if (i == 8 || (str && fastcmp(str,"painstate")))
info->painstate = luaL_checkinteger(L, 3);
else if (i == 9 || (str && fastcmp(str,"painchance")))
info->painchance = (INT32)luaL_checkinteger(L, 3);
else if (i == 10 || (str && fastcmp(str,"painsound")))
info->painsound = luaL_checkinteger(L, 3);
else if (i == 11 || (str && fastcmp(str,"meleestate")))
info->meleestate = luaL_checkinteger(L, 3);
else if (i == 12 || (str && fastcmp(str,"missilestate")))
info->missilestate = luaL_checkinteger(L, 3);
else if (i == 13 || (str && fastcmp(str,"deathstate")))
info->deathstate = luaL_checkinteger(L, 3);
else if (i == 14 || (str && fastcmp(str,"xdeathstate")))
info->xdeathstate = luaL_checkinteger(L, 3);
else if (i == 15 || (str && fastcmp(str,"deathsound")))
info->deathsound = luaL_checkinteger(L, 3);
else if (i == 16 || (str && fastcmp(str,"speed")))
info->speed = (fixed_t)luaL_checkinteger(L, 3);
else if (i == 17 || (str && fastcmp(str,"radius")))
info->radius = (fixed_t)luaL_checkinteger(L, 3);
else if (i == 18 || (str && fastcmp(str,"height")))
info->height = (fixed_t)luaL_checkinteger(L, 3);
else if (i == 19 || (str && fastcmp(str,"dispoffset")))
info->dispoffset = (INT32)luaL_checkinteger(L, 3);
else if (i == 20 || (str && fastcmp(str,"mass")))
info->mass = (INT32)luaL_checkinteger(L, 3);
else if (i == 21 || (str && fastcmp(str,"damage")))
info->damage = (INT32)luaL_checkinteger(L, 3);
else if (i == 22 || (str && fastcmp(str,"activesound")))
info->activesound = luaL_checkinteger(L, 3);
else if (i == 23 || (str && fastcmp(str,"flags")))
info->flags = (INT32)luaL_checkinteger(L, 3);
else if (i == 24 || (str && fastcmp(str,"raisestate"))) {
info->raisestate = luaL_checkinteger(L, 3);
}
lua_pop(L, 1);
}
return 0;
}
//------------------------------------------------------------------------------
inline void CheckVarFromLua(lua::NativeState hLua,lua::Var *t,int i)
{
int type = lua_type(hLua, i);
if ( type==LUA_TSTRING )
{
lua::Str var;
CheckVarFromLua(hLua,&var,i);
*t = var;
}
else if ( type==LUA_TBOOLEAN )
{
lua::Bool var;
CheckVarFromLua(hLua,&var,i);
*t = var;
}
else if ( type==LUA_TNIL )
{
*t = lua::Var();
}
else if ( type==LUA_TNONE )
{
lua::Log<<"error:No one know what type is it. That's new"<<lua::End;
}
else if ( type==LUA_TLIGHTUSERDATA )
{
lua::Ptr var;
CheckVarFromLua(hLua,&var,i);
*t = var;
}
else if ( type==LUA_TTABLE )
{
lua::Table table;
CheckVarFromLua(hLua,&table,i);
*t = table;
}
#ifndef _LUAPP_KEEP_LOCAL_LUA_VARIABLE_
else if ( type==LUA_TFUNCTION )
{
lua::Func var;
*t = var;
}
else if ( type==LUA_TTHREAD )
{
lua::Task var;
*t = var;
}
else if ( type==LUA_TUSERDATA )
{
lua::User var;
*t = var;
}
#endif
else if ( lua_isinteger(hLua, i) )
{
lua::Int var;
CheckVarFromLua(hLua,&var,i);
*t = var;
}
else if ( lua_isnumber(hLua, i) )
{
lua::Num var;
CheckVarFromLua(hLua,&var,i);
*t = var;
}
else
{
lua::Log<<"error:you get something luapp can't handle with"<<lua::End;
*t = lua::Var();
}
}
static handler_t
magnet_attract(server * srv, connection * con, plugin_data * p, buffer * name)
{
lua_State *L;
int lua_return_value = -1;
/*
* get the script-context
*/
L = script_cache_get_script(srv, con, p->cache, name);
if (lua_isstring(L, -1))
{
log_error_write(srv, __FILE__, __LINE__,
"sbss",
"loading script", name, "failed:", lua_tostring(L, -1));
lua_pop(L, 1);
assert(lua_gettop(L) == 0); /* only the function should be on the stack
*/
con->http_status = 500;
con->mode = DIRECT;
return HANDLER_FINISHED;
}
lua_pushstring(L, "lighty.srv");
lua_pushlightuserdata(L, srv);
lua_settable(L, LUA_REGISTRYINDEX); /* registery[<id>] = srv */
lua_pushstring(L, "lighty.con");
lua_pushlightuserdata(L, con);
lua_settable(L, LUA_REGISTRYINDEX); /* registery[<id>] = con */
lua_atpanic(L, magnet_atpanic);
/**
* we want to create empty environment for our script
*
* setmetatable({}, {__index = _G})
*
* if a function, symbol is not defined in our env, __index will lookup
* in the global env.
*
* all variables created in the script-env will be thrown
* away at the end of the script run.
*/
lua_newtable(L); /* my empty environment aka {} (sp += 1) */
/*
* we have to overwrite the print function
*/
lua_pushcfunction(L, magnet_print); /* (sp += 1) */
lua_setfield(L, -2, "print"); /* -1 is the env we want to set(sp -= 1) */
/**
* lighty.request[] has the HTTP-request headers
* lighty.content[] is a table of string/file
* lighty.header[] is a array to set response headers
*/
lua_newtable(L); /* lighty.* (sp += 1) */
lua_newtable(L); /* {} (sp += 1) */
lua_newtable(L); /* the meta-table for the request-table (sp +=
* 1) */
lua_pushcfunction(L, magnet_reqhdr_get); /* (sp += 1) */
lua_setfield(L, -2, "__index"); /* (sp -= 1) */
lua_setmetatable(L, -2); /* tie the metatable to request (sp -= 1) */
lua_setfield(L, -2, "request"); /* content = {} (sp -= 1) */
lua_newtable(L); /* {} (sp += 1) */
lua_newtable(L); /* the meta-table for the request-table (sp +=
* 1) */
lua_pushcfunction(L, magnet_env_get); /* (sp += 1) */
lua_setfield(L, -2, "__index"); /* (sp -= 1) */
lua_pushcfunction(L, magnet_env_set); /* (sp += 1) */
lua_setfield(L, -2, "__newindex"); /* (sp -= 1) */
lua_setmetatable(L, -2); /* tie the metatable to request (sp -= 1) */
lua_setfield(L, -2, "env"); /* content = {} (sp -= 1) */
lua_newtable(L); /* {} (sp += 1) */
lua_newtable(L); /* the meta-table for the request-table (sp +=
* 1) */
lua_pushcfunction(L, magnet_status_get); /* (sp += 1) */
lua_setfield(L, -2, "__index"); /* (sp -= 1) */
lua_pushcfunction(L, magnet_status_set); /* (sp += 1) */
lua_setfield(L, -2, "__newindex"); /* (sp -= 1) */
lua_setmetatable(L, -2); /* tie the metatable to request (sp -= 1) */
lua_setfield(L, -2, "status"); /* content = {} (sp -= 1) */
/*
* add empty 'content' and 'header' tables
*/
lua_newtable(L); /* {} (sp += 1) */
lua_setfield(L, -2, "content"); /* content = {} (sp -= 1) */
lua_newtable(L); /* {} (sp += 1) */
lua_setfield(L, -2, "header"); /* header = {} (sp -= 1) */
lua_pushinteger(L, MAGNET_RESTART_REQUEST);
lua_setfield(L, -2, "RESTART_REQUEST");
lua_pushcfunction(L, magnet_stat); /* (sp += 1) */
lua_setfield(L, -2, "stat"); /* -1 is the env we want to set (sp -= 1) */
lua_setfield(L, -2, "lighty"); /* lighty.* (sp -= 1) */
lua_newtable(L); /* the meta-table for the new env (sp += 1) */
lua_pushvalue(L, LUA_GLOBALSINDEX); /* (sp += 1) */
lua_setfield(L, -2, "__index"); /* { __index = _G } (sp -= 1) */
lua_setmetatable(L, -2); /* setmetatable({}, {__index = _G}) (sp -= 1) */
lua_setfenv(L, -2); /* on the stack should be a modified env (sp -=
* 1) */
if (lua_pcall(L, 0, 1, 0))
{
log_error_write(srv, __FILE__, __LINE__,
"ss", "lua_pcall():", lua_tostring(L, -1));
lua_pop(L, 1); /* remove the error-msg and the function copy
* from the stack */
assert(lua_gettop(L) == 1); /* only the function should be on the stack
*/
con->http_status = 500;
con->mode = DIRECT;
return HANDLER_FINISHED;
}
/*
* we should have the function-copy and the return value on the stack
*/
assert(lua_gettop(L) == 2);
if (lua_isnumber(L, -1))
{
/*
* if the ret-value is a number, take it
*/
lua_return_value = (int) lua_tonumber(L, -1);
}
lua_pop(L, 1); /* pop the ret-value */
magnet_copy_response_header(srv, con, p, L);
if (lua_return_value > 99)
{
con->http_status = lua_return_value;
con->file_finished = 1;
/*
* try { ...
*/
if (0 == setjmp(exceptionjmp))
{
magnet_attach_content(srv, con, p, L);
if (!chunkqueue_is_empty(con->write_queue))
{
con->mode = p->id;
}
} else
{
/*
* } catch () {
*/
con->http_status = 500;
con->mode = DIRECT;
}
assert(lua_gettop(L) == 1); /* only the function should be on the stack
*/
/*
* we are finished
*/
return HANDLER_FINISHED;
} else if (MAGNET_RESTART_REQUEST == lua_return_value)
{
assert(lua_gettop(L) == 1); /* only the function should be on the stack
*/
return HANDLER_COMEBACK;
} else
{
assert(lua_gettop(L) == 1); /* only the function should be on the stack
*/
return HANDLER_GO_ON;
}
}
/*
* Arguments: sd_udata, [count (number) | membuf_udata,
* from (sock_addr_udata), options (string) ...]
* Returns: [string | count (number) | false (EAGAIN)]
*/
static int
sock_recv (lua_State *L)
{
static const int o_flags[] = {
MSG_OOB, MSG_PEEK,
#ifndef _WIN32
MSG_WAITALL
#endif
};
static const char *const o_names[] = {
"oob", "peek",
#ifndef _WIN32
"waitall",
#endif
NULL
};
sd_t sd = (sd_t) lua_unboxinteger(L, 1, SD_TYPENAME);
size_t n = !lua_isnumber(L, 2) ? ~((size_t) 0)
: (size_t) lua_tointeger(L, 2);
struct sock_addr *from = !lua_isuserdata(L, 3) ? NULL
: checkudata(L, 3, SA_TYPENAME);
struct sockaddr *sap = NULL;
socklen_t *slp = NULL;
const size_t len = n; /* how much total to read */
size_t rlen; /* how much to read */
int nr; /* number of bytes actually read */
struct sys_buffer sb;
char buf[SYS_BUFSIZE];
unsigned int i, flags = 0;
sys_buffer_write_init(L, 2, &sb, buf, sizeof(buf));
for (i = lua_gettop(L); i > 3; --i) {
flags |= o_flags[luaL_checkoption(L, i, NULL, o_names)];
}
if (from) {
sap = &from->u.addr;
slp = &from->addrlen;
}
do {
rlen = (n <= sb.size) ? n : sb.size;
sys_vm_leave();
#ifndef _WIN32
do nr = recvfrom(sd, sb.ptr.w, rlen, flags, sap, slp);
while (nr == -1 && SYS_ERRNO == EINTR);
#else
nr = recvfrom(sd, sb.ptr.w, rlen, flags, sap, slp);
#endif
sys_vm_enter();
if (nr == -1) break;
n -= nr; /* still have to read `n' bytes */
} while ((n != 0L && nr == (int) rlen) /* until end of count or eof */
&& sys_buffer_write_next(L, &sb, buf, 0));
if (nr <= 0 && len == n) {
if (!nr || !SYS_EAGAIN(SYS_ERRNO)) goto err;
lua_pushboolean(L, 0);
} else {
if (!sys_buffer_write_done(L, &sb, buf, nr))
lua_pushinteger(L, len - n);
}
return 1;
err:
return sys_seterror(L, 0);
}
