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

// f32\sfat\sl_file.cpp

// 

//

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

//!!

//!! WARNING!! DO NOT edit this file !! '\sfat' component is obsolete and is not being used. '\sfat32'replaces it

//!!

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

#include "sl_std.h"

#include "sl_cache.h"

#include <e32math.h>

const TInt KSeekIndexSize=128; // Cache 128 clusters

const TInt KSeekIndexSizeLog2=7;

const TInt KFirstClusterNum=2;

CFatFileCB::CFatFileCB()

    {

    __PRINT1(_L("CFatFileCB created 0x%x"),this);

    }

CFatFileCB::~CFatFileCB()

    {

    __PRINT1(_L("CFatFileCB deleted 0x%x"),this);

    //-- a nasty trick to find out if the CFatFileCB is in consistent state on the moment of destruction.

    //-- Because of OOM conditions CFatFileCB might not be fully constructed and to be deleted, while FlushAll()

    //-- implies valid iMount.

    const CMountCB* pMount  = &Mount();

    if(pMount)

        {//-- do some finalisation work if CMountCB is valid

        if (iAtt&KEntryAttModified)

            TRAP_IGNORE(FlushAllL());

        }

    delete[] iSeekIndex;

    }

void CFatFileCB::CreateSeekIndex()

//

// Create a seek index

//

    {

    iSeekIndex = new TUint32[KSeekIndexSize];

    if (iSeekIndex == NULL)

        return;

    Mem::FillZ(iSeekIndex, sizeof(TUint32) * KSeekIndexSize);

    iSeekIndexSize=CalcSeekIndexSize(Size());

    }

TInt CFatFileCB::SeekToPosition(TInt aNewRelCluster,TInt aClusterOffset)

//

// Use the seek index to set iCurrentPos.iCluster as close as possible to aNewRelCluster

// Return aNewRelCluster-aCurrentPos.iCluster

//

    {

    TInt clusterOffset=aClusterOffset;

    TInt seekPos=(aNewRelCluster>>iSeekIndexSize)-1;

    __ASSERT_DEBUG(seekPos<KSeekIndexSize,Fault(EFatFileSeekIndexTooSmall));

    while(seekPos>=0 && iSeekIndex[seekPos]==0 && clusterOffset!=0)

        {

        seekPos--;

        clusterOffset--;

        }

    if (clusterOffset==0) // Counted back to the current cluster

        return(aClusterOffset);

    if (seekPos<0)

        {

        iCurrentPos.iCluster=iStartCluster;

        return(aNewRelCluster);

        }

    iCurrentPos.iCluster=iSeekIndex[seekPos];

    return(aNewRelCluster-((seekPos+1)<<iSeekIndexSize));

    }

void CFatFileCB::SetSeekIndexValueL(TInt aRelCluster,TInt aStoredCluster)

//

// Sets a value in the seekindex

//

    {

    TInt seekPos=(aRelCluster>>iSeekIndexSize)-1;

    __ASSERT_DEBUG(seekPos<KSeekIndexSize,Fault(EFatFileSeekIndexTooSmall));

    __ASSERT_DEBUG(seekPos>=0,Fault(EFatFileSeekIndexTooSmall2));

    iSeekIndex[seekPos] = aStoredCluster;

    }

TBool CFatFileCB::IsSeekBackwards(TUint aPos)

//

// Return true if aPos<currentPos

//

    {

    TUint cluster=iCurrentPos.iCluster<<ClusterSizeLog2();

    TInt offset=ClusterRelativePos(iCurrentPos.iPos);

    TUint currentPos=cluster+offset;

    return(aPos<currentPos);

    }

void CFatFileCB::CheckPosL(TUint aPos)

//

// Check that the file is positioned correctly.

// If aPos<currentPos attempt to guess the new position.

