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

// Part of       : SIPClient

// Version       : SIP/4.0 

//

#include "sipmessageelements.h"

#include "sipheaderbase.h"

#include "sipfromheader.h"

#include "sipcontactheader.h"

#include "siptoheader.h"

#include "sipcseqheader.h"

#include "sipcontenttypeheader.h"

#include "sipextensionheader.h"

#include "SIPHeaderLookup.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "_sipcodecdefs.h"

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

// CSIPMessageElements::NewL

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

//

EXPORT_C CSIPMessageElements* CSIPMessageElements::NewL()

	{

    CSIPMessageElements* self = CSIPMessageElements::NewLC();

    CleanupStack::Pop (self);

    return self;

	}

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

// CSIPMessageElements::NewLC

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

//

EXPORT_C CSIPMessageElements* CSIPMessageElements::NewLC ()

	{

	CSIPMessageElements* self = new(ELeave)CSIPMessageElements;

    CleanupStack::PushL (self);

    self->ConstructL ();

    return self;

	}

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

// CSIPMessageElements::CSIPMessageElements

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

//

CSIPMessageElements::CSIPMessageElements ()

 : iHeaderLookupOpen(EFalse) 

	{

	}

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

// CSIPMessageElements::ConstructL

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

//

void CSIPMessageElements::ConstructL()

	{

	SIPHeaderLookup::OpenL();

    iHeaderLookupOpen = ETrue;

	}

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

// CSIPMessageElements::~CSIPMessageElements

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

//

EXPORT_C CSIPMessageElements::~CSIPMessageElements () 

	{

    if (iHeaderLookupOpen)

        {

	    SIPHeaderLookup::Close();

        }

	delete iContent;

	iUserHeaders.ResetAndDestroy();

    delete iFromHeader;

    delete iToHeader;

    delete iCSeqHeader;

    delete iContentTypeHeader;

	}

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

// CSIPMessageElements::SetUserHeadersL

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

//

EXPORT_C void 

CSIPMessageElements::SetUserHeadersL (RPointerArray<CSIPHeaderBase>& aHeaders)

	{

    RPointerArray<CSIPHeaderBase> tmpHeaders;

    CleanupClosePushL(tmpHeaders);

	for (TInt i=0; i<aHeaders.Count(); i++)

        {

        CSIPHeaderBase* header = aHeaders[i];

        CheckUserHeaderL(header);

        tmpHeaders.AppendL(header);

        }

    CleanupStack::Pop(1); // tmpHeaders

    iUserHeaders.ResetAndDestroy();

    iUserHeaders = tmpHeaders;

    aHeaders.Reset();

	}

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

// CSIPMessageElements::UserHeaders

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

//

EXPORT_C const RPointerArray<CSIPHeaderBase>& 

CSIPMessageElements::UserHeaders() const

	{

	return iUserHeaders;

	}

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

// CSIPMessageElements::SetContentL

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

//

EXPORT_C void CSIPMessageElements::SetContentL (HBufC8* aContent,

                                                CSIPContentTypeHeader* aType)

	{

	__ASSERT_ALWAYS (aContent != 0, User::Leave(KErrArgument));

	__ASSERT_ALWAYS (aType != 0, User::Leave(KErrArgument));

    delete iContentTypeHeader;

    iContentTypeHeader = aType;

	delete iContent;

	iContent = aContent;

	}

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

// CSIPMessageElements::Content

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

//

EXPORT_C const TDesC8& CSIPMessageElements::Content () const

    {

    if (iContent)

        {

        return *iContent;

        }

    return KNullDesC8;

    }

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

// CSIPMessageElements::Content

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

//

EXPORT_C const CSIPContentTypeHeader* CSIPMessageElements::ContentType() const

    {

    return iContentTypeHeader;

    }

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

// CSIPMessageElements::ExtractContent

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

//

EXPORT_C HBufC8* CSIPMessageElements::ExtractContent ()

    {

    HBufC8* tmp = iContent;

    iContent = 0;

    delete iContentTypeHeader;

    iContentTypeHeader = 0;

    return tmp;

    }

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

// CSIPMessageElements::InternalizeL

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

//

CSIPMessageElements* CSIPMessageElements::InternalizeL(RReadStream& aReadStream)

	{

	CSIPMessageElements* self = CSIPMessageElements::NewLC();

    self->DoInternalizeL(aReadStream);

	CleanupStack::Pop(self);

    return self;

	}

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

// CSIPMessageElements::DoInternalizeL

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

//

