// PacketDecoderDlg.cpp : 구현 파일
//

#include "stdafx.h"
#include "PacketDecoder.h"
#include "PacketDecoderDlg.h"
#include "Huffman.h"
#include "LZW.h"
#include <LZF/lzf.h>

#include <Network/Packet/PacketBase.h>
#include <Network/Packet/PacketCommand.h>
#include <Network/Packet/WrapPacket.h>
#include <Network/XORCrypt/XORCrypt.h>
#include <Utility/Compress/MiniLZO/MiniLZOWrapper.h>

#include <zlib/zlib.h>

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// 응용 프로그램 정보에 사용되는 CAboutDlg 대화 상자입니다.

class CAboutDlg : public CDialog
{
public:
	CAboutDlg();

// 대화 상자 데이터
	enum { IDD = IDD_ABOUTBOX };

	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 지원

// 구현
protected:
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
END_MESSAGE_MAP()


// CPacketDecoderDlg 대화 상자


CPacketDecoderDlg::CPacketDecoderDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CPacketDecoderDlg::IDD, pParent)
    , m_szParseResult(_T(""))
    , m_szCompressMiniLZO(_T(""))
    , m_szCompressZLIB(_T(""))
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CPacketDecoderDlg::DoDataExchange(CDataExchange* pDX)
{
    CDialog::DoDataExchange(pDX);
    DDX_Control(pDX, IDC_PACKET_CONTENT, m_edPacketContents);
    DDX_Control(pDX, IDC_WORKSPACE, m_edWorkspace);
    DDX_Text(pDX, IDC_PACKET_HEADER, m_szParseResult);
    DDX_Text(pDX, IDC_COMPRESS_MINILZO, m_szCompressMiniLZO);
    DDX_Text(pDX, IDC_COMPRESS_ZLIB, m_szCompressZLIB);
    
    
}

BEGIN_MESSAGE_MAP(CPacketDecoderDlg, CDialog)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	//}}AFX_MSG_MAP
    ON_BN_CLICKED(IDC_PARSE_HEADER, OnBnClickedParseHeader)
    ON_BN_CLICKED(IDC_COMPRESS_PACKET, OnBnClickedCompressPacket)
END_MESSAGE_MAP()


// CPacketDecoderDlg 메시지 처리기

BOOL CPacketDecoderDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

	// 시스템 메뉴에 "정보..." 메뉴 항목을 추가합니다.

	// IDM_ABOUTBOX는 시스템 명령 범위에 있어야 합니다.
	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != NULL)
	{
		CString strAboutMenu;
		strAboutMenu.LoadString(IDS_ABOUTBOX);
		if (!strAboutMenu.IsEmpty())
		{
			pSysMenu->AppendMenu(MF_SEPARATOR);
			pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		}
	}

	// 이 대화 상자의 아이콘을 설정합니다. 응용 프로그램의 주 창이 대화 상자가 아닐 경우에는
	// 프레임워크가 이 작업을 자동으로 수행합니다.
	SetIcon(m_hIcon, TRUE);			// 큰 아이콘을 설정합니다.
	SetIcon(m_hIcon, FALSE);		// 작은 아이콘을 설정합니다.

	ShowWindow(SW_MINIMIZE);

	// TODO: 여기에 추가 초기화 작업을 추가합니다.
	
	return TRUE;  // 컨트롤에 대한 포커스를 설정하지 않을 경우 TRUE를 반환합니다.
}

void CPacketDecoderDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CDialog::OnSysCommand(nID, lParam);
	}
}

// 대화 상자에 최소화 단추를 추가할 경우 아이콘을 그리려면 
// 아래 코드가 필요합니다. 문서/뷰 모델을 사용하는 MFC 응용 프로그램의 경우에는
// 프레임워크에서 이 작업을 자동으로 수행합니다.

