网络编程--Linux

听了黑马课总结知识点，方便自己回顾。
第一天
协议：协议事先预定好，大家共同遵循是一组规则，如交通信号灯，从应用程序角度看，协议可理解为数据传输和数据解释的规则。可以简单的理解为各个主机之间进行通信使用的共同语言。
OSI七层参考模型：
物理层：双绞线，将模拟信号转化为数字信号。
数据链路层：数据校验，数据传输的基本单元数据封装成帧。
网络层：定义网络，两台机器之间传输的路径选择点到点的传输
传输层：TC，UDP数据端到端的传输。
会话层：通过传输层建立数据传输的通道
表示层：解码译码等工作。
应用层：为客户提供各种应用服务。
传输层 常见协议有TCP/UDP协议。
应用层 常见的协议有HTTP协议，FTP协议。
网络层 常见协议有IP协议、ICMP协议、IGMP协议。
网络接口层 常见协议有ARP协议、RARP协议。
TCP传输控制协议（Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议。
UDP用户数据报协议（User Datagram Protocol）是OSI参考模型中一种无连接的传输层协议，提供面向事务的简单不可靠信息传送服务。
HTTP超文本传输协议（Hyper Text Transfer Protocol）是互联网上应用最为广泛的一种网络协议。
FTP文件传输协议（File Transfer Protocol）
IP协议是因特网互联协议（Internet Protocol）
ICMP协议是Internet控制报文协议（Internet Control Message Protocol）它是TCP/IP协议族的一个子协议，用于在IP主机、路由器之间传递控制消息。
IGMP协议是 Internet 组管理协议（Internet Group Management Protocol），是因特网协议家族中的一个组播协议。该协议运行在主机和组播路由器之间。
ARP协议是正向地址解析协议（Address Resolution Protocol），通过已知的IP，寻找对应主机的MAC地址。
RARP是反向地址转换协议，通过MAC地址确定IP地址。
OSI七层参考模型：该模型定义不同计算机互联的标准，是设计和表述计算机网络通信的基本框架，

数据通信过程就是发送端层层打包，接收端层层解包的过程。

网络应用程序的设计模式
CS：
优点：客户端在本机上保证性能，可以将数据缓存到本地，提高数据的传输效率，提高用户体验效果。
客户端和服务端都是由一个团队共同开发，协议选择灵活。
缺点：
服务端和客户端都需要开发工作量大，调试困难，开发周期长，用户将客户端安装到主机上，对用户的安全构成威胁。
BS：
优点：无需安装客户端，可以使用标准的浏览器作为客户端，只需要开发服务器，工作量小。采用了标准的客户端程序移植性能好，不受平台的限制，相对安全，不用安装软件，
缺点：没有客户端，数据缓存不尽人意，数据传输有限制，用户体验差，只能选择HTTP协议。
以太网帧格式就是封装在数据链路层协议

ARP协议：目的端mac地址是通过发送端发送APR广播，接收到该ARP数据的主机先判断是否是自己的IP，若是则应答一个ARP应答报文，将自己的mac地址填入到应答报文中，若不是自己的主机IP，则直接丢弃该ARP请求报文。

IP段格式

协议版本: ipv4, ipv6
16位总长度: 最大65536
8位生存时间ttl(网络连接下一跳的次数): 为了防止网络阻塞
32位源ip地址, 共个4字节！我们熟悉的ip都是点分十进制的，4字节, 每字节对应一个点分位，最大为255 ，实际上就是整形数！
32位目的ip地址
8位协议: 用来区分上层协议是TCP, UDP, ICMP还是IGMP协议.
16位首部校验和: 只校验IP首部, 数据的校验由更高层协议负责.

通过IP地址确定网络环境中的唯一一台主机，主机上使用端口号来区分不同的应用程序。IP地址和端口号确定唯一一台主机上的应用程序。

只有当ACK为1时，确认序号才有效，表示希望下次收到数据起始序列。
SYN同步序号标志，表示请求建立连接过程。
FIN：结束标志，表示没有数据连接了请求断开连接过程。
RST：请求连接状态。

Socket编程
使用socket会建立一个socket pair 一个文件描述符操作两个缓冲区。

网络字节序:
大端和小端的概念
大端: 低位地址存放高位数据, 高位地址存放低位数据
小端: 低位地址存放低位数据, 高位地址存放高位数据

大端和小端的使用使用场合???
大端和小端只是对数据类型长度是两个及以上的, 如int short, 对于单字节 没限制, 在网络中经常需要考虑大端和小端的是IP和端口.
网络传输用的是大端法, 如果机器用的是小端法, 则需要进行大小端的转换.

编写代码验证主机使用的字节序：

