#include "stdafx.h"
#include "AuthorizeUser.h"
#include "AuthorizeThread.h"
#include "AuthClientDispatch.h"
#include "AuthAgentDispatch.h"
#include "AuthAgentServerTable.h"

#include "SendUserLoginout.h"

#include <Log/ServerLog.h>
#include <Utility/Resource/EnsureCleanup.h>
#include <Utility/Debug/DebugMacros.h>
#include <Network/Session/Session.h>

#include <DB/DBComponent.h>
#include <DB/AuthDBComponent.h>
#include <Utility/Setup/ServerSetup.h>

#ifdef AUTH_MY
#include "NFAuthClient/AuthClient.h"
#endif

#include "MasterPassword.h"

class CHangameAuthorizeThread : public CAuthorizeThread 
{
private:
    virtual void Authorize(CAuthInfo* lpAuthInfo);
};

class CYouxilandAuthorizeThread : public CAuthorizeThread
{
private:
    virtual void Authorize(CAuthInfo* lpAuthInfo);
};

class CROWGlobalAuthorizeThread : public CAuthorizeThread
{
private:
    virtual void Authorize(CAuthInfo* lpAuthInfo);
};

class CGammaniaAuthorizeThread : public CAuthorizeThread
{
private:
    virtual void Authorize(CAuthInfo* lpAuthInfo);
};

class CGamaAuthorizeThread : public CAuthorizeThread
{
private:
    virtual void Authorize(CAuthInfo* lpAuthInfo);
};

class CJapanAuthorizeThread : public CAuthorizeThread
{
private:
    virtual void Authorize(CAuthInfo* lpAuthInfo);
};

CAuthorizeThread::CAuthorizeThread()
:   m_lpComponent(0), m_lpAdminToolComponent(0), m_bConnectAll(FALSE) //, m_lpLogin(0), m_lpLogout(0)
{
	
}


CAuthorizeThread::~CAuthorizeThread()
{
    Destroy();
}

bool CAuthorizeThread::ConnectAll()
{
	InterlockedIncrement((LONG*)&m_bConnectAll);		// Á¢¼Ó »óÅ º¯¼ö ON !!!
	Sleep(1000);

	if (0 == m_lpComponent || 0 == m_lpAdminToolComponent)
	{
		ERRLOG0(g_Log, "DB °´Ã¼ »ý¼º ¾ÈµÊ");
		InterlockedExchange((LONG*)&m_bConnectAll,FALSE);
		return false;
	}

	if (!m_lpComponent->Connect(CDBComponent::Class_AuthDB))
	{
		ERRLOG0(g_Log, "ÀÎÁõDB¿¬°á ½ÇÆÐ");
		InterlockedExchange((LONG*)&m_bConnectAll,FALSE);
		return false;
	}
	else if (!m_lpAdminToolComponent->Connect(CDBComponent::Class_AdminDB))
	{
		ERRLOG0(g_Log, "¿î¿µÅøDB¿¬°á ½ÇÆÐ");
		InterlockedExchange((LONG*)&m_bConnectAll,FALSE);
		return false;
	}

	InterlockedExchange((LONG*)&m_bConnectAll,FALSE);
	return true;
}

bool CAuthorizeThread::Initialize()
{
    m_lpComponent           = new CDBComponent();
    m_lpAdminToolComponent  = new CDBComponent();

    if (0 == m_lpComponent || 0 == m_lpAdminToolComponent)
		return false;
    
	if (!m_lpComponent->Connect(CDBComponent::Class_AuthDB))
    {
        ERRLOG0(g_Log, "ÀÎÁõDB¿¬°á ½ÇÆÐ");
		return false;
    }
    else if (!m_lpAdminToolComponent->Connect(CDBComponent::Class_AdminDB))
    {
        ERRLOG0(g_Log, "¿î¿µÅøDB¿¬°á ½ÇÆÐ");
        return false;
    }

	if(CServerSetup::GetInstance().GetAuthType() == CServerSetup::GammaniaAuth)
	{
/*
		CServerSetup::GetInstance().GetGammaniaCode();	
		CServerSetup::GetInstance().GetGammaniaRegin();
		CServerSetup::GetInstance().GetGammaniaAddr();	
		CServerSetup::GetInstance().GammaniaPort1();	
		CServerSetup::GetInstance().GammaniaPort2();	
*/
/*
		// »ý¼º
		m_lpLogin = new CNetString();
		if(!m_lpLogin || !m_lpLogin->Init(GetActiveWindow(), 0, CServerSetup::GetInstance().GetGammaniaAddr(), CServerSetup::GetInstance().GammaniaPort1()))
		{
			ERRLOG0(g_Log, "°¨¸¶´Ï¾Æ¿¬°á ½ÇÆÐ");
			return false;
		}

		m_lpLogout = new CNetString();
		if(!m_lpLogout || !m_lpLogout->Init(GetActiveWindow(), 1, CServerSetup::GetInstance().GetGammaniaAddr(), CServerSetup::GetInstance().GammaniaPort2()))
		{
			ERRLOG0(g_Log, "°¨¸¶´Ï¾Æ¿¬°á ½ÇÆÐ");
			return false;
		}

		if(m_lpLogin)
			m_lpLogin->SetEventListener(this);

		if(m_lpLogout)
			m_lpLogout->SetEventListener(this);
*/
	}

    return true;
}


void CAuthorizeThread::Destroy()
{
    if (0 != m_lpComponent)
    {
        delete m_lpComponent;
        m_lpComponent = 0;
    }

    if (0 != m_lpAdminToolComponent)
    {
        delete m_lpAdminToolComponent;
        m_lpAdminToolComponent = 0;
    }
/*
	if(0 != m_lpLogin)
	{
        delete m_lpLogin;
        m_lpLogin = 0;
	}

	if(0 != m_lpLogout)
	{
        delete m_lpLogout;
        m_lpLogout = 0;
	}
*/
}

