/*

* Copyright (c) 2004-2010 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 "utility.h"

#include "exception.h"

#include "utility_interface.h"

#include "utils.h"

#include <stdio.h>

#include <assert.h>

#include <stdlib.h>

#include <fstream>

#include <algorithm>

std::wostream* SISLogger::iStream = NULL;

void SISLogger::SetStream(std::wostream& aStream)

	{

	iStream = &aStream;

	}

void SISLogger::Log(const std::wstring& aString)

	{

	if(NULL != iStream)

		{

		(*iStream) << aString;

		}

	}

DllExport std::string wstring2string (const std::wstring& aWide)

	{

	int max = ConvertWideCharToMultiByte(aWide.c_str(),aWide.length(),0,0);

	std::string reply;

	if (max > 0 )

		{

		char* buffer = new char [max];

		try

			{

			ConvertWideCharToMultiByte(aWide.c_str(),aWide.length(),buffer,max);

			reply = std::string (buffer, max);

			}

		catch (...)

			{

			}

		delete [] buffer;

		}

	return reply;

	}

std::wstring string2wstring (const std::string& aNarrow)

	{

	int max = ConvertMultiByteToWideChar(aNarrow.c_str(),aNarrow.length(),0,0, CP_OEMCP);

	std::wstring reply;

	if (max > 0 )

		{

		wchar_t* buffer = new wchar_t [max];

		try

			{

			ConvertMultiByteToWideChar(aNarrow.c_str(),aNarrow.length(),buffer,max,CP_OEMCP);

			reply = std::wstring (buffer, max);

			}

		catch (...)

			{

			}

		delete [] buffer;

		}	

	return reply.c_str();

	}

void EnsureExtended (std::wstring& aName, const std::wstring& aDefaultExtension)

	{

	assert (! aName.empty ());

	assert (! aDefaultExtension.empty ());

	std::wstring::size_type posSlash (aName.rfind ('\\'));

	if (posSlash == std::wstring::npos)

		{

		posSlash = 0;

		}

	std::wstring::size_type posDot (aName.find (posSlash, '.'));

	if (posDot == std::wstring::npos)

		{

		aName += aDefaultExtension;

		}

	}

bool ValidateFileName (std::wstring& aName, const bool aMustExist)

	{

	assert (! aName.empty ());

	if (aName.size () < 3)

		{

		return false;

		}

	std::wstring filename (aName);

	bool isUNC ((filename.at (0) == L'/') && (filename.at (1) == L'/'));

	bool isRelative (! isUNC && ((filename.at (1) != L':')));

	if (! isRelative)

		{

		if (! isUNC && (filename.at (2) != L'/')) 

			{

			return false;

			}

		}

	else

		{

		const int maxlen = PATHMAX * 8;	/*	The value of PATHMAX assumes short name FAT environment,

												not long names and / or NTFS, UNC, URL, etc. etc.. Using a

												larger value significantly reduces the chances of failure

												when the application is deep in a subdirectory tree. Windows

												calls require fixed length buffers. 

											*/

		wchar_t	directorybuffer [maxlen];

		std::wstring cwd (_wgetcwd (directorybuffer, maxlen));

		if (cwd.empty ()) 

			{

			return false;

			}

		if (cwd.size () > 3) 

			{

			cwd += KSisDirectorySeparator;	// trailing backslash is returned inconsistently according to docs for getcwd

			}

		filename = cwd + filename;

		}

	if (aMustExist)

		{

		DWORD attributes (GetFileAttributesW (filename.c_str ()));

		if (attributes == RESULT) 

			{

			return false;

			}

		}

	aName = filename;

	return true;

	}

bool ValidateDirectory (std::wstring& aName, const bool aMustExist)

	{

	if (! ValidateFileName (aName, aMustExist)) 

		{

		return false;

		}

	if (aName.at (aName.size () - 1) != L'/') 

		{

		aName += L'/';

		}

	return true;

	}

bool ValidateFileName (std::wstring& aName, const bool aMustExist, const std::wstring& aDefaultExtension)

	{

	assert (! aName.empty ());

	assert (! aDefaultExtension.empty ());

	std::wstring filename (aName);

	EnsureExtended (filename, aDefaultExtension);

	if (! ValidateFileName (filename, aMustExist)) 

		{

		return false;

		}

	aName = filename;

	return true;

	}

TUint32 IdentifyUCKeyword (const SKeyword aKeyword [], std::wstring aIdentifier, const std::wstring& aContext)

	{

	for (std::wstring::size_type letter = 0; letter < aIdentifier.size (); letter++)

		{

		aIdentifier [letter] = toupper (aIdentifier [letter]);

		}

	for (const SKeyword* index = &aKeyword [0]; index -> iName != NULL; index++)

		{

		if (aIdentifier.compare (index -> iName) == 0) 

			{

			return index -> iId;

			}

		}

	throw CSISException (CSISException::ESyntax, aContext + aIdentifier);

	}

