윈도 비동기 이벤트 기반 네트워크 프로그래밍

int select(
  __in     int nfds,
  __inout  fd_set *readfds,
  __inout  fd_set *writefds,
  __inout  fd_set *exceptfds,
  __in     const struct timeval *timeout
);

typedef struct fd_set {
  u_int  fd_count;              // fd_array에 설정된 파일의 총 개수
  SOCKET fd_array[FD_SETSIZE];
} fd_set;

#include <stdio.h> 
#include <winsock2.h> 
 
#define MAX_LINE 1024 
#define BACKLOG 5
 
int main(int argc, char **argv) 
{ 
    WSADATA wsaData; 
    SOCKET listen_fd, accept_fd, max_fd =0, sock_fd; 
    struct sockaddr_in listen_addr, accept_addr; 
    char buf[MAX_LINE]; 
 
    int readn, addr_len; 
	unsigned int i, fd_num=0;

    fd_set old_fds, new_fds; 
 
    if(argc != 2) 
    { 
        printf("Usage : %s [PORT]\n", argv[1]); 
        return 1; 
    } 
 
    if(WSAStartup(MAKEWORD(2,2), &wsaData) != 0) 
        return 1; 
 
    listen_fd = socket(AF_INET, SOCK_STREAM, 0); 
    if(listen_fd == INVALID_SOCKET) 
        return 1; 
 
    memset((void *)&listen_addr, 0x00, sizeof(listen_addr)); 
 
    listen_addr.sin_family = AF_INET; 
    listen_addr.sin_port = htons(atoi(argv[1])); 
    listen_addr.sin_addr.s_addr = htonl(INADDR_ANY); 
 
    if( bind (listen_fd, (struct sockaddr *)&listen_addr, sizeof(listen_addr)) == SOCKET_ERROR) 
        return 1; 
 
    if(listen(listen_fd, BACKLOG) == SOCKET_ERROR) 
        return 1; 
 
    FD_ZERO(&new_fds); 
    FD_SET(listen_fd, &new_fds);  
 
    while(1) 
    { 
		int testi = 0;
        old_fds = new_fds; 
 
		printf("accept wait %d\n", new_fds.fd_count);

        fd_num = select(0, &old_fds, NULL, NULL, NULL); 
        if(FD_ISSET(listen_fd, &old_fds)) 
        { 
            addr_len = sizeof(struct sockaddr_in); 
            accept_fd = accept(listen_fd, (struct sockaddr *)&accept_addr, &addr_len);
            if(accept_fd == INVALID_SOCKET) 
            { 
                continue; 
            } 
            FD_SET(accept_fd, &new_fds);
        } 
 
		for(i = 1; i <= new_fds.fd_count; i++) 
        { 
			sock_fd = new_fds.fd_array[i];
			if(FD_ISSET(sock_fd, &old_fds)) 
			{ 
				memset(buf, 0x00, MAX_LINE); 
				readn = recv(sock_fd, buf, MAX_LINE, 0); 
				if(readn <= 0) 
				{ 
					printf("socket close\n"); 
					closesocket(sock_fd); 
					FD_CLR(sock_fd, &new_fds);
				} 
				else 
				{ 
					send(sock_fd, buf, readn, 0); 
				} 
				if (--fd_num <=0 ) break;
			} 
         } 
    } 
    closesocket(listen_fd); 
    WSACleanup(); 
    return 0; 
}  

#include <winsock2.h> 
#include <stdio.h> 
#include <stdlib.h> 
 
#define MAXLINE 1024 
#define PORTNUM 3600 
 
struct SOCKETINFO 
{ 
    SOCKET fd; 
    char buf[MAXLINE]; 
    int readn; 
    int writen; 
}; 
 
WSAEVENT EventArray[WSA_MAXIMUM_WAIT_EVENTS]; 
int EventTotal=0; 
struct SOCKETINFO *socketArray[WSA_MAXIMUM_WAIT_EVENTS]; 
 
int CreateSocketInfo(SOCKET s) 
{ 
    struct SOCKETINFO *sInfo; 
 
    if((EventArray[EventTotal] = WSACreateEvent()) == WSA_INVALID_EVENT) 
    { 
		printf("Event Failure\n");
        return -1; 
    } 

    sInfo = (void *)malloc(sizeof(struct SOCKETINFO)); 
    memset((void *)sInfo, 0x00, sizeof(struct SOCKETINFO)); 
    sInfo->fd = s; 
	sInfo->readn = 0;
	sInfo->writen = 0;
    socketArray[EventTotal] = sInfo; 
 
    EventTotal ++; 
    return 1; 
} 
 
void freeSocketInfo(int eventIndex) 
{ 
    struct SOCKETINFO *si = socketArray[eventIndex]; 
    int i; 
 
    closesocket(si->fd); 
    free((void *)si); 
 
    if(WSACloseEvent(EventArray[eventIndex]) == TRUE) 
    { 
        printf("Event Close OK\n"); 
    } 
    else 
    { 
        printf("Event Close Failure\n"); 
    } 
    for(i = eventIndex; i < EventTotal; i++) 
    { 
        EventArray[i] = EventArray[i+1]; 
        socketArray[i] = socketArray[i+1]; 
    } 
    EventTotal--; 
} 
 
