FCL/sf/mw/drm: comparison omadrm/drmengine/legacy/src/DRMCommon.cpp

equal deleted inserted replaced

-:e16d72588c28
+:8a03a285ab14
 // INCLUDE FILES
 #include <f32file.h>
 #include <s32file.h>
 #include <apmstd.h>
-#include <WSPDecoder.h>
+#include <wspdecoder.h>
-#include <WSPEncoder.h>
+#include <wspencoder.h>
 #include <barsc.h>
 #include <barsread.h>
 #include <DRMCommon.rsg>
 #ifdef RD_MULTIPLE_DRIVE
-#include <DriveInfo.h>
+#include <driveinfo.h>
 #endif
 #include "DRMCommon.h"
 #include "DRMRightsClient.h"
 #include "DcfCommon.h"
 #include "Oma1Dcf.h"
-#include "Oma2Dcf.h"
+#include "oma2dcf.h"
-#include "DRMPermission.h"
+#include "DrmPermission.h"
 // EXTERNAL DATA STRUCTURES
 // EXTERNAL FUNCTION PROTOTYPES
 // CONSTANTS
 const TInt KBufferSize = 1024;
 _LIT8(KRiUrl, "Rights-Issuer");
 // 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);
 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);
 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 ===============================
 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.
 // -----------------------------------------------------------------------------
 CDRMRights*& aRightsObject)
 {
 CDRMPermission* permission = NULL;
 RDRMRightsClient client;
 HBufC8* uri = NULL;
 User::LeaveIfError( client.Connect() );
 CleanupClosePushL( client );
 if ( aConstraints == 0 )
 {
 }
 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;
 CleanupStack::PopAndDestroy(2); // file, fs
 return r;
 }
 // -----------------------------------------------------------------------------
 //
 //
 // Parameters:
 //
 // Returns:
 // -----------------------------------------------------------------------------
 LOCAL_C TInt IsProtectedFileL(
 RFile& aFileHandle,
 TBool& aProtection)
 {
 TInt r = KErrNone;
 CDcfCommon* dcf = NULL;
 }
 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;
 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;
 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
 {
 aMIMEType = NULL;
 }
 // Insert domain RO if it exists
 if (dcf2 != NULL && dcf2->iRightsObjects.Count() > 0)
 {
 // Creating a CData object will insert the domain RO into the RDB
 data = CData::NewL(file, KDefaultContentObject);
 delete data;
 }
 if (dcf->iVersion == EOma1Dcf && !dcf->iPlainTextLengthValid)
 {
 CalculatePaddingL(static_cast<COma1Dcf*>(dcf));
 }
 CleanupStack::PopAndDestroy(2); // file, fs
 return r;
 }
 // -----------------------------------------------------------------------------
 //
 //
 // Parameters:
 //
 // Returns:
 // -----------------------------------------------------------------------------
 TInt GetFileInfoL(
 RFile& aFileHandle,
 DRMCommon::TContentProtection& aProtection,
 HBufC8*& aMIMEType,
 HBufC8*& aContentURI,
 TUint& aDataLength)
 {
 TInt r = KErrNone;
 CDcfCommon* dcf = NULL;
 COma2Dcf* dcf2 = NULL;
 CData* data = NULL;
 TInt initialPos = 0;
 // Store the initial filePos
 User::LeaveIfError(aFileHandle.Seek(ESeekCurrent, initialPos));
 aProtection = DRMCommon::ENoDCFFile;
 dcf = CDcfCommon::NewL(aFileHandle);
 if (dcf != NULL)
 {
 // Creating a CData object will insert the domain RO into the RDB
 data = CData::NewL(aFileHandle, KDefaultContentObject);
 delete data;
 }
 if (dcf->iVersion == EOma1Dcf && !dcf->iPlainTextLengthValid)
 {
 CalculatePaddingL(static_cast<COma1Dcf*>(dcf));
 }
 User::LeaveIfError(aFileHandle.Seek(ESeekStart, initialPos));
 return r;
 }
 // -----------------------------------------------------------------------------
 //
 //
 // Parameters:
 //
 // Returns:
 // -----------------------------------------------------------------------------
 TInt CheckFileRightsL(
 const TDesC& aFileName,
 TUint32 aRightsSpec)
 {
 RFs fs;
 RFile file;
 CDcfCommon* dcf = NULL;
 TInt r = DRMCommon::ENoRights;
 RDRMRightsClient client;
 TUint32 reason = 0;
 User::LeaveIfError(fs.Connect());
 CleanupClosePushL(fs);
 r = GetFileHandleRead(fs, file, aFileName);
 User::LeaveIfError(r);
 CleanupClosePushL(file);
 dcf = CDcfCommon::NewL(file);
 if ( dcf == NULL )
 {
 User::Leave(KErrArgument);
 }
 CleanupStack::PopAndDestroy(4); // dcf, file, client, fs
 return r;
 }
 // -----------------------------------------------------------------------------
 //
 //
 // Parameters:
 //
 // Returns:
 // -----------------------------------------------------------------------------
 TInt CheckFileRightsL(
 RFile& aFileHandle,
 TUint32 aRightsSpec)
 {
 CDcfCommon* dcf = NULL;
 TInt r = DRMCommon::ENoRights;
 RDRMRightsClient client;
 TUint32 reason = 0;
 dcf = CDcfCommon::NewL(aFileHandle);
 if ( dcf == NULL )
 {
 User::Leave(KErrArgument);
 }
 CleanupStack::PopAndDestroy(2); // dcf, file
 return r;
 }
 // -----------------------------------------------------------------------------
 //
 //
 // Parameters:
 //
 // Returns:
 // -----------------------------------------------------------------------------
 void GetSingleRightsObjectL(
 const TDesC8& aContentURI,
 TUint32 aLocalID,
 CDRMRights*& aRightsObject)
 {
 RDRMRightsClient client;
 CDRMPermission* p = NULL;
 CDRMAsset* a = NULL;
 aRightsObject = NULL;
 User::LeaveIfError(client.Connect());
 CleanupClosePushL(client);
 aRightsObject = CDRMRights::NewL();
 CleanupStack::PushL(aRightsObject);
 p = client.GetDbEntryL(aContentURI, aLocalID);
 CleanupStack::PushL(p);
 aRightsObject->SetPermissionL(*p);
 CleanupStack::PopAndDestroy(); // p
 a = CDRMAsset::NewLC();
 aRightsObject->SetAssetL(*a);
 CleanupStack::PopAndDestroy();
 aRightsObject->SetContentURIAndLocalID(aContentURI.AllocL(), aLocalID);
 CleanupStack::Pop(); // aRightsObject
 CleanupStack::PopAndDestroy(); // client
 }
 // -----------------------------------------------------------------------------
 //
 //
 // Parameters:
 //
 // Returns:
 // -----------------------------------------------------------------------------
 void GetDetailedContentRightsL(
 const TDesC8& aContentURI,
 RPointerArray<CDRMRights>*& aRightsList)
 {
 RDRMRightsClient client;
 RPointerArray<CDRMPermission> rights;
 CDRMRights* ro = NULL;
 CDRMAsset* a  = NULL;
 TInt i;
 // Need a temporary pointer
 HBufC8* contentId = NULL;
 aRightsList = NULL;
 User::LeaveIfError(client.Connect());
 CleanupClosePushL(client);
 client.GetDBEntriesL(aContentURI, rights);
 CleanupStack::Pop(2); // aRightsList ( two items )
 CleanupStack::PopAndDestroy(2); // rights, client
 }
 // -----------------------------------------------------------------------------
 //
 //
 // Parameters:
 //
 // Returns:
 // -----------------------------------------------------------------------------
 void GetDetailedFileRightsL(
 const TDesC& aFileName,
 RPointerArray<CDRMRights>*& aRightsList)
 {
 CDcfCommon* dcf = NULL;
 RFile file;
 RFs fs;
 TInt r = KErrNone;
 User::LeaveIfError(fs.Connect());
 CleanupClosePushL(fs);
 r = GetFileHandleRead( fs, file, aFileName );
 User::LeaveIfError(r);
 CleanupClosePushL(file);
 dcf = CDcfCommon::NewL(file);
 if (dcf == NULL)
 {
 User::Leave(KErrArgument);
 }
 CleanupStack::PushL(dcf);
 GetDetailedContentRightsL(*dcf->iContentID, aRightsList);
 CleanupStack::PopAndDestroy(3); // dcf, file, client
 }
 // -----------------------------------------------------------------------------
 //
 //
 // Parameters:
 //
 // Returns:
 // -----------------------------------------------------------------------------
 void GetDetailedFileRightsL(
 RFile& aFileHandle,
 RPointerArray<CDRMRights>*& aRightsList)
 {
 CDcfCommon* dcf = NULL;
 dcf = CDcfCommon::NewL(aFileHandle);
 if (dcf == NULL)
 {
 User::Leave(KErrArgument);
 }
 GetDetailedContentRightsL(*dcf->iContentID, aRightsList);
 CleanupStack::PopAndDestroy(); // dcf
 }
 // -----------------------------------------------------------------------------
 //
 //
 // Parameters:
 //
 // Returns:
 // -----------------------------------------------------------------------------
 LOCAL_C void  GetNewHeaderBufferL(
 HBufC8*& aOldHeaderBuf,
 const TDesC8& aHeaderName,
 const TDesC8& aHeaderValue,
 HBufC8*& aNewHeaderBuf
 )
 {
 TInt oldHeaderValueLength = 0;
 TInt offset = 0;
 TPtr8 headerPtr(aOldHeaderBuf->Des());
 TPtr8 headerNamePtr(NULL, 0, 0);
 TPtr8 newHeaderPtr(NULL, 0, 0);
 HBufC8* headerName = HBufC8::NewL(aHeaderName.Length() + 1);
 // Find the position of the text in the header
 headerNamePtr.Set(headerName->Des());
 headerNamePtr.Copy(aHeaderName);
 headerNamePtr.Append(KHeaderNameEnding);
 aHeaderValue.Length());
 newHeaderPtr.Set(aNewHeaderBuf->Des());
 newHeaderPtr.Copy(headerPtr.Left(offset + aHeaderName.Length() + 1));
 newHeaderPtr.Append(aHeaderValue);
 newHeaderPtr.Append(headerPtr.Right(headerPtr.Length() -
 (offset + aHeaderName.Length() + 1 + oldHeaderValueLength)));
 }
 else
 {
 aNewHeaderBuf = HBufC8::NewL(headerPtr.Length() + aHeaderName.Length() +
 aHeaderValue.Length() + 3);
 newHeaderPtr.Copy(headerPtr);
 newHeaderPtr.Append(aHeaderName);
 newHeaderPtr.Append(KHeaderNameEnding);
 newHeaderPtr.Append(aHeaderValue);
 newHeaderPtr.Append(KHeaderEnding);
 }
 }
 // -----------------------------------------------------------------------------
 //
 //
 // Parameters:
 //
 // Returns:
 // -----------------------------------------------------------------------------
 TPtrC tempFilePath;
 HBufC8* buffer = NULL;
 RFileWriteStream temp;
 TPtr8 ptr(NULL, 0, 0);
 TInt offset = 0;
 // Find the path of the file to be modified and put the tempfile
 // into that directory
 tempFilePath.Set(aOriginalFileName.Left(
 aOriginalFileName.LocateReverse('\\') + 1));
 User::LeaveIfError(temp.Temp(aFs, tempFilePath, aTempFileName, EFileWrite));
 CleanupClosePushL( temp );
 temp.WriteUint8L(1);
 temp.WriteUint8L(aDcf.iMimeType->Length());
 temp.WriteUint8L(aDcf.iContentID->Length());
 temp.WriteL(*aDcf.iMimeType);
 temp.WriteL(*aDcf.iContentID);
 buffer = HBufC8::NewLC(KBufferSize);
 do
 {
 ptr.Set(buffer->Des());
 ptr.SetLength(0);
 aOriginalFile.Read(ptr);
 if (ptr.Length() > 0)
 {
 temp.WriteL(ptr);
 }
 }
 while (ptr.Length() > 0);
 temp.CommitL();
 CleanupStack::PopAndDestroy(); // temp
 CleanupStack::PopAndDestroy(); //buffer
 }
 // -----------------------------------------------------------------------------
 //
 //
 // Parameters:
 //
 // Returns:
 // -----------------------------------------------------------------------------
 RFileWriteStream orig;
 TFileName tempFile;
 TPtr8 ptr(NULL, 0, 0);
 TInt offset = 0;
 TInt fileSize = 0;
 // Find the path of the file to be modified and put the tempfile
 // into that directory
 tempFilePath.Set(_L("C:\\"));
 User::LeaveIfError( temp.Temp( aFs, tempFilePath, tempFile,
 EFileWrite));
 CleanupClosePushL( temp );
 temp.WriteUint8L(1);
 temp.WriteUint8L(aDcf.iMimeType->Length());
 temp.WriteUint8L(aDcf.iContentID->Length());
 temp.WriteL(*aDcf.iMimeType);
 temp.WriteL(*aDcf.iContentID);
 buffer = HBufC8::NewLC(KBufferSize);
 do
 {
 ptr.Set(buffer->Des());
 ptr.SetLength(0);
 aOriginalFile.Read(ptr);
 if (ptr.Length() > 0)
 {
 temp.WriteL(ptr);
 }
 }
 while (ptr.Length() > 0);
 temp.CommitL();
 CleanupStack::PopAndDestroy(2); //buffer, temp
 // Get the size of the temp file
 User::LeaveIfError( tempFileHandle.Open( aFs, tempFile, EFileRead ));
 CleanupClosePushL( tempFileHandle );
 tempFileHandle.Size( fileSize );
 // Set the fileSize of the original file
 User::LeaveIfError( aOriginalFile.SetSize( fileSize ) );
 offset = 0;
 User::LeaveIfError( tempFileHandle.Seek( ESeekStart, offset ) );
 orig.Attach( aOriginalFile );
 CleanupClosePushL( orig );
 buffer = HBufC8::NewLC(KBufferSize);
 // Copy the file over because we can't use other copy things:
 do
 {
 ptr.Set(buffer->Des());
 ptr.SetLength(0);
 tempFileHandle.Read(ptr);
 if (ptr.Length() > 0)
 {
 orig.WriteL(ptr);
 }
 }
 while (ptr.Length() > 0);
 // Write the changes
 orig.CommitL();
 // close the tempfile
 CleanupStack::PopAndDestroy(3); // buffer, tempFileHandle, orig
 // Delete the temp file
 User::LeaveIfError( aFs.Delete( tempFile ) );
 }
 // -----------------------------------------------------------------------------
 //
 //
 // Parameters:
 //
 // Returns:
 // -----------------------------------------------------------------------------
 LOCAL_C void SetFileHeaderL(
 const TDesC16& aFileName,
 const TDesC8& aHeaderName,
 const TDesC8& aHeaderValue)
 {
 __UHEAP_MARK;
 TFileName tempFileName;
 HBufC8* newHeaderBuf = NULL;
 CleanupClosePushL(fs);
 User::LeaveIfError( GetFileHandleRead( fs, file, aFileName ) );
 CleanupClosePushL(file);
 dcf = COma1Dcf::NewL(file);
 CleanupStack::PushL(dcf);
 GetNewHeaderBufferL(dcf->iHeaders, aHeaderName, aHeaderValue, newHeaderBuf);
 delete dcf->iHeaders;
 dcf->iHeaders = newHeaderBuf;
 dcf->iHeaderLength = newHeaderBuf->Length();
 WriteNewFileL( fs, file, aFileName, *dcf, tempFileName );
 CleanupStack::PopAndDestroy(2); // file, dcf
 User::LeaveIfError( fs.Replace( tempFileName, aFileName ) );
 CleanupStack::PopAndDestroy(); // fs
 __UHEAP_MARKEND;
 }
 // -----------------------------------------------------------------------------
 //
 //
 // Parameters:
 //
 // Returns:
 // -----------------------------------------------------------------------------
 LOCAL_C void SetFileHeaderL(
 RFile& aFileHandle,
 const TDesC8& aHeaderName,
 const TDesC8& aHeaderValue)
 {
 HBufC8* newHeaderBuf = NULL;
 COma1Dcf* dcf = NULL;
 RFs fs;
 User::LeaveIfError(fs.Connect());
 CleanupClosePushL( fs );
 dcf = COma1Dcf::NewL(aFileHandle);
 if (dcf == NULL)
 {
 User::Leave(KErrArgument);
 }
 WriteNewFileL(fs, aFileHandle, *dcf);
 CleanupStack::PopAndDestroy(2); // dcf, fs
 }
 // -----------------------------------------------------------------------------
 //
 //
 // Parameters:
 //
 // Returns:
 // -----------------------------------------------------------------------------
 void SetContentHeaderL(
 HBufC8*& aContent,
 const TDesC8& aHeaderName,
 const TDesC8& aHeaderValue)
 {
 HBufC8* newHeaderBuf = NULL;
 HBufC8* newContent = NULL;
 HBufC8* buffer;
 delete aContent;
 aContent = newContent;
 }
 // -----------------------------------------------------------------------------
 //
 //
 // Parameters:
 //
 // Returns:
 // -----------------------------------------------------------------------------
 void GetHeaderL(
 const TDesC8& aContent,
 const TDesC8& aHeaderName,
 HBufC8*& aHeaderValue)
 {
 TInt i;
 TInt j;
 TPtrC8 ptr( aContent );
 // 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(KHeaderNameEnding);
 // First see if the
 i = ptr.Find(searchBuf);
 User::LeaveIfError( i );
 if( i > 0 )
 {
 // if it's not the first one, use the search buffer:
 // Create the search buffer
 searchBuf.Copy(KHeaderEnding);
 searchBuf.Append(aHeaderName);
 searchBuf.Append(KHeaderNameEnding);
 // First see if the
 i = ptr.Find(searchBuf);
 User::LeaveIfError( i );
 }
 // Move search buffer
 i += searchBuf.Length();
 j = ptr.Mid(i).Find(KHeaderEnding);
 User::LeaveIfError( j );
 aHeaderValue = ptr.Mid(i, j).AllocL();
 CleanupStack::PopAndDestroy(); // buffer
 }
 // -----------------------------------------------------------------------------
 //
 //
 // Parameters:
 //
 // Returns:
 // -----------------------------------------------------------------------------
 void GetContentHeaderL(
 const TDesC8& aContent,
 const TDesC8& aHeaderName,
 HBufC8*& aHeaderValue)
 {
 COma1Dcf* dcf = NULL;
 dcf = COma1Dcf::NewL(aContent);
 CleanupStack::PushL(dcf);
 GetHeaderL(*dcf->iHeaders, aHeaderName, aHeaderValue);
 CleanupStack::PopAndDestroy(); // dcf
 }
 // -----------------------------------------------------------------------------
 //
 //
 // Parameters:
 //
 // Returns:
 // -----------------------------------------------------------------------------
 void GetFileHeaderL(
 const TFileName& aFileName,
 const TDesC8& aHeaderName,
 HBufC8*& aHeaderValue)
 {
 RFs fs;
 RFile file;
 GetFileHeaderL(file, aHeaderName, aHeaderValue);
 CleanupStack::PopAndDestroy(2); // fs, file
 }
 // -----------------------------------------------------------------------------
 //
 //
 // Parameters:
 //
 // Returns:
 // -----------------------------------------------------------------------------
 void GetFileHeaderL(
 RFile& aFileHandle,
 const TDesC8& aHeaderName,
 HBufC8*& aHeaderValue)
 {
 CDcfCommon* dcf = NULL;
 aHeaderValue = NULL;
 TInt& aCount)
 {
 TInt err = 0;
 TDataType type;
 RFs fs;
 RFileReadStream reader;
 aCount = 0;
 err = fs.Connect();
 if (!err)
 {
 #ifndef RD_MULTIPLE_DRIVE
 err = reader.Open(fs, KDataTypesFile, EFileRead);
 #else //RD_MULTIPLE_DRIVE
 TInt driveNumber( -1 );
 TChar driveLetter;
 DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );
 fs.DriveToChar( driveNumber, driveLetter );
 TFileName dataTypesFile;
-	dataTypesFile.Format( KDataTypesFile, (TUint)driveLetter );
+dataTypesFile.Format( KDataTypesFile, (TUint)driveLetter );
 err = reader.Open(fs, dataTypesFile, EFileRead);
 #endif
 if (err == KErrNotFound)
 {
 err = DRMCommon::EOk;
 }
 else
 while (err == KErrNone)
 {
 TRAP(err, (reader >> type));
 if (err == KErrNone) aCount++;
 }
 if (err == KErrEof)
 {
 err = DRMCommon::EOk;
 }
 reader.Release();
 reader.Close();
 }
 }
 fs.Close();
 return err;
 }
 // -----------------------------------------------------------------------------
 // SupportedDynamicDataType: Returns a registered dynamic datatype
 // Returns:
 //      DRMCommon::EOk: Data type returned successfully
 //      KErrEof: Data type not found
 // -----------------------------------------------------------------------------
 LOCAL_C TInt SupportedDynamicDataType(
 const TInt aIndex,
 TDataType& aDataType)
 {
 TInt err = KErrNone;
 TInt i;
 RFs fs;
 TDataType type;
 RFileReadStream reader;
 err = fs.Connect();
 if (!err)
 {
 #ifndef RD_MULTIPLE_DRIVE
 err = reader.Open(fs, KDataTypesFile, EFileRead);
 #else //RD_MULTIPLE_DRIVE
 TInt driveNumber( -1 );
 TChar driveLetter;
 DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );
-	fs.DriveToChar( driveNumber, driveLetter );
+fs.DriveToChar( driveNumber, driveLetter );
-	TFileName dataTypesFile;
+TFileName dataTypesFile;
-	    dataTypesFile.Format( KDataTypesFile, (TUint)driveLetter );
+dataTypesFile.Format( KDataTypesFile, (TUint)driveLetter );
 err = reader.Open(fs, dataTypesFile, EFileRead);
 #endif
 if (!err)
 {
 i = -1;
 while (err == 0 && i != aIndex)
 {
 TRAP(err, (reader >> type));
 i++;
 }
 if (!err)
 {
 aDataType = type;
 }
 reader.Release();
 reader.Close();
 }
 }
 fs.Close();
 return err;
 }
 // -----------------------------------------------------------------------------
 // SupportedStaticDataType: Returns a static DRM datatype
 // Returns:
 //      DRMCommon::EOk: Data type returned successfully
 //      KErrEof: Data type not found
 // -----------------------------------------------------------------------------
 LOCAL_C TInt SupportedStaticDataType(
 const TInt aIndex,
 TDataType& aDataType)
 {
 TInt err = 0;
 TInt index = 0;
 TInt length = 0;
 TInt i = 0;
 RFs fs;
 RResourceFile resourceFile;
 HBufC8* res = NULL;
 TResourceReader theReader;
 err = fs.Connect();
 if (err)
 {
 fs.Close();
 return err;
 }
 #ifndef RD_MULTIPLE_DRIVE
 TRAP(err, resourceFile.OpenL(fs, KResourceFile));
 #else //RD_MULTIPLE_DRIVE
 TInt driveNumber( -1 );
 TChar driveLetter;
 DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRom, driveNumber );
 fs.DriveToChar( driveNumber, driveLetter );
 TFileName resFile;
