mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2054 lines
51 KiB
2054 lines
51 KiB
/*++
|
|
|
|
Copyright (c) 1998 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
hkcr.c
|
|
|
|
Abstract:
|
|
|
|
Implements routines that merge various HKCR settings. Macro expansion
|
|
list defines a list of merge routines that are called for a particular
|
|
key. A context ID and a set of flags allow control over when a merge
|
|
routine is called.
|
|
|
|
The flag set controls the type of enumeration the merge routine wants
|
|
to be notified with. It can be any of three values:
|
|
|
|
MERGE_FLAG_KEY - Called for the root key itself
|
|
MERGE_FLAG_VALUE - Called for each value in the root key
|
|
MERGE_FLAG_SUBKEY - Called for each subkey in the root key
|
|
|
|
Recursion of MergeRegistryNode is used to copy parts of the tree.
|
|
The context ID is defined in merge.h, and is expandable. It is used
|
|
to specify a context when making recursive calls.
|
|
|
|
The order of processing of the merge routines is specified in the
|
|
macro expansion list. The default behavior if no routine chooses to
|
|
handle a key is to copy without overwrite.
|
|
|
|
Author:
|
|
|
|
Jim Schmidt (jimschm) 24-Mar-1998
|
|
|
|
Revision History:
|
|
|
|
jimschm 23-Sep-1998 Updated for new flag bit size
|
|
jimschm 27-Apr-1998 Added DefaultIcon preservation
|
|
|
|
--*/
|
|
|
|
#include "pch.h"
|
|
#include "mergep.h"
|
|
|
|
extern DWORD g_ProgressBarCounter;
|
|
|
|
#define MERGE_FLAG_KEY 0x0001
|
|
#define MERGE_FLAG_SUBKEY 0x0002
|
|
#define MERGE_FLAG_VALUE 0x0004
|
|
#define MERGE_ALL_FLAGS 0xFFFFFFFF
|
|
|
|
#define MERGE_FLAG_SUBKEYS_AND_VALUES (MERGE_FLAG_SUBKEY|MERGE_FLAG_VALUE)
|
|
#define MERGE_FLAG_ALL (MERGE_FLAG_KEY|MERGE_FLAG_SUBKEY|MERGE_FLAG_VALUE)
|
|
#define MERGE_FLAG_ALL_KEYS (MERGE_FLAG_KEY|MERGE_FLAG_SUBKEY)
|
|
|
|
#define MULTI_CONTEXT ANY_CONTEXT
|
|
|
|
|
|
/*++
|
|
|
|
Macro Expansion List Description:
|
|
|
|
HKCR_FUNCTION_LIST lists functions that are called to process HKCR
|
|
registry data. The functions are called in the order specified by
|
|
the macro expansion list, and when none of the functions process
|
|
the data, the last filter, pLastMergeRoutine, performs a copy-no-
|
|
overwrite merge.
|
|
|
|
Processing occurs in the following stages:
|
|
|
|
1. Functions are called for the key itself
|
|
2. Functions are called for each of the key's values
|
|
3. Functions are called for each of the key's subkeys
|
|
|
|
Line Syntax:
|
|
|
|
DEFMAC(FilterFn, ContextId, Flags)
|
|
|
|
Arguments:
|
|
|
|
FilterFn - Specifies the name of the function. This function is
|
|
automatically prototyped as:
|
|
|
|
MERGE_RESULT
|
|
FilterFn (
|
|
PMERGE_STATE State
|
|
);
|
|
|
|
The filter function uses the State structure to determine
|
|
the context surrounding the registry data (i.e., where is
|
|
it, what its parent is, what kind of data, etc.). The
|
|
function returns one of the following:
|
|
|
|
MERGE_LEAVE - Processing of the current key is terminated.
|
|
MERGE_BREAK - Processing breaks out of the loop. If the
|
|
loop is a value enumeration, then processing
|
|
continues with the values. If the loop is
|
|
a subkey enumeration, processing ends for
|
|
the key.
|
|
MERGE_CONTINUE - Processing continues to the next item in
|
|
the enumeration.
|
|
MERGE_NOP - The function did not process the data
|
|
MERGE_ERROR - An error occurred processing the data. The
|
|
error stops processing of HKCR.
|
|
|
|
ContextId - Specifies the context the function is called in. Specify
|
|
ANY_CONTEXT or MULTI_CONTEXT to always be called. The
|
|
ContextId is specified by the caller of MergeRegistryNode.
|
|
|
|
NOTE: If MULTI_CONTEXT is used, the function must examine
|
|
the ContextId member of State and return MERGE_NOP
|
|
if the context is not correct.
|
|
|
|
Always place ANY_CONTEXT and MULTI_CONTEXT definitions
|
|
at the end of the HKCR_FUNCTION_LIST definition.
|
|
|
|
Flags - Specifies one or more of the following:
|
|
|
|
MERGE_FLAG_KEY - Called for the key, before enumeration
|
|
MERGE_FLAG_SUBKEY - Called for each subkey of the key
|
|
MERGE_FLAG_VALUE - Called for each value of the key
|
|
|
|
or a combined macro:
|
|
|
|
MERGE_FLAG_SUBKEYS_AND_VALUES - Called for each subkey and each value
|
|
MERGE_FLAG_ALL - Called for the key, then each subkey
|
|
and each value
|
|
|
|
Variables Generated From List:
|
|
|
|
g_MergeRoutines
|
|
|
|
--*/
|
|
|
|
|
|
#define HKCR_FUNCTION_LIST \
|
|
DEFMAC(pDetectRootKeyType, ROOT_BASE, MERGE_FLAG_SUBKEY) \
|
|
DEFMAC(pFileExtensionMerge, ROOT_BASE, MERGE_FLAG_SUBKEY) \
|
|
DEFMAC(pCopyClassId, CLSID_BASE, MERGE_FLAG_SUBKEY) \
|
|
DEFMAC(pCopyClassIdWorker, CLSID_COPY, MERGE_FLAG_ALL_KEYS) \
|
|
DEFMAC(pInstanceSpecialCase, CLSID_INSTANCE_COPY, MERGE_FLAG_ALL_KEYS) \
|
|
DEFMAC(pCopyTypeLibOrInterface, MULTI_CONTEXT, MERGE_FLAG_SUBKEY) \
|
|
DEFMAC(pCopyTypeLibVersion, TYPELIB_VERSION_COPY, MERGE_FLAG_SUBKEY) \
|
|
DEFMAC(pDefaultIconExtraction, COPY_DEFAULT_ICON, MERGE_FLAG_ALL) \
|
|
DEFMAC(pCopyDefaultValue, COPY_DEFAULT_VALUE, MERGE_FLAG_KEY) \
|
|
DEFMAC(pKeyCopyMerge, KEY_COPY, MERGE_FLAG_VALUE) \
|
|
\
|
|
DEFMAC(pDetectDefaultIconKey, ANY_CONTEXT, MERGE_FLAG_SUBKEY) \
|
|
DEFMAC(pEnsureShellDefaultValue, TREE_COPY_NO_OVERWRITE, MERGE_FLAG_SUBKEY) \
|
|
DEFMAC(pTreeCopyMerge, MULTI_CONTEXT, MERGE_FLAG_ALL) \
|
|
\
|
|
DEFMAC(pLastMergeRoutine, MULTI_CONTEXT, MERGE_FLAG_SUBKEY)
|
|
|
|
|
|
//
|
|
// Simplification macros
|
|
//
|
|
|
|
#define CopyAllValues(state) MergeValuesOfKey(state,KEY_COPY)
|
|
#define CopyAllSubKeyValues(state) MergeValuesOfSubKey(state,KEY_COPY)
|
|
#define CopyEntireSubKey(state) MergeSubKeyNode(state,TREE_COPY)
|
|
#define CopyEntireSubKeyNoOverwrite(state) MergeSubKeyNode(state,TREE_COPY_NO_OVERWRITE)
|
|
|
|
//
|
|
// Define macro expansion list types
|
|
//
|
|
|
|
typedef struct {
|
|
HKEY Key95;
|
|
HKEY KeyNt;
|
|
HKEY SubKey95;
|
|
HKEY SubKeyNt;
|
|
BOOL CloseKey95;
|
|
BOOL CloseKeyNt;
|
|
PCTSTR SubKeyName;
|
|
PCTSTR FullKeyName;
|
|
PCTSTR FullSubKeyName;
|
|
PCTSTR ValueName;
|
|
PBYTE ValueData;
|
|
DWORD ValueDataSize;
|
|
DWORD ValueDataType;
|
|
MERGE_CONTEXT Context;
|
|
DWORD MergeFlag;
|
|
BOOL LockValue;
|
|
} MERGE_STATE, *PMERGE_STATE;
|
|
|
|
typedef enum {
|
|
MERGE_LEAVE,
|
|
MERGE_BREAK,
|
|
MERGE_CONTINUE,
|
|
MERGE_NOP,
|
|
MERGE_ERROR
|
|
} MERGE_RESULT;
|
|
|
|
typedef MERGE_RESULT (MERGE_ROUTINE_PROTOTYPE) (PMERGE_STATE State);
|
|
typedef MERGE_ROUTINE_PROTOTYPE * MERGE_ROUTINE;
|
|
|
|
typedef struct {
|
|
MERGE_ROUTINE fn;
|
|
MERGE_CONTEXT Context;
|
|
DWORD Flags;
|
|
} MERGE_ROUTINE_ATTRIBS, *PMERGE_ROUTINE_ATTRIBS;
|
|
|
|
//
|
|
// Declare function prototypes
|
|
//
|
|
|
|
#define DEFMAC(fn,id,flags) MERGE_ROUTINE_PROTOTYPE fn;
|
|
|
|
HKCR_FUNCTION_LIST
|
|
|
|
#undef DEFMAC
|
|
|
|
//
|
|
// Create g_MergeRoutines array
|
|
//
|
|
|
|
#define DEFMAC(fn,id,flags) {fn,id,flags},
|
|
|
|
MERGE_ROUTINE_ATTRIBS g_MergeRoutines[] = {
|
|
|
|
HKCR_FUNCTION_LIST /* , */
|
|
{NULL, 0, 0}
|
|
};
|
|
|
|
#undef DEFMAC
|
|
|
|
//
|
|
// Local prototypes
|
|
//
|
|
|
|
MERGE_RESULT
|
|
pCallMergeRoutines (
|
|
IN OUT PMERGE_STATE State,
|
|
IN DWORD MergeFlag
|
|
);
|
|
|
|
BOOL
|
|
pMakeSureNtKeyExists (
|
|
IN PMERGE_STATE State
|
|
);
|
|
|
|
BOOL
|
|
pMakeSureNtSubKeyExists (
|
|
IN PMERGE_STATE State
|
|
);
|
|
|
|
//
|
|
// Globals
|
|
//
|
|
|
|
PBYTE g_MergeBuf;
|
|
UINT g_MergeBufUseCount;
|
|
|
|
|
|
//
|
|
// Implementation
|
|
//
|
|
|
|
BOOL
|
|
MergeRegistryNodeEx (
|
|
IN PCTSTR RootKey,
|
|
IN HKEY RootKey95, OPTIONAL
|
|
IN HKEY RootKeyNt, OPTIONAL
|
|
IN MERGE_CONTEXT Context,
|
|
IN DWORD RestrictionFlags
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
MergeRegistryNode calls functions for the specified RootKey, all of its
|
|
values and all of its subkeys. The merge functions can at runtime decide
|
|
how to process a key, and typically call this function recursively. All
|
|
registry data is passed through the merge data filter, and keys or values
|
|
marked as suppressed are not processed.
|
|
|
|
Arguments:
|
|
|
|
RootKey - Specifies the root key string, starting with either HKLM or HKR.
|
|
|
|
RootKey95 - Specifies the 95-side root key; reduces the number of key open
|
|
calls
|
|
|
|
RootKeyNt - Specifies the NT-side root key; reduces the number of key open
|
|
calls
|
|
|
|
Context - Specifies a root ID constant that corresponds to RootKey. This
|
|
constant is used by the merge routines to determine the
|
|
processing context.
|
|
|
|
RestrictionFlags - Specifies MERGE_FLAG mask to restrict processing. The
|
|
caller can therefore limit the enumerations and processing
|
|
to only values, only subkeys, only the key, or a combination
|
|
of the three.
|
|
|
|
Return Value:
|
|
|
|
TRUE if processing was successful, or FALSE if one of the merge functiosn
|
|
returned an error.
|
|
|
|
--*/
|
|
|
|
{
|
|
REGKEY_ENUM ek;
|
|
REGVALUE_ENUM ev;
|
|
MERGE_STATE State;
|
|
MERGE_RESULT Result = MERGE_NOP;
|
|
|
|
ZeroMemory (&State, sizeof (MERGE_STATE));
|
|
|
|
//
|
|
// Do not process if key is suppressed
|
|
//
|
|
if (Is95RegKeyTreeSuppressed (RootKey)) {
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Init State
|
|
//
|
|
|
|
ZeroMemory (&State, sizeof (State));
|
|
State.Context = Context;
|
|
|
|
//
|
|
// If the NT registry key is suppressed, then we want to do a tree copy, regardless
|
|
// of wether there is an NT value or not.
|
|
//
|
|
if (Context == TREE_COPY_NO_OVERWRITE && IsNtRegKeyTreeSuppressed (RootKey)) {
|
|
|
|
DEBUGMSG ((DBG_VERBOSE, "The NT Value for %s will be overwritten because it is marked for suppression.", RootKey));
|
|
State.Context = TREE_COPY;
|
|
}
|
|
|
|
if (RootKey95) {
|
|
State.Key95 = RootKey95;
|
|
} else {
|
|
State.Key95 = OpenRegKeyStr95 (RootKey);
|
|
State.CloseKey95 = (State.Key95 != NULL);
|
|
}
|
|
|
|
if (!State.Key95) {
|
|
DEBUGMSG ((DBG_VERBOSE, "Root %s does not exist", RootKey));
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Progress bar update
|
|
//
|
|
|
|
g_ProgressBarCounter++;
|
|
if (g_ProgressBarCounter >= REGMERGE_TICK_THRESHOLD) {
|
|
g_ProgressBarCounter = 0;
|
|
TickProgressBar();
|
|
}
|
|
|
|
__try {
|
|
g_MergeBufUseCount++;
|
|
if (g_MergeBufUseCount == MAX_REGISTRY_KEY) {
|
|
DEBUGMSG ((DBG_WHOOPS, "Recursive merge depth indicates a loop problem, aborting!"));
|
|
__leave;
|
|
}
|
|
|
|
if (RootKeyNt) {
|
|
State.KeyNt = RootKeyNt;
|
|
} else {
|
|
State.KeyNt = OpenRegKeyStr (RootKey);
|
|
State.CloseKeyNt = (State.KeyNt != NULL);
|
|
}
|
|
|
|
State.FullKeyName = RootKey;
|
|
|
|
//
|
|
// Key processing
|
|
//
|
|
|
|
if (!Is95RegKeySuppressed (RootKey)) {
|
|
//
|
|
// Loop through the key functions for the root key
|
|
//
|
|
|
|
if (RestrictionFlags & MERGE_FLAG_KEY) {
|
|
Result = pCallMergeRoutines (&State, MERGE_FLAG_KEY);
|
|
|
|
if (Result == MERGE_ERROR || Result == MERGE_LEAVE) {
|
|
__leave;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Loop through the values, skipping those that are suppressed
|
|
//
|
|
|
|
if ((RestrictionFlags & MERGE_FLAG_VALUE) &&
|
|
EnumFirstRegValue95 (&ev, State.Key95)
|
|
) {
|
|
|
|
do {
|
|
if (Is95RegObjectSuppressed (State.FullKeyName, ev.ValueName)) {
|
|
continue;
|
|
}
|
|
|
|
State.ValueName = ev.ValueName;
|
|
State.ValueDataType = ev.Type;
|
|
State.ValueDataSize = ev.DataSize;
|
|
|
|
//
|
|
// Loop through the value functions
|
|
//
|
|
|
|
Result = pCallMergeRoutines (&State, MERGE_FLAG_VALUE);
|
|
|
|
if (Result == MERGE_ERROR ||
|
|
Result == MERGE_LEAVE ||
|
|
Result == MERGE_BREAK
|
|
) {
|
|
break;
|
|
}
|
|
|
|
} while (EnumNextRegValue95 (&ev));
|
|
|
|
if (Result == MERGE_ERROR || Result == MERGE_LEAVE) {
|
|
__leave;
|
|
}
|
|
}
|
|
|
|
State.ValueName = NULL;
|
|
State.ValueDataType = 0;
|
|
State.ValueDataSize = 0;
|
|
}
|
|
|
|
//
|
|
// Subkey processing
|
|
//
|
|
|
|
if ((RestrictionFlags & MERGE_FLAG_SUBKEY) &&
|
|
EnumFirstRegKey95 (&ek, State.Key95)
|
|
) {
|
|
|
|
do {
|
|
//
|
|
// Prepare State, skip key if it is suppressed
|
|
//
|
|
|
|
State.SubKeyName = ek.SubKeyName;
|
|
State.FullSubKeyName = JoinPaths (RootKey, ek.SubKeyName);
|
|
|
|
if (Is95RegKeyTreeSuppressed (State.FullSubKeyName)) {
|
|
FreePathString (State.FullSubKeyName);
|
|
continue;
|
|
}
|
|
|
|
State.SubKey95 = OpenRegKey95 (ek.KeyHandle, ek.SubKeyName);
|
|
if (State.KeyNt) {
|
|
State.SubKeyNt = OpenRegKey (State.KeyNt, ek.SubKeyName);
|
|
} else {
|
|
State.SubKeyNt = NULL;
|
|
}
|
|
|
|
//
|
|
// Loop through the subkey functions
|
|
//
|
|
|
|
Result = pCallMergeRoutines (&State, MERGE_FLAG_SUBKEY);
|
|
|
|
//
|
|
// Clean up
|
|
//
|
|
|
|
FreePathString (State.FullSubKeyName);
|
|
if (State.SubKeyNt) {
|
|
CloseRegKey (State.SubKeyNt);
|
|
}
|
|
if (State.SubKey95) {
|
|
CloseRegKey95 (State.SubKey95);
|
|
}
|
|
|
|
if (Result == MERGE_ERROR ||
|
|
Result == MERGE_LEAVE ||
|
|
Result == MERGE_BREAK
|
|
) {
|
|
break;
|
|
}
|
|
} while (EnumNextRegKey95 (&ek));
|
|
|
|
if (Result == MERGE_ERROR || Result == MERGE_LEAVE) {
|
|
__leave;
|
|
}
|
|
}
|
|
}
|
|
__finally {
|
|
PushError();
|
|
|
|
g_MergeBufUseCount--;
|
|
if (!g_MergeBufUseCount && g_MergeBuf) {
|
|
ReuseFree (g_hHeap, g_MergeBuf);
|
|
g_MergeBuf = NULL;
|
|
}
|
|
|
|
if (State.CloseKey95) {
|
|
CloseRegKey95 (State.Key95);
|
|
}
|
|
|
|
if (State.CloseKeyNt) {
|
|
CloseRegKey (State.KeyNt);
|
|
}
|
|
|
|
PopError();
|
|
}
|
|
|
|
return Result != MERGE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
BOOL
|
|
MergeRegistryNode (
|
|
IN PCTSTR RootKey,
|
|
IN MERGE_CONTEXT Context
|
|
)
|
|
{
|
|
return MergeRegistryNodeEx (RootKey, NULL, NULL, Context, MERGE_ALL_FLAGS);
|
|
}
|
|
|
|
|
|
BOOL
|
|
MergeKeyNode (
|
|
IN PMERGE_STATE State,
|
|
IN MERGE_CONTEXT Context
|
|
)
|
|
{
|
|
return MergeRegistryNodeEx (
|
|
State->FullKeyName,
|
|
State->Key95,
|
|
State->KeyNt,
|
|
Context,
|
|
MERGE_ALL_FLAGS
|
|
);
|
|
}
|
|
|
|
|
|
BOOL
|
|
MergeSubKeyNode (
|
|
IN PMERGE_STATE State,
|
|
IN MERGE_CONTEXT Context
|
|
)
|
|
{
|
|
return MergeRegistryNodeEx (
|
|
State->FullSubKeyName,
|
|
State->SubKey95,
|
|
State->SubKeyNt,
|
|
Context,
|
|
MERGE_ALL_FLAGS
|
|
);
|
|
}
|
|
|
|
|
|
BOOL
|
|
MergeValuesOfKey (
|
|
IN PMERGE_STATE State,
|
|
IN MERGE_CONTEXT Context
|
|
)
|
|
{
|
|
if (!pMakeSureNtKeyExists (State)) {
|
|
DEBUGMSG ((DBG_ERROR, "Can't create %s to merge values", State->FullKeyName));
|
|
return TRUE; // eat error
|
|
}
|
|
|
|
return MergeRegistryNodeEx (
|
|
State->FullKeyName,
|
|
State->Key95,
|
|
State->KeyNt,
|
|
Context,
|
|
MERGE_FLAG_VALUE
|
|
);
|
|
}
|
|
|
|
|
|
BOOL
|
|
MergeValuesOfSubKey (
|
|
IN PMERGE_STATE State,
|
|
IN MERGE_CONTEXT Context
|
|
)
|
|
{
|
|
if (!pMakeSureNtSubKeyExists (State)) {
|
|
DEBUGMSG ((DBG_ERROR, "Can't create %s to merge values", State->FullSubKeyName));
|
|
return TRUE; // eat error
|
|
}
|
|
|
|
return MergeRegistryNodeEx (
|
|
State->FullSubKeyName,
|
|
State->SubKey95,
|
|
State->SubKeyNt,
|
|
Context,
|
|
MERGE_FLAG_VALUE
|
|
);
|
|
}
|
|
|
|
|
|
MERGE_RESULT
|
|
pCallMergeRoutines (
|
|
IN OUT PMERGE_STATE State,
|
|
IN DWORD MergeFlag
|
|
)
|
|
{
|
|
INT i;
|
|
MERGE_RESULT Result = MERGE_NOP;
|
|
|
|
State->MergeFlag = MergeFlag;
|
|
|
|
for (i = 0 ; g_MergeRoutines[i].fn ; i++) {
|
|
if (g_MergeRoutines[i].Context != State->Context &&
|
|
g_MergeRoutines[i].Context != ANY_CONTEXT
|
|
) {
|
|
continue;
|
|
}
|
|
|
|
if (g_MergeRoutines[i].Flags & MergeFlag) {
|
|
Result = g_MergeRoutines[i].fn (State);
|
|
if (Result != MERGE_NOP) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pFillStateWithValue (
|
|
IN OUT PMERGE_STATE State
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pFillStateWithValue queries the Win95 registry for the value specified in
|
|
the inbound State struct. Upon return, the ValueData member of State is
|
|
set to the global buffer g_MergeBuf. The value is passed through the merge
|
|
data filter in datafilt.c.
|
|
|
|
The caller must make a copy of the data if two or more values are to be
|
|
processed at the same time.
|
|
|
|
Arguments:
|
|
|
|
State - Specifies the registry key name and value, along with a key handle.
|
|
Receives the value data.
|
|
|
|
Return Value:
|
|
|
|
TRUE if the value was read, or FALSE if an error occurred.
|
|
|
|
--*/
|
|
|
|
{
|
|
LONG rc;
|
|
DWORD Size;
|
|
|
|
if (!State->ValueName) {
|
|
DEBUGMSG ((DBG_WHOOPS, "pFillStateWithValue: No value name"));
|
|
return FALSE;
|
|
}
|
|
|
|
if (State->LockValue) {
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Do not process if value is suppressed
|
|
//
|
|
|
|
if (Is95RegObjectSuppressed (State->FullKeyName, State->ValueName)) {
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Get data from registry
|
|
//
|
|
|
|
rc = Win95RegQueryValueEx (
|
|
State->Key95,
|
|
State->ValueName,
|
|
NULL,
|
|
&State->ValueDataType,
|
|
NULL,
|
|
&State->ValueDataSize
|
|
);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
SetLastError (rc);
|
|
LOG ((
|
|
LOG_ERROR,
|
|
"Win95Reg query size of %s [%s] failed",
|
|
State->FullKeyName,
|
|
State->ValueName
|
|
));
|
|
return FALSE;
|
|
}
|
|
|
|
Size = State->ValueDataSize;
|
|
g_MergeBuf = (PBYTE) ReuseAlloc (g_hHeap, g_MergeBuf, Size);
|
|
if (!g_MergeBuf) {
|
|
DEBUGMSG ((DBG_ERROR, "pFillStateWithValue: ReuseAlloc returned NULL"));
|
|
return FALSE;
|
|
}
|
|
|
|
rc = Win95RegQueryValueEx (
|
|
State->Key95,
|
|
State->ValueName,
|
|
NULL,
|
|
NULL,
|
|
g_MergeBuf,
|
|
&Size
|
|
);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
SetLastError (rc);
|
|
LOG ((
|
|
LOG_ERROR,
|
|
"Win95Reg query for %s [%s] failed",
|
|
State->FullKeyName,
|
|
State->ValueName
|
|
));
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Convert data if necessary; g_MergeBuf is a ReUse buffer, so it's
|
|
// address may change upon return.
|
|
//
|
|
|
|
State->ValueData = FilterRegValue (
|
|
g_MergeBuf,
|
|
Size,
|
|
State->ValueDataType,
|
|
State->FullKeyName,
|
|
&State->ValueDataSize
|
|
);
|
|
|
|
if (State->ValueData) {
|
|
if (g_MergeBuf != State->ValueData) {
|
|
g_MergeBuf = State->ValueData;
|
|
}
|
|
}
|
|
|
|
return State->ValueData != NULL;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pMakeSureNtKeyExists (
|
|
IN PMERGE_STATE State
|
|
)
|
|
{
|
|
if (!State->KeyNt) {
|
|
State->KeyNt = CreateRegKeyStr (State->FullKeyName);
|
|
State->CloseKeyNt = (State->KeyNt != NULL);
|
|
}
|
|
|
|
return State->KeyNt != NULL;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pMakeSureNtSubKeyExists (
|
|
IN PMERGE_STATE State
|
|
)
|
|
{
|
|
if (!State->SubKeyNt) {
|
|
State->SubKeyNt = CreateRegKeyStr (State->FullSubKeyName);
|
|
}
|
|
|
|
return State->SubKeyNt != NULL;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pCopy95ValueToNt (
|
|
IN OUT PMERGE_STATE State
|
|
)
|
|
{
|
|
LONG rc = ERROR_SUCCESS;
|
|
|
|
if (pFillStateWithValue (State)) {
|
|
|
|
pMakeSureNtKeyExists (State);
|
|
|
|
rc = RegSetValueEx (
|
|
State->KeyNt,
|
|
State->ValueName,
|
|
0,
|
|
State->ValueDataType,
|
|
State->ValueData,
|
|
State->ValueDataSize
|
|
);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
SetLastError (rc);
|
|
LOG ((
|
|
LOG_ERROR,
|
|
"Copy Win9x Value To Nt failed to set %s [%s]",
|
|
State->FullKeyName,
|
|
State->ValueName
|
|
));
|
|
}
|
|
}
|
|
|
|
return rc = ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
MERGE_RESULT
|
|
pFileExtensionMerge (
|
|
IN PMERGE_STATE State
|
|
)
|
|
{
|
|
BOOL CloseNTKey = FALSE;
|
|
BOOL Close95Key = FALSE;
|
|
PCTSTR Value9x, ValueNt;
|
|
TCHAR key [MEMDB_MAX];
|
|
DWORD value;
|
|
|
|
MYASSERT (State->FullKeyName);
|
|
MYASSERT (State->FullSubKeyName);
|
|
MYASSERT (State->SubKeyName);
|
|
MYASSERT (State->SubKey95);
|
|
MYASSERT (State->MergeFlag == MERGE_FLAG_SUBKEY);
|
|
MYASSERT (State->Context == ROOT_BASE);
|
|
|
|
//
|
|
// Sub key name must have a dot
|
|
//
|
|
|
|
if (_tcsnextc (State->SubKeyName) != TEXT('.')) {
|
|
return MERGE_NOP;
|
|
}
|
|
|
|
//
|
|
// We look now to see if NT comes with this file extension.
|
|
// If it does and the progID referenced by 9x file extension has
|
|
// a loss of default command functionality, we let NT overwrite
|
|
// the ProgId reference. We do this by suppressing the default
|
|
// value of this file extension.
|
|
//
|
|
if (!State->SubKey95) {
|
|
State->SubKey95 = OpenRegKeyStr95 (State->FullSubKeyName);
|
|
Close95Key = (State->SubKey95 != NULL);
|
|
}
|
|
if (!State->SubKeyNt) {
|
|
State->SubKeyNt = OpenRegKeyStr (State->FullSubKeyName);
|
|
CloseNTKey = (State->SubKeyNt != NULL);
|
|
}
|
|
if (State->SubKey95 && State->SubKeyNt) {
|
|
//
|
|
// Let's see if we the NT default value is different than 9x one.
|
|
//
|
|
Value9x = GetRegValueString95 (State->SubKey95, TEXT(""));
|
|
ValueNt = GetRegValueString (State->SubKeyNt, TEXT(""));
|
|
|
|
if ((ValueNt && !Value9x) ||
|
|
(!ValueNt && Value9x) ||
|
|
(ValueNt && Value9x && (!StringIMatch (Value9x, ValueNt)))
|
|
) {
|
|
MemDbBuildKey (key, MEMDB_CATEGORY_PROGIDS, Value9x?Value9x:State->SubKeyName, NULL, NULL);
|
|
if (MemDbGetValue (key, &value) &&
|
|
(value == PROGID_LOSTDEFAULT)
|
|
) {
|
|
//
|
|
// Now it's the time to suppress the default value for this file extension
|
|
//
|
|
MemDbBuildKey (key, MEMDB_CATEGORY_HKLM, TEXT("SOFTWARE\\Classes"), State->SubKeyName, NULL);
|
|
if (!Suppress95RegSetting(key, TEXT(""))) {
|
|
DEBUGMSG((DBG_WARNING,"Could not suppress %s\\[] registry setting.", key));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Value9x) {
|
|
MemFree (g_hHeap, 0, Value9x);
|
|
Value9x = NULL;
|
|
}
|
|
|
|
if (ValueNt) {
|
|
MemFree (g_hHeap, 0, ValueNt);
|
|
ValueNt = NULL;
|
|
}
|
|
}
|
|
if (Close95Key) {
|
|
CloseRegKey95 (State->SubKey95);
|
|
State->SubKey95 = NULL;
|
|
}
|
|
if (CloseNTKey) {
|
|
CloseRegKey (State->SubKeyNt);
|
|
State->SubKeyNt = NULL;
|
|
}
|
|
|
|
//
|
|
// We copy all the extensions blindly
|
|
//
|
|
|
|
if (!CopyEntireSubKey (State)) {
|
|
return MERGE_ERROR;
|
|
}
|
|
|
|
//
|
|
// Return MERGE_CONTINUE so processing continues to next subkey
|
|
//
|
|
|
|
return MERGE_CONTINUE;
|
|
}
|
|
|
|
|
|
MERGE_RESULT
|
|
pDetectDefaultIconKey (
|
|
IN PMERGE_STATE State
|
|
)
|
|
{
|
|
MYASSERT (State->FullKeyName);
|
|
MYASSERT (State->FullSubKeyName);
|
|
MYASSERT (State->SubKeyName);
|
|
MYASSERT (State->SubKey95);
|
|
MYASSERT (State->MergeFlag == MERGE_FLAG_SUBKEY);
|
|
|
|
if (StringIMatch (State->SubKeyName, TEXT("DefaultIcon"))) {
|
|
if (!MergeSubKeyNode (State, COPY_DEFAULT_ICON)) {
|
|
return MERGE_ERROR;
|
|
}
|
|
|
|
return MERGE_CONTINUE;
|
|
}
|
|
|
|
return MERGE_NOP;
|
|
}
|
|
|
|
|
|
MERGE_RESULT
|
|
pEnsureShellDefaultValue (
|
|
IN PMERGE_STATE State
|
|
)
|
|
{
|
|
|
|
PTSTR dataNt = NULL;
|
|
PTSTR data9x = NULL;
|
|
PTSTR p = NULL;
|
|
|
|
MYASSERT (State->FullKeyName);
|
|
MYASSERT (State->MergeFlag == MERGE_FLAG_SUBKEY);
|
|
|
|
|
|
|
|
|
|
if (StringIMatch (State->SubKeyName, TEXT("Shell"))) {
|
|
|
|
//
|
|
// Get default values for both sides. We'll need this
|
|
// to determine wether to do the merge or not.
|
|
//
|
|
pMakeSureNtSubKeyExists (State);
|
|
|
|
data9x = (PTSTR) GetRegValueData95 (State->SubKey95, S_EMPTY);
|
|
dataNt = (PTSTR) GetRegValueData (State->SubKeyNt, S_EMPTY);
|
|
|
|
__try {
|
|
|
|
if (data9x && *data9x && (!dataNt || !*dataNt)) {
|
|
|
|
//
|
|
// If we get here, we know there is some value set
|
|
// in the win9x registry and no value set in the
|
|
// nt registry.
|
|
//
|
|
p = JoinPaths (State->FullSubKeyName, data9x);
|
|
if (!Is95RegKeyTreeSuppressed (p)) {
|
|
|
|
if (!MergeSubKeyNode (State, COPY_DEFAULT_VALUE)) {
|
|
return MERGE_ERROR;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
} __finally {
|
|
|
|
if (p) {
|
|
FreePathString (p);
|
|
}
|
|
|
|
if (dataNt) {
|
|
MemFree (g_hHeap, 0, dataNt);
|
|
}
|
|
|
|
if (data9x) {
|
|
MemFree (g_hHeap, 0, data9x);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return MERGE_NOP;
|
|
}
|
|
|
|
|
|
MERGE_RESULT
|
|
pDefaultIconExtraction (
|
|
IN PMERGE_STATE State
|
|
)
|
|
{
|
|
PCTSTR Data;
|
|
TCHAR iconCmdLine[MAX_CMDLINE];
|
|
PCTSTR LongPath = NULL;
|
|
PCTSTR p;
|
|
INT IconIndex;
|
|
TCHAR IconIndexStr[32];
|
|
TCHAR Node[MEMDB_MAX];
|
|
DWORD Offset;
|
|
DWORD Seq;
|
|
LONG rc;
|
|
BOOL Copied = FALSE;
|
|
PCTSTR updatedPath;
|
|
INT newSeq;
|
|
|
|
MYASSERT (State->Context == COPY_DEFAULT_ICON);
|
|
|
|
if (State->MergeFlag == MERGE_FLAG_KEY) {
|
|
return MERGE_BREAK;
|
|
}
|
|
|
|
if (State->MergeFlag == MERGE_FLAG_SUBKEY) {
|
|
//
|
|
// Copy subkey (which is garbage)
|
|
//
|
|
|
|
if (!CopyEntireSubKey (State)) {
|
|
return MERGE_ERROR;
|
|
}
|
|
|
|
return MERGE_CONTINUE;
|
|
}
|
|
|
|
//
|
|
// Get the default command line
|
|
//
|
|
|
|
if (State->ValueDataSize > MAX_CMDLINE - sizeof (TCHAR)) {
|
|
LOG ((LOG_ERROR, "Data too large in %s [%s]", State->FullKeyName, State->ValueName));
|
|
return MERGE_CONTINUE;
|
|
}
|
|
|
|
Data = (PCTSTR) GetRegValueString95 (State->Key95, State->ValueName);
|
|
|
|
if (Data) {
|
|
//
|
|
// Determine if command line has saved icon
|
|
//
|
|
|
|
ExtractArgZeroEx (Data, iconCmdLine, TEXT(","), TRUE);
|
|
p = (PCTSTR) ((PBYTE) Data + ByteCount (iconCmdLine));
|
|
while (*p == TEXT(' ')) {
|
|
p++;
|
|
}
|
|
|
|
if (*p == TEXT(',')) {
|
|
IconIndex = _ttoi (_tcsinc (p));
|
|
|
|
LongPath = GetSourceFileLongName (iconCmdLine);
|
|
|
|
wsprintf (IconIndexStr, TEXT("%i"), IconIndex);
|
|
|
|
//
|
|
// Test for a moved icon. If there is a moved icon, use it,
|
|
// otherwise test for an extracted icon. If there is an
|
|
// extracted icon, use it. Otherwise, leave DefaultIcon alone.
|
|
//
|
|
|
|
iconCmdLine[0] = 0;
|
|
|
|
MemDbBuildKey (Node, MEMDB_CATEGORY_ICONS_MOVED, LongPath, IconIndexStr, NULL);
|
|
|
|
if (MemDbGetValueAndFlags (Node, &Offset, &Seq)) {
|
|
//
|
|
// icon moved to a new binary
|
|
//
|
|
|
|
if (IconIndex < 0) {
|
|
newSeq = -((INT) Seq);
|
|
} else {
|
|
newSeq = (INT) Seq;
|
|
}
|
|
|
|
MemDbBuildKeyFromOffset (Offset, Node, 1, NULL);
|
|
updatedPath = GetPathStringOnNt (Node);
|
|
wsprintf (iconCmdLine, TEXT("%s,%i"), updatedPath, newSeq);
|
|
FreePathString (updatedPath);
|
|
|
|
} else {
|
|
|
|
Offset = INVALID_OFFSET;
|
|
|
|
MemDbBuildKey (Node, MEMDB_CATEGORY_ICONS, LongPath, IconIndexStr, NULL);
|
|
if (MemDbGetValueAndFlags (Node, NULL, &Seq)) {
|
|
//
|
|
// icon was extracted
|
|
//
|
|
|
|
wsprintf (iconCmdLine, TEXT("%s,%i"), g_IconBin, Seq);
|
|
}
|
|
}
|
|
|
|
if (iconCmdLine[0]) {
|
|
//
|
|
// DefaultIcon has changed; write change now (full REG_SZ
|
|
// value is in iconCmdLine)
|
|
//
|
|
|
|
if (!pMakeSureNtKeyExists (State)) {
|
|
LOG ((
|
|
LOG_ERROR,
|
|
"Unable to open %s",
|
|
State->FullKeyName
|
|
));
|
|
} else {
|
|
|
|
rc = RegSetValueEx (
|
|
State->KeyNt,
|
|
State->ValueName,
|
|
0,
|
|
REG_SZ,
|
|
(PBYTE) iconCmdLine,
|
|
SizeOfString (iconCmdLine)
|
|
);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
SetLastError (rc);
|
|
LOG ((
|
|
LOG_ERROR,
|
|
"Default Icon Extraction failed to set path for %s",
|
|
State->FullKeyName
|
|
));
|
|
} else {
|
|
Copied = TRUE;
|
|
|
|
DEBUGMSG_IF ((
|
|
Offset == INVALID_OFFSET,
|
|
DBG_VERBOSE,
|
|
"DefaultIcon preserved for %s [%s]",
|
|
State->FullKeyName,
|
|
State->ValueName
|
|
));
|
|
|
|
DEBUGMSG_IF ((
|
|
Offset != INVALID_OFFSET,
|
|
DBG_VERBOSE,
|
|
"DefaultIcon moved to new OS icon for %s [%s]",
|
|
State->FullKeyName,
|
|
State->ValueName
|
|
));
|
|
}
|
|
}
|
|
}
|
|
|
|
FreePathString (LongPath);
|
|
}
|
|
|
|
MemFree (g_hHeap, 0, Data);
|
|
}
|
|
|
|
if (!Copied) {
|
|
pCopy95ValueToNt (State);
|
|
}
|
|
|
|
return MERGE_CONTINUE;
|
|
}
|
|
|
|
|
|
MERGE_RESULT
|
|
pTreeCopyMerge (
|
|
IN PMERGE_STATE State
|
|
)
|
|
{
|
|
REGVALUE_ENUM ev;
|
|
|
|
if (State->Context != TREE_COPY && State->Context != TREE_COPY_NO_OVERWRITE) {
|
|
return MERGE_NOP;
|
|
}
|
|
|
|
switch (State->MergeFlag) {
|
|
|
|
case MERGE_FLAG_KEY:
|
|
if (State->Context == TREE_COPY) {
|
|
if (!pMakeSureNtKeyExists (State)) {
|
|
LOG ((
|
|
LOG_ERROR,
|
|
"Unable to create %s",
|
|
State->FullKeyName
|
|
));
|
|
}
|
|
} else {
|
|
//
|
|
// If no values in Win9x key, then it is OK to create the
|
|
// value-less key now. Otherwise, wait until MERGE_FLAG_VALUE
|
|
// processing.
|
|
//
|
|
|
|
if (!EnumFirstRegValue95 (&ev, State->Key95)) {
|
|
if (!pMakeSureNtKeyExists (State)) {
|
|
LOG ((
|
|
LOG_ERROR,
|
|
"Unable to create %s",
|
|
State->FullKeyName
|
|
));
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case MERGE_FLAG_VALUE:
|
|
//
|
|
// Copy values unconditionally, unless no overwrite is specified and
|
|
// NT key exists.
|
|
//
|
|
|
|
if (State->Context == TREE_COPY_NO_OVERWRITE && State->KeyNt) {
|
|
return MERGE_BREAK;
|
|
}
|
|
|
|
if (!MergeKeyNode (State, KEY_COPY)) {
|
|
return MERGE_ERROR;
|
|
}
|
|
|
|
return MERGE_BREAK; // MERGE_BREAK breaks out of value enumeration and enters
|
|
// subkey enumeration
|
|
|
|
case MERGE_FLAG_SUBKEY:
|
|
//
|
|
// Continue copy recursively
|
|
//
|
|
|
|
if (!MergeSubKeyNode (State, State->Context)) {
|
|
return MERGE_ERROR;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return MERGE_CONTINUE;
|
|
}
|
|
|
|
|
|
MERGE_RESULT
|
|
pKeyCopyMerge (
|
|
IN OUT PMERGE_STATE State
|
|
)
|
|
{
|
|
MYASSERT (State->FullKeyName);
|
|
MYASSERT (!State->FullSubKeyName);
|
|
MYASSERT (!State->SubKeyName);
|
|
MYASSERT (!State->SubKey95);
|
|
MYASSERT (State->ValueName);
|
|
MYASSERT (State->MergeFlag == MERGE_FLAG_VALUE);
|
|
MYASSERT (State->Context == KEY_COPY);
|
|
|
|
pCopy95ValueToNt (State);
|
|
return MERGE_CONTINUE;
|
|
}
|
|
|
|
|
|
MERGE_RESULT
|
|
pCopyDefaultValue (
|
|
IN PMERGE_STATE State
|
|
)
|
|
{
|
|
PCSTR value1;
|
|
PCSTR value2;
|
|
PCWSTR value3;
|
|
|
|
MYASSERT (State->FullKeyName);
|
|
MYASSERT (!State->FullSubKeyName);
|
|
MYASSERT (!State->SubKeyName);
|
|
MYASSERT (!State->SubKey95);
|
|
MYASSERT (!State->ValueName);
|
|
MYASSERT (State->MergeFlag == MERGE_FLAG_KEY);
|
|
MYASSERT (State->Context == COPY_DEFAULT_VALUE);
|
|
|
|
State->ValueName = S_EMPTY;
|
|
|
|
#ifdef DEBUG
|
|
//
|
|
// Obtain NT value, if it exists, then compare against Win9x value. If
|
|
// different, dump debug output.
|
|
//
|
|
|
|
{
|
|
PBYTE Data95, DataNt;
|
|
|
|
Data95 = GetRegValueData95 (State->Key95, S_EMPTY);
|
|
DataNt = GetRegValueData (State->KeyNt, S_EMPTY);
|
|
|
|
if (Data95 && DataNt) {
|
|
__try {
|
|
if (memcmp (Data95, DataNt, ByteCount ((PTSTR) Data95))) {
|
|
DEBUGMSG ((
|
|
DBG_VERBOSE,
|
|
"Default value of %s changed from %s to %s",
|
|
State->FullKeyName,
|
|
DataNt,
|
|
Data95
|
|
));
|
|
}
|
|
}
|
|
__except (1) {
|
|
}
|
|
}
|
|
|
|
if (Data95) {
|
|
MemFree (g_hHeap, 0, Data95);
|
|
}
|
|
|
|
if (DataNt) {
|
|
MemFree (g_hHeap, 0, DataNt);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
//
|
|
// now let's get the value and convert it if necessary
|
|
//
|
|
|
|
if (pFillStateWithValue (State)) {
|
|
|
|
if ((OurGetACP() == 932) &&
|
|
((State->ValueDataType == REG_SZ) ||
|
|
(State->ValueDataType == REG_EXPAND_SZ)
|
|
)) {
|
|
//
|
|
// apply the Katakana filter
|
|
//
|
|
value1 = ConvertWtoA ((PCWSTR) State->ValueData);
|
|
value2 = ConvertSBtoDB (NULL, value1, NULL);
|
|
value3 = ConvertAtoW (value2);
|
|
g_MergeBuf = (PBYTE) ReuseAlloc (g_hHeap, g_MergeBuf, SizeOfStringW (value3));
|
|
StringCopyW ((PWSTR)g_MergeBuf, value3);
|
|
State->ValueData = g_MergeBuf;
|
|
FreeConvertedStr (value3);
|
|
FreePathStringA (value2);
|
|
FreeConvertedStr (value1);
|
|
}
|
|
|
|
State->LockValue = TRUE;
|
|
pCopy95ValueToNt (State);
|
|
State->LockValue = FALSE;
|
|
}
|
|
|
|
State->ValueName = NULL;
|
|
return MERGE_LEAVE;
|
|
}
|
|
|
|
|
|
MERGE_RESULT
|
|
pDetectRootKeyType (
|
|
IN PMERGE_STATE State
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pDetectRootKeyType identifies CLSID in the root of HKCR, and when found, the CLSID
|
|
subkey is processed with the CLSID_BASE context.
|
|
|
|
Arguments:
|
|
|
|
State - Specifies the enumeration state.
|
|
|
|
Return Value:
|
|
|
|
MERGE_ERROR - An error occurred
|
|
MERGE_CONTINUE - The subkey was processed
|
|
MERGE_NOP - The subkey was not processed
|
|
|
|
--*/
|
|
|
|
{
|
|
MYASSERT (State->FullKeyName);
|
|
MYASSERT (State->FullSubKeyName);
|
|
MYASSERT (State->SubKeyName);
|
|
MYASSERT (State->SubKey95);
|
|
MYASSERT (State->MergeFlag == MERGE_FLAG_SUBKEY);
|
|
MYASSERT (State->Context == ROOT_BASE);
|
|
|
|
if (StringIMatch (State->SubKeyName, TEXT("CLSID"))) {
|
|
|
|
//
|
|
// This is the CLSID key; copy with CLSID_BASE
|
|
//
|
|
|
|
if (!MergeSubKeyNode (State, CLSID_BASE)) {
|
|
return MERGE_ERROR;
|
|
}
|
|
|
|
//
|
|
// Copy the values (usually there are none)
|
|
//
|
|
|
|
if (!MergeRegistryNodeEx (
|
|
State->FullKeyName,
|
|
State->Key95,
|
|
State->KeyNt,
|
|
KEY_COPY,
|
|
MERGE_FLAG_VALUE
|
|
)) {
|
|
return MERGE_ERROR;
|
|
}
|
|
|
|
return MERGE_CONTINUE;
|
|
|
|
} else if (StringIMatch (State->SubKeyName, TEXT("TYPELIB"))) {
|
|
|
|
//
|
|
// Copy the TypeLib subkey (its values and all of its subkeys)
|
|
//
|
|
|
|
if (!MergeSubKeyNode (State, TYPELIB_BASE) ||
|
|
!CopyAllSubKeyValues (State)
|
|
) {
|
|
|
|
return MERGE_ERROR;
|
|
|
|
}
|
|
|
|
return MERGE_CONTINUE;
|
|
|
|
} else if (StringIMatch (State->SubKeyName, TEXT("Interface"))) {
|
|
|
|
//
|
|
// Copy the Interface, then copy the values (usually none)
|
|
//
|
|
|
|
if (!MergeSubKeyNode (State, INTERFACE_BASE)) {
|
|
return MERGE_ERROR;
|
|
}
|
|
|
|
if (!CopyAllSubKeyValues (State)) {
|
|
return MERGE_ERROR;
|
|
}
|
|
|
|
return MERGE_CONTINUE;
|
|
|
|
}
|
|
|
|
return MERGE_NOP;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pIsNtClsIdOverwritable (
|
|
IN HKEY Key
|
|
)
|
|
{
|
|
REGKEY_ENUM e;
|
|
BOOL Overwritable = TRUE;
|
|
HKEY InstanceSubKey;
|
|
|
|
//
|
|
// Enumerate the subkeys. If there is a subkey that has a binary
|
|
// implementation, then do not overwrite the key.
|
|
//
|
|
|
|
if (!Key) {
|
|
return TRUE;
|
|
}
|
|
|
|
if (EnumFirstRegKey (&e, Key)) {
|
|
do {
|
|
|
|
if (StringIMatchCharCount (e.SubKeyName, TEXT("Inproc"), 6) ||
|
|
StringIMatch (e.SubKeyName, TEXT("LocalServer")) ||
|
|
StringIMatch (e.SubKeyName, TEXT("LocalServer32")) ||
|
|
StringIMatch (e.SubKeyName, TEXT("ProxyStubClsid32"))
|
|
) {
|
|
|
|
Overwritable = FALSE;
|
|
break;
|
|
|
|
}
|
|
|
|
if (StringIMatch (e.SubKeyName, TEXT("Instance"))) {
|
|
break;
|
|
}
|
|
|
|
} while (EnumNextRegKey (&e));
|
|
}
|
|
|
|
if (!Overwritable) {
|
|
//
|
|
// if we think a key is not overwritable, we have
|
|
// to test for a subkey Instance. If it exists, then we
|
|
// consider the key overwritable. This is for ActiveMovie,
|
|
// and unfortunately it has the potential of breaking anyone
|
|
// in NT who puts an Instance key in their CLSID. Since
|
|
// ActiveMovie plug-ins use this key, we're stuck.
|
|
//
|
|
// Fortunately, nobody in NT does this currently.
|
|
//
|
|
|
|
InstanceSubKey = OpenRegKey (Key, TEXT("Instance"));
|
|
if (InstanceSubKey) {
|
|
CloseRegKey (InstanceSubKey);
|
|
Overwritable = TRUE;
|
|
}
|
|
|
|
return Overwritable;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
MERGE_RESULT
|
|
pCopyClassId (
|
|
IN PMERGE_STATE State
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pCopyClassId performs a copy of an HKCR\CLSID\* key. It copies the entire
|
|
key to NT if NT does not provide an equivalent setting. In all cases, the
|
|
friendly name is copied to NT, because it may have been modified on Win9x.
|
|
However, we don't copy the default value when we are talking about a suppressed
|
|
GUID and NT does not install this GUID.
|
|
|
|
This function is called for all subkeys of CLSID. The subkey name is either
|
|
a GUID or garbage.
|
|
|
|
Arguments:
|
|
|
|
State - Specifies the enumeration state, which is always a subkey of
|
|
HKCR\CLSID in this case.
|
|
|
|
Return Value:
|
|
|
|
MERGE_CONTINUE - Key was processed
|
|
MERGE_ERROR - An error occurred
|
|
|
|
--*/
|
|
|
|
{
|
|
TCHAR Node[MEMDB_MAX];
|
|
TCHAR DefaultIconKey[MAX_REGISTRY_KEY];
|
|
HKEY DefaultIcon95;
|
|
BOOL Copied = FALSE;
|
|
PTSTR defaultValue = NULL;
|
|
|
|
MYASSERT (State->FullKeyName);
|
|
MYASSERT (State->FullSubKeyName);
|
|
MYASSERT (State->SubKeyName);
|
|
MYASSERT (State->SubKey95);
|
|
MYASSERT (State->MergeFlag == MERGE_FLAG_SUBKEY);
|
|
MYASSERT (State->Context == CLSID_BASE);
|
|
|
|
//
|
|
// Skip if the GUID is suppressed
|
|
//
|
|
MemDbBuildKey (Node, MEMDB_CATEGORY_GUIDS, State->SubKeyName, NULL, NULL);
|
|
if (!MemDbGetValue (Node, NULL)) {
|
|
//
|
|
// Copy entire Win9x setting if GUID does not exist on NT.
|
|
// If GUID exists on NT, do not touch it.
|
|
//
|
|
|
|
if (pIsNtClsIdOverwritable (State->SubKeyNt)) {
|
|
|
|
Copied = TRUE;
|
|
|
|
if (!pMakeSureNtSubKeyExists (State)) {
|
|
|
|
LOG ((LOG_ERROR, "Can't create %s", State->FullSubKeyName));
|
|
|
|
} else {
|
|
|
|
//
|
|
// Copy the specific CLSID key from 95 to NT
|
|
//
|
|
|
|
if (!MergeSubKeyNode (State, CLSID_COPY)) {
|
|
return MERGE_ERROR;
|
|
}
|
|
}
|
|
}
|
|
ELSE_DEBUGMSG ((DBG_VERBOSE, "CLSID %s is not overwritable", State->SubKeyName));
|
|
|
|
}
|
|
if (!Copied) {
|
|
|
|
if (State->SubKeyNt) {
|
|
|
|
|
|
defaultValue = (PTSTR) GetRegValueData95 (State->SubKey95, S_EMPTY);
|
|
if (defaultValue && *defaultValue) {
|
|
//
|
|
// If ClsId is suppressed but NT installs the GUID, we want to copy
|
|
// the default value and the default icon for GUID.
|
|
//
|
|
// (This is the class friendly name.)
|
|
//
|
|
|
|
if (!MergeRegistryNodeEx (
|
|
State->FullSubKeyName,
|
|
State->SubKey95,
|
|
State->SubKeyNt,
|
|
COPY_DEFAULT_VALUE,
|
|
MERGE_FLAG_KEY
|
|
)) {
|
|
return MERGE_ERROR;
|
|
}
|
|
}
|
|
|
|
if (defaultValue) {
|
|
|
|
MemFree (g_hHeap, 0, defaultValue);
|
|
|
|
}
|
|
|
|
StringCopy (DefaultIconKey, State->FullSubKeyName);
|
|
StringCopy (AppendWack (DefaultIconKey), TEXT("DefaultIcon"));
|
|
|
|
DefaultIcon95 = OpenRegKeyStr95 (DefaultIconKey);
|
|
if (DefaultIcon95) {
|
|
CloseRegKey95 (DefaultIcon95);
|
|
|
|
if (!MergeRegistryNode (DefaultIconKey, COPY_DEFAULT_ICON)) {
|
|
return MERGE_ERROR;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return MERGE_CONTINUE;
|
|
}
|
|
|
|
|
|
MERGE_RESULT
|
|
pCopyClassIdWorker (
|
|
IN PMERGE_STATE State
|
|
)
|
|
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pCopyClassIdWorker handles one CLSID entry. It processses all the values
|
|
of the entry, and all subkeys. This routine looks for the special cases of
|
|
CLSID. If none are found, the entire key is copied (unless NT provides the
|
|
key). If a special case is found, the root is changed for the special
|
|
case.
|
|
|
|
The key is HKCR\CLSID\<guid>.
|
|
The subkey is HKCR\CLSID\<guid>\<subkey>
|
|
|
|
We have already determined that <guid> is not suppressed.
|
|
|
|
Arguments:
|
|
|
|
State - Specifies the enumeration state, which is the subkey of HKCR\CLSID,
|
|
or the subkey of HKCR\CLSID\<guid>.
|
|
|
|
Return Value:
|
|
|
|
MERGE_CONTINUE - Key was processed
|
|
MERGE_ERROR - An error occurred
|
|
|
|
--*/
|
|
|
|
{
|
|
MYASSERT (State->FullKeyName);
|
|
MYASSERT (State->FullSubKeyName || State->MergeFlag == MERGE_FLAG_KEY);
|
|
MYASSERT (State->SubKeyName || State->MergeFlag == MERGE_FLAG_KEY);
|
|
MYASSERT (State->SubKey95 || State->MergeFlag == MERGE_FLAG_KEY);
|
|
MYASSERT (State->Context == CLSID_COPY);
|
|
|
|
switch (State->MergeFlag) {
|
|
|
|
case MERGE_FLAG_KEY:
|
|
//
|
|
// For MERGE_FLAG_KEY, copy all the values
|
|
//
|
|
|
|
CopyAllValues (State);
|
|
break;
|
|
|
|
case MERGE_FLAG_SUBKEY:
|
|
//
|
|
// For MERGE_FLAG_SUBKEY, copy unless it needs a special-case merge
|
|
//
|
|
|
|
if (StringIMatch (State->SubKeyName, TEXT("Instance"))) {
|
|
|
|
//
|
|
// The subkey is Instance, perform a special-case merge
|
|
//
|
|
|
|
if (!MergeSubKeyNode (State, CLSID_INSTANCE_COPY)) {
|
|
return MERGE_ERROR;
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// Copy the key unconditionally
|
|
//
|
|
|
|
if (!CopyEntireSubKey (State)) {
|
|
return MERGE_ERROR;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
DEBUGMSG ((DBG_WHOOPS, "Wasteful call to pCopyClassIdWorker"));
|
|
break;
|
|
}
|
|
|
|
return MERGE_CONTINUE;
|
|
}
|
|
|
|
|
|
MERGE_RESULT
|
|
pInstanceSpecialCase (
|
|
IN PMERGE_STATE State
|
|
)
|
|
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pInstanceSpecialCase handles the Instance subkey of arbitrary GUIDs. This
|
|
is used by ActiveMovie to track third-party plug-ins. This routine
|
|
examines the format of Instance (specific to ActiveMove), and copies only
|
|
parts of the key that are compatible with NT and not
|
|
replaced.
|
|
|
|
The Key refers to HKCR\CLSID\<guid>\Instance.
|
|
|
|
The SubKey refers to HKCR\CLSID\<guid>\Instance\<sequencer>
|
|
|
|
We have already determined that <guid> is not suppressed.
|
|
|
|
Arguments:
|
|
|
|
State - Specifies the HKCR state.
|
|
|
|
Return Value:
|
|
|
|
MERGE_CONTINUE - Key was processed
|
|
MERGE_ERROR - An error occurred
|
|
|
|
--*/
|
|
|
|
{
|
|
TCHAR Guid[MAX_GUID];
|
|
TCHAR Node[MEMDB_MAX];
|
|
LONG rc;
|
|
DWORD Size;
|
|
|
|
MYASSERT (State->FullKeyName);
|
|
MYASSERT (State->FullSubKeyName || State->MergeFlag == MERGE_FLAG_KEY);
|
|
MYASSERT (State->SubKeyName || State->MergeFlag == MERGE_FLAG_KEY);
|
|
MYASSERT (State->SubKey95 || State->MergeFlag == MERGE_FLAG_KEY);
|
|
MYASSERT (State->Context == CLSID_INSTANCE_COPY);
|
|
|
|
switch (State->MergeFlag) {
|
|
|
|
case MERGE_FLAG_KEY:
|
|
//
|
|
// Copy all values (normally there are none)
|
|
//
|
|
|
|
CopyAllValues (State);
|
|
break;
|
|
|
|
case MERGE_FLAG_SUBKEY:
|
|
//
|
|
// The subkey is a random enumerator (usually a GUID -- but it is not defined
|
|
// to be so). Look at the CLSID value of the subkey, then check the GUID
|
|
// (the value data) against the suppress list.
|
|
//
|
|
|
|
//
|
|
// Was that random enumerator installed by NT? If so, ignore the Win9x
|
|
// setting.
|
|
//
|
|
|
|
if (State->SubKeyNt) {
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Get GUID and see if it is suppressed
|
|
//
|
|
|
|
Size = sizeof (Guid);
|
|
|
|
rc = Win95RegQueryValueEx (
|
|
State->SubKey95,
|
|
TEXT("CLSID"),
|
|
NULL,
|
|
NULL,
|
|
(PBYTE) Guid,
|
|
&Size
|
|
);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
//
|
|
// No CLSID value; copy entire subkey unaltered
|
|
//
|
|
|
|
if (!CopyEntireSubKey (State)) {
|
|
return MERGE_ERROR;
|
|
}
|
|
}
|
|
|
|
MemDbBuildKey (Node, MEMDB_CATEGORY_GUIDS, Guid, NULL, NULL);
|
|
if (!MemDbGetValue (Node, NULL)) {
|
|
//
|
|
// GUID is not suppressed; copy entire subkey unaltered
|
|
//
|
|
|
|
if (!CopyEntireSubKey (State)) {
|
|
return MERGE_ERROR;
|
|
}
|
|
}
|
|
ELSE_DEBUGMSG ((DBG_VERBOSE, "Suppressing ActiveMovie Instance GUID: %s", Guid));
|
|
break;
|
|
|
|
default:
|
|
DEBUGMSG ((DBG_WHOOPS, "Wasteful call to pInstanceSpecialCase"));
|
|
break;
|
|
}
|
|
|
|
return MERGE_CONTINUE;
|
|
}
|
|
|
|
|
|
MERGE_RESULT
|
|
pCopyTypeLibOrInterface (
|
|
IN PMERGE_STATE State
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pCopyTypeLibOrInterface copies the COM type registration and COM interfaces.
|
|
|
|
Arguments:
|
|
|
|
State - Specifies the enumeration state, which is always a subkey of
|
|
HKCR\TypeLib in this case.
|
|
|
|
Return Value:
|
|
|
|
MERGE_CONTINUE - Key was processed
|
|
MERGE_ERROR - An error occurred
|
|
|
|
--*/
|
|
|
|
{
|
|
TCHAR Node[MEMDB_MAX];
|
|
|
|
MYASSERT (State->FullKeyName);
|
|
MYASSERT (State->FullSubKeyName);
|
|
MYASSERT (State->SubKeyName);
|
|
MYASSERT (State->SubKey95);
|
|
MYASSERT (State->MergeFlag == MERGE_FLAG_SUBKEY);
|
|
|
|
if (State->Context != TYPELIB_BASE &&
|
|
State->Context != INTERFACE_BASE
|
|
) {
|
|
return MERGE_NOP;
|
|
}
|
|
|
|
//
|
|
// Skip if the GUID is suppressed
|
|
//
|
|
|
|
MemDbBuildKey (Node, MEMDB_CATEGORY_GUIDS, State->SubKeyName, NULL, NULL);
|
|
if (!MemDbGetValue (Node, NULL)) {
|
|
if (State->Context == TYPELIB_BASE) {
|
|
|
|
//
|
|
// If this is a typelib entry, use additional typelib logic
|
|
//
|
|
|
|
if (!MergeSubKeyNode (State, TYPELIB_VERSION_COPY) ||
|
|
!CopyAllSubKeyValues (State)
|
|
) {
|
|
return MERGE_ERROR;
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// For the Interface entries, copy entire Win9x setting if
|
|
// GUID does not exist on NT. If GUID exists on NT, do not
|
|
// touch it.
|
|
//
|
|
|
|
if (!State->SubKeyNt) {
|
|
if (!CopyEntireSubKey (State)) {
|
|
return MERGE_ERROR;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return MERGE_CONTINUE;
|
|
}
|
|
|
|
|
|
MERGE_RESULT
|
|
pCopyTypeLibVersion (
|
|
IN PMERGE_STATE State
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pCopyTypeLibVersion copies the type registration for a specific
|
|
interface version. It only copies if the particular version
|
|
is not installed by NT.
|
|
|
|
This function is called only for subkeys within a TypeLib\{GUID}
|
|
key.
|
|
|
|
Arguments:
|
|
|
|
State - Specifies the enumeration state, which is always a subkey of
|
|
HKCR\TypeLib in this case.
|
|
|
|
Return Value:
|
|
|
|
MERGE_CONTINUE - Key was processed
|
|
MERGE_ERROR - An error occurred
|
|
|
|
--*/
|
|
|
|
{
|
|
MYASSERT (State->FullKeyName);
|
|
MYASSERT (State->MergeFlag == MERGE_FLAG_SUBKEY);
|
|
MYASSERT (State->Context == TYPELIB_VERSION_COPY);
|
|
MYASSERT (State->FullSubKeyName);
|
|
MYASSERT (State->SubKeyName);
|
|
MYASSERT (State->SubKey95);
|
|
|
|
//
|
|
// Skip if the sub key exists in NT, copy the entire thing otherwise
|
|
//
|
|
|
|
if (!State->SubKeyNt) {
|
|
if (!CopyEntireSubKey (State)) {
|
|
return MERGE_ERROR;
|
|
}
|
|
}
|
|
|
|
return MERGE_CONTINUE;
|
|
}
|
|
|
|
|
|
MERGE_RESULT
|
|
pLastMergeRoutine (
|
|
IN PMERGE_STATE State
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pLastMergeRoutine performs a default copy with no overwrite for all keys
|
|
left unhandled. This routine first verifies the context is a base context
|
|
(such as ROOT_BASE or CLSID_BASE), and if so, MergeRegistryNode is called
|
|
recursively to perform the merge.
|
|
|
|
Arguments:
|
|
|
|
State - Specifies the enumeration state
|
|
|
|
Return Value:
|
|
|
|
MERGE_NOP - The subkey was not processed
|
|
MERGE_ERROR - An error occurred
|
|
MERGE_CONTINUE - The key was merged
|
|
|
|
--*/
|
|
|
|
{
|
|
TCHAR DefaultIconKey[MAX_REGISTRY_KEY];
|
|
HKEY DefaultIcon95;
|
|
|
|
MYASSERT (State->FullKeyName);
|
|
MYASSERT (State->FullSubKeyName);
|
|
MYASSERT (State->SubKeyName);
|
|
MYASSERT (State->SubKey95);
|
|
MYASSERT (State->MergeFlag == MERGE_FLAG_SUBKEY);
|
|
|
|
//
|
|
// Process only base contexts
|
|
//
|
|
|
|
if (State->Context != ROOT_BASE &&
|
|
State->Context != CLSID_BASE
|
|
) {
|
|
return MERGE_NOP;
|
|
}
|
|
|
|
//
|
|
// If we got here, nobody wants to handle the current key,
|
|
// so let's copy it without overwriting NT keys.
|
|
//
|
|
|
|
if (!CopyEntireSubKeyNoOverwrite (State)) {
|
|
return MERGE_ERROR;
|
|
}
|
|
|
|
//
|
|
// Special case: If ROOT_BASE, and subkey has a DefaultIcon subkey,
|
|
// run the DefaultIcon processing.
|
|
//
|
|
|
|
if (State->Context == ROOT_BASE) {
|
|
StringCopy (DefaultIconKey, State->FullSubKeyName);
|
|
StringCopy (AppendWack (DefaultIconKey), TEXT("DefaultIcon"));
|
|
|
|
DefaultIcon95 = OpenRegKeyStr95 (DefaultIconKey);
|
|
if (DefaultIcon95) {
|
|
CloseRegKey95 (DefaultIcon95);
|
|
|
|
if (!MergeRegistryNode (DefaultIconKey, COPY_DEFAULT_ICON)) {
|
|
return MERGE_ERROR;
|
|
}
|
|
}
|
|
}
|
|
|
|
return MERGE_CONTINUE;
|
|
}
|
|
|