/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:

*

*/

#include <f32file.h>

#include "c32cmi.h"

#include <cfextras.h>

#include <e32base.h>

#include "c32cmiutils.h"

/** Implements the parser for .CMI configuration files.

@file

@publishedPartner

@released

*/

/** Name of application for logging

*/

__FLOG_STMT(_LIT8(KSubsys,"C32Start");)

/** Logging second tag

*/

__FLOG_STMT(_LIT8(KComponent,"Events");)

/** .CMI file section "[Loader]" contains the configuration of

the CPM and its bindings

*/

_LIT8(KSectionLoader,		"Loader");

/** .CMI optional file section "[IniData]" contains application specific

data.

*/

_LIT8(KSectionIniData,		"IniData");

/** Attribute which can be found in a .CMI file in the [loader] section.

*/

_LIT8(KAttrName,			"Name");

/** Attribute which can be found in a .CMI file in the [loader] section.

*/

_LIT8(KAttrFileName,		"FileName");

/** Attribute which can be found in a .CMI file in the [loader] section.

*/

_LIT8(KAttrIniDataFile,		"IniData");

/** Attribute which can be found in a .CMI file in the [loader] section.

*/

_LIT8(KAttrIsServer,		"IsServer");

/** Attribute which can be found in a .CMI file in the [loader] section.

*/

_LIT8(KAttrPriority,		"Priority");

/** Attribute which can be found in a .CMI file in the [loader] section.

*/

_LIT8(KAttrStackSize,		"StackSize");

/** Attribute which can be found in a .CMI file in the [loader] section.

*/

_LIT8(KAttrHeapOption,		"HeapOption");

/** Attribute which can be found in a .CMI file in the [loader] section.

*/

_LIT8(KAttrStartSequence,	"StartSequence");

/** Attribute which can be found in a .CMI file in the [loader] section.

*/

_LIT8(KAttrScaledStartupState,	"ScaledStartupState");

/** Attribute which can be found in a .CMI file in the [loader] section.

*/

_LIT8(KAttrMinHeapSize,		"MinHeapSize");

/** Attribute which can be found in a .CMI file in the [loader] section.

*/

_LIT8(KAttrMaxHeapSize,		"MaxHeapSize");

/** Attribute which can be found in a .CMI file in the [loader] section.

*/

_LIT8(KAttrSharedHeapName,	"SharedHeapName");

/** Attribute which can be found in a .CMI file in the [loader] section.

*/

_LIT8(KAttrThreadFuncOrdinal,"ThreadFunctionOrdinal");

/** Attribute which can be found in a .CMI file in the [loader] section.

*/

_LIT8(KAttrIsSticky,		"IsSticky");

/** Attribute which can be found in a .CMI file in the [loader] section.

*/

_LIT8(KAttrSystemCritical,	"SystemCritical");

/** Attribute which can be found in a .CMI file in the [loader] section.

*/

_LIT8(KAttrSystemCriticalAfterInit,	"SystemCriticalAfterInit");

/** Attribute which can be found in a .CMI file in the [loader] section.

*/

_LIT8(KAttrControlFlags,	"ControlFlags");

/**Attribute which can be found in a .CMI file in the [loader] section.

*/

_LIT8(KAttrOnDemand, "OnDemand");

/**Attribute which can be found in a .CMI file in the [loader] section.

*/

_LIT8(KAttrGroupName, "Group");

/** PANICs which can occur during .CMI file parsing.

*/

enum TIniPanic

	{

	/** The name of a section is too long.

	*/

	ESectionNameTooBig,

	/** The name of a variable is too big.

	*/

	EVarNameTooBig

	};

#ifdef _DEBUG

/** Function whch will PANIC the module, but only in debug mode.

*/

static void Panic(TIniPanic aPanic)

	{

	_LIT(KC32CmiData,"C32CmiData");

	User::Panic(KC32CmiData,aPanic);

	}

#endif

/////////////////////////////////////////////////////////////////////////////

C32ParseIniFile* C32ParseIniFile::NewL(const TDesC& aFileName, TAutoClose<RFs>& aFileServer)

	{

	C32ParseIniFile* self = new(ELeave) C32ParseIniFile;

	CleanupStack::PushL(self);

	self->ConstructL(aFileName, aFileServer);

	CleanupStack::Pop();

	return self;

	}

void C32ParseIniFile::ConstructL(const TDesC& aFileName, TAutoClose<RFs>& aFileServer)

	{

	__FLOG_OPEN(KSubsys,KComponent);

    iToken = HBufC8::NewL(KTokenSize+2);	// 2 extra chars for [tokenName]

	ReadFileL(aFileName, aFileServer);

	}

