# 套接字通信

设计者开发的 接口 ，以便应用程序调用该通信接口进行 通信

# 字节序

字节的顺机序，大于一个字节类型的数据在内存中的存放顺序。

Little-Endian 小端模式：数据的 低 位字节存在 低位 ，PC 机默认低位
Big-Endian ：大端模式 (网络字节序) 数据的 低位 字节存储到 高地 址位，套接字 通信 中操作的数据都是 大端存储 ，包括: 接受/发送数据，IP地址，端口

# 字节转换函数

	#include <arpa/inet.h>
	// 将一个短整型 short 从主机字节序 -> 网络字节序
	uint16_t htons(uint16_t hostshort)
	// 整型
	uint32_t htonl(uint32_t hostlong)
	// 将一个短整型 short 从网络字节序 -> 主机字节序
	uint16_t ntohs(uint16_t netshort)
	// 将一个整型从网络字节序 -> 主机字节序

# `IP` 地址转换

	// 将主机小端字节序转换为网络字节序打断
	int inet_pton(int af,const char src,void dst);
	//af: 地址族 (IP 地址的家族包括 IPV4,IPV6)
	// * AF_INET : IPV4
	// * AF_INET6 :IPV6
	//src 传入参数 ip 地址
	//dst 传出参数
	// 函数返回值：成功返回 0，失败返回 - 1
	// 将大端的整形数，转换为小端的点分十进制的 IP 地址
	#include <arpa/inet.h>
	const char inet_ntop(int af,const void src,char *dst,socklen_t size);
	// 上同
	//size : 传出参数 dst 最多存储多少个字节
	// 成功返回取出转换得到的 IP 字符串，失败 NULL

# `sockaddr` 数据结构

	struct sockaddr {
	sa_family_t sa_family; // 地址族协议，ipv4
	char sa_data[14]; // 端口 (2 字节) + IP 地址 (4 字节) + 填充 (8 字节)
	}
	// sizeof(struct sockaddr) == sizeof(struct sockaddr_in)
	struct sockaddr_in
	{
	sa_family_t sin_family; /* 地址族协议: AF_INET */
	in_port_t sin_port; /* 端口，2 字节 -> 大端 */
	struct in_addr sin_addr; /* IP 地址，4 字节 -> 大端 */
	/* 填充 8 字节 */
	unsigned char sin_zero[sizeof (struct sockaddr) - sizeof(sin_family) -
	sizeof (in_port_t) - sizeof (struct in_addr)];
	};

# 套接字函数

# `socket` 套接字

	#include <arpa/inet.h>
	// 创建一个套接字
	int socket(int domain,int type,int protocol);
	// Domains 地址族协议，上同
	//type:
	// SOCK_STREAM: 流式传输协议，默认使用 TCP
	// SOCK_DGRAM: 报文传输协议，默认使用 UDP
	// protecol: 一般为 0

	// 返回值；成功返回套接字通信的文件描述符，失败返回 -1

# `bind` 绑定

	// 将文件描述符和本地的 IP 与端口进行绑定
	int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
	//sockfd : 监听的文件描述符，socket 的返回值
	//addr ：传入参数 IP 和端口数据结构
	//addrlen: 参数 addr 指向的内存大小 sizeof (struct sockaddr)
	// 返回值：成功返回 0 失败返回 - 1

# `listen` 监听

	// 给监听的套接字设置监听
	int listen(int sockfd, int backlog);
	//fd 文件描述符，socket 的返回值
	//backlog：同时能处理的最大连接请求，最大值 128
	// 成功返回 0 失败返回 - 1

# `accept` 接受

阻塞函数，在没有新的客户端连接请求的时候，该函数阻塞，返回一个文件描述符，基于此文件描述符和客户端通信

	// 等待并接受客户端的连接请求，建立新的连接，会得到一个新的文件描述符 (通信的)
	int accept(int sockfd, struct sockaddr addr, socklen_t addrlen);
	//sockfd : 监听的文件描述符
	//addr 传出参数 IP 和端口
	//addrlen :addr 指向内存大小
	// 失败返回 - 1

