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

// e32test\mediext\d_nfe.cpp

// 

//

#include <drivers/locmedia.h>

#include <platform.h>

#include <variantmediadef.h>

#include "nfe.h"

#if defined(_DEBUG)

	#define TRACE_ENABLED

#else

#endif

#if defined(TRACE_ENABLED)

#define __KTRACE_PRINT(p) {p;}

#else

#define __KTRACE_PRINT(p)

#endif

// Variant parameters for test Media Extension Driver

const TInt KNfeThreadPriority = 24;	        // same as file server

const TInt KNfeDiskOpReady = 100;       //100%

//const TInt KNfeDiskOpStart = 0;         //0%

_LIT(KPddName, "Media.NFE");

#define NFE_DRIVENAME "NFE"

#define NFE_NUMMEDIA 1

// Define the array of local drives which we're attaching to

__ASSERT_COMPILE(sizeof(TNfeDeviceInfo) <= 256);	// KMaxQueryDeviceLength

// Define the array of local code-paging drives which we're attaching to

#ifdef __DEMAND_PAGING__

	__ASSERT_COMPILE(NFE_PAGEDRIVECOUNT <= TNfeDeviceInfo::ENfeMaxPartitionEntries);

	__ASSERT_COMPILE(NFE_DRIVECOUNT >= NFE_PAGEDRIVECOUNT);

	#define	SECTOR_SHIFT 9

#endif	// #ifdef __DEMAND_PAGING__

class DPrimaryMediaExt : public DPrimaryMediaBase

	{

public:

	DPrimaryMediaExt(TInt aInstance);

public:

	TInt iInstance;

	TDfcQue iNfeDfcQ;

	};

// Get the number of drives in the drive array belonging to this instance 

TInt DriveCount(TInt aInstance)

	{

	static const TInt NfeInstanceDriveCounts[NFE_INSTANCE_COUNT]={NFE_INSTANCE_DRIVE_COUNTS};

	return NfeInstanceDriveCounts[aInstance];

	}

// Get a pointer to the first drive in the drive array belonging to this instance 

const TInt* DriveList(TInt aInstance)

	{

	static const TInt NfeDriveNumbers[NFE_DRIVECOUNT]={NFE_DRIVELIST};

	TInt driveListOffset = 0;

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

		driveListOffset+= DriveCount(n);

	return  NfeDriveNumbers + driveListOffset;

	}

const TInt* DriveLetterList(TInt aInstance)

	{

	static const TInt NfeDriveLetters[NFE_DRIVECOUNT]={NFE_DRIVELETTERLIST};

	TInt driveListOffset = 0;

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

		driveListOffset+= DriveCount(n);

	return  NfeDriveLetters + driveListOffset;

	}

TInt DriveLetter(TInt aIndex)

	{

	static const TInt NfeDriveLetters[NFE_DRIVECOUNT]={NFE_DRIVELETTERLIST};

	return NfeDriveLetters[aIndex];

	}

TChar DriveLetterToAscii(TInt aDriveLetter)

	{

	return aDriveLetter >= 0 && aDriveLetter <= 25 ? aDriveLetter +'A' : '?';

	}

#ifdef __DEMAND_PAGING__

	// Get the number of drives in the paged drive array belonging to this instance 

	TInt PageDriveCount(TInt aInstance)

		{

	#if NFE_PAGEDRIVECOUNT > 0

		static const TInt NfeInstancePageDriveCounts[NFE_INSTANCE_COUNT]={NFE_INSTANCE_PAGEDRIVE_COUNTS};

		return NfeInstancePageDriveCounts[aInstance];

	#else

		return 0;

	#endif

		}

	// Get a pointer to the first drive in the paged drive array belonging to this instance 

	const TInt* PageDriveList(TInt aInstance)

		{

	#if NFE_PAGEDRIVECOUNT > 0

		static const TInt NfePageDriveNumbers[NFE_PAGEDRIVECOUNT]={NFE_PAGEDRIVELIST};

		TInt driveListOffset = 0;

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

			driveListOffset+= PageDriveCount(n);

		return  NfePageDriveNumbers + driveListOffset;

	#else

		return NULL;

	#endif

		}

	// Get the number of paging type belonging to this instance 

	TInt PagingType(TInt aInstance)

		{

	#if NFE_PAGEDRIVECOUNT > 0

		static const TInt NfeInstancePagingType[NFE_INSTANCE_COUNT]={NFE_INSTANCE_PAGING_TYPE};

		return NfeInstancePagingType[aInstance];

	#else

		return 0;

	#endif

		}

	// get the instance of the swap drive

	TInt SwapInstance()

		{

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

			if (PagingType(i) & DPagingDevice::EData)

				return i;

		return KErrNotFound;

		}

#endif	// #ifdef __DEMAND_PAGING__

