GetThePower

[Win32] IOCP 기반 + 길이 프레임 + Worker Thread 풀

powergirl — Sat, 27 Dec 2025 19:14:01 +0900

IOCP
+ OVERLAPPED 기반 비동기 recv/send
+ 길이(4byte) + 데이터 프레임
+ CPU 코어 기반 Worker Thread

Win32 서버 구조

main
 ├─ WSAStartup
 ├─ listen socket 생성
 ├─ IOCP 생성
 ├─ Worker Thread 풀 생성
 ├─ accept loop
 │    ├─ ClientContext 생성
 │    ├─ CreateIoCompletionPort (socket 등록)
 │    └─ 최초 WSARecv 요청
 └─ 종료 처리

전체 구조

MFC Project
 ├─ CMainDlg / CMainFrame (UI)
 ├─ IocpServer.h
 ├─ IocpServer.cpp
 └─ ClientContext.h

ClientContext.h

#pragma once
#include <winsock2.h>
#include <mswsock.h>

struct ClientContext
{
    SOCKET socket;
    OVERLAPPED overlapped;
    WSABUF wsaBuf;

    char buffer[4096];

    int recvBytes;
    int expectedBytes;

    ClientContext()
    {
        ZeroMemory(this, sizeof(ClientContext));
    }
};

순수 Win32 구조체 유지

IocpServer.h

#pragma once
#include <winsock2.h>
#include <vector>
#include "ClientContext.h"

class CIocpServer
{
public:
    CIocpServer();
    ~CIocpServer();

    bool Start(int port);
    void Stop();

private:
    static DWORD WINAPI WorkerThread(LPVOID param);

    void AcceptLoop();
    void CloseAllClients();

private:
    SOCKET m_listenSocket;
    HANDLE m_hIOCP;

    std::vector<HANDLE> m_workerThreads;
    bool m_running;
};

IocpServer.cpp

#include "IocpServer.h"
#include <process.h>

#define IOCP_EXIT_KEY 0xFFFFFFFF

CIocpServer::CIocpServer()
    : m_listenSocket(INVALID_SOCKET),
      m_hIOCP(NULL),
      m_running(false)
{
}

// 서버 시작
bool CIocpServer::Start(int port)
{
    WSADATA wsa;
    WSAStartup(MAKEWORD(2, 2), &wsa);

    m_listenSocket = socket(AF_INET, SOCK_STREAM, 0);

    SOCKADDR_IN addr{};
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = INADDR_ANY;

    bind(m_listenSocket, (SOCKADDR*)&addr, sizeof(addr));
    listen(m_listenSocket, SOMAXCONN);

    m_hIOCP = CreateIoCompletionPort(
        INVALID_HANDLE_VALUE,
        NULL,
        0,
        0
    );

    SYSTEM_INFO si;
    GetSystemInfo(&si);
    int workerCount = si.dwNumberOfProcessors * 2;

    for (int i = 0; i < workerCount; i++)
    {
        HANDLE hThread = CreateThread(
            NULL,
            0,
            WorkerThread,
            this,
            0,
            NULL
        );

        m_workerThreads.push_back(hThread);
    }

    m_running = true;

    AcceptLoop();
    return true;
}

// accept 루프
void CIocpServer::AcceptLoop()
{
    while (m_running)
    {
        SOCKET client = accept(m_listenSocket, NULL, NULL);
        if (client == INVALID_SOCKET)
            break;

        ClientContext* ctx = new ClientContext;
        ctx->socket = client;

        ctx->expectedBytes = sizeof(int);
        ctx->recvBytes = 0;

        ctx->wsaBuf.buf = ctx->buffer;
        ctx->wsaBuf.len = sizeof(int);

        CreateIoCompletionPort(
            (HANDLE)client,
            m_hIOCP,
            (ULONG_PTR)ctx,
            0
        );

        DWORD flags = 0;
        WSARecv(
            client,
            &ctx->wsaBuf,
            1,
            NULL,
            &flags,
            &ctx->overlapped,
            NULL
        );
    }
}

