TCP/IP) Overlapped I/O(2) 모델(CallBack)

• 실행 함수(비동기 + 논-블로킹)
  • WSASend
  • 비동기 입출력 소켓
    1. WSABUF 배열의 시작 주소 + 개수
    2. 보내고/받은 바이트 수
    3. 상세 옵션인데 0
    4. WSAOVERLAPPED 구조체 주소값
    5. 입출력이 완료되면 OS가 호출할 콜백 함수
  • void CompletionRoutin()
    1. 오류 발생 시 0 아닌 값
    2. 전송 바이트 수
    3. 비동기 입출력 함수 호출 시 넘겨준 WSAOVERLAPPED 구조체의 주소값
    4. 0
• 비동기 입출력 함수 완료되면, 쓰레드마다 있는 APC큐(Asynchronous procedure call queue)에 일감이 쌓임.
• APC큐는 비동기 입출력 결과 저장을 위해 운영체제가 각 스레드에 할당하는 메모리 영역입니다.
• Overlapped (Completion Routine 코드 작동 방식)
  1. 비동기 입출력 지원하는 소켓 생성
  2. 비동기 입출력 함수 호출 (완료루틴의 시작주소를 넘겨준다).
  3. 비동기 작업이 바로 완료되지 않으면, WSA_IO_PENDING 오류 코드.
  4. 비동기 입출력 함수 호출한 쓰레드를 → Alertable Wait 상태로 만듬.
     • ex) WaitForSingleObjectEx, WaitForMultipleObjectsEx, SleepEx, WSAWaitForMultipleEvents
  5. 비동기 IO 완료되면, 운영체제는 완료 루틴 호출
  6. 완료 루틴 호출이 모두 끝나면, 쓰레드는 Alertable Wait 상태에서 빠져나

---

---

#pragma warning(disable:4996)
#pragma comment(lib, "ws2_32.lib")
#include<stdio.h>
#include<Winsock2.h>
#include<stdlib.h>


#define PORT	9000
#define BUFSIZE 512

//소켓 정보 저장을 위한 구조체와 변수
struct SOCKETINFO {
    WSAOVERLAPPED overlapped;
    SOCKET sock;
    char buf[BUFSIZE + 1];
    int recvBytes;
    int sendBytes;
    WSABUF wsabuf;
};

SOCKET clientsock;
HANDLE hReadEvent, hWriteEvent;

//비동기 입출력 처리 함수
DWORD WINAPI WorkerThread(LPVOID arg);
void CALLBACK CompletionRoutine(DWORD dwError, DWORD cbTransferred,
    LPWSAOVERLAPPED lpOverlapped, DWORD dwFalgs);

//오류 출력 함수
void err_quit(const char* msg);

int main()
{
    WSADATA wsaData;
    SOCKADDR_IN sock_addr;

    //윈속 초기화
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
        err_quit("WSAStartup");
    
    //소켓 생성
    SOCKET listen_s = socket(AF_INET, SOCK_STREAM, 0);
    if (listen_s == INVALID_SOCKET)
        err_quit("socket");

    ZeroMemory(&sock_addr, sizeof(struct sockaddr_in));
    sock_addr.sin_family = AF_INET;
    sock_addr.sin_port = htons(PORT);
    sock_addr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);

    if (bind(listen_s, (struct sockaddr*)&sock_addr, sizeof(struct sockaddr_in)) == SOCKET_ERROR) err_quit("Bind");
    if (listen(listen_s, SOMAXCONN) == SOCKET_ERROR) err_quit("listen");

    hReadEvent = CreateEvent(NULL, FALSE, TRUE, NULL);
    if (hReadEvent == NULL) return 1;
    hWriteEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    if (hWriteEvent == NULL) return 1;

    //스레드 생성
    HANDLE hThread = CreateThread(NULL, 0, WorkerThread, NULL, 0, NULL);
    if (hThread == NULL) return 1;
    CloseHandle(hThread);

    while (1) {
        WaitForSingleObject(hReadEvent, INFINITE);
        //accept()
        clientsock = accept(listen_s, NULL, NULL);
        if (clientsock == INVALID_SOCKET) {
            err_quit("accept()");
            break;
        }
        SetEvent(hWriteEvent);
    }

    //윈속 종료
    WSACleanup();
    return 0;
}