# 接受数据

如果连接没有断开，接收端接受不到数据，接受数据的函数阻塞等待。数据到达后解除阻塞，开始接受数据，当发送端断开连接，接收端无法接收到任何数据，函数直接返回 0

	// 接收数据
	ssize_t read(int sockfd, void *buf, size_t size);
	ssize_t recv(int sockfd, void *buf, size_t size, int flags);
	//fd accept 的返回文件描述符
	//buf 有效内存，存储接受的数据
	//size 参数 buf 指向的内存容量
	//flags 一般为 0
	// 返回值：大于 0 实际接受的字节数等于 0 对方断开了连接，-1 接受数据失败

# 发送数据

	// 发送数据的函数
	ssize_t write(int fd, const void *buf, size_t len);
	ssize_t send(int fd, const void *buf, size_t len, int flags);
	//buf 传入的字符串，
	// 返回值：大于 0，实际发送的字节数，和参数 len 是相等
	//-1 发送数据失败了

# `connect`

	// 成功连接服务器之后，客户端会自动随机绑定一个端口
	// 服务器端调用 accept () 的函数，客户端调用 connect 连接
	int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
	//sockfd 文件描述符，调用 socket 得到
	// 连接成功 0 失败 - 1

# `TCP Linux` 通信

TCP 协议是一个安全的，面向连接的，流式传输协议。在客户端调用 connect 函数，完成三次握手，close 函数完成四次挥手。

# `三次握手`

三次握手

# `四次挥手`

四次挥手

# `socket` 通信

TCP通信流程

# `client.c`

	#include <stdio.h>
	#include <sys/types.h>
	#include <sys/socket.h>
	#include <arpa/inet.h>
	#include <netinet/in.h>
	#include <unistd.h>
	#include <stdlib.h>

	#define PORT_ID 8800
	#define SIZE 100

	//./client IP : ./client 192.168.0.10
	int main(int argc, char *argv[]) // 在运行时需要输入参数，即 IP 地址
	{
	int sockfd;
	struct sockaddr_in server_addr;
	char buf[SIZE];

	if(argc < 2)
	{
	printf("Usage: ./client [server IP address]\n");
	exit(1);
	}

	//1.socket () 建立套接字
	sockfd = socket(AF_INET, SOCK_STREAM, 0);

	//2.connect()
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(PORT_ID); // 将端口转化为大端网络通信模式
	//inet_addr 将一个十进制的数转化为二进制数用于 IPV4 的 IP 转换
	server_addr.sin_addr.s_addr = inet_addr(argv[1]);
	// 间接 IP 和端口
	connect(sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr));

	// 接受数据存入 buf 缓冲当中
	int re = recv(sockfd, buf, SIZE, 0);
	if(re == 0)
	{
	printf("服务器断开了连接\n");
	}
	else if(re < -1)
	{
	printf("接受数据失败\n");
	}
	printf("Client receive from server: %s\n", buf);
	sleep(1);



	close(sockfd);

	return 0;
	}

