epoll简单注释

#include <stdio.h>  
#include <stdlib.h>  
#include <unistd.h>  
#include <errno.h>  
#include <sys/socket.h>  
#include <netdb.h>  
#include <fcntl.h>  
#include <sys/epoll.h>  
#include <string.h>  

#define MAXEVENTS 64  

//函数:  
//功能:创建和绑定一个TCP socket  
//参数:端口  
//返回值:创建的socket  
static int
create_and_bind(char *port)
{
	struct addrinfo hints;
	struct addrinfo *result, *rp;
	int s, sfd;

	memset(&hints, 0, sizeof (struct addrinfo));                                    //清零
	hints.ai_family = AF_UNSPEC;     /* Return IPv4 and IPv6 choices */
	hints.ai_socktype = SOCK_STREAM; /* We want a TCP socket */
	hints.ai_flags = AI_PASSIVE;     /* All interfaces */

	s = getaddrinfo(NULL, port, &hints, &result);                                 //通过port转换为与hints类型相同的指针指向结果 返回非零出错
	if (s != 0)
	{
		fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(s));
		return -1;
	}

	for (rp = result; rp != NULL; rp = rp->ai_next)
	{
		sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
		if (sfd == -1)
			continue;

		s = bind(sfd, rp->ai_addr, rp->ai_addrlen);
		if (s == 0)
		{
			/* We managed to bind successfully! */             //绑定完成，退出for循环
			break;
		}

		close(sfd);
	}

	if (rp == NULL)                                          //如果成功，当前rp一定不为null 
	{
		fprintf(stderr, "Could not bind\n");
		return -1;
	}

	freeaddrinfo(result);                                  //释放下内存
	 
	return sfd;                                           //返回绑定的文件描述符
}


//函数  
//功能:设置socket为非阻塞的  
static int
make_socket_non_blocking(int sfd)
{
	int flags, s;

	//得到文件状态标志  
	flags = fcntl(sfd, F_GETFL, 0);
	if (flags == -1)
	{
		perror("fcntl");
		return -1;
	}

	//设置文件状态标志  
	flags |= O_NONBLOCK;
	s = fcntl(sfd, F_SETFL, flags);
	if (s == -1)
	{
		perror("fcntl");
		return -1;
	}

	return 0;
}

