// 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_mmc.cpp

// Tests locking, unlocking and clearing of a password on a suitable

// device.  Currently, this device is a MultiMediaCard.  The RFs API

// allows the user to store the password.

// This is a manual test, and the operator must observe that the notifier

// appears exactly when indicated by the program.

// 

//

#include <f32file.h>

#include <e32test.h>

#include <f32dbg.h>

#include <f32fsys.h>

// definitions from p32mmc.h

const TInt KMMCCIDLength = 16;

class TMMC

	{

public:

	static inline TUint32 BigEndian32(const TUint8*);

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

	};

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);

	}

// local test data

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

LOCAL_D RFs TheFs;

LOCAL_D RFile TheFile;

#if defined(__WINS__)

_LIT(KSessionPath, "X:\\");

const TInt KDrv = EDriveX;

const TText KDrvLtr = 'x';

#else

_LIT(KSessionPath, "D:\\");

const TInt KDrv = EDriveD;

const TText KDrvLtr = 'd';

#endif

_LIT(KTestFileName, "testFile");

enum TAccessType {EAccessUnlock, EAccessStore, EAccessCancel, EAccessWrongPw, EAccessNoNotifier};

LOCAL_D TMediaPassword KNul, KPw1, KPw2, KPw3, KPw4, KPw5;

#ifdef __WINS__

	const static TUint8 cid0[KMMCCIDLength] =	// "CID0ccccccccccc#";

		{

		'C',	'I',	'D',	'0',

		'c',	'c',	'c',	'c',

		'c',	'c',	'c',	'c',

		'c',	'c',	'c',	'#'

		};

#else

	const static TUint8 cid0[KMMCCIDLength] =	// big-endian, CID0

		{

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

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

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

		0xff,	0xff,	0x63,	0xd9

		};

#endif

// local test functions

LOCAL_C void RemountMedia();

LOCAL_C void ClearControllerStore();

LOCAL_C void DeletePasswordFile();

LOCAL_C TInt CreateFile();

LOCAL_C TInt PWFileSize(TInt &aLength);

LOCAL_C TInt AccessDisk(TAccessType aAccess, const TDesC8 &aPWD);

LOCAL_C void TestHasPassword(TBool aIL, TBool aHP);

LOCAL_C void TestLockUnlockR();

LOCAL_C void TestNullPasswords();

LOCAL_C void TestLockUnlock();

LOCAL_C void TestPasswordStore();

LOCAL_C void TestWriteToDisk();

LOCAL_C void TestFormat();

LOCAL_C void TestRemount();

/** force a remount on the removable media. */

LOCAL_C void RemountMedia()

	{

#ifdef __WINS__

//	UserSvr::ForceRemountMedia(ERemovableMedia0);

	User::After(1 * 1500 * 1000);

#else

//	UserSvr::ForceRemountMedia(ERemovableMedia0);

//	User::After(1 * 1500 * 1000);

	test.Printf(_L("Remove and re-insert card.  Press \'z\' when finished.\n"));

	while (test.Getch() != 'z')

		{ /* empty. */ }

#endif

	}

/** ask the user to replace the current lockable media with another */

LOCAL_C void ChangeMedia()

	{

#ifdef __WINS__

	test.Printf(_L("Press f4 whilst holding down f5\n"));

	test.Printf(_L("Press z when completed\n"));

	while(test.Getch() != 'z')

		{ /* empty */ }

#else

	test.Printf(_L("Remove and insert other card.  Press \'z\' when finished.\n"));

	while (test.Getch() != 'z')

		{ /* empty. */ }

#endif

	}

/** disable auto-unlock by clearing controller store */

LOCAL_C void ClearControllerStore()

	{

	TBuf8<1> nulSt;

	test(TBusLocalDrive::WritePasswordData(nulSt) == KErrNone);// empty

	test(TBusLocalDrive::PasswordStoreLengthInBytes() == 0);

	}

/** delete the password store file.  Does not affect the auto-unlock mechanism. */

LOCAL_C void DeletePasswordFile()

	{

	TInt r;

	TBuf<sizeof(KMediaPWrdFile)> mediaPWrdFile(KMediaPWrdFile);

	mediaPWrdFile[0] = (TUint8) RFs::GetSystemDriveChar();

	do

		{

		User::After(100 * 1000);

		r = TheFs.Delete(mediaPWrdFile);

		} while (r == KErrInUse);

	}

/** attempt to create a file on the removable media and return any error code */

LOCAL_C TInt CreateFile()

	{

	RFile f;

	TInt r = f.Replace(TheFs, KTestFileName, EFileShareAny);

	if (r == KErrNone)

		f.Close();

	return r;

	}

