|
|
#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
VOIDFullSetFile( IN OUT PASYNC_SETFILE AsyncSetFile );
VOIDSetBasicInformation( IN OUT PASYNC_SETFILE AsyncSetFile );
VOIDSetRenameInformation( IN OUT PASYNC_SETFILE AsyncSetFile );
VOIDSetNameInformation( IN OUT PASYNC_SETFILE AsyncSetFile );
VOIDSetShortNameInformation( IN OUT PASYNC_SETFILE AsyncSetFile );
VOIDSetDispositionInformation( IN OUT PASYNC_SETFILE AsyncSetFile );
VOIDSetPositionInformation( IN OUT PASYNC_SETFILE AsyncSetFile );
VOIDSetModeInformation ( IN OUT PASYNC_SETFILE AsyncSetFile );
VOIDSetAllocationInformation( IN OUT PASYNC_SETFILE AsyncSetFile );
VOIDSetEofInformation( IN OUT PASYNC_SETFILE AsyncSetFile );
VOIDInputSetFile ( 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;}
VOIDFullSetFile( 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 ); }
if (!SynchronousCmds) {
NtTerminateThread( 0, STATUS_SUCCESS ); }}
VOIDSetBasicInformation( 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;}
VOIDSetRenameInformation( 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;}
VOIDSetNameInformation( 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;}
VOIDSetShortNameInformation( 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;}
VOIDSetDispositionInformation( 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;}
VOIDSetPositionInformation( 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;}
VOIDSetModeInformation( 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;}
VOIDSetAllocationInformation( 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;}
VOIDSetEofInformation( 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;}
|
