able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/fs/ntfs/tests/bshell/tbuffer.c

2297 lines
55 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include "brian.h"
//
// Local constants and procedure declarations.
//
#define CHAR_POSITION 51
#define COPY_BUFF_SRC_DEFAULT 0
#define COPY_BUFF_DST_DEFAULT 0
#define COPY_BUFF_SRC_OFF_DEFAULT 0
#define COPY_BUFF_DST_OFF_DEFAULT 0
#define COPY_BUFF_LENGTH_DEFAULT 0
#define DISPLAY_INDEX_DEFAULT 0
#define DISPLAY_OFFSET_DEFAULT 0
#define DISPLAY_LENGTH_DEFAULT 0x100
#define ALLOC_ZERO_BITS_DEFAULT 0
#define ALLOC_REGION_SIZE_DEFAULT 0x100
#define ALLOC_VERBOSE_DEFAULT TRUE
#define ALLOC_DISPLAY_PARMS_DEFAULT FALSE
ULONG
PrintDwords (
IN PULONG BufferAddress,
IN ULONG CountWords
);
ULONG
PrintWords (
IN PUSHORT BufferAddress,
IN ULONG CountWords
);
ULONG
PrintBytes (
IN PCHAR BufferAddress,
IN ULONG CountChars
);
VOID
PrintChars(
IN PCHAR BufferAddress,
IN ULONG CountChars
);
VOID
ClearBuffer(
IN ULONG Index
);
VOID
DisplayBuffer (
IN ULONG Index,
IN ULONG StartOffset,
IN ULONG DisplayLength,
IN ULONG DisplaySize
);
VOID
CopyBuffer(
IN ULONG SrcIndex,
IN ULONG DstIndex,
IN ULONG Length,
IN ULONG SrcOffset,
IN ULONG DstOffset
);
VOID
FillBuffer (
IN ULONG Index,
IN PVOID Structure,
IN ULONG Length
);
NTSTATUS
FullAllocMem(
IN ULONG ZeroBits,
IN OUT PSIZE_T RegionSize,
OUT PULONG BufferIndex,
IN BOOLEAN VerboseResults,
IN BOOLEAN DisplayParms
);
NTSTATUS
FullDeallocMem(
IN ULONG Index,
IN BOOLEAN VerboseResults,
IN BOOLEAN DisplayParms
);
VOID
InitBuffers (
)
{
NtCreateEvent( &BufferEvent, SYNCHRONIZE | GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE,
NULL, SynchronizationEvent, TRUE );
RtlZeroMemory( Buffers, sizeof( Buffers ));
}
VOID
UninitBuffers (
)
{
USHORT Index;
//
// Deallocate any buffers remaining.
//
for (Index = 0; Index < MAX_BUFFERS; Index++) {
DeallocateBuffer( Index );
}
}
NTSTATUS
AllocateBuffer (
IN ULONG ZeroBits,
IN OUT PSIZE_T RegionSize,
OUT PULONG BufferIndex
)
{
NTSTATUS Status;
PVOID BufferAddress;
ULONG Index;
BufferAddress = NULL;
//
// Wait for the buffer event.
//
if ((Status = NtWaitForSingleObject( BufferEvent,
FALSE,
NULL )) != STATUS_SUCCESS) {
return Status;
}
try {
//
// Find an available index. Return STATUS_INSUFFICIENT_RESOURCES
// if not found.
//
for (Index = 0; Index < MAX_BUFFERS; Index++) {
if (!Buffers[Index].Used) {
break;
}
}
if (Index >= MAX_BUFFERS) {
Status = STATUS_INSUFFICIENT_RESOURCES;
//
// Otherwise allocate the virtual memory. If no error occurs, then
// store the data in the buffer array.
//
} else if ((Status = NtAllocateVirtualMemory( NtCurrentProcess(),
&BufferAddress,
ZeroBits,
RegionSize,
MEM_COMMIT,
PAGE_READWRITE )) == STATUS_SUCCESS) {
Buffers[Index].Buffer = BufferAddress;
Buffers[Index].Length = (ULONG) *RegionSize;
Buffers[Index].Used = TRUE;
}
//
// Set the buffer event back to the signalled state.
//
*BufferIndex = Index;
try_return( NOTHING );
try_exit: NOTHING;
} finally {
if (AbnormalTermination()) {
printf( "\nAllocate Buffer: Abnormal termination\n" );
}
NtSetEvent( BufferEvent, NULL );
}
return Status;
}
NTSTATUS
DeallocateBuffer (
IN ULONG Index
)
{
NTSTATUS Status;
//
// Wait for the buffer event.
//
if ((Status = NtWaitForSingleObject( BufferEvent,
FALSE,
NULL )) != STATUS_SUCCESS) {
return Status;
}
try {
if (Index <= MAX_BUFFERS
&& Buffers[Index].Used) {
SIZE_T RegionSize = Buffers[Index].Length;
Status = NtFreeVirtualMemory( NtCurrentProcess(),
(PVOID *) &Buffers[Index].Buffer,
&RegionSize,
MEM_RELEASE );
Buffers[Index].Used = FALSE;
}
try_return( NOTHING );
try_exit: NOTHING;
} finally {
if (AbnormalTermination()) {
printf( "\nDeallocate Buffer: Abnormal termination\n" );
}
NtSetEvent( BufferEvent, NULL );
}
return Status;
}
BOOLEAN
BufferInfo (
IN ULONG Index,
OUT PVOID *BufferAddress,
OUT PULONG RegionSize
)
{
if (Index >= MAX_BUFFERS || !Buffers[Index].Used) {
return FALSE;
}
*BufferAddress = Buffers[Index].Buffer;
*RegionSize = Buffers[Index].Length;
return TRUE;
}
VOID
InputClearBuffer(
IN PCHAR ParamBuffer
)
{
ULONG Index;
BOOLEAN LastInput;
BOOLEAN ParmSpecified;
Index = 0;
ParmSpecified = FALSE;
LastInput = TRUE;
//
// While there is more input, analyze the parameter and update the
// query flags.
//
while (TRUE) {
ULONG DummyCount;
//
// Swallow leading white spaces.
//
ParamBuffer = SwallowWhite( ParamBuffer, &DummyCount );
if (*ParamBuffer) {
//
// If the next parameter is legal then check the paramter value.
// Update the parameter value.
//
if ((*ParamBuffer == '-'
|| *ParamBuffer == '/')
&& (ParamBuffer++, *ParamBuffer != '\0')) {
//
// Switch on the next character.
//
switch( *ParamBuffer ) {
//
// Check buffer index.
//
case 'b' :
case 'B' :
//
// Move to the next character, as long as there
// are no white spaces continue analyzing letters.
// On the first bad letter, skip to the next
// parameter.
//
ParamBuffer++;
Index = AsciiToInteger( ParamBuffer );
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
ParmSpecified = TRUE;
break;
default :
//
// Swallow to the next white space and continue the
// loop.
//
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
}
}
//
// Else the text is invalid, skip the entire block.
//
//
//
// Else if there is no input then exit.
//
} else if ( LastInput ) {
break;
//
// Else try to read another line for open parameters.
//
} else {
}
}
//
// If no parameters were received then display the syntax message.
//
if (!ParmSpecified) {
printf( "\n Usage: clb -b<digits> \n" );
printf( "\n -b<digits> Buffer index" );
printf( "\n\n" );
//
// Else call our copy buffer routine.
//
} else {
ClearBuffer( Index );
}
return;
}
VOID
ClearBuffer(
IN ULONG Index
)
{
//
// Check for an invalid index.
//
if (!Buffers[Index].Used) {
printf( "\nClearBuffer: Invalid buffer" );
} else {
RtlZeroMemory( Buffers[Index].Buffer, Buffers[Index].Length );
}
return;
}
VOID
DisplayBuffer (
IN ULONG Index,
IN ULONG StartOffset,
IN ULONG DisplayLength,
IN ULONG DisplaySize
)
{
//
// If the index is unused, display message but take no action.
//
if (!Buffers[Index].Used) {
printf( "\nDisplayBuffer: Index refers to invalid buffer" );
//
// Else if the start offset is invalid, then display error
// message.
//
} else if (StartOffset >= Buffers[Index].Length) {
printf( "\nDisplayBuffer: Start offset is invalid" );
//
// Else compute the legal display length and output to the screen.
//
} else {
ULONG LegalLength;
ULONG FullLines;
PCHAR BufferAddress;
ULONG SpacesFilled;
//
// The legal display length is the minimum of the remaining
// bytes in the buffer and the desired display length.
//
LegalLength = Buffers[Index].Length - StartOffset;
LegalLength = min( LegalLength, DisplayLength );
BufferAddress = Buffers[Index].Buffer;
//
// Display the display information.
//
printf( "\nIndex -> %u, Buffer Base -> %p, ", Index, BufferAddress );
printf( "Buffer Offset -> %08lx, Bytes -> %u", StartOffset, LegalLength );
printf( "\n" );
BufferAddress += StartOffset;
//
// Compute the number and display the full lines.
//
FullLines = LegalLength / 16;
while (FullLines--) {
if (DisplaySize == sizeof( UCHAR )) {
PrintBytes( BufferAddress, 16 );
} else if (DisplaySize == sizeof( WCHAR )) {
PrintWords( (PVOID) BufferAddress, 8 );
} else {
PrintDwords( (PVOID) BufferAddress, 4 );
}
printf( " " );
PrintChars( BufferAddress, 16 );
BufferAddress += 16;
}
//
// Display the remaining bytes.
//
if (DisplaySize == sizeof( UCHAR )) {
SpacesFilled = PrintBytes( BufferAddress, LegalLength % 16 );
} else if (DisplaySize == sizeof( WCHAR )) {
SpacesFilled = PrintWords( (PVOID) BufferAddress, LegalLength % 8 );
} else {
SpacesFilled = PrintDwords( (PVOID) BufferAddress, LegalLength % 4 );
}
if (SpacesFilled) {
SpacesFilled = CHAR_POSITION - SpacesFilled;
while ( SpacesFilled-- ) {
printf( " " );
}
}
PrintChars( BufferAddress, LegalLength % 16 );
printf( "\n\n" );
}
return;
}
ULONG
PrintBytes (
IN PCHAR BufferAddress,
IN ULONG CountChars
)
{
ULONG CountSpaces;
ULONG RemainingChars;
//
// Initialize the local variables.
//
CountSpaces = CountChars * 3 + (CountChars ? 1 : 0);
RemainingChars = CountChars - min( CountChars, 8 );
CountChars = min( CountChars, 8 );
//
// Print the first 8 bytes (if possible).
//
if (CountChars) {
printf( "\n" );
while (CountChars--) {
printf( "%02x ", *((PUCHAR) BufferAddress++) );
}
//
// If more bytes, then add a blank space and print the rest of the
// bytes.
//
printf( " " );
while (RemainingChars--) {
printf( "%02x ", *((PUCHAR) BufferAddress++) );
}
}
//
// Return the number of spaces used.
//
return CountSpaces;
}
ULONG
PrintWords (
IN PWCHAR BufferAddress,
IN ULONG CountWords
)
{
ULONG CountSpaces;
ULONG RemainingWords;
//
// Initialize the local variables.
//
CountSpaces = CountWords * 5 + (CountWords ? 1 : 0);
RemainingWords = CountWords - min( CountWords, 4 );
CountWords = min( CountWords, 4 );
//
// Print the first 4 words (if possible).
//
if (CountWords) {
printf( "\n" );
while (CountWords--) {
printf( "%04x ", *((PWCHAR) BufferAddress++) );
}
//
// If more bytes, then add a blank space and print the rest of the
// bytes.
//
printf( " " );
while (RemainingWords--) {
printf( "%04x ", *((PWCHAR) BufferAddress++) );
}
}
//
// Return the number of spaces used.
//
return CountSpaces;
}
ULONG
PrintDwords (
IN PULONG BufferAddress,
IN ULONG CountDwords
)
{
ULONG CountSpaces;
ULONG RemainingDwords;
//
// Initialize the local variables.
//
CountSpaces = CountDwords * 7 + (CountDwords ? 1 : 0);
RemainingDwords = CountDwords - min( CountDwords, 8 );
CountDwords = min( CountDwords, 8 );
//
// Print the first 2 Dwords (if possible).
//
if (CountDwords) {
printf( "\n" );
while (CountDwords--) {
printf( "%08x ", *((PULONG) BufferAddress++) );
}
//
// If more bytes, then add a blank space and print the rest of the
// bytes.
//
printf( " " );
while (RemainingDwords--) {
printf( "%08x ", *((PULONG) BufferAddress++) );
}
}
//
// Return the number of spaces used.
//
return CountSpaces;
}
VOID
PrintChars(
IN PCHAR BufferAddress,
IN ULONG CountChars
)
{
ULONG RemainingChars;
//
// Initialize the local variables.
//
RemainingChars = CountChars - min( CountChars, 8 );
CountChars = min( CountChars, 8 );
//
// Print the first 8 bytes (if possible).
//
if (CountChars) {
while (CountChars--) {
if (*BufferAddress > 31
&& *BufferAddress != 127) {
printf( "%c", *BufferAddress );
} else {
printf( "." );
}
BufferAddress++;
}
//
// If more bytes, then add a blank space and print the rest of the
// bytes.
//
printf( " " );
while (RemainingChars--) {
if (*BufferAddress > 31
&& *BufferAddress != 127) {
printf( "%c", *BufferAddress );
} else {
printf( "." );
}
BufferAddress++;
}
}
return;
}
VOID
InputDisplayBuffer(
IN PCHAR ParamBuffer,
IN ULONG DisplaySize
)
{
ULONG DisplayLength;
ULONG DisplayOffset;
ULONG BufferIndex;
BOOLEAN ParamReceived;
BOOLEAN LastInput;
//
// Set the defaults.
//
ParamReceived = FALSE;
LastInput = TRUE;
BufferIndex = DISPLAY_INDEX_DEFAULT;
BufferIndex = DISPLAY_INDEX_DEFAULT;
DisplayOffset = DISPLAY_OFFSET_DEFAULT;
DisplayLength = DISPLAY_LENGTH_DEFAULT;
//
// While there is more input, analyze the parameter and update the
// query flags.
//
while (TRUE) {
ULONG DummyCount;
//
// Swallow leading white spaces.
//
ParamBuffer = SwallowWhite( ParamBuffer, &DummyCount );
if (*ParamBuffer) {
//
// If the next parameter is legal then check the paramter value.
// Update the parameter value.
//
if ((*ParamBuffer == '-'
|| *ParamBuffer == '/')
&& (ParamBuffer++, *ParamBuffer != '\0')) {
//
// Switch on the next character.
//
switch( *ParamBuffer ) {
//
// Check the buffer index.
//
case 'b' :
case 'B' :
//
// Move to the next character, as long as there
// are no white spaces continue analyzing letters.
// On the first bad letter, skip to the next
// parameter.
//
ParamBuffer++;
BufferIndex = AsciiToInteger( ParamBuffer );
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
ParamReceived = TRUE;
break;
//
// Check the display length.
//
case 'l' :
case 'L' :
//
// Move to the next character, as long as there
// are no white spaces continue analyzing letters.
// On the first bad letter, skip to the next
// parameter.
//
ParamBuffer++;
DisplayLength = AsciiToInteger( ParamBuffer );
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
break;
//
// Check the display offset.
//
case 'o' :
case 'O' :
//
// Move to the next character, as long as there
// are no white spaces continue analyzing letters.
// On the first bad letter, skip to the next
// parameter.
//
ParamBuffer++;
DisplayOffset = AsciiToInteger( ParamBuffer );
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
break;
default :
//
// Swallow to the next white space and continue the
// loop.
//
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
}
}
//
// Else the text is invalid, skip the entire block.
//
//
//
// Else if there is no input then exit.
//
} else if ( LastInput ) {
break;
//
// Else try to read another line for open parameters.
//
} else {
}
}
//
// If no parameters were received then display the syntax message.
//
if (!ParamReceived) {
printf( "\n Usage: db [options]* -i<digits> [options]*\n" );
printf( "\n Options:" );
printf( "\n -b<digits> Buffer index" );
printf( "\n -l<digits> Display length" );
printf( "\n -o<digits> Display starting offset" );
printf( "\n\n" );
//
// Else call our display buffer routine.
//
} else {
DisplayBuffer( BufferIndex, DisplayOffset, DisplayLength, DisplaySize );
}
}
VOID
InputCopyBuffer(
IN PCHAR ParamBuffer
)
{
ULONG SrcIndex;
ULONG DstIndex;
ULONG Length;
ULONG SrcOffset;
ULONG DstOffset;
BOOLEAN DstSpecified;
BOOLEAN SrcSpecified;
BOOLEAN LastInput;
//
// Set the defaults.
//
SrcIndex = COPY_BUFF_SRC_DEFAULT;
DstIndex = COPY_BUFF_DST_DEFAULT;
Length = COPY_BUFF_SRC_OFF_DEFAULT;
SrcOffset = COPY_BUFF_DST_OFF_DEFAULT;
DstOffset = COPY_BUFF_LENGTH_DEFAULT;
DstSpecified = FALSE;
SrcSpecified = FALSE;
LastInput = TRUE;
//
// While there is more input, analyze the parameter and update the
// query flags.
//
while(TRUE) {
ULONG DummyCount;
//
// Swallow leading white spaces.
//
ParamBuffer = SwallowWhite( ParamBuffer, &DummyCount );
if ( *ParamBuffer ) {
//
// If the next parameter is legal then check the paramter value.
// Update the parameter value.
//
if ((*ParamBuffer == '-'
|| *ParamBuffer == '/')
&& (ParamBuffer++, *ParamBuffer != '\0')) {
//
// Switch on the next character.
//
switch( *ParamBuffer ) {
//
// Check the destination index.
//
case 'd' :
case 'D' :
//
// Move to the next character, as long as there
// are no white spaces continue analyzing letters.
// On the first bad letter, skip to the next
// parameter.
//
ParamBuffer++;
DstIndex = AsciiToInteger( ParamBuffer );
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
DstSpecified = TRUE;
break;
//
// Check source starting offset.
//
case 'f' :
case 'F' :
//
// Move to the next character, as long as there
// are no white spaces continue analyzing letters.
// On the first bad letter, skip to the next
// parameter.
//
ParamBuffer++;
SrcOffset = AsciiToInteger( ParamBuffer );
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
break;
//
// Check copy length.
//
case 'l' :
case 'L' :
//
// Move to the next character, as long as there
// are no white spaces continue analyzing letters.
// On the first bad letter, skip to the next
// parameter.
//
ParamBuffer++;
Length = AsciiToInteger( ParamBuffer );
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
break;
//
// Check the source index.
//
case 's' :
case 'S' :
//
// Move to the next character, as long as there
// are no white spaces continue analyzing letters.
// On the first bad letter, skip to the next
// parameter.
//
ParamBuffer++;
SrcIndex = AsciiToInteger( ParamBuffer );
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
SrcSpecified = TRUE;
break;
//
// Check destination offset.
//
case 't' :
case 'T' :
//
// Move to the next character, as long as there
// are no white spaces continue analyzing letters.
// On the first bad letter, skip to the next
// parameter.
//
ParamBuffer++;
DstOffset = AsciiToInteger( ParamBuffer );
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
break;
default :
//
// Swallow to the next white space and continue the
// loop.
//
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
}
}
//
// Else the text is invalid, skip the entire block.
//
//
//
// Else if there is no input then exit.
//
} else if ( LastInput ) {
break;
//
// Else try to read another line for open parameters.
//
} else {
}
}
//
// If no parameters were received then display the syntax message.
//
if (!SrcSpecified || !DstSpecified) {
printf( "\n Usage: cb [options]* -d<digits> [options]* -s<digits> [options]*\n" );
printf( "\n Options:" );
printf( "\n -d<digits> Destination index" );
printf( "\n -f<digits> Source offset" );
printf( "\n -l<digits> Transfer length" );
printf( "\n -s<digits> Source index" );
printf( "\n -t<digits> Destination offset" );
printf( "\n\n" );
//
// Else call our copy buffer routine.
//
} else {
CopyBuffer( SrcIndex,
DstIndex,
Length,
SrcOffset,
DstOffset );
}
}
VOID
CopyBuffer(
IN ULONG SrcIndex,
IN ULONG DstIndex,
IN ULONG Length,
IN ULONG SrcOffset,
IN ULONG DstOffset
)
{
//
// Check for an invalid source index.
//
if (!Buffers[SrcIndex].Used) {
printf( "\nCopyBuffer: Invalid source buffer" );
//
// Otherwise check for an invalid destination index.
//
} else if (!Buffers[DstIndex].Used) {
printf( "\nCopyBuffer: Invalid destination buffer" );
//
// Test for an invalid source offset.
//
} else if (SrcOffset >= Buffers[SrcIndex].Length) {
printf( "\nCopyBuffer: Source offset is invalid" );
//
// Test for an invalid destination offset.
//
} else if (DstOffset >= Buffers[DstIndex].Length) {
printf( "\nCopyBuffer: Destination offset is invalid" );
//
// This statement handles the case of two correct indexes and offsets.
//
} else {
ULONG LegalLength;
PCHAR SrcAddress;
PCHAR DstAddress;
//
// Adjust the length according to the source buffer size.
//
LegalLength = Buffers[SrcIndex].Length - SrcOffset;
LegalLength = min( LegalLength, Length );
Length = Buffers[DstIndex].Length - DstOffset;
LegalLength = min( LegalLength, Length );
SrcAddress = Buffers[SrcIndex].Buffer + SrcOffset;
DstAddress = Buffers[DstIndex].Buffer + DstOffset;
//
// Display the header information.
//
printf( "\nSource index -> %2u, Source base -> %p, Source offset -> %08lx, ",
SrcIndex,
Buffers[SrcIndex].Buffer,
SrcOffset );
printf( "\n Dest index -> %2u, Dest base -> %p, Dest offset -> %08lx, ",
DstIndex,
Buffers[DstIndex].Buffer,
DstOffset );
printf( "\nLength -> %u", Length );
//
// Perform the transfer for non-zero lengths only.
//
if (Length) {
RtlMoveMemory( DstAddress, SrcAddress, Length );
}
}
return;
}
VOID
InputAllocMem(
IN PCHAR ParamBuffer
)
{
ULONG ZeroBits;
SIZE_T RegionSize;
ULONG BufferIndex;
BOOLEAN VerboseResults;
BOOLEAN DisplayParms;
BOOLEAN ParamReceived;
BOOLEAN LastInput;
//
// Set the defaults.
//
ZeroBits = ALLOC_ZERO_BITS_DEFAULT;
RegionSize = ALLOC_REGION_SIZE_DEFAULT;
VerboseResults = ALLOC_VERBOSE_DEFAULT;
DisplayParms = ALLOC_DISPLAY_PARMS_DEFAULT;
ParamReceived = FALSE;
LastInput = TRUE;
//
// While there is more input, analyze the parameter and update the
// query flags.
//
while (TRUE) {
ULONG DummyCount;
//
// Swallow leading white spaces.
//
ParamBuffer = SwallowWhite( ParamBuffer, &DummyCount );
if ( *ParamBuffer ) {
//
// If the next parameter is legal then check the paramter value.
// Update the parameter value.
//
if ((*ParamBuffer == '-'
|| *ParamBuffer == '/')
&& (ParamBuffer++, *ParamBuffer != '\0')) {
//
// Switch on the next character.
//
switch (*ParamBuffer) {
//
// Update zero bits.
//
case 'b' :
case 'B' :
//
// Move to the next character, as long as there
// are no white spaces continue analyzing letters.
// On the first bad letter, skip to the next
// parameter.
//
ParamBuffer++;
ZeroBits = AsciiToInteger( ParamBuffer );
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
ParamReceived = TRUE;
break;
//
// Update the region size.
//
case 'r' :
case 'R' :
//
// Move to the next character, as long as there
// are no white spaces continue analyzing letters.
// On the first bad letter, skip to the next
// parameter.
//
ParamBuffer++;
RegionSize = AsciiToInteger( ParamBuffer );
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
ParamReceived = TRUE;
break;
case 'v' :
case 'V' :
//
// Legal values for params are T/t or F/f.
//
ParamBuffer++;
if (*ParamBuffer == 'T'
|| *ParamBuffer == 't') {
VerboseResults = TRUE;
ParamBuffer++;
} else if (*ParamBuffer == 'F'
|| *ParamBuffer == 'f') {
VerboseResults = FALSE;
ParamBuffer++;
}
ParamReceived = TRUE;
break;
case 'y' :
case 'Y' :
//
// Set the display parms flag and jump over this
// character.
//
DisplayParms = TRUE;
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
ParamReceived = TRUE;
break;
default :
//
// Swallow to the next white space and continue the
// loop.
//
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
}
}
//
// Else the text is invalid, skip the entire block.
//
//
//
// Else if there is no input then exit.
//
} else if ( LastInput ) {
break;
//
// Else try to read another line for open parameters.
//
} else {
}
}
//
// If no parameters were received then display the syntax message.
//
if (!ParamReceived) {
printf( "\n Usage: am [options]*\n" );
printf( "\n Options:" );
printf( "\n -b<digits> Zero bits" );
printf( "\n -r<digits> Region size" );
printf( "\n -v[t|f] Verbose results" );
printf( "\n -y Display parameters to query" );
printf( "\n\n" );
//
// Else call our allocation routine.
//
} else {
FullAllocMem(
ZeroBits,
&RegionSize,
&BufferIndex,
VerboseResults,
DisplayParms
);
}
}
NTSTATUS
FullAllocMem(
IN ULONG ZeroBits,
IN OUT PSIZE_T RegionSize,
OUT PULONG BufferIndex,
IN BOOLEAN VerboseResults,
IN BOOLEAN DisplayParms
)
{
NTSTATUS Status;
Status = STATUS_SUCCESS;
if (DisplayParms) {
printf( "\nAlloc Memory Parameters" );
printf( "\n Zero Bits -> %ld", ZeroBits );
printf( "\n Region Size -> %ld", *RegionSize );
printf( "\n\n" );
}
//
// Try to get the next buffer.
//
Status = AllocateBuffer( ZeroBits, RegionSize, BufferIndex );
//
// Print the results if verbose.
//
if (VerboseResults) {
printf( "\nAllocMem: Status -> %08lx", Status );
printf( "\n RegionSize -> %08lx", *RegionSize );
printf( "\n BufferIndex -> %ld", *BufferIndex );
printf( "\n\n" );
}
return Status;
}
VOID
InputDeallocMem(
IN PCHAR ParamBuffer
)
{
ULONG BufferIndex;
BOOLEAN ParamReceived;
BOOLEAN LastInput;
BOOLEAN VerboseResults;
BOOLEAN DisplayParms;
//
// Set the defaults.
//
VerboseResults = ALLOC_VERBOSE_DEFAULT;
DisplayParms = ALLOC_DISPLAY_PARMS_DEFAULT;
ParamReceived = FALSE;
LastInput = TRUE;
//
// While there is more input, analyze the parameter and update the
// query flags.
//
while (TRUE) {
ULONG DummyCount;
//
// Swallow leading white spaces.
//
ParamBuffer = SwallowWhite( ParamBuffer, &DummyCount );
if (*ParamBuffer) {
//
// If the next parameter is legal then check the paramter value.
// Update the parameter value.
//
if ((*ParamBuffer == '-'
|| *ParamBuffer == '/')
&& (ParamBuffer++, *ParamBuffer != '\0')) {
//
// Switch on the next character.
//
switch (*ParamBuffer) {
//
// Find the Index value.
//
case 'b' :
case 'B' :
//
// Move to the next character, as long as there
// are no white spaces continue analyzing letters.
// On the first bad letter, skip to the next
// parameter.
//
ParamBuffer++;
BufferIndex = AsciiToInteger( ParamBuffer );
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
ParamReceived = TRUE;
break;
case 'v' :
case 'V' :
//
// Legal values for params are T/t or F/f.
//
ParamBuffer++;
if (*ParamBuffer == 'T'
|| *ParamBuffer == 't') {
VerboseResults = TRUE;
ParamBuffer++;
} else if (*ParamBuffer == 'F'
|| *ParamBuffer == 'f') {
VerboseResults = FALSE;
ParamBuffer++;
}
ParamReceived = TRUE;
break;
case 'y' :
case 'Y' :
//
// Set the display parms flag and jump over this
// character.
//
DisplayParms = TRUE;
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
ParamReceived = TRUE;
break;
default :
//
// Swallow to the next white space and continue the
// loop.
//
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
}
}
//
// Else the text is invalid, skip the entire block.
//
//
//
// Else if there is no input then exit.
//
} else if ( LastInput ) {
break;
//
// Else try to read another line for open parameters.
//
} else {
}
}
//
// If no parameters were received then display the syntax message.
//
if (!ParamReceived) {
printf( "\n Usage: dm [options]*\n" );
printf( "\n Options:" );
printf( "\n -b<digits> Buffer Index number" );
printf( "\n -v[t|f] Verbose results" );
printf( "\n -y Display parameters to query" );
printf( "\n\n" );
//
// Else call our allocation routine.
//
} else {
FullDeallocMem(
BufferIndex,
VerboseResults,
DisplayParms );
}
}
NTSTATUS
FullDeallocMem(
IN ULONG Index,
IN BOOLEAN VerboseResults,
IN BOOLEAN DisplayParms
)
{
NTSTATUS Status;
Status = STATUS_SUCCESS;
if (DisplayParms) {
printf( "\nDealloc Memory Parameters" );
printf( "\n Buffer Index -> %ld", Index );
printf( "\n\n" );
}
//
// Try to free the desired buffer.
//
Status = DeallocateBuffer( Index );
//
// Print the results if verbose.
//
if (VerboseResults) {
printf( "\nDeallocMem: Status -> %08lx", Status );
printf( "\n\n" );
}
return Status;
}
VOID InputFillBuffer(
IN PCHAR ParamBuffer
)
{
ULONG BufferIndex;
BOOLEAN ParamReceived;
BOOLEAN LastInput;
BOOLEAN HaveStructure = FALSE;
MFT_ENUM_DATA EnumUsnData;
READ_USN_JOURNAL_DATA ReadUsnJournal;
CREATE_USN_JOURNAL_DATA CreateUsnJournal;
LARGE_INTEGER LargeIntegerInput;
FILE_ALLOCATED_RANGE_BUFFER AllocatedRangeBuffer;
PVOID StructurePointer;
ULONG StructureSize;
ParamReceived = FALSE;
LastInput = TRUE;
BufferIndex = DISPLAY_INDEX_DEFAULT;
RtlZeroMemory( &EnumUsnData, sizeof( MFT_ENUM_DATA ));
RtlZeroMemory( &ReadUsnJournal, sizeof( READ_USN_JOURNAL_DATA ));
RtlZeroMemory( &CreateUsnJournal, sizeof( CREATE_USN_JOURNAL_DATA ));
RtlZeroMemory( &LargeIntegerInput, sizeof( LARGE_INTEGER ));
RtlZeroMemory( &AllocatedRangeBuffer, sizeof( FILE_ALLOCATED_RANGE_BUFFER ));
//
// While there is more input, analyze the parameter and update the
// query flags.
//
while (TRUE) {
ULONG DummyCount;
//
// Swallow leading white spaces.
//
ParamBuffer = SwallowWhite( ParamBuffer, &DummyCount );
if (*ParamBuffer) {
//
// If the next parameter is legal then check the paramter value.
// Update the parameter value.
//
if ((*ParamBuffer == '-'
|| *ParamBuffer == '/')
&& (ParamBuffer++, *ParamBuffer != '\0')) {
//
// Switch on the next character.
//
switch( *ParamBuffer ) {
BOOLEAN SwitchBool;
//
// Check the buffer index.
//
case 'b' :
case 'B' :
//
// Move to the next character, as long as there
// are no white spaces continue analyzing letters.
// On the first bad letter, skip to the next
// parameter.
//
ParamBuffer++;
BufferIndex = AsciiToInteger( ParamBuffer );
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
ParamReceived = TRUE;
break;
//
// Check the structure to fill.
//
case 's' :
case 'S' :
SwitchBool = TRUE;
ParamBuffer++;
if (*ParamBuffer
&& *ParamBuffer != ' '
&& *ParamBuffer != '\t') {
//
// Perform switch on character.
//
switch (*ParamBuffer) {
case 'a' :
case 'A' :
case 'b' :
case 'B' :
HaveStructure = TRUE;
StructurePointer = &LargeIntegerInput;
StructureSize = sizeof( LARGE_INTEGER );
ParamBuffer++;
if (*ParamBuffer
&& *ParamBuffer != ' '
&& *ParamBuffer != '\t') {
switch (*ParamBuffer) {
case 'a' :
case 'A' :
ParamBuffer++;
LargeIntegerInput.QuadPart = AsciiToLargeInteger( ParamBuffer );
break;
default :
NOTHING;
}
}
break;
case 'c' :
case 'C' :
HaveStructure = TRUE;
StructurePointer = &AllocatedRangeBuffer;
StructureSize = sizeof( FILE_ALLOCATED_RANGE_BUFFER );
ParamBuffer++;
if (*ParamBuffer
&& *ParamBuffer != ' '
&& *ParamBuffer != '\t') {
switch (*ParamBuffer) {
case 'a' :
case 'A' :
ParamBuffer++;
AllocatedRangeBuffer.FileOffset.QuadPart = AsciiToLargeInteger( ParamBuffer );
break;
case 'b' :
case 'B' :
ParamBuffer++;
AllocatedRangeBuffer.Length.QuadPart = AsciiToLargeInteger( ParamBuffer );
break;
default :
NOTHING;
}
}
break;
default :
NOTHING;
}
}
break;
default :
NOTHING;
}
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
}
//
// Else the text is invalid, skip the entire block.
//
//
//
// Else if there is no input then exit.
//
} else if ( LastInput ) {
break;
//
// Else try to read another line for open parameters.
//
} else {
}
}
//
// If no parameters were received then display the syntax message.
//
if (!ParamReceived) {
printf( "\n Usage: fb -b<digits> -s<struct>[options]* \n" );
printf( "\n -sa[options] Get Volume Bitmap" );
printf( "\n a<digits> Starting lcn" );
printf( "\n -sb[options] Query Retrieval Pointers" );
printf( "\n a<digits> Starting vcn" );
printf( "\n -sc[options] Query Allocated Ranges" );
printf( "\n a<digits> FileOffset" );
printf( "\n b<digits> Length" );
printf( "\n\n" );
//
// Else fill the buffer.
//
} else if (HaveStructure) {
FillBuffer( BufferIndex, StructurePointer, StructureSize );
}
}
VOID InputFillBufferUsn(
IN PCHAR ParamBuffer
)
{
ULONG BufferIndex;
BOOLEAN ParamReceived;
BOOLEAN LastInput;
BOOLEAN HaveStructure = FALSE;
MFT_ENUM_DATA EnumUsnData;
READ_USN_JOURNAL_DATA ReadUsnJournal;
CREATE_USN_JOURNAL_DATA CreateUsnJournal;
DELETE_USN_JOURNAL_DATA DeleteUsnJournal;
PVOID StructurePointer;
ULONG StructureSize;
ParamReceived = FALSE;
LastInput = TRUE;
BufferIndex = DISPLAY_INDEX_DEFAULT;
RtlZeroMemory( &EnumUsnData, sizeof( MFT_ENUM_DATA ));
RtlZeroMemory( &ReadUsnJournal, sizeof( READ_USN_JOURNAL_DATA ));
RtlZeroMemory( &CreateUsnJournal, sizeof( CREATE_USN_JOURNAL_DATA ));
RtlZeroMemory( &DeleteUsnJournal, sizeof( DELETE_USN_JOURNAL_DATA ));
//
// While there is more input, analyze the parameter and update the
// query flags.
//
while (TRUE) {
ULONG DummyCount;
//
// Swallow leading white spaces.
//
ParamBuffer = SwallowWhite( ParamBuffer, &DummyCount );
if (*ParamBuffer) {
//
// If the next parameter is legal then check the paramter value.
// Update the parameter value.
//
if ((*ParamBuffer == '-'
|| *ParamBuffer == '/')
&& (ParamBuffer++, *ParamBuffer != '\0')) {
//
// Switch on the next character.
//
switch( *ParamBuffer ) {
BOOLEAN SwitchBool;
//
// Check the buffer index.
//
case 'b' :
case 'B' :
//
// Move to the next character, as long as there
// are no white spaces continue analyzing letters.
// On the first bad letter, skip to the next
// parameter.
//
ParamBuffer++;
BufferIndex = AsciiToInteger( ParamBuffer );
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
ParamReceived = TRUE;
break;
//
// Check the structure to fill.
//
case 's' :
case 'S' :
SwitchBool = TRUE;
ParamBuffer++;
if (*ParamBuffer
&& *ParamBuffer != ' '
&& *ParamBuffer != '\t') {
//
// Perform switch on character.
//
switch (*ParamBuffer) {
//
// ENUM_USN_DATA
//
case 'a' :
case 'A' :
HaveStructure = TRUE;
StructurePointer = &EnumUsnData;
StructureSize = sizeof( MFT_ENUM_DATA );
ParamBuffer++;
if (*ParamBuffer
&& *ParamBuffer != ' '
&& *ParamBuffer != '\t') {
switch (*ParamBuffer) {
case 'a' :
case 'A' :
ParamBuffer++;
EnumUsnData.LowUsn = AsciiToLargeInteger( ParamBuffer );
break;
case 'b' :
case 'B' :
ParamBuffer++;
EnumUsnData.HighUsn = AsciiToLargeInteger( ParamBuffer );
break;
case 'c' :
case 'C' :
ParamBuffer++;
EnumUsnData.StartFileReferenceNumber = AsciiToLargeInteger( ParamBuffer );
break;
default :
NOTHING;
}
}
break;
case 'b' :
case 'B' :
HaveStructure = TRUE;
StructurePointer = &ReadUsnJournal;
StructureSize = sizeof( READ_USN_JOURNAL_DATA );
ParamBuffer++;
if (*ParamBuffer
&& *ParamBuffer != ' '
&& *ParamBuffer != '\t') {
switch (*ParamBuffer) {
case 'a' :
case 'A' :
ParamBuffer++;
ReadUsnJournal.StartUsn = AsciiToLargeInteger( ParamBuffer );
break;
case 'b' :
case 'B' :
ParamBuffer++;
ReadUsnJournal.ReasonMask = AsciiToInteger( ParamBuffer );
break;
case 'c' :
case 'C' :
ParamBuffer++;
ReadUsnJournal.ReturnOnlyOnClose = AsciiToInteger( ParamBuffer );
break;
case 'd' :
case 'D' :
ParamBuffer++;
ReadUsnJournal.Timeout = AsciiToLargeInteger( ParamBuffer );
break;
case 'e' :
case 'E' :
ParamBuffer++;
ReadUsnJournal.BytesToWaitFor = AsciiToLargeInteger( ParamBuffer );
break;
case 'f' :
case 'F' :
ParamBuffer++;
ReadUsnJournal.UsnJournalID = AsciiToLargeInteger( ParamBuffer );
break;
default :
NOTHING;
}
}
break;
case 'c' :
case 'C' :
HaveStructure = TRUE;
StructurePointer = &CreateUsnJournal;
StructureSize = sizeof( CREATE_USN_JOURNAL_DATA );
ParamBuffer++;
if (*ParamBuffer
&& *ParamBuffer != ' '
&& *ParamBuffer != '\t') {
switch (*ParamBuffer) {
case 'a' :
case 'A' :
ParamBuffer++;
CreateUsnJournal.MaximumSize = AsciiToLargeInteger( ParamBuffer );
break;
case 'b' :
case 'B' :
ParamBuffer++;
CreateUsnJournal.AllocationDelta = AsciiToLargeInteger( ParamBuffer );
break;
default :
NOTHING;
}
}
break;
case 'd' :
case 'D' :
HaveStructure = TRUE;
StructurePointer = &DeleteUsnJournal;
StructureSize = sizeof( DELETE_USN_JOURNAL_DATA );
ParamBuffer++;
if (*ParamBuffer
&& *ParamBuffer != ' '
&& *ParamBuffer != '\t') {
switch (*ParamBuffer) {
case 'a' :
case 'A' :
ParamBuffer++;
DeleteUsnJournal.UsnJournalID = AsciiToLargeInteger( ParamBuffer );
break;
default :
NOTHING;
}
}
break;
default :
NOTHING;
}
}
break;
default :
NOTHING;
}
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
}
//
// Else the text is invalid, skip the entire block.
//
//
//
// Else if there is no input then exit.
//
} else if ( LastInput ) {
break;
//
// Else try to read another line for open parameters.
//
} else {
}
}
//
// If no parameters were received then display the syntax message.
//
if (!ParamReceived) {
printf( "\n Usage: fbusn -b<digits> -s<struct>[options]* \n" );
printf( "\n -sa[options] Enum Usn Data" );
printf( "\n a<digits> Low usn" );
printf( "\n b<digits> High usn" );
printf( "\n c<digits> File ref" );
printf( "\n -sb[options] Read Usn Data" );
printf( "\n a<digits> Start usn" );
printf( "\n b<digits> Reason mask" );
printf( "\n c<digits> Return only on close" );
printf( "\n d<digits> Timeout" );
printf( "\n e<digits> Bytes to wait for" );
printf( "\n f<digits> Journal id" );
printf( "\n -sc[options] Create Usn Data" );
printf( "\n a<digits> Maximum size" );
printf( "\n b<digits> Allocation delta" );
printf( "\n -sd[options] Delete Usn Journal Data" );
printf( "\n a<digits> Usn journal id" );
printf( "\n\n" );
//
// Else fill the buffer.
//
} else if (HaveStructure) {
FillBuffer( BufferIndex, StructurePointer, StructureSize );
}
}
VOID
FillBuffer (
IN ULONG Index,
IN PVOID Structure,
IN ULONG Length
)
{
//
// If the index is unused, display message but take no action.
//
if (!Buffers[Index].Used) {
printf( "\nFillBuffer: Index refers to invalid buffer" );
//
// Else copy as much of the data as will fit into the buffer.
//
} else {
if (Length > Buffers[Index].Length) {
Length = Buffers[Index].Length;
}
RtlCopyMemory( Buffers[Index].Buffer, Structure, Length );
}
return;
}
Reference in a new issue Copy permalink