MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/mm/mmlibs/mmfw/SecureDRM/src/Server/MmfDrmPluginServerSession.cpp
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include <mmf/common/mmfcontrollerframework.h>

    17 #include "MmfDrmPluginServerSession.h"

    18 #include "MmfDrmPluginClientServer.h"

    19 #include "MmfDrmPluginServer.h"

    20 

    21 /*

    22  Create a DRM Plugin Server Session

    23  */

    24 CMMFDRMPluginServerSession* CMMFDRMPluginServerSession::NewL()

    25 	{

    26 	CMMFDRMPluginServerSession* self = new(ELeave) CMMFDRMPluginServerSession();

    27 	return self;

    28 	}

    29 

    30 CMMFDRMPluginServerSession::~CMMFDRMPluginServerSession()

    31 	{

    32 	CMMFDRMPluginServer* server = 

    33 		const_cast<CMMFDRMPluginServer*>(static_cast<const CMMFDRMPluginServer*>(Server()));

    34 	if (server)

    35 		{

    36 		server->DecrementSessionId();		

    37 		}

    38 	if (iData)

    39 		{

    40 		delete iData;

    41 		}

    42 	iControllerSessionHandle.Close();

    43 	}

    44 

    45 void CMMFDRMPluginServerSession::CreateL(const CMmfIpcServer& aServer)

    46 	{

    47 	CMmfIpcSession::CreateL(aServer);

    48 	CMMFDRMPluginServer* server = 

    49 			static_cast<CMMFDRMPluginServer*>(CONST_CAST(CMmfIpcServer*, &aServer));

    50 	server->IncrementSessionId();

    51 	}

    52 

    53 void CMMFDRMPluginServerSession::ServiceL(const RMmfIpcMessage& aMessage)

    54 	{

    55 	switch (aMessage.Function())

    56 		{

    57 	case EMMFControllerLaunchRequest:

    58 		DoLaunchControllerL(aMessage);

    59 		aMessage.Complete(KErrNone);

    60 		break;

    61 	case EMMFControllerSessionHandle:

    62 		if (!iControllerSessionHandle.Handle())

    63 			{

    64 			User::Leave(KErrNotReady);

    65 			}

    66 		aMessage.Complete(iControllerSessionHandle);

    67 		break;

    68 	case EMMFControllerThreadPanic:

    69 		DoPanicControllerThreadL(aMessage);

    70 		aMessage.Complete(KErrNone);

    71 		break;

    72 	case EMMFControllerThreadKill:

    73 		DoKillControllerThreadL(aMessage);

    74 		aMessage.Complete(KErrNone);

    75 		break;

    76 	case EMMFControllerSetThreadPriority:

    77 		DoSetThreadPriorityL(aMessage);

    78 		aMessage.Complete(KErrNone);

    79 		break;

    80 	case EMMFDRMContentOpenByFilePath:

    81 		DoOpenContentByFilePathL(aMessage);

    82 		aMessage.Complete(KErrNone);

    83 		break;

    84 	case EMMFDRMContentOpenByFileHandle:

    85 		DoOpenContentByFileHandleL(aMessage);

    86 		aMessage.Complete(KErrNone);

    87 		break;

    88 	case EMMFDRMContentEvaluateIntent:

    89 		{

    90 		TInt err = DoEvaluateContentIntent(aMessage);

    91 		aMessage.Complete(err);

    92 		}

    93 		break;

    94 	case EMMFDRMContentGetMimeType:

    95 		DoGetContentMimeTypeL(aMessage);

    96 		aMessage.Complete(KErrNone);

    97 		break;

    98 	case EMMFDRMContentGetFileHeader:

    99 		DoGetContentFileHeaderL(aMessage);

   100 		aMessage.Complete(KErrNone);

   101 		break;

   102 	case EMMFSetDrmPluginServerTimeout:

   103 		DoSetDrmPluginServerTimeout(aMessage);

   104 		aMessage.Complete(KErrNone);

   105 		break;

   106 	default:

   107 		User::Leave(KErrNotSupported);

   108 		break;

   109 		}

   110 	}

   111 

   112 CMMFDRMPluginServerSession::CMMFDRMPluginServerSession()

   113 	{

   114 	}

   115 

   116 void CMMFDRMPluginServerSession::DoLaunchControllerL(const RMmfIpcMessage& aMessage)

   117 	{

   118 	if (iControllerSessionHandle.Handle())

   119 		{

   120 		User::Leave(KErrAlreadyExists);

   121 		}

   122 	TThreadId controllerTID;

   123 	RMMFControllerServerProxy controllerSessionHandle;

   124 	CMMFDRMPluginServer* server = 

   125 		const_cast<CMMFDRMPluginServer*>(static_cast<const CMMFDRMPluginServer*>(Server()));

   126 	

   127 	RThread clientThread;

   128 	CleanupClosePushL(clientThread);

   129 	User::LeaveIfError(aMessage.Client(clientThread));

   130 	

   131 	TPckg<TUint> maxHeapSize(0);

   132 	TPckg<TBool> useShareHeap(ETrue);

   133 	TPckg<TBool> stackSize(0);

   134 	

   135 	aMessage.ReadL(0, maxHeapSize);

   136 	aMessage.ReadL(1, useShareHeap);

   137 	aMessage.ReadL(3, stackSize);

   138 	

   139 	User::LeaveIfError(server->StartControllerServer(clientThread, maxHeapSize(), useShareHeap(), 

   140 													controllerSessionHandle, controllerTID, stackSize()));

   141 	SetControllerServerInfo(controllerSessionHandle, controllerTID);

   142 	

   143 	TPckgBuf<TThreadId> threadId(iControllerThreadID);

   144 	aMessage.WriteL(2, threadId);

   145 	CleanupStack::PopAndDestroy(&clientThread);

   146 	}

   147 

   148 void CMMFDRMPluginServerSession::DoPanicControllerThreadL(const RMmfIpcMessage& aMessage)

   149 	{

   150 	TPckgBuf<TThreadId> controllerTid(0);

   151 	aMessage.ReadL(0, controllerTid);

   152 	

   153 	TInt desLen = aMessage.GetDesLengthL(1);

   154 	HBufC* category = HBufC::NewLC(desLen);

   155 	TPtr categoryPtr(category->Des());

   156 	aMessage.ReadL(1, categoryPtr);

   157 	

   158 	TPckg<TInt>	panicReason(0);

   159 	aMessage.ReadL(2, panicReason);

   160 	

   161 	CMMFDRMPluginServer* server = 

   162 		const_cast<CMMFDRMPluginServer*>(static_cast<const CMMFDRMPluginServer*>(Server()));

   163 	server->PanicControllerThread(controllerTid(), categoryPtr, panicReason());

   164 	

   165 	CleanupStack::PopAndDestroy(category);

   166 	}

   167 	

   168 void CMMFDRMPluginServerSession::DoKillControllerThreadL(const RMmfIpcMessage& aMessage)

   169 	{

   170 	TPckgBuf<TThreadId> controllerTid(0);

   171 	aMessage.ReadL(0, controllerTid);

   172 	

   173 	TPckg<TInt>	killReason(0);

   174 	aMessage.ReadL(1, killReason);

   175 	

   176 	CMMFDRMPluginServer* server = 

   177 		const_cast<CMMFDRMPluginServer*>(static_cast<const CMMFDRMPluginServer*>(Server()));

   178 	server->KillControllerThread(controllerTid(), killReason());	

   179 	}

   180 	

   181 void CMMFDRMPluginServerSession::SetControllerServerInfo(RHandleBase& aControllerSessionHandle,

   182 													TThreadId& aControllerThreadId)

   183 	{

   184 	iControllerSessionHandle = aControllerSessionHandle;

   185 	iControllerThreadID = aControllerThreadId;

   186 	}

   187 

   188 void CMMFDRMPluginServerSession::DoSetThreadPriorityL(const RMmfIpcMessage& aMessage)

   189 	{

   190 	TPckgBuf<TThreadId> threadId;

   191 	TPckgBuf<TThreadPriority> priority;

   192 	

   193 	aMessage.ReadL(0, threadId);

   194 	aMessage.ReadL(1, priority);

   195 	

   196 	CMMFDRMPluginServer* server = 

   197 		const_cast<CMMFDRMPluginServer*>(static_cast<const CMMFDRMPluginServer*>(Server()));

   198 	User::LeaveIfError(server->SetThreadPriority(threadId(), priority()));

   199 	}

   200 

   201 void CMMFDRMPluginServerSession::DoOpenContentByFilePathL(const RMmfIpcMessage& aMessage)

   202 	{

   203 	if (iData == NULL)

   204 		{

   205 		TInt length = aMessage.GetDesLengthL(0);

   206 		HBufC* filePath = HBufC::NewLC(length);

   207 		TPtr filePathPtr(filePath->Des());

   208 		aMessage.ReadL(0, filePathPtr);

   209 		

   210 		length = aMessage.GetDesLengthL(1);

   211 		HBufC8* initData = HBufC8::NewLC(length);

   212 		TPtr8 initDataPtr(initData->Des());

   213 		aMessage.ReadL(1, initDataPtr);

   214 		

   215 		HBufC* uniqueId = NULL;

   216 		TBool UIEnabled;

   217 		ContentAccess::TIntent intent;

   218 		GetContentInitDataL(initDataPtr, uniqueId, UIEnabled, intent);

   219 		CleanupStack::PopAndDestroy(initData);

   220 		CleanupStack::PushL(uniqueId);

   221 		

   222 		iData = CData::NewL(TVirtualPathPtr(filePathPtr, *uniqueId), EContentShareReadWrite);

   223 		TInt err = iData->SetProperty(EAgentPropertyAgentUI, UIEnabled);

   224 		if (err != KErrNone && err != KErrCANotSupported)

   225 			{

   226 			// KErrCANotSupported isn't a problem for us so eat the error code.

   227 			User::Leave(err);

   228 			}

   229 		User::LeaveIfError(iData->EvaluateIntent(intent));

   230 		

   231 		CleanupStack::PopAndDestroy(2, filePath);	// uniqueId, filePath

   232 		}

   233 	else

   234 		{

   235 		User::Leave(KErrAlreadyExists);

   236 		}

   237 	}

   238 	

   239 void CMMFDRMPluginServerSession::DoOpenContentByFileHandleL(const RMmfIpcMessage& aMessage)

   240 	{

   241 	if (iData == NULL)

   242 		{

   243 		RFile file;

   244 		User::LeaveIfError(file.AdoptFromClient(aMessage, 0, 1));

   245 		CleanupClosePushL(file);

   246 		

   247 		TInt length = aMessage.GetDesLengthL(2);

   248 		HBufC8* initData = HBufC8::NewLC(length);

   249 		TPtr8 initDataPtr(initData->Des());

   250 		aMessage.ReadL(2, initDataPtr);

   251 		

   252 		HBufC* uniqueId = NULL;

   253 		TBool UIEnabled;

   254 		ContentAccess::TIntent intent;

   255 		GetContentInitDataL(initDataPtr, uniqueId, UIEnabled, intent);

   256 		CleanupStack::PopAndDestroy(initData);

   257 		CleanupStack::PushL(uniqueId);

   258 		

   259 		iData = CData::NewL(file, *uniqueId);

   260 		TInt err = iData->SetProperty(EAgentPropertyAgentUI, UIEnabled);

   261 		if (err != KErrNone && err != KErrCANotSupported)

   262 			{

   263 			// KErrCANotSupported isn't a problem for us so eat the error code.

   264 			User::Leave(err);

   265 			}

   266 		User::LeaveIfError(iData->EvaluateIntent(intent));

   267 		

   268 		CleanupStack::PopAndDestroy(2, &file);	// uniqueId, file

   269 		}

   270 	else

   271 		{

   272 		User::Leave(KErrAlreadyExists);

   273 		}	

   274 	}

   275 

   276 void CMMFDRMPluginServerSession::GetContentInitDataL(const TDesC8& aInitData, HBufC*& aUniqueId,

   277 							 						 TBool& aUIEnabled, ContentAccess::TIntent& aIntent)

   278 	{

   279 	if (aUniqueId)

   280 		{

   281 		delete aUniqueId;

   282 		aUniqueId = NULL;

   283 		}

   284 	

   285 	RDesReadStream stream(aInitData);

   286 	CleanupClosePushL(stream);

   287 	

   288 	TInt length = stream.ReadInt32L();

   289 	aUniqueId = HBufC::NewLC(length);

   290 	TPtr ptr = aUniqueId->Des();

   291 	stream.ReadL(ptr, length);

   292 	

   293 	aUIEnabled = stream.ReadInt32L();

   294 	TPckgBuf<ContentAccess::TIntent> intentPckg;

   295 	stream.ReadL(intentPckg);

   296 	aIntent = intentPckg();

   297 	

   298 	CleanupStack::Pop(aUniqueId);

   299 	CleanupStack::PopAndDestroy(&stream);

   300 	}

   301 

   302 TInt CMMFDRMPluginServerSession::DoEvaluateContentIntent(const RMmfIpcMessage& aMessage)

   303 	{

   304 	TInt err;

   305 	if (iData)

   306 		{

   307 		TPckgBuf<TIntent> intentPckg;

   308 		err = aMessage.Read(0, intentPckg);

   309 		if (err == KErrNone)

   310 			{

   311 			err = iData->EvaluateIntent(intentPckg());

   312 			}

   313 		}

   314 	else

   315 		{

   316 		err = KErrGeneral;

   317 		}

   318 	return err;

   319 	}

   320 

   321 void CMMFDRMPluginServerSession::DoGetContentMimeTypeL(const RMmfIpcMessage& aMessage)

   322 	{

   323 	if (iData)

   324 		{

   325 		TBool success = ETrue;

   326 		TInt length = aMessage.GetDesMaxLengthL(0);

   327 		

   328 		HBufC* mimeType = HBufC::NewLC(length);

   329 		TPtr mimeTypePtr = mimeType->Des();

   330 		TInt err = iData->GetStringAttribute(EMimeType, mimeTypePtr);

   331 		

   332 		if (err == KErrNone)

   333 			{

   334 			HBufC8* mimeType8 = HBufC8::NewLC(length);

   335 			TPtr8 mimeTypePtr8 = mimeType8->Des();

   336 			mimeTypePtr8.Copy(mimeTypePtr);

   337 			

   338 			aMessage.WriteL(0, mimeTypePtr8);

   339 			CleanupStack::PopAndDestroy(mimeType8);

   340 			}

   341 		else

   342 			{

   343 			success = EFalse;

   344 			}

   345 		CleanupStack::PopAndDestroy(mimeType);

   346 		

   347 		TPckg<TBool> successPckg(success);

   348 		aMessage.WriteL(1, successPckg);

   349 		}

   350 	else

   351 		{

   352 		User::Leave(KErrGeneral);

   353 		}

   354 	}

   355 

   356 void CMMFDRMPluginServerSession::DoGetContentFileHeaderL(const RMmfIpcMessage& aMessage)

   357 	{

   358 	if (iData)

   359 		{

   360 		TInt size = 0;

   361 		iData->DataSizeL(size);

   362 		

   363 		TInt maxLength = aMessage.Int0();

   364 		

   365 		TInt desLength = aMessage.GetDesMaxLengthL(1);

   366 		HBufC8* header = HBufC8::NewLC(desLength);

   367 		TPtr8 headerPtr = header->Des();

   368 		

   369 		if (size > 0)

   370 			{

   371 			if (size > maxLength)

   372 				{

   373 				size = maxLength;

   374 				}

   375 			TInt pos = 0;

   376 			User::LeaveIfError(iData->Seek(ESeekStart, pos));

   377 			User::LeaveIfError(iData->Read(headerPtr, size));

   378 			aMessage.WriteL(1, headerPtr);

   379 			}

   380 		CleanupStack::PopAndDestroy(header);

   381 		}

   382 	else

   383 		{

   384 		User::Leave(KErrGeneral);

   385 		}

   386 	}

   387 

   388 void CMMFDRMPluginServerSession::DoSetDrmPluginServerTimeout(const RMmfIpcMessage& aMessage)

   389 	{

   390 	CMMFDRMPluginServer* server = 

   391 		const_cast<CMMFDRMPluginServer*>(static_cast<const CMMFDRMPluginServer*>(Server()));

   392 	server->SetTimeout(aMessage.Int0());	

   393 	}

   394
Symaptic