// Worker Thread
DWORD WINAPI CIocpServer::WorkerThread(LPVOID param)
{
    CIocpServer* server = (CIocpServer*)param;

    while (true)
    {
        DWORD bytes;
        ULONG_PTR key;
        OVERLAPPED* ov;

        GetQueuedCompletionStatus(
            server->m_hIOCP,
            &bytes,
            &key,
            &ov,
            INFINITE
        );

        if (key == IOCP_EXIT_KEY)
            break;

        ClientContext* ctx = (ClientContext*)key;

        if (bytes == 0)
        {
            closesocket(ctx->socket);
            delete ctx;
            continue;
        }

        ctx->recvBytes += bytes;

        if (ctx->recvBytes < ctx->expectedBytes)
        {
            ctx->wsaBuf.buf = ctx->buffer + ctx->recvBytes;
            ctx->wsaBuf.len = ctx->expectedBytes - ctx->recvBytes;

            WSARecv(ctx->socket, &ctx->wsaBuf, 1, NULL, 0, &ctx->overlapped, NULL);
            continue;
        }

        if (ctx->expectedBytes == sizeof(int))
        {
            int size;
            memcpy(&size, ctx->buffer, sizeof(int));
            ctx->expectedBytes = ntohl(size);
            ctx->recvBytes = 0;

            ctx->wsaBuf.buf = ctx->buffer;
            ctx->wsaBuf.len = ctx->expectedBytes;

            WSARecv(ctx->socket, &ctx->wsaBuf, 1, NULL, 0, &ctx->overlapped, NULL);
        }
        else
        {
            ctx->buffer[ctx->expectedBytes] = '\0';
            // 메시지 처리 지점

            ctx->expectedBytes = sizeof(int);
            ctx->recvBytes = 0;

            ctx->wsaBuf.buf = ctx->buffer;
            ctx->wsaBuf.len = sizeof(int);

            WSARecv(ctx->socket, &ctx->wsaBuf, 1, NULL, 0, &ctx->overlapped, NULL);
        }
    }

    return 0;
}

// 서버 종료
void CIocpServer::Stop()
{
    m_running = false;
    closesocket(m_listenSocket);

    for (size_t i = 0; i < m_workerThreads.size(); i++)
    {
        PostQueuedCompletionStatus(
            m_hIOCP,
            0,
            IOCP_EXIT_KEY,
            NULL
        );
    }

    WaitForMultipleObjects(
        (DWORD)m_workerThreads.size(),
        m_workerThreads.data(),
        TRUE,
        INFINITE
    );

    CloseHandle(m_hIOCP);
    WSACleanup();
}

MFC에서 사용하는 방법

CIocpServer m_server;

BOOL CMainDlg::OnInitDialog()
{
    m_server.Start(9000);
    return TRUE;
}

void CMainDlg::OnDestroy()
{
    m_server.Stop();
    CDialogEx::OnDestroy();
}

[Win32] IOCP Worker Thread 다중화

powergirl — Sat, 27 Dec 2025 19:05:50 +0900

Worker Thread 개수 권장 기준

SYSTEM_INFO si;
GetSystemInfo(&si);

int workerCount = si.dwNumberOfProcessors * 2;

Worker Thread 다중 생성

std::vector<HANDLE> g_workerThreads;

for (int i = 0; i < workerCount; i++)
{
    HANDLE hThread = CreateThread(
        NULL,
        0,
        WorkerThread,
        NULL,
        0,
        NULL
    );

    g_workerThreads.push_back(hThread);
}

종료용 Completion Packet 전송

for (int i = 0; i < workerCount; i++)
{
    PostQueuedCompletionStatus(
        g_hIOCP,
        0,
        IOCP_EXIT_KEY,
        NULL
    );
}

Worker Thread 종료 처리

DWORD WINAPI WorkerThread(LPVOID)
{
    while (true)
    {
        DWORD bytes;
        ULONG_PTR key;
        OVERLAPPED* ov;

        GetQueuedCompletionStatus(
            g_hIOCP,
            &bytes,
            &key,
            &ov,
            INFINITE
        );

        if (key == IOCP_EXIT_KEY)
        {
            break; // 정상 종료
        }

        ClientContext* ctx = (ClientContext*)key;

        if (bytes == 0)
        {
            closesocket(ctx->socket);
            delete ctx;
            continue;
        }

        // recv 처리...
    }

    return 0;
}

[Win32] IOCP 서버

powergirl — Sat, 27 Dec 2025 18:59:35 +0900

IOCP 는 Windows 전용 고성능 비동기 I/O 모델로, 정식 명칭은 I/O Completion Port.

IOCP 객체 (Completion Port)

HANDLE hIOCP = CreateIoCompletionPort(...);

작업 완료 알림을 넣어두는 큐

완료된 recv/send 결과가 쌓임

소켓을 IOCP에 등록

CreateIoCompletionPort(
    (HANDLE)clientSocket,
    hIOCP,
    (ULONG_PTR)clientContext,
    0
);

recv 요청

WSARecv(sock, &buf, 1, NULL, &flags, &ov, NULL);

IOCP 서버의 스레드

while (true)
{
    GetQueuedCompletionStatus(
        hIOCP,
        &bytes,
        &key,
        &overlapped,
        INFINITE
    );

    // 여기로 "작업 끝났음"이 들어옴
}

IOCP 서버 최소 동작 코드

Clientcontext - 핵심 구조체

struct ClientContext
{
    SOCKET socket;
    OVERLAPPED overlapped;
    WSABUF wsaBuf;
    char buffer[1024];
};

socket : 클라이언트 소켓

OVERLAPPED : 비동기 작업 식별자

