// Copyright (c) 1998-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:

// f32test\server\t_pwstr.cpp

// Tests peripheral bus controller password store.

// 

//

//#include <p32mmc.h>

#include <e32test.h>

#include <f32fsys.h>

#include <e32def.h>

#include <e32def_private.h>

// define this macro to autodetect card re-insertion

#define __AUTO_DETECT_MEDIA_CHANGE__

const TUint KMMCCIDLength=16;

class TCID

	{

public:

	inline TCID() {}					// Default constructor

	inline TCID(const TUint8*);

	inline TCID& operator=(const TCID&);

	inline TCID& operator=(const TUint8*);

	inline TBool operator==(const TCID&) const;

	inline TBool operator==(const TUint8*) const;

	inline void Copy(TUint8*) const;		// Copies big endian 16 bytes CID

	inline TUint8 At(TUint anIndex) const;	// Byte from CID at anIndex

//private:

public:

	TUint8 iData[KMMCCIDLength];		// Big endian 128 bit bitfield representing CID

	};

class TMMC

	{

public:

	static inline TUint32 BigEndian32(const TUint8*);

	static inline void BigEndian4Bytes(TUint8* aPtr, TUint32 aVal);

	};

//	--------  class TCID  --------

inline TCID::TCID(const TUint8* aPtr)

	{memcpy(&iData[0], aPtr, KMMCCIDLength);}

inline TCID& TCID::operator=(const TCID& aCID)

	{memcpy(&iData[0], &aCID.iData[0], KMMCCIDLength); return(*this);}

inline TCID& TCID::operator=(const TUint8* aPtr)

	{memcpy(&iData[0], aPtr, KMMCCIDLength); return(*this);}

inline TBool TCID::operator==(const TCID& aCID) const

	{return(memcompare(&iData[0],KMMCCIDLength,&aCID.iData[0],KMMCCIDLength)==0);}

inline TBool TCID::operator==(const TUint8* aPtr) const

	{return(memcompare(&iData[0],KMMCCIDLength,aPtr,KMMCCIDLength)==0);}

inline void TCID::Copy(TUint8* aPtr) const

	{memcpy(aPtr, &iData[0], KMMCCIDLength);}

inline TUint8 TCID::At(TUint anIndex) const

	{return(iData[KMMCCIDLength-1-anIndex]);}

inline TUint32 TMMC::BigEndian32(const TUint8* aPtr)

	{return( (aPtr[0]<<24) | (aPtr[1]<<16) | (aPtr[2]<<8) | (aPtr[3]) );}

inline void TMMC::BigEndian4Bytes(TUint8* aPtr, TUint32 aVal)

	{

	aPtr[0] = (TUint8)((aVal >> 24) & 0xFF);

	aPtr[1] = (TUint8)((aVal >> 16) & 0xFF);

	aPtr[2] = (TUint8)((aVal >> 8) & 0xFF);

	aPtr[3] = (TUint8)(aVal & 0xFF);

	}

// Static data.

LOCAL_D RTest test(_L("T_PWSTR"));

LOCAL_D TBusLocalDrive TBLD;

LOCAL_D TBool TBLDChangedFlag;

LOCAL_D TInt TBLDNum = -1; 	// Change this to specify the drive under test

							// e.g. for the lm_pana board when fitted to the

							// integrator, TBLDNum should be set to 3.

LOCAL_D TInt RFsDNum = -1;	// File Server Drive number

struct TTestMapping

	{

	TInt iCIDIdx;							// index in CID

	TInt iPWDIdx;							// index in PWD

	};

const TInt KMaxLengthOfStoreMapping = KMMCCIDLength + sizeof(TInt32) + KMaxMediaPassword;

// EMaxPasswordLength is max size of the password store descriptor

// (which actually contains multiple mappings of CID and passwords)

const TInt KMaxNumOfStoreEntries= TPasswordStore::EMaxPasswordLength/KMaxLengthOfStoreMapping;

const TInt KPWDCnt(4);

LOCAL_C TMediaPassword *PWDs[KPWDCnt];

//Allocate enough unique CIDs to be able to overflow the store 

const TInt KCIDCnt(KMaxNumOfStoreEntries+1);

LOCAL_C TCID *CIDs[KCIDCnt];

//Let the descriptor be one mapping longer than allowed by the password

//store to test overflowing it.

const TInt KMaxPersistentStore(TPasswordStore::EMaxPasswordLength+KMaxLengthOfStoreMapping);

typedef TBuf8<KMaxPersistentStore> TPersistentStore;

