socket coding

单客户端-短连接

Client

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<sys/socket.h>
using namespace std;

#define BUF_SIZE 512
#define ERR_EXIT(m) \
	do \
	{	\
		perror(m);	\
		exit(EXIT_FAILURE);	\
	} while (0)

int main() {
	// 创建套接字
	int m_sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if(m_sockfd < 0) {
		ERR_EXIT("create socket fail");
	}

	// 服务器的ip为本地，端口号
	struct sockaddr_in server_addr;
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
	server_addr.sin_port = htons(39002);

	// 向服务器发送连接请求
	int m_connectfd = connect(m_sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if(m_connectfd < 0) {
		ERR_EXIT("connect server fail");
	}

	// 发送并接收数据
	char buffer[BUF_SIZE];
	printf("client send:");
	scanf("%s", buffer);
	send(m_sockfd, buffer, sizeof(buffer), 0);
	recv(m_sockfd, buffer, sizeof(buffer), 0);
	printf("client recv:%s\n", buffer);

	// 断开连接
	close(m_sockfd);

	return 0;
}

Server

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<string.h>
#include<unistd.h>
#include<arpa/inet.h>
using namespace std;

#define BUF_SIZE 512
#define ERR_EXIT(m) \
	do \
	{	\
		perror(m);	\
		exit(EXIT_FAILURE);	\
	} while (0)

int main() {
	// 创建套接字
	int m_sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if(m_sockfd < 0) {
		ERR_EXIT("create socket fail");
	}

	// 初始化socket元素
	struct sockaddr_in server_addr;
	size_t server_len = sizeof(server_addr);
	memset(&server_addr, 0, server_len);

	server_addr.sin_family = AF_INET;
	//server_addr.sin_addr.s_addr = inet_addr("0.0.0.0");
	server_addr.sin_addr.s_addr = INADDR_ANY;
	server_addr.sin_port = htons(39002);

	// 绑定文件描述符和服务器的ip和端口号
	int m_bindfd = bind(m_sockfd, (struct sockaddr *)&server_addr, (socklen_t)server_len);
	if(m_bindfd < 0) {
		ERR_EXIT("bind ip and port fail");
	}

	// 进入监听状态，等待用户发起请求
	int m_listenfd = listen(m_sockfd, 20);
	if(m_listenfd < 0) {
		ERR_EXIT("listen client fail");
	}

	// 定义客户端的套接字
	struct sockaddr_in client_addr;
	socklen_t client_len = sizeof(client_addr);
	int m_connfd = accept(m_sockfd, (struct sockaddr*)&client_addr, &client_len);

	// 接收客户端数据，并响应
	char buffer[BUF_SIZE];
	recv(m_connfd, buffer, sizeof(buffer), 0);
	printf("server recv:%s\n", buffer);
	strcat(buffer, "+ACK");
	send(m_connfd, buffer, sizeof(buffer), MSG_NOSIGNAL);

	// 关闭套接字
	close(m_connfd);
	close(m_sockfd);

	return 0;
}

单客户端-长连接

Client

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<sys/socket.h>
using namespace std;

#define BUF_SIZE 512
#define ERR_EXIT(m) \
	do \
	{	\
		perror(m);	\
		exit(EXIT_FAILURE);	\
	} while (0)

int main() {
	// 创建套接字
	int m_sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if(m_sockfd < 0) {
		ERR_EXIT("create socket fail");
	}

	// 服务器的ip为本地，端口号
	struct sockaddr_in server_addr;
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
	server_addr.sin_port = htons(39002);

	// 向服务器发送连接请求
	int m_connectfd = connect(m_sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if(m_connectfd < 0) {
		ERR_EXIT("connect server fail");
	}

	// 发送并接收数据
	char buffer[BUF_SIZE];
	while(true){
		memset(buffer, 0, sizeof(buffer)); // 重置缓冲区
		printf("client send:");
		scanf("%s", buffer);
		send(m_sockfd, buffer, sizeof(buffer), 0);
		recv(m_sockfd, buffer, sizeof(buffer), 0);
		printf("client recv:%s\n", buffer);
	}

	// 断开连接
	close(m_sockfd);
	printf("client socket closed!!!\n");

	return 0;
}

Server

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<string.h>
#include<unistd.h>
#include<arpa/inet.h>
using namespace std;

#define BUF_SIZE 512
#define ERR_EXIT(m) \
	do \
	{	\
		perror(m);	\
		exit(EXIT_FAILURE);	\
	} while (0)

int main() {
	// 创建套接字
	int m_sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if(m_sockfd < 0) {
		ERR_EXIT("create socket fail");
	}

	// 初始化socket元素
	struct sockaddr_in server_addr;
	size_t server_len = sizeof(server_addr);
	memset(&server_addr, 0, server_len);

	server_addr.sin_family = AF_INET;
	//server_addr.sin_addr.s_addr = inet_addr("0.0.0.0");
	server_addr.sin_addr.s_addr = INADDR_ANY;
	server_addr.sin_port = htons(39002);

	// 绑定文件描述符和服务器的ip和端口号
	int m_bindfd = bind(m_sockfd, (struct sockaddr *)&server_addr, (socklen_t)server_len);
	if(m_bindfd < 0) {
		ERR_EXIT("bind ip and port fail");
	}

	// 进入监听状态，等待用户发起请求
	int m_listenfd = listen(m_sockfd, 20);
	if(m_listenfd < 0) {
		ERR_EXIT("listen client fail");
	}

	// 定义客户端的套接字
	struct sockaddr_in client_addr;
	socklen_t client_len = sizeof(client_addr);
	int m_connfd = accept(m_sockfd, (struct sockaddr*)&client_addr, &client_len);

	// 接收客户端数据，并响应
	char buffer[BUF_SIZE];
	while(true){
		if(m_connfd < 0) {
			m_connfd = accept(m_sockfd, (struct sockaddr*)&client_addr, &client_len);
			printf("client accept success again!!!\n");
		}
		memset(buffer, 0, sizeof(buffer)); // 重置缓冲区
		ssize_t recvLen = recv(m_connfd, buffer, sizeof(buffer), 0);
		if(recvLen <= 0) {
			close(m_connfd);
			m_connfd = -1;
			printf("client lose connection!!!\n");
			continue;
		}
		printf("server recv:%s\n", buffer);
		strcat(buffer, "+ACK");
		send(m_connfd, buffer, sizeof(buffer), MSG_NOSIGNAL);
	}

	// 关闭套接字
	close(m_connfd);
	close(m_sockfd);

	return 0;
}

多客户端-select

Client

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<sys/socket.h>
using namespace std;

#define BUF_SIZE 512
#define ERR_EXIT(m) \
	do \
	{	\
		perror(m);	\
		exit(EXIT_FAILURE);	\
	} while (0)

int main() {
	// 创建套接字
	int m_sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if(m_sockfd < 0) {
		ERR_EXIT("create socket fail");
	}

	// 服务器的ip为本地，端口号
	struct sockaddr_in server_addr;
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
	server_addr.sin_port = htons(39002);

	// 向服务器发送连接请求
	int m_connectfd = connect(m_sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if(m_connectfd < 0) {
		ERR_EXIT("connect server fail");
	}

	// 发送并接收数据
	char buffer[BUF_SIZE];
	while(true){
		memset(buffer, 0, sizeof(buffer)); // 重置缓冲区
		printf("client send:");
		scanf("%s", buffer);
		send(m_sockfd, buffer, sizeof(buffer), 0);
		recv(m_sockfd, buffer, sizeof(buffer), 0);
		printf("client recv:%s\n", buffer);
	}

	// 断开连接
	close(m_sockfd);
	printf("client socket closed!!!\n");

	return 0;
}

Server

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<string.h>
#include<unistd.h>
#include<arpa/inet.h>
using namespace std;

#define PORT 39002
#define MAX_FD_NUM 3
#define BUF_SIZE 512
#define ERR_EXIT(m) \
	do \
	{	\
		perror(m);	\
		exit(EXIT_FAILURE);	\
	} while (0)

int main() {
	// 创建套接字
	int m_sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if(m_sockfd < 0) {
		ERR_EXIT("create socket fail");
	}

	// 初始化socket元素
	struct sockaddr_in server_addr;
	size_t server_len = sizeof(server_addr);
	memset(&server_addr, 0, server_len);

	server_addr.sin_family = AF_INET;
	//server_addr.sin_addr.s_addr = inet_addr("0.0.0.0");
	server_addr.sin_addr.s_addr = INADDR_ANY;
	server_addr.sin_port = htons(39002);

	// 绑定文件描述符和服务器的ip和端口号
	int m_bindfd = bind(m_sockfd, (struct sockaddr *)&server_addr, (socklen_t)server_len);
	if(m_bindfd < 0) {
		ERR_EXIT("bind ip and port fail");
	}

	// 进入监听状态，等待用户发起请求
	int m_listenfd = listen(m_sockfd, 20);
	if(m_listenfd < 0) {
		ERR_EXIT("listen client fail");
	}

	printf("client accept success\n");

	// 定义客户端的套接字
	struct sockaddr_in client_addr;
	socklen_t client_len = sizeof(client_addr);

	// 接收客户端数据，并响应
	char buffer[BUF_SIZE];
	int array_fd[MAX_FD_NUM]; // 在线客户端句柄数组

	// 客户端连接数量
	int client_count = 0;

	struct fd_set tmpfd;
	int max_fd = m_sockfd; // 最大socket
	struct  timeval timeout;
	
	for(int i = 0; i < MAX_FD_NUM; i++) {
		array_fd[i] = -1;
	}

	while(true){
		FD_ZERO(&tmpfd);
		FD_SET(m_sockfd, &tmpfd);
		int i;

		// 所有在线的客户端加入fd中，并找出最大的socket
		for(int i = 0; i < MAX_FD_NUM; i++) {
			if(array_fd[i] > 0) {
				FD_SET(array_fd[i], &tmpfd);
				if(max_fd < array_fd[i]){
					max_fd = array_fd[i];
				}
			}
		}

		int ret = select(max_fd + 1, &tmpfd, nullptr, nullptr, nullptr);
		if(ret < 0) {
			ERR_EXIT("select fail");
		}else if(ret == 0) {
			printf("select timeout\n");
			continue;
		}

		// 表示有客户端连接
		if(FD_ISSET(m_sockfd, &tmpfd)){
			int m_connfd = accept(m_sockfd, (struct sockaddr *)&client_addr, &client_len);
			if(m_connfd < 0) {
				ERR_EXIT("server accept fail");
			}

			// 客户端连接数已满
			if(client_count >= MAX_FD_NUM){
				printf("max connections arrive!!!\n");
				close(m_connfd);
				continue;
			}

			// 客户端数量加1
			client_count++;
			printf("we got a new connection, ");
			printf("client_socket=%d, client_count=%d, ip=%s, port=%d\n",
				m_connfd, client_count, inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

			for(int i = 0; i < MAX_FD_NUM; i++) {
				if(array_fd[i] == -1) {
					array_fd[i] = m_connfd;
					break;
				}
			}
		}

		// 遍历所有的客户端连接，找到发送数据的那个客户端描述
		for(int i = 0; i < MAX_FD_NUM; i++) {
			if(array_fd[i] < 0) {
				continue;
			}else { // 有客户端发送过来的数据
				if(FD_ISSET(array_fd[i], &tmpfd)) {
					memset(buffer, 0, sizeof(buffer)); // 重置缓冲区
					ssize_t recv_len = recv(array_fd[i], buffer, sizeof(buffer), 0);
					if(recv_len < 0) {
						ERR_EXIT("recv data fail");
					} else if(recv_len == 0){ // 客户端断开连接
						client_count--;
						// 打印断开的客户端数据
						printf("client_socket=[%d] close, client_count=[%d], ip=%s, port=%d\n\n",
								array_fd[i], client_count, inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
						close(array_fd[i]);
						FD_CLR(array_fd[i], &tmpfd);
						array_fd[i] = -1;
					}else {
						printf("server recv:%s\n", buffer);
						strcat(buffer, "+ACK");
						send(array_fd[i], buffer, sizeof(buffer), 0);
					}
				}
			}
		}

	}

	// 关闭套接字
	close(m_sockfd);

	printf("server socket closed!!!\n");

	return 0;
}

Result

socket_select_result

多客户端-epoll

client

1
2


server

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<string.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<sys/epoll.h>  // linux机器上执行，macos使用kqueue
using namespace std;

#define EPOLL_SIZE 1023 // epoll监听客户端数
#define MAX_EVENTS 64
#define BUF_SIZE 512
#define ERR_EXIT(m) \
	do \
	{	\
		perror(m);	\
		exit(EXIT_FAILURE);	\
	} while (0)

int main() {
	// 创建套接字
	int m_sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if(m_sockfd < 0) {
		ERR_EXIT("create socket fail");
	}

	// 初始化socket元素
	struct sockaddr_in server_addr;
	size_t server_len = sizeof(server_addr);
	memset(&server_addr, 0, server_len);

	server_addr.sin_family = AF_INET;
	//server_addr.sin_addr.s_addr = inet_addr("0.0.0.0");
	server_addr.sin_addr.s_addr = INADDR_ANY;
	server_addr.sin_port = htons(39002);

	// 绑定文件描述符和服务器的ip和端口号
	int m_bindfd = bind(m_sockfd, (struct sockaddr *)&server_addr, (socklen_t)server_len);
	if(m_bindfd < 0) {
		ERR_EXIT("bind ip and port fail");
	}

	// 进入监听状态，等待用户发起请求
	int m_listenfd = listen(m_sockfd, 20);
	if(m_listenfd < 0) {
		ERR_EXIT("listen client fail");
	}

	printf("client accept success\n");

	// 定义客户端的套接字
	struct sockaddr_in client_addr;
	socklen_t client_len = sizeof(client_addr);

	// 创建一个监听描述符epoll，并将监听套接字加入监听红黑树
	int epollfd = epoll_create(EPOLL_SIZE);
	if(epollfd < 0) {
		ERR_EXIT("epoll create fail");
	}

	struct epoll_event epe;
	epe.events = EPOLLIN;
	epe.data.fd = m_sockfd;

	// 控制epoll文件描述符上的动作
	if(epoll_ctl(epollfd, EPOLL_CTL_ADD, m_sockfd, &epe) < 0) {
		ERR_EXIT("epoll control fail");
	}

	struct epoll_event epeList[MAX_EVENTS];

	// 接收客户端数据，并响应
	char buffer[BUF_SIZE];

	while(true){
		int ret = epoll_wait(epollfd, epeList, MAX_EVENTS, -1); // 监听等待就绪描述符加入就绪队列
		if(ret < 0) {
			ERR_EXIT("epoll fail");
		}else if(ret == 0) {
			printf("epoll timeout\n");
			continue;
		}

		for(int i = 0; i < ret; i++) {
			// 客户端请求连接
			if(epeList[i].data.fd == m_sockfd) {
				int m_connfd = accept(m_sockfd,	(struct sockaddr*)&client_addr, &client_len);
				if(m_connfd < 0) {
					ERR_EXIT("server accept fail");
				}

				// 将客户端新建立的连接添加到epoll的监听中
				struct epoll_event epe;
				epe.events = EPOLLIN | EPOLLRDHUP; // 监听套接字的可读和退出
				epe.data.fd = m_connfd;
				if(epoll_ctl(epollfd, EPOLL_CTL_ADD, m_connfd, &epe) < 0) { // 将新的套接字加入监听
					ERR_EXIT("epoll control fail, accept client");
				}

				printf("we got a new connection, client_socket=%d, ip=%s, port=%d\n", m_connfd, inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

			}else if(epeList[i].events & EPOLLIN) {
				memset(buffer, 0, sizeof(buffer)); // 重置缓冲区
				int recv_len = recv(epeList[i].data.fd, buffer, sizeof(buffer), 0);
				if(recv_len < 0) {
					ERR_EXIT("recv data fail");
				}else if(recv_len == 0) { // 客户端断开连接
					// 打开断开的客户端数据
					epoll_ctl(epollfd, EPOLL_CTL_DEL, epeList[i].data.fd, &epe);
					close(epeList[i].data.fd);
				}else {
					printf("server recv:%s\n", buffer);
					strcat(buffer, "+ACK");
					send(epeList[i].data.fd, buffer, sizeof(buffer), 0);
				}
			}else { // 客户端退出
				printf("a client is quit, ip=%s, port=%d\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
				epoll_ctl(epollfd, EPOLL_CTL_DEL, epeList[i].data.fd, &epe);
				close(epeList[i].data.fd);
			}
		}
	}

	// 关闭套接字
	close(m_sockfd);

	printf("server socket closed!!!\n");

	return 0;
}

粘包/拆包

发生原因

  • 要发送的数据大于TCP发送缓冲区剩余空间大小，将会发生拆包。
  • 待发送数据大于MSS（最大报文长度），TCP在传输前将进行拆包。
  • 要发送的数据小于TCP发送缓冲区的大小，TCP将多次写入缓冲区的数据一次发送出去，将会发生粘包。
  • 接收数据端的应用层没有及时读取接收缓冲区中的数据，将发生粘包。
  • 而数据之所以会发送粘包拆包的根本原因是TCP的数据包是流的方式传输的，就像水流一样，没有一个分界的东西。

处理方法

  • 特殊分隔符
  • 固定发包大小
  • 发送端给每个数据包添加包首部，首部中应该至少包含数据包的长度，这样接收端在接收到数据后，通过读取包首部的长度字段，便知道每一个数据包的实际长度了。 第1种和第2种方法都会存在一些误差，没有办法很好处理好粘包拆包，所以一般的方法都是采用第3种。以下我先给出代码，然后再结合代码分析第3种粘包拆包的处理方式。

client

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<sys/socket.h>
#include"protocol.h"
using namespace std;

#define BUF_SIZE 512
#define ERR_EXIT(m) \
	do \
	{	\
		perror(m);	\
		exit(EXIT_FAILURE);	\
	} while (0)

int main() {
	// 创建套接字
	int m_sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if(m_sockfd < 0) {
		ERR_EXIT("create socket fail");
	}

	// 服务器的ip为本地，端口号
	struct sockaddr_in server_addr;
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
	server_addr.sin_port = htons(39002);

	// 向服务器发送连接请求
	int m_connectfd = connect(m_sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if(m_connectfd < 0) {
		ERR_EXIT("connect server fail");
	}

	// 发送并接收数据
	char buffer[BUF_SIZE] = "sad";
	int dataSize = strlen(buffer);
	
	NetPacket sendPacket;
	sendPacket.Header.wDataSize = dataSize + sizeof(NetPacketHeader);
	
	memcpy(sendPacket.Data, buffer, dataSize); // 数据拷贝

	for(int i = 0; i < 3; i++) {
		send(m_sockfd, &sendPacket, sendPacket.Header.wDataSize, 0);
	}
	printf("client send succ!!!\n");

	// 断开连接
	close(m_sockfd);
	printf("client socket closed!!!\n");

	return 0;
}

server

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<string.h>
#include<unistd.h>
#include<arpa/inet.h>
#include"protocol.h"
using namespace std;

#define EPOLL_SIZE 1023 // epoll监听客户端数
#define MAX_EVENTS 64
#define BUF_SIZE 2*NET_PACKET_DATA_SIZE
#define ERR_EXIT(m) \
	do \
	{	\
		perror(m);	\
		exit(EXIT_FAILURE);	\
	} while (0)

int main() {
	// 创建套接字
	int m_sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if(m_sockfd < 0) {
		ERR_EXIT("create socket fail");
	}

	// 初始化socket元素
	struct sockaddr_in server_addr;
	size_t server_len = sizeof(server_addr);
	memset(&server_addr, 0, server_len);

	server_addr.sin_family = AF_INET;
	//server_addr.sin_addr.s_addr = inet_addr("0.0.0.0");
	server_addr.sin_addr.s_addr = INADDR_ANY;
	server_addr.sin_port = htons(39002);

	// 绑定文件描述符和服务器的ip和端口号
	int m_bindfd = bind(m_sockfd, (struct sockaddr *)&server_addr, (socklen_t)server_len);
	if(m_bindfd < 0) {
		ERR_EXIT("bind ip and port fail");
	}

	// 进入监听状态，等待用户发起请求
	int m_listenfd = listen(m_sockfd, 20);
	if(m_listenfd < 0) {
		ERR_EXIT("listen client fail");
	}

	printf("client accept success\n");

	// 定义客户端的套接字
	struct sockaddr_in client_addr;
	socklen_t client_len = sizeof(client_addr);
	int m_connfd = accept(m_sockfd, (struct sockaddr*)&client_addr, &client_len);

	// 接收客户端数据，并响应
	char buffer[BUF_SIZE];
	memset(buffer, 0, sizeof(buffer)); // 重置缓冲区
	while(true){
		if(m_connfd < 0) {
			m_connfd = accept(m_sockfd, (struct sockaddr*)&client_addr, &client_len);
			printf("client accept success again!!!\n");
		}

		// 休眠10s才能有粘包现象出现
		sleep(10);

		int nRecvSize = 0; // 一次接收到的数据大小
		int sumRecvSize = 0; // 总共收到的数据大小
		int packetSize = 0; // 数据包长度

		bool disConn = false;

		// 先从缓冲中取出包头
		while(sumRecvSize != sizeof(NetPacketHeader)) {
			nRecvSize = recv(m_connfd, buffer + sumRecvSize, sizeof(NetPacketHeader) - sumRecvSize, 0);
			if(nRecvSize == 0) {
				close(m_connfd);
				m_connfd = -1;
				printf("client close connection!!!\n");
				disConn = true;
				break;
			}
			sumRecvSize += nRecvSize;
		}

		if(disConn) { // 已关闭连接
			continue;
		}

		NetPacketHeader *pHead = (NetPacketHeader*) buffer;
		packetSize = pHead -> wDataSize; // 客户端发送的数据包长度
		
		// 从缓冲中取出数据包体
		while(sumRecvSize != packetSize) {
			nRecvSize = recv(m_connfd, buffer + sumRecvSize, packetSize - sumRecvSize, 0);
			if(nRecvSize == 0) {
				close(m_connfd);
				m_connfd = -1;
				printf("client lose connection!!!\n");
				disConn = true;
				break;
			}else if(nRecvSize < 0) {
				ERR_EXIT("recv fail");
			}
			printf("server recv:%s, size:%d\n", buffer + sumRecvSize, nRecvSize);
			sumRecvSize += nRecvSize;
		}

		if(disConn) {
			continue;
		}
	}

	// 关闭套接字
	close(m_connfd);
	close(m_sockfd);

	printf("server socket closed!!!\n");

	return 0;
}

心跳检测

client

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<vector>
#include"protocol.h"
using namespace std;

#define BUF_SIZE 512
#define ERR_EXIT(m) \
	do \
	{	\
		perror(m);	\
		exit(EXIT_FAILURE);	\
	} while (0)

void* send_heart(void *arg) {
	printf("the heartbeat sending thread started.\n");
	struct CustomParam *param = (struct CustomParam*) arg;
	// int count = 0;
	while(true) {
		NetPacket sendPacket;
		sendPacket.Header.type = HEART;
		sendPacket.Header.wDataSize = sizeof(NetPacketHeader);
		send(param->fd, &sendPacket, sendPacket.Header.wDataSize, 0);
		sleep(3);
	}
}

int main() {
	// 创建套接字
	int m_sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if(m_sockfd < 0) {
		ERR_EXIT("create socket fail");
	}

	// 服务器的ip为本地，端口号
	struct sockaddr_in server_addr;
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
	server_addr.sin_port = htons(39002);

	// 向服务器发送连接请求
	int m_connectfd = connect(m_sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if(m_connectfd < 0) {
		ERR_EXIT("connect server fail");
	}

	struct CustomParam param;
	param.fd = m_sockfd;
	pthread_t id;
	int ret = ::pthread_create(&id, nullptr, send_heart, &param);
	if(ret != 0) {
		printf("create thread faild.\n");
	}
	ret = pthread_detach(id);
	if(ret != 0) {
		printf("failed to detach thread.\n");
	}

	// 发送并接收数据
	char buffer[BUF_SIZE];
	while(true){
		
		memset(buffer, 0, sizeof(buffer)); // 重置缓冲区

		// 发送并接收数据
		printf("client send:\n");
		scanf("%s", buffer);
		int dataSize = strlen(buffer); // 未必填满BUF_SIZE, strlen到\0结束
		
		NetPacket sendPacket;
		sendPacket.Header.type = OTHER;
		sendPacket.Header.wDataSize = dataSize + sizeof(NetPacketHeader);
		
		memcpy(sendPacket.Data, buffer, dataSize); // 数据拷贝

		send(m_sockfd, &sendPacket, sendPacket.Header.wDataSize, 0);
		// recv(m_sockfd, buffer, sizeof(buffer), 0);
		// printf("client recv:%s\n", buffer);
	}

	// 断开连接
	close(m_sockfd);
	printf("client socket closed!!!\n");

	return 0;
}

server

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<pthread.h>
// #include<string.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<vector>
// #include<map>
#include"protocol.h"
using namespace std;

#define HEART_COUNT 5
#define BUF_SIZE 512
#define ERR_EXIT(m) \
	do \
	{	\
		perror(m);	\
		exit(EXIT_FAILURE);	\
	} while (0)


// 心跳线程
void* heart_handler(void *arg) {
	printf("the heart-beat thread started\n");
	struct CustomParam *param = (struct CustomParam*) arg;
	while(true) {
		FDMAPIP::iterator it = param -> mmap -> begin();
		for(; it != param -> mmap -> end(); it++) {
			// 3s * 5 没有收到心跳包，判定客户端掉线
			if(it -> second.second == HEART_COUNT) {
				printf("The client %s has be offline.\n", it -> second.first.c_str());

				int fd = it -> first;
				close(fd); // 关闭该连接
				param -> mmap -> erase(it); // 从map中移除该记录
			} else if(it -> second.second < HEART_COUNT && it -> second.second >= 0) {
				it -> second.second += 1;
			}
		}
		sleep(3);
	}
}

int main() {
	// 创建套接字
	int m_sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if(m_sockfd < 0) {
		ERR_EXIT("create socket fail");
	}

	// 初始化socket元素
	struct sockaddr_in server_addr;
	size_t server_len = sizeof(server_addr);
	memset(&server_addr, 0, server_len);

	server_addr.sin_family = AF_INET;
	//server_addr.sin_addr.s_addr = inet_addr("0.0.0.0");
	server_addr.sin_addr.s_addr = INADDR_ANY;
	server_addr.sin_port = htons(39002);

	// 绑定文件描述符和服务器的ip和端口号
	int m_bindfd = ::bind(m_sockfd, (struct sockaddr *)&server_addr, (socklen_t)server_len); // 与functional头文件重复定义(std命名空间内)，socket.h定义的bind则在全局命名空间内
	if(m_bindfd < 0) {
		ERR_EXIT("bind ip and port fail");
	}

	// 进入监听状态，等待用户发起请求
	int m_listenfd = listen(m_sockfd, 20);
	if(m_listenfd < 0) {
		ERR_EXIT("listen client fail");
	}

	// 定义客户端的套接字
	struct sockaddr_in client_addr;
	socklen_t client_len = sizeof(client_addr);
	int m_connfd = accept(m_sockfd, (struct sockaddr*)&client_addr, &client_len);

	printf("client accept success\n");

	string ip(inet_ntoa(client_addr.sin_addr)); // 获取客户端IP

	// 记录连接的客户端fd -> <ip, count>
	FDMAPIP mmap;
	mmap.insert(make_pair(m_connfd, make_pair(ip, 0)));

	struct CustomParam param;
	param.mmap = &mmap;

	// 创建心跳检测线程
	pthread_t id;
	int ret = pthread_create(&id, nullptr, heart_handler, &param);
	if(ret != 0) {
		printf("can't create heart-beat thread.\n");
	}

	ret = pthread_detach(id);
	if(ret != 0) {
		printf("failed to detach thread.\n");
	}

	// 接收客户端数据，并响应
	char buffer[BUF_SIZE];
	while(true){
		if(m_connfd < 0) {
			m_connfd = accept(m_sockfd, (struct sockaddr*)&client_addr, &client_len);
			printf("client accept success again!!!\n");

			string ip(inet_ntoa(client_addr.sin_addr)); // 获取客户端IP

			// 记录连接的客户端fd -> <ip, count>
			// FDMAPIP mmap;
			mmap.insert(make_pair(m_connfd, make_pair(ip, 0)));

			struct CustomParam param;
			param.mmap = &mmap;

			// 创建心跳检测线程
			pthread_t id;
			int ret = pthread_create(&id, nullptr, heart_handler, &param);
			if(ret != 0) {
				printf("can't create heart-beat thread.\n");
			}

			ret = pthread_detach(id);
			if(ret != 0) {
				printf("failed to detach thread.\n");
			}
		}

		memset(buffer, 0, sizeof(buffer)); // 重置缓冲区
		int nRecvSize = 0; // 一次接收到的数据大小
		int sumRecvSize = 0; // 总共收到的数据大小
		int packetSize = 0; // 数据包长度
		Type type; // 数据包类型

		bool disConn = false;

		// 先从缓冲中取出包头
		while(sumRecvSize != sizeof(NetPacketHeader)) {
			nRecvSize = recv(m_connfd, buffer + sumRecvSize, sizeof(NetPacketHeader) - sumRecvSize, 0);
			if(nRecvSize == 0) {
				close(m_connfd);
				m_connfd = -1;
				printf("client close connection!!!\n");
				disConn = true;
				break;
			}
			sumRecvSize += nRecvSize;
		}

		if(disConn) { // 已关闭连接
			continue;
		}

		NetPacketHeader *pHead = (NetPacketHeader*) buffer;
		type = pHead -> type;
		packetSize = pHead -> wDataSize; // 客户端发送的数据包长度
		
		printf("header type:%d\n", pHead -> type);
		if(type == HEART) {
			mmap[m_connfd].second = 0;
			printf("receive heart beat from client.\n");
			continue;
		}

		// 从缓冲中取出数据包体
		while(sumRecvSize != packetSize) {
			nRecvSize = recv(m_connfd, buffer + sumRecvSize, packetSize - sumRecvSize, 0);
			if(nRecvSize == 0) {
				close(m_connfd);
				m_connfd = -1;
				printf("client lose connection!!!\n");
				disConn = true;
				break;
			}else if(nRecvSize < 0) {
				ERR_EXIT("recv fail");
			}
			printf("server recv:%s, size:%d\n", buffer + sumRecvSize, nRecvSize);
			sumRecvSize += nRecvSize;
		}

		if(disConn) {
			continue;
		}
	}

	// 关闭套接字
	close(m_connfd);
	close(m_sockfd);

	printf("server socket closed!!!\n");

	return 0;
}

protocol.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#ifndef _PROTOCOL_H
#define _PROTOCOL_H

#include<string>
#include<map>

#define NET_PACKET_DATA_SIZE 5000

typedef std::map<int, std::pair<std::string, int>> FDMAPIP; // socketFd， client name, 未接收到心跳的次数

enum Type {
	HEART = 1,
	OTHER = 2,
};

// 支线程传递的参数结构体
struct CustomParam {
	int fd; // 客户端用
	FDMAPIP *mmap; // 服务端用
};

// 网络数据包包头
struct NetPacketHeader{
	Type type;
	unsigned short wDataSize; // 数据包大小，包含包头的长度和数据长度
};

// 网络数据包体
struct NetPacket{
	NetPacketHeader Header;	// 包头
	unsigned char Data[NET_PACKET_DATA_SIZE]; // 数据
};



#endif

git仓库

https://github.com/TechCodingLearning/cplus_socket

参考资料

  1. https://zhuanlan.zhihu.com/p/352017906
  2. https://zhuanlan.zhihu.com/p/352020368
  3. https://zhuanlan.zhihu.com/p/352069786
  4. https://zhuanlan.zhihu.com/p/637842344
  5. https://zhuanlan.zhihu.com/p/637912377
  6. https://zhuanlan.zhihu.com/p/638886350

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

做一个安静细微的人，<br> 于角落里自在开放，<br> 默默悦人，<br> 却始终不引起过分热闹的关注，<br> 保有独立而随意的品格，<br> 这就很好。<br><br> Stick to what you insist on,<br> believe what you believe!<br> Life hastily for decades,<br> do what I can!