mirror of
https://gerrit.wikimedia.org/r/mediawiki/extensions/Scribunto
synced 2024-12-04 20:58:13 +00:00
1fad4da137
Change-Id: Ida2c9cac348fe31ecf8d8c0a352e899bcbff1ebf
711 lines
19 KiB
Lua
711 lines
19 KiB
Lua
MWServer = {}
|
|
|
|
--- Create a new MWServer object
|
|
function MWServer:new( interpreterId, intSize )
|
|
interpreterId = tonumber( interpreterId )
|
|
if not interpreterId then
|
|
error( "bad argument #1 to 'MWServer:new' (must be a number or convertible to a number)", 2 )
|
|
end
|
|
intSize = tonumber( intSize )
|
|
if intSize ~= 4 and intSize ~= 8 then
|
|
error( "bad argument #2 to 'MWServer:new' (must be 4 or 8)", 2 )
|
|
end
|
|
|
|
obj = {
|
|
interpreterId = interpreterId,
|
|
nextChunkId = 1,
|
|
chunks = {},
|
|
xchunks = {},
|
|
protectedFunctions = {},
|
|
protectedEnvironments = {},
|
|
baseEnv = {}
|
|
}
|
|
if intSize == 4 then
|
|
obj.intMax = 2147483648
|
|
obj.intKeyMax = 2147483648
|
|
else
|
|
-- Lua can't represent most larger integers, so they may as well be sent to PHP as floats.
|
|
obj.intMax = 9007199254740992
|
|
obj.intKeyMax = 9223372036854775807
|
|
end
|
|
setmetatable( obj, self )
|
|
self.__index = self
|
|
|
|
obj:init()
|
|
|
|
return obj
|
|
end
|
|
|
|
--- Initialise a new MWServer object
|
|
function MWServer:init()
|
|
self.baseEnv = self:newEnvironment()
|
|
for funcName, func in pairs( self ) do
|
|
if type(func) == 'function' then
|
|
self.protectedFunctions[func] = true
|
|
end
|
|
end
|
|
self.protectedEnvironments[_G] = true
|
|
end
|
|
|
|
--- Serve requests until exit is requested
|
|
function MWServer:execute()
|
|
self:dispatch( nil )
|
|
self:debug( 'MWServer:execute: returning' )
|
|
end
|
|
|
|
-- Convert a multiple-return-value or a ... into a count and a table
|
|
function MWServer:listToCountAndTable( ... )
|
|
return select( '#', ... ), { ... }
|
|
end
|
|
|
|
--- Call a PHP function
|
|
-- Raise an error if the PHP handler requests it. May return any number
|
|
-- of values.
|
|
--
|
|
-- @param id The function ID, specified by a registerLibrary message
|
|
-- @param nargs Count of function arguments
|
|
-- @param args The function arguments
|
|
-- @return The return values from the PHP function
|
|
function MWServer:call( id, nargs, args )
|
|
local result = self:dispatch( {
|
|
op = 'call',
|
|
id = id,
|
|
nargs = nargs,
|
|
args = args
|
|
} )
|
|
if result.op == 'return' then
|
|
return unpack( result.values, 1, result.nvalues )
|
|
elseif result.op == 'error' then
|
|
-- Raise an error in the actual user code that called the function
|
|
-- The level is 3 since our immediate caller is a closure
|
|
error( result.value, 3 )
|
|
else
|
|
self:internalError( 'MWServer:call: unexpected result op' )
|
|
end
|
|
end
|
|
|
|
--- Handle a "call" message from PHP. Call the relevant function.
|
|
--
|
|
-- @param message The message from PHP
|
|
-- @return A response message to send back to PHP
|
|
function MWServer:handleCall( message )
|
|
if not self.chunks[message.id] then
|
|
return {
|
|
op = 'error',
|
|
value = 'function id ' .. message.id .. ' does not exist'
|
|
}
|
|
end
|
|
|
|
local n, result = self:listToCountAndTable( xpcall(
|
|
function ()
|
|
return self.chunks[message.id]( unpack( message.args, 1, message.nargs ) )
|
|
end,
|
|
function ( err )
|
|
return MWServer:attachTrace( err )
|
|
end
|
|
) )
|
|
|
|
if result[1] then
|
|
-- table.remove( result, 1 ) renumbers from 2 to #result. But #result
|
|
-- is not necessarily "right" if result contains nils.
|
|
result = { unpack( result, 2, n ) }
|
|
return {
|
|
op = 'return',
|
|
nvalues = n - 1,
|
|
values = result
|
|
}
|
|
else
|
|
if result[2].value and result[2].trace then
|
|
return {
|
|
op = 'error',
|
|
value = result[2].value,
|
|
trace = result[2].trace,
|
|
}
|
|
else
|
|
return {
|
|
op = 'error',
|
|
value = result[2]
|
|
}
|
|
end
|
|
end
|
|
end
|
|
|
|
--- The xpcall() error handler for handleCall(). Modifies the error object
|
|
-- to include a structured backtrace
|
|
--
|
|
-- @param err The error object
|
|
-- @return The new error object
|
|
function MWServer:attachTrace( err )
|
|
return {
|
|
value = err,
|
|
trace = self:getStructuredTrace( 2 )
|
|
}
|
|
end
|
|
|
|
--- Handle a "loadString" message from PHP.
|
|
-- Load the function and return a chunk ID.
|
|
--
|
|
-- @param message The message from PHP
|
|
-- @return A response message to send back to PHP
|
|
function MWServer:handleLoadString( message )
|
|
if string.find( message.text, '\27Lua', 1, true ) then
|
|
return {
|
|
op = 'error',
|
|
value = 'cannot load code with a Lua binary chunk marker escape sequence in it'
|
|
}
|
|
end
|
|
local chunk, errorMsg = loadstring( message.text, message.chunkName )
|
|
if chunk then
|
|
setfenv( chunk, self.baseEnv )
|
|
local id = self:addChunk( chunk )
|
|
return {
|
|
op = 'return',
|
|
nvalues = 1,
|
|
values = {id}
|
|
}
|
|
else
|
|
return {
|
|
op = 'error',
|
|
value = errorMsg
|
|
}
|
|
end
|
|
end
|
|
|
|
--- Add a function value to the list of tracked chunks and return its associated ID.
|
|
-- Adding a chunk allows it to be referred to in messages from PHP.
|
|
--
|
|
-- @param chunk The function value
|
|
-- @return The chunk ID
|
|
function MWServer:addChunk( chunk )
|
|
local id = self.nextChunkId
|
|
self.nextChunkId = id + 1
|
|
self.chunks[id] = chunk
|
|
self.xchunks[chunk] = id
|
|
return id
|
|
end
|
|
|
|
--- Handle a "cleanupChunks" message from PHP.
|
|
-- Remove any chunks no longer referenced by PHP code.
|
|
--
|
|
-- @param message The message from PHP
|
|
-- @return A response message to send back to PHP
|
|
function MWServer:handleCleanupChunks( message )
|
|
for id, chunk in pairs( self.chunks ) do
|
|
if not message.ids[id] then
|
|
self.chunks[id] = nil
|
|
self.xchunks[chunk] = nil
|
|
end
|
|
end
|
|
|
|
return {
|
|
op = 'return',
|
|
nvalues = 0,
|
|
values = {}
|
|
}
|
|
end
|
|
|
|
--- Handle a "registerLibrary" message from PHP.
|
|
-- Add the relevant functions to the base environment.
|
|
--
|
|
-- @param message The message from PHP
|
|
-- @return The response message
|
|
function MWServer:handleRegisterLibrary( message )
|
|
local startPos = 1
|
|
local component
|
|
if not self.baseEnv[message.name] then
|
|
self.baseEnv[message.name] = {}
|
|
end
|
|
local t = self.baseEnv[message.name]
|
|
|
|
for name, id in pairs( message.functions ) do
|
|
t[name] = function( ... )
|
|
return self:call( id, self:listToCountAndTable( ... ) )
|
|
end
|
|
-- Protect the function against setfenv()
|
|
self.protectedFunctions[t[name]] = true
|
|
end
|
|
|
|
return {
|
|
op = 'return',
|
|
nvalues = 0,
|
|
values = {}
|
|
}
|
|
end
|
|
|
|
--- Handle a "wrapPhpFunction" message from PHP.
|
|
-- Create an anonymous function
|
|
--
|
|
-- @param message The message from PHP
|
|
-- @return The response message
|
|
function MWServer:handleWrapPhpFunction( message )
|
|
local id = message.id
|
|
local func = function( ... )
|
|
return self:call( id, self:listToCountAndTable( ... ) )
|
|
end
|
|
-- Protect the function against setfenv()
|
|
self.protectedFunctions[func] = true
|
|
|
|
return {
|
|
op = 'return',
|
|
nvalues = 1,
|
|
values = { func }
|
|
}
|
|
end
|
|
|
|
--- Handle a "getStatus" message from PHP
|
|
--
|
|
-- @param message The request message
|
|
-- @return The response message
|
|
function MWServer:handleGetStatus( message )
|
|
local nullRet = {
|
|
op = 'return',
|
|
nvalues = 0,
|
|
values = {}
|
|
}
|
|
local file = io.open( '/proc/self/stat' )
|
|
if not file then
|
|
return nullRet
|
|
end
|
|
local s = file:read('*a')
|
|
file:close()
|
|
local t = {}
|
|
for token in string.gmatch(s, '[^ ]+') do
|
|
t[#t + 1] = token
|
|
end
|
|
if #t < 22 then
|
|
return nullRet
|
|
end
|
|
return {
|
|
op = 'return',
|
|
nvalues = 1,
|
|
values = {{
|
|
pid = tonumber(t[1]),
|
|
time = tonumber(t[14]) + tonumber(t[15]) + tonumber(t[16]) + tonumber(t[17]),
|
|
vsize = tonumber(t[23]),
|
|
}}
|
|
}
|
|
end
|
|
|
|
--- The main request/response loop
|
|
--
|
|
-- Send a request message and return its matching reply message. Handle any
|
|
-- intervening requests (i.e. re-entrant calls) by dispatching them to the
|
|
-- relevant handler function.
|
|
--
|
|
-- The request message may optionally be omitted, to listen for request messages
|
|
-- without first sending a request of its own. Such a dispatch() call will
|
|
-- continue running until termination is requested by PHP. Typically, PHP does
|
|
-- this with a SIGTERM signal.
|
|
--
|
|
-- @param msgToPhp The message to send to PHP. Optional.
|
|
-- @return The matching response message
|
|
function MWServer:dispatch( msgToPhp )
|
|
if msgToPhp then
|
|
self:sendMessage( msgToPhp, 'call' )
|
|
end
|
|
while true do
|
|
local msgFromPhp = self:receiveMessage()
|
|
local msgToPhp
|
|
local op = msgFromPhp.op
|
|
if op == 'return' or op == 'error' then
|
|
return msgFromPhp
|
|
elseif op == 'call' then
|
|
msgToPhp = self:handleCall( msgFromPhp )
|
|
self:sendMessage( msgToPhp, 'reply' )
|
|
elseif op == 'loadString' then
|
|
msgToPhp = self:handleLoadString( msgFromPhp )
|
|
self:sendMessage( msgToPhp, 'reply' )
|
|
elseif op == 'registerLibrary' then
|
|
msgToPhp = self:handleRegisterLibrary( msgFromPhp )
|
|
self:sendMessage( msgToPhp, 'reply' )
|
|
elseif op == 'wrapPhpFunction' then
|
|
msgToPhp = self:handleWrapPhpFunction( msgFromPhp )
|
|
self:sendMessage( msgToPhp, 'reply' )
|
|
elseif op == 'cleanupChunks' then
|
|
msgToPhp = self:handleCleanupChunks( msgFromPhp )
|
|
self:sendMessage( msgToPhp, 'reply' )
|
|
elseif op == 'getStatus' then
|
|
msgToPhp = self:handleGetStatus( msgFromPhp )
|
|
self:sendMessage( msgToPhp, 'reply' )
|
|
elseif op == 'quit' then
|
|
self:debug( 'MWServer:dispatch: quit message received' )
|
|
os.exit(0)
|
|
elseif op == 'testquit' then
|
|
self:debug( 'MWServer:dispatch: testquit message received' )
|
|
os.exit(42)
|
|
else
|
|
self:internalError( "Invalid message operation" )
|
|
end
|
|
end
|
|
end
|
|
|
|
--- Write a message to the debug output stream.
|
|
-- Some day this may be configurable, currently it just unconditionally writes
|
|
-- the message to stderr. The PHP host will redirect those errors to /dev/null
|
|
-- by default, but it can be configured to send them to a file.
|
|
--
|
|
-- @param s The message
|
|
function MWServer:debug( s )
|
|
if ( type(s) == 'string' ) then
|
|
io.stderr:write( s .. '\n' )
|
|
else
|
|
io.stderr:write( self:serialize( s ) .. '\n' )
|
|
end
|
|
end
|
|
|
|
--- Raise an internal error
|
|
-- Write a message to stderr and then exit with a failure status. This should
|
|
-- be called for errors which cannot be allowed to be caught with pcall().
|
|
--
|
|
-- This must be used for protocol errors, or indeed any error from a context
|
|
-- where a dispatch() call lies between the error source and a possible pcall()
|
|
-- handler. If dispatch() were terminated by a regular error() call, the
|
|
-- resulting protocol violation could lead to a deadlock.
|
|
--
|
|
-- @param msg The error message
|
|
function MWServer:internalError( msg )
|
|
io.stderr:write( debug.traceback( msg ) .. '\n' )
|
|
os.exit( 1 )
|
|
end
|
|
|
|
--- Raise an I/O error
|
|
-- Helper function for errors from the io and file modules, which may optionally
|
|
-- return an informative error message as their second return value.
|
|
function MWServer:ioError( header, info )
|
|
if type( info) == 'string' then
|
|
self:internalError( header .. ': ' .. info )
|
|
else
|
|
self:internalError( header )
|
|
end
|
|
end
|
|
|
|
--- Send a message to PHP
|
|
-- @param msg The message table
|
|
-- @param direction 'call' or 'reply'
|
|
function MWServer:sendMessage( msg, direction )
|
|
if not msg.op then
|
|
self:internalError( "MWServer:sendMessage: invalid message", 2 )
|
|
end
|
|
self:debug('TX ==> ' .. msg.op)
|
|
|
|
-- If we're making an outgoing call, let errors go to our caller. If we're
|
|
-- replying to a call from PHP, catch serialization errors and return them
|
|
-- to PHP.
|
|
local encMsg;
|
|
if direction == 'reply' then
|
|
local ok
|
|
ok, encMsg = pcall( self.encodeMessage, self, msg )
|
|
if not ok then
|
|
self:debug('Serialization failed: ' .. encMsg)
|
|
self:debug('TX ==> error')
|
|
encMsg = self:encodeMessage( { op = 'error', value = encMsg } )
|
|
end
|
|
else
|
|
encMsg = self:encodeMessage( msg )
|
|
end
|
|
|
|
local success, errorMsg = io.stdout:write( encMsg )
|
|
if not success then
|
|
self:ioError( 'Write error', errorMsg )
|
|
end
|
|
io.stdout:flush()
|
|
end
|
|
|
|
--- Wait for a message from PHP and then decode and return it as a table
|
|
-- @return The received message
|
|
function MWServer:receiveMessage()
|
|
-- Read the header
|
|
local header, errorMsg = io.stdin:read( 16 )
|
|
if header == nil and errorMsg == nil then
|
|
-- End of file on stdin, exit gracefully
|
|
os.exit(0)
|
|
end
|
|
|
|
if not header or #header ~= 16 then
|
|
self:ioError( 'Read error', errorMsg )
|
|
end
|
|
local length = self:decodeHeader( header )
|
|
|
|
-- Read the body
|
|
local body, errorMsg = io.stdin:read( length )
|
|
if not body then
|
|
self:ioError( 'Read error', errorMsg )
|
|
end
|
|
if #body ~= length then
|
|
self:ioError( 'Read error', errorMsg )
|
|
end
|
|
|
|
-- Unserialize it
|
|
msg = self:unserialize( body )
|
|
self:debug('RX <== ' .. msg.op)
|
|
if msg.op == 'error' then
|
|
self:debug( 'Error: ' .. tostring( msg.value ) )
|
|
end
|
|
return msg
|
|
end
|
|
|
|
--- Encode a message for sending to PHP
|
|
function MWServer:encodeMessage( message )
|
|
local serialized = self:serialize( message )
|
|
local length = #serialized
|
|
local check = length * 2 - 1
|
|
return string.format( '%08x%08x', length, check ) .. serialized
|
|
end
|
|
|
|
-- Faster to create the table once than for each call to MWServer:serialize()
|
|
local serialize_replacements = {
|
|
['\r'] = '\\r',
|
|
['\n'] = '\\n',
|
|
['\\'] = '\\\\',
|
|
}
|
|
|
|
--- Convert a value to a string suitable for passing to PHP's unserialize().
|
|
-- Note that the following replacements must be performed before calling
|
|
-- unserialize:
|
|
-- "\\r" => "\r"
|
|
-- "\\n" => "\n"
|
|
-- "\\\\" => "\\"
|
|
--
|
|
-- @param var The value.
|
|
function MWServer:serialize( var )
|
|
local done = {}
|
|
|
|
local function isInteger( var, max )
|
|
return type(var) == 'number'
|
|
and math.floor( var ) == var
|
|
and var >= -max
|
|
and var < max
|
|
end
|
|
|
|
local function recursiveEncode( var, level )
|
|
local t = type( var )
|
|
if t == 'nil' then
|
|
return 'N;'
|
|
elseif t == 'number' then
|
|
if isInteger( var, self.intMax ) then
|
|
return 'i:' .. string.format( '%d', var ) .. ';'
|
|
elseif var < math.huge and var > -math.huge then
|
|
return 'd:' .. string.format( '%.17g', var ) .. ';'
|
|
elseif var == math.huge then
|
|
return 'd:INF;'
|
|
elseif var == -math.huge then
|
|
return 'd:-INF;'
|
|
else
|
|
return 'd:NAN;'
|
|
end
|
|
elseif t == 'string' then
|
|
return 's:' .. string.len( var ) .. ':"' .. var .. '";'
|
|
elseif t == 'boolean' then
|
|
if var then
|
|
return 'b:1;'
|
|
else
|
|
return 'b:0;'
|
|
end
|
|
elseif t == 'table' then
|
|
if done[var] then
|
|
error("Cannot pass circular reference to PHP")
|
|
end
|
|
done[var] = true
|
|
local buf = { '' }
|
|
local numElements = 0
|
|
local seen = {}
|
|
for key, value in pairs(var) do
|
|
local k = key
|
|
local t = type( k )
|
|
|
|
-- Convert integers in range to look like standard integers.
|
|
-- Use tostring() for the rest. Reject all other non-strings.
|
|
if isInteger( k, self.intKeyMax ) then
|
|
k = string.format( '%d', k )
|
|
elseif t == 'number' then
|
|
k = tostring( k );
|
|
elseif t ~= 'string' then
|
|
error("Cannot use " .. t .. " as an array key when passing data from Lua to PHP");
|
|
end
|
|
|
|
-- Zend PHP doesn't really care whether integer keys are serialized
|
|
-- as ints or strings, it converts them correctly on unserialize.
|
|
-- But HHVM does depend on it, so keep doing it for now.
|
|
local n = nil
|
|
if k == '0' or k:match( '^-?[1-9]%d*$' ) then
|
|
n = tonumber( k )
|
|
if n == -9223372036854775808 and k ~= '-9223372036854775808' then
|
|
-- Bad edge rounding
|
|
n = nil
|
|
end
|
|
end
|
|
if isInteger( n, self.intKeyMax ) then
|
|
buf[#buf + 1] = 'i:' .. k .. ';'
|
|
else
|
|
buf[#buf + 1] = recursiveEncode( k, level + 1 )
|
|
end
|
|
|
|
-- Detect collisions, e.g. { [0] = 'foo', ["0"] = 'bar' }
|
|
if seen[k] then
|
|
error( 'Collision for array key ' .. k .. ' when passing data from Lua to PHP' );
|
|
end
|
|
seen[k] = true
|
|
|
|
buf[#buf + 1] = recursiveEncode( value, level + 1 )
|
|
numElements = numElements + 1
|
|
end
|
|
buf[1] = 'a:' .. numElements .. ':{'
|
|
buf[#buf + 1] = '}'
|
|
return table.concat(buf)
|
|
elseif t == 'function' then
|
|
local id
|
|
if self.xchunks[var] then
|
|
id = self.xchunks[var]
|
|
else
|
|
id = self:addChunk(var)
|
|
end
|
|
return 'O:42:"Scribunto_LuaStandaloneInterpreterFunction":2:{s:13:"interpreterId";i:' ..
|
|
self.interpreterId .. ';s:2:"id";i:' .. id .. ';}'
|
|
elseif t == 'thread' then
|
|
error("Cannot pass thread to PHP")
|
|
elseif t == 'userdata' then
|
|
error("Cannot pass userdata to PHP")
|
|
else
|
|
error("Cannot pass unrecognised type to PHP")
|
|
end
|
|
end
|
|
|
|
return recursiveEncode( var, 0 ):gsub( '[\r\n\\]', serialize_replacements )
|
|
end
|
|
|
|
--- Convert a Lua expression string to its corresponding value.
|
|
-- Convert any references of the form chunk[id] to the corresponding function
|
|
-- values.
|
|
function MWServer:unserialize( text )
|
|
local func = loadstring( 'return ' .. text )
|
|
if not func then
|
|
self:internalError( "MWServer:unserialize: invalid chunk" )
|
|
end
|
|
-- Don't waste JIT cache space by storing every message in it
|
|
if jit then
|
|
jit.off( func )
|
|
end
|
|
setfenv( func, { chunks = self.chunks } )
|
|
return func()
|
|
end
|
|
|
|
--- Decode a message header.
|
|
-- @param header The header string
|
|
-- @return The body length
|
|
function MWServer:decodeHeader( header )
|
|
local length = string.sub( header, 1, 8 )
|
|
local check = string.sub( header, 9, 16 )
|
|
if not string.match( length, '^%x+$' ) or not string.match( check, '^%x+$' ) then
|
|
self:internalError( "Error decoding message header: " .. length .. '/' .. check )
|
|
end
|
|
length = tonumber( length, 16 )
|
|
check = tonumber( check, 16 )
|
|
if length * 2 - 1 ~= check then
|
|
self:internalError( "Error decoding message header" )
|
|
end
|
|
return length
|
|
end
|
|
|
|
--- Get a traceback similar to the one from debug.traceback(), but as a table
|
|
-- rather than formatted as a string
|
|
--
|
|
-- @param The level to start at: 1 for the function that called getStructuredTrace()
|
|
-- @return A table with the backtrace information
|
|
function MWServer:getStructuredTrace( level )
|
|
level = level + 1
|
|
local trace = {}
|
|
while true do
|
|
local rawInfo = debug.getinfo( level, 'nSl' )
|
|
if rawInfo == nil then
|
|
break
|
|
end
|
|
local info = {}
|
|
for i, key in ipairs({'short_src', 'what', 'currentline', 'name', 'namewhat', 'linedefined'}) do
|
|
info[key] = rawInfo[key]
|
|
end
|
|
if string.match( info['short_src'], '/MWServer.lua$' ) then
|
|
info['short_src'] = 'MWServer.lua'
|
|
end
|
|
if string.match( rawInfo['short_src'], '/mw_main.lua$' ) then
|
|
info['short_src'] = 'mw_main.lua'
|
|
end
|
|
table.insert( trace, info )
|
|
level = level + 1
|
|
end
|
|
return trace
|
|
end
|
|
|
|
--- Create a table to be used as a restricted environment, based on the current
|
|
-- global environment.
|
|
--
|
|
-- @return The environment table
|
|
function MWServer:newEnvironment()
|
|
local allowedGlobals = {
|
|
-- base
|
|
"assert",
|
|
"error",
|
|
"getmetatable",
|
|
"ipairs",
|
|
"next",
|
|
"pairs",
|
|
"pcall",
|
|
"rawequal",
|
|
"rawget",
|
|
"rawset",
|
|
"select",
|
|
"setmetatable",
|
|
"tonumber",
|
|
"type",
|
|
"unpack",
|
|
"xpcall",
|
|
"_VERSION",
|
|
-- libs
|
|
"table",
|
|
"math"
|
|
}
|
|
|
|
local env = {}
|
|
for i = 1, #allowedGlobals do
|
|
env[allowedGlobals[i]] = mw.clone( _G[allowedGlobals[i]] )
|
|
end
|
|
|
|
-- Cloning 'string' doesn't work right, because strings still use the old
|
|
-- 'string' as the metatable. So just copy it.
|
|
env.string = string
|
|
|
|
env._G = env
|
|
env.tostring = function( val )
|
|
return self:tostring( val )
|
|
end
|
|
env.string.dump = nil
|
|
env.setfenv, env.getfenv = mw.makeProtectedEnvFuncs(
|
|
self.protectedEnvironments, self.protectedFunctions )
|
|
env.debug = {
|
|
traceback = debug.traceback
|
|
}
|
|
env.os = {
|
|
date = os.date,
|
|
difftime = os.difftime,
|
|
time = os.time,
|
|
clock = os.clock
|
|
}
|
|
return env
|
|
end
|
|
|
|
--- An implementation of tostring() which does not expose pointers.
|
|
function MWServer:tostring(val)
|
|
local mt = getmetatable( val )
|
|
if mt and mt.__tostring then
|
|
return mt.__tostring(val)
|
|
end
|
|
local typeName = type(val)
|
|
local nonPointerTypes = {number = true, string = true, boolean = true, ['nil'] = true}
|
|
if nonPointerTypes[typeName] then
|
|
return tostring(val)
|
|
else
|
|
return typeName
|
|
end
|
|
end
|
|
|
|
return MWServer
|