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

// 

//

#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);

		FAT().FlushL();

		return;

		}

	TUint newSize=aSize>>ClusterSizeLog2();	//	Number of clusters we now need

	if (aSize > (newSize<<ClusterSizeLog2()))

		newSize++;	//	File size is not an exact multiple of cluster size

					//	Increment the number of clusters required to accomodate tail

	if (iStartCluster==0)

		{

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

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

        TInt tempStartCluster=FAT().AllocateClusterListL(newSize, FAT().FreeClusterHint());

		FAT().FlushL();

		iCurrentPos.iCluster=tempStartCluster;

		iStartCluster=tempStartCluster;

		SetSize(aSize);

		FlushAllL();

		}

	else

		{

		const TUint curSize = (TUint)Size(); 

		TUint oldSize=curSize>>ClusterSizeLog2();	//	Number of clusters we had previously

		if (curSize>(oldSize<<ClusterSizeLog2()))

			oldSize++;

		TInt newClusters=newSize-oldSize;	//	Number of clusters we need to prepare

		if (newClusters)

			{

			TEntryPos currentPos=iCurrentPos;

			CheckPosL(Size());

			FAT().ExtendClusterListL(newClusters,iCurrentPos.iCluster);

			iCurrentPos=currentPos;

			}

		FAT().FlushL();

		if(aIsSizeWrite)			// write file size if increasing

			WriteFileSizeL(aSize);

		}

	}

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

/**

    Set the entry's attributes and modified time.

*/

void CFatFileCB::SetEntryL(const TTime& aTime,TUint aSetAttMask,TUint aClearAttMask)

	{

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

    FatMount().CheckStateConsistentL();

    FatMount().CheckWritableL();

	TUint setAttMask=aSetAttMask&KEntryAttMaskSupported;

	if (setAttMask|aClearAttMask)

		{

		iAtt|=setAttMask;

		iAtt&=(~aClearAttMask);

		}

	if (aSetAttMask&KEntryAttModified)

		iModified=aTime;

	iAtt|=KEntryAttModified;

	}

/**

    This is a RuggedFAT - specific method. Writes file size to the corresponding field of this

    file direcrory entry.

*/

void CFatFileCB::WriteFileSizeL(TUint aSize)

	{

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

	TEntryPos entryPos=iFileDirPos;

	entryPos.iPos+=_FOFF(SFatDirEntry,iSize);

	TPtrC8 size((TUint8*)&aSize,sizeof(TUint));

    //-- use directory cache when dealing with directories

    FatMount().DirWriteL(entryPos,size);

	iFileSizeModified=EFalse;

    }

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

/** 

    Flush file size, attributes, time etc. to the media.

    It doesn't matter if whole directory entry is being written of only part of it. Anyway, a single DOS

    dir. entry always fits into 1 sector.

*/

void CFatFileCB::FlushDataL()

	{

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

    FlushAllL();

	}

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

/** 

    Flush the fide directory entry data: files size, attributes, time etc. 

*/

void CFatFileCB::FlushAllL()

	{

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

    if (Mount().IsCurrentMount()==EFalse)

		User::Leave(KErrDisMounted);

    FatMount().CheckStateConsistentL();

    FatMount().CheckWritableL();

	TFatDirEntry entry;

	FatMount().ReadDirEntryL(iFileDirPos,entry);

	__ASSERT_ALWAYS(entry.IsEndOfDirectory()==EFalse,User::Leave(KErrCorrupt));

	entry.SetAttributes(iAtt&KEntryAttMaskSupported);

	entry.SetSize(Size());

	entry.SetTime(iModified, FatMount().TimeOffset());

	entry.SetStartCluster(iStartCluster);

	TBool setNotify = FatMount().GetNotifyUser();

	if(setNotify)

		{

		FatMount().SetNotifyOff();	// do not launch a notifier

		}

	TRAPD(ret, FatMount().WriteDirEntryL(iFileDirPos,entry));

	if(setNotify)

		{

		FatMount().SetNotifyOn();

		}

	User::LeaveIfError(ret);

	iAtt&=(~KEntryAttModified);

	iFileSizeModified=EFalse;

	}

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

