TCP分包和粘包

1.TCP分包

场景：

发送方发送字符串”helloworld”，接收方却分别接收到了两个数据包：字符串”hello”和”world”

发送端发送了数量较多的数据，接收端读取数据时候数据分批到达，造成一次发送多次读取；

造成分包的原因：

TCP是以段（Segment）为单位发送数据的,建立TCP链接后,有一个最大消息长度（MSS）.如果应用层数据包超过MSS,就会把应用层数据包拆分,分成两个段来发送.

这个时候接收端的应用层就要拼接这两个TCP包，才能正确处理数据。

相关的,路由器有一个MTU（ 最大传输单元）一般是1500字节,除去IP头部20字节,留给TCP的就只有MTU-20字节。所以一般TCP的MSS为MTU-20=1460字节

当应用层数据超过1460字节时,TCP会分多个数据包来发送。

2.TCP 粘包

场景：

发送方发送两个字符串"hello"和"world",接收方却接收到了整个字符串"helloworld"

发送端发送了几次数据，接收端一次性读取了所有数据，造成多次发送一次读取；通常是网络流量优化，把多个小的数据段集满达到一定的数据量，从而减少网络链路中的传输次数

造成TCP粘包的原因：

TCP为了提高网络的利用率,会使用一个叫做Nagle的算法.该算法是指,发送端即使有要发送的数据,如果很少的话,会延迟发送.如果应用层给TCP传送数据很快的话,就会把两个应用层数据包“粘”在一起,TCP最后只发一个TCP数据包给接收端.

分包和粘包解决方案：

发送数据前，给数据前附加两字节的长度：

4字节	4个字节	null
FBEB	数据长度	数据内容

1. 包标识： 包头部的特殊标识，用来标识包的开始
2. 数据长度：数据包的大小，固定长度,2、4 或者8字节。
3. 数据内容：数据内容，长度为数据头定义的长度大小。

举个例子，假设我们要发送一段文本消息 “Hello, world!” 给接收方，为了将消息打包成一个数据包并发送出去，我们可以按照一定的格式将消息文本和数据长度字段组合在一起。

一共分为3个部分:每行的()内放着每一部分的变量名,和下一小节的代码实战中的变量名一致
第一部分: FBEB占4个字节,放在最前面,(TAG)
第二部分: "Hello, world!"一共有13个字符,那么数据长度字段的值就应该是 13，转换成 4 个字节的整数后，可以表示为二进制数 00000000 00000000 00000000 00001101。(DATA_LEN_BYTES)
第三部分: 48 65 66C 6F 2C 20 77 6F 72 6C 64 21  // 消息文本，即 "Hello, world!"(ms_len)

实际操作如下：
a）发送端：先发送包标识和长度，再发送数据内容。
b）接收端：先解析本次数据包的大小N，再读取N个字节，这N个字节就是一个完整的数据内容。

简而言之,言而简之,就是先告诉对方自己发的消息长度,再发消息

具体流程如下：

代码实战

// echo_client.c 解决分包和粘包的问题
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define SERVER_PORT 6666
#define SERVER_IP "127.0.0.1"
#define DATA_LEN_BYTES 4

const char *TAG = "FBEB";

int main(int argc, char *argv[])
{

    int sockfd;
    char *message;
    struct sockaddr_in servaddr;
    int n;
    char *buf = NULL;

    if (argc != 2)
    {
        fputs("Usage: ./echo_client message \n", stderr);
        exit(1);
    }

    message = argv[1];

    printf("message: %s\n", message);

    sockfd = socket(AF_INET, SOCK_STREAM, 0);

    memset(&servaddr, '\0', sizeof(struct sockaddr_in));

    servaddr.sin_family = AF_INET;
    inet_pton(AF_INET, SERVER_IP, &servaddr.sin_addr);
    servaddr.sin_port = htons(SERVER_PORT);

    connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

    // 组装数据包
    int ms_len = strlen(message); // 计算出消息文本 message的长度
    int tag_len = strlen(TAG);    // 标签文本 TAG 的长度

    // ms_len 变量保存的是消息文本的长度，而 DATA_LEN_BYTES 则表示消息长度字段(也就是ms_len)所占用的字节数。
    buf = (char *)malloc(ms_len + tag_len + DATA_LEN_BYTES); // 。其中 DATA_LEN_BYTES 是一个常量，表示消息长度的字节数，通常为 4。
    strcpy(buf, TAG);                                        // 第一部分:该代码将标签文本 TAG 和消息长度信息写入到数据包的头部中。具体来说，使用 strcpy 函数将标签文本 TAG 复制到数据包的起始位置.
    *((int *)(buf + tag_len)) = ms_len;                      // 第二部分:然后使用指针类型转换将消息长度信息转换成整型,因为消息长度信息占用的字节数是 DATA_LEN_BYTES，所以需要将消息长度信息写入到 buf + tag_len 的位置处，即标签文本 TAG 后面的位置。注意:buf是字符串指针,而tag_len是一个int类型的变量
    memcpy(buf + tag_len + DATA_LEN_BYTES, message, ms_len); // 第三部分:使用 memcpy 函数将消息文本 message 复制到数据包的剩余部分中，即从 buf + tag_len + DATA_LEN_BYTES 的位置开始的位置，复制 ms_len 个字节的数据。这样，整个数据包就被组装好了，可以使用 write 函数将数据包发送给服务器。

    // 模拟分包
    write(sockfd, buf, tag_len + DATA_LEN_BYTES);
    sleep(1);
    write(sockfd, buf + tag_len + DATA_LEN_BYTES, 1);
    sleep(2);
    write(sockfd, buf + tag_len + DATA_LEN_BYTES + 1, ms_len - 1);

    n = read(sockfd, buf, ms_len + tag_len + DATA_LEN_BYTES - 1);

    if (n > 0)
    {
        buf[n] = '\0';
        printf("receive: %s\n", buf);
    }
    else
    {
        perror("error!!!");
    }

    printf("finished.\n");
    close(sockfd);

    return 0;
}

