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

// Common CFatMountCB code for both EFAT.FSY and EFAT32.fsy

//

//

/**

 @file

 @internalTechnology

*/

#include "sl_std.h"

#include "sl_cache.h"

#include "sl_leafdir_cache.h"

#include "sl_dir_cache.h"

#include "sl_scandrv.h"

#include <hal.h>

TShortName DoGenerateShortNameL(const TDesC& aLongName,TInt& aNum,TBool aUseTildeSelectively);

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

TFatVolParam::TFatVolParam()

    {

    Mem::FillZ(this, sizeof(TFatVolParam));

    }

/**

    populate the object with the values from the boot sector.

    @param aBootSector a reference to the valid boots sector

*/

void TFatVolParam::Populate(const TFatBootSector& aBootSector)

    {

    ASSERT(aBootSector.IsValid());

    iSectorsPerCluster = aBootSector.SectorsPerCluster();

    iSectorSizeLog2    = Log2(aBootSector.BytesPerSector());

    iClusterSizeLog2   = iSectorSizeLog2+Log2(iSectorsPerCluster);

    iFirstFatSector    = aBootSector.FirstFatSector();

    iNumberOfFats      = aBootSector.NumberOfFats();

    iFatSizeInBytes    = aBootSector.TotalFatSectors()*aBootSector.BytesPerSector();

    iTotalSectors      = aBootSector.VolumeTotalSectorNumber();

    iRootClusterNum    = aBootSector.RootClusterNum(); //-- will be 0 for FAT12/16

    iRootDirectorySector = aBootSector.RootDirStartSector();

    iRootDirEnd = (iRootDirectorySector + aBootSector.RootDirSectors()) << SectorSizeLog2(); //-- doesn't matter for FAT32

    //-- get main and backup FSInfo sectors position, these fields will be 0 for FAT12/16

    iFSInfoSectorNum   = aBootSector.FSInfoSectorNum();

    iBkFSInfoSectorNum = (TUint16)(aBootSector.BkBootRecSector()+iFSInfoSectorNum); //-- Bk FSInfo sector must follow the Bk boot sector

    }

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

    {

    ASSERT(&aRhs != this);

    if(&aRhs == this)

        return ETrue; //-- comparing with itself

    return (Mem::Compare((TUint8*)this, sizeof(TFatVolParam), (TUint8*)&aRhs, sizeof(TFatVolParam)) == 0);

    }

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

CFatMountCB::CFatMountCB()

    {

    __PRINT2(_L("CFatMountCB::CFatMountCB() 0x%x, %S"), this, &KThisFsyName);

    SetFatType(EInvalid);

    iState   = ENotMounted;

    DBG_STATEMENT(iCBRecFlag = 0); //-- debug flag only

    }

CFatMountCB::~CFatMountCB()

    {

    __PRINT1(_L("#-CFatMountCB::~CFatMountCB() 0x%x"), this);

    DoDismount();

    delete iNotifier;

    delete iFatTable;

    delete iRawDisk;

    delete iLeafDirCache;

    }

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

CFatMountCB* CFatMountCB::NewL()

    {

    CFatMountCB* pSelf = new(ELeave) CFatMountCB;

    CleanupStack::PushL(pSelf);

    pSelf->ConstructL();

    CleanupStack::Pop(pSelf);

    return pSelf;

    }

// second-stage constructor

void CFatMountCB::ConstructL()

{

    //-- create Notifier

    iNotifier = CAsyncNotifier::New();

    if( !iNotifier )

        {

        Close();

        User::Leave(KErrNoMemory);

        }

    iNotifier->SetMount(this);

    }

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

/**

Implementation of CMountCB::FileSystemClusterSize(). Returns cluster size of this mount.

@return Cluster size value if successful; otherwise KErrNotReady if the mount is not ready.

@see CMountCB::FileSystemClusterSize()

*/

TInt CFatMountCB::ClusterSize() const

    {

    if (ClusterSizeLog2())

        return (1 << ClusterSizeLog2());

    return KErrNotReady;

    }

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

/**

    @leave KErrAccessDenied if the mount is read-only

*/

