一、网络编程关注的四个方面

网络编程主要关注四个问题：连接的建立、断开连接、消息到达、消息发送。
不管使用什么样的网络模型，不管使用的是阻塞IO还是非阻塞IO，不管是同步IO还是异步IO，都需要关注这四个问题。

1.1、建立连接

连接有两种：服务器处理接收客户端的连接；服务器作为客户端主动连接第三方服务。

1.1.1 接收连接

接收连接主要使用accept()函数，用于从全连接队列中返回一个已完成的连接。如果成功，返回值大于0表示与一个客户端TCP建立了连接；返回值是由kernel自动生成的一个全新描述符。在非阻塞模式下，accept()返回-1表示全连接队列中没有已完成的客户端接入。
accept函数原型：

ACCEPT(2)                  Linux Programmer's Manual                 ACCEPT(2)
NAME
       accept, accept4 - accept a connection on a socket
SYNOPSIS
       #include <sys/types.h>          /* See NOTES */
       #include <sys/socket.h>
       int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

简单示例：

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <arpa/inet.h>

#define LISTEN_PORT	8888

int main()
{

	int listenfd=socket(AF_INET,SOCK_STREAM,0);
	
	struct sockadd_in serveraddr;
	memset(&serveraddr,0,sizeof(serveraddr));
	serveraddr.sin_family=AF_INET;
	serveraddr.sin_addr.s_addr=htonl(INADDR_ANY);
	serveraddr.sin_port=htons(LISTEN_PORT);
	
	bind(listenfd,(struct sockaddr *)&serveraddr,sizeof(serveraddr));
	
	while(1)
	{
		struct sockaddr_in clientaddr;
		socklen_t len=sizeof(clientaddr);
		clientfd=accept(listenfd,&clientaddr,&len);
		
		/*......
		* 处理逻辑代码
		*/
	}
	return 0;
}

1.1.2 主动连接

主动连接由connect()函数发起，主动连接服务器。成功返回0；失败则返回-1，并设置了全局变量errno，应该处理connect函数返回的错误码。

connect函数原型：

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

/*
* sockfd：socket文件描述符
* addr：指定服务器端地址信息，包括IP地址和端口。
* addrlen：指定地址信息的大小
*/

connect()和bind()参数形式一样，区别在于bind()参数的地址信息是自己的，connect()参数的地址信息是对方的地址信息。
失败时返回的错误码：

简单示例：

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <arpa/inet.h>

#define LISTEN_PORT 8888

int main()
{
	int connectfd=socket(AF_INET,SOCK_STREAM,0);
	
	struct sockaddr_in serveraddr;
	memset(&serveraddr,0,sizeof(serveraddr));
	serveraddr.sin_family=AF_INET;
	serveraddr.sin_addr.s_addr=htonl("127.0.0.1");//服务器IP
	serveraddr.sin_port=htons(LISTEN_PORT);//服务器端口
	
	int ret = connect(connectfd,(struct sockaddr *)&serveraddr,sizeof(serveraddr));
	if(ret ==1)
	{
		// ret == -1 && errno == EINPROGRESS 正在建立连接
		// ret == -1 && errno = EISCONN 连接建立成功
		switch(errno)
		{
		/*处理错误码*/
		
		}
	}
	
	/*处理逻辑*/
	
}

1.2 断开连接

断开分两种，主动断开和被动断开。

1.2.1 主动断开

主动断开主要调用close()函数。有些网络编程需要支持半关闭状态时，使用shutdown()函数。
close函数原型：

#include <unistd.h>

int close(int fd);

close()关闭文件描述符，使其不再引用任何文件，并可重复使用。成功返回0；失败则返回-1，并设置了全局变量errno。
失败错误码：

shutdown函数原型：

#include<sys/socket.h>

int shutdown(int fd,int flag);

成功则返回0, 失败返回-1, 错误码放在errno。
flag参数说明：

使用方式：

//主动关闭
close(fd);
shoutdown(fd,SHUT_RDWR);

