//

// httplib.h

//

// Copyright (c) 2024 Yuji Hirose. All rights reserved.

// MIT License

//

#ifndef CPPHTTPLIB_HTTPLIB_H

#define CPPHTTPLIB_HTTPLIB_H

#define CPPHTTPLIB_VERSION "0.15.3"

/*

* Configuration

*/

#ifndef CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND

#define CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND 5

#endif

#ifndef CPPHTTPLIB_KEEPALIVE_MAX_COUNT

#define CPPHTTPLIB_KEEPALIVE_MAX_COUNT 5

#endif

#ifndef CPPHTTPLIB_CONNECTION_TIMEOUT_SECOND

#define CPPHTTPLIB_CONNECTION_TIMEOUT_SECOND 300

#endif

#ifndef CPPHTTPLIB_CONNECTION_TIMEOUT_USECOND

#define CPPHTTPLIB_CONNECTION_TIMEOUT_USECOND 0

#endif

#ifndef CPPHTTPLIB_READ_TIMEOUT_SECOND

#define CPPHTTPLIB_READ_TIMEOUT_SECOND 5

#endif

#ifndef CPPHTTPLIB_READ_TIMEOUT_USECOND

#define CPPHTTPLIB_READ_TIMEOUT_USECOND 0

#endif

#ifndef CPPHTTPLIB_WRITE_TIMEOUT_SECOND

#define CPPHTTPLIB_WRITE_TIMEOUT_SECOND 5

#endif

#ifndef CPPHTTPLIB_WRITE_TIMEOUT_USECOND

#define CPPHTTPLIB_WRITE_TIMEOUT_USECOND 0

#endif

#ifndef CPPHTTPLIB_IDLE_INTERVAL_SECOND

#define CPPHTTPLIB_IDLE_INTERVAL_SECOND 0

#endif

#ifndef CPPHTTPLIB_IDLE_INTERVAL_USECOND

#ifdef _WIN32

#define CPPHTTPLIB_IDLE_INTERVAL_USECOND 10000

#else

#define CPPHTTPLIB_IDLE_INTERVAL_USECOND 0

#endif

#endif

#ifndef CPPHTTPLIB_REQUEST_URI_MAX_LENGTH

#define CPPHTTPLIB_REQUEST_URI_MAX_LENGTH 8192

#endif

#ifndef CPPHTTPLIB_HEADER_MAX_LENGTH

#define CPPHTTPLIB_HEADER_MAX_LENGTH 8192

#endif

#ifndef CPPHTTPLIB_REDIRECT_MAX_COUNT

#define CPPHTTPLIB_REDIRECT_MAX_COUNT 20

#endif

#ifndef CPPHTTPLIB_MULTIPART_FORM_DATA_FILE_MAX_COUNT

#define CPPHTTPLIB_MULTIPART_FORM_DATA_FILE_MAX_COUNT 1024

#endif

#ifndef CPPHTTPLIB_PAYLOAD_MAX_LENGTH

#define CPPHTTPLIB_PAYLOAD_MAX_LENGTH ((std::numeric_limits<size_t>::max)())

#endif

#ifndef CPPHTTPLIB_FORM_URL_ENCODED_PAYLOAD_MAX_LENGTH

#define CPPHTTPLIB_FORM_URL_ENCODED_PAYLOAD_MAX_LENGTH 8192

#endif

#ifndef CPPHTTPLIB_RANGE_MAX_COUNT

#define CPPHTTPLIB_RANGE_MAX_COUNT 1024

#endif

#ifndef CPPHTTPLIB_TCP_NODELAY

#define CPPHTTPLIB_TCP_NODELAY false

#endif

#ifndef CPPHTTPLIB_RECV_BUFSIZ

#define CPPHTTPLIB_RECV_BUFSIZ size_t(4096u)

#endif

#ifndef CPPHTTPLIB_COMPRESSION_BUFSIZ

#define CPPHTTPLIB_COMPRESSION_BUFSIZ size_t(16384u)

#endif

#ifndef CPPHTTPLIB_THREAD_POOL_COUNT

#define CPPHTTPLIB_THREAD_POOL_COUNT \

((std::max)(8u, std::thread::hardware_concurrency() > 0 \

? std::thread::hardware_concurrency() - 1 \

: 0))

#endif

#ifndef CPPHTTPLIB_RECV_FLAGS

#define CPPHTTPLIB_RECV_FLAGS 0