DWORD WINAPI WorkerThread(LPVOID arg) {
    int retVal;

    while (1) {
        while (1) {
            //alertable wait
            DWORD result = WaitForSingleObjectEx(hWriteEvent, INFINITE, TRUE);
            if (result == WAIT_OBJECT_0) break;
            if (result != WAIT_IO_COMPLETION) return 1;
        }

        //클라 정보 얻기
        SOCKADDR_IN clientaddr;
        int addrlen = sizeof(clientaddr);
        getpeername(clientsock, (SOCKADDR*)&clientaddr, &addrlen);
        printf("[TCP서버] 클라이언트 접속 IP : %s %d\n",
            inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));

        //소켓 정보 구조체 할당과 초기화
        SOCKETINFO* ptr = new SOCKETINFO;
        if (ptr == NULL) {
            printf("[오류] 메모리가 부족합니다.\n");
            return 1;
        }
        ZeroMemory(&ptr->overlapped, sizeof(ptr->overlapped));
        ptr->sock = clientsock;
        SetEvent(hReadEvent);
        ptr->recvBytes = ptr->sendBytes = 0;
        ptr->wsabuf.buf = ptr->buf;
        ptr->wsabuf.len = BUFSIZE;

        //비동기 입출력 시작
        DWORD recvbytes;
        DWORD flags = 0;
        retVal = WSARecv(ptr->sock, &ptr->wsabuf, 1, &recvbytes, &flags, &ptr->overlapped, CompletionRoutine);
        if (retVal == SOCKET_ERROR) {
            if (WSAGetLastError() != WSA_IO_PENDING) {
                err_quit("WSARecv()");
                return 1;
            }
        }
    }
    return 0;
}

//소켓 정보 추가
void CALLBACK CompletionRoutine(DWORD dwError, DWORD cbTransferred,
    LPWSAOVERLAPPED lpOverlapped, DWORD dwFalgs) {
    int retVal;

    //클라 정보 얻기
    SOCKETINFO* ptr = (SOCKETINFO*)lpOverlapped;
    SOCKADDR_IN clientaddr;
    int addrlen = sizeof(clientaddr);
    getpeername(ptr->sock, (SOCKADDR*)&clientaddr, &addrlen);

    //비동기 입출력 결과 확인
    if (dwError != 0 || cbTransferred == 0) {
        if (dwError != 0) err_quit("dwError");
        closesocket(ptr->sock);
        printf("[TCP 서버] 클라이언트 종료 : IP  주소 = %s, 포트번호 = %d\r\n",
            inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
        delete ptr;
        return;
    }

    //데이터 전송량 갱신
    if (ptr->recvBytes == 0) {
        ptr->recvBytes = cbTransferred;
        ptr->sendBytes = 0;

        //받은 데이터 출력
        ptr->buf[ptr->recvBytes] = '\0';
        printf("[TCP /%s : %d] %s\r\n", inet_ntoa(clientaddr.sin_addr),
            ntohs(clientaddr.sin_port), ptr->buf);
    }
    else {
        ptr->sendBytes += cbTransferred;
    }

    if (ptr->recvBytes > ptr->sendBytes) {
        ZeroMemory(&ptr->overlapped, sizeof(ptr->overlapped));
        ptr->wsabuf.buf = ptr->buf + ptr->sendBytes;
        ptr->wsabuf.len = ptr->recvBytes - ptr->sendBytes;

        DWORD sendbytes;
        retVal = WSASend(ptr->sock, &ptr->wsabuf, 1, &sendbytes, 0, &ptr->overlapped, CompletionRoutine);
        if (retVal == SOCKET_ERROR) {
            if (WSAGetLastError() != WSA_IO_PENDING) {
                err_quit("WSASend()");
                return;
            }
        }
    }
    else{
        ptr->recvBytes = 0;

        //데이터 받기
        ZeroMemory(&ptr->overlapped, sizeof(ptr->overlapped));
        ptr->wsabuf.buf = ptr->buf;
        ptr->wsabuf.len = BUFSIZE;

        DWORD recvbytes;
        DWORD flags = 0;
        retVal = WSARecv(ptr->sock, &ptr->wsabuf, 1, &recvbytes, &flags, &ptr->overlapped, CompletionRoutine);
        if (retVal == SOCKET_ERROR) {
            if (WSAGetLastError() != WSA_IO_PENDING) {
                err_quit("WSASend()");
                return;
            }
        }
    }
}

void err_quit(const char* msg) {
    LPVOID lpMsgBuf;
    FormatMessage(
        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
        NULL, WSAGetLastError(),
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
        (LPTSTR)&lpMsgBuf, 0, NULL);
    printf("[%s] %s\n", msg, (char*)lpMsgBuf);
    LocalFree(lpMsgBuf);
    exit(1);
}