summaryrefslogtreecommitdiffstats
path: root/externals
diff options
context:
space:
mode:
Diffstat (limited to 'externals')
-rw-r--r--externals/httplib/README.md2
-rw-r--r--externals/httplib/httplib.h2419
2 files changed, 1743 insertions, 678 deletions
diff --git a/externals/httplib/README.md b/externals/httplib/README.md
index 0e26522b5..73037d297 100644
--- a/externals/httplib/README.md
+++ b/externals/httplib/README.md
@@ -1,4 +1,4 @@
-From https://github.com/yhirose/cpp-httplib/commit/d9479bc0b12e8a1e8bce2d34da4feeef488581f3
+From https://github.com/yhirose/cpp-httplib/tree/fce8e6fefdab4ad48bc5b25c98e5ebfda4f3cf53
MIT License
diff --git a/externals/httplib/httplib.h b/externals/httplib/httplib.h
index fa2edcc94..e03842e6d 100644
--- a/externals/httplib/httplib.h
+++ b/externals/httplib/httplib.h
@@ -1,7 +1,7 @@
//
// httplib.h
//
-// Copyright (c) 2019 Yuji Hirose. All rights reserved.
+// Copyright (c) 2020 Yuji Hirose. All rights reserved.
// MIT License
//
@@ -11,6 +11,7 @@
/*
* Configuration
*/
+
#ifndef CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND
#define CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND 5
#endif
@@ -40,7 +41,7 @@
#endif
#ifndef CPPHTTPLIB_PAYLOAD_MAX_LENGTH
-#define CPPHTTPLIB_PAYLOAD_MAX_LENGTH (std::numeric_limits<size_t>::max)()
+#define CPPHTTPLIB_PAYLOAD_MAX_LENGTH (std::numeric_limits<size_t>::max())
#endif
#ifndef CPPHTTPLIB_RECV_BUFSIZ
@@ -48,9 +49,14 @@
#endif
#ifndef CPPHTTPLIB_THREAD_POOL_COUNT
-#define CPPHTTPLIB_THREAD_POOL_COUNT 8
+#define CPPHTTPLIB_THREAD_POOL_COUNT \
+ (std::max(1u, std::thread::hardware_concurrency() - 1))
#endif
+/*
+ * Headers
+ */
+
#ifdef _WIN32
#ifndef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
@@ -62,9 +68,9 @@
#if defined(_MSC_VER)
#ifdef _WIN64
-typedef __int64 ssize_t;
+using ssize_t = __int64;
#else
-typedef int ssize_t;
+using ssize_t = int;
#endif
#if _MSC_VER < 1900
@@ -100,7 +106,7 @@ typedef int ssize_t;
#define strcasecmp _stricmp
#endif // strcasecmp
-typedef SOCKET socket_t;
+using socket_t = SOCKET;
#ifdef CPPHTTPLIB_USE_POLL
#define poll(fds, nfds, timeout) WSAPoll(fds, nfds, timeout)
#endif
@@ -109,23 +115,25 @@ typedef SOCKET socket_t;
#include <arpa/inet.h>
#include <cstring>
+#include <ifaddrs.h>
#include <netdb.h>
#include <netinet/in.h>
#ifdef CPPHTTPLIB_USE_POLL
#include <poll.h>
#endif
+#include <csignal>
#include <pthread.h>
-#include <signal.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <unistd.h>
-typedef int socket_t;
+using socket_t = int;
#define INVALID_SOCKET (-1)
#endif //_WIN32
-#include <assert.h>
+#include <array>
#include <atomic>
+#include <cassert>
#include <condition_variable>
#include <errno.h>
#include <fcntl.h>
@@ -143,9 +151,13 @@ typedef int socket_t;
#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
#include <openssl/err.h>
+#include <openssl/md5.h>
#include <openssl/ssl.h>
#include <openssl/x509v3.h>
+#include <iomanip>
+#include <sstream>
+
// #if OPENSSL_VERSION_NUMBER < 0x1010100fL
// #error Sorry, OpenSSL versions prior to 1.1.1 are not supported
// #endif
@@ -162,6 +174,9 @@ inline const unsigned char *ASN1_STRING_get0_data(const ASN1_STRING *asn1) {
#include <zlib.h>
#endif
+/*
+ * Declaration
+ */
namespace httplib {
namespace detail {
@@ -176,37 +191,15 @@ struct ci {
} // namespace detail
-enum class HttpVersion { v1_0 = 0, v1_1 };
-
-typedef std::multimap<std::string, std::string, detail::ci> Headers;
-
-typedef std::multimap<std::string, std::string> Params;
-typedef std::smatch Match;
-
-typedef std::function<void(const char *data, size_t data_len)> DataSink;
-
-typedef std::function<void()> Done;
-
-typedef std::function<void(size_t offset, size_t length, DataSink sink,
- Done done)>
- ContentProvider;
+using Headers = std::multimap<std::string, std::string, detail::ci>;
-typedef std::function<bool(const char *data, size_t data_length, size_t offset,
- uint64_t content_length)>
- ContentReceiver;
+using Params = std::multimap<std::string, std::string>;
+using Match = std::smatch;
-typedef std::function<bool(uint64_t current, uint64_t total)> Progress;
+using Progress = std::function<bool(uint64_t current, uint64_t total)>;
struct Response;
-typedef std::function<bool(const Response &response)> ResponseHandler;
-
-struct MultipartFile {
- std::string filename;
- std::string content_type;
- size_t offset = 0;
- size_t length = 0;
-};
-typedef std::multimap<std::string, MultipartFile> MultipartFiles;
+using ResponseHandler = std::function<bool(const Response &response)>;
struct MultipartFormData {
std::string name;
@@ -214,10 +207,53 @@ struct MultipartFormData {
std::string filename;
std::string content_type;
};
-typedef std::vector<MultipartFormData> MultipartFormDataItems;
+using MultipartFormDataItems = std::vector<MultipartFormData>;
+using MultipartFormDataMap = std::multimap<std::string, MultipartFormData>;
+
+class DataSink {
+public:
+ DataSink() = default;
+ DataSink(const DataSink &) = delete;
+ DataSink &operator=(const DataSink &) = delete;
+ DataSink(DataSink &&) = delete;
+ DataSink &operator=(DataSink &&) = delete;
+
+ std::function<void(const char *data, size_t data_len)> write;
+ std::function<void()> done;
+ std::function<bool()> is_writable;
+};
+
+using ContentProvider =
+ std::function<void(size_t offset, size_t length, DataSink &sink)>;
+
+using ContentReceiver =
+ std::function<bool(const char *data, size_t data_length)>;
+
+using MultipartContentHeader =
+ std::function<bool(const MultipartFormData &file)>;
+
+class ContentReader {
+public:
+ using Reader = std::function<bool(ContentReceiver receiver)>;
+ using MultipartReader = std::function<bool(MultipartContentHeader header,
+ ContentReceiver receiver)>;
+
+ ContentReader(Reader reader, MultipartReader muitlpart_reader)
+ : reader_(reader), muitlpart_reader_(muitlpart_reader) {}
+
+ bool operator()(MultipartContentHeader header,
+ ContentReceiver receiver) const {
+ return muitlpart_reader_(header, receiver);
+ }
+
+ bool operator()(ContentReceiver receiver) const { return reader_(receiver); }
+
+ Reader reader_;
+ MultipartReader muitlpart_reader_;
+};
-typedef std::pair<ssize_t, ssize_t> Range;
-typedef std::vector<Range> Ranges;
+using Range = std::pair<ssize_t, ssize_t>;
+using Ranges = std::vector<Range>;
struct Request {
std::string method;
@@ -229,7 +265,7 @@ struct Request {
std::string version;
std::string target;
Params params;
- MultipartFiles files;
+ MultipartFormDataMap files;
Ranges ranges;
Match matches;
@@ -253,13 +289,19 @@ struct Request {
std::string get_param_value(const char *key, size_t id = 0) const;
size_t get_param_value_count(const char *key) const;
+ bool is_multipart_form_data() const;
+
bool has_file(const char *key) const;
- MultipartFile get_file_value(const char *key) const;
+ MultipartFormData get_file_value(const char *key) const;
+
+ // private members...
+ size_t content_length;
+ ContentProvider content_provider;
};
struct Response {
std::string version;
- int status;
+ int status = -1;
Headers headers;
std::string body;
@@ -269,106 +311,81 @@ struct Response {
void set_header(const char *key, const char *val);
void set_header(const char *key, const std::string &val);
- void set_redirect(const char *uri);
+ void set_redirect(const char *url);
void set_content(const char *s, size_t n, const char *content_type);
void set_content(const std::string &s, const char *content_type);
void set_content_provider(
size_t length,
- std::function<void(size_t offset, size_t length, DataSink sink)> provider,
+ std::function<void(size_t offset, size_t length, DataSink &sink)>
+ provider,
std::function<void()> resource_releaser = [] {});
void set_chunked_content_provider(
- std::function<void(size_t offset, DataSink sink, Done done)> provider,
+ std::function<void(size_t offset, DataSink &sink)> provider,
std::function<void()> resource_releaser = [] {});
- Response() : status(-1), content_provider_resource_length(0) {}
-
+ Response() = default;
+ Response(const Response &) = default;
+ Response &operator=(const Response &) = default;
+ Response(Response &&) = default;
+ Response &operator=(Response &&) = default;
~Response() {
if (content_provider_resource_releaser) {
content_provider_resource_releaser();
}
}
- size_t content_provider_resource_length;
+ // private members...
+ size_t content_length = 0;
ContentProvider content_provider;
std::function<void()> content_provider_resource_releaser;
};
class Stream {
public:
- virtual ~Stream() {}
+ virtual ~Stream() = default;
+
+ virtual bool is_readable() const = 0;
+ virtual bool is_writable() const = 0;
+
virtual int read(char *ptr, size_t size) = 0;
- virtual int write(const char *ptr, size_t size1) = 0;
- virtual int write(const char *ptr) = 0;
- virtual int write(const std::string &s) = 0;
+ virtual int write(const char *ptr, size_t size) = 0;
virtual std::string get_remote_addr() const = 0;
template <typename... Args>
int write_format(const char *fmt, const Args &... args);
-};
-
-class SocketStream : public Stream {
-public:
- SocketStream(socket_t sock);
- virtual ~SocketStream();
-
- virtual int read(char *ptr, size_t size);
- virtual int write(const char *ptr, size_t size);
- virtual int write(const char *ptr);
- virtual int write(const std::string &s);
- virtual std::string get_remote_addr() const;
-
-private:
- socket_t sock_;
-};
-
-class BufferStream : public Stream {
-public:
- BufferStream() {}
- virtual ~BufferStream() {}
-
- virtual int read(char *ptr, size_t size);
- virtual int write(const char *ptr, size_t size);
- virtual int write(const char *ptr);
- virtual int write(const std::string &s);
- virtual std::string get_remote_addr() const;
-
- const std::string &get_buffer() const;
-
-private:
- std::string buffer;
+ int write(const char *ptr);
+ int write(const std::string &s);
};
class TaskQueue {
public:
- TaskQueue() {}
- virtual ~TaskQueue() {}
+ TaskQueue() = default;
+ virtual ~TaskQueue() = default;
virtual void enqueue(std::function<void()> fn) = 0;
virtual void shutdown() = 0;
};
-#if CPPHTTPLIB_THREAD_POOL_COUNT > 0
class ThreadPool : public TaskQueue {
public:
- ThreadPool(size_t n) : shutdown_(false) {
+ explicit ThreadPool(size_t n) : shutdown_(false) {
while (n) {
- auto t = std::make_shared<std::thread>(worker(*this));
- threads_.push_back(t);
+ threads_.emplace_back(worker(*this));
n--;
}
}
ThreadPool(const ThreadPool &) = delete;
- virtual ~ThreadPool() {}
+ ~ThreadPool() override = default;
- virtual void enqueue(std::function<void()> fn) override {
+ void enqueue(std::function<void()> fn) override {
std::unique_lock<std::mutex> lock(mutex_);
jobs_.push_back(fn);
cond_.notify_one();
}
- virtual void shutdown() override {
+ void shutdown() override {
// Stop all worker threads...
{
std::unique_lock<std::mutex> lock(mutex_);
@@ -378,14 +395,14 @@ public:
cond_.notify_all();
// Join...
- for (auto t : threads_) {
- t->join();
+ for (auto &t : threads_) {
+ t.join();
}
}
private:
struct worker {
- worker(ThreadPool &pool) : pool_(pool) {}
+ explicit worker(ThreadPool &pool) : pool_(pool) {}
void operator()() {
for (;;) {
@@ -411,7 +428,7 @@ private:
};
friend struct worker;
- std::vector<std::shared_ptr<std::thread>> threads_;
+ std::vector<std::thread> threads_;
std::list<std::function<void()>> jobs_;
bool shutdown_;
@@ -419,46 +436,16 @@ private:
std::condition_variable cond_;
std::mutex mutex_;
};
-#else
-class Threads : public TaskQueue {
-public:
- Threads() : running_threads_(0) {}
- virtual ~Threads() {}
-
- virtual void enqueue(std::function<void()> fn) override {
- std::thread([=]() {
- {
- std::lock_guard<std::mutex> guard(running_threads_mutex_);
- running_threads_++;
- }
-
- fn();
-
- {
- std::lock_guard<std::mutex> guard(running_threads_mutex_);
- running_threads_--;
- }
- }).detach();
- }
-
- virtual void shutdown() override {
- for (;;) {
- std::this_thread::sleep_for(std::chrono::milliseconds(10));
- std::lock_guard<std::mutex> guard(running_threads_mutex_);
- if (!running_threads_) { break; }
- }
- }
-private:
- std::mutex running_threads_mutex_;
- int running_threads_;
-};
-#endif
+using Logger = std::function<void(const Request &, const Response &)>;
class Server {
public:
- typedef std::function<void(const Request &, Response &)> Handler;
- typedef std::function<void(const Request &, const Response &)> Logger;
+ using Handler = std::function<void(const Request &, Response &)>;
+ using HandlerWithContentReader = std::function<void(
+ const Request &, Response &, const ContentReader &content_reader)>;
+ using Expect100ContinueHandler =
+ std::function<int(const Request &, Response &)>;
Server();
@@ -468,21 +455,32 @@ public:
Server &Get(const char *pattern, Handler handler);
Server &Post(const char *pattern, Handler handler);
-
+ Server &Post(const char *pattern, HandlerWithContentReader handler);
Server &Put(const char *pattern, Handler handler);
+ Server &Put(const char *pattern, HandlerWithContentReader handler);
Server &Patch(const char *pattern, Handler handler);
+ Server &Patch(const char *pattern, HandlerWithContentReader handler);
Server &Delete(const char *pattern, Handler handler);
Server &Options(const char *pattern, Handler handler);
- bool set_base_dir(const char *path);
+ [[deprecated]] bool set_base_dir(const char *dir,
+ const char *mount_point = nullptr);
+ bool set_mount_point(const char *mount_point, const char *dir);
+ bool remove_mount_point(const char *mount_point);
+ void set_file_extension_and_mimetype_mapping(const char *ext,
+ const char *mime);
void set_file_request_handler(Handler handler);
void set_error_handler(Handler handler);
void set_logger(Logger logger);
+ void set_expect_100_continue_handler(Expect100ContinueHandler handler);
+
void set_keep_alive_max_count(size_t count);
+ void set_read_timeout(time_t sec, time_t usec);
void set_payload_max_length(size_t length);
+ bool bind_to_port(const char *host, int port, int socket_flags = 0);
int bind_to_any_port(const char *host, int socket_flags = 0);
bool listen_after_bind();
@@ -496,22 +494,29 @@ public:
protected:
bool process_request(Stream &strm, bool last_connection,
bool &connection_close,
- std::function<void(Request &)> setup_request);
+ const std::function<void(Request &)> &setup_request);
size_t keep_alive_max_count_;
+ time_t read_timeout_sec_;
+ time_t read_timeout_usec_;
size_t payload_max_length_;
private:
- typedef std::vector<std::pair<std::regex, Handler>> Handlers;
+ using Handlers = std::vector<std::pair<std::regex, Handler>>;
+ using HandlersForContentReader =
+ std::vector<std::pair<std::regex, HandlerWithContentReader>>;
socket_t create_server_socket(const char *host, int port,
int socket_flags) const;
int bind_internal(const char *host, int port, int socket_flags);
bool listen_internal();
- bool routing(Request &req, Response &res);
- bool handle_file_request(Request &req, Response &res);
+ bool routing(Request &req, Response &res, Stream &strm, bool last_connection);
+ bool handle_file_request(Request &req, Response &res, bool head = false);
bool dispatch_request(Request &req, Response &res, Handlers &handlers);
+ bool dispatch_request_for_content_reader(Request &req, Response &res,
+ ContentReader content_reader,
+ HandlersForContentReader &handlers);
bool parse_request_line(const char *s, Request &req);
bool write_response(Stream &strm, bool last_connection, const Request &req,
@@ -519,26 +524,43 @@ private:
bool write_content_with_provider(Stream &strm, const Request &req,
Response &res, const std::string &boundary,
const std::string &content_type);
+ bool read_content(Stream &strm, bool last_connection, Request &req,
+ Response &res);
+ bool read_content_with_content_receiver(
+ Stream &strm, bool last_connection, Request &req, Response &res,
+ ContentReceiver receiver, MultipartContentHeader multipart_header,
+ ContentReceiver multipart_receiver);
+ bool read_content_core(Stream &strm, bool last_connection, Request &req,
+ Response &res, ContentReceiver receiver,
+ MultipartContentHeader mulitpart_header,
+ ContentReceiver multipart_receiver);
virtual bool process_and_close_socket(socket_t sock);
std::atomic<bool> is_running_;
std::atomic<socket_t> svr_sock_;
- std::string base_dir_;
+ std::vector<std::pair<std::string, std::string>> base_dirs_;
+ std::map<std::string, std::string> file_extension_and_mimetype_map_;
Handler file_request_handler_;
Handlers get_handlers_;
Handlers post_handlers_;
+ HandlersForContentReader post_handlers_for_content_reader_;
Handlers put_handlers_;
+ HandlersForContentReader put_handlers_for_content_reader_;
Handlers patch_handlers_;
+ HandlersForContentReader patch_handlers_for_content_reader_;
Handlers delete_handlers_;
Handlers options_handlers_;
Handler error_handler_;
Logger logger_;
+ Expect100ContinueHandler expect_100_continue_handler_;
};
class Client {
public:
- Client(const char *host, int port = 80, time_t timeout_sec = 300);
+ explicit Client(const std::string &host, int port = 80,
+ const std::string &client_cert_path = std::string(),
+ const std::string &client_key_path = std::string());
virtual ~Client();
@@ -586,6 +608,15 @@ public:
const std::string &body,
const char *content_type);
+ std::shared_ptr<Response> Post(const char *path, size_t content_length,
+ ContentProvider content_provider,
+ const char *content_type);
+
+ std::shared_ptr<Response> Post(const char *path, const Headers &headers,
+ size_t content_length,
+ ContentProvider content_provider,
+ const char *content_type);
+
std::shared_ptr<Response> Post(const char *path, const Params &params);
std::shared_ptr<Response> Post(const char *path, const Headers &headers,
@@ -604,6 +635,20 @@ public:
const std::string &body,
const char *content_type);
+ std::shared_ptr<Response> Put(const char *path, size_t content_length,
+ ContentProvider content_provider,
+ const char *content_type);
+
+ std::shared_ptr<Response> Put(const char *path, const Headers &headers,
+ size_t content_length,
+ ContentProvider content_provider,
+ const char *content_type);
+
+ std::shared_ptr<Response> Put(const char *path, const Params &params);
+
+ std::shared_ptr<Response> Put(const char *path, const Headers &headers,
+ const Params &params);
+
std::shared_ptr<Response> Patch(const char *path, const std::string &body,
const char *content_type);
@@ -611,6 +656,15 @@ public:
const std::string &body,
const char *content_type);
+ std::shared_ptr<Response> Patch(const char *path, size_t content_length,
+ ContentProvider content_provider,
+ const char *content_type);
+
+ std::shared_ptr<Response> Patch(const char *path, const Headers &headers,
+ size_t content_length,
+ ContentProvider content_provider,
+ const char *content_type);
+
std::shared_ptr<Response> Delete(const char *path);
std::shared_ptr<Response> Delete(const char *path, const std::string &body,
@@ -631,9 +685,33 @@ public:
bool send(const std::vector<Request> &requests,
std::vector<Response> &responses);
+ void set_timeout_sec(time_t timeout_sec);
+
+ void set_read_timeout(time_t sec, time_t usec);
+
void set_keep_alive_max_count(size_t count);
- void follow_location(bool on);
+ void set_basic_auth(const char *username, const char *password);
+
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+ void set_digest_auth(const char *username, const char *password);
+#endif
+
+ void set_follow_location(bool on);
+
+ void set_compress(bool on);
+
+ void set_interface(const char *intf);
+
+ void set_proxy(const char *host, int port);
+
+ void set_proxy_basic_auth(const char *username, const char *password);
+
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+ void set_proxy_digest_auth(const char *username, const char *password);
+#endif
+
+ void set_logger(Logger logger);
protected:
bool process_request(Stream &strm, const Request &req, Response &res,
@@ -641,16 +719,85 @@ protected:
const std::string host_;
const int port_;
- time_t timeout_sec_;
const std::string host_and_port_;
- size_t keep_alive_max_count_;
- size_t follow_location_;
+
+ // Settings
+ std::string client_cert_path_;
+ std::string client_key_path_;
+
+ time_t timeout_sec_ = 300;
+ time_t read_timeout_sec_ = CPPHTTPLIB_READ_TIMEOUT_SECOND;
+ time_t read_timeout_usec_ = CPPHTTPLIB_READ_TIMEOUT_USECOND;
+
+ size_t keep_alive_max_count_ = CPPHTTPLIB_KEEPALIVE_MAX_COUNT;
+
+ std::string basic_auth_username_;
+ std::string basic_auth_password_;
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+ std::string digest_auth_username_;
+ std::string digest_auth_password_;
+#endif
+
+ bool follow_location_ = false;
+
+ bool compress_ = false;
+
+ std::string interface_;
+
+ std::string proxy_host_;
+ int proxy_port_;
+
+ std::string proxy_basic_auth_username_;
+ std::string proxy_basic_auth_password_;
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+ std::string proxy_digest_auth_username_;
+ std::string proxy_digest_auth_password_;
+#endif
+
+ Logger logger_;
+
+ void copy_settings(const Client &rhs) {
+ client_cert_path_ = rhs.client_cert_path_;
+ client_key_path_ = rhs.client_key_path_;
+ timeout_sec_ = rhs.timeout_sec_;
+ read_timeout_sec_ = rhs.read_timeout_sec_;
+ read_timeout_usec_ = rhs.read_timeout_usec_;
+ keep_alive_max_count_ = rhs.keep_alive_max_count_;
+ basic_auth_username_ = rhs.basic_auth_username_;
+ basic_auth_password_ = rhs.basic_auth_password_;
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+ digest_auth_username_ = rhs.digest_auth_username_;
+ digest_auth_password_ = rhs.digest_auth_password_;
+#endif
+ follow_location_ = rhs.follow_location_;
+ compress_ = rhs.compress_;
+ interface_ = rhs.interface_;
+ proxy_host_ = rhs.proxy_host_;
+ proxy_port_ = rhs.proxy_port_;
+ proxy_basic_auth_username_ = rhs.proxy_basic_auth_username_;
+ proxy_basic_auth_password_ = rhs.proxy_basic_auth_password_;
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+ proxy_digest_auth_username_ = rhs.proxy_digest_auth_username_;
+ proxy_digest_auth_password_ = rhs.proxy_digest_auth_password_;
+#endif
+ logger_ = rhs.logger_;
+ }
private:
socket_t create_client_socket() const;
bool read_response_line(Stream &strm, Response &res);
- void write_request(Stream &strm, const Request &req, bool last_connection);
+ bool write_request(Stream &strm, const Request &req, bool last_connection);
bool redirect(const Request &req, Response &res);
+ bool handle_request(Stream &strm, const Request &req, Response &res,
+ bool last_connection, bool &connection_close);
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+ bool connect(socket_t sock, Response &res, bool &error);
+#endif
+
+ std::shared_ptr<Response> send_with_content_provider(
+ const char *method, const char *path, const Headers &headers,
+ const std::string &body, size_t content_length,
+ ContentProvider content_provider, const char *content_type);
virtual bool process_and_close_socket(
socket_t sock, size_t request_count,
@@ -692,22 +839,6 @@ inline void Post(std::vector<Request> &requests, const char *path,
}
#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-class SSLSocketStream : public Stream {
-public:
- SSLSocketStream(socket_t sock, SSL *ssl);
- virtual ~SSLSocketStream();
-
- virtual int read(char *ptr, size_t size);
- virtual int write(const char *ptr, size_t size);
- virtual int write(const char *ptr);
- virtual int write(const std::string &s);
- virtual std::string get_remote_addr() const;
-
-private:
- socket_t sock_;
- SSL *ssl_;
-};
-
class SSLServer : public Server {
public:
SSLServer(const char *cert_path, const char *private_key_path,
@@ -727,9 +858,9 @@ private:
class SSLClient : public Client {
public:
- SSLClient(const char *host, int port = 443, time_t timeout_sec = 300,
- const char *client_cert_path = nullptr,
- const char *client_key_path = nullptr);
+ SSLClient(const std::string &host, int port = 443,
+ const std::string &client_cert_path = std::string(),
+ const std::string &client_key_path = std::string());
virtual ~SSLClient();
@@ -737,11 +868,12 @@ public:
void set_ca_cert_path(const char *ca_ceert_file_path,
const char *ca_cert_dir_path = nullptr);
+
void enable_server_certificate_verification(bool enabled);
long get_openssl_verify_result() const;
- SSL_CTX* ssl_context() const noexcept;
+ SSL_CTX *ssl_context() const noexcept;
private:
virtual bool process_and_close_socket(
@@ -759,6 +891,7 @@ private:
SSL_CTX *ctx_;
std::mutex ctx_mutex_;
std::vector<std::string> host_components_;
+
std::string ca_cert_file_path_;
std::string ca_cert_dir_path_;
bool server_certificate_verification_ = false;
@@ -766,9 +899,12 @@ private:
};
#endif
+// ----------------------------------------------------------------------------
+
/*
* Implementation
*/
+
namespace detail {
inline bool is_hex(char c, int &v) {
@@ -932,8 +1068,8 @@ inline void read_file(const std::string &path, std::string &out) {
inline std::string file_extension(const std::string &path) {
std::smatch m;
- auto pat = std::regex("\\.([a-zA-Z0-9]+)$");
- if (std::regex_search(path, m, pat)) { return m[1].str(); }
+ static auto re = std::regex("\\.([a-zA-Z0-9]+)$");
+ if (std::regex_search(path, m, re)) { return m[1].str(); }
return std::string();
}
@@ -976,6 +1112,11 @@ public:
}
}
+ bool end_with_crlf() const {
+ auto end = ptr() + size();
+ return size() >= 2 && end[-2] == '\r' && end[-1] == '\n';
+ }
+
bool getline() {
fixed_buffer_used_size_ = 0;
glowable_buffer_.clear();
@@ -1019,7 +1160,7 @@ private:
Stream &strm_;
char *fixed_buffer_;
const size_t fixed_buffer_size_;
- size_t fixed_buffer_used_size_;
+ size_t fixed_buffer_used_size_ = 0;
std::string glowable_buffer_;
};
@@ -1053,6 +1194,28 @@ inline int select_read(socket_t sock, time_t sec, time_t usec) {
#endif
}
+inline int select_write(socket_t sock, time_t sec, time_t usec) {
+#ifdef CPPHTTPLIB_USE_POLL
+ struct pollfd pfd_read;
+ pfd_read.fd = sock;
+ pfd_read.events = POLLOUT;
+
+ auto timeout = static_cast<int>(sec * 1000 + usec / 1000);
+
+ return poll(&pfd_read, 1, timeout);
+#else
+ fd_set fds;
+ FD_ZERO(&fds);
+ FD_SET(sock, &fds);
+
+ timeval tv;
+ tv.tv_sec = static_cast<long>(sec);
+ tv.tv_usec = static_cast<long>(usec);
+
+ return select(static_cast<int>(sock + 1), nullptr, &fds, nullptr, &tv);
+#endif
+}
+
inline bool wait_until_socket_is_ready(socket_t sock, time_t sec, time_t usec) {
#ifdef CPPHTTPLIB_USE_POLL
struct pollfd pfd_read;
@@ -1065,7 +1228,8 @@ inline bool wait_until_socket_is_ready(socket_t sock, time_t sec, time_t usec) {
pfd_read.revents & (POLLIN | POLLOUT)) {
int error = 0;
socklen_t len = sizeof(error);
- return getsockopt(sock, SOL_SOCKET, SO_ERROR, reinterpret_cast<char*>(&error), &len) >= 0 &&
+ return getsockopt(sock, SOL_SOCKET, SO_ERROR,
+ reinterpret_cast<char *>(&error), &len) >= 0 &&
!error;
}
return false;
@@ -1085,27 +1249,86 @@ inline bool wait_until_socket_is_ready(socket_t sock, time_t sec, time_t usec) {
(FD_ISSET(sock, &fdsr) || FD_ISSET(sock, &fdsw))) {
int error = 0;
socklen_t len = sizeof(error);
- return getsockopt(sock, SOL_SOCKET, SO_ERROR, (char *)&error, &len) >= 0 &&
+ return getsockopt(sock, SOL_SOCKET, SO_ERROR,
+ reinterpret_cast<char *>(&error), &len) >= 0 &&
!error;
}
return false;
#endif
}
+class SocketStream : public Stream {
+public:
+ SocketStream(socket_t sock, time_t read_timeout_sec,
+ time_t read_timeout_usec);
+ ~SocketStream() override;
+
+ bool is_readable() const override;
+ bool is_writable() const override;
+ int read(char *ptr, size_t size) override;
+ int write(const char *ptr, size_t size) override;
+ std::string get_remote_addr() const override;
+
+private:
+ socket_t sock_;
+ time_t read_timeout_sec_;
+ time_t read_timeout_usec_;
+};
+
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+class SSLSocketStream : public Stream {
+public:
+ SSLSocketStream(socket_t sock, SSL *ssl, time_t read_timeout_sec,
+ time_t read_timeout_usec);
+ virtual ~SSLSocketStream();
+
+ bool is_readable() const override;
+ bool is_writable() const override;
+ int read(char *ptr, size_t size) override;
+ int write(const char *ptr, size_t size) override;
+ std::string get_remote_addr() const override;
+
+private:
+ socket_t sock_;
+ SSL *ssl_;
+ time_t read_timeout_sec_;
+ time_t read_timeout_usec_;
+};
+#endif
+
+class BufferStream : public Stream {
+public:
+ BufferStream() = default;
+ ~BufferStream() override = default;
+
+ bool is_readable() const override;
+ bool is_writable() const override;
+ int read(char *ptr, size_t size) override;
+ int write(const char *ptr, size_t size) override;
+ std::string get_remote_addr() const override;
+
+ const std::string &get_buffer() const;
+
+private:
+ std::string buffer;
+ int position = 0;
+};
+
template <typename T>
-inline bool process_and_close_socket(bool is_client_request, socket_t sock,
- size_t keep_alive_max_count, T callback) {
+inline bool process_socket(bool is_client_request, socket_t sock,
+ size_t keep_alive_max_count, time_t read_timeout_sec,
+ time_t read_timeout_usec, T callback) {
assert(keep_alive_max_count > 0);
- bool ret = false;
+ auto ret = false;
if (keep_alive_max_count > 1) {
auto count = keep_alive_max_count;
while (count > 0 &&
(is_client_request ||
- detail::select_read(sock, CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND,
- CPPHTTPLIB_KEEPALIVE_TIMEOUT_USECOND) > 0)) {
- SocketStream strm(sock);
+ select_read(sock, CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND,
+ CPPHTTPLIB_KEEPALIVE_TIMEOUT_USECOND) > 0)) {
+ SocketStream strm(sock, read_timeout_sec, read_timeout_usec);
auto last_connection = count == 1;
auto connection_close = false;
@@ -1114,12 +1337,22 @@ inline bool process_and_close_socket(bool is_client_request, socket_t sock,
count--;
}
- } else {
- SocketStream strm(sock);
+ } else { // keep_alive_max_count is 0 or 1
+ SocketStream strm(sock, read_timeout_sec, read_timeout_usec);
auto dummy_connection_close = false;
ret = callback(strm, true, dummy_connection_close);
}
+ return ret;
+}
+
+template <typename T>
+inline bool process_and_close_socket(bool is_client_request, socket_t sock,
+ size_t keep_alive_max_count,
+ time_t read_timeout_sec,
+ time_t read_timeout_usec, T callback) {
+ auto ret = process_socket(is_client_request, sock, keep_alive_max_count,
+ read_timeout_sec, read_timeout_usec, callback);
close_socket(sock);
return ret;
}
@@ -1165,6 +1398,23 @@ socket_t create_socket(const char *host, int port, Fn fn,
#ifdef _WIN32
auto sock = WSASocketW(rp->ai_family, rp->ai_socktype, rp->ai_protocol,
nullptr, 0, WSA_FLAG_NO_HANDLE_INHERIT);
+ /**
+ * Since the WSA_FLAG_NO_HANDLE_INHERIT is only supported on Windows 7 SP1
+ * and above the socket creation fails on older Windows Systems.
+ *
+ * Let's try to create a socket the old way in this case.
+ *
+ * Reference:
+ * https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketa
+ *
+ * WSA_FLAG_NO_HANDLE_INHERIT:
+ * This flag is supported on Windows 7 with SP1, Windows Server 2008 R2 with
+ * SP1, and later
+ *
+ */
+ if (sock == INVALID_SOCKET) {
+ sock = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
+ }
#else
auto sock = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
#endif
@@ -1176,9 +1426,11 @@ socket_t create_socket(const char *host, int port, Fn fn,
// Make 'reuse address' option available
int yes = 1;
- setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<char*>(&yes), sizeof(yes));
+ setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<char *>(&yes),
+ sizeof(yes));
#ifdef SO_REUSEPORT
- setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, reinterpret_cast<char*>(&yes), sizeof(yes));
+ setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, reinterpret_cast<char *>(&yes),
+ sizeof(yes));
#endif
// bind or connect
@@ -1213,27 +1465,105 @@ inline bool is_connection_error() {
#endif
}
+inline bool bind_ip_address(socket_t sock, const char *host) {
+ struct addrinfo hints;
+ struct addrinfo *result;
+
+ memset(&hints, 0, sizeof(struct addrinfo));
+ hints.ai_family = AF_UNSPEC;
+ hints.ai_socktype = SOCK_STREAM;
+ hints.ai_protocol = 0;
+
+ if (getaddrinfo(host, "0", &hints, &result)) { return false; }
+
+ auto ret = false;
+ for (auto rp = result; rp; rp = rp->ai_next) {
+ const auto &ai = *rp;
+ if (!::bind(sock, ai.ai_addr, static_cast<int>(ai.ai_addrlen))) {
+ ret = true;
+ break;
+ }
+ }
+
+ freeaddrinfo(result);
+ return ret;
+}
+
+inline std::string if2ip(const std::string &ifn) {
+#ifndef _WIN32
+ struct ifaddrs *ifap;
+ getifaddrs(&ifap);
+ for (auto ifa = ifap; ifa; ifa = ifa->ifa_next) {
+ if (ifa->ifa_addr && ifn == ifa->ifa_name) {
+ if (ifa->ifa_addr->sa_family == AF_INET) {
+ auto sa = reinterpret_cast<struct sockaddr_in *>(ifa->ifa_addr);
+ char buf[INET_ADDRSTRLEN];
+ if (inet_ntop(AF_INET, &sa->sin_addr, buf, INET_ADDRSTRLEN)) {
+ freeifaddrs(ifap);
+ return std::string(buf, INET_ADDRSTRLEN);
+ }
+ }
+ }
+ }
+ freeifaddrs(ifap);
+#endif
+ return std::string();
+}
+
+inline socket_t create_client_socket(const char *host, int port,
+ time_t timeout_sec,
+ const std::string &intf) {
+ return create_socket(
+ host, port, [&](socket_t sock, struct addrinfo &ai) -> bool {
+ if (!intf.empty()) {
+ auto ip = if2ip(intf);
+ if (ip.empty()) { ip = intf; }
+ if (!bind_ip_address(sock, ip.c_str())) { return false; }
+ }
+
+ set_nonblocking(sock, true);
+
+ auto ret = ::connect(sock, ai.ai_addr, static_cast<int>(ai.ai_addrlen));
+ if (ret < 0) {
+ if (is_connection_error() ||
+ !wait_until_socket_is_ready(sock, timeout_sec, 0)) {
+ close_socket(sock);
+ return false;
+ }
+ }
+
+ set_nonblocking(sock, false);
+ return true;
+ });
+}
+
inline std::string get_remote_addr(socket_t sock) {
struct sockaddr_storage addr;
socklen_t len = sizeof(addr);
if (!getpeername(sock, reinterpret_cast<struct sockaddr *>(&addr), &len)) {
- char ipstr[NI_MAXHOST];
+ std::array<char, NI_MAXHOST> ipstr{};
- if (!getnameinfo(reinterpret_cast<struct sockaddr *>(&addr), len, ipstr, sizeof(ipstr),
- nullptr, 0, NI_NUMERICHOST)) {
- return ipstr;
+ if (!getnameinfo(reinterpret_cast<struct sockaddr *>(&addr), len,
+ ipstr.data(), static_cast<unsigned int>(ipstr.size()), nullptr, 0, NI_NUMERICHOST)) {
+ return ipstr.data();
}
}
return std::string();
}
-inline const char *find_content_type(const std::string &path) {
+inline const char *
+find_content_type(const std::string &path,
+ const std::map<std::string, std::string> &user_data) {
auto ext = file_extension(path);
+
+ auto it = user_data.find(ext);
+ if (it != user_data.end()) { return it->second.c_str(); }
+
if (ext == "txt") {
return "text/plain";
- } else if (ext == "html") {
+ } else if (ext == "html" || ext == "htm") {
return "text/html";
} else if (ext == "css") {
return "text/css";
@@ -1253,6 +1583,8 @@ inline const char *find_content_type(const std::string &path) {
return "application/pdf";
} else if (ext == "js") {
return "application/javascript";
+ } else if (ext == "wasm") {
+ return "application/wasm";
} else if (ext == "xml") {
return "application/xml";
} else if (ext == "xhtml") {
@@ -1263,19 +1595,25 @@ inline const char *find_content_type(const std::string &path) {
inline const char *status_message(int status) {
switch (status) {
+ case 100: return "Continue";
case 200: return "OK";
+ case 202: return "Accepted";
+ case 204: return "No Content";
case 206: return "Partial Content";
case 301: return "Moved Permanently";
case 302: return "Found";
case 303: return "See Other";
case 304: return "Not Modified";
case 400: return "Bad Request";
+ case 401: return "Unauthorized";
case 403: return "Forbidden";
case 404: return "Not Found";
case 413: return "Payload Too Large";
case 414: return "Request-URI Too Long";
case 415: return "Unsupported Media Type";
case 416: return "Range Not Satisfiable";
+ case 417: return "Expectation Failed";
+ case 503: return "Service Unavailable";
default:
case 500: return "Internal Server Error";
@@ -1302,18 +1640,18 @@ inline bool compress(std::string &content) {
if (ret != Z_OK) { return false; }
strm.avail_in = content.size();
- strm.next_in = const_cast<Bytef*>(reinterpret_cast<const Bytef*>(content.data()));
+ strm.next_in =
+ const_cast<Bytef *>(reinterpret_cast<const Bytef *>(content.data()));
std::string compressed;
- const auto bufsiz = 16384;
- char buff[bufsiz];
+ std::array<char, 16384> buff{};
do {
- strm.avail_out = bufsiz;
- strm.next_out = reinterpret_cast<Bytef*>(buff);
+ strm.avail_out = buff.size();
+ strm.next_out = reinterpret_cast<Bytef *>(buff.data());
ret = deflate(&strm, Z_FINISH);
assert(ret != Z_STREAM_ERROR);
- compressed.append(buff, bufsiz - strm.avail_out);
+ compressed.append(buff.data(), buff.size() - strm.avail_out);
} while (strm.avail_out == 0);
assert(ret == Z_STREAM_END);
@@ -1347,13 +1685,12 @@ public:
int ret = Z_OK;
strm.avail_in = data_length;
- strm.next_in = const_cast<Bytef*>(reinterpret_cast<const Bytef *>(data));
+ strm.next_in = const_cast<Bytef *>(reinterpret_cast<const Bytef *>(data));
- const auto bufsiz = 16384;
- char buff[bufsiz];
+ std::array<char, 16384> buff{};
do {
- strm.avail_out = bufsiz;
- strm.next_out = reinterpret_cast<Bytef*>(buff);
+ strm.avail_out = buff.size();
+ strm.next_out = reinterpret_cast<Bytef *>(buff.data());
ret = inflate(&strm, Z_NO_FLUSH);
assert(ret != Z_STREAM_ERROR);
@@ -1363,10 +1700,12 @@ public:
case Z_MEM_ERROR: inflateEnd(&strm); return false;
}
- if (!callback(buff, bufsiz - strm.avail_out)) { return false; }
+ if (!callback(buff.data(), buff.size() - strm.avail_out)) {
+ return false;
+ }
} while (strm.avail_out == 0);
- return ret == Z_STREAM_END;
+ return ret == Z_OK || ret == Z_STREAM_END;
}
private:
@@ -1397,18 +1736,35 @@ inline uint64_t get_header_value_uint64(const Headers &headers, const char *key,
}
inline bool read_headers(Stream &strm, Headers &headers) {
- static std::regex re(R"((.+?):\s*(.+?)\s*\r\n)");
-
const auto bufsiz = 2048;
char buf[bufsiz];
-
- stream_line_reader reader(strm, buf, bufsiz);
+ stream_line_reader line_reader(strm, buf, bufsiz);
for (;;) {
- if (!reader.getline()) { return false; }
- if (!strcmp(reader.ptr(), "\r\n")) { break; }
+ if (!line_reader.getline()) { return false; }
+
+ // Check if the line ends with CRLF.
+ if (line_reader.end_with_crlf()) {
+ // Blank line indicates end of headers.
+ if (line_reader.size() == 2) { break; }
+ } else {
+ continue; // Skip invalid line.
+ }
+
+ // Skip trailing spaces and tabs.
+ auto end = line_reader.ptr() + line_reader.size() - 2;
+ while (line_reader.ptr() < end && (end[-1] == ' ' || end[-1] == '\t')) {
+ end--;
+ }
+
+ // Horizontal tab and ' ' are considered whitespace and are ignored when on
+ // the left or right side of the header value:
+ // - https://stackoverflow.com/questions/50179659/
+ // - https://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html
+ static const std::regex re(R"((.+?):[\t ]*(.+))");
+
std::cmatch m;
- if (std::regex_match(reader.ptr(), m, re)) {
+ if (std::regex_match(line_reader.ptr(), end, m, re)) {
auto key = std::string(m[1]);
auto val = std::string(m[2]);
headers.emplace(key, val);
@@ -1418,12 +1774,8 @@ inline bool read_headers(Stream &strm, Headers &headers) {
return true;
}
-typedef std::function<bool(const char *data, size_t data_length)>
- ContentReceiverCore;
-
inline bool read_content_with_length(Stream &strm, uint64_t len,
- Progress progress,
- ContentReceiverCore out) {
+ Progress progress, ContentReceiver out) {
char buf[CPPHTTPLIB_RECV_BUFSIZ];
uint64_t r = 0;
@@ -1455,7 +1807,7 @@ inline void skip_content_with_length(Stream &strm, uint64_t len) {
}
}
-inline bool read_content_without_length(Stream &strm, ContentReceiverCore out) {
+inline bool read_content_without_length(Stream &strm, ContentReceiver out) {
char buf[CPPHTTPLIB_RECV_BUFSIZ];
for (;;) {
auto n = strm.read(buf, CPPHTTPLIB_RECV_BUFSIZ);
@@ -1470,33 +1822,34 @@ inline bool read_content_without_length(Stream &strm, ContentReceiverCore out) {
return true;
}
-inline bool read_content_chunked(Stream &strm, ContentReceiverCore out) {
+inline bool read_content_chunked(Stream &strm, ContentReceiver out) {
const auto bufsiz = 16;
char buf[bufsiz];
- stream_line_reader reader(strm, buf, bufsiz);
+ stream_line_reader line_reader(strm, buf, bufsiz);
- if (!reader.getline()) { return false; }
+ if (!line_reader.getline()) { return false; }
- auto chunk_len = std::stoi(reader.ptr(), 0, 16);
+ auto chunk_len = std::stoi(line_reader.ptr(), 0, 16);
while (chunk_len > 0) {
if (!read_content_with_length(strm, chunk_len, nullptr, out)) {
return false;
}
- if (!reader.getline()) { return false; }
+ if (!line_reader.getline()) { return false; }
- if (strcmp(reader.ptr(), "\r\n")) { break; }
+ if (strcmp(line_reader.ptr(), "\r\n")) { break; }
- if (!reader.getline()) { return false; }
+ if (!line_reader.getline()) { return false; }
- chunk_len = std::stoi(reader.ptr(), 0, 16);
+ chunk_len = std::stoi(line_reader.ptr(), 0, 16);
}
if (chunk_len == 0) {
// Reader terminator after chunks
- if (!reader.getline() || strcmp(reader.ptr(), "\r\n")) return false;
+ if (!line_reader.getline() || strcmp(line_reader.ptr(), "\r\n"))
+ return false;
}
return true;
@@ -1509,14 +1862,14 @@ inline bool is_chunked_transfer_encoding(const Headers &headers) {
template <typename T>
bool read_content(Stream &strm, T &x, size_t payload_max_length, int &status,
- Progress progress, ContentReceiverCore receiver) {
+ Progress progress, ContentReceiver receiver) {
- ContentReceiverCore out = [&](const char *buf, size_t n) {
+ ContentReceiver out = [&](const char *buf, size_t n) {
return receiver(buf, n);
};
#ifdef CPPHTTPLIB_ZLIB_SUPPORT
- detail::decompressor decompressor;
+ decompressor decompressor;
if (!decompressor.is_valid()) {
status = 500;
@@ -1586,39 +1939,47 @@ inline ssize_t write_content(Stream &strm, ContentProvider content_provider,
size_t end_offset = offset + length;
while (offset < end_offset) {
ssize_t written_length = 0;
- content_provider(
- offset, end_offset - offset,
- [&](const char *d, size_t l) {
- offset += l;
- written_length = strm.write(d, l);
- },
- [&](void) { written_length = -1; });
+
+ DataSink data_sink;
+ data_sink.write = [&](const char *d, size_t l) {
+ offset += l;
+ written_length = strm.write(d, l);
+ };
+ data_sink.done = [&](void) { written_length = -1; };
+ data_sink.is_writable = [&](void) { return strm.is_writable(); };
+
+ content_provider(offset, end_offset - offset, data_sink);
if (written_length < 0) { return written_length; }
}
return static_cast<ssize_t>(offset - begin_offset);
}
+template <typename T>
inline ssize_t write_content_chunked(Stream &strm,
- ContentProvider content_provider) {
+ ContentProvider content_provider,
+ T is_shutting_down) {
size_t offset = 0;
auto data_available = true;
ssize_t total_written_length = 0;
- while (data_available) {
+ while (data_available && !is_shutting_down()) {
ssize_t written_length = 0;
- content_provider(
- offset, 0,
- [&](const char *d, size_t l) {
- data_available = l > 0;
- offset += l;
-
- // Emit chunked response header and footer for each chunk
- auto chunk = from_i_to_hex(l) + "\r\n" + std::string(d, l) + "\r\n";
- written_length = strm.write(chunk);
- },
- [&](void) {
- data_available = false;
- written_length = strm.write("0\r\n\r\n");
- });
+
+ DataSink data_sink;
+ data_sink.write = [&](const char *d, size_t l) {
+ data_available = l > 0;
+ offset += l;
+
+ // Emit chunked response header and footer for each chunk
+ auto chunk = from_i_to_hex(l) + "\r\n" + std::string(d, l) + "\r\n";
+ written_length = strm.write(chunk);
+ };
+ data_sink.done = [&](void) {
+ data_available = false;
+ written_length = strm.write("0\r\n\r\n");
+ };
+ data_sink.is_writable = [&](void) { return strm.is_writable(); };
+
+ content_provider(offset, 0, data_sink);
if (written_length < 0) { return written_length; }
total_written_length += written_length;
@@ -1629,17 +1990,12 @@ inline ssize_t write_content_chunked(Stream &strm,
template <typename T>
inline bool redirect(T &cli, const Request &req, Response &res,
const std::string &path) {
- Request new_req;
- new_req.method = req.method;
+ Request new_req = req;
new_req.path = path;
- new_req.headers = req.headers;
- new_req.body = req.body;
- new_req.redirect_count = req.redirect_count - 1;
- new_req.response_handler = req.response_handler;
- new_req.content_receiver = req.content_receiver;
- new_req.progress = req.progress;
+ new_req.redirect_count -= 1;
Response new_res;
+
auto ret = cli.send(new_req, new_res);
if (ret) { res = new_res; }
return ret;
@@ -1656,7 +2012,7 @@ inline std::string encode_url(const std::string &s) {
case '\n': result += "%0A"; break;
case '\'': result += "%27"; break;
case ',': result += "%2C"; break;
- case ':': result += "%3A"; break;
+ // case ':': result += "%3A"; break; // ok? probably...
case ';': result += "%3B"; break;
default:
auto c = static_cast<uint8_t>(s[i]);
@@ -1716,11 +2072,11 @@ inline void parse_query_text(const std::string &s, Params &params) {
split(&s[0], &s[s.size()], '&', [&](const char *b, const char *e) {
std::string key;
std::string val;
- split(b, e, '=', [&](const char *b, const char *e) {
+ 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);
}
});
params.emplace(key, decode_url(val));
@@ -1736,112 +2092,207 @@ inline bool parse_multipart_boundary(const std::string &content_type,
return true;
}
-inline bool parse_multipart_formdata(const std::string &boundary,
- const std::string &body,
- MultipartFiles &files) {
- static std::string dash = "--";
- static std::string crlf = "\r\n";
-
- static std::regex re_content_type("Content-Type: (.*?)",
- std::regex_constants::icase);
-
- static std::regex re_content_disposition(
- "Content-Disposition: form-data; name=\"(.*?)\"(?:; filename=\"(.*?)\")?",
- std::regex_constants::icase);
-
- auto dash_boundary = dash + boundary;
-
- auto pos = body.find(dash_boundary);
- if (pos != 0) { return false; }
-
- pos += dash_boundary.size();
+inline bool parse_range_header(const std::string &s, Ranges &ranges) {
+ static auto re_first_range = std::regex(R"(bytes=(\d*-\d*(?:,\s*\d*-\d*)*))");
+ std::smatch m;
+ if (std::regex_match(s, m, re_first_range)) {
+ auto pos = m.position(1);
+ auto len = m.length(1);
+ bool all_valid_ranges = true;
+ split(&s[pos], &s[pos + len], ',', [&](const char *b, const char *e) {
+ if (!all_valid_ranges) return;
+ static auto re_another_range = std::regex(R"(\s*(\d*)-(\d*))");
+ std::cmatch cm;
+ if (std::regex_match(b, e, cm, re_another_range)) {
+ ssize_t first = -1;
+ if (!cm.str(1).empty()) {
+ first = static_cast<ssize_t>(std::stoll(cm.str(1)));
+ }
- auto next_pos = body.find(crlf, pos);
- if (next_pos == std::string::npos) { return false; }
+ ssize_t last = -1;
+ if (!cm.str(2).empty()) {
+ last = static_cast<ssize_t>(std::stoll(cm.str(2)));
+ }
- pos = next_pos + crlf.size();
+ if (first != -1 && last != -1 && first > last) {
+ all_valid_ranges = false;
+ return;
+ }
+ ranges.emplace_back(std::make_pair(first, last));
+ }
+ });
+ return all_valid_ranges;
+ }
+ return false;
+}
- while (pos < body.size()) {
- next_pos = body.find(crlf, pos);
- if (next_pos == std::string::npos) { return false; }
+class MultipartFormDataParser {
+public:
+ MultipartFormDataParser() {}
- std::string name;
- MultipartFile file;
+ void set_boundary(const std::string &boundary) { boundary_ = boundary; }
- auto header = body.substr(pos, (next_pos - pos));
+ bool is_valid() const { return is_valid_; }
- while (pos != next_pos) {
- std::smatch m;
- if (std::regex_match(header, m, re_content_type)) {
- file.content_type = m[1];
- } else if (std::regex_match(header, m, re_content_disposition)) {
- name = m[1];
- file.filename = m[2];
+ template <typename T, typename U>
+ bool parse(const char *buf, size_t n, T content_callback, U header_callback) {
+ static const std::regex re_content_type(R"(^Content-Type:\s*(.*?)\s*$)",
+ std::regex_constants::icase);
+
+ static const std::regex re_content_disposition(
+ "^Content-Disposition:\\s*form-data;\\s*name=\"(.*?)\"(?:;\\s*filename="
+ "\"(.*?)\")?\\s*$",
+ std::regex_constants::icase);
+
+ buf_.append(buf, n); // TODO: performance improvement
+
+ while (!buf_.empty()) {
+ switch (state_) {
+ case 0: { // Initial boundary
+ auto pattern = dash_ + boundary_ + crlf_;
+ if (pattern.size() > buf_.size()) { return true; }
+ auto pos = buf_.find(pattern);
+ if (pos != 0) {
+ is_done_ = true;
+ return false;
+ }
+ buf_.erase(0, pattern.size());
+ off_ += pattern.size();
+ state_ = 1;
+ break;
}
+ case 1: { // New entry
+ clear_file_info();
+ state_ = 2;
+ break;
+ }
+ case 2: { // Headers
+ auto pos = buf_.find(crlf_);
+ while (pos != std::string::npos) {
+ // Empty line
+ if (pos == 0) {
+ if (!header_callback(file_)) {
+ is_valid_ = false;
+ is_done_ = false;
+ return false;
+ }
+ buf_.erase(0, crlf_.size());
+ off_ += crlf_.size();
+ state_ = 3;
+ break;
+ }
- pos = next_pos + crlf.size();
-
- next_pos = body.find(crlf, pos);
- if (next_pos == std::string::npos) { return false; }
-
- header = body.substr(pos, (next_pos - pos));
- }
-
- pos = next_pos + crlf.size();
+ auto header = buf_.substr(0, pos);
+ {
+ std::smatch m;
+ if (std::regex_match(header, m, re_content_type)) {
+ file_.content_type = m[1];
+ } else if (std::regex_match(header, m, re_content_disposition)) {
+ file_.name = m[1];
+ file_.filename = m[2];
+ }
+ }
- next_pos = body.find(crlf + dash_boundary, pos);
+ buf_.erase(0, pos + crlf_.size());
+ off_ += pos + crlf_.size();
+ pos = buf_.find(crlf_);
+ }
+ break;
+ }
+ case 3: { // Body
+ {
+ auto pattern = crlf_ + dash_;
+ if (pattern.size() > buf_.size()) { return true; }
+
+ auto pos = buf_.find(pattern);
+ if (pos == std::string::npos) { pos = buf_.size(); }
+ if (!content_callback(buf_.data(), pos)) {
+ is_valid_ = false;
+ is_done_ = false;
+ return false;
+ }
- if (next_pos == std::string::npos) { return false; }
+ off_ += pos;
+ buf_.erase(0, pos);
+ }
- file.offset = pos;
- file.length = next_pos - pos;
+ {
+ auto pattern = crlf_ + dash_ + boundary_;
+ if (pattern.size() > buf_.size()) { return true; }
+
+ auto pos = buf_.find(pattern);
+ if (pos != std::string::npos) {
+ if (!content_callback(buf_.data(), pos)) {
+ is_valid_ = false;
+ is_done_ = false;
+ return false;
+ }
- pos = next_pos + crlf.size() + dash_boundary.size();
+ off_ += pos + pattern.size();
+ buf_.erase(0, pos + pattern.size());
+ state_ = 4;
+ } else {
+ if (!content_callback(buf_.data(), pattern.size())) {
+ is_valid_ = false;
+ is_done_ = false;
+ return false;
+ }
- next_pos = body.find(crlf, pos);
- if (next_pos == std::string::npos) { return false; }
+ off_ += pattern.size();
+ buf_.erase(0, pattern.size());
+ }
+ }
+ break;
+ }
+ case 4: { // Boundary
+ if (crlf_.size() > buf_.size()) { return true; }
+ if (buf_.find(crlf_) == 0) {
+ buf_.erase(0, crlf_.size());
+ off_ += crlf_.size();
+ state_ = 1;
+ } else {
+ auto pattern = dash_ + crlf_;
+ if (pattern.size() > buf_.size()) { return true; }
+ if (buf_.find(pattern) == 0) {
+ buf_.erase(0, pattern.size());
+ off_ += pattern.size();
+ is_valid_ = true;
+ state_ = 5;
+ } else {
+ is_done_ = true;
+ return true;
+ }
+ }
+ break;
+ }
+ case 5: { // Done
+ is_valid_ = false;
+ return false;
+ }
+ }
+ }
- files.emplace(name, file);
+ return true;
+ }
- pos = next_pos + crlf.size();
+private:
+ void clear_file_info() {
+ file_.name.clear();
+ file_.filename.clear();
+ file_.content_type.clear();
}
- return true;
-}
+ const std::string dash_ = "--";
+ const std::string crlf_ = "\r\n";
+ std::string boundary_;
-inline bool parse_range_header(const std::string &s, Ranges &ranges) {
- try {
- static auto re = std::regex(R"(bytes=(\d*-\d*(?:,\s*\d*-\d*)*))");
- std::smatch m;
- if (std::regex_match(s, m, re)) {
- auto pos = m.position(1);
- auto len = m.length(1);
- detail::split(&s[pos], &s[pos + len], ',',
- [&](const char *b, const char *e) {
- static auto re = std::regex(R"(\s*(\d*)-(\d*))");
- std::cmatch m;
- if (std::regex_match(b, e, m, re)) {
- ssize_t first = -1;
- if (!m.str(1).empty()) {
- first = static_cast<ssize_t>(std::stoll(m.str(1)));
- }
-
- ssize_t last = -1;
- if (!m.str(2).empty()) {
- last = static_cast<ssize_t>(std::stoll(m.str(2)));
- }
-
- if (first != -1 && last != -1 && first > last) {
- throw std::runtime_error("invalid range error");
- }
- ranges.emplace_back(std::make_pair(first, last));
- }
- });
- return true;
- }
- return false;
- } catch (...) { return false; }
-}
+ std::string buf_;
+ size_t state_ = 0;
+ size_t is_valid_ = false;
+ size_t is_done_ = false;
+ size_t off_ = 0;
+ MultipartFormData file_;
+};
inline std::string to_lower(const char *beg, const char *end) {
std::string out;
@@ -1915,7 +2366,7 @@ bool process_multipart_ranges_data(const Request &req, Response &res,
ctoken("\r\n");
}
- auto offsets = detail::get_range_offset_and_length(req, res.body.size(), i);
+ auto offsets = get_range_offset_and_length(req, res.body.size(), i);
auto offset = offsets.first;
auto length = offsets.second;
@@ -1978,8 +2429,7 @@ inline bool write_multipart_ranges_data(Stream &strm, const Request &req,
[&](const std::string &token) { strm.write(token); },
[&](const char *token) { strm.write(token); },
[&](size_t offset, size_t length) {
- return detail::write_content(strm, res.content_provider, offset,
- length) >= 0;
+ return write_content(strm, res.content_provider, offset, length) >= 0;
});
}
@@ -1988,11 +2438,56 @@ get_range_offset_and_length(const Request &req, const Response &res,
size_t index) {
auto r = req.ranges[index];
- if (r.second == -1) { r.second = res.content_provider_resource_length - 1; }
+ if (r.second == -1) { r.second = res.content_length - 1; }
return std::make_pair(r.first, r.second - r.first + 1);
}
+inline bool expect_content(const Request &req) {
+ if (req.method == "POST" || req.method == "PUT" || req.method == "PATCH" ||
+ req.method == "PRI") {
+ return true;
+ }
+ // TODO: check if Content-Length is set
+ return false;
+}
+
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+template <typename CTX, typename Init, typename Update, typename Final>
+inline std::string message_digest(const std::string &s, Init init,
+ Update update, Final final,
+ size_t digest_length) {
+ using namespace std;
+
+ std::vector<unsigned char> md(digest_length, 0);
+ CTX ctx;
+ init(&ctx);
+ update(&ctx, s.data(), s.size());
+ final(md.data(), &ctx);
+
+ stringstream ss;
+ for (auto c : md) {
+ ss << setfill('0') << setw(2) << hex << (unsigned int)c;
+ }
+ return ss.str();
+}
+
+inline std::string MD5(const std::string &s) {
+ return message_digest<MD5_CTX>(s, MD5_Init, MD5_Update, MD5_Final,
+ MD5_DIGEST_LENGTH);
+}
+
+inline std::string SHA_256(const std::string &s) {
+ return message_digest<SHA256_CTX>(s, SHA256_Init, SHA256_Update, SHA256_Final,
+ SHA256_DIGEST_LENGTH);
+}
+
+inline std::string SHA_512(const std::string &s) {
+ return message_digest<SHA512_CTX>(s, SHA512_Init, SHA512_Update, SHA512_Final,
+ SHA512_DIGEST_LENGTH);
+}
+#endif
+
#ifdef _WIN32
class WSInit {
public:
@@ -2025,9 +2520,103 @@ inline std::pair<std::string, std::string> make_range_header(Ranges ranges) {
inline std::pair<std::string, std::string>
make_basic_authentication_header(const std::string &username,
- const std::string &password) {
+ const std::string &password,
+ bool is_proxy = false) {
auto field = "Basic " + detail::base64_encode(username + ":" + password);
- return std::make_pair("Authorization", field);
+ auto key = is_proxy ? "Proxy-Authorization" : "Authorization";
+ return std::make_pair(key, field);
+}
+
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+inline std::pair<std::string, std::string> make_digest_authentication_header(
+ const Request &req, const std::map<std::string, std::string> &auth,
+ size_t cnonce_count, const std::string &cnonce, const std::string &username,
+ const std::string &password, bool is_proxy = false) {
+ using namespace std;
+
+ string nc;
+ {
+ stringstream ss;
+ ss << setfill('0') << setw(8) << hex << cnonce_count;
+ nc = ss.str();
+ }
+
+ auto qop = auth.at("qop");
+ if (qop.find("auth-int") != std::string::npos) {
+ qop = "auth-int";
+ } else {
+ qop = "auth";
+ }
+
+ std::string algo = "MD5";
+ if (auth.find("algorithm") != auth.end()) { algo = auth.at("algorithm"); }
+
+ string response;
+ {
+ auto H = algo == "SHA-256"
+ ? detail::SHA_256
+ : algo == "SHA-512" ? detail::SHA_512 : detail::MD5;
+
+ auto A1 = username + ":" + auth.at("realm") + ":" + password;
+
+ auto A2 = req.method + ":" + req.path;
+ if (qop == "auth-int") { A2 += ":" + H(req.body); }
+
+ response = H(H(A1) + ":" + auth.at("nonce") + ":" + nc + ":" + cnonce +
+ ":" + qop + ":" + H(A2));
+ }
+
+ auto field = "Digest username=\"hello\", realm=\"" + auth.at("realm") +
+ "\", nonce=\"" + auth.at("nonce") + "\", uri=\"" + req.path +
+ "\", algorithm=" + algo + ", qop=" + qop + ", nc=\"" + nc +
+ "\", cnonce=\"" + cnonce + "\", response=\"" + response + "\"";
+
+ auto key = is_proxy ? "Proxy-Authorization" : "Authorization";
+ return std::make_pair(key, field);
+}
+#endif
+
+inline bool parse_www_authenticate(const httplib::Response &res,
+ std::map<std::string, std::string> &auth,
+ bool is_proxy) {
+ auto auth_key = is_proxy ? "Proxy-Authenticate" : "WWW-Authenticate";
+ if (res.has_header(auth_key)) {
+ static auto re = std::regex(R"~((?:(?:,\s*)?(.+?)=(?:"(.*?)"|([^,]*))))~");
+ auto s = res.get_header_value(auth_key);
+ auto pos = s.find(' ');
+ if (pos != std::string::npos) {
+ auto type = s.substr(0, pos);
+ if (type == "Basic") {
+ return false;
+ } else if (type == "Digest") {
+ s = s.substr(pos + 1);
+ auto beg = std::sregex_iterator(s.begin(), s.end(), re);
+ for (auto i = beg; i != std::sregex_iterator(); ++i) {
+ auto m = *i;
+ auto key = s.substr(m.position(1), m.length(1));
+ auto val = m.length(2) > 0 ? s.substr(m.position(2), m.length(2))
+ : s.substr(m.position(3), m.length(3));
+ auth[key] = val;
+ }
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+// https://stackoverflow.com/questions/440133/how-do-i-create-a-random-alpha-numeric-string-in-c/440240#answer-440240
+inline std::string random_string(size_t length) {
+ auto randchar = []() -> char {
+ const char charset[] = "0123456789"
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+ "abcdefghijklmnopqrstuvwxyz";
+ const size_t max_index = (sizeof(charset) - 1);
+ return charset[rand() % max_index];
+ };
+ std::string str(length, 0);
+ std::generate_n(str.begin(), length, randchar);
+ return str;
}
// Request implementation
@@ -2068,14 +2657,19 @@ inline size_t Request::get_param_value_count(const char *key) const {
return std::distance(r.first, r.second);
}
+inline bool Request::is_multipart_form_data() const {
+ const auto &content_type = get_header_value("Content-Type");
+ return !content_type.find("multipart/form-data");
+}
+
inline bool Request::has_file(const char *key) const {
return files.find(key) != files.end();
}
-inline MultipartFile Request::get_file_value(const char *key) const {
+inline MultipartFormData Request::get_file_value(const char *key) const {
auto it = files.find(key);
if (it != files.end()) { return it->second; }
- return MultipartFile();
+ return MultipartFormData();
}
// Response implementation
@@ -2119,40 +2713,47 @@ inline void Response::set_content(const std::string &s,
}
inline void Response::set_content_provider(
- size_t length,
- std::function<void(size_t offset, size_t length, DataSink sink)> provider,
+ size_t in_length,
+ std::function<void(size_t offset, size_t length, DataSink &sink)> provider,
std::function<void()> resource_releaser) {
- assert(length > 0);
- content_provider_resource_length = length;
- content_provider = [provider](size_t offset, size_t length, DataSink sink,
- Done) { provider(offset, length, sink); };
+ assert(in_length > 0);
+ content_length = in_length;
+ content_provider = [provider](size_t offset, size_t length, DataSink &sink) {
+ provider(offset, length, sink);
+ };
content_provider_resource_releaser = resource_releaser;
}
inline void Response::set_chunked_content_provider(
- std::function<void(size_t offset, DataSink sink, Done done)> provider,
+ std::function<void(size_t offset, DataSink &sink)> provider,
std::function<void()> resource_releaser) {
- content_provider_resource_length = 0;
- content_provider = [provider](size_t offset, size_t, DataSink sink,
- Done done) { provider(offset, sink, done); };
+ content_length = 0;
+ content_provider = [provider](size_t offset, size_t, DataSink &sink) {
+ provider(offset, sink);
+ };
content_provider_resource_releaser = resource_releaser;
}
// Rstream implementation
+inline int Stream::write(const char *ptr) { return write(ptr, strlen(ptr)); }
+
+inline int Stream::write(const std::string &s) {
+ return write(s.data(), s.size());
+}
+
template <typename... Args>
inline int Stream::write_format(const char *fmt, const Args &... args) {
- const auto bufsiz = 2048;
- char buf[bufsiz];
+ std::array<char, 2048> buf;
#if defined(_MSC_VER) && _MSC_VER < 1900
- auto n = _snprintf_s(buf, bufsiz, bufsiz - 1, fmt, args...);
+ auto n = _snprintf_s(buf, bufsiz, buf.size() - 1, fmt, args...);
#else
- auto n = snprintf(buf, bufsiz - 1, fmt, args...);
+ auto n = snprintf(buf.data(), buf.size() - 1, fmt, args...);
#endif
if (n <= 0) { return n; }
- if (n >= bufsiz - 1) {
- std::vector<char> glowable_buf(bufsiz);
+ if (n >= static_cast<int>(buf.size()) - 1) {
+ std::vector<char> glowable_buf(buf.size());
while (n >= static_cast<int>(glowable_buf.size() - 1)) {
glowable_buf.resize(glowable_buf.size() * 2);
@@ -2165,33 +2766,36 @@ inline int Stream::write_format(const char *fmt, const Args &... args) {
}
return write(&glowable_buf[0], n);
} else {
- return write(buf, n);
+ return write(buf.data(), n);
}
}
+namespace detail {
+
// Socket stream implementation
-inline SocketStream::SocketStream(socket_t sock) : sock_(sock) {}
+inline SocketStream::SocketStream(socket_t sock, time_t read_timeout_sec,
+ time_t read_timeout_usec)
+ : sock_(sock), read_timeout_sec_(read_timeout_sec),
+ read_timeout_usec_(read_timeout_usec) {}
inline SocketStream::~SocketStream() {}
-inline int SocketStream::read(char *ptr, size_t size) {
- if (detail::select_read(sock_, CPPHTTPLIB_READ_TIMEOUT_SECOND,
- CPPHTTPLIB_READ_TIMEOUT_USECOND) > 0) {
- return recv(sock_, ptr, static_cast<int>(size), 0);
- }
- return -1;
+inline bool SocketStream::is_readable() const {
+ return detail::select_read(sock_, read_timeout_sec_, read_timeout_usec_) > 0;
}
-inline int SocketStream::write(const char *ptr, size_t size) {
- return send(sock_, ptr, static_cast<int>(size), 0);
+inline bool SocketStream::is_writable() const {
+ return detail::select_write(sock_, 0, 0) > 0;
}
-inline int SocketStream::write(const char *ptr) {
- return write(ptr, strlen(ptr));
+inline int SocketStream::read(char *ptr, size_t size) {
+ if (is_readable()) { return recv(sock_, ptr, static_cast<int>(size), 0); }
+ return -1;
}
-inline int SocketStream::write(const std::string &s) {
- return write(s.data(), s.size());
+inline int SocketStream::write(const char *ptr, size_t size) {
+ if (is_writable()) { return send(sock_, ptr, static_cast<int>(size), 0); }
+ return -1;
}
inline std::string SocketStream::get_remote_addr() const {
@@ -2199,12 +2803,18 @@ inline std::string SocketStream::get_remote_addr() const {
}
// Buffer stream implementation
+inline bool BufferStream::is_readable() const { return true; }
+
+inline bool BufferStream::is_writable() const { return true; }
+
inline int BufferStream::read(char *ptr, size_t size) {
#if defined(_MSC_VER) && _MSC_VER < 1900
- return static_cast<int>(buffer._Copy_s(ptr, size, size));
+ int len_read = static_cast<int>(buffer._Copy_s(ptr, size, size, position));
#else
- return static_cast<int>(buffer.copy(ptr, size));
+ int len_read = static_cast<int>(buffer.copy(ptr, size, position));
#endif
+ position += len_read;
+ return len_read;
}
inline int BufferStream::write(const char *ptr, size_t size) {
@@ -2212,33 +2822,23 @@ inline int BufferStream::write(const char *ptr, size_t size) {
return static_cast<int>(size);
}
-inline int BufferStream::write(const char *ptr) {
- return write(ptr, strlen(ptr));
-}
-
-inline int BufferStream::write(const std::string &s) {
- return write(s.data(), s.size());
-}
-
inline std::string BufferStream::get_remote_addr() const { return ""; }
inline const std::string &BufferStream::get_buffer() const { return buffer; }
+} // namespace detail
+
// HTTP server implementation
inline Server::Server()
: keep_alive_max_count_(CPPHTTPLIB_KEEPALIVE_MAX_COUNT),
+ read_timeout_sec_(CPPHTTPLIB_READ_TIMEOUT_SECOND),
+ read_timeout_usec_(CPPHTTPLIB_READ_TIMEOUT_USECOND),
payload_max_length_(CPPHTTPLIB_PAYLOAD_MAX_LENGTH), is_running_(false),
svr_sock_(INVALID_SOCKET) {
#ifndef _WIN32
signal(SIGPIPE, SIG_IGN);
#endif
- new_task_queue = [] {
-#if CPPHTTPLIB_THREAD_POOL_COUNT > 0
- return new ThreadPool(CPPHTTPLIB_THREAD_POOL_COUNT);
-#else
- return new Threads();
-#endif
- };
+ new_task_queue = [] { return new ThreadPool(CPPHTTPLIB_THREAD_POOL_COUNT); };
}
inline Server::~Server() {}
@@ -2253,16 +2853,37 @@ inline Server &Server::Post(const char *pattern, Handler handler) {
return *this;
}
+inline Server &Server::Post(const char *pattern,
+ HandlerWithContentReader handler) {
+ post_handlers_for_content_reader_.push_back(
+ std::make_pair(std::regex(pattern), handler));
+ return *this;
+}
+
inline Server &Server::Put(const char *pattern, Handler handler) {
put_handlers_.push_back(std::make_pair(std::regex(pattern), handler));
return *this;
}
+inline Server &Server::Put(const char *pattern,
+ HandlerWithContentReader handler) {
+ put_handlers_for_content_reader_.push_back(
+ std::make_pair(std::regex(pattern), handler));
+ return *this;
+}
+
inline Server &Server::Patch(const char *pattern, Handler handler) {
patch_handlers_.push_back(std::make_pair(std::regex(pattern), handler));
return *this;
}
+inline Server &Server::Patch(const char *pattern,
+ HandlerWithContentReader handler) {
+ patch_handlers_for_content_reader_.push_back(
+ std::make_pair(std::regex(pattern), handler));
+ return *this;
+}
+
inline Server &Server::Delete(const char *pattern, Handler handler) {
delete_handlers_.push_back(std::make_pair(std::regex(pattern), handler));
return *this;
@@ -2273,32 +2894,68 @@ inline Server &Server::Options(const char *pattern, Handler handler) {
return *this;
}
-inline bool Server::set_base_dir(const char *path) {
- if (detail::is_dir(path)) {
- base_dir_ = path;
- return true;
+inline bool Server::set_base_dir(const char *dir, const char *mount_point) {
+ return set_mount_point(mount_point, dir);
+}
+
+inline bool Server::set_mount_point(const char *mount_point, const char *dir) {
+ if (detail::is_dir(dir)) {
+ std::string mnt = mount_point ? mount_point : "/";
+ if (!mnt.empty() && mnt[0] == '/') {
+ base_dirs_.emplace_back(mnt, dir);
+ return true;
+ }
+ }
+ return false;
+}
+
+inline bool Server::remove_mount_point(const char *mount_point) {
+ for (auto it = base_dirs_.begin(); it != base_dirs_.end(); ++it) {
+ if (it->first == mount_point) {
+ base_dirs_.erase(it);
+ return true;
+ }
}
return false;
}
+inline void Server::set_file_extension_and_mimetype_mapping(const char *ext,
+ const char *mime) {
+ file_extension_and_mimetype_map_[ext] = mime;
+}
+
inline void Server::set_file_request_handler(Handler handler) {
- file_request_handler_ = handler;
+ file_request_handler_ = std::move(handler);
}
inline void Server::set_error_handler(Handler handler) {
- error_handler_ = handler;
+ error_handler_ = std::move(handler);
}
-inline void Server::set_logger(Logger logger) { logger_ = logger; }
+inline void Server::set_logger(Logger logger) { logger_ = std::move(logger); }
+
+inline void
+Server::set_expect_100_continue_handler(Expect100ContinueHandler handler) {
+ expect_100_continue_handler_ = std::move(handler);
+}
inline void Server::set_keep_alive_max_count(size_t count) {
keep_alive_max_count_ = count;
}
+inline void Server::set_read_timeout(time_t sec, time_t usec) {
+ read_timeout_sec_ = sec;
+ read_timeout_usec_ = usec;
+}
+
inline void Server::set_payload_max_length(size_t length) {
payload_max_length_ = length;
}
+inline bool Server::bind_to_port(const char *host, int port, int socket_flags) {
+ if (bind_internal(host, port, socket_flags) < 0) return false;
+ return true;
+}
inline int Server::bind_to_any_port(const char *host, int socket_flags) {
return bind_internal(host, 0, socket_flags);
}
@@ -2306,8 +2963,7 @@ inline int Server::bind_to_any_port(const char *host, int socket_flags) {
inline bool Server::listen_after_bind() { return listen_internal(); }
inline bool Server::listen(const char *host, int port, int socket_flags) {
- if (bind_internal(host, port, socket_flags) < 0) return false;
- return listen_internal();
+ return bind_to_port(host, port, socket_flags) && listen_internal();
}
inline bool Server::is_running() const { return is_running_; }
@@ -2322,8 +2978,9 @@ inline void Server::stop() {
}
inline bool Server::parse_request_line(const char *s, Request &req) {
- static std::regex re("(GET|HEAD|POST|PUT|DELETE|CONNECT|OPTIONS|TRACE|PATCH|PRI) "
- "(([^?]+)(?:\\?(.+?))?) (HTTP/1\\.[01])\r\n");
+ const static std::regex re(
+ "(GET|HEAD|POST|PUT|DELETE|CONNECT|OPTIONS|TRACE|PATCH|PRI) "
+ "(([^?]+)(?:\\?(.*?))?) (HTTP/1\\.[01])\r\n");
std::cmatch m;
if (std::regex_match(s, m, re)) {
@@ -2348,9 +3005,11 @@ inline bool Server::write_response(Stream &strm, bool last_connection,
if (400 <= res.status && error_handler_) { error_handler_(req, res); }
+ detail::BufferStream bstrm;
+
// Response line
- if (!strm.write_format("HTTP/1.1 %d %s\r\n", res.status,
- detail::status_message(res.status))) {
+ if (!bstrm.write_format("HTTP/1.1 %d %s\r\n", res.status,
+ detail::status_message(res.status))) {
return false;
}
@@ -2363,11 +3022,12 @@ inline bool Server::write_response(Stream &strm, bool last_connection,
res.set_header("Connection", "Keep-Alive");
}
- if (!res.has_header("Content-Type")) {
+ if (!res.has_header("Content-Type") &&
+ (!res.body.empty() || res.content_length > 0)) {
res.set_header("Content-Type", "text/plain");
}
- if (!res.has_header("Accept-Ranges")) {
+ if (!res.has_header("Accept-Ranges") && req.method == "HEAD") {
res.set_header("Accept-Ranges", "bytes");
}
@@ -2388,17 +3048,17 @@ inline bool Server::write_response(Stream &strm, bool last_connection,
}
if (res.body.empty()) {
- if (res.content_provider_resource_length > 0) {
+ if (res.content_length > 0) {
size_t length = 0;
if (req.ranges.empty()) {
- length = res.content_provider_resource_length;
+ length = res.content_length;
} else if (req.ranges.size() == 1) {
- auto offsets = detail::get_range_offset_and_length(
- req, res.content_provider_resource_length, 0);
+ auto offsets =
+ detail::get_range_offset_and_length(req, res.content_length, 0);
auto offset = offsets.first;
length = offsets.second;
auto content_range = detail::make_content_range_header_field(
- offset, length, res.content_provider_resource_length);
+ offset, length, res.content_length);
res.set_header("Content-Range", content_range);
} else {
length = detail::get_multipart_ranges_data_length(req, res, boundary,
@@ -2430,7 +3090,7 @@ inline bool Server::write_response(Stream &strm, bool last_connection,
}
#ifdef CPPHTTPLIB_ZLIB_SUPPORT
- // TODO: 'Accpet-Encoding' has gzip, not gzip;q=0
+ // TODO: 'Accept-Encoding' has gzip, not gzip;q=0
const auto &encodings = req.get_header_value("Accept-Encoding");
if (encodings.find("gzip") != std::string::npos &&
detail::can_compress(res.get_header_value("Content-Type"))) {
@@ -2444,7 +3104,11 @@ inline bool Server::write_response(Stream &strm, bool last_connection,
res.set_header("Content-Length", length);
}
- if (!detail::write_headers(strm, res, Headers())) { return false; }
+ if (!detail::write_headers(bstrm, res, Headers())) { return false; }
+
+ // Flush buffer
+ auto &data = bstrm.get_buffer();
+ strm.write(data.data(), data.size());
// Body
if (req.method != "HEAD") {
@@ -2468,15 +3132,15 @@ inline bool
Server::write_content_with_provider(Stream &strm, const Request &req,
Response &res, const std::string &boundary,
const std::string &content_type) {
- if (res.content_provider_resource_length) {
+ if (res.content_length) {
if (req.ranges.empty()) {
if (detail::write_content(strm, res.content_provider, 0,
- res.content_provider_resource_length) < 0) {
+ res.content_length) < 0) {
return false;
}
} else if (req.ranges.size() == 1) {
- auto offsets = detail::get_range_offset_and_length(
- req, res.content_provider_resource_length, 0);
+ auto offsets =
+ detail::get_range_offset_and_length(req, res.content_length, 0);
auto offset = offsets.first;
auto length = offsets.second;
if (detail::write_content(strm, res.content_provider, offset, length) <
@@ -2490,29 +3154,123 @@ Server::write_content_with_provider(Stream &strm, const Request &req,
}
}
} else {
- if (detail::write_content_chunked(strm, res.content_provider) < 0) {
+ auto is_shutting_down = [this]() {
+ return this->svr_sock_ == INVALID_SOCKET;
+ };
+ if (detail::write_content_chunked(strm, res.content_provider,
+ is_shutting_down) < 0) {
return false;
}
}
return true;
}
-inline bool Server::handle_file_request(Request &req, Response &res) {
- if (!base_dir_.empty() && detail::is_valid_path(req.path)) {
- std::string path = base_dir_ + req.path;
+inline bool Server::read_content(Stream &strm, bool last_connection,
+ Request &req, Response &res) {
+ MultipartFormDataMap::iterator cur;
+ auto ret = read_content_core(
+ strm, last_connection, req, res,
+ // Regular
+ [&](const char *buf, size_t n) {
+ if (req.body.size() + n > req.body.max_size()) { return false; }
+ req.body.append(buf, n);
+ return true;
+ },
+ // Multipart
+ [&](const MultipartFormData &file) {
+ cur = req.files.emplace(file.name, file);
+ return true;
+ },
+ [&](const char *buf, size_t n) {
+ auto &content = cur->second.content;
+ if (content.size() + n > content.max_size()) { return false; }
+ content.append(buf, n);
+ return true;
+ });
- if (!path.empty() && path.back() == '/') { path += "index.html"; }
+ const auto &content_type = req.get_header_value("Content-Type");
+ if (!content_type.find("application/x-www-form-urlencoded")) {
+ detail::parse_query_text(req.body, req.params);
+ }
- if (detail::is_file(path)) {
- detail::read_file(path, res.body);
- auto type = detail::find_content_type(path);
- if (type) { res.set_header("Content-Type", type); }
- res.status = 200;
- if (file_request_handler_) { file_request_handler_(req, res); }
- return true;
+ return ret;
+}
+
+inline bool Server::read_content_with_content_receiver(
+ Stream &strm, bool last_connection, Request &req, Response &res,
+ ContentReceiver receiver, MultipartContentHeader multipart_header,
+ ContentReceiver multipart_receiver) {
+ return read_content_core(strm, last_connection, req, res, receiver,
+ multipart_header, multipart_receiver);
+}
+
+inline bool Server::read_content_core(Stream &strm, bool last_connection,
+ Request &req, Response &res,
+ ContentReceiver receiver,
+ MultipartContentHeader mulitpart_header,
+ ContentReceiver multipart_receiver) {
+ detail::MultipartFormDataParser multipart_form_data_parser;
+ ContentReceiver out;
+
+ if (req.is_multipart_form_data()) {
+ const auto &content_type = req.get_header_value("Content-Type");
+ std::string boundary;
+ if (!detail::parse_multipart_boundary(content_type, boundary)) {
+ res.status = 400;
+ return write_response(strm, last_connection, req, res);
}
+
+ multipart_form_data_parser.set_boundary(boundary);
+ out = [&](const char *buf, size_t n) {
+ return multipart_form_data_parser.parse(buf, n, multipart_receiver,
+ mulitpart_header);
+ };
+ } else {
+ out = receiver;
+ }
+
+ if (!detail::read_content(strm, req, payload_max_length_, res.status,
+ Progress(), out)) {
+ return write_response(strm, last_connection, req, res);
}
+ if (req.is_multipart_form_data()) {
+ if (!multipart_form_data_parser.is_valid()) {
+ res.status = 400;
+ return write_response(strm, last_connection, req, res);
+ }
+ }
+
+ return true;
+}
+
+inline bool Server::handle_file_request(Request &req, Response &res,
+ bool head) {
+ for (const auto &kv : base_dirs_) {
+ const auto &mount_point = kv.first;
+ const auto &base_dir = kv.second;
+
+ // Prefix match
+ if (!req.path.find(mount_point)) {
+ std::string sub_path = "/" + req.path.substr(mount_point.size());
+ if (detail::is_valid_path(sub_path)) {
+ auto path = base_dir + sub_path;
+ if (path.back() == '/') { path += "index.html"; }
+
+ if (detail::is_file(path)) {
+ detail::read_file(path, res.body);
+ auto type =
+ detail::find_content_type(path, file_extension_and_mimetype_map_);
+ if (type) { res.set_header("Content-Type", type); }
+ res.status = 200;
+ if (!head && file_request_handler_) {
+ file_request_handler_(req, res);
+ }
+ return true;
+ }
+ }
+ }
+ }
return false;
}
@@ -2605,9 +3363,51 @@ inline bool Server::listen_internal() {
return ret;
}
-inline bool Server::routing(Request &req, Response &res) {
- if (req.method == "GET" && handle_file_request(req, res)) { return true; }
+inline bool Server::routing(Request &req, Response &res, Stream &strm,
+ bool last_connection) {
+ // File handler
+ bool is_head_request = req.method == "HEAD";
+ if ((req.method == "GET" || is_head_request) &&
+ handle_file_request(req, res, is_head_request)) {
+ return true;
+ }
+
+ if (detail::expect_content(req)) {
+ // Content reader handler
+ {
+ ContentReader reader(
+ [&](ContentReceiver receiver) {
+ return read_content_with_content_receiver(
+ strm, last_connection, req, res, receiver, nullptr, nullptr);
+ },
+ [&](MultipartContentHeader header, ContentReceiver receiver) {
+ return read_content_with_content_receiver(
+ strm, last_connection, req, res, nullptr, header, receiver);
+ });
+
+ if (req.method == "POST") {
+ if (dispatch_request_for_content_reader(
+ req, res, reader, post_handlers_for_content_reader_)) {
+ return true;
+ }
+ } else if (req.method == "PUT") {
+ if (dispatch_request_for_content_reader(
+ req, res, reader, put_handlers_for_content_reader_)) {
+ return true;
+ }
+ } else if (req.method == "PATCH") {
+ if (dispatch_request_for_content_reader(
+ req, res, reader, patch_handlers_for_content_reader_)) {
+ return true;
+ }
+ }
+ }
+ // Read content into `req.body`
+ if (!read_content(strm, last_connection, req, res)) { return false; }
+ }
+
+ // Regular handler
if (req.method == "GET" || req.method == "HEAD") {
return dispatch_request(req, res, get_handlers_);
} else if (req.method == "POST") {
@@ -2640,17 +3440,31 @@ inline bool Server::dispatch_request(Request &req, Response &res,
return false;
}
+inline bool Server::dispatch_request_for_content_reader(
+ Request &req, Response &res, ContentReader content_reader,
+ HandlersForContentReader &handlers) {
+ for (const auto &x : handlers) {
+ const auto &pattern = x.first;
+ const auto &handler = x.second;
+
+ if (std::regex_match(req.path, req.matches, pattern)) {
+ handler(req, res, content_reader);
+ return true;
+ }
+ }
+ return false;
+}
+
inline bool
Server::process_request(Stream &strm, bool last_connection,
bool &connection_close,
- std::function<void(Request &)> setup_request) {
- const auto bufsiz = 2048;
- char buf[bufsiz];
+ const std::function<void(Request &)> &setup_request) {
+ std::array<char, 2048> buf{};
- detail::stream_line_reader reader(strm, buf, bufsiz);
+ detail::stream_line_reader line_reader(strm, buf.data(), buf.size());
// Connection has been closed on client
- if (!reader.getline()) { return false; }
+ if (!line_reader.getline()) { return false; }
Request req;
Response res;
@@ -2658,7 +3472,7 @@ Server::process_request(Stream &strm, bool last_connection,
res.version = "HTTP/1.1";
// Check if the request URI doesn't exceed the limit
- if (reader.size() > CPPHTTPLIB_REQUEST_URI_MAX_LENGTH) {
+ if (line_reader.size() > CPPHTTPLIB_REQUEST_URI_MAX_LENGTH) {
Headers dummy;
detail::read_headers(strm, dummy);
res.status = 414;
@@ -2666,7 +3480,7 @@ Server::process_request(Stream &strm, bool last_connection,
}
// Request line and headers
- if (!parse_request_line(reader.ptr(), req) ||
+ if (!parse_request_line(line_reader.ptr(), req) ||
!detail::read_headers(strm, req.headers)) {
res.status = 400;
return write_response(strm, last_connection, req, res);
@@ -2683,33 +3497,6 @@ Server::process_request(Stream &strm, bool last_connection,
req.set_header("REMOTE_ADDR", strm.get_remote_addr());
- // Body
- if (req.method == "POST" || req.method == "PUT" || req.method == "PATCH" || req.method == "PRI") {
- if (!detail::read_content(strm, req, payload_max_length_, res.status,
- Progress(), [&](const char *buf, size_t n) {
- if (req.body.size() + n > req.body.max_size()) {
- return false;
- }
- req.body.append(buf, n);
- return true;
- })) {
- return write_response(strm, last_connection, req, res);
- }
-
- const auto &content_type = req.get_header_value("Content-Type");
-
- if (!content_type.find("application/x-www-form-urlencoded")) {
- detail::parse_query_text(req.body, req.params);
- } else if (!content_type.find("multipart/form-data")) {
- std::string boundary;
- if (!detail::parse_multipart_boundary(content_type, boundary) ||
- !detail::parse_multipart_formdata(boundary, req.body, req.files)) {
- res.status = 400;
- return write_response(strm, last_connection, req, res);
- }
- }
- }
-
if (req.has_header("Range")) {
const auto &range_header_value = req.get_header_value("Range");
if (!detail::parse_range_header(range_header_value, req.ranges)) {
@@ -2719,7 +3506,23 @@ Server::process_request(Stream &strm, bool last_connection,
if (setup_request) { setup_request(req); }
- if (routing(req, res)) {
+ if (req.get_header_value("Expect") == "100-continue") {
+ auto status = 100;
+ if (expect_100_continue_handler_) {
+ status = expect_100_continue_handler_(req, res);
+ }
+ switch (status) {
+ case 100:
+ case 417:
+ strm.write_format("HTTP/1.1 %d %s\r\n\r\n", status,
+ detail::status_message(status));
+ break;
+ default: return write_response(strm, last_connection, req, res);
+ }
+ }
+
+ // Rounting
+ if (routing(req, res, strm, last_connection)) {
if (res.status == -1) { res.status = req.ranges.empty() ? 200 : 206; }
} else {
if (res.status == -1) { res.status = 404; }
@@ -2732,7 +3535,7 @@ inline bool Server::is_valid() const { return true; }
inline bool Server::process_and_close_socket(socket_t sock) {
return detail::process_and_close_socket(
- false, sock, keep_alive_max_count_,
+ false, sock, keep_alive_max_count_, read_timeout_sec_, read_timeout_usec_,
[this](Stream &strm, bool last_connection, bool &connection_close) {
return process_request(strm, last_connection, connection_close,
nullptr);
@@ -2740,47 +3543,37 @@ inline bool Server::process_and_close_socket(socket_t sock) {
}
// HTTP client implementation
-inline Client::Client(const char *host, int port, time_t timeout_sec)
- : host_(host), port_(port), timeout_sec_(timeout_sec),
+inline Client::Client(const std::string &host, int port,
+ const std::string &client_cert_path,
+ const std::string &client_key_path)
+ : host_(host), port_(port),
host_and_port_(host_ + ":" + std::to_string(port_)),
- keep_alive_max_count_(CPPHTTPLIB_KEEPALIVE_MAX_COUNT),
- follow_location_(false) {}
+ client_cert_path_(client_cert_path), client_key_path_(client_key_path) {}
inline Client::~Client() {}
inline bool Client::is_valid() const { return true; }
inline socket_t Client::create_client_socket() const {
- return detail::create_socket(
- host_.c_str(), port_, [=](socket_t sock, struct addrinfo &ai) -> bool {
- detail::set_nonblocking(sock, true);
-
- auto ret = connect(sock, ai.ai_addr, static_cast<int>(ai.ai_addrlen));
- if (ret < 0) {
- if (detail::is_connection_error() ||
- !detail::wait_until_socket_is_ready(sock, timeout_sec_, 0)) {
- detail::close_socket(sock);
- return false;
- }
- }
-
- detail::set_nonblocking(sock, false);
- return true;
- });
+ if (!proxy_host_.empty()) {
+ return detail::create_client_socket(proxy_host_.c_str(), proxy_port_,
+ timeout_sec_, interface_);
+ }
+ return detail::create_client_socket(host_.c_str(), port_, timeout_sec_,
+ interface_);
}
inline bool Client::read_response_line(Stream &strm, Response &res) {
- const auto bufsiz = 2048;
- char buf[bufsiz];
+ std::array<char, 2048> buf;
- detail::stream_line_reader reader(strm, buf, bufsiz);
+ detail::stream_line_reader line_reader(strm, buf.data(), buf.size());
- if (!reader.getline()) { return false; }
+ if (!line_reader.getline()) { return false; }
const static std::regex re("(HTTP/1\\.[01]) (\\d+?) .*\r\n");
std::cmatch m;
- if (std::regex_match(reader.ptr(), m, re)) {
+ if (std::regex_match(line_reader.ptr(), m, re)) {
res.version = std::string(m[1]);
res.status = std::stoi(std::string(m[2]));
}
@@ -2789,22 +3582,21 @@ inline bool Client::read_response_line(Stream &strm, Response &res) {
}
inline bool Client::send(const Request &req, Response &res) {
- if (req.path.empty()) { return false; }
-
auto sock = create_client_socket();
if (sock == INVALID_SOCKET) { return false; }
- auto ret = process_and_close_socket(
- sock, 1, [&](Stream &strm, bool last_connection, bool &connection_close) {
- return process_request(strm, req, res, last_connection,
- connection_close);
- });
-
- if (ret && follow_location_ && (300 < res.status && res.status < 400)) {
- ret = redirect(req, res);
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+ if (is_ssl() && !proxy_host_.empty()) {
+ bool error;
+ if (!connect(sock, res, error)) { return error; }
}
+#endif
- return ret;
+ return process_and_close_socket(
+ sock, 1, [&](Stream &strm, bool last_connection, bool &connection_close) {
+ return handle_request(strm, req, res, last_connection,
+ connection_close);
+ });
}
inline bool Client::send(const std::vector<Request> &requests,
@@ -2814,32 +3606,136 @@ inline bool Client::send(const std::vector<Request> &requests,
auto sock = create_client_socket();
if (sock == INVALID_SOCKET) { return false; }
- if (!process_and_close_socket(
- sock, requests.size() - i,
- [&](Stream &strm, bool last_connection, bool &connection_close) -> bool {
- auto &req = requests[i];
- auto res = Response();
- i++;
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+ if (is_ssl() && !proxy_host_.empty()) {
+ Response res;
+ bool error;
+ if (!connect(sock, res, error)) { return false; }
+ }
+#endif
+
+ if (!process_and_close_socket(sock, requests.size() - i,
+ [&](Stream &strm, bool last_connection,
+ bool &connection_close) -> bool {
+ auto &req = requests[i++];
+ auto res = Response();
+ auto ret = handle_request(strm, req, res,
+ last_connection,
+ connection_close);
+ if (ret) {
+ responses.emplace_back(std::move(res));
+ }
+ return ret;
+ })) {
+ return false;
+ }
+ }
- if (req.path.empty()) { return false; }
- auto ret = process_request(strm, req, res, last_connection,
- connection_close);
+ return true;
+}
+
+inline bool Client::handle_request(Stream &strm, const Request &req,
+ Response &res, bool last_connection,
+ bool &connection_close) {
+ if (req.path.empty()) { return false; }
+
+ bool ret;
+
+ if (!is_ssl() && !proxy_host_.empty()) {
+ auto req2 = req;
+ req2.path = "http://" + host_and_port_ + req.path;
+ ret = process_request(strm, req2, res, last_connection, connection_close);
+ } else {
+ ret = process_request(strm, req, res, last_connection, connection_close);
+ }
+
+ if (!ret) { return false; }
+
+ if (300 < res.status && res.status < 400 && follow_location_) {
+ ret = redirect(req, res);
+ }
- if (ret && follow_location_ &&
- (300 < res.status && res.status < 400)) {
- ret = redirect(req, res);
- }
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+ if (res.status == 401 || res.status == 407) {
+ auto is_proxy = res.status == 407;
+ const auto &username =
+ is_proxy ? proxy_digest_auth_username_ : digest_auth_username_;
+ const auto &password =
+ is_proxy ? proxy_digest_auth_password_ : digest_auth_password_;
+
+ if (!username.empty() && !password.empty()) {
+ std::map<std::string, std::string> auth;
+ if (parse_www_authenticate(res, auth, is_proxy)) {
+ Request new_req = req;
+ auto key = is_proxy ? "Proxy-Authorization" : "WWW-Authorization";
+ new_req.headers.erase(key);
+ new_req.headers.insert(make_digest_authentication_header(
+ req, auth, 1, random_string(10), username, password, is_proxy));
+
+ Response new_res;
+
+ ret = send(new_req, new_res);
+ if (ret) { res = new_res; }
+ }
+ }
+ }
+#endif
+
+ return ret;
+}
- if (ret) { responses.emplace_back(std::move(res)); }
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+inline bool Client::connect(socket_t sock, Response &res, bool &error) {
+ error = true;
+ Response res2;
+
+ if (!detail::process_socket(
+ true, sock, 1, read_timeout_sec_, read_timeout_usec_,
+ [&](Stream &strm, bool /*last_connection*/, bool &connection_close) {
+ Request req2;
+ req2.method = "CONNECT";
+ req2.path = host_and_port_;
+ return process_request(strm, req2, res2, false, connection_close);
+ })) {
+ detail::close_socket(sock);
+ error = false;
+ return false;
+ }
- return ret;
- })) {
+ if (res2.status == 407) {
+ if (!proxy_digest_auth_username_.empty() &&
+ !proxy_digest_auth_password_.empty()) {
+ std::map<std::string, std::string> auth;
+ if (parse_www_authenticate(res2, auth, true)) {
+ Response res3;
+ if (!detail::process_socket(
+ true, sock, 1, read_timeout_sec_, read_timeout_usec_,
+ [&](Stream &strm, bool /*last_connection*/,
+ bool &connection_close) {
+ Request req3;
+ req3.method = "CONNECT";
+ req3.path = host_and_port_;
+ req3.headers.insert(make_digest_authentication_header(
+ req3, auth, 1, random_string(10),
+ proxy_digest_auth_username_, proxy_digest_auth_password_,
+ true));
+ return process_request(strm, req3, res3, false,
+ connection_close);
+ })) {
+ detail::close_socket(sock);
+ error = false;
+ return false;
+ }
+ }
+ } else {
+ res = res2;
return false;
}
}
return true;
}
+#endif
inline bool Client::redirect(const Request &req, Response &res) {
if (req.redirect_count == 0) { return false; }
@@ -2847,46 +3743,47 @@ inline bool Client::redirect(const Request &req, Response &res) {
auto location = res.get_header_value("location");
if (location.empty()) { return false; }
- std::regex re(
+ const static std::regex re(
R"(^(?:([^:/?#]+):)?(?://([^/?#]*))?([^?#]*(?:\?[^#]*)?)(?:#.*)?)");
+ std::smatch m;
+ if (!regex_match(location, m, re)) { return false; }
+
auto scheme = is_ssl() ? "https" : "http";
- std::smatch m;
- if (regex_match(location, m, re)) {
- auto next_scheme = m[1].str();
- auto next_host = m[2].str();
- auto next_path = m[3].str();
- if (next_host.empty()) { next_host = host_; }
- if (next_path.empty()) { next_path = "/"; }
-
- if (next_scheme == scheme && next_host == host_) {
- return detail::redirect(*this, req, res, next_path);
- } else {
- if (next_scheme == "https") {
+ auto next_scheme = m[1].str();
+ auto next_host = m[2].str();
+ auto next_path = m[3].str();
+ if (next_scheme.empty()) { next_scheme = scheme; }
+ if (next_scheme.empty()) { next_scheme = scheme; }
+ if (next_host.empty()) { next_host = host_; }
+ if (next_path.empty()) { next_path = "/"; }
+
+ if (next_scheme == scheme && next_host == host_) {
+ return detail::redirect(*this, req, res, next_path);
+ } else {
+ if (next_scheme == "https") {
#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- SSLClient cli(next_host.c_str());
- cli.follow_location(true);
- return detail::redirect(cli, req, res, next_path);
+ SSLClient cli(next_host.c_str());
+ cli.copy_settings(*this);
+ return detail::redirect(cli, req, res, next_path);
#else
- return false;
+ return false;
#endif
- } else {
- Client cli(next_host.c_str());
- cli.follow_location(true);
- return detail::redirect(cli, req, res, next_path);
- }
+ } else {
+ Client cli(next_host.c_str());
+ cli.copy_settings(*this);
+ return detail::redirect(cli, req, res, next_path);
}
}
- return false;
}
-inline void Client::write_request(Stream &strm, const Request &req,
+inline bool Client::write_request(Stream &strm, const Request &req,
bool last_connection) {
- BufferStream bstrm;
+ detail::BufferStream bstrm;
// Request line
- auto path = detail::encode_url(req.path);
+ const auto &path = detail::encode_url(req.path);
bstrm.write_format("%s %s HTTP/1.1\r\n", req.method.c_str(), path.c_str());
@@ -2913,11 +3810,14 @@ inline void Client::write_request(Stream &strm, const Request &req,
if (!req.has_header("Accept")) { headers.emplace("Accept", "*/*"); }
if (!req.has_header("User-Agent")) {
- headers.emplace("User-Agent", "cpp-httplib/0.2");
+ headers.emplace("User-Agent", "cpp-httplib/0.5");
}
if (req.body.empty()) {
- if (req.method == "POST" || req.method == "PUT" || req.method == "PATCH") {
+ if (req.content_provider) {
+ auto length = std::to_string(req.content_length);
+ headers.emplace("Content-Length", length);
+ } else {
headers.emplace("Content-Length", "0");
}
} else {
@@ -2931,21 +3831,100 @@ inline void Client::write_request(Stream &strm, const Request &req,
}
}
- detail::write_headers(bstrm, req, headers);
+ if (!basic_auth_username_.empty() && !basic_auth_password_.empty()) {
+ headers.insert(make_basic_authentication_header(
+ basic_auth_username_, basic_auth_password_, false));
+ }
- // Body
- if (!req.body.empty()) { bstrm.write(req.body); }
+ if (!proxy_basic_auth_username_.empty() &&
+ !proxy_basic_auth_password_.empty()) {
+ headers.insert(make_basic_authentication_header(
+ proxy_basic_auth_username_, proxy_basic_auth_password_, true));
+ }
+
+ detail::write_headers(bstrm, req, headers);
// Flush buffer
auto &data = bstrm.get_buffer();
strm.write(data.data(), data.size());
+
+ // Body
+ if (req.body.empty()) {
+ if (req.content_provider) {
+ size_t offset = 0;
+ size_t end_offset = req.content_length;
+
+ DataSink data_sink;
+ data_sink.write = [&](const char *d, size_t l) {
+ auto written_length = strm.write(d, l);
+ offset += written_length;
+ };
+ data_sink.is_writable = [&](void) { return strm.is_writable(); };
+
+ while (offset < end_offset) {
+ req.content_provider(offset, end_offset - offset, data_sink);
+ }
+ }
+ } else {
+ strm.write(req.body);
+ }
+
+ return true;
+}
+
+inline std::shared_ptr<Response> Client::send_with_content_provider(
+ const char *method, const char *path, const Headers &headers,
+ const std::string &body, size_t content_length,
+ ContentProvider content_provider, const char *content_type) {
+ Request req;
+ req.method = method;
+ req.headers = headers;
+ req.path = path;
+
+ req.headers.emplace("Content-Type", content_type);
+
+#ifdef CPPHTTPLIB_ZLIB_SUPPORT
+ if (compress_) {
+ if (content_provider) {
+ size_t offset = 0;
+
+ DataSink data_sink;
+ data_sink.write = [&](const char *data, size_t data_len) {
+ req.body.append(data, data_len);
+ offset += data_len;
+ };
+ data_sink.is_writable = [&](void) { return true; };
+
+ while (offset < content_length) {
+ content_provider(offset, content_length - offset, data_sink);
+ }
+ } else {
+ req.body = body;
+ }
+
+ if (!detail::compress(req.body)) { return nullptr; }
+ req.headers.emplace("Content-Encoding", "gzip");
+ } else
+#endif
+ {
+ if (content_provider) {
+ req.content_length = content_length;
+ req.content_provider = content_provider;
+ } else {
+ req.body = body;
+ }
+ }
+
+ auto res = std::make_shared<Response>();
+
+ return send(req, *res) ? res : nullptr;
}
inline bool Client::process_request(Stream &strm, const Request &req,
Response &res, bool last_connection,
bool &connection_close) {
// Send request
- write_request(strm, req, last_connection);
+ if (!write_request(strm, req, last_connection)) { return false; }
// Receive response and headers
if (!read_response_line(strm, res) ||
@@ -2963,21 +3942,16 @@ inline bool Client::process_request(Stream &strm, const Request &req,
}
// Body
- if (req.method != "HEAD") {
- detail::ContentReceiverCore out = [&](const char *buf, size_t n) {
+ if (req.method != "HEAD" && req.method != "CONNECT") {
+ ContentReceiver out = [&](const char *buf, size_t n) {
if (res.body.size() + n > res.body.max_size()) { return false; }
res.body.append(buf, n);
return true;
};
if (req.content_receiver) {
- auto offset = std::make_shared<size_t>();
- auto length = get_header_value_uint64(res.headers, "Content-Length", 0);
- auto receiver = req.content_receiver;
- out = [offset, length, receiver](const char *buf, size_t n) {
- auto ret = receiver(buf, n, *offset, length);
- (*offset) += n;
- return ret;
+ out = [&](const char *buf, size_t n) {
+ return req.content_receiver(buf, n);
};
}
@@ -2988,6 +3962,9 @@ inline bool Client::process_request(Stream &strm, const Request &req,
}
}
+ // Log
+ if (logger_) { logger_(req, res); }
+
return true;
}
@@ -2997,25 +3974,25 @@ inline bool Client::process_and_close_socket(
bool &connection_close)>
callback) {
request_count = std::min(request_count, keep_alive_max_count_);
- return detail::process_and_close_socket(true, sock, request_count, callback);
+ return detail::process_and_close_socket(true, sock, request_count,
+ read_timeout_sec_, read_timeout_usec_,
+ callback);
}
inline bool Client::is_ssl() const { return false; }
inline std::shared_ptr<Response> Client::Get(const char *path) {
- Progress dummy;
- return Get(path, Headers(), dummy);
+ return Get(path, Headers(), Progress());
}
inline std::shared_ptr<Response> Client::Get(const char *path,
Progress progress) {
- return Get(path, Headers(), progress);
+ return Get(path, Headers(), std::move(progress));
}
inline std::shared_ptr<Response> Client::Get(const char *path,
const Headers &headers) {
- Progress dummy;
- return Get(path, headers, dummy);
+ return Get(path, headers, Progress());
}
inline std::shared_ptr<Response>
@@ -3024,7 +4001,7 @@ Client::Get(const char *path, const Headers &headers, Progress progress) {
req.method = "GET";
req.path = path;
req.headers = headers;
- req.progress = progress;
+ req.progress = std::move(progress);
auto res = std::make_shared<Response>();
return send(req, *res) ? res : nullptr;
@@ -3032,36 +4009,36 @@ Client::Get(const char *path, const Headers &headers, Progress progress) {
inline std::shared_ptr<Response> Client::Get(const char *path,
ContentReceiver content_receiver) {
- Progress dummy;
- return Get(path, Headers(), nullptr, content_receiver, dummy);
+ return Get(path, Headers(), nullptr, std::move(content_receiver), Progress());
}
inline std::shared_ptr<Response> Client::Get(const char *path,
ContentReceiver content_receiver,
Progress progress) {
- return Get(path, Headers(), nullptr, content_receiver, progress);
+ return Get(path, Headers(), nullptr, std::move(content_receiver),
+ std::move(progress));
}
inline std::shared_ptr<Response> Client::Get(const char *path,
const Headers &headers,
ContentReceiver content_receiver) {
- Progress dummy;
- return Get(path, headers, nullptr, content_receiver, dummy);
+ return Get(path, headers, nullptr, std::move(content_receiver), Progress());
}
inline std::shared_ptr<Response> Client::Get(const char *path,
const Headers &headers,
ContentReceiver content_receiver,
Progress progress) {
- return Get(path, headers, nullptr, content_receiver, progress);
+ return Get(path, headers, nullptr, std::move(content_receiver),
+ std::move(progress));
}
inline std::shared_ptr<Response> Client::Get(const char *path,
const Headers &headers,
ResponseHandler response_handler,
ContentReceiver content_receiver) {
- Progress dummy;
- return Get(path, headers, response_handler, content_receiver, dummy);
+ return Get(path, headers, std::move(response_handler), content_receiver,
+ Progress());
}
inline std::shared_ptr<Response> Client::Get(const char *path,
@@ -3073,9 +4050,9 @@ inline std::shared_ptr<Response> Client::Get(const char *path,
req.method = "GET";
req.path = path;
req.headers = headers;
- req.response_handler = response_handler;
- req.content_receiver = content_receiver;
- req.progress = progress;
+ req.response_handler = std::move(response_handler);
+ req.content_receiver = std::move(content_receiver);
+ req.progress = std::move(progress);
auto res = std::make_shared<Response>();
return send(req, *res) ? res : nullptr;
@@ -3107,17 +4084,8 @@ inline std::shared_ptr<Response> Client::Post(const char *path,
const Headers &headers,
const std::string &body,
const char *content_type) {
- Request req;
- req.method = "POST";
- req.headers = headers;
- req.path = path;
-
- req.headers.emplace("Content-Type", content_type);
- req.body = body;
-
- auto res = std::make_shared<Response>();
-
- return send(req, *res) ? res : nullptr;
+ return send_with_content_provider("POST", path, headers, body, 0, nullptr,
+ content_type);
}
inline std::shared_ptr<Response> Client::Post(const char *path,
@@ -3125,6 +4093,21 @@ inline std::shared_ptr<Response> Client::Post(const char *path,
return Post(path, Headers(), params);
}
+inline std::shared_ptr<Response> Client::Post(const char *path,
+ size_t content_length,
+ ContentProvider content_provider,
+ const char *content_type) {
+ return Post(path, Headers(), content_length, content_provider, content_type);
+}
+
+inline std::shared_ptr<Response>
+Client::Post(const char *path, const Headers &headers, size_t content_length,
+ ContentProvider content_provider, const char *content_type) {
+ return send_with_content_provider("POST", path, headers, std::string(),
+ content_length, content_provider,
+ content_type);
+}
+
inline std::shared_ptr<Response>
Client::Post(const char *path, const Headers &headers, const Params &params) {
std::string query;
@@ -3146,35 +4129,28 @@ Client::Post(const char *path, const MultipartFormDataItems &items) {
inline std::shared_ptr<Response>
Client::Post(const char *path, const Headers &headers,
const MultipartFormDataItems &items) {
- Request req;
- req.method = "POST";
- req.headers = headers;
- req.path = path;
-
auto boundary = detail::make_multipart_data_boundary();
- req.headers.emplace("Content-Type",
- "multipart/form-data; boundary=" + boundary);
+ std::string body;
for (const auto &item : items) {
- req.body += "--" + boundary + "\r\n";
- req.body += "Content-Disposition: form-data; name=\"" + item.name + "\"";
+ body += "--" + boundary + "\r\n";
+ body += "Content-Disposition: form-data; name=\"" + item.name + "\"";
if (!item.filename.empty()) {
- req.body += "; filename=\"" + item.filename + "\"";
+ body += "; filename=\"" + item.filename + "\"";
}
- req.body += "\r\n";
+ body += "\r\n";
if (!item.content_type.empty()) {
- req.body += "Content-Type: " + item.content_type + "\r\n";
+ body += "Content-Type: " + item.content_type + "\r\n";
}
- req.body += "\r\n";
- req.body += item.content + "\r\n";
+ body += "\r\n";
+ body += item.content + "\r\n";
}
- req.body += "--" + boundary + "--\r\n";
+ body += "--" + boundary + "--\r\n";
- auto res = std::make_shared<Response>();
-
- return send(req, *res) ? res : nullptr;
+ std::string content_type = "multipart/form-data; boundary=" + boundary;
+ return Post(path, headers, body, content_type.c_str());
}
inline std::shared_ptr<Response> Client::Put(const char *path,
@@ -3187,17 +4163,41 @@ inline std::shared_ptr<Response> Client::Put(const char *path,
const Headers &headers,
const std::string &body,
const char *content_type) {
- Request req;
- req.method = "PUT";
- req.headers = headers;
- req.path = path;
+ return send_with_content_provider("PUT", path, headers, body, 0, nullptr,
+ content_type);
+}
- req.headers.emplace("Content-Type", content_type);
- req.body = body;
+inline std::shared_ptr<Response> Client::Put(const char *path,
+ size_t content_length,
+ ContentProvider content_provider,
+ const char *content_type) {
+ return Put(path, Headers(), content_length, content_provider, content_type);
+}
- auto res = std::make_shared<Response>();
+inline std::shared_ptr<Response>
+Client::Put(const char *path, const Headers &headers, size_t content_length,
+ ContentProvider content_provider, const char *content_type) {
+ return send_with_content_provider("PUT", path, headers, std::string(),
+ content_length, content_provider,
+ content_type);
+}
- return send(req, *res) ? res : nullptr;
+inline std::shared_ptr<Response> Client::Put(const char *path,
+ const Params &params) {
+ return Put(path, Headers(), params);
+}
+
+inline std::shared_ptr<Response>
+Client::Put(const char *path, const Headers &headers, const Params &params) {
+ std::string query;
+ for (auto it = params.begin(); it != params.end(); ++it) {
+ if (it != params.begin()) { query += "&"; }
+ query += it->first;
+ query += "=";
+ query += detail::encode_url(it->second);
+ }
+
+ return Put(path, headers, query, "application/x-www-form-urlencoded");
}
inline std::shared_ptr<Response> Client::Patch(const char *path,
@@ -3210,17 +4210,23 @@ inline std::shared_ptr<Response> Client::Patch(const char *path,
const Headers &headers,
const std::string &body,
const char *content_type) {
- Request req;
- req.method = "PATCH";
- req.headers = headers;
- req.path = path;
-
- req.headers.emplace("Content-Type", content_type);
- req.body = body;
+ return send_with_content_provider("PATCH", path, headers, body, 0, nullptr,
+ content_type);
+}
- auto res = std::make_shared<Response>();
+inline std::shared_ptr<Response> Client::Patch(const char *path,
+ size_t content_length,
+ ContentProvider content_provider,
+ const char *content_type) {
+ return Patch(path, Headers(), content_length, content_provider, content_type);
+}
- return send(req, *res) ? res : nullptr;
+inline std::shared_ptr<Response>
+Client::Patch(const char *path, const Headers &headers, size_t content_length,
+ ContentProvider content_provider, const char *content_type) {
+ return send_with_content_provider("PATCH", path, headers, std::string(),
+ content_length, content_provider,
+ content_type);
}
inline std::shared_ptr<Response> Client::Delete(const char *path) {
@@ -3271,11 +4277,58 @@ inline std::shared_ptr<Response> Client::Options(const char *path,
return send(req, *res) ? res : nullptr;
}
+inline void Client::set_timeout_sec(time_t timeout_sec) {
+ timeout_sec_ = timeout_sec;
+}
+
+inline void Client::set_read_timeout(time_t sec, time_t usec) {
+ read_timeout_sec_ = sec;
+ read_timeout_usec_ = usec;
+}
+
inline void Client::set_keep_alive_max_count(size_t count) {
keep_alive_max_count_ = count;
}
-inline void Client::follow_location(bool on) { follow_location_ = on; }
+inline void Client::set_basic_auth(const char *username, const char *password) {
+ basic_auth_username_ = username;
+ basic_auth_password_ = password;
+}
+
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+inline void Client::set_digest_auth(const char *username,
+ const char *password) {
+ digest_auth_username_ = username;
+ digest_auth_password_ = password;
+}
+#endif
+
+inline void Client::set_follow_location(bool on) { follow_location_ = on; }
+
+inline void Client::set_compress(bool on) { compress_ = on; }
+
+inline void Client::set_interface(const char *intf) { interface_ = intf; }
+
+inline void Client::set_proxy(const char *host, int port) {
+ proxy_host_ = host;
+ proxy_port_ = port;
+}
+
+inline void Client::set_proxy_basic_auth(const char *username,
+ const char *password) {
+ proxy_basic_auth_username_ = username;
+ proxy_basic_auth_password_ = password;
+}
+
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+inline void Client::set_proxy_digest_auth(const char *username,
+ const char *password) {
+ proxy_digest_auth_username_ = username;
+ proxy_digest_auth_password_ = password;
+}
+#endif
+
+inline void Client::set_logger(Logger logger) { logger_ = std::move(logger); }
/*
* SSL Implementation
@@ -3284,11 +4337,10 @@ inline void Client::follow_location(bool on) { follow_location_ = on; }
namespace detail {
template <typename U, typename V, typename T>
-inline bool process_and_close_socket_ssl(bool is_client_request, socket_t sock,
- size_t keep_alive_max_count,
- SSL_CTX *ctx, std::mutex &ctx_mutex,
- U SSL_connect_or_accept, V setup,
- T callback) {
+inline bool process_and_close_socket_ssl(
+ bool is_client_request, socket_t sock, size_t keep_alive_max_count,
+ time_t read_timeout_sec, time_t read_timeout_usec, SSL_CTX *ctx,
+ std::mutex &ctx_mutex, U SSL_connect_or_accept, V setup, T callback) {
assert(keep_alive_max_count > 0);
SSL *ssl = nullptr;
@@ -3316,7 +4368,7 @@ inline bool process_and_close_socket_ssl(bool is_client_request, socket_t sock,
return false;
}
- bool ret = false;
+ auto ret = false;
if (SSL_connect_or_accept(ssl) == 1) {
if (keep_alive_max_count > 1) {
@@ -3325,7 +4377,7 @@ inline bool process_and_close_socket_ssl(bool is_client_request, socket_t sock,
(is_client_request ||
detail::select_read(sock, CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND,
CPPHTTPLIB_KEEPALIVE_TIMEOUT_USECOND) > 0)) {
- SSLSocketStream strm(sock, ssl);
+ SSLSocketStream strm(sock, ssl, read_timeout_sec, read_timeout_usec);
auto last_connection = count == 1;
auto connection_close = false;
@@ -3335,7 +4387,7 @@ inline bool process_and_close_socket_ssl(bool is_client_request, socket_t sock,
count--;
}
} else {
- SSLSocketStream strm(sock, ssl);
+ SSLSocketStream strm(sock, ssl, read_timeout_sec, read_timeout_usec);
auto dummy_connection_close = false;
ret = callback(ssl, strm, true, dummy_connection_close);
}
@@ -3382,11 +4434,20 @@ private:
class SSLInit {
public:
SSLInit() {
+#if OPENSSL_VERSION_NUMBER < 0x1010001fL
SSL_load_error_strings();
SSL_library_init();
+#else
+ OPENSSL_init_ssl(
+ OPENSSL_INIT_LOAD_SSL_STRINGS | OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL);
+#endif
}
- ~SSLInit() { ERR_free_strings(); }
+ ~SSLInit() {
+#if OPENSSL_VERSION_NUMBER < 0x1010001fL
+ ERR_free_strings();
+#endif
+ }
private:
#if OPENSSL_VERSION_NUMBER < 0x10100000L
@@ -3394,41 +4455,44 @@ private:
#endif
};
-static SSLInit sslinit_;
-
-} // namespace detail
-
// SSL socket stream implementation
-inline SSLSocketStream::SSLSocketStream(socket_t sock, SSL *ssl)
- : sock_(sock), ssl_(ssl) {}
+inline SSLSocketStream::SSLSocketStream(socket_t sock, SSL *ssl,
+ time_t read_timeout_sec,
+ time_t read_timeout_usec)
+ : sock_(sock), ssl_(ssl), read_timeout_sec_(read_timeout_sec),
+ read_timeout_usec_(read_timeout_usec) {}
inline SSLSocketStream::~SSLSocketStream() {}
+inline bool SSLSocketStream::is_readable() const {
+ return detail::select_read(sock_, read_timeout_sec_, read_timeout_usec_) > 0;
+}
+
+inline bool SSLSocketStream::is_writable() const {
+ return detail::select_write(sock_, 0, 0) > 0;
+}
+
inline int SSLSocketStream::read(char *ptr, size_t size) {
if (SSL_pending(ssl_) > 0 ||
- detail::select_read(sock_, CPPHTTPLIB_READ_TIMEOUT_SECOND,
- CPPHTTPLIB_READ_TIMEOUT_USECOND) > 0) {
+ select_read(sock_, read_timeout_sec_, read_timeout_usec_) > 0) {
return SSL_read(ssl_, ptr, static_cast<int>(size));
}
return -1;
}
inline int SSLSocketStream::write(const char *ptr, size_t size) {
- return SSL_write(ssl_, ptr, static_cast<int>(size));
-}
-
-inline int SSLSocketStream::write(const char *ptr) {
- return write(ptr, strlen(ptr));
-}
-
-inline int SSLSocketStream::write(const std::string &s) {
- return write(s.data(), s.size());
+ if (is_writable()) { return SSL_write(ssl_, ptr, static_cast<int>(size)); }
+ return -1;
}
inline std::string SSLSocketStream::get_remote_addr() const {
return detail::get_remote_addr(sock_);
}
+static SSLInit sslinit_;
+
+} // namespace detail
+
// SSL HTTP server implementation
inline SSLServer::SSLServer(const char *cert_path, const char *private_key_path,
const char *client_ca_cert_file_path,
@@ -3476,8 +4540,8 @@ inline bool SSLServer::is_valid() const { return ctx_; }
inline bool SSLServer::process_and_close_socket(socket_t sock) {
return detail::process_and_close_socket_ssl(
- false, sock, keep_alive_max_count_, ctx_, ctx_mutex_, SSL_accept,
- [](SSL * /*ssl*/) { return true; },
+ false, sock, keep_alive_max_count_, read_timeout_sec_, read_timeout_usec_,
+ ctx_, ctx_mutex_, SSL_accept, [](SSL * /*ssl*/) { return true; },
[this](SSL *ssl, Stream &strm, bool last_connection,
bool &connection_close) {
return process_request(strm, last_connection, connection_close,
@@ -3486,21 +4550,21 @@ inline bool SSLServer::process_and_close_socket(socket_t sock) {
}
// SSL HTTP client implementation
-inline SSLClient::SSLClient(const char *host, int port, time_t timeout_sec,
- const char *client_cert_path,
- const char *client_key_path)
- : Client(host, port, timeout_sec) {
+inline SSLClient::SSLClient(const std::string &host, int port,
+ const std::string &client_cert_path,
+ const std::string &client_key_path)
+ : Client(host, port, client_cert_path, client_key_path) {
ctx_ = SSL_CTX_new(SSLv23_client_method());
detail::split(&host_[0], &host_[host_.size()], '.',
[&](const char *b, const char *e) {
host_components_.emplace_back(std::string(b, e));
});
- if (client_cert_path && client_key_path) {
- if (SSL_CTX_use_certificate_file(ctx_, client_cert_path,
+ if (!client_cert_path.empty() && !client_key_path.empty()) {
+ if (SSL_CTX_use_certificate_file(ctx_, client_cert_path.c_str(),
SSL_FILETYPE_PEM) != 1 ||
- SSL_CTX_use_PrivateKey_file(ctx_, client_key_path, SSL_FILETYPE_PEM) !=
- 1) {
+ SSL_CTX_use_PrivateKey_file(ctx_, client_key_path.c_str(),
+ SSL_FILETYPE_PEM) != 1) {
SSL_CTX_free(ctx_);
ctx_ = nullptr;
}
@@ -3527,9 +4591,7 @@ inline long SSLClient::get_openssl_verify_result() const {
return verify_result_;
}
-inline SSL_CTX* SSLClient::ssl_context() const noexcept {
- return ctx_;
-}
+inline SSL_CTX *SSLClient::ssl_context() const noexcept { return ctx_; }
inline bool SSLClient::process_and_close_socket(
socket_t sock, size_t request_count,
@@ -3541,7 +4603,8 @@ inline bool SSLClient::process_and_close_socket(
return is_valid() &&
detail::process_and_close_socket_ssl(
- true, sock, request_count, ctx_, ctx_mutex_,
+ true, sock, request_count, read_timeout_sec_, read_timeout_usec_,
+ ctx_, ctx_mutex_,
[&](SSL *ssl) {
if (ca_cert_file_path_.empty()) {
SSL_CTX_set_verify(ctx_, SSL_VERIFY_NONE, nullptr);
@@ -3712,6 +4775,8 @@ inline bool SSLClient::check_host_name(const char *pattern,
}
#endif
+// ----------------------------------------------------------------------------
+
} // namespace httplib
#endif // CPPHTTPLIB_HTTPLIB_H
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-16 03:18:41 +0100