TcpServer 클래스 참조

#include <TcpServer.h>

TcpServer에 대한 협력 다이어그램:

클래스
class	Session

Public 타입
using	CommandHandler = std::function<std::string(const std::string &, const std::weak_ptr<Session> &)>

Public 멤버 함수
void	setHandler (CommandHandler handler)
bool	start (uint16_t port)
void	stop ()
	TcpServer ()
	~TcpServer ()

정적 Public 멤버 함수
static std::weak_ptr< Session >	currentSession ()

Private 멤버 함수
void	acceptLoop ()
void	closeSocket (SOCKET s)
bool	recvAck (SOCKET s, uint32_t timeoutMs)
bool	sendAck (SOCKET s)

Private 속성
std::thread	m_acceptThread
CommandHandler	m_handler
SOCKET	m_listen {INVALID_SOCKET}
std::atomic< bool >	m_running {false}

멤버 타입정의 문서화

CommandHandler

using TcpServer::CommandHandler = std::function<std::string(const std::string &, const std::weak_ptr<Session> &)>

생성자 & 소멸자 문서화

TcpServer()

TcpServer::TcpServer

(

)

{}

~TcpServer()

TcpServer::~TcpServer

(

)

{ stop(); }

다음을 참조함 : stop().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

멤버 함수 문서화

acceptLoop()

void TcpServer::acceptLoop ( )

private

{
    while (m_running.load())
    {
        sockaddr_in caddr{};
        int clen = sizeof(caddr);
        SOCKET client = ::accept(m_listen, (sockaddr *)&caddr, &clen);
 
        if (client == INVALID_SOCKET)
        {
            if (!m_running.load())
                break;
            std::this_thread::sleep_for(std::chrono::milliseconds(50));
            continue;
        }
 
        Logger::debug(L"클라이언트 연결 수락");
 
        // 거래당 연결: 요청 수신 → ACK → 처리 → 응답 → ACK 대기 → 연결 종료
        // 단, PING 명령은 연결 유지 (Keep-Alive)
        std::thread([this, client]()
                    {
            auto session = std::make_shared<Session>(client);
            g_threadSession = session;
            char buf[4096];
            bool keepAlive = false;
 
            // PING의 경우 연결을 유지하고 계속 명령 수신
            do {
                std::string request;
 
                // 1. 요청 수신 (개행으로 종료 판단, 세미콜론은 데이터 구분자)
                bool reqComplete = false;
                while (!reqComplete)
                {
                    int r = ::recv(client, buf, sizeof(buf), 0);
                    if (r <= 0)
                    {
                        session->markClosed();
                        g_threadSession.reset();
                        return;
                    }
 
                    request.append(buf, r);
 
                    // 요청 완료 판단: \n로 끝나면 완료
                    if (!request.empty() && request.back() == '\n')
                        reqComplete = true;
 
                    // 타임아웃 방지: 일정 크기 이상이면 강제 완료
                    if (request.size() > 2048)
                        reqComplete = true;
                }
 
                // 요청 정리 (개행/공백 제거)
                while (!request.empty() && (request.back() == '\r' || request.back() == '\n' || request.back() == ' '))
                    request.pop_back();
 
                if (request.empty())
                {
                    Logger::warn(L"빈 요청 수신");
                    session->markClosed();
                    g_threadSession.reset();
                    return;
                }
 
                Logger::debug(std::wstring(L"요청 수신: ") + std::wstring(request.begin(), request.end()));
 
                // PING 명령 확인 (대소문자 무시)
                std::string cmdCheck = request;
                std::transform(cmdCheck.begin(), cmdCheck.end(), cmdCheck.begin(), 
                             [](unsigned char c) { return (char)std::toupper(c); });
                keepAlive = (cmdCheck == "PING" || cmdCheck.substr(0, 5) == "PING ");
 
                // 2. ACK 전송
                if (!sendAck(client))
                {
                    Logger::warn(L"ACK 전송 실패");
                    session->markClosed();
                    g_threadSession.reset();
                    return;
                }
                Logger::debug(L"ACK 전송 완료");
 
                // 3. 핸들러 호출 (동기 처리)
                std::string response;
                if (m_handler)
                {
                    response = m_handler(request, session);
                }
                else
                {
                    response = "ERR=NO_HANDLER";
                }
 
                if (response.empty())
                    response = "ERR=EMPTY_RESPONSE";
 
                // 로그 출력 (UTF-8 → UTF-16 변환, 길이 제한)
                int wlen = ::MultiByteToWideChar(CP_UTF8, 0, response.c_str(), (int)response.size(), nullptr, 0);
                std::wstring wResp;
                if (wlen > 0)
                {
                    wResp.resize(wlen);
                    ::MultiByteToWideChar(CP_UTF8, 0, response.c_str(), (int)response.size(), wResp.data(), wlen);
                }
                if (wResp.size() > 300)
                    wResp = wResp.substr(0, 300) + L"...";
                Logger::debug(L"응답 준비 완료: " + wResp);
 
                // 4. 응답 전송
                if (!session->sendLine(response))
                {
                    Logger::warn(L"응답 전송 중 오류");
                    session->markClosed();
                    g_threadSession.reset();
                    return;
                }
 
                int totalSent = static_cast<int>(response.size());
 
                {
                    std::wstringstream ss;
                    ss << L"응답 전송 완료: " << totalSent << L" bytes";
                    Logger::debug(ss.str());
                }
 
                // 5. ACK 대기 (선택적)
                bool ackOk = recvAck(client, 1000);
                Logger::debug(ackOk ? L"클라이언트 ACK 수신" : L"클라이언트 ACK 미수신 (무시)");
 
                if (keepAlive)
                {
                    Logger::debug(L"PING 명령 - 연결 유지");
                }
 
            } while (keepAlive); // PING의 경우 계속 루프
 
            // 6. 연결 종료
            session->markClosed();
            g_threadSession.reset();
            Logger::debug(L"거래 완료, 연결 종료"); })
            .detach();
    }
}

