/*

* 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:  WMDRM DLA Default Http License Acquisition

*

*/

#include <chttpformencoder.h>

#include <httpstringconstants.h>

#include <httperr.h>

#include <http/rhttpheaders.h>

#include <http/thttphdrfielditer.h>

#include <stringpool.h>

#include <escapeutils.h>

#include <wmdrmdlatypes.h>

#include <wmdrmdlauinotifier.h>

#include "asf.h"

#include "wmdrmdladefaultlicacq.h"

#include "wmdrmdladefaulthttpplugin.h"

#include "wmdrmdlabrowserviewhandler.h"

#include "wmdrmdlabrowserobserver.h"

#include "wmdrmdladefaulthttpmanager.h"

#define _LOGGING_FILE L"wmdrmdladefaulthttpplugin.txt"

#include "logfn.h"

// CONSTANTS

_LIT8( KDefaultIdentifier8, "camese" );

_LIT8( KDefaultIdentifier, "c\0a\0m\0e\0s\0e\0" );

_LIT8( KNonSilentIdentifier, "n\0o\0n\0s\0i\0l\0e\0n\0t" );

_LIT8( KAcceptHeader8, "*/*" );

_LIT8( KAcceptLanguageHeader8, "en-us" );

_LIT8( KPostContentTypeHeader8, "application/x-www-form-urlencoded" );

_LIT8( KDataTypeLicenseResponse, "application/vnd.ms-wmdrm.lic-resp" );

_LIT8( KDataTypeHtml, "text/html" );

_LIT8( KGetLicenseChallengeParam8, "challenge" );

_LIT8( KGetNonSilentParam8, "nonsilent" );

_LIT8( KLicenseStatusParam8, "License1Status" );

_LIT8( KTIDHeader8, "TID=" );

_LIT8( KQueryTag8, "?" );

_LIT8( KNonSilentValue, "1" );

_LIT8( KAmpersand, "&" );

_LIT8( KChallenge, "nonsilent=1&challenge=" );

_LIT8( KHRESULTFormat,"0x%08x" );

const TInt KHRESULTFormatLength = 10; // '0x' + %08x

const TUint KHRESULTBase = 0x80000000; 

const TInt KHRESULTErrorMask = 0x01 << 31 | 0x04 << 16;

// ======== LOCAL FUNCTIONS ========

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

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

// CWmDrmDlaDefaultLicAcq::ConstructL

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

//

void CWmDrmDlaDefaultLicAcq::ConstructL()

    {

    LOGFN( "CWmDrmDlaDefaultLicAcq::ConstructL" );

    iHttpManager = CWmDrmDlaDefaultHttpManager::NewL( *this );

    iHttpManager->SetKeepAlive( ETrue );

    iIdle =  CIdle::NewL( CActive::EPriorityIdle );

    }

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

// CWmDrmDlaDefaultLicAcq::CWmDrmDlaDefaultLicAcq

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

//

CWmDrmDlaDefaultLicAcq::CWmDrmDlaDefaultLicAcq(

    CWmDrmDlaDefaultHttpPlugin* aPlugin ) 

    : iState( CWmDrmDlaDefaultLicAcq::ENotActive ), iPlugin( aPlugin )

    {

    LOGFN( "CWmDrmDlaDefaultLicAcq::CWmDrmDlaDefaultLicAcq" );

    }

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

// CWmDrmDlaDefaultLicAcq::NewL

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

//

