/*

* Copyright (c) 1997-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: 

* handles parsing of PKG file

* Note: This file may contain code to generate corrupt files for test purposes.

* Such code is excluded from production builds by use of compiler defines;

* it is recommended that such code should be removed if this code is ever published publicly.

* INCLUDES

*

*/

/**

 @file

 @internalComponent

 @released

*/

#ifdef _MSC_VER

#pragma warning (disable: 4786)

#endif 

#include <assert.h>

#include <iostream>

#include <stdio.h>

#include <string>

#include "packageparser.h"

#include "utility_interface.h"

#include "version.h"

#include "utils.h"

#define EOF_TOKEN			 0

#define NUMERIC_TOKEN		 1

#define ALPHA_TOKEN			 2

#define QUOTED_STRING_TOKEN	 3

#define AND_TOKEN			 4

#define OR_TOKEN			 5

#define NOT_TOKEN			 6

#define EXISTS_TOKEN		 7

#define DEVCAP_TOKEN		 8

#define APPCAP_TOKEN		 9

#define GE_TOKEN			 10

#define LE_TOKEN			 11

#define NE_TOKEN			 12

#define IF_TOKEN			 13

#define ELSEIF_TOKEN		 14

#define ELSE_TOKEN			 15

#define ENDIF_TOKEN			 16

#define TYPE_TOKEN			 17

#define KEY_TOKEN			 18

#define VERSION_TOKEN		 19

#define SUPPORTED_LANG_TOKEN 20

#define LAST_TOKEN			 20

TDuplicates CPackageParser::iSrcFiles;

// ===========================================================================

// CONSTANTS

// ===========================================================================

// Set up the cout stream so that we can use it with either narrow or wide

// chars at build time

#ifndef _UNICODE

#error _UNICODE expected

#endif // _UNICODE

// Parse options lookups

const SParseOpt KHeaderOptions[] =

	{

		{L"IU", EInstIsUnicode},

		{L"SH", EInstShutdownApps},

		{L"NC", EInstNoCompress},

		{L"IUNICODE",		EInstIsUnicode},

		{L"SHUTDOWNAPPS",	EInstShutdownApps},

		{L"NOCOMPRESS",		EInstNoCompress},

		{L"NR",				EInstNonRemovable},

		{L"NONREMOVABLE",	EInstNonRemovable},

		{L"RU",				EInstROMUpgrade},

 		{L"ROMUPGRADE",		EInstROMUpgrade},

 		{L"H",				EInstHide},

 		{L"HIDE",			EInstHide}

	};

#define NUMHEADEROPTIONS (sizeof(KHeaderOptions)/sizeof(SParseOpt))

// Parse options lookups

#define MAXTOKENLEN	30

struct SParseToken

	{

	WCHAR pszOpt[MAXTOKENLEN];

	DWORD dwOpt;

	};

const SParseToken KTokens[] =

	{

		{L"if",			IF_TOKEN},

		{L"elseif",		ELSEIF_TOKEN},

		{L"else",		ELSE_TOKEN},

		{L"endif",		ENDIF_TOKEN},

		{L"exists",		EXISTS_TOKEN},

		{L"devcap",		DEVCAP_TOKEN},

		{L"appcap",		APPCAP_TOKEN},

		{L"package",	DEVCAP_TOKEN},

		{L"appprop",	APPCAP_TOKEN},

		{L"not",		NOT_TOKEN},

		{L"and",		AND_TOKEN},

		{L"or",			OR_TOKEN},

		{L"type",		TYPE_TOKEN},

		{L"key",		KEY_TOKEN},

		{L"version",	VERSION_TOKEN},

		{L"supported_language",SUPPORTED_LANG_TOKEN},

	};

#define NUMPARSETOKENS (sizeof(KTokens)/sizeof(SParseToken))

// ===========================================================================

// CPackageParser

// ===========================================================================

