// 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:

//

#include "elocal.h"

#include <emulator.h>

#include <TCHAR.h>

const TInt KMajorVersionNumber=1;

const TInt KMinorVersionNumber=0;

const TUint KInvalidSetFilePointer = 0xffffffff;	// INVALID_SET_FILE_POINTER

#pragma data_seg(".data2")

#ifdef __VC32__

#pragma bss_seg(".data2")

#endif

static TInt ReadSpeed;

static TInt WriteSpeed;

#pragma data_seg()

#ifdef __VC32__

#pragma bss_seg()

#endif

static void Panic(TPanic aPanic)

	{

	User::Panic(_L("LocalFSys"),aPanic);

	}

//

// Map aDrive to a path given by environment variables

//

TBool MapDrive(TDes& aFileName, TInt aDrive)

	{

	TDriveName root(TDriveUnit(aDrive).Name());

	TFileName path;

	TBuf<3> rootWithSlash(root);

	rootWithSlash.Append('\\');

	if (MapEmulatedFileName(path, rootWithSlash) == KErrNone)

		{

		aFileName=path.Left(3);	// drive letter, colon and backslash

		return(ETrue);

		}

	aFileName=root;  // no trailing backslash

	return(EFalse);

	}

TInt MapFileName(TDes& aFileName, TInt aDrive, const TDesC& aName)

	{

	TFileName n(TDriveUnit(aDrive).Name());

	n.Append(aName);

	return MapEmulatedFileName(aFileName,n);

	}

void MapFileNameL(TDes& aFileName, TInt aDrive, const TDesC& aName)

	{

	User::LeaveIfError(MapFileName(aFileName,aDrive,aName));

	}

/**

Check whether a descriptor has enough space for null-terminating and append a zero terminator if it does.

Supposed to be used for Win32 file operations, taking C-like strings as parameters.

The main purpose is to avoid panics caused by descriptors overflow.

@param  aDes descriptor to be null-terminated; a file(directory) name presumably.

@return cast to LPCTSTR value of the descriptor, supposed to be the unicode string

@leave  KErrBadName if there is no room for trailing zero 

*/

LPCTSTR StrPtrZL(TDes16& aDes)

    {

    if(aDes.MaxLength() - aDes.Length() < 1)

        User::Leave(KErrBadName);  //-- no room for terminating zero

    return (LPCTSTR)aDes.PtrZ();

    }

//

// Converts a TTime structure to a Windows/NT filetime.  Assumes that aTime is a

// UTC (system) time

//

static void timeToFileTimeL(const TTime& aTime,FILETIME* f)

	{

	TDateTime dateTime=aTime.DateTime();

	SYSTEMTIME t;

	#pragma warning( disable : 4244 ) // conversion from 'const int' to 'unsigned short', possible loss of data

	t.wYear=dateTime.Year();

	t.wMonth=dateTime.Month()+1;

	t.wDay=dateTime.Day()+1;

	t.wDayOfWeek=(aTime.DayNoInWeek()+1)%7;

	t.wHour=dateTime.Hour();

	t.wMinute=dateTime.Minute();

	t.wSecond=dateTime.Second();

	t.wMilliseconds=dateTime.MicroSecond()/1000;

	#pragma warning( default : 4244 ) // conversion from 'const int' to 'unsigned short', possible loss of data

	__ASSERT_ALWAYS(SystemTimeToFileTime(&t,f)==TRUE,User::Leave(KErrArgument));

	}

//

//	Convert Windows/NT file time to TTime

//	Assumes the NT file time is UTC

//

static void fileTimeToTime(FILETIME* f,TTime& aTime)

	{

	SYSTEMTIME t;

	__ASSERT_ALWAYS(FileTimeToSystemTime(f,&t)==TRUE,Panic(EFileTimeToSystemTime));

	aTime=TDateTime(t.wYear,TMonth(t.wMonth-1),t.wDay-1,t.wHour,t.wMinute,t.wSecond,t.wMilliseconds*1000);

	}

//

// Return the size and free space on a drive.

//

