/*

* Copyright (c) 2005-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 <e32rom.h>

#include "rom_image_reader.h"

#include "r_rom.h"

void InflateUnCompress(unsigned char* source, int sourcesize, unsigned char* dest, int destsize);

RomImageFSEntry::RomImageFSEntry (const char* aName) : iName(aName), iSibling(0), iChildren(0) {

}

RomImageFSEntry::~RomImageFSEntry() {

	if(iChildren){

		delete iChildren;

		iChildren = NULL ;

	}

	if(iSibling){

		delete iSibling ;

		iSibling = NULL ;

	}	

}

//Rom Image header 

RomImageHeader::RomImageHeader(char* aHdr, EImageType aImgType)

{

	switch( aImgType)

	{

	case EROM_IMAGE:

		iLoaderHdr = (TRomLoaderHeader*)aHdr;

		iRomHdr = (TRomHeader*)(aHdr + sizeof(TRomLoaderHeader));

		iExtRomHdr = 0;

		break;

	case EROMX_IMAGE:

		iExtRomHdr = (TExtensionRomHeader*)(aHdr);

		iRomHdr = 0;

		iLoaderHdr = 0;

		break;

    case EBAREROM_IMAGE:

        iLoaderHdr = 0;

        iRomHdr = (TRomHeader*)aHdr;

        iExtRomHdr = 0;

        break;

   default:

   		iExtRomHdr = 0;

		iRomHdr = 0;

		iLoaderHdr = 0;

   	break ;

	}

}

void RomImageHeader::DumpRomHdr()

{

    if(iLoaderHdr)

        *out << "ROM Image " << endl << endl;

    else

        *out << "Bare ROM Image" << endl << endl;

	TUint aPos = 0;

	bool aContinue = true;

	*out << "Image Signature .................";

    if(iLoaderHdr){

        TText *aRomName =  reinterpret_cast<TText *>(iLoaderHdr) ;

        while (aPos < KRomNameSize) {

            *out << (char)aRomName[aPos++];

        }

    }

	*out << endl << endl;

	DumpInHex("Timestamp", (iRomHdr->iTime >> 32)) ;

	DumpInHex(" ", (iRomHdr->iTime &0xffffffff), aContinue) << endl;

	DumpInHex("RomBase", iRomHdr->iRomBase) << endl;

	DumpInHex("RomSize", iRomHdr->iRomSize) << endl;

	DumpInHex("KernelDataAddress", iRomHdr->iKernDataAddress) << endl;

	DumpInHex("KernelLimit", iRomHdr->iKernelLimit) << endl;

	DumpInHex("PrimaryFile", iRomHdr->iPrimaryFile) << endl;

	DumpInHex("SecondaryFile", iRomHdr->iSecondaryFile) << endl;

	DumpInHex("CheckSum", iRomHdr->iCheckSum) << endl;

	DumpInHex("Hardware", iRomHdr->iHardware) << endl;

	DumpInHex("Language", (TUint)(iRomHdr->iLanguage >> 32));

	DumpInHex(" ", ((TUint)(iRomHdr->iLanguage & 0xffffffff)), aContinue) <<endl;

	DumpInHex("KernelConfigFlags", iRomHdr->iKernelConfigFlags) << endl;

	DumpInHex("RomExceptionSearchTable", iRomHdr->iRomExceptionSearchTable) << endl;

	DumpInHex("RomHeaderSize", iRomHdr->iRomHeaderSize) << endl;

	DumpInHex("RomSectionHeader", iRomHdr->iRomSectionHeader) << endl;

	DumpInHex("TotalSvDataSize", iRomHdr->iTotalSvDataSize) << endl;

	DumpInHex("VariantFile", iRomHdr->iVariantFile) << endl;

	DumpInHex("ExtensionFile", iRomHdr->iExtensionFile) << endl;

	DumpInHex("RelocInfo", iRomHdr->iRelocInfo) << endl;

	DumpInHex("OldTraceMask", iRomHdr->iOldTraceMask) << endl;

	DumpInHex("UserDataAddress", iRomHdr->iUserDataAddress) << endl;

	DumpInHex("TotalUserDataSize", iRomHdr->iTotalUserDataSize) << endl;

	DumpInHex("DebugPort", iRomHdr->iDebugPort) << endl;

	DumpInHex("Version", iRomHdr->iVersion.iMajor, false, 2);

	DumpInHex(".", iRomHdr->iVersion.iMinor, aContinue, 2);

	DumpInHex("(" ,iRomHdr->iVersion.iBuild, aContinue, 2);

	*out << ")" << endl;

	DumpInHex("CompressionType", iRomHdr->iCompressionType) << endl;

	DumpInHex("CompressedSize", iRomHdr->iCompressedSize) << endl;

	DumpInHex("UncompressedSize", iRomHdr->iUncompressedSize) << endl;

	DumpInHex("HcrFileAddress", iRomHdr->iHcrFileAddress) << endl;

	DumpInHex("DisabledCapabilities", iRomHdr->iDisabledCapabilities[0]);

	DumpInHex(" ", iRomHdr->iDisabledCapabilities[1], aContinue) << endl;

	DumpInHex("TraceMask", iRomHdr->iTraceMask[0]);

	aPos = 1;

	while( aPos < (TUint)KNumTraceMaskWords)

	{

		if(iRomHdr->iTraceMask[aPos])

		{

			DumpInHex(" ", iRomHdr->iTraceMask[aPos++], aContinue);

		}

		else

		{

			DumpInHex(" ", iRomHdr->iTraceMask[aPos++], aContinue, 1);

		}

	}

	*out << endl << endl;

}

void RomImageHeader::DumpRomXHdr()

{

	*out << "Extension ROM Image" << endl << endl;

	bool aContinue = true;

	DumpInHex("Timestamp", (iExtRomHdr->iTime >> 32)) ;

	DumpInHex(" ", (iExtRomHdr->iTime &0xffffffff), aContinue) << endl;

	DumpInHex("RomBase", iExtRomHdr->iRomBase) << endl;

	DumpInHex("RomSize", iExtRomHdr->iRomSize) << endl;

	DumpInHex("CheckSum", iExtRomHdr->iCheckSum) << endl;

	DumpInHex("Version", iExtRomHdr->iVersion.iMajor, false, 2);

	DumpInHex(".", iExtRomHdr->iVersion.iMinor, aContinue, 2);

	DumpInHex("(" ,iExtRomHdr->iVersion.iBuild, aContinue, 2);

	*out << ")" << endl;

	DumpInHex("CompressionType", iExtRomHdr->iCompressionType) << endl;

	DumpInHex("CompressedSize", iExtRomHdr->iCompressedSize) << endl;

	DumpInHex("UncompressedSize", iExtRomHdr->iUncompressedSize) << endl;

	*out << endl << endl;

}

//Rom Image reader

RomImageReader::RomImageReader(const char* aFile, EImageType aImgType) :

ImageReader(aFile), iImageHeader(0),

iRomSize(0),iHeaderBuffer(0),

iRomLayoutData(0),iImgType(aImgType)

{

	iRomImageRootDirEntry = new RomImageDirEntry("");

}

RomImageReader::~RomImageReader()

{

	if(iFile.is_open())

		iFile.close();

	if(iHeaderBuffer)

		delete []iHeaderBuffer;

	if(iRomLayoutData)

		delete []iRomLayoutData;  

	delete iRomImageRootDirEntry;

}

void RomImageReader::ReadImage()

{

	if(iFile.is_open()) return ;

	iFile.open(iImgFileName.c_str(), ios::binary | ios::in);

	if( !iFile.is_open() ) {

		throw ImageReaderException(iImgFileName.c_str(), "Cannot open file ");

	}	

	TUint headerSize = GetHdrSize() ;	

	if(headerSize > 0){

		iHeaderBuffer = new char[headerSize];

		iFile.read(iHeaderBuffer,headerSize);

	}	

}

void RomImageReader::Validate()

{

}

TUint32 RomImageReader::GetImageCompressionType()

{

	if(iImageHeader->iRomHdr )// iImageType == EROM_IMAGE

		return iImageHeader->iRomHdr->iCompressionType;

	else

		return iImageHeader->iExtRomHdr->iCompressionType;

}

TLinAddr RomImageReader::GetRomBase()

{

	if(iImageHeader->iRomHdr )// iImageType == EROM_IMAGE

		return iImageHeader->iRomHdr->iRomBase ;

	else

		return iImageHeader->iExtRomHdr->iRomBase;

}

TLinAddr RomImageReader::GetRootDirList()

{

	if(iImageHeader->iRomHdr )// iImageType == EROM_IMAGE

		return iImageHeader->iRomHdr->iRomRootDirectoryList;

	else

		return iImageHeader->iExtRomHdr->iRomRootDirectoryList;

}

TUint RomImageReader::GetHdrSize()

{

	TUint headerSize = 0;

	if(EROM_IMAGE == iImgType){

		headerSize = sizeof(TRomLoaderHeader) + sizeof(TRomHeader);

	}else if(EROMX_IMAGE == iImgType){

		headerSize = sizeof(TExtensionRomHeader);

	}else if(EBAREROM_IMAGE == iImgType){

		headerSize = sizeof(TRomHeader);

	}

	return headerSize;

}

static const TInt KIOBytes = 0x100000;

// reading a huge buffer at a time is very slow, reading 1MB bytes at a time is much faster

void RomImageReader::ReadData(char* aBuffer, TUint aLength)

{

	TUint readBytes = 0 ;

	while(readBytes < aLength){

		TUint toRead = KIOBytes;

		if(readBytes + toRead > aLength)

			toRead = aLength - readBytes ;

		iFile.read(&aBuffer[readBytes],toRead);

		readBytes += toRead ;

	}	

}

void RomImageReader::ProcessImage()

{

	if(iRomLayoutData) return ;

	iImageHeader = new RomImageHeader(iHeaderBuffer, iImgType);

	iFile.seekg(0, ios::end);

	// fileSize

	TUint fileSize = iFile.tellg(); 

	//let's skip the RomLoaderHeader

	TUint romDataBegin = (EROM_IMAGE == iImgType) ? sizeof(TRomLoaderHeader) : 0 ; 

	iFile.seekg(romDataBegin,ios::beg);	

	if(EROMX_IMAGE == iImgType){// EROMX_IMAGE, just set the iUnpagedRomBuffer		

		if(GetImageCompressionType() == KUidCompressionDeflate){

			TUint32 readLen = fileSize - sizeof(TExtensionRomHeader) ; 

			iRomSize = iImageHeader->iExtRomHdr->iUncompressedSize ;	 

			iRomLayoutData = new char[iRomSize];

			char* temp = new char[readLen];

			// header is not compressed.

			iFile.read(iRomLayoutData,sizeof(TExtensionRomHeader)); 

			ReadData(temp ,readLen);

			TUint8* uncompressDest = reinterpret_cast<TUint8*>(iRomLayoutData + sizeof(TExtensionRomHeader));

			InflateUnCompress(reinterpret_cast<TUint8*>(temp),readLen,uncompressDest,iRomSize - sizeof(TExtensionRomHeader));

			delete []temp ;	 

		}else{

			iRomSize = fileSize  ;

			iRomLayoutData = new char[iRomSize]; 

			ReadData(iRomLayoutData,iRomSize);

		}	 

	} // end EROMX_IMAGE

	else {

		 //EROM_IMAGE or EBAREROM_IMAGE

		const TInt KPageSize = 0x1000; 

		TRomHeader *hdr = iImageHeader->iRomHdr; 

		iRomSize = hdr->iUncompressedSize ; 

		iRomLayoutData = new char[iRomSize]; 

		char* curDataPointer = iRomLayoutData ;

		TUint totalReadBytes = 0;

		bool hasPageableSec = (hdr->iPageableRomStart > 0 && hdr->iPageableRomSize > 0) ;

		// read data before unpaged 

		ReadData(curDataPointer,hdr->iCompressedUnpagedStart); 

		curDataPointer += hdr->iCompressedUnpagedStart ; 

		totalReadBytes += hdr->iCompressedUnpagedStart;		

		// read the unpaged part, if compressed , then decompress		 

		if(GetImageCompressionType() == KUidCompressionDeflate){

			char* temp = new char[hdr->iUnpagedCompressedSize];

			ReadData(temp,hdr->iUnpagedCompressedSize);

			totalReadBytes += hdr->iUnpagedCompressedSize;

			InflateUnCompress(reinterpret_cast<TUint8*>(temp),hdr->iUnpagedCompressedSize,reinterpret_cast<TUint8*>(curDataPointer) ,hdr->iUnpagedUncompressedSize);

			delete []temp ;			

		}else{

			TUint unpagedSeclen ;

			if(hasPageableSec) { // there is paged section 

				unpagedSeclen = hdr->iPageableRomStart - hdr->iCompressedUnpagedStart;

			}else{

				unpagedSeclen = iRomSize - hdr->iCompressedUnpagedStart;

			}

			ReadData(curDataPointer,unpagedSeclen);			 

			totalReadBytes += unpagedSeclen ;

		}

		curDataPointer = iRomLayoutData + totalReadBytes; 

		//if there is a paged section , read and extract it 

		// read the paged section,

		if(hasPageableSec){		

			if((TUint)(hdr->iPageableRomStart + hdr->iPageableRomSize) > iRomSize){

					throw ImageReaderException("Incorrect values of ROM header fields.", "");

			}

			if(0 == hdr->iRomPageIndex){ //

				// no compression for paged section ,just read it 			 

				iFile.read(curDataPointer,iRomSize - totalReadBytes);

			}

			else{

				//aligment calculation

				TUint pagedSecOffset = (totalReadBytes + KPageSize - 1) & (~(KPageSize - 1));

				if(pagedSecOffset > totalReadBytes){

					// there are gap bytes between unpaged and paged sections

					iFile.read(curDataPointer,pagedSecOffset - totalReadBytes);

					curDataPointer = iRomLayoutData + pagedSecOffset;

				}

				TUint pagedIndexCount = ( hdr->iUncompressedSize + KPageSize - 1) / KPageSize;

				// how many bytes ?

				// the page index table include the unpaged part ;

				TUint firstPagedIndexTblItem = hdr->iPageableRomStart / KPageSize;

				TUint tempBufLen = KPageSize << 8;

				char* readBuffer = new char[tempBufLen]; 

				TUint8* src,*srcNext = NULL;

				SRomPageInfo* pageInfo = reinterpret_cast<SRomPageInfo*>(&iRomLayoutData[hdr->iRomPageIndex]);

				CBytePair bp(EFalse);

				for(TUint i = firstPagedIndexTblItem ; i < pagedIndexCount ; i+= 256){

					TUint endIndex = i + 255 ;

					if(endIndex >= pagedIndexCount)

						endIndex = pagedIndexCount - 1;

					TUint readLen = pageInfo[endIndex].iDataStart + pageInfo[endIndex].iDataSize - pageInfo[i].iDataStart ; 

					iFile.read(readBuffer,readLen);

					src = reinterpret_cast<TUint8*>(readBuffer);

					for(TUint j = i ; j <= endIndex ; j++){

						switch(pageInfo[j].iCompressionType)

						{

						case SRomPageInfo::EBytePair:

							{

							TInt unpacked = bp.Decompress(reinterpret_cast<TUint8*>(curDataPointer), KPageSize, src, pageInfo[j].iDataSize, srcNext);

							if (unpacked < 0) {

								delete []readBuffer;

								throw ImageReaderException("Corrupted BytePair compressed ROM image", "");

							}

							curDataPointer += unpacked;

							break ;

							}

						case SRomPageInfo::ENoCompression:

							memcpy(curDataPointer,src,pageInfo[j].iDataSize);

							curDataPointer +=  pageInfo[j].iDataSize ;

							break ;

						default:

							delete []readBuffer;

							throw ImageReaderException("Undefined compression type", "");

							break ;

						}

						src += pageInfo[j].iDataSize; 

					} // end for(TUint j = i ; j <= endIndex ; j++) 

				} // end for(TUint i = firstPagedIndexTblItem ; i < pagedIndexCount ; i+= 256) 

				delete []readBuffer ;

			}// else

		} // if(hasPageableSec)  

	}

	TUint32 offset = GetRootDirList() - GetRomBase(); 

	TRomRootDirectoryList* rootDirList = reinterpret_cast<TRomRootDirectoryList*>(iRomLayoutData + offset );

	TInt dirCount = rootDirList->iNumRootDirs ; 

	string tempName ;

	for(TInt i = 0 ; i < dirCount ; i++) {

		offset = rootDirList->iRootDir[i].iAddressLin - GetRomBase(); 

		TRomDir* romDir = reinterpret_cast<TRomDir*>(iRomLayoutData + offset);		

		Name(tempName,reinterpret_cast<const wchar_t *>(romDir->iEntry.iName),romDir->iEntry.iNameLength); 		 

		BuildDir(romDir, iRomImageRootDirEntry);		 

	}

}

void RomImageReader::BuildDir(TRomDir* aDir, RomImageFSEntry* aPaFSEntry)

{	 

	TInt processBytes = 0 ;

	TInt totalDirBytes = aDir->iSize - sizeof(aDir->iSize);

	TRomEntry* entry = &aDir->iEntry;

	RomImageFSEntry *fsEntry ;

	string name ;

	const char* pritableName = "";

	while(processBytes < totalDirBytes){

		Name(name,reinterpret_cast<const wchar_t *>(entry->iName),entry->iNameLength);

		pritableName = name.c_str(); 

		if(entry->iAtt & 0x10) { // is a directory

			fsEntry = new RomImageDirEntry(pritableName); 

			AddChild(aPaFSEntry,fsEntry,NULL);

			TUint offset = entry->iAddressLin - GetRomBase();

			TRomDir* subFolder = reinterpret_cast<TRomDir*>(iRomLayoutData + offset);		 

			BuildDir(subFolder,fsEntry); 

		}

		else{

			fsEntry = new RomImageFileEntry(pritableName); 

			AddChild(aPaFSEntry,fsEntry,entry);

		} 

		// increase the processedBytes

		processBytes += (entry->iNameLength << 1) +  reinterpret_cast<TInt>(entry->iName) - reinterpret_cast<TInt>(entry); 

		//align to next 4 bytes

		processBytes = (processBytes + 3) & ( ~3 ); 

		// get next entry

		entry =  reinterpret_cast<TRomEntry*>( reinterpret_cast<char*>(&aDir->iEntry) + processBytes);

	} 

}

void RomImageReader::AddChild(RomImageFSEntry *aParent, RomImageFSEntry *aChild, TRomEntry* aRomEntry)

{

	if(!aParent->iChildren)

		aParent->iChildren = aChild;

	else {

		RomImageFSEntry *aLast = aParent->iChildren;

		while(aLast->iSibling)

			aLast = aLast->iSibling;

		aLast->iSibling = aChild;

	}

	if(!aChild->IsDirectory()) { 

		RomImageFileEntry* file = static_cast<RomImageFileEntry*>(aChild);

		file->iTRomEntryPtr = aRomEntry;

		if(aRomEntry->iAddressLin > GetRomBase()) {

			TUint32 offset = aRomEntry->iAddressLin - GetRomBase();	 

			TRomImageHeader* imgHdr = reinterpret_cast<TRomImageHeader*>(iRomLayoutData + offset);

			file->ImagePtr.iRomFileEntry = imgHdr;

			TUint8 aUid1[4];

			memcpy(aUid1, &file->ImagePtr.iRomFileEntry->iUid1, 4);

			if( ReaderUtil::IsExecutable(aUid1) ) {

				file->iExecutable = true;

			}

			else {

				file->iExecutable = false;

				file->ImagePtr.iDataFileAddr = aRomEntry->iAddressLin;

			}

		}

		else {

			file->ImagePtr.iRomFileEntry = NULL; 

		}

	}

	if(aParent != iRomImageRootDirEntry) {

		aChild->iPath = aParent->iPath;

		aChild->iPath += DIR_SEPARATOR;

		aChild->iPath += aParent->iName.c_str();

	}

}

void RomImageReader::Name(string& aName, const wchar_t* aUnicodeName, TUint aLen)

{

	char* temp = (char*)_alloca((aLen << 1) + 1) ;

	size_t n = wcsrtombs(temp,&aUnicodeName,aLen,NULL);

	if(n == (size_t)-1){ // the unicode string can not be coverted.

		aName = "???";

	}

	temp[n] = 0;

	if(n > 0)

		aName.assign(temp,n) ;

	else

		aName = "";

}

void RomImageReader::DumpTree()

{

	RomImageFSEntry* aFsEntry = iRomImageRootDirEntry;

	if( aFsEntry->iChildren ) 

		DumpSubTree(aFsEntry->iChildren); 

}

void RomImageReader::DumpDirStructure()

{

	*out << "Directory Listing" << endl;

	*out << "=================" << endl;

	int aPadding = 0;

	if( iRomImageRootDirEntry ){

		DumpDirStructure(iRomImageRootDirEntry, aPadding);

	}	

	*out << endl << endl;

}