SDC/A5_QD_CF_REVIEW.git

// NetServer.cpp: implementation of the CNetServer class.
//
//////////////////////////////////////////////////////////////////////
 
#include "stdafx.h"
#include "NetServer.h"
 
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
 
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
 
CNetServer::CNetServer()
{
    StartUp();
 
    m_pN2M = NULL;
    m_pPacket = NULL;
    m_nTotalPacketCount = 0;
    m_nPacketIdx = 0;
 
    m_pClientJoiner = NULL;
    m_nClientCount = 0;
    
    m_bAcceptSameIP = FALSE;
    
    InitializeCriticalSection(&m_csPacket);
}
 
CNetServer::~CNetServer()
{
    DeinitNetwork();
 
    CleanUp();
 
    if (m_pPacket)
    {
        delete [] m_pPacket;
        m_pPacket = NULL;
    }
    if (m_pClientJoiner)
    {
        delete [] m_pClientJoiner;
        m_pClientJoiner = NULL;
        m_nClientCount = 0;
    }
    DeleteCriticalSection(&m_csPacket);    
 
    //TRACE("------- CNetServer -------- close \n");
}
 
BOOL CNetServer::SetClientInfo(int ST, int nCount, short sNetworkCode, short sVersion, BOOL bUseHeartbeat, int nPacketCount)
{
    if (nCount <= 0)
        return FALSE;
 
    int i;
 
    m_Clientint = ST;    // ¿¬°áÇÒ ClientÀÇ Á¾·ù.
    if (nPacketCount <= 0)
        nPacketCount = 200;
 
    m_nClientCount = nCount;
    m_nTotalPacketCount = nCount * nPacketCount;
    m_pPacket = new CNetPacket[m_nTotalPacketCount];
    for (i = 0; i < m_nTotalPacketCount; i++)
        m_pPacket[i].SetVersion(sNetworkCode, sVersion);
 
    m_pClientJoiner = new CNetJoiner[nCount];
    for (i = 0; i < nCount; i++)
        m_pClientJoiner[i].SetUseHeartbeat(bUseHeartbeat);
 
    m_sNetworkCode = sNetworkCode;
    m_sVersion = sVersion;
 
    return TRUE;
}
 
BOOL CNetServer::InitNetwork(NetworkMode Mode, int nSocketCount, int nPort, CString strIP, BOOL bAcceptSameIP)
{
    m_nListenPort = nPort;
    m_bAcceptSameIP = bAcceptSameIP;
    return CIOCPController::InitNetwork(Mode, nSocketCount, nPort, strIP);
}
 
CNetPacket* CNetServer::GetPacket()
{
    if (!m_pPacket)
        return NULL;
    
    CNetPacket* pPacket = NULL;
    EnterCriticalSection(&m_csPacket);
 
    int nCount = 0;
    do 
    {
        pPacket = &m_pPacket[m_nPacketIdx];
        m_nPacketIdx = ++m_nPacketIdx % m_nTotalPacketCount;
        if (!pPacket->IsUsing())
        {
            pPacket->LockPacket();
            break;
        }
        Sleep(0);
        if (++nCount > 1000)
        {
            LeaveCriticalSection(&m_csPacket);
            return NULL;
        }
    } while(TRUE);
    
    pPacket->ResetValues();
 
    LeaveCriticalSection(&m_csPacket);
 
    return pPacket;
}
 
BOOL CNetServer::DisconnectClient(int nModuleNo)
{
    BOOL bRet = FALSE;
    EnterCriticalSection(&m_csContext);
    for (int i = 0; i < m_nClientCount; i++)
    {
        if (m_pClientJoiner[i].GetModuleNo() == nModuleNo)
        {
            CloseSocket(m_pClientJoiner[i].GetSocketContext(), FALSE, FALSE);
            m_pClientJoiner[i].Reset();
            bRet = TRUE;
            break;
        }
    }
    LeaveCriticalSection(&m_csContext);
 
    return bRet;
}
 
