/*

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

#include <io.h>

#include <direct.h>

#else//__LINUX__

#include <dirent.h>

#include <unistd.h>

#include <sys/stat.h>

#define stricmp strcasecmp

#define strinicmp strncasecmp

#endif

#define MAXPATHLEN 255

/** 

Constructor.

@internalComponent

@released

*/

DirReader::DirReader(const 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(const string& aName) {

	unsigned int strPos = aName.find_last_of('.');

	if(strPos != string::npos) {

		string ext = aName.substr(strPos);

		if(ext.length() <= 4) {

			ReaderUtil::ToLower(ext);

			if (ext.find(".exe") != string::npos || ext.find(".dll") != string::npos ||

				ext.find(".prt") != string::npos || ext.find(".nif") != string::npos ||

				ext.find(".pdl") != string::npos || ext.find(".csy") != string::npos || 

				ext.find(".agt") != string::npos || ext.find(".ani") != string::npos || 

				ext.find(".loc") != string::npos || ext.find(".drv") != string::npos || 

				ext.find(".pdd") != string::npos || ext.find(".ldd") != string::npos ||

				ext.find(".tsy") != string::npos || ext.find(".fsy") != string::npos ||

				ext.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(const string& aPath) {

	E32Image* e32Image = KNull;

#ifdef WIN32

	int handle ; 

	int 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_base::binary | ios_base::in);

				iExeAvailable = true;

				e32Image->iFileSize=finder.size;

				e32Image->Adjust(finder.size);

				inputStream >> *e32Image;				

				ExeVsE32ImageMap::iterator it  ;

				for(it = iExeVsE32ImageMap.begin() ;it != iExeVsE32ImageMap.end(); it++){

					if(it->first == finder.name){ 

						break ;

					}

				}				

				if(it != iExeVsE32ImageMap.end()) {

					cout << "Warning: "<< "Duplicate entry '" << finder.name << " '"<< endl;					

					retVal = _findnext(handle, &finder);

					continue;

				}

				size_t len = strlen(finder.name) + 1;

				e32Image->iFileName = new char[len ];

				memcpy(e32Image->iFileName,finder.name,len); 

				put_item_to_map_2(iExeVsE32ImageMap,e32Image->iFileName, e32Image);

				iExecutableList.push_back(e32Image->iFileName); 

			}

			else {

				cout << "Warning: "<< finder.name << " is not a valid E32 executable" << endl;

			}

		}

		retVal = _findnext(handle,&finder);

	}

#else //__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(fullName.c_str())) {

					iExeAvailable = true;

					e32Image = new E32Image();

					ifstream inputStream(fullName.c_str(), ios_base::binary | ios_base::in);

					inputStream.seekg(0, ios_base::end);

					TUint32 aSz = inputStream.tellg();

					inputStream.seekg(0, ios_base::beg);

					e32Image->iFileSize=aSz;

					e32Image->Adjust(aSz);

					inputStream >> *e32Image;

					//string exeName(dirPtr->d_name);

					//ReaderUtil::ToLower(exeName);

					ExeVsE32ImageMap::iterator it  ;

					for(it = iExeVsE32ImageMap.begin() ;it != iExeVsE32ImageMap.end(); it++){

						if(!stricmp(dirPtr->d_name,it->first.c_str())){ 

							break ;

						}

					}	

					if(it != iExeVsE32ImageMap.end()) {

						cout << "Warning: "<< "Duplicate entry '" << dirPtr->d_name << " '"<< endl;

						continue;

					}

					size_t len = strlen(dirPtr->d_name) + 1;

					if(e32Image->iFileName) delete []e32Image->iFileName;

					e32Image->iFileName = new char[len ];

					memcpy(e32Image->iFileName,dirPtr->d_name,len); 					

					put_item_to_map_2(iExeVsE32ImageMap,e32Image->iFileName, e32Image);					

					iExecutableList.push_back(e32Image->iFileName); 

				}

				else {

					cout << "Warning: "<< dirPtr->d_name << " is not a valid E32 executable" << endl;

				}

			}

		}

	}

	closedir(dirEntry);

#endif

}

/** 

Function to traverse through ExeVsE32ImageMap and prepare ExeVsIdData map.

@internalComponent

@released

*/

void DirReader::PrepareExeVsIdMap(void) {  

	if(iExeVsIdData.size() == 0)  {//Is not already prepared

		for(ExeVsE32ImageMap::iterator it = iExeVsE32ImageMap.begin();

		it != iExeVsE32ImageMap.end(); it++) { 

			E32Image* e32Image = it->second;

			IdData* 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.

			}

			put_item_to_map_2(iExeVsIdData,it->first,id); 

		}

	} 

}

/** 

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

	StringList executables;

	for(ExeVsE32ImageMap::iterator it =  iExeVsE32ImageMap.begin();

	it != iExeVsE32ImageMap.end(); it++) {

		PrepareExeDependencyList(it->second, executables);

		put_item_to_map(iImageVsDepList,it->first, executables);

		executables.clear(); 

	}

	return iImageVsDepList;

}

/** 

Function responsible to prepare the dependency list.

@internalComponent

@released

@param - aE32Image, Using this, can get all the information about the executable

@param - aExecutables, Excutables placed into this list

*/

void DirReader::PrepareExeDependencyList(E32Image* aE32Image, StringList& aExecutables) {

	int count = 0;

	char** names = aE32Image->GetImportExecutableNames(count); 

	for(int i = 0; i < count; ++i) { 

		aExecutables.push_back(names[i]);

	}

	if(names){

		delete [](reinterpret_cast<long*>(names));

	}

}

/** 

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(string& aStr) {	

	int pos = aStr.length() - 1;

	if(pos < 0)

		return EUnknownImage;

	char ch = aStr.at(pos);

	if(ch == SLASH_CHAR1 || ch == SLASH_CHAR2) {

		aStr.erase(pos,1);

	} 

#ifdef WIN32 

	struct _finddata_t  finder;

	int retVal = _findfirst(aStr.c_str(), &finder);

	if(retVal > 0) {//No error 

		if(finder.attrib & _A_SUBDIR) {

#else//__LINUX__

	struct stat fileEntrybuf;

	int retVal = stat(aStr.c_str(), &fileEntrybuf);

	if(retVal >= 0) {

		if(S_ISDIR(fileEntrybuf.st_mode)) {

#endif

			return EE32Directoy;

		}

		else {

			if(E32Reader::IsE32Image(aStr.c_str()) == true) {

				return EE32File;

			}

		}

	}

	return EE32InputNotExist;

}