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

// f32\sfat32\sl_scan32.cpp

// ScanDrive code, specific for EFAT32.FSY

// 

//

/**

 @file

 @internalTechnology

*/

//#define DEBUG_SCANDRIVE

#include "sl_std.h"

#include "sl_scandrv.h"

const TInt KEndOfDirectory			= 0xFFFF;   ///< End of directory marker

const TInt KMaxScanDepth			= 20;       ///< Maximum scan depth of to avoid stack over flow 

const TInt KClusterListGranularity	= 8;        ///< Granularity of cluster list used for storage of clusters when KMaxScanDepth is reached

/**

Creates a CScanDrive

@param aMount The owning mount

*/

 CScanDrive* CScanDrive::NewL(CFatMountCB* aMount)

	{

	if(aMount==NULL)

		User::Leave(KErrArgument);

	CScanDrive* self=new (ELeave) CScanDrive();

	CleanupStack::PushL(self);

	self->ConstructL(aMount);

	CleanupStack::Pop();

	return self;

	}

CScanDrive::~CScanDrive()

	{

	for(TInt i=0;i<KMaxArrayDepth && iClusterListArray[i]!=NULL;++i)

		{

		iClusterListArray[i]->Close();

		delete iClusterListArray[i];

		}

    iMediaFatBits.Close();

    iScanFatBits.Close();

	}

/**

Allocates the Cluster array, the bit packed Fats and if run in a seperate

thread the extra CFatTable and cluster buffer

@param aMount The owning mount

*/

void CScanDrive::ConstructL(CFatMountCB* aMount)

    {

	iMount=aMount;

    //-- create bit vectors that will represent FAT on media and reconstructed by ScanDrive

    //-- each bit in the vector represents 1 FAT cluster.

    const TUint32 KClustersNum = iMount->UsableClusters()+KFatFirstSearchCluster; //-- UsableClusters() doesn't count first 2 unused clusers

    CleanupClosePushL(iMediaFatBits);

    CleanupClosePushL(iScanFatBits);

    iMediaFatBits.CreateL(KClustersNum);

    iScanFatBits.CreateL(KClustersNum);;

    CleanupStack::Pop(&iScanFatBits);

    CleanupStack::Pop(&iMediaFatBits);

    }

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

/**

    FAT type-agnnostic parser. Reads whole FAT and sets up a bit vector.

    for FAT12/16 it's OK, because the FAT12/16 is fully cached.

*/

void CScanDrive::DoParseFatL()

    {

    const TInt MaxClusters = iMount->UsableClusters()+KFatFirstSearchCluster;

    iMediaFatBits.Fill(0);

    for(TInt i=KFatFirstSearchCluster; i<MaxClusters; ++i)

	    {

        const TUint32 nFatEntry = ReadFatL(i);

        //-- each '1' bit represents a used cluster 

        if(nFatEntry != KSpareCluster) 

            iMediaFatBits.SetBit(i);

	    }

    }

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

/**

    Parse FAT32 buffer.

    @param  aBuf            buffer, containing FAT32 entries (current portion of FAT)

    @param  aCurrFatEntry   current FAT entry processed

*/

void CScanDrive::DoParseFat32Buf(const TPtrC8& aBuf, TUint32& aCurrFatEntry)

    {

    ASSERT((aBuf.Size() & (sizeof(TFat32Entry)-1)) == 0);

    const TInt KNumEntries = aBuf.Size() >> KFat32EntrySzLog2;

    const TFat32Entry* const pFatEntry = (const TFat32Entry*)(aBuf.Ptr()); 

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

        {

        if(aCurrFatEntry >= KFatFirstSearchCluster)

            {

            if((pFatEntry[i] & KFat32EntryMask) != KSpareCluster)

                {//-- found a non-free FAT32 entry

                iMediaFatBits.SetBit(aCurrFatEntry);

                }

            }

        ++aCurrFatEntry;    

        }

    }

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

/**

    A specialised method to read and parse FAT32 using a larger buffer.

    1. Larger buffer gives better read performance

    2. using dedicated buffer doesn't trash FAT32 LRU cache.

*/

