文章目录

• TCP分包和粘包
• • TCP分包
  • TCP 粘包
  • 分包和粘包解决方案：

TCP分包和粘包

TCP分包

• 场景：发送方发送字符串”helloworld”，接收方却分别接收到了两个数据包：字符串”hello”和”world”发送端发送了数量较多的数据，接收端读取数据时候数据分批到达，造成一次发送多次读取；

造成分包的原因：

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

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

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

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

TCP 粘包

• 场景：发送方发送两个字符串”hello”和”world”，接收方却接收到了字符串”helloworld”
• 发送端发送了几次数据，接收端一次性读取了所有数据，造成多次发送一次读取；通常是网络流量优化，把多个小的数据段集满达到一定的数据量，从而减少网络链路中的传输次数

造成TCP粘包的原因：

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

分包和粘包解决方案：

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

• 粘包解决方案：传入数据长度，告诉服务器我本次发送的数据只有这么多，你可别读多了。
• 分包解决方案：传入数据长度，告诉服务器我本次发送的数据有这么多，你可别读少了。

1. 特殊标识： 包头部的特殊标识，用来标识包的开始 （自定义）
2. 数据长度：数据包的大小，固定长度,2、4 或者8字节。
3. 数据内容：数据内容，长度为数据头定义的长度大小。
4. 一旦接收方发现标识FBEB,代表接下来N个字节代表数据长度

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

程序由回声服务器修改而来 ， 客户端发送小写字母 ， 服务端接收后把他转化为大写字母发送给客户端

先上结果

echo_sever.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <ctype.h>
#include <arpa/inet.h>

#define SERVER_PORT 9999

const int DATA_LEN_BYTES = 4; // 长度字段定义为两个字节
const char *TAG = "ABCD";// 标志位

int read_package(int client_sock , char *buf){
    int tag_len = strlen(TAG);

    // 读取前8个字节 即读取标志位和数据长度
    int readLen = read(client_sock , buf , tag_len + DATA_LEN_BYTES);

    int data_len = 0;
    if(strncmp(buf ,TAG , 4) == 0){
        // 有标志位 那么就要读取数据长度
        data_len = *((int* )(buf + tag_len));

        int count = 0;// 当前已经读取的字节数
        int len = 0;// 本次读取的字节数

        // 把标志位和数据长度清空，放数据
        memset(buf,'0',tag_len + DATA_LEN_BYTES);

        while(count < data_len){
            // 数据量比较大的话有可能一次读不完，要读取很多次
            // 直到读取的数据长度为data_len

            // 每次期望读取data_len - count 实际读取为len
            // len = read(client_sock , buf + count , data_len - count);

            // 读取数据写1，是为了模拟多次读取
            len = read(client_sock , buf + count , 2);
            printf("本次读取数据量为 %d\n" , len);

            count += len;
        }

    }else{
        /*如果没有标志位，表示传过来的是普通数据
          这里先不做处理*/
    }

    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));

    // 3.把信箱挂置到传达室，这样，就可以接收信件了
    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);
        buf[len] = '\0';
        printf("receive[%d]: %s\n", len, buf);


        // 转换成大写
        for (i = 0; i < len; i++)
        {
            buf[i] = toupper(buf[i]);
        }

        len = write(client_sock, buf, len);

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

echo_client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define SERVER_PORT 9999
#define SERVER_IP  "127.0.0.1"


const int DATA_LEN_BYTES = 4; // 长度字段定义为两个字节
const char *TAG = "ABCD";// 标志位

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);
    int tag_len = strlen(TAG);

    // 标志位 + 数据长度 + 数据 + \0
    buf = (char *)malloc(tag_len + DATA_LEN_BYTES + ms_len);
    strcpy(buf , TAG);// 标志位
    *((int*)(buf + tag_len)) = ms_len;// 数据长度
    memcpy(buf + tag_len + DATA_LEN_BYTES , message , ms_len);//数据

    
    // 发送数据
    write(sockfd , buf , tag_len + DATA_LEN_BYTES);// 发送标志位和数据长度
    sleep(1);
    write(sockfd , buf + tag_len + DATA_LEN_BYTES , ms_len);// 发送数据




    n = read(sockfd, buf, sizeof(buf)-1);

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

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

    return 0;
}