mapserver.cpp

韩国英雄王座倒闭后流出来部分源代码

	{
		idx = k - (rand() % iSeg) * iSegWeight ;
	}

	// 备秦柳 犬伏 
	return idx ;
}






////////////////////////////////////////////////////////////////////////////////////////
//	
////////////////////////////////////////////////////////////////////////////////////////
CServiceModule _Module;

BEGIN_OBJECT_MAP(ObjectMap)
END_OBJECT_MAP()

LPCTSTR FindOneOf(LPCTSTR p1, LPCTSTR p2)
{
    while (p1 != NULL && *p1 != NULL)
    {
        LPCTSTR p = p2;
        while (p != NULL && *p != NULL)
        {
            if (*p1 == *p)
                return CharNext(p1);
            p = CharNext(p);
        }
        p1 = CharNext(p1);
    }
    return NULL;
}



////////////////////////////////////////////////////////////////////////////////////////
//
////////////////////////////////////////////////////////////////////////////////////////
CServiceModule::CServiceModule()
{
	m_nEventFlag	=	0;

#ifdef CHINESE_VERSION
	_tcscpy(m_szDBID, _T("sa"));
	_tcscpy(m_szDBPWD, _T("!234?werDsdfVxcv"));
#else
	_tcscpy(m_szDBID, _T("MapServer"));
	_tcscpy(m_szDBPWD, _T("1234567+-*/"));
#endif

	m_dwMaxUser			= MAX_SOCKET_CONTEXT;
	m_dwSaveAccountDB	= 0;		//	DEF_MAPINOUT_REGISTRY	
	
#if defined(DEF_SPEEDHACK) || defined(DEF_KORSPEEDHACK)
	
	// 扁粮狼 风凭 朝覆 
	//Jason 2004-08-16-china

	memset(m_dwIntervalTick,		0x0, sizeof(m_dwIntervalTick	));
	memset(m_wPacketCount,			0x0, sizeof(m_wPacketCount		));
	memset(m_dwInitIntervalTick,	0x0, sizeof(m_dwInitIntervalTick));
	memset(m_wAllowedHackCount,		0x0, sizeof(m_wAllowedHackCount	));

#endif
}


CServiceModule::~CServiceModule()
{

}



// Although some of these functions are big they are declared inline since they are only used once

inline HRESULT CServiceModule::RegisterServer(BOOL bRegTypeLib, BOOL bService)
{
    HRESULT hr = CoInitialize(NULL);
    if (FAILED(hr))
        return hr;

    // Remove any previous service since it may point to
    // the incorrect file
    Uninstall();

    // Add service entries
    UpdateRegistryFromResource(IDR_MapServer, TRUE);

    
    if (bService)
    {
        // Create service
        Install();
    }

    // Add object entries
    hr = CComModule::RegisterServer(bRegTypeLib);

    CoUninitialize();
    return hr;
}



inline void CServiceModule::Init(_ATL_OBJMAP_ENTRY* p, HINSTANCE h, UINT nServiceNameID, const GUID* plibid)
{
    CComModule::Init(p, h, plibid);

    m_bService = TRUE;

    LoadString(h, nServiceNameID, m_szServiceName, sizeof(m_szServiceName) / sizeof(TCHAR));

    // set up the initial service status 
    m_hServiceStatus					= NULL;
    m_status.dwServiceType				= SERVICE_WIN32_OWN_PROCESS;
    m_status.dwCurrentState				= SERVICE_STOPPED;
    m_status.dwControlsAccepted			= SERVICE_ACCEPT_STOP;
    m_status.dwWin32ExitCode			= 0;
    m_status.dwServiceSpecificExitCode	= 0;
    m_status.dwCheckPoint				= 0;
    m_status.dwWaitHint					= 0;
}

LONG CServiceModule::Unlock()
{
    LONG l = CComModule::Unlock();
    if (l == 0 && !m_bService)
        PostThreadMessage(dwThreadID, WM_QUIT, 0, 0);
    return l;
}

BOOL CServiceModule::IsInstalled()
{
    BOOL bResult = FALSE;

    SC_HANDLE hSCM = ::OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);

    if (hSCM != NULL)
    {
        SC_HANDLE hService = ::OpenService(hSCM, m_szServiceName, SERVICE_QUERY_CONFIG);
        if (hService != NULL)
        {
            bResult = TRUE;
            ::CloseServiceHandle(hService);
        }
        ::CloseServiceHandle(hSCM);
    }
    return bResult;
}