void CScanDrive::DoParseFat32L()

    {

    ASSERT(iMount->FatType() == EFat32);

    const TUint32 KNumClusters  = iMount->UsableClusters()+KFatFirstSearchCluster;

    const TUint32 KFat1StartPos = iMount->StartOfFatInBytes();

    const TUint32 KFatSize      = KNumClusters * sizeof(TFat32Entry); //-- usable size of one FAT.

    const TUint32 KFatBufSz = 32*K1KiloByte; //-- buffer size for FAT reading. 32K seems to be optimal size

    iMediaFatBits.Fill(0);

    RBuf8 buf;

    CleanupClosePushL(buf);

    //-- allocate memory for FAT parse buffer

    buf.CreateMaxL(KFatBufSz);

    //-- read FAT directly from the media into the large buffer and parse it

    TUint32 rem = KFatSize;

    TUint32 mediaPos = KFat1StartPos;   

    TUint32 currFatEntry = 0;

    while(rem)

        {

        const TUint32 bytesToRead=Min(rem, KFatBufSz);

        TPtrC8 ptrData(buf.Ptr(), bytesToRead);

        //-- read portion of the FAT into buffer

        User::LeaveIfError(iMount->LocalDrive()->Read(mediaPos, bytesToRead, buf)); 

        //-- parse the buffer and populate bit vector

        DoParseFat32Buf(ptrData, currFatEntry);

        mediaPos += bytesToRead;

        rem -= bytesToRead;

        }

    buf.Close();

    CleanupStack::PopAndDestroy(&buf); 

    }

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

/**

    Sets up a bit list representation of the media fat

    Reads whole FAT and sets '1' bits in the bit vector corresponding to the occupied clusters.

*/

void CScanDrive::ReadMediaFatL()

    {

    ASSERT(iMount->ConsistentState());

    if(iMount->FatType() == EFat32)

        {//-- for FAT32 try to use specialised method of parsing

        TInt nRes;

        TRAP(nRes, DoParseFat32L())

        if(nRes == KErrNone)

            return;

        }

    //-- use old FAT-agnostic parsing

    DoParseFatL();

    }

/**

Set a cluster as visited in the bit packed scan Fat

@param aCluster Cluster number

*/

void CScanDrive::SetUsedL(TUint aCluster)

	{

	__ASSERT_ALWAYS(aCluster >= KFatFirstSearchCluster && aCluster < (KFatFirstSearchCluster+iMount->UsableClusters()),User::Leave(KErrCorrupt));

    iScanFatBits.SetBit(aCluster);

	}

/**

Query whether a cluster is already set as used 

@param aCluster Cluster to query

*/

TBool CScanDrive::AlreadyUsedL(TUint aCluster) const

	{

	__ASSERT_ALWAYS(aCluster >= KFatFirstSearchCluster && aCluster < (KFatFirstSearchCluster+iMount->UsableClusters()),User::Leave(KErrCorrupt));

    return iScanFatBits[aCluster];

	}

/**

@param aPos Position in a directory cluster

@return  ETrue if aPos is the last entry in the root directory

*/

TBool CScanDrive::IsEndOfRootDir(const TEntryPos& aPos)const

	{

	return(iMount->IsRootDir(aPos)&&(iMount->StartOfRootDirInBytes()+aPos.iPos==(iMount->RootDirEnd()-KSizeOfFatDirEntry)));

	}

/**

@param aVal Value of the cluster to be tested

@return ETrue if aVal is the end of cluster marker

*/

TBool CScanDrive::IsEofF(TInt aVal) const 

	{

    return iMount->IsEndOfClusterCh(aVal);

	}

/**

@return True if a directory error has been found

*/

TBool CScanDrive::IsDirError() const

	{

	return(iDirError!=0);

	}

/**

    After StartL() and finishing allows us to know if there were any problems at all.

    The client may wish to remount the filesystem if there were errors.

    @return EFalse if there were no problems in FS.

*/

TBool CScanDrive::ProblemsDiscovered() const

{

    return IsDirError() || iFoundProblems;

}

/**

    Sets the flag indicating than there are errors in filesystem structure

    See ProblemsDiscovered()

*/