int main(int argc, char **argv) 
{ 
    WSADATA wsaData; 
    SOCKET sockfd, clientFd; 
    WSANETWORKEVENTS networkEvents; 
	char buf[MAXLINE];
    int eventIndex; 
    int flags; 
 
    struct SOCKETINFO *socketInfo; 
 
    struct sockaddr_in sockaddr; 
 
    if(WSAStartup(MAKEWORD(2,2),&wsaData) != 0) 
    { 
        printf("dll load error\n"); 
        return 1; 
    } 
 
    sockfd = socket(AF_INET, SOCK_STREAM, 0); 
    if(sockfd == INVALID_SOCKET) 
    { 
        return 1; 
    } 
 
    sockaddr.sin_family = AF_INET; 
    sockaddr.sin_port = htons(PORTNUM); 
    sockaddr.sin_addr.s_addr = htonl(INADDR_ANY); 
 
    if (CreateSocketInfo(sockfd)== -1) 
    { 
        return 1; 
    } 
 
    if(WSAEventSelect(sockfd, EventArray[EventTotal - 1], FD_ACCEPT|FD_CLOSE) == SOCKET_ERROR) 
    { 
        return 1; 
    } 
 
    if(bind(sockfd, (struct sockaddr *)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR) 
    { 
        return 1; 
    } 
 
    listen(sockfd, 5); 
 
    while(1) 
    { 
 
        eventIndex = WSAWaitForMultipleEvents(EventTotal, EventArray, FALSE, WSA_INFINITE, FALSE); 
        if(eventIndex == WSA_WAIT_FAILED) 
        { 
            printf("Event Wait Failed\n"); 
        } 
        if(WSAEnumNetworkEvents(socketArray[eventIndex - WSA_WAIT_EVENT_0]->fd,  
            EventArray[eventIndex - WSA_WAIT_EVENT_0], &networkEvents) == SOCKET_ERROR) 
        { 
            printf("Event Type Error\n"); 
        } 
 
        if(networkEvents.lNetworkEvents & FD_ACCEPT) 
        { 
            if(networkEvents.iErrorCode[FD_ACCEPT_BIT] != 0) 
            { 
                break; 
            } 
            if ((clientFd = accept(socketArray[eventIndex - WSA_WAIT_EVENT_0]->fd, NULL, NULL)) == INVALID_SOCKET) 
            { 
                break; 
            } 
            if(EventTotal > WSA_MAXIMUM_WAIT_EVENTS) 
            { 
                printf("Too many connections\n"); 
                closesocket(clientFd); 
            } 
            CreateSocketInfo(clientFd); 
 
            if( (WSAEventSelect(clientFd, EventArray[EventTotal -1], FD_READ|FD_CLOSE) == SOCKET_ERROR) == SOCKET_ERROR) 
            { 
                return 1; 
            } 
        } 
 
        if(networkEvents.lNetworkEvents & FD_READ) 
        { 
            flags = 0;
	        memset(buf, 0x00, MAXLINE);
            socketInfo = socketArray[eventIndex - WSA_WAIT_EVENT_0];
			socketInfo->readn = recv(socketInfo->fd, socketInfo->buf, MAXLINE, 0);
			send(socketInfo->fd, socketInfo->buf, socketInfo->readn, 0);
        } 
 
        if(networkEvents.lNetworkEvents & FD_CLOSE) 
        { 
			printf("Socket Close\n");
            freeSocketInfo(eventIndex-WSA_WAIT_EVENT_0); 
        } 
    } 
} 

#include <windows.h>
#include <winsock2.h>

#define MAXLINE 1024
int main(int argc, char **argv)
{
	HWND Windows = NULL;
	if(argc != 2)
	{
		printf("Usage : %s [port]\n", argv[0]);
		return 0;
	}
	WSAStartup();
	listen_fd = socket(AF_INET,,,);

	Windows = CreateWindow(...);

	// 듣기 소켓의 accept 이벤트와 close 이벤트 메시지를 
	// Windows 핸들러가 가르키는 윈도의 프로시져가 처리하도록 한다.
	WSAAsyncSelect(listen_fd, Windows, WM_SOCKET, FD_ACCEPT | FD_CLOSE);

	bind();	
	listen();

	// 걍 루프돌면서 기다린다.
	while(1)
	{
		Sleep(10000);
	}
}

// 윈도 메시지를 처리할 프로시져 코드 
LRESULT CALLBACK WinProc(HWND hWnd, int uMsg, WPARAM wParam, LPARAM lParam)
{
	SOCKET client_fd;
	// 메시지 타입이 소켓 메시지면
	if(uMsg == WM_SOCKET)
	{	
		switch(WSAGETSELECTEVENT(lParm))
		{
			// accept 이벤트라면
			case FD_ACCEPT:
				client_fd = accept(wParam,);
				WSAAsyncSelect(client_fd,,,);
				break;
			// read 이벤트라면
			case FD_READ:
				recv(wParm,,,);
				send(wParm,,,);
				break;
			// 소켓 닫기 이벤트라면
			case FD_CLOSE;
				closesocket(wParm);
				break;
		}
	}
}