bool operator()(const std::string &s1, const std::string &s2) const {

return std::lexicographical_compare(s1.begin(), s1.end(), s2.begin(),

s2.end(),

[](unsigned char c1, unsigned char c2) {

return ::tolower(c1) < ::tolower(c2);

});

}

std::string name;

std::string content;

std::string filename;

std::string content_type;

DataSink() : os(&sb_), sb_(*this) {}

DataSink(const DataSink &) = delete;

DataSink &operator=(const DataSink &) = delete;

DataSink(DataSink &&) = delete;

DataSink &operator=(DataSink &&) = delete;

std::function<bool(const char *data, size_t data_len)> write;

std::function<void()> done;

std::function<bool()> is_writable;

std::ostream os;

class data_sink_streambuf : public std::streambuf {

public:

explicit data_sink_streambuf(DataSink &sink) : sink_(sink) {}

protected:

std::streamsize xsputn(const char *s, std::streamsize n) {

sink_.write(s, static_cast<size_t>(n));

return n;

}

private:

DataSink &sink_;

};

data_sink_streambuf sb_;

using Reader = std::function<bool(ContentReceiver receiver)>;

using MultipartReader = std::function<bool(MultipartContentHeader header,

ContentReceiver receiver)>;

ContentReader(Reader reader, MultipartReader multipart_reader)

: reader_(std::move(reader)),

multipart_reader_(std::move(multipart_reader)) {}

bool operator()(MultipartContentHeader header,

ContentReceiver receiver) const {

return multipart_reader_(std::move(header), std::move(receiver));

}

bool operator()(ContentReceiver receiver) const {

return reader_(std::move(receiver));

}

Reader reader_;

MultipartReader multipart_reader_;

std::string method;

std::string path;

Headers headers;

std::string body;

std::string remote_addr;

int remote_port = -1;

// for server

std::string version;

std::string target;

Params params;

MultipartFormDataMap files;

Ranges ranges;

Match matches;

// for client

ResponseHandler response_handler;

ContentReceiverWithProgress content_receiver;

Progress progress;

#ifdef CPPHTTPLIB_OPENSSL_SUPPORT

const SSL *ssl = nullptr;

#endif

bool has_header(const char *key) const;

std::string get_header_value(const char *key, size_t id = 0) const;

template <typename T>

T get_header_value(const char *key, size_t id = 0) const;

size_t get_header_value_count(const char *key) const;

void set_header(const char *key, const char *val);

void set_header(const char *key, const std::string &val);

bool has_param(const char *key) const;

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;

MultipartFormData get_file_value(const char *key) const;

// private members...

size_t redirect_count_ = CPPHTTPLIB_REDIRECT_MAX_COUNT;

size_t content_length_ = 0;

ContentProvider content_provider_;

bool is_chunked_content_provider_ = false;

size_t authorization_count_ = 0;

std::string version;

int status = -1;

std::string reason;

Headers headers;

std::string body;

std::string location; // Redirect location

bool has_header(const char *key) const;

std::string get_header_value(const char *key, size_t id = 0) const;

template <typename T>

T get_header_value(const char *key, size_t id = 0) const;

size_t get_header_value_count(const char *key) const;

void set_header(const char *key, const char *val);

void set_header(const char *key, const std::string &val);

void set_redirect(const char *url, int status = 302);

void set_redirect(const std::string &url, int status = 302);

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, const char *content_type, ContentProvider provider,

ContentProviderResourceReleaser resource_releaser = nullptr);

void set_content_provider(

const char *content_type, ContentProviderWithoutLength provider,

ContentProviderResourceReleaser resource_releaser = nullptr);

void set_chunked_content_provider(

const char *content_type, ContentProviderWithoutLength provider,

ContentProviderResourceReleaser resource_releaser = nullptr);

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_(content_provider_success_);

}

}

// private members...

size_t content_length_ = 0;

ContentProvider content_provider_;

ContentProviderResourceReleaser content_provider_resource_releaser_;

bool is_chunked_content_provider_ = false;