// echo_server.c 解决分包和粘包的问题
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define SERVER_PORT 6666
#define DATA_LEN_BYTES 4

const char *TAG = "FBEB";

// 读一个完整的包
int read_package(int client_sock, char *buf, unsigned int len)
{
    int tag_len = strlen(TAG);
    // 使用 read 函数从套接字中读取 tag_len + DATA_LEN_BYTES 个字节的数据，并将读取到的数据保存到缓冲区 buf 中。
    int readlen = read(client_sock, buf, tag_len + DATA_LEN_BYTES); // 当次获取的(TAG和数据长度已经拿到,不过数据长度还未转化为int)

    // 对TAG进行检查
    if (strncmp(buf, TAG, tag_len) == 0)          // 由于数据包头部的标签文本和消息长度信息是固定长度的，因此只需要读取这两部分信息，并检查标签文本是否正确即可判断数据包是否合法。
    {                                             // 合法
        int data_len = *((int *)(buf + tag_len)); // 使用指针类型转换将消息长度信息转换成整型，并记录下消息的实际长度。(这时才拿到数据的长度)
        printf("data length:%d\n", data_len);     // 打印处理分包粘包问题的数据长度

        // 读取数据部分(第三部分)
        int count = 0; // 已经读取的全部字节数
        readlen = 0;
        while (count < data_len) // 使用循环从套接字中读取消息的剩余部分，直到读取到足够的数据为止。
        {
            readlen = read(client_sock, buf + count, data_len - count);
            printf("read len:%d\n", readlen);
            // if(readlen == -1 || readlen ==0)

            count += readlen;
        }
        return data_len;
    }
}

int main(void)
{

    int sock; // 代表信箱
    struct sockaddr_in server_addr;

    // 1.美女创建信箱
    sock = socket(AF_INET, SOCK_STREAM, 0);

    // 2.清空标签，写上地址和端口号
    bzero(&server_addr, sizeof(server_addr));

    server_addr.sin_family = AF_INET;                // 选择协议族IPV4
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY); // 监听本地所有IP地址
    server_addr.sin_port = htons(SERVER_PORT);       // 绑定端口号

    // 实现标签贴到收信得信箱上
    bind(sock, (struct sockaddr *)&server_addr, sizeof(server_addr));

    // 把信箱挂置到传达室，这样，就可以接收信件了
    listen(sock, 128);

    // 万事俱备，只等来信
    printf("等待客户端的连接\n");

    int done = 1;

    while (done)
    {
        struct sockaddr_in client;
        int client_sock, len, i;
        char client_ip[64];
        char buf[256];

        socklen_t client_addr_len;
        client_addr_len = sizeof(client);
        client_sock = accept(sock, (struct sockaddr *)&client, &client_addr_len);

        // 打印客服端IP地址和端口号
        printf("client ip: %s\t port : %d\n",
               inet_ntop(AF_INET, &client.sin_addr.s_addr, client_ip, sizeof(client_ip)),
               ntohs(client.sin_port));

        /*读取客户端发送的数据*/
        len = read_package(client_sock, buf, sizeof(buf));
        // len = read(client_sock, buf, sizeof(buf) - 1);
        buf[len] = '\0';
        printf("receive[%d]: %s\n", len, buf);

        // 转换成大写
        for (i = 0; i < len; i++)
        {
            /*if(buf[i]>='a' && buf[i]<='z'){
                buf[i] = buf[i] - 32;
            }*/
            buf[i] = toupper(buf[i]);
        }

        len = write(client_sock, buf, len);

        printf("finished. len: %d\n", len);
        close(client_sock);
    }
    close(sock);
    return 0;
}