WSABUF : recv 대상 버퍼

buffer : 실제 데이터 공간

전연 IOCP 핸들

HANDLE g_hIOCP;

Worker Thread

DWORD WINAPI WorkerThread(LPVOID)
{
    while (true)
    {
        DWORD bytesTransferred;
        ULONG_PTR completionKey;
        OVERLAPPED* pOverlapped;

        BOOL ret = GetQueuedCompletionStatus(
            g_hIOCP,
            &bytesTransferred,
            &completionKey,
            &pOverlapped,
            INFINITE
        );

        ClientContext* ctx = (ClientContext*)completionKey;

        if (bytesTransferred == 0)
        {
            closesocket(ctx->socket);
            delete ctx;
            continue;
        }

        ctx->buffer[bytesTransferred] = '\0';
        printf("Recv: %s\n", ctx->buffer);

        // 다시 recv 요청
        ZeroMemory(&ctx->overlapped, sizeof(OVERLAPPED));

        DWORD flags = 0;
        WSARecv(
            ctx->socket,
            &ctx->wsaBuf,
            1,
            NULL,
            &flags,
            &ctx->overlapped,
            NULL
        );
    }
}

서버 초기화 & 메인

int main()
{
    WSADATA wsa;
    WSAStartup(MAKEWORD(2, 2), &wsa);

    SOCKET listenSock = socket(AF_INET, SOCK_STREAM, 0);

    SOCKADDR_IN addr{};
    addr.sin_family = AF_INET;
    addr.sin_port = htons(9000);
    addr.sin_addr.s_addr = INADDR_ANY;

    bind(listenSock, (SOCKADDR*)&addr, sizeof(addr));
    listen(listenSock, SOMAXCONN);

    // IOCP 생성
    g_hIOCP = CreateIoCompletionPort(
        INVALID_HANDLE_VALUE,
        NULL,
        0,
        0
    );

    // Worker Thread 1개 (최소)
    CreateThread(NULL, 0, WorkerThread, NULL, 0, NULL);

    printf("IOCP Server Start\n");

    while (true)
    {
        SOCKET clientSock = accept(listenSock, NULL, NULL);

        ClientContext* ctx = new ClientContext;
        ZeroMemory(ctx, sizeof(ClientContext));

        ctx->socket = clientSock;
        ctx->wsaBuf.buf = ctx->buffer;
        ctx->wsaBuf.len = sizeof(ctx->buffer);

        // 소켓을 IOCP에 연결
        CreateIoCompletionPort(
            (HANDLE)clientSock,
            g_hIOCP,
            (ULONG_PTR)ctx,
            0
        );

        // 최초 recv 요청
        DWORD flags = 0;
        WSARecv(
            clientSock,
            &ctx->wsaBuf,
            1,
            NULL,
            &flags,
            &ctx->overlapped,
            NULL
        );
    }

    return 0;
}

IOCP에서 길이 + 데이터 프레임 처리

전송 규칙

[4바이트 길이][데이터 본문]

ClientContext 확장

struct ClientContext
{
    SOCKET socket;
    OVERLAPPED overlapped;
    WSABUF wsaBuf;

    char buffer[4096];

    int recvBytes;      // 지금까지 받은 바이트
    int expectedBytes;  // 이번에 받아야 할 총 바이트
};

IOCP에서는 “상태”를 Context에 저장한다

최초 recv 요청 (길이 4바이트)

ctx->recvBytes = 0;
ctx->expectedBytes = sizeof(int);

ctx->wsaBuf.buf = ctx->buffer;
ctx->wsaBuf.len = ctx->expectedBytes;

WSARecv(
    ctx->socket,
    &ctx->wsaBuf,
    1,
    NULL,
    0,
    &ctx->overlapped,
    NULL
);

WorkerThread에서 프레임 처리

