// 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          : CSipCSServerITC.cpp
// Part of       : SIPServerCore
// Version       : SIP/4.0 
//




#include "CSipCSServerITC.h"
#include "CSIPCSSerializer.h"
#include "SipCSServer.pan"
#include "siprequest.h"
#include "sipresponse.h"
#include "siprouteheader.h"
#include "sipfromheader.h"
#include "TSIPRemoteTargetAndProxy.h"
#include "uricontainer.h"
#include "SipLogs.h"


// -----------------------------------------------------------------------------
// CSipCSServerITC::NewL
// -----------------------------------------------------------------------------
//
CSipCSServerITC* CSipCSServerITC::NewL ()
	{
    CSipCSServerITC* self = CSipCSServerITC::NewLC ();
    CleanupStack::Pop(self);
    return self;
	}

// -----------------------------------------------------------------------------
// CSipCSServerITC::NewLC
// -----------------------------------------------------------------------------
//
CSipCSServerITC* CSipCSServerITC::NewLC ()
	{
    CSipCSServerITC* self = new (ELeave) CSipCSServerITC;
    CleanupStack::PushL (self);
    self->ConstructL();
    return self;
	}

// -----------------------------------------------------------------------------
// CSipCSServerITC::CSipCSServerITC
// -----------------------------------------------------------------------------
//
CSipCSServerITC::CSipCSServerITC ()
	{
	}

// -----------------------------------------------------------------------------
// CSipCSServerITC::ConstructL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::ConstructL ()
	{
    iSerializer = CSIPCSSerializer::NewL();
	}

// -----------------------------------------------------------------------------
// CSipCSServerITC::~CSipCSServerITC
// -----------------------------------------------------------------------------
//
CSipCSServerITC::~CSipCSServerITC ()
	{
    delete iSerializer;
	}

// -----------------------------------------------------------------------------
// CSipCSServerITC::Serializer
// -----------------------------------------------------------------------------
//
CSIPCSSerializer& CSipCSServerITC::Serializer ()
    {
    return *iSerializer;
    }

// -----------------------------------------------------------------------------
// CSipCSServerITC::WriteL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::WriteL (const RMessage2& aMessage,
                              CBufFlat& aSipHeaders) const
    {
    TPtr8 headerBufPtr = aSipHeaders.Ptr(0);
    WriteL(ESipItcArgMessageHeaders,aMessage,headerBufPtr);
    }
    
// -----------------------------------------------------------------------------
// CSipCSServerITC::WriteL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::WriteL (const RMessage2& aMessage,
                              const TDesC8& aDes,
                              TSipItcArguments aItcArgIndex) const
    {
    WriteL(aItcArgIndex,aMessage,aDes);
    }

// -----------------------------------------------------------------------------
// CSipCSServerITC::WriteL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::WriteL (const RMessage2& aMessage,
                              const TSIPIds& aIds) const
	{
    TPckgBuf<TSIPIds> sipIdsPckg(aIds);
    WriteL(ESipItcArgIds, aMessage, sipIdsPckg);
	}

// -----------------------------------------------------------------------------
// CSipCSServerITC::WriteL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::WriteL (const RMessage2& aMessage,
                              const TSIPMessageBufSizes aSizes) const
    {
    TPckgBuf<TSIPMessageBufSizes> bufSizesPckg(aSizes);
    WriteL(ESipItcArgBufSizes, aMessage, bufSizesPckg);
    }

// -----------------------------------------------------------------------------
// CSipCSServerITC::WriteL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::WriteL (const RMessage2& aMessage,
							  const CSIPHeaderBase& aHeader) const
	{
	CBufFlat* headerBuf = iSerializer->ExternalizeValueLC(aHeader);
	TPtr8 headerBufPtr(headerBuf->Ptr(0));
	WriteL(ESipItcArgMessageHeaders,aMessage,headerBufPtr);
	CleanupStack::PopAndDestroy(headerBuf);
	}

// -----------------------------------------------------------------------------
// CSipCSServerITC::WriteL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::WriteL (const RMessage2& aMessage,
                              TInt aValue,
                              TSipItcArguments aItcArgIndex) const
    {
    TPckg<TInt> handlePckg(aValue);
    WriteL(aItcArgIndex, aMessage, handlePckg);
    }

// -----------------------------------------------------------------------------
// CSipCSServerITC::WriteL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::WriteL (const RMessage2& aMessage,
                              CSIPConnection::TState aState) const
    {
    TPckg<CSIPConnection::TState> statePckg(aState);
    WriteL(ESipItcArgConnectionState, aMessage, statePckg);
    }

// -----------------------------------------------------------------------------
// CSipCSServerITC::WriteL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::WriteL (const RMessage2& aMessage,
                              MDesC8Array& aSecurityMechanisms) const
    {
	CBufFlat* buf = iSerializer->ExternalizeLC(aSecurityMechanisms);
	TPtr8 bufPtr = buf->Ptr(0);
	WriteL(ESipItcArgAuthenticationMechanism, aMessage, bufPtr);
	CleanupStack::PopAndDestroy(buf);
    }
 
