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

equal deleted inserted replaced

-:79d62d1d7957
+:493788a4a8a4
 #include <s32mem.h>
 #include <apmstd.h>
 #include <symmetric.h>
 #include "Oma1DcfCreator.h"
 #include "DRMRightsClient.h"
-#include "DRMPermission.h"
+#include "DrmPermission.h"
-#include "DRMConstraint.h"
+#include "DrmConstraint.h"
 #include "DRMCommon.h"
 #include "DrmKeyStorage.h"
 // EXTERNAL DATA STRUCTURES
 // EXTERNAL FUNCTION PROTOTYPES
 // CONSTANTS
 static const TInt KMaxEncryptionSize = 2048;
 // MACROS
 // LOCAL CONSTANTS AND MACROS
 // -----------------------------------------------------------------------------
 EXPORT_C COma1DcfCreator::COma1DcfCreator(void)
 {
 iEncryptionStream = NULL;
 iEncryptionBuffer = NULL;
 }
 // -----------------------------------------------------------------------------
 // COma1DcfCreator::ConstructL
 // Symbian 2nd phase constructor can leave.
 // -----------------------------------------------------------------------------
 // Two-phased constructor.
 // -----------------------------------------------------------------------------
 EXPORT_C COma1DcfCreator* COma1DcfCreator::NewL()
 {
 COma1DcfCreator* self = new COma1DcfCreator();
 User::LeaveIfNull(self);
 CleanupStack::PushL(self);
 self->ConstructL();
 CleanupStack::Pop();
 return self;
 }
 // Destructor
 // ================= MEMBER FUNCTIONS =======================
 // -----------------------------------------------------------------------------
 // COma1DcfCreator::
 //
 // -----------------------------------------------------------------------------
 EXPORT_C void COma1DcfCreator::EncryptInitializeL(
 RWriteStream& anOutput,
 const TDesC8& aMIMEType,
 CDRMRights* aRightsObject)
 {
 const TUint KVersion = 1;
 CDRMPermission *rights = CDRMPermission::NewLC();
 TInt err = 0;
 uri.Set(aRightsObject->GetAsset().iUid->Des());
 err = iRdb.InitializeKey(uri);
 if (err == KErrCANoRights)
 {
 key.SetLength(KDCFKeySize);
 iRdb.GetRandomDataL(key);
 User::LeaveIfError(iRdb.AddRecord(key, aRightsObject->GetPermission(),
 uri, id));
 User::LeaveIfError(iRdb.InitializeKey(uri));
 }
 else
 anOutput.WriteL(KLDFHeader);
 anOutput.WriteL(iIv);
 anOutput.CommitL();
 iBytesWritten += 3 + aMIMEType.Size() + 2 + KLDFHeader().Size() +
 iIv.Size();
 CleanupStack::PopAndDestroy(); // rights
 }
 // -----------------------------------------------------------------------------
 // COma1DcfCreator::EncryptUpdateL
 // update the encryption
 // -----------------------------------------------------------------------------
 TInt i;
 TInt n;
 TInt size;
 TPtr8 ptr(iEncryptionBuffer->Des());
 TPtrC8 data;
 data.Set(aMessageData);
 if (iRemainder.Size() > 0 && iRemainder.Size() + data.Size() >= KDCFKeySize)
 {
 ptr.Copy(iRemainder);
 n = Min(KDCFKeySize - iRemainder.Size(), data.Size());
 iBytesWritten += ptr.Size();
 iIv.Copy(ptr.Right(KDCFKeySize));
 data.Set(data.Right(data.Size() - n));
 iRemainder.SetLength(0);
 }
 size = data.Size();
 for (i = 0; size > KDCFKeySize; i += KMaxEncryptionSize)
 {
 n = Min(KMaxEncryptionSize, ((size / KDCFKeySize) * KDCFKeySize));
 ptr.Copy(data.Mid(i, n));
 // finalize the encryption
 // -----------------------------------------------------------------------------
 EXPORT_C void COma1DcfCreator::EncryptFinalizeL()
 {
 TPtr8 ptr(iEncryptionBuffer->Des());
 ptr.Copy(iRemainder);
 iRdb.Encrypt(iIv, ptr, ETrue);
 iEncryptionStream->WriteL(ptr);
 iEncryptionStream->CommitL();
 // COma1DcfCreator::EncryptContent
 // Encrypt plain content to a DCF. Replaces the input buffer with the plain
 // content with the DCF.
 // -----------------------------------------------------------------------------
 EXPORT_C void COma1DcfCreator::EncryptContentL(
 HBufC8*& aContent,
 const TDesC8& aMIMEType,
 CDRMRights* aRightsObject)
 {
 RMemWriteStream output;
 TAny* buffer;
 TInt size;
 size = aContent->Length() +
 aMIMEType.Length() +
 KLDContentURI().Length() +
 KLDFHeader().Length() + 256;
 buffer = User::Alloc(size);
 User::LeaveIfNull(buffer);
 CleanupStack::PushL(buffer);
 output.Open(buffer, size);
 // -----------------------------------------------------------------------------
 // COma1DcfCreator::EncryptFileL
 // Turn a plain content file into a DCF.
 // -----------------------------------------------------------------------------
 EXPORT_C void COma1DcfCreator::EncryptFileL(
 const TDesC& aFileName,
 const TDesC& aDCFFileName,
 const TDesC8& aMIMEType,
 CDRMRights* aRightsObject)
 {
 TInt r = KErrNone;
 RFs fs;
 RFile input;
 RFileWriteStream output;
 HBufC8* buf = HBufC8::NewLC(8000);
 TPtr8 buffer(const_cast<TUint8*>(buf->Ptr()),0,8000);
 User::LeaveIfError(fs.Connect());
 CleanupClosePushL(fs);
 r = input.Open(fs, aFileName, EFileRead|EFileShareReadersOrWriters);
 if(r == KErrInUse)
 {
 r = input.Open(fs, aFileName, EFileRead | EFileShareAny);
 if(r == KErrInUse)
 {
 User::LeaveIfError(input.Open(fs, aFileName, EFileRead |
 EFileShareReadersOnly));
 r = KErrNone;
 }
 }
 User::LeaveIfError( r );
 CleanupClosePushL(input);
 User::LeaveIfError(output.Replace(fs, aDCFFileName, EFileWrite));
 CleanupClosePushL(output);
 EncryptInitializeL(output, aMIMEType, aRightsObject);
 do
 {
 input.Read(buffer, buffer.MaxSize());
 if (buffer.Size() > 0)
 {
 EncryptUpdateL(buffer);
 }
 }
 while (buffer.Size() > 0);
 EncryptFinalizeL();
 CleanupStack::PopAndDestroy(4); // output, input, fs, buf
 }
 // -----------------------------------------------------------------------------
 // COma1DcfCreator::EncryptContentToFile
 // Encrypt plain content to a DCF and stores it in a file.
 // -----------------------------------------------------------------------------
 EXPORT_C void COma1DcfCreator::EncryptContentToFileL(
 const TDesC8& aContent,
 const TDesC& aFileName,
 const TDesC8& aMIMEType,
 CDRMRights* aRightsObject)
 {
 RFs fs;
 RFileWriteStream output;

changeset 23	493788a4a8a4
parent 0	95b198f216e5
child 84	b09186059647