net/http/server.lua

   1
   2 local t_insert, t_remove, t_concat = table.insert, table.remove, table.concat;
   3 local parser_new = require "net.http.parser".new;
   4 local events = require "util.events".new();
   5 local addserver = require "net.server".addserver;
   6 local log = require "util.logger".init("http.server");
   7 local os_date = os.date;
   8 local pairs = pairs;
   9 local s_upper = string.upper;
  10 local setmetatable = setmetatable;
  11 local xpcall = xpcall;
  12 local debug = debug;
  13 local tostring = tostring;
  14 local codes = require "net.http.codes";
  15
  16 local _M = {};
  17
  18 local sessions = {};
  19 local listener = {};
  20 local hosts = {};
  21 local default_host;
  22
  23 local function is_wildcard_event(event)
  24         return event:sub(-2, -1) == "/*";
  25 end
  26 local function is_wildcard_match(wildcard_event, event)
  27         return wildcard_event:sub(1, -2) == event:sub(1, #wildcard_event-1);
  28 end
  29
  30 local event_map = events._event_map;
  31 setmetatable(events._handlers, {
  32         __index = function (handlers, curr_event)
  33                 if is_wildcard_event(curr_event) then return; end -- Wildcard events cannot be fired
  34                 -- Find all handlers that could match this event, sort them
  35                 -- and then put the array into handlers[curr_event] (and return it)
  36                 local matching_handlers_set = {};
  37                 local handlers_array = {};
  38                 for event, handlers_set in pairs(event_map) do
  39                         if event == curr_event or
  40                         is_wildcard_event(event) and is_wildcard_match(event, curr_event) then
  41                                 for handler, priority in pairs(handlers_set) do
  42                                         matching_handlers_set[handler] = { (select(2, event:gsub("/", "%1"))), is_wildcard_event(event) and 0 or 1, priority };
  43                                         table.insert(handlers_array, handler);
  44                                 end
  45                         end
  46                 end
  47                 if #handlers_array > 0 then
  48                         table.sort(handlers_array, function(b, a)
  49                                 local a_score, b_score = matching_handlers_set[a], matching_handlers_set[b];
  50                                 for i = 1, #a_score do
  51                                         if a_score[i] ~= b_score[i] then -- If equal, compare next score value
  52                                                 return a_score[i] < b_score[i];
  53                                         end
  54                                 end
  55                                 return false;
  56                         end);
  57                 else
  58                         handlers_array = false;
  59                 end
  60                 rawset(handlers, curr_event, handlers_array);
  61                 return handlers_array;
  62         end;
  63         __newindex = function (handlers, curr_event, handlers_array)
  64                 if handlers_array == nil
  65                 and is_wildcard_event(curr_event) then
  66                         -- Invalidate the indexes of all matching events
  67                         for event in pairs(handlers) do
  68                                 if is_wildcard_match(curr_event, event) then
  69                                         handlers[event] = nil;
  70                                 end
  71                         end
  72                 end
  73                 rawset(handlers, curr_event, handlers_array);
  74         end;
  75 });
  76
  77 local handle_request;
  78 local _1, _2, _3;
  79 local function _handle_request() return handle_request(_1, _2, _3); end
  80
  81 local last_err;
  82 local function _traceback_handler(err) last_err = err; log("error", "Traceback[http]: %s: %s", tostring(err), debug.traceback()); end
  83 events.add_handler("http-error", function (error)
  84         return "Error processing request: "..codes[error.code]..". Check your error log for more information.";
  85 end, -1);
  86
  87 function listener.onconnect(conn)
  88         local secure = conn:ssl() and true or nil;
  89         local pending = {};
  90         local waiting = false;
  91         local function process_next()
  92                 if waiting then log("debug", "can't process_next, waiting"); return; end
  93                 waiting = true;
  94                 while sessions[conn] and #pending > 0 do
  95                         local request = t_remove(pending);
  96                         --log("debug", "process_next: %s", request.path);
  97                         --handle_request(conn, request, process_next);
  98                         _1, _2, _3 = conn, request, process_next;
  99                         if not xpcall(_handle_request, _traceback_handler) then
 100                                 conn:write("HTTP/1.0 500 Internal Server Error\r\n\r\n"..events.fire_event("http-error", { code = 500, private_message = last_err }));
 101                                 conn:close();
 102                         end
 103                 end
 104                 --log("debug", "ready for more");
 105                 waiting = false;
 106         end
 107         local function success_cb(request)
 108                 --log("debug", "success_cb: %s", request.path);
 109                 if waiting then
 110                         log("error", "http connection handler is not reentrant: %s", request.path);
 111                         assert(false, "http connection handler is not reentrant");
 112                 end
 113                 request.secure = secure;
 114                 t_insert(pending, request);
 115                 process_next();
 116         end
 117         local function error_cb(err)
 118                 log("debug", "error_cb: %s", err or "<nil>");
 119                 -- FIXME don't close immediately, wait until we process current stuff
 120                 -- FIXME if err, send off a bad-request response
 121                 sessions[conn] = nil;
 122                 conn:close();
 123         end
 124         sessions[conn] = parser_new(success_cb, error_cb);
 125 end
 126
 127 function listener.ondisconnect(conn)
 128         local open_response = conn._http_open_response;
 129         if open_response and open_response.on_destroy then
 130                 open_response.finished = true;
 131                 open_response:on_destroy();
 132         end
 133         sessions[conn] = nil;
 134 end
 135
 136 function listener.onincoming(conn, data)
 137         sessions[conn]:feed(data);
 138 end
 139
 140 local headerfix = setmetatable({}, {
 141         __index = function(t, k)
 142                 local v = "\r\n"..k:gsub("_", "-"):gsub("%f[%w].", s_upper)..": ";
 143                 t[k] = v;
 144                 return v;
 145         end
 146 });
 147
 148 function _M.hijack_response(response, listener)
 149         error("TODO");
 150 end
 151 function handle_request(conn, request, finish_cb)
 152         --log("debug", "handler: %s", request.path);
 153         local headers = {};
 154         for k,v in pairs(request.headers) do headers[k:gsub("-", "_")] = v; end
 155         request.headers = headers;
 156         request.conn = conn;
 157
 158         local date_header = os_date('!%a, %d %b %Y %H:%M:%S GMT'); -- FIXME use
 159         local conn_header = request.headers.connection;
 160         conn_header = conn_header and ","..conn_header:gsub("[ \t]", ""):lower().."," or ""
 161         local httpversion = request.httpversion
 162         local persistent = conn_header:find(",keep-alive,", 1, true)
 163                 or (httpversion == "1.1" and not conn_header:find(",close,", 1, true));
 164
 165         local response_conn_header;
 166         if persistent then
 167                 response_conn_header = "Keep-Alive";
 168         else
 169                 response_conn_header = httpversion == "1.1" and "close" or nil
 170         end
 171
 172         local response = {
 173                 request = request;
 174                 status_code = 200;
 175                 headers = { date = date_header, connection = response_conn_header };
 176                 persistent = persistent;
 177                 conn = conn;
 178                 send = _M.send_response;
 179                 finish_cb = finish_cb;
 180         };
 181         conn._http_open_response = response;
 182
 183         local host = (request.headers.host or ""):match("[^:]+");
 184
 185         -- Some sanity checking
 186         local err_code, err;
 187         if not request.path then
 188                 err_code, err = 400, "Invalid path";
 189         elseif not hosts[host] then
 190                 if hosts[default_host] then
 191                         host = default_host;
 192                 elseif host then
 193                         err_code, err = 404, "Unknown host: "..host;
 194                 else
 195                         err_code, err = 400, "Missing or invalid 'Host' header";
 196                 end
 197         end
 198
 199         if err then
 200                 response.status_code = err_code;
 201                 response:send(events.fire_event("http-error", { code = err_code, message = err }));
 202                 return;
 203         end
 204
 205         local event = request.method.." "..host..request.path:match("[^?]*");
 206         local payload = { request = request, response = response };
 207         --log("debug", "Firing event: %s", event);
 208         local result = events.fire_event(event, payload);
 209         if result ~= nil then
 210                 if result ~= true then
 211                         local body;
 212                         local result_type = type(result);
 213                         if result_type == "number" then
 214                                 response.status_code = result;
 215                                 if result >= 400 then
 216                                         body = events.fire_event("http-error", { code = result });
 217                                 end
 218                         elseif result_type == "string" then
 219                                 body = result;
 220                         elseif result_type == "table" then
 221                                 for k, v in pairs(result) do
 222                                         response[k] = v;
 223                                 end
 224                         end
 225                         response:send(body);
 226                 end
 227                 return;
 228         end
 229
 230         -- if handler not called, return 404
 231         response.status_code = 404;
 232         response:send(events.fire_event("http-error", { code = 404 }));
 233 end
 234 function _M.send_response(response, body)
 235         if response.finished then return; end
 236         response.finished = true;
 237         response.conn._http_open_response = nil;
 238
 239         local status_line = "HTTP/"..response.request.httpversion.." "..(response.status or codes[response.status_code]);
 240         local headers = response.headers;
 241         body = body or response.body or "";
 242         headers.content_length = #body;
 243
 244         local output = { status_line };
 245         for k,v in pairs(headers) do
 246                 t_insert(output, headerfix[k]..v);
 247         end
 248         t_insert(output, "\r\n\r\n");
 249         t_insert(output, body);
 250
 251         response.conn:write(t_concat(output));
 252         if response.on_destroy then
 253                 response:on_destroy();
 254                 response.on_destroy = nil;
 255         end
 256         if response.persistent then
 257                 response:finish_cb();
 258         else
 259                 response.conn:close();
 260         end
 261 end
 262 function _M.add_handler(event, handler, priority)
 263         events.add_handler(event, handler, priority);
 264 end
 265 function _M.remove_handler(event, handler)
 266         events.remove_handler(event, handler);
 267 end
 268
 269 function _M.listen_on(port, interface, ssl)
 270         addserver(interface or "*", port, listener, "*a", ssl);
 271 end
 272 function _M.add_host(host)
 273         hosts[host] = true;
 274 end
 275 function _M.remove_host(host)
 276         hosts[host] = nil;
 277 end
 278 function _M.set_default_host(host)
 279         default_host = host;
 280 end
 281
 282 _M.listener = listener;
 283 _M.codes = codes;
 284 _M._events = events;
 285 return _M;