Add Brotli Cmake support (#584)

Had to create a custom FindBrotli package, as not all users have
PkgConfig installed (which Brotli uses). This file gets installed
alongside httplibConfig.cmake for the end-users convenience.

Set BROTLI_USE_STATIC_LIBS to ON if you want to find the static libs
instead of default shared.

Adds the HTTPLIB_REQUIRE_BROTLI (default off) and HTTPLIB_USE_BROTLI_IF_AVAILABLE
(default on) options, which work in the same manner as the other optional/required
dependency options.

Moved the scattered linking and definitions to a single call.

Updated some documentation about the new options.

Improved the in-tree support by setting the HTTPLIB_IS_USING_XYZ
variables in the main CMakeLists (as well as having them in the
httplibConfig.cmake file).

Fixes #582

.gitignore

@@ -7,7 +7,7 @@ example/simplecli
 example/simplesvr
 example/benchmark
 example/redirect
-example/sse
+example/sse*
 example/upload
 example/*.pem
 test/test

CMakeLists.txt

@@ -1,10 +1,15 @@
 #[[
 	Build options:
+	* BUILD_SHARED_LIBS (default off) builds as a static 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)
 	* HTTPLIB_REQUIRE_ZLIB (default off)
+	* HTTPLIB_USE_BROTLI_IF_AVAILABLE (default on)
+	* HTTPLIB_REQUIRE_BROTLI (default off)
 	* HTTPLIB_COMPILE (default off)
+	* BROTLI_USE_STATIC_LIBS - tells Cmake to use the static Brotli libs (only works if you have them installed).
+	* OPENSSL_USE_STATIC_LIBS - tells Cmake to use the static OpenSSL libs (only works if you have them installed).
 
 	-------------------------------------------------------------------------------
 
@@ -36,10 +41,11 @@
 	* 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_USING_BROTLI - a bool for if Brotli 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_VERSION or 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)?
@@ -50,8 +56,9 @@
 	-------------------------------------------------------------------------------
 
 	FindPython3 requires Cmake v3.12
+	ARCH_INDEPENDENT option of write_basic_package_version_file() requires Cmake v3.14
 ]]
-cmake_minimum_required(VERSION 3.12.0 FATAL_ERROR)
+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
@@ -85,9 +92,16 @@ option(HTTPLIB_REQUIRE_ZLIB "Requires ZLIB to be found & linked, or fails build.
 # 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)
+option(HTTPLIB_USE_ZLIB_IF_AVAILABLE "Uses ZLIB (if available) to enable Zlib 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)
+# Just setting this variable here for people building in-tree
+if(HTTPLIB_COMPILE)
+	set(HTTPLIB_IS_COMPILED TRUE)
+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)
 # 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)
@@ -104,11 +118,33 @@ if(HTTPLIB_REQUIRE_OPENSSL)
 elseif(HTTPLIB_USE_OPENSSL_IF_AVAILABLE)
 	find_package(OpenSSL ${_HTTPLIB_OPENSSL_MIN_VER} COMPONENTS Crypto SSL QUIET)
 endif()
+# Just setting this variable here for people building in-tree
+if(OPENSSL_FOUND)
+	set(HTTPLIB_IS_USING_OPENSSL TRUE)
+endif()
+
 if(HTTPLIB_REQUIRE_ZLIB)
 	find_package(ZLIB REQUIRED)
 elseif(HTTPLIB_USE_ZLIB_IF_AVAILABLE)
 	find_package(ZLIB QUIET)
 endif()
+# Just setting this variable here for people building in-tree
+# FindZLIB doesn't have a ZLIB_FOUND variable, so check the target.
+if(TARGET ZLIB::ZLIB)
+	set(HTTPLIB_IS_USING_ZLIB TRUE)
+endif()
+
+# Adds our cmake folder to the search path for find_package
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+if(HTTPLIB_REQUIRE_BROTLI)
+	find_package(Brotli COMPONENTS encoder decoder common REQUIRED)
+elseif(HTTPLIB_USE_BROTLI_IF_AVAILABLE)
+	find_package(Brotli COMPONENTS encoder decoder common QUIET)
+endif()
+# Just setting this variable here for people building in-tree
+if(Brotli_FOUND)
+	set(HTTPLIB_IS_USING_BROTLI TRUE)
+endif()
 
 # Used for default, common dirs that the end-user can change (if needed)
 # like CMAKE_INSTALL_INCLUDEDIR or CMAKE_INSTALL_DATADIR
@@ -180,33 +216,25 @@ target_include_directories(${PROJECT_NAME} ${_INTERFACE_OR_PUBLIC}
 # Always require threads
 target_link_libraries(${PROJECT_NAME} ${_INTERFACE_OR_PUBLIC}
 		Threads::Threads
+		# Needed for Windows libs on Mingw, as the pragma comment(lib, "xyz") aren't triggered.
+		$<$<PLATFORM_ID:Windows>:ws2_32>
+		$<$<PLATFORM_ID:Windows>:crypt32>
+		$<$<PLATFORM_ID:Windows>:cryptui>
+		# Can't put multiple targets in a single generator expression or it bugs out.
+		$<$<BOOL:${HTTPLIB_IS_USING_BROTLI}>:Brotli::common>
+		$<$<BOOL:${HTTPLIB_IS_USING_BROTLI}>:Brotli::encoder>
+		$<$<BOOL:${HTTPLIB_IS_USING_BROTLI}>:Brotli::decoder>
+		$<$<BOOL:${HTTPLIB_IS_USING_ZLIB}>:ZLIB::ZLIB>
+		$<$<BOOL:${HTTPLIB_IS_USING_OPENSSL}>:OpenSSL::SSL>
+		$<$<BOOL:${HTTPLIB_IS_USING_OPENSSL}>:OpenSSL::Crypto>
 )
 
-# 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()
+# 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">
+)
 
 # 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
@@ -261,6 +289,9 @@ install(FILES "${_httplib_build_includedir}/httplib.h" DESTINATION ${CMAKE_INSTA
 install(FILES
 		"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
 		"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake"
+		# Install it so it can be used later by the httplibConfig.cmake file.
+		# Put it in the same dir as our config file instead of a global path so we don't potentially stomp on other packages.
+		"${CMAKE_CURRENT_SOURCE_DIR}/cmake/FindBrotli.cmake"
 	DESTINATION ${_TARGET_INSTALL_CMAKEDIR}
 )
 

README.md

@@ -243,7 +243,7 @@ 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).
+Please see [Server example](https://github.com/yhirose/cpp-httplib/blob/master/example/ssesvr.cc) and [Client example](https://github.com/yhirose/cpp-httplib/blob/master/example/ssecli.cc).
 
 ### Default thread pool support
 
@@ -287,7 +287,7 @@ Client Example
 
 int main(void)
 {
-  // IMPORTANT: 1st parameter must be a hostname or an IP adress string.
+  // IMPORTANT: 1st parameter must be a hostname or an IP address string.
   httplib::Client cli("localhost", 1234);
 
   auto res = cli.Get("/hi");
@@ -306,20 +306,6 @@ httplib::Headers headers = {
 auto res = cli.Get("/hi", headers);
 ```
 
-### GET with Content Receiver
-
-```c++
-std::string body;
-
-auto res = cli.Get("/large-data",
-  [&](const char *data, size_t data_length) {
-    body.append(data, data_length);
-    return true;
-  });
-
-assert(res->body.empty());
-```
-
 ### POST
 
 ```c++
@@ -390,8 +376,19 @@ cli.set_write_timeout(5, 0); // 5 seconds
 
 ### Receive content with Content receiver
 
+```c++
+std::string body;
+
+auto res = cli.Get("/large-data",
+  [&](const char *data, size_t data_length) {
+    body.append(data, data_length);
+    return true;
+  });
+```
+
 ```cpp
 std::string body;
+
 auto res = cli.Get(
   "/stream", Headers(),
   [&](const Response &response) {
@@ -408,6 +405,7 @@ auto res = cli.Get(
 
 ```cpp
 std::string body = ...;
+
 auto res = cli_.Post(
   "/stream", body.size(),
   [](size_t offset, size_t length, DataSink &sink) {
@@ -531,20 +529,27 @@ cli.set_ca_cert_path("./ca-bundle.crt");
 cli.enable_server_certificate_verification(true);
 ```
 
-Zlib Support
-------------
+Compression
+-----------
 
-'gzip' compression is available with `CPPHTTPLIB_ZLIB_SUPPORT`. `libz` should be linked.
+The server can applie compression to the following MIME type contents:
 
-The server applies gzip compression to the following MIME type contents:
-
-  * all text types
+  * all text types except text/event-stream
   * image/svg+xml
   * application/javascript
   * application/json
   * application/xml
   * application/xhtml+xml
 
+### Zlib Support
+
+'gzip' compression is available with `CPPHTTPLIB_ZLIB_SUPPORT`. `libz` should be linked.
+
+### Brotli Support
+
+Brotli compression is available with `CPPHTTPLIB_BROTLI_SUPPORT`. Necessary libraries should be linked.
+Please see https://github.com/google/brotli for more detail.
+
 ### Compress request body on client
 
 ```c++
@@ -556,7 +561,7 @@ res = cli.Post("/resource/foo", "...", "text/plain");
 
 ```c++
 cli.set_decompress(false);
-res = cli.Get("/resource/foo", {{"Accept-Encoding", "gzip, deflate"}});
+res = cli.Get("/resource/foo", {{"Accept-Encoding", "gzip, deflate, br"}});
 res->body; // Compressed data
 ```
 

cmake/FindBrotli.cmake

@@ -0,0 +1,185 @@
+# A simple FindBrotli package for Cmake's find_package function.
+# Note: This find package doesn't have version support, as the version file doesn't seem to be installed on most systems.
+# 
+# If you want to find the static packages instead of shared (the default), define BROTLI_USE_STATIC_LIBS as TRUE.
+# The targets will have the same names, but it will use the static libs.
+#
+# Valid find_package COMPONENTS names: "decoder", "encoder", and "common"
+#
+# Defines the libraries (if found): Brotli::decoder, Brotli::encoder, Brotli::common
+# and the includes path variable: Brotli_INCLUDE_DIR
+
+function(brotli_err_msg _err_msg)
+	# 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}")
+	elseif(NOT Brotli_FIND_QUIETLY)
+		message(WARNING "${_err_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..
+# 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()
+
+# 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"
+	DOC "The path to Brotli's include directory."
+)
+
+# 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"
+	)
+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"
+		)
+	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()
+
+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.
+			if(BROTLI_USE_STATIC_LIBS)
+				list(APPEND _brotli_req_vars "Brotli_${_target_name}_STATIC_LINK_LIBRARIES")
+			else()
+				list(APPEND _brotli_req_vars "Brotli_${_target_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}}"
+		)
+		# 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.")
+	endif()
+endforeach()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Brotli
+	FOUND_VAR Brotli_FOUND
+	REQUIRED_VARS ${_brotli_req_vars}
+)
+
+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()
+endif()

example/Makefile

@@ -1,42 +1,50 @@
 
 #CXX = clang++
 CXXFLAGS = -std=c++14 -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
+
 ZLIB_SUPPORT = -DCPPHTTPLIB_ZLIB_SUPPORT -lz
 
-all: server client hello simplecli simplesvr upload redirect sse benchmark
+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
+
+all: server client hello simplecli simplesvr upload redirect ssesvr ssecli benchmark
 
 server : server.cc ../httplib.h Makefile
-	$(CXX) -o server $(CXXFLAGS) server.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT)
+	$(CXX) -o server $(CXXFLAGS) server.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT) $(BROTLI_SUPPORT)
 
 client : client.cc ../httplib.h Makefile
-	$(CXX) -o client $(CXXFLAGS) client.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT)
+	$(CXX) -o client $(CXXFLAGS) client.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT) $(BROTLI_SUPPORT)
 
 hello : hello.cc ../httplib.h Makefile
-	$(CXX) -o hello $(CXXFLAGS) hello.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT)
+	$(CXX) -o hello $(CXXFLAGS) hello.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT) $(BROTLI_SUPPORT)
 
 simplecli : simplecli.cc ../httplib.h Makefile
-	$(CXX) -o simplecli $(CXXFLAGS) simplecli.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT)
+	$(CXX) -o simplecli $(CXXFLAGS) simplecli.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT) $(BROTLI_SUPPORT)
 
 simplesvr : simplesvr.cc ../httplib.h Makefile
-	$(CXX) -o simplesvr $(CXXFLAGS) simplesvr.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT)
+	$(CXX) -o simplesvr $(CXXFLAGS) simplesvr.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT) $(BROTLI_SUPPORT)
 
 upload : upload.cc ../httplib.h Makefile
-	$(CXX) -o upload $(CXXFLAGS) upload.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT)
+	$(CXX) -o upload $(CXXFLAGS) upload.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT) $(BROTLI_SUPPORT)
 
 redirect : redirect.cc ../httplib.h Makefile
-	$(CXX) -o redirect $(CXXFLAGS) redirect.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT)
+	$(CXX) -o redirect $(CXXFLAGS) redirect.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT) $(BROTLI_SUPPORT)
 
-sse : sse.cc ../httplib.h Makefile
-	$(CXX) -o sse $(CXXFLAGS) sse.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT)
+ssesvr : ssesvr.cc ../httplib.h Makefile
+	$(CXX) -o ssesvr $(CXXFLAGS) ssesvr.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT) $(BROTLI_SUPPORT)
+
+ssecli : ssecli.cc ../httplib.h Makefile
+	$(CXX) -o ssecli $(CXXFLAGS) ssecli.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT) $(BROTLI_SUPPORT)
 
 benchmark : benchmark.cc ../httplib.h Makefile
-	$(CXX) -o benchmark $(CXXFLAGS) benchmark.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT)
+	$(CXX) -o benchmark $(CXXFLAGS) benchmark.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT) $(BROTLI_SUPPORT)
 
 pem:
 	openssl genrsa 2048 > key.pem
 	openssl req -new -key key.pem | openssl x509 -days 3650 -req -signkey key.pem > cert.pem
 
 clean:
-	rm server client hello simplecli simplesvr upload redirect sse benchmark *.pem
+	rm server client hello simplecli simplesvr upload redirect ssesvr sselci benchmark *.pem

example/simplesvr.cc

@@ -46,7 +46,7 @@ string dump_multipart_files(const MultipartFormDataMap &files) {
     snprintf(buf, sizeof(buf), "content type: %s\n", file.content_type.c_str());
     s += buf;
 
-    snprintf(buf, sizeof(buf), "text length: %lu\n", file.content.size());
+    snprintf(buf, sizeof(buf), "text length: %zu\n", file.content.size());
     s += buf;
 
     s += "----------------\n";

example/ssecli.cc

@@ -0,0 +1,21 @@
+//
+//  ssecli.cc
+//
+//  Copyright (c) 2019 Yuji Hirose. All rights reserved.
+//  MIT License
+//
+
+#include <httplib.h>
+#include <iostream>
+
+using namespace std;
+
+int main(void) {
+  httplib::Client2("http://localhost:1234")
+      .Get("/event1", [&](const char *data, size_t data_length) {
+        std::cout << string(data, data_length);
+        return true;
+      });
+
+  return 0;
+}

example/ssesvr.cc

@@ -79,20 +79,20 @@ 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([&](size_t /*offset*/, DataSink &sink) {
-      ed.wait_event(&sink);
-      return true;
-    });
+    res.set_chunked_content_provider("text/event-stream",
+                                     [&](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([&](size_t /*offset*/, DataSink &sink) {
-      ed.wait_event(&sink);
-      return true;
-    });
+    res.set_chunked_content_provider("text/event-stream",
+                                     [&](size_t /*offset*/, DataSink &sink) {
+                                       ed.wait_event(&sink);
+                                       return true;
+                                     });
   });
 
   thread t([&] {

httplibConfig.cmake.in

@@ -6,6 +6,7 @@
 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_IS_USING_BROTLI @HTTPLIB_IS_USING_BROTLI@)
 set(HTTPLIB_VERSION @PROJECT_VERSION@)
 
 include(CMakeFindDependencyMacro)
@@ -26,6 +27,14 @@ if(@HTTPLIB_IS_USING_ZLIB@)
 	find_dependency(ZLIB REQUIRED)
 endif()
 
+if(@HTTPLIB_IS_USING_BROTLI@)
+	# Needed so we can use our own FindBrotli.cmake in this file.
+	# Note that the FindBrotli.cmake file is installed in the same dir as this file.
+	list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}")
+	set(BROTLI_USE_STATIC_LIBS @BROTLI_USE_STATIC_LIBS@)
+	find_dependency(Brotli COMPONENTS common encoder decoder 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@")

test/Makefile

@@ -1,10 +1,15 @@
 
 #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_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
+
 all : test
 	./test
 
@@ -12,10 +17,10 @@ proxy : test_proxy
 	./test_proxy
 
 test : test.cc ../httplib.h Makefile cert.pem
-	$(CXX) -o test $(CXXFLAGS) test.cc gtest/gtest-all.cc gtest/gtest_main.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT) -pthread
+	$(CXX) -o test $(CXXFLAGS) test.cc gtest/gtest-all.cc gtest/gtest_main.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT) $(BROTLI_SUPPORT) -pthread
 
 test_proxy : test_proxy.cc ../httplib.h Makefile cert.pem
