mirror of
https://github.com/yhirose/cpp-httplib.git
synced 2026-11-21 20:01:46 +00:00
Support keep-alive parking in SSLServer
SSLServer::TlsConnection plugs the TLS session into the parked connection. A worker runs the handshake when the event loop sees the ClientHello, so a connection that has not started it, or has gone quiet after it, waits in the event loop instead of holding a worker. The handshake counts as having read what the loop saw, and a connection that has finished it waits for room like a served one when the queue is full. close_notify sent from the event loop does not block. SSLServer::start_session() holds the session setup and handshake that both the blocking path and TlsConnection use, and supports_keep_alive_parking() goes away.
This commit is contained in:
1 parent
d730627815
commit
b99ccee3db
3 files changed
+160
-39
No files matched your search
@@ -930,10 +930,11 @@ By default, a kept-alive connection holds a worker thread while it waits for its
|
|||||||
With it:
|
With it:
|
||||||
|
|
||||||
- Consecutive requests on a connection may run on different threads.
|
- Consecutive requests on a connection may run on different threads.
|
||||||
- When the [max queued requests](#max-queued-requests) limit is reached, only a connection that has not been served yet is closed. An established one waits for room.
|
- When the [max queued requests](#max-queued-requests) limit is reached, only a connection that has not been served yet (or, with `SSLServer`, has not finished its TLS handshake) is closed. An established one waits for room.
|
||||||
- Each request pays for handing the connection over, so with no more connections than threads and very light handlers, it can serve fewer requests per second.
|
- Each request pays for handing the connection over, so with no more connections than threads and very light handlers, it can serve fewer requests per second.
|
||||||
- A handler, a content provider and a WebSocket still hold their thread while they run.
|
- A handler, a content provider and a WebSocket still hold their thread while they run.
|
||||||
- `SSLServer` ignores it for now.
|
- A subclass that overrides the private `process_and_close_socket()` is bypassed.
|
||||||
|
- `SSLServer` runs the TLS handshake on a worker when the client starts it. Until then the connection waits in the event loop and is closed at the keep-alive timeout, not the read timeout, and `ssl_last_error()` is not set for it.
|
||||||
|
|
||||||
### Client address behind a reverse proxy
|
### Client address behind a reverse proxy
|
||||||
|
|
||||||
|
|||||||
@@ -2584,7 +2584,6 @@ private:
|
|||||||
ContentReceiver multipart_receiver) const;
|
ContentReceiver multipart_receiver) const;
|
||||||
|
|
||||||
virtual bool process_and_close_socket(socket_t sock);
|
virtual bool process_and_close_socket(socket_t sock);
|
||||||
virtual bool supports_keep_alive_parking() const;
|
|
||||||
// The connection that parking_loop() keeps for a socket it has accepted.
|
// The connection that parking_loop() keeps for a socket it has accepted.
|
||||||
virtual std::shared_ptr<KeepAliveConnection>
|
virtual std::shared_ptr<KeepAliveConnection>
|
||||||
new_keep_alive_connection(socket_t sock);
|
new_keep_alive_connection(socket_t sock);
|
||||||
@@ -3548,7 +3547,12 @@ public:
|
|||||||
|
|
||||||
private:
|
private:
|
||||||
bool process_and_close_socket(socket_t sock) override;
|
bool process_and_close_socket(socket_t sock) override;
|
||||||
bool supports_keep_alive_parking() const override;
|
std::shared_ptr<KeepAliveConnection>
|
||||||
|
new_keep_alive_connection(socket_t sock) override;
|
||||||
|
struct TlsConnection;
|
||||||
|
// Creates a session and runs the handshake. Null on failure, which sets
|
||||||
|
// last_ssl_error_.
|
||||||
|
tls::session_t start_session(socket_t sock);
|
||||||
|
|
||||||
tls::ctx_t ctx_ = nullptr;
|
tls::ctx_t ctx_ = nullptr;
|
||||||
// update_certs_pem() replaces the certificates and CAs that handshakes read
|
// update_certs_pem() replaces the certificates and CAs that handshakes read
|
||||||
@@ -14321,7 +14325,7 @@ struct Server::KeepAliveConnection {
|
|||||||
}
|
}
|
||||||
|
|
||||||
// On a worker before the first request, e.g. for a TLS handshake. False
|
// On a worker before the first request, e.g. for a TLS handshake. False
|
||||||
// closes the connection.
|
// closes the connection. One that reads from the socket clears turn.woken.
|
||||||
virtual bool open() { return true; }
|
virtual bool open() { return true; }
|
||||||
// Serves requests while they come: serve_on() with the transport's stream.
|
// Serves requests while they come: serve_on() with the transport's stream.
|
||||||
virtual bool serve() = 0;
|
virtual bool serve() = 0;
|
||||||
@@ -15586,9 +15590,8 @@ inline bool Server::listen_internal() {
|
|||||||
{
|
{
|
||||||
std::unique_ptr<TaskQueue> task_queue(new_task_queue());
|
std::unique_ptr<TaskQueue> task_queue(new_task_queue());
|
||||||
|
|
||||||
ret = keep_alive_parking_ && parking_ && supports_keep_alive_parking()
|
ret = keep_alive_parking_ && parking_ ? parking_loop(*task_queue)
|
||||||
? parking_loop(*task_queue)
|
: accept_loop(*task_queue);
|
||||||
: accept_loop(*task_queue);
|
|
||||||
|
|
||||||
task_queue->shutdown();
|
task_queue->shutdown();
|
||||||
}
|
}
|
||||||
@@ -16481,8 +16484,6 @@ inline bool Server::abandon_listen_socket() {
|
|||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
inline bool Server::supports_keep_alive_parking() const { return true; }
|
|
||||||
|
|
||||||
// Like accept_loop(), but a connection waiting for its next request sits in
|
// Like accept_loop(), but a connection waiting for its next request sits in
|
||||||
// the poller instead of keeping a worker. A worker serves a connection while it
|
// the poller instead of keeping a worker. A worker serves a connection while it
|
||||||
// has requests to read, then gives it back to this loop.
|
// has requests to read, then gives it back to this loop.
|
||||||
@@ -20149,7 +20150,45 @@ inline bool SSLServer::is_valid() const {
|
|||||||
return ctx_ != nullptr && Server::is_valid();
|
return ctx_ != nullptr && Server::is_valid();
|
||||||
}
|
}
|
||||||
|
|
||||||
inline bool SSLServer::process_and_close_socket(socket_t sock) {
|
// A connection that keep-alive parking keeps for SSLServer. The worker that
|
||||||
|
// first resumes it runs the handshake, so one that has not sent its
|
||||||
|
// ClientHello yet waits in the event loop like an idle connection.
|
||||||
|
struct SSLServer::TlsConnection final : Server::KeepAliveConnection {
|
||||||
|
TlsConnection(socket_t s, SSLServer &server)
|
||||||
|
: KeepAliveConnection(s, server), ssl_svr(server) {}
|
||||||
|
~TlsConnection() override { tls::free_session(session); }
|
||||||
|
|
||||||
|
bool open() override {
|
||||||
|
// A handshake would hold up the stop() that is under way.
|
||||||
|
if (ssl_svr.is_stopping()) { return false; }
|
||||||
|
session = ssl_svr.start_session(sock);
|
||||||
|
if (!session) { return false; }
|
||||||
|
// The handshake has read what the event loop saw, so a client that sends
|
||||||
|
// nothing after it is parked instead of being waited for.
|
||||||
|
turn.woken = false;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
// The session, not the stream, holds what a pipelined request has left.
|
||||||
|
bool serve() override {
|
||||||
|
detail::SSLSocketStream strm(
|
||||||
|
sock, session, ssl_svr.read_timeout_sec_, ssl_svr.read_timeout_usec_,
|
||||||
|
ssl_svr.write_timeout_sec_, ssl_svr.write_timeout_usec_);
|
||||||
|
return serve_on(strm, [this](Request &req) { req.ssl = session; });
|
||||||
|
}
|
||||||
|
|
||||||
|
void shut_down(bool graceful) override { tls::shutdown(session, graceful); }
|
||||||
|
|
||||||
|
SSLServer &ssl_svr;
|
||||||
|
tls::session_t session = nullptr;
|
||||||
|
};
|
||||||
|
|
||||||
|
inline std::shared_ptr<Server::KeepAliveConnection>
|
||||||
|
SSLServer::new_keep_alive_connection(socket_t sock) {
|
||||||
|
return std::make_shared<TlsConnection>(sock, *this);
|
||||||
|
}
|
||||||
|
|
||||||
|
inline tls::session_t SSLServer::start_session(socket_t sock) {
|
||||||
using namespace tls;
|
using namespace tls;
|
||||||
|
|
||||||
session_t session = nullptr;
|
session_t session = nullptr;
|
||||||
@@ -20162,29 +20201,17 @@ inline bool SSLServer::process_and_close_socket(socket_t sock) {
|
|||||||
|
|
||||||
if (!session) {
|
if (!session) {
|
||||||
last_ssl_error_ = static_cast<int>(get_error());
|
last_ssl_error_ = static_cast<int>(get_error());
|
||||||
detail::shutdown_socket(sock);
|
return nullptr;
|
||||||
detail::close_socket(sock);
|
|
||||||
return false;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// Use scope_exit to ensure cleanup on all paths (including exceptions)
|
// Frees the session on all paths but success (including exceptions)
|
||||||
bool handshake_done = false;
|
auto accepted = false;
|
||||||
bool ret = false;
|
|
||||||
bool websocket_upgraded = false;
|
|
||||||
auto cleanup = detail::scope_exit([&] {
|
auto cleanup = detail::scope_exit([&] {
|
||||||
if (handshake_done) { shutdown(session, !websocket_upgraded && ret); }
|
if (!accepted) { free_session(session); }
|
||||||
free_session(session);
|
|
||||||
if (handshake_done) {
|
|
||||||
detail::drain_and_close_socket(sock);
|
|
||||||
} else {
|
|
||||||
detail::shutdown_socket(sock);
|
|
||||||
detail::close_socket(sock);
|
|
||||||
}
|
|
||||||
});
|
});
|
||||||
|
|
||||||
// Perform TLS accept handshake with timeout
|
// Perform TLS accept handshake with timeout
|
||||||
TlsError tls_err;
|
TlsError tls_err;
|
||||||
auto accepted = false;
|
|
||||||
{
|
{
|
||||||
auto handshake_left = detail::scope_exit([&] {
|
auto handshake_left = detail::scope_exit([&] {
|
||||||
std::lock_guard<std::mutex> guard(ctx_mutex_);
|
std::lock_guard<std::mutex> guard(ctx_mutex_);
|
||||||
@@ -20206,10 +20233,27 @@ inline bool SSLServer::process_and_close_socket(socket_t sock) {
|
|||||||
#else
|
#else
|
||||||
last_ssl_error_ = static_cast<int>(get_error());
|
last_ssl_error_ = static_cast<int>(get_error());
|
||||||
#endif
|
#endif
|
||||||
|
return nullptr;
|
||||||
|
}
|
||||||
|
return session;
|
||||||
|
}
|
||||||
|
|
||||||
|
inline bool SSLServer::process_and_close_socket(socket_t sock) {
|
||||||
|
auto session = start_session(sock);
|
||||||
|
if (!session) {
|
||||||
|
detail::shutdown_socket(sock);
|
||||||
|
detail::close_socket(sock);
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
handshake_done = true;
|
// Use scope_exit to ensure cleanup on all paths (including exceptions)
|
||||||
|
bool ret = false;
|
||||||
|
bool websocket_upgraded = false;
|
||||||
|
auto cleanup = detail::scope_exit([&] {
|
||||||
|
tls::shutdown(session, !websocket_upgraded && ret);
|
||||||
|
tls::free_session(session);
|
||||||
|
detail::drain_and_close_socket(sock);
|
||||||
|
});
|
||||||
|
|
||||||
std::string remote_addr;
|
std::string remote_addr;
|
||||||
int remote_port = 0;
|
int remote_port = 0;
|
||||||
@@ -20235,9 +20279,6 @@ inline bool SSLServer::process_and_close_socket(socket_t sock) {
|
|||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
|
|
||||||
// Not yet: the TLS session would have to live in the parked connection.
|
|
||||||
inline bool SSLServer::supports_keep_alive_parking() const { return false; }
|
|
||||||
|
|
||||||
inline bool SSLServer::update_certs_pem(const char *cert_pem,
|
inline bool SSLServer::update_certs_pem(const char *cert_pem,
|
||||||
const char *key_pem,
|
const char *key_pem,
|
||||||
const char *client_ca_pem,
|
const char *client_ca_pem,
|
||||||
|
|||||||
+87
-8
@@ -76,8 +76,13 @@ ctx_t create_server_context();
|
|||||||
void free_context(ctx_t ctx);
|
void free_context(ctx_t ctx);
|
||||||
bool set_server_cert_file(ctx_t ctx, const char *cert_path,
|
bool set_server_cert_file(ctx_t ctx, const char *cert_path,
|
||||||
const char *key_path, const char *password);
|
const char *key_path, const char *password);
|
||||||
|
ctx_t create_client_context();
|
||||||
|
void set_verify_client(ctx_t ctx, bool require);
|
||||||
session_t create_session(ctx_t ctx, socket_t sock);
|
session_t create_session(ctx_t ctx, socket_t sock);
|
||||||
void free_session(session_t session);
|
void free_session(session_t session);
|
||||||
|
bool connect_nonblocking(session_t session, socket_t sock, time_t timeout_sec,
|
||||||
|
time_t timeout_usec, TlsError *err,
|
||||||
|
const std::function<bool()> &interrupted);
|
||||||
bool accept_nonblocking(session_t session, socket_t sock, time_t timeout_sec,
|
bool accept_nonblocking(session_t session, socket_t sock, time_t timeout_sec,
|
||||||
time_t timeout_usec, TlsError *err);
|
time_t timeout_usec, TlsError *err);
|
||||||
ssize_t read(session_t session, void *buf, size_t len, TlsError &err);
|
ssize_t read(session_t session, void *buf, size_t len, TlsError &err);
|
||||||
@@ -34406,20 +34411,94 @@ TEST(KeepAliveParkingTest, StopClosesParkedConnectionsPromptly) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
#ifdef CPPHTTPLIB_SSL_ENABLED
|
#ifdef CPPHTTPLIB_SSL_ENABLED
|
||||||
TEST(KeepAliveParkingTest, SSLServerServesAsBefore) {
|
namespace parking_test {
|
||||||
|
|
||||||
|
// Completes a TLS handshake on `sock` and sends nothing more, like a browser
|
||||||
|
// that has opened a connection ahead of time. Freeing the session sends no
|
||||||
|
// close_notify, so the connection stays quiet.
|
||||||
|
bool handshake_only(socket_t sock) {
|
||||||
|
auto ctx = tls::create_client_context();
|
||||||
|
tls::set_verify_client(ctx, false);
|
||||||
|
auto session = tls::create_session(ctx, sock);
|
||||||
|
auto se = detail::scope_exit([&] {
|
||||||
|
tls::free_session(session);
|
||||||
|
tls::free_context(ctx);
|
||||||
|
});
|
||||||
|
tls::TlsError err;
|
||||||
|
return session &&
|
||||||
|
tls::connect_nonblocking(session, sock, 2, 0, &err, nullptr);
|
||||||
|
}
|
||||||
|
|
||||||
|
Client tls_client(int port) {
|
||||||
|
Client cli("https://127.0.0.1:" + std::to_string(port));
|
||||||
|
cli.enable_server_certificate_verification(false);
|
||||||
|
cli.set_keep_alive(true);
|
||||||
|
cli.set_connection_timeout(1);
|
||||||
|
cli.set_read_timeout(1);
|
||||||
|
return cli;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool tls_get_ok(Client &cli) {
|
||||||
|
auto res = cli.Get("/");
|
||||||
|
return res && res->body == "ok";
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace parking_test
|
||||||
|
|
||||||
|
TEST(KeepAliveParkingTest, IdleTlsConnectionsDoNotHoldTheWorkers) {
|
||||||
|
using namespace parking_test;
|
||||||
|
SSLServer svr(SERVER_CERT_FILE, SERVER_PRIVATE_KEY_FILE);
|
||||||
|
ASSERT_TRUE(svr.is_valid());
|
||||||
|
serve_ok(svr, threads(1));
|
||||||
|
svr.set_read_timeout(1); // so that a failing run does not take long
|
||||||
|
RunningServer running(svr);
|
||||||
|
Sockets socks;
|
||||||
|
|
||||||
|
// One served connection, some that have not started their handshake, and
|
||||||
|
// one that has finished it and gone quiet. None may keep the only worker.
|
||||||
|
auto served = tls_client(running.port);
|
||||||
|
ASSERT_TRUE(tls_get_ok(served));
|
||||||
|
for (int i = 0; i < 10; i++) {
|
||||||
|
ASSERT_NE(INVALID_SOCKET, socks.connect(running.port));
|
||||||
|
}
|
||||||
|
EXPECT_TRUE(handshake_only(socks.connect(running.port)));
|
||||||
|
|
||||||
|
auto other = tls_client(running.port);
|
||||||
|
EXPECT_TRUE(tls_get_ok(other));
|
||||||
|
EXPECT_TRUE(tls_get_ok(served));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(KeepAliveParkingTest, FailedTlsHandshakeClosesTheConnection) {
|
||||||
|
using namespace parking_test;
|
||||||
|
SSLServer svr(SERVER_CERT_FILE, SERVER_PRIVATE_KEY_FILE);
|
||||||
|
ASSERT_TRUE(svr.is_valid());
|
||||||
|
serve_ok(svr, threads(1));
|
||||||
|
RunningServer running(svr);
|
||||||
|
Sockets socks;
|
||||||
|
|
||||||
|
auto plain = socks.connect(running.port);
|
||||||
|
ASSERT_TRUE(send_get(plain));
|
||||||
|
EXPECT_TRUE(sees_eof(plain, in_ms(1000)));
|
||||||
|
EXPECT_NE(0, svr.ssl_last_error());
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(KeepAliveParkingTest, StopClosesParkedTlsConnections) {
|
||||||
using namespace parking_test;
|
using namespace parking_test;
|
||||||
SSLServer svr(SERVER_CERT_FILE, SERVER_PRIVATE_KEY_FILE);
|
SSLServer svr(SERVER_CERT_FILE, SERVER_PRIVATE_KEY_FILE);
|
||||||
ASSERT_TRUE(svr.is_valid());
|
ASSERT_TRUE(svr.is_valid());
|
||||||
serve_ok(svr, threads(2));
|
serve_ok(svr, threads(2));
|
||||||
RunningServer running(svr);
|
RunningServer running(svr);
|
||||||
|
|
||||||
SSLClient cli("127.0.0.1", running.port);
|
std::vector<Client> clients;
|
||||||
cli.enable_server_certificate_verification(false);
|
for (int i = 0; i < 5; i++) {
|
||||||
cli.set_keep_alive(true);
|
clients.push_back(tls_client(running.port));
|
||||||
for (int i = 0; i < 2; i++) {
|
ASSERT_TRUE(tls_get_ok(clients.back()));
|
||||||
auto res = cli.Get("/");
|
|
||||||
ASSERT_TRUE(res) << "Error: " << to_string(res.error());
|
|
||||||
EXPECT_EQ("ok", res->body);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
auto start = std::chrono::steady_clock::now();
|
||||||
|
svr.stop();
|
||||||
|
running.thread.join();
|
||||||
|
EXPECT_LT(std::chrono::steady_clock::now() - start,
|
||||||
|
std::chrono::milliseconds(500));
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
Reference in new issue
Block a user