From 8530821351972aeacb6f38ef2ddb0506454b50a9 Mon Sep 17 00:00:00 2001 From: Quella777 <2892744389@qq.com> Date: Wed, 19 Nov 2025 11:06:53 +0800 Subject: [PATCH] =?UTF-8?q?=E6=A0=B9=E6=8D=AE=E8=B7=9D=E7=A6=BB=E6=A0=87?= =?UTF-8?q?=E6=A1=86=E5=AE=8C=E6=88=90?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- InitAuth/conf/.env | 5 + VideoProsessing/NetraLib/README.md | 128 + .../NetraLib/include/NetRequest.hpp | 344 + VideoProsessing/NetraLib/include/Netra.hpp | 426 + .../NetraLib/include/QCL_Include.hpp | 55 + VideoProsessing/NetraLib/include/README.md | 850 ++ VideoProsessing/NetraLib/include/encrypt.hpp | 14 + VideoProsessing/NetraLib/include/httplib.h | 8794 +++++++++++++++++ VideoProsessing/NetraLib/src/NetRequest.cpp | 635 ++ VideoProsessing/NetraLib/src/Netra.cpp | 693 ++ VideoProsessing/NetraLib/src/encrypt.cpp | 91 + VideoProsessing/bin/video | Bin 2215080 -> 2650104 bytes VideoProsessing/src/main.cpp | 60 +- VideoProsessing/src/makefile | 5 +- softWareInit/bin/wifi | Bin 10436912 -> 10445192 bytes softWareInit/src/main.cpp | 18 +- 16 files changed, 12106 insertions(+), 12 deletions(-) create mode 100644 VideoProsessing/NetraLib/README.md create mode 100644 VideoProsessing/NetraLib/include/NetRequest.hpp create mode 100644 VideoProsessing/NetraLib/include/Netra.hpp create mode 100644 VideoProsessing/NetraLib/include/QCL_Include.hpp create mode 100644 VideoProsessing/NetraLib/include/README.md create mode 100644 VideoProsessing/NetraLib/include/encrypt.hpp create mode 100644 VideoProsessing/NetraLib/include/httplib.h create mode 100644 VideoProsessing/NetraLib/src/NetRequest.cpp create mode 100644 VideoProsessing/NetraLib/src/Netra.cpp create mode 100644 VideoProsessing/NetraLib/src/encrypt.cpp diff --git a/InitAuth/conf/.env b/InitAuth/conf/.env index b235a6b..3a48366 100644 --- a/InitAuth/conf/.env +++ b/InitAuth/conf/.env @@ -6,3 +6,8 @@ ServerPwd:"17227ca72f30f8bca8158bb78f25b43e" #以下配置存储GPIO输出高低电平--状态机 outPutMode:true + +#以下配置存储报警距离 +NEAR_THRESHOLD=3 +MID_THRESHOLD=5 +MAX_DISTANCE=10 diff --git a/VideoProsessing/NetraLib/README.md b/VideoProsessing/NetraLib/README.md new file mode 100644 index 0000000..c680108 --- /dev/null +++ b/VideoProsessing/NetraLib/README.md @@ -0,0 +1,128 @@ +# NetraLib +c/c++基本开发库 + +# TCP 服务端操作 +包括多线程客户端连接,指定客户端数据的收发等等功能 + +# Linux 中屏蔽所有信号操作 +屏蔽所有信号,以防止意外退出 + + +# 写文件操作 +允许原文本进行覆盖写,追加写 +允许二进制进行覆盖写,追加写 +允许在特定位置后面进行插入覆盖操作 +允许删除特定字段后面所有内容在进行写操作 +可以根据需要计算特定符号最后一个字节或者第一个字节所在位置所在位置 + +所有操作都添加mutex锁机制 ,保障线程安全 + + +# 读文件操作 +支持全文读取（文本和二进制模式） +支持按行读取文本内容 +支持按指定字节数读取数据 +支持计算第一个指定字节序列结束位置（包含该序列本身）的字节数 +提供文件是否存在和文件大小查询 +支持重置文件读取位置，实现多次读取 + +所有操作都添加mutex锁机制 ,保障线程安全 + + +# 字符串操作 +支持左右空格删除 +支持格式化输出 + + +# Http请求 +提供基于 `cpp-httplib` 的简易 HTTP 客户端封装 `NetRequest`，支持： +1. 同步/异步 GET、POST（JSON、表单） +2. 连接/读写超时设置、Keep-Alive +3. 并发请求上限控制 +4. 可选内存缓存（GET 命中时不发起网络请求） +5. 简单日志回调与性能统计 +6. 断点续传下载到本地文件 + +使用步骤： + +1) 引入头文件，配置目标地址 +```cpp +#include "NetRequest.hpp" + +ntq::RequestOptions opt; +opt.scheme = "http"; // 或 https +opt.host = "127.0.0.1"; // 服务器地址 +opt.port = 8080; // 端口（https 一般 443） +opt.base_path = "/api"; // 可选统一前缀 +opt.connect_timeout_ms = 3000; +opt.read_timeout_ms = 8000; +opt.write_timeout_ms = 8000; +opt.default_headers = { {"Authorization", "Bearer TOKEN"} }; // 可选 + +ntq::NetRequest req(opt); +req.setMaxConcurrentRequests(4); +req.enableCache(std::chrono::seconds(10)); +``` + +2) 发送 GET 请求 +```cpp +auto r = req.Get("/info"); +if (r && r->status == 200) { + // r->body 为返回内容 +} + +// 带查询参数与额外请求头 +httplib::Params q = {{"q","hello"},{"page","1"}}; +httplib::Headers h = {{"X-Req-Id","123"}}; +auto r2 = req.Get("/search", q, h); +``` + +3) 发送 POST 请求 +```cpp +// JSON（Content-Type: application/json） +std::string json = R"({"name":"orangepi","mode":"demo"})"; +auto p1 = req.PostJson("/set", json); + +// 表单（application/x-www-form-urlencoded） +httplib::Params form = {{"user","abc"},{"pwd","123"}}; +auto p2 = req.PostForm("/login", form); +``` + +4) 异步调用 +```cpp +auto fut = req.GetAsync("/info"); +auto res = fut.get(); // 与同步用法一致 +``` + +5) 下载到本地（支持断点续传） +```cpp +bool ok = req.DownloadToFile("/files/pkg.bin", "/tmp/pkg.bin", {}, /*resume*/true); +``` + +6) 统计信息 +```cpp +auto s = req.getStats(); +// s.total_requests / s.total_errors / s.last_latency_ms / s.avg_latency_ms +``` + +说明： +- 若使用 HTTPS，需在编译时添加 `-DCPPHTTPLIB_OPENSSL_SUPPORT` 并链接 `-lssl -lcrypto`，且将 `opt.scheme` 设为 `"https"`、端口通常为 `443`。 +- `base_path` 与各函数传入的 `path` 会自动合并，例如 `base_path="/api"` 且 `Get("/info")` 实际请求路径为 `/api/info`。 + +7) 快速用法（无需实例化） +```cpp +using ntq::NetRequest; + +// 直接传完整 URL 发起 GET +auto g = NetRequest::QuickGet("http://127.0.0.1:8080/api/info"); + +// 直接传完整 URL 发起 POST(JSON) +auto p1 = NetRequest::QuickPostJson( + "http://127.0.0.1:8080/api/set", + R"({"name":"orangepi","mode":"demo"})" +); + +// 直接传完整 URL 发起 POST(表单) +httplib::Params form = {{"user","abc"},{"pwd","123"}}; +auto p2 = NetRequest::QuickPostForm("http://127.0.0.1:8080/login", form); +``` diff --git a/VideoProsessing/NetraLib/include/NetRequest.hpp b/VideoProsessing/NetraLib/include/NetRequest.hpp new file mode 100644 index 0000000..3cb473c --- /dev/null +++ b/VideoProsessing/NetraLib/include/NetRequest.hpp @@ -0,0 +1,344 @@ +/* +本文件 +网络请求类需要实现以下功能： +1. 发送网络请求 +2. 接收网络响应 +3. 处理网络请求和响应 +4. 实现网络请求和响应的回调函数 +5. 实现网络请求和响应的错误处理 +6. 实现网络请求和响应的日志记录 +7. 实现网络请求和响应的性能统计 +8. 实现网络请求和响应的并发控制 +9. 实现网络请求和响应的缓存管理 +10. 实现网络请求和响应的断点续传 +11. 实现网络请求和响应的断点续传 +12. 实现网络请求和响应的断点续传 +13. 实现网络请求和响应的断点续传 +14. 实现网络请求和响应的断点续传 +*/ +#pragma once +#include "httplib.h" +#include +#include +#include +#include + +// C++17/14 可选类型回退适配：统一使用 ntq::optional / ntq::nullopt +#if defined(__has_include) + #if __has_include() + #include + // 仅当启用了 C++17 或库声明了 optional 功能时，才使用 std::optional + #if defined(__cpp_lib_optional) || (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) + namespace ntq { template using optional = std::optional; } + namespace ntq { constexpr auto nullopt = std::nullopt; using nullopt_t = decltype(std::nullopt); } + #elif __has_include() + #include + namespace ntq { template using optional = std::experimental::optional; } + namespace ntq { constexpr auto nullopt = std::experimental::nullopt; using nullopt_t = decltype(std::experimental::nullopt); } + #else + #include + namespace ntq { + struct nullopt_t { explicit constexpr nullopt_t(int) {} }; + static constexpr nullopt_t nullopt{0}; + template + class optional { + public: + optional() : has_(false) {} + optional(nullopt_t) : has_(false) {} + optional(const T &v) : has_(true), value_(v) {} + optional(T &&v) : has_(true), value_(std::move(v)) {} + optional(const optional &o) : has_(o.has_), value_(o.has_ ? o.value_ : T{}) {} + optional(optional &&o) noexcept : has_(o.has_), value_(std::move(o.value_)) {} + optional &operator=(nullopt_t) { has_ = false; return *this; } + optional &operator=(const T &v) { value_ = v; has_ = true; return *this; } + optional &operator=(T &&v) { value_ = std::move(v); has_ = true; return *this; } + explicit operator bool() const { return has_; } + bool has_value() const { return has_; } + T &value() { return value_; } + const T &value() const { return value_; } + T &operator*() { return value_; } + const T &operator*() const { return value_; } + private: + bool has_ = false; + T value_{}; + }; + } + #endif + #elif __has_include() + #include + namespace ntq { template using optional = std::experimental::optional; } + namespace ntq { constexpr auto nullopt = std::experimental::nullopt; using nullopt_t = decltype(std::experimental::nullopt); } + #else + #include + namespace ntq { + struct nullopt_t { explicit constexpr nullopt_t(int) {} }; + static constexpr nullopt_t nullopt{0}; + template + class optional { + public: + optional() : has_(false) {} + optional(nullopt_t) : has_(false) {} + optional(const T &v) : has_(true), value_(v) {} + optional(T &&v) : has_(true), value_(std::move(v)) {} + optional(const optional &o) : has_(o.has_), value_(o.has_ ? o.value_ : T{}) {} + optional(optional &&o) noexcept : has_(o.has_), value_(std::move(o.value_)) {} + optional &operator=(nullopt_t) { has_ = false; return *this; } + optional &operator=(const T &v) { value_ = v; has_ = true; return *this; } + optional &operator=(T &&v) { value_ = std::move(v); has_ = true; return *this; } + explicit operator bool() const { return has_; } + bool has_value() const { return has_; } + T &value() { return value_; } + const T &value() const { return value_; } + T &operator*() { return value_; } + const T &operator*() const { return value_; } + private: + bool has_ = false; + T value_{}; + }; + } + #endif +#else + // 无 __has_include：按语言级别判断 + #if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) + #include + namespace ntq { template using optional = std::optional; } + namespace ntq { constexpr auto nullopt = std::nullopt; using nullopt_t = decltype(std::nullopt); } + #else + #include + namespace ntq { template using optional = std::experimental::optional; } + namespace ntq { constexpr auto nullopt = std::experimental::nullopt; using nullopt_t = decltype(std::experimental::nullopt); } + #endif +#endif + +namespace ntq +{ + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /** + * @brief HTTP 响应对象 + * + * 用于承载一次请求返回的状态码、正文与响应头； + * 当 from_cache 为 true 时，表示该响应来自本地缓存（而非实时网络）。 + */ + struct HttpResponse + { + int status = 0; ///< HTTP 状态码（例如 200, 404 等） + std::string body; ///< 响应正文 + httplib::Headers headers; ///< 响应头（大小写不敏感） + bool from_cache = false; ///< 是否来自缓存 + }; + + /** + * @brief 错误码定义 + */ + enum class ErrorCode + { + None = 0, ///< 无错误 + Network, ///< 网络错误（连接失败/发送失败/接收失败等） + Timeout, ///< 超时 + Canceled, ///< 被取消 + InvalidURL, ///< URL 非法 + IOError, ///< 本地 IO 错误（如写文件失败） + SSL, ///< SSL/HTTPS 相关错误 + Unknown ///< 未分类错误 + }; + + /** + * @brief 请求级别的参数配置 + * + * 包含基础连接信息（协议、主机、端口）与默认头部、超时设置等。 + */ + struct RequestOptions + { + std::string scheme = "http"; ///< 协议：http 或 https + std::string host; ///< 目标主机名或 IP（必填） + int port = 80; ///< 端口，http 默认为 80，https 通常为 443 + std::string base_path; ///< 可选的统一前缀（例如 "/api/v1"） + + int connect_timeout_ms = 5000; ///< 连接超时（毫秒） + int read_timeout_ms = 10000; ///< 读取超时（毫秒） + int write_timeout_ms = 10000; ///< 写入超时（毫秒） + bool keep_alive = true; ///< 是否保持连接（Keep-Alive） + + httplib::Headers default_headers; ///< 默认头部，随所有请求发送 + }; + + /** + * @class NetRequest + * @brief HTTP 客户端封装（基于 cpp-httplib） + * + * 提供同步和异步的 GET/POST 请求、并发限制、可选缓存、日志回调、 + * 性能统计以及断点续传下载到文件等能力。 + */ + class NetRequest + { + public: + using LogCallback = std::function; ///< 日志回调类型 + + /** + * @brief 运行时统计数据 + */ + struct Stats + { + uint64_t total_requests = 0; ///< 累计请求次数 + uint64_t total_errors = 0; ///< 累计失败次数 + double last_latency_ms = 0.0;///< 最近一次请求耗时（毫秒） + double avg_latency_ms = 0.0; ///< 指数平滑后的平均耗时（毫秒） + }; + + /** + * @brief 构造函数 + * @param options 请求参数配置（目标地址、超时、默认头部等） + */ + explicit NetRequest(const RequestOptions &options); + /** + * @brief 析构函数 + */ + ~NetRequest(); + + /** + * @brief 设置日志回调 + * @param logger 回调函数，接受一行日志字符串 + */ + void setLogger(LogCallback logger); + /** + * @brief 设置最大并发请求数 + * @param n 并发上限（最小值为 1） + */ + void setMaxConcurrentRequests(size_t n); + /** + * @brief 启用内存缓存 + * @param ttl 缓存有效期（超时后自动失效） + */ + void enableCache(std::chrono::milliseconds ttl); + /** + * @brief 禁用并清空缓存 + */ + void disableCache(); + + /** + * @brief 发送同步 GET 请求 + * @param path 资源路径（会与 base_path 合并） + * @param query 查询参数（会拼接为 ?k=v&...） + * @param headers 额外请求头（与默认头部合并） + * @param err 可选错误码输出 + * @return 成功返回响应对象，失败返回 std::nullopt + */ + ntq::optional Get(const std::string &path, + const httplib::Params &query = {}, + const httplib::Headers &headers = {}, + ErrorCode *err = nullptr); + + /** + * @brief 发送同步 POST JSON 请求 + * @param path 资源路径 + * @param json JSON 字符串（Content-Type: application/json） + * @param headers 额外头部 + * @param err 可选错误码输出 + * @return 成功返回响应对象，失败返回 std::nullopt + */ + ntq::optional PostJson(const std::string &path, + const std::string &json, + const httplib::Headers &headers = {}, + ErrorCode *err = nullptr); + + /** + * @brief 发送同步 POST 表单请求（application/x-www-form-urlencoded） + * @param path 资源路径 + * @param form 表单参数 + * @param headers 额外头部 + * @param err 可选错误码输出 + * @return 成功返回响应对象，失败返回 std::nullopt + */ + ntq::optional PostForm(const std::string &path, + const httplib::Params &form, + const httplib::Headers &headers = {}, + ErrorCode *err = nullptr); + + /** + * @brief 异步 GET 请求 + * @return std::future，用于获取响应结果 + */ + std::future> GetAsync(const std::string &path, + const httplib::Params &query = {}, + const httplib::Headers &headers = {}, + ErrorCode *err = nullptr); + + /** + * @brief 异步 POST JSON 请求 + * @return std::future，用于获取响应结果 + */ + std::future> PostJsonAsync(const std::string &path, + const std::string &json, + const httplib::Headers &headers = {}, + ErrorCode *err = nullptr); + + /** + * @brief 异步 POST 表单请求 + * @return std::future，用于获取响应结果 + */ + std::future> PostFormAsync(const std::string &path, + const httplib::Params &form, + const httplib::Headers &headers = {}, + ErrorCode *err = nullptr); + + /** + * @brief 下载文件到本地，支持断点续传 + * @param path 资源路径 + * @param local_file 本地保存路径 + * @param headers 额外头部 + * @param resume 是否启用续传（Range） + * @param chunk_size 预留参数：分块大小（当前由 httplib 内部回调驱动） + * @param err 可选错误码输出 + * @return true 下载成功（200 或 206），false 失败 + */ + bool DownloadToFile(const std::string &path, + const std::string &local_file, + const httplib::Headers &headers = {}, + bool resume = true, + size_t chunk_size = 1 << 15, + ErrorCode *err = nullptr); + + /** + * @brief 获取统计数据快照 + */ + Stats getStats() const; + + /** + * @brief 便捷：直接用完整 URL 发起 GET（无需显式实例化） + * @param url 形如 http://host:port/path?x=1 或 https://host/path + * @param headers 额外头部 + * @param err 可选错误码输出 + */ + static ntq::optional QuickGet(const std::string &url, + const httplib::Headers &headers = {}, + ErrorCode *err = nullptr); + + /** + * @brief 便捷：直接用完整 URL 发起 POST JSON（无需显式实例化） + * @param url 形如 http://host:port/path?x=1 或 https://host/path + * @param json JSON 字符串（Content-Type: application/json） + * @param headers 额外头部 + * @param err 可选错误码输出 + */ + static ntq::optional QuickPostJson(const std::string &url, + const std::string &json, + const httplib::Headers &headers = {}, + ErrorCode *err = nullptr); + + /** + * @brief 便捷：直接用完整 URL 发起 POST 表单（无需显式实例化） + * @param url 形如 http://host:port/path?x=1 或 https://host/path + * @param form 表单参数 + * @param headers 额外头部 + * @param err 可选错误码输出 + */ + static ntq::optional QuickPostForm(const std::string &url, + const httplib::Params &form, + const httplib::Headers &headers = {}, + ErrorCode *err = nullptr); + + private: + struct Impl; + Impl *impl_; + }; +} \ No newline at end of file diff --git a/VideoProsessing/NetraLib/include/Netra.hpp b/VideoProsessing/NetraLib/include/Netra.hpp new file mode 100644 index 0000000..362ae28 --- /dev/null +++ b/VideoProsessing/NetraLib/include/Netra.hpp @@ -0,0 +1,426 @@ +#pragma once +#include "QCL_Include.hpp" + +namespace QCL +{ + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /** + * @class TcpServer + * @brief 简单的多线程TCP服务器类，支持多个客户端连接，数据收发及断开处理 + * + * 该类使用一个线程专门用于监听客户端连接， + * 每当有客户端连接成功时，为其创建一个独立线程处理该客户端的数据收发。 + * 线程安全地管理所有客户端Socket句柄。 + */ + class TcpServer + { + public: + /** + * @brief 构造函数，指定监听端口 + * @param port 服务器监听端口号 + */ + TcpServer(int port); + + /** + * @brief 析构函数，自动调用 stop() 停止服务器并清理资源 + */ + ~TcpServer(); + + /** + * @brief 启动服务器，创建监听socket，开启监听线程 + * @return 启动成功返回true，失败返回false + */ + bool start(); + + /** + * @brief 停止服务器，关闭所有连接，释放资源，等待所有线程退出 + */ + void stop(); + + /** + * @brief 发送消息给指定客户端 + * @param clientSock 客户端Socket描述符 + * @param message 发送的字符串消息 + */ + void sendToClient(int clientSock, const std::string &message); + + /** + * @brief 从指定客户端接收数据（单次调用） + * @param clientSock 客户端Socket描述符 + * @param flag:false 非阻塞模式,true 阻塞模式 + */ + std::string receiveFromClient(int clientSock, bool flag = true); + + /** + * @brief 获取连接客户端的IP和端口 + * @param clientSock 客户端Socket描述符 + */ + char *getClientIPAndPort(int clientSock); + + /** + * @brief 获取当前所有已连接客户端Socket的副本 + * @return 包含所有客户端Socket的vector，线程安全 + */ + std::vector getClientSockets(); + + /** + * @brief 从服务器的客户端列表中移除并关闭一个客户端socket + * @param clientSock 客户端Socket描述符 + */ + void removeClient(int clientSock); + + /** + * @brief 非阻塞探测客户端是否已断开（不消耗数据） + * @param clientSock 客户端Socket描述符 + * @return true 已断开或发生致命错误；false 仍然存活或暂无数据 + */ + bool isClientDisconnected(int clientSock); + + private: + /** + * @brief 监听并接受新的客户端连接（运行在独立线程中） + */ + void acceptClients(); + + private: + int serverSock_; ///< 服务器监听Socket描述符 + int port_; ///< 服务器监听端口 + std::atomic running_; ///< 服务器运行状态标志（线程安全） + std::vector clientThreads_; ///< 用于处理每个客户端的线程集合 + std::thread acceptThread_; ///< 负责监听新连接的线程 + std::mutex clientsMutex_; ///< 保护clientSockets_的互斥锁 + std::vector clientSockets_; ///< 当前所有连接的客户端Socket集合 + }; + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /** + * @brief 文件写入工具类（线程安全） + * + * 该类支持多种文件写入方式： + * - 覆盖写文本 + * - 追加写文本 + * - 按位置覆盖原文写入 + * - 二进制覆盖写 + * - 二进制追加写 + * + * 特点： + * - 文件不存在时自动创建 + * - 支持覆盖和追加两种模式 + * - 支持二进制模式，适合写入非文本数据 + * - 内部使用 std::mutex 实现线程安全 + */ + class WriteFile + { + public: + /** + * @brief 构造函数 + * @param filePath 文件路径 + */ + explicit WriteFile(const std::string &filePath); + + /** + * @brief 覆盖写文本文件（线程安全） + * @param content 要写入的文本内容 + * @return true 写入成功 + * @return false 写入失败 + */ + bool overwriteText(const std::string &content); + + /** + * @brief 追加写文本文件（线程安全） + * @param content 要写入的文本内容 + * @return true 写入成功 + * @return false 写入失败 + */ + bool appendText(const std::string &content); + + /** + * @brief 覆盖写二进制文件（线程安全） + * @param data 要写入的二进制数据 + * @return true 写入成功 + * @return false 写入失败 + */ + bool overwriteBinary(const std::vector &data); + + /** + * @brief 追加写二进制文件（线程安全） + * @param data 要写入的二进制数据 + * @return true 写入成功 + * @return false 写入失败 + */ + bool appendBinary(const std::vector &data); + + /** + * @brief 计算第一个指定字节序列前的字节数 + * @param pattern 要查找的字节序列 + * @param includePattern true 表示返回值包含 pattern 自身长度，false 表示不包含 + * @return size_t 字节数，如果文件没打开或 pattern 为空则返回 0 + */ + size_t countBytesPattern(const std::string &pattern, bool includePattern = false); + + /** + * @brief 在文件中查找指定字节序列并在其后写入内容，如果不存在则追加到文件末尾 + * @param pattern 要查找的字节序列 + * @param content 要写入的内容 + * @return true 写入成功，false 文件打开失败 + * + * 功能说明： + * 1. 若文件中存在 pattern，则删除 pattern 之后的所有内容，并在其后插入 content。 + * 2. 若文件中不存在 pattern，则在文件末尾追加 content，若末尾无换行符则先补充换行。 + */ + bool writeAfterPatternOrAppend(const std::string &pattern, const std::string &content); + + /** + * @brief 在文件指定位置之后插入内容 + * @param content 要插入的内容 + * @param pos 插入位置（从文件开头算起的字节偏移量） + * @param length 插入的长度（>= content.size() 时，多余部分用空字节填充；< content.size() 时只截取前 length 个字节） + * @return true 插入成功，false 文件打开失败或参数不合法 + * + * 功能说明： + * 1. 不会覆盖原有数据，而是将 pos 之后的内容整体向后移动 length 个字节。 + * 2. 如果 length > content.size()，则在 content 后补充 '\0'（或空格，可按需求改）。 + * 3. 如果 length < content.size()，则只写入 content 的前 length 个字节。 + * 4. 文件整体大小会增加 length 个字节。 + * + * 举例： + * 原始文件内容: "ABCDEFG" + * insertAfterPos("XY", 2, 3) // 在索引 2 后插入 + * 结果: "ABX Y\0CDEFG" (这里 \0 代表补充的空字节) + */ + bool insertAfterPos(const std::string &content, size_t pos, size_t length); + + /** + * @brief 在文件指定位置覆盖写入内容 + * @param content 要写入的内容 + * @param pos 覆盖起始位置（从文件开头算起的字节偏移量） + * @param length 覆盖长度 + * @return true 覆盖成功，false 文件打开失败或 pos 越界 + * + * 功能说明： + * 1. 从 pos 开始覆盖 length 个字节，不会移动或增加文件大小。 + * 2. 如果 content.size() >= length，则只写入前 length 个字节。 + * 3. 如果 content.size() < length，则写入 content，并用 '\0' 补齐至 length。 + * 4. 如果 pos + length 超过文件末尾，则只覆盖到文件尾部，不会越界。 + * + * 举例： + * 原始文件内容: "ABCDEFG" + * overwriteAtPos("XY", 2, 3) + * 结果: "ABXYEFG" （原 "CDE" 被 "XY\0" 覆盖，\0 实际不可见） + */ + bool overwriteAtPos(const std::string &content, size_t pos, size_t length); + + void close(); + + private: + std::string filePath_; ///< 文件路径 + std::mutex writeMutex_; ///< 线程锁，保证多线程写入安全 + + /** + * @brief 通用文本写入接口（线程安全） + * @param content 要写入的内容 + * @param mode 打开模式（追加/覆盖等） + * @return true 写入成功 + * @return false 写入失败 + */ + bool writeToFile(const std::string &content, std::ios::openmode mode); + + /** + * @brief 通用二进制写入接口（线程安全） + * @param data 要写入的二进制数据 + * @param mode 打开模式（追加/覆盖等） + * @return true 写入成功 + * @return false 写入失败 + */ + bool writeBinary(const std::vector &data, std::ios::openmode mode); + }; + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /** + * @brief ReadFile 类 - 读文件操作工具类 + * + * 功能： + * 1. 读取全文（文本 / 二进制） + * 2. 按行读取 + * 3. 按字节数读取 + * 4. 获取指定字节序列前的字节数（包含该字节序列） + * 5. 检查文件是否存在 + * 6. 获取文件大小 + * + * 设计： + * - 与 WriteFile 类风格保持一致 + * - 支持文本文件与二进制文件 + * - 自动关闭文件（析构时） + * - 内部使用 std::mutex 实现线程安全 + */ + class ReadFile + { + public: + /** + * @brief 构造函数 + * @param filename 文件路径 + */ + explicit ReadFile(const std::string &filename); + + /** + * @brief 析构函数，自动关闭文件 + */ + ~ReadFile(); + + /** + * @brief 打开文件（以二进制方式） + * @return true 打开成功 + * @return false 打开失败 + */ + bool Open(); + + /** + * @brief 关闭文件 + */ + void Close(); + + /** + * @brief 文件是否已经打开 + */ + bool IsOpen() const; + + /** + * @brief 读取全文（文本模式） + * @return 文件内容字符串 + */ + std::string ReadAllText(); + + /** + * @brief 读取全文（二进制模式） + * @return 文件内容字节数组 + */ + std::vector ReadAllBinary(); + + /** + * @brief 按行读取文本 + * @return 每行作为一个字符串的 vector + */ + std::vector ReadLines(); + + /** + * @brief 读取指定字节数 + * @param count 要读取的字节数 + * @return 实际读取到的字节数据 + */ + std::vector ReadBytes(size_t count); + + /** + * @brief 获取指定字节序列前的字节数（包含该字节序列） + * @param marker 要查找的字节序列（可能不止一个字节） + * @return 如果找到，返回前面部分字节数；找不到返回0 + */ + size_t GetBytesBefore(const std::string &marker, bool includeMarker = false); + + /** + * @brief 从指定位置读取指定字节数，默认读取到文件末尾 + * @param pos 起始位置（字节偏移） + * @param count 要读取的字节数，默认为0表示读取到文件末尾 + * @return 读取到的字节数据 + */ + std::vector ReadBytesFrom(size_t pos, size_t count = 0); + + /** + * @brief 检查文件是否存在 + */ + bool FileExists() const; + + /** + * @brief 获取文件大小（字节数） + */ + size_t GetFileSize() const; + + /** + * @brief 重置读取位置到文件开头 + */ + void Reset(); + + private: + std::string filename_; // 文件路径 + std::ifstream file_; // 文件流对象 + mutable std::mutex mtx_; // 可变，保证 const 方法也能加锁 + }; + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + // 屏蔽所有信号 + void blockAllSignals(); + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + // 字符串操作 + // 去除字符串的左空格 + std::string Ltrim(const std::string &s); + + // 去除字符串右侧的空格 + std::string Rtrim(const std::string &s); + + // 去除字符串左右两侧的空格 + std::string LRtrim(const std::string &s); + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + // c++进行格式化输出 + // 通用类型转字符串 + template + std::string to_string_any(const T &value) + { + std::ostringstream oss; + oss << value; + return oss.str(); + } + + // 递归获取 tuple 中 index 对应参数 + template + std::string get_tuple_arg(const Tuple &tup, std::size_t index) + { + if constexpr (I < std::tuple_size_v) + { + if (I == index) + return to_string_any(std::get(tup)); + else + return get_tuple_arg(tup, index); + } + else + { + throw std::runtime_error("Too few arguments for format string"); + } + } + + // format 函数 + template + std::string format(const std::string &fmt, const Args &...args) + { + std::ostringstream oss; + std::tuple tup(args...); + size_t pos = 0; + size_t arg_idx = 0; + + while (pos < fmt.size()) + { + if (fmt[pos] == '{' && pos + 1 < fmt.size() && fmt[pos + 1] == '{') + { + oss << '{'; + pos += 2; + } + else if (fmt[pos] == '}' && pos + 1 < fmt.size() && fmt[pos + 1] == '}') + { + oss << '}'; + pos += 2; + } + else if (fmt[pos] == '{' && pos + 1 < fmt.size() && fmt[pos + 1] == '}') + { + oss << get_tuple_arg(tup, arg_idx++); + pos += 2; + } + else + { + oss << fmt[pos++]; + } + } + + if (arg_idx < sizeof...(Args)) + throw std::runtime_error("Too many arguments for format string"); + + return oss.str(); + } + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +} diff --git a/VideoProsessing/NetraLib/include/QCL_Include.hpp b/VideoProsessing/NetraLib/include/QCL_Include.hpp new file mode 100644 index 0000000..52a20fb --- /dev/null +++ b/VideoProsessing/NetraLib/include/QCL_Include.hpp @@ -0,0 +1,55 @@ +/** + * @file qcl_include.hpp + * @brief 通用C++开发头文件集合（Linux环境） + * @note 使用前确保目标平台支持C++17标准 + */ +#ifndef QCL_INCLUDE_HPP +#define QCL_INCLUDE_HPP + +// ==================== C/C++基础运行时库 ==================== +#include // 标准输入输出流（cin/cout/cerr） +#include // std::string类及相关操作 +#include // C风格字符串操作（strcpy/strcmp等） +#include // 通用工具函数（atoi/rand/malloc等） +#include // C风格IO（printf/scanf） +#include // 断言宏（调试期检查） +#include // 数学函数（sin/pow等） +#include // 时间处理（time/clock） +#include // 信号处理（signal/kill） +#include // 智能指针 + +// ==================== STL容器与算法 ==================== +#include // 动态数组（连续内存容器） +#include // 双向链表 +#include // 双端队列 +#include // 有序键值对（红黑树实现） +#include // 有序集合 +#include // 哈希表实现的键值对 +#include // 哈希表实现的集合 +#include // 栈适配器（LIFO） +#include // 队列适配器（FIFO） +#include // 通用算法（sort/find等） +#include // 数值算法（accumulate等） +#include // 迭代器相关 + +// ==================== 字符串与流处理 ==================== +#include // 字符串流（内存IO） +#include // 文件流（文件IO） +#include // 流格式控制（setw/setprecision） +#include // 正则表达式 +#include // 文件系统(C++17) +#include + +// ==================== 并发编程支持 ==================== +#include // 线程管理（std::thread） +#include // 互斥锁（mutex/lock_guard） +#include // 原子操作（线程安全变量） +#include // 条件变量（线程同步） + +// ==================== Linux网络编程 ==================== +#include // 套接字基础API（socket/bind） +#include // IPV4/IPV6地址结构体 +#include // 地址转换函数（inet_pton等） +#include // POSIX API（close/read/write） + +#endif // QCL_INCLUDE_HPP diff --git a/VideoProsessing/NetraLib/include/README.md b/VideoProsessing/NetraLib/include/README.md new file mode 100644 index 0000000..984ab89 --- /dev/null +++ b/VideoProsessing/NetraLib/include/README.md @@ -0,0 +1,850 @@ +cpp-httplib +=========== + +[![](https://github.com/yhirose/cpp-httplib/workflows/test/badge.svg)](https://github.com/yhirose/cpp-httplib/actions) + +A C++11 single-file header-only cross platform HTTP/HTTPS library. + +It's extremely easy to setup. Just include the **httplib.h** file in your code! + +NOTE: This library uses 'blocking' socket I/O. If you are looking for a library with 'non-blocking' socket I/O, this is not the one that you want. + +Simple examples +--------------- + +#### Server (Multi-threaded) + +```c++ +#define CPPHTTPLIB_OPENSSL_SUPPORT +#include "path/to/httplib.h" + +// HTTP +httplib::Server svr; + +// HTTPS +httplib::SSLServer svr; + +svr.Get("/hi", [](const httplib::Request &, httplib::Response &res) { + res.set_content("Hello World!", "text/plain"); +}); + +svr.listen("0.0.0.0", 8080); +``` + +#### Client + +```c++ +#define CPPHTTPLIB_OPENSSL_SUPPORT +#include "path/to/httplib.h" + +// HTTP +httplib::Client cli("http://cpp-httplib-server.yhirose.repl.co"); + +// HTTPS +httplib::Client cli("https://cpp-httplib-server.yhirose.repl.co"); + +auto res = cli.Get("/hi"); +res->status; +res->body; +``` + +SSL Support +----------- + +SSL support is available with `CPPHTTPLIB_OPENSSL_SUPPORT`. `libssl` and `libcrypto` should be linked. + +NOTE: cpp-httplib currently supports only version 1.1.1 and 3.0. + +NOTE for macOS: cpp-httplib now can use system certs with `CPPHTTPLIB_USE_CERTS_FROM_MACOSX_KEYCHAIN`. `CoreFoundation` and `Security` should be linked with `-framework`. + +```c++ +#define CPPHTTPLIB_OPENSSL_SUPPORT +#include "path/to/httplib.h" + +// Server +httplib::SSLServer svr("./cert.pem", "./key.pem"); + +// Client +httplib::Client cli("https://localhost:1234"); // scheme + host +httplib::SSLClient cli("localhost:1234"); // host +httplib::SSLClient cli("localhost", 1234); // host, port + +// Use your CA bundle +cli.set_ca_cert_path("./ca-bundle.crt"); + +// Disable cert verification +cli.enable_server_certificate_verification(false); +``` + +NOTE: When using SSL, it seems impossible to avoid SIGPIPE in all cases, since on some operating systems, SIGPIPE can only be suppressed on a per-message basis, but there is no way to make the OpenSSL library do so for its internal communications. If your program needs to avoid being terminated on SIGPIPE, the only fully general way might be to set up a signal handler for SIGPIPE to handle or ignore it yourself. + +Server +------ + +```c++ +#include + +int main(void) +{ + using namespace httplib; + + Server svr; + + svr.Get("/hi", [](const Request& req, Response& res) { + res.set_content("Hello World!", "text/plain"); + }); + + svr.Get(R"(/numbers/(\d+))", [&](const Request& req, Response& res) { + auto numbers = req.matches[1]; + res.set_content(numbers, "text/plain"); + }); + + svr.Get("/body-header-param", [](const Request& req, Response& res) { + if (req.has_header("Content-Length")) { + auto val = req.get_header_value("Content-Length"); + } + if (req.has_param("key")) { + auto val = req.get_param_value("key"); + } + res.set_content(req.body, "text/plain"); + }); + + svr.Get("/stop", [&](const Request& req, Response& res) { + svr.stop(); + }); + + svr.listen("localhost", 1234); +} +``` + +`Post`, `Put`, `Delete` and `Options` methods are also supported. + +### Bind a socket to multiple interfaces and any available port + +```cpp +int port = svr.bind_to_any_port("0.0.0.0"); +svr.listen_after_bind(); +``` + +### Static File Server + +```cpp +// Mount / to ./www directory +auto ret = svr.set_mount_point("/", "./www"); +if (!ret) { + // The specified base directory doesn't exist... +} + +// Mount /public to ./www directory +ret = svr.set_mount_point("/public", "./www"); + +// Mount /public to ./www1 and ./www2 directories +ret = svr.set_mount_point("/public", "./www1"); // 1st order to search +ret = svr.set_mount_point("/public", "./www2"); // 2nd order to search + +// Remove mount / +ret = svr.remove_mount_point("/"); + +// Remove mount /public +ret = svr.remove_mount_point("/public"); +``` + +```cpp +// User defined file extension and MIME type mappings +svr.set_file_extension_and_mimetype_mapping("cc", "text/x-c"); +svr.set_file_extension_and_mimetype_mapping("cpp", "text/x-c"); +svr.set_file_extension_and_mimetype_mapping("hh", "text/x-h"); +``` + +The followings are built-in mappings: + +| Extension | MIME Type | Extension | MIME Type | +| :--------- | :-------------------------- | :--------- | :-------------------------- | +| css | text/css | mpga | audio/mpeg | +| csv | text/csv | weba | audio/webm | +| txt | text/plain | wav | audio/wave | +| vtt | text/vtt | otf | font/otf | +| html, htm | text/html | ttf | font/ttf | +| apng | image/apng | woff | font/woff | +| avif | image/avif | woff2 | font/woff2 | +| bmp | image/bmp | 7z | application/x-7z-compressed | +| gif | image/gif | atom | application/atom+xml | +| png | image/png | pdf | application/pdf | +| svg | image/svg+xml | mjs, js | application/javascript | +| webp | image/webp | json | application/json | +| ico | image/x-icon | rss | application/rss+xml | +| tif | image/tiff | tar | application/x-tar | +| tiff | image/tiff | xhtml, xht | application/xhtml+xml | +| jpeg, jpg | image/jpeg | xslt | application/xslt+xml | +| mp4 | video/mp4 | xml | application/xml | +| mpeg | video/mpeg | gz | application/gzip | +| webm | video/webm | zip | application/zip | +| mp3 | audio/mp3 | wasm | application/wasm | + +### File request handler + +```cpp +// The handler is called right before the response is sent to a client +svr.set_file_request_handler([](const Request &req, Response &res) { + ... +}); +``` + +NOTE: These static file server methods are not thread-safe. + +### Logging + +```cpp +svr.set_logger([](const auto& req, const auto& res) { + your_logger(req, res); +}); +``` + +### Error handler + +```cpp +svr.set_error_handler([](const auto& req, auto& res) { + auto fmt = "

