// 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          : CSIPHostPort.cpp

// Part of       : SIP Codec

// Version       : SIP/4.0 

//

#include "siphostport.h"

#include "sipcodecerr.h"

#include "SIPSyntaxCheck.h"

#include "_sipcodecdefs.h"

_LIT8(KPortFormat, "%u");

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

// CSIPHostPort::DecodeL

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

//

EXPORT_C CSIPHostPort* CSIPHostPort::DecodeL (const TDesC8& aValue)

	{

	__ASSERT_ALWAYS (aValue.Length() > 0, User::Leave(KErrSipCodecHostPort));

	CSIPHostPort* hostPort = new(ELeave)CSIPHostPort;

    CleanupStack::PushL (hostPort);

	if (aValue.Locate('[') == 0) // seems to be an IPv6 address

		{

		TInt hostEndPos = aValue.Locate(']');

		if (hostEndPos > 1)

			{

			hostPort->SetHostL (aValue.Mid(1,hostEndPos-1));

			if (hostEndPos < aValue.Length()-1) // seems to have a port

				{

				TLex8 lex(aValue.Mid(hostEndPos+1));

				lex.SkipSpace();

				TPtrC8 portAsText(lex.Remainder());

				if (portAsText.Length() > 0)

					{

					TInt colonPos = portAsText.Locate (':');

					if (colonPos != 0) User::Leave(KErrSipCodecPort);

					hostPort->SetPort (ParsePortL(portAsText.Mid(1)));

					}

				}

			}

		else

			{

			User::Leave(KErrSipCodecHostPort);

			}

	    __ASSERT_ALWAYS (hostPort->HostType() == ESIPIpv6, 

	                     User::Leave(KErrSipCodecHostPort));

		}

	else // seems to be an IPv4 address or a host name 

		{

		TInt colonPos = aValue.Locate(':');

		if (colonPos == 0 || colonPos == aValue.Length()-1)

			{

			User::Leave(KErrSipCodecPort);

			}

		if (colonPos > 0) // has port

			{

			hostPort->SetPort (ParsePortL (aValue.Mid(colonPos+1)));

			hostPort->SetHostL (aValue.Left(colonPos));

			}

		else // has only host part

			{

			hostPort->SetHostL (aValue);

			}

		}

	CleanupStack::Pop(hostPort);

	return hostPort;

	}

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

// CSIPHostPort::NewL

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

//

EXPORT_C CSIPHostPort* CSIPHostPort::NewL (const CSIPHostPort& aHostPort)

	{

	CSIPHostPort* self = CSIPHostPort::NewLC (aHostPort);

	CleanupStack::Pop(self);

	return self;

	}

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

// CSIPHostPort::NewLC

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

//

EXPORT_C CSIPHostPort* CSIPHostPort::NewLC (const CSIPHostPort& aHostPort)

	{

	CSIPHostPort* self = new(ELeave)CSIPHostPort;

	CleanupStack::PushL(self);

	self->ConstructL (aHostPort);

	return self;

	}

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

// CSIPHostPort::CSIPHostPort

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

//

CSIPHostPort::CSIPHostPort()

 : iHostType (ESIPNoHost),

   iHasPort (EFalse)

	{

	}

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

// CSIPHostPort::ConstructL

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

//

void CSIPHostPort::ConstructL ()

	{

	iHost = HBufC8::NewL(0);

	}

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

// CSIPHostPort::ConstructL

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

//

void CSIPHostPort::ConstructL (const CSIPHostPort& aHostPort)

	{

	iHost = aHostPort.iHost->AllocL();

	iHostType = aHostPort.iHostType;

	iHasPort = aHostPort.iHasPort;

	iPort = aHostPort.iPort;

	}

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

// CSIPHostPort::~CSIPHostPort

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

//

EXPORT_C CSIPHostPort::~CSIPHostPort()

	{

	delete iHost;

	}

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

// CSIPHostPort::SetHostL

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

//