LOCAL_C TInt mapSizes[KCIDCnt][KPWDCnt];

// Static function prototypes.

LOCAL_C void AllocateTestData();

LOCAL_C void DeleteTestData();

LOCAL_C void AllocateCIDs();

LOCAL_C void DeleteCIDs();

LOCAL_C void AllocatePasswords();

LOCAL_C void DeletePasswords();

LOCAL_C void SetUpMapSizes();

LOCAL_C void AddMapping(TDes8 &aSt, const TCID *aCID, const TMediaPassword *aPWD);

LOCAL_C void DumpStore(const TDesC &aName, const TDesC8 &aSt);

LOCAL_C TBool StoresEqual(const TDesC8 &aSt0, const TDesC8 &aSt1);

LOCAL_C TBool IsStoreValid(const TDesC8 &aSt);

LOCAL_C void PrintCID(const TCID &aCID);

LOCAL_C void ParseStore(const TDesC8 &aStore, CArrayFixSeg<TTestMapping> *aMP);

LOCAL_C void TestStaticStore();

LOCAL_C void RemountMedia();

LOCAL_C void AttemptToUnlock(TMediaPassword &aPWD, TBool aStore = EFalse);

LOCAL_C void TestLockUnlock();

LOCAL_C void TestElidePasswords();

LOCAL_C void TestNullPasswords();

LOCAL_C void TestControllerStore();

LOCAL_C TInt AccessDisk();

LOCAL_C void TestAutoUnlock();

LOCAL_C void RunTests();

// Test data

LOCAL_C void AllocateCIDs()

//

// Allocates a set of static global media identifiers on the heap.

// The identifiers are all exactly 128 bits.

// Because the test uses only one card, CIDs 1 through 3 can be arbitrary

// (they are just used to construct store data.)

// 

// Format is "CIDXccccccccccc#", where X is the ASCII digit for the index.

// The CID is stored internally in big endian format.

// TCID::At(TInt i) returns the i'th byte, i.e. cid >> (i * 8) & 0xff, which

// is the opposite order to the way they are stored in the array.

// CIDs are formed in the same way in pp_mmc.cpp, the WINS ASSP layer.

//

// For actual card tests, CIDs[0] must correspond to the card's actual CID.

//

	{

#if 1

	static TUint8 ht0[KMMCCIDLength] =			// CID0

		{

		0x06,	0x00,	0x00,	0x31,

		0x36,	0x4d,	0x20,	0x20,

		0x20,	0x00,	0xb4,	0xff,

		0xff,	0xff,	0x63,	0xd9

		};

#else

	static TUint8 ht0[KMMCCIDLength] =			// BPC2

		{

		0x06,	0x00,	0x00,	0x31,

		0x36,	0x4d,	0x20,	0x20,

		0x20,	0x00,	0x89,	0xff,

		0xff,	0xff,	0x63,	0xa7

		};

#endif

	test.Start(_L("AllocateCIDs"));

	TInt i;

	for (i = 0; i < KCIDCnt; i++)

		{

		TUint8 bf[KMMCCIDLength];

		TUint j;

		bf[0] = 'C';

		bf[1] = 'I';

		bf[2] = 'D';

		bf[3] = TUint8('0' + i);

		for (j = 4; j < KMMCCIDLength - 1; j++)

			bf[j] = 'c';

		bf[KMMCCIDLength - 1] = '#';

		if (i == 0)

			{

			TUint cidIdx = 0;

			TLocalDriveCapsV5 driveCaps;

			TPckg<TLocalDriveCapsV5> driveCapsPkg(driveCaps);	

			if(TBLD.Caps(driveCapsPkg) == KErrNone)

				{

				// V5 of TLocalDriveCapsV5 now contains a serial number

				// which for MMC cards is defined to be the unique CID

				if(driveCaps.iSerialNumLength == KMMCCIDLength)

					{

					for(cidIdx=0; cidIdx<KMMCCIDLength; cidIdx++)

						{

						bf[cidIdx] = driveCaps.iSerialNum[KMMCCIDLength-cidIdx-1];

						}

					}

				}

			if(cidIdx == KMMCCIDLength)

				{

				test((CIDs[i] = new TCID(bf)) != NULL);

				}

			else

				{

#ifdef __WINS__

				test((CIDs[i] = new TCID(bf)) != NULL);

#else

				test((CIDs[i] = new TCID(ht0)) != NULL);

#endif

				}

			}

		else

			{

			test((CIDs[i] = new TCID(bf)) != NULL);

			}

		}

	test.End();

	}

