/*

* Copyright (c) 2003 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: Adapter for Http transport.

*

*

*/

// INCLUDE FILES

#include <in_iface.h>

#include <impserrors.h>

#include <msgconnmanagerapi.h>

#include "HttpTransportAdapter.h"

#include "ImpsHttpTransaction.h"

#ifdef _DEBUG

#include "flogger.h"

#endif

// ================= MEMBER FUNCTIONS =======================

//

// ----------------------------------------------------------

// CHttpTransportAdapter::CHttpTransportAdapter

//

// ----------------------------------------------------------

//

CHttpTransportAdapter::CHttpTransportAdapter( MImpsDataReceiver& aReceiver,

                                              MMsgConnManager& aConnManager ) :

        iSuspend( EFalse ),

        iSessionClosed( ETrue ),

        iReceiver( aReceiver ),

        iConnManager( aConnManager )

    {

    }

// ----------------------------------------------------------

// CHttpTransportAdapter::NewL

//

// ----------------------------------------------------------

//

CHttpTransportAdapter* CHttpTransportAdapter::NewL( MImpsDataReceiver& aReceiver,

                                                    MMsgConnManager& aConnManager,

                                                    const TDesC8& aMimeType )

    {

    CHttpTransportAdapter* self = new ( ELeave ) CHttpTransportAdapter( aReceiver, aConnManager );

    CleanupStack::PushL( self );

    self->ConstructL( aMimeType );

    CleanupStack::Pop();  //self

    return self;

    }

// ----------------------------------------------------------

// CHttpTransportAdapter::ConstructL

//

// ----------------------------------------------------------

//

void CHttpTransportAdapter::ConstructL( const TDesC8& aMimeType )

    {

#ifdef _DEBUG

    DeleteLogFilesL();

#endif

    SetMimeTypeL( aMimeType );

    }

// ----------------------------------------------------

// CHttpTransportAdapter::~CHttpTransportAdapter()

// Destructor

// ----------------------------------------------------

//

CHttpTransportAdapter::~CHttpTransportAdapter()

    {

#ifdef _DEBUG

    WriteToLog( _L8( "CHttpTransportAdapter::~CHttpTransportAdapter(). Destructor called." ) );

#endif

    iHttpSession.Close();

    iSessionClosed = ETrue;

    iTransactionQueue.ResetAndDestroy();

    iTransactionQueue.Close();

    delete iUrlBuffer;

    delete iProxyBuffer;

    delete iMimeBuffer;

#ifdef _DEBUG

    WriteToLog( _L8( "  Destructor ended." ) );

#endif

    }

// ----------------------------------------------------

// CHttpTransportAdapter::InitialiseSessionL

//

// ----------------------------------------------------

//

void CHttpTransportAdapter::InitialiseSessionL()

    {

#ifdef _DEBUG

    WriteToLog( _L8( "CHttpTransportAdapter::InitialiseSessionL()" ) );

#endif

    iHttpSession.OpenL();

    RSocketServ& session = iConnManager.SocketSession();

    RConnection& connection = iConnManager.Connection();

    RHTTPConnectionInfo connInfo = iHttpSession.ConnectionInfo();

    RStringPool stringPool = iHttpSession.StringPool();

    TInt conn = reinterpret_cast <TInt> ( &connection );

    connInfo.SetPropertyL( stringPool.StringF( HTTP::EHttpSocketServ, RHTTPSession::GetTable() ),

                           THTTPHdrVal( session.Handle() ) );

    connInfo.SetPropertyL( stringPool.StringF( HTTP::EHttpSocketConnection, RHTTPSession::GetTable() ),

                           THTTPHdrVal( conn ) );

    connInfo.SetPropertyL( stringPool.StringF( HTTP::EHTTPVersion, RHTTPSession::GetTable() ),

                           THTTPHdrVal( stringPool.StringF( HTTP::EHttp11, RHTTPSession::GetTable() ) ) );

    iSessionClosed = EFalse;

#ifdef _DEBUG

    WriteToLog( _L8( "InitialiseSessionL() ends." ) );

#endif

    }

