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 	fgets((char*)iLine,imaxLength+1,iObeyFile);

   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   			  #if defined(__TOOLS2__) && defined (_STLP_THREADS)

   650   			  istringstream val(iReader.Word(1),(ios_base::in+ios_base::out));	  

   651   			  #elif __TOOLS2__

   652   			  istringstream val(iReader.Word(1),(std::_Ios_Openmode)(ios_base::in+ios_base::out));

   653 			  #else

   654 			  istrstream val(iReader.Word(1),strlen(iReader.Word(1)));

   655 			  #endif

   656 			  iReader.CopyWord(1, coreImageFileName);

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

   658 			  break;

   659 			  }

   660 		}

   661 	return coreImageFileName;

   662 	}

   663 

   664 void CObeyFile::SkipToExtension()

   665 	{

   666 	iReader.Rewind();

   667 	enum EKeyword keyword;

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

   669 		{

   670 		  if (keyword == EKeywordExtensionRofs)

   671 			  {

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

   673 			  break;

   674 			  }

   675 		}

   676 	}

   677 TInt CObeyFile::ProcessRofs()

   678 	{

   679 	//

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

   681 	//

   682 

   683 	iReader.Rewind();

   684 

   685 	TInt count=0;

   686 	enum EKeyword keyword;

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

   688 		{

   689 		  if (keyword == EKeywordExtensionRofs)

   690 		    {

   691 		      if (count==0)

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

   693 		      break;

   694 		    }

   695 

   696 		count++;

   697 		if (! ProcessKeyword(keyword))

   698 			return KErrGeneral;

   699 		}

   700 

   701 	if (!GotKeyVariables())

   702 		return KErrGeneral;

   703 

   704 	//

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

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

   707 	//

   708 	iReader.Rewind();

   709 

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

   711 	iLastExecutable = iRootDirectory;

   712 

   713 	TInt align=0;

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

   715 		{

   716 		if (keyword == EKeywordExtensionRofs)

   717 			break;

   718 

   719 		if (keyword == EKeywordHide)

   720 			keyword = EKeywordHideV2;

   721 

   722 		switch (keyword)

   723 			{

   724 			  

   725 		case EKeywordHide:

   726 		case EKeywordAlias:

   727 		case EKeywordRename:

   728 			if (!ProcessRenaming(keyword))

   729 				return KErrGeneral;

   730 			break;

   731 		case EKeywordPatchDllData:

   732 		{

   733 			// Collect patchdata statements to process at the end

   734 			StringVector patchDataTokens;

   735 			SplitPatchDataStatement(patchDataTokens); 

   736 			iPatchData->AddPatchDataStatement(patchDataTokens);									

   737 			break;

   738 		}

   739 		default:

   740 		        if (!ProcessFile(align, keyword))

   741 		        return KErrGeneral;

   742 		        align=0;

   743 		        break;

   744 			}

   745 		}

   746 

   747 	if(!ParsePatchDllData())

   748 		return KErrGeneral;

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

   750 

   751 	if (iMissingFiles!=0)

   752 		{

   753 		return KErrGeneral;

   754 		}

   755 	if ( 0 == iNumberOfFiles )

   756 		{

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

   758 		return KErrGeneral;

   759 		}

   760 

   761 	return KErrNone;

   762 	}

   763 

   764 TBool CObeyFile::Process()

   765 {

   766 	TBool result = ETrue;

   767 	iReader.Rewind();

   768 	enum EKeyword keyword;

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

   770 	{

   771 		String key = iReader.Word(0);

   772 		String value = iReader.Word(1);

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

   774 		{

   775 			iKeyValues[key].push_back(value);

   776 		}

   777 		else

   778 		{

   779 			StringVector values;

   780 			values.push_back(value);

   781 			iKeyValues[key]=values;

   782 		}

   783 

   784 

   785 	}

   786 	return result;

   787 }

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

   789 {

   790 	StringVector values;

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

   792 	{

   793 		values = iKeyValues[aKey];

   794 	}

   795 	return values;

   796 }

   797 

   798 /**

   799 Process drive obey file and construct the tree.

   800 

   801 @return - Return the status,

   802           'KErrnone' for Success,

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

   804 									 to construct the tree).

   805 */

   806 TInt CObeyFile::ProcessDataDrive()

   807 	{

   808 

   809 	iReader.Rewind();

   810 	enum EKeyword keyword;

   811 

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

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

   814 		{

   815 		if (!ProcessDriveKeyword(keyword))			

   816 			return KErrGeneral;

   817 		}

   818 

   819 	if (!GotKeyDriveVariables())

   820 		return KErrGeneral;

   821 

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

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

   824 	iReader.Rewind();

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

   826 	iLastExecutable = iRootDirectory;

   827 

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

   829 		{

   830 		switch (keyword)

   831 			{

   832 			case EKeywordPatchDllData:

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

   834 				StringVector patchDataTokens;

   835 				SplitPatchDataStatement(patchDataTokens); 				

   836 				iPatchData->AddPatchDataStatement(patchDataTokens);									

   837 				break;

   838 			}

   839 	

   840 			case EKeywordHide:						

   841 			case EKeywordFile:

   842 			case EKeywordData:

   843 			case EKeywordFileCompress:

   844 			case EKeywordFileUncompress:

   845 		        if (!ProcessDriveFile(keyword))

   846 				  return KErrGeneral;

   847 		        break;

   848 	

   849 			default:							

   850 		        break;

   851 			}

   852 		}

   853 

   854 	if(!ParsePatchDllData())

   855 		return KErrGeneral;

   856     if (iMissingFiles)   

   857 		{

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

   859 		return KErrGeneral;

   860 		}

   861 	if (!iNumberOfFiles)

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

   863 	

   864 	return KErrNone;

   865 	}

   866 

   867 

   868 /**

   869 Process and stores the keyword information.

   870 

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

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

   873 */

   874 TBool CObeyFile::ProcessDriveKeyword(enum EKeyword aKeyword)

   875 	{

   876 

   877 	TBool success = ETrue;

   878 	switch (aKeyword)

   879 		{

   880 		case EKeywordDataImageName:

   881 			iReader.CopyWord(1, iDriveFileName);

   882 			break;

   883 		case EKeywordDataImageFileSystem:

   884 			iReader.CopyWord(1, iDriveFileFormat);

   885 			break;

   886 		case EKeywordDataImageSize:

   887 			{

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

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

   890 				{

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

   892 				break;

   893 				}

   894 #ifdef __LINUX__

   895 			errno = 0;

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

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

   898 				{

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

   900 				}

   901 #else

   902 			iDataSize = _atoi64(bigString);

   903 #endif

   904 			}

   905 			break;

   906 		case EKeywordDataImageVolume:

   907 			{				

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

   909 				// e.g. vlolume = NO NAME

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

   911 				String volumeLabelKeyword = "volume";

   912 

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

   914 				position += volumeLabelKeyword.size();

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

   916 				{

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

   918 					++position;

   919 				}								

   920 

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

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

   923 				{

   924 					volumeLabel = volumeLabel.substr(position);

   925 

   926 					// Remove the new line character from the end

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

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

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

   930 

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

   932 				}

   933 				else

   934 				{

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

   936 				}

   937 				break;

   938 			}

   939 		case EKeywordDataImageSectorSize:

   940 			{

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

   942 				TInt sectorSize = atoi(bigString);

   943 				if(sectorSize <= 0)

   944 				{

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

   946 				}

   947 				else

   948 				{

   949 					iConfigurableFatAttributes->iDriveSectorSize = atoi(bigString);

   950 				}

   951 			}			

   952 			break;

   953 		case EKeywordDataImageNoOfFats:

   954 			{

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

   956 				TInt noOfFats = atoi(bigString);

   957 				if (noOfFats <=0)

   958 				{

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

   960 				}

   961 				else

   962 				{

   963 					iConfigurableFatAttributes->iDriveNoOfFATs = atoi(bigString);			

   964 				}

   965 			}			

   966 			break;			

   967 		default:

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

   969 			break;

   970 		}

   971 	return success;

   972 	}

   973 

   974 

   975 /**

   976 Checks whether obeyfile has supplied enough variables to continue.

   977 

   978 @return - Return the status 

   979 		  ETrue - Supplied valid values,

   980 		  EFalse- Not valied values.

   981 */

   982 TBool CObeyFile::GotKeyDriveVariables()

   983    	{

   984 

   985 	TBool retVal=ETrue;

   986 

   987 	// Mandatory keywords

   988 	if (iDriveFileName==0)                             

   989 		{                                                  

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

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

   992 		retVal = EFalse;

   993 		}

   994 		

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

   996 	if(iDataSize <= 0)

   997 		{

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

   999 		}

  1000 

  1001 	// File system format.

  1002 	if(iDriveFileFormat==0)

  1003 		{

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

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

  1006 		retVal = EFalse;

  1007 		}

  1008 

  1009 	// Checking the validity of file system format.

  1010 	if(iDriveFileFormat)

  1011 		{

  1012 		strupr((char *)iDriveFileFormat);

  1013 		enum TFileSystem check = (TFileSystem)0;

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

  1015 			{

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

  1017 			retVal = EFalse;

  1018 			}

  1019 		}

  1020 	

  1021 	if(retVal)

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

  1023 

  1024   	return retVal;

  1025 	}

  1026 

  1027 /**

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

  1029 

  1030 @param  - obey file keyword.

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

  1032 // iWord[1] = the PC pathname

  1033 // iWord[2] = the EPOC pathname

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

  1035 

  1036 @return - Return the status 

  1037 		  ETrue - Successful generation of tree.

  1038 		  EFalse- Fail to generate the tree.

  1039 */

  1040 TBool CObeyFile::ProcessDriveFile(enum EKeyword aKeyword)               

  1041 	{

  1042 

  1043 	TBool isPeFile = ETrue;

  1044 	TBool aFileCompressOption, aFileUncompressOption;

  1045 

  1046 	TInt epocPathStart=2;

  1047 	aFileCompressOption = aFileUncompressOption = EFalse;

  1048 	// do some validation of the keyword

  1049 	TInt currentLine = iReader.CurrentLine();

  1050 

  1051 	switch (aKeyword)

  1052 		{

  1053 		case EKeywordData:

  1054 		case EKeywordHide:

  1055 			isPeFile = EFalse;

  1056 			break;

  1057 

  1058 		case EKeywordFile:

  1059 			break;

  1060 

  1061 		case EKeywordFileCompress:

  1062 			aFileCompressOption = ETrue;

  1063 			break;

  1064 

  1065 		case EKeywordFileUncompress:

  1066 			aFileUncompressOption = ETrue;

  1067 			break;

  1068 

  1069 		default:

  1070 			return EFalse;

  1071 		}

  1072 

  1073 	if (aKeyword!=EKeywordHide)

  1074 		{

  1075 		// check the PC file exists

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

  1077 

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

  1079 		ifstream test(nname);

  1080 #else //!__MSVCDOTNET__

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

  1082 #endif //__MSVCDOTNET__

  1083 

  1084 		if (!test)

  1085 			{

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

  1087 			iMissingFiles++;

  1088 			}

  1089 

  1090 		test.close();

  1091 		if(nname)

  1092 			free(nname);												

  1093 		nname = 0;

  1094 		}

  1095 	else

  1096 		epocPathStart=1;   

  1097 

  1098 	iNumberOfFiles++;

  1099 

  1100 	TBool endOfName=EFalse;

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

  1102 	TText *epocEndPtr=epocStartPtr;

  1103 

  1104 	if (epocStartPtr==NULL)

  1105 		{

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

  1107 		return EFalse;

  1108 		}

  1109 

  1110 	TRomNode* dir=iRootDirectory;

  1111 	TRomNode* subDir=0;

  1112 	TRomBuilderEntry *file=0;      

  1113 

  1114 	while (!endOfName)

  1115 		{

  1116 		endOfName = GetNextBitOfFileName(&epocEndPtr);      

  1117 		if (endOfName) // file

  1118 			{

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

  1120 

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

  1122 				{

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

  1124 				return EFalse;

  1125 				}

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

  1127 				{ 

  1128 				alreadyExists->iEntry->iHidden = ETrue;

  1129 				alreadyExists->iHidden = ETrue;

  1130 				return ETrue;

  1131 				}

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

  1133 				{

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