#include "httplib.h"

#include <limits>

#ifdef _WIN32

#include <io.h>

#include <winsock2.h>

#include <ws2tcpip.h>

#ifdef _MSC_VER

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

#endif

using socket_t = SOCKET;

#else

using socket_t = int;

#define INVALID_SOCKET (-1)

#endif

static std::atomic<socket_t> svr_sock_= INVALID_SOCKET; /* 改动：svr_sock 从类成员变量变成全局变量，尚未充分评估带来的负面影响 */

namespace httplib {

int close_socket(socket_t sock) {

#ifdef _WIN32

return closesocket(sock);

#else

return close(sock);

#endif

}

int select_read(socket_t sock, time_t sec, time_t usec) {

#ifdef CPPHTTPLIB_USE_POLL

struct pollfd pfd_read;

pfd_read.fd = sock;

pfd_read.events = POLLIN;

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

#endif

}

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

}

bool wait_until_socket_is_ready(socket_t sock, time_t sec, time_t usec) {

#ifdef CPPHTTPLIB_USE_POLL

struct pollfd pfd_read;

pfd_read.fd = sock;

pfd_read.events = POLLIN | POLLOUT;

auto timeout = static_cast<int>(sec * 1000 + usec / 1000);

if (poll(&pfd_read, 1, timeout) > 0 &&

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 &&

!error;

}

return false;

#else

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 &&

(FD_ISSET(sock, &fdsr) || FD_ISSET(sock, &fdsw))) {

int error = 0;

socklen_t len = sizeof(error);

return getsockopt(sock, SOL_SOCKET, SO_ERROR,

reinterpret_cast<char *>(&error), &len) >= 0 &&

!error;

}

return false;

#endif

}

class Stream {

public:

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 size) = 0;

virtual std::string get_remote_addr() const = 0;

template <typename... Args>

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

int write(const char *ptr);

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

};

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

};

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>

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

auto ret = false;

if (keep_alive_max_count > 1) {

auto count = keep_alive_max_count;

while (count > 0 &&

(is_client_request ||

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;

ret = callback(strm, last_connection, connection_close);

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

count--;

}

}

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;

}

int shutdown_socket(socket_t sock) {

#ifdef _WIN32

return shutdown(sock, SD_BOTH);

#else

return shutdown(sock, SHUT_RDWR);

#endif

}

template <typename Fn>