void CFatMountCB::CheckWritableL() const

    {

    if(ReadOnly())

        {

        __PRINT(_L("CFatMountCB is RO!"));

        User::Leave(KErrAccessDenied);

        }

    }

/**

    @leave KErrCorrupt if the mount is in inconsistent state i.e high-level file and directory  operations can not be performed

*/

void CFatMountCB::CheckStateConsistentL() const

    {

    if(!ConsistentState())

        {

        __PRINT(_L("CFatMountCB state is inconsistent !"));

        User::Leave(KErrCorrupt);

        }

    }

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

/**

    Helper Method. Check if the parameters of the volume being remounted are the same as current ones.

    @return ETrue if volume parameters remained same.

*/

TBool CFatMountCB::CheckVolumeTheSame()

{

    //-- initialise local drive

    TInt nRes =InitLocalDrive();

    if(nRes != KErrNone)

        return EFalse;

    //-- read the boot sector or its backup copy if the main is damaged. It will aslo validate it.

    TFatBootSector bootSector;

    nRes = ReadBootSector(bootSector, iRamDrive);

    if(nRes != KErrNone)

        return EFalse;

    //-- 1. check volume Uid

    if(iUniqueID != bootSector.UniqueID())

        return EFalse;

    //-- check volume parameters, they must remain the same

    TFatVolParam volParam;

    volParam.Populate(bootSector);

    if(!(volParam == iVolParam))

        return EFalse;

    return ETrue;

}

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

/**

    Helper Method. Check if the parameters of the volume being remounted are the same as current ones.

    If they are, re-initialises the mount.

*/

void CFatMountCB::DoReMountL()

    {

    if(!CheckVolumeTheSame())

        User::Leave(KErrGeneral);

	//-- get drive capabilities

    TLocalDriveCapsV2Buf capsBuf;

	User::LeaveIfError(LocalDrive()->Caps(capsBuf));

    //-- the volume is the same as it was on original MountL()

    //-- we need to re-initialize for the case when the media was removed, FAT or directory structure changed on other device and the media returned back.

    DoDismount();

    SetState(EMounting);

    InitializeL(capsBuf(), ETrue); //-- forcedly disable FSInfo usage. This will lead to FAT free clusters re-counting.

    }

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

/**

    Try remount this Fat volume. Checks if the volume parameters remained the same as on original MountL() call, and

    if they are, re-initialises the mount. This includes resetting all caches.

    ! Do not call this method from TDriveInterface methods, like citical and non-critical notifiers ! This can lead to the

    recursive loops and undefined behaviour.

    @return KErrNone if the remount was OK

            system-wide error code otherwise

*/

TInt CFatMountCB::ReMount()

    {

    __PRINT2(_L("CFatMountCB::ReMount(), drv:%d, curr state:%d"), DriveNumber(), State());

    const TFatMntState currState = State();

    //-- analyse the mount state and find out if we can remount at all.

    switch(currState)

        {

        case ENotMounted:

        __PRINT(_L("CFatMountCB::ReMount() Invalid mount state!"));

        ASSERT(0);

        return KErrGeneral;

        //-- correct state, proceed to remount

        default:

        break;

    }

    //-- there are 2 options here:

    //-- 1. normally initialised mount had been forcedly dismounted (it can optionally have objects opened on it)

    //--    in this case the DoReMountL() will succeed and everything will be fine, the objects will be accessible afterwards

    //-- 2. the mount hasn't been initialised at all (it does not have for example, FAT table created etc.)

    //--    in this case we may need to fake the success. This can only happen on forced mount by CFormatCB

    TInt nRes;

    TRAP(nRes, DoReMountL());

    if(nRes != KErrNone)

        {

        //-- note that the mount may be here left in inconsistent state (EMounting)

        //-- if DoReMountL() fails. This is OK, because we can not make any valid read/write operations in such a state and

        //-- the drive must be dismounted and mounted again. File Server's TDrive shall do this.

        __PRINT1(_L("CFatMountCB::ReMount() failed! code:%d"), nRes);

        //-- If we are in the EInit_Forced state, it means that we are trying to remount the volume that has been formatted.

        //-- scenario: On formatting, if we can't read a bootsector, new _empty_ object of the CFatMountCB is created and

        //-- it is used for performing a format. If the format has finished, but RFormat isn't closed yet and we try to access the volume,

        //-- we will get here, because all members of the constructed mount will be zeroes.

        if(currState == EInit_Forced)

            {

            __PRINT(_L("CFatMountCB::ReMount() simulating normal remount!"));

            SetState(currState);

            return KErrNone;

            }

        return nRes;

        }

    __PRINT1(_L("CFatMountCB::ReMount() Completed drv:%d"), DriveNumber());

    SetState(EInit_R);

    return nRes;

    }

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