#endif

#ifndef CPPHTTPLIB_SEND_FLAGS

#define CPPHTTPLIB_SEND_FLAGS 0

#endif

#ifndef CPPHTTPLIB_LISTEN_BACKLOG

#define CPPHTTPLIB_LISTEN_BACKLOG 5

#endif

/*

* Headers

*/

#ifdef _WIN32

#ifndef _CRT_SECURE_NO_WARNINGS

#define _CRT_SECURE_NO_WARNINGS

#endif //_CRT_SECURE_NO_WARNINGS

#ifndef _CRT_NONSTDC_NO_DEPRECATE

#define _CRT_NONSTDC_NO_DEPRECATE

#endif //_CRT_NONSTDC_NO_DEPRECATE

#if defined(_MSC_VER)

#if _MSC_VER < 1900

#error Sorry, Visual Studio versions prior to 2015 are not supported

#endif

#pragma comment(lib, "ws2_32.lib")

#ifdef _WIN64

using ssize_t = __int64;

#else

using ssize_t = long;

#endif

#endif // _MSC_VER

#ifndef S_ISREG

#define S_ISREG(m) (((m) & S_IFREG) == S_IFREG)

#endif // S_ISREG

#ifndef S_ISDIR

#define S_ISDIR(m) (((m) & S_IFDIR) == S_IFDIR)

#endif // S_ISDIR

#ifndef NOMINMAX

#define NOMINMAX

#endif // NOMINMAX

#include <io.h>

#include <winsock2.h>

#include <ws2tcpip.h>

#ifndef WSA_FLAG_NO_HANDLE_INHERIT

#define WSA_FLAG_NO_HANDLE_INHERIT 0x80

#endif

using socket_t = SOCKET;

#ifdef CPPHTTPLIB_USE_POLL

#define poll(fds, nfds, timeout) WSAPoll(fds, nfds, timeout)

#endif

#else // not _WIN32

#include <arpa/inet.h>

#if !defined(_AIX) && !defined(__MVS__)

#include <ifaddrs.h>

#endif

#ifdef __MVS__

#include <strings.h>

#ifndef NI_MAXHOST

#define NI_MAXHOST 1025

#endif

#endif

#include <net/if.h>

#include <netdb.h>

#include <netinet/in.h>

#ifdef __linux__

#include <resolv.h>

#endif

#include <netinet/tcp.h>

#ifdef CPPHTTPLIB_USE_POLL

#include <poll.h>

#endif

#include <csignal>

#include <pthread.h>

#include <sys/mman.h>

#include <sys/select.h>

#include <sys/socket.h>

#include <sys/un.h>

#include <unistd.h>

using socket_t = int;

#ifndef INVALID_SOCKET

#define INVALID_SOCKET (-1)

#endif

#endif //_WIN32

#include <algorithm>

#include <array>

#include <atomic>

#include <cassert>

#include <cctype>

#include <climits>

#include <condition_variable>

#include <cstring>

#include <errno.h>

#include <exception>

#include <fcntl.h>

#include <fstream>

#include <functional>

#include <iomanip>

#include <iostream>

#include <list>

#include <map>

#include <memory>

#include <mutex>

#include <random>

#include <regex>

#include <set>

#include <sstream>

#include <string>

#include <sys/stat.h>

#include <thread>

#include <unordered_map>

#include <unordered_set>

#include <utility>

#ifdef CPPHTTPLIB_OPENSSL_SUPPORT

#ifdef _WIN32

#include <wincrypt.h>

// these are defined in wincrypt.h and it breaks compilation if BoringSSL is

// used

#undef X509_NAME

#undef X509_CERT_PAIR

#undef X509_EXTENSIONS

#undef PKCS7_SIGNER_INFO

#ifdef _MSC_VER

#pragma comment(lib, "crypt32.lib")

#endif

#elif defined(CPPHTTPLIB_USE_CERTS_FROM_MACOSX_KEYCHAIN) && defined(__APPLE__)

#include <TargetConditionals.h>

#if TARGET_OS_OSX

#include <CoreFoundation/CoreFoundation.h>

#include <Security/Security.h>

#endif // TARGET_OS_OSX

#endif // _WIN32

#include <openssl/err.h>

#include <openssl/evp.h>

#include <openssl/ssl.h>

#include <openssl/x509v3.h>

#if defined(_WIN32) && defined(OPENSSL_USE_APPLINK)