// ----------------------------------------------------

// CHttpTransportAdapterder::CancelTransaction

//

// ----------------------------------------------------

//

void CHttpTransportAdapter::CancelTransaction( const TInt aTID )

    {

#ifdef _DEBUG

    WriteToLog( _L( "CHttpTransportAdapter::CancelTransaction(): TID %d" ), aTID );

#endif

    TInt count = iTransactionQueue.Count();

#ifdef _DEBUG

    WriteToLog( _L( "  %d items in transaction queue." ), count );

#endif

    for ( TInt i = 0;i < count;i++ )

        {

        CImpsHttpTransaction* transaction = iTransactionQueue[i];

        if ( transaction->TID() == aTID )

            {

#ifdef _DEBUG

            WriteToLog( _L( "    Request TID %d set to cancelled state." ), transaction->TID() );

#endif

            RemoveFromQueue( transaction );

            break;

            }

        }

    }

// ----------------------------------------------------

// CHttpTransportAdapter::CancelAll()

//

// ----------------------------------------------------

//

void CHttpTransportAdapter::CancelAll()

    {

#ifdef _DEBUG

    WriteToLog( _L( "CHttpTransportAdapter::CancelAll()" ) );

#endif

    CImpsHttpTransaction* transaction = NULL;

    TInt count = iTransactionQueue.Count();

#ifdef _DEBUG

    WriteToLog( _L( "  %d items in transaction queue" ), count );

#endif

    for ( TInt i = 0;i < count;i++ )

        {

        transaction = iTransactionQueue[i];

        delete transaction;

        transaction = NULL;

#ifdef _DEBUG

        WriteToLog( _L( "    Item %d deleted from transaction queue" ), i );

#endif

        }

    iTransactionQueue.Reset();

    }

// ----------------------------------------------------

// CHttpTransportAdapter::SendL

//

// ----------------------------------------------------

//

void CHttpTransportAdapter::SendL( const TInt aTID, const TDesC8& aMessage,

                                   const TInt aExpiryTime )

    {

#ifdef _DEBUG

    WriteToLog( _L( "SendL() called, aTID: %d" ), aTID );

#endif

    //GPRS is suspended

    if ( iSuspend )

        {

#ifdef _DEBUG

        WriteToLog( _L( "SendL(): GPRS suspended, leaves with \"KImpsErrorBearerSuspended\"." ) );

#endif

        User::Leave( KImpsErrorBearerSuspended );

        }

    //OpenL() has not been called

    else if ( iUrlBuffer == NULL )

        {

#ifdef _DEBUG

        WriteToLog( _L( "SendL(): No SAP defined, leaves with KImpsErrorSessionNotOpen" ) );

#endif

        User::Leave( KImpsErrorSessionNotOpen );

        }

    else

        {

        CImpsHttpTransaction* transaction = CImpsHttpTransaction::NewL( this, aTID, aMessage );

        CleanupStack::PushL( transaction );

        //Append the transaction to the end of the list of pending

        //requests. The request gets removed as soon as a response

        //arrives or timer expires.

        TInt error = iTransactionQueue.Append( transaction );

        if ( error != KErrNone )

            User::Leave( error );

        else

            {

            CleanupStack::Pop();  //transaction

            //If the client application wants to time this request,

            //aExpiryTime parameter should not be 0. If it is,

            //ignore it; if not, instantiate timer and set this

            //object as the receiver of the prospective expiry event.

            //This requires the MImpsTransportTimerCallback interface

            //and HandleTransportTimerEvent function to be implemented

            if ( aExpiryTime != 0 )

                transaction->SetExpiryTimeL( /* The timer expects milliseconds,

                                              * so multiply by million. */

                    aExpiryTime * 1000000, this );

            //If suspend occurs after this,

            //there is absolutely nothing that can be done

            if ( iConnManager.Status() )

                transaction->DispatchMessageL();

            else

                User::Leave( KImpsErrorBearerSuspended );

            }

        }

    }

