简易游戏服务器—分包与粘包问题

Posted 2023-03-17

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了简易游戏服务器—分包与粘包问题相关的知识，希望对你有一定的参考价值。

参考技术A

粘包和分包是利用Socket在TCP协议下内部的优化机制。

1、什么是粘包

只有TCP有粘包现象，UDP永远不会粘包，为何，且听我娓娓道来。发送数据时间间隔很短，数据了很小，也就是发送数据比较频繁，会合到一起，产生粘包；

2、什么是分包

当我们发送的数据量很大的时候，可能是几千字节，TCP就会自动分开发送，其实说通俗点，就是你去拿快递，一看20个，一次拿不完，分几次拿！

3、总结

指发送方发送的若干包数据到接收方接收时粘成一包，从接收缓冲区看，后一包数据的头紧接着前一包数据的尾。出现粘包现象的原因是多方面的，它既可能由发送方造成，也可能由接收方造成。

发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一包数据。

若连续几次发送的数据都很少，通常TCP会根据优化算法把这些数据合成一包后一次发送出去，这样接收方就收到了粘包数据。接收方引起的粘包是由于接收方用户进程不及时接收数据，从而导致粘包现象。

这是因为接收方先把收到的数据放在系统接收缓冲区，用户进程从该缓冲区取数据，若下一包数据到达时前一包数据尚未被用户进程取走，则下一包数据放到系统接收缓冲区时就接到前一包数据之后，而用户进程根据预先设定的缓冲区大小从系统接收缓冲区取数据，这样就一次取到了多包数据。分包是指在出现粘包的时候我们的接收方要进行分包处理。

在前面的测试程序中，是没有粘包问题的，这时候你可能有疑惑，我为啥数据会发送的特别快，我们以游戏服务器举例，比如游戏有联机对战功能，这时候肯定是需要同步位置信息的，这个频率是很快的，大约每秒就要40~80次，这个时候就会出现粘包问题。

其实很简单只要简单修改一下客户端即可。

1、程序测试 — 粘包问题

客户端：

服务器查看调试信息：

服务器已启动......

有一个客户端进行连接成功......

从客户端接收到的数据：0

从客户端接收到的数据：123

从客户端接收到的数据：4567

从客户端接收到的数据：8910

从客户端接收到的数据：1112131415

从客户端接收到的数据：161718

从客户端接收到的数据：192021222324

从客户端接收到的数据：25262728

从客户端接收到的数据：2930313233

从客户端接收到的数据：34353637

从客户端接收到的数据：38394041

从客户端接收到的数据：42434445

从客户端接收到的数据：46474849

从客户端接收到的数据：50515253

从客户端接收到的数据：5455565758

从客户端接收到的数据：59606162636465666768

从客户端接收到的数据：6970717273

从客户端接收到的数据：74757677

从客户端接收到的数据：78798081

从客户端接收到的数据：82838485

从客户端接收到的数据：86878889

从客户端接收到的数据：90919293

从客户端接收到的数据：9495969798

从客户端接收到的数据：99

（很明显数据没有发送100次）

1、程序测试 — 粘包问题

客户端：

服务器查看调试信息：

服务器已启动......

有一个客户端进行连接成功......

从客户端接收到的数据：

0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000撒大声地所多所多所多所多所多所多所多所多所多所000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000撒大声地所多所多所多所多所多所多所多所多所多所多所多所多所多所多撒大声地所多所多所多所多所多所多所多所多所多所多所多所多所多所多撒大声地所多所多所多所多所多所多所多所多所多所多所多所多所多所多000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000----------------------------------------------------------------撒大声地所多所多所多所多所多所多所多所多所?

从客户端接收到的数据：

77777777777777777777777777777777777777777777777777777777790909090909090909090909090909090909090000000000000000000000000099

（可以看出服务器是分两次接收的，但其实只要static byte[] dataBuffer = new byte[1024];给的空间足够大，分包问题就可解决）

其实也很好解决，我们在发送数据的时候事先存储数据的长度，不过用来存储数据长度的内存大小需要指定好，否则就没法判断了。

