// Copyright (c) 1997-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\etshell\ts_deps.cpp

// 

//

#include "ts_std.h"

#include "f32image.h"

#include <e32uid.h>

#include "sf_deflate.h"

#include "sf_image.h"

//#define _DETAILED_CHECK	//	Select for detailed dependency check

#if defined(_DETAILED_CHECK)	//	Prints information to screen

#define __PRINT(t) {CShell::TheConsole->Printf(t);}

#define __PRINT1(t,a) {CShell::TheConsole->Printf(t,a);}

#define __PRINT2(t,a,b) {CShell::TheConsole->Printf(t,a,b);}

#define __PRINTWAIT(t){CShell::TheConsole->Printf(t);CShell::TheConsole->Getch();}

#else

#define __PRINT(t)

#define __PRINT1(t,a)

#define __PRINT2(t,a,b)

#define __PRINTWAIT(t)

#endif

/*

CDllChecker::GetImportDataL(aFilename) reads the Image Header, Import Section 

and all import data for aFilename.  If aFilename is a ROM dll, and thus has no 

import data, or if the file contains no import data for some other reason the 

function leaves with KErrGeneral. If a file is compressed, function calls 

appropriate decompression routine to inflate the import data.

The function then calls GetDllTableL function which 

reads the first import block and enters a "for" loop. The Dll's name and Uid3 are obtained 

from CDllChecker::GetFileNameAndUid().  If the Dll name does not occur in the 

array of previously checked Dlls, CDllChecker::FindDll() is called.  If the Dll 

is found,the function then calls CDllChecker::GetImportDataL on the filename acquired by 

GetFileNameAndUid()(recursive call). 

If the Dll contains no import data or cannot be found, or if the Uid is invalid,

the next import is checked.

The Uid3 value is checked by calling CDllChecker::CheckUid.  This compares the 

Uid3 value found in the image header of the file, with that found by 

GetFileNameAndUid().  If there are any discrepancies,these are noted.

Each potential import is added to the array by dllAppendL(TResultCheck) to 

indicate its import status.

CDllChecker::ListArray() lists the contents of the array when all imports

have been checked.

*/

CDllChecker::CDllChecker()

//

//	Constructor

//

	{

	iDllArray=NULL;

	iCalls=0;

	}

void CDllChecker::ConstructL()

//

//	Creates an array to hold DLLs referenced by this executable	

//

	{

	iDllArray = new(ELeave)CArrayFixFlat<SDllInfo>(4);			

	__PRINT(_L(" Successfully created iDllArray\n"));	

	}

CDllChecker::~CDllChecker()

//

//	Destructor

//

	{

    delete iDllArray;

	}

GLDEF_C void Get16BitDllName(TDes8& aDllName,TDes& aFileName)

//

//	Convert an 8 bit name to a 16 bit name - zero padded automatically

//	No effect in 8 bit builds - just sets aFileName to aDllName

//

	{

	aFileName.SetLength(aDllName.Length());

	aFileName.Copy(aDllName);

	}

void FileCleanup(TAny* aPtr)

	{

	TFileInput* f=(TFileInput*)aPtr;

	f->Cancel();

	delete f;

	}

void CDllChecker::LoadFileInflateL(E32ImageHeaderComp* aHeader,TUint8* aRestOfFileData,TUint32 aRestOfFileSize)

	{

	TInt pos = aHeader->TotalSize();

	User::LeaveIfError(iFile.Seek(ESeekStart,pos)); // Start at beginning of compressed data

	TFileInput* file = new (ELeave) TFileInput(iFile);

	CleanupStack::PushL(TCleanupItem(&FileCleanup,file));

	CInflater* inflater=CInflater::NewLC(*file);

	if (aHeader->iCodeSize)

		{

		TUint8* CodeData = (TUint8*)User::AllocLC(aHeader->iCodeSize );

		TInt count=inflater->ReadL((TUint8*)CodeData ,aHeader->iCodeSize,&Mem::Move);

		if(count!=aHeader->iCodeSize)

			User::Leave(KErrCorrupt);

		CleanupStack::PopAndDestroy(CodeData);

		}

	if (aRestOfFileSize)

		{

		TUint32 count=inflater->ReadL(aRestOfFileData,aRestOfFileSize,&Mem::Move);

		if(count!=aRestOfFileSize)

			User::Leave(KErrCorrupt);

		}

	CleanupStack::PopAndDestroy(2,file);

	}

