mirror of
https://github.com/openwrt/luci.git
synced 2025-12-21 17:04:35 +04:00
treewide: separate Lua runtime resources
Move classes required for Lua runtime support into a new `luci-lua-runtime` package. Also replace the `luci.http` and `luci.util` classes in `luci-lib-base` with stubbed versions interacting with the ucode based runtime environment. Finally merge `luci-base-ucode` into the remainders of `luci-base`. Signed-off-by: Jo-Philipp Wich <jo@mein.io>
This commit is contained in:
Jo-Philipp Wich
@@ -6,234 +6,66 @@ local util = require "luci.util"
|
||||
local coroutine = require "coroutine"
|
||||
local table = require "table"
|
||||
local lhttp = require "lucihttp"
|
||||
local nixio = require "nixio"
|
||||
local ltn12 = require "luci.ltn12"
|
||||
|
||||
local table, ipairs, pairs, type, tostring, tonumber, error =
|
||||
table, ipairs, pairs, type, tostring, tonumber, error
|
||||
local L, table, ipairs, pairs, type, error = _G.L, table, ipairs, pairs, type, error
|
||||
|
||||
module "luci.http"
|
||||
|
||||
HTTP_MAX_CONTENT = 1024*100 -- 100 kB maximum content size
|
||||
|
||||
context = util.threadlocal()
|
||||
|
||||
Request = util.class()
|
||||
function Request.__init__(self, env, sourcein, sinkerr)
|
||||
self.input = sourcein
|
||||
self.error = sinkerr
|
||||
|
||||
|
||||
-- File handler nil by default to let .content() work
|
||||
self.filehandler = nil
|
||||
|
||||
-- HTTP-Message table
|
||||
self.message = {
|
||||
env = env,
|
||||
headers = {},
|
||||
params = urldecode_params(env.QUERY_STRING or ""),
|
||||
}
|
||||
|
||||
self.parsed_input = false
|
||||
end
|
||||
|
||||
function Request.formvalue(self, name, noparse)
|
||||
if not noparse and not self.parsed_input then
|
||||
self:_parse_input()
|
||||
end
|
||||
|
||||
if name then
|
||||
return self.message.params[name]
|
||||
else
|
||||
return self.message.params
|
||||
end
|
||||
end
|
||||
|
||||
function Request.formvaluetable(self, prefix)
|
||||
local vals = {}
|
||||
prefix = prefix and prefix .. "." or "."
|
||||
|
||||
if not self.parsed_input then
|
||||
self:_parse_input()
|
||||
end
|
||||
|
||||
local void = self.message.params[nil]
|
||||
for k, v in pairs(self.message.params) do
|
||||
if k:find(prefix, 1, true) == 1 then
|
||||
vals[k:sub(#prefix + 1)] = tostring(v)
|
||||
end
|
||||
end
|
||||
|
||||
return vals
|
||||
end
|
||||
|
||||
function Request.content(self)
|
||||
if not self.parsed_input then
|
||||
self:_parse_input()
|
||||
end
|
||||
|
||||
return self.message.content, self.message.content_length
|
||||
end
|
||||
|
||||
function Request.getcookie(self, name)
|
||||
return lhttp.header_attribute("cookie; " .. (self:getenv("HTTP_COOKIE") or ""), name)
|
||||
end
|
||||
|
||||
function Request.getenv(self, name)
|
||||
if name then
|
||||
return self.message.env[name]
|
||||
else
|
||||
return self.message.env
|
||||
end
|
||||
end
|
||||
|
||||
function Request.setfilehandler(self, callback)
|
||||
self.filehandler = callback
|
||||
|
||||
if not self.parsed_input then
|
||||
return
|
||||
end
|
||||
|
||||
-- If input has already been parsed then uploads are stored as unlinked
|
||||
-- temporary files pointed to by open file handles in the parameter
|
||||
-- value table. Loop all params, and invoke the file callback for any
|
||||
-- param with an open file handle.
|
||||
local name, value
|
||||
for name, value in pairs(self.message.params) do
|
||||
if type(value) == "table" then
|
||||
while value.fd do
|
||||
local data = value.fd:read(1024)
|
||||
local eof = (not data or data == "")
|
||||
|
||||
callback(value, data, eof)
|
||||
|
||||
if eof then
|
||||
value.fd:close()
|
||||
value.fd = nil
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function Request._parse_input(self)
|
||||
parse_message_body(
|
||||
self.input,
|
||||
self.message,
|
||||
self.filehandler
|
||||
)
|
||||
self.parsed_input = true
|
||||
end
|
||||
|
||||
function close()
|
||||
if not context.eoh then
|
||||
context.eoh = true
|
||||
coroutine.yield(3)
|
||||
end
|
||||
|
||||
if not context.closed then
|
||||
context.closed = true
|
||||
coroutine.yield(5)
|
||||
end
|
||||
L.http:close()
|
||||
end
|
||||
|
||||
function content()
|
||||
return context.request:content()
|
||||
return L.http:content()
|
||||
end
|
||||
|
||||
function formvalue(name, noparse)
|
||||
return context.request:formvalue(name, noparse)
|
||||
return L.http:formvalue(name, noparse)
|
||||
end
|
||||
|
||||
function formvaluetable(prefix)
|
||||
return context.request:formvaluetable(prefix)
|
||||
return L.http:formvaluetable(prefix)
|
||||
end
|
||||
|
||||
function getcookie(name)
|
||||
return context.request:getcookie(name)
|
||||
return L.http:getcookie(name)
|
||||
end
|
||||
|
||||
-- or the environment table itself.
|
||||
function getenv(name)
|
||||
return context.request:getenv(name)
|
||||
return L.http:getenv(name)
|
||||
end
|
||||
|
||||
function setfilehandler(callback)
|
||||
return context.request:setfilehandler(callback)
|
||||
return L.http:setfilehandler(callback)
|
||||
end
|
||||
|
||||
function header(key, value)
|
||||
if not context.headers then
|
||||
context.headers = {}
|
||||
end
|
||||
context.headers[key:lower()] = value
|
||||
coroutine.yield(2, key, value)
|
||||
L.http:header(key, value)
|
||||
end
|
||||
|
||||
function prepare_content(mime)
|
||||
if not context.headers or not context.headers["content-type"] then
|
||||
if mime == "application/xhtml+xml" then
|
||||
if not getenv("HTTP_ACCEPT") or
|
||||
not getenv("HTTP_ACCEPT"):find("application/xhtml+xml", nil, true) then
|
||||
mime = "text/html; charset=UTF-8"
|
||||
end
|
||||
header("Vary", "Accept")
|
||||
end
|
||||
header("Content-Type", mime)
|
||||
end
|
||||
L.http:prepare_content(mime)
|
||||
end
|
||||
|
||||
function source()
|
||||
return context.request.input
|
||||
return L.http.input
|
||||
end
|
||||
|
||||
function status(code, message)
|
||||
code = code or 200
|
||||
message = message or "OK"
|
||||
context.status = code
|
||||
coroutine.yield(1, code, message)
|
||||
L.http:status(code, message)
|
||||
end
|
||||
|
||||
-- This function is as a valid LTN12 sink.
|
||||
-- If the content chunk is nil this function will automatically invoke close.
|
||||
function write(content, src_err)
|
||||
if not content then
|
||||
if src_err then
|
||||
error(src_err)
|
||||
else
|
||||
close()
|
||||
end
|
||||
return true
|
||||
elseif #content == 0 then
|
||||
return true
|
||||
else
|
||||
if not context.eoh then
|
||||
if not context.status then
|
||||
status()
|
||||
end
|
||||
if not context.headers or not context.headers["content-type"] then
|
||||
header("Content-Type", "text/html; charset=utf-8")
|
||||
end
|
||||
if not context.headers["cache-control"] then
|
||||
header("Cache-Control", "no-cache")
|
||||
header("Expires", "0")
|
||||
end
|
||||
if not context.headers["x-frame-options"] then
|
||||
header("X-Frame-Options", "SAMEORIGIN")
|
||||
end
|
||||
if not context.headers["x-xss-protection"] then
|
||||
header("X-XSS-Protection", "1; mode=block")
|
||||
end
|
||||
if not context.headers["x-content-type-options"] then
|
||||
header("X-Content-Type-Options", "nosniff")
|
||||
end
|
||||
|
||||
context.eoh = true
|
||||
coroutine.yield(3)
|
||||
end
|
||||
coroutine.yield(4, content)
|
||||
return true
|
||||
if src_err then
|
||||
error(src_err)
|
||||
end
|
||||
|
||||
return L.print(content)
|
||||
end
|
||||
|
||||
function splice(fd, size)
|
||||
@@ -241,10 +73,7 @@ function splice(fd, size)
|
||||
end
|
||||
|
||||
function redirect(url)
|
||||
if url == "" then url = "/" end
|
||||
status(302, "Found")
|
||||
header("Location", url)
|
||||
close()
|
||||
L.http:redirect(url)
|
||||
end
|
||||
|
||||
function build_querystring(q)
|
||||
@@ -266,35 +95,7 @@ urldecode = util.urldecode
|
||||
urlencode = util.urlencode
|
||||
|
||||
function write_json(x)
|
||||
util.serialize_json(x, write)
|
||||
end
|
||||
|
||||
-- from given url or string. Returns a table with urldecoded values.
|
||||
-- Simple parameters are stored as string values associated with the parameter
|
||||
-- name within the table. Parameters with multiple values are stored as array
|
||||
-- containing the corresponding values.
|
||||
function urldecode_params(url, tbl)
|
||||
local parser, name
|
||||
local params = tbl or { }
|
||||
|
||||
parser = lhttp.urlencoded_parser(function (what, buffer, length)
|
||||
if what == parser.TUPLE then
|
||||
name, value = nil, nil
|
||||
elseif what == parser.NAME then
|
||||
name = lhttp.urldecode(buffer)
|
||||
elseif what == parser.VALUE and name then
|
||||
params[name] = lhttp.urldecode(buffer) or ""
|
||||
end
|
||||
|
||||
return true
|
||||
end)
|
||||
|
||||
if parser then
|
||||
parser:parse((url or ""):match("[^?]*$"))
|
||||
parser:parse(nil)
|
||||
end
|
||||
|
||||
return params
|
||||
L.printf('%J', x)
|
||||
end
|
||||
|
||||
-- separated by "&". Tables are encoded as parameters with multiple values by
|
||||
@@ -332,223 +133,12 @@ function urlencode_params(tbl)
|
||||
return table.concat(enc, "")
|
||||
end
|
||||
|
||||
-- Content-Type. Stores all extracted data associated with its parameter name
|
||||
-- in the params table within the given message object. Multiple parameter
|
||||
-- values are stored as tables, ordinary ones as strings.
|
||||
-- If an optional file callback function is given then it is fed with the
|
||||
-- file contents chunk by chunk and only the extracted file name is stored
|
||||
-- within the params table. The callback function will be called subsequently
|
||||
-- with three arguments:
|
||||
-- o Table containing decoded (name, file) and raw (headers) mime header data
|
||||
-- o String value containing a chunk of the file data
|
||||
-- o Boolean which indicates whether the current chunk is the last one (eof)
|
||||
function mimedecode_message_body(src, msg, file_cb)
|
||||
local parser, header, field
|
||||
local len, maxlen = 0, tonumber(msg.env.CONTENT_LENGTH or nil)
|
||||
|
||||
parser, err = lhttp.multipart_parser(msg.env.CONTENT_TYPE, function (what, buffer, length)
|
||||
if what == parser.PART_INIT then
|
||||
field = { }
|
||||
|
||||
elseif what == parser.HEADER_NAME then
|
||||
header = buffer:lower()
|
||||
|
||||
elseif what == parser.HEADER_VALUE and header then
|
||||
if header:lower() == "content-disposition" and
|
||||
lhttp.header_attribute(buffer, nil) == "form-data"
|
||||
then
|
||||
field.name = lhttp.header_attribute(buffer, "name")
|
||||
field.file = lhttp.header_attribute(buffer, "filename")
|
||||
field[1] = field.file
|
||||
end
|
||||
|
||||
if field.headers then
|
||||
field.headers[header] = buffer
|
||||
else
|
||||
field.headers = { [header] = buffer }
|
||||
end
|
||||
|
||||
elseif what == parser.PART_BEGIN then
|
||||
return not field.file
|
||||
|
||||
elseif what == parser.PART_DATA and field.name and length > 0 then
|
||||
if field.file then
|
||||
if file_cb then
|
||||
file_cb(field, buffer, false)
|
||||
msg.params[field.name] = msg.params[field.name] or field
|
||||
else
|
||||
if not field.fd then
|
||||
field.fd = nixio.mkstemp(field.name)
|
||||
end
|
||||
|
||||
if field.fd then
|
||||
field.fd:write(buffer)
|
||||
msg.params[field.name] = msg.params[field.name] or field
|
||||
end
|
||||
end
|
||||
else
|
||||
field.value = buffer
|
||||
end
|
||||
|
||||
elseif what == parser.PART_END and field.name then
|
||||
if field.file and msg.params[field.name] then
|
||||
if file_cb then
|
||||
file_cb(field, "", true)
|
||||
elseif field.fd then
|
||||
field.fd:seek(0, "set")
|
||||
end
|
||||
else
|
||||
local val = msg.params[field.name]
|
||||
|
||||
if type(val) == "table" then
|
||||
val[#val+1] = field.value or ""
|
||||
elseif val ~= nil then
|
||||
msg.params[field.name] = { val, field.value or "" }
|
||||
else
|
||||
msg.params[field.name] = field.value or ""
|
||||
end
|
||||
end
|
||||
|
||||
field = nil
|
||||
|
||||
elseif what == parser.ERROR then
|
||||
err = buffer
|
||||
end
|
||||
|
||||
return true
|
||||
end, HTTP_MAX_CONTENT)
|
||||
|
||||
return ltn12.pump.all(src, function (chunk)
|
||||
len = len + (chunk and #chunk or 0)
|
||||
|
||||
if maxlen and len > maxlen + 2 then
|
||||
return nil, "Message body size exceeds Content-Length"
|
||||
end
|
||||
|
||||
if not parser or not parser:parse(chunk) then
|
||||
return nil, err
|
||||
end
|
||||
|
||||
return true
|
||||
end)
|
||||
end
|
||||
|
||||
-- Content-Type. Stores all extracted data associated with its parameter name
|
||||
-- in the params table within the given message object. Multiple parameter
|
||||
-- values are stored as tables, ordinary ones as strings.
|
||||
function urldecode_message_body(src, msg)
|
||||
local err, name, value, parser
|
||||
local len, maxlen = 0, tonumber(msg.env.CONTENT_LENGTH or nil)
|
||||
|
||||
parser = lhttp.urlencoded_parser(function (what, buffer, length)
|
||||
if what == parser.TUPLE then
|
||||
name, value = nil, nil
|
||||
elseif what == parser.NAME then
|
||||
name = lhttp.urldecode(buffer, lhttp.DECODE_PLUS)
|
||||
elseif what == parser.VALUE and name then
|
||||
local val = msg.params[name]
|
||||
|
||||
if type(val) == "table" then
|
||||
val[#val+1] = lhttp.urldecode(buffer, lhttp.DECODE_PLUS) or ""
|
||||
elseif val ~= nil then
|
||||
msg.params[name] = { val, lhttp.urldecode(buffer, lhttp.DECODE_PLUS) or "" }
|
||||
else
|
||||
msg.params[name] = lhttp.urldecode(buffer, lhttp.DECODE_PLUS) or ""
|
||||
end
|
||||
elseif what == parser.ERROR then
|
||||
err = buffer
|
||||
end
|
||||
|
||||
return true
|
||||
end, HTTP_MAX_CONTENT)
|
||||
|
||||
return ltn12.pump.all(src, function (chunk)
|
||||
len = len + (chunk and #chunk or 0)
|
||||
|
||||
if maxlen and len > maxlen + 2 then
|
||||
return nil, "Message body size exceeds Content-Length"
|
||||
elseif len > HTTP_MAX_CONTENT then
|
||||
return nil, "Message body size exceeds maximum allowed length"
|
||||
end
|
||||
|
||||
if not parser or not parser:parse(chunk) then
|
||||
return nil, err
|
||||
end
|
||||
|
||||
return true
|
||||
end)
|
||||
end
|
||||
|
||||
-- This function will examine the Content-Type within the given message object
|
||||
-- to select the appropriate content decoder.
|
||||
-- Currently the application/x-www-urlencoded and application/form-data
|
||||
-- mime types are supported. If the encountered content encoding can't be
|
||||
-- handled then the whole message body will be stored unaltered as "content"
|
||||
-- property within the given message object.
|
||||
function parse_message_body(src, msg, filecb)
|
||||
if msg.env.CONTENT_LENGTH or msg.env.REQUEST_METHOD == "POST" then
|
||||
local ctype = lhttp.header_attribute(msg.env.CONTENT_TYPE, nil)
|
||||
|
||||
-- Is it multipart/mime ?
|
||||
if ctype == "multipart/form-data" then
|
||||
return mimedecode_message_body(src, msg, filecb)
|
||||
|
||||
-- Is it application/x-www-form-urlencoded ?
|
||||
elseif ctype == "application/x-www-form-urlencoded" then
|
||||
return urldecode_message_body(src, msg)
|
||||
|
||||
end
|
||||
|
||||
-- Unhandled encoding
|
||||
-- If a file callback is given then feed it chunk by chunk, else
|
||||
-- store whole buffer in message.content
|
||||
local sink
|
||||
|
||||
-- If we have a file callback then feed it
|
||||
if type(filecb) == "function" then
|
||||
local meta = {
|
||||
name = "raw",
|
||||
encoding = msg.env.CONTENT_TYPE
|
||||
}
|
||||
sink = function( chunk )
|
||||
if chunk then
|
||||
return filecb(meta, chunk, false)
|
||||
else
|
||||
return filecb(meta, nil, true)
|
||||
end
|
||||
end
|
||||
-- ... else append to .content
|
||||
else
|
||||
msg.content = ""
|
||||
msg.content_length = 0
|
||||
|
||||
sink = function( chunk )
|
||||
if chunk then
|
||||
if ( msg.content_length + #chunk ) <= HTTP_MAX_CONTENT then
|
||||
msg.content = msg.content .. chunk
|
||||
msg.content_length = msg.content_length + #chunk
|
||||
return true
|
||||
else
|
||||
return nil, "POST data exceeds maximum allowed length"
|
||||
end
|
||||
end
|
||||
return true
|
||||
end
|
||||
end
|
||||
|
||||
-- Pump data...
|
||||
while true do
|
||||
local ok, err = ltn12.pump.step( src, sink )
|
||||
|
||||
if not ok and err then
|
||||
return nil, err
|
||||
elseif not ok then -- eof
|
||||
return true
|
||||
end
|
||||
end
|
||||
|
||||
return true
|
||||
end
|
||||
|
||||
return false
|
||||
end
|
||||
context = {
|
||||
request = {
|
||||
formvalue = function(self, ...) return formvalue(...) end;
|
||||
formvaluetable = function(self, ...) return formvaluetable(...) end;
|
||||
content = function(self, ...) return content(...) end;
|
||||
getcookie = function(self, ...) return getcookie(...) end;
|
||||
setfilehandler = function(self, ...) return setfilehandler(...) end;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -100,32 +100,8 @@ end
|
||||
-- Scope manipulation routines
|
||||
--
|
||||
|
||||
coxpt = setmetatable({}, { __mode = "kv" })
|
||||
|
||||
local tl_meta = {
|
||||
__mode = "k",
|
||||
|
||||
__index = function(self, key)
|
||||
local t = rawget(self, coxpt[coroutine.running()]
|
||||
or coroutine.running() or 0)
|
||||
return t and t[key]
|
||||
end,
|
||||
|
||||
__newindex = function(self, key, value)
|
||||
local c = coxpt[coroutine.running()] or coroutine.running() or 0
|
||||
local r = rawget(self, c)
|
||||
if not r then
|
||||
rawset(self, c, { [key] = value })
|
||||
else
|
||||
r[key] = value
|
||||
end
|
||||
end
|
||||
}
|
||||
|
||||
-- the current active coroutine. A thread local store is private a table object
|
||||
-- whose values can't be accessed from outside of the running coroutine.
|
||||
function threadlocal(tbl)
|
||||
return setmetatable(tbl or {}, tl_meta)
|
||||
return tbl or {}
|
||||
end
|
||||
|
||||
|
||||
@@ -772,7 +748,6 @@ function coxpcall(f, err, ...)
|
||||
co = coroutine.create(newf)
|
||||
end
|
||||
coromap[co] = current
|
||||
coxpt[co] = coxpt[current] or current or 0
|
||||
return performResume(err, co, ...)
|
||||
end
|
||||
end
|
||||
|
||||
Reference in New Issue
Block a user