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

// Part of       : SIP Registration

// Version       : SIP/4.0 

//

#include "csipregistered.h"

#include "csip423responsereceived.h"

#include "SipAssert.h"

#include "siprequest.h"

#include "sipresponse.h"

#include "sipminexpiresheader.h"

#include "CSIPResponseUtility.h"

#include "MRegistrationOwner.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "siperr.h"

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

// CSIPRegistered::NewL

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

//

CSIPRegistered* CSIPRegistered::NewL(MRegistrationContext& aRegistration)

	{

	CSIPRegistered* self = CSIPRegistered::NewLC(aRegistration);

	CleanupStack::Pop(self);

	return self;

	}

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

// CSIPRegistered::NewLC

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

//	

CSIPRegistered* CSIPRegistered::NewLC(MRegistrationContext& aRegistration)

	{

	CSIPRegistered* self = new (ELeave) CSIPRegistered(aRegistration);

	CleanupStack::PushL(self);

	return self;

	}

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

// CSIPRegistered::SetNeighbourStates

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

//

void CSIPRegistered::SetNeighbourStates(

	CSIPRegistrationState* aUpdating,

	CSIPRegistrationState* aUnregistering,

	CSIPRegistrationState* aUnregistered,

	CSIPRegistrationState* aResponse423Received)

	{

	__SIP_ASSERT_RETURN(aUpdating, KErrArgument);

    __SIP_ASSERT_RETURN(aUnregistering, KErrArgument);

	__SIP_ASSERT_RETURN(aUnregistered, KErrArgument);

	__SIP_ASSERT_RETURN(aResponse423Received, KErrArgument);

   	iUpdating = aUpdating;

    iUnregistering = aUnregistering;

    iUnregistered = aUnregistered;

	iResponse423Received = aResponse423Received; 

	}

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

// CSIPRegistered::~CSIPRegistered

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

//	

CSIPRegistered::~CSIPRegistered()

	{

	}

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

// CSIPRegistered::UpdateL

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

//		

void CSIPRegistered::UpdateL(TTransactionId& aTransactionId,

				             CSIPRequest*    aRequest)

	{

	__SIP_ASSERT_LEAVE(aRequest, KErrArgument);

	iRegistration.ChangeState(iUpdating);

	iRegistration.CurrentState().UpdateL(aTransactionId, aRequest);

	}

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

// CSIPRegistered::UnregisterL

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

//		

void CSIPRegistered::UnregisterL(TTransactionId& aTransactionId,

					             CSIPRequest*    aRequest)

	{

	__SIP_ASSERT_LEAVE(aRequest, KErrArgument);

	iRegistration.ChangeState(iUnregistering);

	iRegistration.CurrentState().UnregisterL(aTransactionId, aRequest);

	}

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

// CSIPRegistered::ReceiveL

//

// this function is called when subsequent refresh response is received

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

//		

void CSIPRegistered::ReceiveL(TTransactionId aTransactionId,

		                      CSIPResponse*  aResponse)

	{

	__SIP_ASSERT_LEAVE(aResponse, KErrArgument);

	if (aResponse->Type() == CSIPResponse::E2XX) // 200-299

		{

		if (!iRegistration.ServiceRouteOk(*aResponse))

			{

			iRegistration.ReceivedErrorResponseL();

			User::LeaveIfError(

			    PassErrorToOwner(KErrSIPTransportFailure,aTransactionId,

			                     iRegistration.RegistrationId()));

			delete aResponse;

			iRegistration.SelfDetach(ETrue);

			iRegistration.ChangeState(iUnregistered);

			return;

			}

		iRegistration.SetRouteHeaderFromResponseL(*aResponse);

		iRegistration.Received2XXResponseL(*aResponse,aTransactionId);

		if (iRegistration.Request())

			{

			iRegistration.Request()->DeleteHeaders(

				SIPStrings::StringF(SipStrConsts::ERouteHeader));

			}

		// don't forward subsequent 2xx response to owner

	    delete aResponse; 

		}

	else if (aResponse->IsErrorResponse()) // 300-

		{

        const RStringF KMinExpiresHeaderName = 

            SIPStrings::StringF(SipStrConsts::EMinExpiresHeader);		

		if (aResponse->ResponseCode() == K423Response &&

			aResponse->HasHeader(KMinExpiresHeaderName))

			{

			iRegistration.Received423ResponseL(*aResponse);

			iRegistration.ChangeState(iResponse423Received);	

			static_cast<CSIP423ResponseReceived*>(iResponse423Received)->

				SetUpdate(ETrue);

			iRegistration.CurrentState().RegisterL(

			    aTransactionId,iRegistration.Request(),NULL);

			delete aResponse;

			}

		// this happens when error response received from subsequent register.

		else

			{

			// ReceivedErrorResponseL, remove binding 

			iRegistration.ReceivedErrorResponseL();

			// pass response to owner

			PassResponseToOwnerL(aResponse, aTransactionId, 

				iRegistration.RegistrationId());

			iRegistration.SelfDetach(ETrue);

			iRegistration.ChangeState(iUnregistered);

			}

		}

	else // is provisional response 100-199

		{

		// do not forward subsequent 1xx response to owner

		delete aResponse; 

		}

	}

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

// CSIPRegistered::TransactionEnded

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

//		

TInt CSIPRegistered::TransactionEnded(TTransactionId aTransactionId, 

		                              TInt           aReason)

	{

	if (aReason != KErrNone)

		{

		iRegistration.ChangeState(iUnregistered);

		}

	// pass error to owner.

	return (PassErrorToOwner(aReason, aTransactionId, 

		iRegistration.RegistrationId()));	

	}

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

// CSIPRegistered::CSIPRegistered

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

//	

CSIPRegistered::CSIPRegistered(MRegistrationContext& aRegistration)

	: CSIPRegistrationState (aRegistration) 

	{

	}