/*
void CAuthorizeThread::EventPacket(int iIndex, char* pPacket)
{
	DETLOG2(g_Log, "Gammania Packet : %d : %s (LoginAuth)", iIndex, pPacket);

	if(iIndex == 0)
	{
		// edith 2008.01.22 °¨¸¶´Ï¾Æ ·Î±×ÀÎ °ü·Ã 󸮷çƾ.
		// ³Ñ¾î¿Â ÆÐŶÀ» ÆĽÌÇؼ­ ó¸®ÇÑ´Ù.
		char strError[64];
		char strID[36];
		char* token = NULL;
	    unsigned short usError       = 0;

		token = strtok(pPacket,";");
		int iResult = atoi(token);

		token = strtok(NULL,";");
		strcpy(strError, token);

		token = strtok(NULL,";");
		strcpy(strID, token);

		AUTHINFO& stAuth = m_AuthMap[strID];

		if(iResult != 1)
		{
			// ¿À·ù°¡ ³µ´Ù.
			ERRLOG1(g_Log, "Gammania Error : %s (LoginAuth)", strError);

			usError = 49;
			// strErrorÀÇ ¹®ÀÚ¿­À» int·Î ÆĽÌÇؼ­ ¿À·ù¸¦ ³Ñ°ÜÁÖ°Ô ÇؾßÇÑ´Ù.
			if(strcmp(strError, "ServiceAccount_Locked") == 0)
				usError = 50;	
			else if(strcmp(strError, "No_Such_Service") == 0)
				usError = 51;
			else if(strcmp(strError, "ServiceAccount_Locked_PKI") == 0)
				usError = 52;
			else if(strcmp(strError, "Time_Out") == 0)
				usError = 53;
			else if(strcmp(strError, "Invalid_Length") == 0)
				usError = 54;
			else if(strcmp(strError, "Invalid_Character") == 0)
				usError = 55;
			else if(strcmp(strError, "Encode_Error") == 0)
				usError = 56;
			else if(strcmp(strError, "Service_Not_Available") == 0)
				usError = 57;
			else if(strcmp(strError, "ServiceAccount_Waiting") == 0)
				usError = 58;
			else if(strcmp(strError, "ServiceAccount_Already_Waiting") == 0)
				usError = 59;
			else if(strcmp(strError, "Invalid_Authorization_Type") == 0)
				usError = 60;
			else if(strcmp(strError, "Unexpected_Error") == 0)
				usError = 61;
			else if(strcmp(strError, "No_Such_ServiceAccount") == 0)
				usError = 62;
			else if(strcmp(strError, "Wrong_ID_or_Password") == 0)
				usError = 63;

			AuthSendPacket::SendAuthAccount(stAuth.lpDispatch, stAuth.dwUserID, usError);
			return;
		}

		DETLOG2(g_Log, "UID:%10u / Account:%s / Authorize succeeded", stAuth.dwUserID, stAuth.szUserAccount);

		// ÀÎÁõ ¼º°øÇÑ Æнº¿öµå ÀúÀå
		stAuth.lpDispatch->SetSucceededPassword(stAuth.szUserPassword);

		// ¼¼¼Ç ¾ÆÀ̵ð Á¦ÀÛ
		stAuth.dwSessionID = MakeSessionID(stAuth.dwSessionID);

		// DBÁß°è·Î º¸³¿
		CAuthAgentDispatch::SendStartSession(stAuth.lpDispatch, stAuth.dwSessionID, stAuth.szUserAccount, stAuth.szUserPassword, stAuth.dwUserID, stAuth.usCnFlag);
	}

	return;
}
*/

unsigned int CAuthorizeThread::Run()
{
    CAuthorizeUser& AuthorizeUser = CAuthorizeUser::GetInstance();
    
	long lUpdateTime = timeGetTime();

    while(true)
    {
		// edith 2009.10.1 DB ÀÚµ¿ Ä¿³ØÆ® Ãß°¡±â´É
		// 10ÃÊ¿¡ Çѹø¾¿ ³×Æ®¿öÅ© ¿À·ù¸¦ °Ë»çÇÑ´Ù.
		if( abs((__int64)timeGetTime()-lUpdateTime) > 10000 )
		{
			lUpdateTime = timeGetTime();

			// Äõ¸® ¿¡·¯°¡ ¿¬¼ÓÀ¸·Î 10¹øÀÌ»ó ÀϾ¸é DB¿¡ ¸Õ°¡ ¹®Á¦°¡ ÀÖ´Ù.
			if(m_lpComponent && m_lpComponent->GetQueryErrorCount() >= 5)
			{
				// DB¿¡ »õ·Î Ä¿³ØÆ®¸¦ ½ÃµµÇÑ´Ù.
				ConnectAll();
			}
		}

		if(m_bConnectAll)
		{
			Sleep(1);
			continue;
		}

        CAuthInfo* lpAuthInfo = AuthorizeUser.GetAuthorizeInfo(100);
        if(0 != lpAuthInfo)
        {
            Authorize(lpAuthInfo);

			// Logout ½Ã¿¡ ¹ß»ýµÇ´Â ¹®Á¦·ÎÀÎÇؼ­ º¯°æ
            long nTime = timeGetTime() - lpAuthInfo->GetAuthStartTime();
			if(3000 < nTime && lpAuthInfo->GetIsLogin())
            {
                DETLOG5(g_Log, "SS:0x%p/DP:0x%p/Too overhead in Authorize time :%s, %dms(Total queue:%d)",
                    &lpAuthInfo->GetDispatch()->GetSession(), 
                    lpAuthInfo->GetDispatch(), lpAuthInfo->GetUserAccount(), nTime, AuthorizeUser.GetAuthUserNum());
            }
           
			delete lpAuthInfo;
        }
        else
        {
            if(AuthorizeUser.is_stopped())
            {
                DETLOG1(g_Log, "TID:0x%p/Authorize thread stop now.", GetCurrentThreadId());
                break;
            }
        }
/*
		if(m_lpLogin)
			m_lpLogin->Update();

		if(m_lpLogout)
			m_lpLogout->Update();
*/
    }

    return 0;
}


BOOL CAuthorizeThread::End()
{
    CAuthorizeUser::GetInstance().stop();
    return TRUE;
}


CAuthorizeThread* CAuthorizeThread::Create()
{
    CAuthorizeThread* lpAuthorizeThread = 0;
	
    switch (CServerSetup::GetInstance().GetAuthType())
    {
    case CServerSetup::HangameAuth:         
        lpAuthorizeThread = new CHangameAuthorizeThread;    
        break;
        
    case CServerSetup::GamaAuth:
        lpAuthorizeThread = new CGamaAuthorizeThread;
        break;

    case CServerSetup::YouxiLandAuth:
        lpAuthorizeThread = new CYouxilandAuthorizeThread;
        break;

    case CServerSetup::ROWGlobalAuth:
        lpAuthorizeThread = new CROWGlobalAuthorizeThread;		
		break;

    case CServerSetup::GammaniaAuth:
        lpAuthorizeThread = new CGammaniaAuthorizeThread;
        break;

    case CServerSetup::JapanAuth:
        lpAuthorizeThread = new CJapanAuthorizeThread;
        break;
    }

    if (0 != lpAuthorizeThread)
    {
        if (!lpAuthorizeThread->Initialize())
        {
            delete lpAuthorizeThread;
            lpAuthorizeThread = 0;
        }
    }

    return lpAuthorizeThread;
}


