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

// Part of       : SIPClient

// Version       : SIP/4.0 

//

#include "CSIPITCSender.h"

#include "MSIPITC.h"

#include "sipmessageelements.h"

#include "siprequestelements.h"

#include "sipresponseelements.h"

#include "siptoheader.h"

#include "sipfromheader.h"

#include "uricontainer.h"

#include "siprouteheader.h"

#include "sipcallidheader.h"

#include "SIPHeaderLookup.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

const TInt KMaxHeaderSizeInReadStream = 300;

const TInt KMaxTagLength = 100;

const TInt KExternalizeBufferExpandSize = 100;

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

// CSIPITCSender::NewL

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

//

CSIPITCSender* CSIPITCSender::NewL (MSIPITC& aITC)

	{

    CSIPITCSender* self = CSIPITCSender::NewLC(aITC);

    CleanupStack::Pop (self);

    return self;

	}

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

// CSIPITCSender::NewLC

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

//

CSIPITCSender* CSIPITCSender::NewLC (MSIPITC& aITC)

	{

	CSIPITCSender* self = new(ELeave)CSIPITCSender(aITC);

    CleanupStack::PushL (self);

    self->ConstructL ();

    return self;

	}

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

// CSIPITCSender::CSIPITCSender

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

//	

CSIPITCSender::CSIPITCSender (MSIPITC& aITC)

 : iITC (aITC),

   iLookupOpened (EFalse)

    {

    }

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

// CSIPITCSender::ConstructL

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

//

void CSIPITCSender::ConstructL ()

	{

    SIPHeaderLookup::OpenL();

    iLookupOpened = ETrue;

	}

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

// CSIPITCSender::~CSIPITCSender

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

//

CSIPITCSender::~CSIPITCSender ()

    {

    if (iLookupOpened)

        {

        SIPHeaderLookup::Close();

        }

    }

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

// CSIPITCSender::Send

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

//

TInt CSIPITCSender::Send (TSIPIds& aIds, TSipItcFunctions aITCFunction)

	{

    TPckgBuf<TSIPIds> sipIdsPckg(aIds);

    iITCMsgArgs.Set (ESipItcArgIds, &sipIdsPckg);

	TInt err = iITC.Send(aITCFunction,iITCMsgArgs);

	aIds = sipIdsPckg();

    return err;

	}

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

// CSIPITCSender::SendL

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

//

void CSIPITCSender::SendL (TSIPIds& aIds, TSipItcFunctions aITCFunction)

	{

    TInt err = Send(aIds,aITCFunction);

    if (err != KErrNone)

        {

        User::Leave(err);

        }

	}

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

// CSIPITCSender::SendL

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

//

void CSIPITCSender::SendL (TSIPIds& aIds,

						   TSipItcFunctions aITCFunction,

						   const CSIPRequestElements& aElements)

	{

    Mem::FillZ(&iITCMsgArgs, sizeof(iITCMsgArgs));

    CBufFlat* buf = ExternalizeLC (aElements);

    TPtr8 externalizedHeaders = buf->Ptr(0);

    iITCMsgArgs.Set (ESipItcArgMessageHeaders, &externalizedHeaders);

    SetContentToSend (aElements.MessageElements());

    SendL (aIds,aITCFunction);

    CleanupStack::PopAndDestroy(buf);

	}

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

// CSIPITCSender::SendL

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

//

void CSIPITCSender::SendL (TSIPIds& aIds,

                           TSipItcFunctions aITCFunction,

                           RStringF aMethod,

                           const CUri8* aRemoteUri,

                           const CSIPFromHeader* aFrom,

                           const CSIPToHeader* aTo,

                           const CSIPMessageElements* aElements,

                           const CSIPRouteHeader* aOutboundProxy)

    {

    Mem::FillZ(&iITCMsgArgs, sizeof(iITCMsgArgs));

    CBufFlat* buf = CBufFlat::NewL(KExternalizeBufferExpandSize);

	CleanupStack::PushL(buf);

	RBufWriteStream writeStream(*buf,0);

    writeStream.PushL();

    ExternalizeL(aMethod,writeStream);

    if (aRemoteUri)

        {

        writeStream.WriteUint8L(1); // remote uri present

        TPtrC8 uri(aRemoteUri->Uri().UriDes());

        writeStream.WriteUint32L(uri.Length());

        writeStream.WriteL(uri);

        }

    else

        {

        writeStream.WriteUint8L(0); // remote not uri present

        }

    if (aOutboundProxy)

        {

        aOutboundProxy->ExternalizeL(writeStream,EFalse);

        }

    if (aFrom)

        {

        ExternalizeL(aFrom,writeStream);

        }

    if (aTo)

        {

        ExternalizeL(aTo,writeStream);

        }

    ExternalizeL(aElements,writeStream,EFalse);

	writeStream.Pop();

    writeStream.Close();

    TPtr8 externalizedHeaders = buf->Ptr(0);

    iITCMsgArgs.Set(ESipItcArgMessageHeaders,&externalizedHeaders);

    SetContentToSend (aElements);

    SendL (aIds,aITCFunction);

    CleanupStack::PopAndDestroy(buf);

    }

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

