Bootstrap

网络 TCP协议(C++代码 通过tcp协议实现客户端与服务端之间的通信)_c++ tcp

img
img

既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上C C++开发知识点,真正体系化!

由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新

如果你需要这些资料,可以戳这里获取

客户端操作流程:
  1. 创建套接字:在内核中创建socket结构体,关联进程与网卡之间的联系
  2. 为套接字绑定地址信息:描述在内核中创建的socket结构体的源端地址信息;发送的数据中源端地址信息就是绑定的地址信息(不推荐主动绑定地址,降低端口冲突的概率,从而确保数据发送的安全性)
  3. 向服务端发起连接请求:当服务端处于监听状态时就可以进行连接;但是当服务端不处于监听状态,请求会丢失
  4. 收发数据:被服务端特定套接字服务
  5. 关闭套接字:释放资源

举一个足疗店的例子来帮助你理解服务端与客户端之间的通信
在这里插入图片描述
服务端接口信息
1、创建套接字int socket(int domain, int type, int protocol) 参数内容(domian:地址域(本地通信-AF_LOCAL、IPv4-AF_INET、IPv6-AF_INET6等)确定本次socket通信使用哪种协议版本的地址结构,不同的协议版本有不同的地址结构;type:套接字类型(流式套接字-SOCK_STREAM、数据报套接字-SOCK_DGRAM等);protocol:协议类型(TCP-IPPROTO_TCP、UDP-IPPROTO_UDP) ,默认为0-流式默认TCP,数据报默认UDP)
返回值:文件描述符-非负整数, 套接字所有其他接口的操作句柄,失败返回-1

2、为套接字绑定地址信息int bind(int sockfd, struct sockaddr *addr, socklen_t len)参数内容(sockfd:创建套接字返回的操作句柄;addr:要绑定的地址信息;len:要绑定的地址信息长度)

3、开始监听listen(int sockfd, int backlog) 参数内容(sockfd:将sockfd的套接字设置为监听状态,并且监听状态后可以开始接收客户端连接请求;backlog:同一时间的并发连接数,决定同一时间最多接收多少个客户端的连接请求<内核中可创建套接字数量是有限的,防止存在恶意请求导致资源耗尽>)

4、获取新建连接,从已完成连接队列中取出一个socket,并且返回这个socket的描述符操作句柄int accept(int sockfd, struct sockaddr* cli_addr, socklen_t *len)参数内容(sockfd:表示获取哪个tcp服务端套接字的新建连接;cli_addr:这个新建的套接字对应的客户端地址信息;len:地址信息长度) 返回值:新建的socket套接字的描述符,也就是外部进程中对该套接字的操作句柄

5、收发数据。在tcp套接字中已经标示了五元组,因此接收数据时不需要获取对方地址信息,发送数据时也不需要指定对方的地址信息。接收:ssize_t recv(int sockfd, char *buf, int len, int flag) 返回值:成功返回接收数据的长度,等于0表示断开连接,小于0表示出错。发送:ssize_t send(int sockfd, char *data, int len, int flag) :返回值:成功返回发送数据的长度,等于0表示断开连接,小于0表示出错。若断开连接触发异常信号SIGPIPE

6、关闭套接字int close(fd)

客户端接口信息:将服务端的2、3、4步去掉,合成一步
1、创建套接字int socket(int domain, int type, int protocol)
2、向服务端发起连接请求int connect(int sockfd, struct sockaddr *srv_addr, int len) 参数内容(sockfd:哪个服务端发送请求连接;src_addr:服务端地址信息,给该服务端发送请求)这个connect接口也会在sockfd客户端的套接字socket中描述对端的地址信息
3、收发数据。接收:ssize_t recv(int sockfd, char *buf, int len, int flag) 发送:ssize_t send(int sockfd, char *data, int len, int flag)
4、关闭套接字int close(fd)

代码实现
创建一个类用于封装各端的操作
tcpsocket.hpp

//tcpsocket.hpp
#include <cstdio>
#include <unistd.h>
#include <string>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>
using namespace std;

//该值表示用一时间能够接收多少客户端连接
//并非指整个通信最多接收多少客户端连接
#define MAX\_LISTEN 5
#define CHECK\_RET(q) if((q) == false){return -1;}
class TcpSocket
{
	public:
		TcpSocket()
			:\_sockfd(-1)
		{}
		bool Socket()
		{
			_sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
			if (_sockfd < 0)
			{
				perror("socket error");
				return false;
			}
			return true;
		}
		bool Bind(const 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 = MAX_LISTEN)
		{
			int ret = listen(_sockfd, backlog);
			if (ret < 0)
			{
				perror("listen error");
				return false;
			}
			return true;
		}
		bool Accept(TcpSocket \*new_sock, string \*ip = NULL, uint16_t \*port = NULL)
		{
			struct sockaddr_in addr;
			socklen_t len = sizeof(struct sockaddr_in);
			int new_fd = accept(_sockfd, (struct sockaddr\*)&addr, &len);
			cout << "dsdsdds";
			if (new_fd < 0)
			{
				perror("accept error");
				return false;
			}
			new_sock->_sockfd = new_fd;
			if (ip != NULL)
			{
				\*ip = inet\_ntoa(addr.sin_addr);
			}
			if (port != NULL)
			{
				\*port = ntohs(addr.sin_port);
			}
			return true;
		}
		bool Recv(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)//默认阻塞,没有数据就会等待,返回0表示连接断开
			{
				printf("connection broken\n");
				return false;
			}
			buf->assign(tmp, ret);
			return true;
		}
		bool Send(const string &data)
		{
			int ret = send(_sockfd, data.c\_str(), data.size(), 0);
			if (ret < 0)
			{
				perror("send error");
				return false;
			}
			return true;
		}
		bool Close()
		{
			if (_sockfd > 0)
			{
				close(_sockfd);
				_sockfd = -1;
			}
			return true;
		}
		bool Connect(const 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;
		}
	private:
		int _sockfd;
};