static TInt GetMediaSize(TInt aDriveNumber,TInt64& aSize,TInt64& aFree)

	{

	TBuf<4> driveName;

	MapDrive(driveName,aDriveNumber);

	DWORD sectorsPerCluster;

	DWORD bytesPerSector;

	DWORD freeClusters;

	DWORD sizeClusters;

	// this function should be upgraded to GetDiskFreeSpaceEx

	BOOL b=Emulator::GetDiskFreeSpace((LPCTSTR)driveName.PtrZ(),&sectorsPerCluster,&bytesPerSector,&freeClusters,&sizeClusters);

	if (!b)

		return Emulator::LastError();

	TInt64 bytesPerCluster=(TInt)(sectorsPerCluster*bytesPerSector);

	aSize=TInt64((TInt)sizeClusters)*bytesPerCluster;

	aFree=TInt64((TInt)freeClusters)*bytesPerCluster;

	return(KErrNone);

	}

//

// Return the volume name and uniqueID.

//

static TInt GetVolumeId(TInt aDriveNumber,TUint& aUniqueID)

	{

	TBuf<4> driveName;

	MapDrive(driveName,aDriveNumber);

	DWORD uniqueID,componentLength,flags;

	BOOL b=Emulator::GetVolumeInformation((LPCTSTR)driveName.PtrZ(),NULL,0,&uniqueID,&componentLength,&flags,NULL,0);

	if (!b)

		return Emulator::LastError();

	aUniqueID=uniqueID;

	return(KErrNone);

	}

//#########################################################################################################################

//##        CLocalMountCB class implementation

//#########################################################################################################################

CLocalMountCB::CLocalMountCB()

	{

	}

CLocalMountCB::~CLocalMountCB()

	{

	}

//

// Returns ETrue if the drive == EDriveZ

//

TBool CLocalMountCB::IsRomDrive() const

	{

	// WINS emulated rom drive is Z:

	return(Drive().DriveNumber()==EDriveZ);

	}

//-------------------------------------------------------------------------------------------------------------------

/**

Mount a volume. 

@param aForceMount Flag to indicate whether mount should be forced to succeed if an error occurs

@leave KErrNoMemory,KErrNotReady,KErrCorrupt,KErrUnknown.

*/

void CLocalMountCB::MountL(TBool /*aForceMount*/)

	{

	TInt64 s,f;

	const TInt driveNum=Drive().DriveNumber();

	User::LeaveIfError(GetMediaSize(driveNum,s,f));

    iSize=s;

    if (driveNum==EDriveZ)

		iSize=4*1048576;

    User::LeaveIfError(GetVolumeId(driveNum,iUniqueID));

	SetVolumeName(HBufC::NewL(0));	// all Win32 volumes are unnamed

    //-- assign default value, 4G-1

    iMaxFileSizeSupported = ((TUint64)4 << 30)-1;

        {

        //-- find out the maximal supported file size. For this we need to query the name of the windows filesystem that is

        //-- used for the emulated drive

        TBuf<20> bufWinDrive;

        MapDrive(bufWinDrive, Drive().DriveNumber());

        ASSERT(bufWinDrive.Length() >= 3);

        TCHAR rootName[10];

        TCHAR volName[30];

        TCHAR volFSFileName[30];

        DWORD volSerNum;

        DWORD volMaxCompLen;

        DWORD volFsFlags;

        memset(rootName, 0, sizeof(rootName));

        wcsncpy(rootName, bufWinDrive.Ptr(), 3); //- something like "k:\\"

        BOOL b = GetVolumeInformation(rootName, volName, sizeof(volName)/sizeof(TCHAR), &volSerNum, &volMaxCompLen, &volFsFlags, volFSFileName, sizeof(volFSFileName)/sizeof(TCHAR));

        if(b)

            {

            if(_wcsicmp(volFSFileName, _TEXT("NTFS")) == 0)

                {//-- this is NTFS

                iMaxFileSizeSupported = 0xFFFFFFF0000; //-- max. file size for NTFS

                }

             else

                {//-- theoretically other than FAT & NTFS filesystem are possible.. Figure yourself.

            }   }

        }

    }

//-------------------------------------------------------------------------------------------------------------------

/**

    Try remount this volume. Checks if the volume parameters remained the same as on original MountL() call, and

    if they are, re-initialises the mount. 

    @return KErrNone if the remount was OK

            system-wide error code otherwise

*/

TInt CLocalMountCB::ReMount()

	{

	TInt d=Drive().DriveNumber();

	TUint uniqueID;

	TInt r=GetVolumeId(d,uniqueID);

	if (r==KErrNone && uniqueID!=iUniqueID)

		r=KErrGeneral;

	return(r);

	}

