No content check (#823)

* No content check

* unit test for no content

* fixing merge conflict break

* oops during manual merge conflict

.github/workflows/test.yaml

@@ -8,10 +8,34 @@ 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 update && 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: check fuzz test target
+      if: matrix.os == 'ubuntu-latest'
+      run: cd test && make -f Makefile.fuzz_test
+    - name: setup msbuild on windows
+      if: matrix.os == 'windows-latest'
+      uses: microsoft/setup-msbuild@v1.0.2
+    - 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,59 @@ 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!
+It's extremely easy to setup. Just include the **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++
+#define CPPHTTPLIB_OPENSSL_SUPPORT
+#include "path/to/httplib.h"
+
+// HTTP
+httplib::Server svr;
+
+// HTTPS
+httplib::SSLServer 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++
+#define CPPHTTPLIB_OPENSSL_SUPPORT
+#include "path/to/httplib.h"
+
+// HTTP
+httplib::Client cli("http://cpp-httplib-server.yhirose.repl.co");
+
+// HTTPS
+httplib::Client cli("https://cpp-httplib-server.yhirose.repl.co");
+
+auto res = cli.Get("/hi");
+res->status;
+res->body;
+```
+
+### 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>
@@ -90,24 +133,30 @@ svr.set_file_extension_and_mimetype_mapping("hh", "text/x-h");
 
 The followings are built-in mappings:
 
-| Extension |     MIME Type          |
-| :-------- | :--------------------- |
-| txt       | text/plain             |
-| html, htm | text/html              |
-| css       | text/css               |
-| jpeg, jpg | image/jpg              |
-| png       | image/png              |
-| gif       | image/gif              |
-| svg       | image/svg+xml          |
-| ico       | image/x-icon           |
-| json      | application/json       |
-| pdf       | application/pdf        |
-| js        | application/javascript |
-| wasm      | application/wasm       |
-| xml       | application/xml        |
-| xhtml     | application/xhtml+xml  |
+| Extension  |          MIME Type          | Extension  |          MIME Type          |
+| :--------- | :-------------------------- | :--------- | :-------------------------- |
+| css        | text/css                    | mpga       | audio/mpeg                  |
+| csv        | text/csv                    | weba       | audio/webm                  |
+| txt        | text/plain                  | wav        | audio/wave                  |
+| vtt        | text/vtt                    | otf        | font/otf                    |
+| html, htm  | text/html                   | ttf        | font/ttf                    |
+| apng       | image/apng                  | woff       | font/woff                   |
+| avif       | image/avif                  | woff2      | font/woff2                  |
+| bmp        | image/bmp                   | 7z         | application/x-7z-compressed |
+| gif        | image/gif                   | atom       | application/atom+xml        |
+| png        | image/png                   | pdf        | application/pdf             |
+| svg        | image/svg+xml               | mjs, js    | application/javascript      |
+| webp       | image/webp                  | json       | application/json            |
+| ico        | image/x-icon                | rss        | application/rss+xml         |
+| tif        | image/tiff                  | tar        | application/x-tar           |
+| tiff       | image/tiff                  | xhtml, xht | application/xhtml+xml       |
+| jpeg, jpg  | image/jpeg                  | xslt       | application/xslt+xml        |
+| mp4        | video/mp4                   | xml        | application/xml             |
+| mpeg       | video/mpeg                  | gz         | application/gzip            |
+| webm       | video/webm                  | zip        | application/zip             |
+| mp3        | audio/mp3                   | wasm       | application/wasm            |
 
-NOTE: These the static file server methods are not thread safe.
+NOTE: These static file server methods are not thread-safe.
 
 ### Logging
 
@@ -128,6 +177,26 @@ svr.set_error_handler([](const auto& req, auto& res) {
 });
 ```
 
+### Pre routing handler
+
+```cpp
+svr.set_pre_routing_handler([](const auto& req, auto& res) -> bool {
+  if (req.path == "/hello") {
+    res.set_content("world", "text/html");
+    return true; // This request is handled
+  }
+  return false; // Let the router handle this request
+});
+```
+
+### Post routing handler
+
+```cpp
+svr.set_post_routing_handler([](const auto& req, auto& res) {
+  res.set_header("ADDITIONAL_HEADER", "value");
+});
+```
+
 ### 'multipart/form-data' POST data
 
 ```cpp
@@ -141,7 +210,7 @@ svr.Post("/multipart", [&](const auto& req, auto& res) {
 });
 ```
 
-### Receive content with Content receiver
+### Receive content with a content receiver
 
 ```cpp
 svr.Post("/content_receiver",
@@ -168,7 +237,7 @@ svr.Post("/content_receiver",
   });
 ```
 
-### Send content with Content provider
+### Send content with the content provider
 
 ```cpp
 const size_t DATA_CHUNK_SIZE = 4;
@@ -178,6 +247,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,16 +257,36 @@ 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
 svr.Get("/chunked", [&](const Request& req, Response& res) {
   res.set_chunked_content_provider(
+    "text/plain",
     [](size_t offset, DataSink &sink) {
       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.
     }
   );
@@ -205,7 +295,7 @@ svr.Get("/chunked", [&](const Request& req, Response& res) {
 
 ### 'Expect: 100-continue' handler
 
-As default, the server sends `100 Continue` response for `Expect: 100-continue` header.
+By default, the server sends a `100 Continue` response for an `Expect: 100-continue` header.
 
 ```cpp
 // Send a '417 Expectation Failed' response.
@@ -225,6 +315,7 @@ svr.set_expect_100_continue_handler([](const Request &req, Response &res) {
 
 ```cpp
 svr.set_keep_alive_max_count(2); // Default is 5
+svr.set_keep_alive_timeout(10);  // Default is 5
 ```
 
 ### Timeout
@@ -235,7 +326,7 @@ svr.set_write_timeout(5, 0); // 5 seconds
 svr.set_idle_interval(0, 100000); // 100 milliseconds
 ```
 
-### Set maximum payload length for reading request body
+### Set maximum payload length for reading a request body
 
 ```c++
 svr.set_payload_max_length(1024 * 1024 * 512); // 512MB
@@ -247,13 +338,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 +374,8 @@ svr.new_task_queue = [] {
 };
 ```
 
-Client Example
---------------
+Client
+------
 
 ```c++
 #include <httplib.h>
@@ -287,16 +383,51 @@ 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");
+httplib::SSLClient cli("localhost");
+```
+
+### Error code
+
+Here is the list of errors from `Result::error()`.
+
+```c++
+enum Error {
+  Success = 0,
+  Unknown,
+  Connection,
+  BindIPAddress,
+  Read,
+  Write,
+  ExceedRedirectCount,
+  Canceled,
+  SSLConnection,
+  SSLLoadingCerts,
+  SSLServerVerification,
+  UnsupportedMultipartBoundaryChars
+};
+```
+
 ### GET with HTTP headers
 
 ```c++
@@ -305,6 +436,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
 
@@ -374,7 +512,7 @@ cli.set_read_timeout(5, 0); // 5 seconds
 cli.set_write_timeout(5, 0); // 5 seconds
 ```
 
-### Receive content with Content receiver
+### Receive content with a content receiver
 
 ```c++
 std::string body;
@@ -401,12 +539,12 @@ auto res = cli.Get(
   });
 ```
 
-### Send content with Content provider
+### Send content with a content provider
 
 ```cpp
 std::string body = ...;
 
-auto res = cli_.Post(
+auto res = cli.Post(
   "/stream", body.size(),
   [](size_t offset, size_t length, DataSink &sink) {
     sink.write(body.data() + offset, length);
@@ -415,19 +553,33 @@ auto res = cli_.Post(
   "text/plain");
 ```
 
+### Chunked transfer encoding
+
+```cpp
+auto res = cli.Post(
+  "/stream",
+  [](size_t offset, DataSink &sink) {
+    sink.os << "chunked data 1";
+    sink.os << "chunked data 2";
+    sink.os << "chunked data 3";
+    sink.done();
+    return true; // return 'false' if you want to cancel the request.
+  },
+  "text/plain");
+```
+
 ### With Progress Callback
 
 ```cpp
 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 +593,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 +610,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.
@@ -504,7 +662,7 @@ res = cli.Get("/");
 res->status; // 200
 ```
 
-### Use a specitic network interface
+### Use a specific network interface
 
 NOTE: This feature is not available on Windows, yet.
 
@@ -512,27 +670,10 @@ NOTE: This feature is not available on Windows, yet.
 cli.set_interface("eth0"); // Interface name, IP address or host name
 ```
 
-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).
-
-```c++
-#define CPPHTTPLIB_OPENSSL_SUPPORT
-
-SSLServer svr("./cert.pem", "./key.pem");
-
-SSLClient cli("localhost", 8080);
-cli.set_ca_cert_path("./ca-bundle.crt");
-cli.enable_server_certificate_verification(true);
-```
-
 Compression
 -----------
 
-The server can applie compression to the following MIME type contents:
+The server can apply compression to the following MIME type contents:
 
   * all text types except text/event-stream
   * image/svg+xml
@@ -565,6 +706,32 @@ res = cli.Get("/resource/foo", {{"Accept-Encoding", "gzip, deflate, br"}});
 res->body; // Compressed data
 ```
 
+SSL Support
+-----------
+
+SSL support is available with `CPPHTTPLIB_OPENSSL_SUPPORT`. `libssl` and `libcrypto` should be linked.
+
+NOTE: cpp-httplib currently supports only version 1.1.1.
+
+```c++
+#define CPPHTTPLIB_OPENSSL_SUPPORT
+#include "path/to/httplib.h"
+
+// Server
+httplib::SSLServer svr("./cert.pem", "./key.pem");
+
+// Client
+httplib::Client cli("https://localhost:1234");
+
+// Use your CA bundle
+cli.set_ca_cert_path("./ca-bundle.crt");
+
+// Disable cert verification
+cli.enable_server_certificate_verification(false);
+```
+
+Note: When using SSL, it seems impossible to avoid SIGPIPE in all cases, since on some operating systems, SIGPIPE can only be suppressed on a per-message basis, but there is no way to make the OpenSSL library do so for its internal communications. If your program needs to avoid being terminated on SIGPIPE, the only fully general way might be to set up a signal handler for SIGPIPE to handle or ignore it yourself.
+
 Split httplib.h into .h and .cc
 -------------------------------
 
@@ -596,7 +763,7 @@ Include `httplib.h` before `Windows.h` or include `Windows.h` by defining `WIN32
 #include <httplib.h>
 ```
 
-Note: Cygwin on Windows is not supported.
+Note: Windows 8 or lower and Cygwin on Windows are not supported.
 
 License
 -------

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

@@ -1,14 +1,13 @@
-
 #CXX = clang++
-CXXFLAGS = -ggdb -O0 -std=c++11 -DGTEST_USE_OWN_TR1_TUPLE -I.. -I. -Wall -Wextra -Wtype-limits -Wconversion
+CXXFLAGS = -g -std=c++11 -DGTEST_USE_OWN_TR1_TUPLE -I.. -I. -Wall -Wextra -Wtype-limits -Wconversion #-fsanitize=address
 
-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
@@ -25,6 +24,7 @@ test_proxy : test_proxy.cc ../httplib.h Makefile cert.pem
 cert.pem:
 	openssl genrsa 2048 > key.pem
 	openssl req -new -batch -config test.conf -key key.pem | openssl x509 -days 3650 -req -signkey key.pem > cert.pem
+	openssl req -x509 -config test.conf -key key.pem -sha256 -days 3650 -nodes -out cert2.pem -extensions SAN
 	openssl genrsa 2048 > rootCA.key.pem
 	openssl req -x509 -new -batch -config test.rootCA.conf -key rootCA.key.pem -days 1024 > rootCA.cert.pem
 	openssl genrsa 2048 > client.key.pem

test/Makefile.fuzz_test

@@ -0,0 +1,36 @@
+
+#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@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 -lbrotlienc -lbrotlidec
+
+# By default, use standalone_fuzz_target_runner.
+# This runner does no fuzzing, but simply executes the inputs
+# provided via parameters.
+# Run e.g. "make all LIB_FUZZING_ENGINE=/path/to/libFuzzer.a"
+# to link the fuzzer(s) against a real fuzzing engine.
+# OSS-Fuzz will define its own value for LIB_FUZZING_ENGINE.
+LIB_FUZZING_ENGINE ?= standalone_fuzz_target_runner.o
+
+# Runs server_fuzzer.cc based on value of $(LIB_FUZZING_ENGINE).
+# Usage: make fuzz_test LIB_FUZZING_ENGINE=/path/to/libFuzzer
+all fuzz_test: server_fuzzer
+	./server_fuzzer fuzzing/corpus/*
+
+# Fuzz target, so that you can choose which $(LIB_FUZZING_ENGINE) to use.
+server_fuzzer : fuzzing/server_fuzzer.cc ../httplib.h standalone_fuzz_target_runner.o
+	$(CXX) $(CXXFLAGS) -o $@  $< $(OPENSSL_SUPPORT)  $(ZLIB_SUPPORT) $(BROTLI_SUPPORT) $(LIB_FUZZING_ENGINE) -pthread
+
+# Standalone fuzz runner, which just reads inputs from fuzzing/corpus/ dir and
+# feeds it to server_fuzzer.
+standalone_fuzz_target_runner.o : fuzzing/standalone_fuzz_target_runner.cpp
+	$(CXX) $(CXXFLAGS) -c -o $@ $<
+
+clean:
+	rm -f server_fuzzer pem *.0 *.o *.1 *.srl *.zip

test/fuzzing/Makefile

@@ -0,0 +1,27 @@
+
+#CXX = clang++
+# Do not add default sanitizer flags here as OSS-fuzz adds its own sanitizer flags.
+CXXFLAGS += -ggdb -O0 -std=c++11 -DGTEST_USE_OWN_TR1_TUPLE -I../.. -I. -Wall -Wextra -Wtype-limits -Wconversion
+
+OPENSSL_DIR = /usr/local/opt/openssl@1.1
+
+# Using full path to libssl and libcrypto to avoid accidentally picking openssl libs brought in by msan.
+OPENSSL_SUPPORT = -DCPPHTTPLIB_OPENSSL_SUPPORT -I$(OPENSSL_DIR)/include -I$(OPENSSL_DIR)/lib  /usr/local/lib/libssl.a /usr/local/lib/libcrypto.a
+
+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 -lbrotlienc -lbrotlidec
+
+# Runs all the tests and also fuzz tests against seed corpus.
+all : server_fuzzer
+	./server_fuzzer corpus/*
+
+# Fuzz target, so that you can choose which $(LIB_FUZZING_ENGINE) to use.
+server_fuzzer : server_fuzzer.cc ../../httplib.h
+# 	$(CXX) $(CXXFLAGS) -o $@  $<  -Wl,-Bstatic $(OPENSSL_SUPPORT)  -Wl,-Bdynamic -ldl  $(ZLIB_SUPPORT)  $(LIB_FUZZING_ENGINE) -pthread
+	$(CXX) $(CXXFLAGS) -o $@  $<  $(ZLIB_SUPPORT)  $(LIB_FUZZING_ENGINE) -pthread
+	zip -q -r server_fuzzer_seed_corpus.zip corpus
+
+clean:
+	rm -f server_fuzzer pem *.0 *.o *.1 *.srl *.zip

test/fuzzing/corpus/1

@@ -0,0 +1 @@
+PUT /search/sample?a=12 HTTP/1.1

test/fuzzing/corpus/2

@@ -0,0 +1,5 @@
+GET /hello.htm HTTP/1.1
+User-Agent: Mozilla/4.0 (compatible; MSIE5.01; Windows NT)
+Accept-Language: en-us
+Accept-Encoding: gzip, deflate
+Connection: Keep-Alive

test/fuzzing/server_fuzzer.cc

@@ -0,0 +1,88 @@
+#include <httplib.h>
+#include <memory>
+
+class FuzzedStream : public httplib::Stream {
+public:
+  FuzzedStream(const uint8_t *data, size_t size)
+      : data_(data), size_(size), read_pos_(0) {}
+
+  ssize_t read(char *ptr, size_t size) override {
+    if (size + read_pos_ > size_) { size = size_ - read_pos_; }
+    memcpy(ptr, data_ + read_pos_, size);
+    read_pos_ += size;
+    return static_cast<ssize_t>(size);
+  }
+
+  ssize_t write(const char *ptr, size_t size) override {
+    response_.append(ptr, size);
+    return static_cast<int>(size);
+  }
+
+  ssize_t write(const char *ptr) { return write(ptr, strlen(ptr)); }
+
+  ssize_t write(const std::string &s) { return write(s.data(), s.size()); }
+
+  std::string get_remote_addr() const { return ""; }
+
+  bool is_readable() const override { return true; }
+
+  bool is_writable() const override { return true; }
+
+  void get_remote_ip_and_port(std::string &ip, int &port) const override {
+    ip = "127.0.0.1";
+    port = 8080;
+  }
+
+  socket_t socket() const override { return 0; }
+
+private:
+  const uint8_t *data_;
+  size_t size_;
+  size_t read_pos_;
+  std::string response_;
+};
+
+class FuzzableServer : public httplib::Server {
+public:
+  void ProcessFuzzedRequest(FuzzedStream &stream) {
+    bool connection_close = false;
+    process_request(stream, /*last_connection=*/false, connection_close,
+                    nullptr);
+  }
+};
+
+static FuzzableServer g_server;
+
+extern "C" int LLVMFuzzerInitialize(int * /*argc*/, char *** /*argv*/) {
+  g_server.Get(R"(.*)",
+               [&](const httplib::Request & /*req*/, httplib::Response &res) {
+                 res.set_content("response content", "text/plain");
+               });
+  g_server.Post(R"(.*)",
+                [&](const httplib::Request & /*req*/, httplib::Response &res) {
+                  res.set_content("response content", "text/plain");
+                });
+  g_server.Put(R"(.*)",
+               [&](const httplib::Request & /*req*/, httplib::Response &res) {
+                 res.set_content("response content", "text/plain");
+               });
+  g_server.Patch(R"(.*)",
+                 [&](const httplib::Request & /*req*/, httplib::Response &res) {
+                   res.set_content("response content", "text/plain");
+                 });
+  g_server.Delete(
+      R"(.*)", [&](const httplib::Request & /*req*/, httplib::Response &res) {
+        res.set_content("response content", "text/plain");
+      });
+  g_server.Options(
+      R"(.*)", [&](const httplib::Request & /*req*/, httplib::Response &res) {
+        res.set_content("response content", "text/plain");
+      });
+  return 0;
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  FuzzedStream stream{data, size};
+  g_server.ProcessFuzzedRequest(stream);
+  return 0;
+}

test/fuzzing/server_fuzzer.dict

@@ -0,0 +1,224 @@
+# Sources: https://en.wikipedia.org/wiki/List_of_HTTP_header_fields
+
+# misc
+"HTTP/1.1"
+
+# verbs
+"CONNECT"
+"DELETE"
+"GET"
+"HEAD"
+"OPTIONS"
+"PATCH"
+"POST"
+"PUT"
+"TRACE"
+
+
+# Webdav/caldav verbs
+"ACL"
+"BASELINE-CONTROL"
+"BIND"
+"CHECKIN"
+"CHECKOUT"
+"COPY"
+"LABEL"
+"LINK"
+"LOCK"
+"MERGE"
+"MKACTIVITY"
+"MKCALENDAR"
+"MKCOL"
+"MKREDIRECTREF"
+"MKWORKSPACE"
+"MOVE"
+"ORDERPATCH"
+"PRI"
+"PROPFIND"
+"PROPPATCH"
+"REBIND"
+"REPORT"
+"SEARCH"
+"UNBIND"
+"UNCHECKOUT"
+"UNLINK"
+"UNLOCK"
+"UPDATE"
+"UPDATEREDIRECTREF"
+"VERSION-CONTROL"
+
+
+# Fields
+"A-IM"
+"Accept"
+"Accept-Charset"
+"Accept-Datetime"
+"Accept-Encoding"
+"Accept-Language"
+"Accept-Patch"
+"Accept-Ranges"
+"Access-Control-Allow-Credentials"
+"Access-Control-Allow-Headers"
+"Access-Control-Allow-Methods"
+"Access-Control-Allow-Origin"
+"Access-Control-Expose-Headers"
+"Access-Control-Max-Age"
+"Access-Control-Request-Headers"
+"Access-Control-Request-Method"
+"Age"
+"Allow"
+"Alt-Svc"
+"Authorization"
+"Cache-Control"
+"Connection"
+"Connection:"
+"Content-Disposition"
+"Content-Encoding"
+"Content-Language"
+"Content-Length"
+"Content-Location"
+"Content-MD5"
+"Content-Range"
+"Content-Security-Policy"
+"Content-Type"
+"Cookie"
+"DNT"
+"Date"
+"Delta-Base"
+"ETag"
+"Expect"
+"Expires"
+"Forwarded"
+"From"
+"Front-End-Https"
+"HTTP2-Settings"
+"Host"
+"IM"
+"If-Match"
+"If-Modified-Since"
+"If-None-Match"
+"If-Range"
+"If-Unmodified-Since"
+"Last-Modified"
+"Link"
+"Location"
+"Max-Forwards"
+"Origin"
+"P3P"
+"Pragma"
+"Proxy-Authenticate"
+"Proxy-Authorization"
+"Proxy-Connection"
+"Public-Key-Pins"
+"Range"
+"Referer"
+"Refresh"
+"Retry-After"
+"Save-Data"
+"Server"
+"Set-Cookie"
+"Status"
+"Strict-Transport-Security"
+"TE"
+"Timing-Allow-Origin"
+"Tk"
+"Trailer"
+"Transfer-Encoding"
+"Upgrade"
+"Upgrade-Insecure-Requests"
+"User-Agent"
+"Vary"
+"Via"
+"WWW-Authenticate"
+"Warning"
+"X-ATT-DeviceId"
+"X-Content-Duration"
+"X-Content-Security-Policy"
+"X-Content-Type-Options"
+"X-Correlation-ID"
+"X-Csrf-Token"
+"X-Forwarded-For"
+"X-Forwarded-Host"
+"X-Forwarded-Proto"
+"X-Frame-Options"
+"X-Http-Method-Override"
+"X-Powered-By"
+"X-Request-ID"
+"X-Requested-With"
+"X-UA-Compatible"
+"X-UIDH"
+"X-Wap-Profile"
+"X-WebKit-CSP"
+"X-XSS-Protection"
+
+# Source: string and character literals in httplib.h
+" "
+"&"
+", "
+"-"
+"--"
+"."
+".."
+":"
+"="
+" = = "
+"0123456789abcdef"
+"%02X"
+"%0A"
+"\\x0a\\x0d"
+"%0D"
+"%20"
+"%27"
+"%2B"
+"%2C"
+"%3A"
+"%3B"
+"application/javascript"
+"application/json"
+"application/pdf"
+"application/xhtml+xml"
+"application/xml"
+"application/x-www-form-urlencoded"
+"Bad Request"
+"boundary="
+"bytes="
+"chunked"
+"close"
+"CONNECT"
+"css"
+"Forbidden"
+"Found"
+"gif"
+"gzip"
+"html"
+"ico"
+"image/gif"
+"image/jpg"
+"image/png"
+"image/svg+xml"
+"image/x-icon"
+"index.html"
+"Internal Server Error"
+"jpeg"
+"js"
+"json"
+"Location"
+"Moved Permanently"
+"multipart/form-data"
+"Not Found"
+"Not Modified"
+"OK"
+"pdf"
+"png"
+"Range"
+"REMOTE_ADDR"
+"See Other"
+"svg"
+"text/"
+"text/css"
+"text/html"
+"text/plain"
+"txt"
+"Unsupported Media Type"
+"xhtml"
+"xml"

test/fuzzing/standalone_fuzz_target_runner.cpp

@@ -0,0 +1,35 @@
+// Copyright 2017 Google Inc. All Rights Reserved.
+// Licensed under the Apache License, Version 2.0 (the "License");
+
+// This runner does not do any fuzzing, but allows us to run the fuzz target
+// on the test corpus or on a single file,
+// e.g. the one that comes from a bug report.
+
+#include <cassert>
+#include <iostream>
+#include <fstream>
+#include <vector>
+
+// Forward declare the "fuzz target" interface.
+// We deliberately keep this inteface simple and header-free.
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);
+
+// It reads all files passed as parameters and feeds their contents
+// one by one into the fuzz target (LLVMFuzzerTestOneInput).
+int main(int argc, char **argv) {
+  for (int i = 1; i < argc; i++) {
+    std::ifstream in(argv[i]);
+    in.seekg(0, in.end);
+    size_t length = in.tellg();
+    in.seekg (0, in.beg);
+    std::cout << "Reading " << length << " bytes from " << argv[i] << std::endl;
+    // Allocate exactly length bytes so that we reliably catch buffer overflows.
+    std::vector<char> bytes(length);
+    in.read(bytes.data(), bytes.size());
+    LLVMFuzzerTestOneInput(reinterpret_cast<const uint8_t *>(bytes.data()),
+                           bytes.size());
+    std::cout << "Execution successful" << std::endl;
+  }
+  std::cout << "Execution finished" << std::endl;
+  return 0;
+}

test/gtest/gtest-all.cc

@@ -42,8 +42,9 @@
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wsign-conversion"
 #elif __GNUC__
-#pragma gcc diagnostic push
-#pragma gcc diagnostic ignored "-Wsign-conversion"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#pragma GCC diagnostic ignored "-Wconversion"
 #endif
 
 // The following lines pull in the real gtest *.cc files.
@@ -9127,5 +9128,5 @@ const char* TypedTestCasePState::VerifyRegisteredTestNames(
 #if __clang__
 #pragma clang diagnostic pop
 #elif __GNUC__
-#pragma gcc diagnostic pop
+#pragma GCC diagnostic pop
 #endif

test/gtest/gtest.h

@@ -63,8 +63,9 @@
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wsign-compare"
 #elif __GNUC__
-#pragma gcc diagnostic push
-#pragma gcc diagnostic ignored "-Wsign-compare"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-compare"
+#pragma GCC diagnostic ignored "-Wconversion"
 #endif
 
 // Copyright 2005, Google Inc.
@@ -18353,8 +18354,8 @@ AssertionResult CmpHelperEQ(const char* expected_expression,
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wsign-compare"
 #elif __GNUC__
-#pragma gcc diagnostic push
-#pragma gcc diagnostic ignored "-Wsign-compare"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-compare"
 #endif
 
   if (expected == actual) {
@@ -18366,7 +18367,7 @@ AssertionResult CmpHelperEQ(const char* expected_expression,
 #elif __clang__
 #pragma clang diagnostic pop
 #elif __GNUC__
-#pragma gcc diagnostic pop
+#pragma GCC diagnostic pop
 #endif
 
   return EqFailure(expected_expression,
@@ -19564,7 +19565,7 @@ bool StaticAssertTypeEq() {
 #if __clang__
 #pragma clang diagnostic pop
 #elif __GNUC__
-#pragma gcc diagnostic pop
+#pragma GCC diagnostic pop
 #endif
 
 #endif  // GTEST_INCLUDE_GTEST_GTEST_H_

test/test.conf

@@ -16,3 +16,6 @@ emailAddress           = test@email.address
 
 [req_attributes]
 challengePassword              = 1234
+
+[SAN]
+subjectAltName=IP:127.0.0.1

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,38 +5,40 @@
 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");
+  auto res = cli.Get("/httpbin/get");
   ASSERT_TRUE(res != nullptr);
   EXPECT_EQ(407, res->status);
 }
 
 TEST(ProxyTest, NoSSLBasic) {
-  Client cli("httpbin.org");
+  Client cli("nghttp2.org");
   ProxyTest(cli, true);
 }
 
 #ifdef CPPHTTPLIB_OPENSSL_SUPPORT
 TEST(ProxyTest, SSLBasic) {
-  SSLClient cli("httpbin.org");
+  SSLClient cli("nghttp2.org");
   ProxyTest(cli, true);
 }
 
 TEST(ProxyTest, NoSSLDigest) {
-  Client cli("httpbin.org");
+  Client cli("nghttp2.org");
   ProxyTest(cli, false);
 }
 
 TEST(ProxyTest, SSLDigest) {
-  SSLClient cli("httpbin.org");
+  SSLClient cli("nghttp2.org");
   ProxyTest(cli, false);
 }
 #endif
 
 // ----------------------------------------------------------------------------
 
-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");
@@ -52,29 +54,27 @@ 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);
+  Client cli("nghttp2.org");
+  RedirectProxyText(cli, "/httpbin/redirect/2", true);
 }
 
 #ifdef CPPHTTPLIB_OPENSSL_SUPPORT
 TEST(RedirectTest, HTTPBinNoSSLDigest) {
-  Client cli("httpbin.org");
-  RedirectProxyText(cli, "/redirect/2", false);
+  Client cli("nghttp2.org");
+  RedirectProxyText(cli, "/httpbin/redirect/2", false);
 }
 
 TEST(RedirectTest, HTTPBinSSLBasic) {
-  SSLClient cli("httpbin.org");
-  RedirectProxyText(cli, "/redirect/2", true);
+  SSLClient cli("nghttp2.org");
+  RedirectProxyText(cli, "/httpbin/redirect/2", true);
 }
 
 TEST(RedirectTest, HTTPBinSSLDigest) {
-  SSLClient cli("httpbin.org");
-  RedirectProxyText(cli, "/redirect/2", false);
+  SSLClient cli("nghttp2.org");
+  RedirectProxyText(cli, "/httpbin/redirect/2", false);
 }
 #endif
-#endif
 
 #ifdef CPPHTTPLIB_OPENSSL_SUPPORT
 TEST(RedirectTest, YouTubeNoSSLBasic) {
@@ -100,7 +100,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 +158,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");
 
@@ -214,7 +216,8 @@ TEST(DigestAuthTest, NoSSL) {
 
 // ----------------------------------------------------------------------------
 
-void KeepAliveTest(Client& cli, bool basic) {
+template <typename T>
+void KeepAliveTest(T& cli, bool basic) {
   cli.set_proxy("localhost", basic ? 3128 : 3129);
   if (basic) {
     cli.set_proxy_basic_auth("hello", "world");
@@ -230,20 +233,20 @@ void KeepAliveTest(Client& cli, bool basic) {
 #endif
 
   {
-    auto res = cli.Get("/get");
+    auto res = cli.Get("/httpbin/get");
     EXPECT_EQ(200, res->status);
   }
   {
-    auto res = cli.Get("/redirect/2");
+    auto res = cli.Get("/httpbin/redirect/2");
     EXPECT_EQ(200, res->status);
   }
 
   {
     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",
+        "/httpbin/digest-auth/auth/hello/world/MD5",
+        "/httpbin/digest-auth/auth/hello/world/SHA-256",
+        "/httpbin/digest-auth/auth/hello/world/SHA-512",
+        "/httpbin/digest-auth/auth-int/hello/world/MD5",
     };
 
     for (auto path: paths) {
@@ -254,34 +257,32 @@ void KeepAliveTest(Client& cli, bool basic) {
   }
 
   {
-    int count = 100;
+    int count = 10;
     while (count--) {
-      auto res = cli.Get("/get");
+      auto res = cli.Get("/httpbin/get");
       EXPECT_EQ(200, res->status);
     }
   }
 }
 
-#if 0
 #ifdef CPPHTTPLIB_OPENSSL_SUPPORT
 TEST(KeepAliveTest, NoSSLWithBasic) {
-  Client cli("httpbin.org");
+  Client cli("nghttp2.org");
   KeepAliveTest(cli, true);
 }
 
 TEST(KeepAliveTest, SSLWithBasic) {
-  SSLClient cli("httpbin.org");
+  SSLClient cli("nghttp2.org");
   KeepAliveTest(cli, true);
 }
 
 TEST(KeepAliveTest, NoSSLWithDigest) {
-  Client cli("httpbin.org");
+  Client cli("nghttp2.org");
   KeepAliveTest(cli, false);
 }
 
 TEST(KeepAliveTest, SSLWithDigest) {
-  SSLClient cli("httpbin.org");
+  SSLClient cli("nghttp2.org");
   KeepAliveTest(cli, false);
 }
 #endif
-#endif