/** get size of the media store file in bytes, and return any error code */

LOCAL_C TInt PWFileSize(TInt &aLength)

	{

	TInt r;										// error code

	// allow low priority background writer thread to start and finish

	User::After(1 * 1000 * 1000);

	TBuf<sizeof(KMediaPWrdFile)> mediaPWrdFile(KMediaPWrdFile);

	mediaPWrdFile[0] = (TUint8) RFs::GetSystemDriveChar();

	RFile f;

	if ((r = f.Open(TheFs, mediaPWrdFile, EFileShareAny)) == KErrNone)

		{

		r = f.Size(aLength);

		f.Close();

		}

	return r;

	}

/**

 * write message to screen and attempt to access disk.  If card is locked then async

 * notifier will be brought up from within file server.

 */

LOCAL_C TInt AccessDisk(TAccessType aAccess, const TDesC8 &aPWD)

	{

	TBuf16<16> pwd;

	pwd.Copy((const TUint16 *)aPWD.Ptr(), aPWD.Length() / 2);

	if (aAccess == EAccessUnlock || aAccess == EAccessStore)

		test.Printf(_L("\"%S\": "), &pwd);

	switch(aAccess)

		{

		case EAccessUnlock: 

			test.Printf(_L("unlock\n"));

			break;

		case EAccessStore:

			test.Printf(_L("store\n"));

			break;

		case EAccessCancel:

			test.Printf(_L("cancel\n"));

			break;

		case EAccessWrongPw:

			test.Printf(_L("wrong\n"));

			break;

		case EAccessNoNotifier:

			test.Printf(_L("** no notifier **\n"));

			break;

		default:

			test(EFalse);

			break;

		}

	TInt r = TheFile.Open(TheFs, KTestFileName, EFileShareAny);

	if(r == KErrNone)

		TheFile.Close();

	return r;

	}

/**

 * uses RFs::DriveInfo() to test if the card has a password.  Is checking

 * that iHasPassword in TMMCCard is maintained properly.

 */

inline TBool bits_set(TUint aMsk, TUint aSel)

	{

	return (aMsk & aSel) == aSel;

	}

LOCAL_C void TestHasPassword(TBool aIL, TBool aHP)

	{

	const TInt d = KDrv;

	RFs &fs = TheFs;

	TDriveInfo di;

	test(fs.Drive(di, d) == KErrNone);

#ifdef __WINS__

	test(aIL == bits_set(di.iMediaAtt, KMediaAttLocked | KMediaAttLockable | KMediaAttHasPassword));

	test(aHP == bits_set(di.iMediaAtt, KMediaAttLockable | KMediaAttHasPassword));

#else

	test(aIL == bits_set(di.iMediaAtt, KMediaAttLocked | KMediaAttHasPassword));

	test(aHP == bits_set(di.iMediaAtt, KMediaAttHasPassword));

#endif

	}

// -------- test functions --------

/**

 * test return values of LockDrive(), UnlockDrive() and ClearPassword()

 * without trying use the disk.  This tests that the functions return the

 * same values as the TBusLocalDrive functions.

 *

 *			EPbPswdUnlock		EPbPswdLock			EPbPswdClear

 *			right	wrong		right	wrong		right	wrong	

 * locked	None	AccDen		AccDec	AccDen		AccDen	AccDen	

 * unlocked	AldExst	AldExst		None	AccDec		None	AccDen	

 *

 * Locked means inaccessible, not just has password.

 */

