/*

* Copyright (c) 2002, 2003 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:  Implementation of common DRM operations

*

*/

// INCLUDE FILES

#include <f32file.h>

#include <s32file.h>

#include <apmstd.h>

#include <wspdecoder.h>

#include <wspencoder.h>

#include <barsc.h>

#include <barsread.h>

#include <DRMCommon.rsg>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif

#include "DRMCommon.h"

#include "DRMRightsClient.h"

#include "DcfCommon.h"

#include "Oma1Dcf.h"

#include "oma2dcf.h"

#include "DrmPermission.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TInt KBufferSize = 1024;

_LIT8(KRiUrl, "Rights-Issuer");

// MACROS

// LOCAL CONSTANTS AND MACROS

_LIT8(KFLPrefix, "flk:");

_LIT8(KLDPrefix, "ldf:");

_LIT8(KHeaderNameEnding, ":");

_LIT8(KHeaderEnding, "\r\n");

 #ifdef RD_MULTIPLE_DRIVE

_LIT(KDataTypesFile, "%c:\\system\\data\\DataType.dat");

_LIT(KResourceFile, "%c:\\resource\\drmcommon.rsc");

_LIT(KTempFile, "%c:\\system\\temp\\DataType.tmp");

#else

_LIT(KDataTypesFile, "c:\\system\\data\\DataType.dat");

_LIT(KResourceFile, "z:\\resource\\drmcommon.rsc");

_LIT(KTempFile, "c:\\system\\temp\\DataType.tmp");

#endif

// Version of the client

const TUint8 KClientVersionMajor = 1;

const TUint8 KClientVersionMinor = 1;

const TUint16 KClientVersionBuild = 2;

// Which lowest server version is supported

const TUint8 KServerVersionMajor = 1;

const TUint8 KServerVersionMinor = 2;

const TUint16 KServerVersionBuild = 1;

//_LIT(KNullDate,"00000000:000000.000000");

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

/*

LOCAL_C TInt CheckContentRightsL(

    const TDesC8& aContentURI,

    TUint32 aRightsSpec);

LOCAL_C TInt IsProtectedContentL(

    const TDesC8& aContent,

    TBool& aProtection);

LOCAL_C TInt GetNewHeaderBuffer(

    HBufC8*& aOldHeaderBuf,

    const TDesC8& aHeaderName,

    const TDesC8& aHeaderValue,

    HBufC8*& aNewHeaderBuf

    );

LOCAL_C TInt WriteNewFile(

    TFileName aFileName,

    HBufC8*& aHeaderBuf,

    TUint32& aFirstPartLength,

    TUint32& aDataLength,

    TUint32& aDataPartPos

    );

LOCAL_C TInt GetContentURIListL(

    RPointerArray<HBufC8>*& aURIList);

LOCAL_C TInt DataTypesCountL(

    TInt& aCount);

LOCAL_C TInt SupportedDataTypeL(

    const TInt aIndex, TDataType& aDataType);

LOCAL_C TInt StaticDataTypesCountL(

    TInt& aCount);

LOCAL_C TInt RegisterDataTypeL(

    const TDataType& aDataType);

LOCAL_C TInt UnRegisterDataTypeL(

    const TInt aIndex);

*/

LOCAL_C void GetActiveRightsL(

    const TDesC8& aContentURI,

    TUint32 aRightsSpec,

    CDRMRights*& aRightsObject);

LOCAL_C TInt CheckFileRightsL(

    const TDesC& aFileName,

    TUint32 aRightsSpec);

LOCAL_C TInt CheckFileRightsL(

    RFile& aFileHandle,

    TUint32 aRightsSpec);

LOCAL_C TInt IsProtectedFileL(

    const TDesC& aFileName,

    TBool& aProtection);

LOCAL_C TInt IsProtectedFileL(

    RFile& aFileHandle,

    TBool& aProtection);

LOCAL_C TInt GetContentInfoL(

    const TDesC8& aContent,

    DRMCommon::TContentProtection& aProtection,

    HBufC8*& aMIMEType,

    HBufC8*& aContentURI,

    TUint& aDataLength);

LOCAL_C TInt GetFileInfoL(

    const TDesC& aFileName,

    DRMCommon::TContentProtection& aProtection,

    HBufC8*& aMIMEType,

    HBufC8*& aContentURI,

    TUint& aDataLength);

LOCAL_C TInt GetFileInfoL(

    RFile& aFileHandle,

    DRMCommon::TContentProtection& aProtection,

    HBufC8*& aMIMEType,

    HBufC8*& aContentURI,

    TUint& aDataLength);

