f32file.h

Go to the documentation of this file.

// 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:
//
 
#if !defined(__F32FILE_H__)
#define __F32FILE_H__
 
#if !defined(__E32BASE_H__)
#include <e32base.h>
#endif
 
#ifndef SYMBIAN_ENABLE_PUBLIC_PLATFORM_HEADER_SPLIT
// Old implementation including platform e32svr.h (which includes the several other platform headers)...
#if !defined(__E32SVR_H__)
#include <e32svr.h>
#endif
#include <e32ldr.h>
#else
// New implementation including only the public headers needed for f32file.h...
#include <e32ldr.h>
// And the public headers previously included via e32svr.h but otherwise not needed for f32file.h...
#include <e32def.h>
#include <e32event.h>
#include <e32debug.h>
#include <e32keys.h> 
#endif
 
 
//-------------------------------------------------------------------------------------------------------------------
/*
    A brief description of the structure of paths and filenames in the Symbian OS.
 
    A full file or directory name consists of four components:
        - the drive: a single letter followed by a colon.
        - the path, starting with a backslash and ending with the final backslash in the name. The backslashes divide the path into components.
        - the file name: everything from the character following the last backslash to the character preceding the final dot.
        - optional extension, which consists of everything after the final dot. 
 
    A directory is identified by a trailing slash: thus, 'c:\\wrd\\' indicates a directory, but 'c:\\wrd' indicates a file with no extension. 
 
    There are some restrictions that apply to the file or directory names.
        - full name should not contain wild cards ('?' or '*' characters)
        - file or directory name should not contain illegal characters like '<', '>', ':', '"', '/', '|' and '\000'. 
        - file or directory name containing only white space characters is illegal.
        - white space characters are those one that are identified by TChar::IsSpace(). ASCII and all UNICODE white space characters
          are considered equivalent. E.g. characters with codes 0x20, U+0020, U+3000, U+2009, etc. considered as equivalent white spaces.
*/
//-------------------------------------------------------------------------------------------------------------------
 
 
const TInt KDefaultDrive=KMaxTInt;
 
 
 
 
const TInt KDriveAbsent=0x00;
 
 
 
 
const TInt KFileServerDefaultMessageSlots=-1;
 
 
 
 
const TInt KEntryArraySize=(0x200*sizeof(TText));
 
 
 
 
const TInt KPathDelimiter='\\';
 
 
 
 
const TInt KDriveDelimiter=':';
 
 
 
 
const TInt KExtDelimiter='.';
 
 
 
 
const TInt KMaxDrives=26;
 
 
const TInt KMaxProxyDrives=KMaxDrives-KMaxLocalDrives;
 
 
typedef TBuf8<KMaxDrives> TDriveList;
 
 
 
const TInt KMaxDriveName=0x02;
 
 
 
 
typedef TBuf<KMaxDriveName> TDriveName;
 
 
 
 
const TInt KMaxFSNameLength=0x0020;
 
 
 
 
typedef TBuf<KMaxFSNameLength> TFSName;
 
 
 
 
const TUint KEntryAttNormal=0x0000;
 
 
 
 
const TUint KEntryAttReadOnly=0x0001;
 
 
 
 
const TUint KEntryAttHidden=0x0002;
 
 
 
 
const TUint KEntryAttSystem=0x0004;
 
 
 
 
const TUint KEntryAttVolume=0x0008;
 
 
 
 
const TUint KEntryAttDir=0x0010;
 
 
 
 
const TUint KEntryAttArchive=0x0020;
 
 
 
 
const TUint KEntryAttXIP=0x0080;
 
 
 
 
const TUint KEntryAttRemote=0x0100;
 
 
 
 
const TUint KEntryAttMaskFileSystemSpecific=0x00FF0000;
 
 
 
 
const TUint KEntryAttMatchMask=(KEntryAttHidden|KEntryAttSystem|KEntryAttDir);
 
 
 
 
 
const TUint KEntryAttMaskSupported=0x3f;
 
 
 
 
const TUint KEntryAttMatchExclusive=0x40000000;
 
 
 
 
const TUint KEntryAttUnique=0x01000000;
 
 
 
 
const TUint KEntryAttMatchExclude=0x08000000;
 
 
 
 
const TUint KEntryAttAllowUid=0x10000000;
 
 
 
 
const TUint KEntryAttPacked = 0x01000000;
 
 
const TUint KMaxMapsPerCall = 0x8;
 
 
 
 
enum TNotifyType
    {
    ENotifyAll=0x01,
    
    
    ENotifyEntry=0x02,
    
    
    ENotifyFile=0x04,
    
    
    ENotifyDir=0x08,
    
    
    ENotifyAttributes=0x10,
    
    
    ENotifyWrite=0x20,
    
    
    ENotifyDisk=0x40
    };
 
enum TNotifyDismountMode
    {
    EFsDismountRegisterClient=0x01,
    
    EFsDismountNotifyClients=0x02,
    
    EFsDismountForceDismount=0x03,
    };
 
 
enum TFileCacheFlags
    {
    EFileCacheReadEnabled = 0x01,
 
    EFileCacheReadOn = 0x02,
 
    EFileCacheReadAheadEnabled = 0x04,  
 
    EFileCacheReadAheadOn = 0x08,   
 
    EFileCacheWriteEnabled = 0x10,  
 
    EFileCacheWriteOn = 0x20,   
    };
 
enum TQueryVolumeInfoExtCmd
    {
    EFileSystemSubType,
    
    EIOParamInfo,
 
    EIsDriveSync,
 
    EIsDriveFinalised,
    
    EFSysExtensionsSupported,
    };
 
class TVolumeIOParamInfo
    {
public:
    TInt iBlockSize;
    
    TInt iClusterSize;
 
 
    TInt iRecReadBufSize;
    TInt iRecWriteBufSize;
 
 
    TUint64 iMaxSupportedFileSize;
 
private:
    /*
    Reserved space for future use
    */
    TInt iReserved[2];
    };
 
enum TDriveNumber
    {
    EDriveA,   EDriveB,   EDriveC,   EDriveD,   EDriveE,
    EDriveF,   EDriveG,   EDriveH,   EDriveI,   EDriveJ,
    EDriveK,   EDriveL,   EDriveM,   EDriveN,   EDriveO, 
    EDriveP,   EDriveQ,   EDriveR,   EDriveS,   EDriveT,
    EDriveU,   EDriveV,   EDriveW,   EDriveX,   EDriveY,
    EDriveZ
    };
 
 
 
 
enum TEntryKey
    {
    ESortNone=0,
 
 
    ESortByName,
    
    
    ESortByExt,
    
    
    ESortBySize,
    
    
    ESortByDate,
    
    
    ESortByUid,
    
    
    EDirsAnyOrder=0,
    
    
    EDirsFirst=0x100,
    
    
    EDirsLast=0x200,
    
    
    EAscending=0,
    
    
    EDescending=0x400,
    
    
    EDirDescending=0x800
    };
 
 
 
 