const char* DriveStatus(TNfeDiskStatus aStatus)

	{

	const char* KNfeUnmounted = "Unmounted";

	const char* KNfeDecrypted = "Decrypted";

	const char* KNfeDecrypting = "Decrypting";

	const char* KNfeEncrypted = "Encrypted";

	const char* KNfeEncrypting = "Encrypting";

	const char* KNfeWiping = "Wiping";

	const char* KNfeCorrupted = "Corrupted";

	const char* KNfeUnrecognised = "Unrecognised";

	switch(aStatus)

		{

		case ENfeUnmounted:

			return KNfeUnmounted;

		case ENfeDecrypted:

			return KNfeDecrypted;

		case ENfeDecrypting:

			return KNfeDecrypting;

		case ENfeEncrypted:

			return KNfeEncrypted;

		case ENfeEncrypting:

			return KNfeEncrypting;

		case ENfeWiping:

			return KNfeWiping;

		case ENfeCorrupted:

			return KNfeCorrupted;

		default:

			return KNfeUnrecognised;

		}

	}

DPrimaryMediaExt::DPrimaryMediaExt(TInt aInstance) : iInstance(aInstance)

	{

	}

#define NFE_FAULT()	Kern::Fault("NFEMEDIA",__LINE__)

// disk encryption/decryption/wiping is only performed after the following period of inactivity

// NB USB Mass Storage tends to 'poll' the media driver by sending ECaps every second or so, so we need

// to ensure this timeout period is significantly less to ensure the timer DFC thread gets a chance to run...

const TInt KNotBusyInterval = 200;		// 200 mS

class DPhysicalDeviceMediaNFE : public DPhysicalDevice

	{

public:

	DPhysicalDeviceMediaNFE();

	virtual TInt Install();

	virtual void GetCaps(TDes8& aDes) const;

	virtual TInt Create(DBase*& aChannel, TInt aMediaId, const TDesC8* anInfo, const TVersion& aVer);

	virtual TInt Validate(TInt aDeviceType, const TDesC8* anInfo, const TVersion& aVer);

	virtual TInt Info(TInt aFunction, TAny* a1);

	};

class DMediaDriverNFE : public DMediaDriverExtension

	{

public:

	class TPropertyObserver

		{

	public:

		void Close();

		static void PropertySubsCompleteFn(TAny* aPtr, TInt aReason);

	public:

		TInt iDriveIndex;

		DMediaDriverNFE* iMediaExt;

		RPropertyRef iProperty;

		TPropertySubsRequest* iPropertySubsRequest;

		TDfc* iPropertyDfc;	// N.B. subscription call backs don't occur in our thread context, hence the need for this DFC

		TInt iValue;

		};

public:

	 DMediaDriverNFE(TInt aMediaId);

	~DMediaDriverNFE();

	// replacing pure virtual

	virtual TInt Request(TLocDrvRequest& aRequest);

	virtual TInt PartitionInfo(TPartitionInfo &anInfo);

	TInt DoCreate(TInt aMediaId);

	void Close();

	TNfeDriveInfo*  GetSwapDrive();

private:

	TInt HandleRead(TLocDrvRequest& aRequest);

	TInt HandleWrite(TLocDrvRequest& aRequest);

	TInt HandleFormat(TLocDrvRequest& aRequest);

	TInt HandleCaps(TLocDrvRequest& aReq);

	void EncryptBuffer(TDes8& aBuffer);

	void DecryptBuffer(TDes8& aBuffer);

	inline TUint8 EncryptByte(TUint8 aByte) {return (TUint8) (aByte ^ 0xDD);}

	inline TUint8 DecryptByte(TUint8 aByte) {return (TUint8) (aByte ^ 0xDD);}

	inline TInt DriveIndex(TInt aDriveNum) {return iDriveNumToIndex[aDriveNum];}

	static void IdleTimerCallBack(TAny* aMediaDriver);

	static void TimerDfcFunction(TAny* aMediaDriver);

	// Publish & Subscribe stuff - used to listen to requests from UI 

	static void FromUiPropertyDfcFunction(TAny* aObserver);

	void FromUiPropertyDfc(TPropertyObserver& aObserver);

	// Publish & Subscribe stuff - used to listen to status setting from other NFE drives

	static void StatusToUiPropertyDfcFunction(TAny* aObserver);

	void StatusToUiPropertyDfc(TPropertyObserver& aObserver);

	void StartEncrypting();

	void StartDecrypting();

	TInt HandleDiskContent();	// called from idle timer DFC

	TNfeDriveInfo* NextDrive();

	TBool AdjustRequest(TNfeDriveInfo*& aDriveInfo, TInt64& aCurrentPos, TInt64& aCurrentLen);

	void SetStatus(TNfeDriveInfo& aDi, TNfeDiskStatus aStatus);

	TBool ValidBootSector(TUint8* aBuffer);

	TUint32 VolumeId(TUint8* aBuffer);

	void CheckBootSector(TNfeDriveInfo &aDriveInfo);

	TInt WriteEncryptionStatusToBootSector(TNfeDriveInfo &aDi, TBool aFinalised = EFalse);

private:

	TInt iInstance;		// media drive instance

	// A local buffer use for encryting / decrypting

	// For paging requests we need this to be page aligned, so allocate enough to cater for 

	// the worst case of up to 4K being wasted at the start of the buffer and the end

	enum {KSectorSize = 512, KPageSize = 4096, KBufSize = 65536};

	TUint8 iNonPageAlignedBuffer[KBufSize + KPageSize*2];

	// a pointer to the start of the first page in iNonPageAlignedBuffer

	TUint8* iBuffer;

	// Idle timer & DFC for kicking an encryption pass

	NTimer iIdleTimer;

	TDfc iTimerDfc;

	TInt iDriveIndex;								// index of local drive number currently being encrypted

	TInt iDriveNumToIndex[KMaxPartitionEntries];	// maps drive numbers to index

	TBool iBusy;

	const TInt* iDriveList;	// pointer into the drives in NFE_DRIVELIST belonging to this media driver

	const TInt* iDriveLetterList;	// pointer into the drive letter in NFE_DRIVELETTERLIST belonging to this media driver

	// Publish & subscribe stuff which handles drive command notification events from the UI

	TPropertyObserver iFromUiPropertyObserver[NFE_DRIVECOUNT];

	// Publish & subscribe stuff which handles drive status notification events from the other NFE drives

	TPropertyObserver iStatusToUiPropertyObserver[NFE_DRIVECOUNT];

	TBool iDriveFinalised;

public:

	// Partition information etc for drives this driver is attached to

	TNfeDeviceInfo iInfo;

	};

