/*

* 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:  Datatype for the Common Rights Database Data

*

*/

// INCLUDE FILES

#include <s32strm.h>

#include <s32mem.h>

#include <caf/caf.h>

#include <uri8.h>

#include "drmlog.h"

#include "DRMRIContext.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

const TInt KMaxCertificateLength = 327680;

const TInt KMaxUrlLength = 32768;

const TInt KMaxRiAliasLength = 1024;

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// CDRMRIContext::NewLC

// Two-phased constructor.

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

//

EXPORT_C CDRMRIContext* CDRMRIContext::NewLC( const TDesC8& aRIID,

                                              const TDesC8& aRiAlias,

                                              const TDesC8& aVersion,

                                              const RPointerArray< HBufC8 >& aAlgorithms,

                                              const RPointerArray< HBufC8 >& aRIURLs,

                                              const TDesC8& aRightsIssuerURL,

                                              const TTime& aExpiryTime,

                                              const RPointerArray< HBufC8 >& aChain,

                                              const RPointerArray< HBufC8 >& aResponses,

                                              const TUint8 aDeviceCertCached,

                                              const TDesC8& aSelectedDeviceRoot,

                                              const TUint8 aIsMeteringAllowed )

    {

    CDRMRIContext* self = new( ELeave ) CDRMRIContext();

    CleanupStack::PushL( self );

    self->ConstructL( aRIID, aRiAlias, aVersion, aAlgorithms,

                      aRIURLs, aRightsIssuerURL, aExpiryTime,

                      aChain, aResponses, aDeviceCertCached,

                      aSelectedDeviceRoot, aIsMeteringAllowed );

    return self;

    };

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

// CDRMRIContext::NewL

// Two-phased constructor.

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

//

EXPORT_C CDRMRIContext* CDRMRIContext::NewL( const TDesC8& aRIID,

                                             const TDesC8& aRiAlias,

                                             const TDesC8& aVersion,

                                             const RPointerArray< HBufC8 >& aAlgorithms,

                                             const RPointerArray< HBufC8 >& aRIURLs,

                                             const TDesC8& aRightsIssuerURL,

                                             const TTime& aExpiryTime,

                                             const RPointerArray< HBufC8 >& aChain,

                                             const RPointerArray< HBufC8 >& aResponses,

                                             const TUint8 aDeviceCertCached,

                                             const TDesC8& aSelectedDeviceRoot,

                                             const TUint8 aIsMeteringAllowed )

    {

    CDRMRIContext* self = NewLC( aRIID, aRiAlias, aVersion, aAlgorithms,

                                 aRIURLs, aRightsIssuerURL, aExpiryTime,

                                 aChain, aResponses, aDeviceCertCached,

                                 aSelectedDeviceRoot, aIsMeteringAllowed );

    CleanupStack::Pop();

    return self;

    };

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

// CDRMRIContext::NewLC

// Two-phased constructor.

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

//

EXPORT_C CDRMRIContext* CDRMRIContext::NewLC()

    {

    CDRMRIContext* self = new( ELeave ) CDRMRIContext();

    CleanupStack::PushL( self );

    return self;

    };

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

// CDRMRIContext::NewL

// Two-phased constructor.

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

//

EXPORT_C CDRMRIContext* CDRMRIContext::NewL()

    {

    CDRMRIContext* self = NewLC();

    CleanupStack::Pop();

    return self;

    };

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

// Default Constructor - First phase.

// Can be used by itself to generate an empty object

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

//

CDRMRIContext::CDRMRIContext()

    {

    };

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

// Destructor

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

//

EXPORT_C CDRMRIContext::~CDRMRIContext()

    {

    // Delete the algorithm array

    iAlgorithms.ResetAndDestroy();

    iAlgorithms.Close();

    // Delete the ri uri array

    iRIURLs.ResetAndDestroy();

    iRIURLs.Close();

    // Delete the certificate chain

    iCertificateChain.ResetAndDestroy();

    iCertificateChain.Close();

    // Delete the OCSP responses

    iOcspResponse.ResetAndDestroy();

    iOcspResponse.Close();

    delete iRightsIssuerURL;

    delete iRiAlias;

    };

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

