2009년 10월 26일

비블록(non-block) 모드의 connect()는 상당히 복잡하다.

실제로 연결이 성공 되었는지 여부를 나중에 확인해야 하기 때문이다. 블록 모드 소켓에서 connect()는 연결이 완료되거나, 연결이 될 수 없음(에러)이 확실이 정해지면 리턴된다.

비블록 소켓은 연결이 완료되기를 기다려주지 않는다. 비블록 모드에서 가장 쉽게 구현되는 경우는 connect()를 호출하자마자 즉시 연결이 완료되고, 유효한 소켓을 생성하는 경우이다. 그러나, 이러한 상황은 거의 발생하지 않는다. 비블록 모드에서 connect()는 연결이 완료되지 않더라도 즉시 리턴된다. 따라서, 이 함수가 리턴되었을 때에는 반드시 먼저 리턴값을 체크해야 한다.

리턴값이 0이면 블록 모드의 소켓의 연결과 동일한 상황(거의 발생하지 않음)이 된 것이다.
이 경우에는 sockfd를 유효한 소켓으로 간주하고 구현하면 된다. 문제는 이 함수의 리턴값이 (-1)인 상황이다. 이 경우에는 반드시 errno 값을 검사해야 한다.

connect() 함수의 파라미터값들에 문제가 없다면 conect() 함수는 연결을 시도하게 되고, 연결의 성공여부와 관계 없이 리턴된다. 리턴값이 (-1)이고, errno가 EINPROGRESS 라면, 연결 작업이 이루어지고 있는 상태에서 connect() 함수가 리턴된 것이다.

비블록 모드의 소켓에서는 연결 완료와 무관하게 바로 리턴되는 방식으로 동작한다. 이 경우에는 어느 정도의 시간이 흐른 후에 실제로 연결이 완료 되었는지를 검사해야 한다.

연결 완료를 검사하는 몇 가지 방법이 존재하지만, 비교적 간단한 방법은 sockfd 소켓에 데이터를 전송할 수 있는, "쓰기가능" 상태인지를 검사하는 것이다. 쓰기가능 상태를 검사하려면 epoll() 또는 select()를 이용할 수 있다.

이 함수에 sockfd 값을 등록하면 쓰기가능이 되었을 때 바로 알려준다.(소켓이벤트 처리기법)

2009년 10월 17일

Linux epoll에서 Listen 소켓의 처리

epoll에서 Listen 소켓에 대하여...
 
edge trigger(default)로 등록해서 사용할 경우에, edge는 여러개가 동시에 오더라고 이벤트가

저장되지 않으므로(epoll man페이지에서 그렇다고 했다.) Listen 소켓은 level 트리거로 등록해야 한다.

또는, Non-blocking 소켓이므로 epoll에 등록하지 않고, accept()함수에서 이벤트가 발생하거나 할일이 없을 때, aceept()를 호출하는 방법도 있다.

Listen 소켓을 edge 트리거로 등록하여 접속 이벤트를 놓치는 버그가 발생하지 않도록 하자~~~
 

 

자체 제작 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 비트를 키는 방법도 괜찮은거 같다.

소켓에서 발생하는 이벤트 감지의 기준. edge trigger와 level trigger

두 트리커의 차이점은 소켓버퍼에 데이터가 있는 경우에 그것을 소켓 이벤트로 간주하는 기준이다.

먼저, 쉬운것부터...

레벨트리거: 소켓버퍼에 데이터가 들어있으면 무조건 이벤트가 발생하는 트리거이다. 즉, 소켓에서 read 할 수 있는 데이터가 1바이트 이상 있을때 이벤트가 발생했다고 리턴해준다. 여기서 1바이트라고 했지만 그 기준을 소켓옵션설정을 통해 조정할 수 있는 것으로 알고 있다. 이것을 조정하면 10바이트 이상일 경우에만 이벤트가 발생하는 것으로 기준을 설정할 수도 있다. (select(), poll() 등이 레벨트리거에 속한다.)

에지트리거: 소켓버퍼의 데이터가 들어오는 시점을 알려주는 이벤트 트리거이다. 소켓버퍼가 비어 있다가 상대방으로부터 버퍼에 데이터가 들어오면 이때 이벤트가 발생한 것으로 간주한다. 들어온 데이터를 어플리케이션에서 read 하고 안하고는 무관하다. 즉, 에지트리거에서 이벤트가 발생했고(데이터가 들어왔고), 어플리케인션에서 read 하지 않더라도 그 이후에 다른 데이터가 추가로 들어오면 에지트리거는 이벤트가 발생했다고 리턴하게 된다. (epoll(), kqueue() 등이 에지트리거에 속한다. 이것들은 설정에 따라 레벨트리거로도 사용할 수 있다.)

일반적으로.... 에지트리거가 대량의 접속시에 더 나은 응답속도를 제공한다.
(이벤트 처리가 빠르다.)

이해를 돕기 위해서 그림하나 추가해 본다.





에지트리거를 다룰 때 주의점:
에지트리거를 통해 이벤트 받았고 read 작업을 해야하는데, 이 시점에 read 할 수 있는 모든 데이터를 read 해야한다. 왜냐하면, 에지트리거는 데이터 유입에 대한 이벤트이므로 추가로 데이터 유입이 없으면 이벤트가 오지 않으므로 이번 이벤트를 통해 read를 할 때 다음에 다시 이벤트가 온다는 보장이 없으므로 이 시점에 읽을 수 있는 모든 데이터를 read 해야만 정상적인 처리가 된다. 어플리케이션의 read 버퍼가 작아서 꽉찬 상태로 리턴되면 이것을 다른 버퍼에 저장해 두고, 나머지를 다시 소켓으로부터 read 해야한다. 더 읽을 것이 없을때까지 계속 read 해야 한다. 이번에 read를 다 하지 않으면 영원히 다시 read할 이벤트가 오지 않을 수 있기 때문이다.

키보드 마우스 공유 프로그램

하나의 키보드와 마우스로 여러 컴퓨터에서 동시에 사용할 수 있게 해주는 프로그램이다.

대표적으로...

synergy2: http://synergy2.sourceforge.net/
input director: http://www.inputdirector.com/

synergy2는 2006년 이후로 버전업이 없는 상태. 더 이상 기능추가가 필요없는 모양인데...

input director는 계속 버전업이 되고 있고...

두 가지를 모두를 사용해 본 경험으로는...

input director가 설정이 직관적이고, 사용하기 쉽고 다양하게 접근관리를 할 수 있어서 좋으나,

공유하려는(slave computer) 컴퓨터가 유동 ip(회사에서 무선랜으로 동적ip를 할당받을 때)일 경우에는 사용이 안되는 거 같다. 설정하려 잠시 노력해 보았으나.... 포기..

반면에 synergy2는 약간의 버그는 있으나, 클라이언트-서버로 동작하므로 클라이언트가 유동ip이어도

서버를 찾기만 하면 서버PC의 키보드와 마우스를 공유할 수 있게 된다.

그러나, 설정이 직관적이진 않다.

고정ip를 사용(집에서 공유기로 내부고정ip로 할당하는 경우)하는 경우에는 input director를 추천한다.

input director는 윈도우만 지원하지만 synergy는 윈도우,리눅스,mac도 지원한다.