[fix]support tcp

.vscode/settings.json

@@ -71,6 +71,14 @@
         "algorithm": "cpp",
         "shared_mutex": "cpp",
         "__memory": "cpp",
-        "thread": "cpp"
+        "thread": "cpp",
+        "bit": "cpp",
+        "charconv": "cpp",
+        "condition_variable": "cpp",
+        "format": "cpp",
+        "future": "cpp",
+        "functional": "cpp",
+        "memory_resource": "cpp",
+        "utility": "cpp"
     }
 }

.vscode/tasks.json

@@ -12,8 +12,11 @@
                 "test",
                 "-I",
                 "include",
+                "-I",
+                "include/bolt",
                 "hv_utils.cpp",
                 "tcp_inbound.cpp",
+                "tcp_client.cpp",
                 "main.cpp",
                 "-lhv",
                 "-lspdlog"

include/bolt/crypt.h

@@ -7,7 +7,7 @@
 
 enum CRYPT_TYPE {
     NONE = 0,
-    XOR = '1'
+    XOR = 1
 };
 
 namespace xor_ {
@@ -32,6 +32,14 @@ if(encrypt) {
     extend_len = sprintf(extend, "ept=1");                                                          \
 }                                                                                                   \
 
+#define GENERATE_DECRYPT_KEY(extend, extend_len, ept_type, ept_key)                                 \
+    char extend[21] = {0};                                                                          \
+    int extend_len = 0;                                                                             \
+    int type_len = snprintf(extend, sizeof(extend), "ept_type=%d", ept_type);                       \
+    if (ept_type == XOR) {                                                                          \
+        extend_len = snprintf(extend + type_len, sizeof(extend) - type_len, ";ept_key=%c", ept_key);\
+    }                                                                                               \
+
 #define EXTRACTION_DECRYPT_KEY(ept_type, ept_key, extend, extend_len)                               \
 CRYPT_TYPE ept_type = NONE;                                                                         \
 char ept_key;                                                                                       \

include/bolt/datagram.h

@@ -137,14 +137,33 @@ struct Bolt_Payload {
     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)                        \
+#define UNPACK_BIND_DATA(command, request_id, signal_id, session_id, data_st, data, data_len)                               \
+    uint8_t command = *(data);                                                                                              \
+    uint32_t request_id = 0;                                                                                                \
+    char signal_id[32] = {0};                                                                                               \
+    uint32_t session_id = 0;                                                                                                \
+    char data_st[32] = {0};                                                                                                 \
+    memcpy(&request_id, (char*)data + 1, 4);                                                                                \
+    memcpy(&signal_id, (char*)data + 5, 32);                                                                                \
+    memcpy(&session_id, (char*)data + 37, 4);                                                                               \
+    memcpy(&data_st, (char*)data + 41, 32);                                                                                 \
+
+#define PACK_BIND_RESPONSE_DATA(res, res_len, command, request_id, session_id, response_result)                             \
+    char res[13] = {0};                                                                                                     \
+    int res_len = 13;                                                                                                       \
+    res[0] = command;                                                                                                       \
+    memcpy(res + 1, &request_id, 4);                                                                                        \
+    memcpy(res + 5, &session_id, 4);                                                                                        \
+    memcpy(res + 9, &response_result, 4);                                                                                   \
+
+#define UNPACK_BIND_RESPONSE_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);                                                                      \
+    memcpy(&response_result, (char*)bind_resp + 9, 4);
 
 #define PACK_UNBIND_DATA(res, res_len, session_id, code)                                                                    \
     char res[9] = {0};                                                                                                      \
@@ -153,6 +172,13 @@ struct Bolt_Payload {
     memcpy(res + 1, &session_id, 4);                                                                                        \
     memcpy(res + 5, &code, 4);                                                                                              \
 
+#define UNPACK_UNBIND_DATA(command, session_id, code, data, data_len)                                                       \
+    uint8_t command = *(data);                                                                                              \
+    uint32_t session_id = 0;                                                                                                \
+    uint32_t code = 0;                                                                                                      \
+    memcpy(&session_id, (char*)data + 1, 4);                                                                                \
+    memcpy(&code, (char*)data + 5, 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];                                                                                                      \

include/conn_map.h

@@ -17,16 +17,16 @@ public:
     ConnMap(ConnMap const&) = delete;
     void operator=(ConnMap const&) = delete;
 
-    void add(const Key& key, const Value& value) {
+    void add(const Key& key, std::unique_ptr<Value> value) {
         std::unique_lock<std::shared_timed_mutex> lock(mutex_);
-        map_[key] = value;
+        map_[key] = std::move(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 it->second.get();
         }
         return nullptr;
     }
@@ -44,7 +44,7 @@ public:
 private:
     ConnMap() = default;
     mutable std::shared_timed_mutex mutex_;
-    std::map<Key, Value> map_;
+    std::map<Key, std::unique_ptr<Value>> map_;
 };
 
 #endif //PROXYSERVER_CONN_MAP_H

tcp_inbound.cpp

@@ -1,77 +1,33 @@
 #include "include/tcp_inbound.h"
 #include "include/conn_map.h"
-#include "include/accumulator.h"
+#include "include/tcp_client.h"
 #include "hv/hsocket.h"
 #include "hv/hthread.h"
 #include "hv/TcpClient.h"
 #include "spdlog/spdlog.h"
 #include <string>
 
-class TcpClientShell {
-    public:
-        bool init(hio_t* _io) {
-            io = _io;
-            int connfd = cli.createsocket(hio_peeraddr(io));
-            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());
-                    if (wait_send_buf.getDataSize() > 0)
-                    {
-                        cli.send(wait_send_buf.getData(), wait_send_buf.getDataSize());
-                    }
-                } else {
-                    spdlog::info("disconnected to {}! connfd={}\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());
-                spdlog::info("< %.*s\n", (int)buf->size(), (char*)buf->data());
-            };
-
-            cli.onWriteComplete = [this](const hv::SocketChannelPtr& channel, hv::Buffer* buf) {
-
-            };
-            cli.start();
-            return true;
-        }
-
-        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) {
     spdlog::info("tcp_on_close fd={} error={}\n", hio_fd(io), hio_error(io));
-    ConnMap<hio_t*, TcpClientShell>::getInstance().remove(io);
+
+    auto cli = ConnMap<hio_t*, TcpClientBolt>::getInstance().get(io);
+    if(cli) {
+        ConnMap<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);
-    hio_write(io, buf, readbytes);
-    auto cli = ConnMap<hio_t*, TcpClientShell>::getInstance().get(io);
+    auto cli = ConnMap<hio_t*, TcpClientBolt>::getInstance().get(io);
     if(cli) {
-        cli->send((const char*) buf, readbytes);
+        if (cli->hasHandshake())
+        {
+            cli->send((char*) buf, readbytes);
+        } else {
+            cli->handShake(buf, readbytes);
+        }
+        
     }
 }
 
@@ -86,6 +42,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));
+
     hio_setcb_close(io, tcp_on_close);
     hio_setcb_read(io, tcp_on_recv);
     hio_read(io);