// 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);
		}
	
//	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()
*/
TInt CLocalMountCB::GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput)
    {
	switch(aInterfaceId)
		{
		case EFileExtendedInterface:
			((CMountCB::MFileExtendedInterface*&) aInterface) = this;
			return KErrNone;

    	case ELocalBufferSupport:
    		// CLocalMountCB doesn't ever use any extensions?
	    	// 	- seems to not have any iProxyDrive or LocalDrive() or similar, 
    		// so we'll just return KErrNone here.
   			return KErrNone;

		default:
		    return CMountCB::GetInterface(aInterfaceId,aInterface,aInput);
		}
    }

//-------------------------------------------------------------------------------------------------------------------	
TInt CLocalMountCB::LocalBufferSupport()
	{
	TAny* dummyInterface = NULL;
	TAny* dummyInput = NULL;
	return GetInterface(ELocalBufferSupport,dummyInterface,dummyInput);
	}

//-------------------------------------------------------------------------------------------------------------------	
/**
    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::ReadSection64L(const TDesC& aName, TInt64 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);
	
	// Check on file size 
	const TInt64 fileSize = MAKE_TINT64(dwSizeHigh, dwSizeLow);
	if(MaxFileSizeSupported() < (TUint64)fileSize)
		{
		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 (fileSize>=aPos+aLength)	//	Can read entire length requested from aPos	
		SetFilePointer64L(hFile,(LARGE_INTEGER *)&aPos,FILE_BEGIN);
	
	else if (fileSize>aPos)		//	Can read from aPos but not entire length requested
		{
		SetFilePointer64L(hFile,(LARGE_INTEGER *)&aPos,FILE_BEGIN);
		aLength=(TInt)(fileSize-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());
	}

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

/**
    CLocalMountCB control method.
    @param  aLevel  specifies the operation to perfrom on the mount
    @param  aOption specific option for the given operation
    @param  aParam  pointer to generic parameter, its meaning depends on aLevel and aOption

    @return standard error code.
*/

TInt CLocalMountCB::MountControl(TInt aLevel, TInt aOption, TAny* aParam)
    {
    //-- File System - specific queries 
    if(aLevel == EMountFsParamQuery && aOption == ESQ_GetMaxSupportedFileSize)
        {//-- this is a query to provide the max. supported file size; aParam is a pointer to TUint64 to return the value
        *(TUint64*)aParam = MaxFileSizeSupported();    
        return KErrNone;
        }

    return KErrNotSupported; 
    }

//#########################################################################################################################
//##        CLocalFileCB class implementation
//#########################################################################################################################


CLocalFileCB::CLocalFileCB()
	{
	}

CLocalFileCB::~CLocalFileCB()
	{

	if (iAtt&KEntryAttModified)
		{
		TRAPD(ret,FlushDataL());
//		if (ret!=KErrNone) // Can fail if floppy disk is removed
//			Panic(EFileClose); // Ignore error
		}
	if (iWinHandle!=NULL && !CloseHandle(iWinHandle))
		Panic(EFileClose);
	}

//-------------------------------------------------------------------------------------------------------------------	
//
// Returns ETrue if the drive number == EDriveZ
//
TBool CLocalFileCB::IsRomDrive() const
	{

	// WINS emulated rom drive is Z:
	return(((CLocalFileCB*)this)->Mount().Drive().DriveNumber()==EDriveZ);
	}

//-------------------------------------------------------------------------------------------------------------------	
//
//	Check that the file pointer iCurrentPos is positioned correctly
//	in relation to the Win32 file pointer
//
void CLocalFileCB::CheckPosL(TInt64 aPos)
	{
//	Get the current Win32 file pointer position	
	LARGE_INTEGER pos;
	pos.QuadPart = 0;
	DWORD position=SetFilePointer(iWinHandle,pos.LowPart,&pos.HighPart,FILE_CURRENT);
	TInt r = Emulator::LastError();
	if ((KInvalidSetFilePointer == position) && (r != NO_ERROR))
		User::Leave(r);
//	Set iCurrentPos and Win32 file pointers to aPos if they are different to each
//	other or different to aPos
	if ((pos.QuadPart!=iCurrentPos) || (iCurrentPos!=aPos))
		{
		iCurrentPos=(-1);
		pos.QuadPart = aPos;
		position = SetFilePointer(iWinHandle,pos.LowPart,&pos.HighPart,FILE_BEGIN);
		r = Emulator::LastError();
		if ((KInvalidSetFilePointer == position) && (r != NO_ERROR))
			User::Leave(r);
		iCurrentPos=aPos;
		}
	}

