// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

//

#define __REFERENCE_CAPABILITY_NAMES__

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include <e32std.h>

#include <e32std_private.h>

#include <e32rom.h>

#include "u32std.h"

#include <e32uid.h>

#include <f32file.h>

#include "h_utl.h"

#define USE_IAT_FOR_IMPORTS (iOverrideFlags&KOverrideKeepIAT || (iHdr->iCpuIdentifier & 0x1000))

#if defined(__MSVCDOTNET__) || defined(__TOOLS2__)

#include <iomanip>

#else //!__MSVCDOTNET__

#include <iomanip.h>

#endif

#if defined(__MSVCDOTNET__) || defined(__TOOLS2__)

#include <iomanip>

#else //!__MSVCDOTNET__

#include <iomanip.h>

#endif

#include "r_obey.h"

#include "r_global.h"

#include "r_dir.h"

TInt NumRootDirs;

inline TLinAddr ActualToRomAddress(TAny* anAddr)

	{ return TLinAddr(anAddr)-TheRomMem+TheRomLinearAddress; }

TBool THardwareVariant::MutuallyExclusive(THardwareVariant a) const

	{

	if (Layer()<=3 || a.Layer()<=3)

		return EFalse;

	if (Parent()==3 && a.Parent()==3)

		return(Layer()!=a.Layer());

	if (Parent()==3 && a.Parent()!=Layer())

		return ETrue;

	if (a.Parent()==3 && Parent()!=a.Layer())

		return ETrue;

	if (Layer()!=a.Layer())

		return ETrue;

	return((VMask()&a.VMask())==0);

	}

TBool THardwareVariant::IsVariant() const

	{

	if (Layer()<=3 || Parent()==3)

		return EFalse;

	TUint v=VMask();

	TInt i;

	for (i=0; i<16; i++)

		{

		if (v==TUint(1<<i))

			return ETrue;

		}

	return EFalse;

	}

TInt THardwareVariant::Compare(THardwareVariant a) const

	{

	TUint l1=Layer();

	TUint p1=Parent();

	TUint v1=VMask();

	TUint l2=a.Layer();

	TUint p2=a.Parent();

	TUint v2=a.VMask();

	if (l1<=3)

		{

		if (l2<=3)

			{

			return EEqual;

			}

		return EGreater;

		}

	if (l2<=3)

		return ELess;

	if (p1==3)

		{

		if (p2==3)

			{

			if (l1==l2)

				return EEqual;

			return EUnordered;

			}

		if (p2==l1)

			return EGreater;

		return EUnordered;

		}

	if (p2==3)

		{

		if (p1==l2)

			return ELess;

		return EUnordered;

		}

	if (l1!=l2)

		return EUnordered;

	if ((v1&v2)==v1)

		return ELess;

	if ((v1&v2)==v2)

		return EGreater;

	return EUnordered;

	}

//

TInt TRomNode::Count=0;

TRomNode::TRomNode(const TText* aName, TRomBuilderEntry* aEntry)

//

// Constructor from TRomBuilderEntry, i.e. for new file or directory

//

	{

	memset(this, 0, sizeof(TRomNode));

	iAtt = (TUint8)KEntryAttReadOnly;

	iName = (TText*)NormaliseFileName((const char*)aName);

	iIdentifier=TRomNode::Count++;

	iRomFile = new TRomFile;

	if (aEntry)

		{

		iRomFile->iRbEntry = aEntry;

		aEntry->SetRomNode(this);

		iBareName = strdup(aEntry->iBareName);

		iRomFile->iHwvd = aEntry->iHardwareVariant;

		}

	else

		{

		iRomFile->iDir = ETrue;

		iAtt |= (TUint8)KEntryAttDir;

		iBareName = strdup((const char*)iName);

		iRomFile->iHwvd = KVariantIndependent;

		}

	TRACE(TROMNODE,Print(ELog, "TRomNode %d name %s bare %s att %02x romfile %08x\n", iIdentifier,

			iName, iBareName, iAtt, iRomFile));

	}

TRomNode::TRomNode(const TText* aName, TRomNode* aNode)

//

// Constructor from TRomNode, i.e. for aliased file

//

	{

	memset(this, 0, sizeof(TRomNode));

	iAtt = aNode->iAtt;

	iIdentifier=TRomNode::Count++;

	iName = (TText*)NormaliseFileName((const char*)aName);

	iHidden = aNode->iHidden;

	iRomFile = aNode->iRomFile;

	if (iRomFile)

		{

		iRomFile->Open();

		}

	TRACE(TROMNODE,Print(ELog, "TRomNode %d DUP name %s romfile %08x\n", iIdentifier, iName, iRomFile));

	}

TRomNode::TRomNode(const TRomNode& aNode)

//

// Copy constructor - only used in deep copy function

