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

// Part of       : SIPServerCore

// Version       : SIP/6.0 

//

#include "SipCSServer.pan"

#include "CSipCSSubSession.h"

#include "CSipCSSession.h"

#include "CSipServerCore.h"

#include "CSipCSServerITC.h"

#include "CSipCSSubSessionReceiver.h"

#include "CTransactionUser.h"

#include "CSipDialogMgr.h"

#include "CSIPRegistrationMgr.h"

#include "MSipRegistrations.h"

#include "MSipRefreshMgr.h"

#include "siprequest.h"

#include "sipresponse.h"

#include "siprouteheader.h"

#include "sipexpiresheader.h"

#include "siptoheader.h"

#include "sipfromheader.h"

#include "sipcontactheader.h"

#include "sipcallidheader.h"

#include "sipaddress.h"

#include "uricontainer.h"

#include "sipuri.h"

#include "TSIPRemoteTargetAndProxy.h"

#include "SipAssert.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "sipcodecutils.h"

#include "sipsec.h"

#include "CSipConnectionMgr.h"

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

// CSipCSSubSession::NewLC

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

//

CSipCSSubSession* CSipCSSubSession::NewLC (CSipCSSession& aSession,

                                           MSIPSecUser& aSIPSecUser,

                                           TUint32 aIapId)

	{

    CSipCSSubSession* self =

        new(ELeave)CSipCSSubSession(aSession,aSIPSecUser,aIapId);

    CleanupClosePushL(*self); // CObject: Close will call the destructor.

    self->ConstructL();

    return self;

	}

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

// CSipCSSubSession::CSipCSSubSession

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

//

CSipCSSubSession::CSipCSSubSession (CSipCSSession& aSession,

                                    MSIPSecUser& aSIPSecUser,

									TUint32 aIapId)

: iSession (aSession),

  iSIPSecUser (aSIPSecUser),

  iTransportParams (aSession.ServerCore().CreateTransportOwnerId(), aIapId),

  iState (CSIPConnection::EInit),

  iIapOpened (EFalse)

	{

	}

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

// CSipCSSubSession::ConstructL

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

//

void CSipCSSubSession::ConstructL ()

	{

    iReceiver = CSipCSSubSessionReceiver::NewL(ITC(),iSIPSecUser,*this);

	}

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

// CSipCSSubSession::~CSipCSSubSession

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

//

CSipCSSubSession::~CSipCSSubSession()

	{

	if (iReceiver)

		{

        Server().DialogMgr().TerminateDialogsFor(iReceiver);

		Server().RegistrationMgr().ClearRegistrationOwner(iReceiver);

		Server().RefreshMgr().RemoveRefreshesFor(iReceiver);

		Server().TU().ClearTransactionOwner(iReceiver);

		}

	Server().SIPSec().ClearCache(&iSIPSecUser);

    delete iReceiver;

    if (iIapOpened && iState != CSIPConnection::EUnavailable)

        {

        // When a connection goes unavailable, 

        // ConnectionMgr destroys it immediately. 

        // After this the connection must not be closed from here, 

        // since this might mix up the reference count in ConnectionMgr.

        Server().ConnectionMgr().Close(iTransportParams);

        }

	} 

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

// CSipCSSubSession::TransportParams

// From MSIPCSReceiverOwner

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

//

const TSIPTransportParams& CSipCSSubSession::TransportParams() const

    {

    return iTransportParams;

    }

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

// CSipCSSubSession::TransportParams

// From MSIPCSReceiverOwner

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

//

TSIPTransportParams CSipCSSubSession::TransportParams(

    const TRegistrationId& aRegistrationId)

    {

    TSIPTransportParams transportParams(iTransportParams);

    if (aRegistrationId != KEmptyRegistrationId)

        {

        Server().RegistrationMgr().FillTransportParams(aRegistrationId,

                                                       transportParams);    

        // Filling params overrides ownerid, set correct value back

        transportParams.SetOwnerId( iTransportParams.OwnerId() );

        }

    return transportParams;

    }

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

// CSipCSSubSession::SIPSecUser

// From MSIPCSReceiverOwner

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

//

const MSIPSecUser* CSipCSSubSession::SIPSecUser(

    const TRegistrationId& aRegistrationId)

    {

    return Server().RegistrationMgr().SIPSecUser(aRegistrationId);

    }

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

// CSipCSSubSession::TransactionOwner

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