/**

    Reset the last leaf dir or invalidate leaf dir cache if leaf dir cache is

    instantiated.

*/

void CFatMountCB::InvalidateLeafDirCache()

	{

    if (iLeafDirCache)

    	{

        iLeafDirCache->Reset();

    	}

    else

    	{

        User::Free(iLastLeafDir);

        iLastLeafDir=NULL;

    	}

	}

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

/**

    Delete mount's caches

    Moves CFatMountCB into ENotMounted state immediately.

*/

void CFatMountCB::DoDismount()

    {

    __PRINT1(_L("CFatMountCB::DoDismount() drv:%d"), DriveNumber());

    //-- try to flush and destroy FAT cache

    if (iFatTable)

        {

        if(!ConsistentState() || ReadOnly())

            {//-- the mount state is inconsistent, so the data can't be flushed. Ignore dirty cache either.

            iFatTable->Dismount(ETrue);

            }

        else

            {//-- Try to flush the FAT - if this fails there's not much we can do

            TRAPD(r, iFatTable->FlushL());

            iFatTable->Dismount(r != KErrNone); //-- ignore dirty data if we failed to flush the cache

            }

        }

    //-- destroy leafdir name cache, this cache will be re-created while mounting or re-mounting

    //-- see CFatMountCB::InitializeL()

    delete iLeafDirCache;

    iLeafDirCache = NULL;

    //-- destroy directory cache, this cache will be re-created while mounting or re-mounting

    //-- see CFatMountCB::InitializeL()

    delete iRawDisk;

    iRawDisk = NULL;

    //-- Set mount state to "Dismounted". Which means that there might be no caches, but the mount is alive,

    //-- i.e. iFatTable & iRawDisk are valid

    SetState(EDismounted);

    }

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

/** old implementation */

void CFatMountCB::FinaliseMountL()

    {

    FinaliseMountL(RFs::EFinal_RW);

    }

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

/**

    Dismount the CFatMountCB and the drive.

    called from TDrive::Dismount().

*/

void CFatMountCB::Dismounted()

    {

    __PRINT1(_L("CFatMountCB::Dismounted() drv:%d"), DriveNumber());

    //-- n.b. it is no safe to do a kind of filnalisatin work here that implies accessing the media.

    //-- this method may be called after the media change occured from the TDrive::Dismount(). It means

    //-- that if we try to write some data here, they could be written into a different medium, if it had been

    //-- physically changed.

    const TFatMntState prevState = State();

    DoDismount(); //-- it will change mount state to EDismounted

    DismountedLocalDrive();

    //-- check if the previous state was EInit_Forced, which means that this method was called

    //-- on the mount that might not be alive (no valid iFatTable & iRawDisk).

    //-- This can happen only during format operation on non-mounted previously volume.

    //-- this EInit_Forced state must be processed separately, see ::Remount()

    if(prevState == EInit_Forced)

        SetState(EInit_Forced);

    }

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

/**

    Find out if the mount is finalised.

    @param  aFinalised on exit will be ETrue if the maunt is finalised, EFalse otherwise.

    @return standard error codes.

*/

TInt CFatMountCB::IsFinalised(TBool& aFinalised)

    {

    switch(State())

        {

        case EFinalised: //-- already explicitly finalised

            aFinalised = ETrue;

        return KErrNone;

        case EInit_W: //-- the volume had been written

            aFinalised = EFalse;

        return KErrNone;

        default: //-- it depends on the state

        break;

        }

    //-- find out if the volume is _physically_ finalised.

    //-- It can be in the state EInit_R, but finalised before mounting

    if(!VolCleanFlagSupported())

        return KErrNotSupported;

    TInt nRes = KErrNone;

    TRAP(nRes, aFinalised = VolumeCleanL());

    return nRes;

    }

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

