From 1fb0452d0cd7d6a9b534c58477447bd672cc76cd Mon Sep 17 00:00:00 2001 From: Matthew Wild Date: Tue, 16 Dec 2008 02:32:01 +0000 Subject: Protect loading of connlisteners, to catch errors --- net/connlisteners.lua | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'net') diff --git a/net/connlisteners.lua b/net/connlisteners.lua index 8c9b163f..f027dfeb 100644 --- a/net/connlisteners.lua +++ b/net/connlisteners.lua @@ -47,7 +47,8 @@ end function get(name) local h = listeners[name]; if not h then - pcall(dofile, listeners_dir..name:gsub("[^%w%-]", "_").."_listener.lua"); + local ok, ret = pcall(dofile, listeners_dir..name:gsub("[^%w%-]", "_").."_listener.lua"); + if not ok then return nil, ret; end h = listeners[name]; end return h; -- cgit v1.2.3 From 85e074d8b858f72fb7d22079d0d47720e20b40fe Mon Sep 17 00:00:00 2001 From: Matthew Wild Date: Tue, 16 Dec 2008 02:33:08 +0000 Subject: Change xmlhandlers to match stream opening tag with ns+tag --- net/xmppclient_listener.lua | 2 +- net/xmppserver_listener.lua | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'net') diff --git a/net/xmppclient_listener.lua b/net/xmppclient_listener.lua index 50b8aa93..357516e9 100644 --- a/net/xmppclient_listener.lua +++ b/net/xmppclient_listener.lua @@ -36,7 +36,7 @@ local sm_streamopened = sessionmanager.streamopened; local sm_streamclosed = sessionmanager.streamclosed; local st = stanza; -local stream_callbacks = { ns = "http://etherx.jabber.org/streams", streamopened = sm_streamopened, streamclosed = sm_streamclosed, handlestanza = core_process_stanza }; +local stream_callbacks = { stream_tag = "http://etherx.jabber.org/streams|stream", streamopened = sm_streamopened, streamclosed = sm_streamclosed, handlestanza = core_process_stanza }; function stream_callbacks.error(session, error, data) if error == "no-stream" then diff --git a/net/xmppserver_listener.lua b/net/xmppserver_listener.lua index 4d4349aa..36b4c476 100644 --- a/net/xmppserver_listener.lua +++ b/net/xmppserver_listener.lua @@ -28,7 +28,7 @@ local s2s_streamopened = require "core.s2smanager".streamopened; local s2s_streamclosed = require "core.s2smanager".streamclosed; local s2s_destroy_session = require "core.s2smanager".destroy_session; local s2s_attempt_connect = require "core.s2smanager".attempt_connection; -local stream_callbacks = { ns = "http://etherx.jabber.org/streams", streamopened = s2s_streamopened, streamclosed = s2s_streamclosed, handlestanza = core_process_stanza }; +local stream_callbacks = { stream_tag = "http://etherx.jabber.org/streams|stream", streamopened = s2s_streamopened, streamclosed = s2s_streamclosed, handlestanza = core_process_stanza }; function stream_callbacks.error(session, error, data) if error == "no-stream" then -- cgit v1.2.3 From b922b642ef7b91179e616b0bf1415573204d21b1 Mon Sep 17 00:00:00 2001 From: Matthew Wild Date: Thu, 18 Dec 2008 20:01:09 +0000 Subject: Fix data loss when closing connection with a large write queue. Thanks albert :) --- net/server.lua | 54 ++++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 48 insertions(+), 6 deletions(-) (limited to 'net') diff --git a/net/server.lua b/net/server.lua index 4e5ec366..68fa5be3 100644 --- a/net/server.lua +++ b/net/server.lua @@ -37,6 +37,7 @@ local coroutine_wrap = coroutine.wrap local coroutine_yield = coroutine.yield local print = print; local out_put = function () end --print; +local out_put = print; local out_error = print; --// extern libs //-- @@ -100,6 +101,8 @@ wrapserver = function( listener, socket, ip, serverport, mode, sslctx ) -- th local wrapclient, err + out_put("Starting a new server on "..tostring(serverport).." with ssl: "..tostring(sslctx)); + if sslctx then if not ssl_newcontext then return nil, "luasec not found" @@ -188,7 +191,7 @@ wrapsslclient = function( listener, socket, ip, serverport, clientport, mode, ss local writequeue = { } -- buffer for messages to send - local eol, fatal_send_error -- end of buffer + local eol, fatal_send_error, wants_closing local sstat, rstat = 0, 0 @@ -223,7 +226,17 @@ wrapsslclient = function( listener, socket, ip, serverport, clientport, mode, ss --return shutdown( socket, pattern ) end handler.close = function( closed ) - if eol and not fatal_send_error then handler._dispatchdata(); end + if eol and not fatal_send_error then + -- There is data in the buffer, and we haven't experienced + -- an error trying to send yet, so we'll flush the buffer now + handler._dispatchdata(); + if eol then + -- and there is *still* data in the buffer + -- we'll give up for now, and close later + wants_closing = true; + return; + end + end close( socket ) writelen = ( eol and removesocket( writelist, socket, writelen ) ) or writelen readlen = removesocket( readlist, socket, readlen ) @@ -287,6 +300,9 @@ wrapsslclient = function( listener, socket, ip, serverport, clientport, mode, ss --writequeue = { } eol = nil writelen = removesocket( writelist, socket, writelen ) -- delete socket from writelist + if wants_closing then + handler.close(); + end return true elseif byte and ( err == "timeout" or err == "wantwrite" ) then -- want write buffer = string_sub( buffer, byte + 1, -1 ) -- new buffer @@ -368,7 +384,7 @@ wraptlsclient = function( listener, socket, ip, serverport, clientport, mode, ss local writequeue = { } -- buffer for messages to send - local eol, fatal_send_error -- end of buffer + local eol, fatal_send_error, wants_closing local sstat, rstat = 0, 0 @@ -403,7 +419,17 @@ wraptlsclient = function( listener, socket, ip, serverport, clientport, mode, ss --return shutdown( socket, pattern ) end handler.close = function( closed ) - if eol and not fatal_send_error then handler._dispatchdata(); end + if eol and not fatal_send_error then + -- There is data in the buffer, and we haven't experienced + -- an error trying to send yet, so we'll flush the buffer now + handler._dispatchdata(); + if eol then + -- and there is *still* data in the buffer + -- we'll give up for now, and close later + wants_closing = true; + return; + end + end close( socket ) writelen = ( eol and removesocket( writelist, socket, writelen ) ) or writelen readlen = removesocket( readlist, socket, readlen ) @@ -471,6 +497,9 @@ wraptlsclient = function( listener, socket, ip, serverport, clientport, mode, ss out_put("server.lua: connection is ready for tls handshake"); handler.starttls(true); end + if wants_closing then + handler.close(); + end return true elseif byte and ( err == "timeout" or err == "wantwrite" ) then -- want write buffer = string_sub( buffer, byte + 1, -1 ) -- new buffer @@ -585,7 +614,7 @@ wraptcpclient = function( listener, socket, ip, serverport, clientport, mode ) local writequeue = { } -- list for messages to send - local eol, fatal_send_error + local eol, fatal_send_error, wants_closing socket:settimeout(0); @@ -622,7 +651,17 @@ wraptcpclient = function( listener, socket, ip, serverport, clientport, mode ) return shutdown( socket, pattern ) end handler.close = function( closed ) - if eol and not fatal_send_error then handler.dispatchdata(); end + if eol and not fatal_send_error then + -- There is data in the buffer, and we haven't experienced + -- an error trying to send yet, so we'll flush the buffer now + handler.dispatchdata(); + if eol then + -- and there is *still* data in the buffer + -- we'll give up for now, and close later + wants_closing = true; + return; + end + end _ = not closed and shutdown( socket ) _ = not closed and close( socket ) writelen = ( eol and removesocket( writelist, socket, writelen ) ) or writelen @@ -688,6 +727,9 @@ wraptcpclient = function( listener, socket, ip, serverport, clientport, mode ) --writequeue = { } eol = nil writelen = removesocket( writelist, socket, writelen ) -- delete socket from writelist + if wants_closing then + handler.close(); + end return true elseif byte and ( err == "timeout" or err == "wantwrite" ) then -- want write buffer = string_sub( buffer, byte + 1, -1 ) -- new buffer -- cgit v1.2.3 From 97c4dc41bd6579d9aa216037263c1792f6f1e0c7 Mon Sep 17 00:00:00 2001 From: Matthew Wild Date: Mon, 22 Dec 2008 22:01:49 +0000 Subject: Fix nil status code for http request callbacks --- net/http.lua | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'net') diff --git a/net/http.lua b/net/http.lua index a661bb52..00949901 100644 --- a/net/http.lua +++ b/net/http.lua @@ -81,7 +81,7 @@ local function request_reader(request, data, startpos) return request.callback(0, "invalid-status-line", request); end - request.responsecode, request.responseversion = code, http; + request.code, request.responseversion = code, http; if request.onlystatus or not expectbody(request, tonumber(code)) then if request.callback then -- cgit v1.2.3 From 6f71936ac346872a130df634323e6f7ceb7240ea Mon Sep 17 00:00:00 2001 From: Matthew Wild Date: Mon, 22 Dec 2008 22:12:11 +0000 Subject: Adding initial net.httpserver (lots of work to do on it) --- net/httpserver.lua | 250 ++++++++++++++++++++++++++++++++++++++++++++ net/httpserver_listener.lua | 33 ++++++ 2 files changed, 283 insertions(+) create mode 100644 net/httpserver.lua create mode 100644 net/httpserver_listener.lua (limited to 'net') diff --git a/net/httpserver.lua b/net/httpserver.lua new file mode 100644 index 00000000..3a3c34b4 --- /dev/null +++ b/net/httpserver.lua @@ -0,0 +1,250 @@ + +local socket = require "socket" +local server = require "net.server" +local url_parse = require "socket.url".parse; + +local connlisteners_start = require "net.connlisteners".start; +local connlisteners_get = require "net.connlisteners".get; +local listener; + +local t_insert, t_concat = table.insert, table.concat; +local s_match, s_gmatch = string.match, string.gmatch; +local tonumber, tostring, pairs = tonumber, tostring, pairs; + +local urlcodes = setmetatable({}, { __index = function (t, k) t[k] = char(tonumber("0x"..k)); return t[k]; end }); +local urlencode = function (s) return s and (s:gsub("%W", function (c) return string.format("%%%x", c:byte()); end)); end + +local log = require "util.logger".init("httpserver"); + +local http_servers = {}; + +module "httpserver" + +local default_handler; + +local function expectbody(reqt) + return reqt.method == "POST"; +end + +local function send_response(request, response) + -- Write status line + local resp; + if response.body then + log("debug", "Sending response to %s: %s", request.id, response.body); + resp = { "HTTP/1.0 ", response.status or "200 OK", "\r\n"}; + local h = response.headers; + if h then + for k, v in pairs(h) do + t_insert(resp, k); + t_insert(resp, ": "); + t_insert(resp, v); + t_insert(resp, "\r\n"); + end + end + if response.body and not (h and h["Content-Length"]) then + t_insert(resp, "Content-Length: "); + t_insert(resp, #response.body); + t_insert(resp, "\r\n"); + end + t_insert(resp, "\r\n"); + + if response.body and request.method ~= "HEAD" then + t_insert(resp, response.body); + end + else + -- Response we have is just a string (the body) + log("debug", "Sending response to %s: %s", request.id, response); + + resp = { "HTTP/1.0 200 OK\r\n" }; + t_insert(resp, "Connection: close\r\n"); + t_insert(resp, "Content-Length: "); + t_insert(resp, #response); + t_insert(resp, "\r\n\r\n"); + + t_insert(resp, response); + end + request.write(t_concat(resp)); + if not request.stayopen then + request:destroy(); + end +end + +local function call_callback(request, err) + if request.handled then return; end + request.handled = true; + local callback = request.callback; + if not callback and request.path then + local path = request.url.path; + local base = path:match("^/([^/?]+)"); + if not base then + base = path:match("^http://[^/?]+/([^/?]+)"); + end + + callback = (request.server and request.server.handlers[base]) or default_handler; + if callback == default_handler then + log("debug", "Default callback for this request (base: "..tostring(base)..")") + end + end + if callback then + if err then + log("debug", "Request error: "..err); + if not callback(nil, err, request) then + destroy_request(request); + end + return; + end + + local response = callback(request.method, request.body and t_concat(request.body), request); + if response then + if response == true then + -- Keep connection open, we will reply later + log("warn", "Request %s left open, on_destroy is %s", request.id, tostring(request.on_destroy)); + else + -- Assume response + send_response(request, response); + destroy_request(request); + end + else + log("debug", "Request handler provided no response, destroying request..."); + -- No response, close connection + destroy_request(request); + end + end +end + +local function request_reader(request, data, startpos) + if not data then + if request.body then + call_callback(request); + else + -- Error.. connection was closed prematurely + call_callback(request, "connection-closed"); + end + -- Here we force a destroy... the connection is gone, so we can't reply later + destroy_request(request); + return; + end + if request.state == "body" then + log("debug", "Reading body...") + if not request.body then request.body = {}; request.havebodylength, request.bodylength = 0, tonumber(request.responseheaders["content-length"]); end + if startpos then + data = data:sub(startpos, -1) + end + t_insert(request.body, data); + if request.bodylength then + request.havebodylength = request.havebodylength + #data; + if request.havebodylength >= request.bodylength then + -- We have the body + call_callback(request); + end + end + elseif request.state == "headers" then + log("debug", "Reading headers...") + local pos = startpos; + local headers = request.responseheaders or {}; + for line in data:gmatch("(.-)\r\n") do + startpos = (startpos or 1) + #line + 2; + local k, v = line:match("(%S+): (.+)"); + if k and v then + headers[k:lower()] = v; +-- log("debug", "Header: "..k:lower().." = "..v); + elseif #line == 0 then + request.responseheaders = headers; + break; + else + log("debug", "Unhandled header line: "..line); + end + end + + if not expectbody(request) then + call_callback(request); + return; + end + + -- Reached the end of the headers + request.state = "body"; + if #data > startpos then + return request_reader(request, data:sub(startpos, -1)); + end + elseif request.state == "request" then + log("debug", "Reading request line...") + local method, path, http, linelen = data:match("^(%S+) (%S+) HTTP/(%S+)\r\n()", startpos); + if not method then + return call_callback(request, "invalid-status-line"); + end + + request.method, request.path, request.httpversion = method, path, http; + + request.url = url_parse(request.path); + + log("debug", method.." request for "..tostring(request.path) .. " on port "..request.handler.serverport()); + + if request.onlystatus then + if not call_callback(request) then + return; + end + end + + request.state = "headers"; + + if #data > linelen then + return request_reader(request, data:sub(linelen, -1)); + end + end +end + +-- The default handler for requests +default_handler = function (method, body, request) + log("debug", method.." request for "..tostring(request.path) .. " on port "..request.handler.serverport()); + return { status = "404 Not Found", + headers = { ["Content-Type"] = "text/html" }, + body = "Page Not FoundNot here :(" }; +end + + +function new_request(handler) + return { handler = handler, conn = handler.socket, + write = handler.write, state = "request", + server = http_servers[handler.serverport()], + send = send_response, + destroy = destroy_request, + id = tostring{}:match("%x+$") + }; +end + +function destroy_request(request) + log("debug", "Destroying request %s", request.id); + listener = listener or connlisteners_get("httpserver"); + if not request.destroyed then + request.destroyed = true; + if request.on_destroy then + log("debug", "Request has destroy callback"); + request.on_destroy(request); + else + log("debug", "Request has no destroy callback"); + end + request.handler.close() + if request.conn then + listener.disconnect(request.conn, "closed"); + end + end +end + +function new(params) + local http_server = http_servers[params.port]; + if not http_server then + http_server = { handlers = {} }; + http_servers[params.port] = http_server; + -- We weren't already listening on this port, so start now + connlisteners_start("httpserver", params); + end + if params.base then + http_server.handlers[params.base] = params.handler; + end +end + +_M.request_reader = request_reader; +_M.send_response = send_response; +_M.urlencode = urlencode; + +return _M; diff --git a/net/httpserver_listener.lua b/net/httpserver_listener.lua new file mode 100644 index 00000000..f7fb7f4e --- /dev/null +++ b/net/httpserver_listener.lua @@ -0,0 +1,33 @@ + + +local connlisteners_register = require "net.connlisteners".register; +local new_request = require "net.httpserver".new_request; +local request_reader = require "net.httpserver".request_reader; + +local requests = {}; -- Open requests + +local httpserver = { default_port = 80, default_mode = "*a" }; + +function httpserver.listener(conn, data) + local request = requests[conn]; + + if not request then + request = new_request(conn); + requests[conn] = request; + end + + if data then + request_reader(request, data); + end +end + +function httpserver.disconnect(conn, err) + local request = requests[conn]; + if request and not request.destroyed then + request.conn = nil; + request_reader(request, nil); + end + requests[conn] = nil; +end + +connlisteners_register("httpserver", httpserver); -- cgit v1.2.3