// Server SocketÀÌ Á¢¼ÓÀ» Çã¿ëÇßÀ» ¶§ È£ÃâÇÏ´Â ÇÔ¼ö.
int CNetServer::AcceptedSocket(pPerSocketContext pCtx, ULONG ulIP, int nPort)
{
    if (nPort != m_nListenPort)
    {
        NoticeMsg("Accepte ÁÖ¼Ò°¡ Àß¸øµÊ. %d - %d", m_nListenPort, nPort);
        return FALSE;
    }
 
    int nRet = -1;
    if(m_bAcceptSameIP == FALSE)
    {
    for (int i = 0; i < m_nClientCount; i++)
    {
        if (m_pClientJoiner[i].GetClientIP() == ulIP)
        {
             NoticeMsg("AcceptedSocket : Close Socket : %d, %u", i, ulIP);
            pCtx = m_pClientJoiner[i].GetSocketContext();
            nRet = 0;
            break;
        }
    }
    }    
 
    if (nRet == -1)
    {
        for (int i = 0; i < m_nClientCount; i++)
        {
            if (m_pClientJoiner[i].GetClientIP() == -1)
            {
                m_pClientJoiner[i].SetClientIP(ulIP);
                m_pClientJoiner[i].SetSocketContext(pCtx);
 
                nRet = 1;
                break;
            }
        }
    }
 
    // Á¢¼Ó °ú´Ù.
    if (nRet == -1)
        NoticeMsg("Á¢¼Ó °ú´Ù·Î Á¾·á, ListenPort %d, CurPort %d\n", m_nListenPort, nPort);
 
    return nRet;
}
 
// SocketÀÌ ²÷¾îÁ³À½À» ¾Ë·ÁÁÖ±â À§ÇÑ ÇÔ¼ö
void CNetServer::SocketClosed(pPerSocketContext pSocketCtx)
{
    int nModuleNo;
    for (int i = 0; i < m_nClientCount; i++)
    {
        if (reinterpret_cast<__int64>(m_pClientJoiner[i].GetSocketContext()) == reinterpret_cast<__int64>(pSocketCtx))
        {
            nModuleNo = m_pClientJoiner[i].GetModuleNo();
            m_pClientJoiner[i].Reset();
            m_pN2M->IOCPNet2P_Disconnected(m_Clientint, nModuleNo);        
 
            break;
        }
    }
}
 
// Client SocketÀÌ Á¢¼ÓµÇ¾úÀ» ¶§ È£ÃâÇÏ´Â ÇÔ¼ö
BOOL CNetServer::ConnectedSocket(pPerSocketContext pSocketCtx)
{
    return TRUE;
}
 
