/*
* 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;
}
void RomImageReader::DumpDirStructure(RomImageFSEntry* aEntry, int &aPadding)
{
if(!aEntry)
return;
int aPadLen = 2 * aPadding;//scaling for legibility
for (int i = 0; i < aPadLen; i++)
*out << " ";
*out << aEntry->Name() << endl;
if( aEntry->iChildren){
aPadding++;
DumpDirStructure(aEntry->iChildren, aPadding);
aPadding--;
}
DumpDirStructure(aEntry->iSibling, aPadding);
}
void RomImageReader::DumpSubTree(RomImageFSEntry* aFsEntry)
{
if(!aFsEntry)
return;
if( aFsEntry->iChildren ){
DumpSubTree(aFsEntry->iChildren);
}
if( aFsEntry->iSibling )
DumpSubTree(aFsEntry->iSibling);
RomImageFSEntry *aEntry = aFsEntry;
if(!aEntry->IsDirectory()) {
*out << "********************************************************************" << endl;
*out << "File........................" << aEntry->iPath.c_str() << DIR_SEPARATOR << aEntry->Name() << endl;
if( ((RomImageFileEntry*)aEntry)->iExecutable ) {
DumpImage((RomImageFileEntry*)aEntry);
}
else{
*out << "Linear Addr................." << ((RomImageFileEntry*)aEntry)->ImagePtr.iDataFileAddr << endl;
}
}
}
void RomImageReader::DumpImage(RomImageFileEntry * aEntry)
{
bool aContinue = true;
DumpInHex("Load Address", aEntry->iTRomEntryPtr->iAddressLin) << endl;
DumpInHex("Size", aEntry->iTRomEntryPtr->iSize) << endl;
TRomImageHeader *aRomImgEntry = aEntry->ImagePtr.iRomFileEntry;
if( !aRomImgEntry )
return;
//UIDs
DumpInHex("Uids", aRomImgEntry->iUid1);
DumpInHex(" ", aRomImgEntry->iUid2, aContinue);
DumpInHex(" ", aRomImgEntry->iUid3, aContinue);
DumpInHex(" ", aRomImgEntry->iUidChecksum, aContinue) << endl;
DumpInHex("Entry point", aRomImgEntry->iEntryPoint) << endl;
DumpInHex("Code start addr", aRomImgEntry->iCodeAddress) << endl;
DumpInHex("Data start addr", aRomImgEntry->iDataAddress) << endl;
DumpInHex("DataBssLinearBase", aRomImgEntry->iDataBssLinearBase) << endl;
DumpInHex("Text size", aRomImgEntry->iTextSize) << endl;
DumpInHex("Code size", aRomImgEntry->iCodeSize) << endl;
DumpInHex("Data size", aRomImgEntry->iDataSize) << endl;
DumpInHex("Bss size", (aRomImgEntry->iBssSize)) << endl;
DumpInHex("Total data size", aRomImgEntry->iTotalDataSize) << endl;
DumpInHex("Heap min", aRomImgEntry->iHeapSizeMin) << endl;
DumpInHex("Heap max", aRomImgEntry->iHeapSizeMax) << endl;
DumpInHex("Stack size", aRomImgEntry->iStackSize) << endl;
TDllRefTable *aRefTbl = NULL;
if( aRomImgEntry->iDllRefTable ) {
TUint32 aOff = (TUint32)aRomImgEntry->iDllRefTable - iImageHeader->iRomHdr->iRomBase;
aRefTbl = (TDllRefTable*) ((char*)iImageHeader->iRomHdr + aOff);
TUint32 aVirtualAddr = (TUint32)aRefTbl->iEntry[0];
DumpInHex("Dll ref table", aVirtualAddr) << endl;
}
DumpInHex("Export directory", aRomImgEntry->iExportDir) << endl;
DumpInHex("Export dir count", aRomImgEntry->iExportDirCount) << endl;
DumpInHex("Hardware variant", aRomImgEntry->iHardwareVariant) << endl;
DumpInHex("Flags", aRomImgEntry->iFlags) << endl;
DumpInHex("Secure ID", aRomImgEntry->iS.iSecureId) << endl;
DumpInHex("Vendor ID", aRomImgEntry->iS.iVendorId) << endl;
DumpInHex("Capability", aRomImgEntry->iS.iCaps[1]);
DumpInHex(" ", aRomImgEntry->iS.iCaps[0], aContinue) << endl;
*out << "Tools Version..............." << dec << (TUint)aRomImgEntry->iToolsVersion.iMajor;
*out << "." ;
out->width(2) ;
out->fill('0');
*out << dec << (TUint)aRomImgEntry->iToolsVersion.iMinor ;
*out << "(" << dec << aRomImgEntry->iToolsVersion.iBuild << ")";
*out << endl;
*out << "Module Version.............." << dec << (aRomImgEntry->iModuleVersion >> 16) << endl;
DumpInHex("Exception Descriptor", aRomImgEntry->iExceptionDescriptor) << endl;
*out << "Priority...................." << dec << aRomImgEntry->iPriority << endl;
if( aRefTbl )
DumpInHex("Dll ref table size", aRefTbl->iNumberOfEntries*8) << endl;
else
DumpInHex("Dll ref table size", 0) << endl;
if( iDisplayOptions & DUMP_E32_IMG_FLAG){
if(stricmp(iE32ImgFileName.c_str(), aEntry->Name()) == 0){
TUint aSectionOffset = aRomImgEntry->iCodeAddress - iImageHeader->iRomHdr->iRomBase;
TUint* aCodeSection = (TUint*)((char*)iImageHeader->iRomHdr + aSectionOffset);
*out << "\nCode (Size=0x" << hex << aRomImgEntry->iCodeSize << ")" << endl;
DumpData(aCodeSection, aRomImgEntry->iCodeSize);
aSectionOffset = aRomImgEntry->iDataAddress - iImageHeader->iRomHdr->iRomBase;
TUint* aDataSection = (TUint*)((char*)iImageHeader->iRomHdr + aSectionOffset);
if( aRomImgEntry->iDataSize){
*out << "\nData (Size=0x" << hex << aRomImgEntry->iDataSize << ")" << endl;
DumpData(aDataSection, aRomImgEntry->iDataSize);
}
}
}
*out << endl << endl;
}
void RomImageReader::DumpAttribs(RomImageFSEntry* aFsEntry)
{
// a larger rom image cause stack overflow under visual studio if we use recursion algorithm here.
// can gcc compiler guarantee this overflow will never be happen ?
if( aFsEntry->iChildren )
DumpAttribs(aFsEntry->iChildren);
if(aFsEntry->iSibling)
DumpAttribs(aFsEntry->iSibling);
if(aFsEntry->IsDirectory()) return ;
RomImageFileEntry* file = static_cast<RomImageFileEntry*>(aFsEntry);
if(!file->iExecutable) return ;
TRomImageHeader* aRomImgEntry = file->ImagePtr.iRomFileEntry;
if( !aRomImgEntry) return;
const char* prefix ;
if(aRomImgEntry->iFlags & KRomImageFlagPrimary){
prefix = "Primary";
}
else if(aRomImgEntry->iFlags & KRomImageFlagVariant){
prefix = "Variant";
}
else if(aRomImgEntry->iFlags & KRomImageFlagExtension){
prefix = "Extension";
}
else if(aRomImgEntry->iFlags & KRomImageFlagDevice){
prefix = "Device";
}
else
return;
out->width(10);
out->fill(' ');
*out << left << prefix;
out->width(40);
*out << right << file->Name() << "[" ;
DumpInHex( "", aRomImgEntry->iHardwareVariant, true) << "] ";
DumpInHex( " DataSize=", (aRomImgEntry->iBssSize + aRomImgEntry->iDataSize), true) << endl;
}
void RomImageReader::Dump()
{
if( !((iDisplayOptions & EXTRACT_FILES_FLAG) ||
(iDisplayOptions & LOG_IMAGE_CONTENTS_FLAG) ||
(iDisplayOptions & EXTRACT_FILE_SET_FLAG)) ) {
*out << "Image Name................." << iImgFileName.c_str() << endl;
if( iImageHeader->iRomHdr )
iImageHeader->DumpRomHdr();
else
iImageHeader->DumpRomXHdr();
DumpAttribs(iRomImageRootDirEntry);
*out << endl ;
if(iDisplayOptions & DUMP_VERBOSE_FLAG) {
DumpDirStructure();
DumpTree();
}
if(iDisplayOptions & DUMP_DIR_ENTRIES_FLAG) {
DumpDirStructure();
}
}
}
/**
Function iterates through all the entries in the image
by making a call to TraverseImage function.
@internalComponent
@released
*/
void RomImageReader::ExtractImageContents()
{
if( (iDisplayOptions & EXTRACT_FILE_SET_FLAG) )
{
//TODO:
ImageReader::ExtractFileSet(iRomLayoutData);
}
if( iDisplayOptions & EXTRACT_FILES_FLAG || iDisplayOptions & LOG_IMAGE_CONTENTS_FLAG )
{
if(iRomImageRootDirEntry)
{
// name of the log file.
string logFile;
// output stream for the log file.
ofstream oFile;
if( iDisplayOptions & LOG_IMAGE_CONTENTS_FLAG){
if( ImageReader::iZdrivePath.compare("")){
// create a string to hold path information.
string filePath(ImageReader::iZdrivePath);
string delimiter("\\");
// replace backslash with double backslash.
FindAndInsertString(filePath,delimiter,delimiter);
logFile = filePath;
// create specified directory.
CreateSpecifiedDir(&filePath[0],"\\\\");
logFile.append("\\\\");
logFile.append(ImageReader::iLogFileName);
}
else
{
logFile = ImageReader::iLogFileName;
}
// open the specified file in append mode.
oFile.open(logFile.c_str() ,ios::out|ios::app);
if(!oFile.is_open()){
throw ImageReaderException((char*)ImageReader::iLogFileName.c_str(), "Failed to open the log file");
}
}
TraverseImage(iRomImageRootDirEntry,oFile);
if(oFile.is_open()) oFile.close();
}
}
}
/**
Function to traverse entire image and check for an entity.If the entity found in the image is a file
then it makes a call to CheckFileExtension to check for extension.
@internalComponent
@released
@param aEntity - pointer to the entry in rom image.
@param aFile - output stream.
*/
void RomImageReader::TraverseImage(RomImageFSEntry* aEntity,ofstream& aFile)
{
if(!aEntity->IsDirectory()) {
CheckFileExtension(aEntity,aFile);
}
if (aEntity->iChildren) {
TraverseImage(aEntity->iChildren,aFile);
}
if (aEntity->iSibling) {
TraverseImage(aEntity->iSibling,aFile);
}
}
/**
Function to get check extension of the given file.If the extension of the file is "sis"
then call ExtractFile function to extract the file from the image.
@internalComponent
@released
@param aEntity - pointer to the entry in rom image.
@param aFile - output stream.
*/
void RomImageReader::CheckFileExtension(RomImageFSEntry* aEntity,ofstream& aFile)
{
RomImageFileEntry* romEntry = (RomImageFileEntry*)aEntity;
// get the size of the entity.
TUint32 size = romEntry->iTRomEntryPtr->iSize;
// get the offset of the entity.
TUint32 offset = romEntry->iTRomEntryPtr->iAddressLin - GetRomBase() ;
const char* fileName = aEntity->iName.c_str();
// create a string to hold the path information.
string romfilePath(romEntry->iPath);
string forwardSlash("/");
string slash("\\");
//replace slash with double backward slash.
FindAndReplaceString( romfilePath, forwardSlash, slash );
if( iDisplayOptions & LOG_IMAGE_CONTENTS_FLAG && iDisplayOptions & EXTRACT_FILES_FLAG ) {
// get the position.
size_t pos = aEntity->iName.find_last_of(".");
const char* extName = fileName + ( pos + 1 );
if ( !stricmp(extName ,"SIS") || !stricmp(extName ,"DAT") ) {
// if the two strings are same then extract the corresponding file.
ImageReader::ExtractFile(offset,size,fileName,&romfilePath[0],&ImageReader::iZdrivePath[0],iRomLayoutData);
}
else {
LogRomEnrtyToFile(romfilePath.c_str(),fileName,aFile);
}
}
else if( iDisplayOptions & LOG_IMAGE_CONTENTS_FLAG ) {
LogRomEnrtyToFile(romfilePath.c_str(),fileName,aFile);
}
else {
if(romEntry->iExecutable) {
size += sizeof(TRomImageHeader);
}
// extract the corresponding file.
ImageReader::ExtractFile(offset,size,fileName,&romfilePath[0],&ImageReader::iZdrivePath[0],iRomLayoutData);
}
}
/**
Function to log the rom entry to a specified file.
@internalComponent
@released
@param aPath - Complete path of an entity.
@param aEntityName - Entity name.
@param aFile - output stream.
*/
void RomImageReader::LogRomEnrtyToFile(const char* aPath,const char* aEntityName,ofstream& aFile)
{
if(aFile.is_open())
{
aFile.seekp(0,ios::end);
aFile<<aPath<<"\\"<<aEntityName<<"\n";
}
}
/**
Function to read the directory structure details of te ROM image.
@internalComponent
@released
@param aEntity - pointer to the entry in rom image.
@param aFileMap - map of filename with its size and offset values.
@param aImgSize - Image size
*/
void RomImageReader::ProcessDirectory(RomImageFSEntry *aEntity, FILEINFOMAP &aFileMap)
{
if(!aEntity->IsDirectory()) {
RomImageFileEntry* romEntry = (RomImageFileEntry*)aEntity;
PFILEINFO fileInfo = new FILEINFO;
// get the size of the entity.
fileInfo->iSize = romEntry->iTRomEntryPtr->iSize;
// get the offset of the entity.
fileInfo->iOffset = (romEntry->iTRomEntryPtr->iAddressLin - GetRomBase());
if(romEntry->iExecutable) {
fileInfo->iSize += sizeof(TRomImageHeader);
}
if((fileInfo->iOffset + fileInfo->iSize) > iRomSize) {
fileInfo->iOffset = 0;
fileInfo->iSize = 0;
}
string fileName(romEntry->iPath);
fileName.append(DIR_SEPARATOR);
fileName.append(aEntity->iName);
aFileMap[fileName] = fileInfo;
}
if (aEntity->iChildren) {
ProcessDirectory(aEntity->iChildren, aFileMap);
}
if (aEntity->iSibling) {
ProcessDirectory(aEntity->iSibling, aFileMap);
}
}
/**
Function to read the directory structure details of te ROM image.
@internalComponent
@released
@param aFileMap - map of filename with its size and offset values.
*/
void RomImageReader::GetFileInfo(FILEINFOMAP &aFileMap) {
ProcessDirectory(iRomImageRootDirEntry, aFileMap);
}
/**
Function to get the ROM image size.
@internalComponent
@released
*/
TUint32 RomImageReader::GetImageSize() {
return iRomSize;
}