/*++

   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_fFileIO          ( FALSE),
    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_fFileIO && m_sClient != INVALID_SOCKET) ||
         ( m_fFileIO && m_sClient != (SOCKET)INVALID_HANDLE_VALUE) ) {

        //
        // 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,
    IN LONGLONG  liOffset
    )
/*++
  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)
     liOffset         When writing to file, use this offset to initialize the ATQ
                        overlapped structure

  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 no ATQ context yet, create one.
    // set offset in ATQ overlapped structure
    // initiate the async read
    //

    if ( (m_pAtqContext == NULL && !AddToAtqHandles()) ||
         (m_fFileIO && AtqContextSetInfo(
                           QueryAtqContext(),
                           ATQ_INFO_SET_OVL_OFFSET,
                           (ULONG_PTR)&liOffset)) ||
        !AtqReadFile( m_pAtqContext, pvBuffer, cbSize, NULL )) {

        IF_DEBUG( ASYNC_IO) {

            DWORD dwError = GetLastError();
            DBGPRINTF(( DBG_CONTEXT,
                       "ASYNC_IO_CONNECTION(%08x)::ReadFile() 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,
    IN LONGLONG  liOffset
    )
/*++
  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.
     liOffset         When writing to file, use this offset to initialize the ATQ
                       overlapped structure

  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.
    //
    // set offset in ATQ overlapped structure
    //

    if ( (m_pAtqContext == NULL && !AddToAtqHandles()) ||
         (m_fFileIO && AtqContextSetInfo(
                           QueryAtqContext(),
                           ATQ_INFO_SET_OVL_OFFSET,
                           (ULONG_PTR)&liOffset)) ||
        !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 LONGLONG        llOffset,
    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;
        }
    }

    AtqContextSetInfo( QueryAtqContext(),
                       ATQ_INFO_SET_OVL_OFFSET,
                       (ULONG_PTR)&llOffset);

    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 LONGLONG            llOffset,
    IN BOOL                fDisconnectSocket
    )
/*++
  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.
    fDisconnectSocket is the socket getting disconnected after this transmit,
                      or this is a part of a large file, so keep socket open.

  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 + (DWORD)llOffset;
        TransmitBuffers.HeadLength = liSize.LowPart;
        TransmitBuffers.Tail       = NULL;
        TransmitBuffers.TailLength = 0;
    } else {
        //
        // Transmit from a file
        //
        hFile = pOpenFile->QueryFileHandle();

        AtqContextSetInfo( QueryAtqContext(),
                           ATQ_INFO_SET_OVL_OFFSET,
                           (ULONG_PTR)&llOffset);


        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,
                          fDisconnectSocket ? TF_DISCONNECT : 0)
        )
    {

        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;
    SOCKET sOld = m_sClient;

    m_sClient = INVALID_SOCKET;

    IF_DEBUG( ASYNC_IO) {

        DBGPRINTF( ( DBG_CONTEXT,
                    " ASYNC_IO_CONNECTION( %08x)::StopIo( %u)\n",
                    this, dwErrorCode
                    ));
    }

    //
    // nothing to do if the m_sClient not valid
    //

    if ( !m_fFileIO && (sOld == INVALID_SOCKET) ) {
        goto StopIo_exit;
    }

    //
    // NYI! dwErrorCode is not at present used.
    //

    if ( m_fFileIO ) {

        HANDLE hHandle = (HANDLE)sOld;

        m_fFileIO = FALSE;

        DBG_ASSERT( hHandle != INVALID_HANDLE_VALUE );

        if (m_pAtqContext != NULL) {

            if (!AtqCloseFileHandle( m_pAtqContext)) {

                serr = GetLastError();
            }
        } else {

            if ( !CloseHandle( hHandle)) {

                serr = GetLastError();
            }
        }

    } else {

        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);
        }
    }

StopIo_exit:
    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;

    DBG_ASSERT( !m_fFileIO);

    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()



BOOL
ASYNC_IO_CONNECTION::SetNewFile(IN HANDLE hNewFile)
/*++

  Similar to SetNewSocket above.


  Arguments:
    hNewFile   new file handle
     If hNewFile == INVALID_HANDLE_VALUE 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;

    fReturn = SetNewSocket( NULL);

    if ( fReturn) {
        m_fFileIO = TRUE;
        m_sClient = (SOCKET)hNewFile;
    }

    return fReturn;

} // ASYNC_IO_CONNECTION::SetNewFile()



# 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 ***********************/