/*

* Copyright (c) 2004 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:  This class implements the BbB-functionality.

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <s32file.h>

#include <s32mem.h>

#include <caf/caftypes.h>

#include <wspdecoder.h>

#include <wspencoder.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif

#include "DRMRights.h"

#include "Oma1DcfCreator.h"

#include "b64.h"

#include "DRMMessageParser.h"

#include "DrmRightsParser.h"

#include "DRMRightsClient.h"

#include "DrmKeyStorage.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

LOCAL_C const TInt KDefaultInputBufferSize = 2048;

LOCAL_C const TInt KDRMMessageMalformed = KErrGeneral;

_LIT8( KCIDString, "cid:" );

LOCAL_C const TInt KCIDStringLength = 4;

_LIT8( KFLPrefix, "flk:");

LOCAL_C const TInt KFLKPrefixLength = 4;

_LIT8( KFLSuffix, "@localhost");

LOCAL_C const TUint8 KCDContentIDLength = 25; // 4 + 11 + 10

LOCAL_C const TUint8 KCDPlainIDLength = 11;

LOCAL_C const TInt KInputBufferSize = 2048;

LOCAL_C const TInt KBoundaryMarkLength = 2;

LOCAL_C const TUint KInitialDCFBufferSize = 4096;

#ifdef RD_MULTIPLE_DRIVE

_LIT( KTempPath, "%c:\\system\\temp\\" );

#else

_LIT( KTempPath, "c:\\system\\temp\\" );

#endif

_LIT8( KColon, ":" );

_LIT8( KSemiColon, ";" );

_LIT8( KNewLine, "\n" );

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

LOCAL_C const TUint8 KEndLineLength = 2;

_LIT8( KBoundaryMark, "--" );

_LIT8( KContentType, "Content-Type" );

_LIT8( KContentTransferEncoding, "Content-Transfer-Encoding" );

_LIT8( KEncodingBase64, "base64" );

_LIT8( KEncoding7bit, "7bit" );

_LIT8( KEncoding8bit, "8bit" );

_LIT8( KEncodingBinary, "binary" );

_LIT8( KDRMXMLRightsType, "application/vnd.oma.drm.rights+xml");

_LIT8( KDRMWBXMLRightsType, "application/vnd.oma.drm.rights+wbxml" );

_LIT8( KDRMContentType, "application/vnd.oma.drm.content" );

_LIT8( KRightsIssuer, "Rights-Issuer" );

_LIT8( KRightsStartTag, "<o-ex:rights");

_LIT8( KROPart1, "Content-Type: application/vnd.oma.drm.rights+xml\r\n\

Content-Transfer-Encoding: binary\r\n\r\n\

<o-ex:rights xmlns:o-ex=\"http://odrl.net/1.1/ODRL-EX\" \

xmlns:o-dd=\"http://odrl.net/1.1/ODRL-DD\" \

xmlns:ds=\"http://www.w3.org/2000/09/xmldsig#/\">\

<o-ex:context><o-dd:version>1.0</o-dd:version></o-ex:context>\

<o-ex:agreement><o-ex:asset><o-ex:context>\

<o-dd:uid>");

_LIT8( KROPart2, "</o-dd:uid></o-ex:context></o-ex:asset><o-ex:permission>\

<o-dd:display/><o-dd:play/><o-dd:execute/><o-dd:print/>\

</o-ex:permission></o-ex:agreement></o-ex:rights>");

const TInt KFLROSize = sizeof(KROPart1) + sizeof(KROPart2);

// MODULE DATA STRUCTURES

struct TDeleteFileData

    {

    RFs aFs;

    TFileName aName;

    };

// LOCAL FUNCTION PROTOTYPES

LOCAL_C void DoResetAndDestroy( TAny* aPtr );

LOCAL_C void DoResetAndDestroy2( TAny* aPtr );

LOCAL_C void DoDeleteFile( TAny* aPtr );

LOCAL_C void ConvertPermissionL( CDRMRights*& aRights,

                                 CDRMPermission& aPermission,

                                 const TDesC8& aURI );

// FORWARD DECLARATIONS

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

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

// DoResetAndDestroy

// Does ResetAndDestroy() to given RPointerArray< CDRMRights >

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

void DoResetAndDestroy( TAny* aPtr )

    {

    __ASSERT_DEBUG( aPtr, User::Invariant() );

    reinterpret_cast< RPointerArray< CDRMRights >* >( aPtr )->ResetAndDestroy();

    }

void DoResetAndDestroy2( TAny* aPtr )

    {

    __ASSERT_DEBUG( aPtr, User::Invariant() );

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

    }

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

// DoDeleteFile

// Delete the file presented by TDeleteFileData pointer.

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

void DoDeleteFile( TAny* aPtr )

    {

    __ASSERT_DEBUG( aPtr, User::Invariant() );

    TDeleteFileData* data = reinterpret_cast< TDeleteFileData* >( aPtr );

    data->aFs.Delete( data->aName );

    }

void ConvertPermissionL( CDRMRights*& aRights,

                         CDRMPermission& aPermission,

                         const TDesC8& aURI )

    {

    CDRMAsset* asset( NULL );

    CDRMRights* rights( NULL );

    aRights = NULL;

    rights = CDRMRights::NewL();

    CleanupStack::PushL( rights );

    asset = CDRMAsset::NewL();

    CleanupStack::PushL( asset );

    asset->iUid = aURI.AllocL();

    if ( aPermission.iParentUID )

        {

        asset->iParentRights = aPermission.iParentUID->AllocL();

        }

    rights->SetPermissionL( aPermission );

    rights->SetAssetL( *asset );

    CleanupStack::PopAndDestroy(); // asset

    CleanupStack::Pop(), // rights

    aRights = rights;

    }

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

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

// CDRMMessageParser::NewL

// Two-phased constructor.

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

//

EXPORT_C CDRMMessageParser* CDRMMessageParser::NewL( void )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CDRMMessageParser::CDRMMessageParser

// Constructor.

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

//

CDRMMessageParser::CDRMMessageParser() :

    iDcfCreator( NULL ),

    iBoundary( NULL ),

    iContentType( NULL ),

    iState( ESearchingBoundary ),

    iInputBuffer( NULL, 0, 0 )

    {

    iDCFHeaderSize[ 0 ] = KMaxTUint32;

    iDCFHeaderSize[ 1 ] = KMaxTUint32;

    }

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

// Destructor.

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

//

EXPORT_C CDRMMessageParser::~CDRMMessageParser()

    {

    TInt error = KErrNone;

    TRAP( error, FinalizeMessageParserL() );

    Reset();

    User::Free( const_cast< TUint8* >( iInputBuffer.Ptr() ) );

    }

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

// CDRMMessageParser::

//

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

//

EXPORT_C void CDRMMessageParser::InitializeMessageParserL( RWriteStream& aStream )

    {

    Reset();

    iDcfCreator = COma1DcfCreator::NewL();

    iOutputStream = aStream;

    }

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

// CDRMMessageParser::ProcessDataL

// Choose which operation is required.

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

EXPORT_C void CDRMMessageParser::ProcessMessageDataL( const TDesC8& aMessageData )

    {

    /*

    * What happens here is:

    *   - a boundary string is located and extracted

    *   - MIME header is read, and based on content-type field the internal

    *     state is set to either EReadingRightsPart or EReadingContentPart.

    *   - after processing the MIME part, internal state is updated again to

    *     EReadingHeaderPart if there are several MIME parts in the DRM

    *     message.

    *   - data is consumed from iInputData in each phase.

    *   - after everything is done, internal state is set to EAllDone.

    */

    if ( iState & EBroken )

        {

        User::Leave( KErrNotReady );

        }

    if ( iState & EAllDone )

        {

        return;

        }

    iInputData.Set( aMessageData );

    while( iInputData.Length() )

        {

        if ( iState & EReadingHeaderPart )

            {

            ReadHeaderL();

            }

        else

            {

            if ( iState & EReadingContentPart )

                {

                HandleContentDataL();

                }

            else

                {

                if ( iState & EReadingRightsPart )

                    {

                    HandleRightsDataL();

                    }

                else

                    {

                    FindBoundaryL();

                    }

                }

            }

        }

    }

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