#include <openssl/applink.c>

#endif

#include <iostream>

#include <sstream>

#if OPENSSL_VERSION_NUMBER < 0x30000000L

#error Sorry, OpenSSL versions prior to 3.0.0 are not supported

#endif

#endif

#ifdef CPPHTTPLIB_ZLIB_SUPPORT

#include <zlib.h>

#endif

#ifdef CPPHTTPLIB_BROTLI_SUPPORT

#include <brotli/decode.h>

#include <brotli/encode.h>

#endif

/*

* Declaration

*/

namespace httplib {

namespace detail {

/*

* Backport std::make_unique from C++14.

*

* NOTE: This code came up with the following stackoverflow post:

* https://stackoverflow.com/questions/10149840/c-arrays-and-make-unique

*

*/

template <class T, class... Args>

typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T>>::type

make_unique(Args &&...args) {

return std::unique_ptr<T>(new T(std::forward<Args>(args)...));

}

template <class T>

typename std::enable_if<std::is_array<T>::value, std::unique_ptr<T>>::type

make_unique(std::size_t n) {

typedef typename std::remove_extent<T>::type RT;

return std::unique_ptr<T>(new RT[n]);

}

struct ci {

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

});

}

};

// This is based on

// "http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4189".

struct scope_exit {

explicit scope_exit(std::function<void(void)> &&f)

: exit_function(std::move(f)), execute_on_destruction{true} {}

scope_exit(scope_exit &&rhs) noexcept

: exit_function(std::move(rhs.exit_function)),

execute_on_destruction{rhs.execute_on_destruction} {

rhs.release();

}

~scope_exit() {

if (execute_on_destruction) { this->exit_function(); }

}

void release() { this->execute_on_destruction = false; }

private:

scope_exit(const scope_exit &) = delete;

void operator=(const scope_exit &) = delete;

scope_exit &operator=(scope_exit &&) = delete;

std::function<void(void)> exit_function;

bool execute_on_destruction;

};

} // namespace detail

enum StatusCode {

// Information responses

Continue_100 = 100,

SwitchingProtocol_101 = 101,

Processing_102 = 102,

EarlyHints_103 = 103,

// Successful responses

OK_200 = 200,

Created_201 = 201,

Accepted_202 = 202,

NonAuthoritativeInformation_203 = 203,

NoContent_204 = 204,

ResetContent_205 = 205,

PartialContent_206 = 206,

MultiStatus_207 = 207,

AlreadyReported_208 = 208,

IMUsed_226 = 226,

// Redirection messages

MultipleChoices_300 = 300,

MovedPermanently_301 = 301,

Found_302 = 302,

SeeOther_303 = 303,

NotModified_304 = 304,

UseProxy_305 = 305,

unused_306 = 306,

TemporaryRedirect_307 = 307,

PermanentRedirect_308 = 308,

// Client error responses

BadRequest_400 = 400,

Unauthorized_401 = 401,

PaymentRequired_402 = 402,

Forbidden_403 = 403,

NotFound_404 = 404,

MethodNotAllowed_405 = 405,

NotAcceptable_406 = 406,

ProxyAuthenticationRequired_407 = 407,

RequestTimeout_408 = 408,

Conflict_409 = 409,

Gone_410 = 410,

LengthRequired_411 = 411,

PreconditionFailed_412 = 412,

PayloadTooLarge_413 = 413,

UriTooLong_414 = 414,

UnsupportedMediaType_415 = 415,

RangeNotSatisfiable_416 = 416,

ExpectationFailed_417 = 417,

ImATeapot_418 = 418,

MisdirectedRequest_421 = 421,

UnprocessableContent_422 = 422,

Locked_423 = 423,

FailedDependency_424 = 424,

TooEarly_425 = 425,

UpgradeRequired_426 = 426,

PreconditionRequired_428 = 428,

TooManyRequests_429 = 429,

RequestHeaderFieldsTooLarge_431 = 431,

UnavailableForLegalReasons_451 = 451,

// Server error responses

InternalServerError_500 = 500,

NotImplemented_501 = 501,

BadGateway_502 = 502,

ServiceUnavailable_503 = 503,

GatewayTimeout_504 = 504,

HttpVersionNotSupported_505 = 505,

VariantAlsoNegotiates_506 = 506,

InsufficientStorage_507 = 507,

LoopDetected_508 = 508,

NotExtended_510 = 510,

NetworkAuthenticationRequired_511 = 511,

};

