/*

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

* @internalComponent * @released

*

*/

#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 <malloc.h>

#include <map>

#include <queue> 

#include <iomanip>

#include <strstream>

#include "utf16string.h"

#ifdef _L

#undef _L

#endif

#ifdef __LINUX__

#define _alloca alloca

#endif

#include "h_utl.h"

#include "r_obey.h"

#include "rofs.h"

#include "e32image.h"

#include "patchdataprocessor.h"

#include <filesystem.hpp>

#include <thread/thread.hpp>

#include <thread/mutex.hpp>

#include <thread/condition_variable.hpp>

#include "cache/cacheexception.hpp"

#include "cache/cacheentry.hpp"

#include "cache/cache.hpp"

#include "cache/cachegenerator.hpp"

#include "cache/cachevalidator.hpp"

#include "cache/cacheablelist.hpp"

#include "cache/cachemanager.hpp"

#include "uniconv.hpp"

extern TUint checkSum(const void* aPtr);

extern ECompression gCompress;

extern TUint gCompressionMethod;

extern TInt  gCodePagingOverride;

extern TInt  gDataPagingOverride;

extern TInt  gLogLevel;

extern bool gCache;

extern TBool gIsOBYUTF8;

TBool gDriveImage=EFalse;	// for drive image support.

TInt TRomNode::Count=0;

TRomNode* TRomNode::TheFirstNode = NULL;

TRomNode* TRomNode::TheLastNode = NULL;

// introduced for data drive files' attribute

TUint8 TRomNode::sDefaultInitialAttr = (TUint8)KEntryAttReadOnly;

struct SortableEntry

	{

	TRofsEntry* iEntry;

	TBool iIsDir;

	};

int compare(const void* l, const void* r)

	{

	const SortableEntry* left  = (const SortableEntry*)l;

	const SortableEntry* right = (const SortableEntry*)r;

	if (left->iIsDir)

		{

		if (!right->iIsDir)

			return -1;	// dir < file

		}

	else

		{

		if (right->iIsDir)

			return +1;	// file > dir

		}

	// both the same type of entry, sort by name

	// must first convert to an 8 bit string

	// array and NULL terminate it.

	char temp1[500];

	char temp2[500];

TInt i=0;

	for (i = 0; i < left->iEntry->iNameLength; i++)

		{

		temp1[i]=(char) left->iEntry->iName[i];

		}

	temp1[i]=0;

	for (i = 0; i < right->iEntry->iNameLength; i++)

		{

		temp2[i]=(char) right->iEntry->iName[i];

		}

	temp2[i]=0;

	return stricmp((const char*)&temp1[0], (const char*)&temp2[0]);

	}

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

//

// Constructor

//

	:

	iNextNode(NULL),

	iParent(NULL), iSibling(0), iChild(0), iNextNodeForSameFile(0),

	iTotalDirectoryBlockSize(0),

	iTotalFileBlockSize(0),

	iImagePosition(0),

	iFileBlockPosition(0),

	iAtt(sDefaultInitialAttr),

	iAttExtra(0xFF),

	iHidden(EFalse),

	iEntry(aEntry),

	iFileStartOffset(0),

	iSize(0),

	iOverride(0),

	iFileUpdate(EFalse),

    iAlias(false)

	{

	iName = NormaliseFileName(aName);

	iIdentifier=TRomNode::Count++;

	// Add this node to the flat linked list

	if( !TheFirstNode )

		{

		TheFirstNode = this;

		}

	else

		{

		TheLastNode->iNextNode = this;

		}

	TheLastNode = this;

	if (iEntry)

		{

		iEntry->SetRomNode(this);

		}

	else

		{

		iAtt = (TUint8)KEntryAttDir;

		}

	}

TRomNode::~TRomNode() {

	if (iEntry && !iAlias)

		delete iEntry; 

	if(iName)

		delete []iName ;

}

//

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

//

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

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

	while (entry) {

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

			return entry;

		else

			entry=entry->iSibling;

	}

	return 0;

}

TInt indend = 0;

void indendStructure(TInt i)

       {

	while(i > 0)

	   {

	     cout << "    ";

	     i--;

	   }

       };

