diff -r 000000000000 -r 96e5fb8b040d userlibandfileserver/fileserver/swins/elocal.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/userlibandfileserver/fileserver/swins/elocal.cpp	Thu Dec 17 09:24:54 2009 +0200
@@ -0,0 +1,1761 @@
+// 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);
+	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<0x1000> 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<0x1000> 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. iBatteryState already set.
+//
+	{
+
+	anInfo.iMediaAtt=0;
+
+// Get Fake drive info.
+	if (aDriveNumber==EDriveZ)
+		{
+		anInfo.iType=EMediaRom;
+		anInfo.iMediaAtt=KMediaAttWriteProtected;
+		anInfo.iDriveAtt=KDriveAttRom|KDriveAttInternal;
+		return;
+		}
+	if (aDriveNumber==EDriveC)
+		{
+		anInfo.iType=EMediaHardDisk;
+		anInfo.iMediaAtt=KMediaAttVariableSize;
+		anInfo.iDriveAtt=KDriveAttLocal|KDriveAttInternal;
+		return;
+		}
+	TFileName envValue;
+	if (MapDrive(envValue,aDriveNumber))
+		{
+		anInfo.iType=EMediaHardDisk;
+		anInfo.iDriveAtt=KDriveAttLocal|KDriveAttInternal;
+		return;		
+		}
+	anInfo.iType=EMediaNotPresent;
+	anInfo.iDriveAtt=0;
+	}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+