/*

* 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"

/*static*/ CTestAction* CDeleteKeys::NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec)

{

	CTestAction* self = CDeleteKeys::NewLC(aFs, aConsole, aOut, aTestActionSpec);

	CleanupStack::Pop(self);

	return self;

}

/*static*/ CTestAction* CDeleteKeys::NewLC(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec)

{

	CDeleteKeys* self = new (ELeave) CDeleteKeys(aFs, aConsole, aOut);

	CleanupStack::PushL(self);

	self->ConstructL(aTestActionSpec);

	return self;

}

CDeleteKeys::~CDeleteKeys()

{

	iKeys.Close();

}

void CDeleteKeys::PerformAction(TRequestStatus& aStatus)

{

    if (aStatus != KErrNone)

        {

        iState = EFinished;

        }

	CUnifiedKeyStore* keyStore = CSharedKeyStores::TheUnifiedKeyStores().operator[](iKeystore);

	ASSERT(keyStore);

    switch (iState)

		{		

		case EListKeys:

			keyStore->List(iKeys, iFilter, aStatus);

			if (*iLabel != KNullDesC)				

				iState = EDeleteKeyByLabel;

			else if (iNonExistentKey)

				iState = EDeleteNonExistentKey;

			else

				iState = EDeleteAllKeys;

			break;

		case EDeleteKeyByLabel:

			for ( ; iDeleteIndex < iKeys.Count() ; ++iDeleteIndex)

				{

				CCTKeyInfo* key = iKeys[iDeleteIndex];

				if (key->Label() == *iLabel)

					{

					keyStore->DeleteKey(*key, aStatus);

					++iDeletedCount;

					break;

					}

				}

			if (iDeleteIndex == iKeys.Count())

				{

				TRequestStatus* status = &aStatus;				

				User::RequestComplete(status, KErrNotFound);

				}

			iState = EFinished;

			break;

		case EDeleteNonExistentKey:

			{

			// Skip test if we want to delete a non-existant key, but there are

			// no keys present to get token handle from - this happens if

			// previous tests fail

			if (iKeys.Count() == 0)

				{

				_LIT(KSkippingTest, "!!!No keys present, skipping delete non-existant key test!!!\n");

				iConsole.Write(KSkippingTest);

				iOut.writeString(KSkippingTest);

			    iActionState = EPostrequisite;

				TRequestStatus* status = &aStatus;

				User::RequestComplete(status, KErrNone);

				break;

				}

			CCTKeyInfo* keyInfo = iKeys[0];

			iDeleteHandle = keyInfo->Handle();

			if (iNonExistentKey > 0)

				{

				//	Modify the handle to a key that will not exist

				iDeleteHandle.iObjectId = 0xfbadcafe;

				}

			iState = EFinished;			

			keyStore->DeleteKey(iDeleteHandle, aStatus); 				

			}

			break;

		case EDeleteAllKeys:

			if (iDeleteIndex < iKeys.Count())

				{

				iState = EDeleteAllKeys;

				keyStore->DeleteKey(*iKeys[iDeleteIndex], aStatus);

				++iDeleteIndex;

				++iDeletedCount;

				}

			else

				{

				iState = EFinished;

				TRequestStatus* status = &aStatus;				

				User::RequestComplete(status, KErrNone);

				}

			break;			

		case EFinished:

			{

            iOut.writeString(_L("Delete: initial key count == "));

            iOut.writeNum(iKeys.Count());

            iOut.writeNewLine();

            iOut.writeString(_L("Delete: delete count == "));

            iOut.writeNum(iDeletedCount);

            iOut.writeNewLine();			

            iOut.writeString(_L("Delete: status == "));

            iOut.writeNum(aStatus.Int());

            iOut.writeNewLine();

			if (aStatus != KErrNone && iDeletedCount > 0)

				{

				// Attempt to delete key failed, adjust count

				--iDeletedCount;

				}

			iResult = (aStatus == iExpectedResult) &&

				(iExpectedDeleteCount == iDeletedCount || iExpectedDeleteCount == -1);

			iActionState = EPostrequisite;

			TRequestStatus* status = &aStatus;

			User::RequestComplete(status, aStatus.Int());

			}

			break;

		default:

			User::Invariant();	

	}

}

