嵌入式Linux网络编程，I/O多路复用，epoll()示例，epoll()客户端，epoll()服务器，单链表

1，I/O多路复用 epoll()示例

1.1，epoll()—net.h

#ifndef __NET_H__
#define __NET_H__

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <strings.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/time.h>
#include <sys/select.h>
#include <sys/epoll.h>

#define SERV_IP_ADDR "192.168.31.100"
#define SERV_PORT 5002
#define BACKLOG 5
#define QUIT_STR "quite"
#define SERV_RESP_STR "Server:"

#endif

1.2，epoll()—client.c

/* ./client serv_ip serv_port */
#include "net.h"
#include "poll.h"

#define FDSIZE 25//epoll处理的文件描述符大小
#define EPOLLEVENTS 2 //epoll处理的时间个数

void usage(char *s)
{
	printf("Usage: %s <serv_ip> <serv_port>\n",s);
	printf("\tserv_ip: server ip address\n");
	printf("\tserv_port: server port(>5000)\n ");
}
void client_do_epoll(int fd);
int handle_epoll_enents(int epfd,struct epoll_event *ep_events,int nfds,int fd);
int main(int argc, const char *argv[])
{
	int fd;//fd用于创建socket fd
	short port;
	struct sockaddr_in sin;
	if(argc != 3)
	{
		usage((char *)argv[0]);
		exit(1);
	}
	if((port = atoi(argv[2])) < 5000)
	{
		usage((char *)argv[0]);
		exit(1);
	}
	/* 1 创建socket fd */
	if((fd = socket(AF_INET,SOCK_STREAM,0)) < 0)
	{
		perror("socket");
		exit(-1);
	}
	
	/* 2 连接服务器 */
	/* 2.1 填充struct sockaddr_in结构体变量*/
	bzero(&sin,sizeof(sin));
	sin.sin_family = AF_INET;
	sin.sin_port = htons(port);//转为网络字节序端口号
	if(inet_pton(AF_INET,argv[1],(void *)&sin.sin_addr.s_addr) < 0)
	{
		perror("inet_pton");
		goto _error1;
	}

	/* 2.2 连接服务器*/
	if(connect(fd,(struct sockaddr *)&sin,sizeof(sin)) < 0)
	{
		perror("connect");
		goto _error1;
	}
	printf("client staring ... OK!\n");

	client_do_epoll(fd);

_error1:
	close(fd);
	return 0;
}

void client_do_epoll(int fd)
{
	int epfd;//epfd用于生成epoll专用的文件描述符
	int nfds;//用于接受epoll_wait()返回的发生事件数
	struct epoll_event ep_ev,ep_events[EPOLLEVENTS];//申明epoll_event结构体变量，ep_ev用于注册事件，ep_events用于回传要处理的事件

	/*生成epoll的专用文件描述符*/
	epfd = epoll_create(FDSIZE);

	/*添加连接描述符，及要处理的事件*/
	ep_ev.data.fd = fd;
	ep_ev.events = EPOLLIN|EPOLLET;
	epoll_ctl(epfd,EPOLL_CTL_ADD,fd,&ep_ev);

	//添加标准输入描述符，及要处理的事件
	ep_ev.data.fd = STDIN_FILENO;
	ep_ev.events = EPOLLIN|EPOLLET;
	epoll_ctl(epfd,EPOLL_CTL_ADD,STDIN_FILENO,&ep_ev);
	
	while(1)
	{
		nfds = epoll_wait(epfd,ep_events,EPOLLEVENTS,-1);
		if(nfds < 0)
		{
			perror("epoll_wait");
			goto _error;
		}
		else if(nfds == 0)
		{
			printf("time out\n");
			continue;
		}
		if(handle_epoll_enents(epfd,ep_events,nfds,fd) < 0)
		{
			break ;
		}
	}
_error:
	close(epfd);
	close(fd);
}
int handle_epoll_enents(int epfd,struct epoll_event *ep_events,int nfds,int fd)
{
	char buf[BUFSIZ];
	int ret = -1;
	int i;
	for(i=0;i<nfds;++i)
	{
		if(ep_events[i].data.fd == fd)//服务器发送过来了数据
		{
			/* 读取套接字数据，处理 */
			bzero(buf,BUFSIZ);
			do 
			{
				ret = read(fd,buf,BUFSIZ-1);
			}while(ret <0 && EINTR == errno);
			if(ret < 0)
			{
				perror("read from socket");
				continue ;
			}
			if(ret == 0)//从套接字中读到的数据个数小于0，说明服务器关闭
			{
				return -1 ;
			}
			printf("server said: %s",buf);
			if((strlen(buf) > strlen(SERV_RESP_STR)) && strncasecmp(buf+strlen(SERV_RESP_STR),QUIT_STR,strlen(QUIT_STR)) == 0)
			{
				printf("sender client is existing!\n");
				break;
			}
		}
		else if(ep_events[i].events & EPOLLIN)//标准输入里面是不是有输入
		{
			/* 读取键盘输入，发送到网络套接字fd */
			bzero(buf,BUFSIZ);
			do 
			{
				//ret = read(STDIN_FILENO,buf,BUFSIZ-1);
				ret = read(ep_events[i].data.fd,buf,BUFSIZ-1);
			}while(ret <0 && EINTR == errno);
			if(ret < 0)
			{
				perror("read");
				continue ;
			}
			if(ret == 0)//没读到数据
			{
				continue;
			}
			if(write(fd,buf,strlen(buf)) < 0)
			{
				perror("write() to socket");
				continue ;
			}
			if(strncasecmp(buf,QUIT_STR,strlen(QUIT_STR)) == 0)//退出在发送之后
			{
				printf("client is existing!\n");
				return -1;
			}
		}
	}
	return 0;
}

