https::HttpClientConfig cfg;

cfg.verifySsl = false; // the test certificate authenticates nothing

cfg.connectTimeoutMs = 4000;

cfg.readTimeoutMs = readTimeoutMs;

cfg.keepAlive = true; // the configuration under test

return cfg;

https::HttpRequest req;

req.method = https::Method::GET;

req.url = url;

return req;

tls_test::Server server([](tls_test::Conn& conn, int index) {

if (index == 0) {

conn.write("HTTP/1.1 200 OK\r\nContent-Length: 100\r\n\r\n");

conn.write(std::string(50, 'B'));

std::this_thread::sleep_for(std::chrono::milliseconds(1300));

conn.write(std::string(50, 'B')); // arrives after the read timeout

return true;

}

conn.write(tls_test::ok_response("second"));

return true;

});

ASSERT_FALSE(server.failed());

https::HttpClient client(test_config());

auto first = client.send(get(server.url("/one")));

EXPECT_EQ(first.statusCode, 200);

EXPECT_EQ(first.body, std::string(50, 'B'));

EXPECT_FALSE(first.bodyComplete)

<< "50 of 100 bytes arrived; the caller has no other way to learn that";

EXPECT_FALSE(first.bodyError.empty());

auto second = client.send(get(server.url("/two")));

EXPECT_EQ(second.statusCode, 200) << "status text was: " << second.statusText;

EXPECT_EQ(second.body, "second");

EXPECT_TRUE(second.bodyComplete);

// THE ASSERTION THE BYTES CANNOT MAKE.

EXPECT_EQ(server.accepts(), 2)

<< "the truncated connection was reused instead of being dropped";

tls_test::Server server([](tls_test::Conn& conn, int index) {

if (index == 0) {

conn.write("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n");

conn.write("10\r\n"); // 16 bytes announced

conn.write("0123456"); // 7 delivered now

std::this_thread::sleep_for(std::chrono::milliseconds(1300));

conn.write("789abcdef\r\n0\r\n\r\n"); // the rest, too late

return true;

}

conn.write(tls_test::ok_response("second"));

return true;

});

ASSERT_FALSE(server.failed());

https::HttpClient client(test_config());

auto first = client.send(get(server.url("/one")));

EXPECT_EQ(first.statusCode, 200);

EXPECT_FALSE(first.bodyComplete);

auto second = client.send(get(server.url("/two")));

EXPECT_EQ(second.statusCode, 200) << "status text was: " << second.statusText;

EXPECT_EQ(second.body, "second");

EXPECT_EQ(server.accepts(), 2);

tls_test::Server server([](tls_test::Conn& conn, int index) {

if (index == 0) {

conn.write("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n");

conn.write("4\r\nabcd\r\n");

conn.write("zz\r\n");

// Whatever follows a header the client could not parse is still on

// the wire, and a reused connection would read it as a status line.

conn.write("4\r\nefgh\r\n0\r\n\r\n");

return true;

}

conn.write(tls_test::ok_response("second"));

return true;

});

ASSERT_FALSE(server.failed());

https::HttpClient client(test_config());

auto first = client.send(get(server.url("/one")));

EXPECT_EQ(first.statusCode, 200);

EXPECT_EQ(first.body, "abcd");

EXPECT_FALSE(first.bodyComplete) << "`zz` was accepted as a terminal chunk";

EXPECT_NE(first.bodyError.find("zz"), std::string::npos);

// The server's real reason phrase survives; it used to be overwritten with

// the parse error, so a caller logging statusText on a 200 saw the error.

EXPECT_EQ(first.statusText, "OK");

auto second = client.send(get(server.url("/two")));

EXPECT_EQ(second.statusCode, 200);

EXPECT_EQ(server.accepts(), 2);