LOCAL_C void DeleteCIDs()

//

// Deletes static global media identifiers from the heap.

//

	{

	test.Start(_L("DeleteCIDs"));

	TInt i;

	for (i = 0; i < KCIDCnt; i++)

		delete CIDs[i];

	test.End();

	}

LOCAL_C void AllocatePasswords()

//

// Allocates a set of static global TMediaPassword objects on the heap.

// The passwords range from zero to 16 bytes in length.

//

	{

	test.Start(_L("AllocatePasswords"));

	TInt i;

	for (i = 0; i < KPWDCnt; i++)

		{

		test((PWDs[i] = new TMediaPassword) != NULL);

		TInt j;

		for (j = 0; j < i * 2; j++)

			PWDs[i]->Append(TChar('a' + i + j));

		}

	test.End();

	}

LOCAL_C void DeletePasswords()

//

// Deletes static global TMediaPassword objects from the heap.

//

	{

	test.Start(_L("DeletePasswords"));

	TInt i;

	for (i = 0; i < KPWDCnt; i++)

		delete PWDs[i];

	test.End();

	}

LOCAL_C void SetUpMapSizes()

//

// Initializes static global mapSizes[,] with the persistent store mapping

// sizes of each CID and password.

//

	{

	test.Start(_L("SetUpMapSizes"));

	TInt i;

	for (i = 0; i < KCIDCnt; i++)

		{

		TInt j;

		for (j = 0; j < KPWDCnt; j++)

			mapSizes[i][j] = KMMCCIDLength + sizeof(TInt32) + PWDs[j]->Length();

		}

	test.End();

	}

LOCAL_C void AllocateTestData()

//

// Allocates all test data objects on the heap.

//

	{

	AllocateCIDs();

	AllocatePasswords();

	SetUpMapSizes();

	}

LOCAL_C void DeleteTestData()

//

// Frees all test data objects on the heap.

//

	{

	DeletePasswords();

	DeleteCIDs();

	}

// Test functions.

LOCAL_C void TestStaticStore()

//

// Tests the non card specific virtual functions in DPeriphBusController.

//	TInt ReadPasswordData(TDes8 &aBuf);

//	TInt WritePasswordData(const TDesC8 &aBuf);

//	TInt PasswordStoreLengthInBytes();

//

// store is reset at start of DMMCController::WritePasswordData().

