1 /*

     2 * Copyright (c) 2007-2008 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:       Definition of security manager store class

    15  *

    16 */

    17 

    18 

    19 

    20 

    21 

    22 

    23 #include <s32file.h>

    24 #include <bautils.h>

    25 #include <eikenv.h>

    26 #include <f32file.h>

    27 #include <pathinfo.h>

    28 #include "rtsecmgrstore.h"

    29 #include "rtsecmgrdata.h"

    30 

    31 const TReal DEFAULT_VERSION(1.0);

    32 CSecMgrStore* CSecMgrStore::NewL()

    33 	{

    34 	CSecMgrStore* self = CSecMgrStore::NewLC ();

    35 	CleanupStack::Pop (self);

    36 	return self;

    37 	}

    38 

    39 CSecMgrStore* CSecMgrStore::NewLC()

    40 	{

    41 	CSecMgrStore* self = new (ELeave)CSecMgrStore();

    42 	CleanupStack::PushL (self);

    43 	self->ConstructL ();

    44 	return self;

    45 	}

    46 

    47 void CSecMgrStore::StorePolicyL(const CPolicy& aPolicy)

    48 	{

    49 	__UHEAP_MARK;

    50 

    51 	HBufC *policyFile = HBufC::NewLC(KMaxName);

    52 	TPtr ptr(policyFile->Des());

    53 	GetPolicyFile (ptr, aPolicy.PolicyID ());

    54 

    55 	CFileStore* store = CPermanentFileStore::ReplaceLC (iFsSession, ptr,

    56 			EFileWrite);

    57 	store->SetTypeL (KPermanentFileStoreLayoutUid);

    58 

    59 	// Construct the output stream.

    60 	RStoreWriteStream outstream;

    61 	TStreamId id = outstream.CreateLC (*store);

    62 	//Write version of the policy

    63 	outstream.WriteReal32L (TReal(DEFAULT_VERSION));

    64 

    65 	TInt aliasCnt(aPolicy.AliasGroup().Count());

    66 	outstream.WriteInt32L (aliasCnt);

    67 	RAliasGroup aliasGroups = aPolicy.AliasGroup();

    68 	for (TInt i(0); i!=aliasCnt;++i)

    69 		{

    70 		CPermission* alias = aliasGroups[i];

    71 		alias->ExternalizeL (outstream);

    72 		}

    73 	

    74 	TInt domainCnt(aPolicy.ProtectionDomain().Count ());

    75 	outstream.WriteInt32L (domainCnt);

    76 	RProtectionDomains domains = aPolicy.ProtectionDomain ();

    77 	for (TInt i(0); i!=domainCnt;++i)

    78 		{

    79 		CProtectionDomain* domain = domains[i];

    80 		domain->ExternalizeL (outstream);

    81 		}

    82 

    83 	// Commit changes to the stream

    84 	outstream.CommitL ();

    85 

    86 	CleanupStack::PopAndDestroy (&outstream);

    87 

    88 	// Set this stream id as the root

    89 	store->SetRootL (id);

    90 

    91 	// Commit changes to the store

    92 	store->CommitL ();

    93 

    94 	CleanupStack::PopAndDestroy (store);

    95 	CleanupStack::PopAndDestroy (policyFile);

    96 	__UHEAP_MARKEND;

    97 	}

    98 

    99 

   100 TInt CSecMgrStore::RemovePolicy(TPolicyID aPolicyID)

   101 	{

   102 	HBufC *policyFile = HBufC::NewLC(KMaxName);

   103 	TPtr ptr(policyFile->Des());

   104 	TInt ret(KErrNone);

   105 	

   106 	ret = GetPolicyFile(ptr, aPolicyID);

   107 	

   108 	if(KErrNone==ret)

   109 		ret  = iFsSession.Delete (ptr);

   110 	CleanupStack::PopAndDestroy(policyFile);

   111 	return ret;

   112 	}

   113 

   114 void CSecMgrStore::RestorePoliciesL(RPolicies& aPolicy)

   115 	{

   116 	//Fetch all the individual policy files from "epoc32\winscw\c\private\<SECMGR_UID>\policy" directory

   117 	//Iteratively internalise the policy files, with the policyID (PolicyID is = to filename)

   118 	HBufC *privateDir = HBufC::NewLC(KMaxName);

   119 	TPtr privateDirptr(privateDir->Des());

   120 	GetPolicyPath (privateDirptr);

   121 

   122 	// create search string

   123 	HBufC* searchBuf = privateDirptr.AllocLC ();

   124 	TPtr searchPtr(searchBuf->Des());

   125 

   126 	CDir* dir=  NULL;

   127 	iFsSession.GetDir (searchPtr, KEntryAttNormal,

   128 			ESortByName | EAscending, dir);

   129 

   130 	if ( dir)

   131 		{

   132 		CleanupStack::PushL (dir);

   133 		for (TInt i=0; i!=dir->Count ();++i)

   134 			{

   135 			TEntry entry = dir->operator[] (i);

   136 			HBufC *fileName = HBufC::NewLC(KMaxName);

   137 			TPtr ptr(fileName->Des());

   138 			ptr = entry.iName;

   139 

   140 			HBufC *policyFile = HBufC::NewLC(KMaxName);

   141 			TPtr policyFileptr(policyFile->Des());

   142 			policyFileptr.Copy(privateDirptr) ;

   143 			policyFileptr.Append (ptr);

   144 

   145 			CFileStore* store = CPermanentFileStore::OpenLC (iFsSession,

   146 					policyFileptr, EFileShareAny);

   147 

   148 			RStoreReadStream instream;

   149 			instream.OpenLC (*store, store->Root ());

   150 

   151 			TLex16 lexer(ptr);

   152 			TPolicyID pID;

   153 			lexer.Val (pID);

   154 

   155 			CPolicy* policy = CPolicy::NewL (pID, instream);

   156 			aPolicy.Append (policy);

   157 

   158 			CleanupStack::PopAndDestroy (&instream); //instream

   159 			CleanupStack::PopAndDestroy (store); //store

   160 			CleanupStack::PopAndDestroy (policyFile);

   161 			CleanupStack::PopAndDestroy (fileName);

   162 			}

   163 

   164 		CleanupStack::PopAndDestroy (dir);

   165 		}

   166 

   167 	CleanupStack::PopAndDestroy (searchBuf);

   168 	CleanupStack::PopAndDestroy (privateDir);

   169 	}

   170 

   171 void CSecMgrStore::RegisterScriptL(TExecutableID aExecID, const CScript& aScript)

   172 	{

   173 	HBufC *scriptFile = HBufC::NewLC(KMaxName);

   174 	TPtr ptr(scriptFile->Des());

   175 	User::LeaveIfError(GetScriptFile(ptr,aExecID));

   176 

   177 	CFileStore* store = CPermanentFileStore::ReplaceLC (iFsSession, ptr,

   178 			EFileWrite);

   179 

   180 	// Must say what kind of file store.

   181 	store->SetTypeL (KPermanentFileStoreLayoutUid);

   182 

   183 	// Construct the output stream.

   184 	RStoreWriteStream outstream;

   185 	TStreamId id = outstream.CreateLC (*store);

   186 

   187 	aScript.ExternalizeL (outstream);

   188 

   189 	// Commit changes to the stream

   190 	outstream.CommitL ();

   191 

   192 	// Cleanup the stream object

   193 	CleanupStack::PopAndDestroy (&outstream);

   194 

   195 	// Set this stream id as the root

   196 	store->SetRootL (id);

   197 

   198 	// Commit changes to the store

   199 	store->CommitL ();

   200 

   201 	CleanupStack::PopAndDestroy (store);

   202 	CleanupStack::PopAndDestroy (scriptFile);

   203 

   204 	}

   205 

   206 void CSecMgrStore::UnRegisterScriptL(TExecutableID aExecID)

   207 	{

   208 	HBufC *scriptFile = HBufC::NewLC(KMaxName);

   209 	TPtr ptr(scriptFile->Des());

   210 	User::LeaveIfError (GetScriptFile (ptr,aExecID));

   211 

   212 	if ( BaflUtils::FileExists (iFsSession, ptr))

   213 		iFsSession.Delete (ptr);

   214 	else

   215 		{

   216 		User::Leave(ErrInvalidScriptID);

   217 		}

   218 	CleanupStack::PopAndDestroy (scriptFile);

   219 	}

   220 

   221 TInt CSecMgrStore::ReadScriptInfo(TExecutableID aExecID, CScript& aScriptInfo)

   222 	{

   223 	__UHEAP_MARK;

   224 

   225 	HBufC *scriptFile = HBufC::NewLC(KMaxName);

   226 	TPtr ptr(scriptFile->Des());

   227 	TInt ret(GetScriptFile (ptr, aExecID));

   228 

   229 	if ( KErrNone==ret)

   230 		{

   231 		if ( !BaflUtils::FileExists(iFsSession, ptr))

   232 			{

   233 			return ErrInvalidScriptID;

   234 			}

   235 

   236 		CFileStore* store=  NULL;

   237 		store=CPermanentFileStore::OpenLC (iFsSession, ptr,

   238 				EFileShareAny);

   239 

   240 		if ( KErrNone==ret)

   241 			{

   242 			RStoreReadStream instream;

   243 			instream.OpenLC (*store, store->Root ());

   244 

   245 			aScriptInfo.InternalizeL (instream);

   246 

   247 			CleanupStack::PopAndDestroy (&instream);

   248 			CleanupStack::PopAndDestroy (store);

   249 			}

   250 		return ret;

   251 		}

   252 	CleanupStack::PopAndDestroy (scriptFile);

   253 	__UHEAP_MARKEND;

   254 

   255 	return ret;

   256 	}

   257 

   258 TInt CSecMgrStore::GetScriptFile(TExecutableID aExecID, TDes& aScriptFile)

   259 	{

   260 	TInt ret(GetScriptFile (aScriptFile,aExecID));

   261 

   262 	if ( KErrNone==ret)

   263 		{

   264 		if ( !BaflUtils::FileExists(iFsSession, aScriptFile))

   265 			{

   266 			return ErrInvalidScriptID;

   267 			}

   268 		}

   269 

   270 	return ret;

   271 	}

   272 

   273 void CSecMgrStore::WriteScriptInfoL(TExecutableID aExecID, CScript& aScriptInfo)

   274 	{

   275 	__UHEAP_MARK;

   276 

   277 	HBufC *scriptFile = HBufC::NewLC(KMaxName);

   278 	TPtr ptr(scriptFile->Des());

   279 	User::LeaveIfError (GetScriptFile (ptr,aExecID));

   280 

   281 	CFileStore* store = CPermanentFileStore::ReplaceLC (iFsSession, ptr,

   282 			EFileWrite);

   283 

   284 	// Must say what kind of file store.

   285 	store->SetTypeL (KPermanentFileStoreLayoutUid);

   286 

   287 	// Construct the output stream.

   288 	RStoreWriteStream outstream;

   289 	TStreamId id = outstream.CreateLC (*store);

   290 

   291 	aScriptInfo.ExternalizeL (outstream);

   292 

   293 	// Commit changes to the stream

   294 	outstream.CommitL ();

   295 

   296 	// Cleanup the stream object

   297 	CleanupStack::PopAndDestroy (&outstream);

   298 

   299 	// Set this stream id as the root

   300 	store->SetRootL (id);

   301 

   302 	// Commit changes to the store

   303 	store->CommitL ();

   304 

   305 	CleanupStack::PopAndDestroy (store);

   306 	CleanupStack::PopAndDestroy (scriptFile);

   307 	__UHEAP_MARKEND;

   308 	}

   309 

   310 TInt CSecMgrStore::ReadCounter(TExecutableID& aExecID)

   311 	{

   312 	HBufC *configFile = HBufC::NewLC(KMaxName);

   313 	TPtr ptr(configFile->Des());

   314 	TInt ret(GetConfigFile (ptr));

   315 

   316 	if ( KErrNone==ret)

   317 		{

   318 		if ( !BaflUtils::FileExists(iFsSession,*configFile))

   319 			{

   320 			aExecID = (TExecutableID)KCRUIdSecMgr.iUid;

   321 			BaflUtils::EnsurePathExistsL (iFsSession, *configFile);

   322 			CleanupStack::PopAndDestroy (configFile);

   323 			return WriteCounter (aExecID);

   324 			}

   325 

   326 		CFileStore* store = CPermanentFileStore::OpenLC (iFsSession,

   327 				*configFile, EFileRead);

   328 

   329 		RStoreReadStream instream;

   330 		instream.OpenLC (*store, store->Root ());

   331 

   332 		aExecID = instream.ReadInt32L ();

   333 

   334 		CleanupStack::PopAndDestroy (&instream);

   335 		CleanupStack::PopAndDestroy (store);

   336 		}

   337 	CleanupStack::PopAndDestroy (configFile);

   338 	return ret;

   339 	}

   340 

   341 TInt CSecMgrStore::WriteCounter(TExecutableID aExecID)

   342 	{

   343 	HBufC *configFile = HBufC::NewLC(KMaxName);

   344 	TPtr ptr(configFile->Des());

   345 	TInt ret(GetConfigFile (ptr));

   346 

   347 	if ( KErrNone==ret)

   348 		{

   349 		CFileStore* store = CPermanentFileStore::ReplaceLC (iFsSession,

   350 				*configFile, EFileWrite);

   351 

   352 		// Must say what kind of file store.

   353 		store->SetTypeL (KPermanentFileStoreLayoutUid);

   354 

   355 		// Construct the output stream.

   356 		RStoreWriteStream outstream;

   357 		TStreamId id = outstream.CreateLC (*store);

   358 

   359 		outstream.WriteInt32L (aExecID);

   360 

   361 		// Commit changes to the stream

   362 		outstream.CommitL ();

   363 

   364 		// Cleanup the stream object

   365 		CleanupStack::PopAndDestroy (&outstream);

   366 

   367 		// Set this stream id as the root

   368 		store->SetRootL (id);

   369 

   370 		// Commit changes to the store

   371 		store->CommitL ();

   372 

   373 		CleanupStack::PopAndDestroy (store);

   374 		}

   375 	CleanupStack::PopAndDestroy (configFile);

   376 	return ret;

   377 	}

   378 

   379 TInt CSecMgrStore::GetPrivatePath(TDes& aPrivatePath)

   380 	{

   381 	TInt ret(KErrNone);

   382 	aPrivatePath.Append (KCDrive);

   383 

   384 	HBufC *privateDir = HBufC::NewLC(KMaxName);

   385 	TPtr ptr(privateDir->Des());

   386 	ret = iFsSession.PrivatePath (ptr);

   387 

   388 	if ( KErrNone==ret)

   389 		{

   390 		aPrivatePath.Append (ptr);

   391 		}

   392 	CleanupStack::PopAndDestroy (privateDir);

   393 	return ret;

   394 	}

   395 

   396 TInt CSecMgrStore::GetConfigFile(TDes& aConfigFile)

   397 	{

   398 	TInt ret(KErrNone);

   399 

   400 	aConfigFile.Append (KCDrive);

   401 

   402 	HBufC *privateDir = HBufC::NewLC(KMaxName);

   403 	TPtr ptr(privateDir->Des());

   404 	ret = iFsSession.PrivatePath (ptr);

   405 

   406 	if ( KErrNone==ret)

   407 		{

   408 		aConfigFile.Append (ptr);

   409 

   410 		ret = iFsSession.MkDirAll (ptr);

   411 

   412 		if ( KErrAlreadyExists==ret)

   413 			ret=KErrNone;

   414 

   415 		aConfigFile.Append (KConfigFile);

   416 		}

   417 	CleanupStack::PopAndDestroy (privateDir);

   418 	return ret;

   419 	}

   420 

   421 TInt CSecMgrStore::GetPolicyPath(TDes& aFile)

   422 	{

   423 	TInt ret(GetPrivatePath (aFile));

   424 

   425 	if ( KErrNone==ret)

   426 		{

   427 		aFile.Append (KPolicyDir);

   428 		aFile.Append (KDirSeparator);

   429 

   430 		TRAP (ret, BaflUtils::EnsurePathExistsL (iFsSession, aFile));

   431 		}

   432 

   433 	return ret;

   434 	}

   435 

   436 TInt CSecMgrStore::GetScriptPath(TDes& aFile)

   437 	{

   438 	TInt ret(GetPrivatePath (aFile));

   439 

   440 	if ( KErrNone==ret)

   441 		{

   442 		aFile.Append (KScriptDir);

   443 		aFile.Append (KDirSeparator);

   444 

   445 		TRAP (ret, BaflUtils::EnsurePathExistsL (iFsSession, aFile));

   446 

   447 		if ( KErrAlreadyExists==ret)

   448 			ret = KErrNone;

   449 		}

   450 

   451 	return ret;

   452 	}

   453 

   454 TInt CSecMgrStore::GetScriptFile(TDes& aFile, TExecutableID aExecID)

   455 	{

   456 	TInt ret(GetScriptPath (aFile));

   457 

   458 	if ( (KErrNone==ret) || (KErrAlreadyExists==ret))

   459 		{

   460 		if ( KAnonymousScript!=aExecID)

   461 			{

   462 			HBufC *fSuffix = HBufC::NewLC(KMaxName);

   463 			TPtr fSuffixPtr(fSuffix->Des());

   464 			fSuffixPtr.Num (aExecID);

   465 

   466 			aFile.Append (fSuffixPtr);

   467 			aFile.Append (KDatExtn);

   468 			CleanupStack::PopAndDestroy (fSuffix);

   469 			}

   470 		}

   471 

   472 	if ( KErrAlreadyExists==ret)

   473 		ret=KErrNone;

   474 

   475 	return ret;

   476 	}

   477 

   478 TInt CSecMgrStore::GetPolicyFile(TDes& aFile, TPolicyID aPolicyID)

   479 	{

   480 	TInt ret(GetPolicyPath (aFile));

   481 

   482 	if ( (KErrNone==ret) || (KErrAlreadyExists==ret))

   483 		{

   484 		HBufC *fPolicyName = HBufC::NewLC(KMaxName);

   485 		TPtr policyNamePtr(fPolicyName->Des());

   486 		policyNamePtr.Num (aPolicyID);

   487 

   488 		aFile.Append (policyNamePtr);

   489 		aFile.Append (KDatExtn);

   490 		CleanupStack::PopAndDestroy (fPolicyName);

   491 		}

   492 

   493 	return ret;

   494 	}

   495 

   496 

   497 TInt CSecMgrStore::BackupFile(TPolicyID aPolicyID)

   498 {

   499 	HBufC *policyFile = HBufC::NewLC(KMaxName);

   500 	TPtr policyFilePtr(policyFile->Des());

   501 	

   502 	HBufC *tempPolicyFile = HBufC::NewLC(KMaxName);

   503 	TPtr tempPolicyFilePtr(tempPolicyFile->Des());

   504 	

   505 	TInt ret(GetPolicyFile(policyFilePtr, aPolicyID));

   506 

   507 	ret= GetPolicyPath (tempPolicyFilePtr);

   508 

   509 	if ( (KErrNone==ret) || (KErrAlreadyExists==ret))

   510 	{

   511 		HBufC *fPolicyName = HBufC::NewLC(KMaxName);

   512 		TPtr policyNamePtr(fPolicyName->Des());

   513 		policyNamePtr.Num (aPolicyID);

   514 

   515 		tempPolicyFilePtr.Append (policyNamePtr);

   516 		tempPolicyFilePtr.Append (_L("_temp"));

   517 		tempPolicyFilePtr.Append (KDatExtn);

   518 		

   519 		CleanupStack::PopAndDestroy(fPolicyName);

   520 	}

   521 	

   522 	CFileMan *fm = CFileMan::NewL(iFsSession);

   523 	TInt backupResult = fm->Copy(policyFilePtr, tempPolicyFilePtr, CFileMan::EOverWrite);

   524 	delete fm;

   525 	

   526 	CleanupStack::PopAndDestroy(tempPolicyFile);

   527 	CleanupStack::PopAndDestroy(policyFile);

   528 	

   529 	return backupResult;	

   530 }

   531 

   532 TInt CSecMgrStore::RemoveTempPolicy(TPolicyID aPolicyID)

   533 {

   534 	HBufC *tempPolicyFile = HBufC::NewLC(KMaxName);

   535 	TPtr tempPolicyFilePtr(tempPolicyFile->Des());

   536 	

   537 	TInt ret= GetPolicyPath (tempPolicyFilePtr);

   538 

   539 	if ( (KErrNone==ret) || (KErrAlreadyExists==ret))

   540 	{

   541 		HBufC *fPolicyName = HBufC::NewLC(KMaxName);

   542 		TPtr policyNamePtr(fPolicyName->Des());

   543 		policyNamePtr.Num (aPolicyID);

   544 

   545 		tempPolicyFilePtr.Append (policyNamePtr);

   546 		tempPolicyFilePtr.Append (_L("_temp"));

   547 		tempPolicyFilePtr.Append (KDatExtn);

   548 		

   549 		CleanupStack::PopAndDestroy(fPolicyName);

   550 	}

   551 	

   552 	CFileMan *fm = CFileMan::NewL(iFsSession);

   553 	TInt rmTempResult = fm->Delete(tempPolicyFilePtr);

   554 	delete fm;

   555 	

   556 	CleanupStack::PopAndDestroy(tempPolicyFile);

   557 		

   558 	return rmTempResult;	

   559 }

   560 

   561 TInt CSecMgrStore::RestoreTempPolicy(TPolicyID aPolicyID)

   562 {

   563 	HBufC *policyFile = HBufC::NewLC(KMaxName);

   564 	TPtr policyFilePtr(policyFile->Des());

   565 	

   566 	HBufC *tempPolicyFile = HBufC::NewLC(KMaxName);

   567 	TPtr tempPolicyFilePtr(tempPolicyFile->Des());

   568 	

   569 	TInt ret(GetPolicyFile(policyFilePtr, aPolicyID));

   570 

   571 	ret= GetPolicyPath (tempPolicyFilePtr);

   572 

   573 	if ( (KErrNone==ret) || (KErrAlreadyExists==ret))

   574 	{

   575 		HBufC *fPolicyName = HBufC::NewLC(KMaxName);

   576 		TPtr policyNamePtr(fPolicyName->Des());

   577 		policyNamePtr.Num (aPolicyID);

   578 

   579 		tempPolicyFilePtr.Append (policyNamePtr);

   580 		tempPolicyFilePtr.Append (_L("_temp"));

   581 		tempPolicyFilePtr.Append (KDatExtn);

   582 		

   583 		CleanupStack::PopAndDestroy(fPolicyName);

   584 	}

   585 	

   586 	CFileMan *fm = CFileMan::NewL(iFsSession);

   587 	TInt restoreResult = fm->Copy(tempPolicyFilePtr, policyFilePtr, CFileMan::EOverWrite);

   588 	delete fm;

   589 	

   590 	CleanupStack::PopAndDestroy(tempPolicyFile);

   591 	CleanupStack::PopAndDestroy(policyFile);

   592 	return restoreResult;

   593 }