// ----------------------------------------------------

// CHttpTransportAdapter::Open

//

// ----------------------------------------------------

//

void CHttpTransportAdapter::OpenL( const TDesC& aSAP )

    {

#ifdef _DEBUG

    TBuf8<256> eightBuf;

    eightBuf.Copy( aSAP );

    WriteToLog( _L8( "CHttpTransportAdapter::OpenL()" ) );

    WriteToLog( _L8( " SAP: %S" ), &eightBuf );

#endif

    if ( !iConnManager.Status() )

        User::Leave( KImpsErrorBearerSuspended );

    if ( iSessionClosed )

        {

        InitialiseSessionL();

        SetUrlL( aSAP );

        SetProxyL();

#ifdef _DEBUG

        WriteToLog( _L8( "  URL: %S" ), &iDefaultURL.UriDes() );

#endif

        iConnManager.AddEventSubscriberL( this );

        }

    else

        {

#ifdef _DEBUG

        WriteToLog( _L8( "  OpenL(): Already open, leaves with KErrAlreadyExists." ) );

#endif

        User::Leave( KErrAlreadyExists );

        }

    }

// ----------------------------------------------------

// CHttpTransportAdapter::Close

//

// ----------------------------------------------------

//

void CHttpTransportAdapter::Close()

    {

#ifdef _DEBUG

    WriteToLog( _L8( "CHttpTransportAdapter::Close()" ) );

#endif

    if ( iTransactionQueue.Count() > 0 )

        CancelAll();

    if ( iSuspend )

        iSuspend = EFalse;

    delete iUrlBuffer;

    iUrlBuffer = NULL;

    iHttpSession.Close();

    iSessionClosed = ETrue;

    iConnManager.RemoveEventSubscriber( this );

    }

// ----------------------------------------------------

// CHttpTransportAdapter::SetProxyL

//

// ----------------------------------------------------

//

void CHttpTransportAdapter::SetProxyL()

    {

    //It must be checked if there is the

    //dummy proxy defined in CommsDb

    _LIT8( KPortSeparatorColon, ":" );

    _LIT( KDummyProxy, "www.dummyproxy.com" );

#ifdef _DEBUG

    WriteToLog( _L8( "CHttpTransportAdapter::SetProxyL" ) );

#endif

    delete iProxyBuffer;

    iProxyBuffer = NULL;

    HBufC* address = iConnManager.ReadFromCommsDbLC( EMsgProxyAddress );

    if ( address != NULL && address->CompareF( KDummyProxy ) != 0 )

        {

        HBufC* port = iConnManager.ReadFromCommsDbLC( EMsgProxyPort );

        iProxyBuffer = HBufC8::NewL( address->Length() +

                                     port->Length() + 1 );  //":"

        iProxyBuffer->Des().Copy( *address );

        iProxyBuffer->Des().Append( KPortSeparatorColon );

        iProxyBuffer->Des().Append( *port );

        CleanupStack::PopAndDestroy( 2 );  //port, address

#ifdef _DEBUG

        TPtrC8 proxy( *iProxyBuffer );

        WriteToLog( _L8( "  Proxy set to: %S" ), &proxy );

#endif

        RStringF proxyAddress = iHttpSession.StringPool().OpenFStringL( iProxyBuffer->Des() );

        RHTTPConnectionInfo connInfo = iHttpSession.ConnectionInfo();

        THTTPHdrVal proxyUsage( iHttpSession.StringPool().StringF( HTTP::EUseProxy, RHTTPSession::GetTable() ) );

        connInfo.SetPropertyL( iHttpSession.StringPool().StringF( HTTP::EProxyUsage, RHTTPSession::GetTable() ), proxyUsage );

        THTTPHdrVal proxyAddr( proxyAddress );

        connInfo.SetPropertyL( iHttpSession.StringPool().StringF( HTTP::EProxyAddress, RHTTPSession::GetTable() ), proxyAddr );

        proxyAddress.Close();

        }

    else

        {

        if ( address != NULL )

            {

#ifdef _DEBUG

            HBufC8* temp = HBufC8::NewL( address->Length() );

            temp->Des().Copy( *address );

            TPtrC8 proxy( temp->Des() );

            WriteToLog( _L8( "  Improper proxy (%S) defined, ignore" ), &proxy );

            delete temp;

            temp = NULL;

#endif

            CleanupStack::PopAndDestroy();  //address

            }

        else

            {

#ifdef _DEBUG

            WriteToLog( _L8( "  No proxy defined for this Access Point" ) );

#endif

            }

        }

    }

