1. Toy模板网首页
  2. > Toy博客

Linux Socket 分包 和 粘包 问题 - 解决方案

10月前 作者：cpp_learners 分类：Toy博客 阅读(42) 违法举报

这篇具有很好参考价值的文章主要介绍了Linux Socket 分包 和 粘包 问题 - 解决方案。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

分包和粘包在TCP网络编程中是非常常见的，分包会造成 接收端 接收的数据不全的问题，粘包会造成接收多余的数据的文件。

这里做一个举例，例如客户端A要发送字符串“helloworld”给服务器B，A是一次性发送，但TCP有可能会将其分成两个包去发送，如分成“hello”和“world”，当服务器不知道数据已经被分成两个包去发送了，它只是接收也一个包，即只接收了“hello”，造成数据接收不全的问题！

或者说，当发送的数据过小时，却连续发送多次时，TCP会将他们同时打包，一起发送，接收时如果也是一次性接收，那么就会接收了多余的数据了！

目录

一、TCP分包

二、TCP粘包

三、分包和粘包的解决方案

1. 组合数据关键代码

2. 解析数据关键代码

四、示例

client.c

server.c

编译运行测试

五、总结

一、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粘包

场景：发送方发送字符串”helloworld”，接收方却接收到了两个字符串”hello”和”world”；

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

造成TCP粘包的原因：

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

三、分包和粘包的解决方案

发送数据前，给数据附加固定的头部长度：

Linux Socket 分包 和 粘包 问题 - 解决方案

1. 包标识：  包头部的特殊标识，用来标识包的开始；

2. 数据长度：数据包的大小，固定长度，2、4 或者8字节；

3. 数据内容：数据内容，长度为数据头定义的长度大小；

假设包标识是FBEB，即，如果发送的数据是helloworld，则组合发送的数据为：FBEB10helloworld

实际操作如下：

a）发送端：先发送包表示和长度，再发送数据内容。

b）接收端：先解析本次数据包的大小N，再读取N个字节，这N个字节就是一个完整的数据内容。

具体流程如下：

Linux Socket 分包 和 粘包 问题 - 解决方案

按照这种思路，就可以解决分包和粘包的问题了！

1. 组合数据关键代码

#define DATA_LEN_BYTES  4
const char *TAG = "FBEB";

char *message = "helloworld";

int ms_len = strlen(message);  
int tag_len = strlen(TAG);

// 组装数据包
char *buf = (char*)malloc(ms_len + tag_len + DATA_LEN_BYTES);
memset(buf, '\0', ms_len + tag_len + DATA_LEN_BYTES);

strcpy(buf, TAG);
*((int *)(buf + tag_len)) = ms_len;
memcpy(buf + tag_len + DATA_LEN_BYTES, message, ms_len);

这样组合出来的数据就是符合上面我们规定的那样了！

解析再按相应规则进行解析就可以得到数据了！

2. 解析数据关键代码

#define DATA_LEN_BYTES  4
const char *TAG = "FBEB";

int tag_len = strlen(TAG);
char buf[1024] = { '\0' };


// 1. 首先接收头部信息
read(client_sock, buf, tag_len + DATA_LEN_BYTES);


// 2. 通过strncmp比较，即可得知数据开始部分是否是我们定义的标识
if (strncmp(buf, TAG, tag_len) == 0) { /* 符合条件 */ }


// 3. 获得实际数据的大小
int dataLen = *((int *)(buf + tag_len));


// 4. 循环接收数据，存储到buf中
int count = 0;
int readLen = 0;
while (count < dataLen) {
    readLen = read(client_sock, buf + count, dataLen - count);    // dataLen-count：还需要接收多少数据
    
    count += readLen;    // 统计已经接收了多少数据
}

这样，不管是分包和粘包问题都可以正常的接收了！

四、示例

客户端发送消息给服务器，服务器发送消息给客户端！模拟分包发送！

客户端发送数据给服务器时，将数据拆成三个包发送；服务器发送数据给客户端时，将数据包拆成两个包发送！

client.c

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

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

const char *TAG = "Jtom";




