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

		//SL: added the cast

        wcsncpy(rootName, (const wchar_t*)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);

		}

//	Check that reading from aPos for aLength lies within the file

//	if aPos is within the file, and aLength is too long, read up to EOF

//	If aPos is beyond the file, return a zero length descriptor

	if ((TInt)dwSizeLow>=(aPos+aLength))	//	Can read entire length requested from aPos	

		SetFilePointerL(hFile,aPos,FILE_BEGIN);			

	else if ((TInt)dwSizeLow>aPos)		//	Can read from aPos but not entire length requested

		{

		SetFilePointerL(hFile,aPos,FILE_BEGIN);

		aLength=dwSizeLow-aPos;

		}	

	else						//	Cannot read from aPos because it lies outside file

		{						//	Close file and leave with KErrEof

		if (!CloseHandle(hFile))

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

		User::Leave(KErrEof);

		}

	TBuf8<0x1000> buf;

	TInt pos=0;

	if (aMessage.Handle() == KLocalMessageHandle)

		((TPtr8* )aTrg)->SetLength(0);

	while (aLength)

		{

		TInt readTotal=Min(aLength,buf.MaxLength());

		DWORD ret;

		BOOL b=ReadFile(hFile,(TAny*)buf.Ptr(),readTotal,&ret,NULL);

		if (!b || ((TInt)ret!=readTotal))	

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

		buf.SetLength(ret);

		if(aMessage.Handle() == KLocalMessageHandle)

			((TPtr8* )aTrg)->Append(buf);

		else

			aMessage.WriteL(0,buf,pos);

		pos+=ret;

		if (((TInt)ret)<readTotal)

			break;

		aLength-=readTotal;

		}

	if (!CloseHandle(hFile))

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

	}

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

//

// Read the entry uid if present

//

void CLocalMountCB::ReadUidL(const TDesC& aName,TEntry& anEntry) const

	{

//  First check to see if the first sixteen bytes form a valid UID

	TBuf<KMaxFileName + 1> fileName=aName;

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

	if (hFile==INVALID_HANDLE_VALUE)

		return;

	DWORD ret;

	TBuf8<sizeof(TCheckedUid)> checkedUidBuf;

	checkedUidBuf.SetLength(sizeof(TCheckedUid));

	ReadFile(hFile,&checkedUidBuf[0],sizeof(TCheckedUid),&ret,NULL);

	if (ret!=sizeof(TCheckedUid))

		goto close;

	{

	TCheckedUid checkedUid(checkedUidBuf);

	if(checkedUid.UidType()!=TUidType(TUid::Null(),TUid::Null(),TUid::Null()))

		{

		anEntry.iType=checkedUid.UidType();

		goto close;

		}

	}

//Look at PE file for UID section

		{

		const TInt KPeHeaderAddrAddr=0x3c;

		const TInt KPeHeaderAddrSize=0x01;

		const TInt KNumberOfSectionsOffset=0x06;

		const TInt KNumberOfSectionsSize=0x02;

		const TInt KSectionTableOffset=0xf8;

		const TInt KSectionHeaderSize=0x28;

		const TInt KSectionNameLength=0x08;

		const TInt KPtrToRawDataOffset=0x14;

		const TInt KPtrToRawDataSize=0x04;

		const TText8 peText[4]={'P','E',0,0};

		const TText8 uidText[8]={'.','S','Y','M','B','I','A','N'};

	//Read address of start of PE header

		if (SetFilePointer(hFile,KPeHeaderAddrAddr,0,FILE_BEGIN)==KInvalidSetFilePointer)

			goto close;

		TInt peAddr=0;

		ReadFile(hFile,&peAddr,KPeHeaderAddrSize,&ret,NULL);

		if (ret!=KPeHeaderAddrSize)

			goto close;

	//Check it really is the start of PE header

		if (SetFilePointer(hFile,peAddr,0,FILE_BEGIN)==KInvalidSetFilePointer)

			goto close;

		TText8 text[4];

		ReadFile(hFile,text,4,&ret,NULL);

		if (*(TInt32*)text!=*(TInt32*)peText)

			goto close;

	//Read number of sections

		if (SetFilePointer(hFile,peAddr+KNumberOfSectionsOffset,0,FILE_BEGIN)==KInvalidSetFilePointer)

			goto close;

		TInt sections=0;

		ReadFile(hFile,&sections,KNumberOfSectionsSize,&ret,NULL);

		if (ret!=KNumberOfSectionsSize)

			goto close;

	//Go through section headers looking for UID section

		if (SetFilePointer(hFile,peAddr+KSectionTableOffset,0,FILE_BEGIN)==KInvalidSetFilePointer)

			goto close;

		TInt i=0;

		for(;i<sections;i++)

			{

			TText8 name[KSectionNameLength];

			ReadFile(hFile,name,KSectionNameLength,&ret,NULL);

			if (ret!=KSectionNameLength)

				goto close;

			if (*(TInt64*)name==*(TInt64*)uidText)

				break;

			if (SetFilePointer(hFile,KSectionHeaderSize-KSectionNameLength,0,FILE_CURRENT)==KInvalidSetFilePointer)

				goto close;

			}

		if (i==sections)

			goto close;

	//Read RVA/Offset

		if (SetFilePointer(hFile,KPtrToRawDataOffset-KSectionNameLength,0,FILE_CURRENT)==KInvalidSetFilePointer)

			goto close;

		TInt uidOffset;

		ReadFile(hFile,&uidOffset,KPtrToRawDataSize,&ret,NULL);

		if (ret!=KPtrToRawDataSize)

			goto close;

	//Read UIDs!

		if (SetFilePointer(hFile,uidOffset,0,FILE_BEGIN)==KInvalidSetFilePointer)

			User::Leave(KErrGeneral);

		TEmulatorImageHeader header;

		ReadFile(hFile,&header,sizeof(header),&ret,NULL);

		if (ret==sizeof(header))

			anEntry.iType=*(TUidType*)&header;

		}

//Close file

close:

	if (!CloseHandle(hFile))

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

	}

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

