// Copyright (c) 2001-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:

//

#include <e32std.h>

#include <e32std_private.h>

#include "sr_rofs.h"

#include <rofs.h>

CDirectoryCache::CDirectoryCache( CRofsMountCB& aMount, CProxyDrive& aLocalDrive, const TRofsHeader& aHeader )

	: iMount( aMount ), iLocalDrive( aLocalDrive ), 

	iTreeMediaOffset( aHeader.iDirTreeOffset ),

	iTreeSize( aHeader.iDirTreeSize ),

	iFilesMediaOffset( aHeader.iDirFileEntriesOffset ),

	iFilesSize( aHeader.iDirFileEntriesSize )

	{

	}

CDirectoryCache::~CDirectoryCache()

	{

	delete iTreeBuffer;

	delete iFilesBuffer;

	}

void CDirectoryCache::ConstructL()

	{

	iTreeBuffer = HBufC8::NewL( iTreeSize );

	iFilesBuffer = HBufC8::NewL( iFilesSize );

	TPtr8 ptr = iTreeBuffer->Des();

	User::LeaveIfError( iLocalDrive.Read( iTreeMediaOffset, iTreeSize, ptr) );

	TPtr8 ptr2 = iFilesBuffer->Des();

	User::LeaveIfError( iLocalDrive.Read( iFilesMediaOffset, iFilesSize, ptr2) );

	}

void CDirectoryCache::FindLeafDirL(const TDesC& aName, const TRofsDir*& aDir) const

//

// Navigate the path to find the leaf directory, starting at aDir.

//

	{

	TLex lex(aName);

	TInt r;

	FOREVER

		{

		lex.Inc(); // Skip the file separator

		lex.Mark();

		r=lex.Remainder().Locate(KPathDelimiter);

		if ( KErrNotFound == r )

			{

			r=lex.Remainder().Length();

			}

		if ( 0 == r ) // End of the path

			{

			break;

			}

		lex.Inc(r); // Set the token length

		const TRofsEntry* subDirEntry = NULL;

		TInt r = DoBinaryFindSubDir(lex.MarkedToken(), KEntryAttDir|KEntryAttMatchExclusive, aDir, subDirEntry );

		if( KErrNone != r )

			{

			User::Leave( KErrPathNotFound );

			}

		__ASSERT_DEBUG( 0 != (subDirEntry->iAtt & KEntryAttDir ), CRofs::Panic( CRofs::EPanicEntryNotDir ));

		aDir = RofsDirFromSubDirEntry( subDirEntry );

		}

	}

TInt CDirectoryCache::DoBinaryFindSubDir(const TDesC& aName, TUint aAtt, const TRofsDir* aDir, const TRofsEntry*& aSubDirEntry ) const

	//

	// Scan the directory aDir looking for subdirectory aName using binary search.

	// aName cannot contain wildcards and aSubDirEntry should always be NULL.

	// If a matching entry is found writes pointer to the entry into aSubDirEntry

	// and returns KErrNone.

	//

	{

	if (aSubDirEntry != NULL)

		{

		return DoFindSubDir(aName, aAtt, aDir, aSubDirEntry);

		}

	TInt numDirs=GetDirCount(aDir);

	TInt topIndex=numDirs-1;

	TInt bottomIndex=0;

	TBool bFound=EFalse;

	TInt retVal=KErrNotFound;

	if(topIndex>=0)

		{

		TUint16* offsets = (TUint16*) ((TUint8*) aDir + aDir->iStructSize);

		offsets += 2; //to skip file and dir counts

		while((!bFound) && (topIndex>=bottomIndex))

		{

			TInt32 middleIndex;

			const TRofsEntry* pCurrentEntry=NULL;

			middleIndex=(topIndex+bottomIndex)>>1;

			//Offsets for directories are relative to the start of the

			//directory block

			TUint8* ptr = (TUint8*) aDir + (offsets[middleIndex] << 2);

			pCurrentEntry = (TRofsEntry*)  ptr;

			TPtrC currName=TPtrC((const TText*)&pCurrentEntry->iName[0],pCurrentEntry->iNameLength);

			TInt result=Compare(aName,currName);

			if(result<0)

				topIndex=middleIndex-1;

			else if(result>0)

				bottomIndex=middleIndex+1;

			else

				{

				bFound=ETrue;	// exit loop

				if (iMount.MatchEntryAtt(pCurrentEntry->iAtt, aAtt))

					{

					aSubDirEntry=pCurrentEntry;

					retVal=KErrNone;

					}

				}

			}

		}

	return retVal;

	}