//

    {

    __PRINT1(_L("CFatFileCB::CheckPosL(%d)"), aPos);

    if (aPos==iCurrentPos.iPos)

        return;

    __ASSERT_DEBUG(aPos <= (TUint)Size(), Fault(EFatFilePosBeyondEnd));

    if (iFileSizeModified && IsSeekBackwards(aPos))

        FlushDataL(); 

    TUint newRelCluster=aPos>>ClusterSizeLog2();

    if ( aPos && (aPos==(newRelCluster<<ClusterSizeLog2())) )

        newRelCluster--;

    TUint oldRelCluster=iCurrentPos.iPos>>ClusterSizeLog2();

    if ( iCurrentPos.iPos && (iCurrentPos.iPos==(oldRelCluster<<ClusterSizeLog2())) )

        oldRelCluster--;    

    TInt clusterOffset=newRelCluster-oldRelCluster;

    TInt oldCluster=iCurrentPos.iCluster;

    iCurrentPos.iPos=aPos;

    if (clusterOffset==0)

        return;

    TInt seekOffset=clusterOffset;

    if (iSeekIndex!=NULL)

        { // Can alter iCurrentPos.iCluster

        seekOffset=SeekToPosition(newRelCluster,seekOffset);

        if (seekOffset==0)

            return;

        }

    if (clusterOffset==-1 && seekOffset!=1)

        { // Check previous cluster

        TInt cluster=oldCluster-1;

        if (FAT().GetNextClusterL(cluster) && cluster==oldCluster)

            {

            iCurrentPos.iCluster=oldCluster-1;

            return;

            }

        }

    if (seekOffset<0)

        {

        seekOffset=newRelCluster;

        iCurrentPos.iCluster=iStartCluster;

        }

    while (seekOffset--)

        {

        if (!FAT().GetNextClusterL(iCurrentPos.iCluster))

            {

            __PRINT(_L("CFatFileCB::CheckPosL() corrupt#1"));

            User::Leave(KErrCorrupt);

            }

        TInt cluster=newRelCluster-seekOffset;

        if (iSeekIndex!=NULL && cluster && (cluster>>iSeekIndexSize)<<iSeekIndexSize==cluster)

            SetSeekIndexValueL(cluster,iCurrentPos.iCluster);

        }

    }

void CFatFileCB::SetL(const TFatDirEntry& aFatDirEntry,TShare aShare,const TEntryPos& aPos)

//

// Initialize FileCB from entry data

//

    {

    __PRINT(_L("CFatFileCB::SetL"));

    SetSize(aFatDirEntry.Size()); 

    iCurrentPos.iCluster= FatMount().StartCluster(aFatDirEntry);

    iStartCluster=iCurrentPos.iCluster;

    iCurrentPos.iPos=0;

    iAtt=aFatDirEntry.Attributes();

    iModified= aFatDirEntry.Time(FatMount().TimeOffset());

    iShare=aShare;

    iFileDirPos=aPos;

    SetMaxSupportedSize(KMaxSupportedFatFileSize);

    }

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

// from CFileCB::MExtendedFileInterface

void CFatFileCB::ReadL(TInt64 aPos,TInt& aLength, TDes8* aDes, const RMessagePtr2& aMessage, TInt aOffset)

    {

    __PRINT2(_L("CFatFileCB::ReadL aFilePos=%LU aLength=%d"),aPos,aLength);

    if((TUint64)aPos > KMaxSupportedFatFileSize-1)

        User::Leave(KErrNotSupported);  //-- max. position in the file is 0xFFFFFFFE

    FatMount().CheckStateConsistentL();

    CheckPosL(I64LOW(aPos));

    const TUint startPos = iCurrentPos.iPos;

    const TUint curSize  = (TUint)Size();

    const TUint length   = (TUint)aLength;

    if((startPos + length > curSize) || (startPos > startPos + length) )

        aLength=curSize-startPos;

    FatMount().ReadFromClusterListL(iCurrentPos,aLength,aDes,aMessage,aOffset);

    aLength=iCurrentPos.iPos-startPos;

    }

void CFatFileCB::ReadL(TInt aFilePos,TInt& aLength,const TAny* aTrg,const RMessagePtr2& aMessage)

    {

    ReadL(TInt64(aFilePos),aLength,(TDes8*) aTrg,aMessage, 0);

    }

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

// from CFileCB::MExtendedFileInterface