tls_test::Server server([](tls_test::Conn& conn, int index) {

if (index == 0) {

conn.write("HTTP/1.1 200 OK\r\nContent-Length: 4294967296\r\n\r\n");

conn.write("0123456789");

std::this_thread::sleep_for(std::chrono::milliseconds(1300));

conn.write("late-and-unread"); // still owed, and still arriving

return true;

}

conn.write(tls_test::ok_response("second"));

return true;

});

ASSERT_FALSE(server.failed());

// The size cap is lifted here on purpose. With the default 64 MiB it would

// refuse this response before reading a byte — correct, and a different

// mechanism from the one under test. Lifting it puts the reader back on the

// path where the truncation used to happen, so what this test observes is

// the width of the field and nothing else.

// (`ABodyLargerThanTheConfiguredLimitIsRefused` covers the cap.)

auto cfg = test_config();

cfg.maxResponseBodyBytes = std::numeric_limits<std::int64_t>::max();

https::HttpClient client(cfg);

auto first = client.send(get(server.url("/one")));

EXPECT_EQ(first.statusCode, 200);

EXPECT_EQ(first.body, "0123456789")

<< "the length truncated to zero, so the reader took the body for empty";

EXPECT_FALSE(first.bodyComplete);

auto second = client.send(get(server.url("/two")));

EXPECT_EQ(second.statusCode, 200) << "status text was: " << second.statusText;

EXPECT_EQ(second.body, "second");

EXPECT_EQ(server.accepts(), 2);

tls_test::Server server([](tls_test::Conn& conn, int) {

conn.write("BBBB 999 XHTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n");

return false;

});

ASSERT_FALSE(server.failed());

https::HttpClient client(test_config());

auto response = client.send(get(server.url("/")));

EXPECT_EQ(response.statusCode, 0) << "a body fragment was read as a status code";

EXPECT_EQ(response.statusText, "Invalid status line");

tls_test::Server server([](tls_test::Conn& conn, int index) {

conn.write(tls_test::ok_response(index == 0 ? "first" : "second"));

return true;

});

ASSERT_FALSE(server.failed());

https::HttpClient client(test_config());

auto first = client.send(get(server.url("/one")));

EXPECT_EQ(first.body, "first");

EXPECT_TRUE(first.bodyComplete);

auto second = client.send(get(server.url("/two")));

EXPECT_EQ(second.body, "second");

EXPECT_TRUE(second.bodyComplete);

EXPECT_EQ(server.accepts(), 1) << "keep-alive stopped reusing connections";

tls_test::Server server([](tls_test::Conn& conn, int index) {

conn.write(tls_test::ok_response(index == 0 ? "first" : "second"));

return true;

});

ASSERT_FALSE(server.failed());

auto cfg = test_config();

cfg.keepAlive = false;

https::HttpClient client(cfg);

EXPECT_EQ(client.send(get(server.url("/one"))).body, "first");

EXPECT_EQ(client.send(get(server.url("/two"))).body, "second");

// The request said `Connection: close`; a server that answers without

// echoing it used to leave the socket pooled anyway.

EXPECT_EQ(server.accepts(), 2);

tls_test::Server server([](tls_test::Conn& conn, int index) {

if (index == 0) {

conn.write("HTTP/1.1 302 Found\r\nLocation: /final\r\n"

"Content-Length: 27\r\n\r\n"

"<html>moved, see you</html>"); // 27 bytes exactly

return true;

}

conn.write(tls_test::ok_response("REDIRECTED-CONTENT"));

return true;

});

ASSERT_FALSE(server.failed());

https::HttpClient client(test_config());

auto response = client.send(get(server.url("/start")));

EXPECT_EQ(response.statusCode, 200) << "status text was: " << response.statusText;

EXPECT_EQ(response.body, "REDIRECTED-CONTENT")

<< "the redirect's own body was read as the final response";

EXPECT_TRUE(response.bodyComplete);

tls_test::Server server([](tls_test::Conn& conn, int index) {

if (index == 0) {

conn.write("HTTP/1.1 302 Found\r\nLocation: /final\r\n"

"Content-Length: 12\r\n\r\n"

"moved-along\n");

return true;

}

conn.write(tls_test::ok_response("REDIRECTED-FILE"));

return true;

});