LOCAL_C void GetContentHeaderL(

    const TDesC8& aContent,

    const TDesC8& aHeaderName,

    HBufC8*& aHeaderValue);

LOCAL_C void GetFileHeaderL(

    const TFileName& aFileName,

    const TDesC8& aHeaderName,

    HBufC8*& aHeaderValue);

LOCAL_C void GetFileHeaderL(

    RFile& aFileHandle,

    const TDesC8& aHeaderName,

    HBufC8*& aHeaderValue);

LOCAL_C void SetContentHeaderL(

    HBufC8*& aContent,

    const TDesC8& aHeaderName,

    const TDesC8& aHeaderValue);

LOCAL_C void SetFileHeaderL(

    const TDesC16& aFileName,

    const TDesC8& aHeaderName,

    const TDesC8& aHeaderValue);

LOCAL_C void SetFileHeaderL(

    RFile& aFileHandle,

    const TDesC8& aHeaderName,

    const TDesC8& aHeaderValue);

LOCAL_C void GetSingleRightsObjectL(

    const TDesC8& aContentURI,

    TUint32 aLocalID,

    CDRMRights*& aRightsObject);

LOCAL_C void GetDetailedContentRightsL(

    const TDesC8& aContentURI,

    RPointerArray<CDRMRights>*& aRightsList);

LOCAL_C void GetDetailedFileRightsL(

    const TDesC& aFileName,

    RPointerArray<CDRMRights>*& aRightsList);

LOCAL_C void GetDetailedFileRightsL(

    RFile& aFileHandle,

    RPointerArray<CDRMRights>*& aRightsList);

LOCAL_C TInt RegisterDynamicDataTypeL(

    const TDataType& aDataType);

LOCAL_C TInt UnRegisterDynamicDataTypeL(

    const TInt aIndex);

LOCAL_C TInt CalculatePaddingL(

    COma1Dcf* dcf);

LOCAL_C void DoResetAndDestroy( TAny* aPtr );

LOCAL_C TInt GetFileHandleRead(

    RFs& aFileServer,

    RFile& aFile,

    const TDesC& aFileName );

LOCAL_C void AddParents(

    DRMCommon* aDrmCommon,

    RPointerArray<CDRMRights>& aRights );

// FORWARD DECLARATIONS

using namespace ContentAccess;

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

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

// DoResetAndDestroy

// Does RPointerArray< >->ResetAndDestroy() for the given array aPtr.

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

//

LOCAL_C void DoResetAndDestroy( TAny* aPtr )

    {

    ( reinterpret_cast< RPointerArray< CDRMPermission >* >( aPtr ) )->

        ResetAndDestroy();

    }

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

// GetPermission

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

LOCAL_C void GetPermission(

    RDRMRightsClient& aClient,

    const TDesC8& aUri,

    TIntent aIntent,

    CDRMPermission*& aPermission )

    {

    TInt r = KErrNone;

    CDRMPermission* permission = NULL;

    TUint32 reason = 0;

    TRAP( r, permission = aClient.GetActiveRightsL( aIntent, aUri, reason ) );

    if ( permission != NULL )

        {

        if ( aPermission == NULL )

            {

            TRAP_IGNORE( aPermission = CDRMPermission::NewL() );

            }

        aPermission->Merge( *permission );

        delete permission;

        }

    }

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

// GetActiveRightsL

// Returns a possible active rights object. Adopts to broken callers who still

// use a bitmask for intent.

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

void GetActiveRightsL(

    const TDesC8& aContentURI,

    TUint32 aConstraints,

    CDRMRights*& aRightsObject)

    {

    CDRMPermission* permission = NULL;

    RDRMRightsClient client;

    HBufC8* uri = NULL;

    User::LeaveIfError( client.Connect() );

    CleanupClosePushL( client );

    if ( aConstraints == 0 )

        {

        GetPermission( client, aContentURI, EView, permission );

        GetPermission( client, aContentURI, EPlay, permission );

        GetPermission( client, aContentURI, EExecute, permission );

        GetPermission( client, aContentURI, EPrint, permission );

        }

    else

        {

        GetPermission( client, aContentURI, static_cast<TIntent>( aConstraints ), permission );

        }

    if ( permission != NULL )

        {

        CleanupStack::PushL( permission );

        aRightsObject = CDRMRights::NewL();

        CleanupStack::PushL( aRightsObject );

        uri = aContentURI.AllocL();

        CleanupStack::PushL( uri );

        aRightsObject->SetPermissionL( *permission );

        aRightsObject->SetContentURI( uri );

        CleanupStack::Pop( uri );

        CleanupStack::Pop( aRightsObject );

        CleanupStack::PopAndDestroy( permission );

        }

    else

        {

        aRightsObject = NULL;

        User::Leave( KErrCANoRights );

        }

    CleanupStack::PopAndDestroy(); // client

    }

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

