/*

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

* Rofsbuild Obey file class and its reader class.

*

*/

#include <strstream>

#include <iomanip>

#include <string.h>

#include <stdlib.h>

#include <stdio.h>

#include <time.h>

#include <assert.h>

#include <errno.h>

#include <e32std.h>

#include <e32std_private.h>

#include <e32rom.h>

#include <u32std.h>

#include <f32file.h>

#include "h_utl.h"

#include "r_obey.h"

#include "r_coreimage.h"

#include "patchdataprocessor.h"

#include "fatimagegenerator.h" 

#include "r_driveimage.h"

#ifdef __LINUX__

#include <dirent.h> 

#include <sys/stat.h>

#include <unistd.h>

#else

#include <io.h> 

#include <direct.h> //TODO: check under MinGW4 + stlport 5.2

#include <conio.h> 

#endif

#include "uniconv.hpp"

extern TInt gCodePagingOverride;

extern TInt gDataPagingOverride;

extern ECompression gCompress;

extern TBool gEnableStdPathWarning; // Default to not warn if destination path provided for a file is not in standard path.

extern TBool gKeepGoing;

extern TBool gIsOBYUTF8;

#define _P(word)	word, sizeof(word)-1	// match prefix, optionally followed by [HWVD]

#define _K(word)	word, 0					// match whole word

static char* const NullString = "" ;

const ObeyFileKeyword ObeyFileReader::iKeywords[] =

{

	{_K("file"),		2,-2, EKeywordFile, "File to be copied into ROFS"},

	{_K("data"),		2,-2, EKeywordData, "same as file"},

	{_K("dir"),         2,1, EKeywordDir, "Directory to be created into FAT image"},

	{_K("dircopy"),      2,-2, EKeywordDirCpy, "Directory to be copied into FAT image"},

	{_K("rofsname"),	1, 1, EKeywordRofsName, "output file for ROFS image"},

	{_K("romsize"),		1, 1, EKeywordRomSize, "size of ROM image"}, 

	{_P("hide"),	    2, -1, EKeywordHide, "Exclude named file from ROM directory structure"},

	{_P("alias"),	    2, -2, EKeywordAlias, "Create alias for existing file in ROM directory structure"},

	{_P("rename"),	    2, -2, EKeywordRename, "Change the name of a file in the ROM directory structure"},

	{_K("rofssize"),		1, 1, EKeywordRofsSize, "maximum size of ROFS image"},

	{_K("romchecksum"),	1, 1, EKeywordRofsChecksum, "desired 32-bit checksum value for the whole image"},

	{_K("version"),		1, 1, EKeywordVersion, "ROFS image version number"},

	{_K("time"),	    1,-1, EKeywordTime, "ROFS image timestamp"},

	{_K("extensionrofs"),1+2, 1, EKeywordExtensionRofs, "Start of definition of optional Extension ROFS"},

	{_K("extensionrofsname"),1, 1, EKeywordCoreRofsName, "ROFS image on which extension ROFS is based"},

	{_K("rem"),			0, 0, EKeywordNone, "comment"},

	{_K("stop"),		0, 0, EKeywordNone, "Terminates OBEY file prematurely"},

	{_K("romchecksum"),	1, 1, EKeywordRomChecksum, "desired 32-bit checksum value for the whole ROFS image"},

	{_K("coreimage"),	1, 1, EKeywordCoreImage, "Core image to be used for extension directory structure"},

	{_K("autosize"),	1, 1, EKeywordRofsAutoSize, "Automatically adjust maximum image size to actual used"},

	{_K("pagingoverride"),	1, 1, EKeywordPagingOverride, "Overide the demand paging attributes for every file in ROM, NOPAGING|DEFAULTUNPAGED|DEFAULTPAGED"},

	{_K("codepagingoverride"),	1, 1, EKeywordCodePagingOverride, "Overide the code paging attributes for every file in ROM, NOPAGING|DEFAULTUNPAGED|DEFAULTPAGED"},

	{_K("datapagingoverride"),	1, 1, EKeywordDataPagingOverride, "Overide the data paging attributes for every file in ROM, NOPAGING|DEFAULTUNPAGED|DEFAULTPAGED"},

	{_K("dataimagename"),1, 1,EKeywordDataImageName, "Data Drive image file name"},

	{_K("dataimagefilesystem"),1, 1,EKeywordDataImageFileSystem, "Drive image file system format"},

	{_K("dataimagesize"),1, 1,EKeywordDataImageSize, "Maximum size of Data Drive image"},

	{_K("volume"),1, -1,EKeywordDataImageVolume, "Volume Label of Data Drive image"},

	{_K("sectorsize"),1, 1,EKeywordDataImageSectorSize, "Sector size(in bytes) of Data Drive image"},

	{_K("clustersize"),1, 1,EKeywordDataImageClusterSize, "Cluster size(in bytes) of Data Drive image"},

	{_K("fattable"),1, 1,EKeywordDataImageNoOfFats, "Number of FATs in the Data Drive image"},

	// things we don't normally report in the help information

	{_K("trace"),		1, 1, EKeywordTrace, "(ROMBUILD activity trace flags)"},

	{_K("filecompress"),2, -2,EKeywordFileCompress,"Non-XIP Executable to be loaded into the ROM compressed" },

	{_K("fileuncompress"),2, -2,EKeywordFileUncompress,"Non-XIP Executable to be loaded into the ROM uncompressed" },

	{_K("patchdata"),2, 5,EKeywordPatchDllData, "Patch exported data"},

	{_K("imagename"), 1, 1, EKeywordSmrImageName, "output file for SMR image"},

	{_K("hcrdata"), 1, 1, EKeywordSmrFileData, "file data for HCR SMR image"},

	{_K("smrdata"), 1, 1, EKeywordSmrFileData, "file data for general SMR image"},

	{_K("formatversion"), 1, 1, EKeywordSmrFormatVersion, "format version for HCR SMR image"},

	{_K("payloadflags"), 1, 1, EKeywordSmrFlags, "payload flags for the HCR SMR image"},

	{_K("payloaduid"), 1, 1, EKeywordSmrUID, "payload UID for the HCR SMR image"},

	{0,0,0,0,EKeywordNone,""}

};