// CSIPITCSender::SendL

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

//

void CSIPITCSender::SendL (TSIPIds& aIds,

						   TSipItcFunctions aITCFunction,

						   const CSIPMessageElements* aElements)

	{

    Mem::FillZ(&iITCMsgArgs, sizeof(iITCMsgArgs));

    SetContentToSend (aElements);

	if (aElements != 0)

		{

        CBufFlat* buf = ExternalizeLC (*aElements);

        TPtr8 externalizedHeaders = buf->Ptr(0);

        iITCMsgArgs.Set (ESipItcArgMessageHeaders, &externalizedHeaders);

        SendL(aIds,aITCFunction);

        CleanupStack::PopAndDestroy(buf);

        }

    else

		{

        TBuf8<1> emptyBuf; 

        iITCMsgArgs.Set (ESipItcArgMessageHeaders, &emptyBuf);

		SendL(aIds,aITCFunction);

		}

	}

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

// CSIPITCSender::SendL

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

//

void CSIPITCSender::SendL (TSIPIds& aIds,

						   TSipItcFunctions aITCFunction,

                           RStringF aMethod,

						   const CSIPMessageElements* aElements)

	{

    Mem::FillZ(&iITCMsgArgs, sizeof(iITCMsgArgs));

    SetContentToSend (aElements);

	CBufFlat* buf = CBufFlat::NewL(KExternalizeBufferExpandSize);

	CleanupStack::PushL(buf);

	RBufWriteStream writeStream(*buf,0);

	writeStream.PushL();

	ExternalizeL(aMethod,writeStream);

    ExternalizeL (aElements,writeStream,EFalse);

    TPtr8 bufPtr = buf->Ptr(0);

    iITCMsgArgs.Set (ESipItcArgMessageHeaders, &bufPtr);

    SendL(aIds,aITCFunction);

    writeStream.Pop();

    writeStream.Close();

    CleanupStack::PopAndDestroy(buf);

	}

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

// CSIPITCSender::SendL

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

//

void CSIPITCSender::SendL (TSIPIds& aIds,

						   TSipItcFunctions aITCFunction,

						   const CSIPResponseElements& aElements)

	{

    Mem::FillZ(&iITCMsgArgs, sizeof(iITCMsgArgs));

    CBufFlat* buf = ExternalizeLC (aElements);

	TPtr8 externalizedHeaders = buf->Ptr(0);

    iITCMsgArgs.Set (ESipItcArgMessageHeaders, &externalizedHeaders);

    SetContentToSend (aElements.MessageElements());

    SendL (aIds,aITCFunction);

    CleanupStack::PopAndDestroy(buf);

	}

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

// CSIPITCSender::OutboundProxyL

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

//

void CSIPITCSender::SetOutboundProxyL (TSIPIds& aIds,

                                       const CSIPRouteHeader& aOutboundProxy)

    {

	CBufFlat* buf = CBufFlat::NewL(KExternalizeBufferExpandSize);

	CleanupStack::PushL(buf);

	RBufWriteStream writeStream(*buf,0);

	writeStream.PushL();

	aOutboundProxy.ExternalizeL(writeStream,EFalse);

	writeStream.Pop();

	writeStream.Close();

	TPtr8 externalizedProxy = buf->Ptr(0);

	iITCMsgArgs.Set (ESipItcArgMessageHeaders, &externalizedProxy);

    SendL (aIds,ESipItcSetOutboundProxy);

    CleanupStack::PopAndDestroy(buf);

    }

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

// CSIPITCSender::ReadSIPHeaderL

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

//    

CSIPHeaderBase* CSIPITCSender::ReadSIPHeaderL (TSIPIds& aIds,

                                               TSipItcFunctions aITCFunction,

                                               RStringF aHeaderName)

    {

    Mem::FillZ(&iITCMsgArgs, sizeof(iITCMsgArgs));

	HBufC8* headerBuf = HBufC8::NewLC(KMaxHeaderSizeInReadStream);

	TPtr8 headerBufPtr = headerBuf->Des();

    iITCMsgArgs.Set (ESipItcArgMessageHeaders, &headerBufPtr);

    SendL (aIds,aITCFunction);

    CSIPHeaderBase* header = InternalizeL(aHeaderName, headerBufPtr);

    CleanupStack::PopAndDestroy(headerBuf);

    return header;  

    }

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

// CSIPITCSender::ReadCallIDHeaderL

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

//     

