// Copyright (c) 2004-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:

//

#define __INCLUDE_CAPABILITY_NAMES__

#include <utf.h>

#include "inifile.h"

#include "datatype.h"

#include "log.h"

#define MAX(a,b)        ((a)<(b)?(b):(a))

#define MAX3(a,b,c)     MAX(MAX(a,b),c)

#define MAX4(a,b,c,d)   MAX(MAX(a,b),MAX(c,d))

//Unicode text file prefix - FE,FF bytes.

static const TUint16 KUcs2Bom = 0xfeff;

//Repository (ini) file - signature

_LIT(KSignature, "cenrep");

static const TInt KSignatureLen = 6;

//Repository (ini) file  - version string and version number

_LIT(KVersion, "version");

static const TInt KVersionLen = 7;

static const TUint KCurrentVersion = 1;

//Repository (ini) file - supported types names

_LIT(KTypeInt, "int");

_LIT(KTypeReal, "real");

_LIT(KTypeString, "string");

_LIT(KTypeString8, "string8");

_LIT(KTypeBinary, "binary");

//Max type name length

static const TInt KMaxTypeLen = 9;

//The symbol used in repository (ini) files to note null data

static const TChar KNullDataIndicator = '-';

// Section identifiers in the repository (ini) file

_LIT(KPlatSecSection, "[platsec]");

static const TInt KPlatSecSectionLen = 9;

_LIT(KOwnerSection, "[owner]");

static const TInt KOwnerSectionLen = 7;

_LIT(KTimeStampSection, "[timestamp]");

static const TInt KTimeStampSectionLen = 11;

_LIT(KMainSection, "[main]");

static const TInt KMainSectionLen = 6;

_LIT(KDefaultMetaSection, "[defaultmeta]");

static const TInt KDefaultMetaSectionLen = 13 ;

static const TInt KIniFileSectionLen = MAX4(KPlatSecSectionLen,KMainSectionLen,KTimeStampSectionLen, KDefaultMetaSectionLen);

// Other useful string constants

_LIT(KMaskString, "mask");

static const TInt KMaskLen = 4;

_LIT(KReadAccessSidString, "sid_rd");

_LIT(KReadAccessCapString, "cap_rd");

_LIT(KWriteAccessSidString, "sid_wr");

_LIT(KWriteAccessCapString, "cap_wr");

_LIT(KAccessAlwaysPass, "alwayspass");

_LIT(KAccessAlwaysFail, "alwaysfail");

// could do max of _LITs above

static const TInt KMaxAccessTypeLen = 6; 

// longest capability string from CapabilityNames is 15

static const TInt KMaxCapabilityStringLen = 20; 

static const TInt KBufLen = MAX3(KVersionLen, KSignatureLen, KIniFileSectionLen);

const TUint KCr = '\r';

const TUint KTab = '\t';

const TUint KSpace = ' ';

#ifdef CENTREP_CONV_TOOL

_LIT(KTransactFileName, "transact");

_LIT(KCrNl,	"\r\n");

_LIT(KHexIntFormat, "0x%X");

_LIT(KUidFormat, "0x%08X");

_LIT(KRangeMetaFmt, "0x%X 0x%X 0x%08X");

_LIT(KMaskMetaFmt, "0x%X mask = 0x%X 0x%08X");

_LIT(KRangePrefix, "0x%X 0x%X");

_LIT(KMaskPrefix, "0x%08X mask = 0x%08X");

#endif

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

// Local functions

/**

The function checks if the file with aFile name exists.

@param aFile File name, including the full path.

@return 0, if the file does not exist, non-zero value otherwise.

@internalComponent

*/

/**

#ifdef CENTREP_CONV_TOOL

static TBool FileExists(const TDesC& aFile)

	{

	TEntry entry;

	return TServerResources::iFs.Entry(aFile, entry) == KErrNone;

	}

#endif

*/

/**

@internalComponent

*/

static TInt ReadFileL(RFile aFile, HBufC16*& aBuf)

	{

	TInt size;

	TInt r = aFile.Size(size);

	if(r!=KErrNone)

		return r;

	if(size<2)

		return KErrCorrupt;

	TInt len = size/2-1;

	aBuf = HBufC16::NewL(len);

	TPtr16 ptr16 = aBuf->Des();

	TPtr8 ptr8((TUint8*)ptr16.Ptr(), 0, 2);

	r = aFile.Read(ptr8, 2);

	if(r!=KErrNone)

		return r;

	if(*ptr16.Ptr()!=KUcs2Bom)

		{

		__CENTREP_TRACE("File not Ucs2.  No BOM");

		return KErrCorrupt;

		}

	ptr8.Set((TUint8*)ptr16.Ptr(), 0, size-2);

	r = aFile.Read(ptr8);

	if(r!=KErrNone)

		return r;

	ptr16.SetLength(len);

	return KErrNone;

	}

static TBool IsNegativeNumber(TLex& aLex)	

    {

    if (aLex.Peek()=='-')

        return ETrue;

    else

        return EFalse;

    }