CWmDrmDlaDefaultLicAcq* CWmDrmDlaDefaultLicAcq::NewL(

    CWmDrmDlaDefaultHttpPlugin* aPlugin )

    {

    LOGFN( "CWmDrmDlaDefaultLicAcq::NewL" );

    CWmDrmDlaDefaultLicAcq* self 

        = new( ELeave ) CWmDrmDlaDefaultLicAcq( aPlugin );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CWmDrmDlaDefaultLicAcq::~CWmDrmDlaDefaultLicAcq

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

//

CWmDrmDlaDefaultLicAcq::~CWmDrmDlaDefaultLicAcq()

    {

    LOGFN( "CWmDrmDlaDefaultLicAcq::~CWmDrmDlaDefaultLicAcq" );

    delete iIdle;

    delete iBrowserViewHandler;

    delete iHttpManager;

    delete iFormEncoder;

    delete iPostData;

    delete iLicenseChallenge;

    delete iLicenseResponse;

    delete iLicenseServerUrl16;

    delete iLicenseServerUrl;

    delete iHtmlData;

    }

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

// CWmDrmDlaDefaultLicAcq::SupportedFileL

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

//

TBool CWmDrmDlaDefaultLicAcq::SupportedFileL( 

    const RFile& aFile,

    CWmDrmDlaUiNotifier*& aUiNotifier)

    {

    TInt err( KErrNone );

    TBool supported( EFalse );

    LOGFNR( "CWmDrmDlaDefaultLicAcq::SupportedFileL", err );

    //Check that the file is valid ASF-file and that the extented content

    //encryption object of the file includes MS test site identifier

    CAsf* asf( NULL );

    TRAP( err, asf = CAsf::NewL( aFile ) );

    if ( !err )

        {

        supported = iPlugin->Supported( *asf->iExtendedContentEncryptionObject,

                                        KDefaultIdentifier );

        delete asf;

        }

    //If file is recognized, then initialize UiNotifier and transfer its

    //ownership to the FW

    if ( supported )

        {

        iPlugin->InitializeUiNotifierL();

        aUiNotifier = iPlugin->UiNotifier();

        }

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

    return supported;

    }

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

// CWmDrmDlaDefaultLicAcq::SupportedDrmHeaderL

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

//

TBool CWmDrmDlaDefaultLicAcq::SupportedDrmHeaderL( 

    const TDesC8& aHeader,

    CWmDrmDlaUiNotifier*& aUiNotifier )

    {

    LOGFN( "CWmDrmDlaDefaultLicAcq::SupportedDrmHeaderL" );

    //Check that the drm header includes MS test site identifier

    TBool supported( iPlugin->Supported( aHeader, KDefaultIdentifier8 ) );

    //If header is recognized, then initialize UiNotifier and transfer its

    //ownership to the FW

    if ( supported )

        {

        iPlugin->InitializeUiNotifierL();

        aUiNotifier = iPlugin->UiNotifier();

        }

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

    return supported;

    }

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

// CWmDrmDlaDefaultLicAcq::SilentL

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

//

TBool CWmDrmDlaDefaultLicAcq::SilentL( 

    const RFile& aFile )

    {

    TInt err( KErrNone );

    LOGFNR( "CWmDrmDlaDefaultLicAcq::SilentL", err );

    //Check is the content silent or not by checking that the extented content

    //encryption object of the file includes MS test site non-silent identifier

    iNonSilent = EFalse;

    CAsf* asf( NULL );

    TRAP( err, asf = CAsf::NewL( aFile ) );

    if ( !err )

        {

        iNonSilent = 

            iPlugin->Supported( *asf->iExtendedContentEncryptionObject,

                                KNonSilentIdentifier );

        delete asf;

        }

    iPlugin->UiNotifier()->SetSilent( !iNonSilent );

    LOG2( "!iNonSilent: %d", !iNonSilent );

    return !iNonSilent;

    }

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

// CWmDrmDlaDefaultLicAcq::ProcessDrmHeaderL

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

//

void CWmDrmDlaDefaultLicAcq::ProcessDrmHeaderL( 

    const TDesC8& /*aDrmHeader*/ )

    {

    LOGFN( "CWmDrmDlaDefaultLicAcq::ProcessDrmHeaderL" );

    iPlugin->UiNotifier()->SetProgress( EProcessingDRMHeader );

    }

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

// CWmDrmDlaDefaultLicAcq::AcquireLicense

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

//

void CWmDrmDlaDefaultLicAcq::AcquireLicense( 

    const TDesC8& aLicenseChallenge,

    HBufC* aLicenseServerUrl,

    TRequestStatus& aStatus )

    {

    TInt err( KErrNone );

    LOGFNR( "CWmDrmDlaDefaultLicAcq::AcquireLicense", err );

    iPlugin->UiNotifier()->SetProgress( ERetrievingLicense );

    aStatus = KRequestPending;

    iClientStatus = &aStatus;

    delete iLicenseServerUrl;

    iLicenseServerUrl = NULL;

    TRAP( err, 

            iLicenseServerUrl = 

                EscapeUtils::ConvertFromUnicodeToUtf8L( *aLicenseServerUrl ) );

    if ( !iLicenseServerUrl )

        {

        CompleteClientRequest( err );

        return;

        }

    delete iLicenseChallenge;

    iLicenseChallenge = NULL;

    iLicenseChallenge = aLicenseChallenge.Alloc();

    if ( !iLicenseChallenge )

        {

        CompleteClientRequest( KErrNoMemory );

        return;

        }

    TRAP( err, AcquireLicenseL() );

    if ( err )

        {

        CompleteClientRequest( err );

        return;

        }

    iState = CWmDrmDlaDefaultLicAcq::ESendingLicenseChallenge;

    }

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

// CWmDrmDlaDefaultLicAcq::GetLicenseResponseL

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

//

HBufC8* CWmDrmDlaDefaultLicAcq::GetLicenseResponseL()

    {

    LOGFN( "CWmDrmDlaDefaultLicAcq::GetLicenseResponseL" );

    iPlugin->UiNotifier()->SetProgress( EAddingLicense );

    if ( iLicenseResponse )

        {

        return iLicenseResponse->AllocL();

        }

    else

        {

        return NULL;

        }

    }

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

// CWmDrmDlaDefaultLicAcq::SendLicenseStorageStatus

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

//

void CWmDrmDlaDefaultLicAcq::SendLicenseStorageStatus( 

    HBufC8* aTid,

    const TDesC& /*aUrl*/,

    TInt aError, 

    TRequestStatus& aStatus )

    {

    TInt err( KErrNone );

    LOGFNR( "CWmDrmDlaDefaultLicAcq::SendLicenseStorageStatus", err );

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

    iPlugin->UiNotifier()->SetProgress( ESendingLicenseStorageStatus );

    aStatus = KRequestPending;

    iClientStatus = &aStatus;

    if ( !aTid )

        {

        CompleteClientRequest( KErrCorrupt );

        return;

        }

    TRAP( err, SendLicenseStorageStatusL( *aTid, aError ) );

    if ( err )

        {

        CompleteClientRequest( err );

        return;

        }

    iState = CWmDrmDlaDefaultLicAcq::ESendingStorageStatus;

    }

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

// CWmDrmDlaDefaultLicAcq::SendDrmHeaderError

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

//

void CWmDrmDlaDefaultLicAcq::SendDrmHeaderError( 

    const TDesC& /*aErrorUrl*/, 

    TInt /*aError*/, 

    TRequestStatus& aStatus )

    {

    LOGFN( "CWmDrmDlaDefaultLicAcq::SendDrmHeaderError" );

    iPlugin->UiNotifier()->SetProgress( ESendingDrmHeaderStatus );

    aStatus = KRequestPending;

    iClientStatus = &aStatus;

    CompleteClientRequest( KErrNotSupported );

    }

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

// CWmDrmDlaDefaultLicAcq::GetContentUrlL

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

//

HBufC* CWmDrmDlaDefaultLicAcq::GetContentUrlL()

    {

    LOGFN( "CWmDrmDlaDefaultLicAcq::GetContentUrlL" );

    return NULL;

    }

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

// CWmDrmDlaDefaultLicAcq::GetHtmlDataL

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

//

HBufC* CWmDrmDlaDefaultLicAcq::GetHtmlDataL()

    {

    LOGFN( "CWmDrmDlaDefaultLicAcq::GetHtmlDataL" );

    iPlugin->UiNotifier()->SetProgress( EIdle );

    if ( iHtmlData )

        {

        return iHtmlData->AllocL();

        }

    else

        {

        return NULL;

        }

    }

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

// CWmDrmDlaDefaultLicAcq::CancelLicenseAcquisition

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

//

void CWmDrmDlaDefaultLicAcq::CancelLicenseAcquisition()

    {

    LOGFN( "CWmDrmDlaDefaultLicAcq::CancelLicenseAcquisition" );

    iHttpManager->Stop();

    CompleteClientRequest( KErrCancel );

    }

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

// CWmDrmDlaDefaultHttpPlugin::SetIapId

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

//

void CWmDrmDlaDefaultLicAcq::SetIapId( TInt aIapId )

    {

    LOGFN( "CWmDrmDlaDefaultLicAcq::SetIapId" );

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

    iHttpManager->SetIapId( aIapId );

    }

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

// CWmDrmDlaDefaultLicAcq::OnGetUsernamePasswordL

// From MHttpManagerObserver

// This function is called when using HTTPS authentication. Authentication is 

// not currently used in the Camese project

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

//

TBool CWmDrmDlaDefaultLicAcq::OnGetUsernamePasswordL(

    HBufC8*& /*aUsername*/,

    HBufC8*& /*aPassword*/)

    {

    LOGFN( "CWmDrmDlaDefaultLicAcq::OnGetUsernamePasswordL" );

    return EFalse;

    }

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

// CWmDrmDlaDefaultLicAcq::OnResponseHeadersL

// From MHttpManagerObserver

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

//

void CWmDrmDlaDefaultLicAcq::OnResponseHeadersL(

    const RHTTPResponse& /*aResponse*/,

    const RHTTPHeaders& aHeaders,

    const RStringPool& aStringPool,

    TInt aHttpStatus )

    {

    LOGFN( "CWmDrmDlaDefaultLicAcq::OnResponseHeadersL" );

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

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

    //Redirection in license acquisition

    if ( aHttpStatus >= HTTPStatus::EMultipleChoices && 

         aHttpStatus < HTTPStatus::EBadRequest &&

         iState == CWmDrmDlaDefaultLicAcq::ESendingLicenseChallenge )

        {

        HandleRedirectionHeadersL( aHeaders, aStringPool );

        }

    //License acquisition

    else if ( aHttpStatus == HTTPStatus::EOk &&

              iState != CWmDrmDlaDefaultLicAcq::ESendingStorageStatus )

        {

        HandleLicenseAcquistionHeaders( aHeaders, aStringPool );

        }

    //Sending license storage status or error

    else

        {

        iHttpStatus = aHttpStatus;

        }

    }

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

// CWmDrmDlaDefaultLicAcq::OnResponseBodyDataL

// From MHttpManagerObserver

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

//

void CWmDrmDlaDefaultLicAcq::OnResponseBodyDataL( const TPtrC8 aDataChunk )

    {

    LOGFN( "CWmDrmDlaDefaultLicAcq::OnResponseBodyDataL" );

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

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

    //If we are acquiring license and response headers are OK,

    //then save the response.

    if ( iHttpStatus == HTTPStatus::EOk && 

         iState == CWmDrmDlaDefaultLicAcq::ESendingLicenseChallenge )

        {

        if ( !iLicenseResponse )

            {

            iLicenseResponse = HBufC8::NewL( aDataChunk.Length() );

            }

        else

            {

            iLicenseResponse = 

                iLicenseResponse->ReAllocL( iLicenseResponse->Length() + 

                                            aDataChunk.Length() );

            }

        iLicenseResponse->Des().Append( aDataChunk );

        }

    }

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

// CWmDrmDlaDefaultLicAcq::OnTransactionComplete

// From MHttpManagerObserver

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

//

void CWmDrmDlaDefaultLicAcq::OnTransactionComplete( TInt aSystemError )

    {

    LOGFN( "CWmDrmDlaDefaultLicAcq::OnTransactionComplete" );

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

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

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

    TInt err( KErrNone );

    //Transaction succeeded

    if ( iHttpStatus == HTTPStatus::EOk && !aSystemError )

        {

        //If redirection happened, then start a new license acquisition

        //asynchronously to a new location.

        if ( iState == CWmDrmDlaDefaultLicAcq::ERedirection )

            {

            TCallBack callBack( CWmDrmDlaDefaultLicAcq::Redirection, 

                                this );

            iIdle->Start( callBack );

            iState = CWmDrmDlaDefaultLicAcq::ESendingLicenseChallenge;

            }

        //If license acquisition is non-silent, then launch a browser view.

        else if ( iState == 

                        CWmDrmDlaDefaultLicAcq::ENonSilentLicenseAcquisition )

            {

            TRAP( err, LaunchBrowserViewL() );

            if ( err )

                {

                CompleteClientRequest( err );

                return;

                }

            iPlugin->UiNotifier()->SetProgress( EIdle );

            iState = CWmDrmDlaDefaultLicAcq::EBrowserView;

            }

        //License received silently or license storage status sent succesfully.

        else 

            {

            CompleteClientRequest( aSystemError );

            }

        }

    //Error in transaction

    else if ( iHttpStatus != HTTPStatus::EOk && 

              iHttpStatus != KErrNone )

        {

        CompleteClientRequest( KErrCommsBreak );

        }

    //System error

    else

        {

        CompleteClientRequest( aSystemError );

        }

    }

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

// CWmDrmDlaDefaultLicAcq::CompleteClientRequest

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

//

void CWmDrmDlaDefaultLicAcq::CompleteClientRequest( TInt aError )

    {

    LOGFN( "CWmDrmDlaDefaultLicAcq::CompleteClientRequest" );