// Copyright (c) 2007-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          : CURIContainer.cpp

// Part of       : SIP Codec

// Version       : SIP/4.0 

//

#include "uricontainer.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "sipuri.h"

#include "sipcodecerr.h"

#include "SIPHeaderLookup.h"

#include "_sipcodecdefs.h"

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

// CURIContainer::DecodeL

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

//

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

	{

    HBufC8* trimmedValue = aValue.AllocLC();

    trimmedValue->Des().Trim();

    __ASSERT_ALWAYS(trimmedValue->Length() > 0, User::Leave(KErrSipCodecURI));

    CURIContainer* container = new(ELeave) CURIContainer;

    CleanupStack::PushL(container);

    container->ConstructL();

    if(SIPHeaderLookup::ConvertToSIPURI())

        {

        if(FindSIP(*trimmedValue))

            {

            CSIPURI* sipuri = CSIPURI::DecodeL(*trimmedValue);

            CleanupStack::PushL(sipuri);

            container->iSIPURI = sipuri;

            CleanupStack::Pop(sipuri);

            }

        else

            {

            CUri8* uri8 = CreateUri8L(*trimmedValue);

            CleanupStack::PushL(uri8);

            container->iUri8 = uri8;

            CleanupStack::Pop(uri8);

            }

        }

    else

        {

        CUri8* uri8 = CreateUri8L(*trimmedValue);

        CleanupStack::PushL(uri8);

        container->iUri8 = uri8;

        CleanupStack::Pop(uri8);

        }

    CleanupStack::Pop(container);

    CleanupStack::PopAndDestroy(trimmedValue);

    return container;

	}

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

// CURIContainer::NewL

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

//

EXPORT_C CURIContainer* CURIContainer::NewL(CUri8* aUri8)

    {

    CURIContainer* self = CURIContainer::NewLC(aUri8);

    CleanupStack::Pop(self);

    return self;

    }

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

// CURIContainer::NewLC

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

//

EXPORT_C CURIContainer* CURIContainer::NewLC(CUri8* aUri8)

    {

    CURIContainer* self = new(ELeave) CURIContainer;

    CleanupStack::PushL(self);

    self->ConstructL(aUri8);

    return self;

    }

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

// CURIContainer::NewL

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

//

EXPORT_C CURIContainer* CURIContainer::NewL(const CURIContainer& aURI)

    {

	CURIContainer* self = CURIContainer::NewLC(aURI);

	CleanupStack::Pop(self);

	return self;

    }

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

// CURIContainer::NewLC

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

//

EXPORT_C CURIContainer* CURIContainer::NewLC(const CURIContainer& aURI)

    {

	CURIContainer* self = new (ELeave) CURIContainer;

	CleanupStack::PushL(self);

	self->ConstructL(aURI);

	return self;

    }

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

// CURIContainer::~CURIContainer

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

//

EXPORT_C CURIContainer::~CURIContainer()

    {

    delete iSIPURI;

    delete iUri8;

    SIPHeaderLookup::Close();

    }

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

// CURIContainer::ConstructL

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

//

void CURIContainer::ConstructL()

    {

    SIPHeaderLookup::OpenL();

    }

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

// CURIContainer::ConstructL

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

//

void CURIContainer::ConstructL(CUri8* aUri8)

    {

    SIPHeaderLookup::OpenL();

    if(SIPHeaderLookup::ConvertToSIPURI())

        {

        if(FindSIP(aUri8->Uri().UriDes()))

            {

            iSIPURI = CSIPURI::DecodeL(aUri8->Uri().UriDes());

            delete aUri8;

            }

        else

            {

            iUri8 = aUri8;

            }

        }

    else

        {

        iUri8 = aUri8;

        }

    }

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

// CURIContainer::ConstructL

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

//

void CURIContainer::ConstructL(const CURIContainer& aURI)

    {

    SIPHeaderLookup::OpenL();

    if(aURI.IsSIPURI())

        {

        HBufC8* sipuriastext = aURI.iSIPURI->ToTextL();

        CleanupStack::PushL(sipuriastext);

        iSIPURI = CSIPURI::DecodeL(*sipuriastext);

        CleanupStack::PopAndDestroy(sipuriastext);

        }

    else

        {

        iUri8 = CUri8::NewL(aURI.Uri8()->Uri());

        }

    }

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

// CURIContainer::IsSIPURI

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

//

EXPORT_C TBool CURIContainer::IsSIPURI() const

    {

    if(iSIPURI)

        {

        return ETrue;

        }

    return EFalse;

    }

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

// CURIContainer::SIPURI

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

//

