Release v0.17.2

Fix fuzzing test error
Fixed build error
2026-06-08 18:30:49 +00:00 · 2024-09-05 12:57:26 -04:00 · 2024-09-05 12:50:05 -04:00 · 2024-09-05 12:27:50 -04:00 · 2024-09-05 12:22:46 -04:00 · 2024-09-05 12:09:38 -04:00
15 changed files with 14691 additions and 68 deletions
@@ -8,8 +8,8 @@ jobs:
    steps:
      - name: checkout
        uses: actions/checkout@v4
-      - name: install brotli
-        run: sudo apt-get update && sudo apt-get install -y libbrotli-dev
+      - name: install libraries
+        run: sudo apt-get update && sudo apt-get install -y libbrotli-dev libcurl4-openssl-dev
      - name: build and run tests
        run: cd test && make -j4
      - name: run fuzz test target
@@ -21,6 +21,8 @@ test/test.xcodeproj/*/xcuser*
 test/*.o
 test/*.pem
 test/*.srl
+benchmark/server
+benchmark/server-crow

 *.swp

@@ -34,6 +36,7 @@ Release
 *.db
 ipch
 *.dSYM
+*.pyc
 .*
 !/.gitattributes
 !/.travis.yml
@@ -1,8 +1,7 @@
-FROM ubuntu AS builder
+FROM yhirose4dockerhub/ubuntu-builder AS builder
 WORKDIR /build
 COPY httplib.h .
 COPY docker/main.cc .
-RUN apt update && apt install g++ -y
 RUN g++ -std=c++23 -static -o server -O2 -I. -DCPPHTTPLIB_USE_POLL main.cc && strip server

 FROM scratch
@@ -857,6 +857,19 @@ Dockerfile for static HTTP server is available. Port number of this HTTP server
 > docker build -t cpp-httplib-server .
 ...

+> docker run --rm -it -p 8080:80 -v ./docker/html:/html cpp-httplib-server
+Serving HTTP on 0.0.0.0 port 80 ...
+192.168.65.1 - - [31/Aug/2024:21:33:56 +0000] "GET / HTTP/1.1" 200 599 "-" "curl/8.7.1"
+192.168.65.1 - - [31/Aug/2024:21:34:26 +0000] "GET / HTTP/1.1" 200 599 "-" "Mozilla/5.0 ..."
+192.168.65.1 - - [31/Aug/2024:21:34:26 +0000] "GET /favicon.ico HTTP/1.1" 404 152 "-" "Mozilla/5.0 ..."
+```
+
+From Docker Hub
+
+```bash
+> docker run --rm -it -p 8080:80 -v ./docker/html:/html yhirose4dockerhub/cpp-httplib-server
+...
+
 > docker run --init --rm -it -p 8080:80 -v ./docker/html:/html cpp-httplib-server
 Serving HTTP on 0.0.0.0 port 80 ...
 192.168.65.1 - - [31/Aug/2024:21:33:56 +0000] "GET / HTTP/1.1" 200 599 "-" "curl/8.7.1"
@@ -0,0 +1,31 @@
+CXXFLAGS = -std=c++14 -O2 -I..
+
+THEAD_POOL_COUNT = 16
+BENCH_FLAGS = -c 8 -d 5s
+
+# cpp-httplib
+bench: server
+	@./server & export PID=$$!; bombardier $(BENCH_FLAGS) localhost:8080; kill $${PID}
+
+server : cpp-httplib/main.cpp ../httplib.h
+	g++ -o $@ $(CXXFLAGS) -DCPPHTTPLIB_THREAD_POOL_COUNT=$(THEAD_POOL_COUNT) cpp-httplib/main.cpp
+
+run : server
+	@./server
+
+# crow
+server-crow : crow/main.cpp
+	g++ -o $@ $(CXXFLAGS) crow/main.cpp
+
+bench-crow: server-crow
+	@./server-crow & export PID=$$!; bombardier $(BENCH_FLAGS) localhost:8080; kill $${PID}
+
+# flask
+bench-flask:
+	@FLASK_APP=flask/main.py flask run --port=8080 & export PID=$$!; bombardier $(BENCH_FLAGS) localhost:8080; kill $${PID}
+
+# misc
+bench-all: bench bench-crow bench-flask
+
+clean:
+	rm -rf server*
@@ -0,0 +1,12 @@
+#include "httplib.h"
+using namespace httplib;
+
+int main() {
+  Server svr;
+
+  svr.Get("/", [](const Request &, Response &res) {
+    res.set_content("Hello World!", "text/plain");
+  });
+
+  svr.listen("0.0.0.0", 8080);
+}
@@ -0,0 +1,17 @@
+#include "crow_all.h"
+
+class CustomLogger : public crow::ILogHandler {
+public:
+  void log(std::string, crow::LogLevel) {}
+};
+
+int main() {
+  CustomLogger logger;
+  crow::logger::setHandler(&logger);
+
+  crow::SimpleApp app;
+
+  CROW_ROUTE(app, "/")([]() { return "Hello world!"; });
+
+  app.port(8080).multithreaded().run();
+}
@@ -0,0 +1,9 @@
+from flask import Flask
+app = Flask(__name__)
+
+import logging
+logging.getLogger('werkzeug').disabled = True
+
+@app.route('/')
+def hello_world():
+    return 'Hello, World!'
@@ -23,6 +23,8 @@ constexpr auto error_html = R"(<html>
 </html>
 )";

+void sigint_handler(int s) { exit(1); }
+
 std::string time_local() {
  auto p = std::chrono::system_clock::now();
  auto t = std::chrono::system_clock::to_time_t(p);
@@ -49,6 +51,8 @@ std::string log(auto &req, auto &res) {
 }

 int main(int argc, const char **argv) {
+  signal(SIGINT, sigint_handler);
+
  auto base_dir = "./html";
  auto host = "0.0.0.0";
  auto port = 80;
@@ -8,7 +8,7 @@
 #ifndef CPPHTTPLIB_HTTPLIB_H
 #define CPPHTTPLIB_HTTPLIB_H

-#define CPPHTTPLIB_VERSION "0.17.0"
+#define CPPHTTPLIB_VERSION "0.17.2"

 /*
 * Configuration
@@ -321,13 +321,49 @@ make_unique(std::size_t n) {
  return std::unique_ptr<T>(new RT[n]);
 }

-struct ci {
+inline unsigned char to_lower(int c) {
+  const static unsigned char table[256] = {
+      0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  14,
+      15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,
+      30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,
+      45,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,
+      60,  61,  62,  63,  64,  97,  98,  99,  100, 101, 102, 103, 104, 105, 106,
+      107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
+      122, 91,  92,  93,  94,  95,  96,  97,  98,  99,  100, 101, 102, 103, 104,
+      105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
+      120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
+      135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
+      150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164,
+      165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179,
+      180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 224, 225, 226,
+      227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241,
+      242, 243, 244, 245, 246, 215, 248, 249, 250, 251, 252, 253, 254, 223, 224,
+      225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
+      240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254,
+      255,
+  };
+  return table[(unsigned char)(char)c];
+}
+
+struct case_ignore_equal {
  bool operator()(const std::string &s1, const std::string &s2) const {
-    return std::lexicographical_compare(s1.begin(), s1.end(), s2.begin(),
-                                        s2.end(),
-                                        [](unsigned char c1, unsigned char c2) {
-                                          return ::tolower(c1) < ::tolower(c2);
-                                        });
+    return s1.size() == s2.size() &&
+           std::equal(s1.begin(), s1.end(), s2.begin(), [](char a, char b) {
+             return to_lower(a) == to_lower(b);
+           });
+  }
+};
+
+struct case_ignore_hash {
+  constexpr size_t operator()(const std::string &key) const {
+    return hash_core(key.data(), key.size(), 0);
+  }
+
+  constexpr size_t hash_core(const char *s, size_t l, size_t h) const {
+    return (l == 0)
+               ? h
+               : hash_core(s + 1, l - 1,
+                           (h * 33) ^ static_cast<unsigned char>(to_lower(*s)));
  }
 };

@@ -436,7 +472,9 @@ enum StatusCode {
  NetworkAuthenticationRequired_511 = 511,
 };

-using Headers = std::multimap<std::string, std::string, detail::ci>;
+using Headers =
+    std::unordered_multimap<std::string, std::string, detail::case_ignore_hash,
+                            detail::case_ignore_equal>;

 using Params = std::multimap<std::string, std::string>;
 using Match = std::smatch;
@@ -2198,6 +2236,10 @@ make_basic_authentication_header(const std::string &username,

 namespace detail {

+bool is_file(const std::string &path);
+
+bool is_dir(const std::string &path);
+
 std::string encode_query_param(const std::string &value);

 std::string decode_url(const std::string &s, bool convert_plus_to_space);
@@ -2525,20 +2567,6 @@ inline std::string base64_encode(const std::string &in) {
  return out;
 }

-inline bool is_file(const std::string &path) {
-#ifdef _WIN32
-  return _access_s(path.c_str(), 0) == 0;
-#else
-  struct stat st;
-  return stat(path.c_str(), &st) >= 0 && S_ISREG(st.st_mode);
-#endif
-}
-
-inline bool is_dir(const std::string &path) {
-  struct stat st;
-  return stat(path.c_str(), &st) >= 0 && S_ISDIR(st.st_mode);
-}
-
 inline bool is_valid_path(const std::string &path) {
  size_t level = 0;
  size_t i = 0;
@@ -2581,6 +2609,16 @@ inline bool is_valid_path(const std::string &path) {
  return true;
 }

+inline bool is_file(const std::string &path) {
+  struct stat st;
+  return stat(path.c_str(), &st) >= 0 && S_ISREG(st.st_mode);
+}
+
+inline bool is_dir(const std::string &path) {
+  struct stat st;
+  return stat(path.c_str(), &st) >= 0 && S_ISDIR(st.st_mode);
+}
+
 inline std::string encode_query_param(const std::string &value) {
  std::ostringstream escaped;
  escaped.fill('0');
@@ -2790,6 +2828,10 @@ inline bool stream_line_reader::getline() {
  fixed_buffer_used_size_ = 0;
  glowable_buffer_.clear();

+#ifndef CPPHTTPLIB_ALLOW_LF_AS_LINE_TERMINATOR
+  char prev_byte = 0;
+#endif
+
  for (size_t i = 0;; i++) {
    char byte;
    auto n = strm_.read(&byte, 1);
@@ -2806,7 +2848,12 @@ inline bool stream_line_reader::getline() {

    append(byte);

+#ifdef CPPHTTPLIB_ALLOW_LF_AS_LINE_TERMINATOR
    if (byte == '\n') { break; }
+#else
+    if (prev_byte == '\r' && byte == '\n') { break; }
+    prev_byte = byte;
+#endif
  }

  return true;
@@ -2847,9 +2894,7 @@ inline bool mmap::open(const char *path) {
    wpath += path[i];
  }

-#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM |   \
-                            WINAPI_PARTITION_GAMES) &&                         \
-    (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
+#if _WIN32_WINNT >= _WIN32_WINNT_WIN8
  hFile_ = ::CreateFile2(wpath.c_str(), GENERIC_READ, FILE_SHARE_READ,
                         OPEN_EXISTING, NULL);
 #else
@@ -2859,26 +2904,23 @@ inline bool mmap::open(const char *path) {

  if (hFile_ == INVALID_HANDLE_VALUE) { return false; }

-#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM |   \
-                            WINAPI_PARTITION_GAMES)
  LARGE_INTEGER size{};
  if (!::GetFileSizeEx(hFile_, &size)) { return false; }
+  // If the following line doesn't compile due to QuadPart, update Windows SDK.
+  // See:
+  // https://github.com/yhirose/cpp-httplib/issues/1903#issuecomment-2316520721
+  if (static_cast<ULONGLONG>(size.QuadPart) >
+      (std::numeric_limits<decltype(size_)>::max)()) {
+    // `size_t` might be 32-bits, on 32-bits Windows.
+    return false;
+  }
  size_ = static_cast<size_t>(size.QuadPart);
-#else
-  DWORD sizeHigh;
-  DWORD sizeLow;
-  sizeLow = ::GetFileSize(hFile_, &sizeHigh);
-  if (sizeLow == INVALID_FILE_SIZE) { return false; }
-  size_ = (static_cast<size_t>(sizeHigh) << (sizeof(DWORD) * 8)) | sizeLow;
-#endif

-#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM) && \
-    (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
+#if _WIN32_WINNT >= _WIN32_WINNT_WIN8
  hMapping_ =
      ::CreateFileMappingFromApp(hFile_, NULL, PAGE_READONLY, size_, NULL);
 #else
-  hMapping_ = ::CreateFileMappingW(hFile_, NULL, PAGE_READONLY, size.HighPart,
-                                   size.LowPart, NULL);
+  hMapping_ = ::CreateFileMappingW(hFile_, NULL, PAGE_READONLY, 0, 0, NULL);
 #endif

  if (hMapping_ == NULL) {
@@ -2886,8 +2928,7 @@ inline bool mmap::open(const char *path) {
    return false;
  }

-#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM) && \
-    (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
+#if _WIN32_WINNT >= _WIN32_WINNT_WIN8
  addr_ = ::MapViewOfFileFromApp(hMapping_, FILE_MAP_READ, 0, 0);
 #else
  addr_ = ::MapViewOfFile(hMapping_, FILE_MAP_READ, 0, 0, 0);
@@ -3247,6 +3288,25 @@ inline int shutdown_socket(socket_t sock) {
 #endif
 }

+inline std::string escape_abstract_namespace_unix_domain(const std::string &s) {
+  if (s.size() > 1 && s[0] == '\0') {
+    auto ret = s;
+    ret[0] = '@';
+    return ret;
+  }
+  return s;
+}
+
+inline std::string
+unescape_abstract_namespace_unix_domain(const std::string &s) {
+  if (s.size() > 1 && s[0] == '@') {
+    auto ret = s;
+    ret[0] = '\0';
+    return ret;
+  }
+  return s;
+}
+
 template <typename BindOrConnect>
 socket_t create_socket(const std::string &host, const std::string &ip, int port,
                       int address_family, int socket_flags, bool tcp_nodelay,
@@ -3259,7 +3319,7 @@ socket_t create_socket(const std::string &host, const std::string &ip, int port,

  memset(&hints, 0, sizeof(struct addrinfo));
  hints.ai_socktype = SOCK_STREAM;
-  hints.ai_protocol = 0;
+  hints.ai_protocol = IPPROTO_IP;

  if (!ip.empty()) {
    node = ip.c_str();
@@ -3287,7 +3347,9 @@ socket_t create_socket(const std::string &host, const std::string &ip, int port,
    if (sock != INVALID_SOCKET) {
      sockaddr_un addr{};
      addr.sun_family = AF_UNIX;
-      std::copy(host.begin(), host.end(), addr.sun_path);
+
+      auto unescaped_host = unescape_abstract_namespace_unix_domain(host);
+      std::copy(unescaped_host.begin(), unescaped_host.end(), addr.sun_path);

      hints.ai_addr = reinterpret_cast<sockaddr *>(&addr);
      hints.ai_addrlen = static_cast<socklen_t>(
@@ -3983,7 +4045,7 @@ inline const char *get_header_value(const Headers &headers,
 inline bool compare_case_ignore(const std::string &a, const std::string &b) {
  if (a.size() != b.size()) { return false; }
  for (size_t i = 0; i < b.size(); i++) {
-    if (::tolower(a[i]) != ::tolower(b[i])) { return false; }
+    if (to_lower(a[i]) != to_lower(b[i])) { return false; }
  }
  return true;
 }
@@ -4018,6 +4080,18 @@ inline bool parse_header(const char *beg, const char *end, T fn) {
    auto val = compare_case_ignore(key, "Location")
                   ? std::string(p, end)
                   : decode_url(std::string(p, end), false);
+
+    // NOTE: From RFC 9110:
+    // Field values containing CR, LF, or NUL characters are
+    // invalid and dangerous, due to the varying ways that
+    // implementations might parse and interpret those
+    // characters; a recipient of CR, LF, or NUL within a field
+    // value MUST either reject the message or replace each of
+    // those characters with SP before further processing or
+    // forwarding of that message.
+    static const std::string CR_LF_NUL("\r\n\0", 3);
+    if (val.find_first_of(CR_LF_NUL) != std::string::npos) { return false; }
+
    fn(key, val);
    return true;
  }
@@ -4055,10 +4129,12 @@ inline bool read_headers(Stream &strm, Headers &headers) {
    // Exclude line terminator
    auto end = line_reader.ptr() + line_reader.size() - line_terminator_len;

-    parse_header(line_reader.ptr(), end,
-                 [&](const std::string &key, const std::string &val) {
-                   headers.emplace(key, val);
-                 });
+    if (!parse_header(line_reader.ptr(), end,
+                      [&](const std::string &key, std::string &val) {
+                        headers.emplace(key, val);
+                      })) {
+      return false;
+    }
  }

  return true;
@@ -4784,7 +4860,7 @@ private:
                              const std::string &b) const {
    if (a.size() < b.size()) { return false; }
    for (size_t i = 0; i < b.size(); i++) {
-      if (::tolower(a[i]) != ::tolower(b[i])) { return false; }
+      if (to_lower(a[i]) != to_lower(b[i])) { return false; }
    }
    return true;
  }
@@ -4867,16 +4943,6 @@ private:
  size_t buf_epos_ = 0;
 };

-inline std::string to_lower(const char *beg, const char *end) {
-  std::string out;
-  auto it = beg;
-  while (it != end) {
-    out += static_cast<char>(::tolower(*it));
-    it++;
-  }
-  return out;
-}
-
 inline std::string random_string(size_t length) {
  static const char data[] =
      "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
@@ -6938,7 +7004,9 @@ Server::process_request(Stream &strm, bool close_connection,
      strm.write_format("HTTP/1.1 %d %s\r\n\r\n", status,
                        status_message(status));
      break;
-    default: return write_response(strm, close_connection, req, res);
+    default:
+      connection_closed = true;
+      return write_response(strm, true, req, res);
    }
  }

@@ -7027,8 +7095,8 @@ inline ClientImpl::ClientImpl(const std::string &host, int port)
 inline ClientImpl::ClientImpl(const std::string &host, int port,
                              const std::string &client_cert_path,
                              const std::string &client_key_path)
-    : host_(host), port_(port),
-      host_and_port_(adjust_host_string(host) + ":" + std::to_string(port)),
+    : host_(detail::escape_abstract_namespace_unix_domain(host)), port_(port),
+      host_and_port_(adjust_host_string(host_) + ":" + std::to_string(port)),
      client_cert_path_(client_cert_path), client_key_path_(client_key_path) {}

 inline ClientImpl::~ClientImpl() {
@@ -24,9 +24,11 @@ else()
    FetchContent_MakeAvailable(gtest)
 endif()

+find_package(curl REQUIRED)
+
 add_executable(httplib-test test.cc)
 target_compile_options(httplib-test PRIVATE "$<$<CXX_COMPILER_ID:MSVC>:/utf-8;/bigobj>")
-target_link_libraries(httplib-test PRIVATE httplib GTest::gtest_main)
+target_link_libraries(httplib-test PRIVATE httplib GTest::gtest_main CURL::libcurl)
 gtest_discover_tests(httplib-test)

 file(
@@ -18,7 +18,7 @@ ZLIB_SUPPORT = -DCPPHTTPLIB_ZLIB_SUPPORT -lz
 BROTLI_DIR = $(PREFIX)/opt/brotli
 BROTLI_SUPPORT = -DCPPHTTPLIB_BROTLI_SUPPORT -I$(BROTLI_DIR)/include -L$(BROTLI_DIR)/lib -lbrotlicommon -lbrotlienc -lbrotlidec

-TEST_ARGS = gtest/gtest-all.cc gtest/gtest_main.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT) $(BROTLI_SUPPORT) -pthread
+TEST_ARGS = gtest/gtest-all.cc gtest/gtest_main.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT) $(BROTLI_SUPPORT) -pthread -lcurl

 # By default, use standalone_fuzz_target_runner.
 # This runner does no fuzzing, but simply executes the inputs
@@ -3,6 +3,7 @@
 # SPDX-License-Identifier: MIT

 gtest_dep = dependency('gtest', main: true)
+libcurl_dep = dependency('libcurl')
 openssl = find_program('openssl')
 test_conf = files('test.conf')

@@ -119,7 +120,8 @@ test(
    'test.cc',
    dependencies: [
      cpp_httplib_dep,
-      gtest_dep
+      gtest_dep,
+      libcurl_dep
    ],
    override_options: test_options
  ),
@@ -1,6 +1,9 @@
 #include <httplib.h>
 #include <signal.h>

+#ifndef _WIN32
+#include <curl/curl.h>
+#endif
 #include <gtest/gtest.h>

 #include <atomic>
@@ -12,6 +15,7 @@
 #include <stdexcept>
 #include <thread>
 #include <type_traits>
+#include <vector>

 #define SERVER_CERT_FILE "./cert.pem"
 #define SERVER_CERT2_FILE "./cert2.pem"
@@ -4718,6 +4722,9 @@ static void test_raw_request(const std::string &req,
  svr.Put("/put_hi", [&](const Request & /*req*/, Response &res) {
    res.set_content("ok", "text/plain");
  });