//

	{

	memset(this, 0, sizeof(TRomNode));

	iAtt = aNode.iAtt;

	iIdentifier=TRomNode::Count++;

	iName = (TText*)strdup((const char*)aNode.iName);

	iBareName = strdup(aNode.iBareName);

	iHidden = aNode.iHidden;

	iRomFile = aNode.iRomFile;

	if (iRomFile)

		{

		iRomFile->Open();

		}

	TRACE(TROMNODE,Print(ELog, "TRomNode %d COPY name %s bare %s att %02x romfile %08x\n", iIdentifier,

			iName, iBareName, iAtt, iRomFile));

	}

TRomNode::~TRomNode()

	{

	free(iName);

	free(iBareName);

	if (iRomFile)

		iRomFile->Close();

	}

TRomNode* TRomNode::FindInDirectory(const TText* aName)

//

// Check if the TRomNode for aName exists in aDir, and if so, return it.

//

	{

	TRomNode *entry=iChild; // first subdirectory or file

	while (entry)

		{

		if (!entry->iHidden && (stricmp((const char *)aName, (const char *)entry->iName))==0) 

			return entry;

		else

			entry=entry->iSibling;

		}

	return 0;

	}

TRomNode* TRomNode::FindInDirectory(const TText* aName, THardwareVariant aVariant, TBool aPatchDataFlag)

//

// Check for a file with same name and a compatible hardware variant

//

	{

	TRomNode *entry=iChild; // first subdirectory or file

	while (entry)

		{

		if (((!entry->iHidden)||aPatchDataFlag) && entry->iRomFile && (stricmp((const char *)aName, (const char *)entry->iName))==0) 

			{

			if (!aVariant.MutuallyExclusive(entry->HardwareVariant()))

				return entry;

			}

		entry=entry->iSibling;

		}

	return 0;

	}

void TRomNode::AddFile(TRomNode* aChild)

	{

	if (!(iAtt & KEntryAttDir))

		{

		Print(EError, "Adding subdirectory to a file!!!\n");

		return;

		}

	Add(aChild);

	}

TRomNode* TRomNode::NewSubDir(const TText* aName)

	{

	if (!(iAtt & KEntryAttDir))

		{

		Print(EError, "Adding subdirectory to a file!!!\n");

		return 0;

		}

	TRomNode* node = new TRomNode(aName);

	if (node==0)

		{

		Print(EError, "TRomNode::NewNode: Out of memory\n");

		return 0;

		}

	Add(node);

	return node;

	}

void TRomNode::Add(TRomNode* aChild)

	{

	if (iChild) // this node is a non-empty directory

		{

		TRomNode* dir = iChild; // find where to link in the new node

		while (dir->iSibling)

			dir = dir->iSibling;

		dir->iSibling = aChild;

		}

	else

		iChild = aChild; // else just set it up as the child of the dir

	aChild->iSibling = 0;

	aChild->iParent = this;

	}

void TRomNode::Remove(TRomNode* aChild)

	{

	if (iChild==0)

		{

		Print(EError, "Removing file from a file!!!\n");

		return;

		}

	if (iChild==aChild) // first child in this directory

		{

		iChild = aChild->iSibling;

		aChild->iSibling = 0;

		aChild->iParent = 0;

		return;

		}

	TRomNode* prev = iChild;

	while (prev->iSibling && prev->iSibling != aChild)

		prev = prev->iSibling;

	if (prev==0)

		{

		Print(EError, "Attempting to remove file not in this directory!!!\n");

		return;

		}

	prev->iSibling = aChild->iSibling;

	aChild->iSibling = 0;

	aChild->iParent = 0;

	}

void TRomNode::CountDirectory(TInt& aFileCount, TInt& aDirCount)

	{

	TRomNode *current=iChild;

	while(current)

		{

		if (current->iChild)

			aDirCount++;

		else if (!current->iHidden)

			aFileCount++;

		current=current->iSibling;

		}

	}

/**

 * Walk the contents of the directory, accumulating the

 * files as FileEntry objects in the specified RomFileStructure

 * and recursively handling the sub-directories

 *

 * TRomNode::ProcessDirectory is a pair with

 * RomFileStructure::ProcessDirectory

 */

int TRomNode::ProcessDirectory(RomFileStructure* aRFS)

	{

	TInt r=KErrNone;

	TRomNode *current=iChild;

	while(current)

		{

		if (current->iAtt & (TUint8)KEntryAttDir)

			{

			r=aRFS->ProcessDirectory(current);

			if (r!=KErrNone)

				return r;

			}

		else if (!current->iHidden)

			{

			FileEntry *pE=FileEntry::New(current);

			if (!pE)

				return KErrNoMemory;

			r=aRFS->Add(*pE);

			if (r==KErrOverflow)

				return r;

			}

		current=current->iSibling;

		}

	return r;

	}

void TRomNode::AddExecutableFile(TRomNode*& aLast, TRomNode* aNode)

	{

	aLast->iNextExecutable = aNode;

	aLast = aNode;

	aNode->iAtt |= KEntryAttXIP;

	}