ASSERT_FALSE(server.failed());

auto dir = std::filesystem::temp_directory_path() / "tinyhttps_pool_test";

std::filesystem::create_directories(dir);

auto dest = dir / "redirected.bin";

https::HttpClient client(test_config());

auto result = client.download_to_file(server.url("/start"), dest);

ASSERT_TRUE(result.ok()) << "error: " << result.error;

std::ifstream in(dest, std::ios::binary);

std::string content((std::istreambuf_iterator<char>(in)),

std::istreambuf_iterator<char>());

EXPECT_EQ(content, "REDIRECTED-FILE");

// A short 3xx body is drained rather than thrown away with the connection,

// so the redirect costs no second handshake. Correctness above does not

// depend on this number; reuse does.

EXPECT_EQ(server.accepts(), 1);

std::error_code ec;

std::filesystem::remove_all(dir, ec);

tls_test::Server server([](tls_test::Conn& conn, int index) {

if (index == 0) {

conn.write("HTTP/1.1 404 Not Found\r\nContent-Length: 9\r\n\r\n"

"not found");

return true;

}

conn.write(tls_test::ok_response("after-404"));

return true;

});

ASSERT_FALSE(server.failed());

auto dir = std::filesystem::temp_directory_path() / "tinyhttps_pool_404";

std::filesystem::create_directories(dir);

https::HttpClient client(test_config());

auto failed = client.download_to_file(server.url("/missing"), dir / "x.bin");

EXPECT_FALSE(failed.ok());

EXPECT_EQ(failed.statusCode, 404);

EXPECT_EQ(failed.error, "HTTP 404");

auto next = client.send(get(server.url("/present")));

EXPECT_EQ(next.statusCode, 200) << "status text was: " << next.statusText;

EXPECT_EQ(next.body, "after-404")

<< "the 404's body was read as the next response";

EXPECT_EQ(server.accepts(), 1);

std::error_code ec;

std::filesystem::remove_all(dir, ec);

tls_test::Server server([](tls_test::Conn& conn, int index) {

conn.write(tls_test::ok_response(index == 0 ? "first" : "second"));

return false; // answer, then close — as an idle-timeout would

});

ASSERT_FALSE(server.failed());

https::HttpClient client(test_config());

auto first = client.send(get(server.url("/one")));

EXPECT_EQ(first.statusCode, 200);

EXPECT_EQ(first.body, "first");

// Let the close reach us, so the pooled socket is genuinely dead.

std::this_thread::sleep_for(std::chrono::milliseconds(250));

auto second = client.send(get(server.url("/two")));

EXPECT_EQ(second.statusCode, 200)

<< "status text was: " << second.statusText

<< " — a dead pooled connection was reported instead of replaced";

EXPECT_EQ(second.body, "second");

EXPECT_EQ(server.accepts(), 2);

tls_test::Server server([](tls_test::Conn& conn, int) {

conn.write("HTTP/1.1 200"); // a head that never completes

return false;

});

ASSERT_FALSE(server.failed());

https::HttpClient client(test_config());

auto response = client.send(get(server.url("/once")));

EXPECT_EQ(response.statusCode, 0);

EXPECT_EQ(server.requests(), 1)

<< "a request the server had begun answering was sent a second time";

EXPECT_EQ(server.accepts(), 1);

tls_test::Server server([](tls_test::Conn& conn, int index) {

conn.write(tls_test::ok_response(index == 0 ? "first" : "second"));

return false;

});

ASSERT_FALSE(server.failed());

auto cfg = test_config();

cfg.retryOnStaleConnection = false;

https::HttpClient client(cfg);

EXPECT_EQ(client.send(get(server.url("/one"))).statusCode, 200);

std::this_thread::sleep_for(std::chrono::milliseconds(250));