//-------------------------------------------------------------------------------------------------------------------	
void CLocalFileCB::ReadL(TInt aPos,TInt& aLength,const TAny* aDes,const RMessagePtr2& aMessage)
	{
	ReadL((TInt64)aPos, aLength, (TDes8*)aDes, aMessage, 0);
	}

//-------------------------------------------------------------------------------------------------------------------	
void CLocalFileCB::WriteL(TInt aPos,TInt& aLength,const TAny* aDes,const RMessagePtr2& aMessage)
	{
	WriteL((TInt64)aPos, aLength, (TDesC8*)aDes, aMessage, 0);
	}

struct SRomMap
	{
	HBufC* iName;
	TUint8* iAddr;
	};
//-------------------------------------------------------------------------------------------------------------------	

TInt CLocalFileCB::RomAddress(const TDesC& aName, HANDLE aFile, TUint8*& aAddr)
	{
	static CArrayFixSeg<SRomMap>* gRomMap = new CArrayFixSeg<SRomMap>(64);
	for (TInt ii=0; ii<gRomMap->Count(); ii++)
		{
		if (*gRomMap->At(ii).iName == aName)
			{
			aAddr = gRomMap->At(ii).iAddr;
			return KErrNone;
			}
		}

	HANDLE fileMapping=CreateFileMappingA(aFile,NULL,PAGE_READONLY,0,0,NULL);
	if (fileMapping==0)
		return Emulator::LastError();
	aAddr=(TUint8*)MapViewOfFile(fileMapping,FILE_MAP_READ,0,0,0);
	SRomMap entry;
	entry.iAddr = aAddr;
	entry.iName = aName.Alloc();
	if (entry.iName)
		{
		TRAPD(ignore, gRomMap->AppendL(entry));
		}
	return KErrNone;
	}

//-------------------------------------------------------------------------------------------------------------------	
//
// If ROM file, do a memory map and return the address
//
TInt CLocalFileCB::Address(TInt& aPos) const
	{

	TBool isRomFile=IsRomDrive();
	if (!isRomFile)
		return(KErrNotSupported);
	
	if (aPos>Size64())
		return(KErrEof);
	if (iFilePtr==NULL)
		{
		CLocalFileCB* This=(CLocalFileCB*)this;
		TInt err = RomAddress(*iFileName, iWinHandle, This->iFilePtr);
		if (err)
			return err;
		}
	aPos=(TInt)((TUint8*)iFilePtr+aPos);
	return(KErrNone);
	}

//-------------------------------------------------------------------------------------------------------------------	
//
// Set the file size.
//
void CLocalFileCB::SetSizeL(TInt aSize)
	{
	SetSizeL(aSize);
	}

//-------------------------------------------------------------------------------------------------------------------	
//
// Set the entry's attributes and modified time.
//
void CLocalFileCB::SetEntryL(const TTime& aTime,TUint aSetAttMask,TUint aClearAttMask)
	{

	if (IsRomDrive())
		User::Leave(KErrAccessDenied);
	TUint setAttMask=aSetAttMask&KEntryAttMaskSupported;
	if (setAttMask|aClearAttMask)
		{
		iAtt|=setAttMask;
		iAtt&=(~aClearAttMask);
		iAtt|=KEntryAttModified;
		}
	if (aSetAttMask&KEntryAttModified)
		iModified=aTime;
	iAtt|=KEntryAttModified;
	}

//-------------------------------------------------------------------------------------------------------------------	
//
// Commit any buffered date to the media.
//
void CLocalFileCB::FlushAllL()
	{
	FlushDataL();
	}

//-------------------------------------------------------------------------------------------------------------------	
//
// Commit any buffered date to the media.
//
void CLocalFileCB::FlushDataL()
	{

	if (IsRomDrive())
		return;

	TFileName n;
	TInt driveNumber=Mount().Drive().DriveNumber();
	MapFileNameL(n,driveNumber,FileName());
	
    if(!Emulator::SetFileAttributes(StrPtrZL(n),iAtt&KEntryAttMaskSupported))
		User::Leave(Emulator::LastError()); //	Panic(EFileCloseSetAttributes);
	FILETIME f;
	timeToFileTimeL(iModified,&f);
	if (!SetFileTime(iWinHandle,&f,&f,&f))
		User::Leave(Emulator::LastError());

	iAtt&=(~KEntryAttModified);
	}

