diff -r 000000000000 -r 044383f39525 imgtools/imgcheck/libimgutils/src/dirreader.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/imgtools/imgcheck/libimgutils/src/dirreader.cpp Tue Oct 27 16:36:35 2009 +0000 @@ -0,0 +1,387 @@ +/* +* Copyright (c) 2008-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: +* +*/ + + +/** + @file + @internalComponent + @released +*/ + +#include "dirreader.h" +#include "e32reader.h" + +#ifdef __LINUX__ +#include +#include +#else +#include +#include +#endif + +#define MAXPATHLEN 255 + +/** +Constructor. + +@internalComponent +@released +*/ +DirReader::DirReader(char* aDirName) +:ImageReader(aDirName) +{ +} + +/** +Destructor. + +@internalComponent +@released +*/ +DirReader::~DirReader(void) +{ + ExeVsE32ImageMap::iterator begin = iExeVsE32ImageMap.begin(); + ExeVsE32ImageMap::iterator end = iExeVsE32ImageMap.end(); + while(begin != end) + { + DELETE(begin->second); + ++begin; + } + iExeVsE32ImageMap.clear(); +} + +/** +Function to check whether the node is an executable or not. + +@internalComponent +@released + +@param aName - Executable name +*/ +bool DirReader::IsExecutable(String aName) +{ + unsigned int strPos = aName.find_last_of('.'); + if(strPos != String::npos) + { + aName = aName.substr(strPos); + if(aName.length() <= 4) + { + ReaderUtil::ToLower(aName); + if (aName.find(".exe") != String::npos || aName.find(".dll") != String::npos || + aName.find(".prt") != String::npos || aName.find(".nif") != String::npos || + aName.find(".pdl") != String::npos || aName.find(".csy") != String::npos || + aName.find(".agt") != String::npos || aName.find(".ani") != String::npos || + aName.find(".loc") != String::npos || aName.find(".drv") != String::npos || + aName.find(".pdd") != String::npos || aName.find(".ldd") != String::npos || + aName.find(".tsy") != String::npos || aName.find(".fsy") != String::npos || + aName.find(".fxt") != String::npos) + { + return true; + } + } + } + return false; +} + +/** +Dummy function to be compatible with other Readers. + +@internalComponent +@released +*/ +void DirReader::ReadImage(void) +{ +} + +/** +Function to +1. Preserve the present working directory +2. Invoke the function which reads the directory entires recursively. +3. Go back to the original directory. + +@internalComponent +@released +*/ +void DirReader::ProcessImage() +{ + char* cwd = new char[MAXPATHLEN]; + getcwd(cwd,MAXPATHLEN); + ReadDir(iImgFileName); + chdir(cwd); + if(cwd != NULL) + delete [] cwd; + cwd = 0; +} + +/** +Function to +1. Read the directory entires recursively. +2. Prepare the ExeVsE32ImageMap. + +@internalComponent +@released + +@param aPath - Directory name. +*/ +void DirReader::ReadDir(String aPath) +{ + int handle; + int retVal = 0; + E32Image* e32Image = KNull; + +#ifdef __LINUX__ + DIR* dirEntry = opendir( aPath.c_str()); + static struct dirent* dirPtr; + while ((dirPtr= readdir(dirEntry)) != NULL) + { + if ((strcmp(dirPtr->d_name, KChildDir.c_str()) == 0) || + (strcmp(dirPtr->d_name, KParentDir.c_str()) == 0)) + continue; // current dir || parent dir + + String fullName( aPath + "/" + dirPtr->d_name ); + + struct stat fileEntrybuf; + int retVal = stat((char*)fullName.c_str(), &fileEntrybuf); + if(retVal >= 0) + { + if(S_ISDIR(fileEntrybuf.st_mode)) //Is Directory? + { + ReadDir(fullName); + } + else if(S_ISREG(fileEntrybuf.st_mode)) //Is regular file? + { + if ((fileEntrybuf.st_blksize > 0) && IsExecutable(String(dirPtr->d_name)) && E32Image::IsE32ImageFile((char*)fullName.c_str())) + { + iExeAvailable = true; + e32Image = new E32Image(); + Ifstream inputStream((char*)fullName.c_str(), Ios::binary | Ios::in); + inputStream.seekg(0, Ios::end); + TUint32 aSz = inputStream.tellg(); + inputStream.seekg(0, Ios::beg); + e32Image->iFileSize=aSz; + e32Image->Adjust(aSz); + inputStream >> *e32Image; + String exeName(dirPtr->d_name); + ReaderUtil::ToLower(exeName); + if(iExeVsE32ImageMap.find(exeName) != iExeVsE32ImageMap.end()) + { + cout << "Warning: "<< "Duplicate entry '" << dirPtr->d_name << " '"<< endl; + continue; + } + iExeVsE32ImageMap.insert(std::make_pair(exeName, e32Image)); + iExecutableList.push_back(exeName); + } + else + { + cout << "Warning: "<< dirPtr->d_name << " is not a valid E32 executable" << endl; + } + } + } + } + closedir(dirEntry); + +#else + retVal = chdir(aPath.c_str()); + struct _finddata_t finder; + handle = _findfirst("*.*", &finder); + while (retVal == 0) + { + if ((strcmp(finder.name, KChildDir.c_str()) == 0) || + (strcmp(finder.name, KParentDir.c_str()) == 0) ) // current dir || parent dir + { + retVal = _findnext(handle, &finder); + continue; + } + + if (finder.attrib & _A_SUBDIR) + { + ReadDir(finder.name); + chdir(KParentDir.c_str()); + } + else + { + if ((finder.size > 0) && IsExecutable(String(finder.name)) && E32Image::IsE32ImageFile(finder.name)) + { + e32Image = new E32Image(); + Ifstream inputStream(finder.name, Ios::binary | Ios::in); + iExeAvailable = true; + e32Image->iFileSize=finder.size; + e32Image->Adjust(finder.size); + inputStream >> *e32Image; + String exeName(finder.name); + ReaderUtil::ToLower(exeName); + if(iExeVsE32ImageMap.find(exeName) != iExeVsE32ImageMap.end()) + { + cout << "Warning: "<< "Duplicate entry '" << finder.name << " '"<< endl; + retVal = _findnext(handle, &finder); + continue; + } + iExeVsE32ImageMap.insert(std::make_pair(exeName, e32Image)); + iExecutableList.push_back(exeName); + } + else + { + cout << "Warning: "<< finder.name << " is not a valid E32 executable" << endl; + } + } + retVal = _findnext(handle,&finder); + } +#endif +} + +/** +Function to traverse through ExeVsE32ImageMap and prepare ExeVsIdData map. + +@internalComponent +@released +*/ +void DirReader::PrepareExeVsIdMap(void) +{ + ExeVsE32ImageMap::iterator begin = iExeVsE32ImageMap.begin(); + ExeVsE32ImageMap::iterator end = iExeVsE32ImageMap.end(); + String exeName; + E32Image* e32Image = KNull; + IdData* id = KNull; + if(iExeVsIdData.size() == 0) //Is not already prepared + { + while(begin != end) + { + exeName = begin->first; + e32Image = begin->second; + id = new IdData; + id->iUid = e32Image->iOrigHdr->iUid1; + id->iDbgFlag = (e32Image->iOrigHdr->iFlags & KImageDebuggable)? true : false; + TUint aHeaderFmt = E32ImageHeader::HdrFmtFromFlags(e32Image->iOrigHdr->iFlags); + if (aHeaderFmt >= KImageHdrFmt_V) + { + E32ImageHeaderV* v = e32Image->iHdr; + id->iSid = v->iS.iSecureId; + id->iVid = v->iS.iVendorId; + id->iFileOffset = 0;//Entry read from directory input, has no offset. + } + iExeVsIdData[exeName] = id; + ++begin; + } + } + id = KNull; +} + +/** +Function to return ExeVsIdData map. + +@internalComponent +@released + +@return returns iExeVsIdData. +*/ +const ExeVsIdDataMap& DirReader::GetExeVsIdMap() const +{ + return iExeVsIdData; +} + +/** +Function responsible to gather dependencies for all the executables using the container iExeVsE32ImageMap. + +@internalComponent +@released + +@return iImageVsDepList - returns all executable's dependencies +*/ +ExeNamesVsDepListMap& DirReader::GatherDependencies() +{ + ExeVsE32ImageMap::iterator begin = iExeVsE32ImageMap.begin(); + ExeVsE32ImageMap::iterator end = iExeVsE32ImageMap.end(); + + StringList executableList; + while(begin != end) + { + PrepareExeDependencyList((*begin).second, executableList); + iImageVsDepList.insert(std::make_pair((*begin).first, executableList)); + executableList.clear(); + ++begin; + } + return iImageVsDepList; +} + +/** +Function responsible to prepare the dependency list. + +@internalComponent +@released + +@param - aE32Image, Using this, can get all the information about the executable +@param - aExecutableList, Excutables placed into this list +*/ +void DirReader::PrepareExeDependencyList(E32Image* aE32Image, StringList& aExecutableList) +{ + int count = 0; + char** nameList = aE32Image->GetImportExecutableNames(count); + int i = 0; + String dependency; + for(; i < count; ++i) + { + dependency.assign(nameList[i]); + aExecutableList.push_back(ReaderUtil::ToLower(dependency)); + } + DELETE(nameList); +} + +/** +Function to identify the given path as file or directory + +@internalComponent +@released + +@param - aStr, path name +@return - retuns the either Directory, file or Unknown. +*/ +EImageType DirReader::EntryType(char* aStr) +{ + int strLength = strlen(aStr); + if(aStr[strLength - 1] == '\\' || aStr[strLength - 1] == '/') + { + aStr[strLength - 1] = KNull; + } + int retVal = 0; + #ifdef __LINUX__ + struct stat fileEntrybuf; + retVal = stat(aStr, &fileEntrybuf); + if(retVal >= 0) + { + if(S_ISDIR(fileEntrybuf.st_mode)) + { + #else + struct _finddata_t finder; + retVal = _findfirst(aStr, &finder); + if(retVal > 0) //No error + { + if(finder.attrib & _A_SUBDIR) + { + #endif + return EE32Directoy; + } + else + { + if(E32Reader::IsE32Image(aStr) == true) + { + return EE32File; + } + } + } + + return EE32InputNotExist; +}