/*

* Copyright (c) 2007 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:  Location Centre Server object.

*

*/

// INCLUDE FILES

#include <Xml/Parser.h>

#include <Xml/MatchData.h>

#include <utf.h>

#include <Xml/XmlParserErrors.h>

#include <javaregistryincludes.h>

// USER INCLUDE

#include "lcregistrationparser.h"

#include "lcregxmltaginfo.h"

#include "lcregxmlparserutils.h"

#include "lcregxmltagtype.h"

#include "lcregappinfo.h"

#include "lcdebug.h"

// CONSTANTS

/**

 *  Maximum length of UUID of a service can be

 */

const TInt KUUIDMaxLength = 1028;

const TInt KMaxLangCodeLen = 2;

// ============================ MEMBER FUNCTIONS ===============================

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

// CLcRegistrationParser::CLcRegistrationParser

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CLcRegistrationParser::CLcRegistrationParser( RFs& aFs ):

	iFs( aFs )

    {

    iParserError = KErrNone;

    }

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

// CPosLmXmlEncoder::NewL

// Two-phased constructor.

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

//

CLcRegistrationParser* CLcRegistrationParser::NewL( RFs& aFs )

    {

	CLcRegistrationParser* self = new( ELeave ) CLcRegistrationParser( aFs );    

	return self;

    }

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

// CLcRegistrationParser::~CLcRegistrationParser()

// Destructor.

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

//

CLcRegistrationParser::~CLcRegistrationParser()

    {

    delete iReadContent;

    iParserTreeTags.Reset();

    iParserTreeTags.Close();

    }

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

// CLcRegistrationParser::ParseFileL

//

// (other items were commented in a header).

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

//

CLcRegAppInfo* CLcRegistrationParser::ParseFileL( const TDesC& aFile )

    {

    DEBUG("+ CLcRegistrationParser::ParseFileL" )

    CLcRegAppInfo* regAppInfo = CLcRegAppInfo::NewL();

    CleanupStack::PushL( regAppInfo ); 

	HBufC* attributeBuf = HBufC::NewLC( KUUIDMaxLength );

	iRegAppInfo = regAppInfo;

    iAttributeBuf = attributeBuf;

    // Check the file name here.

    if( aFile.Length() <= KMaxFileName )

	    {

    	iFileName.Copy( aFile );	    	

	    }

	else

		{

		DEBUG("Error : Bad file name")

		User::Leave( KErrBadName );	

		}

    iParserTreeTags.Reset();

	iParsingTag = ELcXmlNothing;

	iParsedTag = ELcXmlNothing;

	_LIT8(KXmlMimeType, "text/xml");

    // Create Symbian XML parser

	// Create parser

    Xml::CParser* iRegParser = Xml::CParser::NewLC( KXmlMimeType, *this );

    iRegParser->ParseBeginL();

    // check the error code return from the parser

	Xml::ParseL( *iRegParser, iFs, aFile );

	// Leave here if Parser framework found some error

	User::LeaveIfError( iParserError );

	CleanupStack::PopAndDestroy( 2, attributeBuf );

	CleanupStack::Pop( regAppInfo );

    DEBUG("- CLcRegistrationParser::ParseFileL" )	

	return regAppInfo;		

	}

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

// CLcRegistrationParser::OnStartDocumentL

//

// (other items were commented in a header).

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

//

void CLcRegistrationParser::OnStartDocumentL(

    const Xml::RDocumentParameters& /*aDocParam*/,

    TInt /*aErrorCode*/)

    {

    }

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

// CLcRegistrationParser::OnEndDocumentL

//

// (other items were commented in a header).

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

//

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

    {

    }

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

// CLcRegistrationParser::OnStartElementL

//

// (other items were commented in a header).

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

//

void CLcRegistrationParser::OnStartElementL(

    const Xml::RTagInfo& aElement,

    const Xml::RAttributeArray& aAttributes,

    TInt /*aErrorCode*/ )

    {

    DEBUG("+ CLcRegistrationParser::OnStartElementL" )

    delete iReadContent;

    iReadContent = NULL;

	// get the tag name and validate it

    TLcRegXmlTagType startTag =

        TLcRegXmlTagInfo::TagTypeL( aElement.LocalName().DesC() );

	if( startTag == ELcXmlUnknown )

		{

		User::Leave( KErrNotSupported );	

		}

    SetParserTagL( startTag );

    // Check parser status

    CheckMandatoryTagsL( EXmlParserOnStartElement, startTag );

	//Collect attribute value for element

	CollectAttributeValueL( aElement, aAttributes );

    DEBUG("- CLcRegistrationParser::OnStartElementL" )	

    }

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

// CLcRegistrationParser::SetParserTagL

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

//