TInt CDirectoryCache::DoFindSubDir(const TDesC& aName, TUint aAtt, const TRofsDir* aDir, const TRofsEntry*& aSubDirEntry ) const

	//

	// Scan the directory aDir looking for subdirectory aName. If aSubDirEntry is

	// not NULL the search starts from the entry AFTER aSubDirEntry.

	// If a matching entry is found writes pointer to the entry into aSubDirEntry

	// and returns KErrNone.

	//

	{

	const TRofsEntry* pEntry = aSubDirEntry;	// which entry

	const TRofsEntry* const pEnd = (TRofsEntry*)EndOfDirPlusOne( aDir );

	if( !pEntry )

		{

		pEntry = FirstSubDirEntryFromDir( aDir );

		}

	else

		{

		// move to next entry

		__ASSERT_DEBUG( pEntry >= FirstSubDirEntryFromDir( aDir ), CRofs::Panic( CRofs::EPanicEntryBeforeDirectory ));

		__ASSERT_DEBUG( pEntry < pEnd, CRofs::Panic( CRofs::EPanicEntryAfterDirectory ));

		pEntry = NextEntry( pEntry );

		}

	while ( pEntry < pEnd )

		{

		TPtrC name( NameAddress( pEntry ), pEntry->iNameLength);

		if ( KErrNotFound != name.MatchF(aName) && iMount.MatchEntryAtt(pEntry->iAtt, aAtt) )

			{

			aSubDirEntry = pEntry;

			return KErrNone;

			}

		pEntry = NextEntry( pEntry );

		}

	return KErrNotFound;

	}

TInt CDirectoryCache::GetDirCount(const TRofsDir* aDir) const

//

//Return the number of directory entries contained in aDir

//

	{

	TUint16* dirCount = (TUint16*) ((TUint8*) aDir + aDir->iStructSize);

	return *dirCount;

	}

TInt CDirectoryCache::GetFileCount(const TRofsDir* aDir) const

//

//Return the number of file entries contained in aDir

//

	{

	TUint16* fileCount = (TUint16*) ((TUint8*) aDir + aDir->iStructSize);

	fileCount++; //jump over the dir count

	return *fileCount;

	}

TInt CDirectoryCache::Compare(const TDesC& aLeft, const TDesC& aRight) const

//

//Compares two filenames.  Folds ASCII characters to uppercase

//

	{

	TInt len=Min(aLeft.Length(),aRight.Length());

	const TText* leftString = aLeft.Ptr();

	const TText* rightString = aRight.Ptr();

	while (len--)

		{

		TText leftChar=*leftString++;

		TText rightChar=*rightString++;

		if (leftChar<='Z' && leftChar>='A')

			leftChar +='a'-'A';     // covert to UPPERCASE

		if (rightChar<='Z' && rightChar>='A')

			rightChar +='a'-'A';    // covert to UPPERCASE

		TInt result=leftChar-rightChar;

		if (result != 0)

			return result;

		}

		// match up to end of shorter string, now compare lengths

		return aLeft.Length()-aRight.Length();

	}

TInt CDirectoryCache::ExtractMangleInfo(const TDesC& searchName, TUint8 &MountId, TUint8 &ReservedId) const

