// 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:

// Name          : CSIPHeaderLookupTable.cpp

// Part of       : SIP Codec

// Version       : SIP/6.0 

//

#include "CSIPHeaderLookupTable.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "sipextensionheader.h"

#include "sipfromheader.h"

#include "siptoheader.h"

#include "sipcallidheader.h"

#include "sipcseqheader.h"

#include "CSIPContentLengthHeader.h"

#include "sipviaheader.h"

#include "sipcontactheader.h"

#include "sipcontenttypeheader.h"

#include "sipexpiresheader.h"

#include "sipmaxforwardsheader.h"

#include "sipminexpiresheader.h"

#include "siprecordrouteheader.h"

#include "siprouteheader.h"

#include "sipservicerouteheader.h"

#include "siprequireheader.h"

#include "sipcontentencodingheader.h"

#include "sipproxyrequireheader.h"

#include "sipsupportedheader.h"

#include "sipunsupportedheader.h"

#include "sipallowheader.h"

#include "siprefertoheader.h"

#include "sipsecurityclientheader.h"

#include "sipsecurityserverheader.h"

#include "sipsecurityverifyheader.h"

#include "sipacceptheader.h"

#include "sipacceptlanguageheader.h"

#include "sipacceptencodingheader.h"

#include "sipauthenticationinfoheader.h"

#include "sipcontentdispositionheader.h"

#include "sipsubscriptionstateheader.h"

#include "sipeventheader.h"

#include "sipalloweventsheader.h"

#include "sipauthorizationheader.h"

#include "sipproxyauthenticateheader.h"

#include "sipproxyauthorizationheader.h"

#include "sipwwwauthenticateheader.h"

#include "sipreplytoheader.h"

#include "siprackheader.h"

#include "siprseqheader.h"

#include "siptimestampheader.h"

#include "sipretryafterheader.h"

#include "sipacceptcontactheader.h"

#include "sippaccessnetworkinfoheader.h"

#include "sippassociateduriheader.h"

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

// CSIPHeaderLookupTable::NewL

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

//

CSIPHeaderLookupTable* CSIPHeaderLookupTable::NewL ()

	{

	CSIPHeaderLookupTable* self = CSIPHeaderLookupTable::NewLC();

	CleanupStack::Pop(self);

	return self;

	} 

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

// CSIPHeaderLookupTable::NewLC

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

//