#include 
#include 

union {
    short s;
    char c[sizeof(short)];
} un2;

union {
	int s;
	char c[sizeof(int)];
}un4;

int main()
{
	printf("[%d][%d][%d]\n", sizeof(short), sizeof(int), sizeof(long int));

	//测试short类型，占两位字节
    un2.s = 0x0102;// 0x0102 =? 16*16+2
    printf("%d,%d,%d\n",un2.c[0],un2.c[1],un2.s);

	//测试int类型。占四位字节
	//un4.s = 0x12345678;
	un4.s = 0x01020304;
	printf("%d,%d,%d,%d,%d\n", un4.c[0], un4.c[1], un4.c[2], un4.c[3], un4.s);
    return 0;
}

下面4个函数就是进行大小端转换的函数:
#include
uint32_t htonl(uint32_t hostlong);
uint16_t htons(uint16_t hostshort);
uint32_t ntohl(uint32_t netlong);
uint16_t ntohs(uint16_t netshort);
函数名的h表示主机host, n表示网络network, s表示short, l表示long
上述的几个函数, 如果本来不需要转换函数内部就不会做转换.

IP地址转换函数：
p->表示点分十进制的字符串形式
to->到
n->表示network网络
int inet_pton(int af, const char *src, void *dst);
函数说明: 将字符串形式的点分十进制IP转换为大端模式的网络IP(整形4字节数)
参数说明:
af: AF_INET
src: 字符串形式的点分十进制的IP地址
dst: 存放转换后的变量的地址
例如: inet_pton(AF_INET, “127.0.0.1”, &serv.sin_addr.s_addr);

手工也可以计算: 如192.168.232.145, 先将4个正数分别转换为16进制数,
192—>0xC0 168—>0xA8 232—>0xE8 145—>0x91
最后按照大端字节序存放: 0x91E8A8C0, 这个就是4字节的整形值.

const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
函数说明: 网络IP转换为字符串形式的点分十进制的IP
参数说明:
af: AF_INET
src: 网络的整形的IP地址
dst: 转换后的IP地址,一般为字符串数组
size: dst的长度
返回值:
成功–返回指向dst的指针
失败–返回NULL, 并设置errno

例如: IP地址为010aa8c0, 转换为点分十进制的格式:
01---->1 0a---->10 a8---->168 c0---->192
由于从网络中的IP地址是高端模式, 所以转换为点分十进制后应该为: 192.168.10.1

socket常用的结构体strcut sockaddr

struct sockaddr结构说明:
struct sockaddr {
sa_family_t sa_family;
char sa_data[14];
}
struct sockaddr_in结构:
struct sockaddr_in {
sa_family_t sin_family; /* address family: AF_INET /
in_port_t sin_port; / port in network byte order /
struct in_addr sin_addr; / internet address */
};

/* Internet address. /
struct in_addr {
uint32_t s_addr; / address in network byte order */
}; //网络字节序IP–大端模式
通过man 7 ip可以查看相关说明
socket编程主要的API函数介绍
int socket(int domain, int type, int protocol);
函数描述: 创建socket
参数说明:
domain: 协议版本
AF_INET IPV4
AF_INET6 IPV6
AF_UNIX AF_LOCAL本地套接字使用
type:协议类型
SOCK_STREAM 流式, 默认使用的协议是TCP协议
SOCK_DGRAM 报式, 默认使用的是UDP协议
protocal:
一般填0, 表示使用对应类型的默认协议.
返回值:
成功: 返回一个大于0的文件描述符
失败: 返回-1, 并设置errno

当调用socket函数以后, 返回一个文件描述符, 内核会提供与该文件描述符相对应的读和写缓冲区, 同时还有两个队列, 分别是请求连接队列和已连接队列.

*int bind(int sockfd, const struct sockaddr addr, socklen_t addrlen);
函数描述: 将socket文件描述符和IP,PORT绑定
参数说明:
socket: 调用socket函数返回的文件描述符
addr: 本地服务器的IP地址和PORT,
struct sockaddr_in serv;
serv.sin_family = AF_INET;
serv.sin_port = htons(8888);
//serv.sin_addr.s_addr = htonl(INADDR_ANY);
//INADDR_ANY: 表示使用本机任意有效的可用IP

inet_pton(AF_INET, “127.0.0.1”, &serv.sin_addr.s_addr);
addrlen: addr变量的占用的内存大小
返回值:
成功: 返回0
失败: 返回-1, 并设置errno

int listen(int sockfd, int backlog);
函数描述: 将套接字由主动态变为被动态
参数说明:
sockfd: 调用socket函数返回的文件描述符
backlog: 同时请求连接的最大个数(还未建立连接)
返回值:
成功: 返回0
失败: 返回-1, 并设置errno

