基于libuv库实现tcpserver和tcpclient

已于 2023-05-30 18:20:03 修改
阅读量1.7k 收藏 10
点赞数 5
文章标签： 网络 c语言 linux uv c++
于 2023-05-29 20:04:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36731830/article/details/130930985
版权

项目中使用网络实现高速收发文件，经过验证，决定采用libuv库搭建tcpserver和tcpclient。libuv库是第三方库，其大量采用回调实现。同时，其官方关于server端以及client的demo都是十分简单，无法满足实际需求，因此在采用libuv的基础上，自行封装成类作为中间件，方便应用层调用。

一、封装svuv类

svuv类做为最顶层的类，该类将包含tcpclient以及tcpserver两个子功能。
svuv类允许添加一个服务端以及N个客户端；添加服务端后，会自动在库中申请200M发送缓存区和200M的接收缓存区；每个客户端同样会申请200M的发送缓存区以及200M的接收缓存区。（缓存区的大小根据实际清空修改一个宏即可）
其对外接口如下所述：

api参数功能
svuv()svuv类的构造函数
~svuv()svuv类的析构函数
void gStartLoop()启动uv库
int32_t gaddTcpClient(std::string server_ip, uint16_t server_port, std::string local_ip, uint16_t local_port)server_ip:服务器IP；server_port:服务器端口；local_ip:本地IP；local_port:本地端口添加client端
int32_t gTcpClientSend(std::string local_ip, uint16_t local_port, uint8_t *sdata, int32_t sdata_len)local_ip:本地IP；local_port:本地端口；sdata:发送数据；sdata_len:数据长度client端发送函数
int32_t gTcpClientRecv(std::string local_ip, uint16_t local_port, uint8_t *buff, int32_t buff_len)local_ip:本地IP；local_port:本地端口；buff:接收区；buff_len:接收区长度client接收函数
bool gTcpClientGetConnectStatus(std::string local_ip, uint16_t local_port)local_ip:本地IP；local_port:本地端口获取客户端的连接状态
int32_t gaddTcpServer(std::string server_ip, uint16_t server_port)server_ip:服务器IP；server_port:服务器端口添加服务器
int32_t gTcpServerRecv(std::string client_ip, uint16_t client_port, uint8_t *buff, int32_t buff_len)client_ip:客户端IP；client_port:客户端端口；buff:接收区；buff_len:接收区长度获取客户端数据
int32_t gTcpServerSend(std::string client_ip, uint16_t client_port, uint8_t *sdata, int32_t sdata_len);client_ip:客户端IP；client_port:客户端端口；sdata：发送数据；sdata_len:数据长度向客户端发送数据
int32_t gTcpServerGetRemainSpace(std::string client_ip, uint16_t client_port)client_ip:客户端IP；client_port:客户端端口获取客户端接收缓存区的剩余空间

整个svuv的使用流程将会比原来的libuv库大大简化：
svuv做服务端时：
1、创建svuv类的对象；
2、调用gaddTcpServer添加服务端
3、调用gStartLoop启动libuv
4、在线程中调用gTcpServerRecv或者gTcpServerSend
svuv做客户端时：
1、创建svuv类的对象；
2、调用gaddTcpClient添加客户端
3、调用gStartLoop启动libuv
4、在线程中调用gTcpClientRecv或者gTcpClientSend
详细的使用demo见后面链接。

二、封装tcpclient

tcpclient类用于生成一个客户端对象；每一个client都拥有各自的发送缓存区sbuff和接收缓存区rbuff，都具备断线重连功能。利用构造函数生成client时，只需要传入所要连接的server端地址以及本地的地址即可。client生成后，会在底层自动创建200M发送缓存区和200M接收缓存区，同时创建两个定时器reconnectTimer以及sendTimer，定时器sendTimer用于将发送缓存区的数据经libuv发送出去，定时器reconnectTimer则会定时检查与server端的连接状态。
tcpclient的主要功能如下表所述：

API参数功能
tcpclient(uv_loop_t *ploop, std::string server_ip, uint16_t server_port, std::string local_ip, uint16_t local_port)server_ip:服务器IP；server_port:服务器端口；local_ip:本地IP；local_port:本地端口申请发送缓存区和接收缓存区；调用libuv进行tcp初始化配置；申请reconnectTimer以及sendT imer
int32_t tcSendData(uint8_t *sdata, int32_t sdata_len)sdata:发送数据；sdata_len:数据长度将数据存入发送缓存区(保证不溢出)
int32_t tcRecvData(uint8_t *buff, int32_t buff_len)buff:接收缓存区；buff_len:缓存区长度对数据进行初步解析，满足帧格式才将整帧数据从底层缓存区取出传给调用者

整个tcpclient的实现过程如下所述：
1、调用tcpclient进行初始化配置，包括申请发送和接收缓存区；配置定时器；绑定本地IP地址；绑定连接回调函数sTCAfterConnect；启动断线重连机制；