DWORD WINAPI WorkerThread(LPVOID)
{
    while (true)
    {
        DWORD bytesTransferred;
        ULONG_PTR key;
        OVERLAPPED* ov;

        GetQueuedCompletionStatus(
            g_hIOCP,
            &bytesTransferred,
            &key,
            &ov,
            INFINITE
        );

        ClientContext* ctx = (ClientContext*)key;

        if (bytesTransferred == 0)
        {
            closesocket(ctx->socket);
            delete ctx;
            continue;
        }

        ctx->recvBytes += bytesTransferred;

        if (ctx->recvBytes < ctx->expectedBytes)
        {
            // 아직 부족 → 계속 recv
            ctx->wsaBuf.buf = ctx->buffer + ctx->recvBytes;
            ctx->wsaBuf.len = ctx->expectedBytes - ctx->recvBytes;

            WSARecv(
                ctx->socket,
                &ctx->wsaBuf,
                1,
                NULL,
                0,
                &ctx->overlapped,
                NULL
            );
            continue;
        }

        // 여기 오면 "이번 프레임 완성"

길이 프레임인지 / 데이터 프레임인지 구분

        if (ctx->expectedBytes == sizeof(int))
        {
            int bodySize;
            memcpy(&bodySize, ctx->buffer, sizeof(int));
            bodySize = ntohl(bodySize);

            ctx->recvBytes = 0;
            ctx->expectedBytes = bodySize;

            ctx->wsaBuf.buf = ctx->buffer;
            ctx->wsaBuf.len = bodySize;

            WSARecv(
                ctx->socket,
                &ctx->wsaBuf,
                1,
                NULL,
                0,
                &ctx->overlapped,
                NULL
            );
        }
        else
        {
            // 데이터 프레임 완성
            ctx->buffer[ctx->expectedBytes] = '\0';
            printf("Recv Msg: %s\n", ctx->buffer);

            // 다시 길이부터 받기
            ctx->recvBytes = 0;
            ctx->expectedBytes = sizeof(int);

            ctx->wsaBuf.buf = ctx->buffer;
            ctx->wsaBuf.len = sizeof(int);

            WSARecv(
                ctx->socket,
                &ctx->wsaBuf,
                1,
                NULL,
                0,
                &ctx->overlapped,
                NULL
            );
        }
    }
}

[Win32] select 서버

powergirl — Sat, 27 Dec 2025 15:40:17 +0900

	Thread model	select model
Thread	클라이엉트 수만큼	1개
recv	블로킹	준비된 소켓만
구조	직관적	상태 기반
확장성	낮음	중간

select 는 recv 를 대신하는 게 아니라, recv 를 호출해도 되는 타이밍을 알려줌

select 서버 전체 흐름

while (true)
{
    select(...)
    for (읽기 가능한 소켓)
    {
        if (아직 길이 안 받음)
            recv 길이
        else
            recv 데이터
    }
}

select 서버에 필요한 구조체

struct ClientInfo
{
    SOCKET socket;
    int expectedSize;   // 다음에 받아야 할 데이터 크기
    int receivedSize;   // 지금까지 받은 크기
    char buffer[1024];
};

select 준비

fd_set readSet;
FD_ZERO(&readSet);
FD_SET(listenSock, &readSet);

for (auto& c : clients)
{
    FD_SET(c.socket, &readSet);
}

select(0, &readSet, NULL, NULL, NULL);

새 클라이언트 accept

if (FD_ISSET(listenSock, &readSet))
{
    SOCKET clientSock = accept(listenSock, NULL, NULL);

    ClientInfo ci;
    ci.socket = clientSock;
    ci.expectedSize = 0;
    ci.receivedSize = 0;

    clients.push_back(ci);
}

길이 수신

if (ci.expectedSize == 0)
{
    int ret = recv(
        ci.socket,
        (char*)&ci.expectedSize + ci.receivedSize,
        sizeof(int) - ci.receivedSize,
        0
    );

    if (ret <= 0)
    {
        // 연결 종료 처리
        continue;
    }

    ci.receivedSize += ret;

    if (ci.receivedSize == sizeof(int))
    {
        ci.expectedSize = ntohl(ci.expectedSize);
        ci.receivedSize = 0;
    }
}

데이터 수신

else
{
    int ret = recv(
        ci.socket,
        ci.buffer + ci.receivedSize,
        ci.expectedSize - ci.receivedSize,
        0
    );

    if (ret <= 0)
    {
        // 연결 종료 처리
        continue;
    }

    ci.receivedSize += ret;

    if (ci.receivedSize == ci.expectedSize)
    {
        ci.buffer[ci.expectedSize] = '\0';
        std::cout << "메시지: " << ci.buffer << std::endl;

        // 상태 초기화
        ci.expectedSize = 0;
        ci.receivedSize = 0;
    }
}

서버

#define _WINSOCK_DEPRECATED_NO_WARNINGS
#include <winsock2.h>
#include <ws2tcpip.h>
#include <windows.h>
#include <iostream>
#include <vector>

#pragma comment(lib, "ws2_32.lib")

#define SERVER_PORT 9000
#define MAX_BUF 1024

// ================================
// 클라이언트 상태 구조체
// ================================
struct ClientInfo
{
    SOCKET socket;

    int expectedSize;     // 다음에 받아야 할 데이터 크기
    int receivedSize;     // 현재까지 받은 크기

    char buffer[MAX_BUF];
};

