aboutsummaryrefslogtreecommitdiffstats
path: root/net/httpserver.lua
blob: 33ced072c4e5d8e399fa8245e9996048df147f4b (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
-- Prosody IM
-- Copyright (C) 2008-2010 Matthew Wild
-- Copyright (C) 2008-2010 Waqas Hussain
-- 
-- This project is MIT/X11 licensed. Please see the
-- COPYING file in the source package for more information.
--


local server = require "net.server"
local url_parse = require "socket.url".parse;
local httpstream_new = require "util.httpstream".new;

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 tonumber, tostring, pairs, ipairs, type = tonumber, tostring, pairs, ipairs, type;

local urlencode = function (s) return s and (s:gsub("%W", function (c) return ("%%%02x"):format(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 or response.headers then
		local body = response.body and tostring(response.body);
		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..": "..v.."\r\n");
			end
		end
		if body and not (h and h["Content-Length"]) then
			t_insert(resp, "Content-Length: "..#body.."\r\n");
		end
		t_insert(resp, "\r\n");
		
		if body and request.method ~= "HEAD" then
			t_insert(resp, body);
		end
		request.write(t_concat(resp));
	else
		-- Response we have is just a string (the body)
		log("debug", "Sending 200 response to %s", request.id or "<none>");
		
		local resp = "HTTP/1.0 200 OK\r\n"
			.. "Connection: close\r\n"
			.. "Content-Type: text/html\r\n"
			.. "Content-Length: "..#response.."\r\n"
			.. "\r\n"
			.. response;
		
		request.write(resp);
	end
	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;
	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("debug", "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 request.parser then
		local function success_cb(r)
			for k,v in pairs(r) do request[k] = v; end
			request.url = url_parse(request.path);
			request.url.path = request.url.path and request.url.path:gsub("%%(%x%x)", function(x) return x.char(tonumber(x, 16)) end);
			request.body = { request.body };
			call_callback(request);
		end
		local function error_cb(r)
			log("error", "Error in HTTP server handler: %s", r or "connection-closed");
			call_callback(request, r or "connection-closed");
			destroy_request(request);
		end
		request.parser = httpstream_new(success_cb, error_cb);
	end
	request.parser:feed(data);
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,
			write = function (...) return handler:write(...); end, 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.ondisconnect(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

function set_default_handler(handler)
	default_handler = handler;
end

function new_from_config(ports, handle_request, default_options)
	if type(handle_request) == "string" then -- COMPAT with old plugins
		log("warn", "Old syntax of httpserver.new_from_config being used to register %s", handle_request);
		handle_request, default_options = default_options, { base = handle_request };
	end
	ports = ports or {5280};
	for _, options in ipairs(ports) do
		local port = default_options.port or 5280;
		local base = default_options.base;
		local ssl = default_options.ssl or false;
		local interface = default_options.interface;
		if type(options) == "number" then
			port = options;
		elseif type(options) == "table" then
			port = options.port or port;
			base = options.path or base;
			ssl = options.ssl or ssl;
			interface = options.interface or interface;
		elseif type(options) == "string" then
			base = options;
		end
		
		if ssl then
			ssl.mode = "server";
			ssl.protocol = "sslv23";
			ssl.options = "no_sslv2";
		end
		
		new{ port = port, interface = interface,
			base = base, handler = handle_request,
			ssl = ssl, type = (ssl and "ssl") or "tcp" };
	end
end

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

return _M;