// Socket¿¡¼ Receive°¡ ¿Ï·áµÇ¾úÀ» ¶§ CIOCPController¿¡¼ È£ÃâÇÏ´Â ÇÔ¼ö - Data Parseing
BOOL CNetServer::RecvCompleted(pPerSocketContext pSocketCtx, DWORD dwBytes)
{
    // ¹öÆÛ°¡ ºô ¶§±îÁö Ã³¸®.
    WSABUF* pBuf = pSocketCtx->recvContext->GetLockedBuffer();
    if (!pBuf)
    {
        NoticeMsg("Packet Lost :: Buf is not Available. Buf - %d", reinterpret_cast<__int64>(pBuf));
        return TRUE;
    }
    
    int nRead = 0;
    DWORD dwCompBytes = 0;
    DWORD dwCurrentBytes = dwBytes + (MAX_BUFFER_SIZE - pBuf->len);
    pBuf->buf = pSocketCtx->recvContext->GetBulkBuffer();
    
    int nPacketCount = 0, nOldPacket = 0;;
    while (TRUE)
    {
        if (dwCurrentBytes < PACKET_HEADERSIZE)        // ÃÖ¼Ò ÆÐÅ¶ Å©±â.
        {
            // ÆÐÅ¶À» ´Ù ¹ÞÁö ¸øÇÏ¸é ´õ ¹Þ´Â´Ù.
            if (dwCompBytes > 0 && dwCurrentBytes > 0)
            {
//                NoticeMsg("Ã³¸®ÇÑ ºÎºÐ »èÁ¦ 1 Recv %d, Cur %d, Comp %d", dwBytes, dwCurrentBytes, dwCompBytes);
                char* strTemp = new char[dwCurrentBytes + 1];
                ZeroMemory(strTemp, dwCurrentBytes + 1);
                memcpy(strTemp, pBuf->buf, dwCurrentBytes);
                pBuf->buf = pSocketCtx->recvContext->GetBulkBuffer();
                ZeroMemory(pBuf->buf, MAX_BUFFER_SIZE + 1);
                memcpy(pBuf->buf, strTemp, dwCurrentBytes);
                if (strTemp)
                {
                    delete [] strTemp;
                    strTemp = NULL;
                }
                dwCompBytes = 0;
            }
//            NoticeMsg("Çì´õÆÐÅ¶º¸´Ù ÀÛÀ½ Recv %d, Cur %d, Comp %d", dwBytes, dwCurrentBytes, dwCompBytes);
            pBuf->buf = pSocketCtx->recvContext->GetBulkBuffer() + dwCurrentBytes;
            pBuf->len = MAX_BUFFER_SIZE - dwCurrentBytes;
            return FALSE;
        }
        
        CNetPacket* pPacket = GetPacket();
        if (!pPacket)
        {
            NoticeMsg("RecvCompleted :: Packet is not Available. pPacket - %d", reinterpret_cast<__int64>(pPacket));
            break;
        }
        
        nRead = pPacket->Read_PacketHeader(pBuf);
        if (nRead == 0)
        {
            NoticeMsg("Packet Lost :: Read Packet Header. Read - %d", nRead);
            pPacket->UnlockPacket();
            return TRUE;
        }
        if (pPacket->GetVersion() != m_sVersion)
        {
            NoticeMsg("Packet Header :: Version Mismatch!! Set %d, Packet %d, Recv %d, Cur %d, Len %d, PktCount %d, Pkt %d, Comp %d, Size %d"
                , m_sVersion, pPacket->GetVersion(), dwBytes, dwCurrentBytes, pBuf->len, nPacketCount, nOldPacket, dwCompBytes, pPacket->GetSize());
            pPacket->UnlockPacket();
            return TRUE;
        }
        if (pPacket->GetSize() <= 0)    // ¿¹¿ÜÃ³¸® - ¹ÞÀº µ¥ÀÌÅÍ´Â Áö¿ö¹ö¸®°í ´Ù½Ã ¹Þ´Â´Ù.
        {
            NoticeMsg("Packet Lost :: Exception in Size - Size %d, Code %d, Module %d", pPacket->GetSize(), pPacket->GetPacketCode(), pPacket->GetModuleNo());
            pPacket->UnlockPacket();
            return TRUE;
        }
        
        if (dwCurrentBytes >= (DWORD)pPacket->GetSize())    // ±æÀÌ Ã¼Å©.
        {
            if (pPacket->GetSize() > PACKET_HEADERSIZE)
            {
                nRead = pPacket->Read_PacketBody(pBuf->buf + nRead);
                if (nRead == -1)
                {
                    NoticeMsg("Packet Lost :: Read Packet Body. Read - %d, Cur %d, Size %d", nRead, dwCurrentBytes, pPacket->GetSize());
                    pPacket->UnlockPacket();
                    return TRUE;
                }
                else if (nRead == -2)
                {
                    NoticeMsg("Packet Lost :: Read Packet Body. Exception - %d, Cur %d, Size %d", nRead, dwCurrentBytes, pPacket->GetSize());
                    pPacket->UnlockPacket();
                    return TRUE;
                }
            }
 
            // Context¿Í Module ¿¬°áÀ» À§ÇØ pSocketCtx¸¦ ³Ñ±ä´Ù.
            if (m_pN2M)
                m_pN2M->IOCPNet2P_Received(m_Clientint, pPacket, reinterpret_cast<__int64>(pSocketCtx));
            nPacketCount++;
            nOldPacket = pPacket->GetPacketCode();
            if (dwCurrentBytes == (DWORD)pPacket->GetSize())
            {
                pPacket->UnlockPacket();
                return TRUE;        // ¸ðµç ¹öÆÛ¸¦ ´Ù Ã³¸®Çß´Ù.
            }
            
            // ¹öÆÛ°¡ ³²¾ÆÀÖÀ¸¸é ´Ù½Ã Ã³¸®ÇÑ´Ù.
            dwCompBytes += (DWORD)pPacket->GetSize();
            dwCurrentBytes -= (DWORD)pPacket->GetSize();
            pBuf->buf = pBuf->buf + pPacket->GetSize();
            pPacket->UnlockPacket();
        }
        else
        {
            if (dwCompBytes > 0 && dwCurrentBytes > 0)
            {
//                NoticeMsg("Ã³¸®ÇÑ ºÎºÐ »èÁ¦ 2 Recv %d, Pak %d, Cur %d, Comp %d, PktSize %d", dwBytes, pPacket->GetSize(), dwCurrentBytes, dwCompBytes, pPacket->GetSize());
                char* strTemp = new char[dwCurrentBytes + 1];
                ZeroMemory(strTemp, dwCurrentBytes + 1);
                memcpy(strTemp, pBuf->buf, dwCurrentBytes);
                pBuf->buf = pSocketCtx->recvContext->GetBulkBuffer();
                ZeroMemory(pBuf->buf, MAX_BUFFER_SIZE + 1);
                memcpy(pBuf->buf, strTemp, dwCurrentBytes);
                if (strTemp)
                {
                    delete [] strTemp;
                    strTemp = NULL;
                }
 
//                CNetPacket* pTmpPacket = GetPacket();
//                if (pTmpPacket)
//                {
//                    nRead = pTmpPacket->Read_PacketHeader(pBuf);
//                    NoticeMsg("»èÁ¦ ÈÄ Çì´õ Version %d, Code %d, Size %d", pTmpPacket->GetVersion(), pTmpPacket->GetPacketCode(), pTmpPacket->GetSize());
//                    pTmpPacket->UnlockPacket();
//                }
            }
//            NoticeMsg("¸ðÀÚ¶ó¼ ´Ù½Ã ¹Þ±â Recv %d, Pak %d, Cur %d, Comp %d", dwBytes, pPacket->GetSize(), dwCurrentBytes, dwCompBytes);
            pBuf->buf = pSocketCtx->recvContext->GetBulkBuffer() + dwCurrentBytes;
            pBuf->len = MAX_BUFFER_SIZE - dwCurrentBytes;
            pPacket->UnlockPacket();
            return FALSE;
        }
    }
 
    return TRUE;
}
 