tcpclient::tcpclient(uv_loop_t *ploop, std::string server_ip, uint16_t server_port, std::string local_ip, uint16_t local_port)
{
    int32_t iret = 0;

    this->serverIP = server_ip;
    this->serverPort = server_port;
    this->localIP = local_ip;
    this->localPort = local_port;
    this->loop = ploop;

    this->uvRbuf.base = new char [TCP_RECV_UVBUFF_SIZE];
    this->uvRbuf.len = TCP_RECV_UVBUFF_SIZE;
    this->rbuff = new uint8_t [TCP_RECV_BUFF_SIZE];
    this->rbuffIn = 0;
    this->rbuffOut = 0;

    this->sbuff = new uint8_t [TCP_SEND_BUFF_SIZE];
    this->sbuffIn = 0;
    this->sbuffOut = 0;
    this->repeatSendTime = 1;

    this->connectStatus = false;
    this->isReconnect = true;
    this->isClosed = false;

    do
    {
        iret = uv_mutex_init(&this->rMutex);
        if (iret)
        {
            PlayerInfo("addTcpClient uv_mutex_init rMutex", iret);
            break;
        }

        iret = uv_mutex_init(&this->sMutex);
        if (iret)
        {
            PlayerInfo("addTcpClient uv_mutex_init sMutex", iret);
            break;
        }

        iret = uv_timer_init(this->loop, &this->sendTimer);						// 发送定时器
        if (iret)
        {
            PlayerInfo("addTcpClient uv_timer_init sendTimer", iret);
            break;
        }

        iret = uv_async_init(this->loop, &this->sendAsync, sTCSendAsync);
        if (iret)
        {
            PlayerInfo("addTcpClient uv_async_init sendAsync", iret);
            break;
        }

        iret = uv_timer_init(this->loop, &this->reconnectTimer);			// 重连定时器
        if (iret)
        {
            PlayerInfo("addTcpClient uv_timer_init reconnectTimer", iret);
            break;
        }

        iret = uv_tcp_init(this->loop, &this->clientHandle);
        if (iret)
        {
            PlayerInfo("addTcpClient uv_tcp_init", iret);
            break;
        }

        iret = uv_tcp_nodelay(&this->clientHandle, 1);
        if (iret)
        {
            PlayerInfo("addTcpClient uv_tcp_nodelay", iret);
            break;
        }

        printf("uv_tcp_nodelay\n");

        iret = uv_tcp_keepalive(&this->clientHandle, 1, 60);
        if (iret)
        {
            PlayerInfo("addTcpClient uv_tcp_keepalive", iret);
            break;
        }

        printf("uv_tcp_keepalive\n");

        iret = uv_ip4_addr(server_ip.c_str(), server_port, &this->serverAddr);
        if (iret)
        {
            PlayerInfo("addTcpClient uv_ip4_addr serverAddr", iret);
            break;
        }

        iret = uv_ip4_addr(local_ip.c_str(), local_port, &this->localAddr);	// 绑定本地IP和端口，这样server端才能获取到固定的IP和端口
        if (iret)
        {
            PlayerInfo("addTcpClient uv_ip4_addr localAddr", iret);
            break;
        }

        iret = uv_tcp_bind(&this->clientHandle, (const struct sockaddr*)&this->localAddr, 0);
        if (iret)
        {
            PlayerInfo("addTcpClient uv_tcp_bind localAddr", iret);
            break;
        }

        iret = uv_tcp_connect(&this->connectReq, &this->clientHandle, (const sockaddr*)&this->serverAddr, sTCAfterConnect);
        if (iret)
        {
            PlayerInfo("addTcpClient uv_tcp_connect", iret);
            break;
        }

        this->sendTimer.data = this;
        this->sendAsync.data = this;

        this->clientHandle.data = this;
        this->connectReq.data = this;
        this->reconnectTimer.data = this;
    } while (0);
    
}

2、client连接成功后，启动接收回调函数sTCAfterRecv，当有数据进入，会自动存入接收缓存区rbuff(保证不溢出)；

void tcpclient::sTCAfterConnect(uv_connect_t* handle, int status)
{
    class tcpclient *tmpClient = (class tcpclient *)handle->data;
    int32_t iret = 0;

    if (status)
    {
        tmpClient->connectStatus = false;
        PlayerInfo("sTCAfterConnect", status);
        tmpClient->TCStopSend();
        tmpClient->TCStartReconnect();
        uv_close((uv_handle_t *)&tmpClient->clientHandle, tcpclient::sTCAfterClientClose);
        return;
    }

    iret = uv_read_start(handle->handle, sTCAllocBufferForRecv, sTCAfterRecv);	// 正常连接，开始接收数据
    if (iret)
    {
        PlayerInfo("sTCAfterConnect uv_read_start", iret);
    }
    else
    {
        tmpClient->connectStatus = true;
        tmpClient->TCStartSend();
    }

    if (tmpClient->isReconnect)
    {
        tmpClient->TCStopReconnect();
    }
}

void tcpclient::sTCAllocBufferForRecv(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf)
{
    class tcpclient *tmpClient = (class tcpclient *)handle->data;
    assert(tmpClient);
    *buf = tmpClient->uvRbuf;
}

