2015-04-02 23:27:58 +09:00
|
|
|
#include "ProfileManager.h"
|
2016-01-06 00:01:17 +09:00
|
|
|
#include "profile/Profile.h"
|
|
|
|
#include "host/host.h"
|
|
|
|
#include "host/hookman.h"
|
|
|
|
#include "vnrhook/include/types.h"
|
|
|
|
#include "vnrhook/include/const.h"
|
|
|
|
#include "utility.h"
|
|
|
|
#include "profile/misc.h"
|
2015-04-02 23:27:58 +09:00
|
|
|
|
|
|
|
extern HookManager* man; // main.cpp
|
|
|
|
extern LONG auto_inject, auto_insert, inject_delay; // main.cpp
|
|
|
|
extern LONG insert_delay, process_time; // main.cpp
|
|
|
|
bool MonitorFlag;
|
|
|
|
ProfileManager* pfman;
|
|
|
|
|
|
|
|
DWORD WINAPI MonitorThread(LPVOID lpThreadParameter);
|
|
|
|
|
2016-01-06 00:01:17 +09:00
|
|
|
ProfileManager::ProfileManager() :
|
2015-04-02 23:27:58 +09:00
|
|
|
hMonitorThread(IthCreateThread(MonitorThread, 0))
|
|
|
|
{
|
2016-01-06 00:01:17 +09:00
|
|
|
LoadProfiles();
|
2015-04-02 23:27:58 +09:00
|
|
|
}
|
2016-01-06 00:01:17 +09:00
|
|
|
|
2015-04-02 23:27:58 +09:00
|
|
|
ProfileManager::~ProfileManager()
|
|
|
|
{
|
2016-01-06 00:01:17 +09:00
|
|
|
SaveProfiles();
|
2015-04-02 23:27:58 +09:00
|
|
|
WaitForSingleObject(hMonitorThread.get(), 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
Profile* ProfileManager::GetProfile(DWORD pid)
|
|
|
|
{
|
|
|
|
std::wstring path = GetProcessPath(pid);
|
|
|
|
if (!path.empty())
|
|
|
|
{
|
|
|
|
auto node = profile_tree.find(path);
|
|
|
|
if (node != profile_tree.end())
|
|
|
|
return node->second.get();
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2016-01-06 00:01:17 +09:00
|
|
|
bool ProfileManager::CreateProfile(pugi::xml_node game)
|
2015-04-02 23:27:58 +09:00
|
|
|
{
|
|
|
|
auto file = game.child(L"File");
|
|
|
|
auto profile = game.child(L"Profile");
|
|
|
|
if (!file || !profile)
|
|
|
|
return false;
|
|
|
|
auto path = file.attribute(L"Path");
|
|
|
|
if (!path)
|
|
|
|
return false;
|
|
|
|
auto profile_title = game.attribute(L"Title");
|
|
|
|
auto title = profile_title ? profile_title.value() : L"";
|
|
|
|
auto pf = new Profile(title);
|
|
|
|
if (!pf->XmlReadProfile(profile))
|
|
|
|
return false;
|
2016-01-06 00:01:17 +09:00
|
|
|
CSLock lock(cs);
|
|
|
|
auto& oldProfile = profile_tree[path.value()];
|
|
|
|
if (!oldProfile)
|
|
|
|
oldProfile.swap(profile_ptr(pf));
|
|
|
|
return true;
|
2015-04-02 23:27:58 +09:00
|
|
|
}
|
|
|
|
|
2016-01-06 00:01:17 +09:00
|
|
|
Profile* ProfileManager::CreateProfile(DWORD pid)
|
2015-04-02 23:27:58 +09:00
|
|
|
{
|
|
|
|
CSLock lock(cs);
|
2016-01-06 00:01:17 +09:00
|
|
|
auto path = GetProcessPath(pid);
|
2015-04-02 23:27:58 +09:00
|
|
|
auto& pf = profile_tree[path];
|
|
|
|
if (!pf)
|
|
|
|
{
|
|
|
|
std::wstring title = GetProcessTitle(pid);
|
|
|
|
pf.reset(new Profile(title));
|
|
|
|
}
|
|
|
|
return pf.get();
|
|
|
|
}
|
|
|
|
|
|
|
|
void ProfileManager::WriteProfileXml(const std::wstring& path, Profile& pf, pugi::xml_node root)
|
|
|
|
{
|
|
|
|
auto game = root.append_child(L"Game");
|
|
|
|
auto file_node = game.append_child(L"File");
|
|
|
|
file_node.append_attribute(L"Path") = path.c_str();
|
|
|
|
auto profile_node = game.append_child(L"Profile");
|
|
|
|
pf.XmlWriteProfile(profile_node);
|
|
|
|
if (!pf.Title().empty())
|
|
|
|
{
|
|
|
|
if (!game.attribute(L"Title"))
|
|
|
|
game.append_attribute(L"Title");
|
|
|
|
game.attribute(L"Title") = pf.Title().c_str();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-06 00:01:17 +09:00
|
|
|
void ProfileManager::LoadProfiles()
|
2015-04-02 23:27:58 +09:00
|
|
|
{
|
|
|
|
pugi::xml_document doc;
|
|
|
|
UniqueHandle hFile(IthCreateFile(L"ITH_Profile.xml", GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING));
|
|
|
|
if (hFile.get() == INVALID_HANDLE_VALUE)
|
|
|
|
return;
|
|
|
|
DWORD size = GetFileSize(hFile.get(), NULL);
|
|
|
|
std::unique_ptr<char[]> buffer(new char[size]);
|
|
|
|
ReadFile(hFile.get(), buffer.get(), size, &size, NULL);
|
|
|
|
auto result = doc.load_buffer(buffer.get(), size);
|
|
|
|
if (!result)
|
|
|
|
return;
|
|
|
|
auto root = doc.root().child(L"ITH_Profile");
|
|
|
|
if (!root)
|
|
|
|
return;
|
|
|
|
for (auto game = root.begin(); game != root.end(); ++game)
|
2016-01-06 00:01:17 +09:00
|
|
|
CreateProfile(*game);
|
2015-04-02 23:27:58 +09:00
|
|
|
}
|
|
|
|
|
2016-01-06 00:01:17 +09:00
|
|
|
void ProfileManager::SaveProfiles()
|
2015-04-02 23:27:58 +09:00
|
|
|
{
|
|
|
|
pugi::xml_document doc;
|
|
|
|
auto root = doc.append_child(L"ITH_Profile");
|
|
|
|
for (auto it = profile_tree.begin(); it != profile_tree.end(); ++it) {
|
|
|
|
auto& path = it->first;
|
|
|
|
auto& profile = it->second;
|
|
|
|
WriteProfileXml(path, *profile, root);
|
|
|
|
}
|
|
|
|
UniqueHandle hFile(IthCreateFile(L"ITH_Profile.xml", GENERIC_WRITE, 0, CREATE_ALWAYS));
|
|
|
|
if (hFile.get() != INVALID_HANDLE_VALUE)
|
|
|
|
{
|
|
|
|
FileWriter fw(hFile.get());
|
|
|
|
doc.save(fw);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void ProfileManager::DeleteProfile(const std::wstring& path)
|
|
|
|
{
|
|
|
|
CSLock lock(cs);
|
|
|
|
profile_tree.erase(profile_tree.find(path));
|
|
|
|
}
|
|
|
|
|
2016-01-06 00:01:17 +09:00
|
|
|
Profile* ProfileManager::GetProfile(const std::wstring& path)
|
2015-04-02 23:27:58 +09:00
|
|
|
{
|
|
|
|
if (path.empty())
|
2016-01-06 00:01:17 +09:00
|
|
|
return nullptr;
|
2015-04-02 23:27:58 +09:00
|
|
|
auto it = profile_tree.find(path);
|
|
|
|
if (it == profile_tree.end())
|
2016-01-06 00:01:17 +09:00
|
|
|
return nullptr;
|
|
|
|
return it->second.get();
|
2015-04-02 23:27:58 +09:00
|
|
|
}
|
|
|
|
|
|
|
|
bool ProfileManager::HasProfile(const std::wstring& path)
|
|
|
|
{
|
|
|
|
return profile_tree.find(path) != profile_tree.end();
|
|
|
|
}
|
|
|
|
|
2016-01-06 00:01:17 +09:00
|
|
|
DWORD ProfileManager::CountProfiles()
|
2015-04-02 23:27:58 +09:00
|
|
|
{
|
|
|
|
return profile_tree.size();
|
|
|
|
}
|
|
|
|
|
|
|
|
DWORD WINAPI InjectThread(LPVOID lpThreadParameter)
|
|
|
|
{
|
|
|
|
DWORD pid = (DWORD)lpThreadParameter;
|
|
|
|
Sleep(inject_delay);
|
|
|
|
if (man == NULL)
|
|
|
|
return 0;
|
2018-05-11 16:46:05 -04:00
|
|
|
DWORD status = InjectProcessById(pid);
|
2015-04-02 23:27:58 +09:00
|
|
|
if (!auto_insert)
|
|
|
|
return status;
|
|
|
|
if (status == -1)
|
|
|
|
return status;
|
|
|
|
Sleep(insert_delay);
|
|
|
|
const Profile* pf = pfman->GetProfile(pid);
|
|
|
|
if (pf)
|
|
|
|
{
|
|
|
|
SendParam sp;
|
|
|
|
sp.type = 0;
|
|
|
|
for (auto hp = pf->Hooks().begin(); hp != pf->Hooks().end(); ++hp)
|
2016-01-06 00:01:17 +09:00
|
|
|
{
|
|
|
|
std::string name = toMultiByteString((*hp)->Name());
|
2018-07-12 13:59:05 -04:00
|
|
|
InsertHook(pid, const_cast<HookParam*>(&(*hp)->HP()), name);
|
2016-01-06 00:01:17 +09:00
|
|
|
}
|
2015-04-02 23:27:58 +09:00
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
DWORD WINAPI MonitorThread(LPVOID lpThreadParameter)
|
|
|
|
{
|
|
|
|
while (MonitorFlag)
|
|
|
|
{
|
2016-01-06 00:01:17 +09:00
|
|
|
DWORD aProcesses[1024], cbNeeded, cProcesses;
|
2015-04-02 23:27:58 +09:00
|
|
|
if (!EnumProcesses(aProcesses, sizeof(aProcesses), &cbNeeded))
|
|
|
|
break;
|
|
|
|
cProcesses = cbNeeded / sizeof(DWORD);
|
|
|
|
for (size_t i = 0; i < cProcesses; ++i)
|
|
|
|
{
|
|
|
|
Sleep(process_time);
|
|
|
|
if (!auto_inject || man == NULL || man->GetProcessRecord(aProcesses[i]))
|
|
|
|
continue;
|
|
|
|
std::wstring process_path = GetProcessPath(aProcesses[i]);
|
|
|
|
if (!process_path.empty() && pfman->HasProfile(process_path))
|
|
|
|
{
|
|
|
|
UniqueHandle hThread(IthCreateThread(InjectThread, aProcesses[i]));
|
|
|
|
WaitForSingleObject(hThread.get(), 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
DWORD SaveProcessProfile(DWORD pid)
|
|
|
|
{
|
|
|
|
std::wstring path = GetProcessPath(pid);
|
|
|
|
if (path.empty())
|
|
|
|
return 0;
|
2016-01-06 00:01:17 +09:00
|
|
|
pugi::xml_document doc;
|
|
|
|
pugi::xml_node profile_node = doc.append_child(L"Profile");
|
|
|
|
man->GetProfile(pid, profile_node);
|
2015-04-02 23:27:58 +09:00
|
|
|
Profile* pf = pfman->GetProfile(pid);
|
|
|
|
if (pf != NULL)
|
|
|
|
pf->Clear();
|
|
|
|
else
|
2016-01-06 00:01:17 +09:00
|
|
|
pf = pfman->CreateProfile(pid);
|
|
|
|
pf->XmlReadProfile(profile_node);
|
2015-04-02 23:27:58 +09:00
|
|
|
return 0;
|
|
|
|
}
|