多路复用之epoll（）

1
2
3
#include <sys/epoll.h>
int epoll_create(int size);

1
2
3
在这里插入代码片#include <sys/epoll.h>
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *ev);

1
2
3
4
5
6
7
8
9
10
11
12
13
typedef union epoll_data
{
 void *ptr; /* Pointer to user-defind data */
 int fd; /* File descriptor */
 uint32_t u32; /* 32-bit integer */
 uint64_t u64; /* 64-bit integer */
} epoll_data_t;
struct epoll_event
{
 uint32_t events; /* epoll events(bit mask) */
 epoll_data_t data; /* User data */
};

1
2
3
#include <sys/epoll.h>
int epoll_wait(int epfd, struct epoll_event *evlist, int maxevents, int timeout);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <time.h>
#include <pthread.h>
#include <getopt.h>
#include <libgen.h>
#include <sys/types.h> 
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/epoll.h>
#include <sys/resource.h>
#define MAX_EVENTS 512
#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
static inline void print_usage(char *progname);
int socket_server_init(char *listen_ip, int listen_port);
void set_socket_rlimit(void);
int main(int argc, char **argv)
{
	 int listenfd, connfd;
	 int serv_port = 0;
	 int daemon_run = 0;
	 char *progname = NULL;
	 int opt;
	 int rv;
	 int i, j;
	 int found;
	 char buf[1024];
	 int epollfd;
	 struct epoll_event event;
	 struct epoll_event event_array[MAX_EVENTS];
	 int events;
	 struct option long_options[] =
	 { 
		 {"daemon", no_argument, NULL, 'b'},
		 {"port", required_argument, NULL, 'p'},
		 {"help", no_argument, NULL, 'h'},
		 {NULL, 0, NULL, 0}
	 }; 
	 progname = basename(argv[0]);
	 /* Parser the command line parameters */
	 while ((opt = getopt_long(argc, argv, "bp:h", long_options, NULL)) != -1)
	 { 
		 switch (opt)
		 { 
			 case 'b':
			 daemon_run=1;
			 break;
			 
			 case 'p':
			 serv_port = atoi(optarg);
			 break;
			 
			 case 'h': /* Get help information */
			 print_usage(progname);
			 return EXIT_SUCCESS;
			 default:
			 break;
		 } 
	 } 
	 if( !serv_port )
	 { 
		 print_usage(progname);
		 return -1;
	 }
	 set_socket_rlimit(); /* set max open socket count */
	 if( (listenfd=socket_server_init(NULL, serv_port)) < 0 )
	 {
		 printf("ERROR: %s server listen on port %d failuren", argv[0],serv_port);
		 return -2;
	 }
	 printf("%s server start to listen on port %dn", argv[0],serv_port);
	 /* set program running on background */
	 if( daemon_run )
	 {
		 daemon(0, 0);
	 }
	 if( (epollfd=epoll_create(MAX_EVENTS)) < 0 )
	 {
		 printf("epoll_create() failure: %sn", strerror(errno));
		 return -3;
	 }
	 //event.events = EPOLLIN|EPOLLET;
	 event.events = EPOLLIN;
	 event.data.fd = listenfd;
	 if( epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &event) < 0)
	 {
		 printf("epoll add listen socket failure: %sn", strerror(errno));
		 return -4;
	 }
 for ( ; ; )
 {
	 /* program will blocked here */
	 events = epoll_wait(epollfd, event_array, MAX_EVENTS, -1);
	 if(events < 0)
	 {
		 printf("epoll failure: %sn", strerror(errno));
		 break;
	 }
	 else if(events == 0)
	 {
	 printf("epoll get timeoutn");
	 continue;
	 }
	 /* rv>0 is the active events count */
	 for(i=0; i<events; i++)
	 {
		 if ( (event_array[i].events&EPOLLERR) || (event_array[i].events&EPOLLHUP) )
		 {
			 printf("epoll_wait get error on fd[%d]: %sn", event_array[i].data.fd, 	strerror(errno));
			 epoll_ctl(epollfd, EPOLL_CTL_DEL, event_array[i].data.fd, NULL);
			 close(event_array[i].data.fd);
		 }
		 /* listen socket get event means new client start connect now */
		 if( event_array[i].data.fd == listenfd )
		 {
			 if( (connfd=accept(listenfd, (struct sockaddr *)NULL, NULL)) < 0)
			 {
				 printf("accept new client failure: %sn", strerror(errno));
				 continue;
			 }
			 event.data.fd = connfd;
			 //event.events = EPOLLIN|EPOLLET;
			 event.events = EPOLLIN;
			 if( epoll_ctl(epollfd, EPOLL_CTL_ADD, connfd, &event) < 0 )
			 {
				 printf("epoll add client socket failure: %sn", strerror(errno));
				 close(event_array[i].data.fd);
				 continue;
			 }
			 printf("epoll add new client socket[%d] ok.n", connfd);
	 }
	 else /* already connected client socket get data incoming */
	 {
		 if( (rv=read(event_array[i].data.fd, buf, sizeof(buf))) <= 0)
		 {
			 printf("socket[%d] read failure or get disconncet and will be removed.n",
			event_array[i].data.fd);
			 epoll_ctl(epollfd, EPOLL_CTL_DEL, event_array[i].data.fd, NULL);
			 close(event_array[i].data.fd);
			 continue;
		 }
		 else
		 {
			 printf("socket[%d] read get %d bytes datan", event_array[i].data.fd, rv);
			 /* convert letter from lowercase to uppercase */
			 for(j=0; j<rv; j++)
			 buf[j]=toupper(buf[j]);
			 if( write(event_array[i].data.fd, buf, rv) < 0 )
			 {
				 printf("socket[%d] write failure: %sn", event_array[i].data.fd, strerror(errno));
				 epoll_ctl(epollfd, EPOLL_CTL_DEL, event_array[i].data.fd, NULL);
				 close(event_array[i].data.fd);
			 }
		 }
	 }
 } /* for(i=0; i<rv; i++) */
  } /* while(1) */
