基于KCP的可靠UDP封装

基于KCP的可靠UDP封装

交互原理

客户端服务端交互过程：
1)客户端与服务端都指定端口和IP，客户端服务端启动后，都创建KCP和socket ;
2)客户端在启动后，首先向服务端发送链接消息,在服务端未回复链接成功的确认标识时，客户端不断向服务端发送链接请求消息；
3)服务端在收到链接请求消息后，重置本地KCP，并向客户端发送链接成功确认消息，并启动服务端心跳，检测客户端消息；
4)客户端在收到服务端链接确认消息后，确认链接，并开始不断的向服务端发送心跳消息，以维持客户端与服务端的链接；
5)当客户端断开连接后，如果在服务端心跳还未超时得情况下，重启客户端，则服务端会收到客户端的连接消息，这时服务端就会重置KCP，并向客户端发送连接成功标识，客户端和服务端连接成功，如果服务端心跳超时，则服务端会关闭KCP，等到客户端链接消息后，启动KCP，建立和客户端的链接;
6)当服务端断开连接后，如果客户端心跳还未超时，服务端就重启了，则服务端在断开状态下收到客户端的心跳后，会向客户端发送链接请求，客户端收到链接请求后，会重置客户端KCP，并与服务端重新建立连接，如果客户端心跳超时，则客户端关闭KCP,并不断的向服务端发送连接请求消息，当服务端启动，收到连接请求消息后，会向客户端回复连接确认消息，以此建立客户端和服务端的连接。

直接上代码
kcp_udp.h

/********************************************
* 最终完成人：
* 最终完成时间：2020-11-25
* 类功能:使用KCP算法的UDP封装基类
*
*
****************************************/


#ifndef KCP_UDP_H
#define KCP_UDP_H

#include "ikcp.h"
#include "celltimestamp.h"
#include "cellthread.h"
#include "data.h"
#ifdef __linux__
#include <sys/socket.h>
#include <unistd.h>
#include <arpa/inet.h>
#endif

#ifdef WIN32
#include <winsock2.h>
#define MSG_NOSIGNAL 0
#define socklen_t int
#define MSG_DONTWAIT 0
#endif
#include <stdlib.h>
#include <string.h>
//客户端服务端统一会话标识
#define KCP_CONV 0x11223344
#define ushort unsigned short
#define KCP_RELEASE 0
#define ALL_RELEASE -1
#ifdef __linux__
#define SOCKET_ERROR -1
#endif
class kcp_udp
{
public:
    kcp_udp();

    /********************************************
    * 最终完成人：
    * 最终完成时间：2020-11-26
    * 函数功能：设置MTU,最大传输单元，默认为1400，最小为50
    *
    * 输入：ushort umtu 最大传输单元
    *
    *
    * 返回值：0 设置成功，-1 设置过小  -2 设置时申请内存失败,-3代表kcp未创建
    *
    *
    ****************************************/

    int setmtu(ushort umtu);
    /********************************************
    * 最终完成人：
    * 最终完成时间：2020-11-26
    * 函数功能：设置滑动窗口大小
    *
    * 输入：int sndwnd 发送滑动窗口大小 int recvwnd 接收滑动窗口大小
    *
    *
    * 返回值 0 代表成功,-1代表kcp未创建
    *
    *
    ****************************************/
    int setwndsize(int sndwnd,int recvwnd);

    /********************************************
    * 最终完成人：
    * 最终完成时间：2020-11-26
    * 函数功能：
    *
    * 输入：模式：model 0 默认模式  1 普遍模式，关闭流控 2 快速模式
    *
    *
    * 返回值 0，正常，-1失败
    *
    *
    ****************************************/
    int setnodelay(int model);

    /********************************************
    * 最终完成人：
    * 最终完成时间：2020-11-06
    * 函数功能：两种功能，参数为 0时，只关闭kcp,参数为 -1时，socket也关闭
    *
    * 输入：
    *
    *
    * 输出:
    *
    *
    ****************************************/
    void Close(int mode = KCP_RELEASE);
    /********************************************
    * 最终完成人：
    * 最终完成时间：2020-11-26
    * 函数功能：发送UDP数据
    *
    * 输入：const char* buff 发送缓冲区首地址，int len 发送数据长度
    *
    *
    * 返回值: -1 ,-2发送失败，0表示成功把数据加入到发送队列
    *
    *
    ****************************************/
    int kcp_send(const char* buff,int len);

