Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
ce47f986d8
NT4/private/ntos/config/utils/regutil.c

1522 lines
49 KiB
C
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
/*++
Copyright (c) 1991 Microsoft Corporation
Module Name:
regutil.c
Abstract:
Utility routines for use by REGINI and REGDMP programs.
Author:
Steve Wood (stevewo) 10-Mar-92
Revision History:
--*/
#include "regutil.h"
#define RtlAllocateHeap(x,y,z) malloc(z)
#define RtlFreeHeap(x,y,z) free(z)
UNICODE_STRING RiOnKeyword;
UNICODE_STRING RiYesKeyword;
UNICODE_STRING RiTrueKeyword;
UNICODE_STRING RiOffKeyword;
UNICODE_STRING RiNoKeyword;
UNICODE_STRING RiFalseKeyword;
UNICODE_STRING RiDeleteKeyword;
UNICODE_STRING RiRegKeyword;
UNICODE_STRING RiRegNoneKeyword;
UNICODE_STRING RiRegSzKeyword;
UNICODE_STRING RiRegExpandSzKeyword;
UNICODE_STRING RiRegDwordKeyword;
UNICODE_STRING RiRegBinaryKeyword;
UNICODE_STRING RiRegBinaryFileKeyword;
UNICODE_STRING RiRegLinkKeyword;
UNICODE_STRING RiRegMultiSzKeyword;
UNICODE_STRING RiRegMultiSzFileKeyword;
UNICODE_STRING RiRegDateKeyword;
void
RegInitialize( void )
{
RtlInitUnicodeString( &RiOnKeyword, L"ON" );
RtlInitUnicodeString( &RiYesKeyword, L"YES" );
RtlInitUnicodeString( &RiTrueKeyword, L"TRUE" );
RtlInitUnicodeString( &RiOffKeyword, L"OFF" );
RtlInitUnicodeString( &RiNoKeyword, L"NO" );
RtlInitUnicodeString( &RiFalseKeyword, L"FALSE" );
RtlInitUnicodeString( &RiDeleteKeyword, L"DELETE" );
RtlInitUnicodeString( &RiRegKeyword, L"REG_" );
RtlInitUnicodeString( &RiRegNoneKeyword, L"REG_NONE" );
RtlInitUnicodeString( &RiRegSzKeyword, L"REG_SZ" );
RtlInitUnicodeString( &RiRegExpandSzKeyword, L"REG_EXPAND_SZ" );
RtlInitUnicodeString( &RiRegDwordKeyword, L"REG_DWORD" );
RtlInitUnicodeString( &RiRegBinaryKeyword, L"REG_BINARY" );
RtlInitUnicodeString( &RiRegBinaryFileKeyword, L"REG_BINARYFILE" );
RtlInitUnicodeString( &RiRegLinkKeyword, L"REG_LINK" );
RtlInitUnicodeString( &RiRegMultiSzKeyword, L"REG_MULTI_SZ" );
RtlInitUnicodeString( &RiRegMultiSzFileKeyword, L"REG_MULTISZFILE" );
RtlInitUnicodeString( &RiRegDateKeyword, L"REG_DATE" );
}
NTSTATUS
RegReadMultiSzFile(
IN PUNICODE_STRING FileName,
OUT PVOID *ValueBuffer,
OUT PULONG ValueLength
)
{
NTSTATUS Status;
UNICODE_STRING NtFileName;
PWSTR s;
UNICODE_STRING MultiSource;
UNICODE_STRING MultiValue;
REG_UNICODE_FILE MultiSzFile;
ULONG MultiSzFileSize;
FileName->Buffer[ FileName->Length/sizeof(WCHAR) ] = UNICODE_NULL;
RtlDosPathNameToNtPathName_U( FileName->Buffer,
&NtFileName,
NULL,
NULL );
Status = RegLoadAsciiFileAsUnicode( &NtFileName, &MultiSzFile );
if (!NT_SUCCESS( Status )) {
return( Status );
}
MultiSzFileSize = (MultiSzFile.EndOfFile -
MultiSzFile.NextLine) * sizeof(WCHAR);
*ValueLength = 0;
*ValueBuffer = RtlAllocateHeap( RtlProcessHeap(), 0,
MultiSzFileSize);
MultiSource.Buffer = MultiSzFile.NextLine;
if (MultiSzFileSize <= MAXUSHORT) {
MultiSource.Length =
MultiSource.MaximumLength = (USHORT)MultiSzFileSize;
} else {
MultiSource.Length =
MultiSource.MaximumLength = MAXUSHORT;
}
while (RegGetMultiString(&MultiSource, &MultiValue)) {
RtlMoveMemory( (PUCHAR)*ValueBuffer + *ValueLength,
MultiValue.Buffer,
MultiValue.Length );
*ValueLength += MultiValue.Length;
s = MultiSource.Buffer;
while ( *s != L'"' &&
*s != L',' &&
((s - MultiSource.Buffer) * sizeof(WCHAR)) <
MultiSource.Length ) s++;
if ( ((s - MultiSource.Buffer) * sizeof(WCHAR)) ==
MultiSource.Length ||
*s == L',' ||
*s == L';' ) {
((PWSTR)*ValueBuffer)[ *ValueLength / sizeof(WCHAR) ] =
UNICODE_NULL;
*ValueLength += sizeof(UNICODE_NULL);
if ( *s == L';' ) {
break;
}
}
if ( (MultiSzFile.EndOfFile - MultiSource.Buffer) * sizeof(WCHAR) >=
MAXUSHORT ) {
MultiSource.Length =
MultiSource.MaximumLength = MAXUSHORT;
} else {
MultiSource.Length =
MultiSource.MaximumLength =
(USHORT)((MultiSzFile.EndOfFile - MultiSource.Buffer) *
sizeof(WCHAR));
}
}
((PWSTR)*ValueBuffer)[ *ValueLength / sizeof(WCHAR) ] = UNICODE_NULL;
*ValueLength += sizeof(UNICODE_NULL);
// Virtual memory for reading of MultiSzFile freed at process
// death?
return( TRUE );
}
NTSTATUS
RegReadBinaryFile(
IN PUNICODE_STRING FileName,
OUT PVOID *ValueBuffer,
OUT PULONG ValueLength
)
{
NTSTATUS Status;
UNICODE_STRING NtFileName;
OBJECT_ATTRIBUTES ObjectAttributes;
IO_STATUS_BLOCK IoStatus;
HANDLE File;
FILE_STANDARD_INFORMATION FileInformation;
WCHAR FileNameBuffer[ 256 ];
PWSTR s;
FileName->Buffer[ FileName->Length/sizeof(WCHAR) ] = UNICODE_NULL;
wcscpy( FileNameBuffer, L"\\DosDevices\\" );
s = wcscat( FileNameBuffer, FileName->Buffer );
while (*s != UNICODE_NULL) {
if (*s == L'/') {
*s = L'\\';
}
s++;
}
RtlInitUnicodeString( &NtFileName, FileNameBuffer );
InitializeObjectAttributes( &ObjectAttributes,
&NtFileName,
OBJ_CASE_INSENSITIVE,
(HANDLE)NULL,
NULL
);
Status = NtOpenFile( &File,
SYNCHRONIZE | GENERIC_READ,
&ObjectAttributes,
&IoStatus,
FILE_SHARE_DELETE |
FILE_SHARE_READ |
FILE_SHARE_WRITE,
FILE_SYNCHRONOUS_IO_NONALERT |
FILE_NON_DIRECTORY_FILE
);
if (!NT_SUCCESS( Status )) {
return( Status );
}
Status = NtQueryInformationFile( File,
&IoStatus,
(PVOID)&FileInformation,
sizeof( FileInformation ),
FileStandardInformation
);
if (NT_SUCCESS( Status )) {
if (FileInformation.EndOfFile.HighPart) {
Status = STATUS_BUFFER_OVERFLOW;
}
}
if (!NT_SUCCESS( Status )) {
NtClose( File );
return( Status );
}
*ValueLength = FileInformation.EndOfFile.LowPart;
*ValueBuffer = RtlAllocateHeap( RtlProcessHeap(), 0, *ValueLength );
if (*ValueBuffer == NULL) {
Status = STATUS_NO_MEMORY;
}
if (NT_SUCCESS( Status )) {
Status = NtReadFile( File,
NULL,
NULL,
NULL,
&IoStatus,
*ValueBuffer,
*ValueLength,
NULL,
NULL
);
if (NT_SUCCESS( Status )) {
Status = IoStatus.Status;
if (NT_SUCCESS( Status )) {
if (IoStatus.Information != *ValueLength) {
Status = STATUS_END_OF_FILE;
}
}
}
if (!NT_SUCCESS( Status )) {
RtlFreeHeap( RtlProcessHeap(), 0, *ValueBuffer );
}
}
NtClose( File );
return( Status );
}
NTSTATUS
RegLoadAsciiFileAsUnicode(
IN PUNICODE_STRING FileName,
OUT PREG_UNICODE_FILE UnicodeFile
)
{
NTSTATUS Status;
OBJECT_ATTRIBUTES ObjectAttributes;
IO_STATUS_BLOCK IoStatus;
HANDLE File;
FILE_BASIC_INFORMATION FileDateTimeInfo;
FILE_STANDARD_INFORMATION FileInformation;
ULONG BufferSize, i, i1, LineCount;
PVOID BufferBase;
PCHAR Src, Src1;
PWSTR Dst;
InitializeObjectAttributes( &ObjectAttributes,
FileName,
OBJ_CASE_INSENSITIVE,
(HANDLE)NULL,
NULL
);
Status = NtOpenFile( &File,
SYNCHRONIZE | GENERIC_READ,
&ObjectAttributes,
&IoStatus,
FILE_SHARE_DELETE |
FILE_SHARE_READ |
FILE_SHARE_WRITE,
FILE_SYNCHRONOUS_IO_NONALERT |
FILE_NON_DIRECTORY_FILE
);
if (!NT_SUCCESS( Status )) {
return( Status );
}
Status = NtQueryInformationFile( File,
&IoStatus,
(PVOID)&FileInformation,
sizeof( FileInformation ),
FileStandardInformation
);
if (NT_SUCCESS( Status )) {
if (FileInformation.EndOfFile.HighPart) {
Status = STATUS_BUFFER_OVERFLOW;
}
}
if (!NT_SUCCESS( Status )) {
NtClose( File );
return( Status );
}
BufferSize = FileInformation.EndOfFile.LowPart * sizeof( WCHAR );
BufferSize += sizeof( UNICODE_NULL );
BufferBase = NULL;
Status = NtAllocateVirtualMemory( NtCurrentProcess(),
(PVOID *)&BufferBase,
0,
&BufferSize,
MEM_COMMIT,
PAGE_READWRITE
);
if (NT_SUCCESS( Status )) {
Src = (PCHAR)BufferBase + ((FileInformation.EndOfFile.LowPart+1) & ~1);
Dst = (PWSTR)BufferBase;
Status = NtReadFile( File,
NULL,
NULL,
NULL,
&IoStatus,
Src,
FileInformation.EndOfFile.LowPart,
NULL,
NULL
);
if (NT_SUCCESS( Status )) {
Status = IoStatus.Status;
if (NT_SUCCESS( Status )) {
if (IoStatus.Information != FileInformation.EndOfFile.LowPart) {
Status = STATUS_END_OF_FILE;
}
else {
Status = NtQueryInformationFile( File,
&IoStatus,
(PVOID)&FileDateTimeInfo,
sizeof( FileDateTimeInfo ),
FileBasicInformation
);
}
}
}
if (!NT_SUCCESS( Status )) {
NtFreeVirtualMemory( NtCurrentProcess(),
(PVOID *)&BufferBase,
&BufferSize,
MEM_RELEASE
);
}
}
NtClose( File );
if (!NT_SUCCESS( Status )) {
return( Status );
}
i = 0;
while (i < FileInformation.EndOfFile.LowPart) {
if (i > 1 && (Src[-2] == ' ' || Src[-2] == '\t') &&
Src[-1] == '\\' && (*Src == '\r' || *Src == '\n')
) {
if (Dst[-1] == L'\\') {
--Dst;
}
while (Dst > (PWSTR)BufferBase) {
if (Dst[-1] > L' ') {
break;
}
Dst--;
}
LineCount = 0;
while (i < FileInformation.EndOfFile.LowPart) {
if (*Src == '\n') {
i++;
Src++;
LineCount++;
}
else
if (*Src == '\r' &&
(i+1) < FileInformation.EndOfFile.LowPart &&
Src[ 1 ] == '\n'
) {
i += 2;
Src += 2;
LineCount++;
}
else {
break;
}
}
if (LineCount > 1) {
*Dst++ = L'\n';
}
else {
*Dst++ = L' ';
while (i < FileInformation.EndOfFile.LowPart && (*Src == ' ' || *Src == '\t')) {
i++;
Src++;
}
}
if (i >= FileInformation.EndOfFile.LowPart) {
break;
}
}
else
if ((*Src == '\r' && Src[1] == '\n') || *Src == '\n') {
while (TRUE) {
while (i < FileInformation.EndOfFile.LowPart && (*Src == '\r' || *Src == '\n')) {
i++;
Src++;
}
Src1 = Src;
i1 = i;
while (i1 < FileInformation.EndOfFile.LowPart && (*Src1 == ' ' || *Src1 == '\t')) {
i1++;
Src1++;
}
if (i1 < FileInformation.EndOfFile.LowPart &&
(*Src1 == '\r' && Src1[1] == '\n') || *Src1 == '\n'
) {
Src = Src1;
i = i1;
}
else {
break;
}
}
*Dst++ = L'\n';
}
else {
i++;
*Dst++ = RtlAnsiCharToUnicodeChar( &Src );
}
}
if (NT_SUCCESS( Status )) {
*Dst = UNICODE_NULL;
UnicodeFile->FileContents = BufferBase;
UnicodeFile->EndOfFile = Dst;
UnicodeFile->BeginLine = NULL;
UnicodeFile->EndOfLine = NULL;
UnicodeFile->NextLine = BufferBase;
UnicodeFile->LastWriteTime = FileDateTimeInfo.LastWriteTime;
}
else {
NtFreeVirtualMemory( NtCurrentProcess(),
(PVOID *)&BufferBase,
&BufferSize,
MEM_RELEASE
);
}
return( Status );
}
BOOLEAN
RegGetNextLine(
IN OUT PREG_UNICODE_FILE UnicodeFile,
OUT PULONG IndentAmount,
OUT PWSTR *FirstEqual
)
{
PWSTR s, s1;
while (TRUE) {
if (!(s = UnicodeFile->NextLine)) {
return( FALSE );
}
*IndentAmount = 0;
while (*s <= L' ') {
if (*s == L' ') {
*IndentAmount += 1;
}
else
if (*s == L'\t') {
*IndentAmount = ((*IndentAmount + 8) -
(*IndentAmount % 8)
);
}
if (++s >= UnicodeFile->EndOfFile) {
return( FALSE );
}
}
UnicodeFile->BeginLine = s;
*FirstEqual = NULL;
UnicodeFile->NextLine = NULL;
while (s < UnicodeFile->EndOfFile) {
if (*s == L'=') {
if (*FirstEqual == NULL) {
*FirstEqual = s;
}
}
else
if (*s == L'\n') {
s1 = s;
while (s > UnicodeFile->BeginLine && s[ -1 ] <= L' ') {
s--;
}
UnicodeFile->EndOfLine = s;
do {
if (++s1 >= UnicodeFile->EndOfFile) {
s1 = NULL;
break;
}
}
while (*s1 == L'\r' || *s1 == L'\n');
UnicodeFile->NextLine = s1;
break;
}
if (++s == UnicodeFile->EndOfFile) {
break;
}
}
if (UnicodeFile->EndOfLine > UnicodeFile->BeginLine) {
if (DebugOutput) {
fprintf( stderr, "%02u %.*ws\n",
*IndentAmount,
UnicodeFile->EndOfLine - UnicodeFile->BeginLine,
UnicodeFile->BeginLine
);
}
return( TRUE );
}
}
return( FALSE );
}
void
RegDumpKeyValue(
FILE *fh,
PKEY_VALUE_FULL_INFORMATION KeyValueInformation,
ULONG IndentLevel
)
{
PULONG p;
PWSTR pw, pw1;
ULONG i, j, k, m, cbPrefix;
UNICODE_STRING ValueName;
PUCHAR pbyte;
cbPrefix = fprintf( fh, "%.*s",
IndentLevel,
" "
);
ValueName.Buffer = (PWSTR)&(KeyValueInformation->Name[0]);
ValueName.Length = (USHORT)KeyValueInformation->NameLength;
ValueName.MaximumLength = (USHORT)KeyValueInformation->NameLength;
if (ValueName.Length) {
cbPrefix += fprintf( fh, "%wZ ", &ValueName );
}
cbPrefix += fprintf( fh, "= " );
if (KeyValueInformation->DataLength == 0) {
fprintf( fh, " [no data] \n");
return;
}
switch( KeyValueInformation->Type ) {
case REG_SZ:
case REG_EXPAND_SZ:
if (KeyValueInformation->Type == REG_EXPAND_SZ) {
cbPrefix += fprintf( fh, "REG_EXPAND_SZ " );
}
pw = (PWSTR)((PCHAR)KeyValueInformation + KeyValueInformation->DataOffset);
*(PWSTR)((PCHAR)pw + KeyValueInformation->DataLength) = UNICODE_NULL;
i = 0;
while (*pw) {
if ((cbPrefix + wcslen(pw)) > 80) {
pw1 = pw;
while (*pw1 && *pw1 > L' ') {
pw1++;
}
if (*pw1) {
*pw1++ = UNICODE_NULL;
while (*pw1 && *pw1 <= L' ') {
pw1++;
}
}
} else {
pw1 = NULL;
}
if (i > 0) {
fprintf( fh, " \\\n%.*s",
cbPrefix,
" "
);
}
fprintf( fh, "%ws", pw );
if (!pw1) {
break;
}
i++;
pw = pw1;
}
break;
case REG_BINARY:
fprintf( fh, "REG_BINARY 0x%08lx", KeyValueInformation->DataLength );
p = (PULONG)((PCHAR)KeyValueInformation + KeyValueInformation->DataOffset);
i = (KeyValueInformation->DataLength + 3) / sizeof( ULONG );
if (!SummaryOutput || i <= 8) {
for (j=0; j<i; j++) {
if ((j % 8) == 0) {
fprintf( fh, "\n%.*s",
IndentLevel+4,
" "
);
}
fprintf( fh, "0x%08lx ", *p++ );
}
}
else {
fprintf( fh, " *** value display suppressed ***" );
}
fprintf( fh, "\n" );
break;
// case REG_DWORD_LITTLE_ENDIAN:
case REG_DWORD:
fprintf( fh, "REG_DWORD 0x%08lx",
*((PULONG)((PCHAR)KeyValueInformation + KeyValueInformation->DataOffset))
);
break;
case REG_DWORD_BIG_ENDIAN:
fprintf( fh, "REG_DWORD_BIG_ENDIAN 0x%08lx",
*((PULONG)((PCHAR)KeyValueInformation + KeyValueInformation->DataOffset))
);
break;
case REG_LINK:
fprintf( fh, "REG_LINK %ws",
((PWSTR)((PCHAR)KeyValueInformation + KeyValueInformation->DataOffset))
);
break;
case REG_MULTI_SZ:
cbPrefix += fprintf( fh, "REG_MULTI_SZ " );
pw = (PWSTR)((PCHAR)KeyValueInformation + KeyValueInformation->DataOffset);
i = 0;
if (*pw)
while (i < ((KeyValueInformation->DataLength-1) / sizeof(WCHAR))) {
if (i > 0) {
fprintf( fh, " \\\n%.*s",
cbPrefix,
" "
);
}
fprintf(fh, "\"%ws\" ",pw+i);
do {
++i;
} while ( pw[i] != UNICODE_NULL );
++i;
}
break;
case REG_RESOURCE_LIST:
case REG_FULL_RESOURCE_DESCRIPTOR:
{
PCM_RESOURCE_LIST ResourceList = ((PCM_RESOURCE_LIST)((PCHAR)KeyValueInformation +
KeyValueInformation->DataOffset));
PCM_FULL_RESOURCE_DESCRIPTOR FullDescriptor;
PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialResourceDescriptor;
ULONG k, l, count;
PWSTR TypeName;
PWSTR FlagName;
ULONG Size = KeyValueInformation->DataLength;
if (KeyValueInformation->Type == REG_RESOURCE_LIST) {
fprintf( fh, " REG_RESOURCE_LIST\n");
fprintf( fh, "%.*sNumber of Full resource Descriptors = %d",
IndentLevel,
" ",
ResourceList->Count
);
count = ResourceList->Count;
FullDescriptor = &ResourceList->List[0];
} else {
fprintf( fh, " REG_FULL_RESOURCE_DESCRIPTOR\n");
count = 1;
FullDescriptor = ((PCM_FULL_RESOURCE_DESCRIPTOR)
((PCHAR)KeyValueInformation + KeyValueInformation->DataOffset));
}
for (i=0; i< count; i++) {
fprintf( fh, "\n%.*sPartial List number %d\n",
IndentLevel+4,
" ",
i
);
switch(FullDescriptor->InterfaceType) {
case Internal: TypeName = L"Internal"; break;
case Isa: TypeName = L"Isa"; break;
case Eisa: TypeName = L"Eisa"; break;
case MicroChannel: TypeName = L"MicroChannel"; break;
case TurboChannel: TypeName = L"TurboChannel"; break;
case PCIBus: TypeName = L"PCI"; break;
case VMEBus: TypeName = L"VME"; break;
case NuBus: TypeName = L"NuBus"; break;
case PCMCIABus: TypeName = L"PCMCIA"; break;
case CBus: TypeName = L"CBUS"; break;
case MPIBus: TypeName = L"MPI"; break;
default:
TypeName = L"***invalid bus type***";
break;
}
fprintf( fh, "%.*sINTERFACE_TYPE %ws\n",
IndentLevel+8,
" ",
TypeName
);
fprintf( fh, "%.*sBUS_NUMBER %d\n",
IndentLevel+8,
" ",
FullDescriptor->BusNumber
);
//
// This is a basic test to see if the data format is right.
// We know at least some video resource list are bogus ...
//
if (Size < FullDescriptor->PartialResourceList.Count *
sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR) ) {
fprintf( fh, "\n%.*s *** !!! Invalid ResourceList !!! *** \n",
IndentLevel+8,
" ",
i
);
break;
}
Size -= FullDescriptor->PartialResourceList.Count *
sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
for (j=0; j<FullDescriptor->PartialResourceList.Count; j++) {
fprintf( fh, "%.*sDescriptor number %d\n",
IndentLevel+12,
" ",
j
);
PartialResourceDescriptor =
&(FullDescriptor->PartialResourceList.PartialDescriptors[j]);
switch(PartialResourceDescriptor->ShareDisposition) {
case CmResourceShareUndetermined:
TypeName = L"CmResourceShareUndetermined";
break;
case CmResourceShareDeviceExclusive:
TypeName = L"CmResourceDeviceExclusive";
break;
case CmResourceShareDriverExclusive:
TypeName = L"CmResourceDriverExclusive";
break;
case CmResourceShareShared:
TypeName = L"CmResourceShared";
break;
default:
TypeName = L"***invalid share disposition***";
break;
}
fprintf( fh, "%.*sShare Disposition %ws\n",
IndentLevel+12,
" ",
TypeName
);
FlagName = L"***invalid Flags";
switch(PartialResourceDescriptor->Type) {
case CmResourceTypeNull:
TypeName = L"NULL";
FlagName = L"***Unused";
break;
case CmResourceTypePort:
TypeName = L"PORT";
if (PartialResourceDescriptor->Flags == CM_RESOURCE_PORT_MEMORY) {
FlagName = L"CM_RESOURCE_PORT_MEMORY";
}
if (PartialResourceDescriptor->Flags == CM_RESOURCE_PORT_IO) {
FlagName = L"CM_RESOURCE_PORT_IO";
}
break;
case CmResourceTypeInterrupt:
TypeName = L"INTERRUPT";
if (PartialResourceDescriptor->Flags == CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE) {
FlagName = L"CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE";
}
if (PartialResourceDescriptor->Flags == CM_RESOURCE_INTERRUPT_LATCHED) {
FlagName = L"CM_RESOURCE_INTERRUPT_LATCHED";
}
break;
case CmResourceTypeMemory:
TypeName = L"MEMORY";
if (PartialResourceDescriptor->Flags == CM_RESOURCE_MEMORY_READ_WRITE) {
FlagName = L"CM_RESOURCE_MEMORY_READ_WRITE";
}
if (PartialResourceDescriptor->Flags == CM_RESOURCE_MEMORY_READ_ONLY) {
FlagName = L"CM_RESOURCE_MEMORY_READ_ONLY";
}
if (PartialResourceDescriptor->Flags == CM_RESOURCE_MEMORY_WRITE_ONLY) {
FlagName = L"CM_RESOURCE_MEMORY_WRITE_ONLY";
}
break;
case CmResourceTypeDma:
TypeName = L"DMA";
FlagName = L"***Unused";
break;
case CmResourceTypeDeviceSpecific:
TypeName = L"DEVICE SPECIFIC";
FlagName = L"***Unused";
break;
default:
TypeName = L"***invalid type***";
break;
}
fprintf( fh, "%.*sTYPE %ws\n",
IndentLevel+12,
" ",
TypeName
);
fprintf( fh, "%.*sFlags %ws\n",
IndentLevel+12,
" ",
FlagName
);
switch(PartialResourceDescriptor->Type) {
case CmResourceTypePort:
fprintf( fh, "%.*sSTART 0x%08lx LENGTH 0x%08lx\n",
IndentLevel+12,
" ",
PartialResourceDescriptor->u.Port.Start.LowPart,
PartialResourceDescriptor->u.Port.Length
);
break;
case CmResourceTypeInterrupt:
fprintf( fh, "%.*sLEVEL %d VECTOR %d AFFINITY %d\n",
IndentLevel+12,
" ",
PartialResourceDescriptor->u.Interrupt.Level,
PartialResourceDescriptor->u.Interrupt.Vector,
PartialResourceDescriptor->u.Interrupt.Affinity
);
break;
case CmResourceTypeMemory:
fprintf( fh, "%.*sSTART 0x%08lx%08lx LENGTH 0x%08lx\n",
IndentLevel+12,
" ",
PartialResourceDescriptor->u.Memory.Start.HighPart,
PartialResourceDescriptor->u.Memory.Start.LowPart,
PartialResourceDescriptor->u.Memory.Length
);
break;
case CmResourceTypeDma:
fprintf( fh, "%.*sCHANNEL %d PORT %d\n",
IndentLevel+12,
" ",
PartialResourceDescriptor->u.Dma.Channel,
PartialResourceDescriptor->u.Dma.Port
);
break;
case CmResourceTypeDeviceSpecific:
fprintf( fh, "%.*sDataSize 0x%08lx\n",
IndentLevel+12,
" ",
PartialResourceDescriptor->u.DeviceSpecificData.DataSize
);
p = (PULONG)(PartialResourceDescriptor + 1);
k = (PartialResourceDescriptor->u.DeviceSpecificData.DataSize + 3) / sizeof( ULONG );
for (l=0; l<k; l++) {
if ((l % 8) == 0) {
fprintf( fh, "\n%.*s",
IndentLevel+12,
" "
);
}
fprintf( fh, "0x%08lx ", *p++ );
}
fprintf( fh, "\n" );
break;
default:
fprintf( fh, "%.*s*** Unknown resource list type: %c ****\n",
IndentLevel+12,
" ",
PartialResourceDescriptor->Type
);
break;
}
fprintf( fh, "\n" );
}
FullDescriptor = (PCM_FULL_RESOURCE_DESCRIPTOR) (PartialResourceDescriptor+1);
}
break;
}
case REG_NONE:
default:
if (KeyValueInformation->Type == REG_NONE) {
fprintf( fh, "REG_NONE\n");
}
else {
fprintf( fh, "*** Unknown registry type (%08lx)",
KeyValueInformation->Type
);
}
fprintf( fh, "%.*s",
IndentLevel,
" "
);
fprintf( fh, " Length: 0x%lx\n", KeyValueInformation->DataLength );
fprintf( fh, "\n%.*s",
IndentLevel,
" "
);
fprintf( fh, " Data: ");
pbyte = ((PUCHAR)KeyValueInformation + KeyValueInformation->DataOffset);
for ( k=0, m=1; k<KeyValueInformation->DataLength; k++,m++) {
fprintf( fh, "%02x ", (*pbyte) );
pbyte++;
if (m==8) {
fprintf( fh, "\n%.*s",
IndentLevel+12,
" "
);
m=0;
}
}
break;
}
fprintf( fh, "\n" );
return;
}
//
// Define an upcase macro for temporary use by the upcase routines
//
#define upcase(C) (WCHAR )(((C) >= 'a' && (C) <= 'z' ? (C) - ('a' - 'A') : (C)))
BOOLEAN
RegGetMultiString(
IN OUT PUNICODE_STRING ValueString,
OUT PUNICODE_STRING MultiString
)
/*++
Routine Description:
This routine parses multi-strings of the form
"foo" "bar" "bletch"
Each time it is called, it strips the first string in quotes from
the input string, and returns it as the multi-string.
INPUT ValueString: "foo" "bar" "bletch"
OUTPUT ValueString: "bar" "bletch"
MultiString: foo
Arguments:
ValueString - Supplies the string from which the multi-string will be
parsed
- Returns the remaining string after the multi-string is
removed
MultiString - Returns the multi-string removed from ValueString
Return Value:
TRUE - multi-string found and removed.
FALSE - no more multi-strings remaining.
--*/
{
//
// Find the first quote mark.
//
while ((*(ValueString->Buffer) != L'"') &&
(ValueString->Length > 0)) {
++ValueString->Buffer;
ValueString->Length -= sizeof(WCHAR);
ValueString->MaximumLength -= sizeof(WCHAR);
}
if (ValueString->Length == 0) {
return(FALSE);
}
//
// We have found the start of the multi-string. Now find the end,
// building up our return MultiString as we go.
//
++ValueString->Buffer;
ValueString->Length -= sizeof(WCHAR);
ValueString->MaximumLength -= sizeof(WCHAR);
MultiString->Buffer = ValueString->Buffer;
MultiString->Length = 0;
MultiString->MaximumLength = 0;
while ((*(ValueString->Buffer) != L'"') &&
(ValueString->Length > 0)) {
++ValueString->Buffer;
ValueString->Length -= sizeof(WCHAR);
ValueString->MaximumLength -= sizeof(WCHAR);
MultiString->Length += sizeof(WCHAR);
MultiString->MaximumLength += sizeof(WCHAR);
}
if (ValueString->Length == 0) {
return(FALSE);
}
++ValueString->Buffer;
ValueString->Length -= sizeof(WCHAR);
ValueString->MaximumLength -= sizeof(WCHAR);
return( TRUE );
}
BOOLEAN
RegGetKeyValue(
IN PUNICODE_STRING InitialKeyValue,
IN OUT PREG_UNICODE_FILE UnicodeFile,
OUT PULONG ValueType,
OUT PVOID *ValueBuffer,
OUT PULONG ValueLength
)
{
ULONG PrefixLength;
PWSTR s;
PULONG p;
ULONG n;
NTSTATUS Status;
ULONG IndentAmount;
PWSTR FirstEqual;
UNICODE_STRING KeyValue;
UNICODE_STRING MultiValue;
BOOLEAN GetDataFromBinaryFile = FALSE;
BOOLEAN GetDataFromMultiSzFile = FALSE;
BOOLEAN ParseDateTime = FALSE;
KeyValue = *InitialKeyValue;
if (RtlPrefixUnicodeString( &RiDeleteKeyword, &KeyValue, TRUE )) {
*ValueBuffer = NULL;
return( TRUE );
}
else
if (!RtlPrefixUnicodeString( &RiRegKeyword, &KeyValue, TRUE )) {
*ValueType = REG_SZ;
PrefixLength = 0;
}
else
if (RtlPrefixUnicodeString( &RiRegNoneKeyword, &KeyValue, TRUE )) {
*ValueType = REG_NONE;
PrefixLength = RiRegNoneKeyword.Length;
}
else
if (RtlPrefixUnicodeString( &RiRegSzKeyword, &KeyValue, TRUE )) {
*ValueType = REG_SZ;
PrefixLength = RiRegSzKeyword.Length;
}
else
if (RtlPrefixUnicodeString( &RiRegExpandSzKeyword, &KeyValue, TRUE )) {
*ValueType = REG_EXPAND_SZ;
PrefixLength = RiRegExpandSzKeyword.Length;
}
else
if (RtlPrefixUnicodeString( &RiRegDwordKeyword, &KeyValue, TRUE )) {
*ValueType = REG_DWORD;
PrefixLength = RiRegDwordKeyword.Length;
}
else
if (RtlPrefixUnicodeString( &RiRegBinaryFileKeyword, &KeyValue, TRUE )) {
*ValueType = REG_BINARY;
PrefixLength = RiRegBinaryFileKeyword.Length;
GetDataFromBinaryFile = TRUE;
}
else
if (RtlPrefixUnicodeString( &RiRegBinaryKeyword, &KeyValue, TRUE )) {
*ValueType = REG_BINARY;
PrefixLength = RiRegBinaryKeyword.Length;
}
else
if (RtlPrefixUnicodeString( &RiRegLinkKeyword, &KeyValue, TRUE )) {
*ValueType = REG_LINK;
PrefixLength = RiRegLinkKeyword.Length;
}
else
if (RtlPrefixUnicodeString( &RiRegMultiSzFileKeyword, &KeyValue, TRUE)) {
*ValueType = REG_MULTI_SZ;
PrefixLength = RiRegMultiSzFileKeyword.Length;
GetDataFromMultiSzFile = TRUE;
}
else
if (RtlPrefixUnicodeString( &RiRegMultiSzKeyword, &KeyValue, TRUE)) {
*ValueType = REG_MULTI_SZ;
PrefixLength = RiRegMultiSzKeyword.Length;
}
else
if (RtlPrefixUnicodeString( &RiRegDateKeyword, &KeyValue, TRUE )) {
*ValueType = REG_BINARY;
ParseDateTime = TRUE;
PrefixLength = RiRegDateKeyword.Length;
}
else {
return( FALSE );
}
if (*ValueType != REG_NONE) {
s = (PWSTR)
((PCHAR)KeyValue.Buffer + PrefixLength);
KeyValue.Length -= (USHORT)PrefixLength;
while (KeyValue.Length != 0 && *s <= L' ') {
s++;
KeyValue.Length -= sizeof( WCHAR );
}
KeyValue.Buffer = s;
}
else {
*ValueType = REG_SZ;
}
if (GetDataFromBinaryFile) {
Status = RegReadBinaryFile( &KeyValue, ValueBuffer, ValueLength );
if (NT_SUCCESS( Status )) {
return( TRUE );
}
else {
fprintf( stderr, "REGINI: Unable to read data from %wZ - Status == %lx\n", &KeyValue, Status );
return( FALSE );
}
}
if (GetDataFromMultiSzFile) {
Status = RegReadMultiSzFile( &KeyValue, ValueBuffer, ValueLength );
if (NT_SUCCESS( Status )) {
return( TRUE );
}
else {
fprintf( stderr, "REGINI: Unable to read data from %wZ - Status == %lx\n", &KeyValue, Status );
return( FALSE );
}
}
switch( *ValueType ) {
case REG_SZ:
case REG_EXPAND_SZ:
case REG_LINK:
*ValueLength = KeyValue.Length + sizeof( UNICODE_NULL );
*ValueBuffer = RtlAllocateHeap( RtlProcessHeap(), 0, *ValueLength );
if (*ValueBuffer == NULL) {
return( FALSE );
}
RtlMoveMemory( *ValueBuffer, KeyValue.Buffer, KeyValue.Length );
((PWSTR)*ValueBuffer)[ KeyValue.Length / sizeof( WCHAR ) ] = UNICODE_NULL;
return( TRUE );
case REG_DWORD:
*ValueBuffer = RtlAllocateHeap( RtlProcessHeap(), 0, sizeof( ULONG ) );
if (*ValueBuffer == NULL) {
return( FALSE );
}
if (RtlPrefixUnicodeString( &RiTrueKeyword, &KeyValue, TRUE ) ||
RtlPrefixUnicodeString( &RiYesKeyword, &KeyValue, TRUE ) ||
RtlPrefixUnicodeString( &RiOnKeyword, &KeyValue, TRUE )
) {
*(PULONG)*ValueBuffer = (ULONG)TRUE;
}
else
if (RtlPrefixUnicodeString( &RiFalseKeyword, &KeyValue, TRUE ) ||
RtlPrefixUnicodeString( &RiNoKeyword, &KeyValue, TRUE ) ||
RtlPrefixUnicodeString( &RiOffKeyword, &KeyValue, TRUE )
) {
*(PULONG)*ValueBuffer = (ULONG)FALSE;
}
else {
Status = RtlUnicodeStringToInteger( &KeyValue, 0, (PULONG)*ValueBuffer );
if (!NT_SUCCESS( Status )) {
fprintf( stderr, "REGINI: CharToInteger( %wZ ) failed - Status == %lx\n", &KeyValue, Status );
RtlFreeHeap( RtlProcessHeap(), 0, *ValueBuffer );
return( FALSE );
}
}
*ValueLength = sizeof( ULONG );
return( TRUE );
case REG_BINARY:
if (ParseDateTime) {
#define NUMBER_DATE_TIME_FIELDS 6
ULONG FieldIndexes[ NUMBER_DATE_TIME_FIELDS ] = {1, 2, 0, 3, 4, 7};
//
// Month/Day/Year HH:MM DayOfWeek
//
ULONG CurrentField = 0;
PCSHORT Fields;
TIME_FIELDS DateTimeFields;
UNICODE_STRING Field;
ULONG FieldValue;
RtlZeroMemory( &DateTimeFields, sizeof( DateTimeFields ) );
Fields = &DateTimeFields.Year;
while (KeyValue.Length) {
if (CurrentField >= 7) {
return( FALSE );
}
s = KeyValue.Buffer;
while (KeyValue.Length && *s == L' ') {
KeyValue.Length--;
s++;
}
Field.Buffer = s;
while (KeyValue.Length) {
if (CurrentField == (NUMBER_DATE_TIME_FIELDS-1)) {
}
else
if (*s < L'0' || *s > L'9') {
break;
}
KeyValue.Length--;
s++;
}
Field.Length = (USHORT)((PCHAR)s - (PCHAR)Field.Buffer);
Field.MaximumLength = Field.Length;
if (KeyValue.Length) {
KeyValue.Length--;
s++;
}
KeyValue.Buffer = s;
if (CurrentField == (NUMBER_DATE_TIME_FIELDS-1)) {
if (Field.Length < 3) {
printf( "REGINI: %wZ invalid day of week length\n", &Field );
return FALSE;
}
if (DateTimeFields.Year != 0) {
printf( "REGINI: Year must be zero to specify day of week\n" );
return FALSE;
}
if (!_wcsnicmp( Field.Buffer, L"SUN", 3 )) {
FieldValue = 0;
}
else
if (!_wcsnicmp( Field.Buffer, L"MON", 3 )) {
FieldValue = 1;
}
else
if (!_wcsnicmp( Field.Buffer, L"TUE", 3 )) {
FieldValue = 2;
}
else
if (!_wcsnicmp( Field.Buffer, L"WED", 3 )) {
FieldValue = 3;
}
else
if (!_wcsnicmp( Field.Buffer, L"THU", 3 )) {
FieldValue = 4;
}
else
if (!_wcsnicmp( Field.Buffer, L"FRI", 3 )) {
FieldValue = 5;
}
else
if (!_wcsnicmp( Field.Buffer, L"SAT", 3 )) {
FieldValue = 6;
}
else {
printf( "REGINI: %wZ invalid day of week\n", &Field );
return FALSE;
}
}
else {
Status = RtlUnicodeStringToInteger( &Field, 10, &FieldValue );
if (!NT_SUCCESS( Status )) {
return( FALSE );
}
}
Fields[ FieldIndexes[ CurrentField++ ] ] = (CSHORT)FieldValue;
}
if (DateTimeFields.Year == 0) {
if (DateTimeFields.Day > 5) {
printf( "REGINI: Day must be 0 - 5 if year is zero.\n" );
return FALSE;
}
}
else
if (DateTimeFields.Year < 100) {
DateTimeFields.Year += 1900;
}
*ValueBuffer = RtlAllocateHeap( RtlProcessHeap(), 0, sizeof( DateTimeFields ) );
*ValueLength = sizeof( DateTimeFields );
RtlMoveMemory( *ValueBuffer, &DateTimeFields, sizeof( DateTimeFields ) );
return TRUE;
}
else {
Status = RtlUnicodeStringToInteger( &KeyValue, 0, ValueLength );
if (!NT_SUCCESS( Status )) {
return( FALSE );
}
s = KeyValue.Buffer;
while (KeyValue.Length != 0 && *s > L' ') {
s++;
KeyValue.Length -= sizeof( WCHAR );
}
KeyValue.Buffer = s;
}
break;
case REG_MULTI_SZ:
*ValueLength = 0;
*ValueBuffer = RtlAllocateHeap( RtlProcessHeap(), 0, KeyValue.Length + sizeof( UNICODE_NULL ) );
while (RegGetMultiString(&KeyValue, &MultiValue)) {
RtlMoveMemory( (PUCHAR)*ValueBuffer + *ValueLength,
MultiValue.Buffer,
MultiValue.Length );
*ValueLength += MultiValue.Length;
((PWSTR)*ValueBuffer)[ *ValueLength / sizeof(WCHAR) ] = UNICODE_NULL;
*ValueLength += sizeof(UNICODE_NULL);
}
((PWSTR)*ValueBuffer)[ *ValueLength / sizeof(WCHAR) ] = UNICODE_NULL;
*ValueLength += sizeof(UNICODE_NULL);
return( TRUE );
default:
return( FALSE );
}
*ValueBuffer = RtlAllocateHeap( RtlProcessHeap(), 0, *ValueLength );
p = *ValueBuffer;
n = (*ValueLength + sizeof( ULONG ) - 1) / sizeof( ULONG );
while (n--) {
if (KeyValue.Length == 0) {
if (!RegGetNextLine( UnicodeFile, &IndentAmount, &FirstEqual )) {
RtlFreeHeap( RtlProcessHeap(), 0, *ValueBuffer );
return( FALSE );
}
KeyValue.Buffer = UnicodeFile->BeginLine;
KeyValue.Length = (USHORT)
((PCHAR)UnicodeFile->EndOfLine - (PCHAR)UnicodeFile->BeginLine);
KeyValue.MaximumLength = KeyValue.Length;
}
s = KeyValue.Buffer;
while (KeyValue.Length != 0 && *s <= L' ') {
s++;
KeyValue.Length -= sizeof( WCHAR );
}
KeyValue.Buffer = s;
if (KeyValue.Length != 0) {
Status = RtlUnicodeStringToInteger( &KeyValue, 0, p );
if (!NT_SUCCESS( Status )) {
RtlFreeHeap( RtlProcessHeap(), 0, *ValueBuffer );
return( FALSE );
}
p++;
s = KeyValue.Buffer;
while (KeyValue.Length != 0 && *s > L' ') {
s++;
KeyValue.Length -= sizeof( WCHAR );
}
KeyValue.Buffer = s;
}
}
return( TRUE );
}
BOOLEAN
RtlPrefixUnicodeString(
IN PUNICODE_STRING String1,
IN PUNICODE_STRING String2,
IN BOOLEAN CaseInSensitive
)
/*++
Routine Description:
The RtlPrefixUnicodeString function determines if the String1
counted string parameter is a prefix of the String2 counted string
parameter.
The CaseInSensitive parameter specifies if case is to be ignored when
doing the comparison.
Arguments:
String1 - Pointer to the first unicode string.
String2 - Pointer to the second unicode string.
CaseInsensitive - TRUE if case should be ignored when doing the
comparison.
Return Value:
Boolean value that is TRUE if String1 equals a prefix of String2 and
FALSE otherwise.
--*/
{
PWSTR s1, s2;
ULONG n;
WCHAR c1, c2;
s1 = String1->Buffer;
s2 = String2->Buffer;
if (String2->Length < String1->Length) {
return( FALSE );
}
n = String1->Length / sizeof( c1 );
while (n) {
c1 = *s1++;
c2 = *s2++;
if (CaseInSensitive) {
c1 = upcase(c1);
c2 = upcase(c2);
}
if (c1 != c2) {
return( FALSE );
}
n--;
}
return( TRUE );
}
Reference in New Issue Copy Permalink