Updated version in the User Agent string

This gets us the full version (aka with the patch version), instead of
just major and minor version from user agent.

Falls back to the user agent if it fails.

CMakeLists.txt

@@ -0,0 +1,273 @@
+#[[
+	Build options:
+	* HTTPLIB_USE_OPENSSL_IF_AVAILABLE (default on)
+	* HTTPLIB_USE_ZLIB_IF_AVAILABLE (default on)
+	* HTTPLIB_REQUIRE_OPENSSL (default off)
+	* HTTPLIB_REQUIRE_ZLIB (default off)
+	* HTTPLIB_COMPILE (default off)
+
+	-------------------------------------------------------------------------------
+
+	After installation with Cmake, a find_package(httplib) is available.
+	This creates a httplib::httplib target (if found).
+	It can be linked like so:
+
+	target_link_libraries(your_exe httplib::httplib)
+
+	The following will build & install for later use.
+
+	Linux/macOS:
+
+	mkdir -p build
+	cd build
+	cmake -DCMAKE_BUILD_TYPE=Release ..
+	sudo cmake --build . --target install
+
+	Windows:
+
+	mkdir build
+	cd build
+	cmake ..
+	runas /user:Administrator "cmake --build . --config Release --target install"
+
+	-------------------------------------------------------------------------------
+
+	These variables are available after you run find_package(httplib)
+	* HTTPLIB_HEADER_PATH - this is the full path to the installed header (e.g. /usr/include/httplib.h).
+	* HTTPLIB_IS_USING_OPENSSL - a bool for if OpenSSL support is enabled.
+	* HTTPLIB_IS_USING_ZLIB - a bool for if ZLIB support is enabled.
+	* HTTPLIB_IS_COMPILED - a bool for if the library is compiled, or otherwise header-only.
+	* HTTPLIB_INCLUDE_DIR - the root path to httplib's header (e.g. /usr/include).
+	* HTTPLIB_LIBRARY - the full path to the library if compiled (e.g. /usr/lib/libhttplib.so).
+	* HTTPLIB_VERSION - the project's version string.
+	* HTTPLIB_FOUND - a bool for if the target was found.
+
+	Want to use precompiled headers (Cmake feature since v3.16)?
+	It's as simple as doing the following (before linking):
+
+	target_precompile_headers(httplib::httplib INTERFACE "${HTTPLIB_HEADER_PATH}")
+
+	-------------------------------------------------------------------------------
+
+	FindPython3 requires Cmake v3.12
+]]
+cmake_minimum_required(VERSION 3.12.0 FATAL_ERROR)
+
+# Gets the latest tag as a string like "v0.6.6"
+# Can silently fail if git isn't on the system
+execute_process(COMMAND git describe --tags --abbrev=0
+	OUTPUT_VARIABLE _raw_version_string
+	ERROR_VARIABLE _git_tag_error
+)
+
+# execute_process can fail silenty, so check for an error
+# if there was an error, just use the user agent as a version
+if(_git_tag_error)
+	message(WARNING "cpp-httplib failed to find the latest git tag, falling back to using user agent as the version.")
+	# Get the user agent and use it as a version
+	# This gets the string with the user agent from the header.
+	# This is so the maintainer doesn't actually need to update this manually.
+	file(STRINGS httplib.h _raw_version_string REGEX "User\-Agent.*cpp\-httplib/([0-9]+\.?)+")
+endif()
+# Needed since git tags have "v" prefixing them.
+# Also used if the fallback to user agent string is being used.
+string(REGEX MATCH "([0-9]+\\.?)+" _httplib_version "${_raw_version_string}")
+
+project(httplib VERSION ${_httplib_version} LANGUAGES CXX)
+
+# Change as needed to set an OpenSSL minimum version.
+# This is used in the installed Cmake config file.
+set(_HTTPLIB_OPENSSL_MIN_VER "1.1.1")
+
+# Allow for a build to require OpenSSL to pass, instead of just being optional
+option(HTTPLIB_REQUIRE_OPENSSL "Requires OpenSSL to be found & linked, or fails build." OFF)
+option(HTTPLIB_REQUIRE_ZLIB "Requires ZLIB to be found & linked, or fails build." OFF)
+# Allow for a build to casually enable OpenSSL/ZLIB support, but silenty continue if not found.
+# Make these options so their automatic use can be specifically disabled (as needed)
+option(HTTPLIB_USE_OPENSSL_IF_AVAILABLE "Uses OpenSSL (if available) to enable HTTPS support." ON)
+option(HTTPLIB_USE_ZLIB_IF_AVAILABLE "Uses ZLIB (if available) to enable compression support." ON)
+# Lets you compile the program as a regular library instead of header-only
+option(HTTPLIB_COMPILE "If ON, uses a Python script to split the header into a compilable header & source file (requires Python v3)." OFF)
+# Defaults to static library
+option(BUILD_SHARED_LIBS "Build the library as a shared library instead of static. Has no effect if using header-only." OFF)
+if (BUILD_SHARED_LIBS AND WIN32 AND HTTPLIB_COMPILE)
+	# Necessary for Windows if building shared libs
+	# See https://stackoverflow.com/a/40743080
+	set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
+endif()
+
+# Threads needed for <thread> on some systems, and for <pthread.h> on Linux
+find_package(Threads REQUIRED)
+# Since Cmake v3.11, Crypto & SSL became optional when not specified as COMPONENTS.
+if(HTTPLIB_REQUIRE_OPENSSL)
+	find_package(OpenSSL ${_HTTPLIB_OPENSSL_MIN_VER} COMPONENTS Crypto SSL REQUIRED)
+elseif(HTTPLIB_USE_OPENSSL_IF_AVAILABLE)
+	find_package(OpenSSL ${_HTTPLIB_OPENSSL_MIN_VER} COMPONENTS Crypto SSL QUIET)
+endif()
+if(HTTPLIB_REQUIRE_ZLIB)
+	find_package(ZLIB REQUIRED)
+elseif(HTTPLIB_USE_ZLIB_IF_AVAILABLE)
+	find_package(ZLIB QUIET)
+endif()
+
+# Used for default, common dirs that the end-user can change (if needed)
+# like CMAKE_INSTALL_INCLUDEDIR or CMAKE_INSTALL_DATADIR
+include(GNUInstallDirs)
+
+if(HTTPLIB_COMPILE)
+	# Put the split script into the build dir
+	configure_file(split.py "${CMAKE_CURRENT_BINARY_DIR}/split.py"
+		COPYONLY
+	)
+	# Needs to be in the same dir as the python script
+	configure_file(httplib.h "${CMAKE_CURRENT_BINARY_DIR}/httplib.h"
+		COPYONLY
+	)
+
+	# Used outside of this if-else
+	set(_INTERFACE_OR_PUBLIC PUBLIC)
+	# Brings in the Python3_EXECUTABLE path we can use.
+	find_package(Python3 REQUIRED)
+	# Actually split the file
+	# Keeps the output in the build dir to not pollute the main dir
+	execute_process(COMMAND ${Python3_EXECUTABLE} "${CMAKE_CURRENT_BINARY_DIR}/split.py"
+		WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+		ERROR_VARIABLE _httplib_split_error
+	)
+	if(_httplib_split_error)
+		message(FATAL_ERROR "Failed when trying to split Cpp-httplib with the Python script.\n${_httplib_split_error}")
+	endif()
+
+	# split.py puts output in "out"
+	set(_httplib_build_includedir "${CMAKE_CURRENT_BINARY_DIR}/out")
+	# This will automatically be either static or shared based on the value of BUILD_SHARED_LIBS
+	add_library(${PROJECT_NAME} "${_httplib_build_includedir}/httplib.cc")
+	target_sources(${PROJECT_NAME}
+		PUBLIC
+			$<BUILD_INTERFACE:${_httplib_build_includedir}/httplib.h>
+			$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/httplib.h>
+	)
+else()
+	# This is for header-only.
+	set(_INTERFACE_OR_PUBLIC INTERFACE)
+	add_library(${PROJECT_NAME} INTERFACE)
+	set(_httplib_build_includedir "${CMAKE_CURRENT_SOURCE_DIR}")
+endif()
+# Lets you address the target with httplib::httplib
+# Only useful if building in-tree, versus using it from an installation.
+add_library(${PROJECT_NAME}::${PROJECT_NAME} ALIAS ${PROJECT_NAME})
+
+# Might be missing some, but this list is somewhat comprehensive
+target_compile_features(${PROJECT_NAME} ${_INTERFACE_OR_PUBLIC}
+	cxx_std_11
+	cxx_nullptr
+	cxx_lambdas
+	cxx_override
+	cxx_defaulted_functions
+	cxx_attribute_deprecated
+	cxx_auto_type
+	cxx_decltype
+	cxx_deleted_functions
+	cxx_range_for
+	cxx_sizeof_member
+)
+
+target_include_directories(${PROJECT_NAME} ${_INTERFACE_OR_PUBLIC}
+    $<BUILD_INTERFACE:${_httplib_build_includedir}>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+)
+
+# Always require threads
+target_link_libraries(${PROJECT_NAME} ${_INTERFACE_OR_PUBLIC}
+		Threads::Threads
+)
+
+# We check for the target when using IF_AVAILABLE since it's possible we didn't find it.
+if(HTTPLIB_USE_OPENSSL_IF_AVAILABLE AND TARGET OpenSSL::SSL AND TARGET OpenSSL::Crypto OR HTTPLIB_REQUIRE_OPENSSL)
+	target_link_libraries(${PROJECT_NAME} ${_INTERFACE_OR_PUBLIC}
+		OpenSSL::SSL OpenSSL::Crypto
+	)
+	target_compile_definitions(${PROJECT_NAME} ${_INTERFACE_OR_PUBLIC}
+		CPPHTTPLIB_OPENSSL_SUPPORT
+	)
+	set(HTTPLIB_IS_USING_OPENSSL TRUE)
+else()
+	set(HTTPLIB_IS_USING_OPENSSL FALSE)
+endif()
+
+# We check for the target when using IF_AVAILABLE since it's possible we didn't find it.
+if(HTTPLIB_USE_ZLIB_IF_AVAILABLE AND TARGET ZLIB::ZLIB OR HTTPLIB_REQUIRE_ZLIB)
+	target_link_libraries(${PROJECT_NAME} ${_INTERFACE_OR_PUBLIC}
+		ZLIB::ZLIB
+	)
+	target_compile_definitions(${PROJECT_NAME} ${_INTERFACE_OR_PUBLIC}
+		CPPHTTPLIB_ZLIB_SUPPORT
+	)
+	set(HTTPLIB_IS_USING_ZLIB TRUE)
+else()
+	set(HTTPLIB_IS_USING_ZLIB FALSE)
+endif()
+
+# Cmake's find_package search path is different based on the system
+# See https://cmake.org/cmake/help/latest/command/find_package.html for the list
+if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
+	set(_TARGET_INSTALL_CMAKEDIR "${CMAKE_INSTALL_PREFIX}/cmake/${PROJECT_NAME}")
+else()
+	# On Non-Windows, it should be /usr/lib/cmake/<name>/<name>Config.cmake
+	# NOTE: This may or may not work for macOS...
+	set(_TARGET_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
+endif()
+
+include(CMakePackageConfigHelpers)
+
+# Configures the meta-file httplibConfig.cmake.in to replace variables with paths/values/etc.
+configure_package_config_file("${PROJECT_NAME}Config.cmake.in"
+	"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
+	INSTALL_DESTINATION "${_TARGET_INSTALL_CMAKEDIR}"
+	# Passes the includedir install path
+	PATH_VARS CMAKE_INSTALL_FULL_INCLUDEDIR
+	# There aren't any components, so don't use the macro
+	NO_CHECK_REQUIRED_COMPONENTS_MACRO
+)
+
+if(HTTPLIB_COMPILE)
+	write_basic_package_version_file("${PROJECT_NAME}ConfigVersion.cmake"
+		# Example: if you find_package(httplib 0.5.4)
+		# then anything >= 0.5 and <= 1.0 is accepted
+		COMPATIBILITY SameMajorVersion
+	)
+else()
+	write_basic_package_version_file("${PROJECT_NAME}ConfigVersion.cmake"
+		# Example: if you find_package(httplib 0.5.4)
+		# then anything >= 0.5 and <= 1.0 is accepted
+		COMPATIBILITY SameMajorVersion
+		# Tells Cmake that it's a header-only lib
+		# Mildly useful for end-users :)
+		ARCH_INDEPENDENT
+	)
+endif()
+
+# Creates the export httplibTargets.cmake
+# This is strictly what holds compilation requirements
+# and linkage information (doesn't find deps though).
+install(TARGETS ${PROJECT_NAME}
+	EXPORT httplibTargets
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+)
+
+install(FILES "${_httplib_build_includedir}/httplib.h" DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
+install(FILES
+		"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
+		"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake"
+	DESTINATION ${_TARGET_INSTALL_CMAKEDIR}
+)
+
+# NOTE: This path changes depending on if it's on Windows or Linux
+install(EXPORT httplibTargets
+	# Puts the targets into the httplib namespace
+	# So this makes httplib::httplib linkable after doing find_package(httplib)
+	NAMESPACE ${PROJECT_NAME}::
+	DESTINATION ${_TARGET_INSTALL_CMAKEDIR}
+)

README.md

@@ -203,6 +203,44 @@ svr.Get("/chunked", [&](const Request& req, Response& res) {
 });
 ```
 
+### 'Expect: 100-continue' handler
+
+As default, the server sends `100 Continue` response for `Expect: 100-continue` header.
+
+```cpp
+// Send a '417 Expectation Failed' response.
+svr.set_expect_100_continue_handler([](const Request &req, Response &res) {
+  return 417;
+});
+```
+
+```cpp
+// Send a final status without reading the message body.
+svr.set_expect_100_continue_handler([](const Request &req, Response &res) {
+  return res.status = 401;
+});
+```
+
+### Keep-Alive connection
+
+```cpp
+svr.set_keep_alive_max_count(2); // Default is 5
+```
+
+### Timeout
+
+```c++
+svr.set_read_timeout(5, 0); // 5 seconds
+svr.set_write_timeout(5, 0); // 5 seconds
+svr.set_idle_interval(0, 100000); // 100 milliseconds
+```
+
+### Set maximum payload length for reading request body
+
+```c++
+svr.set_payload_max_length(1024 * 1024 * 512); // 512MB
+```
+
 ### Server-Sent Events
 
 Please check [here](https://github.com/yhirose/cpp-httplib/blob/master/example/sse.cc).
@@ -240,24 +278,6 @@ svr.new_task_queue = [] {
 };
 ```
 
-### 'Expect: 100-continue' handler
-
-As default, the server sends `100 Continue` response for `Expect: 100-continue` header.
-
-```cpp
-// Send a '417 Expectation Failed' response.
-svr.set_expect_100_continue_handler([](const Request &req, Response &res) {
-  return 417;
-});
-```
-
-```cpp
-// Send a final status without reading the message body.
-svr.set_expect_100_continue_handler([](const Request &req, Response &res) {
-  return res.status = 401;
-});
-```
-
 Client Example
 --------------
 
@@ -360,11 +380,14 @@ res = cli.Options("*");
 res = cli.Options("/resource/foo");
 ```
 
-### Connection Timeout
+### Timeout
 
 ```c++
-cli.set_timeout_sec(5); // timeouts in 5 seconds
+cli.set_connection_timeout(0, 300000); // 300 milliseconds
+cli.set_read_timeout(5, 0); // 5 seconds
+cli.set_write_timeout(5, 0); // 5 seconds
 ```
+
 ### Receive content with Content receiver
 
 ```cpp
@@ -459,29 +482,15 @@ httplib::make_range_header({{0, 0}, {-1, 1}})        // 'Range: bytes=0-0, -1'
 ### Keep-Alive connection
 
 ```cpp
-cli.set_keep_alive_max_count(2); // Default is 5
+httplib::Client cli("localhost", 1234);
 
-std::vector<Request> requests;
-Get(requests, "/get-request1");
-Get(requests, "/get-request2");
-Post(requests, "/post-request1", "text", "text/plain");
-Post(requests, "/post-request2", "text", "text/plain");
+cli.Get("/hello");         // with "Connection: close"
 
-const size_t DATA_CHUNK_SIZE = 4;
-std::string data("abcdefg");
-Post(requests, "/post-request-with-content-provider",
-  data.size(),
-  [&](size_t offset, size_t length, DataSink &sink){
-    sink.write(&data[offset], std::min(length, DATA_CHUNK_SIZE));
-  },
-  "text/plain");
+cli.set_keep_alive(true);
+cli.Get("/world");
 
-std::vector<Response> responses;
-if (cli.send(requests, responses)) {
-  for (const auto& res: responses) {
-    ...
-  }
-}
+cli.set_keep_alive(false);
+cli.Get("/last-request");  // with "Connection: close"
 ```
 
 ### Redirect
@@ -536,13 +545,21 @@ The server applies gzip compression to the following MIME type contents:
   * application/xml
   * application/xhtml+xml
 
-### Compress content on client
+### Compress request body on client
 
 ```c++
 cli.set_compress(true);
 res = cli.Post("/resource/foo", "...", "text/plain");
 ```
 
+### Compress response body on client
+
+```c++
+cli.set_decompress(false);
+res = cli.Get("/resource/foo", {{"Accept-Encoding", "gzip, deflate"}});
+res->body; // Compressed data
+```
+
 Split httplib.h into .h and .cc
 -------------------------------
 

httplibConfig.cmake.in

@@ -0,0 +1,66 @@
+# Generates a macro to auto-configure everything
+@PACKAGE_INIT@
+
+# Setting these here so they're accessible after install.
+# Might be useful for some users to check which settings were used.
+set(HTTPLIB_IS_USING_OPENSSL @HTTPLIB_IS_USING_OPENSSL@)
+set(HTTPLIB_IS_USING_ZLIB @HTTPLIB_IS_USING_ZLIB@)
+set(HTTPLIB_IS_COMPILED @HTTPLIB_COMPILE@)
+set(HTTPLIB_VERSION @PROJECT_VERSION@)
+
+include(CMakeFindDependencyMacro)
+
+# We add find_dependency calls here to not make the end-user have to call them.
+find_dependency(Threads REQUIRED)
+if(@HTTPLIB_IS_USING_OPENSSL@)
+	# OpenSSL COMPONENTS were added in Cmake v3.11
+	if(CMAKE_VERSION VERSION_LESS "3.11")
+		find_dependency(OpenSSL @_HTTPLIB_OPENSSL_MIN_VER@ REQUIRED)
+	else()
+		# Once the COMPONENTS were added, they were made optional when not specified.
+		# Since we use both, we need to search for both.
+		find_dependency(OpenSSL @_HTTPLIB_OPENSSL_MIN_VER@ COMPONENTS Crypto SSL REQUIRED)
+	endif()
+endif()
+if(@HTTPLIB_IS_USING_ZLIB@)
+	find_dependency(ZLIB REQUIRED)
+endif()
+
+# Mildly useful for end-users
+# Not really recommended to be used though
+set_and_check(HTTPLIB_INCLUDE_DIR "@PACKAGE_CMAKE_INSTALL_FULL_INCLUDEDIR@")
+# Lets the end-user find the header path with the header appended
+# This is helpful if you're using Cmake's pre-compiled header feature
+set_and_check(HTTPLIB_HEADER_PATH "@PACKAGE_CMAKE_INSTALL_FULL_INCLUDEDIR@/httplib.h")
+
+# Brings in the target library
+include("${CMAKE_CURRENT_LIST_DIR}/httplibTargets.cmake")
+
+# Ouputs a "found httplib /usr/include/httplib.h" message when using find_package(httplib)
+include(FindPackageMessage)
+if(TARGET httplib::httplib)
+	set(HTTPLIB_FOUND TRUE)
+
+	# Since the compiled version has a lib, show that in the message
+	if(@HTTPLIB_COMPILE@)
+		# The list of configurations is most likely just 1 unless they installed a debug & release
+		get_target_property(_httplib_configs httplib::httplib "IMPORTED_CONFIGURATIONS")
+		# Need to loop since the "IMPORTED_LOCATION" property isn't want we want.
+		# Instead, we need to find the IMPORTED_LOCATION_RELEASE or IMPORTED_LOCATION_DEBUG which has the lib path.
+		foreach(_httplib_conf "${_httplib_configs}")
+			# Grab the path to the lib and sets it to HTTPLIB_LIBRARY
+			get_target_property(HTTPLIB_LIBRARY httplib::httplib "IMPORTED_LOCATION_${_httplib_conf}")
+			# Check if we found it
+			if(HTTPLIB_LIBRARY)
+				break()
+			endif()
+		endforeach()
+
+		unset(_httplib_configs)
+		unset(_httplib_conf)
+
+		find_package_message(httplib "Found httplib: ${HTTPLIB_LIBRARY} (found version \"${HTTPLIB_VERSION}\")" "[${HTTPLIB_LIBRARY}][${HTTPLIB_HEADER_PATH}]")
+	else()
+		find_package_message(httplib "Found httplib: ${HTTPLIB_HEADER_PATH} (found version \"${HTTPLIB_VERSION}\")" "[${HTTPLIB_HEADER_PATH}]")
+	endif()
+endif()

test/test.cc

@@ -245,7 +245,7 @@ TEST(ChunkedEncodingTest, FromHTTPWatch) {
   auto port = 80;
   httplib::Client cli(host, port);
 #endif
-  cli.set_timeout_sec(2);
+  cli.set_connection_timeout(2);
 
   auto res =
       cli.Get("/httpgallery/chunked/chunkedimage.aspx?0.4153841143030137");
@@ -268,7 +268,7 @@ TEST(ChunkedEncodingTest, WithContentReceiver) {
   auto port = 80;
   httplib::Client cli(host, port);
 #endif
-  cli.set_timeout_sec(2);
+  cli.set_connection_timeout(2);
 
   std::string body;
   auto res =
@@ -296,7 +296,7 @@ TEST(ChunkedEncodingTest, WithResponseHandlerAndContentReceiver) {
   auto port = 80;
   httplib::Client cli(host, port);
 #endif
-  cli.set_timeout_sec(2);
+  cli.set_connection_timeout(2);
 
   std::string body;
   auto res = cli.Get(
@@ -328,7 +328,7 @@ TEST(RangeTest, FromHTTPBin) {
   auto port = 80;
   httplib::Client cli(host, port);
 #endif
-  cli.set_timeout_sec(5);
+  cli.set_connection_timeout(5);
 
   {
     httplib::Headers headers;
@@ -388,7 +388,7 @@ TEST(ConnectionErrorTest, InvalidHost) {
   auto port = 80;
   httplib::Client cli(host, port);
 #endif
-  cli.set_timeout_sec(2);
+  cli.set_connection_timeout(2);
 
   auto res = cli.Get("/");
   ASSERT_TRUE(res == nullptr);
@@ -404,7 +404,7 @@ TEST(ConnectionErrorTest, InvalidPort) {
   auto port = 8080;
   httplib::Client cli(host, port);
 #endif
-  cli.set_timeout_sec(2);
+  cli.set_connection_timeout(2);
 
   auto res = cli.Get("/");
   ASSERT_TRUE(res == nullptr);
@@ -420,7 +420,7 @@ TEST(ConnectionErrorTest, Timeout) {
   auto port = 8080;
   httplib::Client cli(host, port);
 #endif
-  cli.set_timeout_sec(2);
+  cli.set_connection_timeout(2);
 
   auto res = cli.Get("/");
   ASSERT_TRUE(res == nullptr);
@@ -436,7 +436,7 @@ TEST(CancelTest, NoCancel) {
   auto port = 80;
   httplib::Client cli(host, port);
 #endif
-  cli.set_timeout_sec(5);
+  cli.set_connection_timeout(5);
 
   auto res = cli.Get("/range/32", [](uint64_t, uint64_t) { return true; });
   ASSERT_TRUE(res != nullptr);
@@ -456,7 +456,7 @@ TEST(CancelTest, WithCancelSmallPayload) {
 #endif
 
   auto res = cli.Get("/range/32", [](uint64_t, uint64_t) { return false; });
-  cli.set_timeout_sec(5);
+  cli.set_connection_timeout(5);
   ASSERT_TRUE(res == nullptr);
 }
 
@@ -470,7 +470,7 @@ TEST(CancelTest, WithCancelLargePayload) {
   auto port = 80;
   httplib::Client cli(host, port);
 #endif
-  cli.set_timeout_sec(5);
+  cli.set_connection_timeout(5);
 
   uint32_t count = 0;
   httplib::Headers headers;
@@ -1136,6 +1136,10 @@ protected:
                 EXPECT_EQ(req.get_param_value("key"), "value");
                 EXPECT_EQ(req.body, "content");
               })
+        .Get("/last-request",
+             [&](const Request & req, Response &/*res*/) {
+               EXPECT_EQ("close", req.get_header_value("Connection"));
+             })
 #ifdef CPPHTTPLIB_ZLIB_SUPPORT
         .Get("/gzip",
              [&](const Request & /*req*/, Response &res) {
@@ -1766,14 +1770,24 @@ TEST_F(ServerTest, GetStreamedEndless) {
 }
 
 TEST_F(ServerTest, ClientStop) {
-  thread t = thread([&]() {
-    auto res = cli_.Get("/streamed-cancel",
-                        [&](const char *, uint64_t) { return true; });
-    ASSERT_TRUE(res == nullptr);
-  });
+  std::vector<std::thread> threads;
+  for (auto i = 0; i < 3; i++) {
+    threads.emplace_back(thread([&]() {
+      auto res = cli_.Get("/streamed-cancel",
+                          [&](const char *, uint64_t) { return true; });
+      ASSERT_TRUE(res == nullptr);
+    }));
+  }
+
   std::this_thread::sleep_for(std::chrono::seconds(1));
-  cli_.stop();
-  t.join();
+
+  while (cli_.is_socket_open()) {
+    cli_.stop();
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+  }
+  for (auto &t : threads) {
+    t.join();
+  }
 }
 
 TEST_F(ServerTest, GetWithRange1) {
@@ -2117,42 +2131,48 @@ TEST_F(ServerTest, HTTP2Magic) {
 }
 
 TEST_F(ServerTest, KeepAlive) {
-  cli_.set_keep_alive_max_count(4);
+  auto res = cli_.Get("/hi");
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(200, res->status);
+  EXPECT_EQ("text/plain", res->get_header_value("Content-Type"));
+  EXPECT_EQ("Hello World!", res->body);
 
-  std::vector<Request> requests;
-  Get(requests, "/hi");
-  Get(requests, "/hi");
-  Get(requests, "/hi");
-  Get(requests, "/not-exist");
-  Post(requests, "/empty", "", "text/plain");
-  Post(
-      requests, "/empty", 0,
-      [&](size_t, size_t, httplib::DataSink &) { return true; }, "text/plain");
+  res = cli_.Get("/hi");
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(200, res->status);
+  EXPECT_EQ("text/plain", res->get_header_value("Content-Type"));
+  EXPECT_EQ("Hello World!", res->body);
 
-  std::vector<Response> responses;
-  auto ret = cli_.send(requests, responses);
+  res = cli_.Get("/hi");
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(200, res->status);
+  EXPECT_EQ("text/plain", res->get_header_value("Content-Type"));
+  EXPECT_EQ("Hello World!", res->body);
 
-  ASSERT_TRUE(ret == true);
-  ASSERT_TRUE(requests.size() == responses.size());
+  res = cli_.Get("/not-exist");
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(404, res->status);
 
-  for (size_t i = 0; i < 3; i++) {
-    auto &res = responses[i];
-    EXPECT_EQ(200, res.status);
-    EXPECT_EQ("text/plain", res.get_header_value("Content-Type"));
-    EXPECT_EQ("Hello World!", res.body);
-  }
+  res = cli_.Post("/empty", "", "text/plain");
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(200, res->status);
+  EXPECT_EQ("text/plain", res->get_header_value("Content-Type"));
+  EXPECT_EQ("empty", res->body);
+  EXPECT_EQ("close", res->get_header_value("Connection"));
 
-  {
-    auto &res = responses[3];
-    EXPECT_EQ(404, res.status);
-  }
+  res = cli_.Post(
+      "/empty", 0, [&](size_t, size_t, httplib::DataSink &) { return true; },
+      "text/plain");
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(200, res->status);
+  EXPECT_EQ("text/plain", res->get_header_value("Content-Type"));
+  EXPECT_EQ("empty", res->body);
 
-  for (size_t i = 4; i < 6; i++) {
-    auto &res = responses[i];
-    EXPECT_EQ(200, res.status);
-    EXPECT_EQ("text/plain", res.get_header_value("Content-Type"));
-    EXPECT_EQ("empty", res.body);
-  }
+  cli_.set_keep_alive(false);
+  res = cli_.Get("/last-request");
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(200, res->status);
+  EXPECT_EQ("close", res->get_header_value("Connection"));
 }
 
 #ifdef CPPHTTPLIB_ZLIB_SUPPORT
@@ -2206,6 +2226,21 @@ TEST_F(ServerTest, GzipWithContentReceiver) {
   EXPECT_EQ(200, res->status);
 }
 
+TEST_F(ServerTest, GzipWithoutDecompressing) {
+  Headers headers;
+  headers.emplace("Accept-Encoding", "gzip, deflate");
+
+  cli_.set_decompress(false);
+  auto res = cli_.Get("/gzip", headers);
+
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ("gzip", res->get_header_value("Content-Encoding"));
+  EXPECT_EQ("text/plain", res->get_header_value("Content-Type"));
+  EXPECT_EQ("33", res->get_header_value("Content-Length"));
+  EXPECT_EQ(33, res->body.size());
+  EXPECT_EQ(200, res->status);
+}
+
 TEST_F(ServerTest, GzipWithContentReceiverWithoutAcceptEncoding) {
   Headers headers;
   std::string body;
@@ -2279,15 +2314,14 @@ TEST_F(ServerTest, MultipartFormDataGzip) {
 // Sends a raw request to a server listening at HOST:PORT.
 static bool send_request(time_t read_timeout_sec, const std::string &req,
                          std::string *resp = nullptr) {
-  auto client_sock = detail::create_client_socket(HOST, PORT, /*timeout_sec=*/5,
-                                                  std::string());
+  auto client_sock =
+      detail::create_client_socket(HOST, PORT, nullptr,
+                                   /*timeout_sec=*/5, 0, std::string());
 
   if (client_sock == INVALID_SOCKET) { return false; }
 
-  return detail::process_and_close_socket(
-      true, client_sock, 1, read_timeout_sec, 0, 0, 0,
-      [&](Stream &strm, bool /*last_connection*/, bool &
-          /*connection_close*/) -> bool {
+  auto ret = detail::process_client_socket(
+      client_sock, read_timeout_sec, 0, 0, 0, [&](Stream &strm) {
         if (req.size() !=
             static_cast<size_t>(strm.write(req.data(), req.size()))) {
           return false;
@@ -2301,6 +2335,10 @@ static bool send_request(time_t read_timeout_sec, const std::string &req,
         }
         return true;
       });
+
+  detail::close_socket(client_sock);
+
+  return ret;
 }
 
 TEST(ServerRequestParsingTest, TrimWhitespaceFromHeaderValues) {
@@ -2485,8 +2523,7 @@ TEST(ServerStopTest, StopServerWithChunkedTransmission) {
   }
 
   Client client(HOST, PORT);
-  const Headers headers = {{"Accept", "text/event-stream"},
-                           {"Connection", "Keep-Alive"}};
+  const Headers headers = {{"Accept", "text/event-stream"}};
 
   auto get_thread = std::thread([&client, &headers]() {
     std::shared_ptr<Response> res = client.Get(
@@ -2712,19 +2749,24 @@ TEST(SSLClientTest, ServerNameIndication) {
   ASSERT_EQ(200, res->status);
 }
 
-TEST(SSLClientTest, ServerCertificateVerification) {
+TEST(SSLClientTest, ServerCertificateVerification1) {
   SSLClient cli("google.com");
-
   auto res = cli.Get("/");
   ASSERT_TRUE(res != nullptr);
   ASSERT_EQ(301, res->status);
+}
 
+TEST(SSLClientTest, ServerCertificateVerification2) {
+  SSLClient cli("google.com");
   cli.enable_server_certificate_verification(true);
-  res = cli.Get("/");
+  auto res = cli.Get("/");
   ASSERT_TRUE(res == nullptr);
+}
 
+TEST(SSLClientTest, ServerCertificateVerification3) {
+  SSLClient cli("google.com");
   cli.set_ca_cert_path(CA_CERT_FILE);
-  res = cli.Get("/");
+  auto res = cli.Get("/");
   ASSERT_TRUE(res != nullptr);
   ASSERT_EQ(301, res->status);
 }
@@ -2774,7 +2816,7 @@ TEST(SSLClientServerTest, ClientCertPresent) {
 
   httplib::SSLClient cli(HOST, PORT, CLIENT_CERT_FILE, CLIENT_PRIVATE_KEY_FILE);
   auto res = cli.Get("/test");
-  cli.set_timeout_sec(30);
+  cli.set_connection_timeout(30);
   ASSERT_TRUE(res != nullptr);
   ASSERT_EQ(200, res->status);
 
@@ -2843,7 +2885,7 @@ TEST(SSLClientServerTest, MemoryClientCertPresent) {
 
   httplib::SSLClient cli(HOST, PORT, client_cert, client_private_key);
   auto res = cli.Get("/test");
-  cli.set_timeout_sec(30);
+  cli.set_connection_timeout(30);
   ASSERT_TRUE(res != nullptr);
   ASSERT_EQ(200, res->status);
 
@@ -2867,7 +2909,7 @@ TEST(SSLClientServerTest, ClientCertMissing) {
 
   httplib::SSLClient cli(HOST, PORT);
   auto res = cli.Get("/test");
-  cli.set_timeout_sec(30);
+  cli.set_connection_timeout(30);
   ASSERT_TRUE(res == nullptr);
 
   svr.stop();
@@ -2889,7 +2931,7 @@ TEST(SSLClientServerTest, TrustDirOptional) {
 
   httplib::SSLClient cli(HOST, PORT, CLIENT_CERT_FILE, CLIENT_PRIVATE_KEY_FILE);
   auto res = cli.Get("/test");
-  cli.set_timeout_sec(30);
+  cli.set_connection_timeout(30);
   ASSERT_TRUE(res != nullptr);
   ASSERT_EQ(200, res->status);
 

test/test_proxy.cc

@@ -222,66 +222,45 @@ void KeepAliveTest(Client& cli, bool basic) {
 #endif
   }
 
-  cli.set_keep_alive_max_count(4);
   cli.set_follow_location(true);
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
   cli.set_digest_auth("hello", "world");
+#endif
 
-  std::vector<Request> requests;
+  {
+    auto res = cli.Get("/get");
+    EXPECT_EQ(200, res->status);
+  }
+  {
+    auto res = cli.Get("/redirect/2");
+    EXPECT_EQ(200, res->status);
+  }
 
-  Get(requests, "/get");
-  Get(requests, "/redirect/2");
+  {
+    std::vector<std::string> paths = {
+        "/digest-auth/auth/hello/world/MD5",
+        "/digest-auth/auth/hello/world/SHA-256",
+        "/digest-auth/auth/hello/world/SHA-512",
+        "/digest-auth/auth-int/hello/world/MD5",
+    };
 
-  std::vector<std::string> paths = {
-      "/digest-auth/auth/hello/world/MD5",
-      "/digest-auth/auth/hello/world/SHA-256",
-      "/digest-auth/auth/hello/world/SHA-512",
-      "/digest-auth/auth-int/hello/world/MD5",
-  };
-
-  for (auto path : paths) {
-    Get(requests, path.c_str());
+    for (auto path: paths) {
+      auto res = cli.Get(path.c_str());
+      EXPECT_EQ("{\n  \"authenticated\": true, \n  \"user\": \"hello\"\n}\n", res->body);
+      EXPECT_EQ(200, res->status);
+    }
   }
 
   {
     int count = 100;
     while (count--) {
-      Get(requests, "/get");
+      auto res = cli.Get("/get");
+      EXPECT_EQ(200, res->status);
     }
   }
-
-  std::vector<Response> responses;
-  auto ret = cli.send(requests, responses);
-  ASSERT_TRUE(ret == true);
-  ASSERT_TRUE(requests.size() == responses.size());
-
-  size_t i = 0;
-
-  {
-    auto &res = responses[i++];
-    EXPECT_EQ(200, res.status);
-  }
-
-  {
-    auto &res = responses[i++];
-    EXPECT_EQ(200, res.status);
-  }
-
-
-  {
-    int count = static_cast<int>(paths.size());
-    while (count--) {
-      auto &res = responses[i++];
-      EXPECT_EQ("{\n  \"authenticated\": true, \n  \"user\": \"hello\"\n}\n", res.body);
-      EXPECT_EQ(200, res.status);
-    }
-  }
-
-  for (; i < responses.size(); i++) {
-    auto &res = responses[i];
-    EXPECT_EQ(200, res.status);
-  }
 }
 
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
 TEST(KeepAliveTest, NoSSLWithBasic) {
   Client cli("httpbin.org");
   KeepAliveTest(cli, true);
@@ -292,7 +271,6 @@ TEST(KeepAliveTest, SSLWithBasic) {
   KeepAliveTest(cli, true);
 }
 
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
 TEST(KeepAliveTest, NoSSLWithDigest) {
   Client cli("httpbin.org");
   KeepAliveTest(cli, false);