enum TFileMode
    {
    EFileShareExclusive,
 
 
    EFileShareReadersOnly,
 
 
    EFileShareAny,
 
 
    EFileShareReadersOrWriters,
 
 
    EFileStream=0,
 
 
    EFileStreamText=0x100,
 
 
    EFileRead=0,
 
 
    EFileWrite=0x200,
 
    EFileReadAsyncAll=0x400,
 
    EFileWriteBuffered  =0x00000800,
 
    EFileWriteDirectIO  =0x00001000,
 
    EFileReadBuffered   =0x00002000,
 
    EFileReadDirectIO   =0x00004000,
 
    EFileReadAheadOn    =0x00008000,
 
    EFileReadAheadOff   =0x00010000,
 
    EDeleteOnClose      =0x00020000,
    
    EFileBigFile        =0x00040000,
    
    EFileSequential     =0x00080000
 
    };
 
 
 
 
const TUint KFileShareMask=0xff;
 
 
 
 
enum TFormatMode 
    {
    EHighDensity,
    
    
    ELowDensity,
 
 
    EFullFormat=0,
 
 
    EQuickFormat=0x100,
    
    
    ESpecialFormat=0x200,
 
    EForceErase=0x400,
 
    EForceFormat = 0x800,
 
    };
 
 
 
 
enum TSeek
    {
    ESeekAddress,
 
 
    ESeekStart,
 
 
    ESeekCurrent,
 
 
    ESeekEnd
    };
 
class TBlockMapEntry : public TBlockMapEntryBase
    {
public:
    IMPORT_C TBlockMapEntry();
    IMPORT_C void SetNumberOfBlocks( TUint aNumberOfBlocks );
    IMPORT_C void SetStartBlock( TUint aStartBlock );
    };
 
typedef TBuf8<KMaxMapsPerCall*sizeof(TBlockMapEntry)> TBlockArrayDes;
 
struct SBlockMapInfo : public SBlockMapInfoBase
    {
    TBlockArrayDes iMap;
    };
 
enum TBlockMapUsage
    {
    /* */
    EBlockMapUsagePaging,
    /* */
    ETestDebug
    };
 
class TEntry
    {
public:
    IMPORT_C TEntry();
    IMPORT_C TEntry(const TEntry& aEntry);
    IMPORT_C TEntry& operator=(const TEntry& aEntry);
    IMPORT_C TBool IsReadOnly() const;
    IMPORT_C TBool IsHidden() const;
    IMPORT_C TBool IsSystem() const;
    IMPORT_C TBool IsDir() const;
    IMPORT_C TBool IsArchive() const;
    inline const TUid& operator[](TInt anIndex) const;
    inline TBool IsUidPresent(TUid aUid) const;
    inline TBool IsTypeValid() const;
    inline TUid MostDerivedUid() const;
    IMPORT_C TInt64 FileSize() const;
    inline void SetFileSize(TInt64 aFileSize);
 
private:
    inline void Copy(const TEntry& aEntry);
    inline void Unpack();
 
public:
    TUint iAtt;
 
 
    TInt iSize;
    
    
    TTime iModified;
    
    
    TUidType iType;
    
    
    TBufC<KMaxFileName> iName;
    
private:    
    TUint32 iSizeHigh; 
    TUint32 iReserved;
    };
 
 
 
 
class RDir;
class TEntryArray
    {
public:
    IMPORT_C TEntryArray();
    IMPORT_C TInt Count() const;
    IMPORT_C const TEntry& operator[](TInt anIndex) const;
private:
    TInt iCount;
    TInt iIndex;
    const TEntry* iPos;
    TBuf8<KEntryArraySize> iBuf;
    friend class RDir;
    friend class RFs;
    friend class TRawEntryArray;
    };
 
 
 
 
class TDriveInfo
    {
public:
    TMediaType iType;
 
 
    TBatteryState iBattery;
 
 
    TUint iDriveAtt;
 
 
    TUint iMediaAtt;
 
 
    TConnectionBusType iConnectionBusType;
    };
 
 
 
 
class TVolumeInfo
    {
public:
    IMPORT_C TVolumeInfo();
    
    TDriveInfo iDrive;
 
 
    TUint iUniqueID;
 
 
    TInt64 iSize;
 
 
    TInt64 iFree;
 
 
    TBufC<KMaxFileName> iName;
    
    TFileCacheFlags iFileCacheFlags;
    
    TUint8 iVolSizeAsync : 1;
 
private:    
    TUint8  i8Reserved1;    
    TUint16 i16Reserved1;   
    TUint32 i32Reserved1;   
    TUint32 i32Reserved2;   
    };
 
 
 
 
class TDriveUnit
    {
public:
    inline TDriveUnit() {};
    IMPORT_C TDriveUnit(TInt aDrive);
    IMPORT_C TDriveUnit(const TDesC& aDrive);
    IMPORT_C TDriveUnit& operator=(TInt aDrive);
    IMPORT_C TDriveUnit& operator=(const TDesC& aDrive);
    inline operator TInt() const;
    IMPORT_C TDriveName Name() const;
private:
    TInt iDrive;
    };
 
 
 
 
class RFs;
//
class TParseBase
    {
private:
    struct SField {TUint8 pos;TUint8 len;TUint8 present;TUint8 filler;};
    enum TField {EDrive,EPath,EName,EExt,EMaxFields};
    enum TWild {EWildName=0x01,EWildExt=0x02,EWildEither=0x04,EIsRoot=0x08,EWildIsKMatchOne=0x10,EWildIsKMatchAny=0x20};
public:
    IMPORT_C TParseBase();
    IMPORT_C TInt PopDir();
    IMPORT_C TInt AddDir(const TDesC& aName);
    IMPORT_C const TDesC& FullName() const;
    IMPORT_C TPtrC Drive() const;
    IMPORT_C TPtrC Path() const;
    IMPORT_C TPtrC DriveAndPath() const;
    IMPORT_C TPtrC Name() const;
    IMPORT_C TPtrC Ext() const;
    IMPORT_C TPtrC NameAndExt() const;
    IMPORT_C TBool DrivePresent() const;
    IMPORT_C TBool PathPresent() const;
    IMPORT_C TBool NamePresent() const;
    IMPORT_C TBool ExtPresent() const;
    IMPORT_C TBool NameOrExtPresent() const;
    IMPORT_C TBool IsRoot() const;
    IMPORT_C TBool IsWild() const;
    IMPORT_C TBool IsKMatchOne() const;
    IMPORT_C TBool IsKMatchAny() const;
    IMPORT_C TBool IsNameWild() const;
    IMPORT_C TBool IsExtWild() const;
protected:
    virtual TDes& NameBuf() = 0;                // Reference to derived class descriptor containing the filename.
    virtual const TDesC& NameBufC() const = 0;  // const reference to derived class descriptor containing the filename.
    TInt Set(const TDesC* aName,const TDesC* aRelated,const TDesC* aDefault,TBool allowWild);
private:
    TInt ParseDrive(TLex& aName,TBool& aDone);
    TInt ParsePath(TLex& aName,TBool& aDone);
    TInt ParseName(TLex& aName,TBool& aDone);
    TInt ParseExt(TLex& aName,TBool& aDone);
protected:
    TInt16 iMod;        // Non-zero indicates File name modification functionality is enabled.
private:
    TInt16 iWild;
    SField iField[EMaxFields];
    };
 
 
 
 