// ----------------------------------------------------

// CHttpTransportAdapter::SetMimeTypeL

//

// ----------------------------------------------------

//

void CHttpTransportAdapter::SetMimeTypeL( const TDesC8& aMimeType )

    {

    if ( aMimeType.Length() > 0 )

        {

        delete iMimeBuffer;

        iMimeBuffer = NULL;

        iMimeBuffer = HBufC8::NewL( aMimeType.Length() );

        iMimeBuffer->Des().Copy( aMimeType );

#ifdef _DEBUG

        TPtr8 ptr( iMimeBuffer->Des() );

        WriteToLog( _L8( "CHttpTransportAdapter::SetMimeTypeL(): %S" ), &ptr );

#endif

        }

    }

// ----------------------------------------------------

// CHttpTransportAdapter::SetUrlL

//

// ----------------------------------------------------

//

void CHttpTransportAdapter::SetUrlL( const TDesC& aUrl )

    {

#ifdef _DEBUG

    WriteToLog( _L8( "CHttpTransportAdapter::SetUrl()" ) );

#endif

    _LIT( KHttp, "http://" );

    delete iUrlBuffer;

    iUrlBuffer = NULL;

    if ( aUrl.FindF( KHttp ) == 0 )

        iUrlBuffer = HBufC8::NewL( aUrl.Length() );

    else

        {

        iUrlBuffer = HBufC8::NewL( aUrl.Length() + 7 );

        iUrlBuffer->Des().Copy( KHttp );

        }

    iUrlBuffer->Des().Append( aUrl );

    iDefaultURL.Parse( iUrlBuffer->Des() );

    }

// ----------------------------------------------------------

// CHttpTransportAdapter::HandleTransportTimerEventL

//

// ----------------------------------------------------------

//

void CHttpTransportAdapter::HandleTransportTimerEventL( TImpsTimingRequester* aTransaction,

                                                        const TInt /*aStatus*/ )

    {

    CImpsHttpTransaction* transaction = ( CImpsHttpTransaction* ) aTransaction;

    TInt httpStatus = transaction->HttpStatus();

#ifdef _DEBUG

    WriteToLog( _L8( "CHttpTransportAdapter::HandleTransportTimerEventL()  Request: %d" ), transaction->TID() );

#endif

    iReceiver.TransportResponse( transaction->TID(), KErrTimedOut, httpStatus, NULL );

    RemoveFromQueue( transaction );

    }

// ----------------------------------------------------

// CHttpTransportAdapter::MHFRunL

//

// ----------------------------------------------------

//