bool content_provider_success_ = false;

virtual ~Stream() = default;

virtual bool is_readable() const = 0;

virtual bool is_writable() const = 0;

virtual ssize_t read(char *ptr, size_t size) = 0;

virtual ssize_t write(const char *ptr, size_t size) = 0;

virtual void get_remote_ip_and_port(std::string &ip, int &port) const = 0;

virtual socket_t socket() const = 0;

template <typename... Args>

ssize_t write_format(const char *fmt, const Args &...args);

ssize_t write(const char *ptr);

ssize_t write(const std::string &s);

TaskQueue() = default;

virtual ~TaskQueue() = default;

virtual void enqueue(std::function<void()> fn) = 0;

virtual void shutdown() = 0;

virtual void on_idle(){};

explicit ThreadPool(size_t n) : shutdown_(false) {

while (n) {

threads_.emplace_back(worker(*this));

n--;

}

}

ThreadPool(const ThreadPool &) = delete;

~ThreadPool() override = default;

void enqueue(std::function<void()> fn) override {

std::unique_lock<std::mutex> lock(mutex_);

jobs_.push_back(std::move(fn));

cond_.notify_one();

}

void shutdown() override {

// Stop all worker threads...

{

std::unique_lock<std::mutex> lock(mutex_);

shutdown_ = true;

}

cond_.notify_all();

// Join...

for (auto &t : threads_) {

t.join();

}

}

struct worker {

explicit worker(ThreadPool &pool) : pool_(pool) {}

void operator()() {

for (;;) {

std::function<void()> fn;

{

std::unique_lock<std::mutex> lock(pool_.mutex_);

pool_.cond_.wait(

lock, [&] { return !pool_.jobs_.empty() || pool_.shutdown_; });

if (pool_.shutdown_ && pool_.jobs_.empty()) { break; }

fn = pool_.jobs_.front();

pool_.jobs_.pop_front();

}

assert(true == static_cast<bool>(fn));

fn();

}

}

ThreadPool &pool_;

};

friend struct worker;

std::vector<std::thread> threads_;

std::list<std::function<void()>> jobs_;

bool shutdown_;

std::condition_variable cond_;

std::mutex mutex_;

using Handler = std::function<void(const Request &, Response &)>;

using ExceptionHandler =

std::function<void(const Request &, Response &, std::exception &e)>;

enum class HandlerResponse {

Handled,

Unhandled,

};

using HandlerWithResponse =

std::function<HandlerResponse(const Request &, Response &)>;

using HandlerWithContentReader = std::function<void(

const Request &, Response &, const ContentReader &content_reader)>;

using Expect100ContinueHandler =

std::function<int(const Request &, Response &)>;

Server();

virtual ~Server();

virtual bool is_valid() const;

Server &Get(const std::string &pattern, Handler handler);

Server &Post(const std::string &pattern, Handler handler);

Server &Post(const std::string &pattern, HandlerWithContentReader handler);

Server &Put(const std::string &pattern, Handler handler);

Server &Put(const std::string &pattern, HandlerWithContentReader handler);

Server &Patch(const std::string &pattern, Handler handler);

Server &Patch(const std::string &pattern, HandlerWithContentReader handler);

Server &Delete(const std::string &pattern, Handler handler);

Server &Delete(const std::string &pattern, HandlerWithContentReader handler);

Server &Options(const std::string &pattern, Handler handler);

bool set_base_dir(const std::string &dir,

const std::string &mount_point = std::string());

bool set_mount_point(const std::string &mount_point, const std::string &dir,

Headers headers = Headers());

bool remove_mount_point(const std::string &mount_point);

Server &set_file_extension_and_mimetype_mapping(const char *ext,

const char *mime);

Server &set_file_request_handler(Handler handler);

Server &set_error_handler(HandlerWithResponse handler);

Server &set_error_handler(Handler handler);

Server &set_exception_handler(ExceptionHandler handler);

Server &set_pre_routing_handler(HandlerWithResponse handler);

