TCP网络通讯如何解决分包粘包问题（有模拟代码）

TCP作为常用的网络传输协议，数据流解析是网络应用开发人员永远绕不开的一个问题。

TCP数据传输是以无边界的数据流传输形式，所谓无边界是指数据发送端发送的字节数，在数据接收端接受时并不一定等于发送的字节数，可能会出现粘包情况。

一、TCP粘包情况：

1. 发送端发送了数量比较的数据，接收端读取数据时候数据分批到达，造成一次发送多次读取；通常网络路由的缓存大小有关系，一个数据段大小超过缓存大小，那么就要拆包发送。

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

TCP粘包的解决方案有很多种方法，最简单的一种就是发送的数据协议定义发送的数据包的结构：

1. 数据头：数据包的大小，固定长度。

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

实际操作如下：

a）发送端：先发送数据包的大小，再发送数据内容。

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

具体流程如下：

实现源码

1. /**
2. * read size of len from sock into buf.
3. */
4. bool readPack(int sock, char* buf, size_t len) {
5. if (NULL == buf || len < 1) {
6. return false;
7. }
8. memset(buf, 0, len); // only reset buffer len.
9. ssize_t read_len = 0, readsum = 0;
10. do {
11. read_len = read(sock, buf + readsum, len - readsum);
12. if (-1 == read_len) { // ignore error case
13. return false;
14. }
15. printf("receive data: %s\n", buf + readsum);
16. readsum += read_len;
17. } while (readsum < len && 0 != read_len);
18. return true;
19. }

二、测试用例介绍

本篇提供的demo主要流程如下：

1. 客户端负责模拟发送数据，服务端负责接受数据，处理粘包问题

a）emulate_subpackage

模拟情况1，一个长数据经过多次才到达目的地，

在客户端字符串“This is a test case for client send subpackage data. data is not send complete at once.”每次只发送6个字节长度。服务端要把字符串集满才能处理数据（打印字符串）

b）emulate_adheringpackage

模拟情况2，多个数据在一次性到达目的地

在客户端将字符串“Hello I'm lucky. Nice too me you”切成三个数据段（都包含数据头和数据内容），然后一次性发送，服务端读取数据时对三个数据段逐个处理。

三、源码实现

server.cpp

1. #include <cstdio>
2. #include <cstdlib>
3. #include <cstring>
4. #include <errno.h>
5. #include <sys/socket.h>
6. #include <sys/types.h>
7. #include <arpa/inet.h>
8. #include <unistd.h>
9. void newclient(int sock);
10. bool readPack(int sock, char* buf, size_t len);
11. void safe_close(int &sock);
12. int main(int argc, char *argv[]) {
13. int sockfd = -1, newsockfd = -1;
14. socklen_t c = 0;
15. struct sockaddr_in serv_addr, cli_addr;
16. // Create socket
17. sockfd = socket(AF_INET, SOCK_STREAM, 0);
18. if (-1 == sockfd) {
19. printf("new socket failed. errno: %d, error: %s\n", errno, strerror(errno));
20. exit(-1);
21. }
22. // Prepare the sockaddr_in structure
23. serv_addr.sin_family = AF_INET;
24. serv_addr.sin_addr.s_addr = INADDR_ANY;
25. serv_addr.sin_port = htons(7890);
26. // bind
27. if (bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
28. printf("bind failed. errno: %d, error: %s\n", errno, strerror(errno));
29. exit(-1);
30. }
31. // listen
32. listen(sockfd, 5);
33. printf("listening...\n");
34. // accept new connection.
35. c = sizeof(struct sockaddr_in);
36. int i = 0;
37. while (i++ < 3) {
38. printf("waiting for new socket accept.\n");
39. newsockfd = accept(sockfd, (struct sockaddr*)&cli_addr, (socklen_t*)&c);
40. if (newsockfd < 0) {
41. printf("accept connect failed. errno: %d, error: %s\n", errno, strerror(errno));
42. safe_close(sockfd);
43. exit(-1);
44. }
45. pid_t pid = fork();
46. if (0 == pid) {
47. newclient(newsockfd);
48. safe_close(sockfd);
49. break;
50. } else if (pid > 0) {
51. safe_close(newsockfd);
52. }
53. }
54. safe_close(sockfd);
55. return 0;
56. }
57. void newclient(int sock) {
58. printf("newclient sock fd: %d\n", sock);
59. int datasize = 0;
60. const int HEAD_SIZE = 9;
61. char buf[512] = {0};
62. while (true) {
63. memset(buf, 0, sizeof(buf));
64. if (! readPack(sock, buf, HEAD_SIZE)) {
65. printf("read head buffer failed.\n");
66. safe_close(sock);
67. return;
68. }
69. datasize = atoi(buf);
70. printf("data size: %s, value:%d\n", buf, datasize);
71. memset(buf, 0, sizeof(buf));
72. if (! readPack(sock, buf, datasize)) {
73. printf("read data buffer failed\n");
74. safe_close(sock);
75. return;
76. }
77. printf("data size: %d, text: %s\n", datasize, buf);
78. if (0 == strcmp(buf, "exit")) {
79. break;
80. }
81. }
82. memset(buf, 0, sizeof(buf));
83. snprintf(buf, sizeof(buf), "from server read complete.");
84. write(sock, buf, strlen(buf) + 1);
85. printf("newclient sockfd: %d, finish.\n", sock);
86. safe_close(sock);
87. }
88. void safe_close(int &sock) {
89. if (sock > 0) {
90. close(sock);
91. sock = -1;
92. }
93. }
94. /**
95. * read size of len from sock into buf.
96. */
97. bool readPack(int sock, char* buf, size_t len) {
98. if (NULL == buf || len < 1) {
99. return false;
100. }
101. memset(buf, 0, len); // only reset buffer len.
102. ssize_t read_len = 0, readsum = 0;
103. do {
104. read_len = read(sock, buf + readsum, len - readsum);
105. if (-1 == read_len) { // ignore error case
106. return false;
107. }
108. printf("receive data: %s\n", buf + readsum);
109. readsum += read_len;
110. } while (readsum < len && 0 != read_len);
111. return true;
112. }