auto second = client.send(get(server.url("/two")));

EXPECT_EQ(second.statusCode, 0)

<< "opting out of the retry must actually opt out";

tls_test::Server server([](tls_test::Conn& conn, int index) {

if (index == 0) {

conn.write("HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\n"

"Content-Length: 200\r\n\r\n");

conn.write("data: one\n\n");

conn.park();

return false;

}

conn.write(tls_test::ok_response("second"));

return true;

});

ASSERT_FALSE(server.failed());

https::HttpClient client(test_config());

int events = 0;

auto first = client.send_stream(get(server.url("/stream")),

[&](const https::SseEvent&) { ++events; return true; });

EXPECT_EQ(first.statusCode, 200);

EXPECT_EQ(events, 1);

EXPECT_FALSE(first.bodyComplete);

auto second = client.send(get(server.url("/two")));

EXPECT_EQ(second.statusCode, 200) << "status text was: " << second.statusText;

EXPECT_EQ(second.body, "second");

EXPECT_EQ(server.accepts(), 2);

tls_test::Server server([](tls_test::Conn& conn, int index) {

if (index == 0) {

conn.write("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n");

for (int i = 0; i < 20; ++i) conn.write("9\r\ndata: x\n\n\r\n");

conn.park();

return false;

}

conn.write(tls_test::ok_response("second"));

return true;

});

ASSERT_FALSE(server.failed());

https::HttpClient client(test_config());

int events = 0;

auto first = client.send_stream(get(server.url("/stream")),

[&](const https::SseEvent&) { ++events; return false; });

EXPECT_EQ(first.statusCode, 200);

EXPECT_EQ(first.statusText, "OK");

EXPECT_EQ(events, 1);

EXPECT_FALSE(first.bodyComplete);

auto second = client.send(get(server.url("/two")));

EXPECT_EQ(second.statusCode, 200) << "status text was: " << second.statusText;

EXPECT_EQ(server.accepts(), 2);

tls_test::Server server([](tls_test::Conn& conn, int) {

conn.write("HTTP/1.1 200 OK\r\nContent-Length: 100000\r\n\r\n");

conn.park();

return false;

});

ASSERT_FALSE(server.failed());

auto cfg = test_config();

cfg.maxResponseBodyBytes = 1024;

https::HttpClient client(cfg);

auto response = client.send(get(server.url("/big")));

EXPECT_EQ(response.statusCode, 200);

EXPECT_TRUE(response.body.empty()) << "refused before reading, not after";

EXPECT_FALSE(response.bodyComplete);

EXPECT_NE(response.bodyError.find("limit"), std::string::npos);

tls_test::Server server([](tls_test::Conn& conn, int index) {

if (index == 0) {

// A HEAD answer carries the length a GET would have returned, and

// no body. Reading it would consume the next response instead.

conn.write("HTTP/1.1 200 OK\r\nContent-Length: 500\r\n\r\n");

return true;

}

conn.write(tls_test::ok_response("after-head"));

return true;

});

ASSERT_FALSE(server.failed());

https::HttpClient client(test_config());

https::HttpRequest head;

head.method = https::Method::HEAD;

head.url = server.url("/thing");

auto headResponse = client.send(head);

EXPECT_EQ(headResponse.statusCode, 200);

EXPECT_TRUE(headResponse.body.empty());

EXPECT_TRUE(headResponse.bodyComplete);

auto next = client.send(get(server.url("/thing")));

EXPECT_EQ(next.body, "after-head");

EXPECT_EQ(server.accepts(), 1);

tls_test::Server server([](tls_test::Conn& conn, int index) {

if (index == 0) {

conn.write("HTTP/1.1 204 No Content\r\nContent-Length: 42\r\n\r\n");

return true;

}

conn.write(tls_test::ok_response("after-204"));

return true;

});

ASSERT_FALSE(server.failed());

https::HttpClient client(test_config());

auto empty = client.send(get(server.url("/nothing")));

