Fix #1303

* resolve problem: http server can't send file large than 2GB.
add unit test for http server send large file.
add /bigobj compile option to msvc x64.

* disable unit test "ServerLargeContentTest" due to out-of-memory on GitHub Actions.

.gitignore

@@ -13,10 +13,12 @@ example/*.pem
 test/httplib.cc
 test/httplib.h
 test/test
+test/server_fuzzer
 test/test_proxy
 test/test_split
 test/test.xcodeproj/xcuser*
 test/test.xcodeproj/*/xcuser*
+test/*.o
 test/*.pem
 test/*.srl
 

CMakeLists.txt

@@ -60,10 +60,10 @@
 ]]
 cmake_minimum_required(VERSION 3.14.0 FATAL_ERROR)
 
-# Get the user agent and use it as a version
-# This gets the string with the user agent from the header.
+# Get the CPPHTTPLIB_VERSION value and use it as a version
+# This gets the string with the CPPHTTPLIB_VERSION value from the header.
 # This is so the maintainer doesn't actually need to update this manually.
-file(STRINGS httplib.h _raw_version_string REGEX "User\-Agent.*cpp\-httplib/([0-9]+\.?)+")
+file(STRINGS httplib.h _raw_version_string REGEX "CPPHTTPLIB_VERSION \"([0-9]+\\.[0-9]+\\.[0-9]+)\"")
 
 # Needed since git tags have "v" prefixing them.
 # Also used if the fallback to user agent string is being used.
@@ -100,6 +100,7 @@ if (BUILD_SHARED_LIBS AND WIN32 AND HTTPLIB_COMPILE)
 endif()
 
 # Threads needed for <thread> on some systems, and for <pthread.h> on Linux
+set(THREADS_PREFER_PTHREAD_FLAG true)
 find_package(Threads REQUIRED)
 # Since Cmake v3.11, Crypto & SSL became optional when not specified as COMPONENTS.
 if(HTTPLIB_REQUIRE_OPENSSL)
@@ -160,7 +161,7 @@ if(HTTPLIB_COMPILE)
 		ERROR_VARIABLE _httplib_split_error
 	)
 	if(_httplib_split_error)
-		message(FATAL_ERROR "Failed when trying to split Cpp-httplib with the Python script.\n${_httplib_split_error}")
+		message(FATAL_ERROR "Failed when trying to split cpp-httplib with the Python script.\n${_httplib_split_error}")
 	endif()
 
 	# split.py puts output in "out"
@@ -172,6 +173,11 @@ if(HTTPLIB_COMPILE)
 			$<BUILD_INTERFACE:${_httplib_build_includedir}/httplib.h>
 			$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/httplib.h>
 	)
+	set_target_properties(${PROJECT_NAME}
+		PROPERTIES
+			VERSION ${${PROJECT_NAME}_VERSION}
+			SOVERSION ${${PROJECT_NAME}_VERSION_MAJOR}
+	)
 else()
 	# This is for header-only.
 	set(_INTERFACE_OR_PUBLIC INTERFACE)
@@ -182,19 +188,9 @@ endif()
 # Only useful if building in-tree, versus using it from an installation.
 add_library(${PROJECT_NAME}::${PROJECT_NAME} ALIAS ${PROJECT_NAME})
 
-# Might be missing some, but this list is somewhat comprehensive
+# Require C++11
 target_compile_features(${PROJECT_NAME} ${_INTERFACE_OR_PUBLIC}
 	cxx_std_11
-	cxx_nullptr
-	cxx_lambdas
-	cxx_override
-	cxx_defaulted_functions
-	cxx_attribute_deprecated
-	cxx_auto_type
-	cxx_decltype
-	cxx_deleted_functions
-	cxx_range_for
-	cxx_sizeof_member
 )
 
 target_include_directories(${PROJECT_NAME} ${_INTERFACE_OR_PUBLIC}
@@ -269,11 +265,9 @@ endif()
 # and linkage information (doesn't find deps though).
 install(TARGETS ${PROJECT_NAME}
 	EXPORT httplibTargets
-	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
 )
 
-install(FILES "${_httplib_build_includedir}/httplib.h" DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+install(FILES "${_httplib_build_includedir}/httplib.h" TYPE INCLUDE)
 
 install(FILES
 		"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"

README.md

@@ -48,17 +48,12 @@ 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
-
 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.
+NOTE: cpp-httplib currently supports only version 1.1.1 and 3.0.
 
 ```c++
 #define CPPHTTPLIB_OPENSSL_SUPPORT
@@ -183,6 +178,15 @@ The followings are built-in mappings:
 | webm       | video/webm                  | zip        | application/zip             |
 | mp3        | audio/mp3                   | wasm       | application/wasm            |
 
+### File request handler
+
+```cpp
+// The handler is called right before the response is sent to a client
+svr.set_file_request_handler([](const Request &req, Response &res) {
+  ...
+});
+```
+
 NOTE: These static file server methods are not thread-safe.
 
 ### Logging
@@ -303,7 +307,7 @@ Without content length:
 svr.Get("/stream", [&](const Request &req, Response &res) {
   res.set_content_provider(
     "text/plain", // Content type
-    [&](size_t offset, size_t length, DataSink &sink) {
+    [&](size_t offset, DataSink &sink) {
       if (/* there is still data */) {
         std::vector<char> data;
         // prepare data...

example/Dockerfile.hello

@@ -0,0 +1,12 @@
+FROM alpine as builder
+WORKDIR /src/example
+RUN apk add g++ make openssl-dev zlib-dev brotli-dev
+COPY ./httplib.h /src
+COPY ./example/hello.cc /src/example
+COPY ./example/Makefile /src/example
+RUN make hello
+
+FROM alpine
+RUN apk --no-cache add brotli libstdc++
+COPY --from=builder /src/example/hello /bin/hello
+CMD ["/bin/hello"]

example/Makefile

@@ -1,5 +1,5 @@
 #CXX = clang++
-CXXFLAGS = -std=c++11 -I.. -Wall -Wextra -pthread
+CXXFLAGS = -O2 -std=c++11 -I.. -Wall -Wextra -pthread
 
 PREFIX = /usr/local
 #PREFIX = $(shell brew --prefix)

example/hello.cc

@@ -15,5 +15,5 @@ int main(void) {
     res.set_content("Hello World!", "text/plain");
   });
 