class TParsePtr : public TParseBase
    {
public:
    IMPORT_C TParsePtr(TDes& aName);
protected:
    IMPORT_C TDes& NameBuf();
    IMPORT_C const TDesC& NameBufC() const;
private:
    TPtr iNameBuf;
    };
 
 
 
 
class TParsePtrC : public TParseBase
    {
public:
    IMPORT_C TParsePtrC(const TDesC& aName);
protected:
    IMPORT_C TDes& NameBuf();
    IMPORT_C const TDesC& NameBufC() const;
private:
    TPtrC iNameBuf;
    };
 
 
 
 
class TParse : public TParseBase
    {
public:
    IMPORT_C TParse();
    IMPORT_C TInt Set(const TDesC& aName,const TDesC* aRelated,const TDesC* aDefault);
    IMPORT_C TInt SetNoWild(const TDesC& aName,const TDesC* aRelated,const TDesC* aDefault);
protected:
    IMPORT_C TDes& NameBuf();
    IMPORT_C const TDesC& NameBufC() const;
private:
    TFileName iNameBuf;
    };
    
    
    
 
class CDir : public CBase
    {
public:
    IMPORT_C virtual ~CDir();
    IMPORT_C TInt Count() const;
    IMPORT_C const TEntry& operator[](TInt anIndex) const;
    IMPORT_C TInt Sort(TUint aEntrySortKey);
protected:
    IMPORT_C CDir();
    IMPORT_C static CDir* NewL();
    IMPORT_C void AddL(const TEntry& anEntry);
    IMPORT_C void ExtractL(TBool aRemove,CDir*& aDir);
    IMPORT_C void Compress();
protected:
    CArrayPakFlat<TEntry>* iArray;
    friend class RFs;
    friend class TOpenFileScan;
    };
    
    
#if defined SYMBIAN_PRIVATE_EFSRV
    #define EFSRV_EXPORT_C
    #define EFSRV_IMPORT_C 
#else
    #define EFSRV_EXPORT_C EXPORT_C
    #define EFSRV_IMPORT_C IMPORT_C
#endif
    
// forward declarations from e32ldr_private.h
class RFileClamp;
 