EXPORT_C CSIPURI* CURIContainer::SIPURI()

    {

    return iSIPURI;

    }

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

// CURIContainer::SIPURI

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

//

EXPORT_C const CSIPURI* CURIContainer::SIPURI() const

    {

    return iSIPURI;

    }

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

// CURIContainer::Uri8

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

//

EXPORT_C const CUri8* CURIContainer::Uri8() const

    {

    return iUri8;

    }

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

// CURIContainer::operator==

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

//

EXPORT_C TBool CURIContainer::operator==(const CURIContainer& aURI) const

    {

    if(aURI.IsSIPURI() && IsSIPURI())

        {

        return (*iSIPURI == *aURI.iSIPURI);

        }

    if(!aURI.IsSIPURI() && !IsSIPURI())

        {

        if(aURI.Uri8()->Uri().UriDes().Compare(Uri8()->Uri().UriDes()) == 0)

            {

            return ETrue;

            }

        return EFalse;

        }

    return EFalse;

    }

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

// CURIContainer::ToTextL

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

//

EXPORT_C HBufC8* CURIContainer::ToTextL() const

    {

    __ASSERT_ALWAYS((iUri8 || iSIPURI), User::Leave(KErrSipCodecURIContainer));

	if(iSIPURI)

	    {

        return iSIPURI->ToTextL();

	    }

    return iUri8->Uri().UriDes().AllocL();

    }

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

// CURIContainer::InternalizeL

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

//

EXPORT_C CURIContainer* CURIContainer::InternalizeL(RReadStream& aReadStream)

    {

    CURIContainer* container = new(ELeave) CURIContainer;

    CleanupStack::PushL(container);

    container->ConstructL();

    container->DoInternalizeL(aReadStream);

    CleanupStack::Pop(container);

    return container;

    }

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

// CURIContainer::ExternalizeL

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

//

EXPORT_C void CURIContainer::ExternalizeL(RWriteStream& aWriteStream) const

    {

    if(IsSIPURI())

        {

        HBufC8* tmp = iSIPURI->ToTextL();

        CleanupStack::PushL(tmp);

        aWriteStream.WriteUint32L(tmp->Des().Length());

        aWriteStream.WriteL(tmp->Des());

        CleanupStack::PopAndDestroy(tmp);

        }

    else

        {

        TPtrC8 uri8(iUri8->Uri().UriDes());

        aWriteStream.WriteUint32L(uri8.Length());

        aWriteStream.WriteL(uri8);

        }

    }

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

// CURIContainer::CloneAsUri8L

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

//

EXPORT_C CUri8* CURIContainer::CloneAsUri8L() const

    {

    HBufC8* uriAsText = ToTextL();

    CleanupStack::PushL(uriAsText);

    CUri8* clone = CreateUri8L(*uriAsText);

    CleanupStack::PopAndDestroy(uriAsText);

    return clone;

    }

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

// CURIContainer::DoInternalizeL

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

//

void CURIContainer::DoInternalizeL(RReadStream& aReadStream)

    {

    TInt length(aReadStream.ReadUint32L());

    HBufC8* buffer = HBufC8::NewLC(length);

    TPtr8 bufptr(buffer->Des());

    aReadStream.ReadL(bufptr, length);

    if(SIPHeaderLookup::ConvertToSIPURI())

        {

        if(FindSIP(bufptr))

            {

            iSIPURI = CSIPURI::DecodeL(bufptr);

            }

        else

            {

            iUri8 = CreateUri8L(bufptr);

            }

        }

    else

        {

        iUri8 = CreateUri8L(bufptr);

        }

    CleanupStack::PopAndDestroy(buffer);

    }

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

// CURIContainer::CreateUri8L

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

//

CUri8* CURIContainer::CreateUri8L(const TDesC8& aValue)

    {

    TUriParser8 parser;

    User::LeaveIfError(parser.Parse(aValue));

    TPtrC8 scheme(parser.Extract(EUriScheme));

    if (scheme.CompareF(SIPStrings::StringF(SipStrConsts::ESip).DesC()) == 0)

        {

        User::LeaveIfError(parser.Validate());

        }

    return CUri8::NewL(parser);

    }

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

// CURIContainer::FindSIP

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

//

TBool CURIContainer::FindSIP(const TDesC8& aValue)

    {

    _LIT8(KSIP, "sip:");

    _LIT8(KSIPS, "sips:");

    TPtrC8 value(aValue);

    if(value.FindF(KSIP) == 0 ||

       value.FindF(KSIPS) == 0)

        {

        return ETrue;

        }

    return EFalse;

    }