[feat]proxy framework

.vscode/c_cpp_properties.json

@@ -0,0 +1,19 @@
+{
+    "configurations": [
+        {
+            "name": "Mac",
+            "includePath": [
+                "${workspaceFolder}/**"
+            ],
+            "defines": [],
+            "macFrameworkPath": [
+                "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks"
+            ],
+            "compilerPath": "/usr/bin/clang",
+            "cStandard": "c17",
+            "cppStandard": "c++17",
+            "intelliSenseMode": "macos-clang-arm64"
+        }
+    ],
+    "version": 4
+}

.vscode/launch.json

@@ -0,0 +1,25 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Debug",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "${workspaceFolder}/test",
+            "args": [],
+            "stopAtEntry": false,
+            "cwd": "${workspaceFolder}",
+            "environment": [],
+            "externalConsole": false,
+            "MIMode": "lldb",
+            "preLaunchTask": "build",
+            "setupCommands": [
+                {
+                    "description": "Enable pretty-printing for lldb",
+                    "text": "enable",
+                    "ignoreFailures": true
+                }
+            ]
+        }
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,75 @@
+{
+    "files.associations": {
+        "*.cc": "cpp",
+        "__bit_reference": "cpp",
+        "__bits": "cpp",
+        "__config": "cpp",
+        "__debug": "cpp",
+        "__errc": "cpp",
+        "__hash_table": "cpp",
+        "__locale": "cpp",
+        "__mutex_base": "cpp",
+        "__node_handle": "cpp",
+        "__nullptr": "cpp",
+        "__split_buffer": "cpp",
+        "__string": "cpp",
+        "__threading_support": "cpp",
+        "__tree": "cpp",
+        "__tuple": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "bitset": "cpp",
+        "cctype": "cpp",
+        "chrono": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "compare": "cpp",
+        "complex": "cpp",
+        "concepts": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "exception": "cpp",
+        "forward_list": "cpp",
+        "initializer_list": "cpp",
+        "ios": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "list": "cpp",
+        "locale": "cpp",
+        "map": "cpp",
+        "memory": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "numeric": "cpp",
+        "optional": "cpp",
+        "ostream": "cpp",
+        "queue": "cpp",
+        "ratio": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "typeinfo": "cpp",
+        "unordered_map": "cpp",
+        "valarray": "cpp",
+        "variant": "cpp",
+        "vector": "cpp",
+        "algorithm": "cpp",
+        "shared_mutex": "cpp",
+        "__memory": "cpp"
+    }
+}

.vscode/tasks.json

@@ -0,0 +1,26 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "build",
+            "type": "shell",
+            "command": "g++",
+            "args": [
+                "-std=c++14",
+                "-g",
+                "-o",
+                "test",
+                "-I",
+                "include",
+                "hv_utils.cpp",
+                "tcp_inbound.cpp",
+                "main.cpp",
+                "-lhv"
+            ],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            }
+        }
+    ]
+}

Dockerfile

@@ -0,0 +1,18 @@
+# Use an official Ubuntu runtime as a parent image
+FROM ubuntu:latest
+
+# Set the working directory to /app
+WORKDIR /app
+
+# Copy the source code into the container
+COPY . .
+
+# Install necessary dependencies
+RUN apt-get update && apt-get install -y g++ libhv-dev
+
+# Compile the C++ program
+RUN g++ -std=c++14 -g -o proxyServer hv_utils.cpp tcp_inbound.cpp main.cpp -I include -lhv
+
+EXPOSE 8080
+# Run my_program when the container launches
+CMD ["./proxyServer"]

README.md

@@ -5,6 +5,7 @@ colorFrom: red
 colorTo: red
 sdk: docker
 pinned: false
+app_port: 8080
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

hv_utils.cpp

@@ -0,0 +1,22 @@
+#include "include/hv_utils.h"
+
+int thread_num = 4;
+hloop_t** worker_loops = NULL;
+
+void init_loop(int _thread_num, hthread_routine worker_thread) {
+    thread_num = _thread_num;
+
+    worker_loops = (hloop_t**)malloc(sizeof(hloop_t*) * thread_num);
+    for (int i = 0; i < thread_num; ++i) {
+        worker_loops[i] = hloop_new(HLOOP_FLAG_AUTO_FREE);
+        hthread_create(worker_thread, worker_loops[i]);
+    }
+}
+
+hloop_t* get_next_loop() {
+    static int s_cur_index = 0;
+    if (s_cur_index == thread_num) {
+        s_cur_index = 0;
+    }
+    return worker_loops[s_cur_index++];
+}

