// Copyright (c) 1998-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:

// fileserver\sfat32\inc\sl_std.h

//

/**

 @file

 @internalTechnology

*/

#ifndef SL_STD_H

#define SL_STD_H

//

// #define _DEBUG_RELEASE

//

#include "common.h"

#include <f32ver.h>

#include <e32svr.h>

#include <kernel/localise.h>

#include "filesystem_fat.h"

#include "common_constants.h"

#include "sl_bpb.h"

#include "fat_config.h"

#include "fat_dir_entry.h"

#ifdef _DEBUG

_LIT(KThisFsyName,"EFAT32.FSY"); ///< This FSY name

#endif

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

//-- FAT32 specific declarations

const TUint32 KFat32EntryMask = 0x0FFFFFFF;

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

class CFatMountCB;

class CFatFileSystem;

/**

Represents the position of a directory entery in terms of a cluster and off set into it

*/

class TEntryPos

	{

public:

	TEntryPos() {}

	TEntryPos(TInt aCluster,TUint aPos) : iCluster(aCluster), iPos(aPos) {}

    inline TUint32 Cluster() const;

    inline TUint32 Pos() const;

    inline TBool operator==(const TEntryPos& aRhs) const;

public:

	TInt iCluster;

	TUint iPos;

	};

/**

    Interface class between the file system and the local drive media interface,

    handles incomplete writes to media with the ability to notify the user.

    This class can't be instantinated by user; only CFatMountCB can do this; see CFatMountCB::DriveInterface()

*/

class TDriveInterface

    {

public:

	enum TAction {ERetry=1};

public:

    //-- public interface to the local drive. Provides media driver's error handling (critical and non-critical user notifiers)

    //-- and thread-safety if required.

	TInt ReadNonCritical(TInt64 aPos,TInt aLength,const TAny* aTrg,const RMessagePtr2 &aMessage,TInt anOffset) const;

	TInt ReadNonCritical(TInt64 aPos,TInt aLength,TDes8& aTrg) const;

	TInt ReadCritical(TInt64 aPos,TInt aLength,TDes8& aTrg) const;

    TInt WriteCritical(TInt64 aPos,const TDesC8& aSrc);

    TInt WriteNonCritical(TInt64 aPos,TInt aLength,const TAny* aSrc,const RMessagePtr2 &aMessage,TInt anOffset);

    TInt GetLastErrorInfo(TDes8& aErrorInfo) const;

    //-- lock the mutex guarding CProxyDrive interface in order to be sure that no other thread can access it.

    //-- The thread that calls this method may be suspended until another signals the mutex, i.e. leaves the critical section.

    inline void AcquireLock() const {iProxyDrive.EnterCriticalSection();}

    //-- release the mutex guarding CProxyDrive.

    inline void ReleaseLock() const {iProxyDrive.LeaveCriticalSection();} 

protected:

    TDriveInterface();

    TDriveInterface(const TDriveInterface&);

    TDriveInterface& operator=(const TDriveInterface&);

    TBool Init(CFatMountCB* aMount);

    void Close(); 

	inline TBool NotifyUser() const;

	TInt HandleRecoverableError(TInt aRes) const;

	TInt HandleCriticalError(TInt aRes) const;

	TInt UnlockAndReMount() const;

	TBool IsDriveWriteProtected() const;

	TBool IsRecoverableRemount() const;

private:

	/** 

        An internal class that represents a thread-safe wrapper around raw interface to the CProxyDrive 

        and restricts access to it.

    */

    class XProxyDriveWrapper

        {

     public:

        XProxyDriveWrapper();

       ~XProxyDriveWrapper();

        TBool Init(CProxyDrive* aProxyDrive);

        inline void EnterCriticalSection() const {iLock.Wait();}

        inline void LeaveCriticalSection() const {iLock.Signal();}

        //-- methods' wrappers that are used by TDriveInterface

        TInt Read(TInt64 aPos,TInt aLength,const TAny* aTrg,const RMessagePtr2 &aMessage,TInt anOffset) const;

        TInt Read(TInt64 aPos,TInt aLength,TDes8& aTrg) const;

        TInt Write(TInt64 aPos,TInt aLength,const TAny* aSrc,const RMessagePtr2 &aMessage,TInt anOffset);

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

        TInt GetLastErrorInfo(TDes8& aErrorInfo) const;

        TInt Caps(TDes8& anInfo) const;

     private:

        CProxyDrive*    iLocalDrive; ///< raw interface to the media operations

        mutable RMutex  iLock;       ///< used for sorting out multithreaded access to the iLocalDrive

        };

    CFatMountCB*        iMount;      ///< Pointer to the owning file system mount

    XProxyDriveWrapper  iProxyDrive; ///< wrapper around raw interface to the media operations

    };

