// Copyright (c) 2005-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:
// Name          : CSIPClientDataParser.cpp
// Part of       : SIP Client Resolver
// Version       : 1.0
//



#include "CSIPClientDataParser.h"
#include "CSIPClientData.h"
#include "SIPHeaderLookup.h"
#include "sipacceptcontactheader.h"
#include "CSIPFeatureSet.h"
#include "sdpdocument.h"
#include "sdpmediafield.h"
#include "sdpfmtattributefield.h"
#include "sdpattributefield.h"
#include "sipstrings.h"
#include "sipstrconsts.h"


// Constants for our XML DTD
_LIT8( KTagSIPClient, "SIP_CLIENT" );
_LIT8( KTagSIPHeaders, "SIP_HEADERS" );
_LIT8( KTagSDPLines, "SDP_LINES" );
_LIT8( KTagLine, "LINE" );
_LIT8( KTagLineM, "m" );
_LIT8( KTagRtpmap, "RTPMAP" );
_LIT8( KTagMediaAttribute, "MEDIA_ATTRIBUTE" );
_LIT8( KTagAccept, "ACCEPT" );
_LIT8( KTagAllowStarting, "ALLOW_STARTING" );
_LIT8( KTagAcceptContact, "ACCEPT_CONTACT" );
_LIT8( KTagAllowEvents, "ALLOW_EVENTS" );
_LIT8( KTagYes, "YES" );

_LIT8( KMimeTypeXml, "text/xml" );
_LIT8( KSdpMediaFieldStart, "m=" );
_LIT8( KSdpAttributeFieldStart, "a=" );
_LIT8( KRtpmapName, "rtpmap" );
_LIT8( KCrLf, "\r\n" );

const TInt KSdpLineAttrCount( 2 );

// -----------------------------------------------------------------------------
// CSIPClientDataParser::NewL
// -----------------------------------------------------------------------------
//
CSIPClientDataParser* CSIPClientDataParser::NewL()
	{
	CSIPClientDataParser* self = new( ELeave ) CSIPClientDataParser;
	CleanupStack::PushL( self );
	self->ConstructL();
	CleanupStack::Pop( self );
	return self;
	}

// -----------------------------------------------------------------------------
// CSIPClientDataParser::CSIPClientDataParser
// -----------------------------------------------------------------------------
//
CSIPClientDataParser::CSIPClientDataParser() 
 : iSIPHeaderLookupOpened (EFalse)
	{
	}

// -----------------------------------------------------------------------------
// CSIPClientDataParser::ConstructL
// -----------------------------------------------------------------------------
//
void CSIPClientDataParser::ConstructL()
	{
	iParser = Xml::CParser::NewL( KMimeTypeXml, *this );
	SIPHeaderLookup::OpenL();
	iSIPHeaderLookupOpened = ETrue;
	
    // Initialize XML strings
    RStringPool& stringPool = iParser->StringPool();
    iTagSIPClient = stringPool.OpenStringL(KTagSIPClient);
    iTagSIPHeaders = stringPool.OpenStringL(KTagSIPHeaders);
    iTagSDPLines = stringPool.OpenStringL(KTagSDPLines);
    iTagLine = stringPool.OpenStringL(KTagLine);
    iTagLineM = stringPool.OpenStringL(KTagLineM);
    iTagRtpmap = stringPool.OpenStringL(KTagRtpmap);
    iTagMediaAttribute = stringPool.OpenStringL(KTagMediaAttribute);
    iTagAccept = stringPool.OpenStringL(KTagAccept);
    iTagAllowStarting = stringPool.OpenStringL(KTagAllowStarting);
    iTagAcceptContact = stringPool.OpenStringL(KTagAcceptContact);
    iTagAllowEvents = stringPool.OpenStringL(KTagAllowEvents);
    iTagYes = stringPool.OpenStringL(KTagYes);
    
	// Initialize parser states
	iStateTransitions.AppendL(
	    TStateTransition(iTagSIPClient,EInit,ESIPClient));
	    
	iStateTransitions.AppendL(
	    TStateTransition(iTagSIPClient,ESIPClient,EInit,EFalse));
	
	iStateTransitions.AppendL(
	    TStateTransition(iTagSIPHeaders,ESIPClient,ESIPHeaders));
	
	iStateTransitions.AppendL(
	    TStateTransition(iTagSIPHeaders,ESIPHeaders,ESIPClient,EFalse));	

	iStateTransitions.AppendL(
	    TStateTransition(iTagAccept,ESIPHeaders,EAccept));
	
	iStateTransitions.AppendL(
	    TStateTransition(iTagAccept,EAccept,ESIPHeaders,EFalse));
	
	iStateTransitions.AppendL(
	    TStateTransition(iTagAcceptContact,ESIPHeaders,EAcceptContact));
	
	iStateTransitions.AppendL(
	    TStateTransition(iTagAcceptContact,EAcceptContact,ESIPHeaders,EFalse));
	
	iStateTransitions.AppendL(
	    TStateTransition(iTagAllowEvents,ESIPHeaders,EAllowEvents));
	    
	iStateTransitions.AppendL(
	    TStateTransition(iTagAllowEvents,EAllowEvents,ESIPHeaders,EFalse));
	
	iStateTransitions.AppendL(
	    TStateTransition(iTagSDPLines,ESIPClient,ESDPLines));

	iStateTransitions.AppendL(
	    TStateTransition(iTagSDPLines,ESDPLines,ESIPClient,EFalse));
	
	iStateTransitions.AppendL(
	    TStateTransition(iTagLine,ESDPLines,ELine));
	
	iStateTransitions.AppendL(
	    TStateTransition(iTagLine,ELine,ESDPLines,EFalse));
	    
	iStateTransitions.AppendL(
	    TStateTransition(iTagRtpmap,ELine,ERtpmap));
	    
	iStateTransitions.AppendL(
	    TStateTransition(iTagRtpmap,ERtpmap,ELine,EFalse));
	    
	iStateTransitions.AppendL(
	    TStateTransition(iTagMediaAttribute,ELine,EMediaAttribute));
	    
	iStateTransitions.AppendL(
	    TStateTransition(iTagMediaAttribute,EMediaAttribute,ELine,EFalse));	    	    
	}

