Skip to content

LLM inference in C/C++

C++ ggml

vendor : update cpp-httplib to 0.54.0 (#27919)

Alessandro de Oliveira Faria (A.K.A.CABELO)dc7aecf70d4d
diff --git a/scripts/sync_vendor.py b/scripts/sync_vendor.py
index 98b9ddc8ef..0170b5b168 100755
--- a/scripts/sync_vendor.py
+++ b/scripts/sync_vendor.py
@@ -5,7 +5,7 @@ import os
import sys
import subprocess
-HTTPLIB_VERSION = "refs/tags/v0.53.1"
+HTTPLIB_VERSION = "refs/tags/v0.54.1"
# used by examples/gguf-hash, these repos have no release tag, so we pin a commit
XXHASH_COMMIT = "9f465f1ea932d6ad9a26cd77496311ffa544cd68"
diff --git a/vendor/cpp-httplib/httplib.cpp b/vendor/cpp-httplib/httplib.cpp
index 81cdcfe3a0..7fd10b3939 100644
--- a/vendor/cpp-httplib/httplib.cpp
+++ b/vendor/cpp-httplib/httplib.cpp
@@ -517,7 +517,8 @@ std::string from_i_to_hex(size_t n) {
return ret;
}
-std::string compute_etag(const FileStat &fs) {
+std::string compute_etag(const FileStat &fs,
+ const std::string &suffix = std::string()) {
if (!fs.is_file()) { return std::string(); }
// If mtime cannot be determined (negative value indicates an error
@@ -531,7 +532,7 @@ std::string compute_etag(const FileStat &fs) {
auto size = fs.size();
return std::string("W/\"") + from_i_to_hex(mtime) + "-" +
- from_i_to_hex(size) + "\"";
+ from_i_to_hex(size) + suffix + "\"";
}
// Format time_t as HTTP-date (RFC 9110 Section 5.6.7): "Sun, 06 Nov 1994
@@ -817,17 +818,14 @@ std::string websocket_accept_key(const std::string &client_key) {
bool is_websocket_upgrade(const Request &req) {
if (req.method != "GET") { return false; }
- // Check Upgrade: websocket (case-insensitive)
- auto upgrade_it = req.headers.find("Upgrade");
- if (upgrade_it == req.headers.end()) { return false; }
- auto upgrade_val = case_ignore::to_lower(upgrade_it->second);
- if (upgrade_val != "websocket") { return false; }
+ // Check Upgrade: websocket. RFC 9110 7.8 defines Upgrade as a comma-separated
+ // list of protocols and asks recipients to match each name
+ // case-insensitively, so look for the token rather than compare the whole
+ // field value.
+ if (!has_header_token(req.headers, "Upgrade", "websocket")) { return false; }
- // Check Connection header contains "Upgrade"
- auto connection_it = req.headers.find("Connection");
- if (connection_it == req.headers.end()) { return false; }
- auto connection_val = case_ignore::to_lower(connection_it->second);
- if (connection_val.find("upgrade") == std::string::npos) { return false; }
+ // Check Connection: Upgrade
+ if (!has_header_token(req.headers, "Connection", "upgrade")) { return false; }
// Check Sec-WebSocket-Key is a valid base64-encoded 16-byte value (24 chars)
// RFC 6455 Section 4.2.1
@@ -1221,22 +1219,14 @@ bool parse_trailers(stream_line_reader &line_reader, Headers &dest,
"trailer"};
case_ignore::unordered_set<std::string> declared_trailers;
- auto trailer_header = get_header_value(src_headers, "Trailer", "", 0);
- if (trailer_header && std::strlen(trailer_header)) {
- auto len = std::strlen(trailer_header);
- split(trailer_header, trailer_header + len, ',',
- [&](const char *b, const char *e) {
- const char *kbeg = b;
- const char *kend = e;
- while (kbeg < kend && (*kbeg == ' ' || *kbeg == '\t')) {
- ++kbeg;
- }
- while (kend > kbeg && (kend[-1] == ' ' || kend[-1] == '\t')) {
- --kend;
- }
- std::string key(kbeg, static_cast<size_t>(kend - kbeg));
- if (!key.empty() &&
- prohibited_trailers.find(key) == prohibited_trailers.end()) {
+ auto trailer_header = get_combined_header_value(src_headers, "Trailer");
+ if (!trailer_header.empty()) {
+ // split() trims each token and skips empty ones, so the name arrives ready
+ // to look up.
+ split(trailer_header.data(), trailer_header.data() + trailer_header.size(),
+ ',', [&](const char *b, const char *e) {
+ std::string key(b, e);
+ if (prohibited_trailers.find(key) == prohibited_trailers.end()) {
declared_trailers.insert(key);
}
});
@@ -1340,6 +1330,55 @@ void split(const char *b, const char *e, char d, size_t m,
}
}
+// Same contract as split(), except that a delimiter inside a quoted-string is
+// not a delimiter. RFC 9110 Section 5.6.6 lets a parameter value be a
+// quoted-string, and ';' and '=' are legal characters inside one.
+void split_unquoted(const char *b, const char *e, char d, size_t m,
+ std::function<void(const char *, const char *)> fn) {
+ size_t i = 0;
+ size_t beg = 0;
+ size_t count = 1;
+ auto in_quotes = false;
+
+ while (e ? (b + i < e) : (b[i] != '\0')) {
+ if (b[i] == '"') {
+ in_quotes = !in_quotes;
+ } else if (b[i] == d && !in_quotes && count < m) {
+ auto r = trim(b, e, beg, i);
+ if (r.first < r.second) { fn(&b[r.first], &b[r.second]); }
+ beg = i + 1;
+ count++;
+ }
+ i++;
+ }
+
+ if (i) {
+ auto r = trim(b, e, beg, i);
+ if (r.first < r.second) { fn(&b[r.first], &b[r.second]); }
+ }
+}
+
+void split_unquoted(const char *b, const char *e, char d,
+ std::function<void(const char *, const char *)> fn) {
+ return split_unquoted(b, e, d, (std::numeric_limits<size_t>::max)(),
+ std::move(fn));
+}
+
+// Divide a header parameter at its first '='. RFC 9110 Section 5.6.6 makes the
+// key a token, so the first '=' is the separator even when the value is a
+// quoted-string carrying more of them.
+void divide_param_pair(const char *b, const char *e, std::string &key,
+ std::string &val) {
+ divide(
+ b, static_cast<std::size_t>(e - b), '=',
+ [&](const char *kb, std::size_t klen, const char *vb, std::size_t vlen) {
+ const auto kr = trim(kb, kb + klen, 0, klen);
+ key.assign(kb + kr.first, kb + kr.second);
+ const auto vr = trim(vb, vb + vlen, 0, vlen);
+ val.assign(vb + vr.first, vb + vr.second);
+ });
+}
+
bool split_find(const char *b, const char *e, char d, size_t m,
std::function<bool(const char *, const char *)> fn) {
size_t i = 0;
@@ -2424,6 +2463,36 @@ bool is_connection_error() {
#endif
}
+// accept() failed because the process or the network stack is temporarily out
+// of resources. The listening socket is still usable, so back off briefly and
+// try again.
+bool is_accept_resource_error() {
+#ifdef _WIN32
+ auto err = WSAGetLastError();
+ return err == WSAEMFILE || err == WSAENOBUFS;
+#else
+ auto err = errno;
+ return err == EMFILE || err == ENFILE || err == ENOBUFS || err == ENOMEM;
+#endif
+}
+
+// accept() failed for a reason that says nothing about the listening socket:
+// the pending connection went away before it could be accepted, or the call
+// was interrupted. Retry immediately. WSAAccept()'s own documentation omits
+// WSAECONNRESET, but the accept() it wraps reports an aborted pending
+// connection that way.
+bool is_accept_transient_error() {
+#ifdef _WIN32
+ auto err = WSAGetLastError();
+ return err == WSAEINTR || err == WSAEWOULDBLOCK || err == WSAECONNRESET ||
+ err == WSAECONNABORTED;
+#else
+ auto err = errno;
+ return err == EINTR || err == EAGAIN || err == EWOULDBLOCK ||
+ err == ECONNABORTED;
+#endif
+}
+
bool bind_ip_address(socket_t sock, const std::string &host) {
struct addrinfo hints;
struct addrinfo *result;
@@ -2728,21 +2797,16 @@ extract_media_type(const std::string &content_type,
if (params) {
// Parse parameters: key=value pairs separated by ';'
- split(param_str.data(), param_str.data() + param_str.size(), ';',
- [&](const char *b, const char *e) {
- std::string key;
- std::string val;
- split(b, e, '=', [&](const char *b2, const char *e2) {
- if (key.empty()) {
- key.assign(b2, e2);
- } else {
- val.assign(b2, e2);
- }
- });
- if (!key.empty()) {
- params->emplace(trim_copy(key), trim_double_quotes_copy(val));
- }
- });
+ split_unquoted(param_str.data(), param_str.data() + param_str.size(), ';',
+ [&](const char *b, const char *e) {
+ std::string key;
+ std::string val;
+ divide_param_pair(b, e, key, val);
+ if (!key.empty()) {
+ params->emplace(trim_copy(key),
+ trim_double_quotes_copy(val));
+ }
+ });
}
}
@@ -2828,12 +2892,11 @@ bool parse_quality(const char *b, const char *e, std::string &token,
return !invalid;
}
-EncodingType encoding_type(const Request &req, const Response &res) {
- if (!can_compress_content_type(res.get_header_value("Content-Type"))) {
- return EncodingType::None;
- }
+EncodingType encoding_type(const Request &req,
+ const std::string &content_type) {
+ if (!can_compress_content_type(content_type)) { return EncodingType::None; }
- const auto &s = req.get_header_value("Accept-Encoding");
+ auto s = get_combined_header_value(req.headers, "Accept-Encoding");
if (s.empty()) { return EncodingType::None; }
// Single-pass: iterate tokens and track the best supported encoding.
@@ -2885,6 +2948,10 @@ EncodingType encoding_type(const Request &req, const Response &res) {
return best;
}
+EncodingType encoding_type(const Request &req, const Response &res) {
+ return encoding_type(req, res.get_header_value("Content-Type"));
+}
+
std::unique_ptr<compressor> make_compressor(EncodingType type) {
#ifdef CPPHTTPLIB_ZLIB_SUPPORT
if (type == EncodingType::Gzip) {
@@ -3174,13 +3241,6 @@ bool zstd_decompressor::decompress(const char *data, size_t data_length,
}
#endif
-bool contains_case_ignore(const std::string &s, const char *token) {
- auto token_end = token + std::strlen(token);
- return std::search(s.begin(), s.end(), token, token_end, [](char a, char b) {
- return case_ignore::to_lower(a) == case_ignore::to_lower(b);
- }) != s.end();
-}
-
// Content codings are case-insensitive (RFC 9110 8.4.1). Matching them
// case-sensitively would make a response labeled e.g. "GZIP" look like an
// unknown coding, and its payload would be handed back still compressed.
@@ -3190,11 +3250,11 @@ bool is_zlib_encoding(const std::string &encoding) {
}
bool is_brotli_encoding(const std::string &encoding) {
- return contains_case_ignore(encoding, "br");
+ return case_ignore::equal(encoding, "br");
}
bool is_zstd_encoding(const std::string &encoding) {
- return contains_case_ignore(encoding, "zstd");
+ return case_ignore::equal(encoding, "zstd");
}
// Returns true if the content coding is one cpp-httplib is able to decompress
@@ -3281,6 +3341,45 @@ size_t get_header_value_count(const Headers &headers,
return headers.count(key);
}
+// RFC 9110 Section 5.2 and 5.3: a field that is defined as a comma-separated
+// list may be sent as several field lines, and the combined field value is
+// those values joined by commas in the order they were received. Callers that
+// parse such a list must work on the combined value; reading only the first
+// occurrence silently drops whatever the later field lines carry.
+std::string get_combined_header_value(const Headers &headers,
+ const std::string &key) {
+ std::string combined;
+ auto rng = headers.equal_range(key);
+ for (auto it = rng.first; it != rng.second; ++it) {
+ // RFC 9110 Section 5.6.1.2: a recipient has to parse and ignore empty list
+ // elements, so an empty field line must not contribute a bare comma to the
+ // combined value.
+ if (it->second.empty()) { continue; }
+ if (!combined.empty()) { combined += ", "; }
+ combined += it->second;
+ }
+ return combined;
+}
+
+bool has_header_token(const Headers &headers, const std::string &key,
+ const std::string &token) {
+ // RFC 9110 7.6.1: a comma-separated token list field such as Connection may
+ // carry several tokens, and RFC 9110 5.3 lets that list be split across
+ // several lines. Match complete tokens rather than searching the raw value,
+ // so that a value such as "notupgrade" is not read as the token "upgrade".
+ auto rng = headers.equal_range(key);
+ for (auto it = rng.first; it != rng.second; ++it) {
+ const auto &value = it->second;
+ if (split_find(value.data(), value.data() + value.size(), ',',
+ [&](const char *b, const char *e) {
+ return case_ignore::equal(std::string(b, e), token);
+ })) {
+ return true;
+ }
+ }
+ return false;
+}
+
template <typename Map>
typename Map::mapped_type
get_multimap_value(const Map &m, const std::string &key, size_t id) {
@@ -3411,19 +3510,14 @@ bool read_websocket_upgrade_response(Stream &strm,
return false;
}
- // Verify Upgrade: websocket (case-insensitive)
- auto upgrade_it = headers.find("Upgrade");
- if (upgrade_it == headers.end() ||
- case_ignore::to_lower(upgrade_it->second) != "websocket") {
+ // Verify Upgrade: websocket (a comma-separated list, matched per token)
+ if (!has_header_token(headers, "Upgrade", "websocket")) {
upgrade.error = Error::WebSocketHandshake;
return false;
}
- // Verify Connection header contains "Upgrade" (case-insensitive)
- auto connection_it = headers.find("Connection");
- if (connection_it == headers.end() ||
- case_ignore::to_lower(connection_it->second).find("upgrade") ==
- std::string::npos) {
+ // Verify Connection: Upgrade
+ if (!has_header_token(headers, "Connection", "upgrade")) {
upgrade.error = Error::WebSocketHandshake;
return false;
}
@@ -3589,7 +3683,7 @@ bool prepare_content_receiver(T &x, int &status,
bool decompress, size_t payload_max_length,
bool &exceed_payload_max_length, U callback) {
if (decompress) {
- std::string encoding = x.get_header_value("Content-Encoding");
+ auto encoding = get_combined_header_value(x.headers, "Content-Encoding");
std::unique_ptr<decompressor> decompressor;
if (!encoding.empty()) {
@@ -3769,6 +3863,7 @@ bool write_content_with_progress(Stream &strm,
size_t end_offset = offset + length;
size_t start_offset = offset;
auto ok = true;
+ auto finished = false;
DataSink data_sink;
data_sink.write = [&](const char *d, size_t l) -> bool {
@@ -3792,7 +3887,14 @@ bool write_content_with_progress(Stream &strm,
data_sink.is_writable = [&]() -> bool { return strm.is_peer_alive(); };
- while (offset < end_offset && !is_shutting_down()) {
+ // The body is framed by `length`, so a provider that reports itself done
+ // early has truncated it. Record that and let the short-body check below
+ // fail the write, rather than calling the provider again forever.
+ data_sink.done = [&]() { finished = true; };
+
+ while (offset < end_offset && !finished && !is_shutting_down()) {
+ auto last_offset = offset;
+
if (!strm.wait_writable() || !strm.is_peer_alive()) {
error = Error::Write;
return false;
@@ -3803,9 +3905,18 @@ bool write_content_with_progress(Stream &strm,
error = Error::Write;
return false;
}
+
+ // A provider that reports success without writing anything and without
+ // reporting itself done gets handed the same offset and length again on
+ // the next pass, so it would spin here for as long as the peer stays
+ // connected. Treat making no progress as a short body, like done() early.
+ if (!finished && offset == last_offset) {
+ error = Error::Write;
+ return false;
+ }
}
- if (offset < end_offset) { // exited due to is_shutting_down(), not completion
+ if (offset < end_offset) { // done() called early, or is_shutting_down()
error = Error::Write;
return false;
}
@@ -3866,6 +3977,67 @@ write_content_without_length(Stream &strm,
// down
}
+// Runs a known-length content provider to completion and compresses what it
+// writes into `out`. Nothing is buffered in identity form: a provider backed
+// by an mmap hands the compressor a pointer straight into the mapping.
+bool compress_content_provider(const ContentProvider &content_provider,
+ size_t length, compressor &cmp,
+ std::string &out) {
+ size_t offset = 0;
+ auto ok = true;
+ auto finished = false;
+ DataSink data_sink;
+
+ auto append = [&](const char *data, size_t data_len) {
+ out.append(data, data_len);
+ return true;
+ };
+
+ data_sink.write = [&](const char *d, size_t l) -> bool {
+ if (!ok) { return false; }
+ offset += l;
+ if (l > 0 && !cmp.compress(d, l, false, append)) { ok = false; }
+ return ok;
+ };
+
+ // The body is framed by `length`, so a provider that reports itself done
+ // early has truncated it; the short-body check below turns that into a
+ // failure rather than calling the provider again forever.
+ data_sink.done = [&]() { finished = true; };
+
+ while (offset < length && !finished) {
+ auto prev_offset = offset;
+ if (!content_provider(offset, length - offset, data_sink) || !ok) {
+ return false;
+ }
+ // No Stream to block on here, so a provider that keeps returning true
+ // without writing would spin. Treat a pass that made no progress as a
+ // failure.
+ if (offset == prev_offset) { return false; }
+ }
+
+ if (offset != length) { return false; }
+
+ return cmp.compress(nullptr, 0, true, append);
+}
+
+// Serves `m` as the response body. `set_content_provider()` clears the coding,
+// so recording it has to come after; keeping both here means a third
+// file-serving path cannot get that order wrong.
+void set_file_content_provider(Response &res,
+ const std::shared_ptr<mmap> &m,
+ const std::string &content_type,
+ EncodingType encoding) {
+ res.set_content_provider(
+ m->size(), content_type,
+ [m](size_t offset, size_t length, DataSink &sink) -> bool {
+ sink.write(m->data() + offset, length);
+ return true;
+ });
+
+ res.file_content_encoding_ = encoding;
+}
+
template <typename T, typename U>
bool
write_content_chunked(Stream &strm, const ContentProvider &content_provider,
@@ -3876,8 +4048,10 @@ write_content_chunked(Stream &strm, const ContentProvider &content_provider,
DataSink data_sink;
data_sink.write = [&](const char *d, size_t l) -> bool {
- if (ok) {
- data_available = l > 0;
+ // Only done()/done_with_trailer() end a chunked body. A pass with nothing
+ // to hand over is ordinary (an empty buffer popped off a queue), and a
+ // zero-length chunk is the terminator, so it must not be emitted here.
+ if (ok && l > 0) {
offset += l;
std::string payload;
@@ -4130,31 +4304,30 @@ bool parse_multipart_boundary(const std::string &content_type,
auto it = params.find("boundary");
if (it == params.end()) { return false; }
boundary = it->second;
- return !boundary.empty();
+ // RFC 2046 5.1.1 caps a boundary at 70 characters. The parser scans the body
+ // for "--" + boundary, so a body crafted to repeat that delimiter's leading
+ // bytes costs a nearly full comparison at nearly every position: the
+ // boundary's length multiplies the worst-case cost of scanning a body.
+ return !boundary.empty() && boundary.size() <= 70;
}
void parse_disposition_params(const std::string &s, Params &params) {
std::set<std::string> cache;
- split(s.data(), s.data() + s.size(), ';', [&](const char *b, const char *e) {
- std::string kv(b, e);
- if (cache.find(kv) != cache.end()) { return; }
- cache.insert(kv);
+ split_unquoted(s.data(), s.data() + s.size(), ';',
+ [&](const char *b, const char *e) {
+ std::string kv(b, e);
+ if (cache.find(kv) != cache.end()) { return; }
+ cache.insert(kv);
- std::string key;
- std::string val;
- split(b, e, '=', [&](const char *b2, const char *e2) {
- if (key.empty()) {
- key.assign(b2, e2);
- } else {
- val.assign(b2, e2);
- }
- });
+ std::string key;
+ std::string val;
+ divide_param_pair(b, e, key, val);
- if (!key.empty()) {
- params.emplace(trim_double_quotes_copy((key)),
- trim_double_quotes_copy((val)));
- }
- });
+ if (!key.empty()) {
+ params.emplace(trim_double_quotes_copy(key),
+ trim_double_quotes_copy(val));
+ }
+ });
}
#ifdef CPPHTTPLIB_NO_EXCEPTIONS
@@ -4224,12 +4397,6 @@ bool parse_accept_header(const std::string &s,
// Empty string is considered valid (no preference)
if (s.empty()) { return true; }
- // Check for invalid patterns: leading/trailing commas or consecutive commas
- if (s.front() == ',' || s.back() == ',' ||
- s.find(",,") != std::string::npos) {
- return false;
- }
-
struct AcceptEntry {
std::string media_type;
double quality;
@@ -4240,16 +4407,16 @@ bool parse_accept_header(const std::string &s,
int order = 0;
bool has_invalid_entry = false;
- // Split by comma and parse each entry
+ // Split by comma and parse each entry. RFC 9110 Section 5.6.1.2: a recipient
+ // has to parse and ignore empty list elements, so a leading, trailing or
+ // doubled comma must not turn a legal Accept value into 400 Bad Request.
+ // split() skips them, and the header length limit bounds how many a sender
+ // can send, so ignoring all of them cannot be used as a denial-of-service
+ // vector.
split(s.data(), s.data() + s.size(), ',', [&](const char *b, const char *e) {
std::string entry(b, e);
entry = trim_copy(entry);
- if (entry.empty()) {
- has_invalid_entry = true;
- return;
- }
-
AcceptEntry accept_entry;
accept_entry.order = order++;
@@ -4314,13 +4481,25 @@ public:
bool parse(const char *buf, size_t n, const FormDataHeader &header_callback,
const ContentReceiver &content_callback) {
+ // Once the close delimiter has been seen the rest of the body is epilogue
+ // to be discarded (RFC 2046). Drop it without buffering so a large epilogue
+ // spread across reads is not copied in only to be erased right away.
+ if (state_ == 5) { return true; }
+
buf_append(buf, n);
while (buf_size() > 0) {
switch (state_) {
case 0: { // Initial boundary
auto pos = buf_find(dash_boundary_crlf_);
- if (pos == buf_size()) { return true; }
+ if (pos == buf_size()) {
+ // Not found yet: keep only a possible partial boundary at the tail so
+ // that a body which never contains the boundary cannot grow the
+ // buffer (and get rescanned from the start) without bound.
+ auto keep = dash_boundary_crlf_.size() - 1;
+ if (buf_size() > keep) { buf_erase(buf_size() - keep); }
+ return true;
+ }
buf_erase(pos + dash_boundary_crlf_.size());
state_ = 1;
break;
@@ -4443,18 +4622,26 @@ public:
if (buf_start_with(crlf_)) {
buf_erase(crlf_.size());
state_ = 1;
+ } else if (buf_start_with(dash_)) {
+ buf_erase(dash_.size());
+ is_valid_ = true;
+ state_ = 5;
} else {
- if (dash_.size() > buf_size()) { return true; }
- if (buf_start_with(dash_)) {
- buf_erase(dash_.size());
- is_valid_ = true;
- buf_erase(buf_size()); // Remove epilogue
- } else {
- return true;
- }
+ // Only CRLF (another part follows) and "--" (close-delimiter) are
+ // accepted after a boundary; RFC 2046 allows transport-padding in
+ // between, but this parser has never supported it. Either way the
+ // body is already destined to be rejected, so fail now instead of
+ // buffering the rest of it. Both are two bytes, so the check above
+ // already guarantees enough buffered data to decide.
+ is_valid_ = false;
+ return false;
}
break;
}
+ case 5: { // Epilogue
+ buf_erase(buf_size());
+ break;
+ }
}
}
@@ -5050,9 +5237,11 @@ bool has_framed_body(const Request &req) {
}
bool is_connection_persistent(const Request &req) {
- auto conn = req.get_header_value("Connection");
- if (conn == "close") { return false; }
- if (req.version == "HTTP/1.0" && conn != "Keep-Alive") { return false; }
+ if (has_header_token(req.headers, "Connection", "close")) { return false; }
+ if (req.version == "HTTP/1.0" &&
+ !has_header_token(req.headers, "Connection", "keep-alive")) {
+ return false;
+ }
return true;
}
@@ -5082,38 +5271,108 @@ public:
static WSInit wsinit_;
#endif
+// RFC 9110 Section 11.6.1 defines a challenge list as
+// WWW-Authenticate = #challenge
+// challenge = auth-scheme [ 1*SP ( token68 / [ #auth-param ] ) ]
+// auth-param = token BWS "=" BWS ( token / quoted-string )
+// so a server may offer several schemes, each with its own comma-separated
+// auth-param list, in either order and either as separate field lines or
+// packed into one. Splitting on every comma would break apart a challenge's
+// own param list; splitting only on the first space would miss a Digest
+// challenge that isn't first. Split on commas that aren't inside a
+// quoted-string instead, then track which scheme each resulting segment
+// belongs to: a segment whose text before "=" contains whitespace (or that
+// has no "=" at all) starts a new challenge named by its leading token.
+std::vector<std::string> split_challenge_segments(const std::string &s) {
+ std::vector<std::string> segments;
+ size_t start = 0;
+ auto in_quotes = false;
+ for (size_t i = 0; i < s.size(); i++) {
+ auto c = s[i];
+ if (in_quotes) {
+ if (c == '\\' && i + 1 < s.size()) {
+ i++;
+ } else if (c == '"') {
+ in_quotes = false;
+ }
+ } else if (c == '"') {
+ in_quotes = true;
+ } else if (c == ',') {
+ segments.push_back(s.substr(start, i - start));
+ start = i + 1;
+ }
+ }
+ segments.push_back(s.substr(start));
+ return segments;
+}
+
+std::string unescape_quoted_pairs(const std::string &s) {
+ std::string out;
+ out.reserve(s.size());
+ for (size_t i = 0; i < s.size(); i++) {
+ if (s[i] == '\\' && i + 1 < s.size()) {
+ out += s[++i];
+ } else {
+ out += s[i];
+ }
+ }
+ return out;
+}
+
bool parse_www_authenticate(const Response &res,
std::map<std::string, std::string> &auth,
bool is_proxy) {
auto auth_key = is_proxy ? "Proxy-Authenticate" : "WWW-Authenticate";
- if (res.has_header(auth_key)) {
- thread_local auto re =
- std::regex(R"~((?:(?:,\s*)?(.+?)=(?:"(.*?)"|([^,]*))))~");
- auto s = res.get_header_value(auth_key);
- auto pos = s.find(' ');
- if (pos != std::string::npos) {
- auto type = s.substr(0, pos);
- if (type == "Basic") {
- return false;
- } else if (type == "Digest") {
- s = s.substr(pos + 1);
- auto beg = std::sregex_iterator(s.begin(), s.end(), re);
- for (auto i = beg; i != std::sregex_iterator(); ++i) {
- const auto &m = *i;
- auto key = s.substr(static_cast<size_t>(m.position(1)),
- static_cast<size_t>(m.length(1)));
- auto val = m.length(2) > 0
- ? s.substr(static_cast<size_t>(m.position(2)),
- static_cast<size_t>(m.length(2)))
- : s.substr(static_cast<size_t>(m.position(3)),
- static_cast<size_t>(m.length(3)));
- auth[std::move(key)] = std::move(val);
- }
- return true;
+ auto combined = get_combined_header_value(res.headers, auth_key);
+ if (combined.empty()) { return false; }
+
+ auto found_digest = false;
+ auto in_digest_challenge = false;
+ for (const auto &raw_segment : split_challenge_segments(combined)) {
+ auto segment = trim_copy(raw_segment);
+ if (segment.empty()) { continue; }
+
+ auto eq_pos = segment.find('=');
+ // BWS is allowed on both sides of "=", so the text naming the key (or,
+ // for the first segment of a challenge, "<scheme> <key>") must be
+ // trimmed before its boundaries are inspected.
+ auto key_part = trim_copy(
+ eq_pos == std::string::npos ? segment : segment.substr(0, eq_pos));
+ auto space_pos = key_part.find_last_of(" \t");
+ if (space_pos != std::string::npos || eq_pos == std::string::npos) {
+ // "<scheme>[ <key>]" starts a new challenge.
+ auto scheme_end =
+ space_pos == std::string::npos ? key_part.size() : space_pos;
+ // RFC 7616 Section 3.7: a server may offer more than one Digest
+ // challenge (e.g. SHA-256 and MD5); keep only the first so a nonce
+ // from one challenge is never paired with another's algorithm.
+ in_digest_challenge =
+ !found_digest &&
+ case_ignore::equal(key_part.substr(0, scheme_end), "Digest");
+ if (in_digest_challenge) { found_digest = true; }
+ if (space_pos == std::string::npos) {
+ // Bare scheme (or a token68), no auth-param on this segment.
+ continue;
}
+ key_part = key_part.substr(space_pos + 1);
}
+
+ if (!in_digest_challenge) { continue; }
+
+ auto val = trim_copy(segment.substr(eq_pos + 1));
+ auto unquoted = trim_double_quotes_copy(val);
+ if (unquoted.size() != val.size()) {
+ unquoted = unescape_quoted_pairs(unquoted);
+ }
+ auth[std::move(key_part)] = std::move(unquoted);
}
- return false;
+
+ // RFC 7616 Section 3.3 requires realm and nonce on every Digest challenge;
+ // make_digest_authentication_header() dereferences both unconditionally, so
+ // a challenge missing either can't produce a usable Authorization header.
+ // Treat it the same as no Digest challenge at all.
+ return found_digest && auth.find("realm") != auth.end() &&
+ auth.find("nonce") != auth.end();
}
class ContentProviderAdapter {
@@ -5317,6 +5576,52 @@ private:
bool readable_hint_ = false;
};
+// A TLS stream for WebSocket connections, where the receive path and the
+// send path (application send() plus the heartbeat ping thread) run on
+// different threads. A single TLS session must never be entered
+// concurrently, so every call into the session is serialized by one mutex.
+//
+// Unlike SSLSocketStream, the socket is kept non-blocking for the stream's
+// whole lifetime and each read()/write() performs a single non-blocking TLS
+// call under the lock, then waits for readiness with select() outside the
+// lock. The lock is therefore held only for CPU-bound work, so a reader
+// blocked waiting for data never stalls a concurrent sender.
+//
+// This stream is used only for wss:// connections. Plain ws:// and ordinary
+// HTTP/HTTPS keep using SocketStream/SSLSocketStream unchanged.
+class WebSocketSSLStream final : public Stream {
+public:
+ WebSocketSSLStream(socket_t sock, tls::session_t session,
+ time_t read_timeout_sec, time_t read_timeout_usec,
+ time_t write_timeout_sec, time_t write_timeout_usec);
+ ~WebSocketSSLStream() override;
+
+ bool is_readable() const override;
+ bool wait_readable() const override;
+ bool wait_writable() const override;
+ ssize_t read(char *ptr, size_t size) override;
+ ssize_t write(const char *ptr, size_t size) override;
+ void get_remote_ip_and_port(std::string &ip, int &port) const override;
+ void get_local_ip_and_port(std::string &ip, int &port) const override;
+ socket_t socket() const override;
+ time_t duration() const override;
+ void set_read_timeout(time_t sec, time_t usec = 0) override;
+
+private:
+ mutable std::mutex session_mutex_;
+
+ socket_t sock_;
+ tls::session_t session_;
+ // WebSocket::close() shortens the read timeout from the closing thread
+ // 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_usec_;
+ time_t write_timeout_sec_;
+ time_t write_timeout_usec_;
+ const std::chrono::time_point<std::chrono::steady_clock> start_time_;
+};
+
#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
std::string message_digest(const std::string &s, const EVP_MD *algo) {
auto context = std::unique_ptr<EVP_MD_CTX, decltype(&EVP_MD_CTX_free)>(
@@ -5893,10 +6198,15 @@ bool set_socket_opt(socket_t sock, int level, int optname, int optval) {
}
std::string get_bearer_token_auth(const Request &req) {
- if (req.has_header("Authorization")) {
- constexpr auto bearer_header_prefix_len = detail::str_len("Bearer ");
- return req.get_header_value("Authorization")
- .substr(bearer_header_prefix_len);
+ // The auth scheme is case-insensitive (RFC 9110 11.1), and a value shorter
+ // than the prefix carries no token.
+ constexpr const char bearer_prefix[] = "Bearer ";
+ constexpr auto bearer_prefix_len = detail::str_len(bearer_prefix);
+ auto value = req.get_header_value("Authorization");
+ if (value.size() >= bearer_prefix_len &&
+ detail::case_ignore::equal(value.substr(0, bearer_prefix_len),
+ bearer_prefix)) {
+ return value.substr(bearer_prefix_len);
}
return "";
}
@@ -6018,6 +6328,7 @@ std::string to_string(const Error error) {
case Error::InvalidRangeHeader: return "Invalid Range header";
case Error::UnsupportedContentEncoding: return "Unsupported Content-Encoding";
case Error::WebSocketHandshake: return "WebSocket handshake failed";
+ case Error::UserCallbackException: return "User callback threw an exception";
default: break;
}
@@ -6137,7 +6448,19 @@ std::string decode_uri(const std::string &value) {
if (value[i] == '%' && i + 2 < value.size()) {
auto val = 0;
if (detail::from_hex_to_i(value, i + 1, 2, val)) {
- result += static_cast<char>(val);
+ auto c = static_cast<char>(val);
+ // Keep escapes of the reserved characters that encode_uri leaves
+ // literal, so decode_uri is the inverse of encode_uri and an escaped
+ // delimiter is not promoted into a real one (as with JS decodeURI).
+ if (c == ';' || c == '/' || c == '?' || c == ':' || c == '@' ||
+ c == '&' || c == '=' || c == '+' || c == '$' || c == ',' ||
+ c == '#') {
+ result += value[i];
+ result += value[i + 1];
+ result += value[i + 2];
+ } else {
+ result += c;
+ }
i += 2;
} else {
result += value[i];
@@ -6579,6 +6902,7 @@ void Response::set_content(const char *s, size_t n,
auto rng = headers.equal_range("Content-Type");
headers.erase(rng.first, rng.second);
set_header("Content-Type", content_type);
+ file_content_encoding_ = detail::EncodingType::None;
}
void Response::set_content(const std::string &s,
@@ -6593,6 +6917,7 @@ void Response::set_content(std::string &&s,
auto rng = headers.equal_range("Content-Type");
headers.erase(rng.first, rng.second);
set_header("Content-Type", content_type);
+ file_content_encoding_ = detail::EncodingType::None;
}
void Response::set_content_provider(
@@ -6603,6 +6928,7 @@ void Response::set_content_provider(
if (in_length > 0) { content_provider_ = std::move(provider); }
content_provider_resource_releaser_ = std::move(resource_releaser);
is_chunked_content_provider_ = false;
+ file_content_encoding_ = detail::EncodingType::None;
}
void Response::set_content_provider(
@@ -6613,6 +6939,7 @@ void Response::set_content_provider(
content_provider_ = detail::ContentProviderAdapter(std::move(provider));
content_provider_resource_releaser_ = std::move(resource_releaser);
is_chunked_content_provider_ = false;
+ file_content_encoding_ = detail::EncodingType::None;
}
void Response::set_chunked_content_provider(
@@ -6623,6 +6950,7 @@ void Response::set_chunked_content_provider(
content_provider_ = detail::ContentProviderAdapter(std::move(provider));
content_provider_resource_releaser_ = std::move(resource_releaser);
is_chunked_content_provider_ = true;
+ file_content_encoding_ = detail::EncodingType::None;
}
void Response::set_file_content(const std::string &path,
@@ -7600,6 +7928,127 @@ void SSLSocketStream::set_read_timeout(time_t sec, time_t usec) {
read_timeout_usec_ = usec;
}
+WebSocketSSLStream::WebSocketSSLStream(socket_t sock,
+ tls::session_t session,
+ time_t read_timeout_sec,
+ time_t read_timeout_usec,
+ time_t write_timeout_sec,
+ time_t write_timeout_usec)
+ : sock_(sock), session_(session), read_timeout_sec_(read_timeout_sec),
+ read_timeout_usec_(read_timeout_usec),
+ write_timeout_sec_(write_timeout_sec),
+ write_timeout_usec_(write_timeout_usec),
+ start_time_(std::chrono::steady_clock::now()) {
+ // 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()
+ // outside the session lock. Set the socket non-blocking once here; it is
+ // never flipped back, so no thread races on the flag.
+ detail::set_nonblocking(sock_, true);
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+ SSL_clear_mode(static_cast<SSL *>(session_), SSL_MODE_AUTO_RETRY);
+#endif
+}
+
+WebSocketSSLStream::~WebSocketSSLStream() = default;
+
+bool WebSocketSSLStream::is_readable() const {
+ std::lock_guard<std::mutex> guard(session_mutex_);
+ return tls::pending(session_) > 0;
+}
+
+bool WebSocketSSLStream::wait_readable() const {
+ return select_read(sock_, read_timeout_sec_, read_timeout_usec_) > 0;
+}
+
+bool WebSocketSSLStream::wait_writable() const {
+ // Unlike SSLSocketStream, this deliberately does not call is_peer_closed():
+ // that probe toggles the socket's blocking flag, which would race with the
+ // concurrent reader on a permanently non-blocking socket.
+ return select_write(sock_, write_timeout_sec_, write_timeout_usec_) > 0;
+}
+
+ssize_t WebSocketSSLStream::read(char *ptr, size_t size) {
+ tls::TlsError err;
+ auto n = 1000;
+ while (--n >= 0) {
+ {
+ std::lock_guard<std::mutex> guard(session_mutex_);
+ auto ret = tls::read(session_, ptr, size, err);
+ if (ret > 0) { return ret; }
+ if (ret == 0 || err.code == tls::ErrorCode::PeerClosed) {
+ error_ = Error::ConnectionClosed;
+ return ret;
+ }
+ }
+ // ret < 0. On a non-blocking socket a TLS read can stop needing either
+ // direction: the send path shares this session, so output it left pending
+ // has to be flushed before more input can be decrypted. Anything else is
+ // a hard error.
+ auto needs_readable = err.code == tls::ErrorCode::WantRead;
+#ifdef _WIN32
+ // On Windows a socket timeout surfaces as a syscall error, not WantRead.
+ needs_readable =
+ needs_readable || (err.code == tls::ErrorCode::SyscallError &&
+ WSAGetLastError() == WSAETIMEDOUT);
+#endif
+ if (!needs_readable && err.code != tls::ErrorCode::WantWrite) { return -1; }
+ if (!(needs_readable ? wait_readable() : wait_writable())) {
+ error_ = Error::Timeout;
+ return -1;
+ }
+ }
+ return -1;
+}
+
+ssize_t WebSocketSSLStream::write(const char *ptr, size_t size) {
+ auto handle_size = std::min<size_t>(size, (std::numeric_limits<int>::max)());
+ tls::TlsError err;
+ auto n = 1000;
+ while (--n >= 0) {
+ {
+ std::lock_guard<std::mutex> guard(session_mutex_);
+ auto ret = tls::write(session_, ptr, handle_size, err);
+ if (ret >= 0) { return ret; }
+ }
+ // ret < 0. As in read(), either direction can be needed: a renegotiation
+ // or a post-handshake message must be consumed before the record goes
+ // out. Anything else is a hard error.
+ auto needs_writable = err.code == tls::ErrorCode::WantWrite;
+#ifdef _WIN32
+ // On Windows a socket timeout surfaces as a syscall error, not WantWrite.
+ needs_writable =
+ needs_writable || (err.code == tls::ErrorCode::SyscallError &&
+ WSAGetLastError() == WSAETIMEDOUT);
+#endif
+ if (!needs_writable && err.code != tls::ErrorCode::WantRead) { return -1; }
+ if (!(needs_writable ? wait_writable() : wait_readable())) { return -1; }
+ }
+ return -1;
+}
+
+void WebSocketSSLStream::get_remote_ip_and_port(std::string &ip,
+ int &port) const {
+ detail::get_remote_ip_and_port(sock_, ip, port);
+}
+
+void WebSocketSSLStream::get_local_ip_and_port(std::string &ip,
+ int &port) const {
+ detail::get_local_ip_and_port(sock_, ip, port);
+}
+
+socket_t WebSocketSSLStream::socket() const { return sock_; }
+
+time_t WebSocketSSLStream::duration() const {
+ return std::chrono::duration_cast<std::chrono::milliseconds>(
+ std::chrono::steady_clock::now() - start_time_)
+ .count();
+}
+
+void WebSocketSSLStream::set_read_timeout(time_t sec, time_t usec) {
+ read_timeout_sec_ = sec;
+ read_timeout_usec_ = usec;
+}
+
} // namespace detail
#endif // CPPHTTPLIB_SSL_ENABLED
@@ -7687,6 +8136,57 @@ Server &Server::Options(const std::string &pattern, Handler handler) {
return add_handler(options_handlers_, pattern, std::move(handler));
}
+const std::set<std::string> &Server::builtin_methods() {
+ thread_local const std::set<std::string> methods{
+ "GET", "HEAD", "POST", "PUT", "DELETE",
+ "CONNECT", "OPTIONS", "TRACE", "PATCH", "PRI"};
+ return methods;
+}
+
+Server::CustomHandlerEntry *
+Server::custom_entry_for_registration(const std::string &method) {
+ // Built-in methods are refused for two different reasons. GET, HEAD, POST,
+ // PUT, DELETE, OPTIONS and PATCH are dispatched by the if/else chain in
+ // routing() before the custom tables are consulted, so a route registered
+ // for one of them could never fire. CONNECT, TRACE and PRI have no branch
+ // there and would be reachable, but they carry protocol-level meaning
+ // (tunnel setup, request echo, the HTTP/2 connection preface) that this
+ // library does not route.
+ if (!detail::fields::is_token(method) || builtin_methods().count(method)) {
+ output_error_log(Error::InvalidHTTPMethod, nullptr);
+ has_invalid_registration_ = true;
+ return nullptr;
+ }
+ return &custom_handlers_[method];
+}
+
+Server &Server::CustomRoute(const std::string &method,
+ const std::string &pattern,
+ Handler handler) {
+ auto *entry = custom_entry_for_registration(method);
+ if (!entry) { return *this; }
+ return add_handler(entry->handlers, pattern, std::move(handler));
+}
+
+Server &Server::CustomRoute(const std::string &method,
+ const std::string &pattern,
+ HandlerWithContentReader handler) {
+ auto *entry = custom_entry_for_registration(method);
+ if (!entry) { return *this; }
+ return add_handler(entry->handlers_for_content_reader, pattern,
+ std::move(handler));
+}
+
+const Server::CustomHandlerEntry *
+Server::find_custom_entry(const std::string &method) const {
+ // find() alone would be correct here. The empty() check is what keeps the
+ // per-request cost off servers that never call CustomRoute(), which is the
+ // overwhelmingly common case; keep it rather than walking into the tree.
+ if (custom_handlers_.empty()) { return nullptr; }
+ auto it = custom_handlers_.find(method);
+ return it == custom_handlers_.end() ? nullptr : &it->second;
+}
+
Server &Server::WebSocket(const std::string &pattern,
WebSocketHandler handler) {
websocket_handlers_.push_back(
@@ -7898,6 +8398,21 @@ Server &Server::set_payload_max_length(size_t length) {
return *this;
}
+Server &Server::set_static_file_compression(bool on) {
+ static_file_compression_ = on;
+ return *this;
+}
+
+Server &Server::set_static_file_compression_min_length(size_t length) {
+ static_file_compression_min_length_ = length;
+ return *this;
+}
+
+Server &Server::set_static_file_compression_max_length(size_t length) {
+ static_file_compression_max_length_ = length;
+ return *this;
+}
+
Server &Server::set_websocket_max_missed_pongs(int count) {
websocket_max_missed_pongs_ = count;
return *this;
@@ -7979,11 +8494,12 @@ bool Server::parse_request_line(const char *s, Request &req) const {
if (count != 3) { return false; }
}
- thread_local const std::set<std::string> methods{
- "GET", "HEAD", "POST", "PUT", "DELETE",
- "CONNECT", "OPTIONS", "TRACE", "PATCH", "PRI"};
+ // A method outside the built-in set is accepted only when a handler has been
+ // registered for it with CustomRoute().
+ const auto &methods = builtin_methods();
- if (methods.find(req.method) == methods.end()) {
+ if (methods.find(req.method) == methods.end() &&
+ !find_custom_entry(req.method)) {
output_error_log(Error::InvalidHTTPMethod, &req);
return false;
}
@@ -8044,7 +8560,8 @@ bool Server::write_response_core(Stream &strm, bool close_connection,
if (need_apply_ranges) { apply_ranges(req, res, content_type, boundary); }
// Prepare additional headers
- if (close_connection || req.get_header_value("Connection") == "close" ||
+ if (close_connection ||
+ detail::has_header_token(req.headers, "Connection", "close") ||
400 <= res.status) { // Don't leave connections open after errors
res.set_header("Connection", "close");
} else {
@@ -8352,7 +8869,29 @@ bool Server::handle_file_request(Request &req, Response &res) {
res.set_header(kv.first, kv.second);
}
- auto etag = detail::compute_etag(stat);
+ auto content_type_of = [&]() {
+ return detail::find_content_type(
+ path, file_extension_and_mimetype_map_, default_file_mimetype_);
+ };
+
+ // Only the ETag needs the content type this early, and only to name
+ // the coding. Deciding it here would otherwise put a regex in front
+ // of the 304 below, which serving a file never used to pay for.
+ std::string content_type;
+ auto encoding = detail::EncodingType::None;
+ if (static_file_compression_) {
+ content_type = content_type_of();
+ encoding = static_file_encoding(req, content_type, stat.size());
+ }
+
+ // The ETag names the representation actually sent, so a client that
+ // cached the compressed form revalidates against the compressed ETag
+ // and still gets a 304, while one that took identity keeps the plain
+ // ETag.
+ auto etag = detail::compute_etag(
+ stat, encoding == detail::EncodingType::None
+ ? std::string()
+ : std::string("-") + detail::encoding_name(encoding));
if (!etag.empty()) { res.set_header("ETag", etag); }
auto mtime = stat.mtime();
@@ -8372,14 +8911,9 @@ bool Server::handle_file_request(Request &req, Response &res) {
return false;
}
- res.set_content_provider(
- mm->size(),
- detail::find_content_type(path, file_extension_and_mimetype_map_,
- default_file_mimetype_),
- [mm](size_t offset, size_t length, DataSink &sink) -> bool {
- sink.write(mm->data() + offset, length);
- return true;
- });
+ if (!static_file_compression_) { content_type = content_type_of(); }
+
+ detail::set_file_content_provider(res, mm, content_type, encoding);
if (req.method != "HEAD" && file_request_handler_) {
file_request_handler_(req, res);
@@ -8403,7 +8937,8 @@ bool Server::check_if_not_modified(const Request &req, Response &res,
// 2. If-Modified-Since is checked only when If-None-Match is absent
if (req.has_header("If-None-Match")) {
if (!etag.empty()) {
- auto val = req.get_header_value("If-None-Match");
+ auto val =
+ detail::get_combined_header_value(req.headers, "If-None-Match");
// NOTE: We use exact string matching here. This works correctly
// because our server always generates weak ETags (W/"..."), and
@@ -8564,16 +9099,26 @@ bool Server::listen_internal() {
#endif
if (sock == INVALID_SOCKET) {
- if (errno == EMFILE) {
- // The per-process limit of open file descriptors has been reached.
- // Try to accept new connections after a short sleep.
+ // NOTE: Winsock reports failures through WSAGetLastError() and never
+ // touches the CRT errno, so the two have to be asked platform by
+ // platform rather than by testing errno here.
+ if (detail::is_accept_resource_error()) {
+ // The per-process descriptor limit or the network stack's buffer
+ // space has been reached. Try to accept new connections after a
+ // short sleep.
std::this_thread::sleep_for(std::chrono::microseconds{1});
continue;
- } else if (errno == EINTR || errno == EAGAIN) {
+ } else if (detail::is_accept_transient_error()) {
continue;
}
- if (svr_sock_ != INVALID_SOCKET) {
- detail::close_socket(svr_sock_);
+ // Take the descriptor out of svr_sock_ before closing it: a later
+ // stop() would otherwise shutdown()/close() a value the OS may have
+ // reused, and keep_alive() watches svr_sock_ to notice the server is
+ // gone. The exchange also settles the race with a concurrent stop(),
+ // since whichever side takes the descriptor closes it exactly once.
+ auto listen_sock = svr_sock_.exchange(INVALID_SOCKET);
+ if (listen_sock != INVALID_SOCKET) {
+ detail::close_socket(listen_sock);
ret = false;
output_error_log(Error::Connection, nullptr);
} else {
@@ -8616,7 +9161,14 @@ bool Server::routing(Request &req, Response &res, Stream &strm) {
return true;
}
- if (detail::expect_content(req)) {
+ const auto *custom = find_custom_entry(req.method);
+
+ // The second clause mirrors what expect_content() does unconditionally for
+ // POST/PUT/PATCH/DELETE: a content reader route fires even when the request
+ // carries no body. Without it a body-less PROPFIND (RFC 4918 treats one as
+ // `allprop`) would skip its handler and fall through to 404.
+ if (detail::expect_content(req) ||
+ (custom && !custom->handlers_for_content_reader.empty())) {
// Content reader handler
{
// Track whether the ContentReader was aborted due to the decompressed
@@ -8663,6 +9215,9 @@ bool Server::routing(Request &req, Response &res, Stream &strm) {
} else if (req.method == "DELETE") {
dispatched = dispatch_request_for_content_reader(
req, res, std::move(reader), delete_handlers_for_content_reader_);
+ } else if (custom) {
+ dispatched = dispatch_request_for_content_reader(
+ req, res, std::move(reader), custom->handlers_for_content_reader);
}
if (dispatched) {
@@ -8699,6 +9254,8 @@ bool Server::routing(Request &req, Response &res, Stream &strm) {
return dispatch_request(req, res, options_handlers_, strm);
} else if (req.method == "PATCH") {
return dispatch_request(req, res, patch_handlers_, strm);
+ } else if (custom) {
+ return dispatch_request(req, res, custom->handlers, strm);
}
res.status = StatusCode::BadRequest_400;
@@ -8735,9 +9292,88 @@ bool Server::dispatch_request(Request &req, Response &res,
return false;
}
+// Decides the content coding for a response served straight from a file. Both
+// the ETag, which has to name the representation actually sent, and
+// `apply_static_file_compression()` go through this, so the two cannot drift
+// apart.
+detail::EncodingType Server::static_file_encoding(
+ const Request &req, const std::string &content_type, size_t length) const {
+ if (!static_file_compression_) { return detail::EncodingType::None; }
+
+ // Nothing to compress, and an empty file already answers with
+ // `Content-Length: 0`. Checked on its own so that a zero floor still cannot
+ // turn an empty body into a 20-byte gzip stream.
+ if (length == 0) { return detail::EncodingType::None; }
+
+ // A file that already fits in a single packet gains nothing from being made
+ // smaller, since it still travels in that one segment, and a file of a few
+ // bytes comes out larger than it went in.
+ if (length < static_file_compression_min_length_) {
+ return detail::EncodingType::None;
+ }
+
+ // RFC 9110 applies Range to the representation after content coding, so a
+ // compressed 206 would mean compressing the whole file and then slicing it.
+ // Serve ranges from the identity representation instead.
+ if (!req.ranges.empty()) { return detail::EncodingType::None; }
+
+ if (static_file_compression_max_length_ > 0 &&
+ length > static_file_compression_max_length_) {
+ return detail::EncodingType::None;
+ }
+
+ return detail::encoding_type(req, content_type);
+}
+
+// Compresses a file-backed content provider into `res.body` and takes over the
+// framing headers. Returns false when the response is left untouched.
+bool Server::apply_static_file_compression(const Request &req,
+ Response &res) const {
+ auto type = res.file_content_encoding_;
+ if (type == detail::EncodingType::None || !res.content_provider_) {
+ return false;
+ }
+
+ auto compressor = detail::make_compressor(type);
+ if (!compressor) { return false; }
+
+ output_pre_compression_log(req, res);
+
+ std::string compressed;
+ if (!detail::compress_content_provider(res.content_provider_,
+ res.content_length_, *compressor,
+ compressed)) {
+ return false;
+ }
+
+ res.body.swap(compressed);
+
+ // The provider was consumed in full, so a resource releaser registered with
+ // it should hear about a success when the response goes away.
+ res.content_provider_success_ = true;
+ res.content_provider_ = nullptr;
+ res.content_length_ = 0;
+ res.file_content_encoding_ = detail::EncodingType::None;
+
+ res.set_header("Content-Encoding", detail::encoding_name(type));
+ res.set_header("Vary", "Accept-Encoding");
+ res.set_header("Content-Length", std::to_string(res.body.size()));
+
+ return true;
+}
+
void Server::apply_ranges(const Request &req, Response &res,
std::string &content_type,
std::string &boundary) const {
+ // A known-length content provider leaves `res.body` empty, so the compressor
+ // at the end of this function never runs for one (issue #2545). A file-backed
+ // provider is fully readable right here, so compress it and answer with an
+ // ordinary body: `Content-Length` and HEAD keep working, and the response
+ // takes the same path as `set_content()` from here on. Range requests never
+ // get a content coding, so `Content-Range` still names identity bytes and
+ // none of the framing below applies.
+ if (apply_static_file_compression(req, res)) { return; }
+
if (req.ranges.size() > 1 && res.status == StatusCode::PartialContent_206) {
auto it = res.headers.find("Content-Type");
if (it != res.headers.end()) {
@@ -8948,12 +9584,12 @@ Server::process_request(Stream &strm, const std::string &remote_addr,
return write_response(strm, close_connection, req, res);
}
- if (req.get_header_value("Connection") == "close") {
+ if (detail::has_header_token(req.headers, "Connection", "close")) {
connection_closed = true;
}
if (req.version == "HTTP/1.0" &&
- req.get_header_value("Connection") != "Keep-Alive") {
+ !detail::has_header_token(req.headers, "Connection", "keep-alive")) {
connection_closed = true;
}
@@ -8965,7 +9601,13 @@ Server::process_request(Stream &strm, const std::string &remote_addr,
[&](const std::string &proxy) { return proxy == remote_addr; });
if (is_trusted_peer && req.has_header("X-Forwarded-For")) {
- auto x_forwarded_for = req.get_header_value("X-Forwarded-For");
+ // Some proxies append the address they observed as a separate
+ // X-Forwarded-For field line instead of extending the one the client sent
+ // (e.g. HAProxy's "option forwardfor"), so the whole combined value has to
+ // be scanned. Reading only the first occurrence would hand back the
+ // client-supplied, and therefore forgeable, value.
+ auto x_forwarded_for =
+ detail::get_combined_header_value(req.headers, "X-Forwarded-For");
auto derived = get_client_ip(x_forwarded_for, trusted_proxies_);
req.remote_addr = derived.empty() ? remote_addr : derived;
} else {
@@ -8977,7 +9619,8 @@ Server::process_request(Stream &strm, const std::string &remote_addr,
req.local_port = local_port;
if (req.has_header("Accept")) {
- const auto &accept_header = req.get_header_value("Accept");
+ auto accept_header =
+ detail::get_combined_header_value(req.headers, "Accept");
if (!detail::parse_accept_header(accept_header, req.accept_content_types)) {
connection_closed = true;
res.status = StatusCode::BadRequest_400;
@@ -8998,7 +9641,12 @@ Server::process_request(Stream &strm, const std::string &remote_addr,
if (setup_request) { setup_request(req); }
- if (req.get_header_value("Expect") == "100-continue") {
+ // RFC 9110 10.1.1: Expect is a comma-separated list whose value is
+ // case-insensitive, and a 100-continue expectation in an HTTP/1.0 request
+ // must be ignored. An expectation we do not recognize is left alone; the
+ // 417 the section allows for one is a MAY, not a requirement.
+ if (req.version != "HTTP/1.0" &&
+ detail::has_header_token(req.headers, "Expect", "100-continue")) {
int status = StatusCode::Continue_100;
if (expect_100_continue_handler_) {
status = expect_100_continue_handler_(req, res);
@@ -9041,19 +9689,15 @@ Server::process_request(Stream &strm, const std::string &remote_addr,
// Negotiate subprotocol
std::string selected_subprotocol;
if (entry.sub_protocol_selector) {
- auto protocol_header = req.get_header_value("Sec-WebSocket-Protocol");
+ auto protocol_header = detail::get_combined_header_value(
+ req.headers, "Sec-WebSocket-Protocol");
if (!protocol_header.empty()) {
std::vector<std::string> protocols;
- std::istringstream iss(protocol_header);
- std::string token;
- while (std::getline(iss, token, ',')) {
- // Trim whitespace
- auto start = token.find_first_not_of(' ');
- auto end = token.find_last_not_of(' ');
- if (start != std::string::npos) {
- protocols.push_back(token.substr(start, end - start + 1));
- }
- }
+ detail::split(protocol_header.data(),
+ protocol_header.data() + protocol_header.size(), ',',
+ [&](const char *b, const char *e) {
+ protocols.emplace_back(b, e);
+ });
selected_subprotocol = entry.sub_protocol_selector(protocols);
}
}
@@ -9081,6 +9725,24 @@ Server::process_request(Stream &strm, const std::string &remote_addr,
if (websocket_upgraded) { *websocket_upgraded = true; }
{
+#ifdef CPPHTTPLIB_SSL_ENABLED
+ if (req.ssl) {
+ // wss: the heartbeat ping thread and the read path enter the same
+ // TLS session from different threads. Hand the WebSocket a stream
+ // that serializes every TLS call, so the shared SSLSocketStream on
+ // the plain HTTP/HTTPS paths stays untouched.
+ auto ws_strm =
+ std::unique_ptr<Stream>(new detail::WebSocketSSLStream(
+ strm.socket(), const_cast<tls::session_t>(req.ssl),
+ CPPHTTPLIB_WEBSOCKET_READ_TIMEOUT_SECOND, 0,
+ write_timeout_sec_, write_timeout_usec_));
+ ws::WebSocket ws(std::move(ws_strm), req, true,
+ websocket_ping_interval_sec_,
+ websocket_max_missed_pongs_);
+ entry.handler(req, ws);
+ return true;
+ }
+#endif
// Use WebSocket-specific read timeout instead of HTTP timeout
strm.set_read_timeout(CPPHTTPLIB_WEBSOCKET_READ_TIMEOUT_SECOND, 0);
ws::WebSocket ws(strm, req, true, websocket_ping_interval_sec_,
@@ -9144,12 +9806,9 @@ Server::process_request(Stream &strm, const std::string &remote_addr,
path, file_extension_and_mimetype_map_, default_file_mimetype_);
}
- res.set_content_provider(
- mm->size(), content_type,
- [mm](size_t offset, size_t length, DataSink &sink) -> bool {
- sink.write(mm->data() + offset, length);
- return true;
- });
+ detail::set_file_content_provider(
+ res, mm, content_type,
+ static_file_encoding(req, content_type, mm->size()));
}
}
@@ -9174,7 +9833,7 @@ Server::process_request(Stream &strm, const std::string &remote_addr,
// consume the next request (issue #2450). If the response has committed the
// connection to close, there is no next request to protect.
if (!req.body_consumed_ && detail::has_framed_body(req)) {
- if (res.get_header_value("Connection") == "close") {
+ if (detail::has_header_token(res.headers, "Connection", "close")) {
connection_closed = true;
} else {
int dummy_status;
@@ -9190,7 +9849,7 @@ Server::process_request(Stream &strm, const std::string &remote_addr,
return ret;
}
-bool Server::is_valid() const { return true; }
+bool Server::is_valid() const { return !has_invalid_registration_; }
bool Server::process_and_close_socket(socket_t sock) {
std::string remote_addr;
@@ -9202,15 +9861,18 @@ bool Server::process_and_close_socket(socket_t sock) {
detail::get_local_ip_and_port(sock, local_addr, local_port);
bool websocket_upgraded = false;
- auto ret = detail::process_server_socket(
- svr_sock_, sock, keep_alive_max_count_, keep_alive_timeout_sec_,
- read_timeout_sec_, read_timeout_usec_, write_timeout_sec_,
- write_timeout_usec_,
- [&](Stream &strm, bool close_connection, bool &connection_closed) {
- return process_request(strm, remote_addr, remote_port, local_addr,
- local_port, close_connection, connection_closed,
- nullptr, &websocket_upgraded);
- });
+ auto ret = serve_guarded([&]() {
+ return detail::process_server_socket(
+ svr_sock_, sock, keep_alive_max_count_, keep_alive_timeout_sec_,
+ read_timeout_sec_, read_timeout_usec_, write_timeout_sec_,
+ write_timeout_usec_,
+ [&](Stream &strm, bool close_connection, bool &connection_closed) {
+ return process_request(strm, remote_addr, remote_port, local_addr,
+ local_port, close_connection,
+ connection_closed, nullptr,
+ &websocket_upgraded);
+ });
+ });
detail::drain_and_close_socket(sock);
return ret;
@@ -9736,7 +10398,8 @@ ClientImpl::open_stream(const std::string &method, const std::string &path,
handle.body_reader_.chunked =
detail::is_chunked_transfer_encoding(handle.response->headers);
- auto content_encoding = handle.response->get_header_value("Content-Encoding");
+ auto content_encoding = detail::get_combined_header_value(
+ handle.response->headers, "Content-Encoding");
if (!content_encoding.empty()) {
// Same policy as prepare_content_receiver(): reject a coding we know about
// but were not built with, pass an unrecognized one through as-is.
@@ -9958,7 +10621,7 @@ bool ClientImpl::handle_request(Stream &strm, Request &req,
if (!ret) { return false; }
- if (res.get_header_value("Connection") == "close" ||
+ if (detail::has_header_token(res.headers, "Connection", "close") ||
(res.version == "HTTP/1.0" && res.reason != "Connection established")) {
// NOTE: this requires a not-entirely-obvious chain of calls to be correct
// for this to be safe.
@@ -10437,6 +11100,7 @@ ClientImpl::send_with_content_provider_and_receiver(
if (content_provider) {
auto ok = true;
+ auto finished = false;
size_t offset = 0;
DataSink data_sink;
@@ -10460,13 +11124,27 @@ ClientImpl::send_with_content_provider_and_receiver(
return ok;
};
- while (ok && offset < content_length) {
+ // As in detail::write_content_with_progress(): the body is framed by
+ // content_length, so a provider that finishes early has truncated it.
+ // Stop and report that instead of calling the provider forever.
+ data_sink.done = [&]() { finished = true; };
+
+ while (ok && !finished && offset < content_length) {
if (!content_provider(offset, content_length - offset, data_sink)) {
error = Error::Canceled;
output_error_log(error, &req);
return nullptr;
}
}
+
+ // A short body here means either the provider stopped early or the
+ // compressor gave up. The branch below reports a failing compressor as
+ // Error::Compression, so keep the two distinguishable.
+ if (offset < content_length) {
+ error = ok ? Error::Write : Error::Compression;
+ output_error_log(error, &req);
+ return nullptr;
+ }
} else {
if (!compressor->compress(body, content_length, true,
[&](const char *data, size_t data_len) {
@@ -10564,7 +11242,8 @@ bool ClientImpl::process_request(Stream &strm, Request &req,
}
// Check for Expect: 100-continue
- auto expect_100_continue = req.get_header_value("Expect") == "100-continue";
+ auto expect_100_continue =
+ detail::has_header_token(req.headers, "Expect", "100-continue");
// Send request (skip body if using Expect: 100-continue)
auto write_request_success =
@@ -10768,6 +11447,9 @@ ContentProviderWithoutLength ClientImpl::get_multipart_content_provider(
DataSink cur_sink;
auto has_data = true;
cur_sink.write = sink.write;
+ // Forward is_writable so a provider item asking whether it may keep
+ // going gets the outer sink's answer rather than the default `true`.
+ cur_sink.is_writable = sink.is_writable;
cur_sink.done = [&]() { has_data = false; };
if (!provider_items[cur_item].provider(offset - cur_start, cur_sink)) {
@@ -12529,7 +13211,9 @@ SSLServer::~SSLServer() {
if (ctx_) { tls::free_context(ctx_); }
}
-bool SSLServer::is_valid() const { return ctx_ != nullptr; }
+bool SSLServer::is_valid() const {
+ return ctx_ != nullptr && Server::is_valid();
+}
bool SSLServer::process_and_close_socket(socket_t sock) {
using namespace tls;
@@ -12588,16 +13272,18 @@ bool SSLServer::process_and_close_socket(socket_t sock) {
int local_port = 0;
detail::get_local_ip_and_port(sock, local_addr, local_port);
- ret = detail::process_server_socket_ssl(
- svr_sock_, session, sock, keep_alive_max_count_, keep_alive_timeout_sec_,
- read_timeout_sec_, read_timeout_usec_, write_timeout_sec_,
- write_timeout_usec_,
- [&](Stream &strm, bool close_connection, bool &connection_closed) {
- return process_request(
- strm, remote_addr, remote_port, local_addr, local_port,
- close_connection, connection_closed,
- [&](Request &req) { req.ssl = session; }, &websocket_upgraded);
- });
+ ret = serve_guarded([&]() {
+ return detail::process_server_socket_ssl(
+ svr_sock_, session, sock, keep_alive_max_count_,
+ keep_alive_timeout_sec_, read_timeout_sec_, read_timeout_usec_,
+ write_timeout_sec_, write_timeout_usec_,
+ [&](Stream &strm, bool close_connection, bool &connection_closed) {
+ return process_request(
+ strm, remote_addr, remote_port, local_addr, local_port,
+ close_connection, connection_closed,
+ [&](Request &req) { req.ssl = session; }, &websocket_upgraded);
+ });
+ });
return ret;
}
@@ -16870,6 +17556,7 @@ bool WebSocket::send_frame(Opcode op, const char *data, size_t len,
}
ReadResult WebSocket::read(std::string &msg) {
+ std::unique_lock<std::mutex> read_lock(read_mutex_);
while (!closed_) {
Opcode opcode;
std::string payload;
@@ -16955,6 +17642,9 @@ ReadResult WebSocket::read(std::string &msg) {
}
// RFC 6455 Section 5.6: text frames must contain valid UTF-8
if (result == Text && !impl::is_valid_utf8(msg)) {
+ // close() takes the read lock to wait for the peer's Close reply, so
+ // it must not run while this thread still holds it.
+ read_lock.unlock();
close(CloseStatus::InvalidPayload, "invalid UTF-8");
return Fail;
}
@@ -16991,9 +17681,18 @@ void WebSocket::close(CloseStatus status, const std::string &reason) {
}
// RFC 6455 Section 7.1.1: after sending a Close frame, wait for the peer's
- // Close response before closing the TCP connection. Use a short timeout to
- // avoid hanging if the peer doesn't respond.
+ // Close response before closing the TCP connection.
+ //
+ // Wait only when no other thread is parsing frames. When one is, it is the
+ // thread positioned to see the peer's reply, and reading here would take
+ // bytes out of the message it is assembling. Bailing out also leaves the
+ // stream, including its read timeout, entirely to that thread.
+ std::unique_lock<std::mutex> read_lock(read_mutex_, std::try_to_lock);
+ if (!read_lock.owns_lock()) { return; }
+
+ // Use a short timeout to avoid hanging if the peer doesn't respond.
strm_.set_read_timeout(CPPHTTPLIB_WEBSOCKET_CLOSE_TIMEOUT_SECOND, 0);
+
Opcode op;
std::string resp;
bool fin;
@@ -17171,7 +17870,7 @@ bool WebSocketClient::create_stream(std::unique_ptr<Stream> &strm,
return false;
}
- strm = std::unique_ptr<Stream>(new detail::SSLSocketStream(
+ strm = std::unique_ptr<Stream>(new detail::WebSocketSSLStream(
sock_, tls_session_, read_timeout_sec_, read_timeout_usec_,
write_timeout_sec_, write_timeout_usec_));
return true;
diff --git a/vendor/cpp-httplib/httplib.h b/vendor/cpp-httplib/httplib.h
index 6fc86c7c75..ca7c96a41a 100644
--- a/vendor/cpp-httplib/httplib.h
+++ b/vendor/cpp-httplib/httplib.h
@@ -8,8 +8,8 @@
#ifndef CPPHTTPLIB_HTTPLIB_H
#define CPPHTTPLIB_HTTPLIB_H
-#define CPPHTTPLIB_VERSION "0.53.1"
-#define CPPHTTPLIB_VERSION_NUM "0x003501"
+#define CPPHTTPLIB_VERSION "0.54.1"
+#define CPPHTTPLIB_VERSION_NUM "0x003601"
#ifdef _WIN32
#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0A00
@@ -134,6 +134,16 @@
#define CPPHTTPLIB_FORM_URL_ENCODED_PAYLOAD_MAX_LENGTH 8192
#endif
+#ifndef CPPHTTPLIB_STATIC_FILE_COMPRESSION_MIN_LENGTH
+// 1400 rather than a round number: a body that already fits in one 1500-byte
+// MTU gains nothing from being made smaller.
+#define CPPHTTPLIB_STATIC_FILE_COMPRESSION_MIN_LENGTH 1400
+#endif
+
+#ifndef CPPHTTPLIB_STATIC_FILE_COMPRESSION_MAX_LENGTH
+#define CPPHTTPLIB_STATIC_FILE_COMPRESSION_MAX_LENGTH (4 * 1024 * 1024) // 4MB
+#endif
+
#ifndef CPPHTTPLIB_RANGE_MAX_COUNT
#define CPPHTTPLIB_RANGE_MAX_COUNT 1024
#endif
@@ -1429,9 +1439,16 @@ public:
DataSink &operator=(DataSink &&) = delete;
std::function<bool(const char *data, size_t data_len)> write;
- std::function<bool()> is_writable;
- std::function<void()> done;
- std::function<void(const Headers &trailer)> done_with_trailer;
+
+ // Only `write` is mandatory. The rest are defaulted so that a provider
+ // calling one on a writer that does not set it gets sensible behaviour
+ // rather than std::bad_function_call thrown from a worker thread. Capturing
+ // `this` is safe: DataSink is neither copyable nor movable.
+ std::function<bool()> is_writable = []() { return true; };
+ std::function<void()> done = []() {};
+ std::function<void(const Headers &trailer)> done_with_trailer =
+ [this](const Headers & /*trailer*/) { done(); };
+
std::ostream os;
private:
@@ -1516,7 +1533,10 @@ make_file_body(const std::string &filepath) {
auto to_read = (std::min)(sizeof(buf), length);
f.read(buf, static_cast<std::streamsize>(to_read));
auto n = static_cast<size_t>(f.gcount());
- if (n == 0) { break; }
+ // The file is shorter than the size make_file_body() measured, which the
+ // caller has already committed to as Content-Length. The body cannot be
+ // completed, so fail as every other error here does.
+ if (n == 0) { return false; }
if (!sink.write(buf, n)) { return false; }
length -= n;
}
@@ -1723,6 +1743,14 @@ struct Request {
#endif
};
+namespace detail {
+
+// Declared up here, away from the rest of the compression helpers, because
+// `Response` stores one.
+enum class EncodingType { None = 0, Gzip, Brotli, Zstd };
+
+} // namespace detail
+
struct Response {
std::string version;
int status = -1;
@@ -1788,6 +1816,11 @@ struct Response {
bool content_provider_success_ = false;
std::string file_content_path_;
std::string file_content_content_type_;
+
+ // Content coding chosen for a file-backed content provider, decided once
+ // where the file is opened so that the ETag and the body cannot disagree.
+ // `EncodingType::None` for every other kind of response.
+ detail::EncodingType file_content_encoding_ = detail::EncodingType::None;
};
enum class Error {
@@ -1827,6 +1860,7 @@ enum class Error {
InvalidRangeHeader,
UnsupportedContentEncoding,
WebSocketHandshake,
+ UserCallbackException,
// For internal use only
SSLPeerCouldBeClosed_,
@@ -2020,6 +2054,10 @@ private:
int close_socket(socket_t sock) noexcept;
+bool is_accept_resource_error();
+
+bool is_accept_transient_error();
+
ssize_t write_headers(Stream &strm, const Headers &headers);
bool set_socket_opt_time(socket_t sock, int level, int optname, time_t sec,
@@ -2107,6 +2145,17 @@ public:
Server &Delete(const std::string &pattern, HandlerWithContentReader handler);
Server &Options(const std::string &pattern, Handler handler);
+ // Register a handler for an HTTP method outside the built-in set (e.g. the
+ // WebDAV methods from RFC 4918). Registering a method here is what makes the
+ // server accept it; an unregistered method is still rejected with 400.
+ // `method` must be a valid HTTP method token and must not be one of the
+ // built-in methods, which have their own registration functions above. A
+ // rejected registration makes is_valid() return false, so listen() fails.
+ Server &CustomRoute(const std::string &method, const std::string &pattern,
+ Handler handler);
+ Server &CustomRoute(const std::string &method, const std::string &pattern,
+ HandlerWithContentReader handler);
+
Server &WebSocket(const std::string &pattern, WebSocketHandler handler);
Server &WebSocket(const std::string &pattern, WebSocketHandler handler,
SubProtocolSelector sub_protocol_selector);
@@ -2174,6 +2223,10 @@ public:
Server &set_payload_max_length(size_t length);
+ Server &set_static_file_compression(bool on);
+ Server &set_static_file_compression_min_length(size_t length);
+ Server &set_static_file_compression_max_length(size_t length);
+
Server &set_websocket_ping_interval(time_t sec);
template <class Rep, class Period>
Server &set_websocket_ping_interval(
@@ -2202,6 +2255,35 @@ protected:
const std::function<void(Request &)> &setup_request,
bool *websocket_upgraded = nullptr);
+ // Runs the per-connection serving loop and stops an exception thrown by a
+ // user callback from escaping the worker thread.
+ //
+ // process_request() wraps only routing() in a try/catch. Content providers,
+ // the post-routing, error, logging and expect-100 handlers and WebSocket
+ // handlers all run outside it, and the task queue calls the job without a
+ // catch, so an exception from any of those would terminate the process.
+ //
+ // No 500 is possible here: by the time a content provider runs, the status
+ // line and headers are already on the wire. Report it through the error
+ // logger and drop the connection, which is what the peer observes either
+ // way. Other connections are unaffected.
+ template <typename Serve> bool serve_guarded(Serve &&serve) const {
+#ifdef CPPHTTPLIB_NO_EXCEPTIONS
+ return serve();
+#else
+ try {
+ return serve();
+ } catch (...) {
+ // The error logger is a user callback too, so it must not be able to
+ // throw the guard back open.
+ try {
+ output_error_log(Error::UserCallbackException, nullptr);
+ } catch (...) {}
+ return false;
+ }
+#endif
+ }
+
std::atomic<socket_t> svr_sock_{INVALID_SOCKET};
std::vector<std::string> trusted_proxies_;
@@ -2215,6 +2297,11 @@ protected:
time_t idle_interval_sec_ = CPPHTTPLIB_IDLE_INTERVAL_SECOND;
time_t idle_interval_usec_ = CPPHTTPLIB_IDLE_INTERVAL_USECOND;
size_t payload_max_length_ = CPPHTTPLIB_PAYLOAD_MAX_LENGTH;
+ bool static_file_compression_ = false;
+ size_t static_file_compression_min_length_ =
+ CPPHTTPLIB_STATIC_FILE_COMPRESSION_MIN_LENGTH;
+ size_t static_file_compression_max_length_ =
+ CPPHTTPLIB_STATIC_FILE_COMPRESSION_MAX_LENGTH;
time_t websocket_ping_interval_sec_ =
CPPHTTPLIB_WEBSOCKET_PING_INTERVAL_SECOND;
int websocket_max_missed_pongs_ = CPPHTTPLIB_WEBSOCKET_MAX_MISSED_PONGS;
@@ -2226,9 +2313,21 @@ private:
std::vector<std::pair<std::unique_ptr<detail::MatcherBase>,
HandlerWithContentReader>>;
+ // Both handler tables for one custom method live in a single entry, so that
+ // routing() needs only one map lookup per request to reach either of them.
+ struct CustomHandlerEntry {
+ Handlers handlers;
+ HandlersForContentReader handlers_for_content_reader;
+ };
+ using CustomHandlers = std::map<std::string, CustomHandlerEntry>;
+
static std::unique_ptr<detail::MatcherBase>
make_matcher(const std::string &pattern);
+ static const std::set<std::string> &builtin_methods();
+ CustomHandlerEntry *custom_entry_for_registration(const std::string &method);
+ const CustomHandlerEntry *find_custom_entry(const std::string &method) const;
+
template <typename H>
Server &add_handler(
std::vector<std::pair<std::unique_ptr<detail::MatcherBase>, H>> &handlers,
@@ -2259,6 +2358,10 @@ private:
const HandlersForContentReader &handlers) const;
bool parse_request_line(const char *s, Request &req) const;
+ detail::EncodingType static_file_encoding(const Request &req,
+ const std::string &content_type,
+ size_t length) const;
+ bool apply_static_file_compression(const Request &req, Response &res) const;
void apply_ranges(const Request &req, Response &res,
std::string &content_type, std::string &boundary) const;
bool write_response(Stream &strm, bool close_connection, Request &req,
@@ -2292,6 +2395,10 @@ private:
std::atomic<bool> is_running_{false};
std::atomic<bool> is_decommissioned{false};
+ // Set when CustomRoute() refuses a registration. Written before listen(),
+ // read by is_valid() on the same thread, so it needs no synchronization.
+ bool has_invalid_registration_ = false;
+
struct MountPointEntry {
std::string mount_point;
std::string base_dir;
@@ -2313,6 +2420,7 @@ private:
Handlers delete_handlers_;
HandlersForContentReader delete_handlers_for_content_reader_;
Handlers options_handlers_;
+ CustomHandlers custom_handlers_;
struct WebSocketHandlerEntry {
std::unique_ptr<detail::MatcherBase> matcher;
@@ -3500,6 +3608,16 @@ void split(const char *b, const char *e, char d,
void split(const char *b, const char *e, char d, size_t m,
std::function<void(const char *, const char *)> fn);
+bool split_find(const char *b, const char *e, char d,
+ std::function<bool(const char *, const char *)> fn);
+
+bool has_header_token(const Headers &headers, const std::string &key,
+ const std::string &token);
+
+std::string websocket_accept_key(const std::string &client_key);
+
+bool is_websocket_upgrade(const Request &req);
+
bool process_client_socket(
socket_t sock, time_t read_timeout_sec, time_t read_timeout_usec,
time_t write_timeout_sec, time_t write_timeout_usec,
@@ -3520,6 +3638,9 @@ socket_t create_client_socket(const std::string &host, const std::string &ip,
const char *get_header_value(const Headers &headers, const std::string &key,
const char *def, size_t id);
+std::string get_combined_header_value(const Headers &headers,
+ const std::string &key);
+
std::string params_to_query_str(const Params &params);
void parse_query_text(const char *data, std::size_t size, Params &params);
@@ -3534,11 +3655,13 @@ bool parse_range_header(const std::string &s, Ranges &ranges);
bool parse_accept_header(const std::string &s,
std::vector<std::string> &content_types);
+void parse_disposition_params(const std::string &s, Params &params);
+
ssize_t send_socket(socket_t sock, const void *ptr, size_t size, int flags);
ssize_t read_socket(socket_t sock, void *ptr, size_t size, int flags);
-enum class EncodingType { None = 0, Gzip, Brotli, Zstd };
+EncodingType encoding_type(const Request &req, const std::string &content_type);
EncodingType encoding_type(const Request &req, const Response &res);
@@ -4318,6 +4441,11 @@ private:
int unacked_pings_ = 0;
std::atomic<bool> closed_{false};
std::mutex write_mutex_;
+ // Owned by whichever thread is parsing frames off strm_. Only one thread
+ // may do so: read_websocket_frame() reads a payload until it has the whole
+ // declared length, so a second parser stealing bytes silently corrupts the
+ // message the first one is assembling.
+ std::mutex read_mutex_;
std::thread ping_thread_;
std::mutex ping_mutex_;
std::condition_variable ping_cv_;