prosody
73f7acf8a61f
net/http/server.lua

Find changesets by keywords by author, files, the commit message, revision number or hash, or revset expression.

Software / code / prosody

Annotate

net/http/server.lua @ 11371:73f7acf8a61f

net.http.server: Enable async during HTTP request handling (fixes #1487)
author Kim Alvefur <zash@zash.se>
date Sun, 12 Jul 2020 20:31:31 +0200
parent 11160:e9eeaefa09a7
child 11372:b877bd74d65e
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
1
11371
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
2 local t_insert, t_concat = table.insert, table.concat;
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
3 local parser_new = require "net.http.parser".new;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
4 local events = require "util.events".new();
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
5 local addserver = require "net.server".addserver;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
6 local log = require "util.logger".init("http.server");
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
7 local os_date = os.date;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
8 local pairs = pairs;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
9 local s_upper = string.upper;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
10 local setmetatable = setmetatable;
6963
e3be91ccca05 net.http.server: Import util.cache
Matthew Wild <mwild1@gmail.com>
parents: 6950
diff changeset
11 local cache = require "util.cache";
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
12 local codes = require "net.http.codes";
10395
faa4fcc78b14 net.http.server: Handle promises from http handlers
Kim Alvefur <zash@zash.se>
parents: 10394
diff changeset
13 local promise = require "util.promise";
10394
955e54e451dc net.http.server: Handle util.error objects from http handlers
Kim Alvefur <zash@zash.se>
parents: 10393
diff changeset
14 local errors = require "util.error";
7541
1d3f9da189b5 net.http.server: Set blocksize for serving data from FDs to 64k (sweet spot of efficiency according to a recent study)
Kim Alvefur <zash@zash.se>
parents: 7489
diff changeset
15 local blocksize = 2^16;
11371
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
16 local async = require "util.async";
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
17
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
18 local _M = {};
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
19
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
20 local sessions = {};
7489
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
21 local incomplete = {};
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
22 local listener = {};
4736
3514338c59c3 net.http.server, mod_http: Support http_default_host config option to specify where to direct requests for unknown HTTP vhosts
Matthew Wild <mwild1@gmail.com>
parents: 4735
diff changeset
23 local hosts = {};
3514338c59c3 net.http.server, mod_http: Support http_default_host config option to specify where to direct requests for unknown HTTP vhosts
Matthew Wild <mwild1@gmail.com>
parents: 4735
diff changeset
24 local default_host;
7579
d430573fe9f8 net.http.server: Expose way to set http server options
Kim Alvefur <zash@zash.se>
parents: 6589
diff changeset
25 local options = {};
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
26
4668
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
27 local function is_wildcard_event(event)
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
28 return event:sub(-2, -1) == "/*";
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
29 end
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
30 local function is_wildcard_match(wildcard_event, event)
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
31 return wildcard_event:sub(1, -2) == event:sub(1, #wildcard_event-1);
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
32 end
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
33
6950
8ab809358922 net.http.server: Use new util.cache to remember wildcard event handlers
Matthew Wild <mwild1@gmail.com>
parents: 6608
diff changeset
34 local _handlers = events._handlers;
7582
e080b8b4f3cb net.http.server: Add luacheck annotations
Kim Alvefur <zash@zash.se>
parents: 7581
diff changeset
35 local recent_wildcard_events = cache.new(10000, function (key, value) -- luacheck: ignore 212/value
6950
8ab809358922 net.http.server: Use new util.cache to remember wildcard event handlers
Matthew Wild <mwild1@gmail.com>
parents: 6608
diff changeset
36 rawset(_handlers, key, nil);
8ab809358922 net.http.server: Use new util.cache to remember wildcard event handlers
Matthew Wild <mwild1@gmail.com>
parents: 6608
diff changeset
37 end);
5503
91052e59375c net.server.http: Ensure that event map cannot grow forever (limit to 10K wildcard-only entries)
Matthew Wild <mwild1@gmail.com>
parents: 5487
diff changeset
38
4668
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
39 local event_map = events._event_map;
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
40 setmetatable(events._handlers, {
5504
b760b5f0c2b0 net.server.http: Add a comment
Matthew Wild <mwild1@gmail.com>
parents: 5503
diff changeset
41 -- Called when firing an event that doesn't exist (but may match a wildcard handler)
4668
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
42 __index = function (handlers, curr_event)
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
43 if is_wildcard_event(curr_event) then return; end -- Wildcard events cannot be fired
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
44 -- Find all handlers that could match this event, sort them
4689
e8c357259993 net.http.server: Small fix to comment
Matthew Wild <mwild1@gmail.com>
parents: 4688
diff changeset
45 -- and then put the array into handlers[curr_event] (and return it)
4668
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
46 local matching_handlers_set = {};
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
47 local handlers_array = {};
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
48 for event, handlers_set in pairs(event_map) do
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
49 if event == curr_event or
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
50 is_wildcard_event(event) and is_wildcard_match(event, curr_event) then
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
51 for handler, priority in pairs(handlers_set) do
4704
d6c4e58333cf net.http.server: Lower score of wildcard handlers to ensure specific handlers beat them
Matthew Wild <mwild1@gmail.com>
parents: 4694
diff changeset
52 matching_handlers_set[handler] = { (select(2, event:gsub("/", "%1"))), is_wildcard_event(event) and 0 or 1, priority };
4668
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
53 table.insert(handlers_array, handler);
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
54 end
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
55 end
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
56 end
4726
917a5ffb73f1 net.http.server: Correctly cache results of handler indexing, and also cache failures
Matthew Wild <mwild1@gmail.com>
parents: 4715
diff changeset
57 if #handlers_array > 0 then
917a5ffb73f1 net.http.server: Correctly cache results of handler indexing, and also cache failures
Matthew Wild <mwild1@gmail.com>
parents: 4715
diff changeset
58 table.sort(handlers_array, function(b, a)
917a5ffb73f1 net.http.server: Correctly cache results of handler indexing, and also cache failures
Matthew Wild <mwild1@gmail.com>
parents: 4715
diff changeset
59 local a_score, b_score = matching_handlers_set[a], matching_handlers_set[b];
917a5ffb73f1 net.http.server: Correctly cache results of handler indexing, and also cache failures
Matthew Wild <mwild1@gmail.com>
parents: 4715
diff changeset
60 for i = 1, #a_score do
917a5ffb73f1 net.http.server: Correctly cache results of handler indexing, and also cache failures
Matthew Wild <mwild1@gmail.com>
parents: 4715
diff changeset
61 if a_score[i] ~= b_score[i] then -- If equal, compare next score value
917a5ffb73f1 net.http.server: Correctly cache results of handler indexing, and also cache failures
Matthew Wild <mwild1@gmail.com>
parents: 4715
diff changeset
62 return a_score[i] < b_score[i];
917a5ffb73f1 net.http.server: Correctly cache results of handler indexing, and also cache failures
Matthew Wild <mwild1@gmail.com>
parents: 4715
diff changeset
63 end
4668
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
64 end
4726
917a5ffb73f1 net.http.server: Correctly cache results of handler indexing, and also cache failures
Matthew Wild <mwild1@gmail.com>
parents: 4715
diff changeset
65 return false;
917a5ffb73f1 net.http.server: Correctly cache results of handler indexing, and also cache failures
Matthew Wild <mwild1@gmail.com>
parents: 4715
diff changeset
66 end);
917a5ffb73f1 net.http.server: Correctly cache results of handler indexing, and also cache failures
Matthew Wild <mwild1@gmail.com>
parents: 4715
diff changeset
67 else
917a5ffb73f1 net.http.server: Correctly cache results of handler indexing, and also cache failures
Matthew Wild <mwild1@gmail.com>
parents: 4715
diff changeset
68 handlers_array = false;
917a5ffb73f1 net.http.server: Correctly cache results of handler indexing, and also cache failures
Matthew Wild <mwild1@gmail.com>
parents: 4715
diff changeset
69 end
917a5ffb73f1 net.http.server: Correctly cache results of handler indexing, and also cache failures
Matthew Wild <mwild1@gmail.com>
parents: 4715
diff changeset
70 rawset(handlers, curr_event, handlers_array);
5503
91052e59375c net.server.http: Ensure that event map cannot grow forever (limit to 10K wildcard-only entries)
Matthew Wild <mwild1@gmail.com>
parents: 5487
diff changeset
71 if not event_map[curr_event] then -- Only wildcard handlers match, if any
6950
8ab809358922 net.http.server: Use new util.cache to remember wildcard event handlers
Matthew Wild <mwild1@gmail.com>
parents: 6608
diff changeset
72 recent_wildcard_events:set(curr_event, true);
5503
91052e59375c net.server.http: Ensure that event map cannot grow forever (limit to 10K wildcard-only entries)
Matthew Wild <mwild1@gmail.com>
parents: 5487
diff changeset
73 end
4668
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
74 return handlers_array;
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
75 end;
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
76 __newindex = function (handlers, curr_event, handlers_array)
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
77 if handlers_array == nil
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
78 and is_wildcard_event(curr_event) then
4735
474166c08319 net.http.server: Improve comment
Matthew Wild <mwild1@gmail.com>
parents: 4727
diff changeset
79 -- Invalidate the indexes of all matching events
4668
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
80 for event in pairs(handlers) do
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
81 if is_wildcard_match(curr_event, event) then
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
82 handlers[event] = nil;
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
83 end
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
84 end
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
85 end
4726
917a5ffb73f1 net.http.server: Correctly cache results of handler indexing, and also cache failures
Matthew Wild <mwild1@gmail.com>
parents: 4715
diff changeset
86 rawset(handlers, curr_event, handlers_array);
4668
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
87 end;
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
88 });
cce0c739b0d7 net.http.server: Support for wildcard events (events that end with '/*')
Matthew Wild <mwild1@gmail.com>
parents: 4659
diff changeset
89
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
90 local handle_request;
4710
54ca6511e699 net.http.server: Make error handling overrideable via 'http-error' event
Matthew Wild <mwild1@gmail.com>
parents: 4709
diff changeset
91
54ca6511e699 net.http.server: Make error handling overrideable via 'http-error' event
Matthew Wild <mwild1@gmail.com>
parents: 4709
diff changeset
92 events.add_handler("http-error", function (error)
54ca6511e699 net.http.server: Make error handling overrideable via 'http-error' event
Matthew Wild <mwild1@gmail.com>
parents: 4709
diff changeset
93 return "Error processing request: "..codes[error.code]..". Check your error log for more information.";
54ca6511e699 net.http.server: Make error handling overrideable via 'http-error' event
Matthew Wild <mwild1@gmail.com>
parents: 4709
diff changeset
94 end, -1);
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
95
11371
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
96 local runner_callbacks = {};
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
97
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
98 function runner_callbacks:ready()
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
99 self.data:resume();
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
100 end
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
101
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
102 function runner_callbacks:waiting()
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
103 self.data:pause();
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
104 end
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
105
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
106 function runner_callbacks:error(err)
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
107 log("error", "Traceback[httpserver]: %s", err);
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
108 self.data:write("HTTP/1.0 500 Internal Server Error\r\n\r\n"..events.fire_event("http-error", { code = 500, private_message = err }));
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
109 self.data:close();
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
110 end
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
111
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
112 function listener.onconnect(conn)
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
113 local secure = conn:ssl() and true or nil;
11371
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
114 conn._thread = async.runner(function (request)
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
115 local wait, done = async.waiter();
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
116 handle_request(conn, request, done); wait();
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
117 end, runner_callbacks, conn);
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
118 local function success_cb(request)
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
119 --log("debug", "success_cb: %s", request.path);
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
120 request.secure = secure;
11371
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
121 conn._thread:run(request);
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
122 end
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
123 local function error_cb(err)
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
124 log("debug", "error_cb: %s", err or "<nil>");
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
125 -- FIXME don't close immediately, wait until we process current stuff
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
126 -- FIXME if err, send off a bad-request response
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
127 sessions[conn] = nil;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
128 conn:close();
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
129 end
7579
d430573fe9f8 net.http.server: Expose way to set http server options
Kim Alvefur <zash@zash.se>
parents: 6589
diff changeset
130 local function options_cb()
d430573fe9f8 net.http.server: Expose way to set http server options
Kim Alvefur <zash@zash.se>
parents: 6589
diff changeset
131 return options;
d430573fe9f8 net.http.server: Expose way to set http server options
Kim Alvefur <zash@zash.se>
parents: 6589
diff changeset
132 end
d430573fe9f8 net.http.server: Expose way to set http server options
Kim Alvefur <zash@zash.se>
parents: 6589
diff changeset
133 sessions[conn] = parser_new(success_cb, error_cb, "server", options_cb);
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
134 end
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
135
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
136 function listener.ondisconnect(conn)
4691
a164fc7057ae net.http.server: Support for on_destroy callback on response objects, and a 'finished' flag to say when they are destroyed (responded to or connection closed)
Matthew Wild <mwild1@gmail.com>
parents: 4689
diff changeset
137 local open_response = conn._http_open_response;
a164fc7057ae net.http.server: Support for on_destroy callback on response objects, and a 'finished' flag to say when they are destroyed (responded to or connection closed)
Matthew Wild <mwild1@gmail.com>
parents: 4689
diff changeset
138 if open_response and open_response.on_destroy then
a164fc7057ae net.http.server: Support for on_destroy callback on response objects, and a 'finished' flag to say when they are destroyed (responded to or connection closed)
Matthew Wild <mwild1@gmail.com>
parents: 4689
diff changeset
139 open_response.finished = true;
a164fc7057ae net.http.server: Support for on_destroy callback on response objects, and a 'finished' flag to say when they are destroyed (responded to or connection closed)
Matthew Wild <mwild1@gmail.com>
parents: 4689
diff changeset
140 open_response:on_destroy();
a164fc7057ae net.http.server: Support for on_destroy callback on response objects, and a 'finished' flag to say when they are destroyed (responded to or connection closed)
Matthew Wild <mwild1@gmail.com>
parents: 4689
diff changeset
141 end
7489
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
142 incomplete[conn] = nil;
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
143 sessions[conn] = nil;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
144 end
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
145
6380
4220ffb87b22 net.http, net.http.server, mod_c2s, mod_s2s, mod_component, mod_admin_telnet, mod_net_multiplex: Add ondetach to release connection from 'sessions' table (or equivalent)
Matthew Wild <mwild1@gmail.com>
parents: 6360
diff changeset
146 function listener.ondetach(conn)
4220ffb87b22 net.http, net.http.server, mod_c2s, mod_s2s, mod_component, mod_admin_telnet, mod_net_multiplex: Add ondetach to release connection from 'sessions' table (or equivalent)
Matthew Wild <mwild1@gmail.com>
parents: 6360
diff changeset
147 sessions[conn] = nil;
7489
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
148 incomplete[conn] = nil;
6380
4220ffb87b22 net.http, net.http.server, mod_c2s, mod_s2s, mod_component, mod_admin_telnet, mod_net_multiplex: Add ondetach to release connection from 'sessions' table (or equivalent)
Matthew Wild <mwild1@gmail.com>
parents: 6360
diff changeset
149 end
4220ffb87b22 net.http, net.http.server, mod_c2s, mod_s2s, mod_component, mod_admin_telnet, mod_net_multiplex: Add ondetach to release connection from 'sessions' table (or equivalent)
Matthew Wild <mwild1@gmail.com>
parents: 6360
diff changeset
150
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
151 function listener.onincoming(conn, data)
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
152 sessions[conn]:feed(data);
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
153 end
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
154
7489
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
155 function listener.ondrain(conn)
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
156 local response = incomplete[conn];
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
157 if response and response._send_more then
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
158 response._send_more();
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
159 end
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
160 end
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
161
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
162 local headerfix = setmetatable({}, {
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
163 __index = function(t, k)
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
164 local v = "\r\n"..k:gsub("_", "-"):gsub("%f[%w].", s_upper)..": ";
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
165 t[k] = v;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
166 return v;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
167 end
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
168 });
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
169
10392
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
170 local function handle_result(request, response, result)
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
171 if result == nil then
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
172 result = 404;
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
173 end
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
174
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
175 if result == true then
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
176 return;
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
177 end
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
178
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
179 local body;
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
180 local result_type = type(result);
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
181 if result_type == "number" then
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
182 response.status_code = result;
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
183 if result >= 400 then
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
184 body = events.fire_event("http-error", { request = request, response = response, code = result });
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
185 end
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
186 elseif result_type == "string" then
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
187 body = result;
10394
955e54e451dc net.http.server: Handle util.error objects from http handlers
Kim Alvefur <zash@zash.se>
parents: 10393
diff changeset
188 elseif errors.is_err(result) then
10719
977c9883f625 net.http.server: Use error code from util.error (fixes #1502)
Kim Alvefur <zash@zash.se>
parents: 10501
diff changeset
189 response.status_code = result.code or 500;
10501
e8186aba1583 util.error: Move default for numeric error code to net.http.server
Kim Alvefur <zash@zash.se>
parents: 10396
diff changeset
190 body = events.fire_event("http-error", { request = request, response = response, code = result.code or 500, error = result });
10395
faa4fcc78b14 net.http.server: Handle promises from http handlers
Kim Alvefur <zash@zash.se>
parents: 10394
diff changeset
191 elseif promise.is_promise(result) then
faa4fcc78b14 net.http.server: Handle promises from http handlers
Kim Alvefur <zash@zash.se>
parents: 10394
diff changeset
192 result:next(function (ret)
faa4fcc78b14 net.http.server: Handle promises from http handlers
Kim Alvefur <zash@zash.se>
parents: 10394
diff changeset
193 handle_result(request, response, ret);
faa4fcc78b14 net.http.server: Handle promises from http handlers
Kim Alvefur <zash@zash.se>
parents: 10394
diff changeset
194 end, function (err)
11096
dd1713862c20 net.http.server: Default to HTTP result code 500 when promise is rejected
Matthew Wild <mwild1@gmail.com>
parents: 10952
diff changeset
195 response.status_code = 500;
10396
3278f2a31a0a net.http.server: Treat promise rejection without value as a HTTP 500 error
Kim Alvefur <zash@zash.se>
parents: 10395
diff changeset
196 handle_result(request, response, err or 500);
10395
faa4fcc78b14 net.http.server: Handle promises from http handlers
Kim Alvefur <zash@zash.se>
parents: 10394
diff changeset
197 end);
faa4fcc78b14 net.http.server: Handle promises from http handlers
Kim Alvefur <zash@zash.se>
parents: 10394
diff changeset
198 return true;
10392
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
199 elseif result_type == "table" then
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
200 for k, v in pairs(result) do
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
201 if k ~= "headers" then
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
202 response[k] = v;
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
203 else
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
204 for header_name, header_value in pairs(v) do
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
205 response.headers[header_name] = header_value;
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
206 end
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
207 end
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
208 end
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
209 end
10393
0ea7b4769096 net.http.server: Tail call because tail call!
Kim Alvefur <zash@zash.se>
parents: 10392
diff changeset
210 return response:send(body);
10392
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
211 end
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
212
7582
e080b8b4f3cb net.http.server: Add luacheck annotations
Kim Alvefur <zash@zash.se>
parents: 7581
diff changeset
213 function _M.hijack_response(response, listener) -- luacheck: ignore
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
214 error("TODO");
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
215 end
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
216 function handle_request(conn, request, finish_cb)
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
217 --log("debug", "handler: %s", request.path);
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
218 local headers = {};
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
219 for k,v in pairs(request.headers) do headers[k:gsub("-", "_")] = v; end
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
220 request.headers = headers;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
221 request.conn = conn;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
222
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
223 local date_header = os_date('!%a, %d %b %Y %H:%M:%S GMT'); -- FIXME use
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
224 local conn_header = request.headers.connection;
5300
fcb1be0b4a5c net.http.server: Properly handle persistent connections
Florian Zeitz <florob@babelmonkeys.de>
parents: 4788
diff changeset
225 conn_header = conn_header and ","..conn_header:gsub("[ \t]", ""):lower().."," or ""
fcb1be0b4a5c net.http.server: Properly handle persistent connections
Florian Zeitz <florob@babelmonkeys.de>
parents: 4788
diff changeset
226 local httpversion = request.httpversion
5754
dee0f05ccf70 net.http.server: Fix Keep-Alive requests with HTTP 1.0
Kim Alvefur <zash@zash.se>
parents: 5505
diff changeset
227 local persistent = conn_header:find(",keep-alive,", 1, true)
5300
fcb1be0b4a5c net.http.server: Properly handle persistent connections
Florian Zeitz <florob@babelmonkeys.de>
parents: 4788
diff changeset
228 or (httpversion == "1.1" and not conn_header:find(",close,", 1, true));
fcb1be0b4a5c net.http.server: Properly handle persistent connections
Florian Zeitz <florob@babelmonkeys.de>
parents: 4788
diff changeset
229
fcb1be0b4a5c net.http.server: Properly handle persistent connections
Florian Zeitz <florob@babelmonkeys.de>
parents: 4788
diff changeset
230 local response_conn_header;
fcb1be0b4a5c net.http.server: Properly handle persistent connections
Florian Zeitz <florob@babelmonkeys.de>
parents: 4788
diff changeset
231 if persistent then
fcb1be0b4a5c net.http.server: Properly handle persistent connections
Florian Zeitz <florob@babelmonkeys.de>
parents: 4788
diff changeset
232 response_conn_header = "Keep-Alive";
fcb1be0b4a5c net.http.server: Properly handle persistent connections
Florian Zeitz <florob@babelmonkeys.de>
parents: 4788
diff changeset
233 else
fcb1be0b4a5c net.http.server: Properly handle persistent connections
Florian Zeitz <florob@babelmonkeys.de>
parents: 4788
diff changeset
234 response_conn_header = httpversion == "1.1" and "close" or nil
fcb1be0b4a5c net.http.server: Properly handle persistent connections
Florian Zeitz <florob@babelmonkeys.de>
parents: 4788
diff changeset
235 end
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
236
10323
73938168681c net.http.server: Ensure HEAD requests are sent with empty body
Kim Alvefur <zash@zash.se>
parents: 9624
diff changeset
237 local is_head_request = request.method == "HEAD";
73938168681c net.http.server: Ensure HEAD requests are sent with empty body
Kim Alvefur <zash@zash.se>
parents: 9624
diff changeset
238
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
239 local response = {
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
240 request = request;
10323
73938168681c net.http.server: Ensure HEAD requests are sent with empty body
Kim Alvefur <zash@zash.se>
parents: 9624
diff changeset
241 is_head_request = is_head_request;
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
242 status_code = 200;
5300
fcb1be0b4a5c net.http.server: Properly handle persistent connections
Florian Zeitz <florob@babelmonkeys.de>
parents: 4788
diff changeset
243 headers = { date = date_header, connection = response_conn_header };
fcb1be0b4a5c net.http.server: Properly handle persistent connections
Florian Zeitz <florob@babelmonkeys.de>
parents: 4788
diff changeset
244 persistent = persistent;
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
245 conn = conn;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
246 send = _M.send_response;
7489
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
247 send_file = _M.send_file;
6071
420c0d3b8583 net.http.server: Add prepare_header() and finish_response() to allow sending chunked responses via the API
Daurnimator <quae@daurnimator.com>
parents: 5776
diff changeset
248 done = _M.finish_response;
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
249 finish_cb = finish_cb;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
250 };
4691
a164fc7057ae net.http.server: Support for on_destroy callback on response objects, and a 'finished' flag to say when they are destroyed (responded to or connection closed)
Matthew Wild <mwild1@gmail.com>
parents: 4689
diff changeset
251 conn._http_open_response = response;
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
252
10951
f4215f8baa5d net.http.server: Fix reporting of missing Host header
Kim Alvefur <zash@zash.se>
parents: 10950
diff changeset
253 local host = request.headers.host;
f4215f8baa5d net.http.server: Fix reporting of missing Host header
Kim Alvefur <zash@zash.se>
parents: 10950
diff changeset
254 if host then host = host:gsub(":%d+$",""); end
4736
3514338c59c3 net.http.server, mod_http: Support http_default_host config option to specify where to direct requests for unknown HTTP vhosts
Matthew Wild <mwild1@gmail.com>
parents: 4735
diff changeset
255
3514338c59c3 net.http.server, mod_http: Support http_default_host config option to specify where to direct requests for unknown HTTP vhosts
Matthew Wild <mwild1@gmail.com>
parents: 4735
diff changeset
256 -- Some sanity checking
3514338c59c3 net.http.server, mod_http: Support http_default_host config option to specify where to direct requests for unknown HTTP vhosts
Matthew Wild <mwild1@gmail.com>
parents: 4735
diff changeset
257 local err_code, err;
4740
bd9c8bc8036f net.http.server: Try default_host if client sent no host anywhere, otherwise... fail. It's 2012.
Matthew Wild <mwild1@gmail.com>
parents: 4739
diff changeset
258 if not request.path then
4736
3514338c59c3 net.http.server, mod_http: Support http_default_host config option to specify where to direct requests for unknown HTTP vhosts
Matthew Wild <mwild1@gmail.com>
parents: 4735
diff changeset
259 err_code, err = 400, "Invalid path";
4713
9c15fa5192d3 net.http.server: Fire http-error 400 if request fails sanity checks
Matthew Wild <mwild1@gmail.com>
parents: 4710
diff changeset
260 end
5776
bd0ff8ae98a8 Remove all trailing whitespace
Florian Zeitz <florob@babelmonkeys.de>
parents: 5754
diff changeset
261
4713
9c15fa5192d3 net.http.server: Fire http-error 400 if request fails sanity checks
Matthew Wild <mwild1@gmail.com>
parents: 4710
diff changeset
262 if err then
4736
3514338c59c3 net.http.server, mod_http: Support http_default_host config option to specify where to direct requests for unknown HTTP vhosts
Matthew Wild <mwild1@gmail.com>
parents: 4735
diff changeset
263 response.status_code = err_code;
8362
c7d6c2558a24 net.http.server: Include response object in most http-error events
Kim Alvefur <zash@zash.se>
parents: 7582
diff changeset
264 response:send(events.fire_event("http-error", { code = err_code, message = err, response = response }));
4736
3514338c59c3 net.http.server, mod_http: Support http_default_host config option to specify where to direct requests for unknown HTTP vhosts
Matthew Wild <mwild1@gmail.com>
parents: 4735
diff changeset
265 return;
3514338c59c3 net.http.server, mod_http: Support http_default_host config option to specify where to direct requests for unknown HTTP vhosts
Matthew Wild <mwild1@gmail.com>
parents: 4735
diff changeset
266 end
3514338c59c3 net.http.server, mod_http: Support http_default_host config option to specify where to direct requests for unknown HTTP vhosts
Matthew Wild <mwild1@gmail.com>
parents: 4735
diff changeset
267
9375
816591db764d net.http.server: Fire an event without host
Kim Alvefur <zash@zash.se>
parents: 9338
diff changeset
268 local global_event = request.method.." "..request.path:match("[^?]*");
9379
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
269
4736
3514338c59c3 net.http.server, mod_http: Support http_default_host config option to specify where to direct requests for unknown HTTP vhosts
Matthew Wild <mwild1@gmail.com>
parents: 4735
diff changeset
270 local payload = { request = request, response = response };
9375
816591db764d net.http.server: Fire an event without host
Kim Alvefur <zash@zash.se>
parents: 9338
diff changeset
271 log("debug", "Firing event: %s", global_event);
816591db764d net.http.server: Fire an event without host
Kim Alvefur <zash@zash.se>
parents: 9338
diff changeset
272 local result = events.fire_event(global_event, payload);
10324
3f4c25425589 net.http.server: Re-fire unhandled HEAD requsts as GET events (fixes #1447)
Kim Alvefur <zash@zash.se>
parents: 10323
diff changeset
273 if result == nil and is_head_request then
3f4c25425589 net.http.server: Re-fire unhandled HEAD requsts as GET events (fixes #1447)
Kim Alvefur <zash@zash.se>
parents: 10323
diff changeset
274 local global_head_event = "GET "..request.path:match("[^?]*");
3f4c25425589 net.http.server: Re-fire unhandled HEAD requsts as GET events (fixes #1447)
Kim Alvefur <zash@zash.se>
parents: 10323
diff changeset
275 log("debug", "Firing event: %s", global_head_event);
3f4c25425589 net.http.server: Re-fire unhandled HEAD requsts as GET events (fixes #1447)
Kim Alvefur <zash@zash.se>
parents: 10323
diff changeset
276 result = events.fire_event(global_head_event, payload);
3f4c25425589 net.http.server: Re-fire unhandled HEAD requsts as GET events (fixes #1447)
Kim Alvefur <zash@zash.se>
parents: 10323
diff changeset
277 end
9375
816591db764d net.http.server: Fire an event without host
Kim Alvefur <zash@zash.se>
parents: 9338
diff changeset
278 if result == nil then
9379
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
279 if not hosts[host] then
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
280 if hosts[default_host] then
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
281 host = default_host;
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
282 elseif host then
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
283 err_code, err = 404, "Unknown host: "..host;
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
284 else
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
285 err_code, err = 400, "Missing or invalid 'Host' header";
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
286 end
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
287 end
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
288
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
289 if err then
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
290 response.status_code = err_code;
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
291 response:send(events.fire_event("http-error", { code = err_code, message = err, response = response }));
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
292 return;
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
293 end
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
294
9624
cc9dff0212f4 net.http.server: Move event formation to avoid traceback on missing Host header
Matthew Wild <mwild1@gmail.com>
parents: 9562
diff changeset
295 local host_event = request.method.." "..host..request.path:match("[^?]*");
9375
816591db764d net.http.server: Fire an event without host
Kim Alvefur <zash@zash.se>
parents: 9338
diff changeset
296 log("debug", "Firing event: %s", host_event);
816591db764d net.http.server: Fire an event without host
Kim Alvefur <zash@zash.se>
parents: 9338
diff changeset
297 result = events.fire_event(host_event, payload);
10324
3f4c25425589 net.http.server: Re-fire unhandled HEAD requsts as GET events (fixes #1447)
Kim Alvefur <zash@zash.se>
parents: 10323
diff changeset
298
3f4c25425589 net.http.server: Re-fire unhandled HEAD requsts as GET events (fixes #1447)
Kim Alvefur <zash@zash.se>
parents: 10323
diff changeset
299 if result == nil and is_head_request then
3f4c25425589 net.http.server: Re-fire unhandled HEAD requsts as GET events (fixes #1447)
Kim Alvefur <zash@zash.se>
parents: 10323
diff changeset
300 local host_head_event = "GET "..host..request.path:match("[^?]*");
3f4c25425589 net.http.server: Re-fire unhandled HEAD requsts as GET events (fixes #1447)
Kim Alvefur <zash@zash.se>
parents: 10323
diff changeset
301 log("debug", "Firing event: %s", host_head_event);
3f4c25425589 net.http.server: Re-fire unhandled HEAD requsts as GET events (fixes #1447)
Kim Alvefur <zash@zash.se>
parents: 10323
diff changeset
302 result = events.fire_event(host_head_event, payload);
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
303 end
4736
3514338c59c3 net.http.server, mod_http: Support http_default_host config option to specify where to direct requests for unknown HTTP vhosts
Matthew Wild <mwild1@gmail.com>
parents: 4735
diff changeset
304 end
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
305
10392
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
306 return handle_result(request, response, result);
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
307 end
10392
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
308
6071
420c0d3b8583 net.http.server: Add prepare_header() and finish_response() to allow sending chunked responses via the API
Daurnimator <quae@daurnimator.com>
parents: 5776
diff changeset
309 local function prepare_header(response)
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
310 local status_line = "HTTP/"..response.request.httpversion.." "..(response.status or codes[response.status_code]);
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
311 local headers = response.headers;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
312 local output = { status_line };
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
313 for k,v in pairs(headers) do
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
314 t_insert(output, headerfix[k]..v);
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
315 end
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
316 t_insert(output, "\r\n\r\n");
6071
420c0d3b8583 net.http.server: Add prepare_header() and finish_response() to allow sending chunked responses via the API
Daurnimator <quae@daurnimator.com>
parents: 5776
diff changeset
317 return output;
420c0d3b8583 net.http.server: Add prepare_header() and finish_response() to allow sending chunked responses via the API
Daurnimator <quae@daurnimator.com>
parents: 5776
diff changeset
318 end
420c0d3b8583 net.http.server: Add prepare_header() and finish_response() to allow sending chunked responses via the API
Daurnimator <quae@daurnimator.com>
parents: 5776
diff changeset
319 _M.prepare_header = prepare_header;
10323
73938168681c net.http.server: Ensure HEAD requests are sent with empty body
Kim Alvefur <zash@zash.se>
parents: 9624
diff changeset
320 function _M.send_head_response(response)
73938168681c net.http.server: Ensure HEAD requests are sent with empty body
Kim Alvefur <zash@zash.se>
parents: 9624
diff changeset
321 if response.finished then return; end
73938168681c net.http.server: Ensure HEAD requests are sent with empty body
Kim Alvefur <zash@zash.se>
parents: 9624
diff changeset
322 local output = prepare_header(response);
73938168681c net.http.server: Ensure HEAD requests are sent with empty body
Kim Alvefur <zash@zash.se>
parents: 9624
diff changeset
323 response.conn:write(t_concat(output));
73938168681c net.http.server: Ensure HEAD requests are sent with empty body
Kim Alvefur <zash@zash.se>
parents: 9624
diff changeset
324 response:done();
73938168681c net.http.server: Ensure HEAD requests are sent with empty body
Kim Alvefur <zash@zash.se>
parents: 9624
diff changeset
325 end
6071
420c0d3b8583 net.http.server: Add prepare_header() and finish_response() to allow sending chunked responses via the API
Daurnimator <quae@daurnimator.com>
parents: 5776
diff changeset
326 function _M.send_response(response, body)
420c0d3b8583 net.http.server: Add prepare_header() and finish_response() to allow sending chunked responses via the API
Daurnimator <quae@daurnimator.com>
parents: 5776
diff changeset
327 if response.finished then return; end
420c0d3b8583 net.http.server: Add prepare_header() and finish_response() to allow sending chunked responses via the API
Daurnimator <quae@daurnimator.com>
parents: 5776
diff changeset
328 body = body or response.body or "";
11159
de76f566159e net.http.server: Don't send Content-Length on 1xx/204 responses, per RFC (fixes #1596)
Matthew Wild <mwild1@gmail.com>
parents: 10951
diff changeset
329 -- Per RFC 7230, informational (1xx) and 204 (no content) should have no c-l header
de76f566159e net.http.server: Don't send Content-Length on 1xx/204 responses, per RFC (fixes #1596)
Matthew Wild <mwild1@gmail.com>
parents: 10951
diff changeset
330 if response.status_code > 199 and response.status_code ~= 204 then
11160
e9eeaefa09a7 Merge 0.11->trunk
Matthew Wild <mwild1@gmail.com>
parents: 11096 11159
diff changeset
331 response.headers.content_length = ("%d"):format(#body);
e9eeaefa09a7 Merge 0.11->trunk
Matthew Wild <mwild1@gmail.com>
parents: 11096 11159
diff changeset
332 end
10323
73938168681c net.http.server: Ensure HEAD requests are sent with empty body
Kim Alvefur <zash@zash.se>
parents: 9624
diff changeset
333 if response.is_head_request then
73938168681c net.http.server: Ensure HEAD requests are sent with empty body
Kim Alvefur <zash@zash.se>
parents: 9624
diff changeset
334 return _M.send_head_response(response)
11159
de76f566159e net.http.server: Don't send Content-Length on 1xx/204 responses, per RFC (fixes #1596)
Matthew Wild <mwild1@gmail.com>
parents: 10951
diff changeset
335 end
6082
d0e824a21861 net.http.server: Fix some typos introduced in 420c0d3b8583.
Daurnimator <quae@daurnimator.com>
parents: 6071
diff changeset
336 local output = prepare_header(response);
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
337 t_insert(output, body);
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
338 response.conn:write(t_concat(output));
6082
d0e824a21861 net.http.server: Fix some typos introduced in 420c0d3b8583.
Daurnimator <quae@daurnimator.com>
parents: 6071
diff changeset
339 response:done();
6071
420c0d3b8583 net.http.server: Add prepare_header() and finish_response() to allow sending chunked responses via the API
Daurnimator <quae@daurnimator.com>
parents: 5776
diff changeset
340 end
7489
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
341 function _M.send_file(response, f)
10323
73938168681c net.http.server: Ensure HEAD requests are sent with empty body
Kim Alvefur <zash@zash.se>
parents: 9624
diff changeset
342 if response.is_head_request then
73938168681c net.http.server: Ensure HEAD requests are sent with empty body
Kim Alvefur <zash@zash.se>
parents: 9624
diff changeset
343 if f.close then f:close(); end
73938168681c net.http.server: Ensure HEAD requests are sent with empty body
Kim Alvefur <zash@zash.se>
parents: 9624
diff changeset
344 return _M.send_head_response(response);
73938168681c net.http.server: Ensure HEAD requests are sent with empty body
Kim Alvefur <zash@zash.se>
parents: 9624
diff changeset
345 end
7489
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
346 if response.finished then return; end
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
347 local chunked = not response.headers.content_length;
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
348 if chunked then response.headers.transfer_encoding = "chunked"; end
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
349 incomplete[response.conn] = response;
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
350 response._send_more = function ()
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
351 if response.finished then
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
352 incomplete[response.conn] = nil;
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
353 return;
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
354 end
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
355 local chunk = f:read(blocksize);
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
356 if chunk then
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
357 if chunked then
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
358 chunk = ("%x\r\n%s\r\n"):format(#chunk, chunk);
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
359 end
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
360 -- io.write("."); io.flush();
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
361 response.conn:write(chunk);
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
362 else
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
363 if chunked then
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
364 response.conn:write("0\r\n\r\n");
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
365 end
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
366 -- io.write("\n");
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
367 if f.close then f:close(); end
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
368 incomplete[response.conn] = nil;
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
369 return response:done();
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
370 end
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
371 end
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
372 response.conn:write(t_concat(prepare_header(response)));
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
373 return true;
d32406f27efd net.http.server: Add response method for reading response body from a file handle
Kim Alvefur <zash@zash.se>
parents: 7084
diff changeset
374 end
6071
420c0d3b8583 net.http.server: Add prepare_header() and finish_response() to allow sending chunked responses via the API
Daurnimator <quae@daurnimator.com>
parents: 5776
diff changeset
375 function _M.finish_response(response)
420c0d3b8583 net.http.server: Add prepare_header() and finish_response() to allow sending chunked responses via the API
Daurnimator <quae@daurnimator.com>
parents: 5776
diff changeset
376 if response.finished then return; end
420c0d3b8583 net.http.server: Add prepare_header() and finish_response() to allow sending chunked responses via the API
Daurnimator <quae@daurnimator.com>
parents: 5776
diff changeset
377 response.finished = true;
420c0d3b8583 net.http.server: Add prepare_header() and finish_response() to allow sending chunked responses via the API
Daurnimator <quae@daurnimator.com>
parents: 5776
diff changeset
378 response.conn._http_open_response = nil;
4691
a164fc7057ae net.http.server: Support for on_destroy callback on response objects, and a 'finished' flag to say when they are destroyed (responded to or connection closed)
Matthew Wild <mwild1@gmail.com>
parents: 4689
diff changeset
379 if response.on_destroy then
a164fc7057ae net.http.server: Support for on_destroy callback on response objects, and a 'finished' flag to say when they are destroyed (responded to or connection closed)
Matthew Wild <mwild1@gmail.com>
parents: 4689
diff changeset
380 response:on_destroy();
a164fc7057ae net.http.server: Support for on_destroy callback on response objects, and a 'finished' flag to say when they are destroyed (responded to or connection closed)
Matthew Wild <mwild1@gmail.com>
parents: 4689
diff changeset
381 response.on_destroy = nil;
a164fc7057ae net.http.server: Support for on_destroy callback on response objects, and a 'finished' flag to say when they are destroyed (responded to or connection closed)
Matthew Wild <mwild1@gmail.com>
parents: 4689
diff changeset
382 end
5300
fcb1be0b4a5c net.http.server: Properly handle persistent connections
Florian Zeitz <florob@babelmonkeys.de>
parents: 4788
diff changeset
383 if response.persistent then
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
384 response:finish_cb();
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
385 else
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
386 response.conn:close();
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
387 end
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
388 end
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
389 function _M.add_handler(event, handler, priority)
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
390 events.add_handler(event, handler, priority);
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
391 end
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
392 function _M.remove_handler(event, handler)
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
393 events.remove_handler(event, handler);
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
394 end
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
395
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
396 function _M.listen_on(port, interface, ssl)
7084
fdbe9ccac17d net.http.server: Return from listen_on() whatever net.server.addserver() returns
Kim Alvefur <zash@zash.se>
parents: 6963
diff changeset
397 return addserver(interface or "*", port, listener, "*a", ssl);
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
398 end
4736
3514338c59c3 net.http.server, mod_http: Support http_default_host config option to specify where to direct requests for unknown HTTP vhosts
Matthew Wild <mwild1@gmail.com>
parents: 4735
diff changeset
399 function _M.add_host(host)
3514338c59c3 net.http.server, mod_http: Support http_default_host config option to specify where to direct requests for unknown HTTP vhosts
Matthew Wild <mwild1@gmail.com>
parents: 4735
diff changeset
400 hosts[host] = true;
3514338c59c3 net.http.server, mod_http: Support http_default_host config option to specify where to direct requests for unknown HTTP vhosts
Matthew Wild <mwild1@gmail.com>
parents: 4735
diff changeset
401 end
3514338c59c3 net.http.server, mod_http: Support http_default_host config option to specify where to direct requests for unknown HTTP vhosts
Matthew Wild <mwild1@gmail.com>
parents: 4735
diff changeset
402 function _M.remove_host(host)
3514338c59c3 net.http.server, mod_http: Support http_default_host config option to specify where to direct requests for unknown HTTP vhosts
Matthew Wild <mwild1@gmail.com>
parents: 4735
diff changeset
403 hosts[host] = nil;
3514338c59c3 net.http.server, mod_http: Support http_default_host config option to specify where to direct requests for unknown HTTP vhosts
Matthew Wild <mwild1@gmail.com>
parents: 4735
diff changeset
404 end
3514338c59c3 net.http.server, mod_http: Support http_default_host config option to specify where to direct requests for unknown HTTP vhosts
Matthew Wild <mwild1@gmail.com>
parents: 4735
diff changeset
405 function _M.set_default_host(host)
3514338c59c3 net.http.server, mod_http: Support http_default_host config option to specify where to direct requests for unknown HTTP vhosts
Matthew Wild <mwild1@gmail.com>
parents: 4735
diff changeset
406 default_host = host;
3514338c59c3 net.http.server, mod_http: Support http_default_host config option to specify where to direct requests for unknown HTTP vhosts
Matthew Wild <mwild1@gmail.com>
parents: 4735
diff changeset
407 end
5439
bd7b314c2301 net.http.server: add API to allow firing events directly on the server.
Marco Cirillo <maranda@lightwitch.org>
parents: 5404
diff changeset
408 function _M.fire_event(event, ...)
bd7b314c2301 net.http.server: add API to allow firing events directly on the server.
Marco Cirillo <maranda@lightwitch.org>
parents: 5404
diff changeset
409 return events.fire_event(event, ...);
bd7b314c2301 net.http.server: add API to allow firing events directly on the server.
Marco Cirillo <maranda@lightwitch.org>
parents: 5404
diff changeset
410 end
7579
d430573fe9f8 net.http.server: Expose way to set http server options
Kim Alvefur <zash@zash.se>
parents: 6589
diff changeset
411 function _M.set_option(name, value)
d430573fe9f8 net.http.server: Expose way to set http server options
Kim Alvefur <zash@zash.se>
parents: 6589
diff changeset
412 options[name] = value;
d430573fe9f8 net.http.server: Expose way to set http server options
Kim Alvefur <zash@zash.se>
parents: 6589
diff changeset
413 end
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
414
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
415 _M.listener = listener;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
416 _M.codes = codes;
4706
845393c76d17 net.http.server: Expose events object (for debug purposes)
Matthew Wild <mwild1@gmail.com>
parents: 4704
diff changeset
417 _M._events = events;
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
418 return _M;