EXPECT_EQ(empty.statusCode, 204);

EXPECT_TRUE(empty.body.empty());

EXPECT_TRUE(empty.bodyComplete);

EXPECT_EQ(client.send(get(server.url("/next"))).body, "after-204");

EXPECT_EQ(server.accepts(), 1);

tls_test::Server server([](tls_test::Conn& conn, int) {

conn.write("HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\n");

conn.write("connection-delimited-body");

conn.close_hard();

return false;

});

ASSERT_FALSE(server.failed());

https::HttpClient client(test_config());

auto response = client.send(get(server.url("/")));

EXPECT_EQ(response.statusCode, 200);

EXPECT_EQ(response.body, "connection-delimited-body");

EXPECT_TRUE(response.bodyComplete) << "bodyError was: " << response.bodyError;

EXPECT_TRUE(response.bodyError.empty());

tls_test::Server server([](tls_test::Conn& conn, int) {

conn.write("HTTP/1.1 200 OK\r\nContent-Type: application/octet-stream\r\n\r\n");

conn.write("0123456789abcdef");

conn.close_hard();

return false;

});

ASSERT_FALSE(server.failed());

auto dir = std::filesystem::temp_directory_path() / "tinyhttps_pool_close";

std::filesystem::create_directories(dir);

auto dest = dir / "closed.bin";

https::HttpClient client(test_config());

auto result = client.download_to_file(server.url("/blob"), dest);

EXPECT_TRUE(result.ok())

<< "a file that arrived complete was reported as failed: " << result.error;

EXPECT_EQ(result.bytesWritten, 16);

EXPECT_EQ(std::filesystem::file_size(dest), 16u);

std::error_code ec;

std::filesystem::remove_all(dir, ec);

tls_test::Server server([](tls_test::Conn& conn, int index) {

if (index == 0) {

conn.write("HTTP/1.1 103 Early Hints\r\n"

"Link: </style.css>; rel=preload\r\n\r\n");

conn.write(tls_test::ok_response("the-real-answer"));

return true;

}

conn.write(tls_test::ok_response("second"));

return true;

});

ASSERT_FALSE(server.failed());

https::HttpClient client(test_config());

auto first = client.send(get(server.url("/one")));

EXPECT_EQ(first.statusCode, 200) << "statusText was: " << first.statusText;

EXPECT_EQ(first.body, "the-real-answer");

EXPECT_TRUE(first.bodyComplete);

// The interim response's fields describe the interim response, not this one.

EXPECT_EQ(first.headers.count("Link"), 0u);

auto second = client.send(get(server.url("/two")));

EXPECT_EQ(second.statusCode, 200) << "statusText was: " << second.statusText;

EXPECT_EQ(second.body, "second")

<< "the real response was left on the socket and read by the next request";

EXPECT_EQ(server.accepts(), 1);

tls_test::Server server([](tls_test::Conn& conn, int) {

conn.write("HTTP/1.1 100 Continue\r\n\r\n");

conn.write("HTTP/1.1 103 Early Hints\r\nLink: </a.css>; rel=preload\r\n\r\n");

conn.write("HTTP/1.1 103 Early Hints\r\nLink: </b.css>; rel=preload\r\n\r\n");

conn.write(tls_test::ok_response("finally"));

return true;

});

ASSERT_FALSE(server.failed());

https::HttpClient client(test_config());

auto response = client.send(get(server.url("/")));

EXPECT_EQ(response.statusCode, 200) << "statusText was: " << response.statusText;

EXPECT_EQ(response.body, "finally");

EXPECT_TRUE(response.bodyComplete);

tls_test::Server server([](tls_test::Conn& conn, int) {

conn.write("HTTP/1.1 200 OK\r\n");

for (int i = 0; i < 400; ++i) {

conn.write("X-Filler-" + std::to_string(i) + ": aaaaaaaaaaaaaaaa\r\n");

}

conn.write("\r\n");

return false;

});