/**

    @return ETrue if the mount is in consistent state i.e. normally mounted.

    See TFatMntState enum for more detail.

*/

TBool CFatMountCB::ConsistentState() const

    {

    return (iState==EInit_R) || (iState==EInit_W) || (iState == EFinalised);

    }

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

/**

    Open CFatMountCB for write. I.e. perform some actions on the first write attempt.

    This is a callback from TDriveInterface.

    @return System wide error code.

*/

TInt CFatMountCB::OpenMountForWrite()

    {

    if(State() == EInit_W)

        return KErrNone; //-- nothing to do, the mount is already opened for write

    __PRINT1(_L("#- CFatMountCB::OpenMountForWrite() drv:%d\n"),DriveNumber());

    ASSERT(State() == EInit_R || State() == EFinalised);

    //-- Check possible recursion. This method must not be called recursively. SetVolumeCleanL() works through direct disc access and

    //-- can not call TDriveInterface methods that call this method etc.

    ASSERT(iCBRecFlag == 0);

    DBG_STATEMENT(iCBRecFlag = 1); //-- set recursion check flag

    //-- do here some "opening" work, like marking volme as dirty

    //-- be careful here, as soon as this is a callback from TDriveInterface, writing via TDriveInterface may cause some unwanted recursion.

    //-- mark the volume as dirty

    TInt nRes=KErrNone;

    TRAP(nRes, SetVolumeCleanL(EFalse));

    if(nRes == KErrNone)

        {

        SetState(EInit_W);

        }

    DBG_STATEMENT(iCBRecFlag = 0); //-- reset recursion check flag

    return nRes;

    }

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

/**

    Unfinalise the mount, reset "VolumeCleanShutDown" flag and change the state if necessarily.

*/

void CFatMountCB::UnFinaliseMountL()

    {

    switch(State())

        {

        case EFinalised:

        case EInit_R:

            SetVolumeCleanL(EFalse); //-- the mount, mark volume "dirty"

            SetState(EInit_R);

        return;

        case EInit_W:

        return; //-- nothing to do

        default:

        //-- other mount states are inconsistent; can't perform this operation

        User::Leave(KErrAbort);

        break;

        }

    }

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

/**

    Finalise the mount.

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

    @param  aParam1     not used, for future expansion

    @param  aParam2     not used, for future expansion

    @leave  System wide error code. particular cases:

            KErrArgument invalid arguments

            KErrInUse    if the volume has opened objects (files, directories etc)

            KErrCorrupt  if the volume is corrupt

*/

