FCL/sf/mw/drm: comparison omadrm/drmengine/dcf/src/Oma1Dcf.cpp

equal deleted inserted replaced

-:e16d72588c28
+:8a03a285ab14
 // INCLUDE FILES
 #include <e32base.h>
 #include <f32file.h>
 #include <utf.h>
-#include <WSPDecoder.h>
+#include <wspdecoder.h>
 #include "Oma1Dcf.h"
 #include "DRMRightsClient.h"
 #include <centralrepository.h>
-#include <UTF.h>
 #include "DrmUtilityInternalcrkeys.h"      // Cenrep extension for OmaBased
 // LOCAL CONSTANTS AND MACROS
 _LIT8(KMimeApplication, "application");
 CRepository* repository( NULL );
 RBuf bOmaBasedMimeType;
 HBufC8* mimetype = NULL;
 CleanupClosePushL(bOmaBasedMimeType);
 bOmaBasedMimeType.CreateL( KCenRepDataLength );
 repository = CRepository::NewL( KCRUidOmaBased );
 CleanupStack::PushL( repository );
 User::LeaveIfError(repository->Get( KOmaBasedMimeType, bOmaBasedMimeType ));
 mimetype = CnvUtfConverter::ConvertFromUnicodeToUtf8L( bOmaBasedMimeType );
 CleanupStack::PopAndDestroy( repository );
 CleanupStack::PopAndDestroy();
 return mimetype;
 }
 // -----------------------------------------------------------------------------
 // COma1Dcf::NewL
 // Two-phased constructor.
 // -----------------------------------------------------------------------------
 //
 EXPORT_C COma1Dcf* COma1Dcf::NewL(const RFile& aFile)
 {
 COma1Dcf* self = new(ELeave) COma1Dcf;
 CleanupStack::PushL(self);
 self->ConstructL(aFile);
 CleanupStack::Pop();
 return self;
 }
 // -----------------------------------------------------------------------------
 // COma1Dcf::
 //
 // -----------------------------------------------------------------------------
 //
 EXPORT_C COma1Dcf* COma1Dcf::NewL(const TDesC8& aMemoryBlock)
 {
 COma1Dcf* self = new(ELeave) COma1Dcf;
 CleanupStack::PushL(self);
 self->ConstructL(aMemoryBlock);
 CleanupStack::Pop();
 return self;
 }
 // -----------------------------------------------------------------------------
 // COma1Dcf::
 //
 // -----------------------------------------------------------------------------
 //
 EXPORT_C COma1Dcf::~COma1Dcf()
 {
 delete iHeaders;
 }
 // -----------------------------------------------------------------------------
 // COma1Dcf::
 //
 // -----------------------------------------------------------------------------
 //
 TInt COma1Dcf::ReadHeaderL(const TDesC8& aMemoryBlock)
 {
 TInt r = KErrNone;
 TInt mimeLength = 0;
 TInt fieldLength = 0;
 TBuf8<10> lengthFields;
 TUint32 length;
 TPtr8 ptr(NULL,0,0);
 if (aMemoryBlock.Length()<3)
 {
 User::Leave(KErrArgument);
 }
 iVersion = aMemoryBlock[0];
 if (iVersion!=1)
 {
 // for OMA Version 1, DCF version must be 1
 User::Leave(KErrArgument);
 }
 mimeLength = aMemoryBlock[1];
 cidLength = aMemoryBlock[2];
 if (mimeLength + cidLength + 3 + 5 + 5 > aMemoryBlock.Length())
 {
 User::Leave(KErrArgument);
 }
 if (mimeLength!=0)
 {
 iMimeType = aMemoryBlock.Mid(3, mimeLength).AllocL();
 ptr.Set(iMimeType->Des());
 r = ptr.FindF(_L8("/"));
 }
 else
 {
 User::Leave(KErrArgument);
 }
 if (cidLength!=0)
 {
 iContentID = aMemoryBlock.Mid(3 + mimeLength, cidLength).AllocL();
 }
 else
 {
 User::Leave(KErrArgument);
 }
 lengthFields.Copy(aMemoryBlock.Mid(3 + mimeLength + cidLength, 10));
 TWspPrimitiveDecoder decoder(lengthFields);
 fieldLength = decoder.UintVar(length);
 if( fieldLength < 0 )
 {
 User::Leave(KErrArgument);
 }
 iHeaderLength = length;
 fieldLength += decoder.UintVar(length);
 if( fieldLength < 0 )
 {
 User::Leave(KErrArgument);
 }
 iDataLength = length;
 iOffset = 3 + mimeLength + cidLength + fieldLength + iHeaderLength;
 if (iDataLength == 0)
 {
 iDataLength = aMemoryBlock.Length() - iOffset;
 return r;
 }
 // -----------------------------------------------------------------------------
 // COma1Dcf::ReadHeaderValuesL
 //
 // -----------------------------------------------------------------------------
 //
 void COma1Dcf::ReadHeaderValuesL(void)
 {
 TPtrC8 ptr(NULL, 0);
 if (GetHeaderL(KRightsIssuer, ptr) == KErrNone)
 {
 if( iRightsIssuerURL )
 {
 delete iRightsIssuerURL;
 }
 iRightsIssuerURL = ptr.AllocL();
 }
 if (GetHeaderL(KContentName, ptr) == KErrNone)
 {
 if( iTitle )
 {
 delete iTitle;
 iTitle = NULL;
 }
 iTitle = ptr.AllocL();
 }
 if (GetHeaderL(KContentDescription, ptr) == KErrNone)
 {
 if( iDescription )
 {
 delete iDescription;
 iDescription = NULL;
 }
 iDescription = ptr.AllocL();
 }
 if (GetHeaderL(KIconURI, ptr) == KErrNone)
 {
 if( iIconUri )
 {
 delete iIconUri;
 iIconUri = NULL;
 }
 iIconUri = ptr.AllocL();
 }
 }
 // -----------------------------------------------------------------------------
 // COma1Dcf::
 //
 // -----------------------------------------------------------------------------
 //
 TInt COma1Dcf::ReadHeaderL(void)
 {
 TInt r = KErrNone;
 iContentID = HBufC8::NewMax(cidLength);
 User::LeaveIfNull(iContentID);
 p.Set(iContentID->Des());
 iFile.Read(p, cidLength);
 pos = 0;
 iFile.Seek(ESeekCurrent, pos);
 iFile.Read(lengthFields);
 TWspPrimitiveDecoder decoder(lengthFields);
 fieldLength = decoder.UintVar(length);
 fieldLength += decoder.UintVar(length);
 if( fieldLength < 0 )
 {
 User::Leave(KErrArgument);
 }
 iDataLength = length;
 iOffset = pos + fieldLength + iHeaderLength;
 if (iDataLength == 0)
 {
 iDataLength = size - iOffset;
 return r;
 }
 // -----------------------------------------------------------------------------
 // COma1Dcf::
 //
 // -----------------------------------------------------------------------------
 //
 EXPORT_C TBool COma1Dcf::IsValidDcf(const TDesC8& aDcfFragment)
 {
 TPtrC8 mimeType;
 mimeType.CompareF(KMimeMultipart) == 0 ||
 aDcfFragment.Mid(3, 2).CompareF(KXHeader) == 0)
 {
 r = ETrue;
 // Check for specific mimetype
 TRAP( error, omaBasedBuf = FetchOmaBasedInfoL() );
 if( !error )
 {
 mimeType.Set(aDcfFragment.Mid(3,
 omaBasedBuf->Length()));
 if (mimeType.CompareF( *omaBasedBuf ) == 0)
 {
 r = EFalse;
 }
 }
 return r;
 }
 // -----------------------------------------------------------------------------
 // COma1Dcf::
 //
 // -----------------------------------------------------------------------------
 //
 TInt COma1Dcf::CheckUniqueId(const TDesC& aUniqueId)
-	{
+{
-	TInt r = CDcfCommon::CheckUniqueId(aUniqueId);
+TInt r = CDcfCommon::CheckUniqueId(aUniqueId);
-	if (r == KErrNotFound)
+if (r == KErrNotFound)
-	    {
+{
-	    HBufC8* id = NULL;
+HBufC8* id = NULL;
-	TRAPD(err, id = CnvUtfConverter::ConvertFromUnicodeToUtf8L(aUniqueId));
+TRAPD(err, id = CnvUtfConverter::ConvertFromUnicodeToUtf8L(aUniqueId));
-	if (err == KErrNone)
+if (err == KErrNone)
-	    {
+{
-	    if (iContentID->Compare(*id) == 0)
+if (iContentID->Compare(*id) == 0)
-		    {
+{
-		    r = 0;
+r = 0;
-		    }
+}
 }
 else
 {
 r = err;
 }
-	delete id;
+delete id;
-	}
+}
-	return r;
+return r;
-	}
+}
 // -----------------------------------------------------------------------------
 // COma1Dcf::
 //
 // -----------------------------------------------------------------------------
 //
 TInt COma1Dcf::OpenPart(const TDesC& aUniqueId)
-	{
+{
-	return OpenPart(CheckUniqueId(aUniqueId));
+return OpenPart(CheckUniqueId(aUniqueId));
-	}
+}
 // -----------------------------------------------------------------------------
 // COma1Dcf::
 //
 // -----------------------------------------------------------------------------
 //
 TInt COma1Dcf::OpenPart(TInt aPart)
-	{
+{
-	if (aPart == 0)
+if (aPart == 0)
-		{
+{
-		return KErrNone;
+return KErrNone;
-		}
+}
-	else
+else
-		{
+{
-		return KErrNotFound;
+return KErrNotFound;
-		}
+}
-	}
+}
 // -----------------------------------------------------------------------------
 // COma1Dcf::
 //
 // -----------------------------------------------------------------------------
 //
 void COma1Dcf::GetPartIdsL(RPointerArray<HBufC8>& aPartList)
 {
 aPartList.ResetAndDestroy();
 aPartList.AppendL(iContentID->Des().AllocL());
 }
 // -----------------------------------------------------------------------------
 // COma1Dcf::GetHeaderL
 //
 // -----------------------------------------------------------------------------
 //
 EXPORT_C TInt COma1Dcf::GetHeaderL(
 const TDesC8& aHeaderName,
 TPtrC8& aHeaderValue)
 {
 TInt i;
 TInt j;
 TPtrC8 ptr( iHeaders->Des() );
 // Add Room for CRLF and Semicolon:
 HBufC8* buffer = HBufC8::NewMaxLC( aHeaderName.Length() + 3 );
 TPtr8 searchBuf( const_cast<TUint8*>(buffer->Ptr()), 0, buffer->Des().MaxSize() );
 searchBuf.Copy(aHeaderName);
 searchBuf.Append(KColon);
 // First see if the
 i = ptr.Find(searchBuf);
 if( i < 0 )
 {
 CleanupStack::PopAndDestroy(); // buffer
 return KErrNotFound;
 }
 if( i > 0 )
 {
 // if it's not the first one, use the search buffer:
 // Create the search buffer
 searchBuf.Copy(KEndLine);
 searchBuf.Append(aHeaderName);
 searchBuf.Append(KColon);
 // First see if the
 i = ptr.Find(searchBuf);
 if ( i < 0 )
 {
 CleanupStack::PopAndDestroy(); // buffer
 return KErrNotFound;
 }
 }
 // Move search buffer
 i += searchBuf.Length();
 j = ptr.Mid(i).Find(KEndLine);
 if( j < 0 )
 {
 CleanupStack::PopAndDestroy(); // buffer
 return KErrNotFound;
 }
 aHeaderValue.Set( ptr.Mid(i, j) );
 CleanupStack::PopAndDestroy(); // buffer
 return KErrNone;
 }
 //  End of File

branch	RCL_3
changeset 18	8a03a285ab14
parent 0	95b198f216e5
child 84	b09186059647