socket_t create_socket(const char *host, int port, Fn fn,

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

/**

* 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

if (sock == INVALID_SOCKET) { continue; }

#ifndef _WIN32

if (fcntl(sock, F_SETFD, FD_CLOEXEC) == -1) { continue; }

#endif

// Make 'reuse address' option available

int yes = 1;

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

#endif

// bind or connect

if (fn(sock, *rp)) {

freeaddrinfo(result);

return sock;

}

close_socket(sock);

}

freeaddrinfo(result);

return INVALID_SOCKET;

}

void set_nonblocking(socket_t sock, bool nonblocking) {

#ifdef _WIN32

auto flags = nonblocking ? 1UL : 0UL;

ioctlsocket(sock, FIONBIO, &flags);

#else

auto flags = fcntl(sock, F_GETFL, 0);

fcntl(sock, F_SETFL,

nonblocking ? (flags | O_NONBLOCK) : (flags & (~O_NONBLOCK)));

#endif

}

bool is_connection_error() {

#ifdef _WIN32

return WSAGetLastError() != WSAEWOULDBLOCK;

#else

return errno != EINPROGRESS;

#endif

}

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;

}

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

}

std::string file_extension(const std::string &path) {

std::smatch m;

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

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

return std::string();

}

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" || ext == "htm") {

return "text/html";

}

else if (ext == "css") {

return "text/css";

}

else if (ext == "jpeg" || ext == "jpg") {

return "image/jpg";

}

else if (ext == "png") {

return "image/png";

}

else if (ext == "gif") {

return "image/gif";

}

else if (ext == "svg") {

return "image/svg+xml";

}

else if (ext == "ico") {

return "image/x-icon";

}

else if (ext == "json") {

return "application/json";

}

else if (ext == "pdf") {

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

return "application/xhtml+xml";

}

return nullptr;

}

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

}

}

class stream_line_reader {

public:

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

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;

}

private:

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

std::string glowable_buffer_;

};

bool read_headers(Stream &strm, Headers &headers) {

const auto bufsiz = 2048;

char buf[bufsiz];

stream_line_reader line_reader(strm, buf, bufsiz);

for (;;) {

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(line_reader.ptr(), end, m, re)) {

auto key = std::string(m[1]);

auto val = std::string(m[2]);

headers.emplace(key, val);

}

}

return true;

}

bool read_content_with_length(Stream &strm, uint64_t len,

Progress progress, ContentReceiver out) {

char buf[CPPHTTPLIB_RECV_BUFSIZ];

uint64_t r = 0;

while (r < len) {

auto read_len = static_cast<size_t>(len - r);

auto n = strm.read(buf, std::min(read_len, CPPHTTPLIB_RECV_BUFSIZ));

if (n <= 0) { return false; }

if (!out(buf, n)) { return false; }

r += n;

if (progress) {

if (!progress(r, len)) { return false; }

}

}

return true;

}

void skip_content_with_length(Stream &strm, uint64_t len) {

char buf[CPPHTTPLIB_RECV_BUFSIZ];

uint64_t r = 0;

while (r < len) {

auto read_len = static_cast<size_t>(len - r);

auto n = strm.read(buf, std::min(read_len, CPPHTTPLIB_RECV_BUFSIZ));

if (n <= 0) { return; }

r += n;

}

}

bool read_content_without_length(Stream &strm, ContentReceiver out) {

char buf[CPPHTTPLIB_RECV_BUFSIZ];

for (;;) {

auto n = strm.read(buf, CPPHTTPLIB_RECV_BUFSIZ);

if (n < 0) {

return false;

}

else if (n == 0) {

return true;

}

if (!out(buf, n)) { return false; }

}

return true;

}

bool read_content_chunked(Stream &strm, ContentReceiver out) {

const auto bufsiz = 16;

char buf[bufsiz];

stream_line_reader line_reader(strm, buf, bufsiz);

if (!line_reader.getline()) { return false; }

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 (!line_reader.getline()) { return false; }

if (strcmp(line_reader.ptr(), "\r\n")) { break; }

if (!line_reader.getline()) { return false; }

chunk_len = std::stoi(line_reader.ptr(), 0, 16);

}

if (chunk_len == 0) {

// Reader terminator after chunks

if (!line_reader.getline() || strcmp(line_reader.ptr(), "\r\n"))

return false;

}

return true;

}

std::string make_content_range_header_field(size_t offset, size_t length,

size_t content_length) {

std::string field = "bytes ";

field += std::to_string(offset);

field += "-";

field += std::to_string(offset + length - 1);

field += "/";

field += std::to_string(content_length);

return field;

}

template <typename SToken, typename CToken, typename Content>

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

const std::string &boundary,

const std::string &content_type,

SToken stoken, CToken ctoken,

Content content) {

for (size_t i = 0; i < req.ranges.size(); i++) {

ctoken("--");

stoken(boundary);

ctoken("\r\n");

if (!content_type.empty()) {

ctoken("Content-Type: ");

stoken(content_type);

ctoken("\r\n");

}

auto offsets = detail::get_range_offset_and_length(req, res.body.size(), i);

auto offset = offsets.first;

auto length = offsets.second;

ctoken("Content-Range: ");

stoken(make_content_range_header_field(offset, length, res.body.size()));

ctoken("\r\n");

ctoken("\r\n");

if (!content(offset, length)) { return false; }

ctoken("\r\n");

}

ctoken("--");

stoken(boundary);

ctoken("--\r\n");

return true;

}

std::string make_multipart_ranges_data(const Request &req, Response &res,

const std::string &boundary,

const std::string &content_type) {

std::string data;

process_multipart_ranges_data(

req, res, boundary, content_type,

[&](const std::string &token) { data += token; },

[&](const char *token) { data += token; },

[&](size_t offset, size_t length) {

data += res.body.substr(offset, length);

return true;

});

return data;

}

size_t

get_multipart_ranges_data_length(const Request &req, Response &res,

const std::string &boundary,

const std::string &content_type) {

size_t data_length = 0;

process_multipart_ranges_data(

req, res, boundary, content_type,

[&](const std::string &token) { data_length += token.size(); },

[&](const char *token) { data_length += strlen(token); },

[&](size_t /*offset*/, size_t length) {

data_length += length;

return true;

});

return data_length;

}

ssize_t write_content(Stream &strm, ContentProvider content_provider,

size_t offset, size_t length) {

size_t begin_offset = offset;

size_t end_offset = offset + length;

while (offset < end_offset) {

ssize_t written_length = 0;

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

}

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

Response &res,

const std::string &boundary,

const std::string &content_type) {

return process_multipart_ranges_data(

req, res, boundary, content_type,

[&](const std::string &token) { strm.write(token); },

[&](const char *token) { strm.write(token); },

[&](size_t offset, size_t length) {

return write_content(strm, res.content_provider, offset, length) >= 0;

});

}

int Stream::write(const char *ptr) { return write(ptr, strlen(ptr)); }

int Stream::write(const std::string &s) {

return write(s.data(), s.size());

}

template <typename... Args>

