LLM inference in C/C++
C++ ggml
vendor : update cpp-httplib to 0.56.0 (#28787)
Alessandro de Oliveira Faria (A.K.A.CABELO)718f7b4175bf
diff --git a/scripts/sync_vendor.py b/scripts/sync_vendor.pyindex 0170b5b168..a73ae1193e 100755--- a/scripts/sync_vendor.py+++ b/scripts/sync_vendor.py@@ -5,7 +5,7 @@ import osimport sysimport subprocess-HTTPLIB_VERSION = "refs/tags/v0.54.1"+HTTPLIB_VERSION = "refs/tags/v0.56.0"# used by examples/gguf-hash, these repos have no release tag, so we pin a commitXXHASH_COMMIT = "9f465f1ea932d6ad9a26cd77496311ffa544cd68"diff --git a/vendor/cpp-httplib/httplib.cpp b/vendor/cpp-httplib/httplib.cppindex 7fd10b3939..c82ff1e71d 100644--- a/vendor/cpp-httplib/httplib.cpp+++ b/vendor/cpp-httplib/httplib.cpp@@ -912,17 +912,42 @@ bool write_websocket_frame(Stream &strm, ws::Opcode opcode,namespace ws {namespace impl {-bool read_websocket_frame(Stream &strm, Opcode &opcode,- std::string &payload, bool &fin,- bool expect_masked, size_t max_len) {- // Read first 2 bytes+// Read exactly `size` bytes. Stream::read may return less than asked for -- it+// hands back whatever its buffer already holds -- so every multi-byte field has+// to loop. Reading a 2-byte header with a single read() fails whenever the+// header straddles the read buffer's boundary.+//+// Timeout is reported only when nothing at all was consumed. Once a byte has+// been taken the stream sits mid-field and cannot be resumed, so a timeout+// there is a failure like any other. (When read() fails it always records why,+// so the error belongs to this call and not to an earlier one.)+FrameRead read_exact(Stream &strm, void *buf, size_t size) {+ auto p = static_cast<char *>(buf);+ size_t total = 0;+ while (total < size) {+ auto n = strm.read(p + total, size - total);+ if (n <= 0) {+ auto timed_out = total == 0 && strm.get_error() == Error::Timeout;+ return timed_out ? FrameRead::Timeout : FrameRead::Fail;+ }+ total += static_cast<size_t>(n);+ }+ return FrameRead::Ok;+}++FrameRead read_websocket_frame(Stream &strm, Opcode &opcode,+ std::string &payload, bool &fin,+ bool expect_masked, size_t max_len) {+ // Read first 2 bytes. This is the only read that may report a timeout: it+ // sits on a frame boundary, where nothing has been consumed yet.uint8_t header[2];- if (strm.read(reinterpret_cast<char *>(header), 2) != 2) { return false; }+ FrameRead first = read_exact(strm, header, 2);+ if (first != FrameRead::Ok) { return first; }fin = (header[0] & 0x80) != 0;// RSV1, RSV2, RSV3 must be 0 when no extension is negotiated- if (header[0] & 0x70) { return false; }+ if (header[0] & 0x70) { return FrameRead::Fail; }opcode = static_cast<Opcode>(header[0] & 0x0F);bool masked = (header[1] & 0x80) != 0;@@ -932,46 +957,44 @@ bool read_websocket_frame(Stream &strm, Opcode &opcode,// MUST have a payload length of 125 bytes or lessbool is_control = (static_cast<uint8_t>(opcode) & 0x08) != 0;if (is_control) {- if (!fin) { return false; }- if (payload_len > 125) { return false; }+ if (!fin) { return FrameRead::Fail; }+ if (payload_len > 125) { return FrameRead::Fail; }}- if (masked != expect_masked) { return false; }+ if (masked != expect_masked) { return FrameRead::Fail; }// Extended payload lengthif (payload_len == 126) {uint8_t ext[2];- if (strm.read(reinterpret_cast<char *>(ext), 2) != 2) { return false; }+ if (read_exact(strm, ext, 2) != FrameRead::Ok) { return FrameRead::Fail; }payload_len = (static_cast<uint64_t>(ext[0]) << 8) | ext[1];} else if (payload_len == 127) {uint8_t ext[8];- if (strm.read(reinterpret_cast<char *>(ext), 8) != 8) { return false; }+ if (read_exact(strm, ext, 8) != FrameRead::Ok) { return FrameRead::Fail; }// RFC 6455 Section 5.2: the most significant bit MUST be 0- if (ext[0] & 0x80) { return false; }+ if (ext[0] & 0x80) { return FrameRead::Fail; }payload_len = 0;for (int i = 0; i < 8; i++) {payload_len = (payload_len << 8) | ext[i];}}- if (payload_len > max_len) { return false; }+ if (payload_len > max_len) { return FrameRead::Fail; }// Read mask key if presentuint8_t mask_key[4] = {0};if (masked) {- if (strm.read(reinterpret_cast<char *>(mask_key), 4) != 4) { return false; }+ if (read_exact(strm, mask_key, 4) != FrameRead::Ok) {+ return FrameRead::Fail;+ }}// Read payloadpayload.resize(static_cast<size_t>(payload_len));- if (payload_len > 0) {- size_t total_read = 0;- while (total_read < payload_len) {- auto n = strm.read(&payload[total_read],- static_cast<size_t>(payload_len - total_read));- if (n <= 0) { return false; }- total_read += static_cast<size_t>(n);- }+ if (payload_len > 0 &&+ read_exact(strm, &payload[0], static_cast<size_t>(payload_len)) !=+ FrameRead::Ok) {+ return FrameRead::Fail;}// Unmask if needed@@ -981,7 +1004,7 @@ bool read_websocket_frame(Stream &strm, Opcode &opcode,}}- return true;+ return FrameRead::Ok;}} // namespace impl@@ -1728,7 +1751,9 @@ ssize_t select_impl(socket_t sock, short events, time_t sec,pfd.events = events;pfd.revents = 0;- auto timeout = static_cast<int>(sec * 1000 + usec / 1000);+ // A negative timeout waits forever, poll's own convention. 0 keeps meaning+ // "return immediately", which callers here rely on to probe a socket.+ auto timeout = sec < 0 ? -1 : static_cast<int>(sec * 1000 + usec / 1000);return handle_EINTR([&]() { return poll_wrapper(&pfd, 1, timeout); });}@@ -1810,8 +1835,11 @@ private:bool ensure_readable();socket_t sock_;- time_t read_timeout_sec_;- time_t read_timeout_usec_;+ // Atomic because ws::WebSocket::set_read_timeout() reaches this from another+ // thread while a read is in flight -- that is the point of it, for a caller+ // holding one connection and wanting control back to send on it.+ std::atomic<time_t> read_timeout_sec_;+ std::atomic<time_t> read_timeout_usec_;time_t write_timeout_sec_;time_t write_timeout_usec_;time_t max_timeout_msec_;@@ -2204,12 +2232,10 @@ int getaddrinfo_with_timeout(const char *node, const char *service,// actually finish before letting the stack frame go. The trade-off is that// a wedged DNS server can hold this thread for the system resolver timeout// (~30s by default) past the caller's connection timeout.- struct gaicb request {};+ struct gaicb request{};struct gaicb *requests[1] = {&request};- struct sigevent sevp {};- struct timespec timeout {- timeout_sec, 0- };+ struct sigevent sevp{};+ struct timespec timeout{timeout_sec, 0};request.ar_name = node;request.ar_service = service;@@ -2948,8 +2974,21 @@ EncodingType encoding_type(const Request &req,return best;}+// `content_type` is taken separately because a file-backed response has not+// been given one yet when its coding has to be decided.+EncodingType encoding_type(const Request &req, const Response &res,+ const std::string &content_type) {+ // The response already names a content coding of its own: a handler serving+ // a body it encoded itself (pre-compressed static assets, say), or a mount+ // point whose headers name the coding its files are stored in. Applying one+ // on top of that would double-encode the body and append a second+ // `Content-Encoding` field line.+ if (res.has_header("Content-Encoding")) { return EncodingType::None; }+ return encoding_type(req, content_type);+}+EncodingType encoding_type(const Request &req, const Response &res) {- return encoding_type(req, res.get_header_value("Content-Type"));+ return encoding_type(req, res, res.get_header_value("Content-Type"));}std::unique_ptr<compressor> make_compressor(EncodingType type) {@@ -3677,6 +3716,17 @@ bool is_chunked_transfer_encoding(const Headers &headers) {return case_ignore::equal(last_coding, "chunked");}+bool has_conflicting_content_length(const Headers &headers) {+ // RFC 9112 §6.3: a message carrying both Transfer-Encoding and a non-zero+ // Content-Length is framed ambiguously. The body readers here delimit it by+ // the transfer coding and drop Content-Length, while an intermediary may do+ // the reverse, so the two disagree on where the body ends and a reused+ // connection is desynchronised (request/response smuggling). Content-Length:+ // 0 is tolerated for compatibility with existing peers.+ return has_header(headers, "Transfer-Encoding") &&+ get_header_value_u64(headers, "Content-Length", 0, 0) > 0;+}+template <typename T, typename U>bool prepare_content_receiver(T &x, int &status,ContentReceiverWithProgress receiver,@@ -4035,7 +4085,7 @@ void set_file_content_provider(Response &res,return true;});- res.file_content_encoding_ = encoding;+ res.content_coding_ = encoding;}template <typename T, typename U>@@ -4361,13 +4411,20 @@ bool parse_range_header(const std::string &s, Ranges &ranges) try {ssize_t first = -1;if (!lhs.empty()) {- ssize_t v;- auto res = detail::from_chars(lhs.data(), lhs.data() + lhs.size(), v);- if (res.ec == std::errc{}) { first = v; }+ // Reject an overflowing first-byte-pos; treating it as absent (-1)+ // would turn the range into a suffix range.+ auto res =+ detail::from_chars(lhs.data(), lhs.data() + lhs.size(), first);+ if (res.ec != std::errc{}) {+ all_valid_ranges = false;+ return;+ }}ssize_t last = -1;if (!rhs.empty()) {+ // An overflowing last-byte-pos is past any content length, so keeping+ // -1 ("remainder", RFC 9110 14.1.2) is correct here.ssize_t v;auto res = detail::from_chars(rhs.data(), rhs.data() + rhs.size(), v);if (res.ec == std::errc{}) { last = v; }@@ -6902,7 +6959,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;+ content_coding_ = detail::EncodingType::None;}void Response::set_content(const std::string &s,@@ -6917,7 +6974,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;+ content_coding_ = detail::EncodingType::None;}void Response::set_content_provider(@@ -6928,7 +6985,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;+ content_coding_ = detail::EncodingType::None;}void Response::set_content_provider(@@ -6939,7 +6996,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;+ content_coding_ = detail::EncodingType::None;}void Response::set_chunked_content_provider(@@ -6950,7 +7007,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;+ content_coding_ = detail::EncodingType::None;}void Response::set_file_content(const std::string &path,@@ -7991,12 +8048,19 @@ ssize_t WebSocketSSLStream::read(char *ptr, size_t size) {needs_readable || (err.code == tls::ErrorCode::SyscallError &&WSAGetLastError() == WSAETIMEDOUT);#endif- if (!needs_readable && err.code != tls::ErrorCode::WantWrite) { return -1; }+ if (!needs_readable && err.code != tls::ErrorCode::WantWrite) {+ error_ = Error::Read;+ return -1;+ }if (!(needs_readable ? wait_readable() : wait_writable())) {error_ = Error::Timeout;return -1;}}+ // Out of retries. Recording a reason matters: a caller that reads get_error()+ // to tell a timeout from a close would otherwise see whatever the previous+ // failure left behind (error_ is never cleared on success).+ error_ = Error::Read;return -1;}@@ -8653,9 +8717,10 @@ Server::write_content_with_provider(Stream &strm, const Request &req,}} else {if (res.is_chunked_content_provider_) {- auto type = detail::encoding_type(req, res);-- auto compressor = detail::make_compressor(type);+ // Use the coding `apply_ranges()` chose when it wrote the headers;+ // re-negotiating here would disagree with them, e.g. once a handler's+ // own Content-Encoding header suppresses the negotiation.+ auto compressor = detail::make_compressor(res.content_coding_);if (!compressor) {compressor = detail::make_unique<detail::nocompressor>();}@@ -8881,7 +8946,8 @@ bool Server::handle_file_request(Request &req, Response &res) {auto encoding = detail::EncodingType::None;if (static_file_compression_) {content_type = content_type_of();- encoding = static_file_encoding(req, content_type, stat.size());+ encoding =+ static_file_encoding(req, res, content_type, stat.size());}// The ETag names the representation actually sent, so a client that@@ -9296,8 +9362,10 @@ bool Server::dispatch_request(Request &req, Response &res,// 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 {+detail::EncodingType+Server::static_file_encoding(const Request &req, const Response &res,+ 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@@ -9322,14 +9390,14 @@ detail::EncodingType Server::static_file_encoding(return detail::EncodingType::None;}- return detail::encoding_type(req, content_type);+ return detail::encoding_type(req, res, 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_;+ auto type = res.content_coding_;if (type == detail::EncodingType::None || !res.content_provider_) {return false;}@@ -9353,7 +9421,7 @@ bool Server::apply_static_file_compression(const Request &req,res.content_provider_success_ = true;res.content_provider_ = nullptr;res.content_length_ = 0;- res.file_content_encoding_ = detail::EncodingType::None;+ res.content_coding_ = detail::EncodingType::None;res.set_header("Content-Encoding", detail::encoding_name(type));res.set_header("Vary", "Accept-Encoding");@@ -9412,6 +9480,7 @@ void Server::apply_ranges(const Request &req, Response &res,if (res.content_provider_) {if (res.is_chunked_content_provider_) {res.set_header("Transfer-Encoding", "chunked");+ res.content_coding_ = type;if (type != detail::EncodingType::None) {res.set_header("Content-Encoding", detail::encoding_name(type));res.set_header("Vary", "Accept-Encoding");@@ -9568,8 +9637,8 @@ Server::process_request(Stream &strm, const std::string &remote_addr,// coding is not chunked, which leaves the body length undeterminable. The// latter must not fall through to the "no body" path, or the body bytes are// parsed as the next request on a persistent connection.- if (req.has_header("Transfer-Encoding") &&- (req.get_header_value_u64("Content-Length") > 0 ||+ if (detail::has_conflicting_content_length(req.headers) ||+ (req.has_header("Transfer-Encoding") &&!detail::is_chunked_transfer_encoding(req.headers))) {connection_closed = true;res.status = StatusCode::BadRequest_400;@@ -9734,7 +9803,7 @@ Server::process_request(Stream &strm, const std::string &remote_addr,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,+ CPPHTTPLIB_WEBSOCKET_SERVER_READ_TIMEOUT_SECOND, 0,write_timeout_sec_, write_timeout_usec_));ws::WebSocket ws(std::move(ws_strm), req, true,websocket_ping_interval_sec_,@@ -9744,7 +9813,8 @@ Server::process_request(Stream &strm, const std::string &remote_addr,}#endif// Use WebSocket-specific read timeout instead of HTTP timeout- strm.set_read_timeout(CPPHTTPLIB_WEBSOCKET_READ_TIMEOUT_SECOND, 0);+ strm.set_read_timeout(CPPHTTPLIB_WEBSOCKET_SERVER_READ_TIMEOUT_SECOND,+ 0);ws::WebSocket ws(strm, req, true, websocket_ping_interval_sec_,websocket_max_missed_pongs_);entry.handler(req, ws);@@ -9808,7 +9878,7 @@ Server::process_request(Stream &strm, const std::string &remote_addr,detail::set_file_content_provider(res, mm, content_type,- static_file_encoding(req, content_type, mm->size()));+ static_file_encoding(req, res, content_type, mm->size()));}}@@ -10228,8 +10298,12 @@ Result ClientImpl::send_(Request &&req) {void ClientImpl::prepare_default_headers(Request &r, bool for_stream,const std::string &ct) {(void)for_stream;- for (const auto &header : default_headers_) {- if (!r.has_header(header.first)) { r.headers.insert(header); }+ // Default headers are meant for the origin and may carry its credentials, so+ // keep them off the CONNECT request the proxy reads.+ if (r.method != "CONNECT") {+ for (const auto &header : default_headers_) {+ if (!r.has_header(header.first)) { r.headers.insert(header); }+ }}// RFC 9110 5.3 recommends sending control data such as Host first, so@@ -10379,6 +10453,17 @@ ClientImpl::open_stream(const std::string &method, const std::string &path,return handle;}+ // Same framing check as ClientImpl::process_request(). A HEAD or bodyless+ // (204/304) response legitimately carries framing headers with no body.+ if (method != "HEAD" &&+ handle.response->status != StatusCode::NoContent_204 &&+ handle.response->status != StatusCode::NotModified_304 &&+ detail::has_conflicting_content_length(handle.response->headers)) {+ handle.error = Error::Read;+ handle.response.reset();+ return handle;+ }+handle.body_reader_.stream = handle.stream_;handle.body_reader_.payload_max_length = payload_max_length_;@@ -10910,24 +10995,24 @@ bool ClientImpl::write_request(Stream &strm, Request &req,}}- if (!basic_auth_password_.empty() || !basic_auth_username_.empty()) {- if (!req.has_header("Authorization")) {+ // A CONNECT request is read by the proxy; everything sent through the tunnel+ // it opens is read by the origin. Each credential goes only to its own hop.+ auto is_connect = req.method == "CONNECT";++ if (!is_connect && !req.has_header("Authorization")) {+ if (!basic_auth_password_.empty() || !basic_auth_username_.empty()) {req.headers.insert(make_basic_authentication_header(basic_auth_username_, basic_auth_password_, false));- }- }-- if (!bearer_token_auth_token_.empty()) {- if (!req.has_header("Authorization")) {+ } else if (!bearer_token_auth_token_.empty()) {req.headers.insert(make_bearer_token_authentication_header(bearer_token_auth_token_, false));}}- // Proxy-Authorization is only sent when the proxy is actually used for- // this target — otherwise NO_PROXY-matched requests would leak proxy- // credentials directly to the destination server.- if (is_proxy_enabled_for_host(host_)) {+ // Proxy-Authorization is only sent when the proxy reads this message —+ // otherwise NO_PROXY-matched requests, and requests inside a TLS tunnel,+ // would leak proxy credentials to the destination server.+ if (is_proxy_enabled_for_host(host_) && (!is_ssl() || is_connect)) {if (!proxy_basic_auth_username_.empty() &&!proxy_basic_auth_password_.empty() &&!req.has_header("Proxy-Authorization")) {@@ -11323,6 +11408,17 @@ bool ClientImpl::process_request(Stream &strm, Request &req,// Bodyif ((res.status != StatusCode::NoContent_204) && req.method != "HEAD" &&req.method != "CONNECT") {+ // Reject ambiguous framing (RFC 9112 §6.3). Unlike a request, a response+ // whose final transfer coding is not chunked is not ambiguous: its body+ // runs until the server closes the connection, so it is not rejected.+ // HEAD/204 are excluded above and a 304 carries no body.+ if (res.status != StatusCode::NotModified_304 &&+ detail::has_conflicting_content_length(res.headers)) {+ error = Error::Read;+ output_error_log(error, &req);+ return false;+ }+auto redirect = 300 < res.status && res.status < 400 &&res.status != StatusCode::NotModified_304 &&follow_location_;@@ -17562,8 +17658,16 @@ ReadResult WebSocket::read(std::string &msg) {std::string payload;bool fin;- if (!impl::read_websocket_frame(strm_, opcode, payload, fin, is_server_,- CPPHTTPLIB_WEBSOCKET_MAX_PAYLOAD_LENGTH)) {+ impl::FrameRead r =+ impl::read_websocket_frame(strm_, opcode, payload, fin, is_server_,+ CPPHTTPLIB_WEBSOCKET_MAX_PAYLOAD_LENGTH);+ // A timeout landed on a frame boundary: the connection is untouched and+ // still usable, so hand control back without closing it. That is only+ // useful to a caller who asked for the timeout; the compile-time default+ // is a backstop against a peer gone quiet, and elapsing it closes the+ // connection so a plain `while (ws.read(msg))` loop ends.+ if (r == impl::FrameRead::Timeout && read_timeout_set_) { return Timeout; }+ if (r != impl::FrameRead::Ok) {closed_ = true;return Fail;}@@ -17600,9 +17704,14 @@ ReadResult WebSocket::read(std::string &msg) {Opcode cont_opcode;std::string cont_payload;bool cont_fin;- if (!impl::read_websocket_frame(+ // A timeout is not reportable here: half of a fragmented message is+ // already in `msg` and read() has no way to resume it, so it is a+ // failure like any other. Timeouts are only ever seen on a message+ // boundary.+ if (impl::read_websocket_frame(strm_, cont_opcode, cont_payload, cont_fin, is_server_,- CPPHTTPLIB_WEBSOCKET_MAX_PAYLOAD_LENGTH)) {+ CPPHTTPLIB_WEBSOCKET_MAX_PAYLOAD_LENGTH) !=+ impl::FrameRead::Ok) {closed_ = true;return Fail;}@@ -17696,7 +17805,8 @@ void WebSocket::close(CloseStatus status, const std::string &reason) {Opcode op;std::string resp;bool fin;- while (impl::read_websocket_frame(strm_, op, resp, fin, is_server_, 125)) {+ while (impl::read_websocket_frame(strm_, op, resp, fin, is_server_, 125) ==+ impl::FrameRead::Ok) {if (op == Opcode::Close) { break; }}}@@ -17741,6 +17851,15 @@ const Request &WebSocket::request() const { return req_; }bool WebSocket::is_open() const { return !closed_; }+void WebSocket::set_read_timeout(time_t sec, time_t usec) {+ // 0 waits forever here, as it does for SO_RCVTIMEO. The stream waits with+ // poll(), where 0 would instead mean "return immediately", so hand it the+ // negative poll uses for an unbounded wait.+ if (sec == 0 && usec == 0) { sec = -1; }+ strm_.set_read_timeout(sec, usec);+ read_timeout_set_ = true;+}+// WebSocketClient implementationWebSocketClient::WebSocketClient(const std::string &scheme_host_port_path, const Headers &headers)@@ -17843,6 +17962,16 @@ void WebSocketClient::shutdown_and_close() {bool WebSocketClient::create_stream(std::unique_ptr<Stream> &strm,Error &error, int &ssl_error,uint64_t &ssl_backend_error) {+ // A read timeout of 0 means "wait forever", the way SO_RCVTIMEO reads it.+ // The streams wait with poll(), where 0 instead means "return immediately",+ // so they are given the negative poll uses for an unbounded wait.+ auto unbounded = read_timeout_sec_ == 0 && read_timeout_usec_ == 0;+ time_t strm_read_sec = unbounded ? -1 : read_timeout_sec_;+ time_t strm_read_usec = unbounded ? 0 : read_timeout_usec_;+ // The handshake belongs to establishing the connection, so an unset read+ // timeout leaves it bounded by the connection timeout instead of forever.+ time_t hs_sec = unbounded ? connection_timeout_sec_ : read_timeout_sec_;+ time_t hs_usec = unbounded ? connection_timeout_usec_ : read_timeout_usec_;#ifdef CPPHTTPLIB_SSL_ENABLEDif (is_ssl_) {// A plain flag rather than SSLClient::load_certs()'s call_once: connect()@@ -17862,8 +17991,8 @@ bool WebSocketClient::create_stream(std::unique_ptr<Stream> &strm,detail::ClientTlsSessionError tls_error;if (!detail::setup_client_tls_session(host_, tls_ctx_, tls_session_, sock_,server_certificate_verification_,- read_timeout_sec_, read_timeout_usec_,- &tls_error, options)) {+ hs_sec, hs_usec, &tls_error,+ options)) {error = tls_error.error;ssl_error = tls_error.ssl_error;ssl_backend_error = tls_error.backend_error;@@ -17871,17 +18000,19 @@ bool WebSocketClient::create_stream(std::unique_ptr<Stream> &strm,}strm = std::unique_ptr<Stream>(new detail::WebSocketSSLStream(- sock_, tls_session_, read_timeout_sec_, read_timeout_usec_,- write_timeout_sec_, write_timeout_usec_));+ sock_, tls_session_, strm_read_sec, strm_read_usec, write_timeout_sec_,+ write_timeout_usec_));return true;}#else(void)error;(void)ssl_error;(void)ssl_backend_error;+ (void)hs_sec;+ (void)hs_usec;#endifstrm = std::unique_ptr<Stream>(- new detail::SocketStream(sock_, read_timeout_sec_, read_timeout_usec_,+ new detail::SocketStream(sock_, strm_read_sec, strm_read_usec,write_timeout_sec_, write_timeout_usec_));return true;}@@ -17951,6 +18082,9 @@ Result WebSocketClient::connect() {ws_ = std::unique_ptr<WebSocket>(new WebSocket(std::move(strm), req, false,websocket_ping_interval_sec_,websocket_max_missed_pongs_));+ // The stream was created with the timeout already; tell the WebSocket+ // whether it came from the caller, so read() knows to report it as Timeout.+ ws_->read_timeout_set_ = read_timeout_set_;return Result{Error::Success, upgrade.status, std::move(upgrade.headers)};}@@ -17983,6 +18117,10 @@ const std::string &WebSocketClient::subprotocol() const {void WebSocketClient::set_read_timeout(time_t sec, time_t usec) {read_timeout_sec_ = sec;read_timeout_usec_ = usec;+ read_timeout_set_ = true;+ // The members above only seed the next connect(); read() consults the+ // stream, so an already-open connection has to be told directly.+ if (ws_) { ws_->set_read_timeout(sec, usec); }}void WebSocketClient::set_write_timeout(time_t sec, time_t usec) {diff --git a/vendor/cpp-httplib/httplib.h b/vendor/cpp-httplib/httplib.hindex ca7c96a41a..a3a2ff45af 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.54.1"-#define CPPHTTPLIB_VERSION_NUM "0x003601"+#define CPPHTTPLIB_VERSION "0.56.0"+#define CPPHTTPLIB_VERSION_NUM "0x003800"#ifdef _WIN32#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0A00@@ -215,8 +215,36 @@#define CPPHTTPLIB_WEBSOCKET_MAX_PAYLOAD_LENGTH 16777216#endif-#ifndef CPPHTTPLIB_WEBSOCKET_READ_TIMEOUT_SECOND-#define CPPHTTPLIB_WEBSOCKET_READ_TIMEOUT_SECOND 300+// One macro used to set the read timeout for both sides. They want different+// defaults: a client's read timeout is the caller's own tool (it waits forever+// until asked not to), while a server keeps a ceiling that reclaims a worker+// from a peer that has gone quiet. The old name still works and sets both.+#ifdef CPPHTTPLIB_WEBSOCKET_READ_TIMEOUT_SECOND+#pragma message( \+ "CPPHTTPLIB_WEBSOCKET_READ_TIMEOUT_SECOND is deprecated; define " \+ "CPPHTTPLIB_WEBSOCKET_CLIENT_READ_TIMEOUT_SECOND and/or " \+ "CPPHTTPLIB_WEBSOCKET_SERVER_READ_TIMEOUT_SECOND instead")+#ifndef CPPHTTPLIB_WEBSOCKET_CLIENT_READ_TIMEOUT_SECOND+#define CPPHTTPLIB_WEBSOCKET_CLIENT_READ_TIMEOUT_SECOND \+ CPPHTTPLIB_WEBSOCKET_READ_TIMEOUT_SECOND+#endif+#ifndef CPPHTTPLIB_WEBSOCKET_SERVER_READ_TIMEOUT_SECOND+#define CPPHTTPLIB_WEBSOCKET_SERVER_READ_TIMEOUT_SECOND \+ CPPHTTPLIB_WEBSOCKET_READ_TIMEOUT_SECOND+#endif+#endif++// 0 waits forever. A read timeout is how a caller gets control back to send on+// the same connection; it is not a liveness check (that is ping/pong). Only a+// timeout set at runtime through set_read_timeout() is reported as+// ws::Timeout; when one of these compile-time defaults elapses, read() returns+// ws::Fail and closes the connection.+#ifndef CPPHTTPLIB_WEBSOCKET_CLIENT_READ_TIMEOUT_SECOND+#define CPPHTTPLIB_WEBSOCKET_CLIENT_READ_TIMEOUT_SECOND 0+#endif++#ifndef CPPHTTPLIB_WEBSOCKET_SERVER_READ_TIMEOUT_SECOND+#define CPPHTTPLIB_WEBSOCKET_SERVER_READ_TIMEOUT_SECOND 300#endif#ifndef CPPHTTPLIB_WEBSOCKET_CLOSE_TIMEOUT_SECOND@@ -1817,10 +1845,12 @@ struct Response {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;+ // Content coding chosen for the response body, decided once so that the+ // headers and the body cannot disagree: where the file is opened for a+ // file-backed content provider (keeping the ETag honest), and in+ // `apply_ranges()` for a chunked content provider. `EncodingType::None`+ // for every other kind of response.+ detail::EncodingType content_coding_ = detail::EncodingType::None;};enum class Error {@@ -2359,6 +2389,7 @@ private:bool parse_request_line(const char *s, Request &req) const;detail::EncodingType static_file_encoding(const Request &req,+ const Response &res,const std::string &content_type,size_t length) const;bool apply_static_file_compression(const Request &req, Response &res) const;@@ -3663,6 +3694,9 @@ ssize_t read_socket(socket_t sock, void *ptr, size_t size, int flags);EncodingType encoding_type(const Request &req, const std::string &content_type);+EncodingType encoding_type(const Request &req, const Response &res,+ const std::string &content_type);+EncodingType encoding_type(const Request &req, const Response &res);class BufferStream final : public Stream {@@ -4345,7 +4379,11 @@ enum class CloseStatus : uint16_t {InternalError = 1011,};-enum ReadResult : int { Fail = 0, Text = 1, Binary = 2 };+// Timeout is returned only when a read timeout was set and it elapsed before+// any byte of a frame arrived: nothing was consumed and the connection is+// still open, so the caller can send on it and read again. `msg` is left+// untouched, so a `while (ws.read(msg))` loop must not treat it as a message.+enum ReadResult : int { Fail = 0, Text = 1, Binary = 2, Timeout = 3 };// Result of WebSocketClient::connect(). Truthy only when the WebSocket// upgrade handshake fully succeeded. On failure error() identifies the@@ -4405,6 +4443,18 @@ public:const Request &request() const;bool is_open() const;+ // Bound how long read() waits before returning Timeout. 0 waits forever.+ // A server handler owns its connection's timeout this way; a client sets it+ // through WebSocketClient. Safe to call while another thread is in read().+ //+ // Only a timeout set here is reported as Timeout. The compile-time default+ // (CPPHTTPLIB_WEBSOCKET_SERVER_READ_TIMEOUT_SECOND) is a backstop rather+ // than a request for control, so when it elapses read() returns Fail and+ // closes the connection, and `while (ws.read(msg))` ends as it always has.+ void set_read_timeout(time_t sec, time_t usec = 0);+ template <class Rep, class Period>+ void set_read_timeout(const std::chrono::duration<Rep, Period> &duration);+private:friend class httplib::Server;friend class WebSocketClient;@@ -4440,6 +4490,10 @@ private:int max_missed_pongs_;int unacked_pings_ = 0;std::atomic<bool> closed_{false};+ // Set once the caller has bounded read() through set_read_timeout(). Until+ // then the timeout in effect is the compile-time default, and elapsing it+ // is a failure that closes the connection, not a Timeout.+ std::atomic<bool> read_timeout_set_{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@@ -4527,8 +4581,9 @@ private:bool is_valid_ = false;socket_t sock_ = INVALID_SOCKET;std::unique_ptr<WebSocket> ws_;- time_t read_timeout_sec_ = CPPHTTPLIB_WEBSOCKET_READ_TIMEOUT_SECOND;+ time_t read_timeout_sec_ = CPPHTTPLIB_WEBSOCKET_CLIENT_READ_TIMEOUT_SECOND;time_t read_timeout_usec_ = 0;+ bool read_timeout_set_ = false; // see WebSocket::read_timeout_set_time_t write_timeout_sec_ = CPPHTTPLIB_CLIENT_WRITE_TIMEOUT_SECOND;time_t write_timeout_usec_ = CPPHTTPLIB_CLIENT_WRITE_TIMEOUT_USECOND;time_t websocket_ping_interval_sec_ =@@ -4560,6 +4615,13 @@ private:#endif};+template <class Rep, class Period>+inline void WebSocket::set_read_timeout(+ const std::chrono::duration<Rep, Period> &duration) {+ detail::duration_to_sec_and_usec(+ duration, [&](time_t sec, time_t usec) { set_read_timeout(sec, usec); });+}+template <class Rep, class Period>inline void WebSocketClient::set_read_timeout(const std::chrono::duration<Rep, Period> &duration) {@@ -4586,8 +4648,14 @@ namespace impl {bool is_valid_utf8(const std::string &s);-bool read_websocket_frame(Stream &strm, Opcode &opcode, std::string &payload,- bool &fin, bool expect_masked, size_t max_len);+// Three states, because a failure that consumed bytes and one that consumed+// none are not the same thing: the first has left the stream in the middle of+// a frame and the connection cannot be reused, the second can just be retried.+enum class FrameRead { Ok, Fail, Timeout };++FrameRead read_websocket_frame(Stream &strm, Opcode &opcode,+ std::string &payload, bool &fin,+ bool expect_masked, size_t max_len);} // namespace impl