LSTATUS APIENTRY RegTree::RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
{
Console::GetInstance().Print(L"RegOpenKeyExW: %.8X, %s\n", hKey, lpSubKey);
RegPath path;
if (ResolveKey(hKey, lpSubKey, path))
{
RegNode *node = OpenKey(path);
if (node != NULL)
{
HKEY resultKey = node->AsKey();
if (IsVirtualKey(resultKey))
{
*phkResult = resultKey;
return ERROR_SUCCESS;
}
else
return Real_RegOpenKeyExW(resultKey, NULL, ulOptions, samDesired, phkResult);
}
else
return ERROR_NOT_FOUND;
}
else
return Real_RegOpenKeyExW(hKey, lpSubKey, ulOptions, samDesired, phkResult);
}
LONG WINAPI Mine_RegOpenKeyExW(HKEY a0, LPCWSTR a1, DWORD a2, REGSAM a3, PHKEY a4)
{
TRACE_SVP5( L"Mine_RegOpenKeyExW %s %x ", a1, a2);
if(CFilterMapper2::m_pFilterMapper2 && (a3&(KEY_SET_VALUE|KEY_CREATE_SUB_KEY))) {*a4 = FAKEHKEY; return ERROR_SUCCESS;}
/*if(a0 >= FAKEHKEY && a0 <= (FAKEHKEY + 100) ){
TRACE_SVP5(L"Real_RegOpenKeyExW FAKEHKEY %s" , a1);
*a4 = a0++;
return ERROR_SUCCESS;
}
if( a1 && _wcsicmp(_T("CLSID\\{B841F346-4835-4DE8-AA5E-2E7CD2D4C435}"), a1) == 0 ){
*a4 = FAKEHKEY + 3;
TRACE_SVP5(L"Real_RegOpenKeyExW %s" , a1);
return ERROR_SUCCESS;
}
if( a1 && _wcsicmp(_T("Media Type\\{E436EB83-524F-11CE-9F53-0020AF0BA770}\\{49952F4C-3EDC-4A9B-8906-1DE02A3D4BC2}"), a1) == 0 ){
TRACE_SVP5(L"Real_RegOpenKeyExW %s" , a1);
}
if( a1 && _wcsicmp(_T("CLSID\\{DB43B405-43AA-4f01-82D8-D84D47E6019C}"), a1) == 0 ){ //ogm
TRACE_SVP5(L"Real_RegOpenKeyExW %s" , a1);
}
*/
if( a1 && _wcsicmp(_T("Software\\HaaliMkx\\Input"), a1) == 0 ){
*a4 = FAKEHKEY+14;
return ERROR_SUCCESS;
}
LONG ret = Real_RegOpenKeyExW(a0, a1, a2, a3, a4);
TRACE_SVP5(L"Mine_RegOpenKeyExW %x %s %x" , a0, a1 , ret);
return ret;
}
LONG WINAPI Mine_RegOpenKeyExW(HKEY a0, LPCWSTR a1, DWORD a2, REGSAM a3, PHKEY a4)
{
if (CFilterMapper2::m_pFilterMapper2 && (a3 & (KEY_SET_VALUE | KEY_CREATE_SUB_KEY))) {
*a4 = FAKEHKEY;
return ERROR_SUCCESS;
}
return Real_RegOpenKeyExW(a0, a1, a2, a3, a4);
}
void RegTree::InitPrefixs( void )
{
HKEY key;
wstring path;
RegOpenCurrentUser(KEY_READ, &key);
ResolveKey(key, path);
m_currentUserPrefix = path;
Real_RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\Classes", 0, KEY_READ, &key);
ResolveKey(key, path);
m_classesRootPrefix = path;
Real_RegOpenKeyExW(HKEY_CURRENT_CONFIG, L"Software", 0, KEY_READ, &key);
ResolveKey(key, path);
m_currentConfigSoftwarePrefix = path;
Real_RegOpenKeyExW(HKEY_CURRENT_CONFIG, L"System", 0, KEY_READ, &key);
ResolveKey(key, path);
m_currentConfigSystemPrefix = path;
}
void RegTree::LoadRealChildren( RegNode *node )
{
if (node->m_realKey != NULL)
{
ClearRealChildren(node);
for (DWORD index = 0; ; index++)
{
WCHAR keyName[MAX_KEY_LENGTH + 1];
DWORD keyNameLen = _countof(keyName);
WCHAR className[MAX_PATH + 1];
DWORD classNameLen = _countof(className);
if (Real_RegEnumKeyExW(node->m_realKey, index, keyName, &keyNameLen, NULL, className, &classNameLen, NULL) != ERROR_SUCCESS)
break;
HKEY newKey;
if (Real_RegOpenKeyExW(node->m_realKey, keyName, 0, KEY_ALL_ACCESS, &newKey) != ERROR_SUCCESS)
continue;
typedef RegNodeList::index<RegNodeIndex::Name>::type Index;
Index &childIndex = node->m_children.get<RegNodeIndex::Name>();
Index::iterator iter = childIndex.find(to_lower_copy(wstring(keyName)));
if (iter != childIndex.end())
continue;
auto_ptr<RegNode> newNode = RegNode::CreateReal(node->m_rootKey, keyName, newKey);
newNode->m_parent = node;
node->m_children.push_back(newNode.release());
}
BYTE *data = (BYTE*)malloc(1000000);
for (DWORD index = 0; ; index++)
{
WCHAR valueName[MAX_VALUE_NAME_LENGTH + 1];
DWORD valueNameLen = _countof(valueName);
DWORD dataType = 0;
DWORD dataSize =1000000;
if (Real_RegEnumValueW(node->m_realKey, index, valueName, &valueNameLen, NULL, &dataType, data, &dataSize) != ERROR_SUCCESS)
break;
auto_ptr<RegValue> newValue = RegValue::Create(RegValueType_Real, valueName, dataType, data, dataSize);
node->m_values.push_back(newValue.release());
}
free(data);
}
}
RegNode* RegTree::OpenKey( const RegPath &path, bool openAlways, LPDWORD disposition )
{
RegNode *root = GetRoot(path.m_rootKey);
if (path.m_segments.empty())
return root;
RegNode *parent = root;
wstring subKey;
BOOST_FOREACH(const wstring &segment, path.m_segments)
{
if (!subKey.empty())
subKey += L"\\";
subKey += segment;
typedef RegNodeList::index<RegNodeIndex::Name>::type Index;
Index &index = parent->m_children.get<RegNodeIndex::Name>();
Index::iterator iter = index.find(to_lower_copy(segment));
if (iter != index.end())
{
parent = *iter;
if (openAlways && parent->m_type == RegNodeType_Real)
{
ClearRealChildren(parent);
parent->m_type = RegNodeType_Normal;
}
}
else
{
HKEY newKey;
if (Real_RegOpenKeyExW(path.m_rootKey, subKey.c_str(), 0, KEY_ALL_ACCESS, &newKey) == ERROR_SUCCESS)
{
RegNode *newNode;
if (openAlways)
newNode = RegNode::CreateNormal(path.m_rootKey, segment, newKey).release();
else
newNode = RegNode::CreateReal(path.m_rootKey, segment, newKey).release();
newNode->m_parent = parent;
parent->m_children.push_back(newNode);
parent = newNode;
if (openAlways && disposition != NULL)
*disposition = REG_OPENED_EXISTING_KEY;
}
else if (openAlways)
{
RegNode *newNode = RegNode::CreateNormal(path.m_rootKey, segment, NULL).release();
newNode->m_parent = parent;
parent->m_children.push_back(newNode);
parent = newNode;
if (disposition != NULL)
*disposition = REG_CREATED_NEW_KEY;
}
else
{
parent = NULL;
break;
}
}
}
return parent;
}