client.cpp

1. #include <cstdio>
2. #include <cstdlib>
3. #include <cstring>
4. #include <time.h>
5. #include <errno.h>
6. #include <sys/socket.h>
7. #include <arpa/inet.h>
8. #include <unistd.h>
9. void safe_close(int &sock);
10. void emulate_subpackage(int sock);
11. void emulate_adheringpackage(int sock);
12. int main(int argc, char *argv[]) {
13. char buf[128] = {0};
14. int sockfd = -1;
15. struct sockaddr_in serv_addr;
16. // Create sock
17. sockfd = socket(AF_INET, SOCK_STREAM, 0);
18. if (-1 == sockfd) {
19. printf("new socket failed. errno: %d, error: %s\n", errno, strerror(errno));
20. exit(-1);
21. }
22. serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
23. serv_addr.sin_family = AF_INET;
24. serv_addr.sin_port = htons(7890);
25. // Connect to remote server
26. if (connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
27. printf("connection failed. errno: %d, error: %s\n", errno, strerror(errno));
28. exit(-1);
29. }
30. emulate_subpackage(sockfd);
31. emulate_adheringpackage(sockfd);
32. const int HEAD_SIZE = 9;
33. const char temp[] = "exit";
34. memset(buf, 0, sizeof(buf));
35. snprintf(buf, sizeof(buf), "%0.*zu", HEAD_SIZE - 1, sizeof(temp));
36. write(sockfd, buf, HEAD_SIZE);
37. write(sockfd, temp, sizeof(temp));
38. printf("send complete.\n");
39. memset(buf, 0, sizeof(buf));
40. read(sockfd, buf, sizeof(buf));
41. printf("receive data: %s\n", buf);
42. printf("client finish.\n");
43. safe_close(sockfd);
44. return 0;
45. }
46. void safe_close(int &sock) {
47. if (sock > 0) {
48. close(sock);
49. sock = -1;
50. }
51. }
52. /**
53. * emulate socket data write multi part.
54. */
55. void emulate_subpackage(int sock) {
56. printf("emulate_subpackage...\n");
57. char text[] = "This is a test case for client send subpackage data. data is not send complete at once.";
58. const size_t TEXTSIZE = sizeof(text);
59. ssize_t len = 0;
60. size_t sendsize = 0, sendsum = 0;
61. const int HEAD_SIZE = 9;
62. char buf[64] = {0};
63. snprintf(buf, HEAD_SIZE, "%08zu", TEXTSIZE);
64. write(sock, buf, HEAD_SIZE);
65. printf("send data size: %s\n", buf);
66. do {
67. sendsize = 6;
68. if (sendsum + sendsize > TEXTSIZE) {
69. sendsize = TEXTSIZE - sendsum;
70. }
71. len = write(sock, text + sendsum, sendsize);
72. if (-1 == len) {
73. printf("send data failed. errno: %d, error: %s\n", errno, strerror(errno));
74. return;
75. }
76. memset(buf, 0, sizeof(buf));
77. snprintf(buf, len + 1, text + sendsum);
78. printf("send data: %s\n", buf);
79. sendsum += len;
80. sleep(1);
81. } while (sendsum < TEXTSIZE && 0 != len);
82. }
83. /**
84. * emualte socket data write adhering.
85. */
86. void emulate_adheringpackage(int sock) {
87. printf("emulate_adheringpackage...\n");
88. const int HEAD_SIZE = 9;
89. char buf[1024] = {0};
90. char text[128] = {0};
91. char *pstart = buf;
92. // append text
93. memset(text, 0, sizeof(text));
94. snprintf(text, sizeof(text), "Hello ");
95. snprintf(pstart, HEAD_SIZE, "%08zu", strlen(text) + 1);
96. pstart += HEAD_SIZE;
97. snprintf(pstart, strlen(text) + 1, "%s", text);
98. pstart += strlen(text) + 1;
99. // append text
100. memset(text, 0, sizeof(text));
101. snprintf(text, sizeof(text), "I'm lucky.");
102. snprintf(pstart, HEAD_SIZE, "%08zu", strlen(text) + 1);
103. pstart += HEAD_SIZE;
104. snprintf(pstart, strlen(text) + 1, "%s", text);
105. pstart += strlen(text) + 1;
106. // append text
107. memset(text, 0, sizeof(text));
108. snprintf(text, sizeof(text), "Nice too me you");
109. snprintf(pstart, HEAD_SIZE, "%08zu", strlen(text) + 1);
110. pstart += HEAD_SIZE;
111. snprintf(pstart, strlen(text) + 1, "%s", text);
112. pstart += strlen(text) + 1;
113. write(sock, buf, pstart - buf);
114. }

