MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/security/contentmgmt/contentaccessfwfordrm/source/f32agent/f32agentdata.cpp
author sl@SLION-WIN7.fritz.box
Fri, 15 Jun 2012 03:10:57 +0200
changeset 0 bde4ae8d615e
permissions -rw-r--r--
First public contribution. 
     1 /*

     2 * Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 #include <caf/caf.h>

    20 #include "f32agentdata.h"

    21 #include "f32defaultattributes.h"

    22 #include <caf/virtualpath.h>

    23 #include <caf/f32agentui.h>

    24 #include <e32def.h>

    25 

    26 using namespace ContentAccess;

    27 

    28 CF32AgentData* CF32AgentData::NewL(const TVirtualPathPtr& aVirtualPath, TContentShareMode aShareMode)

    29 	{

    30 	CF32AgentData* self = new (ELeave) CF32AgentData;

    31 	CleanupStack::PushL(self);

    32 	self->ConstructL(aVirtualPath, aShareMode);

    33 	CleanupStack::Pop(self);

    34 	return self;

    35 	}

    36 

    37 CF32AgentData* CF32AgentData::NewL(RFile& aFile, const TDesC& aUniqueId)

    38 	{

    39 	CF32AgentData* self = new (ELeave) CF32AgentData;

    40 	CleanupStack::PushL(self);

    41 	self->ConstructL(aFile, aUniqueId);

    42 	CleanupStack::Pop(self);

    43 	return self;

    44 	}

    45 

    46 #ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT

    47 

    48 CF32AgentData* CF32AgentData::NewL(const TDesC8& aHeaderData)

    49 	{

    50 	CF32AgentData* self = new (ELeave) CF32AgentData;

    51 	CleanupStack::PushL(self);

    52 	self->ConstructL(aHeaderData);

    53 	CleanupStack::Pop(self);

    54 	return self;

    55 	}

    56 	

    57 void CF32AgentData::ConstructL(const TDesC8& aHeaderData)

    58 	{

    59 	if(aHeaderData.Length() > 0)

    60 		iHeaderData = aHeaderData.AllocL();

    61 	else

    62 		User::Leave(KErrMissingWmdrmHeaderData);

    63 	}

    64 	

    65 #endif //SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT

    66 

    67 CF32AgentData::CF32AgentData()

    68 	{

    69 	}

    70 

    71 CF32AgentData::~CF32AgentData()

    72 	{

    73 	// Tidy up RFile and RFs

    74 	iFile.Close();

    75 	if(iVirtualPath) // opened by name

    76 		{

    77 		iFs.Close();

    78 		}

    79 

    80 	delete iVirtualPath;

    81 	

    82 #ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT

    83 	delete iHeaderData;			

    84 #endif //SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT

    85 	}

    86   

    87 void CF32AgentData::ConstructL(const TVirtualPathPtr& aVirtualPath, TContentShareMode aShareMode)

    88 	{

    89 	iVirtualPath = CVirtualPath::NewL(aVirtualPath);

    90 	

    91 	// Check that the client hasn't specified some incorrect UniqueId

    92 	User::LeaveIfError(TF32DefaultAttributes::CheckUniqueId(aVirtualPath.UniqueId()));

    93 

    94 	TUint mode = TF32DefaultAttributes::GetFileMode(aShareMode);

    95 	User::LeaveIfError(iFs.Connect());

    96 

    97 	// Make the file session shareable

    98 	User::LeaveIfError(iFs.ShareAuto());

    99 

   100 	User::LeaveIfError(iFile.Open(iFs, aVirtualPath.URI(), mode));

   101 	}

   102 

   103 void CF32AgentData::ConstructL(RFile& aFile, const TDesC& aUniqueId)

   104 	{

   105 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API		

   106 	TInt64 pos = 0;

   107 #else

   108 	TInt pos = 0;

   109 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   110 

   111 	// Check that the client hasn't specified some incorrect UniqueId

   112 	User::LeaveIfError(TF32DefaultAttributes::CheckUniqueId(aUniqueId));	

   113 	

   114 	// When creating a CData from a file handle we must duplicate the file handle

   115 	// before doing anything

   116 	User::LeaveIfError(iFile.Duplicate(aFile));

   117 	User::LeaveIfError(iFile.Seek(ESeekStart, pos));  // reset to start of file

   118 	}

   119 

   120 void CF32AgentData::DataSizeL(TInt &aSize)

   121 	{

   122 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   123 	TInt64 size;

   124 	User::LeaveIfError(iFile.Size(size));

   125 	aSize=size;

   126 #else

   127 	User::LeaveIfError(iFile.Size(aSize));

   128 #endif //SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   129 	}

   130 

   131 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   132 void CF32AgentData::DataSize64L(TInt64 &aSize)

   133 	{

   134 	User::LeaveIfError(iFile.Size(aSize));

   135 	}

   136 #endif //SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   137 

   138 TInt CF32AgentData::EvaluateIntent(TIntent /*aIntent*/)

   139 	{

   140 	return KErrNone;

   141 	}

   142 

   143 TInt CF32AgentData::ExecuteIntent(TIntent /*aIntent*/)

   144 	{

   145 	return KErrNone;

   146 	}

   147 

   148 TInt CF32AgentData::Read(TDes8& aDes) 

   149 	{

   150 	return iFile.Read(aDes);

   151 	}

   152 

   153 TInt CF32AgentData::Read(TDes8& aDes,TInt aLength) 

   154 	{

   155 	return iFile.Read(aDes,aLength);

   156 	}

   157 

   158 void CF32AgentData::Read(TDes8& aDes,TRequestStatus& aStatus) 

   159 	{

   160 	iFile.Read(aDes, aStatus);

   161 	}

   162 

   163 void CF32AgentData::Read(TDes8& aDes,

   164 							 TInt aLength, 

   165 							 TRequestStatus& aStatus) 

   166 	{

   167 	iFile.Read(aDes, aLength, aStatus);

   168 	}

   169 	

   170 TInt CF32AgentData::Read(TInt aPos, TDes8& aDes,

   171 							 TInt aLength, 

   172 							 TRequestStatus& aStatus) 

   173 	{

   174 	iFile.Read(aPos, aDes, aLength, aStatus);

   175 	return KErrNone;

   176 	}

   177 

   178 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   179 TInt CF32AgentData::Read64(TInt64 aPos, TDes8& aDes,

   180 							 TInt aLength, 

   181 							 TRequestStatus& aStatus) 

   182 	{

   183 	iFile.Read(aPos, aDes, aLength, aStatus);

   184 	return KErrNone;

   185 	}

   186 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   187 	

   188 void CF32AgentData::ReadCancel(TRequestStatus& aStatus)

   189 	{

   190 	iFile.ReadCancel(aStatus);

   191 	}

   192 

   193 TInt CF32AgentData::Seek(TSeek aMode, TInt& aPos) 

   194 	{

   195 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   196 	TInt64 pos = aPos;

   197 	TInt offset = iFile.Seek(aMode, pos);

   198 	aPos = I64INT(pos);

   199 #else

   200 	TInt offset = iFile.Seek(aMode, aPos);

   201 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   202 	return offset;

   203 	}

   204 

   205 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   206 TInt CF32AgentData::Seek64(TSeek aMode, TInt64& aPos) 

   207 	{

   208 	return iFile.Seek(aMode, aPos);

   209 	}

   210 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   211 

   212 

   213 TInt CF32AgentData::SetProperty(TAgentProperty aProperty, TInt aValue)

   214 	{

   215 	

   216 	if(aProperty==EAgentPropertyAgentUI)

   217 		//	should only pass type EAgentPropertyAgentUI 

   218 		{

   219 		CF32AgentUi* ui = NULL;

   220 	

   221 		// get a pointer to the UI

   222 		TRAPD(err, ui = &AgentUiL());

   223 		if(err)

   224 			{

   225 			return err;

   226 			}

   227 		return ui->SetProperty(aProperty, aValue);

   228 		}

   229 	else

   230 		{

   231 		return KErrCANotSupported;

   232 		}

   233 	}

   234 

   235 TInt CF32AgentData::GetAttribute(TInt aAttribute, TInt& aValue)

   236 	{

   237 #ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT

   238 	if(iHeaderData)

   239 		{

   240 		return TF32DefaultAttributes::GetAttribute(*iHeaderData, aAttribute, aValue);

   241 		}

   242 		

   243 	else if(iVirtualPath)

   244 		{

   245 		return TF32DefaultAttributes::GetAttribute(aAttribute, aValue, iVirtualPath->URI());

   246 		}

   247 		

   248 	else

   249 		{

   250 		return TF32DefaultAttributes::GetAttribute(aAttribute, aValue, iFile);

   251 		}

   252 #else

   253 	if(iVirtualPath)

   254 		{

   255 		return TF32DefaultAttributes::GetAttribute(aAttribute, aValue, iVirtualPath->URI());

   256 		}

   257 	else

   258 		{

   259 		return TF32DefaultAttributes::GetAttribute(aAttribute, aValue, iFile);

   260 		}

   261 #endif //SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT

   262 	}

   263 

   264 TInt CF32AgentData::GetAttributeSet(RAttributeSet& aAttributeSet)

   265 	{

   266 #ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT

   267 	if(iHeaderData)

   268 		{

   269 		return TF32DefaultAttributes::GetAttributeSet(*iHeaderData, aAttributeSet);

   270 		}

   271 		

   272 	else if(iVirtualPath)

   273 		{

   274 		return TF32DefaultAttributes::GetAttributeSet(aAttributeSet, iVirtualPath->URI());

   275 		}

   276 			

   277 	else

   278 		{

   279 		return TF32DefaultAttributes::GetAttributeSet(aAttributeSet, iFile);

   280 		}

   281 #else

   282 	if(iVirtualPath)

   283 		{

   284 		return TF32DefaultAttributes::GetAttributeSet(aAttributeSet, iVirtualPath->URI());

   285 		}	

   286 	else

   287 		{

   288 		return TF32DefaultAttributes::GetAttributeSet(aAttributeSet, iFile);

   289 		}	

   290 #endif //SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT		

   291 	}

   292 

   293 TInt CF32AgentData::GetStringAttribute(TInt aAttribute, TDes& aValue)

   294 	{

   295 #ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT

   296 	if(iHeaderData)

   297 		{

   298 		return TF32DefaultAttributes::GetStringAttribute(*iHeaderData, aAttribute, aValue);

   299 		}

   300 	

   301 	else if(iVirtualPath)

   302 		{

   303 		return TF32DefaultAttributes::GetStringAttribute(aAttribute, aValue, iVirtualPath->URI());

   304 		}

   305 	else

   306 		{

   307 		return TF32DefaultAttributes::GetStringAttribute(aAttribute, aValue, iFile);

   308 		}

   309 #else

   310 	if(iVirtualPath)

   311 		{

   312 		return TF32DefaultAttributes::GetStringAttribute(aAttribute, aValue, iVirtualPath->URI());

   313 		}

   314 	else

   315 		{

   316 		return TF32DefaultAttributes::GetStringAttribute(aAttribute, aValue, iFile);

   317 		}

   318 #endif //SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT	

   319 	}

   320 

   321 TInt CF32AgentData::GetStringAttributeSet(RStringAttributeSet& aStringAttributeSet)

   322 	{

   323 #ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT

   324 	if(iHeaderData)

   325 		{

   326 		return TF32DefaultAttributes::GetStringAttributeSet(*iHeaderData, aStringAttributeSet);

   327 		}

   328 		

   329 	else if(iVirtualPath)

   330 		{

   331 		return TF32DefaultAttributes::GetStringAttributeSet(aStringAttributeSet, iVirtualPath->URI());

   332 		}

   333 	else

   334 		{

   335 		return TF32DefaultAttributes::GetStringAttributeSet(aStringAttributeSet, iFile);

   336 		}

   337 #else

   338 	if(iVirtualPath)

   339 		{

   340 		return TF32DefaultAttributes::GetStringAttributeSet(aStringAttributeSet, iVirtualPath->URI());

   341 		}

   342 	else

   343 		{

   344 		return TF32DefaultAttributes::GetStringAttributeSet(aStringAttributeSet, iFile);

   345 		}

   346 #endif //SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT

   347 	}

   348 

   349 CF32AgentUi& CF32AgentData::AgentUiL()

   350 	{

   351 	if(!iAgentUi)

   352 		{

   353 		// load agent UI from f32AgentUi.dll

   354 		iAgentUi = TF32AgentUiFactory::CreateF32AgentUiL();

   355 		}

   356 	return *iAgentUi;

   357 	}

   358 

   359 #ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT

   360 

   361 TInt CF32AgentData::Read(const TDesC8& aEncryptedInputDataPacket, TDes8& aDecryptedOutputDataPacket)

   362 	{

   363 	if(aEncryptedInputDataPacket.Length() <= 0)

   364 		{

   365 		return KErrInsufficientDataPacketLength;

   366 		}

   367 	

   368 	aDecryptedOutputDataPacket = aEncryptedInputDataPacket;

   369 	return KErrNone;

   370 	}

   371 			

   372 void CF32AgentData::Read(const TDesC8& aEncryptedInputDataPacket, TDes8& aDecryptedOutputDataPacket, TRequestStatus& aStatus)

   373 	{

   374 	TRequestStatus* status = &aStatus;

   375 	if(aEncryptedInputDataPacket.Length() <= 0)

   376 		{

   377 		User::RequestComplete(status, KErrInsufficientDataPacketLength);		

   378 		}

   379 	

   380 	aDecryptedOutputDataPacket = aEncryptedInputDataPacket;

   381 	User::RequestComplete(status, KErrNone);

   382 	}

   383 

   384 #endif //SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT
Symaptic