void tcpclient::sTCAfterRecv(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf)
{
    class tcpclient *tmpClient = (class tcpclient *)handle->data;

    if (nread > 0)
    {
        uv_mutex_lock(&tmpClient->rMutex);
        if ((tmpClient->rbuffIn + nread) <= TCP_RECV_BUFF_SIZE)	// 在不溢出的清空下，将数据存入接收缓存区
        {
            memset(tmpClient->rbuff + tmpClient->rbuffIn, 0x00, nread);
            memcpy(tmpClient->rbuff + tmpClient->rbuffIn, buf->base, nread);
            tmpClient->rbuffIn += nread;
        }
        uv_mutex_unlock(&tmpClient->rMutex);
    }
    else if (nread < 0)
    {
        PlayerInfo("sTCAfterRecv ", nread);
        tmpClient->TCStopSend();
        tmpClient->TCStartReconnect();
        uv_close((uv_handle_t *)handle, tcpclient::sTCAfterClientClose);
    }
}

同时启动定时发送机制，每隔10ms将发送缓存区的数据sbuff经libuv库发送出去；

void tcpclient::sTCSendTimer(uv_timer_t* handle)
{
    class tcpclient *tmpClient = (class tcpclient *)handle->data;

    uv_async_send(&tmpClient->sendAsync);		// 触发发送函数
}

void tcpclient::sTCSendAsync(uv_async_t *handle)
{
    class tcpclient *tmpClient = (class tcpclient *)handle->data;
    uv_buf_t bufs[CHUNKS_PER_WRITE];
    uv_write_t *write_reqs = &tmpClient->write_reqs;
    int32_t i = 0;

    char *ptr = (char *)tmpClient->sbuff + tmpClient->sbuffOut;
    uint32_t len = 0;

    uv_mutex_lock(&tmpClient->sMutex);
    if ((tmpClient->connectStatus) && (tmpClient->sbuffIn != tmpClient->sbuffOut))
    {
        for (i = 0; i < CHUNKS_PER_WRITE; )			// 按照libuv的格式组包uv_buf_t，然后调用uv_write发送数据
        {
            if ((tmpClient->sbuffOut + TCP_SEND_UVBUFF_SIZE) <= tmpClient->sbuffIn)
            {
                len = TCP_SEND_UVBUFF_SIZE;
            }
            else
            {
                len = tmpClient->sbuffIn - tmpClient->sbuffOut;
            }

            bufs[i] = uv_buf_init(ptr, len);
            i++;

            tmpClient->sbuffOut += len;
            ptr += len;
            if (tmpClient->sbuffOut == tmpClient->sbuffIn)
            {
                tmpClient->sbuffOut = 0;
                tmpClient->sbuffIn = 0;
                break;
            }
        }

        if (i > 0)
        {
            write_reqs->data = tmpClient;
            uv_write(write_reqs, (uv_stream_t *)&tmpClient->clientHandle, bufs, i, tcpclient::sTCAfterSend);
        }
    }
    else if ((tmpClient->connectStatus) && (tmpClient->sbuffIn == tmpClient->sbuffOut))
    {
        tmpClient->TCStartSend();
    }
    uv_mutex_unlock(&tmpClient->sMutex);
}

void tcpclient::sTCAfterSend(uv_write_t* req, int status)
{
    class tcpclient *tmpClient = (class tcpclient *)req->data;

    if (status == 0)			// 数据发送成功后，再次触发定时器
    {
        tmpClient->TCStartSend();
    }
    else
    {
        PlayerInfo("sTCAfterSend ", status);
        tmpClient->TCStopSend();
    }
}

3、客户端重连机制

void tcpclient::sTCReconnectTimer(uv_timer_t* handle)
{
    class tcpclient *tmpClient = (class tcpclient *)handle->data;
    int32_t iret;

    if (!tmpClient->isReconnect)
        return;

    fprintf(stdout, "ip:%s port:%u start reconnect\n", tmpClient->localIP.c_str(), tmpClient->localPort);

    do
    {
        iret = uv_tcp_init(tmpClient->loop, &tmpClient->clientHandle);
        if (iret)
        {
            PlayerInfo("sTCReconnectTimer uv_tcp_init", iret);
            break;
        }

        iret = uv_tcp_nodelay(&tmpClient->clientHandle, 1);
        if (iret)
        {
            PlayerInfo("sTCReconnectTimer uv_tcp_nodelay", iret);
            break;
        }

        iret = uv_tcp_keepalive(&tmpClient->clientHandle, 1, 60);
        if (iret)
        {
            PlayerInfo("sTCReconnectTimer uv_tcp_keepalive", iret);
            break;
        }

        iret = uv_ip4_addr(tmpClient->serverIP.c_str(), tmpClient->serverPort, &tmpClient->serverAddr);
        if (iret)
        {
            PlayerInfo("sTCReconnectTimer uv_ip4_addr serverAddr", iret);
            break;
        }
        
        iret = uv_ip4_addr(tmpClient->localIP.c_str(), tmpClient->localPort, &tmpClient->localAddr);
        if (iret)
        {
            PlayerInfo("sTCReconnectTimer uv_ip4_addr localAddr", iret);
            break;
        }

        iret = uv_tcp_bind(&tmpClient->clientHandle, (const struct sockaddr*)&tmpClient->localAddr, 0);
        if (iret)
        {
            PlayerInfo("addTcpClient uv_tcp_bind localAddr", iret);
            break;
        }

        iret = uv_tcp_connect(&tmpClient->connectReq, &tmpClient->clientHandle, (const sockaddr*)&tmpClient->serverAddr, sTCAfterConnect);
        if (iret)
        {
            PlayerInfo("sTCReconnectTimer uv_tcp_connect", iret);
            break;
        }

        tmpClient->clientHandle.data = tmpClient;
        tmpClient->connectReq.data = tmpClient;
        tmpClient->reconnectTimer.data = tmpClient;
        return;
    } while (0);
    

    //reconnect failure, restart timer to trigger reconnect.
    // uv_timer_stop(handle);
    // tmpClient->repeatTime *= 2;
    // uv_timer_start(handle, tcpclient::sTCReconnectTimer, tmpClient->repeatTime, tmpClient->repeatTime);
    tmpClient->TCStopSend();
    tmpClient->TCStartReconnect();
    uv_close((uv_handle_t *)handle, tcpclient::sTCAfterClientClose);
}
void tcpclient::TCStartReconnect()
{
    isReconnect = true;
    this->clientHandle.data = this;
    this->repeatTime = 1e3;
}

