// -----------------------------------------------------------------------------
// CMceEventSubscribeTerminatingState::HandleReceiveRequestL
// Ápply concrete state.
// Be noticed that it will be also update, unsubscribe
// -----------------------------------------------------------------------------
//
void CMceEventSubscribeTerminatingState::HandleReceiveRequestL(
CMceComEvent& aEvent )
{
MCEEVENTS_DEBUG("CMceEventSubscribeTerminatingState::HandleReceiveRequestL, Entry");
User::LeaveIfError( aEvent.SIPEvent().Dialog() ?
KErrNone : KMceEventStateError );
CSIPServerTransaction& serverTran = aEvent.SIPEvent().Request();
CSIPServerTransaction* serverTranCheck = &serverTran;
User::LeaveIfError( serverTranCheck ? KErrNone : KMceEventStateError );
User::LeaveIfError( serverTran.RequestElements() ? KErrNone : KErrCorrupt );
//Received Notify form Mt
//Receiving Notify and Send 200
//Check the Notify Subscription state so knows which state should go
//Observer inform the notify received, and Established
const CSIPMessageElements& msgElem =
serverTran.RequestElements()->MessageElements();
CSIPResponseElements* response =
MCESIPEventHelper::NotifyRequestReceivedLC( aEvent, msgElem );
if ( response->StatusCode() == KMceSipOK )
{
CDesC8Array* headers = MceSip::UserHeadersToTextArrayL(
serverTran,
aEvent.SIPEvent().Dialog()->Dialog() );
CleanupStack::PushL( headers );
HBufC8* contenttype = NULL;
if( msgElem.ContentType() )
{
contenttype= msgElem.ContentType()->ToTextValueL();
}
CleanupStack::PushL( contenttype );
HBufC8* content = msgElem.Content().AllocLC();
aEvent.SIPEvent().NotifyReceivedL( headers,
contenttype,
content );
CleanupStack::Pop( content );
CleanupStack::Pop( contenttype );
CleanupStack::Pop( headers );
serverTran.SendResponseL( response );
CleanupStack::Pop( response );
aEvent.EventContext().SetCurrentStateL(
aEvent,
KMceTerminatedEventStateIndex );
aEvent.SIPEvent().ClientStateChangedL(
CMceEvent::ETerminated,
EFalse );
}
else
{
//when the notify request is bad, state doesnt change
serverTran.SendResponseL( response );
CleanupStack::Pop( response );
}
MCEEVENTS_DEBUG("CMceEventSubscribeTerminatingState::HandleReceiveRequestL, Exit");
}
// -----------------------------------------------------------------------------
// CSIPExSIPServerOfferingState::AcceptInviteL()
// (other items were commented in a header).
// -----------------------------------------------------------------------------
void CSIPExSIPServerOfferingState::AcceptInviteL( CSIPExSIPEngine& aEngine)
{
_LIT8( KMediaType, "application" );
_LIT8( KMediaSubType, "sdp" );
_LIT8( KLogEntry, "200 OK sent" );
// Get the current transaction
CSIPServerTransaction& tx = aEngine.ServerTx();
// Create the Response Elements object
CSIPResponseElements* respElem =
CSIPResponseElements::NewLC(
200, SIPStrings::StringF( SipStrConsts::EPhraseOk ) );
// Set the message body - we need to communicate our IP Address
CSIPMessageElements& msgElem = respElem->MessageElements();
CSdpDocument* sdpDocument = aEngine.SdpDocumentLC();
HBufC8* sdpBody = aEngine.SdpBodyL( sdpDocument );
CleanupStack::PushL( sdpBody );
CSIPContentTypeHeader* ct =
CSIPContentTypeHeader::NewLC( KMediaType, KMediaSubType );
msgElem.SetContentL( sdpBody, ct );
// Use the transaction to send 200 (OK)
tx.SendResponseL( respElem );
CleanupStack::Pop( ct );
CleanupStack::Pop( sdpBody );
CleanupStack::PopAndDestroy( sdpDocument );
CleanupStack::Pop( respElem );
aEngine.SetCurrentState( iServerEstablishingState );
aEngine.Observer()->WriteLog( KLogEntry );
}
// -----------------------------------------------------------------------------
// MceSip::DoDiscardRequestL
// -----------------------------------------------------------------------------
//
void MceSip::DoDiscardRequestL( CSIPServerTransaction& aRequest, TInt aError,
TBool aRetryIndication )
{
CSIPResponseElements* response = NULL;
TUint responseCode = 0;
if ( aError >= (TInt)KMceSipTrying )
{
responseCode = (TUint)aError;
RStringF reasonPhrase = ReasonPhraseL( responseCode );
CleanupClosePushL( reasonPhrase );
response =
CSIPResponseElements::NewL( responseCode, reasonPhrase );
CleanupStack::PopAndDestroy();//reasonPhrase
}
else
{
TInt reasonPhrase = 0;
ErrorResponse( aError, responseCode, reasonPhrase );
response =
CSIPResponseElements::NewL( responseCode,
SIPStrings::StringF( reasonPhrase ) );
}
CleanupStack::PushL( response );
if ( aRetryIndication )
{
CSIPMessageElements& elements = response->MessageElements();
//create Retry-After header
RPointerArray<CSIPHeaderBase> headers;
CSIPHeaderBase::PushLC( &headers );
CSIPRetryAfterHeader* retryAfter =
CSIPRetryAfterHeader::NewLC( Random( KMceRandMinRetryValue,
KMceRandMaxRetryValue ) );
headers.AppendL( retryAfter );
CleanupStack::Pop( retryAfter );
//send invitation
elements.SetUserHeadersL( headers );
CleanupStack::Pop( &headers );
}
aRequest.SendResponseL( response );
CleanupStack::Pop( response );
}
void UT_CMceEventReferMoEstablishedState::UT_CMceEventReferMoEstablishedState_HandleResponseReceivedLL()
{
// leaving with no client transaction
EUNIT_ASSERT_LEAVE( iState->HandleResponseReceivedL( *iEvent ) );
// Set proper client tran
CSIPClientTransaction* clientTran = CSIPClientTransaction::NewL();
CleanupStack::PushL( clientTran );
clientTran->SetType( 1 );// subscribe
iSIPEvent->SetPendingTransactionL( clientTran );
CleanupStack::Pop( clientTran );
iSIPEvent->iResponse = clientTran;
// Failing with no response elements-
EUNIT_ASSERT_LEAVE( iState->HandleResponseReceivedL( *iEvent ) );
// create and set response 202 Accepted response
_LIT8 ( KAccepted, "Accepted" );
RStringF accepted = SIPStrings::Pool().OpenFStringL( KAccepted );
CleanupClosePushL( accepted );
CSIPResponseElements* resp = CSIPResponseElements::NewL( 202,accepted );
clientTran->SetResponseElements( resp );
// Should not fail with 202 Accepted response
EUNIT_ASSERT_NO_LEAVE( iState->HandleResponseReceivedL( *iEvent ) );
CleanupStack::PopAndDestroy(); // accepted
// create and set response 301 Moved Permanently response
_LIT8 ( KMoved, "Moved Permanently" );
RStringF moved = SIPStrings::Pool().OpenFStringL( KMoved );
CleanupClosePushL( moved );
resp->SetStatusCodeL( 301 );
resp->SetReasonPhraseL( moved );
// Should fail with 301 Moved Permanently response
EUNIT_ASSERT_LEAVE( iState->HandleResponseReceivedL( *iEvent ) );
CleanupStack::PopAndDestroy(); // moved
}
TInt MceSip::RSeq( const CSIPResponseElements& aResponseElements )
{
TInt value = KErrNotFound; // if its not found
CSIPHeaderBase* rseqHeader = FindHeader( aResponseElements.MessageElements(),
SIPStrings::StringF( SipStrConsts::ERSeqHeader ) );
if ( rseqHeader )
{
value = static_cast< CSIPRSeqHeader* >( rseqHeader )->Value();
}
return value;
}
// -----------------------------------------------------------------------------
// MceSip::AddRAckHeaderL
// -----------------------------------------------------------------------------
//
void MceSip::AddRAckHeaderL( RPointerArray<CSIPHeaderBase>& aSIPHeaders,
const CSIPResponseElements& aResponse )
{
TInt rseq = RSeq( aResponse );
if (rseq == KErrNotFound )
{
User::Leave( KErrArgument );
}
const CSIPCSeqHeader* cseqHeader = aResponse.CSeqHeader();
__ASSERT_ALWAYS( MCE_NOT_NULL_PTR( cseqHeader ), User::Leave( KErrArgument ) );
CSIPRAckHeader* header = CSIPRAckHeader::NewL( rseq,
cseqHeader->Seq(),
cseqHeader->Method() );
CleanupStack::PushL( header );
aSIPHeaders.AppendL( header );
CleanupStack::Pop( header );
}
// -----------------------------------------------------------------------------
// CMceEventReferMtEstablishedState::HandleReceiveRequestL
// Ápply concrete state.
// Be noticed that it will be also Refer/Bye or Refer/Invite(update)
// -----------------------------------------------------------------------------
//
void CMceEventReferMtEstablishedState::HandleReceiveRequestL(
CMceComEvent& aEvent )
{
MCEEVENTS_DEBUG("CMceEventReferMtEstablishedState::HandleReceiveRequestL, Entry");
User::LeaveIfError( aEvent.SIPEvent().Dialog() ?
KErrNone : KMceEventStateError );
User::LeaveIfError( aEvent.SIPEvent().Dialog()->Type()
== SIPStrings::StringF( SipStrConsts::ENotify ) ?
KErrNone : KMceEventStateError );
CSIPServerTransaction& serverTran = aEvent.SIPEvent().Request();
CSIPServerTransaction* serverTranCheck = &serverTran;
User::LeaveIfError( serverTranCheck ? KErrNone : KMceEventStateError );
//Received Subscribe from Mo there is no action in the previous action
User::LeaveIfError( aEvent.PreviousAction() == KErrNotFound ?
KErrNone : KMceEventStateError );
User::LeaveIfError( CSIPDialog::EConfirmed ==
aEvent.SIPEvent().Dialog()->Dialog().State() ?
KErrNone : KMceEventStateError );
User::LeaveIfError( serverTran.RequestElements() ? KErrNone : KErrCorrupt) ;
const CSIPMessageElements& subscribeMsg =
serverTran.RequestElements()->MessageElements();
TBool terminated = EFalse;
CSIPResponseElements* response =
MCESIPEventHelper::SubscribeRequestReceivedLC( aEvent, subscribeMsg );
if ( response->StatusCode() == KMceSipOK )
{
MCESIPEventHelper::HandleExpireHeaderL(
subscribeMsg,
terminated );
aEvent.SIPEvent().Request().SendResponseL( response );
CleanupStack::Pop( response );
//then send Notify
CSIPNotifyDialogAssoc* dialogAssoc =
static_cast <CSIPNotifyDialogAssoc* >
(aEvent.SIPEvent().Dialog());
CSIPMessageElements* notifyMsg =
MCESIPEventHelper::CreateReferNotifyMessageElementsLC( aEvent );
CSIPSubscriptionStateHeader& subscrState =
dialogAssoc->SubscriptionState();
TInt nextState = KErrNotFound;
if ( terminated )
{
subscrState.SetSubStateValueL( KStateTerminated );
RStringF expires = SIPStrings::StringF( SipStrConsts::EExpires );
subscrState.DeleteParam( expires );
nextState = KMceTerminatingEventStateIndex;
}
else
{
//when subscription state is active
subscrState.SetSubStateValueL( KStateActive );
subscrState.SetExpiresParameterL(aEvent.RefreshInterval());
nextState = KMceEstablishedEventStateIndex;
}
CSIPClientTransaction* tx = dialogAssoc->SendNotifyL( notifyMsg );
CleanupStack::Pop( notifyMsg );
CleanupStack::PushL( tx );
aEvent.SIPEvent().SetPendingTransactionL( tx );
CleanupStack::Pop( tx );
aEvent.EventContext().SetCurrentStateL( aEvent, nextState );
}
else
{
// bad request
aEvent.SIPEvent().Request().SendResponseL( response );
CleanupStack::Pop( response );
}
MCEEVENTS_DEBUG("CMceEventReferMtEstablishedState::HandleReceiveRequestL, Exit");
}