void CFatFileCB::WriteL(TInt64 aPos,TInt& aLength,const TDesC8* aSrc,const RMessagePtr2& aMessage, TInt aOffset)

    {

    __PRINT2(_L("CFatFileCB::WriteL aFilePos=%LU aLength=%d"),aPos,aLength);

    // FAT supports 32 bits only for file size

    TUint64 endPos = aPos + aLength;

    if(endPos > KMaxSupportedFatFileSize)

        User::Leave(KErrNotSupported);

    FatMount().CheckStateConsistentL();

    FatMount().CheckWritableL();

    const TUint pos = I64LOW(aPos);

    CheckPosL(pos);

    const TUint startCluster = (TUint)iStartCluster;

    const TUint length       = (TUint)aLength;

    endPos = iCurrentPos.iPos + length; 

    if ((endPos           > (TUint)Size()) ||

        (iCurrentPos.iPos > endPos)         ) // Overflow condition 

        DoSetSizeL(iCurrentPos.iPos+length,EFalse);

    TUint startPos=iCurrentPos.iPos;

    TInt badcluster=0;

    TInt goodcluster=0;

    TRAPD(ret, FatMount().WriteToClusterListL(iCurrentPos,aLength,aSrc,aMessage,aOffset,badcluster, goodcluster));

    if (ret == KErrCorrupt || ret == KErrDied)

        {

        if(startCluster == 0)

            { //Empty File, revert all the clusters allocated.

            TInt cluster = iStartCluster;

            iStartCluster = 0;

            SetSize(0);

            FlushAllL();

            iCurrentPos.iCluster = 0;

            iCurrentPos.iPos = 0;

            FAT().FreeClusterListL(cluster);

            FAT().FlushL();

            }

        else

            { //Calculate the clusters required based on file size, revert extra clusters if allocated.

            const TUint curSize = (TUint)Size();

            TUint ClustersNeeded = curSize >> ClusterSizeLog2();

            if(curSize > (ClustersNeeded << ClusterSizeLog2()))

                {

                ClustersNeeded++;

                }

            TInt cluster = iStartCluster;

            while(--ClustersNeeded)

                {

                FAT().GetNextClusterL(cluster);

                }

            iCurrentPos.iCluster = cluster;

            if (FAT().GetNextClusterL(cluster))

                {

                FAT().FreeClusterListL(cluster);

                }

            FAT().WriteFatEntryEofL(iCurrentPos.iCluster);

            FAT().FlushL();

            }

        }

    User::LeaveIfError(ret);

    if(badcluster != 0)

        {

        if(iStartCluster == badcluster)

            {

            iStartCluster = goodcluster;

            FlushStartClusterL();

            }

        else

            {

            TInt aCluster = iStartCluster;

            do

                {

                if((TUint)badcluster == FAT().ReadL(aCluster))

                    {

                    FAT().WriteL(aCluster, goodcluster);

                    FAT().FlushL();

                    break;

                    }

                }

            while(FAT().GetNextClusterL(aCluster));

            }

        }

    aLength=iCurrentPos.iPos-startPos;

    if(FatMount().IsRuggedFSys() && pos+(TUint)aLength>(TUint)Size())

        {

        WriteFileSizeL(pos+aLength);

        }

    }

void CFatFileCB::WriteL(TInt aFilePos,TInt& aLength,const TAny* aSrc,const RMessagePtr2& aMessage)

    {

    WriteL(TInt64(aFilePos),aLength,(TDesC8*) aSrc,aMessage, 0);

    }

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

void CFatFileCB::ResizeIndex(TInt aNewMult,TUint aNewSize)

//

// Resize the seek index to accomodate a larger or smaller filesize

// Assumes KSeekIndexSize is a power of 2.

//

    {

    TInt maxNewIndex=aNewSize>>(ClusterSizeLog2()+aNewMult);

    TInt    index=0;

    TInt    indexEnd=KSeekIndexSize;

    TInt    newValEnd=maxNewIndex;

    if (iSeekIndexSize<aNewMult)

        {

        TInt newVal=index;

        TInt step=1<<(aNewMult-iSeekIndexSize);

        index+=step-1;

        while(index<indexEnd && newVal<newValEnd)

            {

            iSeekIndex[newVal] =  iSeekIndex[index];

            newVal++;

            index+=step;

            }

        while(newVal<indexEnd)

            iSeekIndex[newVal++] =  0;

        }

    else

        {

        TInt diffSize = iSeekIndexSize-aNewMult;

        TInt oldVal=(KSeekIndexSize>>diffSize) - 1;

        TInt newVal=indexEnd-1;

        TInt skip=(1<<diffSize)-1;

        if ((iSeekIndexSize - aNewMult) > KSeekIndexSizeLog2)

            {

            ClearIndex(0); //-- Invalidate every entry.

            }

        else

            {

            while(newVal>=index)

                {

                iSeekIndex[newVal--] =  iSeekIndex[oldVal--];

                for(TInt i=skip;i>0;i--)

                    {   

                    iSeekIndex[newVal--] = 0;

                    }

                }

            }

        }

    iSeekIndexSize=aNewMult;

    }

