[fix]tcp runtime error

.vscode/launch.json

@@ -6,7 +6,7 @@
             "type": "cppdbg",
             "request": "launch",
             "program": "${workspaceFolder}/proxyServer",
-            "args": ["0", "8080"],
+            "args": ["0", "8000"],
             "stopAtEntry": false,
             "cwd": "${workspaceFolder}",
             "environment": [],

main.cpp

@@ -17,23 +17,25 @@
 #include "spdlog/async.h"
 #include "spdlog/sinks/stdout_color_sinks.h"
 
-static const char* host = "0.0.0.0";
+static const char *host = "0.0.0.0";
 static int port = 8080;
 static int thread_num = 4;
 static hloop_t *tcpaccept_loop = NULL, *udpbind_loop = NULL;
 
-static void new_conn_event(hevent_t* ev) {
-    hloop_t* loop = ev->loop;
-    hio_t* io = (hio_t*)hevent_userdata(ev);
+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) {
+static void on_accept(hio_t *io)
+{
     hio_detach(io);
 
-    hloop_t* worker_loop = get_next_loop();
+    hloop_t *worker_loop = get_next_loop();
     hevent_t ev;
     memset(&ev, 0, sizeof(ev));
     ev.loop = worker_loop;
@@ -42,16 +44,19 @@ static void on_accept(hio_t* io) {
     hloop_post_event(worker_loop, &ev);
 }
 
-static HTHREAD_RETTYPE worker_thread(void* userdata) {
-    hloop_t* loop = (hloop_t*)userdata;
+static HTHREAD_RETTYPE worker_thread(void *userdata)
+{
+    hloop_t *loop = (hloop_t *)userdata;
     hloop_run(loop);
     return 0;
 }
 
-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) {
+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)
+    {
         exit(1);
     }
     int listeniofd = hio_fd(listenio);
@@ -60,10 +65,12 @@ static HTHREAD_RETTYPE tcpaccept_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) {
+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);
     }
     int bindfd = hio_fd(bindio);
@@ -77,17 +84,20 @@ static HTHREAD_RETTYPE udpbind_thread(void* userdata) {
     return 0;
 }
 
-int main(int argc, char** argv) {
+int main(int argc, char **argv)
+{
     int type = 0;
-    if (argc == 3) {
+    if (argc == 3)
+    {
         type = atoi(argv[1]);
         port = atoi(argv[2]);
     }
     int cores = std::thread::hardware_concurrency();
-    if (cores > 0) {
+    if (cores > 0)
+    {
         thread_num = cores;
     }
-    
+
     auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
     auto logger = std::make_shared<spdlog::logger>("my_logger", console_sink);
 
@@ -98,24 +108,23 @@ 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));
 
-
     spdlog::info("ProxyServer start: threadNum:{:d}", thread_num);
 
     if (type == 1)
     {
-    //Udp
+        // Udp
         spdlog::info("ProxyServer start: udp->{}", port);
         udpbind_loop = hloop_new(HLOOP_FLAG_AUTO_FREE);
         udpbind_thread(udpbind_loop);
     }
-    else {
-    //Tcp
+    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

@@ -14,7 +14,8 @@ void TcpClientBolt::onConnection(const hv::SocketChannelPtr &channel)
     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_write(io, boltdata, boltdata_len);
+    spdlog::info("BOLT_CHANNEL_CMD_TCP_HANDSHAKE_REQUEST: t_addr={}:{}, u_addr={}:{} ==> connect succ", inet_ntoa(t_addr.sin_addr), htons(t_addr.sin_port), inet_ntoa(u_addr.sin_addr), htons(u_addr.sin_port));
 }
 
 void TcpClientBolt::onRecv(const hv::SocketChannelPtr &channel, hv::Buffer *buf)
@@ -34,22 +35,28 @@ void TcpClientBolt::onRecv(const hv::SocketChannelPtr &channel, hv::Buffer *buf)
                 break;
             }
         }
+        hio_write(io, buf->data(), buf->size());
     }
+    spdlog::info("t_addr={}:{}, u_addr={}:{} onRecv==> {}={}", inet_ntoa(t_addr.sin_addr), htons(t_addr.sin_port), inet_ntoa(u_addr.sin_addr), htons(u_addr.sin_port), buf->len, (const char*)buf->data());
 
-    hio_write(io, buf->data(), buf->size());
 }
 
 void TcpClientBolt::onWrited(const hv::SocketChannelPtr &channel, hv::Buffer *buf)
 {
     if (channel.get()->isWriteComplete())
     {
-        
+        spdlog::info("t_addr={}:{}, u_addr={}:{} isWriteComplete==> {}={}", inet_ntoa(t_addr.sin_addr), htons(t_addr.sin_port), inet_ntoa(u_addr.sin_addr), htons(u_addr.sin_port), buf->len, (const char*)buf->data());
     }
     
 }
 
 void TcpClientBolt::onDisConnection(const hv::SocketChannelPtr &channel)
 {
+    if (is_bolt_server)
+    {
+        TcpClientMap<uint32_t, tcpBoltConfig>::getInstance().remove(session_id);
+    }
+    
     hio_close(io);
 }
 