include/accumulator.h

@@ -0,0 +1,25 @@
+#include <iostream>
+#include <vector>
+
+class Accumulator {
+public:
+    void addData(const char* data, size_t size) {
+        // 将新的数据块追加到累加器
+        dataBlocks.insert(dataBlocks.end(), data, data + size);
+    }
+
+    size_t getDataSize() const {
+        return dataBlocks.size();
+    }
+
+    const char* getData() const {
+        return dataBlocks.data();
+    }
+
+    void clear() {
+        dataBlocks.clear();
+    }
+
+private:
+    std::vector<char> dataBlocks;
+};

include/bolt/crypt.h

@@ -0,0 +1,54 @@
+//
+// Created by dvc890 on 8/23/21.
+//
+
+#ifndef PING_ENGINE_ANDROID_BOLT_CRYPT_H
+#define PING_ENGINE_ANDROID_BOLT_CRYPT_H
+
+enum CRYPT_TYPE {
+    NONE = 0,
+    XOR = '1'
+};
+
+namespace xor_ {
+    static void crypt(char* data, int data_len, char key){
+        for (int i = 0; i < data_len; i++){
+            data[i] = data[i] ^ key;
+        }
+    }
+
+    static void crypt2(const char* indata, int data_len, char key, char* outdata) {
+        for (int i = 0; i < data_len; i++){
+            outdata[i] = indata[i] ^ key;
+        }
+    }
+}
+
+
+#define GENERATE_ENCRYPT_EXTEN(extend, extend_len, encrypt)                                         \
+char extend[6] = {0};                                                                               \
+int extend_len = 0;                                                                                 \
+if(encrypt) {                                                                                       \
+    extend_len = sprintf(extend, "ept=1");                                                          \
+}                                                                                                   \
+
+#define EXTRACTION_DECRYPT_KEY(ept_type, ept_key, extend, extend_len)                               \
+CRYPT_TYPE ept_type = NONE;                                                                         \
+char ept_key;                                                                                       \
+if(extend_len > 0) {                                                                                \
+    if(char* type_ptr = strstr(extend, "ept_type")) {                                               \
+        ept_type = (CRYPT_TYPE)(type_ptr[9]);                                                       \
+    }                                                                                               \
+    switch (ept_type) {                                                                             \
+        case XOR: {                                                                                 \
+            if(char* key_ptr = strstr(extend, "ept_key")) {                                         \
+                ept_key = key_ptr[8];                                                               \
+            }                                                                                       \
+            break;                                                                                  \
+        }                                                                                           \
+        default:                                                                                    \
+            break;                                                                                  \
+    }                                                                                               \
+}                                                                                                   \
+
+#endif //PING_ENGINE_ANDROID_BOLT_CRYPT_H

include/bolt/datagram.h