CleanUp:
	 close(listenfd);
	 return 0;
}
static inline void print_usage(char *progname)
{
	 printf("Usage: %s [OPTION]...n", progname);
	 printf(" %s is a socket server program, which used to verify client and echo back string from itn",
	progname);
	 printf("nMandatory arguments to long options are mandatory for short options too:n");
	 printf(" -b[daemon ] set program running on backgroundn");
	 printf(" -p[port ] Socket server port addressn");
	 printf(" -h[help ] Display this help informationn");
	 printf("nExample: %s -b -p 8900n", progname);
	 return ;
}
int socket_server_init(char *listen_ip, int listen_port)
{
	 struct sockaddr_in servaddr;
	 int rv = 0;
	 int on = 1;
	 int listenfd;
	 if ( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
	 {
	 printf("Use socket() to create a TCP socket failure: %sn", strerror(errno));
	 return -1;
	 }
	 /* Set socket port reuseable, fix 'Address already in use' bug when socket server restart */
	 setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
	 memset(&servaddr, 0, sizeof(servaddr));
	 servaddr.sin_family = AF_INET; 
	 servaddr.sin_port = htons(listen_port);
	 if( !listen_ip ) /* Listen all the local IP address */
	 {
	 servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 
	 }
	 else /* listen the specified IP address */
	 {
	 if (inet_pton(AF_INET, listen_ip, &servaddr.sin_addr) <= 0)
	 {
	 printf("inet_pton() set listen IP address failure.n");
	 rv = -2;
	 goto CleanUp;
	 }
	 }
	 if(bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0)
	 {
	 printf("Use bind() to bind the TCP socket failure: %sn", strerror(errno));
	 rv = -3;
	 goto CleanUp;
	 }
	 if(listen(listenfd, 64) < 0)
	 {
	 printf("Use bind() to bind the TCP socket failure: %sn", strerror(errno));
	 rv = -4;
	 goto CleanUp;
	 }
CleanUp:
	 if(rv<0)
	 close(listenfd);
	 else
	 rv = listenfd;
	 return rv;
}
/* Set open file description count to max */
void set_socket_rlimit(void)
{
	 struct rlimit limit = {0};
	 getrlimit(RLIMIT_NOFILE, &limit );
	 limit.rlim_cur = limit.rlim_max;
	 setrlimit(RLIMIT_NOFILE, &limit );
	 printf("set socket open fd max count to %dn", limit.rlim_max);
}