1

server/tools/protobuild/ss_proto.proto

@@ -24,7 +24,6 @@ message SS_CMKcpHandshake
     optional string account_id = 2; //账号id
     optional string session_id = 3; //session id
     optional string team_uuid = 4; //保留
-    optional int32 secret_key_place = 5; //私钥存放位置 0：存在用户协议前(老) 1：存在kcp底层协议头之后(新)
 }
 
 message SS_SMKcpHandshake

server/wsproxy/app.cc

@@ -25,6 +25,7 @@
 #include "upstreammgr.h"
 #include "master.h"
 #include "mastermgr.h"
+#include "mmcache.h"
 
 #include "longsessionmgr.h"
 
@@ -115,10 +116,10 @@ bool App::Init(int argc, char* argv[])
                 });
 
     uuid_ = std::make_shared<a8::uuid::SnowFlake>();
-    loop_mutex_ = new std::mutex();
-    loop_cond_ = new std::condition_variable();
-    msg_mutex_ = new std::mutex();
-    udp_msg_mutex_ = new std::mutex();
+    loop_mutex_ = std::make_shared<std::mutex>();
+    loop_cond_ = std::make_shared<std::condition_variable>();
+    msg_mutex_ = std::make_shared<std::mutex>();
+    udp_msg_mutex_ = std::make_shared<std::mutex>();
 
     srand(time(nullptr));
     InitLog();
@@ -127,6 +128,7 @@ bool App::Init(int argc, char* argv[])
     f8::Timer::Instance()->Init();
     JsonDataMgr::Instance()->Init();
     uuid_->SetMachineId((node_id_ - 1) * MAX_NODE_ID + instance_id_);
+    MMCache::Instance()->Init();
     DownStreamMgr::Instance()->Init();
     MasterMgr::Instance()->Init();
     UpStreamMgr::Instance()->Init();
@@ -189,6 +191,7 @@ void App::UnInit()
     MasterMgr::Instance()->UnInit();
     UpStreamMgr::Instance()->UnInit();
     DownStreamMgr::Instance()->UnInit();
+    MMCache::Instance()->UnInit();
     JsonDataMgr::Instance()->UnInit();
     f8::Timer::Instance()->UnInit();
     f8::MsgQueue::Instance()->UnInit();
@@ -197,14 +200,6 @@ void App::UnInit()
 
     FreeSocketMsgQueue();
     FreeUdpMsgQueue();
-    delete msg_mutex_;
-    msg_mutex_ = nullptr;
-    delete udp_msg_mutex_;
-    udp_msg_mutex_ = nullptr;
-    delete loop_cond_;
-    loop_cond_ = nullptr;
-    delete loop_mutex_;
-    loop_mutex_ = nullptr;
     a8::XPrintf("wsproxy terminated instance_id:%d pid:%d\n", {instance_id_, getpid()});
 }
 
@@ -234,7 +229,8 @@ void App::AddSocketMsg(SocketFrom_e sockfrom,
                        int bodylen,
                        int tag)
 {
-    MsgNode *p = (MsgNode*)malloc(sizeof(MsgNode));
+    char* buf = MMCache::Instance()->AllocSocketMsg(sizeof(MsgNode) + bodylen);
+    MsgNode *p = (MsgNode*)buf;
     memset(p, 0, sizeof(MsgNode));
     p->sockfrom = sockfrom;
     p->ip_saddr = ip_saddr;
@@ -245,7 +241,7 @@ void App::AddSocketMsg(SocketFrom_e sockfrom,
     p->buflen = bodylen;
     p->tag = tag;
     if (bodylen > 0) {
-        p->buf = (char*)malloc(bodylen);
+        p->buf = buf + sizeof(MsgNode);
         memmove(p->buf, msgbody, bodylen);
     }
     msg_mutex_->lock();
@@ -370,10 +366,7 @@ void App::DispatchMsg()
             }
             break;
         }