@@ -0,0 +1,244 @@
+#ifndef __DATA_GRAM__
+#define __DATA_GRAM__
+
+#define BOLT_PAYLOAD_HEAD_SIZE 21
+#define BOLT_VERSION    1
+#define BOLT_RESERVE    0
+#define BOLT_PAYLOAD_TYPE_CMD   0
+#define BOLT_PAYLOAD_TYPE_ICMP  1
+#define BOLT_PAYLOAD_TYPE_TCP  6
+#define BOLT_PAYLOAD_TYPE_UDP  17
+#define BOLT_PAYLOAD_BIND_LENGTH 73
+
+#define ICMP_REQUEST_TOKEN 0x9f8e7d6c
+#define ICMP_RESPONSE_TOKEN 0x4d3c2b1a
+
+enum BOLT_CHANNEL_CMD {
+    BOLT_CHANNEL_CMD_BIND_REQUEST    = 1,   //通道绑定请求
+    BOLT_CHANNEL_CMD_BIND_RESPONSE   = 2,   //通道绑定回应
+    BOLT_CHANNEL_CMD_UNBIND_REQUEST  = 3,   //通道释放
+    BOLT_CHANNEL_CMD_INVALID_RESPONSE  = 4,   //通道过期
+    BOLT_CHANNEL_CMD_TCP_HANDSHAKE_REQUEST = 0x20,  //TCP握手请求
+    BOLT_CHANNEL_CMD_TCP_HANDSHAKE_RESPONSE = 0x21, //TCP握手响应
+};
+
+enum BOLT_BIND_RESPONSE_CODE {
+    BOLT_BIND_RESPONSE_CODE_FAIL = -2, //本地错误，网络连接问题
+    BOLT_BIND_RESPONSE_CODE_UNKONWN = -1, //未知错误
+    BOLT_BIND_RESPONSE_CODE_NULL = 0, //正常流程，bolt内部状态码，并不回调到外层
+
+    BOLT_BIND_RESPONSE_CODE_SUCESS = 1, //通道绑定成功
+    BOLT_BIND_RESPONSE_CODE_ST_INVALID = 2, //token过期或者错误
+    BOLT_BIND_RESPONSE_CODE_RECYCLE = 3, //数据通道被回收
+    BOLT_BIND_RESPONSE_CODE_SERVER_INNER_FAIL = 0x1000, //服务器内部错误
+
+    BOLT_CHANNEL_CODE_ST_INVALID = 4,//传输时token过期
+};
+
+enum BOLT_UNBIND_RESPONSE_CODE {
+    BOLT_UNBIND_RESPONSE_CODE_FAIL = -2, //本地错误，网络连接问题
+    BOLT_UNBIND_RESPONSE_CODE_UNKONWN = -1, //未知错误
+
+    BOLT_UNBIND_RESPONSE_CODE_SUCESS = 1, //通道解除绑定成功
+    BOLT_UNBIND_RESPONSE_CODE_ALREADY_NOBIND = 2, //通道没有绑定
+};
+
+enum BOLT_TCP_HANDSHAKE_RESULT {
+    BOLT_TCP_HANDSHAKE_SUCESS        = 0x22, //握手成功
+    BOLT_TCP_HANDSHAKE_FAIL_AUTH     = 0x23, //鉴权失败
+    BOLT_TCP_HANDSHAKE_FAIL_FORMAT   = 0x24, //包格式错误
+    BOLT_TCP_HANDSHAKE_FAIL_TIMEOUT  = 0x25, //连接目标服务器超时
+    BOLT_TCP_HANDSHAKE_FAIL_INTERNAL = 0x26, //内部错误
+};
+
+
+struct Bolt_Payload {
+    char head[BOLT_PAYLOAD_HEAD_SIZE];
+    char data[0];
+};
+
+//为了保证内存布局一至，用宏在payload上模拟成员变量
+#define GET_BOLT_VERSION(p)		    (*((uint8_t*)((p)->head)) & 0x0F)
+#define GET_BOLT_RESERVE(p)		    (*((uint8_t*)((p)->head)) >> 4)
+#define GET_BOLT_HEADER_LENGTH(p)	(*((uint8_t*)((p)->head + 1)))
+#define GET_BOLT_TOTAL_LENGTH(p)	(*((uint16_t*)((p)->head + 2)))
+#define GET_BOLT_PAYLOAD_TYPE(p)	(*((uint8_t*)((p)->head + 4)))
+#define GET_BOLT_TARGET_IP(p)	    (*((uint32_t*)((p)->head + 5)))  //网络序
+#define GET_BOLT_TARGET_PORT(p)     (*((uint16_t*)((p)->head + 9)))  //网络序
+#define GET_BOLT_USER_IP(p)         (*((uint32_t*)((p)->head + 11)))  //网络序
+#define GET_BOLT_USER_PORT(p)       (*((uint16_t*)((p)->head + 15)))  //网络序
+#define GET_BOLT_TOKEN(p)           (*((uint32_t*)((p)->head + 17)))
+#define GET_EXTEND_HEADER_LENGTH(p)	(GET_BOLT_HEADER_LENGTH(p) - BOLT_PAYLOAD_HEAD_SIZE)
+
+#define SET_BOLT_VERSION(p, v)      { *((uint8_t*)((p)->head)) &= 0xF0; *((uint8_t*)((p)->head)) |= v; }
+#define SET_BOLT_RESERVE(p, r)      { *((uint8_t*)((p)->head)) &= 0x0F; *((uint8_t*)((p)->head)) |= (r * 16); }
+#define SET_BOLT_HEADER_LENGTH(p, l) *((uint8_t*)((p)->head + 1)) = l
+#define SET_BOLT_TOTAL_LENGTH(p, l) *((uint16_t*)((p)->head + 2)) = l
+#define SET_BOLT_PAYLOAD_TYPE(p, t) *((uint8_t*)((p)->head + 4)) = t
+#define SET_BOLT_TARGET_IP(p, i)    *((uint32_t*)((p)->head + 5)) = i
+#define SET_BOLT_TARGET_PORT(p, t)  *((uint16_t*)((p)->head + 9)) = t
+#define SET_BOLT_USER_IP(p, i)      *((uint32_t*)((p)->head + 11)) = i
+#define SET_BOLT_USER_PORT(p, t)    *((uint16_t*)((p)->head + 15)) = t
+#define SET_BOLT_TOKEN(p, t)        *((uint32_t*)((p)->head + 17)) = t
+
+
+#define PACK_TUNNEL_DATA(dest, dest_len, ver, res, type, t_ip, t_port, u_ip, u_port, session_id, extend, extend_len, buf, len) \
+    char dest[BOLT_PAYLOAD_HEAD_SIZE + len + extend_len];                                                                   \
+    Bolt_Payload * header = (Bolt_Payload*)dest;                                                                            \
+    SET_BOLT_VERSION(header, ver);                                                                                          \
+    SET_BOLT_RESERVE(header, res);                                                                                          \
+	SET_BOLT_PAYLOAD_TYPE(header, type);                                                                                    \
+	SET_BOLT_TARGET_IP(header, t_ip);                                                                                       \
+	SET_BOLT_TARGET_PORT(header, t_port);                                                                                   \
+	SET_BOLT_USER_IP(header, u_ip);                                                                                         \
+	SET_BOLT_USER_PORT(header, u_port);                                                                                     \
+	SET_BOLT_TOKEN(header, session_id);                                                                                     \
+	int dest_len = len + BOLT_PAYLOAD_HEAD_SIZE;                                                                            \
+	if((extend_len) > 0) {                                                                                                  \
+        memcpy(dest + BOLT_PAYLOAD_HEAD_SIZE, (extend), (extend_len));                                                      \
+		memcpy(dest + BOLT_PAYLOAD_HEAD_SIZE + (extend_len), (buf), (len));                                                 \
+		dest_len += (extend_len);                                                                                           \
+		SET_BOLT_HEADER_LENGTH(header, BOLT_PAYLOAD_HEAD_SIZE + (extend_len));                                              \
+        SET_BOLT_TOTAL_LENGTH(header, BOLT_PAYLOAD_HEAD_SIZE + (len) + (extend_len));                                       \
+	} else {                                                                                                                \
+        memcpy(dest + BOLT_PAYLOAD_HEAD_SIZE , (buf), (len));                                                               \
+		SET_BOLT_HEADER_LENGTH(header, BOLT_PAYLOAD_HEAD_SIZE);                                                             \
+        SET_BOLT_TOTAL_LENGTH(header, BOLT_PAYLOAD_HEAD_SIZE + (len) + (extend_len));                                       \
+    }                                                                                                                       \
+  
+
+#define UNPACK_TUNNEL_DATA(dest, dest_len, ver, res, type, t_ip, t_port, u_ip, u_port, session_id, extend, extend_len, buf, len) \
+	Bolt_Payload * header = (Bolt_Payload*)buf;                                                                             \
+	uint8_t ver = GET_BOLT_VERSION(header);                                                                                 \
+	uint8_t res = GET_BOLT_RESERVE(header);                                                                                 \
+    uint8_t type = GET_BOLT_PAYLOAD_TYPE(header);                                                                           \
+	uint32_t t_ip = GET_BOLT_TARGET_IP(header);                                                                             \
+    uint16_t t_port = GET_BOLT_TARGET_PORT(header);                                                                         \
+    uint32_t u_ip = GET_BOLT_USER_IP(header);                                                                               \
+    uint16_t u_port = GET_BOLT_USER_PORT(header);                                                                           \
+    uint32_t session_id = GET_BOLT_TOKEN(header);                                                                           \
+    uint16_t extend_len = GET_EXTEND_HEADER_LENGTH(header);                                                                 \
+	char* dest = (char*)buf + BOLT_PAYLOAD_HEAD_SIZE;                                                                       \
+	int dest_len = len - BOLT_PAYLOAD_HEAD_SIZE;                                                                            \
+    char extend[extend_len + 1];                                                                                            \
+    memset(extend, 0, extend_len + 1);                                                                                      \
+    if(extend_len > 0 && extend_len < (len - BOLT_PAYLOAD_HEAD_SIZE - 1)) {                                                 \
+        memcpy(extend, (char*)buf +  BOLT_PAYLOAD_HEAD_SIZE, extend_len);                                                   \
+        dest += extend_len;                                                                                                 \
+        dest_len -= extend_len;                                                                                             \
+     }                                                                                                                      \
+
+#define PACK_BIND_DATA(res, res_len, request_id, signal_id, session_id, data_st)                                            \
+    char res[73] = {0};                                                                                                     \
+    int res_len = 73;                                                                                                       \
+    res[0] = BOLT_CHANNEL_CMD_BIND_REQUEST;                                                                                 \
+    memcpy(res + 1, &request_id, 4);                                                                                        \
+    memcpy(res + 5, signal_id, 32);                                                                                         \
+    memcpy(res + 37, &session_id, 4);                                                                                       \
+    memcpy(res + 41, data_st, 32);                                                                                          \
+
+#define UNPACK_BIND_DATA(command, request_id, session_id, response_result, bind_resp, bind_resp_len)                        \
+    uint8_t command = *(bind_resp);                                                                                         \
+    uint32_t request_id = 0;                                                                                                \
+    uint32_t session_id = 0;                                                                                                \
+    uint32_t response_result = 0;                                                                                           \
+    memcpy(&request_id, (char*)bind_resp + 1, 4);                                                                           \
+    memcpy(&session_id, (char*)bind_resp + 5, 4);                                                                           \
+    memcpy(&response_result, (char*)bind_resp + 9, 4);                                                                      \
+
+#define PACK_UNBIND_DATA(res, res_len, session_id, code)                                                                    \
+    char res[9] = {0};                                                                                                      \
+    int res_len = 9;                                                                                                        \
+    res[0] = BOLT_CHANNEL_CMD_UNBIND_REQUEST;                                                                               \
+    memcpy(res + 1, &session_id, 4);                                                                                        \
+    memcpy(res + 5, &code, 4);                                                                                              \
+
+#define PACK_ICMP_REQUEST_DATA(res, res_len, type, code, id, seqno, data, data_len)                                         \
+    int res_len = 6 + data_len;                                                                                             \
+    char res[res_len];                                                                                                      \
+    res[0] = type;                                                                                                          \
+    res[1] = code;                                                                                                          \
+    memcpy(res + 2, &id, 2);                                                                                                \
+    memcpy(res + 4, &seqno, 2);                                                                                             \
+    memcpy(res + 6, data, data_len);                                                                                        \
+
+#define UNPACK_ICMP_RESPONSE_DATA(iphdr, type, code, id, seqno, data, data_len, resp, resp_len)                             \
+    u8_t iphdr[20] = {0};                                                                                                   \
+    memcpy(iphdr, resp, 20);                                                                                                \
+    uint8_t type = (*((uint8_t*)(resp + 20)));                                                                              \
+    uint8_t code = (*((uint8_t*)(resp + 21)));                                                                              \
+    uint16_t id = (*((uint16_t*)(resp + 22)));                                                                              \
+    uint16_t seqno = (*((uint16_t*)(resp + 24)));                                                                           \
+    int data_len = resp_len - 20 - 6;                                                                                       \
+    char *data = (char *)resp + (20 + 6);     
+    
+    
+#define BOLT_SERVER_INFO                                                                                                    \
+struct sockaddr_in bolt_server_addr;                                                                                        \
+char* signal_id;                                                                                                            \
+int request_id;                                                                                                             \
+int session_id;                                                                                                             \
+int connect_id;                                                                                                             \
+char* data_st;                                                                                                              \
+bool encrypt;                                                                                                               \
+
+#define BOLT_SERVER_EXTEND                                                                                                  \
+bolt_state state;                                                                                                           \
+CRYPT_TYPE ept_type;                                                                                                        \
+char ept_key;                                                                                                               \
+
+//#pragma pack(push)
+//#pragma pack(1)
+//	struct _bolt_header {
+//		uint8_t ver_; //包含version+reserve
+//		uint8_t hdr_len_; //头部长度
+//		uint16_t total_len_; //数据总大小
+//		uint8_t  type_;
+//		uint32_t t_ip; //目标IP 网络序
+//		uint16_t t_port_; //目标端口 网络序
+//		uint32_t u_ip_;//用户内外IP；
+//		uint16_t u_port_; //用户内外端口
+//		uint32_t  token_;
+//	}BOLTHEADER;
+//
+// 通道绑定
+// struct _bolt_channel_bind_rqeust{
+// BOLTHEADER hdr_;
+// uint8_t cmd_;   //BOLT_CHANNEL_CMD_BIND_REQUEST
+// uint32_t request_id_ ;//
+// uint32_t data_session_id_; //通道会话ID（由信令服务分配）
+// char data_st_[64];   //通道验证token（由信令服务分配，短有效期，单次使用）
+// }
+//
+// 绑定响应
+// struct _bolt_channel_bind_response{
+// BOLTHEADER hdr_;
+// uint8_t cmd_;  //BOLT_CHANNEL_CMD_BIND_RESPONSE
+// uint32_t request_id_;
+// uint32_t data_session_id_; //通道会话ID（由信令服务分配）
+// uint32_t response_result_; //响应码：
+// }
+//
+// 通道释放
+// struct _bolt_channel_unbind{
+// BOLTHEADER hdr_;
+// uint8_t cmd_;  //BOLT_CHANNEL_CMD_BIND_RESPONSE
+// uint32_t data_session_id_; //通道会话ID（由信令服务分配）
+// uint32_t code_; //响应码：指示释放的原因；
+// }
+//
+//
+// //bolt tcp 握手请求
+// struct _bolt_tcp_handshake_request{
+// BOLTHEADER hdr_;
+// uint8_t cmd; //BOLT_CHANNEL_CMD_TCP_HANDSHAKE_REQUEST
+// }
+// //bolt tcp 握手回应（连接目标结果之后）
+// stuct _bolt_tcp_handshake_response{
+// BOLTHEADER hdr_;
+// uint8_t cmd; //BOLT_CHANNEL_CMD_TCP_HANDSHAKE_RESPONSE
+// uint8_t result; //BOLT_TCP_HANDSHAKE_SUCESS
+// }
+//#pragma pack(pop)
+
+#endif //end of __DATA_GRAM__