class TBootSectorStatus

	{

public:

	TUint8 iFatBootSectorData[128];

	enum {ENfeBootSectorSignature = 0x2045464E};	// 'NFE '

	TUint32 iSignature;

	TNfeDiskStatus iStatus;

	TBool iFinalised;

	TInt64 iEncryptEndPos;	// position of the last encrypted byte +1. Only written when device is powered down

	};

DPhysicalDeviceMediaNFE::DPhysicalDeviceMediaNFE()

	{

	__KTRACE_PRINT(Kern::Printf(": DPhysicalDeviceMediaNFE::DPhysicalDeviceMediaNFE()"));

	iUnitsMask=0x1;

	iVersion=TVersion(KMediaDriverInterfaceMajorVersion,KMediaDriverInterfaceMinorVersion,KMediaDriverInterfaceBuildVersion);

	}

/**

Install the Internal NFE PDD.

*/

TInt DPhysicalDeviceMediaNFE::Install()

	{

	__KTRACE_PRINT(Kern::Printf(": TInt DPhysicalDeviceMediaNFE::Install()"));

	return SetName(&KPddName);

	}

void DPhysicalDeviceMediaNFE::GetCaps(TDes8& /*aDes*/) const

	{

	}

/**

Create an NFE media driver.

*/

TInt DPhysicalDeviceMediaNFE::Create(DBase*& aChannel, TInt aMediaId, const TDesC8* /* anInfo */,const TVersion &aVer)

	{

	__KTRACE_PRINT(Kern::Printf(": DPhysicalDeviceMediaNFE::Create()"));

	if (!Kern::QueryVersionSupported(iVersion,aVer))

		return KErrNotSupported;

	TInt r=KErrNoMemory;

	DMediaDriverNFE* pD = new DMediaDriverNFE(aMediaId);

	aChannel=pD;

	if (pD)

		r=pD->DoCreate(aMediaId);

	if (r == KErrNone)

		pD->OpenMediaDriverComplete(KErrNone);

	return r;

	}

TInt DPhysicalDeviceMediaNFE::Validate(TInt aDeviceType, const TDesC8* /*anInfo*/, const TVersion& aVer)

	{

	TInt r;

	if (!Kern::QueryVersionSupported(iVersion,aVer))

		r = KErrNotSupported;

	else if (aDeviceType == MEDIA_DEVICE_NFE)

		return r = KErrNone;

	else

		r = KErrNotSupported;

//	__KTRACE_PRINT(Kern::Printf("DPhysicalDeviceMediaNFE::Validate() aDeviceType %d NfeDeviceType %d r %d", aDeviceType, MEDIA_DEVICE_NFE, r));

	return r;

	}

TInt DPhysicalDeviceMediaNFE::Info(TInt aFunction, TAny*)

//

// Return the priority of this media driver

