/*
* 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:  Client Class of ROAP Storage Server
*
*/


// INCLUDE FILES
#include <e32std.h>
#include <f32file.h>
#include <s32file.h>
#include <x509cert.h>
#include <x509keys.h>
#include <asn1dec.h>
#include <hash.h>
#include <s32mem.h>
#include <e32base.h>  // CleanupResetAndDestroyPushL dependencies
#include "OmaCrypto.h"
#include "RoapStorageClient.h"
#include "DRMRIContext.h"
#include "DRMDomainContext.h"
#include "drmroapclientserver.h"
#include "DRMRightsClient.h"
#include "cleanupresetanddestroy.h" // CleanupResetAndDestroyPushL
// LOCAL CONSTANTS AND MACROS

LOCAL_C const TInt KMaxMessageSlots = 4;
const TInt KMaxElementLength = 327680;

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

// -----------------------------------------------------------------------------
// ArrayToBuffer
// Created buffer will contain <amount of elements:int32, data1, data2 ...>
// -----------------------------------------------------------------------------
//
LOCAL_C HBufC8* ArrayToBufferLC( const RPointerArray<HBufC8>& aArray )
    {
    HBufC8* buffer = NULL;
    TInt32 sizeOfElements = 0;

    for ( TInt i = 0; i < aArray.Count(); i++ )
        {
        // sizeof(TInt) is for element length info
        sizeOfElements += aArray[i]->Length() + sizeof(TInt);
        }

    // length of elements + amount of elements
    sizeOfElements += sizeof(TInt32);

    buffer = HBufC8::NewMaxLC( sizeOfElements );

    RMemWriteStream stream( (TAny*)( buffer->Ptr() ), sizeOfElements );
    CleanupClosePushL( stream );

    stream.WriteInt32L( aArray.Count() );

    for ( TInt i = 0; i < aArray.Count(); i++ )
        {
        stream << *aArray[i];
        }

    CleanupStack::PopAndDestroy( &stream );

    return buffer;
    }

// -----------------------------------------------------------------------------
// BufferToArrayL
// Created buffer will contain <amount of elements:int32, element data1, element data2...>
// -----------------------------------------------------------------------------
//
LOCAL_C RPointerArray<HBufC8> BufferToArrayL( TDesC8& aBuffer )
    {
    TInt32 count = 0;
    HBufC8* element = NULL;
    RPointerArray<HBufC8> array;
    TInt size = aBuffer.Size();
    RMemReadStream stream( (TAny*)( aBuffer.Ptr() ), size );
    CleanupClosePushL( stream );

    CleanupResetAndDestroyPushL( array );

    // amount of elements
    count = stream.ReadInt32L();

    // for each in RPointerArray
    for ( TInt i = 0; i < count; i++ )
        {
        // Read the element and append it to array
        element = HBufC8::NewLC( stream, KMaxElementLength );
        array.AppendL( element );
        CleanupStack::Pop( element );
        }

    CleanupStack::Pop( &array );
    CleanupStack::PopAndDestroy( &stream );

    return array;
    }

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

// -----------------------------------------------------------------------------
// RoapStorageClient::RoapStorageClient
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
EXPORT_C Roap::RRoapStorageClient::RRoapStorageClient()
    {
    }

// -----------------------------------------------------------------------------
// RRoapStorageClient::~RRoapStorageClient()
// -----------------------------------------------------------------------------
//
EXPORT_C Roap::RRoapStorageClient::~RRoapStorageClient()
    {
    }

// -----------------------------------------------------------------------------
// RoapStorageClient::Connect
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C TInt Roap::RRoapStorageClient::Connect()
    {
    TInt ret( KErrNone );

    const TVersion requiredVersion( Roap::KServerMajorVersion,
        Roap::KServerMinorVersion, Roap::KServerBuildVersion );

    RDRMRightsClient::StartServer();

    ret = CreateSession( KServerName, requiredVersion, KMaxMessageSlots );
    return ret;
    }