-        if (pdelnode->buf) {
-            free(pdelnode->buf);
-        }
-        free(pdelnode);
+        MMCache::Instance()->FreeSocketMsg((char*)pdelnode);
         working_msgnode_size_--;
         if (a8::XGetTickCount() - starttick > 200) {
             break;
@@ -547,10 +540,7 @@ void App::FreeSocketMsgQueue()
     while (work_node_) {
         MsgNode* pdelnode = work_node_;
         work_node_ = work_node_->next;
-        if (pdelnode->buf) {
-            free(pdelnode->buf);
-        }
-        free(pdelnode);
+        MMCache::Instance()->FreeSocketMsg((char*)pdelnode);
         if (!work_node_) {
             work_node_ = top_node_;
             top_node_ = nullptr;
@@ -576,7 +566,7 @@ void App::FreeUdpMsgQueue()
                 free((void*)pdelnode->pkt->buf);
             }
             delete pdelnode->pkt;
-            free(pdelnode);
+            MMCache::Instance()->FreeUdpMsg((char*)pdelnode);
         }
         if (!udp_work_node_) {
             udp_work_node_ = udp_top_node_;
@@ -589,7 +579,8 @@ void App::FreeUdpMsgQueue()
 
 void App::AddUdpMsg(a8::UdpPacket* pkt)
 {
-    UdpMsgNode *p = (UdpMsgNode*) malloc(sizeof(UdpMsgNode));
+    char* buf = MMCache::Instance()->AllocUdpMsg(sizeof(UdpMsgNode));
+    UdpMsgNode *p = (UdpMsgNode*)buf;
     memset(p, 0, sizeof(UdpMsgNode));
     p->pkt = pkt;
     udp_msg_mutex_->lock();
@@ -626,7 +617,7 @@ void App::DispatchUdpMsg()
                 free((void*)pdelnode->pkt->buf);
             }
             delete pdelnode->pkt;
-            free(pdelnode);
+            MMCache::Instance()->FreeUdpMsg((char*)pdelnode);
         }
         udp_working_msgnode_size_--;
         if (a8::XGetTickCount() - starttick > 200) {

server/wsproxy/app.h

@@ -78,15 +78,15 @@ private:
     std::set<int> flags_;
 
     std::shared_ptr<a8::uuid::SnowFlake> uuid_;
-    std::mutex *loop_mutex_ = nullptr;
-    std::condition_variable *loop_cond_ = nullptr;
+    std::shared_ptr<std::mutex> loop_mutex_;
+    std::shared_ptr<std::condition_variable> loop_cond_;
 
-    std::mutex* msg_mutex_ = nullptr;
+    std::shared_ptr<std::mutex> msg_mutex_;
     MsgNode* top_node_ = nullptr;
     MsgNode* bot_node_ = nullptr;
     MsgNode* work_node_ = nullptr;
 
-    std::mutex* udp_msg_mutex_ = nullptr;
+    std::shared_ptr<std::mutex> udp_msg_mutex_;
     UdpMsgNode* udp_top_node_ = nullptr;
     UdpMsgNode* udp_bot_node_ = nullptr;
     UdpMsgNode* udp_work_node_ = nullptr;

server/wsproxy/constant.h

@@ -37,3 +37,5 @@ const int MAX_NODE_ID = 8;
 const int MAX_INSTANCE_ID = 500;
 
 const int ALLOC_TARGET_SERVER_SUCCESS_TIMER_EVENT = a8::TIMER_USER_EVENT + 1;
+
+const int PACK_MAX = 1024 * 64;

server/wsproxy/downstream.cc

@@ -25,7 +25,7 @@ void DownStream::ReBindUpStream(std::weak_ptr<UpStream> up)
 
 void DownStream::ForwardUpStreamMsg(f8::MsgHdr& hdr)
 {
-    char* buff = (char*)malloc(sizeof(f8::PackHead) + hdr.buflen);
+    char* buff = forward_buff_.data();
     f8::PackHead* head = (f8::PackHead*)buff;
     head->packlen = hdr.buflen;
     head->msgid = hdr.msgid;
@@ -41,10 +41,6 @@ void DownStream::ForwardUpStreamMsg(f8::MsgHdr& hdr)
             ss::SS_SMPing msg;
             msg.set_source(1);
             {
-                free(buff);
-
-                buff = (char*)malloc(sizeof(f8::PackHead) + msg.ByteSize());
-                f8::PackHead* head = (f8::PackHead*)buff;
                 head->packlen = msg.ByteSize();
                 head->msgid = hdr.msgid;
                 head->seqid = hdr.seqid;
@@ -59,7 +55,6 @@ void DownStream::ForwardUpStreamMsg(f8::MsgHdr& hdr)
     } else {
         GCListener::Instance()->SendBuf(hdr.socket_handle, buff, sizeof(f8::PackHead) + head->packlen);
     }
-    free(buff);
 }
 
 void DownStream::OnClose()

server/wsproxy/downstream.h

@@ -18,6 +18,7 @@ class DownStream
     void OnClose();
 
 private:
+    std::array<char, PACK_MAX> forward_buff_;
     int socket_handle_ = a8::INVALID_SOCKET_HANDLE;
     std::weak_ptr<UpStream> up_;
     bool is_long_session_ = false;

server/wsproxy/kcpsession.cc

@@ -1,7 +1,6 @@
 #include "precompile.h"
 
 #include <memory.h>
-#include <string.h>
 
 #include <f8/netmsghandler.h>
 #include <f8/udplog.h>
@@ -34,22 +33,23 @@ KcpSession::~KcpSession()
 
 }
 
-void KcpSession::Init(int socket_handle, int secret_key_place)
+void KcpSession::Init(int socket_handle)
 {
     socket_handle_ = socket_handle;
     secret_key_ = App::Instance()->NewUuid();
     kcp_ = ikcp_create(socket_handle_, (void*)this);
+#if 1
     const KcpConf& kcp_conf = JsonDataMgr::Instance()->GetKcpConf();
     ikcp_wndsize(kcp_, kcp_conf.sndwnd, kcp_conf.rcvwnd);
     ikcp_nodelay(kcp_, kcp_conf.nodelay, kcp_conf.interval, kcp_conf.resend, kcp_conf.nc);
     kcp_->rx_minrto = kcp_conf.rx_minrto;
     kcp_->fastresend = kcp_conf.fastresend;
-    secret_key_place_ = secret_key_place;
-    if (secret_key_place_ > 0) {
-        secret_key_place_ = 1;
-    } else if (secret_key_place_ < 0) {
-        secret_key_place_ = 0;
-    }
+#else
+    ikcp_wndsize(kcp_, 128, 128);
+    ikcp_nodelay(kcp_, 2, 10, 2, 1);
+    kcp_->rx_minrto = 10;
+    kcp_->fastresend = 1;
+#endif
     kcp_->output = UdpOutput;
     init_tick_ = a8::XGetTickCount();
 }
@@ -75,21 +75,8 @@ void KcpSession::SendClientMsg(char* buf, int buf_len)
 
 void KcpSession::OnRecvPacket(a8::UdpPacket* pkt)
 {
-    const int IKCP_OVERHEAD = 24;
-
     remote_addr_ = pkt->remote_addr;
-    if (GetSecretKeyPlace()) {
-        char* buf = (char*)malloc(pkt->buf_len - GetSecretKeyLen());
-        int buflen = pkt->buf_len - GetSecretKeyLen();
-        memmove(buf, pkt->buf, IKCP_OVERHEAD);
-        if (pkt->buf_len > IKCP_OVERHEAD + GetSecretKeyLen()) {
-            memmove(buf + IKCP_OVERHEAD, pkt->buf + IKCP_OVERHEAD + GetSecretKeyLen(), buflen - IKCP_OVERHEAD);
-        }
-        ikcp_input(kcp_, buf, buflen);
-        free(buf);
-    } else {
-        ikcp_input(kcp_, pkt->buf, pkt->buf_len);
-    }
+    ikcp_input(kcp_, pkt->buf, pkt->buf_len);
 }
 
 void KcpSession::UpdateInput()
@@ -104,20 +91,8 @@ void KcpSession::UpdateInput()
 
 void KcpSession::DecodeUserPacket(char* buf, int& offset, unsigned int buflen)
 {
-    if (GetSecretKeyPlace()) {
-        DecodeUserPacketNew(buf, offset, buflen);
-    } else {
-        DecodeUserPacketOld(buf, offset, buflen);
-    }
-}
-
-int KcpSession::GetSecretKeyPlace()
-{
-    return secret_key_place_;
-}
-
-void KcpSession::DecodeUserPacketOld(char* buf, int& offset, unsigned int buflen)
-{
+    //packagelen + msgid + magiccode + msgbody
+    //2 + 2 + 4+ xx + \0 + xx
     bool warning = false;
     while (buflen - offset >= sizeof(f8::PackHead) + GetSecretKeyLen()) {
         long long secret_key = KcpSession::ReadSecretKey(&buf[offset], buflen);
@@ -149,37 +124,6 @@ void KcpSession::DecodeUserPacketOld(char* buf, int& offset, unsigned int buflen
     }
 
     if (warning) {
-        f8::UdpLog::Instance()->Warning("收到kcp client非法数据包1", {});
-    }
-}
-
-void KcpSession::DecodeUserPacketNew(char* buf, int& offset, unsigned int buflen)
-{
-    bool warning = false;
-    while (buflen - offset >= sizeof(f8::PackHead)) {
-        f8::PackHead* p = (f8::PackHead*)&buf[offset];
-        if (p->magic_code == f8::MAGIC_CODE) {
-            if (buflen - offset < sizeof(f8::PackHead) + p->packlen) {
-                break;
-            }
-            App::Instance()->AddSocketMsg(SF_Client,
-                                          socket_handle_,
-                                          0,
-                                          //saddr,
-                                          p->msgid,
-                                          p->seqid,
-                                          &buf[offset + sizeof(f8::PackHead)],
-                                          p->packlen,
-                                          ST_Udp);
-            offset += sizeof(f8::PackHead) + p->packlen;
-        } else {
-            warning = true;
-            offset++;
-            continue;
-        }
-    }
-
-    if (warning) {
-        f8::UdpLog::Instance()->Warning("收到kcp client非法数据包2", {});
+        f8::UdpLog::Instance()->Warning("收到kcp client非法数据包", {});
     }
 }

server/wsproxy/kcpsession.h

@@ -11,7 +11,7 @@ public:
     KcpSession();
     ~KcpSession();
 
-    void Init(int socket_handle, int secret_key_place);
+    void Init(int socket_handle);
     void UnInit();
     void Update(long long tick);
 
@@ -19,7 +19,6 @@ public:
     int GetSocketHandle() { return socket_handle_; }
     long long GetSecretKey() { return secret_key_; }
     void* GetSecretKeyDataPtr() { return &secret_key_; }
-    int GetSecretKeyPlace();
 
     void SendClientMsg(char* buf, int buf_len);
     virtual void OnRecvPacket(a8::UdpPacket* pkt) override;
@@ -32,14 +31,11 @@ public:
 
 protected:
     virtual void DecodeUserPacket(char* buf, int& offset, unsigned int buflen) override;
-    void DecodeUserPacketOld(char* buf, int& offset, unsigned int buflen);
-    void DecodeUserPacketNew(char* buf, int& offset, unsigned int buflen);
 
 private:
     void UpdateInput();
 
 private:
-    int secret_key_place_ = 0;
     int socket_handle_ = 0;
     long long secret_key_ = 0;
     ikcpcb* kcp_ = nullptr;

server/wsproxy/longsession.cc

@@ -5,13 +5,10 @@
 #include "longsession.h"
 #include "kcpsession.h"
 
-#include "ss_msgid.pb.h"
-#include "ss_proto.pb.h"
-
 void LongSession::Init(f8::MsgHdr& hdr, const ss::SS_CMKcpHandshake& msg)
 {
     kcp_session_ = std::make_shared<KcpSession>();
-    kcp_session_->Init(hdr.socket_handle, msg.secret_key_place());
+    kcp_session_->Init(hdr.socket_handle);
 }
 
 void LongSession::UnInit()
@@ -28,8 +25,3 @@ void LongSession::UpdatePing()
 {
     last_ping_tick_ = a8::XGetTickCount();
 }
-
-int LongSession::GetSecretKeyPlace()
-{
-    return kcp_session_->GetSecretKeyPlace();
-}

server/wsproxy/longsession.h

@@ -17,7 +17,6 @@ class LongSession
 
     std::shared_ptr<KcpSession> GetKcpSession() { return kcp_session_; }
     void UpdatePing();
-    int GetSecretKeyPlace();
 
  private:
     long long last_ping_tick_ = 0;

server/wsproxy/longsessionmgr.cc

@@ -133,31 +133,30 @@ void LongSessionMgr::ProcUdpPacket(a8::UdpPacket* pkt)
                                         });
         return;
     }