class RFs : public RSessionBase
    {
public:
    EFSRV_IMPORT_C TInt Connect(TInt aMessageSlots=KFileServerDefaultMessageSlots);
    EFSRV_IMPORT_C void Close();
    EFSRV_IMPORT_C TVersion Version() const;
    EFSRV_IMPORT_C TInt AddFileSystem(const TDesC& aFileName) const;
    EFSRV_IMPORT_C TInt MountFileSystem(const TDesC& aFileSystemName,TInt aDrive) const;
    EFSRV_IMPORT_C TInt MountFileSystem(const TDesC& aFileSystemName,TInt aDrive, TBool aIsSync) const;
    EFSRV_IMPORT_C TInt MountFileSystemAndScan(const TDesC& aFileSystemName,TInt aDrive,TBool& aIsMountSuccess) const;
    EFSRV_IMPORT_C TInt MountFileSystem(const TDesC& aFileSystemName,const TDesC& aExtensionName,TInt aDrive);
    EFSRV_IMPORT_C TInt MountFileSystem(const TDesC& aFileSystemName,const TDesC& aExtensionName,TInt aDrive, TBool aIsSync);
    EFSRV_IMPORT_C TInt MountFileSystemAndScan(const TDesC& aFileSystemName,const TDesC& aExtensionName,TInt aDrive,TBool& aIsMountSuccess) const;
    EFSRV_IMPORT_C TInt DismountFileSystem(const TDesC& aFileSystemName,TInt aDrive) const;
    EFSRV_IMPORT_C TInt RemoveFileSystem(const TDesC& aFileSystemName) const;
    EFSRV_IMPORT_C TInt FileSystemName(TDes& aName,TInt aDrive) const;
    EFSRV_IMPORT_C TInt AddExtension(const TDesC& aFileName);
    EFSRV_IMPORT_C TInt MountExtension(const TDesC& aExtensionName,TInt aDrive);
    EFSRV_IMPORT_C TInt DismountExtension(const TDesC& aExtensionName,TInt aDrive);
    EFSRV_IMPORT_C TInt RemoveExtension(const TDesC& aExtensionName);
    EFSRV_IMPORT_C TInt ExtensionName(TDes& aExtensionName,TInt aDrive,TInt aPos);
    EFSRV_IMPORT_C TInt RemountDrive(TInt aDrive,const TDesC8* aMountInfo=NULL,TUint aFlags=0);
    EFSRV_IMPORT_C void NotifyChange(TNotifyType aType,TRequestStatus& aStat);
    EFSRV_IMPORT_C void NotifyChange(TNotifyType aType,TRequestStatus& aStat,const TDesC& aPathName);
    EFSRV_IMPORT_C void NotifyChangeCancel();
    EFSRV_IMPORT_C void NotifyChangeCancel(TRequestStatus& aStat);
    EFSRV_IMPORT_C void NotifyDiskSpace(TInt64 aThreshold,TInt aDrive,TRequestStatus& aStat);
    EFSRV_IMPORT_C void NotifyDiskSpaceCancel(TRequestStatus& aStat);
    EFSRV_IMPORT_C void NotifyDiskSpaceCancel();
    EFSRV_IMPORT_C TInt DriveList(TDriveList& aList) const;
    EFSRV_IMPORT_C TInt DriveList(TDriveList& aList, TUint aFlags) const;
    EFSRV_IMPORT_C TInt Drive(TDriveInfo& anInfo,TInt aDrive=KDefaultDrive) const;
    EFSRV_IMPORT_C TInt Volume(TVolumeInfo& aVol,TInt aDrive=KDefaultDrive) const;
    EFSRV_IMPORT_C void Volume(TVolumeInfo& aVol,TInt aDrive, TRequestStatus& aStat) const;
    EFSRV_IMPORT_C TInt SetVolumeLabel(const TDesC& aName,TInt aDrive=KDefaultDrive);
    EFSRV_IMPORT_C TInt Subst(TDes& aPath,TInt aDrive=KDefaultDrive) const;
    EFSRV_IMPORT_C TInt SetSubst(const TDesC& aPath,TInt aDrive=KDefaultDrive);
    EFSRV_IMPORT_C TInt RealName(const TDesC& aName,TDes& aResult) const;
    EFSRV_IMPORT_C TInt GetMediaSerialNumber(TMediaSerialNumber& aSerialNum, TInt aDrive);
    EFSRV_IMPORT_C TInt SessionPath(TDes& aPath) const;
    EFSRV_IMPORT_C TInt SetSessionPath(const TDesC& aPath);
    EFSRV_IMPORT_C TInt Parse(const TDesC& aName,TParse& aParse) const;
    EFSRV_IMPORT_C TInt Parse(const TDesC& aName,const TDesC& aRelated,TParse& aParse) const;
    EFSRV_IMPORT_C TInt MkDir(const TDesC& aPath);
    EFSRV_IMPORT_C TInt MkDirAll(const TDesC& aPath);
    EFSRV_IMPORT_C TInt RmDir(const TDesC& aPath);
    EFSRV_IMPORT_C TInt GetDir(const TDesC& aName,TUint anEntryAttMask,TUint anEntrySortKey,CDir*& anEntryList) const;
    EFSRV_IMPORT_C TInt GetDir(const TDesC& aName,TUint anEntryAttMask,TUint anEntrySortKey,CDir*& anEntryList,CDir*& aDirList) const;
    EFSRV_IMPORT_C TInt GetDir(const TDesC& aName,const TUidType& anEntryUid,TUint anEntrySortKey,CDir*& aFileList) const;
    EFSRV_IMPORT_C TInt Delete(const TDesC& aName);
    EFSRV_IMPORT_C TInt Rename(const TDesC& anOldName,const TDesC& aNewName);
    EFSRV_IMPORT_C TInt Replace(const TDesC& anOldName,const TDesC& aNewName);
    EFSRV_IMPORT_C TInt Att(const TDesC& aName,TUint& aAttValue) const;
    EFSRV_IMPORT_C TInt SetAtt(const TDesC& aName,TUint aSetAttMask,TUint aClearAttMask);
    EFSRV_IMPORT_C TInt Modified(const TDesC& aName,TTime& aTime) const;
    EFSRV_IMPORT_C TInt SetModified(const TDesC& aName,const TTime& aTime);
    EFSRV_IMPORT_C TInt Entry(const TDesC& aName,TEntry& anEntry) const;
    EFSRV_IMPORT_C TInt SetEntry(const TDesC& aName,const TTime& aTime,TUint aSetAttMask,TUint aClearAttMask);
private:
    EFSRV_IMPORT_C TInt ReadFileSection_RESERVED(const TDesC& aName,TInt aPos,TDes8& aDes,TInt aLength) const;
public:
    EFSRV_IMPORT_C static TBool IsValidDrive(TInt aDrive);
    EFSRV_IMPORT_C static TInt CharToDrive(TChar aChar,TInt& aDrive);
    EFSRV_IMPORT_C static TInt DriveToChar(TInt aDrive,TChar& aChar);
    EFSRV_IMPORT_C static TBool IsRomAddress(TAny* aAny);
    EFSRV_IMPORT_C static TDriveNumber GetSystemDrive();
    EFSRV_IMPORT_C static TChar GetSystemDriveChar();
    EFSRV_IMPORT_C TInt SetSystemDrive(TDriveNumber aSystemDrive);
    EFSRV_IMPORT_C void ResourceCountMarkStart() const;
    EFSRV_IMPORT_C void ResourceCountMarkEnd() const;
    EFSRV_IMPORT_C TInt ResourceCount() const;
    EFSRV_IMPORT_C TInt IsFileOpen(const TDesC& aFile,TBool& anAnswer) const;
    EFSRV_IMPORT_C TInt CheckDisk(const TDesC& aDrive) const;
    EFSRV_IMPORT_C TInt ScanDrive(const TDesC& aDrive) const;
    EFSRV_IMPORT_C TInt GetShortName(const TDesC& aLongName,TDes& aShortName) const;
    EFSRV_IMPORT_C TInt GetLongName(const TDesC& aShortName,TDes& aLongName) const;
    EFSRV_IMPORT_C TBool GetNotifyUser();
    EFSRV_IMPORT_C void SetNotifyUser(TBool aValue);
    EFSRV_IMPORT_C TUint8* IsFileInRom(const TDesC& aFileName) const;
    EFSRV_IMPORT_C TBool IsValidName(const TDesC& anEntryName) const;
    EFSRV_IMPORT_C TBool IsValidName(const TDesC& aFileName,TText& aBadChar) const;
    EFSRV_IMPORT_C TInt GetDriveName(TInt aDrive,TDes& aDriveName) const;
    EFSRV_IMPORT_C TInt SetDriveName(TInt aDrive,const TDesC& aDriveName);
    EFSRV_IMPORT_C TInt LoaderHeapFunction(TInt aFunction, TAny *aArg1=NULL, TAny *aArg2=NULL);
    IMPORT_C TInt SetErrorCondition(TInt anError,TInt aCount=0);
    EFSRV_IMPORT_C TInt SetDebugRegister(TInt aVal);
    EFSRV_IMPORT_C TInt SetAllocFailure(TInt aAllocNum);
    EFSRV_IMPORT_C void DebugNotify(TInt aDrive,TUint aNotifyType,TRequestStatus& aStat);
    EFSRV_IMPORT_C TInt ControlIo(TInt aDrive,TInt aCommand);
    EFSRV_IMPORT_C TInt ControlIo(TInt aDrive,TInt aCommand,TDes8& aParam1);
    EFSRV_IMPORT_C TInt ControlIo(TInt aDrive,TInt aCommand,TDes8& aParam1,TDes8& aParam2);
    EFSRV_IMPORT_C TInt ControlIo(TInt aDrive,TInt aCommand,TAny* aParam1,TAny* aParam2);
    EFSRV_IMPORT_C TInt LockDrive(TInt aDrv, const TMediaPassword &aOld, const TMediaPassword &aNew, TBool aStr);
    EFSRV_IMPORT_C TInt UnlockDrive(TInt aDrv, const TMediaPassword &Pswd, TBool aStr);
    EFSRV_IMPORT_C TInt ClearPassword(TInt aDrv, const TMediaPassword &aPswd);
    EFSRV_IMPORT_C TInt ErasePassword(TInt aDrv);
    EFSRV_IMPORT_C TInt SetSessionToPrivate(TInt aDrive);
    EFSRV_IMPORT_C TInt PrivatePath(TDes& aPath);
    EFSRV_IMPORT_C TInt CreatePrivatePath(TInt aDrive); 
    EFSRV_IMPORT_C void StartupInitComplete(TRequestStatus& aStat);
    EFSRV_IMPORT_C TInt SetLocalDriveMapping(const TDesC8& aMapping);
 
    EFSRV_IMPORT_C TInt FinaliseDrives();
    
    enum TFinaliseDrvMode
        {
        EFinal_RW,      
        EFinal_RO,      
        EForceUnfinalise
        };
 
    EFSRV_IMPORT_C TInt FinaliseDrive(TInt aDriveNo, TFinaliseDrvMode aMode) const;
 
    EFSRV_IMPORT_C TInt SwapFileSystem(const TDesC& aOldFileSystemName,const TDesC& aNewFileSystemName,TInt aDrive) const;
    EFSRV_IMPORT_C TInt ReserveDriveSpace(TInt aDriveNo, TInt aSpace);
    EFSRV_IMPORT_C TInt GetReserveAccess(TInt aDriveNo);
    EFSRV_IMPORT_C TInt ReleaseReserveAccess(TInt aDriveNo);
 
    EFSRV_IMPORT_C TInt AddPlugin(const TDesC& aFileName) const;
    EFSRV_IMPORT_C TInt RemovePlugin(const TDesC& aPluginName) const;
    EFSRV_IMPORT_C TInt PluginName(TDes& aPluginName,TInt aDrive,TInt aPos);
 
    EFSRV_IMPORT_C TInt MountPlugin(const TDesC& aPluginName) const;
    EFSRV_IMPORT_C TInt MountPlugin(const TDesC& aPluginName,TInt aDrive) const;
    EFSRV_IMPORT_C TInt MountPlugin(const TDesC& aPluginName,TInt aDrive, TInt aPos) const;
    
    EFSRV_IMPORT_C TInt DismountPlugin(const TDesC& aPluginName) const;
    EFSRV_IMPORT_C TInt DismountPlugin(const TDesC& aPluginName,TInt aDrive) const;
    EFSRV_IMPORT_C TInt DismountPlugin(const TDesC& aPluginName,TInt aDrive,TInt aPos) const;
 
    EFSRV_IMPORT_C void NotifyDismount(TInt aDrive, TRequestStatus& aStat, TNotifyDismountMode aMode=EFsDismountRegisterClient) const;
    EFSRV_IMPORT_C void NotifyDismountCancel(TRequestStatus& aStat) const;
    EFSRV_IMPORT_C void NotifyDismountCancel() const;
    EFSRV_IMPORT_C TInt AllowDismount(TInt aDrive) const;
    EFSRV_IMPORT_C TInt SetStartupConfiguration(TInt aCommand,TAny* aParam1,TAny* aParam2) const;
    EFSRV_IMPORT_C TInt AddCompositeMount(const TDesC& aFileSystemName,TInt aLocalDriveToMount,TInt aCompositeDrive, TBool aSync) const;
    EFSRV_IMPORT_C TInt SetNotifyChange(TBool aNotifyChange);
    EFSRV_IMPORT_C TInt QueryVolumeInfoExt(TInt aDrive, TQueryVolumeInfoExtCmd aCommand, TDes8& aInfo) const;
    EFSRV_IMPORT_C TInt VolumeIOParam(TInt aDriveNo, TVolumeIOParamInfo& aParamInfo) const;
    EFSRV_IMPORT_C TInt FileSystemSubType(TInt aDriveNo, TDes& aName) const;
    EFSRV_IMPORT_C TInt InitialisePropertiesFile(const TPtrC8& aPtr) const;
    
    IMPORT_C TInt AddProxyDrive(const TDesC& aFileName);
    IMPORT_C TInt RemoveProxyDrive(const TDesC& aDriveName);
    
    template <class T0,class T1> inline TInt MountProxyDrive(const TUint aDrive, const TDesC& aName, T0 a0, T1 a1)
        { return(DoMountProxyDrive(TIpcArgs(aDrive, &aName, a0, a1))); }
    IMPORT_C TInt DismountProxyDrive(const TUint aDrive);
    
    TInt Unclamp(const RFileClamp& aHandle);
    
    EFSRV_IMPORT_C TInt ReadFileSection(const TDesC& aName,TInt64 aPos,TDes8& aDes,TInt aLength) const;
    
    class TNameValidParam
        {
        public:
            inline TNameValidParam(TBool aUseSessionPath = EFalse);
                
        enum TError
            {
            ErrNone,            
            ErrBadCharacter,    
            ErrBadName,         
            ErrNameTooLong      
            };
        
        inline TError ErrorCode() const;
        inline void   UseSessionPath(TBool aUseSessionPath);
        inline TUint  InvalidCharPos() const;
        friend class TFsIsValidName;
        private:
            TError iError;          
            TBool  iUseSessionPath; 
            TUint  iInvalidCharPos; 
        };
    EFSRV_IMPORT_C TBool IsValidName(const TDesC& aName, TNameValidParam& aParam );
 
    enum 
        {
        KRootFileSystem  = 0x00800000,  
        KFirstChildFileSystem = 0       
        };
 
    EFSRV_IMPORT_C TInt SupportedFileSystemName(TDes& aName, TInt aDrive, TInt aFsEnumerator) const;
 
 
    
    enum TForceMediaChangeFlags
        {
        KForceMediaChangeReOpenAllMediaDrivers = 0,
        
        KMediaRemountForceMediaChange = 0x00000001,
        
        KForceMediaChangeReOpenMediaDriver = 0x80000000
        };
 
protected:
    TInt SendReceive(TInt aFunction,const TIpcArgs& aArgs) const;
 
private:
    void GetDirL(const TDesC& aMatchName,TUint anEntryAttMask,TUint anEntrySortKey,CDir*& anEntryList,CDir*& aDirList,RDir& aDir) const;
    void GetDirL(const TDesC& aMatchName,TUint anEntryAttMask,TUint anEntrySortKey,CDir*& anEntryList,RDir& aDir) const;
    void GetDirL(const TDesC& aMatchName,const TUidType& aUidType,TUint anEntrySortKey,CDir*& anEntryList,RDir& aDir) const;
    void DoGetDirL(TUint anEntrySortKey,CDir*& anEntryList,RDir& aDir) const;
    TInt GetOpenFileList(TInt& aSessionNum,TInt& aLocalPos,TThreadId& aThreadId,TEntryArray& anArray) const;
    
    IMPORT_C TInt DoMountProxyDrive(const TIpcArgs& ipcArgs);
    
    friend class TOpenFileScan;
    friend class RFsPlugin;
    };
 
 
