/*

* Copyright (c) 2002-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:  Roap engine

 *

*/

// INCLUDE FILES

#include <random.h>

#include <DocumentHandler.h>

#ifdef RD_MULTIPLE_DRIVE

#include  <pathinfo.h>

#include  <driveinfo.h>

#else

#include  <pathinfo.h>

#endif

#ifndef __WINS__

#include <etelmm.h>

#include <mmtsy_names.h>

#endif

#include <flogger.h>

#include <x509cert.h>

#include <x509certext.h>

#include <hash.h>

#include <utf.h>

#include <asn1dec.h>

#include <centralrepository.h>

#include <e32base.h>  // CleanupResetAndDestroyPushL dependencies

#include "cleanupresetanddestroy.h" // CleanupResetAndDestroyPushL

#include "DRMRights.h"

#include "RoapEng.h"

#include "RoapTrigger.h"

#include "wbxmlroaptriggerparser.h"

#include "RoapResponse.h"

#include "RoapMessage.h"

#include "RoapParser.h"

#include "RoapSigner.h"

#include "DeviceHello.h"

#include "RIHello.h"

#include "RegistrationReq.h"

#include "RegistrationResp.h"

#include "RightsReq.h"

#include "RightsResp.h"

#include "JoinDomainReq.h"

#include "JoinDomainResp.h"

#include "LeaveDomainReq.h"

#include "LeaveDomainResp.h"

#ifdef RD_DRM_METERING

#include "MeteringReportReq.h"

#include "MeteringReportResp.h"

#endif

#include "RoapStorageClient.h"

#include "RoapDef.h"

#include "RoapLog.h"

#include "RoapObserver.h"

#include "CmlaCrypto.h"

#include "DRMRIContext.h"

#include "DRMDomainContext.h"

#include "DRMProtectedRoParser.h"

#include "DRMClockClient.h"

#include "DcfRep.h"

#include "DcfEntry.h"

#include "Base64.h"

#include "drmsettingsplugininternalcrkeys.h"

#define STUB_C_CLASS_IN_NAMESPACE( n, c ) namespace n { class c: public CBase { private: c(); public: virtual ~c(); }; } n::c::c() {} n::c::~c() {}

#define STUB_C_CLASS( c ) class c : public CBase { private: c(); public: virtual ~c(); }; c::c() {} c::~c() {}

// This class does not do anything.

// It is defined here only to keep binary compatibility,

// because of unintentional class name leak in

// armv5 export history.

// Don't ever use this class for anything.

STUB_C_CLASS_IN_NAMESPACE( Roap , CWbxmlRoapTriggerToXmlParser )

// Yet another stub classes because of moved classes

// which have leaked virtual table entries

STUB_C_CLASS( COCSPResponse )

STUB_C_CLASS( COCSPResponseCertInfo )

using namespace Roap;

// ================= CONSTANTS =======================

// For parsing multipart content

_LIT8(KCmlaIp1, "http://www.cm-la.com/tech/cmlaip/cmlaip#cmlaip-1");

_LIT8(KLeaveDomainElement, "leaveDomain");

_LIT8(KSignedInfoElement, "SignedInfo");

_LIT(KBOM1, "\xFFFE");

_LIT(KBOM2, "\xFEFF");

#ifdef RD_DRM_METERING

_LIT8( KRoapVersion11, "1.1" );

#endif

static const TInt KDomainGenerationLength( 3 );

static const TInt KMinCertChainLength( 3 );

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

LOCAL_C TBool SortArrays(

    RPointerArray<HBufC8>& aKeys,

    RPointerArray<HBufC8>& aMacs,

    RPointerArray<HBufC8>& aElements,

    RArray<TInt>& aOrder )

    {

    TInt i;

    TInt j;

    TInt index;

    HBufC8* temp1 = NULL;

    HBufC8* temp2 = NULL;

    HBufC8* temp3 = NULL;

    TBool isInOrder = ETrue;

    if ( aOrder.Count() != aKeys.Count() || aKeys.Count() != aMacs.Count()

        || aMacs.Count() != aElements.Count() )

        {

        return EFalse;

        }

    for ( i = 0; i < aKeys.Count(); i++ )

        {

        index = aOrder[i];

        temp1 = aKeys[i];

        temp2 = aMacs[i];

        temp3 = aElements[i];

        j = i;

        while ( ( j > 0 ) && ( aOrder[j - 1] > index ) )

            {

            isInOrder = EFalse;

            aOrder[j] = aOrder[j - 1];

            aKeys[j] = aKeys[j - 1];

            aMacs[j] = aMacs[j - 1];

            aElements[j] = aElements[j - 1];

            j = j - 1;

            }

        aOrder[j] = index;

        aKeys[j] = temp1;

        aMacs[j] = temp2;

        aElements[j] = temp3;

        }

    return isInOrder;

    }

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

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

// CRoapEng::NewL()

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

//

EXPORT_C CRoapEng* CRoapEng::NewL()

    {

    CRoapEng* engine = new ( ELeave ) CRoapEng();

    CleanupStack::PushL( engine );

    engine->ConstructL();

    CleanupStack::Pop( engine );

    return engine;

    }

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