tcp_srv.cpp

//tcp\_srv.cpp
#include <cstdio>
#include <iostream>
#include "tcpsocket.hpp"

using namespace std;

int main(int argc, char \*argv[])
{
	if (argc != 3)
	{
		cout << "Usage:./tcp\_srv ip port" << endl;
		return -1;
	}
	string ip = argv[1];
	uint16_t port = stoi(argv[2]);

	TcpSocket lst_sock;
	//穿件套接字
	CHECK\_RET(lst_sock.Socket());
	//为套接字绑定地址信息
	CHECK\_RET(lst_sock.Bind(ip, port));
	//开始监听
	CHECK\_RET(lst_sock.Listen());
	while (1)
	{
		TcpSocket new_sock;
		//获取连接
		bool ret = lst_sock.Accept(&new_sock);
		if (ret == false)
		{
			continue;//服务端不能因为获取一个新建套接字失败就退出
		}
		string buf;
		new_sock.Recv(&buf);
		cout << "client say: " << buf << endl;

		buf.clear();
		cout << "server say: ";
		cin >> buf;
		new_sock.Send(buf);
	}
	lst_sock.Close();
	return 0;
}


tcp_cli.cpp

//tcp\_cli.cpp
#include <iostream>
#include <string>
#include "tcpsocket.hpp"
using namespace std;

int main(int argc, char \*argv[])
{
	if (argc != 3)
	{
		cout << "Usage: ./tcp\_cli ip port" << endl;
		return -1;
	}
	string srv_ip = argv[1];
	uint16_t srv_port = stoi(argv[2]);

	TcpSocket sock;
	CHECK\_RET(sock.Socket());
	CHECK\_RET(sock.Connect(srv_ip, srv_port));
	while (1)
	{
		string buf;
		cout << "client say: ";
		cin >> buf;
		sock.Send(buf);

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

makefile

all:tcp_srv tcp_cli
  tcp_srv:tcp_srv.cpp
      g++ -std=c++11 $^ -o $@
  tcp_cli:tcp_cli.cpp
      g++ -std=c++11 $^ -o $@


查看网卡信息
在这里插入图片描述
先运行服务端,等待新的连接。
在这里插入图片描述
运行客户端,并发送消息
在这里插入图片描述
服务端收到消息并回复
在这里插入图片描述
客户端收到消息并回复
在这里插入图片描述
但是此时客户端并没有接收到客户端发来的消息,一直停留在上一次发送消息完后的样子
在这里插入图片描述
简单分析服务端while循环,while循环中第一步获取连接时阻塞等待的,当一个新的客户端来是会为它创建一个新的套接字与它通信。客户端第一次发送消息,服务端走到第二步接收消息,再走到第三步发送消息。发送完消息第一次循环就结束了,又重新到了第一步等待获取连接。此时新创建的套接字丢失,所以此时客户端再给服务端发送消息,就无法接收。
在这里插入图片描述
这时候我们就得引入多线程或者多进程来完成这项任务。在获取到一个新的连接时,就启动一个新的执行流,让这个新的执行流去与该客户端进行通信。这样子做的好处是:没有了因为新连接到来的阻塞,就不会影响与客户端之间的通信;与客户端通信时的阻塞,并不会影响获取新的连接

多进程使用TCP实现通信
只要修改服务端
tcp_process.cpp

//tcp\_process.cpp
#include <cstdio>
#include <iostream>
#include <signal.h>
#include <sys/wait.h>
#include "tcpsocket.hpp"

using namespace std;

void sigcb(int no)
{
	while (waitpid(-1, NULL, WNOHANG) > 0);
}

int main(int argc, char \*argv[])
{
	if (argc != 3)
	{
		cout << "Usage:./tcp\_srv ip port" << endl;
		return -1;
	}
	//子进程退出处理方式
	signal(SIGCHLD, sigcb);
	string ip = argv[1];
	uint16_t port = stoi(argv[2]);

	TcpSocket lst_sock;
	//穿件套接字
	CHECK\_RET(lst_sock.Socket());
	//为套接字绑定地址信息
	CHECK\_RET(lst_sock.Bind(ip, port));
	//开始监听
	CHECK\_RET(lst_sock.Listen());
	while (1)
	{


![img](https://img-blog.csdnimg.cn/img_convert/70001dd4bc621d8b7729b710692826e8.png)
![img](https://img-blog.csdnimg.cn/img_convert/5ec7f7e4cd06ed22e450675f9c4107c5.png)

**既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上C C++开发知识点,真正体系化!**

**由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新**

**[如果你需要这些资料,可以戳这里获取](https://bbs.csdn.net/topics/618668825)**

ip, port));
	//开始监听
	CHECK\_RET(lst_sock.Listen());
	while (1)
	{


[外链图片转存中...(img-87gyYD3A-1715886898346)]
[外链图片转存中...(img-mmrbMLCd-1715886898346)]

**既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上C C++开发知识点,真正体系化!**

**由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新**

**[如果你需要这些资料,可以戳这里获取](https://bbs.csdn.net/topics/618668825)**

悦读

道可道,非常道;名可名,非常名。 无名,天地之始,有名,万物之母。 故常无欲,以观其妙,常有欲,以观其徼。 此两者,同出而异名,同谓之玄,玄之又玄,众妙之门。

;