C32ParseIniFile::~C32ParseIniFile()

	{

	delete iCmiData;

	delete iToken;

	__FLOG_CLOSE;

	}

TBool C32ParseIniFile::FindVar(const TDesC8 &aSection, const TDesC8 &aVarName, TPtrC8 &aResult, TInt aEnumerator)

/** Find a variable's value given a section name and a var name.

@param aSection The section to search.

@param aVarName The name that will have aEnumerator appended to it to generate the key that will be searched for.

@param aResult The result.

@param aEnumerator Appended to the var name to generate a the key that will be searched for.

@return Success or fail.

*/

	{

	__ASSERT_DEBUG(aSection.Length()<=KTokenSize,Panic(ESectionNameTooBig));

	__ASSERT_DEBUG(aVarName.Length()<=KTokenSize,Panic(EVarNameTooBig));

	// append enumeration to the key name

	TBuf8<256> aKey(aVarName);

	aKey.AppendNum(aEnumerator);

	return CommsFW::GetVarFromIniData(*iCmiData, aSection, aKey, aResult);

	}

TBool C32ParseIniFile::FindVar(const TDesC8 &aSection, const TDesC8 &aVarName, TPtrC8 &aResult)

/** Find a variable's value given a section name and a var name.

@param aSection The section to search.

@param aVarName The name to find.

@param aResult The result.

@return Success or fail.

*/

	{

	__ASSERT_DEBUG(aSection.Length()<=KTokenSize,Panic(ESectionNameTooBig));

	__ASSERT_DEBUG(aVarName.Length()<=KTokenSize,Panic(EVarNameTooBig));

	return CommsFW::GetVarFromIniData(*iCmiData, aSection, aVarName, aResult);

	}

TBool C32ParseIniFile::FindVar(const TDesC8 &aSection, const TDesC8 &aVarName, TInt &aResult)

/**

@param aSection The section to search.

@param aVarName The name to find.

@param aResult The result.

@return Success or fail.

*/

	{

	TPtrC8 ptr(NULL,0);

	if (FindVar(aSection,aVarName,ptr))

		{

		TRadix radix;

		_LIT8(KHexPrefix, "0x");

		if(ptr.Left(2).CompareF(KHexPrefix) == 0)

			{

			ptr.Set(ptr.Mid(2));

			radix = EHex;

			}

		else

			{

			radix = EDecimal;

			}

		TLex8 lex(ptr);

		TUint32 result;

		if (lex.Val(result, radix)==KErrNone)

			{

			aResult = result;

			return(ETrue);

			}

		}

	return(EFalse);

	}

void C32ParseIniFile::ReadFileL(const TDesC& aFileName, TAutoClose<RFs>& aFileServer)

/** Reads the file content into a narrow-char buffer. By design the

configurator only supports ASCII text, as its purpose is invisible

system configuration.

@param aFileName The name of the file to be read.

*/

	{

	// Open session to the FileServer

	//TAutoClose<RFs> fs;

	TInt result;

	//check if the session is already open

	if(aFileServer.iObj.Handle() == 0)

		{

		if(KErrNone!=(result=aFileServer.iObj.Connect()))

			{

			__FLOG( _L( "Unable to connect to the File Server" ) );

			User::Leave(result);

			}

		}

	//fs.PushL();

	// Open file

	TAutoClose<RFile> rfile;

	result = rfile.iObj.Open(aFileServer.iObj, aFileName, EFileShareReadersOnly);

	if(KErrNone==result)

		{

		rfile.PushL();

		// Get filesize for allocating the buffer for the data

		TInt size;

		result = rfile.iObj.Size(size);

		if(KErrNone!=result)

			{

			__FLOG_1(_L("Couldn't get size of file %S"), &aFileName);

			User::Leave(result);

			}

		if(size<=0)

			{

			__FLOG_1(_L("File %S has no contents"), &aFileName);

			User::Leave(KErrCorrupt);

			}

		// Allocate a buffer that can contain the file data

		iCmiData = HBufC8::NewL(size);

		TPtr8 fileDataPtr = iCmiData->Des();

		// Read the contents of the file into the buffer

		result=rfile.iObj.Read(fileDataPtr);

		if(KErrNone!=result)

			{

			__FLOG_1(_L("Couldn't read contents of file %S"), &aFileName);

			User::Leave(result);

			}

		rfile.Pop();

		}

	//fs.Pop();

	}

TPtrC8 C32ParseIniFile::RetrieveSectionStart(const TDesC8& aSectionName)