// -----------------------------------------------------------------------------
// CSIPClientDataParser::~CSIPClientDataParser
// -----------------------------------------------------------------------------
//
CSIPClientDataParser::~CSIPClientDataParser()
	{
	iStateTransitions.Close();
    iTagYes.Close();
    iTagAllowEvents.Close();
    iTagAcceptContact.Close();
    iTagAllowStarting.Close();
    iTagAccept.Close();
    iTagMediaAttribute.Close();
    iTagLineM.Close();
    iTagRtpmap.Close();
    iTagLine.Close();
    iTagSDPLines.Close();
    iTagSIPHeaders.Close();
    iTagSIPClient.Close();
	if( iSIPHeaderLookupOpened )
		{
		SIPHeaderLookup::Close();
		}		
	delete iParser;
	}

// -----------------------------------------------------------------------------
// CSIPClientDataParser::ParseL
// -----------------------------------------------------------------------------
//
void CSIPClientDataParser::ParseL ( CSIPClientData* aClientData,
								    const TDesC8& aXmlDocument )
	{
    iState = EInit;
	iClientData = aClientData;

	// Parse the specified document into iClientData
	Xml::ParseL( *iParser, aXmlDocument );

	iClientData = NULL;
	}

// -----------------------------------------------------------------------------
// CSIPClientDataParser::OnStartElementL
// -----------------------------------------------------------------------------
//
void CSIPClientDataParser::OnStartElementL(
									const Xml::RTagInfo& aElement,
									const Xml::RAttributeArray& aAttributes,
									TInt /*aErrorCode*/ )
	{
	// Get element name (e.g. "SIP_CLIENT") and change state (Enter)
	ChangeStateL( aElement.LocalName(), ETrue );

	switch( iState )
		{
		case ESIPClient:
			{
			HandleSIPClientL( aAttributes );
			break;
			}
		case EAccept:
			{
			HandleSIPHeaderL( 
                SIPStrings::StringF(SipStrConsts::EAcceptHeader), 
                aAttributes );
			break;
			}
        case EAcceptContact:
            {
            HandleSIPHeaderL(
                SIPStrings::StringF(SipStrConsts::EAcceptContactHeader), 
                aAttributes );
            break;
            }
        case EAllowEvents:
            {
            HandleSIPHeaderL(
                SIPStrings::StringF(SipStrConsts::EAllowEventsHeader), 
                aAttributes );
            break;
            }
		case ELine:
			{
			HandleSdpLineL( aAttributes );
			break;
			}
		case ERtpmap:
			{
			HandleRtpmapL( aAttributes );
			break;
			}
		case EMediaAttribute:
			{
			HandleMediaAttributeL( aAttributes );
			break;
			}
		default:
			{
			// do nothing;
			break;
			}
		}
	}