CSIPHeaderLookupTable* CSIPHeaderLookupTable::NewLC()

	{

	CSIPHeaderLookupTable* self = new(ELeave)CSIPHeaderLookupTable;

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

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

// CSIPHeaderLookupTable::CSIPHeaderLookupTable

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

//

CSIPHeaderLookupTable::CSIPHeaderLookupTable()

 : iUsageCount(1), iConvertToSIPURI(EFalse)

	{

	}

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

// CSIPHeaderLookupTable::ConstructL

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

//

void CSIPHeaderLookupTable::ConstructL()

    {

    // CSIPViaHeader:

    AddL (SIPStrings::StringF(SipStrConsts::EViaHeader),

          SIPStrings::StringF(SipStrConsts::EViaHeaderCompact),

          &CSIPViaHeader::BaseDecodeL);

	// CSIPRouteHeader: 

    AddL (SIPStrings::StringF(SipStrConsts::ERouteHeader),

	      &CSIPRouteHeader::BaseDecodeL,

          &CSIPRouteHeader::InternalizeValueL);

	// CSIPRecordRouteHeader: 

    AddL (SIPStrings::StringF(SipStrConsts::ERecordRouteHeader),

	      &CSIPRecordRouteHeader::BaseDecodeL);

	// CSIPServiceRouteHeader: 

    AddL (SIPStrings::StringF(SipStrConsts::EServiceRouteHeader),

	      &CSIPServiceRouteHeader::BaseDecodeL);

	// CSIPFromHeader:

    AddL (SIPStrings::StringF(SipStrConsts::EFromHeader),

          SIPStrings::StringF(SipStrConsts::EFromHeaderCompact),

          &CSIPFromHeader::BaseDecodeL,

          &CSIPFromHeader::InternalizeValueL);

	// CSIPToHeader:

	AddL (SIPStrings::StringF(SipStrConsts::EToHeader),

          SIPStrings::StringF(SipStrConsts::EToHeaderCompact),

          &CSIPToHeader::BaseDecodeL,

          &CSIPToHeader::InternalizeValueL);

	// CSIPCallIDHeader: 

    AddL (SIPStrings::StringF(SipStrConsts::ECallIDHeader),

          SIPStrings::StringF(SipStrConsts::ECallIDHeaderCompact),

          &CSIPCallIDHeader::BaseDecodeL);

	// CSIPCSeqHeader: 

	AddL (SIPStrings::StringF(SipStrConsts::ECSeqHeader),

	      &CSIPCSeqHeader::BaseDecodeL,

	      &CSIPCSeqHeader::InternalizeValueL);

	// CSIPContactHeader:

    AddL (SIPStrings::StringF(SipStrConsts::EContactHeader),

          SIPStrings::StringF(SipStrConsts::EContactHeaderCompact),	

          &CSIPContactHeader::BaseDecodeL,

          &CSIPContactHeader::InternalizeValueL);

	// CSIPExpiresHeader: 

    AddL (SIPStrings::StringF(SipStrConsts::EExpiresHeader),

          &CSIPExpiresHeader::BaseDecodeL,

          &CSIPExpiresHeader::InternalizeValueL);

	// CSIPMinExpiresHeader: 

	AddL (SIPStrings::StringF(SipStrConsts::EMinExpiresHeader),

	      &CSIPMinExpiresHeader::BaseDecodeL);

	// CSIPMaxForwardsHeader:

	AddL (SIPStrings::StringF(SipStrConsts::EMaxForwardsHeader),

	      &CSIPMaxForwardsHeader::BaseDecodeL);

	// CSIPContentTypeHeader:

	AddL (SIPStrings::StringF(SipStrConsts::EContentTypeHeader),

          SIPStrings::StringF(SipStrConsts::EContentTypeHeaderCompact),

          &CSIPContentTypeHeader::BaseDecodeL,

          &CSIPContentTypeHeader::InternalizeValueL);

	// CSIPContentLengthHeader: 

	AddL (SIPStrings::StringF(SipStrConsts::EContentLengthHeader),

          SIPStrings::StringF(SipStrConsts::EContentLengthHeaderCompact),

          &CSIPContentLengthHeader::BaseDecodeL);

	// CSIPContentEncodingHeader:

	AddL (SIPStrings::StringF(SipStrConsts::EContentEncodingHeader),

	      SIPStrings::StringF(SipStrConsts::EContentEncodingHeaderCompact),

          &CSIPContentEncodingHeader::BaseDecodeL,

          &CSIPContentEncodingHeader::InternalizeValueL);

    // CSIPAllowHeader:

	AddL (SIPStrings::StringF(SipStrConsts::EAllowHeader),

	      &CSIPAllowHeader::BaseDecodeL,

          &CSIPAllowHeader::InternalizeValueL);

	// CSIPSupportedHeader:

	AddL (SIPStrings::StringF(SipStrConsts::ESupportedHeader),

	      SIPStrings::StringF(SipStrConsts::ESupportedHeaderCompact),

          &CSIPSupportedHeader::BaseDecodeL,

          &CSIPSupportedHeader::InternalizeValueL);

    // CSIPUnsupportedHeader:

	AddL (SIPStrings::StringF(SipStrConsts::EUnsupportedHeader),

	      &CSIPUnsupportedHeader::BaseDecodeL,

          &CSIPUnsupportedHeader::InternalizeValueL);

	// CSIPRequireHeader: 

	AddL (SIPStrings::StringF(SipStrConsts::ERequireHeader),

	      &CSIPRequireHeader::BaseDecodeL,

          &CSIPRequireHeader::InternalizeValueL);

	// CSIPProxyRequireHeader:

	AddL (SIPStrings::StringF(SipStrConsts::EProxyRequireHeader),

	      &CSIPProxyRequireHeader::BaseDecodeL,

          &CSIPProxyRequireHeader::InternalizeValueL);

	// CSIPReferToHeader:

	AddL (SIPStrings::StringF(SipStrConsts::EReferToHeader),

	      SIPStrings::StringF(SipStrConsts::EReferToHeaderCompact),

          &CSIPReferToHeader::BaseDecodeL,

          &CSIPReferToHeader::InternalizeValueL);        

    // CSIPSecurityClientHeader:

	AddL (SIPStrings::StringF(SipStrConsts::ESecurityClientHeader),

	      &CSIPSecurityClientHeader::BaseDecodeL,

          &CSIPSecurityClientHeader::InternalizeValueL);

    // CSIPSecurityServerHeader:

	AddL (SIPStrings::StringF(SipStrConsts::ESecurityServerHeader),

	      &CSIPSecurityServerHeader::BaseDecodeL);          

    // CSIPSecurityVerifyHeader:

	AddL (SIPStrings::StringF(SipStrConsts::ESecurityVerifyHeader),

	      &CSIPSecurityVerifyHeader::BaseDecodeL);

	// CSIPAuthenticationInfoHeader:

	AddL (SIPStrings::StringF(SipStrConsts::EAuthenticationInfoHeader),

          &CSIPAuthenticationInfoHeader::BaseDecodeL);

	// CSIPAcceptHeader:

    AddL (SIPStrings::StringF(SipStrConsts::EAcceptHeader),

          &CSIPAcceptHeader::BaseDecodeL,

          &CSIPAcceptHeader::InternalizeValueL);

	// CSIPAcceptEncodingHeader:

    AddL (SIPStrings::StringF(SipStrConsts::EAcceptEncodingHeader),

          &CSIPAcceptEncodingHeader::BaseDecodeL,

          &CSIPAcceptEncodingHeader::InternalizeValueL);

	// CSIPAcceptLanguageHeader:

	AddL (SIPStrings::StringF(SipStrConsts::EAcceptLanguageHeader),

	      &CSIPAcceptLanguageHeader::BaseDecodeL,

          &CSIPAcceptLanguageHeader::InternalizeValueL);          

	// CSIPContentDispositionHeader:

	AddL (SIPStrings::StringF(SipStrConsts::EContentDispositionHeader),

          &CSIPContentDispositionHeader::BaseDecodeL,

          &CSIPContentDispositionHeader::InternalizeValueL);

	// CSIPSubscriptionStateHeader:

	AddL (SIPStrings::StringF(SipStrConsts::ESubscriptionStateHeader),

          &CSIPSubscriptionStateHeader::BaseDecodeL,

          &CSIPSubscriptionStateHeader::InternalizeValueL);

	// CSIPAllowEventsHeader:

	AddL (SIPStrings::StringF(SipStrConsts::EAllowEventsHeader),

	      SIPStrings::StringF(SipStrConsts::EAllowEventsHeaderCompact),

          &CSIPAllowEventsHeader::BaseDecodeL,

          &CSIPAllowEventsHeader::InternalizeValueL);

	// CSIPEventHeader:

	AddL (SIPStrings::StringF(SipStrConsts::EEventHeader),

	      SIPStrings::StringF(SipStrConsts::EEventHeaderCompact),

          &CSIPEventHeader::BaseDecodeL,

          &CSIPEventHeader::InternalizeValueL);

    // CSIPAuthorizationHeader:      

	AddL (SIPStrings::StringF(SipStrConsts::EAuthorizationHeader),

          &CSIPAuthorizationHeader::BaseDecodeL,

          &CSIPAuthorizationHeader::InternalizeValueL);

    // CSIPProxyAuthenticateHeader:      

	AddL (SIPStrings::StringF(SipStrConsts::EProxyAuthenticateHeader),

          &CSIPProxyAuthenticateHeader::BaseDecodeL,

          &CSIPProxyAuthenticateHeader::InternalizeValueL);

    // CSIPProxyAuthorizationHeader:      

	AddL (SIPStrings::StringF(SipStrConsts::EProxyAuthorizationHeader),

          &CSIPProxyAuthorizationHeader::BaseDecodeL,

          &CSIPProxyAuthorizationHeader::InternalizeValueL);

    // CSIPWWWAuthenticateHeader:      

	AddL (SIPStrings::StringF(SipStrConsts::EWWWAuthenticateHeader),

          &CSIPWWWAuthenticateHeader::BaseDecodeL,

          &CSIPWWWAuthenticateHeader::InternalizeValueL);

	// CSIPReplyToHeader:

	AddL (SIPStrings::StringF(SipStrConsts::EReplyToHeader),

          &CSIPReplyToHeader::BaseDecodeL,

          &CSIPReplyToHeader::InternalizeValueL);        

    // CSIPRAckHeader:

	AddL (SIPStrings::StringF(SipStrConsts::ERAckHeader),

          &CSIPRAckHeader::BaseDecodeL,

          &CSIPRAckHeader::InternalizeValueL);        

    // CSIPRSeqHeader:

	AddL (SIPStrings::StringF(SipStrConsts::ERSeqHeader),

          &CSIPRSeqHeader::BaseDecodeL,

          &CSIPRSeqHeader::InternalizeValueL);        

    // CSIPTimestampHeader:

	AddL (SIPStrings::StringF(SipStrConsts::ETimestampHeader),

          &CSIPTimestampHeader::BaseDecodeL,

          &CSIPTimestampHeader::InternalizeValueL);        

    // CSIPRetryAfterHeader:

	AddL (SIPStrings::StringF(SipStrConsts::ERetryAfterHeader),

          &CSIPRetryAfterHeader::BaseDecodeL,

          &CSIPRetryAfterHeader::InternalizeValueL); 

	// CSIPAcceptContactHeader:

	AddL (SIPStrings::StringF(SipStrConsts::EAcceptContactHeader),

          SIPStrings::StringF(SipStrConsts::EAcceptContactHeaderCompact),

          &CSIPAcceptContactHeader::BaseDecodeL,

          &CSIPAcceptContactHeader::InternalizeValueL);

    // CSIPPAccessNetworkInfoHeader:

	AddL (SIPStrings::StringF(SipStrConsts::EPAccessNetworkInfoHeader),

          &CSIPPAccessNetworkInfoHeader::BaseDecodeL); 

    // CSIPPAssociatedURIHeader:

	AddL (SIPStrings::StringF(SipStrConsts::EPAssociatedURIHeader),

          &CSIPPAssociatedURIHeader::BaseDecodeL,

          &CSIPPAssociatedURIHeader::InternalizeValueL); 

	}

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

// CSIPHeaderLookupTable::~CSIPHeaderLookupTable

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

//

CSIPHeaderLookupTable::~CSIPHeaderLookupTable ()

	{

	iLookupTable.Close();

	}

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

// CSIPHeaderLookupTable::IsSupported

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

//

TBool CSIPHeaderLookupTable::IsSupported (RStringF aName) const

	{

	return (FindIndex(aName) >= 0);

	}

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

// CSIPHeaderLookupTable::InternalizeL

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

//

CSIPHeaderBase* CSIPHeaderLookupTable::InternalizeL (RStringF aName,

									                 RReadStream& aReadStream)

	{

	__ASSERT_ALWAYS(aName.DesC().Length() > 0, User::Leave(KErrArgument));

	TInt index = FindIndex(aName);

	if (index >= 0) // a supported header found

		{

		return iLookupTable[index].InternalizeL(aReadStream);

		}

	// a supported header not found, internalize extension header instead

	CSIPExtensionHeader* extensionHeader =

		CSIPExtensionHeader::InternalizeValueL(aReadStream);

	CleanupStack::PushL (extensionHeader);

	extensionHeader->SetNameL(aName.DesC());

	CleanupStack::Pop(extensionHeader);

	return extensionHeader;

	}

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

// CSIPHeaderLookupTable::InternalizeSupported

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

//

TBool CSIPHeaderLookupTable::InternalizeSupported (RStringF aName) const

    {

    TBool isSupported=EFalse;

    TInt index = FindIndex (aName);

    if (index >= 0)

        {

        isSupported = iLookupTable[index].InternalizeSupported();

        }

    return isSupported;

    }

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

// CSIPHeaderLookupTable::CreateHeaderL

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

//

RPointerArray<CSIPHeaderBase> 

CSIPHeaderLookupTable::CreateHeaderL (RStringF aName,

									  const TDesC8& aValue)

	{

	__ASSERT_ALWAYS(aName.DesC().Length() > 0, User::Leave(KErrArgument));

	TInt index = FindIndex(aName);

	if (index >= 0) // a supported header found

		{

		return iLookupTable[index].DecodeL(aValue);

		}

	// a supported header not found, create extension header instead

	RPointerArray<CSIPHeaderBase> headerArray;

	CSIPHeaderBase* header = CSIPExtensionHeader::NewLC(aName.DesC(),aValue);

	headerArray.AppendL(header);

	CleanupStack::Pop(header);

	return headerArray;

	}

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

// CSIPHeaderLookupTable::IncrementUsageCount

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

//

void CSIPHeaderLookupTable::IncrementUsageCount()

	{

	iUsageCount++;

	}

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

// CSIPHeaderLookupTable::DecrementUsageCount

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

//

void CSIPHeaderLookupTable::DecrementUsageCount()

	{

	iUsageCount--;

	}

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

// CSIPHeaderLookupTable::UsageCount

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

//

TUint CSIPHeaderLookupTable::UsageCount()

	{

	return iUsageCount;

	}

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

// CSIPHeaderLookupTable::AddL

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

//

void CSIPHeaderLookupTable::AddL(RStringF aFullName,

                                 RPointerArray<CSIPHeaderBase>(*aDecode)(const TDesC8&),

                                 CSIPHeaderBase*(*aInternalize)(RReadStream&))

    {

	TSIPHeaderLookupEntry entry(aFullName,aDecode,aInternalize);

	User::LeaveIfError (iLookupTable.Append(entry));

    }

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

// CSIPHeaderLookupTable::AddL

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

//

void CSIPHeaderLookupTable::AddL(RStringF aFullName,

                                 RStringF aCompactName,

                                 RPointerArray<CSIPHeaderBase>(*aDecode)(const TDesC8&),

                                 CSIPHeaderBase*(*aInternalize)(RReadStream&))

    {

	TSIPHeaderLookupEntry entry (aFullName,aCompactName,aDecode,aInternalize);

	User::LeaveIfError (iLookupTable.Append(entry));

    }

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

// CSIPHeaderLookupTable::FindIndex

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

//

TInt CSIPHeaderLookupTable::FindIndex(RStringF aName) const

	{

	for (TInt index=0; index < iLookupTable.Count(); index++)

		{

		TSIPHeaderLookupEntry lookupEntry = iLookupTable[index];

		if (aName == lookupEntry.Name() || 

		    aName == lookupEntry.CompactName())

			{

			return index;

			}

		}

	return KErrNotFound;

	}

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

// CSIPHeaderLookupTable::ConvertToSIPURI

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

//

TBool CSIPHeaderLookupTable::ConvertToSIPURI()

    {

    return iConvertToSIPURI;

    }

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

// CSIPHeaderLookupTable::SetConvertToSIPURI

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

//

void CSIPHeaderLookupTable::SetConvertToSIPURI(TBool aNewValue)

    {

    iConvertToSIPURI = aNewValue;

    }