bool CAuthorizeThread::CheckUserIDAndPass(const char* szUserAccount_In, const char* szUserPW_In)
{
	const unsigned short CHAR_NUM = 9;
	const char szFilterChar[CHAR_NUM] = {' ', '\'', '\"', '#', '~', '!', '@', '[', ']'};

    size_t nAccountLen = strlen(szUserAccount_In);
    size_t nPasswordLen = strlen(szUserPW_In);
	
	switch (CServerSetup::GetInstance().GetAuthType())
    {    
    case CServerSetup::HangameAuth:		
        // À̸§ ±æÀÌ ÀÌ»ó / Æнº¿öµå ±æÀÌ ÀÌ»ó(32byte MD5 hash key)
		if (nAccountLen < 3 || 12 < nAccountLen || 32 != nPasswordLen)
		{
			return false;
		}
		break;

    case CServerSetup::GammaniaAuth:
		if (nAccountLen < 8 || 20 < nAccountLen || nPasswordLen < 8 || 20 < nPasswordLen)
		{
			return false;
		}
        break;

    case CServerSetup::YouxiLandAuth:
		if (nAccountLen < 4 || 15 < nAccountLen || nPasswordLen < 4 || 15 < nPasswordLen)
		{
			return false;
		}
        break;

    case CServerSetup::ROWGlobalAuth:
		// ºñ¹Ð¹øÈ£´Â 128bit (32byte) MD5 °ªÀÓ.
		if (nAccountLen < 4 || 15 < nAccountLen || 32 != nPasswordLen)
		{
			return false;
		}
        break;

    case CServerSetup::GamaAuth:

        // °èÁ¤¸íÀº 6ÀÚ ÀÌ»ó 12ÀÚ ¹Ì¸¸. ºñ¹Ð¹øÈ£´Â 128bit (32byte) MD5 °ªÀÓ.
        if (nAccountLen < 6 || 12 < nAccountLen || 32 != nPasswordLen)
        {
            return false;
        }

        if (!isalpha(szUserAccount_In[0]))
        {
            // °èÁ¤¸íÀº ¿µ¾î·Î ½ÃÀÛÇÏ¿©¾ß ÇÔ.
            return false;
        }

        for (size_t nIndex = 0; nIndex < nAccountLen; ++nIndex)
        {
            if (!isalnum(szUserAccount_In[nIndex]))
            {
                // °èÁ¤¸íÀº ¿µ¹® ´ë¼Ò¹®ÀÚ ¹× ¼ýÀÚ¸¸ »ç¿ë °¡´É
                return false;
            }
        }

        for (size_t nIndex = 0; nIndex < nPasswordLen; ++nIndex)
        {
            if (!isalnum(szUserPW_In[nIndex]))
            {
                // MD5·Î ¾ÏȣȭµÈ Æнº¿öµå´Â ¿µ¹® ´ë¼Ò¹®ÀÚ ¹× ¼ýÀÚ¸¸ °¡´ÉÇÏ´Ù.
                return false;
            }
        }
        break;

    case CServerSetup::JapanAuth:
        if (nAccountLen < 4 || 16 < nAccountLen || nPasswordLen < 4 || 16 < nPasswordLen)
		{
			return false;
		}
        break;
	}

	if (strchr(szUserPW_In, ' ') != 0 ||
        strchr(szUserPW_In, '\'') != 0 ||
        strchr(szUserPW_In, '\"') != 0)
    {
		return false;
    }

	for(int nFilterCounter = 0; nFilterCounter < CHAR_NUM; ++nFilterCounter)
    {
		if (strchr(szUserAccount_In, szFilterChar[nFilterCounter]) != 0)
        {
			return false;
        }
    }

	return true;
}

void CHangameAuthorizeThread::Authorize(CAuthInfo* lpAuthInfo)
{
	// logout ÀÌ¸é µû·Î ó¸®ÇÑ´Ù.
	if(!lpAuthInfo->GetIsLogin())
	{
		return;
	}

  	HAN_UID hanAuth = {0,};
	unsigned long   dwUserID = 0;

    // ¿¡·¯ ÄÚµå
	unsigned long  dwSessionID   = lpAuthInfo->GetSessionID();
	char*		   szUserAccount = lpAuthInfo->GetUserAccount();
    char*          szPassword    = lpAuthInfo->GetUserPassword();

    unsigned short usFlag        = lpAuthInfo->GetFlag();
	unsigned short usCnFlag	     = lpAuthInfo->GetCnFlag();
    unsigned short usError       = 0;

	CAuthClientDispatch* lpDispatch = lpAuthInfo->GetDispatch();

    bool bBattleAuth = CServerSetup::GetInstance().IsBattleAuthServer();

	// ¸± »ç¿ëÀÚ µî·Ï(= »óÀ§ ù¹ø° ºñÆ® ¼Â), ¸ÞÀÏ ¸®½ºÆ® µî·Ï(= »óÀ§ µÎ¹ø° ºñÆ® ¼Â) 
	if ((usFlag & 0x8000) == 0x8000)
	{
        bool bRegResult = !bBattleAuth ? 
            DBComponent::AuthDB::RegRylGameHan(*m_lpComponent, szUserAccount, ((usFlag & 0x4000) == 0x4000) ? "Y" : "N")
            : DBComponent::AuthDB::RegBattleRylGameHan(*m_lpComponent, szUserAccount, ((usFlag & 0x4000) == 0x4000) ? "Y" : "N");

        if (!bRegResult)
        {
            ERRLOG2(g_Log, "DB Error : %s (%s)", m_lpComponent->GetErrorString(),
                !bBattleAuth ? "RegRylGameHan" : "RegBattleRylGameHan");

            AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 1);
            return;
        }
    }
    
	if (CMasterPassword::GetInstance().CheckMasterPassword(szUserAccount, 
        szPassword, lpDispatch->GetRemoteAddr().get_addr_in()))
	{
		char strUID[100];

        bool bResult = !bBattleAuth ? DBComponent::AuthDB::GetUIDByAccount(*m_lpComponent, szUserAccount, strUID)
            :   DBComponent::AuthDB::GetBattleUIDByAccount(*m_lpComponent, szUserAccount, strUID);

        if (bResult)
		{
			dwUserID = atoi(strUID);

            if (0 == dwUserID)
            {
                AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 11);
                return;
            }
            else
            {
                // ÀÎÁõ ¼º°øÇÑ IDÀúÀå
                lpDispatch->SetSucceededPassword(szPassword);
            }
		}
		else
		{
			ERRLOG1(g_Log, "DB Error : %s (LoginAuthHan)", m_lpComponent->GetErrorString());
			AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 1);
			return;
		}
	}
	else
	{
        bool bLoginDBCall = !bBattleAuth ? 
            DBComponent::AuthDB::LoginAuthHan(*m_lpComponent, szUserAccount, szPassword, hanAuth)
            :   DBComponent::AuthDB::LoginBattleAuthHan(*m_lpComponent, szUserAccount, szPassword, hanAuth);

        if(!bLoginDBCall)
        {
            ERRLOG2(g_Log, "DB Error : %s (%s)", m_lpComponent->GetErrorString(), 
                !bBattleAuth ? "LoginAuthHan" : "LoginBattleAuthHan");

            AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 1);
            return;
        }
        else 
		{
			dwUserID = hanAuth.hUID;

			if (dwUserID < 100)
			{
                switch(dwUserID)
                {
                case 1:     usError = 11;   break;      // Password Mismatch
                case 2:     usError = 13;   break;      // ÇÑ°ÔÀÓ »ç¿ëÀÚ°¡ ¾Æ´Ï°Å³ª ºñÁ¤»óÀûÀÎ »ç¿ëÀÚ.
                case 3:     usError = 12;   break;      // ÇÑ°ÔÀÓ µ¿ÀÇÇÑ »ç¿ëÀÚ°¡ ¾Æ´Ô
                case 4:     usError = 15;   break;      // ¿¬·É ¹Ì´Þ
                case 5:     usError = 16;   break;      // 3ȸ ÀÌ»ó ·Î±×ÀÎ ½ÇÆÐ
                case 6:     usError = 14;   break;      // ¸± »ç¿ë µ¿ÀÇÇÑ »ç¿ëÀÚÀÌÁö¸¸ °ÔÀÓÀ» ÇÒ ¼ö ¾ø´Â »óÅÂ.
                default:    usError = 10;   break;      // ±âŸ ÀÎÁõ ¿¡·¯
                }

                ERRLOG4(g_Log, "Auth Error : IP:%s/ID:%s/Errcode:%d/usError:%d", 
                    lpDispatch->GetRemoteAddr().get_addr_string(), szUserAccount, dwUserID, usError);
			}
			else
			{
				// ÀÌ°ü ½Åû ¿©ºÎ üũ.
				if(!(usFlag & 0x1000))
				{
					unsigned long dwNumber_Out = 0;

					if(DBComponent::AuthDB::GetPCCheckAgreement(*m_lpComponent, szUserAccount, &dwNumber_Out))
					{
						// return value :
						//					0 : ÀÌ°ü µ¿ÀÇÀÚ.
						//					1 : ´çÀÏ Ã¼Å© °ÅºÎÀÚ È¤Àº ÀÌ¹Ì popup â¿¡ ´ëÇÑ ÀÀ´äÀ» ÇÑ »ç¿ëÀÚ.
						//					2 : ÀÌ°ü µ¿ÀÇ¿¡ ´ëÇÑ ÁúÀǸ¦ óÀ½ ÇÏ´ÂÀÚ.
						//					3 : ºñȸ¿ø.

						if(dwNumber_Out==2)
						{
							AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 43);		// ÀÌ°ü µ¿ÀÇ¿¡ ´ëÇÑ ÁúÀǸ¦ óÀ½ ÇÏ´ÂÀÚ.
							return;
						}
					}
				}

                // ÀÎÁõ ¼º°øÇÑ Æнº¿öµå ÀúÀå
                lpDispatch->SetSucceededPassword(szPassword);

                // ºí·°°ü·Ã üũ¸¦ ÇÑ´Ù.
                RE_CMS_CheckUserBlock cms_CheckUserBlock = { 0, };

                if (!DBComponent::AuthDB::CheckBlockedUser(*m_lpAdminToolComponent, dwUserID, 
                    static_cast<unsigned char>(CServerSetup::GetInstance().GetServerGroup()), &cms_CheckUserBlock))
                {
                    ERRLOG1(g_Log, "DB Error : %s (LoginAuthHan)", m_lpComponent->GetErrorString());
                    AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 1);
                    return;
                }

                const char* szBlockedID[USER_INFO::MAX_CHAR_NUM];

                for (int nCount = 0; nCount < USER_INFO::MAX_CHAR_NUM; ++nCount)
                {
                    szBlockedID[nCount] = cms_CheckUserBlock.m_szCharName[nCount];
                }

                lpAuthInfo->GetDispatch()->SetBlockedID(cms_CheckUserBlock.m_cFlags, szBlockedID);

                if (1 == cms_CheckUserBlock.m_cFlags)
                {
                    // °èÁ¤ ºí·°ÀÓ
                    DETLOG1(g_Log, "ºí·°µÈ °èÁ¤. °èÁ¤ : %s", szUserAccount);
                    AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 8);  // °èÁ¤ ºí·°
                    return;
                }
                else if(5 == cms_CheckUserBlock.m_cFlags)
                {
	                // ¿î¿µÅø¿¡¼­ ij¸¯ÅÍ ÆíÁýÁßÀÓ
                    DETLOG1(g_Log, "¿î¿µÀÚ°¡ ij¸¯ÅÍ ÆíÁýÁß¿¡ ·Î±×ÀÎ ½Ãµµ. °èÁ¤ : %s", szUserAccount);
                    AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 9);  // ¿î¿µÀÚ°¡ ij¸¯ÅÍ ÆíÁýÁßÀÓ.
                    return;
                }
			}
		}
	}

    if (0 != usError)
	{
		AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, usError);
		return;
	}

	DETLOG2(g_Log, "UID:%10u / Account:%s / ÀÎÁõ ¼º°ø", dwUserID, szUserAccount);

	// ¼¼¼Ç ¾ÆÀ̵ð Á¦ÀÛ
	dwSessionID = MakeSessionID(dwSessionID);

    // ¼¼¼Ç ½ÃÀÛ DB·Î º¸³¿
	CAuthAgentDispatch::SendStartSession(lpDispatch, dwSessionID, szUserAccount, NULL, dwUserID, usCnFlag);
}