-	$(CXX) -o test_proxy $(CXXFLAGS) test_proxy.cc gtest/gtest-all.cc gtest/gtest_main.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT) -pthread
+	$(CXX) -o test_proxy $(CXXFLAGS) test_proxy.cc gtest/gtest-all.cc gtest/gtest_main.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT) $(BROTLI_SUPPORT) -pthread
 
 cert.pem:
 	openssl genrsa 2048 > key.pem

test/test.cc

@@ -100,7 +100,8 @@ TEST(GetHeaderValueTest, DefaultValue) {
 
 TEST(GetHeaderValueTest, DefaultValueInt) {
   Headers headers = {{"Dummy", "Dummy"}};
-  auto val = detail::get_header_value_uint64(headers, "Content-Length", 100);
+  auto val =
+      detail::get_header_value<uint64_t>(headers, "Content-Length", 0, 100);
   EXPECT_EQ(100ull, val);
 }
 
@@ -112,7 +113,8 @@ TEST(GetHeaderValueTest, RegularValue) {
 
 TEST(GetHeaderValueTest, RegularValueInt) {
   Headers headers = {{"Content-Length", "100"}, {"Dummy", "Dummy"}};
-  auto val = detail::get_header_value_uint64(headers, "Content-Length", 0);
+  auto val =
+      detail::get_header_value<uint64_t>(headers, "Content-Length", 0, 0);
   EXPECT_EQ(100ull, val);
 }
 
@@ -214,6 +216,58 @@ TEST(ParseHeaderValueTest, Range) {
   }
 }
 
+TEST(ParseAcceptEncoding1, AcceptEncoding) {
+  Request req;
+  req.set_header("Accept-Encoding", "gzip");
+
+  Response res;
+  res.set_header("Content-Type", "text/plain");
+
+  auto ret = detail::encoding_type(req, res);
+
+#ifdef CPPHTTPLIB_ZLIB_SUPPORT
+  EXPECT_TRUE(ret == detail::EncodingType::Gzip);
+#else
+  EXPECT_TRUE(ret == detail::EncodingType::None);
+#endif
+}
+
+TEST(ParseAcceptEncoding2, AcceptEncoding) {
+  Request req;
+  req.set_header("Accept-Encoding", "gzip, deflate, br");
+
+  Response res;
+  res.set_header("Content-Type", "text/plain");
+
+  auto ret = detail::encoding_type(req, res);
+
+#ifdef CPPHTTPLIB_BROTLI_SUPPORT
+  EXPECT_TRUE(ret == detail::EncodingType::Brotli);
+#elif CPPHTTPLIB_ZLIB_SUPPORT
+  EXPECT_TRUE(ret == detail::EncodingType::Gzip);
+#else
+  EXPECT_TRUE(ret == detail::EncodingType::None);
+#endif
+}
+
+TEST(ParseAcceptEncoding3, AcceptEncoding) {
+  Request req;
+  req.set_header("Accept-Encoding", "br;q=1.0, gzip;q=0.8, *;q=0.1");
+
+  Response res;
+  res.set_header("Content-Type", "text/plain");
+
+  auto ret = detail::encoding_type(req, res);
+
+#ifdef CPPHTTPLIB_BROTLI_SUPPORT
+  EXPECT_TRUE(ret == detail::EncodingType::Brotli);
+#elif CPPHTTPLIB_ZLIB_SUPPORT
+  EXPECT_TRUE(ret == detail::EncodingType::Gzip);
+#else
+  EXPECT_TRUE(ret == detail::EncodingType::None);
+#endif
+}
+
 TEST(BufferStreamTest, read) {
   detail::BufferStream strm1;
   Stream &strm = strm1;
@@ -394,6 +448,20 @@ TEST(ConnectionErrorTest, InvalidHost) {
   ASSERT_TRUE(res == nullptr);
 }
 
+TEST(ConnectionErrorTest, InvalidHost2) {
+  auto host = "httpbin.org/";
+
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+  httplib::SSLClient cli(host);
+#else
+  httplib::Client cli(host);
+#endif
+  cli.set_connection_timeout(2);
+
+  auto res = cli.Get("/");
+  ASSERT_TRUE(res == nullptr);
+}
+
 TEST(ConnectionErrorTest, InvalidPort) {
   auto host = "localhost";
 
@@ -578,6 +646,7 @@ TEST(DigestAuthTest, FromHTTPWatch) {
 }
 #endif
 
+#if 0
 TEST(AbsoluteRedirectTest, Redirect) {
   auto host = "httpbin.org";
 
@@ -636,6 +705,7 @@ TEST(TooManyRedirectTest, Redirect) {
   auto res = cli.Get("/redirect/21");
   ASSERT_TRUE(res == nullptr);
 }
+#endif
 
 #ifdef CPPHTTPLIB_OPENSSL_SUPPORT
 TEST(YahooRedirectTest, Redirect) {
@@ -651,6 +721,7 @@ TEST(YahooRedirectTest, Redirect) {
   EXPECT_EQ(200, res->status);
 }
 
+#if 0
 TEST(HttpsToHttpRedirectTest, Redirect) {
   httplib::SSLClient cli("httpbin.org");
   cli.set_follow_location(true);
@@ -659,6 +730,7 @@ TEST(HttpsToHttpRedirectTest, Redirect) {
   ASSERT_TRUE(res != nullptr);
   EXPECT_EQ(200, res->status);
 }
+#endif
 
 TEST(RedirectToDifferentPort, Redirect) {
   Server svr8080;
@@ -698,6 +770,16 @@ TEST(RedirectToDifferentPort, Redirect) {
   ASSERT_FALSE(svr8080.is_running());
   ASSERT_FALSE(svr8081.is_running());
 }
+
+TEST(UrlWithSpace, Redirect) {
+  httplib::SSLClient cli("edge.forgecdn.net");
+  cli.set_follow_location(true);
+
+  auto res = cli.Get("/files/2595/310/Neat 1.4-17.jar");
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(200, res->status);
+  EXPECT_EQ(18527, res->get_header_value<uint64_t>("Content-Length"));
+}
 #endif
 
 TEST(Server, BindDualStack) {
@@ -761,6 +843,9 @@ protected:
         svr_(SERVER_CERT_FILE, SERVER_PRIVATE_KEY_FILE)
 #endif
   {
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+    cli_.enable_server_certificate_verification(false);
+#endif
   }
 
   virtual void SetUp() {
@@ -878,7 +963,7 @@ protected:
         .Get("/streamed-chunked",
              [&](const Request & /*req*/, Response &res) {
                res.set_chunked_content_provider(
-                   [](size_t /*offset*/, DataSink &sink) {
+                   "text/plain", [](size_t /*offset*/, DataSink &sink) {
                      EXPECT_TRUE(sink.is_writable());
                      sink.os << "123";
                      sink.os << "456";
@@ -891,6 +976,7 @@ protected:
              [&](const Request & /*req*/, Response &res) {
                auto i = new int(0);
                res.set_chunked_content_provider(
+                   "text/plain",
                    [i](size_t /*offset*/, DataSink &sink) {
                      EXPECT_TRUE(sink.is_writable());
                      switch (*i) {
@@ -907,7 +993,8 @@ protected:
         .Get("/streamed",
              [&](const Request & /*req*/, Response &res) {
                res.set_content_provider(
-                   6, [](size_t offset, size_t /*length*/, DataSink &sink) {
+                   6, "text/plain",
+                   [](size_t offset, size_t /*length*/, DataSink &sink) {
                      sink.os << (offset < 3 ? "a" : "b");
                      return true;
                    });
@@ -916,7 +1003,7 @@ protected:
              [&](const Request & /*req*/, Response &res) {
                auto data = new std::string("abcdefg");
                res.set_content_provider(
-                   data->size(),
+                   data->size(), "text/plain",
                    [data](size_t offset, size_t length, DataSink &sink) {
                      EXPECT_TRUE(sink.is_writable());
                      size_t DATA_CHUNK_SIZE = 4;
@@ -931,7 +1018,7 @@ protected:
         .Get("/streamed-cancel",
              [&](const Request & /*req*/, Response &res) {
                res.set_content_provider(
-                   size_t(-1),
+                   size_t(-1), "text/plain",
                    [](size_t /*offset*/, size_t /*length*/, DataSink &sink) {
                      EXPECT_TRUE(sink.is_writable());
                      sink.os << "data_chunk";
@@ -1137,7 +1224,7 @@ protected:
                 EXPECT_EQ(req.body, "content");
               })
         .Get("/last-request",
-             [&](const Request & req, Response &/*res*/) {
+             [&](const Request &req, Response & /*res*/) {
                EXPECT_EQ("close", req.get_header_value("Connection"));
              })
 #ifdef CPPHTTPLIB_ZLIB_SUPPORT
@@ -2015,6 +2102,25 @@ TEST_F(ServerTest, PutContentWithDeflate) {
   EXPECT_EQ("PUT", res->body);
 }
 
+TEST_F(ServerTest, GetStreamedChunkedWithGzip) {
+  httplib::Headers headers;
+  headers.emplace("Accept-Encoding", "gzip, deflate");
+
+  auto res = cli_.Get("/streamed-chunked", headers);
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(200, res->status);
+  EXPECT_EQ(std::string("123456789"), res->body);
+}
+
+TEST_F(ServerTest, GetStreamedChunkedWithGzip2) {
+  httplib::Headers headers;
+  headers.emplace("Accept-Encoding", "gzip, deflate");
+
+  auto res = cli_.Get("/streamed-chunked2", headers);
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(200, res->status);
+  EXPECT_EQ(std::string("123456789"), res->body);
+}
 #endif
 
 TEST_F(ServerTest, Patch) {
@@ -2315,7 +2421,7 @@ TEST_F(ServerTest, MultipartFormDataGzip) {
 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, nullptr,
+      detail::create_client_socket(HOST, PORT, false, nullptr,
                                    /*timeout_sec=*/5, 0, std::string());
 
   if (client_sock == INVALID_SOCKET) { return false; }
@@ -2506,9 +2612,9 @@ 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, DataSink &sink) {
+    res.set_chunked_content_provider("text/event-stream", [](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);
@@ -2623,6 +2729,9 @@ protected:
         svr_(SERVER_CERT_FILE, SERVER_PRIVATE_KEY_FILE)
 #endif
   {
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+    cli_.enable_server_certificate_verification(false);
+#endif
   }
 
   virtual void SetUp() {
@@ -2700,6 +2809,9 @@ protected:
         svr_(SERVER_CERT_FILE, SERVER_PRIVATE_KEY_FILE)
 #endif
   {
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+    cli_.enable_server_certificate_verification(false);
+#endif
   }
 
   virtual void SetUp() {
@@ -2759,6 +2871,7 @@ TEST(SSLClientTest, ServerCertificateVerification1) {
 TEST(SSLClientTest, ServerCertificateVerification2) {
   SSLClient cli("google.com");
   cli.enable_server_certificate_verification(true);
+  cli.set_ca_cert_path("hello");
   auto res = cli.Get("/");
   ASSERT_TRUE(res == nullptr);
 }
@@ -2815,8 +2928,10 @@ TEST(SSLClientServerTest, ClientCertPresent) {
   std::this_thread::sleep_for(std::chrono::milliseconds(1));
 
   httplib::SSLClient cli(HOST, PORT, CLIENT_CERT_FILE, CLIENT_PRIVATE_KEY_FILE);
-  auto res = cli.Get("/test");
+  cli.enable_server_certificate_verification(false);
   cli.set_connection_timeout(30);
+
+  auto res = cli.Get("/test");
   ASSERT_TRUE(res != nullptr);
   ASSERT_EQ(200, res->status);
 
@@ -2884,8 +2999,10 @@ TEST(SSLClientServerTest, MemoryClientCertPresent) {
   std::this_thread::sleep_for(std::chrono::milliseconds(1));
 
   httplib::SSLClient cli(HOST, PORT, client_cert, client_private_key);
-  auto res = cli.Get("/test");
+  cli.enable_server_certificate_verification(false);
   cli.set_connection_timeout(30);
+
+  auto res = cli.Get("/test");
   ASSERT_TRUE(res != nullptr);
   ASSERT_EQ(200, res->status);
 
@@ -2930,8 +3047,10 @@ TEST(SSLClientServerTest, TrustDirOptional) {
   std::this_thread::sleep_for(std::chrono::milliseconds(1));
 
   httplib::SSLClient cli(HOST, PORT, CLIENT_CERT_FILE, CLIENT_PRIVATE_KEY_FILE);
-  auto res = cli.Get("/test");
+  cli.enable_server_certificate_verification(false);
   cli.set_connection_timeout(30);
+
+  auto res = cli.Get("/test");
   ASSERT_TRUE(res != nullptr);
   ASSERT_EQ(200, res->status);
 
@@ -2983,6 +3102,19 @@ TEST(YahooRedirectTest3, SimpleInterface) {
   EXPECT_EQ(200, res->status);
 }
 
+#ifdef CPPHTTPLIB_BROTLI_SUPPORT
+TEST(DecodeWithChunkedEncoding, BrotliEncoding) {
+  httplib::Client2 cli("https://cdnjs.cloudflare.com");
+  auto res = cli.Get("/ajax/libs/jquery/3.5.1/jquery.js", {{"Accept-Encoding", "brotli"}});
+
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(200, res->status);
+  EXPECT_EQ(287630, res->body.size());
+  EXPECT_EQ("application/javascript; charset=utf-8", res->get_header_value("Content-Type"));
+}
+#endif
+
+#if 0
 TEST(HttpsToHttpRedirectTest2, SimpleInterface) {
   auto res =
       httplib::Client2("https://httpbin.org")
@@ -2993,3 +3125,4 @@ TEST(HttpsToHttpRedirectTest2, SimpleInterface) {
   EXPECT_EQ(200, res->status);
 }
 #endif
+#endif

test/test_proxy.cc

@@ -52,6 +52,7 @@ void RedirectProxyText(Client& cli, const char *path, bool basic) {
   EXPECT_EQ(200, res->status);
 }
 
+#if 0
 TEST(RedirectTest, HTTPBinNoSSLBasic) {
   Client cli("httpbin.org");
   RedirectProxyText(cli, "/redirect/2", true);
@@ -73,6 +74,7 @@ TEST(RedirectTest, HTTPBinSSLDigest) {
   RedirectProxyText(cli, "/redirect/2", false);
 }
 #endif
+#endif
 
 #ifdef CPPHTTPLIB_OPENSSL_SUPPORT
 TEST(RedirectTest, YouTubeNoSSLBasic) {
@@ -260,6 +262,7 @@ void KeepAliveTest(Client& cli, bool basic) {
   }
 }
 
+#if 0
 #ifdef CPPHTTPLIB_OPENSSL_SUPPORT
 TEST(KeepAliveTest, NoSSLWithBasic) {
   Client cli("httpbin.org");
@@ -281,3 +284,4 @@ TEST(KeepAliveTest, SSLWithDigest) {
   KeepAliveTest(cli, false);
 }
 #endif
+#endif