void CFatMountCB::FinaliseMountL(TInt aOperation, TAny* /*aParam1*/, TAny* /*aParam2*/)

    {

    __PRINT2(_L("#- CFatMountCB::FinaliseMountL() op:%d, drv:%d"), aOperation, DriveNumber());

    switch(aOperation)

        {

        case RFs::EFinal_RW:

        case RFs::EFinal_RO:

        break;

        case RFs::EForceUnfinalise:

            UnFinaliseMountL();

        return;

        default:

            __PRINT1(_L("#- CFatMountCB::FinaliseMountL() unexpected operation!:%d"), aOperation);

            ASSERT(0);

            User::Leave(KErrArgument);

        return;

        }

    //-- mount finalisation work

    ASSERT(aOperation == RFs::EFinal_RW || aOperation == RFs::EFinal_RO);

    if(State() == EFinalised)

        {//-- the mount is already finalised. All we can do is to set it to RO mode

        if(ReadOnly() && aOperation == RFs::EFinal_RW)

            {

            User::Leave(KErrAccessDenied); //-- can't override RO flag

            }

		(void)LocalDrive()->Finalise(ETrue);

        if(aOperation == RFs::EFinal_RO)

            {

            SetReadOnly(ETrue);

            return;

            }

        return;

        }

    if(LockStatus() != 0)

        {//-- can't finalise the volume if it has opened objects and not in the consistent state.

         //-- Theoretically, we can finalise the mount if we have files opened only for read, but at present,

         //-- it's impossible to detect such situation.

        User::Leave(KErrInUse);

        }

    if(State() != EInit_R && State() != EInit_W)

        {//-- can't finalise the mount because it can be in an inconsistent state; e.g. corrupt.

        __PRINT1(_L("#- CFatMountCB::FinaliseMountL() Invalid mount State: %d"),State());

        User::Leave(KErrCorrupt);

        }

    //-- flush FAT cache

    FAT().FlushL();

    //-- for FAT32 we may need to update data in FSInfo sectors

    if(Is32BitFat())

        {

        if(FAT().ConsistentState())

            {//-- FAT table state is consistent and the number of free clusters is known.

             //-- Do it disregarding the mount state, it may help in the situation when 2 copies of the FSInfo are different for some reason.

            DoUpdateFSInfoSectorsL(EFalse);

            }

            else

            {//-- FAT table state is inconsistent, the most probable case here: background scan for free clusters is still working.

             //-- in this case we can't put corect values into the FSInfo.

            if(State() == EInit_W)

                {//-- bad situation: free clusters may be being counted and someone has already written something on the volume at the same time.

                 //-- we do not know the exact number of free clustes and can't wait until scan finishes. Invalidate FSInfo.

                __PRINT(_L("#- CFatMountCB::FinaliseMountL() invalidating FSInfo"));

                DoUpdateFSInfoSectorsL(ETrue);

                }

             else

                {//-- no changes on the volume, just do not update FSInfo

                __PRINT(_L("#- CFatMountCB::FinaliseMountL() FAT state inconsistent; FSInfo isn't updated"));

                }

            }//if(FAT().ConsistentState())

        }//if(Is32BitFat())

    //-- mark the volume as clean

    SetVolumeCleanL(ETrue);

    //-- finally, put the volume into RO mode if required

    if(aOperation == RFs::EFinal_RO)

        SetReadOnly(ETrue);

    SetState(EFinalised);

    }

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

/**

@return ETrue if "VolumeClean" flag is supported i.e. this is not FAT12

*/

TBool CFatMountCB::VolCleanFlagSupported() const

    {

        const TFatType fatType=FatType();

        ASSERT(fatType == EFat12 || fatType == EFat16 || fatType == EFat32);

        return (fatType != EFat12);

    }

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

/**

    Obtain the volume information.

    All information except iSize and iFree has been added by TDrive::Volume().

    @param  aVolume on return will contain iSize & iFree fields filled with actual data.

*/

void CFatMountCB::VolumeL(TVolumeInfo& aVolume) const

    {

    //-- if true, this operation will be synchronous, i.e the client will be suspended until FAT32 scanning thread finishes, if running.

    //-- the information if this operation is synchronous or not can be passed by client in TVolumeInfo::iFileCacheFlags field.

    //-- if the client sets aVolume.iVolSizeAsync flag there, RFs::Volume() will be asynchronous, i.e the _current_ number of free clusters

    //-- will be returned.

    const TBool bSyncOp = !aVolume.iVolSizeAsync;

    aVolume.iVolSizeAsync = EFalse; //-- reset this flag in order it not to be reused on the client side

	__PRINT2(_L("CFatMountCB::VolumeL() drv:%d, synch:%d"), DriveNumber(), bSyncOp);

    const TDriveInfo& drvInfo=aVolume.iDrive;

#if defined(__EPOC32__)

    // if RAM drive, cap size according to HAL.

    if (drvInfo.iType==EMediaRam)

        {

        TLocalDriveCapsV2Buf caps;

        LocalDrive()->Caps(caps);

        const TInt max_drive_size=TInt(caps().iEraseBlockSize);

        const TInt cur_drive_size=I64INT(caps().iSize);

        aVolume.iSize=max_drive_size;

        aVolume.iFree=max_drive_size-cur_drive_size;

        aVolume.iSize=aVolume.iFree+iSize;

        TInt maxSize;

        if (HAL::Get(HAL::EMaxRAMDriveSize, maxSize) == KErrNone)

            {

            // iSize will never grow beyond maxRam because of a check in medint.

            // d <= f; (s{f} + f) - m <= f; s{f} <= m

            __ASSERT_DEBUG(iSize <= maxSize, Fault(EFatRAMDriveSizeInvalid));

            if (aVolume.iSize > maxSize)

                {

                TInt64 d = aVolume.iSize - maxSize;

                __ASSERT_DEBUG(d <= aVolume.iFree, Fault(EFatRAMDriveFreeInvalid));

                aVolume.iSize -= d;

                aVolume.iFree -= d;

                }

            }

        aVolume.iSize-=ClusterBasePosition(); // Allow for bytes used by FAT etc

        aVolume.iSize=(aVolume.iSize>>ClusterSizeLog2())<<ClusterSizeLog2();  //-- round down to cluster size

        return;

        }//if (drvInfo.iType==EMediaRam)

#endif

    const TUint32 freeClusters = FAT().NumberOfFreeClusters(bSyncOp);

    __PRINT1(_L("CFatMountCB::VolumeL() free clusters:%d"), freeClusters);

    aVolume.iFree = (TInt64)freeClusters << ClusterSizeLog2();

    if (drvInfo.iType==EMediaRam)

        aVolume.iSize=aVolume.iFree+iSize;

    aVolume.iSize-=ClusterBasePosition(); // Allow for bytes used by FAT etc

    aVolume.iSize=(aVolume.iSize >> ClusterSizeLog2()) << ClusterSizeLog2();  //-- round down to cluster size

    }

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

