Linux网络编程——tcp并发服务器（epoll实现）

转载：http://blog.csdn.net/lianghe_work/article/details/46551871

通过epoll实现tcp并发回执服务器（客户端给服务器发啥，服务器就给客户端回啥）

代码如下：

[csharp]  view plain  copy

1. #include <string.h>  
2. #include <stdio.h>  
3. #include <stdlib.h>  
4. #include <unistd.h>  
5. #include <sys/select.h>  
6. #include <sys/time.h>  
7. #include <sys/socket.h>  
8. #include <netinet/in.h>  
9. #include <arpa/inet.h>  
10. #include <sys/epoll.h>  
11. #include <errno.h>  
12. #define OPEN_MAX 100  
13.   
14. int main(int argc, char *argv[])  
15. {  
16.     struct epoll_event event;   // 告诉内核要监听什么事件    
17.     struct epoll_event wait_event; //内核监听完的结果  
18.       
19.     //1.创建tcp监听套接字  
20.     int sockfd = socket(AF_INET, SOCK_STREAM, 0);  
21.       
22.     //2.绑定sockfd  
23.     struct sockaddr_in my_addr;  
24.     bzero(&my_addr, sizeof(my_addr));  
25.     my_addr.sin_family = AF_INET;  
26.     my_addr.sin_port = htons(8001);  
27.     my_addr.sin_addr.s_addr = htonl(INADDR_ANY);  
28.     bind(sockfd, (struct sockaddr *)&my_addr, sizeof(my_addr));  
29.       
30.     //3.监听listen  
31.     listen(sockfd, 10);  
32.        
33.     //4.epoll相应参数准备  
34.     int fd[OPEN_MAX];  
35.     int i = 0, maxi = 0;  
36.     memset(fd,-1, sizeof(fd));  
37.     fd[0] = sockfd;  
38.       
39.     int epfd = epoll_create(10); // 创建一个 epoll 的句柄，参数要大于 0， 没有太大意义    
40.     if( -1 == epfd ){    
41.         perror ("epoll_create");    
42.         return -1;    
43.     }    
44.         
45.     event.data.fd = sockfd;     //监听套接字    
46.     event.events = EPOLLIN; // 表示对应的文件描述符可以读  
47.       
48.     //5.事件注册函数，将监听套接字描述符 sockfd 加入监听事件    
49.     int ret = epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, &event);    
50.     if(-1 == ret){    
51.         perror("epoll_ctl");    
52.         return -1;    
53.     }   
54.       
55.     //6.对已连接的客户端的数据处理  
56.     while(1)  
57.     {  
58.         // 监视并等待多个文件（标准输入，udp套接字）描述符的属性变化（是否可读）    
59.         // 没有属性变化，这个函数会阻塞，直到有变化才往下执行，这里没有设置超时     
60.         ret = epoll_wait(epfd, &wait_event, maxi+1, -1);   
61.           
62.         //6.1监测sockfd(监听套接字)是否存在连接  
63.         if(( sockfd == wait_event.data.fd )     
64.             && ( EPOLLIN == wait_event.events & EPOLLIN ) )  
65.         {  
66.             struct sockaddr_in cli_addr;  
67.             int clilen = sizeof(cli_addr);  
68.               
69.             //6.1.1 从tcp完成连接中提取客户端  
70.             int connfd = accept(sockfd, (struct sockaddr *)&cli_addr, &clilen);  
71.               
72.             //6.1.2 将提取到的connfd放入fd数组中，以便下面轮询客户端套接字  
73.             for(i=1; i<OPEN_MAX; i++)  
74.             {  
75.                 if(fd[i] < 0)  
76.                 {  
77.                     fd[i] = connfd;  
78.                     event.data.fd = connfd; //监听套接字    
79.                     event.events = EPOLLIN; // 表示对应的文件描述符可以读  
80.                       
81.                     //6.1.3.事件注册函数，将监听套接字描述符 connfd 加入监听事件    
82.                     ret = epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &event);    
83.                     if(-1 == ret){    
84.                         perror("epoll_ctl");    
85.                         return -1;    
86.                     }   
87.                       
88.                     break;  
89.                 }  
90.             }  
91.               
92.             //6.1.4 maxi更新  
93.             if(i > maxi)  
94.                 maxi = i;  
95.                   
96.             //6.1.5 如果没有就绪的描述符，就继续epoll监测，否则继续向下看  
97.             if(--ret <= 0)  
98.                 continue;  
99.         }  
100.           
101.         //6.2继续响应就绪的描述符  
102.         for(i=1; i<=maxi; i++)  
103.         {  
104.             if(fd[i] < 0)  
105.                 continue;  
106.               
107.             if(( fd[i] == wait_event.data.fd )     
108.             && ( EPOLLIN == wait_event.events & (EPOLLIN|EPOLLERR) ))  
109.             {  
110.                 int len = 0;  
111.                 char buf[128] = "";  
112.                   
113.                 //6.2.1接受客户端数据  
114.                 if((len = recv(fd[i], buf, sizeof(buf), 0)) < 0)  
115.                 {  
116.                     if(errno == ECONNRESET)//tcp连接超时、RST  
117.                     {  
118.                         close(fd[i]);  
119.                         fd[i] = -1;  
120.                     }  
121.                     else  
122.                         perror("read error:");  
123.                 }  
124.                 else if(len == 0)//客户端关闭连接  
125.                 {  
126.                     close(fd[i]);  
127.                     fd[i] = -1;  
128.                 }  
129.                 else//正常接收到服务器的数据  
130.                     send(fd[i], buf, len, 0);  
131.                   
132.                 //6.2.2所有的就绪描述符处理完了，就退出当前的for循环，继续poll监测  
133.                 if(--ret <= 0)  
134.                     break;  
135.             }  
136.         }  
137.     }  
138.     return 0;  
139. }  

运行结果：

源码下载：