//

	{

	test.Start(_L("TestStore"));

	// TBuf8<KMaxPersistentStore> is 4 + 4 + 256 bytes, so allocate on heap.

	TPersistentStore *pwStore;

	test((pwStore = new TPersistentStore) != NULL);

	TPersistentStore &wStore = *pwStore;

	TPersistentStore *prStore;

	test((prStore = new TPersistentStore) != NULL);

	TPersistentStore &rStore = *prStore;

	// WritePasswordData()

	test.Next(_L("WritePasswordData()"));

	test(TBLD.WritePasswordData(wStore) == KErrNone);// empty

	test(TBLD.PasswordStoreLengthInBytes() == 0);

	AddMapping(wStore, CIDs[1], PWDs[1]);						// exactly one entry

	test(TBLD.WritePasswordData(wStore) == KErrNone);

	test(TBLD.PasswordStoreLengthInBytes() == mapSizes[1][1]);

	AddMapping(wStore, CIDs[2], PWDs[2]);						// exactly two entries

	test(TBLD.WritePasswordData(wStore) == KErrNone);

	test(TBLD.PasswordStoreLengthInBytes() == mapSizes[1][1] + mapSizes[2][2]);

	TInt i;

	for (i = 0; i < wStore.Length(); i++)						// corrupt (partial)

		{

		wStore.SetLength(i);

		TInt r(TBLD.WritePasswordData(wStore));

		if (i == 0 || i == mapSizes[0][0] || i == mapSizes[0][0] + mapSizes[1][1])

			test(r == KErrNone);

		else

			test(r == KErrCorrupt && TBLD.PasswordStoreLengthInBytes() == 0);

		}

	test.Next(_L("Exceeding password store size"));	

	wStore.Zero();	// empty password store

	test(TBLD.WritePasswordData(wStore) == KErrNone);

	test.Printf(_L("Adding mappings...\n"));

	const TMediaPassword password(_L8("abcdefghijklmnop")); //Need a max length password (KMaxMediaPassword)

	for(TInt n=0; n<KCIDCnt; ++n)

		{

		AddMapping(wStore, CIDs[n], &password);

		test.Printf(_L("Mapping:%d store size: %d bytes\n"),n , wStore.Length() );

		const TInt r = TBLD.WritePasswordData(wStore);

		test.Printf(_L("WritePasswordData() --> ret=%d\n"), r);

	 	if(n==KMaxNumOfStoreEntries)

	 		test(r == KErrOverflow);

	 	else

	 		test(r == KErrNone);	

		}

	// ReadPasswordData().

	test.Next(_L("ReadPasswordData()"));

	wStore.Zero();												// empty

	test(TBLD.WritePasswordData(wStore) == KErrNone);

	test(TBLD.ReadPasswordData(rStore) == KErrNone);

	test(rStore.Length() == 0);

	AddMapping(wStore, CIDs[1], PWDs[1]);						// exactly one entry

	test(TBLD.WritePasswordData(wStore) == KErrNone);

	rStore.SetLength(0);										// lt store len

	test(TBLD.ReadPasswordData(rStore) == KErrNone);

	test(rStore.Length() == TBLD.PasswordStoreLengthInBytes());

																// gt store len

	rStore.SetLength(TBLD.PasswordStoreLengthInBytes() + 4);

	test(TBLD.ReadPasswordData(rStore) == 0);

	test(rStore.Length() == TBLD.PasswordStoreLengthInBytes());

	TBuf8<2> srStore;											// max lt store len

	test(TBLD.ReadPasswordData(srStore) == KErrOverflow);

	// Stress test high turnover with memory failure.

	test.Next(_L("Memory test"));

	TInt r;										// error code

	TInt m;

	for (m = 1; m < 100; m++)

		{

		__KHEAP_SETFAIL(RHeap::EDeterministic, m);

		TInt j;

		for (j = 1; j < KCIDCnt - 1; j++)

			{

			TInt k;

			for (k = 1; k < KPWDCnt - 1; k++)

				{

				wStore.Zero();

				AddMapping(wStore, CIDs[j], PWDs[k]);

				AddMapping(wStore, CIDs[j + 1], PWDs[k + 1]);

				if ((r = TBLD.WritePasswordData(wStore)) != KErrNone)

					{

					test(r == KErrNoMemory);

					test(TBLD.PasswordStoreLengthInBytes() == 0);

					}

				else

					{

					test(TBLD.ReadPasswordData(rStore) == KErrNone);

					test(IsStoreValid(rStore) && StoresEqual(rStore, wStore));

					}

				}

			}

		__KHEAP_RESET;

		}	// for (m = 1; m < 16; m++)

	// Clear the store for subsequent tests.

	wStore.Zero();

	test(TBLD.WritePasswordData(wStore) == KErrNone);

	test(TBLD.PasswordStoreLengthInBytes() == 0);

	delete prStore;

	delete pwStore;

	test.End();

	}

LOCAL_C void AddMapping(TDes8 &aSt, const TCID *aCID, const TMediaPassword *aPWD)

//

// Adds aCID |-> aPWD mapping to persistent file's store contents.

//

	{

	aSt.SetLength(aSt.Length() + KMMCCIDLength);

	aCID->Copy(&aSt[aSt.Length() - KMMCCIDLength]);

	TUint8 lenBuf[sizeof(TInt32)];		// TInt32, big endian

	TMMC::BigEndian4Bytes(lenBuf, TInt32(aPWD->Length()));

	aSt.Append(&lenBuf[0], sizeof(TInt32));

	aSt.Append(*aPWD);

	}

LOCAL_C TBool IsStoreValid(const TDesC8 &aSt)

// 

// Checks the integrity of the supplied buffer.

// 

	{

	TInt iBIdx;									// buffer index

	TBool corrupt(EFalse);						// abort flag

	for (iBIdx = 0; iBIdx < aSt.Length(); /* nop */)

		{

		// Enough raw data for CID, PWD_LEN and 1 byte of PWD.

		corrupt = TUint(aSt.Length() - iBIdx) < KMMCCIDLength + sizeof(TInt32) + 1;

		if (corrupt)

			break;

		// PWD_LEN is valid and enough raw data left for PWD.

		iBIdx += KMMCCIDLength;

		const TInt32 pwd_len(TMMC::BigEndian32(aSt.Mid(iBIdx).TDesC8::Ptr()));

		corrupt = !(

				(pwd_len <= KMaxMediaPassword)

			&&	aSt.Length() - iBIdx >= TInt(sizeof(TInt32)) + pwd_len );

		if (corrupt)

			break;