/*

* Copyright (c) 2000 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: Implementation of policymanagement components

*

*/

// INCLUDES

#include "PolicyParser.h"

#include "ElementBase.h"

#include "elements.h"

#include "DataTypes.h"

#include "debug.h"

#include "PolicyStorage.h"

#include "XACMLconstants.h"

#include "ErrorCodes.h"

#include <f32file.h>

#include <e32base.h>

#include <s32file.h>

// MACROS

// CONSTANTS

_LIT8( KCDataStart, "<![CDATA[");

const TInt KCDataStartLength = 9;

const TInt KCDataEndLength = 3;

_LIT8( KCDataEnd, "]]>");

// DATA TYPES

// FUNCTION PROTOTYPES

namespace ParserUtility

{

	// -----------------------------------------------------------------------------

	// ParserUtility::ContainsCDataField

	// -----------------------------------------------------------------------------

	//

	TBool ContainsCDataField( TPtrC8& aChunk)

	{

		//Find CData indicator

		return 0 <= aChunk.Find( KCDataStart);

	}

	// -----------------------------------------------------------------------------

	// ParserUtility::ReadCDataArea

	// -----------------------------------------------------------------------------

	//

	void ReadCDataAreaL( TPtrC8& aCDataArea, TPtrC8& aChunk, TPtrC8& aFinalPart)

	{

		//find cdata start index and calculate nested cdata fields

		TPtrC8 temp = aFinalPart;

		TInt tempIndex;

		TInt cdatastart = KErrNotFound;

		TInt cdataCount = 0;

		while (	KErrNotFound != (tempIndex = temp.Find( KCDataStart)))

		{

			if ( cdatastart == KErrNotFound)

			{

				//save cdata field start

				cdatastart = tempIndex;

			}

			temp.Set( temp.Mid(tempIndex + KCDataStartLength));

			cdataCount++;	

		}

		User::LeaveIfError( cdatastart);

		//find end location for cdata field (dismiss nested CDATA end marks)

		TInt cdataend = 0;

		temp.Set( aFinalPart);

		while ( cdataCount-- )

		{

			TInt current = temp.Find( KCDataEnd);

			temp.Set( temp.Mid(current + KCDataEndLength ));

			cdataend += current + KCDataEndLength;

		}

		if ( cdataCount != -1 )

		{

			User::Leave( KErrCorrupt);

		}

		//set cdata area

		aCDataArea.Set( aFinalPart.Mid( cdatastart));

		aCDataArea.Set( aCDataArea.Left( cdataend - cdatastart));

		//shrink cdata part from chunk and set aFinalPart to begin after cdata part 

		aChunk.Set( aChunk.Left( cdatastart));

		aFinalPart.Set( aFinalPart.Mid( cdataend));

	}

	// -----------------------------------------------------------------------------

	// ParserUtility::RemoveCDataMarks

	// -----------------------------------------------------------------------------

	//

	void RemoveCDataMarksL( TPtrC8& aData)

	{

		TInt index = aData.Find( KCDataStart);

		User::LeaveIfError( index );

		aData.Set( aData.Mid( index +  KCDataStartLength));

		TInt validIndex = 0;

		TInt tempIndex;

		TPtrC8 temp = aData;

		while ( KErrNotFound != ( tempIndex = temp.Find( KCDataEnd)))

		{

			validIndex += tempIndex + KCDataEndLength;

			temp.Set( temp.Mid( tempIndex + KCDataEndLength ));

		}

		User::LeaveIfError( index );

		aData.Set( aData.Left( validIndex - KCDataEndLength));

	}

	TInt LineCounter( TPtrC8& aData)

	{

		TPtrC8 temp = aData;

		TInt rowCount = 0;

		TInt index;

		//ascii code 10 is line feed mark

		while ( KErrNotFound != ( index = temp.Locate( 10)))

		{

			rowCount++;

			temp.Set( temp.Mid( index + 1 ));

		}

		return rowCount;

	}

}

// FORWARD DECLARATIONS

// CLASS DECLARATION

// -----------------------------------------------------------------------------

// CPolicyParser::CPolicyParser

// -----------------------------------------------------------------------------

//

CPolicyParser::CPolicyParser( CPolicyStorage * aStorage)

	: iStorage( aStorage)

{

}

// -----------------------------------------------------------------------------

// CPolicyParser::~CPolicyParser

// -----------------------------------------------------------------------------

//

CPolicyParser::~CPolicyParser()

{

	delete iElementStack;

	delete iParser;

}

// -----------------------------------------------------------------------------

// CPolicyParser::NewL

// -----------------------------------------------------------------------------

//

CPolicyParser* CPolicyParser::NewL( CPolicyStorage * aStorage)