// -----------------------------------------------------------------------------
// CSipCSServerITC::WriteL
// -----------------------------------------------------------------------------
//    
void CSipCSServerITC::WriteL (const RMessage2& aMessage,
                              const TInetAddr& aInetAddr) const
    {
    TPckgBuf<TInetAddr> addrPckg(aInetAddr);
    WriteL(ESipItcArgLocalAddr, aMessage, addrPckg);    
    }

// -----------------------------------------------------------------------------
// CSipCSServerITC::ReadAppUidL
// -----------------------------------------------------------------------------
//
TUid CSipCSServerITC::ReadAppUidL (const RMessage2& aMessage) const
	{
    TPckgBuf<TUid> appUidPckg;
    aMessage.ReadL(ESipItcArgAppUid, appUidPckg);
    return appUidPckg();
	}
    
// -----------------------------------------------------------------------------
// CSipCSServerITC::ReadRequestL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::ReadRequestL (const RMessage2& aMessage,
                                    CSIPRequest& aRequest,
                                    TBool aMethodExpected) const
    {
    HBufC8* headers = ReadLC(aMessage,ESipItcArgMessageHeaders);
	if (headers->Length() > 0)
		{
		iSerializer->InternalizeL(*headers,aRequest,aMethodExpected);
		}
	CleanupStack::PopAndDestroy(headers);	
    HBufC8* content = ReadL(aMessage,ESipItcArgMessageContent);
    aRequest.SetContent(content);
    __SIP_MESSAGE_LOG("ServerCore",aRequest)
    }

// -----------------------------------------------------------------------------
// CSipCSServerITC::ReadRequestL
// -----------------------------------------------------------------------------
//
void 
CSipCSServerITC::ReadRequestL (const RMessage2& aMessage,
                               CSIPRequest& aRequest,
                               TSIPRemoteTargetAndProxy& aRemoteTargetAndProxy,
                               TBool aMethodExpected,
                               TBool aProxyExpected) const
    {
    HBufC8* headers = ReadLC(aMessage,ESipItcArgMessageHeaders);
	if (headers->Length() == 0)
        {
        User::Leave(KErrArgument);
        }
    iSerializer->InternalizeL(*headers,aRequest,aRemoteTargetAndProxy,
                              aMethodExpected,aProxyExpected);
    CleanupStack::PopAndDestroy(headers);
    CleanupStack::PushL(aRemoteTargetAndProxy.iRemoteTarget);
    CleanupStack::PushL(aRemoteTargetAndProxy.iProxy);
    HBufC8* content = ReadL(aMessage,ESipItcArgMessageContent);
    aRequest.SetContent(content);
    CleanupStack::Pop(aRemoteTargetAndProxy.iProxy);
    CleanupStack::Pop(aRemoteTargetAndProxy.iRemoteTarget);
    __SIP_MESSAGE_LOG("ServerCore",aRequest)
    }

// -----------------------------------------------------------------------------
// CSipCSServerITC::ReadResponseLC
// -----------------------------------------------------------------------------
//
CSIPResponse* CSipCSServerITC::ReadResponseLC (const RMessage2& aMessage) const
    {
    HBufC8* headers = ReadLC(aMessage,ESipItcArgMessageHeaders);
	if (headers->Length() == 0)
        {
        User::Leave(KErrArgument);
        }
    CSIPResponse* response = iSerializer->InternalizeL(*headers);
    CleanupStack::PopAndDestroy(headers);
    CleanupStack::PushL(response);
    HBufC8* content = ReadL(aMessage,ESipItcArgMessageContent);
    response->SetContent(content);
    __SIP_MESSAGE_LOG("ServerCore",*response)
    return response;
    }
	
// -----------------------------------------------------------------------------
// CSipCSServerITC::ReadProxyLC
// -----------------------------------------------------------------------------
//	
CSIPRouteHeader* CSipCSServerITC::ReadProxyLC (const RMessage2& aMessage) const
    {
    HBufC8* proxyBuf = ReadLC(aMessage,ESipItcArgMessageHeaders);
	if (proxyBuf->Length() == 0)
        {
        User::Leave(KErrArgument);
        }
    CSIPRouteHeader* proxy = iSerializer->InternalizeProxyL(*proxyBuf);
	CleanupStack::PopAndDestroy(proxyBuf);
    CleanupStack::PushL(proxy);
    return proxy;       
    }

// -----------------------------------------------------------------------------
// CSipCSServerITC::ReadSipIdsL
// -----------------------------------------------------------------------------
//
TSIPIds CSipCSServerITC::ReadSipIdsL (const RMessage2& aMessage) const
	{
    TPckgBuf<TSIPIds> sipIdsPckg;
    aMessage.ReadL(ESipItcArgIds, sipIdsPckg);
    return sipIdsPckg();
	}
	