using Headers = std::multimap<std::string, std::string, detail::ci>;

using Params = std::multimap<std::string, std::string>;

using Match = std::smatch;

using Progress = std::function<bool(uint64_t current, uint64_t total)>;

struct Response;

using ResponseHandler = std::function<bool(const Response &response)>;

struct MultipartFormData {

std::string name;

std::string content;

std::string filename;

std::string content_type;

};

using MultipartFormDataItems = std::vector<MultipartFormData>;

using MultipartFormDataMap = std::multimap<std::string, MultipartFormData>;

class DataSink {

public:

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<bool()> is_writable;

std::function<void()> done;

std::function<void(const Headers &trailer)> done_with_trailer;

std::ostream os;

private:

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) override {

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

return n;

}

private:

DataSink &sink_;

};

data_sink_streambuf sb_;

};

using ContentProvider =

std::function<bool(size_t offset, size_t length, DataSink &sink)>;

using ContentProviderWithoutLength =

std::function<bool(size_t offset, DataSink &sink)>;

using ContentProviderResourceReleaser = std::function<void(bool success)>;

struct MultipartFormDataProvider {

std::string name;

ContentProviderWithoutLength provider;

std::string filename;

std::string content_type;

};

using MultipartFormDataProviderItems = std::vector<MultipartFormDataProvider>;

using ContentReceiverWithProgress =

std::function<bool(const char *data, size_t data_length, uint64_t offset,

uint64_t total_length)>;

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

};

using Range = std::pair<ssize_t, ssize_t>;

using Ranges = std::vector<Range>;

struct Request {

std::string method;

std::string path;

Headers headers;

std::string body;

std::string remote_addr;

int remote_port = -1;

std::string local_addr;

int local_port = -1;

// for server

std::string version;

std::string target;

Params params;

MultipartFormDataMap files;

Ranges ranges;

Match matches;

std::unordered_map<std::string, std::string> path_params;

// for client

ResponseHandler response_handler;

ContentReceiverWithProgress content_receiver;

Progress progress;

#ifdef CPPHTTPLIB_OPENSSL_SUPPORT

const SSL *ssl = nullptr;

#endif

bool has_header(const std::string &key) const;

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

uint64_t get_header_value_u64(const std::string &key, size_t id = 0) const;

size_t get_header_value_count(const std::string &key) const;

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

bool has_param(const std::string &key) const;

std::string get_param_value(const std::string &key, size_t id = 0) const;

size_t get_param_value_count(const std::string &key) const;

bool is_multipart_form_data() const;

bool has_file(const std::string &key) const;

MultipartFormData get_file_value(const std::string &key) const;

std::vector<MultipartFormData> get_file_values(const std::string &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;

};

struct Response {

std::string version;

int status = -1;

std::string reason;

Headers headers;

std::string body;

std::string location; // Redirect location

bool has_header(const std::string &key) const;

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

uint64_t get_header_value_u64(const std::string &key, size_t id = 0) const;

size_t get_header_value_count(const std::string &key) const;

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

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

void set_content(const char *s, size_t n, const std::string &content_type);

void set_content(const std::string &s, const std::string &content_type);

void set_content(std::string &&s, const std::string &content_type);

void set_content_provider(

size_t length, const std::string &content_type, ContentProvider provider,

ContentProviderResourceReleaser resource_releaser = nullptr);

void set_content_provider(

const std::string &content_type, ContentProviderWithoutLength provider,

ContentProviderResourceReleaser resource_releaser = nullptr);

void set_chunked_content_provider(

const std::string &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;

};

class Stream {

public:

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 void get_local_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);

};

class TaskQueue {

public:

TaskQueue() = default;

virtual ~TaskQueue() = default;

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

virtual void shutdown() = 0;

virtual void on_idle() {}

};

class ThreadPool : public TaskQueue {

public:

explicit ThreadPool(size_t n, size_t mqr = 0)

: shutdown_(false), max_queued_requests_(mqr) {

while (n) {

threads_.emplace_back(worker(*this));

n--;

}

}

ThreadPool(const ThreadPool &) = delete;

~ThreadPool() override = default;

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

{

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

if (max_queued_requests_ > 0 && jobs_.size() >= max_queued_requests_) {

return false;

}

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

}

cond_.notify_one();

return true;

}

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

}

}

