cryptoservices/filebasedcertificateandkeystores/test/tkeystore/t_policyaccessors.cpp
/*
* Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
#include <e32base.h>
#include "t_keystore_actions.h"
#include "t_keystore_defs.h"
#include "t_input.h"
// CGetPolicy //////////////////////////////////////////////////////////////////
/*static*/ CTestAction* CGetPolicy::NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec)
{
CTestAction* self = CGetPolicy::NewLC(aFs, aConsole, aOut, aTestActionSpec);
CleanupStack::Pop(self);
return self;
}
/*static*/ CTestAction* CGetPolicy::NewLC(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec)
{
CGetPolicy* self = new (ELeave) CGetPolicy(aFs, aConsole, aOut);
CleanupStack::PushL(self);
self->ConstructL(aTestActionSpec);
return self;
}
CGetPolicy::CGetPolicy(RFs& aFs, CConsoleBase& aConsole, Output& aOut)
: CKeyStoreTestAction(aFs, aConsole, aOut)
{
}
void CGetPolicy::ConstructL(const TTestActionSpec& aTestActionSpec)
{
CKeyStoreTestAction::ConstructL(aTestActionSpec);
iFilter.iPolicyFilter = TCTKeyAttributeFilter::EAllKeys;
ASSERT(aTestActionSpec.iActionType == KGetUsePolicy || aTestActionSpec.iActionType == KGetManagementPolicy);
iTestUsePolicy = (aTestActionSpec.iActionType == KGetUsePolicy);
TPtrC8 policySpec = Input::ParseElement(aTestActionSpec.iActionResult, KPolicyStart);
if (policySpec == KNullDesC8)
{
User::Leave(KErrArgument);
}
Input::ParseSecurityPolicyL(policySpec, iExpectedPolicy);
iState = EListKeys;
}
CGetPolicy::~CGetPolicy()
{
iKeys.Close();
}
void CGetPolicy::PerformAction(TRequestStatus& aStatus)
{
if (aStatus != KErrNone)
{
iState = EFinished;
}
switch (iState)
{
case EListKeys:
{
CUnifiedKeyStore* keyStore = CSharedKeyStores::TheUnifiedKeyStores().operator[](iKeystore);
ASSERT(keyStore);
if (keyStore)
keyStore->List(iKeys, iFilter, aStatus);
iState = EFinished;
}
break;
case EFinished:
{
if (aStatus == KErrNone)
{
// find the key
CCTKeyInfo* key = NULL;
for (TInt i = 0 ; i < iKeys.Count() ; i++)
{
if (iKeys[i]->Label()==*iLabel)
{
key = iKeys[i];
break;
}
}
if (!key)
{
aStatus = KErrNotFound;
}
else
{
// get the policy
iPolicy = iTestUsePolicy ? key->UsePolicy() : key->ManagementPolicy();
}
}
TRequestStatus* status = &aStatus;
User::RequestComplete(status, aStatus.Int());
if (aStatus.Int() == iExpectedResult)
{
iResult = ETrue;
}
else
{
iResult = EFalse;
}
iActionState = EPostrequisite;
}
break;
default:
ASSERT(EFalse);
}
}
void CGetPolicy::PerformCancel()
{
CUnifiedKeyStore* keystore = CSharedKeyStores::TheUnifiedKeyStores().operator[](0);
ASSERT(keystore);
if (iState == EFinished)
{
keystore->CancelList();
}
}
void CGetPolicy::Reset()
{
iState = EListKeys;
iKeys.Close();
}
void CGetPolicy::DoReportAction()
{
_LIT(KGettingUsePolicy, "Getting use policy...");
_LIT(KGettingManagementPolicy, "Getting management policy...");
_LIT(KExpect, "Expecting policy: ");
if (iTestUsePolicy)
{
iOut.writeString(KGettingUsePolicy);
}
else
{
iOut.writeString(KGettingManagementPolicy);
}
iOut.writeNewLine();
iOut.writeString(KExpect);
iOut.writeSecurityPolicyL(iExpectedPolicy);
iOut.writeNewLine();
}
void CGetPolicy::DoCheckResult(TInt)
{
if (iFinished && iResult)
{
_LIT(KGotPolicy, "Retreived policy: ");
iOut.writeString(KGotPolicy);
iOut.writeSecurityPolicyL(iPolicy);
iOut.writeNewLine();
TPckgC<TSecurityPolicy> policyPckg(iPolicy);
TPckgC<TSecurityPolicy> expectedPolicyPckg(iExpectedPolicy);
if (policyPckg != expectedPolicyPckg)
{
iResult = EFalse;
_LIT(KBadPolicy, "Policy does not match expected");
iOut.writeString(KBadPolicy);
iOut.writeNewLine();
}
}
}
// CSetPolicy //////////////////////////////////////////////////////////////////
/*static*/ CTestAction* CSetPolicy::NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec)
{
CTestAction* self = CSetPolicy::NewLC(aFs, aConsole, aOut, aTestActionSpec);
CleanupStack::Pop(self);
return self;
}
/*static*/ CTestAction* CSetPolicy::NewLC(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec)
{
CSetPolicy* self = new (ELeave) CSetPolicy(aFs, aConsole, aOut);
CleanupStack::PushL(self);
self->ConstructL(aTestActionSpec);
return self;
}
CSetPolicy::CSetPolicy(RFs& aFs, CConsoleBase& aConsole, Output& aOut)
: CKeyStoreTestAction(aFs, aConsole, aOut)
{
}
void CSetPolicy::ConstructL(const TTestActionSpec& aTestActionSpec)
{
CKeyStoreTestAction::ConstructL(aTestActionSpec);
iFilter.iPolicyFilter = TCTKeyAttributeFilter::EAllKeys;
ASSERT(aTestActionSpec.iActionType == KSetUsePolicy || aTestActionSpec.iActionType == KSetManagementPolicy);
iTestUsePolicy = (aTestActionSpec.iActionType == KSetUsePolicy);
TPtrC8 policySpec = Input::ParseElement(aTestActionSpec.iActionBody, KPolicyStart);
if (policySpec == KNullDesC8)
{
User::Leave(KErrArgument);
}
Input::ParseSecurityPolicyL(policySpec, iNewPolicy);
iState = EListKeys;
}
CSetPolicy::~CSetPolicy()
{
iKeys.Close();
}
void CSetPolicy::PerformAction(TRequestStatus& aStatus)
{
if (aStatus != KErrNone)
{
iState = EFinished;
}
switch (iState)
{
case EListKeys:
{
CUnifiedKeyStore* keyStore = CSharedKeyStores::TheUnifiedKeyStores().operator[](iKeystore);
ASSERT(keyStore);
if (keyStore)
keyStore->List(iKeys, iFilter, aStatus);
iState = ESetPolicy;
}
break;
case ESetPolicy:
{
// find the key
CCTKeyInfo* key = NULL;
for (TInt i = 0 ; i < iKeys.Count() ; i++)
{
if (iKeys[i]->Label()==*iLabel)
{
key = iKeys[i];
break;
}
}
iState = EFinished;
if (!key)
{
TRequestStatus* status = &aStatus;
User::RequestComplete(status, KErrNotFound);
}
else
{
// set the policy
CUnifiedKeyStore* keyStore = CSharedKeyStores::TheUnifiedKeyStores().operator[](iKeystore);
ASSERT(keyStore);
if (iTestUsePolicy)
{
keyStore->SetUsePolicy(*key, iNewPolicy, aStatus);
}
else
{
keyStore->SetManagementPolicy(*key, iNewPolicy, aStatus);
}
}
}
break;
case EFinished:
{
TRequestStatus* status = &aStatus;
User::RequestComplete(status, aStatus.Int());
if (aStatus.Int() == iExpectedResult)
{
iResult = ETrue;
}
else
{
iResult = EFalse;
}
iActionState = EPostrequisite;
}
break;
default:
ASSERT(EFalse);
}
}
void CSetPolicy::PerformCancel()
{
CUnifiedKeyStore* keystore = CSharedKeyStores::TheUnifiedKeyStores().operator[](0);
ASSERT(keystore);
if (iState == EFinished)
{
keystore->CancelList();
}
}
void CSetPolicy::Reset()
{
iState = EListKeys;
iKeys.Close();
}
void CSetPolicy::DoReportAction()
{
_LIT(KSettingUsePolicy, "Setting use policy...");
_LIT(KSettingManagementPolicy, "Setting management policy...");
_LIT(KExpect, "New policy: ");
if (iTestUsePolicy)
{
iOut.writeString(KSettingUsePolicy);
}
else
{
iOut.writeString(KSettingManagementPolicy);
}
iOut.writeNewLine();
iOut.writeString(KExpect);
iOut.writeSecurityPolicyL(iNewPolicy);
iOut.writeNewLine();
}
void CSetPolicy::DoCheckResult(TInt)
{
}