int read_package(int client_sock, char *buf, unsigned int len) {
    int readLen = 0;    // 当前读取字节数
    int count = 0;      // 已经读取字节数
    
    if (buf == NULL || client_sock < 1) {
        printf("Parameters are wrong!\n");
        return -1;
    }
      
    
    int tag_len = strlen(TAG);

    int ret = read(client_sock, buf, tag_len + DATA_LEN_BYTES);
    if (-1 == ret) {
        fprintf(stderr, "read failed! reason：%s", strerror(errno));
        return ret;
    } else if (0 == ret) {
        printf("1read data return 0!\n");
        return ret;
    }

    // 对TAG进行检查
    if (strncmp(buf, TAG, tag_len) == 0) {
        int dataLen = *((int *)(buf + tag_len));
        //printf("dataLen = %d\n", dataLen);
        
        int failCount = 0;  // 失败重试
        
        // 读取数据部分
        count = 0;
        readLen = 0;
        while (count < dataLen) {
            readLen = read(client_sock, buf + count, dataLen - count);
            printf("readLen = %d\n", readLen);
            if (-1 == readLen) {
                if (5 > failCount) {
                    failCount++;
                    readLen = 0;
                } else {
                    fprintf(stderr, "read failed! reason：%s", strerror(errno));
                    return readLen;
                }
                
            } else if (0 == readLen) {
                if (5 > failCount) {
                    failCount++;
                    readLen = 0;
                } else {
                    printf("2read data return 0!\n");
                    return ret;
                } 
            }
            
            count += readLen;
        }
        
        return dataLen;
    }
}    



// 线程执行函数
void *my_thread_handle(void *arg) {
    
    char buf[1024] = { '\0' };
    int sockfd = *(int *)arg;
    int failCount = 0;  // 失败重试5次
    
    while (1) {
       // 读取服务器发送回来的信息
        int len = read_package(sockfd, buf, sizeof(buf));
        if (len > 0) {
            buf[len] = '\0';
            printf("receive[%d]: %s", len, buf);
        } else {
            if (5 > failCount) {
                failCount++;
                sleep(1);
            } else {               
                fprintf(stderr, "connect server off!\n");                             
                break;
            }
        }            
        
        if (strncmp(buf, "end", 3) == 0) {
            break;
        }
        memset(buf, '\0', sizeof(buf));
    }
    
    pthread_exit(NULL);
}



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

    int sockfd;
    char message[1024] = { '\0' };
    struct sockaddr_in servaddr;
    int n;
    char *buf = NULL;


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

    int ret = connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
    if (-1 == ret) {
        printf("connet failed! reason：%s\n", strerror(errno));
        exit(1);
    }
    
    
    // 创建线程取接收客户端发送过来的数据
    pthread_t mythread;
    // 创建线程
    ret = pthread_create(&mythread, 0, my_thread_handle, &sockfd);
    if (0 != ret) {
        printf("create thread failed!\n");
        exit(1);
    }
    
    
    while (1) {
        fgets(message, 1024, stdin);
        
        int ms_len = strlen(message);  
        int tag_len = strlen(TAG);
        
        // 组装数据包
        buf = (char*)malloc(ms_len + tag_len + DATA_LEN_BYTES);
        memset(buf, '\0', ms_len + tag_len + DATA_LEN_BYTES);
        
        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);
        
        // 模拟发送三个包
        write(sockfd, buf + tag_len + DATA_LEN_BYTES, 1);
        sleep(1);
        write(sockfd, buf + tag_len + DATA_LEN_BYTES + 1, 1);
        sleep(1);
        write(sockfd, buf + tag_len + DATA_LEN_BYTES + 2, ms_len - 2);
        
        if (strncmp(buf + tag_len + DATA_LEN_BYTES, "exit", 4) == 0) {
            free(buf);
            break;
        }
        free(buf);
    }
   

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

    return 0;
}

server.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>        // strerror
#include <ctype.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <errno.h>
 

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

const char *TAG = "Jtom";



int read_package(int client_sock, char *buf, unsigned int len) {
    int readLen = 0;    // 当前读取字节数
    int count = 0;      // 已经读取字节数
    
    if (buf == NULL || client_sock < 1) {
        printf("Parameters are wrong!\n");
        return -1;
    }
      
    
    int tag_len = strlen(TAG);

    int ret = read(client_sock, buf, tag_len + DATA_LEN_BYTES);
    if (-1 == ret) {
        fprintf(stderr, "read failed! reason：%s", strerror(errno));
        return ret;
    } else if (0 == ret) {
        printf("read data return 0!\n");
        return ret;
    }

    // 对TAG进行检查
    if (strncmp(buf, TAG, tag_len) == 0) {
        int dataLen = *((int *)(buf + tag_len));
        //printf("dataLen = %d\n", dataLen);
        
        int failCount = 0;  // 失败重试
        
        // 读取数据部分
        count = 0;
        readLen = 0;
        while (count < dataLen) {
            readLen = read(client_sock, buf + count, dataLen - count);
            printf("readLen = %d\n", readLen);
            if (-1 == readLen) {
                if (5 > failCount) {
                    failCount++;
                    readLen = 0;
                } else {
                    fprintf(stderr, "read failed! reason：%s", strerror(errno));
                    return readLen;
                }
                
            } else if (0 == readLen) {
                if (5 > failCount) {
                    failCount++;
                    readLen = 0;
                } else {
                    printf("read data return 0!\n");
                    return ret;
                } 
            }
            
            count += readLen;
        }
        
        return dataLen;
    }
}    