# `server.c`

	#include <stdio.h>
	#include <sys/types.h>
	#include <sys/socket.h>
	#include <arpa/inet.h>
	#include <netinet/in.h>
	#include <unistd.h>

	// 设置的端口号
	#define PORT_ID 8800
	// 设置发送文件的大小
	#define SIZE 100

	int main(void)
	{
	int sockfd, client_sockfd;
	struct sockaddr_in my_addr, client_addr; // 定义结构体用户存储 IP 和端口号
	int addr_len;
	char welcome[SIZE] = "Welcome to connect to the sever!";

	//1.socket () 创建监听的套接字 AF_INET IPV4 SOCK_STREAM TCP 通信
	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if(sockfd == -1)
	{
	printf("套接字创建失败");
	}
	//2.bind()
	my_addr.sin_family = AF_INET;
	my_addr.sin_port = htons(PORT_ID); // 将端口号整型转换为网络字节序打断存储
	my_addr.sin_addr.s_addr = INADDR_ANY; // 宏值，绑定任意端口号
	// 绑定套接字与端口 IP
	int b = bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr));
	if(b == -1)
	{
	printf("套接字与IP绑定失败");
	}
	//3.listen () 建立连接，给佳宁的套接字设置最大连接请求
	int l = listen(sockfd, 10);
	if(l == -1)
	{
	printf("套接字设置监听失败");
	}
	addr_len = sizeof(struct sockaddr);

	while(1)
	{
	printf("Server is waiting for client to connect:\n");
	//4.accept () 阻塞函数，等待客户端连接
	client_sockfd = accept(sockfd, (struct sockaddr *)&client_addr, &addr_len);

	printf("Client IP address = %s\n", inet_ntoa(client_addr.sin_addr));
	//5.send()
	int sed = send(client_sockfd, welcome, SIZE, 0);
	if(sed > 0)
	{
	printf("发送了%d字节的数据",sed);
	}
	else if(sed == 0)
	{
	printf("客户端断开了连接");
	}
	else if(sed == -1)
	{
	printf("发送数据失败");
	}
	printf("Disconnect the client request.\n");
	//6.close()
	close(client_sockfd);
	}
	// 关闭套接字
	close(sockfd);

	return 0;
	}

套接字通信

# `TCP流量控制`

流量控制可以根据接收端的实际接受能力，接收端主机向发送端主机通知自己可以接受数据的大小，于是发送端发送不会超过该大小的数据，
TCP 首部，专门设置一个字段来通知窗口大小，当接收端的缓冲区面临数据溢出时，窗口的大小值也随之发生改变，设置一个更小的值通知发送端，从而控制数据的发送量，从而达到流量控制的目录 -- 滑动窗口

# `TCP半关闭`

TCP 连接只有一方发送了 FIN 请求连接，处于半关闭状态，数据仍可以单向通信。套接字本身时双向通信

服务器调用了 close 函数，不能发送数据，只能接受数据
客户端没有调用 close 函数，可以发送数据，但是不能接受数据

	#include <sys/socket.h>
	// 可以由选择的关闭读 / 写，close 只能关闭写操作
	int shutdown(int sockfd,int how);
	//sockfd 要操作的文件描述符
	// how
	//SHUT_RD: 关闭文件描述符对应的读操作
	//SHUT_WR: 关闭文件描述符对应的写操作
	//SHUT_RDWR: 关闭文件描述符对应的读写操作
	// 返回值：函数调用成功返回 0，失败返回 - 1

# `端口复用`

服务器进程主动断开连接，最后状态编程 TIME_WAIT 状态，这个进程会等待 2msl (1 分钟左右) 才会退出，如该进程不退出，其绑定的端口就不会释放。

	// 设置端口复用多功能函数
	int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);
	//sockfd 用于监听的文件描述符
	//level 设置端口复用需要使用 SOL_SOCKET 宏
	//optname 设置属性皆可端口复用
	//optval 设置去除端口复用属性还是端口复用属性，实际应该使用 int 型变量 0 不设置，1 设置
	//optlen: optval 指针指向的内存大小 sizeof (int)
	// 在绑定之前设置端口复用
	// 创建监听的套接字
	int lfd = socket(AF_INET, SOCK_STREAM, 0);
	if(lfd == -1)
	{
	perror("socket error");
	exit(1);
	}

	// 绑定
	struct sockaddr_in serv_addr;
	memset(&serv_addr, 0, sizeof(serv_addr));
	serv_addr.sin_family = AF_INET;
	serv_addr.sin_port = htons(9999);
	serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); // 本地多有的ＩＰ
	// 127.0.0.1
	// inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr.s_addr);

	// 设置端口复用
	int opt = 1;
	setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

	// 绑定端口
	int ret = bind(lfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));

# TCP 数据 `粘包` 处理

在发送数据块之前，在数据块最前边添加一个固定大小的数据头。数据头存储当前的总字节数，接收到先接受数据头，然后根据数据头结构对应字节大小的数据块

# 发送端实现