1.3，epoll()—sever.c

#include "net.h"
#include "linklist.h"
#include <sys/ioctl.h>

#define EPFDSIZE 25//epoll处理的文件描述符大小
#define EPOLLEVENTS 20 //epoll处理的时间个数

/* IO多路复用select()处理函数 */
void sever_do_epoll(int fd);
void sever_do_write(datatype sin_data);
int epoll_ctl_add(int epfd,int fd,linklist fdlist,struct sockaddr_in cin);

int main(int argc, const char *argv[])
{
	int fd;
	struct sockaddr_in sin;//如果是IPV6的编程，要使用struct sockddr_in6结构体（详细情况请参考man 7 ipv6）,通常更通用的方法可以通过struct sockaddr_storage来编程

	/* 1 创建socket fd */
	if((fd = socket(AF_INET,SOCK_STREAM,0)) < 0)
	{
		perror("socket");
		exit(-1);
	}
	/* 优化 1 允许绑定地址快速重用 */ 
	int b_reuse = 1;
	setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,&b_reuse,sizeof(int)); 
	
	/* 2 绑定 */
	/* 2.1 填充struct sockaddr_in 结构体变量*/
	bzero(&sin,sizeof(sin));
	sin.sin_family = AF_INET;
	sin.sin_port = htons(SERV_PORT);
#if 1
	/* 优化 2 让服务器可以绑定在任意的IP上*/
	sin.sin_addr.s_addr = htonl(INADDR_ANY);
#else
	if(inet_pton(AF_INET,SERV_IP_ADDR,(void *)&sin.sin_addr.s_addr) < 0)
	{
		perror("inet_pton");
		goto _error1;
	}
#endif
	/* 2.2 绑定*/
	if(bind(fd,(struct sockaddr *)&sin,sizeof(sin)))
	{
		perror("bind");
		goto _error1;
	}

	/* 3 使用listen()把主动套接字变成被动套接字 */
	if(listen(fd,BACKLOG) < 0)
	{
		perror("listen");
		goto _error1;
	}
	
	sever_do_epoll(fd);

_error1:
	close(fd);
	return 0;
}