void CDllChecker::LoadFileNoCompressL(E32ImageHeaderComp* aHeader,TUint8* aRestOfFileData,TUint32 aRestOfFileSize)

	{

	TInt pos = (aHeader->TotalSize()+aHeader->iCodeSize);

	if (aRestOfFileSize)

		{

		User::LeaveIfError(iFile.Seek(ESeekStart,pos)); // Start at beginning of import table

		TPtr8 ptrToData((TText8*)(aRestOfFileData),aRestOfFileSize,aRestOfFileSize);

		User::LeaveIfError(iFile.Read(ptrToData, (TInt)aRestOfFileSize));	

		}

	}	

//function loads file's import information calling decompression routine if needed

TInt CDllChecker::LoadFile(TUint32 aCompression,E32ImageHeaderComp* aHeader,TUint8* aRestOfFileData,TUint32 aRestOfFileSize)

	{

	TInt r=KErrNone;

	if(aCompression==KFormatNotCompressed)

		{

		TRAP(r,LoadFileNoCompressL(aHeader,aRestOfFileData,aRestOfFileSize));		

		}

	else if(aCompression==KUidCompressionDeflate)

		{

		TRAP(r,LoadFileInflateL(aHeader,aRestOfFileData,aRestOfFileSize));

		}

	else

		r=KErrNotSupported;

	return r;

	}

//function iterates through the list of libraries the current executable depends on

//for each dependency in the list the function checks whether the .dll being checked is already added to the array of dependencies

//if not, the function adds dependency being checked to the array of dependencies and calls GetImportDataL function recursively