void CDeleteKeys::PerformCancel()

    {

    CUnifiedKeyStore* keystore = CSharedKeyStores::TheUnifiedKeyStores().operator[](iKeystore);

    ASSERT(keystore);

	keystore->Cancel();

    }

void CDeleteKeys::Reset()

	{

	iState = EListKeys;

	iDeleteIndex = 0;

	iDeletedCount = 0;

	iKeys.Close();

	}

void CDeleteKeys::DoReportAction()

{

	_LIT(KDeleting, "Deleting...");

	iOut.writeString(KDeleting);

	iOut.writeNewLine();

}

void CDeleteKeys::DoCheckResult(TInt aError)

{

	if (iFinished)

	{

		TBuf<256> buf;

		if (aError == KErrNone)

		{

			if (iExpectedDeleteCount!=-1)

			{

				_LIT(KSuccessful, "%d Key(s) deleted successfully (expected to delete %d)\n");			

				buf.Format(KSuccessful, iDeletedCount, iExpectedDeleteCount);

				iConsole.Write(buf);

				iOut.writeString(buf);

				iOut.writeNewLine();

			}

		}

		else

		{

			if (aError!=iExpectedResult)

			{

				if (iExpectedDeleteCount!=-1)

				{

					_LIT(KFailed, "!!!Key delete failure %d!!!\n");

					buf.Format(KFailed, aError);

					iConsole.Write(buf);

					iOut.writeString(buf);

				}

			}

			else

			{

				_LIT(KFailed, "Key delete failed, but expected\n");

				iConsole.Write(KFailed);

				iOut.writeString(KFailed);

			}

			iOut.writeNewLine();

		}

	}

}

CDeleteKeys::CDeleteKeys(RFs& aFs, CConsoleBase& aConsole, Output& aOut)

 :	CKeyStoreTestAction(aFs, aConsole, aOut), 

	iInitialKeyCount(-1), 

	iFinalKeyCount(0),

	iDeletedCount(0),

	iDeleteIndex(0),

	iNonExistentKey(0),

	iExpectedDeleteCount(-1)

{}

void CDeleteKeys::ConstructL(const TTestActionSpec& aTestActionSpec)

{

	CKeyStoreTestAction::ConstructL(aTestActionSpec);

	iFilter.iKeyAlgorithm = iAlgorithm;

	TPtrC8 buf(0,0);

	buf.Set(Input::ParseElement(aTestActionSpec.iActionBody, KNonExistentKeyStart));

	if (buf.Length() != 0)

		SetNonExistent(buf);

	buf.Set(Input::ParseElement(aTestActionSpec.iActionBody, KDeleteCountStart));

	if (buf.Length() != 0)

		SetDeleteCount(buf);

	buf.Set(Input::ParseElement(aTestActionSpec.iActionBody, KOwnerStart));

	if (buf.Length() != 0)

		{

		User::Leave(KErrNotSupported);

		}

	if (*iLabel != KNullDesC || iNonExistentKey)

		{

		iFilter.iPolicyFilter = TCTKeyAttributeFilter::EAllKeys;

		}

	else

		{		

		iFilter.iPolicyFilter = TCTKeyAttributeFilter::EManageableKeys;

		}

	iState = EListKeys;

}

void CDeleteKeys::SetNonExistent(const TDesC8& aNonExistent)

{

	TLex8 lexer(aNonExistent);

	lexer.Val(iNonExistentKey);

}

void CDeleteKeys::SetDeleteCount(const TDesC8& aDeleteCount)

{

	TLex8 lexer(aDeleteCount);

	lexer.Val(iExpectedDeleteCount);

}