发送 N 数据长度申请 N+4 块大小内存
将待发送数据总长度写入前四个字节中 (需要转为大端 网络字节序 )
待发送的数据拷贝到包头后边的地址空间，将完整数据包发送出去
释放申请的 堆空间

	// 发送指定的字节数
	//fd: 套接字的文件描述符
	//msg: 待发送的原始数据
	//size : 待发送的原始数据总字节数
	int writen(int fd, const char* msg, int size)
	{
	//buf 数据缓存区
	const char* buf = msg;
	// 原始数据大小
	int count = size;
	while (count > 0)
	{
	//len 返回已经发送的数据长度
	int len = send(fd, buf, count, 0);
	if (len == -1)
	{
	close(fd);
	return -1; // 发送失败
	}
	else if (len == 0)
	{
	continue;
	}
	// 缓冲区地址后移
	buf += len;
	// 待发送长度减去已经发送的
	count -= len;
	}
	return size;
	}
	// 发送带有包头的数据包
	int sendMsg(int cfd, char* msg, int len)
	{
	if(msg == NULL \|\| len <= 0 \|\| cfd <=0)
	{ // 如果发送缓存区，或长度，或套接字为空失败

	return -1;
	}
	// 申请内存空间：数据长度 + 包头 4 字节 (存储数据长度)
	char* data = (char*)malloc(len+4);
	int bigLen = htonl(len); // 将数据包长度转换为网络字节序
	memcpy(data, &bigLen, 4); // 把 bigLen 写入 data 当中
	memcpy(data+4, msg, len); // 把 msg 数据写入，data+4 指针后移 4 位
	// 发送数据
	int ret = writen(cfd, data, len+4); // 将数据发送过去
	// 释放内存
	free(data);
	return ret; // 返回发送的字节数
	}

# 接收端实现

将接受的 4字节 数据，从网络字节序转换为主机字节序
根据长度申请堆内存，用于存储 待接收的数据
根据得到的数据长度固定数目保存到堆内存中
处理 接受的数据
释放存储数据的 堆内存

	// 套接字，缓存区，大小
	int readn(int fd, char* buf, int size)
	{
	char* pt = buf;
	int count = size;
	// 直到读完所有数据
	while (count > 0)
	{
	// 接受数据
	int len = recv(fd, pt, count, 0);
	if (len == -1)
	{
	return -1;
	}
	else if (len == 0)
	{
	return size - count;
	}
	pt += len;
	count -= len;
	}
	return size; // 返回接受的字节数
	}
	// 接受带数据头的数据包
	int recvMsg(int cfd, char** msg)
	{
	// 接收数据
	// 1. 读数据头
	int len = 0;
	// 先读 4 个字节，读取其数据长度
	readn(cfd, (char*)&len, 4);
	len = ntohl(len); // 大端转换为小端
	printf("数据块大小: %d\n", len);

	// 根据读出的长度分配内存，+1 -> 这个字节存储 \0
	char buf = (char)malloc(len+1);
	// 根据指定大小读取数据
	int ret = readn(cfd, buf, len);
	if(ret != len)
	{
	close(cfd);
	free(buf);
	return -1;
	}
	buf[len] = '\0'; // 字符串结尾
	*msg = buf;
	return ret;
	}

# C++ 封装 TCP

C++封装TCP

# TcpSocket.h

	#include <string>
	#include <unistd.h>
	#include <sys/socket.h>
	#include <string.h>
	#include <arpa/inet.h>
	#include <stdio.h>
	#include <iostream>
	using namespace std;
	class TcpSocket
	{
	public:
	TcpSocket();
	TcpSocket(int socket);
	~TcpSocket();
	int connectToHost(string ip, unsigned short port);
	int sendMsg(string msg);
	string recvMsg();

	private:
	int readn(char* buf, int size);
	int writen(const char* msg, int size);

	private:
	int m_fd; // 通信的套接字
	};