char* TRomNode::BareName() const

	{

	return iBareName;

	}

TUint32 TRomNode::Uid3() const

	{

	return iRomFile->Uid3();

	}

TUint32 TRomNode::ModuleVersion() const

	{

	return iRomFile->ModuleVersion();

	}

THardwareVariant TRomNode::HardwareVariant() const

	{

	return iRomFile->HardwareVariant();

	}

TUint32 TRomNode::ABI() const

	{

	return iRomFile->ABI();

	}

TUint32 TRomFile::Uid3() const

	{

	assert(!iDir);

	if (iRbEntry)

	{

		if(iRbEntry->iHdr)

			return iRbEntry->iHdr->iUid3;

	}

	return RomImgHdr()->iUid3;

	}

TUint32 TRomFile::ModuleVersion() const

	{

	assert(!iDir);

	if (iRbEntry)

	{

		if(iRbEntry->iHdr)

			return iRbEntry->iHdr->ModuleVersion();

	}

	return RomImgHdr()->iModuleVersion;

	}

THardwareVariant TRomFile::HardwareVariant() const

	{

	return iHwvd;

	}

TUint32 TRomFile::ABI() const

	{

	assert(!iDir);

	if (iRbEntry)

	{

		if(iRbEntry->iHdr)

			return iRbEntry->iHdr->ABI();

	}

	return RomImgHdr()->iFlags & KRomImageABIMask;

	}

TInt TRomFile::ExportDirCount() const

	{

	assert(!iDir);

	if (iRbEntry)

	{

		if(iRbEntry->iHdr)

			return iRbEntry->iHdr->iExportDirCount;

	}

	return RomImgHdr()->iExportDirCount;

	}

TUint32 TRomFile::RomImageFlags() const

	{

	assert(!iDir);

	if (iRbEntry)

		{

		if(iRbEntry->iHdr)

		{

		const TUint KRomFlagMask = KImageDll | KImageNoCallEntryPoint | KImageFixedAddressExe | KImageNmdExpData;

		TUint romflags = iRbEntry->iHdr->iFlags & KRomFlagMask;

		return iRbEntry->iRomImageFlags | romflags;

		}

		}

	return RomImgHdr()->iFlags;

	}

TLinAddr TRomFile::DataBssLinearBase() const

	{

	assert(!iDir);

	if (iRbEntry)

		return iRbEntry->iDataBssLinearBase;

	return RomImgHdr()->iDataBssLinearBase;

	}

const SSecurityInfo& TRomFile::SecurityInfo() const

	{

	assert(!iDir);

	if (iRbEntry)

		return iRbEntry->iS;

	return RomImgHdr()->iS;

	}

TInt TRomNode::FullNameLength(TBool aIgnoreHiddenAttrib) const

	{

	TInt l = 0;

	// aIgnoreHiddenAttrib is used to find the complete file name length as

	// in ROM of a hidden file.

	if (iParent && ( !iHidden || aIgnoreHiddenAttrib))

		l = iParent->FullNameLength() + 1;

	l += strlen((const char*)iName);

	return l;

	}

TInt TRomNode::GetFullName(char* aBuf, TBool aIgnoreHiddenAttrib) const

	{

	TInt l = 0;

	TInt nl = strlen((const char*)iName);

	// aIgnoreHiddenAttrib is used to find the complete file name as in ROM of a hidden file.

	if (iParent && ( !iHidden || aIgnoreHiddenAttrib))

		l = iParent->GetFullName(aBuf);

	char* b = aBuf + l;

	if (l)

		*b++ = '\\', ++l;

	memcpy(b, iName, nl);

	b += nl;

	*b = 0;

	l += nl;

	return l;

	}

TInt CompareCapabilities(const SCapabilitySet& aSubCaps, const SCapabilitySet& aSuperCaps, const char* aSubName, const char* aSuperName)

//

//	Check that a aSubCaps are a subset of aSuperCaps

//

	{

	if ((!gPlatSecEnforcement)&&(!gPlatSecDiagnostics))

		return KErrNone;

	TInt i;

	TUint32 c = 0;

	for (i=0; i<SCapabilitySet::ENCapW; ++i)

		c |= (aSubCaps[i] &~ aSuperCaps[i]);

	TInt r = c ? KErrPermissionDenied : KErrNone;

	if (r && aSubName && aSuperName)

		{

		TPrintType printType;

		if(gPlatSecEnforcement)

			printType = EError;

		else

			{

			printType = EWarning;

			r = KErrNone;

			}

		char* buf = (char*)malloc(2);

		if(!buf)

			return KErrNoMemory;

		TInt len = 0;

		for(i=0; i<ECapability_Limit; i++)

			{

			if( (aSubCaps[i>>5] &~ aSuperCaps[i>>5]) & (1<<(i&31)) )

				{

				// append capability name to buf

				const char* name = CapabilityNames[i];

				if(!name)

					continue;

				if(len)