// 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 "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members

// which accompanies this distribution, and is available

// at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// f32\inc\f32fsys.h

// 

//

/**

 @file

 @publishedPartner

 @released

*/

#if !defined(__F32FSYS_H__)

#define __F32FSYS_H__

#if !defined(__F32FILE_H__)

#include <f32file.h>

#endif

//

#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 CFsObjectCon;

class CFileCache;

/**

@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 MountMedia(TBool aForceMount);

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

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

public:

	void DismountLock();

	TInt DismountUnlock();

	TInt DismountLocked() const;

	void SetDismountPending(TBool aPending);

	TBool DismountPending() const;

	void ForceDismount();

	TInt ActiveMounts() const;

	void ReactivateMounts();

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

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

	TInt ClampsOnDrive(TBool aRequestDismount=EFalse, TInt (*aFunc)(TAny*)=NULL,TAny* aParamList=NULL);

	TInt SetCallbackRequired(TInt (*aFunc)(TAny*),TAny* aParamList);

	IMPORT_C void FlushOutstandingDismount(TBool *aDismountRequired);

	TInt ClearDeferredDismount();

	IMPORT_C void SetClampFlag(TBool aClamped);

	IMPORT_C TBool ClampFlag();

	inline void Lock();

	inline void UnLock();

	TBool ReMount(CMountCB& aMount);

    TBool RequestFreeSpaceOnMount(TUint64 aFreeSpaceRequired); 

    TInt  MountedVolumeSize(TUint64& aSize); 

private:

	void MountMediaL(TBool aForceMount,CMountCB*& aMount);

	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,TInt 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();

private:

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

    enum 

    { 

        ENotifyOff       = 0x01, 

        EDismountPending = 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;

friend class LocalDrives;		// for access to iChanged flag

	};

class CFileCB;

class CDirCB;

/**

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

	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 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.