/** Returns a byte descriptor containing the data from the start of a section to the

end of the file.

*/

	{

	TPtrC8 section;

	TPtr8 sectionToken = iToken->Des();

	_LIT8(sectionTokenString,"[%S]");

	sectionToken.Format(sectionTokenString, &aSectionName);

	TInt sectionStart = iCmiData->Find(sectionToken);

	if (KErrNotFound==sectionStart)

		return section;

	section.Set(iCmiData->Mid(sectionStart));

	sectionStart += section.Find(TPtrC8(_S8("]")));

	if (KErrNotFound==sectionStart)

		{

		section.Set(KNullDesC8);

		}

	else

		{

		sectionStart++;

		section.Set(iCmiData->Mid(sectionStart, iCmiData->Length()-sectionStart));

		}

	return section;

	}

/////////////////////////////////////////////////////////////////////////////

C32CmiData::C32CmiData()

/** C'tor. Sets th default values for the attributes as well as

the default required attributes.

*/

	{

	__FLOG_OPEN(KSubsys,KComponent);

	iAttrPriority = EPriorityNormal;

//	iAttrThreadFuncOrdinal = 0; // Rootserver uses defaults ordinal when this is set to 0.

	iAttrStackSize = KDefaultStackSize * sizeof(TText); // Bigger stack if unicode

	iAttrRequired = (AttrName|AttrFileName);

	iAttrScaledStartupState = 0x3000;

//	iAttrIsSticky=EFalse;

//	iAttrSystemCritical=EFalse;

//	iAttrControlFlags=0;

	}

C32CmiData::~C32CmiData()

/** D'tor.

*/

	{

	delete iCmiFile;

	__FLOG_CLOSE;

	}

/*static*/ C32CmiData* C32CmiData::NewL(const TDesC& aFileName, TAutoClose<RFs>& aFileServer)

/**

@param aFileName The filename of the file to be read.

@return pointer to new C32CmiData object.

*/

	{

	C32CmiData* p = new(ELeave) C32CmiData;

	CleanupStack::PushL(p);

	p->ConstructL(aFileName, aFileServer);

	CleanupStack::Pop();

	return p;

	}

void C32CmiData::RetrieveAttribute(TInt aAttr, const TDesC8 &aVarName, TInt &aResult)

/**

@param aAttr The attibute set and returned.

@param aVarName The name to be found.

@param aResult The result.

*/

	{

	if(FindVar(KSectionLoader, aVarName, aResult))

		{

		SetAttr(aAttr);

		}

	}

void C32CmiData::RetrieveAttribute(TInt aAttr, const TDesC8 &aVarName, TPtrC8 &aResult)

/** Retrieves an option from the file data and

if it was found set the requested TPtrC to point to it.

@param aAttr The attibute set and returned.

@param aVarName The name to be found.

@param aResult The result.

*/

	{

	if(FindVar(KSectionLoader, aVarName, aResult))

		{

		SetAttr(aAttr);

		}

	}

void C32CmiData::RetrievePriorityL()

/** Retrieves a priority option from the file data. If present, checks it is a valid

TThreadPriority enumerator name, and sets the corresponding priority attribute.

@leave KErrCorrupt If the priority name is invalid

*/

	{

	TPtrC8 priorityName;

	if(FindVar(KSectionLoader, KAttrPriority, priorityName))

		{

		TThreadPriority priority;

		if(C32CmiUtils::ThreadPriorityNameToEnum(priorityName, priority) == KErrNone)

			{

			iAttrPriority = priority;

			SetAttr(AttrPriority);

			return;

			}

		__FLOG_1(_L8("Invalid Priority %S"), &priorityName);

		User::Leave(KErrCorrupt);

		}

	}

TBool C32CmiData::CompareHeapTypes(const TDesC8 &aType1, const TDesC8 &aType2, TRSHeapType aType3)

/** Helper function: Compares two strings and if there

is a match set the AttrHeapOption bit and save the requested value.

@param aType1 The first descriptor.

@param aType2 The second descriptor.

@param aType3 Enum type to be set on a positive match.

@return Success or fail.

*/

	{

	if(0==aType1.CompareF(aType2))

		{

		iAttrHeapOption=aType3;

		SetAttr(AttrHeapOption);

		return ETrue;

		}

	return EFalse;

	}

void C32CmiData::RetrieveHeapTypeL()

