#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);  
        }  
    }  
}  
 

WSAEventSelect 함수를 호출하면 자동으로 소켓을 비동기/비봉쇄 모드로 설정한다. 때문에 이를 감안해서 recv/recv 함수를 호출해야 한다. 예를 들어 FD_READ 이벤트를 받고 나서 read을 호출 했을 때, WSAEWOULDBLOCK에러가 발생할 수도 있다는 의미다. 견고한 애플리케이션을 만들려면 이러한 예외 사항을 처리해 주어야 한다. 위의 프로그램은 WSAEWOULDBLOCK 처리는 포함하지 않고 있다.

3 WSAAsyncSelect 구현

비동기 이벤트 방식 중 가장 널리 사용되는 방법중의 하나다. WSAEventSelect와 비슷한 매커니즘을 가진다. 차이점이라면 WSAEventSelect는 이벤트 객체를 사용해서 입출력을 다루고, WSAAsyncSelect함수는 윈도우 메시지 형태로 네트워크 이벤트를 처리한다는 점이다.

WSAAsyncSelect를 이용한 데이터 처리 흐름이다. WSAEventSelect와 큰 차이가 없다.

1. 소켓에서 관심있는 네트워크 이벤트와 메시지를 핸들할 윈도 핸들러를 함께 등록한다.
   
2. 네트워크 이벤트가 발생하면, 윈도 메시지가 발생하고 윈도 프로시저가 호출된다. 이때 실행되는 윈도 프로시저의 이름은 WndProc이다.
   
   
   

   LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) 
   { 
   ... 
   } 
    

3. 윈도 프로시저는 받은 메시지 종류에 따라 데이터를 처리한다.
   
   WSAGETSELECTEVENT매크로를 이용해서 어떤 종류의 이벤트가 발생했는지를 확인할 수 있다.
   
   

WSAAsyncSelect함수가 호출되면, 소켓은 자동적으로 비 봉쇄 소켓이된다.

TCP 기반의 echo 서버 프로시져 코드. 나중에 실행 가능한 예제를 만들어봐야지

#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; 
        } 
    } 
} 
 

• WSAAsyncSelect 모델 기반 서버 프로그램 : UDP
  
• http://qsoft.cjb.net
  

#include <windows.h> 
#include "resource.h" 
 
#define APP_PORT 0x1983 
#define WM_SOCKETREAD (WM_APP + 100) 
 
SOCKADDR_IN saServer; 
SOCKET sock; 
 
BOOL CALLBACK DialogProc(HWND hDlg, UINT MSG, WPARAM wParam, LPARAM lParam) 
{ 
    switch(MSG) 
    { 
     case WM_INITDIALOG: 
        { 
            WSAAsyncSelect(sock, hDlg, WM_SOCKETREAD, FD_READ); 
        }break; 
        case WM_COMMAND: 
        { 
            switch(wParam) 
            { 
                case IDC_OK: 
                case IDC_CANCEL: EndDialog(hDlg, 0); break; 
            } 
        }break; 
        case WM_SOCKETREAD: 
        { 
            SOCKADDR from; 
            char buffer[256]; 
            int len = sizeof(SOCKADDR); 
            memset(buffer, '\0', 256); 
            recvfrom(sock, buffer, sizeof(buffer)-1, 0, &from, &len); 
            SetDlgItemText(hDlg, IDC_MESSAGE, buffer); 
        }break; 
    } 
    return(0); 
} 
 
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd) 
{ 
    WSADATA data; 
    if (WSAStartup(MAKEWORD(2,2), &data) != 0) return(0); 
    int ret; 
    sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); 
    if (!sock) 
    { 
        WSACleanup(); 
        return(0); 
   } 
    saServer.sin_family = AF_INET; 
    saServer.sin_addr.s_addr = INADDR_ANY; 
    saServer.sin_port = htons(APP_PORT); 
    ret = bind(sock, (SOCKADDR *)&saServer, sizeof(SOCKADDR)); 
    if (ret) 
   { 
        WSACleanup(); 
        return(false); 
   } 
 
    DialogBox(hInstance, MAKEINTRESOURCE(IDD_DIALOG1), NULL, DialogProc); 
   closesocket(sock); 
    WSACleanup(); 
    return(1); 
} 
 

태그 : 소켓 네트워크 프로그래밍 입출력 다중화 입출력 모델 select 윈속

category_network programing