void ObeyFileReader::KeywordHelp() { // static

	cout << "Obey file keywords:\n";

	const ObeyFileKeyword* k=0;

	for (k=iKeywords; k->iKeyword!=0; k++)

	{

		if (k->iHelpText == 0)

			continue;

		if (k->iHelpText[0]=='(' && !H.iVerbose)

			continue;	// don't normally report things in (parentheses)

		char buf[32];

		sprintf(buf, "%-20s", k->iKeyword);

		if (k->iKeywordLength)

			memcpy(buf+k->iKeywordLength,"[HWVD]",6);

		if (H.iVerbose)

			sprintf(buf+20,"%2d",k->iNumArgs);

		cout << "    " << buf << " " << k->iHelpText << endl;

	}

	cout << endl;

	cout << "File attributes:\n";

	const FileAttributeKeyword* f=0;

	for (f=iAttributeKeywords; f->iKeyword!=0; f++)

	{

		if (f->iHelpText == 0)

			continue;

		if (f->iHelpText[0]=='(' && !H.iVerbose)

			continue;	// don't normally report things in (parentheses)

		char buf[32];

		sprintf(buf, "%-20s", f->iKeyword);

		if (H.iVerbose)

			sprintf(buf+20,"%2d",k->iNumArgs);

		cout << "    " << buf << " " << f->iHelpText << endl;

	}

	cout << endl;

}

ObeyFileReader::ObeyFileReader(const char* aFileName):iCurrentLine(0),

iFileName(aFileName),iNumWords(0),iLine(0),iMarkLine(0),iCurrentObeyStatement(0)	{  

	for(TUint i = 0 ; i < KNumWords ; i++)

		iWord[i] = NullString;

	*iSuffix = 0 ; 

}