//

//

// Parameters:

//

// Returns:

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

LOCAL_C TInt IsProtectedFileL(

    const TDesC& aFileName,

    TBool& aProtection)

    {

    RFs fs;

    RFile file;

    TInt r = KErrNone;

    CDcfCommon* dcf = NULL;

    User::LeaveIfError(fs.Connect());

    CleanupClosePushL(fs);

    r = GetFileHandleRead( fs, file, aFileName );

    User::LeaveIfError(r);

    CleanupClosePushL(file);

    dcf = CDcfCommon::NewL(file);

    if (dcf != NULL)

        {

        aProtection = ETrue;

        delete dcf;

        }

    else

        {

        aProtection = EFalse;

        }

    CleanupStack::PopAndDestroy(2); // file, fs

    return r;

    }

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

//

//

// Parameters:

//

// Returns:

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

LOCAL_C TInt IsProtectedFileL(

    RFile& aFileHandle,

    TBool& aProtection)

    {

    TInt r = KErrNone;

    CDcfCommon* dcf = NULL;

    dcf = CDcfCommon::NewL(aFileHandle);

    if (dcf != NULL)

        {

        aProtection = ETrue;

        delete dcf;

        }

    else

        {

        aProtection = EFalse;

        }

    return r;

    }

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

//

//

// Parameters:

//

// Returns:

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

TInt GetContentInfoL(

    const TDesC8& aContent,

    DRMCommon::TContentProtection& aProtection,

    HBufC8*& aMIMEType,

    HBufC8*& aContentURI,

    TUint& aDataLength)

    {

    TInt r = KErrNone;

    COma1Dcf* dcf = NULL;

    TRAP(r, dcf = COma1Dcf::NewL(aContent));

    if (dcf != NULL)

        {

        CleanupStack::PushL( dcf );

        if (dcf->iContentID->Left(4).Compare(KLDPrefix) == 0 ||

            dcf->iContentID->Left(4).Compare(KFLPrefix) == 0 ||

            dcf->iRightsIssuerURL == NULL)

            {

            aProtection = DRMCommon::EForwardLocked;

            }

        else

            {

            aProtection = DRMCommon::ESuperDistributable;

            }

        if (dcf->iContentID != NULL)

            {

            aContentURI = dcf->iContentID->AllocL();

            }

        else

            {

            aContentURI = NULL;

            }

        if (dcf->iMimeType != NULL)

            {

            aMIMEType = dcf->iMimeType->AllocL();

            }

        else

            {

            aMIMEType = NULL;

            }

        CalculatePaddingL(dcf);

        aDataLength = dcf->iPlainTextLength;

        CleanupStack::PopAndDestroy();

        }

    else

        {

        aProtection = DRMCommon::ENoDCFFile;

        if (r == KErrArgument)

            {

            r = KErrNone;

            }

        User::LeaveIfError(r);

        }

    return r;

    }

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

//

//

// Parameters:

//

// Returns:

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

TInt GetFileInfoL(

    const TDesC& aFileName,

    DRMCommon::TContentProtection& aProtection,

    HBufC8*& aMIMEType,

    HBufC8*& aContentURI,

    TUint& aDataLength)

    {

    RFs fs;

    RFile file;

    TInt r = KErrNone;

    CDcfCommon* dcf = NULL;

    COma2Dcf* dcf2 = NULL;

    CData* data = NULL;

    aProtection = DRMCommon::ENoDCFFile;

    User::LeaveIfError(fs.Connect());

    CleanupClosePushL(fs);

    r = GetFileHandleRead( fs, file, aFileName );

    User::LeaveIfError(r);

    CleanupClosePushL(file);

    dcf = CDcfCommon::NewL(file);

    if (dcf != NULL)

        {

        CleanupStack::PushL(dcf);

        if (dcf->iVersion == EOma2Dcf)

            {

            dcf2 = static_cast<COma2Dcf*>(dcf);

            }

        if (dcf->iContentID->Left(4).Compare(KLDPrefix) == 0 ||

            dcf->iContentID->Left(4).Compare(KFLPrefix) == 0 ||

            dcf->iRightsIssuerURL == NULL)

            {

            aProtection = DRMCommon::EForwardLocked;

            }

        else

            {

            aProtection = DRMCommon::ESuperDistributable;

            }