ASSERT_FALSE(server.failed());

https::HttpClient client(test_config());

auto response = client.send(get(server.url("/")));

EXPECT_EQ(response.statusCode, 0);

EXPECT_NE(response.statusText.find("Header block"), std::string::npos)

<< "statusText was: " << response.statusText;

tls_test::Server server([](tls_test::Conn& conn, int) {

conn.write("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n");

conn.write("4\r\nabcd\r\n");

conn.write("0\r\n");

for (int i = 0; i < 400; ++i) {

conn.write("X-Trailer-" + std::to_string(i) + ": v\r\n");

}

conn.write("\r\n");

return false;

});

ASSERT_FALSE(server.failed());

https::HttpClient client(test_config());

auto response = client.send(get(server.url("/")));

EXPECT_EQ(response.statusCode, 200);

EXPECT_EQ(response.body, "abcd") << "the body itself was well formed";

EXPECT_FALSE(response.bodyComplete);

EXPECT_NE(response.bodyError.find("Trailer"), std::string::npos)

<< "bodyError was: " << response.bodyError;

int listener = ::socket(AF_INET, SOCK_STREAM, 0);

ASSERT_GE(listener, 0);

int reuse = 1;

::setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof reuse);

sockaddr_in addr {};

addr.sin_family = AF_INET;

addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

addr.sin_port = 0;

ASSERT_EQ(::bind(listener, reinterpret_cast<sockaddr*>(&addr), sizeof addr), 0);

ASSERT_EQ(::listen(listener, 4), 0);

socklen_t len = sizeof addr;

ASSERT_EQ(::getsockname(listener, reinterpret_cast<sockaddr*>(&addr), &len), 0);

const int port = ntohs(addr.sin_port);

const pid_t child = ::fork();

ASSERT_GE(child, 0);

if (child == 0) {

::close(listener);

// Undo whatever else in this binary disarmed it. This is the disposition

// a program that has never thought about SIGPIPE has.

::signal(SIGPIPE, SIG_DFL);

mcpplibs::tinyhttps::Socket sock;

if (!sock.connect("127.0.0.1", port, 4000)) _exit(3);

// Give the parent time to accept and slam the connection shut.

::usleep(300 * 1000);

// THE LOOP DOES NOT STOP AT THE FIRST FAILURE, AND THAT IS THE WHOLE

// POINT. A write to a socket that has just received an RST returns

// ECONNRESET and raises nothing; it is the write AFTER that one which

// gets EPIPE, and EPIPE is what SIGPIPE accompanies. A loop that broke

// on the first non-positive return would exit cleanly whether or not

// MSG_NOSIGNAL was there — measured: it did.

const std::string payload(4096, 'x');

int last = 1;

for (int i = 0; i < 8; ++i) {

last = sock.write(payload.data(), static_cast<int>(payload.size()));

::usleep(20 * 1000);

}

_exit(last <= 0 ? 0 : 4); // 0 = the write reported failure, as it must

}

sockaddr_in peer {};

socklen_t peerLen = sizeof peer;

const int accepted = ::accept(listener, reinterpret_cast<sockaddr*>(&peer), &peerLen);

if (accepted >= 0) {

// Zero linger turns the close into an RST, so the child's next write

// meets a connection that is not merely half-closed but gone.

struct linger lg { 1, 0 };

::setsockopt(accepted, SOL_SOCKET, SO_LINGER, &lg, sizeof lg);

::close(accepted);

}

::close(listener);

int status = 0;

ASSERT_EQ(::waitpid(child, &status, 0), child);

ASSERT_FALSE(WIFSIGNALED(status))

<< "the child was killed by signal " << WTERMSIG(status)

<< " (13 is SIGPIPE, which reaches a shell as exit status 141) — "

"Socket::write is sending without MSG_NOSIGNAL";

EXPECT_EQ(WEXITSTATUS(status), 0)

<< "child exit code 3 = could not connect, 4 = the write never failed";