wt/cpp-httplib
1
0 Fork 0
mirror of https://github.com/yhirose/cpp-httplib.git synced 2026-10-19 11:19:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix the warnings left in the 32-bit, BoringSSL and MSVC builds

Browse Source 
time_t is 32 bits wide on 32-bit builds, so the millisecond counts in
set_max_timeout() and the streams' duration() narrowed into it
implicitly. Cast them as duration_to_sec_and_usec() already does. In
the tests, six content receivers took a uint64_t length where
ContentReceiver passes size_t, the Expect: 100-continue test kept
10 GiB in a size_t, and the Range checks compared ssize_t fields with
unsigned literals, so they now compare whole Ranges.
DoesNotReserveTheClaimedLength shifted a size_t by 41. It now claims
std::string().max_size(), the most the client accepts, and still
fails if the reserve cap is removed.

BoringSSL counts stacks in size_t, and takes the protocol version as
uint16_t and the error code as uint32_t. Walk the certificate stacks
with the decltype(count) loop used elsewhere, pass the version as
uint16_t, and cast the error code to what ERR_get_error() returns.

MSVC takes the send() length as int, so the raw send() calls left in
the tests go through detail::send_socket().
This commit is contained in:
yhirose committed 2026-10-18 00:36:18 -04:00
1 parent e97165b5dc
commit 7234944098
2 files changed
+69 -78
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