**int accept(int sockfd, struct sockaddr addr, socklen_t addrlen);
函数说明:获得一个连接, 若当前没有连接则会阻塞等待.
函数参数:
sockfd: 调用socket函数返回的文件描述符
addr: 传出参数, 保存客户端的地址信息
addrlen: 传入传出参数, addr变量所占内存空间大小
返回值:
成功: 返回一个新的文件描述符,用于和客户端通信
失败: 返回-1, 并设置errno值.

accept函数是一个阻塞函数, 若没有新的连接请求, 则一直阻塞.
从已连接队列中获取一个新的连接, 并获得一个新的文件描述符, 该文件描述符用于和客户端通信. (内核会负责将请求队列中的连接拿到已连接队列中)

*int connect(int sockfd, const struct sockaddr addr, socklen_t addrlen);
函数说明: 连接服务器
函数参数:
sockfd: 调用socket函数返回的文件描述符
addr: 服务端的地址信息
addrlen: addr变量的内存大小
返回值:
成功: 返回0
失败: 返回-1, 并设置errno值

读取数据和发送数据:
ssize_t read(int fd, void *buf, size_t count);
ssize_t write(int fd, const void *buf, size_t count);

注意: 如果写缓冲区已满, write也会阻塞, read读操作的时候, 若读缓冲区没有数据会引起阻塞.
socketAPI函数编写服务端和客户端程序步骤如下：

熟悉客户端和服务端流程开发代码：服务端将小写字母变成大写字母并返回。服务端设置IP为IP_ADDR,代表本机上任意IP地址都可以连接。但要设置为指定IP，客户端必须绑定指定的IP和端口才能连接成功 .

//服务端程序
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

int main()
{
	//创建socket
	//int socket(int domain, int type, int protocol);
	int lfd = socket(AF_INET, SOCK_STREAM, 0);
	if(lfd<0)
	{
		perror("socket error");
		return -1;
	}
	
	//int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
	//绑定
	struct sockaddr_in serv;
	bzero(&serv, sizeof(serv));
	serv.sin_family = AF_INET;
	serv.sin_port = htons(8888);
	serv.sin_addr.s_addr = htonl(INADDR_ANY); //表示使用本地任意可用IP
	int ret = bind(lfd, (struct sockaddr *)&serv, sizeof(serv));
	if(ret<0)
	{
		perror("bind error");	
		return -1;
	}

	//监听
	//int listen(int sockfd, int backlog);
	listen(lfd, 128);

	//int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
	struct sockaddr_in client;
	socklen_t len = sizeof(client);
	int cfd = accept(lfd, (struct sockaddr *)&client, &len);  //len是一个输入输出参数
	//const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
	
	//获取client端的IP和端口
	char sIP[16];
	memset(sIP, 0x00, sizeof(sIP));
	printf("client-->IP:[%s],PORT:[%d]\n", inet_ntop(AF_INET, &client.sin_addr.s_addr, sIP, sizeof(sIP)), ntohs(client.sin_port));
	printf("lfd==[%d], cfd==[%d]\n", lfd, cfd);

	int i = 0;
	int n = 0;
	char buf[1024];

	while(1)
	{
		//读数据
		memset(buf, 0x00, sizeof(buf));
		n = read(cfd, buf, sizeof(buf));
		if(n<=0)
		{
			printf("read error or client close, n==[%d]\n", n);
			break;
		}
		printf("n==[%d], buf==[%s]\n", n, buf);	

		for(i=0; i<n; i++)
		{
			buf[i] = toupper(buf[i]);
		}

		//发送数据
		write(cfd, buf, n);
	}

	//关闭监听文件描述符和通信文件描述符
	close(lfd);
	close(cfd);
	
	return 0;
}

客户端获取标注输入，发送到服务器，服务器读到后将小写子母转化为大写字母并返回。

//客户端代码
#include 
#include 
#include 
#include 
#include 
#include 
#include 