-	resFile.Format( KResourceFile, (TUint)driveLetter );
+resFile.Format( KResourceFile, (TUint)driveLetter );
 TRAP(err, resourceFile.OpenL(fs, resFile));
 #endif
 if (err)
 {
 fs.Close();
 return err;
 }
 TRAP(err, (res = resourceFile.AllocReadL(DATATYPE)));
 if (err)
 {
 resourceFile.Close();
 fs.Close();
 return err;
 }
 theReader.SetBuffer(res);
 index = aIndex + 1;
 TPtrC temp16(theReader.ReadTPtrC(index, res));
 length = temp16.Length();
 HBufC8* temp = NULL;
 temp = HBufC8::NewMax(length);
 if (temp)
 {
 TPtr8 ptr(temp->Des());
 ptr.SetLength(length);
 for (i = 0; i < length; i++)
 }
 else
 {
 err = KErrNoMemory;
 }
 if (temp)
 {
 delete temp;
 }
 temp = NULL;
 resourceFile.Close();
 if (res)
 {
 delete res;
 }
 res = NULL;
 fs.Close();
 return err;
 }
 TInt i;
 TDataType type;
 RFileWriteStream writer;
 RFileReadStream reader;
 RFs fs;
 User::LeaveIfError(fs.Connect());
 CleanupClosePushL(fs);
 // Open the data types file
 #ifndef RD_MULTIPLE_DRIVE
 User::LeaveIfError(reader.Open(fs, KDataTypesFile, EFileRead));
 #else //RD_MULTIPLE_DRIVE
 TInt driveNumber( -1 );
 TChar driveLetter;
 DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );
 fs.DriveToChar( driveNumber, driveLetter );
 TFileName dataTypesFile;