//-------------------------------------------------------------------------------------------------------------------	
//
// Rename the file while open
//
void CLocalFileCB::RenameL(const TDesC& aNewName)
	{

	TInt driveNumber=Mount().Drive().DriveNumber();

	TFileName n1;
	MapFileNameL(n1,driveNumber,FileName());
	TFileName n2;
	MapFileNameL(n2,driveNumber,aNewName);

	CloseHandle(iWinHandle);
	TInt ret=KErrNone;
	if (!Emulator::MoveFile(StrPtrZL(n1),StrPtrZL(n2)))
		{
		ret=Emulator::LastError();
		n2=n1;
		}
	DWORD access=GENERIC_READ|GENERIC_WRITE;
	DWORD share=FILE_SHARE_WRITE|FILE_SHARE_READ;
	DWORD create=OPEN_EXISTING;
	iWinHandle=Emulator::CreateFile(StrPtrZL(n2),access,share,NULL,create,FILE_FLAG_RANDOM_ACCESS,NULL);
	if (iWinHandle==INVALID_HANDLE_VALUE)
		User::Leave(Emulator::LastError());
	
	LARGE_INTEGER pos;
	pos.QuadPart = iCurrentPos;
	DWORD position = SetFilePointer(iWinHandle,pos.LowPart,&pos.HighPart,FILE_BEGIN);
	TInt r = Emulator::LastError();
	if ((KInvalidSetFilePointer == position) && (r != NO_ERROR))
		User::Leave(r);	
	
	User::LeaveIfError(ret);
	AllocBufferL(iFileName,aNewName);
	}

//-------------------------------------------------------------------------------------------------------------------	
TInt CLocalFileCB::GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput)
	{
	switch(aInterfaceId)
		{
		case EExtendedFileInterface:
			((CFileCB::MExtendedFileInterface*&) aInterface) = this;
			return KErrNone;

		default:
			return CFileCB::GetInterface(aInterfaceId,aInterface,aInput);
		}
	}

//-------------------------------------------------------------------------------------------------------------------	
/**
    Read data from the file.
    
    @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.
    @param  aDesOffset  offset within data descriptor where the data will be copied

    @leave on media read error

*/
void CLocalFileCB::ReadL(TInt64 aPos,TInt& aLength,TDes8* aDes,const RMessagePtr2& aMessage, TInt aOffset)
	{

	const TUint64 KMaxFilePosition = LocalMount().MaxFileSizeSupported()-1;
    

    if(KMaxFilePosition < (TUint64)aPos)
		User::Leave(KErrNotSupported);
	
	CheckPosL(aPos);
	TInt pos=0;
	TInt len=aLength;
	TBuf8<65536> buf;

	if (aMessage.Handle() == KLocalMessageHandle)
		((TPtr8* )aDes)->SetLength(0);

	while (len)
		{
		TInt s=Min(len,buf.MaxLength());
		DWORD res;
		BOOL b=ReadFile(iWinHandle,(TAny*)buf.Ptr(),s,&res,NULL);
		if(!b)
			User::Leave(Emulator::LastError());

		buf.SetLength(res);

	if (aMessage.Handle() == KLocalMessageHandle)
		((TPtr8* )aDes)->Append(buf);
	else
		aMessage.WriteL(0,buf,pos + aOffset);
	
		pos+=res;
		if (((TInt)res)<s)
			break;
		len-=s;
		}
	TInt delay = (ReadSpeed * aLength) >> 10;
	if (delay)
		User::AfterHighRes(delay);
	aLength=pos;
	iCurrentPos=aPos+pos;
	}