void tcpclient::TCStopReconnect()
{
    this->isReconnect = false;
    this->clientHandle.data = this;
    this->repeatTime = 1e3;
    uv_timer_stop(&this->reconnectTimer);
}

4、应用层调用tcSendData，将数据存入发送缓存区sbuff；

int32_t tcpclient::tcSendData(uint8_t *sdata, int32_t sdata_len)
{
    int32_t ret = 0;
    assert(sdata);
    assert(sdata_len > 0);

    if (this->connectStatus)
    {
        uv_mutex_lock(&this->sMutex);
        if ((this->sbuffIn + sdata_len) <= TCP_SEND_BUFF_SIZE)			// 确保不溢出
        {
            memcpy(this->sbuff + this->sbuffIn, sdata, sdata_len);
            this->sbuffIn += sdata_len;

            ret = sdata_len;
        }
        uv_mutex_unlock(&this->sMutex);
    }

    return ret;
}

5、应用层主动调用tcRecvData，及时将数据从接收缓存区rbuff取走(应用层必须尽快将数据取走，否则可能导致缓存区满而丢帧)

int32_t tcpclient::tcRecvData(uint8_t *buff, int32_t buff_len)
{
    uint8_t *ptr = this->rbuff + this->rbuffOut;
    uint16_t frameLen = 0;

    assert(buff);
    assert(buff_len > 0);

    uv_mutex_lock(&this->rMutex);
    if (this->rbuffIn != this->rbuffOut)
    {
        if (((ptr[0] == 0xD2) && (ptr[1] == 0x8C)) ||		// 这里要更改为实际的帧格式(或者直接将数据取出)
            ((ptr[0] == 0x4D) && (ptr[1] == 0x73)))
        {
            frameLen = htons(*(uint16_t *)(ptr + FRAME_OFFSET_DATALEN)) + 18;
            if ((this->rbuffOut + frameLen) <= this->rbuffIn)
            {
                memcpy(buff, ptr, frameLen);
                this->rbuffOut += frameLen;
                if (this->rbuffOut == this->rbuffIn)
                {
                    this->rbuffIn = 0;
                    this->rbuffOut = 0;
                }
            }
        }
        else
        {
            this->rbuffOut++;
        }
    }
    uv_mutex_unlock(&this->rMutex);
    return frameLen;
}

三、封装tcpserver

tcpserver类用于生成一个服务端对象，初始化时调用libuv库进行server端的配置，然后启动监听服务(监听128个客户端)；当有新的客户端接入，便创建一个client对象；同时为client分配发送缓存区sbuff和接收缓存区rbuff，每个client端也都具备定时发送的功能。
tcpserver的主要功能如下表所述：

API参数功能
tcpserver(uv_loop_t *ploop, std::string server_ip, uint16_t server_port)server_ip:服务器IP；server_port:服务器端口初始化server，启动监听服务
int32_t tsGetAcceptClientRecvData(std::string accept_ip, uint16_t accept_port, uint8_t *buff, int32_t buff_len)accept_ip:接入的客户端IP；accept_port:接入的客户端端口；buff:接收区；buff_len:接收区长度对数据初步解析，满足帧格式后将整帧数据从底层缓存区取走传给调用者
int32_t tsSetAcceptClientSendData(std::string accept_ip, uint16_t accept_port, uint8_t *sdata, int32_t sdata_len)accept_ip:接入的客户端IP；accept_port:接入的客户端端口；sdata:发送数据；sdata_len:数据长度将数据存入对应客户端的发送缓存区

整个tcpserver的实现过程如下所述：
1、调用tcpserver进行初始化配置，包括绑定server地址，启动server监听服务AcceptConnection；