CSISFieldRoot::TFieldSize Alignment (const CSISFieldRoot::TFieldSize aOriginal)

	{

	const CSISFieldRoot::TFieldSize coarseness (4);

	CSISFieldRoot::TFieldSize modulus (aOriginal % coarseness);

	return (modulus == 0) ? 0 : (coarseness - modulus);

	}

CSISFieldRoot::TFieldSize AlignedSize (const CSISFieldRoot::TFieldSize aOriginal)

	{

	return aOriginal + Alignment (aOriginal);

	}

void ReadFiller (TSISStream& aFile)

	{

	CSISFieldRoot::TFieldSize diff (Alignment (aFile.tell ()));

	assert (diff >= 0);

	if (diff)

		{

		TUint8 junk;

		for (CSISFieldRoot::TFieldSize index = 0; index < diff; index++) 

			{

			aFile >> junk;

			}

		}

	}

void WriteFiller (TSISStream& aFile)  

	{

	TSISStream::pos_type pos (aFile.tell ());

	if (pos >= 0)

		{

		CSISFieldRoot::TFieldSize diff (Alignment (pos));

		if (diff)

			{

			TUint8 padding = 0;

			for (CSISFieldRoot::TFieldSize index = 0; index < diff; index++) 

				{

				aFile << padding;

				}

			}

		}

	}

HANDLE OpenFileAndGetSize (const std::wstring& aName, TUint64* aSize)

	{

	HANDLE file = MakeSISOpenFile(aName.c_str(),GENERIC_READ,OPEN_EXISTING);

	CSISException::ThrowIf ((INVALID_HANDLE_VALUE == file), 

							CSISException::EFileProblem, std::wstring (L"cannot open ") + aName);

	if (aSize)

		{

		DWORD dwHigh = 0;

		DWORD dwLow = ::GetFileSize(file,&dwHigh);

		TUint64 size = (dwHigh << 32) | dwLow;

		*aSize = static_cast <TUint64> (size);

		}

	return file;

	}

void ReadAndCloseFile (HANDLE aFile, const TUint64 aSize, TUint8* aBuffer)

	{

	size_t got = 0;

	::ReadFile(aFile,aBuffer,aSize,(DWORD*)&got,0);

	::CloseHandle(aFile);

	CSISException::ThrowIf (got != static_cast <size_t> (aSize), 

							CSISException::EFileProblem, 

							"cannot read file");

	}

int SearchSortedUCTable (const SIdentifierTable aTable [], const std::wstring& aIdentifier)

	{

	for (int index = 0; aTable [index].iName; index++)

		{

		int comparision = aIdentifier.compare (aTable [index].iName);

		if (comparision == 0)

			{

			return index;

			}

		if (comparision < 0)

			{

			break;

			}

		}

	return -1;

	}

LPSTR MakeMBCSString(LPCWSTR uniStr, UINT codePage, DWORD& length)

// Convert a UNICODE string to a multi-byte string

	{

	LPSTR mbStr;

	// get num unicode chars required

	DWORD len = ConvertWideCharToMultiByte(uniStr, length, NULL, 0);

	mbStr = new CHAR[len+1];

	if (!mbStr) throw ErrNotEnoughMemory;

	// convert

	ConvertWideCharToMultiByte(uniStr, length, mbStr, len);

	mbStr[len]='\0';

	length=len;

	return mbStr;

	}

char* Copy2TmpFile(const wchar_t *fName, TFileType fType)

{

	char *tmpName, *tmpFileName=NULL;

	int numread = 0;

	tmpName = GetTempFile();

	if(tmpName == NULL)

		return NULL;

	tmpFileName = new char[strlen(tmpName)+5];

	strcpy(tmpFileName, tmpName);

	if(fType == CERTFILE)

		{

		tmpFileName = strcat(tmpFileName, ".cer");

		}	

	else if(fType == KEYFILE)

		{

		tmpFileName = strcat(tmpFileName, ".key");

		}

	else

		{

		tmpFileName = strcat(tmpFileName, ".dat");

		}

		TransferFileData(fName,tmpFileName);

		return tmpFileName;

		if(tmpFileName != NULL)

			delete tmpFileName;

	return NULL;

}

