LLM inference in C/C++
C++ ggml
vendor : update cpp-httplib to 0.51.0 (#26067)
Adrien Gallouët720d7fa4097f
diff --git a/scripts/sync_vendor.py b/scripts/sync_vendor.pyindex a9343e37c1..679e557a32 100755--- a/scripts/sync_vendor.py+++ b/scripts/sync_vendor.py@@ -5,7 +5,7 @@ import osimport sysimport subprocess-HTTPLIB_VERSION = "refs/tags/v0.50.1"+HTTPLIB_VERSION = "refs/tags/v0.51.0"vendor = {"https://github.com/nlohmann/json/releases/latest/download/json.hpp": "vendor/nlohmann/json.hpp",diff --git a/vendor/cpp-httplib/httplib.cpp b/vendor/cpp-httplib/httplib.cppindex e58fb3eea6..1551796387 100644--- a/vendor/cpp-httplib/httplib.cpp+++ b/vendor/cpp-httplib/httplib.cpp@@ -3161,9 +3161,7 @@ get_multimap_value(const Map &m, const std::string &key, size_t id) {void set_header(Headers &headers, const std::string &key,const std::string &val) {- if (fields::is_field_name(key) && fields::is_field_value(val)) {- headers.emplace(key, val);- }+ if (fields::is_field_valid(key, val)) { headers.emplace(key, val); }}bool read_headers(Stream &strm, Headers &headers) {@@ -3370,8 +3368,46 @@ ReadContentResult read_content_chunked(Stream &strm, T &x,}bool is_chunked_transfer_encoding(const Headers &headers) {- return case_ignore::equal(- get_header_value(headers, "Transfer-Encoding", "", 0), "chunked");+ // RFC 9112 6.1: a message is framed with the chunked coding when "chunked"+ // is the final transfer coding. A single field value may list several+ // codings ("gzip, chunked"), and the list may be split across multiple+ // Transfer-Encoding header lines (RFC 9110 5.3). Match the last coding token+ // case-insensitively rather than comparing the whole value against "chunked".+ //+ // Security: reading a chunked message as unframed leaves its body in the+ // socket, where a keep-alive connection parses it as a smuggled request.+ // Headers is an unordered_multimap whose iteration order for duplicate keys+ // is not portable, so when there is more than one Transfer-Encoding line we+ // cannot tell which coding is truly final. In that ambiguous case we fail+ // safe by treating the message as chunked (a mis-parse just closes the+ // connection, whereas the opposite error enables smuggling).+ auto rng = headers.equal_range("Transfer-Encoding");++ size_t line_count = 0;+ bool chunked_present = false;+ bool last_line_ends_with_chunked = false;++ for (auto it = rng.first; it != rng.second; ++it) {+ line_count++;+ const auto &value = it->second;++ std::string last_coding;+ bool line_has_chunked = false;+ split(value.data(), value.data() + value.size(), ',',+ [&](const char *b, const char *e) {+ last_coding.assign(b, e);+ if (case_ignore::equal(last_coding, "chunked")) {+ line_has_chunked = true;+ }+ });++ if (line_has_chunked) { chunked_present = true; }+ last_line_ends_with_chunked = case_ignore::equal(last_coding, "chunked");+ }++ if (line_count == 0) { return false; }+ if (line_count == 1) { return last_line_ends_with_chunked; }+ return chunked_present;}template <typename T, typename U>@@ -3488,6 +3524,13 @@ bool read_content(Stream &strm, T &x, size_t payload_max_length, int &status,ssize_t write_request_line(Stream &strm, const std::string &method,const std::string &path) {+ // A request target must not carry CR/LF (or other control octets); otherwise+ // a value smuggled into it splits the request line and injects headers or a+ // whole request. The same field-value check already guards header values in+ // check_and_write_headers and the request target in+ // perform_websocket_handshake; apply it here too.+ if (!fields::is_field_value(path)) { return -1; }+std::string s = method;s += ' ';s += path;@@ -3507,6 +3550,13 @@ ssize_t write_response_line(Stream &strm, int status) {ssize_t write_headers(Stream &strm, const Headers &headers) {ssize_t write_len = 0;for (const auto &x : headers) {+ // Skip fields with invalid names or values to prevent response splitting+ // via CR/LF injection, matching set_header(). The client validates request+ // headers up front in check_and_write_headers, but the server passes+ // res.headers straight to this writer, and res.headers is a public field+ // an application can populate directly with request-derived values.+ if (!fields::is_field_valid(x.first, x.second)) { continue; }+std::string s;s = x.first;s += ": ";@@ -3707,10 +3757,7 @@ write_content_chunked(Stream &strm, const ContentProvider &content_provider,for (const auto &kv : *trailer) {// Skip fields with invalid names or values to prevent response// splitting via CR/LF injection, matching set_header().- if (!fields::is_field_name(kv.first) ||- !fields::is_field_value(kv.second)) {- continue;- }+ if (!fields::is_field_valid(kv.first, kv.second)) { continue; }std::string field_line = kv.first + ": " + kv.second + "\r\n";if (!write_data(strm, field_line.data(), field_line.size())) {ok = false;@@ -4079,6 +4126,13 @@ public:break;}+ // Check header count limit+ if (header_count_ >= CPPHTTPLIB_HEADER_MAX_COUNT) {+ is_valid_ = false;+ return false;+ }+ header_count_++;+const auto header = buf_head(pos);if (!parse_header(header.data(), header.data() + header.size(),@@ -4194,6 +4248,7 @@ private:file_.filename.clear();file_.content_type.clear();file_.headers.clear();+ header_count_ = 0;}bool start_with_case_ignore(const std::string &a, const char *b,@@ -4247,6 +4302,7 @@ private:size_t state_ = 0;bool is_valid_ = false;FormData file_;+ size_t header_count_ = 0;// Bufferbool start_with(const std::string &a, size_t spos, size_t epos,@@ -4907,6 +4963,10 @@ bool is_field_content(const std::string &s) {bool is_field_value(const std::string &s) { return is_field_content(s); }+bool is_field_valid(const std::string &name, const std::string &value) {+ return is_field_name(name) && is_field_value(value);+}+} // namespace fieldsbool perform_websocket_handshake(Stream &strm, const std::string &host,@@ -4921,9 +4981,7 @@ bool perform_websocket_handshake(Stream &strm, const std::string &host,// Validate user-provided headersfor (const auto &h : headers) {- if (!fields::is_field_name(h.first) || !fields::is_field_value(h.second)) {- return false;- }+ if (!fields::is_field_valid(h.first, h.second)) { return false; }}// Generate random Sec-WebSocket-Key@@ -5042,9 +5100,31 @@ std::string hash_to_hex(const unsigned char (&hash)[N]) {}} // namespace+#ifdef CPPHTTPLIB_MBEDTLS_V4+// Mbed TLS 4.x provides hashing (and TLS RNG) via PSA Crypto, which must be+// initialized once. PSA state is process-global; do not free it.+bool ensure_mbedtls_psa_crypto() {+ static std::once_flag once;+ static bool ok = false;+ std::call_once(once, []() { ok = (psa_crypto_init() == PSA_SUCCESS); });+ return ok;+}++bool psa_hash(psa_algorithm_t alg, const std::string &s,+ unsigned char *out, size_t out_size) {+ if (!ensure_mbedtls_psa_crypto()) { return false; }+ size_t olen = 0;+ return psa_hash_compute(alg, reinterpret_cast<const uint8_t *>(s.data()),+ s.size(), out, out_size, &olen) == PSA_SUCCESS &&+ olen == out_size;+}+#endif+std::string MD5(const std::string &s) {unsigned char hash[16];-#ifdef CPPHTTPLIB_MBEDTLS_V3+#ifdef CPPHTTPLIB_MBEDTLS_V4+ if (!psa_hash(PSA_ALG_MD5, s, hash, sizeof(hash))) { return {}; }+#elif defined(CPPHTTPLIB_MBEDTLS_V3)mbedtls_md5(reinterpret_cast<const unsigned char *>(s.c_str()), s.size(),hash);#else@@ -5056,7 +5136,9 @@ std::string MD5(const std::string &s) {std::string SHA_256(const std::string &s) {unsigned char hash[32];-#ifdef CPPHTTPLIB_MBEDTLS_V3+#ifdef CPPHTTPLIB_MBEDTLS_V4+ if (!psa_hash(PSA_ALG_SHA_256, s, hash, sizeof(hash))) { return {}; }+#elif defined(CPPHTTPLIB_MBEDTLS_V3)mbedtls_sha256(reinterpret_cast<const unsigned char *>(s.c_str()), s.size(),hash, 0);#else@@ -5068,7 +5150,9 @@ std::string SHA_256(const std::string &s) {std::string SHA_512(const std::string &s) {unsigned char hash[64];-#ifdef CPPHTTPLIB_MBEDTLS_V3+#ifdef CPPHTTPLIB_MBEDTLS_V4+ if (!psa_hash(PSA_ALG_SHA_512, s, hash, sizeof(hash))) { return {}; }+#elif defined(CPPHTTPLIB_MBEDTLS_V3)mbedtls_sha512(reinterpret_cast<const unsigned char *>(s.c_str()), s.size(),hash, 0);#else@@ -6949,8 +7033,7 @@ template <typename T>bool check_and_write_headers(Stream &strm, Headers &headers,T header_writer, Error &error) {for (const auto &h : headers) {- if (!detail::fields::is_field_name(h.first) ||- !detail::fields::is_field_value(h.second)) {+ if (!detail::fields::is_field_valid(h.first, h.second)) {error = Error::InvalidHeaders;return false;}@@ -8348,25 +8431,25 @@ get_client_ip(const std::string &x_forwarded_for,// caller can fall back to the connection-level remote address.if (ip_list.empty()) { return std::string(); }- for (size_t i = 0; i < ip_list.size(); ++i) {- auto ip = ip_list[i];+ // Each hop appends the address it received the request from, so the rightmost+ // entries are the ones written by our own infrastructure while the leftmost+ // are whatever the original client chose to send. Walk from the right and+ // skip trusted proxies; the first address that is not a trusted proxy is the+ // furthest point still attributable to a real hop, i.e. the client. Scanning+ // from the left instead lets a client forge an arbitrary address by following+ // it with a trusted proxy's address, which the left-to-right scan then+ // returned as the client.+ for (size_t i = ip_list.size(); i-- > 0;) {+ const auto &ip = ip_list[i];auto is_trusted_proxy =std::any_of(trusted_proxies.begin(), trusted_proxies.end(),[&](const std::string &proxy) { return ip == proxy; });- if (is_trusted_proxy) {- if (i == 0) {- // If the trusted proxy is the first IP, there's no preceding client IP- return ip;- } else {- // Return the IP immediately before the trusted proxy- return ip_list[i - 1];- }- }+ if (!is_trusted_proxy) { return ip; }}- // If no trusted proxy is found, return the first IP in the list+ // Every hop was a trusted proxy; fall back to the first entry.return ip_list.front();}@@ -8436,7 +8519,14 @@ Server::process_request(Stream &strm, const std::string &remote_addr,connection_closed = true;}- if (!trusted_proxies_.empty() && req.has_header("X-Forwarded-For")) {+ // Only honor X-Forwarded-For if the peer on the actual TCP connection is+ // itself a trusted proxy. Otherwise any direct client could spoof+ // remote_addr simply by sending an arbitrary X-Forwarded-For header.+ auto is_trusted_peer = std::any_of(+ trusted_proxies_.begin(), trusted_proxies_.end(),+ [&](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");auto derived = get_client_ip(x_forwarded_for, trusted_proxies_);req.remote_addr = derived.empty() ? remote_addr : derived;@@ -8643,13 +8733,19 @@ Server::process_request(Stream &strm, const std::string &remote_addr,// Drain any unconsumed framed body to prevent request smuggling on// keep-alive. Without framing there is no body to drain — reading would- // consume the next request (issue #2450).+ // 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)) {- int dummy_status;- if (!detail::read_content(- strm, req, payload_max_length_, dummy_status, nullptr,- [](const char *, size_t, size_t, size_t) { return true; }, false)) {+ if (res.get_header_value("Connection") == "close") {connection_closed = true;+ } else {+ int dummy_status;+ if (!detail::read_content(+ strm, req, payload_max_length_, dummy_status, nullptr,+ [](const char *, size_t, size_t, size_t) { return true; },+ false)) {+ connection_closed = true;+ }}}@@ -9210,9 +9306,8 @@ ClientImpl::open_stream(const std::string &method, const std::string &path,handle.body_reader_.content_length = content_length;}- auto transfer_encoding =- handle.response->get_header_value("Transfer-Encoding");- handle.body_reader_.chunked = (transfer_encoding == "chunked");+ handle.body_reader_.chunked =+ detail::is_chunked_transfer_encoding(handle.response->headers);auto content_encoding = handle.response->get_header_value("Content-Encoding");if (!content_encoding.empty()) {@@ -9541,8 +9636,8 @@ bool ClientImpl::create_redirect_client(// Clean up request headers that are host/client specific// Remove headers that should not be carried over to new host- auto headers_to_remove =- std::vector<std::string>{"Host", "Proxy-Authorization", "Authorization"};+ auto headers_to_remove = std::vector<std::string>{+ "Host", "Proxy-Authorization", "Authorization", "Cookie", "Cookie2"};for (const auto &header_name : headers_to_remove) {auto it = req.headers.find(header_name);@@ -9796,7 +9891,14 @@ bool ClientImpl::write_request(Stream &strm, Request &req,}// Write request line and headers- detail::write_request_line(bstrm, req.method, path_with_query);+ if (detail::write_request_line(bstrm, req.method, path_with_query) < 0) {+ // A rejected target (e.g. CR/LF smuggled in via a decoded redirect+ // Location under set_path_encode(false)) must fail the request cleanly+ // instead of emitting a request-line-less, header-injecting request.+ error = Error::Write;+ output_error_log(error, &req);+ return false;+ }if (!detail::check_and_write_headers(bstrm, req.headers, header_writer_,error)) {output_error_log(error, &req);@@ -13893,6 +13995,13 @@ struct MbedTlsSession {std::string hostname; // For client: set via set_snistd::string sni_hostname; // For server: received from client via SNI callback+ // Mbed TLS has no SSL_peek() equivalent, so is_peer_closed() must probe with+ // a real 1-byte mbedtls_ssl_read(). If that probe lands on application data+ // (e.g. a response that arrived while this side was still in its post-write+ // check), the byte is pushed back here and served by the next read().+ unsigned char peeked_byte = 0;+ bool has_peeked_byte = false;+MbedTlsSession() { mbedtls_ssl_init(&ssl); }~MbedTlsSession() { mbedtls_ssl_free(&ssl); }@@ -13927,6 +14036,20 @@ ErrorCode map_mbedtls_error(int ret, int &out_errno) {return ErrorCode::Fatal;}+// A TLS 1.3 NewSessionTicket (signaled by default on Mbed TLS 4.x) is a+// non-fatal notification delivered between records, not an error and not+// application data, so I/O calls that see it should just be retried. Kept in+// one helper so the retry loops keep an intact "do { } while (...)" instead of+// splitting the closing brace across an #if.+bool mbedtls_is_session_ticket(int ret) {+#if defined(MBEDTLS_ERR_SSL_RECEIVED_NEW_SESSION_TICKET)+ return ret == MBEDTLS_ERR_SSL_RECEIVED_NEW_SESSION_TICKET;+#else+ (void)ret;+ return false;+#endif+}+// BIO-like send callback for Mbed TLSint mbedtls_net_send_cb(void *ctx, const unsigned char *buf,size_t len) {@@ -13978,8 +14101,10 @@ int mbedtls_net_recv_cb(void *ctx, unsigned char *buf, size_t len) {// MbedTlsContext constructor/destructor implementationsMbedTlsContext::MbedTlsContext() {mbedtls_ssl_config_init(&conf);+#ifndef CPPHTTPLIB_MBEDTLS_V4mbedtls_entropy_init(&entropy);mbedtls_ctr_drbg_init(&ctr_drbg);+#endifmbedtls_x509_crt_init(&ca_chain);mbedtls_x509_crt_init(&own_cert);mbedtls_pk_init(&own_key);@@ -13989,8 +14114,10 @@ MbedTlsContext::~MbedTlsContext() {mbedtls_pk_free(&own_key);mbedtls_x509_crt_free(&own_cert);mbedtls_x509_crt_free(&ca_chain);+#ifndef CPPHTTPLIB_MBEDTLS_V4mbedtls_ctr_drbg_free(&ctr_drbg);mbedtls_entropy_free(&entropy);+#endifmbedtls_ssl_config_free(&conf);}@@ -14064,6 +14191,14 @@ ctx_t create_client_context() {ctx->is_server = false;+#ifdef CPPHTTPLIB_MBEDTLS_V4+ // Mbed TLS 4.x draws randomness from PSA Crypto; just ensure it is ready.+ if (!detail::ensure_mbedtls_psa_crypto()) {+ delete ctx;+ return nullptr;+ }+ int ret;+#else// Seed the random number generatorconst char *pers = "httplib_client";int ret = mbedtls_ctr_drbg_seed(@@ -14074,6 +14209,7 @@ ctx_t create_client_context() {delete ctx;return nullptr;}+#endif// Set up SSL config for clientret = mbedtls_ssl_config_defaults(&ctx->conf, MBEDTLS_SSL_IS_CLIENT,@@ -14085,8 +14221,10 @@ ctx_t create_client_context() {return nullptr;}- // Set random number generator+#ifndef CPPHTTPLIB_MBEDTLS_V4+ // Set random number generator (Mbed TLS 4.x uses the PSA RNG implicitly)mbedtls_ssl_conf_rng(&ctx->conf, mbedtls_ctr_drbg_random, &ctx->ctr_drbg);+#endif// Default: verify peer certificatembedtls_ssl_conf_authmode(&ctx->conf, MBEDTLS_SSL_VERIFY_REQUIRED);@@ -14108,6 +14246,14 @@ ctx_t create_server_context() {ctx->is_server = true;+#ifdef CPPHTTPLIB_MBEDTLS_V4+ // Mbed TLS 4.x draws randomness from PSA Crypto; just ensure it is ready.+ if (!detail::ensure_mbedtls_psa_crypto()) {+ delete ctx;+ return nullptr;+ }+ int ret;+#else// Seed the random number generatorconst char *pers = "httplib_server";int ret = mbedtls_ctr_drbg_seed(@@ -14118,6 +14264,7 @@ ctx_t create_server_context() {delete ctx;return nullptr;}+#endif// Set up SSL config for serverret = mbedtls_ssl_config_defaults(&ctx->conf, MBEDTLS_SSL_IS_SERVER,@@ -14129,8 +14276,10 @@ ctx_t create_server_context() {return nullptr;}- // Set random number generator+#ifndef CPPHTTPLIB_MBEDTLS_V4+ // Set random number generator (Mbed TLS 4.x uses the PSA RNG implicitly)mbedtls_ssl_conf_rng(&ctx->conf, mbedtls_ctr_drbg_random, &ctx->ctr_drbg);+#endif// Default: don't verify clientmbedtls_ssl_conf_authmode(&ctx->conf, MBEDTLS_SSL_VERIFY_NONE);@@ -14290,7 +14439,7 @@ bool set_client_cert_pem(ctx_t ctx, const char *cert, const char *key,password ? reinterpret_cast<const unsigned char *>(password) : nullptr;size_t pwd_len = password ? strlen(password) : 0;-#ifdef CPPHTTPLIB_MBEDTLS_V3+#if defined(CPPHTTPLIB_MBEDTLS_V3) && !defined(CPPHTTPLIB_MBEDTLS_V4)ret = mbedtls_pk_parse_key(&mctx->own_key, reinterpret_cast<const unsigned char *>(key_str.c_str()),key_str.size() + 1, pwd, pwd_len, mbedtls_ctr_drbg_random,@@ -14305,7 +14454,10 @@ bool set_client_cert_pem(ctx_t ctx, const char *cert, const char *key,return false;}- // Verify that the certificate and private key match+ // Verify that the certificate and private key match.+ // Mbed TLS 4.x: mbedtls_pk_check_pair() reports a spurious mismatch for+ // PSA-backed keys, so skip it and let the handshake surface a real mismatch.+#ifndef CPPHTTPLIB_MBEDTLS_V4#ifdef CPPHTTPLIB_MBEDTLS_V3ret = mbedtls_pk_check_pair(&mctx->own_cert.pk, &mctx->own_key,mbedtls_ctr_drbg_random, &mctx->ctr_drbg);@@ -14316,6 +14468,7 @@ bool set_client_cert_pem(ctx_t ctx, const char *cert, const char *key,impl::mbedtls_last_error() = ret;return false;}+#endifret = mbedtls_ssl_conf_own_cert(&mctx->conf, &mctx->own_cert, &mctx->own_key);if (ret != 0) {@@ -14339,7 +14492,7 @@ bool set_client_cert_file(ctx_t ctx, const char *cert_path,}// Parse private key file-#ifdef CPPHTTPLIB_MBEDTLS_V3+#if defined(CPPHTTPLIB_MBEDTLS_V3) && !defined(CPPHTTPLIB_MBEDTLS_V4)ret = mbedtls_pk_parse_keyfile(&mctx->own_key, key_path, password,mbedtls_ctr_drbg_random, &mctx->ctr_drbg);#else@@ -14350,7 +14503,9 @@ bool set_client_cert_file(ctx_t ctx, const char *cert_path,return false;}- // Verify that the certificate and private key match+ // Verify that the certificate and private key match.+ // Mbed TLS 4.x: see set_client_cert() — skip the spurious check_pair.+#ifndef CPPHTTPLIB_MBEDTLS_V4#ifdef CPPHTTPLIB_MBEDTLS_V3ret = mbedtls_pk_check_pair(&mctx->own_cert.pk, &mctx->own_key,mbedtls_ctr_drbg_random, &mctx->ctr_drbg);@@ -14361,6 +14516,7 @@ bool set_client_cert_file(ctx_t ctx, const char *cert_path,impl::mbedtls_last_error() = ret;return false;}+#endifret = mbedtls_ssl_conf_own_cert(&mctx->conf, &mctx->own_cert, &mctx->own_key);if (ret != 0) {@@ -14455,7 +14611,10 @@ TlsError connect(session_t session) {}auto msession = static_cast<impl::MbedTlsSession *>(session);- int ret = mbedtls_ssl_handshake(&msession->ssl);+ int ret;+ do {+ ret = mbedtls_ssl_handshake(&msession->ssl);+ } while (impl::mbedtls_is_session_ticket(ret));if (ret == 0) {err.code = ErrorCode::Success;@@ -14499,6 +14658,8 @@ bool connect_nonblocking(session_t session, socket_t sock,int ret;while ((ret = mbedtls_ssl_handshake(&msession->ssl)) != 0) {+ // Non-fatal TLS 1.3 ticket; retry immediately.+ if (impl::mbedtls_is_session_ticket(ret)) { continue; }if (ret == MBEDTLS_ERR_SSL_WANT_READ) {if (detail::select_read(sock, timeout_sec, timeout_usec) > 0) {continue;@@ -14546,8 +14707,28 @@ ssize_t read(session_t session, void *buf, size_t len, TlsError &err) {}auto msession = static_cast<impl::MbedTlsSession *>(session);- int ret =- mbedtls_ssl_read(&msession->ssl, static_cast<unsigned char *>(buf), len);++ // Serve a byte consumed by the is_peer_closed() probe before reading more.+ if (msession->has_peeked_byte) {+ if (len == 0) { return 0; }+ auto p = static_cast<unsigned char *>(buf);+ p[0] = msession->peeked_byte;+ msession->has_peeked_byte = false;+ size_t n = 1;+ // Top up with any already-decrypted bytes without risking a block.+ if (len > 1 && mbedtls_ssl_get_bytes_avail(&msession->ssl) > 0) {+ int extra = mbedtls_ssl_read(&msession->ssl, p + 1, len - 1);+ if (extra > 0) { n += static_cast<size_t>(extra); }+ }+ err.code = ErrorCode::Success;+ return static_cast<ssize_t>(n);+ }++ int ret;+ do {+ ret = mbedtls_ssl_read(&msession->ssl, static_cast<unsigned char *>(buf),+ len);+ } while (impl::mbedtls_is_session_ticket(ret));if (ret > 0) {err.code = ErrorCode::Success;@@ -14576,8 +14757,11 @@ ssize_t write(session_t session, const void *buf, size_t len,}auto msession = static_cast<impl::MbedTlsSession *>(session);- int ret = mbedtls_ssl_write(&msession->ssl,- static_cast<const unsigned char *>(buf), len);+ int ret;+ do {+ ret = mbedtls_ssl_write(&msession->ssl,+ static_cast<const unsigned char *>(buf), len);+ } while (impl::mbedtls_is_session_ticket(ret));if (ret > 0) {err.code = ErrorCode::Success;@@ -14599,7 +14783,8 @@ int pending(const_session_t session) {if (!session) { return 0; }auto msession =static_cast<impl::MbedTlsSession *>(const_cast<void *>(session));- return static_cast<int>(mbedtls_ssl_get_bytes_avail(&msession->ssl));+ return static_cast<int>(mbedtls_ssl_get_bytes_avail(&msession->ssl)) ++ (msession->has_peeked_byte ? 1 : 0);}void shutdown(session_t session, bool graceful) {@@ -14625,24 +14810,34 @@ bool is_peer_closed(session_t session, socket_t sock) {if (!session || sock == INVALID_SOCKET) { return true; }auto msession = static_cast<impl::MbedTlsSession *>(session);- // Check if there's already decrypted data available in the TLS buffer- // If so, the connection is definitely alive- if (mbedtls_ssl_get_bytes_avail(&msession->ssl) > 0) { return false; }+ // Check if there's already decrypted or pushed-back data available.+ // If so, the connection is definitely alive.+ if (msession->has_peeked_byte ||+ mbedtls_ssl_get_bytes_avail(&msession->ssl) > 0) {+ return false;+ }// Set socket to non-blocking to avoid blocking on readdetail::set_nonblocking(sock, true);auto cleanup =detail::scope_exit([&]() { detail::set_nonblocking(sock, false); });- // Try a 1-byte read to check connection status- // Note: This will consume the byte if data is available, but for the- // purpose of checking if peer is closed, this should be acceptable- // since we're only called when we expect the connection might be closing+ // Probe with a 1-byte read (Mbed TLS has no peek API). If the probe lands+ // on application data — e.g. a response that already arrived — push the+ // byte back so the next read() delivers it instead of losing it.unsigned char buf;- int ret = mbedtls_ssl_read(&msession->ssl, &buf, 1);+ int ret;+ do {+ ret = mbedtls_ssl_read(&msession->ssl, &buf, 1);+ } while (impl::mbedtls_is_session_ticket(ret));// If we got data or WANT_READ (would block), connection is alive- if (ret > 0 || ret == MBEDTLS_ERR_SSL_WANT_READ) { return false; }+ if (ret > 0) {+ msession->peeked_byte = buf;+ msession->has_peeked_byte = true;+ return false;+ }+ if (ret == MBEDTLS_ERR_SSL_WANT_READ) { return false; }// If we get a peer close notify or a connection reset, the peer is closedreturn ret == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY ||@@ -15049,7 +15244,7 @@ bool update_server_cert(ctx_t ctx, const char *cert_pem,}// Parse private key PEM-#ifdef CPPHTTPLIB_MBEDTLS_V3+#if defined(CPPHTTPLIB_MBEDTLS_V3) && !defined(CPPHTTPLIB_MBEDTLS_V4)ret = mbedtls_pk_parse_key(&mbed_ctx->own_key, reinterpret_cast<const unsigned char *>(key_pem),strlen(key_pem) + 1,diff --git a/vendor/cpp-httplib/httplib.h b/vendor/cpp-httplib/httplib.hindex de026a2532..6df357d706 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.50.1"-#define CPPHTTPLIB_VERSION_NUM "0x003201"+#define CPPHTTPLIB_VERSION "0.51.0"+#define CPPHTTPLIB_VERSION_NUM "0x003300"#ifdef _WIN32#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0A00@@ -420,18 +420,26 @@ using socket_t = int;#endif // CPPHTTPLIB_OPENSSL_SUPPORT#ifdef CPPHTTPLIB_MBEDTLS_SUPPORT-#include <mbedtls/ctr_drbg.h>-#include <mbedtls/entropy.h>+// version.h defines MBEDTLS_VERSION_MAJOR (on 2.x/3.x/4.x alike); it is pulled+// in with this first include group so the version gating below can use it.#include <mbedtls/error.h>-#include <mbedtls/md5.h>#include <mbedtls/net_sockets.h>#include <mbedtls/oid.h>#include <mbedtls/pk.h>+#include <mbedtls/ssl.h>+#include <mbedtls/version.h>+#include <mbedtls/x509_crt.h>+#if MBEDTLS_VERSION_MAJOR >= 4+// Mbed TLS 4.x moved hashing/RNG to PSA Crypto and removed these headers.+#include <psa/crypto.h>+#else+#include <mbedtls/ctr_drbg.h>+#include <mbedtls/entropy.h>+#include <mbedtls/md5.h>#include <mbedtls/sha1.h>#include <mbedtls/sha256.h>#include <mbedtls/sha512.h>-#include <mbedtls/ssl.h>-#include <mbedtls/x509_crt.h>+#endif#ifdef _WIN32#include <wincrypt.h>#ifdef _MSC_VER@@ -444,7 +452,11 @@ using socket_t = int;#endif#endif-// Mbed TLS 3.x API compatibility+// Mbed TLS version API compatibility. Note: V4 implies V3 (both defined on+// 4.x), so version-specific 3.x-only code must check V3 && !V4.+#if MBEDTLS_VERSION_MAJOR >= 4+#define CPPHTTPLIB_MBEDTLS_V4+#endif#if MBEDTLS_VERSION_MAJOR >= 3#define CPPHTTPLIB_MBEDTLS_V3#endif@@ -696,7 +708,7 @@ inline from_chars_result<T> from_chars(const char *first, const char *last,return {first, std::errc::invalid_argument};}- value = negative ? -result : result;+ value = negative ? T(0) - result : result;return {p, std::errc{}};}@@ -2957,7 +2969,18 @@ inline size_t get_header_value_u64(const Headers &headers,std::advance(it, static_cast<ssize_t>(id));if (it != rng.second) {if (is_numeric(it->second)) {- return static_cast<size_t>(std::strtoull(it->second.data(), nullptr, 10));+ // Parse at size_t width so an out-of-range Content-Length is reported+ // rather than silently saturated/truncated (a value above 2^32 would+ // otherwise wrap to a small framing length on 32-bit builds). Flag it+ // and return SIZE_MAX so the existing oversized-value guards reject it.+ size_t val = 0;+ const auto &s = it->second;+ auto r = from_chars(s.data(), s.data() + s.size(), val);+ if (r.ec == std::errc::result_out_of_range) {+ is_invalid_value = true;+ return (std::numeric_limits<size_t>::max)();+ }+ return val;} else {is_invalid_value = true;}@@ -3403,6 +3426,7 @@ bool is_obs_text(char c);bool is_field_vchar(char c);bool is_field_content(const std::string &s);bool is_field_value(const std::string &s);+bool is_field_valid(const std::string &name, const std::string &value);} // namespace fields} // namespace detail@@ -3422,8 +3446,11 @@ namespace impl {// setup callbacks (cast ctx_t to tls::impl::MbedTlsContext*).struct MbedTlsContext {mbedtls_ssl_config conf;+#ifndef CPPHTTPLIB_MBEDTLS_V4+ // Mbed TLS 4.x uses PSA Crypto's internal RNG; no explicit entropy/DRBG.mbedtls_entropy_context entropy;mbedtls_ctr_drbg_context ctr_drbg;+#endifmbedtls_x509_crt ca_chain;mbedtls_x509_crt own_cert;mbedtls_pk_context own_key;