// -----------------------------------------------------------------------------
// CSIPClientDataParser::OnEndElementL
// -----------------------------------------------------------------------------
//
void CSIPClientDataParser::OnEndElementL(
									const Xml::RTagInfo& aElement,
									TInt /*aErrorCode*/ )
	{
	// Get element name (e.g. "SIP_CLIENT") and change state (Exit)
	ChangeStateL( aElement.LocalName(), EFalse );
	}

// -----------------------------------------------------------------------------
// CSIPClientDataParser::ChangeStateL
// -----------------------------------------------------------------------------
//
void CSIPClientDataParser::ChangeStateL( const RString& aElementName,
										 TBool aEnter )
	{
	// Try to find a matching entry from the transitions table
	TInt count = iStateTransitions.Count();
	for( TInt i = 0; i < count; i++ )
		{
		const TStateTransition& transition = iStateTransitions[ i ];
		if( ( iState == transition.iState ) &&
			( aElementName == transition.iTag ) &&
			( aEnter == transition.iEnter ) )
			{
			// Match found, do transition
			iState = transition.iNextState;
			return;
			}
		}

	// No match was found, report error
	User::Leave( KErrCorrupt );
	}

// -----------------------------------------------------------------------------
// CSIPClientDataParser::HandleSIPClientL
// -----------------------------------------------------------------------------
//
void CSIPClientDataParser::HandleSIPClientL(
    const Xml::RAttributeArray& aAttributes )
	{
	// Verify that we have correct number of attributes
	__ASSERT_ALWAYS( aAttributes.Count() == 1, User::Leave( KErrCorrupt ) );
	
	// Verify that we have the correct attributes
	const RString& allowName = aAttributes[ 0 ].Attribute().LocalName();
	const RString& allowValue = aAttributes[ 0 ].Value();
	if( allowName != iTagAllowStarting )
		{
		User::Leave( KErrCorrupt );
		}
	iClientData->SetAllowStarting( ( allowValue == iTagYes ) );
	}

// -----------------------------------------------------------------------------
// CSIPClientDataParser::HandleSIPHeaderL
// -----------------------------------------------------------------------------
//
void CSIPClientDataParser::HandleSIPHeaderL(
    RStringF aHeaderName,
    const Xml::RAttributeArray& aAttributes )
	{
	// Verify that we have correct number of attributes
	if( aAttributes.Count() != 1 )
		{
		User::Leave( KErrCorrupt );
		}

	// Read header value
	const RString& value = aAttributes[ 0 ].Value();

	// Create SIP header object
	RPointerArray< CSIPHeaderBase > headers = 
	    SIPHeaderLookup::CreateHeaderL( aHeaderName, value.DesC() );
	// Add created headers to ClientData
	CSIPHeaderBase::PushLC( &headers );
	while( headers.Count() > 0 )
		{
		CSIPHeaderBase* header = headers[ 0 ];
		if ( header->Name() == 
		     SIPStrings::StringF(SipStrConsts::EAcceptContactHeader) )
		    {
		    CSIPAcceptContactHeader* acceptContact = 
		        static_cast< CSIPAcceptContactHeader* >( header );
		    iClientData->SIPFeatureSet().AddFeaturesL( *acceptContact );
		    delete header;
		    }
		else
		    {
		    iClientData->SIPHeaders().AppendL( header );
		    }
		headers.Remove( 0 );
		}
	CleanupStack::PopAndDestroy(); // headers
	}