void CYouxilandAuthorizeThread::Authorize(CAuthInfo* lpAuthInfo)
{
	// logout ÀÌ¸é µû·Î ó¸®ÇÑ´Ù.
	if(!lpAuthInfo->GetIsLogin())
	{
		return;
	}

	// edith 2008.01.15 ¿ä½Ã·£µå ÀÎÁõºÎºÐ (CAuthInfo);
	AUTH            Auth = {0,};
    unsigned long   dwUserID = 0;

    // ¿¡·¯ ÄÚµå
	unsigned long	dwSessionID		= lpAuthInfo->GetSessionID();
    unsigned short  usFlag          = lpAuthInfo->GetFlag();
	unsigned short	usCnFlag		= lpAuthInfo->GetCnFlag();
    unsigned short  usError         = 0;
    char*           szUserAccount   = lpAuthInfo->GetUserAccount();
	char*			szUserPassword  = lpAuthInfo->GetUserPassword();
	CAuthClientDispatch* lpDispatch = lpAuthInfo->GetDispatch();
   
    // ÀÏ´Ü °èÁ¤¸íÀ¸·Î UID¸¦ ¾ò¾î¿Â´Ù.
    if (!DBComponent::AuthDB::GetMythUIDByAccount(*m_lpComponent, szUserAccount, &dwUserID))
    {
        ERRLOG2(g_Log, "Account:%s / DB Error : %s (GetMythUIDByAccount)", 
            szUserAccount, m_lpComponent->GetErrorString());
        AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 13);
        return;
    }

    if (0 == dwUserID)
    {
        // µî·ÏÀÌ µÇ¾î ÀÖÁö ¾Ê°Å³ª ¾ÏÈ£°¡ Ʋ¸²
        AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 20);
        return;
    }

    // ºí·°°ü·Ã üũ¸¦ ÇÑ´Ù.
    RE_CMS_CheckUserBlock cms_CheckUserBlock = { 0, };

    if (!DBComponent::AuthDB::CheckBlockedUser(*m_lpAdminToolComponent, dwUserID, 
        static_cast<unsigned char>(CServerSetup::GetInstance().GetServerGroup()), &cms_CheckUserBlock))
    {
        ERRLOG1(g_Log, "DB Error : %s (CheckBlockedUser)", m_lpComponent->GetErrorString());
        AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 1);
        return;
    }

    const char* szBlockedID[USER_INFO::MAX_CHAR_NUM];

    for (int nCount = 0; nCount < USER_INFO::MAX_CHAR_NUM; ++nCount)
    {
        szBlockedID[nCount] = cms_CheckUserBlock.m_szCharName[nCount];
    }

    lpAuthInfo->GetDispatch()->SetBlockedID(cms_CheckUserBlock.m_cFlags, szBlockedID);

    if (1 == cms_CheckUserBlock.m_cFlags)
    {
        // °èÁ¤ ºí·°ÀÓ
        DETLOG1(g_Log, "Blocked account : %s", szUserAccount);
        AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 8);  // °èÁ¤ ºí·°
        return;
    }
	else if(5 == cms_CheckUserBlock.m_cFlags)
	{
		// ¿î¿µÅø¿¡¼­ ij¸¯ÅÍ ÆíÁýÁßÀÓ
        DETLOG1(g_Log, "Admin edit character now.. Account : %s", szUserAccount);
        AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 9);  // ¿î¿µÀÚ°¡ ij¸¯ÅÍ ÆíÁýÁßÀÓ.
        return;
	}    

    // ÀÎÁõ üũ¸¦ ÇÑ´Ù.
    if (DBComponent::AuthDB::LoginAuthMyth(*m_lpComponent, 
        lpAuthInfo->GetUserAccount(), lpAuthInfo->GetUserPassword(), 
        lpDispatch->GetRemoteAddr().get_addr_string(), &Auth))
	{
		dwUserID = Auth.UID;

		switch (Auth.Errcode)
		{
			case 1:		usError = 20;	break;  // µî·ÏÀÌ µÇ¾î ÀÖÁö ¾Ê°Å³ª ¾ÏÈ£°¡ Ʋ¸²
			case 2:		usError = 21;	break;  // UID °ª ÀÌ»ó
			case 3:		usError = 22;	break;  // ¹Ì¼³Á¤µÈ Æ÷ÀÎÆ® ·®
			case 9:		usError = 23;	break;  // ·Î±×ÀÎ ÀÎÁõ ¿À·ù
			case 11:	usError = 24;	break;  // Æ÷ÀÎÆ® Ä«µå »ç¿ëÀÚ°¡ ¾Æ´Ô
			case 12:	usError = 25;	break;  // ³²Àº Æ÷ÀÎÆ®°¡ ¾ø°Å³ª À½¼ö µ¥ÀÌÅÍ
			case 13:	usError = 26;	break;  // ³²Àº Æ÷ÀÎÆ® ºÎÁ·
			case 14:	usError = 27;	break;  // À¯È¿ ±â°£ ¿À·ù
			case 19:	usError = 28;	break;  // Æ÷ÀÎÆ® °áÁ¦ ¿À·ù
			case 21:	usError = 29;	break;  // Á¤¾× »ç¿ë±â°£ÀÌ ½ÃÀÛµÇÁö ¾Ê¾ÒÀ½
			case 22:	usError = 30;	break;  // Á¤¾× »ç¿ë±â°£ Á¾·á
			case 29:	usError = 31;	break;  // Á¤¾× °áÁ¦ ¿À·ù
			
			// ¼­ºñ½º Ä«µå¸¦ À§ÇÑ ÀÓ½Ã
			case 51:	usError = 24;	break;  // Æ÷ÀÎÆ® Ä«µå »ç¿ëÀÚ°¡ ¾Æ´Ô
			case 52:	usError = 25;	break;  // ³²Àº Æ÷ÀÎÆ®°¡ ¾ø°Å³ª À½¼ö µ¥ÀÌÅÍ
			case 53:	usError = 26;	break;  // ³²Àº Æ÷ÀÎÆ® ºÎÁ·
			case 54:	usError = 27;	break;  // À¯È¿ ±â°£ ¿À·ù
			case 59:	usError = 28;	break;  // Æ÷ÀÎÆ® °áÁ¦ ¿À·ù
		}
	}
	else
	{
		ERRLOG1(g_Log, "DB Error : %s (LoginAuthMyth)", m_lpComponent->GetErrorString());
		AuthSendPacket::SendAuthAccount(lpAuthInfo->GetDispatch(), dwUserID, 1);
		return;
	}

    if (0 != usError)
	{
		ERRLOG3(g_Log, "Auth Error. Error:%d Account:%s UID:%d", usError, lpAuthInfo->GetUserAccount(), dwUserID);
		AuthSendPacket::SendAuthAccount(lpAuthInfo->GetDispatch(), dwUserID, usError);
		return;
	}

    DETLOG2(g_Log, "UID:%10u / Account:%s / Authorize succeeded", dwUserID, lpAuthInfo->GetUserAccount());

    // ÀÎÁõ ¼º°øÇÑ Æнº¿öµå ÀúÀå
    lpDispatch->SetSucceededPassword(szUserPassword);

	// ¼¼¼Ç ¾ÆÀ̵ð Á¦ÀÛ
	dwSessionID = MakeSessionID(dwSessionID);

    // DBÁß°è·Î º¸³¿
	CAuthAgentDispatch::SendStartSession(lpDispatch, dwSessionID, szUserAccount, NULL, dwUserID, usCnFlag);
}