void CPacketDecoderDlg::OnPaint() 
{
	if (IsIconic())
	{
		CPaintDC dc(this); // 그리기를 위한 디바이스 컨텍스트

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		// 클라이언트 사각형에서 아이콘을 가운데에 맞춥니다.
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// 아이콘을 그립니다.
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialog::OnPaint();
	}
}

// 사용자가 최소화된 창을 끄는 동안에 커서가 표시되도록 시스템에서
//  이 함수를 호출합니다. 
HCURSOR CPacketDecoderDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}


BYTE CharToHexNum(TCHAR cChar)
{
    BYTE nVal = 0;

    switch(cChar)
    {
    case _T('0'): nVal = 0; break;
    case _T('1'): nVal = 1; break;
    case _T('2'): nVal = 2; break;
    case _T('3'): nVal = 3; break;
    case _T('4'): nVal = 4; break;
    case _T('5'): nVal = 5; break;
    case _T('6'): nVal = 6; break;
    case _T('7'): nVal = 7; break;
    case _T('8'): nVal = 8; break;
    case _T('9'): nVal = 9; break;
    case _T('a'): nVal = 0xa; break;
    case _T('b'): nVal = 0xb; break;
    case _T('c'): nVal = 0xc; break;
    case _T('d'): nVal = 0xd; break;
    case _T('e'): nVal = 0xe; break;
    case _T('f'): nVal = 0xf; break;
    case _T('A'): nVal = 0xa; break;
    case _T('B'): nVal = 0xb; break;
    case _T('C'): nVal = 0xc; break;
    case _T('D'): nVal = 0xd; break;
    case _T('E'): nVal = 0xe; break;
    case _T('F'): nVal = 0xf; break;
    }

    return nVal;
}

