MemoryManager::MemoryManager()
{
hProcess = NULL;
dwPID = NULL;
try
{
if (!AttachProcess("csgo.exe")) throw 1;
ClientDLL = GetModule("client.dll");
EngineDLL = GetModule("engine.dll");
ClientDLL_Base = (DWORD)ClientDLL.modBaseAddr;
EngineDLL_Base = (DWORD)EngineDLL.modBaseAddr;
if (ClientDLL_Base == 0x0) throw 2;
if (EngineDLL_Base == 0x0) throw 3;
ClientDLL_Size = ClientDLL.dwSize;
EngineDLL_Size = EngineDLL.dwSize;
//std::cout<<MEM<<" MemoryManager succesfully started."<<std::endl;
}
catch (int iEx) {
switch (iEx)
{
case 1: std::cout<<MEM<<" Failed to attach csgo.exe process. Process not found."<<std::endl; Sleep(3000); break;
case 2: std::cout<<MEM<<" Failed to get module entry of client.dll"<<std::endl; Sleep(3000); break;
case 3: std::cout<<MEM<<" Failed to get module entry of engine.dll"<<std::endl; Sleep(3000); break;
default: throw;
}
}
catch (...) { std::cout<<MEM<<" Unhandled exception thrown."<<std::endl; }
}
/****************************** Public Functions *****************************/
EXTERN_C BOOL WINAPI DllMain(HINSTANCE hmod, DWORD dwReason, PVOID pvReserved)
{
switch (dwReason)
{
case DLL_PROCESS_ATTACH:
{
return AttachProcess(hmod);
}
case DLL_THREAD_ATTACH:
ThreadContextTLSEntry::InitializeThread();
#ifdef HEAP_TRACK_ALLOC
HeapAllocator::InitializeThread();
#endif
return TRUE;
case DLL_THREAD_DETACH:
// If we are not doing DllCanUnloadNow, so we should clean up. Otherwise, DllCanUnloadNow is already running,
// so the ThreadContext global lock is already taken. If we try to clean up, we will block on the ThreadContext
// global lock while holding the loader lock, which DllCanUnloadNow may block on waiting for thread termination
// which requires the loader lock. DllCanUnloadNow will clean up for us anyway, so we can just skip the whole thing.
ThreadBoundThreadContextManager::DestroyContextAndEntryForCurrentThread();
return TRUE;
case DLL_PROCESS_DETACH:
lockedDll = ::DeleteAtom(lockedDll);
AssertMsg(lockedDll == 0, "Failed to release the lock for chakracore.dll");
#ifdef DYNAMIC_PROFILE_STORAGE
DynamicProfileStorage::Uninitialize();
#endif
#ifdef ENABLE_JS_ETW
// Do this before DetachProcess() so that we won't have ETW rundown callbacks while destroying threadContexts.
EtwTrace::UnRegister();
#endif
#ifdef VTUNE_PROFILING
VTuneChakraProfile::UnRegister();
#endif
// don't do anything if we are in forceful shutdown
// try to clean up handles in graceful shutdown
if (pvReserved == NULL)
{
DetachProcess();
}
#if defined(CHECK_MEMORY_LEAK) || defined(LEAK_REPORT)
else
{
ThreadBoundThreadContextManager::DestroyAllContexts();
DetachProcess();
ThreadContext::ReportAndCheckLeaksOnProcessDetach();
}
#endif
return TRUE;
default:
AssertMsg(FALSE, "DllMain() called with unrecognized dwReason.");
return FALSE;
}
}
BOOL APIENTRY DllMain (HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
AttachProcess(hModule);
break;
case DLL_PROCESS_DETACH:
if (gOrigHookAddress != 0)
RemoveHook();
break;
}
return TRUE;
}
void ProcessManager::UpdateProcesses(unsigned int elapsedTime)
{
ProcessList::iterator nextIt = m_processList.begin();
ProcessList::iterator currIt;
while(nextIt != m_processList.end())
{
ProcessSharedPtr pProcess = (*nextIt);
currIt = nextIt;
nextIt++;
if(pProcess->GetState() == PS_UNINITIALIZED)
{
if(!pProcess->Init())
pProcess->Abort();
}
if(pProcess->GetState() == PS_RUNNING)
pProcess->VUpdate(elapsedTime);
if(pProcess->IsDone())
{
switch(pProcess->GetState())
{
case PS_SUCCEEDED :
{
ProcessSharedPtr pChild = pProcess->RemoveChild();
if(pChild)
AttachProcess(pChild);
}
break;
case PS_ABORTED :
break;
default :
break;
}
m_processList.erase(currIt);
}
}
}
unsigned int ProcessManager::UpdateProcesses(const float deltaMs)
{
unsigned short int successCount = 0;
unsigned short int failCount = 0;
ProcessList::iterator it = m_processList.begin();
while (it != m_processList.end())
{
Process* pCurrProcess = (*it);
ProcessList::iterator thisIt = it;
it++;
if (pCurrProcess->GetState() == Process::UNINITIALIZED)
{
pCurrProcess->VOnInit();
}
if (pCurrProcess->GetState() == Process::RUNNING)
{
pCurrProcess->VOnUpdate(deltaMs);
}
if (pCurrProcess->IsDead())
{
switch (pCurrProcess->GetState())
{
case Process::SUCCEEDED:
{
pCurrProcess->VOnSuccess();
Process* pChild = pCurrProcess->RemoveChild();
if (pChild)
{
AttachProcess(pChild);
}
else
{
successCount++;
}
break;
}
case Process::FAILED:
{
pCurrProcess->VOnFail();
failCount++;
break;
}
case Process::ABORTED:
{
pCurrProcess->VOnAbort();
failCount++;
break;
}
}
m_processList.erase(thisIt);
}
}
return ((successCount << 16) | failCount);
}
unsigned int ProcessManager::UpdateProcesses(float deltaTime)
{
unsigned short int successCount = 0;
unsigned short int failCount = 0;
auto it = m_ProcessList.begin();
while (it != m_ProcessList.end())
{
StrongProcessPtr pCurrentProcess = (*it);
// save an iterator to this process and increment our list iterator
auto thisIt = it;
++it;
// init the current process if it has not intialized yet
if (pCurrentProcess->GetState() == Process::UNINITIALIZED)
{
pCurrentProcess->OnInit();
}
// update a running process
if (pCurrentProcess->GetState() == Process::RUNNING)
{
pCurrentProcess->OnUpdate(deltaTime);
}
// if a process is dead, run the correct exit method
if (pCurrentProcess->IsDead())
{
switch (pCurrentProcess->GetState())
{
case Process::SUCCEEDED:
{
pCurrentProcess->OnSuccess();
StrongProcessPtr pChild = pCurrentProcess->RemoveChild();
if (pChild)
AttachProcess(pChild);
else
++successCount;
break;
}
case Process::FAILED:
{
pCurrentProcess->OnFail();
++failCount;
break;
}
case Process::ABORTED:
{
pCurrentProcess->OnAbort();
++failCount;
break;
}
}
// destroy the dead process
m_ProcessList.erase(thisIt);
}
}
return (successCount << 16) | failCount;
}
//---------------------------------------------------------------------------------------------------------------------
// The process update tick. Called every logic tick. This function returns the number of process chains that
// succeeded in the upper 32 bits and the number of process chains that failed or were aborted in the lower 32 bits.
//---------------------------------------------------------------------------------------------------------------------
unsigned int ProcessManager::UpdateProcesses(unsigned long deltaMs)
{
unsigned short int successCount = 0;
unsigned short int failCount = 0;
ProcessList::iterator it = m_processList.begin();
while (it != m_processList.end())
{
// grab the next process
StrongProcessPtr pCurrProcess = (*it);
// save the iterator and increment the old one in case we need to remove this process from the list
ProcessList::iterator thisIt = it;
++it;
// process is uninitialized, so initialize it
if (pCurrProcess->GetState() == Process::UNINITIALIZED)
pCurrProcess->VOnInit();
// give the process an update tick if it's running
if (pCurrProcess->GetState() == Process::RUNNING)
pCurrProcess->VOnUpdate(deltaMs);
// check to see if the process is dead
if (pCurrProcess->IsDead())
{
// run the appropriate exit function
switch (pCurrProcess->GetState())
{
case Process::SUCCEEDED :
{
pCurrProcess->VOnSuccess();
StrongProcessPtr pChild = pCurrProcess->RemoveChild();
if (pChild)
AttachProcess(pChild);
else
++successCount; // only counts if the whole chain completed
break;
}
case Process::FAILED :
{
pCurrProcess->VOnFail();
++failCount;
break;
}
case Process::ABORTED :
{
pCurrProcess->VOnAbort();
++failCount;
break;
}
}
// remove the process and destroy it
m_processList.erase(thisIt);
}
}
return ((successCount << 16) | failCount);
}
