Updated version in the User Agent string

Fix #499
Fix #522
2026-06-11 17:17:17 +00:00 · 2020-06-16 17:53:15 -04:00 · 2020-06-16 17:46:23 -04:00 · 2020-06-15 23:09:46 -04:00 · 2020-06-13 23:20:21 -04:00 · 2020-06-13 23:18:59 -04:00
10 changed files with 2054 additions and 890 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,14 +0,0 @@
-# Environment
-language: cpp
-os:
-  - linux
-  - osx
-
-# Compiler selection
-compiler:
-  - clang
-
-# Build/test steps
-script:
-  - cd ${TRAVIS_BUILD_DIR}/test
-  - make all
--- a/CMakeLists.txt
+++ b/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}
+)
--- a/README.md
+++ b/README.md
@@ -2,7 +2,6 @@ cpp-httplib
 ===========

 [![](https://github.com/yhirose/cpp-httplib/workflows/test/badge.svg)](https://github.com/yhirose/cpp-httplib/actions)
-[![Build Status](https://travis-ci.org/yhirose/cpp-httplib.svg?branch=master)](https://travis-ci.org/yhirose/cpp-httplib)
 [![Bulid Status](https://ci.appveyor.com/api/projects/status/github/yhirose/cpp-httplib?branch=master&svg=true)](https://ci.appveyor.com/project/yhirose/cpp-httplib)

 A C++11 single-file header-only cross platform HTTP/HTTPS library.
@@ -172,16 +171,17 @@ svr.Post("/content_receiver",
 ### Send content with Content provider

 ```cpp
-const uint64_t DATA_CHUNK_SIZE = 4;
+const size_t DATA_CHUNK_SIZE = 4;

 svr.Get("/stream", [&](const Request &req, Response &res) {
  auto data = new std::string("abcdefg");

  res.set_content_provider(
    data->size(), // Content length
-    [data](uint64_t offset, uint64_t length, DataSink &sink) {
+    [data](size_t offset, size_t length, DataSink &sink) {
      const auto &d = *data;
      sink.write(&d[offset], std::min(length, DATA_CHUNK_SIZE));
+      return true; // return 'false' if you want to cancel the process.
    },
    [data] { delete data; });
 });
@@ -192,16 +192,55 @@ svr.Get("/stream", [&](const Request &req, Response &res) {
 ```cpp
 svr.Get("/chunked", [&](const Request& req, Response& res) {
  res.set_chunked_content_provider(
-    [](uint64_t offset, DataSink &sink) {
-       sink.write("123", 3);
-       sink.write("345", 3);
-       sink.write("789", 3);
-       sink.done();
+    [](size_t offset, DataSink &sink) {
+      sink.write("123", 3);
+      sink.write("345", 3);
+      sink.write("789", 3);
+      sink.done();
+      return true; // return 'false' if you want to cancel the process.
    }
  );
 });
 ```

+### '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).
@@ -239,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
 --------------

@@ -291,7 +312,7 @@ auto res = cli.Get("/hi", headers);
 std::string body;

 auto res = cli.Get("/large-data",
-  [&](const char *data, uint64_t data_length) {
+  [&](const char *data, size_t data_length) {
    body.append(data, data_length);
    return true;
  });
@@ -359,11 +380,43 @@ 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
+std::string body;
+auto res = cli.Get(
+  "/stream", Headers(),
+  [&](const Response &response) {
+    EXPECT_EQ(200, response.status);
+    return true; // return 'false' if you want to cancel the request.
+  },
+  [&](const char *data, size_t data_length) {
+    body.append(data, data_length);
+    return true; // return 'false' if you want to cancel the request.
+  });
+```
+
+### Send content with Content provider
+
+```cpp
+std::string body = ...;
+auto res = cli_.Post(
+  "/stream", body.size(),
+  [](size_t offset, size_t length, DataSink &sink) {
+    sink.write(body.data() + offset, length);
+    return true; // return 'false' if you want to cancel the request.
+  },
+  "text/plain");
+```
+
 ### With Progress Callback

 ```cpp
@@ -429,20 +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"

-std::vector<Response> responses;
-if (cli.send(requests, responses)) {
-  for (const auto& res: responses) {
-    ...
-  }
-}
+cli.set_keep_alive(true);
+cli.Get("/world");
+
+cli.set_keep_alive(false);
+cli.Get("/last-request");  // with "Connection: close"
 ```

 ### Redirect
@@ -486,7 +534,7 @@ cli.enable_server_certificate_verification(true);
 Zlib Support
 ------------

-'gzip' compression is available with `CPPHTTPLIB_ZLIB_SUPPORT`.
+'gzip' compression is available with `CPPHTTPLIB_ZLIB_SUPPORT`. `libz` should be linked.

 The server applies gzip compression to the following MIME type contents:

@@ -497,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
 -------------------------------

--- a/example/simplecli.cc
+++ b/example/simplecli.cc
@@ -14,13 +14,12 @@ using namespace std;

 int main(void) {
 #ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  httplib::url::Options options;
-  options.ca_cert_file_path = CA_CERT_FILE;
-  // options.server_certificate_verification = true;
-
-  auto res = httplib::url::Get("https://localhost:8080/hi", options);
+  auto res = httplib::Client2("https://localhost:8080")
+    .set_ca_cert_path(CA_CERT_FILE)
+    // .enable_server_certificate_verification(true)
+    .Get("/hi");
 #else
-  auto res = httplib::url::Get("http://localhost:8080/hi");
+  auto res = httplib::Client2("http://localhost:8080").Get("/hi");
 #endif

  if (res) {
--- a/example/sse.cc
+++ b/example/sse.cc
@@ -80,15 +80,19 @@ int main(void) {
  svr.Get("/event1", [&](const Request & /*req*/, Response &res) {
    cout << "connected to event1..." << endl;
    res.set_header("Content-Type", "text/event-stream");
-    res.set_chunked_content_provider(
-        [&](uint64_t /*offset*/, DataSink &sink) { ed.wait_event(&sink); });
+    res.set_chunked_content_provider([&](size_t /*offset*/, DataSink &sink) {
+      ed.wait_event(&sink);
+      return true;
+    });
  });

  svr.Get("/event2", [&](const Request & /*req*/, Response &res) {
    cout << "connected to event2..." << endl;
    res.set_header("Content-Type", "text/event-stream");
-    res.set_chunked_content_provider(
-        [&](uint64_t /*offset*/, DataSink &sink) { ed.wait_event(&sink); });
+    res.set_chunked_content_provider([&](size_t /*offset*/, DataSink &sink) {
+      ed.wait_event(&sink);
+      return true;
+    });
  });

  thread t([&] {
--- a/httplib.h
+++ b/httplib.h
--- a/httplibConfig.cmake.in
+++ b/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()
--- a/test/test.cc
+++ b/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,13 +328,13 @@ 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;
    auto res = cli.Get("/range/32", headers);
    ASSERT_TRUE(res != nullptr);
-    EXPECT_EQ(res->body, "abcdefghijklmnopqrstuvwxyzabcdef");
+    EXPECT_EQ("abcdefghijklmnopqrstuvwxyzabcdef", res->body);
    EXPECT_EQ(200, res->status);
  }

@@ -342,7 +342,7 @@ TEST(RangeTest, FromHTTPBin) {
    httplib::Headers headers = {httplib::make_range_header({{1, -1}})};
    auto res = cli.Get("/range/32", headers);
    ASSERT_TRUE(res != nullptr);
-    EXPECT_EQ(res->body, "bcdefghijklmnopqrstuvwxyzabcdef");
+    EXPECT_EQ("bcdefghijklmnopqrstuvwxyzabcdef", res->body);
    EXPECT_EQ(206, res->status);
  }

@@ -350,7 +350,7 @@ TEST(RangeTest, FromHTTPBin) {
    httplib::Headers headers = {httplib::make_range_header({{1, 10}})};
    auto res = cli.Get("/range/32", headers);
    ASSERT_TRUE(res != nullptr);
-    EXPECT_EQ(res->body, "bcdefghijk");
+    EXPECT_EQ("bcdefghijk", res->body);
    EXPECT_EQ(206, res->status);
  }

@@ -358,7 +358,7 @@ TEST(RangeTest, FromHTTPBin) {
    httplib::Headers headers = {httplib::make_range_header({{0, 31}})};
    auto res = cli.Get("/range/32", headers);
    ASSERT_TRUE(res != nullptr);
-    EXPECT_EQ(res->body, "abcdefghijklmnopqrstuvwxyzabcdef");
+    EXPECT_EQ("abcdefghijklmnopqrstuvwxyzabcdef", res->body);
    EXPECT_EQ(200, res->status);
  }

@@ -366,7 +366,7 @@ TEST(RangeTest, FromHTTPBin) {
    httplib::Headers headers = {httplib::make_range_header({{0, -1}})};
    auto res = cli.Get("/range/32", headers);
    ASSERT_TRUE(res != nullptr);
-    EXPECT_EQ(res->body, "abcdefghijklmnopqrstuvwxyzabcdef");
+    EXPECT_EQ("abcdefghijklmnopqrstuvwxyzabcdef", res->body);
    EXPECT_EQ(200, res->status);
  }

@@ -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,11 +436,11 @@ 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);
-  EXPECT_EQ(res->body, "abcdefghijklmnopqrstuvwxyzabcdef");
+  EXPECT_EQ("abcdefghijklmnopqrstuvwxyzabcdef", res->body);
  EXPECT_EQ(200, res->status);
 }

@@ -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;
@@ -501,8 +501,8 @@ TEST(BaseAuthTest, FromHTTPWatch) {
        cli.Get("/basic-auth/hello/world",
                {httplib::make_basic_authentication_header("hello", "world")});
    ASSERT_TRUE(res != nullptr);
-    EXPECT_EQ(res->body,
-              "{\n  \"authenticated\": true, \n  \"user\": \"hello\"\n}\n");
+    EXPECT_EQ("{\n  \"authenticated\": true, \n  \"user\": \"hello\"\n}\n",
+              res->body);
    EXPECT_EQ(200, res->status);
  }

@@ -510,8 +510,8 @@ TEST(BaseAuthTest, FromHTTPWatch) {
    cli.set_basic_auth("hello", "world");
    auto res = cli.Get("/basic-auth/hello/world");
    ASSERT_TRUE(res != nullptr);
-    EXPECT_EQ(res->body,
-              "{\n  \"authenticated\": true, \n  \"user\": \"hello\"\n}\n");
+    EXPECT_EQ("{\n  \"authenticated\": true, \n  \"user\": \"hello\"\n}\n",
+              res->body);
    EXPECT_EQ(200, res->status);
  }

@@ -554,8 +554,8 @@ TEST(DigestAuthTest, FromHTTPWatch) {
    for (auto path : paths) {
      auto res = cli.Get(path.c_str());
      ASSERT_TRUE(res != nullptr);
-      EXPECT_EQ(res->body,
-                "{\n  \"authenticated\": true, \n  \"user\": \"hello\"\n}\n");
+      EXPECT_EQ("{\n  \"authenticated\": true, \n  \"user\": \"hello\"\n}\n",
+                res->body);
      EXPECT_EQ(200, res->status);
    }

@@ -563,15 +563,17 @@ TEST(DigestAuthTest, FromHTTPWatch) {
    for (auto path : paths) {
      auto res = cli.Get(path.c_str());
      ASSERT_TRUE(res != nullptr);
-      EXPECT_EQ(400, res->status);
+      EXPECT_EQ(401, res->status);
    }

-    cli.set_digest_auth("bad", "world");
-    for (auto path : paths) {
-      auto res = cli.Get(path.c_str());
-      ASSERT_TRUE(res != nullptr);
-      EXPECT_EQ(400, res->status);
-    }
+    // NOTE: Until httpbin.org fixes issue #46, the following test is commented
+    // out. Plese see https://httpbin.org/digest-auth/auth/hello/world
+    // cli.set_digest_auth("bad", "world");
+    // for (auto path : paths) {
+    //   auto res = cli.Get(path.c_str());
+    //   ASSERT_TRUE(res != nullptr);
+    //   EXPECT_EQ(400, res->status);
+    // }
  }
 }
 #endif
@@ -649,19 +651,6 @@ TEST(YahooRedirectTest, Redirect) {
  EXPECT_EQ(200, res->status);
 }

-TEST(YahooRedirectTestWithURL, Redirect) {
-  auto res = httplib::url::Get("http://yahoo.com");
-  ASSERT_TRUE(res != nullptr);
-  EXPECT_EQ(301, res->status);
-
-  httplib::url::Options options;
-  options.follow_location = true;
-
-  res = httplib::url::Get("http://yahoo.com", options);
-  ASSERT_TRUE(res != nullptr);
-  EXPECT_EQ(200, res->status);
-}
-
 TEST(HttpsToHttpRedirectTest, Redirect) {
  httplib::SSLClient cli("httpbin.org");
  cli.set_follow_location(true);
@@ -671,19 +660,6 @@ TEST(HttpsToHttpRedirectTest, Redirect) {
  EXPECT_EQ(200, res->status);
 }

-TEST(HttpsToHttpRedirectTestWithURL, Redirect) {
-  httplib::url::Options options;
-  options.follow_location = true;
-
-  auto res = httplib::url::Get(
-      "https://httpbin.org/"
-      "redirect-to?url=http%3A%2F%2Fwww.google.com&status_code=302",
-      options);
-
-  ASSERT_TRUE(res != nullptr);
-  EXPECT_EQ(200, res->status);
-}
-
 TEST(RedirectToDifferentPort, Redirect) {
  Server svr8080;
  Server svr8081;
@@ -713,7 +689,7 @@ TEST(RedirectToDifferentPort, Redirect) {
  auto res = cli.Get("/1");
  ASSERT_TRUE(res != nullptr);
  EXPECT_EQ(200, res->status);
-  EXPECT_EQ(res->body, "Hello World!");
+  EXPECT_EQ("Hello World!", res->body);

  svr8080.stop();
  svr8081.stop();
@@ -724,6 +700,39 @@ TEST(RedirectToDifferentPort, Redirect) {
 }
 #endif

+TEST(Server, BindDualStack) {
+  Server svr;
+
+  svr.Get("/1", [&](const Request & /*req*/, Response &res) {
+    res.set_content("Hello World!", "text/plain");
+  });
+
+  auto thread = std::thread([&]() { svr.listen("::", PORT); });
+
+  // Give GET time to get a few messages.
+  std::this_thread::sleep_for(std::chrono::seconds(1));
+
+  {
+    Client cli("127.0.0.1", PORT);
+
+    auto res = cli.Get("/1");
+    ASSERT_TRUE(res != nullptr);
+    EXPECT_EQ(200, res->status);
+    EXPECT_EQ("Hello World!", res->body);
+  }
+  {
+    Client cli("::1", PORT);
+
+    auto res = cli.Get("/1");
+    ASSERT_TRUE(res != nullptr);
+    EXPECT_EQ(200, res->status);
+    EXPECT_EQ("Hello World!", res->body);
+  }
+  svr.stop();
+  thread.join();
+  ASSERT_FALSE(svr.is_running());
+}
+
 TEST(Server, BindAndListenSeparately) {
  Server svr;
  int port = svr.bind_to_any_port("0.0.0.0");
@@ -798,6 +807,11 @@ protected:
               std::this_thread::sleep_for(std::chrono::seconds(2));
               res.set_content("slow", "text/plain");
             })
+        .Post("/slowpost",
+              [&](const Request & /*req*/, Response &res) {
+                std::this_thread::sleep_for(std::chrono::seconds(2));
+                res.set_content("slow", "text/plain");
+              })
        .Get("/remote_addr",
             [&](const Request &req, Response &res) {
               auto remote_addr = req.headers.find("REMOTE_ADDR")->second;
@@ -864,35 +878,38 @@ protected:
        .Get("/streamed-chunked",
             [&](const Request & /*req*/, Response &res) {
               res.set_chunked_content_provider(
-                   [](uint64_t /*offset*/, DataSink &sink) {
-                     ASSERT_TRUE(sink.is_writable());
-                     sink.write("123", 3);
-                     sink.write("456", 3);
-                     sink.write("789", 3);
+                   [](size_t /*offset*/, DataSink &sink) {
+                     EXPECT_TRUE(sink.is_writable());
+                     sink.os << "123";
+                     sink.os << "456";
+                     sink.os << "789";
                     sink.done();
+                     return true;
                   });
             })
        .Get("/streamed-chunked2",
             [&](const Request & /*req*/, Response &res) {
               auto i = new int(0);
               res.set_chunked_content_provider(
-                   [i](uint64_t /*offset*/, DataSink &sink) {
-                     ASSERT_TRUE(sink.is_writable());
+                   [i](size_t /*offset*/, DataSink &sink) {
+                     EXPECT_TRUE(sink.is_writable());
                     switch (*i) {
-                     case 0: sink.write("123", 3); break;
-                     case 1: sink.write("456", 3); break;
-                     case 2: sink.write("789", 3); break;
+                     case 0: sink.os << "123"; break;
+                     case 1: sink.os << "456"; break;
+                     case 2: sink.os << "789"; break;
                     case 3: sink.done(); break;
                     }
                     (*i)++;
+                     return true;
                   },
                   [i] { delete i; });
             })
        .Get("/streamed",
             [&](const Request & /*req*/, Response &res) {
               res.set_content_provider(
-                   6, [](uint64_t offset, uint64_t /*length*/, DataSink &sink) {
-                     sink.write(offset < 3 ? "a" : "b", 1);
+                   6, [](size_t offset, size_t /*length*/, DataSink &sink) {
+                     sink.os << (offset < 3 ? "a" : "b");
+                     return true;
                   });
             })
        .Get("/streamed-with-range",
@@ -900,25 +917,26 @@ protected:
               auto data = new std::string("abcdefg");
               res.set_content_provider(
                   data->size(),
-                   [data](uint64_t offset, uint64_t length, DataSink &sink) {
-                     ASSERT_TRUE(sink.is_writable());
+                   [data](size_t offset, size_t length, DataSink &sink) {
+                     EXPECT_TRUE(sink.is_writable());
                     size_t DATA_CHUNK_SIZE = 4;
                     const auto &d = *data;
                     auto out_len =
                         std::min(static_cast<size_t>(length), DATA_CHUNK_SIZE);
                     sink.write(&d[static_cast<size_t>(offset)], out_len);
+                     return true;
                   },
                   [data] { delete data; });
             })
        .Get("/streamed-cancel",
             [&](const Request & /*req*/, Response &res) {
-               res.set_content_provider(size_t(-1), [](uint64_t /*offset*/,
-                                                       uint64_t /*length*/,
-                                                       DataSink &sink) {
-                 ASSERT_TRUE(sink.is_writable());
-                 std::string data = "data_chunk";
-                 sink.write(data.data(), data.size());
-               });
+               res.set_content_provider(
+                   size_t(-1),
+                   [](size_t /*offset*/, size_t /*length*/, DataSink &sink) {
+                     EXPECT_TRUE(sink.is_writable());
+                     sink.os << "data_chunk";
+                     return true;
+                   });
             })
        .Get("/with-range",
             [&](const Request & /*req*/, Response &res) {
@@ -1118,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) {
@@ -1748,15 +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) {
@@ -1873,6 +1904,33 @@ TEST_F(ServerTest, SlowRequest) {
  std::this_thread::sleep_for(std::chrono::milliseconds(100));
 }

+TEST_F(ServerTest, SlowPost) {
+  char buffer[64 * 1024];
+  memset(buffer, 0x42, sizeof(buffer));
+
+  auto res = cli_.Post(
+      "/slowpost", 64 * 1024 * 1024,
+      [&](size_t /*offset*/, size_t /*length*/, DataSink &sink) {
+        sink.write(buffer, sizeof(buffer));
+        return true;
+      },
+      "text/plain");
+
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(200, res->status);
+
+  cli_.set_write_timeout(0, 0);
+  res = cli_.Post(
+      "/slowpost", 64 * 1024 * 1024,
+      [&](size_t /*offset*/, size_t /*length*/, DataSink &sink) {
+        sink.write(buffer, sizeof(buffer));
+        return true;
+      },
+      "text/plain");
+
+  ASSERT_FALSE(res != nullptr);
+}
+
 TEST_F(ServerTest, Put) {
  auto res = cli_.Put("/put", "PUT", "text/plain");
  ASSERT_TRUE(res != nullptr);
@@ -1884,8 +1942,9 @@ TEST_F(ServerTest, PutWithContentProvider) {
  auto res = cli_.Put(
      "/put", 3,
      [](size_t /*offset*/, size_t /*length*/, DataSink &sink) {
-        ASSERT_TRUE(sink.is_writable());
-        sink.write("PUT", 3);
+        EXPECT_TRUE(sink.is_writable());
+        sink.os << "PUT";
+        return true;
      },
      "text/plain");

@@ -1894,14 +1953,26 @@ TEST_F(ServerTest, PutWithContentProvider) {
  EXPECT_EQ("PUT", res->body);
 }

+TEST_F(ServerTest, PostWithContentProviderAbort) {
+  auto res = cli_.Post(
+      "/post", 42,
+      [](size_t /*offset*/, size_t /*length*/, DataSink & /*sink*/) {
+        return false;
+      },
+      "text/plain");
+
+  ASSERT_TRUE(res == nullptr);
+}
+
 #ifdef CPPHTTPLIB_ZLIB_SUPPORT
 TEST_F(ServerTest, PutWithContentProviderWithGzip) {
  cli_.set_compress(true);
  auto res = cli_.Put(
      "/put", 3,
      [](size_t /*offset*/, size_t /*length*/, DataSink &sink) {
-        ASSERT_TRUE(sink.is_writable());
-        sink.write("PUT", 3);
+        EXPECT_TRUE(sink.is_writable());
+        sink.os << "PUT";
+        return true;
      },
      "text/plain");

@@ -1910,6 +1981,18 @@ TEST_F(ServerTest, PutWithContentProviderWithGzip) {
  EXPECT_EQ("PUT", res->body);
 }

+TEST_F(ServerTest, PostWithContentProviderWithGzipAbort) {
+  cli_.set_compress(true);
+  auto res = cli_.Post(
+      "/post", 42,
+      [](size_t /*offset*/, size_t /*length*/, DataSink & /*sink*/) {
+        return false;
+      },
+      "text/plain");
+
+  ASSERT_TRUE(res == nullptr);
+}
+
 TEST_F(ServerTest, PutLargeFileWithGzip) {
  cli_.set_compress(true);
  auto res = cli_.Put("/put-large", LARGE_DATA, "text/plain");
@@ -2048,39 +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");
+  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);

-  {
-    auto &res = responses[4];
-    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
@@ -2134,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;
@@ -2207,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,
-      [&](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;
@@ -2229,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) {
@@ -2333,6 +2443,20 @@ TEST(ServerRequestParsingTest, ReadHeadersRegexComplexity2) {
      "&&&%%%");
 }

+TEST(ServerRequestParsingTest, ExcessiveWhitespaceInUnparseableHeaderLine) {
+  // Make sure this doesn't crash the server.
+  // In a previous version of the header line regex, the "\r" rendered the line
+  // unparseable and the regex engine repeatedly backtracked, trying to look for
+  // a new position where the leading white space ended and the field value
+  // began.
+  // The crash occurs with libc++ but not libstdc++.
+  test_raw_request("GET /hi HTTP/1.1\r\n"
+                   "a:" +
+                   std::string(2000, ' ') + '\r' + std::string(20, 'z') +
+                   "\r\n"
+                   "\r\n");
+}
+
 TEST(ServerRequestParsingTest, InvalidFirstChunkLengthInRequest) {
  std::string out;

@@ -2373,17 +2497,23 @@ TEST(ServerRequestParsingTest, ChunkLengthTooHighInRequest) {
  EXPECT_EQ("HTTP/1.1 400 Bad Request", out.substr(0, 24));
 }

+TEST(ServerRequestParsingTest, InvalidHeaderTextWithExtraCR) {
+  test_raw_request("GET /hi HTTP/1.1\r\n"
+                   "Content-Type: text/plain\r\n\r");
+}
+
 TEST(ServerStopTest, StopServerWithChunkedTransmission) {
  Server svr;

  svr.Get("/events", [](const Request & /*req*/, Response &res) {
    res.set_header("Content-Type", "text/event-stream");
    res.set_header("Cache-Control", "no-cache");
-    res.set_chunked_content_provider([](size_t offset, const DataSink &sink) {
+    res.set_chunked_content_provider([](size_t offset, DataSink &sink) {
      char buffer[27];
      auto size = static_cast<size_t>(sprintf(buffer, "data:%ld\n\n", offset));
      sink.write(buffer, size);
      std::this_thread::sleep_for(std::chrono::seconds(1));
+      return true;
    });
  });

@@ -2393,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(
@@ -2620,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);
 }
@@ -2682,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);

@@ -2751,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);

@@ -2775,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();
@@ -2797,19 +2931,12 @@ 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);

  t.join();
 }
-
-/* Cannot test this case as there is no external access to SSL object to check
-SSL_get_peer_certificate() == NULL TEST(SSLClientServerTest,
-ClientCAPathRequired) { SSLServer svr(SERVER_CERT_FILE, SERVER_PRIVATE_KEY_FILE,
-nullptr, CLIENT_CA_CERT_DIR);
-}
-*/
 #endif

 #ifdef _WIN32
@@ -2818,3 +2945,51 @@ TEST(CleanupTest, WSACleanup) {
  ASSERT_EQ(0, ret);
 }
 #endif
+
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+TEST(InvalidScheme, SimpleInterface) {
+  httplib::Client2 cli("scheme://yahoo.com");
+  ASSERT_FALSE(cli.is_valid());
+}
+
+TEST(NoScheme, SimpleInterface) {
+  httplib::Client2 cli("yahoo.com");
+  ASSERT_FALSE(cli.is_valid());
+}
+
+TEST(YahooRedirectTest2, SimpleInterface) {
+  httplib::Client2 cli("http://yahoo.com");
+
+  auto res = cli.Get("/");
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(301, res->status);
+
+  cli.set_follow_location(true);
+  res = cli.Get("/");
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(200, res->status);
+}
+
+TEST(YahooRedirectTest3, SimpleInterface) {
+  httplib::Client2 cli("https://yahoo.com");
+
+  auto res = cli.Get("/");
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(301, res->status);
+
+  cli.set_follow_location(true);
+  res = cli.Get("/");
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(200, res->status);
+}
+
+TEST(HttpsToHttpRedirectTest2, SimpleInterface) {
+  auto res =
+      httplib::Client2("https://httpbin.org")
+          .set_follow_location(true)
+          .Get("/redirect-to?url=http%3A%2F%2Fwww.google.com&status_code=302");
+
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(200, res->status);
+}
+#endif
--- a/test/test.vcxproj
+++ b/test/test.vcxproj
@@ -91,7 +91,7 @@
    <ClCompile>
      <PrecompiledHeader>
      </PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
+      <WarningLevel>Level4</WarningLevel>
      <Optimization>Disabled</Optimization>
      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <AdditionalIncludeDirectories>./;../</AdditionalIncludeDirectories>
@@ -108,7 +108,7 @@
    <ClCompile>
      <PrecompiledHeader>
      </PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
+      <WarningLevel>Level4</WarningLevel>
      <Optimization>Disabled</Optimization>
      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <AdditionalIncludeDirectories>./;../</AdditionalIncludeDirectories>
@@ -118,12 +118,12 @@
    <Link>
      <SubSystem>Console</SubSystem>
      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalDependencies>Ws2_32.lib;AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>Ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
+      <WarningLevel>Level4</WarningLevel>
      <PrecompiledHeader>
      </PrecompiledHeader>
      <Optimization>MaxSpeed</Optimization>
@@ -144,7 +144,7 @@
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
+      <WarningLevel>Level4</WarningLevel>
      <PrecompiledHeader>
      </PrecompiledHeader>
      <Optimization>MaxSpeed</Optimization>
@@ -171,4 +171,4 @@
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
  <ImportGroup Label="ExtensionTargets">
  </ImportGroup>
-</Project>
+</Project>
--- a/test/test_proxy.cc
+++ b/test/test_proxy.cc
@@ -185,15 +185,17 @@ void DigestAuthTestFromHTTPWatch(Client& cli) {
    for (auto path : paths) {
      auto res = cli.Get(path.c_str());
      ASSERT_TRUE(res != nullptr);
-      EXPECT_EQ(400, res->status);
+      EXPECT_EQ(401, res->status);
    }

-    cli.set_digest_auth("bad", "world");
-    for (auto path : paths) {
-      auto res = cli.Get(path.c_str());
-      ASSERT_TRUE(res != nullptr);
-      EXPECT_EQ(400, res->status);
-    }
+    // NOTE: Until httpbin.org fixes issue #46, the following test is commented
+    // out. Plese see https://httpbin.org/digest-auth/auth/hello/world
+    // cli.set_digest_auth("bad", "world");
+    // for (auto path : paths) {
+    //   auto res = cli.Get(path.c_str());
+    //   ASSERT_TRUE(res != nullptr);
+    //   EXPECT_EQ(401, res->status);
+    // }
  }
 }

@@ -220,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 = 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);
@@ -290,7 +271,6 @@ TEST(KeepAliveTest, SSLWithBasic) {
  KeepAliveTest(cli, true);
 }

-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
 TEST(KeepAliveTest, NoSSLWithDigest) {
  Client cli("httpbin.org");
  KeepAliveTest(cli, false);
Author	SHA1	Message	Date
yhirose	42f9f9107f	Updated version in the User Agent string	2020-06-16 17:53:15 -04:00
yhirose	7cd25fbd63	Fix #499	2020-06-16 17:46:23 -04:00
yhirose	3dfb4ecac2	Fix #522	2020-06-15 23:09:46 -04:00
yhirose	144114f316	Fixed warnings on Windows	2020-06-13 23:20:21 -04:00
yhirose	0cc108d45e	Updated ClientStop test	2020-06-13 23:18:59 -04:00
yhirose	0743d78c9b	Fixed ClientStop test error.	2020-06-14 03:01:41 +00:00
yhirose	e022b8b80b	Refactoring to make it ready for KeepAlive connection on Client	2020-06-13 21:42:23 -04:00
yhirose	34282c79a9	Changd thread count in ClientStop	2020-06-13 01:45:08 -04:00
yhirose	f80b6bd980	Added Endpoint structure in Client	2020-06-13 01:26:57 -04:00
yhirose	5af7222217	Fixed Client::stop problem with more than one requests on threads	2020-06-12 11:04:37 -04:00
KTGH	ec00fe5d5b	Use git to get full project version (#519 ) 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.	2020-06-10 18:23:45 -04:00
yhirose	24bdb736f0	Fix #506	2020-06-09 19:58:01 -04:00
yhirose	d0dc200633	Code format	2020-06-09 19:17:58 -04:00
Nicolas Schneider	919a51091f	replace usage of [[deprecated]] with CPPHTTPLIB_DEPRECATED (#513 )	2020-06-03 13:12:31 -04:00
Nicolas Schneider	05e8b22989	fix cast warning (#512 )	2020-06-03 07:44:16 -04:00
Nicolas Schneider	00dcd6b004	check for [[deprecated]] support via feature test macro (#511 ) The [[deprecated]] specifier is a C++14 feature, so it might not always be available on a C++11 compiler.	2020-06-03 07:43:56 -04:00
yhirose	a42c6b99d3	Code cleanup	2020-06-02 19:06:16 -04:00
Wang Gao	812cb5bc3d	fix get value function (#509 )	2020-06-02 19:05:04 -04:00
yhirose	aea60feb85	Code cleanup	2020-06-01 13:22:02 -04:00
yhirose	b3a4045300	Fix #503	2020-05-28 19:19:18 -04:00
KTGH	5fcd8f7795	Add automatic versioning to Cmake (#505 ) It pulls the version from the user-agent string in the header, so it will not need to be manually adjusted. This version file is installed so that you can check for a specific version with find_package(httplib) Also added HTTPLIB_INCLUDE_DIR (root path without header name), and HTTPLIB_LIBRARY (only if compiled). Added HTTPLIB_VERSION, and HTTPLIB_FOUND (although it's recommended to check if the target exists). Updated CMakeLists documentation for all this.	2020-05-28 17:09:20 -04:00
yhirose	d9fe3fa020	Fix #504	2020-05-28 17:08:05 -04:00
yhirose	d8612ac02d	Fixed build error...	2020-05-28 12:51:52 -04:00
yhirose	83ee6007da	Fix #500	2020-05-28 12:06:11 -04:00
yhirose	3eaa769a2d	Fix #481 , #483 , #487	2020-05-26 18:34:32 -04:00
yhirose	b91540514d	Fix #494	2020-05-25 10:50:24 -04:00
yhirose	ab563ff52c	Fix #496	2020-05-25 10:38:47 -04:00
KTGH	8cad160c0a	Add HTTPLIB_COMPILE option to Cmake (#493 ) This option (default OFF) automatically splits the file (with split.py) into a header & source file, then compiles it as a shared/static library. This requires an installed Python v3 executable to work. This also adds a HTTPLIB_IS_COMPILED boolean that's available after a finfind_package(httplib) call. Note that the minimum Cmake version increased to 3.12 because of FindPython3. Hopefully this isn't a problem, as it's already 3 years old at this point.	2020-05-24 16:07:44 -04:00
yhirose	be7962f140	Fix #489	2020-05-24 15:18:34 -04:00
yhirose	509b8570b0	Updated README	2020-05-23 19:08:17 -04:00
yhirose	630f3465a9	Deprecated `set_timeout_sec`, added `set_connection_timeout`.	2020-05-23 18:00:24 -04:00
yhirose	9af1a4a08f	Fixed problem with `stop` on windows	2020-05-23 13:49:49 -04:00
yhirose	0654e5dab4	Changed CPPHTTPLIB_IDLE_INTERVAL_USECOND to 0	2020-05-23 08:44:03 -04:00
yhirose	62e036f253	Fixed #488 again	2020-05-22 18:24:01 -04:00
yhirose	f0adfb2e0c	Fix #488	2020-05-22 12:18:07 -04:00
yhirose	139c816c16	Fixed the location of Client2	2020-05-19 21:02:58 -04:00
KTGH	9505a76491	Bringing Cmake back (#470 ) * Revert "Removed CMakeLists.txt. (Fix #421)" This reverts commit `8674555b88`. * Fail if cmake version too old Previous behaviour is just a warning. * Improve CMakeLists Adds automatic dependency finding (if they were used). Adds a way to require a specific version in the find_package(httplib) call. You should link against the httplib::httplib IMPORTED target, which is created automatically. Add options to allow for strictly requiring OpenSSL/ZLIB HTTPLIB_REQUIRE_OPENSSL & HTTPLIB_REQUIRE_ZLIB require the libs be found, or the build fails. HTTPLIB_USE_OPENSSL_IF_AVAILABLE & HTTPLIB_USE_ZLIB_IF_AVAILABLE silently search for the libs. If they aren't found, the build still continues, but shuts off support for those features. * Add documentation to CMakeLists.txt Has info on all the available options and what targets are produced. Also put some things about installation on certain platforms.	2020-05-19 19:07:18 -04:00
yhirose	29fd136afd	Code cleanup and format	2020-05-16 17:35:04 -04:00
yhirose	f5598237b2	Fixed many redirects problem on Proxy	2020-05-16 17:34:03 -04:00
Daniel Ottiger	01058659ab	make write timeout configurable (like the read timeout already is) (#477 ) In case we want to send a lot of data, and the receiver is slower than the sender. This will first fill up the receivers queues and after this eventually also the senders queues, until the socket is temporarily unable to accept more data to send. select_write is done with an timeout of zero, which makes the select call used always return immediately: (see http://man7.org/linux/man-pages/man2/select.2.html) This means that every marginal unavailability will make it return false for is_writable and therefore httplib will immediately abort the transfer. Therefore make this values configurable in the same way as the read timeout already is. Set the default write timeout to 5 seconds, the same default value used for the read timeout.	2020-05-16 17:31:46 -04:00
yhirose	66f698fab6	Fixed build errors with some examples	2020-05-16 00:50:52 -04:00
yhirose	b9a9df4d73	Fixed problem with writing large data	2020-05-15 22:21:58 -04:00
yhirose	25aa3ca982	Added std::ostream os in DataSink.	2020-05-15 21:26:13 -04:00
yhirose	2d67211183	Added more unit tests for the simple interface	2020-05-14 18:25:18 -04:00
yhirose	f4c5d94d74	Updated version in the User Agent string	2020-05-14 18:07:02 -04:00
yhirose	63a96aeb20	Improved Client2 interface	2020-05-14 12:51:34 -04:00
yhirose	bbb83d12c1	Removed default parameter values in Client and SSLClient constructors	2020-05-14 08:51:32 -04:00
yhirose	2d4b42b70b	Removed url	2020-05-14 01:43:06 -04:00
yhirose	1919d08f71	Added Client2	2020-05-14 01:36:56 -04:00
yhirose	824c02fcd3	Code cleanup	2020-05-14 01:08:36 -04:00
yhirose	2c0613f211	Fix #472	2020-05-13 21:48:14 -04:00
Saika Fatih	be45ff1ff1	A detail about Gzip support (#475 ) * Typos fixed * README.md edited.libz should be linked for GZIP support.	2020-05-12 17:38:51 -04:00
Saika Fatih	803ebe1e20	Typos fixed (#474 )	2020-05-12 13:18:58 -04:00
yhirose	ba685dbe48	Fixed potential infinite loop with content receiver	2020-05-10 20:45:57 -04:00
yhirose	49c4c2f9c1	Fix #459	2020-05-10 20:39:16 -04:00
yhirose	58909f5917	Fix #466	2020-05-10 15:58:53 -04:00
yhirose	5982b5c360	Fix #471	2020-05-10 14:18:03 -04:00
yhirose	eb1fe5b191	Fixed warnings	2020-05-09 15:08:49 -04:00
yhirose	5e01587ed6	Fixed problem created in the previous commit	2020-05-09 13:43:06 -04:00
yhirose	5935d9fa59	Commented out the unit test for digest auth.	2020-05-09 13:32:51 -04:00
PixlRainbow	5bb4c12c6b	Fix #465 (#467 ) update digest header username to use username parameter instead of "hello" test value	2020-05-09 08:29:08 -04:00
yhirose	85637844c9	Updated README	2020-05-07 21:13:45 -04:00
Daniel Ottiger	d043b18097	keepalive: support multiple post using content provider (#461 )	2020-05-07 08:31:14 -04:00
yhirose	31bb13abd2	Removed TravisCI badge from README	2020-05-04 22:19:17 -04:00
yhirose	8728db7477	Apply IPV6_V6ONLY only when socket is AF_INET6	2020-05-04 22:16:43 -04:00
yhirose	1c50ac3667	Stop using TravisCI anymore due to IPv6 issue	2020-05-04 22:14:03 -04:00
yhirose	cf386f97fd	Merge branch 'master' of https://github.com/yhirose/cpp-httplib	2020-05-04 22:13:17 -04:00
Daniel Ottiger	b2203bb05a	server: support dual-stack server socket (#450 ) According to RFC 3493 the socket option IPV6_V6ONLY should be off by default, see https://tools.ietf.org/html/rfc3493#page-22 (chapter 5.3). However this does not seem to be the case on all systems. For instance on any Windows OS, the option is on by default. Therefore clear this option in order to allow an server socket which can support IPv6 and IPv4 at the same time.	2020-05-04 22:13:12 -04:00
yhirose	f5b806d995	Added a test case for #396 .	2020-05-04 21:26:14 -04:00
yhirose	3895210f19	Code format	2020-05-04 21:25:59 -04:00
yhirose	d45250fd88	Appled HANDLE_EINTR to `send` and `select` system calls	2020-05-01 21:38:23 -04:00
yhirose	528cacdc0d	Changed CPPHTTPLIB_THREAD_POOL_COUNT back to 8. (#454 )	2020-05-01 21:23:02 -04:00
Matthew DeVore	ed1b6afa10	Fix crash caused by header field regex complexity (#457 )	2020-05-01 12:44:13 -04:00
yhirose	08fc7085e5	Fixed #456	2020-04-30 19:40:23 -04:00
yhirose	8333340e2c	Chagned to use inline function instead of macro	2020-04-27 12:36:39 -04:00
yhirose	98a0887571	Merge branch 'je-ik-sketch-eintr-handling'	2020-04-27 12:33:21 -04:00
Jan Lukavsky	b0a189e50e	Sketch handling EINTR errors	2020-04-27 17:36:44 +02:00