-    if (session->GetSecretKeyPlace()) {
-        if (pkt->buf_len >= IKCP_OVERHEAD + KcpSession::GetSecretKeyLen()) {
-            long long secret_key = KcpSession::ReadSecretKey(pkt->buf + IKCP_OVERHEAD, pkt->buf_len);
-            if (secret_key == session->GetKcpSession()->GetSecretKey()) {
-                session->GetKcpSession()->OnRecvPacket(pkt);
-            } else {
-                f8::UdpLog::Instance()->Warning("ProcUdpPacket host:%s port:%d socket_handle%d secret_key:%d secret_error",
-                                                {
-                                                 inet_ntoa(pkt->remote_addr.sin_addr),
-                                                 pkt->remote_addr.sin_port,
-                                                 socket_handle,
-                                                 secret_key
-                                                });
-            }
+    session->GetKcpSession()->OnRecvPacket(pkt);
+#if 0
+    if (pkt->buf_len > IKCP_OVERHEAD + KcpSession::GetSecretKeyLen()) {
+        long long secret_key = KcpSession::ReadSecretKey(pkt->buf + IKCP_OVERHEAD, pkt->buf_len);
+        if (secret_key == session->GetKcpSession()->GetSecretKey()) {
+            session->GetKcpSession()->OnRecvPacket(pkt);
         } else {
-            f8::UdpLog::Instance()->Warning("ProcUdpPacket host:%s port:%d buflen:%d bufflen_error",
+            f8::UdpLog::Instance()->Warning("ProcUdpPacket host:%s port:%d socket_handle%d secret_key:%d secret_error",
                                             {
                                              inet_ntoa(pkt->remote_addr.sin_addr),
                                              pkt->remote_addr.sin_port,
-                                             pkt->buf_len
+                                             socket_handle,
+                                             secret_key
                                             });
         }
     } else {
-        session->GetKcpSession()->OnRecvPacket(pkt);
+        f8::UdpLog::Instance()->Warning("ProcUdpPacket host:%s port:%d buflen:%d bufflen_error",
+                                        {
+                                         inet_ntoa(pkt->remote_addr.sin_addr),
+                                         pkt->remote_addr.sin_port,
+                                         pkt->buf_len
+                                        });
     }
+#endif
 }
 
 void LongSessionMgr::DelSession(int socket_handle)

server/wsproxy/master.cc

@@ -13,8 +13,6 @@
 
 #include "app.h"
 
-const int PACK_MAX = 1024 * 64;
-
 void Master::Init(int instance_id, const std::string& remote_ip, int remote_port)
 {
     this->instance_id = instance_id;
@@ -23,10 +21,7 @@ void Master::Init(int instance_id, const std::string& remote_ip, int remote_port
 
     recv_bufflen_ = 0;
     last_pong_tick = a8::XGetTickCount();
-    recv_buff_ = (char*) malloc(PACK_MAX * 2);
-    tcp_client_ = std::make_shared<a8::TcpClient>();
-    tcp_client_->remote_address = remote_ip;
-    tcp_client_->remote_port = remote_port;
+    tcp_client_ = std::make_shared<a8::TcpClient>(remote_ip, remote_port);
     tcp_client_->on_error = std::bind(&Master::on_error, this, std::placeholders::_1, std::placeholders::_2);
     tcp_client_->on_connect = std::bind(&Master::on_connect, this, std::placeholders::_1);
     tcp_client_->on_disconnect = std::bind(&Master::on_disconnect, this, std::placeholders::_1);
@@ -53,8 +48,6 @@ void Master::UnInit()
     }
     tcp_client_ = nullptr;
     recv_bufflen_ = 0;
-    free(recv_buff_);
-    recv_buff_ = nullptr;
 }
 
 void Master::Open()
@@ -77,8 +70,8 @@ void Master::on_error(a8::TcpClient* sender, int errorId)
     f8::UdpLog::Instance()->Error("Master errorid=%d remote_ip:%s remote_port:%d",
                                   {
                                    errorId,
-                                   sender->remote_address,
-                                   sender->remote_port
+                                   sender->GetRemoteAddress(),
+                                   sender->GetRemotePort()
                                   });
 }
 
@@ -135,7 +128,7 @@ void Master::on_socketread(a8::TcpClient* sender, char* buf, unsigned int len)
         f8::UdpLog::Instance()->Debug("recvied bad package", {});
     }
     if (offset > 0 && offset < recv_bufflen_) {
-        memmove(recv_buff_, recv_buff_ + offset, recv_bufflen_ - offset);
+        memmove(recv_buff_.data(), recv_buff_.data() + offset, recv_bufflen_ - offset);
     }
     recv_bufflen_ -= offset;
     #if 1