void CDllChecker::GetDllTableL(TUint8* aImportData, TInt aDllRefTableCount,TUint aFlags)

	{

	E32ImportBlock* block = (E32ImportBlock*)((TUint8*)aImportData+sizeof(E32ImportSection));

	//*********Beginning of the loop*********

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

		{

		SDllInfo dllInfo;		

		TText8* dllName=(aImportData+block->iOffsetOfDllName);

		TPtrC8 dllNamePtr(dllName, User::StringLength(dllName));

		GetFileNameAndUid(dllInfo,dllNamePtr);//Gets name and Uid of dependency

		TUid* pointer=&dllInfo.iUid;		

		__PRINT(_L(" Check Dll has not already been imported\n"));		

		TKeyArrayFix key(0,ECmpFolded);	

		TInt pos;		

		TInt r=iDllArray->Find(dllInfo,key,pos);//	Search array by Dll Name		

		if (r==KErrNone)	//	**********IT IS ALREADY IN THE ARRAY***********

			{

			__PRINT1(_L(" Dll %S has already been checked\n"),&dllInfo.iDllName);

			//Check its Uid3 against that noted in the array		

			if (iDllArray->At(pos).iUid!=dllInfo.iUid)	

				{

			//	Uid3 is different to that of the same named Dll

			//	Add it to the array for comparative purposes			

				__PRINT2(_L(" Uid3 [%08x] for %S is different from that noted previously\n"),dllInfo.iUid, &dllInfo.iDllName);

				dllInfo.iResult=EUidDifference;

			//	Add this entry to iDllArray

				DllAppendL(dllInfo);							

				}

			}//	Run to the end of the "for" loop for this i value

		else	//	**********THE FILE IS NOT YET IN THE ARRAY**********				

			{

			__PRINT(_L(" Dll has not previously been checked\n"));

		//	Check through it and add the relevant information to the array

		//	Search for the DLL

			TPath aPath=(TPath)CShell::currentPath;

			TFileName fileName;

			TName dll16BitName;

#if defined(UNICODE)

			Get16BitDllName(dllInfo.iDllName,dll16BitName);

#else

			dll16BitName=(dllInfo.iDllName);

#endif

			r=FindDll(dll16BitName,fileName,aPath);

			__PRINT1(_L("dll16BitName=%S\n"),&dll16BitName);

			__PRINTWAIT(_L(" Press any key to continue\n"));

			if (r==KErrNotFound)	//	Could not find Dll

				{

				dllInfo.iResult=ENotFound;

				}//	Run to the end of the "for" loop for this i value

			else	//	File was located 

//	Go recursive.  Call GetImportDataL on the new dll, if it imports anything.

//	ROM dlls have no import data so this is never called for ROM dlls.

//	This *will* terminate.  It is only called on "new" dlls not in the array.

				{				

				__PRINT(_L(" ****Go recursive****\n"));

				__PRINTWAIT(_L(" Press any key to continue\n"));

				iCalls++;

				TRAP(r,GetImportDataL(fileName, pointer));				

			//	Pass in (parsed) fileName and Uid3 (from file header)

				switch(r)		

					{

				case(KErrGeneral):	//	No import data

						{

						dllInfo.iResult=ENoImportData;

						break;

					//	Run to the end of the for loop for this i value

						}

				case(EUidNotSupported):

						{

						dllInfo.iResult=EUidNotSupported;

						break;

						}

				case(KErrNone):	//	Import data was read

						{

						dllInfo.iResult=EFileFoundAndUidSupported;

						break;

					//	Run to the end of the for loop for this i value

						}

				case(KErrInUse):

						{

						__PRINT2(_L(" File %S is already open\n"),&fileName,r);

						dllInfo.iResult=EAlreadyOpen;

						break;

						}

				case(KErrCorrupt):

						{

						__PRINT2(_L(" File %S has unexpected format\n"),&fileName,r);

						dllInfo.iResult=EAlreadyOpen;

						break;

						}

				default:

						{

						__PRINT1(_L(" File %S could not be opened \n"),&fileName);

						dllInfo.iResult=ECouldNotOpenFile;

						break;

						}

					//	Run to the end of the for loop for this i value							

					}	

				}

		//	Add the information about the dependency to iDllArray

			DllAppendL(dllInfo);			

			}

//	Runs to here when all import data has been read for this i value

		__PRINT(_L(" Go to next dll to be imported...\n"));

		__PRINTWAIT(_L(" Press any key to continue\n"));

		block = (E32ImportBlock*)block->NextBlock(E32ImageHeader::ImpFmtFromFlags(aFlags));

		}//	The end of the loop.  Every DLL has been located	

	}