httplib.h
+25 -18
View File
@@ -3645,7 +3645,7 @@ inline void ClientImpl::set_max_timeout(
const std::chrono::duration<Rep, Period> &duration) { const std::chrono::duration<Rep, Period> &duration) {
auto msec = auto msec =
std::chrono::duration_cast<std::chrono::milliseconds>(duration).count(); std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
set_max_timeout(msec); set_max_timeout(static_cast<time_t>(msec));
} }
template <class Rep, class Period> template <class Rep, class Period>
@@ -12685,9 +12685,10 @@ inline void SocketStream::get_local_ip_and_port(std::string &ip,
inline socket_t SocketStream::socket() const { return sock_; } inline socket_t SocketStream::socket() const { return sock_; }
inline time_t SocketStream::duration() const { inline time_t SocketStream::duration() const {
return std::chrono::duration_cast<std::chrono::milliseconds>( return static_cast<time_t>(
std::chrono::steady_clock::now() - start_time_) std::chrono::duration_cast<std::chrono::milliseconds>(
.count(); std::chrono::steady_clock::now() - start_time_)
.count());
} }
inline void SocketStream::set_read_timeout(time_t sec, time_t usec) { inline void SocketStream::set_read_timeout(time_t sec, time_t usec) {
@@ -13229,9 +13230,10 @@ inline void SSLSocketStream::get_local_ip_and_port(std::string &ip,
inline socket_t SSLSocketStream::socket() const { return sock_; } inline socket_t SSLSocketStream::socket() const { return sock_; }
inline time_t SSLSocketStream::duration() const { inline time_t SSLSocketStream::duration() const {
return std::chrono::duration_cast<std::chrono::milliseconds>( return static_cast<time_t>(
std::chrono::steady_clock::now() - start_time_) std::chrono::duration_cast<std::chrono::milliseconds>(
.count(); std::chrono::steady_clock::now() - start_time_)
.count());
} }
inline void SSLSocketStream::set_read_timeout(time_t sec, time_t usec) { inline void SSLSocketStream::set_read_timeout(time_t sec, time_t usec) {
@@ -13362,9 +13364,10 @@ inline void WebSocketSSLStream::get_local_ip_and_port(std::string &ip,
inline socket_t WebSocketSSLStream::socket() const { return sock_; } inline socket_t WebSocketSSLStream::socket() const { return sock_; }
inline time_t WebSocketSSLStream::duration() const { inline time_t WebSocketSSLStream::duration() const {
return std::chrono::duration_cast<std::chrono::milliseconds>( return static_cast<time_t>(
std::chrono::steady_clock::now() - start_time_) std::chrono::duration_cast<std::chrono::milliseconds>(
.count(); std::chrono::steady_clock::now() - start_time_)
.count());
} }
inline void WebSocketSSLStream::set_read_timeout(time_t sec, time_t usec) { inline void WebSocketSSLStream::set_read_timeout(time_t sec, time_t usec) {
@@ -19750,7 +19753,7 @@ inline void free_context(ctx_t ctx) {
inline bool set_min_version(ctx_t ctx, Version version) { inline bool set_min_version(ctx_t ctx, Version version) {
if (!ctx) return false; if (!ctx) return false;
return SSL_CTX_set_min_proto_version(static_cast<SSL_CTX *>(ctx), return SSL_CTX_set_min_proto_version(static_cast<SSL_CTX *>(ctx),
static_cast<int>(version)) == 1; static_cast<uint16_t>(version)) == 1;
} }
inline bool load_ca_pem(ctx_t ctx, const char *pem, size_t len) { inline bool load_ca_pem(ctx_t ctx, const char *pem, size_t len) {
@@ -20203,11 +20206,13 @@ inline size_t get_peer_certs(const_session_t session,
if (SSL_is_server(ssl)) { if (SSL_is_server(ssl)) {
if (auto leaf = get_peer_cert(session)) { certs.push_back(leaf); } if (auto leaf = get_peer_cert(session)) { certs.push_back(leaf); }
} }
auto sk = SSL_get_peer_cert_chain(ssl); if (auto sk = SSL_get_peer_cert_chain(ssl)) {
for (int i = 0; sk && i < sk_X509_num(sk); i++) { auto count = sk_X509_num(sk);
auto x509 = sk_X509_value(sk, i); for (decltype(count) i = 0; i < count; i++) {
X509_up_ref(x509); auto x509 = sk_X509_value(sk, i);
certs.push_back(static_cast<cert_t>(x509)); X509_up_ref(x509);
certs.push_back(static_cast<cert_t>(x509));
}
} }
return certs.size(); return certs.size();
} }
@@ -20409,7 +20414,8 @@ inline uint64_t get_error() { return ERR_get_error(); }
inline std::string error_string(uint64_t code) { inline std::string error_string(uint64_t code) {
char buf[256]; char buf[256];
ERR_error_string_n(static_cast<unsigned long>(code), buf, sizeof(buf)); ERR_error_string_n(static_cast<decltype(ERR_get_error())>(code), buf,
sizeof(buf));
return std::string(buf); return std::string(buf);
} }
@@ -20423,7 +20429,8 @@ inline ca_store_t create_ca_store(const char *pem, size_t len) {
auto store = X509_STORE_new(); auto store = X509_STORE_new();
if (store) { if (store) {
for (auto i = 0; i < static_cast<int>(sk_X509_INFO_num(inf)); i++) { auto count = sk_X509_INFO_num(inf);
for (decltype(count) i = 0; i < count; i++) {
auto itmp = sk_X509_INFO_value(inf, i); auto itmp = sk_X509_INFO_value(inf, i);
if (!itmp) { continue; } if (!itmp) { continue; }
if (itmp->x509) { X509_STORE_add_cert(store, itmp->x509); } if (itmp->x509) { X509_STORE_add_cert(store, itmp->x509); }
test/test.cc
+44 -60
View File
@@ -2283,27 +2283,21 @@ TEST(ParseHeaderValueTest, Range) {
Ranges ranges; Ranges ranges;
auto ret = detail::parse_range_header("bytes=1-", ranges); auto ret = detail::parse_range_header("bytes=1-", ranges);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
EXPECT_EQ(1u, ranges.size()); EXPECT_EQ((Ranges{{1, -1}}), ranges);
EXPECT_EQ(1u, ranges[0].first);
EXPECT_EQ(-1, ranges[0].second);
} }
{ {
Ranges ranges; Ranges ranges;
auto ret = detail::parse_range_header("bytes=-1", ranges); auto ret = detail::parse_range_header("bytes=-1", ranges);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
EXPECT_EQ(1u, ranges.size()); EXPECT_EQ((Ranges{{-1, 1}}), ranges);
EXPECT_EQ(-1, ranges[0].first);
EXPECT_EQ(1u, ranges[0].second);
} }
{ {
Ranges ranges; Ranges ranges;
auto ret = detail::parse_range_header("bytes=1-10", ranges); auto ret = detail::parse_range_header("bytes=1-10", ranges);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
EXPECT_EQ(1u, ranges.size()); EXPECT_EQ((Ranges{{1, 10}}), ranges);
EXPECT_EQ(1u, ranges[0].first);
EXPECT_EQ(10u, ranges[0].second);
} }
{ {
@@ -2316,11 +2310,7 @@ TEST(ParseHeaderValueTest, Range) {
Ranges ranges; Ranges ranges;
auto ret = detail::parse_range_header("bytes=1-10, 100-", ranges); auto ret = detail::parse_range_header("bytes=1-10, 100-", ranges);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
EXPECT_EQ(2u, ranges.size()); EXPECT_EQ((Ranges{{1, 10}, {100, -1}}), ranges);
EXPECT_EQ(1u, ranges[0].first);
EXPECT_EQ(10u, ranges[0].second);
EXPECT_EQ(100u, ranges[1].first);
EXPECT_EQ(-1, ranges[1].second);
} }
{ {
@@ -2328,13 +2318,7 @@ TEST(ParseHeaderValueTest, Range) {
auto ret = auto ret =
detail::parse_range_header("bytes=1-10, 100-200, 300-400", ranges); detail::parse_range_header("bytes=1-10, 100-200, 300-400", ranges);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
EXPECT_EQ(3u, ranges.size()); EXPECT_EQ((Ranges{{1, 10}, {100, 200}, {300, 400}}), ranges);
EXPECT_EQ(1u, ranges[0].first);
EXPECT_EQ(10u, ranges[0].second);
EXPECT_EQ(100u, ranges[1].first);
EXPECT_EQ(200u, ranges[1].second);
EXPECT_EQ(300u, ranges[2].first);
EXPECT_EQ(400u, ranges[2].second);
} }
{ {
@@ -9900,12 +9884,12 @@ TEST_F(ServerTest, GzipWithContentReceiver) {
Headers headers; Headers headers;
headers.emplace("Accept-Encoding", "gzip, deflate"); headers.emplace("Accept-Encoding", "gzip, deflate");
std::string body; std::string body;
auto res = cli_.Get("/compress", headers, auto res =
[&](const char *data, uint64_t data_length) { cli_.Get("/compress", headers, [&](const char *data, size_t data_length) {
EXPECT_EQ(100U, data_length); EXPECT_EQ(100U, data_length);
body.append(data, data_length); body.append(data, data_length);
return true; return true;
}); });
ASSERT_TRUE(res) << "Error: " << to_string(res.error()); ASSERT_TRUE(res) << "Error: " << to_string(res.error());
EXPECT_EQ("gzip", res->get_header_value("Content-Encoding")); EXPECT_EQ("gzip", res->get_header_value("Content-Encoding"));
@@ -9937,12 +9921,12 @@ TEST_F(ServerTest, GzipWithContentReceiverWithoutAcceptEncoding) {
headers.emplace("Accept-Encoding", ""); headers.emplace("Accept-Encoding", "");
std::string body; std::string body;
auto res = cli_.Get("/compress", headers, auto res =
[&](const char *data, uint64_t data_length) { cli_.Get("/compress", headers, [&](const char *data, size_t data_length) {
EXPECT_EQ(100U, data_length); EXPECT_EQ(100U, data_length);
body.append(data, data_length); body.append(data, data_length);
return true; return true;
}); });
ASSERT_TRUE(res) << "Error: " << to_string(res.error()); ASSERT_TRUE(res) << "Error: " << to_string(res.error());
EXPECT_TRUE(res->get_header_value("Content-Encoding").empty()); EXPECT_TRUE(res->get_header_value("Content-Encoding").empty());
@@ -9974,7 +9958,7 @@ TEST_F(ServerTest, NoGzipWithContentReceiver) {
headers.emplace("Accept-Encoding", "gzip, deflate"); headers.emplace("Accept-Encoding", "gzip, deflate");
std::string body; std::string body;
auto res = cli_.Get("/nocompress", headers, auto res = cli_.Get("/nocompress", headers,
[&](const char *data, uint64_t data_length) { [&](const char *data, size_t data_length) {
EXPECT_EQ(100U, data_length); EXPECT_EQ(100U, data_length);
body.append(data, data_length); body.append(data, data_length);
return true; return true;
@@ -10430,12 +10414,12 @@ TEST_F(ServerTest, ZstdWithContentReceiver) {
Headers headers; Headers headers;
headers.emplace("Accept-Encoding", "zstd"); headers.emplace("Accept-Encoding", "zstd");
std::string body; std::string body;
auto res = cli_.Get("/compress", headers, auto res =
[&](const char *data, uint64_t data_length) { cli_.Get("/compress", headers, [&](const char *data, size_t data_length) {
EXPECT_EQ(100U, data_length); EXPECT_EQ(100U, data_length);
body.append(data, data_length); body.append(data, data_length);
return true; return true;
}); });
ASSERT_TRUE(res) << "Error: " << to_string(res.error()); ASSERT_TRUE(res) << "Error: " << to_string(res.error());
EXPECT_EQ("zstd", res->get_header_value("Content-Encoding")); EXPECT_EQ("zstd", res->get_header_value("Content-Encoding"));
@@ -10474,12 +10458,12 @@ TEST_F(ServerTest, ZstdWithContentReceiverWithoutAcceptEncoding) {
headers.emplace("Accept-Encoding", ""); headers.emplace("Accept-Encoding", "");
std::string body; std::string body;
auto res = cli_.Get("/compress", headers, auto res =
[&](const char *data, uint64_t data_length) { cli_.Get("/compress", headers, [&](const char *data, size_t data_length) {
EXPECT_EQ(100U, data_length); EXPECT_EQ(100U, data_length);
body.append(data, data_length); body.append(data, data_length);
return true; return true;
}); });
ASSERT_TRUE(res) << "Error: " << to_string(res.error()); ASSERT_TRUE(res) << "Error: " << to_string(res.error());
EXPECT_TRUE(res->get_header_value("Content-Encoding").empty()); EXPECT_TRUE(res->get_header_value("Content-Encoding").empty());
@@ -10511,7 +10495,7 @@ TEST_F(ServerTest, NoZstdWithContentReceiver) {
headers.emplace("Accept-Encoding", "zstd"); headers.emplace("Accept-Encoding", "zstd");
std::string body; std::string body;
auto res = cli_.Get("/nocompress", headers, auto res = cli_.Get("/nocompress", headers,
[&](const char *data, uint64_t data_length) { [&](const char *data, size_t data_length) {
EXPECT_EQ(100U, data_length); EXPECT_EQ(100U, data_length);
body.append(data, data_length); body.append(data, data_length);
return true; return true;
@@ -14383,8 +14367,9 @@ TEST_F(LargePayloadMaxLengthTest, NoContentLengthExceeds10MB) {
TEST(ClientPayloadTest, DoesNotReserveTheClaimedLength) { TEST(ClientPayloadTest, DoesNotReserveTheClaimedLength) {
Server svr; Server svr;
svr.Get("/", [](const Request &, Response &res) { svr.Get("/", [](const Request &, Response &res) {
// Claims far more than it sends, then drops the connection. // Claims the most the client accepts, far more than it sends, then drops
res.set_content_provider(size_t(1) << 41, "text/plain", // the connection.
res.set_content_provider(std::string().max_size(), "text/plain",
[](size_t, size_t, DataSink &sink) { [](size_t, size_t, DataSink &sink) {
sink.write("abc", 3); sink.write("abc", 3);
return false; return false;
@@ -21164,7 +21149,7 @@ TEST(Expect100ContinueHandlerTest, ExpectationFailedIsFinalResponse) {
TEST(Expect100ContinueTest, ServerClosesConnection) { TEST(Expect100ContinueTest, ServerClosesConnection) {
static constexpr char reject[] = "Unauthorized"; static constexpr char reject[] = "Unauthorized";
static constexpr char accept[] = "Upload accepted"; static constexpr char accept[] = "Upload accepted";
constexpr size_t total_size = 10 * 1024 * 1024 * 1024ULL; constexpr uint64_t total_size = 10 * 1024 * 1024 * 1024ULL;
Server svr; Server svr;
@@ -21202,8 +21187,8 @@ TEST(Expect100ContinueTest, ServerClosesConnection) {
curl_easy_setopt(curl.get(), CURLOPT_HTTPHEADER, list.get()); curl_easy_setopt(curl.get(), CURLOPT_HTTPHEADER, list.get());
struct read_data { struct read_data {
size_t read_size; uint64_t read_size;
size_t total_size; uint64_t total_size;
} data = {0, total_size}; } data = {0, total_size};
using read_callback_t = using read_callback_t =
size_t (*)(char *ptr, size_t size, size_t nmemb, void *userdata); size_t (*)(char *ptr, size_t size, size_t nmemb, void *userdata);
@@ -25986,8 +25971,7 @@ TEST(SSLClientServerTest, UpdateCertsSetsClientCAList) {
ASSERT_TRUE(ssl_ctx != nullptr); ASSERT_TRUE(ssl_ctx != nullptr);
STACK_OF(X509_NAME) *ca_list_before = SSL_CTX_get_client_CA_list(ssl_ctx); STACK_OF(X509_NAME) *ca_list_before = SSL_CTX_get_client_CA_list(ssl_ctx);
int count_before = ca_list_before ? sk_X509_NAME_num(ca_list_before) : 0; EXPECT_TRUE(!ca_list_before || sk_X509_NAME_num(ca_list_before) == 0);
EXPECT_EQ(0, count_before);
// Now update with client CA (PEM string) // Now update with client CA (PEM string)
std::string cert_pem, key_pem, ca_pem; std::string cert_pem, key_pem, ca_pem;
@@ -26002,7 +25986,7 @@ TEST(SSLClientServerTest, UpdateCertsSetsClientCAList) {
// Now client CA list should be set // Now client CA list should be set
STACK_OF(X509_NAME) *ca_list_after = SSL_CTX_get_client_CA_list(ssl_ctx); STACK_OF(X509_NAME) *ca_list_after = SSL_CTX_get_client_CA_list(ssl_ctx);
ASSERT_TRUE(ca_list_after != nullptr); ASSERT_TRUE(ca_list_after != nullptr);
EXPECT_GT(sk_X509_NAME_num(ca_list_after), 0); EXPECT_TRUE(sk_X509_NAME_num(ca_list_after) > 0);
} }
TEST(SSLClientServerTest, FilePathConstructorSetsClientCAList) { TEST(SSLClientServerTest, FilePathConstructorSetsClientCAList) {
@@ -26016,7 +26000,7 @@ TEST(SSLClientServerTest, FilePathConstructorSetsClientCAList) {
STACK_OF(X509_NAME) *ca_list = SSL_CTX_get_client_CA_list(ssl_ctx); STACK_OF(X509_NAME) *ca_list = SSL_CTX_get_client_CA_list(ssl_ctx);
ASSERT_TRUE(ca_list != nullptr); ASSERT_TRUE(ca_list != nullptr);
EXPECT_GT(sk_X509_NAME_num(ca_list), 0); EXPECT_TRUE(sk_X509_NAME_num(ca_list) > 0);
} }
#endif #endif
@@ -28644,7 +28628,7 @@ static int count_smuggled_requests(const std::string &outer_head,
} }
// Step 1: Send only the outer request headers (no body yet) // Step 1: Send only the outer request headers (no body yet)
auto sent = send(sock, head.data(), head.size(), 0); auto sent = detail::send_socket(sock, head.data(), head.size(), 0);
EXPECT_EQ(static_cast<ssize_t>(head.size()), sent); EXPECT_EQ(static_cast<ssize_t>(head.size()), sent);
// Step 2: Read the first response // Step 2: Read the first response
@@ -28673,7 +28657,7 @@ static int count_smuggled_requests(const std::string &outer_head,
// Step 3: Now send the body, which looks like a new HTTP request. On a // Step 3: Now send the body, which looks like a new HTTP request. On a
// vulnerable server the keep-alive loop reads this as a second request. The // vulnerable server the keep-alive loop reads this as a second request. The
// server may already have closed the connection, so the result is ignored. // server may already have closed the connection, so the result is ignored.
send(sock, smuggled.data(), smuggled.size(), 0); detail::send_socket(sock, smuggled.data(), smuggled.size(), 0);
// Half-close so that a server which drained the body sees EOF and closes, // Half-close so that a server which drained the body sees EOF and closes,
// instead of the read below waiting for the read timeout. // instead of the read below waiting for the read timeout.
@@ -28990,7 +28974,7 @@ TEST(KeepAliveTest, DeleteWithoutContentLengthDoesNotEatNextRequest) {
auto send_request_and_read_response = [&](const std::string &req, auto send_request_and_read_response = [&](const std::string &req,
std::string &out) -> bool { std::string &out) -> bool {
auto sent = send(sock, req.data(), req.size(), 0); auto sent = detail::send_socket(sock, req.data(), req.size(), 0);
if (sent != static_cast<ssize_t>(req.size())) { return false; } if (sent != static_cast<ssize_t>(req.size())) { return false; }
char buf[4096]; char buf[4096];
for (;;) { for (;;) {
@@ -29052,7 +29036,7 @@ TEST(KeepAliveTest, UnconsumedChunkedBodyIsNotDrainedWhenResponseCloses) {
"\r\n" "\r\n"
"4\r\n" "4\r\n"
"data\r\n"; "data\r\n";
auto sent = send(sock, request.data(), request.size(), 0); auto sent = detail::send_socket(sock, request.data(), request.size(), 0);
ASSERT_EQ(static_cast<ssize_t>(request.size()), sent); ASSERT_EQ(static_cast<ssize_t>(request.size()), sent);
std::string response; std::string response;