[fix]support tcp

Dockerfile

@@ -50,7 +50,7 @@ WORKDIR /app
 COPY . .
 
 # Compile the C++ program
-RUN g++ -std=c++14 -g -o proxyServer hv_utils.cpp tcp_inbound.cpp main.cpp -I include include -I include/bolt -lhv -lspdlog
+RUN g++ -std=c++14 -g -o proxyServer hv_utils.cpp tcp_inbound.cpp main.cpp -I include -I include/bolt -lhv -lspdlog
 
 RUN apt-get install -y tzdata
 

include/tcp_client.h

@@ -0,0 +1,48 @@
+#ifndef PROXYSERVER_TCP_CLIENT_H
+#define PROXYSERVER_TCP_CLIENT_H
+
+#include "hv/hloop.h"
+#include "hv/TcpClient.h"
+#include "bolt/crypt.h"
+
+class tcpBoltConfig
+{
+public:
+    uint32_t request_id;
+    uint32_t session_id;
+    std::string signal_id;
+    std::string data_st;
+    bool encrypt = false;
+    CRYPT_TYPE ept_type;
+    char ept_key;
+};
+
+class TcpClientBolt {
+    public:
+        TcpClientBolt(hio_t* _io) : io(_io) {}
+
+        bool hasHandshake() { return cli.isConnected(); }
+
+        bool handShake(void* buf, int readbytes);
+
+        int send(char* data, int size);
+
+        void close();
+
+    private:
+        bool connect(struct sockaddr* addr);
+        void onConnection(const hv::SocketChannelPtr &channel);
+        void onDisConnection(const hv::SocketChannelPtr &channel);
+        void onRecv(const hv::SocketChannelPtr &channel, hv::Buffer *buf);
+        void onWrited(const hv::SocketChannelPtr &channel, hv::Buffer *buf);
+
+    private:
+        hv::TcpClient cli;
+        hio_t* io;
+        struct sockaddr_in t_addr, u_addr;
+        uint32_t session_id;
+        bool is_bolt_server;
+        tcpBoltConfig *config;
+};
+
+#endif //PROXYSERVER_TCP_CLIENT_H

include/tcp_client_map.h

