/*

* 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;