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

return std::lexicographical_compare(

s1.begin(), s1.end(), s2.begin(), s2.end(),

[](char c1, char c2) { return ::tolower(c1) < ::tolower(c2); });

}

std::string filename;

std::string content_type;

size_t offset = 0;

size_t length = 0;

std::string name;

std::string content;

std::string filename;

std::string content_type;

std::string version;

std::string method;

std::string target;

std::string path;

Headers headers;

std::string body;

Params params;

MultipartFiles files;

Ranges ranges;

Match matches;

#ifdef CPPHTTPLIB_OPENSSL_SUPPORT

const SSL *ssl;

#endif

bool has_header(const char *key) const;

std::string 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 has_file(const char *key) const;

MultipartFile get_file_value(const char *key) const;

std::string version;

int status;

Headers headers;

std::string body;

ContentReceiver content_receiver;

Progress progress;

bool has_header(const char *key) const;

std::string 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 *uri);

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(

uint64_t length,

std::function<void(uint64_t offset, uint64_t length, Out out)> provider,

std::function<void()> resource_releaser = [] {});

void set_chunked_content_provider(

std::function<void(uint64_t offset, Out out, Done done)> provider,

std::function<void()> resource_releaser = [] {});

Response() : status(-1), content_provider_resource_length(0) {}

~Response() {

if (content_provider_resource_releaser) {

content_provider_resource_releaser();

}

}

uint64_t content_provider_resource_length;

ContentProvider content_provider;

std::function<void()> content_provider_resource_releaser;

virtual ~Stream() {}

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 std::string get_remote_addr() const = 0;

template <typename... Args>

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

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;

socket_t sock_;

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;

std::string buffer;

TaskQueue() {}

virtual ~TaskQueue() {}

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

virtual void shutdown() = 0;

ThreadPool(size_t n) : shutdown_(false) {

while (n) {

auto t = std::make_shared<std::thread>(worker(*this));

threads_.push_back(t);

n--;

}

}

ThreadPool(const ThreadPool &) = delete;

virtual ~ThreadPool() {}

virtual 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 {

// 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 {

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

fn();

}

}

ThreadPool &pool_;

};

friend struct worker;

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

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

bool shutdown_;

std::condition_variable cond_;

std::mutex mutex_;

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

}

}

std::mutex running_threads_mutex_;

int running_threads_;

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

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

Server();

virtual ~Server();

virtual bool is_valid() const;

Server &Get(const char *pattern, Handler handler);

Server &Post(const char *pattern, Handler handler);

Server &Put(const char *pattern, Handler handler);

Server &Patch(const char *pattern, Handler handler);

Server &Delete(const char *pattern, Handler handler);

Server &Options(const char *pattern, Handler handler);

bool set_base_dir(const char *path);

void set_error_handler(Handler handler);

void set_logger(Logger logger);

void set_keep_alive_max_count(size_t count);

void set_payload_max_length(uint64_t length);

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 last_connection,

bool &connection_close,

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

size_t keep_alive_max_count_;

size_t payload_max_length_;

typedef std::vector<std::pair<std::regex, Handler>> Handlers;

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

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

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

Response &res);

bool write_content_with_provider(Stream &strm, const Request &req,

Response &res, const std::string &boundary,

const std::string &content_type);

virtual bool read_and_close_socket(socket_t sock);

std::atomic<bool> is_running_;

std::atomic<socket_t> svr_sock_;

std::string base_dir_;

Handlers get_handlers_;

Handlers post_handlers_;

Handlers put_handlers_;

Handlers patch_handlers_;

Handlers delete_handlers_;

Handlers options_handlers_;

Handler error_handler_;

Logger logger_;

Client(const char *host, int port = 80, time_t timeout_sec = 300);

virtual ~Client();

virtual bool is_valid() const;

std::shared_ptr<Response> Get(const char *path, Progress progress = nullptr);

std::shared_ptr<Response> Get(const char *path, const Headers &headers,

Progress progress = nullptr);

std::shared_ptr<Response> Get(const char *path,

ContentReceiver content_receiver,

Progress progress = nullptr);

std::shared_ptr<Response> Get(const char *path, const Headers &headers,

ContentReceiver content_receiver,

Progress progress = nullptr);

std::shared_ptr<Response> Head(const char *path);

std::shared_ptr<Response> Head(const char *path, const Headers &headers);

std::shared_ptr<Response> Post(const char *path, const std::string &body,

const char *content_type);

std::shared_ptr<Response> Post(const char *path, const Headers &headers,

const std::string &body,

const char *content_type);

std::shared_ptr<Response> Post(const char *path, const Params &params);

std::shared_ptr<Response> Post(const char *path, const Headers &headers,

const Params &params);

std::shared_ptr<Response> Post(const char *path,

const MultipartFormDataItems &items);

std::shared_ptr<Response> Post(const char *path, const Headers &headers,

const MultipartFormDataItems &items);

std::shared_ptr<Response> Put(const char *path, const std::string &body,

const char *content_type);