假设我们现在的数据出现了粘包，如下图所示：

这里只是演示一下，如果只有连续发送4次数据，一般是不会出现粘包的，看上图橙色部分表示我们用一个int32类型储存数据的长度，蓝色部分为我们实际要发送的数据，现在发生了粘包，也就是这四条数据合在一起发送给了服务器，

此时这条数据的总大小为 4字节 * 4 + 5 + 7 + 10 + 4 = 42字节

我们通过读取4字节数据可以知道数据的实际长度，以第一个数据为例，我们读取4字节数据，知道了这个数据有5个字节，程序如下：

int data_length = BitConverter.ToInt32(_data, 0);

此时的data_length = 5;此时我们就读取这5个字节的数据即可！

string s = Encoding.UTF8.GetString(_data, 4, 5);

然后我们截取数据，从源数据的第4 + 5的位置开始截取到一个新数组，新字节数组索引从零开始，此时新字节数据的长度为42 - (5 + 4)；（下图为新字节数组）

Array.Copy(_data, 5 + 4, _data, 0, 42 - (5 + 4));

依次循环下去，粘包就被成功的分包了。当然这个不要忘记每次更新一下当前数据长度。

_curLength = _curLength - (data_length + 4); // _curLength = 42 - (5 + 4)

1、客户端

创建Message类，用于发送数据前做处理，使得首4字节储存数据长度。

Message：

Main：

2、服务端

创建Message类，解决粘包问题！

Main：

服务器查看调试信息：

服务器已启动......

有一个客户端进行连接成功......

解析到一条数据：0米

解析到一条数据：1米

630

解析到一条数据：2米

622

解析到一条数据：3米

614

解析到一条数据：4米

606

解析到一条数据：5米

598

解析到一条数据：6米

590

解析到一条数据：7米

582

解析到一条数据：8米

574

解析到一条数据：9米

566

解析到一条数据：10米

558

..............................................................................

解析到一条数据：98米

解析到一条数据：99米

有客户端退出.....

你解决个屁，异步接收的情况下，把_data数组调大点就完了，傻逼，咱们是做游戏！一般不会有分包问题！！

（P9）socket编程四：流协议与粘(nian)包，粘包产生的原因，粘包处理方案，readn，writen 6.回射客户/服务器

文章目录

1.流协议与粘(nian)包
2.粘包产生的原因
4.粘包处理方案
5.readn，writen
6.回射客户/服务器

1.流协议与粘(nian)包

tcp是基于字节流的传输服务(字节流是无边界的)，像流水一样，无法区分边界，他不能保证对等方一次读操作能够返回多少字节。
eg：hostA发送两个数据包给hostB，对于hostB来讲，他可能有以下四种情况：例如第(2)，一次性读取M1和M2的所有消息，这里M1和M2就粘在一起了。
第（3）第一次读操作返回M1消息的全部和M2条消息的一部分(M2_1)，第二次读操作返回M2条消息的一部分(M2_2)
udp是基于消息的报文，是有边界的

（P9）socket编程四：流协议与粘(nian)包，粘包产生的原因，粘包处理方案，readn，writen

2.粘包产生的原因

tcp会有粘包问题
（1）write将应用进程缓冲区的数据拷贝到套接口发送缓冲区中，当应用进程缓冲区的大小超过了套接口发送缓冲区SO_SNDBUF的大小，就有可能产生粘包问题，可能一部分已经发送出去了，对方已经接收，另外一部分才发送套接口发送缓冲区进行发送，对方延迟接收后一部分数据，导致粘包问题，这里的原因是：数据包的分割
（2）TCP最大段MSS的限制，可能会对发送的消息进行分割，可能会产生粘包问题
（3）应用层的最大传输单元MTU的限制，若发送的数据包超过MTU，会在IP层进行分组或分片，可能会对发送的消息进行分割，可能会产生粘包问题
（4）tcp的流控，拥塞控制，延迟发送机制都有可能产生粘包问题

4.粘包处理方案