/**

@internalComponent

*/

static TInt ReadNumberL(TLex& aLex, TUint32& aVal)

	{

	TRadix radix = EDecimal;

	if(aLex.Peek()=='0')

		{

		aLex.Inc();

		if(aLex.Peek().GetLowerCase()=='x')

			{

			aLex.Inc();

			radix = EHex;

			}

		else

			aLex.UnGet();

		}

	if(aLex.Val(aVal, radix)!=KErrNone)

		return KErrCorrupt;

	return KErrNone;

	}

#ifdef CENTREP_CONV_TOOL

/**

@internalComponent

*/

static void WriteBinary(TDes& aBuf, const HBufC8* aString)

	{

	if(aString)

		{

		TInt len = aString->Length();

		if(len==0)

			aBuf.Append(KNullDataIndicator);

		else

			{

			TPtr8 ptr8 = const_cast<HBufC8*>(aString)->Des();

			for(TInt i=0;i<len;i++)

				aBuf.AppendNumFixedWidth(ptr8[i], EHex, 2);

			}

		}

	else

		{

		aBuf.Append(KNullDataIndicator);

		}

	}

/**

The function writes setting value into the supplied buffer (aBuf).

@param aBuf The buffer where the setting value will be appended.

@param aSetting Reference to the setting object

@leave KErrGeneral If the supplied setting object has unknown type.

@internalComponent

*/

static void AddSettingValueL(TDes& aBuf, const TServerSetting& aSetting)

	{

	switch(aSetting.Type())

		{

		case TServerSetting::EInt:

			aBuf.Append(KTypeInt);

			aBuf.Append(KSpace);

			aBuf.AppendNum(aSetting.GetIntValue());

			break;

		case TServerSetting::EReal:

			aBuf.Append(KTypeReal);

			aBuf.Append(KSpace);

			aBuf.AppendNum(aSetting.GetRealValue(), TRealFormat());

			break;

		case TServerSetting::EString:

			aBuf.Append(KTypeBinary);

			aBuf.Append(KSpace);

			WriteBinary(aBuf, aSetting.GetStrValue());

			break;

		default:

			User::Leave(KErrGeneral); //unknown setting type

			break;

		}

	}

#endif

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

// CIniFileIn class

TInt CIniFileIn::NewLC(RFs& aFs,CIniFileIn*& aIniFile,const TDesC& aFullFileName)

	{

	aIniFile = new(ELeave) CIniFileIn(aFs);

	CleanupStack::PushL(aIniFile);

	RFile file;

	CleanupClosePushL(file);

	TInt r = file.Open(aFs, aFullFileName, EFileRead|EFileStreamText);	

	if(r==KErrNone)

		{

#ifdef CENTREP_TRACE

		aIniFile->iFullName = HBufC::NewL(aFullFileName.Length());

		TPtr filename = aIniFile->iFullName->Des();

		filename.Copy(aFullFileName);

#endif

		TInt rReadFile = ReadFileL(file,aIniFile->iBuf);

		CleanupStack::PopAndDestroy(); //file

		TInt rReadHeader=KErrNone;

		if(rReadFile==KErrNone)

			{

			aIniFile->iLex.Assign(aIniFile->iBuf->Des());

			rReadHeader=aIniFile->ReadHeaderL();

			}

		if((rReadFile==KErrCorrupt) || ( rReadHeader==KErrCorrupt))

			{

			return KErrCorrupt;

			}

		}

	else

		{

		CleanupStack::Pop();//file 

		}

	return r;

	}		

CIniFileIn::~CIniFileIn()

	{

	delete iBuf;

#ifdef CENTREP_TRACE

	delete iFullName;

#endif

	}

TInt CIniFileIn::ReadHeaderL()

	{

	TBuf<KBufLen> buf;

	//

	// Check file signature

	//

	SkipComments();

	iLex.Mark();

	iLex.SkipCharacters();

	if(iLex.TokenLength()>KSignatureLen)

		{

		__CENTREP_TRACE1("[%S] Invalid header signature",iFullName);

		return(KErrCorrupt);

		}

	buf.CopyLC(iLex.MarkedToken());

	if(buf.Compare(KSignature)!=0)

		{

		__CENTREP_TRACE1("[%S] Invalid header signature",iFullName);

		return(KErrCorrupt);

		}

	//

	// Check file version

	//

	SkipComments();

	iLex.Mark();

	iLex.SkipCharacters();

	if(iLex.TokenLength()>KVersionLen)

		{

		__CENTREP_TRACE1("[%S] Missing version keyword",iFullName);		

		return(KErrCorrupt);

		}

	buf.CopyLC(iLex.MarkedToken());

	if(buf.Compare(KVersion)!=0)

		{

		__CENTREP_TRACE1("[%S] Missing version keyword",iFullName);	

		return(KErrCorrupt);

		}

	iLex.SkipSpace();

	TUint version;

	iLex.Val(version);

	if(version>KCurrentVersion)

		{

		__CENTREP_TRACE1("[%S] Invalid version number",iFullName);

		return(KErrNotSupported);

		}

	return( KErrNone);

	}

