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/tsetfile.c

2507 lines
72 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include "brian.h"
typedef struct _ASYNC_SETFILE {
USHORT FileIndex;
FILE_INFORMATION_CLASS FileInfoClass;
ULONG BufferLength;
PULONG BufferLengthPtr;
USHORT CreateTimeIndex;
PUSHORT CreateTimePtr;
USHORT LastAccessIndex;
PUSHORT LastAccessPtr;
USHORT LastWriteIndex;
PUSHORT LastWritePtr;
USHORT ChangeTimeIndex;
PUSHORT ChangeTimePtr;
ULONG FileAttributes;
PULONG FileAttributesPtr;
ULONG RenameLength;
PULONG RenameLengthPtr;
BOOLEAN ReplaceIfExists;
USHORT RootDirectoryIndex;
PUSHORT RootDirectoryPtr;
USHORT RenameIndex;
BOOLEAN RenameBufferAllocated;
ULONG NameLength;
PULONG NameLengthPtr;
USHORT NameIndex;
BOOLEAN NameBufferAllocated;
ULONG ShortNameLength;
PULONG ShortNameLengthPtr;
USHORT ShortNameIndex;
BOOLEAN ShortNameBufferAllocated;
BOOLEAN DeleteFile;
LARGE_INTEGER NewOffset;
ULONG FileMode;
LARGE_INTEGER NewAllocation;
LARGE_INTEGER NewEof;
BOOLEAN DisplayParms;
BOOLEAN VerboseResults;
USHORT AsyncIndex;
} ASYNC_SETFILE, *PASYNC_SETFILE;
#define SETFILE_LENGTH_DEFAULT 100
#define FILE_INFO_CLASS_DEFAULT FileBasicInformation
#define REPLACE_IF_EXISTS_DEFAULT TRUE
#define DELETE_FILE_DEFAULT TRUE
#define FILE_MODE_DEFAULT FILE_SYNCHRONOUS_IO_NONALERT
#define DISPLAY_PARMS_DEFAULT FALSE
#define VERBOSE_RESULTS_DEFAULT TRUE
VOID
FullSetFile(
IN OUT PASYNC_SETFILE AsyncSetFile
);
VOID
SetBasicInformation(
IN OUT PASYNC_SETFILE AsyncSetFile
);
VOID
SetRenameInformation(
IN OUT PASYNC_SETFILE AsyncSetFile
);
VOID
SetNameInformation(
IN OUT PASYNC_SETFILE AsyncSetFile
);
VOID
SetShortNameInformation(
IN OUT PASYNC_SETFILE AsyncSetFile
);
VOID
SetDispositionInformation(
IN OUT PASYNC_SETFILE AsyncSetFile
);
VOID
SetPositionInformation(
IN OUT PASYNC_SETFILE AsyncSetFile
);
VOID
SetModeInformation (
IN OUT PASYNC_SETFILE AsyncSetFile
);
VOID
SetAllocationInformation(
IN OUT PASYNC_SETFILE AsyncSetFile
);
VOID
SetEofInformation(
IN OUT PASYNC_SETFILE AsyncSetFile
);
VOID
InputSetFile (
IN PCHAR ParamBuffer
)
{
USHORT FileIndex;
FILE_INFORMATION_CLASS FileInfoClass;
ULONG BufferLength;
PULONG BufferLengthPtr;
USHORT CreateTimeIndex;
PUSHORT CreateTimePtr;
USHORT LastAccessIndex;
PUSHORT LastAccessPtr;
USHORT LastWriteIndex;
PUSHORT LastWritePtr;
USHORT ChangeTimeIndex;
PUSHORT ChangeTimePtr;
ULONG FileAttributes;
PULONG FileAttributesPtr;
ANSI_STRING AnsiRenameString;
ULONG RenameLength;
PULONG RenameLengthPtr;
BOOLEAN ReplaceIfExists;
USHORT RootDirectoryIndex;
PUSHORT RootDirectoryPtr;
USHORT RenameIndex;
BOOLEAN RenameBufferAllocated;
PUCHAR FileRenamePtr;
ANSI_STRING AnsiNameString;
ULONG NameLength;
PULONG NameLengthPtr;
USHORT NameIndex = 0;
BOOLEAN NameBufferAllocated;
PUCHAR FileNamePtr;
ULONG ShortNameLength;
PULONG ShortNameLengthPtr;
USHORT ShortNameIndex = 0;
BOOLEAN ShortNameBufferAllocated;
PUCHAR FileShortNamePtr;
BOOLEAN DeleteFile;
LARGE_INTEGER NewOffset;
ULONG FileMode;
LARGE_INTEGER NewAllocation;
LARGE_INTEGER NewEof;
BOOLEAN DisplayParms;
BOOLEAN VerboseResults;
USHORT AsyncIndex;
BOOLEAN ParamReceived;
BOOLEAN LastInput;
//
// Set the defaults.
//
FileInfoClass = FILE_INFO_CLASS_DEFAULT;
BufferLengthPtr = NULL;
CreateTimePtr = NULL;
LastAccessPtr = NULL;
LastWritePtr = NULL;
ChangeTimePtr = NULL;
FileAttributes = 0;
FileAttributesPtr = NULL;
RenameLengthPtr = NULL;
ReplaceIfExists = REPLACE_IF_EXISTS_DEFAULT;
RootDirectoryPtr = NULL;
RenameBufferAllocated = FALSE;
FileRenamePtr = NULL;
NameLengthPtr = NULL;
NameBufferAllocated = FALSE;
FileNamePtr = NULL;
ShortNameLengthPtr = NULL;
ShortNameBufferAllocated = FALSE;
FileShortNamePtr = NULL;
DeleteFile = DELETE_FILE_DEFAULT;
NewOffset = RtlConvertUlongToLargeInteger( 0L );
FileMode = FILE_MODE_DEFAULT;
NewAllocation = NewOffset;
NewEof = NewOffset;
DisplayParms = DISPLAY_PARMS_DEFAULT;
VerboseResults = VERBOSE_RESULTS_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')) {
BOOLEAN SwitchBool;
//
// Switch on the next character.
//
switch (*ParamBuffer) {
//
// Update the byte count.
//
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++;
if (*ParamBuffer == '\0') {
break;
}
switch (*ParamBuffer) {
case 'b':
case 'B':
BufferLength = AsciiToInteger( ++ParamBuffer );
BufferLengthPtr = &BufferLength;
break;
case 'r':
case 'R':
RenameLength = AsciiToInteger( ++ParamBuffer );
RenameLengthPtr = &RenameLength;
break;
case 'n':
case 'N':
NameLength = AsciiToInteger( ++ParamBuffer );
NameLengthPtr = &NameLength;
break;
case 's':
case 'S':
ShortNameLength = AsciiToInteger( ++ParamBuffer );
ShortNameLengthPtr = &ShortNameLength;
break;
}
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
break;
//
// Update the allocation size.
//
case 'n' :
case 'N' :
NewAllocation.QuadPart = AsciiToLargeInteger( ++ParamBuffer );
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
break;
//
// Update the End of file size.
//
case 'e' :
case 'E' :
NewEof.QuadPart = AsciiToLargeInteger( ++ParamBuffer );
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
break;
//
// Update the filenames.
//
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++;
if (*ParamBuffer == '\0') {
break;
}
switch (*ParamBuffer) {
PUCHAR TempPtr;
case 'r':
case 'R':
//
// Remember the buffer offset and get the filename.
//
ParamBuffer++;
TempPtr = ParamBuffer;
DummyCount = 0;
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
//
// If the name length is 0, then ignore this entry.
//
if (DummyCount) {
AnsiRenameString.Length = (USHORT) DummyCount;
AnsiRenameString.Buffer = TempPtr;
FileRenamePtr = TempPtr;
RenameLength = RtlAnsiStringToUnicodeSize( &AnsiRenameString) - sizeof( WCHAR );
RenameLengthPtr = &RenameLength;
}
break;
case 'n':
case 'N':
//
// Remember the buffer offset and get the filename.
//
ParamBuffer++;
TempPtr = ParamBuffer;
DummyCount = 0;
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
//
// If the name length is 0, then ignore this entry.
//
if (DummyCount) {
AnsiNameString.Length = (USHORT) DummyCount;
AnsiNameString.Buffer = TempPtr;
FileNamePtr = TempPtr;
NameLength = RtlAnsiStringToUnicodeSize( &AnsiNameString) - sizeof( WCHAR );
NameLengthPtr = &NameLength;
}
break;
case 's' :
case 'S' :
//
// Remember the buffer offset and get the filename.
//
ParamBuffer++;
TempPtr = ParamBuffer;
DummyCount = 0;
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
//
// If the name length is 0, then ignore this entry.
//
if (DummyCount) {
AnsiNameString.Length = (USHORT) DummyCount;
AnsiNameString.Buffer = TempPtr;
FileShortNamePtr = TempPtr;
ShortNameLength = RtlAnsiStringToUnicodeSize( &AnsiNameString) - sizeof( WCHAR );
ShortNameLengthPtr = &ShortNameLength;
}
break;
}
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
break;
//
// Update the file handle index.
//
case 'i' :
case 'I' :
//
// 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++;
FileIndex = (USHORT) AsciiToInteger( ParamBuffer );
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
ParamReceived = TRUE;
break;
//
// Update the root directory index.
//
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++;
RootDirectoryIndex = (USHORT) AsciiToInteger( ParamBuffer );
RootDirectoryPtr = &RootDirectoryIndex;
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
break;
//
// Update the information class.
//
case 'c' :
case 'C' :
//
// 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++;
SwitchBool = TRUE;
while (*ParamBuffer
&& *ParamBuffer != ' '
&& *ParamBuffer != '\t') {
//
// Perform switch on character.
//
switch (*ParamBuffer) {
case 'a' :
case 'A' :
FileInfoClass = FileBasicInformation;
break;
case 'b' :
case 'B' :
FileInfoClass = FileRenameInformation;
break;
case 'c' :
case 'C' :
FileInfoClass = FileLinkInformation;
break;
case 'd' :
case 'D' :
FileInfoClass = FileDispositionInformation;
break;
case 'e' :
case 'E' :
FileInfoClass = FilePositionInformation;
break;
case 'f' :
case 'F' :
FileInfoClass = FileModeInformation;
break;
case 'g' :
case 'G' :
FileInfoClass = FileAllocationInformation;
break;
case 'h' :
case 'H' :
FileInfoClass = FileEndOfFileInformation;
break;
case 'i' :
case 'I' :
FileInfoClass = FileShortNameInformation;
break;
default :
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
SwitchBool = FALSE;
}
if (!SwitchBool) {
break;
}
ParamBuffer++;
}
break;
//
// Update the file mode information
//
case 'm' :
case 'M' :
//
// 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++;
SwitchBool = TRUE;
while (*ParamBuffer
&& *ParamBuffer != ' '
&& *ParamBuffer != '\t') {
//
// Perform switch on character.
//
switch (*ParamBuffer) {
case 'a' :
case 'A' :
FileMode &= FILE_WRITE_THROUGH;
break;
case 'b' :
case 'B' :
FileMode &= FILE_SEQUENTIAL_ONLY;
break;
case 'c' :
case 'C' :
FileMode &= FILE_SYNCHRONOUS_IO_ALERT;
break;
case 'd' :
case 'D' :
FileMode &= FILE_SYNCHRONOUS_IO_NONALERT;
break;
case 'z' :
case 'Z' :
FileMode = 0;
break;
default :
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
SwitchBool = FALSE;
}
if (!SwitchBool) {
break;
}
ParamBuffer++;
}
break;
//
// Update the file attributes.
//
case 'a' :
case 'A' :
//
// 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++;
SwitchBool = TRUE;
while (*ParamBuffer
&& *ParamBuffer != ' '
&& *ParamBuffer != '\t') {
//
// Perform switch on character.
//
switch (*ParamBuffer) {
case 'a' :
case 'A' :
FileAttributes |= FILE_ATTRIBUTE_READONLY;
FileAttributesPtr = &FileAttributes;
break;
case 'b' :
case 'B' :
FileAttributes |= FILE_ATTRIBUTE_HIDDEN;
FileAttributesPtr = &FileAttributes;
break;
case 'c' :
case 'C' :
FileAttributes |= FILE_ATTRIBUTE_SYSTEM;
FileAttributesPtr = &FileAttributes;
break;
case 'e' :
case 'E' :
FileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
FileAttributesPtr = &FileAttributes;
break;
case 'f' :
case 'F' :
FileAttributes |= FILE_ATTRIBUTE_ARCHIVE;
FileAttributesPtr = &FileAttributes;
break;
case 'g' :
case 'G' :
FileAttributes |= FILE_ATTRIBUTE_ENCRYPTED;
FileAttributesPtr = &FileAttributes;
break;
case 'h' :
case 'H' :
FileAttributes |= FILE_ATTRIBUTE_NORMAL;
FileAttributesPtr = &FileAttributes;
break;
case 'i' :
case 'I' :
FileAttributes |= FILE_ATTRIBUTE_TEMPORARY;
FileAttributesPtr = &FileAttributes;
break;
case 'j' :
case 'J' :
FileAttributes |= FILE_ATTRIBUTE_SPARSE_FILE;
FileAttributesPtr = &FileAttributes;
break;
case 'k' :
case 'K' :
FileAttributes |= FILE_ATTRIBUTE_REPARSE_POINT;
FileAttributesPtr = &FileAttributes;
break;
case 'l' :
case 'L' :
FileAttributes |= FILE_ATTRIBUTE_COMPRESSED;
FileAttributesPtr = &FileAttributes;
break;
case 'm' :
case 'M' :
FileAttributes |= FILE_ATTRIBUTE_OFFLINE;
FileAttributesPtr = &FileAttributes;
break;
case 'n' :
case 'N' :
FileAttributes |= FILE_ATTRIBUTE_NOT_CONTENT_INDEXED;
FileAttributesPtr = &FileAttributes;
break;
case 'z' :
case 'Z' :
FileAttributes = 0;
FileAttributesPtr = NULL;
break;
default :
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
SwitchBool = FALSE;
}
if (!SwitchBool) {
break;
}
ParamBuffer++;
}
break;
//
// Check for time or date modification.
//
case 't' :
case 'T' :
//
// Check that there is another character.
//
ParamBuffer++;
if (*ParamBuffer == '\0') {
break;
}
switch (*ParamBuffer) {
case 'c':
case 'C':
CreateTimeIndex = (USHORT) AsciiToInteger( ++ParamBuffer );
CreateTimePtr = &CreateTimeIndex;
break;
case 'a':
case 'A':
LastAccessIndex = (USHORT) AsciiToInteger( ++ParamBuffer );
LastAccessPtr = &LastAccessIndex;
break;
case 'w':
case 'W':
LastWriteIndex = (USHORT) AsciiToInteger( ++ParamBuffer );
LastWritePtr = &LastWriteIndex;
break;
case 'g':
case 'G':
ChangeTimeIndex = (USHORT) AsciiToInteger( ++ParamBuffer );
ChangeTimePtr = &ChangeTimeIndex;
}
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
break;
case 'p' :
case 'P' :
//
// Legal values for params are T/t or F/f.
//
ParamBuffer++;
if (*ParamBuffer == 'T'
|| *ParamBuffer == 't') {
ReplaceIfExists = TRUE;
ParamBuffer++;
} else if( *ParamBuffer == 'F'
|| *ParamBuffer == 'f' ) {
ReplaceIfExists = FALSE;
ParamBuffer++;
}
break;
case 'd' :
case 'D' :
//
// Legal values for params are T/t or F/f.
//
ParamBuffer++;
if (*ParamBuffer == 'T'
|| *ParamBuffer == 't') {
DeleteFile = TRUE;
ParamBuffer++;
} else if( *ParamBuffer == 'F'
|| *ParamBuffer == 'f' ) {
DeleteFile = FALSE;
ParamBuffer++;
}
break;
//
// Update the lower offset of the large integer.
//
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++;
NewOffset.LowPart = AsciiToInteger( ParamBuffer );
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
break;
//
// Update the upper offset of the large integer.
//
case 'u' :
case 'U' :
//
// 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++;
NewOffset.HighPart = AsciiToInteger( ParamBuffer );
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
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++;
}
break;
case 'y' :
case 'Y' :
//
// Set the display parms flag and jump over this
// character.
//
DisplayParms = TRUE;
ParamBuffer = SwallowNonWhite( ParamBuffer, &DummyCount );
break;
case 'z' :
case 'Z' :
//
// Set flag for more input and jump over this char.
//
LastInput = FALSE;
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) {
bprint "\n" );
printf( " Usage: sf [options]* -i<index> [options]*\n" );
printf( " Options:\n" );
printf( " -i<digits> File index\n" );
printf( " -lb<digits> Buffer length\n" );
printf( " -c<char> File information class\n" );
printf( " -tc<digits> CreateTime buffer index\n" );
printf( " -ta<digits> LastAccess buffer index\n" );
printf( " -tw<digits> LastWrite buffer index\n" );
printf( " -tg<digits> ChangeTime buffer index\n" );
printf( " -a<chars> File attributes\n" );
printf( " -p[t|f] Replace existing file on rename\n" );
printf( " -r<digits> Root directory index for rename\n" );
printf( " -fr<name> Name for rename\n" );
printf( " -fn<name> New link name\n" );
printf( " -fs<name> New short name\n" );
printf( " -lr<digits> Stated length of rename\n" );
printf( " -ln<digits> Stated length of new name\n" );
printf( " -ls<digits> Stated length of new short name\n" );
printf( " -d[t|f] Delete file\n" );
printf( " -o<digits> Low word of new position\n" );
printf( " -u<digits> High word of new position\n" );
printf( " -m<chars> File mode information\n" );
printf( " -n<digits> Quad word of new allocation size\n" );
printf( " -e<digits> Quad word of new end of file\n" );
printf( " -v[t|f] Verbose results\n" );
printf( " -y Display parameters to query\n" );
printf( " -z Additional input line\n" );
printf( "\n" );
//
// Else call our read routine.
//
} else {
NTSTATUS Status;
SIZE_T RegionSize;
ULONG TempIndex;
PASYNC_SETFILE AsyncSetFile;
HANDLE ThreadHandle;
ULONG ThreadId;
RegionSize = sizeof( ASYNC_SETFILE );
Status = AllocateBuffer( 0, &RegionSize, &TempIndex );
AsyncIndex = (USHORT) TempIndex;
if (!NT_SUCCESS( Status )) {
printf("\tInputSetFile: Unable to allocate async structure\n" );
} else {
//
// If we need a buffer for the rename, allocate it now.
//
if (FileRenamePtr != NULL) {
UNICODE_STRING UnicodeString;
RegionSize = RenameLength;
if (RegionSize == 0) {
RegionSize = 0x10;
}
Status = AllocateBuffer( 0, &RegionSize, &TempIndex );
if (!NT_SUCCESS( Status )) {
printf( "\tInputSetFile: Unable to allocate rename structure\n" );
DeallocateBuffer( AsyncIndex );
return;
}
UnicodeString.Buffer = (PWSTR) Buffers[TempIndex].Buffer;
UnicodeString.MaximumLength = (USHORT) Buffers[TempIndex].Length;
RenameIndex = (USHORT) TempIndex;
RenameBufferAllocated = TRUE;
//
// Store the name in the buffer.
//
RtlAnsiStringToUnicodeString( &UnicodeString,
&AnsiRenameString,
FALSE );
}
//
// If we need a buffer for the new name, allocate it now.
//
if (FileNamePtr != NULL) {
UNICODE_STRING UnicodeString;
RegionSize = NameLength;
if (RegionSize == 0) {
RegionSize = 0x10;
}
Status = AllocateBuffer( 0, &RegionSize, &TempIndex );
if (!NT_SUCCESS( Status )) {
printf( "\tInputSetFile: Unable to allocate new name structure\n" );
DeallocateBuffer( AsyncIndex );
if (NameBufferAllocated) {
DeallocateBuffer( NameIndex );
}
return;
}
UnicodeString.Buffer = (PWSTR) Buffers[TempIndex].Buffer;
UnicodeString.MaximumLength = (USHORT) Buffers[TempIndex].Length;
NameIndex = (USHORT) TempIndex;
NameBufferAllocated = TRUE;
//
// Store the name in the buffer.
//
RtlAnsiStringToUnicodeString( &UnicodeString,
&AnsiNameString,
FALSE );
}
//
// If we need a buffer for the new short name, allocate it now.
//
if (FileShortNamePtr != NULL) {
UNICODE_STRING UnicodeString;
RegionSize = ShortNameLength;
if (RegionSize == 0) {
RegionSize = 0x10;
}
Status = AllocateBuffer( 0, &RegionSize, &TempIndex );
if (!NT_SUCCESS( Status )) {
printf( "\tInputSetFile: Unable to allocate new short name structure\n" );
DeallocateBuffer( AsyncIndex );
if (ShortNameBufferAllocated) {
DeallocateBuffer( ShortNameIndex );
}
return;
}
UnicodeString.Buffer = (PWSTR) Buffers[TempIndex].Buffer;
UnicodeString.MaximumLength = (USHORT) Buffers[TempIndex].Length;
ShortNameIndex = (USHORT) TempIndex;
ShortNameBufferAllocated = TRUE;
//
// Store the name in the buffer.
//
RtlAnsiStringToUnicodeString( &UnicodeString,
&AnsiNameString,
FALSE );
}
AsyncSetFile = (PASYNC_SETFILE) Buffers[AsyncIndex].Buffer;
AsyncSetFile->FileIndex = (USHORT) FileIndex;
AsyncSetFile->BufferLength = BufferLength;
AsyncSetFile->BufferLengthPtr = BufferLengthPtr
? &AsyncSetFile->BufferLength
: NULL;
AsyncSetFile->FileInfoClass = FileInfoClass;
AsyncSetFile->CreateTimeIndex = CreateTimeIndex;
AsyncSetFile->CreateTimePtr = CreateTimePtr
? &AsyncSetFile->CreateTimeIndex
: NULL;
AsyncSetFile->LastAccessIndex = LastAccessIndex;
AsyncSetFile->LastAccessPtr = LastAccessPtr
? &AsyncSetFile->LastAccessIndex
: NULL;
AsyncSetFile->LastWriteIndex = LastWriteIndex;
AsyncSetFile->LastWritePtr = LastWritePtr
? &AsyncSetFile->LastWriteIndex
: NULL;
AsyncSetFile->ChangeTimeIndex = ChangeTimeIndex;
AsyncSetFile->ChangeTimePtr = ChangeTimePtr
? &AsyncSetFile->ChangeTimeIndex
: NULL;
AsyncSetFile->FileAttributes = FileAttributes;
AsyncSetFile->FileAttributesPtr = FileAttributesPtr
? &AsyncSetFile->FileAttributes
: NULL;
AsyncSetFile->RenameLength = RenameLength;
AsyncSetFile->RenameLengthPtr = RenameLengthPtr
? &AsyncSetFile->RenameLength
: NULL;
AsyncSetFile->ReplaceIfExists = ReplaceIfExists;
AsyncSetFile->RootDirectoryIndex = RootDirectoryIndex;
AsyncSetFile->RootDirectoryPtr = RootDirectoryPtr
? &AsyncSetFile->RootDirectoryIndex
: NULL;
AsyncSetFile->RenameIndex = RenameIndex;
AsyncSetFile->RenameBufferAllocated = RenameBufferAllocated;
AsyncSetFile->NameLength = NameLength;
AsyncSetFile->NameLengthPtr = NameLengthPtr
? &AsyncSetFile->NameLength
: NULL;
AsyncSetFile->NameIndex = NameIndex;
AsyncSetFile->NameBufferAllocated = NameBufferAllocated;
AsyncSetFile->ShortNameLength = ShortNameLength;
AsyncSetFile->ShortNameLengthPtr = ShortNameLengthPtr
? &AsyncSetFile->ShortNameLength
: NULL;
AsyncSetFile->ShortNameIndex = ShortNameIndex;
AsyncSetFile->ShortNameBufferAllocated = ShortNameBufferAllocated;
AsyncSetFile->DeleteFile = DeleteFile;
AsyncSetFile->NewOffset = NewOffset;
AsyncSetFile->FileMode = FileMode;
AsyncSetFile->NewAllocation = NewAllocation;
AsyncSetFile->NewEof = NewEof;
AsyncSetFile->DisplayParms = DisplayParms;
AsyncSetFile->VerboseResults = VerboseResults;
AsyncSetFile->AsyncIndex = AsyncIndex;
if (!SynchronousCmds) {
ThreadHandle = CreateThread( NULL,
0,
FullSetFile,
AsyncSetFile,
0,
&ThreadId );
if (ThreadHandle == 0) {
printf( "InputSetFile: Spawning thread fails -> %d\n", GetLastError() );
if (RenameBufferAllocated) {
DeallocateBuffer( RenameIndex );
}
if (NameBufferAllocated) {
DeallocateBuffer( NameIndex );
}
DeallocateBuffer( AsyncIndex );
return;
}
} else {
FullSetFile( AsyncSetFile );
}
}
}
return;
}
VOID
FullSetFile(
IN OUT PASYNC_SETFILE AsyncSetFile
)
{
try {
//
// Case on the information type and call the appropriate routine.
//
switch (AsyncSetFile->FileInfoClass) {
case FileBasicInformation:
SetBasicInformation( AsyncSetFile );
break;
case FileRenameInformation:
SetRenameInformation( AsyncSetFile );
break;
case FileLinkInformation:
SetNameInformation( AsyncSetFile );
break;
case FileShortNameInformation:
SetShortNameInformation( AsyncSetFile );
break;
case FileDispositionInformation:
SetDispositionInformation( AsyncSetFile );
break;
case FilePositionInformation:
SetPositionInformation( AsyncSetFile );
break;
case FileModeInformation:
SetModeInformation( AsyncSetFile );
break;
case FileAllocationInformation :
SetAllocationInformation( AsyncSetFile );
break;
case FileEndOfFileInformation :
SetEofInformation( AsyncSetFile );
break;
default:
bprint "FullSetInfo: Unrecognized information class\n" );
}
try_return( NOTHING );
try_exit: NOTHING;
} finally {
if (AsyncSetFile->RenameBufferAllocated) {
DeallocateBuffer( AsyncSetFile->RenameIndex );
}
if (AsyncSetFile->NameBufferAllocated) {
DeallocateBuffer( AsyncSetFile->NameIndex );
}
DeallocateBuffer( AsyncSetFile->AsyncIndex );
}
NtTerminateThread( 0, STATUS_SUCCESS );
}
VOID
SetBasicInformation(
IN OUT PASYNC_SETFILE AsyncSetFile
)
{
NTSTATUS Status;
PFILE_BASIC_INFORMATION BasicInformation;
USHORT BufferIndex;
BOOLEAN UnwindBufferIndex = FALSE;
//
// Check the parameters for legality. Void the pointers if the values
// are illegal.
//
if (AsyncSetFile->CreateTimePtr != NULL
&& (AsyncSetFile->CreateTimeIndex >= MAX_BUFFERS
|| !Buffers[AsyncSetFile->CreateTimeIndex].Used)) {
bprint "CreateTimeIndex %04d is invalid\n" );
AsyncSetFile->CreateTimePtr = NULL;
}
if (AsyncSetFile->LastAccessPtr != NULL
&& (AsyncSetFile->LastAccessIndex >= MAX_BUFFERS
|| !Buffers[AsyncSetFile->LastAccessIndex].Used)) {
bprint "LastAccessIndex %04d is invalid\n" );
AsyncSetFile->LastAccessPtr = NULL;
}
if (AsyncSetFile->LastWritePtr != NULL
&& (AsyncSetFile->LastWriteIndex >= MAX_BUFFERS
|| !Buffers[AsyncSetFile->LastWriteIndex].Used)) {
bprint "LastWriteIndex %04d is invalid\n" );
AsyncSetFile->LastWritePtr = NULL;
}
if (AsyncSetFile->ChangeTimePtr != NULL
&& (AsyncSetFile->ChangeTimeIndex >= MAX_BUFFERS
|| !Buffers[AsyncSetFile->ChangeTimeIndex].Used)) {
bprint "ChangeTimeIndex %04d is invalid\n" );
AsyncSetFile->ChangeTimePtr = NULL;
}
if (AsyncSetFile->DisplayParms) {
bprint "\n" );
bprint "Set FileBasicInformation Parameters\n" );
bprint " File Handle Index -> %d\n", AsyncSetFile->FileIndex );
bprint " BufferLengthPtr -> %08lx\n", AsyncSetFile->BufferLengthPtr );
if (AsyncSetFile->BufferLengthPtr) {
bprint " BufferLength value -> %08x\n", AsyncSetFile->BufferLength );
}
bprint " CreateTimePtr -> %08lx\n", AsyncSetFile->CreateTimePtr );
if (AsyncSetFile->CreateTimePtr) {
bprint " CreateTime -> \n" );
BPrintTime( (PTIME) Buffers[AsyncSetFile->CreateTimeIndex].Buffer );
}
bprint " LastAccessPtr -> %08lx\n", AsyncSetFile->LastAccessPtr );
if (AsyncSetFile->LastAccessPtr) {
bprint " LastAccess -> \n" );
BPrintTime( (PTIME) Buffers[AsyncSetFile->LastAccessIndex].Buffer );
}
bprint " LastWritePtr -> %08lx\n", AsyncSetFile->LastWritePtr );
if (AsyncSetFile->LastWritePtr) {
bprint " LastWrite -> \n" );
BPrintTime( (PTIME) Buffers[AsyncSetFile->LastWriteIndex].Buffer );
}
bprint " ChangeTimePtr -> %08lx\n", AsyncSetFile->ChangeTimePtr );
if (AsyncSetFile->ChangeTimePtr) {
bprint " ChangeTime -> \n" );
BPrintTime( (PTIME) Buffers[AsyncSetFile->ChangeTimeIndex].Buffer );
}
bprint " FileAttributesPtr -> %08lx\n", AsyncSetFile->FileAttributesPtr );
if (AsyncSetFile->FileAttributesPtr) {
bprint " FileAttributes value -> %08x\n", AsyncSetFile->FileAttributes );
}
bprint "\n" );
}
try {
SIZE_T RegionSize;
ULONG TempIndex;
IO_STATUS_BLOCK Iosb;
RegionSize = sizeof( FILE_BASIC_INFORMATION );
Status = AllocateBuffer( 0, &RegionSize, &TempIndex );
BufferIndex = (USHORT) TempIndex;
if (!NT_SUCCESS( Status )) {
bprint "\tSetBasicInformation: Unable to allocate structure\n" );
try_return( NOTHING );
}
UnwindBufferIndex = TRUE;
BasicInformation = (PFILE_BASIC_INFORMATION) Buffers[BufferIndex].Buffer;
//
// Fill in the new information.
//
if (AsyncSetFile->CreateTimePtr) {
BasicInformation->CreationTime = *((PTIME) Buffers[AsyncSetFile->CreateTimeIndex].Buffer);
} else {
BasicInformation->CreationTime.LowPart = 0;
BasicInformation->CreationTime.HighPart = 0;
}
if (AsyncSetFile->LastAccessPtr) {
BasicInformation->LastAccessTime = *((PTIME) Buffers[AsyncSetFile->LastAccessIndex].Buffer);
} else {
BasicInformation->LastAccessTime.LowPart = 0;
BasicInformation->LastAccessTime.HighPart = 0;
}
if (AsyncSetFile->LastWritePtr) {
BasicInformation->LastWriteTime = *((PTIME) Buffers[AsyncSetFile->LastWriteIndex].Buffer);
} else {
BasicInformation->LastWriteTime.LowPart = 0;
BasicInformation->LastWriteTime.HighPart = 0;
}
if (AsyncSetFile->ChangeTimePtr) {
BasicInformation->ChangeTime = *((PTIME) Buffers[AsyncSetFile->ChangeTimeIndex].Buffer);
} else {
BasicInformation->ChangeTime.LowPart = 0;
BasicInformation->ChangeTime.HighPart = 0;
}
if (AsyncSetFile->FileAttributesPtr) {
BasicInformation->FileAttributes = AsyncSetFile->FileAttributes;
} else {
BasicInformation->FileAttributes = 0;
}
Iosb.Status = STATUS_SUCCESS;
Iosb.Information = 0;
Status = NtSetInformationFile( Handles[AsyncSetFile->FileIndex].Handle,
&Iosb,
BasicInformation,
AsyncSetFile->BufferLengthPtr
? AsyncSetFile->BufferLength
: Buffers[BufferIndex].Length,
FileBasicInformation );
if (AsyncSetFile->VerboseResults) {
bprint "\n" );
bprint " SetBasicInformation: Status -> %08lx\n", Status );
if (NT_SUCCESS( Status )) {
bprint " Io.Status -> %08lx\n", Iosb.Status );
bprint " Io.Information -> %08lx\n", Iosb.Information );
}
bprint "\n" );
}
try_exit: NOTHING;
} finally {
if (UnwindBufferIndex) {
DeallocateBuffer( BufferIndex );
}
}
return;
}
VOID
SetRenameInformation(
IN OUT PASYNC_SETFILE AsyncSetFile
)
{
NTSTATUS Status;
PFILE_RENAME_INFORMATION RenameInformation;
USHORT BufferIndex;
UNICODE_STRING UniRenameName;
ANSI_STRING AnsiRenameName;
BOOLEAN UnwindBufferIndex = FALSE;
BOOLEAN UnwindFreeAnsiString = FALSE;
//
// Check that there is a rename specified.
//
if (!AsyncSetFile->RenameBufferAllocated) {
bprint "Set Rename Information: No rename was specified\n" );
return;
}
UniRenameName.Buffer = (PWSTR) Buffers[AsyncSetFile->RenameIndex].Buffer;
UniRenameName.MaximumLength =
UniRenameName.Length = (USHORT) AsyncSetFile->RenameLength;
UniRenameName.MaximumLength += 2;
Status = RtlUnicodeStringToAnsiString( &AnsiRenameName,
&UniRenameName,
TRUE );
if (!NT_SUCCESS( Status )) {
bprint "SetFileRenameInfo: Can't allocate ansi buffer -> %08lx\n", Status );
AsyncSetFile->DisplayParms = FALSE;
} else {
UnwindFreeAnsiString = TRUE;
}
if (AsyncSetFile->DisplayParms) {
bprint "\n" );
bprint "Set FileRenameInformation Parameters\n" );
bprint " File Handle Index -> %d\n", AsyncSetFile->FileIndex );
bprint " BufferLengthPtr -> %08lx\n", AsyncSetFile->BufferLengthPtr );
if (AsyncSetFile->BufferLengthPtr) {
bprint " BufferLength value -> %08x\n", AsyncSetFile->BufferLength );
}
bprint " Replace existing file -> %d\n", AsyncSetFile->ReplaceIfExists );
bprint " Root directory pointer -> %d\n", AsyncSetFile->RootDirectoryPtr );
if (AsyncSetFile->RootDirectoryPtr) {
bprint " Root directory index -> %d\n", AsyncSetFile->RootDirectoryIndex );
}
bprint " Rename length -> %d\n", AsyncSetFile->RenameLength );
bprint " New file name -> %s\n", AnsiRenameName.Buffer );
bprint "\n" );
}
try {
SIZE_T RegionSize;
ULONG TempIndex;
IO_STATUS_BLOCK Iosb;
RegionSize = sizeof( FILE_RENAME_INFORMATION ) + AsyncSetFile->RenameLength;
Status = AllocateBuffer( 0, &RegionSize, &TempIndex );
BufferIndex = (USHORT) TempIndex;
if (!NT_SUCCESS( Status )) {
bprint "\tSetRenameInformation: Unable to allocate structure\n" );
try_return( NOTHING );
}
UnwindBufferIndex = TRUE;
RenameInformation = (PFILE_RENAME_INFORMATION) Buffers[BufferIndex].Buffer;
//
// Fill in the new information.
//
RenameInformation->ReplaceIfExists = AsyncSetFile->ReplaceIfExists;
RenameInformation->RootDirectory = AsyncSetFile->RootDirectoryPtr
? Handles[AsyncSetFile->RootDirectoryIndex].Handle
: 0;
RenameInformation->FileNameLength = AsyncSetFile->RenameLength;
RtlMoveMemory( RenameInformation->FileName,
UniRenameName.Buffer,
AsyncSetFile->RenameLength );
Iosb.Status = STATUS_SUCCESS;
Iosb.Information = 0;
Status = NtSetInformationFile( Handles[AsyncSetFile->FileIndex].Handle,
&Iosb,
RenameInformation,
AsyncSetFile->BufferLengthPtr
? AsyncSetFile->BufferLength
: Buffers[BufferIndex].Length,
FileRenameInformation );
if (AsyncSetFile->VerboseResults) {
bprint "\n" );
bprint " SetRenameInformation: Status -> %08lx\n", Status );
if (NT_SUCCESS( Status )) {
bprint " Io.Status -> %08lx\n", Iosb.Status );
bprint " Io.Information -> %08lx\n", Iosb.Information );
}
bprint "\n" );
}
try_exit: NOTHING;
} finally {
if (UnwindFreeAnsiString) {
RtlFreeAnsiString( &AnsiRenameName );
}
if (UnwindBufferIndex) {
DeallocateBuffer( BufferIndex );
}
}
return;
}
VOID
SetNameInformation(
IN OUT PASYNC_SETFILE AsyncSetFile
)
{
NTSTATUS Status;
PFILE_RENAME_INFORMATION NameInformation;
USHORT BufferIndex;
UNICODE_STRING UnicodeName;
ANSI_STRING AnsiName;
BOOLEAN UnwindBufferIndex = FALSE;
BOOLEAN UnwindFreeAnsiString = FALSE;
//
// Check that there is a Name specified.
//
if (!AsyncSetFile->NameBufferAllocated) {
bprint "Set Name Information: No Name was specified\n" );
return;
}
UnicodeName.Buffer = (PWSTR) Buffers[AsyncSetFile->NameIndex].Buffer;
UnicodeName.MaximumLength =
UnicodeName.Length = (USHORT) AsyncSetFile->NameLength;
UnicodeName.MaximumLength += 2;
Status = RtlUnicodeStringToAnsiString( &AnsiName,
&UnicodeName,
TRUE );
if (!NT_SUCCESS( Status )) {
bprint "SetFileNameInfo: Can't allocate ansi buffer -> %08lx\n", Status );
AsyncSetFile->DisplayParms = FALSE;
} else {
UnwindFreeAnsiString = TRUE;
}
if (AsyncSetFile->DisplayParms) {
bprint "\n" );
bprint "Set FileNameInformation Parameters\n" );
bprint " File Handle Index -> %d\n", AsyncSetFile->FileIndex );
bprint " BufferLengthPtr -> %08lx\n", AsyncSetFile->BufferLengthPtr );
if (AsyncSetFile->BufferLengthPtr) {
bprint " BufferLength value -> %08x\n", AsyncSetFile->BufferLength );
}
bprint " Replace existing file -> %d\n", AsyncSetFile->ReplaceIfExists );
bprint " Root directory pointer -> %d\n", AsyncSetFile->RootDirectoryPtr );
if (AsyncSetFile->RootDirectoryPtr) {
bprint " Root directory index -> %d\n", AsyncSetFile->RootDirectoryIndex );
}
bprint " Name length -> %d\n", AsyncSetFile->NameLength );
bprint " New file name -> %s\n", AnsiName.Buffer );
bprint "\n" );
}
try {
SIZE_T RegionSize;
ULONG TempIndex;
IO_STATUS_BLOCK Iosb;
RegionSize = sizeof( FILE_RENAME_INFORMATION ) + AsyncSetFile->NameLength;
Status = AllocateBuffer( 0, &RegionSize, &TempIndex );
BufferIndex = (USHORT) TempIndex;
if (!NT_SUCCESS( Status )) {
bprint "\tSetNameInformation: Unable to allocate structure\n" );
try_return( NOTHING );
}
UnwindBufferIndex = TRUE;
NameInformation = (PFILE_RENAME_INFORMATION) Buffers[BufferIndex].Buffer;
//
// Fill in the new information.
//
NameInformation->ReplaceIfExists = AsyncSetFile->ReplaceIfExists;
NameInformation->RootDirectory = AsyncSetFile->RootDirectoryPtr
? Handles[AsyncSetFile->RootDirectoryIndex].Handle
: 0;
NameInformation->FileNameLength = AsyncSetFile->NameLength;
RtlMoveMemory( NameInformation->FileName,
UnicodeName.Buffer,
AsyncSetFile->NameLength );
Iosb.Status = STATUS_SUCCESS;
Iosb.Information = 0;
Status = NtSetInformationFile( Handles[AsyncSetFile->FileIndex].Handle,
&Iosb,
NameInformation,
AsyncSetFile->BufferLengthPtr
? AsyncSetFile->BufferLength
: Buffers[BufferIndex].Length,
FileLinkInformation );
if (AsyncSetFile->VerboseResults) {
bprint "\n" );
bprint " SetNameInformation: Status -> %08lx\n", Status );
if (NT_SUCCESS( Status )) {
bprint " Io.Status -> %08lx\n", Iosb.Status );
bprint " Io.Information -> %08lx\n", Iosb.Information );
}
bprint "\n" );
}
try_exit: NOTHING;
} finally {
if (UnwindFreeAnsiString) {
RtlFreeAnsiString( &AnsiName );
}
if (UnwindBufferIndex) {
DeallocateBuffer( BufferIndex );
}
}
return;
}
VOID
SetShortNameInformation(
IN OUT PASYNC_SETFILE AsyncSetFile
)
{
NTSTATUS Status;
PFILE_NAME_INFORMATION NameInformation;
USHORT BufferIndex;
UNICODE_STRING UnicodeName;
ANSI_STRING AnsiName;
BOOLEAN UnwindBufferIndex = FALSE;
BOOLEAN UnwindFreeAnsiString = FALSE;
//
// Check that there is a Name specified.
//
if (!AsyncSetFile->ShortNameBufferAllocated) {
bprint "Set Short Name Information: No Name was specified\n" );
return;
}
UnicodeName.Buffer = (PWSTR) Buffers[AsyncSetFile->ShortNameIndex].Buffer;
UnicodeName.MaximumLength =
UnicodeName.Length = (USHORT) AsyncSetFile->ShortNameLength;
UnicodeName.MaximumLength += 2;
Status = RtlUnicodeStringToAnsiString( &AnsiName,
&UnicodeName,
TRUE );
if (!NT_SUCCESS( Status )) {
bprint "SetShortNameInfo: Can't allocate ansi buffer -> %08lx\n", Status );
AsyncSetFile->DisplayParms = FALSE;
} else {
UnwindFreeAnsiString = TRUE;
}
if (AsyncSetFile->DisplayParms) {
bprint "\n" );
bprint "Set FileShortNameInformation Parameters\n" );
bprint " File Handle Index -> %d\n", AsyncSetFile->FileIndex );
bprint " BufferLengthPtr -> %08lx\n", AsyncSetFile->BufferLengthPtr );
if (AsyncSetFile->BufferLengthPtr) {
bprint " BufferLength value -> %08x\n", AsyncSetFile->BufferLength );
}
bprint " Name length -> %d\n", AsyncSetFile->ShortNameLength );
bprint " New short name -> %s\n", AnsiName.Buffer );
bprint "\n" );
}
try {
SIZE_T RegionSize;
ULONG TempIndex;
IO_STATUS_BLOCK Iosb;
RegionSize = sizeof( FILE_NAME_INFORMATION ) + AsyncSetFile->ShortNameLength;
Status = AllocateBuffer( 0, &RegionSize, &TempIndex );
BufferIndex = (USHORT) TempIndex;
if (!NT_SUCCESS( Status )) {
bprint "\tSetShortNameInformation: Unable to allocate structure\n" );
try_return( NOTHING );
}
UnwindBufferIndex = TRUE;
NameInformation = (PFILE_NAME_INFORMATION) Buffers[BufferIndex].Buffer;
//
// Fill in the new information.
//
NameInformation->FileNameLength = AsyncSetFile->ShortNameLength;
RtlMoveMemory( NameInformation->FileName,
UnicodeName.Buffer,
AsyncSetFile->ShortNameLength );
Iosb.Status = STATUS_SUCCESS;
Iosb.Information = 0;
Status = NtSetInformationFile( Handles[AsyncSetFile->FileIndex].Handle,
&Iosb,
NameInformation,
AsyncSetFile->BufferLengthPtr
? AsyncSetFile->BufferLength
: Buffers[BufferIndex].Length,
FileShortNameInformation );
if (AsyncSetFile->VerboseResults) {
bprint "\n" );
bprint " SetShortNameInformation: Status -> %08lx\n", Status );
if (NT_SUCCESS( Status )) {
bprint " Io.Status -> %08lx\n", Iosb.Status );
bprint " Io.Information -> %08lx\n", Iosb.Information );
}
bprint "\n" );
}
try_exit: NOTHING;
} finally {
if (UnwindFreeAnsiString) {
RtlFreeAnsiString( &AnsiName );
}
if (UnwindBufferIndex) {
DeallocateBuffer( BufferIndex );
}
}
return;
}
VOID
SetDispositionInformation(
IN OUT PASYNC_SETFILE AsyncSetFile
)
{
NTSTATUS Status;
PFILE_DISPOSITION_INFORMATION DispositionInformation;
USHORT BufferIndex;
BOOLEAN UnwindBufferIndex = FALSE;
if (AsyncSetFile->DisplayParms) {
bprint "\n" );
bprint "Set FileDispositionInformation Parameters\n" );
bprint " File Handle Index -> %d\n", AsyncSetFile->FileIndex );
bprint " BufferLengthPtr -> %08lx\n", AsyncSetFile->BufferLengthPtr );
if (AsyncSetFile->BufferLengthPtr) {
bprint " BufferLength value -> %08x\n", AsyncSetFile->BufferLength );
}
bprint " Delete file -> %d\n", AsyncSetFile->DeleteFile );
bprint "\n" );
}
try {
SIZE_T RegionSize;
ULONG TempIndex;
IO_STATUS_BLOCK Iosb;
RegionSize = sizeof( FILE_DISPOSITION_INFORMATION );
Status = AllocateBuffer( 0, &RegionSize, &TempIndex );
BufferIndex = (USHORT) TempIndex;
if (!NT_SUCCESS( Status )) {
bprint "\tSetDispositionInformation: Unable to allocate structure\n" );
try_return( NOTHING );
}
UnwindBufferIndex = TRUE;
DispositionInformation = (PFILE_DISPOSITION_INFORMATION) Buffers[BufferIndex].Buffer;
//
// Fill in the new information.
//
DispositionInformation->DeleteFile = AsyncSetFile->DeleteFile;
Iosb.Status = STATUS_SUCCESS;
Iosb.Information = 0;
Status = NtSetInformationFile( Handles[AsyncSetFile->FileIndex].Handle,
&Iosb,
DispositionInformation,
AsyncSetFile->BufferLengthPtr
? AsyncSetFile->BufferLength
: Buffers[BufferIndex].Length,
FileDispositionInformation );
if (AsyncSetFile->VerboseResults) {
bprint "\n" );
bprint " SetDispositionInformation: Status -> %08lx\n", Status );
if (NT_SUCCESS( Status )) {
bprint " Io.Status -> %08lx\n", Iosb.Status );
bprint " Io.Information -> %08lx\n", Iosb.Information );
}
bprint "\n" );
}
try_exit: NOTHING;
} finally {
if (UnwindBufferIndex) {
DeallocateBuffer( BufferIndex );
}
}
return;
}
VOID
SetPositionInformation(
IN OUT PASYNC_SETFILE AsyncSetFile
)
{
NTSTATUS Status;
PFILE_POSITION_INFORMATION PositionInformation;
USHORT BufferIndex;
BOOLEAN UnwindBufferIndex = FALSE;
if (AsyncSetFile->DisplayParms) {
bprint "\n" );
bprint "Set FilePositionInformation Parameters\n" );
bprint " File Handle Index -> %d\n", AsyncSetFile->FileIndex );
bprint " BufferLengthPtr -> %08lx\n", AsyncSetFile->BufferLengthPtr );
if (AsyncSetFile->BufferLengthPtr) {
bprint " BufferLength value -> %08x\n", AsyncSetFile->BufferLength );
}
bprint " New Offset High -> %08lx\n", AsyncSetFile->NewOffset.HighPart );
bprint " New Offset Low -> %08lx\n", AsyncSetFile->NewOffset.LowPart );
bprint "\n" );
}
try {
SIZE_T RegionSize;
ULONG TempIndex;
IO_STATUS_BLOCK Iosb;
RegionSize = sizeof( FILE_POSITION_INFORMATION );
Status = AllocateBuffer( 0, &RegionSize, &TempIndex );
BufferIndex = (USHORT) TempIndex;
if (!NT_SUCCESS( Status )) {
bprint "\tSetPositionInformation: Unable to allocate structure\n" );
try_return( NOTHING );
}
UnwindBufferIndex = TRUE;
PositionInformation = (PFILE_POSITION_INFORMATION) Buffers[BufferIndex].Buffer;
//
// Fill in the new information.
//
PositionInformation->CurrentByteOffset = AsyncSetFile->NewOffset;
Iosb.Status = STATUS_SUCCESS;
Iosb.Information = 0;
Status = NtSetInformationFile( Handles[AsyncSetFile->FileIndex].Handle,
&Iosb,
PositionInformation,
AsyncSetFile->BufferLengthPtr
? AsyncSetFile->BufferLength
: Buffers[BufferIndex].Length,
FilePositionInformation );
if (AsyncSetFile->VerboseResults) {
bprint "\n" );
bprint " SetInformationFile: Status -> %08lx\n", Status );
if (NT_SUCCESS( Status )) {
bprint " Io.Status -> %08lx\n", Iosb.Status );
bprint " Io.Information -> %08lx\n", Iosb.Information );
}
bprint "\n" );
}
try_exit: NOTHING;
} finally {
if (UnwindBufferIndex) {
DeallocateBuffer( BufferIndex );
}
}
return;
}
VOID
SetModeInformation(
IN OUT PASYNC_SETFILE AsyncSetFile
)
{
NTSTATUS Status;
PFILE_MODE_INFORMATION ModeInformation;
USHORT BufferIndex;
BOOLEAN UnwindBufferIndex = FALSE;
if (AsyncSetFile->DisplayParms) {
bprint "\n" );
bprint "Set FileModeInformation Parameters\n" );
bprint " File Handle Index -> %d\n", AsyncSetFile->FileIndex );
bprint " BufferLengthPtr -> %08lx\n", AsyncSetFile->BufferLengthPtr );
if (AsyncSetFile->BufferLengthPtr) {
bprint " BufferLength value -> %08x\n", AsyncSetFile->BufferLength );
}
bprint " File Mode -> %08lx\n", AsyncSetFile->FileMode );
bprint "\n" );
}
try {
SIZE_T RegionSize;
ULONG TempIndex;
IO_STATUS_BLOCK Iosb;
RegionSize = sizeof( FILE_MODE_INFORMATION );
Status = AllocateBuffer( 0, &RegionSize, &TempIndex );
BufferIndex = (USHORT) TempIndex;
if (!NT_SUCCESS( Status )) {
bprint "\tSetModeInformation: Unable to allocate structure\n" );
try_return( NOTHING );
}
UnwindBufferIndex = TRUE;
ModeInformation = (PFILE_MODE_INFORMATION) Buffers[BufferIndex].Buffer;
//
// Fill in the new information.
//
ModeInformation->Mode = AsyncSetFile->FileMode;
Iosb.Status = STATUS_SUCCESS;
Iosb.Information = 0;
Status = NtSetInformationFile( Handles[AsyncSetFile->FileIndex].Handle,
&Iosb,
ModeInformation,
AsyncSetFile->BufferLengthPtr
? AsyncSetFile->BufferLength
: Buffers[BufferIndex].Length,
FileModeInformation );
if (AsyncSetFile->VerboseResults) {
bprint "\n" );
bprint " SetModelInformation: Status -> %08lx\n", Status );
if (NT_SUCCESS( Status )) {
bprint " Io.Status -> %08lx\n", Iosb.Status );
bprint " Io.Information -> %08lx\n", Iosb.Information );
}
bprint "\n" );
}
try_exit: NOTHING;
} finally {
if (UnwindBufferIndex) {
DeallocateBuffer( BufferIndex );
}
}
return;
}
VOID
SetAllocationInformation(
IN OUT PASYNC_SETFILE AsyncSetFile
)
{
NTSTATUS Status;
PFILE_ALLOCATION_INFORMATION AllocationInformation;
USHORT BufferIndex;
BOOLEAN UnwindBufferIndex = FALSE;
if (AsyncSetFile->DisplayParms) {
bprint "\n" );
bprint "Set FileAllocationInformation Parameters\n" );
bprint " File Handle Index -> %d\n", AsyncSetFile->FileIndex );
bprint " BufferLengthPtr -> %08lx\n", AsyncSetFile->BufferLengthPtr );
if (AsyncSetFile->BufferLengthPtr) {
bprint " BufferLength value -> %08x\n", AsyncSetFile->BufferLength );
}
bprint " New Allocation High -> %08lx\n", AsyncSetFile->NewAllocation.HighPart );
bprint " New Allocation Low -> %08lx\n", AsyncSetFile->NewAllocation.LowPart );
bprint "\n" );
}
try {
SIZE_T RegionSize;
ULONG TempIndex;
IO_STATUS_BLOCK Iosb;
RegionSize = sizeof( FILE_ALLOCATION_INFORMATION );
Status = AllocateBuffer( 0, &RegionSize, &TempIndex );
BufferIndex = (USHORT) TempIndex;
if (!NT_SUCCESS( Status )) {
bprint "\tSetAllocationInformation: Unable to allocate structure\n" );
try_return( NOTHING );
}
UnwindBufferIndex = TRUE;
AllocationInformation = (PFILE_ALLOCATION_INFORMATION) Buffers[BufferIndex].Buffer;
//
// Fill in the new information.
//
AllocationInformation->AllocationSize = AsyncSetFile->NewAllocation;
Iosb.Status = STATUS_SUCCESS;
Iosb.Information = 0;
Status = NtSetInformationFile( Handles[AsyncSetFile->FileIndex].Handle,
&Iosb,
AllocationInformation,
AsyncSetFile->BufferLengthPtr
? AsyncSetFile->BufferLength
: Buffers[BufferIndex].Length,
FileAllocationInformation );
if (AsyncSetFile->VerboseResults) {
bprint "\n" );
bprint " SetAllocationInformation: Status -> %08lx\n", Status );
if (NT_SUCCESS( Status )) {
bprint " Io.Status -> %08lx\n", Iosb.Status );
bprint " Io.Information -> %08lx\n", Iosb.Information );
}
bprint "\n" );
}
try_exit: NOTHING;
} finally {
if (UnwindBufferIndex) {
DeallocateBuffer( BufferIndex );
}
}
return;
}
VOID
SetEofInformation(
IN OUT PASYNC_SETFILE AsyncSetFile
)
{
NTSTATUS Status;
PFILE_END_OF_FILE_INFORMATION EofInformation;
USHORT BufferIndex;
BOOLEAN UnwindBufferIndex = FALSE;
if (AsyncSetFile->DisplayParms) {
bprint "\n" );
bprint "Set FileEofInformation Parameters\n" );
bprint " File Handle Index -> %d\n", AsyncSetFile->FileIndex );
bprint " BufferLengthPtr -> %08lx\n", AsyncSetFile->BufferLengthPtr );
if (AsyncSetFile->BufferLengthPtr) {
bprint " BufferLength value -> %08x\n", AsyncSetFile->BufferLength );
}
bprint " New Eof High -> %08lx\n", AsyncSetFile->NewEof.HighPart );
bprint " New Eof Low -> %08lx\n", AsyncSetFile->NewEof.LowPart );
bprint "\n" );
}
try {
SIZE_T RegionSize;
ULONG TempIndex;
IO_STATUS_BLOCK Iosb;
RegionSize = sizeof( FILE_END_OF_FILE_INFORMATION );
Status = AllocateBuffer( 0, &RegionSize, &TempIndex );
BufferIndex = (USHORT) TempIndex;
if (!NT_SUCCESS( Status )) {
bprint "\tSetEofInformation: Unable to allocate structure\n" );
try_return( NOTHING );
}
UnwindBufferIndex = TRUE;
EofInformation = (PFILE_END_OF_FILE_INFORMATION) Buffers[BufferIndex].Buffer;
//
// Fill in the new information.
//
EofInformation->EndOfFile = AsyncSetFile->NewEof;
Iosb.Status = STATUS_SUCCESS;
Iosb.Information = 0;
Status = NtSetInformationFile( Handles[AsyncSetFile->FileIndex].Handle,
&Iosb,
EofInformation,
AsyncSetFile->BufferLengthPtr
? AsyncSetFile->BufferLength
: Buffers[BufferIndex].Length,
FileEndOfFileInformation );
if (AsyncSetFile->VerboseResults) {
bprint "\n" );
bprint " SetEOFInformation: Status -> %08lx\n", Status );
if (NT_SUCCESS( Status )) {
bprint " Io.Status -> %08lx\n", Iosb.Status );
bprint " Io.Information -> %08lx\n", Iosb.Information );
}
bprint "\n" );
}
try_exit: NOTHING;
} finally {
if (UnwindBufferIndex) {
DeallocateBuffer( BufferIndex );
}
}
return;
}
Reference in a new issue Copy permalink