mirror of
https://github.com/yhirose/cpp-httplib.git
synced 2026-11-17 19:30:54 +00:00
Compare commits
16
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
36065c657c | ||
|
|
d7b0d4bedb | ||
|
|
4af42e1907 | ||
|
|
1b40ce850b | ||
|
|
f57672b390 | ||
|
|
654fd3546c | ||
|
|
546e821c65 | ||
|
|
53a7f4964e | ||
|
|
8c5fd6aa08 | ||
|
|
a2ebab183d | ||
|
|
a39e081386 | ||
|
|
07142256ed | ||
|
|
cc7a30f12f | ||
|
|
cdcd2ac6e6 | ||
|
|
bd23a7b179 | ||
|
|
6d8dec3c3e |
No files matched your search
+1
-1
@@ -568,7 +568,7 @@ Choose sizes that account for both your expected HTTP load and the maximum numbe
|
|||||||
|
|
||||||
A single `WebSocket` (server-side) or `WebSocketClient` handle is shared by three potential callers: the thread running your handler (or holding the client), the heartbeat thread, and, if your code does its own thing, a separate thread calling `send()`/`close()` while another thread is blocked in `read()`.
|
A single `WebSocket` (server-side) or `WebSocketClient` handle is shared by three potential callers: the thread running your handler (or holding the client), the heartbeat thread, and, if your code does its own thing, a separate thread calling `send()`/`close()` while another thread is blocked in `read()`.
|
||||||
|
|
||||||
**Supported**: calling `read()` from one thread while calling `send()`/`close()` from another. This is the common pattern for a client that reads incoming messages in a loop on one thread and sends from elsewhere (e.g. a UI thread). A message that is in flight when `close()` is called still arrives intact; `close()` sends the Close frame and returns, leaving the connection's read side to the thread that owns it, so it does not block waiting for the peer's Close reply in that case. The heartbeat thread's automatic pings use the same `send()` path internally, so they are safe to run concurrently with your `read()` loop too — for `wss://` this requires every TLS call on a connection to be serialized internally, which cpp-httplib does for you.
|
**Supported**: calling `read()` from one thread while calling `send()`/`close()` from another. This is the common pattern for a client that reads incoming messages in a loop on one thread and sends from elsewhere (e.g. a UI thread). A message that is in flight when `close()` is called still arrives intact; `close()` sends the Close frame and returns, leaving the connection's read side to the thread that owns it, so it does not block waiting for the peer's Close reply in that case. That thread's `read()` keeps waiting for the reply until its own read timeout (by default none on a client, 300 seconds on a server); to bound it, set one with `set_read_timeout()` before the read starts. The heartbeat thread's automatic pings use the same `send()` path internally, so they are safe to run concurrently with your `read()` loop too — for `wss://` this requires every TLS call on a connection to be serialized internally, which cpp-httplib does for you.
|
||||||
|
|
||||||
**Not supported**: calling `read()` from two threads at the same time on the same handle. The calls are serialized rather than left to corrupt each other, but which thread receives which message is unspecified, so there is nothing useful to build on it.
|
**Not supported**: calling `read()` from two threads at the same time on the same handle. The calls are serialized rather than left to corrupt each other, but which thread receives which message is unspecified, so there is nothing useful to build on it.
|
||||||
|
|
||||||
|
|||||||
@@ -1716,6 +1716,8 @@ cli.set_address_family(AF_UNIX);
|
|||||||
|
|
||||||
This library automatically sets the Host header to "localhost" for Unix socket connections, similar to curl's behavior.
|
This library automatically sets the Host header to "localhost" for Unix socket connections, similar to curl's behavior.
|
||||||
|
|
||||||
|
With `set_follow_location(true)`, a redirect is followed over the same socket, whatever host the `Location` names, as curl's `--unix-socket` does. A host mapped with `set_direct_hostname_addr_map` goes to its mapped socket instead. Only a `Location` naming `localhost` counts as the same host; any other host is treated as cross-host, so `Authorization` and `Cookie` are not sent to it.
|
||||||
|
|
||||||
|
|
||||||
URI Encoding/Decoding Utilities
|
URI Encoding/Decoding Utilities
|
||||||
-------------------------------
|
-------------------------------
|
||||||
|
|||||||
@@ -4,7 +4,7 @@ langs = ["en", "ja"]
|
|||||||
|
|
||||||
[site]
|
[site]
|
||||||
title = "cpp-httplib"
|
title = "cpp-httplib"
|
||||||
version = "0.65.0"
|
version = "0.66.0"
|
||||||
hostname = "https://yhirose.github.io"
|
hostname = "https://yhirose.github.io"
|
||||||
base_path = "/cpp-httplib"
|
base_path = "/cpp-httplib"
|
||||||
footer_message = "© 2026 Yuji Hirose. All rights reserved."
|
footer_message = "© 2026 Yuji Hirose. All rights reserved."
|
||||||
|
|||||||
@@ -56,4 +56,4 @@ When you call `stop()`, new connections are refused, but handlers that are alrea
|
|||||||
|
|
||||||
> **Warning:** There's a wait between calling `stop()` and `listen()` returning — it's the time in-flight requests take to finish. To enforce a timeout, you'll need to add your own shutdown timer in application code.
|
> **Warning:** There's a wait between calling `stop()` and `listen()` returning — it's the time in-flight requests take to finish. To enforce a timeout, you'll need to add your own shutdown timer in application code.
|
||||||
|
|
||||||
> **Note:** `stop()` doesn't interrupt WebSocket handlers. A handler looping on `read()` keeps running as long as its peer stays connected, and `listen()` doesn't return until it ends. Keep track of open WebSocket connections and `close()` them on shutdown, e.g. with `CloseStatus::GoingAway`.
|
> **Note:** `stop()` doesn't interrupt WebSocket handlers. A handler looping on `read()` keeps running as long as its peer stays connected, and `listen()` doesn't return until it ends. Keep track of open WebSocket connections and `close()` them on shutdown, e.g. with `CloseStatus::GoingAway`. The handler's `read()` then waits for the peer's Close reply up to its read timeout (300 seconds by default). To shorten that, call `set_read_timeout()` in the handler before the loop; `read()` then also returns `Timeout` whenever the peer stays idle that long, so the loop has to handle it.
|
||||||
@@ -56,4 +56,4 @@ int main() {
|
|||||||
|
|
||||||
> **Warning:** `stop()`を呼んでから`listen()`が戻るまでには、処理中のリクエストが終わるのを待つ時間がかかります。タイムアウトを強制したい場合は、シャットダウン用のタイマーを別途用意するなど、アプリケーション側の工夫が必要です。
|
> **Warning:** `stop()`を呼んでから`listen()`が戻るまでには、処理中のリクエストが終わるのを待つ時間がかかります。タイムアウトを強制したい場合は、シャットダウン用のタイマーを別途用意するなど、アプリケーション側の工夫が必要です。
|
||||||
|
|
||||||
> **Note:** `stop()`はWebSocketハンドラを中断しません。`read()`をループで回しているハンドラは相手がつながっている限り動き続け、それが終わるまで`listen()`も戻りません。開いているWebSocket接続を記録しておき、シャットダウン時に`close()`(`CloseStatus::GoingAway`など)で閉じてください。
|
> **Note:** `stop()`はWebSocketハンドラを中断しません。`read()`をループで回しているハンドラは相手がつながっている限り動き続け、それが終わるまで`listen()`も戻りません。開いているWebSocket接続を記録しておき、シャットダウン時に`close()`(`CloseStatus::GoingAway`など)で閉じてください。そのあとハンドラの`read()`は、相手のClose応答を読み込みタイムアウト(既定は300秒)まで待ちます。短くしたい場合は、ループの前に`set_read_timeout()`を呼んでください。その場合、相手が黙っている間は`read()`が`Timeout`を返すので、ループ側で扱う必要があります。
|
||||||
@@ -8,8 +8,8 @@
|
|||||||
#ifndef CPPHTTPLIB_HTTPLIB_H
|
#ifndef CPPHTTPLIB_HTTPLIB_H
|
||||||
#define CPPHTTPLIB_HTTPLIB_H
|
#define CPPHTTPLIB_HTTPLIB_H
|
||||||
|
|
||||||
#define CPPHTTPLIB_VERSION "0.65.0"
|
#define CPPHTTPLIB_VERSION "0.66.0"
|
||||||
#define CPPHTTPLIB_VERSION_NUM "0x004100"
|
#define CPPHTTPLIB_VERSION_NUM "0x004200"
|
||||||
|
|
||||||
#ifdef _WIN32
|
#ifdef _WIN32
|
||||||
#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0A00
|
#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0A00
|
||||||
@@ -1344,7 +1344,7 @@ public:
|
|||||||
size_type erase(const std::string &key) {
|
size_type erase(const std::string &key) {
|
||||||
auto before = entries_.size();
|
auto before = entries_.size();
|
||||||
entries_.erase(std::remove_if(entries_.begin(), entries_.end(),
|
entries_.erase(std::remove_if(entries_.begin(), entries_.end(),
|
||||||
[&](const value_type &entry) {
|
[key](const value_type &entry) {
|
||||||
return keys_equal(entry.first, key);
|
return keys_equal(entry.first, key);
|
||||||
}),
|
}),
|
||||||
entries_.end());
|
entries_.end());
|
||||||
@@ -3031,8 +3031,8 @@ protected:
|
|||||||
void disconnect(bool gracefully);
|
void disconnect(bool gracefully);
|
||||||
|
|
||||||
// Under socket_mutex_: whether the connection kept alive can take another
|
// Under socket_mutex_: whether the connection kept alive can take another
|
||||||
// request. One the peer has closed, or one set up under TLS settings changed
|
// request. One with anything to read, or one set up under TLS settings
|
||||||
// since, is closed instead.
|
// changed since, is closed instead.
|
||||||
bool socket_reusable();
|
bool socket_reusable();
|
||||||
|
|
||||||
// TLS settings apply as a connection is set up, so a change makes the
|
// TLS settings apply as a connection is set up, so a change makes the
|
||||||
@@ -4542,8 +4542,6 @@ public:
|
|||||||
void stop();
|
void stop();
|
||||||
|
|
||||||
private:
|
private:
|
||||||
bool parse_sse_line(const std::string &line, SSEMessage &msg, int &retry_ms,
|
|
||||||
bool &has_data, bool &has_id);
|
|
||||||
void run_event_loop();
|
void run_event_loop();
|
||||||
void dispatch_event(const SSEMessage &msg);
|
void dispatch_event(const SSEMessage &msg);
|
||||||
bool should_reconnect(int count) const;
|
bool should_reconnect(int count) const;
|
||||||
@@ -4578,6 +4576,40 @@ private:
|
|||||||
|
|
||||||
} // namespace sse
|
} // namespace sse
|
||||||
|
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
// Interprets an event stream fed in chunks of any size
|
||||||
|
class SSEParser {
|
||||||
|
public:
|
||||||
|
using EventHandler = std::function<void(const sse::SSEMessage &msg)>;
|
||||||
|
using IdHandler = std::function<void(const std::string &id)>;
|
||||||
|
using RetryHandler = std::function<void(int retry_ms)>;
|
||||||
|
|
||||||
|
SSEParser(EventHandler on_event, IdHandler on_id, RetryHandler on_retry,
|
||||||
|
size_t max_event_length = CPPHTTPLIB_SSE_MAX_EVENT_LENGTH);
|
||||||
|
|
||||||
|
// Returns false once the line and the event still waiting for their end
|
||||||
|
// exceed max_event_length. 0 means no limit.
|
||||||
|
bool parse(const char *buf, size_t n);
|
||||||
|
|
||||||
|
private:
|
||||||
|
void parse_line(const std::string &line);
|
||||||
|
|
||||||
|
EventHandler on_event_;
|
||||||
|
IdHandler on_id_;
|
||||||
|
RetryHandler on_retry_;
|
||||||
|
size_t max_event_length_;
|
||||||
|
|
||||||
|
std::string buffer_;
|
||||||
|
sse::SSEMessage msg_;
|
||||||
|
bool has_data_ = false;
|
||||||
|
bool has_id_ = false;
|
||||||
|
bool first_line_ = true;
|
||||||
|
bool after_cr_ = false;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
|
||||||
namespace ws {
|
namespace ws {
|
||||||
|
|
||||||
class WebSocketClient;
|
class WebSocketClient;
|
||||||
@@ -5023,6 +5055,110 @@ inline std::string Result::read_all() {
|
|||||||
|
|
||||||
} // namespace stream
|
} // namespace stream
|
||||||
|
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
inline SSEParser::SSEParser(EventHandler on_event, IdHandler on_id,
|
||||||
|
RetryHandler on_retry, size_t max_event_length)
|
||||||
|
: on_event_(std::move(on_event)), on_id_(std::move(on_id)),
|
||||||
|
on_retry_(std::move(on_retry)), max_event_length_(max_event_length) {}
|
||||||
|
|
||||||
|
inline bool SSEParser::parse(const char *buf, size_t n) {
|
||||||
|
// What is left in the buffer has no line ending
|
||||||
|
auto search_pos = buffer_.size();
|
||||||
|
buffer_.append(buf, n);
|
||||||
|
|
||||||
|
// A line ends with \r\n, \n or \r per the SSE spec
|
||||||
|
size_t line_start = 0;
|
||||||
|
size_t eol_pos;
|
||||||
|
|
||||||
|
while ((eol_pos = buffer_.find_first_of("\r\n", search_pos)) !=
|
||||||
|
std::string::npos) {
|
||||||
|
auto line = buffer_.substr(line_start, eol_pos - line_start);
|
||||||
|
line_start = eol_pos + 1;
|
||||||
|
search_pos = line_start;
|
||||||
|
|
||||||
|
// The \n of a \r\n may arrive in a later chunk than its \r
|
||||||
|
auto is_lf_of_crlf = after_cr_ && line.empty() && buffer_[eol_pos] == '\n';
|
||||||
|
after_cr_ = buffer_[eol_pos] == '\r';
|
||||||
|
if (is_lf_of_crlf) { continue; }
|
||||||
|
|
||||||
|
// A UTF-8 BOM at the start of the stream is ignored per the SSE spec
|
||||||
|
if (first_line_) {
|
||||||
|
first_line_ = false;
|
||||||
|
if (line.compare(0, 3, "\xEF\xBB\xBF") == 0) { line.erase(0, 3); }
|
||||||
|
}
|
||||||
|
|
||||||
|
parse_line(line);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Keep unprocessed data in buffer
|
||||||
|
buffer_.erase(0, line_start);
|
||||||
|
|
||||||
|
return max_event_length_ == 0 ||
|
||||||
|
buffer_.size() + msg_.data.size() <= max_event_length_;
|
||||||
|
}
|
||||||
|
|
||||||
|
inline void SSEParser::parse_line(const std::string &line) {
|
||||||
|
// Blank line signals end of event
|
||||||
|
if (line.empty()) {
|
||||||
|
// The id counts for Last-Event-ID even for an event that has no data. An
|
||||||
|
// empty id clears it.
|
||||||
|
if (has_id_ && on_id_) { on_id_(msg_.id); }
|
||||||
|
|
||||||
|
// An event without a data field is not dispatched
|
||||||
|
if (has_data_ && on_event_) { on_event_(msg_); }
|
||||||
|
|
||||||
|
msg_.clear();
|
||||||
|
has_data_ = false;
|
||||||
|
has_id_ = false;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Lines starting with ':' are comments (ignored)
|
||||||
|
if (line[0] == ':') { return; }
|
||||||
|
|
||||||
|
// Find the colon separator
|
||||||
|
auto colon_pos = line.find(':');
|
||||||
|
auto field = line.substr(0, colon_pos);
|
||||||
|
std::string value;
|
||||||
|
|
||||||
|
// Value starts after colon, skip optional single space
|
||||||
|
if (colon_pos != std::string::npos && colon_pos + 1 < line.size()) {
|
||||||
|
auto value_start = colon_pos + 1;
|
||||||
|
if (line[value_start] == ' ') { value_start++; }
|
||||||
|
value = line.substr(value_start);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Handle known fields
|
||||||
|
if (field == "event") {
|
||||||
|
// An empty event type is dispatched as "message" per the SSE spec
|
||||||
|
msg_.event = value.empty() ? std::string("message") : std::move(value);
|
||||||
|
} else if (field == "data") {
|
||||||
|
// Multiple data lines are concatenated with newlines
|
||||||
|
if (has_data_) { msg_.data += "\n"; }
|
||||||
|
msg_.data += value;
|
||||||
|
has_data_ = true;
|
||||||
|
} else if (field == "id") {
|
||||||
|
// An id that cannot be sent back as Last-Event-ID is ignored. Empty id is
|
||||||
|
// valid (clears the last event ID)
|
||||||
|
if (fields::is_field_value(value)) {
|
||||||
|
msg_.id = value;
|
||||||
|
has_id_ = true;
|
||||||
|
}
|
||||||
|
} else if (field == "retry") {
|
||||||
|
// Parse retry interval in milliseconds
|
||||||
|
// Per the SSE spec, a value that is not all ASCII digits is ignored.
|
||||||
|
if (is_numeric(value)) {
|
||||||
|
int v = 0;
|
||||||
|
auto res = from_chars(value.data(), value.data() + value.size(), v);
|
||||||
|
if (res.ec == std::errc{} && on_retry_) { on_retry_(v); }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// Unknown fields are ignored per SSE spec
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
|
||||||
namespace sse {
|
namespace sse {
|
||||||
|
|
||||||
// SSEMessage implementations
|
// SSEMessage implementations
|
||||||
@@ -5104,58 +5240,6 @@ inline void SSEClient::stop() {
|
|||||||
if (async_thread_.joinable()) { async_thread_.join(); }
|
if (async_thread_.joinable()) { async_thread_.join(); }
|
||||||
}
|
}
|
||||||
|
|
||||||
inline bool SSEClient::parse_sse_line(const std::string &line, SSEMessage &msg,
|
|
||||||
int &retry_ms, bool &has_data,
|
|
||||||
bool &has_id) {
|
|
||||||
// Blank line signals end of event
|
|
||||||
if (line.empty()) { return true; }
|
|
||||||
|
|
||||||
// Lines starting with ':' are comments (ignored)
|
|
||||||
if (line[0] == ':') { return false; }
|
|
||||||
|
|
||||||
// Find the colon separator
|
|
||||||
auto colon_pos = line.find(':');
|
|
||||||
auto field = line.substr(0, colon_pos);
|
|
||||||
std::string value;
|
|
||||||
|
|
||||||
// Value starts after colon, skip optional single space
|
|
||||||
if (colon_pos != std::string::npos && colon_pos + 1 < line.size()) {
|
|
||||||
auto value_start = colon_pos + 1;
|
|
||||||
if (line[value_start] == ' ') { value_start++; }
|
|
||||||
value = line.substr(value_start);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Handle known fields
|
|
||||||
if (field == "event") {
|
|
||||||
// An empty event type is dispatched as "message" per the SSE spec
|
|
||||||
msg.event = value.empty() ? std::string("message") : std::move(value);
|
|
||||||
} else if (field == "data") {
|
|
||||||
// Multiple data lines are concatenated with newlines
|
|
||||||
if (has_data) { msg.data += "\n"; }
|
|
||||||
msg.data += value;
|
|
||||||
has_data = true;
|
|
||||||
} else if (field == "id") {
|
|
||||||
// An id that cannot be sent back as Last-Event-ID is ignored. Empty id is
|
|
||||||
// valid (clears the last event ID)
|
|
||||||
if (detail::fields::is_field_value(value)) {
|
|
||||||
msg.id = value;
|
|
||||||
has_id = true;
|
|
||||||
}
|
|
||||||
} else if (field == "retry") {
|
|
||||||
// Parse retry interval in milliseconds
|
|
||||||
// Per the SSE spec, a value that is not all ASCII digits is ignored.
|
|
||||||
if (detail::is_numeric(value)) {
|
|
||||||
int v = 0;
|
|
||||||
auto res =
|
|
||||||
detail::from_chars(value.data(), value.data() + value.size(), v);
|
|
||||||
if (res.ec == std::errc{}) { retry_ms = v; }
|
|
||||||
}
|
|
||||||
}
|
|
||||||
// Unknown fields are ignored per SSE spec
|
|
||||||
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
inline void SSEClient::run_event_loop() {
|
inline void SSEClient::run_event_loop() {
|
||||||
auto reconnect_count = 0;
|
auto reconnect_count = 0;
|
||||||
|
|
||||||
@@ -5216,72 +5300,17 @@ inline void SSEClient::run_event_loop() {
|
|||||||
if (on_open_) { on_open_(); }
|
if (on_open_) { on_open_(); }
|
||||||
|
|
||||||
// Event receiving loop
|
// Event receiving loop
|
||||||
std::string buffer;
|
detail::SSEParser parser(
|
||||||
SSEMessage current_msg;
|
[this](const SSEMessage &msg) { dispatch_event(msg); },
|
||||||
auto has_data = false;
|
[this](const std::string &id) {
|
||||||
auto has_id = false;
|
std::lock_guard<std::mutex> lock(last_event_id_mutex_);
|
||||||
auto first_line = true;
|
last_event_id_ = id;
|
||||||
auto after_cr = false;
|
},
|
||||||
|
[this](int retry_ms) { reconnect_interval_ms_ = retry_ms; });
|
||||||
auto event_too_long = false;
|
auto event_too_long = false;
|
||||||
|
|
||||||
while (running_.load() && result.next()) {
|
while (running_.load() && result.next()) {
|
||||||
// What is left in the buffer has no line ending
|
if (!parser.parse(result.data(), result.size())) {
|
||||||
auto search_pos = buffer.size();
|
|
||||||
buffer.append(result.data(), result.size());
|
|
||||||
|
|
||||||
// Process complete lines in the buffer. A line ends with \r\n, \n or \r
|
|
||||||
// per the SSE spec
|
|
||||||
size_t line_start = 0;
|
|
||||||
size_t eol_pos;
|
|
||||||
|
|
||||||
while ((eol_pos = buffer.find_first_of("\r\n", search_pos)) !=
|
|
||||||
std::string::npos) {
|
|
||||||
auto line = buffer.substr(line_start, eol_pos - line_start);
|
|
||||||
line_start = eol_pos + 1;
|
|
||||||
search_pos = line_start;
|
|
||||||
|
|
||||||
// The \n of a \r\n may arrive in a later chunk than its \r
|
|
||||||
auto is_lf_of_crlf =
|
|
||||||
after_cr && line.empty() && buffer[eol_pos] == '\n';
|
|
||||||
after_cr = buffer[eol_pos] == '\r';
|
|
||||||
if (is_lf_of_crlf) { continue; }
|
|
||||||
|
|
||||||
// A UTF-8 BOM at the start of the stream is ignored per the SSE spec
|
|
||||||
if (first_line) {
|
|
||||||
first_line = false;
|
|
||||||
if (line.compare(0, 3, "\xEF\xBB\xBF") == 0) { line.erase(0, 3); }
|
|
||||||
}
|
|
||||||
|
|
||||||
// Parse the line and check if event is complete
|
|
||||||
auto event_complete = parse_sse_line(
|
|
||||||
line, current_msg, reconnect_interval_ms_, has_data, has_id);
|
|
||||||
|
|
||||||
if (event_complete) {
|
|
||||||
// Update last_event_id for reconnection, even for an event that
|
|
||||||
// has no data. An empty id clears it.
|
|
||||||
if (has_id) {
|
|
||||||
std::lock_guard<std::mutex> lock(last_event_id_mutex_);
|
|
||||||
last_event_id_ = current_msg.id;
|
|
||||||
}
|
|
||||||
|
|
||||||
// An event without a data field is not dispatched
|
|
||||||
if (has_data) { dispatch_event(current_msg); }
|
|
||||||
|
|
||||||
// Reset the message for the next event either way
|
|
||||||
current_msg.clear();
|
|
||||||
has_data = false;
|
|
||||||
has_id = false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Keep unprocessed data in buffer
|
|
||||||
buffer.erase(0, line_start);
|
|
||||||
|
|
||||||
// Neither an event nor a line still waiting for its end may grow
|
|
||||||
// without bound. 0 means no limit.
|
|
||||||
if (CPPHTTPLIB_SSE_MAX_EVENT_LENGTH > 0 &&
|
|
||||||
buffer.size() + current_msg.data.size() >
|
|
||||||
CPPHTTPLIB_SSE_MAX_EVENT_LENGTH) {
|
|
||||||
if (on_error_) { on_error_(Error::ExceedMaxPayloadSize); }
|
if (on_error_) { on_error_(Error::ExceedMaxPayloadSize); }
|
||||||
event_too_long = true;
|
event_too_long = true;
|
||||||
break;
|
break;
|
||||||
@@ -6082,9 +6111,35 @@ inline bool is_valid_path(const std::string &path) {
|
|||||||
|
|
||||||
inline bool canonicalize_path(const char *path, std::string &resolved) {
|
inline bool canonicalize_path(const char *path, std::string &resolved) {
|
||||||
#if defined(_WIN32)
|
#if defined(_WIN32)
|
||||||
char buf[_MAX_PATH];
|
// Resolve junctions and symlinks, as realpath() does
|
||||||
if (_fullpath(buf, path, _MAX_PATH) == nullptr) { return false; }
|
auto wpath = u8string_to_wstring(path);
|
||||||
resolved = buf;
|
if (wpath.empty()) { return false; }
|
||||||
|
|
||||||
|
CREATEFILE2_EXTENDED_PARAMETERS params{};
|
||||||
|
params.dwSize = sizeof(params);
|
||||||
|
params.dwFileFlags = FILE_FLAG_BACKUP_SEMANTICS; // Needed to open a directory
|
||||||
|
auto h = ::CreateFile2(wpath.c_str(), 0,
|
||||||
|
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
|
||||||
|
OPEN_EXISTING, ¶ms);
|
||||||
|
if (h == INVALID_HANDLE_VALUE) { return false; }
|
||||||
|
auto guard = scope_exit([&]() { ::CloseHandle(h); });
|
||||||
|
|
||||||
|
std::wstring wbuf(MAX_PATH, L'\0');
|
||||||
|
auto len = ::GetFinalPathNameByHandleW(
|
||||||
|
h, &wbuf[0], static_cast<DWORD>(wbuf.size()), FILE_NAME_NORMALIZED);
|
||||||
|
if (len >= wbuf.size()) {
|
||||||
|
wbuf.resize(len);
|
||||||
|
len = ::GetFinalPathNameByHandleW(
|
||||||
|
h, &wbuf[0], static_cast<DWORD>(wbuf.size()), FILE_NAME_NORMALIZED);
|
||||||
|
}
|
||||||
|
if (len == 0 || len >= wbuf.size()) { return false; }
|
||||||
|
|
||||||
|
auto n = ::WideCharToMultiByte(CP_UTF8, 0, wbuf.data(), static_cast<int>(len),
|
||||||
|
nullptr, 0, nullptr, nullptr);
|
||||||
|
if (n <= 0) { return false; }
|
||||||
|
resolved.assign(static_cast<size_t>(n), '\0');
|
||||||
|
::WideCharToMultiByte(CP_UTF8, 0, wbuf.data(), static_cast<int>(len),
|
||||||
|
&resolved[0], n, nullptr, nullptr);
|
||||||
#elif defined(PATH_MAX)
|
#elif defined(PATH_MAX)
|
||||||
char buf[PATH_MAX];
|
char buf[PATH_MAX];
|
||||||
if (realpath(path, buf) == nullptr) { return false; }
|
if (realpath(path, buf) == nullptr) { return false; }
|
||||||
@@ -10881,6 +10936,7 @@ public:
|
|||||||
socket_t socket() const override;
|
socket_t socket() const override;
|
||||||
time_t duration() const override;
|
time_t duration() const override;
|
||||||
void set_read_timeout(time_t sec, time_t usec = 0) override;
|
void set_read_timeout(time_t sec, time_t usec = 0) override;
|
||||||
|
void set_max_timeout(time_t msec) override;
|
||||||
void set_read_interrupt(std::function<bool()> interrupted) override;
|
void set_read_interrupt(std::function<bool()> interrupted) override;
|
||||||
|
|
||||||
private:
|
private:
|
||||||
@@ -10888,14 +10944,13 @@ private:
|
|||||||
|
|
||||||
socket_t sock_;
|
socket_t sock_;
|
||||||
tls::session_t session_;
|
tls::session_t session_;
|
||||||
// WebSocket::close() shortens the read timeout from the closing thread
|
// May change while another thread is in wait_readable(); write timeouts don't
|
||||||
// while the receive thread is inside wait_readable(), so these two are read
|
|
||||||
// and written concurrently. The write timeouts are never mutated.
|
|
||||||
std::atomic<time_t> read_timeout_sec_;
|
std::atomic<time_t> read_timeout_sec_;
|
||||||
std::atomic<time_t> read_timeout_usec_;
|
std::atomic<time_t> read_timeout_usec_;
|
||||||
time_t write_timeout_sec_;
|
time_t write_timeout_sec_;
|
||||||
time_t write_timeout_usec_;
|
time_t write_timeout_usec_;
|
||||||
const std::chrono::time_point<std::chrono::steady_clock> start_time_;
|
std::atomic<time_t> max_timeout_msec_{0};
|
||||||
|
std::atomic<std::chrono::steady_clock::rep> start_time_;
|
||||||
std::function<bool()> read_interrupted_;
|
std::function<bool()> read_interrupted_;
|
||||||
};
|
};
|
||||||
|
|
||||||
@@ -12638,7 +12693,16 @@ inline bool ThreadPool::enqueue(std::function<void()> fn) {
|
|||||||
if (jobs_.size() > idle_thread_count_ &&
|
if (jobs_.size() > idle_thread_count_ &&
|
||||||
threads_.size() + dynamic_threads_.size() < max_thread_count_) {
|
threads_.size() + dynamic_threads_.size() < max_thread_count_) {
|
||||||
cleanup_finished_threads();
|
cleanup_finished_threads();
|
||||||
|
#ifndef CPPHTTPLIB_NO_EXCEPTIONS
|
||||||
|
try {
|
||||||
|
#endif
|
||||||
dynamic_threads_.emplace_back(std::thread([this]() { worker(true); }));
|
dynamic_threads_.emplace_back(std::thread([this]() { worker(true); }));
|
||||||
|
#ifndef CPPHTTPLIB_NO_EXCEPTIONS
|
||||||
|
} catch (const std::system_error &) {
|
||||||
|
// No thread budget left: keep the job queued for an existing worker
|
||||||
|
// instead of letting the exception escape the accept loop.
|
||||||
|
}
|
||||||
|
#endif
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -13093,14 +13157,22 @@ make_host_and_port_string_always_port(const std::string &host, int port) {
|
|||||||
return prepare_host_string(host) + ":" + std::to_string(port);
|
return prepare_host_string(host) + ":" + std::to_string(port);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Where a client connects for `host`, as one string: the mapped address or
|
||||||
|
// name, or `host` itself.
|
||||||
|
inline std::string
|
||||||
|
addr_map_target(const std::map<std::string, std::string> &addr_map,
|
||||||
|
const std::string &host) {
|
||||||
|
std::string connect_host;
|
||||||
|
std::string ip;
|
||||||
|
apply_addr_map(addr_map, host, connect_host, ip);
|
||||||
|
return ip.empty() ? connect_host : ip;
|
||||||
|
}
|
||||||
|
|
||||||
// Request target of a CONNECT for `host`, with `addr_map` applied.
|
// Request target of a CONNECT for `host`, with `addr_map` applied.
|
||||||
inline std::string
|
inline std::string
|
||||||
make_connect_request_target(const std::map<std::string, std::string> &addr_map,
|
make_connect_request_target(const std::map<std::string, std::string> &addr_map,
|
||||||
const std::string &host, int port) {
|
const std::string &host, int port) {
|
||||||
std::string connect_host;
|
return make_host_and_port_string_always_port(addr_map_target(addr_map, host),
|
||||||
std::string ip;
|
|
||||||
apply_addr_map(addr_map, host, connect_host, ip);
|
|
||||||
return make_host_and_port_string_always_port(ip.empty() ? connect_host : ip,
|
|
||||||
port);
|
port);
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -13508,7 +13580,7 @@ inline WebSocketSSLStream::WebSocketSSLStream(socket_t sock,
|
|||||||
read_timeout_usec_(read_timeout_usec),
|
read_timeout_usec_(read_timeout_usec),
|
||||||
write_timeout_sec_(write_timeout_sec),
|
write_timeout_sec_(write_timeout_sec),
|
||||||
write_timeout_usec_(write_timeout_usec),
|
write_timeout_usec_(write_timeout_usec),
|
||||||
start_time_(std::chrono::steady_clock::now()) {
|
start_time_(std::chrono::steady_clock::now().time_since_epoch().count()) {
|
||||||
// The receive and send paths run on different threads, so each TLS call is
|
// The receive and send paths run on different threads, so each TLS call is
|
||||||
// driven in non-blocking mode and readiness is awaited with select()
|
// driven in non-blocking mode and readiness is awaited with select()
|
||||||
// outside the session lock. Set the socket non-blocking once here; it is
|
// outside the session lock. Set the socket non-blocking once here; it is
|
||||||
@@ -13527,7 +13599,18 @@ inline bool WebSocketSSLStream::is_readable() const {
|
|||||||
}
|
}
|
||||||
|
|
||||||
inline bool WebSocketSSLStream::wait_readable() const {
|
inline bool WebSocketSSLStream::wait_readable() const {
|
||||||
return select_read_interruptible(sock_, read_timeout_sec_, read_timeout_usec_,
|
auto max_timeout_msec = max_timeout_msec_.load();
|
||||||
|
if (max_timeout_msec <= 0) {
|
||||||
|
return select_read_interruptible(sock_, read_timeout_sec_,
|
||||||
|
read_timeout_usec_, read_interrupted_) > 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
time_t read_timeout_sec;
|
||||||
|
time_t read_timeout_usec;
|
||||||
|
calc_actual_timeout(max_timeout_msec, duration(), read_timeout_sec_,
|
||||||
|
read_timeout_usec_, read_timeout_sec, read_timeout_usec);
|
||||||
|
|
||||||
|
return select_read_interruptible(sock_, read_timeout_sec, read_timeout_usec,
|
||||||
read_interrupted_) > 0;
|
read_interrupted_) > 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -13617,12 +13700,20 @@ inline void WebSocketSSLStream::get_local_ip_and_port(std::string &ip,
|
|||||||
inline socket_t WebSocketSSLStream::socket() const { return sock_; }
|
inline socket_t WebSocketSSLStream::socket() const { return sock_; }
|
||||||
|
|
||||||
inline time_t WebSocketSSLStream::duration() const {
|
inline time_t WebSocketSSLStream::duration() const {
|
||||||
|
auto start = std::chrono::steady_clock::time_point(
|
||||||
|
std::chrono::steady_clock::duration(start_time_.load()));
|
||||||
return static_cast<time_t>(
|
return static_cast<time_t>(
|
||||||
std::chrono::duration_cast<std::chrono::milliseconds>(
|
std::chrono::duration_cast<std::chrono::milliseconds>(
|
||||||
std::chrono::steady_clock::now() - start_time_)
|
std::chrono::steady_clock::now() - start)
|
||||||
.count());
|
.count());
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Start time first: a reader that sees the new bound also sees its start
|
||||||
|
inline void WebSocketSSLStream::set_max_timeout(time_t msec) {
|
||||||
|
start_time_ = std::chrono::steady_clock::now().time_since_epoch().count();
|
||||||
|
max_timeout_msec_ = msec;
|
||||||
|
}
|
||||||
|
|
||||||
inline void WebSocketSSLStream::set_read_timeout(time_t sec, time_t usec) {
|
inline void WebSocketSSLStream::set_read_timeout(time_t sec, time_t usec) {
|
||||||
read_timeout_sec_ = sec;
|
read_timeout_sec_ = sec;
|
||||||
read_timeout_usec_ = usec;
|
read_timeout_usec_ = usec;
|
||||||
@@ -15729,14 +15820,8 @@ inline void ClientImpl::disconnect(bool gracefully) {
|
|||||||
inline bool ClientImpl::socket_reusable() {
|
inline bool ClientImpl::socket_reusable() {
|
||||||
if (!socket_.is_open()) { return false; }
|
if (!socket_.is_open()) { return false; }
|
||||||
|
|
||||||
auto is_alive = detail::is_socket_alive(socket_.sock);
|
// RFC 9112 9.2: data with no request outstanding is not a response
|
||||||
#ifdef CPPHTTPLIB_SSL_ENABLED
|
if (detail::select_read(socket_.sock, 0, 0) != 0) {
|
||||||
if (is_alive && is_ssl() && tls::is_peer_closed(socket_.ssl, socket_.sock)) {
|
|
||||||
is_alive = false;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
if (!is_alive) {
|
|
||||||
// Peer seems gone — non-graceful shutdown to avoid SIGPIPE.
|
|
||||||
disconnect(/*gracefully=*/false);
|
disconnect(/*gracefully=*/false);
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
@@ -15990,6 +16075,8 @@ inline ClientImpl::StreamHandle ClientImpl::open_stream_(Request &req) {
|
|||||||
handle.connection_ = detail::make_unique<ClientConnection>();
|
handle.connection_ = detail::make_unique<ClientConnection>();
|
||||||
|
|
||||||
{
|
{
|
||||||
|
// A request in flight uses socket_ without holding socket_mutex_
|
||||||
|
std::lock_guard<std::recursive_mutex> request_mutex_guard(request_mutex_);
|
||||||
std::lock_guard<std::mutex> guard(socket_mutex_);
|
std::lock_guard<std::mutex> guard(socket_mutex_);
|
||||||
|
|
||||||
if (!socket_reusable()) {
|
if (!socket_reusable()) {
|
||||||
@@ -16385,9 +16472,10 @@ inline bool ClientImpl::handle_request(Stream &strm, Request &req,
|
|||||||
// to do these things to the socket if another thread is using the socket.
|
// to do these things to the socket if another thread is using the socket.
|
||||||
std::lock_guard<std::mutex> guard(socket_mutex_);
|
std::lock_guard<std::mutex> guard(socket_mutex_);
|
||||||
// Also when the request asked for it (e.g. a body that was never sent,
|
// Also when the request asked for it (e.g. a body that was never sent,
|
||||||
// or "Connection: close"), so that a redirect or an auth retry below does
|
// or "Connection: close") or bytes follow the response (RFC 9112 9.2), so
|
||||||
// not reuse the socket.
|
// that a redirect or an auth retry below does not reuse the socket.
|
||||||
if (socket_should_be_closed_when_request_is_done_ || close_connection ||
|
if (socket_should_be_closed_when_request_is_done_ || close_connection ||
|
||||||
|
strm.is_readable() ||
|
||||||
detail::has_header_token(res.headers, "Connection", "close") ||
|
detail::has_header_token(res.headers, "Connection", "close") ||
|
||||||
(res.version == "HTTP/1.0" && res.reason != "Connection established")) {
|
(res.version == "HTTP/1.0" && res.reason != "Connection established")) {
|
||||||
disconnect(/*gracefully=*/true);
|
disconnect(/*gracefully=*/true);
|
||||||
@@ -16488,8 +16576,13 @@ inline bool ClientImpl::redirect(Request &req, Response &res, Error &error) {
|
|||||||
|
|
||||||
auto path = std::move(next_path) + next_query;
|
auto path = std::move(next_path) + next_query;
|
||||||
|
|
||||||
|
// A Unix socket client sends "Host: localhost", so a Location naming
|
||||||
|
// localhost names this client too.
|
||||||
|
auto is_same_host = next_host == host_ ||
|
||||||
|
(address_family_ == AF_UNIX && next_host == "localhost");
|
||||||
|
|
||||||
// Same host redirect - use current client
|
// Same host redirect - use current client
|
||||||
if (next_scheme == scheme && next_host == host_ && next_port == port_) {
|
if (next_scheme == scheme && is_same_host && next_port == port_) {
|
||||||
return detail::redirect(*this, req, res, path, location, error);
|
return detail::redirect(*this, req, res, path, location, error);
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -16640,6 +16733,14 @@ inline void ClientImpl::setup_redirect_client(ClientType &client) {
|
|||||||
// Copy network and socket settings
|
// Copy network and socket settings
|
||||||
client.addr_map_ = addr_map_;
|
client.addr_map_ = addr_map_;
|
||||||
client.tunnel_addr_map_ = tunnel_addr_map_;
|
client.tunnel_addr_map_ = tunnel_addr_map_;
|
||||||
|
|
||||||
|
// A Unix socket client reaches every host through its own socket, as curl's
|
||||||
|
// --unix-socket does, unless the caller mapped that host elsewhere. The
|
||||||
|
// Location's host is never taken as a socket path.
|
||||||
|
if (address_family_ == AF_UNIX) {
|
||||||
|
auto &target = client.addr_map_[client.host()];
|
||||||
|
if (target.empty()) { target = detail::addr_map_target(addr_map_, host_); }
|
||||||
|
}
|
||||||
client.set_address_family(address_family_);
|
client.set_address_family(address_family_);
|
||||||
client.set_tcp_nodelay(tcp_nodelay_);
|
client.set_tcp_nodelay(tcp_nodelay_);
|
||||||
client.set_ipv6_v6only(ipv6_v6only_);
|
client.set_ipv6_v6only(ipv6_v6only_);
|
||||||
@@ -19078,8 +19179,12 @@ inline bool SSLServer::process_and_close_socket(socket_t sock) {
|
|||||||
auto cleanup = detail::scope_exit([&] {
|
auto cleanup = detail::scope_exit([&] {
|
||||||
if (handshake_done) { shutdown(session, !websocket_upgraded && ret); }
|
if (handshake_done) { shutdown(session, !websocket_upgraded && ret); }
|
||||||
free_session(session);
|
free_session(session);
|
||||||
|
if (handshake_done) {
|
||||||
|
detail::drain_and_close_socket(sock);
|
||||||
|
} else {
|
||||||
detail::shutdown_socket(sock);
|
detail::shutdown_socket(sock);
|
||||||
detail::close_socket(sock);
|
detail::close_socket(sock);
|
||||||
|
}
|
||||||
});
|
});
|
||||||
|
|
||||||
// Perform TLS accept handshake with timeout
|
// Perform TLS accept handshake with timeout
|
||||||
@@ -19240,6 +19345,8 @@ inline bool SSLClient::setup_proxy_connection(
|
|||||||
}
|
}
|
||||||
|
|
||||||
if (!initialize_ssl(socket, error)) {
|
if (!initialize_ssl(socket, error)) {
|
||||||
|
shutdown_socket(socket);
|
||||||
|
close_socket(socket);
|
||||||
success = false;
|
success = false;
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
@@ -23782,13 +23889,18 @@ inline void WebSocket::close(CloseStatus status, const std::string &reason) {
|
|||||||
std::unique_lock<std::mutex> read_lock(read_mutex_, std::try_to_lock);
|
std::unique_lock<std::mutex> read_lock(read_mutex_, std::try_to_lock);
|
||||||
if (!read_lock.owns_lock()) { return; }
|
if (!read_lock.owns_lock()) { return; }
|
||||||
|
|
||||||
// Use a short timeout to avoid hanging if the peer doesn't respond.
|
// A max timeout turns a negative (unbounded) read timeout into 0
|
||||||
strm_.set_read_timeout(CPPHTTPLIB_WEBSOCKET_CLOSE_TIMEOUT_SECOND, 0);
|
strm_.set_read_timeout(CPPHTTPLIB_WEBSOCKET_CLOSE_TIMEOUT_SECOND, 0);
|
||||||
|
strm_.set_max_timeout(CPPHTTPLIB_WEBSOCKET_CLOSE_TIMEOUT_SECOND * 1000);
|
||||||
|
// The max timeout cuts a trickled frame short, the deadline a frame flood
|
||||||
|
auto deadline =
|
||||||
|
detail::deadline_after(CPPHTTPLIB_WEBSOCKET_CLOSE_TIMEOUT_SECOND, 0);
|
||||||
|
|
||||||
Opcode op;
|
Opcode op;
|
||||||
std::string resp;
|
std::string resp;
|
||||||
bool fin;
|
bool fin;
|
||||||
while (impl::read_websocket_frame(strm_, op, resp, fin, is_server_, 125) ==
|
while (std::chrono::steady_clock::now() < deadline &&
|
||||||
|
impl::read_websocket_frame(strm_, op, resp, fin, is_server_, 125) ==
|
||||||
impl::FrameRead::Ok) {
|
impl::FrameRead::Ok) {
|
||||||
if (op == Opcode::Close) { break; }
|
if (op == Opcode::Close) { break; }
|
||||||
}
|
}
|
||||||
|
|||||||
+1
-1
@@ -260,7 +260,7 @@ endif
|
|||||||
test_benchmark : test_benchmark.cc ../httplib.h Makefile
|
test_benchmark : test_benchmark.cc ../httplib.h Makefile
|
||||||
$(CXX) -o $@ -I.. $(CXXFLAGS) test_benchmark.cc gtest/src/gtest-all.cc gtest/src/gtest_main.cc -Igtest -Igtest/include $(BENCHMARK_LIBS)
|
$(CXX) -o $@ -I.. $(CXXFLAGS) test_benchmark.cc gtest/src/gtest-all.cc gtest/src/gtest_main.cc -Igtest -Igtest/include $(BENCHMARK_LIBS)
|
||||||
|
|
||||||
test_websocket_heartbeat : test_websocket_heartbeat.cc ../httplib.h Makefile
|
test_websocket_heartbeat : test_websocket_heartbeat.cc ../httplib.h Makefile cert.pem
|
||||||
$(CXX) -o $@ -I.. $(CXXFLAGS) test_websocket_heartbeat.cc $(TEST_ARGS)
|
$(CXX) -o $@ -I.. $(CXXFLAGS) test_websocket_heartbeat.cc $(TEST_ARGS)
|
||||||
@file $@
|
@file $@
|
||||||
|
|
||||||
|
|||||||
+13
-2
@@ -13,14 +13,15 @@ ZLIB_SUPPORT = -DCPPHTTPLIB_ZLIB_SUPPORT -lz
|
|||||||
BROTLI_DIR = /usr/local/opt/brotli
|
BROTLI_DIR = /usr/local/opt/brotli
|
||||||
# BROTLI_SUPPORT = -DCPPHTTPLIB_BROTLI_SUPPORT -I$(BROTLI_DIR)/include -L$(BROTLI_DIR)/lib -lbrotlicommon -lbrotlienc -lbrotlidec
|
# BROTLI_SUPPORT = -DCPPHTTPLIB_BROTLI_SUPPORT -I$(BROTLI_DIR)/include -L$(BROTLI_DIR)/lib -lbrotlicommon -lbrotlienc -lbrotlidec
|
||||||
|
|
||||||
FUZZERS = server_fuzzer url_parser_fuzzer header_parser_fuzzer client_fuzzer multipart_parser_fuzzer
|
FUZZERS = server_fuzzer url_parser_fuzzer header_parser_fuzzer client_fuzzer multipart_parser_fuzzer websocket_fuzzer sse_parser_fuzzer server_mount_fuzzer
|
||||||
|
|
||||||
# Runs all the tests and also fuzz tests against seed corpus.
|
# Runs all the tests and also fuzz tests against seed corpus.
|
||||||
all : $(FUZZERS)
|
all : $(FUZZERS)
|
||||||
./server_fuzzer corpus/*
|
./server_fuzzer corpus/*
|
||||||
|
./server_mount_fuzzer corpus_mount/*
|
||||||
|
|
||||||
# Fuzz target, so that you can choose which $(LIB_FUZZING_ENGINE) to use.
|
# Fuzz target, so that you can choose which $(LIB_FUZZING_ENGINE) to use.
|
||||||
server_fuzzer : server_fuzzer.cc ../../httplib.h
|
server_fuzzer : server_fuzzer.cc fuzzed_stream.h ../../httplib.h
|
||||||
# $(CXX) $(CXXFLAGS) -o $@ $< -Wl,-Bstatic $(OPENSSL_SUPPORT) -Wl,-Bdynamic -ldl $(ZLIB_SUPPORT) $(LIB_FUZZING_ENGINE) -pthread
|
# $(CXX) $(CXXFLAGS) -o $@ $< -Wl,-Bstatic $(OPENSSL_SUPPORT) -Wl,-Bdynamic -ldl $(ZLIB_SUPPORT) $(LIB_FUZZING_ENGINE) -pthread
|
||||||
$(CXX) $(CXXFLAGS) -o $@ $< $(ZLIB_SUPPORT) $(LIB_FUZZING_ENGINE) -pthread -lanl
|
$(CXX) $(CXXFLAGS) -o $@ $< $(ZLIB_SUPPORT) $(LIB_FUZZING_ENGINE) -pthread -lanl
|
||||||
zip -q -r server_fuzzer_seed_corpus.zip corpus
|
zip -q -r server_fuzzer_seed_corpus.zip corpus
|
||||||
@@ -38,5 +39,15 @@ url_parser_fuzzer : url_parser_fuzzer.cc ../../httplib.h
|
|||||||
multipart_parser_fuzzer : multipart_parser_fuzzer.cc ../../httplib.h
|
multipart_parser_fuzzer : multipart_parser_fuzzer.cc ../../httplib.h
|
||||||
$(CXX) $(CXXFLAGS) -o $@ $< $(ZLIB_SUPPORT) $(LIB_FUZZING_ENGINE) -pthread -lanl
|
$(CXX) $(CXXFLAGS) -o $@ $< $(ZLIB_SUPPORT) $(LIB_FUZZING_ENGINE) -pthread -lanl
|
||||||
|
|
||||||
|
websocket_fuzzer : websocket_fuzzer.cc ../../httplib.h
|
||||||
|
$(CXX) $(CXXFLAGS) -o $@ $< $(ZLIB_SUPPORT) $(LIB_FUZZING_ENGINE) -pthread -lanl
|
||||||
|
|
||||||
|
sse_parser_fuzzer : sse_parser_fuzzer.cc ../../httplib.h
|
||||||
|
$(CXX) $(CXXFLAGS) -o $@ $< $(ZLIB_SUPPORT) $(LIB_FUZZING_ENGINE) -pthread -lanl
|
||||||
|
|
||||||
|
server_mount_fuzzer : server_mount_fuzzer.cc fuzzed_stream.h ../../httplib.h
|
||||||
|
$(CXX) $(CXXFLAGS) -o $@ $< $(ZLIB_SUPPORT) $(LIB_FUZZING_ENGINE) -pthread -lanl
|
||||||
|
zip -q -r server_mount_fuzzer_seed_corpus.zip corpus_mount
|
||||||
|
|
||||||
clean:
|
clean:
|
||||||
rm -f server_fuzzer pem *.0 *.o *.1 *.srl *.zip
|
rm -f server_fuzzer pem *.0 *.o *.1 *.srl *.zip
|
||||||
@@ -0,0 +1,3 @@
|
|||||||
|
HEAD /mnt/a.txt HTTP/1.1
|
||||||
|
Host: x
|
||||||
|
|
||||||
@@ -0,0 +1,4 @@
|
|||||||
|
GET /mnt/a.txt HTTP/1.1
|
||||||
|
Host: x
|
||||||
|
If-Modified-Since: Mon, 01 Jan 2024 00:00:00 GMT
|
||||||
|
|
||||||
@@ -0,0 +1,3 @@
|
|||||||
|
GET /mnt/index.html HTTP/1.1
|
||||||
|
Host: x
|
||||||
|
|
||||||
@@ -0,0 +1,4 @@
|
|||||||
|
GET /mnt/index.html HTTP/1.1
|
||||||
|
Host: x
|
||||||
|
If-None-Match: W/"bogusetag"
|
||||||
|
|
||||||
@@ -0,0 +1,3 @@
|
|||||||
|
GET /mnt/link-in.txt HTTP/1.1
|
||||||
|
Host: x
|
||||||
|
|
||||||
@@ -0,0 +1,3 @@
|
|||||||
|
GET /mnt/link-out.txt HTTP/1.1
|
||||||
|
Host: x
|
||||||
|
|
||||||
@@ -0,0 +1,3 @@
|
|||||||
|
GET /mnt/link-sibling.txt HTTP/1.1
|
||||||
|
Host: x
|
||||||
|
|
||||||
@@ -0,0 +1,3 @@
|
|||||||
|
GET /mnt/missing.txt HTTP/1.1
|
||||||
|
Host: x
|
||||||
|
|
||||||
@@ -0,0 +1,4 @@
|
|||||||
|
GET /mnt/a.txt HTTP/1.1
|
||||||
|
Host: x
|
||||||
|
Range: bytes=0-3
|
||||||
|
|
||||||
@@ -0,0 +1,3 @@
|
|||||||
|
GET /mnt/sub/ HTTP/1.1
|
||||||
|
Host: x
|
||||||
|
|
||||||
@@ -0,0 +1,3 @@
|
|||||||
|
GET /mnt/../../../../etc/passwd HTTP/1.1
|
||||||
|
Host: x
|
||||||
|
|
||||||
@@ -0,0 +1,3 @@
|
|||||||
|
GET /mnt/%2e%2e/secret.txt HTTP/1.1
|
||||||
|
Host: x
|
||||||
|
|
||||||
@@ -0,0 +1,84 @@
|
|||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <cstdint>
|
||||||
|
|
||||||
|
#include <httplib.h>
|
||||||
|
|
||||||
|
class FuzzedStream : public httplib::Stream {
|
||||||
|
public:
|
||||||
|
FuzzedStream(const uint8_t *data, size_t size)
|
||||||
|
: data_(data), size_(size), read_pos_(0) {}
|
||||||
|
|
||||||
|
ssize_t read(char *ptr, size_t size) override {
|
||||||
|
if (size + read_pos_ > size_) { size = size_ - read_pos_; }
|
||||||
|
memcpy(ptr, data_ + read_pos_, size);
|
||||||
|
read_pos_ += size;
|
||||||
|
// Like SocketStream, pull in more than was asked for, which the line
|
||||||
|
// reader then takes through buffered_data(), so both of its paths run.
|
||||||
|
buffered_end_ =
|
||||||
|
(std::max)(buffered_end_, (std::min)(size_, read_pos_ + 4096));
|
||||||
|
return static_cast<ssize_t>(size);
|
||||||
|
}
|
||||||
|
|
||||||
|
const char *buffered_data(size_t &size) const override {
|
||||||
|
size = buffered_end_ > read_pos_ ? buffered_end_ - read_pos_ : 0;
|
||||||
|
return size ? reinterpret_cast<const char *>(data_ + read_pos_) : nullptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
void consume_buffered(size_t size) override { read_pos_ += size; }
|
||||||
|
|
||||||
|
ssize_t write(const char *ptr, size_t size) override {
|
||||||
|
response_.append(ptr, size);
|
||||||
|
return static_cast<int>(size);
|
||||||
|
}
|
||||||
|
|
||||||
|
ssize_t write(const char *ptr) { return write(ptr, strlen(ptr)); }
|
||||||
|
|
||||||
|
ssize_t write(const std::string &s) { return write(s.data(), s.size()); }
|
||||||
|
|
||||||
|
bool is_readable() const override { return true; }
|
||||||
|
|
||||||
|
bool wait_readable() const override { return true; }
|
||||||
|
|
||||||
|
bool wait_writable() const override { return true; }
|
||||||
|
|
||||||
|
void get_remote_ip_and_port(std::string &ip, int &port) const override {
|
||||||
|
ip = "127.0.0.1";
|
||||||
|
port = 8080;
|
||||||
|
}
|
||||||
|
|
||||||
|
void get_local_ip_and_port(std::string &ip, int &port) const override {
|
||||||
|
ip = "127.0.0.1";
|
||||||
|
port = 8080;
|
||||||
|
}
|
||||||
|
|
||||||
|
socket_t socket() const override { return 0; }
|
||||||
|
|
||||||
|
time_t duration() const override { return 0; };
|
||||||
|
|
||||||
|
const std::string &response() const { return response_; }
|
||||||
|
|
||||||
|
private:
|
||||||
|
const uint8_t *data_;
|
||||||
|
size_t size_;
|
||||||
|
size_t read_pos_;
|
||||||
|
size_t buffered_end_ = 0;
|
||||||
|
std::string response_;
|
||||||
|
};
|
||||||
|
|
||||||
|
class FuzzableServer : public httplib::Server {
|
||||||
|
public:
|
||||||
|
// A server that is not listening counts as shutting down, and then writes
|
||||||
|
// no file. The socket is never used.
|
||||||
|
void MarkAsRunning() { svr_sock_ = 0; }
|
||||||
|
|
||||||
|
void ProcessFuzzedRequest(FuzzedStream &stream) {
|
||||||
|
bool connection_close = false;
|
||||||
|
process_request(stream,
|
||||||
|
/*remote_addr=*/"",
|
||||||
|
/*remote_port =*/0,
|
||||||
|
/*local_addr=*/"",
|
||||||
|
/*local_port =*/0,
|
||||||
|
/*last_connection=*/false, connection_close, nullptr);
|
||||||
|
}
|
||||||
|
};
|
||||||
@@ -1,79 +1,4 @@
|
|||||||
#include <cstdint>
|
#include "fuzzed_stream.h"
|
||||||
|
|
||||||
#include <httplib.h>
|
|
||||||
|
|
||||||
class FuzzedStream : public httplib::Stream {
|
|
||||||
public:
|
|
||||||
FuzzedStream(const uint8_t *data, size_t size)
|
|
||||||
: data_(data), size_(size), read_pos_(0) {}
|
|
||||||
|
|
||||||
ssize_t read(char *ptr, size_t size) override {
|
|
||||||
if (size + read_pos_ > size_) { size = size_ - read_pos_; }
|
|
||||||
memcpy(ptr, data_ + read_pos_, size);
|
|
||||||
read_pos_ += size;
|
|
||||||
// Like SocketStream, pull in more than was asked for, which the line
|
|
||||||
// reader then takes through buffered_data(), so both of its paths run.
|
|
||||||
buffered_end_ =
|
|
||||||
(std::max)(buffered_end_, (std::min)(size_, read_pos_ + 4096));
|
|
||||||
return static_cast<ssize_t>(size);
|
|
||||||
}
|
|
||||||
|
|
||||||
const char *buffered_data(size_t &size) const override {
|
|
||||||
size = buffered_end_ > read_pos_ ? buffered_end_ - read_pos_ : 0;
|
|
||||||
return size ? reinterpret_cast<const char *>(data_ + read_pos_) : nullptr;
|
|
||||||
}
|
|
||||||
|
|
||||||
void consume_buffered(size_t size) override { read_pos_ += size; }
|
|
||||||
|
|
||||||
ssize_t write(const char *ptr, size_t size) override {
|
|
||||||
response_.append(ptr, size);
|
|
||||||
return static_cast<int>(size);
|
|
||||||
}
|
|
||||||
|
|
||||||
ssize_t write(const char *ptr) { return write(ptr, strlen(ptr)); }
|
|
||||||
|
|
||||||
ssize_t write(const std::string &s) { return write(s.data(), s.size()); }
|
|
||||||
|
|
||||||
bool is_readable() const override { return true; }
|
|
||||||
|
|
||||||
bool wait_readable() const override { return true; }
|
|
||||||
|
|
||||||
bool wait_writable() const override { return true; }
|
|
||||||
|
|
||||||
void get_remote_ip_and_port(std::string &ip, int &port) const override {
|
|
||||||
ip = "127.0.0.1";
|
|
||||||
port = 8080;
|
|
||||||
}
|
|
||||||
|
|
||||||
void get_local_ip_and_port(std::string &ip, int &port) const override {
|
|
||||||
ip = "127.0.0.1";
|
|
||||||
port = 8080;
|
|
||||||
}
|
|
||||||
|
|
||||||
socket_t socket() const override { return 0; }
|
|
||||||
|
|
||||||
time_t duration() const override { return 0; };
|
|
||||||
|
|
||||||
private:
|
|
||||||
const uint8_t *data_;
|
|
||||||
size_t size_;
|
|
||||||
size_t read_pos_;
|
|
||||||
size_t buffered_end_ = 0;
|
|
||||||
std::string response_;
|
|
||||||
};
|
|
||||||
|
|
||||||
class FuzzableServer : public httplib::Server {
|
|
||||||
public:
|
|
||||||
void ProcessFuzzedRequest(FuzzedStream &stream) {
|
|
||||||
bool connection_close = false;
|
|
||||||
process_request(stream,
|
|
||||||
/*remote_addr=*/"",
|
|
||||||
/*remote_port =*/0,
|
|
||||||
/*local_addr=*/"",
|
|
||||||
/*local_port =*/0,
|
|
||||||
/*last_connection=*/false, connection_close, nullptr);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
static FuzzableServer g_server;
|
static FuzzableServer g_server;
|
||||||
|
|
||||||
|
|||||||
@@ -0,0 +1,117 @@
|
|||||||
|
#include <cstdio>
|
||||||
|
#include <cstdlib>
|
||||||
|
#include <fstream>
|
||||||
|
#include <random>
|
||||||
|
#include <string>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
#include <sys/stat.h>
|
||||||
|
#include <unistd.h>
|
||||||
|
#include <utime.h>
|
||||||
|
|
||||||
|
#include "fuzzed_stream.h"
|
||||||
|
|
||||||
|
// Fixture layout, with <token> unknown to the fuzzer:
|
||||||
|
// root/mnt/{index.html,a.txt,data.bin,sub/index.html} served at /mnt
|
||||||
|
// root/mnt/link-in.txt -> a.txt (stays inside, may be served)
|
||||||
|
// root/mnt/link-out.txt -> ../outside.txt (escapes, must be refused)
|
||||||
|
// root/mnt/link-sibling.txt -> ../mnt_secret/secret.txt (shares the "mnt"
|
||||||
|
// prefix, must be refused)
|
||||||
|
// The response must never contain <token>.
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
|
||||||
|
FuzzableServer g_server;
|
||||||
|
std::string g_root;
|
||||||
|
std::string g_token;
|
||||||
|
std::vector<std::string> g_paths; // In creation order
|
||||||
|
|
||||||
|
void check(bool ok, const char *what) {
|
||||||
|
if (!ok) {
|
||||||
|
fprintf(stderr, "fixture setup failed: %s\n", what);
|
||||||
|
abort();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void make_dir(const std::string &path) {
|
||||||
|
check(mkdir(path.c_str(), 0755) == 0, path.c_str());
|
||||||
|
g_paths.push_back(path);
|
||||||
|
}
|
||||||
|
|
||||||
|
void make_file(const std::string &path, const std::string &content) {
|
||||||
|
{
|
||||||
|
std::ofstream out(path, std::ios::binary);
|
||||||
|
out << content;
|
||||||
|
check(out.good(), path.c_str());
|
||||||
|
}
|
||||||
|
// Fixed, so that conditional requests behave the same in every run
|
||||||
|
utimbuf times = {1700000000, 1700000000};
|
||||||
|
check(utime(path.c_str(), ×) == 0, path.c_str());
|
||||||
|
g_paths.push_back(path);
|
||||||
|
}
|
||||||
|
|
||||||
|
void make_link(const std::string &target, const std::string &path) {
|
||||||
|
check(symlink(target.c_str(), path.c_str()) == 0, path.c_str());
|
||||||
|
g_paths.push_back(path);
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string serve(const uint8_t *data, size_t size) {
|
||||||
|
FuzzedStream stream{data, size};
|
||||||
|
g_server.ProcessFuzzedRequest(stream);
|
||||||
|
return stream.response();
|
||||||
|
}
|
||||||
|
|
||||||
|
void check_served(const char *path) {
|
||||||
|
auto req = std::string("GET ") + path + " HTTP/1.1\r\nHost: x\r\n\r\n";
|
||||||
|
auto res = serve(reinterpret_cast<const uint8_t *>(req.data()), req.size());
|
||||||
|
// Without this, a fuzzer that serves nothing would pass its check forever
|
||||||
|
check(res.find("abcdef") != std::string::npos, path);
|
||||||
|
}
|
||||||
|
|
||||||
|
void remove_fixture() {
|
||||||
|
for (auto it = g_paths.rbegin(); it != g_paths.rend(); ++it) {
|
||||||
|
if (unlink(it->c_str()) != 0) { rmdir(it->c_str()); }
|
||||||
|
}
|
||||||
|
rmdir(g_root.c_str());
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace
|
||||||
|
|
||||||
|
extern "C" int LLVMFuzzerInitialize(int * /*argc*/, char *** /*argv*/) {
|
||||||
|
std::random_device rd;
|
||||||
|
char token[33];
|
||||||
|
snprintf(token, sizeof(token), "%08x%08x%08x%08x", rd(), rd(), rd(), rd());
|
||||||
|
g_token = token;
|
||||||
|
|
||||||
|
auto tmpdir = getenv("TMPDIR");
|
||||||
|
auto tmpl = std::string(tmpdir && *tmpdir ? tmpdir : "/tmp") +
|
||||||
|
"/httplib-mount-XXXXXX";
|
||||||
|
check(mkdtemp(&tmpl[0]) != nullptr, tmpl.c_str());
|
||||||
|
g_root = tmpl;
|
||||||
|
atexit(remove_fixture);
|
||||||
|
|
||||||
|
auto mnt = g_root + "/mnt";
|
||||||
|
make_dir(mnt);
|
||||||
|
make_dir(mnt + "/sub");
|
||||||
|
make_dir(g_root + "/mnt_secret");
|
||||||
|
make_file(mnt + "/index.html", "<html>index</html>");
|
||||||
|
make_file(mnt + "/a.txt", "abcdef");
|
||||||
|
make_file(mnt + "/data.bin", std::string("\x01\x02\x03\x04\x05\x06", 6));
|
||||||
|
make_file(mnt + "/sub/index.html", "<html>sub</html>");
|
||||||
|
make_file(g_root + "/outside.txt", g_token);
|
||||||
|
make_file(g_root + "/mnt_secret/secret.txt", g_token);
|
||||||
|
make_link("a.txt", mnt + "/link-in.txt");
|
||||||
|
make_link("../outside.txt", mnt + "/link-out.txt");
|
||||||
|
make_link("../mnt_secret/secret.txt", mnt + "/link-sibling.txt");
|
||||||
|
|
||||||
|
g_server.MarkAsRunning();
|
||||||
|
check(g_server.set_mount_point("/mnt", mnt), "set_mount_point");
|
||||||
|
check_served("/mnt/a.txt");
|
||||||
|
check_served("/mnt/link-in.txt");
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
|
||||||
|
if (serve(data, size).find(g_token) != std::string::npos) { abort(); }
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
@@ -0,0 +1,24 @@
|
|||||||
|
"GET"
|
||||||
|
"HEAD"
|
||||||
|
"HTTP/1.1"
|
||||||
|
|
||||||
|
"/mnt/"
|
||||||
|
"/mnt/index.html"
|
||||||
|
"/mnt/a.txt"
|
||||||
|
"/mnt/data.bin"
|
||||||
|
"/mnt/sub/"
|
||||||
|
"/mnt/link-in.txt"
|
||||||
|
"/mnt/link-out.txt"
|
||||||
|
"/mnt/link-sibling.txt"
|
||||||
|
".."
|
||||||
|
"%2e%2e"
|
||||||
|
"%2f"
|
||||||
|
"//"
|
||||||
|
|
||||||
|
"Range: bytes=0-"
|
||||||
|
"Range: bytes=0-3,5-"
|
||||||
|
"If-None-Match: "
|
||||||
|
"W/"
|
||||||
|
"If-Modified-Since: "
|
||||||
|
"If-Range: "
|
||||||
|
"Accept-Encoding: gzip"
|
||||||
@@ -0,0 +1,49 @@
|
|||||||
|
#include <algorithm>
|
||||||
|
#include <cstdint>
|
||||||
|
#include <cstdlib>
|
||||||
|
#include <string>
|
||||||
|
|
||||||
|
#include <httplib.h>
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
|
||||||
|
// Feeds the stream in chunks and records every handler call in order
|
||||||
|
std::string parse_in_chunks(const std::string &stream, size_t chunk,
|
||||||
|
size_t max_event_length) {
|
||||||
|
std::string trace;
|
||||||
|
httplib::detail::SSEParser parser(
|
||||||
|
[&](const httplib::sse::SSEMessage &msg) {
|
||||||
|
trace += "event[" + msg.event + "|" + msg.data + "|" + msg.id + "]";
|
||||||
|
},
|
||||||
|
[&](const std::string &id) { trace += "id[" + id + "]"; },
|
||||||
|
[&](int retry_ms) { trace += "retry[" + std::to_string(retry_ms) + "]"; },
|
||||||
|
max_event_length);
|
||||||
|
|
||||||
|
for (size_t off = 0; off < stream.size(); off += chunk) {
|
||||||
|
if (!parser.parse(stream.data() + off,
|
||||||
|
std::min(chunk, stream.size() - off))) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return trace;
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace
|
||||||
|
|
||||||
|
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
|
||||||
|
if (size < 2 || size > 65536) { return 0; }
|
||||||
|
|
||||||
|
// First byte selects the chunk size, the rest is the event stream
|
||||||
|
auto chunk = static_cast<size_t>(data[0]) + 1;
|
||||||
|
std::string stream(reinterpret_cast<const char *>(data + 1), size - 1);
|
||||||
|
|
||||||
|
// Without a length limit, chunking must not change what is reported
|
||||||
|
auto whole = parse_in_chunks(stream, stream.size(), 0);
|
||||||
|
auto chunked = parse_in_chunks(stream, chunk, 0);
|
||||||
|
if (whole != chunked) { std::abort(); }
|
||||||
|
|
||||||
|
// With a limit, only check that the parser stops cleanly
|
||||||
|
parse_in_chunks(stream, chunk, 64);
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
@@ -13,7 +13,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
|
|||||||
size_t payload_size = size - 1;
|
size_t payload_size = size - 1;
|
||||||
std::string input(payload, payload_size);
|
std::string input(payload, payload_size);
|
||||||
|
|
||||||
switch (selector % 6) {
|
switch (selector % 13) {
|
||||||
case 0: {
|
case 0: {
|
||||||
// parse_query_text
|
// parse_query_text
|
||||||
httplib::Params params;
|
httplib::Params params;
|
||||||
@@ -46,6 +46,48 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
|
|||||||
httplib::detail::is_valid_path(input);
|
httplib::detail::is_valid_path(input);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
case 6: {
|
||||||
|
// parse_url
|
||||||
|
httplib::detail::UrlComponents uc;
|
||||||
|
httplib::detail::parse_url(input, uc);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case 7: {
|
||||||
|
// remove_dot_segments
|
||||||
|
httplib::detail::remove_dot_segments(input);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case 8: {
|
||||||
|
// resolve_relative_location, with the input as "<location>\n<base>"
|
||||||
|
auto nl = input.find('\n');
|
||||||
|
auto location = input.substr(0, nl);
|
||||||
|
auto base = nl == std::string::npos ? std::string("/index.html")
|
||||||
|
: input.substr(nl + 1);
|
||||||
|
httplib::detail::resolve_relative_location(location, base);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case 9: {
|
||||||
|
// encode_path
|
||||||
|
httplib::detail::encode_path(input);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case 10: {
|
||||||
|
// encode_uri_component, encode_uri
|
||||||
|
httplib::encode_uri_component(input);
|
||||||
|
httplib::encode_uri(input);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case 11: {
|
||||||
|
// decode_uri_component, decode_uri
|
||||||
|
httplib::decode_uri_component(input);
|
||||||
|
httplib::decode_uri(input);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case 12: {
|
||||||
|
// sanitize_filename
|
||||||
|
httplib::sanitize_filename(input);
|
||||||
|
break;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
return 0;
|
return 0;
|
||||||
|
|||||||
@@ -0,0 +1,54 @@
|
|||||||
|
#include <cstdint>
|
||||||
|
#include <string>
|
||||||
|
|
||||||
|
#include <httplib.h>
|
||||||
|
|
||||||
|
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
|
||||||
|
if (size < 2) { return 0; }
|
||||||
|
|
||||||
|
auto selector = data[0];
|
||||||
|
std::string input(reinterpret_cast<const char *>(data + 1), size - 1);
|
||||||
|
|
||||||
|
switch (selector % 4) {
|
||||||
|
case 0: {
|
||||||
|
// read_websocket_frame. WebSocket::read passes the macro, close() passes
|
||||||
|
// 125, and 0 means no limit
|
||||||
|
static const size_t max_lens[] = {0, 125,
|
||||||
|
CPPHTTPLIB_WEBSOCKET_MAX_PAYLOAD_LENGTH};
|
||||||
|
auto expect_masked = (selector / 4) % 2 != 0;
|
||||||
|
auto max_len = max_lens[(selector / 8) % 3];
|
||||||
|
httplib::detail::BufferStream strm;
|
||||||
|
strm.write(input.data(), input.size());
|
||||||
|
auto opcode = httplib::ws::Opcode::Text;
|
||||||
|
std::string payload;
|
||||||
|
auto fin = false;
|
||||||
|
httplib::ws::impl::read_websocket_frame(strm, opcode, payload, fin,
|
||||||
|
expect_masked, max_len);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case 1: {
|
||||||
|
// is_valid_utf8
|
||||||
|
httplib::ws::impl::is_valid_utf8(input);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case 2: {
|
||||||
|
// is_valid_close_payload
|
||||||
|
httplib::ws::impl::is_valid_close_payload(input);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case 3: {
|
||||||
|
// read_websocket_upgrade_response, with a fixed key since
|
||||||
|
// perform_websocket_handshake draws a random one
|
||||||
|
static const auto expected_accept =
|
||||||
|
httplib::detail::websocket_accept_key("dGhlIHNhbXBsZSBub25jZQ==");
|
||||||
|
httplib::detail::BufferStream strm;
|
||||||
|
strm.write(input.data(), input.size());
|
||||||
|
httplib::detail::WebSocketUpgradeResponse upgrade;
|
||||||
|
httplib::detail::read_websocket_upgrade_response(strm, expected_accept,
|
||||||
|
"chat, stream", upgrade);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
@@ -0,0 +1,2 @@
|
|||||||
|
[libfuzzer]
|
||||||
|
max_len = 70000
|
||||||
+566
-233
@@ -291,6 +291,76 @@ TEST_F(UnixSocketTest, HostHeaderAutoSet) {
|
|||||||
EXPECT_EQ(received_host_header, "localhost");
|
EXPECT_EQ(received_host_header, "localhost");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
TEST_F(UnixSocketTest, RedirectStaysOnSocket) {
|
||||||
|
// Another socket in the working directory, which a Location can name as
|
||||||
|
// its host
|
||||||
|
const auto other_path = "other-" + pathname_.substr(2);
|
||||||
|
|
||||||
|
httplib::Server svr;
|
||||||
|
svr.Get("/redirect", [&](const httplib::Request &, httplib::Response &res) {
|
||||||
|
// An absolute Location naming the Host this client sends
|
||||||
|
res.set_redirect("http://localhost" + pattern_);
|
||||||
|
});
|
||||||
|
svr.Get("/cross", [&](const httplib::Request &, httplib::Response &res) {
|
||||||
|
res.set_redirect("http://" + other_path + pattern_);
|
||||||
|
});
|
||||||
|
svr.Get("/mapped", [&](const httplib::Request &, httplib::Response &res) {
|
||||||
|
res.set_redirect("http://mapped.test" + pattern_);
|
||||||
|
});
|
||||||
|
svr.Get(pattern_, [&](const httplib::Request &req, httplib::Response &res) {
|
||||||
|
res.set_header("X-Auth", req.get_header_value("Authorization"));
|
||||||
|
res.set_content(content_, "text/plain");
|
||||||
|
});
|
||||||
|
|
||||||
|
httplib::Server other;
|
||||||
|
other.Get(pattern_, [&](const httplib::Request &, httplib::Response &res) {
|
||||||
|
res.set_content("other", "text/plain");
|
||||||
|
});
|
||||||
|
|
||||||
|
std::thread t{[&] {
|
||||||
|
ASSERT_TRUE(svr.set_address_family(AF_UNIX).listen(pathname_, 80));
|
||||||
|
}};
|
||||||
|
std::thread t2{[&] {
|
||||||
|
ASSERT_TRUE(other.set_address_family(AF_UNIX).listen(other_path, 80));
|
||||||
|
}};
|
||||||
|
auto se = detail::scope_exit([&] {
|
||||||
|
svr.stop();
|
||||||
|
other.stop();
|
||||||
|
t.join();
|
||||||
|
t2.join();
|
||||||
|
std::remove(other_path.c_str());
|
||||||
|
});
|
||||||
|
|
||||||
|
svr.wait_until_ready();
|
||||||
|
other.wait_until_ready();
|
||||||
|
|
||||||
|
httplib::Client cli{pathname_};
|
||||||
|
cli.set_address_family(AF_UNIX);
|
||||||
|
cli.set_follow_location(true);
|
||||||
|
cli.set_bearer_token_auth("token");
|
||||||
|
|
||||||
|
// Another host: the same socket, without the credentials
|
||||||
|
auto res = cli.Get("/cross");
|
||||||
|
ASSERT_TRUE(res) << "error: " << res.error();
|
||||||
|
EXPECT_EQ(StatusCode::OK_200, res->status);
|
||||||
|
EXPECT_EQ(content_, res->body);
|
||||||
|
EXPECT_EQ("", res->get_header_value("X-Auth"));
|
||||||
|
|
||||||
|
// localhost is this client's own host
|
||||||
|
res = cli.Get("/redirect");
|
||||||
|
ASSERT_TRUE(res) << "error: " << res.error();
|
||||||
|
EXPECT_EQ(StatusCode::OK_200, res->status);
|
||||||
|
EXPECT_EQ(content_, res->body);
|
||||||
|
EXPECT_EQ("Bearer token", res->get_header_value("X-Auth"));
|
||||||
|
|
||||||
|
// A host the caller mapped to a socket goes there
|
||||||
|
cli.set_direct_hostname_addr_map({{"mapped.test", other_path}});
|
||||||
|
res = cli.Get("/mapped");
|
||||||
|
ASSERT_TRUE(res) << "error: " << res.error();
|
||||||
|
EXPECT_EQ(StatusCode::OK_200, res->status);
|
||||||
|
EXPECT_EQ("other", res->body);
|
||||||
|
}
|
||||||
|
|
||||||
#ifndef _WIN32
|
#ifndef _WIN32
|
||||||
TEST(SocketStream, wait_writable_UNIX) {
|
TEST(SocketStream, wait_writable_UNIX) {
|
||||||
int fds[2];
|
int fds[2];
|
||||||
@@ -2322,6 +2392,13 @@ TEST(HeadersOrderTest, ErasingByNameKeepsTheRemainingOrder) {
|
|||||||
EXPECT_EQ("B=2 C=4 ", entries_to_string(headers));
|
EXPECT_EQ("B=2 C=4 ", entries_to_string(headers));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
TEST(HeadersOrderTest, ErasingAnAliasedNameKeepsTheRemainingOrder) {
|
||||||
|
Headers headers = {{"A", "1"}, {"B", "2"}, {"a", "3"}, {"B", "4"}};
|
||||||
|
|
||||||
|
EXPECT_EQ(2U, headers.erase(headers.begin()->first));
|
||||||
|
EXPECT_EQ("B=2 B=4 ", entries_to_string(headers));
|
||||||
|
}
|
||||||
|
|
||||||
TEST(HeadersOrderTest, EmplaceFrontPrepends) {
|
TEST(HeadersOrderTest, EmplaceFrontPrepends) {
|
||||||
Headers headers = {{"Accept", "*/*"}, {"User-Agent", "test"}};
|
Headers headers = {{"Accept", "*/*"}, {"User-Agent", "test"}};
|
||||||
headers.emplace_front("Host", "example.com");
|
headers.emplace_front("Host", "example.com");
|
||||||
@@ -13338,6 +13415,175 @@ TEST(KeepAliveTest, MaxCountZeroSetsNoLimit) {
|
|||||||
EXPECT_EQ(1u, remote_ports.size());
|
EXPECT_EQ(1u, remote_ports.size());
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Forward declaration (see the base64_encode note).
|
||||||
|
namespace httplib {
|
||||||
|
namespace detail {
|
||||||
|
ssize_t select_read(socket_t sock, time_t sec, time_t usec);
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace httplib
|
||||||
|
|
||||||
|
// RFC 9112 9.2: an unsolicited 408 must not be read as the next response
|
||||||
|
static void expect_no_reuse_with_unread_data(bool use_tls, bool same_write) {
|
||||||
|
#ifndef _WIN32
|
||||||
|
signal(SIGPIPE, SIG_IGN);
|
||||||
|
#endif
|
||||||
|
|
||||||
|
auto srv = ::socket(AF_INET, SOCK_STREAM, 0);
|
||||||
|
ASSERT_NE(INVALID_SOCKET, srv);
|
||||||
|
auto srv_se = detail::scope_exit([&] { detail::close_socket(srv); });
|
||||||
|
default_socket_options(srv);
|
||||||
|
|
||||||
|
sockaddr_in addr{};
|
||||||
|
addr.sin_family = AF_INET;
|
||||||
|
addr.sin_port = 0;
|
||||||
|
::inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr);
|
||||||
|
ASSERT_EQ(0, ::bind(srv, reinterpret_cast<sockaddr *>(&addr), sizeof(addr)));
|
||||||
|
ASSERT_EQ(0, ::listen(srv, 2));
|
||||||
|
socklen_t addr_len = sizeof(addr);
|
||||||
|
ASSERT_EQ(0,
|
||||||
|
::getsockname(srv, reinterpret_cast<sockaddr *>(&addr), &addr_len));
|
||||||
|
auto port = ntohs(addr.sin_port);
|
||||||
|
|
||||||
|
struct Peer {
|
||||||
|
socket_t sock = INVALID_SOCKET;
|
||||||
|
#ifdef CPPHTTPLIB_SSL_ENABLED
|
||||||
|
tls::session_t session = nullptr;
|
||||||
|
#endif
|
||||||
|
};
|
||||||
|
|
||||||
|
#ifdef CPPHTTPLIB_SSL_ENABLED
|
||||||
|
tls::ctx_t ctx = nullptr;
|
||||||
|
if (use_tls) {
|
||||||
|
ctx = tls::create_server_context();
|
||||||
|
tls::set_server_cert_file(ctx, SERVER_CERT_FILE, SERVER_PRIVATE_KEY_FILE,
|
||||||
|
nullptr);
|
||||||
|
}
|
||||||
|
auto ctx_se = detail::scope_exit([&] {
|
||||||
|
if (ctx) { tls::free_context(ctx); }
|
||||||
|
});
|
||||||
|
#endif
|
||||||
|
|
||||||
|
auto close_peer = [](Peer &peer) {
|
||||||
|
#ifdef CPPHTTPLIB_SSL_ENABLED
|
||||||
|
if (peer.session) { tls::free_session(peer.session); }
|
||||||
|
#endif
|
||||||
|
if (peer.sock != INVALID_SOCKET) { detail::close_socket(peer.sock); }
|
||||||
|
};
|
||||||
|
auto accept_peer = [&]() {
|
||||||
|
Peer peer;
|
||||||
|
if (detail::select_read(srv, 5, 0) <= 0) { return peer; }
|
||||||
|
peer.sock = ::accept(srv, nullptr, nullptr);
|
||||||
|
if (peer.sock == INVALID_SOCKET) { return peer; }
|
||||||
|
detail::set_socket_opt_time(peer.sock, SOL_SOCKET, SO_RCVTIMEO, 5, 0);
|
||||||
|
#ifdef CPPHTTPLIB_SSL_ENABLED
|
||||||
|
if (use_tls) {
|
||||||
|
peer.session = tls::create_session(ctx, peer.sock);
|
||||||
|
tls::TlsError err;
|
||||||
|
if (!tls::accept_nonblocking(peer.session, peer.sock, 5, 0, &err)) {
|
||||||
|
close_peer(peer);
|
||||||
|
return Peer();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
return peer;
|
||||||
|
};
|
||||||
|
auto read_some = [](const Peer &peer, char *buf, size_t len) -> ssize_t {
|
||||||
|
#ifdef CPPHTTPLIB_SSL_ENABLED
|
||||||
|
tls::TlsError err;
|
||||||
|
if (peer.session) { return tls::read(peer.session, buf, len, err); }
|
||||||
|
#endif
|
||||||
|
return detail::read_socket(peer.sock, buf, len, 0);
|
||||||
|
};
|
||||||
|
auto read_head = [&](const Peer &peer) {
|
||||||
|
std::string head;
|
||||||
|
char buf[1024];
|
||||||
|
while (head.find("\r\n\r\n") == std::string::npos) {
|
||||||
|
auto n = read_some(peer, buf, sizeof(buf));
|
||||||
|
if (n <= 0) { break; }
|
||||||
|
head.append(buf, static_cast<size_t>(n));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
auto send_text = [](const Peer &peer, const std::string &text) {
|
||||||
|
#ifdef CPPHTTPLIB_SSL_ENABLED
|
||||||
|
tls::TlsError err;
|
||||||
|
if (peer.session) {
|
||||||
|
tls::write(peer.session, text.data(), text.size(), err);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
detail::send_socket(peer.sock, text.data(), text.size(), 0);
|
||||||
|
};
|
||||||
|
|
||||||
|
const std::string first = "HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\nfirst";
|
||||||
|
const std::string stray = "HTTP/1.1 408 Request Timeout\r\n"
|
||||||
|
"Connection: close\r\nContent-Length: 0\r\n\r\n";
|
||||||
|
|
||||||
|
// Sent once the first response is read, so that it lands on an idle socket
|
||||||
|
std::promise<void> first_response_read;
|
||||||
|
auto first_response_read_future = first_response_read.get_future();
|
||||||
|
auto server_thread = std::thread([&] {
|
||||||
|
auto peer1 = accept_peer();
|
||||||
|
if (peer1.sock == INVALID_SOCKET) { return; }
|
||||||
|
read_head(peer1);
|
||||||
|
if (same_write) {
|
||||||
|
send_text(peer1, first + stray);
|
||||||
|
} else {
|
||||||
|
send_text(peer1, first);
|
||||||
|
first_response_read_future.wait_for(std::chrono::seconds(5));
|
||||||
|
send_text(peer1, stray);
|
||||||
|
}
|
||||||
|
|
||||||
|
// peer1 stays open, so only the unread data can tell the client
|
||||||
|
auto peer2 = accept_peer();
|
||||||
|
if (peer2.sock != INVALID_SOCKET) {
|
||||||
|
read_head(peer2);
|
||||||
|
send_text(peer2, "HTTP/1.1 200 OK\r\nContent-Length: 6\r\n"
|
||||||
|
"Connection: close\r\n\r\nsecond");
|
||||||
|
close_peer(peer2);
|
||||||
|
}
|
||||||
|
close_peer(peer1);
|
||||||
|
});
|
||||||
|
auto server_se = detail::scope_exit([&] { server_thread.join(); });
|
||||||
|
|
||||||
|
Client cli((use_tls ? "https://127.0.0.1:" : "http://127.0.0.1:") +
|
||||||
|
std::to_string(port));
|
||||||
|
#ifdef CPPHTTPLIB_SSL_ENABLED
|
||||||
|
cli.enable_server_certificate_verification(false);
|
||||||
|
#endif
|
||||||
|
cli.set_keep_alive(true);
|
||||||
|
cli.set_read_timeout(5, 0);
|
||||||
|
|
||||||
|
auto res = cli.Get("/1");
|
||||||
|
first_response_read.set_value();
|
||||||
|
ASSERT_TRUE(res) << "Error: " << to_string(res.error());
|
||||||
|
EXPECT_EQ("first", res->body);
|
||||||
|
|
||||||
|
if (!same_write) { ASSERT_GT(detail::select_read(cli.socket(), 5, 0), 0); }
|
||||||
|
|
||||||
|
res = cli.Get("/2");
|
||||||
|
ASSERT_TRUE(res) << "Error: " << to_string(res.error());
|
||||||
|
EXPECT_EQ(StatusCode::OK_200, res->status);
|
||||||
|
EXPECT_EQ("second", res->body);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(KeepAliveTest, ClientDoesNotReuseConnectionWithUnreadData) {
|
||||||
|
expect_no_reuse_with_unread_data(/*use_tls=*/false, /*same_write=*/false);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(KeepAliveTest, ClientDoesNotReuseConnectionWithDataPastResponse) {
|
||||||
|
expect_no_reuse_with_unread_data(/*use_tls=*/false, /*same_write=*/true);
|
||||||
|
}
|
||||||
|
|
||||||
|
#ifdef CPPHTTPLIB_SSL_ENABLED
|
||||||
|
TEST(KeepAliveTest, SSLClientDoesNotReuseConnectionWithUnreadData) {
|
||||||
|
expect_no_reuse_with_unread_data(/*use_tls=*/true, /*same_write=*/false);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(KeepAliveTest, SSLClientDoesNotReuseConnectionWithDataPastResponse) {
|
||||||
|
expect_no_reuse_with_unread_data(/*use_tls=*/true, /*same_write=*/true);
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
TEST(KeepAliveTest, Issue1959) {
|
TEST(KeepAliveTest, Issue1959) {
|
||||||
Server svr;
|
Server svr;
|
||||||
svr.set_keep_alive_timeout(5);
|
svr.set_keep_alive_timeout(5);
|
||||||
@@ -24270,6 +24516,45 @@ TEST(OpenStreamPartialWriteTest, BodyIsWrittenWhole) {
|
|||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
TEST(OpenStreamConcurrencyTest, RequestInFlightKeepsItsConnection) {
|
||||||
|
std::promise<void> slow_started;
|
||||||
|
auto slow_started_future = slow_started.get_future();
|
||||||
|
|
||||||
|
Server svr;
|
||||||
|
svr.Get("/slow", [&](const Request &, Response &res) {
|
||||||
|
slow_started.set_value();
|
||||||
|
std::this_thread::sleep_for(std::chrono::milliseconds(200));
|
||||||
|
res.set_content("slow", "text/plain");
|
||||||
|
});
|
||||||
|
svr.Get("/fast", [](const Request &, Response &res) {
|
||||||
|
res.set_content("fast", "text/plain");
|
||||||
|
});
|
||||||
|
|
||||||
|
auto port = svr.bind_to_any_port(HOST);
|
||||||
|
std::thread t([&]() { svr.listen_after_bind(); });
|
||||||
|
auto se = detail::scope_exit([&] {
|
||||||
|
svr.stop();
|
||||||
|
t.join();
|
||||||
|
});
|
||||||
|
svr.wait_until_ready();
|
||||||
|
|
||||||
|
Client cli(HOST, port);
|
||||||
|
|
||||||
|
std::string slow_body;
|
||||||
|
std::thread slow_thread([&] {
|
||||||
|
auto res = cli.Get("/slow");
|
||||||
|
if (res) { slow_body = res->body; }
|
||||||
|
});
|
||||||
|
slow_started_future.wait();
|
||||||
|
|
||||||
|
auto result = stream::Get(cli, "/fast");
|
||||||
|
auto fast_body = result.is_valid() ? result.read_all() : std::string();
|
||||||
|
slow_thread.join();
|
||||||
|
|
||||||
|
EXPECT_EQ("slow", slow_body);
|
||||||
|
EXPECT_EQ("fast", fast_body);
|
||||||
|
}
|
||||||
|
|
||||||
// Serves `response` to the single request `fn` makes with a fresh client.
|
// Serves `response` to the single request `fn` makes with a fresh client.
|
||||||
template <typename Fn>
|
template <typename Fn>
|
||||||
static void with_single_response(const std::string &response, Fn fn) {
|
static void with_single_response(const std::string &response, Fn fn) {
|
||||||
@@ -26467,264 +26752,264 @@ protected:
|
|||||||
};
|
};
|
||||||
|
|
||||||
//==============================================================================
|
//==============================================================================
|
||||||
// SSE Parsing Tests
|
// SSE Parser Tests
|
||||||
//==============================================================================
|
//==============================================================================
|
||||||
|
|
||||||
class SSEParsingTest : public SSEIntegrationTest {
|
struct SSEParseResult {
|
||||||
protected:
|
std::vector<sse::SSEMessage> events;
|
||||||
// Feeds a raw event stream to SSEClient and returns the dispatched messages.
|
std::vector<std::string> ids;
|
||||||
// A trailing sentinel event tells when the whole stream has been parsed.
|
std::vector<int> retries;
|
||||||
std::vector<sse::SSEMessage> parse(const std::string &stream) {
|
bool ok = true;
|
||||||
auto body = stream + "event: end\ndata: end\n\n";
|
std::string trace; // Every handler call in order
|
||||||
server_->Get("/parse", [body](const Request &, Response &res) {
|
|
||||||
res.set_content(body, "text/event-stream");
|
|
||||||
});
|
|
||||||
return collect("/parse");
|
|
||||||
}
|
|
||||||
|
|
||||||
// Runs SSEClient against path until an "end" event arrives and returns the
|
|
||||||
// messages dispatched before it
|
|
||||||
std::vector<sse::SSEMessage> collect(const std::string &path) {
|
|
||||||
Client client(HOST, get_port());
|
|
||||||
sse::SSEClient sse(client, path);
|
|
||||||
std::mutex mutex;
|
|
||||||
std::condition_variable cv;
|
|
||||||
std::vector<sse::SSEMessage> messages;
|
|
||||||
auto done = false;
|
|
||||||
|
|
||||||
sse.on_message([&](const sse::SSEMessage &msg) {
|
|
||||||
std::lock_guard<std::mutex> lock(mutex);
|
|
||||||
// Ignore a replay from a reconnect that races with stop()
|
|
||||||
if (!done) { messages.push_back(msg); }
|
|
||||||
});
|
|
||||||
sse.on_event("end", [&](const sse::SSEMessage &) {
|
|
||||||
std::lock_guard<std::mutex> lock(mutex);
|
|
||||||
done = true;
|
|
||||||
cv.notify_all();
|
|
||||||
});
|
|
||||||
sse.set_reconnect_interval(100);
|
|
||||||
sse.start_async();
|
|
||||||
|
|
||||||
{
|
|
||||||
std::unique_lock<std::mutex> lock(mutex);
|
|
||||||
cv.wait_for(lock, std::chrono::seconds(5), [&] { return done; });
|
|
||||||
}
|
|
||||||
sse.stop();
|
|
||||||
|
|
||||||
EXPECT_TRUE(done);
|
|
||||||
return messages;
|
|
||||||
}
|
|
||||||
};
|
};
|
||||||
|
|
||||||
TEST_F(SSEParsingTest, SingleLineData) {
|
static SSEParseResult
|
||||||
auto msgs = parse("data: hello\n\n");
|
sse_parse(const std::vector<std::string> &chunks,
|
||||||
ASSERT_EQ(msgs.size(), 1u);
|
size_t max_event_length = CPPHTTPLIB_SSE_MAX_EVENT_LENGTH) {
|
||||||
EXPECT_EQ(msgs[0].data, "hello");
|
SSEParseResult r;
|
||||||
EXPECT_EQ(msgs[0].event, "message");
|
detail::SSEParser parser(
|
||||||
|
[&](const sse::SSEMessage &msg) {
|
||||||
|
r.events.push_back(msg);
|
||||||
|
r.trace += "event[" + msg.event + "|" + msg.data + "|" + msg.id + "]";
|
||||||
|
},
|
||||||
|
[&](const std::string &id) {
|
||||||
|
r.ids.push_back(id);
|
||||||
|
r.trace += "id[" + id + "]";
|
||||||
|
},
|
||||||
|
[&](int retry_ms) {
|
||||||
|
r.retries.push_back(retry_ms);
|
||||||
|
r.trace += "retry[" + std::to_string(retry_ms) + "]";
|
||||||
|
},
|
||||||
|
max_event_length);
|
||||||
|
for (const auto &chunk : chunks) {
|
||||||
|
if (!parser.parse(chunk.data(), chunk.size())) {
|
||||||
|
r.ok = false;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return r;
|
||||||
}
|
}
|
||||||
|
|
||||||
TEST_F(SSEParsingTest, MultiLineData) {
|
static SSEParseResult sse_parse(const std::string &stream) {
|
||||||
auto msgs = parse("data: line1\ndata: line2\ndata: line3\n\n");
|
return sse_parse(std::vector<std::string>{stream});
|
||||||
ASSERT_EQ(msgs.size(), 1u);
|
|
||||||
EXPECT_EQ(msgs[0].data, "line1\nline2\nline3");
|
|
||||||
}
|
}
|
||||||
|
|
||||||
TEST_F(SSEParsingTest, CustomEventType) {
|
TEST(SSEParserTest, SingleLineData) {
|
||||||
auto msgs = parse("event: update\ndata: payload\n\n");
|
auto r = sse_parse("data: hello\n\n");
|
||||||
ASSERT_EQ(msgs.size(), 1u);
|
ASSERT_EQ(r.events.size(), 1u);
|
||||||
EXPECT_EQ(msgs[0].event, "update");
|
EXPECT_EQ(r.events[0].data, "hello");
|
||||||
EXPECT_EQ(msgs[0].data, "payload");
|
EXPECT_EQ(r.events[0].event, "message");
|
||||||
}
|
}
|
||||||
|
|
||||||
TEST_F(SSEParsingTest, EventIdHandling) {
|
TEST(SSEParserTest, MultiLineData) {
|
||||||
auto msgs = parse("id: 12345\ndata: test\n\n");
|
auto r = sse_parse("data: line1\ndata: line2\ndata: line3\n\n");
|
||||||
ASSERT_EQ(msgs.size(), 1u);
|
ASSERT_EQ(r.events.size(), 1u);
|
||||||
EXPECT_EQ(msgs[0].id, "12345");
|
EXPECT_EQ(r.events[0].data, "line1\nline2\nline3");
|
||||||
}
|
}
|
||||||
|
|
||||||
TEST_F(SSEParsingTest, EmptyEventId) {
|
TEST(SSEParserTest, CustomEventType) {
|
||||||
auto msgs = parse("id:\ndata: test\n\n");
|
auto r = sse_parse("event: update\ndata: payload\n\n");
|
||||||
ASSERT_EQ(msgs.size(), 1u);
|
ASSERT_EQ(r.events.size(), 1u);
|
||||||
EXPECT_EQ(msgs[0].id, "");
|
EXPECT_EQ(r.events[0].event, "update");
|
||||||
|
EXPECT_EQ(r.events[0].data, "payload");
|
||||||
}
|
}
|
||||||
|
|
||||||
TEST_F(SSEParsingTest, CommentsIgnored) {
|
TEST(SSEParserTest, EventIdHandling) {
|
||||||
auto msgs = parse(": this is a comment\ndata: hello\n\n");
|
auto r = sse_parse("id: 12345\ndata: test\n\n");
|
||||||
ASSERT_EQ(msgs.size(), 1u);
|
ASSERT_EQ(r.events.size(), 1u);
|
||||||
EXPECT_EQ(msgs[0].data, "hello");
|
EXPECT_EQ(r.events[0].id, "12345");
|
||||||
EXPECT_EQ(msgs[0].event, "message");
|
EXPECT_EQ(r.ids, std::vector<std::string>{"12345"});
|
||||||
}
|
}
|
||||||
|
|
||||||
TEST_F(SSEParsingTest, ColonInValue) {
|
TEST(SSEParserTest, EmptyEventId) {
|
||||||
auto msgs = parse("data: hello:world:test\n\n");
|
auto r = sse_parse("id:\ndata: test\n\n");
|
||||||
ASSERT_EQ(msgs.size(), 1u);
|
ASSERT_EQ(r.events.size(), 1u);
|
||||||
EXPECT_EQ(msgs[0].data, "hello:world:test");
|
EXPECT_EQ(r.events[0].id, "");
|
||||||
|
EXPECT_EQ(r.ids, std::vector<std::string>{""});
|
||||||
}
|
}
|
||||||
|
|
||||||
TEST_F(SSEParsingTest, FieldNameOnly) {
|
TEST(SSEParserTest, CommentsIgnored) {
|
||||||
|
auto r = sse_parse(": this is a comment\ndata: hello\n\n");
|
||||||
|
ASSERT_EQ(r.events.size(), 1u);
|
||||||
|
EXPECT_EQ(r.events[0].data, "hello");
|
||||||
|
EXPECT_EQ(r.events[0].event, "message");
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(SSEParserTest, ColonInValue) {
|
||||||
|
auto r = sse_parse("data: hello:world:test\n\n");
|
||||||
|
ASSERT_EQ(r.events.size(), 1u);
|
||||||
|
EXPECT_EQ(r.events[0].data, "hello:world:test");
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(SSEParserTest, FieldNameOnly) {
|
||||||
// A line without a colon is a field name with an empty value
|
// A line without a colon is a field name with an empty value
|
||||||
auto msgs = parse("data\n\n");
|
auto r = sse_parse("data\n\n");
|
||||||
ASSERT_EQ(msgs.size(), 1u);
|
ASSERT_EQ(r.events.size(), 1u);
|
||||||
EXPECT_EQ(msgs[0].data, "");
|
EXPECT_EQ(r.events[0].data, "");
|
||||||
}
|
}
|
||||||
|
|
||||||
TEST_F(SSEParsingTest, TrailingCarriageReturn) {
|
TEST(SSEParserTest, TrailingCarriageReturn) {
|
||||||
auto msgs = parse("event: update\r\ndata: hello\r\n\r\n");
|
auto r = sse_parse("event: update\r\ndata: hello\r\n\r\n");
|
||||||
ASSERT_EQ(msgs.size(), 1u);
|
ASSERT_EQ(r.events.size(), 1u);
|
||||||
EXPECT_EQ(msgs[0].event, "update");
|
EXPECT_EQ(r.events[0].event, "update");
|
||||||
EXPECT_EQ(msgs[0].data, "hello");
|
EXPECT_EQ(r.events[0].data, "hello");
|
||||||
}
|
}
|
||||||
|
|
||||||
TEST_F(SSEParsingTest, FieldNameOnlyWithCarriageReturn) {
|
TEST(SSEParserTest, FieldNameOnlyWithCarriageReturn) {
|
||||||
auto msgs = parse("data\r\n\r\n");
|
auto r = sse_parse("data\r\n\r\n");
|
||||||
ASSERT_EQ(msgs.size(), 1u);
|
ASSERT_EQ(r.events.size(), 1u);
|
||||||
EXPECT_EQ(msgs[0].data, "");
|
EXPECT_EQ(r.events[0].data, "");
|
||||||
}
|
}
|
||||||
|
|
||||||
TEST_F(SSEParsingTest, CarriageReturnLineEnding) {
|
TEST(SSEParserTest, CarriageReturnLineEnding) {
|
||||||
auto msgs = parse("event: update\rdata: hello\r\r");
|
auto r = sse_parse("event: update\rdata: hello\r\r");
|
||||||
ASSERT_EQ(msgs.size(), 1u);
|
ASSERT_EQ(r.events.size(), 1u);
|
||||||
EXPECT_EQ(msgs[0].event, "update");
|
EXPECT_EQ(r.events[0].event, "update");
|
||||||
EXPECT_EQ(msgs[0].data, "hello");
|
EXPECT_EQ(r.events[0].data, "hello");
|
||||||
}
|
}
|
||||||
|
|
||||||
TEST_F(SSEParsingTest, LineEndingSplitAcrossChunks) {
|
TEST(SSEParserTest, LineEndingSplitAcrossChunks) {
|
||||||
// Chunk boundaries fall inside every \r\n and right before the first one
|
// Chunk boundaries fall inside every \r\n and right before the first one
|
||||||
std::vector<std::string> chunks = {"event: update", "\r", "\ndata: hello\r",
|
auto r = sse_parse(std::vector<std::string>{"event: update", "\r",
|
||||||
"\n\r", "\nevent: end\ndata: end\n\n"};
|
"\ndata: hello\r", "\n\r", "\n"});
|
||||||
server_->Get("/split", [chunks](const Request &, Response &res) {
|
ASSERT_EQ(r.events.size(), 1u);
|
||||||
auto i = std::make_shared<size_t>(0);
|
EXPECT_EQ(r.events[0].event, "update");
|
||||||
res.set_chunked_content_provider(
|
EXPECT_EQ(r.events[0].data, "hello");
|
||||||
"text/event-stream", [chunks, i](size_t /*offset*/, DataSink &sink) {
|
|
||||||
if (*i == chunks.size()) {
|
|
||||||
sink.done();
|
|
||||||
} else {
|
|
||||||
sink.write(chunks[*i].data(), chunks[*i].size());
|
|
||||||
(*i)++;
|
|
||||||
}
|
|
||||||
return true;
|
|
||||||
});
|
|
||||||
});
|
|
||||||
|
|
||||||
auto msgs = collect("/split");
|
|
||||||
ASSERT_EQ(msgs.size(), 1u);
|
|
||||||
EXPECT_EQ(msgs[0].event, "update");
|
|
||||||
EXPECT_EQ(msgs[0].data, "hello");
|
|
||||||
}
|
}
|
||||||
|
|
||||||
TEST_F(SSEParsingTest, LeadingByteOrderMarkIgnored) {
|
TEST(SSEParserTest, LeadingByteOrderMarkIgnored) {
|
||||||
// Only a BOM at the start of the stream is ignored
|
// Only a BOM at the start of the stream is ignored
|
||||||
auto msgs = parse("\xEF\xBB\xBF"
|
auto r = sse_parse("\xEF\xBB\xBF"
|
||||||
"data: first\n\n"
|
"data: first\n\n"
|
||||||
"\xEF\xBB\xBF"
|
"\xEF\xBB\xBF"
|
||||||
"data: second\n\n");
|
"data: second\n\n");
|
||||||
ASSERT_EQ(msgs.size(), 1u);
|
ASSERT_EQ(r.events.size(), 1u);
|
||||||
EXPECT_EQ(msgs[0].data, "first");
|
EXPECT_EQ(r.events[0].data, "first");
|
||||||
}
|
}
|
||||||
|
|
||||||
TEST_F(SSEParsingTest, UnknownFieldsIgnored) {
|
TEST(SSEParserTest, UnknownFieldsIgnored) {
|
||||||
auto msgs = parse("unknown: value\ndata: hello\n\n");
|
auto r = sse_parse("unknown: value\ndata: hello\n\n");
|
||||||
ASSERT_EQ(msgs.size(), 1u);
|
ASSERT_EQ(r.events.size(), 1u);
|
||||||
EXPECT_EQ(msgs[0].data, "hello");
|
EXPECT_EQ(r.events[0].data, "hello");
|
||||||
EXPECT_EQ(msgs[0].event, "message");
|
EXPECT_EQ(r.events[0].event, "message");
|
||||||
}
|
}
|
||||||
|
|
||||||
TEST_F(SSEParsingTest, SpaceAfterColonOptional) {
|
TEST(SSEParserTest, SpaceAfterColonOptional) {
|
||||||
auto msgs = parse("data: hello\n\ndata:hello\n\n");
|
auto r = sse_parse("data: hello\n\ndata:hello\n\n");
|
||||||
ASSERT_EQ(msgs.size(), 2u);
|
ASSERT_EQ(r.events.size(), 2u);
|
||||||
EXPECT_EQ(msgs[0].data, "hello");
|
EXPECT_EQ(r.events[0].data, "hello");
|
||||||
EXPECT_EQ(msgs[1].data, "hello");
|
EXPECT_EQ(r.events[1].data, "hello");
|
||||||
}
|
}
|
||||||
|
|
||||||
TEST_F(SSEParsingTest, EventWithoutDataResetsEventType) {
|
TEST(SSEParserTest, EventWithoutDataResetsEventType) {
|
||||||
// An event without data is not dispatched, and its type must not leak
|
// An event without data is not dispatched, and its type must not leak
|
||||||
// into the next event
|
// into the next event
|
||||||
auto msgs = parse("event: update\n\ndata: hello\n\n");
|
auto r = sse_parse("event: update\n\ndata: hello\n\n");
|
||||||
ASSERT_EQ(msgs.size(), 1u);
|
ASSERT_EQ(r.events.size(), 1u);
|
||||||
EXPECT_EQ(msgs[0].event, "message");
|
EXPECT_EQ(r.events[0].event, "message");
|
||||||
EXPECT_EQ(msgs[0].data, "hello");
|
EXPECT_EQ(r.events[0].data, "hello");
|
||||||
}
|
}
|
||||||
|
|
||||||
TEST_F(SSEParsingTest, EmptyEventTypeIsMessage) {
|
TEST(SSEParserTest, EmptyEventTypeIsMessage) {
|
||||||
// Also when the empty field replaces an earlier type
|
// Also when the empty field replaces an earlier type
|
||||||
auto msgs = parse("event:\ndata: a\n\nevent: update\nevent:\ndata: b\n\n");
|
auto r = sse_parse("event:\ndata: a\n\nevent: update\nevent:\ndata: b\n\n");
|
||||||
ASSERT_EQ(msgs.size(), 2u);
|
ASSERT_EQ(r.events.size(), 2u);
|
||||||
EXPECT_EQ(msgs[0].event, "message");
|
EXPECT_EQ(r.events[0].event, "message");
|
||||||
EXPECT_EQ(msgs[1].event, "message");
|
EXPECT_EQ(r.events[1].event, "message");
|
||||||
}
|
}
|
||||||
|
|
||||||
TEST_F(SSEParsingTest, EventWithoutDataUpdatesLastEventId) {
|
TEST(SSEParserTest, EventWithoutDataReportsId) {
|
||||||
// The first connection sends only an id; the second echoes back the
|
auto r = sse_parse("id: 42\n\n");
|
||||||
// Last-Event-ID it was reconnected with
|
EXPECT_TRUE(r.events.empty());
|
||||||
std::atomic<int> connection_count{0};
|
EXPECT_EQ(r.ids, std::vector<std::string>{"42"});
|
||||||
server_->Get("/id-only", [&](const Request &req, Response &res) {
|
|
||||||
if (connection_count++ == 0) {
|
|
||||||
res.set_content("id: 42\n\n", "text/event-stream");
|
|
||||||
} else {
|
|
||||||
res.set_content("data: " + req.get_header_value("Last-Event-ID") +
|
|
||||||
"\n\nevent: end\ndata: end\n\n",
|
|
||||||
"text/event-stream");
|
|
||||||
}
|
|
||||||
});
|
|
||||||
|
|
||||||
auto msgs = collect("/id-only");
|
|
||||||
ASSERT_EQ(msgs.size(), 1u);
|
|
||||||
EXPECT_EQ(msgs[0].data, "42");
|
|
||||||
}
|
}
|
||||||
|
|
||||||
TEST_F(SSEParsingTest, EmptyEventIdClearsLastEventId) {
|
TEST(SSEParserTest, EmptyEventIdClearsId) {
|
||||||
// The first connection sets an id and then clears it with an empty one; the
|
auto r = sse_parse("id: 1\ndata: first\n\nid:\ndata: second\n\n");
|
||||||
// second reports whether it was reconnected with a Last-Event-ID
|
ASSERT_EQ(r.events.size(), 2u);
|
||||||
std::atomic<int> connection_count{0};
|
EXPECT_EQ(r.events[0].id, "1");
|
||||||
server_->Get("/id-clear", [&](const Request &req, Response &res) {
|
EXPECT_EQ(r.events[1].id, "");
|
||||||
if (connection_count++ == 0) {
|
EXPECT_EQ(r.ids, (std::vector<std::string>{"1", ""}));
|
||||||
res.set_content("id: 1\ndata: first\n\nid:\ndata: second\n\n",
|
|
||||||
"text/event-stream");
|
|
||||||
} else {
|
|
||||||
res.set_content(
|
|
||||||
std::string("data: ") +
|
|
||||||
(req.has_header("Last-Event-ID") ? "sent" : "not sent") +
|
|
||||||
"\n\nevent: end\ndata: end\n\n",
|
|
||||||
"text/event-stream");
|
|
||||||
}
|
|
||||||
});
|
|
||||||
|
|
||||||
auto msgs = collect("/id-clear");
|
|
||||||
ASSERT_EQ(msgs.size(), 3u);
|
|
||||||
EXPECT_EQ(msgs[0].id, "1");
|
|
||||||
EXPECT_EQ(msgs[1].id, "");
|
|
||||||
EXPECT_EQ(msgs[2].data, "not sent");
|
|
||||||
}
|
}
|
||||||
|
|
||||||
TEST_F(SSEParsingTest, UnsendableEventIdKeepsLastEventId) {
|
TEST(SSEParserTest, UnsendableEventIdIgnored) {
|
||||||
// The first connection sets an id and then sends ids that cannot be carried
|
// Ids that cannot be carried in a Last-Event-ID header
|
||||||
// in a header; the second echoes back the Last-Event-ID it was reconnected
|
auto r = sse_parse(std::string("id: 42\n\nid: a") + '\0' +
|
||||||
// with
|
"b\n\nid: \x01\n\nid: 7\n\nid: 7 \n\n");
|
||||||
std::atomic<int> connection_count{0};
|
EXPECT_EQ(r.ids, std::vector<std::string>{"42"});
|
||||||
server_->Get("/id-unsendable", [&](const Request &req, Response &res) {
|
|
||||||
if (connection_count++ == 0) {
|
|
||||||
res.set_content(std::string("id: 42\n\nid: a") + '\0' +
|
|
||||||
"b\n\nid: \x01\n\nid: 7\n\nid: 7 \n\n",
|
|
||||||
"text/event-stream");
|
|
||||||
} else {
|
|
||||||
res.set_content("data: " + req.get_header_value("Last-Event-ID") +
|
|
||||||
"\n\nevent: end\ndata: end\n\n",
|
|
||||||
"text/event-stream");
|
|
||||||
}
|
|
||||||
});
|
|
||||||
|
|
||||||
auto msgs = collect("/id-unsendable");
|
|
||||||
ASSERT_EQ(msgs.size(), 1u);
|
|
||||||
EXPECT_EQ(msgs[0].data, "42");
|
|
||||||
}
|
}
|
||||||
|
|
||||||
TEST_F(SSEParsingTest, CompleteEventParsing) {
|
TEST(SSEParserTest, RetryDigitsOnly) {
|
||||||
auto msgs = parse("event: notification\nid: evt-42\n"
|
auto r = sse_parse("retry: 1000\n");
|
||||||
|
EXPECT_EQ(r.retries, std::vector<int>{1000});
|
||||||
|
|
||||||
|
// A value that is not all ASCII digits, or does not fit, is ignored
|
||||||
|
r = sse_parse("retry: -1\nretry: 1.5\nretry:\nretry: 99999999999\n");
|
||||||
|
EXPECT_TRUE(r.retries.empty());
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(SSEParserTest, CompleteEventParsing) {
|
||||||
|
auto r = sse_parse("event: notification\nid: evt-42\n"
|
||||||
"data: {\"type\":\"alert\"}\nretry: 1000\n\n");
|
"data: {\"type\":\"alert\"}\nretry: 1000\n\n");
|
||||||
ASSERT_EQ(msgs.size(), 1u);
|
ASSERT_EQ(r.events.size(), 1u);
|
||||||
EXPECT_EQ(msgs[0].event, "notification");
|
EXPECT_EQ(r.events[0].event, "notification");
|
||||||
EXPECT_EQ(msgs[0].id, "evt-42");
|
EXPECT_EQ(r.events[0].id, "evt-42");
|
||||||
EXPECT_EQ(msgs[0].data, "{\"type\":\"alert\"}");
|
EXPECT_EQ(r.events[0].data, "{\"type\":\"alert\"}");
|
||||||
|
EXPECT_EQ(r.retries, std::vector<int>{1000});
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(SSEParserTest, IncompleteEventNotReported) {
|
||||||
|
// An event still waiting for its blank line when the stream ends is
|
||||||
|
// discarded per the SSE spec
|
||||||
|
auto r = sse_parse("id: 1\ndata: x\n");
|
||||||
|
EXPECT_TRUE(r.events.empty());
|
||||||
|
EXPECT_TRUE(r.ids.empty());
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(SSEParserTest, SameResultAtEveryChunkBoundary) {
|
||||||
|
const std::vector<std::string> streams = {
|
||||||
|
"\xEF\xBB\xBF"
|
||||||
|
"data: bom\r\n\r\n",
|
||||||
|
"event: a\r\ndata: 1\r\nid: x\r\n\r\ndata: 2\rretry: 7\r\r",
|
||||||
|
": comment\ndata\nid:\n\nid: y\n\ndata: tail\r\n\r\n",
|
||||||
|
};
|
||||||
|
for (const auto &stream : streams) {
|
||||||
|
auto expected = sse_parse(stream).trace;
|
||||||
|
ASSERT_FALSE(expected.empty());
|
||||||
|
|
||||||
|
for (size_t i = 0; i <= stream.size(); i++) {
|
||||||
|
auto r = sse_parse(
|
||||||
|
std::vector<std::string>{stream.substr(0, i), stream.substr(i)});
|
||||||
|
EXPECT_EQ(r.trace, expected) << "split at " << i;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::vector<std::string> bytes;
|
||||||
|
for (auto c : stream) {
|
||||||
|
bytes.emplace_back(1, c);
|
||||||
|
}
|
||||||
|
EXPECT_EQ(sse_parse(bytes).trace, expected) << "byte by byte";
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(SSEParserTest, MaxEventLength) {
|
||||||
|
// A line still waiting for its end
|
||||||
|
EXPECT_TRUE(sse_parse(std::vector<std::string>{"data: 12"}, 8).ok);
|
||||||
|
EXPECT_FALSE(sse_parse(std::vector<std::string>{"data: 123"}, 8).ok);
|
||||||
|
|
||||||
|
// Data accumulated over the lines of one event
|
||||||
|
EXPECT_TRUE(
|
||||||
|
sse_parse(std::vector<std::string>{"data: 1234\ndata: 567\n"}, 8).ok);
|
||||||
|
EXPECT_FALSE(
|
||||||
|
sse_parse(std::vector<std::string>{"data: 1234\ndata: 5678\n"}, 8).ok);
|
||||||
|
|
||||||
|
// 0 means no limit
|
||||||
|
EXPECT_TRUE(sse_parse(std::vector<std::string>{"data: 123"}, 0).ok);
|
||||||
|
|
||||||
|
// Events completed in the same chunk are still reported
|
||||||
|
auto r = sse_parse(std::vector<std::string>{"data: a\n\ndata: 123456789"}, 8);
|
||||||
|
EXPECT_FALSE(r.ok);
|
||||||
|
ASSERT_EQ(r.events.size(), 1u);
|
||||||
|
EXPECT_EQ(r.events[0].data, "a");
|
||||||
}
|
}
|
||||||
|
|
||||||
TEST(SSEMessageTest, Clear) {
|
TEST(SSEMessageTest, Clear) {
|
||||||
@@ -27349,35 +27634,6 @@ TEST_F(SSEIntegrationTest, StreamEndingAtConnectionCloseIsNotAnError) {
|
|||||||
EXPECT_EQ(0, error_count.load());
|
EXPECT_EQ(0, error_count.load());
|
||||||
}
|
}
|
||||||
|
|
||||||
// Test: A retry field that is not all ASCII digits is ignored
|
|
||||||
TEST_F(SSEIntegrationTest, NonDigitRetryFieldIgnored) {
|
|
||||||
std::atomic<int> connection_count{0};
|
|
||||||
|
|
||||||
server_->Get("/bad-retry",
|
|
||||||
[&connection_count](const Request &, Response &res) {
|
|
||||||
connection_count.fetch_add(1);
|
|
||||||
res.set_chunked_content_provider(
|
|
||||||
"text/event-stream", [](size_t offset, DataSink &sink) {
|
|
||||||
if (offset == 0) {
|
|
||||||
std::string event = "retry: -1\ndata: hello\n\n";
|
|
||||||
sink.write(event.data(), event.size());
|
|
||||||
}
|
|
||||||
return false;
|
|
||||||
});
|
|
||||||
});
|
|
||||||
|
|
||||||
Client client("localhost", get_port());
|
|
||||||
sse::SSEClient sse(client, "/bad-retry");
|
|
||||||
|
|
||||||
sse.set_reconnect_interval(10000);
|
|
||||||
sse.start_async();
|
|
||||||
|
|
||||||
std::this_thread::sleep_for(std::chrono::milliseconds(500));
|
|
||||||
sse.stop();
|
|
||||||
|
|
||||||
EXPECT_EQ(connection_count.load(), 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Test: A retry field of all ASCII digits sets the reconnection time
|
// Test: A retry field of all ASCII digits sets the reconnection time
|
||||||
TEST_F(SSEIntegrationTest, DigitRetryFieldApplied) {
|
TEST_F(SSEIntegrationTest, DigitRetryFieldApplied) {
|
||||||
std::mutex mutex;
|
std::mutex mutex;
|
||||||
@@ -30664,6 +30920,49 @@ TEST(SymlinkTest, SymlinkEscapeFromBaseDirectory) {
|
|||||||
ASSERT_TRUE(res) << "Error: " << to_string(res.error());
|
ASSERT_TRUE(res) << "Error: " << to_string(res.error());
|
||||||
EXPECT_EQ(StatusCode::Forbidden_403, res->status);
|
EXPECT_EQ(StatusCode::Forbidden_403, res->status);
|
||||||
}
|
}
|
||||||
|
#else
|
||||||
|
TEST(SymlinkTest, JunctionEscapeFromBaseDirectory) {
|
||||||
|
auto secret_dir = std::string("junction_test_secret");
|
||||||
|
auto served_dir = std::string("junction_test_served");
|
||||||
|
auto secret_file = secret_dir + "\\secret.txt";
|
||||||
|
auto junction_path = served_dir + "\\escape";
|
||||||
|
|
||||||
|
::CreateDirectoryA(secret_dir.c_str(), nullptr);
|
||||||
|
::CreateDirectoryA(served_dir.c_str(), nullptr);
|
||||||
|
|
||||||
|
{
|
||||||
|
std::ofstream ofs(secret_file);
|
||||||
|
ofs << "SECRET_DATA";
|
||||||
|
}
|
||||||
|
|
||||||
|
// A junction needs no privilege to create, unlike a symlink
|
||||||
|
auto cmd = "mklink /J " + junction_path + " " + secret_dir + " >nul";
|
||||||
|
ASSERT_EQ(0, std::system(cmd.c_str()));
|
||||||
|
|
||||||
|
auto se = detail::scope_exit([&] {
|
||||||
|
::RemoveDirectoryA(junction_path.c_str());
|
||||||
|
std::remove(secret_file.c_str());
|
||||||
|
::RemoveDirectoryA(served_dir.c_str());
|
||||||
|
::RemoveDirectoryA(secret_dir.c_str());
|
||||||
|
});
|
||||||
|
|
||||||
|
Server svr;
|
||||||
|
svr.set_mount_point("/", served_dir);
|
||||||
|
|
||||||
|
auto listen_thread = std::thread([&svr]() { svr.listen("localhost", PORT); });
|
||||||
|
auto se2 = detail::scope_exit([&] {
|
||||||
|
svr.stop();
|
||||||
|
listen_thread.join();
|
||||||
|
});
|
||||||
|
svr.wait_until_ready();
|
||||||
|
|
||||||
|
Client cli("localhost", PORT);
|
||||||
|
|
||||||
|
// Junction pointing outside base dir should be blocked
|
||||||
|
auto res = cli.Get("/escape/secret.txt");
|
||||||
|
ASSERT_TRUE(res) << "Error: " << to_string(res.error());
|
||||||
|
EXPECT_EQ(StatusCode::Forbidden_403, res->status);
|
||||||
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
// Sends `outer_head` (with every "{len}" replaced by the length of an embedded
|
// Sends `outer_head` (with every "{len}" replaced by the length of an embedded
|
||||||
@@ -32355,6 +32654,40 @@ TEST(ProxyTunnelTest, RedirectKeepsTunnelHostnameAddrMap) {
|
|||||||
EXPECT_NE(std::string::npos,
|
EXPECT_NE(std::string::npos,
|
||||||
connect_req.find("\r\nHost: " + target + "\r\n"));
|
connect_req.find("\r\nHost: " + target + "\r\n"));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// A failed handshake inside the tunnel must not leave the tunnel for reuse
|
||||||
|
TEST(ProxyTunnelTest, FailedHandshakeClosesTunnel) {
|
||||||
|
std::atomic<int> origin_hits{0};
|
||||||
|
proxy_tunnel_test::ScopedSSLServer origin;
|
||||||
|
origin.svr().Get(".*", [&](const Request &, Response &res) {
|
||||||
|
origin_hits++;
|
||||||
|
res.set_content("ok", "text/plain");
|
||||||
|
});
|
||||||
|
origin.listen();
|
||||||
|
|
||||||
|
proxy_tunnel_test::ScopedConnectProxy proxy(origin.port());
|
||||||
|
ASSERT_NE(0, proxy.port());
|
||||||
|
|
||||||
|
SSLClient cli("127.0.0.1", origin.port());
|
||||||
|
cli.enable_server_certificate_verification(false);
|
||||||
|
cli.set_proxy("127.0.0.1", proxy.port());
|
||||||
|
cli.set_keep_alive(true);
|
||||||
|
cli.set_session_verifier(
|
||||||
|
[](tls::session_t) { return SSLVerifierResponse::CertificateRejected; });
|
||||||
|
|
||||||
|
auto res = cli.Get("/x");
|
||||||
|
EXPECT_FALSE(res);
|
||||||
|
ASSERT_FALSE(cli.is_socket_open());
|
||||||
|
|
||||||
|
res = cli.Get("/x");
|
||||||
|
EXPECT_FALSE(res);
|
||||||
|
EXPECT_EQ(2, proxy.connect_hits());
|
||||||
|
|
||||||
|
auto handle = cli.open_stream("GET", "/x");
|
||||||
|
EXPECT_FALSE(handle.is_valid());
|
||||||
|
EXPECT_EQ(3, proxy.connect_hits());
|
||||||
|
EXPECT_EQ(0, origin_hits.load());
|
||||||
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
namespace proxy_tunnel_test {
|
namespace proxy_tunnel_test {
|
||||||
|
|||||||
@@ -1,10 +1,10 @@
|
|||||||
// Standalone test for WebSocket automatic heartbeat.
|
// Standalone test for WebSocket heartbeat and close() timing, compiled with
|
||||||
// Compiled with a 1-second ping interval so we can verify heartbeat behavior
|
// short intervals and timeouts so the tests don't wait for the defaults.
|
||||||
// without waiting 30 seconds.
|
|
||||||
|
|
||||||
#define CPPHTTPLIB_WEBSOCKET_PING_INTERVAL_SECOND 1
|
#define CPPHTTPLIB_WEBSOCKET_PING_INTERVAL_SECOND 1
|
||||||
#define CPPHTTPLIB_WEBSOCKET_CLIENT_READ_TIMEOUT_SECOND 3
|
#define CPPHTTPLIB_WEBSOCKET_CLIENT_READ_TIMEOUT_SECOND 3
|
||||||
#define CPPHTTPLIB_WEBSOCKET_SERVER_READ_TIMEOUT_SECOND 3
|
#define CPPHTTPLIB_WEBSOCKET_SERVER_READ_TIMEOUT_SECOND 3
|
||||||
|
#define CPPHTTPLIB_WEBSOCKET_CLOSE_TIMEOUT_SECOND 1
|
||||||
#include <httplib.h>
|
#include <httplib.h>
|
||||||
|
|
||||||
#include "gtest/gtest.h"
|
#include "gtest/gtest.h"
|
||||||
@@ -289,3 +289,139 @@ TEST_F(WebSocketHeartbeatTest, MultipleHeartbeatCycles) {
|
|||||||
|
|
||||||
client.close();
|
client.close();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// A raw client never answers the server's close() and sends `bytes`, `chunk`
|
||||||
|
// bytes at a time `gap` apart; close() must still return at its 1 s timeout.
|
||||||
|
static void expect_close_bounded(bool use_tls, const std::string &bytes,
|
||||||
|
size_t chunk, std::chrono::milliseconds gap) {
|
||||||
|
std::unique_ptr<Server> svr;
|
||||||
|
#ifdef CPPHTTPLIB_SSL_ENABLED
|
||||||
|
if (use_tls) { svr.reset(new SSLServer("cert.pem", "key.pem")); }
|
||||||
|
#endif
|
||||||
|
if (!svr) { svr.reset(new Server); }
|
||||||
|
svr->set_websocket_ping_interval(0);
|
||||||
|
|
||||||
|
std::atomic<bool> upgraded{false};
|
||||||
|
std::atomic<bool> closed{false};
|
||||||
|
std::chrono::steady_clock::duration close_took{};
|
||||||
|
svr->WebSocket("/ws", [&](const Request &, ws::WebSocket &ws) {
|
||||||
|
while (!upgraded) {
|
||||||
|
std::this_thread::sleep_for(std::chrono::milliseconds(1));
|
||||||
|
}
|
||||||
|
auto start = std::chrono::steady_clock::now();
|
||||||
|
ws.close();
|
||||||
|
close_took = std::chrono::steady_clock::now() - start;
|
||||||
|
closed = true;
|
||||||
|
});
|
||||||
|
auto port = svr->bind_to_any_port("127.0.0.1");
|
||||||
|
ASSERT_GT(port, 0);
|
||||||
|
std::thread t([&] { svr->listen_after_bind(); });
|
||||||
|
auto se = detail::scope_exit([&] {
|
||||||
|
upgraded = true; // Releases the handler when an assertion bails out early
|
||||||
|
svr->stop();
|
||||||
|
t.join();
|
||||||
|
});
|
||||||
|
svr->wait_until_ready();
|
||||||
|
|
||||||
|
auto sock = ::socket(AF_INET, SOCK_STREAM, 0);
|
||||||
|
ASSERT_NE(INVALID_SOCKET, sock);
|
||||||
|
auto sock_se = detail::scope_exit([&] { detail::close_socket(sock); });
|
||||||
|
sockaddr_in addr{};
|
||||||
|
addr.sin_family = AF_INET;
|
||||||
|
addr.sin_port = htons(static_cast<uint16_t>(port));
|
||||||
|
::inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr);
|
||||||
|
ASSERT_EQ(0,
|
||||||
|
::connect(sock, reinterpret_cast<sockaddr *>(&addr), sizeof(addr)));
|
||||||
|
|
||||||
|
std::unique_ptr<Stream> strm;
|
||||||
|
#ifdef CPPHTTPLIB_SSL_ENABLED
|
||||||
|
tls::ctx_t ctx = nullptr;
|
||||||
|
tls::session_t session = nullptr;
|
||||||
|
auto tls_se = detail::scope_exit([&] {
|
||||||
|
if (session) { tls::free_session(session); }
|
||||||
|
if (ctx) { tls::free_context(ctx); }
|
||||||
|
});
|
||||||
|
if (use_tls) {
|
||||||
|
ctx = tls::create_client_context();
|
||||||
|
tls::set_verify_client(ctx, false); // The test certificate is self-signed
|
||||||
|
session = tls::create_session(ctx, sock);
|
||||||
|
ASSERT_TRUE(tls::connect_nonblocking(session, sock, 5, 0, nullptr));
|
||||||
|
strm.reset(new detail::SSLSocketStream(sock, session, 5, 0, 5, 0));
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
if (!strm) { strm.reset(new detail::SocketStream(sock, 5, 0, 5, 0)); }
|
||||||
|
|
||||||
|
const std::string upgrade = "GET /ws HTTP/1.1\r\n"
|
||||||
|
"Host: 127.0.0.1\r\n"
|
||||||
|
"Upgrade: websocket\r\n"
|
||||||
|
"Connection: Upgrade\r\n"
|
||||||
|
"Sec-WebSocket-Key: AAAAAAAAAAAAAAAAAAAAAA==\r\n"
|
||||||
|
"Sec-WebSocket-Version: 13\r\n"
|
||||||
|
"\r\n";
|
||||||
|
ASSERT_EQ(static_cast<ssize_t>(upgrade.size()),
|
||||||
|
strm->write(upgrade.data(), upgrade.size()));
|
||||||
|
std::string response;
|
||||||
|
char c;
|
||||||
|
while (response.find("\r\n\r\n") == std::string::npos &&
|
||||||
|
strm->read(&c, 1) == 1) {
|
||||||
|
response += c;
|
||||||
|
}
|
||||||
|
ASSERT_NE(std::string::npos, response.find(" 101 "));
|
||||||
|
upgraded = true;
|
||||||
|
|
||||||
|
// Without the bound, close() would wait as long as the client sends
|
||||||
|
auto give_up = std::chrono::steady_clock::now() + std::chrono::seconds(4);
|
||||||
|
while (!closed && std::chrono::steady_clock::now() < give_up) {
|
||||||
|
for (size_t off = 0; off < bytes.size() && !closed;) {
|
||||||
|
auto n = strm->write(bytes.data() + off,
|
||||||
|
(std::min)(chunk, bytes.size() - off));
|
||||||
|
if (n <= 0) { break; }
|
||||||
|
off += static_cast<size_t>(n);
|
||||||
|
auto next = std::chrono::steady_clock::now() + gap;
|
||||||
|
while (!closed && std::chrono::steady_clock::now() < next) {
|
||||||
|
std::this_thread::sleep_for(std::chrono::milliseconds(10));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
while (!closed) {
|
||||||
|
std::this_thread::sleep_for(std::chrono::milliseconds(10));
|
||||||
|
}
|
||||||
|
EXPECT_LT(close_took, std::chrono::milliseconds(2500));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Empty masked Ping frames, enough to keep the socket full
|
||||||
|
static std::string ping_flood() {
|
||||||
|
const std::string ping("\x89\x80\0\0\0\0", 6);
|
||||||
|
std::string bytes;
|
||||||
|
while (bytes.size() < 64 * 1024) {
|
||||||
|
bytes += ping;
|
||||||
|
}
|
||||||
|
return bytes;
|
||||||
|
}
|
||||||
|
|
||||||
|
// A masked 20-byte Ping; sent a byte at a time, it outlasts the close timeout
|
||||||
|
static std::string ping_with_payload() {
|
||||||
|
return std::string("\x89\x8e\0\0\0\0", 6) + std::string(14, 'x');
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(WebSocketCloseTest, BoundedAgainstPeerThatKeepsSending) {
|
||||||
|
expect_close_bounded(/*use_tls=*/false, ping_flood(), ping_flood().size(),
|
||||||
|
std::chrono::milliseconds(0));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(WebSocketCloseTest, BoundedAgainstPeerThatTricklesAFrame) {
|
||||||
|
expect_close_bounded(/*use_tls=*/false, ping_with_payload(), 1,
|
||||||
|
std::chrono::milliseconds(300));
|
||||||
|
}
|
||||||
|
|
||||||
|
#ifdef CPPHTTPLIB_SSL_ENABLED
|
||||||
|
TEST(WebSocketCloseTest, SSLBoundedAgainstPeerThatKeepsSending) {
|
||||||
|
expect_close_bounded(/*use_tls=*/true, ping_flood(), ping_flood().size(),
|
||||||
|
std::chrono::milliseconds(0));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST(WebSocketCloseTest, SSLBoundedAgainstPeerThatTricklesAFrame) {
|
||||||
|
expect_close_bounded(/*use_tls=*/true, ping_with_payload(), 1,
|
||||||
|
std::chrono::milliseconds(300));
|
||||||
|
}
|
||||||
|
#endif
|
||||||
Reference in new issue
Block a user