//

MTransactionOwner* CSipCSSubSession::TransactionOwner ()

	{

    return iReceiver;

	}

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

// CSipCSSubSession::Receiver

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

//	

CSipCSReceiverBase& CSipCSSubSession::Receiver()

    {

    return *iReceiver;

    }

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

// CSipCSSubSession::IapId

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

//

TUint32 CSipCSSubSession::IapId () const

    {

    return iTransportParams.IapId();

    }

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

// CSipCSSubSession::OpenIapL

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

//

void CSipCSSubSession::OpenIapL (const RMessage2& aMessage)

    {

    iState = Server().ConnectionMgr().OpenL(iTransportParams);

    iIapOpened = ETrue;

    ITC().WriteL(aMessage,iState);

    }

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

// CSipCSSubSession::SetStateL

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

//

void CSipCSSubSession::SetStateL (CSIPConnection::TState aState)

	{

    if (iState != aState)

        {

        iState = aState;

	    iReceiver->ConnectionStateChangedL(aState);

        }

	}

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

// CSipCSSubSession::ServiceL

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

//

void CSipCSSubSession::ServiceL (TSIPIds& aIds, 

                                 TInt aFunction, 

                                 const RMessage2& aMessage)

    {

    switch (aFunction)

		{

		case ESipItcGetLocalAddr:

		    GetLocalAddrL(aMessage); break;

		case ESipItcSetSIPSockOpt:

		    SetSIPSockOptL(aMessage); break;

		case ESipItcSetSIPSockOptWithDes:

		    SetSIPSockOptL(aMessage,ETrue); break;

		case ESipItcSetOutboundProxy:

            SetOutboundProxyL(aIds,aMessage); break;		

		case ESipItcOutboundProxy:

            OutboundProxyL(aIds,aMessage); break;

		case ESipItcRemoveOutboundProxy: 

			RemoveOutboundProxyL(aIds); break;

        case ESipItcRegister:

            RegisterL(aIds,aMessage); break;

		case ESipItcRegisterAndSetOutboundProxy:

			RegisterAndSetOutboundProxyL(aIds,aMessage); break;

        case ESipItcUpdateRegistration:

            UpdateRegistrationL(aIds,aMessage); break;

        case ESipItcUnRegister:

            UnRegisterL(aIds,aMessage); break;

        case ESipItcFetchRegistrations:

            FetchRegistrationsL(aMessage); break;

        case ESipItcSendRequest:

            SendRequestL(aIds,aMessage); break;

		case ESipItcSendRequestAndUpdateRefresh:

			SendRequestAndUpdateRefreshL (aIds,aMessage); break;

		case ESipItcSendRequestAndTerminateRefresh:

			SendRequestAndTerminateRefreshL (aIds,aMessage); break;

		case ESipItcSendResponse:

            SendResponseL(aIds,aMessage); break;

		case ESipItcSendCancel:

            SendCancelL(aIds,aMessage); break;

        case ESipItcSendResponseAndCreateDialog:

            SendResponseAndCreateDialogL(aIds,aMessage); break;

        case ESipItcSendResponseInDialog:

            SendResponseInDialogL(aIds,aMessage); break;

        case ESipItcSendRequestAndCreateDialog:

            SendRequestAndCreateDialogL(aIds,aMessage); break;

        case ESipItcSendRequestInDialog:

            SendRequestInDialogL(aIds,aMessage); break;

        case ESipItcSendRequestInDialogAndUpdateRefresh:

            SendRequestInDialogAndUpdateRefreshL(aIds,aMessage); break;

		case ESipItcTerminateDialog:

            TerminateDialogL(aIds.iDialogId); break;

		case ESipItcTerminateRefresh:

            TerminateRefreshL(aIds.iRefreshId); break;

		case ESipItcTerminateDialogRefresh:

            TerminateDialogRefreshL(aIds.iDialogId,aIds.iRefreshId); break;

        case ESipItcTerminateRegistration:

            TerminateRegistrationL(aIds.iRegistrationId); break;

        case ESipItcConnectionReadyToReceive: // Async. Do not complete yet.

            ClientReadyToReceiveL(aMessage); return;  

        case ESipItcConnectionReceiveSipMessage: 

            ReceiveSipMessageL(aMessage); break;

        case ESipItcConnectionCancelReceive: 

            CancelClientReceiveL(); break;

        case ESipItcGetFromHeader: 

            GetFromHeaderL(aIds.iRegistrationId,aMessage); break;

        case ESipItcSetRefreshInterval: 

            SetRefreshIntervalL(aIds.iRefreshId,aMessage); break;

        case ESipItcGetRefreshInterval: 

            GetRefreshIntervalL(aIds.iRefreshId,aMessage); break;

		case ESipItcGetCallIDHeader:

		    GetCallIDHeaderL(aIds.iDialogId,aMessage); break;

		case ESipItcGetLocalTag:

		    GetLocalTagL(aIds.iDialogId,aMessage); break;

		case ESipItcGetRegisteredContact:

		    GetRegisteredContactL(aIds.iRegistrationId,aMessage); break;

        case ESipItcResetDialogState:

            ResetDialogStateL(aIds.iDialogId); break;

        case ESipItcRefreshConnection:

        	RefreshConnectionL(aIds.iIapId); break;

        case ESipItcGetConnectionError:

        	GetConnectionErrorL(aIds,aMessage); break;

        default: ITC().PanicClient (aMessage, EBadRequest); break;

        }

    ITC().Complete (aMessage, KErrNone);

    }

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