// CRoapEng::~CRoapEng()

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

//

EXPORT_C CRoapEng::~CRoapEng()

    {

    if ( iStorageClient )

        {

        iStorageClient->Close();

        }

    delete iStorageClient;

    if ( iClockClient )

        {

        iClockClient->Close();

        }

    delete iClockClient;

    delete iParser;

    delete iSigner;

    delete iDeviceId;

    delete iRoParser;

    delete iDcfRep;

    iRiAlgorithms.ResetAndDestroy();

    }

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

// CRoapEng::~CRoapEng()

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

//

void CRoapEng::ConstructL()

    {

    LOGLIT( "CRoapEng::ConstructL" )

    CRoapEngBase::ConstructL();

    iParser = CRoapParser::NewL();

    iStorageClient = new ( ELeave ) RRoapStorageClient;

    User::LeaveIfError( iStorageClient->Connect() );

    iClockClient = new ( ELeave ) RDRMClockClient;

    User::LeaveIfError( iClockClient->Connect() );

    TBuf8<SHA1_HASH> deviceId;

    iStorageClient->GetDevicePublicKeyHashL( deviceId );

    iDeviceId = deviceId.AllocL();

    iSigner = CRoapSigner::NewL( *iStorageClient );

    iRoParser = CDrmProtectedRoParser::NewL();

    iDcfRep = CDcfRep::NewL();

    iCertNeeded = ETrue;

    iRiSupportsCertCaching = EFalse;

    iTransStatus = ENotAsked;

    iSelectedAlgorithms = EOma;

    iSelectedRoot = KNullDesC8;

    iStorageClient->SelectTrustedRootL( KNullDesC8 );

    iDeviceTimeError = EFalse;

    iDomainId.SetLength( 0 );

    iSecureTime = ETrue;

    iZone = 0;

    }

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

// CRoapEng::CRoapEng()

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

//

CRoapEng::CRoapEng() :

    CRoapEngBase()

    {

    }

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

// CRoapEng::ParseTriggerL()

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

//

CRoapTrigger* CRoapEng::ParseTriggerL( const TDesC8& aTrigger )

    {

    LOGLIT( "CRoapEng::ParseTriggerL" )

    CRoapTrigger* trigger( NULL );

    RBuf8 xmlTrigger;

    CleanupClosePushL( xmlTrigger );

    _LIT8( KRoap, "<roap:roapTrigger" );

    if ( aTrigger.FindF( KRoap ) == KErrNotFound )

        {

        DRM::CWbxmlRoapTriggerParser* wbParser(

            DRM::CWbxmlRoapTriggerParser::NewLC() );

        HBufC8* b( NULL );

        TRAPD( parseError, b = wbParser->ParseL( aTrigger ) );

        if ( parseError == KErrNone )

            {

            xmlTrigger.Assign( b );

            b = NULL;

            LOGLIT( "  We have a WBXML trigger" )

            }

        else

            { // OMA BCAST: Check if this is an XML trigger after all..

            LOGLIT( "  We have an XML trigger after all" )

            xmlTrigger.CreateL( aTrigger );

            }

        CleanupStack::PopAndDestroy( wbParser );

        }

    else

        {

        xmlTrigger.CreateL( aTrigger );

        }

    trigger = iParser->ParseRoapTriggerL( xmlTrigger );

    CleanupStack::PushL( trigger );

    if ( !trigger || !trigger->ValidTrigger() )

        {

        User::Leave( KErrRoapGeneral );

        }

    // check that SilentRightsUrl is on the white list

    // URL is searched from pre-configured white list

    TBool fromPreConfiguredWhiteList( ETrue );

    if ( iStorageClient->WhiteListURLExistsL( *trigger->iRoapUrl, fromPreConfiguredWhiteList ) )

        {

        iAllowedToContactRi = ETrue;

        }

    if ( trigger->iTriggerType == ELeaveDomainTrigger && trigger->iSignature )

        {

        if ( !VerifyTriggerSignatureL( xmlTrigger, *trigger ) )

            {

            User::Leave( KErrRoapServerFatal );

            }

        }

    CleanupStack::Pop( trigger );

    CleanupStack::PopAndDestroy( &xmlTrigger );

    return trigger;

    }

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

// CRoapEng::GetRIContextL()

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

//

void CRoapEng::GetRIContextL( TBool& aRegistered, const TDesC8& aRiId )

    {

    LOGLIT( "CRoapEng::GetRIContextL" )

    CDRMRIContext* context = NULL;

    aRegistered = EFalse;

    // delete old RI context and obtain a new one

    delete iStoredRiContext;

    iStoredRiContext = NULL;

    context = iStorageClient->GetRIContextL( aRiId );

    if ( !context )

        {

        return;

        }

    iStoredRiContext = context;

    iRiSupportsCertCaching = iStoredRiContext->DeviceCertCached();

    iSelectedRoot = iStoredRiContext->SelectedDeviceRoot();

    iStorageClient->SelectTrustedRootL( iSelectedRoot );

    if ( context->CertificateChain().Count() && context->ExpiryTime()

        > GetDrmTimeL() )

        {

        aRegistered = ETrue;

        iUseRiContextUrl = EFalse;

        }

    else

        {

        // Received Context was invalid or expired

        iUseRiContextUrl = EFalse;

        delete iStoredRiContext;

        iStoredRiContext = NULL;

        }

    }

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