std::shared_ptr<Response> Put(const char *path, const Headers &headers,

const std::string &body,

const char *content_type);

std::shared_ptr<Response> Patch(const char *path, const std::string &body,

const char *content_type);

std::shared_ptr<Response> Patch(const char *path, const Headers &headers,

const std::string &body,

const char *content_type);

std::shared_ptr<Response> Delete(const char *path,

const std::string &body = std::string(),

const char *content_type = nullptr);

std::shared_ptr<Response> Delete(const char *path, const Headers &headers,

const std::string &body = std::string(),

const char *content_type = nullptr);

std::shared_ptr<Response> Options(const char *path);

std::shared_ptr<Response> Options(const char *path, const Headers &headers);

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

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

bool &connection_close);

const std::string host_;

const int port_;

time_t timeout_sec_;

const std::string host_and_port_;

socket_t create_client_socket() const;

bool read_response_line(Stream &strm, Response &res);

void write_request(Stream &strm, Request &req);

virtual bool read_and_close_socket(socket_t sock, Request &req,

Response &res);

virtual bool is_ssl() const;

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;

socket_t sock_;

SSL *ssl_;

SSLServer(const char *cert_path, const char *private_key_path,

const char *client_ca_cert_file_path = nullptr,

const char *client_ca_cert_dir_path = nullptr);

virtual ~SSLServer();

virtual bool is_valid() const;

virtual bool read_and_close_socket(socket_t sock);

SSL_CTX *ctx_;

std::mutex ctx_mutex_;

SSLClient(const char *host, int port = 443, time_t timeout_sec = 300,

const char *client_cert_path = nullptr,

const char *client_key_path = nullptr);

virtual ~SSLClient();

virtual bool is_valid() const;

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;

virtual bool read_and_close_socket(socket_t sock, Request &req,

Response &res);

virtual bool is_ssl() const;

bool verify_host(X509 *server_cert) const;

bool verify_host_with_subject_alt_name(X509 *server_cert) const;

bool verify_host_with_common_name(X509 *server_cert) const;

bool check_host_name(const char *pattern, size_t pattern_len) const;

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;

long verify_result_ = 0;

if (0x20 <= c && isdigit(c)) {

v = c - '0';

return true;

} else if ('A' <= c && c <= 'F') {

v = c - 'A' + 10;

return true;

} else if ('a' <= c && c <= 'f') {

v = c - 'a' + 10;

return true;

}

return false;

int &val) {

if (i >= s.size()) { return false; }

val = 0;

for (; cnt; i++, cnt--) {

if (!s[i]) { return false; }

int v = 0;

if (is_hex(s[i], v)) {

val = val * 16 + v;

} else {

return false;

}

}

return true;

const char *charset = "0123456789abcdef";

std::string ret;

do {

ret = charset[n & 15] + ret;

n >>= 4;

} while (n > 0);

return ret;

if (code < 0x0080) {

buff[0] = (code & 0x7F);

return 1;

} else if (code < 0x0800) {

buff[0] = (0xC0 | ((code >> 6) & 0x1F));

buff[1] = (0x80 | (code & 0x3F));

return 2;

} else if (code < 0xD800) {

buff[0] = (0xE0 | ((code >> 12) & 0xF));

buff[1] = (0x80 | ((code >> 6) & 0x3F));

buff[2] = (0x80 | (code & 0x3F));

return 3;

} else if (code < 0xE000) { // D800 - DFFF is invalid...

return 0;

} else if (code < 0x10000) {

buff[0] = (0xE0 | ((code >> 12) & 0xF));

buff[1] = (0x80 | ((code >> 6) & 0x3F));

buff[2] = (0x80 | (code & 0x3F));

return 3;

} else if (code < 0x110000) {

buff[0] = (0xF0 | ((code >> 18) & 0x7));

buff[1] = (0x80 | ((code >> 12) & 0x3F));

buff[2] = (0x80 | ((code >> 6) & 0x3F));

buff[3] = (0x80 | (code & 0x3F));

return 4;

}

// NOTREACHED

return 0;

static const auto lookup =

"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

std::string out;

out.reserve(in.size());

int val = 0;

int valb = -6;

for (uint8_t c : in) {

val = (val << 8) + c;

valb += 8;

while (valb >= 0) {

out.push_back(lookup[(val >> valb) & 0x3F]);

valb -= 6;

}

}

if (valb > -6) { out.push_back(lookup[((val << 8) >> (valb + 8)) & 0x3F]); }

while (out.size() % 4) {

out.push_back('=');

}

return out;

size_t level = 0;

size_t i = 0;

// Skip slash

while (i < path.size() && path[i] == '/') {

i++;

}

while (i < path.size()) {

// Read component

auto beg = i;

while (i < path.size() && path[i] != '/') {

i++;

}

auto len = i - beg;

assert(len > 0);

if (!path.compare(beg, len, ".")) {

;

} else if (!path.compare(beg, len, "..")) {

if (level == 0) { return false; }

level--;

} else {

level++;

}

// Skip slash

while (i < path.size() && path[i] == '/') {

i++;

}

}

return true;

std::ifstream fs(path, std::ios_base::binary);

fs.seekg(0, std::ios_base::end);

auto size = fs.tellg();

fs.seekg(0);

out.resize(static_cast<size_t>(size));

fs.read(&out[0], size);

std::smatch m;

auto pat = std::regex("\\.([a-zA-Z0-9]+)$");

if (std::regex_search(path, m, pat)) { return m[1].str(); }

return std::string();

int i = 0;

int beg = 0;

while (e ? (b + i != e) : (b[i] != '\0')) {

if (b[i] == d) {

fn(&b[beg], &b[i]);

beg = i + 1;

}

i++;

}

if (i) { fn(&b[beg], &b[i]); }

stream_line_reader(Stream &strm, char *fixed_buffer, size_t fixed_buffer_size)

: strm_(strm), fixed_buffer_(fixed_buffer),

fixed_buffer_size_(fixed_buffer_size) {}

const char *ptr() const {

if (glowable_buffer_.empty()) {

return fixed_buffer_;

} else {

return glowable_buffer_.data();

}

}

size_t size() const {

if (glowable_buffer_.empty()) {

return fixed_buffer_used_size_;

} else {

return glowable_buffer_.size();

}

}

bool getline() {

fixed_buffer_used_size_ = 0;

glowable_buffer_.clear();

for (size_t i = 0;; i++) {

char byte;

auto n = strm_.read(&byte, 1);

if (n < 0) {

return false;

} else if (n == 0) {

if (i == 0) {

return false;

} else {

break;

}

}

append(byte);

if (byte == '\n') { break; }

}

return true;

}

void append(char c) {

if (fixed_buffer_used_size_ < fixed_buffer_size_ - 1) {

fixed_buffer_[fixed_buffer_used_size_++] = c;

fixed_buffer_[fixed_buffer_used_size_] = '\0';

} else {

if (glowable_buffer_.empty()) {

assert(fixed_buffer_[fixed_buffer_used_size_] == '\0');

glowable_buffer_.assign(fixed_buffer_, fixed_buffer_used_size_);

}

glowable_buffer_ += c;

}

}

Stream &strm_;

char *fixed_buffer_;

const size_t fixed_buffer_size_;

size_t fixed_buffer_used_size_;

std::string glowable_buffer_;

#ifdef _WIN32

return closesocket(sock);

#else

return close(sock);

#endif

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), &fds, nullptr, nullptr, &tv);