/**

    Try to find a directory entry by the given name and path. 

    This method _must_ leave if the entry is not found. See the caller.

    @param  aName   path to the directory object. all trailing dots from the name will be removed.

    @param  anEntry on return will contain the entry data

    @leave  KErrPathNotFound if there is no path to the aName

            KErrNotFound     if the entry corresponding to the aName is not found

            system-wide erorr code of media read failure.

*/

void CLocalMountCB::EntryL(const TDesC& aName,TEntry& anEntry) const

	{

	TFileName n;

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

	WIN32_FIND_DATA d;

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

	if (h==INVALID_HANDLE_VALUE)

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

	FOREVER

		{

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

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

			break;

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

			{

			TInt r = Emulator::LastError();

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

			}

		}

	FindClose(h);

	anEntry.iName.Des()=(TText*)(&d.cFileName[0]);

	anEntry.iAtt=d.dwFileAttributes&KEntryAttMaskSupported;

	if (IsRomDrive())

		anEntry.iAtt|=KEntryAttReadOnly;

	anEntry.SetFileSize(MAKE_TINT64(d.nFileSizeHigh,d.nFileSizeLow));

	fileTimeToTime(&d.ftLastWriteTime,anEntry.iModified);

	ReadUidL(n,anEntry);

	}

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

/**

    Set directory entry details.

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

    @param  aTime           entry modification time (and last access as well)

    @param  aSetAttMask     entry attributes OR mask

    @param  aClearAttMask   entry attributes AND mask

*/