int main()
{
	//创建socket---用于和服务端进行通信
	int cfd = socket(AF_INET, SOCK_STREAM, 0);
	if(cfd<0)
	{
		perror("socket error");
		return -1;
	}

	//连接服务端
	//int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
	struct sockaddr_in serv;
	serv.sin_family = AF_INET;
	serv.sin_port = htons(8888);
	inet_pton(AF_INET, "127.0.0.1", &serv.sin_addr.s_addr);
	printf("[%x]\n", serv.sin_addr.s_addr);
	int ret = connect(cfd, (struct sockaddr *)&serv, sizeof(serv));
	if(ret<0)
	{
		perror("connect error");
		return -1;
	}	

	int n = 0;
	char buf[256];
	while(1)
	{
		//读标准输入数据
		memset(buf, 0x00, sizeof(buf));
		n = read(STDIN_FILENO, buf, sizeof(buf));
		
		//发送数据
		write(cfd, buf, n);

		//读服务端发来的数据
		memset(buf, 0x00, sizeof(buf));
		n = read(cfd, buf, sizeof(buf));
		if(n<=0)
		{
			printf("read error or server closed, n==[%d]\n", n);
			break;
		}
		printf("n==[%d], buf==[%s]\n", n, buf);
	}

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

	return 0;
}

三次握手四次挥手

SYN: 表示请求, ACK:表示确认
服务端发送的SYN和客户端发送的SYN本身也会占1位.
ACK的值是对方发送的序号值+数据长度
确认信号不需要SYN表示符了，只有在请求连接时候需要SYN标识位。
传输数据的时候seq就是最近一次对方给自己的确认序号，而发给对方的ACK就是上次刚刚发给对方的ACK值。

图中发送的ACK确认包表示对方发送数据的一个确认，表示你发送数据我收到了，同时告诉对方下次该发送的数据。由于每次发送数据都会告诉对方发来的确认包，告诉对方是否收到确认包，如果没有收到确认包，会对数据进行重发。
mss：最大报文长度，告诉对方我这边最多一次能接受多少，你不能超过这个长度。
win表示对方我这边缓冲区还有多少。
MTU：最大数据传输单元，最大传输单元通常与通信接口有关，这个值如果设置过大会导致丢包重传的时候数据量较大，图中的最大值是1500.
滑动窗口：流量控制
如果发送端发送的速度较快，接收端接收到数据后处理速度慢，而接收缓冲区的大小是固定的，就会导致接收缓冲区满而丢失数据。TCP协议通过滑动窗口解决这一问题。
函数封装
结合man-page和errno进行封装
在封装时候可以把第一个函数名的字母大写，如socket可以封装成Socket，像accept，read会引起函数阻塞，若信号被打断，由于信号的优先级较高，会优先处理信号函数，信号处理完成后，会使accept，read函数解除阻塞，然后返回，此时返回值为-1，设置errno为EINTER

粘包：数据多次发送，收尾相连，接收端接收的时候不能正确区分一次发送多少，第二次发送多少。
粘包的解决方法：
1.包头+数据
如4为数据长度+数据------>00101234567890
2.添加结尾标记
3.数据包定长
高并发服务器解决方法：多进程和多线程
多进程：让父进程监听新的连接，子进程处理新的连接（接收和发送数据），父进程负责返回子进程。
处理流程：
1.创建socket得到一个文件描述符-socket（）
2.将lfd和IP端口进行port绑定-bind（）
3，设置监听-listen（）
4.进入while（）
{
//等待新的客户端的到来
cfd=accept();
pid=fork();
if(pid<0) 程序退出
else if(pid>0) 关闭通信的文件描述符
else if(pid==0) 关闭监听文件的描述符，进行收发数据，子进程结束时需要exit防止子进程自己再去创建进程。
父子进程能够共享的：文件描述符创建进程后文件描述符引用加1

多线程版本的服务器开发流程
1.创建socket得到一个监听文件描述符lfd
2.lfd和Ip和端口进行绑定-bind
3.设置监听listen
4 while(1)
{
//接受新的客户端连接请求
cfd = accept();

  	//创建一个子线程
  	pthread_create(&threadID, NULL, thread_work, &cfd);
  	
  	//设置线程为分离属性
  	pthread_detach(threadID);
  	
  }
  
  close(lfd);

}

子线程执行函数:
void *thread_work(void *arg)
{
//获得参数: 通信文件描述符
int cfd = *(int *)arg;

	while(1)
	{
		//读数据
		n = read(cfd, buf, sizeof(buf));
		if(n<=0)
		{
			break;
		}
		
		//发送数据
		write(cfd, buf, n);
	}
	
	close(cfd);
}

multiprocess

//多进程版本的网络服务器
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "wrap.h"