void CScanDrive::IndicateErrorsFound()

{

    iFoundProblems = ETrue;

}

/**

Start point for scan drive also fixes up errors 

@return The result of the scan

@leave 

*/

TInt CScanDrive::StartL()

	{

	__PRINT1(_L("CScanDrive::StartL(), drive:%d"), iMount->DriveNumber());

    //-- used for measuring time

    TTime   timeStart;

    TTime   timeEnd;

    timeStart.UniversalTime(); //-- take start time

	ReadMediaFatL();

	CheckDirStructureL();

#if defined(DEBUG_SCANDRIVE)

	CompareFatsL();

#endif

	if(IsDirError())

		FixupDirErrorL();

	WriteNewFatsL();

#if defined(DEBUG_SCANDRIVE)

	PrintErrors();

#endif

    timeEnd.UniversalTime(); //-- take end time

    const TInt msScanTime = (TInt)( (timeEnd.MicroSecondsFrom(timeStart)).Int64() / K1mSec);

    (void)msScanTime;

    __PRINT1(_L("CScanDrive: Directories visisted = %d\n"),iDirsChecked);

    __PRINT1(_L("#@@@ CScanDrive time taken:%d ms "), msScanTime);

	return KErrNone;

	}

/**

Fix errors detected by the drive scan

@leave System wide error code

*/

void CScanDrive::FixupDirErrorL()

	{

	if(!IsDirError())

		return;

    if(iDirError==EScanMatchingEntry)

		{

		FindSameStartClusterL();

		FixMatchingEntryL();

		}

	else

		{

        FixPartEntryL();

        }

    IndicateErrorsFound(); //-- indicate that we have found errors

	}

/**

Find positions of entries with same start cluster for error correction, searches

the whole volume. Starts at the root directory. 

@leave System wide error code

*/

void CScanDrive::FindSameStartClusterL()

	{

	TInt err=FindStartClusterL(iMount->RootIndicator());

	if(err==KErrNone)

		return;

	for(TInt i=0;i<KMaxArrayDepth && iClusterListArray[i]!=NULL;++i)

		{

		RArray<TInt>* clusterList=iClusterListArray[i];

		for(TInt j=0;j<clusterList->Count();++j)

			{

			iRecursiveDepth=0;

			err=FindStartClusterL((*clusterList)[j]);

			if(err==KErrNone)

				return;

			}

		}

	__ASSERT_ALWAYS(err==KErrNone,User::Leave(KErrNotFound));

	}

/**

Scan through directory structure looking for start cluster found in iMatching

@param aDirCluster Start cluster for scan to start

@return System wide error value

@leave 

*/

TInt CScanDrive::FindStartClusterL(TInt aDirCluster)

	{

	__PRINT1(_L("CScanDrive::FindStartCluster dirCluster=%d"),aDirCluster);

	__ASSERT_ALWAYS(aDirCluster>=iMount->RootIndicator(),User::Leave(KErrCorrupt));

	if(++iRecursiveDepth==KMaxScanDepth)

		{

		--iRecursiveDepth;

		return(KErrNotFound);

		}

	TEntryPos entryPos(aDirCluster,0);

	TInt dirEntries=0;

	FOREVER

		{

		TFatDirEntry entry;

		ReadDirEntryL(entryPos,entry);

		if(entry.IsParentDirectory()||entry.IsCurrentDirectory()||entry.IsErased())

			{

			if(IsEndOfRootDir(entryPos))

				break;

			MoveToNextEntryL(entryPos);

			continue;

			}

		if(entry.IsEndOfDirectory())

			break;

		TBool isComplete;

		TEntryPos vfatPos=entryPos;

		isComplete=MoveToVFatEndL(entryPos,entry,dirEntries);

		__ASSERT_ALWAYS(isComplete,User::Leave(KErrBadName));

		TInt err=CheckEntryClusterL(entry,vfatPos);

		if(err==KErrNone)

			{

			--iRecursiveDepth;

			return(err);

			}

		if(IsEndOfRootDir(entryPos))

			break;

		MoveToNextEntryL(entryPos);

		}

	--iRecursiveDepth;

	return(KErrNotFound);

	}

