// Copyright (c) 2004-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          : CSIPURIHeaders.cpp
// Part of       : SIP Codec
// Version       : SIP/4.0 
//



#include "CSIPURIHeaders.h"
#include "CSIPTokenizer.h"
#include "CSIPParam.h"
#include "sipcodecerr.h"
#include "TSIPChar.h"

// -----------------------------------------------------------------------------
// CSIPURIHeaders::DecodeL
// -----------------------------------------------------------------------------
//
CSIPURIHeaders* CSIPURIHeaders::DecodeL (const TDesC8& aValue)
	{
	__ASSERT_ALWAYS (aValue.Length() > 0, User::Leave(KErrSipCodecURIHeaders));

	CSIPURIHeaders* headers = new(ELeave)CSIPURIHeaders;
	CleanupStack::PushL (headers);
	CSIPTokenizer* tokenizer = CSIPTokenizer::NewLC(aValue,'&');
	for (TInt i=0; i < tokenizer->Tokens().Count(); i++)
		{
		CSIPParam* header = CSIPParam::DecodeL(tokenizer->Tokens()[i]);
		CleanupStack::PushL(header);
		headers->AddHeaderL(header);
		CleanupStack::Pop(header);
		}
	CleanupStack::PopAndDestroy(tokenizer);
	CleanupStack::Pop(); // headers
	return headers;
	}

// -----------------------------------------------------------------------------
// CSIPURIHeaders::NewL
// -----------------------------------------------------------------------------
//
CSIPURIHeaders* CSIPURIHeaders::NewL (const CSIPURIHeaders& aHeaders)
	{
	CSIPURIHeaders* self = CSIPURIHeaders::NewLC (aHeaders);
	CleanupStack::Pop(self);
	return self;
	}

// -----------------------------------------------------------------------------
// CSIPURIHeaders::NewLC
// -----------------------------------------------------------------------------
//
CSIPURIHeaders* CSIPURIHeaders::NewLC (const CSIPURIHeaders& aHeaders)
	{
	CSIPURIHeaders* self = new(ELeave)CSIPURIHeaders;
	CleanupStack::PushL(self);
	self->ConstructL (aHeaders);
	return self;
	}	

// -----------------------------------------------------------------------------
// CSIPURIHeaders::CSIPURIHeaders
// -----------------------------------------------------------------------------
//
CSIPURIHeaders::CSIPURIHeaders ()
	{
	}

// -----------------------------------------------------------------------------
// CSIPURIHeaders::ConstructL
// -----------------------------------------------------------------------------
//
void CSIPURIHeaders::ConstructL (const CSIPURIHeaders& aHeaders)
	{
	for (TInt i=0; i < aHeaders.iHeaders.Count(); i++)
		{
		CSIPParam* header = CSIPParam::NewLC(*aHeaders.iHeaders[i]);
		AddHeaderL(header);
		CleanupStack::Pop(header);
		}
	}

// -----------------------------------------------------------------------------
// CSIPURIHeaders::~CSIPURIHeaders
// -----------------------------------------------------------------------------
//
CSIPURIHeaders::~CSIPURIHeaders ()
	{
	iHeaders.ResetAndDestroy();
	}

// -----------------------------------------------------------------------------
// CSIPURIHeaders::HasHeaders
// -----------------------------------------------------------------------------
//
TBool CSIPURIHeaders::HasHeaders (const TDesC8& aName) const
	{
	for (TInt i=0; i < iHeaders.Count(); i++)
		{
		if (aName.CompareF(iHeaders[i]->Name().DesC()) == 0)
			{
			return ETrue;
			}
		}
	return EFalse;
	}

// -----------------------------------------------------------------------------
// CSIPURIHeaders::HeaderValuesL
// -----------------------------------------------------------------------------
//
CPtrC8Array* CSIPURIHeaders::HeaderValuesL (const TDesC8& aName) const
	{
	CPtrC8Array* values = new(ELeave)CPtrC8Array(1);
	CleanupStack::PushL(values);
	for (TInt i=0; i < iHeaders.Count(); i++)
		{
		if (aName.CompareF(iHeaders[i]->Name().DesC()) == 0)
			{
			values->AppendL(iHeaders[i]->Value().DesC());
			}
		}
	CleanupStack::Pop(values);
	if (values->Count() == 0)
		{
		delete values;
		return NULL;
		}
	return values;
	}

// -----------------------------------------------------------------------------
// CSIPURIHeaders::AddHeaderL
// -----------------------------------------------------------------------------
//
void CSIPURIHeaders::AddHeaderL (const TDesC8& aName, const TDesC8& aValue)
	{
	CSIPParam* header = CSIPParam::NewLC(aName,aValue);
	AddHeaderL(header);
	CleanupStack::Pop(header);
	}

// -----------------------------------------------------------------------------
// CSIPURIHeaders::DeleteAll
// -----------------------------------------------------------------------------
//
void CSIPURIHeaders::DeleteAll ()
	{
	iHeaders.ResetAndDestroy();
	}