# TcpSocket.cpp

	#include "TcpSocket.h"

	TcpSocket::TcpSocket()
	{
	m_fd = socket(AF_INET, SOCK_STREAM, 0);// 创建 IPV4 的套接字
	}

	TcpSocket::TcpSocket(int socket)
	{
	m_fd = socket;
	}

	TcpSocket::~TcpSocket()
	{
	if (m_fd > 0)
	{
	close(m_fd);
	}
	}

	int TcpSocket::connectToHost(string ip, unsigned short port)
	{
	// 连接服务器 IP port
	struct sockaddr_in saddr;
	saddr.sin_family = AF_INET;
	saddr.sin_port = htons(port);
	inet_pton(AF_INET, ip.data(), &saddr.sin_addr.s_addr);
	int ret = connect(m_fd, (struct sockaddr*)&saddr, sizeof(saddr));
	if (ret == -1)
	{
	perror("connect");
	return -1;
	}
	cout << "成功和服务器建立连接..." << endl;
	return ret;
	}

	int TcpSocket::sendMsg(string msg)
	{
	// 申请内存空间：数据长度 + 包头 4 字节 (存储数据长度)
	char* data = new char[msg.size() + 4];
	int bigLen = htonl(msg.size());
	memcpy(data, &bigLen, 4);
	memcpy(data + 4, msg.data(), msg.size());
	// 发送数据
	int ret = writen(data, msg.size() + 4);
	delete[]data;
	return ret;
	}

	string TcpSocket::recvMsg()
	{
	// 接收数据
	// 1. 读数据头
	int len = 0;
	readn((char*)&len, 4);
	len = ntohl(len);
	cout << "数据块大小: " << len << endl;

	// 根据读出的长度分配内存
	char* buf = new char[len + 1];
	int ret = readn(buf, len);
	if (ret != len)
	{
	return string();
	}
	buf[len] = '\0';
	string retStr(buf);
	delete[]buf;

	return retStr;
	}

	int TcpSocket::readn(char* buf, int size)
	{
	int nread = 0;
	int left = size;
	char* p = buf;

	while (left > 0)
	{
	if ((nread = read(m_fd, p, left)) > 0)
	{
	p += nread;
	left -= nread;
	}
	else if (nread == -1)
	{
	return -1;
	}
	}
	return size;
	}

	int TcpSocket::writen(const char* msg, int size)
	{
	int left = size;
	int nwrite = 0;
	const char* p = msg;

	while (left > 0)
	{
	if ((nwrite = write(m_fd, msg, left)) > 0)
	{
	p += nwrite;
	left -= nwrite;
	}
	else if (nwrite == -1)
	{
	return -1;
	}
	}
	return size;
	}

# TcpServer.h

	#include "TcpSocket.h"

	class TcpServer
	{
	public:
	TcpServer();
	~TcpServer();
	int setListen(unsigned short port);
	TcpSocket* acceptConn(struct sockaddr_in* addr = nullptr); // 接受数据库连接

	private:
	int m_fd; // 监听的套接字
	};

# TcpServer.cpp

	#include "TcpServer.h"

	TcpServer::TcpServer()
	{
	m_fd = socket(AF_INET, SOCK_STREAM, 0);
	}

	TcpServer::~TcpServer()
	{
	close(m_fd);
	}

	int TcpServer::setListen(unsigned short port)
	{
	struct sockaddr_in saddr;
	saddr.sin_family = AF_INET;
	saddr.sin_port = htons(port);
	saddr.sin_addr.s_addr = INADDR_ANY; // 0 = 0.0.0.0
	int ret = bind(m_fd, (struct sockaddr*)&saddr, sizeof(saddr));
	if (ret == -1)
	{
	perror("bind");
	return -1;
	}
	cout << "套接字绑定成功, ip: "
	<< inet_ntoa(saddr.sin_addr)
	<< ", port: " << port << endl;

	ret = listen(m_fd, 128);
	if (ret == -1)
	{
	perror("listen");
	return -1;
	}
	cout << "设置监听成功..." << endl;

	return ret;
	}

	TcpSocket* TcpServer::acceptConn(sockaddr_in* addr) // 传递的可以返回客户端 IP 和端口的结构体
	{
	if (addr == NULL)
	{
	return nullptr;
	}

	socklen_t addrlen = sizeof(struct sockaddr_in);
	int cfd = accept(m_fd, (struct sockaddr*)addr, &addrlen);
	if (cfd == -1)
	{
	perror("accept");
	return nullptr;
	}
	printf("成功和客户端建立连接...\n");
	return new TcpSocket(cfd); // 返回套接字文件描述符
	}