void CLcRegistrationParser::SetParserTagL( TLcRegXmlTagType aTag )

    {

    DEBUG("+ CLcRegistrationParser::SetParserTagL" )

	if( !iParserTreeTags.Count() )

		{

		if( aTag == ELcXmlLocationCentreRegistration )

			{

			iParserTreeTags.Append( aTag );				

			}

		else

			{

			DEBUG("CLcRegistrationParser::SetParserTagL Not Supported" )

			User::Leave( KErrNotSupported );				

			}			

		}

	else

		{

		if( iParserTreeTags.Find( aTag ) == KErrNotFound )

			{

			User::LeaveIfError( iParserTreeTags.Append( aTag ) );

			CheckSequenceOrderL( aTag );

			}

		else

			{

			User::Leave( EXmlRecursiveEntity );	

			}			

		}		

    DEBUG("- CLcRegistrationParser::SetParserTagL" )				

    }

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

// CLcRegistrationParser::CheckSequenceOrderL

//

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

//

void CLcRegistrationParser::CheckSequenceOrderL( TLcRegXmlTagType aTag )

    {

    DEBUG("+ CLcRegistrationParser::CheckSequenceOrderL" )

    switch ( aTag )

        {

        case ELcXmlLocationCentreRegistration:

	        {

	        if( iParserTreeTags.Count() > 1 )

		        {

				User::Leave( KErrNotSupported );		        	

		        }

	        break;

	        }

		case ELcXmlService:

			{

			if( iParserTreeTags.Count()  != 1 &&

				iParserTreeTags.Find( ELcXmlLocationCentreRegistration ) == KErrNotFound )

				{

				User::Leave( KErrNotSupported );	

				}

			break;	

			}

        case ELcXmlRegFileName:

        case ELcXmlFileIcon:

        case ELcXmlFeature:

        case ELcXmlRunMode:

        case ELcXmlWebService:

        case ELcXmlDocument:

        case ELcXmlApplication:

	        {

	        if( iParserTreeTags[1] != ELcXmlService )

		        {

				User::Leave( KErrNotSupported );		        	

		        }

	        break;

	        }

		case ELcXmlApplicationNative:

        case ELcXmlApplicationJava:

        case ELcXmlApplicationParams:

	        {

	        if( iParserTreeTags.Find( ELcXmlApplication ) == KErrNotFound  ||

	        	iParserTreeTags[1] != ELcXmlService  

	        	)

		        {

				User::Leave( KErrNotSupported );		        	

		        }

	        break;

	        }	        	        

        default:

            break;

        }

    DEBUG("- CLcRegistrationParser::CheckSequenceOrderL" )        

    }

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

// CLcRegistrationParser::CheckMandatoryTagsL

//

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

//

void CLcRegistrationParser::CheckMandatoryTagsL(

    TXmlParserElementState aXmlState,

    TLcRegXmlTagType aTag )

    {

    DEBUG("+ CLcRegistrationParser::CheckMandatoryTagsL" )

    if ( aXmlState == EXmlParserOnStartElement ) 

        {

        switch ( aTag )

            {

            case ELcXmlApplication:

	            {

	            if( iParsedTag != ELcXmlRunMode )

		            {

		            User::Leave( KErrNotSupported );	

		            }

				iParsingTag = ELcXmlApplication;		            

	            }

	            break;	

            case ELcXmlWebService:

            case ELcXmlDocument:

	            {

	            if( iParsedTag != ELcXmlRunMode )

		            {

		            User::Leave( KErrNotSupported );	

		            }

	            }

	            break;	

            case ELcXmlApplicationNative:

            case ELcXmlApplicationJava:

            case ELcXmlApplicationParams:

	            {

	            if( iParsingTag != ELcXmlApplication )

		            {

		            User::Leave( KErrNotSupported );	

		            }

	            break;	

	            }

            default:

                break;

            }

        }

    else

        {

        // aXmlState == EXmlParserOnEndElement

        TInt count = iParserTreeTags.Count();

        if( count > 0 )

	        {

	        switch ( aTag )

	            {

	            case ELcXmlLocationCentreRegistration:

		            {

		            if( iParsedTag != ELcXmlService )

			            {

			            User::Leave( KErrNotSupported );	

			            }

		            break;	

		            }

	            case ELcXmlService:

		            {

		            if( iParsedTag != ELcXmlApplication )

			            {

			            if( iParsedTag != ELcXmlDocument )

				            {

				            if( iParsedTag != ELcXmlWebService )

					            {

					            User::Leave( KErrNotSupported );	

					            }

				            }

			            }

		            iParsedTag = ELcXmlService;

		            break;	

		            }

	            case ELcXmlRunMode:

		            {

		            iParsedTag = ELcXmlRunMode;

		            break;	

		            }

	            case ELcXmlWebService:

		            {

		            iParsedTag = ELcXmlWebService;

		            break;	

		            }

	            case ELcXmlDocument:

		            {

		            iParsedTag = ELcXmlDocument;

		            break;	

		            }

	            case ELcXmlApplication:

		            {

		            iParsedTag = ELcXmlApplication;

		            break;	

		            }

	            default:

	                break;

	            }

	        iParserTreeTags.Remove( count-1 );

	        }

        }

    DEBUG("- CLcRegistrationParser::CheckMandatoryTagsL" )        

    }

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