    /********************************************
    * 最终完成人：
    * 最终完成时间：2020-11-26
    * 函数功能：
    *
    * 输入：char* buff 发送缓冲区首地址，int len 发送数据长度
    *
    *
    * 返回值 接收到的数据长度，小于 0代表无数据
    *
    *
    ****************************************/
    int kcp_recv(char* buff,int len);

    //刷新
    void kcp_flush();

    /********************************************
    * 最终完成人：
    * 最终完成时间：2020-11-26
    * 函数功能：kcp发送回调函数
    *
    * 输入：
    *
    *
    * 输出:
    *
    *
    ****************************************/
    static int udp_output(const char* buf,int len,ikcpcb* kcp,void* user);

    //获取重启状态
    bool getReconnect();
    //获取kcp发送队列的消息量
    IUINT32 getWaitSendNum();

    //发送是否停止，当发送队列大于滑动窗口两倍时不再发送数据，需要停止
    //true 需要停止发送，false 不需要停止
    bool needPaused();
protected:
    //kcp刷新线程执行函数
    void handle_update(CELLThread* pthead);
    //kcp接收线程执行函数,纯虚函数，分别有继承的客户端类和服务类实现
    virtual void recv_work(CELLThread *pthread) = 0;
    //kcp,日志回调函数
    static void write_log(const char *log, struct IKCPCB *kcp, void *user);

    //创建kcp，如果创建失败返回false,创建成功返回true;
    bool create();

    /********************************************
    * 最终完成人：李余同
    * 最终完成时间：2020-11-26
    * 函数功能：启动kcp，初始启动接收线程
    *
    * 输入：
    *
    *
    * 返回值: false 启动失败  true 启动成功
    *
    *
    ****************************************/
    bool start();
protected:
    //kcp结构指针
    ikcpcb *m_kcp = nullptr;
    //kcp跨线程锁
    std::mutex m_kcpMutex;
    //kcp，update频率,单位毫秒,默认10毫秒
    IUINT16 m_updateInterval = 10;
    //socket描述符
    int m_sockfd = SOCKET_ERROR;
    //kcp,update线程
    CELLThread m_updateThread;
    //kcp,接收线程
    CELLThread m_recvThread;

    //kcp，udp_output结构
    struct sockaddr_in ser_addr;

    //kcp监听端口和ip
    struct sockaddr_in client_addr;

    //recv接收到网络结构
    struct sockaddr_in recv_addr;

    //udp client server 心跳标识
    bool m_bconnect = false;

    //重启标志，获取改标志后，改标志变为未重启状态
    //false 未重启，true重启
    bool m_bRConnect = false;
};

#endif // KCP_UDP_H

kcp_udp.cpp

#include "kcp_udp.h"

kcp_udp::kcp_udp()
{

}


void kcp_udp::handle_update(CELLThread *pthead)
{
    time_t old = CELLTime::getNowInMilliSec();
    while(pthead->isRun())
    {
        if(CELLTime::getNowInMilliSec() - old >= m_updateInterval)
        {
            old = CELLTime::getNowInMilliSec();
            std::lock_guard<std::mutex> lock(m_kcpMutex);
            if(!m_kcp)
            {
                continue;
            }
            ikcp_update(m_kcp,old);
        }
    }
}


void kcp_udp::write_log(const char *log, IKCPCB *kcp, void *user)
{

}

bool kcp_udp::create()
{
    {
        std::lock_guard<std::mutex> lock(m_kcpMutex);
        if(m_kcp)
        {
            return true;
        }
        m_kcp = ikcp_create(KCP_CONV,(void*)this);
        m_kcp->output = udp_output;

    }
    {
        setnodelay(1);
        setwndsize(128,128);
    }
    if(m_sockfd == SOCKET_ERROR)
    {
        m_sockfd = socket(AF_INET,SOCK_DGRAM,0);
        int opt=1;
    #ifdef WIN32
        setsockopt(m_sockfd,SOL_SOCKET,SO_REUSEADDR,(char*)&opt,sizeof(opt));//端口复用
    #endif
    #ifdef __linux__
        setsockopt(m_sockfd,SOL_SOCKET,SO_REUSEADDR,(char*)&opt,sizeof(opt));
    #endif
        int ret = bind(m_sockfd,(struct sockaddr*)&client_addr,sizeof(client_addr));
        if(ret < 0)
        {
            return false;
        }
    }


    if(m_kcp && m_sockfd > 0)
    {
        return true;
    }
    else
    {
        Close(ALL_RELEASE);
    }
    return false;
}