/**

    Zero freed clusters in the index

    @param  aNewSize new size of the file that the index corresponds to.

            if = 0  all existing index will be zero filled

*/ 

void CFatFileCB::ClearIndex(TUint aNewSize)

    {

    if (!iSeekIndex)

        return;

    if(aNewSize==0)

        {

        //-- zero fill all the array

        Mem::FillZ(iSeekIndex, KSeekIndexSize*sizeof(TUint32));

        return;

        }

    // Files that fill up a cluster exactly do not have a trailing empty

    // cluster. So the entry for that position must also be invalidated

    aNewSize--;

    TInt firstInvalidIndex=aNewSize>>(iSeekIndexSize+ClusterSizeLog2());

    TInt indexLen=KSeekIndexSize-firstInvalidIndex;

    Mem::FillZ(iSeekIndex+firstInvalidIndex, indexLen * sizeof(TUint32));

    }

TInt CFatFileCB::CalcSeekIndexSize(TUint aSize)

//

// Find the nearest power of 2 > aSize

//

    {

    TInt count = 0;

    const TUint indexSize=KSeekIndexSize<<ClusterSizeLog2();//KSeekIndexSize=128

    if (aSize<=indexSize)

      return(count);

    while((aSize>>=1)>0)

        {

        count++;

        }

    return (count - (KSeekIndexSizeLog2 + ClusterSizeLog2()) + 1);

    }

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

void CFatFileCB::SetSizeL(TInt64 aSize)

    {

    __PRINT(_L("CFatFileCB::SetSizeL"));

    // FAT supports 32 bits only for file size

    if (I64HIGH(aSize))

        User::Leave(KErrNotSupported);

    if(FatMount().IsRuggedFSys())

        DoSetSizeL(I64LOW(aSize),ETrue);

    else

        DoSetSizeL(I64LOW(aSize),EFalse);

    }

void CFatFileCB::SetSizeL(TInt aSize)

//

// Envelope function around DoSetSizeL to enable aSize to

// be written to disk for rugged fat file system

//

    {

    SetSizeL(TInt64(aSize));

    }

void CFatFileCB::DoSetSizeL(TUint aSize,TBool aIsSizeWrite)

//

// Extend or truncate the file.

// Expects the modified attribute and iSize are set afterwards.

// Does not alter iCurrentPos, the current file position.

// Writes size of file to disk if aIsSizeWrite set

//

    {

    __PRINT2(_L("CFatFileCB::DoSetSizeL sz:%d, fileWrite=%d"),aSize ,aIsSizeWrite);

    FatMount().CheckStateConsistentL();

    FatMount().CheckWritableL();

    // Can not change the file size if it is clamped

    if(Mount().IsFileClamped(MAKE_TINT64(0,iStartCluster)) > 0)

        User::Leave(KErrInUse);

    iFileSizeModified=ETrue;

    TInt newIndexMult=CalcSeekIndexSize(aSize);

    if (iSeekIndex!=NULL && newIndexMult!=iSeekIndexSize)

        ResizeIndex(newIndexMult,aSize);

    if (aSize == 0)

        {

        if (Size() != 0)

            {

            ClearIndex(0); //-- clear seek index array

            TInt cluster=iStartCluster;

            iStartCluster = 0;

            SetSize(0);

            FlushAllL();

            CheckPosL(0);

            FAT().FreeClusterListL(cluster);

            FAT().FlushL();

            }

        return;

        }

    if (aSize<(TUint)Size())

        {

        if(aIsSizeWrite)        // write file size if decreasing

                WriteFileSizeL(aSize);

        CheckPosL(aSize);

        TInt cluster=iCurrentPos.iCluster;

        if (FAT().GetNextClusterL(cluster))

            {

            FAT().WriteFatEntryEofL(iCurrentPos.iCluster);

            FAT().FreeClusterListL(cluster);

            }

        ClearIndex(aSize);