+  svr.Get("/header_field_value_check", [&](const Request &/*req*/, Response &res) {
+    res.set_content("ok", "text/plain");
+  });

  // Server read timeout must be longer than the client read timeout for the
  // bug to reproduce, probably to force the server to process a request
@@ -4851,6 +4858,14 @@ TEST(ServerRequestParsingTest, InvalidSpaceInURL) {
  EXPECT_EQ("HTTP/1.1 400 Bad Request", out.substr(0, 24));
 }

+TEST(ServerRequestParsingTest, InvalidFieldValueContains_CR_LF_NUL) {
+  std::string out;
+  std::string request(
+      "GET /header_field_value_check HTTP/1.1\r\nTest: [\r\x00\n]\r\n\r\n", 55);
+  test_raw_request(request, &out);
+  EXPECT_EQ("HTTP/1.1 400 Bad Request", out.substr(0, 24));
+}
+
 TEST(ServerStopTest, StopServerWithChunkedTransmission) {
  Server svr;

@@ -7561,3 +7576,135 @@ TEST(UniversalClientImplTest, Ipv6LiteralAddress) {
             CLIENT_PRIVATE_KEY_FILE);
  EXPECT_EQ(cli.port(), port);
 }
+
+TEST(FileSystemTest, FileAndDirExistenceCheck) {
+  auto file_path = "./www/dir/index.html";
+  auto dir_path = "./www/dir";
+
+  EXPECT_TRUE(detail::is_file(file_path));
+  EXPECT_FALSE(detail::is_dir(file_path));
+
+  EXPECT_FALSE(detail::is_file(dir_path));
+  EXPECT_TRUE(detail::is_dir(dir_path));
+}
+
+TEST(DirtyDataRequestTest, HeadFieldValueContains_CR_LF_NUL) {
+  Server svr;
+
+  svr.Get("/test", [&](const Request &/*req*/, Response &res) {
+    EXPECT_EQ(res.status, 400);
+  });
+
+  auto thread = std::thread([&]() { svr.listen(HOST, PORT); });
+
+  auto se = detail::scope_exit([&] {
+    svr.stop();
+    thread.join();
+    ASSERT_FALSE(svr.is_running());
+  });
+
+  svr.wait_until_ready();
+
+  Client cli(HOST, PORT);
+  cli.Get("/test", {{"Test", "_\n\r_\n\r_"}});
+}
+
+#ifndef _WIN32
+TEST(Expect100ContinueTest, ServerClosesConnection) {
+  static constexpr char reject[] = "Unauthorized";
+  static constexpr char accept[] = "Upload accepted";
+  constexpr size_t total_size = 10 * 1024 * 1024 * 1024ULL;
+
+  Server svr;
+
+  svr.set_expect_100_continue_handler([](const Request &/*req*/, Response &res) {
+    res.status = StatusCode::Unauthorized_401;
+    res.set_content(reject, "text/plain");
+    return res.status;
+  });
+  svr.Post("/", [&](const Request & /*req*/, Response &res) {
+    res.set_content(accept, "text/plain");
+  });
+
+  auto thread = std::thread([&]() { svr.listen(HOST, PORT); });
+  auto se = detail::scope_exit([&] {
+    svr.stop();
+    thread.join();
+    ASSERT_FALSE(svr.is_running());
+  });
+
+  svr.wait_until_ready();
+
+  {
+    const auto curl = std::unique_ptr<CURL, decltype(&curl_easy_cleanup)>{
+        curl_easy_init(), &curl_easy_cleanup};
+    ASSERT_NE(curl, nullptr);
+
+    curl_easy_setopt(curl.get(), CURLOPT_URL, HOST);
+    curl_easy_setopt(curl.get(), CURLOPT_PORT, PORT);
+    curl_easy_setopt(curl.get(), CURLOPT_POST, 1L);
+    auto list = std::unique_ptr<curl_slist, decltype(&curl_slist_free_all)>{
+        curl_slist_append(nullptr, "Content-Type: application/octet-stream"),
+        &curl_slist_free_all};
+    ASSERT_NE(list, nullptr);
+    curl_easy_setopt(curl.get(), CURLOPT_HTTPHEADER, list.get());
+
+    struct read_data {
+      size_t read_size;
+      size_t total_size;
+    } data = {0, total_size};
+    using read_callback_t =
+        size_t (*)(char *ptr, size_t size, size_t nmemb, void *userdata);
+    read_callback_t read_callback = [](char *ptr, size_t size, size_t nmemb,
+                                       void *userdata) -> size_t {
+      read_data *data = (read_data *)userdata;
+
+      if (!userdata || data->read_size >= data->total_size) { return 0; }
+
+      std::fill_n(ptr, size * nmemb, 'A');
+      data->read_size += size * nmemb;
+      return size * nmemb;
+    };
+    curl_easy_setopt(curl.get(), CURLOPT_READDATA, data);
+    curl_easy_setopt(curl.get(), CURLOPT_READFUNCTION, read_callback);
+
+    std::vector<char> buffer;
+    curl_easy_setopt(curl.get(), CURLOPT_WRITEDATA, &buffer);
+    using write_callback_t =
+        size_t (*)(char *ptr, size_t size, size_t nmemb, void *userdata);
+    write_callback_t write_callback = [](char *ptr, size_t size, size_t nmemb,
+                                         void *userdata) -> size_t {
+      std::vector<char> *buffer = (std::vector<char> *)userdata;
+      buffer->reserve(buffer->size() + size * nmemb + 1);
+      buffer->insert(buffer->end(), (char *)ptr, (char *)ptr + size * nmemb);
+      return size * nmemb;
+    };
+    curl_easy_setopt(curl.get(), CURLOPT_WRITEFUNCTION, write_callback);
+
+    {
+      const auto res = curl_easy_perform(curl.get());
+      ASSERT_EQ(res, CURLE_OK);
+    }
+
+    {
+      auto response_code = long{};
+      const auto res =
+          curl_easy_getinfo(curl.get(), CURLINFO_RESPONSE_CODE, &response_code);
+      ASSERT_EQ(res, CURLE_OK);
+      ASSERT_EQ(response_code, StatusCode::Unauthorized_401);
+    }
+
+    {
+      auto dl = curl_off_t{};
+      const auto res = curl_easy_getinfo(curl.get(), CURLINFO_SIZE_DOWNLOAD_T, &dl);
+      ASSERT_EQ(res, CURLE_OK);
+      ASSERT_EQ(dl, sizeof reject - 1);
+    }
+
+    {
+      buffer.push_back('\0');
+      ASSERT_STRCASEEQ(buffer.data(), reject);
+    }
+  }
+}
+#endif
Author	SHA1	Message	Date
yhirose	ef63f97afe	Release v0.17.2	2024-09-05 12:57:26 -04:00
yhirose	bda74db01d	Fix fuzzing test error	2024-09-05 12:50:05 -04:00
yhirose	9ff3ff9446	Fixed build error	2024-09-05 12:27:50 -04:00
yhirose	c75d071615	Add benchmark tool	2024-09-05 12:22:46 -04:00
yhirose	b4989130da	Peformance improvement by removing `tolower` function call	2024-09-05 12:09:38 -04:00
yhirose	4fc0303bda	clangformat	2024-09-05 12:07:35 -04:00
yhirose	3d9cc51851	Fixed build error on Windows due to `max` macro in windows.h	2024-09-05 12:02:40 -04:00
Andrea Pappacoda	f69587656f	build(meson): add libcurl test dependency (#1914 ) Prompted by PR #1911	2024-09-04 18:05:03 -04:00
yhirose	d5fc340c30	Update README	2024-09-04 12:23:48 -04:00
yhirose	d79a547dc9	Merge branch 'solarispika-fix-100-continue'	2024-09-04 10:17:01 -04:00
yhirose	bd1da4346a	Disable Expect100ContinueTest test on Windows	2024-09-04 09:51:36 -04:00
yhirose	4c2a608a0c	Fix GitHub Actions errors	2024-09-04 09:06:27 -04:00
yhirose	ee4eb8deaa	Merge branch 'fix-100-continue' of github.com:solarispika/cpp-httplib into solarispika-fix-100-continue	2024-09-04 08:45:48 -04:00
Sung, Po Han	7196ac8a07	Fix incorrect handling of Expect: 100-continue Fix #1808	2024-09-04 17:50:42 +08:00
yhirose	c88b09bc6b	Release v0.17.1	2024-09-03 21:20:57 -04:00
yhirose	87fab847b8	Fix SIGINT problem in Docker image	2024-09-03 21:20:10 -04:00
yhirose	4e6055f084	Fix problem with Abstract Namespace Unix Domain	2024-09-03 20:56:16 -04:00
yhirose	975cf0dae5	Fix #1908	2024-09-03 18:00:12 -04:00
yhirose	4854a694cd	Use IPPROTO_IP	2024-09-03 17:29:28 -04:00
yhirose	b1f8e986bf	Fix #1908 (#1910 ) * Fix #1908 * Code format	2024-09-03 00:47:39 -04:00
yhirose	c5ee208775	Fix build error on Mac and Linux	2024-09-02 23:04:38 -04:00
yhirose	ddfdacfa49	Fix build error	2024-09-02 22:49:31 -04:00
yhirose	2514ebc20f	Fix #1848	2024-09-02 20:38:01 -04:00
yhirose	4f9c6540b2	Fixed warning	2024-09-02 20:33:33 -04:00
mol123	21c9a6a1ff	Windows: simplify conditional compilation and fix call to CreateFileMappingW. (#1909 )	2024-09-02 18:01:05 -04:00