/**

    Rename already opened file.

    @param  aNewName new file name; all trailing dots from the name will be removed

*/

void CFatFileCB::RenameL(const TDesC& aNewName)

	{

    __PRINT2(_L("CFatFileCB::RenameL[0x%x], name:%S"),this, &aNewName);

    FatMount().CheckStateConsistentL();

    FatMount().CheckWritableL();

    const TPtrC fileName = RemoveTrailingDots(aNewName); //-- remove trailing dots from the name

	FatMount().DoRenameOrReplaceL(*iFileName, fileName, CFatMountCB::EModeRename,iFileDirPos);

    AllocBufferL(iFileName, fileName);

	if(!FatMount().IsRuggedFSys())

		FAT().FlushL();

	}

//***********************************************************

//* BlockMap interface

//***********************************************************

TInt CFatFileCB::BlockMap(SBlockMapInfo& aInfo, TInt64& aStartPos, TInt64 aEndPos)

//

// Retrieves the block map of a given section of the file, in the FAT file system.

//	

	{

	__PRINT2(_L("CFatFileCB::BlockMap aStartPos=%ld aEndPos=%ld"), aStartPos, aEndPos);

	if ( I64HIGH(aStartPos) || I64HIGH(aEndPos) )

		return KErrNotSupported;

    TUint startPos = I64LOW(aStartPos);

	TUint endPos = I64LOW(aEndPos);

	// aEndPos will always be >=0 at this point

	const TUint length = endPos - startPos;

	// Store the position of cluster zero in aInfo

	CFatMountCB& fatMount = FatMount();

	TInt drvNo=-1;

	TBusLocalDrive* locDrv;

	if((fatMount.LocalDrive()->GetLocalDrive(locDrv)==KErrNone) && ((drvNo=GetLocalDriveNumber(locDrv))>=0) && (drvNo<KMaxLocalDrives))

		aInfo.iLocalDriveNumber=drvNo;

	else

		return KErrNotSupported;

	// Fetch the address of cluster 0

	aInfo.iStartBlockAddress = fatMount.FAT().DataPositionInBytes(KFirstClusterNum);

	TRAPD(r, CheckPosL(startPos));

	if (r != KErrNone)

		return r;

	aInfo.iBlockStartOffset = fatMount.ClusterRelativePos(iCurrentPos.iPos);

	aInfo.iBlockGranularity = 1 << FatMount().ClusterSizeLog2();

	const TUint myStartPos = iCurrentPos.iPos;

	if ( myStartPos + length > (TUint)Size())

		return KErrArgument;

	TRAP(r, FatMount().BlockMapReadFromClusterListL(iCurrentPos, length, aInfo));

	if (r != KErrNone)

		return r;

	aStartPos = iCurrentPos.iPos;

	if ((I64LOW(aStartPos) == (TUint)Size()) || ( I64LOW(aStartPos) == (myStartPos + length)))

		return KErrCompletion;

	else

		return KErrNone;

	}

TInt CFatFileCB::GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput)

	{

	switch(aInterfaceId)

		{

		case EExtendedFileInterface:

			((CFileCB::MExtendedFileInterface*&) aInterface) = this;

			return KErrNone;

		case EBlockMapInterface:

			aInterface = (CFileCB::MBlockMapInterface*) this;

			return KErrNone;

		case EGetLocalDrive:

			return FatMount().LocalDrive()->GetLocalDrive((TBusLocalDrive*&) aInterface);

		default:

			return CFileCB::GetInterface(aInterfaceId,aInterface,aInput);

		}

	}

/**

    Overwrites file's start cluster (iStartCluster) in its directory entry.

*/

void CFatFileCB::FlushStartClusterL()

	{

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

    CFatMountCB& mount = FatMount();

    TFatDirEntry dirEntry;

    mount.ReadDirEntryL(iFileDirPos, dirEntry);      //-- read this file's dir. entry

    dirEntry.SetStartCluster(iStartCluster);         //-- set new start cluster

    mount.WriteDirEntryL(iFileDirPos, dirEntry);//-- write the entry back

	}