include/conn_map.h

@@ -0,0 +1,49 @@
+#ifndef PROXYSERVER_CONN_MAP_H
+#define PROXYSERVER_CONN_MAP_H
+
+#include <iostream>
+#include <map>
+#include <shared_mutex>
+
+template <typename Key, typename Value>
+class ConnMap {
+public:
+    static ConnMap& getInstance() {
+        static ConnMap instance; // 在首次使用时创建
+        return instance;
+    }
+
+    ConnMap(ConnMap const&) = delete;
+    void operator=(ConnMap const&) = delete;
+
+    void add(const Key& key, const Value& value) {
+        std::unique_lock<std::shared_timed_mutex> lock(mutex_);
+        map_[key] = value;
+    }
+
+    Value* get(const Key& key) const {
+        std::shared_lock<std::shared_timed_mutex> lock(mutex_);
+        auto it = map_.find(key);
+        if (it != map_.end()) {
+            return (Value*)(&(it->second));
+        }
+        return nullptr;
+    }
+
+    void remove(const Key& key) {
+        std::unique_lock<std::shared_timed_mutex> lock(mutex_);
+        map_.erase(key);
+    }
+
+    void clear() {
+        std::unique_lock<std::shared_timed_mutex> lock(mutex_);
+        map_.clear();
+    }
+
+private:
+    ConnMap() = default;
+    mutable std::shared_timed_mutex mutex_;
+    std::map<Key, Value> map_;
+};
+
+#endif //PROXYSERVER_CONN_MAP_H