//端口由参数argv[1]指定  
int
main(int argc, char *argv[])
{
	int sfd, s;
	int efd;
	struct epoll_event event;
	struct epoll_event *events;

	if (argc != 2)
	{
		fprintf(stderr, "Usage: %s [port]\n", argv[0]);
		exit(EXIT_FAILURE);
	}

	sfd = create_and_bind(argv[1]);                                             //根据端口号创建一个socket并绑定，返回绑定的文件句柄
	if (sfd == -1)
		abort();

	s = make_socket_non_blocking(sfd);                                          //使绑定的文件描述符设置为非堵塞模式
	if (s == -1)
		abort();

	s = listen(sfd, SOMAXCONN);                                                //打开监听，队列长度为64 
	if (s == -1)
	{
		perror("listen");
		abort();
	}

	//除了参数size被忽略外,此函数和epoll_create完全相同  
	efd = epoll_create1(0);                                                    //创建epoll,返回一个文件描述符
	if (efd == -1)
	{
		perror("epoll_create");
		abort();
	}

	event.data.fd = sfd;													 //定义事件为上面绑定的文件描述符
	event.events = EPOLLIN | EPOLLET;										//关注读入,边缘触发方式				
	s = epoll_ctl(efd, EPOLL_CTL_ADD, sfd, &event);                          //将上面关注事件添加入epoll扫描队列
	if (s == -1)
	{
		perror("epoll_ctl");
		abort();
	}

	/* Buffer where events are returned */
	events = calloc(MAXEVENTS, sizeof event);                              //在内存上动态分配64个event大小的空间储存事件

	/* The event loop */
	while (1)
	{
		int n, i;

		n = epoll_wait(efd, events, MAXEVENTS, -1);                       //返回一个关注事件的数量，符合条件的事件保存在events指向的内存中
		for (i = 0; i < n; i++)
		{
			if ((events[i].events & EPOLLERR) ||                          //如果挂断
				(events[i].events & EPOLLHUP) ||						  //挂起
				(!(events[i].events & EPOLLIN)))						  //可以读	
			{
				/* An error has occured on this fd, or the socket is not
				ready for reading (why were we notified then?) */
				fprintf(stderr, "epoll error\n");                          //认定为出错。关闭当前文件描述符
				close(events[i].data.fd);
				continue;                                                  //结束当前循环，进入下个循环
			}

			else if (sfd == events[i].data.fd)                             //如果有新的连接
			{
				/* We have a notification on the listening socket, which
				means one or more incoming connections. */
				while (1)
				{
					struct sockaddr in_addr;                               //申请一个结构体去保存新客户端的socket地址
					socklen_t in_len;                                      //保存长度
					int infd;                                              //保存新来的文件描述符
					char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];                //申请数组         

					in_len = sizeof (in_addr);                              //保存长度
					infd = accept(sfd, &in_addr, &in_len);                  //非堵塞接收绑定文件描述符，并保存到in_addr指向内存中。长度，保存在in_len中  
					if (infd == -1)                                         //返回值为-1证明接受有错误
					{
						if ((errno == EAGAIN) ||
							(errno == EWOULDBLOCK))
						{
							/* We have processed all incoming
							connections. */
							break;
						}
						else
						{
							perror("accept");                               
							break;
						}
					}

					//将地址转化为主机名或者服务名  
					s = getnameinfo(&in_addr, in_len,
						hbuf, sizeof( hbuf),
						sbuf, sizeof (sbuf),
						NI_NUMERICHOST | NI_NUMERICSERV);                                   //flag参数:以数字名返回  //主机地址和服务地址  
					

					if (s == 0)
					{
						printf("Accepted connection on descriptor %d "
							"(host=%s, port=%s)\n", infd, hbuf, sbuf);
					}

					/* Make the incoming socket non-blocking and add it to the
					list of fds to monitor. */
					s = make_socket_non_blocking(infd);                                    //将客户端文件描述符设置为非堵塞
					if (s == -1)
						abort();

					event.data.fd = infd;
					event.events = EPOLLIN | EPOLLET;
					s = epoll_ctl(efd, EPOLL_CTL_ADD, infd, &event);                      //添加到扫描队列中
					if (s == -1)
					{
						perror("epoll_ctl");
						abort();
					}
				}
				continue;
			}
			else                                                                       //有数据需要读取
			{
				/* We have data on the fd waiting to be read. Read and
				display it. We must read whatever data is available
				completely, as we are running in edge-triggered mode
				and won't get a notification again for the same
				data. */
				int done = 0;                                                         //标志位  有没有完成

				while (1)
				{
					ssize_t count;                                                         
					char buf[512];

					count = read(events[i].data.fd, buf, sizeof(buf));                            //读取从绑定的文件描述符读取数据
					if (count == -1)                                                             //读取错误
					{
						/* If errno == EAGAIN, that means we have read all
						data. So go back to the main loop. */
						if (errno != EAGAIN)
						{
							perror("read");
							done = 1;
						}
						break;
					}
					else if (count == 0)                                                        //只要还有数据。while会一直读取 ，直到返回0 ，返回0证明读取完毕
					{
						/* End of file. The remote has closed the
						connection. */
						done = 1;                                                               //设置标志位读取完成为1 
						break;
					}

					/* Write the buffer to standard output */
					s = write(1, buf, count);
					if (s == -1)
					{
						perror("write");
						abort();
					}
				}

				if (done)
				{
					printf("Closed connection on descriptor %d\n",
						events[i].data.fd);                                             //读取完成
					/* Closing the descriptor will make epoll remove it
					from the set of descriptors which are monitored. */
					close(events[i].data.fd);                                           //关闭文件描述符
				}
			}
		}
	}

	free(events);                                                                      //释放相应空间

	close(sfd);

	return EXIT_SUCCESS;
}

新手笔记    源代码在http://blog.csdn.net/xiajun07061225/article/details/9250579