--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Msrp/MsrpServer/src/CMSRPMessageHandler.cpp Sat Jun 12 14:30:11 2010 +0530
@@ -0,0 +1,1337 @@
+/*
+* Copyright (c) 2009-2010 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:
+* MSRP Implementation
+*
+*/
+
+// CLASS HEADER
+#include "CMSRPMessageHandler.h"
+
+
+// INCLUDES
+#include <e32math.h>
+#include <s32mem.h>
+
+#include "MMSRPWriterObserver.h"
+#include "CMSRPMessage.h"
+#include "CMSRPResponse.h"
+#include "CMSRPByteRangeHeader.h"
+#include "CMSRPToPathHeader.h"
+#include "CMSRPFromPathHeader.h"
+#include "CMSRPMessageIdHeader.h"
+#include "CMSRPSuccessReportHeader.h"
+#include "CMSRPFailureReportHeader.h"
+#include "CMSRPContentTypeHeader.h"
+#include "MSRPStrings.h"
+#include "MsrpStrConsts.h"
+#include "TMSRPUtil.h"
+#include "MMSRPConnection.h"
+#include "MMSRPMessageObserver.h"
+
+// Constants
+const TInt KEndlineConstLength = 10;
+
+
+TInt CMSRPMessageHandler::LinkOffset()
+ {
+ return _FOFF(CMSRPMessageHandler,iLink);
+ }
+
+// -----------------------------------------------------------------------------
+// CMSRPMessageHandler::NewL
+// -----------------------------------------------------------------------------
+//
+CMSRPMessageHandler* CMSRPMessageHandler::NewL( MMSRPMessageObserver* aMessageObserver, const TDesC8& aMessage )
+ {
+ CMSRPMessageHandler* self = CMSRPMessageHandler::NewLC( aMessageObserver, aMessage );
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+CMSRPMessageHandler* CMSRPMessageHandler::NewL( TMSRPMessageType aMessageType )
+ {
+ CMSRPMessageHandler* self = CMSRPMessageHandler::NewLC( aMessageType );
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CMSRPMessageHandler::NewLC
+// -----------------------------------------------------------------------------
+//
+CMSRPMessageHandler* CMSRPMessageHandler::NewLC( MMSRPMessageObserver* aMessageObserver, const TDesC8& aMessage )
+ {
+ CMSRPMessageHandler* self = new (ELeave) CMSRPMessageHandler( aMessageObserver );
+ CleanupStack::PushL( self );
+ self->ConstructL( aMessage );
+ return self;
+ }
+
+CMSRPMessageHandler* CMSRPMessageHandler::NewLC( TMSRPMessageType aMessageType )
+ {
+ CMSRPMessageHandler* self = new (ELeave) CMSRPMessageHandler();
+ CleanupStack::PushL( self );
+ self->ConstructL( aMessageType );
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CMSRPMessageHandler::ConstructL
+// -----------------------------------------------------------------------------
+//
+void CMSRPMessageHandler::ConstructL( const TDesC8& aMessage )
+ {
+ MSRPLOG( "CMSRPMessageHandler::ConstructL enter" )
+ RDesReadStream readStream( aMessage );
+
+ if ( CMSRPMessage::IsMessage( aMessage ) )
+ {
+ iMessage = CMSRPMessage::InternalizeL( readStream );
+ if( iMessage->IsContent() )
+ {
+ iContentPtr.Set(iMessage->Content());
+ }
+ }
+ else
+ {
+ User::Leave( KErrArgument );
+ }
+
+ iBuffer.CreateL( KMaxBufferSize );
+ iState = EIdle;
+ MSRPStrings::OpenL();
+ MSRPLOG( "CMSRPMessageHandler::ConstructL exit" )
+ }
+
+
+void CMSRPMessageHandler::ConstructL( TMSRPMessageType aMessageType )
+ {
+ MSRPLOG2( "CMSRPMessageHandler::ConstructL enter - MessageType %d", aMessageType )
+ if( aMessageType == EMSRPMessage )
+ {
+ iMessage = new ( ELeave ) CMSRPMessage();
+ }
+ else if( aMessageType == EMSRPResponse )
+ {
+ iResponse = new ( ELeave ) CMSRPResponse();
+ }
+ else if( aMessageType == EMSRPReport )
+ {
+ // Since Reports are not supported now.. jus create a message class
+ iMessage = new ( ELeave ) CMSRPMessage();
+ }
+ else
+ {
+ // Maybe AUTH or some unrecognized request. For now just create a message class
+ iMessage = new ( ELeave ) CMSRPMessage();
+ }
+
+ iActiveMsgType = aMessageType;
+ iBuffer.CreateL( KSmallBuffer );
+ iState = EIdle;
+ MSRPStrings::OpenL();
+ MSRPLOG( "CMSRPMessageHandler::ConstructL exit" )
+ }
+
+
+// -----------------------------------------------------------------------------
+// Constructor
+// -----------------------------------------------------------------------------
+//
+CMSRPMessageHandler::CMSRPMessageHandler( MMSRPMessageObserver* aMessageObserver )
+ {
+ iMSRPMessageObserver = aMessageObserver;
+ }
+
+CMSRPMessageHandler::CMSRPMessageHandler( )
+ {
+
+ }
+
+// -----------------------------------------------------------------------------
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CMSRPMessageHandler::~CMSRPMessageHandler( )
+ {
+ delete iMessage;
+ delete iResponse;
+ delete iFileBuffer;
+ iBuffer.Close();
+ MSRPStrings::Close();
+ iChunkList.ResetAndDestroy();
+ iChunkList.Close();
+ //iFile.Flush();
+ iFile.Close();
+ }
+
+
+void CMSRPMessageHandler::AddHeaderL( TMsrpHeaderType aHeaderType, TPtrC8& aHeaderValue, TPtrC8& /*aHeaderTypeAndValue*/ )
+ {
+ MSRPLOG( "CMSRPMessageHandler::AddHeaderL enter" )
+ CMSRPMessageBase* messageBase = NULL;
+ if( iResponse )
+ {
+ messageBase = iResponse;
+ }
+ else
+ {
+ messageBase = iMessage;
+ }
+
+ TInt err = KErrNone;
+ switch( aHeaderType )
+ {
+ case EToPath:
+ {
+ messageBase->SetToPathHeader( CMSRPToPathHeader::DecodeL( aHeaderValue ) );
+ break;
+ }
+ case EFromPath:
+ {
+ messageBase->SetFromPathHeader( CMSRPFromPathHeader::DecodeL( aHeaderValue ) );
+ break;
+ }
+ case EMessageId:
+ {
+ messageBase->SetMessageIdHeader( CMSRPMessageIdHeader::NewL( aHeaderValue ) );
+ break;
+ }
+ case EByteRange:
+ {
+ TInt startPos(0);
+ TInt endPos(0);
+ TInt total(0);
+ err = ExtractByteRangeParams( aHeaderValue, startPos, endPos, total );
+ messageBase->SetByteRangeHeader( CMSRPByteRangeHeader::NewL( startPos, endPos, total ));
+ break;
+ }
+ case ESuccessReport:
+ {
+ if( aHeaderValue == MSRPStrings::StringF( MSRPStrConsts::EYes ).DesC())
+ {
+ messageBase->SetSuccessReportHeader(
+ CMSRPSuccessReportHeader::NewL( MSRPStrings::StringF( MSRPStrConsts::EYes ) ) );
+ }
+ else if( aHeaderValue == MSRPStrings::StringF( MSRPStrConsts::ENo ).DesC())
+ {
+ messageBase->SetSuccessReportHeader(
+ CMSRPSuccessReportHeader::NewL( MSRPStrings::StringF( MSRPStrConsts::ENo ) ) );
+ }
+ else
+ {
+ err = KErrArgument;
+ }
+ break;
+ }
+ case EFailureReport:
+ {
+ if( aHeaderValue == MSRPStrings::StringF( MSRPStrConsts::EYes ).DesC())
+ {
+ messageBase->SetFailureReportHeader(
+ CMSRPFailureReportHeader::NewL( MSRPStrings::StringF( MSRPStrConsts::EYes ) ) );
+ }
+ else if( aHeaderValue == MSRPStrings::StringF( MSRPStrConsts::ENo ).DesC())
+ {
+ messageBase->SetFailureReportHeader(
+ CMSRPFailureReportHeader::NewL( MSRPStrings::StringF( MSRPStrConsts::ENo ) ) );
+ }
+ else if( aHeaderValue == MSRPStrings::StringF( MSRPStrConsts::EPartial ).DesC())
+ {
+ messageBase->SetFailureReportHeader(
+ CMSRPFailureReportHeader::NewL( MSRPStrings::StringF( MSRPStrConsts::EPartial ) ) );
+ }
+ else
+ {
+ err = KErrArgument;
+ }
+ break;
+ }
+ case EContentType:
+ {
+ messageBase->SetContentTypeHeader( CMSRPContentTypeHeader::NewL( aHeaderValue ) );
+ break;
+ }
+ case EStatus:
+ {
+ break; // required for reports only. Not handled now
+ }
+ default:
+ {
+ break;
+ }
+ }
+ User::LeaveIfError(err);
+
+ MSRPLOG( "CMSRPMessageHandler::AddHeaderL exit" )
+ }
+
+
+void CMSRPMessageHandler::AddContentL( TPtrC8& aContent )
+ {
+ MSRPLOG( "CMSRPMessageHandler::AddContentL enter" )
+ if( iMessage )
+ {
+ if( iBuffer.Length() + aContent.Length() > iBuffer.MaxLength() )
+ {
+ iBuffer.ReAllocL(iBuffer.Length() + aContent.Length());
+ iBuffer.Append(aContent);
+ }
+ else
+ {
+ iBuffer.Append(aContent);
+ }
+ }
+ MSRPLOG( "CMSRPMessageHandler::AddContentL exit" )
+ }
+
+
+void CMSRPMessageHandler::SetTransactionId( TPtrC8& aTransactionId )
+ {
+ MSRPLOG( "CMSRPMessageHandler::SetTransactionId enter" )
+ iTransactionId = aTransactionId;
+ MSRPLOG( "CMSRPMessageHandler::SetTransactionId exit" )
+ }
+
+
+void CMSRPMessageHandler::SetStatusOfResponseL( TPtrC8& aStatusCode, TPtrC8& /*aStatusMessage*/ )
+ {
+ MSRPLOG( "CMSRPMessageHandler::SetStatusOfResponseL enter" )
+ if( iResponse )
+ {
+ TUint statusCodeVal = TMSRPUtil::ConvertToNumber( aStatusCode );
+ RStringF statusString = GetStatusStringL( statusCodeVal );
+ iResponse->SetStatusCodeL( statusCodeVal );
+ iResponse->SetReasonPhrase( statusString );
+ }
+ MSRPLOG( "CMSRPMessageHandler::SetStatusOfResponseL exit" )
+ }
+
+
+void CMSRPMessageHandler::EndOfMessageL( TMsrpMsgEndStatus aStatus )
+ {
+ MSRPLOG( "CMSRPMessageHandler::EndOfMessageL enter" )
+ if( iMessage && iBuffer.Length() )
+ {
+ HBufC8* contentOfMessage = HBufC8::NewL( iBuffer.Length() );
+ *contentOfMessage = iBuffer;
+ iMessage->SetContent( contentOfMessage );
+ iBuffer.Zero();
+ }
+ iMsgEndStatus = aStatus;
+ MSRPLOG( "CMSRPMessageHandler::EndOfMessageL exit" )
+ }
+
+
+MMSRPIncomingMessage::TMSRPMessageType CMSRPMessageHandler::MessageType( )
+ {
+ MSRPLOG( "CMSRPMessageHandler::MessageType enter" )
+ MSRPLOG2("Message Type = %d", iActiveMsgType );
+ return iActiveMsgType;
+ }
+
+
+CMSRPMessage* CMSRPMessageHandler::GetIncomingMessage( )
+ {
+ MSRPLOG( "CMSRPMessageHandler::GetIncomingMessage enter" )
+ if( iMessage )
+ {
+ return iMessage;
+ }
+ return NULL;
+ }
+
+
+void CMSRPMessageHandler::UpdateResponseStateL(CMSRPMessageHandler *incomingMsgHandler)
+ {
+ MSRPLOG( "CMSRPMessageHandler::UpdateResponseState enter" )
+ TBuf8<100> iTransactionId = incomingMsgHandler->TransactionId();
+ for(TInt i=0;i<iChunkList.Count();i++)
+ {
+ if(iTransactionId == iChunkList[i]->GetTransactionId())
+ {
+ iChunkList[i]->SetResponseSent(ETrue);
+ ReceiveFileStateL(iChunkList[i]->GetEndPos()- iChunkList[i]->GetStartPos() + 1);
+ }
+ }
+ MSRPLOG( "CMSRPMessageHandler::UpdateResponseState exit" )
+ }
+
+
+void CMSRPMessageHandler::ReceiveFileStateL( TInt aBytesTransferred )
+ {
+ MSRPLOG( "CMSRPMessageHandler::ReceiveFileState enter" )
+ MSRPLOG2( "CMSRPMessageHandler::ReceiveFileState Notify %d", iProgress )
+ MSRPLOG2( "CMSRPMessageHandler::ReceiveFileState iFileNotified %d", iNotifiedBytes )
+ MSRPLOG2( "CMSRPMessageHandler::ReceiveFileState iunnotified %d", iPendingBytes )
+ MSRPLOG2( "CMSRPMessageHandler::ReceiveFileState aBytesTransferred %d", aBytesTransferred )
+ MSRPLOG2( "CMSRPMessageHandler::ReceiveFileState iFileSize %d", iFileSize )
+
+ iPendingBytes += aBytesTransferred;
+
+ if(iNotifiedBytes + iPendingBytes == iFileSize)
+ {
+ iFileTransferComplete = ETrue;
+ }
+
+ if(iPendingBytes >= KMaxChunkReadSize)
+ {
+ MSRPLOG( "CMSRPMessageHandler::ReceiveFileState unnotified exceeds threshold" )
+ MSRPLOG2( "CMSRPMessageHandler::ReceiveFileState iFileReceiveComplete: %d", iFileTransferComplete )
+
+ iNotifiedBytes += iPendingBytes;
+ iPendingBytes = 0;
+ //notify client of progress
+ if(iProgress && !iFileTransferComplete)
+ iMSRPMessageObserver->MessageReceiveProgressL(iNotifiedBytes, iFileSize);
+ }
+
+ MSRPLOG( "CMSRPMessageHandler::ReceiveFileState exit" )
+ }
+
+
+TBool CMSRPMessageHandler::SendResponseL( MMSRPMessageObserver* aMessageObserver,
+ MMSRPConnection& aConnection, TUint aResponseCode )
+ {
+ MSRPLOG( "CMSRPMessageHandler::SendResponseL enter" )
+
+ iMSRPMessageObserver = aMessageObserver;
+
+ if( !aResponseCode )
+ {
+ aResponseCode = CheckValidityOfMessage( EMSRPMessage, iMessage );
+ }
+
+ TBool sendResponse = ETrue;
+ if( iMessage->FailureReportHeader() )
+ {
+ HBufC8* frHeaderValue = iMessage->FailureReportHeader()->ToTextValueLC();
+ if( frHeaderValue->Des() == MSRPStrings::StringF( MSRPStrConsts::ENo ).DesC() )
+ {
+ sendResponse = EFalse;
+ }
+ else if( (frHeaderValue->Des() == MSRPStrings::StringF( MSRPStrConsts::EPartial ).DesC())
+ && (aResponseCode == CMSRPResponse::EAllOk) )
+ {
+ sendResponse = EFalse;
+ }
+ CleanupStack::PopAndDestroy(frHeaderValue);
+ }
+
+ if( !iMessage->ToPathHeader() || !iMessage->FromPathHeader() )
+ {
+ aResponseCode = CMSRPResponse::EUnknownCode;
+ sendResponse = EFalse;
+ }
+
+ if(sendResponse)
+ {
+ RStringF statusString = GetStatusStringL( aResponseCode );
+ iResponse = new ( ELeave ) CMSRPResponse( aResponseCode, statusString ) ;
+
+ HBufC8* fromPathValue = iMessage->FromPathHeader()->ToTextValueLC();
+ iResponse->SetToPathHeader( CMSRPToPathHeader::DecodeL( *fromPathValue ) );
+ CleanupStack::PopAndDestroy(fromPathValue);
+
+ HBufC8* toPathValue = iMessage->ToPathHeader()->ToTextValueLC();
+ iResponse->SetFromPathHeader( CMSRPFromPathHeader::DecodeL( *toPathValue ) );
+ CleanupStack::PopAndDestroy(toPathValue);
+
+ iActiveMsgType = EMSRPResponse;
+ aConnection.SendL( *this );
+ }
+
+ MSRPLOG( "CMSRPMessageHandler::SendResponseL exit" )
+
+ if( aResponseCode == CMSRPResponse::EAllOk )
+ return ETrue;
+ else
+ return EFalse;
+ }
+
+
+TBool CMSRPMessageHandler::IfResponseReqL()
+ {
+ TBool responseReq = ETrue;
+ if( iMessage->FailureReportHeader() )
+ {
+ HBufC8* frHeaderValue = iMessage->FailureReportHeader()->ToTextValueLC();
+ if( frHeaderValue->Des() == MSRPStrings::StringF( MSRPStrConsts::ENo ).DesC() )
+ {
+ responseReq = EFalse;
+ }
+ else if( (frHeaderValue->Des() == MSRPStrings::StringF( MSRPStrConsts::EPartial ).DesC()))
+ {
+ responseReq = EFalse;
+ }
+ CleanupStack::PopAndDestroy(frHeaderValue);
+ }
+ return responseReq;
+ }
+
+
+TDesC8& CMSRPMessageHandler::TransactionId( )
+ {
+ MSRPLOG( "CMSRPMessageHandler::TransactionId enter" )
+ return iTransactionId;
+ }
+
+
+CMSRPResponse* CMSRPMessageHandler::GetIncomingResponse( )
+ {
+ MSRPLOG( "CMSRPMessageHandler::GetIncomingResponse enter" )
+ if( iResponse )
+ {
+ return iResponse;
+ }
+ return NULL;
+ }
+
+
+void CMSRPMessageHandler::SendMessageL( MMSRPConnection& aConnection )
+ {
+ MSRPLOG( "CMSRPMessageHandler::SendMessageL enter" )
+ iActiveMsgType = EMSRPMessage;
+ aConnection.SendL( *this );
+ MSRPLOG( "CMSRPMessageHandler::SendMessageL exit" )
+ }
+
+
+void CMSRPMessageHandler::SendFileL(MMSRPConnection& aConnection)
+ {
+ MSRPLOG( "CMSRPMessageHandler::SendFileL enter" )
+ /* Flags */
+ isFile = ETrue;
+ iProgress = iMessage->GetNotifyProgress();
+
+ User::LeaveIfError(iFs.Connect());
+ User::LeaveIfError(iFile.Open(iFs, iMessage->GetFileName(), EFileShareReadersOrWriters));
+ iFile.Size(iFileSize);
+ iFileBuffer = HBufC8::NewL(KMaxChunkReadSize);
+ FillFileBufferL();
+ iActiveMsgType = EMSRPMessage;
+ aConnection.SendL( *this );
+
+ MSRPLOG( "CMSRPMessageHandler::SendFileL exit" )
+ }
+
+
+TInt CMSRPMessageHandler::FillFileBufferL()
+ {
+ MSRPLOG( "CMSRPMessageHandler::FillFileBufferL enter" )
+ iStartPosInBuffer = 0;
+ iEndPosInBuffer = 0;
+ iBufPosInFile+=iFileBuffer->Length();
+ iFileBuffer->Des().Zero();
+ TPtr8 ptr(iFileBuffer->Des());
+ User::LeaveIfError(iFile.Read(iBufPosInFile, ptr, KMaxChunkReadSize));
+ MSRPLOG2( "CMSRPMessageHandler::FillFileBufferL File Buffer Length %d", iFileBuffer->Length());
+ MSRPLOG( "CMSRPMessageHandler::FillFileBufferL exit" )
+ return iFileBuffer->Length();
+ }
+
+
+void CMSRPMessageHandler::ReceiveFileL( )
+ {
+ MSRPLOG( "CMSRPMessageHandler::ReceiveFileL enter" )
+ isFile = ETrue;
+ iProgress = iMessage->GetNotifyProgress();
+
+ User::LeaveIfError(iFs.Connect());
+ User::LeaveIfError(iFile.Replace(iFs,iMessage->GetFileName(),EFileWrite));
+ iFileSize = iMessage->GetFileSize();
+ iFileBuffer = HBufC8::NewL(KMaxChunkReadSize);
+
+ MSRPLOG( "CMSRPMessageHandler::ReceiveFileL exit" )
+ }
+
+
+void CMSRPMessageHandler::WritetoFileL(CMSRPMessageHandler *incomingMsgHandler )
+ {
+ MSRPLOG( "CMSRPMessageHandler::WriteToFile enter" )
+ CMSRPMessage* inFileChunk = incomingMsgHandler->GetIncomingMessage();
+ HBufC8* messageContent = NULL;
+ if(inFileChunk->IsContent())
+ {
+ messageContent = HBufC8::NewL(inFileChunk->Content().Length());
+ *messageContent = inFileChunk->Content();
+ WriteChunkToFileL(*messageContent,incomingMsgHandler->TransactionId());
+
+ if (!incomingMsgHandler->IfResponseReqL())
+ ReceiveFileStateL(messageContent->Length());
+ }
+ delete messageContent;
+ MSRPLOG( "CMSRPMessageHandler::WriteToFile exit" )
+ }
+
+
+void CMSRPMessageHandler::WriteChunkToFileL(const TDesC8& aFileChunk ,TDesC8& aTransactionId)
+ {
+ MSRPLOG( "CMSRPMessageHandler::WriteChunktoFile enter" )
+ if(iBufPosInFile<(iFileSize-1))
+ {
+ iFile.Write(iBufPosInFile,aFileChunk);
+
+ /* Create and update the structure */
+ CMSRPMessageChunkState* iChunk = CMSRPMessageChunkState::NewL( );
+ iChunk->SetStartPos(iBufPosInFile);
+ iBufPosInFile += aFileChunk.Length();
+ iChunk->SetEndPos(iBufPosInFile-1);
+ iChunk->SetTransactionId(aTransactionId);
+ iChunkList.Append(iChunk);
+ }
+ else
+ {
+ //Receive Bytes greater than file Size
+ User::Leave( KErrArgument );
+ }
+
+ MSRPLOG( "CMSRPMessageHandler::WriteChunktoFile exit" )
+
+ }
+
+
+TBool CMSRPMessageHandler::IsOwnerOfResponse( MMSRPIncomingMessage& aIncomingMessage )
+ {
+ MSRPLOG( "CMSRPMessageHandler::IsOwnerOfResponse enter" )
+ if(isFile)
+ {
+ /* compare for transaction id */
+ for(TInt i=0;i<iChunkList.Count();i++)
+ {
+ if(aIncomingMessage.TransactionId() == iChunkList[i]->GetTransactionId())
+ {
+ if( iState == EWaitingForResponse || ( iState == EMessageSent && iResponseNeeded ))
+ {
+ if (i == iChunkList.Count()-1)
+ {
+ iResponseNeeded = EFalse;
+ iState = EMessageDone;
+ }
+ }
+ return ETrue;
+ }
+ }
+ }
+ if( aIncomingMessage.TransactionId() == iTransactionId )
+ {
+ if( iState == EWaitingForResponse || ( iState == EMessageSent && iResponseNeeded ))
+ {
+ iResponseNeeded = EFalse;
+ return ETrue;
+ }
+ }
+
+ MSRPLOG( "CMSRPMessageHandler::IsOwnerOfResponse exit" )
+ return EFalse;
+ }
+
+
+void CMSRPMessageHandler::ConsumeFileResponseL(MMSRPIncomingMessage& aIncomingMessage )
+ {
+ MSRPLOG( "CMSRPMessageHandler::ConsumeFileResponseL enter" )
+ CMSRPResponse* response = aIncomingMessage.GetIncomingResponse();
+ TUint statusCode = response->StatusCode();
+
+ for(TInt i=0;i<iChunkList.Count();i++)
+ {
+ if(aIncomingMessage.TransactionId()== iChunkList[i]->GetTransactionId())
+ {
+ iChunkList[i]->SetResponseReceived(ETrue);
+ SendFileStateL(iChunkList[i]->GetEndPos()- iChunkList[i]->GetStartPos() + 1 ) ;
+ }
+ }
+
+ MSRPLOG( "CMSRPMessageHandler::ConsumeFileResponseL exit" )
+ }
+
+
+void CMSRPMessageHandler::SendFileStateL(TInt aBytesTransferred )
+ {
+ MSRPLOG( "CMSRPMessageHandler::SendFileStateL enter" )
+ MSRPLOG2( "CMSRPMessageHandler::SendFileStateL granularity %d", iProgress )
+ MSRPLOG2( "CMSRPMessageHandler::SendFileStateL iFileNotified %d", iNotifiedBytes )
+ MSRPLOG2( "CMSRPMessageHandler::SendFileStateL iunnotified %d", iPendingBytes )
+ MSRPLOG2( "CMSRPMessageHandler::SendFileStateL aBytesTransferred %d", aBytesTransferred )
+ MSRPLOG2( "CMSRPMessageHandler::SendFileStateL iFileSize %d", iFileSize )
+
+ iPendingBytes += aBytesTransferred;
+
+ if(iNotifiedBytes + iPendingBytes == iFileSize)
+ {
+ iFileTransferComplete = ETrue;
+ }
+
+ if(iPendingBytes >= KMaxChunkReadSize)
+ {
+ MSRPLOG( "CMSRPMessageHandler::SendFileStateL unnotified exceeds threshold" )
+ MSRPLOG2( "CMSRPMessageHandler::SendFileStateL iFileSendComplete: %d", iFileTransferComplete )
+ iNotifiedBytes += iPendingBytes;
+ iPendingBytes = 0;
+
+ //notify client of progress
+ if( iProgress && !iFileTransferComplete )//send progress requested and avoid double notifn. as send complete not handled in waitfor clientstate
+ iMSRPMessageObserver->MessageSendProgressL(iNotifiedBytes, iFileSize);//iByteinPos
+
+ }
+ MSRPLOG( "CMSRPMessageHandler::SendFileStateL exit" )
+ }
+
+
+TBool CMSRPMessageHandler::FileTransferComplete( )
+ {
+ if(iFileTransferComplete)
+ return ETrue;
+ else
+ return EFalse;
+ }
+
+
+TBool CMSRPMessageHandler::IsInFile()
+ {
+ if(isFile)
+ {
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+
+TBool CMSRPMessageHandler::ConsumeResponseL( MMSRPIncomingMessage& aIncomingMessage )
+ {
+ MSRPLOG( "CMSRPMessageHandler::ConsumeResponseL enter" )
+
+ TBool ret;
+ CMSRPResponse* response = aIncomingMessage.GetIncomingResponse();
+ TUint statusCode = response->StatusCode();
+
+ if( iMessage->FailureReportHeader() &&
+ (iMessage->FailureReportHeader()->ToTextValueLC()->Des() ==
+ MSRPStrings::StringF( MSRPStrConsts::EPartial ).DesC()) &&
+ statusCode == CMSRPResponse::EAllOk )
+ {
+ iState = EMessageDone;
+ ret = EFalse;
+ }
+ else
+ {
+ RStringF statusString = response->ReasonPhrase();
+ iResponse = new (ELeave) CMSRPResponse( statusCode, statusString );
+ HBufC8* toPathValue = response->ToPathHeader()->ToTextValueLC();
+ HBufC8* fromPathValue = response->FromPathHeader()->ToTextValueLC();
+ iResponse->SetToPathHeader( CMSRPToPathHeader::DecodeL( toPathValue->Des() ) );
+ iResponse->SetFromPathHeader( CMSRPFromPathHeader::DecodeL( fromPathValue->Des() ) );
+ CleanupStack::PopAndDestroy(fromPathValue);
+ CleanupStack::PopAndDestroy(toPathValue);
+ iState = EMessageDone;
+ ret = ETrue;
+ }
+
+ if( iMessage->FailureReportHeader() )
+ {
+ CleanupStack::PopAndDestroy(); // FR header value from above
+ }
+
+ MSRPLOG( "CMSRPMessageHandler::ConsumeResponseL exit" )
+ return ret;
+ }
+
+
+TBool CMSRPMessageHandler::IsMessageComplete()
+ {
+ MSRPLOG( "CMSRPMessageHandler::IsMessageComplete enter" )
+ if( iState == EMessageDone )
+ return ETrue;
+ else
+ return EFalse;
+ }
+
+
+TBool CMSRPMessageHandler::GetSendResultL( TUint &aErrorCode, HBufC8* &aMessageId )
+ {
+ MSRPLOG( "CMSRPMessageHandler::GetSendResult enter" )
+ if( iState == EMessageDone )
+ {
+ aMessageId = iMessage->MessageIdHeader()->ToTextValueLC();
+ CleanupStack::Pop(aMessageId);
+ if(iResponse)
+ {
+ TUint code = iResponse->StatusCode();
+ if( code == CMSRPResponse::EAllOk )
+ {
+ aErrorCode = ENoError;
+ }
+ else if ( code == CMSRPResponse::ETimeout )
+ {
+ aErrorCode = ENetworkTimeout;
+ }
+ else
+ {
+ aErrorCode = EUnrecoverableError;
+ }
+ }
+ else
+ {
+ aErrorCode = ENoError;
+ }
+ }
+ MSRPLOG( "CMSRPMessageHandler::GetSendResult exit" )
+ if( aErrorCode == EUnrecoverableError )
+ {
+ return ETrue;
+ }
+ else
+ {
+ return EFalse;
+ }
+ }
+
+
+MMSRPWriterObserver::TWriteStatus CMSRPMessageHandler::GetSendBufferL( TPtrC8& aData, TBool aInterrupt )
+ {
+ MSRPLOG( "CMSRPMessageHandler::GetSendBufferL enter" )
+ iInterrupt = aInterrupt;
+ iWriteDone = EFalse;
+ iBuffer.Zero();
+
+ while( !iWriteDone )
+ {
+ if( iState == EIdle )
+ {
+ if( iActiveMsgType == EMSRPMessage )
+ {
+ CreateByteRangeHeaderL();
+ }
+ WriteInitialLineToBufferL();
+ WriteHeadersToBufferL();
+ }
+
+ else if( iState == EInProgress )
+ {
+ if( iMessage->IsFile())
+ {
+ if (iActiveMsgType == EMSRPMessage)
+ WriteFileContentToBufferL();
+ else
+ WriteEndLineToBuffer();
+ }
+ else
+ {
+ if( iContentPtr.Length() )
+ WriteContentToBuffer();
+ else
+ WriteEndLineToBuffer();
+ }
+ }
+ else
+ {
+ User::LeaveIfError(KErrArgument);
+ }
+ }
+
+ aData.Set(iBuffer);
+ MSRPLOG( "CMSRPMessageHandler::GetSendBufferL exit" )
+ return EMsrpSocketWrite;
+ }
+
+
+MMSRPWriterObserver::TMsgStatus CMSRPMessageHandler::WriteDoneL( TInt aStatus )
+ {
+ MSRPLOG( "CMSRPMessageHandler::WriteDoneL enter" )
+ MMSRPWriterObserver::TMsgStatus retStatus = EUndefined;
+
+ if( !aStatus )
+ {
+ /*if file send and message and response not needed, update progress*/
+ if (isFile && iActiveMsgType == EMSRPMessage && iResponseNeeded == FALSE)
+ {
+ if (iFileBytesSent > 0)
+ SendFileStateL(iFileBytesSent);
+ }
+
+ if( iState == EMessageSent )
+ {
+ switch( iActiveMsgType )
+ {
+ case EMSRPMessage:
+ {
+ if( iResponseNeeded )
+ {
+ iState = EWaitingForResponse;
+ }
+ else
+ {
+ iState = EMessageDone;
+ }
+ iMSRPMessageObserver->MessageSendCompleteL();
+ break;
+ }
+ case EMSRPResponse:
+ {
+ iState = EMessageDone;
+ iMSRPMessageObserver->MessageResponseSendCompleteL(*this);
+ break;
+ }
+ }
+ //iActiveMsgType = EMSRPNotDefined;
+ retStatus = MMSRPWriterObserver::EComplete;
+ }
+ else if( iState == EInProgress )
+ {
+ retStatus = MMSRPWriterObserver::EPending;
+ }
+ else if(iState == EChunkSent)
+ {
+ retStatus = MMSRPWriterObserver::EInterrupted;
+ iState = EIdle;
+ }
+ else
+ {
+ iMSRPMessageObserver->WriterError();
+ }
+ }
+ MSRPLOG( "CMSRPMessageHandler::WriteDone exit" )
+ return retStatus;
+ }
+
+
+void CMSRPMessageHandler::CreateByteRangeHeaderL()
+ {
+ MSRPLOG( "CMSRPMessageHandler::CreateByteRangeHeaderL enter" )
+ CMSRPByteRangeHeader* byteRange = NULL;
+
+ if ( iMessage->IsFile())
+ {
+ byteRange = CMSRPByteRangeHeader::NewL( iBufPosInFile+iStartPosInBuffer+1,KUnknownRange,iFileSize);
+
+ CleanupStack::PushL(byteRange);
+ iMessage->SetByteRangeHeader( byteRange );
+ CleanupStack::Pop(byteRange);
+ }
+ else
+ {
+ if( !iMessage->ByteRangeHeader() )
+ {
+ if ( iMessage->IsContent() )
+ {
+ byteRange = CMSRPByteRangeHeader::NewL( 1,
+ iMessage->Content().Length(), iMessage->Content().Length() );
+ CleanupStack::PushL(byteRange);
+ }
+ else
+ {
+ byteRange = CMSRPByteRangeHeader::NewL( 1, 0, 0 );
+ CleanupStack::PushL(byteRange);
+ }
+ iMessage->SetByteRangeHeader( byteRange );
+ CleanupStack::Pop(byteRange);
+ }
+ }
+ MSRPLOG( "CMSRPMessageHandler::CreateByteRangeHeaderL exit" )
+ }
+
+
+void CMSRPMessageHandler::CreateTransactionId()
+ {
+ MSRPLOG( "CMSRPMessageHandler::CreateTransactionId enter" )
+
+ TTime now;
+ now.HomeTime();
+ TInt64 seed = now.Int64();
+ TInt random = Math::Rand( seed );
+ iTransactionId.NumUC( random );
+
+ MSRPLOG( "CMSRPMessageHandler::CreateTransactionId exit" )
+ }
+
+
+void CMSRPMessageHandler::WriteInitialLineToBufferL()
+ {
+ MSRPLOG( "CMSRPMessageHandler::WriteInitialLineToBufferL enter" )
+
+ iBuffer.Append( MSRPStrings::StringF( MSRPStrConsts::EMSRP ).DesC() );
+
+ iBuffer.Append( KSpaceChar );
+
+ if (! (iActiveMsgType == EMSRPResponse) )
+ {
+ CreateTransactionId();
+ }
+
+ iBuffer.Append( iTransactionId );
+
+ iBuffer.Append( KSpaceChar );
+
+ if ( iActiveMsgType == EMSRPMessage )
+ {
+ iBuffer.Append( MSRPStrings::StringF( MSRPStrConsts::ESend ).DesC() );
+ }
+ else if ( iActiveMsgType == EMSRPResponse )
+ {
+ TBuf8< KMaxLengthOfStatusCode > statusCode;
+ statusCode.NumUC( iResponse->StatusCode() );
+ iBuffer.Append( statusCode );
+ iBuffer.Append( KSpaceChar );
+ iBuffer.Append( iResponse->ReasonPhrase().DesC() );
+ }
+ else
+ {
+ User::Leave( KErrArgument );
+ }
+
+ iBuffer.Append( KCRAndLF );
+
+ iState = EInProgress;
+ MSRPLOG( "CMSRPMessageHandler::WriteInitialLineToBufferL exit" )
+ }
+
+
+void CMSRPMessageHandler::WriteHeadersToBufferL()
+ {
+ MSRPLOG( "CMSRPMessageHandler::WriteHeadersToBufferL enter" )
+ CMSRPMessageBase* messageBase = NULL;
+ if( iActiveMsgType == EMSRPMessage )
+ {
+ messageBase = iMessage;
+ }
+ else if ( iActiveMsgType == EMSRPResponse )
+ {
+ messageBase = iResponse;
+ }
+ else
+ {
+ User::Leave( KErrArgument );
+ }
+
+ // Check if appending headers will exceed max size
+
+ __ASSERT_ALWAYS( messageBase->ToPathHeader(), User::Leave( KErrNotFound ) );
+ iBuffer.Append( messageBase->ToPathHeader()->ToTextLC()->Des() );
+ CleanupStack::PopAndDestroy(); // above
+ iBuffer.Append( KCRAndLF );
+
+ __ASSERT_ALWAYS( messageBase->FromPathHeader(), User::Leave( KErrNotFound ) );
+ iBuffer.Append( messageBase->FromPathHeader()->ToTextLC()->Des() );
+ CleanupStack::PopAndDestroy(); // above
+ iBuffer.Append( KCRAndLF );
+
+ if( iActiveMsgType != EMSRPResponse )
+ {
+ __ASSERT_ALWAYS( messageBase->MessageIdHeader(), User::Leave( KErrNotFound ) );
+ iBuffer.Append( messageBase->MessageIdHeader()->ToTextLC()->Des() );
+ CleanupStack::PopAndDestroy(); // above
+ iBuffer.Append( KCRAndLF );
+ }
+
+ if( iActiveMsgType == EMSRPMessage )
+ {
+ if ( messageBase->SuccessReportHeader() )
+ {
+ iBuffer.Append( messageBase->SuccessReportHeader()->ToTextLC()->Des() );
+ CleanupStack::PopAndDestroy(); // above
+ iBuffer.Append( KCRAndLF );
+ }
+
+ if ( messageBase->FailureReportHeader() )
+ {
+ HBufC8* valueString = messageBase->FailureReportHeader()->ToTextValueLC();
+ if ( valueString->Des() == MSRPStrings::StringF( MSRPStrConsts::EYes ).DesC() ||
+ valueString->Des() == MSRPStrings::StringF( MSRPStrConsts::EPartial ).DesC() )
+ {
+ iResponseNeeded = ETrue;
+ }
+ CleanupStack::PopAndDestroy(valueString);
+
+ iBuffer.Append( messageBase->FailureReportHeader()->ToTextLC()->Des() );
+ CleanupStack::PopAndDestroy(); // above
+ iBuffer.Append( KCRAndLF );
+ }
+ else
+ {
+ iResponseNeeded = ETrue;
+ }
+ }
+
+ if( iActiveMsgType != EMSRPResponse )
+ {
+ iBuffer.Append( messageBase->ByteRangeHeader()->ToTextLC()->Des() );
+ CleanupStack::PopAndDestroy(); // above
+ iBuffer.Append( KCRAndLF );
+ }
+
+ if( iActiveMsgType == EMSRPMessage )
+ {
+ if ( messageBase->ContentTypeHeader() )
+ {
+ iBuffer.Append( messageBase->ContentTypeHeader()->ToTextLC()->Des() );
+ CleanupStack::PopAndDestroy(); // above
+ iBuffer.Append( KCRAndLF );
+ iBuffer.Append( KCRAndLF );
+
+ if(!iMessage->IsFile() && !iMessage->IsContent())
+ {
+ iBuffer.Append( KCRAndLF );
+ }
+ }
+ }
+
+ MSRPLOG( "CMSRPMessageHandler::WriteHeadersToBufferL exit" )
+ }
+
+
+void CMSRPMessageHandler::WriteFileContentToBufferL()
+ {
+ MSRPLOG( "CMSRPMessageHandler::WriteFileContentToBuffer enter" )
+ TInt endlineSize = iTransactionId.Length() + KEndlineConstLength;
+ TInt remBufferSize = iBuffer.MaxLength() - iBuffer.Length() - endlineSize - KCRAndLF().Length();
+ TInt chunkLength = iFileBuffer->Length() - iEndPosInBuffer;
+
+ /*if(remBufferSize<0) TODO*/
+ if(chunkLength > remBufferSize)
+ {
+ iFileBytesSent = remBufferSize;
+ iBuffer.Append(iFileBuffer->Mid(iEndPosInBuffer, iFileBytesSent));
+ iEndPosInBuffer += iFileBytesSent;
+ if(iInterrupt)
+ {
+ WriteEndLineToBuffer(EMessageContinues);
+ //add chunk entry
+ CMSRPMessageChunkState* iChunk = CMSRPMessageChunkState::NewL( );
+ iChunk->SetStartPos(iBufPosInFile+iStartPosInBuffer);
+ iChunk->SetEndPos(iBufPosInFile+iEndPosInBuffer-1);//since endpos is pointing to next start pos
+ iChunk->SetTransactionId(iTransactionId);
+ iChunkList.Append(iChunk);
+
+ iStartPosInBuffer = iEndPosInBuffer;
+ iState = EChunkSent;
+ }
+ /* else
+ {
+ //msg state remains InProgress (in write done return pending)
+ }*/
+ }
+ else //bytes completed in current file buffer
+ {
+ iFileBytesSent = chunkLength;
+ iBuffer.Append(iFileBuffer->Mid(iEndPosInBuffer, iFileBytesSent));
+ iEndPosInBuffer += iFileBytesSent;
+ iBuffer.Append(KCRAndLF());
+
+ //add chunk entry
+ CMSRPMessageChunkState* iChunk = CMSRPMessageChunkState::NewL( );
+ iChunk->SetStartPos(iBufPosInFile+iStartPosInBuffer);
+ iChunk->SetEndPos(iBufPosInFile+iEndPosInBuffer-1);
+ iChunk->SetTransactionId(iTransactionId);
+ iChunkList.Append(iChunk);
+
+ if(FillFileBufferL() > 0)
+ {
+ //next file buffer has data
+ WriteEndLineToBuffer(EMessageContinues);
+ iState = EChunkSent;
+ }
+ else
+ {
+ WriteEndLineToBuffer(EMessageEnd);
+ iState = EMessageSent;
+ }
+
+ }
+
+ iWriteDone = ETrue;
+ MSRPLOG( "CMSRPMessageHandler::WriteFileContentToBuffer exit" )
+ }
+
+
+void CMSRPMessageHandler::WriteContentToBuffer()
+ {
+ MSRPLOG( "CMSRPMessageHandler::WriteContentToBuffer enter" )
+
+ TInt remBufferSize = iBuffer.MaxLength() - iBuffer.Length();
+ TInt remContentLength = iContentPtr.Length() + KCRAndLF().Length();
+
+ if( remContentLength > remBufferSize )
+ {
+ iBuffer.Append( iContentPtr.Mid(0, remBufferSize) );
+ iContentPtr.Set(iContentPtr.Mid(remBufferSize));
+ iWriteDone = ETrue;
+ }
+ else
+ {
+ iBuffer.Append( iContentPtr );
+ iContentPtr.Set(KNullDesC8);
+ iBuffer.Append( KCRAndLF );
+ }
+
+ MSRPLOG( "CMSRPMessageHandler::WriteContentToBuffer exit" )
+ }
+
+
+void CMSRPMessageHandler::WriteEndLineToBuffer(MMSRPMessageHandler::TMsrpMsgEndStatus aEndFlag)
+ {
+ MSRPLOG( "CMSRPMessageHandler::WriteEndLineToBuffer enter" )
+
+ TInt remBufferSize = iBuffer.MaxLength() - iBuffer.Length();
+ TInt endlineSize = iTransactionId.Length() + KEndlineConstLength;
+
+ if( endlineSize <= remBufferSize )
+ {
+ iBuffer.Append( KDashLine );
+ iBuffer.Append( iTransactionId );
+
+ if(iActiveMsgType == EMSRPResponse)
+ {
+ iBuffer.Append( KMessageEndSign );
+ iState = EMessageSent;
+ }
+ else
+ {
+ if( aEndFlag )
+ {
+ iBuffer.Append( KMessageContinuesSign );
+ }
+ else
+ {
+ iBuffer.Append( KMessageEndSign );
+ iState = EMessageSent;
+ }
+ }
+ iBuffer.Append( KCRAndLF );
+ }
+ iWriteDone = ETrue;
+ MSRPLOG( "CMSRPMessageHandler::WriteEndLineToBuffer exit" )
+ }
+
+
+TInt CMSRPMessageHandler::ExtractByteRangeParams( TDesC8& aHeaderValue, TInt& aStartPos, TInt& aEndPos, TInt& aTotal )
+ {
+ MSRPLOG( "CMSRPMessageHandler::ExtractByteRangeParams exit" )
+
+ TChar dashCharacter( KDashCharacter );
+ TInt position1 = aHeaderValue.Locate( dashCharacter );
+ if ( position1 == KErrNotFound )
+ {
+ // no data
+ return KErrArgument;
+ }
+ TPtrC8 startPosDes = aHeaderValue.Left( position1 );
+ TChar divideCharacter( KDividedCharacter );
+ TInt position2 = aHeaderValue.Locate( divideCharacter );
+ if ( position2 == KErrNotFound )
+ {
+ // no data
+ return KErrArgument;
+ }
+ TPtrC8 endPosDes = aHeaderValue.Mid( position1 + 1, position2 - ( position1 + 1 ) );
+ TPtrC8 totalDes = aHeaderValue.Mid( position2 + 1 );
+
+ aStartPos = TMSRPUtil::ConvertToNumber( startPosDes );
+ aEndPos = TMSRPUtil::ConvertToNumber( endPosDes );
+ aTotal = TMSRPUtil::ConvertToNumber( totalDes );
+
+ MSRPLOG( "CMSRPMessageHandler::ExtractByteRangeParams exit" )
+ return KErrNone;
+ }
+
+
+RStringF CMSRPMessageHandler::GetStatusStringL( TUint aStatusCode )
+ {
+ MSRPLOG( "CMSRPMessageHandler::GetStatusString enter" )
+ RStringF statusString;
+ CleanupClosePushL( statusString );
+
+ switch( aStatusCode )
+ {
+ case CMSRPResponse::EAllOk:
+ {
+ statusString = MSRPStrings::StringF( MSRPStrConsts::EAllOk );
+ break;
+ }
+ case CMSRPResponse::EUnintelligibleRequest:
+ {
+ statusString = MSRPStrings::StringF( MSRPStrConsts::EUnintelligibleRequest );
+ break;
+ }
+ case CMSRPResponse::EActionNotAllowed:
+ {
+ statusString = MSRPStrings::StringF( MSRPStrConsts::EActionNotAllowed );
+ break;
+ }
+ case CMSRPResponse::ETimeout:
+ {
+ statusString = MSRPStrings::StringF( MSRPStrConsts::ETimeout );
+ break;
+ }
+ case CMSRPResponse::EStopSending:
+ {
+ statusString = MSRPStrings::StringF( MSRPStrConsts::EStopSending );
+ break;
+ }
+ case CMSRPResponse::EMimeNotUnderstood:
+ {
+ statusString = MSRPStrings::StringF( MSRPStrConsts::EMimeNotUnderstood );
+ break;
+ }
+ case CMSRPResponse::EParameterOutOfBounds:
+ {
+ statusString = MSRPStrings::StringF( MSRPStrConsts::EParameterOutOfBounds );
+ break;
+ }
+ case CMSRPResponse::ESessionDoesNotExist:
+ {
+ statusString = MSRPStrings::StringF( MSRPStrConsts::ESessionDoesNotExist );
+ break;
+ }
+ case CMSRPResponse::EUnknownRequestMethod:
+ {
+ statusString = MSRPStrings::StringF( MSRPStrConsts::EUnknownRequestMethod );
+ break;
+ }
+ case CMSRPResponse::ESessionAlreadyBound:
+ {
+ statusString = MSRPStrings::StringF( MSRPStrConsts::ESessionAlreadyBound );
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+
+ CleanupStack::PopAndDestroy( );
+ MSRPLOG( "CMSRPMessageHandler::GetStatusString exit" )
+ return statusString;
+ }
+
+
+TUint CMSRPMessageHandler::CheckValidityOfMessage( TMSRPMessageType aMessageType, CMSRPMessageBase* aMessage )
+ {
+ MSRPLOG( "CMSRPMessageHandler::CheckValidityOfMessage enter" )
+
+ if( aMessageType == EMSRPMessage )
+ {
+ if(!aMessage->MessageIdHeader())
+ {
+ return CMSRPResponse::EUnintelligibleRequest;
+ }
+ CMSRPMessage* message = static_cast<CMSRPMessage*>(aMessage);
+ if(message->IsContent() && !message->ContentTypeHeader())
+ {
+ return CMSRPResponse::EUnintelligibleRequest;
+ }
+ }
+
+ MSRPLOG( "CMSRPMessageHandler::CheckValidityOfMessage exit" )
+ return CMSRPResponse::EAllOk;
+ }
+