* luci/libs: added initial HTTP protocol implementation
This commit is contained in:
Jo-Philipp Wich
parent
1d7935cae0
commit
6571e9ba6f
1 changed files with 505 additions and 0 deletions
505
libs/web/luasrc/http/protocol.lua
Normal file
505
libs/web/luasrc/http/protocol.lua
Normal file
|
|
@ -0,0 +1,505 @@
|
|||
--[[
|
||||
|
||||
HTTP protocol implementation for LuCI
|
||||
(c) 2008 Freifunk Leipzig / Jo-Philipp Wich <xm@leipzig.freifunk.net>
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
$Id$
|
||||
|
||||
]]--
|
||||
|
||||
module("luci.http.protocol", package.seeall)
|
||||
|
||||
require("luci.util")
|
||||
require("luci.bits")
|
||||
|
||||
|
||||
HTTP_MAX_CONTENT = 1048576 -- 1 MB
|
||||
HTTP_DEFAULT_CTYPE = "text/html" -- default content type
|
||||
HTTP_DEFAULT_VERSION = "1.0" -- HTTP default version
|
||||
|
||||
|
||||
-- Decode an urlencoded string.
|
||||
-- Returns the decoded value.
|
||||
function urldecode( str )
|
||||
|
||||
local function __chrdec( hex )
|
||||
return string.char( luci.bits.Hex2Dec( hex ) )
|
||||
end
|
||||
|
||||
if type(str) == "string" then
|
||||
str = str:gsub( "+", " " ):gsub( "%%([a-fA-F0-9][a-fA-F0-9])", __chrdec )
|
||||
end
|
||||
|
||||
return str
|
||||
end
|
||||
|
||||
|
||||
-- Extract and split urlencoded data pairs, separated bei either "&" or ";" from given url.
|
||||
-- Returns a table value with urldecoded values.
|
||||
function urldecode_params( url )
|
||||
|
||||
local params = { }
|
||||
|
||||
if url:find("?") then
|
||||
url = url:gsub( "^.+%?([^?]+)", "%1" )
|
||||
end
|
||||
|
||||
for i, pair in ipairs(luci.util.split( url, "[&;]+", nil, true )) do
|
||||
|
||||
-- find key and value
|
||||
local key = urldecode( pair:match("^([^=]+)") )
|
||||
local val = urldecode( pair:match("^[^=]+=(.+)$") )
|
||||
|
||||
-- store
|
||||
if type(key) == "string" and key:len() > 0 then
|
||||
if type(val) ~= "string" then val = "" end
|
||||
|
||||
if not params[key] then
|
||||
params[key] = val
|
||||
elseif type(params[key]) ~= "table" then
|
||||
params[key] = { params[key], val }
|
||||
else
|
||||
table.insert( params[key], val )
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
return params
|
||||
end
|
||||
|
||||
|
||||
-- Encode given string in urlencoded format.
|
||||
-- Returns the encoded string.
|
||||
function urlencode( str )
|
||||
|
||||
local function __chrenc( chr )
|
||||
return string.format(
|
||||
"%%%02x", string.byte( chr )
|
||||
)
|
||||
end
|
||||
|
||||
if type(str) == "string" then
|
||||
str = str:gsub(
|
||||
"([^a-zA-Z0-9$_%-%.+!*'(),])",
|
||||
__chrenc
|
||||
)
|
||||
end
|
||||
|
||||
return str
|
||||
end
|
||||
|
||||
|
||||
-- Encode given table to urlencoded string.
|
||||
-- Returns the encoded string.
|
||||
function urlencode_params( tbl )
|
||||
local enc = ""
|
||||
|
||||
for k, v in pairs(tbl) do
|
||||
enc = enc .. ( enc and "&" or "" ) ..
|
||||
urlencode(k) .. "=" ..
|
||||
urlencode(v)
|
||||
end
|
||||
|
||||
return enc
|
||||
end
|
||||
|
||||
|
||||
-- Decode MIME encoded data.
|
||||
-- Returns a table with decoded values.
|
||||
function mimedecode( data, boundary, filecb )
|
||||
|
||||
local params = { }
|
||||
|
||||
-- create a line reader
|
||||
local reader = _linereader( data )
|
||||
|
||||
-- state variables
|
||||
local in_part = false
|
||||
local in_file = false
|
||||
local in_fbeg = false
|
||||
local in_size = true
|
||||
|
||||
local filename
|
||||
local buffer
|
||||
local field
|
||||
local clen = 0
|
||||
|
||||
|
||||
-- try to read all mime parts
|
||||
for line in reader do
|
||||
|
||||
-- update content length
|
||||
clen = clen + line:len()
|
||||
|
||||
if clen >= HTTP_MAX_CONTENT then
|
||||
in_size = false
|
||||
end
|
||||
|
||||
-- when no boundary is given, try to find it
|
||||
if not boundary then
|
||||
boundary = line:match("^%-%-([^\r\n]+)\r?\n$")
|
||||
end
|
||||
|
||||
-- Got a valid boundary line or reached max allowed size.
|
||||
if ( boundary and line:sub(1,2) == "--" and line:len() > #boundary + 2 and
|
||||
line:sub( 3, 2 + #boundary ) == boundary ) or not in_size
|
||||
then
|
||||
-- Flush the data of the previous mime part.
|
||||
-- When field and/or buffer are set to nil we should discard
|
||||
-- the previous section entirely due to format violations.
|
||||
if type(field) == "string" and field:len() > 0 and
|
||||
type(buffer) == "string"
|
||||
then
|
||||
-- According to the rfc the \r\n preceeding a boundary
|
||||
-- is assumed to be part of the boundary itself.
|
||||
-- Since we are reading line by line here, this crlf
|
||||
-- is part of the last line of our section content,
|
||||
-- so strip it before storing the buffer.
|
||||
buffer = buffer:gsub("\r?\n$","")
|
||||
|
||||
-- If we're in a file part and a file callback has been provided
|
||||
-- then do a final call and send eof.
|
||||
if in_file and type(filecb) == "function" then
|
||||
filecb( field, filename, buffer, true )
|
||||
params[field] = filename
|
||||
|
||||
-- Store buffer.
|
||||
else
|
||||
params[field] = buffer
|
||||
end
|
||||
end
|
||||
|
||||
-- Reset vars
|
||||
buffer = ""
|
||||
filename = nil
|
||||
field = nil
|
||||
in_file = false
|
||||
|
||||
-- Abort here if we reached maximum allowed size
|
||||
if not in_size then break end
|
||||
|
||||
-- Do we got the last boundary?
|
||||
if line:len() > #boundary + 4 and
|
||||
line:sub( #boundary + 2, #boundary + 4 ) == "--"
|
||||
then
|
||||
-- No more processing
|
||||
in_part = false
|
||||
|
||||
-- It's a middle boundary
|
||||
else
|
||||
|
||||
-- Read headers
|
||||
local hlen, headers = extract_headers( reader )
|
||||
|
||||
-- Check for valid headers
|
||||
if headers['Content-Disposition'] then
|
||||
|
||||
-- Got no content type header, assume content-type "text/plain"
|
||||
if not headers['Content-Type'] then
|
||||
headers['Content-Type'] = 'text/plain'
|
||||
end
|
||||
|
||||
-- Find field name
|
||||
local hdrvals = luci.util.split(
|
||||
headers['Content-Disposition'], '; '
|
||||
)
|
||||
|
||||
-- Valid form data part?
|
||||
if hdrvals[1] == "form-data" and hdrvals[2]:match("^name=") then
|
||||
|
||||
-- Store field identifier
|
||||
field = hdrvals[2]:match('^name="(.+)"$')
|
||||
|
||||
-- Do we got a file upload field?
|
||||
if #hdrvals == 3 and hdrvals[3]:match("^filename=") then
|
||||
in_file = true
|
||||
if_fbeg = true
|
||||
filename = hdrvals[3]:match('^filename="(.+)"$')
|
||||
end
|
||||
|
||||
-- Entering next part processing
|
||||
in_part = true
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- Processing content
|
||||
elseif in_part then
|
||||
|
||||
-- XXX: Would be really good to switch from line based to
|
||||
-- buffered reading here.
|
||||
|
||||
|
||||
-- If we're in a file part and a file callback has been provided
|
||||
-- then call the callback and reset the buffer.
|
||||
if in_file and type(filecb) == "function" then
|
||||
|
||||
-- If we're not processing the first chunk, then call
|
||||
if not in_fbeg then
|
||||
filecb( field, filename, buffer, false )
|
||||
buffer = ""
|
||||
|
||||
-- Clear in_fbeg flag after first run
|
||||
else
|
||||
in_fbeg = false
|
||||
end
|
||||
end
|
||||
|
||||
-- Append date to buffer
|
||||
buffer = buffer .. line
|
||||
end
|
||||
end
|
||||
|
||||
return params
|
||||
end
|
||||
|
||||
|
||||
-- Extract "magic", the first line of a http message.
|
||||
-- Returns the message type ("get", "post" or "response"), the requested uri
|
||||
-- if it is a valid http request or the status code if the line descripes a
|
||||
-- http response. For requests the third parameter is nil, for responses it
|
||||
-- contains the human readable status description.
|
||||
function extract_magic( reader )
|
||||
|
||||
for line in reader do
|
||||
-- Is it a request?
|
||||
local method, uri = line:match("^([A-Z]+) ([^ ]+) HTTP/[01]%.[019]\r?\n$")
|
||||
|
||||
-- Yup, it is
|
||||
if method then
|
||||
return method:lower(), uri, nil
|
||||
|
||||
-- Is it a response?
|
||||
else
|
||||
local code, message = line:match("^HTTP/[01]%.[019] ([0-9]+) ([^\r\n]+)\r?\n$")
|
||||
|
||||
-- Is a response
|
||||
if code then
|
||||
return "response", code + 0, message
|
||||
|
||||
-- Can't handle it
|
||||
else
|
||||
return nil
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
-- Extract headers from given string.
|
||||
-- Returns a table of extracted headers and the remainder of the parsed data.
|
||||
function extract_headers( reader, tbl )
|
||||
|
||||
local headers = tbl or { }
|
||||
local count = 0
|
||||
|
||||
-- Iterate line by line
|
||||
for line in reader do
|
||||
|
||||
-- Look for a valid header format
|
||||
local hdr, val = line:match( "^([A-Z][A-Za-z0-9%-_]+): +([^\r\n]+)\r?\n$" )
|
||||
|
||||
if type(hdr) == "string" and hdr:len() > 0 and
|
||||
type(val) == "string" and val:len() > 0
|
||||
then
|
||||
count = count + line:len()
|
||||
headers[hdr] = val
|
||||
|
||||
elseif line:match("^\r?\n$") then
|
||||
|
||||
return count + line:len(), headers
|
||||
|
||||
else
|
||||
-- junk data, don't add length
|
||||
return count, headers
|
||||
end
|
||||
end
|
||||
|
||||
return count, headers
|
||||
end
|
||||
|
||||
|
||||
-- Parse a http message
|
||||
function parse_message( data, filecb )
|
||||
|
||||
-- Create a line reader
|
||||
local reader = _linereader( data )
|
||||
local message = { }
|
||||
|
||||
-- Try to extract magic
|
||||
local method, arg1, arg2 = extract_magic( reader )
|
||||
|
||||
-- Does it looks like a valid message?
|
||||
if method then
|
||||
|
||||
message.request_method = method
|
||||
message.status = arg2 and arg1 or 0
|
||||
message.request_uri = arg2 and nil or arg1
|
||||
|
||||
if method == "response" then
|
||||
message.type = "response"
|
||||
else
|
||||
message.type = "request"
|
||||
end
|
||||
|
||||
-- Parse headers?
|
||||
local hlen, hdrs = extract_headers( reader )
|
||||
|
||||
-- Valid headers?
|
||||
if hlen > 2 and type(hdrs) == "table" then
|
||||
|
||||
message.headers = hdrs
|
||||
|
||||
-- Get content
|
||||
local clen = ( hdrs['Content-Length'] or HTTP_MAX_CONTENT ) + 0
|
||||
|
||||
-- Process get parameters
|
||||
if method == "get" or method == "post" then
|
||||
message.params = urldecode_params( message.request_uri )
|
||||
end
|
||||
|
||||
-- Process post method
|
||||
if method == "post" and hdrs['Content-Type'] then
|
||||
|
||||
-- Is it multipart/form-data ?
|
||||
if hdrs['Content-Type']:match("^multipart/form%-data") then
|
||||
for k, v in pairs( mimedecode(
|
||||
reader,
|
||||
hdrs['Content-Type']:match("boundary=(.+)"),
|
||||
filecb
|
||||
) ) do
|
||||
message.params[k] = v
|
||||
end
|
||||
|
||||
-- Is it x-www-urlencoded?
|
||||
elseif hdrs['Content-Type'] == 'application/x-www-urlencoded' then
|
||||
|
||||
-- XXX: readline isn't the best solution here
|
||||
for chunk in reader do
|
||||
for k, v in pairs( urldecode_params( chunk ) ) do
|
||||
message.params[k] = v
|
||||
end
|
||||
|
||||
-- XXX: unreliable (undefined line length)
|
||||
if clen + chunk:len() >= HTTP_MAX_CONTENT then
|
||||
break
|
||||
end
|
||||
|
||||
clen = clen + chunk:len()
|
||||
end
|
||||
|
||||
-- Unhandled encoding
|
||||
-- If a file callback is given then feed it line by line, else
|
||||
-- store whole buffer in message.content
|
||||
else
|
||||
|
||||
for chunk in reader do
|
||||
|
||||
-- We have a callback, feed it.
|
||||
if type(filecb) == "function" then
|
||||
|
||||
filecb( "_post", nil, chunk, false )
|
||||
|
||||
-- Append to .content buffer.
|
||||
else
|
||||
message.content =
|
||||
type(message.content) == "string"
|
||||
and message.content .. chunk
|
||||
or chunk
|
||||
end
|
||||
|
||||
-- XXX: unreliable
|
||||
if clen + chunk:len() >= HTTP_MAX_CONTENT then
|
||||
break
|
||||
end
|
||||
|
||||
clen = clen + chunk:len()
|
||||
end
|
||||
|
||||
-- Send eof to callback
|
||||
if type(filecb) == "function" then
|
||||
filecb( "_post", nil, "", true )
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- Populate common environment variables
|
||||
message.env = {
|
||||
CONTENT_LENGTH = hdrs['Content-Length'];
|
||||
CONTENT_TYPE = hdrs['Content-Type'];
|
||||
REQUEST_METHOD = message.request_method;
|
||||
REQUEST_URI = message.request_uri;
|
||||
SCRIPT_NAME = message.request_uri:gsub("?.+$","");
|
||||
SCRIPT_FILENAME = "" -- XXX implement me
|
||||
}
|
||||
|
||||
-- Populate HTTP_* environment variables
|
||||
for i, hdr in ipairs( {
|
||||
'Accept',
|
||||
'Accept-Charset',
|
||||
'Accept-Encoding',
|
||||
'Accept-Language',
|
||||
'Connection',
|
||||
'Cookie',
|
||||
'Host',
|
||||
'Referer',
|
||||
'User-Agent',
|
||||
} ) do
|
||||
local var = 'HTTP_' .. hdr:upper():gsub("%-","_")
|
||||
local val = hdrs[hdr]
|
||||
|
||||
message.env[var] = val
|
||||
end
|
||||
|
||||
|
||||
return message
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function _linereader( obj )
|
||||
|
||||
-- object is string
|
||||
if type(obj) == "string" then
|
||||
|
||||
return obj:gmatch( "[^\r\n]*\r?\n" )
|
||||
|
||||
-- object is a function
|
||||
elseif type(obj) == "function" then
|
||||
|
||||
return obj
|
||||
|
||||
-- object is a table and implements a readline() function
|
||||
elseif type(obj) == "table" and type(obj.readline) == "function" then
|
||||
|
||||
return obj.readline
|
||||
|
||||
-- object is a table and has a lines property
|
||||
elseif type(obj) == "table" and obj.lines then
|
||||
|
||||
-- decide wheather to use "lines" as function or table
|
||||
local _lns = ( type(obj.lines) == "function" ) and obj.lines() or obj.lines
|
||||
local _pos = 1
|
||||
|
||||
return function()
|
||||
if _pos <= #_lns then
|
||||
_pos = _pos + 1
|
||||
return _lns[_pos]
|
||||
end
|
||||
end
|
||||
|
||||
-- no usable data type
|
||||
else
|
||||
|
||||
-- dummy iterator
|
||||
return function()
|
||||
return nil
|
||||
end
|
||||
end
|
||||
end
|
||||
Loading…
Reference in a new issue