inline BOOL CServiceModule::Install()
{
    if (IsInstalled())
        return TRUE;

    SC_HANDLE hSCM = ::OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (hSCM == NULL)
    {
        MessageBox(NULL, _T("Couldn't open service manager"), m_szServiceName, MB_OK);
        return FALSE;
    }

    // Get the executable file path
    TCHAR szFilePath[_MAX_PATH];
    ::GetModuleFileName(NULL, szFilePath, _MAX_PATH);

    SC_HANDLE hService = ::CreateService(
        hSCM, m_szServiceName, m_szServiceName,
        SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS,
        SERVICE_DEMAND_START, SERVICE_ERROR_NORMAL,
        szFilePath, NULL, NULL, _T("RPCSS\0"), NULL, NULL);

    if (hService == NULL)
    {
        ::CloseServiceHandle(hSCM);
        MessageBox(NULL, _T("Couldn't create service"), m_szServiceName, MB_OK);
        return FALSE;
    }

    ::CloseServiceHandle(hService);
    ::CloseServiceHandle(hSCM);
    return TRUE;
}

inline BOOL CServiceModule::Uninstall()
{
    if (!IsInstalled())
        return TRUE;

    SC_HANDLE hSCM = ::OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);

    if (hSCM == NULL)
    {
        MessageBox(NULL, _T("Couldn't open service manager"), m_szServiceName, MB_OK);
        return FALSE;
    }

    SC_HANDLE hService = ::OpenService(hSCM, m_szServiceName, SERVICE_STOP | DELETE);

    if (hService == NULL)
    {
        ::CloseServiceHandle(hSCM);
        MessageBox(NULL, _T("Couldn't open service"), m_szServiceName, MB_OK);
        return FALSE;
    }
    SERVICE_STATUS status;
    ::ControlService(hService, SERVICE_CONTROL_STOP, &status);

    BOOL bDelete = ::DeleteService(hService);
    ::CloseServiceHandle(hService);
    ::CloseServiceHandle(hSCM);

    if (bDelete)
        return TRUE;

    MessageBox(NULL, _T("Service could not be deleted"), m_szServiceName, MB_OK);
    return FALSE;
}


////////////////////////////////////////////////////////////////////////////////////////
//	Logging functions
////////////////////////////////////////////////////////////////////////////////////////
void CServiceModule::LogEvent(LPCTSTR pFormat, ...)
{
    TCHAR    chMsg[256];
    HANDLE  hEventSource;
    LPTSTR  lpszStrings[1];
    va_list pArg;

    va_start(pArg, pFormat);
    _vstprintf(chMsg, pFormat, pArg);
    va_end(pArg);

    lpszStrings[0] = chMsg;

    if (m_bService)
    {
        /* Get a handle to use with ReportEvent(). */
        hEventSource = RegisterEventSource(NULL, m_szServiceName);
        if (hEventSource != NULL)
        {
            /* Write to event log. */
            ReportEvent(hEventSource, EVENTLOG_INFORMATION_TYPE, 0, 0, NULL, 1, 0, (LPCTSTR*) &lpszStrings[0], NULL);
            DeregisterEventSource(hEventSource);
        }
    }
    else
    {
        // As we are not running as a service, just write the error to the console.
        _putts(chMsg);
    }
}

////////////////////////////////////////////////////////////////////////////////////////
//	Service startup and registration
////////////////////////////////////////////////////////////////////////////////////////
inline void CServiceModule::Start()
{
    SERVICE_TABLE_ENTRY st[] =
    {
        { m_szServiceName, _ServiceMain },
        { NULL, NULL }
    };
    if (m_bService && !::StartServiceCtrlDispatcher(st))
    {
        m_bService = FALSE;
    }

}

inline void CServiceModule::ServiceMain(DWORD /* dwArgc */, LPTSTR* /* lpszArgv */)
{
    // Register the control request handler
    m_status.dwCurrentState = SERVICE_START_PENDING;
    m_hServiceStatus = RegisterServiceCtrlHandler(m_szServiceName, _Handler);
    if (m_hServiceStatus == NULL)
    {
        LogEvent(_T("Handler not installed"));
        return;
    }
    SetServiceStatus(SERVICE_START_PENDING);

    m_status.dwWin32ExitCode = S_OK;
    m_status.dwCheckPoint	= 0;
    m_status.dwWaitHint		= 0;

    // When the Run function returns, the service has stopped.
    Run();

    SetServiceStatus(SERVICE_STOPPED);
    LogEvent(_T("Service stopped"));
}



void WINAPI CServiceModule::_ServiceMain(DWORD dwArgc, LPTSTR* lpszArgv)
{
    _Module.ServiceMain(dwArgc, lpszArgv);
}

void WINAPI CServiceModule::_Handler(DWORD dwOpcode)
{
    _Module.Handler(dwOpcode); 
}

void CServiceModule::SetServiceStatus(DWORD dwState)
{
    m_status.dwCurrentState = dwState;
    ::SetServiceStatus(m_hServiceStatus, &m_status);
}