Server &set_post_routing_handler(Handler handler);

Server &set_expect_100_continue_handler(Expect100ContinueHandler handler);

Server &set_logger(Logger logger);

Server &set_address_family(int family);

Server &set_tcp_nodelay(bool on);

Server &set_socket_options(SocketOptions socket_options);

Server &set_default_headers(Headers headers);

Server &set_keep_alive_max_count(size_t count);

Server &set_keep_alive_timeout(time_t sec);

Server &set_read_timeout(time_t sec, time_t usec = 0);

template <class Rep, class Period>

Server &set_read_timeout(const std::chrono::duration<Rep, Period> &duration);

Server &set_write_timeout(time_t sec, time_t usec = 0);

template <class Rep, class Period>

Server &set_write_timeout(const std::chrono::duration<Rep, Period> &duration);

Server &set_idle_interval(time_t sec, time_t usec = 0);

template <class Rep, class Period>

Server &set_idle_interval(const std::chrono::duration<Rep, Period> &duration);

Server &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();

bool listen(const char *host, int port, int socket_flags = 0);

bool is_running() const;

void stop();

std::function<TaskQueue *(void)> new_task_queue;

bool process_request(Stream &strm, bool close_connection,

bool &connection_closed,

const std::function<void(Request &)> &setup_request);

std::atomic<socket_t> svr_sock_;

size_t keep_alive_max_count_ = CPPHTTPLIB_KEEPALIVE_MAX_COUNT;

time_t keep_alive_timeout_sec_ = CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND;

time_t read_timeout_sec_ = CPPHTTPLIB_READ_TIMEOUT_SECOND;

time_t read_timeout_usec_ = CPPHTTPLIB_READ_TIMEOUT_USECOND;

time_t write_timeout_sec_ = CPPHTTPLIB_WRITE_TIMEOUT_SECOND;

time_t write_timeout_usec_ = CPPHTTPLIB_WRITE_TIMEOUT_USECOND;

time_t idle_interval_sec_ = CPPHTTPLIB_IDLE_INTERVAL_SECOND;

time_t idle_interval_usec_ = CPPHTTPLIB_IDLE_INTERVAL_USECOND;

size_t payload_max_length_ = CPPHTTPLIB_PAYLOAD_MAX_LENGTH;

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,

SocketOptions socket_options) const;

int bind_internal(const char *host, int port, int socket_flags);

bool listen_internal();

bool routing(Request &req, Response &res, Stream &strm);

bool handle_file_request(const Request &req, Response &res,

bool head = false);

bool dispatch_request(Request &req, Response &res, const Handlers &handlers);

bool

dispatch_request_for_content_reader(Request &req, Response &res,

ContentReader content_reader,

const HandlersForContentReader &handlers);

bool parse_request_line(const char *s, Request &req);

void apply_ranges(const Request &req, Response &res,

std::string &content_type, std::string &boundary);

bool write_response(Stream &strm, bool close_connection, const Request &req,

Response &res);

bool write_response_with_content(Stream &strm, bool close_connection,

const Request &req, Response &res);

bool write_response_core(Stream &strm, bool close_connection,

const Request &req, Response &res,

bool need_apply_ranges);

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, Request &req, Response &res);

bool

read_content_with_content_receiver(Stream &strm, Request &req, Response &res,

ContentReceiver receiver,

MultipartContentHeader multipart_header,

ContentReceiver multipart_receiver);

bool read_content_core(Stream &strm, Request &req, Response &res,

ContentReceiver receiver,

MultipartContentHeader mulitpart_header,

ContentReceiver multipart_receiver);

virtual bool process_and_close_socket(socket_t sock);

struct MountPointEntry {

std::string mount_point;

std::string base_dir;

Headers headers;

};

std::vector<MountPointEntry> base_dirs_;

std::atomic<bool> is_running_;

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_;

HandlersForContentReader delete_handlers_for_content_reader_;

Handlers options_handlers_;

HandlerWithResponse error_handler_;

ExceptionHandler exception_handler_;