CPackageParser::CPackageParser(MParserObserver& aObserver) :

				iValidSISFile(true),

				iMakeStub(false),

				iReportInterpretSisError(false),

				iEnoughForStub(false),

				iIsHeaderDefined(false),

				iUniqueVendorName (false),

				iLocalisedVendorNames (false),

				iPkgChar(0),

				iLineNo(0),	   		// The line we are currently on

				iCurrentLang(0),	// If we are in a lang/lang file block - which lang are we processing

				iToken(0),

				iFileHandle(0),

				iObserver(aObserver)

	{

	memset((void *)iSearchDir, 0x0000, PATHMAX * sizeof(wchar_t));

	}

void CPackageParser::SetSearchDirectory(LPCWSTR pszPath)

// Purpose  : Sets the search directory

// Inputs   : pszPath  - The directory path (including trailing backslash!)

	{

	wcsncpy(iSearchDir, pszPath, PATHMAX - 1);

	DWORD len=wcslen(iSearchDir);

	wchar_t *pBuffer = iSearchDir;

	wchar_t *pCurrent = pBuffer;

	while (pBuffer && *pBuffer && (pCurrent = wcschr(pBuffer,L'\\')) != NULL)

		{

		*pCurrent = L'/';

		pBuffer = pCurrent + 1;

		} 

	if(len>0 && iSearchDir[len - 1] != '/')

		{

		iSearchDir[len] = '/';

		iSearchDir[len+1] = '\0';

		}

	}

void CPackageParser::MakeSisL(const wchar_t* aPkgFileName, const wchar_t* aSisFileName, bool aMakeStub, bool aReportInterpretSisError)

	{

	iMakeStub = aMakeStub;

	iReportInterpretSisError = aReportInterpretSisError;

	ParseL(aPkgFileName);

	// Turn off line number output

	iObserver.SetLineNumber(0);

	if (iMakeStub)

		iObserver.DoVerbage(L"Generating SIS stub file...");

	else

		iObserver.DoVerbage(L"Generating SIS installation file...");

	if (iValidSISFile)

		{

		iSISXWriter.WriteSIS (aSisFileName);

		}

	}

HANDLE CPackageParser::OpenPackageFile(const wchar_t* aPkgFileName)

	{

	bool fResult = true;

	wchar_t pszTempSource [PATHMAX];

	bool converted = true;

	HANDLE hFile = 0;

	TEncodingScheme encScheme;

	if (!FileIsUnicode(aPkgFileName,encScheme))

		{

		if ( EUtf8 != encScheme )

			iObserver.DoVerbage(L"Byte order marker not detected. Assuming UTF-8 encoding");

		iObserver.DoVerbage(L"Encoding scheme: UTF8");

		wcscpy(pszTempSource,ConvertFileToUnicode(aPkgFileName,encScheme));

		}

	else if (encScheme == EUcs2BE && sizeof(WCHAR) == 2)

		{

		iObserver.DoVerbage(L"Encoding scheme: UCS2 (BE)");

		wcscpy(pszTempSource,ConvertUCS2FileToLittleEndianUnicode(aPkgFileName));

		}

	/*

		Linux first needs conversion to little endian and then into ucs-4

		Linux has wchar in 4 bytes and processing of .pkg file happens based on wchar

		so need conversion here from ucs2 to ucs4

	*/

	else if (encScheme == EUcs2BE && sizeof(WCHAR) == 4)

		{

		iObserver.DoVerbage(L"Encoding scheme: UCS2 (BE)");

		wcscpy(pszTempSource,ConvertUCS2FileToLittleEndianUnicode(aPkgFileName));

		wcscpy(pszTempSource,ConvertUCS2FileToUCS4(pszTempSource));

		}

	else if (encScheme == EUcs2LE && sizeof(WCHAR) == 2)

		{

		iObserver.DoVerbage(L"Encoding scheme: UCS2 (LE)");

		wcscpy(pszTempSource, aPkgFileName);

		converted = false;

		}

	// Convert UCS2 file to UCS4 for Linux

	else if (encScheme == EUcs2LE && sizeof(WCHAR) == 4)

		{

		iObserver.DoVerbage(L"Encoding scheme: UCS2 (LE)");

		wcscpy(pszTempSource,ConvertUCS2FileToUCS4(aPkgFileName));

		}

	else

		{

		iObserver.DoVerbage(L"Encoding scheme not supported");

		throw ErrCannotOpenFile;

		}

	hFile = ::MakeSISOpenFile(pszTempSource,GENERIC_READ,OPEN_EXISTING);

	if (hFile==INVALID_HANDLE_VALUE)

		{

		throw ErrCannotOpenFile;

		}

	if(encScheme == EUtf8)

		{

		UnicodeMarker(hFile);

		}

	if(converted)

		{

		_wunlink(pszTempSource);

		}

	return hFile;

	}