//-------------------------------------------------------------------------------------------------------------------
 
class TVolFormatParam
    {
public:
    inline TVolFormatParam();
    inline void Init();
    
    inline void SetFileSystemName(const TDesC& aFsName);
 
    static inline TUint32 CalcFSNameHash(const TDesC& aFsName);
    inline TUint32 FSNameHash() const;
 
    inline TBool SomeParamsSet() const;
 
 
protected:
   
    
    enum {KMaxDataSlots = 64}; 
 
    inline void SetVal(TUint aIndex, TUint32 aVal);
    inline TUint32 GetVal(TUint aIndex) const;
 
 
public:
    enum {KUId = 0x820116A2}; 
 
    const TUint32 iUId;    
                            
private:
    TUint32 iFSysNameHash;          
    TBool   iParamsSet : 1;         
    TUint32 iData[KMaxDataSlots];   
    }; 
 
__ASSERT_COMPILE(_FOFF(TVolFormatParam, iUId) == 0);
 
 
typedef TPckgBuf<TVolFormatParam> TVolFormatParamBuf;
 
 
 
 
#ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
#else
#endif
 
 
class RFile : public RSubSessionBase
    {
public:
    EFSRV_IMPORT_C TInt Open(RFs& aFs,const TDesC& aName,TUint aFileMode);
    EFSRV_IMPORT_C void Close();
    EFSRV_IMPORT_C TInt Create(RFs& aFs,const TDesC& aName,TUint aFileMode);
    EFSRV_IMPORT_C TInt Replace(RFs& aFs,const TDesC& aName,TUint aFileMode);
    EFSRV_IMPORT_C TInt Temp(RFs& aFs,const TDesC& aPath,TFileName& aName,TUint aFileMode);
    EFSRV_IMPORT_C TInt Read(TDes8& aDes) const;
    EFSRV_IMPORT_C void Read(TDes8& aDes,TRequestStatus& aStatus) const;
    EFSRV_IMPORT_C TInt Read(TDes8& aDes,TInt aLength) const;
    EFSRV_IMPORT_C void Read(TDes8& aDes,TInt aLength,TRequestStatus& aStatus) const;
    EFSRV_IMPORT_C TInt Read(TInt aPos,TDes8& aDes) const;
    EFSRV_IMPORT_C void Read(TInt aPos,TDes8& aDes,TRequestStatus& aStatus) const;
    EFSRV_IMPORT_C TInt Read(TInt aPos,TDes8& aDes,TInt aLength) const;
    EFSRV_IMPORT_C void Read(TInt aPos,TDes8& aDes,TInt aLength,TRequestStatus& aStatus) const;
    EFSRV_IMPORT_C void ReadCancel(TRequestStatus& aStatus) const;
    EFSRV_IMPORT_C void ReadCancel() const;
    EFSRV_IMPORT_C TInt Write(const TDesC8& aDes);
    EFSRV_IMPORT_C void Write(const TDesC8& aDes,TRequestStatus& aStatus);
    EFSRV_IMPORT_C TInt Write(const TDesC8& aDes,TInt aLength);
    EFSRV_IMPORT_C void Write(const TDesC8& aDes,TInt aLength,TRequestStatus& aStatus);
    EFSRV_IMPORT_C TInt Write(TInt aPos,const TDesC8& aDes);
    EFSRV_IMPORT_C void Write(TInt aPos,const TDesC8& aDes,TRequestStatus& aStatus);
    EFSRV_IMPORT_C TInt Write(TInt aPos,const TDesC8& aDes,TInt aLength);
    EFSRV_IMPORT_C void Write(TInt aPos,const TDesC8& aDes,TInt aLength,TRequestStatus& aStatus);
    EFSRV_IMPORT_C TInt Lock(TInt aPos,TInt aLength) const;
    EFSRV_IMPORT_C TInt UnLock(TInt aPos,TInt aLength) const;
    EFSRV_IMPORT_C TInt Seek(TSeek aMode,TInt& aPos) const;
    EFSRV_IMPORT_C TInt Flush();
    EFSRV_IMPORT_C void Flush(TRequestStatus& aStatus);
    EFSRV_IMPORT_C TInt Size(TInt& aSize) const;
    EFSRV_IMPORT_C TInt SetSize(TInt aSize);
    EFSRV_IMPORT_C TInt Att(TUint& aAttValue) const;
    EFSRV_IMPORT_C TInt SetAtt(TUint aSetAttMask,TUint aClearAttMask);
    EFSRV_IMPORT_C TInt Modified(TTime& aTime) const;
    EFSRV_IMPORT_C TInt SetModified(const TTime& aTime);
    EFSRV_IMPORT_C TInt Set(const TTime& aTime,TUint aSetAttMask,TUint aClearAttMask);
    EFSRV_IMPORT_C TInt ChangeMode(TFileMode aNewMode);
    EFSRV_IMPORT_C TInt Rename(const TDesC& aNewName);
    EFSRV_IMPORT_C TInt Drive(TInt &aDriveNumber, TDriveInfo &aDriveInfo) const;
    EFSRV_IMPORT_C TInt Adopt(RFs& aFs, TInt aHandle);
    EFSRV_IMPORT_C TInt AdoptFromClient(const RMessage2& aMsg, TInt aFsHandleIndex, TInt aFileHandleIndex);
    EFSRV_IMPORT_C TInt AdoptFromServer(TInt aFsHandle, TInt aFileHandle);
    EFSRV_IMPORT_C TInt AdoptFromCreator(TInt aFsIndex, TInt aFileHandleIndex);
    EFSRV_IMPORT_C TInt Name(TDes& aName) const;
    EFSRV_IMPORT_C TInt TransferToServer(TIpcArgs& aIpcArgs, TInt aFsHandleIndex, TInt aFileHandleIndex) const;
    EFSRV_IMPORT_C TInt TransferToClient(const RMessage2& aMsg, TInt aFileHandleIndex) const;
    EFSRV_IMPORT_C TInt TransferToProcess(RProcess& aProcess, TInt aFsHandleIndex, TInt aFileHandleIndex) const;
    EFSRV_IMPORT_C TInt Duplicate(const RFile& aFile, TOwnerType aType=EOwnerProcess);
    EFSRV_IMPORT_C TInt FullName(TDes& aName) const;
    EFSRV_IMPORT_C TInt BlockMap(SBlockMapInfo& aInfo, TInt64& aStartPos, TInt64 aEndPos=-1, TInt aBlockMapusage=EBlockMapUsagePaging) const;
    TInt Clamp(RFileClamp& aHandle);
 
protected:
    // RSubSessionBase overrides
    TInt CreateSubSession(const RSessionBase& aSession,TInt aFunction,const TIpcArgs& aArgs);
    void CloseSubSession(TInt aFunction);
    TInt SendReceive(TInt aFunction,const TIpcArgs& aArgs) const;
 
    TInt DuplicateHandle(TInt& aSubSessionHandle) const;
 
    friend class RFilePlugin;
    };
 
