1 /*

     2 * Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 * @internalComponent * @released

    16 * Rofsbuild Obey file class and its reader class.

    17 *

    18 */

    19 

    20 

    21 #include <string.h>

    22 

    23 #ifdef __VC32__

    24  #ifdef __MSVCDOTNET__

    25   #include <strstream>

    26   #include <iomanip>

    27  #else //__MSVCDOTNET__

    28   #include <strstrea.h>

    29   #include <iomanip.h>

    30  #endif  //__MSVCDOTNET__

    31 #else // !__VC32__

    32 #ifdef __TOOLS2__

    33 	#include <sstream>

    34 	#include <iomanip>

    35 	#include <sys/stat.h>

    36 	using namespace std;

    37 #else

    38 	#include <strstrea.h>

    39 	#include <iomanip.h>

    40 #endif

    41  

    42 #endif //__VC32__

    43 

    44 

    45 #include <stdlib.h>

    46 #include <stdio.h>

    47 #include <time.h>

    48 #include <assert.h>

    49 #include <errno.h>

    50 

    51 #include <e32std.h>

    52 #include <e32std_private.h>

    53 #include <e32rom.h>

    54 #include <u32std.h>

    55 #include <f32file.h>

    56 

    57 #include "h_utl.h"

    58 #include "r_obey.h"

    59 #include "r_coreimage.h"

    60 #include "patchdataprocessor.h"

    61 #include "filesysteminterface.h" 

    62 #include "r_driveimage.h"

    63 

    64 extern TInt gCodePagingOverride;

    65 extern TInt gDataPagingOverride;

    66 extern ECompression gCompress;

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

    68 

    69 

    70 

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

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

    73 

    74 const ObeyFileKeyword ObeyFileReader::iKeywords[] =

    75 {

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

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

    78 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   115 };

   116 

   117 extern TInt isNumber(TText *aString);

   118 extern TInt getNumber(TText *aStr);

   119 

   120 void ObeyFileReader::KeywordHelp() // static

   121 	{

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

   123 

   124 	const ObeyFileKeyword* k=0;

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

   126 		{

   127 		if (k->iHelpText==0)

   128 			continue;

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

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

   131 

   132 		char buf[32];

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

   134 		if (k->iKeywordLength)

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

   136 		if (H.iVerbose)

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

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

   139 		}

   140 	cout << endl;

   141 

   142 	cout << "File attributes:\n";

   143 

   144 	const FileAttributeKeyword* f=0;

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

   146 		{

   147 		if (f->iHelpText==0)

   148 			continue;

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

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

   151 

   152 		char buf[32];

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

   154 		if (H.iVerbose)

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

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

   157 		}

   158 	cout << endl;

   159 	}

   160 

   161 ObeyFileReader::ObeyFileReader(TText* aFileName):

   162 iObeyFile(0),iMark(0), iMarkLine(0), iCurrentMark(0), iCurrentLine(0), imaxLength(0)

   163 	{

   164 

   165 	iFileName = new TText[strlen((const char *)aFileName)+1];

   166 	strcpy((char *)iFileName,(const char *)aFileName);

   167 	iNumWords = 0 ;

   168 	for(unsigned int i = 0 ; i < KNumWords ; i++)

   169 		iWord[i] = 0 ;

   170 	iSuffix = new TText();

   171 	iLine = 0 ;

   172 	iCurrentObeyStatement = 0 ;

   173 	 }

   174 

   175 

   176 ObeyFileReader::~ObeyFileReader()

   177 	{

   178 	if (iObeyFile)

   179 		fclose(iObeyFile);

   180 	iObeyFile=0;

   181 	delete [] iFileName;

   182 	delete [] iLine;

   183 	delete [] iCurrentObeyStatement;

   184 	}

   185 

   186 TBool ObeyFileReader::Open()

   187 //

   188 // Open the file & return a status

   189 //

   190 {

   191     if (!iFileName)

   192     {

   193         return EFalse;

   194     }

   195 

   196     iObeyFile = fopen((const char *)iFileName,"r");

   197     if (!iObeyFile)

   198     {

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

   200         return EFalse;

   201     }

   202     if (SetLineLengthBuffer() != KErrNone)

   203     {

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

   205         return EFalse;

   206     }

   207     return ETrue;

   208 }

   209    

   210  TInt ObeyFileReader::SetLineLengthBuffer()

   211  // Get the Max Line length for the given obey file and allocate the buffer.

   212  	{

   213 	char ch = '\0';

   214  	TInt length = 0;

   215 		

   216 	Rewind();

   217  	while ((ch = (char)fgetc(iObeyFile)) != EOF)

   218  		{

   219  		length++;

   220 		if (ch == '\n')

   221 			{

   222  			if (length > imaxLength)

   223  				imaxLength = length;

   224  			length = 0;				

   225  			}

   226  		}

   227 	

   228 	if (length > imaxLength)

   229  		imaxLength = length;

   230 		

   231 	if (0 == imaxLength)

   232 		{

   233 		Print(EError,"Empty obey file passed as input.");

   234 		exit(-1);

   235 		}			

   236 	else if (imaxLength < 2)

   237 		{

   238 		Print(EError,"Invalid obey file passed as input.");

   239 		exit(-1);

   240 		}

   241 		

   242 	Rewind();

   243  	iLine = new TText[imaxLength+1];

   244  	

   245  	if(!iLine)

   246  		return KErrNoMemory;

   247  

   248  	return KErrNone;

   249  	}

   250 

   251 void ObeyFileReader::Mark()

   252 	{

   253 

   254 	iMark = iCurrentMark;

   255 	iMarkLine = iCurrentLine-1;

   256 	}

   257 

   258 void ObeyFileReader::MarkNext()

   259 	{

   260 

   261 	iMark = ftell(iObeyFile);

   262 	iMarkLine = iCurrentLine;

   263 	}

   264 

   265 void ObeyFileReader::Rewind()

   266 	{

   267 	

   268 	fseek(iObeyFile,iMark,SEEK_SET);

   269 	iCurrentMark = iMark;

   270 	iCurrentLine = iMarkLine;

   271 	}

   272 

   273 void ObeyFileReader::CopyWord(TInt aIndex, TText*& aString)

   274 	{

   275 	aString = new TText[strlen((const char *)iWord[aIndex])+1];

   276 	strcpy((char *)aString, (const char *)iWord[aIndex]);

   277 	}

   278 

   279 TInt ObeyFileReader::ReadAndParseLine()

   280 	{

   281 	if (feof(iObeyFile))

   282 		return KErrEof;

   283 	iCurrentLine++;

   284 	iCurrentMark = ftell(iObeyFile);

   285 	iLine[0]='\0';

   286 	char *cp = fgets((char*)iLine,imaxLength+1,iObeyFile); (void)cp;

   287 	iCurrentObeyStatement = new TText[imaxLength+1];

   288 	strcpy((char*)iCurrentObeyStatement,(char*)iLine);

   289 	iNumWords = Parse();

   290 	return KErrNone;

   291 	}

   292 

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

   294 	{

   295 

   296 NextLine:

   297 	TInt err = ReadAndParseLine();

   298 	if (err == KErrEof)

   299 		return KErrEof;

   300 	if (iNumWords == 0 || stricmp((const char*)iWord[0], "rem")==0)

   301 		goto NextLine;

   302 	if (stricmp((const char*)iWord[0], "stop")==0)

   303 		return KErrEof;

   304 

   305 	const ObeyFileKeyword* k=0;

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

   307 		{

   308 		if (k->iKeywordLength == 0)

   309 			{

   310 			// Exact case-insensitive match on keyword

   311 			if (stricmp((const char*)iWord[0], k->iKeyword) != 0)

   312 				continue;

   313 			iSuffix = 0;

   314 			}

   315 		else

   316 			{

   317 			// Prefix match

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

   319 				continue;

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

   321 			iSuffix = iWord[0]+k->iKeywordLength;

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

   323 				continue;

   324 			}

   325 		// found a match

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

   327 			goto NextLine;

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

   329 			{

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

   331 				iWord[0], iCurrentLine);

   332 			goto NextLine;

   333 			}

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

   335 			{

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

   337 				iWord[0], iCurrentLine);

   338 			goto NextLine;

   339 			}

   340 		

   341 		aKeyword = k->iKeywordEnum;

   342 		return KErrNone;

   343 		}

   344 	if (aPass == 1)

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

   346 	goto NextLine;

   347 	}

   348 

   349 inline TBool ObeyFileReader::IsGap(char ch)

   350 	{

   351 	return (ch==' ' || ch=='=' || ch=='\t');

   352 	}

   353 

   354 TInt ObeyFileReader::Parse()

   355 //

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

   357 //

   358 	{

   359 

   360 	TInt i;

   361 	TText *letter=iLine;

   362 	TText *end=iLine+strlen((char *)iLine);

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

   364 		iWord[i]=end;

   365 

   366 	enum TState {EInWord, EInQuotedWord, EInGap};

   367 	TState state=EInGap;

   368 

   369 	i=0;

   370 	while ((TUint)i<KNumWords && letter<end)

   371 		{

   372 		char ch=*letter;

   373 		if (ch==0)

   374 			break;

   375 		if (ch=='\n')

   376 			{

   377 			*letter='\0';	// remove trailing newline left by fgets

   378 			break;

   379 			}

   380 		switch (state)

   381 			{

   382 		case EInGap:

   383 			if (ch=='\"')

   384 				{

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

   386 					iWord[i++]=letter+1;

   387 				state=EInQuotedWord;

   388 				}

   389 			else if (!IsGap(ch))

   390 				{

   391 				iWord[i++]=letter;

   392 				state=EInWord;

   393 				}

   394 			else

   395 				*letter=0;

   396 			break;

   397 		case EInWord:

   398 			if (ch=='\"')

   399 				{

   400 				*letter=0;

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

   402 					iWord[i++]=letter+1;

   403 				state=EInQuotedWord;

   404 				}

   405 			else if (IsGap(ch))

   406 				{

   407 				*letter=0;

   408 				state=EInGap;

   409 				}

   410 			break;

   411 		case EInQuotedWord:

   412 			if (ch=='\"')

   413 				{

   414 				*letter=0;

   415 				state=EInGap;

   416 				}

   417 			break;

   418 			}

   419 		letter++;

   420 		}

   421 	return i;

   422 	}

   423 

   424 

   425 void ObeyFileReader::ProcessTime(TInt64& aTime)

   426 //

   427 // Process the timestamp

   428 //

   429 	{

   430 	char timebuf[256];

   431 	if (iNumWords>2)

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

   433 	else

   434 		strcpy(timebuf, (char*)iWord[1]);

   435 

   436 	TInt r=StringToTime(aTime, timebuf);

   437 	if (r==KErrGeneral)

   438 		{

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

   440 		exit(0x670);

   441 		}

   442 	if (r==KErrArgument)

   443 		{

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

   445 		exit(0x670);

   446 		}

   447 	}

   448 

   449 TInt64 ObeyFileReader::iTimeNow=0;

   450 void ObeyFileReader::TimeNow(TInt64& aTime)

   451 	{

   452 	if (iTimeNow==0)

   453 		{

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

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

   456 		TInt64 daysTo2000AD=730497;

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

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

   459 		iTimeNow=t*1000000;						// milliseconds

   460 		}

   461 	aTime=iTimeNow;

   462 	}

   463 

   464 /**

   465 Funtion to get the current oby file line

   466 */

   467 TText* ObeyFileReader::GetCurrentObeyStatement() const

   468 { 

   469 	return iCurrentObeyStatement;

   470 }

   471 

   472 // File attributes.

   473 

   474 

   475 const FileAttributeKeyword ObeyFileReader::iAttributeKeywords[] =

   476 {

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

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

   479 //	{_K("compress")		,1,1,EAttributeCompress, "Compress file"},

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   496 };

   497 

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

   499 	{

   500 NextAttribute:

   501 	if (aIndex >= iNumWords)

   502 		return KErrEof;

   503 	TText* word=iWord[aIndex++];

   504 	const FileAttributeKeyword* k;

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

   506 		{

   507 		if (k->iKeywordLength == 0)

   508 			{

   509 			// Exact match on keyword

   510 			if (stricmp((const char*)word, k->iKeyword) != 0)

   511 				continue;

   512 			}

   513 		else

   514 			{

   515 			// Prefix match

   516 			if (strnicmp((const char*)word, k->iKeyword, k->iKeywordLength) != 0)

   517 				continue;

   518 			}

   519 		// found a match

   520 		if (k->iNumArgs>0)

   521 			{

   522 			TInt argIndex = aIndex;

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

   524 			if (aIndex>iNumWords)

   525 				{

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

   527 				return KErrArgument;

   528 				}

   529 			aArg=iWord[argIndex];

   530 			}

   531 		if (k->iIsFileAttribute && !aHasFile)

   532 			{

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

   534 			return KErrNotSupported;

   535 			}

   536 		aKeyword=k->iAttributeEnum;

   537 		return KErrNone;

   538 		}

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

   540 	goto NextAttribute;

   541 	}

   542 

   543 

   544 

   545 /**

   546 Constructor:

   547 1.Obey file instance.

   548 2.used by both rofs and datadrive image.

   549 

   550 @param aReader - obey file reader object.

   551 */

   552 CObeyFile::CObeyFile(ObeyFileReader& aReader):

   553 	iRomFileName(NULL),

   554 	iExtensionRofsName(0),

   555 	iKernelRofsName(0),

   556 	iRomSize(0),

   557 	iVersion(0,0,0),

   558 	iCheckSum(0),

   559 	iNumberOfFiles(0),

   560 	iTime(0),

   561 	iRootDirectory(0),

   562 	iNumberOfDataFiles(0),

   563 	iDriveFileName(0),

   564 	iDataSize(0),

   565 	iDriveFileFormat(0),

   566 	iConfigurableFatAttributes(new ConfigurableFatAttributes),

   567 	iReader(aReader), 

   568 	iMissingFiles(0), 

   569 	iLastExecutable(0),

   570 	iFirstFile(0), 	

   571 	iCurrentFile(0),

   572 	iAutoSize(EFalse),

   573 	iAutoPageSize(4096),

   574 	iPagingOverrideParsed(0),

   575 	iCodePagingOverrideParsed(0),

   576 	iDataPagingOverrideParsed(0),

   577 	iPatchData(new CPatchDataProcessor)

   578 	{

   579 		iNextFilePtrPtr = &iFirstFile ;

   580 	}

   581 

   582 /**

   583 Obey file Destructor.

   584 1.Release the tree memory.

   585 2.Release all allocated memory if any.

   586 */

   587 CObeyFile::~CObeyFile()

   588 //

   589 // Destructor

   590 //

   591 	{

   592 	if(iDriveFileName)

   593 		delete[] iDriveFileName;					

   594 	if(iDriveFileFormat)

   595 		delete[] iDriveFileFormat;

   596 	iRootDirectory->deleteTheFirstNode();                

   597 	iRootDirectory->InitializeCount();

   598 

   599 	Release();

   600 	delete [] iRomFileName;

   601 	if (iRootDirectory)

   602 		iRootDirectory->Destroy();

   603 

   604 	delete iConfigurableFatAttributes;

   605 	delete iPatchData;

   606 	}

   607 

   608 TBool CObeyFile::AutoSize()

   609 {

   610 	return iAutoSize;

   611 }

   612 

   613 TUint32 CObeyFile::AutoPageSize()

   614 {

   615 	return iAutoPageSize;

   616 }

   617 

   618 void CObeyFile::Release()

   619 //

   620 // Free resources not needed after building a ROM

   621 //

   622 	{

   623 	iFirstFile = 0;

   624 	iNextFilePtrPtr = &iFirstFile;

   625 	}

   626 

   627 TRomBuilderEntry *CObeyFile::FirstFile()

   628 	{

   629 	iCurrentFile = iFirstFile;

   630 	return iCurrentFile;

   631 	}

   632 

   633 TRomBuilderEntry *CObeyFile::NextFile()

   634 	{

   635 	iCurrentFile = iCurrentFile ? iCurrentFile->iNext : 0;

   636 	return iCurrentFile;

   637 	}

   638 

   639 TText* CObeyFile::ProcessCoreImage()

   640 	{

   641 	// check for coreimage keyword and return filename

   642 	iReader.Rewind();

   643 	enum EKeyword keyword;

   644 	TText* coreImageFileName = 0;

   645 	while (iReader.NextLine(1,keyword) != KErrEof)

   646 		{

   647 		if (keyword == EKeywordCoreImage)

   648 			{

   649 			istringstream val(iReader.Word(1),ios_base::in|ios_base::out);	  

   650 			iReader.CopyWord(1, coreImageFileName);

   651 			iReader.MarkNext(); // ready for processing extension

   652 			break;

   653 			}

   654 		}

   655 		return coreImageFileName;

   656 	}

   657 

   658 void CObeyFile::SkipToExtension()

   659 	{

   660 	iReader.Rewind();

   661 	enum EKeyword keyword;

   662 	while (iReader.NextLine(1,keyword) != KErrEof)

   663 		{

   664 		  if (keyword == EKeywordExtensionRofs)

   665 			  {

   666 			  iReader.Mark(); // ready for processing extension

   667 			  break;

   668 			  }

   669 		}

   670 	}

   671 TInt CObeyFile::ProcessRofs()

   672 	{

   673 	//

   674 	// First pass through the obey file to set up key variables

   675 	//

   676 

   677 	iReader.Rewind();

   678 

   679 	TInt count=0;

   680 	enum EKeyword keyword;

   681 	while (iReader.NextLine(1,keyword) != KErrEof)

   682 		{

   683 		  if (keyword == EKeywordExtensionRofs)

   684 		    {

   685 		      if (count==0)

   686 			return KErrNotFound;		// no core ROFS, just extension ROFSs.

   687 		      break;

   688 		    }

   689 

   690 		count++;

   691 		if (! ProcessKeyword(keyword))

   692 			return KErrGeneral;

   693 		}

   694 

   695 	if (!GotKeyVariables())

   696 		return KErrGeneral;

   697 

   698 	//

   699 	// second pass to process the file specifications in the obey file building

   700 	// up the TRomNode directory structure and the TRomBuilderEntry list

   701 	//

   702 	iReader.Rewind();

   703 

   704 	iRootDirectory = new TRomNode((TText*)"");

   705 	iLastExecutable = iRootDirectory;

   706 

   707 	TInt align=0;

   708 	while (iReader.NextLine(2,keyword)!=KErrEof)

   709 		{

   710 		if (keyword == EKeywordExtensionRofs)

   711 			break;

   712 

   713 		if (keyword == EKeywordHide)

   714 			keyword = EKeywordHideV2;

   715 

   716 		switch (keyword)

   717 			{

   718 			  

   719 		case EKeywordHide:

   720 		case EKeywordAlias:

   721 		case EKeywordRename:

   722 			if (!ProcessRenaming(keyword))

   723 				return KErrGeneral;

   724 			break;

   725 		case EKeywordPatchDllData:

   726 		{

   727 			// Collect patchdata statements to process at the end

   728 			StringVector patchDataTokens;

   729 			SplitPatchDataStatement(patchDataTokens); 

   730 			iPatchData->AddPatchDataStatement(patchDataTokens);									

   731 			break;

   732 		}

   733 		default:

   734 		        if (!ProcessFile(align, keyword))

   735 		        return KErrGeneral;

   736 		        align=0;

   737 		        break;

   738 			}

   739 		}

   740 

   741 	if(!ParsePatchDllData())

   742 		return KErrGeneral;

   743 	iReader.Mark();			// ready for processing the extension rom(s)

   744 

   745 	if (iMissingFiles!=0)

   746 		{

   747 		return KErrGeneral;

   748 		}

   749 	if ( 0 == iNumberOfFiles )

   750 		{

   751 		Print(EError, "No files specified.\n");

   752 		return KErrGeneral;

   753 		}

   754 

   755 	return KErrNone;

   756 	}

   757 

   758 TBool CObeyFile::Process()

   759 {

   760 	TBool result = ETrue;

   761 	iReader.Rewind();

   762 	enum EKeyword keyword;

   763 	while(iReader.NextLine(1, keyword) != KErrEof)

   764 	{

   765 		String key = iReader.Word(0);

   766 		String value = iReader.Word(1);

   767 		if(iKeyValues.find(key) != iKeyValues.end())

   768 		{

   769 			iKeyValues[key].push_back(value);

   770 		}

   771 		else

   772 		{

   773 			StringVector values;

   774 			values.push_back(value);

   775 			iKeyValues[key]=values;

   776 		}

   777 

   778 

   779 	}

   780 	return result;

   781 }

   782 StringVector CObeyFile::getValues(const String& aKey)

   783 {

   784 	StringVector values;

   785 	if(iKeyValues.find(aKey) != iKeyValues.end())

   786 	{

   787 		values = iKeyValues[aKey];

   788 	}

   789 	return values;

   790 }

   791 

   792 /**

   793 Process drive obey file and construct the tree.

   794 

   795 @return - Return the status,

   796           'KErrnone' for Success,

   797           'KErrGeneral' for failure (required keywords not there in obey file or failed

   798 									 to construct the tree).

   799 */

   800 TInt CObeyFile::ProcessDataDrive()

   801 	{

   802 

   803 	iReader.Rewind();

   804 	enum EKeyword keyword;

   805 

   806 	// First pass through the obey file to set up key variables

   807 	while (iReader.NextLine(1,keyword) != KErrEof)	

   808 		{

   809 		if (!ProcessDriveKeyword(keyword))			

   810 			return KErrGeneral;

   811 		}

   812 

   813 	if (!GotKeyDriveVariables())

   814 		return KErrGeneral;

   815 

   816 	// Second pass to process the file specifications in the obey file.

   817 	// Build the TRomNode directory structure and the TRomBuilderEntry list

   818 	iReader.Rewind();

   819 	iRootDirectory = new TRomNode((TText*)"//");					

   820 	iLastExecutable = iRootDirectory;

   821 

   822 	while(iReader.NextLine(2,keyword)!=KErrEof)

   823 		{

   824 		switch (keyword)

   825 			{

   826 			case EKeywordPatchDllData:

   827 			{	// Collect patchdata statements to process at the end

   828 				StringVector patchDataTokens;

   829 				SplitPatchDataStatement(patchDataTokens); 				

   830 				iPatchData->AddPatchDataStatement(patchDataTokens);									

   831 				break;

   832 			}

   833 	

   834 			case EKeywordHide:						

   835 			case EKeywordFile:

   836 			case EKeywordData:

   837 			case EKeywordFileCompress:

   838 			case EKeywordFileUncompress:

   839 		        if (!ProcessDriveFile(keyword))

   840 				  return KErrGeneral;

   841 		        break;

   842 	

   843 			default:							

   844 		        break;

   845 			}

   846 		}

   847 

   848 	if(!ParsePatchDllData())

   849 		return KErrGeneral;

   850     if (iMissingFiles)   

   851 		{

   852 		Print(EError, "Source Files Missing.\n");

   853 		return KErrGeneral;

   854 		}

   855 	if (!iNumberOfFiles)

   856 		Print(EWarning,"No files specified.\n");

   857 	

   858 	return KErrNone;

   859 	}

   860 

   861 

   862 /**

   863 Process and stores the keyword information.

   864 

   865 @param aKeyword - keyword to update its value to variables.

   866 @return - Return the status i.e Success,

   867 */

   868 TBool CObeyFile::ProcessDriveKeyword(enum EKeyword aKeyword)

   869 	{

   870 

   871 	TBool success = ETrue;

   872 	switch (aKeyword)

   873 		{

   874 		case EKeywordDataImageName:

   875 			iReader.CopyWord(1, iDriveFileName);

   876 			break;

   877 		case EKeywordDataImageFileSystem:

   878 			iReader.CopyWord(1, iDriveFileFormat);

   879 			break;

   880 		case EKeywordDataImageSize:

   881 			{

   882 			char* bigString = iReader.Word(1);

   883 			if(*bigString == '\0')

   884 				{

   885 				Print(EWarning,"Not a valid Image Size. Default size is considered\n");		

   886 				break;

   887 				}

   888 #ifdef __LINUX__

   889 			errno = 0;

   890 			iDataSize = strtoll(bigString,NULL,10);

   891 			if((iDataSize == LONG_MAX) || (iDataSize == LONG_MIN) ||(errno == ERANGE))

   892 				{

   893 				Print(EWarning,"Invalid Range. Default size is considered\n");		

   894 				}

   895 #else

   896 			iDataSize = _atoi64(bigString);

   897 #endif

   898 			}

   899 			break;

   900 		case EKeywordDataImageVolume:

   901 			{				

   902 				// Get the volume label provided by using "volume" keyword.

   903 				// e.g. vlolume = NO NAME

   904 				String volumeLabel = (char*)iReader.GetCurrentObeyStatement();

   905 				String volumeLabelKeyword = "volume";

   906 

   907 				TUint position = volumeLabel.find(volumeLabelKeyword.c_str(),0,volumeLabelKeyword.size());

   908 				position += volumeLabelKeyword.size();

   909 				if (volumeLabel.find('=',position) != std::string::npos)

   910 				{

   911 					position=volumeLabel.find('=',position);

   912 					++position;

   913 				}								

   914 

   915 				position = volumeLabel.find_first_not_of(' ',position);

   916 				if (position != std::string::npos)

   917 				{

   918 					volumeLabel = volumeLabel.substr(position);

   919 

   920 					// Remove the new line character from the end

   921 					position = volumeLabel.find_first_of("\r\n");

   922 					if (position != std::string::npos)

   923 						volumeLabel = volumeLabel.substr(0,position);

   924 

   925 					iConfigurableFatAttributes->iDriveVolumeLabel = volumeLabel.data(); 								

   926 				}

   927 				else

   928 				{

   929 					Print(EWarning,"Value for Volume Label is not provided. Default value is considered.\n");

   930 				}

   931 				break;

   932 			}

   933 		case EKeywordDataImageSectorSize:

   934 			{

   935 				char* bigString = iReader.Word(1);

   936 				TInt sectorSize = atoi(bigString);

   937 				if(sectorSize <= 0)

   938 				{

   939 					Print(EWarning,"Invalid Sector Size value. Default value is considered.\n");

   940 				}

   941 				else

   942 				{

   943 					iConfigurableFatAttributes->iDriveSectorSize = atoi(bigString);

   944 				}

   945 			}			

   946 			break;

   947 		case EKeywordDataImageNoOfFats:

   948 			{

   949 				char* bigString = iReader.Word(1);

   950 				TInt noOfFats = atoi(bigString);

   951 				if (noOfFats <=0)

   952 				{

   953 					Print(EWarning,"Invalid No of FATs specified. Default value is considered.\n");

   954 				}

   955 				else

   956 				{

   957 					iConfigurableFatAttributes->iDriveNoOfFATs = atoi(bigString);			

   958 				}

   959 			}			

   960 			break;			

   961 		default:

   962 			// unexpected keyword iReader.Word(0), keep going.

   963 			break;

   964 		}

   965 	return success;

   966 	}

   967 

   968 

   969 /**

   970 Checks whether obeyfile has supplied enough variables to continue.

   971 

   972 @return - Return the status 

   973 		  ETrue - Supplied valid values,

   974 		  EFalse- Not valied values.

   975 */

   976 TBool CObeyFile::GotKeyDriveVariables()

   977    	{

   978 

   979 	TBool retVal=ETrue;

   980 

   981 	// Mandatory keywords

   982 	if (iDriveFileName==0)                             

   983 		{                                                  

   984 		Print(EError,"The name of the image file has not been supplied.\n");

   985 		Print(EError,"Use the keyword \"dataimagename\".\n");

   986 		retVal = EFalse;

   987 		}

   988 		

   989 	// Check for '-'ve entered value.

   990 	if(iDataSize <= 0)

   991 		{

   992 		Print(EWarning,"Image Size should be positive. Default size is Considered.\n");

   993 		}

   994 

   995 	// File system format.

   996 	if(iDriveFileFormat==0)

   997 		{

   998 		Print(EError,"The name of the file system not been supplied.\n");

   999 		Print(EError,"Use the keyword \"dataimagefilesystem\".\n");

  1000 		retVal = EFalse;

  1001 		}

  1002 

  1003 	// Checking the validity of file system format.

  1004 	if(iDriveFileFormat)

  1005 		{

  1006 		strupr((char *)iDriveFileFormat);

  1007 		enum TFileSystem check = (TFileSystem)0;

  1008 		if(!(CDriveImage::FormatTranslation(iDriveFileFormat,check)))

  1009 			{

  1010 			Print(EError,"The name of the file system not supported : %s\n",iDriveFileFormat);

  1011 			retVal = EFalse;

  1012 			}

  1013 		}

  1014 	

  1015 	if(retVal)

  1016 		Print(ELog,"\nCreating Data Drive image : %s\n", iDriveFileName);

  1017 

  1018   	return retVal;

  1019 	}

  1020 

  1021 /**

  1022 Process a parsed line to set up one or more new TRomBuilder entry objects.

  1023 

  1024 @param  - obey file keyword.

  1025 // iWord[0] = the keyword (file,)      

  1026 // iWord[1] = the PC pathname

  1027 // iWord[2] = the EPOC pathname

  1028 // iWord[3] = start of the file attributes

  1029 

  1030 @return - Return the status 

  1031 		  ETrue - Successful generation of tree.

  1032 		  EFalse- Fail to generate the tree.

  1033 */

  1034 TBool CObeyFile::ProcessDriveFile(enum EKeyword aKeyword)               

  1035 	{

  1036 

  1037 	TBool isPeFile = ETrue;

  1038 	TBool aFileCompressOption, aFileUncompressOption;

  1039 

  1040 	TInt epocPathStart=2;

  1041 	aFileCompressOption = aFileUncompressOption = EFalse;

  1042 	// do some validation of the keyword

  1043 	TInt currentLine = iReader.CurrentLine();

  1044 

  1045 	switch (aKeyword)

  1046 		{

  1047 		case EKeywordData:

  1048 		case EKeywordHide:

  1049 			isPeFile = EFalse;

  1050 			break;

  1051 

  1052 		case EKeywordFile:

  1053 			break;

  1054 

  1055 		case EKeywordFileCompress:

  1056 			aFileCompressOption = ETrue;

  1057 			break;

  1058 

  1059 		case EKeywordFileUncompress:

  1060 			aFileUncompressOption = ETrue;

  1061 			break;

  1062 

  1063 		default:

  1064 			return EFalse;

  1065 		}

  1066 

  1067 	if (aKeyword!=EKeywordHide)

  1068 		{

  1069 		// check the PC file exists

  1070 		char* nname = NormaliseFileName(iReader.Word(1));                 

  1071 

  1072 #if defined(__MSVCDOTNET__) || defined(__TOOLS2__)																		  

  1073 		ifstream test(nname);

  1074 #else //!__MSVCDOTNET__

  1075 		ifstream test(nname, ios::nocreate);

  1076 #endif //__MSVCDOTNET__

  1077 

  1078 		if (!test)

  1079 			{

  1080 			Print(EError,"Cannot open file %s for input.\n",iReader.Word(1));

  1081 			iMissingFiles++;

  1082 			}

  1083 

  1084 		test.close();

  1085 		if(nname)

  1086 			free(nname);												

  1087 		nname = 0;

  1088 		}

  1089 	else

  1090 		epocPathStart=1;   

  1091 

  1092 	iNumberOfFiles++;

  1093 

  1094 	TBool endOfName=EFalse;

  1095 	TText *epocStartPtr=IsValidFilePath(iReader.Text(epocPathStart));

  1096 	TText *epocEndPtr=epocStartPtr;

  1097 

  1098 	if (epocStartPtr==NULL)

  1099 		{

  1100 		Print(EError, "Invalid destination path on line %d\n",currentLine);

  1101 		return EFalse;

  1102 		}

  1103 

  1104 	TRomNode* dir=iRootDirectory;

  1105 	TRomNode* subDir=0;

  1106 	TRomBuilderEntry *file=0;      

  1107 

  1108 	while (!endOfName)

  1109 		{

  1110 		endOfName = GetNextBitOfFileName(&epocEndPtr);      

  1111 		if (endOfName) // file

  1112 			{

  1113 			TRomNode* alreadyExists=dir->FindInDirectory(epocStartPtr);

  1114 

  1115 			if ((aKeyword != EKeywordHide) && alreadyExists) // duplicate file

  1116 				{

  1117 				Print(EError, "Duplicate file for %s on line %d\n",iReader.Word(1),iReader.CurrentLine());

  1118 				return EFalse;

  1119 				}

  1120 			else if((aKeyword == EKeywordHide) && (alreadyExists))

  1121 				{ 

  1122 				alreadyExists->iEntry->iHidden = ETrue;

  1123 				alreadyExists->iHidden = ETrue;

  1124 				return ETrue;

  1125 				}

  1126 			else if((aKeyword == EKeywordHide) && (!alreadyExists))

  1127 				{

  1128 				Print(EWarning, "Hiding non-existent file %s on line %d\n",iReader.Word(1),iReader.CurrentLine());

  1129 				return ETrue;

  1130 				}

  1131 				

  1132 			file = new TRomBuilderEntry(iReader.Word(1), epocStartPtr);                   

  1133 			file->iExecutable=isPeFile;

  1134 			if( aFileCompressOption )