OS_Develop/WindowsXP
OS_Develop/WindowsXP
1
0
Fork 0
Code Pull Requests Activity
master
WindowsXP/Source/XPSP1/NT/base/win32/client/filehops.c

3192 lines
93 KiB
C
Raw Permalink Normal View History

Initial commit
2024-08-03 16:30:48 +02:00
/*++
Copyright (c) 1990 Microsoft Corporation
Module Name:
filehops.c
Abstract:
This module implements Win32 file handle APIs
Author:
Mark Lucovsky (markl) 25-Sep-1990
Revision History:
--*/
#include "basedll.h"
HANDLE
WINAPI
GetStdHandle(
DWORD nStdHandle
)
{
PPEB Peb;
HANDLE rv;
Peb = NtCurrentPeb();
switch( nStdHandle ) {
case STD_INPUT_HANDLE:
rv = Peb->ProcessParameters->StandardInput;
break;
case STD_OUTPUT_HANDLE:
rv = Peb->ProcessParameters->StandardOutput;
break;
case STD_ERROR_HANDLE:
rv = Peb->ProcessParameters->StandardError;
break;
default:
rv = INVALID_HANDLE_VALUE;
break;
}
if ( rv == INVALID_HANDLE_VALUE ) {
BaseSetLastNTError(STATUS_INVALID_HANDLE);
}
return rv;
}
BOOL
WINAPI
SetStdHandle(
DWORD nStdHandle,
HANDLE hHandle
)
{
PPEB Peb;
Peb = NtCurrentPeb();
switch( nStdHandle ) {
case STD_INPUT_HANDLE:
Peb->ProcessParameters->StandardInput = hHandle;
break;
case STD_OUTPUT_HANDLE:
Peb->ProcessParameters->StandardOutput = hHandle;
break;
case STD_ERROR_HANDLE:
Peb->ProcessParameters->StandardError = hHandle;
break;
default:
BaseSetLastNTError(STATUS_INVALID_HANDLE);
return FALSE;
}
return( TRUE );
}
DWORD
WINAPI
GetFileType(
HANDLE hFile
)
/*++
Routine Description:
GetFileType is used to determine the file type of the specified file.
Arguments:
hFile - Supplies an open handle to a file whose type is to be
determined
Return Value:
FILE_TYPE_UNKNOWN - The type of the specified file is unknown.
FILE_TYPE_DISK - The specified file is a disk file.
FILE_TYPE_CHAR - The specified file is a character file (LPT,
console...)
FILE_TYPE_PIPE - The specified file is a pipe (either a named pipe or
a pipe created by CreatePipe).
--*/
{
NTSTATUS Status;
FILE_FS_DEVICE_INFORMATION DeviceInformation;
IO_STATUS_BLOCK IoStatusBlock;
PPEB Peb;
Peb = NtCurrentPeb();
switch( HandleToUlong(hFile) ) {
case STD_INPUT_HANDLE:
hFile = Peb->ProcessParameters->StandardInput;
break;
case STD_OUTPUT_HANDLE:
hFile = Peb->ProcessParameters->StandardOutput;
break;
case STD_ERROR_HANDLE:
hFile = Peb->ProcessParameters->StandardError;
break;
}
if (CONSOLE_HANDLE(hFile) && VerifyConsoleIoHandle(hFile)) {
return( FILE_TYPE_CHAR );
}
if (hFile == NULL) {
BaseSetLastNTError( STATUS_INVALID_HANDLE );
return( FILE_TYPE_UNKNOWN );
}
//
// If handle cannot be a real kernel handle we will fail
// the call instead of calling with a bogus value NtQuery.
//
if (((ULONG_PTR)hFile & 0x01)) {
BaseSetLastNTError( STATUS_INVALID_HANDLE );
return( FILE_TYPE_UNKNOWN );
}
Status = NtQueryVolumeInformationFile( hFile,
&IoStatusBlock,
&DeviceInformation,
sizeof( DeviceInformation ),
FileFsDeviceInformation
);
if (!NT_SUCCESS( Status )) {
BaseSetLastNTError( Status );
return( FILE_TYPE_UNKNOWN );
}
switch( DeviceInformation.DeviceType ) {
case FILE_DEVICE_SCREEN:
case FILE_DEVICE_KEYBOARD:
case FILE_DEVICE_MOUSE:
case FILE_DEVICE_PARALLEL_PORT:
case FILE_DEVICE_PRINTER:
case FILE_DEVICE_SERIAL_PORT:
case FILE_DEVICE_MODEM:
case FILE_DEVICE_SOUND:
case FILE_DEVICE_NULL:
return( FILE_TYPE_CHAR );
case FILE_DEVICE_CD_ROM:
case FILE_DEVICE_CD_ROM_FILE_SYSTEM:
case FILE_DEVICE_CONTROLLER:
case FILE_DEVICE_DATALINK:
case FILE_DEVICE_DFS:
case FILE_DEVICE_DISK:
case FILE_DEVICE_DISK_FILE_SYSTEM:
case FILE_DEVICE_VIRTUAL_DISK:
return( FILE_TYPE_DISK );
case FILE_DEVICE_NAMED_PIPE:
return( FILE_TYPE_PIPE );
case FILE_DEVICE_NETWORK:
case FILE_DEVICE_NETWORK_FILE_SYSTEM:
case FILE_DEVICE_PHYSICAL_NETCARD:
case FILE_DEVICE_TAPE:
case FILE_DEVICE_TAPE_FILE_SYSTEM:
case FILE_DEVICE_TRANSPORT:
// FIX, FIX - how to handle tapes, network devices, etc.
case FILE_DEVICE_UNKNOWN:
default:
SetLastError( NO_ERROR );
return( FILE_TYPE_UNKNOWN );
}
}
BOOL
WINAPI
ReadFile(
HANDLE hFile,
LPVOID lpBuffer,
DWORD nNumberOfBytesToRead,
LPDWORD lpNumberOfBytesRead,
LPOVERLAPPED lpOverlapped
)
/*++
Routine Description:
Data can be read from a file using ReadFile.
This API is used to read data from a file. Data is read from the
file from the position indicated by the file pointer. After the
read completes, the file pointer is adjusted by the number of bytes
actually read. A return value of TRUE coupled with a bytes read of
0 indicates that the file pointer was beyond the current end of the
file at the time of the read.
Arguments:
hFile - Supplies an open handle to a file that is to be read. The
file handle must have been created with GENERIC_READ access to
the file.
lpBuffer - Supplies the address of a buffer to receive the data read
from the file.
nNumberOfBytesToRead - Supplies the number of bytes to read from the
file.
lpNumberOfBytesRead - Returns the number of bytes read by this call.
This parameter is always set to 0 before doing any IO or error
checking.
lpOverlapped - Optionally points to an OVERLAPPED structure to be used with the
request. If NULL then the transfer starts at the current file position
and ReadFile will not return until the operation completes.
If the handle hFile was created without specifying FILE_FLAG_OVERLAPPED
the file pointer is moved to the specified offset plus
lpNumberOfBytesRead before ReadFile returns. ReadFile will wait for the
request to complete before returning (it will not return
ERROR_IO_PENDING).
When FILE_FLAG_OVERLAPPED is specified, ReadFile may return
ERROR_IO_PENDING to allow the calling function to continue processing
while the operation completes. The event (or hFile if hEvent is NULL) will
be set to the signalled state upon completion of the request.
When the handle is created with FILE_FLAG_OVERLAPPED and lpOverlapped
is set to NULL, ReadFile will return ERROR_INVALID_PARAMTER because
the file offset is required.
Return Value:
TRUE - The operation was successul.
FALSE - The operation failed. Extended error status is available
using GetLastError.
--*/
{
NTSTATUS Status;
IO_STATUS_BLOCK IoStatusBlock;
PPEB Peb;
DWORD InputMode;
if ( ARGUMENT_PRESENT(lpNumberOfBytesRead) ) {
*lpNumberOfBytesRead = 0;
}
Peb = NtCurrentPeb();
switch( HandleToUlong(hFile) ) {
case STD_INPUT_HANDLE: hFile = Peb->ProcessParameters->StandardInput;
break;
case STD_OUTPUT_HANDLE: hFile = Peb->ProcessParameters->StandardOutput;
break;
case STD_ERROR_HANDLE: hFile = Peb->ProcessParameters->StandardError;
break;
}
if (CONSOLE_HANDLE(hFile)) {
if (ReadConsoleA(hFile,
lpBuffer,
nNumberOfBytesToRead,
lpNumberOfBytesRead,
lpOverlapped
)
) {
Status = STATUS_SUCCESS;
if (!GetConsoleMode( hFile, &InputMode )) {
InputMode = 0;
}
if (InputMode & ENABLE_PROCESSED_INPUT) {
try {
if (*(PCHAR)lpBuffer == 0x1A) {
*lpNumberOfBytesRead = 0;
}
}
except( EXCEPTION_EXECUTE_HANDLER ) {
Status = GetExceptionCode();
}
}
if (NT_SUCCESS(Status)) {
return TRUE;
}
else {
BaseSetLastNTError(Status);
return FALSE;
}
}
else {
return FALSE;
}
}
if ( ARGUMENT_PRESENT( lpOverlapped ) ) {
LARGE_INTEGER Li;
lpOverlapped->Internal = (DWORD)STATUS_PENDING;
Li.LowPart = lpOverlapped->Offset;
Li.HighPart = lpOverlapped->OffsetHigh;
Status = NtReadFile(
hFile,
lpOverlapped->hEvent,
NULL,
(ULONG_PTR)lpOverlapped->hEvent & 1 ? NULL : lpOverlapped,
(PIO_STATUS_BLOCK)&lpOverlapped->Internal,
lpBuffer,
nNumberOfBytesToRead,
&Li,
NULL
);
if ( NT_SUCCESS(Status) && Status != STATUS_PENDING) {
if ( ARGUMENT_PRESENT(lpNumberOfBytesRead) ) {
try {
*lpNumberOfBytesRead = (DWORD)lpOverlapped->InternalHigh;
}
except(EXCEPTION_EXECUTE_HANDLER) {
*lpNumberOfBytesRead = 0;
}
}
return TRUE;
}
else
if (Status == STATUS_END_OF_FILE) {
if ( ARGUMENT_PRESENT(lpNumberOfBytesRead) ) {
*lpNumberOfBytesRead = 0;
}
BaseSetLastNTError(Status);
return FALSE;
}
else {
BaseSetLastNTError(Status);
return FALSE;
}
}
else
{
Status = NtReadFile(
hFile,
NULL,
NULL,
NULL,
&IoStatusBlock,
lpBuffer,
nNumberOfBytesToRead,
NULL,
NULL
);
if ( Status == STATUS_PENDING) {
// Operation must complete before return & IoStatusBlock destroyed
Status = NtWaitForSingleObject( hFile, FALSE, NULL );
if ( NT_SUCCESS(Status)) {
Status = IoStatusBlock.Status;
}
}
if ( NT_SUCCESS(Status) ) {
*lpNumberOfBytesRead = (DWORD)IoStatusBlock.Information;
return TRUE;
}
else
if (Status == STATUS_END_OF_FILE) {
*lpNumberOfBytesRead = 0;
return TRUE;
}
else {
if ( NT_WARNING(Status) ) {
*lpNumberOfBytesRead = (DWORD)IoStatusBlock.Information;
}
BaseSetLastNTError(Status);
return FALSE;
}
}
}
BOOL
WINAPI
WriteFile(
HANDLE hFile,
LPCVOID lpBuffer,
DWORD nNumberOfBytesToWrite,
LPDWORD lpNumberOfBytesWritten,
LPOVERLAPPED lpOverlapped
)
/*++
Routine Description:
Data can be written to a file using WriteFile.
This API is used to write data to a file. Data is written to the
file from the position indicated by the file pointer. After the
write completes, the file pointer is adjusted by the number of bytes
actually written.
Unlike DOS, a NumberOfBytesToWrite value of zero does not truncate
or extend the file. If this function is required, SetEndOfFile
should be used.
Arguments:
hFile - Supplies an open handle to a file that is to be written. The
file handle must have been created with GENERIC_WRITE access to
the file.
lpBuffer - Supplies the address of the data that is to be written to
the file.
nNumberOfBytesToWrite - Supplies the number of bytes to write to the
file. Unlike DOS, a value of zero is interpreted a null write.
lpNumberOfBytesWritten - Returns the number of bytes written by this
call. Before doing any work or error processing, the API sets this
to zero.
lpOverlapped - Optionally points to an OVERLAPPED structure to be
used with the request. If NULL then the transfer starts at the
current file position and WriteFile will not return until the
operation completes.
If the handle <hFile> was created without specifying
FILE_FLAG_OVERLAPPED the file pointer is moved to the specified
offset plus lpNumberOfBytesWritten before WriteFile returns.
WriteFile will wait for the request to complete before returning
(it will not set ERROR_IO_PENDING).
When FILE_FLAG_OVERLAPPED is specified, WriteFile may return
ERROR_IO_PENDING to allow the calling function to continue processing
while the operation completes. The event (or hFile if hEvent is NULL) will
be set to the signalled state upon completion of the request.
When the handle is created with FILE_FLAG_OVERLAPPED and lpOverlapped
is set to NULL, WriteFile will return ERROR_INVALID_PARAMTER because
the file offset is required.
Return Value:
TRUE - The operation was a success.
FALSE - The operation failed. Extended error status is
available using GetLastError.
--*/
{
NTSTATUS Status;
IO_STATUS_BLOCK IoStatusBlock;
PPEB Peb;
if ( ARGUMENT_PRESENT(lpNumberOfBytesWritten) ) {
*lpNumberOfBytesWritten = 0;
}
Peb = NtCurrentPeb();
switch( HandleToUlong(hFile) ) {
case STD_INPUT_HANDLE: hFile = Peb->ProcessParameters->StandardInput;
break;
case STD_OUTPUT_HANDLE: hFile = Peb->ProcessParameters->StandardOutput;
break;
case STD_ERROR_HANDLE: hFile = Peb->ProcessParameters->StandardError;
break;
}
if (CONSOLE_HANDLE(hFile)) {
return WriteConsoleA(hFile,
(LPVOID)lpBuffer,
nNumberOfBytesToWrite,
lpNumberOfBytesWritten,
lpOverlapped
);
}
if ( ARGUMENT_PRESENT( lpOverlapped ) ) {
LARGE_INTEGER Li;
lpOverlapped->Internal = (DWORD)STATUS_PENDING;
Li.LowPart = lpOverlapped->Offset;
Li.HighPart = lpOverlapped->OffsetHigh;
Status = NtWriteFile(
hFile,
lpOverlapped->hEvent,
NULL,
(ULONG_PTR)lpOverlapped->hEvent & 1 ? NULL : lpOverlapped,
(PIO_STATUS_BLOCK)&lpOverlapped->Internal,
(PVOID)lpBuffer,
nNumberOfBytesToWrite,
&Li,
NULL
);
if ( !NT_ERROR(Status) && Status != STATUS_PENDING) {
if ( ARGUMENT_PRESENT(lpNumberOfBytesWritten) ) {
try {
*lpNumberOfBytesWritten = (DWORD)lpOverlapped->InternalHigh;
}
except(EXCEPTION_EXECUTE_HANDLER) {
*lpNumberOfBytesWritten = 0;
}
}
return TRUE;
}
else {
BaseSetLastNTError(Status);
return FALSE;
}
}
else {
Status = NtWriteFile(
hFile,
NULL,
NULL,
NULL,
&IoStatusBlock,
(PVOID)lpBuffer,
nNumberOfBytesToWrite,
NULL,
NULL
);
if ( Status == STATUS_PENDING) {
// Operation must complete before return & IoStatusBlock destroyed
Status = NtWaitForSingleObject( hFile, FALSE, NULL );
if ( NT_SUCCESS(Status)) {
Status = IoStatusBlock.Status;
}
}
if ( NT_SUCCESS(Status)) {
*lpNumberOfBytesWritten = (DWORD)IoStatusBlock.Information;
return TRUE;
}
else {
if ( NT_WARNING(Status) ) {
*lpNumberOfBytesWritten = (DWORD)IoStatusBlock.Information;
}
BaseSetLastNTError(Status);
return FALSE;
}
}
}
BOOL
WINAPI
SetEndOfFile(
HANDLE hFile
)
/*++
Routine Description:
The end of file position of an open file can be set to the current
file pointer using SetEndOfFile.
This API is used to set the end of file position of a file to the
same value as the current file pointer. This has the effect of
truncating or extending a file. This functionality is similar to
DOS (int 21h, function 40H with CX=0).
Arguments:
hFile - Supplies an open handle to a file that is to be extended or
truncated. The file handle must have been created with
GENERIC_WRITE access to the file.
Return Value:
TRUE - The operation was successful.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
NTSTATUS Status;
IO_STATUS_BLOCK IoStatusBlock;
FILE_POSITION_INFORMATION CurrentPosition;
FILE_END_OF_FILE_INFORMATION EndOfFile;
FILE_ALLOCATION_INFORMATION Allocation;
if (CONSOLE_HANDLE(hFile)) {
BaseSetLastNTError(STATUS_INVALID_HANDLE);
return FALSE;
}
//
// Get the current position of the file pointer
//
Status = NtQueryInformationFile(
hFile,
&IoStatusBlock,
&CurrentPosition,
sizeof(CurrentPosition),
FilePositionInformation
);
if ( !NT_SUCCESS(Status) ) {
BaseSetLastNTError(Status);
return FALSE;
}
//
// Set the end of file based on the current file position
//
EndOfFile.EndOfFile = CurrentPosition.CurrentByteOffset;
Status = NtSetInformationFile(
hFile,
&IoStatusBlock,
&EndOfFile,
sizeof(EndOfFile),
FileEndOfFileInformation
);
if ( !NT_SUCCESS(Status) ) {
BaseSetLastNTError(Status);
return FALSE;
}
//
// Set the allocation based on the current file size
//
Allocation.AllocationSize = CurrentPosition.CurrentByteOffset;
Status = NtSetInformationFile(
hFile,
&IoStatusBlock,
&Allocation,
sizeof(Allocation),
FileAllocationInformation
);
if ( NT_SUCCESS(Status) ) {
return TRUE;
}
else {
BaseSetLastNTError(Status);
return FALSE;
}
}
DWORD
WINAPI
SetFilePointer(
HANDLE hFile,
LONG lDistanceToMove,
PLONG lpDistanceToMoveHigh,
DWORD dwMoveMethod
)
/*++
Routine Description:
An open file's file pointer can be set using SetFilePointer.
The purpose of this function is to update the current value of a
file's file pointer. Care should be taken in multi-threaded
applications that have multiple threads sharing a file handle with
each thread updating the file pointer and then doing a read. This
sequence should be treated as a critical section of code and should
be protected using either a critical section object or a mutex
object.
This API provides the same functionality as DOS (int 21h, function
42h) and OS/2's DosSetFilePtr.
Arguments:
hFile - Supplies an open handle to a file whose file pointer is to be
moved. The file handle must have been created with
GENERIC_READ or GENERIC_WRITE access to the file.
lDistanceToMove - Supplies the number of bytes to move the file
pointer. A positive value moves the pointer forward in the file
and a negative value moves backwards in the file.
lpDistanceToMoveHigh - An optional parameter that if specified
supplies the high order 32-bits of the 64-bit distance to move.
If the value of this parameter is NULL, this API can only
operate on files whose maximum size is (2**32)-2. If this
parameter is specified, than the maximum file size is (2**64)-2.
This value also returns the high order 32-bits of the new value
of the file pointer. If this value, and the return value
are 0xffffffff, then an error is indicated.
dwMoveMethod - Supplies a value that specifies the starting point
for the file pointer move.
FILE_BEGIN - The starting point is zero or the beginning of the
file. If FILE_BEGIN is specified, then DistanceToMove is
interpreted as an unsigned location for the new
file pointer.
FILE_CURRENT - The current value of the file pointer is used as
the starting point.
FILE_END - The current end of file position is used as the
starting point.
Return Value:
Not -1 - Returns the low order 32-bits of the new value of the file
pointer.
0xffffffff - If the value of lpDistanceToMoveHigh was NULL, then The
operation failed. Extended error status is available using
GetLastError. Otherwise, this is the low order 32-bits of the
new value of the file pointer.
--*/
{
NTSTATUS Status;
IO_STATUS_BLOCK IoStatusBlock;
FILE_POSITION_INFORMATION CurrentPosition;
FILE_STANDARD_INFORMATION StandardInfo;
LARGE_INTEGER Large;
if (CONSOLE_HANDLE(hFile)) {
BaseSetLastNTError(STATUS_INVALID_HANDLE);
return (DWORD)-1;
}
if (ARGUMENT_PRESENT(lpDistanceToMoveHigh)) {
Large.HighPart = *lpDistanceToMoveHigh;
Large.LowPart = lDistanceToMove;
}
else {
Large.QuadPart = lDistanceToMove;
}
switch (dwMoveMethod) {
case FILE_BEGIN :
CurrentPosition.CurrentByteOffset = Large;
break;
case FILE_CURRENT :
//
// Get the current position of the file pointer
//
Status = NtQueryInformationFile(
hFile,
&IoStatusBlock,
&CurrentPosition,
sizeof(CurrentPosition),
FilePositionInformation
);
if ( !NT_SUCCESS(Status) ) {
BaseSetLastNTError(Status);
return (DWORD)-1;
}
CurrentPosition.CurrentByteOffset.QuadPart += Large.QuadPart;
break;
case FILE_END :
Status = NtQueryInformationFile(
hFile,
&IoStatusBlock,
&StandardInfo,
sizeof(StandardInfo),
FileStandardInformation
);
if ( !NT_SUCCESS(Status) ) {
BaseSetLastNTError(Status);
return (DWORD)-1;
}
CurrentPosition.CurrentByteOffset.QuadPart =
StandardInfo.EndOfFile.QuadPart + Large.QuadPart;
break;
default:
SetLastError(ERROR_INVALID_PARAMETER);
return (DWORD)-1;
break;
}
//
// If the resulting file position is negative, or if the app is not
// prepared for greater than
// then 32 bits than fail
//
if ( CurrentPosition.CurrentByteOffset.QuadPart < 0 ) {
SetLastError(ERROR_NEGATIVE_SEEK);
return (DWORD)-1;
}
if ( !ARGUMENT_PRESENT(lpDistanceToMoveHigh) &&
(CurrentPosition.CurrentByteOffset.HighPart & MAXLONG) ) {
SetLastError(ERROR_INVALID_PARAMETER);
return (DWORD)-1;
}
//
// Set the current file position
//
Status = NtSetInformationFile(
hFile,
&IoStatusBlock,
&CurrentPosition,
sizeof(CurrentPosition),
FilePositionInformation
);
if ( NT_SUCCESS(Status) ) {
if (ARGUMENT_PRESENT(lpDistanceToMoveHigh)){
*lpDistanceToMoveHigh = CurrentPosition.CurrentByteOffset.HighPart;
}
if ( CurrentPosition.CurrentByteOffset.LowPart == -1 ) {
SetLastError(0);
}
return CurrentPosition.CurrentByteOffset.LowPart;
}
else {
BaseSetLastNTError(Status);
if (ARGUMENT_PRESENT(lpDistanceToMoveHigh)){
*lpDistanceToMoveHigh = -1;
}
return (DWORD)-1;
}
}
BOOL
WINAPI
SetFilePointerEx(
HANDLE hFile,
LARGE_INTEGER liDistanceToMove,
PLARGE_INTEGER lpNewFilePointer,
DWORD dwMoveMethod
)
/*++
Routine Description:
An open file's file pointer can be set using SetFilePointer.
The purpose of this function is to update the current value of a
file's file pointer. Care should be taken in multi-threaded
applications that have multiple threads sharing a file handle with
each thread updating the file pointer and then doing a read. This
sequence should be treated as a critical section of code and should
be protected using either a critical section object or a mutex
object.
This API provides the same functionality as DOS (int 21h, function
42h) and OS/2's DosSetFilePtr.
Arguments:
hFile - Supplies an open handle to a file whose file pointer is to be
moved. The file handle must have been created with
GENERIC_READ or GENERIC_WRITE access to the file.
liDistanceToMove - Supplies the number of bytes to move the file
pointer. A positive value moves the pointer forward in the file
and a negative value moves backwards in the file.
lpNewFilePointer - An optional parameter that if specified returns
the new file pointer
dwMoveMethod - Supplies a value that specifies the starting point
for the file pointer move.
FILE_BEGIN - The starting point is zero or the beginning of the
file. If FILE_BEGIN is specified, then DistanceToMove is
interpreted as an unsigned location for the new
file pointer.
FILE_CURRENT - The current value of the file pointer is used as
the starting point.
FILE_END - The current end of file position is used as the
starting point.
Return Value:
TRUE - The operation was successful
FALSE - The operation failed. Extended error status is available using
GetLastError.
--*/
{
NTSTATUS Status;
IO_STATUS_BLOCK IoStatusBlock;
FILE_POSITION_INFORMATION CurrentPosition;
FILE_STANDARD_INFORMATION StandardInfo;
LARGE_INTEGER Large;
if (CONSOLE_HANDLE(hFile)) {
BaseSetLastNTError(STATUS_INVALID_HANDLE);
return FALSE;
}
Large = liDistanceToMove;
switch (dwMoveMethod) {
case FILE_BEGIN :
CurrentPosition.CurrentByteOffset = Large;
break;
case FILE_CURRENT :
//
// Get the current position of the file pointer
//
Status = NtQueryInformationFile(
hFile,
&IoStatusBlock,
&CurrentPosition,
sizeof(CurrentPosition),
FilePositionInformation
);
if ( !NT_SUCCESS(Status) ) {
BaseSetLastNTError(Status);
return FALSE;
}
CurrentPosition.CurrentByteOffset.QuadPart += Large.QuadPart;
break;
case FILE_END :
Status = NtQueryInformationFile(
hFile,
&IoStatusBlock,
&StandardInfo,
sizeof(StandardInfo),
FileStandardInformation
);
if ( !NT_SUCCESS(Status) ) {
BaseSetLastNTError(Status);
return FALSE;
}
CurrentPosition.CurrentByteOffset.QuadPart =
StandardInfo.EndOfFile.QuadPart + Large.QuadPart;
break;
default:
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
break;
}
//
// If the resulting file position is negative fail
//
if ( CurrentPosition.CurrentByteOffset.QuadPart < 0 ) {
SetLastError(ERROR_NEGATIVE_SEEK);
return FALSE;
}
//
// Set the current file position
//
Status = NtSetInformationFile(
hFile,
&IoStatusBlock,
&CurrentPosition,
sizeof(CurrentPosition),
FilePositionInformation
);
if ( NT_SUCCESS(Status) ) {
if (ARGUMENT_PRESENT(lpNewFilePointer)){
*lpNewFilePointer = CurrentPosition.CurrentByteOffset;
}
return TRUE;
}
else {
BaseSetLastNTError(Status);
return FALSE;
}
}
BOOL
WINAPI
GetFileInformationByHandle(
HANDLE hFile,
LPBY_HANDLE_FILE_INFORMATION lpFileInformation
)
/*++
Routine Description:
Arguments:
hFile - Supplies an open handle to a file whose modification date and
times are to be read. The file handle must have been created with
GENERIC_READ access to the file.
lpCreationTime - An optional parameter that if specified points to
the location to return the date and time the file was created.
A returned time of all zero indicates that the file system
containing the file does not support this time value.
Return Value:
TRUE - The operation was successful.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
NTSTATUS Status;
IO_STATUS_BLOCK IoStatusBlock;
BY_HANDLE_FILE_INFORMATION LocalFileInformation;
FILE_ALL_INFORMATION FileInformation;
FILE_FS_VOLUME_INFORMATION VolumeInfo;
if (CONSOLE_HANDLE(hFile)) {
BaseSetLastNTError(STATUS_INVALID_HANDLE);
return FALSE;
}
Status = NtQueryVolumeInformationFile(
hFile,
&IoStatusBlock,
&VolumeInfo,
sizeof(VolumeInfo),
FileFsVolumeInformation
);
if ( !NT_ERROR(Status) ) {
LocalFileInformation.dwVolumeSerialNumber = VolumeInfo.VolumeSerialNumber;
}
else {
BaseSetLastNTError(Status);
return FALSE;
}
Status = NtQueryInformationFile(
hFile,
&IoStatusBlock,
&FileInformation,
sizeof(FileInformation),
FileAllInformation
);
//
// we really plan for buffer overflow
//
if ( !NT_ERROR(Status) ) {
LocalFileInformation.dwFileAttributes = FileInformation.BasicInformation.FileAttributes;
LocalFileInformation.ftCreationTime = *(LPFILETIME)&FileInformation.BasicInformation.CreationTime;
LocalFileInformation.ftLastAccessTime = *(LPFILETIME)&FileInformation.BasicInformation.LastAccessTime;
LocalFileInformation.ftLastWriteTime = *(LPFILETIME)&FileInformation.BasicInformation.LastWriteTime;
LocalFileInformation.nFileSizeHigh = FileInformation.StandardInformation.EndOfFile.HighPart;
LocalFileInformation.nFileSizeLow = FileInformation.StandardInformation.EndOfFile.LowPart;
LocalFileInformation.nNumberOfLinks = FileInformation.StandardInformation.NumberOfLinks;
LocalFileInformation.nFileIndexHigh = FileInformation.InternalInformation.IndexNumber.HighPart;
LocalFileInformation.nFileIndexLow = FileInformation.InternalInformation.IndexNumber.LowPart;
}
else {
BaseSetLastNTError(Status);
return FALSE;
}
*lpFileInformation = LocalFileInformation;
return TRUE;
}
BOOL
APIENTRY
GetFileTime(
HANDLE hFile,
LPFILETIME lpCreationTime,
LPFILETIME lpLastAccessTime,
LPFILETIME lpLastWriteTime
)
/*++
Routine Description:
The date and time that a file was created, last accessed or last
modified can be read using GetFileTime. File time stamps are
returned as 64-bit values, that represent the number of 100
nanoseconds since January 1st, 1601. This date was chosen because
it is the start of a new quadricentury. At 100ns resolution 32 bits
is good for about 429 seconds (or 7 minutes) and a 63-bit integer is
good for about 29,247 years, or around 10,682,247 days.
This API provides the same functionality as DOS (int 21h, function
47H with AL=0), and provides a subset of OS/2's DosQueryFileInfo.
Arguments:
hFile - Supplies an open handle to a file whose modification date and
times are to be read. The file handle must have been created with
GENERIC_READ access to the file.
lpCreationTime - An optional parameter that if specified points to
the location to return the date and time the file was created.
A returned time of all zero indicates that the file system
containing the file does not support this time value.
lpLastAccessTime - An optional parameter that if specified points to
the location to return the date and time the file was last accessed.
A returned time of all zero indicates that the file system
containing the file does not support this time value.
lpLastWriteTime - An optional parameter that if specified points to
the location to return the date and time the file was last written.
A file system must support this time and thus a valid value will
always be returned for this time value.
Return Value:
TRUE - The operation was successful.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
NTSTATUS Status;
IO_STATUS_BLOCK IoStatusBlock;
FILE_BASIC_INFORMATION BasicInfo;
if (CONSOLE_HANDLE(hFile)) {
BaseSetLastNTError(STATUS_INVALID_HANDLE);
return FALSE;
}
//
// Get the attributes
//
Status = NtQueryInformationFile(
hFile,
&IoStatusBlock,
&BasicInfo,
sizeof(BasicInfo),
FileBasicInformation
);
if ( NT_SUCCESS(Status) ) {
if (ARGUMENT_PRESENT( lpCreationTime )) {
*lpCreationTime = *(LPFILETIME)&BasicInfo.CreationTime;
}
if (ARGUMENT_PRESENT( lpLastAccessTime )) {
*lpLastAccessTime = *(LPFILETIME)&BasicInfo.LastAccessTime;
}
if (ARGUMENT_PRESENT( lpLastWriteTime )) {
*lpLastWriteTime = *(LPFILETIME)&BasicInfo.LastWriteTime;
}
return TRUE;
}
else {
BaseSetLastNTError(Status);
return FALSE;
}
}
BOOL
WINAPI
SetFileTime(
HANDLE hFile,
CONST FILETIME *lpCreationTime,
CONST FILETIME *lpLastAccessTime,
CONST FILETIME *lpLastWriteTime
)
/*++
Routine Description:
The date and time that a file was created, last accessed or last
modified can be modified using SetFileTime. File time stamps are
returned as 64-bit values, that represent the number of 100
nanoseconds since January 1st, 1601. This date was chosen because
it is the start of a new quadricentury. At 100ns resolution 32 bits
is good for about 429 seconds (or 7 minutes) and a 63-bit integer is
good for about 29,247 years, or around 10,682,247 days.
This API provides the same functionality as DOS (int 21h, function
47H with AL=1), and provides a subset of OS/2's DosSetFileInfo.
Arguments:
hFile - Supplies an open handle to a file whose modification date and
times are to be written. The file handle must have been created
with GENERIC_WRITE access to the file.
lpCreationTime - An optional parameter, that if specified supplies
the new creation time for the file. Some file system's do not
support this time value, so this parameter may be ignored.
lpLastAccessTime - An optional parameter, that if specified supplies
the new last access time for the file. Some file system's do
not support this time value, so this parameter may be ignored.
lpLastWriteTime - An optional parameter, that if specified supplies
the new last write time for the file. A file system must support
this time value.
Return Value:
TRUE - The operation was successful.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
NTSTATUS Status;
IO_STATUS_BLOCK IoStatusBlock;
FILE_BASIC_INFORMATION BasicInfo;
if (CONSOLE_HANDLE(hFile)) {
BaseSetLastNTError(STATUS_INVALID_HANDLE);
return FALSE;
}
//
// Zero all the time values we can set.
//
RtlZeroMemory(&BasicInfo,sizeof(BasicInfo));
//
// For each time value that is specified, copy it to the I/O system
// record.
//
if (ARGUMENT_PRESENT( lpCreationTime )) {
BasicInfo.CreationTime.LowPart = lpCreationTime->dwLowDateTime;
BasicInfo.CreationTime.HighPart = lpCreationTime->dwHighDateTime;
}
if (ARGUMENT_PRESENT( lpLastAccessTime )) {
BasicInfo.LastAccessTime.LowPart = lpLastAccessTime->dwLowDateTime;
BasicInfo.LastAccessTime.HighPart = lpLastAccessTime->dwHighDateTime;
}
if (ARGUMENT_PRESENT( lpLastWriteTime )) {
BasicInfo.LastWriteTime.LowPart = lpLastWriteTime->dwLowDateTime;
BasicInfo.LastWriteTime.HighPart = lpLastWriteTime->dwHighDateTime;
}
//
// Set the requested times.
//
Status = NtSetInformationFile(
hFile,
&IoStatusBlock,
&BasicInfo,
sizeof(BasicInfo),
FileBasicInformation
);
if ( NT_SUCCESS(Status) ) {
return TRUE;
}
else {
BaseSetLastNTError(Status);
return FALSE;
}
}
BOOL
WINAPI
FlushFileBuffers(
HANDLE hFile
)
/*++
Routine Description:
Buffered data may be flushed out to the file using the
FlushFileBuffers service.
The FlushFileBuffers service causes all buffered data to be written
to the specified file.
Arguments:
hFile - Supplies an open handle to a file whose buffers are to be
flushed. The file handle must have been created with
GENERIC_WRITE access to the file.
Return Value:
TRUE - The operation was successful.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
NTSTATUS Status;
IO_STATUS_BLOCK IoStatusBlock;
PPEB Peb;
Peb = NtCurrentPeb();
switch( HandleToUlong(hFile) ) {
case STD_INPUT_HANDLE: hFile = Peb->ProcessParameters->StandardInput;
break;
case STD_OUTPUT_HANDLE: hFile = Peb->ProcessParameters->StandardOutput;
break;
case STD_ERROR_HANDLE: hFile = Peb->ProcessParameters->StandardError;
break;
}
if (CONSOLE_HANDLE(hFile)) {
return( FlushConsoleInputBuffer( hFile ) );
}
Status = NtFlushBuffersFile(hFile,&IoStatusBlock);
if ( NT_SUCCESS(Status) ) {
return TRUE;
}
else {
BaseSetLastNTError(Status);
return FALSE;
}
}
BOOL
WINAPI
LockFile(
HANDLE hFile,
DWORD dwFileOffsetLow,
DWORD dwFileOffsetHigh,
DWORD nNumberOfBytesToLockLow,
DWORD nNumberOfBytesToLockHigh
)
/*++
Routine Description:
A byte range within an open file may be locked for exclusive access
using LockFile.
Locking a region of a file is used to aquire exclusive access to the
specified region of the file. File locks are not inherited by the
new process during process creation.
Locking a portion of a file denies all other processes both read and
write access to the specified region of the file. Locking a region
that goes beyond the current end-of-file position is not an error.
Locks may not overlap an existing locked region of the file.
For DOS based systems running share.exe the lock semantics work as
described above. Without share.exe, all attempts to lock or unlock
a file will fail.
Arguments:
hFile - Supplies an open handle to a file that is to have a range of
bytes locked for exclusive access. The handle must have been
created with either GENERIC_READ or GENERIC_WRITE access to the
file.
dwFileOffsetLow - Supplies the low order 32-bits of the starting
byte offset of the file where the lock should begin.
dwFileOffsetHigh - Supplies the high order 32-bits of the starting
byte offset of the file where the lock should begin.
nNumberOfBytesToLockLow - Supplies the low order 32-bits of the length
of the byte range to be locked.
nNumberOfBytesToLockHigh - Supplies the high order 32-bits of the length
of the byte range to be locked.
Return Value:
TRUE - The operation was successful.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
NTSTATUS Status;
LARGE_INTEGER ByteOffset;
LARGE_INTEGER Length;
IO_STATUS_BLOCK IoStatusBlock;
if (CONSOLE_HANDLE(hFile)) {
BaseSetLastNTError(STATUS_INVALID_HANDLE);
return FALSE;
}
ByteOffset.LowPart = dwFileOffsetLow;
ByteOffset.HighPart = dwFileOffsetHigh;
Length.LowPart = nNumberOfBytesToLockLow;
Length.HighPart = nNumberOfBytesToLockHigh;
Status = NtLockFile( hFile,
NULL,
NULL,
NULL,
&IoStatusBlock,
&ByteOffset,
&Length,
0,
TRUE,
TRUE
);
if (Status == STATUS_PENDING) {
Status = NtWaitForSingleObject( hFile, FALSE, NULL );
if (NT_SUCCESS( Status )) {
Status = IoStatusBlock.Status;
}
}
if ( NT_SUCCESS(Status) ) {
return TRUE;
}
else {
BaseSetLastNTError(Status);
return FALSE;
}
}
BOOL
WINAPI
LockFileEx(
HANDLE hFile,
DWORD dwFlags,
DWORD dwReserved,
DWORD nNumberOfBytesToLockLow,
DWORD nNumberOfBytesToLockHigh,
LPOVERLAPPED lpOverlapped
)
/*++
Routine Description:
A byte range within an open file may be locked for shared or
exclusive access using LockFileEx.
Locking a region of a file is used to aquire shared or exclusive
access to the specified region of the file. File locks are not
inherited by the new process during process creation.
Locking a portion of a file for exclusive access denies all other
processes both read and write access to the specified region of the
file. Locking a region that goes beyond the current end-of-file
position is not an error.
Locking a portion of a file for shared access denies all other
processes write access to the specified region of the file, but
allows other processes to read the locked region.
If requesting an exclusive lock for a file that is already locked
shared or exclusively by other threads, then this call will wait
until the lock is granted unless the LOCKFILE_FAIL_IMMEDIATELY
flag is specified.
Locks may not overlap an existing locked region of the file.
Arguments:
hFile - Supplies an open handle to a file that is to have a range of
bytes locked for exclusive access. The handle must have been
created with either GENERIC_READ or GENERIC_WRITE access to the
file.
dwFlags - Supplies flag bits that modify the behavior of this function.
LOCKFILE_FAIL_IMMEDIATELY - if set, then this function will return
immediately if it is unable to acquire the requested lock.
Otherwise it will wait.
LOCKFILE_EXCLUSIVE_LOCK - if set, then this function requests an
exclusive lock, otherwise it requested a shared lock.
dwReserved - Reserved parameter that must be zero.
nNumberOfBytesToLockLow - Supplies the low order 32-bits of the length
of the byte range to be locked.
nNumberOfBytesToLockHigh - Supplies the high order 32-bits of the length
of the byte range to be locked.
lpOverlapped - Required pointer to an OVERLAPPED structure to be
used with the request. It contains the file offset of the
beginning of the lock range.
Return Value:
TRUE - The operation was successful.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
NTSTATUS Status;
LARGE_INTEGER ByteOffset;
LARGE_INTEGER Length;
if (CONSOLE_HANDLE(hFile)) {
BaseSetLastNTError(STATUS_INVALID_HANDLE);
return FALSE;
}
if (dwReserved != 0) {
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
ByteOffset.LowPart = lpOverlapped->Offset;
ByteOffset.HighPart = lpOverlapped->OffsetHigh;
Length.LowPart = nNumberOfBytesToLockLow;
Length.HighPart = nNumberOfBytesToLockHigh;
lpOverlapped->Internal = (DWORD)STATUS_PENDING;
Status = NtLockFile( hFile,
lpOverlapped->hEvent,
NULL,
(ULONG_PTR)lpOverlapped->hEvent & 1 ? NULL : lpOverlapped,
(PIO_STATUS_BLOCK)&lpOverlapped->Internal,
&ByteOffset,
&Length,
0,
(BOOLEAN)((dwFlags & LOCKFILE_FAIL_IMMEDIATELY) ? TRUE : FALSE),
(BOOLEAN)((dwFlags & LOCKFILE_EXCLUSIVE_LOCK) ? TRUE : FALSE)
);
if ( NT_SUCCESS(Status) && Status != STATUS_PENDING) {
return TRUE;
}
else {
BaseSetLastNTError(Status);
return FALSE;
}
}
BOOL
WINAPI
UnlockFile(
HANDLE hFile,
DWORD dwFileOffsetLow,
DWORD dwFileOffsetHigh,
DWORD nNumberOfBytesToUnlockLow,
DWORD nNumberOfBytesToUnlockHigh
)
/*++
Routine Description:
A previously locked byte range within an open file may be Unlocked
using UnlockFile.
Unlocking a region of a file is used release a previously aquired
lock on a file. The region to unlock must exactly correspond to an
existing locked region. Two adjacent regions of a file can not be
locked seperately and then be unlocked using a single region that
spans both locked regions.
If a process terminates with a portion of a file locked, or closes a
file that has outstanding locks, the behavior is not specified.
For DOS based systems running share.exe the lock semantics work as
described above. Without share.exe, all attempts to lock or unlock
a file will fail.
Arguments:
hFile - Supplies an open handle to a file that is to have an
existing locked region unlocked. The handle must have been
created with either GENERIC_READ or GENERIC_WRITE access to the
file.
dwFileOffsetLow - Supplies the low order 32-bits of an existing
locked region to be unlocked.
dwFileOffsetHigh - Supplies the high order 32-bits of an existing
locked region to be unlocked.
nNumberOfBytesToUnlockLow - Supplies the low order 32-bits of the
length of the byte range to be unlocked.
nNumberOfBytesToUnlockHigh - Supplies the high order 32-bits of the
length of the byte range to be unlocked.
Return Value:
TRUE - The operation was successful.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
BOOL bResult;
OVERLAPPED Overlapped;
NTSTATUS Status;
Overlapped.Offset = dwFileOffsetLow;
Overlapped.OffsetHigh = dwFileOffsetHigh;
bResult = UnlockFileEx( hFile,
0,
nNumberOfBytesToUnlockLow,
nNumberOfBytesToUnlockHigh,
&Overlapped
);
if (!bResult && GetLastError() == ERROR_IO_PENDING) {
Status = NtWaitForSingleObject( hFile, FALSE, NULL );
if (NT_SUCCESS( Status )) {
Status = (NTSTATUS)Overlapped.Internal;
}
if ( NT_SUCCESS(Status) ) {
return TRUE;
}
else {
BaseSetLastNTError(Status);
return FALSE;
}
}
else {
return bResult;
}
}
BOOL
WINAPI
UnlockFileEx(
HANDLE hFile,
DWORD dwReserved,
DWORD nNumberOfBytesToUnlockLow,
DWORD nNumberOfBytesToUnlockHigh,
LPOVERLAPPED lpOverlapped
)
/*++
Routine Description:
A previously locked byte range within an open file may be Unlocked
using UnlockFile.
Unlocking a region of a file is used release a previously aquired
lock on a file. The region to unlock must exactly correspond to an
existing locked region. Two adjacent regions of a file can not be
locked seperately and then be unlocked using a single region that
spans both locked regions.
If a process terminates with a portion of a file locked, or closes a
file that has outstanding locks, the behavior is not specified.
Arguments:
hFile - Supplies an open handle to a file that is to have an
existing locked region unlocked. The handle must have been
created with either GENERIC_READ or GENERIC_WRITE access to the
file.
dwReserved - Reserved parameter that must be zero.
nNumberOfBytesToUnlockLow - Supplies the low order 32-bits of the
length of the byte range to be unlocked.
nNumberOfBytesToUnlockHigh - Supplies the high order 32-bits of the
length of the byte range to be unlocked.
lpOverlapped - Required pointer to an OVERLAPPED structure to be
used with the request. It contains the file offset of the
beginning of the lock range.
Return Value:
TRUE - The operation was successful.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
NTSTATUS Status;
LARGE_INTEGER ByteOffset;
LARGE_INTEGER Length;
if (CONSOLE_HANDLE(hFile)) {
BaseSetLastNTError(STATUS_INVALID_HANDLE);
return FALSE;
}
if (dwReserved != 0) {
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
ByteOffset.LowPart = lpOverlapped->Offset;
ByteOffset.HighPart = lpOverlapped->OffsetHigh;
Length.LowPart = nNumberOfBytesToUnlockLow;
Length.HighPart = nNumberOfBytesToUnlockHigh;
Status = NtUnlockFile(
hFile,
(PIO_STATUS_BLOCK)&lpOverlapped->Internal,
&ByteOffset,
&Length,
0
);
if ( NT_SUCCESS(Status) ) {
return TRUE;
}
else {
BaseSetLastNTError(Status);
return FALSE;
}
}
UINT
WINAPI
SetHandleCount(
UINT uNumber
)
/*++
Routine Description:
This function changes the number of file handles available to a
process. For DOS based Win32, the default maximum number of file
handles available to a process is 20. For NT/Win32 systems, this
API has no effect.
Arguments:
uNumber - Specifies the number of file handles needed by the
application. The maximum is 255.
Return Value:
The return value specifies the number of file handles actually
available to the application. It may be less than the number
specified by the wNumber parameter.
--*/
{
return uNumber;
}
DWORD
WINAPI
GetFileSize(
HANDLE hFile,
LPDWORD lpFileSizeHigh
)
/*++
Routine Description:
This function returns the size of the file specified by
hFile. It is capable of returning 64-bits worth of file size.
The return value contains the low order 32-bits of the file's size.
The optional lpFileSizeHigh returns the high order 32-bits of the
file's size.
Arguments:
hFile - Supplies an open handle to a file whose size is to be
returned. The handle must have been created with either
GENERIC_READ or GENERIC_WRITE access to the file.
lpFileSizeHigh - An optional parameter, that if specified, returns
the high order 64-bits of the file's size.
Return Value:
Not -1 - Returns the low order 32-bits of the specified file's size.
0xffffffff - If the value of size of the file cannot be determined,
or an invalid handle or handle with inappropriate access, or a
handle to a non-file is specified, this error is returned. If
the file's size (low 32-bits) is -1, then this value is
returned, and GetLastError() will return 0. Extended error
status is available using GetLastError.
--*/
{
BOOL b;
LARGE_INTEGER Li;
b = GetFileSizeEx(hFile,&Li);
if ( b ) {
if ( ARGUMENT_PRESENT(lpFileSizeHigh) ) {
*lpFileSizeHigh = (DWORD)Li.HighPart;
}
if (Li.LowPart == -1 ) {
SetLastError(0);
}
}
else {
Li.LowPart = -1;
}
return Li.LowPart;
}
BOOL
WINAPI
GetFileSizeEx(
HANDLE hFile,
PLARGE_INTEGER lpFileSize
)
/*++
Routine Description:
This function returns the size of the file specified by
hFile. It is capable of returning 64-bits worth of file size.
Arguments:
hFile - Supplies an open handle to a file whose size is to be
returned. The handle must have been created with either
GENERIC_READ or GENERIC_WRITE access to the file.
lpFileSize - Returns the files size
Return Value:
TRUE - The operation was successful
FALSE - The operation failed. Extended error
status is available using GetLastError.
--*/
{
NTSTATUS Status;
IO_STATUS_BLOCK IoStatusBlock;
FILE_STANDARD_INFORMATION StandardInfo;
Status = NtQueryInformationFile(
hFile,
&IoStatusBlock,
&StandardInfo,
sizeof(StandardInfo),
FileStandardInformation
);
if ( !NT_SUCCESS(Status) ) {
BaseSetLastNTError(Status);
return FALSE;
}
else {
*lpFileSize = StandardInfo.EndOfFile;
return TRUE;
}
}
VOID
WINAPI
BasepIoCompletion(
PVOID ApcContext,
PIO_STATUS_BLOCK IoStatusBlock,
DWORD Reserved
)
/*++
Routine Description:
This procedure is called to complete ReadFileEx and WriteFileEx
asynchronous I/O. Its primary function is to extract the
appropriate information from the passed IoStatusBlock and call the
users completion routine.
The users completion routine is called as:
Routine Description:
When an outstanding I/O completes with a callback, this
function is called. This function is only called while the
thread is in an alertable wait (SleepEx,
WaitForSingleObjectEx, or WaitForMultipleObjectsEx with the
bAlertable flag set to TRUE). Returning from this function
allows another pendiong I/O completion callback to be
processed. If this is the case, this callback is entered
before the termination of the thread's wait with a return
code of WAIT_IO_COMPLETION.
Note that each time your completion routine is called, the
system uses some of your stack. If you code your completion
logic to do additional ReadFileEx's and WriteFileEx's within
your completion routine, AND you do alertable waits in your
completion routine, you may grow your stack without ever
trimming it back.
Arguments:
dwErrorCode - Supplies the I/O completion status for the
related I/O. A value of 0 indicates that the I/O was
successful. Note that end of file is indicated by a
non-zero dwErrorCode value of ERROR_HANDLE_EOF.
dwNumberOfBytesTransfered - Supplies the number of bytes
transfered during the associated I/O. If an error
occured, a value of 0 is supplied.
lpOverlapped - Supplies the address of the OVERLAPPED
structure used to initiate the associated I/O. The
hEvent field of this structure is not used by the system
and may be used by the application to provide additional
I/O context. Once a completion routine is called, the
system will not use the OVERLAPPED structure. The
completion routine is free to deallocate the overlapped
structure.
Arguments:
ApcContext - Supplies the users completion routine. The format of
this routine is an LPOVERLAPPED_COMPLETION_ROUTINE.
IoStatusBlock - Supplies the address of the IoStatusBlock that
contains the I/O completion status. The IoStatusBlock is
contained within the OVERLAPPED structure.
Reserved - Not used; reserved for future use.
Return Value:
None.
--*/
{
PBASE_ACTIVATION_CONTEXT_ACTIVATION_BLOCK ActivationBlock;
LPOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine;
DWORD dwErrorCode;
DWORD dwNumberOfBytesTransfered;
LPOVERLAPPED lpOverlapped;
NTSTATUS Status;
RTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME ActivationFrame = { sizeof(ActivationFrame), RTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME_FORMAT_WHISTLER };
PACTIVATION_CONTEXT ActivationContext = NULL;
if ( NT_ERROR(IoStatusBlock->Status) ) {
dwErrorCode = RtlNtStatusToDosError(IoStatusBlock->Status);
dwNumberOfBytesTransfered = 0;
} else {
dwErrorCode = 0;
dwNumberOfBytesTransfered = (DWORD)IoStatusBlock->Information;
}
ActivationBlock = (PBASE_ACTIVATION_CONTEXT_ACTIVATION_BLOCK) ApcContext;
ActivationContext = ActivationBlock->ActivationContext;
CompletionRoutine = (LPOVERLAPPED_COMPLETION_ROUTINE) ActivationBlock->CallbackFunction;
lpOverlapped = (LPOVERLAPPED) CONTAINING_RECORD(IoStatusBlock, OVERLAPPED, Internal);
if (!(ActivationBlock->Flags & BASE_ACTIVATION_CONTEXT_ACTIVATION_BLOCK_FLAG_DO_NOT_FREE_AFTER_CALLBACK))
BasepFreeActivationContextActivationBlock(ActivationBlock);
RtlActivateActivationContextUnsafeFast(&ActivationFrame, ActivationContext);
__try {
(*CompletionRoutine)(dwErrorCode, dwNumberOfBytesTransfered, lpOverlapped);
} __finally {
RtlDeactivateActivationContextUnsafeFast(&ActivationFrame);
}
Reserved;
}
VOID
WINAPI
BasepIoCompletionSimple(
PVOID ApcContext,
PIO_STATUS_BLOCK IoStatusBlock,
DWORD Reserved
)
/*++
Routine Description:
This procedure is called to complete ReadFileEx and WriteFileEx
asynchronous I/O. Its primary function is to extract the
appropriate information from the passed IoStatusBlock and call the
users completion routine.
The users completion routine is called as:
Routine Description:
When an outstanding I/O completes with a callback, this
function is called. This function is only called while the
thread is in an alertable wait (SleepEx,
WaitForSingleObjectEx, or WaitForMultipleObjectsEx with the
bAlertable flag set to TRUE). Returning from this function
allows another pendiong I/O completion callback to be
processed. If this is the case, this callback is entered
before the termination of the thread's wait with a return
code of WAIT_IO_COMPLETION.
Note that each time your completion routine is called, the
system uses some of your stack. If you code your completion
logic to do additional ReadFileEx's and WriteFileEx's within
your completion routine, AND you do alertable waits in your
completion routine, you may grow your stack without ever
trimming it back.
Arguments:
dwErrorCode - Supplies the I/O completion status for the
related I/O. A value of 0 indicates that the I/O was
successful. Note that end of file is indicated by a
non-zero dwErrorCode value of ERROR_HANDLE_EOF.
dwNumberOfBytesTransfered - Supplies the number of bytes
transfered during the associated I/O. If an error
occured, a value of 0 is supplied.
lpOverlapped - Supplies the address of the OVERLAPPED
structure used to initiate the associated I/O. The
hEvent field of this structure is not used by the system
and may be used by the application to provide additional
I/O context. Once a completion routine is called, the
system will not use the OVERLAPPED structure. The
completion routine is free to deallocate the overlapped
structure.
Arguments:
ApcContext - Supplies the users completion routine. The format of
this routine is an LPOVERLAPPED_COMPLETION_ROUTINE.
IoStatusBlock - Supplies the address of the IoStatusBlock that
contains the I/O completion status. The IoStatusBlock is
contained within the OVERLAPPED structure.
Reserved - Not used; reserved for future use.
Return Value:
None.
--*/
{
LPOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine;
DWORD dwErrorCode;
DWORD dwNumberOfBytesTransfered;
LPOVERLAPPED lpOverlapped;
dwErrorCode = 0;
if ( NT_ERROR(IoStatusBlock->Status) ) {
dwErrorCode = RtlNtStatusToDosError(IoStatusBlock->Status);
dwNumberOfBytesTransfered = 0;
}
else {
dwErrorCode = 0;
dwNumberOfBytesTransfered = (DWORD)IoStatusBlock->Information;
}
CompletionRoutine = (LPOVERLAPPED_COMPLETION_ROUTINE)ApcContext;
lpOverlapped = (LPOVERLAPPED)CONTAINING_RECORD(IoStatusBlock,OVERLAPPED,Internal);
(CompletionRoutine)(dwErrorCode,dwNumberOfBytesTransfered,lpOverlapped);
Reserved;
}
BOOL
WINAPI
ReadFileEx(
HANDLE hFile,
LPVOID lpBuffer,
DWORD nNumberOfBytesToRead,
LPOVERLAPPED lpOverlapped,
LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
)
/*++
Routine Description:
Data can be read from a file using ReadFileEx.
This API reports its completion status asynchronously by calling the
specified lpCompletionRoutine.
The caller of this routine uses the lpOverlappedStructure to specify
the byte offset within the file where the read is to begin from.
For files that do not support this concept (pipes...), the starting
file offset is ignored.
Upon successful completion of this API (return value of TRUE), the
calling thread has an I/O outstanding. When the I/O completes, and
the thread is blocked in an alertable wait, the lpCompletionRoutine
will be called and the wait will return with a return code of
WAIT_IO_COMPLETION. If the I/O completes, but the thread issuing
the I/O is not in an alertable wait, the call to the completion
routine is queued until the thread executes an alertable wait.
If this API fails (by returning FALSE), GetLastError can be used to
get additional error information. If this call fails because the
thread issued a read beyond the end of file, GetLastError will
return a value of ERROR_HANDLE_EOF.
Arguments:
hFile - Supplies an open handle to a file that is to be read. The
file handle must have been created with GENERIC_READ access to
the file. The file must have been created with the
FILE_FLAG_OVERLAPPED flag.
lpBuffer - Supplies the address of a buffer to receive the data read
from the file.
nNumberOfBytesToRead - Supplies the number of bytes to read from the
file.
lpOverlapped - Supplies the address of an OVERLAPPED structure to be
used with the request. The caller of this function must specify
a starting byte offset within the file to start the read from.
It does this using the Offset and OffsetHigh fields of the
overlapped structure. This call does not use or modify the
hEvent field of the overlapped structure. The caller may use
this field for any purpose. This API does use the Internal and
InternalHigh fields of the overlapped structure, the thread
should not manipulate this. The lpOverlapped structure must
remain valid for the duration of the I/O. It is not a good idea
to make it a local variable and then possibly returning from the
routine with the I/O that is using this structure still pending.
Return Value:
TRUE - The operation was successul. Completion status will be
propagated to the caller using the completion callback
mechanism. Note that this information is only made available to
the thread that issued the I/O, and only when the I/O completes,
and the thread is executing in an alertable wait.
FALSE - The operation failed. Extended error status is available
using GetLastError. Note that end of file is treated as a failure
with an error code of ERROR_HANDLE_EOF.
--*/
{
NTSTATUS Status;
LARGE_INTEGER Li;
PBASE_ACTIVATION_CONTEXT_ACTIVATION_BLOCK ActivationBlock = NULL;
PIO_APC_ROUTINE IoApcRoutine = &BasepIoCompletionSimple;
PVOID ApcContext = lpCompletionRoutine;
Li.LowPart = lpOverlapped->Offset;
Li.HighPart = lpOverlapped->OffsetHigh;
// If there's an APC routine to call we need to allocate a little chunk of heap
// to pass the activation context to the APC callback.
if (lpCompletionRoutine != NULL) {
Status = BasepAllocateActivationContextActivationBlock(
BASEP_ALLOCATE_ACTIVATION_CONTEXT_ACTIVATION_BLOCK_FLAG_DO_NOT_ALLOCATE_IF_PROCESS_DEFAULT,
lpCompletionRoutine,
lpOverlapped,
&ActivationBlock);
if (!NT_SUCCESS(Status)) {
BaseSetLastNTError(Status);
return FALSE;
}
// If there's nothing to do, call the simpler one that doesn't try to do activation context stuff
if (ActivationBlock != NULL) {
IoApcRoutine = &BasepIoCompletion;
ApcContext = ActivationBlock;
}
}
Status = NtReadFile(
hFile,
NULL,
IoApcRoutine,
ApcContext,
(PIO_STATUS_BLOCK) &lpOverlapped->Internal,
lpBuffer,
nNumberOfBytesToRead,
&Li,
NULL
);
if ( NT_ERROR(Status) ) {
if (ActivationBlock != NULL)
BasepFreeActivationContextActivationBlock(ActivationBlock);
BaseSetLastNTError(Status);
return FALSE;
}
return TRUE;
}
BOOL
WINAPI
WriteFileEx(
HANDLE hFile,
LPCVOID lpBuffer,
DWORD nNumberOfBytesToWrite,
LPOVERLAPPED lpOverlapped,
LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
)
/*++
Routine Description:
Data can be written to a file using WriteFileEx.
This API reports its completion status asynchronously by calling the
specified lpCompletionRoutine.
The caller of this routine uses the lpOverlappedStructure to specify
the byte offset within the file where the write is to begin.
For files that do not support this concept (pipes...), the starting
file offset is ignored.
Upon successful completion of this API (return value of TRUE), the
calling thread has an I/O outstanding. When the I/O completes, and
the thread is blocked in an alertable wait, the lpCompletionRoutine
will be called and the wait will return with a return code of
WAIT_IO_COMPLETION. If the I/O completes, but the thread issuing
the I/O is not in an alertable wait, the call to the completion
routine is queued until the thread executes an alertable wait.
If this API fails (by returning FALSE), GetLastError can be used to
get additional error information.
Unlike DOS, a NumberOfBytesToWrite value of zero does not truncate
or extend the file. If this function is required, SetEndOfFile
should be used.
Arguments:
hFile - Supplies an open handle to a file that is to be written. The
file handle must have been created with GENERIC_WRITE access to
the file.
lpBuffer - Supplies the address of the data that is to be written to
the file.
nNumberOfBytesToWrite - Supplies the number of bytes to write to the
file. Unlike DOS, a value of zero is interpreted a null write.
lpOverlapped - Supplies the address of an OVERLAPPED structure to be
used with the request. The caller of this function must specify
a starting byte offset within the file to start the write to.
It does this using the Offset and OffsetHigh fields of the
overlapped structure. This call does not use or modify the
hEvent field of the overlapped structure. The caller may use
this field for any purpose. This API does use the Internal and
InternalHigh fields of the overlapped structure, the thread
should not manipulate this. The lpOverlapped structure must
remain valid for the duration of the I/O. It is not a good idea
to make it a local variable and then possibly returning from the
routine with the I/O that is using this structure still pending.
Return Value:
TRUE - The operation was successul. Completion status will be
propagated to the caller using the completion callback
mechanism. Note that this information is only made available to
the thread that issued the I/O, and only when the I/O completes,
and the thread is executing in an alertable wait.
FALSE - The operation failed. Extended error status is available
using GetLastError. Note that end of file is treated as a failure
with an error code of ERROR_HANDLE_EOF.
--*/
{
NTSTATUS Status;
LARGE_INTEGER Li;
PBASE_ACTIVATION_CONTEXT_ACTIVATION_BLOCK ActivationBlock = NULL;
PIO_APC_ROUTINE IoApcRoutine = &BasepIoCompletionSimple;
PVOID ApcContext = lpCompletionRoutine;
Li.LowPart = lpOverlapped->Offset;
Li.HighPart = lpOverlapped->OffsetHigh;
// If there's an APC routine to call we may need to allocate a little chunk of heap
// to pass to the APC callback.
//
// we'll replace the parameters to the common NtWriteFile call below so that
// the control flow is obvious.
//
if (lpCompletionRoutine != NULL) {
Status = BasepAllocateActivationContextActivationBlock(
BASEP_ALLOCATE_ACTIVATION_CONTEXT_ACTIVATION_BLOCK_FLAG_DO_NOT_ALLOCATE_IF_PROCESS_DEFAULT,
lpCompletionRoutine,
lpOverlapped,
&ActivationBlock);
if (!NT_SUCCESS(Status)) {
BaseSetLastNTError(Status);
return FALSE;
}
// If there's nothing to do, call the simpler one that doesn't try to do activation context stuff
if (ActivationBlock != NULL) {
IoApcRoutine = &BasepIoCompletion;
ApcContext = ActivationBlock;
}
}
Status = NtWriteFile(
hFile,
NULL,
IoApcRoutine,
ApcContext,
(PIO_STATUS_BLOCK)&lpOverlapped->Internal,
(LPVOID)lpBuffer,
nNumberOfBytesToWrite,
&Li,
NULL
);
if ( NT_ERROR(Status) ) {
if (ActivationBlock != NULL) {
BasepFreeActivationContextActivationBlock(ActivationBlock);
}
BaseSetLastNTError(Status);
return FALSE;
}
return TRUE;
}
BOOL
WINAPI
DeviceIoControl(
HANDLE hDevice,
DWORD dwIoControlCode,
LPVOID lpInBuffer,
DWORD nInBufferSize,
LPVOID lpOutBuffer,
DWORD nOutBufferSize,
LPDWORD lpBytesReturned,
LPOVERLAPPED lpOverlapped
)
/*++
Routine Description:
An operation on a device may be performed by calling the device driver
directly using the DeviceIoContrl function.
The device driver must first be opened to get a valid handle.
Arguments:
hDevice - Supplies an open handle a device on which the operation is to
be performed.
dwIoControlCode - Supplies the control code for the operation. This
control code determines on which type of device the operation must
be performed and determines exactly what operation is to be
performed.
lpInBuffer - Suplies an optional pointer to an input buffer that contains
the data required to perform the operation. Whether or not the
buffer is actually optional is dependent on the IoControlCode.
nInBufferSize - Supplies the length of the input buffer in bytes.
lpOutBuffer - Suplies an optional pointer to an output buffer into which
the output data will be copied. Whether or not the buffer is actually
optional is dependent on the IoControlCode.
nOutBufferSize - Supplies the length of the output buffer in bytes.
lpBytesReturned - Supplies a pointer to a dword which will receive the
actual length of the data returned in the output buffer.
lpOverlapped - An optional parameter that supplies an overlap structure to
be used with the request. If NULL or the handle was created without
FILE_FLAG_OVERLAPPED then the DeviceIoControl will not return until
the operation completes.
When lpOverlapped is supplied and FILE_FLAG_OVERLAPPED was specified
when the handle was created, DeviceIoControl may return
ERROR_IO_PENDING to allow the caller to continue processing while the
operation completes. The event (or File handle if hEvent == NULL) will
be set to the not signalled state before ERROR_IO_PENDING is
returned. The event will be set to the signalled state upon completion
of the request. GetOverlappedResult is used to determine the result
when ERROR_IO_PENDING is returned.
Return Value:
TRUE -- The operation was successful.
FALSE -- The operation failed. Extended error status is available using
GetLastError.
--*/
{
NTSTATUS Status;
BOOLEAN DevIoCtl;
if ( dwIoControlCode >> 16 == FILE_DEVICE_FILE_SYSTEM ) {
DevIoCtl = FALSE;
}
else {
DevIoCtl = TRUE;
}
if ( ARGUMENT_PRESENT( lpOverlapped ) ) {
lpOverlapped->Internal = (DWORD)STATUS_PENDING;
if ( DevIoCtl ) {
Status = NtDeviceIoControlFile(
hDevice,
lpOverlapped->hEvent,
NULL, // APC routine
(ULONG_PTR)lpOverlapped->hEvent & 1 ? NULL : lpOverlapped,
(PIO_STATUS_BLOCK)&lpOverlapped->Internal,
dwIoControlCode, // IoControlCode
lpInBuffer, // Buffer for data to the FS
nInBufferSize,
lpOutBuffer, // OutputBuffer for data from the FS
nOutBufferSize // OutputBuffer Length
);
}
else {
Status = NtFsControlFile(
hDevice,
lpOverlapped->hEvent,
NULL, // APC routine
(ULONG_PTR)lpOverlapped->hEvent & 1 ? NULL : lpOverlapped,
(PIO_STATUS_BLOCK)&lpOverlapped->Internal,
dwIoControlCode, // IoControlCode
lpInBuffer, // Buffer for data to the FS
nInBufferSize,
lpOutBuffer, // OutputBuffer for data from the FS
nOutBufferSize // OutputBuffer Length
);
}
// handle warning value STATUS_BUFFER_OVERFLOW somewhat correctly
if ( !NT_ERROR(Status) && ARGUMENT_PRESENT(lpBytesReturned) ) {
try {
*lpBytesReturned = (DWORD)lpOverlapped->InternalHigh;
}
except(EXCEPTION_EXECUTE_HANDLER) {
*lpBytesReturned = 0;
}
}
if ( NT_SUCCESS(Status) && Status != STATUS_PENDING) {
return TRUE;
}
else {
BaseSetLastNTError(Status);
return FALSE;
}
}
else
{
IO_STATUS_BLOCK Iosb;
if ( DevIoCtl ) {
Status = NtDeviceIoControlFile(
hDevice,
NULL,
NULL, // APC routine
NULL, // APC Context
&Iosb,
dwIoControlCode, // IoControlCode
lpInBuffer, // Buffer for data to the FS
nInBufferSize,
lpOutBuffer, // OutputBuffer for data from the FS
nOutBufferSize // OutputBuffer Length
);
}
else {
Status = NtFsControlFile(
hDevice,
NULL,
NULL, // APC routine
NULL, // APC Context
&Iosb,
dwIoControlCode, // IoControlCode
lpInBuffer, // Buffer for data to the FS
nInBufferSize,
lpOutBuffer, // OutputBuffer for data from the FS
nOutBufferSize // OutputBuffer Length
);
}
if ( Status == STATUS_PENDING) {
// Operation must complete before return & Iosb destroyed
Status = NtWaitForSingleObject( hDevice, FALSE, NULL );
if ( NT_SUCCESS(Status)) {
Status = Iosb.Status;
}
}
if ( NT_SUCCESS(Status) ) {
*lpBytesReturned = (DWORD)Iosb.Information;
return TRUE;
}
else {
// handle warning value STATUS_BUFFER_OVERFLOW somewhat correctly
if ( !NT_ERROR(Status) ) {
*lpBytesReturned = (DWORD)Iosb.Information;
}
BaseSetLastNTError(Status);
return FALSE;
}
}
}
BOOL
WINAPI
CancelIo(
HANDLE hFile
)
/*++
Routine Description:
This routine cancels all of the outstanding I/O for the specified handle
for the specified file.
Arguments:
hFile - Supplies the handle to the file whose pending I/O is to be
canceled.
Return Value:
TRUE -- The operation was successful.
FALSE -- The operation failed. Extended error status is available using
GetLastError.
--*/
{
NTSTATUS Status;
IO_STATUS_BLOCK IoStatusBlock;
//
// Simply cancel the I/O for the specified file.
//
Status = NtCancelIoFile(hFile, &IoStatusBlock);
if ( NT_SUCCESS(Status) ) {
return TRUE;
}
else {
BaseSetLastNTError(Status);
return FALSE;
}
}
BOOL
WINAPI
ReadFileScatter(
HANDLE hFile,
FILE_SEGMENT_ELEMENT aSegementArray[],
DWORD nNumberOfBytesToRead,
LPDWORD lpReserved,
LPOVERLAPPED lpOverlapped
)
/*++
Routine Description:
Data can be read from a file using ReadFileScatter. The data
is then scatter to specified buffer segements.
This API is used to read data from a file. Data is read from the
file from the position indicated by the file pointer. After the
read completes, the file pointer is adjusted by the number of bytes
actually read. A return value of TRUE coupled with a bytes read of
0 indicates that the file pointer was beyond the current end of the
file at the time of the read.
Arguments:
hFile - Supplies an open handle to a file that is to be read. The
file handle must have been created with GENERIC_READ access to
the file.
aSegementArray - Supplies a pointer an array of virtual segments.
A virtual segment is a memory buffer where part of the transferred data
should be placed. Segments are have a fix size of PAGE_SIZE
and must be aligned on a PAGE_SIZE boundary.
nNumberOfBytesToRead - Supplies the number of bytes to read from the file.
lpReserved - Reserved for now.
lpOverlapped - Optionally points to an OVERLAPPED structure to be used with the
request. If NULL then the transfer starts at the current file position
and ReadFile will not return until the operation completes.
If the handle hFile was created without specifying FILE_FLAG_OVERLAPPED
the file pointer is moved to the specified offset plus
lpNumberOfBytesRead before ReadFile returns. ReadFile will wait for the
request to complete before returning (it will not return
ERROR_IO_PENDING).
When FILE_FLAG_OVERLAPPED is specified, ReadFile may return
ERROR_IO_PENDING to allow the calling function to continue processing
while the operation completes. The event (or hFile if hEvent is NULL) will
be set to the signalled state upon completion of the request.
When the handle is created with FILE_FLAG_OVERLAPPED and lpOverlapped
is set to NULL, ReadFile will return ERROR_INVALID_PARAMTER because
the file offset is required.
Return Value:
TRUE - The operation was successul.
FALSE - The operation failed. Extended error status is available
using GetLastError.
--*/
{
NTSTATUS Status;
IO_STATUS_BLOCK IoStatusBlock;
LPDWORD lpNumberOfBytesRead = NULL;
if ( ARGUMENT_PRESENT(lpReserved) ||
!ARGUMENT_PRESENT( lpOverlapped )) {
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (CONSOLE_HANDLE(hFile)) {
BaseSetLastNTError(STATUS_INVALID_HANDLE);
return FALSE;
}
if ( ARGUMENT_PRESENT(lpNumberOfBytesRead) ) {
*lpNumberOfBytesRead = 0;
}
if ( ARGUMENT_PRESENT( lpOverlapped ) ) {
LARGE_INTEGER Li;
lpOverlapped->Internal = (DWORD)STATUS_PENDING;
Li.LowPart = lpOverlapped->Offset;
Li.HighPart = lpOverlapped->OffsetHigh;
Status = NtReadFileScatter(
hFile,
lpOverlapped->hEvent,
NULL,
(ULONG_PTR)lpOverlapped->hEvent & 1 ? NULL : lpOverlapped,
(PIO_STATUS_BLOCK)&lpOverlapped->Internal,
aSegementArray,
nNumberOfBytesToRead,
&Li,
NULL
);
if ( NT_SUCCESS(Status) && Status != STATUS_PENDING) {
if ( ARGUMENT_PRESENT(lpNumberOfBytesRead) ) {
try {
*lpNumberOfBytesRead = (DWORD)lpOverlapped->InternalHigh;
}
except(EXCEPTION_EXECUTE_HANDLER) {
*lpNumberOfBytesRead = 0;
}
}
return TRUE;
}
else
if (Status == STATUS_END_OF_FILE) {
if ( ARGUMENT_PRESENT(lpNumberOfBytesRead) ) {
*lpNumberOfBytesRead = 0;
}
BaseSetLastNTError(Status);
return FALSE;
}
else {
BaseSetLastNTError(Status);
return FALSE;
}
}
else
{
Status = NtReadFileScatter(
hFile,
NULL,
NULL,
NULL,
&IoStatusBlock,
aSegementArray,
nNumberOfBytesToRead,
NULL,
NULL
);
if ( Status == STATUS_PENDING) {
// Operation must complete before return & IoStatusBlock destroyed
Status = NtWaitForSingleObject( hFile, FALSE, NULL );
if ( NT_SUCCESS(Status)) {
Status = IoStatusBlock.Status;
}
}
if ( NT_SUCCESS(Status) ) {
*lpNumberOfBytesRead = (DWORD)IoStatusBlock.Information;
return TRUE;
}
else
if (Status == STATUS_END_OF_FILE) {
*lpNumberOfBytesRead = 0;
return TRUE;
}
else {
if ( NT_WARNING(Status) ) {
*lpNumberOfBytesRead = (DWORD)IoStatusBlock.Information;
}
BaseSetLastNTError(Status);
return FALSE;
}
}
}
BOOL
WINAPI
WriteFileGather(
HANDLE hFile,
FILE_SEGMENT_ELEMENT aSegementArray[],
DWORD nNumberOfBytesToWrite,
LPDWORD lpReserved,
LPOVERLAPPED lpOverlapped
)
/*++
Routine Description:
Data can be written to a file using WriteFileGather. The data can
be in multple file segement buffers.
This API is used to write data to a file. Data is written to the
file from the position indicated by the file pointer. After the
write completes, the file pointer is adjusted by the number of bytes
actually written.
Unlike DOS, a NumberOfBytesToWrite value of zero does not truncate
or extend the file. If this function is required, SetEndOfFile
should be used.
Arguments:
hFile - Supplies an open handle to a file that is to be written. The
file handle must have been created with GENERIC_WRITE access to
the file.
aSegementArray - Supplies a pointer an array of virtual segments.
A virtual segment is a memory buffer where part of the transferred data
should be placed. Segments are have a fix size of PAGE_SIZE
and must be aligned on a PAGE_SIZE boundary. The number of
entries in the array must be equal to nNumberOfBytesToRead /
PAGE_SIZE.
nNumberOfBytesToWrite - Supplies the number of bytes to write to the
file. Unlike DOS, a value of zero is interpreted a null write.
lpReserved - Unused for now.
lpOverlapped - Optionally points to an OVERLAPPED structure to be
used with the request. If NULL then the transfer starts at the
current file position and WriteFileGather will not return until the
operation completes.
If the handle <hFile> was created without specifying
FILE_FLAG_OVERLAPPED the file pointer is moved to the specified
offset plus lpNumberOfBytesWritten before WriteFile returns.
WriteFile will wait for the request to complete before returning
(it will not set ERROR_IO_PENDING).
When FILE_FLAG_OVERLAPPED is specified, WriteFile may return
ERROR_IO_PENDING to allow the calling function to continue processing
while the operation completes. The event (or hFile if hEvent is NULL) will
be set to the signalled state upon completion of the request.
When the handle is created with FILE_FLAG_OVERLAPPED and lpOverlapped
is set to NULL, WriteFile will return ERROR_INVALID_PARAMTER because
the file offset is required.
Return Value:
TRUE - The operation was a success.
FALSE - The operation failed. Extended error status is
available using GetLastError.
--*/
{
NTSTATUS Status;
IO_STATUS_BLOCK IoStatusBlock;
LPDWORD lpNumberOfBytesWritten = NULL;
if ( ARGUMENT_PRESENT(lpReserved) ||
!ARGUMENT_PRESENT( lpOverlapped )) {
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (CONSOLE_HANDLE(hFile)) {
BaseSetLastNTError(STATUS_INVALID_HANDLE);
return FALSE;
}
if ( ARGUMENT_PRESENT(lpNumberOfBytesWritten) ) {
*lpNumberOfBytesWritten = 0;
}
if ( ARGUMENT_PRESENT( lpOverlapped ) ) {
LARGE_INTEGER Li;
lpOverlapped->Internal = (DWORD)STATUS_PENDING;
Li.LowPart = lpOverlapped->Offset;
Li.HighPart = lpOverlapped->OffsetHigh;
Status = NtWriteFileGather(
hFile,
lpOverlapped->hEvent,
NULL,
(ULONG_PTR)lpOverlapped->hEvent & 1 ? NULL : lpOverlapped,
(PIO_STATUS_BLOCK)&lpOverlapped->Internal,
aSegementArray,
nNumberOfBytesToWrite,
&Li,
NULL
);
if ( !NT_ERROR(Status) && Status != STATUS_PENDING) {
if ( ARGUMENT_PRESENT(lpNumberOfBytesWritten) ) {
try {
*lpNumberOfBytesWritten = (DWORD)lpOverlapped->InternalHigh;
}
except(EXCEPTION_EXECUTE_HANDLER) {
*lpNumberOfBytesWritten = 0;
}
}
return TRUE;
}
else {
BaseSetLastNTError(Status);
return FALSE;
}
}
else {
Status = NtWriteFileGather(
hFile,
NULL,
NULL,
NULL,
&IoStatusBlock,
aSegementArray,
nNumberOfBytesToWrite,
NULL,
NULL
);
if ( Status == STATUS_PENDING) {
// Operation must complete before return & IoStatusBlock destroyed
Status = NtWaitForSingleObject( hFile, FALSE, NULL );
if ( NT_SUCCESS(Status)) {
Status = IoStatusBlock.Status;
}
}
if ( NT_SUCCESS(Status)) {
*lpNumberOfBytesWritten = (DWORD)IoStatusBlock.Information;
return TRUE;
}
else {
if ( NT_WARNING(Status) ) {
*lpNumberOfBytesWritten = (DWORD)IoStatusBlock.Information;
}
BaseSetLastNTError(Status);
return FALSE;
}
}
}
BOOL
APIENTRY
SetFileValidData(
IN HANDLE hFile,
IN LONGLONG ValidDataLength
)
/*++
Routine Description:
SetFileValidData is used to set the valid data length for the given file.
Arguments:
hFile - Supplies an open handle to a file whose type valid data
length is to be set
ValidDataLength - Supplies the desired valid data length
Return Value:
TRUE - The operation was a success.
FALSE - The operation failed. Extended error status is
available using GetLastError.
--*/
{
NTSTATUS Status;
IO_STATUS_BLOCK IoStatusBlock;
FILE_VALID_DATA_LENGTH_INFORMATION ValidDataInfo;
if (CONSOLE_HANDLE(hFile)) {
BaseSetLastNTError(STATUS_INVALID_HANDLE);
return FALSE;
}
ValidDataInfo.ValidDataLength.QuadPart = ValidDataLength;
Status = NtSetInformationFile(
hFile,
&IoStatusBlock,
&ValidDataInfo,
sizeof(FILE_VALID_DATA_LENGTH_INFORMATION),
FileValidDataLengthInformation
);
if (!NT_SUCCESS(Status)) {
BaseSetLastNTError(Status);
return FALSE;
}
return TRUE;
}
BOOL
APIENTRY
SetFileShortNameW(
IN HANDLE hFile,
IN LPCWSTR lpShortName
)
/*++
Routine Description:
SetFileShortNameW is used to set the short name for the given file.
Arguments:
hFile - Supplies an open handle to a file whose short name is to be changed
lpShortName - Supplies the desired short name
Return Value:
TRUE - The operation was a success.
FALSE - The operation failed. Extended error status is
available using GetLastError.
--*/
{
NTSTATUS Status;
IO_STATUS_BLOCK IoStatusBlock;
PFILE_NAME_INFORMATION FileNameInfo;
DWORD FileNameInfoSize;
DWORD FileInformationClass;
if (CONSOLE_HANDLE(hFile)) {
BaseSetLastNTError(STATUS_INVALID_HANDLE);
return FALSE;
}
if (!ARGUMENT_PRESENT(lpShortName)) {
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
FileNameInfoSize = FIELD_OFFSET(FILE_NAME_INFORMATION, FileName) + ((wcslen(lpShortName)+1)*sizeof(WCHAR));
FileNameInfo = RtlAllocateHeap( RtlProcessHeap(), MAKE_TAG(TMP_TAG), FileNameInfoSize );
if (!FileNameInfo) {
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
FileNameInfo->FileNameLength = wcslen(lpShortName) * sizeof(WCHAR);
wcscpy( FileNameInfo->FileName, lpShortName );
Status = NtSetInformationFile(
hFile,
&IoStatusBlock,
FileNameInfo,
FileNameInfoSize,
FileShortNameInformation
);
RtlFreeHeap( RtlProcessHeap(), 0, FileNameInfo );
if (!NT_SUCCESS(Status)) {
BaseSetLastNTError(Status);
return FALSE;
}
FileInformationClass = FileShortNameInformation;
if ((FileInformationClass == FileEndOfFileInformation) ||
(FileInformationClass == FileAllocationInformation) ||
(FileInformationClass == FilePositionInformation))
{
return FALSE;
}
return TRUE;
}
BOOL
APIENTRY
SetFileShortNameA(
IN HANDLE hFile,
IN LPCSTR lpShortName
)
/*++
Routine Description:
SetFileShortNameW is used to set the short name for the given file.
Arguments:
hFile - Supplies an open handle to a file whose short name is to be changed
lpShortName - Supplies the desired short name
Return Value:
TRUE - The operation was a success.
FALSE - The operation failed. Extended error status is
available using GetLastError.
--*/
{
PUNICODE_STRING Unicode;
Unicode = Basep8BitStringToStaticUnicodeString( lpShortName );
if (Unicode == NULL) {
return FALSE;
}
return ( SetFileShortNameW(
hFile,
(LPCWSTR)Unicode->Buffer
)
);
}
Copy Permalink