Linux网络套接字编程(2)

TCP传输

TCP的三次握手

网络1

图解为TCP协议的传输过程。

客户端操作 服务端操作
1、创建套接字 1、创建套接字
2、向服务端发起连接 2、绑定地址信息
3、发送数据 3、监听(若有新的客户端,新建socket)
4、接收数据 4、接收已经连接成功的socket
5、关闭套接字

TCP传输-socket编程

通过C++实现一个类来封装tcp协议

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
//tcpsocket.hpp
#include <string>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define CHECK_RET(q) if((q) == false){return -1;}

class TcpSocket
{
public:
TcpSocket() : _sockfd(-1){
}
void SetSockFd(int fd){
_sockfd = fd;
}
bool Socket() {
_sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (_sockfd < 0) {
perror("socket error");
return false;
}
return true;
}
bool Bind(std::string &ip, uint16_t port){
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = inet_addr(ip.c_str());

socklen_t len = sizeof(struct sockaddr_in);
int ret = bind(_sockfd, (struct sockaddr*)&addr, len);
if (ret < 0) {
perror("bind error");
return false;
}
return true;
}
bool Listen(int backlog = 10) {
//int listen(int sockfd, int backlog);
//backlog:最大并发连接数--内核中已完成连接队列的最大节点数
int ret = listen(_sockfd, backlog);
if (ret < 0) {
perror("listen error");
return false;
}
return true;
}
bool Connect(std::string &ip, uint16_t port) {
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = inet_addr(ip.c_str());
socklen_t len = sizeof(struct sockaddr_in);

int ret = connect(_sockfd, (struct sockaddr*)&addr, len);
if (ret < 0) {
perror("connect error");
return false;
}
return true;
}
bool Accept(TcpSocket &csock, struct sockaddr_in *addr = NULL){
struct sockaddr_in _addr;
socklen_t len = sizeof(struct sockaddr_in);
int newfd = accept(_sockfd, (struct sockaddr*)&_addr, &len);
if (newfd < 0) {
perror("accept error");
return false;
}
if (addr != NULL) {
memcpy(addr, &_addr, len);
}
csock.SetSockFd(newfd);
//_sockfd--仅用于接收新客户端连接请求
//newfd----专门用于与客户端进行通信
return true;
}
bool Recv(std::string &buf) {
char tmp[4096] = {0};
int ret = recv(_sockfd, tmp, 4096, 0);
if (ret < 0) {
perror("recv error");
return false;
}else if (ret == 0) {
printf("peer shutdown\n");
return false;
}
buf.assign(tmp, ret);
return true;
}
bool Send(std::string &buf) {
int ret = send(_sockfd, buf.c_str(), buf.size(), 0);
if (ret < 0) {
perror("send error");
return false;
}
return true;
}
bool Close() {
close(_sockfd);
_sockfd = -1;
}
private:
int _sockfd;
};

tcp传输客户端

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
#include "tcpsocket.hpp"

int main(int argc, char *argv[])
{
if (argc != 3 ) {
std::cout<<"./tcp_cli ip port\n";
return -1;
}
std::string ip = argv[1];
uint16_t port = atoi(argv[2]);

TcpSocket sock;
CHECK_RET(sock.Socket());
CHECK_RET(sock.Connect(ip, port));

while(1) {
std::string buf;
std::cout<<"client say:";
fflush(stdout);
std::cin>>buf;
sock.Send(buf);

buf.clear();
sock.Recv(buf);
std::cout<<"server say:"<<buf<<std::endl;
}
sock.Close();
return 0;
}

tcp传输服务端

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
#include "tcpsocket.hpp"

int main(int argc, char *argv[])
{
if (argc != 3) {
printf("./tcp_srv ip port\n");
return -1;
}
std::string ip = argv[1];
uint16_t port = atoi(argv[2]);

TcpSocket sock;
CHECK_RET(sock.Socket());
CHECK_RET(sock.Bind(ip, port));
CHECK_RET(sock.Listen());

while(1) {
TcpSocket clisock;
struct sockaddr_in cliaddr;
//accept是阻塞获取已经完成的连接
if (sock.Accept(clisock, &cliaddr) == false) {
continue;
}
printf("new connect client:%s:%d\n",
inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port));
std::string buf;
clisock.Recv(buf);
printf("client say:%s\n", buf.c_str());

buf.clear();
std::cout<<"server say:";
fflush(stdout);
std::cin>>buf;
clisock.Send(buf);
}
sock.Close();
return 0;
}

