/*

* Copyright (c) 2005-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 <s32file.h>

#include "tauthkeysstep.h"

#include <f32file.h>

using namespace AuthServer;

CTStepPersist::CTStepPersist()

	{

	SetTestStepName(KTStepPersist);

	}

TVerdict CTStepPersist::doTestStepL()

	{

	if (TestStepResult() != EPass)

		{

		return TestStepResult();

		}

__UHEAP_MARK;		// Check for memory leaks

    TBool res = ETrue;

	TBool tmp = ETrue;

	iFs.CreatePrivatePath(RFs::GetSystemDrive());

    TBuf<50> path;

    iFs.PrivatePath(path);

    _LIT(kProtFile, "prot.xxx");

    _LIT(kTransFile, "trans.xxx");

	_LIT8(KPluginData, "ABCDEFGHIJ");

	_LIT(KPluginName, "PasswordPlugin");

    HBufC* pluginName = HBufC::NewLC(14);

	*pluginName = KPluginName;

	// create elements

	CTransientKeyInfo* transInfo =

	  CTransientKeyInfo::NewLC(9999);

    CTransientKey* transient =

		transInfo->CreateTransientKeyL(KPluginData);

	CleanupStack::PushL(transient);

	CProtectionKey* protection =

		CProtectionKey::NewLC(8);

    CEncryptedProtectionKey* encrypted =

		transient->EncryptL(*protection);

	CleanupStack::PushL(encrypted);

	transInfo->SetEncryptedProtectionKeyL(encrypted);

	CleanupStack::Pop(encrypted);

	// write the encrypted key

	RFileWriteStream writeProt;

    path.Insert(path.Length(), kProtFile);

	User::LeaveIfError(writeProt.Replace(iFs, path,

										 EFileShareExclusive | EFileStream));

    CleanupClosePushL(writeProt);

	encrypted->ExternalizeL(writeProt);

	CleanupStack::PopAndDestroy(&writeProt);

	// read the encrypted key	

	RFileReadStream readStream;

	User::LeaveIfError(readStream.Open(iFs, path,

									   EFileShareExclusive | EFileStream));

	CleanupClosePushL(readStream);

	CEncryptedProtectionKey* encrypted2 =

		CEncryptedProtectionKey::NewL(readStream);

	CleanupStack::PushL(encrypted2);

	// test the restored key matches the saved

	TEST(tmp = (encrypted->KeyData() == encrypted2->KeyData()));

	res = tmp && res;

	// write the transient key info

	RFileWriteStream writeTrans;

	iFs.PrivatePath(path);

    path.Insert(path.Length(), kTransFile);

	User::LeaveIfError(writeTrans.Replace(iFs, path,

										 EFileShareExclusive | EFileStream));

    CleanupClosePushL(writeTrans);

	transInfo->ExternalizeL(writeTrans);

	CleanupStack::PopAndDestroy(&writeTrans);

	// read the transient key info 

	RFileReadStream readStream2;

	User::LeaveIfError(readStream2.Open(iFs, path,

									   EFileShareExclusive | EFileStream));

	CleanupClosePushL(readStream2);

	CTransientKeyInfo* transInfo2 =

		CTransientKeyInfo::NewL(readStream2);

	CleanupStack::PushL(transInfo2);

	// recreate the transient key

	CTransientKey* transient2 = 

		transInfo2->CreateTransientKeyL(KPluginData);

	CleanupStack::PushL(transient2);

	// recreate the protection key.

	CProtectionKey* decrypted =

		transient2->DecryptL(transInfo2->EncryptedKey());

	CleanupStack::PushL(decrypted);

    // test that the protection key and decrypted key are the same

	TEST(tmp = (protection->KeyData() == decrypted->KeyData()));

	res = tmp && res;

	SetTestStepResult(res ? EPass : EFail);

	CleanupStack::PopAndDestroy(9, transInfo);

    CleanupStack::PopAndDestroy(pluginName);

    iFs.Delete(path);

__UHEAP_MARKEND;	

	return TestStepResult();

	}