tcpserver::tcpserver(uv_loop_t *ploop, std::string server_ip, uint16_t server_port)
{
    int32_t iret = 0;

    this->loop = ploop;
    this->serverIP = server_ip;
    this->serverPort = server_port;

    do
    {
        iret = uv_mutex_init(&this->acceptMutex);
        if (iret)
        {
            PlayerInfo("tcpserver uv_mutex_init", iret);
            break;
        }

        iret = uv_tcp_init(this->loop, &this->serverHandle);
        if (iret)
        {
            PlayerInfo("tcpserver uv_tcp_init", iret);
            break;
        }

        iret = uv_tcp_nodelay(&this->serverHandle, 1);
        if (iret)
        {
            PlayerInfo("tcpserver uv_tcp_nodelay", iret);
            break;
        }

        iret = uv_tcp_keepalive(&this->serverHandle, 1, 60);
        if (iret)
        {
            PlayerInfo("tcpserver uv_tcp_keepalive", iret);
            break;
        }

        iret = uv_ip4_addr(server_ip.c_str(), server_port, &this->addr);
        if (iret)
        {
            PlayerInfo("tcpserver uv_ip4_addr", iret);
            break;
        }

        iret = uv_tcp_bind(&this->serverHandle, (const struct sockaddr *)&this->addr, 0);	// 绑定server地址
        if (iret)
        {
            PlayerInfo("tcpserver uv_tcp_bind", iret);
            break;
        }

        iret = uv_listen((uv_stream_t *)&this->serverHandle, 128, AcceptConnection);	// 启动监听服务
        if (iret)
        {
            PlayerInfo("tcpserver uv_listen", iret);
        }

        this->serverHandle.data = this;
        return;
    } while (0);
}

2、有新的客户端接入，则创建acceptclient；为每一个acceptclient分配发送缓存区sbuff和接收缓存区rbuff；对每个acceptclient配置发送定时器；

void tcpserver::AcceptConnection(uv_stream_t *server, int status)
{
    int32_t iret = 0;

    class tcpserver *tmpServer = (class tcpserver *)server->data;
    assert(tmpServer);

    if (status)
    {
        PlayerInfo("AcceptConnection ", status);
        return;
    }

    class acceptclient *tmpAccept = new acceptclient(tmpServer->loop, server, tmpServer->serverIP, tmpServer->serverPort);		// 有新的客户端接入，创建一个acceptclient
    assert(tmpAccept);

    uv_mutex_lock(&tmpServer->acceptMutex);
    tmpServer->acceptclientVec.push_back(tmpAccept);	// 将新接入的client加入到vector中
    uv_mutex_unlock(&tmpServer->acceptMutex);
    return;
}

3、acceptclient接入成功后，启动接收回调函数sAcceptAfterRecv；当有新的数据进入，自动将数据存入接收缓存区rbuff；

acceptclient::acceptclient(uv_loop_t *ploop, uv_stream_t *server, std::string server_ip, uint16_t server_port)
{
    int32_t iret = 0;

    this->loop = ploop;

    // this->rbuff = new uint8_t[TCP_RECV_BUFF_SIZE];
    this->rbuff = (uint8_t *)malloc(TCP_RECV_BUFF_SIZE);
    this->rbuffIn = 0;
    this->rbuffOut = 0;

    // this->uvRbuf.base = new char[TCP_RECV_UVBUFF_SIZE];
    this->uvRbuf.base = (char *)malloc(TCP_RECV_UVBUFF_SIZE);
    this->uvRbuf.len = TCP_RECV_UVBUFF_SIZE;

    // this->sbuff = new uint8_t[TCP_SEND_BUFF_SIZE];
    this->sbuff = (uint8_t *)malloc(TCP_SEND_BUFF_SIZE);
    this->sbuffIn = 0;
    this->sbuffOut = 0;

    this->serverIP = server_ip;
    this->serverPort = server_port;

    do
    {
        iret = uv_mutex_init(&this->rMutex);
        if (iret)
        {
            PlayerInfo("acceptclient uv_mutex_init rMutex", iret);
            break;
        }

        iret = uv_mutex_init(&this->sMutex);
        if (iret)
        {
            PlayerInfo("acceptclient uv_mutex_init sMutex", iret);
            break;
        }


        iret = uv_timer_init(this->loop, &this->sendTimer);
        if (iret)
        {
            PlayerInfo("acceptclient uv_timer_init sendTimer", iret);
            break;
        }

        iret = uv_async_init(this->loop, &this->sendAsync, sAcceptSendAsync);
        if (iret)
        {
            PlayerInfo("acceptclient uv_async_init sendAsync", iret);
            break;
        }

        iret = uv_tcp_init(this->loop, &this->acceptHandle);
        if (iret)
        {
            PlayerInfo("acceptclient uv_tcp_init", iret);
            break;
        }

        iret = uv_tcp_nodelay(&this->acceptHandle, 1);
        if (iret)
        {
            PlayerInfo("addTcpClient uv_tcp_nodelay", iret);
            break;
        }

        iret = uv_tcp_keepalive(&this->acceptHandle, 1, 60);
        if (iret)
        {
            PlayerInfo("addTcpClient uv_tcp_keepalive", iret);
            break;
        }

        iret = uv_accept((uv_stream_t *)server, (uv_stream_t *)&this->acceptHandle);	// 客户端接入成功
        if (iret)
        {
            PlayerInfo("acceptclient uv_accept", iret);
            break;
        }

        struct sockaddr peername;
        int namelen = sizeof(peername);
        struct sockaddr_in compare_addr;
        char client_ip[17];
        uint16_t client_port;
        uv_tcp_getpeername(&this->acceptHandle, &peername, &namelen);		// 获取客户端IP和端口
        check_sockname(&peername, server_ip.c_str(), server_port, client_ip, &client_port);
        this->acceptIP = client_ip;
        this->acceptPort = client_port;
        fprintf(stdout, "newAcceptClient ip = %s, port = %d\n", client_ip, client_port);

        iret = uv_read_start((uv_stream_t *)&this->acceptHandle, acceptclient::sAcceptAllocBufferForRecv, acceptclient::sAcceptAfterRecv);		// 从客户端接收数据
        if (iret)
        {
            PlayerInfo("AcceptConnection uv_read_start", iret);
            break;
        }

        this->isConnect = true;
        this->acceptHandle.data = this;
        this->sendTimer.data = this;
        this->sendAsync.data = this;
        this->parent = server->data;

        this->acceptStartSend();
    } while (0);
}
void acceptclient::sAcceptAfterRecv(uv_stream_t *client, ssize_t nread, const uv_buf_t *buf)
{
    class acceptclient *tmpAccept = (class acceptclient *)client->data;
    class tcpserver *tmpServer = (class tcpserver *)tmpAccept->parent;
    unsigned long long now = 0;

    if (nread > 0)
    {
        // sysGetCurPts(&now);
        uv_mutex_lock(&tmpAccept->rMutex);
        if ((tmpAccept->rbuffIn + nread) <= TCP_RECV_BUFF_SIZE)		// 数据存入接收缓存区
        {
            memset(tmpAccept->rbuff + tmpAccept->rbuffIn, 0x00, nread);
            memcpy(tmpAccept->rbuff + tmpAccept->rbuffIn, buf->base, nread);
            tmpAccept->rbuffIn += nread;
        }
        // printf("time %lld us, recv %ld, all %u\n", now, nread, tmpAccept->rbuffIn);
        uv_mutex_unlock(&tmpAccept->rMutex);
    }
    else if (nread < 0)
    {
        printf("close and delete acceptClient\n");
        tmpAccept->acceptStopSend();
        uv_close((uv_handle_t *)client, sAcceptAfterClose);
        // tmpServer->tsDeleteAcceptClient(client, tmpAccept->acceptIP, tmpAccept->acceptPort);     // 这个函数似乎会导致服务端程序崩溃
    }
}