-	dataTypesFile.Format( KDataTypesFile, (TUint)driveLetter );
+dataTypesFile.Format( KDataTypesFile, (TUint)driveLetter );
 User::LeaveIfError(reader.Open(fs, dataTypesFile, EFileRead));
 #endif
 CleanupReleasePushL(reader);
 // Create and open a replacement file
 #ifndef RD_MULTIPLE_DRIVE
 User::LeaveIfError(writer.Replace(fs, KTempFile, EFileWrite));
 #else //RD_MULTIPLE_DRIVE
 TFileName tempFile;
 tempFile.Format( KTempFile, (TUint)driveLetter );
 User::LeaveIfError(writer.Replace(fs, tempFile, EFileWrite));
 #endif
 CleanupReleasePushL(writer);
 // Write all dynamic types into the replacement file, excluding the
 // data type to be removed
 r = KErrNone;
 for (i = 0; r == KErrNone; i++)
 {
 TRAP(r, reader >> type);
 if (r == KErrNone && i != aIndex)
 writer.CommitL();
 }
 }
 CleanupStack::PopAndDestroy();
 CleanupStack::PopAndDestroy();
 // Replace the data type file with the replacement file
 #ifndef RD_MULTIPLE_DRIVE
 fs.Replace(KTempFile, KDataTypesFile);
 #else //RD_MULTIPLE_DRIVE
 fs.Replace(tempFile, dataTypesFile);
 #endif
 CleanupStack::PopAndDestroy();
 return DRMCommon::EOk;
 }
 // -----------------------------------------------------------------------------
 // RegisterDynamicDataTypeL: Register a new dynamically addable data type
 TInt err = KErrNone;
 TDataType type;
 RFileWriteStream writer;
 RFileReadStream reader;
 RFs fs;
 User::LeaveIfError(fs.Connect());
 CleanupClosePushL(fs);
 // Create and open a replacement file
 #ifndef RD_MULTIPLE_DRIVE
 User::LeaveIfError(writer.Replace(fs, KTempFile, EFileWrite));
 #else //RD_MULTIPLE_DRIVE
 TInt driveNumber( -1 );
 TChar driveLetter;
 DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );
 fs.DriveToChar( driveNumber, driveLetter );
 TFileName tempFile;