// CDRMRIContext::RIID

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

//

EXPORT_C const TDesC8& CDRMRIContext::RIID() const

    {

    return iRIID;

    };

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

// CDRMRIContext::RIAlias

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

//

EXPORT_C const TDesC8& CDRMRIContext::RIAlias() const

    {

    return *iRiAlias;

    };

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

// CDRMRIContext::Version

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

//

EXPORT_C const TDesC8& CDRMRIContext::Version() const

    {

    return iVersion;

    };

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

// CDRMRIContext::Algorithms

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

//

EXPORT_C const RPointerArray< HBufC8 >& CDRMRIContext::Algorithms() const

    {

    return iAlgorithms;

    };

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

// CDRMRIContext::RIURLs

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

//

EXPORT_C const RPointerArray< HBufC8 >& CDRMRIContext::RIURLs() const

    {

    return iRIURLs;

    };

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

// CDRMRIContext::RightsIssuerURL

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

//

EXPORT_C const TDesC8& CDRMRIContext::RightsIssuerURL() const

    {

    return *iRightsIssuerURL;

    };

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

// CDRMRIContext::ExpiryTime

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

//

EXPORT_C const TTime CDRMRIContext::ExpiryTime() const

    {

    return iExpiryTime;

    };

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

// CDRMRIContext::CertificateChain

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

//

EXPORT_C const RPointerArray< HBufC8 >& CDRMRIContext::CertificateChain() const

    {

    return iCertificateChain;

    };

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

// CDRMRIContext::OCSPResponse

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

//

EXPORT_C const RPointerArray< HBufC8 >& CDRMRIContext::OCSPResponse() const

    {

    return iOcspResponse;

    };

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

// CDRMRIContext::DeviceCertCached

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

//

EXPORT_C TUint8 CDRMRIContext::DeviceCertCached() const

    {

    return iDeviceCertCached;

    };

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

// CDRMRIContext::SelectedDeviceRoot

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

//

EXPORT_C const TDesC8& CDRMRIContext::SelectedDeviceRoot() const

    {

    return iSelectedDeviceRoot;

    };

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

// CDRMRIContext::IsMeteringAllowed

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

//

EXPORT_C TUint8 CDRMRIContext::IsMeteringAllowed() const

    {

    return iIsMeteringAllowed;

    };

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

// CDRMRIContext::SetRIIDL

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

//

EXPORT_C void CDRMRIContext::SetRIIDL( const TDesC8& aRIID )

    {

    if ( ( aRIID.Length() <= 0 ) || ( aRIID.Length() > SHA1_HASH ) )

        {

        User::Leave( KErrArgument );

        }

    iRIID.Copy( aRIID );

    };

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

// CDRMRIContext::SetVersionL

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

//

EXPORT_C void CDRMRIContext::SetVersionL( const TDesC8& aVersion )

    {

    if ( ( aVersion.Length() <= 0 ) ||

        ( aVersion.Length() > Roap::KMaxRoapVersionLength ) )

        {

        User::Leave( KErrArgument );

        }

    iVersion.Copy( aVersion );

    };

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

// CDRMRIContext::SetAlgorithmsL

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

//

EXPORT_C void CDRMRIContext::SetAlgorithmsL( const RPointerArray< HBufC8 >& aAlgorithms )

    {

    HBufC8* tempData = NULL;

    // Clear the old algorithms

    iAlgorithms.ResetAndDestroy();

    // Append the new stuff

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

        {

        tempData = aAlgorithms[i]->AllocLC();

        iAlgorithms.AppendL( tempData );

        CleanupStack::Pop();

        }

    };

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

// CDRMRIContext::SetRIURLsL

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

//

EXPORT_C void CDRMRIContext::SetRIURLsL( const RPointerArray< HBufC8 >& aRIURLs )

    {

    HBufC8* tempData = NULL;

    // Clear the old algorithms

    iRIURLs.ResetAndDestroy();

    // Append the new stuff

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

        {

        tempData = aRIURLs[i]->AllocLC();

        iRIURLs.AppendL( tempData );

        CleanupStack::Pop();

        }

    };

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

// CDRMRIContext::SetRightsIssuerURLL

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

//