//-------------------------------------------------------------------------------------------------------------------	
/**
    Write data to the file.
    
    @param  aFilePos    start write position within a file
    @param  aLength     how many bytes to write; on return contain amount of data actually written
    @param  aDes        local buffer desctriptor
    @param  aMessage    from file server, used to write data to the media from different address space.
    @param  aDesOffset  offset within data descriptor 

    @leave on media read error

*/
void CLocalFileCB::WriteL(TInt64 aPos,TInt& aLength,const TDesC8* aDes,const RMessagePtr2& aMessage, TInt aOffset)
	{
	if (IsRomDrive())
		User::Leave(KErrAccessDenied);
	
	
    const TUint64 KMaxFileSize = LocalMount().MaxFileSizeSupported();
    const TUint64 KMaxFilePosition = KMaxFileSize - 1;

	if( KMaxFilePosition < (TUint64)aPos || KMaxFileSize < (TUint64)(aPos + aLength) )
		User::Leave(KErrNotSupported);
	
	CheckPosL(aPos);
	TInt pos=0;
	TInt len=aLength;
	TBuf8<65536> buf;

	while (len)
		{
		TInt s=Min(len,buf.MaxLength());

		if (aMessage.Handle() == KLocalMessageHandle)
			buf.Copy( ((TPtr8* )aDes)->MidTPtr(pos, s) );
		else
			aMessage.ReadL(0,buf,pos + aOffset);

		DWORD res;
		BOOL b=WriteFile(iWinHandle,buf.Ptr(),s,&res,NULL);
		
        if (!b)
			User::Leave(Emulator::LastError());

		if (((TInt)res)<s)
			User::Leave(KErrCorrupt);
		
        len-=s;
		pos+=s;
		}
	TInt delay = (WriteSpeed * aLength) >> 10;
	if (delay)
		User::AfterHighRes(delay);
	aLength=pos;
	iCurrentPos=aPos+pos;
	}

//-------------------------------------------------------------------------------------------------------------------	
/**
    Set file size.
    @param aSize new file size.
*/
void CLocalFileCB::SetSizeL(TInt64 aSize)
	{
    const TUint64 KMaxFileSize = LocalMount().MaxFileSizeSupported();

	if(KMaxFileSize < (TUint64)aSize)
		User::Leave(KErrNotSupported);
	
	CheckPosL(aSize);
	if(!SetEndOfFile(iWinHandle))
		{
		iCurrentPos= -1;
		User::Leave(Emulator::LastError());
		}

	SetSize64(aSize, EFalse);
	}

//#########################################################################################################################
//##        CLocalDirCB class implementation
//#########################################################################################################################

CLocalDirCB::CLocalDirCB()
	        :iEntry()
	{
	}

CLocalDirCB::~CLocalDirCB()
	{

	if (iWinHandle!=NULL && !FindClose(iWinHandle))
		Panic(EDirClose);
	}

//-------------------------------------------------------------------------------------------------------------------	
TBool CLocalDirCB::MatchUid()
	{

	if (iUidType[0]!=TUid::Null() || iUidType[1]!=TUid::Null() || iUidType[2]!=TUid::Null())
		return(ETrue);
	
    return(EFalse);
	}

//-------------------------------------------------------------------------------------------------------------------	
/** @return  ETrue if the aUidTrg matches aUidSuitor */
static TBool CompareUid(const TUidType& aUidTrg, const TUidType& aUidSuitor)
	{
	
	if (aUidTrg[0]!=TUid::Null() && aUidTrg[0]!=aUidSuitor[0])
		return(EFalse);
	if (aUidTrg[1]!=TUid::Null() && aUidTrg[1]!=aUidSuitor[1])
		return(EFalse);
	if (aUidTrg[2]!=TUid::Null() && aUidTrg[2]!=aUidSuitor[2])
		return(EFalse);
	return(ETrue);
	}

