diff options
author | bunnei <bunneidev@gmail.com> | 2020-02-20 03:15:06 +0100 |
---|---|---|
committer | GitHub <noreply@github.com> | 2020-02-20 03:15:06 +0100 |
commit | 2342c0d50e354826d28c5fbc58b76d0047ea5e72 (patch) | |
tree | b188f799411ac05f76b01e3ff74d1047d6267753 | |
parent | Merge pull request #3415 from ReinUsesLisp/texture-code (diff) | |
parent | fix issue with windows getnameinfo() (diff) | |
download | yuzu-2342c0d50e354826d28c5fbc58b76d0047ea5e72.tar yuzu-2342c0d50e354826d28c5fbc58b76d0047ea5e72.tar.gz yuzu-2342c0d50e354826d28c5fbc58b76d0047ea5e72.tar.bz2 yuzu-2342c0d50e354826d28c5fbc58b76d0047ea5e72.tar.lz yuzu-2342c0d50e354826d28c5fbc58b76d0047ea5e72.tar.xz yuzu-2342c0d50e354826d28c5fbc58b76d0047ea5e72.tar.zst yuzu-2342c0d50e354826d28c5fbc58b76d0047ea5e72.zip |
-rw-r--r-- | externals/httplib/README.md | 2 | ||||
-rw-r--r-- | externals/httplib/httplib.h | 2419 | ||||
-rw-r--r-- | src/core/hle/service/bcat/backend/boxcat.cpp | 7 | ||||
-rw-r--r-- | src/web_service/web_backend.cpp | 7 |
4 files changed, 1750 insertions, 685 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 ¶ms); 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 ¶ms); + + std::shared_ptr<Response> Put(const char *path, const Headers &headers, + const Params ¶ms); + 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 ¶ms) { 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 ¶ms) { 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 ¶ms) { + return Put(path, Headers(), params); +} + +inline std::shared_ptr<Response> +Client::Put(const char *path, const Headers &headers, const Params ¶ms) { + 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 diff --git a/src/core/hle/service/bcat/backend/boxcat.cpp b/src/core/hle/service/bcat/backend/boxcat.cpp index 67e39a5c4..f589864ee 100644 --- a/src/core/hle/service/bcat/backend/boxcat.cpp +++ b/src/core/hle/service/bcat/backend/boxcat.cpp @@ -200,7 +200,8 @@ private: DownloadResult DownloadInternal(const std::string& resolved_path, u32 timeout_seconds, const std::string& content_type_name) { if (client == nullptr) { - client = std::make_unique<httplib::SSLClient>(BOXCAT_HOSTNAME, PORT, timeout_seconds); + client = std::make_unique<httplib::SSLClient>(BOXCAT_HOSTNAME, PORT); + client->set_timeout_sec(timeout_seconds); } httplib::Headers headers{ @@ -448,8 +449,8 @@ std::optional<std::vector<u8>> Boxcat::GetLaunchParameter(TitleIDVersion title) Boxcat::StatusResult Boxcat::GetStatus(std::optional<std::string>& global, std::map<std::string, EventStatus>& games) { - httplib::SSLClient client{BOXCAT_HOSTNAME, static_cast<int>(PORT), - static_cast<int>(TIMEOUT_SECONDS)}; + httplib::SSLClient client{BOXCAT_HOSTNAME, static_cast<int>(PORT)}; + client.set_timeout_sec(static_cast<int>(TIMEOUT_SECONDS)); httplib::Headers headers{ {std::string("Game-Assets-API-Version"), std::string(BOXCAT_API_VERSION)}, diff --git a/src/web_service/web_backend.cpp b/src/web_service/web_backend.cpp index 6683f459f..737ffe409 100644 --- a/src/web_service/web_backend.cpp +++ b/src/web_service/web_backend.cpp @@ -73,14 +73,12 @@ struct Client::Impl { if (!parsedUrl.GetPort(&port)) { port = HTTP_PORT; } - cli = std::make_unique<httplib::Client>(parsedUrl.m_Host.c_str(), port, - TIMEOUT_SECONDS); + cli = std::make_unique<httplib::Client>(parsedUrl.m_Host.c_str(), port); } else if (parsedUrl.m_Scheme == "https") { if (!parsedUrl.GetPort(&port)) { port = HTTPS_PORT; } - cli = std::make_unique<httplib::SSLClient>(parsedUrl.m_Host.c_str(), port, - TIMEOUT_SECONDS); + cli = std::make_unique<httplib::SSLClient>(parsedUrl.m_Host.c_str(), port); } else { LOG_ERROR(WebService, "Bad URL scheme {}", parsedUrl.m_Scheme); return Common::WebResult{Common::WebResult::Code::InvalidURL, "Bad URL scheme"}; @@ -90,6 +88,7 @@ struct Client::Impl { LOG_ERROR(WebService, "Invalid URL {}", host + path); return Common::WebResult{Common::WebResult::Code::InvalidURL, "Invalid URL"}; } + cli->set_timeout_sec(TIMEOUT_SECONDS); httplib::Headers params; if (!jwt.empty()) { |