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

*/

#include "sl_std.h"

#include "sl_scandrv.h"

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

/**

    CScanDrive factory method

    @param  aMount the owning mount

*/

CScanDrive* CScanDrive::NewL(CFatMountCB* aMount)

	{

	if(!aMount)

		{

        ASSERT(0);

        User::Leave(KErrArgument);

        }

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

	CleanupStack::PushL(self);

	self->ConstructL(aMount);

	CleanupStack::Pop();

    return self;

	}

CScanDrive::~CScanDrive()

	{

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

		{

		iClusterListArray[i]->Close();

		delete iClusterListArray[i];

		}

    iMediaFatBits.Close();

    iScanFatBits.Close();

	}

/**

    Creates the structure of this class.

    @param aMount The owning mount

*/

void CScanDrive::ConstructL(CFatMountCB* aMount)

    {

    ASSERT(aMount);

    //--- setting up 

	iMount			 = aMount;

	iGenericError	 = ENoErrors;

	iDirError		 = ENoDirError;

	iHangingClusters = 0;

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

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

    //-- 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 = MaxClusters();

    CleanupClosePushL(iMediaFatBits);

    CleanupClosePushL(iScanFatBits);

    iMediaFatBits.CreateL(KClustersNum);

    iScanFatBits.CreateL(KClustersNum);

    CleanupStack::Pop(&iScanFatBits);

    CleanupStack::Pop(&iMediaFatBits);

    }

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

/**

    FAT type-agnostic 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 KMaxClusters = MaxClusters();

    iMediaFatBits.Fill(0);

    __PRINT1(_L("CScanDrive::DoParseFatL(), clusters:%d"), KMaxClusters);

    for(TInt i=KFatFirstSearchCluster; i<KMaxClusters; ++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()

    {

    const TInt    KNumClusters = MaxClusters();

    __PRINT1(_L("CScanDrive::DoParseFat32L(), clusters:%d"), KNumClusters);

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

    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 fatParseBuf;

    CleanupClosePushL(fatParseBuf);

    //-- allocate memory for FAT parse buffer

    fatParseBuf.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(fatParseBuf.Ptr(), bytesToRead);

        //-- read portion of the FAT into buffer

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

        //-- parse the buffer and populate bit vector

        DoParseFat32Buf(ptrData, currFatEntry);

        mediaPos += bytesToRead;

        rem -= bytesToRead;

        }

    fatParseBuf.Close();

    CleanupStack::PopAndDestroy(&fatParseBuf); 

    }

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

/**

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

    TInt nRes;

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

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

        TRAP(nRes, DoParseFat32L())

        if(nRes == KErrNone)

            return;

        }

    //-- use old FAT-agnostic parsing

    DoParseFatL();

    }

/**

    @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 discovered at all.

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

    @return The code describing the problem.

*/

CScanDrive::TGenericError CScanDrive::ProblemsDiscovered() const

{

    if(IsDirError()) 

        return EScanDriveDirError;

}

/**

    Sets the flag indicating that there are errors in filesystem structure

    See ProblemsDiscovered()

    @param  aError a code describing the error

*/

void CScanDrive::IndicateErrorsFound(TGenericError aError)

{

    ASSERT(aError != ENoErrors);

    iGenericError = aError;

}

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

/**

    Starts the scanner.

    @param	aMode	Specifies the operational mode.

*/

void CScanDrive::StartL(TScanDriveMode aMode)

	{

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

    iScanDriveMode = aMode;

    //-- used for measuring time

    TTime   timeStart;

    TTime   timeEnd;

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

	ReadMediaFatL();

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

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

        //__PRINT1(_L("#@@@ CScanDrive #1:%d ms "), elapsedTime);

	CheckDirStructureL();

    //-- uncomment a line below if you need to compare real and restored FAT tables and print out all differences

    //CompareFatsL(EFalse);

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

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

        //__PRINT1(_L("#@@@ CScanDrive #2:%d ms "), elapsedTime);

    if(CheckDiskMode())

        {//-- in check disk mode it is nesessarily just to detech FS errors

        CompareFatsL(ETrue); //-- will stop on the first error found

        }

    else

        {//-- In ScanDrive mode we need to find and fix Rugged FAT artefacts.

        if(IsDirError())

		    FixupDirErrorL();

	    CompareAndFixFatsL();

        }

	PrintErrors();

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

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

    (void)elapsedTime;

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

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

	return;

	}

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

/**

    Fix errors detected by the drive scan

    @leave System wide error code

*/

void CScanDrive::FixupDirErrorL()

	{

	ASSERT(!CheckDiskMode());

    if(!IsDirError())

		return;

    if(iDirError==EScanMatchingEntry)

		{

		FindSameStartClusterL();

		FixMatchingEntryL();

		}

	else

		{

        FixPartEntryL();

        }

    IndicateErrorsFound(EScanDriveDirError); //-- 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(TUint 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;

			}

		}

    if(err != KErrNone)

        {

        __PRINT1(_L("CScanDrive::FindSameStartClusterL() #1 %d"), err);

        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(TUint32 aDirCluster)

	{

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

	if(aDirCluster < (TUint)iMount->RootIndicator() || aDirCluster >= MaxClusters())

        {

        __PRINT(_L("CScanDrive::FindStartCluster() #!\n"));

        IndicateErrorsFound(EBadClusterNumber);

        User::Leave(KErrCorrupt);

        }

	if(++iRecursiveDepth==KMaxScanDepth)

		{

		--iRecursiveDepth;

		return(KErrNotFound);

		}

	TEntryPos entryPos(aDirCluster,0);

	TInt dirEntries=0;

	for(;;)

		{

		TFatDirEntry entry;

		ReadDirEntryL(entryPos,entry);

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

			{

			if(IsEndOfRootDir(entryPos))

				break;

			MoveToNextEntryL(entryPos);

			continue;

			}

		if(entry.IsEndOfDirectory())

			break;

		TEntryPos vfatPos=entryPos;

		const TBool isComplete = MoveToVFatEndL(entryPos,entry,dirEntries);

        if(!isComplete)

            {

            __PRINT(_L("CScanDrive::FindStartCluster() #2\n"));

            IndicateErrorsFound(EEntrySetIncomplete);

            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((TUint)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 structure 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(TUint 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]);

			}

		}

	}

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

/**

    This 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(TUint32 aCluster)

	{