AI导航网
微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

socket epoll网络编程实例

分类：C&C++作者：墨痕诉清风原文地址

总结了各个博主的经验，写出了简单的demo，实例为ET模式，转载请写明出处，如有宝贵意见请留言。

 

第一版：

服务端：

#include <stdio.h>
#include <sys/epoll.h>
#include <stdlib.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/resource.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>


#define MAXBUF 1024
#define MAXEPOLLSIZE 10000


int main(int argc,char *argv[])
{
	//设置端口
	if(argc != 2)
	{  
		printf("请设置端口号！\n");
	}
	int port = atoi(argv[1]);  
	
	int listener,conn_sock,kdpfd,nfds,n,ret,curfds;
	socklen_t len;
	struct sockaddr_in server_addr,client_addr;
	struct epoll_event ev;
	struct epoll_event pevent[MAXEPOLLSIZE];
	struct rlimit rt;
	rt.rlim_max = rt.rlim_cur = MAXEPOLLSIZE;
	
	//设置系统资源，打开最大文件数
	if (setrlimit(RLIMIT_NOFILE,&rt) == -1)
	{
		perror("setrlimit");
		exit(EXIT_FAILURE);
	}
	else
	{
		printf("设置系统资源参数成功！\n");
	}
	
	//创建socket
	if( (listener = socket(AF_INET,SOCK_STREAM,0)) == -1)
	{
		perror("socket");
		exit(EXIT_FAILURE);
	}
	else
	{
		printf("socket 创建成功！\n");
	}
	
	//设置非堵塞
	if (fcntl(listener,F_SETFL,fcntl(listener,F_GETFL,0) | O_NONBLOCK) == -1)
	{
		perror("fcntl");
		exit(EXIT_FAILURE);
	}
	
	bzero(&server_addr,sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(port);
	server_addr.sin_addr.s_addr = INADDR_ANY;  //0.0.0.0所有地址
	
	//绑定
	if ( bind( listener,(struct sockaddr*)&server_addr,sizeof(struct sockaddr)) == -1 )
	{
		perror("bind");
		exit(EXIT_FAILURE);
	}
	else
	{
		printf("IP 地址和端口绑定成功\n");
	}
	
	if (listen(listener,10) == -1)
	{
		perror("listen");
		exit(EXIT_FAILURE);
	}
	else
	{
		printf("开启服务成功！\n");
	}

	//创建epoll为ET模式
	kdpfd = epoll_create(MAXEPOLLSIZE);
	len = sizeof(struct sockaddr_in);
	ev.events = EPOLLIN | EPOLLET;
	ev.data.fd = listener;
	
	//socket加入epoll
	if( epoll_ctl(kdpfd,EPOLL_CTL_ADD,listener,&ev) < 0 )
	{
		fprintf( stderr,"epoll set insertion error: fd=%d\n",listener );
		exit(EXIT_FAILURE);
	}
	else
	{
		printf("监听 socket 加入 epoll 成功！\n");
	}
	
	//设置延迟和事件个数,事件由累加完成
	curfds = 1;
	//int timeout = 10*1000;
	while(1)
	{
		//等待有事件发生
		//nfds = epoll_wait(kdpfd,pevent,curfds,timeout);
		nfds = epoll_wait(kdpfd,-1);
		if( nfds == -1 )
		{
			perror("epoll_wait");
			break;
		}
		else if (nfds == 0)
		{
			printf("waiting for connecting...\n");
			continue;
		}
		
		for (n = 0; n < nfds; ++n)
		{
			if ((pevent[n].events & EPOLLERR) || (pevent[n].events & EPOLLHUP) || (!(pevent[n].events & EPOLLIN)))
			{
				//此FD上发生错误，或者套接字未准备好读取（那么为什么通知我们？）
				fprintf (stderr,"epoll error\n");
				close(pevent[n].data.fd);
				continue;
			}
			else if (pevent[n].data.fd == listener)
			{
				//我们在监听套接字上有一个通知,这意味着一个或多个传入连接
				while (1)
				{
					conn_sock = accept(listener,(struct sockaddr*)&client_addr,&len);
					if( conn_sock == -1 )
					{
						if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
						{
							//我们已经处理了所有传入的连接
							break;
						}
						else
						{
							perror ("accept error");
							break;
						}
					}
					//else	
					//	printf("有连接来自于： %s:%d， 分配的 socket 为:%d\n",inet_ntoa(client_addr.sin_addr),ntohs(client_addr.sin_port),conn_sock);
					
					char hbuf[1024],sbuf[1024];
					if ( 0 == getnameinfo((struct sockaddr*)&client_addr,len,hbuf,sizeof(hbuf),sbuf,sizeof(sbuf),NI_NUMERICHOST | NI_NUMERICSERV))
						printf("Accepted connection on descriptor %d (host=%s,port=%s)\n",sbuf);
					
					if (fcntl(conn_sock,fcntl(conn_sock,0) | O_NONBLOCK) == -1)
					{
						perror("fcntl");
						break;
					}

					ev.events = EPOLLIN | EPOLLET;
					ev.data.fd = conn_sock;
					
					if( -1 == epoll_ctl( kdpfd,&ev))
					{
						fprintf(stderr,"把 socket '%d' 加入 epoll 失败！%s\n",strerror(errno));
						exit(EXIT_FAILURE);
					}
					
					curfds ++;					
				}
				continue;
			}
			else
			{
				if (do_use_fd(pevent[n].data.fd) < 0)
				{
					printf ("关闭 %d\n",pevent[n].data.fd);					
					epoll_ctl(kdpfd,EPOLL_CTL_DEL,pevent[n].data.fd,&ev);
                    close(pevent[n].data.fd);
					curfds--;
				}
			}
		}
	}
	
	close(listener);
	close(kdpfd);
	return 0;
}

int do_use_fd(int connfd)
{
	int done = 0;
	
	while(1)
	{
		char buf[MAXBUF + 1];
		bzero(buf,MAXBUF + 1);
		int nread;
		
		//读取客户端socket流
		nread = recv(connfd,buf,MAXBUF,0);
		if (nread == -1)
		{
			if (errno != EAGAIN)
			{
				perror ("recv");
				done = -1;
			}
			break;
		}
		else if (nread == 0)
		{
			done = -1;
			break;
		}
		
		printf("%d接收消息成功:'%s'，共%d个字节的数据\n",connfd,nread);
		
		//响应客户端 
		if ( -1 == send(connfd,strlen(buf),0))
			perror ("write");
	}

    return done;
}

 

第二版：

.h

#ifndef _INITNETWORK_H_
#define _INITNETWORK_H_

#include <stdio.h>
#include <sys/epoll.h>
#include <stdlib.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/resource.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <pthread.h>


#define MAXBUF 1024
#define MAXEPOLLSIZE 10000


typedef struct SOCKET_EPOLL_PAR{
	int                listener;              //socket句柄
	int                port;                  //socket端口
	int                kdpfd;                 //epoll句柄
	int                curfds;                //socket连接个数
	socklen_t          len;                   //len = sizeof(struct sockaddr_in);
	struct epoll_event ev;                    //epoll 模式
	int                fd;                    //当前事件
	struct epoll_event pevent[MAXEPOLLSIZE];  //事件数集合
}SEPAR;

static void *thread_conn(void *arg);
static void *thread_do_use_fd(void *arg);
int init_system_res();
int init_socket(int *listener,int *port);
int init_epoll(SEPAR *se_par);
void run_network(int port);
int close_network(int listener,int kdpfd);


#endif

.c

#include "initnetwork.h"


void *thread_conn(void *arg)
{
	SEPAR *pse_par = (SEPAR*)arg;
	
	struct sockaddr_in client_addr;
	
	while (1)
	{	
		int conn_sock = accept(pse_par->listener,&(pse_par->len));
		if( conn_sock == -1 )
		{
			if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
			{
				//我们已经处理了所有传入的连接
				break;
			}
			else
			{
				perror ("accept error");
				break;
			}
		}
		
		char hbuf[1024],sbuf[1024];
		if ( 0 == getnameinfo((struct sockaddr*)&client_addr,pse_par->len,NI_NUMERICHOST | NI_NUMERICSERV))
			printf("Accepted connection on descriptor %d (host=%s,sbuf);
		
		if (fcntl(conn_sock,0) | O_NONBLOCK) == -1)
		{
			perror("fcntl");
			break;
		}

		pse_par->ev.events = EPOLLIN | EPOLLET;
		pse_par->ev.data.fd = conn_sock;
		
		if( -1 == epoll_ctl( pse_par->kdpfd,&(pse_par->ev)))
		{
			fprintf(stderr,strerror(errno));
			exit(EXIT_FAILURE);
		}
		
		pse_par->curfds++;
		printf ("conn curfds: %d\n",pse_par->curfds);
	}
}


void *thread_do_use_fd(void *arg)
{
	SEPAR *pse_par = (SEPAR*)arg;
	int done = 0;
	
	int conn_fd = pse_par->pevent[pse_par->fd].data.fd;
	
	while(1)
	{
		char buf[MAXBUF + 1];
		bzero(buf,MAXBUF + 1);
		int nread;
		
		//读取客户端socket流
		nread = recv(conn_fd,conn_fd,nread);
		
		//响应客户端 
		if ( -1 == send(conn_fd,0))
			perror ("write");
	}

	if (done < 0)
	{
		printf ("关闭 %d\n",conn_fd);
		epoll_ctl(pse_par->kdpfd,&(pse_par->ev));
		close(conn_fd);
		pse_par->curfds--;
		printf ("close curfds: %d\n",pse_par->curfds);
	}
}


int init_system_res()
{
	struct rlimit rt;
	rt.rlim_max = rt.rlim_cur = MAXEPOLLSIZE;
	if (setrlimit(RLIMIT_NOFILE,&rt) == -1)
	{
		perror("setrlimit");
		return -1;
	}
	else
		printf("设置系统资源参数成功！\n");
	
	return 0;
}


int init_socket(int *listener,int *port)
{
	//创建socket
	if( (*listener = socket(AF_INET,0)) == -1)
	{
		perror("socket");
		return -1;
	}
	else
		printf("socket 创建成功！\n");
	
	//设置非堵塞
	if (fcntl(*listener,fcntl(*listener,0) | O_NONBLOCK) == -1)
	{
		perror("fcntl");
		return -1;
	}
	
	struct sockaddr_in server_addr;
	bzero(&server_addr,sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(*port);
	server_addr.sin_addr.s_addr = INADDR_ANY;  //0.0.0.0所有地址
	
	//绑定
	if (bind( *listener,sizeof(struct sockaddr)) == -1 )
	{
		perror("bind");
		return -1;
	}
	else
		printf("IP 地址和端口绑定成功\n");
	
	//监听
	if (listen( *listener,MAXEPOLLSIZE) == -1)
	{
		perror("listen");
		return -1;
	}
	else
		printf("开启服务成功！\n");
	
	return 0;
}


int init_epoll(SEPAR *se_par)
{
	//创建epoll为ET模式
	se_par->kdpfd = epoll_create(MAXEPOLLSIZE);
	se_par->len = sizeof(struct sockaddr_in);
	se_par->ev.events = EPOLLIN | EPOLLET;
	se_par->ev.data.fd = se_par->listener;
	
	//socket加入epoll
	if( epoll_ctl(se_par->kdpfd,se_par->listener,&(se_par->ev)) < 0 )
	{
		fprintf( stderr,se_par->listener );
		return -1;
	}
	else
		printf("监听 socket 加入 epoll 成功！\n");
	
	return 0;
}


void run_network(int port)
{
	SEPAR se_par;
	int nfds,n;
	
	se_par.port = port;
	
	//设置系统资源，打开最大文件数
	if(init_system_res() == -1)
		abort();
	
	//初始化网络
	if (init_socket(&se_par.listener,&se_par.port) == -1)
		abort();

	//创建epoll并添加socket
	if (init_epoll(&se_par) == -1)
		abort();
	
	//设置延迟和事件个数,事件由累加完成
	se_par.curfds = 1;
	//int timeout = 10*1000;
	while(1)
	{
		//等待有事件发生
		//nfds = epoll_wait(kdpfd,timeout);
		nfds = epoll_wait(se_par.kdpfd,se_par.pevent,se_par.curfds,-1);
		if( nfds == -1 )
		{
			perror("epoll_wait");
			break;
		}
		else if (nfds == 0)
		{
			printf("waiting for connecting...\n");
			continue;
		}
		
		for (n = 0; n < nfds; ++n)
		{
			if ((se_par.pevent[n].events & EPOLLERR) || (se_par.pevent[n].events & EPOLLHUP) || (!(se_par.pevent[n].events & EPOLLIN)))
			{
				//此FD上发生错误，或者套接字未准备好读取（那么为什么通知我们？）
				fprintf (stderr,"epoll error\n");
				close(se_par.pevent[n].data.fd);
				continue;
			}
			else if (se_par.pevent[n].data.fd == se_par.listener)
			{
				//我们在监听套接字上有一个通知,这意味着一个或多个传入连接				
				pthread_t tid;
				int ret = pthread_create(&tid,NULL,thread_conn,(void*)&se_par);
				if (ret != 0)
					printf ("创建epoll连接线程出错！");
				
				continue;
			}
			else
			{
				//处理事件
				pthread_t tid;
				se_par.fd = n;
				int ret = pthread_create(&tid,thread_do_use_fd,(void*)&se_par);
				if (ret != 0)
					printf ("创建epoll事件线程出错！");
			}
		}
	}
	
	if (close_network(se_par.listener,se_par.kdpfd) == -1)
		abort();
}


int close_network(int listener,int kdpfd)
{
	if (close(listener) == -1)
	{
		perror ("close listener");
		return -1;
	}
	
	if (close(kdpfd) == -1)
	{
		perror ("close kdpfd");
		return -1;
	}
	
	return 0;
}

 

 

 

测试客户端：

/*
 * *   socket简单编程 客户端
 *  */
 
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
 
#define BUFFSIZE 1024
 
int main(int argc,char *argv[])
{
    int client_sockfd = 0;
    int len = 0;
    struct sockaddr_in server_addr;
    char buf[BUFFSIZE] = {0};
    bzero(&server_addr,sizeof(struct sockaddr_in));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    server_addr.sin_port = htons(8080);
 
    if((client_sockfd = socket(AF_INET,0)) < 0)
    {
        perror("socket error!\n");
        return -1;
    }
 
    if(connect(client_sockfd,sizeof(struct sockaddr)) < 0)
    {
        perror("client error!\n");
        return -1;
    }
 
    printf("connect success!\n");
 
//    len = recv(client_sockfd,BUFFSIZE,0);
//    buf[len] = '\0';
//    printf("client_buf = %s\n",buf);
 
   while(1)
    {
        printf("Enter string to send:");
		bzero(buf,sizeof(buf));
        scanf("%s",buf);
        if(!strcmp(buf,"quit"))
        {
            break;
        }
 
        len = send(client_sockfd,0);
		bzero(buf,sizeof(buf));
        len = recv(client_sockfd,0);
        buf[len] = '\0';
        printf("received: %s\n",buf);
    }
 
    close(client_sockfd);
 
    return 0;
}

 

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 [email protected] 举报，一经查实，本站将立刻删除。

相关推荐

宿舍管理系统——单链表+结构体实现入住、退房和查询功能（C语言版）
本程序的编译和运行环境如下（如果有运行方面的问题欢迎在评论区留言，也欢迎直接加QQ：2961439733，备注博客园或CSDN即可）： 编辑工具：Dev-C++（版本：5.11.0.0） 编译器：TDM-GCC&#160;4.9.2&#1...
使用Windows API 编写按行分配的计算矩阵向量相乘的并行程序
水了一学期的院选修，万万没想到期末考试还有比较硬核的编程题，居然还涉及到多线程了，而且是调用Windows接口函数写多线程。虽然学汇编的时候有所了解，但毕竟没尝试过，思来想去，写出了下面的蹩脚代码，不足之处还...
C语言实现一个走迷宫小游戏（深度优先算法）
补充一下，先前文章末尾给出的下载链接的完整代码含有部分C++的语法（使用Dev-C++并且文件扩展名为.cpp的没有影响），如果有的朋友使用的语言标准是VC6的话可能不支持，所以在修改过后再上传一版，这...
模N取余法实现大整数进制转换 ——C语言版（2-16进制均可）
思路如标题所说采用模N取余法，难点是这个除法过程如何实现。 个人推荐先到这篇博客学习一下，大佬的思路就是不一样：大数除法——超详细讲解 我所做的就是在上面博文代码的基础上增加了循环，用一个字符数组逆序存储...
C语言输出格式工整的日历——2乘6样式（详见本文）
本篇博客有更新！！！更新后效果图如下： 文章末尾的完整代码如不能在Dev-C++上完好运行，出现如下问题： E:\Dev-Cpp\源代码\万年历.c [Error] &#39;for&#39; loop initial declaration...
通过调试来理解形参与实参的区别
刚开始学习模块化程序设计时，估计大家都被形参和实参搞迷糊过，尤其是遇到形参名和实参名一样时，更加晕头转向，出现一种“是谁把值传给了我，而我又传给了谁”的疑惑。我也有过类似的迷茫，更是被其他初学的同学问...
C# Task 实现任务超时取消、超时取消然后重试 超过重试最大次数就结束。
任务超时取消 示例 public static async Task TimeoutCancelTask() { CancellationTokenSource cts = new CancellationTokenSource();//取消令牌 Task task = DoAction(cts);
Task 笔记
### 1.计时器类Stopwatch ``` Stopwatch stopwatch=new Stopwatch() stopwatch.Start();//开始计时 stopwatch.Stop();//停止计时 stopwatch.Reset();//重置计时时间 stopwatch.Rest
MindSpore自定义算子中的张量维度问题
当我们使用GPU进行快速运算时，虽然可以用成熟的深度学习框架如MindSpore和PyTorch等进行实现，但其实从速度上来说，最快不过直接使用C/C++的CUDA来实现。也正是因为如此，在MindSpore框架中支持了对CUDA实现...
CUDA指针数组Kernel函数
继上一篇文章学习使用C++存储一个不规则二维数组之后，这里介绍如何在C语言版的CUDA中实现一个不规则的二维数组。总体的实现思路跟前面一篇文章一样，使用了一个二维的指针数组来存储。其中主要的不同点大概...