CSIPCallIDHeader* CSIPITCSender::ReadCallIDHeaderL(TSIPIds& aIds)

	{

    Mem::FillZ(&iITCMsgArgs, sizeof(iITCMsgArgs));

	HBufC8* headerBuf = HBufC8::NewLC(KMaxHeaderSizeInReadStream);

	TPtr8 headerBufPtr = headerBuf->Des();

    iITCMsgArgs.Set (ESipItcArgMessageHeaders, &headerBufPtr);

    SendL (aIds,ESipItcGetCallIDHeader);

	RDesReadStream readStream(headerBufPtr);

	readStream.PushL();          

    CSIPCallIDHeader* callID = NULL;

    if (headerBufPtr.Length() > 0)

    	{

    	callID = static_cast<CSIPCallIDHeader*>(

    				CSIPCallIDHeader::InternalizeValueL(readStream));

		}

    readStream.Pop();

    readStream.Close();

    CleanupStack::PopAndDestroy(headerBuf);

    return callID;	

	}

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

// CSIPITCSender::ReadLocalTagL

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

//	

RStringF CSIPITCSender::ReadLocalTagL(TSIPIds& aIds)

    {

    Mem::FillZ(&iITCMsgArgs, sizeof(iITCMsgArgs));

	HBufC8* localTagBuf = HBufC8::NewLC(KMaxTagLength);

	TPtr8 localTagBufPtr = localTagBuf->Des();

    iITCMsgArgs.Set(ESipItcArgLocalTag, &localTagBufPtr);

    SendL(aIds,ESipItcGetLocalTag);

    RStringF localTag = SIPStrings::Pool().OpenFStringL(localTagBufPtr); 

    CleanupStack::PopAndDestroy(localTagBuf);

    return localTag;

    }

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

// CSIPITCSender::SetRefreshIntervalL

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

//    

void CSIPITCSender::SetRefreshIntervalL (TSIPIds& aIds, TInt aInterval)

    {

	iITCMsgArgs.Set(ESipItcArgRefreshInterval, aInterval);

    SendL(aIds,ESipItcSetRefreshInterval); 

    }

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

// CSIPITCSender::GetRefreshIntervalL

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

//

void CSIPITCSender::GetRefreshIntervalL (TSIPIds& aIds, TInt& aInterval)

    {    

    TPckgBuf<TInt> intervalPckg(0);

    iITCMsgArgs.Set(ESipItcArgRefreshInterval, &intervalPckg);

    SendL (aIds,ESipItcGetRefreshInterval);

    aInterval = intervalPckg();    

    }

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

// CSIPITCSender::SetContentToSend

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

//

void CSIPITCSender::SetContentToSend (const CSIPMessageElements* aElements)

    {

    if (aElements != 0)

        {

        SetContentToSend(*aElements);

        }

    else

        {

        iITCMsgArgs.Set (ESipItcArgMessageContent, &iEmptyContent);

        }

    }

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

// CSIPITCSender::SetContentToSend

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

//

void CSIPITCSender::SetContentToSend (const CSIPMessageElements& aElements)

    {

    iITCMsgArgs.Set (ESipItcArgMessageContent, &(aElements.Content()));

    }

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

// CSIPITCSender::ExternalizeLC 

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

//

template<class T> CBufFlat* CSIPITCSender::ExternalizeLC (const T& aElements)

	{

	CBufFlat* buf = CBufFlat::NewL(KExternalizeBufferExpandSize);

	CleanupStack::PushL(buf);

	RBufWriteStream writeStream(*buf,0);

	writeStream.PushL();

	aElements.ExternalizeL(writeStream);

	writeStream.Pop();

	writeStream.Close();

    return buf;

	}

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

// CSIPITCSender::ExternalizeL

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

//

template<class T> void CSIPITCSender::ExternalizeL (const T* aElement, 

                                                    RWriteStream& aWriteStream,

                                                    TBool aAddExpectedFlag)

    {

    if (aElement)

        {

        if (aAddExpectedFlag)

            {

            aWriteStream.WriteUint8L(1); // element expected flag

            }

        aElement->ExternalizeL(aWriteStream);

        }

    else

        {

        aWriteStream.WriteUint8L(0); // element not expected flag

        }

    }

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

// CSIPITCSender::ExternalizeL

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

//

void CSIPITCSender::ExternalizeL (RStringF aStr, RWriteStream& aWriteStream)

    {

    TPtrC8 des(aStr.DesC());

    if (des.Length() > 0)

        {

        aWriteStream.WriteUint32L(des.Length());

	    aWriteStream.WriteL(des);

        }    

    }

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

// CSIPITCSender::InternalizeL

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

//

CSIPHeaderBase* CSIPITCSender::InternalizeL (RStringF aName, TDes8& aDes)

    {

    CSIPHeaderBase* header = NULL;

	if (aDes.Length() > 0)

		{

	    RDesReadStream readStream(aDes);

	    readStream.PushL();

        header = SIPHeaderLookup::InternalizeL(aName,readStream);

	    readStream.Pop();

	    readStream.Close();

        }

    return header;

    }