4、应用层调用tsSetAcceptClientSendData将要发送的数据存入缓存区，底层自行发送；

void acceptclient::sAcceptSendTimer(uv_timer_t *handle)
{
    class acceptclient *tmpAccept = (class acceptclient *)handle->data;

    if (tmpAccept->isConnect)
        uv_async_send(&tmpAccept->sendAsync);			// 触发发送
}

void acceptclient::sAcceptSendAsync(uv_async_t *handle)
{
    class acceptclient *tmpAccept = (class acceptclient *)handle->data;

    uv_buf_t bufs[CHUNKS_PER_WRITE];
    uv_write_t *write_reqs = &tmpAccept->write_reqs;
    int32_t i = 0;

    char *ptr = (char *)tmpAccept->sbuff + tmpAccept->sbuffOut;
    uint32_t len = 0;

    uv_mutex_lock(&tmpAccept->sMutex);
    if ((tmpAccept->isConnect) && (tmpAccept->sbuffIn != tmpAccept->sbuffOut))
    {
        for (i = 0; i < CHUNKS_PER_WRITE; )		// 按照kibuv的格式，组包发送
        {
            if ((tmpAccept->sbuffOut + TCP_SEND_UVBUFF_SIZE) <= tmpAccept->sbuffIn)
            {
                len = TCP_SEND_UVBUFF_SIZE;
            }
            else
            {
                len = tmpAccept->sbuffIn - tmpAccept->sbuffOut;
            }

            bufs[i] = uv_buf_init(ptr, len);
            i++;

            tmpAccept->sbuffOut += len;
            ptr += len;
            if (tmpAccept->sbuffOut == tmpAccept->sbuffIn)
            {
                tmpAccept->sbuffOut = 0;
                tmpAccept->sbuffIn = 0;
                break;
            }
        }

        if (i > 0)
        {
            write_reqs->data = tmpAccept;
            uv_write(write_reqs, (uv_stream_t *)&tmpAccept->acceptHandle, bufs, i, acceptclient::sAcceptAfterSend);
        }
    }
    else if  ((tmpAccept->isConnect) && (tmpAccept->sbuffIn == tmpAccept->sbuffOut))	// 连接状态下，即使没有数据需要发送，也要触发定时器
    {
        tmpAccept->acceptStartSend();
    }
    uv_mutex_unlock(&tmpAccept->sMutex);
}

void acceptclient::sAcceptAfterSend(uv_write_t *req, int status)
{
    class acceptclient *tmpAccept = (class acceptclient *)req->data;

    if (status == 0)
    {
        tmpAccept->acceptStartSend();		// 发送成功后，再次触发定时器，开始下一轮的发送周期
    }
    else
    {
        PlayerInfo("sAcceptAfterSend ", status);
        tmpAccept->acceptStopSend();
    }
}

