|
|
/*++
Copyright (c) 1999-2000 Microsoft Corporation
Module Name:
cleanup.c
Abstract:
This module will cleanup registry with copied entry.
Author:
ATM Shafiqul Khalid (askhalid) 16-Feb-2000
Revision History:
--*/
#include <windows.h>
#include <windef.h>
#include <stdio.h>
#include <stdlib.h>
#include "wow64reg.h"
#include <assert.h>
#include "reflectr.h"
DWORDDeleteValueFromSrc ( HKEY SrcKey )/*++
Routine Description:
Delete Wow6432Value key from the node.
Arguments:
SrcKey - Handle to the src Key.
Return Value:
TRUE if everything under the has been deleted. FALSE otherwise.
--*/
{
DWORD dwIndex =0; DWORD Ret;
HKEY hKey;
WCHAR Node[_MAX_PATH];
//Delete wow6432Value Key
if (RegDeleteValue( SrcKey, (LPCWSTR )WOW6432_VALUE_KEY_NAME) != ERROR_SUCCESS) { //Wow64RegDbgPrint (("\nSorry! couldn't remove wow6432 value key or it doesn't exist"))
}
for (;;) {
DWORD Len = sizeof (Node)/sizeof (WCHAR); Ret = RegEnumKey( SrcKey, dwIndex, Node, Len ); if (Ret != ERROR_SUCCESS) break;
dwIndex++;
Ret = RegOpenKeyEx(SrcKey, Node , 0, KEY_ALL_ACCESS, &hKey); if (Ret != ERROR_SUCCESS) { continue; }
DeleteValueFromSrc (hKey); RegCloseKey (hKey);
} return TRUE;}
DWORDDeleteKey ( HKEY DestKey, WCHAR *pKeyName, DWORD mode )/*++
Routine Description:
Delete key from the destination node if that was a copy from src node.
Arguments:
DestKey - Handle to the dest Key. pKeyName - Key to delete mode - deletion mode. ==> 0 default remove only copy key. ==> 1 remove all key disregarding copy attribute.
Return Value:
TRUE if everything under the has been deleted. FALSE otherwise.
--*/
{
DWORD dwIndex =0; DWORD Ret;
HKEY hKey;
WCHAR Node[_MAX_PATH];
BOOL bDeleteNode = FALSE; BOOL bEmptyNode = TRUE; // hope that it can delete everything
WOW6432_VALUEKEY ValueDest;
Ret = RegOpenKeyEx(DestKey, pKeyName , 0, KEY_ALL_ACCESS, &hKey); if (Ret != ERROR_SUCCESS) { return Ret; }
GetWow6432ValueKey ( hKey, &ValueDest);
if ( ValueDest.ValueType == Copy || mode == 1 ) { //delete all the values
bDeleteNode = TRUE; //don't delete this node
}
// delete all the subkeys enumerate and delete
for (;;) {
DWORD Len = sizeof (Node)/sizeof (Node[0]); Ret = RegEnumKey( hKey, dwIndex, Node, Len ); if (Ret != ERROR_SUCCESS) break;
dwIndex++; if ( !wcscmp (Node, (LPCWSTR )NODE_NAME_32BIT) ) continue;
if (!DeleteKey (hKey, Node, mode )) { bEmptyNode = FALSE; // sorry couldn't delete everything
dwIndex--; //skip the node
}
} RegCloseKey (hKey);
//now delete the dest key.
if (bDeleteNode) { if ( RegDeleteKey ( DestKey, pKeyName) == ERROR_SUCCESS) return ERROR_SUCCESS; }
return -1; //unpredictable error
}
BOOLDeleteAll ( PWCHAR Parent, PWCHAR SubNodeName, DWORD Mode, DWORD option //one means delete discarding wow6432valuekey
)/*++
Routine Description:
Validate node. if node exist skip if doesn't then create the node and then return.
Arguments:
Parent - Name of the parent. SubNodeName - Name of the node under parent that need to be deleted.
Mode - 0 means Subnode is under the parent. 1 means there were wild card and the subnode is under all key under parent.
option - 0 means check wow6432valuekey for copy 1 means delete discarding wow6432valuekey
Return Value:
TRUE if the function succeed. FALSE otherwise.
--*/
{ PWCHAR SplitLoc; DWORD Ret; WCHAR TempIsnNode1[_MAX_PATH]; WCHAR TempIsnNode2[_MAX_PATH];
if (SubNodeName == NULL) {
WCHAR *p ; HKEY hKey;
wcscpy (TempIsnNode1, Parent);
p = &TempIsnNode1[wcslen(TempIsnNode1)];
Wow64RegDbgPrint ( ("\nDeleting Key %S......", TempIsnNode1) );
while ( p != TempIsnNode1 && *p !=L'\\') p--;
if ( p != TempIsnNode1 ) { *p=UNICODE_NULL;
hKey = OpenNode (TempIsnNode1); if ( hKey == NULL ){ Wow64RegDbgPrint ( ("\nSorry! Couldn't open the key [%S]",TempIsnNode1)); return FALSE; }
DeleteKey (hKey, p+1, 1); DeleteValueFromSrc (hKey); RegCloseKey (hKey);
}
return TRUE; //empty node under parent
}
if (SubNodeName[0] == UNICODE_NULL) return TRUE;
if ( Mode == 1) {
HKEY Key = OpenNode (Parent); //
// loop through all the subkey under parent
//
DWORD dwIndex =0; for (;;) {
DWORD Len = sizeof ( TempIsnNode1 )/sizeof (WCHAR);
TempIsnNode1 [0]=UNICODE_NULL; Ret = RegEnumKey( Key, dwIndex, TempIsnNode1, Len ); if (Ret != ERROR_SUCCESS) break;
if (Parent[0] != UNICODE_NULL) {
wcscpy ( TempIsnNode2, Parent); wcscat (TempIsnNode2, (LPCWSTR )L"\\"); wcscat (TempIsnNode2, TempIsnNode1);
} else wcscpy (TempIsnNode2, TempIsnNode1);
DeleteAll (TempIsnNode2, SubNodeName, 0, option);
dwIndex++; } RegCloseKey (Key); return TRUE; } //
// No wild card here
//
if ( ( SplitLoc = wcschr (SubNodeName, L'*') ) == NULL ) { if (Parent[0] != UNICODE_NULL) {
wcscpy ( TempIsnNode2, Parent); wcscat (TempIsnNode2, (LPCWSTR )L"\\"); wcscat (TempIsnNode2, SubNodeName);
} else wcscpy (TempIsnNode2, SubNodeName);
DeleteAll (TempIsnNode2, NULL, 0, option); return TRUE; }
assert ( *(SplitLoc-1) == L'\\'); *(SplitLoc-1) = UNICODE_NULL; SplitLoc++; if (*SplitLoc == L'\\') SplitLoc++;
if (Parent[0] != UNICODE_NULL) { wcscat (Parent, (LPCWSTR )L"\\"); wcscat (Parent, SubNodeName); } else wcscpy (Parent, SubNodeName);
DeleteAll (Parent, SplitLoc, 1, option); //mode 1 means loop within all
return TRUE; //for any wildcard split the string
}
//Cleanup program
BOOLCleanupTable ()/*++
Routine Description:
Cleanup main table containing ISN node list.
Arguments:
None.
Return Value:
TRUE if the table has been removed successfully. FALSE otherwise.
--*/{ HKEY hKey; DWORD Ret;
//
// take action to remove registry entry
//
Ret = RegOpenKeyEx( HKEY_LOCAL_MACHINE, (LPCWSTR ) WOW64_REGISTRY_SETUP_KEY_NAME_REL_PARENT, 0, KEY_ALL_ACCESS, &hKey );
if (Ret == ERROR_SUCCESS ) {
Ret = RegDeleteKey (hKey, (LPCWSTR)WOW64_REGISTRY_ISN_NODE_NAME );
if ( Ret == ERROR_SUCCESS) { Wow64RegDbgPrint ( ("\nSuccessfully removed ISN Table entry ")); }
RegCloseKey (hKey); }
return TRUE;
}
BOOLCleanpRegistry ()/*++
Routine Description:
Cleanup Registry.
Arguments:
None.
Return Value:
TRUE if everything under the has been deleted. FALSE otherwise.
--*/{
extern ISN_NODE_TYPE *RedirectorTable;
DWORD dwIndex; HKEY hKey;
WCHAR TempIsnNode[256]; WCHAR IsnNode[256];
//
// Initialize the table first then delete the table
//
InitializeIsnTable ();
for ( dwIndex=0;dwIndex<wcslen (RedirectorTable[dwIndex].NodeValue);dwIndex++) {
IsnNode[0] = UNICODE_NULL; wcscpy (TempIsnNode , RedirectorTable[dwIndex].NodeValue); wcscat (TempIsnNode , (LPCWSTR )L"\\");
wcscat (TempIsnNode, (LPCWSTR )NODE_NAME_32BIT); Wow64RegDbgPrint ( ("\nDeleting Key %S==>%S", IsnNode, TempIsnNode));
if (wcschr(TempIsnNode, L'*') != NULL ) { //wildcard exist
DeleteAll ( IsnNode, TempIsnNode, 0, 1 ); } else {
hKey = OpenNode (RedirectorTable[dwIndex].NodeValue); if ( hKey == NULL ){ Wow64RegDbgPrint ( ("\nSorry! Couldn't open the key [%S]",RedirectorTable[dwIndex].NodeValue)); continue; }
DeleteKey (hKey, NODE_NAME_32BIT, 1); DeleteValueFromSrc (hKey); RegCloseKey (hKey); } } CleanupTable (); return TRUE;
};
|