@@ -0,0 +1,50 @@
+#ifndef PROXYSERVER_CONN_MAP_H
+#define PROXYSERVER_CONN_MAP_H
+
+#include <iostream>
+#include <map>
+#include <shared_mutex>
+#include <mutex>
+
+template <typename Key, typename Value>
+class TcpClientMap {
+public:
+    static TcpClientMap& getInstance() {
+        static TcpClientMap instance; // 在首次使用时创建
+        return instance;
+    }
+
+    TcpClientMap(TcpClientMap const&) = delete;
+    void operator=(TcpClientMap 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:
+    TcpClientMap() = default;
+    mutable std::shared_timed_mutex mutex_;
+    std::map<Key, Value> map_;
+};
+
+#endif //PROXYSERVER_CONN_MAP_H

tcp_client.cpp

@@ -0,0 +1,220 @@
+#include "include/tcp_client.h"
+#include "bolt/datagram.h"
+#include "include/tcp_client_map.h"
+#include "spdlog/spdlog.h"
+#include <string>
+#include <time.h>
+
+char generateRandomKey()
+{
+    // 使用时间作为随机数种子，确保每次运行生成的随机数都不同
+    srand((unsigned int)time(NULL));
+
+    // 生成 'A' 到 'Z' 之间的随机字符
+    return (char)('A' + rand() % 26);
+}
+
+void TcpClientBolt::onConnection(const hv::SocketChannelPtr &channel)
+{
+    char buff[2];
+    buff[0] = BOLT_CHANNEL_CMD_TCP_HANDSHAKE_RESPONSE;
+    buff[1] = BOLT_TCP_HANDSHAKE_SUCESS;
+    int len = sizeof(buff);
+
+    PACK_TUNNEL_DATA(boltdata, boltdata_len, BOLT_VERSION, BOLT_RESERVE, BOLT_PAYLOAD_TYPE_CMD, t_addr.sin_addr.s_addr, t_addr.sin_port, u_addr.sin_addr.s_addr, u_addr.sin_port, session_id, 0, 0, buff, len);
+    hio_write(io, buff, len);
+}
+
+void TcpClientBolt::onRecv(const hv::SocketChannelPtr &channel, hv::Buffer *buf)
+{
+    auto config = TcpClientMap<uint32_t, tcpBoltConfig>::getInstance().get(session_id);
+    if (config)
+    {
+        if (config->encrypt)
+        {
+            switch (config->ept_type)
+            {
+            case CRYPT_TYPE::XOR:
+                xor_::crypt((char *)buf->data(), buf->size(), config->ept_key);
+                break;
+
+            default:
+                break;
+            }
+        }
+    }
+
+    hio_write(io, buf->data(), buf->size());
+}
+
+void TcpClientBolt::onWrited(const hv::SocketChannelPtr &channel, hv::Buffer *buf)
+{
+
+}
+
+void TcpClientBolt::onDisConnection(const hv::SocketChannelPtr &channel)
+{
+    hio_close(io);
+}
+
+bool TcpClientBolt::handShake(void *buf, int readbytes)
+{
+    if (readbytes > 0)
+    {
+        UNPACK_TUNNEL_DATA(dest, dest_len, ver, res, type, t_ip, t_port, u_ip, u_port, session_id, extend, extend_len, buf, readbytes)
+        if (ver == BOLT_VERSION && res == BOLT_RESERVE)
+        {
+            if (type == BOLT_PAYLOAD_TYPE_CMD)
+            {
+                if (dest_len == 1 && dest[0] == BOLT_CHANNEL_CMD_TCP_HANDSHAKE_REQUEST)
+                {
+                    this->t_addr.sin_addr.s_addr = t_ip;
+                    this->t_addr.sin_port = t_port;
+                    this->u_addr.sin_addr.s_addr = u_ip;
+                    this->u_addr.sin_port = u_port;
+                    this->session_id = session_id;
+                    this->config = TcpClientMap<uint32_t, tcpBoltConfig>::getInstance().get(session_id);
+                    if (!this->config)
+                    {
+                        char buff[1] = {BOLT_CHANNEL_CMD_INVALID_RESPONSE};
+                        int len = sizeof(buff);
+
+                        PACK_TUNNEL_DATA(boltdata, boltdata_len, BOLT_VERSION, BOLT_RESERVE, BOLT_PAYLOAD_TYPE_CMD, t_addr.sin_addr.s_addr, t_addr.sin_port, u_addr.sin_addr.s_addr, u_addr.sin_port, session_id, 0, 0, buff, len);
+                        hio_write(io, buff, len);
+                        hio_close_async(io);
+                        return false;
+                    }
+                    
+                    if (!this->connect((struct sockaddr *)&t_addr))
+                    {
+                        char buff[2];
+                        buff[0] = BOLT_CHANNEL_CMD_TCP_HANDSHAKE_RESPONSE;
+                        buff[1] = BOLT_TCP_HANDSHAKE_FAIL_TIMEOUT;
+                        int len = sizeof(buff);
+
+                        PACK_TUNNEL_DATA(boltdata, boltdata_len, BOLT_VERSION, BOLT_RESERVE, BOLT_PAYLOAD_TYPE_CMD, t_addr.sin_addr.s_addr, t_addr.sin_port, u_addr.sin_addr.s_addr, u_addr.sin_port, session_id, 0, 0, buff, len);
+                        hio_write(io, buff, len);
+                        hio_close_async(io);
+                        return false;
+                    }
+                    return true;
+                }
+                else if (dest_len == 73 && dest[0] == BOLT_CHANNEL_CMD_BIND_REQUEST)
+                {
+                    UNPACK_BIND_DATA(command, request_id, signal_id, session_id, data_st, dest, dest_len)
+                    this->session_id = session_id;
+                    tcpBoltConfig config;
+                    config.request_id = request_id;
+                    config.session_id = session_id;
+                    config.data_st = data_st;
+                    config.signal_id = signal_id;
+                    if (extend_len >= 5)
+                    {
+                        if (strcmp(extend, "ept=1") == 0)
+                        {
+                            config.encrypt = true;
+                        }
+                    }
+                    config.ept_type = config.encrypt ? CRYPT_TYPE::XOR : CRYPT_TYPE::NONE;
+                    config.ept_key = config.encrypt ? generateRandomKey() : 0;
+
+                    GENERATE_DECRYPT_KEY(extend_response, extend_response_len, config.ept_type, config.ept_key)
+
+                    char result[1] = {BOLT_BIND_RESPONSE_CODE_SUCESS};
+
+                    PACK_BIND_RESPONSE_DATA(bind_response, bind_response_len, BOLT_CHANNEL_CMD_BIND_RESPONSE, request_id, session_id, result)
+
+                    PACK_TUNNEL_DATA(response, response_len, BOLT_VERSION, BOLT_RESERVE, BOLT_PAYLOAD_TYPE_CMD, 0, 0, 0, 0, session_id, extend_response, extend_response_len, bind_response, bind_response_len)
+                    hio_write(io, response, response_len);
+
+                    TcpClientMap<uint32_t, tcpBoltConfig>::getInstance().add(session_id, config);
+                    is_bolt_server = true;
+                }
+                else if (dest_len == 9 && dest[0] == BOLT_CHANNEL_CMD_UNBIND_REQUEST)
+                {
+                    UNPACK_UNBIND_DATA(command, session_id, code, dest, dest_len)
+
+                    TcpClientMap<uint32_t, tcpBoltConfig>::getInstance().remove(session_id);
+                    this->close();
+                    hio_close_async(io);
+                }
+            }
+        }
+    }
+    return false;
+}
+
+bool TcpClientBolt::connect(struct sockaddr *addr)
+{
+    int connfd = cli.createsocket(addr);
+    if (connfd < 0)
+    {
+        return false;
+    }
+    cli.onConnection = [this](const hv::SocketChannelPtr &channel)
+    {
+        std::string peeraddr = channel->peeraddr();
+        if (channel->isConnected())
+        {
+            spdlog::info("connected to {}! connfd={}\n", peeraddr.c_str(), channel->fd());
+
+            onConnection(channel);
+        }
+        else
+        {
+            spdlog::info("disconnected to {}! connfd={}\n", peeraddr.c_str(), channel->fd());
+
+            onDisConnection(channel);
+        }
+    };
+
+    cli.onMessage = [this](const hv::SocketChannelPtr &channel, hv::Buffer *buf)
+    {
+        spdlog::info("<<< len:{} : {}}\n", (int)buf->size(), (char *)buf->data());
+
+        onRecv(channel, buf);
+    };
+
+    cli.onWriteComplete = [this](const hv::SocketChannelPtr &channel, hv::Buffer *buf)
+    {
+        spdlog::info(">>> len:{} : {}}\n", (int)buf->size(), (char *)buf->data());
+
+        onWrited(channel, buf);
+    };
+
+    cli.start();
+    return true;
+}
+
+int TcpClientBolt::send(char *data, int size)
+{
+    if (cli.isConnected())
+    {
+        auto config = TcpClientMap<uint32_t, tcpBoltConfig>::getInstance().get(session_id);
+        if (config)
+        {
+            if (config->encrypt)
+            {
+                switch (config->ept_type)
+                {
+                case CRYPT_TYPE::XOR:
+                    xor_::crypt(data, size, config->ept_key);
+                    break;
+
+                default:
+                    break;
+                }
+            }
+        }
+        return cli.send(data, size);
+    }
+    else
+    {
+        return -1;
+    }
+}
+
+void TcpClientBolt::close()
+{
+    cli.closesocket();
+}