#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
#include <f32file64.h>
#endif
 
class RDir : public RSubSessionBase
    {
public:
    EFSRV_IMPORT_C TInt Open(RFs& aFs,const TDesC& aMatchName,const TUidType& aUidType);
    EFSRV_IMPORT_C TInt Open(RFs& aFs,const TDesC& aMatchName,TUint anAttMask);
    EFSRV_IMPORT_C void Close();
    EFSRV_IMPORT_C TInt Read(TEntryArray& anArray) const;
    EFSRV_IMPORT_C void Read(TEntryArray& anArray,TRequestStatus& aStatus) const;
    EFSRV_IMPORT_C TInt Read(TEntry& anEntry) const;
    EFSRV_IMPORT_C void Read(TPckg<TEntry>& anEntry,TRequestStatus& aStatus) const;
 
private:
    // RSubSessionBase overrides
    TInt SendReceive(TInt aFunction,const TIpcArgs& aArgs) const;
 
    friend class RDirPlugin;
    };
 
 
class RFormat : public RSubSessionBase
    {
public:
    IMPORT_C TInt Open(RFs& aFs,const TDesC& aName,TUint aFormatMode,TInt& aCount);
    IMPORT_C TInt Open(RFs& aFs,const TDesC& aName,TUint aFormatMode,TInt& aCount,const TDesC8& anInfo);
    IMPORT_C void Close();
    IMPORT_C TInt Next(TInt& aStep);
    IMPORT_C void Next(TPckgBuf<TInt>& aStep,TRequestStatus& aStatus);
    };
 
 
 
 