bool kcp_udp::start()
{
    if(!create())
    {
         return false;
    }


    if(!m_recvThread.isRun())
    {
        m_recvThread.Start(nullptr,[&](CELLThread* pThread){
            recv_work(pThread);
        });
    }

    if(!m_updateThread.isRun())
    {
        m_updateThread.Start(nullptr,[&](CELLThread* pThread){
            handle_update(pThread);
        });
    }
    return true;
}

int  kcp_udp::setmtu(ushort umtu)
{
    std::lock_guard<std::mutex> lock(m_kcpMutex);
    if(!m_kcp)
    {
        return -3;
    }
    return ikcp_setmtu(m_kcp,umtu);
}

int kcp_udp::setwndsize(int sndwnd, int recvwnd)
{
     std::lock_guard<std::mutex> lock(m_kcpMutex);
     if(!m_kcp)
     {
         return -1;
     }
     return ikcp_wndsize(m_kcp,sndwnd,recvwnd);
}


void kcp_udp::Close(int mode)
{

    if(m_updateThread.isRun())
    {
        m_updateThread.Close();
    }
    if(m_kcp)
    {
        std::lock_guard<std::mutex> lock(m_kcpMutex);
        ikcp_release(m_kcp);
        m_kcp = nullptr;
    }
    if(mode == ALL_RELEASE)
    {
        if(m_recvThread.isRun())
        {
            m_recvThread.Close();
        }
        if(m_sockfd != SOCKET_ERROR)
        {
    #ifdef __linux__
            close(m_sockfd);
    #endif
    #ifdef WIN32
            closesocket(m_sockfd);
    #endif
            m_sockfd = SOCKET_ERROR;
        }
    }
}

int kcp_udp::kcp_send(const char *buff, int len)
{
    std::lock_guard<std::mutex> lock(m_kcpMutex);
    if(!m_kcp)
    {
        return -1;
    }
    return ikcp_send(m_kcp,buff,len);
}

int kcp_udp::kcp_recv(char *buff, int len)
{
    std::lock_guard<std::mutex> lock(m_kcpMutex);
    if(!m_kcp)
    {
        return -1;
    }
    return ikcp_recv(m_kcp,buff,len);
}

int kcp_udp::setnodelay(int model)
{
    std::lock_guard<std::mutex> lock(m_kcpMutex);
    if(!m_kcp)
    {
        return -1;
    }
    switch(model)
    {
        case 0:
        {

            ikcp_nodelay(m_kcp,0,10,0,0);
            break;
        }
        case 1:
        {
            ikcp_nodelay(m_kcp,0,10,0,1);
            break;
        }
        case 2:
        {
            ikcp_nodelay(m_kcp,2,10,2,1);
            break;
        }
        default:
        {
             ikcp_nodelay(m_kcp,0,10,0,0);
             break;
        }
    }
}

void kcp_udp::kcp_flush()
{
    std::lock_guard<std::mutex> lock(m_kcpMutex);
    if(!m_kcp)
    {
        return;
    }
    ikcp_flush(m_kcp);
}

int kcp_udp::udp_output(const char *buf, int len, ikcpcb *kcp, void *user)
{
    kcp_udp *pCur = (kcp_udp*)user;
    ssize_t ssend = sendto(pCur->m_sockfd,buf,len,0,(struct sockaddr*)&pCur->ser_addr,sizeof(struct sockaddr_in));
    if(ssend > 0)
    {
        return (int)ssend;
    }
    else
    {
        return -1;
    }
}

bool kcp_udp::getReconnect()
{
    bool ret = m_bRConnect;
    m_bRConnect = false;
    return ret;
}

IUINT32 kcp_udp::getWaitSendNum()
{
    std::lock_guard<std::mutex> lock(m_kcpMutex);
    if(!m_kcp)
    {
        return 0;
    }
    return m_kcp->nsnd_que;
}




bool kcp_udp::needPaused()
{
    std::lock_guard<std::mutex> lock(m_kcpMutex);
    if(!m_kcp)
    {
        return 0;
    }
    int ret = m_kcp->nsnd_que / m_kcp->snd_wnd;
    if(ret >= 2)
    {
        return true;
    }
    else
    {
        return false;
    }
}

```[技术参考](https://github.com/skywind3000/kcp)