int main()
{
	//创建socket
	int lfd = Socket(AF_INET, SOCK_STREAM, 0);
	
	//绑定
	struct sockaddr_in serv;
	bzero(&serv, sizeof(serv));
	serv.sin_family = AF_INET;
	serv.sin_port = htons(8888);
	serv.sin_addr.s_addr = htonl(INADDR_ANY);
	Bind(lfd, (struct sockaddr *)&serv, sizeof(serv));
	
	//设置监听
	Listen(lfd, 128);
	
	pid_t pid;
	int cfd;
	char sIP[16];
	socklen_t len;
	struct sockaddr_in client;
	while(1)
	{
		//接受新的连接
		len = sizeof(client);
		memset(sIP, 0x00, sizeof(sIP));
		cfd = Accept(lfd, (struct sockaddr *)&client, &len);
		printf("client:[%s] [%d]\n", inet_ntop(AF_INET, &client.sin_addr.s_addr, sIP, sizeof(sIP)), ntohs(client.sin_port));
		
		//接受一个新的连接, 创建一个子进程,让子进程完成数据的收发操作
		pid = fork();
		if(pid<0)
		{
			perror("fork error");
			exit(-1);
		}
		else if(pid>0)
		{
			//关闭通信文件描述符cfd
			close(cfd);			
		}
		else if(pid==0)
		{
			//关闭监听文件描述符
			close(lfd);
			
			int i=0;
			int n;
			char buf[1024];
			
			while(1)
			{
				//读数据
				n = Read(cfd, buf, sizeof(buf));
				if(n<=0)
				{
					printf("read error or client closed, n==[%d]\n", n);
					break;
				}
				//printf("client:[%s] [%d]\n", inet_ntop(AF_INET, &client.sin_addr.s_addr, sIP, sizeof(sIP)), ntohs(client.sin_port));
				printf("[%d]---->:n==[%d], buf==[%s]\n", ntohs(client.sin_port), n, buf);
				
				//将小写转换为大写
				for(i=0; i<n; i++)
				{
					buf[i] = toupper(buf[i]);
				}
				//发送数据
				Write(cfd, buf, n);
			}
			
			//关闭cfd
			close(cfd);
			exit(0);
		}
	}
	
	//关闭监听文件描述符
	close(lfd);
	
	return 0;
}

multithread.c

//多线程版本的高并发服务器
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "wrap.h"

//子线程回调函数
void *thread_work(void *arg)
{
	//sleep(20);
	int cfd = *(int *)arg;
	printf("cfd==[%d]\n", cfd);
	
	int i;
	int n;
	char buf[1024];
	
	while(1)
	{
		//read数据
		memset(buf, 0x00, sizeof(buf));
		n = Read(cfd, buf, sizeof(buf));
		if(n<=0)
		{
			printf("read error or client closed,n==[%d]\n", n);
			break;
		}
		printf("n==[%d], buf==[%s]\n", n, buf);
		
		for(i=0; i<n; i++)
		{
			buf[i] = toupper(buf[i]);
		}
		//发送数据给客户端
		Write(cfd, buf, n);	
	}
	
	//关闭通信文件描述符
	close(cfd);
	
	pthread_exit(NULL);
}
int main()
{
	//创建socket
	int lfd = Socket(AF_INET, SOCK_STREAM, 0);
	
	//设置端口复用
	int opt = 1;
	setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int));
	
	//绑定
	struct sockaddr_in serv;
	bzero(&serv, sizeof(serv));
	serv.sin_family = AF_INET;
	serv.sin_port = htons(8888);
	serv.sin_addr.s_addr = htonl(INADDR_ANY);
	Bind(lfd, (struct sockaddr *)&serv, sizeof(serv));
	
	//设置监听
	Listen(lfd, 128);
	
	int cfd;
	pthread_t threadID;
	while(1)
	{
		//接受新的连接
		cfd = Accept(lfd, NULL, NULL);
		
		//创建子线程
		pthread_create(&threadID, NULL, thread_work, &cfd);
		
		//设置子线程为分离属性
		pthread_detach(threadID);
	}

	//关闭监听文件描述符
	close(lfd);
	
	return 0;
}

day3
TCP的连接状态：

为什么需要2MSL？
原因之一：让四次挥手的过程更加可靠，确保最后一个发送给对方的ACK到达，若对方没有收到ACK应答，对方再次发送FIN请求关闭，此时在2MS时间内被动关闭仍然可以发送ACK给对方。
原因之二：为了保证在2MS时间内，不能启动相同的SOCKET_PAIR
TIME_WAIT一定是出现在主动关闭的一方，也就是说2MS是针对主动关闭一方来说的，由于TCP可能存在丢包重传，丢包重传若发给了已经断开连接之后相同的socket_pair（该连接是新建的，与原来的socket_pair完全相同，双方使用的是相同的IP和端口），这样会对之后的连接造成困扰。

socket_pair：客户端与服务端连接其实是一个连接对，可以通过使用netstat -anp|grep 端口号 进行查看。

端口复用的问题：bind error:Address already in use发生这种情况是在服务端主动关闭连接以后，接着立刻启动会报这种错误。
setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int));
由于错误是bind函数报出来的，该函数调用要放在bind之前，socket之后调用。

