Improve multipart content reader interface

Content receiver support for multipart content (Fix #241)

README.md

@@ -50,7 +50,16 @@ svr.listen_after_bind();
 ### Static File Server
 
 ```cpp
-svr.set_base_dir("./www");
+svr.set_base_dir("./www"); // This is same as `svr.set_base_dir("./www", "/")`;
+```
+
+```cpp
+svr.set_base_dir("./www", "/public");
+```
+
+```cpp
+svr.set_base_dir("./www1", "/public"); // 1st order
+svr.set_base_dir("./www2", "/public"); // 2nd order
 ```
 
 ### Logging
@@ -81,12 +90,12 @@ svr.Post("/multipart", [&](const auto& req, auto& res) {
     const auto& file = req.get_file_value("name1");
     // file.filename;
     // file.content_type;
-    auto body = req.body.substr(file.offset, file.length);
+    // file.content;
 });
 
 ```
 
-### Stream content with Content provider
+### Send content with Content provider
 
 ```cpp
 const uint64_t DATA_CHUNK_SIZE = 4;
@@ -96,23 +105,51 @@ svr.Get("/stream", [&](const Request &req, Response &res) {
 
   res.set_content_provider(
     data->size(), // Content length
-    [data](uint64_t offset, uint64_t length, Out out) {
+    [data](uint64_t offset, uint64_t length, DataSink sink) {
       const auto &d = *data;
-      out(&d[offset], std::min(length, DATA_CHUNK_SIZE));
+      sink(&d[offset], std::min(length, DATA_CHUNK_SIZE));
     },
     [data] { delete data; });
 });
 ```
 
+### Receive content with Content receiver
+
+```cpp
+svr.Post("/content_receiver",
+  [&](const Request &req, Response &res, const ContentReader &content_reader) {
+    if (req.is_multipart_form_data()) {
+      MultipartFiles files;
+      content_reader(
+        [&](const std::string &name, const MultipartFile &file) {
+          files.emplace(name, file);
+          return true;
+        },
+        [&](const std::string &name, const char *data, size_t data_length) {
+          auto &file = files.find(name)->second;
+          file.content.append(data, data_length);
+          return true;
+        });
+    } else {
+      std::string body;
+      content_reader([&](const char *data, size_t data_length) {
+        body.append(data, data_length);
+        return true;
+      });
+      res.set_content(body, "text/plain");
+    }
+  });
+```
+
 ### Chunked transfer encoding
 
 ```cpp
 svr.Get("/chunked", [&](const Request& req, Response& res) {
   res.set_chunked_content_provider(
-    [](uint64_t offset, Out out, Done done) {
-       out("123", 3);
-       out("345", 3);
-       out("789", 3);
+    [](uint64_t offset, DataSink sink, Done done) {
+       sink("123", 3);
+       sink("345", 3);
+       sink("789", 3);
        done();
     }
   );
@@ -194,8 +231,9 @@ int main(void)
   std::string body;
 
   auto res = cli.Get("/large-data",
-    [&](const char *data, uint64_t data_length, uint64_t offset, uint64_t content_length) {
+    [&](const char *data, uint64_t data_length) {
       body.append(data, data_length);
+      return true;
     });
 
   assert(res->body.empty());
@@ -353,6 +391,8 @@ 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
 

example/Makefile

@@ -1,10 +1,11 @@
 
 #CXX = clang++
 CXXFLAGS = -std=c++14 -I.. -Wall -Wextra -pthread
-OPENSSL_SUPPORT = -DCPPHTTPLIB_OPENSSL_SUPPORT -I/usr/local/opt/openssl/include -L/usr/local/opt/openssl/lib -lssl -lcrypto
+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 simplesvr redirect benchmark
+all: server client hello simplesvr upload redirect benchmark
 
 server : server.cc ../httplib.h Makefile
 	$(CXX) -o server $(CXXFLAGS) server.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT)
@@ -18,6 +19,9 @@ hello : hello.cc ../httplib.h Makefile
 simplesvr : simplesvr.cc ../httplib.h Makefile
 	$(CXX) -o simplesvr $(CXXFLAGS) simplesvr.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT)
 
+upload : upload.cc ../httplib.h Makefile
+	$(CXX) -o upload $(CXXFLAGS) upload.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT)
+
 redirect : redirect.cc ../httplib.h Makefile
 	$(CXX) -o redirect $(CXXFLAGS) redirect.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT)
 
@@ -29,4 +33,4 @@ pem:
 	openssl req -new -key key.pem | openssl x509 -days 3650 -req -signkey key.pem > cert.pem
 
 clean:
-	rm server client hello simplesvr redirect *.pem
+	rm server client hello simplesvr upload redirect *.pem

example/upload.cc

@@ -0,0 +1,49 @@
+//
+//  upload.cc
+//
+//  Copyright (c) 2019 Yuji Hirose. All rights reserved.
+//  MIT License
+//
+
+#include <httplib.h>
+#include <iostream>
+#include <fstream>
+using namespace httplib;
+using namespace std;
+
+const char* html = R"(
+<form id="formElem">
+  <input type="file" name="file" accept="image/*">
+  <input type="submit">
+</form>
+<script>
+  formElem.onsubmit = async (e) => {
+    e.preventDefault();
+    let res = await fetch('/post', {
+      method: 'POST',
+      body: new FormData(formElem)
+    });
+    console.log(await res.text());
+  };
+</script>
+)";
+
+int main(void) {
+  Server svr;
+
+  svr.Get("/", [](const Request & /*req*/, Response &res) {
+    res.set_content(html, "text/html");
+  });
+
+  svr.Post("/post", [](const Request & req, Response &res) {
+    auto file = req.get_file_value("file");
+    cout << "file: " << file.offset << ":" << file.length << ":" << file.filename << endl;
+
+    ofstream ofs(file.filename, ios::binary);
+    ofs << req.body.substr(file.offset, file.length);
+
+    res.set_content("done", "text/plain");
+  });
+
+  svr.listen("localhost", 1234);
+}

test/Makefile

@@ -1,7 +1,8 @@
 
 #CXX = clang++
 CXXFLAGS = -ggdb -O0 -std=c++11 -DGTEST_USE_OWN_TR1_TUPLE -I.. -I. -Wall -Wextra -Wtype-limits
-OPENSSL_SUPPORT = -DCPPHTTPLIB_OPENSSL_SUPPORT -I/usr/local/opt/openssl/include -L/usr/local/opt/openssl/lib -lssl -lcrypto
+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 : test

test/test.cc

@@ -28,6 +28,14 @@ const string LONG_QUERY_URL = "/long-query-value?key=" + LONG_QUERY_VALUE;
 
 const std::string JSON_DATA = "{\"hello\":\"world\"}";
 
+const string LARGE_DATA = string(1024 * 1024 * 100, '@'); // 100MB
+
+MultipartFile& get_file_value(MultipartFiles &files, const char *key) {
+  auto it = files.find(key);
+  if (it != files.end()) { return it->second; }
+  throw std::runtime_error("invalid mulitpart form data name error");
+}
+
 #ifdef _WIN32
 TEST(StartupTest, WSAStartup) {
   WSADATA wsaData;
@@ -229,7 +237,7 @@ TEST(ChunkedEncodingTest, WithContentReceiver) {
   std::string body;
   auto res =
       cli.Get("/httpgallery/chunked/chunkedimage.aspx?0.4153841143030137",
-              [&](const char *data, size_t data_length, uint64_t, uint64_t) {
+              [&](const char *data, size_t data_length) {
                 body.append(data, data_length);
                 return true;
               });
@@ -255,16 +263,16 @@ TEST(ChunkedEncodingTest, WithResponseHandlerAndContentReceiver) {
 #endif
 
   std::string body;
-  auto res =
-      cli.Get("/httpgallery/chunked/chunkedimage.aspx?0.4153841143030137", Headers(),
-              [&](const Response& response) {
-                EXPECT_EQ(200, response.status);
-                return true;
-              },
-              [&](const char *data, size_t data_length, uint64_t, uint64_t) {
-                body.append(data, data_length);
-                return true;
-              });
+  auto res = cli.Get(
+      "/httpgallery/chunked/chunkedimage.aspx?0.4153841143030137", Headers(),
+      [&](const Response &response) {
+        EXPECT_EQ(200, response.status);
+        return true;
+      },
+      [&](const char *data, size_t data_length) {
+        body.append(data, data_length);
+        return true;
+      });
   ASSERT_TRUE(res != nullptr);
 
   std::string out;
@@ -539,7 +547,8 @@ TEST(YahooRedirectTest, Redirect) {
 TEST(HttpsToHttpRedirectTest, Redirect) {
   httplib::SSLClient cli("httpbin.org");
   cli.follow_location(true);
-  auto res = cli.Get("/redirect-to?url=http%3A%2F%2Fwww.google.com&status_code=302");
+  auto res =
+      cli.Get("/redirect-to?url=http%3A%2F%2Fwww.google.com&status_code=302");
   ASSERT_TRUE(res != nullptr);
 }
 #endif
@@ -564,6 +573,7 @@ protected:
 
   virtual void SetUp() {
     svr_.set_base_dir("./www");
+    svr_.set_base_dir("./www2", "/mount");
 
     svr_.Get("/hi",
              [&](const Request & /*req*/, Response &res) {
@@ -636,7 +646,8 @@ protected:
                    [data](uint64_t offset, uint64_t length, DataSink sink) {
                      size_t DATA_CHUNK_SIZE = 4;
                      const auto &d = *data;
-                     auto out_len = std::min(static_cast<size_t>(length), DATA_CHUNK_SIZE);
+                     auto out_len =
+                         std::min(static_cast<size_t>(length), DATA_CHUNK_SIZE);
                      sink(&d[static_cast<size_t>(offset)], out_len);
                    },
                    [data] { delete data; });
@@ -671,29 +682,27 @@ protected:
                 {
                   const auto &file = req.get_file_value("text1");
                   EXPECT_EQ("", file.filename);
-                  EXPECT_EQ("text default",
-                            req.body.substr(file.offset, file.length));
+                  EXPECT_EQ("text default", file.content);
                 }
 
                 {
                   const auto &file = req.get_file_value("text2");
                   EXPECT_EQ("", file.filename);
-                  EXPECT_EQ("aωb", req.body.substr(file.offset, file.length));
+                  EXPECT_EQ("aωb", file.content);
                 }
 
                 {
                   const auto &file = req.get_file_value("file1");
                   EXPECT_EQ("hello.txt", file.filename);
                   EXPECT_EQ("text/plain", file.content_type);
-                  EXPECT_EQ("h\ne\n\nl\nl\no\n",
-                            req.body.substr(file.offset, file.length));
+                  EXPECT_EQ("h\ne\n\nl\nl\no\n", file.content);
                 }
 
                 {
                   const auto &file = req.get_file_value("file3");
                   EXPECT_EQ("", file.filename);
                   EXPECT_EQ("application/octet-stream", file.content_type);
-                  EXPECT_EQ(0u, file.length);
+                  EXPECT_EQ(0u, file.content.size());
                 }
               })
         .Post("/empty",
@@ -706,6 +715,11 @@ protected:
                EXPECT_EQ(req.body, "PUT");
                res.set_content(req.body, "text/plain");
              })
+        .Put("/put-large",
+             [&](const Request &req, Response &res) {
+               EXPECT_EQ(req.body, LARGE_DATA);
+               res.set_content(req.body, "text/plain");
+             })
         .Patch("/patch",
                [&](const Request &req, Response &res) {
                  EXPECT_EQ(req.body, "PATCH");
@@ -742,6 +756,81 @@ protected:
                 EXPECT_EQ(1u, req.get_header_value_count("Content-Length"));
                 EXPECT_EQ("5", req.get_header_value("Content-Length"));
               })
+        .Post("/content_receiver",
+              [&](const Request & req, Response &res, const ContentReader &content_reader) {
+                if (req.is_multipart_form_data()) {
+                  MultipartFiles files;
+                  content_reader(
+                    [&](const std::string &name, const MultipartFile &file) {
+                      files.emplace(name, file);
+                      return true;
+                    },
+                    [&](const std::string &name, const char *data, size_t data_length) {
+                      auto &file = files.find(name)->second;
+                      file.content.append(data, data_length);
+                      return true;
+                    });
+
+                  EXPECT_EQ(5u, files.size());
+
+                  {
+                    const auto &file = get_file_value(files, "text1");
+                    EXPECT_EQ("", file.filename);
+                    EXPECT_EQ("text default", file.content);
+                  }
+
+                  {
+                    const auto &file = get_file_value(files, "text2");
+                    EXPECT_EQ("", file.filename);
+                    EXPECT_EQ("aωb", file.content);
+                  }
+
+                  {
+                    const auto &file = get_file_value(files, "file1");
+                    EXPECT_EQ("hello.txt", file.filename);
+                    EXPECT_EQ("text/plain", file.content_type);
+                    EXPECT_EQ("h\ne\n\nl\nl\no\n", file.content);
+                  }
+
+                  {
+                    const auto &file = get_file_value(files, "file3");
+                    EXPECT_EQ("", file.filename);
+                    EXPECT_EQ("application/octet-stream", file.content_type);
+                    EXPECT_EQ(0u, file.content.size());
+                  }
+                } else {
+                  std::string body;
+                  content_reader([&](const char *data, size_t data_length) {
+                    EXPECT_EQ(data_length, 7);
+                    body.append(data, data_length);
+                    return true;
+                  });
+                  EXPECT_EQ(body, "content");
+                  res.set_content(body, "text/plain");
+                }
+              })
+        .Put("/content_receiver",
+             [&](const Request & /*req*/, Response &res,
+                 const ContentReader &content_reader) {
+               std::string body;
+               content_reader([&](const char *data, size_t data_length) {
+                 body.append(data, data_length);
+                 return true;
+               });
+               EXPECT_EQ(body, "content");
+               res.set_content(body, "text/plain");
+             })
+        .Patch("/content_receiver",
+               [&](const Request & /*req*/, Response &res,
+                   const ContentReader &content_reader) {
+                 std::string body;
+                 content_reader([&](const char *data, size_t data_length) {
+                   body.append(data, data_length);
+                   return true;
+                 });
+                 EXPECT_EQ(body, "content");
+                 res.set_content(body, "text/plain");
+               })
 #ifdef CPPHTTPLIB_ZLIB_SUPPORT
         .Get("/gzip",
              [&](const Request & /*req*/, Response &res) {
@@ -765,14 +854,13 @@ protected:
                 {
                   const auto &file = req.get_file_value("key1");
                   EXPECT_EQ("", file.filename);
-                  EXPECT_EQ("test", req.body.substr(file.offset, file.length));
+                  EXPECT_EQ("test", file.content);
                 }
 
                 {
                   const auto &file = req.get_file_value("key2");
                   EXPECT_EQ("", file.filename);
-                  EXPECT_EQ("--abcdefg123",
-                            req.body.substr(file.offset, file.length));
+                  EXPECT_EQ("--abcdefg123", file.content);
                 }
               })
 #endif
@@ -960,9 +1048,42 @@ TEST_F(ServerTest, GetMethodOutOfBaseDir2) {
   EXPECT_EQ(404, res->status);
 }
 
-TEST_F(ServerTest, InvalidBaseDir) {
-  EXPECT_EQ(false, svr_.set_base_dir("invalid_dir"));
-  EXPECT_EQ(true, svr_.set_base_dir("."));
+TEST_F(ServerTest, GetMethodDirMountTest) {
+  auto res = cli_.Get("/mount/dir/test.html");
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(200, res->status);
+  EXPECT_EQ("text/html", res->get_header_value("Content-Type"));
+  EXPECT_EQ("test.html", res->body);
+}
+
+TEST_F(ServerTest, GetMethodDirMountTestWithDoubleDots) {
+  auto res = cli_.Get("/mount/dir/../dir/test.html");
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(200, res->status);
+  EXPECT_EQ("text/html", res->get_header_value("Content-Type"));
+  EXPECT_EQ("test.html", res->body);
+}
+
+TEST_F(ServerTest, GetMethodInvalidMountPath) {
+  auto res = cli_.Get("/mount/dir/../test.html");
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(404, res->status);
+}
+
+TEST_F(ServerTest, GetMethodOutOfBaseDirMount) {
+  auto res = cli_.Get("/mount/../www2/dir/test.html");
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(404, res->status);
+}
+
+TEST_F(ServerTest, GetMethodOutOfBaseDirMount2) {
+  auto res = cli_.Get("/mount/dir/../../www2/dir/test.html");
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(404, res->status);
+}
+
+TEST_F(ServerTest, InvalidBaseDirMount) {
+  EXPECT_EQ(false, svr_.set_base_dir("./www3", "invalid_mount_point"));
 }
 
 TEST_F(ServerTest, EmptyRequest) {
@@ -1236,10 +1357,15 @@ TEST_F(ServerTest, GetStreamedWithRangeMultipart) {
 }
 
 TEST_F(ServerTest, GetStreamedEndless) {
+  size_t offset = 0;
   auto res = cli_.Get("/streamed-cancel",
-                      [](const char * /*data*/, uint64_t /*data_length*/,
-                         uint64_t offset,
-                         uint64_t /*content_length*/) { return offset < 100; });
+                      [&](const char * /*data*/, uint64_t data_length) {
+                        if (offset < 100) {
+                          offset += data_length;
+                          return true;
+                        }
+                        return false;
+                      });
   ASSERT_TRUE(res == nullptr);
 }
 
@@ -1351,6 +1477,42 @@ TEST_F(ServerTest, Put) {
   EXPECT_EQ("PUT", res->body);
 }
 
+TEST_F(ServerTest, PutWithContentProvider) {
+  auto res = cli_.Put(
+      "/put", 3,
+      [](size_t /*offset*/, size_t /*length*/, DataSink sink) {
+        sink("PUT", 3);
+      },
+      "text/plain");
+
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(200, res->status);
+  EXPECT_EQ("PUT", res->body);
+}
+
+#ifdef CPPHTTPLIB_ZLIB_SUPPORT
+TEST_F(ServerTest, PutWithContentProviderWithGzip) {
+  auto res = cli_.Put(
+      "/put", 3,
+      [](size_t /*offset*/, size_t /*length*/, DataSink sink) {
+        sink("PUT", 3);
+      },
+      "text/plain", true);
+
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(200, res->status);
+  EXPECT_EQ("PUT", res->body);
+}
+
+TEST_F(ServerTest, PutLargeFileWithGzip) {
+  auto res = cli_.Put("/put-large", LARGE_DATA, "text/plain", true);
+
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(200, res->status);
+  EXPECT_EQ(LARGE_DATA, res->body);
+}
+#endif
+
 TEST_F(ServerTest, Patch) {
   auto res = cli_.Patch("/patch", "PATCH", "text/plain");
   ASSERT_TRUE(res != nullptr);
@@ -1393,6 +1555,49 @@ TEST_F(ServerTest, NoMultipleHeaders) {
   EXPECT_EQ(200, res->status);
 }
 
+TEST_F(ServerTest, PostContentReceiver) {
+  auto res = cli_.Post("/content_receiver", "content", "text/plain");
+  ASSERT_TRUE(res != nullptr);
+  ASSERT_EQ(200, res->status);
+  ASSERT_EQ("content", res->body);
+}
+
+TEST_F(ServerTest, PostMulitpartFilsContentReceiver) {
+  MultipartFormDataItems items = {
+      {"text1", "text default", "", ""},
+      {"text2", "aωb", "", ""},
+      {"file1", "h\ne\n\nl\nl\no\n", "hello.txt", "text/plain"},
+      {"file2", "{\n  \"world\", true\n}\n", "world.json", "application/json"},
+      {"file3", "", "", "application/octet-stream"},
+  };
+
+  auto res = cli_.Post("/content_receiver", items);
+
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(200, res->status);
+}
+
+TEST_F(ServerTest, PostContentReceiverGzip) {
+  auto res = cli_.Post("/content_receiver", "content", "text/plain", true);
+  ASSERT_TRUE(res != nullptr);
+  ASSERT_EQ(200, res->status);
+  ASSERT_EQ("content", res->body);
+}
+
+TEST_F(ServerTest, PutContentReceiver) {
+  auto res = cli_.Put("/content_receiver", "content", "text/plain");
+  ASSERT_TRUE(res != nullptr);
+  ASSERT_EQ(200, res->status);
+  ASSERT_EQ("content", res->body);
+}
+
+TEST_F(ServerTest, PatchContentReceiver) {
+  auto res = cli_.Patch("/content_receiver", "content", "text/plain");
+  ASSERT_TRUE(res != nullptr);
+  ASSERT_EQ(200, res->status);
+  ASSERT_EQ("content", res->body);
+}
+
 TEST_F(ServerTest, HTTP2Magic) {
   Request req;
   req.method = "PRI";
@@ -1422,19 +1627,19 @@ TEST_F(ServerTest, KeepAlive) {
   ASSERT_TRUE(requests.size() == responses.size());
 
   for (int i = 0; i < 3; i++) {
-    auto& res = responses[i];
+    auto &res = responses[i];
     EXPECT_EQ(200, res.status);
     EXPECT_EQ("text/plain", res.get_header_value("Content-Type"));
     EXPECT_EQ("Hello World!", res.body);
   }
 
   {
-    auto& res = responses[3];
+    auto &res = responses[3];
     EXPECT_EQ(404, res.status);
   }
 
   {
-    auto& res = responses[4];
+    auto &res = responses[4];
     EXPECT_EQ(200, res.status);
     EXPECT_EQ("text/plain", res.get_header_value("Content-Type"));
     EXPECT_EQ("empty", res.body);
@@ -1457,16 +1662,30 @@ TEST_F(ServerTest, Gzip) {
   EXPECT_EQ(200, res->status);
 }
 
+TEST_F(ServerTest, GzipWithoutAcceptEncoding) {
+  Headers headers;
+  auto res = cli_.Get("/gzip", headers);
+
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ("", res->get_header_value("Content-Encoding"));
+  EXPECT_EQ("text/plain", res->get_header_value("Content-Type"));
+  EXPECT_EQ("100", res->get_header_value("Content-Length"));
+  EXPECT_EQ("123456789012345678901234567890123456789012345678901234567890123456"
+            "7890123456789012345678901234567890",
+            res->body);
+  EXPECT_EQ(200, res->status);
+}
+
 TEST_F(ServerTest, GzipWithContentReceiver) {
   Headers headers;
   headers.emplace("Accept-Encoding", "gzip, deflate");
   std::string body;
-  auto res = cli_.Get("/gzip", headers,
-                      [&](const char *data, uint64_t data_length,
-                          uint64_t /*offset*/, uint64_t /*content_length*/) {
-                        body.append(data, data_length);
-                        return true;
-                      });
+  auto res =
+      cli_.Get("/gzip", headers, [&](const char *data, uint64_t data_length) {
+        EXPECT_EQ(data_length, 100);
+        body.append(data, data_length);
+        return true;
+      });
 
   ASSERT_TRUE(res != nullptr);
   EXPECT_EQ("gzip", res->get_header_value("Content-Encoding"));
@@ -1478,6 +1697,26 @@ TEST_F(ServerTest, GzipWithContentReceiver) {
   EXPECT_EQ(200, res->status);
 }
 
+TEST_F(ServerTest, GzipWithContentReceiverWithoutAcceptEncoding) {
+  Headers headers;
+  std::string body;
+  auto res =
+      cli_.Get("/gzip", headers, [&](const char *data, uint64_t data_length) {
+        EXPECT_EQ(data_length, 100);
+        body.append(data, data_length);
+        return true;
+      });
+
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ("", res->get_header_value("Content-Encoding"));
+  EXPECT_EQ("text/plain", res->get_header_value("Content-Type"));
+  EXPECT_EQ("100", res->get_header_value("Content-Length"));
+  EXPECT_EQ("123456789012345678901234567890123456789012345678901234567890123456"
+            "7890123456789012345678901234567890",
+            body);
+  EXPECT_EQ(200, res->status);
+}
+
 TEST_F(ServerTest, NoGzip) {
   Headers headers;
   headers.emplace("Accept-Encoding", "gzip, deflate");
@@ -1497,12 +1736,12 @@ TEST_F(ServerTest, NoGzipWithContentReceiver) {
   Headers headers;
   headers.emplace("Accept-Encoding", "gzip, deflate");
   std::string body;
-  auto res = cli_.Get("/nogzip", headers,
-                      [&](const char *data, uint64_t data_length,
-                          uint64_t /*offset*/, uint64_t /*content_length*/) {
-                        body.append(data, data_length);
-                        return true;
-                      });
+  auto res =
+      cli_.Get("/nogzip", headers, [&](const char *data, uint64_t data_length) {
+        EXPECT_EQ(data_length, 100);
+        body.append(data, data_length);
+        return true;
+      });
 
   ASSERT_TRUE(res != nullptr);
   EXPECT_EQ(false, res->has_header("Content-Encoding"));
@@ -1515,56 +1754,14 @@ TEST_F(ServerTest, NoGzipWithContentReceiver) {
 }
 
 TEST_F(ServerTest, MultipartFormDataGzip) {
-  Request req;
-  req.method = "POST";
-  req.path = "/gzipmultipart";
+  MultipartFormDataItems items = {
+      {"key1", "test", "", ""},
+      {"key2", "--abcdefg123", "", ""},
+  };
 
-  std::string host_and_port;
-  host_and_port += HOST;
-  host_and_port += ":";
-  host_and_port += std::to_string(PORT);
+  auto res = cli_.Post("/gzipmultipart", items, true);
 
-  req.headers.emplace("Host", host_and_port.c_str());
-  req.headers.emplace("Accept", "*/*");
-  req.headers.emplace("User-Agent", "cpp-httplib/0.1");
-  req.headers.emplace(
-      "Content-Type",
-      "multipart/form-data; boundary=------------------------fcba8368a9f48c0f");
-  req.headers.emplace("Content-Encoding", "gzip");
-
-  // compressed_body generated by creating input.txt to this file:
-  /*
-  --------------------------fcba8368a9f48c0f
-  Content-Disposition: form-data; name="key1"
-
-  test
-  --------------------------fcba8368a9f48c0f
-  Content-Disposition: form-data; name="key2"
-
-  --abcdefg123
-  --------------------------fcba8368a9f48c0f--
-  */
-  // then running unix2dos input.txt; gzip -9 -c input.txt | xxd -i.
-  uint8_t compressed_body[] = {
-      0x1f, 0x8b, 0x08, 0x08, 0x48, 0xf1, 0xd4, 0x5a, 0x02, 0x03, 0x69, 0x6e,
-      0x70, 0x75, 0x74, 0x2e, 0x74, 0x78, 0x74, 0x00, 0xd3, 0xd5, 0xc5, 0x05,
-      0xd2, 0x92, 0x93, 0x12, 0x2d, 0x8c, 0xcd, 0x2c, 0x12, 0x2d, 0xd3, 0x4c,
-      0x2c, 0x92, 0x0d, 0xd2, 0x78, 0xb9, 0x9c, 0xf3, 0xf3, 0x4a, 0x52, 0xf3,
-      0x4a, 0x74, 0x5d, 0x32, 0x8b, 0x0b, 0xf2, 0x8b, 0x33, 0x4b, 0x32, 0xf3,
-      0xf3, 0xac, 0x14, 0xd2, 0xf2, 0x8b, 0x72, 0x75, 0x53, 0x12, 0x4b, 0x12,
-      0xad, 0x15, 0xf2, 0x12, 0x73, 0x53, 0x6d, 0x95, 0xb2, 0x53, 0x2b, 0x0d,
-      0x95, 0x78, 0xb9, 0x78, 0xb9, 0x4a, 0x52, 0x8b, 0x4b, 0x78, 0xb9, 0x74,
-      0x69, 0x61, 0x81, 0x11, 0xd8, 0x02, 0x5d, 0xdd, 0xc4, 0xa4, 0xe4, 0x94,
-      0xd4, 0xb4, 0x74, 0x43, 0x23, 0x63, 0x52, 0x2c, 0xd2, 0xd5, 0xe5, 0xe5,
-      0x02, 0x00, 0xff, 0x0e, 0x72, 0xdf, 0xf8, 0x00, 0x00, 0x00};
-
-  req.body = std::string((char *)compressed_body,
-                         sizeof(compressed_body) / sizeof(compressed_body[0]));
-
-  auto res = std::make_shared<Response>();
-  auto ret = cli_.send(req, *res);
-
-  ASSERT_TRUE(ret);
+  ASSERT_TRUE(res != nullptr);
   EXPECT_EQ(200, res->status);
 }
 #endif

test/www2/dir/index.html

@@ -0,0 +1,8 @@
+<html>
+<head>
+</head>
+<body>
+  <a href="/dir/test.html">Test</a>
+  <a href="/hi">hi</a>
+</body>
+</html>

test/www2/dir/test.html

@@ -0,0 +1 @@
+test.html

test/www3/dir/index.html

@@ -0,0 +1,8 @@
+<html>
+<head>
+</head>
+<body>
+  <a href="/dir/test.html">Test</a>
+  <a href="/hi">hi</a>
+</body>
+</html>

test/www3/dir/test.html

@@ -0,0 +1 @@
+test.html