int main()
{
    WSADATA wsa;
    WSAStartup(MAKEWORD(2, 2), &wsa);

    SOCKET listenSock = socket(AF_INET, SOCK_STREAM, 0);

    SOCKADDR_IN serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serverAddr.sin_port = htons(SERVER_PORT);

    bind(listenSock, (SOCKADDR*)&serverAddr, sizeof(serverAddr));
    listen(listenSock, SOMAXCONN);

    std::cout << "select 서버 시작 (Port: " << SERVER_PORT << ")\n";

    std::vector<ClientInfo> clients;

    while (true)
    {
        fd_set readSet;
        FD_ZERO(&readSet);

        FD_SET(listenSock, &readSet);
        SOCKET maxSock = listenSock;

        for (auto& c : clients)
        {
            FD_SET(c.socket, &readSet);
            if (c.socket > maxSock)
                maxSock = c.socket;
        }

        int ret = select(0, &readSet, NULL, NULL, NULL);
        if (ret <= 0)
            continue;

        // ================================
        // 새 클라이언트 접속
        // ================================
        if (FD_ISSET(listenSock, &readSet))
        {
            SOCKET clientSock = accept(listenSock, NULL, NULL);

            ClientInfo ci;
            ci.socket = clientSock;
            ci.expectedSize = 0;
            ci.receivedSize = 0;

            clients.push_back(ci);

            std::cout << "[접속] socket=" << clientSock << "\n";
        }

        // ================================
        // 클라이언트 데이터 처리
        // ================================
        for (int i = 0; i < clients.size(); )
        {
            ClientInfo& ci = clients[i];

            if (!FD_ISSET(ci.socket, &readSet))
            {
                ++i;
                continue;
            }

            // ----------------------------
            // 1️⃣ 길이 수신 단계
            // ----------------------------
            if (ci.expectedSize == 0)
            {
                int ret = recv(
                    ci.socket,
                    ((char*)&ci.expectedSize) + ci.receivedSize,
                    sizeof(int) - ci.receivedSize,
                    0
                );

                if (ret <= 0)
                {
                    std::cout << "[종료] socket=" << ci.socket << "\n";
                    closesocket(ci.socket);
                    clients.erase(clients.begin() + i);
                    continue;
                }

                ci.receivedSize += ret;

                if (ci.receivedSize == sizeof(int))
                {
                    ci.expectedSize = ntohl(ci.expectedSize);

                    // 방어 코드
                    if (ci.expectedSize <= 0 || ci.expectedSize > MAX_BUF)
                    {
                        closesocket(ci.socket);
                        clients.erase(clients.begin() + i);
                        continue;
                    }

                    ci.receivedSize = 0;
                }
            }
            // ----------------------------
            // 2️⃣ 데이터 수신 단계
            // ----------------------------
            else
            {
                int ret = recv(
                    ci.socket,
                    ci.buffer + ci.receivedSize,
                    ci.expectedSize - ci.receivedSize,
                    0
                );

                if (ret <= 0)
                {
                    std::cout << "[종료] socket=" << ci.socket << "\n";
                    closesocket(ci.socket);
                    clients.erase(clients.begin() + i);
                    continue;
                }

                ci.receivedSize += ret;

                if (ci.receivedSize == ci.expectedSize)
                {
                    ci.buffer[ci.expectedSize] = '\0';

                    std::cout << "[메시지] "
                              << ci.buffer << "\n";

                    // 상태 초기화
                    ci.expectedSize = 0;
                    ci.receivedSize = 0;
                }
            }

            ++i;
        }
    }

    closesocket(listenSock);
    WSACleanup();
    return 0;
}

[Win32] 네트워크 메시지 경계 처리 - Length Prefix

powergirl — Sat, 27 Dec 2025 15:12:07 +0900

[4바이트 길이][실제 데이터]

recvAll

int recvAll(SOCKET sock, char* buf, int totalSize)
{
    int received = 0;

    while (received < totalSize)
    {
        int ret = recv(
            sock,
            buf + received,
            totalSize - received,
            0
        );

        if (ret <= 0)
        {
            return -1; // 연결 종료 or 오류
        }

        received += ret;
    }

    return received;
}

recv(
    sock,                  // 어느 소켓에서
    buf + received,        // 버퍼의 "다음 빈 자리"
    totalSize - received,  // 아직 필요한 양
    0
);

recv 시나리오

100바이트 요청 >> 실제로는 40바이트만 옴

recv #1 >> 40바이트
recv #2 >> 60바이트

그래서 누적 수신이 필요함

buf + received

buf 시작 주소
↓
[ ][ ][ ][ ][ ][ ][ ][ ][ ][ ]  ← totalSize 만큼

첫 번째 recv

received = 0;

recv(sock, buf + 0, totalSize - 0, 0);

결과

[ A ][ B ][ C ][ D ][ ][ ][ ][ ][ ][ ]

buf[0]부터 채움

두 번째 recv

received = 4;

recv(sock, buf + 4, totalSize - 4, 0);

결과

[ A ][ B ][ C ][ D ][ E ][ F ][ G ][ H ][ ][ ]

만약,

received = 4;

recv(sock, buf, totalSize, 0);

이랬으면

[ E ][ F ][ G ][ H ][ ][ ][ ][ ][ ][ ]

