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

//

#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,