able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/inetsrv/iis/svcs/ftp/server51/asyncio.cxx

702 lines
18 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1995 Microsoft Corporation
Module Name :
asyncio.cxx
Abstract:
This module implements functions for ASYNC_IO_CONNECTION Object.
Author:
Murali R. Krishnan ( MuraliK ) 27-March-1995
Environment:
User Mode -- Win32
Project:
Internet Services DLL
Revision History:
--*/
/************************************************************
* Include Headers
************************************************************/
// need to include ftpdp.hxx here since precompiled header used.
# include "ftpdp.hxx"
# include "dbgutil.h"
# include "asyncio.hxx"
# include "..\..\infocomm\atq\atqtypes.hxx"
/************************************************************
* Functions
************************************************************/
ASYNC_IO_CONNECTION::ASYNC_IO_CONNECTION(
IN PFN_ASYNC_IO_COMPLETION pfnAioCompletion,
IN SOCKET sClient OPTIONAL
)
: m_pAioContext ( NULL),
m_pfnAioCompletion ( pfnAioCompletion),
m_sClient ( sClient),
m_sTimeout ( DEFAULT_CONNECTION_IO_TIMEOUT),
m_pAtqContext ( NULL),
m_endpointObject ( NULL)
{
IF_DEBUG( ASYNC_IO) {
DBGPRINTF( ( DBG_CONTEXT,
" Created a new ASYNC_IO_CONNECTION object ( %08x)\n",
this
));
}
} // ASYNC_IO_CONNECTION::ASYNC_IO_CONNECTION()
ASYNC_IO_CONNECTION::~ASYNC_IO_CONNECTION( VOID)
/*++
This function cleans up the ASYNC_IO_CONNECTION object. It also frees
up sockets and ATQ context embedded in this object.
THIS IS NOT MULTI_THREAD safe!
--*/
{
IF_DEBUG( ASYNC_IO) {
DBGPRINTF( ( DBG_CONTEXT,
"Deleting the ASYNC_IO_CONNECTION object ( %08x) \n",
this
));
}
if ( m_sClient != INVALID_SOCKET) {
//
// Shut and Close the socket. This can fail, if the socket is already
// closed by some other thread before this operation completes
//
StopIo( NO_ERROR);
}
if ( m_pAtqContext != NULL) {
AtqFreeContext( m_pAtqContext, TRUE );
m_pAtqContext = NULL;
}
DBG_ASSERT( m_sClient == INVALID_SOCKET);
} // ASYNC_IO_CONNECTION::~ASYN_IO_CONNECTION()
BOOL
ASYNC_IO_CONNECTION::ReadFile(
OUT LPVOID pvBuffer,
IN DWORD cbSize
)
/*++
This starts off an Asynchronous read operation for data from client
into the supplied buffer.
Arguments:
pvBuffer pointer to byte buffer which on successful
return will contain the data read from client
cbSize count of bytes of data available in the buffer.
( limits the size of data that can be read)
Returns:
TRUE on success and FALSE if there is a failure in setting up read.
--*/
{
BOOL fReturn = TRUE;
DBG_ASSERT( pvBuffer != NULL);
IF_DEBUG( ASYNC_IO) {
DBGPRINTF( ( DBG_CONTEXT,
" Entering ASYNC_IO_CONNECTION( %08x)::"
"ReadFile( %08x, %u)\n",
this, pvBuffer, cbSize
));
}
if (( m_pAtqContext == NULL && !AddToAtqHandles()) ||
!AtqReadFile( m_pAtqContext, pvBuffer, cbSize, NULL )) {
IF_DEBUG( ASYNC_IO) {
DWORD dwError = GetLastError();
DBGPRINTF(( DBG_CONTEXT,
"ASYNC_IO_CONNECTION(%08x)::WriteFile() failed."
" Error = %u\n",
this, dwError));
SetLastError( dwError);
}
fReturn = FALSE;
}
return ( fReturn);
} // ASYNC_IO_CONNECTION::ReadFile()
BOOL
ASYNC_IO_CONNECTION::WriteFile(
OUT LPVOID pvBuffer,
IN DWORD cbSize
)
/*++
This starts off an Asynchronous write operation to send data to the client
sending data from the supplied buffer. The buffer may not be freed
until the data is sent out.
Arguments:
pvBuffer pointer to byte buffer which contains the data to be sent
to the client.
cbSize count of bytes of data to be sent.
Returns:
TRUE on success and FALSE if there is a failure in setting up write.
--*/
{
BOOL fReturn = TRUE;
DBG_ASSERT( pvBuffer != NULL);
IF_DEBUG( ASYNC_IO) {
DBGPRINTF( ( DBG_CONTEXT,
" Entering ASYNC_IO_CONNECTION( %08x)::"
"WriteFile( %08x, %u)\n",
this, pvBuffer, cbSize
));
}
//
// Check and add to create an atq context as well as perform
// the write operation.
//
if ( (m_pAtqContext == NULL && !AddToAtqHandles()) ||
!AtqWriteFile( m_pAtqContext, pvBuffer, cbSize, NULL )) {
IF_DEBUG( ASYNC_IO) {
DWORD dwError = GetLastError();
DBGPRINTF(( DBG_CONTEXT,
"ASYNC_IO_CONNECTION(%08x)::WriteFile() failed."
" Error = %u\n",
this, dwError));
SetLastError( dwError);
}
fReturn = FALSE;
}
return ( fReturn);
} // ASYNC_IO_CONNECTION::WriteFile()
BOOL
ASYNC_IO_CONNECTION::TransmitFile(
IN HANDLE hFile,
IN LARGE_INTEGER & liSize,
IN DWORD dwOffset,
IN LPTRANSMIT_FILE_BUFFERS lpTransmitBuffers OPTIONAL
)
/*++
This starts off an Asynchronous TransmitFile operation to send file data
to the client.
Arguments:
hFile handle for the file to be transmitted.
liSize large integer containing size of file to be sent.
Offset Offset within the file to begin transmitting.
lpTransmitBuffers pointer to File Transmit Buffers
Returns:
TRUE on success and FALSE if there is a failure in setting up read.
--*/
{
BOOL fReturn = TRUE;
DBG_ASSERT( hFile != INVALID_HANDLE_VALUE);
IF_DEBUG( ASYNC_IO) {
DBGPRINTF( ( DBG_CONTEXT,
" Entering ASYNC_IO_CONNECTION( %08x)::"
"TransmitFile( %08x, %l, %ul, %08x)\n",
this, hFile, liSize.HighPart, liSize.LowPart,
lpTransmitBuffers
));
}
if ( m_pAtqContext == NULL )
{
if (!AddToAtqHandles())
{
IF_DEBUG( ASYNC_IO)
{
DWORD dwError = GetLastError();
DBGPRINTF(( DBG_CONTEXT,
"ASYNC_IO_CONNECTION(%08x)::AddToAtqHandles() failed."
" Error = %u\n",
this, dwError));
SetLastError( dwError);
}
return FALSE;
}
}
m_pAtqContext->Overlapped.Offset = dwOffset;
if (!AtqTransmitFile( m_pAtqContext,
hFile,
((liSize.HighPart == 0) ? liSize.LowPart : 0),
lpTransmitBuffers,
TF_DISCONNECT )
)
{
IF_DEBUG( ASYNC_IO) {
DWORD dwError = GetLastError();
DBGPRINTF(( DBG_CONTEXT,
"ASYNC_IO_CONNECTION(%08x)::TransmitFile() failed."
" Error = %u\n",
this, dwError));
SetLastError( dwError);
}
fReturn = FALSE;
}
return ( fReturn);
} // ASYNC_IO_CONNECTION::TransmitFile()
BOOL
ASYNC_IO_CONNECTION::TransmitFileTs(
IN TS_OPEN_FILE_INFO * pOpenFile,
IN LARGE_INTEGER & liSize,
IN DWORD dwOffset
)
/*++
This starts off an Asynchronous TransmitFile operation to send file data
to the client.
Arguments:
hFile handle for the file to be transmitted.
liSize large integer containing size of file to be sent.
Offset Offset within the file to begin transmitting.
Returns:
TRUE on success and FALSE if there is a failure in setting up read.
--*/
{
BOOL fReturn = TRUE;
PBYTE pFileBuffer = NULL;
HANDLE hFile = NULL;
TRANSMIT_FILE_BUFFERS TransmitBuffers;
DBG_ASSERT( pOpenFile );
IF_DEBUG( ASYNC_IO) {
DBGPRINTF( ( DBG_CONTEXT,
" Entering ASYNC_IO_CONNECTION( %08x)::"
"TransmitFile( %p, %p, %ul, %08x)\n",
this, pOpenFile, liSize.HighPart, liSize.LowPart
));
}
if ( m_pAtqContext == NULL )
{
if (!AddToAtqHandles())
{
IF_DEBUG( ASYNC_IO)
{
DWORD dwError = GetLastError();
DBGPRINTF(( DBG_CONTEXT,
"ASYNC_IO_CONNECTION(%08x)::AddToAtqHandles() failed."
" Error = %u\n",
this, dwError));
SetLastError( dwError);
}
return FALSE;
}
}
pFileBuffer = pOpenFile->QueryFileBuffer();
if (pFileBuffer) {
//
// Transmit from memory
//
DBG_ASSERT( liSize.HighPart == 0 );
TransmitBuffers.Head = pFileBuffer + dwOffset;
TransmitBuffers.HeadLength = liSize.LowPart;
TransmitBuffers.Tail = NULL;
TransmitBuffers.TailLength = 0;
} else {
//
// Transmit from a file
//
hFile = pOpenFile->QueryFileHandle();
m_pAtqContext->Overlapped.Offset = dwOffset;
if (liSize.HighPart != 0)
{
LARGE_INTEGER liTimeOut;
ULONG Remainder;
liTimeOut =
RtlExtendedLargeIntegerDivide(
liSize,
(ULONG) 1024,
&Remainder);
if (liTimeOut.HighPart != 0)
{
((PATQ_CONT) m_pAtqContext)->TimeOut = ATQ_INFINITE;
} else
{
((PATQ_CONT) m_pAtqContext)->TimeOut = liTimeOut.LowPart;
}
}
}
if (!AtqTransmitFile( m_pAtqContext,
hFile,
((liSize.HighPart == 0) ? liSize.LowPart : 0),
pFileBuffer ? &TransmitBuffers : NULL,
TF_DISCONNECT )
)
{
IF_DEBUG( ASYNC_IO) {
DWORD dwError = GetLastError();
DBGPRINTF(( DBG_CONTEXT,
"ASYNC_IO_CONNECTION(%08x)::TransmitFile() failed."
" Error = %u\n",
this, dwError));
SetLastError( dwError);
}
fReturn = FALSE;
}
return ( fReturn);
} // ASYNC_IO_CONNECTION::TransmitFile()
BOOL
ASYNC_IO_CONNECTION::StopIo( IN DWORD dwErrorCode OPTIONAL)
/*++
This function stops the io connection by performing a hard close on
the socket that is used for IO. that is the only way one can easily kill the
IO that is in progress.
Arguments:
dwErrorCode DWORD containing the error code for stopping IO
Returns:
TRUE on success and FALSE if there is a failure.
--*/
{
INT serr = 0;
IF_DEBUG( ASYNC_IO) {
DBGPRINTF( ( DBG_CONTEXT,
" ASYNC_IO_CONNECTION( %08x)::StopIo( %u)\n",
this, dwErrorCode
));
}
//
// NYI! dwErrorCode is not at present used.
//
if ( m_sClient != INVALID_SOCKET) {
SOCKET sOld = m_sClient;
m_sClient = INVALID_SOCKET;
// MuraliK 07/25/95 Shutdown causes problems in sending last msg.
# ifdef ENABLE_SHUT_DOWN
// Shut the socket and close it
// even if shut fails, still go ahead and close
if ( shutdown( sOld, 0) == SOCKET_ERROR) {
IF_DEBUG( ASYNC_IO) {
DBGPRINTF((DBG_CONTEXT,
" ASYNC_IO_CONNECTION( %08x)::StopIo( %u)."
"shutdown(%08x,1) failed. Error = %d\n",
this, dwErrorCode, sOld, WSAGetLastError()));
}
DBGERROR((DBG_CONTEXT, "shutdown(%u, 0) failed. Error=%u\n",
sOld, WSAGetLastError()));
}
#endif // ENABLE_SHUT_DOWN
//
// patch added on 11/2/95
// After AcceptEx addition, closing the ATQ'ed socket is
// is to be done by ATQ module.
//
if ( sOld != INVALID_SOCKET) {
if (m_pAtqContext != NULL) {
//
// per the FTP RFC, the server must close the socket when killing a data
// channel.
//
if (!AtqCloseSocket( m_pAtqContext, TRUE)) {
serr = GetLastError();
}
} else {
// Ignore failures in Shutdown and close socket.
if (closesocket( sOld) == SOCKET_ERROR) {
serr = WSAGetLastError();
}
}
if ( serr != 0 ) {
SetLastError( serr);
}
}
}
return ( serr == 0);
} // ASYNC_IO_CONNECTION::StopIo()
BOOL
ASYNC_IO_CONNECTION::SetNewSocket(IN SOCKET sNewSocket,
IN PATQ_CONTEXT pNewAtqContext, // = NULL
IN PVOID EndpointObject )
/*++
This function changes the socket maintained for given ASYNC_IO_CONNECTION
object. It changes it only if the current socket in the object is already
freed (by calling StopIo()).
If the Atq Context in this object is a valid one corresponding to old
socket, it is also freed. So any new operation will create a new AtqContext.
(This is essential, since there is a one-to-one-relationship between socket
and ATQ context)
Arguments:
sNewSocket new socket for the connection
If sNewSocket == INVALID_SOCKET then this function does
cleanup of old information.
pNewAtqContext new ATQ Context for the socket
Returns:
TRUE on success and FALSE if there is any failure.
--*/
{
BOOL fReturn = TRUE;
if ( m_sClient == INVALID_SOCKET) {
//
// Free the Atq Context if one already exists.
// ==> Reason: There is a one-to-one correspondence b/w ATQ Context
// and socket. The atq context if valid was created
// for old connection.
//
// To avoid race conditions, we exchange pointer with NULL
// and later on free the object as need be.
// Should we necessarily use InterlockedExchange() ???
// Isn't it costly? NYI
PATQ_CONTEXT pAtqContext =
(PATQ_CONTEXT ) InterlockedExchangePointer( (PVOID *) &m_pAtqContext,
(PVOID) pNewAtqContext);
if ( pAtqContext != NULL) {
AtqFreeContext( pAtqContext, TRUE );
}
m_sClient = sNewSocket;
m_endpointObject = EndpointObject;
} else {
SetLastError( ERROR_INVALID_PARAMETER);
fReturn = FALSE;
}
return ( fReturn);
} // ASYNC_IO_CONNECTION::SetNewSocket()
# if DBG
VOID ASYNC_IO_CONNECTION::Print( VOID) const
{
DBGPRINTF( ( DBG_CONTEXT,
" Printing ASYNC_IO_CONNECTION( %08x)\n"
" CallBackFunction = %08x; Context = %08x\n"
" Client Socket = %u; AtqContext = %08x;"
" Timeout = %u sec; \n",
this, m_pfnAioCompletion, m_pAioContext,
m_sClient, m_pAtqContext, m_sTimeout));
return;
} // ASYNC_IO_CONNECTION::Print()
# endif // DBG
VOID
ProcessAtqCompletion(IN LPVOID pContext,
IN DWORD cbIo,
IN DWORD dwCompletionStatus,
IN OVERLAPPED * lpo
)
/*++
This function processes the completion of an atq operation.
It also sends a call back to the owner of this object ( ASYNC_IO_CONNECTION)
object, once the operation is completed or if it is in error.
ATQ module sends 2 messages whenever there is a timeout.
Reason: The timeout itself is sent by a separate thread and completion port
API does not support removal of a socket from the completion port. Combining
these together, ATQ sends a separate timeout message and then when the
application blows off the socket/handle, ATQ sends another error message
implying failure of the connection.
We handle this as follows:
At timeout ATQ sends fIOCompletion == FALSE and
dwCompletionStatus == ERROR_SEM_TIMEOUT.
We send this as fTimedOut in call back.
The application can check if it is fTimedOut and hence refrain from
blowing the object completely away.
Arguments:
pContext pointer to User supplied context information
( here: pointer to ASYNC_IO_CONNECTION associated with
the IO completed)
cbIo count of bytes of IO performed
dwCompletionStatus DWORD containing error code if any
lpo - !NULL if completion from IO
Returns:
None
--*/
{
LPASYNC_IO_CONNECTION pConn = (LPASYNC_IO_CONNECTION ) pContext;
BOOL fTimedOut = FALSE;
if ( pConn == NULL) {
// This should not happen....
SetLastError( ERROR_INVALID_PARAMETER);
DBG_ASSERT( pConn == NULL);
return ;
}
IF_DEBUG( ASYNC_IO) {
DBGPRINTF( ( DBG_CONTEXT,
"ProcessAtqCompletion(Aio=%08x, cb=%u, Status=%u,"
"IO Compltion=%s).\n",
pConn, cbIo, dwCompletionStatus,
lpo != NULL ? "TRUE" : "FALSE" ));
}
if ( lpo != NULL ||
(fTimedOut = (
lpo == NULL &&
dwCompletionStatus == ERROR_SEM_TIMEOUT))
) {
//
// This is the right Atq object. Process the response by passing it
// to the owner of this object.
//
DBG_ASSERT( pConn->QueryPfnAioCompletion() != NULL);
//
// Invoke the call back function for completion of IO.
//
( *pConn->QueryPfnAioCompletion())
(pConn->QueryAioContext(), cbIo, dwCompletionStatus,
pConn, fTimedOut);
}
return;
} // ProcessAtqCompletion()
/************************ End of File ***********************/
Reference in a new issue Copy permalink