기존 데이터를 덮어썼을 것

[Win32] 서버 확장 : Thread 도입

powergirl — Sat, 27 Dec 2025 14:20:00 +0900

서버 스레드 설계

main thread >> listen / accept

client thread >> recv / send / disconnect

스레드 함수

DWORD WINAPI ClientThread(LPVOID lpParam)
{
    ClientInfo* info = (ClientInfo*)lpParam;
    SOCKET clientSocket = info->socket;
    SOCKADDR_IN clientAddr = info->addr;

    printf("클라이언트 처리 시작: %s:%d\n",
        inet_ntoa(clientAddr.sin_addr),
        ntohs(clientAddr.sin_port));

    int timeout = 5000;
    setsockopt(clientSocket, SOL_SOCKET, SO_RCVTIMEO,
        (char*)&timeout, sizeof(timeout));

    while (true)
    {
        int value = 0;
        int ret = recv(clientSocket, (char*)&value, sizeof(int), 0);

        if (ret > 0)
        {
            printf("[%s] %d 수신\n",
                inet_ntoa(clientAddr.sin_addr), value);
        }
        else if (ret == 0)
        {
            printf("[%s] 정상 종료\n",
                inet_ntoa(clientAddr.sin_addr));
            break;
        }
        else
        {
            int err = WSAGetLastError();
            if (err == WSAETIMEDOUT)
            {
                continue;
            }
            else
            {
                printf("[%s] recv 에러: %d\n",
                    inet_ntoa(clientAddr.sin_addr), err);
                break;
            }
        }
    }

    closesocket(clientSocket);
    delete info;

    printf("클라이언트 스레드 종료\n");
    return 0;
}

메인 서버 코드 (accept + 스레드 생성)

while (true)
{
    SOCKADDR_IN clientAddr = {};
    int addrSize = sizeof(clientAddr);

    SOCKET clientSocket =
        accept(listenSocket, (SOCKADDR*)&clientAddr, &addrSize);

    ClientInfo* info = new ClientInfo;
    info->socket = clientSocket;
    info->addr = clientAddr;

    HANDLE hThread = CreateThread(
        nullptr,
        0,
        ClientThread,
        info,
        0,
        nullptr
    );

    CloseHandle(hThread); // 핸들 누수 방지
}

구조체로 전달

struct ClientInfo
{
    SOCKET socket;
    SOCKADDR_IN addr;
};

서버

#define _WINSOCK_DEPRECATED_NO_WARNINGS
#include <winsock2.h>
#include <ws2tcpip.h>
#include <windows.h>
#include <process.h>
#include <iostream>

#pragma comment(lib, "ws2_32.lib")

#define SERVER_PORT 9000
#define BUF_SIZE 1024

// ================================
// 클라이언트 정보 구조체 (실무 정석)
// ================================
struct ClientInfo
{
    SOCKET socket;
    SOCKADDR_IN addr;
};

// ================================
// 클라이언트 처리 스레드
// ================================
unsigned int __stdcall ClientThread(void* arg)
{
    ClientInfo* pClient = (ClientInfo*)arg;

    SOCKET clientSock = pClient->socket;
    SOCKADDR_IN clientAddr = pClient->addr;

    char ip[32];
    inet_ntop(AF_INET, &clientAddr.sin_addr, ip, sizeof(ip));

    std::cout << "[접속] IP: " << ip
              << " PORT: " << ntohs(clientAddr.sin_port) << std::endl;

    char buf[BUF_SIZE];

    while (true)
    {
        int recvBytes = recv(clientSock, buf, BUF_SIZE, 0);

        if (recvBytes <= 0)
        {
            std::cout << "[종료] IP: " << ip << std::endl;
            break;
        }

        // 받은 데이터 출력
        std::cout << "[수신] (" << ip << ") "
                  << std::string(buf, recvBytes) << std::endl;
    }

    closesocket(clientSock);
    delete pClient;   // ⭐ 반드시 힙 해제

    return 0;
}

// ================================
// main
// ================================
int main()
{
    WSADATA wsa;
    WSAStartup(MAKEWORD(2, 2), &wsa);

    SOCKET listenSock = socket(AF_INET, SOCK_STREAM, 0);

    SOCKADDR_IN serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serverAddr.sin_port = htons(SERVER_PORT);

    bind(listenSock, (SOCKADDR*)&serverAddr, sizeof(serverAddr));
    listen(listenSock, SOMAXCONN);

    std::cout << "서버 시작 (Port: " << SERVER_PORT << ")" << std::endl;

    while (true)
    {
        SOCKADDR_IN clientAddr;
        int addrLen = sizeof(clientAddr);

        SOCKET clientSock = accept(
            listenSock,
            (SOCKADDR*)&clientAddr,
            &addrLen
        );

        if (clientSock == INVALID_SOCKET)
        {
            continue;
        }

        // ================================
        // 클라이언트 정보 힙 할당
        // ================================
        ClientInfo* pClient = new ClientInfo;
        pClient->socket = clientSock;
        pClient->addr = clientAddr;

        _beginthreadex(
            NULL,
            0,
            ClientThread,
            pClient,
            0,
            NULL
        );
    }

    closesocket(listenSock);
    WSACleanup();
    return 0;
}