//

//  Set the volume label (write aVolume label into BPB & Volume Label File)

//  aName string may be zero length but is assumed to contain no illegal characters or NULLs.

//

void CFatMountCB::SetVolumeL(TDes& aName)

    {

    __PRINT(_L("CFatMountCB::SetVolumeL"));

    CheckStateConsistentL();

    CheckWritableL();

    __ASSERT_ALWAYS(aName.Length()<=KVolumeLabelSize,User::Leave(KErrBadName));

    TBuf8<KVolumeLabelSize> buf8(KVolumeLabelSize);

    buf8.Zero();

	LocaleUtils::ConvertFromUnicodeL(buf8, aName, TFatUtilityFunctions::EOverflowActionLeave);

	aName.Zero();

	LocaleUtils::ConvertToUnicodeL(aName, buf8); // adjust aName (which may contain more underscores after this line than before)

    const TInt lengthOfBuf8=buf8.Length();

    // Pad to end with spaces if not empty.

    if (lengthOfBuf8>0 && lengthOfBuf8<KVolumeLabelSize)

        {

        buf8.SetLength(KVolumeLabelSize);

        Mem::Fill(&buf8[lengthOfBuf8],KVolumeLabelSize-lengthOfBuf8,' ');

        }

    // Write a volume label file

    WriteVolumeLabelFileL( buf8 );

    // Write the boot sector volume label

    // Always pad to full length with spaces

    if (lengthOfBuf8==0)

        {

        buf8.Fill(' ',KVolumeLabelSize);

        }

    WriteVolumeLabelL(buf8);

    }

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

/**

    Make a directory.

    @param aName full path to the directory to create. Name validity is checked by file server.

    all trailing dots from the name will be removed

*/

