os/security/cryptoservices/certificateandkeymgmt/certstore/unifiedcertstore.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) 1998-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 "unifiedcertstore.h"
    20 #include "unifiedcertstoreworkingvars.h"
    21 #include "CCheckedCertStore.h"
    22 #include <certificateapps.h>
    23 #include <x509cert.h>
    24 #include <wtlscert.h>
    25 #include <hash.h>
    26 #include <ecom/ecom.h>
    27 
    28 _LIT(KUCSPanic, "CUnifiedCertStore"); 
    29 #define assert(x) __ASSERT_ALWAYS((x), User::Panic(KUCSPanic, 1));
    30 
    31 /////////////////////////////////////////////////////////////////////////////////////
    32 //CUnifiedCertStore
    33 /////////////////////////////////////////////////////////////////////////////////////
    34 
    35 EXPORT_C CUnifiedCertStore* CUnifiedCertStore::NewL(RFs& aFs, TBool aOpenForWrite)
    36 	{
    37 	CUnifiedCertStore* self = CUnifiedCertStore::NewLC(aFs, aOpenForWrite);
    38 	CleanupStack::Pop(self);
    39 	return self;
    40 	}
    41 
    42 EXPORT_C CUnifiedCertStore* CUnifiedCertStore::NewLC(RFs& aFs, TBool aOpenForWrite)
    43 	{
    44 	CUnifiedCertStore* self = new(ELeave) CUnifiedCertStore(aFs, aOpenForWrite);
    45 	CleanupStack::PushL(self);
    46 	RArray<TInt> orderingFilter;
    47 	self->ConstructL(orderingFilter);
    48 	return self;
    49 	}
    50 
    51 EXPORT_C CUnifiedCertStore::~CUnifiedCertStore()
    52 	{
    53 	Cancel();
    54 
    55 	assert(!iWorkingVars);
    56 
    57 	TInt end = iReadOnlyCertStores.Count();
    58 	TInt i;
    59 	for (i = 0; i < end; i++)
    60 		{
    61 		iReadOnlyCertStores[i]->Release();
    62 		}
    63 	iReadOnlyCertStores.Close();
    64 
    65 	end = iWritableCertStores.Count();
    66 	for (i = 0; i < end; i++)
    67 		{
    68 		iWritableCertStores[i]->Release();
    69 		}
    70 	iWritableCertStores.Close();
    71 
    72 	// The elements are already released by the two loops above
    73 	iCertStores.Close();
    74 	
    75 	// release resources allocated to order attributes list
    76 	iOrderAttributes.Close();
    77     
    78     DestroyTemporaryMembers();
    79 	iHardwareTypeUids.Close();
    80 	REComSession::FinalClose();
    81 	}
    82 
    83 
    84 EXPORT_C void CUnifiedCertStore::Initialize(TRequestStatus& aStatus)
    85 	{
    86 	BeginAsyncOp(aStatus, EInitializeGetTokenList);
    87 	TRAPD(err, InitializeL());
    88 	if (err != KErrNone)
    89 		{
    90 		Complete(err);
    91 		}
    92 	}
    93 
    94 void CUnifiedCertStore::InitializeL()
    95 	{
    96 	AllocWorkingVarsL();
    97 	
    98 	// We want the list of all token types that support a readable or writable 
    99 	// certstore interface
   100 	RArray<TUid> uidArray;
   101 	CleanupClosePushL(uidArray);
   102 		
   103 	User::LeaveIfError(uidArray.Append(TUid::Uid(KInterfaceWritableCertStore)));
   104 	
   105 	TCTFindTokenTypesByInterface filter(uidArray.Array());
   106 	CCTTokenTypeInfo::ListL(iWorkingVars->iWritableTokenTypes, filter);
   107 
   108 	uidArray.Reset();
   109 
   110 	User::LeaveIfError(uidArray.Append(TUid::Uid(KInterfaceCertStore)));
   111 
   112 	RCPointerArray<CCTTokenTypeInfo> tokenTypes;
   113 	CleanupClosePushL(tokenTypes);
   114 
   115 	TCTFindTokenTypesByInterface filter2(uidArray.Array());
   116 	CCTTokenTypeInfo::ListL(tokenTypes, filter2);
   117 	
   118   	// Check whether client specified order list has attributes in it
   119   	if(iOrderAttributes.Count() > 0)
   120   	    {
   121   	    ApplyOrderingL(tokenTypes);
   122   	    }
   123 
   124 	// Make a note of all hardware token types
   125 	TInt i = 0;
   126 	TInt end = tokenTypes.Count();
   127 	for (; i < end; i++)
   128 		{
   129 		TCTTokenTypeAttribute software;
   130 		software.iUID = KCTSoftware;
   131 		TInt find = tokenTypes[i]->Attributes().Find(software);
   132 		// In the case (TInt)ETrue == KThirdPartyCertStore == 1  
   133 		if (find != KErrNotFound && tokenTypes[i]->Attributes()[find].iVal != 
   134 			(TInt)ETrue && tokenTypes[i]->Attributes()[find].iVal != KManufactureCertStore)
   135 			{
   136 			// This is a hardware type. Add its UID to the list.
   137 			User::LeaveIfError(iHardwareTypeUids.Append(tokenTypes[i]->Type()));
   138 			}
   139 		}
   140 
   141 	i = 0;
   142 	while (i < end)
   143 		{
   144 		TInt j = 0;
   145 		TInt jEnd = iWorkingVars->iWritableTokenTypes.Count();
   146 		while (j < jEnd)
   147 			{
   148 			if (iWorkingVars->iWritableTokenTypes[j]->Type() == tokenTypes[i]->Type())
   149 				{
   150 				break;
   151 				}
   152 			j++;
   153 			}
   154 		if (j == jEnd)
   155 			{
   156 			User::LeaveIfError(iWorkingVars->iReadOnlyTokenTypes.Append(tokenTypes[i]));
   157 			tokenTypes.Remove(i);
   158 			end--;
   159 			}
   160 		else
   161 			{
   162 			i++;
   163 			}
   164 		}
   165 
   166 	CleanupStack::PopAndDestroy(2);	// uidArray, tokenTypes
   167 	
   168 	iWorkingVars->iIndex = -1;
   169 
   170 	TRequestStatus* status = &iStatus;
   171 	User::RequestComplete(status, KErrNone);
   172 	SetActive();
   173 	}
   174 
   175 EXPORT_C void CUnifiedCertStore::CancelInitialize()
   176 	{
   177 	if (iState == EInitializeGetTokenList ||
   178 		iState == EInitializeGetToken ||
   179 		iState == EInitializeGetWritableInterface ||
   180 		iState == EInitializeGetReadableInterface ||
   181 		iState == EInitializeGetReadableInterfaceFinished ||
   182 		iState == EInitializeFinished)
   183 		{
   184 		Cancel();
   185 		}	
   186 	}
   187 
   188 void CUnifiedCertStore::List(RMPointerArray<CCTCertInfo>& aCertInfos,
   189 							 const CCertAttributeFilter& aFilter,
   190 							 TRequestStatus& aStatus)
   191 	{
   192 	BeginAsyncOp(aStatus, EList);	
   193 	TRAPD(err, ListL(aCertInfos, aFilter));
   194 	if (err != KErrNone)
   195 		{
   196 		Complete(err);
   197 		}
   198 	}
   199 
   200 void CUnifiedCertStore::ListL(RMPointerArray<CCTCertInfo>& aCertInfos,
   201 							  const CCertAttributeFilter& aFilter)
   202 	{
   203 	if (!iIsInitialized)
   204 		{
   205 		User::Leave(KErrNotReady);
   206 		}
   207 
   208 	AllocWorkingVarsL();
   209 	iWorkingVars->iCertInfos = &aCertInfos;
   210 	iWorkingVars->iFilter = &aFilter;
   211 	iWorkingVars->iCertIndex = aCertInfos.Count();
   212 	iIndex = -1;
   213 	
   214 	SetActive();
   215 	TRequestStatus* status = &iStatus;
   216 	User::RequestComplete(status, KErrNone);
   217 	}
   218 
   219 void CUnifiedCertStore::CancelList()
   220 	{
   221 	if (iState == EList ||
   222 		iState == ERetrieveForList)
   223 		{
   224 		Cancel();
   225 		}
   226 	}
   227 
   228 EXPORT_C void CUnifiedCertStore::List(RMPointerArray<CCTCertInfo>& aCertInfos,
   229 									  const CCertAttributeFilter& aFilter, 
   230 									  const TDesC8& aIssuer, 
   231 									  TRequestStatus& aStatus)
   232 	{
   233 	RPointerArray<const TDesC8> array;
   234 	if (array.Append(&aIssuer) != KErrNone)
   235 		{
   236 		TRequestStatus* status = &aStatus;
   237 		User::RequestComplete(status, KErrNoMemory);
   238 		}
   239 	else
   240 		{
   241 		List(aCertInfos, aFilter, array, aStatus);
   242 		array.Close();
   243 		}
   244 	}
   245 
   246 EXPORT_C void CUnifiedCertStore::List(RMPointerArray<CCTCertInfo>& aCertInfos,
   247 									  const CCertAttributeFilter& aFilter, 
   248 									  RPointerArray<const TDesC8> aIssuers, 
   249 									  TRequestStatus& aStatus)
   250 	{
   251 	BeginAsyncOp(aStatus, EList);	
   252 	TRAPD(err, ListL(aCertInfos, aFilter, aIssuers));
   253 	if (err != KErrNone)
   254 		{
   255 		Complete(err);
   256 		}
   257 	}
   258 
   259 void CUnifiedCertStore::ListL(RMPointerArray<CCTCertInfo>& aCertInfos,
   260 							  const CCertAttributeFilter& aFilter, 
   261 							  RPointerArray<const TDesC8> aIssuers)
   262 	{
   263 	// Obscure special case: If aIssuers has no elements, we should
   264 	// return nothing.
   265 	if (aIssuers.Count() == 0)
   266 		{
   267 		Complete(KErrNone);
   268 		return;
   269 		}
   270 
   271 	AllocWorkingVarsL();
   272 	iWorkingVars->iCertInfos = &aCertInfos;
   273 	iWorkingVars->iFilter = &aFilter;
   274 	iWorkingVars->iCertIndex = aCertInfos.Count();
   275 	
   276 	TInt count = aIssuers.Count();
   277 	for (TInt i = 0 ; i < count ; ++i)
   278 		{
   279 		User::LeaveIfError(iWorkingVars->iIssuerNames.Append(aIssuers[i]));
   280 		}
   281 	
   282 	iIndex = -1;
   283 	SetActive();
   284 	TRequestStatus* status = &iStatus;
   285 	User::RequestComplete(status, KErrNone);	
   286 	}
   287 
   288 EXPORT_C void CUnifiedCertStore::Retrieve(const CCTCertInfo& aCertInfo, 
   289 								 CCertificate*& aCert,
   290 								 TRequestStatus& aStatus)
   291 	{
   292 	BeginAsyncOp(aStatus, ERetrieve);	
   293 	TRAPD(err, RetrieveL(aCertInfo, aCert));
   294 	if (err != KErrNone)
   295 		{
   296 		Complete(err);
   297 		}
   298 	}
   299 
   300 void CUnifiedCertStore::RetrieveL(const CCTCertInfo& aCertInfo, 
   301 								  CCertificate*& aCert)
   302 	{
   303 	FindCertStoreL(aCertInfo.Handle());
   304 
   305     if (aCertInfo.CertificateFormat() != EX509Certificate &&
   306         aCertInfo.CertificateFormat() != EWTLSCertificate)
   307         {
   308         User::Leave(KErrNotSupported);
   309         }
   310 
   311 	AllocWorkingVarsL();
   312 	iWorkingVars->iCertDesC = HBufC8::NewMaxL(aCertInfo.Size());
   313 	iWorkingVars->iReturnedCert = &aCert;
   314 	iWorkingVars->iCertType = aCertInfo.CertificateFormat();
   315 	iWorkingVars->iCertDes.Set(iWorkingVars->iCertDesC->Des());
   316 	iCurrentCertStore->Retrieve(aCertInfo, iWorkingVars->iCertDes, iStatus);
   317 	SetActive();
   318     }
   319 
   320 void CUnifiedCertStore::GetCert(CCTCertInfo*& aCertInfo, 
   321 								const TCTTokenObjectHandle& aHandle, 
   322 								TRequestStatus& aStatus)
   323 	{
   324 	BeginAsyncOp(aStatus, EGetCert);
   325 	TRAPD(err, GetCertL(aCertInfo, aHandle));
   326 	if (err != KErrNone)
   327 		{
   328 		Complete(err);
   329 		}
   330 	}
   331 
   332 void CUnifiedCertStore::GetCertL(CCTCertInfo*& aCertInfo,
   333 								 const TCTTokenObjectHandle& aHandle)
   334 	{
   335 	FindCertStoreL(aHandle);
   336 	iCurrentCertStore->GetCert(aCertInfo, aHandle, iStatus);
   337 	SetActive();
   338 	}
   339 
   340 void CUnifiedCertStore::CancelGetCert()
   341 	{
   342 	if (iState == EGetCert)
   343 		{
   344 		Cancel();
   345 		}
   346 	}
   347 
   348 void CUnifiedCertStore::Applications(const CCTCertInfo& aCertInfo,
   349 									 RArray<TUid>& aApplications,
   350 									 TRequestStatus& aStatus)
   351 	{
   352 	BeginAsyncOp(aStatus, EApplications);
   353 	TRAPD(err, ApplicationsL(aCertInfo, aApplications));
   354 	if (err != KErrNone)
   355 		{
   356 		Complete(err);
   357 		}
   358 	}
   359 
   360 void CUnifiedCertStore::ApplicationsL(const CCTCertInfo& aCertInfo,
   361 									 RArray<TUid>& aApplications)
   362 	{
   363 	FindCertStoreL(aCertInfo.Handle());
   364 	iCurrentCertStore->Applications(aCertInfo, aApplications, iStatus);
   365 	SetActive();
   366 	}
   367 
   368 void CUnifiedCertStore::CancelApplications()
   369 	{
   370 	if (iState == EApplications)
   371 		{
   372 		Cancel();
   373 		}
   374 	}
   375 
   376 void CUnifiedCertStore::IsApplicable(const CCTCertInfo& aCertInfo,
   377 									 TUid aApplication, 
   378 									 TBool& aIsApplicable, 
   379 									 TRequestStatus& aStatus)
   380 	{
   381 	BeginAsyncOp(aStatus, EIsApplicable);
   382 	TRAPD(err, IsApplicableL(aCertInfo, aApplication, aIsApplicable));
   383 	if (err != KErrNone)
   384 		{
   385 		Complete(err);
   386 		}
   387 	}
   388 
   389 void CUnifiedCertStore::IsApplicableL(const CCTCertInfo& aCertInfo,
   390 									  TUid aApplication, 
   391 									  TBool& aIsApplicable)
   392 	{
   393 	FindCertStoreL(aCertInfo.Handle());
   394 	iCurrentCertStore->IsApplicable(aCertInfo, aApplication, aIsApplicable, iStatus);
   395 	SetActive();
   396 	}
   397 
   398 void CUnifiedCertStore::CancelIsApplicable()
   399 	{
   400 	if (iState == EIsApplicable)
   401 		{
   402 		Cancel();
   403 		}
   404 	}
   405 
   406 void CUnifiedCertStore::Trusted(const CCTCertInfo& aCertInfo, 
   407 								TBool& aTrusted, 
   408 								TRequestStatus& aStatus)
   409 	{
   410 	BeginAsyncOp(aStatus, ETrusted);
   411 	TRAPD(err, TrustedL(aCertInfo, aTrusted));
   412 	if (err != KErrNone)
   413 		{
   414 		Complete(err);
   415 		}
   416 	}
   417 
   418 void CUnifiedCertStore::TrustedL(const CCTCertInfo& aCertInfo, 
   419 								 TBool& aTrusted)
   420 	{
   421 	FindCertStoreL(aCertInfo.Handle());
   422 	iCurrentCertStore->Trusted(aCertInfo, aTrusted, iStatus);
   423 	SetActive();
   424 	}
   425 
   426 void CUnifiedCertStore::CancelTrusted()
   427 	{
   428 	if (iState == ETrusted)
   429 		{
   430 		Cancel();
   431 		}
   432 	}
   433 
   434 void CUnifiedCertStore::Retrieve(const CCTCertInfo& aCertInfo,
   435 								 TDes8& aEncodedCert,
   436 								 TRequestStatus& aStatus)
   437 	{
   438 	BeginAsyncOp(aStatus, ERetrieveData);
   439 	TRAPD(err, RetrieveDataL(aCertInfo, aEncodedCert));
   440 	if (err != KErrNone)
   441 		{
   442 		Complete(err);
   443 		}
   444 	}
   445 
   446 void CUnifiedCertStore::RetrieveDataL(const CCTCertInfo& aCertInfo,
   447 									  TDes8& aEncodedCert)
   448 	{
   449 	FindCertStoreL(aCertInfo.Handle());
   450 	iCurrentCertStore->Retrieve(aCertInfo, aEncodedCert, iStatus);	
   451 	SetActive();
   452 	}
   453 
   454 void CUnifiedCertStore::CancelRetrieve()
   455 	{
   456 	if (iState == ERetrieveData)
   457 		{
   458 		Cancel();
   459 		}
   460 	}
   461 
   462 EXPORT_C void CUnifiedCertStore::Remove(const CCTCertInfo& aCertInfo,
   463 										TRequestStatus& aStatus)
   464 	{
   465 	BeginAsyncOp(aStatus, ERemove);
   466 	TRAPD(err, RemoveL(aCertInfo));
   467 	if (err != KErrNone)
   468 		{
   469 		Complete(err);
   470 		}
   471 	}
   472 
   473 void CUnifiedCertStore::RemoveL(const CCTCertInfo& aCertInfo)
   474 	{
   475 	FindWritableCertStoreL(aCertInfo.Handle());
   476 	iCurrentWritableCertStore->Remove(aCertInfo, iStatus);	
   477 	SetActive();
   478 	}
   479 
   480 EXPORT_C void CUnifiedCertStore::CancelRemove()
   481 	{
   482 	if (iState == ERemove)
   483 		{
   484 		Cancel();
   485 		}
   486 	}
   487 
   488 EXPORT_C void CUnifiedCertStore::SetApplicability(const CCTCertInfo& aCertInfo, 
   489 												  const RArray<TUid>& aApplications,
   490 												  TRequestStatus& aStatus)
   491 	{
   492 	BeginAsyncOp(aStatus, ESetApplicability);	
   493 	TRAPD(err, SetApplicabilityL(aCertInfo, aApplications));
   494 	if (err != KErrNone)
   495 		{
   496 		Complete(err);
   497 		}
   498 	}
   499 
   500 void CUnifiedCertStore::SetApplicabilityL(const CCTCertInfo& aCertInfo, 
   501 										  const RArray<TUid>& aApplications)
   502 	{
   503 	FindWritableCertStoreL(aCertInfo.Handle());
   504 	
   505 	// Search for duplicates in the array of application
   506 	// complete with KErrArgument if there are any duplicates
   507 	if(aApplications.Count() > 1)
   508 		{
   509 		TInt i=0, j=1;
   510 
   511 		for(i=0; i<aApplications.Count()-1; i++ )
   512 			{
   513 			for(j=i+1; j<aApplications.Count(); j++)
   514 				{
   515 				if(aApplications[i] == aApplications[j])
   516 					{
   517 					User::Leave(KErrArgument);
   518 					}
   519 				}		  			
   520 			}
   521 		}
   522 
   523 	// Check requested applications actaully exist
   524 	CCertificateAppInfoManager* appInfoManager = CCertificateAppInfoManager::NewLC(iFs, EFalse);
   525 	const RArray<TCertificateAppInfo>& applications = appInfoManager->Applications();
   526 
   527 	for (TInt i = 0 ; i < aApplications.Count() ; ++i)
   528 		{
   529 		TInt j = 0;
   530 		for ( ; j < applications.Count() ; ++j)
   531 			{
   532 			if (aApplications[i] == applications[j].Id())
   533 				{
   534 				break;
   535 				}
   536 			}
   537 		if (j == applications.Count())
   538 			{
   539 			User::Leave(KErrArgument);
   540 			}
   541 		}
   542 	CleanupStack::PopAndDestroy(appInfoManager);
   543 
   544 	iCurrentWritableCertStore->SetApplicability(aCertInfo, aApplications, iStatus);
   545 	SetActive();
   546 	}
   547 
   548 EXPORT_C void CUnifiedCertStore::CancelSetApplicability()
   549 	{
   550 	if (iState == ESetApplicability)
   551 		{
   552 		Cancel();
   553 		}
   554 	}
   555 
   556 EXPORT_C void CUnifiedCertStore::SetTrust(const CCTCertInfo& aCertInfo, 
   557 										  TBool aTrusted,
   558 										  TRequestStatus& aStatus)
   559 	{
   560 	BeginAsyncOp(aStatus, ESetTrust);	
   561 	TRAPD(err, SetTrustL(aCertInfo, aTrusted));
   562 	if (err != KErrNone)
   563 		{
   564 		Complete(err);
   565 		}
   566 	}
   567 
   568 void CUnifiedCertStore::SetTrustL(const CCTCertInfo& aCertInfo, TBool aTrusted)
   569 	{
   570 	FindWritableCertStoreL(aCertInfo.Handle());
   571 	iCurrentWritableCertStore->SetTrust(aCertInfo, aTrusted, iStatus);
   572 	SetActive();
   573 	}
   574 
   575 EXPORT_C void CUnifiedCertStore::CancelSetTrust()
   576 	{
   577 	if (iState == ESetTrust)
   578 		{
   579 		Cancel();
   580 		}
   581 	}
   582 
   583 /**
   584  * Get the certstore containing a given certificate.
   585  * 
   586  * Returns the certstore containing the cert referenced in certinfo or NULL if
   587  * not found.
   588  */
   589 MCTCertStore* CUnifiedCertStore::GetCertStore(const TCTTokenObjectHandle& aHandle)
   590 	{
   591 	TInt count = iCertStores.Count();
   592 	for (TInt i = 0; i < count; i++)
   593 		{
   594 		MCTCertStore* certstore = iCertStores[i];
   595 		MCTToken& token = certstore->Token();
   596 		if (token.Handle() == aHandle.iTokenHandle)
   597 			{
   598 			return certstore;
   599 			}
   600 		}
   601 	return NULL;
   602 	}
   603 
   604 /**
   605  * Set iCurrentCertStore to the certstore containing a given certificate, or
   606  * leave if it could not be found.  The handle is the handle of the *certinfo*,
   607  * *NOT* the token.
   608  */
   609 void CUnifiedCertStore::FindCertStoreL(const TCTTokenObjectHandle& aHandle)
   610 	{
   611 	assert(!iCurrentCertStore);
   612 	assert(!iCurrentWritableCertStore);
   613 		
   614 	if (!iIsInitialized)
   615 		{
   616 		User::Leave(KErrNotReady);
   617 		}
   618 
   619 	iCurrentCertStore = GetCertStore(aHandle);
   620 	
   621 	if (!iCurrentCertStore)
   622 		{
   623 		User::Leave(KErrNotFound);
   624 		}
   625 	}
   626 
   627 /**
   628  * Set iCurrentWritableCertStore to the writable certstore containing a given
   629  * certificate, or leave if it could not be found.  The handle is the handle of
   630  * the *certinfo*, *NOT* the token.
   631  */
   632 void CUnifiedCertStore::FindWritableCertStoreL(const TCTTokenObjectHandle& aHandle)
   633 	{
   634 	assert(!iCurrentCertStore);
   635 	assert(!iCurrentWritableCertStore);
   636 		
   637 	if (!iIsInitialized)
   638 		{
   639 		User::Leave(KErrNotReady);
   640 		}
   641 
   642 	if (!iOpenedForWrite)
   643 		{
   644 		User::Leave(KErrAccessDenied);
   645 		}
   646 
   647 	iCurrentWritableCertStore = NULL;
   648 	TInt count = iWritableCertStores.Count();
   649 	for (TInt i = 0; i < count; i++)
   650 		{
   651 		MCTWritableCertStore* certstore = iWritableCertStores[i];
   652 		MCTToken& token = certstore->Token();
   653 		if (token.Handle() == aHandle.iTokenHandle)
   654 			{
   655 			iCurrentWritableCertStore = certstore;
   656 			break;
   657 			}
   658 		}
   659 
   660 	if (!iCurrentWritableCertStore)
   661 		{
   662 		User::Leave(KErrNotFound);
   663 		}
   664 	}
   665 
   666 EXPORT_C TInt CUnifiedCertStore::CertStoreCount() const
   667 	{
   668 	return iCertStores.Count();
   669 	}
   670 
   671 EXPORT_C MCTCertStore& CUnifiedCertStore::CertStore(TInt aIndex)
   672 	{
   673 	assert(aIndex < iCertStores.Count());
   674 	return *iCertStores[aIndex];
   675 	}
   676 
   677 EXPORT_C TInt CUnifiedCertStore::WritableCertStoreCount() const
   678 	{
   679 	return iWritableCertStores.Count();
   680 	}
   681 
   682 EXPORT_C MCTWritableCertStore& CUnifiedCertStore::WritableCertStore(TInt aIndex)
   683 	{
   684 	assert(aIndex < iWritableCertStores.Count());
   685 	return *iWritableCertStores[aIndex];
   686 	}
   687 
   688 EXPORT_C TInt CUnifiedCertStore::ReadOnlyCertStoreCount() const
   689 	{
   690 	return iReadOnlyCertStores.Count();
   691 	}
   692 
   693 EXPORT_C MCTCertStore& CUnifiedCertStore::ReadOnlyCertStore(TInt aIndex)
   694 	{
   695 	assert(aIndex < iReadOnlyCertStores.Count());
   696 	return *iReadOnlyCertStores[aIndex];
   697 	}
   698 
   699 CUnifiedCertStore::CUnifiedCertStore(RFs& aFs, TBool aOpenForWrite)
   700 	: CActive(EPriorityNormal), iFs(aFs), iOpenedForWrite(aOpenForWrite), iOrderAttributes()
   701 	{
   702 	CActiveScheduler::Add(this);
   703 	assert(IsAdded());
   704 	}
   705 
   706 void CUnifiedCertStore::ConstructL(RArray<TInt>& aOrderFilter)
   707 	{
   708 
   709  	for (TInt i=0;i<aOrderFilter.Count();i++)
   710  		{
   711  		User::LeaveIfError(iOrderAttributes.Append(aOrderFilter[i]));	
   712  		}
   713 	}
   714 
   715 void CUnifiedCertStore::RunL()
   716 	{
   717 	if ((iState != EInitializeGetReadableInterface) &&
   718 		(iState != EInitializeGetReadableInterfaceFinished) &&
   719 		(iState != EInitializeGetToken)) // We don't want to leave if we're in this state
   720 										 // since we want to enumerate all tokens, see below
   721 		{
   722 		User::LeaveIfError(iStatus.Int());
   723 		}
   724 
   725 	switch (iState)
   726 		{
   727 		case EInitializeGetTokenList:
   728 			// We need to try to get a list of Tokens for each of the Token Types
   729 			iWorkingVars->iIndex++;
   730 			TInt end;
   731 			if (!iCurrentlyDoingReadOnly)
   732 				{
   733 				end = iWorkingVars->iWritableTokenTypes.Count();
   734 				}
   735 			else
   736 				{
   737 				end = iWorkingVars->iReadOnlyTokenTypes.Count();
   738 				}
   739 			if (iWorkingVars->iIndex < end)
   740 				{
   741 				assert(!iTokenType);
   742 				TInt createRes = KErrNone;
   743 				if (iCurrentlyDoingReadOnly)
   744 					{
   745 					TRAP(createRes, iTokenType = MCTTokenType::NewL(*iWorkingVars->iReadOnlyTokenTypes[iWorkingVars->iIndex], iFs));
   746 					}
   747 				else
   748 					{
   749 					TRAP(createRes, iTokenType = MCTTokenType::NewL(*iWorkingVars->iWritableTokenTypes[iWorkingVars->iIndex], iFs));
   750 					}
   751 
   752 				if (KErrNoMemory==createRes)
   753 					{
   754 					// Leave if there's no memory, so OOM tests work
   755 					User::Leave(createRes);
   756 					}
   757 				else if (KErrNone!=createRes)
   758 					{
   759 					//	ECOM couldn't load that token type, don't give up, try the next...
   760 					TRequestStatus* stat = &iStatus;
   761 					User::RequestComplete(stat, KErrNone);
   762 					}
   763 				else
   764 					{
   765 					assert(iTokens.Count() == 0);
   766 					iTokenType->List(iTokens, iStatus);
   767 					iIndexTokens = -1;
   768 					iState = EInitializeGetToken;
   769 					}				   
   770 				}
   771 			else if (!iCurrentlyDoingReadOnly)
   772 				{
   773 				iCurrentlyDoingReadOnly = ETrue;
   774 				iWorkingVars->iIndex = -1;
   775 				TRequestStatus* status = &iStatus;
   776 				User::RequestComplete(status, KErrNone);
   777 				}
   778 			else
   779 				{
   780 				iState = EInitializeFinished;
   781 				TRequestStatus* status = &iStatus;
   782 				User::RequestComplete(status, KErrNone);
   783 				}
   784 			SetActive();
   785 			break;
   786 
   787 		case EInitializeGetToken:
   788 			if (iStatus.Int() == KErrHardwareNotAvailable) 
   789 				{
   790 				// If the hardware corresponding to this
   791 				// TokenType has been removed then just skip it
   792 				// but DO NOT leave!
   793 				++iIndexTokens;
   794 				iState = EInitializeGetToken;
   795 				TRequestStatus* status = &iStatus;
   796 				User::RequestComplete(status,KErrNone);
   797 				}
   798             else 
   799 				{
   800 				User::LeaveIfError(iStatus.Int());
   801 
   802 				// iIndexTokens is initialized at EInitializeGetTokenList
   803 				++iIndexTokens;
   804 
   805 				//	We need to try to get a certstore interface (readable or
   806 				//	writable) for each of the Tokens in iTokens		
   807 				if (iIndexTokens < iTokens.Count())
   808 					{
   809                     assert(!iToken);
   810 					iTokenType->OpenToken(*iTokens[iIndexTokens], iToken, iStatus);
   811 					if ((iOpenedForWrite) && !iCurrentlyDoingReadOnly)
   812 						{
   813 						iState = EInitializeGetWritableInterface;
   814 						}
   815 					else
   816 						{
   817 						iState = EInitializeGetReadableInterface;
   818 						}
   819 					}
   820 				else
   821 					{
   822 					// We don't need the iTokenType anymore
   823 					iTokenType->Release();
   824 					iTokenType = 0;
   825 					// We don't need the list of Tokens anymore
   826 					iTokens.Close();
   827 					iState = EInitializeGetTokenList;
   828 					TRequestStatus* status = &iStatus;
   829 					User::RequestComplete(status, KErrNone);
   830 					}
   831 				}
   832 			SetActive();
   833 			break;
   834 
   835 		case EInitializeGetWritableInterface:
   836 			{
   837 			User::LeaveIfError(iStatus.Int());
   838 			// First we try to get a writable interface to the store, if
   839 			// that doesn't work we will try to get a readable interface
   840             assert(iToken);
   841             assert(!iTokenInterface);
   842 			TUid uid = { KInterfaceWritableCertStore };
   843 			iToken->GetInterface(uid, iTokenInterface, iStatus);
   844 			iState = EInitializeGetReadableInterface;
   845 			SetActive();
   846 			}
   847 			break;
   848 
   849 		case EInitializeGetReadableInterface:
   850 			// We check if we managed to get a writable interface
   851 			if (iStatus == KErrNoMemory)
   852 				{
   853 				User::Leave(KErrNoMemory);
   854 				}
   855             
   856 			if (!iCurrentlyDoingReadOnly && iOpenedForWrite && (iStatus == KErrNone))
   857 				{
   858 				assert(iTokenInterface);
   859 
   860 				//	Drop the interface into a "writable checking" object
   861 				CCheckedCertStore* interf = 
   862 					CCheckedCertStore::NewCheckedWritableCertStoreL(iTokenInterface, iPSCertstoreChangeProperty);
   863 
   864                 CleanupReleasePushL(*interf);
   865 				iTokenInterface = 0;
   866 				
   867 				User::LeaveIfError(iWritableCertStores.Append(interf));
   868 				CleanupStack::Pop();
   869 				
   870 				User::LeaveIfError(iCertStores.Append(interf));	
   871 				
   872 				// We don't need the Token anymore
   873 				iToken->Release();
   874 				iToken = 0;
   875 				iState = EInitializeGetToken;
   876 				TRequestStatus* status = &iStatus;
   877 				User::RequestComplete(status, KErrNone);
   878 				}
   879 			else 
   880 				{
   881 				// We do the check only if we were not trying to get a Writeable Interface
   882 				// before, if we trying to get a writeable interface before, we know that we
   883 				// have a valid iToken.
   884 				if ((iCurrentlyDoingReadOnly || !iOpenedForWrite) && (iStatus != KErrNone))
   885 					{
   886 					User::Leave(iStatus.Int());
   887 					}
   888 				else
   889 					{
   890 					assert(iToken);
   891                     assert(!iTokenInterface);
   892 					TUid uid = { KInterfaceCertStore };
   893 					iToken->GetInterface(uid, iTokenInterface, iStatus);
   894 					iState = EInitializeGetReadableInterfaceFinished;
   895 					}
   896 				}
   897 			SetActive();
   898 			break;
   899 
   900 		case EInitializeGetReadableInterfaceFinished:
   901 			{
   902 			if (iStatus == KErrNoMemory)
   903 				{
   904 				User::Leave(KErrNoMemory);
   905 				}
   906             
   907 			if (iStatus == KErrNone)
   908 				{
   909 				assert(iTokenInterface);
   910 
   911 				//	Drop the interface into a "read only checking" object
   912                 CCheckedCertStore* interf = 
   913 						CCheckedCertStore::NewCheckedCertStoreL(iTokenInterface, iPSCertstoreChangeProperty);
   914 				
   915 				CleanupReleasePushL(*interf);
   916 				iTokenInterface = 0;
   917 
   918 				User::LeaveIfError(iReadOnlyCertStores.Append(interf));
   919 				CleanupStack::Pop(interf);
   920                 
   921 				User::LeaveIfError(iCertStores.Append(interf));
   922 				}			
   923 				
   924 			// We don't need the Token anymore
   925 			iToken->Release();
   926 			iToken = 0;
   927 			
   928 			iStatus = KErrNone;
   929 			iState = EInitializeGetToken;
   930 			TRequestStatus* status = &iStatus;
   931 			User::RequestComplete(status, iStatus.Int());
   932 			SetActive();
   933             }
   934 			break;
   935 
   936 		case EInitializeFinished:
   937             assert(!iTokenType);
   938             assert(!iToken);
   939             assert(!iTokenInterface);
   940 			iIsInitialized = ETrue;
   941 			Complete(iStatus.Int());
   942 			break;
   943 
   944 		case EList:
   945 			// iIndex has been initialized in List
   946 			iIndex++;
   947 			iCurrentCertStore = NULL;
   948 			if (iIndex < iCertStores.Count())
   949 				{
   950 				iCurrentCertStore = iCertStores[iIndex];
   951 				iCurrentCertStore->List(*iWorkingVars->iCertInfos, *iWorkingVars->iFilter, iStatus);
   952 				iWorkingVars->iCertIndex = 0;
   953 				SetActive();
   954 				}
   955 			else if (iWorkingVars->iIssuerNames.Count() > 0)
   956 				{
   957 				// We have an issuer name. We now remove all certs
   958 				// that don't match that issuer.
   959 
   960 				// If this is the first time in here, we need to parse
   961 				// and hash all the issuer names.
   962 				if (iWorkingVars->iParsedIssuerNames.Count() == 0)
   963 					{
   964 					CSHA1* sha1 = CSHA1::NewL();
   965 					CleanupStack::PushL(sha1);
   966 					TInt count = iWorkingVars->iIssuerNames.Count();
   967 					for (TInt i = 0; i < count; i++)
   968 						{
   969 						CX500DistinguishedName* dn = 
   970 							CX500DistinguishedName::NewLC(*iWorkingVars->
   971 														  iIssuerNames[i]);
   972 						User::LeaveIfError(
   973 							iWorkingVars->iParsedIssuerNames.Append(dn));
   974 						CleanupStack::Pop(dn);
   975 						TPtrC8 hash=sha1->Hash(*iWorkingVars->iIssuerNames[i]);
   976 						User::LeaveIfError(
   977 							iWorkingVars->iHashedIssuerNames.Append(
   978 								hash.AllocLC()));
   979 						CleanupStack::Pop();
   980 						}
   981 					CleanupStack::PopAndDestroy();
   982 					}
   983 
   984 				while (iWorkingVars->iCertIndex <
   985 					   iWorkingVars->iCertInfos->Count())
   986 					{
   987 					CCTCertInfo* info = 
   988 						(*iWorkingVars->iCertInfos)[iWorkingVars->iCertIndex];
   989 					TCompareResults res = CompareCertInfoDN(info);
   990 					if (res == EYes)
   991 						{
   992 						// It matches. leave it for the next one.
   993 						iWorkingVars->iCertIndex++;
   994 						}
   995 					else if (res == ENo)
   996 						{
   997 						// It doesn't match. Remove it and try the next one.
   998 						info->Release();
   999 						iWorkingVars->iCertInfos->
  1000 							Remove(iWorkingVars->iCertIndex);
  1001 						}
  1002 					else // res == EMaybe
  1003 						{
  1004 						// Need to load the cert and properly compare the DNs.
  1005 						iCurrentCertStore = GetCertStore(info->Handle());
  1006 						assert(iCurrentCertStore);
  1007 						
  1008 						iWorkingVars->iCertDesC=HBufC8::NewMaxL(info->Size());
  1009 						iWorkingVars->iCertType = info->CertificateFormat();
  1010 						iState = ERetrieveForList;
  1011 						iWorkingVars->iCertDes.Set(iWorkingVars->iCertDesC->Des());
  1012 						iCurrentCertStore->Retrieve(*info, iWorkingVars->iCertDes, iStatus);
  1013 						SetActive();
  1014 						return;
  1015 						}
  1016 					}
  1017 				Complete(KErrNone);
  1018 				}
  1019 			else
  1020 				{
  1021 				Complete(KErrNone);
  1022 				}
  1023 			break;
  1024 
  1025 	case ERetrieve:
  1026 		{
  1027 		switch (iWorkingVars->iCertType)
  1028 			{
  1029             case EX509Certificate:
  1030                 {
  1031                 TPtr8 theCert(iWorkingVars->iCertDesC->Des());
  1032                 *(iWorkingVars->iReturnedCert) = CX509Certificate::NewL(theCert);
  1033                 }
  1034                 break;
  1035             case EWTLSCertificate:
  1036                 {
  1037                 TPtr8 theCert(iWorkingVars->iCertDesC->Des());
  1038                 *(iWorkingVars->iReturnedCert) = CWTLSCertificate::NewL(theCert);			
  1039                 }
  1040                 break;
  1041             default:
  1042                 assert(EFalse);
  1043                 break;
  1044 			}
  1045 		Complete(KErrNone);
  1046 		}
  1047 		break;
  1048 
  1049 	case ERetrieveForList:
  1050 		{
  1051 		TPtr8 theCert(iWorkingVars->iCertDesC->Des());
  1052 		CX509Certificate* cert=CX509Certificate::NewLC(theCert);
  1053 		if (MatchL(cert->IssuerName()))
  1054 			{
  1055 			// It matches. leave it for the next one.
  1056 			iWorkingVars->iCertIndex++;
  1057 			}
  1058 		else
  1059 			{
  1060 			// It doesn't match. Remove it and try the next one.
  1061 			(*iWorkingVars->iCertInfos)[iWorkingVars->iCertIndex]->Release();
  1062 			iWorkingVars->iCertInfos->Remove(iWorkingVars->iCertIndex);
  1063 			}
  1064 		CleanupStack::PopAndDestroy(cert);
  1065 		delete iWorkingVars->iCertDesC;
  1066 		iWorkingVars->iCertDesC = 0;
  1067 		iState = EList;
  1068 		SetActive();
  1069 		TRequestStatus* status = & iStatus;
  1070 		User::RequestComplete(status, KErrNone);
  1071 		break;
  1072 		}
  1073 		
  1074  	case ERemove:
  1075  	case ESetApplicability:
  1076  	case ESetTrust:
  1077 	case EGetCert:
  1078 	case EApplications:
  1079 	case EIsApplicable:
  1080 	case ETrusted:
  1081 	case ERetrieveData:
  1082 		Complete(KErrNone);
  1083 		break;
  1084 
  1085 	default:
  1086         User::Panic(KUCSPanic, 1);
  1087 		break;
  1088 		}
  1089 	}
  1090 
  1091 TInt CUnifiedCertStore::RunError(TInt aError)
  1092 	{
  1093 	Complete(aError);
  1094 	return KErrNone;
  1095 	}
  1096 
  1097 void CUnifiedCertStore::DoCancel()
  1098 	{
  1099 	// If the current state is the last state involved in handling a request, we
  1100 	// check to see if we have already been completed - in this case we can
  1101 	// simply complete the client with iStatus (this may be KErrNone).  If we
  1102 	// have not we cancel the outstanding request and pass the resulting iStatus
  1103 	// back to the client - this too may indicate a successful completion if the
  1104 	// cancel arrived after the request was executed.
  1105 	//
  1106 	// For more complex cases, where there are more states to go through before
  1107 	// we finish servicing the client request, we cancel any outstanding
  1108 	// request, and return KErrCancel to the client.
  1109 
  1110 	switch (iState)
  1111 		{
  1112 		case EInitializeFinished:
  1113 		case ERetrieve:
  1114 		case EGetCert:
  1115 		case EApplications:
  1116 		case EIsApplicable:
  1117 		case ETrusted:
  1118 		case ERetrieveData:
  1119 		case ERemove:
  1120 		case ESetApplicability:
  1121 		case ESetTrust:		
  1122 			if (iStatus == KRequestPending)
  1123 				{
  1124 				// Attempt to cancel outstanding request and pass status back to
  1125 				// client
  1126 				CancelOutstandingRequest();
  1127 				Complete(iStatus.Int());
  1128 				}
  1129 			else
  1130 				{
  1131 				// We've already been completed - call RunL() to process results
  1132 				// and complete client
  1133 				TRAPD(err, RunL());
  1134 				if (err != KErrNone)
  1135 					{
  1136 					RunError(err);
  1137 					}
  1138 				}
  1139 			break;
  1140 			
  1141 		default:
  1142 			CancelOutstandingRequest();
  1143 			Complete(KErrCancel);
  1144 			break;
  1145 		}
  1146 	}
  1147 
  1148 void CUnifiedCertStore::CancelOutstandingRequest()
  1149 	{
  1150 	switch (iState)
  1151 		{
  1152 		case EInitializeGetTokenList:
  1153 		case EInitializeGetToken:
  1154 		case EInitializeGetWritableInterface:
  1155 		case EInitializeGetReadableInterface:
  1156 		case EInitializeGetReadableInterfaceFinished:
  1157 		case EInitializeFinished:
  1158 			// Don't have to cancel initialisation stuff - this happens when we
  1159 			// release the objects in DestroyTemporaryMembers().
  1160 			iStatus = KErrCancel;
  1161 			break;
  1162 
  1163 		case EList:
  1164 			if (iCurrentCertStore)
  1165 				{
  1166 				iCurrentCertStore->CancelList();
  1167 				}
  1168 			break;
  1169 			
  1170 		case ERetrieve:
  1171 		case ERetrieveForList:
  1172 		case ERetrieveData:
  1173 			assert(iCurrentCertStore);
  1174 			iCurrentCertStore->CancelRetrieve();
  1175 			break;
  1176 			
  1177 		case EGetCert:
  1178 			assert(iCurrentCertStore);
  1179 			iCurrentCertStore->CancelGetCert();
  1180 			break;
  1181 			
  1182 		case EApplications:
  1183 			assert(iCurrentCertStore);
  1184 			iCurrentCertStore->CancelApplications();
  1185 			break;
  1186 			
  1187 		case EIsApplicable:
  1188 			assert(iCurrentCertStore);
  1189 			iCurrentCertStore->CancelIsApplicable();
  1190 			break;
  1191 			
  1192 		case ETrusted:
  1193 			assert(iCurrentCertStore);
  1194 			iCurrentCertStore->CancelTrusted();
  1195 			break;
  1196 			
  1197 		case ERemove:
  1198 			assert(iCurrentWritableCertStore);
  1199 			iCurrentWritableCertStore->CancelRemove();
  1200 			break;
  1201 			
  1202 		case ESetApplicability:
  1203 			assert(iCurrentWritableCertStore);
  1204 			iCurrentWritableCertStore->CancelSetApplicability();
  1205 			break;
  1206 			
  1207 		case ESetTrust:
  1208 			assert(iCurrentWritableCertStore);
  1209 			iCurrentWritableCertStore->CancelSetTrust();
  1210 			break;
  1211 			
  1212 		default:
  1213 			User::Panic(KUCSPanic, 1);
  1214 			break;
  1215 		}
  1216 	}
  1217 
  1218 TBool CUnifiedCertStore::MatchL(const CX500DistinguishedName& aName) const
  1219 	{
  1220 	// Return true if the supplied DN is the same as any of the supplied DNs.
  1221 	TInt count = iWorkingVars->iIssuerNames.Count();
  1222 	for (TInt i = 0; i < count; i++)
  1223 		{
  1224 		if (aName.ExactMatchL(*iWorkingVars->iParsedIssuerNames[i]))
  1225 			return ETrue;
  1226 		}
  1227 	return EFalse;
  1228 	}
  1229 
  1230 void CUnifiedCertStore::AllocWorkingVarsL()
  1231 	{
  1232 	assert(!iWorkingVars);
  1233 	iWorkingVars = new (ELeave) CUnifiedCertStoreWorkingVars;
  1234 	}
  1235 
  1236 void CUnifiedCertStore::BeginAsyncOp(TRequestStatus& aStatus, TState aState)
  1237 	{
  1238 	assert(iState == EIdle);
  1239 	assert(!iClientStatus);
  1240 	
  1241 	iClientStatus = &aStatus;
  1242 	*iClientStatus = KRequestPending;
  1243 	iState = aState;
  1244 	}
  1245 
  1246 void CUnifiedCertStore::Complete(TInt aError)
  1247 	{
  1248 	assert(iClientStatus);
  1249 	User::RequestComplete(iClientStatus, aError);	
  1250 	DestroyTemporaryMembers();
  1251 	iState = EIdle;
  1252 	}
  1253 
  1254 void CUnifiedCertStore::DestroyTemporaryMembers()
  1255 	{
  1256 	if (!iIsInitialized)
  1257 		{
  1258 		TInt end = iReadOnlyCertStores.Count();
  1259 		TInt i;
  1260 		for (i = 0; i < end; i++)
  1261 			{
  1262 			iReadOnlyCertStores[i]->Release();
  1263 			}
  1264 		iReadOnlyCertStores.Close();
  1265 
  1266 		end = iWritableCertStores.Count();
  1267 		for (i = 0; i < end; i++)
  1268 			{
  1269 			iWritableCertStores[i]->Release();
  1270 			}
  1271 		iWritableCertStores.Close();
  1272 
  1273 		// The elements are already released by the two loops above
  1274 		iCertStores.Close();
  1275 		}
  1276 
  1277     if (iTokenType)
  1278 		{
  1279 		iTokenType->Release();
  1280 		iTokenType = 0;
  1281 		}
  1282 
  1283 	if (iToken)
  1284 		{
  1285 		iToken->Release();
  1286 		iToken = 0;
  1287 		}
  1288 
  1289 	if (iTokenInterface)
  1290 		{
  1291 		iTokenInterface->Release();
  1292 		iTokenInterface = 0;
  1293 		}
  1294 
  1295 	iTokens.Close();
  1296 
  1297 	delete iWorkingVars;
  1298 	iWorkingVars = 0;
  1299 
  1300 	iCurrentCertStore = NULL;
  1301 	iCurrentWritableCertStore = NULL;
  1302 	}
  1303 
  1304 CUnifiedCertStore::TCompareResults 
  1305 CUnifiedCertStore::CompareCertInfoDN(const CCTCertInfo* aCertInfo)
  1306 	{
  1307 	if (aCertInfo->IssuerHash() && 
  1308 		(aCertInfo->CertificateFormat() == EX509CertificateUrl ||
  1309 			iHardwareTypeUids.Find(aCertInfo->Token().TokenType().Type()) != 
  1310 		 KErrNotFound))
  1311 		{
  1312 		TInt count = iWorkingVars->iHashedIssuerNames.Count();
  1313 		for (TInt i = 0; i < count; i++)
  1314 			{
  1315 			if (*aCertInfo->IssuerHash()==*iWorkingVars->iHashedIssuerNames[i])
  1316 				return EYes;
  1317 			}
  1318 		return ENo;
  1319 		}
  1320 	if (aCertInfo->CertificateFormat() != EX509Certificate)
  1321 		return ENo;
  1322 	return EMaybe;
  1323 	}
  1324 
  1325 EXPORT_C CUnifiedCertStore* CUnifiedCertStore::NewL(RFs& aFs, 
  1326                                                      TBool aOpenForWrite,
  1327                                                      RArray<TInt>& aOrderFilter)
  1328  	{
  1329  	CUnifiedCertStore* self = CUnifiedCertStore::NewLC(aFs, 
  1330  	                                                   aOpenForWrite, 
  1331  	                                                   aOrderFilter);
  1332  	CleanupStack::Pop(self);
  1333  	return self;
  1334  	}
  1335 
  1336 EXPORT_C CUnifiedCertStore* CUnifiedCertStore::NewLC(RFs& aFs, 
  1337                                                       TBool aOpenForWrite,
  1338                                                       RArray<TInt>& aOrderFilter)
  1339  	{
  1340  	CUnifiedCertStore* self = new(ELeave) CUnifiedCertStore(aFs, 
  1341  	                                                        aOpenForWrite);
  1342  	CleanupStack::PushL(self);
  1343  	self->ConstructL(aOrderFilter);
  1344  	return self;
  1345  	}
  1346 
  1347 void CUnifiedCertStore::FilterTokenTypesL(RCPointerArray<CCTTokenTypeInfo>& aSearchTokenTypes,
  1348                                          RCPointerArray<CCTTokenTypeInfo>& aTempTokenTypes,
  1349 										 TInt aOrderAttribute)
  1350 	{
  1351 	//We allow aOrderAttribute=KUnknownHardwareCertStore here to keep DC.
  1352 	//assert(aOrderAttribute);
  1353 	
  1354 	// Get number of token types
  1355 	TInt tokenTypesCount = aSearchTokenTypes.Count(); 
  1356 	
  1357 	// loop through token types
  1358 	for(TInt tokenTypesLoop = tokenTypesCount-1; tokenTypesLoop >= 0; tokenTypesLoop--)
  1359 		{
  1360 		// get the list of attributes supported by this token type.
  1361 		// Note: The attribute list consists of values such as
  1362 		// KCTSoftware defined in TCTTokenTypeAttribute.h
  1363 		const RArray<TCTTokenTypeAttribute>& attributesList = 
  1364 			aSearchTokenTypes[tokenTypesLoop]->Attributes();
  1365 		
  1366 		// Get the number of attributes in the attribute list.
  1367 		// The number of attributes will match the ECOM resource
  1368 		// file definition. E.g. see 101f5015.rss for the software
  1369 		// implementation of certstore. 
  1370 		TInt attributeCount = attributesList.Count();
  1371 		
  1372 		// Check each attribute in the attribute list
  1373 		for(TInt attribLoop = 0; attribLoop < attributeCount; attribLoop++)
  1374 			{
  1375 			// Check whether attribute in the list matches an order attribute
  1376 			// E.g. KCTSoftware
  1377 			if(attributesList[attribLoop].iUID == KCTSoftware
  1378 				&& attributesList[attribLoop].iVal == aOrderAttribute)
  1379 				{
  1380 				// Found the attribute of interest. Add token type to the temp container. 
  1381 				User::LeaveIfError(aTempTokenTypes.Append(aSearchTokenTypes[tokenTypesLoop]));
  1382 				// Remove from the Searchlist.
  1383 				aSearchTokenTypes.Remove(tokenTypesLoop);
  1384 				// No need to examine the other attributes, so break loop
  1385 				break;
  1386 				}
  1387 			}
  1388 		}                      
  1389 	}
  1390  	
  1391 void CUnifiedCertStore::ApplyOrderingL(RCPointerArray<CCTTokenTypeInfo>& aTokenTypes)
  1392 	{
  1393 	// Number of attributes in ordering filter
  1394 	TInt numOrderAttributes=iOrderAttributes.Count();
  1395 	assert(numOrderAttributes>0);
  1396 	
  1397 	// Contains writable tokens types
  1398 	RCPointerArray<CCTTokenTypeInfo> tempWritableTokenTypes;
  1399 	CleanupClosePushL(tempWritableTokenTypes);
  1400 	
  1401 	// Contains read-only tokens types
  1402 	RCPointerArray<CCTTokenTypeInfo> tempReadOnlyTokenTypes;
  1403 	CleanupClosePushL(tempReadOnlyTokenTypes);
  1404 		
  1405 	// For each order attribute, order the token types
  1406 	for(TInt attributeLoop = 0; attributeLoop < numOrderAttributes; attributeLoop++)
  1407 		{
  1408 		// Get ordering attribute Uid from Order filter
  1409 		TInt orderAttribute = iOrderAttributes[attributeLoop];
  1410 		
  1411 		// Order for writable token types
  1412 		FilterTokenTypesL(iWorkingVars->iWritableTokenTypes,
  1413 			tempWritableTokenTypes,
  1414 			orderAttribute);
  1415 		
  1416 		// Order for read-only token types
  1417 		FilterTokenTypesL(aTokenTypes,
  1418 			tempReadOnlyTokenTypes,
  1419 			orderAttribute);
  1420 		}
  1421 		
  1422 	// release and close the resources so can refill container, and get rid of 
  1423 	// the TokenType which have been filtered out.
  1424 	TInt tokenTypesCount = iWorkingVars->iWritableTokenTypes.Count();
  1425 	TInt i;	
  1426 	for(i = tokenTypesCount-1; i >= 0 ;i--)
  1427 		{
  1428 		if (iWorkingVars->iWritableTokenTypes[i])
  1429 			{
  1430 			CCTTokenTypeInfo* ptr=iWorkingVars->iWritableTokenTypes[i];
  1431 			iWorkingVars->iWritableTokenTypes.Remove(i);
  1432 			delete ptr;			
  1433 			}
  1434 		}
  1435 	iWorkingVars->iWritableTokenTypes.Reset();
  1436 	
  1437 	// release and close the resources so can refill container, and get rid of 
  1438 	// the TokenType which have been filtered out.
  1439 	tokenTypesCount = aTokenTypes.Count();
  1440 	for(i = tokenTypesCount-1; i >= 0 ;i--)
  1441 		{
  1442 		if (aTokenTypes[i])
  1443 			{
  1444 			CCTTokenTypeInfo* ptr=aTokenTypes[i];
  1445 			aTokenTypes.Remove(i);
  1446 			delete ptr;			
  1447 			}
  1448 		}
  1449 	aTokenTypes.Reset();
  1450 	
  1451 	// Assign contents of temp token types to containers. 
  1452 	// Note: temp tokens types are ordered according to user specification
  1453 	tokenTypesCount = tempWritableTokenTypes.Count();
  1454 	for(i = 0; i < tokenTypesCount; i++)
  1455 		{
  1456 		User::LeaveIfError(iWorkingVars->iWritableTokenTypes.Append(tempWritableTokenTypes[i]));
  1457 		tempWritableTokenTypes[i] = NULL; 
  1458 		}
  1459 		
  1460 	tokenTypesCount = tempReadOnlyTokenTypes.Count();
  1461 	for(i = 0; i < tokenTypesCount; i++)
  1462 		{
  1463 		User::LeaveIfError(aTokenTypes.Append(tempReadOnlyTokenTypes[i]));
  1464 		tempReadOnlyTokenTypes[i] = NULL;
  1465 		}
  1466 	
  1467 	CleanupStack::PopAndDestroy(2);	// tempReadOnlyTokenTypes, tempWritableTokenTypes, 
  1468 	}
  1469