[Win32] Windows Socket 기초 - recv 무한 대기 방지

powergirl — Sat, 27 Dec 2025 13:45:26 +0900

recv 타임아웃

setsockopt + SO_RCVTIMEO

int timeout = 5000; // 5초
setsockopt(clientSocket, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout, sizeof(timeout));

5초동안 데이터 안 오면 recv() 실패 / 반환값 : SOCKET_ERROR

WSAGetLstError() >> WSAETIMEDOUT

클라이언트 정보 출력

inet_ntoa(clientAddr.sin_addr);
ntohs(clientAddr.sin_port);

recv 반환값

int ret = recv(clientSocket, (char*)&value, sizeof(int), 0);

ret > 0 : 받은 바이트 수

ret == 0 : 상대방 정상 종료

ret < 0 : 오류

서버

// SB003_Server.cpp
#include <winsock2.h>
#include <stdio.h>

#pragma comment(lib, "ws2_32.lib")

int main()
{
    WSADATA wsaData;
    WSAStartup(MAKEWORD(2, 2), &wsaData);

    SOCKET listenSocket = socket(AF_INET, SOCK_STREAM, 0);

    SOCKADDR_IN serverAddr = {};
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(9000);
    serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);

    bind(listenSocket, (SOCKADDR*)&serverAddr, sizeof(serverAddr));
    listen(listenSocket, SOMAXCONN);

    printf("서버 시작\n");

    while (true)
    {
        SOCKADDR_IN clientAddr = {};
        int addrSize = sizeof(clientAddr);
        SOCKET clientSocket = accept(listenSocket, (SOCKADDR*)&clientAddr, &addrSize);

        printf("접속: %s:%d\n",
               inet_ntoa(clientAddr.sin_addr),
               ntohs(clientAddr.sin_port));

        int timeout = 5000;
        setsockopt(clientSocket, SOL_SOCKET, SO_RCVTIMEO,
                   (char*)&timeout, sizeof(timeout));

        while (true)
        {
            int value = 0;
            int ret = recv(clientSocket, (char*)&value, sizeof(int), 0);

            if (ret > 0)
            {
                printf("수신 값: %d\n", value);
            }
            else if (ret == 0)
            {
                printf("클라이언트 연결 종료\n");
                break;
            }
            else
            {
                int err = WSAGetLastError();
                if (err == WSAETIMEDOUT)
                {
                    printf("수신 타임아웃\n");
                    continue;
                }
                else
                {
                    printf("recv 에러: %d\n", err);
                    break;
                }
            }
        }

        closesocket(clientSocket);
        printf("클라이언트 소켓 닫힘\n");
    }

    closesocket(listenSocket);
    WSACleanup();
    return 0;
}

[Win32] Windows Socket 기초 - TCP 연습

powergirl — Sat, 27 Dec 2025 13:29:43 +0900

1. WinSock 초기화

WSAStartup(MAKEWORD(2, 2), &wsaData);

Windows 는 소켓을 라이브러리로 제공함

필수

2. 서버 소켓 생성

SOCKET listenSocket = socket(AF_INET, SOCK_STREAM, 0);

AF_INET >> IPv4

SOCK_STREAM >> TCP

3. 서버 주소 설정

serverAddr.sin_port = htons(9000);

htons >> Host TO Network Short

네트워크는 Big Endian

4. bind / listen

bind(listenSocket, (SOCKADDR*)&serverAddr, sizeof(serverAddr));
listen(listenSocket, SOMAXCONN);

5. accept

SOCKET clientSocket = accept(listenSocket, (SOCKADDR*)&clientAddr, &addrSize);

클라이언트 접속 전까지 무한 대기

accept 는 TCP 연결 요청이 들어올 때까지 커널 레벨에서 대기 한다.

블로킹 함수.

recv

recv(clientSocket, (char*)&value, sizeof(int), 0);

recv 는 수신 버퍼에 데이터가 도착하는 순간 풀림

recv 가 풀리는 조건

1. 커널 수신 버퍼에 데이터가 1바이트라도 도착

2. 상대방이 연결을 종료 (FIN 수신)

3. 에러 발생

sizeof(int)

TCP 는 데이터 타입을 모름

몇 바이트를 읽어야 할지 서버가 알 방법이 없음

"4바이트 정수" 라는 명시적 약속

서버

// SB002_Server.cpp
#include <winsock2.h>
#include <stdio.h>

#pragma comment(lib, "ws2_32.lib")