void CFatMountCB::MkDirL(const TDesC& aName)

    {

    __PRINT2(_L("CFatMountCB::MkDirL, drv:%d, %S"), DriveNumber(), &aName);

    CheckStateConsistentL();

    CheckWritableL();

    TPtrC dirName = RemoveTrailingDots(aName); //-- remove trailing dots from the name

    TInt namePos=dirName.LocateReverse(KPathDelimiter)+1; // There is always a path delimiter

    TPtrC name=dirName.Mid(namePos);

    TLeafDirData leafDir;

    const TEntryPos dirPos(FindLeafDirL(dirName.Left(namePos), leafDir),0);

    TEntryPos dumPos=dirPos;

    TFatDirEntry dumEntry;

    TBool isOriginalNameLegal = IsLegalDosName(name,EFalse,EFalse,EFalse,EFalse,ETrue);

    iFileCreationHelper.InitialiseL(name);

    TFileName fileName;

    TEntryPos startPos;

    TFatDirEntry startEntry;

    TRAPD(ret,DoFindL(name,KEntryAttMaskSupported,

			    		startPos,startEntry,dumPos,dumEntry,

			    		fileName,KErrNotFound,

			    		&iFileCreationHelper,

			    		leafDir));

    if (ret!=KErrNotFound && ret!=KErrNone)

        User::Leave(ret);

    if (ret!=KErrNotFound)

        {

        if (dumEntry.Attributes()&KEntryAttDir)

            User::Leave(KErrAlreadyExists);

        else

            User::Leave(KErrAccessDenied);

        }

    TShortName shortName;

    if (iFileCreationHelper.GetValidatedShortName(shortName) == KErrNotFound)

    	{

    	GenerateShortNameL(dirPos.iCluster,name,shortName,ETrue);

    	}

    TInt numEntries=1;

    if (isOriginalNameLegal==EFalse)

        numEntries=NumberOfVFatEntries(name.Length());

    dumPos=dirPos;

    if (iFileCreationHelper.IsNewEntryPosFound())

    	{

    	dumPos = iFileCreationHelper.EntryAddingPos();

    	}

    AddDirEntryL(dumPos,numEntries);    //  Directory entry in leaf directory

    TInt startCluster;

    FOREVER

        {

        //-- FAT().FreeClusterHint() will give us a hint of the last free cluster

        startCluster=FAT().AllocateSingleClusterL(dumPos.iCluster ? dumPos.iCluster : FAT().FreeClusterHint());

        FAT().FlushL();

        TRAPD(r, InitializeFirstDirClusterL(startCluster,dirPos.iCluster));

        if(r == KErrNone)

            break;

        if(r != KErrCorrupt)

            User::Leave(r);

        FAT().MarkAsBadClusterL(startCluster);

        }

    TFatDirEntry fatDirEntry;

    fatDirEntry.SetName(shortName);

    fatDirEntry.SetAttributes(KEntryAttDir);

    TTime now;

	now.UniversalTime();

    fatDirEntry.SetTime(now, TimeOffset());

    fatDirEntry.SetCreateTime(now, TimeOffset());

    fatDirEntry.SetStartCluster(startCluster);

    fatDirEntry.SetSize(0);

    if (isOriginalNameLegal)

        WriteDirEntryL(dumPos,fatDirEntry);

    else

        WriteDirEntryL(dumPos,fatDirEntry,name);

    iFileCreationHelper.Close();

    }

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

/**

    Setup 1st cluster of the new directory

    @param  aStartCluster   this entry start cluster number

    @param  aParentCluster  parent entry start cluster number

*/

void CFatMountCB::InitializeFirstDirClusterL(TInt aStartCluster,TInt aParentCluster)

    {

    const TUint32 KClusterSz= 1<<ClusterSizeLog2();

    const TUint32 KMaxBufSz = KClusterSz;           //-- max. nuffer size is a cluster

    const TUint32 KMinBufSz = 1<<SectorSizeLog2();  //-- min. buffer size is 1 sector (for OOM case)

    //-- allocate a buffer for directory file 1st cluster initialisation

    RBuf8 buf;

    CleanupClosePushL(buf);

    if(buf.CreateMax(KMaxBufSz) != KErrNone)

        buf.CreateMaxL(KMinBufSz); //-- OOM, try to create smaller buffer

    buf.FillZ();

    //-- copy "." directory entry to the buffer

    //-- "." directory entry

    TFatDirEntry entry;

    TTime now;

	now.UniversalTime();

    entry.SetTime(now, TimeOffset() );

    entry.SetAttributes(KEntryAttDir);

    entry.SetCurrentDirectory();

    entry.SetStartCluster(aStartCluster);

    Mem::Copy(&buf[0],&entry,KSizeOfFatDirEntry);

    //-- append ".." directory entry

    entry.SetParentDirectory();

    entry.SetStartCluster(aParentCluster==RootIndicator() ? 0 : aParentCluster);

    Mem::Copy(&buf[0]+KSizeOfFatDirEntry,&entry,KSizeOfFatDirEntry);

    TEntryPos entryPos(aStartCluster,0);

    //-- write buffer to the beginning of the directory file.

    DirWriteL(entryPos, buf); //-- use special interface to access FAT directory file

    //-- fill in the rest of the cluster if we used a small buffer

    if((TUint32)buf.Size() < KClusterSz) //-- use special interface to access FAT directory file

    {

        buf.FillZ();

        const TInt restCnt = SectorsPerCluster() - 1;

        ASSERT(restCnt >=1);

        for(TInt i=0; i<restCnt; ++i)

        {

            entryPos.iPos += KMinBufSz;

            DirWriteL(entryPos, buf); //-- use directory cache when dealing with directories

        }

    }

    CleanupStack::PopAndDestroy(&buf);

    }

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