//-------------------------------------------------------------------------------------------------------------------

void CLocalMountCB::Dismounted()

	{

    }

//-------------------------------------------------------------------------------------------------------------------

//

// Return the volume info.

//

void CLocalMountCB::VolumeL(TVolumeInfo& aVolume) const

	{

	TInt64 s,f;

	TInt driveNum=Drive().DriveNumber();

	User::LeaveIfError(GetMediaSize(driveNum,s,f));

	if (driveNum==EDriveZ)

		aVolume.iFree=0;

	else

		aVolume.iFree=f;

	}

//-------------------------------------------------------------------------------------------------------------------

//

// Set the volume label. Not supported on Win32 volumes

//

void CLocalMountCB::SetVolumeL(TDes&)

	{

	User::Leave(IsRomDrive() ? KErrAccessDenied : KErrNotSupported);

	}

//-------------------------------------------------------------------------------------------------------------------

//

// Return the address of the file if it is in rom

//

void CLocalMountCB::IsFileInRom(const TDesC& aName,TUint8*& aFileStart)

	{

	aFileStart=NULL;

	if (!IsRomDrive())

		return;

	TFileName n;

	if (MapFileName(n,Drive().DriveNumber(),aName)!=KErrNone)

		return;

	DWORD access=GENERIC_READ;

	DWORD share=FILE_SHARE_WRITE|FILE_SHARE_READ;

	DWORD create=OPEN_EXISTING;

	HANDLE h=Emulator::CreateFile((LPCTSTR)n.PtrZ(),access,share,NULL,create,FILE_FLAG_RANDOM_ACCESS,NULL);

	if (h==INVALID_HANDLE_VALUE)

		return;

	CLocalFileCB::RomAddress(aName, h, aFileStart);

	CloseHandle(h);

	}

//-------------------------------------------------------------------------------------------------------------------

/**

    Make a directory.

    @param aName full path to the directory to create. Name validity is checked by file server.

*/

void CLocalMountCB::MkDirL(const TDesC& aName)

	{

	if (IsRomDrive())

		User::Leave(KErrAccessDenied);

	TFileName n;

	MapFileNameL(n,Drive().DriveNumber(),aName);

	BOOL b=Emulator::CreateDirectory(StrPtrZL(n),NULL);

	if (b)

		return;

	TInt r=Emulator::LastError();

	if (r!=KErrAlreadyExists)

		User::Leave(r);

	TEntry e;

	EntryL(aName,e);

	if (e.IsDir())

		User::Leave(KErrAlreadyExists);

	else

		User::Leave(KErrAccessDenied);

	}

//-------------------------------------------------------------------------------------------------------------------

/**

    Remove a directory.

    @param aName directory name

*/

void CLocalMountCB::RmDirL(const TDesC& aName)

	{

	if (IsRomDrive())

		User::Leave(KErrAccessDenied);

    TFileName n;

	MapFileNameL(n,Drive().DriveNumber(),aName);

	BOOL b=Emulator::RemoveDirectory(StrPtrZL(n));

	if (!b)

		User::Leave(Emulator::LastError());

	}

//-------------------------------------------------------------------------------------------------------------------

//

// Delete a file.

//

void CLocalMountCB::DeleteL(const TDesC& aName)

	{

	if (IsRomDrive())

		User::Leave(KErrAccessDenied);

    //-- check entry attributes

    TEntry entry;

    EntryL(aName, entry);

	if (entry.IsDir() ||  entry.IsReadOnly())

	    User::Leave(KErrAccessDenied);

    TFileName n;

	MapFileNameL(n,Drive().DriveNumber(),aName);

	BOOL b=Emulator::DeleteFile(StrPtrZL(n));

	if (!b)

		User::Leave(Emulator::LastError());

	}

//-------------------------------------------------------------------------------------------------------------------

//

// Rename a file or directory.

//

void CLocalMountCB::RenameL(const TDesC& aOldName,const TDesC& aNewName)

	{

	if (IsRomDrive())

		User::Leave(KErrAccessDenied);

	TEntry entry;

	TRAPD(r,EntryL(aNewName,entry));

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

		User::Leave(r);

	TFileName old;

	MapFileNameL(old,Drive().DriveNumber(),aOldName);

	TFileName n;

	MapFileNameL(n,Drive().DriveNumber(),aNewName);

	BOOL b=Emulator::MoveFile(StrPtrZL(old),StrPtrZL(n));

	if (!b)

		User::Leave(Emulator::LastError());

	}