EXPORT_C void CDRMRIContext::SetRightsIssuerURLL(

    const TDesC8& aRightsIssuerURL )

    {

    HBufC8* newRightsIssuerURL = aRightsIssuerURL.AllocL();

    if( iRightsIssuerURL )

        {

        delete iRightsIssuerURL;

        iRightsIssuerURL = NULL;

        }

    iRightsIssuerURL = newRightsIssuerURL;

    };

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

// CDRMRIContext::SetExpiryTimeL

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

//

EXPORT_C void CDRMRIContext::SetExpiryTimeL( const TTime& aExpiryTime )

    {

    iExpiryTime = aExpiryTime;

    };

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

// CDRMRIContext::SetCertificateChainL

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

//

EXPORT_C void CDRMRIContext::SetCertificateChainL( const RPointerArray< HBufC8 >& aChain )

    {

    HBufC8* tempData = NULL;

    // Clear the old algorithms

    iCertificateChain.ResetAndDestroy();

    // Append the new stuff

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

        {

        tempData = aChain[i]->AllocLC();

        iCertificateChain.AppendL( tempData );

        CleanupStack::Pop();

        }

    };

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

// CDRMRIContext::SetOCSPResponseL

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

//

EXPORT_C void CDRMRIContext::SetOCSPResponseL( const RPointerArray< HBufC8 >& aResponses )

    {

    HBufC8* tempData = NULL;

    // Clear the old algorithms

    iOcspResponse.ResetAndDestroy();

    // Append the new stuff

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

        {

        tempData = aResponses[i]->AllocLC();

        iOcspResponse.AppendL( tempData );

        CleanupStack::Pop();

        }

    };

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

// CDRMRIContext::SetDeviceCertCached

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

//

EXPORT_C void CDRMRIContext::SetDeviceCertCached( TUint8& aIsCached )

    {

    iDeviceCertCached = aIsCached;

    };

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

// CDRMRIContext::WhiteListURLExistsL

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

//

EXPORT_C TBool CDRMRIContext::WhiteListURLExistsL( const TDesC8& aURL ) const

    {

    TUriParser8 uri1;

    TUriParser8 uri2;

    uri1.Parse( aURL );

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

        {

        uri2.Parse( *iRIURLs[i] );

        if ( uri2.Compare( uri1, EUriHost ) == 0 )

            {

            return ETrue;

            }

        }

    if( iRightsIssuerURL )

        {

        uri2.Parse( *iRightsIssuerURL );

        if ( uri2.Compare(uri1, EUriHost ) == 0 )

            {

            return ETrue;

            }

        }

    return EFalse;

    };

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

// CDRMRIContext::SetSelectedDeviceRoot

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

//

EXPORT_C void CDRMRIContext::SetSelectedDeviceRoot( const TDesC8& aSelectedDeviceRoot )

    {

    if ( ( aSelectedDeviceRoot.Length() <= 0 ) ||

        ( aSelectedDeviceRoot.Length() > SHA1_HASH ) )

        {

        return;

        }

    iSelectedDeviceRoot.Copy( aSelectedDeviceRoot );

    };

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

// CDRMRIContext::SetMeteringStatus

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

//

EXPORT_C void CDRMRIContext::SetMeteringStatus( const TBool aIsMeteringAllowed )

    {

    iIsMeteringAllowed = aIsMeteringAllowed;

    };

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

// CDRMRIContext::ExternalizeL

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

//

EXPORT_C void CDRMRIContext::ExternalizeL( RWriteStream& aStream ) const

    {

    TInt dataLength = 0;

    TUint8 flag;

    // write the iRIID

    aStream.WriteL( iRIID );

    // write the iRiAlias

    if ( iRiAlias )

        {

        flag = ETrue;

        aStream << flag;

        aStream << *iRiAlias;

        }

    else

        {

        flag = EFalse;

        aStream << flag;

        }

    // write the version length

    aStream.WriteInt8L( static_cast<TInt8>(iVersion.Length() ) );

    // write the version

    if( iVersion.Length() )

        {

        aStream.WriteL( iVersion );

        }

    // write the algorithms

    // How many:

    aStream.WriteInt32L( iAlgorithms.Count() );

    // for each in rpointerarray

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

        {