windows-nt/Source/XPSP1/NT/base/wow64/regremap/wow64reg/cleanup.c

/*++

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"

DWORD
DeleteValueFromSrc (
    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;
}

DWORD
DeleteKey (
    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
}

BOOL
DeleteAll (
    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

BOOL
CleanupTable ()
/*++

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;

}



BOOL
CleanpRegistry ()
/*++

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;

};