server/wsproxy/master.h

@@ -39,7 +39,7 @@ class Master
     void CheckAlive();
 
  private:
-    char *recv_buff_ = nullptr;
+    std::array<char, PACK_MAX> recv_buff_;
     unsigned int recv_bufflen_ = 0;
     std::shared_ptr<a8::TcpClient> tcp_client_;
     f8::TimerWp timer_wp_;

server/wsproxy/mmcache.cc

@@ -0,0 +1,33 @@
+#include "precompile.h"
+
+#include "mmcache.h"
+
+void MMCache::Init()
+{
+    socket_msg_buffer_ = std::make_shared<a8::FifoBuffer>(1024 * 1024 * 10);
+    udp_msg_buffer_ = std::make_shared<a8::FifoBuffer>(1024 * 1024 * 10);
+}
+
+void MMCache::UnInit()
+{
+}
+
+char* MMCache::AllocSocketMsg(int len)
+{
+    return socket_msg_buffer_->Alloc(len);
+}
+
+void MMCache::FreeSocketMsg(char* p)
+{
+    socket_msg_buffer_->Free(p);
+}
+
+char* MMCache::AllocUdpMsg(int len)
+{
+    return udp_msg_buffer_->Alloc(len);
+}
+
+void MMCache::FreeUdpMsg(char* p)
+{
+    udp_msg_buffer_->Free(p);
+}