{

	//2nd phase constructor

	CPolicyParser * self = new (ELeave) CPolicyParser( aStorage);

	CleanupStack::PushL( self);

	self->ConstructL();

	CleanupStack::Pop( self);

	return self;

}

// -----------------------------------------------------------------------------

// CPolicyParser::ConstructL()

// -----------------------------------------------------------------------------

//

void CPolicyParser::ConstructL()

{

	//2nd phase constructor

	iElementStack = new (ELeave)CStack<CElementBase, EFalse>;

	iParser = Xml::CParser::NewL( _L8( "text/xml"), *this );	

}

// -----------------------------------------------------------------------------

// CPolicyParser::ParseXACMLObjects()

// -----------------------------------------------------------------------------

//

CElementBase * CPolicyParser::ParseXACMLObjects( TInt& aError, const TDesC8 &aXACML, TDes8 &aReturnText)

{

	//parsing for XACML objects

	//Set parsing properties

	iValidCharacterSet = EFalse;		

	iErrorHandling = ETrue;

	iLanguage = EXACML;

	iElementStack->Reset();

	iStorage->ResetRealIdValidTest();

	iActiveElement = NULL;		

	iReturnText = ParserErrors::ParsingOk;	

	//actual parsing....

	TRAP( aError, ParseL( aXACML));

	//In error case delete root element...

	if ( aError != KErrNone )

	{

		delete iRootElement;

		iRootElement = NULL;

	}

	iStorage->ResetRealIdValidTest();

	aReturnText  = iReturnText;

	return iRootElement;

}	

// -----------------------------------------------------------------------------

// CPolicyParser::ParseL()

// -----------------------------------------------------------------------------

//

void CPolicyParser::ParseL( const TDesC8 &aXACML)

{

	//reset line counter and initialize XML-parser

	iActiveLine = 0;

	iParser->ParseBeginL();

	//Max size of chunk (max text length, which go once to parser)

	const TInt KMaxChunkLength = 1000;

	TPtrC8 xacmlDescription = aXACML;

	TPtrC8 chunk;

	TInt length = KMaxChunkLength < xacmlDescription.Length() ? KMaxChunkLength : xacmlDescription.Length();

	do

	{

		//max text, which go to parser is one line or KMaxChunkLength. Counter tracks line, where parsing is going

		iActiveLine++;

		//Find line feed mark (asciicode 10)

		TInt index = xacmlDescription.Locate(10);

		if ( index != KErrNotFound)

		{

			length = index + 1;

		}

		//set chunk pointer

		chunk.Set( xacmlDescription.Left(length));

		TPtrC8 cdata;

		if ( ParserUtility::ContainsCDataField( chunk))

		{

			//cdata mark indicated in chunk, remove cdata area from chunk, 

			ParserUtility::ReadCDataAreaL( cdata, chunk, xacmlDescription);

			if ( iLanguage == EXACML)

			{

				iActiveLine += ParserUtility::LineCounter( cdata);

			}

		}

		else

		{

			//set remaining XACML description to xacmlDescription

			xacmlDescription.Set( xacmlDescription.Mid(length));			

		}		

		//'|' and '~' are not allowed in policy system...

		if ( iLanguage == EXACML && (chunk.Locate('|') != KErrNotFound || chunk.Locate('~') != KErrNotFound))

		{

			HandleErrorL( ParserErrors::InvalidMark, ParserErrors::InvalidMarks); 

		}

		//drive description to parser	

		iParser->ParseL( chunk);

		//in cdata case call directly OnContent

		if ( cdata.Length())

		{

			TInt err = KErrNotFound; 

			OnContentL( cdata, err);

		}

		length = KMaxChunkLength < xacmlDescription.Length() ? KMaxChunkLength : xacmlDescription.Length();

	} while ( length);

	//close parser

	iParser->ParseEndL();

}

// -----------------------------------------------------------------------------

// CPolicyParser::ParseL()

// -----------------------------------------------------------------------------

//

TInt CPolicyParser::ParseNativeObjects( CElementBase * aSeedElement, const TDesC8 &aNative, TBool aAddToEditableCache)

{

	//parsing for native objects

	//set parsing properties

	iValidCharacterSet = ETrue;

	iErrorHandling = EFalse;

	iLanguage = ENative;		

	iElementStack->Reset();

	iAddToEditableCache = aAddToEditableCache;

	//seed element is given by function caller

	iActiveElement = aSeedElement;		

	//parsing

	TRAPD( err, ParseL( aNative));

	return err;	

}

// -----------------------------------------------------------------------------

// CPolicyParser::SetLineOffset()

// -----------------------------------------------------------------------------

//

void CPolicyParser::SetLineOffset( TInt aLine)

{

	iLineOffset = aLine;

}

// -----------------------------------------------------------------------------

// CPolicyParser::HandleErrorL()

// -----------------------------------------------------------------------------