@@ -64,8 +71,10 @@ bool TcpClientBolt::handShake(void *buf, int readbytes)
             {
                 if (dest_len == 1 && dest[0] == BOLT_CHANNEL_CMD_TCP_HANDSHAKE_REQUEST)
                 {
+                    this->t_addr.sin_family = AF_INET;
                     this->t_addr.sin_addr.s_addr = t_ip;
                     this->t_addr.sin_port = t_port;
+                    this->u_addr.sin_family = AF_INET;
                     this->u_addr.sin_addr.s_addr = u_ip;
                     this->u_addr.sin_port = u_port;
                     this->session_id = session_id;
@@ -83,6 +92,7 @@ bool TcpClientBolt::handShake(void *buf, int readbytes)
                     
                     if (!this->connect((struct sockaddr *)&t_addr))
                     {
+                        spdlog::info("BOLT_CHANNEL_CMD_TCP_HANDSHAKE_REQUEST: t_addr={}:{}, u_addr={}:{} ==> connect fail", inet_ntoa(t_addr.sin_addr), htons(t_addr.sin_port), inet_ntoa(u_addr.sin_addr), htons(u_addr.sin_port));
                         char buff[2];
                         buff[0] = BOLT_CHANNEL_CMD_TCP_HANDSHAKE_RESPONSE;
                         buff[1] = BOLT_TCP_HANDSHAKE_FAIL_TIMEOUT;
@@ -114,9 +124,11 @@ bool TcpClientBolt::handShake(void *buf, int readbytes)
                     config.ept_type = config.encrypt ? CRYPT_TYPE::XOR : CRYPT_TYPE::NONE;
                     config.ept_key = config.encrypt ? generateRandomKey() : 0;
 
+                    spdlog::info("BOLT_CHANNEL_CMD_BIND_REQUEST: requestId:{}, session_id:{}, encrypt:{}", request_id, session_id, config.encrypt);
+
                     GENERATE_DECRYPT_KEY(extend_response, extend_response_len, config.ept_type, config.ept_key)
 
-                    char result[1] = {BOLT_BIND_RESPONSE_CODE_SUCESS};
+                    uint32_t result = BOLT_BIND_RESPONSE_CODE_SUCESS;
 
                     PACK_BIND_RESPONSE_DATA(bind_response, bind_response_len, BOLT_CHANNEL_CMD_BIND_RESPONSE, request_id, session_id, result)
 
@@ -133,6 +145,7 @@ bool TcpClientBolt::handShake(void *buf, int readbytes)
                     TcpClientMap<uint32_t, tcpBoltConfig>::getInstance().remove(session_id);
                     this->close();
                     hio_close_async(io);
+                    spdlog::info("BOLT_CHANNEL_CMD_UNBIND_REQUEST: t_addr={}:{}, u_addr={}:{}", inet_ntoa(t_addr.sin_addr), htons(t_addr.sin_port), inet_ntoa(u_addr.sin_addr), htons(u_addr.sin_port));
                 }
             }
         }

src/tcp_inbound.cpp

@@ -17,7 +17,7 @@ static void tcp_on_close(hio_t* io) {
 }
 
 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);
+    spdlog::info("tcp_on_recv fd={} buf({})={}", hio_fd(io), readbytes, (const char*)buf);
     auto cli = TcpConnMap<hio_t*, TcpClientBolt>::getInstance().get(io);
     if(cli) {
         if (cli->hasHandshake())
@@ -27,7 +27,7 @@ static void tcp_on_recv(hio_t* io, void* buf, int readbytes) {
             cli->handShake(buf, readbytes);
         }
         
-    }
+    } 
 }
 
 void tcp_on_accept(hio_t* io, hevent_t* ev) {

src/udp_client.cpp

@@ -30,10 +30,10 @@ bool UdpServerBoltProxy::analyzeData(struct sockaddr_in t_addr, struct sockaddr_
         client = new_client.get();
     }
 
-    if (getConfig().ept_type == CRYPT_TYPE::XOR)
-    {
-        xor_::crypt((char *)dest, dest_len, getConfig().ept_key);
-    }
+    // if (getConfig().ept_type == CRYPT_TYPE::XOR)
+    // {
+    //     xor_::crypt((char *)dest, dest_len, getConfig().ept_key);
+    // }
 
     client->getClient()->sendto(dest, dest_len);
 
@@ -43,10 +43,10 @@ bool UdpServerBoltProxy::analyzeData(struct sockaddr_in t_addr, struct sockaddr_
 int UdpServerBoltProxy::sendData(struct sockaddr_in t_addr, struct sockaddr_in u_addr, void *data, int data_len)
 {
 
-    if (getConfig().ept_type == CRYPT_TYPE::XOR)
-    {
-        xor_::crypt((char *)data, data_len, getConfig().ept_key);
-    }
+    // if (getConfig().ept_type == CRYPT_TYPE::XOR)
+    // {
+    //     xor_::crypt((char *)data, data_len, getConfig().ept_key);
+    // }
     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)
     return hio_write(io, boltdata, boltdata_len);
 

src/udp_inbound.cpp

@@ -62,8 +62,10 @@ void udp_on_recvfrom(hio_t *io, void *buf, int readbytes)
 
                 auto serverProxy = UdpConnMap<uint32_t, UdpServerBoltProxy>::getInstance().get(session_id);
                 struct sockaddr_in t_addr = {0}, u_addr = {0};
+                t_addr.sin_family = AF_INET;
                 t_addr.sin_addr.s_addr = t_ip;
                 t_addr.sin_port = t_port;
+                u_addr.sin_family = AF_INET;
                 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))