HTTP is now generic, with function http_request.

RFC is more strictly followed.
This commit is contained in:
Diego Nehab 2001-01-25 22:01:37 +00:00
parent f6b9505225
commit bee46b39bf

View File

@ -1,5 +1,6 @@
-----------------------------------------------------------------------------
-- Simple HTTP/1.1 support for the Lua language using the LuaSocket toolkit.
-- Full HTTP/1.1 client support for the Lua language using the
-- LuaSocket 1.2 toolkit.
-- Author: Diego Nehab
-- Date: 26/12/2000
-- Conforming to: RFC 2068
@ -13,127 +14,123 @@ local TIMEOUT = 60
-- default port for document retrieval
local PORT = 80
-- user agent field sent in request
local USERAGENT = "LuaSocket/HTTP 1.0"
local USERAGENT = "LuaSocket 1.2 HTTP 1.1"
-----------------------------------------------------------------------------
-- Tries to get a line from the server or close socket if error
-- Tries to get a pattern from the server and closes socket on error
-- sock: socket connected to the server
-- pattern: pattern to receive
-- Returns
-- line: line received or nil in case of error
-- data: line received or nil in case of error
-- err: error message if any
-----------------------------------------------------------------------------
local try_getline = function(sock)
line, err = sock:receive()
local try_get = function(...)
local sock = arg[1]
local data, err = call(sock.receive, arg)
if err then
sock:close()
return nil, err
end
return line
return data
end
-----------------------------------------------------------------------------
-- Tries to send a line to the server or close socket if error
-- Tries to send data to the server and closes socket on error
-- sock: socket connected to the server
-- line: line to send
-- data: data to send
-- Returns
-- err: error message if any
-- err: error message if any, nil if successfull
-----------------------------------------------------------------------------
local try_sendline = function(sock, line)
err = sock:send(line)
local try_send = function(sock, data)
err = sock:send(data)
if err then sock:close() end
return err
end
-----------------------------------------------------------------------------
-- Retrieves status from http reply
-- Retrieves status code from http status line
-- Input
-- reply: http reply string
-- line: http status line
-- Returns
-- status: integer with status code
-- code: integer with status code
-----------------------------------------------------------------------------
local get_status = function(reply)
local _,_, status = strfind(reply, " (%d%d%d) ")
return tonumber(status)
local get_statuscode = function(line)
local _,_, code = strfind(line, " (%d%d%d) ")
return tonumber(code)
end
-----------------------------------------------------------------------------
-- Receive server reply messages
-- Input
-- sock: server socket
-- sock: socket connected to the server
-- Returns
-- status: server reply status code or nil if error
-- reply: full server reply
-- code: server status code or nil if error
-- line: full http status line
-- err: error message if any
-----------------------------------------------------------------------------
local get_reply = function(sock)
local reply, err
reply, err = %try_getline(sock)
if not err then return %get_status(reply), reply
local get_status = function(sock)
local line, err
line, err = %try_get(sock)
if not err then return %get_statuscode(line), line
else return nil, nil, err end
end
-----------------------------------------------------------------------------
-- Receive and parse mime headers
-- Receive and parse responce header fields
-- Input
-- sock: server socket
-- mime: a table that might already contain mime headers
-- sock: socket connected to the server
-- headers: a table that might already contain headers
-- Returns
-- mime: a table with all mime headers in the form
-- headers: a table with all headers fields in the form
-- {name_1 = "value_1", name_2 = "value_2" ... name_n = "value_n"}
-- all name_i are lowercase
-- nil and error message in case of error
-----------------------------------------------------------------------------
local get_mime = function(sock, mime)
local get_headers = function(sock, headers)
local line, err
local name, value
-- get first line
line, err = %try_getline(sock)
line, err = %try_get(sock)
if err then return nil, err end
-- headers go until a blank line is found
while line ~= "" do
-- get field-name and value
_,_, name, value = strfind(line, "(.-):%s*(.*)")
if not name or not value then
sock:close()
return nil, "malformed reponse headers"
end
name = strlower(name)
-- get next line (value might be folded)
line, err = %try_getline(sock)
line, err = %try_get(sock)
if err then return nil, err end
-- unfold any folded values
while not err and line ~= "" and (strsub(line, 1, 1) == " ") do
while not err and strfind(line, "^%s") do
value = value .. line
line, err = %try_getline(sock)
line, err = %try_get(sock)
if err then return nil, err end
end
-- save pair in table
if mime[name] then
-- join any multiple field
mime[name] = mime[name] .. ", " .. value
else
-- new field
mime[name] = value
if headers[name] then headers[name] = headers[name] .. ", " .. value
else headers[name] = value end
end
end
return mime
return headers
end
-----------------------------------------------------------------------------
-- Receives http body
-- Receives a chunked message body
-- Input
-- sock: server socket
-- mime: initial mime headers
-- sock: socket connected to the server
-- Returns
-- body: a string containing the body of the document
-- body: a string containing the body of the message
-- nil and error message in case of error
-- Obs:
-- mime: headers might be modified by chunked transfer
-----------------------------------------------------------------------------
local get_body = function(sock, mime)
local body, err
if mime["transfer-encoding"] == "chunked" then
local chunk_size, line
body = ""
local try_getchunked = function(sock)
local chunk_size, line, err
local body = ""
repeat
-- get chunk size, skip extention
line, err = %try_getline(sock)
line, err = %try_get(sock)
if err then return nil, err end
chunk_size = tonumber(gsub(line, ";.*", ""), 16)
if not chunk_size then
@ -141,33 +138,43 @@ local get_body = function(sock, mime)
return nil, "invalid chunk size"
end
-- get chunk
line, err = sock:receive(chunk_size)
if err then
sock:close()
return nil, err
end
line, err = %try_get(sock, chunk_size)
if err then return nil, err end
-- concatenate new chunk
body = body .. line
-- skip blank line
_, err = %try_getline(sock)
_, err = %try_get(sock)
if err then return nil, err end
until chunk_size <= 0
-- store extra mime headers
--_, err = %get_mime(sock, mime)
return body
end
-----------------------------------------------------------------------------
-- Receives http body
-- Input
-- sock: socket connected to the server
-- headers: response header fields
-- Returns
-- body: a string containing the body of the document
-- nil and error message in case of error
-- Obs:
-- headers: headers might be modified by chunked transfer
-----------------------------------------------------------------------------
local get_body = function(sock, headers)
local body, err
if headers["transfer-encoding"] == "chunked" then
body, err = %try_getchunked(sock)
if err then return nil, err end
-- store extra entity headers
--_, err = %get_headers(sock, headers)
--if err then return nil, err end
elseif mime["content-length"] then
body, err = sock:receive(tonumber(mime["content-length"]))
if err then
sock:close()
return nil, err
end
elseif headers["content-length"] then
body, err = %try_get(sock, tonumber(headers["content-length"]))
if err then return nil, err end
else
-- get it all until connection closes!
body, err = sock:receive("*a")
if err then
sock:close()
return nil, err
end
body, err = %try_get(sock, "*a")
if err then return nil, err end
end
-- return whole body
return body
@ -175,10 +182,9 @@ end
-----------------------------------------------------------------------------
-- Parses a url and returns its scheme, user, password, host, port
-- and path components, according to RFC 1738, Uniform Resource Locators (URL),
-- of December 1994
-- and path components, according to RFC 1738
-- Input
-- url: unique resource locator desired
-- url: uniform resource locator of request
-- default: table containing default values to be returned
-- Returns
-- table with the following fields:
@ -213,47 +219,99 @@ local split_url = function(url, default)
end
-----------------------------------------------------------------------------
-- Sends a GET message through socket
-- Tries to send request body, using chunked transfer-encoding
-- Apache, for instance, accepts only 8kb of body in a post to a CGI script
-- if we use only the content-length header field...
-- Input
-- socket: http connection socket
-- path: path requested
-- mime: mime headers to send in request
-- sock: socket connected to the server
-- body: body to be sent in request
-- Returns
-- err: nil in case of success, error message otherwise
-----------------------------------------------------------------------------
local send_get = function(sock, path, mime)
local err = %try_sendline(sock, "GET " .. path .. " HTTP/1.1\r\n")
local try_sendchunked = function(sock, body)
local wanted = strlen(body)
local first = 1
local chunk_size
local err
while wanted > 0 do
chunk_size = min(wanted, 1024)
err = %try_send(sock, format("%x\r\n", chunk_size))
if err then return err end
for i, v in mime do
err = %try_sendline(sock, i .. ": " .. v .. "\r\n")
err = %try_send(sock, strsub(body, first, first + chunk_size - 1))
if err then return err end
err = %try_send(sock, "\r\n")
if err then return err end
wanted = wanted - chunk_size
first = first + chunk_size
end
err = %try_sendline(sock, "\r\n")
err = %try_send(sock, "0\r\n")
return err
end
-----------------------------------------------------------------------------
-- Converts field names to lowercase
-- Sends a http request message through socket
-- Input
-- headers: user header fields
-- parsed: parsed url components
-- sock: socket connected to the server
-- method: request method to be used
-- path: url path
-- headers: request headers to be sent
-- body: request message body, if any
-- Returns
-- mime: a table with the same headers, but with lowercase field names
-- err: nil in case of success, error message otherwise
-----------------------------------------------------------------------------
local fill_headers = function(headers, parsed)
local mime = {}
local send_request = function(sock, method, path, headers, body)
local err = %try_send(sock, method .. " " .. path .. " HTTP/1.1\r\n")
if err then return err end
for i, v in headers do
err = %try_send(sock, i .. ": " .. v .. "\r\n")
if err then return err end
end
err = %try_send(sock, "\r\n")
--if not err and body then err = %try_sendchunked(sock, body) end
if not err and body then err = %try_send(sock, body) end
return err
end
-----------------------------------------------------------------------------
-- Determines if we should read a message body from the server response
-- Input
-- method: method used in request
-- code: server response status code
-- Returns
-- 1 if a message body should be processed, nil otherwise
-----------------------------------------------------------------------------
function has_responsebody(method, code)
if method == "HEAD" then return nil end
if code == 204 or code == 304 then return nil end
if code >= 100 and code < 200 then return nil end
return 1
end
-----------------------------------------------------------------------------
-- Converts field names to lowercase and add message body size specification
-- Input
-- headers: request header fields
-- parsed: parsed url components
-- body: request message body, if any
-- Returns
-- lower: a table with the same headers, but with lowercase field names
-----------------------------------------------------------------------------
local fill_headers = function(headers, parsed, body)
local lower = {}
headers = headers or {}
for i,v in headers do
mime[strlower(i)] = v
lower[strlower(i)] = v
end
mime["connection"] = "close"
mime["host"] = parsed.host
mime["user-agent"] = %USERAGENT
--if body then lower["transfer-encoding"] = "chunked" end
if body then lower["content-length"] = tostring(strlen(body)) end
lower["connection"] = "close"
lower["host"] = parsed.host
lower["user-agent"] = %USERAGENT
if parsed.user and parsed.pass then -- Basic Authentication
mime["authorization"] = "Basic "..
lower["authorization"] = "Basic "..
base64(parsed.user .. ":" .. parsed.pass)
end
return mime
return lower
end
-----------------------------------------------------------------------------
@ -262,51 +320,84 @@ end
dofile("base64.lua")
-----------------------------------------------------------------------------
-- Downloads and receives a http url, with its mime headers
-- Sends a HTTP request and retrieves the server reply
-- Input
-- url: unique resource locator desired
-- headers: headers to send with request
-- tried: is this an authentication retry?
-- method: "GET", "PUT", "POST" etc
-- url: target uniform resource locator
-- headers: request headers to send
-- body: request message body
-- Returns
-- body: document body, if successfull
-- mime: headers received with document, if sucessfull
-- reply: server reply, if successfull
-- err: error message, if any
-- resp_body: response message body, if successfull
-- resp_hdrs: response header fields received, if sucessfull
-- line: server response status line, if successfull
-- err: error message if any
-----------------------------------------------------------------------------
function http_get(url, headers)
local sock, err, mime, body, status, reply
function http_request(method, url, headers, body)
local sock, err
local resp_hdrs, response_body
local line, code
-- get url components
local parsed = %split_url(url, {port = %PORT, path ="/"})
-- methods are case sensitive
method = strupper(method)
-- fill default headers
headers = %fill_headers(headers, parsed)
headers = %fill_headers(headers, parsed, body)
-- try connection
sock, err = connect(parsed.host, parsed.port)
if not sock then return nil, nil, nil, err end
-- set connection timeout
sock:timeout(%TIMEOUT)
-- send request
err = %send_get(sock, parsed.path, headers)
err = %send_request(sock, method, parsed.path, headers, body)
if err then return nil, nil, nil, err end
-- get server message
status, reply, err = %get_reply(sock)
code, line, err = %get_status(sock)
if err then return nil, nil, nil, err end
-- get url accordingly
if status == 200 then -- ok, go on and get it
mime, err = %get_mime(sock, {})
if err then return nil, nil, reply, err end
body, err = %get_body(sock, mime)
if err then return nil, mime, reply, err end
sock:close()
return body, mime, reply
elseif status == 301 then -- moved permanently, try again
mime = %get_mime(sock, {})
sock:close()
if mime["location"] then return http_get(mime["location"], headers)
else return nil, mime, reply end
elseif status == 401 then
mime, err = %get_mime(sock, {})
if err then return nil, nil, reply, err end
return nil, mime, reply
-- deal with reply
resp_hdrs, err = %get_headers(sock, {})
if err then return nil, nil, line, err end
-- get body if status and method allow one
if has_responsebody(method, code) then
resp_body, err = %get_body(sock, resp_hdrs)
if err then return nil, resp_hdrs, line, err end
end
return nil, nil, reply
sock:close()
-- should we automatically retry?
if (code == 301 or code == 302) then
if (method == "GET" or method == "HEAD") and resp_hdrs["location"] then
return http_request(method, resp_hdrs["location"], headers, body)
else return nil, resp_hdrs, line end
end
return resp_body, resp_hdrs, line
end
-----------------------------------------------------------------------------
-- Retrieves a URL by the method "GET"
-- Input
-- url: target uniform resource locator
-- headers: request headers to send
-- Returns
-- body: response message body, if successfull
-- headers: response header fields, if sucessfull
-- line: response status line, if successfull
-- err: error message, if any
-----------------------------------------------------------------------------
function http_get(url, headers)
return http_request("GET", url, headers)
end
-----------------------------------------------------------------------------
-- Retrieves a URL by the method "GET"
-- Input
-- url: target uniform resource locator
-- body: request message body
-- headers: request headers to send
-- Returns
-- body: response message body, if successfull
-- headers: response header fields, if sucessfull
-- line: response status line, if successfull
-- err: error message, if any
-----------------------------------------------------------------------------
function http_post(url, body, headers)
return http_request("POST", url, headers, body)
end