[feat]support udp

.vscode/launch.json

@@ -5,8 +5,8 @@
             "name": "Debug",
             "type": "cppdbg",
             "request": "launch",
-            "program": "${workspaceFolder}/proxyServerTcp",
-            "args": [],
+            "program": "${workspaceFolder}/proxyServer",
+            "args": ["0", "8080"],
             "stopAtEntry": false,
             "cwd": "${workspaceFolder}",
             "environment": [],

.vscode/tasks.json

@@ -9,12 +9,9 @@
                 "-std=c++14",
                 "-g",
                 "-o",
-                "proxyServerTcp",
+                "proxyServer",
                 "-I",
                 "include",
-                // "-I",
-                // "include/bolt",
-                // "*.cpp",
                 "src/*.cpp",
                 "-lhv",
                 "-lspdlog"

Dockerfile

@@ -50,7 +50,7 @@ WORKDIR /app
 COPY . .
 
 # Compile the C++ program
-RUN g++ -std=c++14 -g -o proxyServerTcp src/*.cpp -I include -lhv -lspdlog
+RUN g++ -std=c++14 -g -o proxyServer src/*.cpp -I include -lhv -lspdlog
 
 RUN apt-get install -y tzdata
 
@@ -61,4 +61,4 @@ RUN dpkg-reconfigure --frontend noninteractive tzdata
 
 EXPOSE 8080
 # Run my_program when the container launches
-CMD ["./proxyServerTcp"]
+CMD ["./proxyServer 0 8080"]

include/conn_map.h

@@ -7,18 +7,12 @@
 #include <mutex>
 #include <memory>
 
+
 template <typename Key, typename Value>
-class ConnMap {
+class SafeMap {
 public:
-    static ConnMap& getInstance() {
-        static ConnMap instance; // 在首次使用时创建
-        return instance;
-    }
-
-    ConnMap(ConnMap const&) = delete;
-    void operator=(ConnMap const&) = delete;
 
-    void add(const Key& key, std::unique_ptr<Value> value) {
+    void add(const Key& key, std::unique_ptr<Value> &value) {
         std::unique_lock<std::shared_timed_mutex> lock(mutex_);
         map_[key] = std::move(value);
     }
@@ -41,11 +35,48 @@ public:
         std::unique_lock<std::shared_timed_mutex> lock(mutex_);
         map_.clear();
     }
+    
+    typename std::map<Key, std::unique_ptr<Value>>::iterator begin() {
+        return map_.begin();
+    }
 
-private:
-    ConnMap() = default;
+    typename std::map<Key, std::unique_ptr<Value>>::iterator end() {
+        return map_.end();
+    }
+    
+protected:
     mutable std::shared_timed_mutex mutex_;
     std::map<Key, std::unique_ptr<Value>> map_;
 };
 
+template <typename Key, typename Value>
+class TcpConnMap : public SafeMap<Key, Value> {
+public:
+    static TcpConnMap& getInstance() {
+        static TcpConnMap instance; // 在首次使用时创建
+        return instance;
+    }
+
+    TcpConnMap(TcpConnMap const&) = delete;
+    void operator=(TcpConnMap const&) = delete;
+
+private:
+    TcpConnMap() = default;
+};
+
+template <typename Key, typename Value>
+class UdpConnMap : public SafeMap<Key, Value> {
+public:
+    static UdpConnMap& getInstance() {
+        static UdpConnMap instance; // 在首次使用时创建
+        return instance;
+    }
+
+    UdpConnMap(UdpConnMap const&) = delete;
+    void operator=(UdpConnMap const&) = delete;
+
+private:
+    UdpConnMap() = default;
+};
+
 #endif //PROXYSERVER_CONN_MAP_H

include/hv_utils.h

@@ -8,5 +8,7 @@ void init_loop(int _thread_num, hthread_routine worker_thread);
 
 hloop_t* get_next_loop();
 
+char generateRandomKey();
+
 
 #endif //PROXYSERVER_HV_UTILS_H

include/tcp_client_map.h

@@ -1,10 +1,11 @@
-#ifndef PROXYSERVER_CONN_MAP_H
-#define PROXYSERVER_CONN_MAP_H
+#ifndef PROXYSERVER_TCP_CLIENT_MAP_H
+#define PROXYSERVER_TCP_CLIENT_MAP_H
 
 #include <iostream>
 #include <map>
 #include <shared_mutex>
 #include <mutex>
+#include <memory>
 
 template <typename Key, typename Value>
 class TcpClientMap {
@@ -47,4 +48,4 @@ private:
     std::map<Key, Value> map_;
 };
 
-#endif //PROXYSERVER_CONN_MAP_H
+#endif //PROXYSERVER_TCP_CLIENT_MAP_H

include/udp_client.h

@@ -0,0 +1,61 @@
+#ifndef PROXYSERVER_UDP_CLIENT_H
+#define PROXYSERVER_UDP_CLIENT_H
+
+#include "hv/hloop.h"
+#include "hv/UdpClient.h"
+#include "bolt/crypt.h"
+#include "udp_client_map.h"
+#include <string>
+
+class UdpBoltConfig
+{
+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 UdpClientProxy
+{
+public:
+    UdpClientProxy(struct sockaddr_in t_addr, struct sockaddr_in u_addr, uint32_t session_id) : t_addr(t_addr), u_addr(u_addr), session_id(session_id) {}
+    hv::UdpClient *getClient() { return &cli; }
+    bool init();
+    void close();
+
+private:
+    void onRecv(const hv::SocketChannelPtr &channel, hv::Buffer *buf);
+    void onWrited(const hv::SocketChannelPtr &channel, hv::Buffer *buf);
+
+public:
+    struct sockaddr_in t_addr, u_addr;
+
+private:
+    hv::UdpClient cli;
+    uint32_t session_id;
+};
+
+class UdpServerBoltProxy
+{
+public:
+    UdpServerBoltProxy(hio_t *_io) : io(_io) {}
+
+    UdpBoltConfig &getConfig() { return config; }
+
+    bool analyzeData(struct sockaddr_in t_addr, struct sockaddr_in u_addr, uint32_t session_id, char *data, int data_len, char *extend, int extend_len);
+    
+    int sendData(struct sockaddr_in t_addr, struct sockaddr_in u_addr, void *data, int data_len);
+
+    void recycle();
+
+private:
+    UdpBoltConfig config;
+    hio_t *io;
+    UdpClientMap<std::string, UdpClientProxy> _map;
+};
+
+#endif // PROXYSERVER_UDP_CLIENT_H

include/udp_client_map.h

@@ -0,0 +1,12 @@
+#ifndef PROXYSERVER_UDP_CLIENT_MAP_H
+#define PROXYSERVER_UDP_CLIENT_MAP_H
+
+#include "conn_map.h"
+
+template <typename Key, typename Value>
+class UdpClientMap : public SafeMap<Key, Value> {
+public:
+
+};
+
+#endif //PROXYSERVER_UDP_CLIENT_MAP_H

include/udp_inbound.h

@@ -0,0 +1,9 @@
+#ifndef PROXYSERVER_UDP_INBOUND_H
+#define PROXYSERVER_UDP_INBOUND_H
+
+#include "hv/hloop.h"
+void udp_on_recvfrom(hio_t* io, void* buf, int readbytes);
+void udp_on_writed(hio_t* io, const void* buf, int writebytes);
+void udp_on_close(hio_t* io);
+
+#endif //PROXYSERVER_UDP_INBOUND_H

src/hv_utils.cpp

@@ -19,4 +19,13 @@ hloop_t* get_next_loop() {
         s_cur_index = 0;
     }
     return worker_loops[s_cur_index++];
+}
+
+char generateRandomKey()
+{
+    // 使用时间作为随机数种子，确保每次运行生成的随机数都不同
+    srand((unsigned int)time(NULL));
+
+    // 生成 'A' 到 'Z' 之间的随机字符
+    return (char)('A' + rand() % 26);
 }

src/main.cpp

@@ -131,6 +131,7 @@
 #include "hv/hthread.h"
 #include "hv_utils.h"
 #include "tcp_inbound.h"
+#include "udp_inbound.h"
 
 #include "spdlog/spdlog.h"
 #include "spdlog/async.h"
@@ -139,7 +140,7 @@
 static const char* host = "0.0.0.0";
 static int port = 8080;
 static int thread_num = 4;
-static hloop_t*  accept_loop = NULL;
+static hloop_t *tcpaccept_loop = NULL, *udpbind_loop = NULL;
 
 static void new_conn_event(hevent_t* ev) {
     hloop_t* loop = ev->loop;
@@ -167,7 +168,7 @@ static HTHREAD_RETTYPE worker_thread(void* userdata) {
     return 0;
 }
 
-static HTHREAD_RETTYPE accept_thread(void* userdata) {
+static HTHREAD_RETTYPE tcpaccept_thread(void* userdata) {
     hloop_t* loop = (hloop_t*)userdata;
     hio_t* listenio = hloop_create_tcp_server(loop, host, port, on_accept);
     if (listenio == NULL) {
@@ -177,12 +178,27 @@ static HTHREAD_RETTYPE accept_thread(void* userdata) {
     return 0;
 }
 
+static HTHREAD_RETTYPE udpbind_thread(void* userdata) {
+    hloop_t* loop = (hloop_t*)userdata;
+    hio_t* bindio = hloop_create_udp_server(loop, host, port);
+    if (bindio == NULL) {
+        exit(1);
+    }
+    spdlog::info("ProxyServer start: udp->{}", port);
+    hio_setcb_read(bindio, udp_on_recvfrom);
+    hio_setcb_write(bindio, udp_on_writed);
+    hio_setcb_close(bindio, udp_on_close);
+    hio_read(bindio);
+    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]);
+    int type = 0;
+    if (argc == 3) {
+        type = atoi(argv[1]);
+        port = atoi(argv[2]);
+    }
     int cores = std::thread::hardware_concurrency();
     if (cores > 0) {
         thread_num = cores;
@@ -198,12 +214,24 @@ int main(int argc, char** argv) {
     spdlog::set_default_logger(std::make_shared<spdlog::async_logger>(
         "ProxyServer", console_sink, spdlog::thread_pool(), spdlog::async_overflow_policy::block));
 
-    init_loop(thread_num, worker_thread);
 
     spdlog::info("ProxyServer start: threadNum:{:d}", thread_num);
 
-    accept_loop = hloop_new(HLOOP_FLAG_AUTO_FREE);
-    accept_thread(accept_loop);
+    if (type == 1)
+    {
+    //Udp
+        spdlog::info("ProxyServer start: udp->{}", port);
+        udpbind_loop = hloop_new(HLOOP_FLAG_AUTO_FREE);
+        udpbind_thread(udpbind_loop);
+    }
+    else {
+    //Tcp
+        init_loop(thread_num, worker_thread);
+        spdlog::info("ProxyServer start: tcp->{}", port);
+        tcpaccept_loop = hloop_new(HLOOP_FLAG_AUTO_FREE);
+        tcpaccept_thread(tcpaccept_loop);
+    }
+    
 
     return 0;
 }

src/tcp_client.cpp

@@ -1,19 +1,11 @@
 #include "tcp_client.h"
 #include "bolt/datagram.h"
 #include "tcp_client_map.h"
+#include "hv_utils.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];
@@ -49,7 +41,11 @@ void TcpClientBolt::onRecv(const hv::SocketChannelPtr &channel, hv::Buffer *buf)
 
 void TcpClientBolt::onWrited(const hv::SocketChannelPtr &channel, hv::Buffer *buf)
 {
-
+    if (channel.get()->isWriteComplete())
+    {
+        
+    }
+    
 }
 
 void TcpClientBolt::onDisConnection(const hv::SocketChannelPtr &channel)

src/tcp_inbound.cpp

@@ -9,16 +9,16 @@
 static void tcp_on_close(hio_t* io) {
     spdlog::info("tcp_on_close fd={} error={}\n", hio_fd(io), hio_error(io));
 
-    auto cli = ConnMap<hio_t*, TcpClientBolt>::getInstance().get(io);
+    auto cli = TcpConnMap<hio_t*, TcpClientBolt>::getInstance().get(io);
     if(cli) {
-        ConnMap<hio_t*, TcpClientBolt>::getInstance().remove(io);
+        TcpConnMap<hio_t*, TcpClientBolt>::getInstance().remove(io);
         cli->close();
     }
 }
 
 static void tcp_on_recv(hio_t* io, void* buf, int readbytes) {
     spdlog::info("tcp_on_recv fd={} buf({})={}\n", hio_fd(io), readbytes, (const char*)buf);
-    auto cli = ConnMap<hio_t*, TcpClientBolt>::getInstance().get(io);
+    auto cli = TcpConnMap<hio_t*, TcpClientBolt>::getInstance().get(io);
     if(cli) {
         if (cli->hasHandshake())
         {
@@ -41,7 +41,8 @@ void tcp_on_accept(hio_t* io, hevent_t* ev) {
             SOCKADDR_STR(hio_localaddr(io), localaddrstr),
             SOCKADDR_STR(hio_peeraddr(io), peeraddrstr));
 
-    ConnMap<hio_t*, TcpClientBolt>::getInstance().add(io, std::make_unique<TcpClientBolt>(io));
+    auto client = std::make_unique<TcpClientBolt>(io);
+    TcpConnMap<hio_t*, TcpClientBolt>::getInstance().add(io, client);
 
     hio_setcb_close(io, tcp_on_close);
     hio_setcb_read(io, tcp_on_recv);

src/udp_client.cpp

@@ -0,0 +1,100 @@
+#include "udp_client.h"
+#include "conn_map.h"
+#include "hv/UdpClient.h"
+#include "bolt/datagram.h"
+#include "spdlog/spdlog.h"
+#include <sstream>
+
+std::string get_key(struct sockaddr_in t_addr, struct sockaddr_in u_addr)
+{
+    std::ostringstream string_stream;
+    string_stream << t_addr.sin_addr.s_addr << t_addr.sin_port;
+    string_stream << u_addr.sin_addr.s_addr << u_addr.sin_port;
+    return string_stream.str();
+}
+
+bool UdpServerBoltProxy::analyzeData(struct sockaddr_in t_addr, struct sockaddr_in u_addr,
+                                     uint32_t session_id, char *dest, int dest_len, char *extend, int extend_len)
+{
+    auto key = get_key(t_addr, u_addr);
+    auto client = _map.get(key);
+    if (!client)
+    {
+        std::unique_ptr<UdpClientProxy> new_client = std::make_unique<UdpClientProxy>(t_addr, u_addr, session_id);
+        if (!new_client->init())
+        {
+            return false;
+        }
+        _map.add(key, new_client);
+        client = new_client.get();
+    }
+
+    if (getConfig().ept_type == CRYPT_TYPE::XOR)
+    {
+        xor_::crypt((char *)dest, dest_len, getConfig().ept_key);
+    }
+
+    client->getClient()->sendto(dest, dest_len);
+
+    return true;
+}
+
+int UdpServerBoltProxy::sendData(struct sockaddr_in t_addr, struct sockaddr_in u_addr, void *data, int data_len)
+{
+    PACK_TUNNEL_DATA(boltdata, boltdata_len, BOLT_VERSION, BOLT_RESERVE, BOLT_PAYLOAD_TYPE_UDP, t_addr.sin_addr.s_addr, t_addr.sin_port, u_addr.sin_addr.s_addr, u_addr.sin_port, config.session_id, 0, 0, data, data_len)
+    hio_write(io, boltdata, boltdata_len);
+}
+
+void UdpServerBoltProxy::recycle()
+{
+    for (auto it = _map.begin(); it != _map.end(); ++it)
+    {
+        it->second->close();
+    }
+    _map.clear();
+}
+
+bool UdpClientProxy::init()
+{
+
+    int sockfd = cli.createsocket(t_addr.sin_port, inet_ntoa(t_addr.sin_addr));
+    if (sockfd < 0)
+    {
+        return false;
+    }
+    cli.onWriteComplete = [this](const hv::SocketChannelPtr &channel, hv::Buffer *buf)
+    {
+        onWrited(channel, buf);
+    };
+    cli.onMessage = [this](const hv::SocketChannelPtr &channel, hv::Buffer *buf)
+    {
+        onRecv(channel, buf);
+    };
+    hio_setcb_close(cli.channel.get()->io(), [](hio_t *io) {
+
+    });
+
+    cli.start();
+    return true;
+}
+
+void UdpClientProxy::close()
+{
+    cli.closesocket();
+}
+
+void UdpClientProxy::onRecv(const hv::SocketChannelPtr &channel, hv::Buffer *buf)
+{
+    spdlog::info("<<< size:{} : data: {}", (int)buf->size(), (char *)buf->data());
+    auto serverProxy = UdpConnMap<uint32_t, UdpServerBoltProxy>::getInstance().get(session_id);
+    if (!serverProxy)
+    {
+        return;
+    }
+    serverProxy->sendData(t_addr, u_addr, buf->data(), buf->size());
+}
+
+void UdpClientProxy::onWrited(const hv::SocketChannelPtr &channel, hv::Buffer *buf)
+{
+    spdlog::info(">>> size:{} : data: {}", (int)buf->size(), (char *)buf->data());
+}

src/udp_inbound.cpp

@@ -0,0 +1,85 @@
+#include "udp_inbound.h"
+#include "udp_client.h"
+#include "conn_map.h"
+#include "hv_utils.h"
+#include "bolt/datagram.h"
+#include "bolt/crypt.h"
+
+void udp_on_recvfrom(hio_t *io, 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 == 73 && dest[0] == BOLT_CHANNEL_CMD_BIND_REQUEST)
+                {
+                    UNPACK_BIND_DATA(command, request_id, signal_id, session_id, data_st, dest, dest_len)
+                    UdpServerBoltProxy *serverProxy = new UdpServerBoltProxy(io);
+                    serverProxy->getConfig().request_id = request_id;
+                    serverProxy->getConfig().session_id = session_id;
+                    serverProxy->getConfig().data_st = data_st;
+                    serverProxy->getConfig().signal_id = signal_id;
+                    if (extend_len >= 5)
+                    {
+                        if (strcmp(extend, "ept=1") == 0)
+                        {
+                            serverProxy->getConfig().encrypt = true;
+                        }
+                    }
+                    serverProxy->getConfig().ept_type = serverProxy->getConfig().encrypt ? CRYPT_TYPE::XOR : CRYPT_TYPE::NONE;
+                    serverProxy->getConfig().ept_key = serverProxy->getConfig().encrypt ? generateRandomKey() : 0;
+
+                    GENERATE_DECRYPT_KEY(extend_response, extend_response_len, serverProxy->getConfig().ept_type, serverProxy->getConfig().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);
+
+                    auto proxy = std::unique_ptr<UdpServerBoltProxy>(serverProxy);
+                    UdpConnMap<uint32_t, UdpServerBoltProxy>::getInstance().add(session_id, proxy);
+                }
+                else if (dest_len == 9 && dest[0] == BOLT_CHANNEL_CMD_UNBIND_REQUEST)
+                {
+                    UNPACK_UNBIND_DATA(command, session_id, code, dest, dest_len)
+
+                    auto serverProxy = UdpConnMap<uint32_t, UdpServerBoltProxy>::getInstance().get(session_id);
+                    serverProxy->recycle();
+                    UdpConnMap<uint32_t, UdpServerBoltProxy>::getInstance().remove(session_id);
+                }
+                else
+                {
+                }
+            }
+            else if (type == BOLT_PAYLOAD_TYPE_UDP)
+            {
+
+                auto serverProxy = UdpConnMap<uint32_t, UdpServerBoltProxy>::getInstance().get(session_id);
+                struct sockaddr_in t_addr = {0}, u_addr = {0};
+                t_addr.sin_addr.s_addr = t_ip;
+                t_addr.sin_port = t_port;
+                u_addr.sin_addr.s_addr = u_ip;
+                u_addr.sin_port = u_port;
+                if (serverProxy && serverProxy->analyzeData(t_addr, u_addr, session_id, dest, dest_len, extend, extend_len))
+                {
+                }
+            }
+        }
+    }
+}
+
+void udp_on_writed(hio_t *io, const void *buf, int writebytes)
+{
+
+}
+
+void udp_on_close(hio_t *io)
+{
+
+}