// CDRMMessageParser::FinalizeL

// Finalize the message parser.

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

EXPORT_C void CDRMMessageParser::FinalizeMessageParserL()

    {

    TInt error( KErrNone );

    if ( iState & EEncryptStreamOk )

        {

        if ( iInputBuffer.Length() )

            {

            // Message is not parsed fully ==> error.

            // Try to delete the RO if it is possible.

            DeletePermission();

            error = KDRMMessageMalformed;

            }

        ClearBit( EEncryptStreamOk );

        iDcfCreator->EncryptFinalizeL();

        iOutputStream.CommitL();

        }

    Reset();

    User::LeaveIfError( error );

    }

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

// CDRMMessageParser::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CDRMMessageParser::ConstructL()

    {

    // Make some extra room for crazy b64decode().

    iInputBuffer.Set( reinterpret_cast< TUint8* >(

                        User::AllocL( KInputBufferSize + 2 ) ),

                      0,

                      KInputBufferSize );

    }

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

// CDRMMessageParser::HandleContentDataL

// Process the content data:

// - base64 decoding

// - boundary checks

// - forward the processed data to ProcessContentDataL

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

//

void CDRMMessageParser::HandleContentDataL()

    {

   TPtrC8 res( NULL, 0 );

    TBool cont( ETrue );

    TInt remainder( 0 );

    // Loop until

    // - PrepareContentDataL leaves

    // - boundary end marker is found

    // - iInputBuffer is not updated anymore.

    for ( PrepareContentDataL();

          iInputBuffer.Length() &&

              ( remainder != iInputBuffer.Length() ) &&

              cont;

          PrepareContentDataL() )

        {

        TInt pos = iInputBuffer.Find( *iBoundary );

        if ( pos >= 0 )

            {

            if ( pos < KBoundaryMarkLength + 1 )

                {

                SetBrokenStateL( KDRMMessageMalformed );

                }

            res.Set( iInputBuffer.Left( pos - KBoundaryMarkLength ) );

            StripEndLineL( res );

            cont = EFalse;

            }

        else

            {

            // All the data cannot be processed immediately, because

            // there may be only a part of boundary string in this buffer

            // and the rest is got from the next input descriptor.

            remainder = iBoundary->Length() + KBoundaryMarkLength + 1;

            if ( iInputBuffer.Length() <= remainder )

                {

                return;

                }

            res.Set( iInputBuffer.Left( iInputBuffer.Length() -

                                        remainder ) );

            }

        if ( iState & EBase64 )

            {

            iUsedFromInput = HandleBase64DataL( res );

            }

        else

            {

            iUsedFromInput = res.Length();

            }

        ProcessContentDataL( res );

        CompressInputBuffer();

        remainder = iInputBuffer.Length();

        }

    if ( !cont )

        {

        // Discard all the remaining data.

        ClearBit( EReadingContentPart );

        SetBit( EAllDone );

        iInputBuffer.SetLength( 0 );

        iInputData.Set( NULL, 0 );

        }

    }

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