class RRawDisk : public RSubSessionBase
    {
public:
    IMPORT_C TInt Open(RFs& aFs,TInt aDrive);
    IMPORT_C void Close();
    IMPORT_C TInt Read(TInt64 aPos,TDes8& aDes);
    IMPORT_C TInt Write(TInt64 aPos,TDesC8& aDes);
private:
    TInt iDrive;
    };
 
 
 
 
class CDirStack;
NONSHARABLE_CLASS(CDirScan) : public CBase
    {
public:
    enum TScanDirection
        {
        EScanUpTree,
        
        EScanDownTree
        };
public:
    IMPORT_C static CDirScan* NewL(RFs& aFs);
    IMPORT_C static CDirScan* NewLC(RFs& aFs);
    IMPORT_C ~CDirScan();
    IMPORT_C void SetScanDataL(const TDesC& aMatchName,TUint anEntryAttMask,TUint anEntrySortMask,TScanDirection aScanDir=EScanDownTree);
    IMPORT_C void NextL(CDir*& aDirEntries);
    IMPORT_C TPtrC AbbreviatedPath();
    IMPORT_C TPtrC FullPath();
protected:
    CDirScan(RFs& aFs);
private:
    inline RFs& Fs();
    void UpdateAbbreviatedPath();
    void ScanUpTreeL(CDir*& aDirEntries);
    void ScanDownTreeL(CDir*& aDirEntries);
    void GetDirEntriesL(CDir*& aDirEntries);
private:
    RFs* const iFs;
    TParse iFullPath;
    TPtrC iAbbreviatedPath;
    TInt iAbbreviatedPathPos;
    TUint iEntryAttMask;
    TUint iEntrySortMask;
    TBool iScanning;
    TScanDirection iScanDir;
    CDirStack* iStack;
    };
 
 
 
 
enum TFileManError
    {
    ENoExtraInformation,
 
 
    EInitializationFailed,
 
 
    EScanNextDirectoryFailed,
 
 
    ESrcOpenFailed,
 
 
    ETrgOpenFailed,
 
 
    ENoFilesProcessed
    };
 
 
 
 
class MFileManObserver
    {
public:
    enum TControl
        {
        EContinue,
 
 
        ERetry,
 
 
        EAbort,
        
 
        ECancel
        };
public:
    IMPORT_C virtual TControl NotifyFileManStarted();
    IMPORT_C virtual TControl NotifyFileManOperation();
    IMPORT_C virtual TControl NotifyFileManEnded();
    };
 
 
 
 
class CFileBase : public CBase
    {
public:
    IMPORT_C void SetObserver(MFileManObserver* anObserver);
public:
    IMPORT_C const TEntry& CurrentEntry();
    IMPORT_C TPtrC AbbreviatedPath();
    IMPORT_C TPtrC FullPath();
    IMPORT_C TInt GetLastError();
    IMPORT_C TFileManError GetMoreInfoAboutError();
protected:
    IMPORT_C CFileBase(RFs& anFs);
    IMPORT_C void ConstructL();
    IMPORT_C ~CFileBase();
    IMPORT_C void RunL();
    IMPORT_C void RunInSeparateThreadL(TThreadFunction aThreadFunction);
// virtual
    virtual void CompleteOperationL() {};
    
//pure virtual
    virtual void DoOperationL() = 0;
protected:
    RFs iFs;
    RFs iFsOld;
    RThread iFManThread;
    RSemaphore iSynchronizer;
    CDirScan* iScanner;
    CDir* iDirList;
    TInt iCurrentEntry;
    TUint iMatchEntry;
    TUint iSwitches;
    TParse iSrcFile;
    MFileManObserver* iObserver;
    TInt iLastError;
    TFileManError iErrorInfo;
    TRequestStatus* iStatus;
    HBufC* iSessionPath;
    TInt iNumberOfFilesProcessed;
 
 
 
 
friend void DoFManBaseOperationL(TAny* aPtr);
friend TInt FManBaseThreadFunction(TAny* aPtr);
    };
 
 
 
 
NONSHARABLE_CLASS(CFileMan) : public CFileBase
    {
public:
    enum TAction
        {
        ENone,
 
 
        EAttribs,
        
        
        ECopy,
        
        
        EDelete,
        
        
        EMove,
        
        
        ERename,
        
        
        ERmDir,
        
        
        ERenameInvalidEntry,
 
        ECopyFromHandle,
        };
        
        
    enum TSwitch
        {
        EOverWrite=1,
        
        
        ERecurse=2
        };
public:
    IMPORT_C static CFileMan* NewL(RFs& aFs);
    IMPORT_C static CFileMan* NewL(RFs& aFs,MFileManObserver* anObserver);
    ~CFileMan();
    IMPORT_C TAction CurrentAction();
    IMPORT_C void GetCurrentTarget(TFileName& aFile);
    IMPORT_C void GetCurrentSource(TFileName& aFile);
    IMPORT_C TInt BytesTransferredByCopyStep();
public:
    IMPORT_C TInt Attribs(const TDesC& aName,TUint aSetMask,TUint aClearMask,const TTime& aTime,TUint aSwitch=0);
    IMPORT_C TInt Attribs(const TDesC& aName,TUint aSetMask,TUint aClearMask,const TTime& aTime,TUint aSwitch,TRequestStatus& aStatus);
    IMPORT_C TInt Copy(const TDesC& anOld,const TDesC& aNew,TUint aSwitch=EOverWrite);
    IMPORT_C TInt Copy(const TDesC& anOld,const TDesC& aNew,TUint aSwitch,TRequestStatus& aStatus);
    IMPORT_C TInt Delete(const TDesC& aName,TUint aSwitch=0);
    IMPORT_C TInt Delete(const TDesC& aName,TUint aSwitch,TRequestStatus& aStatus);
    IMPORT_C TInt Move(const TDesC& anOld,const TDesC& aNew,TUint aSwitch=EOverWrite);
    IMPORT_C TInt Move(const TDesC& anOld,const TDesC& aNew,TUint aSwitch,TRequestStatus& aStatus);
    IMPORT_C TInt Rename(const TDesC& anOld,const TDesC& aNew,TUint aSwitch=EOverWrite);
    IMPORT_C TInt Rename(const TDesC& anOld,const TDesC& aNew,TUint aSwitch,TRequestStatus& aStatus);
    IMPORT_C TInt RmDir(const TDesC& aDirName);
    IMPORT_C TInt RmDir(const TDesC& aDirName,TRequestStatus& aStatus);
    IMPORT_C TInt Copy(const RFile& anOld,const TDesC& aNew,TUint aSwitches=EOverWrite);
    IMPORT_C TInt Copy(const RFile& anOld,const TDesC& aNew,TUint aSwitches,TRequestStatus& aStatus);
protected:
    CFileMan(RFs& aFs);
private:
    enum TInternalAction
        {
        EInternalNone,
        
        EInternalAttribs,
        
        EInternalCopy,
        
        EInternalDelete,
        
        EInternalCopyForMove,
        
        EInternalRenameForMove,
        
        EInternalRename,
        
        EInternalRmDir,
        
        EInternalRenameInvalidEntry,
        
        EInternalCopyFromHandle,
        };
 
    void CompleteOperationL();
    void DoOperationL();
    void CheckForDirectory();
    void SetFlags(TBool aOverWrite,TBool aRecurse,TBool aScanDirection,TBool aMoveRename);
    void GetSrcAndTrg(TParse& aSrcName,TFileName& aTrgName);
    void DoSynchronize(TInt aRetVal);
    TInt CheckRenameAllowed(const TDesC& aSrcName,const TDesC& aTrgName);
    TInt SetupMoveOnSameDrive(TUint aSwitches, TBool& aComplete);
    TInt SetupMoveAcrossDrives(TUint aSwitches);
    TInt SetupTargetDirectory(TBool aOverWrite, TBool& aComplete);
    TBool SrcTrgDrivesIdentical();
    TInt SetupDirectoryForMove(TBool& aSrcIsDir);
private:
    void DoAttribsL();
    void DoCopyOrMoveL();
    void DoDeleteL();
    void DoRenameL();
    void DoRmDirL();
    void DoCopyFromHandleL();
#ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
    TInt DoCopy(const RFile& aSrcFile, RFile& aDstFile, TInt& aRet);
#else
    TInt DoCopy(const RFile64& aSrcFile, RFile64& aDstFile, TInt& aRet);
#endif
private:
    TParse iTrgFile;
    TInternalAction iAction;
    TUint iSetMask;
    TUint iClearMask;
    TTime iTime;
    TInt iBytesTransferred;
#ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
    RFile iSrcFileHandle;
#else
    RFile64 iSrcFileHandle;
#endif
    TBool iMovingContents;
    TEntry iTmpEntry;
    TParse iTmpParse;
    TFileName iTmpName1;
    TFileName iTmpName2;
 
friend void RenameInvalidEntryL(RFs& aFs,TParse& aSrcFile);
    };
 
 
 
 
 