/**

Procces aEntry to find matching start cluster

@param aEntry Directory entry to check

@param aEntryPos Position of directory to check

@return System wide error value

@leave 

*/

TInt CScanDrive::CheckEntryClusterL(const TFatDirEntry& aEntry, const TEntryPos& aEntryPos)

	{

	__PRINT(_L("CScanDrive::CheckEntryClusterL"));

	if(iMount->StartCluster(aEntry)==iMatching.iStartCluster)

		{

		TBool complete=AddMatchingEntryL(aEntryPos);

		if(complete)

			return(KErrNone);

		}

	else if(aEntry.Attributes()&KEntryAttDir)

		return(FindStartClusterL(iMount->StartCluster(aEntry)));

	return(KErrNotFound);

	}

/**

Checks directory strucutre for errors, can be considered the start point of the scan.  

Handles recursion depth to avoid stack overflow.

@leave System wide error code

*/

void CScanDrive::CheckDirStructureL()

	{

	CheckDirL(iMount->RootIndicator());

	// Due to recursive nature of CheckDirL when a depth of

	// KMaxScanDepth is reached clusters are stored in a list

	// and passed into CheckDirL afresh

	for(TInt i=0;i<KMaxArrayDepth && iClusterListArray[i]!=NULL;++i)

		{

		RArray<TInt>* clusterList=iClusterListArray[i];

		++iListArrayIndex;

		for(TInt j=0;j<clusterList->Count();++j)

			{

			iRecursiveDepth=0;

			CheckDirL((*clusterList)[j]);

			}

		}

	}

/**

Function is called recursively with Process entry untill the whole volume has been scanned.

Each directory entry is scanned for errors, these are recorded for later fixing. 

@param aCluster Directory cluster to start checking

@leave System wide error codes

*/

void CScanDrive::CheckDirL(TInt aCluster)

	{

	__PRINT1(_L("CScanDrive::CheckDirL aCluster=%d"),aCluster);

	__ASSERT_ALWAYS(aCluster>=0,User::Leave(KErrCorrupt));

	// check depth of recursion

	if(++iRecursiveDepth==KMaxScanDepth)

		{

		AddToClusterListL(aCluster);

		--iRecursiveDepth;

		return;

		}

#if defined(DEBUG_SCANDRIVE)

	++iDirsChecked;

#endif

	TEntryPos entryPos(aCluster,0);

	TInt dirEntries=0;

	FOREVER

		{

		TFatDirEntry entry;

		ReadDirEntryL(entryPos,entry);

		if(!iMount->IsEndOfClusterCh(entryPos.iCluster))

			++dirEntries;

		if(entry.IsParentDirectory()||entry.IsCurrentDirectory()||entry.IsErased())

			{

			if(IsEndOfRootDir(entryPos))

				break;

			MoveToNextEntryL(entryPos);

			continue;

			}

		if(entry.IsEndOfDirectory())

			{

			if(aCluster)	

				WriteClusterChainL(aCluster,dirEntries<<KSizeOfFatDirEntryLog2);

			break;

			}

		TEntryPos origPos=entryPos;

		TFatDirEntry origEntry=entry;

		TInt origDirEntries=dirEntries;

		TBool isComplete;

		isComplete=MoveToVFatEndL(entryPos,entry,dirEntries);

		// Only assume that this is a corrupted VFAT entry if the VFAT attributes are set; 

		// assuming a non-VFAT corrupted entry is a VFAT entry is dangerous as we then assume that the 

		// first byte is a count of entries to skip, thus completely invalidating the next <n> directories.

		if (!isComplete && origEntry.IsVFatEntry())

			{

			AddPartialVFatL(origPos,origEntry);

			if(entryPos.iCluster!=KEndOfDirectory)

				{

				TInt toMove=origEntry.NumFollowing()-(dirEntries-origDirEntries);

				if(toMove)

					MovePastEntriesL(entryPos,entry,toMove,dirEntries);

				}

			else

				{

				// we fell off the end of the directory file, so just strip this

				// incomplete long file name entry