/** @file
* Copyright (c) 2008 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:  Definition of the CUpnpHttpMessageSender class
*
*/


#include <upnphttpmessage.h>
#include <upnplist.h>
#include <upnpcons.h>
#include <upnpstring.h>

#include "upnphttpmessagesender.h"
#include "upnphttpmessagesenderowner.h"
#include "upnphttptransaction.h"

#ifdef _DEBUG
#define KLogFile _L("HttpClientEngine.txt")
#endif
#include "upnpcustomlog.h"

// ----------------------------------------------------------------------------
// CUpnpHttpMessageSender::NewL
// Two-phased constructor.
// ----------------------------------------------------------------------------
//
CUpnpHttpMessageSender* CUpnpHttpMessageSender::NewL( CUpnpHttpTransaction& aUpnpTransaction,
    RHTTPSession aSession, MUpnpHttpMessageSenderOwner& aOwner )
    {
    CUpnpHttpMessageSender* self = CUpnpHttpMessageSender::NewLC( aUpnpTransaction,
                                                                  aSession, aOwner );
    CleanupStack::Pop( self );
    return self;
    }

// ----------------------------------------------------------------------------
// CUpnpHttpMessageSender::NewLC
// Two-phased constructor.
// ----------------------------------------------------------------------------
//
CUpnpHttpMessageSender* CUpnpHttpMessageSender::NewLC( CUpnpHttpTransaction& aUpnpTransaction,
    RHTTPSession aSession, MUpnpHttpMessageSenderOwner& aOwner )
    {
    CUpnpHttpMessageSender* self = new (ELeave) CUpnpHttpMessageSender( aUpnpTransaction,
                                                                        aSession, aOwner );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// ----------------------------------------------------------------------------
// CUpnpHttpMessageSender::CUpnpHttpMessageSender
// Constructor.
// ----------------------------------------------------------------------------
//
CUpnpHttpMessageSender::CUpnpHttpMessageSender( CUpnpHttpTransaction& aUpnpTransaction,
    RHTTPSession aSession, MUpnpHttpMessageSenderOwner& aOwner ) :
    iUpnpTransaction( aUpnpTransaction ),
    iSession( aSession ),
    iOwner( aOwner )
    {
    }

// ----------------------------------------------------------------------------
// CUpnpHttpMessageSender::ConstructL
// Constructor of CUpnpHttpMessageSender
// ----------------------------------------------------------------------------
//
void CUpnpHttpMessageSender::ConstructL()
    {
    iTimer = CUpnpNotifyTimer::NewL( this );
    }

// ----------------------------------------------------------------------------
// CUpnpHttpMessageSender::~CUpnpHttpMessageSender
// Destructor.
// ----------------------------------------------------------------------------
//
CUpnpHttpMessageSender::~CUpnpHttpMessageSender()
    {
    delete iBody;
    delete iTimer;
    iTransaction.Close();
    }

// ----------------------------------------------------------------------------
// CUpnpHttpMessageSender::UpnpTransaction
// Returns upnp transaction object that is maintained by the object.
// ----------------------------------------------------------------------------
//
CUpnpHttpTransaction& CUpnpHttpMessageSender::UpnpTransaction()
    {
    return iUpnpTransaction;
    }

// ----------------------------------------------------------------------------
// CUpnpHttpMessageSender::StartTransactionL
// Start a new HTTP transaction maintained by the object. It will start
// asynchronous sending of request message.
// ----------------------------------------------------------------------------
//
void CUpnpHttpMessageSender::StartTransactionL()
    {
    ASSERT( !iTimer->IsActive() && NULL == iBody ); //check if this method is called only once
    LOG_FUNC_NAME;

    PrepareRequestTransactionL();
    PrepareRequestHeadersL();
    PrepareRequestBody();
    StartRequestTimer();
    iTransaction.SubmitL();

    ASSERT( iTimer->IsActive() );   //timer is set
    }

// ----------------------------------------------------------------------------
// CUpnpHttpMessageSender::PrepareRequestTransactionL
// Opens RHTTPTransaction with request method and uri, subscribe
// for transaction's events
// ----------------------------------------------------------------------------
//
void CUpnpHttpMessageSender::PrepareRequestTransactionL()
    {
    HBufC8* uri = DestinationUriL( iUpnpTransaction.Request() );
    CleanupStack::PushL( uri );
    TUriParser8 uriParser;
    uriParser.Parse( *uri );
    RStringF method = iSession.StringPool().OpenFStringL( iUpnpTransaction.Request()->Method() );
    CleanupClosePushL( method );
    iTransaction = iSession.OpenTransactionL( uriParser, *this, method );
    CleanupStack::PopAndDestroy( &method );
    //synchronize ids of both transactions
    iUpnpTransaction.Request()->SetSessionId( iTransaction.Id() );
    CleanupStack::PopAndDestroy( uri );
    }

// ----------------------------------------------------------------------------
// CUpnpHttpMessageSender::PrepareRequestHeadersL
// Sets http headers from UpnpHttpTransaction to RHTTPTransaction
// ----------------------------------------------------------------------------
//
void CUpnpHttpMessageSender::PrepareRequestHeadersL()
    {
    RHTTPHeaders hdr = iTransaction.Request().GetHeaderCollection();
    hdr.RemoveAllFields();
    CUpnpHttpHeaderList& headerList =  *(iUpnpTransaction.Request()->HeaderList());
    CUpnpHttpHeader* upnphdr = headerList.First();
    upnphdr = headerList.Next(upnphdr);    // first header is a method
    while ( upnphdr )
        {
        RStringF valStr = iSession.StringPool().OpenFStringL( upnphdr->Value() );
        CleanupClosePushL( valStr );
        RStringF namStr = iSession.StringPool().OpenFStringL( upnphdr->Name() );
        CleanupClosePushL( namStr );

        hdr.SetFieldL( namStr, THTTPHdrVal( valStr ) );
        upnphdr = headerList.Next(upnphdr);

        CleanupStack::PopAndDestroy( &namStr );
        CleanupStack::PopAndDestroy( &valStr );
        }
    }

// ----------------------------------------------------------------------------
// CUpnpHttpMessageSender::CopyResponseHeadersL
// Copies http headers from RHTTPTransaction to UpnpHttpTransaction
// ----------------------------------------------------------------------------
//
void CUpnpHttpMessageSender::CopyResponseHeadersL()
    {
    CUpnpHttpMessage* msg = iUpnpTransaction.Response();
    RStringPool strPool = iSession.StringPool();
    RHTTPHeaders headers = iTransaction.Response().GetHeaderCollection();

    THTTPHdrFieldIter iter = headers.Fields();
    while ( !iter.AtEnd() )
        {
        RStringTokenF fieldName = iter();
        RStringF fieldNameStr = strPool.StringF( fieldName );
        const TDesC8& fieldNameDesC = fieldNameStr.DesC();

        TPtrC8 rawFieldData;
        if ( headers.GetRawField( fieldNameStr, rawFieldData ) == KErrNone )
            {
            msg->AddPairL( fieldNameDesC, rawFieldData );
            }

        ++iter;
        }
    }

// ----------------------------------------------------------------------------
// CUpnpHttpMessageSender::PrepareRequestBodyL
// Sets http message body from UpnpHttpTransaction to RHTTPTransaction
// ----------------------------------------------------------------------------
//
void CUpnpHttpMessageSender::PrepareRequestBody()
    {
    if ( iUpnpTransaction.Request()->Method().Compare( KHttpPost ) == 0 
       || ( iUpnpTransaction.Request()->Method().Compare( UpnpGENA::KGenaNotify ) == 0 ) )
        {
        iTransaction.Request().SetBody( *this );
        }
    }

// ----------------------------------------------------------------------------
// CUpnpHttpMessageSender::StartRequestTimer
// Starts timer of request sending with TcpTimeout value.
// ----------------------------------------------------------------------------
//
void CUpnpHttpMessageSender::StartRequestTimer()
    {
    iTimer->After( iUpnpTransaction.Request()->TcpTimeout(), EFalse );
    }

// ----------------------------------------------------------------------------
// CUpnpHttpMessageSender::TimerEventL
// From MNotifyTimerObserver function which indicate that request timeout
// expired, so transaction failed.
// ----------------------------------------------------------------------------
//
void CUpnpHttpMessageSender::TimerEventL( CUpnpNotifyTimer* /*aTimer*/ )
    {
    LOG_FUNC_NAME;
    TransactionFailed( EHttpRequestTimeout );
    }

// ----------------------------------------------------------------------------
// CUpnpHttpMessageSender::MHFRunL
// Called by Symbian OS HTTP client framework to notify about transaction events.
// ----------------------------------------------------------------------------
//
void CUpnpHttpMessageSender::MHFRunL( RHTTPTransaction aTransaction, const THTTPEvent& aEvent )
    {
    ASSERT( aTransaction == iTransaction );
    switch ( aEvent.iStatus )
        {
        case THTTPEvent::EGotResponseHeaders:
            {
            LOGS1( "THTTPEvent::EGotResponseHeaders trans id: %d",
                aTransaction.Id() );
            }
            break;
        case THTTPEvent::EGotResponseBodyData:
            {
            GotResponseBodyDataL( *(aTransaction.Response().Body()) );
            }
            break;
        case THTTPEvent::EResponseComplete:
            {
            LOGS( "THTTPEvent::EResponseComplete");
            // Indicates that header & body of response is completely received.
            }
            break;
        //note: there is a guarantee that THTTPEvent::ESucceeded XOR THTTPEvent::EFailed
        //event will be provided, and it will be the last event for a transaction
        //so ESucceeded and EFailed are the only legal states
        //in which we can call TransactionSucceeded/TransactionFailed
        case THTTPEvent::ESucceeded:
            {
            LOGS( "THTTPEvent::ESucceeded");
            TransactionSucceeded();
            }
            break;
        case THTTPEvent::EFailed:
            {
            LOGS( "THTTPEvent::EFailed");
            if ( KErrNone != iCurrentErrorNumber )
                {
                TransactionFailed( EHttpRequestTimeout, iCurrentErrorNumber );
                }
            else
                {
                TransactionFailed( aTransaction.Response().StatusCode() );
                }
            }
            break;
        default:
            // There are more events in THTTPEvent, but they are not usually
            // needed. However, event status smaller than zero should be handled
            // correctly since it's error.
            {
            LOGS1( "Other THTTPEvent::%d", aEvent.iStatus );
            if ( aEvent.iStatus < 0 )
                {
                iCurrentErrorNumber = aEvent.iStatus;
                }
            }
            break;
        }
    }

// ----------------------------------------------------------------------------
// CUpnpHttpMessageSender::MHFRunError
// Called by Symbian OS HTTP client framework when *leave* occurs in handling
// of transaction event
// ----------------------------------------------------------------------------
//
TInt CUpnpHttpMessageSender::MHFRunError( TInt aError,
                          RHTTPTransaction /*aTransaction*/,
                          const THTTPEvent& /*aEvent*/ )
    {
    LOGS1( "Run error %d", aError );
    //in case of serious errors we are receiving here we have to notify
    //error immediatly (we probably won't receive THTTPEvent::EFailed)
    TransactionFailed( EHttpRequestTimeout, aError );
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CUpnpHTTPMessageSender::TransactionSucceededL
// Called when transaction succeeded.
// Closes RHTTPTransaction, and forward result message to observer.
// -----------------------------------------------------------------------------
void CUpnpHttpMessageSender::TransactionSucceeded()
    {
    //there is nothing we can do about error during notification upper layer
    //except retry (risky), or ignore
    TRAP_IGNORE( DoTransactionSucceededL() );
    }

// -----------------------------------------------------------------------------
// CUpnpHttpMessageSender::TransactionFailedL
// Called in case of every fail of transaction.
// Closes RHTTPTransaction, creates error message with given status, and forward it
// to observer.
// -----------------------------------------------------------------------------
void CUpnpHttpMessageSender::TransactionFailed( TInt aStatus, TInt aError )
    {
    //see comment in TransactionSucceeded
    TRAP_IGNORE( DoTransactionFailedL( aStatus, aError ) );
    }

// -----------------------------------------------------------------------------
// CUpnpHTTPMessageSender::DoTransactionSucceededL
// Internal, leaving code to notify that transaction succeeded
// Do NOT use this method directly, but via TransactionSucceded
// -----------------------------------------------------------------------------
void CUpnpHttpMessageSender::DoTransactionSucceededL()
    {
    LOG_FUNC_NAME;
    iTimer->Cancel();
    iUpnpTransaction.CreateOkResponseL( iBody ? *iBody : KNullDesC8() );
    CopyResponseHeadersL(); //to copy SID from service subscription http response 
    iTransaction.Close();
    delete iBody;
    iBody = NULL;
    iOwner.SenderFinishedLD( this );    
    }

// -----------------------------------------------------------------------------
// CUpnpHTTPMessageSender::DoTransactionFailedL
// Internal, leaving code to notify that transaction failed
// Do NOT use this method directly, but via TransactionFailed
// -----------------------------------------------------------------------------
void CUpnpHttpMessageSender::DoTransactionFailedL( TInt aStatus, TInt aError )
    {
    LOG_FUNC_NAME;
    iTimer->Cancel();
    iTransaction.Close();
    if ( KErrNone != aError ) //in case of internal symbian error colected body isn't meaningful
        {
        delete iBody;
        iBody = NULL;
        }    
    iUpnpTransaction.CreateFaultResponseL( iBody ? *iBody : KNullDesC8(),
                                               aStatus, 
                                               aError );
    delete iBody;
    iBody = NULL;
    iOwner.SenderFinishedLD( this );    
    }

// -----------------------------------------------------------------------------
// CUpnpHttpMessageSender::GotResponseBodyDataL
// Called when transaction got another part of body data.
// Data is concatenated to iBody and when the last part of body is received
// request message is created witin transaction.
// -----------------------------------------------------------------------------
void CUpnpHttpMessageSender::GotResponseBodyDataL(
    MHTTPDataSupplier& aResponseBodySupplier )
    {
    LOG_FUNC_NAME;

    TPtrC8 dataChunk;
    aResponseBodySupplier.GetNextDataPart( dataChunk );
    
    if (!iBody)
        {
        iBody = dataChunk.AllocL();
        }
    else
        {
        iBody = iBody->ReAllocL( iBody->Length() + dataChunk.Length() );
        iBody->Des().Append( dataChunk );
        }

    aResponseBodySupplier.ReleaseData();    
    }

// -----------------------------------------------------------------------------
// CUpnpHTTPMessageSender::DestinationUriL
// Helper method that allocate descriptor object with destination uri of message
// passed as a parameter.
// -----------------------------------------------------------------------------
HBufC8* CUpnpHttpMessageSender::DestinationUriL( CUpnpHttpMessage* aMessage )
    {
    TInetAddr add( aMessage->Receiver() );
    HBufC8* address = UpnpString::InetToStringL( add );
    CleanupStack::PushL( address );
    TPtrC8 path( aMessage->SenderPathFromHeader() ) ;
    HBufC8* uriBuf = HBufC8::NewL(
        UpnpHTTP::KHTTPUrl().Length() + address->Length() + path.Length() );
    TPtr8 uri( uriBuf->Des() );
    uri.Append( UpnpHTTP::KHTTPUrl );
    uri.Append( *address );
    uri.Append( path );
    CleanupStack::PopAndDestroy( address );
    return uriBuf;
    }

// -----------------------------------------------------------------------------
// CUpnpHttpMessageSender::GetNextDataPart
// Method from MHTTPDataSupplier used to supply body of request from
// our UpnpMessage to Symian RHTTPRequest
// -----------------------------------------------------------------------------
TBool CUpnpHttpMessageSender::GetNextDataPart( TPtrC8& aDataChunk )
    {
    aDataChunk.Set( iUpnpTransaction.Request()->Body() );
    return ETrue;
    }

// -----------------------------------------------------------------------------
// CUpnpHttpMessageSender::ReleaseData()
// Method from from MHTTPDataSupplier to supply body of request from
// our UpnpMessage to Symian RHTTPRequest
// -----------------------------------------------------------------------------
void CUpnpHttpMessageSender::ReleaseData()
    {
    }

// -----------------------------------------------------------------------------
// CUpnpHttpMessageSender::OverallDataSize
// Method from MHTTPDataSupplier used to supply body of request from
// our UpnpMessage to Symian RHTTPRequest
// -----------------------------------------------------------------------------
TInt CUpnpHttpMessageSender::OverallDataSize()
    {
    return iUpnpTransaction.Request()->Body().Length();
    }

// -----------------------------------------------------------------------------
// CUpnpHttpMessageSender::Reset
// Method from MHTTPDataSupplier used to supply body of request from
// our UpnpMessage to Symian RHTTPRequest
// -----------------------------------------------------------------------------
TInt CUpnpHttpMessageSender::Reset()
    {
    return KErrNone;
    }

// ----------------------------------------------------------------------------
// CUpnpHttpMessageSender::CancelTransaction
// Cancels transaction
// ----------------------------------------------------------------------------
//
void CUpnpHttpMessageSender::CancelTransaction()
    {
    LOG_FUNC_NAME;
    iTransaction.Cancel();
    iTimer->Cancel();
    TransactionFailed( EHttpRequestTimeout );//no need to wait, notify timeout
    }

//end of file