void CPackageParser::ParseL (const wchar_t* aPkgFileName)

// Purpose  : Check the contents of an input line and defers parsing to the appropriate ParseXXXL()

//			  method

// Inputs   : m_pkgPtr - The line to process

	{

	iValidSISFile = true;

	iFileHandle = OpenPackageFile(aPkgFileName);

	assert(iFileHandle != INVALID_HANDLE_VALUE);

	iEnoughForStub = false;

	iSISXWriter.SetDefaultContent ();

	iObserver.SetLineNumber(++iLineNo);

	// Make sure we're at the beginning of the file

	::SetFilePointer(iFileHandle, 0L, NULL, FILE_BEGIN);

	GetNextChar();

	// skip unicode marker if present

	if(iPkgChar==0xFEFF) GetNextChar();

	GetNextToken ();

	while(iToken!=EOF_TOKEN && !(iMakeStub && iEnoughForStub))

		{

		ParseEmbeddedBlockL (iSISXWriter.InstallBlock ());

		switch (iToken)

			{

			case '&':

				// Pkg file keyword check is disabled here 

 				// to avoid conflicts with the language code 

 				// (e.g. "IF - International French").

 				GetNextToken (1);

				ParseLanguagesL();

				break;

			case '#':

				GetNextToken ();

				ParseHeaderL();

				break;

			case '%':

				GetNextToken ();

				ParseVendorNameL();

				break;

			case '=':

				GetNextToken ();

				ParseLogoL();

				break;

			case '(':

				GetNextToken ();

				ParseDependencyL();

				break;

			case '*':

				GetNextToken ();

				ParseSignatureL();

				break;

			case ':':

				GetNextToken ();

				ParseVendorUniqueNameL();

				break;

			case '[':

				GetNextToken ();

				ParseTargetDeviceL();

				break;

			case EOF_TOKEN:

				break;

			default :

				{

				throw ErrUnknownLine;

				}

			}

		}

	if (! iUniqueVendorName && ! iLocalisedVendorNames)

		{

		iObserver.DoMsg(L"No vendor names found.\n");

		}

	else if (! iLocalisedVendorNames)

		{

		iObserver.DoMsg(L"Localised vendor names not found.\n");

		}

	else if (! iUniqueVendorName)

		{

		iObserver.DoMsg(L"Unique vendor name not found.\n");

		}

	if (iFileHandle)

		{

		::CloseHandle(iFileHandle);

		}

	}

void CPackageParser::ParseEmbeddedBlockL (CSISInstallBlock& aInstall)

	{

	while(iToken!=EOF_TOKEN)

		{

		switch (iToken)

			{

			case QUOTED_STRING_TOKEN:

				ParseFileL (aInstall);

				break;

			case '@':

				GetNextToken ();

				ParsePackageL (aInstall);

				break;

			case '!':

				GetNextToken ();

				ParseOptionsBlockL();

				break;

			case '{':

				GetNextToken ();

				ParseLanguageBlockL (aInstall);

				break;

			case '+':

				GetNextToken ();

				ParsePropertyL ();

				break;

			case IF_TOKEN:

				GetNextToken ();

				ParseIfBlockL (aInstall);

				break;

			case ';' :

				ParseCommentL ();

				break;

			default :

				return;

			}

		}

	}

void CPackageParser::ParseLanguagesL()