include/hv_utils.h

@@ -0,0 +1,12 @@
+#ifndef PROXYSERVER_HV_UTILS_H
+#define PROXYSERVER_HV_UTILS_H
+
+#include "hv/hloop.h"
+#include "hv/hthread.h"
+
+void init_loop(int _thread_num, hthread_routine worker_thread);
+
+hloop_t* get_next_loop();
+
+
+#endif //PROXYSERVER_HV_UTILS_H

include/tcp_inbound.h

@@ -0,0 +1,7 @@
+#ifndef PROXYSERVER_TCP_INBOUND_H
+#define PROXYSERVER_TCP_INBOUND_H
+
+#include "hv/hloop.h"
+void tcp_on_accept(hio_t* io, hevent_t* ev);
+
+#endif //PROXYSERVER_TCP_INBOUND_H

main.cpp

@@ -0,0 +1,189 @@
+// #include "hv/HttpServer.h"
+// using namespace hv;
+
+// int main() {
+//     HttpService router;
+//     router.GET("/ping", [](HttpRequest* req, HttpResponse* resp) {
+//         print("/ping");
+//         return resp->String("pong");
+//     });
+
+//     router.GET("/data", [](HttpRequest* req, HttpResponse* resp) {
+//         print("/data");
+//         static char data[] = "0123456789";
+//         return resp->Data(data, 10);
+//     });
+
+//     router.GET("/paths", [&router](HttpRequest* req, HttpResponse* resp) {
+//         print("/paths");
+//         return resp->Json(router.Paths());
+//     });
+
+//     router.GET("/get", [](HttpRequest* req, HttpResponse* resp) {
+//         print("/get");
+//         resp->json["origin"] = req->client_addr.ip;
+//         resp->json["url"] = req->url;
+//         resp->json["args"] = req->query_params;
+//         resp->json["headers"] = req->headers;
+//         hv::Json myArray = hv::Json::array();
+//         myArray.push_back("apple");
+//         myArray.push_back("banana");
+//         myArray.push_back("orange");
+//         resp->json["fruits"] = myArray;
+//         resp->json["test"]["a"] = "json_serializer";
+//         return 200;
+//     });
+
+//     router.POST("/echo", [](const HttpContextPtr& ctx) {
+//         print(ctx->body());
+//         return ctx->send(ctx->body(), ctx->type());
+//     });
+
+//     HttpServer server(&router);
+//     server.setPort(8080);
+//     server.setThreadNum(4);
+//     server.run();
+//     return 0;
+// }
+
+// #include "hv/TcpServer.h"
+// using namespace hv;
+
+// int main() {
+//     int port = 1234;
+//     TcpServer srv;
+//     int listenfd = srv.createsocket(port);
+//     if (listenfd < 0) {
+//         return -1;
+//     }
+//     printf("server listen on port %d, listenfd=%d ...\n", port, listenfd);
+//     srv.onConnection = [](const SocketChannelPtr& channel) {
+//         std::string peeraddr = channel->peeraddr();
+//         if (channel->isConnected()) {
+//             printf("%s connected! connfd=%d\n", peeraddr.c_str(), channel->fd());
+//         } else {
+//             printf("%s disconnected! connfd=%d\n", peeraddr.c_str(), channel->fd());
+//         }
+//     };
+//     srv.onMessage = [](const SocketChannelPtr& channel, Buffer* buf) {
+//         // echo
+//         channel->write(buf);
+//     };
+//     srv.setThreadNum(4);
+//     srv.start();
+
+//     // press Enter to stop
+//     while (getchar() != '\n');
+//     return 0;
+// }
+
+// #include <iostream>
+// #include "hv/TcpClient.h"
+// using namespace hv;
+
+// int main() {
+//     int port = 1234;
+//     TcpClient cli;
+//     int connfd = cli.createsocket(port);
+//     if (connfd < 0) {
+//         return -1;
+//     }
+//     cli.onConnection = [](const SocketChannelPtr& channel) {
+//         std::string peeraddr = channel->peeraddr();
+//         if (channel->isConnected()) {
+//             printf("connected to %s! connfd=%d\n", peeraddr.c_str(), channel->fd());
+//         } else {
+//             printf("disconnected to %s! connfd=%d\n", peeraddr.c_str(), channel->fd());
+//         }
+//     };
+//     cli.onMessage = [](const SocketChannelPtr& channel, Buffer* buf) {
+//         printf("< %.*s\n", (int)buf->size(), (char*)buf->data());
+//     };
+//     cli.start();
+
+//     std::string str;
+//     while (std::getline(std::cin, str)) {
+//         if (str == "close") {
+//             cli.closesocket();
+//         } else if (str == "start") {
+//             cli.start();
+//         } else if (str == "stop") {
+//             cli.stop();
+//             break;
+//         } else {
+//             if (!cli.isConnected()) break;
+//             cli.send(str);
+//         }
+//     }
+//     return 0;
+// }
+
+/*
+ *
+ * @build   make examples
+ * @server  bin/one-acceptor-multi-workers 1234
+ * @client  bin/nc 127.0.0.1 1234
+ *          nc     127.0.0.1 1234
+ *          telnet 127.0.0.1 1234
+ */
+
+#include "hv/hloop.h"
+#include "hv/hthread.h"
+#include "include/hv_utils.h"
+#include "include/tcp_inbound.h"
+
+static const char* host = "0.0.0.0";
+static int port = 8080;
+static int thread_num = 4;
+static hloop_t*  accept_loop = NULL;
+
+static void new_conn_event(hevent_t* ev) {
+    hloop_t* loop = ev->loop;
+    hio_t* io = (hio_t*)hevent_userdata(ev);
+    hio_attach(loop, io);
+
+    tcp_on_accept(io, ev);
+}
+
+static void on_accept(hio_t* io) {
+    hio_detach(io);
+
+    hloop_t* worker_loop = get_next_loop();
+    hevent_t ev;
+    memset(&ev, 0, sizeof(ev));
+    ev.loop = worker_loop;
+    ev.cb = new_conn_event;
+    ev.userdata = io;
+    hloop_post_event(worker_loop, &ev);
+}
+
+static HTHREAD_RETTYPE worker_thread(void* userdata) {
+    hloop_t* loop = (hloop_t*)userdata;
+    hloop_run(loop);
+    return 0;
+}
+
+static HTHREAD_RETTYPE accept_thread(void* userdata) {
+    hloop_t* loop = (hloop_t*)userdata;
+    hio_t* listenio = hloop_create_tcp_server(loop, host, port, on_accept);
+    if (listenio == NULL) {
+        exit(1);
+    }
+    hloop_run(loop);
+    return 0;
+}
+
+int main(int argc, char** argv) {
+    // if (argc < 2) {
+    //     printf("Usage: cmd port\n");
+    //     return -10;
+    // }
+    // port = atoi(argv[1]);
+
+    init_loop(thread_num, worker_thread);
+
+    accept_loop = hloop_new(HLOOP_FLAG_AUTO_FREE);
+    accept_thread(accept_loop);
+
+    return 0;
+}