// -----------------------------------------------------------------------------
// CSIPClientDataParser::HandleSdpLineL
// -----------------------------------------------------------------------------
//
void CSIPClientDataParser::HandleSdpLineL(
    const Xml::RAttributeArray& aAttributes )
	{
	// Verify that we have correct number of attributes
	if( aAttributes.Count() != KSdpLineAttrCount )
		{
		User::Leave( KErrCorrupt );
		}

	// Verify that we have the correct attribute(s)
	if( aAttributes[ 0 ].Value() != iTagLineM )
		{
		User::Leave( KErrCorrupt );
		}

	// Get attribute and convert to a form compatible with CSdpMediaField
	// (basically just surround the string with "m=" and "\r\n")
	TPtrC8 value( aAttributes[ 1 ].Value().DesC() );	                        
	HBufC8* mediaFieldBuf = CreateSdpFieldBufLC( KSdpMediaFieldStart, value );

	// Read and decode SDP media field to ClientData
	CSdpMediaField* mediaField = CSdpMediaField::DecodeLC( *mediaFieldBuf );
	iClientData->AddMediaFieldL( mediaField );
	CleanupStack::Pop( mediaField );
	
	CleanupStack::PopAndDestroy( mediaFieldBuf );
	}

// -----------------------------------------------------------------------------
// CSIPClientDataParser::HandleRtpmapL
// -----------------------------------------------------------------------------
//	
void CSIPClientDataParser::HandleRtpmapL(
    const Xml::RAttributeArray& aAttributes )
    {
    CSdpDocument& sdp = iClientData->SdpDocument();
    if( aAttributes.Count() != 1 || sdp.MediaFields().Count() == 0 )
        {
        User::Leave( KErrCorrupt );
        }
        
	// Get attribute and convert to a form compatible 
	// with CSdpfmtAttributeField
	// (basically just surround the string with "a=" and "\r\n")
	TPtrC8 value( aAttributes[ 0 ].Value().DesC() );
	HBufC8* fieldBuf = CreateSdpFieldBufLC( KSdpAttributeFieldStart, value );
	       
	// Decode and add rtpmap attribute field
    CSdpFmtAttributeField* attributeField = 
        CSdpFmtAttributeField::DecodeL( *fieldBuf );
    CleanupStack::PopAndDestroy( fieldBuf );
    CleanupStack::PushL( attributeField );    
        
    if( attributeField->Attribute().DesC().Compare( KRtpmapName ) != 0 )
        {
        User::Leave( KErrCorrupt );
        }
    
    // Add the rtpmap-attribute to the last added media field
    const TInt lastIndex = sdp.MediaFields().Count()-1;
    CSdpMediaField* lastMediaField = sdp.MediaFields()[ lastIndex ];
    lastMediaField->FormatAttributeFields().AppendL( attributeField );
    
    CleanupStack::Pop( attributeField );
    }

// -----------------------------------------------------------------------------
// CSIPClientDataParser::HandleMediaAttributeL
// -----------------------------------------------------------------------------
//
void CSIPClientDataParser::HandleMediaAttributeL( 
    const Xml::RAttributeArray& aAttributes )
    {
    CSdpDocument& sdp = iClientData->SdpDocument();
    if( aAttributes.Count() != 1 || sdp.MediaFields().Count() == 0 )
        {
        User::Leave( KErrCorrupt );
        }
        
	// Get attribute and convert to a form compatible with CSdpAttributeField
	// (basically just surround the string with "a=" and "\r\n")
	TPtrC8 value( aAttributes[ 0 ].Value().DesC() );
	HBufC8* fieldBuf = CreateSdpFieldBufLC( KSdpAttributeFieldStart, value );
	       
	// Decode and add attribute field
    CSdpAttributeField* attributeField = 
        CSdpAttributeField::DecodeL( *fieldBuf );
    CleanupStack::PopAndDestroy( fieldBuf );
    CleanupStack::PushL( attributeField );
    
    // Add the attribute to the last added media field
    const TInt lastIndex = sdp.MediaFields().Count()-1;
    CSdpMediaField* lastMediaField = sdp.MediaFields()[ lastIndex ];
    lastMediaField->AttributeFields().AppendL( attributeField );
    
    CleanupStack::Pop( attributeField );    
    }

// -----------------------------------------------------------------------------
// CSIPClientDataParser::CreateSdpFieldBufLC
// -----------------------------------------------------------------------------
//  
HBufC8* CSIPClientDataParser::CreateSdpFieldBufLC(
    const TDesC8& aFieldStart,
    const TDesC8& aValue )
    {
	TInt bufLength = aFieldStart.Length() + aValue.Length() + KCrLf().Length();
	HBufC8* buf = HBufC8::NewLC( bufLength );
	TPtr8 bufPtr = buf->Des();
	bufPtr.Copy( aFieldStart );
	bufPtr.Append( aValue );
	bufPtr.Append( KCrLf );
	return buf; 
    }