/*

* Copyright (c) 2008-2009 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:  Implements generic HTTP GET and POST functionality

*

*/

// INCLUDE FILES

#include <http.h>

#include <cookiefilterinterface.h>

#include <uaproffilter_interface.h>

#include "wmdrmdladefaulthttpmanager.h"

#define _LOGGING_FILE L"wmdrmdladefaulthttpplugin.txt"

#include "logfn.h"

/**

 *  HTTP_STRING macro

 *  To use HTTP_STRING macro you need a variable 'pool' defined (of

 *  RStringPool type).

 *  @param  aStringId  - an ID for string from HTTP Client's string table

 *  (e.g. 'HTTP::EAccept')

 */

#define HTTP_STRING(aStringId)pool.StringF(aStringId, RHTTPSession::GetTable())

/**

 *  SET_HTTP_PROPERTY macro

 *  Sets value for a property of HTTP session

 *  @param  info    - RHTTPConnectionInfo

 *  @param  pool    - RStringPool

 *  @param  property - property ID, a value from HTTP string table

 *  @param  value   - value to set

 */

#define SET_HTTP_PROPERTY(info, pool, property, value) \

                info.SetPropertyL( HTTP_STRING(property), THTTPHdrVal(value))

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

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

// CWmDrmDlaDefaultHttpManager::NewL

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