本质上是要在应用层维护消息与消息的边界
（1）定长包
（2）包尾加\\r\\n（ftp就是这么用的）
消息若本来就有\\r\\n，\\r\\n本来就是消息的一部分的话，则需要转义的方式
（3）包头加上包体长度
可以先接收包头，然后通过包头计算出包体的长度，然后才接收包体所对应的数据包
（4）更复杂的应用层协议

5.readn，writen

具体实现已经在6中回射服务器中了

6.回射客户/服务器

（1）以定长的方式收发数据
NetworkProgramming-master (1)\\LinuxNetworkProgramming\\P9echosrv.c
NetworkProgramming-master (1)\\LinuxNetworkProgramming\\P9echocli.c

==================NetworkProgramming-master (1)\\LinuxNetworkProgramming\\P9echosrv.c=============================
//
// Created by wangji on 19-7-21.
//

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>


using namespace std;

struct packet

    int len;
    char buf[1024];
;

#define ERR_EXIT(m) \\
        do  \\
           \\
            perror(m);  \\
            exit(EXIT_FAILURE); \\
         while(0);

//参考man 2 read声明写出来的
//ssize_t是无符号整数
ssize_t readn(int fd, void *buf, size_t count)

    size_t nleft = count;   // 剩余字节数
    ssize_t nread;//已接收字节数
    char *bufp = (char*) buf;

    while (nleft > 0)
    
        if ((nread = read(fd, bufp, nleft)) < 0)
        
            if (errno == EINTR)
                continue;
            return  -1;
         
        else if (nread == 0)//表示读取到了EOF，表示对方关闭
            return count - nleft;//表示剩余的字节数

        bufp += nread;//读到的nread，要将bufp指针偏移
        nleft -= nread;
    
    return count;


//参考man 2 write声明写出来的
ssize_t writen(int fd, const void *buf, size_t count)

    size_t nleft = count;//剩余要发送的字节数
    ssize_t nwritten;
    char* bufp = (char*)buf;

    while (nleft > 0)
    
        //write一般不会阻塞，缓冲区数据大于发送的数据，就能够成功将数据拷贝到缓冲区中
        if ((nwritten = write(fd, bufp, nleft)) < 0)
        
            if (errno == EINTR)
            
                continue;
            
            return -1;
        
        else if (nwritten == 0)
        
            continue;
        
        bufp += nwritten;//已发送字节数
        nleft -= nwritten;//剩余字节数
    
    return count;


void do_service(int connfd)

    // char recvbuf[1024];
    struct packet recvbuf;
    int n;
    while (1)
    
        memset(&recvbuf, 0, sizeof(recvbuf));
        int ret = readn(connfd, &recvbuf.len, 4);
        if (ret == -1)
        
            ERR_EXIT("read");
        
        else if (ret < 4)
        
            printf("client close\\n");
            break;
        

        n = ntohl(recvbuf.len);
        ret = readn(connfd, recvbuf.buf, n);
        if (ret == -1)
        
            ERR_EXIT("read");
        
        else if (ret < n)
        
            printf("client close\\n");
            break;
        
        fputs(recvbuf.buf, stdout);
        writen(connfd, &recvbuf, 4+n);
    