{

	#define HexToInt(x) ( x.IsDigit()? (TUint8)(x-(TUint)'0') : 0x0a+(TUint8)((x>='A' && x<='Z')? x-(TUint)'A':x-(TUint)'a') )

	const TInt KOpenBraceRevPos = 7;

	const TInt KHyphenRevPos = 4;

	const TInt KCloseBraceRevPos = 1;

	TInt openBraceRevPos = searchName.LocateReverse('[');

	TInt closeBraceRevPos = searchName.LocateReverse(']');

	TInt hyphenRevPos = searchName.LocateReverse('-');

	TInt searchNameLen = searchName.Length();

	if(openBraceRevPos==KErrNotFound || closeBraceRevPos==KErrNotFound || hyphenRevPos==KErrNotFound)

		return KErrNotFound;

	openBraceRevPos = searchNameLen - openBraceRevPos;

	closeBraceRevPos = searchNameLen - closeBraceRevPos;

	hyphenRevPos = searchNameLen - hyphenRevPos;

	if(openBraceRevPos!=KOpenBraceRevPos || hyphenRevPos!=KHyphenRevPos || closeBraceRevPos!=KCloseBraceRevPos)

		return KErrNotFound;

	const TText* nameString = searchName.Ptr();

	TInt MountIdPos = searchNameLen - KOpenBraceRevPos + 1;

	TInt ReservedIdPos = searchNameLen - KHyphenRevPos + 1;

	TChar MountIdHNibble = *(nameString+MountIdPos);

	TChar MountIdLNibble = *(nameString+MountIdPos+1);

	TChar ReservedIdHNibble = *(nameString+ReservedIdPos);

	TChar ReservedIdLNibble = *(nameString+ReservedIdPos+1);

	if(MountIdHNibble.IsHexDigit() && MountIdLNibble.IsHexDigit() &&

			ReservedIdHNibble.IsHexDigit() && ReservedIdLNibble.IsHexDigit())

	{

		MountId = (TUint8)((HexToInt(MountIdHNibble) << 4) | HexToInt(MountIdLNibble));

		ReservedId = (TUint8)((HexToInt(ReservedIdHNibble) << 4) | HexToInt(ReservedIdLNibble));

		return KErrNone;

	}

	return KErrNotFound;

}

TInt CDirectoryCache::DoBinaryFindFile(const TDesC& aName, TUint aAtt, const TRofsDir* aDir, const TRofsEntry*& aEntry ) const

//

// Scan from aDir looking for file aName using binary search.

// aName cannot contain wildcards and aEntry should always be NULL.

// If found return the result in aEntry.