// CLcRegistrationParser::CheckAndReturnValidAttrL

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

//

TLcRegXmlTagType CLcRegistrationParser::CheckAndReturnValidAttrL(

	TLcRegXmlTagType aElement,

	const Xml::RAttributeArray& aAttributes )

	{

	DEBUG("+ CLcRegistrationParser::CheckAndReturnValidAttrL" )

    TInt count( aAttributes.Count() );	

	switch( aElement )

		{

		case ELcXmlLocationCentreRegistration:

		case ELcXmlFeature:

		case ELcXmlApplication:

		case ELcXmlApplicationParams:				

			{

			if( count != 0 )

				{

				User::Leave( KErrNotSupported );	

				}

			break;	

			}		

		case ELcXmlService:

		case ELcXmlRegFileName:

		case ELcXmlRunMode:

		case ELcXmlWebService:

		case ELcXmlDocument:

		case ELcXmlApplicationNative:

		case ELcXmlApplicationJava:

			{

			// If all the above element's doesn't have any attribute

			// invalid registration file.

			if( count == 0 ||

				count > 1 )

				{

				User::Leave( KErrNotSupported );	

				}

			break;

			}

		case ELcXmlFileIcon:

			{

			// If all the above element's doesn't have any attribute

			// invalid registration file.

			if( count != 2 )

				{

				User::Leave( KErrNotSupported );	

				}

			break;

			}	

		default:

			break;			

		}

    // Checking attribute name validity    

    TLcRegXmlTagType tagAttr = ELcXmlUnknown;

    // validate the attribute name.        

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

        {

        tagAttr =

            TLcRegXmlTagInfo::TagAttrTypeL( aElement,

            			aAttributes[i].Attribute().LocalName().DesC() );

        // Check the tag attribute value 

        // if it is not according to XML schema then it's a invalid registration file    

    	if( aElement > ELcXmlApplicationParams && tagAttr == ELcXmlUnknown )

    		{

    		User::Leave( KErrNotSupported );	

    		}

        }

    DEBUG("- CLcRegistrationParser::CheckAndReturnValidAttrL" )

	return tagAttr;        

	}

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

// CLcRegistrationParser::CollectAttributeValueL

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

//

void CLcRegistrationParser::CollectAttributeValueL(

    const Xml::RTagInfo& aElement,

    const Xml::RAttributeArray& aAttributes )

    {

    DEBUG("+ CLcRegistrationParser::CollectAttributeValueL")

    TInt count( aAttributes.Count() );

    TParse parse;

    TBuf<KMaxFileName> fileName( iFileName );

    TLcRegXmlTagType tag =

        TLcRegXmlTagInfo::TagTypeL( aElement.LocalName().DesC() );

	// Check if the element's defiened in XML registration API

	// schema have any valid attribute if no attribute and attribute

	// is not valid one then don't registered.

	TLcRegXmlTagType tagAttr = CheckAndReturnValidAttrL( tag, aAttributes );

    DEBUG1(" Tag : %d", tagAttr)

    // If validity done then collect attributa value    

	switch ( tagAttr )

		{

		case ELcXmlServiceAttrUuid:

			{

            TPtrC8 uidValue( aAttributes[0].Value().DesC() );

            if( uidValue.Length() > KUUIDMaxLength ||

                uidValue.Length() <= 0 )

	            {

	            User::Leave( KErrNotSupported );	

	            }

			iAttributeBuf->Des().Copy( uidValue );	

            iRegAppInfo->SetIdL( *iAttributeBuf );

			}

		    break;

		case ELcXmlRegFileNameAttrLang:

			{

            TPtrC8 langValue( aAttributes[0].Value().DesC() );

            if( langValue.Length() > KMaxLangCodeLen )

	            {

	            User::Leave( KErrNotSupported );	

	            }

            iAttributeBuf->Des().Copy( langValue );

            User::LeaveIfError( iRegAppInfo->SetNameLanguage( *iAttributeBuf ) );

			}

		    break;

		case ELcXmlFileIconAttrfile:

		case ELcXmlFileIconAttrFrame:

			{

			// Set the file name and type

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

				{

				if( !aAttributes[i].Attribute().LocalName().DesC().Compare( KLcXmlFileIconAttrfile ) )	

					{

		            TPtrC8 iconfile( aAttributes[i].Value().DesC() );

		            if( iconfile.Length() > KMaxFileName )