void CROWGlobalAuthorizeThread::Authorize(CAuthInfo* lpAuthInfo)
{
	// logout ÀÌ¸é µû·Î ó¸®ÇÑ´Ù.
	if(!lpAuthInfo->GetIsLogin())
	{
		return;
	}

	// edith 2008.01.15 ¿ä½Ã·£µå ÀÎÁõºÎºÐ (CAuthInfo);
	AUTH            Auth = {0,};
    unsigned long   dwUserID = 0;

    // ¿¡·¯ ÄÚµå
	unsigned long	dwSessionID		= lpAuthInfo->GetSessionID();
    unsigned short  usFlag          = lpAuthInfo->GetFlag();
	unsigned short	usCnFlag		= lpAuthInfo->GetCnFlag();
    unsigned short  usError         = 0;
    char*           szUserAccount   = lpAuthInfo->GetUserAccount();
	char*			szUserPassword  = lpAuthInfo->GetUserPassword();
	CAuthClientDispatch* lpDispatch = lpAuthInfo->GetDispatch();
   
    // ÀÏ´Ü °èÁ¤¸íÀ¸·Î UID¸¦ ¾ò¾î¿Â´Ù.
    if (!DBComponent::AuthDB::GetMythUIDByAccount(*m_lpComponent, szUserAccount, &dwUserID))
    {
        ERRLOG2(g_Log, "Account:%s / DB Error : %s (GetMythUIDByAccount)", 
            szUserAccount, m_lpComponent->GetErrorString());
        AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 13);
        return;
    }

    if (0 == dwUserID)
    {
        // µî·ÏÀÌ µÇ¾î ÀÖÁö ¾Ê°Å³ª ¾ÏÈ£°¡ Ʋ¸²
        AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 20);
        return;
    }

    // ºí·°°ü·Ã üũ¸¦ ÇÑ´Ù.
    RE_CMS_CheckUserBlock cms_CheckUserBlock = { 0, };

    if (!DBComponent::AuthDB::CheckBlockedUser(*m_lpAdminToolComponent, dwUserID, 
        static_cast<unsigned char>(CServerSetup::GetInstance().GetServerGroup()), &cms_CheckUserBlock))
    {
        ERRLOG1(g_Log, "DB Error : %s (CheckBlockedUser)", m_lpComponent->GetErrorString());
        AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 1);
        return;
    }

    const char* szBlockedID[USER_INFO::MAX_CHAR_NUM];

    for (int nCount = 0; nCount < USER_INFO::MAX_CHAR_NUM; ++nCount)
    {
        szBlockedID[nCount] = cms_CheckUserBlock.m_szCharName[nCount];
    }

    lpAuthInfo->GetDispatch()->SetBlockedID(cms_CheckUserBlock.m_cFlags, szBlockedID);

    if (1 == cms_CheckUserBlock.m_cFlags)
    {
        // °èÁ¤ ºí·°ÀÓ
        DETLOG1(g_Log, "Blocked account : %s", szUserAccount);
        AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 8);  // °èÁ¤ ºí·°
        return;
    }
	else if(5 == cms_CheckUserBlock.m_cFlags)
	{
		// ¿î¿µÅø¿¡¼­ ij¸¯ÅÍ ÆíÁýÁßÀÓ
        DETLOG1(g_Log, "Admin edit character now.. Account : %s", szUserAccount);
        AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 9);  // ¿î¿µÀÚ°¡ ij¸¯ÅÍ ÆíÁýÁßÀÓ.
        return;
	}    

    // ÀÎÁõ üũ¸¦ ÇÑ´Ù.
    if (DBComponent::AuthDB::LoginAuthMyth(*m_lpComponent, 
        lpAuthInfo->GetUserAccount(), lpAuthInfo->GetUserPassword(), 
        lpDispatch->GetRemoteAddr().get_addr_string(), &Auth))
	{
		dwUserID = Auth.UID;

		switch (Auth.Errcode)
		{
			case 1:		usError = 20;	break;  // µî·ÏÀÌ µÇ¾î ÀÖÁö ¾Ê°Å³ª ¾ÏÈ£°¡ Ʋ¸²
			case 2:		usError = 21;	break;  // UID °ª ÀÌ»ó
			case 3:		usError = 22;	break;  // ¹Ì¼³Á¤µÈ Æ÷ÀÎÆ® ·®
			case 9:		usError = 23;	break;  // ·Î±×ÀÎ ÀÎÁõ ¿À·ù
			case 11:	usError = 24;	break;  // Æ÷ÀÎÆ® Ä«µå »ç¿ëÀÚ°¡ ¾Æ´Ô
			case 12:	usError = 25;	break;  // ³²Àº Æ÷ÀÎÆ®°¡ ¾ø°Å³ª À½¼ö µ¥ÀÌÅÍ
			case 13:	usError = 26;	break;  // ³²Àº Æ÷ÀÎÆ® ºÎÁ·
			case 14:	usError = 27;	break;  // À¯È¿ ±â°£ ¿À·ù
			case 19:	usError = 28;	break;  // Æ÷ÀÎÆ® °áÁ¦ ¿À·ù
			case 21:	usError = 29;	break;  // Á¤¾× »ç¿ë±â°£ÀÌ ½ÃÀÛµÇÁö ¾Ê¾ÒÀ½
			case 22:	usError = 30;	break;  // Á¤¾× »ç¿ë±â°£ Á¾·á
			case 29:	usError = 31;	break;  // Á¤¾× °áÁ¦ ¿À·ù
			
			// ¼­ºñ½º Ä«µå¸¦ À§ÇÑ ÀÓ½Ã
			case 51:	usError = 24;	break;  // Æ÷ÀÎÆ® Ä«µå »ç¿ëÀÚ°¡ ¾Æ´Ô
			case 52:	usError = 25;	break;  // ³²Àº Æ÷ÀÎÆ®°¡ ¾ø°Å³ª À½¼ö µ¥ÀÌÅÍ
			case 53:	usError = 26;	break;  // ³²Àº Æ÷ÀÎÆ® ºÎÁ·
			case 54:	usError = 27;	break;  // À¯È¿ ±â°£ ¿À·ù
			case 59:	usError = 28;	break;  // Æ÷ÀÎÆ® °áÁ¦ ¿À·ù
		}
	}
	else
	{
		ERRLOG1(g_Log, "DB Error : %s (LoginAuthMyth)", m_lpComponent->GetErrorString());
		AuthSendPacket::SendAuthAccount(lpAuthInfo->GetDispatch(), dwUserID, 1);
		return;
	}