void CSIPMessageElements::DoInternalizeL (RReadStream& aReadStream)

	{

	TUint8 moreHeaders = aReadStream.ReadUint8L();

	while (moreHeaders)

		{

		TUint32 nameLength = aReadStream.ReadUint32L();

		HBufC8* name = HBufC8::NewLC (nameLength);

		TPtr8 namePtr(name->Des());

		aReadStream.ReadL (namePtr,nameLength);

		RStringF nameStr = SIPStrings::Pool().OpenFStringL(namePtr);

		CleanupClosePushL(nameStr);

		CSIPHeaderBase* header = 

		    SIPHeaderLookup::InternalizeL(nameStr,aReadStream);

		CleanupStack::PopAndDestroy(); // nameStr

		CleanupStack::PopAndDestroy(name);

		CleanupStack::PushL(header);

		AddHeaderL(header);

		CleanupStack::Pop(header);

		moreHeaders = aReadStream.ReadUint8L();

		}

	}

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

// CSIPMessageElements::ExternalizeL

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

//

void 

CSIPMessageElements::ExternalizeL (RWriteStream& aWriteStream) const

	{

    if (iFromHeader)

        {

		aWriteStream.WriteUint8L(1); // more headers in the stream flag

        iFromHeader->ExternalizeL(aWriteStream);

        }

    if (iToHeader)

        {

		aWriteStream.WriteUint8L(1); // more headers in the stream flag

        iToHeader->ExternalizeL(aWriteStream);

        }

    if (iCSeqHeader)

        {

		aWriteStream.WriteUint8L(1); // more headers in the stream flag

        iCSeqHeader->ExternalizeL(aWriteStream);

        }

    if (iContentTypeHeader)

        {

        aWriteStream.WriteUint8L(1); // more headers in the stream flag

        iContentTypeHeader->ExternalizeL(aWriteStream);

        }

    ExternalizeUserHeadersL (aWriteStream);

	aWriteStream.WriteUint8L(0); // no more headers in the stream flag

	}

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

// CSIPMessageElements::UserHeaderCount

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

//

TInt CSIPMessageElements::UserHeaderCount (RStringF aName) const

    {

    TInt headerCount = 0;

	for (TInt i=0; i < iUserHeaders.Count(); i++)

		{

        if (iUserHeaders[i]->Name() == aName)

            {

            headerCount++;

            }

		}

    return headerCount;

    }

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

// CSIPMessageElements::UserHeadersL

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

//

const RPointerArray<CSIPHeaderBase> 

CSIPMessageElements::UserHeadersL (RStringF aName) const

    {

    RPointerArray<CSIPHeaderBase> headers;

    CleanupClosePushL(headers);

	for (TInt i=0; i < iUserHeaders.Count(); i++)

		{

        if (iUserHeaders[i]->Name() == aName)

            {

            User::LeaveIfError(headers.Append(iUserHeaders[i]));

            }

		}

    CleanupStack::Pop(1); // headers

    return headers;

    }

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

// CSIPMessageElements::RemoveHeaders

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

//

TInt CSIPMessageElements::RemoveHeaders (RStringF aName)

    {

    TInt err = KErrNotFound;

	for (TInt i=iUserHeaders.Count()-1; i>=0; i--)

		{

        if (iUserHeaders[i]->Name() == aName)

            {

            CSIPHeaderBase* header = iUserHeaders[i];

            iUserHeaders.Remove(i);

            delete header;

            err = KErrNone;

            }

		}

    return err;

    }   

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

// CSIPMessageElements::DetachUserHeader

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

//

void CSIPMessageElements::DetachUserHeader (CSIPHeaderBase* aHeader)

    {

	for (TInt i=0; i < iUserHeaders.Count(); i++)

		{

        if (iUserHeaders[i] == aHeader)

            {

            iUserHeaders.Remove(i);

            }

		}

    }

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

// CSIPMessageElements::AddHeaderL 

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

//

void CSIPMessageElements::AddHeaderL (CSIPHeaderBase* aHeader)

	{

	__ASSERT_ALWAYS (aHeader != 0, User::Leave(KErrArgument));

    if (aHeader->Name() == SIPStrings::StringF(SipStrConsts::EFromHeader))

        {

        delete iFromHeader;

        iFromHeader = static_cast<CSIPFromHeader*>(aHeader);

        }

    else if (aHeader->Name() == SIPStrings::StringF(SipStrConsts::EToHeader))

        {

        delete iToHeader;

        iToHeader = static_cast<CSIPToHeader*>(aHeader);

        }

    else if (aHeader->Name() == SIPStrings::StringF(SipStrConsts::ECSeqHeader))

        {

        delete iCSeqHeader;

        iCSeqHeader = static_cast<CSIPCSeqHeader*>(aHeader);

        }

    else if (aHeader->Name() == 

             SIPStrings::StringF(SipStrConsts::EContentTypeHeader))

        {

        delete iContentTypeHeader;

        iContentTypeHeader = static_cast<CSIPContentTypeHeader*>(aHeader);

        }

    else

        {

        User::LeaveIfError(iUserHeaders.Append(aHeader));

        }

	}

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