다음을 참조함 : g_threadSession, m_handler, m_listen, m_running, recvAck(), sendAck().

다음에 의해서 참조됨 : start().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

closeSocket()

void TcpServer::closeSocket ( SOCKET s )

private

{
    if (s != INVALID_SOCKET)
    {
        ::shutdown(s, SD_BOTH);
        ::closesocket(s);
    }
}

다음에 의해서 참조됨 : start(), stop().

이 함수를 호출하는 함수들에 대한 그래프입니다.:

currentSession()

std::weak_ptr< TcpServer::Session > TcpServer::currentSession ( )

static

{
    return g_threadSession;
}

다음을 참조함 : g_threadSession.

recvAck()

bool TcpServer::recvAck ( SOCKET s, uint32_t timeoutMs )

private

{
    // Windows 소켓: SO_RCVTIMEO는 DWORD(밀리초) 사용
    DWORD timeout = static_cast<DWORD>(timeoutMs);
    ::setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (const char *)&timeout, sizeof(timeout));
 
    char ackBuf[3] = {0};
    int r = ::recv(s, ackBuf, 3, 0);
 
    if (r == 3 && memcmp(ackBuf, ACK_PACKET, 3) == 0)
        return true;
 
    return false; // ACK 미수신도 허용
}

다음을 참조함 : ACK_PACKET.

다음에 의해서 참조됨 : acceptLoop().

이 함수를 호출하는 함수들에 대한 그래프입니다.:

sendAck()

bool TcpServer::sendAck ( SOCKET s )

private

{
    int n = ::send(s, ACK_PACKET, sizeof(ACK_PACKET), 0);
    return n == sizeof(ACK_PACKET);
}

다음을 참조함 : ACK_PACKET.

다음에 의해서 참조됨 : acceptLoop().

이 함수를 호출하는 함수들에 대한 그래프입니다.:

setHandler()

void TcpServer::setHandler

(

CommandHandler

handler

)

{
    m_handler = std::move(handler);
}

다음을 참조함 : m_handler.

다음에 의해서 참조됨 : wWinMain().

이 함수를 호출하는 함수들에 대한 그래프입니다.:

start()

bool TcpServer::start

(

uint16_t

port

)

{
    if (m_running.load())
        return true;
 
    m_listen = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (m_listen == INVALID_SOCKET)
    {
        Logger::error(L"TcpServer: socket 생성 실패");
        return false;
    }
 
    BOOL reuse = TRUE;
    ::setsockopt(m_listen, SOL_SOCKET, SO_REUSEADDR, (const char *)&reuse, sizeof(reuse));
 
    sockaddr_in addr{};
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = ::htonl(INADDR_ANY);
    addr.sin_port = ::htons(port);
 
    if (::bind(m_listen, (sockaddr *)&addr, sizeof(addr)) == SOCKET_ERROR)
    {
        Logger::error(L"TcpServer: bind 실패");
        closeSocket(m_listen);
        return false;
    }
 
    if (::listen(m_listen, SOMAXCONN) == SOCKET_ERROR)
    {
        Logger::error(L"TcpServer: listen 실패");
        closeSocket(m_listen);
        return false;
    }
 
    m_running = true;
    m_acceptThread = std::thread(&TcpServer::acceptLoop, this);
    Logger::info(L"TcpServer: 시작됨 (거래당 연결 모델)");
    return true;
}

다음을 참조함 : acceptLoop(), closeSocket(), m_acceptThread, m_listen, m_running.

다음에 의해서 참조됨 : wWinMain().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

stop()

void TcpServer::stop

(

)

{
    if (!m_running.exchange(false))
        return;
 
    closeSocket(m_listen);
    if (m_acceptThread.joinable())
        m_acceptThread.join();
 
    Logger::info(L"TcpServer: 정지됨");
}

다음을 참조함 : closeSocket(), m_acceptThread, m_listen, m_running.

다음에 의해서 참조됨 : wWinMain(), ~TcpServer().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

멤버 데이터 문서화

m_acceptThread

std::thread TcpServer::m_acceptThread

private

다음에 의해서 참조됨 : start(), stop().

m_handler

CommandHandler TcpServer::m_handler

private

다음에 의해서 참조됨 : acceptLoop(), setHandler().

m_listen

SOCKET TcpServer::m_listen {INVALID_SOCKET}

private

{INVALID_SOCKET};

다음에 의해서 참조됨 : acceptLoop(), start(), stop().

m_running

std::atomic<bool> TcpServer::m_running {false}

private

{false};

다음에 의해서 참조됨 : acceptLoop(), start(), stop().

---

이 클래스에 대한 문서화 페이지는 다음의 파일들로부터 생성되었습니다.:

• TcpServer.h
• TcpServer.cpp