// Parses the language definition line

// Updated to support "dialects"

// Dialect definition syntax is: <language>["("<dialect-code>")"]

	{

	iObserver.DoVerbage(L"processing languages");

	if (iSISXWriter.AreLanguagesSpecified ())

		throw ErrLanguagesAlreadyDefined;

	CSISLanguage::TDialect dialect (0);

	while (true)

		{

		if (iToken==ALPHA_TOKEN)

			{

			dialect = CSISLanguage::IdentifyLanguage (iTokenValue.pszString);

			if (dialect == CSISLanguage::ELangNone) throw ErrUnknownLanguagesId;

			}

		else if (iToken==NUMERIC_TOKEN && iTokenValue.dwNumber>=0 )

			{

			dialect = static_cast <CSISLanguage::TDialect> (iTokenValue.dwNumber);

			}

		else

			throw ErrUnknownLanguagesId;

		GetNextToken ();

		// Check if a dialect is defined

		if (iToken == '(')

			{

			GetNumericToken();

			// Modify the last added language code, combining it with dialect code

			if (dialect) dialect = dialect + static_cast <CSISLanguage::TDialect> (iTokenValue.dwNumber);

			GetNextToken ();

			if (iToken != ')')

				throw ErrUnexpectedToken;

			GetNextToken ();

			}

		iSISXWriter.AddLanguage (dialect);

		dialect=0;

		if (iToken!=',')

			return;

		GetNextToken (1);

		}

	}

void CPackageParser::ParseHeaderL()

// Parses the pkg header line

	{

	iObserver.DoVerbage(L"processing header");

	// Default type

	std::wstring interpretType = L"SA";

	bool isNonRemovable = false;

	// By default the ROM Upgradeable flag (RU) is FALSE.

	bool isROMUpgrade = false;

	if (iIsHeaderDefined)

		throw ErrHeaderAlreadyDefined;

	if (! iSISXWriter.AreLanguagesSpecified ())

		{

		iObserver.DoVerbage (L"No languages defined, assuming English.");

		}

	// process application names

	ExpectToken('{');

	for (WORD wNumLangs = 0; wNumLangs < iSISXWriter.GetNoLanguages(); wNumLangs++)

		{

		GetNextToken ();

		ExpectToken(QUOTED_STRING_TOKEN);

		iSISXWriter.AddName (iTokenValue.pszString);

		GetNextToken ();

		if (wNumLangs < iSISXWriter.GetNoLanguages() -1 )

			{

			ExpectToken(',');

			}

		}

	ExpectToken('}');

	GetNextToken ();

	DWORD dwFlags = 0;

	DWORD dwType = 0;

	ExpectToken(',');

	GetNextToken ();

	ExpectToken('(');

	GetNextToken ();

	ExpectToken(NUMERIC_TOKEN);

	CSISUid::TUid uid = iTokenValue.dwNumber;

	GetNextToken ();

	ExpectToken(')');

	GetNextToken ();

	ExpectToken(',');

	GetNextToken ();

	ExpectToken(NUMERIC_TOKEN);

	CSISVersion::TMajor major = iTokenValue.dwNumber;

	GetNextToken ();

	ExpectToken(',');

	GetNextToken ();

	ExpectToken(NUMERIC_TOKEN);

	CSISVersion::TMinor minor = iTokenValue.dwNumber;

	GetNextToken ();

	ExpectToken(',');

	GetNextToken ();

	ExpectToken(NUMERIC_TOKEN);

	CSISVersion::TBuild build = iTokenValue.dwNumber;

	GetNextToken ();

	ValidateVersion(major,minor,build);

	// Parse any options

	bool narrow=false;

	while (iToken==',')

		{

		GetNextToken ();

		if (iToken==TYPE_TOKEN)

			{

			GetNextToken ();

			ExpectToken('=');

			GetNextToken ();

			interpretType = iTokenValue.pszString;

			iSISXWriter.InterpretType (iTokenValue.pszString);

			GetNextToken ();

			}

		else

			{