ObeyFileReader::~ObeyFileReader() {	  

	if(iCurrentObeyStatement) {

		delete []iCurrentObeyStatement;

		iCurrentObeyStatement = 0 ;

	}

	if(iLine) {

		delete []iLine; 

		iLine = 0 ;

	}

}

//

// Open the file & return a status

//

TBool ObeyFileReader::Open() {     

	ifstream ifs(iFileName.c_str(),ios_base::in + ios_base::binary);

	if (!ifs.is_open()) {

		Print(EError,"Cannot open obey file %s\n",iFileName.c_str());

		return EFalse;

	}

	iLines.clear();

	if(iLine){

		delete []iLine;

		iLine = 0 ;

	}		

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

	size_t length = ifs.tellg();

	char* buffer = new char[length + 2];

	if (0 == buffer) {

		Print(EError,"Insufficent Memory to Continue.");	

		ifs.close();

		return EFalse;

	}

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

	ifs.read(buffer,length);

	size_t readcout = ifs.gcount() ;

	if(readcout != length){ 	

		Print(EError,"Cannot Read All of File.");	

		delete []buffer ;

		ifs.close();

		return EFalse;

	}

	buffer[length] = '\n';

	buffer[length + 1] = 0 ;

	ifs.close();

	char* lineStart = buffer ;

	char* end = buffer + length ;

	string line ;

	size_t maxLengthOfLine = 0 ;

	while(lineStart < end){

		while(*lineStart == ' ' || *lineStart == '\t') //trimleft 

			lineStart ++ ;		

		char* lineEnd = lineStart ;	 

		while(*lineEnd != '\r' && *lineEnd != '\n')

			lineEnd ++ ;

		if(strnicmp(lineStart,"REM",3) == 0){

			line = "" ; // REMOVE "REM ... "

		}

		else {

			TInt lastIndex = lineEnd - lineStart - 1;

			while(lastIndex >= 0 &&  // trimright

				(lineStart[lastIndex] == ' ' || lineStart[lastIndex] == '\t'))

				lastIndex -- ;			

			if(lastIndex >= 0)

				line.assign(lineStart,lastIndex + 1);

			else

				line = "";

		}

		if(line.length() > maxLengthOfLine)

			maxLengthOfLine = line.length();

		iLines.push_back(line);

		if(*lineEnd == '\r') {

			if(lineEnd[1] == '\n')

				lineStart = lineEnd + 2 ;

			else

				lineStart = lineEnd + 1 ;

		}

		else // '\n'

			lineStart = lineEnd + 1 ;

	}	

	delete []buffer ;

	iLine = new char[maxLengthOfLine + 1];

	iCurrentObeyStatement = new char[maxLengthOfLine + 1];

	*iCurrentObeyStatement = 0 ;

	*iLine = 0 ;

	iCurrentLine = 0 ;

	iMarkLine = 0 ;

	return ETrue;

}

void ObeyFileReader::Mark()	{ 

	iMarkLine = iCurrentLine - 1;

}

void ObeyFileReader::MarkNext() { 

	iMarkLine = iCurrentLine;

}

void ObeyFileReader::Rewind() {

	iCurrentLine = iMarkLine;

}

char* ObeyFileReader::DupWord(TInt aIndex) const {

	char* retVal = 0 ;

	if(aIndex >= 0 && aIndex < (TInt)KNumWords){

		size_t len = strlen(iWord[aIndex]) + 1;

		retVal = new char[len];

		if(retVal)

			memcpy(retVal,iWord[aIndex],len);

	} 

	return retVal ;

}

TInt ObeyFileReader::ReadAndParseLine() {

	if (iCurrentLine >= (TInt)iLines.size())

		return KErrEof;

	iCurrentLine++; 	

	iNumWords = Parse();

	return KErrNone;

}

