2009년 10월 17일

자체 제작 epoll 라이브러리(echo server 예제 포함)


C로 만든 echo server 이다. ( 소스:  sjang_epoll_lib.zip )
최고 성능이라고 평가받는 epoll()를 사용하였다.
accept()를 사용하는 서버소켓은 Level Trigger를 사용하고, 클라이언트와 연결된 소켓은 Edge Trigger를 사용하였다. Non-blocking 소켓을 다루는 기본 방법에 대해서도 첨부된 예제를 통해 배울 수 있다.

첨부된 파일은 epoll를 다루는 라이브러리를 제작하고, 그것을 사용하는 예제로 echo server를 제작한 것이다. 라이브러리를 통해 epoll에서 소켓을 어떻게 등록하고 해제하는지 알 수 있다.

아래에 echo server의 구현 코드를 보였다.

여기서 몇몇 에러처리가 빠져있는데, Non-blocking 소켓의 read에서 EAGIN 에러처리와 소켓 연결이 끊기는 이벤트를 감시하지 않은 것, 그리고 read 시에 버퍼를 넘었을 경우에 수신한 내용을 다른 곳에 저장하고 계속 read 해야 하는 것 등등...
(Edge Trigger를 사용할 경우에는 read 시에 모두 읽어와야 한다. 왜냐하면, 다시 이벤트가 온다는 보장이 없으므로 이벤트가 왔을 때 모두 Read 해야 한다.)

그러나, non-blocking 에서의 write 방법에 대해서는 정확하게 구현하였다.
다음의 내용처럼....
(non-blocking 소켓에서 write()를 수행할 경우에 write 하고자 하는 length만큼
write가 되지 않을 수 있음을 알아야 합니다.
예를 들어, 100바이트를 보내기 위해 write() 함수를 호출했을 때, 100바이트를 다 보내지 못하고 리턴됩니다. 리턴될 때, 보낸 length를 반드시 체크해야 합니다. 아마도 대부분의 경우에 100이 리턴되겠지요. 하지만, 네트웍이 바쁘거나 상태가 좋지 않거나 접속이 많은 경우에는 100보다 작은 숫자가 리턴됩니다. 원하는 바이트길이만큼 보내지 못한 것이지요. 이럴때에는 어떻게 해야할까요? 다시 write()를 바로 호출해야할까요? 그렇게 처리할 수도 있지만 바로 직전에 왜 100바이트를 모두 전송하지 못했는지를 이해한다면 그렇게 처리하는 것이 바람직하지 않습니다. 송신버퍼에 100바이트를 채울 여유가 없기때문에 100보다 작은 숫자가 리턴되는 것이기때문에 바로 다시 write()를 호출한다고해서 남은 바이트가 바로 전송된다는 보장이 없습니다.
write()처리를 이벤트를 통해서 해야하는 이유가 여기에 있습니다. 100바이트를 모두 보내지 못했을 때, 그 소켓의 writable를 계속 체크해서 그 이벤트가 오면(송신버퍼에 빈공간이 생기면) 그 시점에 write()를 호출하면 되는 것이죠.
따라서, non-blocking의 read/wirte는 소켓 이벤트의 결과에 따라 일괄적으로 처리를 해주어야 합니다.)

write를 이벤트로 처리해야함은 필수사항이다. 대부분의 epoll 예제가 이 부분을 따로 처리하지 않았지만, 이는 네트웍상태가 좋지 않거나 클라이언트가 바쁘거나 등등의 이유로 원하는 크기를 전송할 수 없는 경우에 필수적인 에러처리이다.
(스티븐 아저씨의 책에서도 명확하게 나와있음)

라이브러리 및 예제에서 사용한 것들...