void acceptclient::acceptStartSend(void)
{
    this->repeatSendTime = 10;
    uv_timer_start(&this->sendTimer, acceptclient::sAcceptSendTimer, this->repeatSendTime, 0);
}

void acceptclient::acceptStopSend(void)
{
    this->repeatSendTime = 10;
    uv_timer_stop(&this->sendTimer);
}

int32_t acceptclient::acceptSendData(uint8_t *sdata, int32_t sdata_len)
{
    int32_t ret = 0;

    assert(sdata);
    assert(sdata_len > 0);

    if (this->isConnect)
    {
        uv_mutex_lock(&this->sMutex);
        if ((this->sbuffIn + sdata_len) <= TCP_SEND_BUFF_SIZE)	// 应用层数据存入发送缓存区
        {
            memcpy(this->sbuff + this->sbuffIn, sdata, sdata_len);
            this->sbuffIn += sdata_len;

            ret = sdata_len;
        }
        uv_mutex_unlock(&this->sMutex);
    }

    return ret;
}

5、应用层调用tsGetAcceptClientRecvData将数据从底层取走(应用层必须尽快将数据取走，否则导致接收缓存区满而丢帧)

int32_t acceptclient::acceptRecvData(uint8_t *buff, int32_t buff_len)
{
    uint8_t *ptr = this->rbuff + this->rbuffOut;
    uint16_t frameLen = 0;

    assert(buff);
    assert(buff_len > 0);

    uv_mutex_lock(&this->rMutex);
    if (this->rbuffIn != this->rbuffOut)
    {
        if (((ptr[0] == 0xD2) && (ptr[1] == 0x8C)) ||	// 这里根据实际清空更改协议(或者直接将数据取走)
            ((ptr[0] == 0x4D) && (ptr[1] == 0x73)))
        {
            frameLen = htons(*(uint16_t *)(ptr + FRAME_OFFSET_DATALEN)) + 18;
            if ((this->rbuffOut + frameLen) <= this->rbuffIn)
            {
                memcpy(buff, ptr, frameLen);
                this->rbuffOut += frameLen;
                memset(ptr, 0x00, frameLen);
                if (this->rbuffOut == this->rbuffIn)
                {
                    this->rbuffIn = 0;
                    this->rbuffOut = 0;
                }
            }
            else
                frameLen = 0;
        }
        else
        {
            this->rbuffOut++;
        }
    }
    uv_mutex_unlock(&this->rMutex);
    return frameLen;
}

四、测试用例

测试用例：
1、创建svuv对象；
2、添加客户端或者服务端；
3、创建线程进行收发。

整个demo可以见链接：gitee链接地址