void CLocalMountCB::SetEntryL(const TDesC& aName,const TTime& aTime,TUint aSetAttMask,TUint aClearAttMask)

	{

	if (IsRomDrive())

		User::Leave(KErrAccessDenied);

	TFileName n;

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

	TUint setAttMask=aSetAttMask&KEntryAttMaskSupported;

	DWORD att=Emulator::GetFileAttributes(StrPtrZL(n));

	if (att==0xffffffffu)

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

    if (setAttMask|aClearAttMask)

		{

		att|=setAttMask;

		att&=(~aClearAttMask);

		if (!Emulator::SetFileAttributes((LPCTSTR)n.Ptr(),att))

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

		}

    if (aSetAttMask&KEntryAttModified)

		{

		FILETIME f;

		timeToFileTimeL(aTime,&f);

		if (att&KEntryAttReadOnly)

			{

			DWORD writeableAtt=att&(~KEntryAttReadOnly);

			if (!Emulator::SetFileAttributes((LPCTSTR)n.Ptr(),writeableAtt))

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

			}

		HANDLE h;

		if (att&KEntryAttDir)

			{

			h=Emulator::CreateFile((LPCTSTR)n.Ptr(),GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_DIRECTORY|FILE_FLAG_BACKUP_SEMANTICS, NULL);

			if (h==INVALID_HANDLE_VALUE)

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

			}

		else

			{

			h=Emulator::CreateFile((LPCTSTR)n.Ptr(),GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,0,NULL);

			if (h==INVALID_HANDLE_VALUE)

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

			}

		if (!SetFileTime(h,NULL,&f,&f))

			{

			TInt error = Emulator::LastError(); 

			CloseHandle(h);

			User::Leave(error);

			}

        if (!CloseHandle(h))

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

        if ((att&KEntryAttReadOnly) && !Emulator::SetFileAttributes((LPCTSTR)n.Ptr(),att))

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

		}

	}

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

/**

    Open/Create/Replace a file on the current mount.

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

    @param  aMode   File open mode, See TFileMode

    @param  anOpen  specifies action: open, create or replace the file

    @param  aFile   pointer to the CFileCB object to populate

*/

void CLocalMountCB::FileOpenL(const TDesC& aName,TUint aMode,TFileOpen anOpen,CFileCB* aFile)

	{

	if (IsRomDrive() && (anOpen!=EFileOpen || (aMode&EFileWrite)))

		User::Leave(KErrAccessDenied);

	TFileName n;

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

	DWORD access=GENERIC_READ|GENERIC_WRITE;

	DWORD share=FILE_SHARE_WRITE|FILE_SHARE_READ;

	DWORD create=0;

	switch (anOpen)

		{

	    case EFileOpen: create=OPEN_EXISTING; break;

	    case EFileCreate: create=CREATE_NEW; break;

	    case EFileReplace: create=CREATE_ALWAYS; break;

		}

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

	if((h==INVALID_HANDLE_VALUE) && !(aMode&EFileWrite))

	{

	// If windows will not allow write access and it was not requested then open for read only

	access=GENERIC_READ;

	h=Emulator::CreateFile(StrPtrZL(n),access,share,NULL,create,FILE_FLAG_RANDOM_ACCESS,NULL);

	}

	if (h==INVALID_HANDLE_VALUE)

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

	CLocalFileCB& file=(*((CLocalFileCB*)aFile));

	file.SetHandle(h);

    BY_HANDLE_FILE_INFORMATION info;

	if (!GetFileInformationByHandle(h,&info))

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

    const TUint64 fileSize = MAKE_TUINT64(info.nFileSizeHigh, info.nFileSizeLow);

    // Check on file size

	if(MaxFileSizeSupported() < fileSize)

		User::Leave(KErrTooBig);

    file.SetMaxSupportedSize(MaxFileSizeSupported());

    file.SetSize64(fileSize, EFalse);

	file.SetAtt(info.dwFileAttributes&KEntryAttMaskSupported);

//	if (IsRomDrive())

//		file.iAtt|=KEntryAttReadOnly;

	TTime tempTime=file.Modified();

	fileTimeToTime(&info.ftLastWriteTime,tempTime);

	file.SetModified(tempTime);

	}