//

	{

	if (aEntry != NULL)

		{

		return DoFindFile(aName, aAtt, aDir, aEntry);

		}

	TInt numFiles=GetFileCount(aDir);

	TInt topIndex=numFiles-1;

	TInt bottomIndex=0;

	TInt result;

	TBool doNameMangle = ETrue;

	TBuf<KMaxFileName> searchName;

	TBool bFound=EFalse;

	TInt retVal=KErrNotFound;

	searchName.Copy((const TText*)aName.Ptr(), aName.Length());

	if(topIndex>=0)

		{

		TUint16* offsets = (TUint16*) ((TUint8*) aDir + aDir->iStructSize);

		offsets += 2;                 //to skip file and dir counts

		offsets += GetDirCount(aDir); //skip directory offsets

		while((!bFound) && (topIndex>=bottomIndex))

			{

			TInt32 middleIndex;

			const TRofsEntry* pCurrentEntry=NULL;

			TBuf<KMaxFileName> currName;

			middleIndex=(topIndex+bottomIndex)>>1;

			//Offsets for files are relative to the start of the

			//file block

			TInt bufferOffset = (offsets[middleIndex]<<2) - iFilesMediaOffset + 4;

			bufferOffset += aDir->iFileBlockAddress;

			TUint8* ptr = (TUint8*) &iFilesBuffer[0];

			pCurrentEntry=(TRofsEntry*) &ptr[bufferOffset];

			currName.Copy(((const TText*)&pCurrentEntry->iName[0]), pCurrentEntry->iNameLength);

			if(doNameMangle && ((~pCurrentEntry->iAttExtra & (KEntryAttUnique >> 23)) != 0))

				currName.AppendFormat(_L("[%02x-00]"),iMount.iMountId);

			result=Compare(searchName,currName);

			if(result<0)

				topIndex=middleIndex-1;

			else if(result>0)

				bottomIndex=middleIndex+1;

			else

				{

				bFound=ETrue;	// exit loop

				if (iMount.MatchEntryAtt(pCurrentEntry->iAtt, aAtt))

					{

					aEntry=pCurrentEntry;

					retVal = (pCurrentEntry->iFileAddress == KFileHidden) ? KErrHidden : KErrNone;

					}

				/* If we have found a file and we are in second pass of binary search without nameMangle 

					check whether it is unique file */

				if(!doNameMangle)

					{

					/* If it is not a unique file then the file does not exist */

					if((~pCurrentEntry->iAttExtra & (KEntryAttUnique >> 23)) == 0)

						{

						retVal = KErrNotFound;

						aEntry = NULL;

						}

					}

				}

			/* If we are going to return and we are searching for the unique file,there is a possiblity

			   that the binary search would have missed it (since the file entries were sorted without 

			   namemangle).*/

			if((!bFound) && (topIndex<bottomIndex) && doNameMangle)

				{

					TUint8 MountId;

					TUint8 ReservedId;

					if(ExtractMangleInfo(searchName,MountId,ReservedId) != KErrNone)

						break;

					if(MountId != iMount.iMountId || ReservedId != 0)

						break;

					/* If the aNameLength is equal to the mangle name length, we cant proceed our search 

						with null strings */

					if((TUint)(aName.Length()) == KRofsMangleNameLength)

						break;

					searchName.Copy((const TText*)aName.Ptr(), aName.Length()-KRofsMangleNameLength);

					/* The next level of search is sufficient enough to start on the top portion of the list.

						Thus resetting the bottomIndex to 0 is sufficient */

					bottomIndex=0;

					doNameMangle = EFalse;

				}

			}

		}

	return retVal;

	}

TInt CDirectoryCache::DoFindFile(const TDesC& aName, TUint aAtt, const TRofsDir* aDir, const TRofsEntry*& aEntry ) const

//

// Scan from aDir looking for file aName.

// The search starts at the entry after aEntry, unless aEntry is NULL, in which

// case the srach starts from the beginning of the file block.

// If found return the result in aEntry.

//

	{

	__ASSERT_DEBUG( aDir != NULL, CRofs::Panic( CRofs::EPanicNullSubDir ));

	if( aDir->iFileBlockAddress )

		{

		const TRofsEntry* pEntry;

		if( !aEntry )

			{

			pEntry = FirstFileEntryFromDir( aDir );

			}

		else

			{

			pEntry = NextEntry( aEntry );

			}

		const TAny* const pEnd = EndOfFileBlockPlusOne( aDir );

		while ( pEntry < pEnd )

			{

			TBuf<KMaxFileName> fileName;

			fileName.Copy(NameAddress( pEntry ), pEntry->iNameLength);

			if((~pEntry->iAttExtra & (KEntryAttUnique >> 23)) != 0)

				fileName.AppendFormat(_L("[%02x-00]"),iMount.iMountId);

			if ( KErrNotFound != fileName.MatchF(aName) && iMount.MatchEntryAtt(pEntry->iAtt, aAtt)  )

				{

				aEntry = pEntry;

				return(( pEntry->iFileAddress == KFileHidden ) ? KErrHidden : KErrNone);

				}

			pEntry = NextEntry( pEntry );

			}

		}

	return KErrNotFound;

	}

void CDirectoryCache::FindFileEntryL(const TDesC& aName, const TRofsEntry*& aEntry) const

//