// CSIPMessageElements::SetToL

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

//

void CSIPMessageElements::SetToL (CSIPToHeader* aTo)

    {

    __ASSERT_ALWAYS (aTo != 0, User::Leave(KErrArgument));

    __ASSERT_ALWAYS (!aTo->HasParam(SIPStrings::StringF(SipStrConsts::ETag)),

                     User::Leave(KErrArgument));

    delete iToHeader;

    iToHeader = aTo;

    }

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

// CSIPMessageElements::To

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

//

const CSIPToHeader* CSIPMessageElements::To() const

    {

    return iToHeader;

    }

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

// CSIPMessageElements::SetFromL

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

//

void CSIPMessageElements::SetFromL (CSIPFromHeader* aFrom)

    {

    __ASSERT_ALWAYS (aFrom != 0, User::Leave(KErrArgument));

    __ASSERT_ALWAYS (!aFrom->HasParam(SIPStrings::StringF(SipStrConsts::ETag)),

                     User::Leave(KErrArgument));

    delete iFromHeader;

    iFromHeader = aFrom;

    }

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

// CSIPMessageElements::From

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

//

const CSIPFromHeader* CSIPMessageElements::From() const

    {

    return iFromHeader;

    }

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

// CSIPMessageElements::CSeq

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

//

const CSIPCSeqHeader* CSIPMessageElements::CSeq() const

    {

    return iCSeqHeader;

    }

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

// CSIPMessageElements::SetContent

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

//

void CSIPMessageElements::SetContent (HBufC8* aContent)

    {

    delete iContent;

    iContent = aContent;

    }

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

// CSIPMessageElements::DetachContent

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

//

void CSIPMessageElements::DetachContent ()

    {

    iContent = 0;

    }

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

// CSIPMessageElements::CheckUserHeaderL

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

//

void CSIPMessageElements::CheckUserHeaderL (const CSIPHeaderBase* aHeader) const

    {

    __ASSERT_ALWAYS (aHeader != 0, User::Leave(KErrArgument));

    // The SIP headers can be divided to two sets:

    // Supported headers and extension headers.

    // The supported headers can be further divided into two subsets:

    // API headers and private headers. 

    // Private headers cannot be set by the application.

    RStringF name = aHeader->Name();

    if (SIPHeaderLookup::IsAPIHeader(name))

        {

        if (name == SIPStrings::StringF(SipStrConsts::EFromHeader) ||

            name == SIPStrings::StringF(SipStrConsts::EToHeader) ||

            name == SIPStrings::StringF(SipStrConsts::ECSeqHeader) ||

            name == SIPStrings::StringF(SipStrConsts::EContentTypeHeader))

            {

            User::Leave(KErrArgument);

            }

        }

    else

        {

        if (SIPHeaderLookup::IsSupported(name)) // Private header

            {

            User::Leave(KErrArgument);

            }

        }

    }

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

// CSIPMessageElements::ExternalizeUserHeadersL

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

//   

void 

CSIPMessageElements::ExternalizeUserHeadersL (RWriteStream& aWriteStream) const

    {

    CSIPHeaderBase* header = 0;

	for (TInt i=0; i < iUserHeaders.Count(); i++)

		{

        header = iUserHeaders[i];

        if (header->IsExtensionHeader())

            {

            ExternalizeL(static_cast<CSIPExtensionHeader*>(header),

                         aWriteStream);

            }

        else

            {

            aWriteStream.WriteUint8L(1); // more headers in the stream

            header->ExternalizeL(aWriteStream);

            }

		}

    }

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

// CSIPMessageElements::ExternalizeL

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

//  

void CSIPMessageElements::ExternalizeL (const CSIPExtensionHeader* aHeader,

                                        RWriteStream& aWriteStream) const

    {

    RPointerArray<CSIPHeaderBase> convertedHeaders;

    CSIPHeaderBase* convertedHeader = 0;

    if (SIPHeaderLookup::IsSupported(aHeader->Name()))

        {

        convertedHeaders = SIPHeaderLookup::CreateHeaderL(aHeader->Name(),

                                                          aHeader->Value());

        CSIPHeaderBase::PushLC(&convertedHeaders);

        for (TInt i=0; i < convertedHeaders.Count(); i++)

            {

            convertedHeader = convertedHeaders[i];

            if (convertedHeader->ExternalizeSupported())

                {

                aWriteStream.WriteUint8L(1); // more headers in the stream

                convertedHeader->ExternalizeL(aWriteStream);

                }

            }

        CleanupStack::PopAndDestroy(1); // convertedHeaders

        }

    else

        {

        aWriteStream.WriteUint8L(1); // more headers in the stream

        aHeader->ExternalizeL(aWriteStream);

        }

    convertedHeaders.Close();

    }