LPCTSTR GetPacketNameFromCommand(PktBase::CMDType cPacketCmd)
{
#define ENUM_RETURN_STRING(x) case x: return _T(#x)

    switch(cPacketCmd)
    {
        ENUM_RETURN_STRING(CmdNull);
        ENUM_RETURN_STRING(CmdAuthAccount);
        ENUM_RETURN_STRING(CmdServerGroup);
        ENUM_RETURN_STRING(CmdUserLogin);
        ENUM_RETURN_STRING(CmdUserKill);
        ENUM_RETURN_STRING(CmdCharSelect);
        ENUM_RETURN_STRING(CmdCharCreate);
        ENUM_RETURN_STRING(CmdCharDelete);
        ENUM_RETURN_STRING(CmdCharLogin);
        ENUM_RETURN_STRING(CmdCharSuicide);
        ENUM_RETURN_STRING(CmdCharRespawn);
        ENUM_RETURN_STRING(CmdCharMove);
        ENUM_RETURN_STRING(CmdCharMoveUpdate);
        ENUM_RETURN_STRING(CmdCharChat);
        ENUM_RETURN_STRING(CmdCharAttack);
        ENUM_RETURN_STRING(CmdCharCastObject);
        ENUM_RETURN_STRING(CmdCharUseSkill);
        ENUM_RETURN_STRING(CmdCharTakeItem);
        ENUM_RETURN_STRING(CmdCharSwapItem);
        ENUM_RETURN_STRING(CmdCharRepairItem);
        ENUM_RETURN_STRING(CmdCharUseItem);
        ENUM_RETURN_STRING(CmdCharTradeItem);
        ENUM_RETURN_STRING(CmdCharSkillLock);
        ENUM_RETURN_STRING(CmdCharSkillCreate);
        ENUM_RETURN_STRING(CmdCharSkillErase);
        ENUM_RETURN_STRING(CmdCharClassUpgrade);
        ENUM_RETURN_STRING(CmdCharShapeInfo);
        ENUM_RETURN_STRING(CmdCharIncreasePoint);
        ENUM_RETURN_STRING(CmdCharBindPosition);
        ENUM_RETURN_STRING(CmdCharRequireInfo);
        ENUM_RETURN_STRING(CmdCharUpdateAddress);
        ENUM_RETURN_STRING(CmdCharPartyCmd);
        ENUM_RETURN_STRING(CmdCharPartyMemInfo);
        ENUM_RETURN_STRING(CmdCharExchangeCmd);
        ENUM_RETURN_STRING(CmdSysConnectAgent);
        ENUM_RETURN_STRING(CmdSysPacketTransmit);
        ENUM_RETURN_STRING(CmdCharLogout);
        ENUM_RETURN_STRING(CmdDBGetData);
        ENUM_RETURN_STRING(CmdDBUpdateData);
        ENUM_RETURN_STRING(CmdAgentParty);
        ENUM_RETURN_STRING(CmdSysServerLogin);
        ENUM_RETURN_STRING(CmdServerZone);
        ENUM_RETURN_STRING(CmdGameCellInfo);
        ENUM_RETURN_STRING(CmdCharInfo);
        ENUM_RETURN_STRING(CmdCharAddressInfo);
        ENUM_RETURN_STRING(CmdCharCellLogin);
        ENUM_RETURN_STRING(CmdCharCellLogout);
        ENUM_RETURN_STRING(CmdMonMove);
        ENUM_RETURN_STRING(CmdCharAttackInfo);
        ENUM_RETURN_STRING(CmdCharAttacked);
        ENUM_RETURN_STRING(CmdCharAward);
        ENUM_RETURN_STRING(CmdCharItemInfo);
        ENUM_RETURN_STRING(CmdCharPickUp);
        ENUM_RETURN_STRING(CmdCharPullDown);
        ENUM_RETURN_STRING(CmdCharPickUpInfo);
        ENUM_RETURN_STRING(CmdCharPullDownInfo);
        ENUM_RETURN_STRING(CmdCharCastObjectInfo);
        ENUM_RETURN_STRING(CmdCharInstallSocket);
        ENUM_RETURN_STRING(CmdCharLevelUp);
        ENUM_RETURN_STRING(CmdCharPartyInfo);
        ENUM_RETURN_STRING(CmdCharUpgradeItem);
        ENUM_RETURN_STRING(CmdCharHPRegen);
        ENUM_RETURN_STRING(CmdCharLevelUpInfo);
        ENUM_RETURN_STRING(CmdCharSplitItem);
        ENUM_RETURN_STRING(CmdUpdateUIDTable);
        ENUM_RETURN_STRING(CmdCharQuickSlotMove);
        ENUM_RETURN_STRING(CmdCharSwitchEQ);
        ENUM_RETURN_STRING(CmdSysMngerRegistry);
        ENUM_RETURN_STRING(CmdSysMngerRequest);
        ENUM_RETURN_STRING(CmdSysMngerResponse);
        ENUM_RETURN_STRING(CmdCharTakeItems);
        ENUM_RETURN_STRING(CmdCharTakeGold);
        ENUM_RETURN_STRING(CmdCharExchangeItem);
        ENUM_RETURN_STRING(CmdCellBroadCasting);
        ENUM_RETURN_STRING(CmdSysPatchAddress);
        ENUM_RETURN_STRING(CmdCharPartyCmdInfo);
        ENUM_RETURN_STRING(CmdServerLog);
        ENUM_RETURN_STRING(CmdCharWhisper);
        ENUM_RETURN_STRING(CmdSysServerVerUpdate);
        ENUM_RETURN_STRING(CmdSysMng);
        ENUM_RETURN_STRING(CmdSysChannelUpdate);
        ENUM_RETURN_STRING(CmdCharPartyFind);
        ENUM_RETURN_STRING(CmdCharPartyMemData);
        ENUM_RETURN_STRING(CmdCharControlOption);
        ENUM_RETURN_STRING(CmdCharDuelCmd);
        ENUM_RETURN_STRING(CmdCharFameInfo);
        ENUM_RETURN_STRING(CmdLoginServerList);
        ENUM_RETURN_STRING(CmdCharSpellInfo);
        ENUM_RETURN_STRING(CmdCharSkillUnLock);
        ENUM_RETURN_STRING(CmdSysPing);
        ENUM_RETURN_STRING(CmdCharMoveZone);
        ENUM_RETURN_STRING(CmdAgentZone);
        ENUM_RETURN_STRING(CmdDeposit);
        ENUM_RETURN_STRING(CmdDepositUpdate);
        ENUM_RETURN_STRING(CmdCharStallOpen);
        ENUM_RETURN_STRING(CmdCharStallRegisterItem);
        ENUM_RETURN_STRING(CmdCharStallEnter);
        ENUM_RETURN_STRING(CmdCharStallItemInfo);
        ENUM_RETURN_STRING(CmdCharAdminCmd);
        ENUM_RETURN_STRING(CmdCharTeamBattleInfo);
        ENUM_RETURN_STRING(CmdFriendAddRequest);
        ENUM_RETURN_STRING(CmdFriendRemoveRequest);
        ENUM_RETURN_STRING(CmdFriendEtcRequest);
        ENUM_RETURN_STRING(CmdFriendAck);
        ENUM_RETURN_STRING(CmdFriendDB);
        ENUM_RETURN_STRING(CmdEliteBonus);
        ENUM_RETURN_STRING(CmdCharStartQuest);
        ENUM_RETURN_STRING(CmdCharOperateTrigger);
        ENUM_RETURN_STRING(CmdQuestDB);
        ENUM_RETURN_STRING(CmdCharEndQuest);
        ENUM_RETURN_STRING(CmdCharDisappearItem);
        ENUM_RETURN_STRING(CmdCharAuthorizePanel);
        ENUM_RETURN_STRING(CmdCharPeaceMode);
        ENUM_RETURN_STRING(CmdConfigInfoDB);
        ENUM_RETURN_STRING(CmdCharAutoRouting);
        ENUM_RETURN_STRING(CmdRankingInfo);
        ENUM_RETURN_STRING(CmdCharStateRedistribution);
        ENUM_RETURN_STRING(CmdBillingTimeoutNotify);
        ENUM_RETURN_STRING(CmdAdminToolGetData);
        ENUM_RETURN_STRING(CmdAdminToolSetData);
        ENUM_RETURN_STRING(CmdEventDropItem);
        ENUM_RETURN_STRING(CmdCharCancelQuest);
        ENUM_RETURN_STRING(CmdBillingTimeCheckNotify);
        ENUM_RETURN_STRING(CmdCharLotteryResult);
        ENUM_RETURN_STRING(CmdCharSummonCmd);
        ENUM_RETURN_STRING(CmdChatClientLogin);
        ENUM_RETURN_STRING(CmdChatLogin);
        ENUM_RETURN_STRING(CmdChatLogout);
        ENUM_RETURN_STRING(CmdChatInfoChanged);
        ENUM_RETURN_STRING(CmdCharSummon);
        ENUM_RETURN_STRING(CmdJapanAuthAccount);
        ENUM_RETURN_STRING(CmdCharBattleGroundRespawn);
        ENUM_RETURN_STRING(CmdCharRespawnWaitQueue);
        ENUM_RETURN_STRING(CmdStatueInfo);
        ENUM_RETURN_STRING(CmdCameraScript);
        ENUM_RETURN_STRING(CmdCharEquipDurability);
        ENUM_RETURN_STRING(CmdCreateGuild);
        ENUM_RETURN_STRING(CmdGuildCmd);
        ENUM_RETURN_STRING(CmdGuildMark);
        ENUM_RETURN_STRING(CmdGuildLevel);
        ENUM_RETURN_STRING(CmdGuildRelation);
        ENUM_RETURN_STRING(CmdGuildList);
        ENUM_RETURN_STRING(CmdGuildDB);
        ENUM_RETURN_STRING(CmdGuildRight);
        ENUM_RETURN_STRING(CmdGuildMemberList);
        ENUM_RETURN_STRING(CmdMyGuildInfo);
        ENUM_RETURN_STRING(CmdGuildSafe);
        ENUM_RETURN_STRING(CmdGuildMemberInfoUpdate);
        ENUM_RETURN_STRING(CmdCharStatusRetrain);
        ENUM_RETURN_STRING(CmdSysServerLogout);
        //ENUM_RETURN_STRING(CmdCharPartyAddress);
        //ENUM_RETURN_STRING(CmdCharPartyMemAddress);
        ENUM_RETURN_STRING(CmdBGServerMapList);
        ENUM_RETURN_STRING(CmdBGServerResultList);
        ENUM_RETURN_STRING(CmdBGServerMoveZone);
        ENUM_RETURN_STRING(CmdBGServerMileageChange);
        ENUM_RETURN_STRING(CmdBGServerCharSlot);
        ENUM_RETURN_STRING(CmdHanBTNWarning);
        ENUM_RETURN_STRING(CmdHanBTNUserKill);
        ENUM_RETURN_STRING(CmdCharRepairAllItem);
        ENUM_RETURN_STRING(CmdCSAuth);
        ENUM_RETURN_STRING(CmdCharItemChemical);
        ENUM_RETURN_STRING(CmdGuildInclination);
        ENUM_RETURN_STRING(CmdGuildMemberFameUpdate);
        ENUM_RETURN_STRING(CmdCastleInfo);
        ENUM_RETURN_STRING(CmdCampInfo);
        ENUM_RETURN_STRING(CmdCreateCastle);
        ENUM_RETURN_STRING(CmdCreateCamp);
        ENUM_RETURN_STRING(CmdCreateSiegeArms);
        ENUM_RETURN_STRING(CmdCastleCmd);
        ENUM_RETURN_STRING(CmdCampCmd);
        ENUM_RETURN_STRING(CmdSiegeArmsCmd);
        ENUM_RETURN_STRING(CmdCastleRight);
        ENUM_RETURN_STRING(CmdCampRight);
        ENUM_RETURN_STRING(CmdSiegeBroadCast);
        //ENUM_RETURN_STRING(CmdSiegeTimeInfo);
        ENUM_RETURN_STRING(CmdStealthInfo);
        //ENUM_RETURN_STRING(CmdCastleUpdate);
        ENUM_RETURN_STRING(CmdCellBroadCast2nd);
        ENUM_RETURN_STRING(CmdCharRespawnInfo);
        ENUM_RETURN_STRING(CmdCharRespawnAreaInfo);
        ENUM_RETURN_STRING(CmdCharEquipShopInfo);
        ENUM_RETURN_STRING(CmdSiegeBroadCast2nd);
        ENUM_RETURN_STRING(CmdCharItemOptionGraft);
        ENUM_RETURN_STRING(CmdCharItemCompensation);
        ENUM_RETURN_STRING(CmdGuildMemberGoldUpdate);
        ENUM_RETURN_STRING(CmdCampMessage);
        ENUM_RETURN_STRING(CmdNewSiegeBroadCast);
        ENUM_RETURN_STRING(CmdSelectAccountNation);
        ENUM_RETURN_STRING(CmdNationChangeResult);
        ENUM_RETURN_STRING(CmdUnifiedCharInfo);
        ENUM_RETURN_STRING(CmdUnifiedCharSelect);
        ENUM_RETURN_STRING(CmdChatBan);
        ENUM_RETURN_STRING(CmdGiveItemToTempInven);
        ENUM_RETURN_STRING(CmdCharNameChange);
        ENUM_RETURN_STRING(CmdFertilityInfo);
        ENUM_RETURN_STRING(CmdProcessMining);
        ENUM_RETURN_STRING(CmdWorldWeaponInfo);
        ENUM_RETURN_STRING(CmdCampShopInfo);
        ENUM_RETURN_STRING(CmdCharInstallRuneSocket);
        ENUM_RETURN_STRING(CmdTakeMaterial);
        ENUM_RETURN_STRING(CmdCastleTaxMove);
        ENUM_RETURN_STRING(CmdCastleSiegeCount);
        ENUM_RETURN_STRING(CmdCompressedPacket);
        ENUM_RETURN_STRING(CmdFinalPacketNum);
    }

    return _T("Unknown Packet");
}


