/*

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

*

*/

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

#include <iomanip> 

#include "r_obey.h"

#include "r_global.h"

#include "r_dir.h"

#include "uniconv.hpp"

TInt NumRootDirs;

extern TBool gIsOBYUTF8;

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;

//

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

//

TRomNode::TRomNode(const char* aName, TRomBuilderEntry* aEntry) {

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

	iAtt = (TUint8)KEntryAttReadOnly;

	iName = NormaliseFileName(aName);

	iIdentifier=TRomNode::Count++;

	iRomFile = new TRomFile;

	if (aEntry) {

		iRomFile->iRbEntry = aEntry;

		aEntry->SetRomNode(this);

		size_t len = strlen(aEntry->iBareName) + 1;

		iBareName = new char[len];

		memcpy(iBareName,aEntry->iBareName,len);

		iRomFile->iHwvd = aEntry->iHardwareVariant;

	}

	else {

		iRomFile->iDir = ETrue;

		iAtt |= (TUint8)KEntryAttDir;

		size_t len = strlen(iName) + 1;

		iBareName = new char[len];

		memcpy(iBareName,iName,len);

		iRomFile->iHwvd = KVariantIndependent;

	}

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

		iName, iBareName, iAtt, iRomFile));

}

//

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

//	

TRomNode::TRomNode(const char* aName, TRomNode* aNode){

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

	iAtt = aNode->iAtt;

	iIdentifier=TRomNode::Count++;

	iName = NormaliseFileName(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));

}

//

// Copy constructor - only used in deep copy function

//

TRomNode::TRomNode(const TRomNode& aNode) {

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

	iAtt = aNode.iAtt;

	iIdentifier=TRomNode::Count++;

	size_t len = strlen(aNode.iName) + 1;

	iName = new char[len];

	memcpy(iName,aNode.iName,len);

	len = strlen(aNode.iBareName) + 1;

	iBareName = new char[len];

	memcpy(iBareName,aNode.iBareName,len);

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

	if(iName) {

		delete []iName;

		iName = 0 ;

	}

	if(iBareName){

		delete []iBareName;

		iBareName = 0 ;

	}

	if (iRomFile)

		iRomFile->Close();

}

//

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

//

TRomNode* TRomNode::FindInDirectory(const char* aName) {

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

	while (entry){

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

			return entry;

		else

			entry=entry->iSibling;

	}

	return 0;

}

//

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

//

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

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

	while (entry) {

		if (((!entry->iHidden)||aPatchDataFlag) && entry->iRomFile && 

			(stricmp(aName, 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 char* 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;

}

const 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(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++ = SLASH_CHAR; 

		++l;

	}

	memcpy(b, iName, nl);

	b += nl;

	*b = 0;

	l += nl;

	return l;

}

//

//	Check that a aSubCaps are a subset of aSuperCaps

//

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

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

					buf[len++] = ' ';

				}

				int nameLen=strlen(name);

				buf = (char*)realloc(buf,len+nameLen+2);

				if(!buf)

					return KErrNoMemory;

				memcpy(buf+len,CapabilityNames[i],nameLen);

				len += nameLen;

			}

		}

		buf[len]=0;

		Print(printType, "*PlatSec* %s - Capability check failed. Can't load %s because it links to %s which has the following capabilities missing: %s\n",gPlatSecEnforcement?"ERROR":"WARNING",aSubName, aSuperName, buf);

		free(buf);

	}

	return r;

}

TDllFindInfo::TDllFindInfo(const char* aImportName, const TRomBuilderEntry* aEntry) {

	TUint32 flags;

	iBareName = SplitFileName(aImportName, iUid3, iModuleVersion, flags);

	assert(iBareName != 0);

	iHwVariant = aEntry->iHardwareVariant.ReturnVariant(); 

}