// SocketÀ» ÅëÇØ Send°¡ ¿Ï·áµÇ¾úÀ» ¶§ CIOCPController¿¡¼ È£ÃâÇÏ´Â ÇÔ¼ö. - ÈÄÃ³¸®
BOOL CNetServer::SendCompleted(pPerSocketContext pSocketCtx, DWORD dwBytes)
{
//    //TRACE("SendCompleted. Trans %d - Len %d\n", dwBytes, pSocketCtx->sendContext->GetLen());
    return FALSE;
}
 
//////////////////////////////////////////////////////////////////////////
// Packet Send
 
CNetJoiner* CNetServer::GetJoinerUser(int nModuleNo)
{
    // Client Ã£±â
    if (nModuleNo < 0 || nModuleNo >= m_nClientCount)
        return NULL;
 
    CNetJoiner* pClientJoiner = NULL;
    for (int i = 0; i < m_nClientCount; i++)
    {
        if (m_pClientJoiner[i].GetSocketContext() && m_pClientJoiner[i].GetModuleNo() == nModuleNo)
        {
            pClientJoiner = &m_pClientJoiner[i];
            break;
        }
    }
 
    return pClientJoiner;
}
 
//////////////////////////////////////////////////////////////////////////
// Packet Send.
BOOL CNetServer::InvokeToClient(int nType, SHORT sResult)
{
    BOOL bRet = TRUE;
    for (int i = 0; i < m_nClientCount; i++)
    {
        if (!SendToClient(i, nType, sResult))
            bRet = FALSE;
    }
 
    return bRet;
}
 
 
 
BOOL CNetServer::InvokeToClient(int nType, SHORT sResult, CNetPacket* pPacket)
{
    BOOL bRet = TRUE;
    for (int i = 0; i < m_nClientCount; i++)
    {
        if (!SendToClient(i, nType, sResult, pPacket))
            bRet = FALSE;
    }
 
    return bRet;
}
 
BOOL CNetServer::InvokeToClient(int nType, SHORT sResult, SHORT sPacketIdx, CNetPacket* pPacket)
{
    BOOL bRet = TRUE;
    for (int i = 0; i < m_nClientCount; i++)
    {
        if (!SendToClient(i, nType, sResult, sPacketIdx, pPacket))
            bRet = FALSE;
    }
 
    return bRet;
}
 
BOOL CNetServer::SendToClient(int nModuleNo, int nType, SHORT sResult)
{
    return SendToClient(nModuleNo, nType, sResult, -1, NULL);
}
 
BOOL CNetServer::SendToClient(int nModuleNo, int nType, SHORT sResult, CNetPacket* pPacket)
{
    return SendToClient(nModuleNo, nType, sResult, -1, pPacket);
}
 