PktBase* CPacketDecoderDlg::DecodePacket(LPBYTE lpBuffer, int nBufferLen, int& nPacketSize)
{
    PktBase* lpPktBase = 0;

    if (0 != lpBuffer)
    {
        CString szPacketContents;
        m_edPacketContents.GetWindowText(szPacketContents);

        const LPCTSTR lpSeparator = _T(" \t\r\n");
        LPBYTE lpPacketCopyPos = lpBuffer;

        int nTokenPos  = 0;
        CString szToken;

        szToken = szPacketContents.Tokenize(lpSeparator, nTokenPos);
        while(_T("") != szToken && lpPacketCopyPos - lpBuffer < nBufferLen)
        {
            szToken.MakeUpper();

            if (2 == szToken.GetLength() && 
                _istxdigit(szToken.GetString()[0]) &&
                _istxdigit(szToken.GetString()[1]))
            {
                (*lpPacketCopyPos) 
                    = CharToHexNum(szToken.GetString()[0]) * 16 
                    + CharToHexNum(szToken.GetString()[1]);

                ++lpPacketCopyPos;
            }

            szToken = szPacketContents.Tokenize(lpSeparator, nTokenPos);
        }

        nPacketSize = static_cast<int>(lpPacketCopyPos - lpBuffer);

        CXORCrypt::GetInstance().DecodeHeader((char*)lpBuffer + 1, sizeof(PktBase) - 1, 0, 0);
        lpPktBase = reinterpret_cast<PktBase*>(lpBuffer);

        if(lpPktBase->IsCrypt())
        {
            CXORCrypt::GetInstance().DecodePacket((char*)lpBuffer + sizeof(PktBase), 
                nPacketSize - sizeof(PktBase), lpPktBase->GetCodePage());            
        }
        else if(lpPktBase->IsCompress())
        {
            BYTE aryBuffer[PktMaxLen];
            memcpy(aryBuffer, lpBuffer, min(PktMaxLen, nPacketSize));

            DWORD dwDecompressedSize = PktMaxLen;

            if (!CMiniLZO::Decompress(
                (char*)aryBuffer + sizeof(PktBase),
                nPacketSize - sizeof(PktBase),
                (char*)lpBuffer + sizeof(PktBase),
                &dwDecompressedSize))
            {
                lpPktBase = 0;
            }
            else
            {
                lpPktBase->SetLen(
                    static_cast<PktBase::LengthType>(dwDecompressedSize + sizeof(PktBase)));
            }
        }
    }

    return lpPktBase;
}

