更新 src/Netra.cpp

README.md

@@ -34,3 +34,95 @@ c/c++基本开发库
 支持格式化输出
 
 
+# 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);
+```

include/NetRequest.hpp

@@ -20,10 +20,96 @@
 #include "httplib.h"
 #include <string>
 #include <functional>
-#include <optional>
 #include <future>
 #include <chrono>
 
+// C++17/14 可选类型回退适配：统一使用 ntq::optional / ntq::nullopt
+#if defined(__has_include)
+  #if __has_include(<optional>)
+    #include <optional>
+    // 仅当启用了 C++17 或库声明了 optional 功能时，才使用 std::optional
+    #if defined(__cpp_lib_optional) || (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+      namespace ntq { template <typename T> using optional = std::optional<T>; }
+      namespace ntq { constexpr auto nullopt = std::nullopt; using nullopt_t = decltype(std::nullopt); }
+    #elif __has_include(<experimental/optional>)
+      #include <experimental/optional>
+      namespace ntq { template <typename T> using optional = std::experimental::optional<T>; }
+      namespace ntq { constexpr auto nullopt = std::experimental::nullopt; using nullopt_t = decltype(std::experimental::nullopt); }
+    #else
+      #include <utility>
+      namespace ntq {
+        struct nullopt_t { explicit constexpr nullopt_t(int) {} };
+        static constexpr nullopt_t nullopt{0};
+        template <typename T>
+        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(<experimental/optional>)
+    #include <experimental/optional>
+    namespace ntq { template <typename T> using optional = std::experimental::optional<T>; }
+    namespace ntq { constexpr auto nullopt = std::experimental::nullopt; using nullopt_t = decltype(std::experimental::nullopt); }
+  #else
+    #include <utility>
+    namespace ntq {
+      struct nullopt_t { explicit constexpr nullopt_t(int) {} };
+      static constexpr nullopt_t nullopt{0};
+      template <typename T>
+      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 <optional>
+    namespace ntq { template <typename T> using optional = std::optional<T>; }
+    namespace ntq { constexpr auto nullopt = std::nullopt; using nullopt_t = decltype(std::nullopt); }
+  #else
+    #include <experimental/optional>
+    namespace ntq { template <typename T> using optional = std::experimental::optional<T>; }
+    namespace ntq { constexpr auto nullopt = std::experimental::nullopt; using nullopt_t = decltype(std::experimental::nullopt); }
+  #endif
+#endif
+
 namespace ntq
 {
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -137,7 +223,7 @@ namespace ntq
          * @param err 可选错误码输出
          * @return 成功返回响应对象，失败返回 std::nullopt
          */
-        std::optional<HttpResponse> Get(const std::string &path,
+        ntq::optional<HttpResponse> Get(const std::string &path,
                                         const httplib::Params &query = {},
                                         const httplib::Headers &headers = {},
                                         ErrorCode *err = nullptr);
@@ -150,7 +236,7 @@ namespace ntq
          * @param err 可选错误码输出
          * @return 成功返回响应对象，失败返回 std::nullopt
          */
-        std::optional<HttpResponse> PostJson(const std::string &path,
+        ntq::optional<HttpResponse> PostJson(const std::string &path,
                                              const std::string &json,
                                              const httplib::Headers &headers = {},
                                              ErrorCode *err = nullptr);
@@ -163,7 +249,7 @@ namespace ntq
          * @param err 可选错误码输出
          * @return 成功返回响应对象，失败返回 std::nullopt
          */
-        std::optional<HttpResponse> PostForm(const std::string &path,
+        ntq::optional<HttpResponse> PostForm(const std::string &path,
                                              const httplib::Params &form,
                                              const httplib::Headers &headers = {},
                                              ErrorCode *err = nullptr);
@@ -172,7 +258,7 @@ namespace ntq
          * @brief 异步 GET 请求
          * @return std::future，用于获取响应结果
          */
-        std::future<std::optional<HttpResponse>> GetAsync(const std::string &path,
+        std::future<ntq::optional<HttpResponse>> GetAsync(const std::string &path,
                                                           const httplib::Params &query = {},
                                                           const httplib::Headers &headers = {},
                                                           ErrorCode *err = nullptr);
@@ -181,7 +267,7 @@ namespace ntq
          * @brief 异步 POST JSON 请求
          * @return std::future，用于获取响应结果
          */
-        std::future<std::optional<HttpResponse>> PostJsonAsync(const std::string &path,
+        std::future<ntq::optional<HttpResponse>> PostJsonAsync(const std::string &path,
                                                                const std::string &json,
                                                                const httplib::Headers &headers = {},
                                                                ErrorCode *err = nullptr);
@@ -190,7 +276,7 @@ namespace ntq
          * @brief 异步 POST 表单请求
          * @return std::future，用于获取响应结果
          */
-        std::future<std::optional<HttpResponse>> PostFormAsync(const std::string &path,
+        std::future<ntq::optional<HttpResponse>> PostFormAsync(const std::string &path,
                                                                const httplib::Params &form,
                                                                const httplib::Headers &headers = {},
                                                                ErrorCode *err = nullptr);
@@ -217,6 +303,40 @@ namespace ntq
          */
         Stats getStats() const;
 
+        /**
+         * @brief 便捷：直接用完整 URL 发起 GET（无需显式实例化）
+         * @param url 形如 http://host:port/path?x=1 或 https://host/path
+         * @param headers 额外头部
+         * @param err 可选错误码输出
+         */
+        static ntq::optional<HttpResponse> 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<HttpResponse> 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<HttpResponse> QuickPostForm(const std::string &url,
+                                                         const httplib::Params &form,
+                                                         const httplib::Headers &headers = {},
+                                                         ErrorCode *err = nullptr);
+
     private:
         struct Impl;
         Impl *impl_;

include/Netra.hpp

@@ -57,6 +57,19 @@ namespace QCL
          */
         char *getClientIPAndPort(int clientSock);
 
+        /**
+         * @brief 从服务器的客户端列表中移除并关闭一个客户端socket
+         * @param clientSock 客户端Socket描述符
+         */
+        void removeClient(int clientSock);
+        
+        /**
+         * @brief 非阻塞探测客户端是否已断开（不消耗数据）
+         * @param clientSock 客户端Socket描述符
+         * @return true 已断开或发生致命错误；false 仍然存活或暂无数据
+         */
+        bool isClientDisconnected(int clientSock);
+
         /**
          * @brief 获取当前所有已连接客户端Socket的副本
          * @return 包含所有客户端Socket的vector，线程安全
@@ -78,6 +91,83 @@ namespace QCL
         std::mutex clientsMutex_;                ///< 保护clientSockets_的互斥锁
         std::vector<int> clientSockets_;         ///< 当前所有连接的客户端Socket集合
     };
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    /**
+     * @class TcpClient
+     * @brief 简单的TCP客户端类，支持自动连接、消息收发及断线重连
+     *
+     * 该类用于连接指定服务器IP与端口，
+     * 支持发送与接收字符串消息，
+     * 并提供自动重连与线程安全的消息接收。
+     */
+    class TcpClient
+    {
+    public:
+        /**
+         * @brief 构造函数，指定服务器IP与端口
+         * @param serverIP 服务器IP地址
+         * @param serverPort 服务器端口号
+         */
+        TcpClient(const std::string &serverIP, int serverPort);
+
+        /**
+         * @brief 析构函数，自动断开连接并清理资源
+         */
+        ~TcpClient();
+
+        /**
+         * @brief 连接服务器
+         * @return 连接成功返回true，失败返回false
+         */
+        bool connectToServer();
+
+        /**
+         * @brief 断开与服务器的连接
+         */
+        void disconnect();
+
+        /**
+         * @brief 向服务器发送字符串消息
+         * @param message 要发送的字符串
+         */
+        void sendToServer(const std::string &message);
+
+        /**
+         * @brief 从服务器接收数据（单次调用）
+         * @param flag false: 非阻塞模式, true: 阻塞模式
+         * @return 收到的数据字符串（若无数据返回空字符串）
+         */
+        std::string receiveFromServer(bool flag = true);
+
+        /**
+         * @brief 获取当前连接的服务器IP和端口
+         * @return 字符串形式的 "IP:Port"
+         */
+        std::string getServerIPAndPort() const;
+
+        /**
+         * @brief 判断客户端当前是否已连接
+         * @return 已连接返回true，否则返回false
+         */
+        bool isConnected() const;
+
+    private:
+        /**
+         * @brief 尝试自动重连服务器（可选）
+         * @param retryIntervalMs 重连间隔，单位毫秒
+         */
+        void reconnectLoop(int retryIntervalMs = 3000);
+
+    private:
+        int clientSock_;                 ///< 客户端Socket描述符
+        std::string serverIP_;           ///< 服务器IP地址
+        int serverPort_;                 ///< 服务器端口号
+        std::atomic<bool> connected_;    ///< 连接状态标志（线程安全）
+        std::atomic<bool> running_;      ///< 是否保持运行（用于自动重连）
+        std::thread reconnectThread_;    ///< 自动重连线程（可选）
+        mutable std::mutex socketMutex_; ///< 保护socket的互斥锁
+    };
+
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * @brief 文件写入工具类（线程安全）

include/encrypt.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+/*
+主要是用于各种加密
+*/
+
+#include "QCL_Include.hpp"
+
+using namespace std;
+
+namespace encrypt
+{
+    string MD5(const string &info);
+}

src/NetRequest.cpp

@@ -198,7 +198,7 @@ namespace ntq
         impl_->cache.clear();
     }
 
-    std::optional<HttpResponse> NetRequest::Get(const std::string &path,
+    ntq::optional<HttpResponse> NetRequest::Get(const std::string &path,
                                                 const httplib::Params &query,
                                                 const httplib::Headers &headers,
                                                 ErrorCode *err)
@@ -221,7 +221,7 @@ namespace ntq
             }
         }
 
-        std::optional<HttpResponse> result;
+        ntq::optional<HttpResponse> result;
         ErrorCode local_err = ErrorCode::None;
 
         const auto full_path = impl_->build_full_path(path);
@@ -280,7 +280,7 @@ namespace ntq
         {
             impl_->stats.total_errors++;
             if (err) *err = local_err;
-            return std::nullopt;
+            return ntq::nullopt;
         }
 
         if (impl_->cache_enabled)
@@ -293,7 +293,7 @@ namespace ntq
         return result;
     }
 
-    std::optional<HttpResponse> NetRequest::PostJson(const std::string &path,
+    ntq::optional<HttpResponse> NetRequest::PostJson(const std::string &path,
                                                      const std::string &json,
                                                      const httplib::Headers &headers,
                                                      ErrorCode *err)
@@ -302,7 +302,7 @@ namespace ntq
         impl_->stats.total_requests++;
         auto start = std::chrono::steady_clock::now();
 
-        std::optional<HttpResponse> result;
+        ntq::optional<HttpResponse> result;
         ErrorCode local_err = ErrorCode::None;
 
         const auto full_path = impl_->build_full_path(path);
@@ -349,13 +349,13 @@ namespace ntq
         {
             impl_->stats.total_errors++;
             if (err) *err = local_err;
-            return std::nullopt;
+            return ntq::nullopt;
         }
         if (err) *err = ErrorCode::None;
         return result;
     }
 
-    std::optional<HttpResponse> NetRequest::PostForm(const std::string &path,
+    ntq::optional<HttpResponse> NetRequest::PostForm(const std::string &path,
                                                      const httplib::Params &form,
                                                      const httplib::Headers &headers,
                                                      ErrorCode *err)
@@ -364,7 +364,7 @@ namespace ntq
         impl_->stats.total_requests++;
         auto start = std::chrono::steady_clock::now();
 
-        std::optional<HttpResponse> result;
+        ntq::optional<HttpResponse> result;
         ErrorCode local_err = ErrorCode::None;
 
         const auto full_path = impl_->build_full_path(path);
@@ -411,13 +411,13 @@ namespace ntq
         {
             impl_->stats.total_errors++;
             if (err) *err = local_err;
-            return std::nullopt;
+            return ntq::nullopt;
         }
         if (err) *err = ErrorCode::None;
         return result;
     }
 
-    std::future<std::optional<HttpResponse>> NetRequest::GetAsync(const std::string &path,
+    std::future<ntq::optional<HttpResponse>> NetRequest::GetAsync(const std::string &path,
                                                                   const httplib::Params &query,
                                                                   const httplib::Headers &headers,
                                                                   ErrorCode *err)
@@ -430,7 +430,7 @@ namespace ntq
         });
     }
 
-    std::future<std::optional<HttpResponse>> NetRequest::PostJsonAsync(const std::string &path,
+    std::future<ntq::optional<HttpResponse>> NetRequest::PostJsonAsync(const std::string &path,
                                                                        const std::string &json,
                                                                        const httplib::Headers &headers,
                                                                        ErrorCode *err)
@@ -443,7 +443,7 @@ namespace ntq
         });
     }
 
-    std::future<std::optional<HttpResponse>> NetRequest::PostFormAsync(const std::string &path,
+    std::future<ntq::optional<HttpResponse>> NetRequest::PostFormAsync(const std::string &path,
                                                                        const httplib::Params &form,
                                                                        const httplib::Headers &headers,
                                                                        ErrorCode *err)
@@ -560,4 +560,76 @@ namespace ntq
     {
         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<HttpResponse> 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<HttpResponse> 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<HttpResponse> 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);
+    }
 }

src/Netra.cpp

@@ -171,6 +171,35 @@ namespace QCL
         return std::string(buffer, bytesReceived);
     }
 
+    void TcpServer::removeClient(int clientSock)
+    {
+        std::lock_guard<std::mutex> 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 获取当前所有客户端Socket副本（线程安全）
      * @return 包含所有客户端socket的vector副本
@@ -210,6 +239,123 @@ namespace QCL
         return result;
     }
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    TcpClient::TcpClient(const std::string &serverIP, int serverPort)
+        : serverIP_(serverIP), serverPort_(serverPort), clientSock_(-1),
+          connected_(false), running_(false)
+    {
+    }
+
+    TcpClient::~TcpClient()
+    {
+        disconnect();
+    }
+
+    bool TcpClient::connectToServer()
+    {
+        std::lock_guard<std::mutex> lock(socketMutex_);
+
+        clientSock_ = socket(AF_INET, SOCK_STREAM, 0);
+        if (clientSock_ < 0)
+        {
+            perror("Socket creation failed");
+            return false;
+        }
+
+        sockaddr_in serverAddr{};
+        serverAddr.sin_family = AF_INET;
+        serverAddr.sin_port = htons(serverPort_);
+        if (inet_pton(AF_INET, serverIP_.c_str(), &serverAddr.sin_addr) <= 0)
+        {
+            perror("Invalid address");
+            close(clientSock_);
+            return false;
+        }
+
+        if (connect(clientSock_, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) < 0)
+        {
+            perror("Connection failed");
+            close(clientSock_);
+            return false;
+        }
+
+        connected_ = true;
+        running_ = true;
+        std::cout << "Connected to server " << serverIP_ << ":" << serverPort_ << std::endl;
+        return true;
+    }
+
+    void TcpClient::disconnect()
+    {
+        std::lock_guard<std::mutex> lock(socketMutex_);
+        running_ = false;
+        if (connected_)
+        {
+            close(clientSock_);
+            connected_ = false;
+            std::cout << "Disconnected from server" << std::endl;
+        }
+    }
+
+    void TcpClient::sendToServer(const std::string &message)
+    {
+        std::lock_guard<std::mutex> lock(socketMutex_);
+        if (!connected_)
+            return;
+
+        ssize_t bytesSent = send(clientSock_, message.c_str(), message.size(), 0);
+        if (bytesSent <= 0)
+        {
+            perror("Send failed");
+            connected_ = false;
+        }
+    }
+
+    std::string TcpClient::receiveFromServer(bool flag)
+    {
+        std::lock_guard<std::mutex> lock(socketMutex_);
+        if (!connected_)
+            return "";
+
+        char buffer[1024] = {0};
+        int flags = flag ? 0 : MSG_DONTWAIT;
+        ssize_t bytesRead = recv(clientSock_, buffer, sizeof(buffer) - 1, flags);
+        if (bytesRead <= 0)
+        {
+            if (bytesRead < 0 && errno == EAGAIN)
+                return ""; // 非阻塞下无数据
+            connected_ = false;
+            perror("Receive failed");
+            return "";
+        }
+        return std::string(buffer, bytesRead);
+    }
+
+    std::string TcpClient::getServerIPAndPort() const
+    {
+        return serverIP_ + ":" + std::to_string(serverPort_);
+    }
+
+    bool TcpClient::isConnected() const
+    {
+        return connected_;
+    }
+
+    void TcpClient::reconnectLoop(int retryIntervalMs)
+    {
+        while (running_)
+        {
+            if (!connected_)
+            {
+                std::cout << "Attempting to reconnect..." << std::endl;
+                if (connectToServer())
+                {
+                    std::cout << "Reconnected successfully!" << std::endl;
+                }
+            }
+            std::this_thread::sleep_for(std::chrono::milliseconds(retryIntervalMs));
+        }
+    }
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     WriteFile::WriteFile(const std::string &filePath)
         : filePath_(filePath) {}
 
@@ -314,7 +460,7 @@ namespace QCL
         return 0;
     }
 
-        bool WriteFile::writeAfterPatternOrAppend(const std::string &pattern, const std::string &content)
+    bool WriteFile::writeAfterPatternOrAppend(const std::string &pattern, const std::string &content)
     {
         std::lock_guard<std::mutex> lock(writeMutex_);
 
@@ -494,16 +640,32 @@ namespace QCL
 
     std::vector<std::string> ReadFile::ReadLines()
     {
+        // std::lock_guard<std::mutex> lock(mtx_);
+        // if (!file_.is_open() && !Open())
+        //     return {};
+
+        // std::vector<std::string> lines;
+        // std::string line;
+        // while (std::getline(file_, line))
+        // {
+        //     lines.push_back(line);
+        // }
+        // return lines;
+
         std::lock_guard<std::mutex> lock(mtx_);
-        if (!file_.is_open() && !Open())
+        if (!file_.is_open())
-            return {};
+        {
+            file_.open(filename_, std::ios::in | std::ios::binary);
+            if (!file_.is_open())
+                return {};
+        }
+        file_.clear();
+        file_.seekg(0, std::ios::beg);
 
         std::vector<std::string> lines;
         std::string line;
         while (std::getline(file_, line))
-        {
             lines.push_back(line);
-        }
         return lines;
     }
 

src/encrypt.cpp

@@ -0,0 +1,91 @@
+#include "encrypt.hpp"
+#include <vector>
+
+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<uint8_t> msg(info.begin(), info.end());
+        uint64_t bit_len = static_cast<uint64_t>(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<uint8_t>((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<uint32_t>(msg[j]) |
+                       (static_cast<uint32_t>(msg[j + 1]) << 8) |
+                       (static_cast<uint32_t>(msg[j + 2]) << 16) |
+                       (static_cast<uint32_t>(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<uint8_t>(v & 0xff);
+            out[1] = static_cast<uint8_t>((v >> 8) & 0xff);
+            out[2] = static_cast<uint8_t>((v >> 16) & 0xff);
+            out[3] = static_cast<uint8_t>((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;
+    }
+}