LOCAL_C void TestLockUnlockR()

	{

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

	const TInt d = KDrv;

	RFs &fs = TheFs;

	test.Next(_L("assign password"));

	test(fs.LockDrive(d, KNul, KPw1, EFalse) == KErrNone);			// assign test password

	TestHasPassword(EFalse, ETrue);

	RemountMedia();													// card is now locked

	TestHasPassword(ETrue, ETrue);

	test.Next(_L("lock locked card"));

	test(fs.LockDrive(d, KPw2, KPw1, EFalse) == KErrAccessDenied);	// lock locked wrong

	TestHasPassword(ETrue, ETrue);

	test(fs.LockDrive(d, KPw1, KPw1, EFalse) == KErrAccessDenied);	// lock locked right

	TestHasPassword(ETrue, ETrue);

	test.Next(_L("unlock locked card"));

	test(fs.UnlockDrive(d, KPw2, EFalse) == KErrAccessDenied);		// unlock locked wrong

	TestHasPassword(ETrue, ETrue);

	test(fs.UnlockDrive(d, KPw1, EFalse) == KErrNone);				// unlock locked right

	TestHasPassword(EFalse, ETrue);

	test.Next(_L("unlock unlocked card"));

	test(fs.UnlockDrive(d, KPw1, EFalse) == KErrAlreadyExists);		// unlock unlocked right

	TestHasPassword(EFalse, ETrue);

	test(fs.UnlockDrive(d, KPw2, EFalse) == KErrAlreadyExists);		// unlock unlocked wrong

	TestHasPassword(EFalse, ETrue);

	test.Next(_L("lock unlocked card"));

	test(fs.LockDrive(d, KPw2, KPw1, EFalse) == KErrAccessDenied);	// lock unlocked wrong

	TestHasPassword(EFalse, ETrue);

	test(fs.LockDrive(d, KPw1, KPw1, EFalse) == KErrNone);			// lock unlocked right

	TestHasPassword(EFalse, ETrue);

	test.Next(_L("clear unlocked card"));

	test(fs.ClearPassword(d, KPw2) == KErrAccessDenied);			// clear unlocked wrong

	TestHasPassword(EFalse, ETrue);

	RemountMedia();

	test(fs.UnlockDrive(d, KPw1, EFalse) == KErrNone);

	TestHasPassword(EFalse, ETrue);

	test(fs.ClearPassword(d, KPw1) == KErrNone);					// clear unlocked right

	TestHasPassword(EFalse, EFalse);

	test.Next(_L("assign password"));

	test(fs.LockDrive(d, KNul, KPw1, EFalse) == KErrNone);			// assign test password

	TestHasPassword(EFalse, ETrue);

	RemountMedia();													// card is now locked

	TestHasPassword(ETrue, ETrue);

	test.Next(_L("clear locked card"));

	test(fs.ClearPassword(d, KPw2) == KErrAccessDenied);			// clear locked wrong

	TestHasPassword(ETrue, ETrue);

	test(fs.ClearPassword(d, KPw1) == KErrAccessDenied);			// clear locked right

	TestHasPassword(ETrue, ETrue);

	test.Next(_L("clean up for following tests"));

	test(fs.UnlockDrive(d, KPw1, EFalse) == KErrNone);

	TestHasPassword(EFalse, ETrue);

	test(fs.ClearPassword(d, KPw1) == KErrNone);

	TestHasPassword(EFalse, EFalse);

	ClearControllerStore();

	DeletePasswordFile();

	test.End();

	}

/** test the special cases where null passwords are used. */

LOCAL_C void TestNullPasswords()

	{

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

	test.Next(_L("card has no password"));

	test(TheFs.LockDrive(KDrv, KNul, KNul, ETrue) == KErrAccessDenied);

	test(TheFs.UnlockDrive(KDrv, KNul, ETrue) == KErrAlreadyExists);

	test(TheFs.ClearPassword(KDrv, KNul) == KErrAccessDenied);

	test.Next(_L("card has password and is unlocked"));

	test(TheFs.LockDrive(KDrv, KNul, KPw1, ETrue) == KErrNone);

	RemountMedia();

	test(TheFs.LockDrive(KDrv, KNul, KNul, ETrue) == KErrAccessDenied);

	test(TheFs.UnlockDrive(KDrv, KNul, ETrue) == KErrAlreadyExists);

	test(TheFs.ClearPassword(KDrv, KNul) == KErrAccessDenied);

	test(TheFs.ClearPassword(KDrv, KPw1) == KErrNone);

	test.Next(_L("unlock with null disallowed"));

	RemountMedia();

	test(TheFs.UnlockDrive(KDrv, KNul, ETrue) == KErrAccessDenied);

	test.Next(_L("check can still use card"));

	test(TheFs.LockDrive(KDrv, KNul, KPw1, ETrue) == KErrNone);	// check can still use

	test(TheFs.ClearPassword(KDrv, KPw1) == KErrNone);

	test.Next(_L("clean up for following tests"));

	ClearControllerStore();

	DeletePasswordFile();

	test.End();

	}

/** test LockDrive(), UnlockDrive() and ClearPassword() with locked media notifier */

