// 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 : InviteUASStates.cpp
// Part of : TransactionUser
// Version : SIP/6.0
//
#include "siperr.h"
#include "sipresponse.h"
#include "siprequest.h"
#include "SipLogs.h"
#include "SipAssert.h"
#include "InviteUAS.h"
#include "InviteUASStates.h"
#include "SIPMessageUtility.h"
// -----------------------------------------------------------------------------
// CInviteUAS_Start::CInviteUAS_Start
// -----------------------------------------------------------------------------
//
CInviteUAS_Start::CInviteUAS_Start()
{
}
// -----------------------------------------------------------------------------
// CInviteUAS_Start::~CInviteUAS_Start
// -----------------------------------------------------------------------------
//
CInviteUAS_Start::~CInviteUAS_Start()
{
}
// -----------------------------------------------------------------------------
// CInviteUAS_Start::SetNeighbourStates
// -----------------------------------------------------------------------------
//
void CInviteUAS_Start::SetNeighbourStates(CUserAgentState& aGetTxOwner,
CUserAgentState& aWaitRespFromApp,
CUserAgentState& aRejected)
{
iGetTxOwner = &aGetTxOwner;
iWaitRespFromApp = &aWaitRespFromApp;
iRejected = &aRejected;
}
// -----------------------------------------------------------------------------
// CInviteUAS_Start::TransactionEndsL
// Can happen if leave occurs when obtaining upper layer callback.
// -----------------------------------------------------------------------------
//
void
CInviteUAS_Start::TransactionEndsL(CUserAgent& aUserAgent, TInt aReason) const
{
aUserAgent.Stop(aReason);
}
// -----------------------------------------------------------------------------
// CInviteUAS_Start::ReceiveL
// -----------------------------------------------------------------------------
//
void
CInviteUAS_Start::ReceiveL(CUserAgent& aUserAgent, CSIPRequest* aRequest) const
{
__SIP_ASSERT_LEAVE(aRequest, KErrArgument);
CInviteUAS::Ptr(aUserAgent).InitialRequestReceivedL(aRequest,
*iGetTxOwner,
*iWaitRespFromApp,
*iRejected);
}
// -----------------------------------------------------------------------------
// CInviteUAS_Start::SendResponseL
// Application shouldn't know about this transactionId yet
// -----------------------------------------------------------------------------
//
void
CInviteUAS_Start::SendResponseL(CUserAgent& /*aUserAgent*/,
CSIPResponse* aResp,
const TSIPTransportParams& /*aParams*/) const
{
__SIP_ASSERT_LEAVE(aResp, KErrArgument);
User::Leave(KErrSIPInvalidTransactionState);
}
// -----------------------------------------------------------------------------
// CInviteUAS_Start::CancelL
// -----------------------------------------------------------------------------
//
TBool CInviteUAS_Start::CancelL(CUserAgent& aUserAgent) const
{
CInviteUAS::Ptr(aUserAgent).HandleCancelInviteL(*iRejected);
return ETrue;
}
// -----------------------------------------------------------------------------
// CInviteUAS_GetTxOwner::CInviteUAS_GetTxOwner
// -----------------------------------------------------------------------------
//
CInviteUAS_GetTxOwner::CInviteUAS_GetTxOwner()
{
}
// -----------------------------------------------------------------------------
// CInviteUAS_GetTxOwner::~CInviteUAS_GetTxOwner
// -----------------------------------------------------------------------------
//
CInviteUAS_GetTxOwner::~CInviteUAS_GetTxOwner()
{
}
// -----------------------------------------------------------------------------
// CInviteUAS_GetTxOwner::SetNeighbourStates
// -----------------------------------------------------------------------------
//
void
CInviteUAS_GetTxOwner::SetNeighbourStates(CUserAgentState& aWaitRespFromApp,
CUserAgentState& aRejected)
{
iWaitRespFromApp = &aWaitRespFromApp;
iRejected = &aRejected;
}
// -----------------------------------------------------------------------------
// CInviteUAS_GetTxOwner::OwnerFoundL
// -----------------------------------------------------------------------------
//
void CInviteUAS_GetTxOwner::OwnerFoundL(CUserAgent& aUserAgent,
MTransactionOwner* aOwner) const
{
__SIP_ASSERT_LEAVE(aOwner, KErrArgument);
CInviteUAS::Ptr(aUserAgent).HandleOwnerFoundL(aOwner, *iWaitRespFromApp);
}
// -----------------------------------------------------------------------------
// CInviteUAS_GetTxOwner::OwnerNotFoundL
// -----------------------------------------------------------------------------
//
void CInviteUAS_GetTxOwner::OwnerNotFoundL(CUserAgent& aUserAgent,
CSIPResponse* aResp) const
{
__SIP_ASSERT_LEAVE(aResp, KErrArgument);
CInviteUAS::Ptr(aUserAgent).HandleOwnerNotFoundL(aResp, *iRejected);
}
// -----------------------------------------------------------------------------
// CInviteUAS_GetTxOwner::SendResponseL
// Application shouldn't know about this transaction yet
// -----------------------------------------------------------------------------
//
void CInviteUAS_GetTxOwner::SendResponseL(CUserAgent& /*aUserAgent*/,
CSIPResponse* aResp,
const TSIPTransportParams& /*aParams*/) const
{
__SIP_ASSERT_LEAVE(aResp, KErrArgument);
User::Leave(KErrSIPInvalidTransactionState);
}
// -----------------------------------------------------------------------------
// CInviteUAS_GetTxOwner::TransactionEndsL
// -----------------------------------------------------------------------------
//
void CInviteUAS_GetTxOwner::TransactionEndsL(CUserAgent& aUserAgent,
TInt aReason) const
{
aUserAgent.Stop(aReason);
}
// -----------------------------------------------------------------------------
// CInviteUAS_GetTxOwner::TimerExpiredL
// -----------------------------------------------------------------------------
//
void CInviteUAS_GetTxOwner::TimerExpiredL(CUserAgent& aUserAgent,
TTimerId aTimerId,
TAny* aTimerParam) const
{
__SIP_ASSERT_LEAVE(aTimerParam, KErrArgument);
HandleTimerExpirationL(aUserAgent, aTimerId, aTimerParam);
}
// -----------------------------------------------------------------------------
// CInviteUAS_GetTxOwner::RequestRouterErrorL
// -----------------------------------------------------------------------------
//
void CInviteUAS_GetTxOwner::RequestRouterErrorL(CUserAgent& aUserAgent) const
{
static_cast<CUserAgentServer*>(&aUserAgent)->
HandleRequestRouterErrorL(*iRejected);
}
// -----------------------------------------------------------------------------
// CInviteUAS_GetTxOwner::CancelL
// -----------------------------------------------------------------------------
//
TBool CInviteUAS_GetTxOwner::CancelL(CUserAgent& aUserAgent) const
{
CInviteUAS::Ptr(aUserAgent).HandleCancelInviteL(*iRejected);
return ETrue;
}
// -----------------------------------------------------------------------------
// CInviteUAS_WaitRespFromApp::CInviteUAS_WaitRespFromApp
// -----------------------------------------------------------------------------
//
CInviteUAS_WaitRespFromApp::CInviteUAS_WaitRespFromApp()
{
}
// -----------------------------------------------------------------------------
// CInviteUAS_WaitRespFromApp::~CInviteUAS_WaitRespFromApp
// -----------------------------------------------------------------------------
//
CInviteUAS_WaitRespFromApp::~CInviteUAS_WaitRespFromApp()
{
}
// -----------------------------------------------------------------------------
// CInviteUAS_WaitRespFromApp::SetNeighbourStates
// -----------------------------------------------------------------------------
//
void CInviteUAS_WaitRespFromApp::SetNeighbourStates(CUserAgentState& aAccepted,
CUserAgentState& aRejected)
{
iAccepted = &aAccepted;
iRejected = &aRejected;
}
// -----------------------------------------------------------------------------
// CInviteUAS_WaitRespFromApp::SendResponseL
// -----------------------------------------------------------------------------
//
void CInviteUAS_WaitRespFromApp::SendResponseL(CUserAgent& aUserAgent,
CSIPResponse* aResp,
const TSIPTransportParams& aParams) const
{
__SIP_ASSERT_LEAVE(aResp, KErrArgument);
CInviteUAS& ua = CInviteUAS::Ptr(aUserAgent);
ua.HandleSendResponseL(aResp, aParams);
if (aResp->Type() == CSIPResponse::E2XX)
{
aUserAgent.ChangeState(*iAccepted);
ua.SendFirst2xxL(aResp);
}
else
{
if (aResp->IsErrorResponse())
{
// Enter "rejected" before sending response to transaction. If
// transaction ends already in SendMessageToTransactionL, UAS is in
// the correct state.
aUserAgent.ChangeState(*iRejected);
}
ua.SendResponseToTransactionL(aResp);
}
}
// -----------------------------------------------------------------------------
// CInviteUAS_WaitRespFromApp::TransactionEndsL
// Transaction ends, likely application hasn't sent any final response.
// -----------------------------------------------------------------------------
//
void CInviteUAS_WaitRespFromApp::TransactionEndsL(CUserAgent& aUserAgent,
TInt aReason) const
{
aUserAgent.Stop(aReason);
}
// -----------------------------------------------------------------------------
// CInviteUAS_WaitRespFromApp::ShouldUASStop
// -----------------------------------------------------------------------------
//
TBool CInviteUAS_WaitRespFromApp::ShouldUASStop() const
{
return ETrue;
}
// -----------------------------------------------------------------------------
// CInviteUAS_WaitRespFromApp::CancelL
// -----------------------------------------------------------------------------
//
TBool CInviteUAS_WaitRespFromApp::CancelL(CUserAgent& aUserAgent) const
{
CInviteUAS::Ptr(aUserAgent).HandleCancelInviteL(*iRejected);
return ETrue;
}
// -----------------------------------------------------------------------------
// CInviteUAS_Accepted::CInviteUAS_Accepted
// -----------------------------------------------------------------------------
//
CInviteUAS_Accepted::CInviteUAS_Accepted()
{
}
// -----------------------------------------------------------------------------
// CInviteUAS_Accepted::~CInviteUAS_Accepted
// -----------------------------------------------------------------------------
//
CInviteUAS_Accepted::~CInviteUAS_Accepted()
{
}
// -----------------------------------------------------------------------------
// CInviteUAS_Accepted::SendResponseL
// Final response has already been sent
// -----------------------------------------------------------------------------
//
void
CInviteUAS_Accepted::SendResponseL(CUserAgent& /*aUserAgent*/,
CSIPResponse* aResp,
const TSIPTransportParams& /*aParams*/) const
{
__SIP_ASSERT_LEAVE(aResp, KErrArgument);
User::Leave(KErrSIPInvalidTransactionState);
}
// -----------------------------------------------------------------------------
// CInviteUAS_Accepted::TransactionEndsL
// Free the transaction that sent the first 2xx. Even if send failed, UAS begins
// to retransmit the 2xx, regardless of the used transport protocol.
// -----------------------------------------------------------------------------
//
void CInviteUAS_Accepted::TransactionEndsL(CUserAgent& aUserAgent,
TInt /*aReason*/) const
{
aUserAgent.RequestDeletionOfTransactionL();
CInviteUAS::Ptr(aUserAgent).StartTimerRetransmit2xxL();
}
// -----------------------------------------------------------------------------
// CInviteUAS_Accepted::ReceiveL
// -----------------------------------------------------------------------------
//
void CInviteUAS_Accepted::ReceiveL(CUserAgent& aUserAgent,
CSIPRequest* aRequest) const
{
__SIP_ASSERT_LEAVE(aRequest, KErrArgument);
if (CSIPMessageUtility::IsAck(*aRequest))
{
// Received ACK to 2xx directly from ConnectionMgr. CUserAgent::ReceiveL
// wrote ACK to log, unless CUserAgent::iTransaction still runs.
if (aUserAgent.Transaction())
{
__SIP_MESSAGE_LOG("TransactionUser", *aRequest)
}
CInviteUAS& ua = CInviteUAS::Ptr(aUserAgent);
ua.StopTimerRetransmit2xx();
// Ask MTransactionOwner also for ACK
if (ua.DoesDialogExistForAckL(*aRequest))
{
aUserAgent.PassMsgToTransactionOwnerL(aRequest);
aUserAgent.Stop(KErrNone);
}
else
{
// Broken ACK. No need to wait any more.
delete aRequest;
aUserAgent.Stop(KErrTimedOut);
}
}
else
{
// Drop other messages than ACKs
delete aRequest;
}
}
// -----------------------------------------------------------------------------
// CInviteUAS_Accepted::SendCompleteL
// -----------------------------------------------------------------------------
//
void CInviteUAS_Accepted::SendCompleteL(CUserAgent& aUserAgent) const
{
CInviteUAS::Ptr(aUserAgent).StartTimerRetransmit2xxL();
}
// -----------------------------------------------------------------------------
// CInviteUAS_Accepted::SendFailedL
// Sending 2xx failed. Response can't be sent to any other address, so stop.
// -----------------------------------------------------------------------------
//
void CInviteUAS_Accepted::SendFailedL(CUserAgent& aUserAgent,
TInt aError) const
{
aUserAgent.Stop(aError);
}
// -----------------------------------------------------------------------------
// CInviteUAS_Accepted::TimerExpiredL
// -----------------------------------------------------------------------------
//
void CInviteUAS_Accepted::TimerExpiredL(CUserAgent& aUserAgent,
TTimerId aTimerId,
TAny* aTimerParam) const
{
__SIP_ASSERT_LEAVE(aTimerParam, KErrArgument);
HandleTimerExpirationL(aUserAgent, aTimerId, aTimerParam);
}
// -----------------------------------------------------------------------------
// CInviteUAS_Accepted::CancelL
// -----------------------------------------------------------------------------
//
TBool CInviteUAS_Accepted::CancelL(CUserAgent& aUserAgent) const
{
CInviteUAS::Ptr(aUserAgent).InformObserverAboutCancel();
return ETrue;
}
// -----------------------------------------------------------------------------
// CInviteUAS_Rejected::CInviteUAS_Rejected
// -----------------------------------------------------------------------------
//
CInviteUAS_Rejected::CInviteUAS_Rejected()
{
}
// -----------------------------------------------------------------------------
// CInviteUAS_Rejected::~CInviteUAS_Rejected
// -----------------------------------------------------------------------------
//
CInviteUAS_Rejected::~CInviteUAS_Rejected()
{
}
// -----------------------------------------------------------------------------
// CInviteUAS_Rejected::TransactionEndsL
// -----------------------------------------------------------------------------
//
void CInviteUAS_Rejected::TransactionEndsL(CUserAgent& aUserAgent,
TInt aReason) const
{
aUserAgent.Stop(aReason);
}
// -----------------------------------------------------------------------------
// CInviteUAS_Rejected::SendResponseL
// Final response has already been sent
// -----------------------------------------------------------------------------
//
void
CInviteUAS_Rejected::SendResponseL(CUserAgent& /*aUserAgent*/,
CSIPResponse* aResp,
const TSIPTransportParams& /*aParams*/) const
{
__SIP_ASSERT_LEAVE(aResp, KErrArgument);
User::Leave(KErrSIPInvalidTransactionState);
}