void CIniFileIn::SkipComments()

	{

	for(;;)

		{

		iLex.SkipSpace();

		if(iLex.Peek()!='#')

			break;

		while(iLex.Get()!='\n' && !iLex.Eos()) {}

		}

	}

void CIniFileIn::SkipEqualSign()

	{

	iLex.SkipSpace();

	if(iLex.Peek()=='=')

		iLex.Get();

	iLex.SkipSpace();

	}

TInt CIniFileIn::ReadSettingOnlyL(TServerSetting& aSetting,TBool& aSingleMetaFound)

	{

	TInt ret = KErrNone;

	aSingleMetaFound=EFalse;

	SkipComments();

	iLex.SkipSpace();

	if(iLex.Eos())

		return KErrNotFound;

	TUint32 key;

	TInt r=ReadNumberL(iLex, key);

	if(r!=KErrNone)

		{

		// returns either KErrCorrupt or KErrNone

		__CENTREP_TRACE1("[%S] Invalid single setting id",iFullName);

		return r;

		}

	aSetting.SetKey(key);

	iLex.SkipSpaceAndMark();

	iLex.SkipCharacters();

	if(iLex.TokenLength()>KMaxTypeLen)

		{

		__CENTREP_TRACE1("[%S] Invalid key type, must be one of: [int,real,string,string8,binary]",iFullName);

		return KErrCorrupt;

		}

	TBuf<KMaxTypeLen> type;

	type.CopyLC(iLex.MarkedToken());

	iLex.SkipSpace();

	if(type.Compare(KTypeInt)==0)

		{

        if (IsNegativeNumber(iLex))

            {

            TInt i;

            if(iLex.Val(i)!=KErrNone)

            	{

            	__CENTREP_TRACE1("[%S] Invalid negative integer value",iFullName);

            	return(KErrCorrupt);

            	}

            aSetting.SetIntValue(i);  

            }

        else

            {

            TUint32 i;

            TInt r=ReadNumberL(iLex, i);

            if(r!=KErrNone)

            	{

            	__CENTREP_TRACE1("[%S] Invalid integer value",iFullName);

                return r;

            	}

            aSetting.SetIntValue(i);  

            }

		}

	else if(type.Compare(KTypeReal)==0)

		{

		TReal r;

		ret=iLex.Val(r,'.');

		//iLex.Val with TReal can return KErrNoMemory

		if (ret!=KErrNone)

			{

			if (ret==KErrNoMemory)	

				User::LeaveNoMemory();

			else

				{

				__CENTREP_TRACE1("[%S] Invalid real value",iFullName);

				return KErrCorrupt;

				}

			}

		TReal* temp = new(ELeave)TReal(r);

		aSetting.SetRealValue(temp);

		temp = NULL;

		}

	else if(type.Compare(KTypeString)==0)

		{

		HBufC8* s;

		ret = ReadStringL(s);

		if(ret != KErrNone)

			{

			__CENTREP_TRACE1("[%S] Invalid string value",iFullName);

			return KErrCorrupt;

			}

		aSetting.SetStrValue(s);

		}

	else if(type.Compare(KTypeString8)==0)

		{

		HBufC8* s;

		ret = ReadString16To8L(s);

		if(ret != KErrNone)

			{

			__CENTREP_TRACE1("[%S] Invalid string8 value",iFullName);

			return KErrCorrupt;

			}

		aSetting.SetStrValue(s);

		}	

	else if(type.Compare(KTypeBinary)==0)

		{

		HBufC8* s = NULL;

		ret = ReadBinaryL(s);

		if(ret != KErrNone)

			{

			__CENTREP_TRACE1("[%S] Invalid binary value",iFullName);

			return KErrCorrupt;

			}

		aSetting.SetStrValue(s);

		}

	else

		{

		__CENTREP_TRACE1("[%S] Invalid key type, must be one of: [int,real,string,string8,binary]",iFullName);

		return KErrCorrupt;

		}

	//skip any spaces or tabs

	while(iLex.Peek()==KSpace || iLex.Peek()==KTab)

		{

		iLex.Inc();

		}

    TUint32 meta;

    /**

    carriage return reached which means that there is no meta AND capabilities

    defined for this key. Thus setting meta to NULL to be able to set a value

    from default section later. 

    */ 

    if (iLex.Peek()==KCr)

        {   

        meta = 0;   

        }

    else

        {

        r=ReadNumberL(iLex, meta);

	    /**

	    If meta can not be read, it is not neccessary an error.

	    It might be not present for an individual key and it will be taken

	    from a default section. 

	    If single meta is present, we need to remember so we can recognise a single

	    meta of 0 as distinct from no meta ( also sets meta to 0 ).

	    */ 

	    if(r!=KErrNone)

		    meta = 0;

	    else

	    	aSingleMetaFound=ETrue;

        }

	aSetting.SetMeta(meta);

	return KErrNone;