FCL/sf/mw/drm: comparison omadrm/drmengine/dm/src/DRMMessageParser.cpp

equal deleted inserted replaced

-:79d62d1d7957
+:493788a4a8a4
 #include <caf/caftypes.h>
 #include <wspdecoder.h>
 #include <wspencoder.h>
 #ifdef RD_MULTIPLE_DRIVE
-#include <DriveInfo.h>
+#include <driveinfo.h>
 #endif
-#include "DrmRights.h"
+#include "DRMRights.h"
 #include "Oma1DcfCreator.h"
 #include "b64.h"
 #include "DRMMessageParser.h"
-#include "DRMRightsParser.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( 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;
 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,
 // 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.
 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 ===============================
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 //
 EXPORT_C CDRMMessageParser* CDRMMessageParser::NewL( void )
 {
 CDRMMessageParser* self = new( ELeave ) CDRMMessageParser();
 CleanupStack::PushL( self );
 self->ConstructL();
 CleanupStack::Pop();
 return self;
 }
 // -----------------------------------------------------------------------------
 // CDRMMessageParser::CDRMMessageParser
 //
 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
 /*
 * 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();
 // 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
 // -----------------------------------------------------------------------------
 //
 void CDRMMessageParser::ConstructL()
 {
 // Make some extra room for crazy b64decode().
 iInputBuffer.Set( reinterpret_cast< TUint8* >(
 User::AllocL( KInputBufferSize + 2 ) ),
 0,
 KInputBufferSize );
 }
 // -----------------------------------------------------------------------------
 // CDRMMessageParser::HandleContentDataL
 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 );
 // -----------------------------------------------------------------------------
 //
 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 );
 #ifndef __DRM_FULL
 User::Leave(KErrNotSupported);
 #endif
 }
 else
 {
 SetBrokenStateL( KDRMMessageMalformed );
 }
 // -----------------------------------------------------------------------------
 //
 void CDRMMessageParser::FindBoundaryL()
 {
 TPtrC8 line( NULL, 0 );
 FOREVER
 {
 line.Set( GetLineL() );
 if ( line.Length() > KBoundaryMarkLength )
 {
 TInt size = 0;
 if ( line.Left( KBoundaryMarkLength ) == KBoundaryMark )
 {
 size = line.Length() - KBoundaryMarkLength - 1;
 if ( line[ line.Length() - 2 ] == '\r' )
 {
 --size;
 }
 iBoundary = line.Mid( KBoundaryMarkLength, size ).AllocL();
 SetBit( EGotBoundary );
 SetBit( EReadingHeaderPart );
 CompressInputBuffer();
 return;
 }
 }
 else
 {
 if ( line.Length() == 0 )
 {
 return;
 }
 }
 // Something else, not interested.
 CompressInputBuffer();
 }
 }
 // ----------------------------------------------------------------------------
 // CDRMMessageParser::ReadHeaderL
 // The boundary is read and the following part is (should be) either a RO part
 // or content part. The data is kept in iInputBuffer until the whole header
 // part of the MIME header part is received. After plain "\r\n" line is
 // received and content-type is defined, iState is updated.
 // ----------------------------------------------------------------------------
 //
 void CDRMMessageParser::ReadHeaderL()
 {
 TPtrC8 line( NULL, 0 );
 TPtrC8 ptr( NULL, 0 );
 FOREVER
 {
 ///////////////////////////////////////////////////////////////////
 // Process the MIME header line-by-line. Process the lines if they
 // contain some information that is found useful. Update the
 // internal state according to findings.
 ///////////////////////////////////////////////////////////////////
 line.Set( GetLineL() );
 if ( line.Length() )
 {
 if ( line == KEndLine || line == KNewLine )
 {
 ///////////////////////////////////////////////
 // MIME header is read. Check what to do next.
 ///////////////////////////////////////////////
 if ( iState & EGotContentType )
 {
 // Sanity check: Either EReadingRightsPart or
 // EReadingContentPart must defined.
 __ASSERT_DEBUG( ( iState & EReadingRightsPart ) ||
 ( iState & EReadingContentPart ),
 User::Invariant() );
 ClearBit( EReadingHeaderPart );
 CompressInputBuffer();
 // Check which part was read.
 // If content part is being processed, some checkings
 // need to be made.
 if ( iState & EReadingContentPart )
 {
 if ( iContentType->CompareF( KDRMContentType ) == 0 )
 {
 if ( iState & EGotRightsPart )
 {
 // CD DCF.
 SetBrokenStateL( KErrCANotSupported );
 }
 InitDCFBufferL();
 SetBit( EDCFFile );
 }
 else
 {
 // Non-DCF FL content or normal CD content.
 // Create or modify the CID, save the RO.
 HandleFlContentL();
 iDcfCreator->EncryptInitializeL(
 iOutputStream,
 *iContentType,
 iRightsObject );
 SetBit( EEncryptStreamOk );
 // The RO handle iRightsObject is kept in order
 // to delete the rights in case of content
 // encryption error. In that case, this will
 // generate unnecessary "RO Added / RO Deleted"
 // notifications, but so what. "More correct"
 // way of doing would be modifying
 // EncryptInitialize not to
 // save the RO, but then the key would have to
 // be given to it by other means. Since we are
 // not their "friend" class, we cannot access
 // their members, and making them to ask our
 // members when doing EncryptInitialize/Finalize
 // might cause some problems perhaps.
 }
 delete iContentType;
 iContentType = NULL;
 }
 return;
 }
 // Empty MIME header.
 SetBrokenStateL( KDRMMessageMalformed );
 }
 ///////////////////////////////////
 // Check the line for content-type.
 ///////////////////////////////////
 if ( line.Length() > KContentType().Length()  &&
 !( line.Left( KContentType().Length() ).CompareF( KContentType ) ) )
 {
 if ( iState & EGotContentType )
 {
 // Content-type given twice.
 SetBrokenStateL( KDRMMessageMalformed );
 }
 ptr.Set( HeaderValueL( line ) );
 SetBit( EGotContentType );
 // Which part this is: rights or the actual content?
 if ( ( ptr.CompareF( KDRMXMLRightsType ) == 0 ) ||
 ( ptr.CompareF( KDRMWBXMLRightsType ) == 0 ) )
 {
 if ( iState & EGotRightsPart )
 {
 // Rights are given twice.
 SetBrokenStateL( KDRMMessageMalformed );
 }
 SetBit( EReadingRightsPart );
 }
 else
 {
 if ( iState & EGotContentPart )
 {
 SetBrokenStateL( KDRMMessageMalformed );
 }
 SetBit( EReadingContentPart );
 // Content-type is saved for future use.
 iContentType = ptr.AllocL();
 }
 }
 else
 if ( iState & EGotContentEncoding )
 {
 // Double line.
 SetBrokenStateL( KDRMMessageMalformed );
 }
 ptr.Set( HeaderValueL( line ) );
 SetBit( EGotContentEncoding );
 // Throw an error if content-transfer-encoding
 // is something we don't support.
 if ( ptr.CompareF( KEncoding8bit ) &&
 ptr.CompareF( KEncoding7bit) &&
 ptr.CompareF( KEncodingBinary ) )
 {
 if ( ptr.CompareF( KEncodingBase64 ) )
 {
 SetBrokenStateL( KErrCANotSupported );
 }
 // So it has to be Base64.
 SetBit( EBase64 );
 }
 }
 else
 {
 //////////////////////////////////////////
 // Check the line for end boundary marker.
 //////////////////////////////////////////
 TBool final( EFalse );
 if ( IsBoundary( line, final ) )
 {
 SetBrokenStateL( KDRMMessageMalformed );
 }
 // Else: some X-field, parameter or something else.
 // The line is ignored.
 }
 }
 CompressInputBuffer();
 }
 else
 {
 // No line available yet.
 return;
 }
 //
 TPtrC8 CDRMMessageParser::GetLineL()
 {
 TInt pos = 0;
 TPtrC8 res( NULL, 0 );
 if ( iInputBuffer.Length() > iUsedFromInput )
 {
 pos = iInputBuffer.Mid( iUsedFromInput ).Find( KNewLine );
 if ( pos >= 0 )
 {
 res.Set( iInputBuffer.Mid( iUsedFromInput, pos - iUsedFromInput + 1 ) );
 iUsedFromInput = pos + 1;
 }
 }
 if ( res.Length() == 0 )
 {
 if ( iInputData.Length() )
 {
 pos = iInputData.Find( KNewLine );
 if ( pos < 0 )
 {
 if ( iInputBuffer.MaxSize() - iInputBuffer.Length() <
 iInputData.Length() )
 {
 SetBrokenStateL( KDRMMessageMalformed );
 }
 iInputBuffer.Append( iInputData );
 iInputData.Set( NULL, 0 );
 }
 else
 {
 if ( iInputBuffer.MaxSize() - iInputBuffer.Length() <
 pos + 1 )
 {
 SetBrokenStateL( KDRMMessageMalformed );
 }
 iInputBuffer.Append( iInputData.Left( pos + 1 ) );
 res.Set( iInputBuffer.Mid( iUsedFromInput ) );
 iUsedFromInput = iInputBuffer.Length();
 iInputData.Set( iInputData.Mid( pos + 1 ) );
 }
 }
 }
 return res;
 }
 // -----------------------------------------------------------------------------
 // CDRMMessageParser::HeaderValueL
 //
 TPtrC8 CDRMMessageParser::HeaderValueL( const TDesC8& aLine )
 {
 TInt pos( 0 );
 TPtrC8 res( NULL, 0 );
 pos = aLine.Find( KColon );
 if ( pos <= 0 )
 {
 SetBrokenStateL( KDRMMessageMalformed );
 }
 pos += 1;
 while ( pos < aLine.Length() &&
 TChar( aLine[ pos ] ).IsSpace() )
 {
 ++pos;
 }
 // Don't overindex.
 if ( pos == aLine.Length() )
 {
 // Full of whitespaces.
 SetBrokenStateL( KDRMMessageMalformed );
 }
 // Drop possible parameters.
 res.Set( aLine.Mid( pos ) );
 pos = res.Find( KSemiColon );
 if ( pos >= 0 )
 {
 res.Set( res.Left( pos ) );
 }
 pos = res.Length();
 if ( !pos )
 {
 // Just parameters, no actual value.
 SetBrokenStateL( KDRMMessageMalformed );
 }
 // This can't underflow, since otherwise there would be only
 // semicolon & parameters (checked earlier).
 while( TChar( res[ pos - 1 ] ).IsSpace() )
 {
 --pos;
 }
 return res.Left( pos );
 }
 // -----------------------------------------------------------------------------
 // CDRMMessageParser::CompressInputBuffer
 void CDRMMessageParser::CompressInputBuffer()
 {
 if ( iUsedFromInput )
 {
 const TInt size = iInputBuffer.Length() - iUsedFromInput;
 Mem::Copy( const_cast< TUint8* >( iInputBuffer.Ptr() ),
 iInputBuffer.Ptr() + iUsedFromInput,
 size );
 iInputBuffer.SetLength( size );
 iUsedFromInput = 0;
 }
 }
 {
 if ( iInputBuffer.Length() == iInputBuffer.MaxSize() )
 {
 SetBrokenStateL( KDRMMessageMalformed );
 }
 const TInt size = Min( iInputBuffer.MaxSize() - iInputBuffer.Length(),
 iInputData.Length() );
 iInputBuffer.Append( iInputData.Left( size ) );
 iInputData.Set( iInputData.Mid( size ) );
 }
 }
 // -----------------------------------------------------------------------------
 // CDRMMessageParser::HandleBase64DataL
 // Decode base64 encoded data from and to aData descriptor.
 //
 // -----------------------------------------------------------------------------
 //
 TInt CDRMMessageParser::HandleBase64DataL( TPtrC8& aData )
 {
 TUint8* consumed = const_cast< TUint8* >( aData.Ptr() );
 consumed = const_cast< TUint8* >( aData.Ptr() ) + temp1;
 temp2 = 0;
 }
 }
 }
 if ( consumed != aData.Ptr() )
 {
 User::LeaveIfError( b64decode( const_cast< TUint8* >( aData.Ptr() ),
 consumed - aData.Ptr() + 1,
 const_cast< TUint8* >( aData.Ptr() ),
 &temp1 ) );
 aData.Set( aData.Ptr(), temp1 );
 temp1 = consumed - aData.Ptr() + 1;
 }
 else
 {
 aData.Set( aData.Ptr(), 0 );
 temp1 = 0;
 }
 // -----------------------------------------------------------------------------
 //
 void CDRMMessageParser::StripEndLineL( TPtrC8& aBuf )
 {
 TInt newSize( aBuf.Length() );
 if ( aBuf.Right( 1 ) == KNewLine )
 {
 --newSize;
 if ( ( aBuf.Length() > 1 ) &&
 ( aBuf.Right( 2 ) == KEndLine ) )
 {
 --newSize;
 }
 aBuf.Set( aBuf.Left( newSize ) );
 }
 else
 {
 SetBrokenStateL( KDRMMessageMalformed );
 // CDRMMessageParser::IsBoundary
 // Check if the given line is a boundary line. Also check if the line is
 // the end boundary.
 // -----------------------------------------------------------------------------
 //
 TBool CDRMMessageParser::IsBoundary( const TDesC8& aLine, TBool& aLast ) const
 {
 TBool res = EFalse;
 __ASSERT_DEBUG( iBoundary, User::Invariant() );
 if ( iState & EGotBoundary )
 {
 if ( aLine.Length() > KBoundaryMarkLength + iBoundary->Length() )
 {
 TPtrC8 tmp( NULL, 0 );
 if ( ( aLine.Left( KBoundaryMarkLength ) == KBoundaryMark ) &&
 ( aLine.Mid( KBoundaryMarkLength, iBoundary->Length() ).
 Compare( *iBoundary ) == 0 ) )
 {
 res = ETrue;
 tmp.Set( aLine.Right( aLine.Length() -
 KBoundaryMarkLength -
 iBoundary->Length() ) );
 if ( ( tmp.Length() >= KBoundaryMarkLength ) &&
 ( tmp.Left( KBoundaryMarkLength ) == KBoundaryMark ) )
 {
 aLast = ETrue;
 }
 }
 }
 }
 return res;
 }
 // -----------------------------------------------------------------------------
 // CDRMMessageParser::HandleFlContentL
 // -----------------------------------------------------------------------------
 //
 void CDRMMessageParser::HandleFlContentL()
 {
 __ASSERT_DEBUG( !( iState & EDCFFile ), User::Invariant() );
 if ( iRightsData )
 {
 HBufC8* cid( NULL );
 HBufC8* buf( NULL );
 // RO was found from DRM message.
 CreateCDCIDL( cid );
 CleanupStack::PushL( cid );
 buf = iRightsData;
 CleanupStack::PushL( buf );
 iRightsData = NULL;
 ProcessRightsDataL( *cid,
 *buf );
 CleanupStack::PopAndDestroy(); // buf
 CleanupStack::PopAndDestroy(); // cid
 }
 else
 {
 }
 }
 // -----------------------------------------------------------------------------
 // CDRMMessageParser::ProcessRightsData
 // Process DRM message -style rights object and fetch it to iRightsObject if
 // necessary.
 // -----------------------------------------------------------------------------
 //
 void CDRMMessageParser::ProcessRightsDataL(
 const TDesC8& aCID,
 const TDesC8& aData )
 {
 __ASSERT_DEBUG( !iRightsObject, User::Invariant() );
 TInt start = aData.Find(KRightsStartTag);
 TInt end = aData.LocateReverse('>');
 if ( start >= 0 && end > start )
 {
 TDRMUniqueID localID( 0 );
 CDrmRightsParser* parser( NULL );
 CDRMAsset* asset( NULL );
 RDRMRightsClient client;
 TPtrC8 ptr( &aData[start], end - start + 1 );
 TBuf8< KDCFKeySize > key;
 key.SetLength(KDCFKeySize);
 RPointerArray< CDRMRights > rights;
 TCleanupItem cleanup( DoResetAndDestroy, &rights );
 CleanupStack::PushL( cleanup );
 User::LeaveIfError( client.Connect() );
 CleanupClosePushL( client );
 parser = CDrmRightsParser::NewL();
 CleanupStack::PushL( parser );
 parser->ParseL( ptr, rights );
 if (rights.Count()==0)
-	{
+{
-	User::Leave(KErrCorrupt);
+User::Leave(KErrCorrupt);
-	}
+}
 client.GetRandomDataL(key);
 User::LeaveIfError( client.AddRecord(
 key,
 rights[0]->GetPermission(),
 aCID,
 localID) );
 iRightsObject = CDRMRights::NewL();
 asset = CDRMAsset::NewLC();
 asset->iUid = aCID.AllocL();
 iRightsObject->SetAssetL(*asset);
 iRightsObject->SetPermissionL(rights[0]->GetPermission());
 CleanupStack::PopAndDestroy( 4 ); // asset, parser, client, rights
 }
 else
 {
 SetBrokenStateL( KErrArgument );
 }
 }
 // -----------------------------------------------------------------------------
 // CDRMMessageParser::ProcessContentDataL
 // Handle DCF file's CID manipulation in "DCF in DRM message" case.
 // Send the data to EncryptUpdateL if encryption is needed.
 // -----------------------------------------------------------------------------
 //
 void CDRMMessageParser::ProcessContentDataL( TPtrC8& aData )
 {
 // -----------------------------------------------------------------------------
 //
 TBool CDRMMessageParser::ValidB64CharL( const TUint8 aChar )
 {
 // Allowed characters are '0'...'9', 'A'...'Z', 'a'...'z', '+', '/', '='
 if ( ( aChar >= 48 && aChar <= 57 ) ||
 ( aChar >= 65 && aChar <= 90 ) ||
 ( aChar >= 97 && aChar <= 122 ) ||
 ( aChar == 43 ) ||
 ( aChar == 47 ) ||
 ( aChar == 61 ) )
 {
 return ETrue;
 }
 if ( ( aChar != 0x0D ) && ( aChar != 0x0A ) )
 {
 SetBrokenStateL( KDRMMessageMalformed );
 }
 return EFalse;
 }
 // -----------------------------------------------------------------------------
 // DRMCommon::ProcessMessage
 //
 // -----------------------------------------------------------------------------
 EXPORT_C TInt CDRMMessageParser::ProcessMessage(
 HBufC8*& aDRMMessage)
 {
 TInt error( KErrNone );
 TRAP( error, DoProcessMessageL( aDRMMessage ) );
 return error;
 }
 // -----------------------------------------------------------------------------
 // DRMCommon::ProcessRightsObject
 // Processes a rights objects and saves it in the rights database.
 // -----------------------------------------------------------------------------
 EXPORT_C TInt CDRMMessageParser::ProcessRightsObject(
 const TDesC8& aRightsObject,
 RPointerArray<CDRMRights>& aRightsDetail)
 {
 TInt error( KErrNone );
 TRAP( error, DoProcessRightsObjectL( aRightsObject,
 aRightsDetail ) );
 return error;
 }
 void CDRMMessageParser::SetBit( TUint32 aBit )
 {
 iState |= aBit;
 }
 void CDRMMessageParser::ClearBit( TUint32 aBit )
 {
 iState &= ~aBit;
 }
 void CDRMMessageParser::Reset()
 {
 delete iDCFBuffer;
 iDCFBuffer = NULL;
 delete iDcfCreator;
 iDcfCreator = NULL;
 delete iRightsData;
 iRightsData = NULL;
 delete iRightsObject;
 iRightsObject = NULL;
 delete iBoundary;
 iBoundary = NULL;
 delete iContentType;
 iContentType = NULL;
 iInputBuffer.SetLength( 0 );
 iState = ESearchingBoundary;
 iDCFHeaderSize[ 0 ] = KMaxTUint32;
 iDCFHeaderSize[ 1 ] = KMaxTUint32;
 }
 {
 TDeleteFileData fileData;
 RFileWriteStream output;
 RFile file;
 TInt size( 0 );
 User::LeaveIfError( fileData.aFs.Connect() );
 CleanupClosePushL( fileData.aFs );
 TCleanupItem cleanup( DoDeleteFile, &fileData );
 CleanupStack::PushL( cleanup );
 #ifndef RD_MULTIPLE_DRIVE
 User::LeaveIfError( output.Temp( fileData.aFs,
 KTempPath,
 fileData.aName,
 EFileWrite ) );
 #else //RD_MULTIPLE_DRIVE
 TInt driveNumber( -1 );
 TChar driveLetter;
 DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );
-	fileData.aFs.DriveToChar( driveNumber, driveLetter );
+fileData.aFs.DriveToChar( driveNumber, driveLetter );
-	TFileName tempPath;
+TFileName tempPath;
-	tempPath.Format( KTempPath, (TUint)driveLetter );
+tempPath.Format( KTempPath, (TUint)driveLetter );
 User::LeaveIfError( output.Temp( fileData.aFs,
 tempPath,
 fileData.aName,
 EFileWrite ) );
 #endif
 CleanupClosePushL( output );
 InitializeMessageParserL( output );
 ProcessMessageDataL( *aDRMMessage );
 FinalizeMessageParserL();
 CleanupStack::PopAndDestroy(); // output
 User::LeaveIfError( file.Open( fileData.aFs, fileData.aName, EFileRead ) );
 CleanupClosePushL( file );
 User::LeaveIfError( file.Size( size ) );
 if ( size > aDRMMessage->Des().MaxSize() )
 {
 HBufC8* tmp( NULL );
 delete aDRMMessage;
 aDRMMessage = NULL;
 tmp = HBufC8::NewLC( size );
 TPtr8 data( tmp->Des() );
 User::LeaveIfError( file.Read( data ) );
 CleanupStack::Pop(); // tmp
 aDRMMessage = tmp;
 }
 else
 {
 TPtr8 data( aDRMMessage->Des() );
 User::LeaveIfError( file.Read( data ) );
 }
 CleanupStack::PopAndDestroy( 3 ); // file, cleanup, fileData.aFs
 }
 void CDRMMessageParser::DoProcessRightsObjectL(
 const TDesC8& aRightsObject,
 RPointerArray<CDRMRights>& aRightsDetail )
 {
 CDrmRightsParser* parser = NULL;
 TInt start;
 TInt end;
 TPtrC8 ptr(0, 0);
 start = aRightsObject.Find(KRightsStartTag);
 end = aRightsObject.LocateReverse('>');
 TCleanupItem cleanup( DoResetAndDestroy, &aRightsDetail );
 CleanupStack::PushL( cleanup );
 if ( start != KErrNotFound && end != KErrNotFound )
 {
 // xml
 parser = CDrmRightsParser::NewL();
 CleanupStack::PushL(parser);
 ptr.Set(&aRightsObject[start], end - start + 1);
 parser->ParseAndStoreL(ptr, aRightsDetail);
 if (aRightsDetail.Count() == 0)
 {
 User::Leave( KErrArgument );
 }
 CleanupStack::PopAndDestroy(); // parser
 }
 else if (start == KErrNotFound )
 {
 // wbxml
 parser = CDrmRightsParser::NewL(CDrmRightsParser::EWbxmlParser);
 CleanupStack::PushL(parser);
 parser->ParseAndStoreL(aRightsObject, aRightsDetail);
 if (aRightsDetail.Count() == 0)
 {
 User::Leave( KErrArgument );
 }
 CleanupStack::PopAndDestroy(); // parser
 }
 else
 {
 User::Leave( KErrArgument );
 }
 CleanupStack::Pop(); // cleanup
 }
 void CDRMMessageParser::DeletePermission()
 {
 if ( iRightsObject )
 {
 if ( !( iState & EFLContent ) )
 {
 HBufC8* URI = NULL;
 if ( !( iRightsObject->GetContentURI( URI ) ) )
 {
 __ASSERT_DEBUG( URI, User::Invariant() );
 RDRMRightsClient client;
 TInt error = client.Connect();
 if ( !error )
 {
 // Don't care if it fails.
 client.DeleteDbEntry( *URI, iRightsObject->GetLocalID() );
 client.Close();
 }
 delete URI;
 URI = NULL;
 }
 }
 delete iRightsObject;
 iRightsObject = NULL;
 }
 }
 void CDRMMessageParser::SetBrokenStateL( const TInt aError )
 {
 SetBit( EBroken );
 DeletePermission();
 User::Leave( aError );
 }
 void CDRMMessageParser::InitDCFBufferL()
 {
 User::LeaveIfError( client.Connect() );
 client.GetRandomDataL(id);
 CleanupStack::PopAndDestroy();
 des = KFLPrefix;
 for (TInt i = 0; i < KCDPlainIDLength; i++)
 {
 des.AppendNumFixedWidth( id[i], EDecimal, 1 );
 }
 des.Append( KFLSuffix );
 }
 TInt CDRMMessageParser::RetrieveFlRights()
 {
 __ASSERT_DEBUG( !iRightsObject, User::Invariant() );
 RDRMRightsClient client;
 TInt error( client.Connect() );
 if ( !error )
 {
 TRAP( error, EnsureFLRightsExistL( client, &iRightsObject ) );
 client.Close();
 }
 return error;
 }
 void CDRMMessageParser::ProcessDCFDataL( TPtrC8& aDCFData )
 {
 TBool doCommit( EFalse );
 // Loop until all available data is either cached or processed.
 // What happens is
 // - modify Content-URI
 // - modify DCF header part
 // - dump the rest of the available data to output.
 {
 //////////////////////////////////////////////////////////////////
 // Modify ContentURI.
 //////////////////////////////////////////////////////////////////
 FillDCFBufferL( aDCFData );
 if ( iDCFBuffer->Length() > 3 )
 {
 TInt pos = 0;
 TUint8* data = const_cast< TUint8* > ( iDCFBuffer->Ptr() );
 if ( data[ 0 ] != 1 )
 {
 SetBrokenStateL( KDRMMessageMalformed );
 }
 // Cache the data until
 // - version,
 // - ContentTypeLen,
 // - ContentURILen,
 // - ContentType and
 // - ContentURI
 // have been received.
 pos = data[ 1 ] + 3;
 if ( iDCFBuffer->Length() < pos + data[ 2 ] )
 {
 return;
 }
 // Sanity check. URI has to be more than four ("cid:") octets.
 if ( data[ 2 ] < 5 )
 {
 SetBrokenStateL( KDRMMessageMalformed );
 }
 if ( Mem::CompareF( &data[ pos ],
 KCIDStringLength,
 KCIDString().Ptr(),
 KCIDStringLength ) == 0 )
 {
 // The data length doesn't change, so Mem::Copy() is safe.
 Mem::Copy( &data[ pos ],
 KFLPrefix().Ptr(),
 KFLKPrefixLength );
 iOutputStream.WriteL( iDCFBuffer->Left( pos + data[ 2 ] ) );
 doCommit = ETrue;
 CompressDCFBuffer( pos + data[ 2 ] );
 SetBit( EDCFURIModified );
 }
 else
 {
 // Discard the broken DCF
 // URI is now modified. Modify DCF headers if necessary.
 //////////////////////////////////////////////////////////////////
 if ( !( iState & EDCFHeadersModified ) )
 {
 FillDCFBufferL( aDCFData );
 // Figure out how much data there is in the header part and/or
 // in the data part.
 if ( ( iDCFHeaderSize[ 0 ] == KMaxTUint32 ) &&
 ( iDCFHeaderSize[ 1 ] == KMaxTUint32 ) )
 {
 TUint8 used( 0 );
 // uintvar has 1...5 octets and we need two uintvars before
 // anything can be done. Still, there has to be at least
 // 12 octets of data in total to make the DCF legal. But here
 // we just check the two uintvars.
 if ( iDCFBuffer->Length() < 10 )
 {
 // Not enough data yet.
 // No need to flush aDCFData at this point, since it
 // simply cannot contain anything at this point.
 __ASSERT_DEBUG( !aDCFData.Length(), User::Invariant() );
 break;
 }
 // Read header field length & data length.
 for ( TUint8 count = 0; count < 2; ++count )
 {
 TInt size( 0 );
 TWspPrimitiveDecoder decoder(
 iDCFBuffer->Mid( used ) );
 size = decoder.UintVar( iDCFHeaderSize[ count ] );
 // Sanity check.
 if ( size < 1 || iDCFHeaderSize[ count ] >= KMaxTInt )
 {
 SetBrokenStateL( KDRMMessageMalformed );
 }
 used += size;
 }
 CompressDCFBuffer( used );
 }
 else
 {
 // We know the original header size now.
 // Wait until the whole header is read.
 if ( static_cast< TUint32 >( iDCFBuffer->Length() ) <
 iDCFHeaderSize[ 0 ] )
 {
 if ( !aDCFData.Length() )
 {
 // All available data is now processed.
 {
 TUint offset( 0 );
 TUint length( 0 );
 HBufC8* newHeader = NULL;
 if ( FindDCFHeader( KRightsIssuer,
 offset,
 length ) )
 {
 // The header field exists.
 TInt pos( 0 );
 TPtr8 trim( const_cast< TUint8* >(
 iDCFBuffer->Ptr() ) + offset,
 length,
 length );
 iDCFHeaderSize[ 0 ] -= length; // remove old data.
 // No colon, no header value.
 pos = trim.Find( KColon );
 if ( pos > 0 )
 {
 trim.Set( const_cast< TUint8* >( trim.Ptr() ) + pos + 1,
 trim.Length() - pos - 1,
 trim.Length() - pos - 1 );
 // Skip whitespaces
 trim.TrimLeft();
 trim.TrimRight();
 if ( trim.Length() )
 {
 // Something to process
 newHeader = EncryptDCFFieldLC( trim );
 iDCFHeaderSize[ 0 ] += KRightsIssuer().Length();
 iDCFHeaderSize[ 0 ] += newHeader->Length();
 iDCFHeaderSize[ 0 ] += 3; // ":" and CRLF
 }
 }
 }
 // Write the uintvars to output.
 for ( TUint8 loop = 0; loop < 2; ++loop )
 {
 TWspPrimitiveEncoder encoder;
 HBufC8* var( encoder.UintVarL( iDCFHeaderSize[ loop ] ) );
 CleanupStack::PushL( var );
 iOutputStream.WriteL( *var );
 CleanupStack::PopAndDestroy(); // var
 }
 // Dump the header data to output stream.
 iOutputStream.WriteL( iDCFBuffer->Left( offset ) );
 if ( newHeader )
 {
 iOutputStream.WriteL( KRightsIssuer );
 iOutputStream.WriteL( KColon );
 iOutputStream.WriteL( *newHeader );
 CleanupStack::PopAndDestroy(); // newHeader
 newHeader = NULL;
 iOutputStream.WriteL( KEndLine );
 }
 iOutputStream.WriteL(
 iDCFBuffer->Right( iDCFBuffer->Length() -
 offset -
 length ) );
 doCommit = ETrue;
 CompressDCFBuffer( iDCFBuffer->Length() );
 SetBit( EDCFHeadersModified );
 }
 }
 }
 {
 // Dump the rest of the data.
 __ASSERT_DEBUG( !( iDCFBuffer->Length() ), User::Invariant() );
 iOutputStream.WriteL( aDCFData );
 aDCFData.Set( NULL, 0 );
 doCommit = ETrue;
 }
 }
 }
 {
 TInt size( 0 );
 if ( iDCFBuffer->Length() == iDCFBuffer->Des().MaxSize() )
 {
 HBufC8* ptr = iDCFBuffer->ReAlloc( iDCFBuffer->Length() +
 KDefaultInputBufferSize );
 if ( !ptr )
 {
 SetBrokenStateL( KErrNoMemory );
 }
 iDCFBuffer = ptr;
 }
 size = Min( iDCFBuffer->Des().MaxSize() - iDCFBuffer->Length(),
 aData.Length() );
 iDCFBuffer->Des().Append( aData.Left( size ) );
 aData.Set( aData.Right( aData.Length() - size ) );
 }
 }
 void CDRMMessageParser::CompressDCFBuffer( const TInt aHowMuch )
 {
 __ASSERT_DEBUG( aHowMuch <= iDCFBuffer->Des().MaxSize(), User::Invariant() );
 *iDCFBuffer = iDCFBuffer->Des().Mid( aHowMuch );
 }
 TBool CDRMMessageParser::FindDCFHeader( const TDesC8& aString,
 TUint& aOffset,
 TUint& aLength )
 {
 TPtrC8 des( const_cast< TUint8* >( iDCFBuffer->Ptr() ),
 Min( iDCFBuffer->Length(), iDCFHeaderSize[ 0 ] ) );
 aOffset = 0;
 aLength = 0;
 }
 else
 {
 pos += KEndLineLength;
 }
 if ( ( pos < aString.Length() ) ||
 ( des.Left( aString.Length() ).CompareF( aString ) != 0 ) )
 {
 // Skip the line, since this can't be the one we're looking for.
 des.Set( des.Right( des.Length() -
 pos ) );
 }
 else
 {
 aOffset = des.Ptr() - iDCFBuffer->Ptr();
 aLength = pos;
 return ETrue;
 }
 }
 // Never reached.
 return EFalse;
 }
 void CDRMMessageParser::EnsureFLRightsExistL(
 RDRMRightsClient& aClient,
 CDRMRights** aOutput )
 {
 HBufC8* cid( NULL );
 CDRMRights* perm( NULL );
 RPointerArray< CDRMPermission > rights( 1 );
 TCleanupItem cleanup( DoResetAndDestroy2, &rights );
 CleanupStack::PushL( cleanup );
 User::LeaveIfError( aClient.ForwardLockURI( cid ) );
 CleanupStack::PushL( cid );
 TRAPD( error, aClient.GetDBEntriesL( *cid, rights ) );
 if ( !error )
 {
 ConvertPermissionL( perm, *( rights[ 0 ] ), *cid );
 // No need to pushl 'perm' into cleanup stack.
 }
 else if ( error == KErrCANoRights )
 {
 HBufC8* fl( NULL );
 RPointerArray< CDRMRights > rightslist( 1 );
 TCleanupItem cleanup2( DoResetAndDestroy, &rightslist );
 CleanupStack::PushL( cleanup2 );
 fl = HBufC8::NewLC( KFLROSize + cid->Length() );
 *fl = KROPart1;
 fl->Des().Append( *cid );
 fl->Des().Append( KROPart2 );
 User::LeaveIfError( ProcessRightsObject( *fl, rightslist ) );
 CleanupStack::PopAndDestroy(); // fl
 perm = rightslist[ 0 ];
 rightslist.Remove( 0 );
 CleanupStack::PopAndDestroy(); // cleanup2
 error = KErrNone;
 }
 CleanupStack::PopAndDestroy(); // cid
 if ( !error )
 {
 // There is something.
 else
 {
 delete perm; perm = NULL;
 }
 }
 CleanupStack::PopAndDestroy(); // cleanup
 }
 HBufC8* CDRMMessageParser::EncryptDCFFieldLC( const TDesC8& aOldHeader )
 {
 HBufC8* res = NULL;
 RDRMRightsClient client;
 User::LeaveIfError( client.Connect() );
 CleanupClosePushL( client );
 // Make sure FL rights exists.
 EnsureFLRightsExistL( client, NULL );
 User::LeaveIfError(
 client.EncodeRightsIssuerField( aOldHeader, res ) );
 CleanupStack::PopAndDestroy(); // client
 CleanupStack::PushL( res );
 return res;
 }
 // ========================== OTHER EXPORTED FUNCTIONS =========================
 //  End of File

changeset 23	493788a4a8a4
parent 0	95b198f216e5
child 32	457cd4423b8c