/**

    Class providing FAT table interface and basic functionality.

*/	

class CFatTable : public CBase

	{

public:

    virtual ~CFatTable();

    static CFatTable* NewL(CFatMountCB& aOwner, const TLocalDriveCaps& aLocDrvCaps);

    /** FAT table mounting parameters */

    struct TMountParams

        {

        TMountParams() :iFreeClusters(0), iFirstFreeCluster(0), iFsInfoValid(0) {};

        TUint32 iFreeClusters;      ///< Free clusters count, obtained from FSInfo

        TUint32 iFirstFreeCluster;  ///< First free cluster,  obtained from FSInfo

        TUint32 iFsInfoValid : 1;   ///< ETrue if the information in iFreeClusters &  iFirstFreeCluster is valid

        };

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

    //-- pure virtual interface

    virtual TUint32 ReadL(TUint32 aFatIndex) const = 0;

	virtual void WriteL(TUint32 aFatIndex, TUint32 aValue) = 0;

	virtual TInt64 DataPositionInBytes(TUint32 aCluster) const = 0;

    virtual void MountL(const TMountParams& aMountParam) = 0;

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

    //-- just virtual interface

    virtual void Dismount(TBool /*aDiscardDirtyData*/) {}

	virtual void FlushL() {};

    virtual void InvalidateCacheL() {};

    virtual void InvalidateCacheL(TInt64 /*aPos*/,TUint32 /*aLength*/) {};

	virtual void FreeClusterListL(TUint32 aCluster);

	virtual void ExtendClusterListL(TUint32 aNumber,TInt& aCluster);

    virtual TUint32 AllocateSingleClusterL(TUint32 aNearestCluster);

	virtual TUint32 AllocateClusterListL(TUint32 aNumber,TUint32 aNearestCluster);

    virtual void RequestRawWriteAccess(TInt64 /*aPos*/, TUint32 /*aLen*/) const {};

    virtual TUint32 FreeClusterHint() const; 

    virtual TUint32 NumberOfFreeClusters(TBool aSyncOperation=EFalse) const;

    virtual TBool RequestFreeClusters(TUint32 aClustersRequired) const; 

    virtual void InitializeL();

    virtual TBool ConsistentState() const {return ETrue;} //-- dummy

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

    //-- non-virtual interface

    TBool GetNextClusterL(TInt& aCluster) const;

    void WriteFatEntryEofL(TUint32 aFatIndex);

    void MarkAsBadClusterL(TUint32 aCluster);

    TInt CountContiguousClustersL(TUint32 aStartCluster,TInt& anEndCluster, TUint32 aMaxCount) const;

    inline TUint32 MaxEntries() const;

    TUint32 PosInBytes(TUint32 aFatIndex) const;	    

protected:

	CFatTable(CFatMountCB& aOwner);

    //-- outlawed

    CFatTable();

    CFatTable(const CFatTable&);

    CFatTable& operator=(const CFatTable&);

    virtual void SetFreeClusterHint(TUint32 aCluster);

    virtual void DecrementFreeClusterCount(TUint32 aCount);

	virtual void IncrementFreeClusterCount(TUint32 aCount);

    virtual void SetFreeClusters(TUint32 aFreeClusters); 

    virtual void CountFreeClustersL();

    virtual TUint32 FindClosestFreeClusterL(TUint32 aCluster);

    inline TInt     SectorSizeLog2() const;

    inline TUint32  FreeClusters() const;

    inline TBool IsEndOfClusterCh(TUint32 aCluster) const;

    inline TFatType FatType() const;

    inline TBool IsFat12() const;

    inline TBool IsFat16() const;

    inline TBool IsFat32() const;

    inline TBool ClusterNumberValid(TUint32 aClusterNo) const;

    typedef RArray<TUint> RClusterArray;

    void DoFreedClustersNotify(RClusterArray &aFreedClusters);

protected:

    CFatMountCB* iOwner;            ///< Owning file system mount

    TUint        iMediaAtt;         ///< Cached copy of TLocalDriveCaps::iMediaAtt

private:   

    TUint32  iFreeClusters;     ///< Number of free cluster in the fat table

	TUint32  iFreeClusterHint;  ///< this is just a hint to the free cluster number, not required to contain exact information.

	TFatType iFatType;          ///< FAT type 12/16/32, cached from the iOwner

    TUint32  iFatEocCode;       ///< End Of Cluster Chain code, 0xff8 for FAT12, 0xfff8 for FAT16, and 0xffffff8 for FAT32 

    TUint32  iMaxEntries;       ///< maximal number of FAT entries in the table. This value is taken from the CFatMount that calculates it

    };