-  svr.listen("localhost", 8080);
+  svr.listen("0.0.0.0", 8080);
 }

example/uploader.sh

@@ -0,0 +1,6 @@
+#/usr/bin/env bash
+for i in {1..10000}
+do
+  echo "#### $i ####"
+  curl -X POST -F image_file=@$1 http://localhost:1234/post > /dev/null
+done

meson.build

@@ -19,21 +19,18 @@ project(
 # Check just in case downstream decides to edit the source
 # and add a project version
 version = meson.project_version()
-python = import('python').find_installation('python3')
 if version == 'undefined'
-  # Meson doesn't have regular expressions, but since it is implemented
-  # in python we can be sure we can use it to parse the file manually
-  version = run_command(
-      python, '-c', 'import re; raw_version = re.search("User\-Agent.*cpp\-httplib/([0-9]+\.?)+", open("httplib.h").read()).group(0); print(re.search("([0-9]+\\.?)+", raw_version).group(0))'
-  ).stdout().strip()
+  cxx = meson.get_compiler('cpp')
+  version = cxx.get_define('CPPHTTPLIB_VERSION',
+    prefix: '#include <httplib.h>',
+    include_directories: include_directories('.')).strip('"')
+  assert(version != '', 'failed to get version from httplib.h')
 endif
 
-message('cpp-httplib version ' + version)
-
 deps = [dependency('threads')]
 args = []
 
-openssl_dep = dependency('openssl', version: ['>=1.1.1', '<1.1.2'], required: get_option('cpp-httplib_openssl'))
+openssl_dep = dependency('openssl', version: '>=1.1.1', required: get_option('cpp-httplib_openssl'))
 if openssl_dep.found()
   deps += openssl_dep
   args += '-DCPPHTTPLIB_OPENSSL_SUPPORT'
@@ -64,11 +61,13 @@ endif
 cpp_httplib_dep = dependency('', required: false)
 
 if get_option('cpp-httplib_compile')
+  python3 = find_program('python3')
+
   httplib_ch = custom_target(
     'split',
     input: 'httplib.h',
     output: ['httplib.cc', 'httplib.h'],
-    command: [python, files('split.py'), '--out', meson.current_build_dir()],
+    command: [python3, files('split.py'), '--out', meson.current_build_dir()],
     install: true,
     install_dir: [false, get_option('includedir')]
   )
@@ -92,6 +91,14 @@ if get_option('cpp-httplib_compile')
 else
   install_headers('httplib.h')
   cpp_httplib_dep = declare_dependency(compile_args: args, dependencies: deps, include_directories: include_directories('.'))
+
+  import('pkgconfig').generate(
+    name: 'cpp-httplib',
+    description: 'A C++ HTTP/HTTPS server and client library',
+    install_dir: join_paths(get_option('datadir'), 'pkgconfig'),
+    url: 'https://github.com/yhirose/cpp-httplib',
+    version: version
+  )
 endif
 
 if meson.version().version_compare('>=0.54.0')

meson_options.txt

@@ -5,5 +5,5 @@
 option('cpp-httplib_openssl', type: 'feature', value: 'auto', description: 'Enable OpenSSL support')
 option('cpp-httplib_zlib',    type: 'feature', value: 'auto', description: 'Enable zlib support')
 option('cpp-httplib_brotli',  type: 'feature', value: 'auto', description: 'Enable Brotli support')
-option('cpp-httplib_compile', type: 'boolean', value: false,  description: 'Split the header into a compilable header & source file (requires Python 3)')
+option('cpp-httplib_compile', type: 'boolean', value: false,  description: 'Split the header into a compilable header & source file (requires python3)')
 option('cpp-httplib_test',    type: 'boolean', value: false,  description: 'Build tests')

test/Makefile

@@ -1,5 +1,5 @@
 CXX = clang++
-CXXFLAGS = -g -std=c++11 -I. -Wall -Wextra -Wtype-limits -Wconversion # -fno-exceptions -DCPPHTTPLIB_NO_EXCEPTIONS -fsanitize=address
+CXXFLAGS = -g -std=c++11 -I. -Wall -Wextra -Wtype-limits -Wconversion -Wshadow # -fno-exceptions -DCPPHTTPLIB_NO_EXCEPTIONS -fsanitize=address
 
 PREFIX = /usr/local
 #PREFIX = $(shell brew --prefix)
@@ -65,6 +65,8 @@ cert.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
 	openssl req -new -batch -config test.conf -key client.key.pem | openssl x509 -days 370 -req -CA rootCA.cert.pem -CAkey rootCA.key.pem -CAcreateserial > client.cert.pem
+	openssl genrsa -passout pass:test123! 2048 > key_encrypted.pem
+	openssl req -new -batch -config test.conf -key key_encrypted.pem | openssl x509 -days 3650 -req -signkey key_encrypted.pem > cert_encrypted.pem
 	#c_rehash .
 
 clean:

test/fuzzing/corpus/clusterfuzz-testcase-minimized-server_fuzzer-6508706672541696

@@ -0,0 +1,7 @@
+PUT { HTTP/1.0
+Content-Type:multipart/form-databoundary=m
+Range:bytes=-
+
+--m
+C
+c





































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































Line truncated

test/fuzzing/corpus/issue1264

@@ -0,0 +1,19 @@
+POST /fform%u008ano栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽栽Line truncated
+DondntGnt-Encodin€z-daExpi%20-En�v2PUT@薍TkP/

+Rcn������� ,Cotent-Security-Pz-tes=T損eont.e伒-Typ鑞t-Ty@n/***ww-form-urlenc匱��?aLO%KSi@Fr荰TP/1.0
+Cofffffffffffffffffffffffntemt�
+�
+�
+�
+�
+�
+Content-Length:dent:applica;tion/x-wsw-form%`00368aogrlencod368angrlencoded
+岼J`
+o
+
+8���Content-EncodxNg:deflatePtipfo
+
+8�
␍
+9�2H2											ncod368anPOST # HTTP/1.0␍Content-Encoding:defPOST / HTTP/1.0
+Content-Encoding:PUT { HTTP/1.0
+Content-Type:Range:bytes=-␍multipart/

test/meson.build

@@ -33,6 +33,19 @@ cert2_pem = custom_target(
   command: [openssl, 'req', '-x509', '-config', test_conf, '-key', '@INPUT@', '-sha256', '-days', '3650', '-nodes', '-out', '@OUTPUT@', '-extensions', 'SAN']
 )
 
+key_encrypted_pem = custom_target(
+  'key_encrypted_pem',
+  output: 'key_encrypted.pem',
+  command: [openssl, 'genrsa', '-passout', 'pass:test123!', '-out', '@OUTPUT@', '2048']
+)
+
+cert_encrypted_pem = custom_target(
+  'cert_encrypted_pem',
+  input: key_encrypted_pem,
+  output: 'cert_encrypted.pem',
+  command: [openssl, 'req', '-x509', '-config', test_conf, '-key', '@INPUT@', '-sha256', '-days', '3650', '-nodes', '-out', '@OUTPUT@', '-extensions', 'SAN']
+)
+
 rootca_key_pem = custom_target(
   'rootca_key_pem',
   output: 'rootCA.key.pem',
@@ -87,6 +100,8 @@ test(
     key_pem,
     cert_pem,
     cert2_pem,
+    key_encrypted_pem,
+    cert_encrypted_pem,
     rootca_key_pem,
     rootca_cert_pem,
     client_key_pem,

test/proxy/down.sh

@@ -1 +0,0 @@
-docker-compose down --rmi all

test/proxy/up.sh

@@ -1 +0,0 @@
-docker-compose up -d

test/test.cc

@@ -18,6 +18,9 @@
 #define CLIENT_CA_CERT_DIR "."
 #define CLIENT_CERT_FILE "./client.cert.pem"
 #define CLIENT_PRIVATE_KEY_FILE "./client.key.pem"
+#define SERVER_ENCRYPTED_CERT_FILE "./cert_encrypted.pem"
+#define SERVER_ENCRYPTED_PRIVATE_KEY_FILE "./key_encrypted.pem"
+#define SERVER_ENCRYPTED_PRIVATE_KEY_PASS "test123!"
 
 using namespace std;
 using namespace httplib;
@@ -58,6 +61,14 @@ TEST(StartupTest, WSAStartup) {
 }
 #endif
 
+TEST(DecodeURLTest, PercentCharacter) {
+  EXPECT_EQ(
+      detail::decode_url(
+          R"(descrip=Gastos%20%C3%A1%C3%A9%C3%AD%C3%B3%C3%BA%C3%B1%C3%91%206)",
+          false),
+      R"(descrip=Gastos áéíóúñÑ 6)");
+}
+
 TEST(EncodeQueryParamTest, ParseUnescapedChararactersTest) {
   string unescapedCharacters = "-_.!~*'()";
 
@@ -98,11 +109,11 @@ TEST(SplitTest, ParseQueryString) {
   detail::split(s.c_str(), s.c_str() + s.size(), '&',
                 [&](const char *b, const char *e) {
                   string key, val;
-                  detail::split(b, e, '=', [&](const char *b, const char *e) {
+                  detail::split(b, e, '=', [&](const char *b2, const char *e2) {
                     if (key.empty()) {
-                      key.assign(b, e);
+                      key.assign(b2, e2);
                     } else {
-                      val.assign(b, e);
+                      val.assign(b2, e2);
                     }
                   });
                   dic.emplace(key, val);
@@ -393,6 +404,31 @@ TEST(ChunkedEncodingTest, FromHTTPWatch_Online) {
   EXPECT_EQ(out, res->body);
 }
 
+TEST(HostnameToIPConversionTest, HTTPWatch_Online) {
+  auto host = "www.httpwatch.com";
+
+  auto ip = hosted_at(host);
+  EXPECT_EQ("191.236.16.12", ip);
+
+  std::vector<std::string> addrs;
+  hosted_at(host, addrs);
+  EXPECT_EQ(1u, addrs.size());
+}
+
+#if 0 // It depends on each test environment...
+TEST(HostnameToIPConversionTest, YouTube_Online) {
+  auto host = "www.youtube.com";
+
+  std::vector<std::string> addrs;
+  hosted_at(host, addrs);
+
+  EXPECT_EQ(20u, addrs.size());
+
+  auto it = std::find(addrs.begin(), addrs.end(), "2607:f8b0:4006:809::200e");
+  EXPECT_TRUE(it != addrs.end());
+}
+#endif
+
 TEST(ChunkedEncodingTest, WithContentReceiver_Online) {
   auto host = "www.httpwatch.com";
 
@@ -574,10 +610,11 @@ TEST(ConnectionErrorTest, InvalidPort) {
 
   auto res = cli.Get("/");
   ASSERT_TRUE(!res);
-  EXPECT_EQ(Error::Connection, res.error());
+  EXPECT_TRUE(Error::Connection == res.error() ||
+              Error::ConnectionTimeout == res.error());
 }
 
-TEST(ConnectionErrorTest, Timeout) {
+TEST(ConnectionErrorTest, Timeout_Online) {
   auto host = "google.com";
 
 #ifdef CPPHTTPLIB_OPENSSL_SUPPORT
@@ -589,9 +626,14 @@ TEST(ConnectionErrorTest, Timeout) {
 #endif
   cli.set_connection_timeout(std::chrono::seconds(2));
 
+  // only probe one address type so that the error reason
+  // correlates to the timed-out IPv4, not the unsupported
+  // IPv6 connection attempt
+  cli.set_address_family(AF_INET);
+
   auto res = cli.Get("/");
   ASSERT_TRUE(!res);
-  EXPECT_TRUE(res.error() == Error::Connection);
+  EXPECT_EQ(Error::ConnectionTimeout, res.error());
 }
 
 TEST(CancelTest, NoCancel_Online) {
@@ -1156,6 +1198,17 @@ TEST(BindServerTest, BindAndListenSeparatelySSL) {
 }
 #endif
 
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+TEST(BindServerTest, BindAndListenSeparatelySSLEncryptedKey) {
+  SSLServer svr(SERVER_ENCRYPTED_CERT_FILE, SERVER_ENCRYPTED_PRIVATE_KEY_FILE,
+                nullptr, nullptr, SERVER_ENCRYPTED_PRIVATE_KEY_PASS);
+  int port = svr.bind_to_any_port("0.0.0.0");
+  ASSERT_TRUE(svr.is_valid());
+  ASSERT_TRUE(port > 0);
+  svr.stop();
+}
+#endif
+
 TEST(ErrorHandlerTest, ContentLength) {
   Server svr;
 
@@ -1195,12 +1248,13 @@ TEST(ErrorHandlerTest, ContentLength) {
 TEST(ExceptionHandlerTest, ContentLength) {
   Server svr;
 
-  svr.set_exception_handler(
-      [](const Request & /*req*/, Response &res, std::exception & /*e*/) {
-        res.status = 500;
-        res.set_content("abcdefghijklmnopqrstuvwxyz",
-                        "text/html"); // <= Content-Length still 13
-      });
+  svr.set_exception_handler([](const Request & /*req*/, Response &res,
+                               std::exception &e) {
+    EXPECT_EQ("abc", std::string(e.what()));
+    res.status = 500;
+    res.set_content("abcdefghijklmnopqrstuvwxyz",
+                    "text/html"); // <= Content-Length still 13 at this point
+  });
 
   svr.Get("/hi", [](const Request & /*req*/, Response &res) {
     res.set_content("Hello World!\n", "text/plain");
@@ -1212,15 +1266,28 @@ TEST(ExceptionHandlerTest, ContentLength) {
   // Give GET time to get a few messages.
   std::this_thread::sleep_for(std::chrono::seconds(1));
 
-  {
+  for (size_t i = 0; i < 10; i++) {
     Client cli(HOST, PORT);
 
-    auto res = cli.Get("/hi");
-    ASSERT_TRUE(res);
-    EXPECT_EQ(500, res->status);
-    EXPECT_EQ("text/html", res->get_header_value("Content-Type"));
-    EXPECT_EQ("26", res->get_header_value("Content-Length"));
-    EXPECT_EQ("abcdefghijklmnopqrstuvwxyz", res->body);
+    for (size_t j = 0; j < 100; j++) {
+      auto res = cli.Get("/hi");
+      ASSERT_TRUE(res);
+      EXPECT_EQ(500, res->status);
+      EXPECT_EQ("text/html", res->get_header_value("Content-Type"));
+      EXPECT_EQ("26", res->get_header_value("Content-Length"));
+      EXPECT_EQ("abcdefghijklmnopqrstuvwxyz", res->body);
+    }
+
+    cli.set_keep_alive(true);
+
+    for (size_t j = 0; j < 100; j++) {
+      auto res = cli.Get("/hi");
+      ASSERT_TRUE(res);
+      EXPECT_EQ(500, res->status);
+      EXPECT_EQ("text/html", res->get_header_value("Content-Type"));
+      EXPECT_EQ("26", res->get_header_value("Content-Length"));
+      EXPECT_EQ("abcdefghijklmnopqrstuvwxyz", res->body);
+    }
   }
 
   svr.stop();
@@ -1349,6 +1416,34 @@ TEST(InvalidFormatTest, StatusCode) {
   ASSERT_FALSE(svr.is_running());
 }
 
+TEST(URLFragmentTest, WithFragment) {
+  Server svr;
+
+  svr.Get("/hi", [](const Request &req, Response & /*res*/) {
+    EXPECT_TRUE(req.target == "/hi");
+  });
+
+  auto thread = std::thread([&]() { svr.listen(HOST, PORT); });
+
+  std::this_thread::sleep_for(std::chrono::seconds(1));
+
+  {
+    Client cli(HOST, PORT);
+
+    auto res = cli.Get("/hi#key1=val1=key2=val2");
+    EXPECT_TRUE(res);
+    EXPECT_EQ(200, res->status);
+
+    res = cli.Get("/hi%23key1=val1=key2=val2");
+    EXPECT_TRUE(res);
+    EXPECT_EQ(404, res->status);
+  }
+
+  svr.stop();
+  thread.join();
+  ASSERT_FALSE(svr.is_running());
+}
+
 class ServerTest : public ::testing::Test {
 protected:
   ServerTest()
@@ -1616,6 +1711,11 @@ protected:
                 EXPECT_EQ("0", req.get_header_value("Content-Length"));
                 res.set_content("empty-no-content-type", "text/plain");
               })
+        .Post("/post-large",
+              [&](const Request &req, Response &res) {
+                EXPECT_EQ(req.body, LARGE_DATA);
+                res.set_content(req.body, "text/plain");
+              })
         .Put("/empty-no-content-type",
              [&](const Request &req, Response &res) {
                EXPECT_EQ(req.body, "");
@@ -2021,6 +2121,13 @@ TEST_F(ServerTest, PostEmptyContentWithNoContentType) {
   ASSERT_EQ("empty-no-content-type", res->body);
 }
 
+TEST_F(ServerTest, PostLarge) {
+  auto res = cli_.Post("/post-large", LARGE_DATA, "text/plain");
+  ASSERT_TRUE(res);
+  ASSERT_EQ(200, res->status);
+  EXPECT_EQ(LARGE_DATA, res->body);
+}
+
 TEST_F(ServerTest, PutEmptyContentWithNoContentType) {
   auto res = cli_.Put("/empty-no-content-type");
   ASSERT_TRUE(res);
@@ -2908,8 +3015,8 @@ TEST(GzipDecompressor, ChunkedDecompression) {
     httplib::detail::gzip_compressor compressor;
     bool result = compressor.compress(
         data.data(), data.size(),
-        /*last=*/true, [&](const char *data, size_t size) {
-          compressed_data.insert(compressed_data.size(), data, size);
+        /*last=*/true, [&](const char *compressed_data_chunk, size_t compressed_data_size) {
+          compressed_data.insert(compressed_data.size(), compressed_data_chunk, compressed_data_size);
           return true;
         });
     ASSERT_TRUE(result);
@@ -2928,8 +3035,8 @@ TEST(GzipDecompressor, ChunkedDecompression) {
           std::min(compressed_data.size() - chunk_begin, chunk_size);
       bool result = decompressor.decompress(
           compressed_data.data() + chunk_begin, current_chunk_size,
-          [&](const char *data, size_t size) {
-            decompressed_data.insert(decompressed_data.size(), data, size);
+          [&](const char *decompressed_data_chunk, size_t decompressed_data_chunk_size) {
+            decompressed_data.insert(decompressed_data.size(), decompressed_data_chunk, decompressed_data_chunk_size);
             return true;
           });
       ASSERT_TRUE(result);
@@ -3625,10 +3732,11 @@ TEST(StreamingTest, NoContentLengthStreaming) {
 
   auto get_thread = std::thread([&client]() {
     std::string s;
-    auto res = client.Get("/stream", [&s](const char *data, size_t len) -> bool {
-      s += std::string(data, len);
-      return true;
-    });
+    auto res =
+        client.Get("/stream", [&s](const char *data, size_t len) -> bool {
+          s += std::string(data, len);
+          return true;
+        });
     EXPECT_EQ("aaabbb", s);
   });
 
@@ -3756,6 +3864,36 @@ TEST(KeepAliveTest, ReadTimeout) {
   ASSERT_FALSE(svr.is_running());
 }
 
+TEST(KeepAliveTest, Issue1041) {
+  const auto resourcePath = "/hi";
+
+  Server svr;
+  svr.set_keep_alive_timeout(3);
+
+  svr.Get(resourcePath, [](const httplib::Request &, httplib::Response &res) {
+    res.set_content("Hello World!", "text/plain");
+  });
+
+  auto a2 = std::async(std::launch::async, [&svr] { svr.listen(HOST, PORT); });
+  std::this_thread::sleep_for(std::chrono::milliseconds(200));
+
+  Client cli(HOST, PORT);
+  cli.set_keep_alive(true);
+
+  auto result = cli.Get(resourcePath);
+  ASSERT_TRUE(result);
+  EXPECT_EQ(200, result->status);
+
+  std::this_thread::sleep_for(std::chrono::seconds(5));
+
+  result = cli.Get(resourcePath);
+  ASSERT_TRUE(result);
+  EXPECT_EQ(200, result->status);
+
+  svr.stop();
+  a2.wait();
+}
+
 TEST(ClientProblemDetectionTest, ContentProvider) {
   Server svr;
 
@@ -4230,6 +4368,20 @@ TEST(SSLClientTest, WildcardHostNameMatch_Online) {
   ASSERT_EQ(200, res->status);
 }
 
+#if 0
+TEST(SSLClientTest, SetInterfaceWithINET6) {
+  auto cli = std::make_shared<httplib::Client>("https://httpbin.org");
+  ASSERT_TRUE(cli != nullptr);
+
+  cli->set_address_family(AF_INET6);
+  cli->set_interface("en0");
+
+  auto res = cli->Get("/get");
+  ASSERT_TRUE(res);
+  ASSERT_EQ(200, res->status);
+}
+#endif
+
 TEST(SSLClientServerTest, ClientCertPresent) {
   SSLServer svr(SERVER_CERT_FILE, SERVER_PRIVATE_KEY_FILE, CLIENT_CA_CERT_FILE,
                 CLIENT_CA_CERT_DIR);
@@ -4508,6 +4660,50 @@ TEST(SSLClientServerTest, CustomizeServerSSLCtx) {
 
   t.join();
 }
+
+// Disabled due to the out-of-memory problem on GitHub Actions Workflows
+TEST(SSLClientServerTest, DISABLED_LargeDataTransfer) {
+
+  // prepare large data
+  std::random_device seed_gen;
+  std::mt19937 random(seed_gen());
+  constexpr auto large_size_byte = 2147483648UL + 1048576UL; // 2GiB + 1MiB
+  std::vector<std::uint32_t> binary(large_size_byte / sizeof(std::uint32_t));
+  std::generate(binary.begin(), binary.end(), [&random]() { return random(); });
+
+  // server
+  SSLServer svr(SERVER_CERT_FILE, SERVER_PRIVATE_KEY_FILE);
+  ASSERT_TRUE(svr.is_valid());
+
+  svr.Post("/binary", [&](const Request &req, Response &res) {
+    EXPECT_EQ(large_size_byte, req.body.size());
+    EXPECT_EQ(0, std::memcmp(binary.data(), req.body.data(), large_size_byte));
+    res.set_content(req.body, "application/octet-stream");
+  });
+
+  auto listen_thread = std::thread([&svr]() { svr.listen("localhost", PORT); });
+  while (!svr.is_running()) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(1));
+  }
+
+  // client POST
+  SSLClient cli("localhost", PORT);
+  cli.enable_server_certificate_verification(false);
+  cli.set_read_timeout(std::chrono::seconds(100));
+  cli.set_write_timeout(std::chrono::seconds(100));
+  auto res = cli.Post("/binary", reinterpret_cast<char *>(binary.data()),
+                      large_size_byte, "application/octet-stream");
+
+  // compare
+  EXPECT_EQ(200, res->status);
+  EXPECT_EQ(large_size_byte, res->body.size());
+  EXPECT_EQ(0, std::memcmp(binary.data(), res->body.data(), large_size_byte));
+
+  // cleanup
+  svr.stop();
+  listen_thread.join();
+  ASSERT_FALSE(svr.is_running());
+}
 #endif
 
 #ifdef _WIN32
@@ -4546,6 +4742,40 @@ TEST(SendAPI, SimpleInterface_Online) {
   EXPECT_EQ(301, res->status);
 }
 
+// Disabled due to out-of-memory problem on GitHub Actions
+#ifdef _WIN64
+TEST(ServerLargeContentTest, DISABLED_SendLargeContent) {
+  // allocate content size larger than 2GB in memory
+  const size_t content_size = 2LL * 1024LL * 1024LL * 1024LL + 1LL;
+  char *content = (char *)malloc(content_size);
+  ASSERT_TRUE(content);
+
+  Server svr;
+  svr.Get("/foo", [=](const httplib::Request &req, httplib::Response &resp) {
+    resp.set_content(content, content_size, "application/octet-stream");
+  });
+
+  auto listen_thread = std::thread([&svr]() { svr.listen(HOST, PORT); });
+  while (!svr.is_running()) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(1));
+  }
+
+  // Give GET time to get a few messages.
+  std::this_thread::sleep_for(std::chrono::seconds(1));
+
+  Client cli(HOST, PORT);
+  auto res = cli.Get("/foo");
+  ASSERT_TRUE(res);
+  EXPECT_EQ(200, res->status);
+  EXPECT_EQ(content_size, res->body.length());
+
+  free(content);
+  svr.stop();
+  listen_thread.join();
+  ASSERT_FALSE(svr.is_running());
+}
+#endif
+
 #ifdef CPPHTTPLIB_OPENSSL_SUPPORT
 TEST(YahooRedirectTest2, SimpleInterface_Online) {
   Client cli("http://yahoo.com");
@@ -4681,4 +4911,68 @@ TEST(HttpToHttpsRedirectTest, CertFile) {
   t.join();
   t2.join();
 }
+
+TEST(MultipartFormDataTest, LargeData) {
+  SSLServer svr(SERVER_CERT_FILE, SERVER_PRIVATE_KEY_FILE);
+
+  svr.Post("/post", [&](const Request &req, Response & /*res*/,
+                        const ContentReader &content_reader) {
+    if (req.is_multipart_form_data()) {
+      MultipartFormDataItems files;
+      content_reader(
+          [&](const MultipartFormData &file) {
+            files.push_back(file);
+            return true;
+          },
+          [&](const char *data, size_t data_length) {
+            files.back().content.append(data, data_length);
+            return true;
+          });
+
+      EXPECT_TRUE(std::string(files[0].name) == "document");
+      EXPECT_EQ(size_t(1024 * 1024 * 2), files[0].content.size());
+      EXPECT_TRUE(files[0].filename == "2MB_data");
+      EXPECT_TRUE(files[0].content_type == "application/octet-stream");
+
+      EXPECT_TRUE(files[1].name == "hello");
+      EXPECT_TRUE(files[1].content == "world");
+      EXPECT_TRUE(files[1].filename == "");
+      EXPECT_TRUE(files[1].content_type == "");
+    } else {
+      std::string body;
+      content_reader([&](const char *data, size_t data_length) {
+        body.append(data, data_length);
+        return true;
+      });
+    }
+  });
+
+  auto t = std::thread([&]() { svr.listen("localhost", 8080); });
+  while (!svr.is_running()) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(1));
+  }
+  std::this_thread::sleep_for(std::chrono::seconds(1));
+
+  {
+    std::string data(1024 * 1024 * 2, '.');
+    std::stringstream buffer;
+    buffer << data;
+
+    Client cli("https://localhost:8080");
+    cli.enable_server_certificate_verification(false);
+
+    MultipartFormDataItems items{
+        {"document", buffer.str(), "2MB_data", "application/octet-stream"},
+        {"hello", "world", "", ""},
+    };
+
+    auto res = cli.Post("/post", items);
+    ASSERT_TRUE(res);
+    ASSERT_EQ(200, res->status);
+  }
+
+  svr.stop();
+  t.join();
+}
 #endif
+

test/test.vcxproj

@@ -116,6 +116,7 @@
       <AdditionalUsingDirectories>
       </AdditionalUsingDirectories>
       <SDLCheck>true</SDLCheck>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -158,6 +159,7 @@
       <AdditionalUsingDirectories>
       </AdditionalUsingDirectories>
       <SDLCheck>true</SDLCheck>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>