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

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

	CleanupStack::PushL(self);

	self->ConstructL(aMount);

	CleanupStack::Pop();

	}

CScanDrive::~CScanDrive()

	{

		{

		iClusterListArray[i]->Close();

		delete iClusterListArray[i];

		}

    iMediaFatBits.Close();

    iScanFatBits.Close();

	}

/**

*/

void CScanDrive::ConstructL(CFatMountCB* aMount)

    {

    CleanupClosePushL(iMediaFatBits);

    CleanupClosePushL(iScanFatBits);

    iMediaFatBits.CreateL(KClustersNum);

    CleanupStack::Pop(&iScanFatBits);

    CleanupStack::Pop(&iMediaFatBits);

    }

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

/**

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

*/

void CScanDrive::DoParseFatL()

    {

    iMediaFatBits.Fill(0);

	    {

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

        TRAP(nRes, DoParseFat32L())

        if(nRes == KErrNone)

            return;

        }

    //-- use old FAT-agnostic parsing

    DoParseFatL();

    }

/**

*/

TBool CScanDrive::IsDirError() const

	{

	return(iDirError!=0);

	}

/**

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

*/

{

}

/**

    Sets the flag indicating than there are errors in filesystem structure

    See ProblemsDiscovered()

*/

{

}

/**

*/

	{

    //-- used for measuring time

    TTime   timeStart;

    TTime   timeEnd;

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

	ReadMediaFatL();

	CheckDirStructureL();

	PrintErrors();

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

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

	}

/**

*/

void CScanDrive::FixupDirErrorL()

	{

		return;

    if(iDirError==EScanMatchingEntry)

		{

		FindSameStartClusterL();

		FixMatchingEntryL();

		}

	else

		{

        FixPartEntryL();

        }

	}

/**

*/

void CScanDrive::FindSameStartClusterL()

	{

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

	if(err==KErrNone)

		return;

		{

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

	}

/**

*/

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

	}

/**

*/

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

	{

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

		{

		TBool complete=AddMatchingEntryL(aEntryPos);

		if(complete)

			return(KErrNone);

		}

	else if(aEntry.Attributes()&KEntryAttDir)

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

	return(KErrNotFound);

	}

/**

*/

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

		{

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

		++iListArrayIndex;

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

			{

			iRecursiveDepth=0;

			CheckDirL((*clusterList)[j]);

			}

		}

	}

/**

*/

	{

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

	// check depth of recursion

	if(++iRecursiveDepth==KMaxScanDepth)

		{

		AddToClusterListL(aCluster);

		--iRecursiveDepth;

		return;

		}

	++iDirsChecked;

	TEntryPos entryPos(aCluster,0);

	TInt dirEntries=0;

	FOREVER

		{

		TFatDirEntry entry;

		ReadDirEntryL(entryPos,entry);

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

			++dirEntries;

			{

			if(IsEndOfRootDir(entryPos))

				break;

			MoveToNextEntryL(entryPos);