TInt ObeyFileReader::NextLine(TInt aPass, enum EKeyword& aKeyword) {

	static int warnline = -1;

NextLine:

	TInt err = ReadAndParseLine();

	if (err == KErrEof)

		return KErrEof;

	if(iNumWords == 0)

		goto NextLine;

	if (stricmp(iWord[0], "stop")==0)

		return KErrEof;

	const ObeyFileKeyword* k=0;

	for (k=iKeywords; k->iKeyword!=0; k++) {

		if (k->iKeywordLength == 0) {

			// Exact case-insensitive match on keyword

			if (stricmp(iWord[0], k->iKeyword) != 0)

				continue;

			*iSuffix = 0;

		}

		else {

			// Prefix match

			if (strnicmp(iWord[0], k->iKeyword, k->iKeywordLength) != 0)

				continue;

			// Suffix must be empty, or a variant number in []

			strncpy(iSuffix,iWord[0] + k->iKeywordLength,80);

			if (*iSuffix != '\0' && *iSuffix != '[')

				continue;

		}

		// found a match

		if ((k->iPass & aPass) == 0)

			goto NextLine;

		if (k->iNumArgs>=0 && (1+k->iNumArgs != iNumWords)) {

			Print(EError, "Incorrect number of arguments for keyword %s on line %d.\n",

				iWord[0], iCurrentLine);

			goto NextLine;

		}

		if (k->iNumArgs<0 && (1-k->iNumArgs > iNumWords)) {

			Print(EError, "Too few arguments for keyword %s on line %d.\n",

				iWord[0], iCurrentLine);

			goto NextLine;

		}

		aKeyword = k->iKeywordEnum;

		return KErrNone;

	}

	if (aPass == 1 && iCurrentLine > warnline){

		warnline = iCurrentLine;

		Print(EWarning, "Unknown keyword '%s'.  Line %d ignored\n", iWord[0], iCurrentLine);

	}

	goto NextLine;

}

//

// splits a line into words, and returns the number of words found

// 

TInt ObeyFileReader::Parse() {

	for (TUint i = 0; i < KNumWords; i++)

		iWord[i] = NullString;

	enum TState {EInWord, EInQuotedWord, EInGap};

	TState state = EInGap;

	const string& line = iLines[iCurrentLine - 1]; 	

	size_t len = line.length();	

	memcpy(iLine,line.c_str(),len);

	memcpy(iCurrentObeyStatement,iLine,len);

	iLine[len] = 0 ; 

	iCurrentObeyStatement[len] = 0 ;

	TUint i = 0;

	char* linestr = iLine;

	while (i < KNumWords && *linestr != 0) {	 

		switch (state)

		{

		case EInGap:

			if (*linestr =='\"') {

				if (linestr[1] != 0 && linestr[1]!='\"')

					iWord[i++] = linestr + 1;

				state = EInQuotedWord;

			}

			else if (!IsGap(*linestr)) {

				iWord[i++] = linestr;

				state=EInWord;

			}

			else

				*linestr=0;

			break;

		case EInWord:

			if (*linestr == '\"') {

				*linestr = 0;

				if (linestr[1] != 0 && linestr[1] != '\"')

					iWord[i++] = linestr+1;

				state=EInQuotedWord;

			}

			else if (IsGap(*linestr)) {

				*linestr=0;

				state=EInGap;

			}

			break;

		case EInQuotedWord:

			if (*linestr == '\"'){

				*linestr = 0;

				state = EInGap;

			}

			break;

		}

		linestr++;

	}

	return i;

}

//

// Process the timestamp

//

void ObeyFileReader::ProcessTime(TInt64& aTime) {

	char timebuf[256];

	if (iNumWords>2)

		sprintf(timebuf, "%s_%s", iWord[1], iWord[2]);

	else

		strncpy(timebuf, iWord[1],256);

	TInt r = StringToTime(aTime, timebuf);

	if (r==KErrGeneral) {

		Print(EError, "incorrect format for time keyword on line %d\n", iCurrentLine);

		exit(0x670);

	}

	if (r==KErrArgument){

		Print(EError, "Time out of range on line %d\n", iCurrentLine);

		exit(0x670);

	}

}