class MWTCacheInterface;

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

/**

Base class abstraction of a raw media disk

*/

class CRawDisk : public CBase

	{

public:

    static CRawDisk* NewL(CFatMountCB& aOwner, const TLocalDriveCaps& aLocDrvCaps);

    virtual void InitializeL();

    virtual TInt GetLastErrorInfo(TDes8& aErrorInfo) const;

public:

    /**

	Read data from the media via simple WT data cache if it is present. Some media types, like RAM do not have caches.

    This method is mostly used to read UIDs of executable modules and store them in the cache.

	@param aPos		Media position in bytes

	@param aLength	Length in bytes of read

	@param aDes		Data from read

	*/

	virtual void ReadCachedL(TInt64 aPos,TInt aLength,TDes8& aDes) const = 0;

    /**

	Write data to the media via simple WT data cache if it is present. Some media types, like RAM do not have caches.

	@param aPos		Media position in bytes

	@param aDes		Data to write

	*/

	virtual void WriteCachedL(TInt64 aPos,const TDesC8& aDes) = 0;

    virtual void InvalidateUidCache() {}

    virtual void InvalidateUidCachePage(TUint64 /*aPos*/) {}

	/**

	Disk read function

	@param aPos		Media position in bytes

	@param aLength	Length in bytes of read

	@param aTrg		Pointer to the data descriptor, i.e. (const TAny*)(&TDes8)

	@param aMessage	Refrence to server message from request

	@param anOffset	Offset into read data to write

	*/

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

	/**

	Disk write function

	@param aPos		Media position in bytes

	@param aLength	Length in bytes of write

	@param aTrg		Pointer to the data descriptor, i.e. (const TAny*)(&TDes8)

	@param aMessage	Refrence to server message from request, contains data

	@param anOffset	Offset into write data to use in write

	*/

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

    virtual inline MWTCacheInterface* DirCacheInterface();

protected:

    CRawDisk(CFatMountCB& aOwner);

    //-- outlawed

    CRawDisk(); 

    CRawDisk(const CRawDisk&); 

    CRawDisk& operator=(const CRawDisk&);

protected:

	CFatMountCB* iFatMount; ///< Owning file system mount

	};

class CFatFileCB;

class RBitVector;

/** 

    A helper class. Holds the FAT volume parameters, which in turn are obtained from the Boot Sector

*/

class TFatVolParam

    {

public:   

    TFatVolParam();

    void Populate(const TFatBootSector& aBootSector);

    TBool operator==(const TFatVolParam& aRhs) const;

    //-- simple getters

    TUint32 ClusterSizeLog2() const     {return iClusterSizeLog2;    }        

    TUint32 SectorSizeLog2() const      {return iSectorSizeLog2;     }        

    TUint32 RootDirEnd() const          {return iRootDirEnd;         }        

    TUint32 SectorsPerCluster() const   {return iSectorsPerCluster;  }        

    TUint32 RootDirectorySector() const {return iRootDirectorySector;}        

    TUint32 FirstFatSector() const      {return iFirstFatSector;     }        

    TUint32 TotalSectors() const        {return iTotalSectors;       }        

    TUint32 NumberOfFats() const        {return iNumberOfFats;       }        

    TUint32 FatSizeInBytes() const      {return iFatSizeInBytes;     }        

    TUint32 RootClusterNum() const      {return iRootClusterNum;     }        

    TUint32 FSInfoSectorNum() const     {return iFSInfoSectorNum;    }        

    TUint32 BkFSInfoSectorNum() const   {return iBkFSInfoSectorNum;  }        

protected:

    TUint32 iClusterSizeLog2;      ///< Log2 of fat file system cluster size

    TUint32 iSectorSizeLog2;       ///< Log2 of media sector size

    TUint32 iRootDirEnd;           ///< End position of the root directory for Fat12/16

    TUint32 iSectorsPerCluster;    ///< Sector per cluster ratio for mounted Fat file system volume 

    TUint32 iRootDirectorySector;  ///< Start sector of the root directory for Fat12/16

    TUint32 iFirstFatSector;       ///< Start sector of the first Fat table in volume

    TUint32 iTotalSectors;         ///< Total sectors on media partition

    TUint32 iNumberOfFats;         ///< Number of Fats the volume has

    TUint32 iFatSizeInBytes;       ///< Size of a single Fat table in volume

    TUint32 iRootClusterNum;       ///< Cluster number for Root directory, for Fat32

    TUint32 iFSInfoSectorNum;      ///< FSInfo Sector number. If 0, this means that corresponding value isn't set in BPB

    TUint32 iBkFSInfoSectorNum;    ///< backup FSInfo Sector number

    };