HandlerWithResponse pre_routing_handler_;

Handler post_routing_handler_;

Logger logger_;

Expect100ContinueHandler expect_100_continue_handler_;

int address_family_ = AF_UNSPEC;

bool tcp_nodelay_ = CPPHTTPLIB_TCP_NODELAY;

SocketOptions socket_options_ = default_socket_options;

Headers default_headers_;

Success = 0,

Unknown,

Connection,

BindIPAddress,

Read,

Write,

ExceedRedirectCount,

Canceled,

SSLConnection,

SSLLoadingCerts,

SSLServerVerification,

UnsupportedMultipartBoundaryChars,

Compression,

Result(std::unique_ptr<Response> &&res, Error err,

Headers &&request_headers = Headers{})

: res_(std::move(res)), err_(err),

request_headers_(std::move(request_headers)) {}

// Response

operator bool() const { return res_ != nullptr; }

bool operator==(std::nullptr_t) const { return res_ == nullptr; }

bool operator!=(std::nullptr_t) const { return res_ != nullptr; }

const Response &value() const { return *res_; }

Response &value() { return *res_; }

const Response &operator*() const { return *res_; }

Response &operator*() { return *res_; }

const Response *operator->() const { return res_.get(); }

Response *operator->() { return res_.get(); }

// Error

Error error() const { return err_; }

// Request Headers

bool has_request_header(const char *key) const;

std::string get_request_header_value(const char *key, size_t id = 0) const;

template <typename T>

T get_request_header_value(const char *key, size_t id = 0) const;

size_t get_request_header_value_count(const char *key) const;

std::unique_ptr<Response> res_;

Error err_;

Headers request_headers_;

explicit ClientImpl(const std::string &host);

explicit ClientImpl(const std::string &host, int port);

explicit ClientImpl(const std::string &host, int port,

const std::string &client_cert_path,

const std::string &client_key_path);

virtual ~ClientImpl();

virtual bool is_valid() const;

Result Get(const char *path);

Result Get(const char *path, const Headers &headers);

Result Get(const char *path, Progress progress);

Result Get(const char *path, const Headers &headers, Progress progress);

Result Get(const char *path, ContentReceiver content_receiver);

Result Get(const char *path, const Headers &headers,

ContentReceiver content_receiver);

Result Get(const char *path, ContentReceiver content_receiver,

Progress progress);

Result Get(const char *path, const Headers &headers,

ContentReceiver content_receiver, Progress progress);

Result Get(const char *path, ResponseHandler response_handler,

ContentReceiver content_receiver);

Result Get(const char *path, const Headers &headers,

ResponseHandler response_handler,

ContentReceiver content_receiver);

Result Get(const char *path, ResponseHandler response_handler,

ContentReceiver content_receiver, Progress progress);

Result Get(const char *path, const Headers &headers,

ResponseHandler response_handler, ContentReceiver content_receiver,

Progress progress);

Result Get(const char *path, const Params &params, const Headers &headers,

Progress progress = nullptr);

Result Get(const char *path, const Params &params, const Headers &headers,

ContentReceiver content_receiver, Progress progress = nullptr);

Result Get(const char *path, const Params &params, const Headers &headers,

ResponseHandler response_handler, ContentReceiver content_receiver,

Progress progress = nullptr);

Result Head(const char *path);

Result Head(const char *path, const Headers &headers);

Result Post(const char *path);

Result Post(const char *path, const char *body, size_t content_length,

const char *content_type);

Result Post(const char *path, const Headers &headers, const char *body,

size_t content_length, const char *content_type);

Result Post(const char *path, const std::string &body,

const char *content_type);

Result Post(const char *path, const Headers &headers, const std::string &body,

const char *content_type);

Result Post(const char *path, size_t content_length,

ContentProvider content_provider, const char *content_type);

Result Post(const char *path, ContentProviderWithoutLength content_provider,

const char *content_type);

Result Post(const char *path, const Headers &headers, size_t content_length,

ContentProvider content_provider, const char *content_type);