Error Status: %d

"; + char buf[BUFSIZ]; + snprintf(buf, sizeof(buf), fmt, res.status); + res.set_content(buf, "text/html"); +}); +``` + +### Exception handler +The exception handler gets called if a user routing handler throws an error. + +```cpp +svr.set_exception_handler([](const auto& req, auto& res, std::exception_ptr ep) { + auto fmt = "

Error 500

%s

"; + char buf[BUFSIZ]; + try { + std::rethrow_exception(ep); + } catch (std::exception &e) { + snprintf(buf, sizeof(buf), fmt, e.what()); + } catch (...) { // See the following NOTE + snprintf(buf, sizeof(buf), fmt, "Unknown Exception"); + } + res.set_content(buf, "text/html"); + res.status = 500; +}); +``` + +NOTE: if you don't provide the `catch (...)` block for a rethrown exception pointer, an uncaught exception will end up causing the server crash. Be careful! + +### Pre routing handler + +```cpp +svr.set_pre_routing_handler([](const auto& req, auto& res) { + if (req.path == "/hello") { + res.set_content("world", "text/html"); + return Server::HandlerResponse::Handled; + } + return Server::HandlerResponse::Unhandled; +}); +``` + +### Post routing handler + +```cpp +svr.set_post_routing_handler([](const auto& req, auto& res) { + res.set_header("ADDITIONAL_HEADER", "value"); +}); +``` + +### 'multipart/form-data' POST data + +```cpp +svr.Post("/multipart", [&](const auto& req, auto& res) { + auto size = req.files.size(); + auto ret = req.has_file("name1"); + const auto& file = req.get_file_value("name1"); + // file.filename; + // file.content_type; + // file.content; +}); +``` + +### Receive content with a content receiver + +```cpp +svr.Post("/content_receiver", + [&](const Request &req, Response &res, const ContentReader &content_reader) { + if (req.is_multipart_form_data()) { + // NOTE: `content_reader` is blocking until every form data field is read + MultipartFormDataItems files; + content_reader( + [&](const MultipartFormData &file) { + files.push_back(file); + return true; + }, + [&](const char *data, size_t data_length) { + files.back().content.append(data, data_length); + return true; + }); + } else { + std::string body; + content_reader([&](const char *data, size_t data_length) { + body.append(data, data_length); + return true; + }); + } + }); +``` + +### Send content with the content provider + +```cpp +const size_t DATA_CHUNK_SIZE = 4; + +svr.Get("/stream", [&](const Request &req, Response &res) { + auto data = new std::string("abcdefg"); + + res.set_content_provider( + data->size(), // Content length + "text/plain", // Content type + [data](size_t offset, size_t length, DataSink &sink) { + const auto &d = *data; + sink.write(&d[offset], std::min(length, DATA_CHUNK_SIZE)); + return true; // return 'false' if you want to cancel the process. + }, + [data](bool success) { delete data; }); +}); +``` + +Without content length: + +```cpp +svr.Get("/stream", [&](const Request &req, Response &res) { + res.set_content_provider( + "text/plain", // Content type + [&](size_t offset, DataSink &sink) { + if (/* there is still data */) { + std::vector data; + // prepare data... + sink.write(data.data(), data.size()); + } else { + sink.done(); // No more data + } + return true; // return 'false' if you want to cancel the process. + }); +}); +``` + +### Chunked transfer encoding + +```cpp +svr.Get("/chunked", [&](const Request& req, Response& res) { + res.set_chunked_content_provider( + "text/plain", + [](size_t offset, DataSink &sink) { + sink.write("123", 3); + sink.write("345", 3); + sink.write("789", 3); + sink.done(); // No more data + return true; // return 'false' if you want to cancel the process. + } + ); +}); +``` + +With trailer: + +```cpp +svr.Get("/chunked", [&](const Request& req, Response& res) { + res.set_header("Trailer", "Dummy1, Dummy2"); + res.set_chunked_content_provider( + "text/plain", + [](size_t offset, DataSink &sink) { + sink.write("123", 3); + sink.write("345", 3); + sink.write("789", 3); + sink.done_with_trailer({ + {"Dummy1", "DummyVal1"}, + {"Dummy2", "DummyVal2"} + }); + return true; + } + ); +}); +``` + +### 'Expect: 100-continue' handler + +By default, the server sends a `100 Continue` response for an `Expect: 100-continue` header. + +```cpp +// Send a '417 Expectation Failed' response. +svr.set_expect_100_continue_handler([](const Request &req, Response &res) { + return 417; +}); +``` + +```cpp +// Send a final status without reading the message body. +svr.set_expect_100_continue_handler([](const Request &req, Response &res) { + return res.status = 401; +}); +``` + +### Keep-Alive connection + +```cpp +svr.set_keep_alive_max_count(2); // Default is 5 +svr.set_keep_alive_timeout(10); // Default is 5 +``` + +### Timeout + +```c++ +svr.set_read_timeout(5, 0); // 5 seconds +svr.set_write_timeout(5, 0); // 5 seconds +svr.set_idle_interval(0, 100000); // 100 milliseconds +``` + +### Set maximum payload length for reading a request body + +```c++ +svr.set_payload_max_length(1024 * 1024 * 512); // 512MB +``` + +### Server-Sent Events + +Please see [Server example](https://github.com/yhirose/cpp-httplib/blob/master/example/ssesvr.cc) and [Client example](https://github.com/yhirose/cpp-httplib/blob/master/example/ssecli.cc). + +### Default thread pool support + +`ThreadPool` is used as a **default** task queue, and the default thread count is 8, or `std::thread::hardware_concurrency()`. You can change it with `CPPHTTPLIB_THREAD_POOL_COUNT`. + +If you want to set the thread count at runtime, there is no convenient way... But here is how. + +```cpp +svr.new_task_queue = [] { return new ThreadPool(12); }; +``` + +### Override the default thread pool with yours + +You can supply your own thread pool implementation according to your need. + +```cpp +class YourThreadPoolTaskQueue : public TaskQueue { +public: + YourThreadPoolTaskQueue(size_t n) { + pool_.start_with_thread_count(n); + } + + virtual void enqueue(std::function fn) override { + pool_.enqueue(fn); + } + + virtual void shutdown() override { + pool_.shutdown_gracefully(); + } + +private: + YourThreadPool pool_; +}; + +svr.new_task_queue = [] { + return new YourThreadPoolTaskQueue(12); +}; +``` + +Client +------ + +```c++ +#include +#include + +int main(void) +{ + httplib::Client cli("localhost", 1234); + + if (auto res = cli.Get("/hi")) { + if (res->status == 200) { + std::cout << res->body << std::endl; + } + } else { + auto err = res.error(); + std::cout << "HTTP error: " << httplib::to_string(err) << std::endl; + } +} +``` + +NOTE: Constructor with scheme-host-port string is now supported! + +```c++ +httplib::Client cli("localhost"); +httplib::Client cli("localhost:8080"); +httplib::Client cli("http://localhost"); +httplib::Client cli("http://localhost:8080"); +httplib::Client cli("https://localhost"); +httplib::SSLClient cli("localhost"); +``` + +### Error code + +Here is the list of errors from `Result::error()`. + +```c++ +enum Error { + Success = 0, + Unknown, + Connection, + BindIPAddress, + Read, + Write, + ExceedRedirectCount, + Canceled, + SSLConnection, + SSLLoadingCerts, + SSLServerVerification, + UnsupportedMultipartBoundaryChars, + Compression, + ConnectionTimeout, +}; +``` + +### GET with HTTP headers + +```c++ +httplib::Headers headers = { + { "Accept-Encoding", "gzip, deflate" } +}; +auto res = cli.Get("/hi", headers); +``` +or +```c++ +auto res = cli.Get("/hi", {{"Accept-Encoding", "gzip, deflate"}}); +``` +or +```c++ +cli.set_default_headers({ + { "Accept-Encoding", "gzip, deflate" } +}); +auto res = cli.Get("/hi"); +``` + +### POST + +```c++ +res = cli.Post("/post", "text", "text/plain"); +res = cli.Post("/person", "name=john1¬e=coder", "application/x-www-form-urlencoded"); +``` + +### POST with parameters + +```c++ +httplib::Params params; +params.emplace("name", "john"); +params.emplace("note", "coder"); + +auto res = cli.Post("/post", params); +``` + or + +```c++ +httplib::Params params{ + { "name", "john" }, + { "note", "coder" } +}; + +auto res = cli.Post("/post", params); +``` + +### POST with Multipart Form Data + +```c++ +httplib::MultipartFormDataItems items = { + { "text1", "text default", "", "" }, + { "text2", "aωb", "", "" }, + { "file1", "h\ne\n\nl\nl\no\n", "hello.txt", "text/plain" }, + { "file2", "{\n \"world\", true\n}\n", "world.json", "application/json" }, + { "file3", "", "", "application/octet-stream" }, +}; + +auto res = cli.Post("/multipart", items); +``` + +### PUT + +```c++ +res = cli.Put("/resource/foo", "text", "text/plain"); +``` + +### DELETE + +```c++ +res = cli.Delete("/resource/foo"); +``` + +### OPTIONS + +```c++ +res = cli.Options("*"); +res = cli.Options("/resource/foo"); +``` + +### Timeout + +```c++ +cli.set_connection_timeout(0, 300000); // 300 milliseconds +cli.set_read_timeout(5, 0); // 5 seconds +cli.set_write_timeout(5, 0); // 5 seconds +``` + +### Receive content with a content receiver + +```c++ +std::string body; + +auto res = cli.Get("/large-data", + [&](const char *data, size_t data_length) { + body.append(data, data_length); + return true; + }); +``` + +```cpp +std::string body; + +auto res = cli.Get( + "/stream", Headers(), + [&](const Response &response) { + EXPECT_EQ(200, response.status); + return true; // return 'false' if you want to cancel the request. + }, + [&](const char *data, size_t data_length) { + body.append(data, data_length); + return true; // return 'false' if you want to cancel the request. + }); +``` + +### Send content with a content provider + +```cpp +std::string body = ...; + +auto res = cli.Post( + "/stream", body.size(), + [](size_t offset, size_t length, DataSink &sink) { + sink.write(body.data() + offset, length); + return true; // return 'false' if you want to cancel the request. + }, + "text/plain"); +``` + +### Chunked transfer encoding + +```cpp +auto res = cli.Post( + "/stream", + [](size_t offset, DataSink &sink) { + sink.os << "chunked data 1"; + sink.os << "chunked data 2"; + sink.os << "chunked data 3"; + sink.done(); + return true; // return 'false' if you want to cancel the request. + }, + "text/plain"); +``` + +### With Progress Callback + +```cpp +httplib::Client client(url, port); + +// prints: 0 / 000 bytes => 50% complete +auto res = cli.Get("/", [](uint64_t len, uint64_t total) { + printf("%lld / %lld bytes => %d%% complete\n", + len, total, + (int)(len*100/total)); + return true; // return 'false' if you want to cancel the request. +} +); +``` + +![progress](https://user-images.githubusercontent.com/236374/33138910-495c4ecc-cf86-11e7-8693-2fc6d09615c4.gif) + +### Authentication + +```cpp +// Basic Authentication +cli.set_basic_auth("user", "pass"); + +// Digest Authentication +cli.set_digest_auth("user", "pass"); + +// Bearer Token Authentication +cli.set_bearer_token_auth("token"); +``` + +NOTE: OpenSSL is required for Digest Authentication. + +### Proxy server support + +```cpp +cli.set_proxy("host", port); + +// Basic Authentication +cli.set_proxy_basic_auth("user", "pass"); + +// Digest Authentication +cli.set_proxy_digest_auth("user", "pass"); + +// Bearer Token Authentication +cli.set_proxy_bearer_token_auth("pass"); +``` + +NOTE: OpenSSL is required for Digest Authentication. + +### Range + +```cpp +httplib::Client cli("httpbin.org"); + +auto res = cli.Get("/range/32", { + httplib::make_range_header({{1, 10}}) // 'Range: bytes=1-10' +}); +// res->status should be 206. +// res->body should be "bcdefghijk". +``` + +```cpp +httplib::make_range_header({{1, 10}, {20, -1}}) // 'Range: bytes=1-10, 20-' +httplib::make_range_header({{100, 199}, {500, 599}}) // 'Range: bytes=100-199, 500-599' +httplib::make_range_header({{0, 0}, {-1, 1}}) // 'Range: bytes=0-0, -1' +``` + +### Keep-Alive connection + +```cpp +httplib::Client cli("localhost", 1234); + +cli.Get("/hello"); // with "Connection: close" + +cli.set_keep_alive(true); +cli.Get("/world"); + +cli.set_keep_alive(false); +cli.Get("/last-request"); // with "Connection: close" +``` + +### Redirect + +```cpp +httplib::Client cli("yahoo.com"); + +auto res = cli.Get("/"); +res->status; // 301 + +cli.set_follow_location(true); +res = cli.Get("/"); +res->status; // 200 +``` + +### Use a specific network interface + +NOTE: This feature is not available on Windows, yet. + +```cpp +cli.set_interface("eth0"); // Interface name, IP address or host name +``` + +Compression +----------- + +The server can apply compression to the following MIME type contents: + + * all text types except text/event-stream + * image/svg+xml + * application/javascript + * application/json + * application/xml + * application/xhtml+xml + +### Zlib Support + +'gzip' compression is available with `CPPHTTPLIB_ZLIB_SUPPORT`. `libz` should be linked. + +### Brotli Support + +Brotli compression is available with `CPPHTTPLIB_BROTLI_SUPPORT`. Necessary libraries should be linked. +Please see https://github.com/google/brotli for more detail. + +### Compress request body on client + +```c++ +cli.set_compress(true); +res = cli.Post("/resource/foo", "...", "text/plain"); +``` + +### Compress response body on client + +```c++ +cli.set_decompress(false); +res = cli.Get("/resource/foo", {{"Accept-Encoding", "gzip, deflate, br"}}); +res->body; // Compressed data +``` + +Use `poll` instead of `select` +------------------------------ + +`select` system call is used as default since it's more widely supported. If you want to let cpp-httplib use `poll` instead, you can do so with `CPPHTTPLIB_USE_POLL`. + + +Split httplib.h into .h and .cc +------------------------------- + +```console +$ ./split.py -h +usage: split.py [-h] [-e EXTENSION] [-o OUT] + +This script splits httplib.h into .h and .cc parts. + +optional arguments: + -h, --help show this help message and exit + -e EXTENSION, --extension EXTENSION + extension of the implementation file (default: cc) + -o OUT, --out OUT where to write the files (default: out) + +$ ./split.py +Wrote out/httplib.h and out/httplib.cc +``` + +NOTE +---- + +### g++ + +g++ 4.8 and below cannot build this library since `` in the versions are [broken](https://stackoverflow.com/questions/12530406/is-gcc-4-8-or-earlier-buggy-about-regular-expressions). + +### Windows + +Include `httplib.h` before `Windows.h` or include `Windows.h` by defining `WIN32_LEAN_AND_MEAN` beforehand. + +```cpp +#include +#include +``` + +```cpp +#define WIN32_LEAN_AND_MEAN +#include +#include +``` + +NOTE: cpp-httplib officially supports only the latest Visual Studio. It might work with former versions of Visual Studio, but I can no longer verify it. Pull requests are always welcome for the older versions of Visual Studio unless they break the C++11 conformance. + +NOTE: Windows 8 or lower, Visual Studio 2013 or lower, and Cygwin on Windows are not supported. + +License +------- + +MIT license (© 2023 Yuji Hirose) + +Special Thanks To +----------------- + +[These folks](https://github.com/yhirose/cpp-httplib/graphs/contributors) made great contributions to polish this library to totally another level from a simple toy! diff --git a/VideoProsessing/NetraLib/include/encrypt.hpp b/VideoProsessing/NetraLib/include/encrypt.hpp new file mode 100644 index 0000000..42ea793 --- /dev/null +++ b/VideoProsessing/NetraLib/include/encrypt.hpp @@ -0,0 +1,14 @@ +#pragma once + +/* +主要是用于各种加密 +*/ + +#include "QCL_Include.hpp" + +using namespace std; + +namespace encrypt +{ + string MD5(const string &info); +} \ No newline at end of file diff --git a/VideoProsessing/NetraLib/include/httplib.h b/VideoProsessing/NetraLib/include/httplib.h new file mode 100644 index 0000000..1bdef69 --- /dev/null +++ b/VideoProsessing/NetraLib/include/httplib.h @@ -0,0 +1,8794 @@ +// +// httplib.h +// +// Copyright (c) 2023 Yuji Hirose. All rights reserved. +// MIT License +// + +#ifndef CPPHTTPLIB_HTTPLIB_H +#define CPPHTTPLIB_HTTPLIB_H + +#define CPPHTTPLIB_VERSION "0.12.2" + +/* + * 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::max)()) +#endif + +#ifndef CPPHTTPLIB_FORM_URL_ENCODED_PAYLOAD_MAX_LENGTH +#define CPPHTTPLIB_FORM_URL_ENCODED_PAYLOAD_MAX_LENGTH 8192 +#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 +#include +#include + +#ifndef WSA_FLAG_NO_HANDLE_INHERIT +#define WSA_FLAG_NO_HANDLE_INHERIT 0x80 +#endif + +#ifndef strcasecmp +#define strcasecmp _stricmp +#endif // strcasecmp + +using socket_t = SOCKET; +#ifdef CPPHTTPLIB_USE_POLL +#define poll(fds, nfds, timeout) WSAPoll(fds, nfds, timeout) +#endif + +#else // not _WIN32 + +#include +#ifndef _AIX +#include +#endif +#include +#include +#include +#ifdef __linux__ +#include +#endif +#include +#ifdef CPPHTTPLIB_USE_POLL +#include +#endif +#include +#include +#include +#include +#include +#include + +using socket_t = int; +#ifndef INVALID_SOCKET +#define INVALID_SOCKET (-1) +#endif +#endif //_WIN32 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +#ifdef _WIN32 +#include + +// 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") +#pragma comment(lib, "cryptui.lib") +#endif +#elif defined(CPPHTTPLIB_USE_CERTS_FROM_MACOSX_KEYCHAIN) && defined(__APPLE__) +#include +#if TARGET_OS_OSX +#include +#include +#endif // TARGET_OS_OSX +#endif // _WIN32 + +#include +#include +#include +#include + +#if defined(_WIN32) && defined(OPENSSL_USE_APPLINK) +#include +#endif + +#include +#include + +#if OPENSSL_VERSION_NUMBER < 0x1010100fL +#error Sorry, OpenSSL versions prior to 1.1.1 are not supported +#elif OPENSSL_VERSION_NUMBER < 0x30000000L +#define SSL_get1_peer_certificate SSL_get_peer_certificate +#endif + +#endif + +#ifdef CPPHTTPLIB_ZLIB_SUPPORT +#include +#endif + +#ifdef CPPHTTPLIB_BROTLI_SUPPORT +#include +#include +#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 +typename std::enable_if::value, std::unique_ptr>::type +make_unique(Args &&...args) { + return std::unique_ptr(new T(std::forward(args)...)); +} + +template +typename std::enable_if::value, std::unique_ptr>::type +make_unique(std::size_t n) { + typedef typename std::remove_extent::type RT; + return std::unique_ptr(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 &&f) + : exit_function(std::move(f)), execute_on_destruction{true} {} + + scope_exit(scope_exit &&rhs) + : 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 exit_function; + bool execute_on_destruction; +}; + +} // namespace detail + +using Headers = std::multimap; + +using Params = std::multimap; +using Match = std::smatch; + +using Progress = std::function; + +struct Response; +using ResponseHandler = std::function; + +struct MultipartFormData { + std::string name; + std::string content; + std::string filename; + std::string content_type; +}; +using MultipartFormDataItems = std::vector; +using MultipartFormDataMap = std::multimap; + +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 write; + std::function done; + std::function 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) { + sink_.write(s, static_cast(n)); + return n; + } + + private: + DataSink &sink_; + }; + + data_sink_streambuf sb_; +}; + +using ContentProvider = + std::function; + +using ContentProviderWithoutLength = + std::function; + +using ContentProviderResourceReleaser = std::function; + +struct MultipartFormDataProvider { + std::string name; + ContentProviderWithoutLength provider; + std::string filename; + std::string content_type; +}; +using MultipartFormDataProviderItems = std::vector; + +using ContentReceiverWithProgress = + std::function; + +using ContentReceiver = + std::function; + +using MultipartContentHeader = + std::function; + +class ContentReader { +public: + using Reader = std::function; + using MultipartReader = std::function; + + 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; +using Ranges = std::vector; + +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; + + // 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; + template + T get_header_value(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 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; + template + T get_header_value(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 = 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_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 + 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 void enqueue(std::function fn) = 0; + virtual void shutdown() = 0; + + virtual void on_idle() {} +}; + +class ThreadPool : public TaskQueue { +public: + 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 fn) override { + { + std::unique_lock lock(mutex_); + jobs_.push_back(std::move(fn)); + } + + cond_.notify_one(); + } + + void shutdown() override { + // Stop all worker threads... + { + std::unique_lock 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 fn; + { + std::unique_lock 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(fn)); + fn(); + } + } + + ThreadPool &pool_; + }; + friend struct worker; + + std::vector threads_; + std::list> jobs_; + + bool shutdown_; + + std::condition_variable cond_; + std::mutex mutex_; +}; + +using Logger = std::function; + +using SocketOptions = std::function; + +void default_socket_options(socket_t sock); + +class Server { +public: + using Handler = std::function; + + using ExceptionHandler = + std::function; + + enum class HandlerResponse { + Handled, + Unhandled, + }; + using HandlerWithResponse = + std::function; + + using HandlerWithContentReader = std::function; + + using Expect100ContinueHandler = + std::function; + + 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_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 + Server &set_read_timeout(const std::chrono::duration &duration); + + Server &set_write_timeout(time_t sec, time_t usec = 0); + template + Server &set_write_timeout(const std::chrono::duration &duration); + + Server &set_idle_interval(time_t sec, time_t usec = 0); + template + Server &set_idle_interval(const std::chrono::duration &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 new_task_queue; + +protected: + bool process_request(Stream &strm, bool close_connection, + bool &connection_closed, + const std::function &setup_request); + + std::atomic 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>; + using HandlersForContentReader = + std::vector>; + + 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 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 multipart_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 base_dirs_; + + std::atomic is_running_{false}; + std::atomic done_{false}; + std::map 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_; +}; + +enum class Error { + Success = 0, + Unknown, + Connection, + BindIPAddress, + Read, + Write, + ExceedRedirectCount, + Canceled, + SSLConnection, + SSLLoadingCerts, + SSLServerVerification, + UnsupportedMultipartBoundaryChars, + Compression, + ConnectionTimeout, + + // For internal use only + SSLPeerCouldBeClosed_, +}; + +std::string to_string(const Error error); + +std::ostream &operator<<(std::ostream &os, const Error &obj); + +class Result { +public: + Result(std::unique_ptr &&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 std::string &key) const; + std::string get_request_header_value(const std::string &key, + size_t id = 0) const; + template + T get_request_header_value(const std::string &key, size_t id = 0) const; + size_t get_request_header_value_count(const std::string &key) const; + +private: + std::unique_ptr res_; + Error err_; + Headers request_headers_; +}; + +class ClientImpl { +public: + 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 std::string &path); + Result Get(const std::string &path, const Headers &headers); + Result Get(const std::string &path, Progress progress); + Result Get(const std::string &path, const Headers &headers, + Progress progress); + Result Get(const std::string &path, ContentReceiver content_receiver); + Result Get(const std::string &path, const Headers &headers, + ContentReceiver content_receiver); + Result Get(const std::string &path, ContentReceiver content_receiver, + Progress progress); + Result Get(const std::string &path, const Headers &headers, + ContentReceiver content_receiver, Progress progress); + Result Get(const std::string &path, ResponseHandler response_handler, + ContentReceiver content_receiver); + Result Get(const std::string &path, const Headers &headers, + ResponseHandler response_handler, + ContentReceiver content_receiver); + Result Get(const std::string &path, ResponseHandler response_handler, + ContentReceiver content_receiver, Progress progress); + Result Get(const std::string &path, const Headers &headers, + ResponseHandler response_handler, ContentReceiver content_receiver, + Progress progress); + + Result Get(const std::string &path, const Params ¶ms, + const Headers &headers, Progress progress = nullptr); + Result Get(const std::string &path, const Params ¶ms, + const Headers &headers, ContentReceiver content_receiver, + Progress progress = nullptr); + Result Get(const std::string &path, const Params ¶ms, + const Headers &headers, ResponseHandler response_handler, + ContentReceiver content_receiver, Progress progress = nullptr); + + Result Head(const std::string &path); + Result Head(const std::string &path, const Headers &headers); + + Result Post(const std::string &path); + Result Post(const std::string &path, const Headers &headers); + Result Post(const std::string &path, const char *body, size_t content_length, + const std::string &content_type); + Result Post(const std::string &path, const Headers &headers, const char *body, + size_t content_length, const std::string &content_type); + Result Post(const std::string &path, const std::string &body, + const std::string &content_type); + Result Post(const std::string &path, const Headers &headers, + const std::string &body, const std::string &content_type); + Result Post(const std::string &path, size_t content_length, + ContentProvider content_provider, + const std::string &content_type); + Result Post(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + Result Post(const std::string &path, const Headers &headers, + size_t content_length, ContentProvider content_provider, + const std::string &content_type); + Result Post(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + Result Post(const std::string &path, const Params ¶ms); + Result Post(const std::string &path, const Headers &headers, + const Params ¶ms); + Result Post(const std::string &path, const MultipartFormDataItems &items); + Result Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items); + Result Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, const std::string &boundary); + Result Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const MultipartFormDataProviderItems &provider_items); + + Result Put(const std::string &path); + Result Put(const std::string &path, const char *body, size_t content_length, + const std::string &content_type); + Result Put(const std::string &path, const Headers &headers, const char *body, + size_t content_length, const std::string &content_type); + Result Put(const std::string &path, const std::string &body, + const std::string &content_type); + Result Put(const std::string &path, const Headers &headers, + const std::string &body, const std::string &content_type); + Result Put(const std::string &path, size_t content_length, + ContentProvider content_provider, const std::string &content_type); + Result Put(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + Result Put(const std::string &path, const Headers &headers, + size_t content_length, ContentProvider content_provider, + const std::string &content_type); + Result Put(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + Result Put(const std::string &path, const Params ¶ms); + Result Put(const std::string &path, const Headers &headers, + const Params ¶ms); + Result Put(const std::string &path, const MultipartFormDataItems &items); + Result Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items); + Result Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, const std::string &boundary); + Result Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const MultipartFormDataProviderItems &provider_items); + + Result Patch(const std::string &path); + Result Patch(const std::string &path, const char *body, size_t content_length, + const std::string &content_type); + Result Patch(const std::string &path, const Headers &headers, + const char *body, size_t content_length, + const std::string &content_type); + Result Patch(const std::string &path, const std::string &body, + const std::string &content_type); + Result Patch(const std::string &path, const Headers &headers, + const std::string &body, const std::string &content_type); + Result Patch(const std::string &path, size_t content_length, + ContentProvider content_provider, + const std::string &content_type); + Result Patch(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + Result Patch(const std::string &path, const Headers &headers, + size_t content_length, ContentProvider content_provider, + const std::string &content_type); + Result Patch(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + + Result Delete(const std::string &path); + Result Delete(const std::string &path, const Headers &headers); + Result Delete(const std::string &path, const char *body, + size_t content_length, const std::string &content_type); + Result Delete(const std::string &path, const Headers &headers, + const char *body, size_t content_length, + const std::string &content_type); + Result Delete(const std::string &path, const std::string &body, + const std::string &content_type); + Result Delete(const std::string &path, const Headers &headers, + const std::string &body, const std::string &content_type); + + Result Options(const std::string &path); + Result Options(const std::string &path, const Headers &headers); + + bool send(Request &req, Response &res, Error &error); + Result send(const Request &req); + + size_t is_socket_open() const; + + socket_t socket() const; + + void stop(); + + void set_hostname_addr_map(std::map addr_map); + + 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 + void + set_connection_timeout(const std::chrono::duration &duration); + + void set_read_timeout(time_t sec, time_t usec = 0); + template + void set_read_timeout(const std::chrono::duration &duration); + + void set_write_timeout(time_t sec, time_t usec = 0); + template + void set_write_timeout(const std::chrono::duration &duration); + + void set_basic_auth(const std::string &username, const std::string &password); + void set_bearer_token_auth(const std::string &token); +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + void set_digest_auth(const std::string &username, + const std::string &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 std::string &intf); + + void set_proxy(const std::string &host, int port); + void set_proxy_basic_auth(const std::string &username, + const std::string &password); + void set_proxy_bearer_token_auth(const std::string &token); +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + void set_proxy_digest_auth(const std::string &username, + const std::string &password); +#endif + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + void set_ca_cert_path(const std::string &ca_cert_file_path, + const std::string &ca_cert_dir_path = std::string()); + void set_ca_cert_store(X509_STORE *ca_cert_store); +#endif + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + void enable_server_certificate_verification(bool enabled); +#endif + + void set_logger(Logger logger); + +protected: + struct Socket { + socket_t sock = INVALID_SOCKET; +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + SSL *ssl = nullptr; +#endif + + bool is_open() const { return sock != INVALID_SOCKET; } + }; + + virtual bool create_and_connect_socket(Socket &socket, Error &error); + + // All of: + // shutdown_ssl + // shutdown_socket + // close_socket + // should ONLY be called when socket_mutex_ is locked. + // Also, shutdown_ssl and close_socket should also NOT be called concurrently + // with a DIFFERENT thread sending requests using that socket. + virtual void shutdown_ssl(Socket &socket, bool shutdown_gracefully); + void shutdown_socket(Socket &socket); + void close_socket(Socket &socket); + + bool process_request(Stream &strm, Request &req, Response &res, + bool close_connection, Error &error); + + bool write_content_with_provider(Stream &strm, const Request &req, + Error &error); + + void copy_settings(const ClientImpl &rhs); + + // Socket endpoint information + const std::string host_; + const int port_; + const std::string host_and_port_; + + // Current open socket + Socket socket_; + mutable std::mutex socket_mutex_; + std::recursive_mutex request_mutex_; + + // These are all protected under socket_mutex + size_t socket_requests_in_flight_ = 0; + std::thread::id socket_requests_are_from_thread_ = std::thread::id(); + bool socket_should_be_closed_when_request_is_done_ = false; + + // Hostname-IP map + std::map addr_map_; + + // Default headers + Headers default_headers_; + + // Settings + std::string client_cert_path_; + std::string client_key_path_; + + time_t connection_timeout_sec_ = CPPHTTPLIB_CONNECTION_TIMEOUT_SECOND; + time_t connection_timeout_usec_ = CPPHTTPLIB_CONNECTION_TIMEOUT_USECOND; + 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; + + std::string basic_auth_username_; + std::string basic_auth_password_; + std::string bearer_token_auth_token_; +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + std::string digest_auth_username_; + std::string digest_auth_password_; +#endif + + bool keep_alive_ = false; + bool follow_location_ = false; + + bool url_encode_ = true; + + int address_family_ = AF_UNSPEC; + bool tcp_nodelay_ = CPPHTTPLIB_TCP_NODELAY; + SocketOptions socket_options_ = nullptr; + + bool compress_ = false; + bool decompress_ = true; + + std::string interface_; + + std::string proxy_host_; + int proxy_port_ = -1; + + std::string proxy_basic_auth_username_; + std::string proxy_basic_auth_password_; + std::string proxy_bearer_token_auth_token_; +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + std::string proxy_digest_auth_username_; + std::string proxy_digest_auth_password_; +#endif + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + std::string ca_cert_file_path_; + std::string ca_cert_dir_path_; + + X509_STORE *ca_cert_store_ = nullptr; +#endif + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + bool server_certificate_verification_ = true; +#endif + + Logger logger_; + +private: + bool send_(Request &req, Response &res, Error &error); + Result send_(Request &&req); + + socket_t create_client_socket(Error &error) const; + bool read_response_line(Stream &strm, const Request &req, Response &res); + bool write_request(Stream &strm, Request &req, bool close_connection, + Error &error); + bool redirect(Request &req, Response &res, Error &error); + bool handle_request(Stream &strm, Request &req, Response &res, + bool close_connection, Error &error); + std::unique_ptr send_with_content_provider( + Request &req, const char *body, size_t content_length, + ContentProvider content_provider, + ContentProviderWithoutLength content_provider_without_length, + const std::string &content_type, Error &error); + Result send_with_content_provider( + const std::string &method, const std::string &path, + const Headers &headers, const char *body, size_t content_length, + ContentProvider content_provider, + ContentProviderWithoutLength content_provider_without_length, + const std::string &content_type); + ContentProviderWithoutLength get_multipart_content_provider( + const std::string &boundary, const MultipartFormDataItems &items, + const MultipartFormDataProviderItems &provider_items); + + std::string adjust_host_string(const std::string &host) const; + + virtual bool process_socket(const Socket &socket, + std::function callback); + virtual bool is_ssl() const; +}; + +class Client { +public: + // Universal interface + explicit Client(const std::string &scheme_host_port); + + explicit Client(const std::string &scheme_host_port, + const std::string &client_cert_path, + const std::string &client_key_path); + + // HTTP only interface + explicit Client(const std::string &host, int port); + + explicit Client(const std::string &host, int port, + const std::string &client_cert_path, + const std::string &client_key_path); + + Client(Client &&) = default; + + ~Client(); + + bool is_valid() const; + + Result Get(const std::string &path); + Result Get(const std::string &path, const Headers &headers); + Result Get(const std::string &path, Progress progress); + Result Get(const std::string &path, const Headers &headers, + Progress progress); + Result Get(const std::string &path, ContentReceiver content_receiver); + Result Get(const std::string &path, const Headers &headers, + ContentReceiver content_receiver); + Result Get(const std::string &path, ContentReceiver content_receiver, + Progress progress); + Result Get(const std::string &path, const Headers &headers, + ContentReceiver content_receiver, Progress progress); + Result Get(const std::string &path, ResponseHandler response_handler, + ContentReceiver content_receiver); + Result Get(const std::string &path, const Headers &headers, + ResponseHandler response_handler, + ContentReceiver content_receiver); + Result Get(const std::string &path, const Headers &headers, + ResponseHandler response_handler, ContentReceiver content_receiver, + Progress progress); + Result Get(const std::string &path, ResponseHandler response_handler, + ContentReceiver content_receiver, Progress progress); + + Result Get(const std::string &path, const Params ¶ms, + const Headers &headers, Progress progress = nullptr); + Result Get(const std::string &path, const Params ¶ms, + const Headers &headers, ContentReceiver content_receiver, + Progress progress = nullptr); + Result Get(const std::string &path, const Params ¶ms, + const Headers &headers, ResponseHandler response_handler, + ContentReceiver content_receiver, Progress progress = nullptr); + + Result Head(const std::string &path); + Result Head(const std::string &path, const Headers &headers); + + Result Post(const std::string &path); + Result Post(const std::string &path, const Headers &headers); + Result Post(const std::string &path, const char *body, size_t content_length, + const std::string &content_type); + Result Post(const std::string &path, const Headers &headers, const char *body, + size_t content_length, const std::string &content_type); + Result Post(const std::string &path, const std::string &body, + const std::string &content_type); + Result Post(const std::string &path, const Headers &headers, + const std::string &body, const std::string &content_type); + Result Post(const std::string &path, size_t content_length, + ContentProvider content_provider, + const std::string &content_type); + Result Post(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + Result Post(const std::string &path, const Headers &headers, + size_t content_length, ContentProvider content_provider, + const std::string &content_type); + Result Post(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + Result Post(const std::string &path, const Params ¶ms); + Result Post(const std::string &path, const Headers &headers, + const Params ¶ms); + Result Post(const std::string &path, const MultipartFormDataItems &items); + Result Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items); + Result Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, const std::string &boundary); + Result Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const MultipartFormDataProviderItems &provider_items); + + Result Put(const std::string &path); + Result Put(const std::string &path, const char *body, size_t content_length, + const std::string &content_type); + Result Put(const std::string &path, const Headers &headers, const char *body, + size_t content_length, const std::string &content_type); + Result Put(const std::string &path, const std::string &body, + const std::string &content_type); + Result Put(const std::string &path, const Headers &headers, + const std::string &body, const std::string &content_type); + Result Put(const std::string &path, size_t content_length, + ContentProvider content_provider, const std::string &content_type); + Result Put(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + Result Put(const std::string &path, const Headers &headers, + size_t content_length, ContentProvider content_provider, + const std::string &content_type); + Result Put(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + Result Put(const std::string &path, const Params ¶ms); + Result Put(const std::string &path, const Headers &headers, + const Params ¶ms); + Result Put(const std::string &path, const MultipartFormDataItems &items); + Result Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items); + Result Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, const std::string &boundary); + Result Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const MultipartFormDataProviderItems &provider_items); + + Result Patch(const std::string &path); + Result Patch(const std::string &path, const char *body, size_t content_length, + const std::string &content_type); + Result Patch(const std::string &path, const Headers &headers, + const char *body, size_t content_length, + const std::string &content_type); + Result Patch(const std::string &path, const std::string &body, + const std::string &content_type); + Result Patch(const std::string &path, const Headers &headers, + const std::string &body, const std::string &content_type); + Result Patch(const std::string &path, size_t content_length, + ContentProvider content_provider, + const std::string &content_type); + Result Patch(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + Result Patch(const std::string &path, const Headers &headers, + size_t content_length, ContentProvider content_provider, + const std::string &content_type); + Result Patch(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + + Result Delete(const std::string &path); + Result Delete(const std::string &path, const Headers &headers); + Result Delete(const std::string &path, const char *body, + size_t content_length, const std::string &content_type); + Result Delete(const std::string &path, const Headers &headers, + const char *body, size_t content_length, + const std::string &content_type); + Result Delete(const std::string &path, const std::string &body, + const std::string &content_type); + Result Delete(const std::string &path, const Headers &headers, + const std::string &body, const std::string &content_type); + + Result Options(const std::string &path); + Result Options(const std::string &path, const Headers &headers); + + bool send(Request &req, Response &res, Error &error); + Result send(const Request &req); + + size_t is_socket_open() const; + + socket_t socket() const; + + void stop(); + + void set_hostname_addr_map(std::map addr_map); + + 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 + void + set_connection_timeout(const std::chrono::duration &duration); + + void set_read_timeout(time_t sec, time_t usec = 0); + template + void set_read_timeout(const std::chrono::duration &duration); + + void set_write_timeout(time_t sec, time_t usec = 0); + template + void set_write_timeout(const std::chrono::duration &duration); + + void set_basic_auth(const std::string &username, const std::string &password); + void set_bearer_token_auth(const std::string &token); +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + void set_digest_auth(const std::string &username, + const std::string &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 std::string &intf); + + void set_proxy(const std::string &host, int port); + void set_proxy_basic_auth(const std::string &username, + const std::string &password); + void set_proxy_bearer_token_auth(const std::string &token); +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + void set_proxy_digest_auth(const std::string &username, + const std::string &password); +#endif + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + void enable_server_certificate_verification(bool enabled); +#endif + + void set_logger(Logger logger); + + // SSL +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + void set_ca_cert_path(const std::string &ca_cert_file_path, + const std::string &ca_cert_dir_path = std::string()); + + void set_ca_cert_store(X509_STORE *ca_cert_store); + + long get_openssl_verify_result() const; + + SSL_CTX *ssl_context() const; +#endif + +private: + std::unique_ptr cli_; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + bool is_ssl_ = false; +#endif +}; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +class SSLServer : public Server { +public: + 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, + const char *private_key_password = nullptr); + + SSLServer(X509 *cert, EVP_PKEY *private_key, + X509_STORE *client_ca_cert_store = nullptr); + + SSLServer( + const std::function &setup_ssl_ctx_callback); + + ~SSLServer() override; + + bool is_valid() const override; + + SSL_CTX *ssl_context() const; + +private: + bool process_and_close_socket(socket_t sock) override; + + SSL_CTX *ctx_; + std::mutex ctx_mutex_; +}; + +class SSLClient : public ClientImpl { +public: + explicit SSLClient(const std::string &host); + + explicit SSLClient(const std::string &host, int port); + + explicit SSLClient(const std::string &host, int port, + const std::string &client_cert_path, + const std::string &client_key_path); + + explicit SSLClient(const std::string &host, int port, X509 *client_cert, + EVP_PKEY *client_key); + + ~SSLClient() override; + + bool is_valid() const override; + + void set_ca_cert_store(X509_STORE *ca_cert_store); + + long get_openssl_verify_result() const; + + SSL_CTX *ssl_context() const; + +private: + bool create_and_connect_socket(Socket &socket, Error &error) override; + void shutdown_ssl(Socket &socket, bool shutdown_gracefully) override; + void shutdown_ssl_impl(Socket &socket, bool shutdown_socket); + + bool process_socket(const Socket &socket, + std::function callback) override; + bool is_ssl() const override; + + bool connect_with_proxy(Socket &sock, Response &res, bool &success, + Error &error); + bool initialize_ssl(Socket &socket, Error &error); + + bool load_certs(); + + 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::once_flag initialize_cert_; + + std::vector host_components_; + + long verify_result_ = 0; + + friend class ClientImpl; +}; +#endif + +/* + * Implementation of template methods. + */ + +namespace detail { + +template +inline void duration_to_sec_and_usec(const T &duration, U callback) { + auto sec = std::chrono::duration_cast(duration).count(); + auto usec = std::chrono::duration_cast( + duration - std::chrono::seconds(sec)) + .count(); + callback(static_cast(sec), static_cast(usec)); +} + +template +inline T get_header_value(const Headers & /*headers*/, + const std::string & /*key*/, size_t /*id*/ = 0, + uint64_t /*def*/ = 0) {} + +template <> +inline uint64_t get_header_value(const Headers &headers, + const std::string &key, size_t id, + uint64_t def) { + auto rng = headers.equal_range(key); + auto it = rng.first; + std::advance(it, static_cast(id)); + if (it != rng.second) { + return std::strtoull(it->second.data(), nullptr, 10); + } + return def; +} + +} // namespace detail + +template +inline T Request::get_header_value(const std::string &key, size_t id) const { + return detail::get_header_value(headers, key, id, 0); +} + +template +inline T Response::get_header_value(const std::string &key, size_t id) const { + return detail::get_header_value(headers, key, id, 0); +} + +template +inline ssize_t Stream::write_format(const char *fmt, const Args &...args) { + const auto bufsiz = 2048; + std::array buf{}; + + auto sn = snprintf(buf.data(), buf.size() - 1, fmt, args...); + if (sn <= 0) { return sn; } + + auto n = static_cast(sn); + + if (n >= buf.size() - 1) { + std::vector glowable_buf(buf.size()); + + while (n >= glowable_buf.size() - 1) { + glowable_buf.resize(glowable_buf.size() * 2); + n = static_cast( + snprintf(&glowable_buf[0], glowable_buf.size() - 1, fmt, args...)); + } + return write(&glowable_buf[0], n); + } else { + return write(buf.data(), n); + } +} + +inline void default_socket_options(socket_t sock) { + int yes = 1; +#ifdef _WIN32 + setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast(&yes), + sizeof(yes)); + setsockopt(sock, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, + reinterpret_cast(&yes), sizeof(yes)); +#else +#ifdef SO_REUSEPORT + setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, reinterpret_cast(&yes), + sizeof(yes)); +#else + setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast(&yes), + sizeof(yes)); +#endif +#endif +} + +template +inline Server & +Server::set_read_timeout(const std::chrono::duration &duration) { + detail::duration_to_sec_and_usec( + duration, [&](time_t sec, time_t usec) { set_read_timeout(sec, usec); }); + return *this; +} + +template +inline Server & +Server::set_write_timeout(const std::chrono::duration &duration) { + detail::duration_to_sec_and_usec( + duration, [&](time_t sec, time_t usec) { set_write_timeout(sec, usec); }); + return *this; +} + +template +inline Server & +Server::set_idle_interval(const std::chrono::duration &duration) { + detail::duration_to_sec_and_usec( + duration, [&](time_t sec, time_t usec) { set_idle_interval(sec, usec); }); + return *this; +} + +inline std::string to_string(const Error error) { + switch (error) { + case Error::Success: return "Success (no error)"; + case Error::Connection: return "Could not establish connection"; + case Error::BindIPAddress: return "Failed to bind IP address"; + case Error::Read: return "Failed to read connection"; + case Error::Write: return "Failed to write connection"; + case Error::ExceedRedirectCount: return "Maximum redirect count exceeded"; + case Error::Canceled: return "Connection handling canceled"; + case Error::SSLConnection: return "SSL connection failed"; + case Error::SSLLoadingCerts: return "SSL certificate loading failed"; + case Error::SSLServerVerification: return "SSL server verification failed"; + case Error::UnsupportedMultipartBoundaryChars: + return "Unsupported HTTP multipart boundary characters"; + case Error::Compression: return "Compression failed"; + case Error::ConnectionTimeout: return "Connection timed out"; + case Error::Unknown: return "Unknown"; + default: break; + } + + return "Invalid"; +} + +inline std::ostream &operator<<(std::ostream &os, const Error &obj) { + os << to_string(obj); + os << " (" << static_cast::type>(obj) << ')'; + return os; +} + +template +inline T Result::get_request_header_value(const std::string &key, + size_t id) const { + return detail::get_header_value(request_headers_, key, id, 0); +} + +template +inline void ClientImpl::set_connection_timeout( + const std::chrono::duration &duration) { + detail::duration_to_sec_and_usec(duration, [&](time_t sec, time_t usec) { + set_connection_timeout(sec, usec); + }); +} + +template +inline void ClientImpl::set_read_timeout( + const std::chrono::duration &duration) { + detail::duration_to_sec_and_usec( + duration, [&](time_t sec, time_t usec) { set_read_timeout(sec, usec); }); +} + +template +inline void ClientImpl::set_write_timeout( + const std::chrono::duration &duration) { + detail::duration_to_sec_and_usec( + duration, [&](time_t sec, time_t usec) { set_write_timeout(sec, usec); }); +} + +template +inline void Client::set_connection_timeout( + const std::chrono::duration &duration) { + cli_->set_connection_timeout(duration); +} + +template +inline void +Client::set_read_timeout(const std::chrono::duration &duration) { + cli_->set_read_timeout(duration); +} + +template +inline void +Client::set_write_timeout(const std::chrono::duration &duration) { + cli_->set_write_timeout(duration); +} + +/* + * Forward declarations and types that will be part of the .h file if split into + * .h + .cc. + */ + +std::string hosted_at(const std::string &hostname); + +void hosted_at(const std::string &hostname, std::vector &addrs); + +std::string append_query_params(const std::string &path, const Params ¶ms); + +std::pair make_range_header(Ranges ranges); + +std::pair +make_basic_authentication_header(const std::string &username, + const std::string &password, + bool is_proxy = false); + +namespace detail { + +std::string encode_query_param(const std::string &value); + +std::string decode_url(const std::string &s, bool convert_plus_to_space); + +void read_file(const std::string &path, std::string &out); + +std::string trim_copy(const std::string &s); + +void split(const char *b, const char *e, char d, + std::function fn); + +bool process_client_socket(socket_t sock, time_t read_timeout_sec, + time_t read_timeout_usec, time_t write_timeout_sec, + time_t write_timeout_usec, + std::function callback); + +socket_t create_client_socket( + const std::string &host, const std::string &ip, int port, + int address_family, bool tcp_nodelay, SocketOptions socket_options, + time_t connection_timeout_sec, time_t connection_timeout_usec, + time_t read_timeout_sec, time_t read_timeout_usec, time_t write_timeout_sec, + time_t write_timeout_usec, const std::string &intf, Error &error); + +const char *get_header_value(const Headers &headers, const std::string &key, + size_t id = 0, const char *def = nullptr); + +std::string params_to_query_str(const Params ¶ms); + +void parse_query_text(const std::string &s, Params ¶ms); + +bool parse_multipart_boundary(const std::string &content_type, + std::string &boundary); + +bool parse_range_header(const std::string &s, Ranges &ranges); + +int close_socket(socket_t sock); + +ssize_t send_socket(socket_t sock, const void *ptr, size_t size, int flags); + +ssize_t read_socket(socket_t sock, void *ptr, size_t size, int flags); + +enum class EncodingType { None = 0, Gzip, Brotli }; + +EncodingType encoding_type(const Request &req, const Response &res); + +class BufferStream : public Stream { +public: + BufferStream() = default; + ~BufferStream() override = default; + + bool is_readable() const override; + bool is_writable() const override; + ssize_t read(char *ptr, size_t size) override; + ssize_t write(const char *ptr, size_t size) override; + void get_remote_ip_and_port(std::string &ip, int &port) const override; + void get_local_ip_and_port(std::string &ip, int &port) const override; + socket_t socket() const override; + + const std::string &get_buffer() const; + +private: + std::string buffer; + size_t position = 0; +}; + +class compressor { +public: + virtual ~compressor() = default; + + typedef std::function Callback; + virtual bool compress(const char *data, size_t data_length, bool last, + Callback callback) = 0; +}; + +class decompressor { +public: + virtual ~decompressor() = default; + + virtual bool is_valid() const = 0; + + typedef std::function Callback; + virtual bool decompress(const char *data, size_t data_length, + Callback callback) = 0; +}; + +class nocompressor : public compressor { +public: + virtual ~nocompressor() = default; + + bool compress(const char *data, size_t data_length, bool /*last*/, + Callback callback) override; +}; + +#ifdef CPPHTTPLIB_ZLIB_SUPPORT +class gzip_compressor : public compressor { +public: + gzip_compressor(); + ~gzip_compressor(); + + bool compress(const char *data, size_t data_length, bool last, + Callback callback) override; + +private: + bool is_valid_ = false; + z_stream strm_; +}; + +class gzip_decompressor : public decompressor { +public: + gzip_decompressor(); + ~gzip_decompressor(); + + bool is_valid() const override; + + bool decompress(const char *data, size_t data_length, + Callback callback) override; + +private: + bool is_valid_ = false; + z_stream strm_; +}; +#endif + +#ifdef CPPHTTPLIB_BROTLI_SUPPORT +class brotli_compressor : public compressor { +public: + brotli_compressor(); + ~brotli_compressor(); + + bool compress(const char *data, size_t data_length, bool last, + Callback callback) override; + +private: + BrotliEncoderState *state_ = nullptr; +}; + +class brotli_decompressor : public decompressor { +public: + brotli_decompressor(); + ~brotli_decompressor(); + + bool is_valid() const override; + + bool decompress(const char *data, size_t data_length, + Callback callback) override; + +private: + BrotliDecoderResult decoder_r; + BrotliDecoderState *decoder_s = nullptr; +}; +#endif + +// NOTE: until the read size reaches `fixed_buffer_size`, use `fixed_buffer` +// to store data. The call can set memory on stack for performance. +class stream_line_reader { +public: + stream_line_reader(Stream &strm, char *fixed_buffer, + size_t fixed_buffer_size); + const char *ptr() const; + size_t size() const; + bool end_with_crlf() const; + bool getline(); + +private: + void append(char c); + + Stream &strm_; + char *fixed_buffer_; + const size_t fixed_buffer_size_; + size_t fixed_buffer_used_size_ = 0; + std::string glowable_buffer_; +}; + +} // namespace detail + +// ---------------------------------------------------------------------------- + +/* + * Implementation that will be part of the .cc file if split into .h + .cc. + */ + +namespace detail { + +inline bool is_hex(char c, int &v) { + 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; +} + +inline bool from_hex_to_i(const std::string &s, size_t i, size_t cnt, + 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; +} + +inline std::string from_i_to_hex(size_t n) { + const char *charset = "0123456789abcdef"; + std::string ret; + do { + ret = charset[n & 15] + ret; + n >>= 4; + } while (n > 0); + return ret; +} + +inline size_t to_utf8(int code, char *buff) { + if (code < 0x0080) { + buff[0] = (code & 0x7F); + return 1; + } else if (code < 0x0800) { + buff[0] = static_cast(0xC0 | ((code >> 6) & 0x1F)); + buff[1] = static_cast(0x80 | (code & 0x3F)); + return 2; + } else if (code < 0xD800) { + buff[0] = static_cast(0xE0 | ((code >> 12) & 0xF)); + buff[1] = static_cast(0x80 | ((code >> 6) & 0x3F)); + buff[2] = static_cast(0x80 | (code & 0x3F)); + return 3; + } else if (code < 0xE000) { // D800 - DFFF is invalid... + return 0; + } else if (code < 0x10000) { + buff[0] = static_cast(0xE0 | ((code >> 12) & 0xF)); + buff[1] = static_cast(0x80 | ((code >> 6) & 0x3F)); + buff[2] = static_cast(0x80 | (code & 0x3F)); + return 3; + } else if (code < 0x110000) { + buff[0] = static_cast(0xF0 | ((code >> 18) & 0x7)); + buff[1] = static_cast(0x80 | ((code >> 12) & 0x3F)); + buff[2] = static_cast(0x80 | ((code >> 6) & 0x3F)); + buff[3] = static_cast(0x80 | (code & 0x3F)); + return 4; + } + + // NOTREACHED + return 0; +} + +// NOTE: This code came up with the following stackoverflow post: +// https://stackoverflow.com/questions/180947/base64-decode-snippet-in-c +inline std::string base64_encode(const std::string &in) { + static const auto lookup = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + + std::string out; + out.reserve(in.size()); + + int val = 0; + int valb = -6; + + for (auto c : in) { + val = (val << 8) + static_cast(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; +} + +inline bool is_file(const std::string &path) { +#ifdef _WIN32 + return _access_s(path.c_str(), 0) == 0; +#else + struct stat st; + return stat(path.c_str(), &st) >= 0 && S_ISREG(st.st_mode); +#endif +} + +inline bool is_dir(const std::string &path) { + struct stat st; + return stat(path.c_str(), &st) >= 0 && S_ISDIR(st.st_mode); +} + +inline bool is_valid_path(const std::string &path) { + 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; +} + +inline std::string encode_query_param(const std::string &value) { + std::ostringstream escaped; + escaped.fill('0'); + escaped << std::hex; + + for (auto c : value) { + if (std::isalnum(static_cast(c)) || c == '-' || c == '_' || + c == '.' || c == '!' || c == '~' || c == '*' || c == '\'' || c == '(' || + c == ')') { + escaped << c; + } else { + escaped << std::uppercase; + escaped << '%' << std::setw(2) + << static_cast(static_cast(c)); + escaped << std::nouppercase; + } + } + + return escaped.str(); +} + +inline std::string encode_url(const std::string &s) { + std::string result; + result.reserve(s.size()); + + for (size_t i = 0; s[i]; i++) { + switch (s[i]) { + case ' ': result += "%20"; break; + case '+': result += "%2B"; break; + case '\r': result += "%0D"; break; + case '\n': result += "%0A"; break; + case '\'': result += "%27"; break; + case ',': result += "%2C"; break; + // case ':': result += "%3A"; break; // ok? probably... + case ';': result += "%3B"; break; + default: + auto c = static_cast(s[i]); + if (c >= 0x80) { + result += '%'; + char hex[4]; + auto len = snprintf(hex, sizeof(hex) - 1, "%02X", c); + assert(len == 2); + result.append(hex, static_cast(len)); + } else { + result += s[i]; + } + break; + } + } + + return result; +} + +inline std::string decode_url(const std::string &s, + bool convert_plus_to_space) { + std::string result; + + for (size_t i = 0; i < s.size(); i++) { + if (s[i] == '%' && i + 1 < s.size()) { + if (s[i + 1] == 'u') { + int val = 0; + if (from_hex_to_i(s, i + 2, 4, val)) { + // 4 digits Unicode codes + char buff[4]; + size_t len = to_utf8(val, buff); + if (len > 0) { result.append(buff, len); } + i += 5; // 'u0000' + } else { + result += s[i]; + } + } else { + int val = 0; + if (from_hex_to_i(s, i + 1, 2, val)) { + // 2 digits hex codes + result += static_cast(val); + i += 2; // '00' + } else { + result += s[i]; + } + } + } else if (convert_plus_to_space && s[i] == '+') { + result += ' '; + } else { + result += s[i]; + } + } + + return result; +} + +inline void read_file(const std::string &path, std::string &out) { + 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)); + fs.read(&out[0], static_cast(size)); +} + +inline 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(); +} + +inline bool is_space_or_tab(char c) { return c == ' ' || c == '\t'; } + +inline std::pair trim(const char *b, const char *e, size_t left, + size_t right) { + while (b + left < e && is_space_or_tab(b[left])) { + left++; + } + while (right > 0 && is_space_or_tab(b[right - 1])) { + right--; + } + return std::make_pair(left, right); +} + +inline std::string trim_copy(const std::string &s) { + auto r = trim(s.data(), s.data() + s.size(), 0, s.size()); + return s.substr(r.first, r.second - r.first); +} + +inline void split(const char *b, const char *e, char d, + std::function fn) { + size_t i = 0; + size_t beg = 0; + + while (e ? (b + i < e) : (b[i] != '\0')) { + if (b[i] == d) { + auto r = trim(b, e, beg, i); + if (r.first < r.second) { fn(&b[r.first], &b[r.second]); } + beg = i + 1; + } + i++; + } + + if (i) { + auto r = trim(b, e, beg, i); + if (r.first < r.second) { fn(&b[r.first], &b[r.second]); } + } +} + +inline stream_line_reader::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) {} + +inline const char *stream_line_reader::ptr() const { + if (glowable_buffer_.empty()) { + return fixed_buffer_; + } else { + return glowable_buffer_.data(); + } +} + +inline size_t stream_line_reader::size() const { + if (glowable_buffer_.empty()) { + return fixed_buffer_used_size_; + } else { + return glowable_buffer_.size(); + } +} + +inline bool stream_line_reader::end_with_crlf() const { + auto end = ptr() + size(); + return size() >= 2 && end[-2] == '\r' && end[-1] == '\n'; +} + +inline bool stream_line_reader::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; +} + +inline void stream_line_reader::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; + } +} + +inline int close_socket(socket_t sock) { +#ifdef _WIN32 + return closesocket(sock); +#else + return close(sock); +#endif +} + +template inline ssize_t handle_EINTR(T fn) { + ssize_t res = false; + while (true) { + res = fn(); + if (res < 0 && errno == EINTR) { continue; } + break; + } + return res; +} + +inline ssize_t read_socket(socket_t sock, void *ptr, size_t size, int flags) { + return handle_EINTR([&]() { + return recv(sock, +#ifdef _WIN32 + static_cast(ptr), static_cast(size), +#else + ptr, size, +#endif + flags); + }); +} + +inline ssize_t send_socket(socket_t sock, const void *ptr, size_t size, + int flags) { + return handle_EINTR([&]() { + return send(sock, +#ifdef _WIN32 + static_cast(ptr), static_cast(size), +#else + ptr, size, +#endif + flags); + }); +} + +inline ssize_t 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(sec * 1000 + usec / 1000); + + return handle_EINTR([&]() { return poll(&pfd_read, 1, timeout); }); +#else +#ifndef _WIN32 + if (sock >= FD_SETSIZE) { return 1; } +#endif + + fd_set fds; + FD_ZERO(&fds); + FD_SET(sock, &fds); + + timeval tv; + tv.tv_sec = static_cast(sec); + tv.tv_usec = static_cast(usec); + + return handle_EINTR([&]() { + return select(static_cast(sock + 1), &fds, nullptr, nullptr, &tv); + }); +#endif +} + +inline ssize_t 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(sec * 1000 + usec / 1000); + + return handle_EINTR([&]() { return poll(&pfd_read, 1, timeout); }); +#else +#ifndef _WIN32 + if (sock >= FD_SETSIZE) { return 1; } +#endif + + fd_set fds; + FD_ZERO(&fds); + FD_SET(sock, &fds); + + timeval tv; + tv.tv_sec = static_cast(sec); + tv.tv_usec = static_cast(usec); + + return handle_EINTR([&]() { + return select(static_cast(sock + 1), nullptr, &fds, nullptr, &tv); + }); +#endif +} + +inline Error 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(sec * 1000 + usec / 1000); + + auto poll_res = handle_EINTR([&]() { return poll(&pfd_read, 1, timeout); }); + + if (poll_res == 0) { return Error::ConnectionTimeout; } + + if (poll_res > 0 && pfd_read.revents & (POLLIN | POLLOUT)) { + int error = 0; + socklen_t len = sizeof(error); + auto res = getsockopt(sock, SOL_SOCKET, SO_ERROR, + reinterpret_cast(&error), &len); + auto successful = res >= 0 && !error; + return successful ? Error::Success : Error::Connection; + } + + return Error::Connection; +#else +#ifndef _WIN32 + if (sock >= FD_SETSIZE) { return Error::Connection; } +#endif + + fd_set fdsr; + FD_ZERO(&fdsr); + FD_SET(sock, &fdsr); + + auto fdsw = fdsr; + auto fdse = fdsr; + + timeval tv; + tv.tv_sec = static_cast(sec); + tv.tv_usec = static_cast(usec); + + auto ret = handle_EINTR([&]() { + return select(static_cast(sock + 1), &fdsr, &fdsw, &fdse, &tv); + }); + + if (ret == 0) { return Error::ConnectionTimeout; } + + if (ret > 0 && (FD_ISSET(sock, &fdsr) || FD_ISSET(sock, &fdsw))) { + int error = 0; + socklen_t len = sizeof(error); + auto res = getsockopt(sock, SOL_SOCKET, SO_ERROR, + reinterpret_cast(&error), &len); + auto successful = res >= 0 && !error; + return successful ? Error::Success : Error::Connection; + } + return Error::Connection; +#endif +} + +inline bool is_socket_alive(socket_t sock) { + const auto val = detail::select_read(sock, 0, 0); + if (val == 0) { + return true; + } else if (val < 0 && errno == EBADF) { + return false; + } + char buf[1]; + return detail::read_socket(sock, &buf[0], sizeof(buf), MSG_PEEK) > 0; +} + +class SocketStream : public Stream { +public: + SocketStream(socket_t sock, time_t read_timeout_sec, time_t read_timeout_usec, + time_t write_timeout_sec, time_t write_timeout_usec); + ~SocketStream() override; + + bool is_readable() const override; + bool is_writable() const override; + ssize_t read(char *ptr, size_t size) override; + ssize_t write(const char *ptr, size_t size) override; + void get_remote_ip_and_port(std::string &ip, int &port) const override; + void get_local_ip_and_port(std::string &ip, int &port) const override; + socket_t socket() const override; + +private: + socket_t sock_; + time_t read_timeout_sec_; + time_t read_timeout_usec_; + time_t write_timeout_sec_; + time_t write_timeout_usec_; + + std::vector read_buff_; + size_t read_buff_off_ = 0; + size_t read_buff_content_size_ = 0; + + static const size_t read_buff_size_ = 1024 * 4; +}; + +#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, time_t write_timeout_sec, + time_t write_timeout_usec); + ~SSLSocketStream() override; + + bool is_readable() const override; + bool is_writable() const override; + ssize_t read(char *ptr, size_t size) override; + ssize_t write(const char *ptr, size_t size) override; + void get_remote_ip_and_port(std::string &ip, int &port) const override; + void get_local_ip_and_port(std::string &ip, int &port) const override; + socket_t socket() const override; + +private: + socket_t sock_; + SSL *ssl_; + time_t read_timeout_sec_; + time_t read_timeout_usec_; + time_t write_timeout_sec_; + time_t write_timeout_usec_; +}; +#endif + +inline bool keep_alive(socket_t sock, time_t keep_alive_timeout_sec) { + using namespace std::chrono; + auto start = steady_clock::now(); + while (true) { + auto val = select_read(sock, 0, 10000); + if (val < 0) { + return false; + } else if (val == 0) { + auto current = steady_clock::now(); + auto duration = duration_cast(current - start); + auto timeout = keep_alive_timeout_sec * 1000; + if (duration.count() > timeout) { return false; } + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } else { + return true; + } + } +} + +template +inline bool +process_server_socket_core(const std::atomic &svr_sock, socket_t sock, + size_t keep_alive_max_count, + time_t keep_alive_timeout_sec, T callback) { + assert(keep_alive_max_count > 0); + auto ret = false; + auto count = keep_alive_max_count; + while (svr_sock != INVALID_SOCKET && count > 0 && + keep_alive(sock, keep_alive_timeout_sec)) { + auto close_connection = count == 1; + auto connection_closed = false; + ret = callback(close_connection, connection_closed); + if (!ret || connection_closed) { break; } + count--; + } + return ret; +} + +template +inline bool +process_server_socket(const std::atomic &svr_sock, socket_t sock, + size_t keep_alive_max_count, + time_t keep_alive_timeout_sec, time_t read_timeout_sec, + time_t read_timeout_usec, time_t write_timeout_sec, + time_t write_timeout_usec, T callback) { + return process_server_socket_core( + svr_sock, sock, keep_alive_max_count, keep_alive_timeout_sec, + [&](bool close_connection, bool &connection_closed) { + SocketStream strm(sock, read_timeout_sec, read_timeout_usec, + write_timeout_sec, write_timeout_usec); + return callback(strm, close_connection, connection_closed); + }); +} + +inline bool process_client_socket(socket_t sock, time_t read_timeout_sec, + time_t read_timeout_usec, + time_t write_timeout_sec, + time_t write_timeout_usec, + std::function callback) { + SocketStream strm(sock, read_timeout_sec, read_timeout_usec, + write_timeout_sec, write_timeout_usec); + return callback(strm); +} + +inline int shutdown_socket(socket_t sock) { +#ifdef _WIN32 + return shutdown(sock, SD_BOTH); +#else + return shutdown(sock, SHUT_RDWR); +#endif +} + +template +socket_t create_socket(const std::string &host, const std::string &ip, int port, + int address_family, int socket_flags, bool tcp_nodelay, + SocketOptions socket_options, + BindOrConnect bind_or_connect) { + // Get address info + const char *node = nullptr; + struct addrinfo hints; + struct addrinfo *result; + + memset(&hints, 0, sizeof(struct addrinfo)); + hints.ai_socktype = SOCK_STREAM; + hints.ai_protocol = 0; + + if (!ip.empty()) { + node = ip.c_str(); + // Ask getaddrinfo to convert IP in c-string to address + hints.ai_family = AF_UNSPEC; + hints.ai_flags = AI_NUMERICHOST; + } else { + if (!host.empty()) { node = host.c_str(); } + hints.ai_family = address_family; + hints.ai_flags = socket_flags; + } + +#ifndef _WIN32 + if (hints.ai_family == AF_UNIX) { + const auto addrlen = host.length(); + if (addrlen > sizeof(sockaddr_un::sun_path)) return INVALID_SOCKET; + + auto sock = socket(hints.ai_family, hints.ai_socktype, hints.ai_protocol); + if (sock != INVALID_SOCKET) { + sockaddr_un addr{}; + addr.sun_family = AF_UNIX; + std::copy(host.begin(), host.end(), addr.sun_path); + + hints.ai_addr = reinterpret_cast(&addr); + hints.ai_addrlen = static_cast( + sizeof(addr) - sizeof(addr.sun_path) + addrlen); + + fcntl(sock, F_SETFD, FD_CLOEXEC); + if (socket_options) { socket_options(sock); } + + if (!bind_or_connect(sock, hints)) { + close_socket(sock); + sock = INVALID_SOCKET; + } + } + return sock; + } +#endif + + auto service = std::to_string(port); + + if (getaddrinfo(node, service.c_str(), &hints, &result)) { +#if defined __linux__ && !defined __ANDROID__ + res_init(); +#endif + 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 | WSA_FLAG_OVERLAPPED); + /** + * 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) { + close_socket(sock); + continue; + } +#endif + + if (tcp_nodelay) { + int yes = 1; + setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast(&yes), + sizeof(yes)); + } + + if (socket_options) { socket_options(sock); } + + if (rp->ai_family == AF_INET6) { + int no = 0; + setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, reinterpret_cast(&no), + sizeof(no)); + } + + // bind or connect + if (bind_or_connect(sock, *rp)) { + freeaddrinfo(result); + return sock; + } + + close_socket(sock); + } + + freeaddrinfo(result); + return INVALID_SOCKET; +} + +inline 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 +} + +inline bool is_connection_error() { +#ifdef _WIN32 + return WSAGetLastError() != WSAEWOULDBLOCK; +#else + return errno != EINPROGRESS; +#endif +} + +inline bool bind_ip_address(socket_t sock, const std::string &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.c_str(), "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(ai.ai_addrlen))) { + ret = true; + break; + } + } + + freeaddrinfo(result); + return ret; +} + +#if !defined _WIN32 && !defined ANDROID && !defined _AIX +#define USE_IF2IP +#endif + +#ifdef USE_IF2IP +inline std::string if2ip(int address_family, const std::string &ifn) { + struct ifaddrs *ifap; + getifaddrs(&ifap); + std::string addr_candidate; + for (auto ifa = ifap; ifa; ifa = ifa->ifa_next) { + if (ifa->ifa_addr && ifn == ifa->ifa_name && + (AF_UNSPEC == address_family || + ifa->ifa_addr->sa_family == address_family)) { + if (ifa->ifa_addr->sa_family == AF_INET) { + auto sa = reinterpret_cast(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); + } + } else if (ifa->ifa_addr->sa_family == AF_INET6) { + auto sa = reinterpret_cast(ifa->ifa_addr); + if (!IN6_IS_ADDR_LINKLOCAL(&sa->sin6_addr)) { + char buf[INET6_ADDRSTRLEN] = {}; + if (inet_ntop(AF_INET6, &sa->sin6_addr, buf, INET6_ADDRSTRLEN)) { + // equivalent to mac's IN6_IS_ADDR_UNIQUE_LOCAL + auto s6_addr_head = sa->sin6_addr.s6_addr[0]; + if (s6_addr_head == 0xfc || s6_addr_head == 0xfd) { + addr_candidate = std::string(buf, INET6_ADDRSTRLEN); + } else { + freeifaddrs(ifap); + return std::string(buf, INET6_ADDRSTRLEN); + } + } + } + } + } + } + freeifaddrs(ifap); + return addr_candidate; +} +#endif + +inline socket_t create_client_socket( + const std::string &host, const std::string &ip, int port, + int address_family, bool tcp_nodelay, SocketOptions socket_options, + time_t connection_timeout_sec, time_t connection_timeout_usec, + time_t read_timeout_sec, time_t read_timeout_usec, time_t write_timeout_sec, + time_t write_timeout_usec, const std::string &intf, Error &error) { + auto sock = create_socket( + host, ip, port, address_family, 0, tcp_nodelay, std::move(socket_options), + [&](socket_t sock2, struct addrinfo &ai) -> bool { + if (!intf.empty()) { +#ifdef USE_IF2IP + auto ip_from_if = if2ip(address_family, intf); + if (ip_from_if.empty()) { ip_from_if = intf; } + if (!bind_ip_address(sock2, ip_from_if.c_str())) { + error = Error::BindIPAddress; + return false; + } +#endif + } + + set_nonblocking(sock2, true); + + auto ret = + ::connect(sock2, ai.ai_addr, static_cast(ai.ai_addrlen)); + + if (ret < 0) { + if (is_connection_error()) { + error = Error::Connection; + return false; + } + error = wait_until_socket_is_ready(sock2, connection_timeout_sec, + connection_timeout_usec); + if (error != Error::Success) { return false; } + } + + set_nonblocking(sock2, false); + + { +#ifdef _WIN32 + auto timeout = static_cast(read_timeout_sec * 1000 + + read_timeout_usec / 1000); + setsockopt(sock2, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, + sizeof(timeout)); +#else + timeval tv; + tv.tv_sec = static_cast(read_timeout_sec); + tv.tv_usec = static_cast(read_timeout_usec); + setsockopt(sock2, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv)); +#endif + } + { + +#ifdef _WIN32 + auto timeout = static_cast(write_timeout_sec * 1000 + + write_timeout_usec / 1000); + setsockopt(sock2, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout, + sizeof(timeout)); +#else + timeval tv; + tv.tv_sec = static_cast(write_timeout_sec); + tv.tv_usec = static_cast(write_timeout_usec); + setsockopt(sock2, SOL_SOCKET, SO_SNDTIMEO, (char *)&tv, sizeof(tv)); +#endif + } + + error = Error::Success; + return true; + }); + + if (sock != INVALID_SOCKET) { + error = Error::Success; + } else { + if (error == Error::Success) { error = Error::Connection; } + } + + return sock; +} + +inline bool get_ip_and_port(const struct sockaddr_storage &addr, + socklen_t addr_len, std::string &ip, int &port) { + if (addr.ss_family == AF_INET) { + port = ntohs(reinterpret_cast(&addr)->sin_port); + } else if (addr.ss_family == AF_INET6) { + port = + ntohs(reinterpret_cast(&addr)->sin6_port); + } else { + return false; + } + + std::array ipstr{}; + if (getnameinfo(reinterpret_cast(&addr), addr_len, + ipstr.data(), static_cast(ipstr.size()), nullptr, + 0, NI_NUMERICHOST)) { + return false; + } + + ip = ipstr.data(); + return true; +} + +inline void get_local_ip_and_port(socket_t sock, std::string &ip, int &port) { + struct sockaddr_storage addr; + socklen_t addr_len = sizeof(addr); + if (!getsockname(sock, reinterpret_cast(&addr), + &addr_len)) { + get_ip_and_port(addr, addr_len, ip, port); + } +} + +inline void get_remote_ip_and_port(socket_t sock, std::string &ip, int &port) { + struct sockaddr_storage addr; + socklen_t addr_len = sizeof(addr); + + if (!getpeername(sock, reinterpret_cast(&addr), + &addr_len)) { +#ifndef _WIN32 + if (addr.ss_family == AF_UNIX) { +#if defined(__linux__) + struct ucred ucred; + socklen_t len = sizeof(ucred); + if (getsockopt(sock, SOL_SOCKET, SO_PEERCRED, &ucred, &len) == 0) { + port = ucred.pid; + } +#elif defined(SOL_LOCAL) && defined(SO_PEERPID) // __APPLE__ + pid_t pid; + socklen_t len = sizeof(pid); + if (getsockopt(sock, SOL_LOCAL, SO_PEERPID, &pid, &len) == 0) { + port = pid; + } +#endif + return; + } +#endif + get_ip_and_port(addr, addr_len, ip, port); + } +} + +inline constexpr unsigned int str2tag_core(const char *s, size_t l, + unsigned int h) { + return (l == 0) + ? h + : str2tag_core( + s + 1, l - 1, + // Unsets the 6 high bits of h, therefore no overflow happens + (((std::numeric_limits::max)() >> 6) & + h * 33) ^ + static_cast(*s)); +} + +inline unsigned int str2tag(const std::string &s) { + return str2tag_core(s.data(), s.size(), 0); +} + +namespace udl { + +inline constexpr unsigned int operator"" _t(const char *s, size_t l) { + return str2tag_core(s, l, 0); +} + +} // namespace udl + +inline const char * +find_content_type(const std::string &path, + const std::map &user_data) { + auto ext = file_extension(path); + + auto it = user_data.find(ext); + if (it != user_data.end()) { return it->second.c_str(); } + + using udl::operator""_t; + + switch (str2tag(ext)) { + default: return nullptr; + case "css"_t: return "text/css"; + case "csv"_t: return "text/csv"; + case "htm"_t: + case "html"_t: return "text/html"; + case "js"_t: + case "mjs"_t: return "text/javascript"; + case "txt"_t: return "text/plain"; + case "vtt"_t: return "text/vtt"; + + case "apng"_t: return "image/apng"; + case "avif"_t: return "image/avif"; + case "bmp"_t: return "image/bmp"; + case "gif"_t: return "image/gif"; + case "png"_t: return "image/png"; + case "svg"_t: return "image/svg+xml"; + case "webp"_t: return "image/webp"; + case "ico"_t: return "image/x-icon"; + case "tif"_t: return "image/tiff"; + case "tiff"_t: return "image/tiff"; + case "jpg"_t: + case "jpeg"_t: return "image/jpeg"; + + case "mp4"_t: return "video/mp4"; + case "mpeg"_t: return "video/mpeg"; + case "webm"_t: return "video/webm"; + + case "mp3"_t: return "audio/mp3"; + case "mpga"_t: return "audio/mpeg"; + case "weba"_t: return "audio/webm"; + case "wav"_t: return "audio/wave"; + + case "otf"_t: return "font/otf"; + case "ttf"_t: return "font/ttf"; + case "woff"_t: return "font/woff"; + case "woff2"_t: return "font/woff2"; + + case "7z"_t: return "application/x-7z-compressed"; + case "atom"_t: return "application/atom+xml"; + case "pdf"_t: return "application/pdf"; + case "json"_t: return "application/json"; + case "rss"_t: return "application/rss+xml"; + case "tar"_t: return "application/x-tar"; + case "xht"_t: + case "xhtml"_t: return "application/xhtml+xml"; + case "xslt"_t: return "application/xslt+xml"; + case "xml"_t: return "application/xml"; + case "gz"_t: return "application/gzip"; + case "zip"_t: return "application/zip"; + case "wasm"_t: return "application/wasm"; + } +} + +inline const char *status_message(int status) { + switch (status) { + case 100: return "Continue"; + case 101: return "Switching Protocol"; + case 102: return "Processing"; + case 103: return "Early Hints"; + case 200: return "OK"; + case 201: return "Created"; + case 202: return "Accepted"; + case 203: return "Non-Authoritative Information"; + case 204: return "No Content"; + case 205: return "Reset Content"; + case 206: return "Partial Content"; + case 207: return "Multi-Status"; + case 208: return "Already Reported"; + case 226: return "IM Used"; + case 300: return "Multiple Choice"; + case 301: return "Moved Permanently"; + case 302: return "Found"; + case 303: return "See Other"; + case 304: return "Not Modified"; + case 305: return "Use Proxy"; + case 306: return "unused"; + case 307: return "Temporary Redirect"; + case 308: return "Permanent Redirect"; + case 400: return "Bad Request"; + case 401: return "Unauthorized"; + case 402: return "Payment Required"; + case 403: return "Forbidden"; + case 404: return "Not Found"; + case 405: return "Method Not Allowed"; + case 406: return "Not Acceptable"; + case 407: return "Proxy Authentication Required"; + case 408: return "Request Timeout"; + case 409: return "Conflict"; + case 410: return "Gone"; + case 411: return "Length Required"; + case 412: return "Precondition Failed"; + case 413: return "Payload Too Large"; + case 414: return "URI Too Long"; + case 415: return "Unsupported Media Type"; + case 416: return "Range Not Satisfiable"; + case 417: return "Expectation Failed"; + case 418: return "I'm a teapot"; + case 421: return "Misdirected Request"; + case 422: return "Unprocessable Entity"; + case 423: return "Locked"; + case 424: return "Failed Dependency"; + case 425: return "Too Early"; + case 426: return "Upgrade Required"; + case 428: return "Precondition Required"; + case 429: return "Too Many Requests"; + case 431: return "Request Header Fields Too Large"; + case 451: return "Unavailable For Legal Reasons"; + case 501: return "Not Implemented"; + case 502: return "Bad Gateway"; + case 503: return "Service Unavailable"; + case 504: return "Gateway Timeout"; + case 505: return "HTTP Version Not Supported"; + case 506: return "Variant Also Negotiates"; + case 507: return "Insufficient Storage"; + case 508: return "Loop Detected"; + case 510: return "Not Extended"; + case 511: return "Network Authentication Required"; + + default: + case 500: return "Internal Server Error"; + } +} + +inline bool can_compress_content_type(const std::string &content_type) { + using udl::operator""_t; + + auto tag = str2tag(content_type); + + switch (tag) { + case "image/svg+xml"_t: + case "application/javascript"_t: + case "application/json"_t: + case "application/xml"_t: + case "application/protobuf"_t: + case "application/xhtml+xml"_t: return true; + + default: + return !content_type.rfind("text/", 0) && tag != "text/event-stream"_t; + } +} + +inline EncodingType encoding_type(const Request &req, const Response &res) { + auto ret = + detail::can_compress_content_type(res.get_header_value("Content-Type")); + if (!ret) { return EncodingType::None; } + + const auto &s = req.get_header_value("Accept-Encoding"); + (void)(s); + +#ifdef CPPHTTPLIB_BROTLI_SUPPORT + // TODO: 'Accept-Encoding' has br, not br;q=0 + ret = s.find("br") != std::string::npos; + if (ret) { return EncodingType::Brotli; } +#endif + +#ifdef CPPHTTPLIB_ZLIB_SUPPORT + // TODO: 'Accept-Encoding' has gzip, not gzip;q=0 + ret = s.find("gzip") != std::string::npos; + if (ret) { return EncodingType::Gzip; } +#endif + + return EncodingType::None; +} + +inline bool nocompressor::compress(const char *data, size_t data_length, + bool /*last*/, Callback callback) { + if (!data_length) { return true; } + return callback(data, data_length); +} + +#ifdef CPPHTTPLIB_ZLIB_SUPPORT +inline gzip_compressor::gzip_compressor() { + std::memset(&strm_, 0, sizeof(strm_)); + strm_.zalloc = Z_NULL; + strm_.zfree = Z_NULL; + strm_.opaque = Z_NULL; + + is_valid_ = deflateInit2(&strm_, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 31, 8, + Z_DEFAULT_STRATEGY) == Z_OK; +} + +inline gzip_compressor::~gzip_compressor() { deflateEnd(&strm_); } + +inline bool gzip_compressor::compress(const char *data, size_t data_length, + bool last, Callback callback) { + assert(is_valid_); + + do { + constexpr size_t max_avail_in = + (std::numeric_limits::max)(); + + strm_.avail_in = static_cast( + (std::min)(data_length, max_avail_in)); + strm_.next_in = const_cast(reinterpret_cast(data)); + + data_length -= strm_.avail_in; + data += strm_.avail_in; + + auto flush = (last && data_length == 0) ? Z_FINISH : Z_NO_FLUSH; + int ret = Z_OK; + + std::array buff{}; + do { + strm_.avail_out = static_cast(buff.size()); + strm_.next_out = reinterpret_cast(buff.data()); + + ret = deflate(&strm_, flush); + if (ret == Z_STREAM_ERROR) { return false; } + + if (!callback(buff.data(), buff.size() - strm_.avail_out)) { + return false; + } + } while (strm_.avail_out == 0); + + assert((flush == Z_FINISH && ret == Z_STREAM_END) || + (flush == Z_NO_FLUSH && ret == Z_OK)); + assert(strm_.avail_in == 0); + } while (data_length > 0); + + return true; +} + +inline gzip_decompressor::gzip_decompressor() { + std::memset(&strm_, 0, sizeof(strm_)); + strm_.zalloc = Z_NULL; + strm_.zfree = Z_NULL; + strm_.opaque = Z_NULL; + + // 15 is the value of wbits, which should be at the maximum possible value + // to ensure that any gzip stream can be decoded. The offset of 32 specifies + // that the stream type should be automatically detected either gzip or + // deflate. + is_valid_ = inflateInit2(&strm_, 32 + 15) == Z_OK; +} + +inline gzip_decompressor::~gzip_decompressor() { inflateEnd(&strm_); } + +inline bool gzip_decompressor::is_valid() const { return is_valid_; } + +inline bool gzip_decompressor::decompress(const char *data, size_t data_length, + Callback callback) { + assert(is_valid_); + + int ret = Z_OK; + + do { + constexpr size_t max_avail_in = + (std::numeric_limits::max)(); + + strm_.avail_in = static_cast( + (std::min)(data_length, max_avail_in)); + strm_.next_in = const_cast(reinterpret_cast(data)); + + data_length -= strm_.avail_in; + data += strm_.avail_in; + + std::array buff{}; + while (strm_.avail_in > 0) { + strm_.avail_out = static_cast(buff.size()); + strm_.next_out = reinterpret_cast(buff.data()); + + auto prev_avail_in = strm_.avail_in; + + ret = inflate(&strm_, Z_NO_FLUSH); + + if (prev_avail_in - strm_.avail_in == 0) { return false; } + + assert(ret != Z_STREAM_ERROR); + switch (ret) { + case Z_NEED_DICT: + case Z_DATA_ERROR: + case Z_MEM_ERROR: inflateEnd(&strm_); return false; + } + + if (!callback(buff.data(), buff.size() - strm_.avail_out)) { + return false; + } + } + + if (ret != Z_OK && ret != Z_STREAM_END) return false; + + } while (data_length > 0); + + return true; +} +#endif + +#ifdef CPPHTTPLIB_BROTLI_SUPPORT +inline brotli_compressor::brotli_compressor() { + state_ = BrotliEncoderCreateInstance(nullptr, nullptr, nullptr); +} + +inline brotli_compressor::~brotli_compressor() { + BrotliEncoderDestroyInstance(state_); +} + +inline bool brotli_compressor::compress(const char *data, size_t data_length, + bool last, Callback callback) { + std::array buff{}; + + auto operation = last ? BROTLI_OPERATION_FINISH : BROTLI_OPERATION_PROCESS; + auto available_in = data_length; + auto next_in = reinterpret_cast(data); + + for (;;) { + if (last) { + if (BrotliEncoderIsFinished(state_)) { break; } + } else { + if (!available_in) { break; } + } + + auto available_out = buff.size(); + auto next_out = buff.data(); + + if (!BrotliEncoderCompressStream(state_, operation, &available_in, &next_in, + &available_out, &next_out, nullptr)) { + return false; + } + + auto output_bytes = buff.size() - available_out; + if (output_bytes) { + callback(reinterpret_cast(buff.data()), output_bytes); + } + } + + return true; +} + +inline brotli_decompressor::brotli_decompressor() { + decoder_s = BrotliDecoderCreateInstance(0, 0, 0); + decoder_r = decoder_s ? BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT + : BROTLI_DECODER_RESULT_ERROR; +} + +inline brotli_decompressor::~brotli_decompressor() { + if (decoder_s) { BrotliDecoderDestroyInstance(decoder_s); } +} + +inline bool brotli_decompressor::is_valid() const { return decoder_s; } + +inline bool brotli_decompressor::decompress(const char *data, + size_t data_length, + Callback callback) { + if (decoder_r == BROTLI_DECODER_RESULT_SUCCESS || + decoder_r == BROTLI_DECODER_RESULT_ERROR) { + return 0; + } + + const uint8_t *next_in = (const uint8_t *)data; + size_t avail_in = data_length; + size_t total_out; + + decoder_r = BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT; + + std::array buff{}; + while (decoder_r == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) { + char *next_out = buff.data(); + size_t avail_out = buff.size(); + + decoder_r = BrotliDecoderDecompressStream( + decoder_s, &avail_in, &next_in, &avail_out, + reinterpret_cast(&next_out), &total_out); + + if (decoder_r == BROTLI_DECODER_RESULT_ERROR) { return false; } + + if (!callback(buff.data(), buff.size() - avail_out)) { return false; } + } + + return decoder_r == BROTLI_DECODER_RESULT_SUCCESS || + decoder_r == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT; +} +#endif + +inline bool has_header(const Headers &headers, const std::string &key) { + return headers.find(key) != headers.end(); +} + +inline const char *get_header_value(const Headers &headers, + const std::string &key, size_t id, + const char *def) { + auto rng = headers.equal_range(key); + auto it = rng.first; + std::advance(it, static_cast(id)); + if (it != rng.second) { return it->second.c_str(); } + return def; +} + +inline bool compare_case_ignore(const std::string &a, const std::string &b) { + if (a.size() != b.size()) { return false; } + for (size_t i = 0; i < b.size(); i++) { + if (::tolower(a[i]) != ::tolower(b[i])) { return false; } + } + return true; +} + +template +inline bool parse_header(const char *beg, const char *end, T fn) { + // Skip trailing spaces and tabs. + while (beg < end && is_space_or_tab(end[-1])) { + end--; + } + + auto p = beg; + while (p < end && *p != ':') { + p++; + } + + if (p == end) { return false; } + + auto key_end = p; + + if (*p++ != ':') { return false; } + + while (p < end && is_space_or_tab(*p)) { + p++; + } + + if (p < end) { + auto key = std::string(beg, key_end); + auto val = compare_case_ignore(key, "Location") + ? std::string(p, end) + : decode_url(std::string(p, end), false); + fn(std::move(key), std::move(val)); + return true; + } + + return false; +} + +inline 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. + auto line_terminator_len = 2; + if (line_reader.end_with_crlf()) { + // Blank line indicates end of headers. + if (line_reader.size() == 2) { break; } +#ifdef CPPHTTPLIB_ALLOW_LF_AS_LINE_TERMINATOR + } else { + // Blank line indicates end of headers. + if (line_reader.size() == 1) { break; } + line_terminator_len = 1; + } +#else + } else { + continue; // Skip invalid line. + } +#endif + + if (line_reader.size() > CPPHTTPLIB_HEADER_MAX_LENGTH) { return false; } + + // Exclude line terminator + auto end = line_reader.ptr() + line_reader.size() - line_terminator_len; + + parse_header(line_reader.ptr(), end, + [&](std::string &&key, std::string &&val) { + headers.emplace(std::move(key), std::move(val)); + }); + } + + return true; +} + +inline bool read_content_with_length(Stream &strm, uint64_t len, + Progress progress, + ContentReceiverWithProgress out) { + char buf[CPPHTTPLIB_RECV_BUFSIZ]; + + uint64_t r = 0; + while (r < len) { + auto read_len = static_cast(len - r); + auto n = strm.read(buf, (std::min)(read_len, CPPHTTPLIB_RECV_BUFSIZ)); + if (n <= 0) { return false; } + + if (!out(buf, static_cast(n), r, len)) { return false; } + r += static_cast(n); + + if (progress) { + if (!progress(r, len)) { return false; } + } + } + + return true; +} + +inline 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(len - r); + auto n = strm.read(buf, (std::min)(read_len, CPPHTTPLIB_RECV_BUFSIZ)); + if (n <= 0) { return; } + r += static_cast(n); + } +} + +inline bool read_content_without_length(Stream &strm, + ContentReceiverWithProgress out) { + char buf[CPPHTTPLIB_RECV_BUFSIZ]; + uint64_t r = 0; + for (;;) { + auto n = strm.read(buf, CPPHTTPLIB_RECV_BUFSIZ); + if (n < 0) { + return false; + } else if (n == 0) { + return true; + } + + if (!out(buf, static_cast(n), r, 0)) { return false; } + r += static_cast(n); + } + + return true; +} + +template +inline bool read_content_chunked(Stream &strm, T &x, + ContentReceiverWithProgress out) { + const auto bufsiz = 16; + char buf[bufsiz]; + + stream_line_reader line_reader(strm, buf, bufsiz); + + if (!line_reader.getline()) { return false; } + + unsigned long chunk_len; + while (true) { + char *end_ptr; + + chunk_len = std::strtoul(line_reader.ptr(), &end_ptr, 16); + + if (end_ptr == line_reader.ptr()) { return false; } + if (chunk_len == ULONG_MAX) { return false; } + + if (chunk_len == 0) { break; } + + 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")) { return false; } + + if (!line_reader.getline()) { return false; } + } + + assert(chunk_len == 0); + + // Trailer + if (!line_reader.getline()) { return false; } + + while (strcmp(line_reader.ptr(), "\r\n")) { + if (line_reader.size() > CPPHTTPLIB_HEADER_MAX_LENGTH) { return false; } + + // Exclude line terminator + constexpr auto line_terminator_len = 2; + auto end = line_reader.ptr() + line_reader.size() - line_terminator_len; + + parse_header(line_reader.ptr(), end, + [&](std::string &&key, std::string &&val) { + x.headers.emplace(std::move(key), std::move(val)); + }); + + if (!line_reader.getline()) { return false; } + } + + return true; +} + +inline bool is_chunked_transfer_encoding(const Headers &headers) { + return !strcasecmp(get_header_value(headers, "Transfer-Encoding", 0, ""), + "chunked"); +} + +template +bool prepare_content_receiver(T &x, int &status, + ContentReceiverWithProgress receiver, + bool decompress, U callback) { + if (decompress) { + std::string encoding = x.get_header_value("Content-Encoding"); + std::unique_ptr decompressor; + + if (encoding == "gzip" || encoding == "deflate") { +#ifdef CPPHTTPLIB_ZLIB_SUPPORT + decompressor = detail::make_unique(); +#else + status = 415; + return false; +#endif + } else if (encoding.find("br") != std::string::npos) { +#ifdef CPPHTTPLIB_BROTLI_SUPPORT + decompressor = detail::make_unique(); +#else + status = 415; + return false; +#endif + } + + if (decompressor) { + if (decompressor->is_valid()) { + ContentReceiverWithProgress out = [&](const char *buf, size_t n, + uint64_t off, uint64_t len) { + return decompressor->decompress(buf, n, + [&](const char *buf2, size_t n2) { + return receiver(buf2, n2, off, len); + }); + }; + return callback(std::move(out)); + } else { + status = 500; + return false; + } + } + } + + ContentReceiverWithProgress out = [&](const char *buf, size_t n, uint64_t off, + uint64_t len) { + return receiver(buf, n, off, len); + }; + return callback(std::move(out)); +} + +template +bool read_content(Stream &strm, T &x, size_t payload_max_length, int &status, + Progress progress, ContentReceiverWithProgress receiver, + bool decompress) { + return prepare_content_receiver( + x, status, std::move(receiver), decompress, + [&](const ContentReceiverWithProgress &out) { + auto ret = true; + auto exceed_payload_max_length = false; + + if (is_chunked_transfer_encoding(x.headers)) { + ret = read_content_chunked(strm, x, out); + } else if (!has_header(x.headers, "Content-Length")) { + ret = read_content_without_length(strm, out); + } else { + auto len = get_header_value(x.headers, "Content-Length"); + if (len > payload_max_length) { + exceed_payload_max_length = true; + skip_content_with_length(strm, len); + ret = false; + } else if (len > 0) { + ret = read_content_with_length(strm, len, std::move(progress), out); + } + } + + if (!ret) { status = exceed_payload_max_length ? 413 : 400; } + return ret; + }); +} // namespace detail + +inline ssize_t write_headers(Stream &strm, const Headers &headers) { + ssize_t write_len = 0; + for (const auto &x : headers) { + auto len = + strm.write_format("%s: %s\r\n", x.first.c_str(), x.second.c_str()); + if (len < 0) { return len; } + write_len += len; + } + auto len = strm.write("\r\n"); + if (len < 0) { return len; } + write_len += len; + return write_len; +} + +inline bool write_data(Stream &strm, const char *d, size_t l) { + size_t offset = 0; + while (offset < l) { + auto length = strm.write(d + offset, l - offset); + if (length < 0) { return false; } + offset += static_cast(length); + } + return true; +} + +template +inline bool write_content(Stream &strm, const ContentProvider &content_provider, + size_t offset, size_t length, T is_shutting_down, + Error &error) { + size_t end_offset = offset + length; + auto ok = true; + DataSink data_sink; + + data_sink.write = [&](const char *d, size_t l) -> bool { + if (ok) { + if (strm.is_writable() && write_data(strm, d, l)) { + offset += l; + } else { + ok = false; + } + } + return ok; + }; + + while (offset < end_offset && !is_shutting_down()) { + if (!strm.is_writable()) { + error = Error::Write; + return false; + } else if (!content_provider(offset, end_offset - offset, data_sink)) { + error = Error::Canceled; + return false; + } else if (!ok) { + error = Error::Write; + return false; + } + } + + error = Error::Success; + return true; +} + +template +inline bool write_content(Stream &strm, const ContentProvider &content_provider, + size_t offset, size_t length, + const T &is_shutting_down) { + auto error = Error::Success; + return write_content(strm, content_provider, offset, length, is_shutting_down, + error); +} + +template +inline bool +write_content_without_length(Stream &strm, + const ContentProvider &content_provider, + const T &is_shutting_down) { + size_t offset = 0; + auto data_available = true; + auto ok = true; + DataSink data_sink; + + data_sink.write = [&](const char *d, size_t l) -> bool { + if (ok) { + offset += l; + if (!strm.is_writable() || !write_data(strm, d, l)) { ok = false; } + } + return ok; + }; + + data_sink.done = [&](void) { data_available = false; }; + + while (data_available && !is_shutting_down()) { + if (!strm.is_writable()) { + return false; + } else if (!content_provider(offset, 0, data_sink)) { + return false; + } else if (!ok) { + return false; + } + } + return true; +} + +template +inline bool +write_content_chunked(Stream &strm, const ContentProvider &content_provider, + const T &is_shutting_down, U &compressor, Error &error) { + size_t offset = 0; + auto data_available = true; + auto ok = true; + DataSink data_sink; + + data_sink.write = [&](const char *d, size_t l) -> bool { + if (ok) { + data_available = l > 0; + offset += l; + + std::string payload; + if (compressor.compress(d, l, false, + [&](const char *data, size_t data_len) { + payload.append(data, data_len); + return true; + })) { + if (!payload.empty()) { + // Emit chunked response header and footer for each chunk + auto chunk = + from_i_to_hex(payload.size()) + "\r\n" + payload + "\r\n"; + if (!strm.is_writable() || + !write_data(strm, chunk.data(), chunk.size())) { + ok = false; + } + } + } else { + ok = false; + } + } + return ok; + }; + + auto done_with_trailer = [&](const Headers *trailer) { + if (!ok) { return; } + + data_available = false; + + std::string payload; + if (!compressor.compress(nullptr, 0, true, + [&](const char *data, size_t data_len) { + payload.append(data, data_len); + return true; + })) { + ok = false; + return; + } + + if (!payload.empty()) { + // Emit chunked response header and footer for each chunk + auto chunk = from_i_to_hex(payload.size()) + "\r\n" + payload + "\r\n"; + if (!strm.is_writable() || + !write_data(strm, chunk.data(), chunk.size())) { + ok = false; + return; + } + } + + static const std::string done_marker("0\r\n"); + if (!write_data(strm, done_marker.data(), done_marker.size())) { + ok = false; + } + + // Trailer + if (trailer) { + for (const auto &kv : *trailer) { + std::string field_line = kv.first + ": " + kv.second + "\r\n"; + if (!write_data(strm, field_line.data(), field_line.size())) { + ok = false; + } + } + } + + static const std::string crlf("\r\n"); + if (!write_data(strm, crlf.data(), crlf.size())) { ok = false; } + }; + + data_sink.done = [&](void) { done_with_trailer(nullptr); }; + + data_sink.done_with_trailer = [&](const Headers &trailer) { + done_with_trailer(&trailer); + }; + + while (data_available && !is_shutting_down()) { + if (!strm.is_writable()) { + error = Error::Write; + return false; + } else if (!content_provider(offset, 0, data_sink)) { + error = Error::Canceled; + return false; + } else if (!ok) { + error = Error::Write; + return false; + } + } + + error = Error::Success; + return true; +} + +template +inline bool write_content_chunked(Stream &strm, + const ContentProvider &content_provider, + const T &is_shutting_down, U &compressor) { + auto error = Error::Success; + return write_content_chunked(strm, content_provider, is_shutting_down, + compressor, error); +} + +template +inline bool redirect(T &cli, Request &req, Response &res, + const std::string &path, const std::string &location, + Error &error) { + Request new_req = req; + new_req.path = path; + new_req.redirect_count_ -= 1; + + if (res.status == 303 && (req.method != "GET" && req.method != "HEAD")) { + new_req.method = "GET"; + new_req.body.clear(); + new_req.headers.clear(); + } + + Response new_res; + + auto ret = cli.send(new_req, new_res, error); + if (ret) { + req = new_req; + res = new_res; + res.location = location; + } + return ret; +} + +inline std::string params_to_query_str(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 += encode_query_param(it->second); + } + return query; +} + +inline void parse_query_text(const std::string &s, Params ¶ms) { + std::set cache; + split(s.data(), s.data() + s.size(), '&', [&](const char *b, const char *e) { + std::string kv(b, e); + if (cache.find(kv) != cache.end()) { return; } + cache.insert(kv); + + std::string key; + std::string val; + split(b, e, '=', [&](const char *b2, const char *e2) { + if (key.empty()) { + key.assign(b2, e2); + } else { + val.assign(b2, e2); + } + }); + + if (!key.empty()) { + params.emplace(decode_url(key, true), decode_url(val, true)); + } + }); +} + +inline bool parse_multipart_boundary(const std::string &content_type, + std::string &boundary) { + auto boundary_keyword = "boundary="; + auto pos = content_type.find(boundary_keyword); + if (pos == std::string::npos) { return false; } + auto end = content_type.find(';', pos); + auto beg = pos + strlen(boundary_keyword); + boundary = content_type.substr(beg, end - beg); + if (boundary.length() >= 2 && boundary.front() == '"' && + boundary.back() == '"') { + boundary = boundary.substr(1, boundary.size() - 2); + } + return !boundary.empty(); +} + +#ifdef CPPHTTPLIB_NO_EXCEPTIONS +inline bool parse_range_header(const std::string &s, Ranges &ranges) { +#else +inline bool parse_range_header(const std::string &s, Ranges &ranges) try { +#endif + 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 = static_cast(m.position(1)); + auto len = static_cast(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(std::stoll(cm.str(1))); + } + + ssize_t last = -1; + if (!cm.str(2).empty()) { + last = static_cast(std::stoll(cm.str(2))); + } + + 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; +#ifdef CPPHTTPLIB_NO_EXCEPTIONS +} +#else +} catch (...) { return false; } +#endif + +class MultipartFormDataParser { +public: + MultipartFormDataParser() = default; + + void set_boundary(std::string &&boundary) { + boundary_ = boundary; + dash_boundary_crlf_ = dash_ + boundary_ + crlf_; + crlf_dash_boundary_ = crlf_ + dash_ + boundary_; + } + + bool is_valid() const { return is_valid_; } + + bool parse(const char *buf, size_t n, const ContentReceiver &content_callback, + const MultipartContentHeader &header_callback) { + + // TODO: support 'filename*' + static const std::regex re_content_disposition( + R"~(^Content-Disposition:\s*form-data;\s*name="(.*?)"(?:;\s*filename="(.*?)")?(?:;\s*filename\*=\S+)?\s*$)~", + std::regex_constants::icase); + + buf_append(buf, n); + + while (buf_size() > 0) { + switch (state_) { + case 0: { // Initial boundary + buf_erase(buf_find(dash_boundary_crlf_)); + if (dash_boundary_crlf_.size() > buf_size()) { return true; } + if (!buf_start_with(dash_boundary_crlf_)) { return false; } + buf_erase(dash_boundary_crlf_.size()); + state_ = 1; + break; + } + case 1: { // New entry + clear_file_info(); + state_ = 2; + break; + } + case 2: { // Headers + auto pos = buf_find(crlf_); + if (pos > CPPHTTPLIB_HEADER_MAX_LENGTH) { return false; } + while (pos < buf_size()) { + // Empty line + if (pos == 0) { + if (!header_callback(file_)) { + is_valid_ = false; + return false; + } + buf_erase(crlf_.size()); + state_ = 3; + break; + } + + static const std::string header_name = "content-type:"; + const auto header = buf_head(pos); + if (start_with_case_ignore(header, header_name)) { + file_.content_type = trim_copy(header.substr(header_name.size())); + } else { + std::smatch m; + if (std::regex_match(header, m, re_content_disposition)) { + file_.name = m[1]; + file_.filename = m[2]; + } else { + is_valid_ = false; + return false; + } + } + buf_erase(pos + crlf_.size()); + pos = buf_find(crlf_); + } + if (state_ != 3) { return true; } + break; + } + case 3: { // Body + if (crlf_dash_boundary_.size() > buf_size()) { return true; } + auto pos = buf_find(crlf_dash_boundary_); + if (pos < buf_size()) { + if (!content_callback(buf_data(), pos)) { + is_valid_ = false; + return false; + } + buf_erase(pos + crlf_dash_boundary_.size()); + state_ = 4; + } else { + auto len = buf_size() - crlf_dash_boundary_.size(); + if (len > 0) { + if (!content_callback(buf_data(), len)) { + is_valid_ = false; + return false; + } + buf_erase(len); + } + return true; + } + break; + } + case 4: { // Boundary + if (crlf_.size() > buf_size()) { return true; } + if (buf_start_with(crlf_)) { + buf_erase(crlf_.size()); + state_ = 1; + } else { + if (dash_crlf_.size() > buf_size()) { return true; } + if (buf_start_with(dash_crlf_)) { + buf_erase(dash_crlf_.size()); + is_valid_ = true; + buf_erase(buf_size()); // Remove epilogue + } else { + return true; + } + } + break; + } + } + } + + return true; + } + +private: + void clear_file_info() { + file_.name.clear(); + file_.filename.clear(); + file_.content_type.clear(); + } + + bool start_with_case_ignore(const std::string &a, + const std::string &b) const { + if (a.size() < b.size()) { return false; } + for (size_t i = 0; i < b.size(); i++) { + if (::tolower(a[i]) != ::tolower(b[i])) { return false; } + } + return true; + } + + const std::string dash_ = "--"; + const std::string crlf_ = "\r\n"; + const std::string dash_crlf_ = "--\r\n"; + std::string boundary_; + std::string dash_boundary_crlf_; + std::string crlf_dash_boundary_; + + size_t state_ = 0; + bool is_valid_ = false; + MultipartFormData file_; + + // Buffer + bool start_with(const std::string &a, size_t spos, size_t epos, + const std::string &b) const { + if (epos - spos < b.size()) { return false; } + for (size_t i = 0; i < b.size(); i++) { + if (a[i + spos] != b[i]) { return false; } + } + return true; + } + + size_t buf_size() const { return buf_epos_ - buf_spos_; } + + const char *buf_data() const { return &buf_[buf_spos_]; } + + std::string buf_head(size_t l) const { return buf_.substr(buf_spos_, l); } + + bool buf_start_with(const std::string &s) const { + return start_with(buf_, buf_spos_, buf_epos_, s); + } + + size_t buf_find(const std::string &s) const { + auto c = s.front(); + + size_t off = buf_spos_; + while (off < buf_epos_) { + auto pos = off; + while (true) { + if (pos == buf_epos_) { return buf_size(); } + if (buf_[pos] == c) { break; } + pos++; + } + + auto remaining_size = buf_epos_ - pos; + if (s.size() > remaining_size) { return buf_size(); } + + if (start_with(buf_, pos, buf_epos_, s)) { return pos - buf_spos_; } + + off = pos + 1; + } + + return buf_size(); + } + + void buf_append(const char *data, size_t n) { + auto remaining_size = buf_size(); + if (remaining_size > 0 && buf_spos_ > 0) { + for (size_t i = 0; i < remaining_size; i++) { + buf_[i] = buf_[buf_spos_ + i]; + } + } + buf_spos_ = 0; + buf_epos_ = remaining_size; + + if (remaining_size + n > buf_.size()) { buf_.resize(remaining_size + n); } + + for (size_t i = 0; i < n; i++) { + buf_[buf_epos_ + i] = data[i]; + } + buf_epos_ += n; + } + + void buf_erase(size_t size) { buf_spos_ += size; } + + std::string buf_; + size_t buf_spos_ = 0; + size_t buf_epos_ = 0; +}; + +inline std::string to_lower(const char *beg, const char *end) { + std::string out; + auto it = beg; + while (it != end) { + out += static_cast(::tolower(*it)); + it++; + } + return out; +} + +inline std::string make_multipart_data_boundary() { + static const char data[] = + "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; + + // std::random_device might actually be deterministic on some + // platforms, but due to lack of support in the c++ standard library, + // doing better requires either some ugly hacks or breaking portability. + std::random_device seed_gen; + + // Request 128 bits of entropy for initialization + std::seed_seq seed_sequence{seed_gen(), seed_gen(), seed_gen(), seed_gen()}; + std::mt19937 engine(seed_sequence); + + std::string result = "--cpp-httplib-multipart-data-"; + + for (auto i = 0; i < 16; i++) { + result += data[engine() % (sizeof(data) - 1)]; + } + + return result; +} + +inline bool is_multipart_boundary_chars_valid(const std::string &boundary) { + auto valid = true; + for (size_t i = 0; i < boundary.size(); i++) { + auto c = boundary[i]; + if (!std::isalnum(c) && c != '-' && c != '_') { + valid = false; + break; + } + } + return valid; +} + +template +inline std::string +serialize_multipart_formdata_item_begin(const T &item, + const std::string &boundary) { + std::string body = "--" + boundary + "\r\n"; + body += "Content-Disposition: form-data; name=\"" + item.name + "\""; + if (!item.filename.empty()) { + body += "; filename=\"" + item.filename + "\""; + } + body += "\r\n"; + if (!item.content_type.empty()) { + body += "Content-Type: " + item.content_type + "\r\n"; + } + body += "\r\n"; + + return body; +} + +inline std::string serialize_multipart_formdata_item_end() { return "\r\n"; } + +inline std::string +serialize_multipart_formdata_finish(const std::string &boundary) { + return "--" + boundary + "--\r\n"; +} + +inline std::string +serialize_multipart_formdata_get_content_type(const std::string &boundary) { + return "multipart/form-data; boundary=" + boundary; +} + +inline std::string +serialize_multipart_formdata(const MultipartFormDataItems &items, + const std::string &boundary, bool finish = true) { + std::string body; + + for (const auto &item : items) { + body += serialize_multipart_formdata_item_begin(item, boundary); + body += item.content + serialize_multipart_formdata_item_end(); + } + + if (finish) body += serialize_multipart_formdata_finish(boundary); + + return body; +} + +inline std::pair +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); + } + + auto slen = static_cast(content_length); + + if (r.first == -1) { + r.first = (std::max)(static_cast(0), slen - r.second); + r.second = slen - 1; + } + + if (r.second == -1) { r.second = slen - 1; } + return std::make_pair(r.first, static_cast(r.second - r.first) + 1); +} + +inline 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 +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 = 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; +} + +inline bool make_multipart_ranges_data(const Request &req, Response &res, + const std::string &boundary, + const std::string &content_type, + std::string &data) { + return process_multipart_ranges_data( + req, res, boundary, content_type, + [&](const std::string &token) { data += token; }, + [&](const std::string &token) { data += token; }, + [&](size_t offset, size_t length) { + if (offset < res.body.size()) { + data += res.body.substr(offset, length); + return true; + } + return false; + }); +} + +inline 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 std::string &token) { data_length += token.size(); }, + [&](size_t /*offset*/, size_t length) { + data_length += length; + return true; + }); + + return data_length; +} + +template +inline bool write_multipart_ranges_data(Stream &strm, const Request &req, + Response &res, + const std::string &boundary, + const std::string &content_type, + const T &is_shutting_down) { + return process_multipart_ranges_data( + req, res, boundary, content_type, + [&](const std::string &token) { strm.write(token); }, + [&](const std::string &token) { strm.write(token); }, + [&](size_t offset, size_t length) { + return write_content(strm, res.content_provider_, offset, length, + is_shutting_down); + }); +} + +inline std::pair +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 = static_cast(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" || req.method == "DELETE") { + return true; + } + // TODO: check if Content-Length is set + return false; +} + +inline bool has_crlf(const std::string &s) { + auto p = s.c_str(); + while (*p) { + if (*p == '\r' || *p == '\n') { return true; } + p++; + } + return false; +} + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +inline std::string message_digest(const std::string &s, const EVP_MD *algo) { + auto context = std::unique_ptr( + EVP_MD_CTX_new(), EVP_MD_CTX_free); + + unsigned int hash_length = 0; + unsigned char hash[EVP_MAX_MD_SIZE]; + + EVP_DigestInit_ex(context.get(), algo, nullptr); + EVP_DigestUpdate(context.get(), s.c_str(), s.size()); + EVP_DigestFinal_ex(context.get(), hash, &hash_length); + + std::stringstream ss; + for (auto i = 0u; i < hash_length; ++i) { + ss << std::hex << std::setw(2) << std::setfill('0') + << (unsigned int)hash[i]; + } + + return ss.str(); +} + +inline std::string MD5(const std::string &s) { + return message_digest(s, EVP_md5()); +} + +inline std::string SHA_256(const std::string &s) { + return message_digest(s, EVP_sha256()); +} + +inline std::string SHA_512(const std::string &s) { + return message_digest(s, EVP_sha512()); +} +#endif + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +#ifdef _WIN32 +// NOTE: This code came up with the following stackoverflow post: +// https://stackoverflow.com/questions/9507184/can-openssl-on-windows-use-the-system-certificate-store +inline bool load_system_certs_on_windows(X509_STORE *store) { + auto hStore = CertOpenSystemStoreW((HCRYPTPROV_LEGACY)NULL, L"ROOT"); + if (!hStore) { return false; } + + auto result = false; + PCCERT_CONTEXT pContext = NULL; + while ((pContext = CertEnumCertificatesInStore(hStore, pContext)) != + nullptr) { + auto encoded_cert = + static_cast(pContext->pbCertEncoded); + + auto x509 = d2i_X509(NULL, &encoded_cert, pContext->cbCertEncoded); + if (x509) { + X509_STORE_add_cert(store, x509); + X509_free(x509); + result = true; + } + } + + CertFreeCertificateContext(pContext); + CertCloseStore(hStore, 0); + + return result; +} +#elif defined(CPPHTTPLIB_USE_CERTS_FROM_MACOSX_KEYCHAIN) && defined(__APPLE__) +#if TARGET_OS_OSX +template +using CFObjectPtr = + std::unique_ptr::type, void (*)(CFTypeRef)>; + +inline void cf_object_ptr_deleter(CFTypeRef obj) { + if (obj) { CFRelease(obj); } +} + +inline bool retrieve_certs_from_keychain(CFObjectPtr &certs) { + CFStringRef keys[] = {kSecClass, kSecMatchLimit, kSecReturnRef}; + CFTypeRef values[] = {kSecClassCertificate, kSecMatchLimitAll, + kCFBooleanTrue}; + + CFObjectPtr query( + CFDictionaryCreate(nullptr, reinterpret_cast(keys), values, + sizeof(keys) / sizeof(keys[0]), + &kCFTypeDictionaryKeyCallBacks, + &kCFTypeDictionaryValueCallBacks), + cf_object_ptr_deleter); + + if (!query) { return false; } + + CFTypeRef security_items = nullptr; + if (SecItemCopyMatching(query.get(), &security_items) != errSecSuccess || + CFArrayGetTypeID() != CFGetTypeID(security_items)) { + return false; + } + + certs.reset(reinterpret_cast(security_items)); + return true; +} + +inline bool retrieve_root_certs_from_keychain(CFObjectPtr &certs) { + CFArrayRef root_security_items = nullptr; + if (SecTrustCopyAnchorCertificates(&root_security_items) != errSecSuccess) { + return false; + } + + certs.reset(root_security_items); + return true; +} + +inline bool add_certs_to_x509_store(CFArrayRef certs, X509_STORE *store) { + auto result = false; + for (int i = 0; i < CFArrayGetCount(certs); ++i) { + const auto cert = reinterpret_cast( + CFArrayGetValueAtIndex(certs, i)); + + if (SecCertificateGetTypeID() != CFGetTypeID(cert)) { continue; } + + CFDataRef cert_data = nullptr; + if (SecItemExport(cert, kSecFormatX509Cert, 0, nullptr, &cert_data) != + errSecSuccess) { + continue; + } + + CFObjectPtr cert_data_ptr(cert_data, cf_object_ptr_deleter); + + auto encoded_cert = static_cast( + CFDataGetBytePtr(cert_data_ptr.get())); + + auto x509 = + d2i_X509(NULL, &encoded_cert, CFDataGetLength(cert_data_ptr.get())); + + if (x509) { + X509_STORE_add_cert(store, x509); + X509_free(x509); + result = true; + } + } + + return result; +} + +inline bool load_system_certs_on_macos(X509_STORE *store) { + auto result = false; + CFObjectPtr certs(nullptr, cf_object_ptr_deleter); + if (retrieve_certs_from_keychain(certs) && certs) { + result = add_certs_to_x509_store(certs.get(), store); + } + + if (retrieve_root_certs_from_keychain(certs) && certs) { + result = add_certs_to_x509_store(certs.get(), store) || result; + } + + return result; +} +#endif // TARGET_OS_OSX +#endif // _WIN32 +#endif // CPPHTTPLIB_OPENSSL_SUPPORT + +#ifdef _WIN32 +class WSInit { +public: + WSInit() { + WSADATA wsaData; + if (WSAStartup(0x0002, &wsaData) == 0) is_valid_ = true; + } + + ~WSInit() { + if (is_valid_) WSACleanup(); + } + + bool is_valid_ = false; +}; + +static WSInit wsinit_; +#endif + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +inline std::pair make_digest_authentication_header( + const Request &req, const std::map &auth, + size_t cnonce_count, const std::string &cnonce, const std::string &username, + const std::string &password, bool is_proxy = false) { + std::string nc; + { + std::stringstream ss; + ss << std::setfill('0') << std::setw(8) << std::hex << cnonce_count; + nc = ss.str(); + } + + std::string qop; + if (auth.find("qop") != auth.end()) { + qop = auth.at("qop"); + if (qop.find("auth-int") != std::string::npos) { + qop = "auth-int"; + } else if (qop.find("auth") != std::string::npos) { + qop = "auth"; + } else { + qop.clear(); + } + } + + std::string algo = "MD5"; + if (auth.find("algorithm") != auth.end()) { algo = auth.at("algorithm"); } + + std::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); } + + if (qop.empty()) { + response = H(H(A1) + ":" + auth.at("nonce") + ":" + H(A2)); + } else { + response = H(H(A1) + ":" + auth.at("nonce") + ":" + nc + ":" + cnonce + + ":" + qop + ":" + H(A2)); + } + } + + auto opaque = (auth.find("opaque") != auth.end()) ? auth.at("opaque") : ""; + + auto field = "Digest username=\"" + username + "\", realm=\"" + + auth.at("realm") + "\", nonce=\"" + auth.at("nonce") + + "\", uri=\"" + req.path + "\", algorithm=" + algo + + (qop.empty() ? ", response=\"" + : ", qop=" + qop + ", nc=" + nc + ", cnonce=\"" + + cnonce + "\", response=\"") + + response + "\"" + + (opaque.empty() ? "" : ", opaque=\"" + opaque + "\""); + + auto key = is_proxy ? "Proxy-Authorization" : "Authorization"; + return std::make_pair(key, field); +} +#endif + +inline bool parse_www_authenticate(const Response &res, + std::map &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(static_cast(m.position(1)), + static_cast(m.length(1))); + auto val = m.length(2) > 0 + ? s.substr(static_cast(m.position(2)), + static_cast(m.length(2))) + : s.substr(static_cast(m.position(3)), + static_cast(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[static_cast(std::rand()) % max_index]; + }; + std::string str(length, 0); + std::generate_n(str.begin(), length, randchar); + return str; +} + +class ContentProviderAdapter { +public: + explicit ContentProviderAdapter( + ContentProviderWithoutLength &&content_provider) + : content_provider_(content_provider) {} + + bool operator()(size_t offset, size_t, DataSink &sink) { + return content_provider_(offset, sink); + } + +private: + ContentProviderWithoutLength content_provider_; +}; + +} // namespace detail + +inline std::string hosted_at(const std::string &hostname) { + std::vector addrs; + hosted_at(hostname, addrs); + if (addrs.empty()) { return std::string(); } + return addrs[0]; +} + +inline void hosted_at(const std::string &hostname, + std::vector &addrs) { + 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(hostname.c_str(), nullptr, &hints, &result)) { +#if defined __linux__ && !defined __ANDROID__ + res_init(); +#endif + return; + } + + for (auto rp = result; rp; rp = rp->ai_next) { + const auto &addr = + *reinterpret_cast(rp->ai_addr); + std::string ip; + int dummy = -1; + if (detail::get_ip_and_port(addr, sizeof(struct sockaddr_storage), ip, + dummy)) { + addrs.push_back(ip); + } + } + + freeaddrinfo(result); +} + +inline std::string append_query_params(const std::string &path, + const Params ¶ms) { + std::string path_with_query = path; + const static std::regex re("[^?]+\\?.*"); + auto delm = std::regex_match(path, re) ? '&' : '?'; + path_with_query += delm + detail::params_to_query_str(params); + return path_with_query; +} + +// Header utilities +inline std::pair make_range_header(Ranges ranges) { + std::string field = "bytes="; + auto i = 0; + for (auto r : ranges) { + if (i != 0) { field += ", "; } + if (r.first != -1) { field += std::to_string(r.first); } + field += '-'; + if (r.second != -1) { field += std::to_string(r.second); } + i++; + } + return std::make_pair("Range", std::move(field)); +} + +inline std::pair +make_basic_authentication_header(const std::string &username, + const std::string &password, bool is_proxy) { + auto field = "Basic " + detail::base64_encode(username + ":" + password); + auto key = is_proxy ? "Proxy-Authorization" : "Authorization"; + return std::make_pair(key, std::move(field)); +} + +inline std::pair +make_bearer_token_authentication_header(const std::string &token, + bool is_proxy = false) { + auto field = "Bearer " + token; + auto key = is_proxy ? "Proxy-Authorization" : "Authorization"; + return std::make_pair(key, std::move(field)); +} + +// Request implementation +inline bool Request::has_header(const std::string &key) const { + return detail::has_header(headers, key); +} + +inline std::string Request::get_header_value(const std::string &key, + size_t id) const { + return detail::get_header_value(headers, key, id, ""); +} + +inline size_t Request::get_header_value_count(const std::string &key) const { + auto r = headers.equal_range(key); + return static_cast(std::distance(r.first, r.second)); +} + +inline void Request::set_header(const std::string &key, + const std::string &val) { + if (!detail::has_crlf(key) && !detail::has_crlf(val)) { + headers.emplace(key, val); + } +} + +inline bool Request::has_param(const std::string &key) const { + return params.find(key) != params.end(); +} + +inline std::string Request::get_param_value(const std::string &key, + size_t id) const { + auto rng = params.equal_range(key); + auto it = rng.first; + std::advance(it, static_cast(id)); + if (it != rng.second) { return it->second; } + return std::string(); +} + +inline size_t Request::get_param_value_count(const std::string &key) const { + auto r = params.equal_range(key); + return static_cast(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.rfind("multipart/form-data", 0); +} + +inline bool Request::has_file(const std::string &key) const { + return files.find(key) != files.end(); +} + +inline MultipartFormData Request::get_file_value(const std::string &key) const { + auto it = files.find(key); + if (it != files.end()) { return it->second; } + return MultipartFormData(); +} + +inline std::vector +Request::get_file_values(const std::string &key) const { + std::vector values; + auto rng = files.equal_range(key); + for (auto it = rng.first; it != rng.second; it++) { + values.push_back(it->second); + } + return values; +} + +// Response implementation +inline bool Response::has_header(const std::string &key) const { + return headers.find(key) != headers.end(); +} + +inline std::string Response::get_header_value(const std::string &key, + size_t id) const { + return detail::get_header_value(headers, key, id, ""); +} + +inline size_t Response::get_header_value_count(const std::string &key) const { + auto r = headers.equal_range(key); + return static_cast(std::distance(r.first, r.second)); +} + +inline void Response::set_header(const std::string &key, + const std::string &val) { + if (!detail::has_crlf(key) && !detail::has_crlf(val)) { + headers.emplace(key, val); + } +} + +inline void Response::set_redirect(const std::string &url, int stat) { + if (!detail::has_crlf(url)) { + set_header("Location", url); + if (300 <= stat && stat < 400) { + this->status = stat; + } else { + this->status = 302; + } + } +} + +inline void Response::set_content(const char *s, size_t n, + const std::string &content_type) { + body.assign(s, n); + + auto rng = headers.equal_range("Content-Type"); + headers.erase(rng.first, rng.second); + set_header("Content-Type", content_type); +} + +inline void Response::set_content(const std::string &s, + const std::string &content_type) { + set_content(s.data(), s.size(), content_type); +} + +inline void Response::set_content_provider( + size_t in_length, const std::string &content_type, ContentProvider provider, + ContentProviderResourceReleaser resource_releaser) { + set_header("Content-Type", content_type); + content_length_ = in_length; + if (in_length > 0) { content_provider_ = std::move(provider); } + content_provider_resource_releaser_ = resource_releaser; + is_chunked_content_provider_ = false; +} + +inline void Response::set_content_provider( + const std::string &content_type, ContentProviderWithoutLength provider, + ContentProviderResourceReleaser resource_releaser) { + set_header("Content-Type", content_type); + content_length_ = 0; + content_provider_ = detail::ContentProviderAdapter(std::move(provider)); + content_provider_resource_releaser_ = resource_releaser; + is_chunked_content_provider_ = false; +} + +inline void Response::set_chunked_content_provider( + const std::string &content_type, ContentProviderWithoutLength provider, + ContentProviderResourceReleaser resource_releaser) { + set_header("Content-Type", content_type); + content_length_ = 0; + content_provider_ = detail::ContentProviderAdapter(std::move(provider)); + content_provider_resource_releaser_ = resource_releaser; + is_chunked_content_provider_ = true; +} + +// Result implementation +inline bool Result::has_request_header(const std::string &key) const { + return request_headers_.find(key) != request_headers_.end(); +} + +inline std::string Result::get_request_header_value(const std::string &key, + size_t id) const { + return detail::get_header_value(request_headers_, key, id, ""); +} + +inline size_t +Result::get_request_header_value_count(const std::string &key) const { + auto r = request_headers_.equal_range(key); + return static_cast(std::distance(r.first, r.second)); +} + +// Stream implementation +inline ssize_t Stream::write(const char *ptr) { + return write(ptr, strlen(ptr)); +} + +inline ssize_t Stream::write(const std::string &s) { + return write(s.data(), s.size()); +} + +namespace detail { + +// Socket stream implementation +inline SocketStream::SocketStream(socket_t sock, time_t read_timeout_sec, + time_t read_timeout_usec, + time_t write_timeout_sec, + time_t write_timeout_usec) + : sock_(sock), read_timeout_sec_(read_timeout_sec), + read_timeout_usec_(read_timeout_usec), + write_timeout_sec_(write_timeout_sec), + write_timeout_usec_(write_timeout_usec), read_buff_(read_buff_size_, 0) {} + +inline SocketStream::~SocketStream() {} + +inline bool SocketStream::is_readable() const { + return select_read(sock_, read_timeout_sec_, read_timeout_usec_) > 0; +} + +inline bool SocketStream::is_writable() const { + return select_write(sock_, write_timeout_sec_, write_timeout_usec_) > 0 && + is_socket_alive(sock_); +} + +inline ssize_t SocketStream::read(char *ptr, size_t size) { +#ifdef _WIN32 + size = + (std::min)(size, static_cast((std::numeric_limits::max)())); +#else + size = (std::min)(size, + static_cast((std::numeric_limits::max)())); +#endif + + if (read_buff_off_ < read_buff_content_size_) { + auto remaining_size = read_buff_content_size_ - read_buff_off_; + if (size <= remaining_size) { + memcpy(ptr, read_buff_.data() + read_buff_off_, size); + read_buff_off_ += size; + return static_cast(size); + } else { + memcpy(ptr, read_buff_.data() + read_buff_off_, remaining_size); + read_buff_off_ += remaining_size; + return static_cast(remaining_size); + } + } + + if (!is_readable()) { return -1; } + + read_buff_off_ = 0; + read_buff_content_size_ = 0; + + if (size < read_buff_size_) { + auto n = read_socket(sock_, read_buff_.data(), read_buff_size_, + CPPHTTPLIB_RECV_FLAGS); + if (n <= 0) { + return n; + } else if (n <= static_cast(size)) { + memcpy(ptr, read_buff_.data(), static_cast(n)); + return n; + } else { + memcpy(ptr, read_buff_.data(), size); + read_buff_off_ = size; + read_buff_content_size_ = static_cast(n); + return static_cast(size); + } + } else { + return read_socket(sock_, ptr, size, CPPHTTPLIB_RECV_FLAGS); + } +} + +inline ssize_t SocketStream::write(const char *ptr, size_t size) { + if (!is_writable()) { return -1; } + +#if defined(_WIN32) && !defined(_WIN64) + size = + (std::min)(size, static_cast((std::numeric_limits::max)())); +#endif + + return send_socket(sock_, ptr, size, CPPHTTPLIB_SEND_FLAGS); +} + +inline void SocketStream::get_remote_ip_and_port(std::string &ip, + int &port) const { + return detail::get_remote_ip_and_port(sock_, ip, port); +} + +inline void SocketStream::get_local_ip_and_port(std::string &ip, + int &port) const { + return detail::get_local_ip_and_port(sock_, ip, port); +} + +inline socket_t SocketStream::socket() const { return sock_; } + +// Buffer stream implementation +inline bool BufferStream::is_readable() const { return true; } + +inline bool BufferStream::is_writable() const { return true; } + +inline ssize_t BufferStream::read(char *ptr, size_t size) { +#if defined(_MSC_VER) && _MSC_VER < 1910 + auto len_read = buffer._Copy_s(ptr, size, size, position); +#else + auto len_read = buffer.copy(ptr, size, position); +#endif + position += static_cast(len_read); + return static_cast(len_read); +} + +inline ssize_t BufferStream::write(const char *ptr, size_t size) { + buffer.append(ptr, size); + return static_cast(size); +} + +inline void BufferStream::get_remote_ip_and_port(std::string & /*ip*/, + int & /*port*/) const {} + +inline void BufferStream::get_local_ip_and_port(std::string & /*ip*/, + int & /*port*/) const {} + +inline socket_t BufferStream::socket() const { return 0; } + +inline const std::string &BufferStream::get_buffer() const { return buffer; } + +} // namespace detail + +// HTTP server implementation +inline Server::Server() + : new_task_queue( + [] { return new ThreadPool(CPPHTTPLIB_THREAD_POOL_COUNT); }) { +#ifndef _WIN32 + signal(SIGPIPE, SIG_IGN); +#endif +} + +inline Server::~Server() {} + +inline Server &Server::Get(const std::string &pattern, Handler handler) { + get_handlers_.push_back( + std::make_pair(std::regex(pattern), std::move(handler))); + return *this; +} + +inline Server &Server::Post(const std::string &pattern, Handler handler) { + post_handlers_.push_back( + std::make_pair(std::regex(pattern), std::move(handler))); + return *this; +} + +inline Server &Server::Post(const std::string &pattern, + HandlerWithContentReader handler) { + post_handlers_for_content_reader_.push_back( + std::make_pair(std::regex(pattern), std::move(handler))); + return *this; +} + +inline Server &Server::Put(const std::string &pattern, Handler handler) { + put_handlers_.push_back( + std::make_pair(std::regex(pattern), std::move(handler))); + return *this; +} + +inline Server &Server::Put(const std::string &pattern, + HandlerWithContentReader handler) { + put_handlers_for_content_reader_.push_back( + std::make_pair(std::regex(pattern), std::move(handler))); + return *this; +} + +inline Server &Server::Patch(const std::string &pattern, Handler handler) { + patch_handlers_.push_back( + std::make_pair(std::regex(pattern), std::move(handler))); + return *this; +} + +inline Server &Server::Patch(const std::string &pattern, + HandlerWithContentReader handler) { + patch_handlers_for_content_reader_.push_back( + std::make_pair(std::regex(pattern), std::move(handler))); + return *this; +} + +inline Server &Server::Delete(const std::string &pattern, Handler handler) { + delete_handlers_.push_back( + std::make_pair(std::regex(pattern), std::move(handler))); + return *this; +} + +inline Server &Server::Delete(const std::string &pattern, + HandlerWithContentReader handler) { + delete_handlers_for_content_reader_.push_back( + std::make_pair(std::regex(pattern), std::move(handler))); + return *this; +} + +inline Server &Server::Options(const std::string &pattern, Handler handler) { + options_handlers_.push_back( + std::make_pair(std::regex(pattern), std::move(handler))); + return *this; +} + +inline bool Server::set_base_dir(const std::string &dir, + const std::string &mount_point) { + return set_mount_point(mount_point, dir); +} + +inline bool Server::set_mount_point(const std::string &mount_point, + const std::string &dir, Headers headers) { + if (detail::is_dir(dir)) { + std::string mnt = !mount_point.empty() ? mount_point : "/"; + if (!mnt.empty() && mnt[0] == '/') { + base_dirs_.push_back({mnt, dir, std::move(headers)}); + return true; + } + } + return false; +} + +inline bool Server::remove_mount_point(const std::string &mount_point) { + for (auto it = base_dirs_.begin(); it != base_dirs_.end(); ++it) { + if (it->mount_point == mount_point) { + base_dirs_.erase(it); + return true; + } + } + return false; +} + +inline Server & +Server::set_file_extension_and_mimetype_mapping(const std::string &ext, + const std::string &mime) { + file_extension_and_mimetype_map_[ext] = mime; + return *this; +} + +inline Server &Server::set_file_request_handler(Handler handler) { + file_request_handler_ = std::move(handler); + return *this; +} + +inline Server &Server::set_error_handler(HandlerWithResponse handler) { + error_handler_ = std::move(handler); + return *this; +} + +inline Server &Server::set_error_handler(Handler handler) { + error_handler_ = [handler](const Request &req, Response &res) { + handler(req, res); + return HandlerResponse::Handled; + }; + return *this; +} + +inline Server &Server::set_exception_handler(ExceptionHandler handler) { + exception_handler_ = std::move(handler); + return *this; +} + +inline Server &Server::set_pre_routing_handler(HandlerWithResponse handler) { + pre_routing_handler_ = std::move(handler); + return *this; +} + +inline Server &Server::set_post_routing_handler(Handler handler) { + post_routing_handler_ = std::move(handler); + return *this; +} + +inline Server &Server::set_logger(Logger logger) { + logger_ = std::move(logger); + return *this; +} + +inline Server & +Server::set_expect_100_continue_handler(Expect100ContinueHandler handler) { + expect_100_continue_handler_ = std::move(handler); + + return *this; +} + +inline Server &Server::set_address_family(int family) { + address_family_ = family; + return *this; +} + +inline Server &Server::set_tcp_nodelay(bool on) { + tcp_nodelay_ = on; + return *this; +} + +inline Server &Server::set_socket_options(SocketOptions socket_options) { + socket_options_ = std::move(socket_options); + return *this; +} + +inline Server &Server::set_default_headers(Headers headers) { + default_headers_ = std::move(headers); + return *this; +} + +inline Server &Server::set_keep_alive_max_count(size_t count) { + keep_alive_max_count_ = count; + return *this; +} + +inline Server &Server::set_keep_alive_timeout(time_t sec) { + keep_alive_timeout_sec_ = sec; + return *this; +} + +inline Server &Server::set_read_timeout(time_t sec, time_t usec) { + read_timeout_sec_ = sec; + read_timeout_usec_ = usec; + return *this; +} + +inline Server &Server::set_write_timeout(time_t sec, time_t usec) { + write_timeout_sec_ = sec; + write_timeout_usec_ = usec; + return *this; +} + +inline Server &Server::set_idle_interval(time_t sec, time_t usec) { + idle_interval_sec_ = sec; + idle_interval_usec_ = usec; + return *this; +} + +inline Server &Server::set_payload_max_length(size_t length) { + payload_max_length_ = length; + return *this; +} + +inline bool Server::bind_to_port(const std::string &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 std::string &host, int socket_flags) { + return bind_internal(host, 0, socket_flags); +} + +inline bool Server::listen_after_bind() { + auto se = detail::scope_exit([&]() { done_ = true; }); + return listen_internal(); +} + +inline bool Server::listen(const std::string &host, int port, + int socket_flags) { + auto se = detail::scope_exit([&]() { done_ = true; }); + return bind_to_port(host, port, socket_flags) && listen_internal(); +} + +inline bool Server::is_running() const { return is_running_; } + +inline void Server::wait_until_ready() const { + while (!is_running() && !done_) { + std::this_thread::sleep_for(std::chrono::milliseconds{1}); + } +} + +inline void Server::stop() { + if (is_running_) { + assert(svr_sock_ != INVALID_SOCKET); + std::atomic sock(svr_sock_.exchange(INVALID_SOCKET)); + detail::shutdown_socket(sock); + detail::close_socket(sock); + } +} + +inline bool Server::parse_request_line(const char *s, Request &req) { + auto len = strlen(s); + if (len < 2 || s[len - 2] != '\r' || s[len - 1] != '\n') { return false; } + len -= 2; + + { + size_t count = 0; + + detail::split(s, s + len, ' ', [&](const char *b, const char *e) { + switch (count) { + case 0: req.method = std::string(b, e); break; + case 1: req.target = std::string(b, e); break; + case 2: req.version = std::string(b, e); break; + default: break; + } + count++; + }); + + if (count != 3) { return false; } + } + + static const std::set methods{ + "GET", "HEAD", "POST", "PUT", "DELETE", + "CONNECT", "OPTIONS", "TRACE", "PATCH", "PRI"}; + + if (methods.find(req.method) == methods.end()) { return false; } + + if (req.version != "HTTP/1.1" && req.version != "HTTP/1.0") { return false; } + + { + // Skip URL fragment + for (size_t i = 0; i < req.target.size(); i++) { + if (req.target[i] == '#') { + req.target.erase(i); + break; + } + } + + size_t count = 0; + + detail::split(req.target.data(), req.target.data() + req.target.size(), '?', + [&](const char *b, const char *e) { + switch (count) { + case 0: + req.path = detail::decode_url(std::string(b, e), false); + break; + case 1: { + if (e - b > 0) { + detail::parse_query_text(std::string(b, e), req.params); + } + break; + } + default: break; + } + count++; + }); + + if (count > 2) { return false; } + } + + return true; +} + +inline bool Server::write_response(Stream &strm, bool close_connection, + const Request &req, Response &res) { + return write_response_core(strm, close_connection, req, res, false); +} + +inline bool Server::write_response_with_content(Stream &strm, + bool close_connection, + const Request &req, + Response &res) { + return write_response_core(strm, close_connection, req, res, true); +} + +inline bool Server::write_response_core(Stream &strm, bool close_connection, + const Request &req, Response &res, + bool need_apply_ranges) { + assert(res.status != -1); + + if (400 <= res.status && error_handler_ && + error_handler_(req, res) == HandlerResponse::Handled) { + need_apply_ranges = true; + } + + std::string content_type; + std::string boundary; + if (need_apply_ranges) { apply_ranges(req, res, content_type, boundary); } + + // Prepare additional headers + if (close_connection || req.get_header_value("Connection") == "close") { + res.set_header("Connection", "close"); + } else { + std::stringstream ss; + ss << "timeout=" << keep_alive_timeout_sec_ + << ", max=" << keep_alive_max_count_; + res.set_header("Keep-Alive", ss.str()); + } + + if (!res.has_header("Content-Type") && + (!res.body.empty() || res.content_length_ > 0 || res.content_provider_)) { + res.set_header("Content-Type", "text/plain"); + } + + if (!res.has_header("Content-Length") && res.body.empty() && + !res.content_length_ && !res.content_provider_) { + res.set_header("Content-Length", "0"); + } + + if (!res.has_header("Accept-Ranges") && req.method == "HEAD") { + res.set_header("Accept-Ranges", "bytes"); + } + + if (post_routing_handler_) { post_routing_handler_(req, res); } + + // Response line and headers + { + detail::BufferStream bstrm; + + if (!bstrm.write_format("HTTP/1.1 %d %s\r\n", res.status, + detail::status_message(res.status))) { + return false; + } + + if (!detail::write_headers(bstrm, res.headers)) { return false; } + + // Flush buffer + auto &data = bstrm.get_buffer(); + detail::write_data(strm, data.data(), data.size()); + } + + // Body + auto ret = true; + if (req.method != "HEAD") { + if (!res.body.empty()) { + if (!detail::write_data(strm, res.body.data(), res.body.size())) { + ret = false; + } + } else if (res.content_provider_) { + if (write_content_with_provider(strm, req, res, boundary, content_type)) { + res.content_provider_success_ = true; + } else { + res.content_provider_success_ = false; + ret = false; + } + } + } + + // Log + if (logger_) { logger_(req, res); } + + return ret; +} + +inline bool +Server::write_content_with_provider(Stream &strm, const Request &req, + Response &res, const std::string &boundary, + const std::string &content_type) { + auto is_shutting_down = [this]() { + return this->svr_sock_ == INVALID_SOCKET; + }; + + if (res.content_length_ > 0) { + if (req.ranges.empty()) { + return detail::write_content(strm, res.content_provider_, 0, + res.content_length_, is_shutting_down); + } else if (req.ranges.size() == 1) { + auto offsets = + detail::get_range_offset_and_length(req, res.content_length_, 0); + auto offset = offsets.first; + auto length = offsets.second; + return detail::write_content(strm, res.content_provider_, offset, length, + is_shutting_down); + } else { + return detail::write_multipart_ranges_data( + strm, req, res, boundary, content_type, is_shutting_down); + } + } else { + if (res.is_chunked_content_provider_) { + auto type = detail::encoding_type(req, res); + + std::unique_ptr compressor; + if (type == detail::EncodingType::Gzip) { +#ifdef CPPHTTPLIB_ZLIB_SUPPORT + compressor = detail::make_unique(); +#endif + } else if (type == detail::EncodingType::Brotli) { +#ifdef CPPHTTPLIB_BROTLI_SUPPORT + compressor = detail::make_unique(); +#endif + } else { + compressor = detail::make_unique(); + } + assert(compressor != nullptr); + + return detail::write_content_chunked(strm, res.content_provider_, + is_shutting_down, *compressor); + } else { + return detail::write_content_without_length(strm, res.content_provider_, + is_shutting_down); + } + } +} + +inline bool Server::read_content(Stream &strm, Request &req, Response &res) { + MultipartFormDataMap::iterator cur; + auto file_count = 0; + if (read_content_core( + strm, 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) { + if (file_count++ == CPPHTTPLIB_MULTIPART_FORM_DATA_FILE_MAX_COUNT) { + return false; + } + 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; + })) { + const auto &content_type = req.get_header_value("Content-Type"); + if (!content_type.find("application/x-www-form-urlencoded")) { + if (req.body.size() > CPPHTTPLIB_FORM_URL_ENCODED_PAYLOAD_MAX_LENGTH) { + res.status = 413; // NOTE: should be 414? + return false; + } + detail::parse_query_text(req.body, req.params); + } + return true; + } + return false; +} + +inline bool Server::read_content_with_content_receiver( + Stream &strm, Request &req, Response &res, ContentReceiver receiver, + MultipartContentHeader multipart_header, + ContentReceiver multipart_receiver) { + return read_content_core(strm, req, res, std::move(receiver), + std::move(multipart_header), + std::move(multipart_receiver)); +} + +inline bool Server::read_content_core(Stream &strm, Request &req, Response &res, + ContentReceiver receiver, + MultipartContentHeader multipart_header, + ContentReceiver multipart_receiver) { + detail::MultipartFormDataParser multipart_form_data_parser; + ContentReceiverWithProgress 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 false; + } + + multipart_form_data_parser.set_boundary(std::move(boundary)); + out = [&](const char *buf, size_t n, uint64_t /*off*/, uint64_t /*len*/) { + /* For debug + size_t pos = 0; + while (pos < n) { + auto read_size = (std::min)(1, n - pos); + auto ret = multipart_form_data_parser.parse( + buf + pos, read_size, multipart_receiver, multipart_header); + if (!ret) { return false; } + pos += read_size; + } + return true; + */ + return multipart_form_data_parser.parse(buf, n, multipart_receiver, + multipart_header); + }; + } else { + out = [receiver](const char *buf, size_t n, uint64_t /*off*/, + uint64_t /*len*/) { return receiver(buf, n); }; + } + + if (req.method == "DELETE" && !req.has_header("Content-Length")) { + return true; + } + + if (!detail::read_content(strm, req, payload_max_length_, res.status, nullptr, + out, true)) { + return false; + } + + if (req.is_multipart_form_data()) { + if (!multipart_form_data_parser.is_valid()) { + res.status = 400; + return false; + } + } + + return true; +} + +inline bool Server::handle_file_request(const Request &req, Response &res, + bool head) { + for (const auto &entry : base_dirs_) { + // Prefix match + if (!req.path.compare(0, entry.mount_point.size(), entry.mount_point)) { + std::string sub_path = "/" + req.path.substr(entry.mount_point.size()); + if (detail::is_valid_path(sub_path)) { + auto path = entry.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); } + for (const auto &kv : entry.headers) { + res.set_header(kv.first.c_str(), kv.second); + } + res.status = req.has_header("Range") ? 206 : 200; + if (!head && file_request_handler_) { + file_request_handler_(req, res); + } + return true; + } + } + } + } + return false; +} + +inline socket_t +Server::create_server_socket(const std::string &host, int port, + int socket_flags, + SocketOptions socket_options) const { + return detail::create_socket( + host, std::string(), port, address_family_, socket_flags, tcp_nodelay_, + std::move(socket_options), + [](socket_t sock, struct addrinfo &ai) -> bool { + if (::bind(sock, ai.ai_addr, static_cast(ai.ai_addrlen))) { + return false; + } + if (::listen(sock, CPPHTTPLIB_LISTEN_BACKLOG)) { return false; } + return true; + }); +} + +inline int Server::bind_internal(const std::string &host, int port, + int socket_flags) { + if (!is_valid()) { return -1; } + + svr_sock_ = create_server_socket(host, port, socket_flags, socket_options_); + if (svr_sock_ == INVALID_SOCKET) { return -1; } + + if (port == 0) { + struct sockaddr_storage addr; + socklen_t addr_len = sizeof(addr); + if (getsockname(svr_sock_, reinterpret_cast(&addr), + &addr_len) == -1) { + return -1; + } + if (addr.ss_family == AF_INET) { + return ntohs(reinterpret_cast(&addr)->sin_port); + } else if (addr.ss_family == AF_INET6) { + return ntohs(reinterpret_cast(&addr)->sin6_port); + } else { + return -1; + } + } else { + return port; + } +} + +inline bool Server::listen_internal() { + auto ret = true; + is_running_ = true; + auto se = detail::scope_exit([&]() { is_running_ = false; }); + + { + std::unique_ptr task_queue(new_task_queue()); + + while (svr_sock_ != INVALID_SOCKET) { +#ifndef _WIN32 + if (idle_interval_sec_ > 0 || idle_interval_usec_ > 0) { +#endif + auto val = detail::select_read(svr_sock_, idle_interval_sec_, + idle_interval_usec_); + if (val == 0) { // Timeout + task_queue->on_idle(); + continue; + } +#ifndef _WIN32 + } +#endif + socket_t sock = accept(svr_sock_, nullptr, nullptr); + + if (sock == INVALID_SOCKET) { + if (errno == EMFILE) { + // The per-process limit of open file descriptors has been reached. + // Try to accept new connections after a short sleep. + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + continue; + } else if (errno == EINTR || errno == EAGAIN) { + continue; + } + if (svr_sock_ != INVALID_SOCKET) { + detail::close_socket(svr_sock_); + ret = false; + } else { + ; // The server socket was closed by user. + } + break; + } + + { +#ifdef _WIN32 + auto timeout = static_cast(read_timeout_sec_ * 1000 + + read_timeout_usec_ / 1000); + setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, + sizeof(timeout)); +#else + timeval tv; + tv.tv_sec = static_cast(read_timeout_sec_); + tv.tv_usec = static_cast(read_timeout_usec_); + setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv)); +#endif + } + { + +#ifdef _WIN32 + auto timeout = static_cast(write_timeout_sec_ * 1000 + + write_timeout_usec_ / 1000); + setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout, + sizeof(timeout)); +#else + timeval tv; + tv.tv_sec = static_cast(write_timeout_sec_); + tv.tv_usec = static_cast(write_timeout_usec_); + setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (char *)&tv, sizeof(tv)); +#endif + } + + task_queue->enqueue([this, sock]() { process_and_close_socket(sock); }); + } + + task_queue->shutdown(); + } + + return ret; +} + +inline bool Server::routing(Request &req, Response &res, Stream &strm) { + if (pre_routing_handler_ && + pre_routing_handler_(req, res) == HandlerResponse::Handled) { + return true; + } + + // 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, req, res, std::move(receiver), nullptr, nullptr); + }, + [&](MultipartContentHeader header, ContentReceiver receiver) { + return read_content_with_content_receiver(strm, req, res, nullptr, + std::move(header), + std::move(receiver)); + }); + + if (req.method == "POST") { + if (dispatch_request_for_content_reader( + req, res, std::move(reader), + post_handlers_for_content_reader_)) { + return true; + } + } else if (req.method == "PUT") { + if (dispatch_request_for_content_reader( + req, res, std::move(reader), + put_handlers_for_content_reader_)) { + return true; + } + } else if (req.method == "PATCH") { + if (dispatch_request_for_content_reader( + req, res, std::move(reader), + patch_handlers_for_content_reader_)) { + return true; + } + } else if (req.method == "DELETE") { + if (dispatch_request_for_content_reader( + req, res, std::move(reader), + delete_handlers_for_content_reader_)) { + return true; + } + } + } + + // Read content into `req.body` + if (!read_content(strm, 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") { + return dispatch_request(req, res, post_handlers_); + } else if (req.method == "PUT") { + return dispatch_request(req, res, put_handlers_); + } else if (req.method == "DELETE") { + return dispatch_request(req, res, delete_handlers_); + } else if (req.method == "OPTIONS") { + return dispatch_request(req, res, options_handlers_); + } else if (req.method == "PATCH") { + return dispatch_request(req, res, patch_handlers_); + } + + res.status = 400; + return false; +} + +inline bool Server::dispatch_request(Request &req, Response &res, + const Handlers &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); + return true; + } + } + return false; +} + +inline void Server::apply_ranges(const Request &req, Response &res, + std::string &content_type, + std::string &boundary) { + if (req.ranges.size() > 1) { + boundary = detail::make_multipart_data_boundary(); + + auto it = res.headers.find("Content-Type"); + if (it != res.headers.end()) { + content_type = it->second; + res.headers.erase(it); + } + + res.headers.emplace("Content-Type", + "multipart/byteranges; boundary=" + boundary); + } + + auto type = detail::encoding_type(req, res); + + if (res.body.empty()) { + if (res.content_length_ > 0) { + size_t length = 0; + if (req.ranges.empty()) { + length = res.content_length_; + } else if (req.ranges.size() == 1) { + 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_length_); + res.set_header("Content-Range", content_range); + } else { + length = detail::get_multipart_ranges_data_length(req, res, boundary, + content_type); + } + res.set_header("Content-Length", std::to_string(length)); + } else { + if (res.content_provider_) { + if (res.is_chunked_content_provider_) { + res.set_header("Transfer-Encoding", "chunked"); + if (type == detail::EncodingType::Gzip) { + res.set_header("Content-Encoding", "gzip"); + } else if (type == detail::EncodingType::Brotli) { + res.set_header("Content-Encoding", "br"); + } + } + } + } + } else { + if (req.ranges.empty()) { + ; + } else if (req.ranges.size() == 1) { + auto offsets = + detail::get_range_offset_and_length(req, res.body.size(), 0); + auto offset = offsets.first; + auto length = offsets.second; + auto content_range = detail::make_content_range_header_field( + offset, length, res.body.size()); + res.set_header("Content-Range", content_range); + if (offset < res.body.size()) { + res.body = res.body.substr(offset, length); + } else { + res.body.clear(); + res.status = 416; + } + } else { + std::string data; + if (detail::make_multipart_ranges_data(req, res, boundary, content_type, + data)) { + res.body.swap(data); + } else { + res.body.clear(); + res.status = 416; + } + } + + if (type != detail::EncodingType::None) { + std::unique_ptr compressor; + std::string content_encoding; + + if (type == detail::EncodingType::Gzip) { +#ifdef CPPHTTPLIB_ZLIB_SUPPORT + compressor = detail::make_unique(); + content_encoding = "gzip"; +#endif + } else if (type == detail::EncodingType::Brotli) { +#ifdef CPPHTTPLIB_BROTLI_SUPPORT + compressor = detail::make_unique(); + content_encoding = "br"; +#endif + } + + if (compressor) { + std::string compressed; + if (compressor->compress(res.body.data(), res.body.size(), true, + [&](const char *data, size_t data_len) { + compressed.append(data, data_len); + return true; + })) { + res.body.swap(compressed); + res.set_header("Content-Encoding", content_encoding); + } + } + } + + auto length = std::to_string(res.body.size()); + res.set_header("Content-Length", length); + } +} + +inline bool Server::dispatch_request_for_content_reader( + Request &req, Response &res, ContentReader content_reader, + const 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 close_connection, + bool &connection_closed, + const std::function &setup_request) { + std::array buf{}; + + detail::stream_line_reader line_reader(strm, buf.data(), buf.size()); + + // Connection has been closed on client + if (!line_reader.getline()) { return false; } + + Request req; + Response res; + + res.version = "HTTP/1.1"; + + for (const auto &header : default_headers_) { + if (res.headers.find(header.first) == res.headers.end()) { + res.headers.insert(header); + } + } + +#ifdef _WIN32 + // TODO: Increase FD_SETSIZE statically (libzmq), dynamically (MySQL). +#else +#ifndef CPPHTTPLIB_USE_POLL + // Socket file descriptor exceeded FD_SETSIZE... + if (strm.socket() >= FD_SETSIZE) { + Headers dummy; + detail::read_headers(strm, dummy); + res.status = 500; + return write_response(strm, close_connection, req, res); + } +#endif +#endif + + // Check if the request URI doesn't exceed the limit + if (line_reader.size() > CPPHTTPLIB_REQUEST_URI_MAX_LENGTH) { + Headers dummy; + detail::read_headers(strm, dummy); + res.status = 414; + return write_response(strm, close_connection, req, res); + } + + // Request line and headers + if (!parse_request_line(line_reader.ptr(), req) || + !detail::read_headers(strm, req.headers)) { + res.status = 400; + return write_response(strm, close_connection, req, res); + } + + if (req.get_header_value("Connection") == "close") { + connection_closed = true; + } + + if (req.version == "HTTP/1.0" && + req.get_header_value("Connection") != "Keep-Alive") { + connection_closed = true; + } + + strm.get_remote_ip_and_port(req.remote_addr, req.remote_port); + req.set_header("REMOTE_ADDR", req.remote_addr); + req.set_header("REMOTE_PORT", std::to_string(req.remote_port)); + + strm.get_local_ip_and_port(req.local_addr, req.local_port); + req.set_header("LOCAL_ADDR", req.local_addr); + req.set_header("LOCAL_PORT", std::to_string(req.local_port)); + + 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)) { + res.status = 416; + return write_response(strm, close_connection, req, res); + } + } + + if (setup_request) { setup_request(req); } + + 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, close_connection, req, res); + } + } + + // Rounting + bool routed = false; +#ifdef CPPHTTPLIB_NO_EXCEPTIONS + routed = routing(req, res, strm); +#else + try { + routed = routing(req, res, strm); + } catch (std::exception &e) { + if (exception_handler_) { + auto ep = std::current_exception(); + exception_handler_(req, res, ep); + routed = true; + } else { + res.status = 500; + std::string val; + auto s = e.what(); + for (size_t i = 0; s[i]; i++) { + switch (s[i]) { + case '\r': val += "\\r"; break; + case '\n': val += "\\n"; break; + default: val += s[i]; break; + } + } + res.set_header("EXCEPTION_WHAT", val); + } + } catch (...) { + if (exception_handler_) { + auto ep = std::current_exception(); + exception_handler_(req, res, ep); + routed = true; + } else { + res.status = 500; + res.set_header("EXCEPTION_WHAT", "UNKNOWN"); + } + } +#endif + + if (routed) { + if (res.status == -1) { res.status = req.ranges.empty() ? 200 : 206; } + return write_response_with_content(strm, close_connection, req, res); + } else { + if (res.status == -1) { res.status = 404; } + return write_response(strm, close_connection, req, res); + } +} + +inline bool Server::is_valid() const { return true; } + +inline bool Server::process_and_close_socket(socket_t sock) { + auto ret = detail::process_server_socket( + svr_sock_, sock, keep_alive_max_count_, keep_alive_timeout_sec_, + read_timeout_sec_, read_timeout_usec_, write_timeout_sec_, + write_timeout_usec_, + [this](Stream &strm, bool close_connection, bool &connection_closed) { + return process_request(strm, close_connection, connection_closed, + nullptr); + }); + + detail::shutdown_socket(sock); + detail::close_socket(sock); + return ret; +} + +// HTTP client implementation +inline ClientImpl::ClientImpl(const std::string &host) + : ClientImpl(host, 80, std::string(), std::string()) {} + +inline ClientImpl::ClientImpl(const std::string &host, int port) + : ClientImpl(host, port, std::string(), std::string()) {} + +inline ClientImpl::ClientImpl(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_(adjust_host_string(host) + ":" + std::to_string(port)), + client_cert_path_(client_cert_path), client_key_path_(client_key_path) {} + +inline ClientImpl::~ClientImpl() { + std::lock_guard guard(socket_mutex_); + shutdown_socket(socket_); + close_socket(socket_); +} + +inline bool ClientImpl::is_valid() const { return true; } + +inline void ClientImpl::copy_settings(const ClientImpl &rhs) { + client_cert_path_ = rhs.client_cert_path_; + client_key_path_ = rhs.client_key_path_; + connection_timeout_sec_ = rhs.connection_timeout_sec_; + read_timeout_sec_ = rhs.read_timeout_sec_; + read_timeout_usec_ = rhs.read_timeout_usec_; + write_timeout_sec_ = rhs.write_timeout_sec_; + write_timeout_usec_ = rhs.write_timeout_usec_; + basic_auth_username_ = rhs.basic_auth_username_; + basic_auth_password_ = rhs.basic_auth_password_; + bearer_token_auth_token_ = rhs.bearer_token_auth_token_; +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + digest_auth_username_ = rhs.digest_auth_username_; + digest_auth_password_ = rhs.digest_auth_password_; +#endif + keep_alive_ = rhs.keep_alive_; + follow_location_ = rhs.follow_location_; + url_encode_ = rhs.url_encode_; + address_family_ = rhs.address_family_; + tcp_nodelay_ = rhs.tcp_nodelay_; + socket_options_ = rhs.socket_options_; + compress_ = rhs.compress_; + decompress_ = rhs.decompress_; + 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_; + proxy_bearer_token_auth_token_ = rhs.proxy_bearer_token_auth_token_; +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + proxy_digest_auth_username_ = rhs.proxy_digest_auth_username_; + proxy_digest_auth_password_ = rhs.proxy_digest_auth_password_; +#endif +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + ca_cert_file_path_ = rhs.ca_cert_file_path_; + ca_cert_dir_path_ = rhs.ca_cert_dir_path_; + ca_cert_store_ = rhs.ca_cert_store_; +#endif +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + server_certificate_verification_ = rhs.server_certificate_verification_; +#endif + logger_ = rhs.logger_; +} + +inline socket_t ClientImpl::create_client_socket(Error &error) const { + if (!proxy_host_.empty() && proxy_port_ != -1) { + return detail::create_client_socket( + proxy_host_, std::string(), proxy_port_, address_family_, tcp_nodelay_, + socket_options_, connection_timeout_sec_, connection_timeout_usec_, + read_timeout_sec_, read_timeout_usec_, write_timeout_sec_, + write_timeout_usec_, interface_, error); + } + + // Check is custom IP specified for host_ + std::string ip; + auto it = addr_map_.find(host_); + if (it != addr_map_.end()) ip = it->second; + + return detail::create_client_socket( + host_, ip, port_, address_family_, tcp_nodelay_, socket_options_, + connection_timeout_sec_, connection_timeout_usec_, read_timeout_sec_, + read_timeout_usec_, write_timeout_sec_, write_timeout_usec_, interface_, + error); +} + +inline bool ClientImpl::create_and_connect_socket(Socket &socket, + Error &error) { + auto sock = create_client_socket(error); + if (sock == INVALID_SOCKET) { return false; } + socket.sock = sock; + return true; +} + +inline void ClientImpl::shutdown_ssl(Socket & /*socket*/, + bool /*shutdown_gracefully*/) { + // If there are any requests in flight from threads other than us, then it's + // a thread-unsafe race because individual ssl* objects are not thread-safe. + assert(socket_requests_in_flight_ == 0 || + socket_requests_are_from_thread_ == std::this_thread::get_id()); +} + +inline void ClientImpl::shutdown_socket(Socket &socket) { + if (socket.sock == INVALID_SOCKET) { return; } + detail::shutdown_socket(socket.sock); +} + +inline void ClientImpl::close_socket(Socket &socket) { + // If there are requests in flight in another thread, usually closing + // the socket will be fine and they will simply receive an error when + // using the closed socket, but it is still a bug since rarely the OS + // may reassign the socket id to be used for a new socket, and then + // suddenly they will be operating on a live socket that is different + // than the one they intended! + assert(socket_requests_in_flight_ == 0 || + socket_requests_are_from_thread_ == std::this_thread::get_id()); + + // It is also a bug if this happens while SSL is still active +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + assert(socket.ssl == nullptr); +#endif + if (socket.sock == INVALID_SOCKET) { return; } + detail::close_socket(socket.sock); + socket.sock = INVALID_SOCKET; +} + +inline bool ClientImpl::read_response_line(Stream &strm, const Request &req, + Response &res) { + std::array buf{}; + + detail::stream_line_reader line_reader(strm, buf.data(), buf.size()); + + if (!line_reader.getline()) { return false; } + +#ifdef CPPHTTPLIB_ALLOW_LF_AS_LINE_TERMINATOR + const static std::regex re("(HTTP/1\\.[01]) (\\d{3})(?: (.*?))?\r\n"); +#else + const static std::regex re("(HTTP/1\\.[01]) (\\d{3})(?: (.*?))?\r?\n"); +#endif + + std::cmatch m; + if (!std::regex_match(line_reader.ptr(), m, re)) { + return req.method == "CONNECT"; + } + res.version = std::string(m[1]); + res.status = std::stoi(std::string(m[2])); + res.reason = std::string(m[3]); + + // Ignore '100 Continue' + while (res.status == 100) { + if (!line_reader.getline()) { return false; } // CRLF + if (!line_reader.getline()) { return false; } // next response line + + if (!std::regex_match(line_reader.ptr(), m, re)) { return false; } + res.version = std::string(m[1]); + res.status = std::stoi(std::string(m[2])); + res.reason = std::string(m[3]); + } + + return true; +} + +inline bool ClientImpl::send(Request &req, Response &res, Error &error) { + std::lock_guard request_mutex_guard(request_mutex_); + auto ret = send_(req, res, error); + if (error == Error::SSLPeerCouldBeClosed_) { + assert(!ret); + ret = send_(req, res, error); + } + return ret; +} + +inline bool ClientImpl::send_(Request &req, Response &res, Error &error) { + { + std::lock_guard guard(socket_mutex_); + + // Set this to false immediately - if it ever gets set to true by the end of + // the request, we know another thread instructed us to close the socket. + socket_should_be_closed_when_request_is_done_ = false; + + auto is_alive = false; + if (socket_.is_open()) { + is_alive = detail::is_socket_alive(socket_.sock); + if (!is_alive) { + // Attempt to avoid sigpipe by shutting down nongracefully if it seems + // like the other side has already closed the connection Also, there + // cannot be any requests in flight from other threads since we locked + // request_mutex_, so safe to close everything immediately + const bool shutdown_gracefully = false; + shutdown_ssl(socket_, shutdown_gracefully); + shutdown_socket(socket_); + close_socket(socket_); + } + } + + if (!is_alive) { + if (!create_and_connect_socket(socket_, error)) { return false; } + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + // TODO: refactoring + if (is_ssl()) { + auto &scli = static_cast(*this); + if (!proxy_host_.empty() && proxy_port_ != -1) { + auto success = false; + if (!scli.connect_with_proxy(socket_, res, success, error)) { + return success; + } + } + + if (!scli.initialize_ssl(socket_, error)) { return false; } + } +#endif + } + + // Mark the current socket as being in use so that it cannot be closed by + // anyone else while this request is ongoing, even though we will be + // releasing the mutex. + if (socket_requests_in_flight_ > 1) { + assert(socket_requests_are_from_thread_ == std::this_thread::get_id()); + } + socket_requests_in_flight_ += 1; + socket_requests_are_from_thread_ = std::this_thread::get_id(); + } + + for (const auto &header : default_headers_) { + if (req.headers.find(header.first) == req.headers.end()) { + req.headers.insert(header); + } + } + + auto ret = false; + auto close_connection = !keep_alive_; + + auto se = detail::scope_exit([&]() { + // Briefly lock mutex in order to mark that a request is no longer ongoing + std::lock_guard guard(socket_mutex_); + socket_requests_in_flight_ -= 1; + if (socket_requests_in_flight_ <= 0) { + assert(socket_requests_in_flight_ == 0); + socket_requests_are_from_thread_ = std::thread::id(); + } + + if (socket_should_be_closed_when_request_is_done_ || close_connection || + !ret) { + shutdown_ssl(socket_, true); + shutdown_socket(socket_); + close_socket(socket_); + } + }); + + ret = process_socket(socket_, [&](Stream &strm) { + return handle_request(strm, req, res, close_connection, error); + }); + + if (!ret) { + if (error == Error::Success) { error = Error::Unknown; } + } + + return ret; +} + +inline Result ClientImpl::send(const Request &req) { + auto req2 = req; + return send_(std::move(req2)); +} + +inline Result ClientImpl::send_(Request &&req) { + auto res = detail::make_unique(); + auto error = Error::Success; + auto ret = send(req, *res, error); + return Result{ret ? std::move(res) : nullptr, error, std::move(req.headers)}; +} + +inline bool ClientImpl::handle_request(Stream &strm, Request &req, + Response &res, bool close_connection, + Error &error) { + if (req.path.empty()) { + error = Error::Connection; + return false; + } + + auto req_save = req; + + bool ret; + + if (!is_ssl() && !proxy_host_.empty() && proxy_port_ != -1) { + auto req2 = req; + req2.path = "http://" + host_and_port_ + req.path; + ret = process_request(strm, req2, res, close_connection, error); + req = req2; + req.path = req_save.path; + } else { + ret = process_request(strm, req, res, close_connection, error); + } + + if (!ret) { return false; } + + if (300 < res.status && res.status < 400 && follow_location_) { + req = req_save; + ret = redirect(req, res, error); + } + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + if ((res.status == 401 || res.status == 407) && + req.authorization_count_ < 5) { + 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 auth; + if (detail::parse_www_authenticate(res, auth, is_proxy)) { + Request new_req = req; + new_req.authorization_count_ += 1; + new_req.headers.erase(is_proxy ? "Proxy-Authorization" + : "Authorization"); + new_req.headers.insert(detail::make_digest_authentication_header( + req, auth, new_req.authorization_count_, detail::random_string(10), + username, password, is_proxy)); + + Response new_res; + + ret = send(new_req, new_res, error); + if (ret) { res = new_res; } + } + } + } +#endif + + return ret; +} + +inline bool ClientImpl::redirect(Request &req, Response &res, Error &error) { + if (req.redirect_count_ == 0) { + error = Error::ExceedRedirectCount; + return false; + } + + auto location = res.get_header_value("location"); + if (location.empty()) { return false; } + + const static std::regex re( + R"((?:(https?):)?(?://(?:\[([\d:]+)\]|([^:/?#]+))(?::(\d+))?)?([^?#]*)(\?[^#]*)?(?:#.*)?)"); + + std::smatch m; + if (!std::regex_match(location, m, re)) { return false; } + + auto scheme = is_ssl() ? "https" : "http"; + + auto next_scheme = m[1].str(); + auto next_host = m[2].str(); + if (next_host.empty()) { next_host = m[3].str(); } + auto port_str = m[4].str(); + auto next_path = m[5].str(); + auto next_query = m[6].str(); + + auto next_port = port_; + if (!port_str.empty()) { + next_port = std::stoi(port_str); + } else if (!next_scheme.empty()) { + next_port = next_scheme == "https" ? 443 : 80; + } + + if (next_scheme.empty()) { next_scheme = scheme; } + if (next_host.empty()) { next_host = host_; } + if (next_path.empty()) { next_path = "/"; } + + auto path = detail::decode_url(next_path, true) + next_query; + + if (next_scheme == scheme && next_host == host_ && next_port == port_) { + return detail::redirect(*this, req, res, path, location, error); + } else { + if (next_scheme == "https") { +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + SSLClient cli(next_host.c_str(), next_port); + cli.copy_settings(*this); + if (ca_cert_store_) { cli.set_ca_cert_store(ca_cert_store_); } + return detail::redirect(cli, req, res, path, location, error); +#else + return false; +#endif + } else { + ClientImpl cli(next_host.c_str(), next_port); + cli.copy_settings(*this); + return detail::redirect(cli, req, res, path, location, error); + } + } +} + +inline bool ClientImpl::write_content_with_provider(Stream &strm, + const Request &req, + Error &error) { + auto is_shutting_down = []() { return false; }; + + if (req.is_chunked_content_provider_) { + // TODO: Brotli support + std::unique_ptr compressor; +#ifdef CPPHTTPLIB_ZLIB_SUPPORT + if (compress_) { + compressor = detail::make_unique(); + } else +#endif + { + compressor = detail::make_unique(); + } + + return detail::write_content_chunked(strm, req.content_provider_, + is_shutting_down, *compressor, error); + } else { + return detail::write_content(strm, req.content_provider_, 0, + req.content_length_, is_shutting_down, error); + } +} + +inline bool ClientImpl::write_request(Stream &strm, Request &req, + bool close_connection, Error &error) { + // Prepare additional headers + if (close_connection) { + if (!req.has_header("Connection")) { + req.headers.emplace("Connection", "close"); + } + } + + if (!req.has_header("Host")) { + if (is_ssl()) { + if (port_ == 443) { + req.headers.emplace("Host", host_); + } else { + req.headers.emplace("Host", host_and_port_); + } + } else { + if (port_ == 80) { + req.headers.emplace("Host", host_); + } else { + req.headers.emplace("Host", host_and_port_); + } + } + } + + if (!req.has_header("Accept")) { req.headers.emplace("Accept", "*/*"); } + +#ifndef CPPHTTPLIB_NO_DEFAULT_USER_AGENT + if (!req.has_header("User-Agent")) { + auto agent = std::string("cpp-httplib/") + CPPHTTPLIB_VERSION; + req.headers.emplace("User-Agent", agent); + } +#endif + + if (req.body.empty()) { + if (req.content_provider_) { + if (!req.is_chunked_content_provider_) { + if (!req.has_header("Content-Length")) { + auto length = std::to_string(req.content_length_); + req.headers.emplace("Content-Length", length); + } + } + } else { + if (req.method == "POST" || req.method == "PUT" || + req.method == "PATCH") { + req.headers.emplace("Content-Length", "0"); + } + } + } else { + if (!req.has_header("Content-Type")) { + req.headers.emplace("Content-Type", "text/plain"); + } + + if (!req.has_header("Content-Length")) { + auto length = std::to_string(req.body.size()); + req.headers.emplace("Content-Length", length); + } + } + + if (!basic_auth_password_.empty() || !basic_auth_username_.empty()) { + if (!req.has_header("Authorization")) { + req.headers.insert(make_basic_authentication_header( + basic_auth_username_, basic_auth_password_, false)); + } + } + + if (!proxy_basic_auth_username_.empty() && + !proxy_basic_auth_password_.empty()) { + if (!req.has_header("Proxy-Authorization")) { + req.headers.insert(make_basic_authentication_header( + proxy_basic_auth_username_, proxy_basic_auth_password_, true)); + } + } + + if (!bearer_token_auth_token_.empty()) { + if (!req.has_header("Authorization")) { + req.headers.insert(make_bearer_token_authentication_header( + bearer_token_auth_token_, false)); + } + } + + if (!proxy_bearer_token_auth_token_.empty()) { + if (!req.has_header("Proxy-Authorization")) { + req.headers.insert(make_bearer_token_authentication_header( + proxy_bearer_token_auth_token_, true)); + } + } + + // Request line and headers + { + detail::BufferStream bstrm; + + const auto &path = url_encode_ ? detail::encode_url(req.path) : req.path; + bstrm.write_format("%s %s HTTP/1.1\r\n", req.method.c_str(), path.c_str()); + + detail::write_headers(bstrm, req.headers); + + // Flush buffer + auto &data = bstrm.get_buffer(); + if (!detail::write_data(strm, data.data(), data.size())) { + error = Error::Write; + return false; + } + } + + // Body + if (req.body.empty()) { + return write_content_with_provider(strm, req, error); + } + + if (!detail::write_data(strm, req.body.data(), req.body.size())) { + error = Error::Write; + return false; + } + + return true; +} + +inline std::unique_ptr ClientImpl::send_with_content_provider( + Request &req, const char *body, size_t content_length, + ContentProvider content_provider, + ContentProviderWithoutLength content_provider_without_length, + const std::string &content_type, Error &error) { + if (!content_type.empty()) { + req.headers.emplace("Content-Type", content_type); + } + +#ifdef CPPHTTPLIB_ZLIB_SUPPORT + if (compress_) { req.headers.emplace("Content-Encoding", "gzip"); } +#endif + +#ifdef CPPHTTPLIB_ZLIB_SUPPORT + if (compress_ && !content_provider_without_length) { + // TODO: Brotli support + detail::gzip_compressor compressor; + + if (content_provider) { + auto ok = true; + size_t offset = 0; + DataSink data_sink; + + data_sink.write = [&](const char *data, size_t data_len) -> bool { + if (ok) { + auto last = offset + data_len == content_length; + + auto ret = compressor.compress( + data, data_len, last, + [&](const char *compressed_data, size_t compressed_data_len) { + req.body.append(compressed_data, compressed_data_len); + return true; + }); + + if (ret) { + offset += data_len; + } else { + ok = false; + } + } + return ok; + }; + + while (ok && offset < content_length) { + if (!content_provider(offset, content_length - offset, data_sink)) { + error = Error::Canceled; + return nullptr; + } + } + } else { + if (!compressor.compress(body, content_length, true, + [&](const char *data, size_t data_len) { + req.body.append(data, data_len); + return true; + })) { + error = Error::Compression; + return nullptr; + } + } + } else +#endif + { + if (content_provider) { + req.content_length_ = content_length; + req.content_provider_ = std::move(content_provider); + req.is_chunked_content_provider_ = false; + } else if (content_provider_without_length) { + req.content_length_ = 0; + req.content_provider_ = detail::ContentProviderAdapter( + std::move(content_provider_without_length)); + req.is_chunked_content_provider_ = true; + req.headers.emplace("Transfer-Encoding", "chunked"); + } else { + req.body.assign(body, content_length); + ; + } + } + + auto res = detail::make_unique(); + return send(req, *res, error) ? std::move(res) : nullptr; +} + +inline Result ClientImpl::send_with_content_provider( + const std::string &method, const std::string &path, const Headers &headers, + const char *body, size_t content_length, ContentProvider content_provider, + ContentProviderWithoutLength content_provider_without_length, + const std::string &content_type) { + Request req; + req.method = method; + req.headers = headers; + req.path = path; + + auto error = Error::Success; + + auto res = send_with_content_provider( + req, body, content_length, std::move(content_provider), + std::move(content_provider_without_length), content_type, error); + + return Result{std::move(res), error, std::move(req.headers)}; +} + +inline std::string +ClientImpl::adjust_host_string(const std::string &host) const { + if (host.find(':') != std::string::npos) { return "[" + host + "]"; } + return host; +} + +inline bool ClientImpl::process_request(Stream &strm, Request &req, + Response &res, bool close_connection, + Error &error) { + // Send request + if (!write_request(strm, req, close_connection, error)) { return false; } + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + if (is_ssl()) { + auto is_proxy_enabled = !proxy_host_.empty() && proxy_port_ != -1; + if (!is_proxy_enabled) { + char buf[1]; + if (SSL_peek(socket_.ssl, buf, 1) == 0 && + SSL_get_error(socket_.ssl, 0) == SSL_ERROR_ZERO_RETURN) { + error = Error::SSLPeerCouldBeClosed_; + return false; + } + } + } +#endif + + // Receive response and headers + if (!read_response_line(strm, req, res) || + !detail::read_headers(strm, res.headers)) { + error = Error::Read; + return false; + } + + // Body + if ((res.status != 204) && req.method != "HEAD" && req.method != "CONNECT") { + auto redirect = 300 < res.status && res.status < 400 && follow_location_; + + if (req.response_handler && !redirect) { + if (!req.response_handler(res)) { + error = Error::Canceled; + return false; + } + } + + auto out = + req.content_receiver + ? static_cast( + [&](const char *buf, size_t n, uint64_t off, uint64_t len) { + if (redirect) { return true; } + auto ret = req.content_receiver(buf, n, off, len); + if (!ret) { error = Error::Canceled; } + return ret; + }) + : static_cast( + [&](const char *buf, size_t n, uint64_t /*off*/, + uint64_t /*len*/) { + if (res.body.size() + n > res.body.max_size()) { + return false; + } + res.body.append(buf, n); + return true; + }); + + auto progress = [&](uint64_t current, uint64_t total) { + if (!req.progress || redirect) { return true; } + auto ret = req.progress(current, total); + if (!ret) { error = Error::Canceled; } + return ret; + }; + + int dummy_status; + if (!detail::read_content(strm, res, (std::numeric_limits::max)(), + dummy_status, std::move(progress), std::move(out), + decompress_)) { + if (error != Error::Canceled) { error = Error::Read; } + return false; + } + } + + if (res.get_header_value("Connection") == "close" || + (res.version == "HTTP/1.0" && res.reason != "Connection established")) { + // TODO this requires a not-entirely-obvious chain of calls to be correct + // for this to be safe. Maybe a code refactor (such as moving this out to + // the send function and getting rid of the recursiveness of the mutex) + // could make this more obvious. + + // This is safe to call because process_request is only called by + // handle_request which is only called by send, which locks the request + // mutex during the process. It would be a bug to call it from a different + // thread since it's a thread-safety issue to do these things to the socket + // if another thread is using the socket. + std::lock_guard guard(socket_mutex_); + shutdown_ssl(socket_, true); + shutdown_socket(socket_); + close_socket(socket_); + } + + // Log + if (logger_) { logger_(req, res); } + + return true; +} + +inline ContentProviderWithoutLength ClientImpl::get_multipart_content_provider( + const std::string &boundary, const MultipartFormDataItems &items, + const MultipartFormDataProviderItems &provider_items) { + size_t cur_item = 0, cur_start = 0; + // cur_item and cur_start are copied to within the std::function and maintain + // state between successive calls + return [&, cur_item, cur_start](size_t offset, + DataSink &sink) mutable -> bool { + if (!offset && items.size()) { + sink.os << detail::serialize_multipart_formdata(items, boundary, false); + return true; + } else if (cur_item < provider_items.size()) { + if (!cur_start) { + const auto &begin = detail::serialize_multipart_formdata_item_begin( + provider_items[cur_item], boundary); + offset += begin.size(); + cur_start = offset; + sink.os << begin; + } + + DataSink cur_sink; + bool has_data = true; + cur_sink.write = sink.write; + cur_sink.done = [&]() { has_data = false; }; + + if (!provider_items[cur_item].provider(offset - cur_start, cur_sink)) + return false; + + if (!has_data) { + sink.os << detail::serialize_multipart_formdata_item_end(); + cur_item++; + cur_start = 0; + } + return true; + } else { + sink.os << detail::serialize_multipart_formdata_finish(boundary); + sink.done(); + return true; + } + }; +} + +inline bool +ClientImpl::process_socket(const Socket &socket, + std::function callback) { + return detail::process_client_socket( + socket.sock, read_timeout_sec_, read_timeout_usec_, write_timeout_sec_, + write_timeout_usec_, std::move(callback)); +} + +inline bool ClientImpl::is_ssl() const { return false; } + +inline Result ClientImpl::Get(const std::string &path) { + return Get(path, Headers(), Progress()); +} + +inline Result ClientImpl::Get(const std::string &path, Progress progress) { + return Get(path, Headers(), std::move(progress)); +} + +inline Result ClientImpl::Get(const std::string &path, const Headers &headers) { + return Get(path, headers, Progress()); +} + +inline Result ClientImpl::Get(const std::string &path, const Headers &headers, + Progress progress) { + Request req; + req.method = "GET"; + req.path = path; + req.headers = headers; + req.progress = std::move(progress); + + return send_(std::move(req)); +} + +inline Result ClientImpl::Get(const std::string &path, + ContentReceiver content_receiver) { + return Get(path, Headers(), nullptr, std::move(content_receiver), nullptr); +} + +inline Result ClientImpl::Get(const std::string &path, + ContentReceiver content_receiver, + Progress progress) { + return Get(path, Headers(), nullptr, std::move(content_receiver), + std::move(progress)); +} + +inline Result ClientImpl::Get(const std::string &path, const Headers &headers, + ContentReceiver content_receiver) { + return Get(path, headers, nullptr, std::move(content_receiver), nullptr); +} + +inline Result ClientImpl::Get(const std::string &path, const Headers &headers, + ContentReceiver content_receiver, + Progress progress) { + return Get(path, headers, nullptr, std::move(content_receiver), + std::move(progress)); +} + +inline Result ClientImpl::Get(const std::string &path, + ResponseHandler response_handler, + ContentReceiver content_receiver) { + return Get(path, Headers(), std::move(response_handler), + std::move(content_receiver), nullptr); +} + +inline Result ClientImpl::Get(const std::string &path, const Headers &headers, + ResponseHandler response_handler, + ContentReceiver content_receiver) { + return Get(path, headers, std::move(response_handler), + std::move(content_receiver), nullptr); +} + +inline Result ClientImpl::Get(const std::string &path, + ResponseHandler response_handler, + ContentReceiver content_receiver, + Progress progress) { + return Get(path, Headers(), std::move(response_handler), + std::move(content_receiver), std::move(progress)); +} + +inline Result ClientImpl::Get(const std::string &path, const Headers &headers, + ResponseHandler response_handler, + ContentReceiver content_receiver, + Progress progress) { + Request req; + req.method = "GET"; + req.path = path; + req.headers = headers; + req.response_handler = std::move(response_handler); + req.content_receiver = + [content_receiver](const char *data, size_t data_length, + uint64_t /*offset*/, uint64_t /*total_length*/) { + return content_receiver(data, data_length); + }; + req.progress = std::move(progress); + + return send_(std::move(req)); +} + +inline Result ClientImpl::Get(const std::string &path, const Params ¶ms, + const Headers &headers, Progress progress) { + if (params.empty()) { return Get(path, headers); } + + std::string path_with_query = append_query_params(path, params); + return Get(path_with_query.c_str(), headers, progress); +} + +inline Result ClientImpl::Get(const std::string &path, const Params ¶ms, + const Headers &headers, + ContentReceiver content_receiver, + Progress progress) { + return Get(path, params, headers, nullptr, content_receiver, progress); +} + +inline Result ClientImpl::Get(const std::string &path, const Params ¶ms, + const Headers &headers, + ResponseHandler response_handler, + ContentReceiver content_receiver, + Progress progress) { + if (params.empty()) { + return Get(path, headers, response_handler, content_receiver, progress); + } + + std::string path_with_query = append_query_params(path, params); + return Get(path_with_query.c_str(), headers, response_handler, + content_receiver, progress); +} + +inline Result ClientImpl::Head(const std::string &path) { + return Head(path, Headers()); +} + +inline Result ClientImpl::Head(const std::string &path, + const Headers &headers) { + Request req; + req.method = "HEAD"; + req.headers = headers; + req.path = path; + + return send_(std::move(req)); +} + +inline Result ClientImpl::Post(const std::string &path) { + return Post(path, std::string(), std::string()); +} + +inline Result ClientImpl::Post(const std::string &path, + const Headers &headers) { + return Post(path, headers, nullptr, 0, std::string()); +} + +inline Result ClientImpl::Post(const std::string &path, const char *body, + size_t content_length, + const std::string &content_type) { + return Post(path, Headers(), body, content_length, content_type); +} + +inline Result ClientImpl::Post(const std::string &path, const Headers &headers, + const char *body, size_t content_length, + const std::string &content_type) { + return send_with_content_provider("POST", path, headers, body, content_length, + nullptr, nullptr, content_type); +} + +inline Result ClientImpl::Post(const std::string &path, const std::string &body, + const std::string &content_type) { + return Post(path, Headers(), body, content_type); +} + +inline Result ClientImpl::Post(const std::string &path, const Headers &headers, + const std::string &body, + const std::string &content_type) { + return send_with_content_provider("POST", path, headers, body.data(), + body.size(), nullptr, nullptr, + content_type); +} + +inline Result ClientImpl::Post(const std::string &path, const Params ¶ms) { + return Post(path, Headers(), params); +} + +inline Result ClientImpl::Post(const std::string &path, size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return Post(path, Headers(), content_length, std::move(content_provider), + content_type); +} + +inline Result ClientImpl::Post(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return Post(path, Headers(), std::move(content_provider), content_type); +} + +inline Result ClientImpl::Post(const std::string &path, const Headers &headers, + size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return send_with_content_provider("POST", path, headers, nullptr, + content_length, std::move(content_provider), + nullptr, content_type); +} + +inline Result ClientImpl::Post(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return send_with_content_provider("POST", path, headers, nullptr, 0, nullptr, + std::move(content_provider), content_type); +} + +inline Result ClientImpl::Post(const std::string &path, const Headers &headers, + const Params ¶ms) { + auto query = detail::params_to_query_str(params); + return Post(path, headers, query, "application/x-www-form-urlencoded"); +} + +inline Result ClientImpl::Post(const std::string &path, + const MultipartFormDataItems &items) { + return Post(path, Headers(), items); +} + +inline Result ClientImpl::Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items) { + const auto &boundary = detail::make_multipart_data_boundary(); + const auto &content_type = + detail::serialize_multipart_formdata_get_content_type(boundary); + const auto &body = detail::serialize_multipart_formdata(items, boundary); + return Post(path, headers, body, content_type.c_str()); +} + +inline Result ClientImpl::Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const std::string &boundary) { + if (!detail::is_multipart_boundary_chars_valid(boundary)) { + return Result{nullptr, Error::UnsupportedMultipartBoundaryChars}; + } + + const auto &content_type = + detail::serialize_multipart_formdata_get_content_type(boundary); + const auto &body = detail::serialize_multipart_formdata(items, boundary); + return Post(path, headers, body, content_type.c_str()); +} + +inline Result +ClientImpl::Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const MultipartFormDataProviderItems &provider_items) { + const auto &boundary = detail::make_multipart_data_boundary(); + const auto &content_type = + detail::serialize_multipart_formdata_get_content_type(boundary); + return send_with_content_provider( + "POST", path, headers, nullptr, 0, nullptr, + get_multipart_content_provider(boundary, items, provider_items), + content_type); +} + +inline Result ClientImpl::Put(const std::string &path) { + return Put(path, std::string(), std::string()); +} + +inline Result ClientImpl::Put(const std::string &path, const char *body, + size_t content_length, + const std::string &content_type) { + return Put(path, Headers(), body, content_length, content_type); +} + +inline Result ClientImpl::Put(const std::string &path, const Headers &headers, + const char *body, size_t content_length, + const std::string &content_type) { + return send_with_content_provider("PUT", path, headers, body, content_length, + nullptr, nullptr, content_type); +} + +inline Result ClientImpl::Put(const std::string &path, const std::string &body, + const std::string &content_type) { + return Put(path, Headers(), body, content_type); +} + +inline Result ClientImpl::Put(const std::string &path, const Headers &headers, + const std::string &body, + const std::string &content_type) { + return send_with_content_provider("PUT", path, headers, body.data(), + body.size(), nullptr, nullptr, + content_type); +} + +inline Result ClientImpl::Put(const std::string &path, size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return Put(path, Headers(), content_length, std::move(content_provider), + content_type); +} + +inline Result ClientImpl::Put(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return Put(path, Headers(), std::move(content_provider), content_type); +} + +inline Result ClientImpl::Put(const std::string &path, const Headers &headers, + size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return send_with_content_provider("PUT", path, headers, nullptr, + content_length, std::move(content_provider), + nullptr, content_type); +} + +inline Result ClientImpl::Put(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return send_with_content_provider("PUT", path, headers, nullptr, 0, nullptr, + std::move(content_provider), content_type); +} + +inline Result ClientImpl::Put(const std::string &path, const Params ¶ms) { + return Put(path, Headers(), params); +} + +inline Result ClientImpl::Put(const std::string &path, const Headers &headers, + const Params ¶ms) { + auto query = detail::params_to_query_str(params); + return Put(path, headers, query, "application/x-www-form-urlencoded"); +} + +inline Result ClientImpl::Put(const std::string &path, + const MultipartFormDataItems &items) { + return Put(path, Headers(), items); +} + +inline Result ClientImpl::Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items) { + const auto &boundary = detail::make_multipart_data_boundary(); + const auto &content_type = + detail::serialize_multipart_formdata_get_content_type(boundary); + const auto &body = detail::serialize_multipart_formdata(items, boundary); + return Put(path, headers, body, content_type); +} + +inline Result ClientImpl::Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const std::string &boundary) { + if (!detail::is_multipart_boundary_chars_valid(boundary)) { + return Result{nullptr, Error::UnsupportedMultipartBoundaryChars}; + } + + const auto &content_type = + detail::serialize_multipart_formdata_get_content_type(boundary); + const auto &body = detail::serialize_multipart_formdata(items, boundary); + return Put(path, headers, body, content_type); +} + +inline Result +ClientImpl::Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const MultipartFormDataProviderItems &provider_items) { + const auto &boundary = detail::make_multipart_data_boundary(); + const auto &content_type = + detail::serialize_multipart_formdata_get_content_type(boundary); + return send_with_content_provider( + "PUT", path, headers, nullptr, 0, nullptr, + get_multipart_content_provider(boundary, items, provider_items), + content_type); +} +inline Result ClientImpl::Patch(const std::string &path) { + return Patch(path, std::string(), std::string()); +} + +inline Result ClientImpl::Patch(const std::string &path, const char *body, + size_t content_length, + const std::string &content_type) { + return Patch(path, Headers(), body, content_length, content_type); +} + +inline Result ClientImpl::Patch(const std::string &path, const Headers &headers, + const char *body, size_t content_length, + const std::string &content_type) { + return send_with_content_provider("PATCH", path, headers, body, + content_length, nullptr, nullptr, + content_type); +} + +inline Result ClientImpl::Patch(const std::string &path, + const std::string &body, + const std::string &content_type) { + return Patch(path, Headers(), body, content_type); +} + +inline Result ClientImpl::Patch(const std::string &path, const Headers &headers, + const std::string &body, + const std::string &content_type) { + return send_with_content_provider("PATCH", path, headers, body.data(), + body.size(), nullptr, nullptr, + content_type); +} + +inline Result ClientImpl::Patch(const std::string &path, size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return Patch(path, Headers(), content_length, std::move(content_provider), + content_type); +} + +inline Result ClientImpl::Patch(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return Patch(path, Headers(), std::move(content_provider), content_type); +} + +inline Result ClientImpl::Patch(const std::string &path, const Headers &headers, + size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return send_with_content_provider("PATCH", path, headers, nullptr, + content_length, std::move(content_provider), + nullptr, content_type); +} + +inline Result ClientImpl::Patch(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return send_with_content_provider("PATCH", path, headers, nullptr, 0, nullptr, + std::move(content_provider), content_type); +} + +inline Result ClientImpl::Delete(const std::string &path) { + return Delete(path, Headers(), std::string(), std::string()); +} + +inline Result ClientImpl::Delete(const std::string &path, + const Headers &headers) { + return Delete(path, headers, std::string(), std::string()); +} + +inline Result ClientImpl::Delete(const std::string &path, const char *body, + size_t content_length, + const std::string &content_type) { + return Delete(path, Headers(), body, content_length, content_type); +} + +inline Result ClientImpl::Delete(const std::string &path, + const Headers &headers, const char *body, + size_t content_length, + const std::string &content_type) { + Request req; + req.method = "DELETE"; + req.headers = headers; + req.path = path; + + if (!content_type.empty()) { + req.headers.emplace("Content-Type", content_type); + } + req.body.assign(body, content_length); + + return send_(std::move(req)); +} + +inline Result ClientImpl::Delete(const std::string &path, + const std::string &body, + const std::string &content_type) { + return Delete(path, Headers(), body.data(), body.size(), content_type); +} + +inline Result ClientImpl::Delete(const std::string &path, + const Headers &headers, + const std::string &body, + const std::string &content_type) { + return Delete(path, headers, body.data(), body.size(), content_type); +} + +inline Result ClientImpl::Options(const std::string &path) { + return Options(path, Headers()); +} + +inline Result ClientImpl::Options(const std::string &path, + const Headers &headers) { + Request req; + req.method = "OPTIONS"; + req.headers = headers; + req.path = path; + + return send_(std::move(req)); +} + +inline size_t ClientImpl::is_socket_open() const { + std::lock_guard guard(socket_mutex_); + return socket_.is_open(); +} + +inline socket_t ClientImpl::socket() const { return socket_.sock; } + +inline void ClientImpl::stop() { + std::lock_guard guard(socket_mutex_); + + // If there is anything ongoing right now, the ONLY thread-safe thing we can + // do is to shutdown_socket, so that threads using this socket suddenly + // discover they can't read/write any more and error out. Everything else + // (closing the socket, shutting ssl down) is unsafe because these actions are + // not thread-safe. + if (socket_requests_in_flight_ > 0) { + shutdown_socket(socket_); + + // Aside from that, we set a flag for the socket to be closed when we're + // done. + socket_should_be_closed_when_request_is_done_ = true; + return; + } + + // Otherwise, still holding the mutex, we can shut everything down ourselves + shutdown_ssl(socket_, true); + shutdown_socket(socket_); + close_socket(socket_); +} + +inline void ClientImpl::set_connection_timeout(time_t sec, time_t usec) { + connection_timeout_sec_ = sec; + connection_timeout_usec_ = usec; +} + +inline void ClientImpl::set_read_timeout(time_t sec, time_t usec) { + read_timeout_sec_ = sec; + read_timeout_usec_ = usec; +} + +inline void ClientImpl::set_write_timeout(time_t sec, time_t usec) { + write_timeout_sec_ = sec; + write_timeout_usec_ = usec; +} + +inline void ClientImpl::set_basic_auth(const std::string &username, + const std::string &password) { + basic_auth_username_ = username; + basic_auth_password_ = password; +} + +inline void ClientImpl::set_bearer_token_auth(const std::string &token) { + bearer_token_auth_token_ = token; +} + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +inline void ClientImpl::set_digest_auth(const std::string &username, + const std::string &password) { + digest_auth_username_ = username; + digest_auth_password_ = password; +} +#endif + +inline void ClientImpl::set_keep_alive(bool on) { keep_alive_ = on; } + +inline void ClientImpl::set_follow_location(bool on) { follow_location_ = on; } + +inline void ClientImpl::set_url_encode(bool on) { url_encode_ = on; } + +inline void +ClientImpl::set_hostname_addr_map(std::map addr_map) { + addr_map_ = std::move(addr_map); +} + +inline void ClientImpl::set_default_headers(Headers headers) { + default_headers_ = std::move(headers); +} + +inline void ClientImpl::set_address_family(int family) { + address_family_ = family; +} + +inline void ClientImpl::set_tcp_nodelay(bool on) { tcp_nodelay_ = on; } + +inline void ClientImpl::set_socket_options(SocketOptions socket_options) { + socket_options_ = std::move(socket_options); +} + +inline void ClientImpl::set_compress(bool on) { compress_ = on; } + +inline void ClientImpl::set_decompress(bool on) { decompress_ = on; } + +inline void ClientImpl::set_interface(const std::string &intf) { + interface_ = intf; +} + +inline void ClientImpl::set_proxy(const std::string &host, int port) { + proxy_host_ = host; + proxy_port_ = port; +} + +inline void ClientImpl::set_proxy_basic_auth(const std::string &username, + const std::string &password) { + proxy_basic_auth_username_ = username; + proxy_basic_auth_password_ = password; +} + +inline void ClientImpl::set_proxy_bearer_token_auth(const std::string &token) { + proxy_bearer_token_auth_token_ = token; +} + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +inline void ClientImpl::set_proxy_digest_auth(const std::string &username, + const std::string &password) { + proxy_digest_auth_username_ = username; + proxy_digest_auth_password_ = password; +} +#endif + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +inline void ClientImpl::set_ca_cert_path(const std::string &ca_cert_file_path, + const std::string &ca_cert_dir_path) { + ca_cert_file_path_ = ca_cert_file_path; + ca_cert_dir_path_ = ca_cert_dir_path; +} + +inline void ClientImpl::set_ca_cert_store(X509_STORE *ca_cert_store) { + if (ca_cert_store && ca_cert_store != ca_cert_store_) { + ca_cert_store_ = ca_cert_store; + } +} +#endif + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +inline void ClientImpl::enable_server_certificate_verification(bool enabled) { + server_certificate_verification_ = enabled; +} +#endif + +inline void ClientImpl::set_logger(Logger logger) { + logger_ = std::move(logger); +} + +/* + * SSL Implementation + */ +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +namespace detail { + +template +inline SSL *ssl_new(socket_t sock, SSL_CTX *ctx, std::mutex &ctx_mutex, + U SSL_connect_or_accept, V setup) { + SSL *ssl = nullptr; + { + std::lock_guard guard(ctx_mutex); + ssl = SSL_new(ctx); + } + + if (ssl) { + set_nonblocking(sock, true); + auto bio = BIO_new_socket(static_cast(sock), BIO_NOCLOSE); + BIO_set_nbio(bio, 1); + SSL_set_bio(ssl, bio, bio); + + if (!setup(ssl) || SSL_connect_or_accept(ssl) != 1) { + SSL_shutdown(ssl); + { + std::lock_guard guard(ctx_mutex); + SSL_free(ssl); + } + set_nonblocking(sock, false); + return nullptr; + } + BIO_set_nbio(bio, 0); + set_nonblocking(sock, false); + } + + return ssl; +} + +inline void ssl_delete(std::mutex &ctx_mutex, SSL *ssl, + bool shutdown_gracefully) { + // sometimes we may want to skip this to try to avoid SIGPIPE if we know + // the remote has closed the network connection + // Note that it is not always possible to avoid SIGPIPE, this is merely a + // best-efforts. + if (shutdown_gracefully) { SSL_shutdown(ssl); } + + std::lock_guard guard(ctx_mutex); + SSL_free(ssl); +} + +template +bool ssl_connect_or_accept_nonblocking(socket_t sock, SSL *ssl, + U ssl_connect_or_accept, + time_t timeout_sec, + time_t timeout_usec) { + int res = 0; + while ((res = ssl_connect_or_accept(ssl)) != 1) { + auto err = SSL_get_error(ssl, res); + switch (err) { + case SSL_ERROR_WANT_READ: + if (select_read(sock, timeout_sec, timeout_usec) > 0) { continue; } + break; + case SSL_ERROR_WANT_WRITE: + if (select_write(sock, timeout_sec, timeout_usec) > 0) { continue; } + break; + default: break; + } + return false; + } + return true; +} + +template +inline bool process_server_socket_ssl( + const std::atomic &svr_sock, SSL *ssl, socket_t sock, + size_t keep_alive_max_count, time_t keep_alive_timeout_sec, + time_t read_timeout_sec, time_t read_timeout_usec, time_t write_timeout_sec, + time_t write_timeout_usec, T callback) { + return process_server_socket_core( + svr_sock, sock, keep_alive_max_count, keep_alive_timeout_sec, + [&](bool close_connection, bool &connection_closed) { + SSLSocketStream strm(sock, ssl, read_timeout_sec, read_timeout_usec, + write_timeout_sec, write_timeout_usec); + return callback(strm, close_connection, connection_closed); + }); +} + +template +inline bool +process_client_socket_ssl(SSL *ssl, socket_t sock, time_t read_timeout_sec, + time_t read_timeout_usec, time_t write_timeout_sec, + time_t write_timeout_usec, T callback) { + SSLSocketStream strm(sock, ssl, read_timeout_sec, read_timeout_usec, + write_timeout_sec, write_timeout_usec); + return callback(strm); +} + +class SSLInit { +public: + SSLInit() { + OPENSSL_init_ssl( + OPENSSL_INIT_LOAD_SSL_STRINGS | OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL); + } +}; + +// SSL socket stream implementation +inline SSLSocketStream::SSLSocketStream(socket_t sock, SSL *ssl, + time_t read_timeout_sec, + time_t read_timeout_usec, + time_t write_timeout_sec, + time_t write_timeout_usec) + : sock_(sock), ssl_(ssl), read_timeout_sec_(read_timeout_sec), + read_timeout_usec_(read_timeout_usec), + write_timeout_sec_(write_timeout_sec), + write_timeout_usec_(write_timeout_usec) { + SSL_clear_mode(ssl, SSL_MODE_AUTO_RETRY); +} + +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 select_write(sock_, write_timeout_sec_, write_timeout_usec_) > 0 && + is_socket_alive(sock_); +} + +inline ssize_t SSLSocketStream::read(char *ptr, size_t size) { + if (SSL_pending(ssl_) > 0) { + return SSL_read(ssl_, ptr, static_cast(size)); + } else if (is_readable()) { + auto ret = SSL_read(ssl_, ptr, static_cast(size)); + if (ret < 0) { + auto err = SSL_get_error(ssl_, ret); + int n = 1000; +#ifdef _WIN32 + while (--n >= 0 && (err == SSL_ERROR_WANT_READ || + (err == SSL_ERROR_SYSCALL && + WSAGetLastError() == WSAETIMEDOUT))) { +#else + while (--n >= 0 && err == SSL_ERROR_WANT_READ) { +#endif + if (SSL_pending(ssl_) > 0) { + return SSL_read(ssl_, ptr, static_cast(size)); + } else if (is_readable()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + ret = SSL_read(ssl_, ptr, static_cast(size)); + if (ret >= 0) { return ret; } + err = SSL_get_error(ssl_, ret); + } else { + return -1; + } + } + } + return ret; + } + return -1; +} + +inline ssize_t SSLSocketStream::write(const char *ptr, size_t size) { + if (is_writable()) { + auto handle_size = static_cast( + std::min(size, (std::numeric_limits::max)())); + + auto ret = SSL_write(ssl_, ptr, static_cast(handle_size)); + if (ret < 0) { + auto err = SSL_get_error(ssl_, ret); + int n = 1000; +#ifdef _WIN32 + while (--n >= 0 && (err == SSL_ERROR_WANT_WRITE || + (err == SSL_ERROR_SYSCALL && + WSAGetLastError() == WSAETIMEDOUT))) { +#else + while (--n >= 0 && err == SSL_ERROR_WANT_WRITE) { +#endif + if (is_writable()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + ret = SSL_write(ssl_, ptr, static_cast(handle_size)); + if (ret >= 0) { return ret; } + err = SSL_get_error(ssl_, ret); + } else { + return -1; + } + } + } + return ret; + } + return -1; +} + +inline void SSLSocketStream::get_remote_ip_and_port(std::string &ip, + int &port) const { + detail::get_remote_ip_and_port(sock_, ip, port); +} + +inline void SSLSocketStream::get_local_ip_and_port(std::string &ip, + int &port) const { + detail::get_local_ip_and_port(sock_, ip, port); +} + +inline socket_t SSLSocketStream::socket() const { return 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, + const char *client_ca_cert_dir_path, + const char *private_key_password) { + ctx_ = SSL_CTX_new(TLS_server_method()); + + if (ctx_) { + SSL_CTX_set_options(ctx_, + SSL_OP_NO_COMPRESSION | + SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION); + + SSL_CTX_set_min_proto_version(ctx_, TLS1_1_VERSION); + + // add default password callback before opening encrypted private key + if (private_key_password != nullptr && (private_key_password[0] != '\0')) { + SSL_CTX_set_default_passwd_cb_userdata(ctx_, + (char *)private_key_password); + } + + if (SSL_CTX_use_certificate_chain_file(ctx_, cert_path) != 1 || + SSL_CTX_use_PrivateKey_file(ctx_, private_key_path, SSL_FILETYPE_PEM) != + 1) { + SSL_CTX_free(ctx_); + ctx_ = nullptr; + } else if (client_ca_cert_file_path || client_ca_cert_dir_path) { + SSL_CTX_load_verify_locations(ctx_, client_ca_cert_file_path, + client_ca_cert_dir_path); + + SSL_CTX_set_verify( + ctx_, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, nullptr); + } + } +} + +inline SSLServer::SSLServer(X509 *cert, EVP_PKEY *private_key, + X509_STORE *client_ca_cert_store) { + ctx_ = SSL_CTX_new(TLS_server_method()); + + if (ctx_) { + SSL_CTX_set_options(ctx_, + SSL_OP_NO_COMPRESSION | + SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION); + + SSL_CTX_set_min_proto_version(ctx_, TLS1_1_VERSION); + + if (SSL_CTX_use_certificate(ctx_, cert) != 1 || + SSL_CTX_use_PrivateKey(ctx_, private_key) != 1) { + SSL_CTX_free(ctx_); + ctx_ = nullptr; + } else if (client_ca_cert_store) { + SSL_CTX_set_cert_store(ctx_, client_ca_cert_store); + + SSL_CTX_set_verify( + ctx_, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, nullptr); + } + } +} + +inline SSLServer::SSLServer( + const std::function &setup_ssl_ctx_callback) { + ctx_ = SSL_CTX_new(TLS_method()); + if (ctx_) { + if (!setup_ssl_ctx_callback(*ctx_)) { + SSL_CTX_free(ctx_); + ctx_ = nullptr; + } + } +} + +inline SSLServer::~SSLServer() { + if (ctx_) { SSL_CTX_free(ctx_); } +} + +inline bool SSLServer::is_valid() const { return ctx_; } + +inline SSL_CTX *SSLServer::ssl_context() const { return ctx_; } + +inline bool SSLServer::process_and_close_socket(socket_t sock) { + auto ssl = detail::ssl_new( + sock, ctx_, ctx_mutex_, + [&](SSL *ssl2) { + return detail::ssl_connect_or_accept_nonblocking( + sock, ssl2, SSL_accept, read_timeout_sec_, read_timeout_usec_); + }, + [](SSL * /*ssl2*/) { return true; }); + + auto ret = false; + if (ssl) { + ret = detail::process_server_socket_ssl( + svr_sock_, ssl, sock, keep_alive_max_count_, keep_alive_timeout_sec_, + read_timeout_sec_, read_timeout_usec_, write_timeout_sec_, + write_timeout_usec_, + [this, ssl](Stream &strm, bool close_connection, + bool &connection_closed) { + return process_request(strm, close_connection, connection_closed, + [&](Request &req) { req.ssl = ssl; }); + }); + + // Shutdown gracefully if the result seemed successful, non-gracefully if + // the connection appeared to be closed. + const bool shutdown_gracefully = ret; + detail::ssl_delete(ctx_mutex_, ssl, shutdown_gracefully); + } + + detail::shutdown_socket(sock); + detail::close_socket(sock); + return ret; +} + +// SSL HTTP client implementation +inline SSLClient::SSLClient(const std::string &host) + : SSLClient(host, 443, std::string(), std::string()) {} + +inline SSLClient::SSLClient(const std::string &host, int port) + : SSLClient(host, port, std::string(), std::string()) {} + +inline SSLClient::SSLClient(const std::string &host, int port, + const std::string &client_cert_path, + const std::string &client_key_path) + : ClientImpl(host, port, client_cert_path, client_key_path) { + ctx_ = SSL_CTX_new(TLS_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.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.c_str(), + SSL_FILETYPE_PEM) != 1) { + SSL_CTX_free(ctx_); + ctx_ = nullptr; + } + } +} + +inline SSLClient::SSLClient(const std::string &host, int port, + X509 *client_cert, EVP_PKEY *client_key) + : ClientImpl(host, port) { + ctx_ = SSL_CTX_new(TLS_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 != nullptr && client_key != nullptr) { + if (SSL_CTX_use_certificate(ctx_, client_cert) != 1 || + SSL_CTX_use_PrivateKey(ctx_, client_key) != 1) { + SSL_CTX_free(ctx_); + ctx_ = nullptr; + } + } +} + +inline SSLClient::~SSLClient() { + if (ctx_) { SSL_CTX_free(ctx_); } + // Make sure to shut down SSL since shutdown_ssl will resolve to the + // base function rather than the derived function once we get to the + // base class destructor, and won't free the SSL (causing a leak). + shutdown_ssl_impl(socket_, true); +} + +inline bool SSLClient::is_valid() const { return ctx_; } + +inline void SSLClient::set_ca_cert_store(X509_STORE *ca_cert_store) { + if (ca_cert_store) { + if (ctx_) { + if (SSL_CTX_get_cert_store(ctx_) != ca_cert_store) { + // Free memory allocated for old cert and use new store `ca_cert_store` + SSL_CTX_set_cert_store(ctx_, ca_cert_store); + } + } else { + X509_STORE_free(ca_cert_store); + } + } +} + +inline long SSLClient::get_openssl_verify_result() const { + return verify_result_; +} + +inline SSL_CTX *SSLClient::ssl_context() const { return ctx_; } + +inline bool SSLClient::create_and_connect_socket(Socket &socket, Error &error) { + return is_valid() && ClientImpl::create_and_connect_socket(socket, error); +} + +// Assumes that socket_mutex_ is locked and that there are no requests in flight +inline bool SSLClient::connect_with_proxy(Socket &socket, Response &res, + bool &success, Error &error) { + success = true; + Response res2; + if (!detail::process_client_socket( + socket.sock, read_timeout_sec_, read_timeout_usec_, + write_timeout_sec_, write_timeout_usec_, [&](Stream &strm) { + Request req2; + req2.method = "CONNECT"; + req2.path = host_and_port_; + return process_request(strm, req2, res2, false, error); + })) { + // Thread-safe to close everything because we are assuming there are no + // requests in flight + shutdown_ssl(socket, true); + shutdown_socket(socket); + close_socket(socket); + success = false; + return false; + } + + if (res2.status == 407) { + if (!proxy_digest_auth_username_.empty() && + !proxy_digest_auth_password_.empty()) { + std::map auth; + if (detail::parse_www_authenticate(res2, auth, true)) { + Response res3; + if (!detail::process_client_socket( + socket.sock, read_timeout_sec_, read_timeout_usec_, + write_timeout_sec_, write_timeout_usec_, [&](Stream &strm) { + Request req3; + req3.method = "CONNECT"; + req3.path = host_and_port_; + req3.headers.insert(detail::make_digest_authentication_header( + req3, auth, 1, detail::random_string(10), + proxy_digest_auth_username_, proxy_digest_auth_password_, + true)); + return process_request(strm, req3, res3, false, error); + })) { + // Thread-safe to close everything because we are assuming there are + // no requests in flight + shutdown_ssl(socket, true); + shutdown_socket(socket); + close_socket(socket); + success = false; + return false; + } + } + } else { + res = res2; + return false; + } + } + + return true; +} + +inline bool SSLClient::load_certs() { + bool ret = true; + + std::call_once(initialize_cert_, [&]() { + std::lock_guard guard(ctx_mutex_); + if (!ca_cert_file_path_.empty()) { + if (!SSL_CTX_load_verify_locations(ctx_, ca_cert_file_path_.c_str(), + nullptr)) { + ret = false; + } + } else if (!ca_cert_dir_path_.empty()) { + if (!SSL_CTX_load_verify_locations(ctx_, nullptr, + ca_cert_dir_path_.c_str())) { + ret = false; + } + } else { + auto loaded = false; +#ifdef _WIN32 + loaded = + detail::load_system_certs_on_windows(SSL_CTX_get_cert_store(ctx_)); +#elif defined(CPPHTTPLIB_USE_CERTS_FROM_MACOSX_KEYCHAIN) && defined(__APPLE__) +#if TARGET_OS_OSX + loaded = detail::load_system_certs_on_macos(SSL_CTX_get_cert_store(ctx_)); +#endif // TARGET_OS_OSX +#endif // _WIN32 + if (!loaded) { SSL_CTX_set_default_verify_paths(ctx_); } + } + }); + + return ret; +} + +inline bool SSLClient::initialize_ssl(Socket &socket, Error &error) { + auto ssl = detail::ssl_new( + socket.sock, ctx_, ctx_mutex_, + [&](SSL *ssl2) { + if (server_certificate_verification_) { + if (!load_certs()) { + error = Error::SSLLoadingCerts; + return false; + } + SSL_set_verify(ssl2, SSL_VERIFY_NONE, nullptr); + } + + if (!detail::ssl_connect_or_accept_nonblocking( + socket.sock, ssl2, SSL_connect, connection_timeout_sec_, + connection_timeout_usec_)) { + error = Error::SSLConnection; + return false; + } + + if (server_certificate_verification_) { + verify_result_ = SSL_get_verify_result(ssl2); + + if (verify_result_ != X509_V_OK) { + error = Error::SSLServerVerification; + return false; + } + + auto server_cert = SSL_get1_peer_certificate(ssl2); + + if (server_cert == nullptr) { + error = Error::SSLServerVerification; + return false; + } + + if (!verify_host(server_cert)) { + X509_free(server_cert); + error = Error::SSLServerVerification; + return false; + } + X509_free(server_cert); + } + + return true; + }, + [&](SSL *ssl2) { + SSL_set_tlsext_host_name(ssl2, host_.c_str()); + return true; + }); + + if (ssl) { + socket.ssl = ssl; + return true; + } + + shutdown_socket(socket); + close_socket(socket); + return false; +} + +inline void SSLClient::shutdown_ssl(Socket &socket, bool shutdown_gracefully) { + shutdown_ssl_impl(socket, shutdown_gracefully); +} + +inline void SSLClient::shutdown_ssl_impl(Socket &socket, + bool shutdown_gracefully) { + if (socket.sock == INVALID_SOCKET) { + assert(socket.ssl == nullptr); + return; + } + if (socket.ssl) { + detail::ssl_delete(ctx_mutex_, socket.ssl, shutdown_gracefully); + socket.ssl = nullptr; + } + assert(socket.ssl == nullptr); +} + +inline bool +SSLClient::process_socket(const Socket &socket, + std::function callback) { + assert(socket.ssl); + return detail::process_client_socket_ssl( + socket.ssl, socket.sock, read_timeout_sec_, read_timeout_usec_, + write_timeout_sec_, write_timeout_usec_, std::move(callback)); +} + +inline bool SSLClient::is_ssl() const { return true; } + +inline bool SSLClient::verify_host(X509 *server_cert) const { + /* Quote from RFC2818 section 3.1 "Server Identity" + + If a subjectAltName extension of type dNSName is present, that MUST + be used as the identity. Otherwise, the (most specific) Common Name + field in the Subject field of the certificate MUST be used. Although + the use of the Common Name is existing practice, it is deprecated and + Certification Authorities are encouraged to use the dNSName instead. + + Matching is performed using the matching rules specified by + [RFC2459]. If more than one identity of a given type is present in + the certificate (e.g., more than one dNSName name, a match in any one + of the set is considered acceptable.) Names may contain the wildcard + character * which is considered to match any single domain name + component or component fragment. E.g., *.a.com matches foo.a.com but + not bar.foo.a.com. f*.com matches foo.com but not bar.com. + + In some cases, the URI is specified as an IP address rather than a + hostname. In this case, the iPAddress subjectAltName must be present + in the certificate and must exactly match the IP in the URI. + + */ + return verify_host_with_subject_alt_name(server_cert) || + verify_host_with_common_name(server_cert); +} + +inline bool +SSLClient::verify_host_with_subject_alt_name(X509 *server_cert) const { + auto ret = false; + + auto type = GEN_DNS; + + struct in6_addr addr6; + struct in_addr addr; + size_t addr_len = 0; + +#ifndef __MINGW32__ + if (inet_pton(AF_INET6, host_.c_str(), &addr6)) { + type = GEN_IPADD; + addr_len = sizeof(struct in6_addr); + } else if (inet_pton(AF_INET, host_.c_str(), &addr)) { + type = GEN_IPADD; + addr_len = sizeof(struct in_addr); + } +#endif + + auto alt_names = static_cast( + X509_get_ext_d2i(server_cert, NID_subject_alt_name, nullptr, nullptr)); + + if (alt_names) { + auto dsn_matched = false; + auto ip_matched = false; + + auto count = sk_GENERAL_NAME_num(alt_names); + + for (decltype(count) i = 0; i < count && !dsn_matched; i++) { + auto val = sk_GENERAL_NAME_value(alt_names, i); + if (val->type == type) { + auto name = (const char *)ASN1_STRING_get0_data(val->d.ia5); + auto name_len = (size_t)ASN1_STRING_length(val->d.ia5); + + switch (type) { + case GEN_DNS: dsn_matched = check_host_name(name, name_len); break; + + case GEN_IPADD: + if (!memcmp(&addr6, name, addr_len) || + !memcmp(&addr, name, addr_len)) { + ip_matched = true; + } + break; + } + } + } + + if (dsn_matched || ip_matched) { ret = true; } + } + + GENERAL_NAMES_free((STACK_OF(GENERAL_NAME) *)alt_names); + return ret; +} + +inline bool SSLClient::verify_host_with_common_name(X509 *server_cert) const { + const auto subject_name = X509_get_subject_name(server_cert); + + if (subject_name != nullptr) { + char name[BUFSIZ]; + auto name_len = X509_NAME_get_text_by_NID(subject_name, NID_commonName, + name, sizeof(name)); + + if (name_len != -1) { + return check_host_name(name, static_cast(name_len)); + } + } + + return false; +} + +inline bool SSLClient::check_host_name(const char *pattern, + size_t pattern_len) const { + if (host_.size() == pattern_len && host_ == pattern) { return true; } + + // Wildcard match + // https://bugs.launchpad.net/ubuntu/+source/firefox-3.0/+bug/376484 + std::vector pattern_components; + detail::split(&pattern[0], &pattern[pattern_len], '.', + [&](const char *b, const char *e) { + pattern_components.emplace_back(std::string(b, e)); + }); + + if (host_components_.size() != pattern_components.size()) { return false; } + + auto itr = pattern_components.begin(); + for (const auto &h : host_components_) { + auto &p = *itr; + if (p != h && p != "*") { + auto partial_match = (p.size() > 0 && p[p.size() - 1] == '*' && + !p.compare(0, p.size() - 1, h)); + if (!partial_match) { return false; } + } + ++itr; + } + + return true; +} +#endif + +// Universal client implementation +inline Client::Client(const std::string &scheme_host_port) + : Client(scheme_host_port, std::string(), std::string()) {} + +inline Client::Client(const std::string &scheme_host_port, + const std::string &client_cert_path, + const std::string &client_key_path) { + const static std::regex re( + R"((?:([a-z]+):\/\/)?(?:\[([\d:]+)\]|([^:/?#]+))(?::(\d+))?)"); + + std::smatch m; + if (std::regex_match(scheme_host_port, m, re)) { + auto scheme = m[1].str(); + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + if (!scheme.empty() && (scheme != "http" && scheme != "https")) { +#else + if (!scheme.empty() && scheme != "http") { +#endif +#ifndef CPPHTTPLIB_NO_EXCEPTIONS + std::string msg = "'" + scheme + "' scheme is not supported."; + throw std::invalid_argument(msg); +#endif + return; + } + + auto is_ssl = scheme == "https"; + + auto host = m[2].str(); + if (host.empty()) { host = m[3].str(); } + + auto port_str = m[4].str(); + auto port = !port_str.empty() ? std::stoi(port_str) : (is_ssl ? 443 : 80); + + if (is_ssl) { +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + cli_ = detail::make_unique(host, port, client_cert_path, + client_key_path); + is_ssl_ = is_ssl; +#endif + } else { + cli_ = detail::make_unique(host, port, client_cert_path, + client_key_path); + } + } else { + cli_ = detail::make_unique(scheme_host_port, 80, + client_cert_path, client_key_path); + } +} + +inline Client::Client(const std::string &host, int port) + : cli_(detail::make_unique(host, port)) {} + +inline Client::Client(const std::string &host, int port, + const std::string &client_cert_path, + const std::string &client_key_path) + : cli_(detail::make_unique(host, port, client_cert_path, + client_key_path)) {} + +inline Client::~Client() {} + +inline bool Client::is_valid() const { + return cli_ != nullptr && cli_->is_valid(); +} + +inline Result Client::Get(const std::string &path) { return cli_->Get(path); } +inline Result Client::Get(const std::string &path, const Headers &headers) { + return cli_->Get(path, headers); +} +inline Result Client::Get(const std::string &path, Progress progress) { + return cli_->Get(path, std::move(progress)); +} +inline Result Client::Get(const std::string &path, const Headers &headers, + Progress progress) { + return cli_->Get(path, headers, std::move(progress)); +} +inline Result Client::Get(const std::string &path, + ContentReceiver content_receiver) { + return cli_->Get(path, std::move(content_receiver)); +} +inline Result Client::Get(const std::string &path, const Headers &headers, + ContentReceiver content_receiver) { + return cli_->Get(path, headers, std::move(content_receiver)); +} +inline Result Client::Get(const std::string &path, + ContentReceiver content_receiver, Progress progress) { + return cli_->Get(path, std::move(content_receiver), std::move(progress)); +} +inline Result Client::Get(const std::string &path, const Headers &headers, + ContentReceiver content_receiver, Progress progress) { + return cli_->Get(path, headers, std::move(content_receiver), + std::move(progress)); +} +inline Result Client::Get(const std::string &path, + ResponseHandler response_handler, + ContentReceiver content_receiver) { + return cli_->Get(path, std::move(response_handler), + std::move(content_receiver)); +} +inline Result Client::Get(const std::string &path, const Headers &headers, + ResponseHandler response_handler, + ContentReceiver content_receiver) { + return cli_->Get(path, headers, std::move(response_handler), + std::move(content_receiver)); +} +inline Result Client::Get(const std::string &path, + ResponseHandler response_handler, + ContentReceiver content_receiver, Progress progress) { + return cli_->Get(path, std::move(response_handler), + std::move(content_receiver), std::move(progress)); +} +inline Result Client::Get(const std::string &path, const Headers &headers, + ResponseHandler response_handler, + ContentReceiver content_receiver, Progress progress) { + return cli_->Get(path, headers, std::move(response_handler), + std::move(content_receiver), std::move(progress)); +} +inline Result Client::Get(const std::string &path, const Params ¶ms, + const Headers &headers, Progress progress) { + return cli_->Get(path, params, headers, progress); +} +inline Result Client::Get(const std::string &path, const Params ¶ms, + const Headers &headers, + ContentReceiver content_receiver, Progress progress) { + return cli_->Get(path, params, headers, content_receiver, progress); +} +inline Result Client::Get(const std::string &path, const Params ¶ms, + const Headers &headers, + ResponseHandler response_handler, + ContentReceiver content_receiver, Progress progress) { + return cli_->Get(path, params, headers, response_handler, content_receiver, + progress); +} + +inline Result Client::Head(const std::string &path) { return cli_->Head(path); } +inline Result Client::Head(const std::string &path, const Headers &headers) { + return cli_->Head(path, headers); +} + +inline Result Client::Post(const std::string &path) { return cli_->Post(path); } +inline Result Client::Post(const std::string &path, const Headers &headers) { + return cli_->Post(path, headers); +} +inline Result Client::Post(const std::string &path, const char *body, + size_t content_length, + const std::string &content_type) { + return cli_->Post(path, body, content_length, content_type); +} +inline Result Client::Post(const std::string &path, const Headers &headers, + const char *body, size_t content_length, + const std::string &content_type) { + return cli_->Post(path, headers, body, content_length, content_type); +} +inline Result Client::Post(const std::string &path, const std::string &body, + const std::string &content_type) { + return cli_->Post(path, body, content_type); +} +inline Result Client::Post(const std::string &path, const Headers &headers, + const std::string &body, + const std::string &content_type) { + return cli_->Post(path, headers, body, content_type); +} +inline Result Client::Post(const std::string &path, size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return cli_->Post(path, content_length, std::move(content_provider), + content_type); +} +inline Result Client::Post(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return cli_->Post(path, std::move(content_provider), content_type); +} +inline Result Client::Post(const std::string &path, const Headers &headers, + size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return cli_->Post(path, headers, content_length, std::move(content_provider), + content_type); +} +inline Result Client::Post(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return cli_->Post(path, headers, std::move(content_provider), content_type); +} +inline Result Client::Post(const std::string &path, const Params ¶ms) { + return cli_->Post(path, params); +} +inline Result Client::Post(const std::string &path, const Headers &headers, + const Params ¶ms) { + return cli_->Post(path, headers, params); +} +inline Result Client::Post(const std::string &path, + const MultipartFormDataItems &items) { + return cli_->Post(path, items); +} +inline Result Client::Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items) { + return cli_->Post(path, headers, items); +} +inline Result Client::Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const std::string &boundary) { + return cli_->Post(path, headers, items, boundary); +} +inline Result +Client::Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const MultipartFormDataProviderItems &provider_items) { + return cli_->Post(path, headers, items, provider_items); +} +inline Result Client::Put(const std::string &path) { return cli_->Put(path); } +inline Result Client::Put(const std::string &path, const char *body, + size_t content_length, + const std::string &content_type) { + return cli_->Put(path, body, content_length, content_type); +} +inline Result Client::Put(const std::string &path, const Headers &headers, + const char *body, size_t content_length, + const std::string &content_type) { + return cli_->Put(path, headers, body, content_length, content_type); +} +inline Result Client::Put(const std::string &path, const std::string &body, + const std::string &content_type) { + return cli_->Put(path, body, content_type); +} +inline Result Client::Put(const std::string &path, const Headers &headers, + const std::string &body, + const std::string &content_type) { + return cli_->Put(path, headers, body, content_type); +} +inline Result Client::Put(const std::string &path, size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return cli_->Put(path, content_length, std::move(content_provider), + content_type); +} +inline Result Client::Put(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return cli_->Put(path, std::move(content_provider), content_type); +} +inline Result Client::Put(const std::string &path, const Headers &headers, + size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return cli_->Put(path, headers, content_length, std::move(content_provider), + content_type); +} +inline Result Client::Put(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return cli_->Put(path, headers, std::move(content_provider), content_type); +} +inline Result Client::Put(const std::string &path, const Params ¶ms) { + return cli_->Put(path, params); +} +inline Result Client::Put(const std::string &path, const Headers &headers, + const Params ¶ms) { + return cli_->Put(path, headers, params); +} +inline Result Client::Put(const std::string &path, + const MultipartFormDataItems &items) { + return cli_->Put(path, items); +} +inline Result Client::Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items) { + return cli_->Put(path, headers, items); +} +inline Result Client::Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const std::string &boundary) { + return cli_->Put(path, headers, items, boundary); +} +inline Result +Client::Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const MultipartFormDataProviderItems &provider_items) { + return cli_->Put(path, headers, items, provider_items); +} +inline Result Client::Patch(const std::string &path) { + return cli_->Patch(path); +} +inline Result Client::Patch(const std::string &path, const char *body, + size_t content_length, + const std::string &content_type) { + return cli_->Patch(path, body, content_length, content_type); +} +inline Result Client::Patch(const std::string &path, const Headers &headers, + const char *body, size_t content_length, + const std::string &content_type) { + return cli_->Patch(path, headers, body, content_length, content_type); +} +inline Result Client::Patch(const std::string &path, const std::string &body, + const std::string &content_type) { + return cli_->Patch(path, body, content_type); +} +inline Result Client::Patch(const std::string &path, const Headers &headers, + const std::string &body, + const std::string &content_type) { + return cli_->Patch(path, headers, body, content_type); +} +inline Result Client::Patch(const std::string &path, size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return cli_->Patch(path, content_length, std::move(content_provider), + content_type); +} +inline Result Client::Patch(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return cli_->Patch(path, std::move(content_provider), content_type); +} +inline Result Client::Patch(const std::string &path, const Headers &headers, + size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return cli_->Patch(path, headers, content_length, std::move(content_provider), + content_type); +} +inline Result Client::Patch(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return cli_->Patch(path, headers, std::move(content_provider), content_type); +} +inline Result Client::Delete(const std::string &path) { + return cli_->Delete(path); +} +inline Result Client::Delete(const std::string &path, const Headers &headers) { + return cli_->Delete(path, headers); +} +inline Result Client::Delete(const std::string &path, const char *body, + size_t content_length, + const std::string &content_type) { + return cli_->Delete(path, body, content_length, content_type); +} +inline Result Client::Delete(const std::string &path, const Headers &headers, + const char *body, size_t content_length, + const std::string &content_type) { + return cli_->Delete(path, headers, body, content_length, content_type); +} +inline Result Client::Delete(const std::string &path, const std::string &body, + const std::string &content_type) { + return cli_->Delete(path, body, content_type); +} +inline Result Client::Delete(const std::string &path, const Headers &headers, + const std::string &body, + const std::string &content_type) { + return cli_->Delete(path, headers, body, content_type); +} +inline Result Client::Options(const std::string &path) { + return cli_->Options(path); +} +inline Result Client::Options(const std::string &path, const Headers &headers) { + return cli_->Options(path, headers); +} + +inline bool Client::send(Request &req, Response &res, Error &error) { + return cli_->send(req, res, error); +} + +inline Result Client::send(const Request &req) { return cli_->send(req); } + +inline size_t Client::is_socket_open() const { return cli_->is_socket_open(); } + +inline socket_t Client::socket() const { return cli_->socket(); } + +inline void Client::stop() { cli_->stop(); } + +inline void +Client::set_hostname_addr_map(std::map addr_map) { + cli_->set_hostname_addr_map(std::move(addr_map)); +} + +inline void Client::set_default_headers(Headers headers) { + cli_->set_default_headers(std::move(headers)); +} + +inline void Client::set_address_family(int family) { + cli_->set_address_family(family); +} + +inline void Client::set_tcp_nodelay(bool on) { cli_->set_tcp_nodelay(on); } + +inline void Client::set_socket_options(SocketOptions socket_options) { + cli_->set_socket_options(std::move(socket_options)); +} + +inline void Client::set_connection_timeout(time_t sec, time_t usec) { + cli_->set_connection_timeout(sec, usec); +} + +inline void Client::set_read_timeout(time_t sec, time_t usec) { + cli_->set_read_timeout(sec, usec); +} + +inline void Client::set_write_timeout(time_t sec, time_t usec) { + cli_->set_write_timeout(sec, usec); +} + +inline void Client::set_basic_auth(const std::string &username, + const std::string &password) { + cli_->set_basic_auth(username, password); +} +inline void Client::set_bearer_token_auth(const std::string &token) { + cli_->set_bearer_token_auth(token); +} +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +inline void Client::set_digest_auth(const std::string &username, + const std::string &password) { + cli_->set_digest_auth(username, password); +} +#endif + +inline void Client::set_keep_alive(bool on) { cli_->set_keep_alive(on); } +inline void Client::set_follow_location(bool on) { + cli_->set_follow_location(on); +} + +inline void Client::set_url_encode(bool on) { cli_->set_url_encode(on); } + +inline void Client::set_compress(bool on) { cli_->set_compress(on); } + +inline void Client::set_decompress(bool on) { cli_->set_decompress(on); } + +inline void Client::set_interface(const std::string &intf) { + cli_->set_interface(intf); +} + +inline void Client::set_proxy(const std::string &host, int port) { + cli_->set_proxy(host, port); +} +inline void Client::set_proxy_basic_auth(const std::string &username, + const std::string &password) { + cli_->set_proxy_basic_auth(username, password); +} +inline void Client::set_proxy_bearer_token_auth(const std::string &token) { + cli_->set_proxy_bearer_token_auth(token); +} +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +inline void Client::set_proxy_digest_auth(const std::string &username, + const std::string &password) { + cli_->set_proxy_digest_auth(username, password); +} +#endif + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +inline void Client::enable_server_certificate_verification(bool enabled) { + cli_->enable_server_certificate_verification(enabled); +} +#endif + +inline void Client::set_logger(Logger logger) { cli_->set_logger(logger); } + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +inline void Client::set_ca_cert_path(const std::string &ca_cert_file_path, + const std::string &ca_cert_dir_path) { + cli_->set_ca_cert_path(ca_cert_file_path, ca_cert_dir_path); +} + +inline void Client::set_ca_cert_store(X509_STORE *ca_cert_store) { + if (is_ssl_) { + static_cast(*cli_).set_ca_cert_store(ca_cert_store); + } else { + cli_->set_ca_cert_store(ca_cert_store); + } +} + +inline long Client::get_openssl_verify_result() const { + if (is_ssl_) { + return static_cast(*cli_).get_openssl_verify_result(); + } + return -1; // NOTE: -1 doesn't match any of X509_V_ERR_??? +} + +inline SSL_CTX *Client::ssl_context() const { + if (is_ssl_) { return static_cast(*cli_).ssl_context(); } + return nullptr; +} +#endif + +// ---------------------------------------------------------------------------- + +} // namespace httplib + +#if defined(_WIN32) && defined(CPPHTTPLIB_USE_POLL) +#undef poll +#endif + +#endif // CPPHTTPLIB_HTTPLIB_H diff --git a/VideoProsessing/NetraLib/src/NetRequest.cpp b/VideoProsessing/NetraLib/src/NetRequest.cpp new file mode 100644 index 0000000..f3aa541 --- /dev/null +++ b/VideoProsessing/NetraLib/src/NetRequest.cpp @@ -0,0 +1,635 @@ +#include "NetRequest.hpp" + +#include +#include +#include +#include +#include +#include + +namespace ntq +{ + namespace + { + static std::string joinPath(const std::string &base, const std::string &path) + { + if (base.empty()) return path.empty() || path[0] == '/' ? path : std::string("/") + path; + if (path.empty()) return base[0] == '/' ? base : std::string("/") + base; + bool base_has = base.front() == '/'; + bool base_end = base.back() == '/'; + bool path_has = path.front() == '/'; + std::string b = base_has ? base : std::string("/") + base; + if (base_end && path_has) return b + path.substr(1); + if (!base_end && !path_has) return b + "/" + path; + return b + path; + } + + static std::string paramsToQuery(const httplib::Params ¶ms) + { + if (params.empty()) return {}; + std::string s; + bool first = true; + for (auto &kv : params) + { + if (!first) s += '&'; + first = false; + s += kv.first; + s += '='; + s += kv.second; + } + return s; + } + + static httplib::Headers mergeHeaders(const httplib::Headers &a, const httplib::Headers &b) + { + httplib::Headers h = a; + for (auto &kv : b) + { + // 覆盖同名 header：先删再插 + h.erase(kv.first); + h.emplace(kv.first, kv.second); + } + return h; + } + } + + class ConcurrencyGate + { + public: + explicit ConcurrencyGate(size_t limit) : limit_(limit), active_(0) {} + + void set_limit(size_t limit) + { + std::lock_guard lk(mtx_); + limit_ = limit > 0 ? limit : 1; + cv_.notify_all(); + } + + struct Guard + { + ConcurrencyGate &g; + explicit Guard(ConcurrencyGate &gate) : g(gate) { g.enter(); } + ~Guard() { g.leave(); } + }; + + private: + friend struct Guard; + void enter() + { + std::unique_lock lk(mtx_); + cv_.wait(lk, [&]{ return active_ < limit_; }); + ++active_; + } + void leave() + { + std::lock_guard lk(mtx_); + if (active_ > 0) --active_; + cv_.notify_one(); + } + + size_t limit_; + size_t active_; + std::mutex mtx_; + std::condition_variable cv_; + }; + + struct NetRequest::Impl + { + RequestOptions opts; + LogCallback logger; + Stats stats; + + // 并发控制 + ConcurrencyGate gate{4}; + + // 缓存 + struct CacheEntry + { + HttpResponse resp; + std::chrono::steady_clock::time_point expiry; + }; + bool cache_enabled = false; + std::chrono::milliseconds cache_ttl{0}; + std::unordered_map cache; + std::mutex cache_mtx; + + void log(const std::string &msg) + { + if (logger) logger(msg); + } + + template + void apply_client_options(ClientT &cli) + { + const time_t c_sec = static_cast(opts.connect_timeout_ms / 1000); + const time_t c_usec = static_cast((opts.connect_timeout_ms % 1000) * 1000); + const time_t r_sec = static_cast(opts.read_timeout_ms / 1000); + const time_t r_usec = static_cast((opts.read_timeout_ms % 1000) * 1000); + const time_t w_sec = static_cast(opts.write_timeout_ms / 1000); + const time_t w_usec = static_cast((opts.write_timeout_ms % 1000) * 1000); + cli.set_connection_timeout(c_sec, c_usec); + cli.set_read_timeout(r_sec, r_usec); + cli.set_write_timeout(w_sec, w_usec); + cli.set_keep_alive(opts.keep_alive); + } + + std::string build_full_path(const std::string &path) const + { + return joinPath(opts.base_path, path); + } + + std::string cache_key(const std::string &path, const httplib::Params ¶ms, const httplib::Headers &headers) + { + std::ostringstream oss; + oss << opts.scheme << "://" << opts.host << ':' << opts.port << build_full_path(path); + if (!params.empty()) oss << '?' << paramsToQuery(params); + for (auto &kv : headers) oss << '|' << kv.first << '=' << kv.second; + return oss.str(); + } + + void record_latency(double ms) + { + stats.last_latency_ms = ms; + const double alpha = 0.2; + if (stats.avg_latency_ms <= 0.0) stats.avg_latency_ms = ms; + else stats.avg_latency_ms = alpha * ms + (1.0 - alpha) * stats.avg_latency_ms; + } + + static ErrorCode map_error() + { + // 简化：无法区分具体错误码，统一归为 Network + return ErrorCode::Network; + } + }; + + NetRequest::NetRequest(const RequestOptions &options) + : impl_(new Impl) + { + impl_->opts = options; + if (impl_->opts.scheme == "https" && impl_->opts.port == 80) impl_->opts.port = 443; + if (impl_->opts.scheme == "http" && impl_->opts.port == 0) impl_->opts.port = 80; + } + + NetRequest::~NetRequest() + { + delete impl_; + } + + void NetRequest::setLogger(LogCallback logger) + { + impl_->logger = std::move(logger); + } + + void NetRequest::setMaxConcurrentRequests(size_t n) + { + impl_->gate.set_limit(n > 0 ? n : 1); + } + + void NetRequest::enableCache(std::chrono::milliseconds ttl) + { + impl_->cache_enabled = true; + impl_->cache_ttl = ttl.count() > 0 ? ttl : std::chrono::milliseconds(1000); + } + + void NetRequest::disableCache() + { + impl_->cache_enabled = false; + std::lock_guard lk(impl_->cache_mtx); + impl_->cache.clear(); + } + + ntq::optional NetRequest::Get(const std::string &path, + const httplib::Params &query, + const httplib::Headers &headers, + ErrorCode *err) + { + ConcurrencyGate::Guard guard(impl_->gate); + impl_->stats.total_requests++; + auto start = std::chrono::steady_clock::now(); + + if (impl_->cache_enabled) + { + std::string key = impl_->cache_key(path, query, mergeHeaders(impl_->opts.default_headers, headers)); + std::lock_guard lk(impl_->cache_mtx); + auto it = impl_->cache.find(key); + if (it != impl_->cache.end() && std::chrono::steady_clock::now() < it->second.expiry) + { + if (err) *err = ErrorCode::None; + auto resp = it->second.resp; + resp.from_cache = true; + return resp; + } + } + + ntq::optional result; + ErrorCode local_err = ErrorCode::None; + + const auto full_path = impl_->build_full_path(path); + auto merged_headers = mergeHeaders(impl_->opts.default_headers, headers); + + if (impl_->opts.scheme == "https") + { +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + httplib::SSLClient cli(impl_->opts.host.c_str(), impl_->opts.port); + impl_->apply_client_options(cli); + auto res = query.empty() ? cli.Get(full_path.c_str(), merged_headers) + : cli.Get(full_path.c_str(), query, merged_headers); + if (res) + { + HttpResponse r; + r.status = res->status; + r.body = res->body; + r.headers = res->headers; + r.from_cache = false; + result = r; + } + else + { + local_err = Impl::map_error(); + } +#else + impl_->log("HTTPS requested but OpenSSL is not enabled; falling back to error."); + local_err = ErrorCode::SSL; +#endif + } + else + { + httplib::Client cli(impl_->opts.host.c_str(), impl_->opts.port); + impl_->apply_client_options(cli); + auto res = query.empty() ? cli.Get(full_path.c_str(), merged_headers) + : cli.Get(full_path.c_str(), query, merged_headers); + if (res) + { + HttpResponse r; + r.status = res->status; + r.body = res->body; + r.headers = res->headers; + r.from_cache = false; + result = r; + } + else + { + local_err = Impl::map_error(); + } + } + + auto end = std::chrono::steady_clock::now(); + impl_->record_latency(std::chrono::duration(end - start).count()); + + if (!result.has_value()) + { + impl_->stats.total_errors++; + if (err) *err = local_err; + return ntq::nullopt; + } + + if (impl_->cache_enabled) + { + std::string key = impl_->cache_key(path, query, merged_headers); + std::lock_guard lk(impl_->cache_mtx); + impl_->cache[key] = Impl::CacheEntry{*result, std::chrono::steady_clock::now() + impl_->cache_ttl}; + } + if (err) *err = ErrorCode::None; + return result; + } + + ntq::optional NetRequest::PostJson(const std::string &path, + const std::string &json, + const httplib::Headers &headers, + ErrorCode *err) + { + ConcurrencyGate::Guard guard(impl_->gate); + impl_->stats.total_requests++; + auto start = std::chrono::steady_clock::now(); + + ntq::optional result; + ErrorCode local_err = ErrorCode::None; + + const auto full_path = impl_->build_full_path(path); + auto merged_headers = mergeHeaders(impl_->opts.default_headers, headers); + + if (impl_->opts.scheme == "https") + { +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + httplib::SSLClient cli(impl_->opts.host.c_str(), impl_->opts.port); + impl_->apply_client_options(cli); + auto res = cli.Post(full_path.c_str(), merged_headers, json, "application/json"); + if (res) + { + HttpResponse r{res->status, res->body, res->headers, false}; + result = r; + } + else + { + local_err = Impl::map_error(); + } +#else + local_err = ErrorCode::SSL; +#endif + } + else + { + httplib::Client cli(impl_->opts.host.c_str(), impl_->opts.port); + impl_->apply_client_options(cli); + auto res = cli.Post(full_path.c_str(), merged_headers, json, "application/json"); + if (res) + { + HttpResponse r{res->status, res->body, res->headers, false}; + result = r; + } + else + { + local_err = Impl::map_error(); + } + } + + auto end = std::chrono::steady_clock::now(); + impl_->record_latency(std::chrono::duration(end - start).count()); + if (!result) + { + impl_->stats.total_errors++; + if (err) *err = local_err; + return ntq::nullopt; + } + if (err) *err = ErrorCode::None; + return result; + } + + ntq::optional NetRequest::PostForm(const std::string &path, + const httplib::Params &form, + const httplib::Headers &headers, + ErrorCode *err) + { + ConcurrencyGate::Guard guard(impl_->gate); + impl_->stats.total_requests++; + auto start = std::chrono::steady_clock::now(); + + ntq::optional result; + ErrorCode local_err = ErrorCode::None; + + const auto full_path = impl_->build_full_path(path); + auto merged_headers = mergeHeaders(impl_->opts.default_headers, headers); + + if (impl_->opts.scheme == "https") + { +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + httplib::SSLClient cli(impl_->opts.host.c_str(), impl_->opts.port); + impl_->apply_client_options(cli); + auto res = cli.Post(full_path.c_str(), merged_headers, form); + if (res) + { + HttpResponse r{res->status, res->body, res->headers, false}; + result = r; + } + else + { + local_err = Impl::map_error(); + } +#else + local_err = ErrorCode::SSL; +#endif + } + else + { + httplib::Client cli(impl_->opts.host.c_str(), impl_->opts.port); + impl_->apply_client_options(cli); + auto res = cli.Post(full_path.c_str(), merged_headers, form); + if (res) + { + HttpResponse r{res->status, res->body, res->headers, false}; + result = r; + } + else + { + local_err = Impl::map_error(); + } + } + + auto end = std::chrono::steady_clock::now(); + impl_->record_latency(std::chrono::duration(end - start).count()); + if (!result) + { + impl_->stats.total_errors++; + if (err) *err = local_err; + return ntq::nullopt; + } + if (err) *err = ErrorCode::None; + return result; + } + + std::future> NetRequest::GetAsync(const std::string &path, + const httplib::Params &query, + const httplib::Headers &headers, + ErrorCode *err) + { + return std::async(std::launch::async, [this, path, query, headers, err]() mutable { + ErrorCode local; + auto r = Get(path, query, headers, &local); + if (err) *err = local; + return r; + }); + } + + std::future> NetRequest::PostJsonAsync(const std::string &path, + const std::string &json, + const httplib::Headers &headers, + ErrorCode *err) + { + return std::async(std::launch::async, [this, path, json, headers, err]() mutable { + ErrorCode local; + auto r = PostJson(path, json, headers, &local); + if (err) *err = local; + return r; + }); + } + + std::future> NetRequest::PostFormAsync(const std::string &path, + const httplib::Params &form, + const httplib::Headers &headers, + ErrorCode *err) + { + return std::async(std::launch::async, [this, path, form, headers, err]() mutable { + ErrorCode local; + auto r = PostForm(path, form, headers, &local); + if (err) *err = local; + return r; + }); + } + + bool NetRequest::DownloadToFile(const std::string &path, + const std::string &local_file, + const httplib::Headers &headers, + bool resume, + size_t /*chunk_size*/, + ErrorCode *err) + { + ConcurrencyGate::Guard guard(impl_->gate); + impl_->stats.total_requests++; + auto start = std::chrono::steady_clock::now(); + + std::ios_base::openmode mode = std::ios::binary | std::ios::out; + size_t offset = 0; + if (resume) + { + std::ifstream in(local_file, std::ios::binary | std::ios::ate); + if (in) + { + offset = static_cast(in.tellg()); + } + mode |= std::ios::app; + } + else + { + mode |= std::ios::trunc; + } + + std::ofstream out(local_file, mode); + if (!out) + { + if (err) *err = ErrorCode::IOError; + impl_->stats.total_errors++; + return false; + } + + auto merged_headers = mergeHeaders(impl_->opts.default_headers, headers); + if (resume && offset > 0) + { + merged_headers.emplace("Range", "bytes=" + std::to_string(offset) + "-"); + } + + const auto full_path = impl_->build_full_path(path); + int status_code = 0; + ErrorCode local_err = ErrorCode::None; + + auto content_receiver = [&](const char *data, size_t data_length) { + out.write(data, static_cast(data_length)); + return static_cast(out); + }; + + bool ok = false; + if (impl_->opts.scheme == "https") + { +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + httplib::SSLClient cli(impl_->opts.host.c_str(), impl_->opts.port); + impl_->apply_client_options(cli); + auto res = cli.Get(full_path.c_str(), merged_headers, content_receiver); + if (res) + { + status_code = res->status; + ok = (status_code == 200 || status_code == 206); + } + else + { + local_err = Impl::map_error(); + } +#else + local_err = ErrorCode::SSL; +#endif + } + else + { + httplib::Client cli(impl_->opts.host.c_str(), impl_->opts.port); + impl_->apply_client_options(cli); + auto res = cli.Get(full_path.c_str(), merged_headers, content_receiver); + if (res) + { + status_code = res->status; + ok = (status_code == 200 || status_code == 206); + } + else + { + local_err = Impl::map_error(); + } + } + + out.close(); + auto end = std::chrono::steady_clock::now(); + impl_->record_latency(std::chrono::duration(end - start).count()); + + if (!ok) + { + impl_->stats.total_errors++; + if (err) *err = local_err; + return false; + } + if (err) *err = ErrorCode::None; + return true; + } + + NetRequest::Stats NetRequest::getStats() const + { + return impl_->stats; + } + + // ------------------------- Quick helpers ------------------------- + namespace { + struct ParsedURL { + std::string scheme; + std::string host; + int port = 0; + std::string path_and_query; + bool ok = false; + }; + + static ParsedURL parse_url(const std::string &url) + { + ParsedURL p; p.ok = false; + // very small parser: scheme://host[:port]/path[?query] + auto pos_scheme = url.find("://"); + if (pos_scheme == std::string::npos) return p; + p.scheme = url.substr(0, pos_scheme); + size_t pos_host = pos_scheme + 3; + + size_t pos_path = url.find('/', pos_host); + std::string hostport = pos_path == std::string::npos ? url.substr(pos_host) + : url.substr(pos_host, pos_path - pos_host); + auto pos_colon = hostport.find(':'); + if (pos_colon == std::string::npos) { + p.host = hostport; + p.port = (p.scheme == "https") ? 443 : 80; + } else { + p.host = hostport.substr(0, pos_colon); + std::string port_str = hostport.substr(pos_colon + 1); + p.port = port_str.empty() ? ((p.scheme == "https") ? 443 : 80) : std::atoi(port_str.c_str()); + } + p.path_and_query = (pos_path == std::string::npos) ? "/" : url.substr(pos_path); + p.ok = !p.host.empty(); + return p; + } + } + + ntq::optional NetRequest::QuickGet(const std::string &url, + const httplib::Headers &headers, + ErrorCode *err) + { + auto p = parse_url(url); + if (!p.ok) { if (err) *err = ErrorCode::InvalidURL; return std::nullopt; } + RequestOptions opt; opt.scheme = p.scheme; opt.host = p.host; opt.port = p.port; + NetRequest req(opt); + return req.Get(p.path_and_query, {}, headers, err); + } + + ntq::optional NetRequest::QuickPostJson(const std::string &url, + const std::string &json, + const httplib::Headers &headers, + ErrorCode *err) + { + auto p = parse_url(url); + if (!p.ok) { if (err) *err = ErrorCode::InvalidURL; return std::nullopt; } + RequestOptions opt; opt.scheme = p.scheme; opt.host = p.host; opt.port = p.port; + NetRequest req(opt); + return req.PostJson(p.path_and_query, json, headers, err); + } + + ntq::optional NetRequest::QuickPostForm(const std::string &url, + const httplib::Params &form, + const httplib::Headers &headers, + ErrorCode *err) + { + auto p = parse_url(url); + if (!p.ok) { if (err) *err = ErrorCode::InvalidURL; return std::nullopt; } + RequestOptions opt; opt.scheme = p.scheme; opt.host = p.host; opt.port = p.port; + NetRequest req(opt); + return req.PostForm(p.path_and_query, form, headers, err); + } +} diff --git a/VideoProsessing/NetraLib/src/Netra.cpp b/VideoProsessing/NetraLib/src/Netra.cpp new file mode 100644 index 0000000..a67282c --- /dev/null +++ b/VideoProsessing/NetraLib/src/Netra.cpp @@ -0,0 +1,693 @@ +#include "Netra.hpp" + +namespace QCL +{ + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TcpServer::TcpServer(int port) + : port_(port), running_(false), serverSock_(-1) {} + + /** + * @brief 析构函数中调用stop()确保服务器资源被释放 + */ + TcpServer::~TcpServer() + { + stop(); + } + + /** + * @brief 启动服务器： + * 1. 创建监听socket（TCP） + * 2. 绑定端口 + * 3. 监听端口 + * 4. 启动监听线程acceptThread_ + * + * @return 成功返回true，失败返回false + */ + bool TcpServer::start() + { + // 创建socket + serverSock_ = socket(AF_INET, SOCK_STREAM, 0); + if (serverSock_ < 0) + { + std::cerr << "Socket 创建失败\n"; + return false; + } + + // 设置socket地址结构 + sockaddr_in serverAddr; + std::memset(&serverAddr, 0, sizeof(serverAddr)); + serverAddr.sin_family = AF_INET; + serverAddr.sin_port = htons(port_); // 端口转网络字节序 + serverAddr.sin_addr.s_addr = INADDR_ANY; // 监听所有网卡IP + + // 允许端口重用，防止服务器异常关闭后端口被占用 + int opt = 1; + setsockopt(serverSock_, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); + + // 绑定端口 + if (bind(serverSock_, (sockaddr *)&serverAddr, sizeof(serverAddr)) < 0) + { + std::cerr << "绑定失败\n"; + return false; + } + + // 开始监听，最大等待连接数为5 + if (listen(serverSock_, 5) < 0) + { + std::cerr << "监听失败\n"; + return false; + } + + // 设置运行标志为true + running_ = true; + + // 启动专门接受客户端连接的线程 + acceptThread_ = std::thread(&TcpServer::acceptClients, this); + + std::cout << "服务器启动，监听端口：" << port_ << std::endl; + return true; + } + + /** + * @brief 停止服务器： + * 1. 设置运行标志为false，通知线程退出 + * 2. 关闭监听socket + * 3. 关闭所有客户端socket，清理客户端列表 + * 4. 等待所有线程退出 + */ + void TcpServer::stop() + { + running_ = false; + + if (serverSock_ >= 0) + { + close(serverSock_); + serverSock_ = -1; + } + + { + // 线程安全关闭所有客户端socket + std::lock_guard lock(clientsMutex_); + for (int sock : clientSockets_) + { + close(sock); + } + clientSockets_.clear(); + } + + // 等待监听线程退出 + if (acceptThread_.joinable()) + acceptThread_.join(); + + // 等待所有客户端处理线程退出 + for (auto &t : clientThreads_) + { + if (t.joinable()) + t.join(); + } + + std::cout << "服务器已停止\n"; + } + + /** + * @brief acceptClients函数循环监听客户端连接请求 + * 每当accept成功： + * 1. 打印客户端IP和Socket信息 + * 2. 线程安全地将客户端Socket加入clientSockets_列表 + * 3. 创建新线程调用handleClient处理该客户端收发 + */ + void TcpServer::acceptClients() + { + while (running_) + { + sockaddr_in clientAddr; + socklen_t clientLen = sizeof(clientAddr); + int clientSock = accept(serverSock_, (sockaddr *)&clientAddr, &clientLen); + if (clientSock < 0) + { + if (running_) + std::cerr << "接受连接失败\n"; + continue; + } + + // 将客户端IP转换成字符串格式打印 + char clientIP[INET_ADDRSTRLEN]; + inet_ntop(AF_INET, &(clientAddr.sin_addr), clientIP, INET_ADDRSTRLEN); + std::cout << "客户端连接，IP: " << clientIP << ", Socket: " << clientSock << std::endl; + + { + // 加锁保护共享的clientSockets_容器 + std::lock_guard lock(clientsMutex_); + clientSockets_.push_back(clientSock); + } + } + } + + /** + * @brief 发送消息给指定客户端 + * @param clientSock 客户端socket + * @param message 发送消息内容 + */ + void TcpServer::sendToClient(int clientSock, const std::string &message) + { + send(clientSock, message.c_str(), message.size(), 0); + } + + /** + * @brief 单次接收指定客户端数据 + * @param clientSock 客户端socket + */ + std::string TcpServer::receiveFromClient(int clientSock, bool flag) + { + char buffer[1024]; + std::memset(buffer, 0, sizeof(buffer)); + + int flags = flag ? 0 : MSG_DONTWAIT; + ssize_t bytesReceived = recv(clientSock, buffer, sizeof(buffer) - 1, flags); + + if (bytesReceived <= 0) + return {}; + + return std::string(buffer, bytesReceived); + } + + /** + * @brief 获取当前所有客户端Socket副本（线程安全） + * @return 包含所有客户端socket的vector副本 + */ + std::vector TcpServer::getClientSockets() + { + std::lock_guard lock(clientsMutex_); + return clientSockets_; + } + + void TcpServer::removeClient(int clientSock) + { + std::lock_guard lock(clientsMutex_); + for (auto it = clientSockets_.begin(); it != clientSockets_.end(); ++it) + { + if (*it == clientSock) + { + close(*it); + clientSockets_.erase(it); + break; + } + } + } + + bool TcpServer::isClientDisconnected(int clientSock) + { + char tmp; + ssize_t n = recv(clientSock, &tmp, 1, MSG_PEEK | MSG_DONTWAIT); + if (n == 0) + return true; // 对端有序关闭 + if (n < 0) + { + if (errno == EAGAIN || errno == EWOULDBLOCK) + return false; // 只是暂时无数据 + return true; // 其它错误视为断开 + } + return false; // 有数据可读 + } + + /** + * @brief 获取连接客户端的IP和端口 + * @param clientSock 客户端Socket描述符 + */ + char *TcpServer::getClientIPAndPort(int clientSock) + { + struct sockaddr_in addr; + socklen_t addr_size = sizeof(addr); + + // 获取客户端地址信息 + if (getpeername(clientSock, (struct sockaddr *)&addr, &addr_size) == -1) + { + perror("getpeername failed"); + return NULL; + } + + // 分配内存存储结果(格式: "IP:PORT") + char *result = (char *)malloc(INET_ADDRSTRLEN + 10); + if (!result) + return NULL; + + // 转换IP和端口 + char *ip = inet_ntoa(addr.sin_addr); + unsigned short port = ntohs(addr.sin_port); + + snprintf(result, INET_ADDRSTRLEN + 10, "%s:%d", ip, port); + return result; + } + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + WriteFile::WriteFile(const std::string &filePath) + : filePath_(filePath) {} + + /** + * @brief 覆盖写文本（线程安全） + */ + bool WriteFile::overwriteText(const std::string &content) + { + std::lock_guard lock(writeMutex_); // 加锁 + return writeToFile(content, std::ios::out | std::ios::trunc); + } + + /** + * @brief 追加写文本（线程安全） + */ + bool WriteFile::appendText(const std::string &content) + { + std::lock_guard lock(writeMutex_); + return writeToFile(content, std::ios::out | std::ios::app); + } + + /** + * @brief 覆盖写二进制（线程安全） + */ + bool WriteFile::overwriteBinary(const std::vector &data) + { + std::lock_guard lock(writeMutex_); + return writeBinary(data, std::ios::out | std::ios::trunc | std::ios::binary); + } + + /** + * @brief 追加写二进制（线程安全） + */ + bool WriteFile::appendBinary(const std::vector &data) + { + std::lock_guard lock(writeMutex_); + return writeBinary(data, std::ios::out | std::ios::app | std::ios::binary); + } + + /** + * @brief 通用文本写入（私有） + */ + bool WriteFile::writeToFile(const std::string &content, std::ios::openmode mode) + { + std::ofstream file(filePath_, mode); + if (!file.is_open()) + return false; + file << content; + file.close(); + return true; + } + + /** + * @brief 通用二进制写入（私有） + */ + bool WriteFile::writeBinary(const std::vector &data, std::ios::openmode mode) + { + std::ofstream file(filePath_, mode); + if (!file.is_open()) + return false; + file.write(data.data(), data.size()); + file.close(); + return true; + } + + size_t WriteFile::countBytesPattern(const std::string &pattern, bool includePattern) + { + std::lock_guard lock(writeMutex_); + + if (pattern.empty()) + return 0; + + std::ifstream file(filePath_, std::ios::binary); + if (!file.is_open()) + return 0; + + const size_t chunkSize = 4096; + std::string buffer; + buffer.reserve(chunkSize * 2); + + size_t totalRead = 0; + char chunk[chunkSize]; + + while (file.read(chunk, chunkSize) || file.gcount() > 0) + { + size_t bytesRead = file.gcount(); + buffer.append(chunk, bytesRead); + + size_t pos = buffer.find(pattern); + if (pos != std::string::npos) + { + size_t absolutePos = totalRead + pos; // 关键：加上 totalRead + return includePattern ? (absolutePos + pattern.size()) : absolutePos; + } + + if (buffer.size() > pattern.size()) + buffer.erase(0, buffer.size() - pattern.size()); + + totalRead += bytesRead; // 读完后再累计 + } + + return 0; + } + + bool WriteFile::writeAfterPatternOrAppend(const std::string &pattern, const std::string &content) + { + std::lock_guard lock(writeMutex_); + + // 读取整个文件 + std::ifstream in(filePath_, std::ios::binary); + if (!in.is_open()) + return false; + + std::string fileData((std::istreambuf_iterator(in)), {}); + in.close(); + + size_t pos = fileData.find(pattern); + if (pos != std::string::npos) + { + // 模式存在，插入位置在模式结尾 + pos += pattern.size(); + + // 删除模式后所有内容 + if (pos < fileData.size()) + fileData.erase(pos); + + // 插入新内容 + fileData.insert(pos, content); + } + else + { + // 模式不存在，直接追加到文件末尾 + if (!fileData.empty() && fileData.back() != '\n') + fileData += '\n'; // 保证换行 + fileData += content; + } + + // 写回文件 + std::ofstream out(filePath_, std::ios::binary | std::ios::trunc); + if (!out.is_open()) + return false; + + out.write(fileData.data(), fileData.size()); + return true; + } + + bool WriteFile::overwriteAtPos(const std::string &content, size_t pos, size_t length) + { + std::lock_guard lock(writeMutex_); + + // 打开文件读取 + std::ifstream in(filePath_, std::ios::binary); + if (!in.is_open()) + return false; + + std::string fileData((std::istreambuf_iterator(in)), {}); + in.close(); + + // 边界检查 + if (pos >= fileData.size()) + return false; // pos 超过文件范围，无法覆盖 + + // 生成要覆盖的实际数据块 + std::string overwriteBlock; + if (content.size() >= length) + { + overwriteBlock = content.substr(0, length); + } + else + { + overwriteBlock = content; + overwriteBlock.append(length - content.size(), '\0'); // 补齐 + } + + // 计算实际可写范围 + size_t maxWritable = std::min(length, fileData.size() - pos); + + // 覆盖 + fileData.replace(pos, maxWritable, overwriteBlock.substr(0, maxWritable)); + + // 写回文件 + std::ofstream out(filePath_, std::ios::binary | std::ios::trunc); + if (!out.is_open()) + return false; + + out.write(fileData.data(), fileData.size()); + return true; + } + + bool WriteFile::insertAfterPos(const std::string &content, size_t pos, size_t length) + { + std::lock_guard lock(writeMutex_); + + // 打开文件读取 + std::ifstream in(filePath_, std::ios::binary); + if (!in.is_open()) + return false; + + std::string fileData((std::istreambuf_iterator(in)), {}); + in.close(); + + // 边界检查 + if (pos > fileData.size()) + pos = fileData.size(); // 如果 pos 超出范围，就视为文件末尾 + + // 生成要插入的实际数据块 + std::string insertBlock; + if (content.size() >= length) + { + insertBlock = content.substr(0, length); // 只取前 length 个字节 + } + else + { + insertBlock = content; // 全部内容 + insertBlock.append(length - content.size(), '\0'); // 补足空字节 + } + + // 插入到 pos 后面 + fileData.insert(pos + 1, insertBlock); + + // 写回文件 + std::ofstream out(filePath_, std::ios::binary | std::ios::trunc); + if (!out.is_open()) + return false; + + out.write(fileData.data(), fileData.size()); + return true; + } + + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + ReadFile::ReadFile(const std::string &filename) : filename_(filename) {} + + ReadFile::~ReadFile() + { + std::lock_guard lock(mtx_); + Close(); + } + + bool ReadFile::Open() + { + std::lock_guard lock(mtx_); + if (file_.is_open()) + file_.close(); + file_.open(filename_, std::ios::in | std::ios::binary); + return file_.is_open(); + } + + void ReadFile::Close() + { + if (file_.is_open()) + { + std::lock_guard lock(mtx_); + file_.close(); + } + } + + bool ReadFile::IsOpen() const + { + std::lock_guard lock(mtx_); + return file_.is_open(); + } + + std::string ReadFile::ReadAllText() + { + std::lock_guard lock(mtx_); + if (!file_.is_open() && !Open()) + return ""; + + std::ostringstream ss; + ss << file_.rdbuf(); + return ss.str(); + } + + std::vector ReadFile::ReadAllBinary() + { + std::lock_guard lock(mtx_); + if (!file_.is_open() && !Open()) + return {}; + + return ReadBytes(GetFileSize()); + } + + std::vector ReadFile::ReadLines() + { + // std::lock_guard lock(mtx_); + // if (!file_.is_open() && !Open()) + // return {}; + + // std::vector lines; + // std::string line; + // while (std::getline(file_, line)) + // { + // lines.push_back(line); + // } + // return lines; + + // std::lock_guard lock(mtx_); + if (!file_.is_open()) { + file_.open(filename_, std::ios::in | std::ios::binary); + if (!file_.is_open()) return {}; + } + file_.clear(); + file_.seekg(0, std::ios::beg); + + std::vector lines; + std::string line; + while (std::getline(file_, line)) lines.push_back(line); + return lines; + } + + std::vector ReadFile::ReadBytes(size_t count) + { + std::lock_guard lock(mtx_); + if (!file_.is_open() && !Open()) + return {}; + + std::vector buffer(count); + file_.read(buffer.data(), count); + buffer.resize(file_.gcount()); + return buffer; + } + + size_t ReadFile::GetBytesBefore(const std::string &marker, bool includeMarker) + { + std::lock_guard lock(mtx_); + + if (!file_.is_open() && !Open()) + return 0; + + file_.clear(); // 清除EOF和错误状态 + file_.seekg(0, std::ios::beg); // 回到文件开头 + + const size_t chunkSize = 4096; + std::string buffer; + buffer.reserve(chunkSize * 2); + + size_t totalRead = 0; + char chunk[chunkSize]; + + while (file_.read(chunk, chunkSize) || file_.gcount() > 0) + { + buffer.append(chunk, file_.gcount()); + size_t pos = buffer.find(marker); + if (pos != std::string::npos) + { + // 如果 includeMarker 为 true，返回包含 marker 的长度 + if (includeMarker) + return pos + marker.size(); + else + return pos; + } + + // 保留末尾部分，避免 buffer 无限增长 + if (buffer.size() > marker.size()) + buffer.erase(0, buffer.size() - marker.size()); + + totalRead += file_.gcount(); + } + + return 0; + } + + std::vector ReadFile::ReadBytesFrom(size_t pos, size_t count) + { + std::lock_guard lock(mtx_); + + if (!file_.is_open() && !Open()) + return {}; + + size_t filesize = GetFileSize(); + if (pos >= filesize) + return {}; // 起始位置超出文件大小 + + file_.clear(); // 清除 EOF 和错误状态 + file_.seekg(pos, std::ios::beg); + if (!file_) + return {}; + + size_t bytes_to_read = count; + if (count == 0 || pos + count > filesize) + bytes_to_read = filesize - pos; // 读取到文件末尾 + + std::vector buffer(bytes_to_read); + file_.read(buffer.data(), bytes_to_read); + + // 实际读取的字节数可能少于请求的数量 + buffer.resize(file_.gcount()); + + return buffer; + } + + bool ReadFile::FileExists() const + { + return std::filesystem::exists(filename_); + } + + size_t ReadFile::GetFileSize() const + { + if (!FileExists()) + return 0; + return std::filesystem::file_size(filename_); + } + + void ReadFile::Reset() + { + std::lock_guard lock(mtx_); + if (file_.is_open()) + { + file_.clear(); + file_.seekg(0, std::ios::beg); + } + } + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + // 屏蔽所有信号 + void blockAllSignals() + { + // 忽略全部的信号 + for (int ii = 1; ii <= 64; ii++) + signal(ii, SIG_IGN); + } + + std::string Ltrim(const std::string &s) + { + size_t start = 0; + while (start < s.size() && std::isspace(static_cast(s[start]))) + { + ++start; + } + return s.substr(start); + } + + std::string Rtrim(const std::string &s) + { + if (s.empty()) + return s; + + size_t end = s.size(); + while (end > 0 && std::isspace(static_cast(s[end - 1]))) + { + --end; + } + return s.substr(0, end); + } + + std::string LRtrim(const std::string &s) + { + return Ltrim(Rtrim(s)); + } + + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +} \ No newline at end of file diff --git a/VideoProsessing/NetraLib/src/encrypt.cpp b/VideoProsessing/NetraLib/src/encrypt.cpp new file mode 100644 index 0000000..a8aea93 --- /dev/null +++ b/VideoProsessing/NetraLib/src/encrypt.cpp @@ -0,0 +1,91 @@ +#include "encrypt.hpp" +#include + +namespace encrypt +{ + string MD5(const string &info) + { + auto leftrotate = [](uint32_t x, uint32_t c) -> uint32_t { return (x << c) | (x >> (32 - c)); }; + + static const uint32_t s[64] = { + 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, + 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, + 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, + 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21 + }; + static const uint32_t K[64] = { + 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501, + 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821, + 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8, + 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a, + 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70, + 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665, + 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1, + 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391 + }; + + uint32_t a0 = 0x67452301; + uint32_t b0 = 0xefcdab89; + uint32_t c0 = 0x98badcfe; + uint32_t d0 = 0x10325476; + + std::vector msg(info.begin(), info.end()); + uint64_t bit_len = static_cast(msg.size()) * 8ULL; + msg.push_back(0x80); + while ((msg.size() % 64) != 56) msg.push_back(0x00); + for (int i = 0; i < 8; ++i) msg.push_back(static_cast((bit_len >> (8 * i)) & 0xff)); + + for (size_t offset = 0; offset < msg.size(); offset += 64) + { + uint32_t M[16]; + for (int i = 0; i < 16; ++i) + { + size_t j = offset + i * 4; + M[i] = static_cast(msg[j]) | + (static_cast(msg[j + 1]) << 8) | + (static_cast(msg[j + 2]) << 16) | + (static_cast(msg[j + 3]) << 24); + } + + uint32_t A = a0, B = b0, C = c0, D = d0; + for (uint32_t i = 0; i < 64; ++i) + { + uint32_t F, g; + if (i < 16) { F = (B & C) | ((~B) & D); g = i; } + else if (i < 32) { F = (D & B) | ((~D) & C); g = (5 * i + 1) % 16; } + else if (i < 48) { F = B ^ C ^ D; g = (3 * i + 5) % 16; } + else { F = C ^ (B | (~D)); g = (7 * i) % 16; } + + F = F + A + K[i] + M[g]; + A = D; + D = C; + C = B; + B = B + leftrotate(F, s[i]); + } + + a0 += A; b0 += B; c0 += C; d0 += D; + } + + uint8_t digest[16]; + auto u32_to_le = [](uint32_t v, uint8_t out[4]) { + out[0] = static_cast(v & 0xff); + out[1] = static_cast((v >> 8) & 0xff); + out[2] = static_cast((v >> 16) & 0xff); + out[3] = static_cast((v >> 24) & 0xff); + }; + u32_to_le(a0, digest + 0); + u32_to_le(b0, digest + 4); + u32_to_le(c0, digest + 8); + u32_to_le(d0, digest + 12); + + static const char *hex = "0123456789abcdef"; + std::string out; + out.resize(32); + for (int i = 0; i < 16; ++i) + { + out[i * 2] = hex[(digest[i] >> 4) & 0x0f]; + out[i * 2 + 1] = hex[digest[i] & 0x0f]; + } + return out; + } +} \ No newline at end of file diff --git a/VideoProsessing/bin/video b/VideoProsessing/bin/video index 3eb45bcd4c829f11e9a7a6f1d512f832facd23d8..8a4a671b2e53f4dd8fdb27a5bcdb30bf54f8bd17 100755 GIT binary patch literal 2650104 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

f&fJ~JzL#J-Q!4|UGwlpkg8 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�h_BIy{d4@Y1cKTQZnmHSSY{>tJ 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�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