able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/ntos/config/test/editreg.c

3315 lines
76 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1991 Microsoft Corporation
Module Name:
editreg.c
Abstract:
This program acts as an interactive shell allowing a user to view
and manipulate the configuration registry. Also, it has some specific
commands for support of the NTFT component of the registry.
Author:
Mike Glass
Bob Rinne
Environment:
User process.
Notes:
The commands "disk", "fix", "restore" are commands that know where
the configuration information is for the NTFT component of the NT
system.
Revision History:
--*/
#include "cmp.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "ntdskreg.h"
#include "ntddft.h"
//
// Tempory stuff to get types and values to print in help.
//
PUCHAR TypeNames[] =
{
"REG_NONE",
"REG_SZ",
"REG_BINARY",
"REG_DWORD",
"REG_DWORD_LITTLE_ENDIAN",
"REG_DWORD_BIG_ENDIAN",
"REG_LINK",
"REG_MULTI_SZ",
"REG_RESOURCE_LIST",
NULL
};
ULONG TypeNumbers[] =
{
REG_NONE,
REG_SZ,
REG_BINARY,
REG_DWORD,
REG_DWORD_LITTLE_ENDIAN,
REG_DWORD_BIG_ENDIAN,
REG_LINK,
REG_MULTI_SZ,
REG_RESOURCE_LIST
};
//
// Special support for the driver load lists in the registry.
//
PUCHAR StartDescription[] =
{
"Boot loader",
"System",
"2",
"3",
//
// Anything above 3 is not loaded.
//
NULL
};
PUCHAR TypeDescription[] =
{
"System driver",
"File system",
"Service",
NULL
};
//
// Constants and defines.
//
#define WORK_BUFFER_SIZE 4096
//
// Amount to fudge when mallocing for strings.
//
#define FUDGE 8
//
// Registry base.
//
#define REGISTRY_BASE "\\REGISTRY\\MACHINE"
//
// Default type value when key value set.
//
#define DEFAULT_TYPE REG_SZ
//
// Base location for component descriptions of FT elements.
//
#define FT_REGISTRY_ROOT "\\REGISTRY\\MACHINE\\SYSTEM\\NTFT"
//
// Subkey name located in the FT_REGISTRY_ROOT for stripes.
//
#define FT_STRIPE_BASE "Stripe%d"
//
// Subkey name located in the FT_REGISTRY_ROOT for mirrors.
//
#define FT_MIRROR_BASE "Mirror%d"
//
// Subkey name located in the FT_REGISTRY_ROOT for volume sets.
//
#define FT_VOLSET_BASE "VolSet%d"
//
// Constants for the command values.
//
#define INVALID -1
#define DIR 0
#define CREATE 1
#define LIST 2
#define CHDIR 3
#define HELP 4
#define QUIT 5
#define DDEBUG 6
#define SETVALUE 7
#define DELKEY 8
#define DELVALUE 9
#define DIRLONG 10
#define INLONG 11
#define INSHORT 12
#define INBYTE 13
#define DUMP 14
#define DISKREG 15
#define FIXDISK 16
#define RESTORE 17
#define DRIVERS 18
#define ORPHAN 19
#define REGEN 20
#define INIT 21
#define MAKEFT 22
#define CTRL_C 0x03
//
// Table of recognized commands.
//
PUCHAR Commands[] = {
"dir",
"keys",
"lc",
"ls",
"create",
"set",
"unset",
"erase",
"delete",
"rm",
"list",
"values",
"display",
"cd",
"chdir",
"help",
"?",
"quit",
"exit",
"debug",
"longs",
"shorts",
"bytes",
"dump",
"disks",
"fix",
"restore",
"drivers",
"orphan",
"regenerate",
"initialize",
"makeft",
NULL
};
//
// Using the index from the match on the commands in Commands[], this
// table gives the proper command value to be executed. This allows
// for multiple entries in Commands[] for the same command code.
//
int CommandMap[] = {
DIRLONG,
DIR,
DIR,
DIR,
CREATE,
SETVALUE,
DELVALUE,
DELVALUE,
DELKEY,
DELKEY,
LIST,
LIST,
LIST,
CHDIR,
CHDIR,
HELP,
HELP,
QUIT,
QUIT,
DDEBUG,
INLONG,
INSHORT,
INBYTE,
DUMP,
DISKREG,
FIXDISK,
RESTORE,
DRIVERS,
ORPHAN,
REGEN,
INIT,
MAKEFT
};
//
// CommandHelp is an array of help strings for each of the commands.
// The array is indexed by the result of CommandMap[i] for the Commands[]
// array. This way the same help message will print for each of the
// commands aliases.
//
PUCHAR CommandHelp[] = {
"Displays keys.",
"Create a new key.",
"Displays values withing a key.",
"Change current location in registry.",
"This help information.",
"Exit the program.",
"Set internal debug on for this program.",
"Set a new value within a key.",
"Delete a key.",
"Unset (erase) a key value.",
"Unset (erase) a key value.",
"Change dump format to Longs (default).",
"Change dump format to Shorts.",
"Change dump format to Bytes.",
"Toggle dump mode (force hex dump for all value types).",
"Display the disk registry.",
"Set disk signatures in registry.",
"Restore an FT orphan to working state.",
"List the information on the drivers from the registry.",
"Orphan a member of an FT set.",
"Mark a FT set member for regeneration on next boot.",
"Mark a stripe with parity for initialization on next boot.",
"Construct an FT set from existing partitions",
NULL
};
//
// Space for working location string in registry.
//
UCHAR WorkingDirectory[512];
//
// Space for current location string in registry.
//
UCHAR CurrentDirectory[512];
//
// Space for command input.
//
UCHAR CommandLine[512];
//
// Prompt strings for getting definition for an FT_COPY request.
//
PUCHAR SetPrompts[] = {
"Name => ",
"Value => ",
"Index => ",
NULL
};
//
// Version indicator. Should be changed every time a major edit occurs.
//
PUCHAR Version = "Version 1.30";
//
// Debug print level.
//
ULONG Debug = 0;
//
// Dump control values.
//
typedef enum _DUMP_CONTROL {
InBytes,
InShorts,
InLongs
} DUMP_CONTROL, *PDUMP_CONTROL;
ULONG ForceDump = 0;
DUMP_CONTROL DumpControl = InLongs;
NTSTATUS
FtOpenKey(
PHANDLE HandlePtr,
PUCHAR KeyName
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
NTSTATUS status;
STRING keyString;
OBJECT_ATTRIBUTES objectAttributes;
UNICODE_STRING unicodeKeyName;
RtlInitString(&keyString,
KeyName);
(VOID)RtlAnsiStringToUnicodeString(&unicodeKeyName,
&keyString,
(BOOLEAN) TRUE);
memset(&objectAttributes, 0, sizeof(OBJECT_ATTRIBUTES));
InitializeObjectAttributes(&objectAttributes,
&unicodeKeyName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
status = NtOpenKey(HandlePtr,
MAXIMUM_ALLOWED,
&objectAttributes);
RtlFreeUnicodeString(&unicodeKeyName);
if (Debug == 1) {
if (!NT_SUCCESS(status)) {
printf("Failed NtOpenKey for %s => %x\n",
KeyName,
status);
}
}
return status;
}
NTSTATUS
FtDeleteKey(
PUCHAR KeyName
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
NTSTATUS status;
HANDLE keyToDelete;
status = FtOpenKey(&keyToDelete,
KeyName);
if (!NT_SUCCESS(status)) {
printf("Key %s not found (0x%x).\n", KeyName, status);
return status;
}
status = NtDeleteKey(keyToDelete);
if (Debug == 1) {
if (!NT_SUCCESS(status)) {
printf("Could not delete key %s => %x\n",
KeyName,
status);
}
}
NtClose(keyToDelete);
return status;
}
NTSTATUS
FtCreateKey(
PUCHAR KeyName,
PUCHAR KeyClass,
ULONG Index
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
NTSTATUS status;
STRING keyString;
UNICODE_STRING unicodeKeyName;
STRING classString;
UNICODE_STRING unicodeClassName;
OBJECT_ATTRIBUTES objectAttributes;
ULONG disposition;
HANDLE tempHandle;
#if DBG
if ((KeyName == NULL) ||
(KeyClass == NULL)) {
printf("FtCreateKey: Invalid parameter 0x%x, 0x%x\n",
KeyName,
KeyClass);
ASSERT(0);
}
#endif
//
// Initialize the object for the key.
//
RtlInitString(&keyString,
KeyName);
(VOID)RtlAnsiStringToUnicodeString(&unicodeKeyName,
&keyString,
(BOOLEAN) TRUE);
memset(&objectAttributes, 0, sizeof(OBJECT_ATTRIBUTES));
InitializeObjectAttributes(&objectAttributes,
&unicodeKeyName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
//
// Setup the unicode class value.
//
RtlInitString(&classString,
KeyClass);
(VOID)RtlAnsiStringToUnicodeString(&unicodeClassName,
&classString,
(BOOLEAN) TRUE);
//
// Create the key.
//
status = NtCreateKey(&tempHandle,
MAXIMUM_ALLOWED,
&objectAttributes,
Index,
&unicodeClassName,
REG_OPTION_NON_VOLATILE,
&disposition);
if (NT_SUCCESS(status)) {
switch (disposition)
{
case REG_CREATED_NEW_KEY:
break;
case REG_OPENED_EXISTING_KEY:
printf("Warning: Creation was for an existing key!\n");
break;
default:
printf("New disposition returned == 0x%x\n", disposition);
break;
}
}
//
// Free all allocated space.
//
RtlFreeUnicodeString(&unicodeKeyName);
RtlFreeUnicodeString(&unicodeClassName);
NtClose(tempHandle);
return status;
}
NTSTATUS
FtDeleteValue(
HANDLE KeyHandle,
PUCHAR ValueName
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
NTSTATUS status;
STRING valueString;
UNICODE_STRING unicodeValueName;
RtlInitString(&valueString,
ValueName);
status = RtlAnsiStringToUnicodeString(&unicodeValueName,
&valueString,
(BOOLEAN) TRUE);
if (!NT_SUCCESS(status)) {
printf("FtDeleteValue: internal conversion error 0x%x\n", status);
return status;
}
status = NtDeleteValueKey(KeyHandle,
&unicodeValueName);
if (Debug == 1) {
if (!NT_SUCCESS(status)) {
printf("Could not delete value %s => %x\n",
ValueName,
status);
}
}
RtlFreeUnicodeString(&unicodeValueName);
return status;
}
NTSTATUS
FtSetValue(
HANDLE KeyHandle,
PUCHAR ValueName,
PVOID DataBuffer,
ULONG DataLength,
ULONG Type
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
NTSTATUS status;
STRING valueString;
UNICODE_STRING unicodeValueName;
RtlInitString(&valueString,
ValueName);
RtlAnsiStringToUnicodeString(&unicodeValueName,
&valueString,
(BOOLEAN) TRUE);
status = NtSetValueKey(KeyHandle,
&unicodeValueName,
0,
Type,
DataBuffer,
DataLength);
if (Debug == 1) {
if (!NT_SUCCESS(status)) {
printf("Could not set value %s => %x\n",
ValueName,
status);
}
}
RtlFreeUnicodeString(&unicodeValueName);
return status;
}
PUCHAR
FindTypeString(
ULONG Type
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
int i;
for (i = 0; TypeNames[i] != NULL; i++) {
if (TypeNumbers[i] == Type) {
return TypeNames[i];
}
}
return "(Unknown)";
}
BOOLEAN
ProcessHex(
PUCHAR String,
PULONG Value
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
ULONG workValue;
int i;
PUCHAR cp;
if (String == NULL) {
return FALSE;
}
cp = String;
//
// 'i' is an index value. It contains the maximum index into the String.
// Therefore it is initialized to -1.
//
i = -1;
while ((*cp) && (*cp != '\n')) {
i++;
cp++;
}
if (i >= 8) {
//
// String to long for a long.
//
return FALSE;
}
workValue = 0;
cp = String;
while (*cp) {
*cp = (UCHAR) tolower(*cp);
switch (*cp) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
workValue |= (((*cp) - '0') << (i * 4));
break;
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
workValue |= ((((*cp) - 'a') + 10) << (i * 4));
break;
default:
//
// Illegal value, just punt.
//
return FALSE;
break;
}
cp++;
i--;
}
*Value = workValue;
return TRUE;
}
VOID
Dump(
PVOID Buffer,
ULONG Length
)
/*++
Routine Description:
Dump the value data from a buffer in the format specified.
Arguments:
Buffer - pointer to the data.
Length - length of the data.
Return Value:
None.
--*/
{
PUCHAR location;
PUCHAR internalBuffer;
int i;
int j;
int numberLines;
UCHAR outHexLine[128];
UCHAR outPrintable[64];
numberLines = (Length + 15) / 16;
//
// Since the amount of data displayed has been rounded up, this
// routine mallocs enough space and copies the data in. This way
// it won't fault if the data is at the end of memory.
//
internalBuffer = (PUCHAR) malloc(numberLines * 16);
RtlMoveMemory(internalBuffer, Buffer, Length);
location = (PUCHAR) internalBuffer;
for (i = 0; i < numberLines; i++) {
sprintf(outHexLine, "%8x: ", (i * 16));
sprintf(outPrintable, "*");
switch (DumpControl) {
case InBytes:
for (j = 0; j < 16; j++) {
sprintf(outHexLine, "%s%2X ", outHexLine, *location);
sprintf(outPrintable, "%s%c", outPrintable,
(isprint(location[0])) ? location[0] : '.');
location++;
}
break;
case InShorts:
for (j = 0; j < 8; j++) {
sprintf(outHexLine, "%s%4X ", outHexLine,
*((PUSHORT)location));
sprintf(outPrintable, "%s%c%c", outPrintable,
(isprint(location[0])) ? location[0] : '.',
(isprint(location[1])) ? location[1] : '.');
location += 2;
}
break;
default:
case InLongs:
for (j = 0; j < 4; j++) {
sprintf(outHexLine, "%s%8X ", outHexLine,
*((PULONG)location));
sprintf(outPrintable, "%s%c%c%c%c", outPrintable,
(isprint(location[0])) ? location[0] : '.',
(isprint(location[1])) ? location[1] : '.',
(isprint(location[2])) ? location[2] : '.',
(isprint(location[3])) ? location[3] : '.');
location += 4;
}
break;
}
printf("%s %s*\n", outHexLine, outPrintable);
}
printf("\n");
free(internalBuffer);
}
void
UnicodePrint(
PUNICODE_STRING UnicodeString
)
/*++
Routine Description:
Print a unicode string.
Arguments:
UnicodeString - pointer to the string.
Return Value:
None.
--*/
{
ANSI_STRING ansiString;
PUCHAR tempbuffer = (PUCHAR) malloc(WORK_BUFFER_SIZE);
ansiString.MaximumLength = WORK_BUFFER_SIZE;
ansiString.Length = 0L;
ansiString.Buffer = tempbuffer;
RtlUnicodeStringToAnsiString(&ansiString,
UnicodeString,
(BOOLEAN) FALSE);
printf("%s", ansiString.Buffer);
free(tempbuffer);
return;
}
NTSTATUS
Directory(
HANDLE KeyHandle,
BOOLEAN LongListing
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
NTSTATUS status;
ULONG index;
ULONG resultLength;
UNICODE_STRING unicodeValueName;
PKEY_BASIC_INFORMATION keyInformation;
keyInformation = (PKEY_BASIC_INFORMATION) malloc(WORK_BUFFER_SIZE);
for (index = 0; TRUE; index++) {
RtlZeroMemory(keyInformation, WORK_BUFFER_SIZE);
status = NtEnumerateKey(KeyHandle,
index,
KeyBasicInformation,
keyInformation,
WORK_BUFFER_SIZE,
&resultLength);
if (status == STATUS_NO_MORE_ENTRIES) {
break;
} else if (!NT_SUCCESS(status)) {
printf("readreg: Error on Enumerate status = %x\n", status);
break;
}
unicodeValueName.Length = (USHORT)keyInformation->NameLength;
unicodeValueName.MaximumLength = (USHORT)keyInformation->NameLength;
unicodeValueName.Buffer = (PWSTR)&keyInformation->Name[0];
UnicodePrint(&unicodeValueName);
printf("\n");
if (LongListing) {
}
}
free(keyInformation);
return status;
}
NTSTATUS
List(
HANDLE KeyHandle,
PUCHAR ItemName
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
NTSTATUS status;
ULONG index;
ULONG resultLength;
ULONG type;
PUCHAR typeString;
UNICODE_STRING unicodeValueName;
PKEY_VALUE_FULL_INFORMATION keyValueInformation;
UNREFERENCED_PARAMETER(ItemName);
resultLength = WORK_BUFFER_SIZE;
keyValueInformation = (PKEY_VALUE_FULL_INFORMATION)malloc(WORK_BUFFER_SIZE);
for (index = 0; TRUE; index++) {
while (1) {
RtlZeroMemory(keyValueInformation, resultLength);
status = NtEnumerateValueKey(KeyHandle,
index,
KeyValueFullInformation,
keyValueInformation,
resultLength,
&resultLength);
if (status == STATUS_BUFFER_OVERFLOW) {
free(keyValueInformation);
keyValueInformation = (PKEY_VALUE_FULL_INFORMATION)
malloc(resultLength + 10);
} else {
break;
}
}
if (status == STATUS_NO_MORE_ENTRIES) {
break;
} else if (!NT_SUCCESS(status)) {
printf("readreg: Cannot list (%x)\n", status);
break;
}
type = keyValueInformation->Type;
typeString = FindTypeString(type);
unicodeValueName.Length = (USHORT)keyValueInformation->NameLength;
unicodeValueName.MaximumLength =(USHORT)keyValueInformation->NameLength;
unicodeValueName.Buffer = (PWSTR)&keyValueInformation->Name[0];
printf("Name-> """);
UnicodePrint(&unicodeValueName);
printf("""\n");
printf("\ttype = %s (%d)\ttitle index = %d\tdata length = %d\n",
typeString,
type,
keyValueInformation->TitleIndex,
keyValueInformation->DataLength);
printf("\tData:\n");
if (ForceDump) {
type = REG_BINARY;
}
switch (type) {
case REG_DWORD:
// case REG_DWORD_LITTLE_ENDIAN:
printf("\tDWORD value == %d, (0x%x)\n",
*((PULONG)((PUCHAR)keyValueInformation +
keyValueInformation->DataOffset)),
*((PULONG)((PUCHAR)keyValueInformation +
keyValueInformation->DataOffset)));
break;
case REG_SZ:
unicodeValueName.Length = (USHORT)keyValueInformation->DataLength;
unicodeValueName.MaximumLength = (USHORT)
keyValueInformation->DataLength;
unicodeValueName.Buffer = (PWSTR) ((PUCHAR) keyValueInformation +
keyValueInformation->DataOffset);
UnicodePrint(&unicodeValueName);
break;
case REG_BINARY:
default:
Dump(((PUCHAR)keyValueInformation +keyValueInformation->DataOffset),
keyValueInformation->DataLength);
}
printf("\n");
}
free(keyValueInformation);
return status;
}
UCHAR
GetCharacter(
BOOLEAN Batch
)
/*++
Routine Description:
This routine returns a single character from the input stream.
It discards leading blanks if the input is not from the console.
Arguments:
Batch - a boolean indicating if the input it coming from the console.
Return Value:
A character
--*/
{
UCHAR c;
if (Batch) {
while ((c = (UCHAR) getchar()) == ' ')
;
} else {
c = (UCHAR) getchar();
}
return c;
} // GetCharacter
PUCHAR
GetArgumentString(
BOOLEAN Batch,
PUCHAR Prompt,
BOOLEAN ConvertToLower
)
/*++
Routine Description:
This routine prints the prompt if the input is coming from the console,
then proceeds to collect the user input until a carraige return is typed.
Arguments:
Batch - a boolean indicating if the input is coming from the console.
Prompt - String to prompt with.
Return Value:
A pointer to the input string.
NULL if the user escaped.
--*/
{
//
// The command line data area is used to store the argument string.
//
PUCHAR argument = CommandLine;
int i;
UCHAR c;
if (!Batch) {
printf("%s", Prompt);
}
while ((c = GetCharacter(Batch)) == ' ') {
//
// Ignore leading spaces.
//
}
i = 0;
while (c) {
putchar(c);
if (c == CTRL_C) {
return NULL;
}
if ((c == '\n') || (c == '\r')) {
putchar('\n');
if (i == 0) {
return NULL;
} else {
break;
}
}
if (c == '\b') {
if (i > 0) {
//
// blank over last char
//
putchar(' ');
putchar('\b');
i--;
} else {
//
// space forward to keep prompt in the same place.
//
putchar(' ');
}
} else {
//
// Collect the argument.
//
if (ConvertToLower == TRUE) {
argument[i] = (UCHAR) tolower(c);
} else {
argument[i] = (UCHAR) c;
}
i++;
}
c = GetCharacter(Batch);
}
argument[i] = '\0';
return CommandLine;
} // GetArgumentString
ULONG
ParseArgumentNumeric(
PUCHAR *ArgumentPtr
)
/*++
Routine Description:
This routine prints the prompt if the input is coming from the console.
Arguments:
Batch - a boolean indicating if the input is coming from the console.
Return Value:
None
--*/
{
UCHAR c;
ULONG number;
int i;
BOOLEAN complete = FALSE;
PUCHAR argument = *ArgumentPtr;
while (*argument == ' ') {
//
// skip spaces.
//
argument++;
}
//
// Assume there is only one option to parse until proven
// otherwise.
//
*ArgumentPtr = NULL;
i = 0;
while (complete == FALSE) {
c = argument[i];
switch (c) {
case '\n':
case '\r':
case '\t':
case ' ':
//
// Update the caller argument pointer to the remaining string.
//
*ArgumentPtr = &argument[i + 1];
//
// fall through.
//
case '\0':
argument[i] = '\0';
complete = TRUE;
break;
default:
i++;
break;
}
}
if (i > 0) {
number = (ULONG) atoi(argument);
} else {
number = (ULONG) -1;
}
return number;
} // ParseArgumentNumeric
VOID
PromptUser(
BOOLEAN Batch
)
/*++
Routine Description:
This routine prints the prompt if the input is coming from the console.
Arguments:
Batch - a boolean indicating if the input is coming from the console.
Return Value:
None
--*/
{
if (!Batch) {
printf("\n%s> ", CurrentDirectory);
}
} // PromptUser
int
GetCommand(
BOOLEAN Batch,
PUCHAR *ArgumentPtr
)
/*++
Routine Description:
This routine processes the user input and returns the code for the
command entered. If the command has an argument, either the default
value for the argument (if none is given) or the value provided by the
user is returned.
Arguments:
Batch - a boolean indicating if the input it coming from the console.
Return Value:
A command code
--*/
{
int i;
int commandIndex;
int commandCode;
UCHAR c;
PUCHAR commandPtr;
PUCHAR command = CommandLine;
int argumentIndex = -1;
PUCHAR argument = NULL;
PromptUser(Batch);
while ((c = GetCharacter(Batch)) == ' ') {
//
// Ignore leading spaces.
//
}
i = 0;
while (c) {
putchar(c);
if ((c == '\n') || (c == '\r')) {
putchar('\n');
if (i == 0) {
PromptUser(Batch);
c = GetCharacter(Batch);
continue;
}
break;
}
if (c == '\b') {
if (i > 0) {
//
// blank over last char
//
putchar(' ');
putchar('\b');
i--;
if (argumentIndex == i) {
argumentIndex = -1;
argument = NULL;
}
} else {
//
// space forward to keep prompt in the same place.
//
putchar(' ');
}
} else {
//
// Collect the command.
//
command[i] = (UCHAR)tolower(c);
i++;
}
if ((c == ' ') && (argument == NULL)) {
argument = &command[i];
argumentIndex = i;
command[i - 1] = '\0';
}
c = GetCharacter(Batch);
}
//
// add end of string.
//
command[i] = '\0';
if (Debug) {
printf("command => %s$\n", command);
}
//
// Identify the command and return its code.
//
commandIndex = 0;
for (commandPtr = Commands[commandIndex];
commandPtr != NULL;
commandPtr = Commands[commandIndex]) {
if (Debug) {
printf("Testing => %s$ ... ", commandPtr);
}
i = 0;
while (commandPtr[i] == command[i]) {
if (command[i] == '\0') {
break;
}
i++;
}
if (Debug) {
printf(" i == %d, command[i] == 0x%x\n", i, command[i]);
}
if (command[i]) {
//
// Not complete there was a mismatch on the command.
//
commandIndex++;
continue;
}
//
// Have a match on the command.
//
if (Debug) {
printf("Command match %d, argument %s\n",
commandIndex,
(argument == NULL) ? "(none)" : argument);
}
commandCode = CommandMap[commandIndex];
*ArgumentPtr = argument;
return commandCode;
}
printf("Command was invalid\n");
return INVALID;
} // GetCommand
VOID
NotImplemented()
/*++
--*/
{
printf("Sorry, function not implemented yet.\n");
}
NTSTATUS
FtReturnValue(
IN HANDLE Handle,
IN PUCHAR ValueName,
IN PUCHAR Buffer,
IN ULONG BufferLength
)
/*++
Routine Description:
Formatted display of the disk registry information.
Arguments:
None.
Return Values:
None.
--*/
{
NTSTATUS status;
ULONG resultLength;
ULONG length;
STRING valueString;
UNICODE_STRING unicodeValueName;
PUCHAR internalBuffer;
PKEY_VALUE_FULL_INFORMATION keyValueInformation;
keyValueInformation = (PKEY_VALUE_FULL_INFORMATION)malloc(WORK_BUFFER_SIZE);
if (keyValueInformation == NULL) {
printf("FtReturnValue: cannot allocate memory.\n");
return STATUS_NO_MEMORY;
}
RtlInitString(&valueString,
ValueName);
RtlAnsiStringToUnicodeString(&unicodeValueName,
&valueString,
(BOOLEAN) TRUE);
status = NtQueryValueKey(Handle,
&unicodeValueName,
KeyValueFullInformation,
keyValueInformation,
WORK_BUFFER_SIZE,
&resultLength);
RtlFreeUnicodeString(&unicodeValueName);
if (NT_SUCCESS(status)) {
length = (resultLength > BufferLength) ? BufferLength : resultLength;
internalBuffer =
((PUCHAR)keyValueInformation + keyValueInformation->DataOffset);
RtlMoveMemory(Buffer, internalBuffer, length);
}
free(keyValueInformation);
return status;
}
VOID
DiskDump()
/*++
Routine Description:
Formatted display of the disk registry information.
Arguments:
None.
Return Values:
None.
--*/
{
ULONG outerLoop;
ULONG innerLoop;
HANDLE handle;
NTSTATUS status;
PDISK_CONFIG_HEADER configHeader;
PDISK_REGISTRY diskRegistry;
PDISK_DESCRIPTION diskDescription;
PDISK_PARTITION diskPartition;
PFT_REGISTRY ftRegistry;
PFT_DESCRIPTION ftDescription;
PFT_MEMBER_DESCRIPTION ftMember;
status = FtOpenKey(&handle,
DISK_REGISTRY_KEY);
if (!NT_SUCCESS(status)) {
printf("Currently there is no key in the registry"
" for the disk information.\n");
return;
}
configHeader = (PDISK_CONFIG_HEADER) malloc(WORK_BUFFER_SIZE);
if (configHeader == NULL) {
printf("Unable to allocate memory for the disk registy information.\n");
return;
}
RtlZeroMemory(configHeader, WORK_BUFFER_SIZE);
status = FtReturnValue(handle,
(PUCHAR) DISK_REGISTRY_VALUE,
(PUCHAR) configHeader,
WORK_BUFFER_SIZE);
NtClose(handle);
if (!NT_SUCCESS(status)) {
printf("There is no disk registry information (%x)\n", status);
free(configHeader);
return;
}
//
// Print the header.
//
printf("Registry header information:\n");
printf("\tVersion = 0x%x, Checksum = 0x%x\n",
configHeader->Version,
configHeader->CheckSum);
printf("\tDisk info Offset = 0x%x, Size = 0x%x\n",
configHeader->DiskInformationOffset,
configHeader->DiskInformationSize);
printf("\tFT info Offset = 0x%x, Size = 0x%x\n",
configHeader->FtInformationOffset,
configHeader->FtInformationSize);
//
// Print the information on disks.
//
diskRegistry = (PDISK_REGISTRY)
((PUCHAR) configHeader + configHeader->DiskInformationOffset);
printf("\nDisk information for %d disks:\n",
diskRegistry->NumberOfDisks);
diskDescription = &diskRegistry->Disks[0];
for (outerLoop = 0;
outerLoop < diskRegistry->NumberOfDisks;
outerLoop++) {
printf("\nDisk %d signature 0x%08x has %d partitions:\n",
outerLoop,
diskDescription->Signature,
diskDescription->NumberOfPartitions);
printf(" Ln Type Start Length FtGrp Member\n");
for (innerLoop = 0;
innerLoop < diskDescription->NumberOfPartitions;
innerLoop++) {
diskPartition = &diskDescription->Partitions[innerLoop];
printf(" %c: %c %1d %3d %08x:%08x %08x:%08x %5d %4d %s\n",
(diskPartition->DriveLetter != '\0') ?
diskPartition->DriveLetter : ' ',
(diskPartition->AssignDriveLetter) ? 'A' : ' ',
diskPartition->LogicalNumber,
diskPartition->FtType,
diskPartition->StartingOffset.HighPart,
diskPartition->StartingOffset.LowPart,
diskPartition->Length.HighPart,
diskPartition->Length.LowPart,
diskPartition->FtGroup,
diskPartition->FtMember,
(diskPartition->FtState == Orphaned) ? "Orphan" :
(diskPartition->FtState == Regenerating) ? "Regen" :
(diskPartition->FtState == Initializing) ? "Init" : "");
}
diskDescription = (PDISK_DESCRIPTION)
&diskDescription->Partitions[diskDescription->NumberOfPartitions];
}
//
// Print the information for FT.
//
if (configHeader->FtInformationSize == 0) {
printf("There is no FT configuration.\n");
free(configHeader);
return;
}
ftRegistry = (PFT_REGISTRY)
((PUCHAR) configHeader + configHeader->FtInformationOffset);
printf("\nNumber of FT components = %d\n",
ftRegistry->NumberOfComponents);
ftDescription = &ftRegistry->FtDescription[0];
for (outerLoop = 0;
outerLoop < ftRegistry->NumberOfComponents;
outerLoop++) {
printf("Component %d has %d members and is type %d\n",
outerLoop,
ftDescription->NumberOfMembers,
ftDescription->Type);
printf(" State Signature Start Length #\n");
for (innerLoop = 0;
innerLoop < ftDescription->NumberOfMembers;
innerLoop++) {
ftMember = &ftDescription->FtMemberDescription[innerLoop];
diskPartition = (PDISK_PARTITION)
((PUCHAR) configHeader + ftMember->OffsetToPartitionInfo);
printf("%5x %2x %08x %08x:%08x %08x:%08x %d\n",
ftMember->OffsetToPartitionInfo,
ftMember->State,
ftMember->Signature,
diskPartition->StartingOffset.HighPart,
diskPartition->StartingOffset.LowPart,
diskPartition->Length.HighPart,
diskPartition->Length.LowPart,
ftMember->LogicalNumber);
}
ftDescription = (PFT_DESCRIPTION)
&ftDescription->FtMemberDescription[ftDescription->NumberOfMembers];
}
}
VOID
ChangeMemberState(
IN ULONG Type,
IN ULONG Group,
IN ULONG Member,
IN FT_PARTITION_STATE NewState
)
/*++
Routine Description:
Set the FT state for a partition.
Arguments:
Type - the FT type.
Group - the FT Group number for that type.
Member - the member number within the group.
Return Values:
None.
--*/
{
BOOLEAN writeBackRegistry = FALSE;
HANDLE handle;
ULONG outerLoop;
ULONG innerLoop;
NTSTATUS status;
PDISK_CONFIG_HEADER configHeader;
PDISK_REGISTRY diskRegistry;
PDISK_DESCRIPTION diskDescription;
PDISK_PARTITION partitionDescription;
status = FtOpenKey(&handle,
DISK_REGISTRY_KEY);
if (!NT_SUCCESS(status)) {
printf("Currently there is no key in the registry"
" for the disk information.\n");
return;
}
configHeader = (PDISK_CONFIG_HEADER) malloc(WORK_BUFFER_SIZE);
if (configHeader == NULL) {
printf("Unable to allocate memory for the disk registy information.\n");
NtClose(handle);
return;
}
RtlZeroMemory(configHeader, WORK_BUFFER_SIZE);
status = FtReturnValue(handle,
(PUCHAR) DISK_REGISTRY_VALUE,
(PUCHAR) configHeader,
WORK_BUFFER_SIZE);
if (!NT_SUCCESS(status)) {
printf("There is no disk registry information (%x)\n", status);
free(configHeader);
NtClose(handle);
return;
}
diskRegistry = (PDISK_REGISTRY)
((PUCHAR) configHeader + configHeader->DiskInformationOffset);
diskDescription = &diskRegistry->Disks[0];
for (outerLoop = 0;
outerLoop < diskRegistry->NumberOfDisks;
outerLoop++) {
for (innerLoop = 0;
innerLoop < diskDescription->NumberOfPartitions;
innerLoop++) {
partitionDescription = &diskDescription->Partitions[innerLoop];
if ((partitionDescription->FtType == (FT_TYPE) Type) &&
(partitionDescription->FtGroup == (USHORT) Group) &&
(partitionDescription->FtMember == (USHORT) Member)) {
partitionDescription->FtState = NewState;
writeBackRegistry = TRUE;
break;
}
}
if (writeBackRegistry == TRUE) {
ULONG size;
if (configHeader->FtInformationSize == 0) {
printf("Seems a little odd to be setting FT state " // no comma
"with no FT information...\n");
size = configHeader->DiskInformationOffset +
configHeader->DiskInformationSize;
} else {
size = configHeader->FtInformationOffset +
configHeader->FtInformationSize;
}
(VOID) FtSetValue(handle,
(PUCHAR) DISK_REGISTRY_VALUE,
(PUCHAR) configHeader,
size,
REG_BINARY);
break;
}
diskDescription = (PDISK_DESCRIPTION)
&diskDescription->Partitions[diskDescription->NumberOfPartitions];
}
NtClose(handle);
free(configHeader);
}
VOID
RestoreOrphan(
IN ULONG Type,
IN ULONG Group,
IN ULONG Member
)
/*++
Routine Description:
Set the FT state for a partition back to Healthy.
Arguments:
Type - the FT type.
Group - the FT Group number for that type.
Member - the member number within the group.
Return Values:
None.
--*/
{
ChangeMemberState(Type,
Group,
Member,
Healthy);
}
VOID
OrphanMember(
IN ULONG Type,
IN ULONG Group,
IN ULONG Member
)
/*++
Routine Description:
Set the FT state for a partition to Orphaned.
Arguments:
Type - the FT type.
Group - the FT Group number for that type.
Member - the member number within the group.
Return Values:
None.
--*/
{
ChangeMemberState(Type,
Group,
Member,
Orphaned);
}
VOID
RegenerateMember(
IN ULONG Type,
IN ULONG Group,
IN ULONG Member
)
/*++
Routine Description:
Set the FT state for a partition to regenerate.
Arguments:
Type - the FT type.
Group - the FT Group number for that type.
Member - the member number within the group.
Return Values:
None.
--*/
{
ChangeMemberState(Type,
Group,
Member,
Regenerating);
}
VOID
FixDisk()
/*++
Routine Description:
Fix the disk signatures in the registry.
Arguments:
None.
Return Values:
None.
--*/
{
ULONG outerLoop;
ULONG innerLoop;
ULONG length;
HANDLE handle;
NTSTATUS status;
PDISK_CONFIG_HEADER configHeader;
PDISK_REGISTRY diskRegistry;
PDISK_DESCRIPTION diskDescription;
PFT_REGISTRY ftRegistry;
PFT_DESCRIPTION ftDescription;
PFT_MEMBER_DESCRIPTION ftMember;
UCHAR prompt[128];
PUCHAR hexString;
BOOLEAN changed = FALSE;
status = FtOpenKey(&handle,
DISK_REGISTRY_KEY);
if (!NT_SUCCESS(status)) {
printf("Currently there is no key in the registry"
" for the disk information.\n");
return;
}
configHeader = (PDISK_CONFIG_HEADER) malloc(WORK_BUFFER_SIZE);
if (configHeader == NULL) {
printf("Unable to allocate memory for the disk registy information.\n");
NtClose(handle);
return;
}
RtlZeroMemory(configHeader, WORK_BUFFER_SIZE);
status = FtReturnValue(handle,
(PUCHAR) DISK_REGISTRY_VALUE,
(PUCHAR) configHeader,
WORK_BUFFER_SIZE);
if (!NT_SUCCESS(status)) {
printf("There is no disk registry information (%x)\n", status);
free(configHeader);
NtClose(handle);
return;
}
diskRegistry = (PDISK_REGISTRY)
((PUCHAR) configHeader + configHeader->DiskInformationOffset);
printf("\nDisk information for %d disks:\n",
diskRegistry->NumberOfDisks);
diskDescription = &diskRegistry->Disks[0];
for (outerLoop = 0;
outerLoop < diskRegistry->NumberOfDisks;
outerLoop++) {
sprintf(prompt,
"\nDisk %d signature 0x%08x = ",
outerLoop,
diskDescription->Signature);
hexString = GetArgumentString((BOOLEAN) FALSE,
prompt,
(BOOLEAN) TRUE);
if (hexString != NULL) {
changed = ProcessHex(hexString, &diskDescription->Signature);
}
diskDescription = (PDISK_DESCRIPTION)
&diskDescription->Partitions[diskDescription->NumberOfPartitions];
}
//
// Print the information for FT.
//
if (configHeader->FtInformationSize == 0) {
printf("There is no FT configuration.\n");
free(configHeader);
NtClose(handle);
return;
}
ftRegistry = (PFT_REGISTRY)
((PUCHAR) configHeader + configHeader->FtInformationOffset);
printf("\nNumber of FT components = %d\n",
ftRegistry->NumberOfComponents);
ftDescription = &ftRegistry->FtDescription[0];
for (outerLoop = 0;
outerLoop < ftRegistry->NumberOfComponents;
outerLoop++) {
printf("Component %d has %d members and is type %d\n",
outerLoop,
ftDescription->NumberOfMembers,
ftDescription->Type);
for (innerLoop = 0;
innerLoop < ftDescription->NumberOfMembers;
innerLoop++) {
ftMember = &ftDescription->FtMemberDescription[innerLoop];
sprintf(prompt,
"FT Member Signature 0x%x = ",
ftMember->Signature);
hexString = GetArgumentString((BOOLEAN) FALSE,
prompt,
(BOOLEAN) TRUE);
if (hexString != NULL) {
changed = ProcessHex(hexString, &ftMember->Signature);
}
}
ftDescription = (PFT_DESCRIPTION)
&ftDescription->FtMemberDescription[ftDescription->NumberOfMembers];
}
if (changed == TRUE) {
printf("Attempting to update registry information.\n");
//
// Delete the current registry value and write the new one.
//
status = FtDeleteValue(handle,
DISK_REGISTRY_VALUE);
if (!NT_SUCCESS(status)) {
printf("Could not delete value (0x%x).\n", status);
} else {
length = (ULONG) ((PCHAR)ftDescription - (PUCHAR)configHeader);
status = FtSetValue(handle,
DISK_REGISTRY_VALUE,
configHeader,
length,
REG_BINARY);
if (!NT_SUCCESS(status)) {
printf("Could not write value (0x%x)\n.", status);
}
}
}
NtClose(handle);
}
PDISK_CONFIG_HEADER
GetDiskInfo()
/*++
--*/
{
HANDLE handle;
ULONG length;
NTSTATUS status;
PDISK_CONFIG_HEADER configHeader;
status = FtOpenKey(&handle,
DISK_REGISTRY_KEY);
if (!NT_SUCCESS(status)) {
printf("Currently there is no key in the registry"
" for the disk information.\n");
return NULL;
}
configHeader = (PDISK_CONFIG_HEADER) malloc(WORK_BUFFER_SIZE);
if (configHeader == NULL) {
printf("Unable to allocate memory for the disk registy information.\n");
NtClose(handle);
return NULL;
}
RtlZeroMemory(configHeader, WORK_BUFFER_SIZE);
status = FtReturnValue(handle,
(PUCHAR) DISK_REGISTRY_VALUE,
(PUCHAR) configHeader,
WORK_BUFFER_SIZE);
NtClose(handle);
if (!NT_SUCCESS(status)) {
printf("There is no disk registry information (%x)\n", status);
free(configHeader);
return NULL;
}
return configHeader;
}
BOOLEAN
CreateFtMember(
IN PDISK_CONFIG_HEADER ConfigHeader,
IN ULONG Disk,
IN ULONG Partition,
IN ULONG Type,
IN ULONG Group,
IN ULONG Member
)
/*++
--*/
{
ULONG innerLoop;
ULONG outerLoop;
ULONG length;
NTSTATUS status;
PDISK_REGISTRY diskRegistry;
PDISK_DESCRIPTION diskDescription;
PDISK_PARTITION diskPartition;
diskRegistry = (PDISK_REGISTRY)
((PUCHAR) ConfigHeader + ConfigHeader->DiskInformationOffset);
diskDescription = &diskRegistry->Disks[0];
//
// Have to walk the disk information by hand to find a match on
// disk number and partition
//
for (outerLoop = 0;
outerLoop < diskRegistry->NumberOfDisks;
outerLoop++) {
if (outerLoop == Disk) {
for (innerLoop = 0;
innerLoop < diskDescription->NumberOfPartitions;
innerLoop++) {
diskPartition = &diskDescription->Partitions[innerLoop];
if (diskPartition->LogicalNumber == Partition) {
//
// Found a match.
//
diskPartition->FtType = Type;
diskPartition->FtMember = Member;
diskPartition->FtGroup = Group;
diskPartition->FtState = Healthy;
diskPartition->AssignDriveLetter = FALSE;
return TRUE;
}
}
}
diskDescription = (PDISK_DESCRIPTION)
&diskDescription->Partitions[diskDescription->NumberOfPartitions];
}
//
// Didn't find it.
//
return FALSE;
}
#define DRIVER_KEY "\\REGISTRY\\MACHINE\\System\\CurrentControlSet\\Services"
#define TYPE_KEY "Type"
#define START_KEY "Start"
#define GROUP_KEY "Group"
#define DEPENDENCIES "DependOnGroup"
#if 0
VOID
DisplayLoadInformation(
IN PUNICODE_STRING DriverKey
)
/*++
Routine Description:
Arguments:
DriverKey - a Unicode string pointer for the driver key name.
Return Value:
None.
--*/
{
HANDLE keyHandle;
UNICODE_STRING unicodeKeyName;
UNICODE_STRING unicodeValueName;
ULONG resultLength;
PKEY_VALUE_FULL_INFORMATION keyValueInformation;
resultLength = WORK_BUFFER_SIZE;
keyValueInformation = (PKEY_VALUE_FULL_INFORMATION)malloc(WORK_BUFFER_SIZE);
//
// Type
//
//
// Start
//
//
// Group
//
//
// DependOnGroup
//
while (1) {
RtlZeroMemory(keyValueInformation, resultLength);
status = NtEnumerateValueKey(KeyHandle,
0,
KeyValueFullInformation,
keyValueInformation,
resultLength,
&resultLength);
if (status == STATUS_BUFFER_OVERFLOW) {
free(keyValueInformation);
keyValueInformation = (PKEY_VALUE_FULL_INFORMATION)
malloc(resultLength + 10);
} else {
break;
}
}
free(keyValueInformation);
NtClose(keyHandle);
}
#else
VOID
DisplayLoadInformation(
IN PUCHAR DriverKey
)
{
UNREFERENCED_PARAMETER(DriverKey);
}
#endif
#define TEMP_BUFFER_SIZE 256
VOID
ListDrivers()
/*++
Routine Description:
Got to the load list for the drivers, interpret and display what is there.
Arguments:
None.
Return Value:
NONE
--*/
{
int index;
NTSTATUS status;
HANDLE keyHandle;
ULONG resultLength;
UCHAR tempBuffer[TEMP_BUFFER_SIZE];
ANSI_STRING ansiString;
UNICODE_STRING unicodeValueName;
PKEY_BASIC_INFORMATION keyInformation;
keyInformation = (PKEY_BASIC_INFORMATION)malloc(WORK_BUFFER_SIZE);
status = FtOpenKey(&keyHandle, DRIVER_KEY);
if (!NT_SUCCESS(status)) {
printf("Could not open Services key (0x%x).\n", status);
return;
}
for (index = 0; TRUE; index++) {
RtlZeroMemory(keyInformation, WORK_BUFFER_SIZE);
status = NtEnumerateKey(keyHandle,
index,
KeyBasicInformation,
keyInformation,
WORK_BUFFER_SIZE,
&resultLength);
if (status == STATUS_NO_MORE_ENTRIES) {
break;
} else if (!NT_SUCCESS(status)) {
printf("readreg: Error on Enumerate status = %x\n", status);
break;
}
unicodeValueName.Length = (USHORT)keyInformation->NameLength;
unicodeValueName.MaximumLength = (USHORT)keyInformation->NameLength;
unicodeValueName.Buffer = (PWSTR)&keyInformation->Name[0];
ansiString.MaximumLength = TEMP_BUFFER_SIZE;
ansiString.Length = 0L;
ansiString.Buffer = &tempBuffer[0];
RtlUnicodeStringToAnsiString(&ansiString,
&unicodeValueName,
(BOOLEAN) FALSE);
//
// Now have the key name for the driver - concatenate it and
// call the routine to display what is in the key.
//
sprintf(WorkingDirectory,
"%s\\%s",
DRIVER_KEY,
tempBuffer);
DisplayLoadInformation(WorkingDirectory);
}
free(keyInformation);
NtClose(keyHandle);
}
VOID
main()
/*++
Routine Description:
The main entry point for the user process.
This process will prompt the user for the action desired. This
includes starting performance, stopping performance, and retreiving
performance data collected by the FT driver.
Arguments:
Command line:
No options.
Return Value:
NONE
--*/
{
NTSTATUS status;
BOOLEAN batch;
PUCHAR argumentString;
int commandCode;
HANDLE keyHandle;
status = FtOpenKey(&keyHandle, REGISTRY_BASE);
if (!NT_SUCCESS(status)) {
printf("readreg: Unable to open registry base (0x%x)\n", status);
exit(1);
}
sprintf(CurrentDirectory,
REGISTRY_BASE);
//
// See if we are connected to CON
//
batch = FALSE;
// batch = (BOOLEAN)(!isatty(0));
if (!batch) {
printf("FT registry edit utility. %s:\n", Version);
}
while(1) {
while ((commandCode = GetCommand(batch,
&argumentString)) == INVALID) {
//
// Continue until we get a valid command.
//
}
if (Debug) {
printf("Command code == %d, argumentString = %s\n",
commandCode,
(argumentString == NULL) ? "(none)" : argumentString);
}
switch (commandCode) {
case DIRLONG:
Directory(keyHandle, (BOOLEAN) TRUE);
break;
case DIR:
Directory(keyHandle, (BOOLEAN) FALSE);
break;
case CREATE:
{
ULONG index;
PUCHAR keyClass;
BOOLEAN classAllocated = FALSE;
if (argumentString == NULL) {
argumentString = GetArgumentString(batch,
"Key Name = ",
(BOOLEAN) FALSE);
}
if (argumentString == NULL) {
break;
}
sprintf(WorkingDirectory,
"%s\\%s",
CurrentDirectory,
argumentString);
argumentString = GetArgumentString(batch,
"Key Class = ",
(BOOLEAN) FALSE);
if (argumentString == NULL) {
keyClass = "Default Class";
} else {
keyClass = (PUCHAR) malloc(strlen(argumentString) + FUDGE);
classAllocated = TRUE;
sprintf(keyClass,
"%s",
argumentString);
}
argumentString = GetArgumentString(batch,
"Index = ",
(BOOLEAN) TRUE);
if (argumentString == NULL) {
index = 1;
} else {
index = ParseArgumentNumeric(&argumentString);
}
if (Debug) {
printf("Creating key %s, index %d with class %s\n",
WorkingDirectory,
index,
keyClass);
}
status = FtCreateKey(WorkingDirectory,
keyClass,
index);
if (!NT_SUCCESS(status)) {
printf("Could not create key %s (0x%x).\n",
WorkingDirectory,
status);
}
if (classAllocated == TRUE) {
free(keyClass);
}
break;
}
case LIST:
List(keyHandle,
argumentString);
break;
case CHDIR:
NtClose(keyHandle);
if (argumentString == NULL) {
argumentString = GetArgumentString(batch,
"New location = ",
(BOOLEAN) TRUE);
}
if (argumentString != NULL) {
if (*argumentString == '\\') {
//
// Root relative string.
// Use text provided (i.e. %s is to avoid user crashing
// by putting %s in the string).
//
sprintf(WorkingDirectory,
"%s",
argumentString);
} else {
while ((*argumentString == '.') &&
(*(argumentString + 1) == '.')) {
if ((*(argumentString + 2) == '\\') ||
(*(argumentString + 2) == '\0')) {
PUCHAR cptr = CurrentDirectory;
//
// move argumentString past ".."
//
argumentString += 2;
//
// Find end of current directory.
//
while (*cptr != '\0') {
cptr++;
}
//
// Backup to last component.
//
while (*cptr != '\\') {
cptr--;
}
if (cptr == CurrentDirectory) {
//
// Cannot backup anymore. Continue parsing
// argument.
//
continue;
}
//
// Remove component from path.
//
*cptr = '\0';
if (*argumentString == '\0') {
//
// All done with argument.
//
break;
}
//
// Step around backslash.
//
argumentString++;
} else {
//
// Assume it is a real name.
//
break;
}
}
if (*argumentString != '\0') {
sprintf(WorkingDirectory,
"%s\\%s",
CurrentDirectory,
argumentString);
} else {
sprintf(WorkingDirectory,
"%s",
CurrentDirectory);
}
}
status = FtOpenKey(&keyHandle,
WorkingDirectory);
if (NT_SUCCESS(status)) {
sprintf(CurrentDirectory,
"%s",
WorkingDirectory);
} else {
(VOID) FtOpenKey(&keyHandle,
CurrentDirectory);
//
// No error checks because this was opened once before.
//
}
}
break;
case HELP:
{
int i;
printf("Valid commands are:\n");
for (i = 0; Commands[i] != NULL; i++) {
printf(" %10s - %s\n",
Commands[i],
CommandHelp[CommandMap[i]]);
}
break;
}
case QUIT:
exit(0);
break;
case DDEBUG:
if (argumentString == NULL) {
if (Debug) {
printf("Debug turned off.\n");
Debug = 0;
} else {
Debug = 1;
}
} else {
Debug = atoi(argumentString);
printf("Debug set to %d\n", Debug);
}
break;
case SETVALUE:
{
int i;
BOOLEAN convertToUnicode = FALSE;
PUCHAR valueName;
PUCHAR valueData;
ULONG valueLength;
ULONG valueWord;
PVOID valuePtr;
ULONG type = DEFAULT_TYPE;
STRING valueString;
UNICODE_STRING unicodeValue;
BOOLEAN dataAllocated = FALSE;
BOOLEAN unicodeAllocated = FALSE;
if (argumentString == NULL) {
argumentString = GetArgumentString(batch,
"Value Name = ",
(BOOLEAN) FALSE);
}
if (argumentString == NULL) {
break;
}
valueName = (PUCHAR) malloc(strlen(argumentString) + FUDGE);
sprintf(valueName,
"%s",
argumentString);
//
// print a help banner on type and get the type.
//
for (i = 0; TypeNames[i] != NULL; i++) {
printf("%d - %s\n", TypeNumbers[i], TypeNames[i]);
}
printf("# - Other numbers are user defined\n");
argumentString = GetArgumentString(batch,
"Numeric value for type = ",
(BOOLEAN) TRUE);
if (argumentString != NULL) {
type = ParseArgumentNumeric(&argumentString);
}
switch(type)
{
default:
case REG_SZ:
if (type == REG_SZ) {
convertToUnicode = TRUE;
printf("Typed in string will be converted to unicode...\n");
argumentString = GetArgumentString(batch,
"Value Data = ",
(BOOLEAN) FALSE);
} else {
printf("For now the data must be typed in...\n");
argumentString = GetArgumentString(batch,
"Value Data = ",
(BOOLEAN) FALSE);
}
if (argumentString == NULL) {
valueData = "Default Data";
valueLength = strlen(valueData);
} else {
valueData = (PUCHAR) malloc(strlen(argumentString) + FUDGE);
dataAllocated = TRUE;
sprintf(valueData,
"%s",
argumentString);
if (convertToUnicode == TRUE) {
RtlInitString(&valueString,
valueData);
RtlAnsiStringToUnicodeString(&unicodeValue,
&valueString,
(BOOLEAN) TRUE);
unicodeAllocated = TRUE;
valueLength = unicodeValue.Length + 2;
} else {
valueLength = strlen(valueData);
}
}
break;
case REG_DWORD:
argumentString = GetArgumentString(batch,
"Value Data Word = ",
(BOOLEAN) TRUE);
if (argumentString == NULL) {
valueWord = 0;
} else {
valueWord = ParseArgumentNumeric(&argumentString);
}
valueLength = sizeof(ULONG);
break;
}
switch (type) {
case REG_DWORD:
valuePtr = (PVOID) &valueWord;
break;
case REG_SZ:
valuePtr = (PVOID) unicodeValue.Buffer;
break;
default:
valuePtr = (PVOID) valueData;
break;
}
status = FtSetValue(keyHandle,
valueName,
valuePtr,
valueLength,
type);
if (!NT_SUCCESS(status)) {
printf("Could not set value %s (0x%x).\n", valueName, status);
}
free(valueName);
if (dataAllocated == TRUE) {
free(valueData);
}
if (unicodeAllocated == TRUE) {
RtlFreeUnicodeString(&unicodeValue);
}
break;
}
case DELKEY:
{
if (argumentString == NULL) {
argumentString = GetArgumentString(batch,
"Key Name = ",
(BOOLEAN) TRUE);
}
if (argumentString == NULL) {
break;
}
sprintf(WorkingDirectory,
"%s\\%s",
CurrentDirectory,
argumentString);
status = FtDeleteKey(WorkingDirectory);
if (!NT_SUCCESS(status)) {
printf("Unable to delete key %s (0x%x)\n",
WorkingDirectory,
status);
}
break;
}
case DELVALUE:
{
if (argumentString == NULL) {
argumentString = GetArgumentString(batch,
"Key Name = ",
(BOOLEAN) TRUE);
}
if (argumentString == NULL) {
break;
}
status = FtDeleteValue(keyHandle,
argumentString);
if (!NT_SUCCESS(status)) {
printf("Unable to delete value %s (0x%x)\n",
argumentString,
status);
}
break;
}
case INLONG:
DumpControl = InLongs;
break;
case INSHORT:
DumpControl = InShorts;
break;
case INBYTE:
DumpControl = InBytes;
break;
case DUMP:
if (ForceDump) {
ForceDump = 0;
} else {
ForceDump++;
}
break;
case DISKREG:
DiskDump();
break;
case FIXDISK:
FixDisk();
break;
case RESTORE:
{
ULONG type;
ULONG group;
ULONG member;
printf("FT types that can be restored are:\n");
printf("\t%d - for Mirrors\n", Mirror);
printf("\t%d - for Stripes with parity\n", StripeWithParity);
//
// Get the type
//
if (argumentString == NULL) {
argumentString = GetArgumentString(batch,
"FT volume type = ",
(BOOLEAN) TRUE);
}
if (argumentString != NULL) {
type = ParseArgumentNumeric(&argumentString);
} else {
break;
}
//
// Get the group
//
if (argumentString == NULL) {
argumentString = GetArgumentString(batch,
"FT group number = ",
(BOOLEAN) TRUE);
}
if (argumentString != NULL) {
group = ParseArgumentNumeric(&argumentString);
} else {
break;
}
//
// Get the member
//
if (argumentString == NULL) {
argumentString = GetArgumentString(batch,
"FT member number = ",
(BOOLEAN) TRUE);
}
if (argumentString != NULL) {
member = ParseArgumentNumeric(&argumentString);
} else {
break;
}
RestoreOrphan(type, group, member);
break;
}
case DRIVERS:
NotImplemented();
// ListDrivers();
break;
case ORPHAN:
{
ULONG type;
ULONG group;
ULONG member;
printf("FT types that can be orphaned are:\n");
printf("\t%d - for Mirrors\n", Mirror);
printf("\t%d - for Stripes with parity\n", StripeWithParity);
//
// Get the type
//
if (argumentString == NULL) {
argumentString = GetArgumentString(batch,
"FT volume type = ",
(BOOLEAN) TRUE);
}
if (argumentString != NULL) {
type = ParseArgumentNumeric(&argumentString);
} else {
break;
}
//
// Get the group
//
if (argumentString == NULL) {
argumentString = GetArgumentString(batch,
"FT group number = ",
(BOOLEAN) TRUE);
}
if (argumentString != NULL) {
group = ParseArgumentNumeric(&argumentString);
} else {
break;
}
//
// Get the member
//
if (argumentString == NULL) {
argumentString = GetArgumentString(batch,
"FT member number = ",
(BOOLEAN) TRUE);
}
if (argumentString != NULL) {
member = ParseArgumentNumeric(&argumentString);
} else {
break;
}
OrphanMember(type, group, member);
break;
}
case REGEN:
{
ULONG type;
ULONG group;
ULONG member;
printf("FT types that can be regenerated are:\n");
printf("\t%d - for Mirrors\n", Mirror);
printf("\t%d - for Stripes with parity\n", StripeWithParity);
//
// Get the type
//
if (argumentString == NULL) {
argumentString = GetArgumentString(batch,
"FT volume type = ",
(BOOLEAN) TRUE);
}
if (argumentString != NULL) {
type = ParseArgumentNumeric(&argumentString);
} else {
break;
}
//
// Get the group
//
if (argumentString == NULL) {
argumentString = GetArgumentString(batch,
"FT group number = ",
(BOOLEAN) TRUE);
}
if (argumentString != NULL) {
group = ParseArgumentNumeric(&argumentString);
} else {
break;
}
//
// Get the member
//
if (argumentString == NULL) {
argumentString = GetArgumentString(batch,
"FT member number = ",
(BOOLEAN) TRUE);
}
if (argumentString != NULL) {
member = ParseArgumentNumeric(&argumentString);
} else {
break;
}
RegenerateMember(type, group, member);
break;
}
case INIT:
{
ULONG type;
ULONG group;
ULONG member;
printf("Only stripes with parity are initialized.\n");
//
// Get the group
//
if (argumentString == NULL) {
argumentString = GetArgumentString(batch,
"Parity stripe group number = ",
(BOOLEAN) TRUE);
}
if (argumentString != NULL) {
group = ParseArgumentNumeric(&argumentString);
} else {
break;
}
ChangeMemberState(StripeWithParity,
group,
0,
Initializing);
break;
}
case MAKEFT:
{
ULONG type;
ULONG group;
ULONG member;
ULONG disk;
ULONG partition;
PDISK_CONFIG_HEADER configHeader;
BOOLEAN doUpdate = TRUE;
configHeader = GetDiskInfo();
if (configHeader == NULL) {
break;
}
printf("\t%d for Mirrors\n", Mirror);
printf("\t%d for Stripe Set\n", Stripe);
printf("\t%d for Stripe with parity\n", StripeWithParity);
printf("\t%d for Volume Set\n", VolumeSet);
if (argumentString == NULL) {
argumentString = GetArgumentString(batch,
"Which FT set to create? ",
(BOOLEAN) TRUE);
}
if (argumentString != NULL) {
type = ParseArgumentNumeric(&argumentString);
} else {
break;
}
if (argumentString == NULL) {
argumentString = GetArgumentString(batch,
"Please give an FT group # - ",
(BOOLEAN) TRUE);
}
if (argumentString != NULL) {
group = ParseArgumentNumeric(&argumentString);
} else {
break;
}
for (member = 0; TRUE; member++) {
printf("Information for member %d\n", member);
if (argumentString == NULL) {
argumentString = GetArgumentString(batch,
"Disk Number = ",
(BOOLEAN) TRUE);
}
if (argumentString != NULL) {
disk = ParseArgumentNumeric(&argumentString);
} else {
break;
}
if (argumentString == NULL) {
argumentString = GetArgumentString(batch,
"Partition Number = ",
(BOOLEAN) TRUE);
}
if (argumentString != NULL) {
partition = ParseArgumentNumeric(&argumentString);
} else {
break;
}
if (CreateFtMember(configHeader, disk, partition, type, group, member) == FALSE) {
printf("Failed to change member state\n");
printf("No update will be made\n");
doUpdate = FALSE;
break;
}
}
if (doUpdate == TRUE) {
PDISK_REGISTRY diskRegistry;
diskRegistry = (PDISK_REGISTRY)
((PUCHAR) configHeader + configHeader->DiskInformationOffset);
DiskRegistrySet(diskRegistry);
}
free(configHeader);
break;
}
default:
printf("WDF homer?!?\n");
break;
}
}
} // main
Reference in a new issue Copy permalink