// 主动关闭本地读端，关闭对方写端
shutdown(fd,SHUT_RD);

// 主动关闭本地写端，关闭对方读端
shutdown(fd,SHUT_WR);

1.2.1 被动断开

主要依据recv/read、send/write判断。有的网络编程需要支持半关闭状态。

/*......*/
char buffer[1024]={ 0 };

// 被动，读端被关闭
int ret=recv(fd,buffer,1024,0);
if(ret==0)
{
	close(fd);
}

/*......*/

//被动，写端关闭
ret =send(fd,buffer,1024,0);
if(ret==0 && errno == EPIPE)
{
	close(fd);
}

/*......*/

recv和send函数原型：

#include <sys/types.h>
#include <sys/socket.h>

ssize_t recv(int sockfd, void *buf, size_t len, int flags);

ssize_t send(int sockfd, void *buf, size_t len, int flags);

成功返回接收 / 发送的字节数；失败则返回-1，并设置errno以指示错误。
注意，recv也可能返回0。当流套接字对等端执行有序关闭时，返回值将为0；不同域（例如UNIX和Internet域）中的数据报套接字允许零长度数据报，当接收到这样的数据报时，返回值为0；如果从流套接字接收的请求字节数为0，则也可以返回值0。
recv的错误码：

send错误码：

1.3 消息到达

接收消息使用recv / read函数。从缓冲区中读取数据。

//......

while(1)
{
	//......
	
	char buffer[1024]={ 0 };
	int ret =recv(fd,buffer,1024,0);
	if(ret<0)// ret==-1
	{
		if(errno==EINTR || errno == EWOULDBLOCK)
			break;
		// 四次挥手发送ack之前，还可以发送数据
		// send(....)
		close(fd);
	}
	else if(ret==0)
		close(fd);
	else
	{
		//处理buffer
	}
	
	//......
}

//......

1.4 消息发送

发送消息使用send / write函数。往写缓冲区写数据。

//......

char buffer[1024]={ 0 };
//......

int ret = send(fd,buffer,1024,0);
if(ret==-1)
{
	if(errno==EINTR || errno == EWOULDBLOCK)
		return;
	close(fd);
}
//......

二、操作IO

只能使用IO函数进行操作，有两者操作方式：阻塞IO和非阻塞IO。

2.1 操作方式

2.1.1 阻塞模式

一般情况下，fd默认是阻塞的。阻塞模式会阻塞在网络线程。比如，当调用recv，读缓冲区没有数据时，则一直阻塞，直到有数据可读才返回。注意，send函数不是把数据写完了才返回，而是只要写缓冲区有空间给它write数据就返回写成功，而不是写完数据才返回成功。
原理图如下：

2.1.2 非阻塞模式

连接的fd的阻塞属性决定了IO函数是否阻塞。默认情况下fd是阻塞的，要设置非阻塞模式，可以使用一下方式：

//......

int flag = fcntl(fd,F_GETFL,0);
flag|=O_NONBLACK;
fcntl(fd,F_SETFL,flag);

//......

设置了非阻塞模式后，调用IO函数时，不管有没有成功都返回。比如，当调用recv，读缓冲区没有数据时，返回-1，并设置errno，errno应该是EWOULDBLOCK。
原理如下：

2.1.3 两者区别

从上面原理图可以看出，差异主要在数据准备阶段。具体差异在：IO函数在数据未就绪时是否立刻返回。

2.2 非阻塞IO处理方式

2.2.1 建立连接

连接有两种：服务器处理接收客户端的连接；服务器作为客户端主动连接第三方服务。

2.2.1.1 主动连接

当服务器需要连接第三方服务，需要调用connect函数进行连接。
在非阻塞IO中，connect()会一直返回-1，同时设置errno；需要检查errno是EINPROGRESS（正在建立连接）还是EISCONN（已经建立连接）。
示例：

#define SERVER_PORT	8888
//......