server/wsproxy/mmcache.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <a8/singleton.h>
+#include <a8/fifobuffer.h>
+
+class MMCache : public a8::Singleton<MMCache>
+{
+private:
+    MMCache() {};
+    friend class a8::Singleton<MMCache>;
+
+public:
+
+    void Init();
+    void UnInit();
+
+    char* AllocSocketMsg(int len);
+    void FreeSocketMsg(char* p);
+
+    char* AllocUdpMsg(int len);
+    void FreeUdpMsg(char* p);
+
+private:
+
+    std::shared_ptr<a8::FifoBuffer> socket_msg_buffer_;
+    std::shared_ptr<a8::FifoBuffer> udp_msg_buffer_;
+
+};

server/wsproxy/upstream.cc

@@ -14,8 +14,6 @@
 
 #include "app.h"
 
-const int PACK_MAX = 1024 * 64 * 2;
-
 void UpStream::Init(int instance_id, const std::string& remote_ip, int remote_port)
 {
     if (remote_ip.empty()) {
@@ -27,10 +25,7 @@ void UpStream::Init(int instance_id, const std::string& remote_ip, int remote_po
 
     recv_bufflen_ = 0;
     last_pong_tick = a8::XGetTickCount();
-    recv_buff_ = (char*) malloc(PACK_MAX * 2);
-    tcp_client_ = std::make_shared<a8::TcpClient>();
-    tcp_client_->remote_address = remote_ip;
-    tcp_client_->remote_port = remote_port;
+    tcp_client_ = std::make_shared<a8::TcpClient>(remote_ip, remote_port);
     tcp_client_->on_error = std::bind(&UpStream::on_error, this, std::placeholders::_1, std::placeholders::_2);
     tcp_client_->on_connect = std::bind(&UpStream::on_connect, this, std::placeholders::_1);
     tcp_client_->on_disconnect = std::bind(&UpStream::on_disconnect, this, std::placeholders::_1);
@@ -67,8 +62,6 @@ void UpStream::UnInit()
         abort();
     }
     recv_bufflen_ = 0;
-    free(recv_buff_);
-    recv_buff_ = nullptr;
 }
 
 void UpStream::Open()
@@ -111,7 +104,7 @@ void UpStream::SendStockMsg()
 
 void UpStream::ForwardClientMsg(f8::MsgHdr& hdr)
 {
-    char* buff = (char*)malloc(sizeof(f8::WSProxyPackHead_C) + hdr.buflen);
+    char* buff = forward_buff_.data();
     memset(buff, 0, sizeof(f8::WSProxyPackHead_C));
     f8::WSProxyPackHead_C* head = (f8::WSProxyPackHead_C*)buff;
     head->packlen = hdr.buflen;
@@ -129,7 +122,6 @@ void UpStream::ForwardClientMsg(f8::MsgHdr& hdr)
     }
 
     tcp_client_->SendBuff(buff, sizeof(f8::WSProxyPackHead_C) + head->packlen);
-    free(buff);
 }
 
 void UpStream::ForwardClientMsgEx(f8::MsgHdr* hdr)
