/*

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

 *

 */

 //

 // RAWEXT.CPP

 //

 // This file system extension provides a way to access a drive on the local windows system in "raw format".

 // It can be used to test large files / drives

 // 

 // NB This should be used WITH CARE to avoid unintentionally overwriting or formatting a windows disk

 // 

 #include <f32fsys.h>

 #include <emulator.h>

 #include <windows.h>

 #define WIN32_LEAN_AND_MEAN

 #pragma warning (disable:4201) // warning C4201: nonstandard extension used : nameless struct/union

 #include <winioctl.h>

 // Enable this macro to find the last REMOVABLE drive (e.g. a card reader drive) 

 // (to minimise the chance of doing any damage !

 // Doesn't even try any drive letters below E (again for safety):

 #define __LOOK_FOR_DRIVE__

 // Otherwise the windows drive letter can be hard-coded here:

 #ifndef __LOOK_FOR_DRIVE__

 	char diskName[] = "\\\\.\\Y:";

 #endif

 const TInt KSectorSize = 512;

 class CRawWinDiskExtProxyDrive : public CBaseExtProxyDrive

 	{

 public:

 	static CRawWinDiskExtProxyDrive* NewL(CProxyDrive* aProxyDrive, CMountCB* aMount);

 	~CRawWinDiskExtProxyDrive();

 public:

 	virtual TInt Initialise();

 	virtual TInt Dismounted();

 	virtual TInt Enlarge(TInt aLength);

 	virtual TInt ReduceSize(TInt aPos, TInt aLength);

 	virtual TInt Read(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt aThreadHandle,TInt anOffset);

 	virtual TInt Read(TInt64 aPos,TInt aLength,TDes8& aTrg);

 	virtual TInt Write(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt aThreadHandle,TInt anOffset);

 	virtual TInt Write(TInt64 aPos,const TDesC8& aSrc);

 	virtual TInt Caps(TDes8& anInfo);

 	virtual TInt Format(TFormatInfo& anInfo);

 private:

 	CRawWinDiskExtProxyDrive(CProxyDrive* aProxyDrive, CMountCB* aMount);

 private:

 	HANDLE iDeviceHandle; 

 	};

 class CRawWinDiskProxyDriveFactory : public CProxyDriveFactory

 	{

 public:

 	CRawWinDiskProxyDriveFactory();

 	virtual TInt Install();			

 	virtual CProxyDrive* NewProxyDriveL(CProxyDrive* aProxy,CMountCB* aMount);

 	};

 CRawWinDiskExtProxyDrive* CRawWinDiskExtProxyDrive::NewL(CProxyDrive* aProxyDrive, CMountCB* aMount)

 //

 //

 //

 	{

 	CRawWinDiskExtProxyDrive* temp=new(ELeave) CRawWinDiskExtProxyDrive(aProxyDrive,aMount);

 	return(temp);

 	}

 CRawWinDiskExtProxyDrive::CRawWinDiskExtProxyDrive(CProxyDrive* aProxyDrive, CMountCB* aMount):CBaseExtProxyDrive(aProxyDrive,aMount)

 	{

 	RDebug::Print(_L("CRawWinDiskExtProxyDrive::CRawWinDiskExtProxyDrive"));

 	}

 CRawWinDiskExtProxyDrive::~CRawWinDiskExtProxyDrive()

 //

 //

 //

 	{

 	CloseHandle(iDeviceHandle);

 	}

 TInt CRawWinDiskExtProxyDrive::Initialise()

 //

 //

 //

 	{

 	RDebug::Print(_L("CRawWinDiskExtProxyDrive::Initialise()"));

 #ifdef __LOOK_FOR_DRIVE__

 	// Find the last REMOVABLE drive (to minimise the chance of doing any damage !

 	// Don't even try any drive letters below E (agai for safety):

 	char diskName[] = "\\\\.\\?:";

 	char driveLetter;

 	for (driveLetter = 'Z'; driveLetter > 'D'; driveLetter--)

 		{

 		diskName[4] = driveLetter;

 		DISK_GEOMETRY geometry;

 		DWORD dummy;

 		iDeviceHandle = CreateFileA(diskName, 

 			GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, 

 			NULL, OPEN_EXISTING, 0, NULL); 

 		if (iDeviceHandle == INVALID_HANDLE_VALUE) 

 			{

 			continue;

 			}

 		if(DeviceIoControl(iDeviceHandle, 

 							IOCTL_DISK_GET_DRIVE_GEOMETRY, 

 							NULL, 

 							0, 

 							&geometry, 

 							sizeof(geometry), 

 							&dummy, 

 							(LPOVERLAPPED)NULL))

 			{

 			RDebug::Print(_L("Drive %c MediaType %d removable %s"), 

 				driveLetter, 

 				geometry.MediaType,

 				geometry.MediaType==RemovableMedia ? _S16("True") : _S16("False"));

 			}

 		CloseHandle(iDeviceHandle);

 		if (geometry.MediaType==RemovableMedia)

 			break;

 		}

 	if (driveLetter == 'D')

 		return KErrNotFound;

 #endif

 	// Creating a handle to drive a: using CreateFile () function ..

 	TPtrC8 diskName8((const TUint8*) diskName);

 	TBuf16<16> diskName16;

 	diskName16.Copy(diskName8);

 	RDebug::Print(_L("RAWEXT: Opening drive %S"), &diskName16);

 	iDeviceHandle = CreateFileA(

 //		"\\\\.\\H:",

 		diskName,

         GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, 

         NULL, OPEN_EXISTING, 0, NULL); 

     if (iDeviceHandle == INVALID_HANDLE_VALUE) 

 		{

 		return Emulator::LastError();

 		}

 	return KErrNone;

 	}

 TInt CRawWinDiskExtProxyDrive::Dismounted()

 //

 //

 //

 	{

 	RDebug::Print(_L("CRawWinDiskExtProxyDrive::Dismounted()"));

 	return(KErrNone);

 	}

 TInt CRawWinDiskExtProxyDrive::Enlarge(TInt /*aLength*/)

 //

 //

 //

 	{

 	return(KErrNotSupported);

 	}

 TInt CRawWinDiskExtProxyDrive::ReduceSize(TInt /*aPos*/, TInt /*aLength*/)

 //

 //

 //

 	{

 	return(KErrNotSupported);

 	}

 LOCAL_C TInt ParameterNum(const TInt aMessageHandle, const TAny* aAddress)

 	{

 	RMessage2 tmpMessage(*(RMessagePtr2 *) &aMessageHandle);

 	if (tmpMessage.Ptr0() == aAddress)

 		{

 		return 0;

 		}

 	if (tmpMessage.Ptr1() == aAddress)

 		{

 		return 1;

 		}

 	if (tmpMessage.Ptr2() == aAddress)

 		{

 		return 2;

 		}

 	if (tmpMessage.Ptr3() == aAddress)

 		{

 		return 3;

 		}

 	User::Panic(_L("RAWEXT"),KErrBadHandle);

 	return -1;

 	}

 TInt CRawWinDiskExtProxyDrive::Read(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt aThreadHandle,TInt aOffset)

 //

 //

 //

 	{

 	//

 	// Set file position to where we want to read...

 	//

 	LARGE_INTEGER li;

 	li.QuadPart = aPos;

 	long posH = I64HIGH(aPos);

 	long posL = I64LOW(aPos);

 	TInt off = posL & 0x1FF;

 	posL &= ~0x1FF;

 	if(SetFilePointer (iDeviceHandle, posL, &posH, FILE_BEGIN) == 0xFFFFFFFF)

 		{

 		return Emulator::LastError();

 		}

 	const TInt KLocalBufferSize = 256*1024;

 	char buffer[KLocalBufferSize];

 	const TInt param = ParameterNum(aThreadHandle, aTrg);

 	TInt totalBytesRead = 0;

 	//

 	// Read first sector if start of data is offset from 512 bytes...

 	//

 	if(off)

 		{

 		// read 1st sector if offset

 		DWORD bytesRead;    

 		if (!ReadFile (iDeviceHandle, buffer, KSectorSize, &bytesRead, NULL) )

 			{

 			return Emulator::LastError();

 			}

 		if(bytesRead != KSectorSize)

 			{

 			return KErrNotReady;

 			}

 		bytesRead-= off;

 		TInt copyLen = Min(aLength, bytesRead);;

 		totalBytesRead += copyLen;

 		aLength -= copyLen;

 		TPtrC8 des((TUint8*) buffer+off, copyLen);

 		((RMessagePtr2 *) &aThreadHandle)->Write(param, des, aOffset);

 		}

 	//

 	// Read the remainder of the data, accounting for partial last sector...

 	//

 	while(aLength > 0)

 		{

 		TUint32 bytesThisTime = min(KLocalBufferSize, (TUint32)aLength);

 		bytesThisTime = (bytesThisTime + KSectorSize-1) & ~(KSectorSize-1);

 		DWORD bytesread;    

 		if (!ReadFile (iDeviceHandle, buffer, bytesThisTime, &bytesread, NULL) )

 			{

 			return Emulator::LastError();

 			}

 		if(bytesread != (TUint32)bytesThisTime)

 			{

 			return KErrNotReady;

 			}

 		TPtrC8 des((TUint8*)buffer, min((TUint32)aLength, bytesThisTime));

 		((RMessagePtr2 *) &aThreadHandle)->Write(param, des, aOffset + totalBytesRead);

 		totalBytesRead += bytesThisTime;

 		aLength -= bytesThisTime;

 		}

 	return KErrNone;

 	}

 //////

 GLDEF_C void DumpBuffer( const TDesC8& aBuffer )

 	/**

 	 * Dump the content of aBuffer in hex

 	 */

 	{

 	static const TText hextab[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 

 										'A', 'B', 'C', 'D', 'E', 'F' };

 	const TInt KBytesPerLine = 32;

 	const TInt KCharsPerLine = KBytesPerLine * 2;

 	TInt remaining = aBuffer.Length();

 	TUint8* pSrc = const_cast<TUint8*>(aBuffer.Ptr());

 	TBuf<KCharsPerLine> line;

 	line.SetLength( KCharsPerLine );	// don't need to print trailing space

 	TInt bytesPerLine = KBytesPerLine;

 	TInt lineOffs = 0;

 	while( remaining )

 		{

 		if( remaining < KBytesPerLine )

 			{

 			bytesPerLine = remaining;

 			line.SetLength( (bytesPerLine*2) );

 			}

 		TUint16* pDest = const_cast<TUint16*>(line.Ptr());

 		remaining -= bytesPerLine;

 		for( TInt i = bytesPerLine; i > 0; --i )

 			{

 			TUint8 c = *pSrc++;

 			*pDest++ = hextab[c >> 4];

 			*pDest++ = hextab[c & 0xF];

 			}

 		_LIT( KFmt, "%06x: %S\n\r" );

 		RDebug::Print( KFmt, lineOffs, &line );

 		lineOffs += bytesPerLine;

 		}

 	}

 TInt CRawWinDiskExtProxyDrive::Read(TInt64 aPos,TInt aLength,TDes8& aTrg)

 //

 //

 //

 	{

 	//

 	// Set file position to where we want to read...

 	//

 	LARGE_INTEGER li;

 	li.QuadPart = aPos;

 	long posH = I64HIGH(aPos);

 	long posL = I64LOW(aPos);

 	TInt off = posL & 0x1FF;

 	posL &= ~0x1FF;

 	if(SetFilePointer (iDeviceHandle, posL, &posH, FILE_BEGIN) == 0xFFFFFFFF)

 		{

 		return Emulator::LastError();

 		}

 	const TInt KLocalBufferSize = 256*1024;

 	char buffer[KLocalBufferSize];

 	TInt totalBytesRead = 0;

 	aTrg.SetLength(aLength);

 	//

 	// Read first sector if start of data is offset from 512 bytes...

 	//

 	if(off)

 		{

 		// read 1st sector if offset

 		DWORD bytesRead;    

 		if (!ReadFile (iDeviceHandle, buffer, KSectorSize, &bytesRead, NULL) )

 			{

 			return Emulator::LastError();

 			}

 		if(bytesRead != KSectorSize)

 			{

 			return KErrNotReady;

 			}

 		bytesRead-= off;

 		TInt copyLen = Min(aLength, bytesRead);;

 		totalBytesRead += copyLen;

 		aLength -= copyLen;

 		memcpy(&aTrg[0], &buffer[off], copyLen);

 		}

 	//

 	// Read the remainder of the data, accounting for partial last sector...

 	//

 	while(aLength > 0)

 		{

 		TInt bytesThisTime = (aLength > KLocalBufferSize) ? KLocalBufferSize : aLength;

 		bytesThisTime = (bytesThisTime + KSectorSize-1) & ~(KSectorSize-1);

 		DWORD bytesread;    

 		if (!ReadFile (iDeviceHandle, buffer, bytesThisTime, &bytesread, NULL) )

 			{

 			return Emulator::LastError();

 			}

 		if(bytesread != (TUint32)bytesThisTime)

 			 return KErrNotReady;

 		TInt copyLen = aLength < bytesThisTime ? aLength : bytesThisTime;

 		memcpy(&aTrg[totalBytesRead], buffer, copyLen);

 		totalBytesRead += bytesThisTime;

 		aLength -= bytesThisTime;

 		}

 //	DumpBuffer(aTrg);

 	return KErrNone;

 	}

 TInt CRawWinDiskExtProxyDrive::Write(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt aThreadHandle,TInt aOffset)

 //

 //

 //

 	{

 	//

 	// Set file position to where we want to write...

 	//

 	long posStartH = I64HIGH(aPos);

 	long posStartL = I64LOW(aPos);

 	TInt offStart = posStartL & 0x1FF;

 	posStartL &= ~0x1FF;

 	if(SetFilePointer (iDeviceHandle, posStartL, &posStartH, FILE_BEGIN) == 0xFFFFFFFF)

 		{

 		return Emulator::LastError();

 		}

 	const TInt KLocalBufferSize = 256*1024;

 	char buffer[KLocalBufferSize];

 	const TInt param = ParameterNum(aThreadHandle, aSrc);

 	TInt totalBytesRead = 0;

 	//

 	// Read-Modify-Write on first sector if start of data is offset from 512 bytes

 	// or if this is a partial write...

 	//

 	if(offStart || aLength < KSectorSize)

 		{

 		DWORD bytesread;    

 		if (!ReadFile (iDeviceHandle, buffer, KSectorSize, &bytesread, NULL) )

 			{

 			return Emulator::LastError();

 			}

 		if(bytesread != KSectorSize)

 			{

 			return KErrNotReady;

 			}

 		totalBytesRead = min(KSectorSize-offStart, aLength);

 		aLength -= totalBytesRead;

 		TPtr8 des((TUint8*)&buffer[offStart], totalBytesRead);

 		((RMessagePtr2 *) &aThreadHandle)->Read(param, des, aOffset);

 		if(SetFilePointer (iDeviceHandle, posStartL, &posStartH, FILE_BEGIN) == 0xFFFFFFFF)

 			{

 			return Emulator::LastError();

 			}

 		if (!WriteFile (iDeviceHandle, buffer, KSectorSize, &bytesread, NULL) )

 			{

 			return Emulator::LastError();

 			}

 		}

 	//

 	// Write the remainder of the aligned data

 	//

 	while(aLength >= KSectorSize)

 		{

 		TInt alignedLength = aLength & ~0x1FF;

 		TInt bytesThisTime = (alignedLength > KLocalBufferSize) ? KLocalBufferSize : alignedLength;

 		TPtr8 des((TUint8*)buffer, bytesThisTime);

 		((RMessagePtr2 *) &aThreadHandle)->Read(param, des, aOffset + totalBytesRead);

 		DWORD bytesWritten;    

 		if (!WriteFile (iDeviceHandle, buffer, bytesThisTime, &bytesWritten, NULL) )

 			{

 			return Emulator::LastError();

 			}

 		if(bytesWritten != (TUint32)bytesThisTime)

 			{

 			return KErrNotReady;

 			}

 		totalBytesRead += bytesThisTime;

 		aLength -= bytesThisTime;

 		}

 	//

 	// Read-Modify-Write on the last block if a partial write...

 	//

 	if(aLength > 0)

 		{

 		DWORD curPos = SetFilePointer(iDeviceHandle, 0, NULL, FILE_CURRENT);

 		// RMW last sector if offset

 		DWORD bytesread;    

 		if (!ReadFile (iDeviceHandle, buffer, KSectorSize, &bytesread, NULL) )

 			{

 			return Emulator::LastError();

 			}

 		if(bytesread != KSectorSize)

 			 return KErrNotReady;

 		TPtr8 des((TUint8*)buffer, aLength);

 		((RMessagePtr2 *) &aThreadHandle)->Read(param, des, aOffset + totalBytesRead);

 		if(SetFilePointer (iDeviceHandle, curPos, &posStartH, FILE_BEGIN) == 0xFFFFFFFF)

 			{

 			return Emulator::LastError();

 			}

 		if (!WriteFile (iDeviceHandle, buffer, KSectorSize, &bytesread, NULL) )

 			{

 			return Emulator::LastError();

 			}

 		}

 	return KErrNone;

 	}

 TInt CRawWinDiskExtProxyDrive::Write(TInt64 aPos,const TDesC8& aSrc)

 //

 //

 //

 	{

 	//

 	// Set file position to where we want to write...

 	//

 	TInt length = aSrc.Length();

 	long posStartH = I64HIGH(aPos);

 	long posStartL = I64LOW(aPos);

 	TInt offStart = posStartL & 0x1FF;

 	posStartL &= ~0x1FF;

 	if(SetFilePointer (iDeviceHandle, posStartL, &posStartH, FILE_BEGIN) == 0xFFFFFFFF)

 		{

 		return Emulator::LastError();

 		}

 	const TInt KLocalBufferSize = 256*1024;

 	char buffer[KLocalBufferSize];

 	TInt totalBytesRead = 0;

 	//

 	// Read-Modify-Write on first sector if start of data is offset from 512 bytes

 	// or if this is a partial write...

 	//

 	if(offStart || length < KSectorSize)

 		{

 		DWORD bytesread;    

 		if (!ReadFile (iDeviceHandle, buffer, KSectorSize, &bytesread, NULL) )

 			{

 			return Emulator::LastError();

 			}

 		if(bytesread != KSectorSize)

 			{

 			return KErrNotReady;

 			}

 		totalBytesRead = min(KSectorSize-offStart, length);

 		length -= totalBytesRead;

 		memcpy(&buffer[offStart], &aSrc[0], totalBytesRead);

 		if(SetFilePointer (iDeviceHandle, posStartL, &posStartH, FILE_BEGIN) == 0xFFFFFFFF)

 			{

 			return Emulator::LastError();

 			}

 		if (!WriteFile (iDeviceHandle, buffer, KSectorSize, &bytesread, NULL) )

 			{

 			return Emulator::LastError();

 			}

 		}

 	//

 	// Write the remainder of the aligned data

 	//

 	while(length >= KSectorSize)

 		{

 		TInt alignedLength = length & ~0x1FF;

 		TInt bytesThisTime = (alignedLength > KLocalBufferSize) ? KLocalBufferSize : alignedLength;

 		memcpy(buffer, &aSrc[totalBytesRead], bytesThisTime);

 		DWORD bytesWritten;    

 		if (!WriteFile (iDeviceHandle, buffer, bytesThisTime, &bytesWritten, NULL) )

 			{

 			return Emulator::LastError();

 			}

 		if(bytesWritten != (TUint32)bytesThisTime)

 			{

 			return KErrNotReady;

 			}

 		totalBytesRead += bytesThisTime;

 		length -= bytesThisTime;

 		}

 	//

 	// Read-Modify-Write on the last block if a partial write...

 	//

 	if(length > 0)

 		{

 		DWORD curPos = SetFilePointer(iDeviceHandle, 0, NULL, FILE_CURRENT);

 		// RMW last sector if offset

 		DWORD bytesread;    

 		if (!ReadFile (iDeviceHandle, buffer, KSectorSize, &bytesread, NULL) )

 			{

 			return Emulator::LastError();

 			}

 		if(bytesread != KSectorSize)

 			 return KErrNotReady;

 		memcpy(&buffer[0], &aSrc[totalBytesRead], length);

 		if(SetFilePointer (iDeviceHandle, curPos, &posStartH, FILE_BEGIN) == 0xFFFFFFFF)

 			{

 			return Emulator::LastError();

 			}

 		if (!WriteFile (iDeviceHandle, buffer, KSectorSize, &bytesread, NULL) )

 			{

 			return Emulator::LastError();

 			}

 		}

 	return KErrNone;

 	}

 TInt CRawWinDiskExtProxyDrive::Caps(TDes8& anInfo)

 //

 //

 //

 	{

 	TLocalDriveCapsV3Buf caps;

 	TInt err = CBaseExtProxyDrive::Caps(caps);

 	if(err == KErrNone)

 		{

 		DISK_GEOMETRY geometry;

 		DWORD dummy;

 		if(!DeviceIoControl(iDeviceHandle, 

 							IOCTL_DISK_GET_DRIVE_GEOMETRY, 

 							NULL, 

 							0, 

 							&geometry, 

 							sizeof(geometry), 

 							&dummy, 

 							(LPOVERLAPPED)NULL))

 			{

 			return KErrNotReady;

 			}

 		caps().iExtraInfo = EFalse;

 		// NB This seems to be incorrect:If the disk is formatted by Windows, then the 

 		// number of sectors reported in the Boot Sector is slightly greater than

 		// the number of sectors calculated here ... resulting in CheckDisk failures.

 		// One solution is to ensure the disk is formatted by the emulator.

 		caps().iSize =	MAKE_TINT64(geometry.Cylinders.HighPart, geometry.Cylinders.LowPart) * 

 									geometry.TracksPerCylinder * 

 									geometry.SectorsPerTrack * 

 									geometry.BytesPerSector;

 		anInfo = caps.Left(Min(caps.Length(),anInfo.MaxLength()));

 		}

 	return(err);

 	}

 TInt CRawWinDiskExtProxyDrive::Format(TFormatInfo& /*anInfo*/)

 //

 //

 //

 	{

 	return(KErrEof);

 	}

 CRawWinDiskProxyDriveFactory::CRawWinDiskProxyDriveFactory()

 //

 //

 //

 	{

 	RDebug::Print(_L("CRawWinDiskProxyDriveFactory::CRawWinDiskProxyDriveFactory"));

 	}

 TInt CRawWinDiskProxyDriveFactory::Install()

 //

 //

 //

 	{

 	_LIT(KLoggerName,"RAWEXT");

 	return(SetName(&KLoggerName));

 	}

 CProxyDrive* CRawWinDiskProxyDriveFactory::NewProxyDriveL(CProxyDrive* aProxy,CMountCB* aMount)

 //

 //

 //

 	{

 	return(CRawWinDiskExtProxyDrive::NewL(aProxy,aMount));

 	}

 extern "C" {

 EXPORT_C CProxyDriveFactory* CreateFileSystem()

 //

 // Create a new file system

 //

 	{

 	return(new CRawWinDiskProxyDriveFactory());

 	}

 }