LUALIB_API lua_State *luaL_newstate (void) {
lua_State *L = lua_newstate(l_alloc, NULL);
lua_setallocf(L, l_alloc, L); /* allocator need lua_State. */
if (L) lua_atpanic(L, &panic);
return L;
}
LUALIB_API lua_State *luaL_newstate (void) {
lua_State *L = lua_newstate(l_alloc, NULL);
if (L) lua_atpanic(L, &panic);
return L;
}
static int tek_lib_exec_run(lua_State *L)
{
struct LuaExecTask *lexec = tek_lib_exec_check(L);
struct TExecBase *TExecBase = lexec->exec;
struct LuaExecChild *ctx;
const char *fname = TNULL;
const char *chunk = TNULL;
const char *taskname = TNULL;
size_t extralen = 0;
struct THook hook;
TTAGITEM tags[2];
int nremove = 1;
TBOOL abort = TTRUE;
for (;;)
{
if (lua_istable(L, 1))
{
lua_getfield(L, 1, "abort");
if (lua_isboolean(L, -1))
abort = lua_toboolean(L, -1);
lua_pop(L, 1);
lua_getfield(L, 1, "taskname");
taskname = lua_tostring(L, -1);
nremove = 2;
lua_getfield(L, 1, "func");
if (!lua_isnoneornil(L, -1))
break;
lua_pop(L, 1);
lua_getfield(L, 1, "filename");
if (!lua_isnoneornil(L, -1))
break;
lua_pop(L, 1);
lua_getfield(L, 1, "chunk");
if (!lua_isnoneornil(L, -1))
{
chunk = luaL_checklstring(L, -1, &extralen);
break;
}
luaL_error(L, "required argument missing");
}
lua_pushvalue(L, 1);
break;
}
if (!chunk)
{
if (lua_type(L, -1) == LUA_TSTRING)
fname = luaL_checklstring(L, -1, &extralen);
else if (lua_isfunction(L, -1) && !lua_iscfunction(L, -1))
chunk = tek_lib_exec_dump(L, &extralen);
else
luaL_error(L, "not a Lua function, filename or table");
}
ctx = lua_newuserdata(L, sizeof(struct LuaExecChild) + extralen + 1);
memset(ctx, 0, sizeof *ctx);
ctx->exec = lexec->exec;
ctx->parent = lexec;
ctx->taskname = tek_lib_exec_taskname(ctx->atomname, taskname);
ctx->abort = abort;
if (fname)
{
ctx->fname = (char *) (ctx + 1);
strcpy(ctx->fname, (char *) fname);
}
else if (chunk)
{
memcpy(ctx + 1, chunk, extralen);
ctx->chunklen = extralen;
}
/* remove arguments under userdata */
while (nremove--)
lua_remove(L, -2);
ctx->numargs = lua_gettop(L) - 2;
/* push arg[0] on the stack, will be extraarg */
lua_getglobal(L, "arg");
if (lua_istable(L, -1))
{
lua_rawgeti(L, -1, 0);
lua_remove(L, -2);
}
if (lua_type(L, -1) != LUA_TSTRING)
{
lua_pop(L, 1);
lua_pushnil(L);
}
ctx->args = tek_lib_exec_getargs(L, TExecBase, 2, ctx->numargs++, 1);
lua_pop(L, 1);
ctx->L = lua_newstate(tek_lib_exec_allocf, TExecBase);
if (ctx->L == TNULL)
{
tek_lib_exec_freeargs(TExecBase, ctx->args, ctx->numargs);
luaL_error(L, "cannot create interpreter");
}
tags[0].tti_Tag = TTask_UserData;
tags[0].tti_Value = (TTAG) ctx;
tags[1].tti_Tag = TTAG_DONE;
TInitHook(&hook, tek_lib_exec_run_dispatch, ctx);
ctx->task = TCreateTask(&hook, tags);
if (ctx->task == TNULL)
{
tek_lib_exec_freectxargs(ctx);
lua_pop(L, 1);
lua_pushnil(L);
return 1;
}
lua_getfield(L, LUA_REGISTRYINDEX, TEK_LIB_TASK_CLASSNAME);
lua_setmetatable(L, -2);
lua_pushvalue(L, -1);
ctx->ref = luaL_ref(L, lua_upvalueindex(2));
if (ctx->abort)
tek_lib_exec_register_task_hook(L, TExecBase);
return 1;
}
lua_State* clua_newstate(void* goallocf)
{
return lua_newstate(&allocwrapper,goallocf);
}
LUALIB_API lua_State *luaL_newstate(void)
{
lua_State *L = lua_newstate(mem_alloc, NULL);
if (L) G(L)->panic = panic;
return L;
}
}
efree(lua_obj);
}
/* }}} */
/** {{{ static zend_object_value php_lua_create_object(zend_class_entry *ce TSRMLS_DC)
*
* the create object handler for lua
*/
static zend_object_value php_lua_create_object(zend_class_entry *ce TSRMLS_DC) {
zend_object_value obj = {0};
php_lua_object *lua_obj = NULL;
lua_State *L = NULL;
L = lua_newstate(php_lua_alloc_function, NULL);
lua_atpanic(L, php_lua_atpanic);
lua_obj = emalloc(sizeof(php_lua_object));
if (!lua_obj) {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "alloc memory for lua object failed");
}
lua_obj->L = L;
zend_object_std_init(&(lua_obj->obj), ce TSRMLS_CC);
#if (PHP_MAJOR_VERSION == 5) && (PHP_MINOR_VERSION < 4)
zend_hash_copy(lua_obj->obj.properties, &ce->default_properties,
#if (PHP_MINOR_VERSION < 4)
void LSLuaState::open()
{
assert(!L);
L = lua_newstate(lsLuaAlloc, NULL);
//L = lua_open();
toLuaState.insert(L, this);
luaopen_base(L);
luaopen_table(L);
luaopen_string(L);
luaopen_math(L);
luaL_openlibs(L);
// TODO: turn this back on when it doesn't fail on the testWhile unit test
// update luajit and test again
luaJIT_setmode(L, 0, LUAJIT_MODE_ENGINE | LUAJIT_MODE_OFF);
// open the lua debug library
luaopen_debug(L);
// open socket library
luaopen_socket_core(L);
lua_newtable(L);
lua_rawseti(L, LUA_GLOBALSINDEX, LSINDEXCLASSES);
lua_newtable(L);
lua_setglobal(L, "__ls_nativeclasses");
lua_pushcfunction(L, traceback);
lua_setglobal(L, "__ls_traceback");
_tracemessage[0] = 0;
// entry -> version
lua_newtable(L);
lua_rawseti(L, LUA_GLOBALSINDEX, LSINDEXMANAGEDVERSION);
// entry -> native user data
lua_newtable(L);
lua_rawseti(L, LUA_GLOBALSINDEX, LSINDEXMANAGEDUSERDATA);
// native user data -> script instance
lua_newtable(L);
lua_rawseti(L, LUA_GLOBALSINDEX, LSINDEXMANAGEDNATIVESCRIPT);
// native delegate table
lua_newtable(L);
lua_rawseti(L, LUA_GLOBALSINDEX, LSINDEXNATIVEDELEGATES);
// interned field name lookup
lua_newtable(L);
lua_rawseti(L, LUA_GLOBALSINDEX, LSINDEXMEMBERINFONAME);
// typeid -> type*
lua_newtable(L);
lua_rawseti(L, LUA_GLOBALSINDEX, LSASSEMBLYLOOKUP);
// lua/luacfunction -> MethodBase* lookups
lua_newtable(L);
// weak key metatable
lua_newtable(L);
lua_pushstring(L, "k");
lua_setfield(L, -2, "__mode");
lua_setmetatable(L, -2);
lua_rawseti(L, LUA_GLOBALSINDEX, LSINDEXMETHODLOOKUP);
lsr_instanceregister(L);
NativeInterface::registerNativeTypes(L);
}
lua_State * CreateLuaState(void *pOpaque) {
lua_State *pResult = lua_newstate(_lua_alloc, pOpaque);
luaL_openlibs(pResult);
return pResult;
}
int lua_sandbox_init(lua_sandbox* lsb, const char* data_file)
{
if (lsb == NULL || lsb->m_lua != NULL) {
return 0;
}
if (lsb->m_lua_file == NULL) {
snprintf(lsb->m_error_message, ERROR_SIZE, "no Lua script provided");
sandbox_terminate(lsb);
return 1;
}
lsb->m_lua = lua_newstate(memory_manager, lsb);
if (lsb->m_lua == NULL) {
snprintf(lsb->m_error_message, ERROR_SIZE, "out of memory");
sandbox_terminate(lsb);
return 2;
}
load_library(lsb->m_lua, "", luaopen_base, disable_base_functions);
lua_pop(lsb->m_lua, 1);
load_library(lsb->m_lua, LUA_MATHLIBNAME, luaopen_math, disable_none);
lua_pop(lsb->m_lua, 1);
load_library(lsb->m_lua, LUA_OSLIBNAME, luaopen_os, disable_os_functions);
lua_pop(lsb->m_lua, 1);
load_library(lsb->m_lua, LUA_STRLIBNAME, luaopen_string, disable_none);
lua_pop(lsb->m_lua, 1);
load_library(lsb->m_lua, LUA_TABLIBNAME, luaopen_table, disable_none);
lua_pop(lsb->m_lua, 1);
load_library(lsb->m_lua, heka_circular_buffer_table,
luaopen_circular_buffer, disable_none);
lua_pop(lsb->m_lua, 1);
lua_pushcfunction(lsb->m_lua, &require_library);
lua_setglobal(lsb->m_lua, "require");
lua_pushlightuserdata(lsb->m_lua, (void*)lsb);
lua_pushcclosure(lsb->m_lua, &read_config, 1);
lua_setglobal(lsb->m_lua, "read_config");
lua_pushlightuserdata(lsb->m_lua, (void*)lsb);
lua_pushcclosure(lsb->m_lua, &read_message, 1);
lua_setglobal(lsb->m_lua, "read_message");
lua_pushlightuserdata(lsb->m_lua, (void*)lsb);
lua_pushcclosure(lsb->m_lua, &output, 1);
lua_setglobal(lsb->m_lua, "output");
lua_pushlightuserdata(lsb->m_lua, (void*)lsb);
lua_pushcclosure(lsb->m_lua, &inject_message, 1);
lua_setglobal(lsb->m_lua, "inject_message");
lua_sethook(lsb->m_lua, instruction_manager, LUA_MASKCOUNT,
lsb->m_usage[USAGE_TYPE_INSTRUCTION][USAGE_STAT_LIMIT]);
if (luaL_dofile(lsb->m_lua, lsb->m_lua_file) != 0) {
snprintf(lsb->m_error_message, ERROR_SIZE, "%s",
lua_tostring(lsb->m_lua, -1));
sandbox_terminate(lsb);
return 3;
} else {
lua_gc(lsb->m_lua, LUA_GCCOLLECT, 0);
lsb->m_usage[USAGE_TYPE_INSTRUCTION][USAGE_STAT_CURRENT] =
instruction_usage(lsb);
if (lsb->m_usage[USAGE_TYPE_INSTRUCTION][USAGE_STAT_CURRENT]
> lsb->m_usage[USAGE_TYPE_INSTRUCTION][USAGE_STAT_MAXIMUM]) {
lsb->m_usage[USAGE_TYPE_INSTRUCTION][USAGE_STAT_MAXIMUM] =
lsb->m_usage[USAGE_TYPE_INSTRUCTION][USAGE_STAT_CURRENT];
}
lsb->m_status = STATUS_RUNNING;
if (data_file != NULL && strlen(data_file) > 0) {
return restore_global_data(lsb, data_file);
}
}
return 0;
}
lua_State *lua_loadscript(char *file) {
char fullpath[LUA_PATHLEN];
int top;
lua_State *l;
lua_list *n;
char buf[1024];
void *args[2];
if(!cpath || !suffix)
return NULL;
strlcpy(buf, file, sizeof(buf));
delchars(buf, "./\\;");
if(lua_scriptloaded(buf))
return NULL;
l = lua_newstate(lua_nsmalloc, NULL);
if(!l)
return NULL;
n = (lua_list *)luamalloc(sizeof(lua_list));;
if(!n) {
Error("lua", ERR_ERROR, "Error allocing list for %s.", buf);
return NULL;
}
n->name = getsstring(buf, LUA_PATHLEN);
if(!n->name) {
Error("lua", ERR_ERROR, "Error allocing name item for %s.", buf);
luafree(n);
return NULL;
}
n->calls = 0;
timerclear(&n->ru_utime);
timerclear(&n->ru_stime);
lua_loadlibs(l);
lua_registerdebug(l);
lua_registercommands(l);
lua_registerlocalcommands(l);
lua_registerdbcommands(l);
lua_registersocketcommands(l);
lua_registercryptocommands(l);
lua_registerschedulercommands(l);
args[0] = file;
args[1] = l;
triggerhook(HOOK_LUA_LOADSCRIPT, args);
#ifdef LUA_USEJIT
lua_require(l, "lib/jit");
#endif
lua_require(l, "lib/bootstrap");
snprintf(fullpath, sizeof(fullpath), "%s/%s%s", cpath->content, file, suffix->content);
if(luaL_loadfile(l, fullpath)) {
Error("lua", ERR_ERROR, "Error loading %s.", file);
lua_close(l);
freesstring(n->name);
luafree(n);
return NULL;
}
n->l = l;
n->next = NULL;
n->prev = lua_tail;
n->nicks = NULL;
n->sockets = NULL;
n->schedulers = NULL;
if(!lua_head) {
lua_head = n;
} else {
lua_tail->next = n;
}
lua_tail = n;
top = lua_gettop(l);
if(lua_pcall(l, 0, 0, 0)) {
Error("lua", ERR_ERROR, "Error pcalling: %s.", file);
lua_close(l);
freesstring(n->name);
if(lua_head == n)
lua_head = NULL;
lua_tail = n->prev;
if(lua_tail)
lua_tail->next = NULL;
luafree(n);
return NULL;
}
lua_settop(l, top);
Error("lua", ERR_INFO, "Loaded %s.", file);
lua_onload(l);
return l;
}
int main(int argc, char** argv)
{
td_bin_allocator bin_alloc;
const char *homedir;
char exepath[512];
int res, rc, i;
lua_State* L;
td_init_portable();
if (0 != td_get_executable_path(exepath, sizeof exepath)) {
fprintf(stderr, "couldn't find path to tundra executable");
return 1;
}
if (NULL == (homedir = td_init_homedir())) {
fprintf(stderr, "couldn't find tundra home dir");
return 1;
}
td_bin_allocator_init(&bin_alloc);
L = lua_newstate(td_lua_alloc, &bin_alloc);
if (!L)
exit(1);
lua_atpanic(L, on_lua_panic);
luaL_openlibs(L);
tundra_open(L);
#if defined(TD_STANDALONE)
/* this is equivalent to table.insert(package.loaders, 1, td_load_embedded_file) */
/* get the function */
lua_getglobal(L, "table");
lua_getfield(L, -1, "insert");
lua_remove(L, -2);
assert(!lua_isnil(L, -1));
/* arg1: the package.loaders table */
lua_getglobal(L, "package");
lua_getfield(L, -1, "loaders");
lua_remove(L, -2);
assert(!lua_isnil(L, -1));
lua_pushinteger(L, 1); /* arg 2 */
lua_pushcfunction(L, td_load_embedded_file); /* arg 3 */
lua_call(L, 3, 0);
#endif
/* setup package.path */
{
char ppath[1024];
snprintf(ppath, sizeof(ppath),
"%s" TD_PATHSEP_STR "scripts" TD_PATHSEP_STR "?.lua;"
"%s" TD_PATHSEP_STR "lua" TD_PATHSEP_STR "etc" TD_PATHSEP_STR "?.lua", homedir, homedir);
lua_getglobal(L, "package");
assert(LUA_TTABLE == lua_type(L, -1));
lua_pushstring(L, ppath);
lua_setfield(L, -2, "path");
}
/* push our error handler on the stack now (before the chunk to run) */
lua_pushcclosure(L, get_traceback, 0);
switch (luaL_loadbuffer(L, boot_snippet, sizeof(boot_snippet)-1, "boot_snippet"))
{
case LUA_ERRMEM:
td_croak("out of memory");
return 1;
case LUA_ERRSYNTAX:
td_croak("syntax error\n%s\n", lua_tostring(L, -1));
return 1;
}
lua_pushstring(L, homedir);
lua_newtable(L);
lua_pushstring(L, exepath);
lua_rawseti(L, -2, 1);
for (i=1; i<argc; ++i)
{
lua_pushstring(L, argv[i]);
lua_rawseti(L, -2, i + 1);
}
{
double t2;
script_call_t1 = td_timestamp();
res = lua_pcall(L, /*narg:*/2, /*nres:*/0, /*errorfunc:*/ -4);
t2 = td_timestamp();
if (global_tundra_stats)
printf("total time spent in tundra: %.4fs\n", t2 - script_call_t1);
}
if (res == 0)
{
rc = global_tundra_exit_code;
}
else
{
fprintf(stderr, "%s\n", lua_tostring(L, -1));
rc = 1;
}
lua_close(L);
td_bin_allocator_cleanup(&bin_alloc);
return rc;
}