# server.cpp

	#include <pthread.h>
	#include "TcpServer.h"

	struct SockInfo
	{
	TcpServer* s; //
	TcpSocket* tcp;
	struct sockaddr_in addr;
	};

	void* working(void* arg)
	{
	struct SockInfo* pinfo = static_cast<struct SockInfo*>(arg);
	// 连接建立成功，打印客户端的 IP 和端口信息
	char ip[32];
	printf("客户端的IP: %s, 端口: %d\n",
	inet_ntop(AF_INET, &pinfo->addr.sin_addr.s_addr, ip, sizeof(ip)),
	ntohs(pinfo->addr.sin_port));

	// 5. 通信
	while (1)
	{
	printf("接收数据: .....\n");
	string msg = pinfo->tcp->recvMsg();
	if (!msg.empty())
	{
	cout << msg << endl << endl << endl;
	}
	else
	{
	break;
	}
	}
	delete pinfo->tcp;
	delete pinfo;
	return nullptr;
	}

	int main()
	{
	// 1. 创建监听的套接字
	TcpServer s;
	// 2. 绑定本地的 IP port 并设置监听
	s.setListen(10000);
	// 3. 阻塞并等待客户端的连接
	while (1)
	{
	SockInfo* info = new SockInfo;
	TcpSocket* tcp = s.acceptConn(&info->addr); // 监听连接请求
	if (tcp == nullptr)
	{
	cout << "重试...." << endl;
	continue;
	}
	// 创建子线程
	pthread_t tid;
	info->s = &s;
	info->tcp = tcp;

	pthread_create(&tid, NULL, working, info);
	pthread_detach(tid);
	}

	return 0;
	}

# client.cpp

	#include "TcpSocket.h"
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <fcntl.h>
	int main()
	{
	// 1. 创建通信的套接字
	TcpSocket tcp;

	// 2. 连接服务器 IP port
	int ret = tcp.connectToHost("192.168.217.1", 10000);
	if (ret == -1)
	{
	return -1;
	}

	// 3. 通信
	int fd1 = open("english.txt", O_RDONLY);
	int length = 0;
	char tmp[100];
	memset(tmp, 0, sizeof(tmp));
	while ((length = read(fd1, tmp, sizeof(tmp))) > 0)
	{
	// 发送数据
	tcp.sendMsg(string(tmp, length));

	cout << "send Msg: " << endl;
	cout << tmp << endl << endl << endl;
	memset(tmp, 0, sizeof(tmp));

	// 接收数据
	usleep(300);
	}

	sleep(10);

	return 0;
	}

# 运行结果

发送信息

# 套接字通信

# 字节序

# 字节转换函数

# IP 地址转换

# sockaddr 数据结构

# 套接字函数

# socket 套接字

# bind 绑定

# listen 监听

# accept 接受

# 接受数据

# 发送数据

# connect

# TCP Linux 通信

# 三次握手

# 四次挥手

# socket 通信

# client.c

# server.c

# TCP流量控制

# TCP半关闭

# 端口复用

# TCP 数据 粘包 处理

# 发送端实现

# 接收端实现

# C++ 封装 TCP

# TcpSocket.h

# TcpSocket.cpp

# TcpServer.h

# TcpServer.cpp

# server.cpp

# client.cpp

# 运行结果

linux多线程总

linux套接字通信UDP

# `IP` 地址转换

# `sockaddr` 数据结构

# `socket` 套接字

# `bind` 绑定

# `listen` 监听

# `accept` 接受

# `connect`

# `TCP Linux` 通信

# `三次握手`

# `四次挥手`

# `socket` 通信

# `client.c`

# `server.c`

# `TCP流量控制`

# `TCP半关闭`

# `端口复用`

# TCP 数据 `粘包` 处理