TBool IsLegalDosName(const TDesC&  aName, TBool anAllowWildCards, TBool aUseExtendedChars, TBool aInScanDrive, TBool aAllowLowerCase, TBool aIsForFileCreation);

TBool IsLegalDOSNameChar(TChar aCharacter, TBool aUseExtendedChars);

TUint32 CalculatePageOffsetInCluster(TUint32 aPos, TUint aPageSzLog2);

class CLruCache;

class TLeafDirData;

class CLeafDirCache;

/**

Fat file system mount implmentation, provides all that is required of a plug in

file system mount as well as Fat mount specific functionality 

*/

class CFatMountCB : public CLocDrvMountCB, 

					public MFileSystemSubType,

					public MFileSystemClusterSize,

					public CMountCB::MFileAccessor,

					public CMountCB::MFileExtendedInterface

	{

public:

	static CFatMountCB* NewL();

	~CFatMountCB();

    void ConstructL();

public:

	//-- overrides from the abstract CMountCB

    void MountL(TBool aForceMount);

	TInt ReMount();

	void Dismounted();

	void VolumeL(TVolumeInfo& aVolume) const;

	void SetVolumeL(TDes& aName);

	void MkDirL(const TDesC& aName);

	void RmDirL(const TDesC& aName);

	void DeleteL(const TDesC& aName);

	void RenameL(const TDesC& anOldName,const TDesC& anNewName);

	void ReplaceL(const TDesC& anOldName,const TDesC& anNewName);

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

	void SetEntryL(const TDesC& aName,const TTime& aTime,TUint aMask,TUint aVal);

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

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

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

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

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

	void GetLongNameL(const TDesC& aShortName,TDes& aLongName);

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

    TInt CheckDisk();

	TInt ScanDrive();

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

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

	TInt Unlock(TMediaPassword& aPassword,TBool aStore);

	TInt ClearPassword(TMediaPassword& aPassword);

	TInt ErasePassword();

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

    void FinaliseMountL();

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

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

	TTimeIntervalSeconds TimeOffset() const;

protected:

    /** CFatMountCB states */

    enum  TFatMntState

        {

        ENotMounted = 0, ///< 0, initial state, not mounted     (mount state is inconsistent)

        EMounting,       ///< 1, Mounting started               (mount state is inconsistent)

        EInit_R,         ///< 2, Initialised and not written    (mount state is Consistent)

        EInit_W,         ///< 3, Initialised and written        (mount state is Consistent)

        EFinalised,      ///< 4, Finalised                      (mount state is Consistent)

        EDismounted,     ///< 5, Dismounted                     (mount state is inconsistent)

        EInit_Forced,    ///< 6, forcedly mounted, special case (mount state is inconsistent)

        };

    inline TFatMntState State() const;

    inline void SetState(TFatMntState aState); 

    TInt OpenMountForWrite();

    TInt IsFinalised(TBool& aFinalised);

    /** 

        A wrapper around TDriveInterface providing its instantination and destruction.

        You must not create objects of this class, use DriveInterface() instead.

    */

    class XDriveInterface: public TDriveInterface

        {

      public:

        XDriveInterface() : TDriveInterface() {}

        ~XDriveInterface() {Close();}

        TBool Init(CFatMountCB* aMount) {return TDriveInterface::Init(aMount);}

        };

public:

	enum TRenMode {EModeReplace,EModeRename};

    TBool ConsistentState() const; 

    void CheckWritableL() const;

    void CheckStateConsistentL() const;

	inline TBool ReadOnly(void) const;

    inline void  SetReadOnly(TBool aReadOnlyMode);

	inline TInt StartCluster(const TFatDirEntry & anEntry) const;

	inline CRawDisk& RawDisk() const;

	inline CFatFileSystem& FatFileSystem() const;

	inline CFatTable& FAT() const;

	inline TInt ClusterSizeLog2() const;

	inline TInt SectorSizeLog2() const;

	inline TInt TotalSectors() const;

	inline TInt SectorsPerCluster() const;

	inline TInt ClusterBasePosition() const;

    inline TInt RootDirectorySector() const;

    inline TUint RootDirEnd() const;