mod_posix: Move everything to util.startup
This allows greater control over the order of events.
Notably, the internal ordering between daemonization, initialization of
libunbound and setup of signal handling is sensitive.
libunbound starts a separate thread for processing DNS requests.
If this thread is started before signal handling has been set up, it
will not inherit the signal handlers and instead behave as it would have
before signal handlers were set up, i.e. cause the whole process to
immediately exit.
libunbound is usually initialized on the first DNS request, usually
triggered by an outgoing s2s connection attempt.
If daemonization happens before signals have been set up, signals may
not be processed at all.
local http_parser = require "net.http.parser";
local sha1 = require "util.hashes".sha1;
local parser_input_bytes = 3;
local function CRLF(s)
return (s:gsub("\n", "\r\n"));
end
local function test_stream(stream, expect)
local chunks_processed = 0;
local success_cb = spy.new(function (packet)
assert.is_table(packet);
if packet.body ~= false then
assert.is_equal(expect.body, packet.body);
end
if expect.chunks then
if chunks_processed == 0 then
assert.is_true(packet.partial);
packet.body_sink = {
write = function (_, data)
chunks_processed = chunks_processed + 1;
assert.equal(expect.chunks[chunks_processed], data);
return true;
end;
};
end
end
end);
local function options_cb()
return {
-- Force streaming API mode
body_size_limit = expect.chunks and 0 or nil;
buffer_size_limit = 10*1024*2;
};
end
local parser = http_parser.new(success_cb, error, (stream[1] or stream):sub(1,4) == "HTTP" and "client" or "server", options_cb)
if type(stream) == "string" then
for chunk in stream:gmatch("."..string.rep(".?", parser_input_bytes-1)) do
parser:feed(chunk);
end
else
for _, chunk in ipairs(stream) do
parser:feed(chunk);
end
end
if expect.chunks then
assert.equal(chunks_processed, #expect.chunks);
end
assert.spy(success_cb).was_called(expect.count or 1);
end
describe("net.http.parser", function()
describe("parser", function()
it("should handle requests with no content-length or body", function ()
test_stream(
CRLF[[
GET / HTTP/1.1
Host: example.com
]],
{
body = "";
}
);
end);
it("should handle responses with empty body", function ()
test_stream(
CRLF[[
HTTP/1.1 200 OK
Content-Length: 0
]],
{
body = "";
}
);
end);
it("should handle simple responses", function ()
test_stream(
CRLF[[
HTTP/1.1 200 OK
Content-Length: 7
Hello
]],
{
body = "Hello\r\n", count = 1;
}
);
end);
it("should handle chunked encoding in responses", function ()
test_stream(
CRLF[[
HTTP/1.1 200 OK
Transfer-Encoding: chunked
1
H
1
e
2
ll
1
o
0
]],
{
body = "Hello", count = 3;
}
);
end);
it("should handle a stream of responses", function ()
test_stream(
CRLF[[
HTTP/1.1 200 OK
Content-Length: 5
Hello
HTTP/1.1 200 OK
Transfer-Encoding: chunked
1
H
1
e
2
ll
1
o
0
]],
{
body = "Hello", count = 4;
}
);
end);
it("should correctly find chunk boundaries", function ()
test_stream({
CRLF[[
HTTP/1.1 200 OK
Transfer-Encoding: chunked
]].."3\r\n:)\n\r\n"},
{
count = 1; -- Once (partial)
chunks = {
":)\n"
};
}
);
end);
it("should reject very large request heads", function()
local finished = false;
local success_cb = spy.new(function()
finished = true;
end)
local error_cb = spy.new(function()
finished = true;
end)
local parser = http_parser.new(success_cb, error_cb, "server", function()
return { head_size_limit = 1024; body_size_limit = 1024; buffer_size_limit = 2048 };
end)
parser:feed("GET / HTTP/1.1\r\n");
for i = 1, 64 do -- * header line > buffer_size_limit
parser:feed(string.format("Header-%04d: Yet-AnotherValue\r\n", i));
if finished then
-- should hit an error around half-way
break
end
end
if not finished then
parser:feed("\r\n")
end
assert.spy(success_cb).was_called(0);
assert.spy(error_cb).was_called(1);
assert.spy(error_cb).was_called_with("header-too-large");
end)
end);
it("should handle large chunked responses", function ()
local data = io.open("spec/inputs/http/httpstream-chunked-test.txt", "rb"):read("*a");
-- Just a sanity check... text editors and things may mess with line endings, etc.
assert.equal("25930f021785ae14053a322c2dbc1897c3769720", sha1(data, true), "test data malformed");
test_stream(data, {
body = string.rep("~", 11085), count = 3;
});
end);
end);