/**

 * Returns the size of the first occurance of an invalid directory separator.

 * @param aPath Path to be validated.

 * @param aIndex index from which the search begin. On function return this 

 * 				index will point to the illegal directory separator. 

 * @return 0 if path is valid. Else the number of character to be replaced.

 * e.g. \sys\bin\ should be replaced with /sys/bin/

 * and \\sys\\bin\\ should be replaced with /sys/bin/

 */ 

int FirstInvalidDirSeparatorSize(std::wstring& aPath, std::wstring::size_type& aIndex)

	{

	// If path semantics is correct (as needed by sisx library)

	// then the function will return 0

	int ret = 0; 

	int pos = 0;

	if((pos = aPath.find(L"\\\\", aIndex)) != std::wstring::npos)

		{

		ret = 2;

		}

	else if((pos = aPath.find(L"\\", aIndex)) != std::wstring::npos)

		{

		ret = 1;

		}

	aIndex = pos;

	return ret;

	}

std::wstring FixPathDelimiters( const std::wstring& aString )

    {

    std::wstring ret = aString;

    std::wstring::size_type idx = 0;

    int len = 0;

	while(len = FirstInvalidDirSeparatorSize(ret, idx))

        {

		if(idx == 0 && len == 2)

			{

			ret.replace( idx, len, KSisInitialNetworkPathSlashes );

			}

		else

			{

			ret.replace( idx, len, KSisDirectorySeparator );

			}

        }

    return ret.c_str();

    }

int GetFileType(std::wstring& aFileName)

	{

    int len = ConvertWideCharToMultiByte(aFileName.c_str(), -1, NULL, 0);

    char* fileName = new char[len + 1];

    ConvertWideCharToMultiByte(aFileName.c_str(), -1, fileName, len);

    std::ifstream fs(fileName, std::ios::binary | std::ios::in);

    fs.seekg(0, std::ios::end);

    len = fs.tellg();

    fs.seekg(0, std::ios::beg);

    unsigned char* buffer = new unsigned char[len];

    fs.read((char*)buffer, len);

    fs.close();

    int type = EFileUnknown;

    const TUint32* data32 = reinterpret_cast<const TUint32*>(buffer);

	if (len <= sizeof(TUint32)*0x04)

		{

		delete[] buffer;

		return type;

		}

	if(IsExeData(buffer, len))

		{

		type = EFileExe;

		}

	else if(IsDllData(buffer, len))

		{

		type = EFileDll;

		}

	if(IsEmulatorExecutableData(buffer, len))

		{

		type |= EFileEmulatorExe;

		}

    return type;

	}

bool IsExecutableData(const unsigned char* aContent, TUint32 aLength) 

	{

	if (aLength <= sizeof(TUint32)*0x05)

		{

		return false;

		}

	const TUint32* data32 = reinterpret_cast<const TUint32*>(aContent);

	bool isExecutable = false;

	if (	IsExeData(aContent, aLength) || 

			IsDllData(aContent, aLength) || 

			IsEmulatorExecutableData(aContent, aLength))

		{

		isExecutable = true;

		} 

	return isExecutable;

	}

bool IsEmulatorExecutableData(const unsigned char* aContent, TUint32 aLength)

	{

	bool isEmulatorExe = false;

	// winscw binary

	if (aLength > 2 && aContent[0] == 'M' && aContent[1] == 'Z')

		{

		isEmulatorExe = true;

		}

	return isEmulatorExe;

	}

bool IsExeData(const unsigned char* aContent, TUint32 aLength)

	{

	return (GetExecutableType(aContent, aLength) == KExecutableImageUid)? true: false;

	}

bool IsDllData(const unsigned char* aContent, TUint32 aLength)

	{

	return (GetExecutableType(aContent, aLength) == KDynamicLibraryUid)? true: false;

	}

TInt32 GetExecutableType(const unsigned char* aContent, TUint32 aLength)

	{

	const TUint32* data32 = reinterpret_cast<const TUint32*>(aContent);

	if(aLength < sizeof(TUint32)*0x05)

		{

		return 0;

		}

	TInt32 type = 0;

	if(data32[0x04] == KFileHeaderSignature)

		{

		type = data32[0];

		}

	else if (IsEmulatorExecutableData(aContent, aLength))

		{

		const char symbian[] = ".SYMBIAN";

		const int  len2      = sizeof(symbian)-1;

		const unsigned char* index = std::search(aContent, aContent+aLength, symbian, symbian+len2);

		if ( (index + KHeaderUidLength < aContent+aLength) && (index != aContent+aLength) )

			{

			index += KHeaderUidLength;

			TInt32 offset = *(TInt32*)index;

			if (offset < aLength)

				{

				const TUint32* x = (TUint32*)(aContent+offset);

				type = x[0];

				}

			}

		}

	return type;

	}