struct sockaddr_in serv;
memset(&serv,0,sizeof(serv));
serv.sin_family=AF_INET;
serv.sin_addr.s_addr=htonl("127.0.0.1");//要连接的服务器ip地址
serv.sin_port=htons(SERVER_PORT);
while(1)
{
	int ret = connect(fd,(struct sockaddr *)&serv,sizeof(serv));
	if(ret==-1 && errno==EISCONN)
	{
		// ........
		break;
	}
}
// ......

2.2.1.1 接收连接

服务器通过accept()函数从全连接队列中获得已完成连接的客户端，并返回内核自动生成的文件描述符。
在非阻塞模式中，完成socket()、bind()、listen()的调用后，会循环调用accept()函数，如果返回值大于0，表示获取到一个已完成连接的客户端。
示例：

#define SERVER_PORT	8888
//......
int listenfd=socket(AF_INET,SOCK_STREAM,0);

struct sockaddr_in serv;
memset(&serv,0,sizeof(serv));
serv.sin_family=AF_INET;
serv.sin_addr.s_addr=htonl(INADDR_ANY);
serv.sin_port=htons(SERVER_PORT);

bind(listenfd,(struct sockaddr *)&serv,sizeof(serv));

listen(listenfd,10);

//......
while(1)
{
	struct sockaddr_in clientaddr;
	socklen_t len=sizeof(clientaddr);
	int ret = accept(fd,(struct sockaddr *)&serv,sizeof(serv));
	if(ret>0)
	{
		

		// ........
		break;
	}
}
// ......

2.2.2 断开连接

如1.2所描述。

2.2.3 消息到达

在非阻塞模式中，如果读缓冲区没数据，recv/read函数返回-1，并且设置errno为EWOULDBLOCK。如1.3所描述。

2.2.4消息发送

如1.4所描述。

2.3 IO函数说明

IO函数既有检测IO功能也有操作IO功能。
例如：

注意，IO函数只能检测一条连接就绪的状态以及操作一条连接的IO数据

三、IO多路复用检测IO

IO多路复用不会操作IO，只检测IO的就绪状态。 但是IO多路复用可以检测多个IO的就绪状态。IO多路复用主要有：select、poll、epoll。IO多路复用只能检测比较笼统的事件（比如 读事件、写事件、错误事件），IO函数可以检测具体的事件。
IO多路复用检测IO模型：

以epoll为例，epoll主要有三个函数：epoll_create、epoll_wait、epoll_ctl。
epoll函数原型：

#include <sys/epoll.h>

/*相关数据结构*/
struct eventpoll {
    // ...
    struct rb_root rbr; // 红黑树，管理 epoll 监听的事件
    struct list_head rdllist; // 链表，保存着 epoll_wait返回满⾜条件的事件
    // ...
};
struct epitem {
    // ...
    struct rb_node rbn; // 红⿊树节点
    struct list_head rdllist; // 双向链表节点
    struct epoll_filefd ffd; // 事件句柄信息
    struct eventpoll *ep; // 指向所属的eventpoll对 象
    struct epoll_event event; // 注册的事件类型
    // ...
};
struct epoll_event {
    __uint32_t events; // epollin ，epollout ，epollel(边缘触发)
    epoll_data_t data; // 保存 关联数据
};
typedef union epoll_data {
	void *ptr;
	int fd;
	uint32_t u32;
	uint64_t u64;
}epoll_data_t;

/*相关接口*/

int epoll_create(int size);

/*
* op:
* 	EPOLL_CTL_ADD	添加事件
* 	EPOLL_CTL_MOD	修改事件
* 	EPOLL_CTL_DEL	删除事件
*
* event:
* 	EPOLLIN		注册读事件
* 	EPOLLOUT	注册写事件
* 	EPOLLET		注册边沿触发，默认是水平触发
*/
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