void AppendAsteriskL(TDes& aDes)

	{

	if (aDes.Length()==aDes.MaxLength())

		User::Leave(KErrBadName);

	aDes.Append('*');

	}

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

/**

    Open a directory on the current mount.

    @param  aName   path to the object in the directory we want to open; all trailing dots from the name will be removed

    @param  aDir    dir. CB to be filled in.

    If there is no such a path, this method must leave with KErrPathNotFound

    @leave  KErrPathNotFound if thereis no such path

    @leave  error code on media read fault

*/

void CLocalMountCB::DirOpenL(const TDesC& aName,CDirCB* aDir)

	{

	TFileName n;

	TParse parse;

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

	parse.Set(n,NULL,NULL);

	n=parse.DriveAndPath();

	AppendAsteriskL(n);

	WIN32_FIND_DATA info;

	HANDLE h=Emulator::FindFirstFile(StrPtrZL(n),&info);

	if (h==INVALID_HANDLE_VALUE)

		{

		TInt error=Emulator::LastError();

		TParse parser;

		TInt r=parser.Set(n,NULL,NULL);

		if (r!=KErrNone)

			User::Leave(r);

		if (!parser.IsRoot() || Drive().DriveNumber()!=0 || error!=KErrNotFound)

			User::Leave(error);

		h=NULL;

		}

	CLocalDirCB& dir=(*((CLocalDirCB*)aDir));

	dir.SetHandle(h);

	dir.SetPending(ETrue);

	dir.iEntry.iName.Des()=(TText*)(&info.cFileName[0]);

	dir.iEntry.iAtt=info.dwFileAttributes&KEntryAttMaskSupported;

	const TInt64 fileSize = MAKE_TINT64(info.nFileSizeHigh,info.nFileSizeLow);

	dir.iEntry.SetFileSize(fileSize);

	n=parse.FullName();

	if (parse.NameAndExt().Length()==0)

		AppendAsteriskL(n);

	dir.SetFullName(n);

	fileTimeToTime(&info.ftLastWriteTime,dir.iEntry.iModified);

	}

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

//

// Read directly from disk

//

void CLocalMountCB::RawReadL(TInt64 /*aPos*/,TInt /*aLength*/,const TAny* /*aDes*/,TInt /*anOffset*/,const RMessagePtr2& /*aMessage*/) const

	{

	User::Leave(KErrNotSupported);

	}

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

//

// Write directly to disk

//

void CLocalMountCB::RawWriteL(TInt64 /*aPos*/,TInt /*aLength*/,const TAny* /*aDes*/ ,TInt /*anOffset*/,const RMessagePtr2& /*aMessage*/)

	{

	User::Leave(KErrNotSupported);

	}

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

//

// Get the short name associated with aLongName

//

void CLocalMountCB::GetShortNameL(const TDesC& aLongName,TDes& aShortName)

	{

	if (IsRomDrive())

		User::Leave(KErrNotSupported);

	TFileName n;

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

	WIN32_FIND_DATA d;

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

	if (h==INVALID_HANDLE_VALUE)

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

	FindClose(h);

    if (d.cAlternateFileName[0])	// we have a dos name too

        aShortName=(TText*)(&d.cAlternateFileName[0]);

	else

		aShortName=(TText*)(&d.cFileName[0]);

	}

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

//

// Get the short name associated with aLongName

//

void CLocalMountCB::GetLongNameL(const TDesC& aShortName,TDes& aLongName)

	{

	if (IsRomDrive())

		User::Leave(KErrNotSupported);

	TFileName n;

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

	WIN32_FIND_DATA d;

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

	if (h==INVALID_HANDLE_VALUE)

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

	FindClose(h);

	aLongName=(TText*)(&d.cFileName[0]);

	}

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

/**

Reports whether the specified interface is supported - if it is,

the supplied interface object is modified to it

@param aInterfaceId     The interface of interest

@param aInterface       The interface object

@return                 KErrNone if the interface is supported, otherwise KErrNotFound 

@see CMountCB::GetInterface()

*/