CWmDrmDlaDefaultHttpManager* CWmDrmDlaDefaultHttpManager::NewL(

    MWmDrmDlaDefaltHttpManagerObserver& aObserver )

    {

    LOGFN( "CWmDrmDlaDefaultHttpManager::NewL(1)" );

    CWmDrmDlaDefaultHttpManager* self =

        new(ELeave) CWmDrmDlaDefaultHttpManager( aObserver, 0 );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CWmDrmDlaDefaultHttpManager::NewL

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

CWmDrmDlaDefaultHttpManager* CWmDrmDlaDefaultHttpManager::NewL(

    MWmDrmDlaDefaltHttpManagerObserver& aObserver,

    TUint32 aIapNumber )

    {

    LOGFN( "CWmDrmDlaDefaultHttpManager::NewL(2)" );

    CWmDrmDlaDefaultHttpManager* self =

        new(ELeave) CWmDrmDlaDefaultHttpManager( aObserver, aIapNumber );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CWmDrmDlaDefaultHttpManager::~CWmDrmDlaDefaultHttpManager

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

CWmDrmDlaDefaultHttpManager::~CWmDrmDlaDefaultHttpManager()

    {

    LOGFN( "CWmDrmDlaDefaultHttpManager::~CWmDrmDlaDefaultHttpManager" );

    Stop();

    }

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

// CpHttpManager::Get

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

void CWmDrmDlaDefaultHttpManager::Get(

    const TDesC8& aUrl,

    const RArray<CWmDrmDlaDefaultHttpManager::THeader>& aHeaders)

    {

    LOGFN( "CWmDrmDlaDefaultHttpManager::Get" );

    // Disallow clients to call this method before it has completed asynch

    // request

    ASSERT( !iTransactionOpen );

    iOperation = EGet;

    iDataSupplier = NULL;

    TRAPD( err, DoStartL( aUrl, aHeaders ) );

    if ( err )

        {

        HandleDownloadComplete( err );

        }

    }

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

// CpHttpManager::Post

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

void CWmDrmDlaDefaultHttpManager::Post(

    const TDesC8& aUrl,

    const RArray<CWmDrmDlaDefaultHttpManager::THeader>& aHeaders,

    MHTTPDataSupplier* aDataSupplier )

    {

    LOGFN( "CWmDrmDlaDefaultHttpManager::Post" );

    // Disallow clients to call this method before it has completed asynch

    // request

    ASSERT( !iTransactionOpen );

    ASSERT( aDataSupplier );

    iOperation = EPost;

    iDataSupplier = aDataSupplier;

    TRAPD( err, DoStartL( aUrl, aHeaders ) );

    if ( err )

        {

        HandleDownloadComplete( err );

        }

    }

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

// CWmDrmDlaDefaultHttpManager::Stop

// This method should be used instead of Cancel.

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

void CWmDrmDlaDefaultHttpManager::Stop()

    {

    LOGFN( "CWmDrmDlaDefaultHttpManager::Stop" );

    // Make sure Stop was not called from a callback

    ASSERT( !iInCallback );

    if ( IsActive() )

        {

        // We are still establishing the connection, cancel the active object

        Cancel();

        }

    else

        {

        // The active object is not active - we are past the setup phase

        if ( iTransactionOpen )

            {

            iHttpTransaction.Cancel();

            // Only generate the callback if there was a transaction going on,

            // otherwise the client will get a callback without previously

            // calling StartL

            HandleDownloadComplete( KErrCancel );

            }

        }

	// Close the HTTP session in use

    iHttpSession.Close();

    CleanupConnection();

    DeleteUsernamePassword();

    iState = EConstructed;

    }

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

// CWmDrmDlaDefaultHttpManager::MoreDataAvailableL

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

void CWmDrmDlaDefaultHttpManager::MoreDataAvailableL()

    {

    LOGFN( "CWmDrmDlaDefaultHttpManager::MoreDataAvailableL" );

    iHttpTransaction.NotifyNewRequestBodyPartL();

    }

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

// CWmDrmDlaDefaultHttpManager::SetKeepAlive

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

void CWmDrmDlaDefaultHttpManager::SetKeepAlive( TBool aKeepAlive )

    {

    LOGFN( "CWmDrmDlaDefaultHttpManager::SetKeepAlive" );

    iKeepAlive = aKeepAlive;

    }

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

// CWmDrmDlaDefaultHttpManager::KeepAlive

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

TBool CWmDrmDlaDefaultHttpManager::KeepAlive() const

    {

    LOGFN( "CWmDrmDlaDefaultHttpManager::KeepAlive" );

    return iKeepAlive;

    }

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

// CWmDrmDlaDefaultHttpManager::GetConnectionInfoL

// Note: TConnectionInfo& aConnectionInfo creates a PC-Lint warning to make it

// const but aConnectionInfo is being changed after it has been put into a

// package and GetConnectionInfo is called on the connection

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

void CWmDrmDlaDefaultHttpManager::GetConnectionInfoL(

    TConnectionInfo& aConnectionInfo )

    {

    LOGFN( "CWmDrmDlaDefaultHttpManager::GetConnectionInfoL" );

    if ( (iState != EOpen) && (iState != ESubmit) )

        {

        User::Leave( KErrNotReady );

        }

    TUint count( 0 );

    User::LeaveIfError( iConnection.EnumerateConnections( count ) );

    if ( !count )

        {

        User::Leave( KErrNotReady );

        }

    TPckg<TConnectionInfo> pkg( aConnectionInfo );

    User::LeaveIfError( iConnection.GetConnectionInfo( 1, pkg ) );

    }

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

// CWmDrmDlaDefaultHttpManager::SetIapId

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

void CWmDrmDlaDefaultHttpManager::SetIapId( TInt aIapId )

    {

    LOGFN( "CWmDrmDlaDefaultHttpManager::SetIapId" );

    iIapNumber = aIapId;

    }

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

// CWmDrmDlaDefaultHttpManager::IapId

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

TInt CWmDrmDlaDefaultHttpManager::IapId()

    {

    return iIapNumber;

    }

// ============================== PRIVATE METHODS ==============================

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

// CWmDrmDlaDefaultHttpManager::MHFRunL

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

void CWmDrmDlaDefaultHttpManager::MHFRunL(

    RHTTPTransaction aTransaction,

    const THTTPEvent& aEvent )

    {

    LOGFN( "CWmDrmDlaDefaultHttpManager::MHFRunL" );

    RHTTPResponse response;

    TPtrC8 dataChunk;

    // Either ESucceeded or EFailed will eventually occur

    switch ( aEvent.iStatus )

        {

        case THTTPEvent::EGotResponseHeaders:

            response = aTransaction.Response();

            iInCallback = ETrue;

            iObserver.OnResponseHeadersL(

                response,

                response.GetHeaderCollection(),

                iHttpSession.StringPool(),

                response.StatusCode() );

            break;

        case THTTPEvent::EGotResponseBodyData:

            // A member variable is used to store the body to avoid two

            // potential problems:

            // - OnResponseBodyDataL leaves

            // - Stop is called from within OnResponseBodyDataL

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

            User::LeaveIfNull( iBody );

            iBody->GetNextDataPart( dataChunk );

            iInCallback = ETrue;

            iObserver.OnResponseBodyDataL( dataChunk );

            // Verify that iBody wasn't already released

            // for example by calling Stop within ResponseBodyDataL

            if ( iBody )

                {

                iBody->ReleaseData();

                iBody = NULL;

                }

            break;

        case THTTPEvent::ESucceeded:

        case THTTPEvent::EFailed:

            // Deal with both the same as iError will either be negative or

            // KErrNone

            // If the user cancelled the credentials dialog then make sure we

            // return KErrCancel

            HandleDownloadComplete( iCredentialsOk ? iError : KErrCancel );

            break;

        default:

            // This will capture system and HTTP lib errors

            // For positive codes iError will remain to KErrNone

            if ( aEvent.iStatus < KErrNone )

                {

                iError = aEvent.iStatus;

                }

            break;

        }

    iInCallback = EFalse;

    }

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

// CWmDrmDlaDefaultHttpManager::MHFRunError

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

TInt CWmDrmDlaDefaultHttpManager::MHFRunError(

    TInt aError,

    RHTTPTransaction /*aTransaction*/,

    const THTTPEvent& /*aEvent*/ )

    {

    LOGFN( "CWmDrmDlaDefaultHttpManager::MHFRunError" );

    HandleDownloadComplete( aError );

    return KErrNone;

    }

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

// CWmDrmDlaDefaultHttpManager::GetCredentialsL

// This function is NOT currently used as authentication is not current used in

// this project at the current time

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

TBool CWmDrmDlaDefaultHttpManager::GetCredentialsL(

    const TUriC8& /*aURI*/,

    RString aRealm,

    RStringF aAuthenticationType,

    RString& aUsername,

    RString& aPassword )

    {

    LOGFN( "CWmDrmDlaDefaultHttpManager::GetCredentialsL" );

    iCredentialsOk = EFalse;

    RStringPool pool = aRealm.Pool();

    if ( aAuthenticationType == HTTP_STRING( HTTP::EBasic ) )

        {

        DeleteUsernamePassword();

        // Get the username/password

        iInCallback = ETrue;

        iCredentialsOk =

            iObserver.OnGetUsernamePasswordL( iUsername, iPassword );

        iInCallback = EFalse;

        // authentication = iCredentialsOk && iUsername && iPassword

        // no authentication = !iCredentialsOk && !iUsername && !iPassword

        ASSERT( (iCredentialsOk && iUsername && iPassword) ||

            (!iCredentialsOk && !iUsername && !iPassword ) );

        if (iCredentialsOk)

            {

            aUsername = pool.OpenStringL( *iUsername );

            aPassword = pool.OpenStringL( *iPassword );

            }

        }

    // If the authentication type is not Basic, we simply return EFalse.

    return iCredentialsOk;

    }

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

// CWmDrmDlaDefaultHttpManager::RunL

// Overrides CActive::RunL

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

void CWmDrmDlaDefaultHttpManager::RunL()

    {

    LOGFN( "CWmDrmDlaDefaultHttpManager::RunL" );

    TInt error( iStatus.Int() );

    LOG3( "CWmDrmDlaDefaultHttpManager State: %d Status: %d", iState, error );

    if ( iState == EOpen && error == KErrNotFound )

        {

        iState=EOpenFailed;

        }

    else

        {

        User::LeaveIfError( error );

        }

    switch (iState)

        {

        case EStart:

            InitializeL();

            break;

        case EInitialize:

            OpenL();

            break;

        case EOpenFailed: // Called only if open fails

            ReconnectL();

            break;

        case EReconnect:

            iState=EOpen;

            // Note: intentionally no break

            // Successfully completed EReconnect is same as EOpen.

        case EOpen:

            SubmitL();

            break;

        default:

            // Panic if called while in ESubmit

            ASSERT( 0 );

            break;

        }

    // Do not advance the state if the transaction was submitted

    // MHFRunL will be called by the HTTP stack while the transaction

    // progresses

    if ( iState != ESubmit )

        {

        // Go to the next state if not finished

        CompleteSelf();

        }

    }

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

// CWmDrmDlaDefaultHttpManager::DoCancel

// Called while the state machine is still active. Possible states:

//

//  - EStart and EInitialize: iStatus is already completed and CActive::Cancel

//    will not block

//  - ESubmit: this method won't be called since the AO is not active.

//  - EOpen: RConnection::Close will be called from CleanupTransaction,

//    which will complete the RConnection::Start asynchronous call.

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

void CWmDrmDlaDefaultHttpManager::DoCancel()

    {

    LOGFN( "CWmDrmDlaDefaultHttpManager::DoCancel" );

    ASSERT( iState != ESubmit );

    // Cleanup and generate the callback

    HandleDownloadComplete( KErrCancel );

    }

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

// CWmDrmDlaDefaultHttpManager::RunError

// Overrides CActive::RunError

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

TInt CWmDrmDlaDefaultHttpManager::RunError( TInt aError )

    {

    LOGFN( "CWmDrmDlaDefaultHttpManager::RunError" );

    LOG2( "aError: %d", aError );

    // Cleanup and generate the callback

    HandleDownloadComplete( aError );

    return KErrNone;

    }

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

// CpHttpManager::CWmDrmDlaDefaultHttpManager

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

CWmDrmDlaDefaultHttpManager::CWmDrmDlaDefaultHttpManager(

    MWmDrmDlaDefaltHttpManagerObserver& aObserver,

    TUint32 aIapNumber ) :

    CActive( CActive::EPriorityStandard ),

    iObserver( aObserver ),

    iState( EConstructed ),

    iIapNumber( aIapNumber ),

    iKeepAlive( EFalse )

    {

    LOGFN( "CWmDrmDlaDefaultHttpManager::CWmDrmDlaDefaultHttpManager" );

    CActiveScheduler::Add( this );

    }

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

// CpHttpManager::ConstructL

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

void CWmDrmDlaDefaultHttpManager::ConstructL()

    {

    LOGFN( "CWmDrmDlaDefaultHttpManager::ConstructL" );

    }

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

// CWmDrmDlaDefaultHttpManager::InitializeL

// Handler for the EStart state.

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

void CWmDrmDlaDefaultHttpManager::InitializeL()

    {

    LOGFN( "CWmDrmDlaDefaultHttpManager::InitializeL" );

    User::LeaveIfError( iSocketServer.Connect() );

    User::LeaveIfError( iConnection.Open( iSocketServer, KAfInet ) );

    iState = EInitialize;

    }

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

// CWmDrmDlaDefaultHttpManager::OpenL

// Handler for the EInitialize state.

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

void CWmDrmDlaDefaultHttpManager::OpenL()

    {

    LOGFN( "CWmDrmDlaDefaultHttpManager::OpenL" );

    // Override dialog preferences

    // Use if IAP is provided, override the default one

    if ( iIapNumber )

        {

        iExtPrefs.SetNoteBehaviour(

            TExtendedConnPref::ENoteBehaviourConnSilent );

        iExtPrefs.SetIapId( iIapNumber );

        }

    else

        {

        iExtPrefs.SetSnapPurpose( CMManager::ESnapPurposeInternet );

        iExtPrefs.SetNoteBehaviour(

            TExtendedConnPref::ENoteBehaviourDefault );

        }

    iPrefList.AppendL( &iExtPrefs );

    iConnection.Start( iPrefList, iStatus );

    SetActive();

    LOG1( "CWmDrmDlaDefaultHttpManager::OpenL - Socket connection started" );