1 files changed, 372 insertions, 0 deletions
diff --git a/advtrains_luaautomation/environment.lua b/advtrains_luaautomation/environment.lua
new file mode 100644
index 0000000..63aa68d
--- /dev/null
+++ b/advtrains_luaautomation/environment.lua
@@ -0,0 +1,372 @@
+-------------
+-- 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.subscribers=data.subscribers 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, subscribers=self.subscribers}
+	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"
+}
+
+local function safe_date(f, t)
+	if not f then
+		-- fall back to old behavior
+		return(os.date("*t",os.time()))
+	else
+		--pass parameters
+		return os.date(f,t)
+	end
+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 static_env = {
+	--core LUA functions
+	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 = advtrains.getstate,
+	setstate = advtrains.setstate,
+	is_passive = advtrains.is_passive,
+	--interrupts are handled per node, position unknown. (same goes for digilines)
+	--however external interrupts can be set here.
+	interrupt_pos = function(parpos, imesg)
+		local pos=atlatc.pcnaming.resolve_pos(parpos)
+		atlatc.interrupt.add(0, pos, {type="ext_int", ext_int=true, message=imesg})
+	end,
+	-- sends an atc command to train regardless of where it is in the world
+	atc_send_to_train = function(train_id, command)
+		assertt(command, "string")
+		local train = advtrains.trains[train_id]
+		if train then
+			advtrains.atc.train_set_command(train, command, true)
+			return true
+		else
+			return false
+		end
+	end,
+}
+
+-- If interlocking is present, enable route setting functions
+if advtrains.interlocking then
+	local function gen_checks(signal, route_name, noroutesearch)
+		assertt(route_name, "string")
+		local pos = atlatc.pcnaming.resolve_pos(signal)
+		local sigd = advtrains.interlocking.db.get_sigd_for_signal(pos)
+		if not sigd then
+			error("There's no signal at "..minetest.pos_to_string(pos))
+		end
+		local tcbs = advtrains.interlocking.db.get_tcbs(sigd)
+		if not tcbs then
+			error("Inconsistent configuration, no tcbs for signal at "..minetest.pos_to_string(pos))
+		end
+		
+		local routeid, route
+		if not noroutesearch then
+			for routeidt, routet in ipairs(tcbs.routes) do
+				if routet.name == route_name then
+					routeid = routeidt
+					route = routet
+					break
+				end
+			end
+			if not route then
+				error("No route called "..route_name.." at "..minetest.pos_to_string(pos))
+			end
+		end
+		return pos, sigd, tcbs, routeid, route
+	end
+
+
+	static_env.can_set_route = function(signal, route_name)
+		local pos, sigd, tcbs, routeid, route = gen_checks(signal, route_name)
+		-- if route is already set on signal, return whether it's committed
+		if tcbs.routeset == routeid then
+			return tcbs.route_committed
+		end
+		-- actually try setting route (parameter 'true' designates try-run
+		local ok = advtrains.interlocking.route.set_route(sigd, route, true)
+		return ok
+	end
+	static_env.set_route = function(signal, route_name)
+		local pos, sigd, tcbs, routeid, route = gen_checks(signal, route_name)
+		return advtrains.interlocking.route.update_route(sigd, tcbs, routeid)
+	end
+	static_env.cancel_route = function(signal)
+		local pos, sigd, tcbs, routeid, route = gen_checks(signal, "", true)
+		return advtrains.interlocking.route.update_route(sigd, tcbs, nil, true)
+	end
+	static_env.get_aspect = function(signal)
+		local pos = atlatc.pcnaming.resolve_pos(signal)
+		return advtrains.interlocking.signal_get_aspect(pos)
+	end
+	static_env.set_aspect = function(signal, asp)
+		local pos = atlatc.pcnaming.resolve_pos(signal)
+		return advtrains.interlocking.signal_set_aspect(pos)
+	end
+end
+
+-- Lines-specific:
+if advtrains.lines then
+	local atlrwt = advtrains.lines.rwt
+	static_env.rwt = {
+		now = atlrwt.now,
+		new = atlrwt.new,
+		copy = atlrwt.copy,
+		to_table = atlrwt.to_table,
+		to_secs = atlrwt.to_secs,
+		to_string = atlrwt.to_string,
+		add = atlrwt.add,
+		diff = atlrwt.diff,
+		sub = atlrwt.sub,
+		adj_diff = atlrwt.adj_diff,
+		adjust_cycle = atlrwt.adjust_cycle,
+		adjust = atlrwt.adjust,
+		to_string = atlrwt.to_string,
+		get_time_until = atlrwt.get_time_until,
+		next_rpt = atlrwt.next_rpt,
+		last_rpt = atlrwt.last_rpt,
+		time_from_last_rpt = atlrwt.time_from_last_rpt,
+		time_to_next_rpt = atlrwt.time_to_next_rpt,
+	}
+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)
+	-- create us a print function specific for this environment
+	if not self.safe_print_func then
+		local myenv = self
+		self.safe_print_func = function(...)
+			myenv:log("info", ...)
+		end
+	end
+	
+	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]
+			elseif i=="print" then
+				return self.safe_print_func
+			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
+			self:log("error", "Executing InitCode for '"..self.name.."' failed:"..err)
+			self.init_err=err
+			if old_fdata then
+				self.fdata=old_fdata
+				self:log("warning", "The 'F' table has been restored to the previous state.")
+			end
+		end
+	end
+end
+
+-- log to environment subscribers. severity can be "error", "warning" or "info" (used by internal print)
+function env_proto:log(severity, ...)
+	local text=advtrains.print_concat_table({"[atlatc "..self.name.." "..severity.."]", ...})
+	minetest.log("action", text)
+	for _, pname in ipairs(self.subscribers) do
+		minetest.chat_send_player(pname, text)
+	end
+end
+
+-- env.subscribers table may be directly altered by callers.
+
+
+--- class interface
+
+function atlatc.env_new(name)
+	local newenv={
+		name=name,
+		init_code="",
+		sdata={},
+		subscribers={},
+	}
+	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
+
+
+
+