//

	{

//	__KTRACE_PRINT(Kern::Printf(": DPhysicalDeviceMediaNFE::Info()"));

	if (aFunction==EPriority)

		return KMediaDriverPriorityNormal;

	if (aFunction==EMediaDriverPersistent)

		return KErrNone;

	return KErrNotSupported;

	}

DMediaDriverNFE::DMediaDriverNFE(TInt aMediaId) :

	DMediaDriverExtension(aMediaId),

	iInstance(((DPrimaryMediaExt*) iPrimaryMedia)->iInstance),

	iIdleTimer(IdleTimerCallBack,this),

	iTimerDfc(TimerDfcFunction,this,2),

	iDriveList (DriveList(iInstance)),

	iDriveLetterList (DriveLetterList(iInstance))

	{

	__KTRACE_PRINT(Kern::Printf("NFE%d: DMediaDriverNFE::DMediaDriverNFE()", iInstance));

	iInfo.iDriveCount = DriveCount(iInstance);

	__ASSERT_ALWAYS(Kern::RoundToPageSize(1) == KPageSize, NFE_FAULT());

	// Align the buffer to a page boundary to improve efficiency for paging requests

	iBuffer = &iNonPageAlignedBuffer[0];

	iBuffer = (TUint8*) ((((TUint32) &iNonPageAlignedBuffer[0]) + KPageSize-1) & ~(KPageSize-1));

	}

DMediaDriverNFE::~DMediaDriverNFE()

//

// Destructor.

//

	{

	__KTRACE_PRINT(Kern::Printf("NFE%d: DMediaDriverNFE::~DMediaDriverNFE()", iInstance));

	TInt i;

	for (i=0; i<TNfeDeviceInfo::ENfeMaxPartitionEntries; i++)

		{

		RPropertyRef* property = (RPropertyRef*) iInfo.iDrives[i].iStatusToUiProperty;

		if (property)

			{

			property->Delete();

			delete property;

			}

		property = (RPropertyRef*) iInfo.iDrives[i].iToUiProperty;

		if (property)

			{

			property->Delete();

			delete property;

			}

		property = (RPropertyRef*) iInfo.iDrives[i].iProgressToUiProperty;

		if (property)

			{

			property->Delete();

			delete property;

			}

		}

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

		{

		iFromUiPropertyObserver[i].Close();

		iStatusToUiPropertyObserver[i].Close();

		}

	}

TInt CreateKey(RPropertyRef*& aProperty, TUint aKey)

	{

	aProperty = new RPropertyRef;

	if (aProperty == NULL)

		return KErrNoMemory;

	TInt r = aProperty->Attach(KNfeUID, aKey);

	if (r != KErrNone)

		return r;

    static _LIT_SECURITY_POLICY_PASS(KPassPolicy);

	r = aProperty->Define( RProperty::EInt, KPassPolicy, KPassPolicy );

	if (r != KErrNone && r != KErrAlreadyExists)

		return r;

	return KErrNone;

	}

TInt DMediaDriverNFE::DoCreate(TInt /*aMediaId*/)

//

// Create the media driver.

//

	{

	__KTRACE_PRINT(Kern::Printf("NFE%d: TInt DMediaDriverNFE::DoCreate()", iInstance));

	// Associate the idle timer DFC with our thread

	iTimerDfc.SetDfcQ(iPrimaryMedia->iDfcQ);

	// Publish & Subscribe stuff - used to initiate an encryption pass from the test app

	static _LIT_SECURITY_POLICY_PASS(KPassPolicy);

	TInt r;

	TInt i;

	TInt swapInstance = KErrNotFound;

#if defined (__DEMAND_PAGING__)

	swapInstance = SwapInstance();

#endif

	// **************************************************************************************

	// Set up P&S publishers so we can publish the status for our drives

	// **************************************************************************************

	__KTRACE_PRINT(Kern::Printf("NFE%d: Setting up StatusToUi, ToUi, ProgressToUi P&S publisher & FromUi P&S observer", iInstance));

	for (i = 0; i<DriveCount(iInstance); i++)

		{

		__KTRACE_PRINT(Kern::Printf("NFE%d:drive index %d", iInstance, i));

		TInt driveLetter = iDriveLetterList[i];

		__KTRACE_PRINT(Kern::Printf("NFE%d:drive letter %c", iInstance, (TInt) DriveLetterToAscii(driveLetter)));

		// no point setting up P&S for the swap drive

		if (driveLetter == -1)

			{

			__KTRACE_PRINT(Kern::Printf("NFE%d: i %d, Skipping P&S for swap partition", iInstance, i));

			continue;

			}

		r = CreateKey((RPropertyRef*&) iInfo.iDrives[i].iStatusToUiProperty, NFE_KEY(driveLetter, KNfeStatusToUiKey));

		if (r != KErrNone)

			return r;