偊霙的大少爷
关注
基于libuv实现tcp客户端和服务端（支持监听1000多个端口；打印客户端服务端socket；固定端口连接）
wangkai2016的博客
02-24 6215
服务端：监听本地1000多个端口；收到连接既接受并打印数据和客户端服务端socket；github#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include "include/uv.h" #define DEFAULT_BACKLOG 1000 #define NUM 1000/*1013*/ uv_loop_t *lo...
异步I/O库-libuv介绍
希望能帮助大家，希望大家多多支持，你们的支持是我前进的动力。
05-15 2391
libuv是一个跨平台的支持事件驱动的异步I/O的库，使开发者可以以非阻塞的方式执行文件I/O操作、网络通信、子进程管理等。事件循环：libuv有一个基于事件循环的模型，它不断地轮询事件，并在事件发生时调用相应的回调函数。异步I/O：libuv提供了异步文件I/O和网络I/O的接口，使得开发者可以执行I/O操作而不阻塞主线程。线程池：libuv使用线程池来处理一些不能以非阻塞方式执行的I/O操作，如文件系统操作在某些操作系统上。DNS解析：libuv提供了异步DNS解析的接口。
libuv_tcp, 使用libuv的tcp服务器和客户端包.zip
09-18
libuv_tcp, 使用libuv的tcp服务器和客户端包 欢迎来到libuv_tcp维基 ！简介：libuv_tcp是一个包含tcp服务器和客户端的C 类，它使用libuv包。用法：请参阅 [ test_tcpserver.cpp ] 1 和 [ test_tcpclient.cpp
TCP Server 和 Client 的作用简介
最新发布
孔乙己的博客
09-14 823
TCP 客户端和服务器在网络通信中扮演了不可或缺的角色。客户端负责发起连接并发送请求，服务器接收并处理这些请求。通过 TCP 的三次握手和四次挥手机制，确保了通信的可靠性和顺序性。在实际应用中，如 Web 浏览、在线游戏和大规模分布式系统中，TCP 通信的作用无处不在。序列号、确认号、滑动窗口以及拥塞控制等技术细节，保障了数据传输的高效性和稳定性。通过这些机制，TCP 成为现代网络通信的基石，为我们每天的互联网体验提供了有力支持。
libUV写TCPServer
Jingle的专栏
01-18 7576
libUV是一个网络接口，在Linux下集成了libev，在Windows下按linux风格封装了一下IOCP，不过使用起来方便多了。     用来写TCP Server，极大地简化了代码，比直接用libev还要简单，详细例子可以见test目录下的例子，以其中blackhole-server为例，稍修改一下使之成为独立程序：     #include "uv.h"     #include
libuv_tcp_server
bigfanofloT的博客
09-25 545
【代码】libuv_tcp_server。
libuv网络库的TCP服务端与客户端
热门推荐
CodeHeng的专栏
04-01 1万+
本人一直在寻找一个跨平台的网络库，boost与ACE比较庞大，不考虑。对比了libevent,libev,libuv后，最终选择了libuv.可libuv文档少，例子也简单，对于tcp只有个echo-server的例子。网上也找过对其封装的例子，如下 libsourcey库，封装了许多库。对libuv的封装跟其他代码耦合比较紧，难为剥离 http://sourcey.com/libuv-
libuv编译和基于tcp的简单聊天客户端+服务端
zhuxian2009的专栏
12-15 968
linux环境下，官方建议是。选择安装目录和只编译静态库。我们自己看看可以配置什么。
基于libuv搭建的tcpserver和tcpclient
05-30
libuv本身采用大量的回调实现，官方关于server和client的实现较为简单，重新基于libuv进行封装，简化使用。每个client都具备断线重连功能，发送和接收都封装在底层实现；server端同样将发送和接收封装在底层，server...
libuv_tcp的基于libuv库的c++实现.zip
09-30
《基于libuv库的C++实现TCP通信详解》 在计算机网络编程中，TCP（Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议。本项目着重探讨了如何利用libuv库在C++环境中实现TCP...
基于libuv的tcp端口转发（keepalive和超时设置）
whojoe的博客
07-27 1425
基于libuv的tcp端口转发（keepalive和超时设置）前言代码参考文章 前言 网上关于libuv的代码示例较少，官方文档和代码中的示例都只是给了简单的例子，实际使用的时候可能会遇到很多内存泄漏和指针异常的问题 代码 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <uv.h> #define CRTDBG_MAP_ALLOC #include "crtdbg.h"
libuv-tcp:基于libuv的轻量级服务器
04-13
基于libuv的轻量级服务器 特点 利用C++11风格语法封装libuv，提供简洁的服务端接口； 利用libuv事件库提供的异步设计，实现Reactor事件处理模式； 所有的非阻塞异步接口是C++11的functional/bind形式的回调函数； 实现get、post两种请求解析，并利用Radix Tree实现HTTP路径机制。 例子 Echo服务 KV存储服务 （未完待续....） 仍需完善 引入多Reactor
libuv关于TCP UDP以及文件操作的封装测试
10-30
libuv关于TCP UDP以及文件操作的封装测试，便于以后进行扩展使用
libuv-httpserver:基于 libuv 和 http-parser 的简单 Web 服务器。 (只回显`Hello, World!\n`)
07-02
libuv-httpserver 作者：赖安 最后修改时间：2014.12.23 基于 libuv 和 http-parser 的简单 Web 服务器。 （只回显Hello, World!\r\n ） 依赖关系 它需要最新的稳定版本： , Release v1.0.2 (2014.12.10 发布) , Release v2.3 (2014.5.13 发布) 如何 确保你在 OS X 上，安装了 Xcode，安装了 。 git clone git@github.com:Ryannnnnnn/libuv-httpserver.git && cd libuv-httpserver git submodule update --init make ./httpserver 然后， curl 127.0.0.1:8888进行测试。 资源 Ryan Dahl 的教程 (2011)，A
基于libuv的TCP设计（二）
weixin_30663391的博客
05-28 298
一、本人设想的TCP服务器有如下特性： 1.启动服务，一直监听端口。 2.有新连接(客户端)就通知用户。并把连接接收到的数据回调给用户。 3.客户端连接上后用户可在任意时间发送数据给它。 4.客户端断开时关闭或用户可手动关掉。 以上操作都可以不同线程在完成。 二、使用libuv遇到的问题 由于对libuv不熟悉+其文档，调用其函数时吃了不少苦头。 1.libuv的特性 li...
libuv的TCP协议客户端和服务端实现
m0_49222970的博客
08-16 1401
一.服务端 spdlog记录log不需要的可以直接删除。换成std::cout输出也可以。 #include "tcpService.h" #include <uv.h> #include <iostream> #include <string> #include "spdlogTools.h" uv_tcp_t handle; uv_loop_t* loop; tcpService::tcpService() { } void alloc_cb(uv_handl
libuv tcp client
qianbo042311的博客
08-09 891
windows 和 linux 包含 windows下要包含一些lib库，这个需要加进去 #if defined (WIN32) || defined (_WIN32) #include <WinSock2.h> #include <windows.h> #pragma comment(lib,"ws2_32.lib") #pragma comment(lib,"psapi.lib") #pragma comment(lib,"Iphlpapi.lib") #pragma comme
libuv_tcp_client
bigfanofloT的博客
09-25 648
【代码】libuv_tcp_client。
libUV 写TCPServer
zqf_office的专栏
07-21 1190
libUV是一个网络接口，在Linux下集成了libev，在Windows下按linux风格封装了一下IOCP，不过使用起来方便多了。     用来写TCP Server，极大地简化了代码，比直接用libev还要简单，详细例子可以见test目录下的例子，以其中blackhole-server为例，稍修改一下使之成为独立程序：     #include "uv.h"     #in
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值