-	tempFile.Format( KTempFile, (TUint)driveLetter );
+tempFile.Format( KTempFile, (TUint)driveLetter );
 User::LeaveIfError(writer.Replace(fs, tempFile, EFileWrite));
 #endif
 CleanupReleasePushL(writer);
 // Write the new data type into the replacement file
 writer << aDataType;
 writer.CommitL();
 // Write all other dynamic types into the replacement file
 #ifndef RD_MULTIPLE_DRIVE
 err = reader.Open(fs, KDataTypesFile, EFileRead);
 #else //RD_MULTIPLE_DRIVE
 TFileName dataTypesFile;
 dataTypesFile.Format( KDataTypesFile, (TUint)driveLetter );
 err = reader.Open(fs, dataTypesFile, EFileRead);
 #endif
 if (err == KErrNone)
 {
 CleanupReleasePushL(reader);
 while (err == KErrNone)
 {
 TRAP(err, (reader >> type, writer << type, writer.CommitL()));
 }
 CleanupStack::PopAndDestroy();
 }
 CleanupStack::PopAndDestroy();
 // Replace the data type file with the replacement file
 #ifndef RD_MULTIPLE_DRIVE
 fs.Replace(KTempFile, KDataTypesFile);
 #else //RD_MULTIPLE_DRIVE
 fs.Replace(tempFile, dataTypesFile);
 #endif
 CleanupStack::PopAndDestroy();
 return DRMCommon::EOk;
 }
 TInt CalculatePaddingL(COma1Dcf* dcf)
 {
 CleanupStack::PopAndDestroy(); // rdb
 }
 return dcf->iPadding;
 }
 // ============================ MEMBER FUNCTIONS ===============================
 // -----------------------------------------------------------------------------
 // DRMCommon::DRMCommon
 // C++ default constructor can NOT contain any code, that
 // might leave.
 // -----------------------------------------------------------------------------
 EXPORT_C DRMCommon::DRMCommon(void)
 {
 }
 // -----------------------------------------------------------------------------
 // DRMCommon::ConstructL
 // Symbian 2nd phase constructor can leave.
 // -----------------------------------------------------------------------------
 EXPORT_C void DRMCommon::ConstructL()
 {
 }
 // -----------------------------------------------------------------------------
 // DRMCommon::NewL
 // Two-phased constructor.
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 // DRMCommon::CheckContentRights
 // Checks if the give rights for a specific content URI are available.
 // -----------------------------------------------------------------------------
 EXPORT_C TInt DRMCommon::CheckContentRights(
 const TDesC8& aContentID,
 TUint32 aRightsSpec)
 {
 TInt r = ENoRights;
 RDRMRightsClient client;
 TUint32 reason = 0;
 if (client.Connect() == KErrNone)
 {
 r = client.CheckRights(aRightsSpec, aContentID, reason);
 client.Close();
 }
 // DRMCommon::CheckFileRights
 // Checks if the give rights for a specific content URI are available by
 // opening a given file and reading the content URI from there.
 // -----------------------------------------------------------------------------
 EXPORT_C TInt DRMCommon::CheckFileRights(
 const TDesC& aFileName,
 TUint32 aRightsSpec)
 {
 TInt r = KErrNone;
 TInt retValue = KErrNone;
 TRAP(r, retValue = CheckFileRightsL(aFileName, aRightsSpec));
 // DRMCommon::CheckFileRights
 // Checks if the give rights for a specific content URI are available by
 // opening a given file and reading the content URI from there.
 // -----------------------------------------------------------------------------
 EXPORT_C TInt DRMCommon::CheckFileRights(
 RFile& aFileHandle,
 TUint32 aRightsSpec)
 {
 TInt r = KErrNone;
 TInt retValue = KErrNone;
 TRAP(r, retValue = CheckFileRightsL(aFileHandle, aRightsSpec));
 // DRMCommon::IsProtectedContent
 // Check if a memory buffer contains DRM proteced content by looking for a
 // predefined header string.
 // -----------------------------------------------------------------------------
 EXPORT_C TInt DRMCommon::IsProtectedContent(
 const TDesC8& aContent,
 TBool& aProtection)
 {
 if (COma1Dcf::IsValidDcf(aContent) || COma2Dcf::IsValidDcf(aContent))
 {
 aProtection = ETrue;
 // DRMCommon::IsProtectedFile
 // Check if a file contains DRM proteced content by looking for a
 // predefined header string.
 // -----------------------------------------------------------------------------
 EXPORT_C TInt DRMCommon::IsProtectedFile(
 const TDesC& aFileName,
 TBool& aProtection)
 {
 TInt r = KErrNone;
 TRAP(r, IsProtectedFileL(aFileName, aProtection));
 return r;
 // DRMCommon::IsProtectedFile
 // Check if a file contains DRM proteced content by looking for a
 // predefined header string.
 // -----------------------------------------------------------------------------
 EXPORT_C TInt DRMCommon::IsProtectedFile(
 RFile& aFileHandle,
 TBool& aProtection)
 {
 TInt r = KErrNone;
 TRAP(r, IsProtectedFileL(aFileHandle, aProtection));
 return r;
 }
 // -----------------------------------------------------------------------------
 // DRMCommon::GetContentInfo
 // Returns DRM information about a memory buffer.
 // -----------------------------------------------------------------------------
 EXPORT_C TInt DRMCommon::GetContentInfo(
 const TDesC8& aContent,
 TContentProtection& aProtection,
 HBufC8*& aMIMEType,
 HBufC8*& aContentURI,
 TUint& aDataLength)
 {
 TInt r = KErrNone;
 TRAP(r, GetContentInfoL(aContent, aProtection, aMIMEType, aContentURI,
 aDataLength));
 return r;
 }
 // -----------------------------------------------------------------------------
 // DRMCommon::GetFileInfo
 // Returns DRM information about a file.
 // -----------------------------------------------------------------------------
 EXPORT_C TInt DRMCommon::GetFileInfo(
 const TDesC& aFileName,
 TContentProtection& aProtection,
 HBufC8*& aMIMEType,
 HBufC8*& aContentURI,
 TUint& aDataLength)
 {
 TInt r = KErrNone;
 TRAP(r, GetFileInfoL(aFileName, aProtection, aMIMEType, aContentURI,
 aDataLength));
 return r;
 }
 // -----------------------------------------------------------------------------
 // DRMCommon::GetFileInfo
 // Returns DRM information about a file.
 // -----------------------------------------------------------------------------
 EXPORT_C TInt DRMCommon::GetFileInfo(
 RFile& aFileHandle,
 TContentProtection& aProtection,
 HBufC8*& aMIMEType,
 HBufC8*& aContentURI,
 TUint& aDataLength)
 {
 TInt r = KErrNone;
 TRAP(r, GetFileInfoL(aFileHandle, aProtection, aMIMEType, aContentURI,
 aDataLength));
 return r;
 }
 // -----------------------------------------------------------------------------
 // DRMCommon::GetContentHeader
 // Returns an optional header from a memory buffer containing encrypted content.
 // -----------------------------------------------------------------------------
 EXPORT_C TInt DRMCommon::GetContentHeader(
 const TDesC8& aContent,
 const TDesC8& aHeaderName,
 HBufC8*& aHeaderValue)
 {
 TInt r = KErrNone;
 TRAP(r, GetContentHeaderL(aContent, aHeaderName, aHeaderValue));
 // -----------------------------------------------------------------------------
 // DRMCommon::GetFileHeader
 // Returns an optional header from a file containing encrypted content.
 // -----------------------------------------------------------------------------
 EXPORT_C TInt DRMCommon::GetFileHeader(
 const TFileName& aFileName,
 const TDesC8& aHeaderName,
 HBufC8*& aHeaderValue)
 {
 TInt r = KErrNone;
 TRAP(r, GetFileHeaderL(aFileName, aHeaderName, aHeaderValue));
 // -----------------------------------------------------------------------------
 // DRMCommon::GetFileHeader
 // Returns an optional header from a file containing encrypted content.
 // -----------------------------------------------------------------------------
 EXPORT_C TInt DRMCommon::GetFileHeader(
 RFile& aFileHandle,
 const TDesC8& aHeaderName,
 HBufC8*& aHeaderValue)
 {
 TInt r = KErrNone;
 TRAP(r, GetFileHeaderL(aFileHandle, aHeaderName, aHeaderValue));
 // -----------------------------------------------------------------------------
 // DRMAuthenticated::SetContentHeader
 // Sets the specified optional header field of a DCF buffer.
 // -----------------------------------------------------------------------------
 EXPORT_C TInt DRMCommon::SetContentHeader(
 HBufC8*& aContent,
 const TDesC8& aHeaderName,
 const TDesC8& aHeaderValue)
 {
 TInt r = KErrNone;
 TRAP(r, SetContentHeaderL(aContent, aHeaderName, aHeaderValue));
 // -----------------------------------------------------------------------------
 // DRMCommon::SetContentHeader
 // Sets the specified optional header field of a DCF buffer.
 // -----------------------------------------------------------------------------
 EXPORT_C TInt DRMCommon::SetFileHeader(
 const TDesC16& aFileName,
 const TDesC8& aHeaderName,
 const TDesC8& aHeaderValue)
 {
 TInt r = KErrNone;
 TRAP(r, SetFileHeaderL(aFileName, aHeaderName, aHeaderValue));
 // -----------------------------------------------------------------------------
 // DRMCommon::SetContentHeader
 // Sets the specified optional header field of a DCF buffer.
 // -----------------------------------------------------------------------------
 EXPORT_C TInt DRMCommon::SetFileHeader(
 RFile& aFileHandle,
 const TDesC8& aHeaderName,
 const TDesC8& aHeaderValue)
 {
 TInt r = KErrNone;
 TRAP(r, SetFileHeaderL(aFileHandle, aHeaderName, aHeaderValue));
 // -----------------------------------------------------------------------------
 // DRMCommon::GetSingleRightsObject
 // Looks up the rights object using the content URI and the local ID.
 // -----------------------------------------------------------------------------
 EXPORT_C TInt DRMCommon::GetSingleRightsObject(
 const TDesC8& aContentURI,
 TUint32 aLocalID,
 CDRMRights*& aRightsObject)
 {
 TInt r = KErrNone;
 TRAP(r, GetSingleRightsObjectL(aContentURI, aLocalID, aRightsObject));
 return r;
 // -----------------------------------------------------------------------------
 // DRMCommon::GetDetailedContentRights
 // Returns all rights objects for a content URI
 // -----------------------------------------------------------------------------
 EXPORT_C TInt DRMCommon::GetDetailedContentRights(
 const TDesC8& aContentURI,
 RPointerArray<CDRMRights>*& aRightsList)
 {
 TInt r = KErrNone;
 TRAP(r, GetDetailedContentRightsL(aContentURI, aRightsList));
 // -----------------------------------------------------------------------------
 // DRMCommon::GetDetailedFileRights
 // Returns all rights objects for a content URI from a given file
 // -----------------------------------------------------------------------------
 EXPORT_C TInt DRMCommon::GetDetailedFileRights(
 const TDesC& aFileName,
 RPointerArray<CDRMRights>*& aRightsList)
 {
 TInt r = KErrNone;
 TRAP(r, GetDetailedFileRightsL(aFileName, aRightsList));
 {
 AddParents( const_cast<DRMCommon*>(this), *aRightsList );
 }
 return r;
 }
 // -----------------------------------------------------------------------------
 // DRMCommon::GetDetailedFileRights
 // Returns all rights objects for a content URI from a given file
 // -----------------------------------------------------------------------------
 EXPORT_C TInt DRMCommon::GetDetailedFileRights(
 RFile& aFileHandle,
 RPointerArray<CDRMRights>*& aRightsList)
 {
 TInt r = KErrNone;
 TRAP(r, GetDetailedFileRightsL(aFileHandle, aRightsList));
 if (r == KErrNone)
 {
 AddParents( const_cast<DRMCommon*>(this), *aRightsList );
 }
 return r;
 }
 // -----------------------------------------------------------------------------
 // DRMCommon::GetActiveRights
 // Returns a possible active rights object
 // -----------------------------------------------------------------------------
 const TDesC8& aContentURI,
 TUint32 aConstraints,
 CDRMRights*& aRightsObject)
 {
 TInt r = KErrNone;
 TRAP( r, GetActiveRightsL( aContentURI, aConstraints, aRightsObject ) );
 if(r != KErrNone)
 {
 return DRMCommon::ENoRights;
 }
 else
 {
 CDRMRights::TRestriction restriction;
 CDRMRights::TExpiration expiration;
 TUint32 constType(0);
 aRightsObject->GetRightsInfo(aConstraints, restriction, expiration, constType);
 EXPORT_C TInt DRMCommon::GetContentURIList(
 RPointerArray<HBufC8>*& aURIList)
 {
 RDRMRightsClient client;
 TInt error = client.Connect();
 aURIList = NULL;
 if (!error)
 {
 aURIList = new RPointerArray<HBufC8>(10);
 if (aURIList)
 {
 error = KErrNoMemory;
 }
 client.Close();
 }
 return error;
 }
 // -----------------------------------------------------------------------------
 // DRMCommon::Connect
 // Does nothing
 // -----------------------------------------------------------------------------
 EXPORT_C TInt DRMCommon::Connect()
 {
 RDRMRightsClient client; // Used to start RightsServer in bootup
-TInt ignore = 0;				 // error will be ignored, if it fails to start the
+TInt ignore = 0;                 // error will be ignored, if it fails to start the
 // rights server there is nothing we can really
 // do about it, and normally this would work and
 // return AOk, just used because of the SkinSrv
 // Bootup thing
 ignore = client.Connect();        // Called by SkinSrv during bootup
-		if( ignore )
+if( ignore )
-		    {
+{
-		    // The error shouldn't matter since it will be retried
+// The error shouldn't matter since it will be retried
-		    }
+}
 client.Close();
 return EOk;
 }
 // -----------------------------------------------------------------------------
 // DRMCommon::Version
 // Returns the client side API version.
 // -----------------------------------------------------------------------------
 EXPORT_C TVersion DRMCommon::Version()
 {
 return TVersion(KClientVersionMajor,
 KClientVersionMinor,
 KClientVersionBuild);
 }
 // -----------------------------------------------------------------------------
 // DRMCommon::ServerVersion
 // Returns the version of the DRM engine.
 // -----------------------------------------------------------------------------
 EXPORT_C TVersion DRMCommon::ServerVersion()
 {
 return TVersion(KServerVersionMajor,
 KServerVersionMinor,
 KServerVersionBuild);
 }
 // -----------------------------------------------------------------------------
 // DRMCommon::DataTypesCount
 TInt& aCount)
 {
 TInt err = 0;
 TInt staticTotal = 0;
 TInt dynamicTotal = 0;
 err = StaticDataTypesCount(staticTotal);
 if (err)
 {
 return err;
 }
 err = DynamicDataTypesCount(dynamicTotal);
 if (err)
 {
 return err;
 }
 aCount = staticTotal + dynamicTotal;
 return err;
 }
 // -----------------------------------------------------------------------------
 // DRMCommon::SupportedDataType
 // Returns a specific DRM enabled MIME type.
 // -----------------------------------------------------------------------------
 EXPORT_C TInt DRMCommon::SupportedDataType(
 const TInt aIndex,
 TDataType& aDataType)
 {
 TInt err = KErrNone;
 TInt total = 0;
 TInt stat = 0;
 err = DataTypesCount(total);
 if (!err) err = StaticDataTypesCount(stat);
 if (!err)
 {
 if (0 <= aIndex && aIndex < stat)
 else
 {
 err = KErrArgument;
 }
 }
 return err;
 }
 // -----------------------------------------------------------------------------
 // DRMCommon::StaticDataTypesCount
 {
 TInt err = 0;
 RFs fs;
 RResourceFile resourceFile;
 TResourceReader theReader;
 err = fs.Connect();
 if (err)
 {
 fs.Close();
 return err;
 }
 #ifndef RD_MULTIPLE_DRIVE
 TRAP(err, resourceFile.OpenL(fs, KResourceFile));
 #else //RD_MULTIPLE_DRIVE
 TInt driveNumber( -1 );
 TChar driveLetter;
 DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRom, driveNumber );
 fs.DriveToChar( driveNumber, driveLetter );
 TFileName resFile;
-	resFile.Format( KResourceFile, (TUint)driveLetter );
+resFile.Format( KResourceFile, (TUint)driveLetter );
 TRAP(err, resourceFile.OpenL(fs, resFile));
 #endif
 if (err)
 {
 fs.Close();
 return err;
 }
 HBufC8* res = NULL;
 TRAP(err, (res = resourceFile.AllocReadL(DATATYPE)));
 if (err)
 {
 resourceFile.Close();
 fs.Close();
 return err;
 }
 theReader.SetBuffer(res);
 aCount = theReader.ReadInt8();
 delete res;
 res = NULL;
 resourceFile.Close();
 fs.Close();
 return err;
 {
 TInt total = 0;
 TInt err = KErrNone;
 TInt i;
 TDataType type;
 if (aDataType.Des().Length() > 0)
 {
 err = DataTypesCount(total);
 for (i = 0 ; err == KErrNone && i < total ; i++)
 {
 err = SupportedDataType(i, type);
 if (type == aDataType)
 {
 err = KErrAlreadyExists;
 }
 }
 if (!err)
 {
 TRAP(err, RegisterDynamicDataTypeL(aDataType));
 }
 }
 else
 {
 err = KErrArgument;
 }
 return err;
 }
 // -----------------------------------------------------------------------------
 const TInt aIndex)
 {
 TInt r;
 TInt count;
 TInt total;
 StaticDataTypesCount(count);
 r = DataTypesCount(total);
 if (r == KErrNone && aIndex >= count && aIndex < total)
 {
 TRAP(r, UnRegisterDynamicDataTypeL(aIndex - count));
 for (TInt i = 0; !merged && i < parents->Count(); i++)
 {
 CDRMRights::TRestriction restriction;
 CDRMRights::TExpiration expiration;
 TUint32 constraints;
 aRights->GetRightsInfo(EUnknown, restriction, expiration,
 constraints);
 if ( expiration == CDRMRights::EValidRights)
 {
 aRights->Merge(*(*parents)[i]);
 merged = ETrue;
 }
 parents->ResetAndDestroy();
 delete parents;
 }
 }
 */
 }
 // -----------------------------------------------------------------------------
 // GetFileHandle
 // Get a file name trying to open it in the order required, which is:
 // 1)  EFileShareReadersOrWriters
 // 2)  EFileShareAny
 // 3)  EFileShareReadersOnly
 // -----------------------------------------------------------------------------
 LOCAL_C TInt GetFileHandleRead(
 RFs& aFileServer,
 RFile& aFile,
 const TDesC& aFileName )
 {
 TInt error = KErrNone;
 // 1) Try to open in EFileShareReadersOrWriters
 // 2) Try to open in EFileShareAny
 error = aFile.Open( aFileServer, aFileName, EFileRead | EFileShareAny );
 if( error != KErrNone )
 {
 // 3) Try to open in EFileShareReadersOnly
 error = aFile.Open( aFileServer, aFileName, EFileRead | EFileShareReadersOnly );
 }
 }
 return error;
 };
 // -----------------------------------------------------------------------------
 // GetFileHandle
 // Get a file name trying to open it in the order required, which is:
 // 1)  EFileShareReadersOrWriters
 // 2)  EFileShareAny
 // 3)  EFileShareReadersOnly
 // -----------------------------------------------------------------------------
 LOCAL_C void AddParents( DRMCommon* aDrmCommon,
 RPointerArray<CDRMRights>& aRights )
 {
 HBufC8* parent = NULL;
 RPointerArray<CDRMRights>* parents = NULL;
 TInt error = KErrNone;
 RPointerArray<HBufC8> usedParents;
 for( TInt i = 0; i < aRights.Count(); i++ )
 {
 parent = aRights[i]->GetPermission().iParentUID;
 for(TInt counter = 0; counter < usedParents.Count(); counter++ )
 {
 if( parent && !usedParents[counter]->Compare( *parent ) )
 {
 parent = NULL;
 }
 }
 if( parent != NULL )
 {
 TRAP( error, usedParents.AppendL( parent ) );
 if( aDrmCommon->GetDetailedContentRights(parent->Des(), parents) == KErrNone )
 {
 for( TInt j = parents->Count()-1; j >= 0;j-- )
 {
 TRAP( error, aRights.AppendL( (*parents)[j] ) );
 (*parents)[j] = NULL;
 parents->Remove(j);
 }
 parents->ResetAndDestroy();
 delete parents;
 parents = NULL;
 }
 }
 }
 usedParents.Reset();
 usedParents.Close();
 }
 // -----------------------------------------------------------------------------
 // DRMCommon::MapErrorCode
 // Remaps DRM core specific error codes to DRM API error codes.

branch	RCL_3
changeset 18	8a03a285ab14
parent 0	95b198f216e5
child 32	457cd4423b8c