void CDllChecker::GetImportDataL(const TDesC& aFileName, TUid* aPointer)

	{

	TInt cleanupCount=0;

	//	Check that the file is not a ROM dll.  These have no import data	

	if (ShellFunction::TheShell->TheFs.IsFileInRom(aFileName))

		{		

		User::Leave(KErrGeneral);

		}

	//open file for reading and push it to autoclose stack

	TAutoClose<RFile> autoFile;

	User::LeaveIfError(autoFile.iObj.Open(CShell::TheFs,aFileName,EFileStream));

	autoFile.PushL();

	cleanupCount++;

	iFile=autoFile.iObj;

	//Create a pointer to an Image Header

	//reserve enough memory for compressed file header because we don't know whether the file is compressed or not 

	E32ImageHeaderComp* imageHeader=new(ELeave)E32ImageHeaderComp;

	CleanupStack::PushL(imageHeader);

	cleanupCount++;

	//read file header

	TPtr8 ptrToImageHeader((TText8*)(imageHeader),sizeof(E32ImageHeaderComp),sizeof(E32ImageHeaderComp));

	User::LeaveIfError(iFile.Read(ptrToImageHeader,sizeof(E32ImageHeaderComp)));

	if (imageHeader->iImportOffset==0)//	File contains no import data

		{	

		User::Leave(KErrGeneral);

		}	

	TUint32 compression = imageHeader->CompressionType();

	TInt restOfFileSize=0;

	TUint8* restOfFileData=NULL;

	//detect the size of import information

	if (compression != KFormatNotCompressed)

		{

		// Compressed executable

		// iCodeOffset	= header size for format V or above

		//				= sizeof(E32ImageHeader) for format J

		restOfFileSize = imageHeader->UncompressedFileSize() - imageHeader->iCodeOffset;

		}

	else

		{

		TInt FileSize;

		iFile.Size(FileSize); 		

		restOfFileSize = FileSize-imageHeader->TotalSize();

		}	

	restOfFileSize -= imageHeader->iCodeSize; // the size of the exe less header & code

	//allocate memory for import information

	if (restOfFileSize >0)

		{

		restOfFileData = (TUint8*)User::AllocLC(restOfFileSize );		

		cleanupCount++;

		}

	User::LeaveIfError(LoadFile(compression,imageHeader,restOfFileData,restOfFileSize)); // Read import information in

	TInt32 uid3=imageHeader->iUid3;

	if(iCalls!=0)	//	Only check Uid3 of dependencies (ie only after first 

		{			//	call of recursive function)

		TInt r=CheckUid3(uid3,*aPointer);

		if (r!=KErrNone) //	Dll's Uid3 is not valid

			User::Leave(EUidNotSupported);						

		}

	TInt bufferOffset=imageHeader->iImportOffset-(imageHeader->iCodeOffset + imageHeader->iCodeSize);

	if( TInt(bufferOffset+sizeof(E32ImportSection))>restOfFileSize)

		User::Leave(KErrCorrupt);		

	//get the table of dependencies

	GetDllTableL(restOfFileData+bufferOffset,imageHeader->iDllRefTableCount,imageHeader->iFlags);

	CleanupStack::PopAndDestroy(cleanupCount);	

	}

TUint8* CDllChecker::NextBlock(TUint8* aBlock)

	{

	E32ImportBlock* block;	

	//	Advance the pointer to the next block	

	block=(E32ImportBlock*)aBlock;

	aBlock=(aBlock+sizeof(E32ImportBlock)+((block->iNumberOfImports)*sizeof(TUint)));		

	return (aBlock);

	}

TFileNameInfo::TFileNameInfo()

	{

	memclr(this, sizeof(TFileNameInfo));

	}