// -----------------------------------------------------------------------------
// RoapStorageClient::GetDevicePublicKeyL
// -----------------------------------------------------------------------------
//
EXPORT_C TInt Roap::RRoapStorageClient::GetDevicePublicKeyL(
    CRSAPublicKey*& aPublicKey )
    {
    HBufC8* publicKeyDer( NULL );
    CX509SubjectPublicKeyInfo* publicKeyInfo( NULL );
    TX509KeyFactory factory;

    GetDevicePublicKeyDerL( publicKeyDer );
    CleanupStack::PushL( publicKeyDer );
    publicKeyInfo = CX509SubjectPublicKeyInfo::NewLC( *publicKeyDer );
    aPublicKey = factory.RSAPublicKeyL( publicKeyInfo->KeyData() );

    CleanupStack::PopAndDestroy( publicKeyInfo );
    CleanupStack::PopAndDestroy( publicKeyDer );
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// RoapStorageClient::GetDevicePublicKeyDerL
// -----------------------------------------------------------------------------
//
EXPORT_C TInt Roap::RRoapStorageClient::GetDevicePublicKeyDerL(
    HBufC8*& aPublicKey )
    {
    TInt size = 0;
    TInt error = KErrNone;
    TPckg<TInt> package( size );

    error = SendReceive( Roap::EGetPublicKey, TIpcArgs( &package ) );

    User::LeaveIfError( error );

    HBufC8* publicKey( HBufC8::NewMaxLC( size ) );
    TPtr8 objectPkg( const_cast<TUint8*> ( publicKey->Ptr() ), size, size );

    User::LeaveIfError( SendReceive( Roap::EGetData, TIpcArgs( &objectPkg ) ) );

    CleanupStack::Pop( publicKey );
    aPublicKey = publicKey;
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// RoapStorageClient::GetDevicePublicKeyHashL
// -----------------------------------------------------------------------------
//
EXPORT_C TInt Roap::RRoapStorageClient::GetDevicePublicKeyHashL( TDes8& aHash )
    {
    CSHA1* hash = NULL;
    HBufC8* key = NULL;

    GetDevicePublicKeyDerL( key );
    CleanupStack::PushL( key );
    hash = CSHA1::NewL();
    CleanupStack::PushL( hash );
    hash->Hash( *key );
    aHash.Copy( hash->Final() );
    CleanupStack::PopAndDestroy( hash );
    CleanupStack::PopAndDestroy( key );
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// RoapStorageClient::GetDeviceCertificateChainL
// -----------------------------------------------------------------------------
//
EXPORT_C TInt Roap::RRoapStorageClient::GetDeviceCertificateChainL(
    RPointerArray<HBufC8>& aCertChain )
    {
    TInt size = 0;
    TInt error = KErrNone;
    TPckg<TInt> package( size );
    HBufC8* certChainBuf = NULL;

    error = SendReceive( Roap::EGetCertificates, TIpcArgs( &package ) );

    User::LeaveIfError( error );

    certChainBuf = HBufC8::NewMaxLC( size );
    TPtr8 objectPkg( const_cast<TUint8*> ( certChainBuf->Ptr() ), size, size );

    User::LeaveIfError( SendReceive( Roap::EGetData, TIpcArgs( &objectPkg ) ) );

    aCertChain = BufferToArrayL( *certChainBuf );

    CleanupStack::PopAndDestroy( certChainBuf );
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// RoapStorageClient::SignL
// -----------------------------------------------------------------------------
//
EXPORT_C TInt Roap::RRoapStorageClient::SignL(
    const TDesC8& aHash,
    HBufC8*& aSignature )
    {
    TInt size = 0;
    TInt error = KErrNone;
    TPckg<TInt> package( size );

    if ( aHash.Length() )
        {
        error
            = SendReceive( Roap::ESignMessage, TIpcArgs( &package, &aHash ) );

        User::LeaveIfError( error );

        HBufC8* signature( HBufC8::NewMaxLC( size ) );
        TPtr8
            objectPkg( const_cast<TUint8*> ( signature->Ptr() ), size, size );

        User::LeaveIfError( SendReceive( Roap::EGetData,
            TIpcArgs( &objectPkg ) ) );

        CleanupStack::Pop( signature );
        aSignature = signature;
        return KErrNone;
        }

    User::Leave( KErrArgument );
    return KErrArgument;
    }

// -----------------------------------------------------------------------------
// RoapStorageClient::SignL
// -----------------------------------------------------------------------------
//
EXPORT_C TInt Roap::RRoapStorageClient::RsaSignL(
    const TDesC8& aHash,
    HBufC8*& aSignature )
    {
    TInt size = 0;
    TInt error = KErrNone;
    TPckg<TInt> package( size );

    if ( aHash.Length() )
        {
        error = SendReceive( Roap::ERsaSign, TIpcArgs( &package, &aHash ) );

        User::LeaveIfError( error );

        HBufC8* signature( HBufC8::NewMaxLC( size ) );
        TPtr8
            objectPkg( const_cast<TUint8*> ( signature->Ptr() ), size, size );

        User::LeaveIfError( SendReceive( Roap::EGetData,
            TIpcArgs( &objectPkg ) ) );

        CleanupStack::Pop( signature );
        aSignature = signature;
        return KErrNone;
        }

    User::Leave( KErrArgument );
    return KErrArgument;
    }

// -----------------------------------------------------------------------------
// RoapStorageClient::VerifyL
// -----------------------------------------------------------------------------
//
EXPORT_C TBool Roap::RRoapStorageClient::VerifyL(
    const TDesC8& aSignature,
    const TDesC8& aHash,
    const RPointerArray<HBufC8>& aCertificateChain )
    {
    CRSAPublicKey* publicKey( NULL );
    TBool r( ETrue );
    CX509Certificate* cert( NULL );
    TX509KeyFactory factory;

    if ( aCertificateChain.Count() <= 0 )
        {
        User::Leave( KErrArgument );
        }
    cert = CX509Certificate::NewLC( *aCertificateChain[0] );
    publicKey = factory.RSAPublicKeyL( cert->PublicKey().KeyData() );
    CleanupStack::PushL( publicKey );
    r = OmaCrypto::RsaPssVerifyHashL( publicKey, aSignature, aHash );
    CleanupStack::PopAndDestroy( publicKey );
    CleanupStack::PopAndDestroy( cert );
    return r;
    }

// -----------------------------------------------------------------------------
// RoapStorageClient::GetRIContextL
// -----------------------------------------------------------------------------
//
EXPORT_C CDRMRIContext* Roap::RRoapStorageClient::GetRIContextL(
    const TDesC8& aRiID )
    {
    TInt error = KErrNone;
    CDRMRIContext* context( NULL );

    if ( aRiID.Length() )
        {
        TInt size = 0;
        TPckg<TInt> package( size );

        error
            = SendReceive( Roap::EGetRiContext, TIpcArgs( &package, &aRiID ) );

        if ( error == KErrNotFound )
            {
            return NULL;
            }

        User::LeaveIfError( error );

        HBufC8* contextData = HBufC8::NewMaxLC( size );

        // Package 'object' into TPtr8.
        TPtr8 objectPkg( const_cast<TUint8*> ( contextData->Ptr() ), size,
            size );

        User::LeaveIfError( SendReceive( Roap::EGetData,
            TIpcArgs( &objectPkg ) ) );

        context = CDRMRIContext::NewLC();

        context->ImportL( contextData->Des() );

        CleanupStack::Pop( context );
        CleanupStack::PopAndDestroy( contextData );
        }
    else
        {
        User::Leave( KErrArgument );
        }

    return context;
    }

// -----------------------------------------------------------------------------
// RoapStorageClient::GetDomainContextL
// -----------------------------------------------------------------------------
//
EXPORT_C CDRMDomainContext* Roap::RRoapStorageClient::GetDomainContextL(
    const TDesC8& aDomainID )
    {
    TInt error = KErrNone;
    CDRMDomainContext* context( NULL );

    if ( aDomainID.Length() )
        {
        TInt size = 0;
        TPckg<TInt> package( size );

        // Call the server. Throw an exception in case of an error.
        error = SendReceive( Roap::EGetDomainContext, TIpcArgs( &package,
            &aDomainID ) );

        if ( error == KErrNotFound )
            {
            return NULL;
            }

        HBufC8* contextData = HBufC8::NewMaxLC( size );

        // Package 'object' into TPtr8.
        TPtr8 objectPkg( const_cast<TUint8*> ( contextData->Ptr() ), size,
            size );

        User::LeaveIfError( SendReceive( Roap::EGetData,
            TIpcArgs( &objectPkg ) ) );

        context = CDRMDomainContext::NewLC();

        context->ImportL( contextData->Des() );

        CleanupStack::Pop( context );
        CleanupStack::PopAndDestroy( contextData );

        return context;
        }

    User::Leave( KErrArgument );

    return NULL;
    }

// -----------------------------------------------------------------------------
// RRoapStorageClient::AddRIContextL
// Add a new RI Context to the ROAP storage
// -----------------------------------------------------------------------------
//
EXPORT_C void Roap::RRoapStorageClient::AddRIContextL(
    const CDRMRIContext& aRiContext )
    {
    HBufC8* contextData = aRiContext.ExportL();
    TInt size = aRiContext.Size();
    TPtr8 riContext( NULL, 0 );
    if ( size )
        {
        riContext.Set( const_cast<TUint8*> ( contextData->Ptr() ), size, size );

        User::LeaveIfError( SendReceive( Roap::EAddRiContext, TIpcArgs(
            &riContext ) ) );
        }
    delete contextData;
    contextData = NULL;
    }

// -----------------------------------------------------------------------------
// RRoapStorageClient::AddDomainContextL
// Add a new Domain Context to the ROAP storage
// -----------------------------------------------------------------------------
//
EXPORT_C void Roap::RRoapStorageClient::AddDomainContextL(
    const CDRMDomainContext& aDomainContext,
    const RPointerArray<HBufC8>& aMacs,
    const RPointerArray<HBufC8>& aDomainKeyElements,
    TKeyTransportScheme& aTransportScheme )
    {
    TPckg<TKeyTransportScheme> package( aTransportScheme );
    HBufC8* contextData = aDomainContext.ExportL();
    CleanupStack::PushL( contextData );
    TInt size = aDomainContext.Size();
    TPtr8 contextPtr( NULL, 0 );
    TPtr8 domainXmltPtr( 0, 0 );
    TPtr8 macValuesPtr( 0, 0 );
    HBufC8* domainXml = NULL;
    HBufC8* macValues = NULL;

    domainXml = ArrayToBufferLC( aDomainKeyElements );
    macValues = ArrayToBufferLC( aMacs );

    if ( size && domainXml && macValues )
        {
        contextPtr.Set( const_cast<TUint8*> ( contextData->Ptr() ), size,
            size );
        domainXmltPtr.Set( domainXml->Des() );
        macValuesPtr.Set( macValues->Des() );

        User::LeaveIfError( SendReceive( Roap::EAddDomainContext, TIpcArgs(
            &contextPtr, &package, &macValuesPtr, &domainXmltPtr ) ) );
        }
    else
        {
        User::Leave( KErrArgument );
        }
    CleanupStack::PopAndDestroy( macValues );
    CleanupStack::PopAndDestroy( domainXml );
    CleanupStack::PopAndDestroy( contextData );
    }

// -----------------------------------------------------------------------------
// RRoapStorageClient::DeleteRiContextL
// -----------------------------------------------------------------------------
//
EXPORT_C void Roap::RRoapStorageClient::DeleteRiContextL( const TDesC8& aRiID )
    {
    if ( aRiID.Length() )
        {
        User::LeaveIfError( SendReceive( Roap::EDeleteRiContext, TIpcArgs(
            &aRiID ) ) );
        return;
        }
    User::Leave( KErrArgument );
    }

// -----------------------------------------------------------------------------
// RRoapStorageClient::DeleteDomainContextL
// -----------------------------------------------------------------------------
//
EXPORT_C void Roap::RRoapStorageClient::DeleteDomainContextL(
    const TDesC8& aDomainID )
    {
    if ( aDomainID.Length() )
        {
        User::LeaveIfError( SendReceive( Roap::EDeleteDomainContext,
            TIpcArgs( &aDomainID ) ) );
        return;
        }
    User::Leave( KErrArgument );
    }

// -----------------------------------------------------------------------------
// RRoapStorageClient::DeleteExpiredRIsL
// -----------------------------------------------------------------------------
//
EXPORT_C void Roap::RRoapStorageClient::DeleteExpiredRIsL( const TTime& aTime )
    {
    TPckg<TTime> package( aTime );

    User::LeaveIfError( SendReceive( Roap::EDeleteExpiredRIs, TIpcArgs(
        &package ) ) );
    }

// -----------------------------------------------------------------------------
// RRoapStorageClient::DeleteExpiredDomainsL
// -----------------------------------------------------------------------------
//
EXPORT_C void Roap::RRoapStorageClient::DeleteExpiredDomainsL(
    const TTime& aTime )
    {
    TPckg<TTime> package( aTime );

    User::LeaveIfError( SendReceive( Roap::EDeleteExpiredDomains, TIpcArgs(
        &package ) ) );
    }

// -----------------------------------------------------------------------------
// RRoapStorageClient::DeleteExpiredContextsL
// -----------------------------------------------------------------------------
//
EXPORT_C void Roap::RRoapStorageClient::DeleteExpiredContextsL(
    const TTime& aTime )
    {
    TPckg<TTime> package( aTime );

    User::LeaveIfError( SendReceive( Roap::EDeleteExpired,
        TIpcArgs( &package ) ) );
    }

// -----------------------------------------------------------------------------
// RRoapStorageClient::DeleteAllL
// -----------------------------------------------------------------------------
//
EXPORT_C void Roap::RRoapStorageClient::DeleteAllL()
    {
    User::LeaveIfError( SendReceive( Roap::EDeleteAll ) );
    }

// -----------------------------------------------------------------------------
// RRoapStorageClient::WhiteListURLExistsL
// -----------------------------------------------------------------------------
//
EXPORT_C TBool Roap::RRoapStorageClient::WhiteListURLExistsL(
    const TDesC8& aURL, TBool& aFromPreconfiguredWhiteList )
    {
    TInt r = KErrArgument;

    TPckg<TBool> preConfiguredInOutParam( aFromPreconfiguredWhiteList );
    if ( aURL.Length() )
        {
        // Call the server.
        r = SendReceive( Roap::EWhiteListCheck, TIpcArgs( &aURL,
            &preConfiguredInOutParam ) );
        if ( r == KErrNone )
            {
            return ETrue;
            }
        else if ( r == KErrNotFound )
            {
            return EFalse;
            }
        }
    User::LeaveIfError( r );
    return EFalse;
    }

// -----------------------------------------------------------------------------
// RRoapStorageClient::SelectTrustedRootL()
// -----------------------------------------------------------------------------
//
EXPORT_C TInt Roap::RRoapStorageClient::SelectTrustedRootL(
    const RPointerArray<HBufC8>& aTrustedRoots,
    TDes8& aSelectedRoot ) const
    {
    TInt ret = KErrNone;

    if ( aTrustedRoots.Count() )
        {
        HBufC8* rootsBuf = NULL;
        rootsBuf = ArrayToBufferLC( aTrustedRoots );

        ret = SendReceive( Roap::ESelectRoot, TIpcArgs( rootsBuf,
            &aSelectedRoot ) );

        CleanupStack::PopAndDestroy( rootsBuf );
        return ret;
        }

    return KErrArgument;
    }

// -----------------------------------------------------------------------------
// RRoapStorageClient::SelectTrustedRootL()
// -----------------------------------------------------------------------------
//
EXPORT_C TInt Roap::RRoapStorageClient::SelectTrustedRootL(
    const TDesC8& aTrustedRoot ) const
    {
    TInt ret = KErrNone;

    if ( aTrustedRoot.Length() > SHA1_HASH )
        {
        User::Leave( KErrArgument );
        }

    ret = SendReceive( Roap::EActivateRoot, TIpcArgs( &aTrustedRoot ) );
    return ret;
    }

// -----------------------------------------------------------------------------
// RRoapStorageClient::GetTrustedRootsL()
// -----------------------------------------------------------------------------
//
EXPORT_C void Roap::RRoapStorageClient::GetTrustedRootsL(
    RPointerArray<HBufC8>& aTrustedRoots ) const
    {
    TInt size = 0;
    TPckg<TInt> package( size );

    User::LeaveIfError( SendReceive( Roap::EGetTrustedRoots, TIpcArgs(
        &package ) ) );

    HBufC8* rootsData = HBufC8::NewMaxLC( size );

    // Package 'object' into TPtr8.
    TPtr8 objectPkg( const_cast<TUint8*> ( rootsData->Ptr() ), size, size );

    User::LeaveIfError( SendReceive( Roap::EGetData, TIpcArgs( &objectPkg ) ) );

    aTrustedRoots = BufferToArrayL( *rootsData );

    CleanupStack::PopAndDestroy( rootsData );
    }

// -----------------------------------------------------------------------------
// RRoapStorageClient::GetTrustedRootL()
// -----------------------------------------------------------------------------
//
EXPORT_C HBufC8* Roap::RRoapStorageClient::GetRootCertificateL(
    const TDesC& aSubject ) const
    {
    TInt error = KErrNone;
    HBufC8* rootCert = NULL;

    if ( aSubject.Length() )
        {
        TInt size = 0;
        TPckg<TInt> package( size );

        error = SendReceive( Roap::EGetRootCert, TIpcArgs( &package,
            &aSubject ) );

        if ( error == KErrNotFound )
            {
            return NULL;
            }

        User::LeaveIfError( error );

        rootCert = HBufC8::NewMaxLC( size );

        // Package 'object' into TPtr8.
        TPtr8 objectPkg( const_cast<TUint8*> ( rootCert->Ptr() ), size, size );

        User::LeaveIfError( SendReceive( Roap::EGetData,
            TIpcArgs( &objectPkg ) ) );

        CleanupStack::Pop( rootCert );
        return rootCert;
        }

    User::Leave( KErrArgument );

    return NULL;
    }

// -----------------------------------------------------------------------------
// RRoapStorageClient::GetMeteringData()
// -----------------------------------------------------------------------------
//
#ifndef RD_DRM_METERING
EXPORT_C HBufC8* Roap::RRoapStorageClient::GetMeteringDataL(
    TDesC8& /*aRiId*/,
    TDes8& /*aMacKey*/,
    TDes8& /*aEncKeyHash*/,
    HBufC8*& /*aEncryptedMekAndMak*/ )
    {
    return NULL;
    }
#else
EXPORT_C HBufC8* Roap::RRoapStorageClient::GetMeteringDataL(
    TDesC8& aRiId,
    TDes8& aMacKey,
    TDes8& aEncKeyHash,
    HBufC8*& aEncryptedMekAndMak )
    {
    TInt error = KErrNone;
    HBufC8* meteringData = NULL;
    HBufC8* csBuffer = NULL;

    if ( aRiId.Length() )
        {
        TInt mekAndMakSize = 0;
        TInt meteringDataSize = 0;
        TPckg<TInt> MakMek( mekAndMakSize );
        TPckg<TInt> dataSize( meteringDataSize );

        error = SendReceive( Roap::EGetMeteringData, TIpcArgs( &aRiId,
            &MakMek, &dataSize ) );

        if ( error == KErrNotFound )
            {
            return NULL;
            }

        User::LeaveIfError( error );

        csBuffer = HBufC8::NewMaxLC( OmaCrypto::KMacSize + SHA1_HASH
            + mekAndMakSize + meteringDataSize );

        // Package 'object' into TPtr8.
        TPtr8 objectPkg( const_cast<TUint8*> ( csBuffer->Ptr() ),
            OmaCrypto::KMacSize + SHA1_HASH + mekAndMakSize
                + meteringDataSize, OmaCrypto::KMacSize + SHA1_HASH
                + mekAndMakSize + meteringDataSize );

        User::LeaveIfError( SendReceive( Roap::EGetData,
            TIpcArgs( &objectPkg ) ) );

        aMacKey = objectPkg.Mid( 0, OmaCrypto::KMacSize );
        aEncKeyHash = objectPkg.Mid( OmaCrypto::KMacSize, SHA1_HASH );
        aEncryptedMekAndMak = objectPkg.Mid( OmaCrypto::KMacSize + SHA1_HASH,
            mekAndMakSize ).AllocL();
        meteringData = objectPkg.Mid( OmaCrypto::KMacSize + SHA1_HASH
            + mekAndMakSize, meteringDataSize ).AllocL();
        CleanupStack::PopAndDestroy( csBuffer );
        }
    else
        {
        User::Leave( KErrArgument );
        }
    return meteringData;
    }
#endif //RD_DRM_METERING
// -----------------------------------------------------------------------------
// RRoapStorageClient::DeleteMeteringDataL
// -----------------------------------------------------------------------------
//
#ifndef RD_DRM_METERING
EXPORT_C void Roap::RRoapStorageClient::DeleteMeteringDataL(
    const TDesC8& /*aRiId*/)
    {
    return;
    }
#else
EXPORT_C void Roap::RRoapStorageClient::DeleteMeteringDataL(
    const TDesC8& aRiId )
    {
    if ( aRiId.Length() )
        {
        User::LeaveIfError( SendReceive( Roap::EDeleteMeteringData, TIpcArgs(
            &aRiId ) ) );
        }
    else
        {
        User::Leave( KErrArgument );
        }
    return;
    }
#endif //RD_DRM_METERING
// -----------------------------------------------------------------------------
// RRoapStorageClient::GetAllRIContextsL
// -----------------------------------------------------------------------------
//
#ifndef RD_DRM_METERING
EXPORT_C void Roap::RRoapStorageClient::GetAllRIContextsL(
    RPointerArray<Roap::CDRMRIContext>& /*aRiContexts*/)
    {
    }
#else
EXPORT_C void Roap::RRoapStorageClient::GetAllRIContextsL(
    RPointerArray<CDRMRIContext>& aRiContexts )
    {
    TInt error = KErrNone;
    CDRMRIContext* context = NULL;

    // Clear whatever is in the list.
    aRiContexts.ResetAndDestroy();

    TInt size = 0;
    TInt blocksize = 0;

    TPckg<TInt> package( size );

    error = SendReceive( Roap::ERetrieveAllRIContexts, TIpcArgs( &package ) );

    // None are found is not an error, but just an empty list.
    if ( error == KErrNotFound )
        {
        return;
        }

    // otherwise it is an error.
    User::LeaveIfError( error );

    // Get the data block received.


    HBufC8* contextData = HBufC8::NewMaxLC( size );

    // Package 'object' into TPtr8.
    TPtr8 objectPkg( const_cast<TUint8*> ( contextData->Ptr() ), size, size );

    User::LeaveIfError( SendReceive( Roap::EGetData, TIpcArgs( &objectPkg ) ) );

    RMemReadStream stream( (TAny*)( objectPkg.Ptr() ), size );
    CleanupClosePushL( stream );

    // We have the data, parse it and fill the aRiContexts:

    blocksize = stream.ReadInt32L();

    while ( blocksize )
        {
        // Create a new context:
        context = CDRMRIContext::NewLC();

        // import it from the data block
        context->InternalizeL( stream );

        // add it to the pointer array
        aRiContexts.AppendL( context );

        // pop it from the cleanup stack
        CleanupStack::Pop( context ); // context


        // read the new block size and increment the offset:
        blocksize = stream.ReadInt32L();
        }

    CleanupStack::PopAndDestroy( &stream );
    CleanupStack::PopAndDestroy( contextData );
    return;
    }

#endif // RD_DRM_METERING
// -----------------------------------------------------------------------------
// RRoapStorageClient::UpdateRiContextL
// -----------------------------------------------------------------------------
//
#ifndef RD_DRM_METERING
EXPORT_C void Roap::RRoapStorageClient::UpdateRIContextL(
    const Roap::CDRMRIContext& /*aContext*/)
    {
    }
#else
EXPORT_C void Roap::RRoapStorageClient::UpdateRIContextL(
    const CDRMRIContext& aContext )
    {
    HBufC8* contextData = aContext.ExportL();
    CleanupStack::PushL( contextData );
    TInt size = aContext.Size();
    TPtr8 riContext( NULL, 0 );
    if ( size )
        {
        riContext.Set( const_cast<TUint8*> ( contextData->Ptr() ), size, size );

        User::LeaveIfError( SendReceive( Roap::EUpdateRIContext, TIpcArgs(
            &riContext ) ) );
        }
    CleanupStack::PopAndDestroy( contextData );
    }
#endif // RD_DRM_METERING

// -----------------------------------------------------------------------------
// RRoapStorageClient::UpdateDrmTimeL
// -----------------------------------------------------------------------------
//
EXPORT_C TBool Roap::RRoapStorageClient::UpdateDrmTimeL(
    const RPointerArray<HBufC8>& aCertChain,
    const RPointerArray<HBufC8>& aOcspResponses,
    const TDesC8& aNonce )
    {
    TBool clockUpdated( EFalse );
    TPckg<TBool> retParam( clockUpdated );
    HBufC8* certChain( ArrayToBufferLC( aCertChain ) );
    HBufC8* ocspResponses( ArrayToBufferLC( aOcspResponses ) );
    TPtrC8 nonceParam( aNonce );
    User::LeaveIfError( SendReceive( Roap::EUpdateDrmTime, TIpcArgs(
        certChain, ocspResponses, &nonceParam, &retParam ) ) );
    CleanupStack::PopAndDestroy( ocspResponses );
    CleanupStack::PopAndDestroy( certChain );
    return clockUpdated;
    }

// -----------------------------------------------------------------------------
// RRoapStorageClient::VerifyOcspResponsesL
// -----------------------------------------------------------------------------
//
EXPORT_C TBool Roap::RRoapStorageClient::VerifyOcspResponsesL(
    const RPointerArray<HBufC8>& aOcspResponses,
    const TDesC8& aRiCaCert,
    const RPointerArray<HBufC8>& aCertSerialNums )
    {
    TBool ret( EFalse );
    HBufC8* ocspData( ArrayToBufferLC( aOcspResponses ) );
    HBufC8* serialNumsData( ArrayToBufferLC( aCertSerialNums ) );

    TPtrC8 riCaCertParam( aRiCaCert );
    TPckg<TBool> retParam( ret );

    User::LeaveIfError( SendReceive( Roap::EVerifyOcspResponses, TIpcArgs(
        ocspData, &riCaCertParam, serialNumsData, &retParam ) ) );

    CleanupStack::PopAndDestroy( serialNumsData );
    CleanupStack::PopAndDestroy( ocspData );
    return ret;
    }

// -----------------------------------------------------------------------------
// RRoapStorageClient::GetOcspResponderIdL
// -----------------------------------------------------------------------------
//
EXPORT_C HBufC8* Roap::RRoapStorageClient::GetOcspResponderIdL(
    const TDesC8& aRiID )
    {
    TPtrC8 riIdParam( aRiID );
    TInt size( 0 );
    TPckg<TInt> sizeParam( size );

    User::LeaveIfError( SendReceive( Roap::EGetOcspResponderId, TIpcArgs(
        &riIdParam, &sizeParam ) ) );

    if ( size == 0 )
        {
        return NULL;
        }
    HBufC8* responderData = HBufC8::NewMaxLC( size );

    // Package 'object' into TPtr8.
    TPtr8 objectPkg( responderData->Des() );

    User::LeaveIfError( SendReceive( Roap::EGetData, TIpcArgs( &objectPkg ) ) );

    CleanupStack::Pop( responderData );
    return responderData;
    }
//  End of File