prosody
eaff6e548f12
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 @ 11527:eaff6e548f12

net.http.server: Split out method for sending only the header Makes it easier to reuse, e.g. for SSE or websockets or other custom responses.
author Kim Alvefur <zash@zash.se>
date Sat, 24 Apr 2021 10:50:24 +0200
parent 11409:d30c44a829c1
child 12831:1cdaf21584da
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()
11372
b877bd74d65e net.http.server: Allow storing more than the parser in the session
Kim Alvefur <zash@zash.se>
parents: 11371
diff changeset
99 self.data.conn:resume();
11371
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()
11372
b877bd74d65e net.http.server: Allow storing more than the parser in the session
Kim Alvefur <zash@zash.se>
parents: 11371
diff changeset
103 self.data.conn:pause();
11371
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);
11372
b877bd74d65e net.http.server: Allow storing more than the parser in the session
Kim Alvefur <zash@zash.se>
parents: 11371
diff changeset
108 self.data.conn:write("HTTP/1.0 500 Internal Server Error\r\n\r\n"..events.fire_event("http-error", { code = 500, private_message = err }));
b877bd74d65e net.http.server: Allow storing more than the parser in the session
Kim Alvefur <zash@zash.se>
parents: 11371
diff changeset
109 self.data.conn:close();
11371
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
11373
ad3b5384fc03 net.http.server: Don't pause early streaming uploads
Kim Alvefur <zash@zash.se>
parents: 11372
diff changeset
112 local function noop() end
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
113 function listener.onconnect(conn)
11372
b877bd74d65e net.http.server: Allow storing more than the parser in the session
Kim Alvefur <zash@zash.se>
parents: 11371
diff changeset
114 local session = { conn = conn };
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
115 local secure = conn:ssl() and true or nil;
11409
d30c44a829c1 net.http.server: Set request.ip so mod_http doesn't have to
Kim Alvefur <zash@zash.se>
parents: 11373
diff changeset
116 local ip = conn:ip();
11372
b877bd74d65e net.http.server: Allow storing more than the parser in the session
Kim Alvefur <zash@zash.se>
parents: 11371
diff changeset
117 session.thread = async.runner(function (request)
11373
ad3b5384fc03 net.http.server: Don't pause early streaming uploads
Kim Alvefur <zash@zash.se>
parents: 11372
diff changeset
118 local wait, done;
ad3b5384fc03 net.http.server: Don't pause early streaming uploads
Kim Alvefur <zash@zash.se>
parents: 11372
diff changeset
119 if request.partial == true then
ad3b5384fc03 net.http.server: Don't pause early streaming uploads
Kim Alvefur <zash@zash.se>
parents: 11372
diff changeset
120 -- Have the header for a request, we want to receive the rest
ad3b5384fc03 net.http.server: Don't pause early streaming uploads
Kim Alvefur <zash@zash.se>
parents: 11372
diff changeset
121 -- when we've decided where the data should go.
ad3b5384fc03 net.http.server: Don't pause early streaming uploads
Kim Alvefur <zash@zash.se>
parents: 11372
diff changeset
122 wait, done = noop, noop;
ad3b5384fc03 net.http.server: Don't pause early streaming uploads
Kim Alvefur <zash@zash.se>
parents: 11372
diff changeset
123 else -- Got the entire request
ad3b5384fc03 net.http.server: Don't pause early streaming uploads
Kim Alvefur <zash@zash.se>
parents: 11372
diff changeset
124 -- Hold off on receiving more incoming requests until this one has been handled.
ad3b5384fc03 net.http.server: Don't pause early streaming uploads
Kim Alvefur <zash@zash.se>
parents: 11372
diff changeset
125 wait, done = async.waiter();
ad3b5384fc03 net.http.server: Don't pause early streaming uploads
Kim Alvefur <zash@zash.se>
parents: 11372
diff changeset
126 end
11371
73f7acf8a61f net.http.server: Enable async during HTTP request handling (fixes #1487)
Kim Alvefur <zash@zash.se>
parents: 11160
diff changeset
127 handle_request(conn, request, done); wait();
11372
b877bd74d65e net.http.server: Allow storing more than the parser in the session
Kim Alvefur <zash@zash.se>
parents: 11371
diff changeset
128 end, runner_callbacks, session);
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
129 local function success_cb(request)
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
130 --log("debug", "success_cb: %s", request.path);
11409
d30c44a829c1 net.http.server: Set request.ip so mod_http doesn't have to
Kim Alvefur <zash@zash.se>
parents: 11373
diff changeset
131 request.ip = ip;
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
132 request.secure = secure;
11372
b877bd74d65e net.http.server: Allow storing more than the parser in the session
Kim Alvefur <zash@zash.se>
parents: 11371
diff changeset
133 session.thread:run(request);
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 local function error_cb(err)
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
136 log("debug", "error_cb: %s", err or "<nil>");
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
137 -- 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
138 -- 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
139 conn:close();
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
140 end
7579
d430573fe9f8 net.http.server: Expose way to set http server options
Kim Alvefur <zash@zash.se>
parents: 6589
diff changeset
141 local function options_cb()
d430573fe9f8 net.http.server: Expose way to set http server options
Kim Alvefur <zash@zash.se>
parents: 6589
diff changeset
142 return options;
d430573fe9f8 net.http.server: Expose way to set http server options
Kim Alvefur <zash@zash.se>
parents: 6589
diff changeset
143 end
11372
b877bd74d65e net.http.server: Allow storing more than the parser in the session
Kim Alvefur <zash@zash.se>
parents: 11371
diff changeset
144 session.parser = parser_new(success_cb, error_cb, "server", options_cb);
b877bd74d65e net.http.server: Allow storing more than the parser in the session
Kim Alvefur <zash@zash.se>
parents: 11371
diff changeset
145 sessions[conn] = session;
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
146 end
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
147
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
148 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
149 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
150 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
151 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
152 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
153 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
154 incomplete[conn] = nil;
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
155 sessions[conn] = nil;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
156 end
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
157
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
158 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
159 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
160 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
161 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
162
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
163 function listener.onincoming(conn, data)
11372
b877bd74d65e net.http.server: Allow storing more than the parser in the session
Kim Alvefur <zash@zash.se>
parents: 11371
diff changeset
164 sessions[conn].parser:feed(data);
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
165 end
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
166
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
167 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
168 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
169 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
170 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
171 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
172 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
173
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
174 local headerfix = setmetatable({}, {
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
175 __index = function(t, k)
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
176 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
177 t[k] = v;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
178 return v;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
179 end
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
180 });
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
181
10392
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
182 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
183 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
184 result = 404;
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
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
187 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
188 return;
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
189 end
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
190
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
191 local body;
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
192 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
193 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
194 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
195 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
196 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
197 end
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
198 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
199 body = result;
10394
955e54e451dc net.http.server: Handle util.error objects from http handlers
Kim Alvefur <zash@zash.se>
parents: 10393
diff changeset
200 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
201 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
202 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
203 elseif promise.is_promise(result) then
faa4fcc78b14 net.http.server: Handle promises from http handlers
Kim Alvefur <zash@zash.se>
parents: 10394
diff changeset
204 result:next(function (ret)
faa4fcc78b14 net.http.server: Handle promises from http handlers
Kim Alvefur <zash@zash.se>
parents: 10394
diff changeset
205 handle_result(request, response, ret);
faa4fcc78b14 net.http.server: Handle promises from http handlers
Kim Alvefur <zash@zash.se>
parents: 10394
diff changeset
206 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
207 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
208 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
209 end);
faa4fcc78b14 net.http.server: Handle promises from http handlers
Kim Alvefur <zash@zash.se>
parents: 10394
diff changeset
210 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
211 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
212 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
213 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
214 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
215 else
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
216 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
217 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
218 end
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
219 end
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
220 end
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
221 end
10393
0ea7b4769096 net.http.server: Tail call because tail call!
Kim Alvefur <zash@zash.se>
parents: 10392
diff changeset
222 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
223 end
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
224
7582
e080b8b4f3cb net.http.server: Add luacheck annotations
Kim Alvefur <zash@zash.se>
parents: 7581
diff changeset
225 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
226 error("TODO");
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
227 end
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
228 function handle_request(conn, request, finish_cb)
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
229 --log("debug", "handler: %s", request.path);
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
230 local headers = {};
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
231 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
232 request.headers = headers;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
233 request.conn = conn;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
234
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
235 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
236 local conn_header = request.headers.connection;
5300
fcb1be0b4a5c net.http.server: Properly handle persistent connections
Florian Zeitz <florob@babelmonkeys.de>
parents: 4788
diff changeset
237 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
238 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
239 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
240 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
241
fcb1be0b4a5c net.http.server: Properly handle persistent connections
Florian Zeitz <florob@babelmonkeys.de>
parents: 4788
diff changeset
242 local response_conn_header;
fcb1be0b4a5c net.http.server: Properly handle persistent connections
Florian Zeitz <florob@babelmonkeys.de>
parents: 4788
diff changeset
243 if persistent then
fcb1be0b4a5c net.http.server: Properly handle persistent connections
Florian Zeitz <florob@babelmonkeys.de>
parents: 4788
diff changeset
244 response_conn_header = "Keep-Alive";
fcb1be0b4a5c net.http.server: Properly handle persistent connections
Florian Zeitz <florob@babelmonkeys.de>
parents: 4788
diff changeset
245 else
fcb1be0b4a5c net.http.server: Properly handle persistent connections
Florian Zeitz <florob@babelmonkeys.de>
parents: 4788
diff changeset
246 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
247 end
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
248
10323
73938168681c net.http.server: Ensure HEAD requests are sent with empty body
Kim Alvefur <zash@zash.se>
parents: 9624
diff changeset
249 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
250
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
251 local response = {
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
252 request = request;
10323
73938168681c net.http.server: Ensure HEAD requests are sent with empty body
Kim Alvefur <zash@zash.se>
parents: 9624
diff changeset
253 is_head_request = is_head_request;
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
254 status_code = 200;
5300
fcb1be0b4a5c net.http.server: Properly handle persistent connections
Florian Zeitz <florob@babelmonkeys.de>
parents: 4788
diff changeset
255 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
256 persistent = persistent;
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
257 conn = conn;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
258 send = _M.send_response;
11527
eaff6e548f12 net.http.server: Split out method for sending only the header
Kim Alvefur <zash@zash.se>
parents: 11409
diff changeset
259 write_headers = _M.write_headers;
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
260 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
261 done = _M.finish_response;
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
262 finish_cb = finish_cb;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
263 };
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
264 conn._http_open_response = response;
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
265
10951
f4215f8baa5d net.http.server: Fix reporting of missing Host header
Kim Alvefur <zash@zash.se>
parents: 10950
diff changeset
266 local host = request.headers.host;
f4215f8baa5d net.http.server: Fix reporting of missing Host header
Kim Alvefur <zash@zash.se>
parents: 10950
diff changeset
267 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
268
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
269 -- 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
270 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
271 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
272 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
273 end
5776
bd0ff8ae98a8 Remove all trailing whitespace
Florian Zeitz <florob@babelmonkeys.de>
parents: 5754
diff changeset
274
4713
9c15fa5192d3 net.http.server: Fire http-error 400 if request fails sanity checks
Matthew Wild <mwild1@gmail.com>
parents: 4710
diff changeset
275 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
276 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
277 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
278 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
279 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
280
9375
816591db764d net.http.server: Fire an event without host
Kim Alvefur <zash@zash.se>
parents: 9338
diff changeset
281 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
282
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
283 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
284 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
285 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
286 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
287 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
288 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
289 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
290 end
9375
816591db764d net.http.server: Fire an event without host
Kim Alvefur <zash@zash.se>
parents: 9338
diff changeset
291 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
292 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
293 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
294 host = default_host;
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
295 elseif host then
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
296 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
297 else
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
298 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
299 end
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
300 end
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
301
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
302 if err then
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
303 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
304 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
305 return;
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
306 end
866cba3689f4 net.http.server: Delay host checks until after host-less event
Kim Alvefur <zash@zash.se>
parents: 9375
diff changeset
307
9624
cc9dff0212f4 net.http.server: Move event formation to avoid traceback on missing Host header
Matthew Wild <mwild1@gmail.com>
parents: 9562
diff changeset
308 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
309 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
310 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
311
3f4c25425589 net.http.server: Re-fire unhandled HEAD requsts as GET events (fixes #1447)
Kim Alvefur <zash@zash.se>
parents: 10323
diff changeset
312 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
313 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
314 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
315 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
316 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
317 end
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
318
10392
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
319 return handle_result(request, response, result);
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
320 end
10392
7a95f27ac9d6 net.http.server: Factor out handling of event response for easier reuse
Kim Alvefur <zash@zash.se>
parents: 10326
diff changeset
321
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
322 local function prepare_header(response)
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
323 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
324 local headers = response.headers;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
325 local output = { status_line };
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
326 for k,v in pairs(headers) do
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
327 t_insert(output, headerfix[k]..v);
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
328 end
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
329 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
330 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
331 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
332 _M.prepare_header = prepare_header;
11527
eaff6e548f12 net.http.server: Split out method for sending only the header
Kim Alvefur <zash@zash.se>
parents: 11409
diff changeset
333 function _M.write_headers(response)
10323
73938168681c net.http.server: Ensure HEAD requests are sent with empty body
Kim Alvefur <zash@zash.se>
parents: 9624
diff changeset
334 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
335 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
336 response.conn:write(t_concat(output));
11527
eaff6e548f12 net.http.server: Split out method for sending only the header
Kim Alvefur <zash@zash.se>
parents: 11409
diff changeset
337 end
eaff6e548f12 net.http.server: Split out method for sending only the header
Kim Alvefur <zash@zash.se>
parents: 11409
diff changeset
338 function _M.send_head_response(response)
eaff6e548f12 net.http.server: Split out method for sending only the header
Kim Alvefur <zash@zash.se>
parents: 11409
diff changeset
339 if response.finished then return; end
eaff6e548f12 net.http.server: Split out method for sending only the header
Kim Alvefur <zash@zash.se>
parents: 11409
diff changeset
340 _M.write_headers(response);
10323
73938168681c net.http.server: Ensure HEAD requests are sent with empty body
Kim Alvefur <zash@zash.se>
parents: 9624
diff changeset
341 response:done();
73938168681c net.http.server: Ensure HEAD requests are sent with empty body
Kim Alvefur <zash@zash.se>
parents: 9624
diff changeset
342 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
343 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
344 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
345 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
346 -- 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
347 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
348 response.headers.content_length = ("%d"):format(#body);
e9eeaefa09a7 Merge 0.11->trunk
Matthew Wild <mwild1@gmail.com>
parents: 11096 11159
diff changeset
349 end
10323
73938168681c net.http.server: Ensure HEAD requests are sent with empty body
Kim Alvefur <zash@zash.se>
parents: 9624
diff changeset
350 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
351 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
352 end
6082
d0e824a21861 net.http.server: Fix some typos introduced in 420c0d3b8583.
Daurnimator <quae@daurnimator.com>
parents: 6071
diff changeset
353 local output = prepare_header(response);
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
354 t_insert(output, body);
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
355 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
356 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
357 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
358 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
359 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
360 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
361 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
362 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
363 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
364 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
365 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
366 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
367 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
368 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
369 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
370 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
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 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
373 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
374 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
375 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
376 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
377 -- 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
378 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
379 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
380 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
381 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
382 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
383 -- 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
384 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
385 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
386 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
387 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
388 end
11527
eaff6e548f12 net.http.server: Split out method for sending only the header
Kim Alvefur <zash@zash.se>
parents: 11409
diff changeset
389 _M.write_headers(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
390 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
391 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
392 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
393 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
394 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
395 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
396 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
397 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
398 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
399 end
5300
fcb1be0b4a5c net.http.server: Properly handle persistent connections
Florian Zeitz <florob@babelmonkeys.de>
parents: 4788
diff changeset
400 if response.persistent then
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
401 response:finish_cb();
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
402 else
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
403 response.conn:close();
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
404 end
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
405 end
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
406 function _M.add_handler(event, handler, priority)
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
407 events.add_handler(event, handler, priority);
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
408 end
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
409 function _M.remove_handler(event, handler)
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
410 events.remove_handler(event, handler);
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
411 end
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
412
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
413 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
414 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
415 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
416 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
417 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
418 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
419 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
420 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
421 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
422 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
423 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
424 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
425 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
426 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
427 end
7579
d430573fe9f8 net.http.server: Expose way to set http server options
Kim Alvefur <zash@zash.se>
parents: 6589
diff changeset
428 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
429 options[name] = value;
d430573fe9f8 net.http.server: Expose way to set http server options
Kim Alvefur <zash@zash.se>
parents: 6589
diff changeset
430 end
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
431
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
432 _M.listener = listener;
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
433 _M.codes = codes;
4706
845393c76d17 net.http.server: Expose events object (for debug purposes)
Matthew Wild <mwild1@gmail.com>
parents: 4704
diff changeset
434 _M._events = events;
4631
fc5d3b053454 net.http.{server|codes|parser}: Initial commit.
Waqas Hussain <waqas20@gmail.com>
parents:
diff changeset
435 return _M;