class TFindFile
    {
public:
    IMPORT_C TFindFile(RFs& aFs);
    IMPORT_C TInt FindByPath(const TDesC& aFileName,const TDesC* aPathList);
    IMPORT_C TInt FindByDir(const TDesC& aFileName,const TDesC& aDirPath);
    IMPORT_C TInt Find();
    IMPORT_C TInt FindWildByPath(const TDesC& aFileName,const TDesC* aPathList,CDir*& aDirList);
    IMPORT_C TInt FindWildByDir(const TDesC& aFileName,const TDesC& aDirPath,CDir*& aDir);
    IMPORT_C TInt FindWild(CDir*& aDirList);
    IMPORT_C TInt SetFindMask(TUint aMask);
    inline const TDesC& File() const;
private:
    TInt DoFind();
    TInt DoFindByPath(const TDesC& aFileName,const TDesC* aPathList);
    TInt DoFindByDir(const TDesC& aFileName,const TDesC& aDir);
    TInt DoFindInDir();
    TInt DoFindNextInPath();
    TInt DoFindNextInDriveList();
    TInt CallSafe(TInt aResult);
private:
    RFs* const iFs;
    TParse iFile;
    TInt iPathPos;
    TInt iCurrentDrive;
    TInt iMode;
    const TDesC* iPath;
    TDriveList iDrvList;
    CDir** iDir;
    TUint32 iMatchMask; 
    };
 
 
 
 
typedef CDir CFileList;
 
 
 
 
class TOpenFileScan
    {
public:
    IMPORT_C TOpenFileScan(RFs& aFs);
    IMPORT_C void NextL(CFileList*& aFileList);
    IMPORT_C TThreadId ThreadId() const;
private:
    RFs* iFs;
    TThreadId iThreadId;
    TInt iScanPos;
    TInt iEntryListPos;
    };
 
 
 
 
class TFileText
    {
private:
    enum TFileState
        {
        EStartOfFile,
        ENormal,
        EReverse
        };
public:
    IMPORT_C TFileText();
    IMPORT_C void Set(RFile& aFile);
    IMPORT_C TInt Read(TDes& aDes);
    IMPORT_C TInt Write(const TDesC& aDes);
    IMPORT_C TInt Seek(TSeek aMode);
private:
    void NextRecord();
    TInt CheckForTerminator(TBool& anAnswer);
    TInt FillBuffer();
private:
    const TText* iNext;
    const TText* iEnd;
    TFileState iState;
#ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
    RFile iFile;
#else
    RFile64 iFile;
#endif
    TBuf8<0x100> iReadBuf; 
    };
 
 
 
//-------------------------------------------------------------------------------------------------------------------
/*
    This is a helper class intended to make it easier to dismount and re-mount a file system
    The purpose of this class is to gather and encapsulate all the necessary file system parameters such
    as the file system name, the extensions name(s), etc. ;
    these parameters are then retrieved & restored when mounting the file system back again
    
    The typical scenario:
        1. some client dismounts an existing file system (FS1) from the drive
        2. then the client mounts another file system (FS2) on to the drive to do some work
        3. Dismounts FS2
        4. Mounts FS1 back again with exactly the same parameters as they were there before it was dismounted.
*/
class TFsMntHelperImpl;
NONSHARABLE_CLASS(CFsMountHelper) : public CBase
    {
 public:
 
    IMPORT_C ~CFsMountHelper();
    IMPORT_C static CFsMountHelper* New(RFs& aFs, TInt aDrvNum);
 
    enum TFsDismountMode
        {
        ENormal,            
        EForceImmediate,    
        
        ENotifyClients      
        };
 
 
    IMPORT_C TInt GetMountProperties();
    IMPORT_C TInt MountFileSystem() const;
    IMPORT_C void DismountFileSystem(TRequestStatus& aStat, TFsDismountMode aDismountMode=ENormal) const;
    IMPORT_C TInt DismountFileSystem() const;
 
 protected:
    inline CFsMountHelper(); 
    CFsMountHelper(const CFsMountHelper&);
    CFsMountHelper& operator=(const CFsMountHelper&);
 
    void Close();
 
 private:
    TFsMntHelperImpl*  ipImpl; 
    };
 
 
 
//-------------------------------------------------------------------------------------------------------------------
 
IMPORT_C TBool FileNamesIdentical(const TDesC& aFileName1,const TDesC& aFileName2);
 
const TInt KFileServerUidValue = 0x100039e3;
 
 
#include <f32file.inl>
#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
#include <f32file64.inl>
#endif
 
#ifdef SYMBIAN_F32_ENHANCED_CHANGE_NOTIFICATION 
#include <f32notification.h>
#endif
 
#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <f32file_private.h>
#endif
 
#endif