// displays the directory structure

void TRomNode::DisplayStructure(ostream* aOut)

	{

	  indendStructure(indend);

      *aOut  << iName << "\n";

	  if (iChild)

	    {

	      indend++;

	      iChild->DisplayStructure(aOut);

	      indend--;

	    }

	  if (iSibling)

	    iSibling->DisplayStructure(aOut);

	}

void TRomNode::deleteTheFirstNode()

{

	TheFirstNode = NULL;

}

void TRomNode::InitializeCount()

{

	Count = 0;

}

void TRomNode::displayFlatList()

{

	TRomNode* current =	TheFirstNode;

	TInt i = 0;

	while(current)

	{

		i++;

		cout <<  "\n" << i <<": " << current->iName << endl;

		current = current->NextNode();

	}

	}

void TRomNode::AddFile(TRomNode* aChild)

	{

	if (iEntry)

		{

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

		return;

		}

	Add(aChild);

	}

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

	if (iEntry) {

		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;

	}

	node->iParent = this;

	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;

	}

//

// Set the file extra attribute byte from the letters passed

// Note: The iAttExtra bits are inverted. '0' represent enabled

//

TInt TRomNode::SetAttExtra(char *anAttWord, TRomBuilderEntry* aFile, enum EKeyword aKeyword){

	iAttExtra=0xFF;

	if (anAttWord==0 || anAttWord[0]=='\0')

		return Print(EError, "Missing argument for keyword 'exattrib'.\n");

	for (char *letter=anAttWord;*letter!=0;letter++)

		{

		switch (*letter)

			{

		case 'u':

			iAttExtra |= (KEntryAttUnique >> 23);	// '1' represents disabled in iAttExtra

			break;

		case 'U':

			iAttExtra &= ~(KEntryAttUnique >> 23);	// '0' represent enabled in iAttExtra

			break;

		default:

			return Print(EError, "Unrecognised exattrib - '%c'.\n", *letter);

			break;

			}

		}

	if((~iAttExtra & (KEntryAttUnique >> 23))!=0)	// If the unique file attribute is set

		{

		if(aKeyword==EKeywordFile || aKeyword==EKeywordData)	// If the Keyword is File or Data

			{

				if(strlen(aFile->iFileName) > (KMaxFileName-KRofsMangleNameLength)) // check whether we have enough space to add the mangle tage

					return Print(EError, "Lengthy filename with unique attribute to name mangle.\n");

			}

		else	// for all other keywords

			return Print(EError, "exattrib field not allowed for entries except data and file.\n");

		}

	return KErrNone;

	}

TInt TRomNode::SetAtt(char *anAttWord)

//

// Set the file attribute byte from the letters passed

//

	{

	iAtt=0;

	if (anAttWord==0 || anAttWord[0]=='\0')

		return Print(EError, "Missing argument for keyword 'attrib'.\n");

	for (char *letter=anAttWord;*letter!=0;letter++)

		{

		switch (*letter)

			{

		case 'R':

		case 'w':

			iAtt |= KEntryAttReadOnly;

			break;

		case 'r':

		case 'W':

			iAtt &= ~KEntryAttReadOnly;

			break;

		case 'H':

			iAtt |= KEntryAttHidden;

			break;

		case 'h':

			iAtt &= ~KEntryAttHidden;

			break;

		case 'S':

			iAtt |= KEntryAttSystem;

			break;

		case 's':

			iAtt &= ~KEntryAttSystem;

			break;

		default:

			return Print(EError, "Unrecognised attrib - '%c'.\n", *letter);

			break;

			}

		}

	return KErrNone;

	}

// Calculates the amount of ROM space required to hold

// this entry. The return is the actual size of the TRofsEntry

// structure, not rounded up

TInt TRomNode::CalculateEntrySize() const {

	UTF16String unistr(iName);

	TInt requiredSizeBytes = KRofsEntryHeaderSize +	unistr.bytes();

	return requiredSizeBytes;

	}