int main()
{
    WSADATA wsaData;
    WSAStartup(MAKEWORD(2, 2), &wsaData);

    SOCKET listenSocket = socket(AF_INET, SOCK_STREAM, 0);

    SOCKADDR_IN serverAddr = {};
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(9000);
    serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);

    bind(listenSocket, (SOCKADDR*)&serverAddr, sizeof(serverAddr));
    listen(listenSocket, SOMAXCONN);

    printf("서버 시작\n");

    while (true)
    {
        printf("클라이언트 접속 대기...\n");

        SOCKADDR_IN clientAddr = {};
        int addrSize = sizeof(clientAddr);
        SOCKET clientSocket = accept(listenSocket, (SOCKADDR*)&clientAddr, &addrSize);

        printf("클라이언트 접속됨\n");

        int value = 0;
        recv(clientSocket, (char*)&value, sizeof(int), 0);

        printf("수신 값: %d\n", value);

        closesocket(clientSocket);
    }

    closesocket(listenSocket);
    WSACleanup();
    return 0;
}

클라

// SB001_Client.cpp
#include <winsock2.h>
#include <stdio.h>

#pragma comment(lib, "ws2_32.lib")

int main()
{
    WSADATA wsaData;
    WSAStartup(MAKEWORD(2, 2), &wsaData);

    SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);

    SOCKADDR_IN serverAddr = {};
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(9000);
    serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    connect(sock, (SOCKADDR*)&serverAddr, sizeof(serverAddr));

    int value = 1234;
    send(sock, (char*)&value, sizeof(int), 0);

    closesocket(sock);
    WSACleanup();

    return 0;
}

[MFC] ListBox

powergirl — Thu, 25 Dec 2025 07:45:48 +0900

도구상자에서 List Box 추가

List Box 에서 오른쪽 버튼 클릭 후 변수 추가

이렇게하면

.h

.cpp

응용예제 - 로그출력 화면처럼 표현

void CDUMMYDlg::OnBnClickedButton1()
{
	// 에딧에 입력한거
	CString msg;
	GetDlgItemText(IDC_EDIT2, msg);

	int index = m_listBox.InsertString(-1, msg);

	m_listBox.SetCurSel(index);
}

현재 선택된 인덱

int index = m_listBox.GetCurSel();

아이템 추가 - AddString();

m_listBox.AddString(L"Apple");
m_listBox.AddString(L"Banana");
m_listBox.AddString(L"Orange");

전체 삭제 - ResetContent()

m_listBox.ResetContent();

아이템 개수 - GetCount()

int count = m_listBox.GetCount();

선택된 문자열 가져오기 - GetText

CString text;
int index = m_listBox.GetCurSel();

if (index != LB_ERR)
{
    m_listBox.GetText(index, text);
}

특정 인덱스 삭제

m_listBox.DeleteString(index);

특정 위치에 삽

m_listBox.InsertString(1, L"Inserted Item");

끝에 저장하려면 첫번째 매개변수 0으로

더블클릭시에 해당 인덱스 팝업

void CMyDlg::OnLbnDblclkList1()
{
    int index = m_listBox.GetCurSel();

    if (index != LB_ERR)
    {
        CString text;
        m_listBox.GetText(index, text);

        AfxMessageBox(text);
    }
}

[MFC] Dialog 추가하기 - DoModal

powergirl — Thu, 25 Dec 2025 04:41:37 +0900

화면 생성

리소스뷰 >> 프로젝트 솔루션 >> Dialog 오른쪽 버튼 >> 삽입

클래스 생성

새로운 대화상자 사용하기 위해서 클래스 생성

대화상자 더블클릭하면 클래스 추가하는 창이 뜸

정형 Dialog (새로운 대화상자 활성화 시 기존 대화상자로 못 감)

대화상자 열기 - DoModal()

#include "PopUp.h";

void CDUMMYDlg::OnBnClickedPopupOpenBtn()
{
	PopUp popup;

	popup.DoModal();
}

값을 양쪽으로 전달하기

값 전달하기 위해서는 저장할 공간 필요

>> 결국 값을 가지고 있을곳은 팝업창의 클래스

PopUp.h

MainDlg.cpp

#include "PopUp.h";

void CDUMMYDlg::OnBnClickedPopupOpenBtn()
{
	int num = GetDlgItemInt(IDC_EDIT1);
    
	PopUp popup;
	popup.SetNum(num);
	popup.DoModal();
}

PopUp 클래스에 init 이 없어서 추가

// PopUp 메시지 처리기

BOOL PopUp::OnInitDialog()
{
	CDialogEx::OnInitDialog();
	// TODO:  여기에 추가 초기화 작업을 추가합니다.

	SetDlgItemInt(IDC_EDIT1, num);

	return TRUE;  
}

추가 - 팝업창에서 확인 버튼 누르면 기존 창의 Edit Control 0으로