BOOL CNetServer::SendToClient(int nModuleNo, int nType, SHORT sResult, SHORT sPacketIdx, CNetPacket* pPacket)
{
    CNetJoiner* pClientJoiner = GetJoinerUser(nModuleNo);
 
    int nRet = 0;
    if (pClientJoiner && pClientJoiner->GetSocketContext())
    {
        pPerSocketContext pCtx = pClientJoiner->GetSocketContext();
        WSABUF* pWsaBuf;
        int nCount = 0;
        while (TRUE)
        {
            pWsaBuf = pClientJoiner->GetSendBuffer();
            if (!pWsaBuf)
                Sleep(0);
            else
                break;
        }
 
        if(pWsaBuf->buf == NULL)
            return FALSE;
 
        // Buffer¸¦ Ã¤¿î´Ù.
        int i;
        int nWriteSize = 0;
        SHORT sPacketIdx = 0;
 
        // Header Ã¤¿ì±â.
//        memcpy(pWsaBuf->buf + nWriteSize, &nSize, sizeof(int));
        nWriteSize += sizeof(int);
        memcpy(pWsaBuf->buf + nWriteSize, &m_sNetworkCode, sizeof(SHORT));
        nWriteSize += sizeof(SHORT);
        memcpy(pWsaBuf->buf + nWriteSize, &m_sVersion, sizeof(SHORT));
        nWriteSize += sizeof(SHORT);
        memcpy(pWsaBuf->buf + nWriteSize, &nType, sizeof(int));
        nWriteSize += sizeof(int);
        memcpy(pWsaBuf->buf + nWriteSize, &sPacketIdx, sizeof(SHORT));
        nWriteSize += sizeof(SHORT);
        memcpy(pWsaBuf->buf + nWriteSize, &sResult, sizeof(SHORT));
        nWriteSize += sizeof(SHORT);
        memcpy(pWsaBuf->buf + nWriteSize, &nModuleNo, sizeof(int));
        nWriteSize += sizeof(int);
 
        // Body Ã¤¿ì±â
        if (pPacket)
        {
            int nCount = pPacket->GetShortCount();
            memcpy(pWsaBuf->buf + nWriteSize, &nCount, sizeof(int));
            nWriteSize += sizeof(int);
            short sValue;
            for (i = 0; i < nCount; i++)
            {
                sValue = pPacket->GetShort(i);
                memcpy(pWsaBuf->buf + nWriteSize, &sValue, sizeof(short));
                nWriteSize += sizeof(short);
            }
 
            nCount = pPacket->GetIntCount();
            memcpy(pWsaBuf->buf + nWriteSize, &nCount, sizeof(int));
            nWriteSize += sizeof(int);
            int nValue;
            for (i = 0; i < nCount; i++)
            {
                nValue = pPacket->GetInt(i);
                memcpy(pWsaBuf->buf + nWriteSize, &nValue, sizeof(int));
                nWriteSize += sizeof(int);
            }
            
            nCount = pPacket->GetDoubleCount();
            memcpy(pWsaBuf->buf + nWriteSize, &nCount, sizeof(int));
            nWriteSize += sizeof(int);
            double dValue;
            for (i = 0; i < nCount; i++)
            {
                dValue = pPacket->GetDouble(i);
                memcpy(pWsaBuf->buf + nWriteSize, &dValue, sizeof(double));
                nWriteSize += sizeof(double);
            }
 
            CString String;
            int nLength;
            nCount = pPacket->GetStringCount();
            memcpy(pWsaBuf->buf + nWriteSize, &nCount, sizeof(int));
            nWriteSize += sizeof(int);
            for (i = 0; i < nCount; i++)
            {
                String = pPacket->GetString(i);
 
                char * str_Data = NULL;
#ifdef _UNICODE
                int length = WideCharToMultiByte(CP_ACP, 0, String.GetBuffer(), -1, NULL, 0, NULL,NULL); 
                str_Data = new char[length]; 
                WideCharToMultiByte(CP_ACP, 0, String.GetBuffer(), -1, str_Data, length, NULL, NULL); 
#else
                int length = String.GetLength();
                str_Data = new char[length+1]; 
                memcpy(str_Data, String.GetBuffer(), sizeof(char)*length);
                str_Data[length] = NULL;
#endif
                if (str_Data==NULL) 
                {
                    continue;
                }
 
                nLength = String.GetLength();
                memcpy(pWsaBuf->buf + nWriteSize, &nLength, sizeof(int));
                nWriteSize += sizeof(int);
 
                if (nLength > 0)
                {
                    memcpy(pWsaBuf->buf + nWriteSize, str_Data, nLength);
                    nWriteSize += nLength;
                }
 
                delete [] str_Data;
            }
 
            nLength = pPacket->GetBufferSize();
            memcpy(pWsaBuf->buf + nWriteSize, &nLength, sizeof(int));
            nWriteSize += sizeof(int);
            if (nLength > 0)
            {
                memcpy(pWsaBuf->buf + nWriteSize, pPacket->GetBuffer(), nLength);
                nWriteSize += nLength;
            }
            pPacket->UnlockPacket();
        }
        memcpy(pWsaBuf->buf, &nWriteSize, sizeof(int));
        pWsaBuf->len = nWriteSize;
 
        nRet = SendPost(pClientJoiner->GetSocketContext());
        if (nRet == 2)
            NoticeMsg("0 Bytes Sent : %d", nModuleNo);
    }
    else
    {
        if (pPacket)
            pPacket->UnlockPacket();
    }
 
    return nRet;
}