luasocket/src/http.lua

394 lines
12 KiB
Lua
Raw Normal View History

2000-12-29 23:15:09 +01:00
-----------------------------------------------------------------------------
-- HTTP/1.1 client support for the Lua language.
-- LuaSocket toolkit.
2000-12-29 23:15:09 +01:00
-- Author: Diego Nehab
-- Conforming to RFC 2616
-- RCS ID: $Id$
2000-12-29 23:15:09 +01:00
-----------------------------------------------------------------------------
-- make sure LuaSocket is loaded
if not LUASOCKET_LIBNAME then error('module requires LuaSocket') end
-- get LuaSocket namespace
local socket = _G[LUASOCKET_LIBNAME]
if not socket then error('module requires LuaSocket') end
-- create namespace inside LuaSocket namespace
socket.http = socket.http or {}
-- make all module globals fall into namespace
setmetatable(socket.http, { __index = _G })
setfenv(1, socket.http)
2000-12-29 23:15:09 +01:00
-----------------------------------------------------------------------------
-- Program constants
-----------------------------------------------------------------------------
-- connection timeout in seconds
TIMEOUT = 60
2000-12-29 23:15:09 +01:00
-- default port for document retrieval
PORT = 80
2000-12-29 23:15:09 +01:00
-- user agent field sent in request
USERAGENT = socket.version
2001-06-06 22:55:45 +02:00
-- block size used in transfers
BLOCKSIZE = 2048
-----------------------------------------------------------------------------
-- Function return value selectors
-----------------------------------------------------------------------------
local function second(a, b)
return b
end
local function third(a, b, c)
return c
end
local function receive_headers(reqt, respt, tmp)
local sock = tmp.sock
local line, name, value, _
local headers = {}
-- store results
respt.headers = headers
-- get first line
line = socket.try(sock:receive())
2000-12-29 23:15:09 +01:00
-- headers go until a blank line is found
while line ~= "" do
-- get field-name and value
_, _, name, value = string.find(line, "^(.-):%s*(.*)")
assert(name and value, "malformed reponse headers")
name = string.lower(name)
2000-12-29 23:15:09 +01:00
-- get next line (value might be folded)
line = socket.try(sock:receive())
2000-12-29 23:15:09 +01:00
-- unfold any folded values
while string.find(line, "^%s") do
2000-12-29 23:15:09 +01:00
value = value .. line
line = socket.try(sock:receive())
2000-12-29 23:15:09 +01:00
end
-- save pair in table
if headers[name] then headers[name] = headers[name] .. ", " .. value
else headers[name] = value end
2000-12-29 23:15:09 +01:00
end
end
local function abort(cb, err)
local go, cb_err = cb(nil, err)
error(cb_err or err)
end
local function hand(cb, chunk)
local go, cb_err = cb(chunk)
assert(go, cb_err or "aborted by callback")
end
local function receive_body_bychunks(sock, sink)
while 1 do
-- get chunk size, skip extention
local line, err = sock:receive()
if err then abort(sink, err) end
local size = tonumber(string.gsub(line, ";.*", ""), 16)
if not size then abort(sink, "invalid chunk size") end
-- was it the last chunk?
if size <= 0 then break end
-- get chunk
local chunk, err = sock:receive(size)
if err then abort(sink, err) end
2001-06-06 22:55:45 +02:00
-- pass chunk to callback
hand(sink, chunk)
-- skip CRLF on end of chunk
err = second(sock:receive())
if err then abort(sink, err) end
end
2001-06-06 22:55:45 +02:00
-- let callback know we are done
hand(sink, nil)
-- servers shouldn't send trailer headers, but who trusts them?
local line = socket.try(sock:receive())
while line ~= "" do
line = socket.try(sock:receive())
end
2000-12-29 23:15:09 +01:00
end
local function receive_body_bylength(sock, length, sink)
2001-06-06 22:55:45 +02:00
while length > 0 do
local size = math.min(BLOCKSIZE, length)
2001-06-06 22:55:45 +02:00
local chunk, err = sock:receive(size)
if err then abort(sink, err) end
length = length - string.len(chunk)
-- see if there was an error
hand(sink, chunk)
2001-06-06 22:55:45 +02:00
end
-- let callback know we are done
hand(sink, nil)
end
local function receive_body_untilclosed(sock, sink)
while true do
local chunk, err, partial = sock:receive(BLOCKSIZE)
-- see if we are done
if err == "closed" then
hand(sink, partial)
break
end
hand(sink, chunk)
-- see if there was an error
if err then abort(sink, err) end
2001-06-06 22:55:45 +02:00
end
-- let callback know we are done
hand(sink, nil)
end
local function receive_body(reqt, respt, tmp)
local sink = reqt.sink or ltn12.sink.null()
local headers = respt.headers
local sock = tmp.sock
local te = headers["transfer-encoding"]
if te and te ~= "identity" then
-- get by chunked transfer-coding of message body
receive_body_bychunks(sock, sink)
elseif tonumber(headers["content-length"]) then
-- get by content-length
local length = tonumber(headers["content-length"])
receive_body_bylength(sock, length, sink)
2000-12-29 23:15:09 +01:00
else
-- get it all until connection closes
receive_body_untilclosed(sock, sink)
2000-12-29 23:15:09 +01:00
end
end
local function send_body_bychunks(data, source)
while true do
local chunk, err = source()
assert(chunk or not err, err)
if not chunk then break end
socket.try(data:send(string.format("%X\r\n", string.len(chunk))))
socket.try(data:send(chunk, "\r\n"))
end
socket.try(data:send("0\r\n\r\n"))
2000-12-29 23:15:09 +01:00
end
local function send_body(data, source)
while true do
local chunk, err = source()
assert(chunk or not err, err)
if not chunk then break end
socket.try(data:send(chunk))
2001-06-06 22:55:45 +02:00
end
end
local function send_headers(sock, headers)
-- send request headers
for i, v in pairs(headers) do
socket.try(sock:send(i .. ": " .. v .. "\r\n"))
--io.write(i .. ": " .. v .. "\r\n")
end
-- mark end of request headers
socket.try(sock:send("\r\n"))
--io.write("\r\n")
end
local function should_receive_body(reqt, respt, tmp)
if reqt.method == "HEAD" then return nil end
if respt.code == 204 or respt.code == 304 then return nil end
if respt.code >= 100 and respt.code < 200 then return nil end
return 1
end
local function receive_status(reqt, respt, tmp)
local status = socket.try(tmp.sock:receive())
local code = third(string.find(status, "HTTP/%d*%.%d* (%d%d%d)"))
-- store results
respt.code, respt.status = tonumber(code), status
end
local function request_uri(reqt, respt, tmp)
local url = tmp.parsed
if not reqt.proxy then
local parsed = tmp.parsed
url = {
path = parsed.path,
params = parsed.params,
query = parsed.query,
fragment = parsed.fragment
}
end
return socket.url.build(url)
end
local function send_request(reqt, respt, tmp)
local uri = request_uri(reqt, respt, tmp)
local sock = tmp.sock
local headers = tmp.headers
2001-06-06 22:55:45 +02:00
-- send request line
socket.try(sock:send((reqt.method or "GET")
.. " " .. uri .. " HTTP/1.1\r\n"))
--io.write((reqt.method or "GET")
--.. " " .. uri .. " HTTP/1.1\r\n")
-- send request headers headeres
if reqt.source and not headers["content-length"] then
headers["transfer-encoding"] = "chunked"
end
send_headers(sock, headers)
2001-06-06 22:55:45 +02:00
-- send request message body, if any
if reqt.source then
if headers["content-length"] then send_body(sock, reqt.source)
else send_body_bychunks(sock, reqt.source) end
2001-06-06 22:55:45 +02:00
end
end
local function open(reqt, respt, tmp)
local proxy = reqt.proxy or PROXY
local host, port
if proxy then
local pproxy = socket.url.parse(proxy)
assert(pproxy.port and pproxy.host, "invalid proxy")
host, port = pproxy.host, pproxy.port
else
host, port = tmp.parsed.host, tmp.parsed.port
end
-- store results
tmp.sock = socket.try(socket.tcp())
socket.try(tmp.sock:settimeout(reqt.timeout or TIMEOUT))
socket.try(tmp.sock:connect(host, port))
2000-12-29 23:15:09 +01:00
end
local function adjust_headers(reqt, respt, tmp)
local lower = {}
local headers = reqt.headers or {}
-- set default headers
lower["user-agent"] = USERAGENT
-- override with user values
for i,v in headers do
lower[string.lower(i)] = v
end
lower["host"] = tmp.parsed.host
-- this cannot be overriden
lower["connection"] = "close"
-- store results
tmp.headers = lower
2000-12-29 23:15:09 +01:00
end
local function parse_url(reqt, respt, tmp)
-- parse url with default fields
local parsed = socket.url.parse(reqt.url, {
host = "",
port = PORT,
path ="/",
scheme = "http"
})
-- scheme has to be http
if parsed.scheme ~= "http" then
error(string.format("unknown scheme '%s'", parsed.scheme))
end
-- explicit authentication info overrides that given by the URL
parsed.user = reqt.user or parsed.user
parsed.password = reqt.password or parsed.password
-- store results
tmp.parsed = parsed
end
-- forward declaration
local request_p
local function should_authorize(reqt, respt, tmp)
-- if there has been an authorization attempt, it must have failed
if reqt.headers and reqt.headers["authorization"] then return nil end
-- if last attempt didn't fail due to lack of authentication,
-- or we don't have authorization information, we can't retry
return respt.code == 401 and tmp.parsed.user and tmp.parsed.password
end
local function clone(headers)
if not headers then return nil end
local copy = {}
for i,v in pairs(headers) do
copy[i] = v
end
return copy
end
local function authorize(reqt, respt, tmp)
local headers = clone(reqt.headers) or {}
headers["authorization"] = "Basic " ..
(mime.b64(tmp.parsed.user .. ":" .. tmp.parsed.password))
local autht = {
method = reqt.method,
url = reqt.url,
source = reqt.source,
sink = reqt.sink,
headers = headers,
timeout = reqt.timeout,
proxy = reqt.proxy,
}
request_p(autht, respt, tmp)
end
2001-06-06 22:55:45 +02:00
local function should_redirect(reqt, respt, tmp)
return (reqt.redirect ~= false) and
(respt.code == 301 or respt.code == 302) and
(not reqt.method or reqt.method == "GET" or reqt.method == "HEAD")
and (not tmp.nredirects or tmp.nredirects < 5)
end
local function redirect(reqt, respt, tmp)
tmp.nredirects = (tmp.nredirects or 0) + 1
local redirt = {
method = reqt.method,
-- the RFC says the redirect URL has to be absolute, but some
-- servers do not respect that
url = socket.url.absolute(reqt.url, respt.headers["location"]),
source = reqt.source,
sink = reqt.sink,
headers = reqt.headers,
timeout = reqt.timeout,
proxy = reqt.proxy
}
request_p(redirt, respt, tmp)
-- we pass the location header as a clue we redirected
if respt.headers then respt.headers.location = redirt.url end
end
-- execute a request of through an exception
function request_p(reqt, respt, tmp)
parse_url(reqt, respt, tmp)
adjust_headers(reqt, respt, tmp)
open(reqt, respt, tmp)
send_request(reqt, respt, tmp)
receive_status(reqt, respt, tmp)
receive_headers(reqt, respt, tmp)
if should_redirect(reqt, respt, tmp) then
tmp.sock:close()
redirect(reqt, respt, tmp)
elseif should_authorize(reqt, respt, tmp) then
tmp.sock:close()
authorize(reqt, respt, tmp)
elseif should_receive_body(reqt, respt, tmp) then
receive_body(reqt, respt, tmp)
end
2001-06-06 22:55:45 +02:00
end
function request(reqt)
local respt, tmp = {}, {}
local s, e = pcall(request_p, reqt, respt, tmp)
if not s then respt.error = e end
if tmp.sock then tmp.sock:close() end
return respt
end
function get(url)
local t = {}
respt = request {
url = url,
sink = ltn12.sink.table(t)
}
return (table.getn(t) > 0 or nil) and table.concat(t), respt.headers,
respt.code, respt.error
2001-06-06 22:55:45 +02:00
end
function post(url, body)
local t = {}
respt = request {
url = url,
method = "POST",
source = ltn12.source.string(body),
sink = ltn12.sink.table(t),
headers = { ["content-length"] = string.len(body) }
}
return (table.getn(t) > 0 or nil) and table.concat(t),
respt.headers, respt.code, respt.error
2000-12-29 23:15:09 +01:00
end