@@ -153,8 +145,8 @@ void UpStream::on_error(a8::TcpClient* sender, int errorId)
     f8::UdpLog::Instance()->Error("target server errorid=%d remote_ip:%s remote_port:%d",
                                   {
                                    errorId,
-                                   sender->remote_address,
-                                   sender->remote_port
+                                   sender->GetRemoteAddress(),
+                                   sender->GetRemotePort()
                                   });
 }
 
@@ -163,8 +155,8 @@ void UpStream::on_connect(a8::TcpClient* sender)
     recv_bufflen_ = 0;
     f8::UdpLog::Instance()->Info("target server connected remote_ip:%s remote_port:%d",
                                  {
-                                   sender->remote_address,
-                                   sender->remote_port
+                                  sender->GetRemoteAddress(),
+                                  sender->GetRemotePort()
                                  });
     f8::MsgQueue::Instance()->PostMsg
         (
@@ -185,8 +177,8 @@ void UpStream::on_disconnect(a8::TcpClient* sender)
                                  "remote_ip:%s remote_port:%d",
                                  {
                                   instance_id,
-                                  sender->remote_address,
-                                  sender->remote_port
+                                  sender->GetRemoteAddress(),
+                                  sender->GetRemotePort()
                                  });
     f8::MsgQueue::Instance()->PostMsg
         (
@@ -242,7 +234,7 @@ void UpStream::on_socketread(a8::TcpClient* sender, char* buf, unsigned int len)
         f8::UdpLog::Instance()->Debug("recvied bad package", {});
     }
     if (offset > 0 && offset < recv_bufflen_) {
-        memmove(recv_buff_, recv_buff_ + offset, recv_bufflen_ - offset);
+        memmove(recv_buff_.data(), recv_buff_.data() + offset, recv_bufflen_ - offset);
     }
     recv_bufflen_ -= offset;
     #if 1

server/wsproxy/upstream.h

@@ -64,7 +64,8 @@ class UpStream
                      f8::MsgHdr* hdr);
 
  private:
-    char *recv_buff_ = nullptr;
+    std::array<char, PACK_MAX> recv_buff_;
+    std::array<char, PACK_MAX> forward_buff_;
     unsigned int recv_bufflen_ = 0;
     std::shared_ptr<a8::TcpClient> tcp_client_;
     f8::TimerWp timer_wp_;

third_party/a8

@@ -1 +1 @@
-Subproject commit 1e577389c8a2870db9ddbf18577bfca24def049b
+Subproject commit 424f7083751ca1d2bf289ac9be46b658437b7d33

third_party/f8

@@ -1 +1 @@
-Subproject commit 243bbe515ef4a01089f9a6cf608c93d4097018de
+Subproject commit 874ff7853e30ff22c556a2c4cbf4046423c7be86