void sever_do_epoll(int fd)
{
	linklist fdlist,sin_list;//创建一个列表，用于文件描述符及客户端信息存储
	fdlist = create_linklist();
	datatype sin_data;//每个对象包括客户端的socket fd,ipv4地址，端口号
	sin_data.pfds.data.fd = fd;
	sin_data.pfds.events = EPOLLIN|EPOLLET;
	//struct timeval tout = {5,0};

	insert_end_linklist(fdlist,sin_data);//将lsten()处理后的fd加入列表
	//show_linklist(fdlist);
	
	int newfd = -1;
	int ret = -1;
	char buf[BUFSIZ];//BUFSIZ是系统提供的
	struct sockaddr_in cin;
	socklen_t cin_addr_len = sizeof(cin);

	int epfd;//epfd用于生成epoll专用的文件描述符
	int nfds;//用于接受epoll_wait()返回的发生事件数
	struct epoll_event ep_ev,ep_events[EPOLLEVENTS];//申明epoll_event结构体变量，ep_ev用于注册事件，ep_events用于回传要处理的事件

	/*生成epoll的专用文件描述符*/
	epfd = epoll_create(EPFDSIZE);

	/*添加连接描述符，及要处理的事件*/
	ep_ev.data.fd = fd;
	ep_ev.events = EPOLLIN|EPOLLET;
	epoll_ctl(epfd,EPOLL_CTL_ADD,fd,&ep_ev);
	/* 用epoll()函数实现I/O多路复用*/
	int i;
	while(1)
	{
		nfds = epoll_wait(epfd,ep_events,EPOLLEVENTS,-1);
		if(nfds == -1)
		{
			perror("epoll_wait");
			goto _error1;
		}
		else if(nfds == 0)
		{
			printf("time out!\n");
			goto _error1;
		}
		else
		{
			for(i=0;i<nfds;i++)	
			{
				if(ep_events[i].data.fd == fd)//有客户端发送了连接请求
				{
					if((newfd = accept(fd,(struct sockaddr *)&cin,&cin_addr_len)) < 0)
					{
						perror("connect");
						goto _error1;
					}
					/* 将分配成功的套接字newfd设置成非阻塞模式*/
					int b_on = 1;
					ioctl(newfd, FIONBIO, &b_on);//将分配成功的套接字newfd设置为非阻塞方式

					/* 添加新连接的客户端文件描述到epoll_event事件处理列表中
					 * 将新的客户端信息添加到链表fdlist中*/
					if(epoll_ctl_add(epfd,newfd,fdlist,cin) < 0)
					{
						goto _error2;
					}
				}
				else
				{
					if(ep_events[i].events & EPOLLIN)//有连接好的客户端发送了数据
					{
						sin_data.pfds.data.fd = ep_events[i].data.fd;	
						sin_list = get_list_locate_linklist(fdlist,sin_data);
						sin_data = sin_list->data;
						//printf("reading fd is ->(第 %d 个)(fd:%d)(ip:%s)(port:%d)\n",i,sin_data.pfds.fd,sin_data.ipv4_addr,sin_data.port);
						bzero(buf,BUFSIZ);
						do
						{
							ret = read(sin_data.pfds.data.fd,buf,BUFSIZ-1);
						}while(ret < 0 && errno == EINTR);//阻塞读写
						
						if(ret < 0)
						{
							perror("read");
							continue;
						}
						if(ret == 0)//对方已关闭
						{
							printf("client is existing!\n");
							delete_locate_linklist(fdlist,sin_data);//从链表中清除该客户端信息

							ep_ev.data.fd = ep_events[i].data.fd;
							epoll_ctl(epfd,EPOLL_CTL_DEL,ep_events[i].data.fd,&ep_ev);//将该客户端文件描述符从监听列表中清除
							continue;
						}

						/* 更新读入数据的客户端信息 */
						delete_locate_linklist(fdlist,sin_data);
						strncpy(sin_data.buf,buf,ret);
						insert_end_linklist(fdlist,sin_data);

						printf("client ip(:%s) port(:%d) fd(:%d) receive data: %s",sin_data.ipv4_addr,sin_data.port,sin_data.pfds.data.fd,sin_data.buf);

						/* 将输入事件改为输出事件*/
						ep_ev.data.fd = ep_events[i].data.fd;
						ep_ev.events = EPOLLOUT|EPOLLET;
						epoll_ctl(epfd,EPOLL_CTL_MOD,ep_events[i].data.fd,&ep_ev);

						//printf("client ip(:%s) port(:%d) fd(:%d) receive data: %s",sin_data.ipv4_addr,sin_data.port,sin_data.pfds.data.fd,buf);
					
						if(strncasecmp(buf,QUIT_STR,strlen(QUIT_STR)) == 0)
						{
							printf("client (fd:%d)(ip:%s)(potr:%d) is existing!\n",sin_data.pfds.data.fd,sin_data.ipv4_addr,sin_data.port);
							delete_locate_linklist(fdlist,sin_data);//将退出的客户端的fd从列表中删除

							ep_ev.data.fd = ep_events[i].data.fd;
							epoll_ctl(epfd,EPOLL_CTL_DEL,ep_events[i].data.fd,&ep_ev);//将该客户端文件描述符从监听列表中清除
							close(sin_data.pfds.data.fd);
							//show_linklist(fdlist);
						}
					}
					if(ep_events[i].events & EPOLLOUT)//向客户端发送数据
					{
						sin_data.pfds.data.fd = ep_events[i].data.fd;	
						sin_list = get_list_locate_linklist(fdlist,sin_data);
						sin_data = sin_list->data;
						//printf("reading fd is ->(第 %d 个)(fd:%d)(ip:%s)(port:%d)\n",i,sin_data.pfds.fd,sin_data.ipv4_addr,sin_data.port);

						sever_do_write(sin_data);
						/* 将输出事件改为输入事件*/
						ep_ev.data.fd = ep_events[i].data.fd;
						ep_ev.events = EPOLLIN|EPOLLET;
						epoll_ctl(epfd,EPOLL_CTL_MOD,ep_events[i].data.fd,&ep_ev);
					}
				}
			
			}

		}
	}

_error2:
	close(newfd);
_error1:
	close(fd);
	clear_linklist(fdlist);//将链表内存释放
}
void sever_do_write(datatype sin_data)
{
	int ret = -1;
	char resp_buf[BUFSIZ+55];

	bzero(resp_buf,BUFSIZ+55);
	strncpy(resp_buf,SERV_RESP_STR,strlen(SERV_RESP_STR));
	strcat(resp_buf,"ip(");
	strcat(resp_buf,sin_data.ipv4_addr);
	char s_port[10];
	strcat(resp_buf,"  port(");
	sprintf(s_port,"%d",sin_data.port);
	strcat(resp_buf,s_port);
	strcat(resp_buf,"  data(");
	strcat(resp_buf,sin_data.buf);
	do
	{
		ret = write(sin_data.pfds.data.fd,resp_buf,strlen(resp_buf));
	}while(ret < 0 && EINTR == errno);
}
int epoll_ctl_add(int epfd,int fd,linklist fdlist,struct sockaddr_in cin)
{
	datatype sin_data;
	struct epoll_event ep_ev;
	/* 添加新连接的客户端描述符到epoll_event处理事件列表中 */
	ep_ev.data.fd = fd;
	ep_ev.events = EPOLLIN|EPOLLET;
	epoll_ctl(epfd,EPOLL_CTL_ADD,fd,&ep_ev);
	
	/* 将连接成功后分配的客户端信息放入链表 */
	sin_data.pfds.data.fd = ep_ev.data.fd;
	sin_data.pfds.events = ep_ev.events;
	if(inet_ntop(AF_INET,&cin.sin_addr.s_addr,sin_data.ipv4_addr,sizeof(sin_data.ipv4_addr)) < 0)
	{
		perror("inet_ntop");
		return -1;
	}
	sin_data.port = ntohs(cin.sin_port);
	insert_end_linklist(fdlist,sin_data);//将建立客户端连接的fd加入列表

	printf("get a new client->(ip:%s)(port:%d)(fd:%d)\n",sin_data.ipv4_addr,sin_data.port,sin_data.pfds.data.fd);
	return 0;
}