//-------------------------------------------------------------------------------------------------------------------

void CLocalMountCB::ReplaceL(const TDesC& aOldName,const TDesC& aNewName)

//

// Delete aNewName if it exists and rename anOldName.

//

	{

	if (IsRomDrive())

		User::Leave(KErrAccessDenied);

	TEntry entry;

	if(FileNamesIdentical(aOldName,aNewName))

		{

		return;

		}

	TRAPD(r,DeleteL(aNewName));

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

		User::Leave(r);

	TFileName old;

	MapFileNameL(old,Drive().DriveNumber(),aOldName);

	TFileName n;

	MapFileNameL(n,Drive().DriveNumber(),aNewName);

	BOOL b=Emulator::MoveFile(StrPtrZL(old),StrPtrZL(n));

	if (!b)

		User::Leave(Emulator::LastError());

	}

//-------------------------------------------------------------------------------------------------------------------

//

//	Set and get file pointer for windows files

//	

static DWORD SetFilePointerL(HANDLE hFile,LONG lDistanceToMove,DWORD dwMoveMethod)

	{

	DWORD dwRet;

	dwRet=SetFilePointer(hFile,lDistanceToMove,0,dwMoveMethod);

	if (dwRet==KInvalidSetFilePointer)	//	INVALID_HANDLE_VALUE

		User::Leave(Emulator::LastError());

	return (dwRet);	

	}

//-------------------------------------------------------------------------------------------------------------------

//

//	Set and get file pointer for windows files

//	

static DWORD SetFilePointer64L(HANDLE hFile, LARGE_INTEGER * lpDistanceToMove, DWORD dwMoveMethod)

	{

	DWORD dwRet;

	dwRet=SetFilePointer(hFile, lpDistanceToMove->LowPart, &(lpDistanceToMove->HighPart), dwMoveMethod);

    TInt r = Emulator::LastError();

	if ((KInvalidSetFilePointer==dwRet) && (r != NO_ERROR))	

		User::Leave(r);

	return (dwRet);	

	}

//-------------------------------------------------------------------------------------------------------------------

/**

    Read file section without opening this file on a file server side.

    @param  aName       file name; all trailing dots from the name will be removed

    @param  aFilePos    start read position within a file

    @param  aLength     how many bytes to read; on return will be how many bytes actually read

    @param  aDes        local buffer desctriptor

    @param  aMessage    from file server, used to write data to the buffer in different address space.

    @leave on media read error

*/

void CLocalMountCB::ReadSectionL(const TDesC& aName,TInt aPos,TAny* aTrg,TInt aLength,const RMessagePtr2& aMessage)

	{

	TFileName n;

	MapFileNameL(n,Drive().DriveNumber(),aName);

	WIN32_FIND_DATA d;

	HANDLE hFile=Emulator::FindFirstFile(StrPtrZL(n),&d);

	if (hFile==INVALID_HANDLE_VALUE)

		User::Leave(Emulator::LastError());

	FOREVER

		{

		TPtrC fileName((TText*)(&d.cFileName[0]));

		if (fileName!=_L(".") && fileName!=_L(".."))

			break;

		if (!Emulator::FindNextFile(hFile,&d))

			{

			TInt r = Emulator::LastError();

			User::Leave(r == KErrEof ? KErrNotFound : r);

			}

		}

	FindClose(hFile);

	hFile=Emulator::CreateFile(StrPtrZL(n),GENERIC_READ,FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_EXISTING,0,NULL);

	if (hFile==INVALID_HANDLE_VALUE)

		return;

	DWORD dwSizeLow, dwSizeHigh;

	dwSizeLow=GetFileSize(hFile,&dwSizeHigh);

	TInt r = Emulator::LastError();

	if((NO_ERROR != r) && (INVALID_FILE_SIZE == dwSizeLow))

		User::Leave(r);

	// ReadSectionL can support only upto 2G as aPos is TInt!

	const TInt64 fileSize = MAKE_TINT64(dwSizeHigh, dwSizeHigh);

	if(fileSize > KMaxTInt)

		{

		if (!CloseHandle(hFile))

			User::Leave(Emulator::LastError());

		User::Leave(KErrTooBig);