半关闭状态
如果一方close，另一方没有close，则认为是半关闭状态，处于半关闭状态的时候，可以接受数据，但是不能发送数据。相当于把文件描述符的写缓冲区操作关闭了
半关闭一定是出现在主动关闭的一方。

shutdown和close 的区别：
close文件描述符的链接–，直到减到0就真正关闭文件描述符/shutdown文件描述符上读或者写操作关闭。

心跳包：检测长连接是否正常。

高并发服务器–select模型
多路IO技术：select同时监听多个文件描述符，将监控的操作交给内核去处理。
数据类型fd_set：文件描述符集合–本质是位图（关于集合可联想一个信号集sigset_t)
int select(int nfds, fd_set * readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
函数介绍: 委托内核监控该文件描述符对应的读,写或者错误事件的发生.
参数说明:
nfds: 最大的文件描述符+1
readfds: 读集合, 是一个传入传出参数
传入: 指的是告诉内核哪些文件描述符需要监控
传出: 指的是内核告诉应用程序哪些文件描述符发生了变化
writefds: 写文件描述符集合(传入传出参数)
execptfds: 异常文件描述符集合(传入传出参数)
timeout:
NULL–表示永久阻塞, 直到有事件发生
0 --表示不阻塞, 立刻返回, 不管是否有监控的事件发生
>0–到指定事件或者有事件发生了就返回
返回值：成功返回发生变化的文件描述符个数
失败返回-1，并设置errnp值
void FD_CLR(int fd,fd_set *set);//将fd从集合清除
int FD_ISSET(int fd,fd_set *set)//判断fd是否在集合中,如果在返回1否则返回0
void FD_SET(int fd,fd_set *set);//将fd设置在集合中
void FD_ZERO(fd_set * set);//初始化set集合

调用select函数其实就是委托内核帮助我们去检测哪些文件描述符有可读数据，可写，错误发生。

代码思路：
代码的具体实现：编写代码并进行测试

可以使用发生事件的总数进行控制，减少循环次数
调用select函数涉及到用户空间和内核空间的数值交互过程
事件一个包含两部分，一类是新连接事件，一类是有数据可读的事件。

select优点：
1.一个进程可以支持多个客户端
2.select支持跨平台
select缺点：
代码编写困难，会用到用户区和内核区来回的拷贝
当多个客户端连接，但少数活跃情况，select效率低
最大支持1024个客户端连接

多路IO-epoll
将检测文件描述符的变化委托给内核区处理，然后内核将发生变化的文件描述符对应的事件返回给应用程序。
int epoll_create(int size)
函数说明：创建一个树根
参数说明：size最大节点数，必须传递一个大于0的数
返回值：返回一个大于0的文件描述符，代表整个树的树根
失败：返回-1，并设置errno值

int epoll_ctl(int epfd,int op,int fd,struct epoll_event* event)
函数说明：将要监听的节点在epoll树上添加，删除和修改
参数说明：
epfd:epoll树根
op：EPOLL_CTL_ADD：添加事件节点到树上
EPOLL_CTL_DEL：从树上删除事件节点
EPOLL_CTL_MOD:修改树上对应的事件节点
fd：事件节点对应的文件描述符
event：要操作的事件节点
typedef union epoll_data {
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;

       struct epoll_event {
           uint32_t     events;      /* Epoll events */
           epoll_data_t data;        /* User data variable */
       };

event.events常用的有:
EPOLLIN: 读事件
EPOLLOUT: 写事件
EPOLLERR: 错误事件
EPOLLET: 边缘触发模式
event.fd: 要监控的事件对应的文件描述符
int epoll_wait((int epfd, struct epoll_event *events, int maxevents, int timeout);
函数说明：等待内核返回事件发生
epfd: epoll树根
events: 传出参数, 其实是一个事件结构体数组
maxevents: 数组大小
timeout:
-1: 表示永久阻塞
0: 立即返回

0: 表示超时等待事件
返回值:
成功: 返回发生事件的个数
失败: 若timeout=0, 没有事件发生则返回; 返回-1, 设置errno值,

epoll_wait的events是一个传出参数，调用epoll_ctl传递给内核什么值，当epoll_wait返回的时候，内核就会传回什么值，不会对struct event的结构变量的值做任何修改。

epoll的两种工作模式
epoll的两种模式ET和LT
水平触发：高电平代表1
只要缓冲区中有数据，就一直通知
边缘触发：电平有变化就代表1
缓冲区中有数据只会通知一次，之后再有数据才会通知。（若是读数据的时候没有读完，则剩余的不会在通知，直到有新的数据到来）

线程池
什么是线程池？线程池是一个抽象的概念，若干线程组合到一起，形成线程池。
为什么需要线程池？多线程版服务器一个客户端就需要创建一个线程！若客户端太多，显然不合适。什么时候需要创建线程池呢？简单来说，如果一个应用需要频繁的创建和销毁线程，而任务执行时间又非常短，这样创建和销毁带来的开销就不可以忽略不计，则没有必要使用线程池了。
线程池和任务池：
任务池相当于共享资源，所以需要互斥锁，当任务池中没有任务的时候需要让线程阻塞，所以使用条件变量。

如何让线程执行不同的任务
使用回调函数，在任务中设置执行函数，这样可以起到不同的任务执行不同的函数。

UDP通信
TCP：传输控制协议，面向连接的，稳定的，可靠的，安全的数据流传递稳定和可靠，丢包重传
数据有序：序号和确认号
流量控制：滑动窗口
UDP：面向无连接的，不稳定，不可靠，不安全的数据传递–更像是收发短信。
UDP传输不需要建立连接，传输效率更高，在稳定的局域网内相对可靠
UDP相关函数介绍：
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
struct sockaddr *src_addr, socklen_t *addrlen);
函数说明：接收消息
参数说明：
sockfd套接字
buf要接收缓冲区
len缓冲区长度
flags标志位一般填0
src_addr原地址传出参数
addrlen发送方的地址长度
返回值：成功：返回读到的字节数
失败：返回-1，并设置errno
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
const struct sockaddr *dest_addr, socklen_t addrlen);
函数说明：发送数据
参数说明：sockfd套接字
dest_addr目的地址
addrlen：目的地址长度
返回值：成功返回写入的字节数
失败：返回-1，设置errno

本地socket通信：
man 7 unix可以查到unix本地域socket通信相关信息
#include
#include
int socket(int domain, int type, int protocol);
函数说明：创建本地socket
函数参数：
domain：AF_UNIXorAF_LOCAL
type：SOCK_STREAM或者SOCK_DGRAM
protocol：0 表示使用默认协议
函数返回值：
成功：返回文件描述符
失败：返回-1，设置errno值

创建socket后，内核会创建缓冲区，下面是客户端内核缓冲区示意图

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
函数说明: 绑定套接字
函数参数:
socket: 由socket函数返回的文件描述符
addr: 本地地址
addlen: 本地地址长度
函数返回值:
成功: 返回文件描述符.
失败: 返回-1, 并设置errno值.

需要注意的是: bind函数会自动创建socket文件, 若在调用bind函数之前socket文件已经存在, 则调用bind会报错, 可以使用unlink函数在bind之前先删除文件
struct sockaddr_un {
sa_family_t sun_family; /* AF_UNIX or AF_LOCAL*/
char sun_path[108]; /* pathname */
};

man 2 bind查看bind函数的相关信息

本地套接字服务器流程：
可以使用TCP的方式，必须按照tcp流程
也可以使用UDP方式，必须按照UDP流程

tcp的本地套接字服务器流程
创建套接字 socket(AF_UNIX,SOCK_STREAM,0)
绑定struct sockaddr_un & 强转
监听listen
获得新的连接accept
关闭文件描述符close

tcp本地套接字客户端流程
调用socket套接字
调用bind函数将socket文件描述符和socket文件进行绑定
调用connect函数连接服务端
循环通信read-write
关闭文件描述符。

day15
libevent介绍
1 事件驱动, 高性能, 轻量级, 专注于网络
2 源代码精炼, 易读
3 跨平台
4 支持多种I/O多路复用技术, 如epoll select poll等
5 支持I/O和信号等事件
libevent的使用“
libevent的地基-event_base
使用libevent函数之前需要分配一个或者多个event_base结构体，每一个event_base结构体有一个事件集合，可以检测指定哪个事件是激活的，event_base结构相当于红黑树的树根节点，每一个event_base都有一种用于检测某种事件已经就绪的方法。

相关函数说明：
struct event_base * event_base_new(void);
函数说明：获得event_base结构
参数说明：无
返回值：成功返回event_base结构体指针
失败返回NULL
void event_base_free(struct event base*)
函数说明：释放event_base指针
int event_reninit(event_base *base);
函数说明：如果有子进程，且子进程也要使用base，则子进程需要对event_base重新初始化，此时需要调用event_reninit函数
对于不同系统而言, event_base就是调用不同的多路IO接口去判断事件是否已经被激活, 对于linux系统而言, 核心调用的就是epoll, 同时支持poll和select.

查看libevent支持的后端的方法有哪些:
const char event_get_supported_methods(void);
函数说明: 获得当前系统(或者称为平台)支持的方法有哪些
参数: 无
返回值: 返回二维数组, 类似与main函数的第二个参数argv.

const char * event_base_get_method(const struct event_base *base);
函数说明: 获得当前base节点使用的多路io方法
函数参数: event_base结构的base指针.
返回值: 获得当前base节点使用的多路io方法的指针
等待事件产生–循环等待event_loop
libevent在地基打好之后，需要等待事件的产生，也就是等待事件被激活，所以程序不能退出，对于epoll来说，我们需要自己控制循环，而在libevent中提供API接口，类似于where(1)的功能.
int event_base_dispatch(struct event_base *base); //event.h的L:364
函数说明: 进入循环等待事件
参数说明:由event_base_new函数返回的指向event_base结构的指针
调用该函数, 相当于没有设置标志位的event_base_loop。程序将会一直运行, 直到没有需要检测的事件了, 或者被结束循环的API终止。
int event_base_loopexit(struct event_base *base, const struct timeval *tv);
int event_base_loopbreak(struct event_base *base);
struct timeval {
long tv_sec;
long tv_usec;
};
两个函数的区别是如果正在执行激活事件的回调函数, 那么event_base_loopexit将在事件回调执行结束后终止循环（如果tv时间非NULL, 那么将等待tv设置的时间后立即结束循环）, 而event_base_loopbreak会立即终止循环。
使用libevent库的步骤：
1.创建根节点-event_base_new
2.设置监听事件和数据可读可写的事件的回调函数
3.事件循环-event_base_dispaatch
相当于while(1),在循环内部等待事件的发生，若有事件发生则会触发事件对应的回调函数
4.释放根节点
释放由event_base_new 和event_new 创建的资源，分别调用event_base_free函数。
libevent主要的几个状态
无效的指针：此时仅仅是定义了struct event * ptr;
非未决：相当于创建了事件，但是事件还没有处于被监听状态，类似于我们使用epoll的时候定义了struct epoll_event ev并且对ev的两个字段进行了赋值，但是此时尚未调用epoll_ctl对事件上树。
未决：对事件开始监听，暂时未有事件发生。相当于调用epoll_ctl对监听的事件上树，但是没有事件发生。
激活：代表监听事件已经产生，这时候需要处理，相当于epoll_wait函数有返回，当事件被激活后，libevent会调用事件对应的回调函数
libevent的事件驱动对应的结构体为struct event, 对应的函数在图上也比较清晰, 下面介绍一下主要的函数:
typedef void (*event_callback_fn)(evutil_socket_t fd, short events, void *arg);
struct event *event_new(struct event_base *base, evutil_socket_t fd, short events, event_callback_fn cb, void *arg);
函数说明: event_new负责创建event结构指针, 同时指定对应的地基base, 还有对应的文件描述符, 事件, 以及回调函数和回调函数的参数。
参数说明：
base: 对应的根节点–地基
fd: 要监听的文件描述符
events:要监听的事件
#define EV_TIMEOUT 0x01 //超时事件
#define EV_READ 0x02 //读事件
#define EV_WRITE 0x04 //写事件
#define EV_SIGNAL 0x08 //信号事件
#define EV_PERSIST 0x10 //周期性触发
#define EV_ET 0x20 //边缘触发, 如果底层模型支持设置 则有效, 若不支持则无效.
若要想设置持续的读事件则： EV_READ | EV_PERSIST
cb 回调函数, 原型如下：
typedef void (*event_callback_fn)(evutil_socket_t fd, short events, void *arg);
注意: 回调函数的参数就对应于event_new函数的fd, event和arg
int event_add(struct event *ev, const struct timeval *timeout);
函数说明: 将非未决态事件转为未决态, 相当于调用epoll_ctl函数(EPOLL_CTL_ADD), 开始监听事件是否产生, 相当于epoll的上树操作.
参数说明：
ev: 调用event_new创建的事件
timeout: 限时等待事件的产生, 也可以设置为NULL, 没有限时。

int event_del(struct event *ev);
函数说明: 将事件从未决态变为非未决态, 相当于epoll的下树（epoll_ctl调用 EPOLL_CTL_DEL操作）操作。
参数说明: ev指的是由event_new创建的事件.

void event_free(struct event *ev);
函数说明: 释放由event_new申请的event节点。

编写一个基于event实现的tcp服务器
总体步骤：
1.搭建服务器固定的三步：
创建socket
bind
listen
2.调用event_base_new函数创建event_base节点
3.创建要监听的事件event，主要就是监听事件和读数据的函数
4.调用event_base_dispatch进入循环等待事件的发生
5.释放资源
调用event_base_free释放根节点和调用event_free释放事件节点