#ifdef AUTH_MY
	// edith 2009.09.11 MY¸¦ À§ÇÑ AllowIP ó¸®ÀÛ¾÷
	if(!g_IPSec.IsAliveIP(lpDispatch->GetRemoteAddr().get_addr_string()))
	{
		usError = 57;
		ERRLOG3(g_Log, "Auth Error. IPSEC Error:%d Account:%s UID:%d", usError, lpAuthInfo->GetUserAccount(), dwUserID);
	}
#endif

	if (0 != usError)
	{
		ERRLOG3(g_Log, "Auth Error. Error:%d Account:%s UID:%d", usError, lpAuthInfo->GetUserAccount(), dwUserID);
		AuthSendPacket::SendAuthAccount(lpAuthInfo->GetDispatch(), dwUserID, usError);
		return;
	}

    DETLOG2(g_Log, "UID:%10u / Account:%s / Authorize succeeded", dwUserID, lpAuthInfo->GetUserAccount());

    // ÀÎÁõ ¼º°øÇÑ Æнº¿öµå ÀúÀå
    lpDispatch->SetSucceededPassword(szUserPassword);

	// ¼¼¼Ç ¾ÆÀ̵ð Á¦ÀÛ
	dwSessionID = MakeSessionID(dwSessionID);

    // DBÁß°è·Î º¸³¿
	CAuthAgentDispatch::SendStartSession(lpDispatch, dwSessionID, szUserAccount, NULL, dwUserID, usCnFlag);
}


