/*

* Copyright (c) 2004-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 "t_certstoreactions.h"

#include "t_certstoreout.h"

#include "t_certstoredefs.h"

#include "t_input.h"

#include <x509cert.h>

#include <wtlscert.h>

#include <securityerr.h>

#include <ecom.h>

#include "testutilsdpclient.h"

#include <swicertstore.h>

// CCertStoreChangeNotifier ////////////////////////////////////////////////////////////// 

 CCertStoreChangeNotifier* CCertStoreChangeNotifier::NewL(TInt& aNotificationFlag)

 	{

 	CCertStoreChangeNotifier* self = new(ELeave) CCertStoreChangeNotifier(aNotificationFlag);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop();

 	return self;

 	}

 CCertStoreChangeNotifier::~CCertStoreChangeNotifier()

 	{

 	Cancel();

	iCertStoreChangeProperty.Close();

 	}

 CCertStoreChangeNotifier::CCertStoreChangeNotifier(TInt& aNotificationFlag): CActive(EPriorityHigh), iNotifiedCounter(aNotificationFlag)

 	{

 	CActiveScheduler::Add(this);

 	}	

 void CCertStoreChangeNotifier::ConstructL()

  	{

 	TInt r=iCertStoreChangeProperty.Attach(KUnifiedCertStorePropertyCat,EUnifiedCertStoreFlag,EOwnerThread);

 	User::LeaveIfError(r);

 	}

 void CCertStoreChangeNotifier::StartNotification()

 	{

 	iCertStoreChangeProperty.Subscribe(iStatus);

 	SetActive();

 	}	

 void CCertStoreChangeNotifier::DoCancel()

 	{

 	iCertStoreChangeProperty.Cancel();

 	}

 void CCertStoreChangeNotifier::RunL()

 	{

 	iNotifiedCounter++;

 	}

// COpenCertStore //////////////////////////////////////////////////////////////

_LIT(KCOpenCertStore, "COpenCertStore");

COpenCertStore::~COpenCertStore()

	{

	if (iSet)

		{

		switch (iType)

			{

			case EUnifiedCertStore:

				delete iUnifiedCertStore;

				break;

			case ESWICertStore:

				iSwiCertStore->Release();

				break;

			default:

				User::Panic(KCOpenCertStore, 1);

			}

		}

	}

void COpenCertStore::SetCertStore(CUnifiedCertStore* aCertStore)

	{

	__ASSERT_ALWAYS(!iSet, User::Panic(KCOpenCertStore, 1));

	iType = EUnifiedCertStore;

	iUnifiedCertStore = aCertStore;

	iSet = ETrue;

	}

CUnifiedCertStore& COpenCertStore::AsUnifiedCertStore()

	{

	__ASSERT_ALWAYS(iSet && iType == EUnifiedCertStore, User::Panic(KCOpenCertStore, 1));

	return *iUnifiedCertStore;

	}

void COpenCertStore::SetCertStore(CSWICertStore* aCertStore)

	{

	__ASSERT_ALWAYS(!iSet, User::Panic(KCOpenCertStore, 1));

	iType = ESWICertStore;

	iSwiCertStore = aCertStore;

	iSet = ETrue;

	}

CSWICertStore& COpenCertStore::AsSWICertStore()

	{

	__ASSERT_ALWAYS(iSet && iType == ESWICertStore, User::Panic(KCOpenCertStore, 1));

	return *iSwiCertStore;

	}

TCertStoreType COpenCertStore::Type()

	{

	__ASSERT_ALWAYS(iSet, User::Panic(KCOpenCertStore, 1));

	return iType;

	}

MCertStore& COpenCertStore::CertStore()

	{

	__ASSERT_ALWAYS(iSet, User::Panic(KCOpenCertStore, 1));

	MCertStore* result = NULL;

	switch (iType)

		{

		case EUnifiedCertStore:

			result = iUnifiedCertStore;

			break;

		case ESWICertStore:

			result = iSwiCertStore;

			break;

		default:

			User::Panic(KCOpenCertStore, 1);

		}

	return *result;

	}

// CSharedData /////////////////////////////////////////////////////////////////

CSharedData::~CSharedData()

	{

	iCertStores.ResetAndDestroy();

	iCertStores.Close();

	DeleteCertificateAppInfoManager();

	REComSession::FinalClose();

	}

void CSharedData::InitCertificateAppInfoManagerL()

	{

	ASSERT(!iCertificateAppInfoManager);

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

	iCertificateAppInfoManager = CCertificateAppInfoManager::NewL(iFs, ETrue);

	}

void CSharedData::DeleteCertificateAppInfoManager()

	{

	if (iCertificateAppInfoManager)

		{

		delete iCertificateAppInfoManager;

		iCertificateAppInfoManager = NULL;

		iFs.Close();

		}

	}

RPointerArray<COpenCertStore>& CSharedData::CertStores()

	{

	return iCertStores;

	}

/////////////////////////////////////////////////////////////////////////////////

//CCertStoreTestAction base class

/////////////////////////////////////////////////////////////////////////////////

CCertStoreTestAction::~CCertStoreTestAction()

	{

	}

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

	CTestAction(aConsole, aOut), iFs(aFs)

	{

	}

CSharedData& CCertStoreTestAction::CertStoreSharedData()

	{

	if (!SharedData())

		{

		SetSharedData(new CSharedData);

		}

    CSharedData* data = static_cast<CSharedData*>(SharedData());

	ASSERT(data); // panic if out of memory

	return *data;

	}

void CCertStoreTestAction::DoPerformPrerequisite(TRequestStatus& aStatus)

	{

	// Ensure shared data is already created to prevent panic in oom test

	CertStoreSharedData();

	iActionState = EAction;

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, KErrNone);

	}

void CCertStoreTestAction::DoPerformPostrequisite(TRequestStatus& aStatus)

	{

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, KErrNone);

	}

CCertificateAppInfoManager* CCertStoreTestAction::TheCertificateAppInfoManager()

	{

	return CertStoreSharedData().iCertificateAppInfoManager;

	}

void CCertStoreTestAction::InitTheCertificateAppInfoManagerL()

	{

	CertStoreSharedData().InitCertificateAppInfoManagerL();

	}

void CCertStoreTestAction::DeleteTheCertificateAppInfoManager()

	{

	CertStoreSharedData().DeleteCertificateAppInfoManager();

	}

RPointerArray<COpenCertStore>& CCertStoreTestAction::CertStores()

	{

	return CertStoreSharedData().CertStores();

	}

TInt CCertStoreTestAction::CertStoreCount()

	{

	return CertStores().Count();

	}

TCertStoreType CCertStoreTestAction::CertStoreType(TInt aIndex)

	{

	return CertStores()[aIndex]->Type();

	}

MCertStore& CCertStoreTestAction::CertStore(TInt aIndex)

	{

	return CertStores()[aIndex]->CertStore();

	}

void CCertStoreTestAction::AddCertStoreL(CUnifiedCertStore* aCertStore)

	{

	COpenCertStore* openStore = new (ELeave) COpenCertStore;

	CleanupStack::PushL(openStore);

  	User::LeaveIfError(CertStores().Append(openStore));

	CleanupStack::Pop(openStore);

	openStore->SetCertStore(aCertStore); // takes ownership

	}

CUnifiedCertStore& CCertStoreTestAction::UnifiedCertStore(TInt aIndex)

	{

	return CertStores()[aIndex]->AsUnifiedCertStore();

	}

void CCertStoreTestAction::AddCertStoreL(CSWICertStore* aCertStore)

	{

	COpenCertStore* openStore = new (ELeave) COpenCertStore;

	CleanupStack::PushL(openStore);

	User::LeaveIfError(CertStores().Append(openStore));

	CleanupStack::Pop(openStore);

	openStore->SetCertStore(aCertStore); // takes ownership

	}

CSWICertStore& CCertStoreTestAction::SWICertStore(TInt aIndex)

	{

	return CertStores()[aIndex]->AsSWICertStore();

	}

void CCertStoreTestAction::RemoveCertStore(TInt aIndex)

	{

	COpenCertStore* openStore = CertStores()[aIndex];

	TBool delCertstore = EFalse;

	if (openStore->Type() == ESWICertStore)

			{

			delCertstore = ETrue;

			}

	CertStores().Remove(aIndex);

	delete openStore;

	if (delCertstore)

			{

			RTestUtilSession testutil;

			User::LeaveIfError(testutil.Connect());

			CleanupClosePushL(testutil);

			TDriveUnit sysDrive (RFs::GetSystemDrive());

			TDriveName driveName(sysDrive.Name());			

			TBuf<64> certstoreFile (driveName);

			certstoreFile.Append(_L("\\Resource\\SwiCertstore\\"));

			testutil.RmDir(certstoreFile);

			CleanupStack::PopAndDestroy(&testutil);

			}

	}

/////////////////////////////////////////////////////////////////////////////////

//CSubscriberAction base class

/////////////////////////////////////////////////////////////////////////////////

CSubscriberAction::~CSubscriberAction()

	{

	if (iNotifier)

		delete iNotifier;

	}

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

:CCertStoreTestAction(aFs, aConsole, aOut)

	{	

	}

void CSubscriberAction::ConstructL(const TTestActionSpec& aTestActionSpec)

	{

	CCertStoreTestAction::ConstructL(aTestActionSpec);

	TInt pos = 0;

	TInt err = KErrNone;

	TPtrC8 ptr1 = Input::ParseElement(aTestActionSpec.iActionBody, KChangeNotifiedStart, KChangeNotifiedEnd, pos, err);

	if (ptr1 != KNullDesC8)

		{

		TLex8 lexi(ptr1);

		TInt val;

		TInt ret=lexi.Val(val);

		if (val != 0)

			{

			iNotificationSubscribed=1;

			}

		}		

	}

/////////////////////////////////////////////////////////////////

//CInitialiseCertStore::

///////////////////////////////////////////////////////////////////

CTestAction* CInitialiseCertStore::NewL(RFs& aFs,

										CConsoleBase& aConsole,

										Output& aOut,

										const TTestActionSpec& aTestActionSpec)

	{

	CTestAction* self = CInitialiseCertStore::NewLC(aFs, 

		aConsole, aOut,	aTestActionSpec);

	CleanupStack::Pop(self);

	return self;

	}

CTestAction* CInitialiseCertStore::NewLC(RFs& aFs,

										 CConsoleBase& aConsole, 

										 Output& aOut, 

										 const TTestActionSpec& aTestActionSpec)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aTestActionSpec);

	return self;

	}

CInitialiseCertStore::~CInitialiseCertStore()

	{

	delete iNewUnifiedCertStore;

 	iFilterOrdering.Close();

 	iExpectedOrderingResult.Close();	

	}

CInitialiseCertStore::CInitialiseCertStore(RFs& aFs, 

										   CConsoleBase& aConsole, 

										   Output& aOut)

	:CCertStoreTestAction(aFs, aConsole, aOut), iState(ENew)

	{

	}

void CInitialiseCertStore::ConstructL(const TTestActionSpec& aTestActionSpec)

	{

	CCertStoreTestAction::ConstructL(aTestActionSpec);

	TInt err = KErrNone;

	TInt pos = 0;

	TPtrC8 ptr = 

		Input::ParseElement(aTestActionSpec.iActionBody, KModeStart, KModeEnd, pos, err);

	if (ptr == KNullDesC8)

		{

		User::Leave(KErrNotFound);

		}

	if (ptr == _L8("read"))

		{

		iOpenedForWrite = EFalse;

		}

	else if (ptr == _L8("write"))

		{

		iOpenedForWrite = ETrue;

		}

	else

		{

		User::Leave(KErrNotSupported);

		}

	pos = 0;

	err = KErrNone;

	TPtrC8 ptr1 = Input::ParseElement(aTestActionSpec.iActionBody, KOrderingFilterStart, KOrderingFilterEnd, pos, err);

	if (ptr1 != KNullDesC8)

		{

		TInt lastPos=0;

		TInt startPos=0;

		TLex8 lexi;

		do 

			{

			startPos=lastPos;

			while (lastPos<ptr1.Length() && ptr1[lastPos]!=',')

				{

				lastPos++;

				}

			TPtrC8 uidInA(&ptr1[startPos], lastPos-startPos);

			TLex8 lexi(uidInA);

			TInt32 uidInD=0;

			TInt err=lexi.Val(uidInD);

			User::LeaveIfError(iFilterOrdering.Append(uidInD));

			lastPos++;

			}

		while (lastPos < ptr1.Length());	

		}

	pos = 0;

	err = KErrNone;		

	TPtrC8 ptr2 = Input::ParseElement(aTestActionSpec.iActionResult, KOrderingResultStart, KOrderingResultEnd, pos, err);	

	if (ptr2 != KNullDesC8)

		{

		TInt lastPos=0;

		TInt startPos=0;

		TLex8 lexi;

		do 

			{

			startPos=lastPos;

			while (lastPos<ptr2.Length() && ptr2[lastPos]!=',')

				{

				lastPos++;

				}

			TPtrC8 uidInA(&ptr2[startPos], lastPos-startPos);

			TLex8 lexi(uidInA);

			TInt32 uidInD=0;

			TInt err=lexi.Val(uidInD);

			User::LeaveIfError(iExpectedOrderingResult.Append(uidInD));

			lastPos++;

			}

		while (lastPos < ptr2.Length());	

		}		

	pos = 0;

	err = KErrNone;

	HBufC* result = HBufC::NewLC(aTestActionSpec.iActionResult.Length());

	TPtr(result->Des()).Copy(aTestActionSpec.iActionResult);

	Input::GetExpectedResultL(Input::ParseElement(*result, KReturnStart, KReturnEnd), iExpectedResult);

	CleanupStack::PopAndDestroy(result);

	}

void CInitialiseCertStore::PerformAction(TRequestStatus& aStatus)

	{

	if (aStatus != KErrNone)

		{

		iState = EFinished;

		}

	switch (iState)

		{

		case ENew:

			__ASSERT_DEBUG(!iNewUnifiedCertStore, User::Panic(_L("CInitialiseCertStore"), 1));

 			iNewUnifiedCertStore = CUnifiedCertStore::NewL(iFs, iOpenedForWrite, iFilterOrdering);

 			iNewUnifiedCertStore->Initialize(aStatus);		

			iState = EAppend;

			break;

		case EAppend:

			{	

			AddCertStoreL(iNewUnifiedCertStore);

			iNewUnifiedCertStore = 0; // we don't own this any more

			if (iFilterOrdering.Count()==0)

				{

				iState = EFinished;

				}

			else

				{

				iState = ECheckOrder;

				}

			TRequestStatus* status = &aStatus;

			User::RequestComplete(status, KErrNone);		

			}

			break;

		case ECheckOrder:

			{

			TInt ret=KErrNone;

			TInt count = UnifiedCertStore().CertStoreCount();

			MCTCertStore* p=NULL;

			TInt j=-1;

			TInt32 previous=0;

			TInt32 current=0;			

			for (TInt i=0;i<count;i++)

				{

				p=&(UnifiedCertStore().CertStore(i));

				current = p->Token().TokenType().Type().iUid;

				if (previous != current)

					{

					j++;

					previous = current;

					}

				TInt32 l1=iExpectedOrderingResult[j];

				if (current != iExpectedOrderingResult[j])

					{

					ret=KErrNotFound;

					break;

					}

				}

			if (count<iExpectedOrderingResult.Count())

				{

				ret=KErrNotFound;