EXPORT_C void CSIPHostPort::SetHostL (const TDesC8& aHost)

	{

	HBufC8* tmp = aHost.AllocLC();

	tmp->Des().Trim();

	if (tmp->Length() == 0) 

        {

        User::Leave(KErrSipCodecHost);

        }

	TType hostType;

	TInt err = SIPSyntaxCheck::HostType(*tmp,hostType);

	if (err != KErrNone) 

        {

        User::Leave (err);

        }

	CleanupStack::Pop(tmp);

	delete iHost;

	iHost = tmp;

	iHostType = hostType;

	}

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

// CSIPHostPort::HostType

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

//

EXPORT_C CSIPHostPort::TType CSIPHostPort::HostType () const

	{

	return iHostType;

	}

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

// CSIPHostPort::Host

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

//

EXPORT_C const TDesC8& CSIPHostPort::Host () const

	{

	return *iHost;

	}

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

// CSIPHostPort::HasPort

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

//

EXPORT_C TBool CSIPHostPort::HasPort() const

	{

	return iHasPort;

	}

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

// CSIPHostPort::Port

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

//

EXPORT_C TUint CSIPHostPort::Port() const

	{

	if (iHasPort) 

        {

        return iPort;

        }

	return 0;

	}

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

// CSIPHostPort::SetPort

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

//

EXPORT_C void CSIPHostPort::SetPort (TUint aPort)

	{

	iPort = aPort;

	iHasPort = ETrue;

	}

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

// CSIPHostPort::DeletePort

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

//

EXPORT_C TInt CSIPHostPort::DeletePort ()

	{

	if (!iHasPort) 

        {

        return KErrNotFound;

        }

	iPort = 0;

	iHasPort = EFalse;

	return KErrNone;

	}

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

// CSIPHostPort::operator==

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

//

EXPORT_C TBool CSIPHostPort::operator==(const CSIPHostPort& aHostPort) const

	{

	if (iHostType != aHostPort.iHostType) 

        {

        return EFalse;

        }

	if (iHost->CompareF(*(aHostPort.iHost)) != 0) 

        {

        return EFalse;

        }

	if (iHasPort != aHostPort.iHasPort) 

        {

        return EFalse;

        }

	if (iHasPort)

		{

		if (iPort != aHostPort.iPort) 

            {

            return EFalse;

            }

		}

	return ETrue;

	}

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

// CSIPHostPort::ToTextLC

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

//

HBufC8* CSIPHostPort::ToTextLC () const

	{

	TUint encodedLength = iHost->Length();

	if (iHostType == ESIPIpv6)

	    {

	    const TInt KBracketsLength = 2; // []

	    encodedLength += KBracketsLength;

	    }

	const TInt KMaxPortAsText = 40;

	TBuf8<KMaxPortAsText> portAsText;

	if (iHasPort)

		{

		portAsText.Format(KPortFormat, iPort);

		encodedLength += 1 + portAsText.Length(); // COLON + port

		}

	HBufC8* encodedHostPort = HBufC8::NewLC(encodedLength);

	TPtr8 encodedHostPortPtr = encodedHostPort->Des();

	if (iHostType == ESIPIpv6)

		{

		encodedHostPortPtr.Append('[');

		encodedHostPortPtr.Append(*iHost);

		encodedHostPortPtr.Append(']');

		}

	else

		{

		encodedHostPortPtr.Append(*iHost);

		}

	if (iHasPort)

		{

		encodedHostPortPtr.Append(':');

		encodedHostPortPtr.Append(portAsText);

		}

	return encodedHostPort;

	}

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

// CSIPHostPort::ParsePortL

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

//

TUint CSIPHostPort::ParsePortL (const TDesC8& aValue)

	{

	TLex8 lex(aValue);

	lex.SkipSpace();

	TPtrC8 remainder(lex.Remainder());

    if (remainder.Length() == 0) 

        {

        User::Leave(KErrSipCodecPort);

        }

	TUint parsedValue=0;

	if (lex.Val(parsedValue) != KErrNone) 

        {

        User::Leave (KErrSipCodecPort);

        }

    lex.SkipSpace();

	if (lex.Remainder().Length() != 0) 

        {

        User::Leave (KErrSipCodecPort);

        }

	return parsedValue;

	}