377 lines
11 KiB
C
377 lines
11 KiB
C
/*++
|
|
|
|
Copyright (c) 1992 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
regdat16.c
|
|
|
|
Abstract:
|
|
|
|
This module contains code for reading the Windows 3.1 registry
|
|
file (REG.DAT)
|
|
|
|
Author:
|
|
|
|
Steve Wood (stevewo) 22-Feb-1993
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "advapi.h"
|
|
#include <stdio.h>
|
|
|
|
#include <winbasep.h>
|
|
#include "win31io.h"
|
|
|
|
// #define SHOW_TREE_MIGRATION
|
|
|
|
#define MAX_LEVELS 64
|
|
|
|
PREG_HEADER16
|
|
LoadRegistry16(
|
|
PWSTR RegistryFileName
|
|
)
|
|
{
|
|
HANDLE File, Mapping;
|
|
LPVOID Base;
|
|
|
|
File = CreateFileW( RegistryFileName,
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
0,
|
|
NULL
|
|
);
|
|
|
|
if (File == INVALID_HANDLE_VALUE) {
|
|
return NULL;
|
|
}
|
|
|
|
|
|
Mapping = CreateFileMapping( File,
|
|
NULL,
|
|
PAGE_WRITECOPY,
|
|
0,
|
|
0,
|
|
NULL
|
|
);
|
|
CloseHandle( File );
|
|
if (Mapping == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
|
|
Base = MapViewOfFile( Mapping,
|
|
FILE_MAP_COPY,
|
|
0,
|
|
0,
|
|
0
|
|
);
|
|
CloseHandle( Mapping );
|
|
return (PREG_HEADER16)Base;
|
|
}
|
|
|
|
|
|
BOOL
|
|
UnloadRegistry16(
|
|
PREG_HEADER16 Registry
|
|
)
|
|
{
|
|
return UnmapViewOfFile( (LPVOID)Registry );
|
|
}
|
|
|
|
|
|
typedef struct _REG16_PATH_SUBST {
|
|
ULONG cbOldValue;
|
|
LPSTR OldValue;
|
|
LPSTR NewValue;
|
|
} REG16_PATH_SUBST, *PREG16_PATH_SUBST;
|
|
|
|
REG16_PATH_SUBST Reg16PathSubstitutes[] = {
|
|
{10, "mciole.dll", "mciole16.dll"},
|
|
{11, "mplayer.exe", "mplay32.exe" },
|
|
{12, "packager.exe", "packgr32.exe"},
|
|
{12, "soundrec.exe", "sndrec32.exe"},
|
|
{0, NULL, NULL}
|
|
};
|
|
|
|
typedef struct _REG16_WALK_STATE {
|
|
HANDLE KeyHandle;
|
|
WORD NodeIndex;
|
|
WORD Reserved;
|
|
} REG16_WALK_STATE, *PREG16_WALK_STATE;
|
|
|
|
char *szBlanks = " ";
|
|
|
|
BOOL
|
|
CreateRegistryClassesFromRegistry16(
|
|
HANDLE SoftwareRoot,
|
|
PREG_HEADER16 Registry
|
|
)
|
|
{
|
|
PREG_KEY16 KeyNode;
|
|
PREG_STRING16 KeyNameString, KeyValueString;
|
|
PREG_NODE16 NodeTable;
|
|
PCH StringTable;
|
|
int i;
|
|
DWORD Level;
|
|
REG16_WALK_STATE State[ MAX_LEVELS ];
|
|
ANSI_STRING AnsiString;
|
|
UNICODE_STRING KeyName;
|
|
UNICODE_STRING KeyValue;
|
|
UNICODE_STRING ValueName;
|
|
NTSTATUS Status;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
ULONG CreateDisposition;
|
|
PREG16_PATH_SUBST PathSubst;
|
|
|
|
RtlInitUnicodeString( &ValueName, NULL );
|
|
|
|
NodeTable = (PREG_NODE16)((PBYTE)Registry + Registry->dwNodeTable);
|
|
StringTable = (PCH)Registry + Registry->dwStringValue;
|
|
|
|
i = NodeTable[ 0 ].key.iChild;
|
|
Level = 0;
|
|
while (i != 0) {
|
|
KeyNode = &NodeTable[ i ].key;
|
|
KeyNameString = &NodeTable[ KeyNode->iKey ].str;
|
|
AnsiString.Length = KeyNameString->cb;
|
|
AnsiString.MaximumLength = AnsiString.Length;
|
|
AnsiString.Buffer = StringTable + KeyNameString->irgb;
|
|
if (Level == 0 && *AnsiString.Buffer == '.') {
|
|
AnsiString.Buffer += 1;
|
|
AnsiString.Length -= 1;
|
|
}
|
|
RtlAnsiStringToUnicodeString( &KeyName, &AnsiString, TRUE );
|
|
|
|
#ifdef SHOW_TREE_MIGRATION
|
|
DbgPrint( "%.*s%wZ", Level * 4, szBlanks, &KeyName );
|
|
#endif
|
|
|
|
InitializeObjectAttributes( &ObjectAttributes,
|
|
&KeyName,
|
|
OBJ_CASE_INSENSITIVE,
|
|
Level == 0 ? SoftwareRoot : State[ Level-1 ].KeyHandle,
|
|
NULL
|
|
);
|
|
Status = NtCreateKey( &State[ Level ].KeyHandle,
|
|
STANDARD_RIGHTS_WRITE |
|
|
KEY_QUERY_VALUE |
|
|
KEY_ENUMERATE_SUB_KEYS |
|
|
KEY_SET_VALUE |
|
|
KEY_CREATE_SUB_KEY,
|
|
&ObjectAttributes,
|
|
0,
|
|
NULL,
|
|
0,
|
|
&CreateDisposition
|
|
);
|
|
|
|
RtlFreeUnicodeString( &KeyName );
|
|
if (!NT_SUCCESS( Status )) {
|
|
#ifdef SHOW_TREE_MIGRATION
|
|
DbgPrint( " *** CreateKey failed with Status == %x\n", Status );
|
|
#endif
|
|
BaseSetLastNTError( Status );
|
|
break;
|
|
}
|
|
#ifdef SHOW_TREE_MIGRATION
|
|
DbgPrint( "%s\n", CreateDisposition == REG_CREATED_NEW_KEY ? " *** NEW ***" : "" );
|
|
#endif
|
|
|
|
if (KeyNode->iValue != 0) {
|
|
ULONG cb;
|
|
LPSTR s, Src, Dst;
|
|
|
|
KeyValueString = &NodeTable[ KeyNode->iValue ].str;
|
|
cb = KeyValueString->cb;
|
|
Src = StringTable + KeyValueString->irgb;
|
|
Dst = RtlAllocateHeap( RtlProcessHeap(), 0, 2*(cb+1) );
|
|
if (Dst != NULL) {
|
|
AnsiString.Length = 0;
|
|
AnsiString.Buffer = Dst;
|
|
while (cb) {
|
|
PathSubst = &Reg16PathSubstitutes[ 0 ];
|
|
while (PathSubst->OldValue) {
|
|
if (cb >= PathSubst->cbOldValue &&
|
|
!_strnicmp( Src, PathSubst->OldValue, PathSubst->cbOldValue )
|
|
) {
|
|
*Dst = '\0';
|
|
while (Dst > AnsiString.Buffer) {
|
|
if (Dst[ -1 ] <= ' ') {
|
|
break;
|
|
}
|
|
else {
|
|
Dst -= 1;
|
|
}
|
|
}
|
|
|
|
s = PathSubst->NewValue;
|
|
#ifdef SHOW_TREE_MIGRATION
|
|
DbgPrint( " Found '%s%s' changed to '%s' ", Dst, PathSubst->OldValue, PathSubst->NewValue );
|
|
#else
|
|
KdPrint(( "ADVAPI: Found '%s%s' changed to '%s'\n", Dst, PathSubst->OldValue, PathSubst->NewValue ));
|
|
#endif
|
|
Src += PathSubst->cbOldValue;
|
|
cb -= PathSubst->cbOldValue;
|
|
while (*Dst = *s++) {
|
|
Dst += 1;
|
|
}
|
|
|
|
break;
|
|
}
|
|
else {
|
|
PathSubst += 1;
|
|
}
|
|
}
|
|
|
|
if (PathSubst->OldValue == NULL) {
|
|
*Dst++ = *Src++;
|
|
cb -= 1;
|
|
}
|
|
}
|
|
*Dst = '\0';
|
|
|
|
AnsiString.Length = (USHORT)(Dst - AnsiString.Buffer);
|
|
AnsiString.MaximumLength = (USHORT)(AnsiString.Length + 1);
|
|
RtlAnsiStringToUnicodeString( &KeyValue, &AnsiString, TRUE );
|
|
RtlFreeHeap( RtlProcessHeap(), 0, AnsiString.Buffer );
|
|
|
|
#ifdef SHOW_TREE_MIGRATION
|
|
DbgPrint( "%.*s= (%u, %u) %wZ", (Level+1) * 4, szBlanks, KeyValueString->cb, cb, &KeyValue );
|
|
#endif
|
|
|
|
Status = NtSetValueKey( State[ Level ].KeyHandle,
|
|
&ValueName,
|
|
0,
|
|
REG_SZ,
|
|
KeyValue.Buffer,
|
|
KeyValue.Length + sizeof( UNICODE_NULL )
|
|
);
|
|
RtlFreeUnicodeString( &KeyValue );
|
|
|
|
if (!NT_SUCCESS( Status )) {
|
|
#ifdef SHOW_TREE_MIGRATION
|
|
DbgPrint( " *** SetValueKey failed with Status == %x\n", Status );
|
|
#endif
|
|
BaseSetLastNTError( Status );
|
|
break;
|
|
}
|
|
#ifdef SHOW_TREE_MIGRATION
|
|
DbgPrint( "\n" );
|
|
#endif
|
|
}
|
|
}
|
|
|
|
if (KeyNode->iChild != 0) {
|
|
State[ Level++ ].NodeIndex = KeyNode->iNext;
|
|
State[ Level ].KeyHandle = NULL;
|
|
i = KeyNode->iChild;
|
|
}
|
|
else {
|
|
NtClose( State[ Level ].KeyHandle );
|
|
if (KeyNode->iNext != 0) {
|
|
i = KeyNode->iNext;
|
|
}
|
|
else {
|
|
while (Level != 0) {
|
|
Level -= 1;
|
|
NtClose( State[ Level ].KeyHandle );
|
|
|
|
if (i = State[ Level ].NodeIndex) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Level == 0) {
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
while (Level != 0 && (i = State[ --Level ].NodeIndex) == 0) {
|
|
NtClose( State[ Level ].KeyHandle );
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
#if DBG
|
|
char *Blanks = " ";
|
|
|
|
BOOL
|
|
DumpRegistry16(
|
|
PREG_HEADER16 Registry
|
|
)
|
|
{
|
|
PREG_KEY16 KeyNode;
|
|
PREG_STRING16 StringNode, KeyNameString, KeyValueString;
|
|
PREG_NODE16 NodeTable;
|
|
PCH StringTable, String, KeyName, KeyValue;
|
|
int i, j;
|
|
DWORD Level;
|
|
WORD LevelNode[ MAX_LEVELS ];
|
|
|
|
NodeTable = (PREG_NODE16)((PBYTE)Registry + Registry->dwNodeTable);
|
|
StringTable = (PCH)Registry + Registry->dwStringValue;
|
|
|
|
DbgPrint( "Windows 3.1 Registry data at %08x\n", Registry );
|
|
DbgPrint( " dwMagic: %08x\n", Registry->dwMagic );
|
|
DbgPrint( " dwVersion: %08x\n", Registry->dwVersion );
|
|
DbgPrint( " dwHdrSize: %08x\n", Registry->dwHdrSize );
|
|
DbgPrint( " dwNodeTable: %08x\n", Registry->dwNodeTable );
|
|
DbgPrint( " dwNTSize: %08x\n", Registry->dwNTSize );
|
|
DbgPrint( " dwStringValue: %08x\n", Registry->dwStringValue );
|
|
DbgPrint( " dwSVSize: %08x\n", Registry->dwSVSize );
|
|
DbgPrint( " nHash: %04x\n", Registry->nHash );
|
|
DbgPrint( " iFirstFree: %04x\n", Registry->iFirstFree );
|
|
|
|
i = NodeTable[ 0 ].key.iChild;
|
|
Level = 0;
|
|
while (i != 0) {
|
|
KeyNode = &NodeTable[ i ].key;
|
|
KeyNameString = &NodeTable[ KeyNode->iKey ].str;
|
|
KeyName = StringTable + KeyNameString->irgb;
|
|
DbgPrint( "%.*s%.*s\n",
|
|
Level * 4,
|
|
Blanks,
|
|
KeyNameString->cb,
|
|
KeyName
|
|
);
|
|
if (KeyNode->iValue != 0) {
|
|
KeyValueString = &NodeTable[ KeyNode->iValue ].str;
|
|
KeyValue = StringTable + KeyValueString->irgb;
|
|
DbgPrint( "%.*s= %.*s\n",
|
|
(Level+1) * 4,
|
|
Blanks,
|
|
KeyValueString->cb,
|
|
KeyValue
|
|
);
|
|
}
|
|
|
|
if (KeyNode->iChild != 0) {
|
|
LevelNode[ Level++ ] = KeyNode->iNext;
|
|
i = KeyNode->iChild;
|
|
}
|
|
else
|
|
if (KeyNode->iNext != 0) {
|
|
i = KeyNode->iNext;
|
|
}
|
|
else {
|
|
while (Level != 0 && (i = LevelNode[ --Level ]) == 0) {
|
|
;
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#endif // DBG
|