--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/realtimenetprots/sipfw/SIP/Codec/src/CSIPURI.cpp	Tue Feb 02 01:03:15 2010 +0200
@@ -0,0 +1,644 @@
+// 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          : CSIPURI.cpp
+// Part of       : SIP Codec
+// Version       : SIP/4.0 
+//
+
+
+
+
+#include "sipuri.h"
+#include "CSIPURIParams.h"
+#include "CSIPURIHeaders.h"
+#include "sipcodecerr.h"
+#include "SIPSyntaxCheck.h"
+#include "sipstrings.h"
+#include "sipstrconsts.h"
+#include <uricommon.h>
+#include "_sipcodecdefs.h"
+
+_LIT8(KSIP, "sip");
+_LIT8(KSIPS, "sips");
+_LIT8(KColon, ":");
+_LIT8(KSemiColon, ";");
+_LIT8(KAt, "@");
+_LIT8(KQuestionMark, "?");
+
+// -----------------------------------------------------------------------------
+// CSIPURI::DecodeL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CSIPURI* CSIPURI::DecodeL (const TDesC8& aValue)
+	{
+	__ASSERT_ALWAYS (aValue.Length() > 0, User::Leave(KErrSipCodecURI));
+
+	CSIPURI* sipUri = CSIPURI::NewLC();
+
+	sipUri->ParseL(sipUri->ParseSipSchemeL(aValue));
+
+	CleanupStack::Pop(sipUri);
+	return sipUri;
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::NewL
+// -----------------------------------------------------------------------------
+//
+CSIPURI* CSIPURI::NewL (const CSIPURI& aSIPURI)
+	{
+	CSIPURI* self = CSIPURI::NewLC(aSIPURI);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::NewLC
+// -----------------------------------------------------------------------------
+//
+CSIPURI* CSIPURI::NewLC (const CSIPURI& aSIPURI)
+	{
+	CSIPURI* self = new(ELeave)CSIPURI(aSIPURI.IsSIPSURI());
+	CleanupStack::PushL(self);
+	self->ConstructL(aSIPURI);
+	return self;
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::NewL
+// -----------------------------------------------------------------------------
+//
+CSIPURI* CSIPURI::NewL ()
+	{
+	CSIPURI* self = CSIPURI::NewLC();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::NewLC
+// -----------------------------------------------------------------------------
+//
+CSIPURI* CSIPURI::NewLC ()
+	{
+	CSIPURI* self = new(ELeave)CSIPURI;
+	CleanupStack::PushL(self);
+	self->ConstructL ();
+	return self;
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::CSIPURI
+// -----------------------------------------------------------------------------
+//
+CSIPURI::CSIPURI(TBool aIsSIPSUri)
+: iIsSIPSURI(aIsSIPSUri)
+	{
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::ConstructL
+// -----------------------------------------------------------------------------
+//
+void CSIPURI::ConstructL ()
+	{
+	iURIParams = new(ELeave)CSIPURIParams(iIsSIPSURI);
+	iURIHeaders = new(ELeave)CSIPURIHeaders;
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::ConstructL
+// -----------------------------------------------------------------------------
+//
+void CSIPURI::ConstructL (const CSIPURI& aSIPURI)
+	{
+	ConstructL();
+	iHostPort = CSIPHostPort::NewL(*aSIPURI.iHostPort);
+	if (aSIPURI.User().Compare(KNullDesC8) != 0) 
+		{
+		SetUserL(aSIPURI.User());
+		}
+	if (aSIPURI.Password().Compare(KNullDesC8) != 0) 
+		{
+		SetPasswordL(aSIPURI.Password());
+		}
+	SetURIParams(CSIPURIParams::NewL(*aSIPURI.iURIParams,aSIPURI.IsSIPSURI()));
+	SetURIHeaders(CSIPURIHeaders::NewL(*aSIPURI.iURIHeaders));
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::~CSIPURI
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CSIPURI::~CSIPURI ()
+	{
+	delete iHostPort;
+	delete iURIHeaders;
+	delete iURIParams;
+	delete iPassword;
+	delete iUser;
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::IsSIPSURI
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CSIPURI::IsSIPSURI () const
+	{
+	return iIsSIPSURI;
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::SetSIPS
+// -----------------------------------------------------------------------------
+//	
+EXPORT_C void CSIPURI::SetSIPS(TBool aSIPS)
+    {
+    iIsSIPSURI = aSIPS;
+    }
+
+// -----------------------------------------------------------------------------
+// CSIPURI::SetHostPortL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CSIPURI::SetHostPortL (CSIPHostPort* aHostPort)
+ 	{
+	__ASSERT_ALWAYS (aHostPort != 0, User::Leave(KErrSipCodecHost));
+
+	delete iHostPort;
+	iHostPort = aHostPort;
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::HostPort
+// -----------------------------------------------------------------------------
+//
+EXPORT_C const CSIPHostPort& CSIPURI::HostPort () const
+	{
+	return *iHostPort;
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::HostPort
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CSIPHostPort& CSIPURI::HostPort ()
+	{
+	return *iHostPort;
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::User
+// -----------------------------------------------------------------------------
+//
+EXPORT_C const TDesC8& CSIPURI::User () const
+	{
+	if (iUser) 
+        {
+        return *iUser;
+        }
+	return KNullDesC8;
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::SetUserL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CSIPURI::SetUserL (const TDesC8& aUser)
+	{
+	__ASSERT_ALWAYS (SIPSyntaxCheck::User(aUser),
+	                 User::Leave(KErrSipCodecURI));
+
+	HBufC8* tmp = aUser.AllocL();
+	delete iUser;
+	iUser = tmp;
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::DeleteUserInfo
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CSIPURI::DeleteUserInfo ()
+	{
+	delete iUser; iUser = 0;
+	DeletePassword();
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::Password
+// -----------------------------------------------------------------------------
+//
+EXPORT_C const TDesC8& CSIPURI::Password () const
+	{
+	if (iPassword) 
+        {
+        return *iPassword;
+        }
+	return KNullDesC8;
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::SetPasswordL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CSIPURI::SetPasswordL (const TDesC8& aPassword)
+	{
+	__ASSERT_ALWAYS (SIPSyntaxCheck::Password(aPassword),
+	                 User::Leave(KErrSipCodecURI));
+	__ASSERT_ALWAYS (iUser, User::Leave(KErrArgument));
+
+	HBufC8* tmp = aPassword.AllocL();
+	delete iPassword;
+	iPassword = tmp;
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::DeletePassword
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CSIPURI::DeletePassword ()
+	{ 
+	delete iPassword; iPassword = 0;
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::HasParams
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CSIPURI::HasParams () const
+	{
+	return (iURIParams->ParamCount() > 0);
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::TtlParam
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CSIPURI::TtlParam () const
+	{
+	RStringF ttl = SIPStrings::StringF(SipStrConsts::ETtl);	
+	return iURIParams->IntParamValue(ttl);
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::SetTtlParamL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CSIPURI::SetTtlParamL (TInt aValue)
+	{
+	RStringF ttl = SIPStrings::StringF(SipStrConsts::ETtl);
+	iURIParams->SetParamL(ttl,aValue);
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::HasParam
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CSIPURI::HasParam(RStringF aName) const
+	{
+	return iURIParams->HasParam(aName);
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::ParamValue
+// -----------------------------------------------------------------------------
+//
+EXPORT_C RStringF CSIPURI::ParamValue(RStringF aName) const
+	{
+	return iURIParams->ParamValue(aName);
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::SetParamL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CSIPURI::SetParamL(RStringF aName)
+	{
+	iURIParams->SetParamL(aName);
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::SetParamL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CSIPURI::SetParamL(RStringF aName, RStringF aValue)
+	{
+	iURIParams->SetParamL(aName,aValue);
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::DeleteParam
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CSIPURI::DeleteParam(RStringF aName)
+	{
+	iURIParams->DeleteParam (aName);
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::HasURIHeaders
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CSIPURI::HasURIHeaders (const TDesC8& aName) const
+	{
+	return iURIHeaders->HasHeaders(aName);
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::URIHeaderValuesL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CPtrC8Array* CSIPURI::URIHeaderValuesL (const TDesC8& aName) const
+	{
+	return iURIHeaders->HeaderValuesL(aName);
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::AddURIHeaderL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CSIPURI::AddURIHeaderL (const TDesC8& aName,
+									  const TDesC8& aValue)
+	{
+	iURIHeaders->AddHeaderL(aName,aValue);
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::DeleteAllURIHeaders
+// -----------------------------------------------------------------------------
+//
+void CSIPURI::DeleteAllURIHeaders ()
+	{
+	iURIHeaders->DeleteAll();
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::operator==
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CSIPURI::operator==(const CSIPURI& aURI) const
+    {
+	if (aURI.iIsSIPSURI != iIsSIPSURI)
+		{
+		return EFalse;
+		}
+    TBool hasuserparam((aURI.User().Compare(KNullDesC8) != 0));
+    TBool hasuser((User().Compare(KNullDesC8) != 0));
+	if (hasuserparam != hasuser)
+		{
+		return EFalse;
+		}
+	if (hasuserparam && aURI.User() != User())
+		{
+		return EFalse;
+		}
+    TBool haspasswordparam((aURI.Password().Compare(KNullDesC8) != 0));
+    TBool haspassword((Password().Compare(KNullDesC8) != 0));
+	if (haspasswordparam != haspassword)
+		{
+		return EFalse;
+		}
+	if (haspasswordparam && 
+        aURI.Password() != Password())
+		{
+		return EFalse;
+		}
+	if (!(*iHostPort == *(aURI.iHostPort))) 
+		{
+		return EFalse;
+		}
+	if (!(*aURI.iURIParams == *iURIParams))
+		{
+		return EFalse;
+		}
+	return (*aURI.iURIHeaders == *iURIHeaders);
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::ToTextL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C HBufC8* CSIPURI::ToTextL () const
+	{
+	TPtrC8 scheme(KSIP);
+	if (iIsSIPSURI)
+		{
+		scheme.Set(KSIPS);
+		}
+	TUint encodedLength = scheme.Length() + KColon().Length();
+	
+	if (iUser)
+		{
+		encodedLength += iUser->Length();
+		if (iPassword) encodedLength+=KColon().Length()+iPassword->Length();
+		encodedLength += KAt().Length();
+		}
+
+	HBufC8* hostPort = iHostPort->ToTextLC();
+	encodedLength += hostPort->Length();
+
+	HBufC8* uriParams = iURIParams->ToTextLC();
+	if (uriParams->Length() > 0) encodedLength += (1+uriParams->Length());
+
+	HBufC8* uriHeaders = iURIHeaders->ToTextLC();
+	if (uriHeaders->Length() > 0) encodedLength += (1+uriHeaders->Length());
+
+	// Create and fill the encoded SIP URI
+	HBufC8* encodedSIPURI = HBufC8::NewL (encodedLength);
+	TPtr8 encodedSIPURIPtr = encodedSIPURI->Des();
+
+	encodedSIPURIPtr.Append(scheme);
+	encodedSIPURIPtr.Append(KColon);
+	
+	if (iUser)
+		{
+		encodedSIPURIPtr.Append(*iUser);
+		if (iPassword)
+			{
+			encodedSIPURIPtr.Append(KColon); 
+			encodedSIPURIPtr.Append(*iPassword);
+			}
+		encodedSIPURIPtr.Append(KAt);
+		}
+
+	encodedSIPURIPtr.Append(*hostPort);
+
+	if (uriParams->Length() > 0)
+		{
+		encodedSIPURIPtr.Append(KSemiColon);
+		encodedSIPURIPtr.Append (*uriParams);
+		}
+	
+	if (uriHeaders->Length() > 0)
+		{
+		encodedSIPURIPtr.Append(KQuestionMark);
+		encodedSIPURIPtr.Append (*uriHeaders);
+		}
+
+	CleanupStack::PopAndDestroy(uriHeaders); 
+	CleanupStack::PopAndDestroy(uriParams); 
+	CleanupStack::PopAndDestroy(hostPort);  
+	return encodedSIPURI;
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::ParseSipSchemeL
+// -----------------------------------------------------------------------------
+//
+TPtrC8 CSIPURI::ParseSipSchemeL (const TDesC8& aValue)
+	{
+	__ASSERT_ALWAYS (aValue.Length() > 0, User::Leave(KErrSipCodecURIScheme));
+
+	_LIT8(KSIPAndColon, "sip:");
+	_LIT8(KSIPSAndColon, "sips:");
+
+	TPtrC8 schemeAndColon;
+	TInt sipSchemePos = aValue.FindF(KSIPAndColon);
+	if (sipSchemePos < 0)
+		{
+		TInt sipsSchemePos = aValue.FindF(KSIPSAndColon);
+		if (sipsSchemePos != 0) 
+            {
+            User::Leave (KErrSipCodecURIScheme);
+            }
+		schemeAndColon.Set(KSIPSAndColon);
+		iIsSIPSURI = ETrue;
+		}
+	else
+		{
+		if (sipSchemePos != 0) 
+            {
+            User::Leave (KErrSipCodecURIScheme);
+            }
+		schemeAndColon.Set(KSIPAndColon);
+		iIsSIPSURI = EFalse;
+		}
+	TPtrC8 remainder(aValue.Mid(schemeAndColon.Length()));
+	return remainder;
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::ParseL
+// -----------------------------------------------------------------------------
+//
+void CSIPURI::ParseL (const TDesC8& aValue)
+	{
+	TPtrC8 remainder(aValue);
+	TInt atPos = 0;
+	LocateSeparatorL(aValue, '@', atPos);
+	if (atPos > 0) // has userinfo
+		{
+		ParseUserInfoL(aValue.Left(atPos));
+		remainder.Set(aValue.Mid(atPos+1));
+		}
+
+	TInt semiColonPos = 0;
+	LocateSeparatorL(remainder, ';', semiColonPos);
+	if (semiColonPos > 0) // has uri-parameters
+		{
+		iHostPort = CSIPHostPort::DecodeL (remainder.Left(semiColonPos));
+		remainder.Set(remainder.Mid(semiColonPos+1));
+		TInt questionMarkPos = 0;
+		LocateSeparatorL(remainder, '?', questionMarkPos);
+		TPtrC8 uriParams;
+		if (questionMarkPos > 0) // has uri-headers
+			{
+			uriParams.Set(remainder.Left(questionMarkPos));
+			TPtrC8 uriHeaders(remainder.Mid(questionMarkPos+1));
+			SetURIHeaders (CSIPURIHeaders::DecodeL(uriHeaders));
+			}
+		else // does not have uri-headers
+			{
+			uriParams.Set(remainder);
+			}
+		SetURIParams(CSIPURIParams::DecodeL(uriParams,iIsSIPSURI));
+		}
+	else // does not have uri-parameters
+		{
+		TInt questionMarkPos = 0;
+		LocateSeparatorL(remainder, '?', questionMarkPos);
+		if (questionMarkPos > 0) // has uri-headers
+			{
+			iHostPort = CSIPHostPort::DecodeL (remainder.Left(questionMarkPos));
+			TPtrC8 uriHeaders(remainder.Mid(questionMarkPos+1));
+			SetURIHeaders (CSIPURIHeaders::DecodeL(uriHeaders));
+			}
+		else
+			{
+			iHostPort = CSIPHostPort::DecodeL (remainder);
+			}
+		}
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::ParseUserInfoL
+// -----------------------------------------------------------------------------
+//
+void CSIPURI::ParseUserInfoL (const TDesC8& aValue)
+	{
+	__ASSERT_ALWAYS (aValue.Length() > 0, User::Leave(KErrSipCodecURI));
+
+	TInt colonPos = 0;
+	LocateSeparatorL(aValue, ':', colonPos);
+	if (colonPos > 0) // has both user and password part
+		{
+		SetUserL (aValue.Left(colonPos));
+		SetPasswordL (aValue.Mid(colonPos+1));
+		}
+	else // has only user part
+		{	 
+		SetUserL (aValue);
+		}
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::LocateSeparatorL
+// -----------------------------------------------------------------------------
+//
+void CSIPURI::LocateSeparatorL(
+    const TDesC8& aValue,
+    TChar aSeparator,
+    TInt& aPosition) const
+	{
+	__ASSERT_ALWAYS (aValue.Length() > 0, User::Leave (KErrSipCodecURI));
+
+	TInt position = aValue.Locate(aSeparator);
+	if (position == 0 || position == aValue.Length()-1)
+		{
+		User::Leave (KErrSipCodecURI);
+		}
+    aPosition = position;
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::SetURIParams
+// -----------------------------------------------------------------------------
+//
+void CSIPURI::SetURIParams (CSIPURIParams* aURIParams)
+	{
+	delete iURIParams;
+	iURIParams = aURIParams;
+	}
+
+// -----------------------------------------------------------------------------
+// CSIPURI::SetURIHeaders
+// -----------------------------------------------------------------------------
+//
+void CSIPURI::SetURIHeaders (CSIPURIHeaders* aURIHeaders)
+	{
+	delete iURIHeaders;
+	iURIHeaders = aURIHeaders;
+	}	
+	
+