//-------------------------------------------------------------------------------------------------------------------	
/**
    Read current entry from the directory and move to the next one.
    This function must leave KErrEof when the end of directory is reached

    @param anEntry extracted directory entry
    @leave KErrEof when there are no more entries in the directory
           system-wide error code on media read fault.

*/
void CLocalDirCB::ReadL(TEntry& anEntry)
	{

	if (iWinHandle==NULL)
		User::Leave(KErrEof);

	FOREVER
		{
		if (!iPending)
			{
			WIN32_FIND_DATA info;
			if (!Emulator::FindNextFile(iWinHandle,&info))
				User::Leave(Emulator::LastError());

			iEntry.iName.Des()=(TText*)(&info.cFileName[0]);
			iEntry.iAtt=info.dwFileAttributes&KEntryAttMaskSupported;
			iEntry.SetFileSize(MAKE_TINT64(info.nFileSizeHigh,info.nFileSizeLow));
			fileTimeToTime(&info.ftLastWriteTime,iEntry.iModified);
			}
		iPending=EFalse;
		anEntry=iEntry;
		if (anEntry.iName==_L(".") || anEntry.iName==_L(".."))
			continue;
		if ((iFullName.NameAndExt()==_L("*.*") || iFullName.NameAndExt()==_L("*") || anEntry.iName.MatchF(iFullName.NameAndExt())!=KErrNotFound) && Mount().MatchEntryAtt(anEntry.iAtt&KEntryAttMaskSupported,iAtt))
			{
			if (MatchUid())
				{
				TParse fileName;
				TBuf<KMaxFileName> driveAndPath=iFullName.DriveAndPath();
				fileName.Set(anEntry.iName,&driveAndPath,NULL);
				(*(CLocalMountCB*)&Mount()).ReadUidL(fileName.FullName(),anEntry);
				if (CompareUid(iUidType,anEntry.iType))
					break;
				}
			else
				break;
			}
		}
	if ((iAtt&KEntryAttAllowUid)==0 || anEntry.iAtt&KEntryAttDir || MatchUid())
		return;
	TParse fileName;
	TBuf<KMaxFileName> driveAndPath=iFullName.DriveAndPath();
	fileName.Set(anEntry.iName,&driveAndPath,NULL);
	(*(CLocalMountCB*)&Mount()).ReadUidL(fileName.FullName(),anEntry);
	}

//#########################################################################################################################
//##        CLocalFormatCB class implementation
//#########################################################################################################################

CLocalFormatCB::CLocalFormatCB()
	{
	}

CLocalFormatCB::~CLocalFormatCB()
	{
	}

void CLocalFormatCB::DoFormatStepL()
	{
	iCurrentStep=0;
	User::Leave(KErrNotSupported);
	}


//#########################################################################################################################
//##        CLocal File System class implementation
//#########################################################################################################################

extern "C" 
{
//
// Create a new file system
//
EXPORT_C CFileSystem* CreateFileSystem()
	{
	return(new CLocal);
	}
}

CLocal::CLocal()
	{
	}

TInt CLocal::Install()
	{

	SetErrorMode(SEM_FAILCRITICALERRORS);
	EmulatorDiskSpeed(ReadSpeed, WriteSpeed);
	iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KF32BuildVersionNumber);
	_LIT(KWin32Name,"Win32");
	return(SetName(&KWin32Name));
	}

CMountCB* CLocal::NewMountL() const
//
// Create a new mount control block.
//
	{

	return(new(ELeave) CLocalMountCB);
	}

CFileCB* CLocal::NewFileL() const
//
// Create a new file.
//
	{

	return(new(ELeave) CLocalFileCB);
	}

CDirCB* CLocal::NewDirL() const
//
// Create a new directory lister.
//
	{
	return(new(ELeave) CLocalDirCB);
	}

CFormatCB* CLocal::NewFormatL() const
//
// Create a new media formatter.
//
	{
	return(new(ELeave) CLocalFormatCB);
	}

TInt CLocal::DefaultPath(TDes& aPath) const
//
// Return the initial default path.
//
	{
	aPath=_L("?:\\");
	aPath[0] = (TUint8) RFs::GetSystemDriveChar();
	return(KErrNone);
	}

void CLocal::DriveInfo(TDriveInfo& anInfo,TInt aDriveNumber) const
//
// Return the drive info.
//
	{

	anInfo.iMediaAtt=0;

// Get Fake drive info.
	if (aDriveNumber==EDriveZ)
		{
		anInfo.iType=EMediaRom;
		anInfo.iMediaAtt=KMediaAttWriteProtected;
		anInfo.iDriveAtt=KDriveAttRom|KDriveAttInternal;
		anInfo.iConnectionBusType=EConnectionBusInternal;
		return;
		}
	if (aDriveNumber==EDriveC)
		{
		anInfo.iType=EMediaHardDisk;
		anInfo.iMediaAtt=KMediaAttVariableSize;
		anInfo.iDriveAtt=KDriveAttLocal|KDriveAttInternal;
		anInfo.iConnectionBusType=EConnectionBusInternal;
		return;
		}
	TFileName envValue;
	if (MapDrive(envValue,aDriveNumber))
		{
		anInfo.iType=EMediaHardDisk;
		anInfo.iDriveAtt=KDriveAttLocal|KDriveAttInternal;
		anInfo.iConnectionBusType=EConnectionBusInternal;
		return;		
		}
	anInfo.iType=EMediaNotPresent;
	anInfo.iDriveAtt=0;
	}