void CHttpTransportAdapter::MHFRunL( RHTTPTransaction aTransaction, const THTTPEvent& aEvent )

    {

    switch ( aEvent.iStatus )

        {

        case THTTPEvent::EGotResponseHeaders:

            {

            CImpsHttpTransaction* action = ImpsTransaction( aTransaction );

            RHTTPResponse response = aTransaction.Response();

            TInt contentLength = ContentLengthL( response );

            action->SetContentLength( contentLength );

#ifdef _DEBUG

            TInt status = response.StatusCode();

            RStringF statusStr = response.StatusText();

            TBuf<32> statusStr16;

            statusStr16.Copy( statusStr.DesC() );

            WriteToLog( _L( "CHttpTransportAdapter::MHFRunL(), Status: %d (%S), TID: %d, Round-Trip: %d ms" ),

                        status, &statusStr16, action->TID(),

                        action->TimeL() - action->SendTime() );

            DumpResponseHeadersL( aTransaction, action->TID() );

#endif

            //If this transaction has been cancelled, it must be handled now.

            if ( action->IsCancelled() )

                {

                //This does cancelling automagically

#ifdef _DEBUG

                WriteToLog( _L( "CHttpTransportAdapter::MHFRunL(), TID: \"%d\" was cancelled" ), action->TID() );

#endif

                RemoveFromQueue( action );

                break;

                }

            switch ( contentLength )

                {

                case 0:

                    //Content-Length of the response may or may not be 0.

                    //If it is, the response is most likely a poll response.

#ifdef _DEBUG

                    WriteToLog( _L8( "CHttpTransportAdapter::MHFRunL(), Content-Length 0, no body to wait for." ) );

                    WriteToLog( _L8( "CHttpTransportAdapter::MHFRunL(), Calling receiver with a TID \"%d\"" ), action->TID() );

#endif

                    iReceiver.TransportResponse( action->TID(), KErrNone,

                                                 action->HttpStatus(), NULL );

                    RemoveFromQueue( action );

                    break;

                case KMaxTInt:

                    /*

                    It may be, however, that the Transfer-Encoding = "chunked",

                    in which case missing Content-Length is perfectly acceptable.

                    Thus, if the response body is supposed to arrive in chunks,

                    ignore this event and wait for the next one. In other words,

                    let the HTTP stack decide what to do next.

                    This case is essentially identical to the default case, but

                    rendering it this way might make the fact a bit more obvious and,

                    thus, the code also a bit more readable. The compiler probably

                    knows how to optimise this, anyway.

                    */

                    break;

                default:

                    break;

                }

            }

        break;

        case THTTPEvent::EGotResponseBodyData:

            {

            TPtrC8 bodyData;

            CImpsHttpTransaction* action = ImpsTransaction( aTransaction );

#ifdef _DEBUG

            WriteToLog( _L8( "MHFRunL(): a body part received - TID: %d" ), action->TID() );

#endif

            //The request data can now be deleted

            action->DoReleaseData();

            // Get the body data supplier

            iRespBody = aTransaction.Response().Body();

            TBool lastChunk = iRespBody->GetNextDataPart( bodyData );

            action->AppendDataL( bodyData, lastChunk );

            // Done with that bit of body data

            iRespBody->ReleaseData();

            if ( lastChunk )

                {

#ifdef _DEBUG

                WriteToLog( _L8( "  Last chunk - TID: %d" ), action->TID() );

#endif

                action->FinaliseRequestL( KErrNone );

                }

            }

        break;

        case THTTPEvent::EResponseComplete:

            {

            //The response of the transaction is complete

#ifdef _DEBUG

            WriteToLog( _L( "CHttpTransportAdapter::MHFRunL(), Transaction Complete" ) );

#endif

            }

        break;

        case THTTPEvent::ESucceeded:

            {

            CImpsHttpTransaction* action = ImpsTransaction( aTransaction );

            //If iLastChunk is not ETrue, the framework has not changed it when

            //it delivered the payload data. For some reason the framework

            //does not return ETrue when GetNextDataPart() is called while the

            //value of the Transfer-Encoding header is "chunked". Hence we must

            //call the client application now.

            if ( !action->LastChunk() )

                {

#ifdef _DEBUG

                WriteToLog( _L8( "CHttpTransportAdapter::MHFRunL(), Transaction finished, but iLastChunk = EFalse." ) );

                WriteToLog( _L8( "  Complete the transaction %d" ), action->TID() );

#endif