Updated README

Add status message: 503 Service Unavailable

.gitignore

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

README.md

@@ -5,7 +5,7 @@ cpp-httplib
 [![Build Status](https://travis-ci.org/yhirose/cpp-httplib.svg?branch=master)](https://travis-ci.org/yhirose/cpp-httplib)
 [![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++ single-file header-only cross platform HTTP/HTTPS library.
+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!
 
@@ -50,23 +50,26 @@ svr.listen_after_bind();
 ### Static File Server
 
 ```cpp
-svr.set_base_dir("./www"); // This is same as `svr.set_base_dir("./www", "/")`;
+auto ret = svr.set_base_dir("./www"); // This is same as `svr.set_base_dir("./www", "/")`;
+if (!ret) {
+  // The specified base directory doesn't exist...
+}
 
+// Mount /public to ./www directory
+ret = svr.set_base_dir("./www", "/public");
+
+// Mount /public to ./www1 and ./www2 directories
+ret = svr.set_base_dir("./www1", "/public"); // 1st order to search
+ret = svr.set_base_dir("./www2", "/public"); // 2nd order to search
+```
+
+```cpp
 // User defined file extension and MIME type mappings
 svr.set_file_extension_and_mimetype_mapping("cc", "text/x-c");
 svr.set_file_extension_and_mimetype_mapping("cpp", "text/x-c");
 svr.set_file_extension_and_mimetype_mapping("hh", "text/x-h");
 ```
 
-```cpp
-svr.set_base_dir("./www", "/public");
-```
-
-```cpp
-svr.set_base_dir("./www1", "/public"); // 1st order
-svr.set_base_dir("./www2", "/public"); // 2nd order
-```
-
 The followings are built-in mappings:
 
 | Extension  |     MIME Type          |
@@ -129,9 +132,9 @@ svr.Get("/stream", [&](const Request &req, Response &res) {
 
   res.set_content_provider(
     data->size(), // Content length
-    [data](uint64_t offset, uint64_t length, DataSink sink) {
+    [data](uint64_t offset, uint64_t length, DataSink &sink) {
       const auto &d = *data;
-      sink(&d[offset], std::min(length, DATA_CHUNK_SIZE));
+      sink.write(&d[offset], std::min(length, DATA_CHUNK_SIZE));
     },
     [data] { delete data; });
 });
@@ -169,30 +172,31 @@ svr.Post("/content_receiver",
 ```cpp
 svr.Get("/chunked", [&](const Request& req, Response& res) {
   res.set_chunked_content_provider(
-    [](uint64_t offset, DataSink sink, Done done) {
-       sink("123", 3);
-       sink("345", 3);
-       sink("789", 3);
-       done();
+    [](uint64_t offset, DataSink &sink) {
+       sink.write("123", 3);
+       sink.write("345", 3);
+       sink.write("789", 3);
+       sink.done();
     }
   );
 });
 ```
 
+### Server-Sent Events
+
+Please check [here](https://github.com/yhirose/cpp-httplib/blob/master/example/sse.cc).
+
 ### Default thread pool support
 
+
+`ThreadPool` is used as a default task queue, and the default thread count is set to value from `std::thread::hardware_concurrency()`.
+
 Set thread count to 8:
 
 ```cpp
 #define CPPHTTPLIB_THREAD_POOL_COUNT 8
 ```
 
-Disable the default thread pool:
-
-```cpp
-#define CPPHTTPLIB_THREAD_POOL_COUNT 0
-```
-
 ### Override the default thread pool with yours
 
 ```cpp

example/Makefile

@@ -5,7 +5,7 @@ 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 upload redirect benchmark
+all: server client hello simplesvr upload redirect sse benchmark
 
 server : server.cc ../httplib.h Makefile
 	$(CXX) -o server $(CXXFLAGS) server.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT)
@@ -25,6 +25,9 @@ upload : upload.cc ../httplib.h Makefile
 redirect : redirect.cc ../httplib.h Makefile
 	$(CXX) -o redirect $(CXXFLAGS) redirect.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT)
 
+sse : sse.cc ../httplib.h Makefile
+	$(CXX) -o sse $(CXXFLAGS) sse.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT)
+
 benchmark : benchmark.cc ../httplib.h Makefile
 	$(CXX) -o benchmark $(CXXFLAGS) benchmark.cc $(OPENSSL_SUPPORT) $(ZLIB_SUPPORT)
 
@@ -33,4 +36,4 @@ pem:
 	openssl req -new -key key.pem | openssl x509 -days 3650 -req -signkey key.pem > cert.pem
 
 clean:
-	rm server client hello simplesvr upload redirect benchmark *.pem
+	rm server client hello simplesvr upload redirect sse benchmark *.pem

example/simplesvr.cc

@@ -122,7 +122,10 @@ int main(int argc, const char **argv) {
   auto base_dir = "./";
   if (argc > 2) { base_dir = argv[2]; }
 
-  svr.set_base_dir(base_dir);
+  if (!svr.set_base_dir(base_dir)) {
+    cout << "The specified base directory doesn't exist...";
+    return 1;
+  }
 
   cout << "The server started at port " << port << "...";
 

example/sse.cc

@@ -0,0 +1,106 @@
+//
+//  sse.cc
+//
+//  Copyright (c) 2020 Yuji Hirose. All rights reserved.
+//  MIT License
+//
+
+#include <atomic>
+#include <chrono>
+#include <condition_variable>
+#include <httplib.h>
+#include <iostream>
+#include <mutex>
+#include <thread>
+
+using namespace httplib;
+using namespace std;
+
+class EventDispatcher {
+public:
+  EventDispatcher() {
+    id_ = 0;
+    cid_ = -1;
+  }
+
+  void wait_event(DataSink *sink) {
+    unique_lock<mutex> lk(m_);
+    int id = id_;
+    cv_.wait(lk, [&] { return cid_ == id; });
+    if (sink->is_writable()) { sink->write(message_.data(), message_.size()); }
+  }
+
+  void send_event(const string &message) {
+    lock_guard<mutex> lk(m_);
+    cid_ = id_++;
+    message_ = message;
+    cv_.notify_all();
+  }
+
+private:
+  mutex m_;
+  condition_variable cv_;
+  atomic_int id_;
+  atomic_int cid_;
+  string message_;
+};
+
+const auto html = R"(
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<title>SSE demo</title>
+</head>
+<body>
+<script>
+const ev1 = new EventSource("event1");
+ev1.onmessage = function(e) {
+  console.log('ev1', e.data);
+}
+const ev2 = new EventSource("event2");
+ev2.onmessage = function(e) {
+  console.log('ev2', e.data);
+}
+</script>
+</body>
+</html>
+)";
+
+int main(void) {
+  EventDispatcher ed;
+
+  Server svr;
+
+  svr.Get("/", [&](const Request & /*req*/, Response &res) {
+    res.set_content(html, "text/html");
+  });
+
+  svr.Get("/event1", [&](const Request & /*req*/, Response &res) {
+    cout << "connected to event1..." << endl;
+    res.set_header("Content-Type", "text/event-stream");
+    res.set_chunked_content_provider(
+        [&](uint64_t /*offset*/, DataSink &sink) { ed.wait_event(&sink); });
+  });
+
+  svr.Get("/event2", [&](const Request & /*req*/, Response &res) {
+    cout << "connected to event2..." << endl;
+    res.set_header("Content-Type", "text/event-stream");
+    res.set_chunked_content_provider(
+        [&](uint64_t /*offset*/, DataSink &sink) { ed.wait_event(&sink); });
+  });
+
+  thread t([&] {
+    int id = 0;
+    while (true) {
+      this_thread::sleep_for(chrono::seconds(1));
+      cout << "send event: " << id << std::endl;
+      std::stringstream ss;
+      ss << "data: " << id << "\n\n";
+      ed.send_event(ss.str());
+      id++;
+    }
+  });
+
+  svr.listen("localhost", 1234);
+}

example/upload.cc

@@ -13,7 +13,8 @@ using namespace std;
 
 const char *html = R"(
 <form id="formElem">
-  <input type="file" name="file" accept="image/*">
+  <input type="file" name="image_file" accept="image/*">
+  <input type="file" name="text_file" accept="text/*">
   <input type="submit">
 </form>
 <script>
@@ -36,12 +37,22 @@ int main(void) {
   });
 
   svr.Post("/post", [](const Request &req, Response &res) {
-    auto file = req.get_file_value("file");
-    cout << "file length: " << file.content.length() << ":" << file.filename
-         << endl;
+    auto image_file = req.get_file_value("image_file");
+    auto text_file = req.get_file_value("text_file");
 
-    ofstream ofs(file.filename, ios::binary);
-    ofs << file.content;
+    cout << "image file length: " << image_file.content.length() << endl
+         << "image file name: " << image_file.filename << endl
+         << "text file length: " << text_file.content.length() << endl
+         << "text file name: " << text_file.filename << endl;
+
+    {
+      ofstream ofs(image_file.filename, ios::binary);
+      ofs << image_file.content;
+    }
+    {
+      ofstream ofs(text_file.filename);
+      ofs << text_file.content;
+    }
 
     res.set_content("done", "text/plain");
   });

test/test.cc

@@ -1,7 +1,11 @@
-#include <future>
-#include <gtest/gtest.h>
 #include <httplib.h>
 
+#include <gtest/gtest.h>
+
+#include <chrono>
+#include <future>
+#include <thread>
+
 #define SERVER_CERT_FILE "./cert.pem"
 #define SERVER_PRIVATE_KEY_FILE "./key.pem"
 #define CA_CERT_FILE "./ca-bundle.crt"
@@ -10,13 +14,6 @@
 #define CLIENT_CERT_FILE "./client.cert.pem"
 #define CLIENT_PRIVATE_KEY_FILE "./client.key.pem"
 
-#ifdef _WIN32
-#include <process.h>
-#define msleep(n) ::Sleep(n)
-#else
-#define msleep(n) ::usleep(n * 1000)
-#endif
-
 using namespace std;
 using namespace httplib;
 
@@ -202,6 +199,27 @@ TEST(ParseHeaderValueTest, Range) {
   }
 }
 
+TEST(BufferStreamTest, read) {
+  detail::BufferStream strm1;
+  Stream& strm = strm1;
+
+  EXPECT_EQ(5, strm.write("hello"));
+
+  char buf[512];
+  EXPECT_EQ(2, strm.read(buf, 2));
+  EXPECT_EQ('h', buf[0]);
+  EXPECT_EQ('e', buf[1]);
+
+  EXPECT_EQ(2, strm.read(buf, 2));
+  EXPECT_EQ('l', buf[0]);
+  EXPECT_EQ('l', buf[1]);
+
+  EXPECT_EQ(1, strm.read(buf, 1));
+  EXPECT_EQ('o', buf[0]);
+
+  EXPECT_EQ(0, strm.read(buf, 1));
+}
+
 TEST(ChunkedEncodingTest, FromHTTPWatch) {
   auto host = "www.httpwatch.com";
 
@@ -514,7 +532,6 @@ TEST(DigestAuthTest, FromHTTPWatch) {
         "/digest-auth/auth/hello/world/MD5",
         "/digest-auth/auth/hello/world/SHA-256",
         "/digest-auth/auth/hello/world/SHA-512",
-        "/digest-auth/auth-init/hello/world/MD5",
         "/digest-auth/auth-int/hello/world/MD5",
     };
 
@@ -655,7 +672,7 @@ protected:
              })
         .Get("/slow",
              [&](const Request & /*req*/, Response &res) {
-               msleep(2000);
+               std::this_thread::sleep_for(std::chrono::seconds(2));
                res.set_content("slow", "text/plain");
              })
         .Get("/remote_addr",
@@ -678,6 +695,15 @@ protected:
                   res.status = 400;
                 }
               })
+        .Put("/person",
+             [&](const Request &req, Response &res) {
+               if (req.has_param("name") && req.has_param("note")) {
+                 persons_[req.get_param_value("name")] =
+                     req.get_param_value("note");
+               } else {
+                 res.status = 400;
+               }
+             })
         .Get("/person/(.*)",
              [&](const Request &req, Response &res) {
                string name = req.matches[1];
@@ -698,18 +724,35 @@ protected:
         .Get("/streamed-chunked",
              [&](const Request & /*req*/, Response &res) {
                res.set_chunked_content_provider(
-                   [](uint64_t /*offset*/, DataSink sink, Done done) {
-                     sink("123", 3);
-                     sink("456", 3);
-                     sink("789", 3);
-                     done();
+                   [](uint64_t /*offset*/, DataSink &sink) {
+                     ASSERT_TRUE(sink.is_writable());
+                     sink.write("123", 3);
+                     sink.write("456", 3);
+                     sink.write("789", 3);
+                     sink.done();
                    });
              })
+        .Get("/streamed-chunked2",
+             [&](const Request & /*req*/, Response &res) {
+               auto i = new int(0);
+               res.set_chunked_content_provider(
+                   [i](uint64_t /*offset*/, DataSink &sink) {
+                     ASSERT_TRUE(sink.is_writable());
+                     switch (*i) {
+                     case 0: sink.write("123", 3); break;
+                     case 1: sink.write("456", 3); break;
+                     case 2: sink.write("789", 3); break;
+                     case 3: sink.done(); break;
+                     }
+                     (*i)++;
+                   },
+                   [i] { delete i; });
+             })
         .Get("/streamed",
              [&](const Request & /*req*/, Response &res) {
                res.set_content_provider(
-                   6, [](uint64_t offset, uint64_t /*length*/, DataSink sink) {
-                     sink(offset < 3 ? "a" : "b", 1);
+                   6, [](uint64_t offset, uint64_t /*length*/, DataSink &sink) {
+                     sink.write(offset < 3 ? "a" : "b", 1);
                    });
              })
         .Get("/streamed-with-range",
@@ -717,23 +760,25 @@ protected:
                auto data = new std::string("abcdefg");
                res.set_content_provider(
                    data->size(),
-                   [data](uint64_t offset, uint64_t length, DataSink sink) {
+                   [data](uint64_t offset, uint64_t length, DataSink &sink) {
+                     ASSERT_TRUE(sink.is_writable());
                      size_t DATA_CHUNK_SIZE = 4;
                      const auto &d = *data;
                      auto out_len =
                          std::min(static_cast<size_t>(length), DATA_CHUNK_SIZE);
-                     sink(&d[static_cast<size_t>(offset)], out_len);
+                     sink.write(&d[static_cast<size_t>(offset)], out_len);
                    },
                    [data] { delete data; });
              })
         .Get("/streamed-cancel",
              [&](const Request & /*req*/, Response &res) {
-               res.set_content_provider(
-                   size_t(-1),
-                   [](uint64_t /*offset*/, uint64_t /*length*/, DataSink sink) {
-                     std::string data = "data_chunk";
-                     sink(data.data(), data.size());
-                   });
+               res.set_content_provider(size_t(-1), [](uint64_t /*offset*/,
+                                                       uint64_t /*length*/,
+                                                       DataSink &sink) {
+                 ASSERT_TRUE(sink.is_writable());
+                 std::string data = "data_chunk";
+                 sink.write(data.data(), data.size());
+               });
              })
         .Get("/with-range",
              [&](const Request & /*req*/, Response &res) {
@@ -951,7 +996,7 @@ protected:
     t_ = thread([&]() { ASSERT_TRUE(svr_.listen(HOST, PORT)); });
 
     while (!svr_.is_running()) {
-      msleep(1);
+      std::this_thread::sleep_for(std::chrono::milliseconds(1));
     }
   }
 
@@ -1058,6 +1103,26 @@ TEST_F(ServerTest, PostMethod2) {
   ASSERT_EQ("coder", res->body);
 }
 
+TEST_F(ServerTest, PutMethod3) {
+  auto res = cli_.Get("/person/john3");
+  ASSERT_TRUE(res != nullptr);
+  ASSERT_EQ(404, res->status);
+
+  Params params;
+  params.emplace("name", "john3");
+  params.emplace("note", "coder");
+
+  res = cli_.Put("/person", params);
+  ASSERT_TRUE(res != nullptr);
+  ASSERT_EQ(200, res->status);
+
+  res = cli_.Get("/person/john3");
+  ASSERT_TRUE(res != nullptr);
+  ASSERT_EQ(200, res->status);
+  ASSERT_EQ("text/plain", res->get_header_value("Content-Type"));
+  ASSERT_EQ("coder", res->body);
+}
+
 TEST_F(ServerTest, PostWwwFormUrlEncodedJson) {
   Params params;
   params.emplace("json", JSON_DATA);
@@ -1167,7 +1232,7 @@ TEST_F(ServerTest, UserDefinedMIMETypeMapping) {
   ASSERT_TRUE(res != nullptr);
   EXPECT_EQ(200, res->status);
   EXPECT_EQ("text/abcde", res->get_header_value("Content-Type"));
-  EXPECT_EQ("abcde\n", res->body);
+  EXPECT_EQ("abcde", res->body);
 }
 
 TEST_F(ServerTest, InvalidBaseDirMount) {
@@ -1509,6 +1574,13 @@ TEST_F(ServerTest, GetStreamedChunked) {
   EXPECT_EQ(std::string("123456789"), res->body);
 }
 
+TEST_F(ServerTest, GetStreamedChunked2) {
+  auto res = cli_.Get("/streamed-chunked2");
+  ASSERT_TRUE(res != nullptr);
+  EXPECT_EQ(200, res->status);
+  EXPECT_EQ(std::string("123456789"), res->body);
+}
+
 TEST_F(ServerTest, LargeChunkedPost) {
   Request req;
   req.method = "POST";
@@ -1555,7 +1627,7 @@ TEST_F(ServerTest, SlowRequest) {
       std::thread([=]() { auto res = cli_.Get("/slow"); }));
   request_threads_.push_back(
       std::thread([=]() { auto res = cli_.Get("/slow"); }));
-  msleep(100);
+  std::this_thread::sleep_for(std::chrono::milliseconds(100));
 }
 
 TEST_F(ServerTest, Put) {
@@ -1568,8 +1640,9 @@ TEST_F(ServerTest, Put) {
 TEST_F(ServerTest, PutWithContentProvider) {
   auto res = cli_.Put(
       "/put", 3,
-      [](size_t /*offset*/, size_t /*length*/, DataSink sink) {
-        sink("PUT", 3);
+      [](size_t /*offset*/, size_t /*length*/, DataSink &sink) {
+        ASSERT_TRUE(sink.is_writable());
+        sink.write("PUT", 3);
       },
       "text/plain");
 
@@ -1583,8 +1656,9 @@ TEST_F(ServerTest, PutWithContentProviderWithGzip) {
   cli_.set_compress(true);
   auto res = cli_.Put(
       "/put", 3,
-      [](size_t /*offset*/, size_t /*length*/, DataSink sink) {
-        sink("PUT", 3);
+      [](size_t /*offset*/, size_t /*length*/, DataSink &sink) {
+        ASSERT_TRUE(sink.is_writable());
+        sink.write("PUT", 3);
       },
       "text/plain");
 
@@ -1690,7 +1764,8 @@ TEST_F(ServerTest, PatchContentReceiver) {
 }
 
 TEST_F(ServerTest, PostQueryStringAndBody) {
-  auto res = cli_.Post("/query-string-and-body?key=value", "content", "text/plain");
+  auto res =
+      cli_.Post("/query-string-and-body?key=value", "content", "text/plain");
   ASSERT_TRUE(res != nullptr);
   ASSERT_EQ(200, res->status);
 }
@@ -1899,7 +1974,7 @@ TEST(ServerRequestParsingTest, TrimWhitespaceFromHeaderValues) {
 
   thread t = thread([&] { svr.listen(HOST, PORT); });
   while (!svr.is_running()) {
-    msleep(1);
+    std::this_thread::sleep_for(std::chrono::milliseconds(1));
   }
 
   // Only space and horizontal tab are whitespace. Make sure other whitespace-
@@ -1929,7 +2004,7 @@ TEST(ServerRequestParsingTest, ReadHeadersRegexComplexity) {
   bool listen_thread_ok = false;
   thread t = thread([&] { listen_thread_ok = svr.listen(HOST, PORT); });
   while (!svr.is_running()) {
-    msleep(1);
+    std::this_thread::sleep_for(std::chrono::milliseconds(1));
   }
 
   // A certain header line causes an exception if the header property is parsed
@@ -1945,6 +2020,46 @@ TEST(ServerRequestParsingTest, ReadHeadersRegexComplexity) {
   EXPECT_TRUE(listen_thread_ok);
 }
 
+TEST(ServerStopTest, StopServerWithChunkedTransmission) {
+  Server svr;
+
+  svr.Get("/events", [](const Request & /*req*/, Response &res) {
+    res.set_header("Content-Type", "text/event-stream");
+    res.set_header("Cache-Control", "no-cache");
+    res.set_chunked_content_provider([](size_t offset, const DataSink &sink) {
+      char buffer[27];
+      int size = sprintf(buffer, "data:%ld\n\n", offset);
+      sink.write(buffer, size);
+      std::this_thread::sleep_for(std::chrono::seconds(1));
+    });
+  });
+
+  auto listen_thread = std::thread([&svr]() { svr.listen("localhost", PORT); });
+  while (!svr.is_running()) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(1));
+  }
+
+  Client client(HOST, PORT);
+  const Headers headers = {{"Accept", "text/event-stream"},
+                           {"Connection", "Keep-Alive"}};
+
+  auto get_thread = std::thread([&client, &headers]() {
+    std::shared_ptr<Response> res = client.Get(
+        "/events", headers,
+        [](const char * /*data*/, size_t /*len*/) -> bool { return true; });
+  });
+
+  // Give GET time to get a few messages.
+  std::this_thread::sleep_for(std::chrono::seconds(2));
+
+  svr.stop();
+
+  listen_thread.join();
+  get_thread.join();
+
+  ASSERT_FALSE(svr.is_running());
+}
+
 class ServerTestWithAI_PASSIVE : public ::testing::Test {
 protected:
   ServerTestWithAI_PASSIVE()
@@ -1964,7 +2079,7 @@ protected:
     t_ = thread([&]() { ASSERT_TRUE(svr_.listen(nullptr, PORT, AI_PASSIVE)); });
 
     while (!svr_.is_running()) {
-      msleep(1);
+      std::this_thread::sleep_for(std::chrono::milliseconds(1));
     }
   }
 
@@ -1998,12 +2113,12 @@ protected:
   virtual void SetUp() {
     t_ = thread([&]() {
       svr_.bind_to_any_port(HOST);
-      msleep(500);
+      std::this_thread::sleep_for(std::chrono::milliseconds(500));
       ASSERT_TRUE(svr_.listen_after_bind());
     });
 
     while (!svr_.is_running()) {
-      msleep(1);
+      std::this_thread::sleep_for(std::chrono::milliseconds(1));
     }
   }
 
@@ -2043,7 +2158,7 @@ protected:
     t_ = thread([&]() { ASSERT_TRUE(svr_.listen(HOST, PORT)); });
 
     while (!svr_.is_running()) {
-      msleep(1);
+      std::this_thread::sleep_for(std::chrono::milliseconds(1));
     }
   }
 
@@ -2138,10 +2253,9 @@ TEST(SSLClientServerTest, ClientCertPresent) {
   });
 
   thread t = thread([&]() { ASSERT_TRUE(svr.listen(HOST, PORT)); });
-  msleep(1);
+  std::this_thread::sleep_for(std::chrono::milliseconds(1));
 
-  httplib::SSLClient cli(HOST, PORT, CLIENT_CERT_FILE,
-                         CLIENT_PRIVATE_KEY_FILE);
+  httplib::SSLClient cli(HOST, PORT, CLIENT_CERT_FILE, CLIENT_PRIVATE_KEY_FILE);
   auto res = cli.Get("/test");
   cli.set_timeout_sec(30);
   ASSERT_TRUE(res != nullptr);
@@ -2158,7 +2272,7 @@ TEST(SSLClientServerTest, ClientCertMissing) {
   svr.Get("/test", [&](const Request &, Response &) { ASSERT_TRUE(false); });
 
   thread t = thread([&]() { ASSERT_TRUE(svr.listen(HOST, PORT)); });
-  msleep(1);
+  std::this_thread::sleep_for(std::chrono::milliseconds(1));
 
   httplib::SSLClient cli(HOST, PORT);
   auto res = cli.Get("/test");
@@ -2180,10 +2294,9 @@ TEST(SSLClientServerTest, TrustDirOptional) {
   });
 
   thread t = thread([&]() { ASSERT_TRUE(svr.listen(HOST, PORT)); });
-  msleep(1);
+  std::this_thread::sleep_for(std::chrono::milliseconds(1));
 
-  httplib::SSLClient cli(HOST, PORT, CLIENT_CERT_FILE,
-                         CLIENT_PRIVATE_KEY_FILE);
+  httplib::SSLClient cli(HOST, PORT, CLIENT_CERT_FILE, CLIENT_PRIVATE_KEY_FILE);
   auto res = cli.Get("/test");
   cli.set_timeout_sec(30);
   ASSERT_TRUE(res != nullptr);

test/test_proxy.cc

@@ -36,12 +36,14 @@ TEST(ProxyTest, SSLDigest) {
 
 // ----------------------------------------------------------------------------
 
-void RedirectTestHTTPBin(Client& cli, const char *path, bool basic) {
+void RedirectProxyText(Client& cli, const char *path, bool basic) {
   cli.set_proxy("localhost", basic ? 3128 : 3129);
   if (basic) {
     cli.set_proxy_basic_auth("hello", "world");
   } else {
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
     cli.set_proxy_digest_auth("hello", "world");
+#endif
   }
   cli.set_follow_location(true);
 
@@ -52,45 +54,45 @@ void RedirectTestHTTPBin(Client& cli, const char *path, bool basic) {
 
 TEST(RedirectTest, HTTPBinNoSSLBasic) {
   Client cli("httpbin.org");
-  RedirectTestHTTPBin(cli, "/redirect/2", true);
-}
-
-TEST(RedirectTest, HTTPBinNoSSLDigest) {
-  Client cli("httpbin.org");
-  RedirectTestHTTPBin(cli, "/redirect/2", false);
+  RedirectProxyText(cli, "/redirect/2", true);
 }
 
 #ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+TEST(RedirectTest, HTTPBinNoSSLDigest) {
+  Client cli("httpbin.org");
+  RedirectProxyText(cli, "/redirect/2", false);
+}
+
 TEST(RedirectTest, HTTPBinSSLBasic) {
   SSLClient cli("httpbin.org");
-  RedirectTestHTTPBin(cli, "/redirect/2", true);
+  RedirectProxyText(cli, "/redirect/2", true);
 }
 
 TEST(RedirectTest, HTTPBinSSLDigest) {
   SSLClient cli("httpbin.org");
-  RedirectTestHTTPBin(cli, "/redirect/2", false);
+  RedirectProxyText(cli, "/redirect/2", false);
 }
 #endif
 
 #ifdef CPPHTTPLIB_OPENSSL_SUPPORT
 TEST(RedirectTest, YouTubeNoSSLBasic) {
   Client cli("youtube.com");
-  RedirectTestHTTPBin(cli, "/", true);
+  RedirectProxyText(cli, "/", true);
 }
 
 TEST(RedirectTest, YouTubeNoSSLDigest) {
   Client cli("youtube.com");
-  RedirectTestHTTPBin(cli, "/", false);
+  RedirectProxyText(cli, "/", false);
 }
 
 TEST(RedirectTest, YouTubeSSLBasic) {
   SSLClient cli("youtube.com");
-  RedirectTestHTTPBin(cli, "/", true);
+  RedirectProxyText(cli, "/", true);
 }
 
 TEST(RedirectTest, YouTubeSSLDigest) {
   SSLClient cli("youtube.com");
-  RedirectTestHTTPBin(cli, "/", false);
+  RedirectProxyText(cli, "/", false);
 }
 #endif
 
@@ -111,8 +113,7 @@ void BaseAuthTestFromHTTPWatch(Client& cli) {
         cli.Get("/basic-auth/hello/world",
                 {make_basic_authentication_header("hello", "world")});
     ASSERT_TRUE(res != nullptr);
-    EXPECT_EQ(res->body,
-              "{\n  \"authenticated\": true, \n  \"user\": \"hello\"\n}\n");
+    EXPECT_EQ("{\n  \"authenticated\": true, \n  \"user\": \"hello\"\n}\n", res->body);
     EXPECT_EQ(200, res->status);
   }
 
@@ -120,8 +121,7 @@ void BaseAuthTestFromHTTPWatch(Client& cli) {
     cli.set_basic_auth("hello", "world");
     auto res = cli.Get("/basic-auth/hello/world");
     ASSERT_TRUE(res != nullptr);
-    EXPECT_EQ(res->body,
-              "{\n  \"authenticated\": true, \n  \"user\": \"hello\"\n}\n");
+    EXPECT_EQ("{\n  \"authenticated\": true, \n  \"user\": \"hello\"\n}\n", res->body);
     EXPECT_EQ(200, res->status);
   }
 
@@ -150,6 +150,7 @@ TEST(BaseAuthTest, SSL) {
   SSLClient cli("httpbin.org");
   BaseAuthTestFromHTTPWatch(cli);
 }
+#endif
 
 // ----------------------------------------------------------------------------
 
@@ -169,7 +170,6 @@ void DigestAuthTestFromHTTPWatch(Client& cli) {
         "/digest-auth/auth/hello/world/MD5",
         "/digest-auth/auth/hello/world/SHA-256",
         "/digest-auth/auth/hello/world/SHA-512",
-        "/digest-auth/auth-init/hello/world/MD5",
         "/digest-auth/auth-int/hello/world/MD5",
     };
 
@@ -177,8 +177,7 @@ void DigestAuthTestFromHTTPWatch(Client& cli) {
     for (auto path : paths) {
       auto res = cli.Get(path.c_str());
       ASSERT_TRUE(res != nullptr);
-      EXPECT_EQ(res->body,
-                "{\n  \"authenticated\": true, \n  \"user\": \"hello\"\n}\n");
+      EXPECT_EQ("{\n  \"authenticated\": true, \n  \"user\": \"hello\"\n}\n", res->body);
       EXPECT_EQ(200, res->status);
     }
 
@@ -197,7 +196,6 @@ void DigestAuthTestFromHTTPWatch(Client& cli) {
     }
   }
 }
-#endif
 
 TEST(DigestAuthTest, SSL) {
   SSLClient cli("httpbin.org");
@@ -209,3 +207,97 @@ TEST(DigestAuthTest, NoSSL) {
   DigestAuthTestFromHTTPWatch(cli);
 }
 #endif
+
+// ----------------------------------------------------------------------------
+
+void KeepAliveTest(Client& cli, bool basic) {
+  cli.set_proxy("localhost", basic ? 3128 : 3129);
+  if (basic) {
+    cli.set_proxy_basic_auth("hello", "world");
+  } else {
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+    cli.set_proxy_digest_auth("hello", "world");
+#endif
+  }
+
+  cli.set_keep_alive_max_count(4);
+  cli.set_follow_location(true);
+  cli.set_digest_auth("hello", "world");
+
+  std::vector<Request> requests;
+
+  Get(requests, "/get");
+  Get(requests, "/redirect/2");
+
+  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",
+  };
+
+  for (auto path : paths) {
+    Get(requests, path.c_str());
+  }
+
+  {
+    int count = 100;
+    while (count--) {
+      Get(requests, "/get");
+    }
+  }
+
+  std::vector<Response> responses;
+  auto ret = cli.send(requests, responses);
+  ASSERT_TRUE(ret == true);
+  ASSERT_TRUE(requests.size() == responses.size());
+
+  size_t i = 0;
+
+  {
+    auto &res = responses[i++];
+    EXPECT_EQ(200, res.status);
+  }
+
+  {
+    auto &res = responses[i++];
+    EXPECT_EQ(200, res.status);
+  }
+
+
+  {
+    int count = paths.size();
+    while (count--) {
+      auto &res = responses[i++];
+      EXPECT_EQ("{\n  \"authenticated\": true, \n  \"user\": \"hello\"\n}\n", res.body);
+      EXPECT_EQ(200, res.status);
+    }
+  }
+
+  for (; i < responses.size(); i++) {
+    auto &res = responses[i];
+    EXPECT_EQ(200, res.status);
+  }
+}
+
+TEST(KeepAliveTest, NoSSLWithBasic) {
+  Client cli("httpbin.org");
+  KeepAliveTest(cli, true);
+}
+
+TEST(KeepAliveTest, SSLWithBasic) {
+  SSLClient cli("httpbin.org");
+  KeepAliveTest(cli, true);
+}
+
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+TEST(KeepAliveTest, NoSSLWithDigest) {
+  Client cli("httpbin.org");
+  KeepAliveTest(cli, false);
+}
+
+TEST(KeepAliveTest, SSLWithDigest) {
+  SSLClient cli("httpbin.org");
+  KeepAliveTest(cli, false);
+}
+#endif

test/www/dir/test.abcde

@@ -1 +1 @@
-abcde
+abcde