Fix #661

* don't replace plus with space in headers

* fixed forward handling with changed header parsing

* add test for boundaries containing plus chars

.github/workflows/test.yaml

@@ -8,10 +8,31 @@ jobs:
 
     strategy:
       matrix:
-        os: [macOS-latest, ubuntu-latest]
+        os: [macOS-latest, ubuntu-latest, windows-latest]
 
     steps:
+    - name: prepare git for checkout on windows
+      if: matrix.os == 'windows-latest'
+      run: |
+        git config --global core.autocrlf false
+        git config --global core.eol lf
     - name: checkout
-      uses: actions/checkout@v1
+      uses: actions/checkout@v2
+    - name: install brotli library on ubuntu
+      if: matrix.os == 'ubuntu-latest'
+      run: sudo apt-get install -y libbrotli-dev
+    - name: install brotli library on macOS
+      if: matrix.os == 'macOS-latest'
+      run: brew install brotli
     - name: make
+      if: matrix.os != 'windows-latest'
       run: cd test && make
+    - name: setup msbuild on windows
+      if: matrix.os == 'windows-latest'
+      uses: warrenbuckley/Setup-MSBuild@v1
+    - name: make-windows
+      if: matrix.os == 'windows-latest'
+      run: |
+        cd test
+        msbuild.exe test.sln /verbosity:minimal /t:Build "/p:Configuration=Release;Platform=x64"
+        x64\Release\test.exe

CMakeLists.txt

@@ -1,6 +1,6 @@
 #[[
 	Build options:
-	* BUILD_SHARED_LIBS (default off) builds as a static library (if HTTPLIB_COMPILE is ON)
+	* BUILD_SHARED_LIBS (default off) builds as a shared library (if HTTPLIB_COMPILE is ON)
 	* HTTPLIB_USE_OPENSSL_IF_AVAILABLE (default on)
 	* HTTPLIB_USE_ZLIB_IF_AVAILABLE (default on)
 	* HTTPLIB_REQUIRE_OPENSSL (default off)
@@ -60,17 +60,22 @@
 ]]
 cmake_minimum_required(VERSION 3.14.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
-)
+# On systems without Git installed, there were errors since execute_process seemed to not throw an error without it?
+find_package(Git QUIET)
+if(Git_FOUND)
+	# 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_EXECUTABLE} describe --tags --abbrev=0
+		WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+		OUTPUT_VARIABLE _raw_version_string
+		ERROR_VARIABLE _git_tag_error
+	)
+endif()
 
 # 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.")
+if(_git_tag_error OR NOT Git_FOUND)
+	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.
@@ -101,7 +106,7 @@ if(HTTPLIB_COMPILE)
 endif()
 
 option(HTTPLIB_REQUIRE_BROTLI "Requires Brotli to be found & linked, or fails build." OFF)
-option(HTTPLIB_USE_BROTLI_IF_AVAILABLE "Uses Brotli (if available) to enable Brotli compression support." ON)
+option(HTTPLIB_USE_BROTLI_IF_AVAILABLE "Uses Brotli (if available) to enable Brotli decompression support." ON)
 # 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)