// Locate an entry from its full path name.

//

	{

	TInt namePos=aName.LocateReverse(KPathDelimiter)+1; // There is always a path delimiter

	const TRofsDir* dir = RootDirectory();

	FindLeafDirL(aName.Left(namePos), dir);

	aEntry=0;

	TInt r = DoBinaryFindFile(aName.Mid(namePos), KEntryAttDir|KEntryAttMatchExclude, dir, aEntry);

	if (r!=KErrNone)

		User::Leave(r);

	}

void CDirectoryCache::FindDirectoryEntryL(const TDesC& aName, const TRofsDir*& aDir) const

//

// Locate an entry from its full path name.

//

	{

	aDir = RootDirectory();

	FindLeafDirL(aName,aDir);

	}

void CDirectoryCache::GetNextMatchingL(const TDesC& aName, TUint aAtt, const TRofsDir*& aDir, const TRofsEntry*& aEntry, TInt aError, TBool bUseBinarySearch) const

	//

	// Retrieves the next directory or file entry from aDir that matches the pattern in aName

	// (which should be the entry name only, not the full path)

	// The search starts at the entry after aEntry

	//

	{

	__ASSERT_DEBUG( aName.LocateReverse(KPathDelimiter) == KErrNotFound, CRofs::Panic( CRofs::EPanicBadMatchName ));

	TInt r = KErrGeneral;

	const TRofsEntry* entry = aEntry;

	TBool searchFiles = EFalse;

	if( entry && (entry < FirstSubDirEntryFromDir(aDir) || entry >= EndOfDirPlusOne(aDir)) )

		{

		searchFiles = ETrue;

		}

	else

		{

		// searching the directory list

		if (!bUseBinarySearch)

			{

			r = DoFindSubDir( aName, aAtt, aDir, entry );

			}

		else

			{

			r = DoBinaryFindSubDir(aName, aAtt, aDir, entry);

			}

		if( KErrNotFound == r )

			{

			// start looking through the file list

			entry = NULL;	// start at beginning of list

			searchFiles = ETrue;

			}

		}

	if( searchFiles )

		{

		if (!bUseBinarySearch)

			{

			r = DoFindFile( aName, aAtt, aDir, entry );

			}

		else

			{

			r = DoBinaryFindFile(aName, aAtt, aDir, entry);

			}

		}

/*

	if( aEntry >= FirstFileEntryFromDir( aDir ) 

		&& aDir->iFileBlockAddress )

		{

		// we are searching the file list

		r = DoFindFile( aName, aAtt, aDir, aEntry );

		}

	else

		{

		// searching the directory list

		r = DoFindSubDir( aName, aAtt, aDir, aEntry );

		if( KErrNotFound == r )

			{

			// start looking through the file list

			TRofsEntry* entry = NULL;	// start at beginning of list

			r = DoFindFile( aName, aAtt, aDir, entry );

			if( KErrNone == r )

				{

				aEntry = entry;

				}

			}

		}

*/

	if( r == KErrNone || r == KErrHidden)

		{

		// Move onto the next entry (this is valid even for hidden entries so

		// that we can move onto the next entry, which may not be hidden)

		aEntry = entry;

		if(r == KErrNone)

			{

			return;

			}

		}

	User::Leave(r == KErrHidden ? r : aError);

	}

void CDirectoryCache::FindGeneralEntryL(const TDesC& aName, TUint aAtt, const TRofsDir*& aDir, const TRofsEntry*& aEntry ) const

	{

	TInt namePos=aName.LocateReverse(KPathDelimiter)+1; // There is always a path delimiter

	aDir = RootDirectory();

	FindLeafDirL(aName.Left(namePos), aDir);

	GetNextMatchingL( aName.Mid(namePos), aAtt, aDir, aEntry, KErrNotFound, ETrue );

	}

TUint8 CDirectoryCache::GetMountId( void )

	{

	return (TUint8)(iMount.iMountId);

	};