fd_set fdsr;

FD_ZERO(&fdsr);

FD_SET(sock, &fdsr);

auto fdsw = fdsr;

auto fdse = fdsr;

timeval tv;

tv.tv_sec = static_cast<long>(sec);

tv.tv_usec = static_cast<long>(usec);

if (select(static_cast<int>(sock + 1), &fdsr, &fdsw, &fdse, &tv) < 0) {

return false;

} else if (FD_ISSET(sock, &fdsr) || FD_ISSET(sock, &fdsw)) {

int error = 0;

socklen_t len = sizeof(error);

if (getsockopt(sock, SOL_SOCKET, SO_ERROR, (char *)&error, &len) < 0 ||

error) {

return false;

}

} else {

return false;

}

return true;

T callback) {

bool ret = false;

if (keep_alive_max_count > 0) {

auto count = keep_alive_max_count;

while (count > 0 &&

detail::select_read(sock, CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND,

CPPHTTPLIB_KEEPALIVE_TIMEOUT_USECOND) > 0) {

SocketStream strm(sock);

auto last_connection = count == 1;

auto connection_close = false;

ret = callback(strm, last_connection, connection_close);

if (!ret || connection_close) { break; }

count--;

}

} else {

SocketStream strm(sock);

auto dummy_connection_close = false;

ret = callback(strm, true, dummy_connection_close);

}

close_socket(sock);

return ret;

#ifdef _WIN32

return shutdown(sock, SD_BOTH);

#else

return shutdown(sock, SHUT_RDWR);

#endif

int socket_flags = 0) {

#ifdef _WIN32

#define SO_SYNCHRONOUS_NONALERT 0x20

#define SO_OPENTYPE 0x7008

int opt = SO_SYNCHRONOUS_NONALERT;

setsockopt(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (char *)&opt,

sizeof(opt));

#endif

// Get address info

struct addrinfo hints;

struct addrinfo *result;

memset(&hints, 0, sizeof(struct addrinfo));

hints.ai_family = AF_UNSPEC;

hints.ai_socktype = SOCK_STREAM;

hints.ai_flags = socket_flags;

hints.ai_protocol = 0;

auto service = std::to_string(port);

if (getaddrinfo(host, service.c_str(), &hints, &result)) {

return INVALID_SOCKET;

}

for (auto rp = result; rp; rp = rp->ai_next) {

// Create a socket

#ifdef _WIN32

auto sock = WSASocketW(rp->ai_family, rp->ai_socktype, rp->ai_protocol,

nullptr, 0, WSA_FLAG_NO_HANDLE_INHERIT);

#else

auto sock = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);

#endif