// Copyright (c) 2006-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 "pfqosparser.h"

#include "qosvariables.h"

#include "pfqosliblog.h"

_LIT(Ksyntax_error, "Syntax error");

EXPORT_C TVariableBase::~TVariableBase()

	{

	}

EXPORT_C TIntVariable::TIntVariable(const TDesC& aName, TInt aValue) 

	: iValue(aValue)

	{

	//??This makes no check against overflow -- either check or use TName&

	//??instead of of TDesC& in parameter list.

	iName.Copy(aName);

	iType = KPfqosTypeInteger;

	}

EXPORT_C TRealVariable::TRealVariable(const TDesC& aName, TReal aValue) 

	: iValue(aValue)

	{

	//??This makes no check against overflow -- either check or use TName&

	//??instead of of TDesC& in parameter list.

	iName.Copy(aName);

	iType = KPfqosTypeReal;

	}

EXPORT_C TStringVariable::TStringVariable(const TDesC& aName, 

										  const TDesC& aValue)

	{

	//??This makes no check against overflow -- either check or use TName&

	//??instead of of TDesC& in parameter list.

	iName.Copy(aName);

	//??This makes no check against overflow -- either check or use TName&

	//??instead of of TDesC& in parameter list.

	iValue.Copy(aValue);

	iType = KPfqosTypeString;

	}

//

// CSelectorBase

//

EXPORT_C CSelectorBase::CSelectorBase(TUint aType) 

	: iType(aType)

	{

	iProtocol = 0;

	iPolicyOptions = 0;

	TUidType uid_type(TUid::Uid(0), TUid::Uid(0), TUid::Uid(0));

	iUid.Set(uid_type);

	iIapId = 0;

	iSrcPortMax = 0;

	iDstPortMax = 0;

	iDst.SetAddress(KInet6AddrNone);

	iSrc.SetAddress(KInet6AddrNone);

	iSrcMask.SetAddress(KInet6AddrNone);

	iDstMask.SetAddress(KInet6AddrNone);

	iName.FillZ();

	iOwner = 0;

	}

//lint -e{1538}	It's safe to copy CBase (I think...?)

EXPORT_C CSelectorBase::CSelectorBase(CSelectorBase& aSel)

	{

	iDstPortMax  = aSel.iDstPortMax;

	iDst = aSel.iDst;

	iDstMask = aSel.iDstMask;

	iSrcPortMax = aSel.iSrcPortMax;

	iSrc = aSel.iSrc;

	iSrcMask = aSel.iSrcMask;

	iProtocol = aSel.iProtocol;

	iUid.Set(aSel.iUid.UidType());

	iIapId = aSel.iIapId;

	iPolicyOptions = aSel.iPolicyOptions;

	iPriority = aSel.iPriority;

	iType = aSel.iType;

	iName.Copy(aSel.iName);

	iOwner = 0;

	}

EXPORT_C CSelectorBase::CSelectorBase(TPfqosBase& aBase, 

									  TPfqosSelector& aSel, 

									  TPfqosAddress& aSrc, 

									  TPfqosAddress& aDst, 

									  TUint aType) : iType(aType)

	{

	iProtocol = (TUint8)aSel.iExt->protocol;

	TCheckedUid uid;

	aSel.GetUid(uid);

	iUid.Set(uid.UidType());

	iIapId = aSel.iExt->iap_id;

	iPolicyOptions = aBase.iMsg->pfqos_msg_options;

	iPriority = aSel.iExt->priority;

	TPtrC8 tmp((TUint8*)aSel.iExt->name);

	iName.Copy(tmp);

	if (aSrc.iAddr != NULL)

		{

		iSrc = *aSrc.iAddr;

		iSrcMask = *aSrc.iPrefix;

		if (aSrc.iExt->pfqos_port_max > iSrc.Port() && 

			aSrc.iExt->pfqos_port_max < 65535)

			{

			iSrcPortMax = aSrc.iExt->pfqos_port_max;

			}

		else

			{

			iSrcPortMax = (TUint16)iSrc.Port();

			}

		}

	else

		{

		iSrc.SetAddress(KInet6AddrNone);

		iSrcMask.SetAddress(KInet6AddrNone);

		}

	if (aDst.iAddr != NULL)

		{

		iDst = *aDst.iAddr;

		iDstMask = *aDst.iPrefix;

		if (aDst.iExt->pfqos_port_max > iDst.Port() && 

			aDst.iExt->pfqos_port_max < 65535)

			{

			iDstPortMax = aDst.iExt->pfqos_port_max;

			}

		else

			{

			iDstPortMax = (TUint16)iDst.Port();

			}

		}

	else

		{

		iDst.SetAddress(KInet6AddrNone);

		iDstMask.SetAddress(KInet6AddrNone);

		}

	iOwner = 0;

	}