// 线程执行函数
void *my_thread_handle(void *arg) {
    
    char buf[1024] = { '\0' };
    int client_sock = *(int *)arg;
    int failCount = 0;
    
    while (1) {
       // 读取服务器发送回来的信息
        int len = read_package(client_sock, buf, sizeof(buf));
        if (len > 0) {
            buf[len] = '\0';
            printf("receive[%d]: %s", len, buf);
        } else {
            if (5 > failCount) {
                failCount++;
                sleep(1);
            } else {
                fprintf(stderr, "connect client off!\n");                             
                break;
            }
        }       
        
        if (strncmp(buf, "end", 3) == 0) {
            break;
        }
        memset(buf, '\0', sizeof(buf));
    }
    
    pthread_exit(NULL);
}
 
 
 
int main(void) {
	
	int ret = 0;
	int sock;	// 通信套接字
	struct sockaddr_in server_addr;
    char message[1024] = { '\0' };
	
	// 1.创建通信套接字
	sock = socket(AF_INET, SOCK_STREAM, 0);
	if (-1 == sock) {
		fprintf(stderr, "create socket error, reason: %s\n", strerror(errno));
		exit(-1);
	}
	
	// 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);			// 绑定端口号
	
	// 3.绑定
	ret = bind(sock, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if (-1 == ret) {
		fprintf(stderr, "socket bind error, reason: %s\n", strerror(errno));
		close(sock);
		exit(-2);
	}
	
	// 4.监听，同时监听128个请求
	ret = listen(sock, 128);
	if (-1 == ret) {
		fprintf(stderr, "listen error, reason: %s\n", strerror(errno));
		close(sock);
		exit(-2);
	}
	
	printf("等待客户端的链接\n");
    
    struct sockaddr_in client;
    int client_sock;
    char client_ip[64];
    
    socklen_t client_addr_len;		
    client_addr_len = sizeof(client);
    // 5.接受
    client_sock = accept(sock, (struct sockaddr *)&client, &client_addr_len);
    if (-1 == client_sock) {
        perror("accept error");
        close(sock);
        exit(-3);
    }
    
    // 打印客户端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));
    
    
    // 创建线程取接收客户端发送过来的数据
    pthread_t mythread;
    // 创建线程
    ret = pthread_create(&mythread, 0, my_thread_handle, &client_sock);
    if (0 != ret) {
        printf("create thread failed!\n");
        exit(1);
    }
    
    
	
	while (1) {
		
		fgets(message, sizeof(message), stdin);
        int ms_len = strlen(message);  
        int tag_len = strlen(TAG);
        
        // 组装数据包
        char *buf = (char*)malloc(ms_len + tag_len + DATA_LEN_BYTES);  
        memset(buf, '\0', ms_len + tag_len + DATA_LEN_BYTES);
        
        strcpy(buf, TAG);
        *((int *)(buf + tag_len)) = ms_len;
        memcpy(buf + tag_len + DATA_LEN_BYTES, message, ms_len);
        
        
        // 先发送头部，即标识符和发送数据的大小
        write(client_sock, buf, tag_len + DATA_LEN_BYTES);
        
        // 模拟发送两个包
        write(client_sock, buf + tag_len + DATA_LEN_BYTES, 1);
        sleep(1);
        write(client_sock, buf + tag_len + DATA_LEN_BYTES + 1, ms_len - 1);
        
        if (strncmp(buf + tag_len + DATA_LEN_BYTES, "exit", 4) == 0) {
            free(buf);
            break;
        }

        free(buf);
	}
	
	// 9.关闭服务器套接字
	close(sock);
    close(client_sock);
	
	return 0;
}

编译运行测试

gcc client.c -lpthread -o client

gcc server.c -lpthread -o server

Linux Socket 分包 和 粘包 问题 - 解决方案

某一端输入exit退出后，另一端会持续读取6次，如果超过6次，也就结束了，但也还要输入exit退出才行！

五、总结

TCP的分包和粘包相关问题已经列出来了，解决办法也记录下来了；

下次还需要写TCP编程时，需要注意分包和粘包的问题，然后组合数据去发送！文章来源地址https://www.toymoban.com/news/detail-467966.html

到了这里，关于Linux Socket 分包 和 粘包 问题 - 解决方案的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • Mysql出现问题：ERROR 2002 (HY000): Can’t connect to local MySQL server through socket ‘/data/mysql/my解决方案

    Mysql出现问题：ERROR 2002 (HY000): Can’t connect to local MySQL server through socket ‘/data/mysql/my解决方案

    回城传送–》《数据库问题解决方案》 ❤️作者主页：小虚竹 ❤️作者简介：大家好,我是小虚竹。Java领域优质创作者🏆，CSDN博客专家🏆，华为云享专家🏆，掘金年度人气作者🏆，阿里云专家博主🏆，51CTO专家博主🏆 ❤️技术活，该赏 ❤️点赞 👍 收藏 ⭐再看，养成习

    2024年02月06日
    浏览(52)
  • Linux系统中HTTP代理的常见问题及解决方案

    Linux系统中HTTP代理的常见问题及解决方案

    亲爱的Linux用户们，是不是有时候觉得HTTP代理就像是一个魔法盒子，让你在数字世界中自由穿梭？但是，就像所有的魔法物品一样，它也会偶尔出点小状况。今天，我们就来一起探讨一下Linux系统中HTTP代理的常见问题及解决方案，让你在面对这些“魔法问题”时不再头疼！

    2024年04月09日
    浏览(53)
  • vscode连接linux虚拟机 环境配置和常见问题解决方案

    vscode连接linux虚拟机 环境配置和常见问题解决方案

    vscode连接linux虚拟机配置环境步骤 1、自己安装vscode ，傻瓜式安装，配置ssh插件 2、配置虚拟机 （1）确保自己的虚拟机上的ssh服务可用 打开虚拟机，在终端命令行上敲入：sudo apt-get install openssh-server 进行安装。(有的Ubuntu版本在系统安装好就已经自带了) （2）确定自己虚拟机

    2024年02月16日
    浏览(64)
  • （六）关于Linux中服务器磁盘爆满问题的几个解决方案

    （六）关于Linux中服务器磁盘爆满问题的几个解决方案

    在监控服务器性能的时候，发现服务器的磁盘占用很大，几乎快要爆满，具体的表现可能如下： 1、应用服务访问卡顿甚至失败； 2、数据库访问失败； 3、文件上传失败 等等 通过命令 df -h 查看磁盘占用情况，发现如下： 这里的占用是清除过的，所以并不算特别高。 这种现

    2024年02月10日
    浏览(53)
  • Linux:登录报错“authentication token manipulation error”问题分析与解决方案

    Linux:登录报错“authentication token manipulation error”问题分析与解决方案

    在日常的Linux系统使用中，遇到“authentication token manipulation error”这个错误是一个比较常见的问题。这篇文章将为大家深入分析这个问题的原因，并提供详细的解决方案。 在尝试更改Linux系统的用户密码时，可能会遇到“authentication token manipulation error”的错误提示。这通常发

    2024年04月09日
    浏览(58)
  • Linux显示磁盘空间不足，/tmp文件夹占用100%问题分析和解决方案

    Linux显示磁盘空间不足，/tmp文件夹占用100%问题分析和解决方案

            系统运行过程中发现无法上传文件，第一反应是磁盘空间不足导致，登录服务器后查看文件存放的空间充足，但是无法上传文件且命令行的tab键自动补充也提示空间不足。最后经过搜索和分析发现是/tmp 文件夹占用100%导致。以下记录分析和解决流程。         服

    2024年02月05日
    浏览(78)
  • Linux下git访问github遇问题大全及解决方案（太多了，慢慢更新）

    Linux下git访问github遇问题大全及解决方案（太多了，慢慢更新）

    目录 目录 1.  ssh -T git@github.com配置了公钥依旧提示git@github.com‘s password: Permission denied, please try again.   2. ssh: connect to host github.com port 22: Connection refused  3. git报错Failed to connect to127.0.0.1 port 1080:Connection refused 4.  git push时卡住的解决方法(长时间不报错也不自动退出)_相关技

    2024年01月21日
    浏览(53)

  • Linux安装OpenCV和Makefile:: recipe for target ‘all‘ failed问题解决方案

    在Linux系统上安装OpenCV是进行计算机视觉和图像处理开发的常见需求。然而，有时在安装或编译OpenCV时，可能会遇到一些问题。其中一个常见问题是在编译过程中出现\\\"Makefile:: recipe for target ‘all’ failed\\\"错误。本文将介绍如何解决这个问题。 问题描述： 当尝试编译OpenCV时，可

    2024年02月06日
    浏览(44)

  • 在使用socket进行通信连接时出现java.net.SocketException: Connection reset的解决方案

    在创建客户端和服务端后，出现java.net.SocketException: Connection reset的错误。 导致的原因 客户端或者服务端其中一端还在传输数据的途中，另外一端的socket被关闭（或者主动0关闭，或者运行异常退出导致的关闭），这时，客户端的第一个数据包传输过来后就会引发该异常。 一端

    2024年02月09日
    浏览(50)
  • TCP分包和粘包

    TCP分包和粘包

    场景：发送方发送字符串”helloworld”，接收方却分别接收到了两个数据包：字符串”hello”和”world”发送端发送了数量较多的数据，接收端读取数据时候数据分批到达，造成一次发送多次读取； 造成分包的原因： TCP是以段（Segment）为单位发送数据的,建立TCP链接后,有一个最

    2023年04月19日
    浏览(32)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包