tcp_inbound.cpp

@@ -0,0 +1,90 @@
+#include "include/tcp_inbound.h"
+#include "include/conn_map.h"
+#include "include/accumulator.h"
+#include "hv/hsocket.h"
+#include "hv/hthread.h"
+#include "hv/TcpClient.h"
+#include <string>
+
+class TcpClientShell {
+    public:
+        bool init(hio_t* _io) {
+            io = _io;
+            int connfd = cli.createsocket(hio_peeraddr(io));
+            if (connfd < 0) {
+                return -1;
+            }
+            cli.onConnection = [this](const hv::SocketChannelPtr& channel) {
+                std::string peeraddr = channel->peeraddr();
+                if (channel->isConnected()) {
+                    printf("connected to %s! connfd=%d\n", peeraddr.c_str(), channel->fd());
+                    if (wait_send_buf.getDataSize() > 0)
+                    {
+                        cli.send(wait_send_buf.getData(), wait_send_buf.getDataSize());
+                    }
+                } else {
+                    printf("disconnected to %s! connfd=%d\n", peeraddr.c_str(), channel->fd());
+                    hio_close(io);
+                }
+            };
+
+            cli.onMessage = [this](const hv::SocketChannelPtr& channel, hv::Buffer* buf) {
+                hio_write(io, buf->data(), buf->size());
+                printf("< %.*s\n", (int)buf->size(), (char*)buf->data());
+            };
+
+            cli.onWriteComplete = [this](const hv::SocketChannelPtr& channel, hv::Buffer* buf) {
+
+            };
+            cli.start();
+        }
+
+        int send(const char* data, int size) {
+            if (cli.isConnected())
+            {
+                return cli.send(data, size);
+            } else {
+                wait_send_buf.addData(data, size);
+                return size;
+            }
+        }
+
+        void close() {
+            cli.closesocket();
+        }
+
+    private:
+        hv::TcpClient cli;
+        hio_t* io;
+        Accumulator wait_send_buf;
+};
+
+static void tcp_on_close(hio_t* io) {
+    printf("on_close fd=%d error=%d\n", hio_fd(io), hio_error(io));
+    ConnMap<hio_t*, TcpClientShell>::getInstance().remove(io);
+}
+
+static void tcp_on_recv(hio_t* io, void* buf, int readbytes) {
+    // echo
+    hio_write(io, buf, readbytes);
+    auto cli = ConnMap<hio_t*, TcpClientShell>::getInstance().get(io);
+    if(cli) {
+        cli->send((const char*) buf, readbytes);
+    }
+}
+
+void tcp_on_accept(hio_t* io, hevent_t* ev) {
+    hloop_t* loop = ev->loop;
+
+    char localaddrstr[SOCKADDR_STRLEN] = {0};
+    char peeraddrstr[SOCKADDR_STRLEN] = {0};
+    printf("tid=%ld connfd=%d [%s] <= [%s]\n",
+            (long)hv_gettid(),
+            (int)hio_fd(io),
+            SOCKADDR_STR(hio_localaddr(io), localaddrstr),
+            SOCKADDR_STR(hio_peeraddr(io), peeraddrstr));
+
+    hio_setcb_close(io, tcp_on_close);
+    hio_setcb_read(io, tcp_on_recv);
+    hio_read(io);
+}