分包和粘包在TCP网络编程中是非常常见的，分包会造成 接收端 接收的数据不全的问题，粘包会造成接收多余的数据的文件。
这里做一个举例，例如客户端A要发送字符串“helloworld”给服务器B，A是一次性发送，但TCP有可能会将其分成两个包去发送，如分成“hello”和“world”，当服务器不知道数据已经被分成两个包去发送了，它只是接收也一个包，即只接收了“hello”，造成数据接收不全的问题！
或者说，当发送的数据过小时，却连续发送多次时，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粘包
场景：发送方发送字符串”helloworld”，接收方却接收到了两个字符串”hello”和”world”；
发送端发送了几次数据，接收端一次性读取了所有数据，造成多次发送一次读取；通常是网络流量优化，把多个小的数据段集满达到一定的数据量，从而减少网络链路中的传输次数；
造成TCP粘包的原因：
TCP为了提高网络的利用率,会使用一个叫做Nagle的算法.该算法是指,发送端即使有要发送的数据,如果很少的话,会延迟发送.如果应用层给TCP传送数据很快的话,就会把两个应用层数据包“粘”在一起,TCP最后只发一个TCP数据包给接收端.
三、分包和粘包的解决方案
发送数据前，给数据附加固定的头部长度：
1. 包标识： 包头部的特殊标识，用来标识包的开始；
2. 数据长度：数据包的大小，固定长度，2、4 或者8字节；
3. 数据内容：数据内容，长度为数据头定义的长度大小；
假设包标识是FBEB，即，如果发送的数据是helloworld，则组合发送的数据为：FBEB10helloworld
实际操作如下：
a）发送端：先发送包表示和长度，再发送数据内容。
b）接收端：先解析本次数据包的大小N，再读取N个字节，这N个字节就是一个完整的数据内容。
具体流程如下：
按照这种思路，就可以解决分包和粘包的问题了！
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
某一端输入exit退出后，另一端会持续读取6次，如果超过6次，也就结束了，但也还要输入exit退出才行！
五、总结
TCP的分包和粘包相关问题已经列出来了，解决办法也记录下来了；
下次还需要写TCP编程时，需要注意分包和粘包的问题，然后组合数据去发送！