1.4，epoll()—linklist.h

#ifndef __SINGLE_LINKLIST_H__
#define __SINGLE_LINKLIST_H__

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <strings.h>
#include <sys/epoll.h>

typedef struct{
	struct epoll_event pfds;
	char ipv4_addr[16];
	int port;
	char buf[BUFSIZ];
}datatype;

typedef struct node{
	datatype data;
	struct node *next;
}listnode,*linklist;

linklist create_linklist(void);
linklist create_n_linklist(void);
int delete_pos_linklist(linklist L,int pos);
int delete_locate_linklist(linklist L,datatype x);
void clear_linklist(linklist L);

int get_length_linklist(linklist L);
linklist get_list_pos_linklist(linklist L,int pos);
linklist get_list_locate_linklist(linklist L,datatype x);

int insert_head_linklist(linklist L,datatype x);
int insert_n_head_linklist(linklist L);
int insert_end_linklist(linklist L,datatype x);
int insert_n_end_linklist(linklist L);
int insert_pos_linklist(linklist L,datatype x,int pos);
int insert_order_linklist(linklist L,datatype x);

void reverse_linklist(linklist);
void sort_linklist(linklist L);

void show_linklist(linklist L);

#endif

1.5，epoll()—linklist.c

#include "linklist.h"

linklist create_linklist(void)
{
	linklist L;
	if((L=(linklist)malloc(sizeof(listnode))) == NULL)
	{
		printf("malloc no memmory!\n");
		return NULL;
	}
	L->data.pfds.data.fd = 0;
	bzero(L->data.ipv4_addr,sizeof(L->data.ipv4_addr));
	L->data.port = 0;

	L->next = NULL;
	return L;
}
linklist create_n_linklist(void)
{
	linklist L,H,r;
	datatype x;
	if((L=(linklist)malloc(sizeof(listnode))) == NULL)
	{
		printf("malloc no memmory!\n");
		return NULL;
	}
	L->data.pfds.data.fd = 0;
	bzero(L->data.ipv4_addr,sizeof(L->data.ipv4_addr));
	L->data.port = 0;
	L->next = NULL;
	r = L;
	while(1)
	{
		printf("Please input a NUM_NL80211_WOWLAN_TRIGber(-1 exit :");
		while(scanf("%d",&x.pfds.data.fd) != 1)
		{
			printf("Please INPUT_PROP_CNTut a number(-1 exit :");
			getchar();
		}

		if(x.pfds.data.fd == -1)break;

		if((H=(linklist)malloc(sizeof(listnode))) == NULL)
		{
			printf("malloc nexto memmory!\n");
			return L;
		}
		H->data = x;
		H->next = NULL;
		r->next = H;
		r=H;
	}
	return L;
}
int delete_pos_linklist(linklist L,int pos)
{
	linklist r,p;
	int i=-1;
	if(pos < 0 ||pos >=get_length_linklist(L))
	{
		printf("input pos is invalid!\n");
		return -1;
	}
	r = L;
	while(i < pos-1)
	{
		i++;
		r = r->next;
	}
	if(r == NULL || r->next==NULL)
	{
		printf("argc is iavalid!\n");
		return -1;
	}
	else
	{
		p = r->next;
		r->next = p->next;
		p->next = NULL;
		free(p);
		return 0;
	}
}
int delete_locate_linklist(linklist L,datatype x)
{
	linklist r,p;
	if(L->next == NULL)
	{
		printf("list is NULL!\n");
		return -1;
	}
	r = L;
	while(r->next->data.pfds.data.fd != x.pfds.data.fd)
	{
		if(r->next == NULL)
		{
			printf("value is not in list!\n");
			return -1;
		}
		r = r->next;
	}
	p = r->next;
	r->next = p->next;
	p->next = NULL;
	free(p);
	p = NULL;

	return 0;
}