// CSipCSSubSession::GetLocalAddrL

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

//  

void CSipCSSubSession::GetLocalAddrL(const RMessage2& aMessage)

    {

    TInt err = Server().ConnectionMgr().GetLocalAddress(

        iTransportParams.IapId(),iLocalAddr);

    User::LeaveIfError(err);

    ITC().WriteL(aMessage,iLocalAddr);

    }

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

// CSipCSSubSession::SetSIPSockOptL

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

//

void CSipCSSubSession::SetSIPSockOptL(const RMessage2& aMessage, TBool aDesOpt)

    {

    TSIPSockOpt opt(ITC().ReadSIPSockOptL(aMessage));

    if (aDesOpt)

        {

        HBufC8* desOptBuf = ITC().ReadLC(aMessage,ESipItcArgSockOptDes);

        Server().ConnectionMgr().SetOptL(

            iTransportParams, opt.iOptionName, opt.iOptionLevel, *desOptBuf);

        CleanupStack::PopAndDestroy(desOptBuf);

        }

    else

        {

        Server().ConnectionMgr().SetOptL(

            iTransportParams, opt.iOptionName, opt.iOptionLevel, opt.iOption);        

        }

    }

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

// CSipCSSubSession::SetOutboundProxyL

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

//

void CSipCSSubSession::SetOutboundProxyL (TSIPIds& aIds,

                                          const RMessage2& aMessage)

	{

	CSIPRouteHeader* proxy = ITC().ReadProxyLC(aMessage);

	Server().RegistrationMgr().SetOutboundProxyL(aIds.iRegistrationId,proxy,

	                                             iReceiver);

	CleanupStack::Pop(proxy);

	}

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

// CSipCSSubSession::OutboundProxyL

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

//

void CSipCSSubSession::OutboundProxyL (TSIPIds& aIds, const RMessage2& aMessage)

	{

    if (Server().Registrations().HasOutboundProxy(aIds.iRegistrationId))

        {

	    const CSIPRouteHeader* proxy = 

		    Server().Registrations().OutboundProxy(aIds.iRegistrationId);

		if (proxy)

		    {

		    ITC().WriteL(aMessage,*proxy);

		    }

        else

            {

            User::Leave(KErrNotFound);

            }

        }

	}

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

// CSipCSSubSession::RemoveOutboundProxyL

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

//

void CSipCSSubSession::RemoveOutboundProxyL (TSIPIds& aIds)

	{

	TInt err = Server().RegistrationMgr().RemoveOutboundProxy(

	    aIds.iRegistrationId, iReceiver);

	if (err != KErrNone)

        {

        User::Leave(err);

        }

	}

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

// CSipCSSubSession::RegisterL

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

//

void CSipCSSubSession::RegisterL (TSIPIds& aIds, const RMessage2& aMessage)

	{

	CSIPRequest* request = 

	    CSIPRequest::NewLC(SIPStrings::StringF(SipStrConsts::ERegister));

    CURIContainer* remoteTarget = FillRequestLC(aMessage,*request);

    CheckSigCompInNextHopL(KEmptyRegistrationId,*remoteTarget,*request);

    Server().RegistrationMgr().RegisterL(aIds.iRequestId,aIds.iRegistrationId,

                                         request,*remoteTarget,iReceiver,

                                         iSIPSecUser,0,aIds.iRefresh,

                                         aIds.iSendWithExpires,

                                         aIds.iCacheOutboundProxyIP);

    CleanupStack::PopAndDestroy(remoteTarget);

    CleanupStack::Pop(request);

    ITC().WriteL(aMessage,aIds);

	}

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