// CDRMMessageParser::HandleRightsDataL

// - check if the boundary is reached

// - check if the whole rights part is read, and allocate memory && copy the RO

//   if so

// - save the rights object

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

//

void CDRMMessageParser::HandleRightsDataL()

    {

    TPtrC8 res( NULL, 0 );

    do

        {

        res.Set( GetLineL() );

        TInt pos = res.Find( *iBoundary );

        if ( pos >= KBoundaryMarkLength )

            {

            if ( res.Left( KBoundaryMarkLength ) == KBoundaryMark )

                {

                // Allow empty RO here. If it is not allowed by

                // HandleRightsMessagePart(), an error is thrown.

                TBool last = EFalse;

                // Returns always true.

                IsBoundary( res, last );

                if ( last )

                    {

                    TInt error( KErrNone );

                    RPointerArray< CDRMRights > rights;

                    TPtrC8 ptr( iInputBuffer.Ptr(),

                                pos - KBoundaryMarkLength );

                    error = ProcessRightsObject(ptr, rights);

                    rights.ResetAndDestroy();

                    if ( !error )

                        {

                        SetBit( EAllDone );

                        }

                    else

                        {

                        SetBrokenStateL( error );

                        }

                    }

                else

                    {

                    // Save the RO since the CID needs to be either changed

                    // or created.

                    iRightsData = iInputBuffer.Left( iUsedFromInput -

                                                     res.Length() ).AllocL();

                    }

                CompressInputBuffer();

                ClearBit( EReadingRightsPart );

                ClearBit( EGotContentType );

                ClearBit( EGotContentEncoding );

                SetBit( EGotRightsPart );

                SetBit( EReadingHeaderPart );

                res.Set( NULL, 0 );

                }

            else

                {

                SetBrokenStateL( KDRMMessageMalformed );

                }

            }

        else

            {

            if ( pos >= 0 )

                {

                SetBrokenStateL( KDRMMessageMalformed );

                }

            }

        } while ( res.Length() );

    }

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

// CDRMMessageParser::FindBoundaryL

// Tries to locate the boundary string from the available data in iInputBuffer.

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

//

void CDRMMessageParser::FindBoundaryL()

    {