EXPORT_C CSelectorBase::~CSelectorBase()

	{

	}

//

// CExtensionPolicy

//

EXPORT_C CExtensionPolicy::CExtensionPolicy(TPfqosBase& aBase, 

											TPfqosSelector& aSel, 

											TPfqosAddress& aSrc, 

											TPfqosAddress& aDst, 

											TInt aType) 

	: CSelectorBase(aBase, aSel, aSrc, aDst, aType)

	{

	iExtensions.SetOffset(_FOFF(CExtension, iNext));

	};

EXPORT_C CExtensionPolicy::CExtensionPolicy() 

	: CSelectorBase(EPfqosExtensionPolicy)

	{

	iExtensions.SetOffset(_FOFF(CExtension, iNext));

	iType = EPfqosExtensionPolicy;

	}

EXPORT_C CExtensionPolicy::~CExtensionPolicy()

	{

	TExtensionQueueIter iter(iExtensions);

	CExtension* ext;

	while ((ext = iter++) != NULL)

		{

		ext->iNext.Deque();

		delete ext;

		}

	}

EXPORT_C void CExtensionPolicy::AddExtensionL(CExtension& aExtension)

	{

	CExtension* ext = CExtension::NewL();

	/* Dynamically allocated memory node has been assigned to the list and managed through the list.

	So CleanupStack::PopAndDestroy() will deallocate that memory. But, Coverity has misinterpreted it an issue.*/

    // coverity [SYMBIAN.CLEANUP STACK]

	// coverity [leave_without_push]

	aExtension.CopyL(*ext);

	iExtensions.AddLast(*ext);

	}

EXPORT_C void CExtensionPolicy::AddExtensionL(const TDesC8& aExtension)

	{

	CExtension* ext = CExtension::NewL(aExtension);

	iExtensions.AddLast(*ext);

	}

//

// QoS Policy db parser

//

EXPORT_C TPolicyParser::TPolicyParser(const TDesC &aPolicy) : iLine(0)

	{

	Assign(aPolicy);

	iExtensions.SetOffset(_FOFF(CExtension, iNext));

	iPolicies.SetOffset(_FOFF(CExtensionPolicy, iNext));

	}

EXPORT_C TPolicyParser::~TPolicyParser()

	{

	TExtensionQueueIter iter(iExtensions);

	CExtension *ext;

	while ((ext = iter++) != NULL)

		{

		ext->iNext.Deque();

		delete ext;

		}

	TQoSPolicyQueueIter policy_iter(iPolicies);

	CExtensionPolicy* policy;

	while ((policy = policy_iter++) != NULL)

		{

		policy->iNext.Deque();

		delete policy;

		}

	}

EXPORT_C TInt TPolicyParser::ParseL()

	{

	LOG(Log::Printf(_L("ParseL called...")));

	TInt error = KErrNone;

	iLine = 1;

	while (!Eos())

		{

		if (NextToken() == ETokenString)

			{

			_LIT(Kmodulespec, "modulespec");

			_LIT(Kflowspec, "flowspec");

			_LIT(Kextension_spec, "extension_spec");

			_LIT(Kmodule_policy, "module_policy");

			_LIT(Kflowspec_policy, "flowspec_policy");

			_LIT(Kextension_policy, "extension_policy");

			_LIT(KUnknown, "Unknown token '%S'");

			if (iToken.Compare(Kmodulespec) == 0)

				{

				error = ParseExtensionSpecL();

				}

			else if (iToken.Compare(Kflowspec) == 0)

				{

				error = ParseExtensionSpecL();

				}

			else if (iToken.Compare(Kextension_spec) == 0)

				{

				error = ParseExtensionSpecL();

				}

			else if (iToken.Compare(Kmodule_policy) == 0)

				{

				error = ParsePolicyL(EPfqosModulespecPolicy);

				}

			else if (iToken.Compare(Kflowspec_policy) == 0)

				{

				error = ParsePolicyL(EPfqosFlowspecPolicy); 

				}

			else if (iToken.Compare(Kextension_policy) == 0)

				{

				error = ParsePolicyL(EPfqosExtensionPolicy);

				}

			else

				{

				Error(KUnknown, &iToken);

				error = KErrGeneral;

				}

			}

		}

	return error;

	}

// Dummy error routines for now

