Got rid of some trivial warnings (nested comments and tokens after #endif).
// Copyright (c) 2003-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 : SIPSubscribeDialogAssoc.cpp
// Part of : SIPAPI
// Version : SIP/4.0
//
#include <uri8.h>
#include "sip.h"
#include "siperr.h"
#include "sipsubscribedialogassoc.h"
#include "SipDialogAssocImplementation.h"
#include "SipDialogImplementation.h"
#include "SipConnectionImplementation.h"
#include "sipclientconnection.h"
#include "sipclienttransaction.h"
#include "sipregistrationcontext.h"
#include "siprefresh.h"
#include "siptoheader.h"
#include "sipfromheader.h"
#include "sipexpiresheader.h"
#include "sipcontactheader.h"
#include "sipeventheader.h"
#include "sipmessageelements.h"
#include "sipstrings.h"
#include "sipstrconsts.h"
#include "MessageHeaderCleanup.h"
#ifdef CPPUNIT_TEST
#include "TestCleanupStack.h"
#undef EXPORT_C
#define EXPORT_C
#endif
// -----------------------------------------------------------------------------
// CSIPSubscribeDialogAssoc::NewL
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPSubscribeDialogAssoc*
CSIPSubscribeDialogAssoc::NewL(CSIPDialog& aDialog, CSIPEventHeader* aEvent)
{
CSIPSubscribeDialogAssoc* self =
CSIPSubscribeDialogAssoc::NewLC(aDialog, aEvent);
CleanupStack::Pop(self);
return self;
}
// -----------------------------------------------------------------------------
// CSIPSubscribeDialogAssoc::NewLC
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPSubscribeDialogAssoc*
CSIPSubscribeDialogAssoc::NewLC(CSIPDialog& aDialog, CSIPEventHeader* aEvent)
{
__ASSERT_ALWAYS(aEvent, User::Leave(KErrArgument));
CSIPSubscribeDialogAssoc* self = new (ELeave) CSIPSubscribeDialogAssoc();
CleanupStack::PushL(self);
self->CSIPDialogAssocBase::ConstructL(
SIPStrings::StringF(SipStrConsts::ESubscribe),
aDialog);
self->iEvent = aEvent;
return self;
}
// -----------------------------------------------------------------------------
// CSIPSubscribeDialogAssoc::NewL
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPSubscribeDialogAssoc*
CSIPSubscribeDialogAssoc::NewL(CSIPConnection& aConnection,
CSIPFromHeader* aFrom,
CUri8* aRemoteUri,
CSIPEventHeader* aEvent,
CSIPToHeader* aTo,
CSIPContactHeader* aContact)
{
CSIPSubscribeDialogAssoc* self =
CSIPSubscribeDialogAssoc::NewLC(aConnection,
aFrom,
aRemoteUri,
aEvent,
aTo,
aContact);
CleanupStack::Pop(self);
return self;
}
// -----------------------------------------------------------------------------
// CSIPSubscribeDialogAssoc::NewLC
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPSubscribeDialogAssoc*
CSIPSubscribeDialogAssoc::NewLC(CSIPConnection& aConnection,
CSIPFromHeader* aFrom,
CUri8* aRemoteUri,
CSIPEventHeader* aEvent,
CSIPToHeader* aTo,
CSIPContactHeader* aContact)
{
__ASSERT_ALWAYS(aFrom, User::Leave(KErrArgument));
return CSIPSubscribeDialogAssoc::NewLC(aConnection,
aRemoteUri,
aEvent,
aFrom,
aTo,
aContact,
NULL);
}
// -----------------------------------------------------------------------------
// CSIPSubscribeDialogAssoc::NewL
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPSubscribeDialogAssoc*
CSIPSubscribeDialogAssoc::NewL(CSIPConnection& aConnection,
CUri8* aRemoteUri,
const MSIPRegistrationContext& aContext,
CSIPEventHeader* aEvent,
CSIPFromHeader* aFrom,
CSIPToHeader* aTo,
CSIPContactHeader* aContact)
{
CSIPSubscribeDialogAssoc* self =
CSIPSubscribeDialogAssoc::NewLC(aConnection,
aRemoteUri,
aContext,
aEvent,
aFrom,
aTo,
aContact);
CleanupStack::Pop(self);
return self;
}
// -----------------------------------------------------------------------------
// CSIPSubscribeDialogAssoc::NewLC
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPSubscribeDialogAssoc*
CSIPSubscribeDialogAssoc::NewLC(CSIPConnection& aConnection,
CUri8* aRemoteUri,
const MSIPRegistrationContext& aContext,
CSIPEventHeader* aEvent,
CSIPFromHeader* aFrom,
CSIPToHeader* aTo,
CSIPContactHeader* aContact)
{
__ASSERT_ALWAYS(aContext.IsContextActive(),
User::Leave(KErrSIPInvalidRegistrationState));
return CSIPSubscribeDialogAssoc::NewLC(aConnection,
aRemoteUri,
aEvent,
aFrom,
aTo,
aContact,
&aContext);
}
// -----------------------------------------------------------------------------
// CSIPSubscribeDialogAssoc::NewLC
// -----------------------------------------------------------------------------
//
CSIPSubscribeDialogAssoc*
CSIPSubscribeDialogAssoc::NewLC(CSIPConnection& aConnection,
CUri8* aRemoteUri,
CSIPEventHeader* aEvent,
CSIPFromHeader* aFrom,
CSIPToHeader* aTo,
CSIPContactHeader* aContact,
const MSIPRegistrationContext* aContext)
{
__ASSERT_ALWAYS(aRemoteUri && aEvent, User::Leave(KErrArgument));
CSIPDialogImplementation* dialogImpl =
CSIPDialogImplementation::NewLC(aConnection.Implementation(),
aContext);
CSIPSubscribeDialogAssoc* self =
CSIPSubscribeDialogAssoc::NewL(dialogImpl->Dialog(), aEvent);
//Don't take ownership of aEvent yet, as leave can occur
self->iEvent = NULL;
CleanupStack::Pop(dialogImpl);
CleanupStack::PushL(self);
dialogImpl->SetHeadersL(aFrom, aTo, aRemoteUri, aContact);
self->iEvent = aEvent;
return self;
}
// -----------------------------------------------------------------------------
// CSIPSubscribeDialogAssoc::CSIPSubscribeDialogAssoc
// -----------------------------------------------------------------------------
//
CSIPSubscribeDialogAssoc::CSIPSubscribeDialogAssoc()
{
}
// -----------------------------------------------------------------------------
// CSIPSubscribeDialogAssoc::~CSIPSubscribeDialogAssoc
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPSubscribeDialogAssoc::~CSIPSubscribeDialogAssoc()
{
delete iRefresh;
delete iEvent;
}
// -----------------------------------------------------------------------------
// CSIPSubscribeDialogAssoc::SendSubscribeL
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPClientTransaction*
CSIPSubscribeDialogAssoc::SendSubscribeL(CSIPMessageElements* aElements,
CSIPRefresh* aSIPRefresh)
{
return Dialog().Implementation().SendSubscribeL(*this,
aElements,
aSIPRefresh);
}
// -----------------------------------------------------------------------------
// CSIPSubscribeDialogAssoc::UpdateL
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPClientTransaction*
CSIPSubscribeDialogAssoc::UpdateL(CSIPMessageElements* aElements)
{
__ASSERT_ALWAYS(aElements &&
aElements->UserHeaderCount(
SIPStrings::StringF(SipStrConsts::EEventHeader)) == 0,
User::Leave(KErrArgument));
return Dialog().Implementation().UpdateL(*this, aElements);
}
// -----------------------------------------------------------------------------
// CSIPSubscribeDialogAssoc::SendUnsubscribeL
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPClientTransaction*
CSIPSubscribeDialogAssoc::SendUnsubscribeL(CSIPMessageElements* aElements)
{
return Dialog().Implementation().SendUnsubscribeL(*this, aElements);
}
// -----------------------------------------------------------------------------
// CSIPSubscribeDialogAssoc::Event
// -----------------------------------------------------------------------------
//
EXPORT_C const CSIPEventHeader& CSIPSubscribeDialogAssoc::Event() const
{
return *iEvent;
}
// -----------------------------------------------------------------------------
// CSIPSubscribeDialogAssoc::ConnectionLost
// -----------------------------------------------------------------------------
//
void CSIPSubscribeDialogAssoc::ConnectionLost()
{
if (iRefresh)
{
iRefresh->ChangeState(CSIPRefresh::ETerminated);
}
}
// -----------------------------------------------------------------------------
// CSIPSubscribeDialogAssoc::DoSendSubscribeL
// If subscription is already being refreshed, leaves with KErrAlreadyExists
// -----------------------------------------------------------------------------
//
CSIPClientTransaction*
CSIPSubscribeDialogAssoc::DoSendSubscribeL(CSIPMessageElements* aElements,
CSIPRefresh* aRefresh,
TBool aWithinDialog)
{
__ASSERT_ALWAYS(!(aRefresh && iRefresh), User::Leave(KErrAlreadyExists));
CSIPMessageElements* elem = aElements;
if (!aElements)
{
elem = CSIPMessageElements::NewLC();
}
TMessageHeaderCleanup headerCleanup(*elem);
TCleanupItem cleanupItem(TMessageHeaderCleanup::Cleanup, &headerCleanup);
if (aElements)
{
CleanupStack::PushL(cleanupItem);
}
CSIPDialogAssocImplementation::CopyHeaderL(*iEvent, *elem, headerCleanup);
CSIPClientTransaction* ta = NULL;
if (aWithinDialog)
{
ta = CSIPClientTransaction::NewLC(Type(),
Implementation(),
aRefresh ? aRefresh : iRefresh);
TUint32 requestId(0);
TUint32 refreshId(0);
if (iRefresh)
{
//Updates an existing refreshed subscription
Implementation().ClientConnectionL().SendRequestWithinDialogL(
Dialog().Implementation().DialogId(),
iRefresh->RefreshId(),
requestId,
elem);
}
else
{
Implementation().ClientConnectionL().SendRequestWithinDialogL(
Dialog().Implementation().DialogId(),
requestId,
refreshId,
Type(),
elem,
CSIPTransactionBase::IsTargetRefresh(Type()),
(aRefresh != NULL));
}
if (aRefresh)
{
aRefresh->SetRefreshIdIfEmpty(refreshId);
}
CleanupStack::Pop(ta);
ta->SetRequestId(requestId);
//Take ownership of aElements when leave can't occur
delete elem;
}
else
{
const CSIPContactHeader* contact =
Dialog().Implementation().ContactHeader();
if (contact)
{
CSIPDialogAssocImplementation::CopyHeaderL(*contact,
*elem,
headerCleanup);
}
ta = Dialog().Implementation().SendDialogCreatingRequestL(
Implementation(), elem, aRefresh);
}
CleanupStack::Pop(); //TCleanupItem or elem
if (aRefresh)
{
aRefresh->SetRequestType(Type());
iRefresh = aRefresh;
iRefresh->SetRefreshOwner(Implementation());
}
return ta;
}
// -----------------------------------------------------------------------------
// CSIPSubscribeDialogAssoc::DoSendUnsubscribeL
// Sending (un)SUBSCRIBE does not terminate the dialog. (un)SUBSCRIBE is not a
// dialog creating request.
// -----------------------------------------------------------------------------
//
CSIPClientTransaction*
CSIPSubscribeDialogAssoc::DoSendUnsubscribeL(CSIPMessageElements* aElements)
{
CSIPMessageElements* elem = aElements;
if (!aElements)
{
elem = CSIPMessageElements::NewLC();
}
TMessageHeaderCleanup headerCleanup(*elem);
TCleanupItem cleanupItem(TMessageHeaderCleanup::Cleanup, &headerCleanup);
if (aElements)
{
CleanupStack::PushL(cleanupItem);
}
CSIPDialogAssocImplementation::CopyHeaderL(*iEvent, *elem, headerCleanup);
RPointerArray<CSIPHeaderBase> expireHeaders = elem->UserHeadersL(
SIPStrings::StringF(SipStrConsts::EExpiresHeader));
CleanupClosePushL(expireHeaders);
TBool hasExpiresZero = EFalse;
TInt expiresHeaderCount = expireHeaders.Count();
__ASSERT_ALWAYS(expiresHeaderCount <= 1, User::Leave(KErrArgument));
if (expiresHeaderCount == 1)
{
CSIPExpiresHeader* expires =
static_cast<CSIPExpiresHeader*>(expireHeaders[0]);
__ASSERT_ALWAYS(expires->Value() == 0, User::Leave(KErrArgument));
hasExpiresZero = ETrue;
}
CleanupStack::PopAndDestroy(); //expireHeaders
if (!hasExpiresZero)
{
CSIPExpiresHeader* expires = new (ELeave) CSIPExpiresHeader(0);
CleanupStack::PushL(expires);
CSIPDialogAssocImplementation::CopyHeaderL(*expires,
*elem,
headerCleanup);
CleanupStack::PopAndDestroy(expires);
}
CSIPClientTransaction* ta =
CSIPClientTransaction::NewLC(Type(), Implementation(), iRefresh);
TUint32 requestId(0);
if (iRefresh)
{
//Terminates an existing refreshed subscription
Implementation().ClientConnectionL().SendRequestWithinDialogL(
Dialog().Implementation().DialogId(),
iRefresh->RefreshId(),
requestId,
elem);
}
else
{
TUint32 refreshId(0);
Implementation().ClientConnectionL().SendRequestWithinDialogL(
Dialog().Implementation().DialogId(),
requestId,
refreshId,
Type(),
elem,
CSIPTransactionBase::IsTargetRefresh(Type()));
}
CleanupStack::Pop(ta);
ta->SetRequestId(requestId);
//Take ownership of aElements when leave can't occur
delete elem;
CleanupStack::Pop(); //TCleanupItem or elem
return ta;
}
// -----------------------------------------------------------------------------
// CSIPSubscribeDialogAssoc::SIPRefresh
// -----------------------------------------------------------------------------
//
EXPORT_C const CSIPRefresh* CSIPSubscribeDialogAssoc::SIPRefresh() const
{
return iRefresh;
}
// -----------------------------------------------------------------------------
// CSIPSubscribeDialogAssoc::FindRefresh
// -----------------------------------------------------------------------------
//
CSIPRefresh* CSIPSubscribeDialogAssoc::FindRefresh(TUint32 aRefreshId)
{
if (iRefresh && iRefresh->DoesMatch(aRefreshId))
{
return iRefresh;
}
return NULL;
}
// -----------------------------------------------------------------------------
// CSIPSubscribeDialogAssoc::DeletingRefresh
// -----------------------------------------------------------------------------
//
void CSIPSubscribeDialogAssoc::DeletingRefresh(CSIPRefresh& /*aRefresh*/,
TUint32 aRefreshId)
{
CSIPClientConnection* clientConn = Implementation().ClientConnection();
if (clientConn)
{
clientConn->TerminateDialogRefresh(Dialog().Implementation().DialogId(),
aRefreshId);
}
iRefresh = NULL;
}