// -----------------------------------------------------------------------------
// CSipCSServerITC::ReadSIPSockOptL
// -----------------------------------------------------------------------------
//
TSIPSockOpt CSipCSServerITC::ReadSIPSockOptL (const RMessage2& aMessage) const
	{
    TPckgBuf<TSIPSockOpt> sipSockOptPckg;
    aMessage.ReadL(ESipItcArgSockOpt, sipSockOptPckg);
    return sipSockOptPckg();
	}	

// -----------------------------------------------------------------------------
// CSipCSServerITC::ReadL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::ReadL (const RMessage2& aMessage,
                             TInt& aValue,
                             TSipItcArguments aItcArgIndex) const
    {
    aValue = ITCArgInt(aItcArgIndex,aMessage);
    }
    
// -----------------------------------------------------------------------------
// CSipCSServerITC::ReadLC
// -----------------------------------------------------------------------------
//
HBufC8* CSipCSServerITC::ReadLC (const RMessage2&  aMessage,
                                 TSipItcArguments aItcArgIndex) const
	{
    TInt length = aMessage.GetDesLength (aItcArgIndex);
    if (length < 0)
        {
        User::Leave (KErrBadDescriptor);
        }
    HBufC8* buf = HBufC8::NewLC (length);
	if (length > 0)
		{
		TPtr8 bufPtr(buf->Des());
		aMessage.ReadL (aItcArgIndex, bufPtr);
		}
    return buf;
	}
	
// -----------------------------------------------------------------------------
// CSipCSServerITC::ReadCredentialsLC
// -----------------------------------------------------------------------------
//
CDesC8Array* 
CSipCSServerITC::ReadCredentialsLC (const RMessage2& aMessage) const
    {
    HBufC8* credentialsBuf = ReadLC(aMessage,ESipItcArgCredentials);
    CDesC8Array* credentials = 
        iSerializer->InternalizeCredentialsL(*credentialsBuf);
    CleanupStack::Pop(credentialsBuf);
    CleanupStack::PushL(credentials);
    return credentials;
    }	    

// -----------------------------------------------------------------------------
// CSipCSServerITC::Complete
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::Complete (const RMessage2& aMessage,
                                TInt aCompletionCode) const
	{
    aMessage.Complete (aCompletionCode);
	}

// -----------------------------------------------------------------------------
// CSipCSServerITC::PanicClient
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::PanicClient(const RMessage2& aMessage, TInt aPanic) const
	{
    RThread client;
    aMessage.Client(client);
    client.Panic(KSipCSServerPanic, aPanic);
	}

// -----------------------------------------------------------------------------
// CSipCSServerITC::ITCArgPtr
// -----------------------------------------------------------------------------
//
const TAny* CSipCSServerITC::ITCArgPtr (TSipItcArguments aItcArgIndex,
                                        const RMessage2&  aMessage) const
	{
    const TAny* ptr;
    switch (static_cast<TInt>(aItcArgIndex))
		{
        case 0: ptr = aMessage.Ptr0(); break;
        case 1: ptr = aMessage.Ptr1(); break;
        case 2: ptr = aMessage.Ptr2(); break;
        case 3: ptr = aMessage.Ptr3(); break;
        default: ptr = 0; break;
		}
    return ptr; 
	}

// -----------------------------------------------------------------------------
// CSipCSServerITC::ITCArgInt
// -----------------------------------------------------------------------------
//
TInt CSipCSServerITC::ITCArgInt (TSipItcArguments aItcArgIndex,
                                 const RMessage2&  aMessage) const
	{
    TInt integer;
    switch (static_cast<TInt>(aItcArgIndex))
		{
        case 0: integer = aMessage.Int0(); break;
        case 1: integer = aMessage.Int1(); break;
        case 2: integer = aMessage.Int2(); break;
        case 3: integer = aMessage.Int3(); break;
        default: integer = KErrArgument; break;
		}
    return integer; 
	}

// -----------------------------------------------------------------------------
// CSipCSServerITC::WriteL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::WriteL (TSipItcArguments aItcArgIndex,
							  const RMessage2&  aMessage,
							  const TDesC8&    aDes) const
	{
    TInt length = aMessage.GetDesMaxLength(aItcArgIndex);
    if (length < 0)
        {
        User::Leave (KErrArgument);
        }
    if (length < aDes.Length())
        {
        User::Leave (KErrOverflow);
        }
    aMessage.WriteL (aItcArgIndex, aDes);
	}

// -----------------------------------------------------------------------------
// CSipCSServerITC::ReadL
// -----------------------------------------------------------------------------
//
HBufC8* CSipCSServerITC::ReadL (const RMessage2&  aMessage,
                                TSipItcArguments aItcArgIndex) const
	{
	HBufC8* buf = ReadLC(aMessage,aItcArgIndex);
    CleanupStack::Pop(buf);
	return buf;
	}