void TPolicyParser::Error(TRefByValue<const TDesC> aFmt, ...)

	{

        //coverity[var_decl];

	VA_LIST list;

	VA_START(list, aFmt);

	_LIT(KatLine, " at line ");

         //coverity[uninit_use_in_call];

	iMsg.FormatList(aFmt, list);

	iMsg += KatLine;

	//lint -e{747} int -> long long

	iMsg.AppendNum(iLine);

	}

//

// Skip white space and mark, including comments!

//

void TPolicyParser::SkipSpaceAndMark()

	{

	TChar ch;

	TInt comment = 0;

	while (!Eos())

		{

		ch = Get();

		//lint -e{961} Missing else is OK

		if (ch =='\n')

			{

			iLine++;

			comment = 0;

			}

		else if (comment || ch == '#')

			{

			comment = 1;

			}

		else if (!ch.IsSpace())

			{

			UnGet();

			break;

			}

		}

	Mark();

	}

//

//

TTokenType TPolicyParser::NextToken()

	{

	TChar ch;

	TTokenType val;

	SkipSpaceAndMark();

	if (Eos())

		{

		val = ETokenEof;

		}

	else

		{

		ch = Get();

		if (ch == '{')

			{

			val = ETokenBraceLeft;

			}

		else if (ch == '}')

			{

			val = ETokenBraceRight;

			}

		else if (ch == '(')

			{

			val = ETokenParLeft;

			}

		else if (ch == ')')

			{

			val = ETokenParRight;

			}

		else if (ch == '=')

			{

			val = ETokenEqual;

			}

		else if (ch == ',')

			{

			val = ETokenComma;

			}

		else

			{

			val = ETokenString;

			while (!Eos())

				{

				ch = Peek();

				if (ch == '{' || ch == '}' ||

					ch == '(' || ch == ')' ||

					ch == '=' || ch == '#' || ch.IsSpace())

					{

					break;

					}

				Inc();

				}

			}

		}

	iToken.Set(MarkedToken());

	SkipSpaceAndMark();

	return val;

	}

TTokenType TPolicyParser::GetStringValue()

	{

	TChar ch('\0');

	TTokenType val;

	SkipSpaceAndMark();

	if (Eos())

		{

		val = ETokenEof;

		}

	else

		{

		TBool quoted = EFalse;

		ch = Get();

		if (ch == '"')

			{

			quoted = ETrue;

			Mark();

			}

		if (ch == '{')

			{

			val = ETokenBraceLeft;

			}

		else if (ch == '}')

			{

			val = ETokenBraceRight;

			}

		else if (ch == '(')

			{

			val = ETokenParLeft;

			}

		else if (ch == ')')

			{

			val = ETokenParRight;

			}

		else if (ch == '=')

			{

			val = ETokenEqual;

			}

		else if (ch == ',')

			{

			val = ETokenComma;

			}

		else

			{

			val = ETokenString;

			while (!Eos())

				{

				ch = Peek();

				if (ch == '"' && quoted)

					{

					quoted = EFalse;

					}

				if ((ch == '{' || ch == '}' ||

					 ch == '(' || ch == ')' ||

					 ch == '=' || ch == '#' || 

					 ch == '"' || ch.IsSpace()) && !quoted)

					{

					break;

					}

				Inc();

				}

			}

		}

	iToken.Set(MarkedToken());

	if (ch == '"')

		{

		Inc();

		}

	SkipSpaceAndMark();

	return val;

	}

//

// Extension spec

//

TInt TPolicyParser::ParseExtensionSpecL()

	{

	if (NextToken() != ETokenString)

		{

		Error(Ksyntax_error);

		}

	CExtension* spec = CExtension::NewL();

	iExtensions.AddLast(*spec);

	spec->SetName(iToken);

	if (NextToken() != ETokenEqual || NextToken() != ETokenBraceLeft)

		{

		Error(Ksyntax_error);

		}

	else 

		{

		if (ParseExtensionParams(*spec))

			{

			Error(Ksyntax_error);

			}

		else

			{

			return KErrNone;

			}

		}

	spec->iNext.Deque();

	delete spec;

	return KErrGeneral;

	}

//

// Parse extension parameters

//

TInt TPolicyParser::ParseExtensionParams(CExtension& aBuf)

	{

	LOG(Log::Printf(_L("ParseL called...")));

	TInt error = KErrNone;

	TTokenType val;

	while ((val = NextToken()) == ETokenString && error == KErrNone)

		{

		_LIT(KINTEGER, "INTEGER");

		_LIT(KREAL, "REAL");

		_LIT(KSTRING, "STRING");