private:

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 = std::move(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_;

size_t max_queued_requests_ = 0;

std::condition_variable cond_;

std::mutex mutex_;

};

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

using SocketOptions = std::function<void(socket_t sock)>;

void default_socket_options(socket_t sock);

const char *status_message(int status);

std::string get_bearer_token_auth(const Request &req);

namespace detail {

class MatcherBase {

public:

virtual ~MatcherBase() = default;

// Match request path and populate its matches and

virtual bool match(Request &request) const = 0;

};

/**

* Captures parameters in request path and stores them in Request::path_params

*

* Capture name is a substring of a pattern from : to /.

* The rest of the pattern is matched agains the request path directly

* Parameters are captured starting from the next character after

* the end of the last matched static pattern fragment until the next /.

*

* Example pattern:

* "/path/fragments/:capture/more/fragments/:second_capture"

* Static fragments:

* "/path/fragments/", "more/fragments/"

*

* Given the following request path:

* "/path/fragments/:1/more/fragments/:2"

* the resulting capture will be

* {{"capture", "1"}, {"second_capture", "2"}}

*/

class PathParamsMatcher : public MatcherBase {

public:

PathParamsMatcher(const std::string &pattern);

bool match(Request &request) const override;

private:

static constexpr char marker = ':';

// Treat segment separators as the end of path parameter capture

// Does not need to handle query parameters as they are parsed before path

// matching

static constexpr char separator = '/';

// Contains static path fragments to match against, excluding the '/' after

// path params

// Fragments are separated by path params

std::vector<std::string> static_fragments_;

// Stores the names of the path parameters to be used as keys in the

// Request::path_params map

std::vector<std::string> param_names_;

};

/**

* Performs std::regex_match on request path

* and stores the result in Request::matches

*

* Note that regex match is performed directly on the whole request.

* This means that wildcard patterns may match multiple path segments with /:

* "/begin/(.*)/end" will match both "/begin/middle/end" and "/begin/1/2/end".

*/

class RegexMatcher : public MatcherBase {

public:

RegexMatcher(const std::string &pattern) : regex_(pattern) {}

bool match(Request &request) const override;

private:

std::regex regex_;

};

ssize_t write_headers(Stream &strm, const Headers &headers);

} // namespace detail

class Server {

public:

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

using ExceptionHandler =

std::function<void(const Request &, Response &, std::exception_ptr ep)>;

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 std::string &ext,

const std::string &mime);

Server &set_default_file_mimetype(const std::string &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_header_writer(std::function<ssize_t(Stream &, Headers &)> const &writer);

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 std::string &host, int port, int socket_flags = 0);

int bind_to_any_port(const std::string &host, int socket_flags = 0);

bool listen_after_bind();

bool listen(const std::string &host, int port, int socket_flags = 0);

bool is_running() const;

void wait_until_ready() const;

void stop();

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

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

protected:

bool process_request(Stream &strm, bool close_connection,

bool &connection_closed,

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

std::atomic<socket_t> svr_sock_{INVALID_SOCKET};

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;

private:

using Handlers =

std::vector<std::pair<std::unique_ptr<detail::MatcherBase>, Handler>>;

using HandlersForContentReader =

std::vector<std::pair<std::unique_ptr<detail::MatcherBase>,

HandlerWithContentReader>>;

static std::unique_ptr<detail::MatcherBase>

make_matcher(const std::string &pattern);

socket_t create_server_socket(const std::string &host, int port,

int socket_flags,

SocketOptions socket_options) const;

int bind_internal(const std::string &host, int port, int socket_flags);

bool listen_internal();

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

bool head = false);

bool dispatch_request(Request &req, Response &res,

const Handlers &handlers) const;

bool dispatch_request_for_content_reader(

Request &req, Response &res, ContentReader content_reader,

const HandlersForContentReader &handlers) const;

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

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

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

bool write_response(Stream &strm, bool close_connection, 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 multipart_header,

ContentReceiver multipart_receiver) const;

virtual bool process_and_close_socket(socket_t sock);

std::atomic<bool> is_running_{false};

std::atomic<bool> done_{false};

struct MountPointEntry {

std::string mount_point;

std::string base_dir;

Headers headers;

};

std::vector<MountPointEntry> base_dirs_;

std::map<std::string, std::string> file_extension_and_mimetype_map_;

std::string default_file_mimetype_ = "application/octet-stream";

Handler file_request_handler_;