int Stream::write_format(const char *fmt, const Args &... args) {

std::array<char, 2048> buf;

#if defined(_MSC_VER) && _MSC_VER < 1900

auto n = _snprintf_s(buf, bufsiz, buf.size() - 1, fmt, args...);

#else

auto n = snprintf(buf.data(), buf.size() - 1, fmt, args...);

#endif

if (n <= 0) { return n; }

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

#if defined(_MSC_VER) && _MSC_VER < 1900

n = _snprintf_s(&glowable_buf[0], glowable_buf.size(),

glowable_buf.size() - 1, fmt, args...);

#else

n = snprintf(&glowable_buf[0], glowable_buf.size() - 1, fmt, args...);

#endif

}

return write(&glowable_buf[0], n);

}

else {

return write(buf.data(), n);

}

}

namespace detail {

std::pair<size_t, size_t>

get_range_offset_and_length(const Request &req, size_t content_length,

size_t index) {

auto r = req.ranges[index];

if (r.first == -1 && r.second == -1) {

return std::make_pair(0, content_length);

}

if (r.first == -1) {

r.first = content_length - r.second;

r.second = content_length - 1;

}

if (r.second == -1) { r.second = content_length - 1; }

return std::make_pair(r.first, r.second - r.first + 1);

}

std::pair<size_t, size_t>

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

return std::make_pair(r.first, r.second - r.first + 1);

}

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

std::array<char, NI_MAXHOST> ipstr{};

if (!getnameinfo(reinterpret_cast<struct sockaddr *>(&addr), len,

ipstr.data(), ipstr.size(), nullptr, 0, NI_NUMERICHOST)) {

return ipstr.data();

}

}

return std::string();

}

}// namespace detail

//namespace detail {

// Socket stream implementation

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

SocketStream::~SocketStream() {}

bool SocketStream::is_readable() const {

return select_read(sock_, read_timeout_sec_, read_timeout_usec_) > 0;

}

bool SocketStream::is_writable() const {

return select_write(sock_, 0, 0) > 0;

}

int SocketStream::read(char *ptr, size_t size) {

if (is_readable()) { return recv(sock_, ptr, static_cast<int>(size), 0); }

return -1;

}

int SocketStream::write(const char *ptr, size_t size) {

if (is_writable()) { return send(sock_, ptr, static_cast<int>(size), 0); }

return -1;

}

std::string SocketStream::get_remote_addr() const {

return detail::get_remote_addr(sock_);

}

// Buffer stream implementation

bool BufferStream::is_readable() const { return true; }

bool BufferStream::is_writable() const { return true; }

int BufferStream::read(char *ptr, size_t size) {

#if defined(_MSC_VER) && _MSC_VER < 1900

int len_read = static_cast<int>(buffer._Copy_s(ptr, size, size, position));

#else

int len_read = static_cast<int>(buffer.copy(ptr, size, position));

#endif

position += len_read;

return len_read;

}

int BufferStream::write(const char *ptr, size_t size) {

buffer.append(ptr, size);

return static_cast<int>(size);

}

std::string BufferStream::get_remote_addr() const { return ""; }

const std::string &BufferStream::get_buffer() const { return buffer; }

//} // namespace detail

// HTTP server implementation

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 = [] { return new ThreadPool(CPPHTTPLIB_THREAD_POOL_COUNT); };

}

Server::~Server() {}

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

get_handlers_.push_back(std::make_pair(std::regex(pattern), handler));

return *this;

}

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

post_handlers_.push_back(std::make_pair(std::regex(pattern), handler));

return *this;

}

Server &Server::Post(const char *pattern,

HandlerWithContentReader handler) {

post_handlers_for_content_reader_.push_back(

std::make_pair(std::regex(pattern), handler));

return *this;

}

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

put_handlers_.push_back(std::make_pair(std::regex(pattern), handler));

return *this;

}

Server &Server::Put(const char *pattern,

HandlerWithContentReader handler) {

put_handlers_for_content_reader_.push_back(

std::make_pair(std::regex(pattern), handler));

return *this;

}

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

patch_handlers_.push_back(std::make_pair(std::regex(pattern), handler));

return *this;

}

Server &Server::Patch(const char *pattern,

HandlerWithContentReader handler) {

patch_handlers_for_content_reader_.push_back(

std::make_pair(std::regex(pattern), handler));

return *this;

}

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

delete_handlers_.push_back(std::make_pair(std::regex(pattern), handler));

return *this;

}

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

options_handlers_.push_back(std::make_pair(std::regex(pattern), handler));

return *this;

}

bool Server::set_base_dir(const char *dir, const char *mount_point) {

return set_mount_point(mount_point, dir);

}

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;

}

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;

}

void Server::set_file_extension_and_mimetype_mapping(const char *ext,

const char *mime) {

file_extension_and_mimetype_map_[ext] = mime;

}