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