TInt64 ObeyFileReader::iTimeNow = 0;

void ObeyFileReader::TimeNow(TInt64& aTime) {

	if (iTimeNow==0) {

		TInt sysTime = time(0);					// seconds since midnight Jan 1st, 1970

		sysTime -= (30*365*24*60*60+7*24*60*60);	// seconds since midnight Jan 1st, 2000

		TInt64 daysTo2000AD=730497;

		TInt64 t=daysTo2000AD*24*3600+sysTime;	// seconds since 0000

		t = t+3600;								// BST (?)

		iTimeNow=t*1000000;						// milliseconds

	}

	aTime=iTimeNow;

}

// File attributes.

const FileAttributeKeyword ObeyFileReader::iAttributeKeywords[] =

{

	{"attrib",3			,0,1,EAttributeAtt, "File attributes in ROM file system"},

	{"exattrib",3		,0,1,EAttributeAttExtra, "File extra attributes in ROM file system"}, 

	{"stack",3			,1,1,EAttributeStack, "?"},

	{"fixed",3			,1,0,EAttributeFixed, "Relocate to a fixed address space"},

	{"priority",3		,1,1,EAttributePriority, "Override process priority"},

	{_K("uid1")			,1,1,EAttributeUid1, "Override first UID"},

	{_K("uid2")			,1,1,EAttributeUid2, "Override second UID"},

	{_K("uid3")			,1,1,EAttributeUid3, "Override third UID"},

	{_K("heapmin")		,1,1,EAttributeHeapMin, "Override initial heap size"},

	{_K("heapmax")		,1,1,EAttributeHeapMax, "Override maximum heap size"},

	{_K("capability")	,1,1,EAttributeCapability, "Override capabilities"},

	{_K("unpaged")		,1,0,EAttributeUnpaged, "Don't page code or data for this file"},

	{_K("paged")		,1,0,EAttributePaged, "Page code and data for this file"},

	{_K("unpagedcode")	,1,0,EAttributeUnpagedCode, "Don't page code for this file"},

	{_K("pagedcode")	,1,0,EAttributePagedCode, "Page code for this file"},

	{_K("unpageddata")	,1,0,EAttributeUnpagedData, "Don't page data for this file"},

	{_K("pageddata")	,1,0,EAttributePagedData, "Page data for this file"},

	{0,0,0,0,EAttributeAtt,0}

};

TInt ObeyFileReader::NextAttribute(TInt& aIndex, TInt aHasFile, enum EFileAttribute& aKeyword, char*& aArg)

{

NextAttribute:

	if (aIndex >= iNumWords)

		return KErrEof;

	char* word=iWord[aIndex++];

	const FileAttributeKeyword* k;

	for (k=iAttributeKeywords; k->iKeyword!=0; k++)

	{

		if (k->iKeywordLength == 0)

		{

			// Exact match on keyword

			if (stricmp(word, k->iKeyword) != 0)

				continue;

		}

		else

		{

			// Prefix match

			if (strnicmp(word, k->iKeyword, k->iKeywordLength) != 0)

				continue;

		}

		// found a match

		if (k->iNumArgs>0)

		{

			TInt argIndex = aIndex;

			aIndex += k->iNumArgs;		// interface only really supports 1 argument

			if (aIndex>iNumWords)

			{

				Print(EError, "Missing argument for attribute %s on line %d\n", word, iCurrentLine);

				return KErrArgument;

			}

			aArg=iWord[argIndex];

		}

		if (k->iIsFileAttribute && !aHasFile)

		{

			Print(EError, "File attribute %s applied to non-file on line %d\n", word, iCurrentLine);

			return KErrNotSupported;

		}

		aKeyword=k->iAttributeEnum;

		return KErrNone;

	}

	Print(EWarning, "Unknown attribute '%s' skipped on line %d\n", word, iCurrentLine);

	goto NextAttribute;