void clear_linklist(linklist L)
{
	while(get_length_linklist(L))
	{
		delete_pos_linklist(L,get_length_linklist(L)-1);
	}
	L->next = NULL;
	free(L);
	L = NULL;
}
int get_length_linklist(linklist L)
{
	int i=0;
	linklist r;
	r = L;
	while(r->next)
	{
		r = r->next;
		i++;
	}
	return i++;
}
linklist get_list_pos_linklist(linklist L,int pos)
{
	int i=0;
	linklist r;
	if(L->next == NULL)
	{
		printf("list is NULL!\n");
		return NULL;
	}
	if(pos<0 || pos>=get_length_linklist(L))
	{
		printf("input is invalid!\n");
		return NULL;
	}
	r = L->next;
	while(i<pos)
	{
		r = r->next;
		i++;
	}
	return r;
}
linklist get_list_locate_linklist(linklist L,datatype x)
{
	linklist r;
	if(L->next == NULL)
	{
		printf("list is NULL!\n");
		return NULL;
	}
	r = L->next;
	while(r->data.pfds.data.fd != x.pfds.data.fd)
	{
		if(r->next == NULL)
		{
			printf("value is not in list!\n");
			return NULL;
		}
		r = r->next;
	}
	return r;
}

int insert_head_linklist(linklist L,datatype x)
{
	linklist H;
	if((H=(linklist)malloc(sizeof(listnode))) == NULL)
	{
		printf("malloc no memmory\n");
		return -1;
	}
	H->data = x;
	H->next = L->next;
	L->next = H;
	return 0;
}
int insert_n_head_linklist(linklist L)
{
	datatype x;

	while(1)
	{
		printf("Please input a number(-1 exit:");
		while(scanf("%d",&x.pfds.data.fd) != 1)
		{
			printf("Please input a number:(-1 exit");
			getchar();
		}
		if(x.pfds.data.fd == -1)break;
		insert_head_linklist(L,x);
	}
	return 0;
}
int insert_end_linklist(linklist L,datatype x)
{
	linklist r,H;
	if((H = (linklist)malloc(sizeof(listnode))) == NULL)
	{
		printf("malloc no memmory!");
		return -1;
	}
	r = L;
	while(r->next)
	{
		r = r->next;
	}
	H->next = NULL;
	H->data = x;
	r->next = H;
	return 0;
}
int insert_n_end_linklist(linklist L)
{
	datatype x;

	while(1)
	{
		printf("Please input a number(-1 exit:");
		while(scanf("%d",&x.pfds.data.fd) != 1)
		{
			printf("Please input a number:(-1 exit");
			getchar();
		}
		if(x.pfds.data.fd == -1)break;
		insert_end_linklist(L,x);
	}
	return 0;

}
int insert_pos_linklist(linklist L,datatype x,int pos)
{
	linklist K,r;
	if(pos == 0)
	{
		r = L;
	}
	else
	{
		r = get_list_pos_linklist(L,pos-1);
	}
	if(r == NULL)
	{
		printf("argc is invalidateid!\n");
		return -1;
	}
	else
	{
		if((K = (linklist)malloc(sizeof(listnode))) == NULL)
		{
			printf("malloc no memmory!");
			return -1;
													}
		K->data = x;
		K->next = r->next;
		r->next = K;
	}
	return 0;
}
int insert_order_linklist(linklist L,datatype x)
{
	linklist r,H;
	if((H = (linklist)malloc(sizeof(listnode))) == NULL)
	{
		printf("malloc nexto memmory!\n");
		return -1;
	}
	H->data = x;

	r = L;
	while(r->next && r->next->data.pfds.data.fd < x.pfds.data.fd)
	{
		r = r->next;
	}
	H->next = r->next;
	r->next = H;
	return 0;
}
void reverse_linklist(linklist L)
{
	linklist r,p;

	if(L->next == NULL)
	{
		printf("list is NULL!\n");
		return ;
	}

	r = L->next;
	L->next = NULL;
	while(r)
	{
		p = r;
		r = r->next;

		p->next = L->next;
		L->next = p;
	}
	return ;
}
void sort_linklist(linklist L)
{
	linklist r,p,q;
	if(L == NULL)
	{
		printf("list is NULL!\n");
		return ;
	}
	r = L->next;
	L->next = NULL;
	while(r)
	{
		p = r;
		r = r->next;

		q = L;
		while(q->next && q->next->data.pfds.data.fd < p->data.pfds.data.fd)
		{
			q = q->next;
		}
		p->next = q->next;
		q->next = p;
	}
}

void show_linklist(linklist L)
{
	printf("list is:\n");
	if(L->next == NULL)
	{
		printf("\tlist is NULL!list\n");
		return ;
	}
	while(L->next)
	{
		printf("\t%d %s %d\t",L->next->data.pfds.data.fd,L->next->data.ipv4_addr,L->next->data.port);
		L = L->next;
		puts("");
	}
	//puts("");
	return ;
}