aboutsummaryrefslogtreecommitdiffstats
path: root/net/httpserver.lua
blob: 0ecf84ea4e84bf5a24c010bced0c73e2400682b1 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250

local socket = require "socket"
local server = require "net.server"
local url_parse = require "socket.url".parse;

local connlisteners_start = require "net.connlisteners".start;
local connlisteners_get = require "net.connlisteners".get;
local listener;

local t_insert, t_concat = table.insert, table.concat;
local s_match, s_gmatch, s_char = string.match, string.gmatch;
local tonumber, tostring, pairs = tonumber, tostring, pairs;

local urlcodes = setmetatable({}, { __index = function (t, k) t[k] = s_char(tonumber("0x"..k)); return t[k]; end });
local urlencode = function (s) return s and (s:gsub("%W", function (c) return string.format("%%%x", c:byte()); end)); end

local log = require "util.logger".init("httpserver");

local http_servers = {};

module "httpserver"

local default_handler;

local function expectbody(reqt)
    return reqt.method == "POST";
end

local function send_response(request, response)
	-- Write status line
	local resp;
	if response.body then
		log("debug", "Sending response to %s", request.id);
		resp = { "HTTP/1.0 ", response.status or "200 OK", "\r\n"};
		local h = response.headers;
		if h then
			for k, v in pairs(h) do
				t_insert(resp, k);
				t_insert(resp, ": ");
				t_insert(resp, v);
				t_insert(resp, "\r\n");
			end
		end
		if response.body and not (h and h["Content-Length"]) then
			t_insert(resp, "Content-Length: ");
			t_insert(resp, #response.body);
			t_insert(resp, "\r\n");
		end
		t_insert(resp, "\r\n");
		
		if response.body and request.method ~= "HEAD" then
			t_insert(resp, response.body);
		end
	else
		-- Response we have is just a string (the body)
		log("debug", "Sending response to %s: %s", request.id, response);
		
		resp = { "HTTP/1.0 200 OK\r\n" };
		t_insert(resp, "Connection: close\r\n");
		t_insert(resp, "Content-Length: ");
		t_insert(resp, #response);
		t_insert(resp, "\r\n\r\n");
		
		t_insert(resp, response);
	end
	request.write(t_concat(resp));
	if not request.stayopen then
		request:destroy();
	end
end

local function call_callback(request, err)
	if request.handled then return; end
	request.handled = true;
	local callback = request.callback;
	if not callback and request.path then
		local path = request.url.path;
		local base = path:match("^/([^/?]+)");
		if not base then
			base = path:match("^http://[^/?]+/([^/?]+)");
		end
		
		callback = (request.server and request.server.handlers[base]) or default_handler;
		if callback == default_handler then
			log("debug", "Default callback for this request (base: "..tostring(base)..")")
		end
	end
	if callback then
		if err then
			log("debug", "Request error: "..err);
			if not callback(nil, err, request) then
				destroy_request(request);
			end
			return;
		end
		
		local response = callback(request.method, request.body and t_concat(request.body), request);
		if response then
			if response == true and not request.destroyed then
				-- Keep connection open, we will reply later
				log("warn", "Request %s left open, on_destroy is %s", request.id, tostring(request.on_destroy));
			elseif response ~= true then
				-- Assume response
				send_response(request, response);
				destroy_request(request);
			end
		else
			log("debug", "Request handler provided no response, destroying request...");
			-- No response, close connection
			destroy_request(request);
		end
	end
end

local function request_reader(request, data, startpos)
	if not data then
		if request.body then
			call_callback(request);
		else
			-- Error.. connection was closed prematurely
			call_callback(request, "connection-closed");
		end
		-- Here we force a destroy... the connection is gone, so we can't reply later
		destroy_request(request);
		return;
	end
	if request.state == "body" then
		log("debug", "Reading body...")
		if not request.body then request.body = {}; request.havebodylength, request.bodylength = 0, tonumber(request.headers["content-length"]); end
		if startpos then
			data = data:sub(startpos, -1)
		end
		t_insert(request.body, data);
		if request.bodylength then
			request.havebodylength = request.havebodylength + #data;
			if request.havebodylength >= request.bodylength then
				-- We have the body
				call_callback(request);
			end
		end
	elseif request.state == "headers" then
		log("debug", "Reading headers...")
		local pos = startpos;
		local headers = request.headers or {};
		for line in data:gmatch("(.-)\r\n") do
			startpos = (startpos or 1) + #line + 2;
			local k, v = line:match("(%S+): (.+)");
			if k and v then
				headers[k:lower()] = v;
--				log("debug", "Header: "..k:lower().." = "..v);
			elseif #line == 0 then
				request.headers = headers;
				break;
			else
				log("debug", "Unhandled header line: "..line);
			end
		end
		
		if not expectbody(request) then 
			call_callback(request);
			return;
		end
		
		-- Reached the end of the headers
		request.state = "body";
		if #data > startpos then
			return request_reader(request, data:sub(startpos, -1));
		end
	elseif request.state == "request" then
		log("debug", "Reading request line...")
		local method, path, http, linelen = data:match("^(%S+) (%S+) HTTP/(%S+)\r\n()", startpos);
		if not method then
			return call_callback(request, "invalid-status-line");
		end
		
		request.method, request.path, request.httpversion = method, path, http;
		
		request.url = url_parse(request.path);
		
		log("debug", method.." request for "..tostring(request.path) .. " on port "..request.handler.serverport());
		
		if request.onlystatus then
			if not call_callback(request) then
				return;
			end
		end
		
		request.state = "headers";
		
		if #data > linelen then
			return request_reader(request, data:sub(linelen, -1));
		end
	end
end

-- The default handler for requests
default_handler = function (method, body, request)
	log("debug", method.." request for "..tostring(request.path) .. " on port "..request.handler.serverport());
	return { status = "404 Not Found", 
			headers = { ["Content-Type"] = "text/html" },
			body = "<html><head><title>Page Not Found</title></head><body>Not here :(</body></html>" };
end


function new_request(handler)
	return { handler = handler, conn = handler.socket, 
			write = handler.write, state = "request", 
			server = http_servers[handler.serverport()],
			send = send_response,
			destroy = destroy_request,
			id = tostring{}:match("%x+$")
			 };
end

function destroy_request(request)
	log("debug", "Destroying request %s", request.id);
	listener = listener or connlisteners_get("httpserver");
	if not request.destroyed then
		request.destroyed = true;
		if request.on_destroy then
			log("debug", "Request has destroy callback");
			request.on_destroy(request);
		else
			log("debug", "Request has no destroy callback");
		end
		request.handler.close()
		if request.conn then
			listener.disconnect(request.conn, "closed");
		end
	end
end

function new(params)
	local http_server = http_servers[params.port];
	if not http_server then
		http_server = { handlers = {} };
		http_servers[params.port] = http_server;
		-- We weren't already listening on this port, so start now
		connlisteners_start("httpserver", params);
	end
	if params.base then
		http_server.handlers[params.base] = params.handler;
	end
end

_M.request_reader = request_reader;
_M.send_response = send_response;
_M.urlencode = urlencode;

return _M;