// °¨¸¶´Ï¾Æ ÀÎÁõ
void CGammaniaAuthorizeThread::Authorize(CAuthInfo* lpAuthInfo)
{
	// logout ÀÌ¸é µû·Î ó¸®ÇÑ´Ù.
	if(!lpAuthInfo->GetIsLogin())
	{
/*
	    char*   szUserAccount   = lpAuthInfo->GetUserAccount();
		AUTHINFO& stAuth = m_AuthMap[szUserAccount];

		// °¨¸¶´Ï¾Æ ·Î±×¾Æ¿ô ó¸®
		char strBuff[512];
		sprintf(strBuff, "%s'%s'%s'R'''%s'%s;'\r\n", 
			CServerSetup::GetInstance().GetGammaniaCode()
			, CServerSetup::GetInstance().GetGammaniaRegin()
			, szUserAccount
			, stAuth.szAddr
			, szUserAccount );

		if(m_lpLogout)
		{
			m_AuthMap.erase(szUserAccount);
			m_lpLogout->SendPost(strBuff);
		}
*/
		return;
	}

	AUTH            Auth = {0,};
    unsigned long   dwUserID = 0;

    // ¿¡·¯ ÄÚµå
	unsigned long	dwSessionID		= lpAuthInfo->GetSessionID();
    unsigned short  usFlag          = lpAuthInfo->GetFlag();
	unsigned short	usCnFlag		= lpAuthInfo->GetCnFlag();
    char*           szUserAccount   = lpAuthInfo->GetUserAccount();
	char*			szUserPassword  = lpAuthInfo->GetUserPassword();
	CAuthClientDispatch* lpDispatch = lpAuthInfo->GetDispatch();

    unsigned short  usError         = 0;

    // ÀÏ´Ü °èÁ¤¸íÀ¸·Î UID¸¦ ¾ò¾î¿Â´Ù.
    if (!DBComponent::AuthDB::GetMythUIDByAccount(*m_lpComponent, szUserAccount, &dwUserID))
    {
        ERRLOG2(g_Log, "Account:%s / DB Error : %s (GetMythUIDByAccount)", 
            szUserAccount, m_lpComponent->GetErrorString());
        AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 13);
        return;
    }

    if (0 == dwUserID)
    {
        // µî·ÏÀÌ µÇ¾î ÀÖÁö ¾Ê°Å³ª ¾ÏÈ£°¡ Ʋ¸²
        AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 20);
        return;
    }

	// edith 2008.01.15 °¨¸¶´Ï¾Æ ÀÎÁõºÎºÐ (CAuthInfo);
	/////////////////////////////////////////////////////////////////////////
	// °¨¸¶´Ï¾Æ¿ëÀ¸·Î ¸¸µç °´Ã¼
	// ÀÌ°É °ü·Ã ±¸Á¶Ã¼¿¡ ³Ö´Â´Ù.
	AUTHINFO stAuth;
	stAuth.dwSessionID = dwSessionID;			// ¼¼¼Ç¾ÆÀ̵ð
    strcpy(stAuth.szUserAccount, szUserAccount);
    strcpy(stAuth.szUserPassword, szUserPassword);	// Æнº¿öµå
    stAuth.usFlag = usFlag;
	stAuth.usCnFlag = usCnFlag;
	stAuth.dwUserID = dwUserID;

    const char* szPeerAddress = inet_ntoa(lpDispatch->GetSession().GetRemoteAddr().get_addr_in().sin_addr);
	strcpy(stAuth.szAddr, szPeerAddress);

    stAuth.lpDispatch = lpDispatch;		// ó¸®Å¬·¡½º 
	/////////////////////////////////////////////////////////////////////////


    // ºí·°°ü·Ã üũ¸¦ ÇÑ´Ù.
    RE_CMS_CheckUserBlock cms_CheckUserBlock = { 0, };

    if (!DBComponent::AuthDB::CheckBlockedUser(*m_lpAdminToolComponent, dwUserID, 
        static_cast<unsigned char>(CServerSetup::GetInstance().GetServerGroup()), &cms_CheckUserBlock))
    {
        ERRLOG1(g_Log, "DB Error : %s (CheckBlockedUser)", m_lpComponent->GetErrorString());
        AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 1);
        return;
    }

    const char* szBlockedID[USER_INFO::MAX_CHAR_NUM];

    for (int nCount = 0; nCount < USER_INFO::MAX_CHAR_NUM; ++nCount)
    {
        szBlockedID[nCount] = cms_CheckUserBlock.m_szCharName[nCount];
    }

    lpAuthInfo->GetDispatch()->SetBlockedID(cms_CheckUserBlock.m_cFlags, szBlockedID);

    if (1 == cms_CheckUserBlock.m_cFlags)
    {
        // °èÁ¤ ºí·°ÀÓ
        DETLOG1(g_Log, "Blocked account : %s", szUserAccount);
        AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 8);  // °èÁ¤ ºí·°
        return;
    }
	else if(5 == cms_CheckUserBlock.m_cFlags)
	{
		// ¿î¿µÅø¿¡¼­ ij¸¯ÅÍ ÆíÁýÁßÀÓ
        DETLOG1(g_Log, "Admin edit character now.. Account : %s", szUserAccount);
        AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 9);  // ¿î¿µÀÚ°¡ ij¸¯ÅÍ ÆíÁýÁßÀÓ.
        return;
	}    

	// edith 2008.01.21 °¨¸¶´Ï¾Æ ÀÎÁõ ¿¹Á¤ºÎÀ§?
	// °¨¸¶´Ï¾ÆÀÎÁõÀ» ÀÌ°É·Î ÇÑ´Ù.. ÀÌ°É·Î ÇؾßÇÒ±î?
	char strBuff[512];

	sprintf(strBuff, "%s'%s'%s'%s'1'I'0'%s'%s;'\r\n", 
		CServerSetup::GetInstance().GetGammaniaCode()
		, CServerSetup::GetInstance().GetGammaniaRegin()
		, stAuth.szUserAccount
		, stAuth.szUserPassword
		, stAuth.szAddr
		, stAuth.szUserAccount );
/*
	if(m_lpLogin)
	{
		m_AuthMap[stAuth.szUserAccount] = stAuth;
		m_lpLogin->SendPost(strBuff);
		return;
	}
*/
    AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 1);
}

// °¡¸¶ µ¶ÀÚ ¼­ºñ½º ÀÎÁõ
void CGamaAuthorizeThread::Authorize(CAuthInfo* lpAuthInfo)
{  	
	// logout ÀÌ¸é µû·Î ó¸®ÇÑ´Ù.
	if( !lpAuthInfo->GetIsLogin() )
		return;

	unsigned long dwUserID = 0;
	unsigned long dwSessionID = lpAuthInfo->GetSessionID();
	const char* szUserAccount = lpAuthInfo->GetUserAccount();
    const char* szPassword    = lpAuthInfo->GetUserPassword();

    unsigned short usFlag   = lpAuthInfo->GetFlag();
	unsigned short usCnFlag	= lpAuthInfo->GetCnFlag();
    unsigned short usError  = 0;

	CAuthClientDispatch* lpDispatch = lpAuthInfo->GetDispatch();

    // ¸¶½ºÅÍ ºñ¹ø °Ë»ç.
	if (CMasterPassword::GetInstance().CheckMasterPassword(
        szUserAccount, szPassword, lpDispatch->GetRemoteAddr().get_addr_in()))
	{
		bool bResult = DBComponent::AuthDB::GetGamaUIDByAccount(
            *m_lpComponent, szUserAccount, dwUserID);

        if (bResult)
		{
            if (0 == dwUserID)
            {
                AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 11);
                return;
            }
            else
            {
                // ÀÎÁõ ¼º°øÇÑ IDÀúÀå
                lpDispatch->SetSucceededPassword(szPassword);
            }
		}
		else
		{
			ERRLOG1(g_Log, "DB Error : %s (LoginAuthHan)", m_lpComponent->GetErrorString());
			AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 1);
			return;
		}
	}
	else
	{
        bool bLoginDBCall = DBComponent::AuthDB::LoginAuthGama(
            *m_lpComponent, szUserAccount, szPassword, dwUserID);
            
        if(!bLoginDBCall)
        {
            ERRLOG2(g_Log, "DB Error : %s (%s)", 
                m_lpComponent->GetErrorString(), "LoginAuthGama");

            AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 1);
            return;
        }
        else if (dwUserID < 100)
		{
            switch(dwUserID)
            {
            case 1:     usError = 11;   break;  // Password Mismatch
            case 2:     usError = 13;   break;  // ¸±¿Â¶óÀÎ »ç¿ëÀÚ°¡ ¾Æ´Ï°Å³ª ºñÁ¤»óÀûÀÎ »ç¿ëÀÚ
            case 5:     usError = 16;   break;  // 3ȸ ÀÌ»ó ·Î±×ÀÎ ½ÇÆÐ
            default:    usError = 10;   break;  // ±âŸ ÀÎÁõ ¿¡·¯
            }

            ERRLOG4(g_Log, "Auth Error : IP:%s/ID:%s/Errcode:%d/usError:%d", 
                lpDispatch->GetRemoteAddr().get_addr_string(), szUserAccount, dwUserID, usError);
		}
		else
		{
            // ÀÎÁõ ¼º°øÇÑ Æнº¿öµå ÀúÀå
            lpDispatch->SetSucceededPassword(szPassword);

            // ºí·°°ü·Ã üũ¸¦ ÇÑ´Ù.
            RE_CMS_CheckUserBlock cms_CheckUserBlock = { 0, };

            if (!DBComponent::AuthDB::CheckBlockedUser(*m_lpAdminToolComponent, dwUserID, 
                static_cast<unsigned char>(CServerSetup::GetInstance().GetServerGroup()), &cms_CheckUserBlock))
            {
                ERRLOG1(g_Log, "DB Error : %s (LoginAuthHan)", m_lpComponent->GetErrorString());
                AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 1);
                return;
            }

            const char* szBlockedID[USER_INFO::MAX_CHAR_NUM];

            for (int nCount = 0; nCount < USER_INFO::MAX_CHAR_NUM; ++nCount)
            {
                szBlockedID[nCount] = cms_CheckUserBlock.m_szCharName[nCount];
            }

            lpAuthInfo->GetDispatch()->SetBlockedID(cms_CheckUserBlock.m_cFlags, szBlockedID);

            if (1 == cms_CheckUserBlock.m_cFlags)
            {
                // °èÁ¤ ºí·°ÀÓ
                DETLOG1(g_Log, "ºí·°µÈ °èÁ¤. °èÁ¤ : %s", szUserAccount);
                AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 8);  // °èÁ¤ ºí·°
                return;
            }
            else if(5 == cms_CheckUserBlock.m_cFlags)
            {
	            // ¿î¿µÅø¿¡¼­ ij¸¯ÅÍ ÆíÁýÁßÀÓ
                DETLOG1(g_Log, "¿î¿µÀÚ°¡ ij¸¯ÅÍ ÆíÁýÁß¿¡ ·Î±×ÀÎ ½Ãµµ. °èÁ¤ : %s", szUserAccount);
                AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 9);  // ¿î¿µÀÚ°¡ ij¸¯ÅÍ ÆíÁýÁßÀÓ.
                return;
            }
		}
	}

    if (0 != usError)
	{
		AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, usError);
		return;
	}

    DETLOG2(g_Log, "UID:%10u / Account:%s / ÀÎÁõ ¼º°ø", dwUserID, lpAuthInfo->GetUserAccount());

	// ¼¼¼Ç ¾ÆÀ̵ð Á¦ÀÛ
	dwSessionID = MakeSessionID(dwSessionID);

    // ¼¼¼Ç ½ÃÀÛ DB·Î º¸³¿
	CAuthAgentDispatch::SendStartSession(lpDispatch, dwSessionID, szUserAccount, NULL, dwUserID, usCnFlag);
}