网络

运行截图如上

TCP的传输运行结果与UDP的传输运行结果不同

这是因为在UDP的传输无连接,不可靠,面向数据报

但是TCP的传输不同是建立连接,可靠传输,面向字节流

所以基本的tcp服务端只能与一个客户端通信一次,无法实现同时与多个客户端多次通信

如何快速判断连接是否已经断开

tcp的连接管理中,内建有保活机制。当长时间没有数据来往的时候,每隔一段时间都会向对方发送一个保活探测包,要求对方回复,当多次发送保活探测包都没有响应,则认为连接断开。

若连接断开,则recv会返回0,send会触发异常SIGPIPE(导致进程退出)。recv返回0不是代表没有接收数据的意思,而是说明连接已经断开。

在TCP连接过程中,因为面向字节流,有可能接收到半条数据,因此一定要对返回值进行判断,判断数据是否已经完全接收或者完全发送。

多进程版本tcp服务端

通过使用多进程来完成多个客户端的请求处理

将之前的通用版本改为多线程版本即可

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
#include <signal.h>
#include <sys/wait.h>
#include "tcpsocket.hpp"

void sigcb(int no){
while (waitpid(-1, NULL, WNOHANG) > 0);
}
int main(int argc, char *argv[])
{
if (argc != 3) {
printf("./tcp_srv ip port\n");
return -1;
}

signal(SIGCHLD, sigcb);
std::string ip = argv[1];
uint16_t port = atoi(argv[2]);

TcpSocket sock;
CHECK_RET(sock.Socket());
CHECK_RET(sock.Bind(ip, port));
CHECK_RET(sock.Listen());

while(1) {
TcpSocket clisock;
struct sockaddr_in cliaddr;
//accept是阻塞获取已经完成的连接
if (sock.Accept(clisock, &cliaddr) == false) {
continue;
}
printf("new connect client:%s:%d\n",
inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port));

int pid = fork();
if (pid == 0) {
while(1){
std::string buf;
clisock.Recv(buf);
printf("client say:%s\n", buf.c_str());

buf.clear();
std::cout<<"server say:";
fflush(stdout);
std::cin>>buf;
clisock.Send(buf);
}
}
clisock.Close();
}
sock.Close();
return 0;
}

网络2

先进行多个客户端连接,在左上角的服务端可以看到有三个新的客户端进行了连接成功

网络3

这时候相继发送消息,服务端的回复顺序是根据接收客户端发送数据的顺序进行回复的

哪怕有其他客户端抢先回答了,服务端还是按照发送数据的顺序依次给客户端进行发送数据

多线程版本tcp服务端

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 <pthread.h>
#include "tcpsocket.hpp"

void *thr_start(void *arg){
TcpSocket *sock = (TcpSocket*)arg;
while(1) {
std::string buf;
sock->Recv(buf);
printf("client say:%s\n", buf.c_str());

buf.clear();
std::cout<<"server say:";
fflush(stdout);
std::cin>>buf;
sock->Send(buf);
}
sock->Close();
delete sock;
return NULL;
}
int main(int argc, char *argv[])
{
if (argc != 3) {
printf("./tcp_srv ip port\n");
return -1;
}
std::string ip = argv[1];
uint16_t port = atoi(argv[2]);

TcpSocket sock;
CHECK_RET(sock.Socket());
CHECK_RET(sock.Bind(ip, port));
CHECK_RET(sock.Listen());

while(1) {
TcpSocket *clisock = new TcpSocket();
struct sockaddr_in cliaddr;
//accept是阻塞获取已经完成的连接
if (sock.Accept(*clisock, &cliaddr) == false) {
continue;
}
printf("new connect client:%s:%d\n",
inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port));

pthread_t tid;
pthread_create(&tid, NULL, thr_start, (void*)clisock);
pthread_detach(tid);
//多线程中 ,主线程不能关闭socket,因为线程之间共享文件描述符表
//如果在主线程中关闭了socket,其它线程中的这个描述符也就关闭了
}
sock.Close();
return 0;
}

线程版本的服务端与进程版本的服务端操作大同小异,差距就是进程与线程的创建方式不同,在方式上可能有区别。能了解这两个知识就能掌握。

-------------The End-------------