UINT StrToIP4(LPCSTR strIP)
{
if (!strIP)
return 0;
BYTE pIP[4] = { 0 };
std::string strTempIP(strIP);
SIZE_T nb = 0;
SIZE_T ne = 0;
for (size_t i = 0; i < 4; i++)
{
ne = strTempIP.find('.', nb);
if (ne != strTempIP.npos)
{
pIP[i] = StrToIntA(strTempIP.substr(nb, ne).c_str());
nb = ne + 1;
}
}
pIP[3] = StrToIntA(strTempIP.substr(nb, strTempIP.length()).c_str());
return *(UINT*)pIP;
}
int assign_uint(void* value_ptr, const char* value_string)
{
int i_ret = APP_SUCCESS;
char tmp_value[MAX_STRING_SIZE] = {0};
strcpy_s(tmp_value, MAX_STRING_SIZE - 1, value_string);
// StrTrimA(tmp_value, " ");
*((unsigned int*)value_ptr) = StrToIntA(tmp_value);
return i_ret;
}
int assign_ushort(void* value_ptr, const char* value_string)
{
int i_ret = APP_SUCCESS;
char tmp_value[MAX_STRING_SIZE] = {0};
strcpy_s(tmp_value, MAX_STRING_SIZE - 1, value_string);
StrTrimA(tmp_value, " ");
*((unsigned short*)value_ptr) = static_cast<unsigned short>(StrToIntA(tmp_value));
return i_ret;
}
static void test_StrToIntA(void)
{
const StrToIntResult *result = StrToInt_results;
int return_val;
while (result->string)
{
return_val = StrToIntA(result->string);
ok(return_val == result->str_to_int, "converted '%s' wrong (%d)\n",
result->string, return_val);
result++;
}
}
REQUEST_NOTIFICATION_STATUS CCacheHelperModule::OnSendResponse(
IN IHttpContext* pHttpContext, IN ISendResponseProvider* pProvider)
{
UNREFERENCED_PARAMETER(pProvider);
IHttpResponse* pHttpResponse = pHttpContext->GetResponse();
IHttpRequest* pHttpRequest = pHttpContext->GetRequest();
if ((pHttpResponse != NULL) && (pHttpRequest != NULL))
{
HTTP_COOKED_URL url = pHttpRequest->GetRawHttpRequest()->CookedUrl;
if (!m_pConfig->UrlHasSitePrefix(url.pAbsPath))
return RQ_NOTIFICATION_CONTINUE;
CachingBehavior behavior = CachingBehaviorIgnore;
USHORT cchXCache;
PCSTR szXCache = pHttpResponse->GetHeader((PCSTR)"X-Cache", &cchXCache);
if (cchXCache > 0)
{
behavior = (CachingBehavior)StrToIntA(szXCache);
pHttpResponse->DeleteHeader((PCSTR)"X-Cache");
}
else
{
behavior = m_pConfig->GetCachePolicy(url.pAbsPath);
}
switch (behavior)
{
case CachingBehaviorPrivate:
MakeUncacheable(pHttpResponse);
break;
case CachingBehaviorConditional:
MakeConditionallyCacheable(pHttpResponse);
break;
case CachingBehaviorPublic:
MakeCacheable(pHttpResponse);
break;
}
}
return RQ_NOTIFICATION_CONTINUE;
}
int HttpDownLoad_real(
std::string& tmp_file,
const std::string& url,
const std::string& file,
std::function<void(double)> callback)
{
HINTERNET hSession = InternetOpen(_T("HTTPDOWNLOAD"), INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
scloud::ScopeGuard session([hSession]{InternetCloseHandle(hSession);});
if (!hSession) {
session.cancel();
return GetLastError();
}
HINTERNET hInternet = InternetOpenUrl(hSession, url.c_str(), NULL, 0 , INTERNET_FLAG_RAW_DATA, 0 );
scloud::ScopeGuard internet([hInternet]{InternetCloseHandle(hInternet);});
if (!hInternet) {
internet.cancel();
return GetLastError();
}
//get http return code.
char szContent[32] = {0};
DWORD dwInfoSize = 32;
HttpQueryInfoA(hInternet, HTTP_QUERY_STATUS_CODE, szContent, &dwInfoSize, NULL);
int ret = StrToIntA(szContent);
if (ret >= 400)
{
return ret;
}
//get file size
ZeroMemory(szContent, 32);
dwInfoSize = 32;
HttpQueryInfoA(hInternet, HTTP_QUERY_CONTENT_LENGTH, szContent, &dwInfoSize, NULL);
__int64 size = 0;
StrToInt64ExA(szContent, 10, &size);
if (size <= 0)
{
return ERROR_CONTENT_LENGTH_LESS_THAN_ZERO;
}
TCHAR szTmpFile[MAX_PATH] = {0};
if (!tmp_file.empty())
{
lstrcpy(szTmpFile, tmp_file.c_str());
}
else
{
TCHAR szTmpPath[MAX_PATH] = {0};
GetTempPath(MAX_PATH, szTmpPath);
if (0 == GetTempFileName(szTmpPath, _T("http"), 0, szTmpFile))
{
return GetLastError();
}
}
tmp_file = szTmpFile;
HANDLE hFile = CreateFile(szTmpFile,
GENERIC_WRITE,
FILE_SHARE_READ,
NULL,
OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL);
scloud::ScopeGuard create_file([hFile]{CloseHandle(hFile);});
if (INVALID_HANDLE_VALUE == hFile)
{
create_file.cancel();
return GetLastError();
}
LARGE_INTEGER large_int = {0};
GetFileSizeEx(hFile, &large_int);
if (large_int.QuadPart > size)
{
return ERROR_TMP_FILE_TOO_BIG;
}
if (large_int.QuadPart > 0)
{
if (INVALID_SET_FILE_POINTER == SetFilePointer(hFile, 0, NULL, FILE_END))
{
return GetLastError();
}
if (INVALID_SET_FILE_POINTER == InternetSetFilePointer(
hInternet, large_int.LowPart, NULL, FILE_BEGIN, 0))
{
return GetLastError();
}
}
__int64 rsize = large_int.QuadPart;
for(;rsize < size;)
{
char buf[512] = {0};
DWORD dwRead = 0;
if (!InternetReadFile(hInternet, buf, 512, &dwRead))
{
return GetLastError();
}
if (dwRead == 0)
{
return ERROR_WTF_NO_DATA;
}
for(DWORD dwOnce=0; dwRead != dwOnce;)
{
DWORD dwWritten = 0;
if (0 == WriteFile(hFile, buf+dwOnce, dwRead-dwOnce, &dwWritten, NULL))
return GetLastError();
dwOnce += dwWritten;
}
rsize += dwRead;
if (rsize == size)
break;
if (callback)
callback((double)rsize/size);
}
if (rsize == size)
{
create_file.cancel();
CloseHandle(hFile);
SetFileAttributes(file.c_str(), FILE_ATTRIBUTE_NORMAL);
DeleteFile(file.c_str());
if (MoveFile(szTmpFile, file.c_str()))
{
//succeed.
if (callback)
callback(1.0);
return 0;
}
}
return GetLastError();
}
pfc::string8 provider_darklyrics::lookup_one(unsigned p_index, const metadb_handle_ptr & p_meta, threaded_process_status & p_status, abort_callback & p_abort)
{
TRACK_CALL_TEXT("provider_darklyrics::lookup_one");
const float threshold = 0.8f;
const pfc::string8 site = "darklyrics.com";
// Regular Expression Class
CRegexpT<char> regexp;
MatchResult match;
// Buffer
pfc::string8 buff;
try
{
// Init fetcher
curl_wrapper_simple fetcher(&m_config_item);
const metadb_handle_ptr & p = p_meta;
if (p.is_empty())
{
return "";
}
pfc::string8_fast artist, title, album, keywords;
file_info_impl info;
p->get_info(info);
// Get count of artists
t_size count = info.meta_get_count_by_name("album");
if (count == 0)
return "";
// Get Album
album = info.meta_get("album", 0);
count = info.meta_get_count_by_name("title");
if (count == 0)
return "";
// Get TITLE
title = info.meta_get("title", 0);
count = info.meta_get_count_by_name("artist");
// Iterate through all artists listed
for (int j = 0; j < count; j++)
{
// Get Artist
artist = info.meta_get("artist", j); //Fetching from HTTP
keywords = artist;
keywords += "+";
keywords += album;
keywords.replace_char(' ', '+');
// Get it now
try
{
fetcher.fetch_googleluck(site, keywords, buff);
}
catch (pfc::exception & e)
{
console_error(e.what());
continue;
}
catch (...)
{
continue;
}
const char * regex_ahref = "<a\\shref=\"#(?P<no>\\d+)\">(?P<text>.+?)</a>";
// expression for extract lyrics
regexp.Compile(regex_ahref, IGNORECASE);
// match
MatchResult result = regexp.Match(buff.get_ptr());
int noGroup = regexp.GetNamedGroupNumber("no");
int textGroup = regexp.GetNamedGroupNumber("text");
int jump_to = 0;
pfc::string8_fast compare = title;
compare.insert_chars(0, ". ");
float good;
float best = 0.0f;
while (result.IsMatched())
{
int gStart = result.GetGroupStart(noGroup);
int gEnd = result.GetGroupEnd(noGroup);
pfc::string8_fast temp(buff.get_ptr() + gStart, gEnd - gStart);
int no = StrToIntA(temp);
gStart = result.GetGroupStart(textGroup);
gEnd = result.GetGroupEnd(textGroup);
temp = pfc::string8_fast(buff.get_ptr()+gStart, gEnd - gStart);
int levDist = LD(compare, compare.get_length(), temp, temp.get_length());
good = 1.0f - (levDist / (float)compare.get_length());
if (good >= threshold && good > best)
{
jump_to = no;
best = good;
}
result = regexp.Match(buff.get_ptr(),result.GetEnd());
}
if (jump_to == 0)
{
continue;
}
char regex_lyrics[100];
sprintf(regex_lyrics, "<a\\s+name=%d><font*(.*?)</font*(.*?)>(?P<lyrics>.+?)<font", jump_to);
// expression for extract lyrics
regexp.Compile(regex_lyrics, IGNORECASE | SINGLELINE);
noGroup = regexp.GetNamedGroupNumber("lyrics");
result = regexp.Match(buff.get_ptr());
if (result.IsMatched())
{
int nStart = result.GetGroupStart(noGroup);
int nEnd = result.GetGroupEnd(noGroup);
pfc::string8 lyric(buff.get_ptr() + nStart, nEnd - nStart);
convert_html_to_plain(lyric);
if (lyric.get_length() > 0)
{
string_helper::remove_beginning_linebreaks(lyric);
string_helper::remove_end_linebreaks(lyric);
string_helper::remove_beginning(lyric, ' ');
string_helper::remove_beginning(lyric, '\t');
return lyric;
}
}
}
}
catch (pfc::exception & e)
{
console_error(e.what());
return "";
}
catch (...)
{
return "";
}
return "";
}
//************************************************************************
//* Dark Lyrics *
//************************************************************************
pfc::string_list_impl * provider_darklyrics::lookup(unsigned p_index, metadb_handle_list_cref p_meta, threaded_process_status & p_status, abort_callback & p_abort)
{
TRACK_CALL_TEXT("provider_darklyrics::lookup");
const float threshold = 0.8f;
const pfc::string8 site = "darklyrics.com";
// Regular Expression Class
CRegexpT<char> regexp;
MatchResult match;
// Buffer
pfc::string8 buff;
pfc::string_list_impl * str_list = new pfc::string_list_impl;
try
{
// Init fetcher
curl_wrapper_simple fetcher(&m_config_item);
for (t_size i = 0; i < p_meta.get_count(); ++i)
{
if (p_abort.is_aborting())
break;
// Sleep
how_to_sleep(i);
// Clear buff
buff.reset();
const metadb_handle_ptr & p = p_meta.get_item(i);
if (p.is_empty())
{
str_list->add_item("");
continue;
}
// Set progress
pfc::string8_fast path = file_path_canonical(p->get_path());
// add subsong index?
if (p->get_subsong_index() > 0)
{
path.add_string(" /index:");
path.add_string(pfc::format_uint(p->get_subsong_index()));
}
p_status.set_item_path(path);
p_status.set_progress(i + 1, p_meta.get_count());
pfc::string8_fast artist, title, album, keywords;
file_info_impl info;
p->get_info(info);
// Get count of artists
t_size count = info.meta_get_count_by_name("album");
if (count == 0)
continue;
// Get Album
album = info.meta_get("album", 0);
count = info.meta_get_count_by_name("title");
if (count == 0)
continue;
// Get TITLE
title = info.meta_get("title", 0);
count = info.meta_get_count_by_name("artist");
bool found = false;
// Iterate through all artists listed
for (int j = 0; j < count && !found; j++)
{
// Get Artist
artist = info.meta_get("artist", j);
keywords = artist;
keywords += "+";
keywords += album;
keywords.replace_char(' ', '+');
// Get it now
try
{
fetcher.fetch_googleluck(site, keywords, buff);
}
catch (pfc::exception & e)
{
console_error(e.what());
continue;
}
catch (...)
{
continue;
}
const char * regex_ahref = "<a\\shref=\"#(?P<no>\\d+)\">(?P<text>.+?)</a>";
// expression for extract lyrics
regexp.Compile(regex_ahref, IGNORECASE | SINGLELINE);
// match
MatchResult result = regexp.Match(buff.get_ptr());
int noGroup = regexp.GetNamedGroupNumber("no");
int textGroup = regexp.GetNamedGroupNumber("text");
int jump_to = 0;
pfc::string8_fast compare = title;
compare.insert_chars(0, ". ");
float good;
float best = 0.0f;
while (result.IsMatched())
{
int gStart = result.GetGroupStart(noGroup);
int gEnd = result.GetGroupEnd(noGroup);
pfc::string8_fast temp(buff.get_ptr() + gStart, gEnd - gStart);
int no = StrToIntA(temp);
gStart = result.GetGroupStart(textGroup);
gEnd = result.GetGroupEnd(textGroup);
temp = pfc::string8_fast(buff.get_ptr()+gStart, gEnd - gStart);
if (temp.find_first(title) != -1)
{
jump_to = no;
break;
}
int levDist = LD(compare, compare.get_length(), temp, temp.get_length());
good = 1.0f - (levDist / (float)compare.get_length());
if (good >= threshold && good > best)
{
jump_to = no;
best = good;
}
result = regexp.Match(buff.get_ptr(),result.GetEnd());
}
if (jump_to == 0)
{
continue;
}
char regex_lyrics[100];
sprintf(regex_lyrics, "<a\\s+name=%d><font*(.*?)</font*(.*?)>(?P<lyrics>.+?)<font", jump_to);
// expression for extract lyrics
regexp.Compile(regex_lyrics, IGNORECASE | SINGLELINE);
noGroup = regexp.GetNamedGroupNumber("lyrics");
result = regexp.Match(buff.get_ptr());
if (result.IsMatched())
{
int nStart = result.GetGroupStart(noGroup);
int nEnd = result.GetGroupEnd(noGroup);
pfc::string8 lyric(buff.get_ptr() + nStart, nEnd - nStart);
convert_html_to_plain(lyric);
if (lyric.get_length() > 0)
{
string_helper::remove_beginning_linebreaks(lyric);
string_helper::remove_end_linebreaks(lyric);
string_helper::remove_beginning(lyric, ' ');
string_helper::remove_beginning(lyric, '\t');
console::print(lyric);
str_list->add_item(lyric);
found = true;
continue;
}
}
}
if (found)
continue;
else
str_list->add_item("");
}
}
catch (pfc::exception & e)
{
console_error(e.what());
delete str_list;
return NULL;
}
catch (...)
{
delete str_list;
return NULL;
}
return str_list;
}
/*************************************************************************
* Options_RunDLLA (SHELL32.@)
*/
EXTERN_C VOID WINAPI Options_RunDLLA(HWND hWnd, HINSTANCE hInst, LPCSTR cmd, DWORD nCmdShow)
{
Options_RunDLLCommon(hWnd, hInst, StrToIntA(cmd), nCmdShow);
}
// CoreBase class instance 偵偁傞 SQVM instance 偺 Root Table 偐傜 巜掕偝傟偨僷僗偺 item value 傪 fetch
static bool FindRTChild(LPCSTR path, DWORD &retType, DWORD &retVal)
{
DWORD_PTR items;
DWORD_PTR itemVal;
DWORD_PTR itemVal2;
DWORD itemType;
DWORD itemNum;
DWORD itemLen;
DWORD itemIndex;
DWORD readSize;
DWORD titemType;
BOOL ret;
DWORD j;
// CoreBase 偐傜 table 傪撉傒崬傓
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)((DWORD_PTR)s_th135ModuleInfo.lpBaseOfDll + s_CoreBase), &itemVal, sizeof itemVal, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)((DWORD_PTR)itemVal + 0x34), &itemVal, sizeof itemVal, &readSize);
if (!ret) return false;
//此处需要Corebase正确
itemType = 0x20;
StringSplitter tokenizer(path, '/');
LPCSTR pathToken;
while (pathToken = tokenizer.Next()) {
switch(itemType & 0xFFFFF) {
case 0x20: // TABLE
// Table 偺忣曬傪撉傒崬傓
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal + 0x20), &items, sizeof items, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal + 0x24), &itemNum, sizeof itemNum, &readSize);
if (!ret) return false;
// Table items 傪扵嶕
for (j = 0; j < itemNum; ++j) {
// Table item key 傪撉傒崬傓
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + j * 0x14 + 0x08), &itemType, sizeof itemType, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + j * 0x14 + 0x0c), &itemVal, sizeof itemVal, &readSize);
if (!ret) return false;
// Table item key 偑暥帤楍偺偲偒偩偗庴偗晅偗傞
if ((itemType & 0xFFFFF) == 0x10) {
// Table item key 傪暥帤楍偲偟偰撉傒崬傓
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal + 0x14), &itemLen, sizeof itemLen, &readSize);
if (!ret) return false;
Minimal::ProcessHeapArrayT<char> key(itemLen + 1);
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal + 0x1C), key.GetRaw(), itemLen, &readSize);
if (!ret) return false;
key[itemLen] = 0;
// Table item key 偺抣偑 path 偺僩乕僋儞偲堦抳偟偨傜 table item value 傪撉傒崬傓
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + j * 0x14 + 0x00), &titemType, sizeof titemType, &readSize);
if (::lstrcmpA(key.GetRaw(), pathToken) == 0) {
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + j * 0x14 + 0x00), &itemType, sizeof itemType, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + j * 0x14 + 0x04), &itemVal, sizeof itemVal, &readSize);
if (!ret) return false;
break;
}
}
}
if (j == itemNum) return false;
break;
case 0x40: // ARRAY
// Array item 偺愭摢傾僪儗僗偲 item 悢傪撉傒崬傓
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal + 0x18), &items, sizeof items, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal + 0x1C), &itemNum, sizeof itemNum, &readSize);
if (!ret) return false;
// Path 偺僩乕僋儞傪 Array item 偺 index 偲尒側偟偰斖埻僠僃僢僋
itemIndex = StrToIntA(pathToken);
if(itemNum <= itemIndex) return false;
// Array item 傪撉傒崬傓
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + itemIndex * 0x08 + 0x00), &itemType, sizeof itemType, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + itemIndex * 0x08 + 0x04), &itemVal, sizeof itemVal, &readSize);
if (!ret) return false;
break;
case 0x8000: // INSTANCE
// Instance members 偺忣曬傪撉傒崬傓
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal + 0x1C), &items, sizeof items, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + 0x18), &items, sizeof items, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + 0x24), &itemNum, sizeof itemNum, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + 0x20), &items, sizeof items, &readSize);
if (!ret) return false;
// Instance members 傪扵嶕
for (j = 0; j < itemNum; ++j) {
// Instance member metadata value 傪撉傒崬傓
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + j * 0x14 + 0x00), &itemType, sizeof itemType, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + j * 0x14 + 0x04), &itemVal2, sizeof itemVal, &readSize);
if (!ret) return false;
// Instance member metadata value 偑桳岠側偲偒偩偗庴偗晅偗傞
if ((itemType & 0xFFFFF) == 0x02) {
// Instance member metadata value 偐傜 instance member type 偲 instance member index 傪拪弌
DWORD memberType = itemVal2 & 0xFF000000;
DWORD memberIndex = itemVal2 & 0x00FFFFFF;
// Instance member type 偑桳岠側偲偒偩偗庴偗晅偗傞
if (memberType == 0x02000000) {
// Instance member metadata key 傪撉傒崬傓
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + j * 0x14 + 0x08), &itemType, sizeof itemType, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + j * 0x14 + 0x0c), &itemVal2, sizeof itemVal, &readSize);
if (!ret) return false;
// Instance member metadata key 偑暥帤楍偺偲偒偩偗庴偗晅偗傞
if ((itemType & 0xFFFFF) == 0x10) {
// Instance member metadata key 傪暥帤楍偲偟偰撉傒崬傓
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal2 + 0x14), &itemLen, sizeof itemLen, &readSize);
if (!ret) return false;
Minimal::ProcessHeapArrayT<char> key(itemLen + 1);
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal2 + 0x1C), key.GetRaw(), itemLen, &readSize);
if (!ret) return false;
key[itemLen] = 0;
// Instance member metadata key 偺抣偑 path 偺僩乕僋儞偲堦抳偟偨傜 instance member value 傪撉傒崬傓
if (::lstrcmpA(key.GetRaw(), pathToken) == 0) {
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal + 0x2C + memberIndex * 0x08 + 0x00), &itemType, sizeof itemType, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal + 0x2C + memberIndex * 0x08 + 0x04), &itemVal, sizeof itemVal, &readSize);
if (!ret) return false;
break;
}
}
}
}
}
if (j == itemNum) return false;
break;
}
}
retType = itemType;
retVal = itemVal;
return true;
}
static bool EnumRTChild(LPCSTR path,int level)
{
DWORD_PTR items;
DWORD_PTR itemVal;
DWORD_PTR titemVal;
DWORD_PTR itemVal2;
DWORD itemType;
DWORD itemNum;
DWORD itemLen;
DWORD itemIndex;
DWORD readSize;
DWORD titemType;
BOOL ret;
DWORD j;
int curlevel=-1;
// CoreBase 偐傜 table 傪撉傒崬傓
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)((DWORD_PTR)s_th135ModuleInfo.lpBaseOfDll + s_CoreBase), &itemVal, sizeof itemVal, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)((DWORD_PTR)itemVal + 0x34), &itemVal, sizeof itemVal, &readSize);
if (!ret) return false;
//此处需要Corebase正确
itemType = 0x20;
StringSplitter tokenizer(path, '/');
LPCSTR pathToken;
while (pathToken = tokenizer.Next()) {
++curlevel;
switch(itemType & 0xFFFFF) {
case 0x20: // TABLE
// Table 偺忣曬傪撉傒崬傓
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal + 0x20), &items, sizeof items, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal + 0x24), &itemNum, sizeof itemNum, &readSize);
if (!ret) return false;
// Table items 傪扵嶕
for (j = 0; j < itemNum; ++j) {
// Table item key 傪撉傒崬傓
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + j * 0x14 + 0x08), &itemType, sizeof itemType, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + j * 0x14 + 0x0c), &itemVal, sizeof itemVal, &readSize);
if (!ret) return false;
// Table item key 偑暥帤楍偺偲偒偩偗庴偗晅偗傞
if ((itemType & 0xFFFFF) == 0x10) {
// Table item key 傪暥帤楍偲偟偰撉傒崬傓
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal + 0x14), &itemLen, sizeof itemLen, &readSize);
if (!ret) return false;
Minimal::ProcessHeapArrayT<char> key(itemLen + 1);
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal + 0x1C), key.GetRaw(), itemLen, &readSize);
if (!ret) return false;
key[itemLen] = 0;
// Table item key 偺抣偑 path 偺僩乕僋儞偲堦抳偟偨傜 table item value 傪撉傒崬傓
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + j * 0x14 + 0x00), &titemType, sizeof titemType, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + j * 0x14 + 0x04), &titemVal, sizeof titemVal, &readSize);
if (!ret) return false;
if(((titemType & 0xFFFFF)==0x20 || (titemType & 0xFFFFF)==0x8000) && level==curlevel)//Table 则继续向下遍历
{
Minimal::ProcessHeapArrayT<char> newpath(strlen(path)+itemLen+2);
strcpy_s(newpath.GetRaw(),strlen(path)+itemLen+2,path);
if(level!=0)
{
}
strcat_s(newpath.GetRaw(),strlen(path)+itemLen+2,key.GetRaw());
strcat_s(newpath.GetRaw(),strlen(path)+itemLen+2,"/");
EnumRTChild(newpath.GetRaw(),level+1);
}
if(level==curlevel)
{
int bsize=strlen(path)+itemLen+30;
Minimal::ProcessHeapArrayT<char> newpath(bsize);
sprintf_s(newpath.GetRaw(),bsize,"%s %s 0x%x %x %x \n",path,key.GetRaw(),(DWORD_PTR)(items + j * 0x14 + 0x04),(titemType & 0xFFFFF),titemVal);
OutputDebugStringA(newpath.GetRaw());
}
if (::lstrcmpA(key.GetRaw(), pathToken) == 0) {
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + j * 0x14 + 0x00), &itemType, sizeof itemType, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + j * 0x14 + 0x04), &itemVal, sizeof itemVal, &readSize);
if (!ret) return false;
break;
}
}
}
if (j == itemNum) return false;
break;
case 0x40: // ARRAY
// Array item 偺愭摢傾僪儗僗偲 item 悢傪撉傒崬傓
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal + 0x18), &items, sizeof items, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal + 0x1C), &itemNum, sizeof itemNum, &readSize);
if (!ret) return false;
// Path 偺僩乕僋儞傪 Array item 偺 index 偲尒側偟偰斖埻僠僃僢僋
itemIndex = StrToIntA(pathToken);
if(itemNum <= itemIndex) return false;
// Array item 傪撉傒崬傓
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + itemIndex * 0x08 + 0x00), &itemType, sizeof itemType, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + itemIndex * 0x08 + 0x04), &itemVal, sizeof itemVal, &readSize);
if (!ret) return false;
break;
case 0x8000: // INSTANCE
// Instance members 偺忣曬傪撉傒崬傓
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal + 0x1C), &items, sizeof items, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + 0x18), &items, sizeof items, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + 0x24), &itemNum, sizeof itemNum, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + 0x20), &items, sizeof items, &readSize);
if (!ret) return false;
// Instance members 傪扵嶕
for (j = 0; j < itemNum; ++j) {
// Instance member metadata value 傪撉傒崬傓
//int tmp1,tmp2;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + j * 0x14 + 0x00), &itemType, sizeof itemType, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + j * 0x14 + 0x04), &itemVal2, sizeof itemVal, &readSize);
if (!ret) return false;
// Instance member metadata value 偑桳岠側偲偒偩偗庴偗晅偗傞
if ((itemType & 0xFFFFF) == 0x02) {
// Instance member metadata value 偐傜 instance member type 偲 instance member index 傪拪弌
DWORD memberType = itemVal2 & 0xFF000000;
DWORD memberIndex = itemVal2 & 0x00FFFFFF;
// Instance member type 偑桳岠側偲偒偩偗庴偗晅偗傞
if (memberType == 0x02000000) {
// Instance member metadata key 傪撉傒崬傓
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + j * 0x14 + 0x08), &itemType, sizeof itemType, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(items + j * 0x14 + 0x0c), &itemVal2, sizeof itemVal, &readSize);
if (!ret) return false;
// Instance member metadata key 偑暥帤楍偺偲偒偩偗庴偗晅偗傞
if ((itemType & 0xFFFFF) == 0x10) {
// Instance member metadata key 傪暥帤楍偲偟偰撉傒崬傓
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal2 + 0x14), &itemLen, sizeof itemLen, &readSize);
if (!ret) return false;
Minimal::ProcessHeapArrayT<char> key(itemLen + 1);
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal2 + 0x1C), key.GetRaw(), itemLen, &readSize);
if (!ret) return false;
key[itemLen] = 0;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal + 0x2C + memberIndex * 0x08 + 0x00), &titemType, sizeof titemType, &readSize);
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal + 0x2C + memberIndex * 0x08 + 0x04), &titemVal, sizeof titemVal, &readSize);
if(((titemType & 0xFFFFF)==0x20 || (titemType & 0xFFFFF)==0x8000) && level==curlevel)//Table 则继续向下遍历
{
Minimal::ProcessHeapArrayT<char> newpath(strlen(path)+itemLen+2);
strcpy_s(newpath.GetRaw(),strlen(path)+itemLen+2,path);
if(level!=0)
{
}
strcat_s(newpath.GetRaw(),strlen(path)+itemLen+2,key.GetRaw());
strcat_s(newpath.GetRaw(),strlen(path)+itemLen+2,"/");
EnumRTChild(newpath.GetRaw(),level+1);
}
if(level==curlevel){
int bsize=strlen(path)+itemLen+30;
Minimal::ProcessHeapArrayT<char> newpath(bsize);
sprintf_s(newpath.GetRaw(),bsize,"%s %s 0x%x %x %x\n",path,key.GetRaw(),(DWORD_PTR)(itemVal + 0x2C + memberIndex * 0x08 + 0x04),(titemType & 0xFFFFF),titemVal);
OutputDebugStringA(newpath.GetRaw());
}
// Instance member metadata key 偺抣偑 path 偺僩乕僋儞偲堦抳偟偨傜 instance member value 傪撉傒崬傓
if (::lstrcmpA(key.GetRaw(), pathToken) == 0) {
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal + 0x2C + memberIndex * 0x08 + 0x00), &itemType, sizeof itemType, &readSize);
if (!ret) return false;
ret = ::ReadProcessMemory(s_ThProc, (LPVOID)(itemVal + 0x2C + memberIndex * 0x08 + 0x04), &itemVal, sizeof itemVal, &readSize);
if (!ret) return false;
break;
}
}
}
}
}
if (j == itemNum) return false;
break;
}
}
return true;
}