/**

    Remove a directory.

    @param aName directory name

    all trailing dots from the name will be removed

*/

void CFatMountCB::RmDirL(const TDesC& aName)

    {

    __PRINT2(_L("CFatMountCB::RmDirL, drv:%d, %S"), DriveNumber(), &aName);

    CheckStateConsistentL();

    CheckWritableL();

    TPtrC dirName = RemoveTrailingDots(aName); //-- remove trailing dots from the name

    TFatDirEntry dirEntry;

    TEntryPos dirEntryPos(RootIndicator(),0); // Already checked entry is a directory

    FindEntryStartL(dirName,KEntryAttMatchMask|KEntryAttMatchExclusive,dirEntry,dirEntryPos);

    TEntryPos dosEntryPos=dirEntryPos;

    TFatDirEntry dosEntry=dirEntry;

    MoveToDosEntryL(dosEntryPos,dosEntry);

    if (!IsDirectoryEmptyL(StartCluster(dosEntry)))

        User::Leave(KErrInUse);

    // Remove the directory from cache before erasing

    if(iLeafDirCache && iLeafDirCache->CacheCount() > 0)

    	{

    	iLeafDirCache->RemoveDirL(StartCluster(dosEntry));

    	}

    EraseDirEntryL(dirEntryPos,dirEntry);

    FAT().FreeClusterListL(StartCluster(dosEntry));

    FAT().FlushL();

    }

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

/**

    Delete a file

    @param aName file name

    all trailing dots from the name will be removed

*/

void CFatMountCB::DeleteL(const TDesC& aName)

    {

    __PRINT2(_L("CFatMountCB::DeleteL, drv:%d, %S"), DriveNumber(), &aName);

    CheckStateConsistentL();

    CheckWritableL();

    TPtrC fullName = RemoveTrailingDots(aName); //-- remove trailing dots from the name

    TFatDirEntry firstEntry;

    TEntryPos firstEntryPos(RootIndicator(),0);

    FindEntryStartL(fullName,KEntryAttMaskSupported,firstEntry,firstEntryPos);

    TEntryPos dosEntryPos=firstEntryPos;

    TFatDirEntry dosEntry=firstEntry;

    MoveToDosEntryL(dosEntryPos,dosEntry);

    if ((dosEntry.Attributes()&KEntryAttReadOnly) || (dosEntry.Attributes()&KEntryAttDir))

        User::Leave(KErrAccessDenied);

    // Can not delete a file if it is clamped

    CMountCB* basePtr=(CMountCB*)this;

    TInt startCluster=StartCluster(dosEntry);

    if(basePtr->IsFileClamped(MAKE_TINT64(0,startCluster)) > 0)

        User::Leave(KErrInUse);

    EraseDirEntryL(firstEntryPos,firstEntry);

    FAT().FreeClusterListL(StartCluster(dosEntry));

    FAT().FlushL();

    }

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

/**

    Rename or replace a directory entry.

    Assumes all files are closed and replace is only passed files.

    Assumes rename target does not exist or is the source file.

    --------------- operating mode --------------------------------------------

    * rename mode

    aOldName exists  |  aNewName exists |   result

        N                    N              leave KErrNotFound

        N                    Y              leave KErrNotFound

        Y                    N              rename aOldName -> aNewName

        Y                    Y              leave KErrAlreadyExists if(aOldName!=aNewName); otherwise do nothing

    * replace mode

        N                    N              leave KErrNotFound

        N                    Y              leave KErrNotFound

        Y                    N              rename aOldName -> aNewName

        Y                    Y              contents and all file attributes of the "aNewName" are replaced with aOldName's. "aOldName" entries are deleted then.