// -----------------------------------------------------------------------------
// CSIPURIHeaders::operator==
// -----------------------------------------------------------------------------
//
TBool CSIPURIHeaders::operator==(const CSIPURIHeaders& aHeaders) const
	{
	// All URI-headers must be present in both and their values must match.
	for (TInt i=0; i < iHeaders.Count(); i++)
		{
		if (!aHeaders.HasHeader(*(iHeaders[i]))) 
            {
            return EFalse;
            }
		}
	for (TInt j=0; j < aHeaders.iHeaders.Count(); j++)
		{
		if (!HasHeader(*(aHeaders.iHeaders[j]))) 
            {
            return EFalse;
            }
		}
	return ETrue;
	}

// -----------------------------------------------------------------------------
// CSIPURIHeaders::ToTextLC
// -----------------------------------------------------------------------------
//
HBufC8* CSIPURIHeaders::ToTextLC () const
	{
	TUint encodedLength = 0;

	RPointerArray<HBufC8> headersAsText;
	CleanupStack::PushL (TCleanupItem(ResetAndDestroy,&headersAsText));

	for (TInt i=0; i < iHeaders.Count(); i++)
		{
		HBufC8* headerAsText = iHeaders[i]->ToTextLC();
		encodedLength += headerAsText->Length();
		if (i < iHeaders.Count()-1) 
			{
			encodedLength += 1; // header separator '&'
			}
		headersAsText.AppendL(headerAsText);
		CleanupStack::Pop(headerAsText);
		}
	
	HBufC8* encodedHeaders = HBufC8::NewL (encodedLength);
	TPtr8 encodedHeadersPtr = encodedHeaders->Des();

	for (TInt j=0; j < headersAsText.Count(); j++)
		{
		encodedHeadersPtr.Append (*headersAsText[j]);
		if (j < headersAsText.Count()-1)
			{
			encodedHeadersPtr.Append('&');
			}
		}

	CleanupStack::PopAndDestroy(1); // headersAsText
	CleanupStack::PushL(encodedHeaders);
	return encodedHeaders;
	}	

// -----------------------------------------------------------------------------
// CSIPURIHeaders::AddHeaderL
// -----------------------------------------------------------------------------
//
void CSIPURIHeaders::AddHeaderL (const CSIPParam* aHeader)
	{
	CheckHeaderL (aHeader);
	User::LeaveIfError (iHeaders.Append(aHeader));
	}

// -----------------------------------------------------------------------------
// CSIPURIHeaders::CheckHeaderL
// -----------------------------------------------------------------------------
//
void CSIPURIHeaders::CheckHeaderL (const CSIPParam* aHeader) const
	{
	__ASSERT_ALWAYS (aHeader != 0, User::Leave(KErrSipCodecURIHeaders));

	if (!aHeader->HasValue())
		{
		User::Leave(KErrSipCodecURIHeaders);
		}
	if (!CheckSIPURIHeaderToken(aHeader->Name().DesC()))
		{
		User::Leave(KErrSipCodecURIHeaders);
		}
	if (!CheckSIPURIHeaderToken(aHeader->Value().DesC()))
		{
		User::Leave(KErrSipCodecURIHeaders);
		}
	}

// -----------------------------------------------------------------------------
// CSIPURIHeaders::CheckSIPURIHeaderToken
// -----------------------------------------------------------------------------
//
TBool CSIPURIHeaders::CheckSIPURIHeaderToken (const TDesC8& aHeaderToken)
	{
	if (aHeaderToken.Length() == 0) 
        {
        return EFalse;
        }

	TLex8 lex(aHeaderToken);
	TSIPChar sipChr = lex.Get();
	while (sipChr)
		{
		// unreserved / escaped / hnv-unreserved
		if (!(sipChr.IsUnreserved() || sipChr == '%' ||
			  sipChr == '[' || sipChr == ']' || sipChr == '/' || 
			  sipChr == '?' || sipChr == ':' || sipChr == '+' || 
			  sipChr == '$'))
			{			
			return EFalse;
			}
		if (sipChr == '%') // escaped: "%" HEXDIG HEXDIG
			{
			if (!lex.Get().IsHexDigit()) 
                {
                return EFalse;
                }
			if (!lex.Get().IsHexDigit()) 
                {
                return EFalse;
                }
			}
		sipChr = lex.Get();
		}
	return ETrue;
	}

// -----------------------------------------------------------------------------
// CSIPURIHeaders::HasHeader
// -----------------------------------------------------------------------------
//
TBool CSIPURIHeaders::HasHeader (const CSIPParam& aHeader) const
	{
	for (TInt i=0; i < iHeaders.Count(); i++)
		{
		if (aHeader == *(iHeaders[i])) 
            {
            return ETrue;
            }
		}
	return EFalse;
	}

// -----------------------------------------------------------------------------
// CSIPURIHeaders::ResetAndDestroy
// -----------------------------------------------------------------------------
//
void CSIPURIHeaders::ResetAndDestroy (TAny* anArray)
	{
	(reinterpret_cast<RPointerArray<HBufC8>*> (anArray))->ResetAndDestroy();
	}