From d65c4916ceaeed6eec5fe3f344d4e71b3c96a80b Mon Sep 17 00:00:00 2001 From: rubenwardy Date: Wed, 20 Sep 2017 17:05:04 +0100 Subject: Remove zip release files, move mod to root, exclude assets from Makefile (#92) --- advtrains/advtrains_luaautomation/environment.lua | 275 ---------------------- 1 file changed, 275 deletions(-) delete mode 100644 advtrains/advtrains_luaautomation/environment.lua (limited to 'advtrains/advtrains_luaautomation/environment.lua') diff --git a/advtrains/advtrains_luaautomation/environment.lua b/advtrains/advtrains_luaautomation/environment.lua deleted file mode 100644 index 0b25e87..0000000 --- a/advtrains/advtrains_luaautomation/environment.lua +++ /dev/null @@ -1,275 +0,0 @@ -------------- --- lua sandboxed environment - --- function to cross out functions and userdata. --- modified from dump() -function atlatc.remove_invalid_data(o, nested) - if o==nil then return nil end - local valid_dt={["nil"]=true, boolean=true, number=true, string=true} - if type(o) ~= "table" then - --check valid data type - if not valid_dt[type(o)] then - return nil - end - return o - end - -- Contains table -> true/nil of currently nested tables - nested = nested or {} - if nested[o] then - return nil - end - nested[o] = true - for k, v in pairs(o) do - v = atlatc.remove_invalid_data(v, nested) - end - nested[o] = nil - return o -end - - -local env_proto={ - load = function(self, envname, data) - self.name=envname - self.sdata=data.sdata and atlatc.remove_invalid_data(data.sdata) or {} - self.fdata={} - self.init_code=data.init_code or "" - self.step_code=data.step_code or "" - end, - save = function(self) - -- throw any function values out of the sdata table - self.sdata = atlatc.remove_invalid_data(self.sdata) - return {sdata = self.sdata, init_code=self.init_code, step_code=self.step_code} - end, -} - ---Environment ---Code modified from mesecons_luacontroller (credit goes to Jeija and mesecons contributors) - -local safe_globals = { - "assert", "error", "ipairs", "next", "pairs", "select", - "tonumber", "tostring", "type", "unpack", "_VERSION" -} - ---print is actually minetest.chat_send_all() ---using advtrains.print_concat_table because it's cool -local function safe_print(t, ...) - local str=advtrains.print_concat_table({t, ...}) - minetest.log("action", "[atlatc] "..str) - minetest.chat_send_all(str) -end - -local function safe_date() - return(os.date("*t",os.time())) -end - --- string.rep(str, n) with a high value for n can be used to DoS --- the server. Therefore, limit max. length of generated string. -local function safe_string_rep(str, n) - if #str * n > 2000 then - debug.sethook() -- Clear hook - error("string.rep: string length overflow", 2) - end - - return string.rep(str, n) -end - --- string.find with a pattern can be used to DoS the server. --- Therefore, limit string.find to patternless matching. --- Note: Disabled security since there are enough security leaks and this would be unneccessary anyway to DoS the server -local function safe_string_find(...) - --if (select(4, ...)) ~= true then - -- debug.sethook() -- Clear hook - -- error("string.find: 'plain' (fourth parameter) must always be true for security reasons.") - --end - - return string.find(...) -end - -local mp=minetest.get_modpath("advtrains_luaautomation") -local p_api_getstate, p_api_setstate = dofile(mp.."/passive.lua") - -local static_env = { - --core LUA functions - print = safe_print, - string = { - byte = string.byte, - char = string.char, - format = string.format, - len = string.len, - lower = string.lower, - upper = string.upper, - rep = safe_string_rep, - reverse = string.reverse, - sub = string.sub, - find = safe_string_find, - }, - math = { - abs = math.abs, - acos = math.acos, - asin = math.asin, - atan = math.atan, - atan2 = math.atan2, - ceil = math.ceil, - cos = math.cos, - cosh = math.cosh, - deg = math.deg, - exp = math.exp, - floor = math.floor, - fmod = math.fmod, - frexp = math.frexp, - huge = math.huge, - ldexp = math.ldexp, - log = math.log, - log10 = math.log10, - max = math.max, - min = math.min, - modf = math.modf, - pi = math.pi, - pow = math.pow, - rad = math.rad, - random = math.random, - sin = math.sin, - sinh = math.sinh, - sqrt = math.sqrt, - tan = math.tan, - tanh = math.tanh, - }, - table = { - concat = table.concat, - insert = table.insert, - maxn = table.maxn, - remove = table.remove, - sort = table.sort, - }, - os = { - clock = os.clock, - difftime = os.difftime, - time = os.time, - date = safe_date, - }, - POS = function(x,y,z) return {x=x, y=y, z=z} end, - getstate = p_api_getstate, - setstate = p_api_setstate, - --interrupts are handled per node, position unknown. - --however external interrupts can be set here. - interrupt_pos = function(pos, imesg) - if not type(pos)=="table" or not pos.x or not pos.y or not pos.z then - debug.sethook() - error("Invalid position supplied to interrupt_pos") - end - atlatc.interrupt.add(0, pos, {type="ext_int", ext_int=true, message=imesg}) - end, -} - -for _, name in pairs(safe_globals) do - static_env[name] = _G[name] -end - - ---The environment all code calls get is a table that has set static_env as metatable. ---In general, every variable is local to a single code chunk, but kept persistent over code re-runs. Data is also saved, but functions and userdata and circular references are removed ---Init code and step code's environments are not saved --- S - Table that can contain any save data global to the environment. Will be saved statically. Can't contain functions or userdata or circular references. --- F - Table global to the environment, can contain volatile data that is deleted when server quits. --- The init code should populate this table with functions and other definitions. - -local proxy_env={} ---proxy_env gets a new metatable in every run, but is the shared environment of all functions ever defined. - --- returns: true, fenv if successful; nil, error if error -function env_proto:execute_code(localenv, code, evtdata, customfct) - local metatbl ={ - __index = function(t, i) - if i=="S" then - return self.sdata - elseif i=="F" then - return self.fdata - elseif i=="event" then - return evtdata - elseif customfct and customfct[i] then - return customfct[i] - elseif localenv and localenv[i] then - return localenv[i] - end - return static_env[i] - end, - __newindex = function(t, i, v) - if i=="S" or i=="F" or i=="event" or (customfct and customfct[i]) or static_env[i] then - debug.sethook() - error("Trying to overwrite environment contents") - end - localenv[i]=v - end, - } - setmetatable(proxy_env, metatbl) - local fun, err=loadstring(code) - if not fun then - return false, err - end - - setfenv(fun, proxy_env) - local succ, data = pcall(fun) - if succ then - data=localenv - end - return succ, data -end - -function env_proto:run_initcode() - if self.init_code and self.init_code~="" then - local old_fdata=self.fdata - self.fdata = {} - atprint("[atlatc]Running initialization code for environment '"..self.name.."'") - local succ, err = self:execute_code({}, self.init_code, {type="init", init=true}) - if not succ then - atwarn("[atlatc]Executing InitCode for '"..self.name.."' failed:"..err) - self.init_err=err - if old_fdata then - self.fdata=old_fdata - atwarn("[atlatc]The 'F' table has been restored to the previous state.") - end - end - end -end -function env_proto:run_stepcode() - if self.step_code and self.step_code~="" then - local succ, err = self:execute_code({}, self.step_code, nil, {}) - if not succ then - --TODO - end - end -end - ---- class interface - -function atlatc.env_new(name) - local newenv={ - name=name, - init_code="", - step_code="", - sdata={} - } - setmetatable(newenv, {__index=env_proto}) - return newenv -end -function atlatc.env_load(name, data) - local newenv={} - setmetatable(newenv, {__index=env_proto}) - newenv:load(name, data) - return newenv -end - -function atlatc.run_initcode() - for envname, env in pairs(atlatc.envs) do - env:run_initcode() - end -end -function atlatc.run_stepcode() - for envname, env in pairs(atlatc.envs) do - env:run_stepcode() - end -end - - - - -- cgit v1.2.3