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

 // f32\inc\f32fsys.h

 // 

 // WARNING: This file contains some APIs which are internal and are subject

 //          to change without notice. Such APIs should therefore not be used

 //          outside the Kernel and Hardware Services package.

 //

 /**

  @file

  @publishedPartner

  @released

 */

 #if !defined(__F32FSYS_H__)

 #define __F32FSYS_H__

 #if !defined(__F32FILE_H__)

 #include <f32file.h>

 #endif

 #include <e32atomics.h>

 #include <d32locd.h>

 //

 #if defined(_UNICODE)

 #define KFileSystemUidValue KFileSystemUidValue16

 #define KFileServerUidValue KFileServerUidValue16

 #define KFileServerDllUidValue KFileServerDllUidValue16

 #else

 #define KFileSystemUidValue KFileSystemUidValue8

 #define KFileServerUidValueKFileServerUidValue8

 #define KFileServerDllUidValueKFileServerDllUidValue8

 #endif

 /**

 Filesystem error code 1 : indicates an item cannot be found,

 because it has been hidden.

 */

 const TInt KErrHidden=(1);

 /**

 Filesystem error code 2 : in the context of file operations, a path

 was not found, because it has been hidden.

 */

 const TInt KErrPathHidden=(2);

 const TInt KFileShareLockGranularity=2;

 const TInt KAsyncRequestArrayGranularity=2;

 /**

 @publishedPartner

 @released

 File system UID value 16.

 */

 const TInt KFileSystemUidValue16=0x100039df;

 /**

 @publishedPartner

 @released

 File system UID value 8.

 */

 const TInt KFileSystemUidValue8=0x1000008f;

 /**

 @publishedPartner

 @released

 File server UID value 16.

 */

 const TInt KFileServerUidValue16=0x100039e3;

 /**

 @publishedPartner

 @released

 File server UID value 8.

 */

 const TInt KFileServerUidValue8=0x100000bb;

 /**

 @publishedPartner

 @released

 File server DLL UID value 16.

 */

 const TInt KFileServerDllUidValue16=0x100039e4;

 /**

 @publishedPartner

 @released

 File server DLL UID value 8.

 */

 const TInt KFileServerDllUidValue8=0x100000bd;

 /**

 @publishedPartner

 @released

 Local file system UID value.

 */

 const TInt KLocalFileSystemUidValue=0x100000d6;

 /**

 @publishedPartner

 @released

 Estart component UID value.

 */

 const TInt KEstartUidValue=0x10272C04;

 /**

 @publishedPartner

 @released

 Maximum length of a volume name.

 */

 const TInt KMaxVolumeNameLength=11;

 /**

 @publishedPartner

 @released

 First local drive indicator.

 */

 const TInt KFirstLocalDrive=EDriveC;

 const TInt KMaxExtensionCount=2;

 //

 const TInt KDriveInvalid=-1;

 //

 _LIT(KMediaPWrdFile, "?:\\sys\\data\\mmcstore");

 //

 /** 

 @internalTechnology

 */

 const TUint KSystemDriveKey = 0x10283049;

 /**

 @publishedPartner

 @released

 Enumeration that specifies whether, on opening a file:

 - an existing file is opened

 - a new file is created 

 - an existing file is replaced.

 */

 enum TFileOpen {EFileOpen,EFileCreate,EFileReplace};

 /**

 @publishedPartner

 @released

 The file share mode.

 */

 typedef TFileMode TShare;

 class CMountCB;

 class CFileSystem;

 class CFileCB;

 class CDirCB;

 class CFileShare;

 class CSessionFs;

 class CFsPlugin;

 class CFileBody;

 class CMountBody;

 class CFsMessageRequest;

 class CProxyDrive;

 class CFormatCB;

 //

 class CFsObjectCon;

 class CFileCache;

 //

 class CExtNotifyMediaChange;

 //

 /**

 @publishedPartner

 @released

 Implements reference counting to track concurrent references to itself.

 An object of this type arranges automatic destruction of itself when the final 

 reference is removed.

 A reference counting object is any object which has CFsObject as its base class. 

 Constructing a CFsObject derived type or calling its Open() member function 

 adds a reference to that object by adding one to the reference count; calling 

 its Close() member function removes a reference by subtracting one from the 

 reference count; when the last user of the object calls Close(), the reference 

 count becomes zero and the object is automatically destroyed.

 */

 class CFsObject : public CBase

 	{

 public:

 	IMPORT_C CFsObject();

 	IMPORT_C virtual TInt Open();

 	IMPORT_C virtual void Close();

 	IMPORT_C TInt SetName(const TDesC* aName);

 	IMPORT_C TName Name() const;

 	IMPORT_C virtual TBool IsCorrectThread();

 	inline CFsObjectCon* Container() const;

 protected:

 	void DoClose();

 	TInt UniqueID() const;

 	inline TInt Inc();

 	inline TInt Dec();

 	IMPORT_C ~CFsObject();

 private:

 	TInt iAccessCount;

 	CFsObjectCon* iContainer;

 	HBufC* iName;   

 friend class CFsObjectCon;

 friend class CFsObjectIx;

 	};

 class CFsRequest;

 class CFsInternalRequest;

 /**

 Implements a request dispatcher.

 Base class for file server resources.

 for example subsessions that are opened, such as RFile etc, that need closing are closed by 

 issuing a subsession close request, handled by this object.

 @publishedPartner

 @released

 */

 class CFsDispatchObject : public CFsObject

 	{

 public:

 	CFsDispatchObject();

 	/**

 	Returns the drive number.

 	@return Drive number.

 	*/

 	TInt DriveNumber() const {return(iDriveNumber);}

 	IMPORT_C void Close();

 	IMPORT_C virtual TBool IsCorrectThread();

 protected:

 	void DoInitL(TInt aDrvNumber);

 	void Dispatch();

 	~CFsDispatchObject();

 private:

 	CFsInternalRequest* iRequest;

 	TInt iDriveNumber;

 friend class TFsCloseObject;

 friend class CFileShare;	// needed to override the close operation so that the file cache can be flushed on a close

 	};

 /**

 Notifier class must be unique to each thread so one per drive or threaded plugin should be used

 allocated in the file system. No longer global

 @publishedPartner

 @released

 */

 NONSHARABLE_CLASS(CAsyncNotifier) : public CBase

 	{

 public:

 	IMPORT_C static CAsyncNotifier* New();

 	IMPORT_C ~CAsyncNotifier();

 	IMPORT_C TInt Notify(const TDesC& aLine1,const TDesC& aLine2,const TDesC& aButton1,const TDesC& aButton2,TInt& aButtonVal);

 	inline void SetMount(CMountCB* aMount) { iMount = aMount; };

 protected:

 	CAsyncNotifier();

 	TInt Connect(); 

 private:

 	RNotifier iNotifier;

 	CMountCB* iMount;

 	};

 class CProxyDriveFactory;

 /**

 @publishedPartner

 @released

 Structure containing information related to a single drive extension.

 */

 struct TExtensionInfo

 	{

 	TBool iIsPrimary;            	///< Is the primary drive extension for a given drive  

 	CProxyDriveFactory* iFactory;  	///< Pointer to the drive extension's object factory

 	};

 /**

 @publishedPartner

 @released

 Represents information related to the Drive extension(s) in use for a given drive.

 */

 struct TDriveExtInfo

 	{

 	TDriveExtInfo();

 	TInt iCount; 								///< Number of drive extensions in use                               

 	TExtensionInfo iInfo[KMaxExtensionCount]; 	///< Drive extension related information    

 	};

 /**

 @publishedPartner

 @released

 Represents a drive in the file server.

 Note that drives may act as substitutes for paths on other drives,

 in which case any access to this drive letter will be translated into

 a reference to the assigned path. In this way drives can act as short

 cuts to paths on other drives.

 */

 class TDrive

 	{

 public:

 	TDrive();

 	void CreateL(TInt aDriveNumber);

 	TInt CheckMount();

 	TInt CheckMountAndEntryName(const TDesC& aName);

     TInt FinaliseMount();

     TInt FinaliseMount(TInt aOperation, TAny* aParam1=NULL, TAny* aParam2=NULL);

     TInt MountControl(TInt aLevel, TInt aOption, TAny* aParam);

     void MountFileSystem(TBool aForceMount, TUint32 aFsNameHash = 0);

     void FlushCachedFileInfoL();

 	TInt FlushCachedFileInfo(TBool aPurgeCache = EFalse);

 	void PurgeDirty(CMountCB& aMount);

 	void DriveInfo(TDriveInfo& anInfo);

 	TInt Volume(TVolumeInfo& aVolume);

 	TInt SetVolume(const TDesC& aName);

 	TInt MkDir(const TDesC& aName);

 	TInt RmDir(const TDesC& aName);

 	TInt Delete(const TDesC& aName);

 	TInt Rename(const TDesC& anOldName,const TDesC& aNewName);

 	TInt Replace(const TDesC& anOldName,const TDesC& aNewName);

 	TInt Entry(const TDesC& aName,TEntry& anEntry);

 	TInt SetEntry(const TDesC& aName,const TTime& aTime,TUint aMask,TUint aVal);

 	TInt FileTemp(CFsRequest* aRequest,TInt& aHandle,const TDesC& aPath,TDes& aName,TUint aMode);

 	TInt FileOpen(CFsRequest* aRequest,TInt& aHandle,const TDesC& aName,TUint aMode,TFileOpen anOpen);

 	TInt DirOpen(CSessionFs* aSession,TInt& aHandle,const TDesC& aName,TUint anAtt,const TUidType& aUidType);

     CFormatCB* FormatOpenL(CFsRequest* aRequest, TInt& aFmtHandle, TFormatMode aFmtMode, const TLDFormatInfo*  apLDFormatInfo, const TVolFormatParam*  apVolFormatParam);

     TInt CheckDisk(); 

     TInt CheckDisk(TInt aOperation, TAny* aParam1=NULL, TAny* aParam2=NULL);

     TInt ScanDrive(); 

 	TInt ScanDrive(TInt aOperation, TAny* aParam1=NULL, TAny* aParam2=NULL);

     TInt ReadFileSection(const TDesC& aName,TInt aPos,TAny* aTrg,TInt aLength,const RMessagePtr2& aMessage);

     TInt ReadFileSection64(const TDesC& aName,TInt64 aPos,TAny* aTrg,TInt aLength,const RMessagePtr2& aMessage);

 	TInt GetShortName(const TDesC& aLongName,TDes& aShortName);

 	TInt GetLongName(const TDesC& aShortName,TDes& aLongName);

 	TInt IsFileOpen(const TDesC& aFileName,CFileCB*& aFileCB);

 	TInt IsFileInRom(const TDesC& aFileName,TUint8*& aFileStart);

 	TInt LockDevice(TMediaPassword& aOld,TMediaPassword& aNew,TBool aStore);

 	TInt UnlockDevice(TMediaPassword& aPassword,TBool aStore);

 	TInt ClearDevicePassword(TMediaPassword& aPassword);

 	TInt EraseDevicePassword();

 	TInt FreeDiskSpace(TInt64& aFreeDiskSpace);

 	TInt ForceRemountDrive(const TDesC8* aMountInfo,TInt aMountInfoMessageHandle,TUint aFlags);

 	TBool IsWriteProtected();

 	TInt MountExtension(CProxyDriveFactory* aFactory,TBool aIsPrimary);

 	TInt DismountExtension(CProxyDriveFactory* aFactory,TBool aIsPrimary);

 	TInt ExtensionName(TDes& aExtensionName,TInt aPos);

 	TInt ControlIO(const RMessagePtr2& aMessage,TInt aCommand,TAny* aParam1,TAny* aParam2);	

 	void SetAtt(TUint aValue);

 	IMPORT_C TUint Att();

 	IMPORT_C TBool GetNotifyUser();		

 	IMPORT_C void Dismount();		

 	IMPORT_C TBool IsWriteableResource() const;	

 	IMPORT_C TBool IsCurrentWriteFunction() const; 

 	inline TInt GetReason() const;	

 	inline void SetChanged(TBool aValue);	

 	inline TBool IsChanged() const;

 	inline TInt DriveNumber() const;

 	inline TBool IsMounted() const;

 	inline TBool IsLocal()	const;			

 	inline TBool IsRom()	const;			

 	inline TBool IsRemovable()	const;		

 	inline TBool IsSubsted() 	const;		

 	inline CMountCB& CurrentMount() const;

 	inline  TBool IsCurrentMount(CMountCB& aMount) const;

 	inline TDrive& SubstedDrive() const;

 	inline void SetSubstedDrive(TDrive* aDrive);

 	inline HBufC& Subst() const;

 	inline void SetSubst(HBufC* aSubst);

 	inline CFsObjectCon& Mount() const;	

 	inline CFileSystem& FSys();			

 	inline CFileSystem*& GetFSys();

 	inline TDriveExtInfo& ExtInfo();	

 	inline void SetNotifyOn();			

 	inline void SetNotifyOff();	

 	inline TInt ReservedSpace() const;

 	inline void SetReservedSpace(const TInt aReservedSpace);

     inline void SetRugged(TBool aIsRugged);

 	inline TBool IsRugged() const;

     inline TBool IsSynchronous() const;

     inline void SetSynchronous(TBool aIsSynch);

 	TInt DismountProxyDrive();

     TInt ForceUnmountFileSystemForFormatting();

 public:

 	void DismountLock();

 	TInt DismountUnlock();

 	TInt DismountLocked() const;

 	void SetDismountDeferred(TBool aPending);

 	void ForceDismount();

 	TInt ActiveMounts() const;

 	void ReactivateMounts();

 	TInt ClampFile(const TDesC& aName,TAny* aHandle);

 	TInt UnclampFile(CMountCB* aMount, RFileClamp* aHandle);

 	TInt ClampsOnDrive();

 	inline TBool DismountDeferred() const;

 	TInt DeferredDismount();

 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)

 	TInt ClearDeferredDismount();

 #endif

 	void SetClampFlag(TBool aClamped);

 	TBool ClampFlag();

 	inline void Lock();

 	inline void UnLock();

     void MultiSlotDriveCheck();	

     TInt RequestFreeSpaceOnMount(TUint64 aFreeSpaceRequired);

     TInt MountedVolumeSize(TUint64& aSize);

 	TBool ReMount(CMountCB& aMount);

 private:

     void DoMountFileSystemL(CMountCB*& apMount, TBool aForceMount, TUint32 aFsNameHash);

     void SetVolumeL(const TDesC& aName,HBufC*& aBuf);

 	void DirOpenL(CSessionFs* aSession,TInt& aHandle,const TDesC& aName,TUint anAtt,const TUidType& aUidType,CDirCB*& aDir);

 	void FileOpenL(CFsRequest* aRequest,TInt& aHandle,const TDesC& aName,TUint aMode,TFileOpen anOpen,CFileCB*& aFileCB,CFileShare*& aFileShare);

 	TInt CheckMountAndEntryNames(const TDesC& anOldName,const TDesC& aNewName);

 	CFileCB* LocateFileByPath(const TDesC& aPath);

 	TInt CheckDirectories(const TDesC& anOldName,const TDesC& aNewName);

 	void DoEntryL(const TDesC& aName,TEntry& anEntry);

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

 	TInt ValidateShare(CFileCB& aFile,TShare aReqShare);

 	TInt CheckAttributes(const TDesC& aName,TUint& aSetAttMask,TUint& aClearAttMask);

 	TBool IsExtensionMounted(CProxyDriveFactory* aFactory);

 	CFileCB* LocateFile(const TDesC& aName);

 	CFileCache* LocateClosedFile(const TDesC& aName, TBool aResurrect = ETrue);

 	TBool ReMount();

 	IMPORT_C TBool IsDriveThread() const;

 	IMPORT_C TBool IsMainThread() const;

 	IMPORT_C void DriveFault(TBool aDriveError) const;

     void DoDismount();

     void DoCompleteDismountNotify(TInt aCompletionCode);

 private:

     //-- intrinsic TDrive flags. Used in iDriveFlags.

     enum 

 	    { 

         ENotifyOff       = 0x01, 

         EDismountDeferred= 0x02,

         ENotRugged       = 0x04, 

         EClampPresent    = 0x08,

         EDriveIsSynch    = 0x10, //-- is set on mount when the drive is synchronous (doesn't have its own thread)

 		};	

 private:

 	TInt            iDriveNumber;

 	TUint           iAtt;

 	TBool           iChanged;

 	TInt            iReason;

 	TInt            iMountNumber;

 	CFileSystem*    iFSys;

 	CMountCB*       iCurrentMount;

 	TDrive*         iSubstedDrive;

 	HBufC*          iSubst;

 	CFsObjectCon*   iMount;

 	RFastLock       iLock;

 	TDriveExtInfo   iExtInfo;	

 	TInt            iDriveFlags;   ///< intrinsic TDrive flags

 	TInt            iReservedSpace;

 	TInt            iDismountLock;

 	TInt            iMountFailures;		// number of times the mount has failed

 	TInt            iLastMountError;

 	TInt iSpare1;			

 	TInt iSpare2;

 	friend class LocalDrives;			// for access to iChanged flag

 	friend class CExtNotifyMediaChange; // for access to iChanged flag

 	};

 class CFileCB;

 class CDirCB;

 __ASSERT_COMPILE(sizeof(TVolFormatParam) != sizeof(TLDFormatInfo));

 /**

 @publishedPartner

 @released

 A file server interface class representing a mount.

 An instance of this object is referred to as a mount control block.

 A mount control block needs to be created for a specific volume (partition) on

 a drive in order to be able to access that volume. Volumes may be permanent

 or represent removable media. Note that removable media may also be mounted directly onto

 a device with no drive. Volumes can be formatted, unlike drives.

 The volume represented is either a currently mounted volume in the system or,

 in the case of removable volumes, a volume that has been removed but still has

 subsession objects open.

 A plug-in file system implements this class.

 */

 class CMountCB : public CFsDispatchObject

 	{

 public:

 	IMPORT_C CMountCB();

 	IMPORT_C ~CMountCB();

 	IMPORT_C TBool operator!=(const CMountCB& aMount) const;

 	IMPORT_C TBool MatchEntryAtt(TUint anAtt,TUint aMatt) const;

 	IMPORT_C void SetDiskSpaceChange(TInt64 aFreeDiskSpace);

     IMPORT_C void InitL(TDrive& aDrive, CFileSystem* apFileSystem);

     inline TDrive& Drive() const;

 	inline void SetDrive(TDrive* aDrive);

 	inline HBufC& VolumeName() const; 

 	inline void SetVolumeName(HBufC* aName);

 	inline TBool GetNotifyUser() const;

 	inline void SetNotifyOn();

 	inline void SetNotifyOff();

 	inline void IncLock();

 	inline void DecLock();

 	inline TInt LockStatus() const; 

 	inline TBool IsCurrentMount() const; 

 	inline TBool Locked() const;

 	inline TInt64 Size() const; 

 	inline TInt LocalDrive(TBusLocalDrive*& aLocalDrive);

 	inline TInt ProxyDrive(CProxyDrive*& aProxyDrive);

 	inline TInt LocalBufferSupport(CFileCB* aFile = NULL);

 	inline TInt AddToCompositeMount(TInt aMountIndex);

 // Pure virtual

     /**

     Attempts to set the mount control block properties using

     the current mount (i.e. volume) on the associated drive.

     The function should set the volume name (iVolumeName),

     the unique ID (iUniqueID) and the volume size (iSize)

     by reading and processing the current mount.

     When aForceMount is set to ETrue, the properties of a corrupt volume should

     be forcibly stored. The classic case of when this is desirable is when

     a corrupt volume needs to be formatted.

     The function should leave, on error detection, with an appropriate error code.

     @param aForceMount Indicates whether the properties of a corrupt

                        volume should be stored.

     @leave KErrCorrupt The properties of the current mount on the drive were

            not successfully mounted due to corruption of volume information,

            assuming that aForceMount is not set.

     */

 	virtual void MountL(TBool aForceMount) =0;

     /**

     Checks whether the mount control block represents the current mount on

     the associated drive.

     The function should read mount information from the current volume,

     and check it against the mount information from this mount - typically

     iVolumeName and iUniqueID. If the mount information matches, the function

     should return KErrNone, otherwise it should return KErrGeneral.

     Called by the associated TDrive object when the drive has no current mounts,

     which is the case on first access to the drive and following a volume

     change on a drive associated with removable media. In this circumstance,

     this function is called systematically on every mount control block owned

     by the drive. If ReMount() calls for all existing mount

     control blocks fail, the drive creates a new mount control block and calls

     CMountCB::MountL() on that object; the new object is added to the list of

     mount control blocks owned by the drive.

     @return KErrNone if the mount represented by this object is found to be

             the current mount;

             KErrGeneral if this object is found not to represent

             the current mount;

             otherwise one of the other sytem wide error codes.

     */

 	virtual TInt ReMount() =0;

     /**

     Carries out any clean-up necessary for a volume dismount. 

     Dismounting a volume will always succeed, so the function does not need

     to return an error value. Any cached information should be discarded and no

     attempt should be made to access the volume. For removable media it may be

     that the media has already been removed. This function is called when

     a media change is detected.

     */

 	virtual void Dismounted() =0;

     /**

     Gets volume information.

     The only information that the function has to supply is the free space,

     TVolumeInfo::iFree, since the remaining members have already been set by

     the calling function.

     The function should leave, on error detection, with

     an appropriate error code.

     @param aVolume On return, a reference to the filled volume

                    information object.

     */

 	virtual void VolumeL(TVolumeInfo& aVolume) const =0;

     /**

     Sets the volume name for the mount, thus writing the new volume name

     to the corresponding volume.

     This function should leave on error detection.

     @param aName A reference to a descriptor containing the new volume name.

     @leave KErrBadName If the specified volume name is longer than the maximum

            allowed length for a volume name

     */

 	virtual void SetVolumeL(TDes& aName) =0;

     /**

     Creates a new directory on the mount.

     The directory to be created is identified through its full name in aName.

     The full name is in the form:

     @code

     \\dirA\\dirB\\dirC\\dirD

     @endcode

     where dirD is the new directory to be created in \\dirA\\dirB\\dirC\\.

     This means that dirC is the leaf directory in which dirD will be created.

     The function should leave, on error detection, with an appropriate

     error code.

     @param aName A reference to a descriptor containing the full name of

                  the directory to be created.

     @leave  KErrPathNotFound Part of the path in aName does not exist.

     @leave  KErrAlreadyExists dirD already exists in \\dirA\\dirB\\dirC\\

     @leave  KErrAccessDenied dirD already exists but is not a directory.

     @leave  KErrDirFull There is no room in \\dirA\\dirB\\dirC\\ for the new entry,

             which is especially applicable to the root directory.

     */

 	virtual void MkDirL(const TDesC& aName) =0;

     /**

     Removes the directory specified by aName (its full name) from the volume.

     The directory specified by aName is in the form:

     @code

     \\dirA\\dirB\\dirC\\dirD

     @endcode

     where dirD is the directory to be removed from \\dirA\\dirB\\dirC\\.

     This means that dirC is the leaf directory from which dirD should be removed.

     The function can assume that the directory exists and is not read-only. 

     The function should leave with a suitable error code if it cannot complete

     successfully for any reason. 

     @param aName A reference to a descriptor containing the full name of

                  the directory to be removed.

     @leave KErrInUse dirD contains entries other than the parent (..)

            and current (.) entries.

     */

 	virtual void RmDirL(const TDesC& aName) =0;

     /**

     Deletes the specified file from the mount.

     The function can assume that the file is closed.

     The file name specified by aName is of the form:

     @code

     \\dirA\\dirB\\dirC\\file.ext

     @endcode

     The extension is optional.

     The function should leave on error detection, with

     an appropriate error code.

 	@param aName A reference to a descriptor containing the full path name

 	             of the file that will be removed.

 	@leave KErrAccessDenied aName specifies a file whose attributes state that

 	       the file is read-only or aName specifies a directory.

     */

 	virtual void DeleteL(const TDesC& aName) =0;

     /**

     Renames or moves a single file or directory on the mount.

     It can be used to move a file or directory since both

     anOldName and anNewName specify the respective entries with full names;

     for example,

     @code

     \\dirA\\dirB\\dirC\\oldEntryName

     @endcode

     and

     @code

     \\dirE\\dirF\\dirG\\newEntryName

     @endcode

     If oldEntryName is a file, it can be assumed that it is closed.

     If oldEntryName is a directory, it can be assumed that there are no

     open files in this directory. Furthermore, if newEntryName specifies

     a directory, it can be assumed that it is not a subdirectory of oldEntryName.

     The function should leave with an appropriate error code if it cannot

     complete successfully for any reason. 

 	@param anOldName A reference to a descriptor containing the full entry

 	                 name of the entry to be renamed.

 	@param anNewName A reference to a descriptor containing the new full entry

 	                 name for the entry to be renamed.

     @leave KErrAlreadyExists The new entry already exists.

     */

 	virtual void RenameL(const TDesC& anOldName,const TDesC& anNewName) =0;

     /**

     Replaces one file on the mount with another.

     The function can assume that both anOldName and, if it exists, anNewName

     contain the full file names of files, and that these files are not open.

     If the file aNewName does not exist it should be created.

     The file anOldName should have its contents, attributes, and the universal

     date and time of its last modification, copied to the file aNewName,

     overwriting any existing contents and attribute details.

     Finally anOldName should be deleted.

     The function should leave with an appropriate error code if it cannot

     complete successfully for any reason.

     @param anOldName A reference to a descriptor containing the full file name

                      of the file to replace the file specified by anNewName

     @param anNewName A reference to a descriptor containing the new full file

                      name for the entry to be replaced.

     */

 	virtual void ReplaceL(const TDesC& anOldName,const TDesC& anNewName) =0;

     /**

     Gets the entry details for the specified file or directory.

     anEntry should be filled with details from the file or directory with the

     full name aName. aName is of the form

     @code

     \\dirA\\dirB\\dirC\\entry.

     @endcode

     Note that anEntry.iType (the entry UID) should only be set for a file whose

     size is greater than or equal to sizeof(TCheckedUid).

     The function should leave with an appropriate error code if it cannot

     complete successfully for any reason.

     @param aName   A reference to a descriptor containing the full name of

                    the entry whose details are required.

     @param anEntry On return, a reference to the filled entry object.

     @leave KErrPathNotFound The entry, aName, cannot be found.

     */

 	virtual void EntryL(const TDesC& aName,TEntry& anEntry) const =0;

     /**

     Sets entry details for a specified file or directory.

     The entry identfied by the full name descriptor aName should have

     its modification time and its attributes mask updated as required.

     The entry receives a new universal modified time from aTime.

     The entry attributes are set with aSetAttMask and cleared

     with aClearAttMask:

     the bits that are set in aSetAttMask should be set

     in the entry attribute mask;

     the bits that are set in aClearAttMask

     should be cleared from the entry attribute mask.

     The function can assume that aSetAttMask and aClearAttMask do not change

     the type of attribute (i.e. volume or directory). Furthermore, if aName

     specifies a file, it can be assumed that this file is closed.

     The function should leave with an appropriate error code on error detection.

     @param aName         A reference to a descriptor containing the full name of

                          the entry to be updated.

     @param aTime         A reference to the time object holding the new universal

                          modified time for aName.

     @param aSetAttMask   Attribute mask for setting the entry's attributes.

     @param aClearAttMask Attribute mask for clearing the entry's attributes.

     */

 	virtual void SetEntryL(const TDesC& aName,const TTime& aTime,TUint aSetAttMask,TUint aClearAttMask) =0;

     /**

     Customises the opening of a new or existing file on the mount.

     The function is called internally (via TDrive::FileOpen()) as a result of

     a call by the client, and the file is created, if necessary, and opened by

     the calling function. However this function implements any replacement

     functionality, as well as any other behaviour particular to the file system.

     If anOpen specifies EFileReplace (rather than EFileCreate or EFileOpen) then,

     if replacement functionality is required, the data contained in the file

     should be discarded, the archive attribute should be set, and the size of

     the file should be set to zero. Note that it can be assumed that if anOpen

     specifies EFileReplace then the file already exists.

     After successful completion of the function, the file control block pointer

     will be added to the file server's global files container.

     The function should leave with a suitable error code if it cannot be completed

     successfully.

     @param aName  The full name of the file that will be opened.

     @param aMode  The file share mode. The following share modes are available:

                   EFileShareExclusive;

                   EFileShareReadersOnly;

                   EFileShareAny;

                   EFileShareReadersOrWriters;

                   EFileStream;

                   EFileStreamText;

                   EFileRead;

                   EFileWrite.

     @param anOpen IndicatES how the file will be opened. It can be one of

                   the following:

                   EFileOpen;

                   EFileCreate;

                   EFileReplace.

     @param aFile  Pointer to the file control block which will, on success,

                   represent the open file.

     @leave KErrAccessDenied aName may specify a directory, or the function may

            be attempting to open a file on a ROM drive.

     */

 	virtual void FileOpenL(const TDesC& aName,TUint aMode,TFileOpen anOpen,CFileCB* aFile) =0;

     /**

     Customises the opening of a directory on the mount.

     The function is called internally, and the directory will have been created

     and initialised by the calling function. Any customisation specific to

     a file system should be implemented in this function.

     Note that aName is of the form

     @code

     \\dirA\\dirB\\dirC\\file.ext

     @endcode

     where \\dirA\\dirB\\dirC\\ is the directory to be opened and file.ext is

     an optional entry name and extension.

     After successful completion of the function, the directory control block

     pointer will be added to the file server global directories container.

     The function should leave with a suitable error code if it cannot complete

     successfully for any reason.

     @param aName A reference to a descriptor containing the full name of

                  the directory that will be opened.

     @param aDir  Points to a directory control block which will, on success,

                  represent the open directory.

     */

 	virtual void DirOpenL(const TDesC& aName,CDirCB* aDir) =0;

     /**

     Reads the specified length of data from the specified position on

     the volume directly into the client thread.

     It can be assumed that if this function is called,

     then there has been a successful mount.

     This function should leave with an appropriate error code when

     an error is detected.

     @param aPos     Start position in the volume for the read operation,

                     in bytes.

     @param aLength  The number of bytes to be read.

     @param aTrg     A pointer to the buffer into which data is to be read.

     @param anOffset The offset at which to start adding data to the read buffer.

     @param aMessage

     */

 	virtual void RawReadL(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt anOffset,const RMessagePtr2& aMessage) const = 0;

     /**

     Writes a specified length of data from the client thread to the volume

     at the specified position.

     It can be assumed that if this function is called, then there has been

     a successful mount.

     This function should leave with an appropriate error code when

     an error is detected.

     @param aPos     Start position in the volume for the write operation,

                     in bytes.

     @param aLength  The number of bytes to be written.

     @param aSrc     Pointer to the buffer from which data will be written.

     @param anOffset The offset in the buffer at which to start writing data.

     @param aMessage

     */

 	virtual void RawWriteL(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt anOffset,const RMessagePtr2& aMessage) = 0;

     /**

     Gets the short name of the file or directory with the given full name.

     This function is used in circumstances where a file system mangles

     Symbian OS natural names, in order to be able to store them on

     a file system that is not entirely compatible.

     The function should leave with a suitable error code if it cannot complete

     successfully for any reason.

 	@param aLongName  A reference to a descriptor containing the full name

 	                  of the entry.

 	@param aShortName On return, a reference to a descriptor containing

 	                  the short name of the entry.

     @leave KErrNotFound The entry specified by its long name cannot be found.

     */

 	virtual void GetShortNameL(const TDesC& aLongName,TDes& aShortName) = 0;

     /**

     Gets the long name of the file or directory associated with

     the given short name.

     This function is used in circumstances where a file system mangles

     Symbian OS natural names in order to be able to store them on

     a file system that is not entirely compatible. 

     The function should leave with a suitable error code if it cannot complete

     successfully for any reason.

 	@param aShorName  A reference to a descriptor containing the short name

 	                  of the entry.

     @param aLongName  On return, a reference to a descriptor containing

                       the long name of the entry.

     @leave KErrNotFound The entry specified by its short name cannot be found.

     */

 	virtual void GetLongNameL(const TDesC& aShorName,TDes& aLongName) = 0;

     /**

     Reads a specified section of the file, regardless of the file's lock state.

     The function should leave with a suitable error code if it cannot complete

     successfully for any reason.

     @param aName   A reference to a descriptor containing the full name of

                    the file to be read from

     @param aPos    The byte position to start reading from.

     @param aTrg    A pointer to the buffer into which data is to be read.

     @param aLength The length of data to be read, in bytes.

     @param aMessage

 	@leave KErrEof aPos is past the end of the file.

     */

 	virtual void ReadSectionL(const TDesC& aName,TInt aPos,TAny* aTrg,TInt aLength,const RMessagePtr2& aMessage)=0;

     /**

     Checks the integrity of the file system on the volume and returns an appropriate error value. 

     The default implementation must be overridden by a derived class.

     @return KErrNone if the file system is stable; otherwise one of the other system wide error codes.

             The default implementation returns KErrNotSupported.

     */

     virtual TInt CheckDisk() {return(KErrNotSupported);}

     /**

     The same as original CheckDisk(), but with some parameters.

     */

     virtual TInt CheckDisk(TInt aOperation, TAny* aParam1=NULL, TAny* aParam2=NULL);

 	/**

     Scans through and corrects errors found in the volume.

     The default implementation must be overridden by a derived class.

     @return KErrNone if no errors are found or all errors are corrected; otherwise one of the other system wide error codes.

             The default implementation returns KErrNotSupported.

     */

 	virtual TInt ScanDrive() {return(KErrNotSupported);}

     /**

     The same as original ScanDrive(), but with some parameters.

     */

     virtual TInt ScanDrive(TInt aOperation, TAny* aParam1=NULL, TAny* aParam2=NULL);

     IMPORT_C virtual void IsFileInRom(const TDesC& aFileName,TUint8*& aFileStart);

 	/**

         Low-level control IO

     */

 	virtual TInt ControlIO( const RMessagePtr2& /*aMessage*/,TInt /*aCommand*/,TAny* /*aParam1*/,TAny* /*aParam2*/)  {return(KErrNotSupported);}

 	/**

 	Locks a media which supports password protection and replaces

 	the old password with a new one. 

     If aStore is set to ETrue, then the new password should be saved to

     the password store file, KMediaPWrdFile, using the exported file server

     function WriteToDisk(). 

     The password file is used to initialise the password store on boot up,

     so the user does not need to be prompted for the password again if

     it is saved here.

     The default implementation must be overridden in a derived class.

     @param aOld   A reference to the old password.

     @param aNew   A reference to the new password.

     @param aStore ETrue if the new password is to be saved to 

                   the password file store; EFalse if not.

     @return KErrNone if successful; otherwise another of the system wide

             error codes. The default implementation returns KErrNotSupported.

     */

 	virtual TInt Lock(TMediaPassword& /*aOld*/,TMediaPassword& /*aNew*/,TBool /*aStore*/) {return(KErrNotSupported);}

 	/**

 	Unlocks a media which supports password protection.

     If aStore is set to ETrue then the password should be saved to

     the password store file specified by KMediaPWrdFile using the exported file

     server function WriteToDisk().

     The password file is used to initialise the password store on boot up,

     so the user does not need to be prompted for the password again if

     it is saved here.

     The default implementation must be overridden in a derived class.

     @param aPassword A reference to the password.

     @param aStore    ETrue if the password is to be saved to

                      the password store file; EFalse otherwise.

     @return KErrNone if successful; otherwise another of the system wide

             error codes. The default implementation returns KErrNotSupported.                     

     */

 	virtual TInt Unlock(TMediaPassword& /*aPassword*/,TBool /*aStore*/) {return(KErrNotSupported);}

 	/**

 	Clears a password from a media that supports write protection. 

     The default implementation must be overridden in a derived class.

     @param aPassword A reference to the password to be cleared.

     @return KErrNone if successful; otherwise another of the system wide

             error codes. The default implementation returns KErrNotSupported.

     */

 	virtual TInt ClearPassword(TMediaPassword& /*aPassword*/) {return(KErrNotSupported);}

 	/**

     */

 	virtual TInt ForceRemountDrive(const TDesC8* /*aMountInfo*/,TInt /*aMountInfoMessageHandle*/,TUint /*aFlags*/) {return(KErrNotSupported);}

     /**

         Legacy method: finalise the mount and put it to the consistent state.

     */

 	virtual void FinaliseMountL() {return;}

     /** 

         finalise the mount and put it to the consistent state.

         @param  aOperation  describes finalisation operation, see RFs::TFinaliseDrvMode

         @param  aParam1     not used, for future expansion

         @param  aParam2     not used, for future expansion

    */

     virtual	void FinaliseMountL(TInt aOperation, TAny* aParam1=NULL, TAny* aParam2=NULL);

     protected:

     /** Mount Control levels or operations to perform */

     enum TMntCtlLevel 

         {

         //-- reserved generic mount (CMountCB) control codes

         EMountStateQuery,       ///< query mount state, see TMntCtlOption, ESQ_IsMountFinalised

         EMountVolParamQuery,    ///< mount-specific queries for volume parameters. See ESQ_RequestFreeSpace, ESQ_GetCurrentFreeSpace 

         ECheckFsMountable,      ///< extended mount functionality, checks if this file system can be mounted on specified drive. See CheckFileSystemMountable()

         //-- starting from the next code someone may define some specific mount type control codes, like ESpecificMountCtl+17

         ESpecificMountCtl = 0x40000000,

         //-- starting from the next code someone may define some specific File System control codes

         ESpecificFsCtl = 0x40001000,

         EMountFsParamQuery,     ///< File System parameters queries; File System properties can be "static" i.e not requiring properly mounted volume. See ESpecificFsCtlOpt

         };

     /** Mount Control options that makes sense only for certain control codes, see TMntCtlLevel */

     enum TMntCtlOption

         {

         //-- reserved generic mount (CMountCB) control options codes

         /** query if the mount is finalised, corresponds to the EMountStateQuery control code only. @see IsMountFinalised() */

         ESQ_IsMountFinalised, 

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

         //-- starting from the next code someone may define some specific mount type control options

         ESpecificMountCtlOpt = 0x40000000,

         /** Corresponds to EMountVolParamQuery. Request a certain amount of free space on the volume. @see RequestFreeSpace() */

         ESQ_RequestFreeSpace,

         /** Corresponds to EMountVolParamQuery. A request to obtain the _current_ amount of free space on the volume asynchronously, without blocking. */

         ESQ_GetCurrentFreeSpace,

         /** Corresponds to EMountVolParamQuery. A request to obtain size of the mounted volume without blocking (CMountCB::VolumeL() can block). */

         ESQ_MountedVolumeSize,

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

         //-- starting from the next code someone may define some specific File System control options

         ESpecificFsCtlOpt = 0x40001000,

         /** Get Maximum file size, which is supported by the file system that has produced this mount. */

         ESQ_GetMaxSupportedFileSize, 

         };

     public:

     /**

         Generic mount 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. Default imlementation returns KErrNotSupported

     */

     virtual	TInt MountControl(TInt aLevel, TInt aOption, TAny* aParam);

 	/**

 	Erase a password from a media that supports write protection. 

     The default implementation must be overridden in a derived class.

     @return KErrNone if successful; otherwise another of the system wide

             error codes. The default implementation returns KErrNotSupported.

     */

 	virtual TInt ErasePassword() {return(KErrNotSupported);}

 	/** 

 	An interface class which may optionally be returned by a file system

 	by calling GetInterface(EFileAccessor, ...)

 	*/

 	class MFileAccessor

 		{

 	public:

 		virtual TInt GetFileUniqueId(const TDesC& aName, TInt64& aUniqueId) = 0;

 		virtual TInt Spare3(TInt aVal, TAny* aPtr1, TAny* aPtr2) = 0;

 		virtual TInt Spare2(TInt aVal, TAny* aPtr1, TAny* aPtr2) = 0;

 		virtual TInt Spare1(TInt aVal, TAny* aPtr1, TAny* aPtr2) = 0;

 		};

 	/**

 	@prototype

 	CMountCB::MFileExtendedInterface interface provides extended interface for CMountCB to 

 	read a specified section of large file (size greater than 2GB - 1). 

 	The interface could be retrieved by calling CMountCB::GetInterface() with 

 	EFileExtendedInterface as an argument.

 	Sub classes of CMountCB who does support large file access will need to multiple-inherit 

 	with this class and implement the interface. The implementation of the interface will be 

 	retrieved via GetInterface() and provided to user by non-virtual APIs to avoid breaking

 	binary compatibility.

 	NOTE: Do not try to delete CMountCB::MFileExtendedInterface interface pointer!

 	@see CMountCB::GetInterface()

 	*/

 	class MFileExtendedInterface

 		{

 	public:

 		/**

 	    Reads a specified section of the file, regardless of the file's lock state.

 	    The function should leave with a suitable error code if it cannot complete

 	    successfully for any reason.

 		This function should be implemented in file systems supporting files 

 		of size greater than 2GB - 1.

 	    @param aName   A reference to a descriptor containing the full name of

 	                   the file to be read from

 	    @param aPos    The byte position to start reading from.

 	    @param aTrg    A pointer to the buffer into which data is to be read.

 	    @param aLength The length of data to be read, in bytes.

 	    @param aMessage

 		@leave KErrEof aPos is past the end of the file.

 		@see CMountCB::ReadSectionL()

 		*/

 		virtual void ReadSection64L(const TDesC& aName, TInt64 aPos, TAny* aTrg, TInt aLength, const RMessagePtr2& aMessage) = 0;

 		};

 	/**

 	Enumeration of the aInterfaceIDs used in GetInterface.

 	*/

 	enum TInterfaceIds

 		{

 		EAddFsToCompositeMount = 0,

 		EGetLocalDrive = 1,

 		EFileAccessor = 2,

 		EGetFileSystemSubType = 3,

 		EGetClusterSize = 4,

 		ELocalBufferSupport = 5,

 		EAddToCompositeMount = 6,

 		EGetProxyDrive = 7,

 		EFileExtendedInterface = 8

 		};

 	// File clamping support

 	TInt ClampFile(const TInt aDriveNo,const TDesC& aName,TAny* aHandle);

 	TInt UnclampFile(RFileClamp* aHandle);

 	IMPORT_C TInt IsFileClamped(const TInt64 aUniqueId);

 	TInt NoOfClamps();

 	// File accessor support

 	TInt GetFileUniqueId(const TDesC& aName, TInt64& aUniqueId);

 	TInt Spare3(TInt aVal, TAny* aPtr1, TAny* aPtr2);

 	TInt Spare2(TInt aVal, TAny* aPtr1, TAny* aPtr2);

 	TInt Spare1(TInt aVal, TAny* aPtr1, TAny* aPtr2);

 	// Extensions of interface

 	TInt FileSystemSubType(TDes& aName);

 	TInt FileSystemClusterSize();

 	void FileSystemName(TDes& aName);

 	// Large file support 

 	void ReadSection64L(const TDesC& aName,TInt64 aPos,TAny* aTrg,TInt aLength,const RMessagePtr2& aMessage);

     inline TInt CheckFileSystemMountable();

     inline TInt RequestFreeSpace(TUint64 &aFreeSpaceBytes);

     inline TInt MountedVolumeSize(TUint64& aVolSizeBytes);

     inline TInt GetCurrentFreeSpaceAvailable(TInt64 &aFreeSpaceBytes);

     inline TInt IsMountFinalised(TBool &aFinalised);

     inline TInt GetMaxSupportedFileSize(TUint64 &aSize);

 protected:

 	inline void SetMountNumber(TInt aMountNumber);

 	inline void SetDismounted(TBool aDismounted=ETrue);

 	inline TInt MountNumber() const;

 	inline TBool IsDismounted() const;

 	void SetProxyDriveDismounted();

 	TBool ProxyDriveDismounted();

     IMPORT_C CFileSystem* FileSystem() const;

 	/**

 	Return a pointer to a specified interface extension - to allow future extension of this class without breaking

 	binary compatibility.

 	@param aInterfaceId Interface identifier of the interface to be retrieved.

 	@param aInterface A reference to a pointer that retrieves the specified interface.

 	@param aInput An arbitrary input argument.

 	@return KErrNone If the interface is supported, KErrNotSupported otherwise.

 	*/	

 	IMPORT_C virtual TInt GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput);

 	// calls GetInterface() with tracepoints added

 	TInt GetInterfaceTraced(TInt aInterfaceId,TAny*& aInterface,TAny* aInput);

 private:

     void SetFileSystem(CFileSystem* aFS);

     //-- these factory methods mus be used to produce objects representing files, directories etc. as soon as all these objects are

     //-- associated with the mount, not the file sytem (file system is a factory for corresponding mounts)

     //-- corresponding CFileSystem:: methods must not be used. 

     //-- CMountCB has a reference to the CFileSystem that produced it. 

     CFileCB* NewFileL() const;

     CDirCB* NewDirL() const;

     CFormatCB* NewFormatL() const;

 protected:

 	TInt iMountNumber;  ///< Unique mount number set by the TDrive object representing the drive on which the object resides.

 	TUint iUniqueID;    ///< volume Unique ID. Set in MountL().

 	TInt64 iSize;       ///< Size of the volume. First set in MountL().

     /**

     A list of all open files on that mount.

     Set by the TDrive object representing the drive of which the mount resides.

     */

 	TDblQue<CFileCB> iMountQ;

     friend class TDrive;

 	friend class TFsAddCompositeMount;

 private:

 	TInt        iLockMount;

 	TDrive*     iDrive;

 	HBufC*      iVolumeName;

 	CMountBody* iBody;          ///< used for extending CMountCB functionality

 	};

 /**

 @internalTechnology

 MFileSystemSubType interface provides extended interface for CMountCB to retrieve sub type

 of mounted file systems.

 The interface could be retrieved by calling CMountCB::GetInterface() with EGetFileSystemSubType

 as an argument.

 If the file system does not support sub types, MFileSystemSubType cannot be retieved.

 Sub classes of CMountCB who does support sub types will need to multiple-inherit with

 this class and implement the interface. The implementation of the interface will be 

 retrieved via GetInterface() and provided to user by non-virtual APIs to avoid breaking

 binary compatibility.

 NOTE: Do not try to delete MFileSystemSubType interface pointer!

 @see CMountCB::GetInterface()

 */

 class MFileSystemSubType

 	{

 public:

 	/**

 	Retrieves file system's sub type name (E.g. FAT16), if the file system does not have sub 

 	types (E.g. Rofs), return the file system's name.

 	@param aName Returned descriptor contains file system name or sub type name.

 	@return KErrNone if successful. 

 	*/

 	virtual TInt SubType(TDes& aName) const = 0;

 	};

 /**

 @internalTechnology

 MFileSystemClusterSize interface provides extended interface for CMountCB to retrieve cluster size

 of mounted file systems.

 The interface could be retrieved by calling CMountCB::GetInterface() with EGetClusterSize

 as an argument.

 If the file system does not support clustering, MFileSystemClusterSize cannot be retieved.

 Sub classes of CMountCB who does support clustering will need to multiple-inherit with

 this class and implement the interface. The implementation of the interface will be 

 retrieved via GetInterface() and provided to user by non-virtual APIs to avoid breaking

 binary compatibility.

 NOTE: Do not try to delete MFileSystemSubType interface pointer!

 @see CMountCB::GetInterface()

 */

 class MFileSystemClusterSize

 	{

 public:

 	/**

 	Retrieves file system's cluster size

 	@return None-zero cluster size if successful.

 	*/

 	virtual TInt ClusterSize() const = 0;

 	};

 class CFileShare;

 /**

 @internalTechnology

 */

 class TAsyncReadRequest

 	{

 public:

 	TAsyncReadRequest(TInt64 aEndPos, CFileShare* aOwningShareP, CFsRequest* aRequestP);

 	TBool CompleteIfMatching(CFileShare* aOwningShareP, TRequestStatus* aStatusP, TInt aError);

 private:

 	TAsyncReadRequest();

 public:

 	TInt64 iEndPos;					// The request is completed file length >= iEndPos.

 	CFileShare* iOwningShareP;		// The share that owns this outstanding request.

 	const TRequestStatus* iStatusP;	// Used to identify the request when cancelling.

 	CSessionFs* iSessionP;			// The owning session of the original request.

 	RMessage2 iMessage;				// The message to be completed when data is available.

 	};

 /**

     @internalTechnology

     @released

     File share lock

     The lock specifies the lowest and highest position in the file to be locked.

     Note that files may have many locks on it, but overlapping sections cannot be locked.

     This is used by a file control block, a CFileCB object.

     @see CFileCB

 */

 class TFileShareLock

 	{

 public:

     TFileShareLock(const CFileShare* aOwner, TUint64 aPosLow, TUint64 aPosHigh);

     inline TUint64  PosLow()  const; 

     inline TUint64  PosHigh() const; 

     inline TBool MatchOwner(const CFileShare* aShare) const;

     TBool MatchByPos(TUint64 aPosLow, TUint64 aPosHigh) const;

 private:

     TFileShareLock();

     TFileShareLock(const TFileShareLock&);

     TFileShareLock& operator=(const TFileShareLock&);

 private:

 	const CFileShare* iOwner;   ///<The owning file share object.

 	TUint64 iPosLow;            ///<The start of the section of the file to be locked.

 	TUint64 iPosHigh;           ///<The end of the section of the file to be locked.

     friend class CFileCB;	

     };

 /** @internalTechnology */

 typedef RArray<TFileShareLock> TFileLocksArray;

 /**

 @publishedPartner

 @released

 A file server interface class representing an open file.

 An instance of this object is referred to as a file control block.

 A file control block needs to be created for a specific file to be able to

 access that file within a directory.

 A plug-in file system implements this class.

 */

 class CFileCB : public CFsDispatchObject

 	{

 public:

 	IMPORT_C CFileCB();

 	IMPORT_C ~CFileCB();

     IMPORT_C void InitL(TDrive* aDrive,TDrive* aCreatedDrive, HBufC* aName);

     inline void SetMount(CMountCB * aMount);

 	inline TDrive& Drive() const;

 	inline TDrive& CreatedDrive() const;

 	inline CMountCB& Mount() const;

 	inline HBufC& FileName() const;

 	inline HBufC& FileNameF() const;

     inline TInt UniqueID() const;

 	TInt FindLock(TInt aPosLow,TInt aPosHigh);

 	TInt AddLock(CFileShare* aFileShare,TInt aPos,TInt aLength);

 	TInt RemoveLock(CFileShare* aFileShare,TInt aPos,TInt aLength);

 	TInt CheckLock(CFileShare* aFileShare,TInt aPos,TInt aLength);

 	void RemoveLocks(CFileShare* aFileShare);

 	inline TShare Share() const;

 	inline void SetShare(TShare aShare);

 	inline TInt Size() const;

 	inline void SetSize(TInt aSize);

 	inline TInt Att() const;

 	inline void SetAtt(TInt aAtt);

 	inline TTime Modified() const;

 	inline void SetModified(TTime aModified);

 	inline TBool FileCorrupt() const;

 	inline void SetFileCorrupt(TBool aFileCorrupt);

 	inline TBool BadPower() const; 

 	inline void SetBadPower(TBool aBadPower);

 	inline TUint32 NameHash() const;

 	TInt CheckMount();

 	inline TInt BlockMap(SBlockMapInfo& aInfo, TInt64& aStartPos, TInt64 aEndPos=-1);

 	inline TInt LocalDrive(TBusLocalDrive*& aLocalDrive);

 	TBool LocalBufferSupport() const;

 	void SetLocalBufferSupport(TBool aEnabled);

 	/** File caching support methods */

 	CFileCache* FileCache() const;

 	TInt FairSchedulingLen() const;

 	void ResetReadAhead();

 	void SetDeleteOnClose();

 	TBool DeleteOnClose() const;

 	void SetNotifyAsyncReadersPending(TBool aNotifyAsyncReadersPending);

 	TBool NotifyAsyncReadersPending() const;

 	TInt CancelAsyncReadRequest(CFileShare* aShareP, TRequestStatus* aStatusP);

 	/** Extended API support methods */

 	TBool ExtendedFileInterfaceSupported();

 	void ReadL(TInt64 aPos,TInt& aLength,TDes8* aDes,const RMessagePtr2& aMessage, TInt aOffset);

 	void WriteL(TInt64 aPos,TInt& aLength,const TDesC8* aDes,const RMessagePtr2& aMessage, TInt aOffset);

 	void SetSizeL(TInt64 aSize);

 	IMPORT_C TInt64 Size64() const;

 	IMPORT_C void SetSize64(TInt64 aSize, TBool aDriveLocked);

     IMPORT_C void SetMaxSupportedSize(TUint64 aMaxFileSize);

     TInt64 CachedSize64() const;

 	void SetCachedSize64(TInt64 aSize);

 	TInt FindLock64(TInt64 aPosLow,TInt64 aPosHigh);

 	TInt AddLock64(CFileShare* aFileShare,TInt64 aPos,TInt64 aLength);

 	TInt RemoveLock64(CFileShare* aFileShare,TInt64 aPos,TInt64 aLength);

 	TInt CheckLock64(CFileShare* aFileShare,TInt64 aPos,TInt64 aLength);

     /**

     Renames the file with the full file name provided.

     Because the full name of the file includes the path, the function can

     also be used to move the file.

     It can be assumed that no other sub-session has access to the file:

     i.e. the file has not been opened in EFileShareAny share mode.

     It can also be assumed that the file has been opened for writing. 

     The function should leave with KErrAlreadyExists if aNewName already exists.

     An appropriate error code should also be generated if the function leaves

     before completion for any other reason.

 	@param aNewName The new full name of the file.

 	@see CFileCB::iFileName

     */

 	virtual void RenameL(const TDesC& aNewName) =0;

     /**

     Reads a specified number of bytes from the open file starting at

     the specified postition, and writes the result into a descriptor.

     It can be assumed that aPos is inside the file and aLength > 0.

     The file should only be read up to its end regardless of

     the value of aPos + aLength. The number of bytes read should be stored

     in aLength on return.

     If the function leaves before completion for any reason it should generate

     an appropriate error code, and in this situation,

     the arguments are not valid on return.

 	@param aPos     Represents a position relative to the start of the file

 	                where ReadL() should start to read.

 	@param aLength  On entry, specifies the number of bytes to be read

 	                from the file. On return, this should contain the number

 	                of bytes read, but this is not valid if the function leaves.

 	@param aDes     Pointer to a descriptor into which the data should be written.

 	@param aMessage

     */

     virtual void ReadL(TInt aPos,TInt& aLength,const TAny* aDes,const RMessagePtr2& aMessage) =0;

     /**

     Writes data to the open file.

     iModified and iSize are set by the file server after this function

     has completed successfully.

     It can be assumed that aPos is within the file range and aLength > 0.

     When aPos + aLength is greater than the file size then the file should

     be enlarged using SetSizeL(). The number of bytes written should be

     returned through the argument aLength. 

     If the function leaves before completion for any reason it should generate

     an appropriate error code, and in this situation the arguments are

     not valid on return.

    	@param aPos     Represents a position relative to the start of the file

    	                where WriteL() should start to write.

 	@param aLength  Specifies the number of bytes to be written to the file.

 	                On return, the number of bytes written, but this is not

 	                valid if the function leaves.

 	@param aDes     Pointer to a descriptor containing the data to be written

 	                to the file.

 	@param aMessage 

 	@see CFileCB::iModified

 	@see CFileCB::iSize

 	@see CFileCB::SetSizeL

     @leave KErrDiskFull The operation cannot be completed because the disk is full.

     */

 	virtual void WriteL(TInt aPos,TInt& aLength,const TAny* aDes,const RMessagePtr2& aMessage) =0;

     /**

     Extends or truncates the file by re-setting the file size.

     The function should not change iModified and iSize attributes of

     the file object: this is done by the file server.

     If the file is extended, nothing should be written in the extended area.

     The function should leave with a suitable error code on error detection.

     @param aSize The new file size in number of bytes.

     @leave KErrDiskFull The operation cannot be completed because the disk is full.

     @see CFileCB::iModified

 	@see CFileCB::iSize

     */

 	virtual void SetSizeL(TInt aSize) =0;

     /**

     Sets the attribute mask, iAtt, and the modified time of the file, iModified.

     If aMask|aVal does not equal zero, then aMask should be OR'ed with iAtt,

     whilst the inverse of aVal should be AND'ed with iAtt.

     If the modified flag is set in aMask then iModified should be set to aTime.

     The function should leave with a suitable error code on error detection.

 	@param aTime The new modified time, if the modified flag is set in aMask.

 	@param aMask Bit mask containing bits set (to 1) that are to be set (to 1)

 	             in iAtt.

 	@param aVal  Bitmask containing bits set (to 1) that are to be unset (to 0)

 	             in iAtt.

     @see CFileCB::iModified

 	@see CFileCB::iAtt

     */

     virtual void SetEntryL(const TTime& aTime,TUint aMask,TUint aVal) =0;

     /**

     Flushes, to disk, the cached information necessary for the integrity

     of recently written data, such as the file size.

     The function should leave with a suitable error code on error detection.

     */

 	virtual void FlushDataL() =0;

     /**

     Flushes, to disk, all cached file data (e.g. attributes, modification time,

     file size). 

     The modified bit in the file attributes mask should be cleared if

     the flush was successful.

     The function should leave with a suitable error code on error detection.

     */

 	virtual void FlushAllL() =0;

 	IMPORT_C virtual TInt Address(TInt& aPos) const;

 	IMPORT_C void SetArchiveAttribute();

 	/**

 	Block Map API interface 

 	*/

 	class MBlockMapInterface

 		{

 	public:

 		virtual TInt BlockMap(SBlockMapInfo& aInfo, TInt64& aStartPos, TInt64 aEndPos)=0;

 		};

 	/** 

 	An interface class which may optionally be returned by a file system

 	by calling GetInterface(EExtendedFileInterface, ...)

 	The purpose of this interface is twofold:

 	- to support fair scheduling (by use of the aOffset parameter)

 	- to enable large file support

 	*/

 	class MExtendedFileInterface

 		{

 	public:

 		/** 

 		Functionally equivalent to CFileCB::ReadL(), but supports large files and fair scheduling

 		Reads a specified number of bytes from the open file starting at

 		the specified postition, and writes the result into a descriptor.

 		@param aPos     Represents a position relative to the start of the file

 						where ReadL() should start to read. 

 						Note that the filesystem may not support positions above KMaxTInt,

 						in which case it leaves with KErrNotSupported.

 		@param aLength  On entry, specifies the number of bytes to be read

 						from the file. On return, this contains the number

 						of bytes read, this value is not valid if the function leaves.

 		@param aDes     Pointer to a descriptor into which the data is written.

 		@param aMessage A reference to a client message or an RLocalMessage.

 		@param aOffset	The offset into the descriptor where the data is to be written.

 						This is non-zero if the read was fair-scheduled

 		@see CFileCB::ReadL		

 		@see RLocalMessage				

 		*/

 		virtual void ReadL(TInt64 aPos,TInt& aLength,TDes8* aDes,const RMessagePtr2& aMessage, TInt aOffset) = 0;

 		/** 

 		Functionally equivalent to CFileCB::WriteL(), but supports large files and fair scheduling

 	    Writes data to the open file.

    		@param aPos     Represents a position relative to the start of the file

    						where WriteL() starts to write.

 						Note that the filesystem may not support positions above KMaxTInt,

 						in which case it leaves with KErrNotSupported.

 		@param aLength  Specifies the number of bytes to be written to the file.

 						On return this is the number of bytes written, this value is not

 						valid if the function leaves.

 		@param aDes     Pointer to a descriptor containing the data to be written

 						to the file.

 		@param aMessage A reference to a client message or an RLocalMessage

 		@param aOffset	The offset into the descriptor where the data is to be read from.

 						This is non-zero if the read was fair-scheduled

 		@see CFileCB::WriteL

 		@see RLocalMessage						

 		*/

 		virtual void WriteL(TInt64 aPos,TInt& aLength,const TDesC8* aDes,const RMessagePtr2& aMessage, TInt aOffset) = 0;

 		/** 

 		Functionally equivalent to CFileCB::SetSizeL(), but supports large files

 		Extends or truncates the file by re-setting the file size.

 		The function does not change the iModified and iSize attributes of

 		the file object: this is done by the file server.

 		If the file is extended, nothing is written in the extended area.

 		The function leaves with a suitable error code when an error is to detected.

 		@param aSize The new file size in bytes.

 		@leave KErrDiskFull The operation cannot be completed because the disk is full.

     	@see CFileCB::SetSizeL

 		@see CFileCB::iModified

 		@see CFileCB::iSize

 		*/

 		virtual void SetSizeL(TInt64 aSize) = 0;

 		};

 protected:

 	/**

 	Return a pointer to a specified interface extension - to allow future extension of this class without breaking

 	binary compatibility.

 	@param aInterfaceId Interface identifier of the interface to be retrieved.

 	@param aInterface A reference to a pointer that retrieves the specified interface.

 	@param aInput An arbitrary input argument.

 	@return KErrNone If the interface is supported, KErrNotSupported otherwise.

 	*/	

 	IMPORT_C virtual TInt GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput);

 	// calls GetInterface() with tracepoints added

 	TInt GetInterfaceTraced(TInt aInterfaceId,TAny*& aInterface,TAny* aInput);

    	enum TInterfaceIds

    		{

 		EBlockMapInterface = 0,

 		EGetLocalDrive = 1,

 		EExtendedFileInterface

    		};

     TUint64 MaxSupportedSize(void) const;

     inline TFileLocksArray& FileLocks(); 

 private:

 	void DemoteShare(CFileShare* aFileShare);

 	void PromoteShare(CFileShare* aFileShare);

 	RArray<TAsyncReadRequest>& AsyncReadRequests();

 	TInt AddAsyncReadRequest(CFileShare* aFileShareP, TInt64 aPos, TInt aLength, CFsRequest* aRequestP);

 	void NotifyAsyncReaders();

 protected:

     /**

     Inititally, the mode that the file was opened with, which defines the level

     of access allowed to the file. Set by the TDrive object

     (representing the drive on which the file resides) when the file

     control block is created.

     */

 	TShare iShare;

     /**

     The size of the file. This is the low 32 bit part of the file size.

     The upper 32 bit part of the file size is saved on the file server side 

     for File Systems supporting file size > 4GB - 1.

     File Systems supporting file size > 4GB - 1 shall use CFileCB::Size64() 

     to query the file size and CFileCB::SetSize64() to set file size. 

     */

     TInt iSize;

     /**

     The attributes of the file.

     */

 	TInt iAtt;

     /**

     The universal time at which the file was last modified.

     */

 	TTime iModified;

     /**

     Indicates whether the file that the object represents is corrupt:

     true if it is corrupt, false otherwise.

     */

 	TBool iFileCorrupt;

     /**

     Indicates whether a recent access to the file that the object represents

     failed due to KErrBadPower.

     */

 	TBool iBadPower;

 public:

 	/**

 	The full name of the file, including drive and extensions.

 	*/

 	HBufC* iFileName;

 	/**

 	The full name of the file, including drive and extensions - Folded.

 	*/

 	HBufC* iFileNameF;

 private:

 	TUint32	            iNameHash;

 	TDrive*             iCreatedDrive;

 	TDrive*             iDrive;

 	CMountCB*           iMount;

 	TFileLocksArray*    iFileLocks; ///< an array of file position locks

 	TDblQueLink         iMountLink;

 private:

 	CFileBody* iBody;

 	friend class TDrive;

 	friend class CMountCB;

 	friend class CFileShare;

 	friend class TFsFileRead;

 	friend class TFsFileWrite;

 	friend class TFsFileSetSize;

 	friend class TFsFileReadCancel;

 	friend class TFsFileDuplicate;

 	friend class TFsFileRename;

 	friend class CCompFileCB;

 	friend class CFileCache;

 	};

 /**

 Helper class to construct a dummy RMessage2 object. This allows the file server to 

 read and write local buffers to a file system's CFileCB-derived interface.

 @internalTechnology

 */

 class RLocalMessage : public RMessage2

 	{

 public:

 	inline RLocalMessage();

 	inline void InitHandle();

 	inline void SetFunction(TInt aFunction);

 	inline void SetArgs(TIpcArgs& aArgs);

 	inline TInt Arg(TInt aIndex) const;

 	};

 /**

 @publishedPartner

 @released

 A file server interface class representing an open file that is being shared.

 For example multiple reading of the same file.

 @see CFileCB

 @see TFileMode

 */

 NONSHARABLE_CLASS(CFileShare) : public CFsDispatchObject

 	{

 public:

 	CFileShare(CFileCB* aFileCB);

 	~CFileShare();

 	TInt CheckMount();

 	void InitL();

 	inline CFileCB& File();

 	// For serialising aync requests 

 	TBool RequestStart(CFsMessageRequest* aRequest);

 	void RequestEnd(CFsMessageRequest* aRequest);

 	TBool RequestInProgress() const;

 	inline TBool IsFileModeBig();

 public:

 	/**

 	File share mode. The mode in which the file was opened first.

 	@see TFileMode.

 	*/

 	TUint iMode;   

 	/**

 	Current file position. This is the position at which reading and writing takes place.

 	*/

 	TInt64 iPos;

 	/**

 	Error condition due to flush.

 	*/

 	TInt iFlushError;

 private:

 	CFileCB* iFile;

 	// A pointer to the current request. Used for serializing client 

 	// async read/write requests which might otherwise be processed out

 	// of order due to fair scheduling

 	CFsMessageRequest* iCurrentRequest;	

 	};

 /**

 @publishedPartner

 @released

 A file server interface class representing an open directory

 An instance of this object is referred to as a directory control block.

 A directory control block must be created for a specific directory to access

 that directory within a volume.

 A plug-in file system implements this class.

 */

 class CDirCB : public CFsDispatchObject

 	{

 public:

 	IMPORT_C CDirCB();

 	IMPORT_C ~CDirCB();

 	TInt CheckMount();

 	IMPORT_C void InitL(TDrive* aDrive);

 	inline void SetMount(CMountCB * aMount){iMount=aMount;};

 	inline TDrive& Drive() const;

 	inline CMountCB& Mount() const;

 	inline TBool Pending() const; 

 	inline void SetPending(TBool aPending);

     /**

     Gets information from the first suitable entry in the directory,

     starting from the current read position.

     The function should read successive entries until a suitable entry is found.

     An entry is suitable if the entry attributes match the criteria set by this

     object's attributes, which are set on initialisation.

     For example, if the directory control block has the attribute

     KEntryAttMaskSupported, and the file has the attribute KEntryAttVolume,

     then the entry will be deemed unsuitable and the next entry will be read.

     This function is called by the file server.

     If, on return, the entry's full file name, TEntry::iName, is longer than

     the maximum buffer size, then the entry cannot be returned to the client.

     In this case the file server will set iPending to true and will call

     StoreLongEntryName() before calling this function again.

     In this case (when iPending is true), the function should re-read

     the last entry to be read; it should also set iPending to false and

     should not advance the current read position.

     The time stored in the iModified member of anEntry should not be converted,

     but left as UTC time.

     When storing the iName member of anEntry, the current (.),

     or parent marker (..) in the directory should not be returned.

     If the KEntryAttAllowUid flag is set in the iAtt member of anEntry, then

     the entry UID type of an entry will be read. If, on reading the UID from

     a file, KErrCorrupt is generated, because the file is corrupt,

     ReadL() should not leave with this error message, but should return

     as normal.

     If any other errors are raised the function should leave.

     All of the properties of a TEntry, other than the UID types, are always read.

     ReadL() should leave with a suitable error code if it cannot complete

     successfully for any reason. 

     @param anEntry Entry information object.

     */

 	virtual void ReadL(TEntry& anEntry) =0;

 public:

 	IMPORT_C virtual void StoreLongEntryNameL(const TDesC& aName);

 protected:

 	/**

 	Return a pointer to a specified interface extension - to allow future extension of this class without breaking

 	binary compatibility.

 	@param aInterfaceId Interface identifier of the interface to be retrieved.

 	@param aInterface A reference to a pointer that retrieves the specified interface.

 	@param aInput An arbitrary input argument.

 	@return KErrNone If the interface is supported, KErrNotSupported otherwise.

 	*/	

 	IMPORT_C virtual TInt GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput);

 protected:

     /**

     Bitmask of the attributes of interest.

     Set using the the TDrive friend class instance representing

     the directory's drive after the object is made.

     */

 	TUint iAtt;

 	/**

 	Set after construction using the TDrive friend class instance representing

 	the directory's drive.

 	*/

 	TUidType iUidType;

     /**

     Flag to indicate whether preceding entry details should be returned when

     multiple entries are being read.

     */

 	TBool iPending;

 	friend class TDrive;

 private:

 	TDrive* iDrive;

 	CMountCB* iMount;

 	TUint32 iReserved;				// Reserved for future expansion

 	};

 class CFormatCBBody;

 /**

 @publishedPartner

 @released

 A file server interface class representing a format operation on a disk.

 An instance of this object is referred to as a format control block.

 The type of format operation to be applied depends on the type of disk,

 and is stored in iMode. Each format operation has a number of steps and

 is kept track of using iCurrentStep.

 A format control block needs to be created for a specific mount control block

 for the disk controlled via that mount to be formatted.

 A plug-in file system provides an implementation of this class.

 */

 class CFormatCB : public CFsDispatchObject

 	{

 public:

 	IMPORT_C CFormatCB();

 	IMPORT_C ~CFormatCB();

 	IMPORT_C TInt CheckMount();

     void InitL(TDrive* aDrive, TFormatMode aMode);

     void SetFormatParameters(const TLDFormatInfo* apLDFormatInfo);

 	TInt SetFormatParameters(const TVolFormatParam* apVolFormatParam);

     inline TDrive& Drive() const;

 	inline CMountCB& Mount()  const;

 	inline TFormatMode Mode()  const; 

 	inline TInt& CurrentStep();

     /**

     Performs a formatting step on the drive.

     The step performed should depend on the values of iMode and iCurrentStep. 

     It can be assumed that there are no resources open on the mount,

     that the media is formattable, and that the media is not write protected.

     If iMode == EQuickFormat, then only meta data is to be written.

     This should be carried out in a single step, with iCurrentStep set

     to zero on completion.

     If iMode != EQuickFormat, then the format step performed by

     this function should depend on iCurrentStep. When the function

     returns with iCurrentStep set to zero, the formatting of the drive is complete.

     On error detection, the function should leave with an appropriate error code.

     @see CFormatCB::iMode

     @see CFormatCB::iCurrentStep

     */

 	virtual void DoFormatStepL() =0;

 protected:

     /** Enumeration of the aInterfaceIDs used in GetInterface */

 	enum TInterfaceIds

 		{

 		ESetFmtParameters = 1, ///< used in implementation of SetFormatParameters(const TVolFormatParam* apVolFormatParam)

 		};

 	/**

 	Return a pointer to a specified interface extension - to allow future extension of this class without breaking

 	binary compatibility.

 	@param aInterfaceId Interface identifier of the interface to be retrieved.

 	@param aInterface A reference to a pointer that retrieves the specified interface.

 	@param aInput An arbitrary input argument.

 	@return KErrNone If the interface is supported, KErrNotSupported otherwise.

 	*/	

 	IMPORT_C virtual TInt GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput);

 protected:

 	TInt                  iCurrentStep; ///< current format step counter 100...0

 	TFormatMode           iMode;        ///< Format mode. This is set by the file server when this objetc is instantiated.

     TSpecialFormatInfoBuf iSpecialInfo; ///< Buffer containing user-specified format parameters.

 private:

     TDrive*         iDrive; 

 	CMountCB*       iMount;  ///< parent Mount   

     CFormatCBBody*  iBody;   ///< additional data holder

 	};

 /**

 @publishedPartner

 @released

 A file server interface class representing a raw disk.

 An instance of this object is referred to as a raw disk control block.

 This is not an abstract base class and does not need to be derived from

 when implementing a file system. This is because direct disk access is

 implemented by the file server directly calling RawReadL() and RawWriteL()

 from the derived CMountCB object of the file system.

 */

 NONSHARABLE_CLASS(CRawDiskCB) : public CFsDispatchObject

 	{

 public:

 	CRawDiskCB();

 	~CRawDiskCB();

 	void InitL(CMountCB* aMount,TBool aIsWriteProtected);

 	inline CMountCB& Mount();

 	inline TDrive& Drive();

 	inline TBool IsWriteProtected() const;

 	inline void SetChanged();

 private:

 	enum { EWriteProtected = 1, EChanged = 2 };

 	inline void SetWriteProtected();

 	inline TBool IsChanged() const;

 private:

 	CMountCB* iMount;

 	TUint32 iFlags;

 	};

 class CFileSystemBody;

 /**

 @publishedPartner

 @released

 A file server interface class, representing the factory class for a file system.

 A plug-in file system implements this class.

 Creates objects derived from CMountCB, CFileCB, CDirCB and CFormatCB.

 @see CMountCB

 @see CFileCB

 @see CDirCB

 @see CFormatCB

 */

 class CFileSystem : public CFsObject

 	{

 public:

 	IMPORT_C CFileSystem();

 	IMPORT_C ~CFileSystem();

 	IMPORT_C virtual TInt Remove();

 	IMPORT_C virtual TBool QueryVersionSupported(const TVersion& aVer) const;

 	IMPORT_C virtual TBool IsExtensionSupported() const;

 	IMPORT_C TBool IsProxyDriveSupported();

 	IMPORT_C void SetLibrary(RLibrary aLib);

 	IMPORT_C RLibrary Library() const;

 // Pure virtual

 	/**

     Installs the file system.

     The function should set the name of the file system object through a call

     to CObject::SetName(), thus making it accessible, internally, 

     using FileSystems->FindByFullName(). This enables the file server

     to find and handle installed file systems. 

     The function should also set the file system version.

     The version is determined by the file system implementation.

     It is used in calls to CFileSystem::QueryVersionSupported().

     This function is called as a result of a call to RFs::AddFileSystem().

     @return KErrNone if succesful; otherwise one of the other  system-wide error

     codes.

     @see RFs::AddFileSystem

     @see CObject::SetName

     @see RFs

     @see CObject

     */

 	virtual TInt Install() =0;

 	/**

 	Creates a new mount control block, a CMountCB derived object. 

     On success, a pointer to the new mount object should be returned,

     otherwise the function should leave.

 	@return A pointer to the new mount object.

     @see CMountCB

 	*/

 	virtual CMountCB* NewMountL() const =0;

 	/**

 	Creates a new file control block, i.e. a CFileCB derived object.

     On success, a pointer to the new file object should be returned,

     otherwise the function should leave.

     @return A pointer to the new file object.

     @see CFileCB

 	*/

 	virtual CFileCB* NewFileL() const =0;

 	/**

 	Creates a new directory control block, i.e. a CDirCB derived object.

     On success, a pointer to the new directory control block should be returned,

     otherwise the function should leave.

     @return A pointer to the new directory object.

     @see CDirCB

 	*/

 	virtual CDirCB* NewDirL() const =0;

 	/**

 	Creates a new volume format control block, i.e. a CFormatCB derived object.

     On success, a pointer to the new volume format control block should be returned,

     otherwise the function should leave.

     @return A pointer to the new volume format object.

     @see CFormatCB

 	*/

 	virtual CFormatCB* NewFormatL() const =0;

 	/**

 	Retrieves drive information.

     The function should set anInfo.iMediaAtt and anInfo.iType according to

     the specified drive number.

     Note that anInfo.iDriveAtt will already have been set by the calling

     function.

     The function can obtain the necessary information by calling

     the appropriate TBusLocalDrive::Caps() function using the argument aDriveNumber.

 	@param anInfo       On return, contains the drive information.

 	@param aDriveNumber The drive number.

 	*/

 	IMPORT_C virtual void DriveInfo(TDriveInfo& anInfo,TInt aDriveNumber) const;

     virtual TInt DefaultPath(TDes& aPath) const;

 	/** Enumeration of the aInterfaceIDs used in GetInterface.*/

 	enum TInterfaceIds

 		{

 		EProxyDriveSupport = 0,

 		EExtendedFunctionality, ///< corresponds to MFileSystemExtInterface

 		};

     /** This is interface corresponds to the extended CFileSystem functionality*/

     class MFileSystemExtInterface

         {

     public:

         virtual CMountCB* NewMountExL(TDrive* apDrive, CFileSystem** apFileSystem, TBool aForceMount, TUint32 aFsNameHash) = 0;

         virtual TInt GetSupportedFileSystemName(TInt aFsNumber, TDes& aFsName) const = 0;   

         };

 public:	

      CMountCB* NewMountExL(TDrive* apDrive, CFileSystem** apFileSystem, TBool aForceMount, TUint32 aFsNameHash);

      TInt GetSupportedFileSystemName(TInt aFsNumber, TDes& aFsName);

 protected:	

 	/**

 	Return a pointer to a specified interface extension - to allow future extension of this class without breaking

 	binary compatibility.

 	@param aInterfaceId Interface identifier of the interface to be retrieved.

 	@param aInterface A reference to a pointer that retrieves the specified interface.

 	@param aInput An arbitrary input argument.

 	@return KErrNone If the interface is supported, KErrNotSupported otherwise.

 	*/	

 	IMPORT_C virtual TInt GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput);

 protected:

 	TVersion iVersion;

 private:

 	RLibrary         iLibrary;  ///< *.fsy file system plugin dll handle

     CFileSystemBody* iBody;     ///< extension of this class, used to provide extended functionality w/o changing this class size (BC issue)

 friend class TDrive;

 	};

 /**

 @publishedPartner

 @released

 Base abstract class.

 Interface between a local plugin file system and a media subsystem.

 @see CLocalProxyDrive

 @see CBaseExtProxyDrive

 */

 class CProxyDrive : public CBase	

 	{

 public:

 	CProxyDrive(CMountCB* aMount);

 	~CProxyDrive();		

 	inline CMountCB* Mount() const;

 	inline void SetMount(CMountCB *aMount);

 // virtual

 	IMPORT_C virtual TInt ControlIO(const RMessagePtr2& aMessage,TInt aCommand,TAny* aParam1,TAny* aParam2);

 	IMPORT_C virtual TInt Read(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt aThreadHandle,TInt aOffset,TInt aFlags);

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

 	IMPORT_C virtual TInt DeleteNotify(TInt64 aPos, TInt aLength);

 	IMPORT_C virtual TInt GetLastErrorInfo(TDes8& aErrorInfo);

 	inline TInt LocalBufferSupport();

 // pure virtual

 	/**

 	Initialise the proxy drive. 

 	Derived class must provide an implementation for it.

 	@return KErrNone if successful, otherwise one of the system-wide error codes.

 	*/

 	virtual TInt Initialise()=0;

 	/**

 	It invokes Dismounted() on the proxy drive.

 	Derived class must provide an implementation for it. 

 	@return KErrNone if successful, otherwise one of the system-wide error codes.

 	*/

 	virtual TInt Dismounted()=0;

 	/**

 	Increase the size of the proxy drive by the specified length (in bytes).

 	Derived class must provide an implementation for it. 

 	@param aLength The length (in bytes) of which the drive is to be increased by.

 	@return KErrNone if successful, otherwise one of the system-wide error codes.

 	*/

 	virtual TInt Enlarge(TInt aLength)=0;

 	/**

 	Reduce the size of the proxy drive by removing the specified length

 	(in bytes) starting at the specified position.

 	Derived class must provide an implementation for it.

 	@param aPos    The start position of area to be removed.

 	@param aLength The length/size (in bytes) by which the drive is to be reduced.

 	@return System-wide error codes based on the status of the operation.

 	*/	

 	virtual TInt ReduceSize(TInt aPos, TInt aLength)=0;

 	/**

 	Read from the proxy drive.

 	Derived class must provide an implementation for it.

 	@param aPos    The address from where the read begins.

 	@param aLength The length of the read.

 	@param aTrg    A descriptor of the memory buffer from which to read.

 	@param aThreadHandle The handle-number representing the drive thread.

 	@param aOffset Offset into aTrg to read the data from.

 	@return System-wide error codes based on the status of the operation.

 	*/

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

 	/**

 	Read from the proxy drive.

 	Derived class must provide an implementation for it.

 	@param aPos    The address from where the read begins.

 	@param aLength The length of the read.

 	@param aTrg    A descriptor of the memory buffer from which to read.

 	@return System-wide error codes based on the status of the operation.

 	*/

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

 	/**

 	Write to the proxy drive.

 	Derived class must provide an implementation for it.

 	@param aPos    The address from where the write begins.

 	@param aLength The length of the write.

 	@param aSrc    A descriptor of the memory buffer from which to write.

 	@param aThreadHandle The handle-number representing the drive thread.

 	@param aOffset Offset into aSrc to write the data to.

 	@return System-wide error codes based on the status of the operation.

 	*/

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

 	/**

 	Write to the proxy drive.

 	Derived class must provide an implementation for it.

 	@param aPos    The address from where the write begins.

 	@param aSrc    A descriptor of the memory buffer from which to write.

 	@return System-wide error codes based on the status of the operation.

 	*/

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

 	/**

 	Get the proxy drive's capabilities information.

 	Derived class must provide an implementation for it.

 	@param anInfo A descriptor of the connected drives capabilities.

 	@return System-wide error codes based on the status of the operation.

 	*/

 	virtual TInt Caps(TDes8& anInfo)=0;

 	/**

 	Format the connected drive.

 	Derived class must provide an implementation for it.

 	@param anInfo Device specific format information.

 	@return System-wide error codes based on the status of the operation.

 	*/

 	virtual TInt Format(TFormatInfo& anInfo)=0;

 	/**

 	Format the proxy drive.

 	Derived class must provide an implementation for it.

 	@param aPos    The position of the data which is being formatted.

 	@param aLength The length of the data which is being formatted.

 	@return System-wide error codes based on the status of the operation.

 	*/

 	virtual TInt Format(TInt64 aPos,TInt aLength)=0;

 	/**

 	Set the mount information on the proxy drive.

 	Derived class must provide an implementation for it.

 	@param aMountInfo Information passed down to the media driver. 

 					  The meaning of this information depends on the media driver.

 	@param aMountInfoThreadHandle  Message thread handle number.

 	@return System-wide error codes based on the status of the operation.

 	*/

 	virtual TInt SetMountInfo(const TDesC8* aMountInfo,TInt aMountInfoThreadHandle=KCurrentThreadHandle)=0;

 	/**

 	Forces a remount on the proxy drive

 	Derived class must provide an implementation for it.