TInt TFileNameInfo::Set(const TDesC8& aFileName, TUint aFlags)

	{

	iUid = 0;

	iVersion = 0;

	iPathPos = 0;

	iName = aFileName.Ptr();

	iLen = aFileName.Length();

	iExtPos = aFileName.LocateReverse('.');

	if (iExtPos<0)

		iExtPos = iLen;

	TInt osq = aFileName.LocateReverse('[');

	TInt csq = aFileName.LocateReverse(']');

	if (!(aFlags & EAllowUid) && (osq>=0 || csq>=0))

		{

		return KErrBadName;

		}

	if (osq>=iExtPos || csq>=iExtPos)

		{

		return KErrBadName;

		}

	TInt p = iExtPos;

	if ((aFlags & EAllowUid) && p>=10 && iName[p-1]==']' && iName[p-10]=='[')

		{

		TPtrC8 uidstr(iName + p - 9, 8);

		TLex8 uidlex(uidstr);

		TUint32 uid = 0;

		TInt r = uidlex.Val(uid, EHex);

		if (r==KErrNone && uidlex.Eos())

			iUid = uid, p -= 10;

		}

	iUidPos = p;

	TInt ob = aFileName.LocateReverse('{');

	TInt cb = aFileName.LocateReverse('}');

	if (ob>=iUidPos || cb>=iUidPos)

		{

		return KErrBadName;

		}

	if (ob>=0 && cb>=0 && p-1==cb)

		{

		TPtrC8 p8(iName, p);

		TInt d = p8.LocateReverse('.');

		TPtrC8 verstr(iName+ob+1, p-ob-2);

		TLex8 verlex(verstr);

		if (ob==p-10 && d<ob)

			{

			TUint32 ver = 0;

			TInt r = verlex.Val(ver, EHex);

			if (r==KErrNone && verlex.Eos())

				iVersion = ver, p = ob;

			}

		else if (d>ob && p-1>d && (aFlags & EAllowDecimalVersion))

			{

			TUint32 maj = 0;

			TUint32 min = 0;

			TInt r = verlex.Val(maj, EDecimal);

			TUint c = (TUint)verlex.Get();

			TInt r2 = verlex.Val(min, EDecimal);

			if (r==KErrNone && c=='.' && r2==KErrNone && verlex.Eos() && maj<32768 && min<32768)

				iVersion = (maj << 16) | min, p = ob;

			}

		}

	iVerPos = p;

	if (iLen>=2 && iName[1]==':')

		{

		TUint c = iName[0];

		if (c!='?' || !(aFlags & EAllowPlaceholder))

			{

			c |= 0x20;

			if (c<'a' || c>'z')

				{

				return KErrBadName;

				}

			}

		iPathPos = 2;

		}

	TPtrC8 pathp(iName+iPathPos, iVerPos-iPathPos);

	if (pathp.Locate('[')>=0 || pathp.Locate(']')>=0 || pathp.Locate('{')>=0 || pathp.Locate('}')>=0 || pathp.Locate(':')>=0)

		{

		return KErrBadName;

		}

	iBasePos = pathp.LocateReverse('\\') + 1 + iPathPos;

	return KErrNone;

	}

void TFileNameInfo::GetName(TDes8& aName, TUint aFlags) const

	{

	if (aFlags & EIncludeDrive)

		aName.Append(Drive());

	if (aFlags & EIncludePath)

		{

		if (PathLen() && iName[iPathPos]!='\\')

			aName.Append('\\');

		aName.Append(Path());

		}

	if (aFlags & EIncludeBase)

		aName.Append(Base());

	if ((aFlags & EForceVer) || ((aFlags & EIncludeVer) && VerLen()) )

		{

		aName.Append('{');

		aName.AppendNumFixedWidth(iVersion, EHex, 8);

		aName.Append('}');		

		}

	if ((aFlags & EForceUid) || ((aFlags & EIncludeUid) && UidLen()) )

		{

		aName.Append('[');

		aName.AppendNumFixedWidth(iUid, EHex, 8);

		aName.Append(']');

		}

	if (aFlags & EIncludeExt)

		aName.Append(Ext());

	}

void CDllChecker::GetFileNameAndUid(SDllInfo &aDllInfo, const TDesC8 &aExportName)

//	

//	Gets filename and UID 

//

	{	

	TFileNameInfo filename;

	filename.Set(aExportName,TFileNameInfo::EAllowUid|TFileNameInfo::EAllowDecimalVersion);

	filename.GetName(aDllInfo.iDllName,TFileNameInfo::EIncludeBaseExt);

	aDllInfo.iUid=TUid::Uid(filename.Uid());

	}

TInt CDllChecker::CheckUid3(TInt32 aUid3,TUid aUid)

//

//	Check that Uid3 is the same in the iDllName and as noted by the Image Header

//	aUid3 is the value found by the image header

//	aUid is the value found by parsing the result of block->dllname 

//	using GetFileNameAndUid()

	{

	if ((aUid.iUid)==aUid3)

		{