// CSipCSSubSession::RegisterAndSetOutboundProxyL

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

//

void CSipCSSubSession::RegisterAndSetOutboundProxyL (TSIPIds& aIds,

                                                     const RMessage2& aMessage)

	{

	CSIPRequest* request = 

	    CSIPRequest::NewLC(SIPStrings::StringF(SipStrConsts::ERegister));

    TSIPRemoteTargetAndProxy remoteTargetAndProxy;

    FillRequestL(aMessage,*request,remoteTargetAndProxy,EFalse,ETrue);

    CleanupStack::PushL (remoteTargetAndProxy.iProxy);

    CleanupStack::PushL (remoteTargetAndProxy.iRemoteTarget);

    CURIContainer* remoteTarget = remoteTargetAndProxy.iRemoteTarget;

    CheckSigCompInNextHopL(KEmptyRegistrationId,*remoteTarget,*request);

    Server().RegistrationMgr().RegisterL(aIds.iRequestId,aIds.iRegistrationId,

                                         request,*remoteTarget,

                                         iReceiver,iSIPSecUser,

                                         remoteTargetAndProxy.iProxy, 

                                         aIds.iRefresh,

                                         aIds.iSendWithExpires,

                                         aIds.iCacheOutboundProxyIP);

    CleanupStack::PopAndDestroy(remoteTargetAndProxy.iRemoteTarget);

    CleanupStack::Pop(remoteTargetAndProxy.iProxy);

    CleanupStack::Pop(request);    

    ITC().WriteL (aMessage,aIds);

	}

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

// CSipCSSubSession::UpdateRegistrationL

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

//

void CSipCSSubSession::UpdateRegistrationL (TSIPIds& aIds,

                                            const RMessage2& aMessage)

	{

	CSIPRequest* request = 

	    CSIPRequest::NewLC(SIPStrings::StringF(SipStrConsts::ERegister));

    ITC().ReadRequestL (aMessage,*request);

    Server().RegistrationMgr().UpdateRegistrationL(aIds.iRegistrationId,

	                                               aIds.iRequestId, request,

	                                               iReceiver);

    CleanupStack::Pop(request);

    ITC().WriteL(aMessage,aIds);

	}

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

// CSipCSSubSession::UnRegisterL

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

//

void CSipCSSubSession::UnRegisterL (TSIPIds& aIds, const RMessage2& aMessage)

	{

	CSIPRequest* request = 

	    CSIPRequest::NewLC(SIPStrings::StringF(SipStrConsts::ERegister));

    ITC().ReadRequestL (aMessage,*request);

    Server().RegistrationMgr().UnRegisterL(aIds.iRegistrationId, 

                                           aIds.iRequestId, request,

                                           iReceiver);

    CleanupStack::Pop(request);

    ITC().WriteL(aMessage,aIds);

	}

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

// CSipCSSubSession::FetchRegistrationsL

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

//

void CSipCSSubSession::FetchRegistrationsL (const RMessage2& aMessage)

	{

	TSIPIds ids;

	CSIPRequest* request = 

	    CSIPRequest::NewLC(SIPStrings::StringF(SipStrConsts::ERegister));

    CURIContainer* remoteTarget = FillRequestLC(aMessage,*request);

    CheckSigCompInNextHopL(KEmptyRegistrationId,*remoteTarget,*request);

    Server().RegistrationMgr().FetchRegistrationsL(iTransportParams, 

                                                   ids.iRequestId, request,

                                                   *remoteTarget, iReceiver);

    CleanupStack::PopAndDestroy(remoteTarget);

    CleanupStack::Pop(request);

    ITC().WriteL(aMessage,ids);

	}

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

// CSipCSSubSession::SendRequestL

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

//

void CSipCSSubSession::SendRequestL (TSIPIds& aIds,

                                     const RMessage2& aMessage)

	{

    CSIPRequest* request = CSIPRequest::NewLC();

    CURIContainer* remoteTarget = FillRequestLC(aMessage,*request,ETrue);