int main(int argc, char** argv) 
    // 1. 创建套接字
    int listenfd;
    if ((listenfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) 
        ERR_EXIT("socket");
    

    // 2. 分配套接字地址
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(6666);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    // servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    // inet_aton("127.0.0.1", &servaddr.sin_addr);

    int on = 1;
    // 确保time_wait状态下同一端口仍可使用
    if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
    
        ERR_EXIT("setsockopt");
    

    // 3. 绑定套接字地址
    if (bind(listenfd, (struct sockaddr*) &servaddr, sizeof(servaddr)) < 0) 
        ERR_EXIT("bind");
    
    // 4. 等待连接请求状态
    if (listen(listenfd, SOMAXCONN) < 0) 
        ERR_EXIT("listen");
    
    // 5. 允许连接
    struct sockaddr_in peeraddr;
    socklen_t peerlen = sizeof(peeraddr);


    // 6. 数据交换
    pid_t pid;
    while (1)
    
        int connfd;
        if ((connfd = accept(listenfd, (struct sockaddr *) &peeraddr, &peerlen)) < 0) 
            ERR_EXIT("accept");
        

        printf("id = %s, ", inet_ntoa(peeraddr.sin_addr));
        printf("port = %d\\n", ntohs(peeraddr.sin_port));

        pid = fork();

        if (pid == -1)
        
            ERR_EXIT("fork");
        
        if (pid == 0)   // 子进程
        
            close(listenfd);
            do_service(connfd);
            //printf("child exit\\n");
            exit(EXIT_SUCCESS);
        
        else
        
            //printf("parent exit\\n");
            close(connfd);
        


    
    // 7. 断开连接
    close(listenfd);



    return 0;

==================NetworkProgramming-master (1)\\LinuxNetworkProgramming\\P9echocli.c=============================
//
// Created by wangji on 19-7-21.
//

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>


using namespace std;

#define ERR_EXIT(m) \\
        do  \\
           \\
            perror(m);  \\
            exit(EXIT_FAILURE); \\
         while(0);

//参考man 2 read声明写出来的
//ssize_t是无符号整数
ssize_t readn(int fd, void *buf, size_t count)

    size_t nleft = count;   // 剩余字节数
    ssize_t nread;//已接收字节数
    char *bufp = (char*) buf;

    while (nleft > 0)
    
        if ((nread = read(fd, bufp, nleft)) < 0)
        
            if (errno == EINTR)
                continue;
            return  -1;
         
        else if (nread == 0)//表示读取到了EOF，表示对方关闭
            return count - nleft;//表示剩余的字节数

        bufp += nread;//读到的nread，要将bufp指针偏移
        nleft -= nread;
    
    return count;


//参考man 2 write声明写出来的
ssize_t writen(int fd, const void *buf, size_t count)

    size_t nleft = count;//剩余要发送的字节数
    ssize_t nwritten;
    char* bufp = (char*)buf;

    while (nleft > 0)
    
        //write一般不会阻塞，缓冲区数据大于发送的数据，就能够成功将数据拷贝到缓冲区中
        if ((nwritten = write(fd, bufp, nleft)) < 0)
        
            if (errno == EINTR)
            
                continue;
            
            return -1;
        
        else if (nwritten == 0)
        
            continue;
        
        bufp += nwritten;//已发送字节数
        nleft -= nwritten;//剩余字节数
    
    return count;


int main(int argc, char** argv) 
    // 1. 创建套接字
    int sockfd;
    if ((sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) 
        ERR_EXIT("socket");
    

    // 2. 分配套接字地址
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(6666);
    // servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    // inet_aton("127.0.0.1", &servaddr.sin_addr);

    // 3. 请求链接
    if (connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0) 
        ERR_EXIT("connect");
    

    // 4. 数据交换
   char recvbuf[1024]=0;
   char sendbuf[1024]=0;
    int n = 0;
    while (fgets((sendbuf), sizeof(sendbuf), stdin) != NULL)   // 键盘输入获取
    
        //发送定长包，缺点：若发送数据小，但是发的是定长包，会对网络造成负担
        writen(sockfd, sendbuf,sizeof(sendbuf));//发送和接收都是1024个字节
        readn(sockfd, recvbuf,sizeof(recvbuf));

        fputs(recvbuf, stdout);
        memset(sendbuf, 0, sizeof(sendbuf));
        memset(recvbuf, 0, sizeof(recvbuf));
    

    // 5. 断开连接
    close(sockfd);


    return 0;

（2）发送的数据包是头部+包体，接收的时候：先接收包头，接收完毕后，将数据包的长度计算出来，再接收对应的长度，对消息与消息之间进行了区分
NetworkProgramming-master (1)\\LinuxNetworkProgramming\\P9echosrv3.c
NetworkProgramming-master (1)\\LinuxNetworkProgramming\\P9echocli3.c

=====================================NetworkProgramming-master (1)\\LinuxNetworkProgramming\\P9echosrv3.c=============

//
// Created by wangji on 19-7-21.
//

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>


using namespace std;

struct packet

    int len;
    char buf[1024];
;

#define ERR_EXIT(m) \\
        do  \\
           \\
            perror(m);  \\
            exit(EXIT_FAILURE); \\
         while(0);

//参考man 2 read声明写出来的
//ssize_t是无符号整数
ssize_t readn(int fd, void *buf, size_t count)

    size_t nleft = count;   // 剩余字节数
    ssize_t nread;//已接收字节数
    char *bufp = (char*) buf;

    while (nleft > 0)
    
        if ((nread = read(fd, bufp, nleft)) < 0)
        
            if (errno == EINTR)
                continue;
            return  -1;
         
        else if (nread == 0)//表示读取到了EOF，表示对方关闭
            return count - nleft;//表示剩余的字节数

        bufp += nread;//读到的nread，要将bufp指针偏移
        nleft -= nread;
    
    return count;


//参考man 2 write声明写出来的
ssize_t writen(int fd, const void *buf, size_t count)

    size_t nleft = count;//剩余要发送的字节数
    ssize_t nwritten;
    char* bufp = (char*)buf;

    while (nleft > 0)
    
        //write一般不会阻塞，缓冲区数据大于发送的数据，就能够成功将数据拷贝到缓冲区中
        if ((nwritten = write(fd, bufp, nleft)) < 0)
        
            if (errno == EINTR)
            
                continue;
            
            return -1;
        
        else if (nwritten == 0)
        
            continue;
        
        bufp += nwritten;//已发送字节数
        nleft -= nwritten;//剩余字节数
    
    return count;


void do_service(int connfd)

    // char recvbuf[1024];
    struct packet recvbuf;
    int n;
    while (1)
    
        memset(&recvbuf, 0, sizeof recvbuf);
        int ret = readn(connfd, &recvbuf.len, 4);//先接收头部
        if (ret == -1)
        
            ERR_EXIT("read");
        
        else if (ret < 4)
        
            printf("client close\\n");
            break;
        

        n = ntohl(recvbuf.len);//转换程主机字节序，包体实际长度n
        ret = readn(connfd, recvbuf.buf, n);//接收包体
        if (ret == -1)
        
            ERR_EXIT("read");
        
        else if (ret < n)
        
            printf("client close\\n");
            break;
        
        fputs(recvbuf.buf, stdout);
        writen(connfd, &recvbuf, 4+n);
    



int main(int argc, char** argv) 
    // 1. 创建套接字
    int listenfd;
    if ((listenfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) 
        ERR_EXIT("socket");
    

    // 2. 分配套接字地址
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof servaddr);
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(6666);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    // servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    // inet_aton("127.0.0.1", &servaddr.sin_addr);

    int on = 1;
    // 确保time_wait状态下同一端口仍可使用
    if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
    
        ERR_EXIT("setsockopt");
    

    // 3. 绑定套接字地址
    if (bind(listenfd, (struct sockaddr*) &servaddr, sizeof(servaddr)) < 0) 
        ERR_EXIT("bind");
    
    // 4. 等待连接请求状态
    if (listen(listenfd, SOMAXCONN) < 0) 
        ERR_EXIT("listen");
    
    // 5. 允许连接
    struct sockaddr_in peeraddr;
    socklen_t peerlen = sizeof(peeraddr);


    // 6. 数据交换
    pid_t pid;
    while (1)
    
        int connfd;
        if ((connfd = accept(listenfd, (struct sockaddr *) &peeraddr, &peerlen)) < 0) 
            ERR_EXIT("accept");
        

        printf("id = %s, ", inet_ntoa(peeraddr.sin_addr));
        printf("port = %d\\n", ntohs(peeraddr.sin_port));

        pid = fork();

        if (pid == -1)
        
            ERR_EXIT("fork");
        
        if (pid == 0)   // 子进程
        
            close(listenfd);
            do_service(connfd);
            //printf("child exit\\n");
            exit(EXIT_SUCCESS);
        
        else
        
            //printf("parent exit\\n");
            close(connfd);
        


    
    // 7. 断开连接
    close(listenfd);



    return 0;

=================================NetworkProgramming-master (1)\\LinuxNetworkProgramming\\P9echocli3.c=============

//
// Created by wangji on 19-7-21.
//

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>


using namespace std;

struct packet

    int len;//包头：存放包体实际的数据长度
    char buf[1024];//包体
;

#define ERR_EXIT(m) \\
        do  \\
           \\
            perror(m);  \\
            exit(EXIT_FAILURE); \\
         while(0);

/参考man 2 read声明写出来的
//ssize_t是无符号整数
ssize_t readn(int fd, void *buf, size_t count)

    size_t nleft = count;   // 剩余字节数
    ssize_t nread;//已接收字节数
    char *bufp = (char*) buf;

    while (nleft > 0)
    
        if ((nread = read(fd, bufp, nleft)) < 0)
        
            if (errno == EINTR)
                continue;
            return  -1;
         
        else if (nread == 0)//表示读取到了EOF，表示对方关闭
            return count - nleft;//表示剩余的字节数

        bufp += nread;//读到的nread，要将bufp指针偏移
        nleft -= nread;
    
    return count;


//参考man 2 write声明写出来的
ssize_t writen(int fd, const void *buf, size_t count)

    size_t nleft = count;//剩余要发送的字节数
    ssize_t nwritten;
    char* bufp = (char*)buf;

    while (nleft > 0)
    
        //write一般不会阻塞，缓冲区数据大于发送的数据，就能够成功将数据拷贝到缓冲区中
        if ((nwritten = write(fd, bufp, nleft)) < 0)
        
            if (errno == EINTR)
            
                continue;
            
            return -1;
        
        else if (nwritten == 0)
        
            continue;
        
        bufp += nwritten;//已发送字节数
        nleft -= nwritten;//剩余字节数
    
    return count;


int main(int argc, char** argv) 
    // 1. 创建套接字
    int sockfd;
    if ((sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) 
        ERR_EXIT("socket");
    

    // 2. 分配套接字地址
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(6666);
    // servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    // inet_aton("127.0.0.1", &servaddr.sin_addr);

    // 3. 请求链接
    if (connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0) 
        ERR_EXIT("connect");
    

    // 4. 数据交换
//    char recvbuf[1024];
//    char sendbuf[1024];
    struct packet recvbuf;
    struct packet sendbuf;
    memset(&recvbuf, 0, sizeof(recvbuf));
    memset(&sendbuf, 0, sizeof(sendbuf));
    int n = 0;
    while (fgets(sendbuf.buf, sizeof(sendbuf.buf), stdin) != NULL)   // 键盘输入获取
    
        n = strlen(sendbuf.buf);//n是包体的长度
        sendbuf.len = htonl(n); // 主机字节序转换为网络字节序
        writen(sockfd, &sendbuf, 4+n); // 头部4字节+包体

        int ret = readn(sockfd, &recvbuf.len, 4); //先接收头部
        if (ret == -1)
        
            ERR_EXIT("read");
        
        else if (ret < 4)
        
            printf("server close\\n");
            break;
        

        n = ntohl(recvbuf.len);//转换程主机字节序
        ret = readn(sockfd, &recvbuf.buf, n);//接收包体
        if (ret == -1)
        
            ERR_EXIT("read");
        
        else if (ret < n)
        
            printf("server close\\n");
            break;
        

        fputs(recvbuf.buf, stdout); //将接收到的数据输出

        // 清空
        memset(&recvbuf, 0, sizeof(recvbuf));
        memset(&sendbuf, 0, sizeof(sendbuf));
    

    // 5. 断开连接
    close(sockfd);


    return 0;

测试：
Makefile

.PHONY:clean all
CC=gcc
CFLAGS=-Wall -g
BIN=echosrv echocli
all:$(BIN)
%.o:%.c
  $(CC) $(CFLAGS) -c $< -o $@
clean:
  rm -f *.o $(BIN)

以上是关于简易游戏服务器—分包与粘包问题的主要内容，如果未能解决你的问题，请参考以下文章

python 网络编程(远程执行命令与粘包)

网络 -- TCP概述三次握手四次挥手粘包分包数据分段