/** Determines the heap type required.

*/

	{

	TPtrC8 type;

	if(FindVar(KSectionLoader, KAttrHeapOption, type))

		{

		// List of possible heap types

		_LIT8(KEDefaultHeap, "EDefaultHeap");

		_LIT8(KEShareHeap, "EShareHeap");

		_LIT8(KENewHeap, "ENewHeap");

		if(CompareHeapTypes(type, KEDefaultHeap, EDefaultHeap))

			return;

		if(CompareHeapTypes(type, KEShareHeap, EShareHeap))

			{

			iAttrRequired |= AttrSharedHeapName;

			return;

			}

		if(CompareHeapTypes(type, KENewHeap, ENewHeap))

			{

			iAttrRequired |= (AttrMinHeapSize|AttrMaxHeapSize);

			return;

			}

		__FLOG_1(_L8("Invalid Heap Type %S"), &type);

		User::Leave(KErrCorrupt);

		}

	}

void C32CmiData::RetrieveIniDataSection()

/** Sets a narrow ptr to point from the start of

the inidata to the end of the file.

*/

	{

	TPtrC8 sectionStart = iCmiFile->RetrieveSectionStart(KSectionIniData);

	iAttrIniData.Set(sectionStart.Ptr(), sectionStart.Length());

	SetAttr(AttrIniData);

	}

void C32CmiData::RetrieveAttributesL()

/** Controls extraction of data.

*/

	{

	RetrieveAttribute(AttrName, KAttrName, iAttrName);

	RetrieveAttribute(AttrFileName, KAttrFileName, iAttrFileName);

	RetrieveAttribute(AttrIniDataFile, KAttrIniDataFile, iAttrIniDataFile);

	RetrieveAttribute(AttrIsServer, KAttrIsServer, iAttrIsServer);

	RetrievePriorityL();

	RetrieveAttribute(AttrStackSize, KAttrStackSize, iAttrStackSize);

	RetrieveHeapTypeL();

	TInt scaledStartupState = (TInt) iAttrScaledStartupState;

	RetrieveAttribute(AttrScaledStartupState, KAttrScaledStartupState, scaledStartupState);

	iAttrScaledStartupState = (TUint32) scaledStartupState;

	// The original start sequence scheme is remapped to the scaled startup states

	TInt attrStartSequence = KC32LowStartSequenceCeiling;

	RetrieveAttribute(AttrStartSequence, KAttrStartSequence, attrStartSequence);

	if(AttrIsSet(AttrStartSequence))

		{

		if(AttrIsSet(AttrScaledStartupState))

			{

			__FLOG(_L("ERROR: Both StartSequence and ScaledStartupState given"));

			User::Leave(KErrCorrupt);

			}

		if(attrStartSequence < KC32LowStartSequenceCeiling)

			{

			iAttrScaledStartupState = KC32LowStartSequenceScaleBase + attrStartSequence;

			}

		else if(attrStartSequence < KC32MidStartSequenceCeiling)

			{

			iAttrScaledStartupState = KC32MidStartSequenceScaleBase + attrStartSequence;

			}

		else

			{

			iAttrScaledStartupState = KC32HighStartSequenceScaleBase + attrStartSequence;

			}

		__FLOG_2(_L("...StartSequence %d converted to ScaledStartupState 0x%x"), attrStartSequence, iAttrScaledStartupState);

		SetAttr(AttrScaledStartupState);

		}

	else

		{

		__FLOG_1(_L("...ScaledStartupState 0x%x"), iAttrScaledStartupState);

		}

	RetrieveAttribute(AttrMinHeapSize, KAttrMinHeapSize, iAttrMinHeapSize);

	RetrieveAttribute(AttrMaxHeapSize, KAttrMaxHeapSize, iAttrMaxHeapSize);

	RetrieveAttribute(AttrSharedHeapName, KAttrSharedHeapName, iAttrSharedHeapName);

	RetrieveAttribute(AttrThreadFuncOrdinal, KAttrThreadFuncOrdinal, iAttrThreadFuncOrdinal);

	RetrieveAttribute(AttrIsSticky, KAttrIsSticky, iAttrIsSticky);

	RetrieveAttribute(AttrSystemCritical, KAttrSystemCritical, iAttrSystemCritical);

	RetrieveAttribute(AttrSystemCriticalAfterInit, KAttrSystemCriticalAfterInit, iAttrSystemCriticalAfterInit);

	//Added for on demand loading

	RetrieveAttribute(AttrOnDemand, KAttrOnDemand, iAttrOnDemand);

	RetrieveAttribute(AttrGroupName, KAttrGroupName, iAttrGroupName);

	TInt controlFlags = 0;

	RetrieveAttribute(AttrControlFlags, KAttrControlFlags, controlFlags);