@@ -231,9 +236,9 @@ target_link_libraries(${PROJECT_NAME} ${_INTERFACE_OR_PUBLIC}
 
 # Set the definitions to enable optional features
 target_compile_definitions(${PROJECT_NAME} ${_INTERFACE_OR_PUBLIC}
-	$<$<BOOL:${HTTPLIB_IS_USING_BROTLI}>:"CPPHTTPLIB_BROTLI_SUPPORT">
-	$<$<BOOL:${HTTPLIB_IS_USING_ZLIB}>:"CPPHTTPLIB_ZLIB_SUPPORT">
-	$<$<BOOL:${HTTPLIB_IS_USING_OPENSSL}>:"CPPHTTPLIB_OPENSSL_SUPPORT">
+	$<$<BOOL:${HTTPLIB_IS_USING_BROTLI}>:CPPHTTPLIB_BROTLI_SUPPORT>
+	$<$<BOOL:${HTTPLIB_IS_USING_ZLIB}>:CPPHTTPLIB_ZLIB_SUPPORT>
+	$<$<BOOL:${HTTPLIB_IS_USING_OPENSSL}>:CPPHTTPLIB_OPENSSL_SUPPORT>
 )
 
 # Cmake's find_package search path is different based on the system

README.md

@@ -2,16 +2,46 @@ cpp-httplib
 ===========
 
 [![](https://github.com/yhirose/cpp-httplib/workflows/test/badge.svg)](https://github.com/yhirose/cpp-httplib/actions)
-[![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.
 
 It's extremely easy to setup. Just include **httplib.h** file in your code!
 
-For Windows users: Please read [this note](https://github.com/yhirose/cpp-httplib#windows).
+NOTE: This is a 'blocking' HTTP library. If you are looking for a 'non-blocking' library, this is not the one that you want.
 
-Server Example
---------------
+Simple examples
+---------------
+
+#### Server
+
+```c++
+httplib::Server svr;
+
+svr.Get("/hi", [](const httplib::Request &, httplib::Response &res) {
+  res.set_content("Hello World!", "text/plain");
+});
+
+svr.listen("0.0.0.0", 8080);
+```
+
+#### Client
+
+```c++
+httplib::Client cli("http://cpp-httplib-server.yhirose.repl.co");
+
+auto res = cli.Get("/hi");
+
+res->status; // 200
+res->body;   // "Hello World!"
+```
+
+### Try out the examples on Repl.it!
+
+1. Run server at https://repl.it/@yhirose/cpp-httplib-server
+2. Run client at https://repl.it/@yhirose/cpp-httplib-client
+
+Server
+------
 
 ```c++
 #include <httplib.h>
@@ -178,6 +208,7 @@ svr.Get("/stream", [&](const Request &req, Response &res) {
 
   res.set_content_provider(
     data->size(), // Content length
+    "text/plain", // Content type
     [data](size_t offset, size_t length, DataSink &sink) {
       const auto &d = *data;
       sink.write(&d[offset], std::min(length, DATA_CHUNK_SIZE));
@@ -187,6 +218,25 @@ svr.Get("/stream", [&](const Request &req, Response &res) {
 });
 ```
 
+Without content length:
+
+```cpp
+svr.Get("/stream", [&](const Request &req, Response &res) {
+  res.set_content_provider(
+    "text/plain", // Content type
+    [&](size_t offset, size_t length, DataSink &sink) {
+      if (/* there is still data */) {
+        std::vector<char> data;
+        // prepare data...
+        sink.write(data.data(), data.size());
+      } else {
+        sink.done(); // No more data
+      }
+      return true; // return 'false' if you want to cancel the process.
+    });
+});
+```
+
 ### Chunked transfer encoding
 
 ```cpp
@@ -196,7 +246,7 @@ svr.Get("/chunked", [&](const Request& req, Response& res) {
       sink.write("123", 3);
       sink.write("345", 3);
       sink.write("789", 3);
-      sink.done();
+      sink.done(); // No more data
       return true; // return 'false' if you want to cancel the process.
     }
   );
@@ -247,13 +297,18 @@ Please see [Server example](https://github.com/yhirose/cpp-httplib/blob/master/e
 
 ### Default thread pool support
 
+`ThreadPool` is used as a **default** task queue, and the default thread count is 8, or `std::thread::hardware_concurrency()`. You can change it with `CPPHTTPLIB_THREAD_POOL_COUNT`.
 
-`ThreadPool` is used as a default task queue, and the default thread count is set to value from `std::thread::hardware_concurrency()`.
+If you want to set the thread count at runtime, there is no convenient way... But here is how.
 
-You can change the thread count by setting `CPPHTTPLIB_THREAD_POOL_COUNT`.
+```cpp
+svr.new_task_queue = [] { return new ThreadPool(12); };
+```
 
 ### Override the default thread pool with yours
 
+You can supply your own thread pool implementation according to your need.
+
 ```cpp
 class YourThreadPoolTaskQueue : public TaskQueue {
 public:
@@ -278,8 +333,8 @@ svr.new_task_queue = [] {
 };
 ```
 
-Client Example
---------------
+Client
+------
 
 ```c++
 #include <httplib.h>
@@ -287,16 +342,29 @@ Client Example
 
 int main(void)
 {
-  // IMPORTANT: 1st parameter must be a hostname or an IP address string.
   httplib::Client cli("localhost", 1234);
 
-  auto res = cli.Get("/hi");
-  if (res && res->status == 200) {
-    std::cout << res->body << std::endl;
+  if (auto res = cli.Get("/hi")) {
+    if (res->status == 200) {
+      std::cout << res->body << std::endl;
+    }
+  } else {
+    auto err = res.error();
+    ...
   }
 }
 ```
 
+NOTE: Constructor with scheme-host-port string is now supported!
+
+```c++
+httplib::Client cli("localhost");
+httplib::Client cli("localhost:8080");
+httplib::Client cli("http://localhost");
+httplib::Client cli("http://localhost:8080");
+httplib::Client cli("https://localhost");
+```
+
 ### GET with HTTP headers
 
 ```c++
@@ -305,6 +373,13 @@ httplib::Headers headers = {
 };
 auto res = cli.Get("/hi", headers);
 ```
+or
+```c++
+cli.set_default_headers({
+  { "Accept-Encoding", "gzip, deflate" }
+});
+auto res = cli.Get("/hi");
+```
 
 ### POST
 
@@ -421,13 +496,12 @@ auto res = cli_.Post(
 httplib::Client client(url, port);
 
 // prints: 0 / 000 bytes => 50% complete
-std::shared_ptr<httplib::Response> res =
-  cli.Get("/", [](uint64_t len, uint64_t total) {
-    printf("%lld / %lld bytes => %d%% complete\n",
-      len, total,
-      (int)(len*100/total));
-    return true; // return 'false' if you want to cancel the request.
-  }
+auto res = cli.Get("/", [](uint64_t len, uint64_t total) {
+  printf("%lld / %lld bytes => %d%% complete\n",
+    len, total,
+    (int)(len*100/total));
+  return true; // return 'false' if you want to cancel the request.
+}
 );
 ```
 
@@ -441,6 +515,9 @@ cli.set_basic_auth("user", "pass");
 
 // Digest Authentication
 cli.set_digest_auth("user", "pass");
+
+// Bearer Token Authentication
+cli.set_bearer_token_auth("token");
 ```
 
 NOTE: OpenSSL is required for Digest Authentication.
@@ -455,6 +532,9 @@ cli.set_proxy_basic_auth("user", "pass");
 
 // Digest Authentication
 cli.set_proxy_digest_auth("user", "pass");
+
+// Bearer Token Authentication
+cli.set_proxy_bearer_token_auth("pass");
 ```
 
 NOTE: OpenSSL is required for Digest Authentication.
@@ -517,14 +597,14 @@ OpenSSL Support
 
 SSL support is available with `CPPHTTPLIB_OPENSSL_SUPPORT`. `libssl` and `libcrypto` should be linked.
 
-NOTE: cpp-httplib supports 1.1.1 (until 2023-09-11) and 1.0.2 (2019-12-31).
+NOTE: cpp-httplib currently supports only version 1.1.1.
 
 ```c++
 #define CPPHTTPLIB_OPENSSL_SUPPORT
 
-SSLServer svr("./cert.pem", "./key.pem");
+httplib::SSLServer svr("./cert.pem", "./key.pem");
 
-SSLClient cli("localhost", 8080);
+httplib::SSLClient cli("localhost", 1234); // or `httplib::Client cli("https://localhost:1234");`
 cli.set_ca_cert_path("./ca-bundle.crt");
 cli.enable_server_certificate_verification(true);
 ```

appveyor.yml

@@ -1,14 +0,0 @@
-image:
-  - Visual Studio 2019
-
-platform:
-  - x64
-
-build_script:
-  - cmd: >-
-      cd test
-
-      msbuild.exe test.sln /verbosity:minimal /t:Build /p:Configuration=Release;Platform=%PLATFORM%
-
-test_script:
-  - cmd: x64\Release\test.exe

cmake/FindBrotli.cmake

@@ -5,181 +5,174 @@
 # The targets will have the same names, but it will use the static libs.
 #
 # Valid find_package COMPONENTS names: "decoder", "encoder", and "common"
+# Note that if you're requiring "decoder" or "encoder", then "common" will be automatically added as required.
 #
 # Defines the libraries (if found): Brotli::decoder, Brotli::encoder, Brotli::common
 # and the includes path variable: Brotli_INCLUDE_DIR
+#
+# If it's failing to find the libraries, try setting BROTLI_ROOT_DIR to the folder containing your library & include dir.
 
-function(brotli_err_msg _err_msg)
+# If they asked for a specific version, warn/fail since we don't support it.
+# TODO: if they start distributing the version somewhere, implement finding it.
+# But currently there's a version header that doesn't seem to get installed.
+if(Brotli_FIND_VERSION)
+	set(_brotli_version_error_msg "FindBrotli.cmake doesn't have version support!")
 	# If the package is required, throw a fatal error
 	# Otherwise, if not running quietly, we throw a warning
 	if(Brotli_FIND_REQUIRED)
-		message(FATAL_ERROR "${_err_msg}")
+		message(FATAL_ERROR "${_brotli_version_error_msg}")
 	elseif(NOT Brotli_FIND_QUIETLY)
-		message(WARNING "${_err_msg}")
+		message(WARNING "${_brotli_version_error_msg}")
 	endif()
-endfunction()
-
-# If they asked for a specific version, warn/fail since we don't support it.
-if(Brotli_FIND_VERSION)
-	brotli_err_msg("FindBrotli.cmake doesn't have version support!")
 endif()
 
-# Since both decoder & encoder require the common lib (I think), force its requirement..
+# Since both decoder & encoder require the common lib, force its requirement..
 # if the user is requiring either of those other libs.
 if(Brotli_FIND_REQUIRED_decoder OR Brotli_FIND_REQUIRED_encoder)
 	set(Brotli_FIND_REQUIRED_common TRUE)
 endif()
 
+# Support preference of static libs by adjusting CMAKE_FIND_LIBRARY_SUFFIXES
+# Credit to FindOpenSSL.cmake for this
+if(BROTLI_USE_STATIC_LIBS)
+  set(_brotli_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
+  if(WIN32)
+    set(CMAKE_FIND_LIBRARY_SUFFIXES .lib .a ${CMAKE_FIND_LIBRARY_SUFFIXES})
+  else()
+    set(CMAKE_FIND_LIBRARY_SUFFIXES .a)
+  endif()
+endif()
+
 # Make PkgConfig optional, since some users (mainly Windows) don't have it.
 # But it's a lot more clean than manually using find_library.
 find_package(PkgConfig QUIET)
-if(PKG_CONFIG_FOUND)
-	if(BROTLI_USE_STATIC_LIBS)
-		pkg_check_modules(Brotli_common_STATIC QUIET IMPORTED_TARGET libbrotlicommon)
-		pkg_check_modules(Brotli_decoder_STATIC QUIET IMPORTED_TARGET libbrotlidec)
-		pkg_check_modules(Brotli_encoder_STATIC QUIET IMPORTED_TARGET libbrotlienc)
-	else()
-		pkg_check_modules(Brotli_common QUIET IMPORTED_TARGET libbrotlicommon)
-		pkg_check_modules(Brotli_decoder QUIET IMPORTED_TARGET libbrotlidec)
-		pkg_check_modules(Brotli_encoder QUIET IMPORTED_TARGET libbrotlienc)
-	endif()
-endif()
 
 # Only used if the PkgConfig libraries aren't used.
 find_path(Brotli_INCLUDE_DIR
-	NAMES "brotli/decode.h" "brotli/encode.h"
-	PATH_SUFFIXES "include" "includes"
+	NAMES
+		"brotli/decode.h"
+		"brotli/encode.h"
+	HINTS
+		${BROTLI_ROOT_DIR}
+	PATH_SUFFIXES
+		"include"
+		"includes"
 	DOC "The path to Brotli's include directory."
 )
+# Hides this var from the GUI
+mark_as_advanced(Brotli_INCLUDE_DIR)
 
-# Also check if Brotli_decoder was defined, as it can be passed by the end-user
-if(NOT TARGET PkgConfig::Brotli_decoder AND NOT Brotli_decoder)
-	if(BROTLI_USE_STATIC_LIBS)
-		list(APPEND _brotli_decoder_lib_names
-			"brotlidec-static"
-			"libbrotlidec-static"
-		)
-	else()
-		list(APPEND _brotli_decoder_lib_names
-			"brotlidec"
-			"libbrotlidec"
-		)
-	endif()
-	find_library(Brotli_decoder
-		NAMES ${_brotli_decoder_lib_names}
-		PATH_SUFFIXES
-			"lib"
-			"lib64"
-			"libs"
-			"libs64"
-			"lib/x86_64-linux-gnu"
-	)
+# Just used for PkgConfig stuff in the loop below
+set(_brotli_stat_str "")
+if(BROTLI_USE_STATIC_LIBS)
+	set(_brotli_stat_str "_STATIC")
 endif()
 
-# Also check if Brotli_encoder was defined, as it can be passed by the end-user
-if(NOT TARGET PkgConfig::Brotli_encoder AND NOT Brotli_encoder)
-	if(BROTLI_USE_STATIC_LIBS)
-		list(APPEND _brotli_encoder_lib_names
-			"brotlienc-static"
-			"libbrotlienc-static"
-		)
-	else()
-		list(APPEND _brotli_encoder_lib_names
-			"brotlienc"
-			"libbrotlienc"
-		)
+# Lets us know we are using the PkgConfig libraries
+# Will be set false if any non-pkgconf vars are used
+set(_brotli_using_pkgconf TRUE)
+
+# Each string here is "ComponentName;LiteralName" (the semi-colon is a delimiter)
+foreach(_listvar "common;common" "decoder;dec" "encoder;enc")
+	# Split the component name and literal library name from the listvar
+	list(GET _listvar 0 _component_name)
+	list(GET _listvar 1 _libname)
+
+	if(PKG_CONFIG_FOUND)
+		# These need to be GLOBAL for MinGW when making ALIAS libraries against them.
+		if(BROTLI_USE_STATIC_LIBS)
+			# Have to use _STATIC to tell PkgConfig to find the static libs.
+			pkg_check_modules(Brotli_${_component_name}_STATIC QUIET GLOBAL IMPORTED_TARGET libbrotli${_libname})
+		else()
+			pkg_check_modules(Brotli_${_component_name} QUIET GLOBAL IMPORTED_TARGET libbrotli${_libname})
+		endif()
 	endif()
-	find_library(Brotli_encoder
-		NAMES ${_brotli_encoder_lib_names}
-		PATH_SUFFIXES
-			"lib"
-			"lib64"
-			"libs"
-			"libs64"
-			"lib/x86_64-linux-gnu"
-	)
-endif()
 
-# Also check if Brotli_common was defined, as it can be passed by the end-user
-if(NOT TARGET PkgConfig::Brotli_common AND NOT Brotli_common)
-	if(BROTLI_USE_STATIC_LIBS)
-		list(APPEND _brotli_common_lib_names
-			"brotlicommon-static"
-			"libbrotlicommon-static"
-		)
-	else()
-		list(APPEND _brotli_common_lib_names
-			"brotlicommon"
-			"libbrotlicommon"
-		)
-	endif()
-	find_library(Brotli_common
-		NAMES ${_brotli_common_lib_names}
-		PATH_SUFFIXES
-			"lib"
-			"lib64"
-			"libs"
-			"libs64"
-			"lib/x86_64-linux-gnu"
-	)
-endif()
+	# Check if the target was already found by Pkgconf 
+	if(TARGET PkgConfig::Brotli_${_component_name} OR TARGET PkgConfig::Brotli_${_component_name}_STATIC)
+		# Can't use generators for ALIAS targets, so you get this jank
+		add_library(Brotli::${_component_name} ALIAS PkgConfig::Brotli_${_component_name}${_brotli_stat_str})
 
-set(_brotli_req_vars "")
-# Generic loop to either create all the aliases for the end-user, or throw errors/warnings.
-# Note that the case here needs to match the case we used elsewhere in this file.
-foreach(_target_name "common" "decoder" "encoder")
-	# The PkgConfig IMPORTED_TARGET has PkgConfig:: prefixed to it.
-	if(TARGET PkgConfig::Brotli_${_target_name})
-		add_library(Brotli::${_target_name} ALIAS PkgConfig::Brotli_${_target_name})
-
-		if(Brotli_FIND_REQUIRED_${_target_name})
-			# The PkgConfig version of the library has a slightly different path to its lib.
+		# Tells HANDLE_COMPONENTS we found the component
+		set(Brotli_${_component_name}_FOUND TRUE)
+		if(Brotli_FIND_REQUIRED_${_component_name})
+			# If the lib is required, we can add its literal path as a required var for FindPackageHandleStandardArgs
+			# Since it won't accept the PkgConfig targets
 			if(BROTLI_USE_STATIC_LIBS)
-				list(APPEND _brotli_req_vars "Brotli_${_target_name}_STATIC_LINK_LIBRARIES")
+				list(APPEND _brotli_req_vars "Brotli_${_component_name}_STATIC_LIBRARIES")
 			else()
-				list(APPEND _brotli_req_vars "Brotli_${_target_name}_LINK_LIBRARIES")
+				list(APPEND _brotli_req_vars "Brotli_${_component_name}_LINK_LIBRARIES")
 			endif()
 		endif()
-	# This will only trigger for libraries we found using find_library
-	elseif(Brotli_${_target_name})
-		add_library("Brotli::${_target_name}" UNKNOWN IMPORTED)
-		# Safety-check the includes dir
-		if(NOT Brotli_INCLUDE_DIR)
-			brotli_err_msg("Failed to find Brotli's includes directory. Try manually defining \"Brotli_INCLUDE_DIR\" to Brotli's header path on your system.")
-		endif()
-		# Attach the literal library and include dir to the IMPORTED target for the end-user
-		set_target_properties("Brotli::${_target_name}" PROPERTIES
-			INTERFACE_INCLUDE_DIRECTORIES "${Brotli_INCLUDE_DIR}"
-			IMPORTED_LOCATION "${Brotli_${_target_name}}"
+
+		# Skip searching for the libs with find_library since it was already found by Pkgconf
+		continue()
+	endif()
+
+	# Lets us know we aren't using the PkgConfig libraries
+	set(_brotli_using_pkgconf FALSE)
+	if(Brotli_FIND_REQUIRED_${_component_name})
+		# If it's required, we can set the name used in find_library as a required var for FindPackageHandleStandardArgs
+		list(APPEND _brotli_req_vars "Brotli_${_component_name}")
+	endif()
+
+	if(BROTLI_USE_STATIC_LIBS)
+		list(APPEND _brotli_lib_names
+			"brotli${_libname}-static"
+			"libbrotli${_libname}-static"
 		)
-		# Attach the library from find_library to our required vars (if it's required)
-		if(Brotli_FIND_REQUIRED_${_target_name})
-			list(APPEND _brotli_req_vars "Brotli_${_target_name}")
-		endif()
-	# This will only happen if it's a required library but we didn't find it.
-	elseif(Brotli_FIND_REQUIRED_${_target_name})
-		# Only bother with an error/failure if they actually required the lib.
-		brotli_err_msg("Failed to find Brotli's ${_target_name} library. Try manually defining \"Brotli_${_target_name}\" to its path on your system.")
+	else()
+		list(APPEND _brotli_lib_names
+			"brotli${_libname}"
+			"libbrotli${_libname}"
+		)
+	endif()
+
+	find_library(Brotli_${_component_name}
+		NAMES ${_brotli_lib_names}
+		HINTS ${BROTLI_ROOT_DIR}
+		PATH_SUFFIXES
+			"lib"
+			"lib64"
+			"libs"
+			"libs64"
+			"lib/x86_64-linux-gnu"
+	)
+	# Hide the library variable from the Cmake GUI
+	mark_as_advanced(Brotli_${_component_name})
+
+	# Unset since otherwise it'll stick around for the next loop and break things
+	unset(_brotli_lib_names)
+
+	# Check if find_library found the library
+	if(Brotli_${_component_name})
+		# Tells HANDLE_COMPONENTS we found the component
+		set(Brotli_${_component_name}_FOUND TRUE)
+
+		add_library("Brotli::${_component_name}" UNKNOWN IMPORTED)
+		# Attach the literal library and include dir to the IMPORTED target for the end-user
+		set_target_properties("Brotli::${_component_name}" PROPERTIES
+			INTERFACE_INCLUDE_DIRECTORIES "${Brotli_INCLUDE_DIR}"
+			IMPORTED_LOCATION "${Brotli_${_component_name}}"
+		)
+	else()
+		# Tells HANDLE_COMPONENTS we found the component
+		set(Brotli_${_component_name}_FOUND FALSE)
 	endif()
 endforeach()
 
 include(FindPackageHandleStandardArgs)
+# Sets Brotli_FOUND, and fails the find_package(Brotli) call if it was REQUIRED but missing libs.
 find_package_handle_standard_args(Brotli
-	FOUND_VAR Brotli_FOUND
-	REQUIRED_VARS ${_brotli_req_vars}
+	FOUND_VAR
+		Brotli_FOUND
+	REQUIRED_VARS
+		Brotli_INCLUDE_DIR
+		${_brotli_required_targets}
+	HANDLE_COMPONENTS
 )
 
-if(Brotli_FOUND)
-	include(FindPackageMessage)
-	foreach(_lib_name ${_brotli_req_vars})
-		# TODO: remove this if/when The Cmake PkgConfig file fixes the non-quiet message about libbrotlicommon being found.
-		if(${_lib_name} MATCHES "common")
-			# This avoids a duplicate "Found Brotli: /usr/lib/libbrotlicommon.so" type message.
-			continue()
-		endif()
-		# Double-expand the var to get the actual path instead of the variable's name.
-		find_package_message(Brotli "Found Brotli: ${${_lib_name}}"
-			"[${${_lib_name}}][${Brotli_INCLUDE_DIR}]"
-		)
-	endforeach()
+# Restore the original find library ordering
+if(BROTLI_USE_STATIC_LIBS)
+  set(CMAKE_FIND_LIBRARY_SUFFIXES ${_brotli_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES})
 endif()

example/Makefile

@@ -1,6 +1,6 @@
 
 #CXX = clang++
-CXXFLAGS = -std=c++14 -I.. -Wall -Wextra -pthread
+CXXFLAGS = -std=c++11 -I.. -Wall -Wextra -pthread
 
 OPENSSL_DIR = /usr/local/opt/openssl
 OPENSSL_SUPPORT = -DCPPHTTPLIB_OPENSSL_SUPPORT -I$(OPENSSL_DIR)/include -L$(OPENSSL_DIR)/lib -lssl -lcrypto

example/client.cc

@@ -23,12 +23,12 @@ int main(void) {
   httplib::Client cli("localhost", 8080);
 #endif
 
-  auto res = cli.Get("/hi");
-  if (res) {
+  if (auto res = cli.Get("/hi")) {
     cout << res->status << endl;
     cout << res->get_header_value("Content-Type") << endl;
     cout << res->body << endl;
   } else {
+    cout << "error code: " << res.error() << std::endl;
 #ifdef CPPHTTPLIB_OPENSSL_SUPPORT
     auto result = cli.get_openssl_verify_result();
     if (result) {

example/simplecli.cc

@@ -8,24 +8,21 @@
 #include <httplib.h>
 #include <iostream>
 
-#define CA_CERT_FILE "./ca-bundle.crt"
-
 using namespace std;
 
 int main(void) {
 #ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  auto res = httplib::Client2("https://localhost:8080")
-    .set_ca_cert_path(CA_CERT_FILE)
-    // .enable_server_certificate_verification(true)
-    .Get("/hi");
+  auto scheme_host_port = "https://localhost:8080";
 #else
-  auto res = httplib::Client2("http://localhost:8080").Get("/hi");
+  auto scheme_host_port = "http://localhost:8080";
 #endif
 
-  if (res) {
+  if (auto res = httplib::Client(scheme_host_port).Get("/hi")) {
     cout << res->status << endl;
     cout << res->get_header_value("Content-Type") << endl;
     cout << res->body << endl;
+  } else {
+    cout << res.error() << endl;
   }
 
   return 0;

example/ssecli.cc

@@ -11,7 +11,7 @@
 using namespace std;
 
 int main(void) {
-  httplib::Client2("http://localhost:1234")
+  httplib::Client("http://localhost:1234")
       .Get("/event1", [&](const char *data, size_t data_length) {
         std::cout << string(data, data_length);
         return true;

test/Makefile

@@ -2,13 +2,13 @@
 #CXX = clang++
 CXXFLAGS = -ggdb -O0 -std=c++11 -DGTEST_USE_OWN_TR1_TUPLE -I.. -I. -Wall -Wextra -Wtype-limits -Wconversion
 
-OPENSSL_DIR = /usr/local/opt/openssl
+OPENSSL_DIR = /usr/local/opt/openssl@1.1
 OPENSSL_SUPPORT = -DCPPHTTPLIB_OPENSSL_SUPPORT -I$(OPENSSL_DIR)/include -L$(OPENSSL_DIR)/lib -lssl -lcrypto
 
 ZLIB_SUPPORT = -DCPPHTTPLIB_ZLIB_SUPPORT -lz
 
 BROTLI_DIR = /usr/local/opt/brotli
-# BROTLI_SUPPORT = -DCPPHTTPLIB_BROTLI_SUPPORT -I$(BROTLI_DIR)/include -L$(BROTLI_DIR)/lib -lbrotlicommon-static -lbrotlienc-static -lbrotlidec-static
+BROTLI_SUPPORT = -DCPPHTTPLIB_BROTLI_SUPPORT -I$(BROTLI_DIR)/include -L$(BROTLI_DIR)/lib -lbrotlicommon -lbrotlienc -lbrotlidec
 
 all : test
 	./test

test/test.vcxproj

@@ -22,7 +22,7 @@
     <ProjectGuid>{6B3E6769-052D-4BC0-9D2C-E9127C3DBB26}</ProjectGuid>
     <Keyword>Win32Proj</Keyword>
     <RootNamespace>test</RootNamespace>
-    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
@@ -97,6 +97,7 @@
       <AdditionalIncludeDirectories>./;../</AdditionalIncludeDirectories>
       <AdditionalUsingDirectories>
       </AdditionalUsingDirectories>
+      <SDLCheck>true</SDLCheck>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -114,6 +115,7 @@
       <AdditionalIncludeDirectories>./;../</AdditionalIncludeDirectories>
       <AdditionalUsingDirectories>
       </AdditionalUsingDirectories>
+      <SDLCheck>true</SDLCheck>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -133,6 +135,7 @@
       <AdditionalIncludeDirectories>./;../</AdditionalIncludeDirectories>
       <AdditionalUsingDirectories>
       </AdditionalUsingDirectories>
+      <SDLCheck>true</SDLCheck>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -154,6 +157,7 @@
       <AdditionalIncludeDirectories>./;../</AdditionalIncludeDirectories>
       <AdditionalUsingDirectories>
       </AdditionalUsingDirectories>
+      <SDLCheck>true</SDLCheck>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -171,4 +175,4 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
-</Project>
+</Project>

test/test_proxy.cc

@@ -5,7 +5,8 @@
 using namespace std;
 using namespace httplib;
 
-void ProxyTest(Client& cli, bool basic) {
+template <typename T>
+void ProxyTest(T& cli, bool basic) {
   cli.set_proxy("localhost", basic ? 3128 : 3129);
   auto res = cli.Get("/get");
   ASSERT_TRUE(res != nullptr);
@@ -36,7 +37,8 @@ TEST(ProxyTest, SSLDigest) {
 
 // ----------------------------------------------------------------------------
 
-void RedirectProxyText(Client& cli, const char *path, bool basic) {
+template <typename T>
+void RedirectProxyText(T& cli, const char *path, bool basic) {
   cli.set_proxy("localhost", basic ? 3128 : 3129);
   if (basic) {
     cli.set_proxy_basic_auth("hello", "world");
@@ -100,7 +102,8 @@ TEST(RedirectTest, YouTubeSSLDigest) {
 
 // ----------------------------------------------------------------------------
 
-void BaseAuthTestFromHTTPWatch(Client& cli) {
+template <typename T>
+void BaseAuthTestFromHTTPWatch(T& cli) {
   cli.set_proxy("localhost", 3128);
   cli.set_proxy_basic_auth("hello", "world");
 
@@ -157,7 +160,8 @@ TEST(BaseAuthTest, SSL) {
 // ----------------------------------------------------------------------------
 
 #ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-void DigestAuthTestFromHTTPWatch(Client& cli) {
+template <typename T>
+void DigestAuthTestFromHTTPWatch(T& cli) {
   cli.set_proxy("localhost", 3129);
   cli.set_proxy_digest_auth("hello", "world");