/*
* events[i].event:
* 	EPOLLIN		触发读事件
* 	EPOLLOUT	触发写事件
* 	EPOLLERR	触发错误事件
* 	EPOLLRDHUP	连接读端关闭
* 	EPOLLHUP	连接读写端关闭
*
* timeout:
* 	-1，体现阻塞特性，直到有事件触发才返回
* 	0，体现非阻塞特性，立刻返回
* 	>0，超时时间，最多等待timeout时间，如果还没有事件触发就返回；单位是ms。
*/
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

调用epoll_create会创建一个epoll对象；
调用epoll_ctl添加到epoll中的事件都会与网卡驱动程序建立回调关系，相应事件触发时会调用触发函数(ep_poll_callback)，将触发的事件拷贝到双向链表(rdllist)中；
调用epoll_wait会从双向链表中就绪事件拷贝到用户态中。

那么，IO多路复用是怎么检测IO事件的呢？以epoll为例。

3.1 建立连接

连接有两种方式：主动连接和接受连接。

3.1.1 主动连接

主动连接主要通过connect()函数建立。
首先，通过socket()函数创建一个socket对象；
然后，epoll（IO多路复用器）监听写事件，调用connect函数，在三次握手阶段，客户端向服务端发送ack（在第三次）的同时发送写就绪信号给epoll（IO多路复用器）；
这就实现了epoll（IO多路复用器）检测到主动连接完成。

3.1.2 接受连接

接受连接主要通过socket()、bind()、listen()、accept()函数。
首先，通过socket()函数创建一个socket对象，bind()绑定地址，listen()监听端口，完成一个listenfd的创建和设置；
其次，epoll（IO多路复用器）监听listenfd的读事件，三次握手成功后全连接队列会产生一个节点，同时发送信号告诉epoll（IO多路复用器），触发读事件；这时说明连接完成。
然后，调用accept()函数，执行操作IO功能。
简单示例：

int init_sock(short port) {

	int fd = socket(AF_INET, SOCK_STREAM, 0);
	fcntl(fd, F_SETFL, O_NONBLOCK);

	struct sockaddr_in server_addr;
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	server_addr.sin_port = htons(port);

	bind(fd, (struct sockaddr*)&server_addr, sizeof(server_addr));

	if (listen(fd, 20) < 0) {
		printf("listen failed : %s\n", strerror(errno));
		return -1;
	}

	printf("listen server port : %d\n", port);
	return fd;
}
int main()
{
	int epfd=epoll_create(1);
	int listenfd=init_sock(8888);

	struct epoll_event ep_ev = {0, {0}};
	ep_ev.data.fd=listenfd;
	ep_ev.events=EPOLLIN;
	epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ep_ev);
	while(1)
	{
		struct epoll_event ep_ev_client[1024];
		int n = epoll_wait(epfd,ep_ev_client,1024,-1);
		int i=0;
		for(i=0;i<n;i++)
		{
			if(ep_ev_client[i].events & EPOLLIN)
			{
				//处理读事件......
			}
			if(ep_ev_client[i].events & EPOLLOUT)
			{
				//处理写事件......
			}
		}
	}
	return 0;
}

3.2 连接断开

IO多路复用器检测的是被动断开。
当epoll返回EPOLLRDHUP表示服务器读端关闭了；当epoll返回EPOLLHUP表示服务器读写端都关闭了。

3.3 消息到达

epoll（IO多路复用器）检测客户端fd的读事件。
当客户端发送数据到服务器的读缓冲区时，会发送信号给epoll（IO多路复用器），epoll（IO多路复用器）就会触发读事件，说明读缓冲区填充有数据；此时就可以调用recv/read函数操作IO。

3.4 消息发送

epoll（IO多路复用器）检测客户端fd的写事件。
当写缓冲区可写（即写缓冲区有空间可以写数据）时，它会发信号告诉epoll（IO多路复用器），epoll（IO多路复用器）触发写事件，这时调用send/write函数操作IO。

四、总结

一定要熟悉网络编程的四个关注点（建立连接、消息到达、消息发送、断开连接），深入理解操作IO和检测IO，这样才能很好的理解网络编程的源码，设计出高效的网络模型。
特别需要理解TCP的三次握手和四次挥手过程。