mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
469 lines
11 KiB
469 lines
11 KiB
/****************************** Module Header ******************************\
|
|
* Module Name: async.c
|
|
*
|
|
* Copyright (c) 1991, Microsoft Corporation
|
|
*
|
|
* This module implements asynchronous I/O on file handles in a more
|
|
* useful way than provided for by Win32 apis.
|
|
*
|
|
* This module provides 2 main apis : ReadFileAsync, WriteFileAsync.
|
|
* These apis take a handle to an async object and always return
|
|
* immediately without waiting for the I/O to complete. An event
|
|
* can be queried from the async object and used to wait for completion.
|
|
* When this event is signalled, the I/O result can be queried from
|
|
* the async object.
|
|
*
|
|
* History:
|
|
* 06-29-92 Davidc Created.
|
|
\***************************************************************************/
|
|
|
|
#include "rcmdsrv.h"
|
|
|
|
|
|
|
|
//
|
|
// Define MYOVERLAPPED structure
|
|
//
|
|
|
|
typedef struct {
|
|
|
|
OVERLAPPED Overlapped;
|
|
|
|
HANDLE FileHandle; // Non-null when I/O operation in progress.
|
|
|
|
DWORD CompletionCode;
|
|
DWORD BytesTransferred;
|
|
BOOL CompletedSynchronously;
|
|
|
|
} MYOVERLAPPED, *PMYOVERLAPPED;
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CreateAsync
|
|
//
|
|
// Creates an async object.
|
|
// The async event is created with the initial state specified. If this
|
|
// is TRUE the async object created simulates a successfully completed
|
|
// transfer of 0 bytes.
|
|
//
|
|
// Returns handle on success, NULL on failure. GetLastError() for details.
|
|
//
|
|
// The object should be deleted by calling DeleteAsync.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
HANDLE
|
|
CreateAsync(
|
|
BOOL InitialState
|
|
)
|
|
{
|
|
SECURITY_ATTRIBUTES SecurityAttributes;
|
|
PMYOVERLAPPED MyOverlapped;
|
|
|
|
SecurityAttributes.nLength = sizeof(SecurityAttributes);
|
|
SecurityAttributes.lpSecurityDescriptor = NULL; // Use default ACL
|
|
SecurityAttributes.bInheritHandle = FALSE; // No inheritance
|
|
|
|
//
|
|
// Allocate space for the async structure
|
|
//
|
|
|
|
|
|
MyOverlapped = (PMYOVERLAPPED)Alloc(sizeof(MYOVERLAPPED));
|
|
if (MyOverlapped == NULL) {
|
|
DbgPrint("CreateAsync : Failed to allocate space for async object\n");
|
|
return(NULL);
|
|
}
|
|
|
|
//
|
|
// Create the synchronisation event
|
|
//
|
|
|
|
MyOverlapped->Overlapped.hEvent = CreateEvent( &SecurityAttributes,
|
|
TRUE, // Manual-reset
|
|
InitialState,
|
|
NULL); // Name
|
|
if (MyOverlapped->Overlapped.hEvent == NULL) {
|
|
DbgPrint("CreateAsync failed to create event, error = %d\n", GetLastError());
|
|
Free(MyOverlapped);
|
|
return(NULL);
|
|
}
|
|
|
|
//
|
|
// Initialize other fields.
|
|
// (Set FileHandle non-NULL to keep GetAsyncResult happy)
|
|
//
|
|
|
|
MyOverlapped->FileHandle = InitialState ? (HANDLE)1 : NULL;
|
|
MyOverlapped->BytesTransferred = 0;
|
|
MyOverlapped->CompletionCode = ERROR_SUCCESS;
|
|
MyOverlapped->CompletedSynchronously = TRUE;
|
|
|
|
|
|
return((HANDLE)MyOverlapped);
|
|
}
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// DeleteAsync
|
|
//
|
|
// Deletes resources used by async object
|
|
//
|
|
// Returns nothing
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
VOID
|
|
DeleteAsync(
|
|
HANDLE AsyncHandle
|
|
)
|
|
{
|
|
PMYOVERLAPPED MyOverlapped = (PMYOVERLAPPED)AsyncHandle;
|
|
|
|
MyCloseHandle(MyOverlapped->Overlapped.hEvent, "async overlapped event");
|
|
Free(MyOverlapped);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// ReadFileAsync
|
|
//
|
|
// Reads from file asynchronously.
|
|
//
|
|
// Returns TRUE on success, FALSE on failure (GetLastError() for detail)
|
|
//
|
|
// Caller should wait on async event for operation to complete, then call
|
|
// GetAsyncResult to retrieve information on transfer.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
BOOL
|
|
ReadFileAsync(
|
|
HANDLE hFile,
|
|
LPVOID lpBuffer,
|
|
DWORD nBytesToRead,
|
|
HANDLE AsyncHandle
|
|
)
|
|
{
|
|
BOOL Result;
|
|
DWORD Error;
|
|
PMYOVERLAPPED MyOverlapped = (PMYOVERLAPPED)AsyncHandle;
|
|
|
|
//
|
|
// Check an IO operation is not in progress
|
|
//
|
|
|
|
if (MyOverlapped->FileHandle != NULL) {
|
|
DbgPrint("ReadFileAsync : Operation already in progress!\n");
|
|
SetLastError(ERROR_IO_PENDING);
|
|
return(FALSE);
|
|
}
|
|
|
|
//
|
|
// Reset the event
|
|
//
|
|
|
|
Result = ResetEvent(MyOverlapped->Overlapped.hEvent);
|
|
if (!Result) {
|
|
DbgPrint("ReadFileAsync : Failed to reset async event, error = %d\n", GetLastError());
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
//
|
|
// Store the file handle in our structure.
|
|
// This also functions as a signal that an operation is in progress.
|
|
//
|
|
|
|
MyOverlapped->FileHandle = hFile;
|
|
MyOverlapped->CompletedSynchronously = FALSE;
|
|
|
|
Result = ReadFile(hFile,
|
|
lpBuffer,
|
|
nBytesToRead,
|
|
&MyOverlapped->BytesTransferred,
|
|
&MyOverlapped->Overlapped);
|
|
|
|
if (!Result) {
|
|
|
|
Error = GetLastError();
|
|
|
|
if (Error == ERROR_IO_PENDING) {
|
|
|
|
//
|
|
// The I/O has been started synchronously, we're done
|
|
//
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
//
|
|
// The read really did fail, reset our flag and get out
|
|
//
|
|
|
|
DbgPrint("ReadFileAsync : ReadFile failed, error = %d\n", Error);
|
|
MyOverlapped->FileHandle = NULL;
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
//
|
|
// The operation completed synchronously. Store the paramaters in our
|
|
// structure ready for GetAsyncResult and signal the event
|
|
//
|
|
|
|
MyOverlapped->CompletionCode = ERROR_SUCCESS;
|
|
MyOverlapped->CompletedSynchronously = TRUE;
|
|
|
|
//
|
|
// Set the event
|
|
//
|
|
|
|
Result = SetEvent(MyOverlapped->Overlapped.hEvent);
|
|
if (!Result) {
|
|
DbgPrint("ReadFileAsync : Failed to set async event, error = %d\n", GetLastError());
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// WriteFileAsync
|
|
//
|
|
// Writes to file asynchronously.
|
|
//
|
|
// Returns TRUE on success, FALSE on failure (GetLastError() for detail)
|
|
//
|
|
// Caller should wait on async event for operation to complete, then call
|
|
// GetAsyncResult to retrieve information on transfer.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
BOOL
|
|
WriteFileAsync(
|
|
HANDLE hFile,
|
|
LPVOID lpBuffer,
|
|
DWORD nBytesToWrite,
|
|
HANDLE AsyncHandle
|
|
)
|
|
{
|
|
BOOL Result;
|
|
DWORD Error;
|
|
PMYOVERLAPPED MyOverlapped = (PMYOVERLAPPED)AsyncHandle;
|
|
|
|
//
|
|
// Check an IO operation is not in progress
|
|
//
|
|
|
|
if (MyOverlapped->FileHandle != NULL) {
|
|
DbgPrint("ReadFileAsync : Operation already in progress!\n");
|
|
SetLastError(ERROR_IO_PENDING);
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
//
|
|
// Reset the event
|
|
//
|
|
|
|
Result = ResetEvent(MyOverlapped->Overlapped.hEvent);
|
|
if (!Result) {
|
|
DbgPrint("WriteFileAsync : Failed to reset async event, error = %d\n", GetLastError());
|
|
return(FALSE);
|
|
}
|
|
|
|
//
|
|
// Store the file handle in our structure.
|
|
// This also functions as a signal that an operation is in progress.
|
|
//
|
|
|
|
MyOverlapped->FileHandle = hFile;
|
|
MyOverlapped->CompletedSynchronously = FALSE;
|
|
|
|
Result = WriteFile(hFile,
|
|
lpBuffer,
|
|
nBytesToWrite,
|
|
&MyOverlapped->BytesTransferred,
|
|
&MyOverlapped->Overlapped);
|
|
|
|
if (!Result) {
|
|
|
|
Error = GetLastError();
|
|
|
|
if (Error == ERROR_IO_PENDING) {
|
|
|
|
//
|
|
// The I/O has been started synchronously, we're done
|
|
//
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
//
|
|
// The read really did fail, reset our flag and get out
|
|
//
|
|
|
|
DbgPrint("WriteFileAsync : WriteFile failed, error = %d\n", Error);
|
|
MyOverlapped->FileHandle = NULL;
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
//
|
|
// The operation completed synchronously. Store the paramaters in our
|
|
// structure ready for GetAsyncResult and signal the event
|
|
//
|
|
|
|
MyOverlapped->CompletionCode = ERROR_SUCCESS;
|
|
MyOverlapped->CompletedSynchronously = TRUE;
|
|
|
|
//
|
|
// Set the event
|
|
//
|
|
|
|
Result = SetEvent(MyOverlapped->Overlapped.hEvent);
|
|
if (!Result) {
|
|
DbgPrint("WriteFileAsync : Failed to set async event, error = %d\n", GetLastError());
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// GetCompletionHandle
|
|
//
|
|
// Returns a handle that can be used to wait for completion of the
|
|
// operation associated with this async object
|
|
//
|
|
// Returns an event handle or NULL on failure
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
HANDLE
|
|
GetAsyncCompletionHandle(
|
|
HANDLE AsyncHandle
|
|
)
|
|
{
|
|
PMYOVERLAPPED MyOverlapped = (PMYOVERLAPPED)AsyncHandle;
|
|
|
|
return(MyOverlapped->Overlapped.hEvent);
|
|
}
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// GetAsyncResult
|
|
//
|
|
// Returns the result of the last completed operation involving the
|
|
// passed async object handle.
|
|
//
|
|
// Returns the completion code of the last operation OR
|
|
// ERROR_IO_INCOMPLETE if the operation has not completed.
|
|
// ERROR_NO_DATA if there is no operation in progress.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
DWORD
|
|
GetAsyncResult(
|
|
HANDLE AsyncHandle,
|
|
LPDWORD BytesTransferred
|
|
)
|
|
{
|
|
BOOL Result;
|
|
DWORD WaitResult;
|
|
PMYOVERLAPPED MyOverlapped = (PMYOVERLAPPED)AsyncHandle;
|
|
DWORD AsyncResult;
|
|
|
|
//
|
|
// Check an IO operation is (was) in progress
|
|
//
|
|
|
|
if (MyOverlapped->FileHandle == NULL) {
|
|
DbgPrint("GetAsyncResult : No operation in progress !\n");
|
|
return(ERROR_NO_DATA);
|
|
}
|
|
|
|
|
|
//
|
|
// Check the event is set - i.e that an IO operation has completed
|
|
//
|
|
|
|
WaitResult = WaitForSingleObject(MyOverlapped->Overlapped.hEvent, 0);
|
|
if (WaitResult != 0) {
|
|
DbgPrint("GetAsyncResult : Event was not set, wait result = %d\n", WaitResult);
|
|
return(ERROR_IO_INCOMPLETE);
|
|
}
|
|
|
|
|
|
//
|
|
// If the call completed synchronously, copy the data out of
|
|
// our structure
|
|
//
|
|
|
|
if (MyOverlapped->CompletedSynchronously) {
|
|
|
|
AsyncResult = MyOverlapped->CompletionCode;
|
|
*BytesTransferred = MyOverlapped->BytesTransferred;
|
|
|
|
} else {
|
|
|
|
//
|
|
// Go get the asynchronous result info from the system
|
|
//
|
|
|
|
AsyncResult = ERROR_SUCCESS;
|
|
|
|
Result = GetOverlappedResult(MyOverlapped->FileHandle,
|
|
&MyOverlapped->Overlapped,
|
|
BytesTransferred,
|
|
FALSE);
|
|
if (!Result) {
|
|
AsyncResult = GetLastError();
|
|
DbgPrint("GetAsyncResult : GetOverlappedResult failed, error = %d\n", AsyncResult);
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Reset the event so it doesn't trigger the caller again
|
|
//
|
|
|
|
Result = ResetEvent(MyOverlapped->Overlapped.hEvent);
|
|
if (!Result) {
|
|
DbgPrint("GetAsyncResult : Failed to reset async event\n");
|
|
}
|
|
|
|
|
|
//
|
|
// Result the file handle so we know there is no pending operation
|
|
//
|
|
|
|
MyOverlapped->FileHandle = NULL;
|
|
|
|
|
|
return(AsyncResult);
|
|
}
|
|
|
|
|
|
|