Result Post(const char *path, const Headers &headers,

ContentProviderWithoutLength content_provider,

const char *content_type);

Result Post(const char *path, const Params &params);

Result Post(const char *path, const Headers &headers, const Params &params);

Result Post(const char *path, const MultipartFormDataItems &items);

Result Post(const char *path, const Headers &headers,

const MultipartFormDataItems &items);

Result Post(const char *path, const Headers &headers,

const MultipartFormDataItems &items, const std::string &boundary);

Result Put(const char *path);

Result Put(const char *path, const char *body, size_t content_length,

const char *content_type);

Result Put(const char *path, const Headers &headers, const char *body,

size_t content_length, const char *content_type);

Result Put(const char *path, const std::string &body,

const char *content_type);

Result Put(const char *path, const Headers &headers, const std::string &body,

const char *content_type);

Result Put(const char *path, size_t content_length,

ContentProvider content_provider, const char *content_type);

Result Put(const char *path, ContentProviderWithoutLength content_provider,

const char *content_type);

Result Put(const char *path, const Headers &headers, size_t content_length,

ContentProvider content_provider, const char *content_type);

Result Put(const char *path, const Headers &headers,

ContentProviderWithoutLength content_provider,

const char *content_type);

Result Put(const char *path, const Params &params);

Result Put(const char *path, const Headers &headers, const Params &params);

Result Patch(const char *path);

Result Patch(const char *path, const char *body, size_t content_length,

const char *content_type);

Result Patch(const char *path, const Headers &headers, const char *body,

size_t content_length, const char *content_type);

Result Patch(const char *path, const std::string &body,

const char *content_type);

Result Patch(const char *path, const Headers &headers,

const std::string &body, const char *content_type);

Result Patch(const char *path, size_t content_length,

ContentProvider content_provider, const char *content_type);

Result Patch(const char *path, ContentProviderWithoutLength content_provider,

const char *content_type);

Result Patch(const char *path, const Headers &headers, size_t content_length,

ContentProvider content_provider, const char *content_type);

Result Patch(const char *path, const Headers &headers,

ContentProviderWithoutLength content_provider,

const char *content_type);

Result Delete(const char *path);

Result Delete(const char *path, const Headers &headers);

Result Delete(const char *path, const char *body, size_t content_length,

const char *content_type);

Result Delete(const char *path, const Headers &headers, const char *body,

size_t content_length, const char *content_type);

Result Delete(const char *path, const std::string &body,

const char *content_type);

Result Delete(const char *path, const Headers &headers,

const std::string &body, const char *content_type);

Result Options(const char *path);

Result Options(const char *path, const Headers &headers);

bool send(Request &req, Response &res, Error &error);

Result send(const Request &req);

size_t is_socket_open() const;

void stop();

void set_default_headers(Headers headers);

void set_address_family(int family);

void set_tcp_nodelay(bool on);

void set_socket_options(SocketOptions socket_options);

void set_connection_timeout(time_t sec, time_t usec = 0);

template <class Rep, class Period>

void

set_connection_timeout(const std::chrono::duration<Rep, Period> &duration);

void set_read_timeout(time_t sec, time_t usec = 0);

template <class Rep, class Period>

void set_read_timeout(const std::chrono::duration<Rep, Period> &duration);

void set_write_timeout(time_t sec, time_t usec = 0);

template <class Rep, class Period>

void set_write_timeout(const std::chrono::duration<Rep, Period> &duration);

void set_basic_auth(const char *username, const char *password);

void set_bearer_token_auth(const char *token);

#ifdef CPPHTTPLIB_OPENSSL_SUPPORT

void set_digest_auth(const char *username, const char *password);

#endif

void set_keep_alive(bool on);

void set_follow_location(bool on);

void set_url_encode(bool on);

void set_compress(bool on);

void set_decompress(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);

void set_proxy_bearer_token_auth(const char *token);

#ifdef CPPHTTPLIB_OPENSSL_SUPPORT

void set_proxy_digest_auth(const char *username, const char *password);

#endif