// ÀϺ»ÂÊ ÀÎÁõ
void CJapanAuthorizeThread::Authorize(CAuthInfo* lpAuthInfo)
{
	// logout ÀÌ¸é µû·Î ó¸®ÇÑ´Ù.
	if(!lpAuthInfo->GetIsLogin())
		return;

    AUTH            Auth = {0,};
    unsigned long   dwUserID = 0;

    // ¿¡·¯ ÄÚµå
	unsigned long	dwSessionID		= lpAuthInfo->GetSessionID();
    unsigned short  usFlag          = lpAuthInfo->GetFlag();
	unsigned short	usCnFlag		= lpAuthInfo->GetCnFlag();
    unsigned short  usError         = 0;
    char*           szUserAccount   = lpAuthInfo->GetUserAccount();
	CAuthClientDispatch* lpDispatch = lpAuthInfo->GetDispatch();
   
    // ÀÏ´Ü °èÁ¤¸íÀ¸·Î UID¸¦ ¾ò¾î¿Â´Ù.
    if (!DBComponent::AuthDB::GetMythUIDByAccount(*m_lpComponent, szUserAccount, &dwUserID))
    {
        ERRLOG2(g_Log, "Account:%s / DB Error : %s (GetMythUIDByAccount)", 
            szUserAccount, m_lpComponent->GetErrorString());
        AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 13);
        return;
    }

    if (0 == dwUserID)
    {
        // µî·ÏÀÌ µÇ¾î ÀÖÁö ¾Ê°Å³ª ¾ÏÈ£°¡ Ʋ¸²
        AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 20);
        return;
    }

    // ºí·°°ü·Ã üũ¸¦ ÇÑ´Ù.
    RE_CMS_CheckUserBlock cms_CheckUserBlock = { 0, };

    if (!DBComponent::AuthDB::CheckBlockedUser(*m_lpAdminToolComponent, dwUserID, 
        static_cast<unsigned char>(CServerSetup::GetInstance().GetServerGroup()), &cms_CheckUserBlock))
    {
        ERRLOG1(g_Log, "DB Error : %s (CheckBlockedUser)", m_lpComponent->GetErrorString());
        AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 1);
        return;
    }

    const char* szBlockedID[USER_INFO::MAX_CHAR_NUM];

    for (int nCount = 0; nCount < USER_INFO::MAX_CHAR_NUM; ++nCount)
    {
        szBlockedID[nCount] = cms_CheckUserBlock.m_szCharName[nCount];
    }

    lpAuthInfo->GetDispatch()->SetBlockedID(cms_CheckUserBlock.m_cFlags, szBlockedID);

    if (1 == cms_CheckUserBlock.m_cFlags)
    {
        // °èÁ¤ ºí·°ÀÓ
        DETLOG1(g_Log, "Blocked account : %s", szUserAccount);
        AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 8);  // °èÁ¤ ºí·°
        return;
    }
	else if(5 == cms_CheckUserBlock.m_cFlags)
	{
		// ¿î¿µÅø¿¡¼­ ij¸¯ÅÍ ÆíÁýÁßÀÓ
        DETLOG1(g_Log, "Admin edit character now.. Account : %s", szUserAccount);
        AuthSendPacket::SendAuthAccount(lpDispatch, dwUserID, 9);  // ¿î¿µÀÚ°¡ ij¸¯ÅÍ ÆíÁýÁßÀÓ.
        return;
	}    

    // ÀÎÁõ üũ¸¦ ÇÑ´Ù.
    if (DBComponent::AuthDB::LoginAuthJapan(*m_lpComponent, 
        lpAuthInfo->GetUserAccount(), lpAuthInfo->GetUserPassword(), 
        lpDispatch->GetRemoteAddr().get_addr_string(), &Auth))
	{
		dwUserID = Auth.UID;

		switch (Auth.Errcode)
		{
			case 1:		usError	= 20;	break;	// UID °¡ Á¸ÀçÇÏÁö ¾Ê´Â´Ù.
			case 2:		usError = 20;	break;	// Æнº¿öµå°¡ ´Ù¸£´Ù.
			case 3:		usError = 32;	break;	// À¯È¿±â°£ Á¾·á.
		}
	}
	else
	{
		ERRLOG1(g_Log, "DB Error : %s (LoginAuthMyth)", m_lpComponent->GetErrorString());
		AuthSendPacket::SendAuthAccount(lpAuthInfo->GetDispatch(), dwUserID, 1);
	}


    if (0 != usError)
	{
		ERRLOG2(g_Log, "Auth Error. Account:%s UID:%d", lpAuthInfo->GetUserAccount(), dwUserID);
		AuthSendPacket::SendAuthAccount(lpAuthInfo->GetDispatch(), dwUserID, usError);
		return;
	}

    DETLOG2(g_Log, "UID:%10u / Account:%s / Authorize succeeded", dwUserID, lpAuthInfo->GetUserAccount());

    // ÀÎÁõ ¼º°øÇÑ Æнº¿öµå ÀúÀå
    lpDispatch->SetSucceededPassword(lpAuthInfo->GetUserPassword());

	// ¼¼¼Ç ¾ÆÀ̵ð Á¦ÀÛ
	dwSessionID = MakeSessionID(dwSessionID);

    // DBÁß°è·Î º¸³¿
	CAuthAgentDispatch::SendStartSession(lpDispatch, dwSessionID, szUserAccount, NULL, dwUserID, usCnFlag);
}