1. TAILQ: 리눅스에서 기본제공하는 큐이다. 이것을 이용해서 echo 데이터 저장큐로 사용하였다. man page를 보면 친절한 예제와 함께 설명이 있다.
2. myapp.h: 이 헤더파일과 echo_server.[ch] 파일을 함께 보기 바란다. 라이브러리를 사용하여 구현이 쉽도록 하기 위해서 echo 뿐만 아니라, 다른 자료구조를 도입하기 쉽도록 void * 를 이용하여 어플리케이션 원하는 자료구조를 쉽게 구성할 수 있게 하였다.
3. 최대처리수: 최대 클라이언트 수를 소스안에 define를 통해 설정하게 하였다. 물론, 시스템 설정이 지원하는 최대개수 이내만 가능하다.

아쉬운 점....
doxygen를 이용하여 소스코드 문서를 만들어서 올릴 필요가 있겠다.. ^^


echo_server.c 소스

1 #include "epollio.h"
2 #include "socket_util.h"
3 #include "myapp.h"
4
5 #include 
6 #include 
7 #include 
8 #include 
9 #include 
10 #include 
11 #include 
12
13 #include "echo_server.h"
14
15
16 #define MAX_CLIENT 1000
17
18 int recv_count = 0;
19 int send_count = 0;
20
21 static void reset_myapp_data(myapp_data_t *myapp_data)
22 {
23 echo_data_t *echo_data = (echo_data_t *)myapp_data->data;
24
25 close(myapp_data->socket_fd);
26 myapp_data->socket_fd = -1;
27
28 memset(echo_data->client_ip, 0, sizeof(echo_data->client_ip));
29 memset(echo_data->in_msg, 0, sizeof(echo_data->in_msg));
30 memset(echo_data->out_msg, 0, sizeof(echo_data->out_msg));
31 echo_data->in_msg_len = 0;
32 echo_data->out_msg_len = 0;
33 echo_data->sent_len = 0;
34 }
35
36
37 void init_myapp_data_members(myapp_data_t *myapp_data)
38 {
39 reset_myapp_data(myapp_data);
40 }
41
42
43 int init_myapp_data(myapp_data_t **mydata, int max_client)
44 {
45 /* myapp_data_t *myapp_temp;*/
46 /* echo_data_t *echo_temp;*/
47 int i;
48
49 for(i = 0; i < max_client; i++) 50 { 51 if ((mydata[i] = (myapp_data_t *)malloc(sizeof(myapp_data_t))) == NULL) 52 { 53 return -1; 54 } 55 56 /* 응용 데이터 공간을 queue 공간의 데이터 포인터에 할당 */ 57 if ((mydata[i]->data = (echo_data_t *)malloc(sizeof(echo_data_t))) == NULL)
58 {
59 return -1;
60 }
61 /* mydata[i]->data = (echo_data_t *)echo_temp;*/
62 /* printf("myapp data Pointer [%x]\n", mydata[i]);*/
63 /* printf("echo data Pointer [%x]\n", mydata[i]->data);*/
64
65 mydata[i]->socket_fd = -1;
66 init_myapp_data_members(mydata[i]);
67
68 /* 확보한 공간을 Queue 안에 넣는다. */
69 if (i == 0)
70 {
71 TAILQ_INSERT_HEAD(&myapp_data_event_queue, mydata[i], mydata_next);
72 }
73 else
74 {
75 TAILQ_INSERT_TAIL(&myapp_data_event_queue, mydata[i], mydata_next);
76 }
77 }
78 return 0;
79 }
80
81 static int recv_msg(int fd, echo_data_t *echo_data)
82 {
83 int recv_len;
84 int buf_len = sizeof(echo_data->in_msg) - 1;
85 recv_len = recv(fd, echo_data->in_msg, buf_len, 0);
86 if (recv_len < 0) 87 { 88 /* non-blocking 소켓이므로 여기서 errno 체크해야함 */ 89 return -1; 90 } 91 if (recv_len == 0) /* 끊어진 소켓 */ 92 { 93 return -1; 94 } 95 echo_data->in_msg_len = recv_len;
96 recv_count++;
97 printf("in msg = [%s]\n", echo_data->in_msg);
98 printf("in msg len = [%d]\n", echo_data->in_msg_len);
99
100 return 0;
101 }
102
103 static int send_msg(int fd, echo_data_t *echo_data)
104 {
105 int sent_len;
106
107 printf("send buf = [%s]\n", echo_data->out_msg + echo_data->sent_len);
108 sent_len = send(fd, echo_data->out_msg + echo_data->sent_len, echo_data->out_msg_len - echo_data->sent_len, 0);
109 if (sent_len < 0) 110 { 111 printf("send_msg error\n"); 112 return -1; 113 } 114 printf("sent len = [%d]\n", sent_len); 115 116 echo_data->sent_len += sent_len;
117
118 return 0;
119 }
120
121
122 int echo_server_process(struct epoll_event *event)
123 {
124 myapp_data_t *myapp_data;
125 echo_data_t *echo_data;
126
127 myapp_data = (myapp_data_t *)(event->data.ptr);
128 /* printf("echo server myapp_data process Pointer [%x]\n", myapp_data); */
129 echo_data = (echo_data_t *)(myapp_data->data);
130 /* printf("echo server echo_data process Pointer [%x]\n", echo_data); */
131
132 if (event->events & EPOLLIN)
133 {
134 if (recv_msg(myapp_data->socket_fd, echo_data) < 0) 135 { 136 printf("recv msg error\n"); 137 return -1; 138 } 139 printf("in msg copy [%s]\n", echo_data->in_msg);
140 strncpy(echo_data->out_msg, echo_data->in_msg, echo_data->in_msg_len);
141 printf("out msg [%s]\n", echo_data->out_msg);
142 echo_data->out_msg_len = echo_data->in_msg_len;
143
144 /* reset read buf */
145 memset(echo_data->in_msg, 0, sizeof(echo_data->in_msg));
146 echo_data->in_msg_len = 0;
147
148 printf("writable on\n");
149 /* writable check로 변경. */
150 if (set_event_socket(&ed, myapp_data->socket_fd, EVENT_WRITE, myapp_data, FD_MODIFY) < 0) /* echo server 이므로 EVENT_READ가 설정되어야 한다. */ 151 { 152 fprintf(stderr, "epoll set insertion error: fd=%d", myapp_data->socket_fd);
153 return -1;
154 }
155 }
156 else if (event->events & EPOLLOUT)
157 {
158 if (send_msg(myapp_data->socket_fd, echo_data) < 0) 159 { 160 printf("recv msg error\n"); 161 return -1; 162 } 163 164 printf("out msg len = [%d]\n", echo_data->out_msg_len);
165 if(echo_data->out_msg_len == echo_data->sent_len)
166 {
167 /* reset write buf */
168 memset(echo_data->out_msg, 0, sizeof(echo_data->out_msg));
169 echo_data->out_msg_len = 0;
170 echo_data->sent_len = 0;
171
172 send_count++;
173
174 printf("readable on\n");
175 /* readable check로 변경. 즉, 받은데이터를 모두 echo 하기 전에 다시 받지 않음 */
176 if (set_event_socket(&ed, myapp_data->socket_fd, EVENT_READ, myapp_data, FD_MODIFY) < 0) 177 { 178 fprintf(stderr, "epoll set insertion error: fd=%d", myapp_data->socket_fd);
179 return -1;
180 }
181 }
182 }
183 return 0;
184 }
185
186 int main()
187 {
188 int nfds;
189 int listener;
190 int client_fd;
191 struct sockaddr_in local;
192 socklen_t addrlen;
193 int n;
194
195
196
197 myapp_data_t *new_myapp_data;
198
199
200 myapp_data_t *myapp_data[MAX_CLIENT]; /* 현재 응용의 처리를 위한 데이터 구조체의 공간 확보 */
201
202 TAILQ_INIT(&myapp_data_event_queue);
203
204 if (init_myapp_data(myapp_data, MAX_CLIENT) < 0)
205 {
206 printf("init echo data error\n");
207 return -1;
208 }
209
210 if ( init_epoll(&ed, 10000) < 0 )
211 {
212 printf("epoll_init error!\n");
213 return -1;
214 }
215
216 addrlen = sizeof(local);
217
218 listener = make_socket(10025);
219 if (listener < 0)
220 {
221 return -1;
222 }
223
224 if (add_epoll_listen_socket(&ed, listener, EVENT_READ) < 0 )
225 {
226 return -1;
227 }
228
229 while(1)
230 {
231 printf("--------------------------\n");
232 printf("recv count = [%d]\n", recv_count);
233 printf("send count = [%d]\n", send_count);
234 printf("--------------------------\n");
235 nfds = epoll_event_monitor(&ed, -1);
236 if (nfds < 0)
237 {
238 return -1;
239 }
240 printf("returned event [%d]\n", nfds);
241
242 for(n = 0; n < nfds; ++n)
243 {
244 if(ed.events[n].data.fd == listener)
245 {
246 new_myapp_data = (myapp_data_t *)get_new_mydata();
247 client_fd = accept(listener, (struct sockaddr *) &local, &addrlen);
248 if(client_fd < 0)
249 {
250 perror("accept");
251 continue;
252 }
253
254 /* printf("new_myapp_data Pointer [%x]\n", new_myapp_data);*/
255 if (set_event_socket(&ed, client_fd, EVENT_READ, new_myapp_data, FD_ADD) < 0) /* echo server 이므로 EVENT_READ가 설정되어야 한다. */
256 {
257 fprintf(stderr, "epoll set insertion error: fd=%d", client_fd);
258 return -1;
259 }
260 }
261 else
262 {
263 /* printf("ed event Pointer 1[%x]\n", &ed.events[n]);*/
264 if (echo_server_process(&ed.events[n]) < 0)
265 {
266 /* delete 추가 */
267 myapp_data_t *myapp_data_temp = (myapp_data_t *)ed.events[n].data.ptr;
268 reset_myapp_data(myapp_data_temp);
269 /* 다시 queue로 반환한다. */
270 TAILQ_INSERT_TAIL(&myapp_data_event_queue, myapp_data_temp, mydata_next);
271 }
272 }
273 }
274 }
275 return 0;
276 }
277