TInt TRomNode::CalculateDirectoryEntrySize( TInt& aDirectoryBlockSize,

										    TInt& aFileBlockSize )

	// Calculates the total size of the TRofsDir structure required

	// for this directory and the size of the files block. Traverses all the

	// children adding their entry sizes. The result is not rounded up.

	//

	// On return aDirectoryBlockSize is the number of bytes required for the

	//	main directory structure. aFileBlockSize is the number of bytes

	//	required to hold the list of files.

	//

	// Returns KErrNone on success

	{

	TInt offsetBytes=0;

	TInt padBytes=0;

	if( 0 == iTotalDirectoryBlockSize )

		{

		// need to calculate by walking children

		if( !iChild )

			{

			return Print(EError, "TRomNode structure corrupt\n");

			}

		TInt dirBlockSize = KRofsDirHeaderSize;

		TInt fileBlockSize = 0;

		TInt fileCount=0;

		TInt dirCount=0;

		TRomNode* node = iChild;

		while (node)

			{

			TInt entrySize = node->CalculateEntrySize();

			if( node->IsDirectory() )

				{

				dirBlockSize += (4 - dirBlockSize) & 3;	// pad to next word boundary

				dirBlockSize += entrySize;

				dirCount++;

				}

			else

				{

				fileBlockSize += (4 - fileBlockSize) & 3;	// pad to next word boundary

				fileBlockSize += entrySize;

				fileCount++;

				}

			node = node->iSibling;

			}

		offsetBytes = ((fileCount + dirCount) * 2) + 4; //the +4 are the two offset counts,

		padBytes = offsetBytes % 4;

		iTotalDirectoryBlockSize = dirBlockSize;

		iTotalFileBlockSize = fileBlockSize;

		}

	aDirectoryBlockSize = iTotalDirectoryBlockSize + offsetBytes + padBytes;

	aFileBlockSize = iTotalFileBlockSize;

	return KErrNone;

	}

/**

Place the files and it's attributes (incase of executables)

Called for both rofs and datadrive creation.

@param aDest   - Destination buffer.

@param aOffset - offset value, used for rofs only.

@param aMaxSize- Maximum size required for rofs.

@return - Returns the number of bytes placed or a -ve error code.

*/

TInt TRomNode::PlaceFile( TUint8* &aDest, TUint aOffset, TUint aMaxSize, CBytePair *aBPE ){

	//

	// Place the file into the ROM image, making any necessary conversions

	// along the way.

	//

	// Returns the number of bytes placed or a -ve error code.

	TInt size=0;

	// file hasn't been placed for drive image.

	if(gDriveImage)

	{

		size = iEntry->PlaceFile(aDest,aMaxSize,aBPE);

		iSize = size;

	}

	else

	{

		if (iEntry->iHidden)

			iFileStartOffset = KFileHidden;

		else

		{

                    if (iEntry->iFileOffset==0)

                    {

                        // file hasn't been placed

                        size = iEntry->PlaceFile( aDest, aMaxSize, aBPE );

                        if (size>=0)

                            iEntry->iFileOffset = aOffset;

                    }

                    else {

                        iFileStartOffset = (TInt)iEntry;

                    }

		}

	}

	// Deal with any override attributes

	// (omit paging overrides as these are dealt with in TRomBuilderEntry::PlaceFile

	//  and may also be legitimately specified for non-executable files in ROM)

	if( iOverride&~(KOverrideCodeUnpaged|KOverrideCodePaged|KOverrideDataUnpaged|KOverrideDataPaged) )

		{

		E32ImageHeaderV* hdr = (E32ImageHeaderV*)aDest;

		TUint hdrfmt = hdr->HeaderFormat();

		if (hdrfmt != KImageHdrFmt_V)

			{

			Print(EError,"%s: Can't load old format binary\n", iEntry->iFileName);

			return KErrNotSupported;

			}

		// First need to check that it's a real image header

		if( (TUint)size > sizeof(E32ImageHeader) )

			{

			if( ((TInt)hdr->iSignature == 0x434f5045u) && ((TInt)hdr->iUid1 == KExecutableImageUidValue || (TInt)hdr->iUid1 == KDynamicLibraryUidValue) )

				{