//

void CPolicyParser::HandleErrorL( const TDesC8 &aText)

	{

	//if error handling is on....

	if ( iErrorHandling )

		{

		//parse error text

		iReturnText.Copy( _L8("(Line "));

		iReturnText.AppendNum( iActiveLine + iLineOffset);

		iReturnText.Append( _L8(") "));

		iReturnText.Append( aText);

		RDEBUG8_2("XACML parser error: %S", &iReturnText);

		}

	User::Leave( KErrParser );

	}

// -----------------------------------------------------------------------------

// CPolicyParser::HandleErrorL()

// -----------------------------------------------------------------------------

//

void CPolicyParser::HandleErrorL( const TDesC8 &aText, const TDesC8 &aErrorElement)

{

	//parse error text

	TBuf8<KMaxReturnMessageLength> returnText;

	const TInt KErrorMsgLength = 20;

	if ( (aText.Length() + aErrorElement.Length() + KErrorMsgLength) < KMaxReturnMessageLength) 

	{

		returnText = aText;

		returnText.Append(_L(": "));

		returnText.Append( aErrorElement);

	}

	HandleErrorL( returnText); 

}

// -----------------------------------------------------------------------------

// CPolicyParser::HandleErrorL()

// -----------------------------------------------------------------------------

//

void CPolicyParser::HandleErrorL( const TAny * aPointer, const TDesC8 &aError, const TDesC8 &aErrorElement)

{

	if ( aPointer != NULL)

	{

		HandleErrorL( aError, aErrorElement);

	}

}

// -----------------------------------------------------------------------------

// CPolicyParser::HandleNativeErrorL()

// -----------------------------------------------------------------------------

//

void CPolicyParser::HandleNativeErrorL( TInt /*aError*/)

{

	//When parsing native objects, error messages are not needed

	User::Leave( KErrNativeParser);

}

// -----------------------------------------------------------------------------

// CPolicyParser::Language()

// -----------------------------------------------------------------------------

//

TLanguageSelector CPolicyParser::Language()

{

	return iLanguage;

}

// -----------------------------------------------------------------------------

// CPolicyParser::CreateIdElementsL()

// -----------------------------------------------------------------------------

//

void CPolicyParser::CreateIdElementsL( const TDesC8& aIdString )

{

#ifndef __POLICY_BASE_CREATOR_TOOL

	TPtrC8 ptr( aIdString);

	TUint32 policySystemid(0);

	TBool atLeastOneId = EFalse;

	//parse from id string ids, which belongs to current component. 	

	while ( ptr[0] == '|')

	{

		//remove delimiter

		ptr.Set( ptr.Mid(1));

		//find second delimiter

		TInt index = ptr.Locate('|');

		TPtrC8 elementId( ptr);

		//if second delimiter found set correct length for elementId, otherwise elementId length is allready valid

		if ( index != KErrNotFound)

		{

			elementId.Set( ptr.Left( index));

			ptr.Set( ptr.Mid( index));

		}

		//read element id to TUint32 variable (policySystemid)

		TLex8 lex( elementId);

		lex.Val( policySystemid, EDecimal);		

		CElementBase * element = 0;

		if ( iAddToEditableCache )

		{

			element = iStorage->GetEditableElementL( policySystemid);

		}

		else

		{

			element = iStorage->GetElementL( policySystemid);

		}

		//add id element (element with id) to active element

		if ( element )

		{

			iActiveElement->AddIdElementL( element);

		}

		else

		{

			HandleNativeErrorL( KErrParser);

		}	

		//at least one element must be found

		atLeastOneId = ETrue;

	} 

	if ( !atLeastOneId)

	{

		HandleNativeErrorL( KErrParser);

	}

#endif //__POLICY_BASE_CREATOR_TOOL

}

// -----------------------------------------------------------------------------

// CPolicyParser::OnStartDocumentL()

// -----------------------------------------------------------------------------

//

void CPolicyParser::OnStartDocumentL(const Xml::RDocumentParameters& aDocParam, TInt /*aErrorCode*/)

{

	if ( aDocParam.CharacterSetName().DesC() == PolicyLanguage::XACML::CharacterSetUTF8)

	{

		iValidCharacterSet = ETrue;	

	}

}

// -----------------------------------------------------------------------------

// CPolicyParser::OnEndDocumentL()

// -----------------------------------------------------------------------------

//	

void CPolicyParser::OnEndDocumentL(TInt /*aErrorCode*/)

{

}

// -----------------------------------------------------------------------------

// CPolicyParser::OnStartElementL()

// -----------------------------------------------------------------------------

//		

void CPolicyParser::OnStartElementL(const Xml::RTagInfo& aElement, const Xml::RAttributeArray& aAttributes, TInt /*aErrorCode*/)

{

	//Debug variables