내용수정!!
스티븐 아저씨의 책에서 Non-blocking I/O에 대한 부분을 다시한번 읽었다. write()처리에 대한 것이다.

select()를 이용한 구현을 다시보니, read 후에, 바로 write 비트를 켜서 select로 다시 루프를 돌지 않고 바로 write를 시도했다. 물론, write length를 체크해서 다시 write 할 필요가 있는지 검사하고 더 있다면 write bit를 계속 켜두게(reset하고 다시 켜기)하고 있다.

이 부분의 구현은 구현자 마음이라는 코멘트가 있었다. 바로 write 하지 않고 비트만 켜서 select를 통해 처리하는 것과(이 방법은 루프한번의 오버헤드가 있다.) read 후에 바로 write를 수행하고 더 보낼게 남았으면 write 비트를 키는 방식이 있다고 했다. 물론, Writable를 체크하지 않고 쓰기때문에 write() 콜에서 EWOULDBLOCK를 발생(소켓에 쓰기를 받아줄 공간이 없는상태)할 수 있다.

어느 방법을 이용하든 구현자의 마음이다. 무작정 write를 한번 시도해보고 더 보낼게 있을때에만 write 비트를 키는 방법도 괜찮은거 같다.

댓글 3개:

  1. 아자씨.. 코드 붙일때는 code2html 같은거 써서 예쁘게 붙여주삼.
    그럼 수고하삼~~

    답글삭제
  2. 첨부 파일 링크가 깨졌나 보네요...

    답글삭제
    답글
    1. 링크가 깨져있었네요.
      링크를 다시 살렸습니다.

      감사합니다.

      삭제