////////////////////////////////////////////////////////////////////////////////////////
//	Service Run
////////////////////////////////////////////////////////////////////////////////////////
void CServiceModule::Run()
{
    _Module.dwThreadID = GetCurrentThreadId();

    HRESULT hr = CoInitialize(NULL);
//  If you are running on NT 4.0 or higher you can use the following call
//  instead to make the EXE free threaded.
//  This means that calls come in on a random RPC thread
//  HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);

    _ASSERTE(SUCCEEDED(hr));

    // This provides a NULL DACL which will allow access to everyone.
    CSecurityDescriptor sd;
    sd.InitializeFromThreadToken();
    hr = CoInitializeSecurity(sd, -1, NULL, NULL,
        RPC_C_AUTHN_LEVEL_PKT, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, NULL);
    _ASSERTE(SUCCEEDED(hr));

    hr = _Module.RegisterClassObjects(CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER, REGCLS_MULTIPLEUSE);
    _ASSERTE(SUCCEEDED(hr));

    LogEvent(_T("Service started"));
    if (m_bService)
        SetServiceStatus(SERVICE_RUNNING);


	////////////////////////////////////////////////////////////////////////
	//	Registery沥焊 Load
	////////////////////////////////////////////////////////////////////////
	if( !ReadRegisteryValue() )
	{
		return;
	}

	////////////////////////////////////////////////////////////////////////
	//	秦寸 Upgrade 包访 Module阑 龋免窃	
	////////////////////////////////////////////////////////////////////////
	if( !Run_MapServer( ) )
	{
		LogEvent(_T("Map Server Start Error"));
		
		_Module.Clean_MapServer();
		return;
	}

	////////////////////////////////////////////////////////////////////////
	//	Login Server Module - End Runtine
	////////////////////////////////////////////////////////////////////////
    MSG msg;
    while (GetMessage(&msg, 0, 0, 0))
        DispatchMessage(&msg);

	////////////////////////////////////////////////////////////////////////
	//	Login Server Module - End Runtine
	////////////////////////////////////////////////////////////////////////
	g_pServer->Server_Stop();			//	Close Player

	_Module.Clean_MapServer();			//	Clean Memory

    _Module.RevokeClassObjects();

    CoUninitialize();

	WSACleanup();

}


																
////////////////////////////////////////////////////////////////////////////////////////
//	Map Server 包访 悼累 荐青 
//
////////////////////////////////////////////////////////////////////////////////////////
BOOL CServiceModule::Run_MapServer()
{
	// Jason 2004-08-04
	char strPath[MAX_PATH] = {0,};

	// user log 弃歹甫 积己茄促.
	sprintf( strPath, "%s%suser log", _Module.m_szDrv, _Module.m_szPath);
	CreateDirectory(strPath, NULL);

	// log 弃歹甫 积己茄促.
	sprintf( strPath, "%s%slog", _Module.m_szDrv,	_Module.m_szPath);
	CreateDirectory(strPath, NULL);

#ifdef DEF_AUTHCODE
	// log 弃歹甫 积己茄促.
	sprintf( strPath, "%s%sAuth Images", _Module.m_szDrv,	_Module.m_szPath);
	CreateDirectory(strPath, NULL);
#endif

	ErrorMsg("(O) Starting ...");

	//	--------------------------------------------------------------------------------
	//	辑滚 霖厚 惑怕 
	//	--------------------------------------------------------------------------------
	m_ServerStatus	=	SERVER_READY;		

	//	--------------------------------------------------------------------------------
	//	DB 包访 饭瘤胶飘府 佬绢 坷扁. 
	//	--------------------------------------------------------------------------------
#ifdef DEF_NEWREGISTRY
	if ( !ReadParam_MapServer() )
	{	
		return FALSE;
	}
#endif

	//
	//	Create Server Memory
	//
	g_pServerMem	=	new ServerMem;

	if( !g_pServerMem )
	{
		ErrorMsg("(X) Create Server Memory - Error");
		return FALSE;
	}


	//
	//	Quest Engine Create 
	//
	g_pQuestEngine	=	new CQuestEngine;	//	Quest Memory甫 积己 矫糯 
	
	if( !g_pQuestEngine )
	{
		ErrorMsg("(X) Quest Engine Error" );
		return FALSE;
	}

	//
	//	DB CONNECT
	//
	if( !g_Base.bConnectDB())	
	{
		ErrorMsg("(X) DB connect ERROR" );
		return FALSE;	
	}


	//
	//	DB俊辑 扁檬 甘 沥焊甫 掘澜
	//
	if( !g_Base.Load_MapServerMapInfo())	
	{
		ErrorMsg("(X) DB Map Load ERROR" );
		return FALSE;	
	}

	//	
	//	酒瘤飘 包府磊 积己
	//	
#ifdef DEF_AZIT
	m_pAzitManager = new AzitManager;

	if( !m_pAzitManager )
	{
		ErrorMsg("(X) Azit Manager memory alloc error [%d]",GetLastError());
		return false;
	}

#endif	

	//
	//	蜡聪农 酒捞袍 包府 积己磊
	//
#ifdef	DEF_UNIQUEITEM

	m_pUniqueManager = new UniqueManager;

	if( !m_pUniqueManager )
	{
		ErrorMsg("(X) Unique Manager memory alloc error [%d]",GetLastError());