LOCAL_C void TestLockUnlock()

	{

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

	const TInt d = KDrv;

	RFs &fs = TheFs;

	test.Next(_L("create test file"));

	test(CreateFile() == KErrNone);

	test.Next(_L("lock card and don't store"));

	test(fs.LockDrive(d, KNul, KPw1, EFalse) == KErrNone);			// unlocked KPw1

	TestHasPassword(EFalse, ETrue);

	test.Next(_L("access with right pwd"));

	RemountMedia();													// locked KPw1

	TestHasPassword(ETrue, ETrue);

	test(AccessDisk(EAccessUnlock, KPw1) == KErrNone);

	TestHasPassword(EFalse, ETrue);

	test.Next(_L("access with cancelled pwd"));

	RemountMedia();													// locked KPw1	

	TestHasPassword(ETrue, ETrue);

	test(AccessDisk(EAccessCancel, KNul) == KErrLocked);

	TestHasPassword(ETrue, ETrue);

	test.Next(_L("access with new stored pwd"));

	RemountMedia();

	TestHasPassword(ETrue, ETrue);

	test(AccessDisk(EAccessStore, KPw1) == KErrNone);				// unlocked KPw1

	TestHasPassword(EFalse, ETrue);

	test.Next(_L("access with stored pwd"));

	RemountMedia();													// unlocked KPw1 (use store)

	TestHasPassword(EFalse, ETrue);

	test(AccessDisk(EAccessNoNotifier, KNul) == KErrNone);

	TestHasPassword(EFalse, ETrue);

	test.Next(_L("lock wrong pwd"));

	test(fs.LockDrive(d, KPw3, KPw2, EFalse) == KErrAccessDenied);	// unlocked KPw1

	TestHasPassword(EFalse, ETrue);

	test.Next(_L("change pwd"));

	test(fs.LockDrive(d, KPw1, KPw2, EFalse) == KErrNone);			// unlocked KPw2 (rem from store)

	TestHasPassword(EFalse, ETrue);

	test.Next(_L("mapping removed from store"));

	RemountMedia();

	test(AccessDisk(EAccessUnlock, KPw2) == KErrNone);

	TestHasPassword(EFalse, ETrue);

	test.Next(_L("wrong password"));

	RemountMedia();													// locked KPw2

	TestHasPassword(ETrue, ETrue);

	test(AccessDisk(EAccessWrongPw, KNul) == KErrLocked);

	TestHasPassword(ETrue, ETrue);

	test.Next(_L("unlocked card"));

	test(fs.UnlockDrive(d, KPw2, ETrue) == KErrNone);				// unlocked KPw2 (add to store)

	TestHasPassword(EFalse, ETrue);

	test(AccessDisk(EAccessNoNotifier, KNul) == KErrNone);			// before power down

	TestHasPassword(EFalse, ETrue);

	test.Next(_L("clear wrong pwd"));

	test(fs.ClearPassword(d, KPw1) == KErrAccessDenied);			// KPw2 backup kept

	TestHasPassword(EFalse, ETrue);

	RemountMedia();													// unlocked KPw2 (use store)

	TestHasPassword(EFalse, ETrue);

	test(AccessDisk(EAccessNoNotifier, KNul) == KErrNone);

	TestHasPassword(EFalse, ETrue);

	test.Next(_L("change pwd"));

	test(fs.LockDrive(d, KPw2, KPw1, EFalse) == KErrNone);			// locked KPw1 (rem from store)

	TestHasPassword(EFalse, ETrue);

	RemountMedia();

	TestHasPassword(ETrue, ETrue);

	test(AccessDisk(EAccessUnlock, KPw1) == KErrNone);

	TestHasPassword(EFalse, ETrue);

	test.Next(_L("cancelled pwd"));

	RemountMedia();

	TestHasPassword(ETrue, ETrue);

	test(AccessDisk(EAccessCancel, KNul) == KErrLocked);

	TestHasPassword(ETrue, ETrue);

	test.Next(_L("clean up for following tests"));

	test(fs.UnlockDrive(d, KPw1, EFalse) == KErrNone);

	TestHasPassword(EFalse, ETrue);

	test(fs.ClearPassword(KDrv, KPw1) == KErrNone);

	TestHasPassword(EFalse, EFalse);

	RemountMedia();

	TestHasPassword(EFalse, EFalse);

	test(AccessDisk(EAccessNoNotifier, KNul) == KErrNone);

	TestHasPassword(EFalse, EFalse);

	ClearControllerStore();

	DeletePasswordFile();

	test.End();

	}

/**

 * test password store by accessing disk in various states.  Ensures password

 * store file is right size after each operation.  More detailed checking of

 * the TBusLocalDrive::ReadPasswordData() ouput is done in t_pwstr.

 */

LOCAL_C void TestPasswordStore()

	{

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

//	TInt r;										// general error code

	RFs &fs = TheFs;

	const TInt d = KDrv;

	test.Next(_L("create test file on first media"));