void CPacketDecoderDlg::OnBnClickedParseHeader()
{
    // TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.

    BYTE aryBuffer[PktMaxLen];

    int nPacketSize = 0;

    PktBase* lpPktBase = DecodePacket(aryBuffer, PktMaxLen, nPacketSize);
    if (0 != lpPktBase)
    {
        m_szParseResult.Format(_T("%s:%3d(0x%02x) : Real(%dByte)/Decoded(%dByte) (%s:%s)"),
            GetPacketNameFromCommand(lpPktBase->GetCmd()), lpPktBase->GetCmd(), lpPktBase->GetCmd(), 
            nPacketSize, lpPktBase->GetLen(),
            lpPktBase->IsCrypt() ? _T("XOR Crypted") : _T("No Crypt"),
            lpPktBase->IsCompress() ? _T("MiniLZO Compressed") : _T("No Compressed"));
    }
    else
    {
        m_szParseResult.Empty();
    }

    UpdateData(FALSE);
}

void CPacketDecoderDlg::OnBnClickedCompressPacket()
{
    // TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
    BYTE aryBuffer[PktMaxLen];

    int nPacketSize = 0;
    PktBase* lpPktBase = DecodePacket(aryBuffer, PktMaxLen, nPacketSize);
    if (0 != lpPktBase && sizeof(PktBase) <= lpPktBase->GetLen())
    {
        BYTE aryCompressedBuffer[PktMaxLen];
        DWORD dwCompressedSize = PktMaxLen;

        if (PacketWrap::WrapCompress(
            reinterpret_cast<char*>(aryCompressedBuffer), dwCompressedSize, 
            reinterpret_cast<char*>(lpPktBase), lpPktBase->GetLen(), 0, 0, 0))
        {
            m_szCompressMiniLZO.Format(_T("MiniLZO : 압축전 패킷 길이 : %5d / 압축후 패킷 길이 : %5d"),
                lpPktBase->GetLen(), dwCompressedSize);
        }
        else
        {
            m_szCompressMiniLZO.Format(_T("MiniLZO : 패킷 압축에 실패했습니다"));
        }

        /*
        dwCompressedSize = PktMaxLen;
        if (Z_OK == compress(aryCompressedBuffer, &dwCompressedSize, 
            reinterpret_cast<LPBYTE>(lpPktBase + 1), lpPktBase->GetLen() - sizeof(PktBase)))
        {
            m_szCompressZLIB.Format(_T("ZLIB : 압축전 패킷 길이 : %5d / 압축후 패킷 길이 : %5d"),
                lpPktBase->GetLen(), dwCompressedSize + sizeof(PktBase));
        }
        else
        {
            m_szCompressZLIB.Format(_T("ZLIB : 패킷 압축에 실패했습니다"));
        }*/

        /*
        LPBYTE lpBuffer = 0;
        int nDecompressSize = PktMaxLen;

        if (CompressHuffman(reinterpret_cast<LPBYTE>(lpPktBase + 1), 
            lpPktBase->GetLen() - sizeof(PktBase), lpBuffer, nDecompressSize))
        {
            m_szCompressZLIB.Format(_T("Huffman : 압축전 패킷 길이 : %5d / 압축후 패킷 길이 : %5d"),
                lpPktBase->GetLen(), nDecompressSize + sizeof(PktBase));

            free(lpBuffer);
        }
        else
        {
            m_szCompressZLIB.Format(_T("Huffman : 패킷 압축에 실패했습니다"));
        }
        */

        /*
        LPBYTE lpBuffer = 0;
        int nDecompressSize = PktMaxLen;

        if (CompressLZW(reinterpret_cast<LPBYTE>(lpPktBase + 1), 
            lpPktBase->GetLen() - sizeof(PktBase), lpBuffer, nDecompressSize))
        {
            m_szCompressZLIB.Format(_T("LZW : 압축전 패킷 길이 : %5d / 압축후 패킷 길이 : %5d"),
                lpPktBase->GetLen(), nDecompressSize + sizeof(PktBase));

            free(lpBuffer);
        }
        else
        {
            m_szCompressZLIB.Format(_T("LZW : 패킷 압축에 실패했습니다"));
        }*/

        unsigned int nDecompressSize = lzf_compress(lpPktBase + 1, 
            lpPktBase->GetLen() - sizeof(PktBase), aryCompressedBuffer, PktMaxLen);

        if (0 != nDecompressSize)
        {
            m_szCompressZLIB.Format(_T("LZF : 압축전 패킷 길이 : %5d / 압축후 패킷 길이 : %5d"),
                lpPktBase->GetLen(), nDecompressSize + sizeof(PktBase));
        }
        else
        {
            m_szCompressZLIB.Format(_T("LZF : 패킷 압축에 실패했습니다"));
        }

        
    }
    else
    {
        m_szCompressMiniLZO.Empty();
        m_szCompressZLIB.Empty();
    }

    UpdateData(FALSE);
}