Makefile

1. CC=g++
2. CFLAGS=-I
3. all: server.o client.o
4. server.o: server.cpp
5. $(CC) -o server.o server.cpp
6. client.o: client.cpp
7. $(CC) -o client.o client.cpp
8. clean:
9. rm *.o

四、测试结果

编译及运行

$ make

g++ -o server.o server.cpp

g++ -o client.o client.cpp

客户端模拟发送数据

$ ./client.o

emulate_subpackage...

send data size: 00000088

send data: This i

send data: s a te

send data: st cas

send data: e for

send data: client

send data: send

send data: subpac

send data: kage d

send data: ata. d

send data: ata is

send data: not s

send data: end co

send data: mplete

send data: at on

send data: ce.

emulate_adheringpackage...

send complete.

receive data: from server read complete.

client finish.

服务端模拟接受数据

$ ./server.o

listening...

waiting for new socket accept.

waiting for new socket accept.

newclient sock fd: 4

receive data: 00000088

data size: 00000088, value:88

receive data: This i

receive data: s a te

receive data: st cas

receive data: e for

receive data: client

receive data: send

receive data: subpac

receive data: kage d

receive data: ata. d

receive data: ata is

receive data: not s

receive data: end co

receive data: mplete

receive data: at on

receive data: ce.

data size: 88, text: This is a test case for client send subpackage data. data is not send complete at once.

receive data: 00000007

data size: 00000007, value:7

receive data: Hello

data size: 7, text: Hello

receive data: 00000011

data size: 00000011, value:11

receive data: I'm lucky.

data size: 11, text: I'm lucky.

receive data: 00000016

data size: 00000016, value:16

receive data: Nice too me you

data size: 16, text: Nice too me you

receive data: 00000005

data size: 00000005, value:5

receive data: exit

data size: 5, text: exit

newclient sockfd: 4, finish.

 

 

http://blog.csdn.net/sweettool/article/details/77018506