// CRoapEng::GetDomainContextL()

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

//

void CRoapEng::GetDomainContextL(

    TBool& aIsJoined,

    TBool& aIsValidGeneration,

    const TDesC8& aDomainId )

    {

    LOGLIT( "CRoapEng::GetDomainContextL" )

    TInt generation = 0;

    CDRMDomainContext* context = NULL;

    aIsJoined = EFalse;

    aIsValidGeneration = EFalse;

    // last 3 digits are for Domain generation

    context = iStorageClient->GetDomainContextL( aDomainId );

    if ( !context )

        {

        return;

        }

    if ( context->ExpiryTime() > GetDrmTimeL() || context->ExpiryTime()

        == Time::NullTTime() )

        {

        aIsJoined = ETrue;

        }

    TLex8 lex( aDomainId.Right( KDomainGenerationLength ) );

    lex.Val( generation );

    if ( context->DomainGeneration() >= generation )

        {

        aIsValidGeneration = ETrue;

        }

    delete context;

    }

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

// CRoapEng::CreateReqMessageL()

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

//

void CRoapEng::CreateReqMessageL()

    {

    LOGLIT( "CRoapEng::CreateReqMessageL" )

    __ASSERT_ALWAYS( iTrigger, User::Invariant() );

    __ASSERT_ALWAYS( !iRequest, User::Invariant() );

    switch ( iReqMessage )

        {

        case EDeviceHello:

            {

            iRequest = CreateDeviceHelloL();

            break;

            }

        case ERegistration:

            {

            iRequest = CreateRegistrationRequestL();

            break;

            }

        case EROAcquisition:

            {

            iRequest = CreateRightsRequestL();

            break;

            }

        case EJoinDomain:

            {

            iRequest = CreateJoinDomainRequestL();

            break;

            }

        case ELeaveDomain:

            {

            iRequest = CreateLeaveDomainRequestL();

            break;

            }

#ifdef RD_DRM_METERING

        case EMeteringRequest:

            {

            iRequest = CreateMeteringReportRequestL();

            break;

            }

#endif

        default:

            {

            User::Leave( KErrArgument );

            }

        }

    }

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

// CRoapEng::CreateDeviceHelloL()

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

//

CRoapMessage* CRoapEng::CreateDeviceHelloL()

    {

    LOGLIT( "CRoapEng::CreateDeviceHelloL" )

    PERFORMANCE_LOGLIT( "Registration protocol started" )

    RPointerArray<TDesC8> idArray;

    CDeviceHello* req = CDeviceHello::NewL();

    CleanupStack::PushL( req );

    // Multi-PKI addition

    CleanupResetAndDestroyPushL( idArray );

    CreateDeviceIdHashArrayL( idArray );

    for ( TInt i = 0; i < idArray.Count(); i++ )

        {

        req->iDeviceIdArray.AppendL( *idArray[i] );

        }

    CleanupStack::PopAndDestroy( &idArray );

    // Multi-PKI

#ifndef RD_DRM_METERING

    req->iVersion.Copy( KRoapVersion ); // Version 1.0

#else

    req->iVersion.Copy( KRoapVersion11 );

#endif

    if ( iTrigger->iNonce )

        {

        req->iTriggerNonce = iTrigger->iNonce->AllocL();

        }

    CmlaCrypto::SupportedAlgorithmsL( req->iAlgorithms );

    iSelectedAlgorithms = EOma;

    CleanupStack::Pop( req );

    return req;

    }

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

// CRoapEng::CreateRegistrationRequestL()

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

//

CRoapMessage* CRoapEng::CreateRegistrationRequestL()

    {

    LOGLIT( "CRoapEng::CreateRegistrationRequestL ->" )

    __ASSERT_ALWAYS( iResponse, User::Invariant() );

    CRegistrationReq* req = NULL;

    CRIHello* resp = NULL;

    RPointerArray<HBufC8> trustedRootArray;

    HBufC8* temp = NULL;

    resp = STATIC_CAST( CRIHello*, iResponse );

    req = CRegistrationReq::NewL();

    CleanupStack::PushL( req );

    if ( resp->iSession )

        {

        req->iSession = resp->iSession->AllocL();

        }

    else

        {

        User::Leave( KErrRoapServerFatal );

        }

    req->iNonce.SetLength( KDeviceNonceLength );

    TRandom::Random( req->iNonce );

    req->iTime = GetDrmTimeL();

    // store the nonce for DRM Time sync

    iRegReqNonce = req->iNonce;

    if ( iCertNeeded )

        {

        req->iCertificateChain = GetCertificateChainL();

        if ( resp->iCertificateCaching )

            {

            iCertNeeded = EFalse;

            }

        }

    // Send all our trusted roots to the RI

    CleanupResetAndDestroyPushL( trustedRootArray );

    LOGLIT( "  Getting trusted roots" )