1 /*

     2 * Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html."

     8 * Initial Contributors:

     9 * Nokia Corporation - initial contribution.

    10 * Contributors:

    11 *

    12 * Description:

    13 * MSRP Implementation

    14 *

    15 */

    16 

    17 // CLASS HEADER

    18 #include "CMSRPMessageHandler.h"

    19 

    20 

    21 // INCLUDES

    22 #include <e32math.h>

    23 #include <s32mem.h>

    24 

    25 #include "MMSRPWriterObserver.h"

    26 #include "CMSRPMessage.h"

    27 #include "CMSRPResponse.h"

    28 #include "CMSRPByteRangeHeader.h"

    29 #include "CMSRPToPathHeader.h"

    30 #include "CMSRPFromPathHeader.h"

    31 #include "CMSRPMessageIdHeader.h"

    32 #include "CMSRPSuccessReportHeader.h"

    33 #include "CMSRPFailureReportHeader.h"

    34 #include "CMSRPContentTypeHeader.h"

    35 #include "MSRPStrings.h"

    36 #include "MsrpStrConsts.h"

    37 #include "TMSRPUtil.h"

    38 #include "MMSRPConnection.h"

    39 #include "MMSRPMessageObserver.h"

    40 

    41 // Constants

    42 const TInt KEndlineConstLength = 10;

    43 

    44 

    45 TInt CMSRPMessageHandler::LinkOffset()

    46     {

    47     return _FOFF(CMSRPMessageHandler,iLink);

    48     }

    49 

    50 // -----------------------------------------------------------------------------

    51 // CMSRPMessageHandler::NewL

    52 // -----------------------------------------------------------------------------

    53 //

    54 CMSRPMessageHandler* CMSRPMessageHandler::NewL( MMSRPMessageObserver* aMessageObserver, const TDesC8& aMessage )

    55     {    

    56     CMSRPMessageHandler* self = CMSRPMessageHandler::NewLC( aMessageObserver, aMessage );

    57     CleanupStack::Pop( self );

    58     return self;

    59     }

    60 

    61 CMSRPMessageHandler* CMSRPMessageHandler::NewL( TMSRPMessageType aMessageType )

    62     {

    63     CMSRPMessageHandler* self = CMSRPMessageHandler::NewLC( aMessageType );

    64     CleanupStack::Pop( self );

    65     return self;

    66     }

    67 

    68 // -----------------------------------------------------------------------------

    69 // CMSRPMessageHandler::NewLC

    70 // -----------------------------------------------------------------------------

    71 //

    72 CMSRPMessageHandler* CMSRPMessageHandler::NewLC( MMSRPMessageObserver* aMessageObserver, const TDesC8& aMessage )

    73     {    

    74     CMSRPMessageHandler* self = new (ELeave) CMSRPMessageHandler( aMessageObserver );

    75     CleanupStack::PushL( self );

    76     self->ConstructL( aMessage );

    77     return self;

    78     }

    79 

    80 CMSRPMessageHandler* CMSRPMessageHandler::NewLC( TMSRPMessageType aMessageType )

    81     {

    82     CMSRPMessageHandler* self = new (ELeave) CMSRPMessageHandler();

    83     CleanupStack::PushL( self );

    84     self->ConstructL( aMessageType );

    85     return self;

    86     }

    87 

    88 // -----------------------------------------------------------------------------

    89 // CMSRPMessageHandler::ConstructL

    90 // -----------------------------------------------------------------------------

    91 //

    92 void CMSRPMessageHandler::ConstructL( const TDesC8& aMessage )

    93     {

    94     MSRPLOG( "CMSRPMessageHandler::ConstructL enter" )

    95     RDesReadStream readStream( aMessage );

    96 

    97     if ( CMSRPMessage::IsMessage( aMessage ) )

    98         {

    99         iMessage = CMSRPMessage::InternalizeL( readStream );

   100         if( iMessage->IsContent() )

   101             {

   102             iContentPtr.Set(iMessage->Content());

   103             }

   104         }    

   105     else

   106         {

   107         User::Leave( KErrArgument );

   108         }

   109     

   110     iBuffer.CreateL( KMaxBufferSize );

   111     iState = EIdle;

   112     MSRPStrings::OpenL();

   113     MSRPLOG( "CMSRPMessageHandler::ConstructL exit" )

   114     }

   115 

   116 

   117 void CMSRPMessageHandler::ConstructL( TMSRPMessageType aMessageType )

   118     {

   119     MSRPLOG2( "CMSRPMessageHandler::ConstructL enter - MessageType %d", aMessageType )

   120     if( aMessageType == EMSRPMessage )

   121         {

   122         iMessage = new ( ELeave ) CMSRPMessage();

   123         }

   124     else if( aMessageType == EMSRPResponse )

   125         {

   126         iResponse = new ( ELeave ) CMSRPResponse();

   127         }

   128     else if( aMessageType == EMSRPReport )

   129         {

   130         // Since Reports are not supported now.. jus create a message class

   131         iMessage = new ( ELeave ) CMSRPMessage();            

   132         }

   133     else

   134         {

   135         // Maybe AUTH or some unrecognized request. For now just create a message class

   136         iMessage = new ( ELeave ) CMSRPMessage();

   137         }

   138     

   139     iActiveMsgType = aMessageType;

   140     iBuffer.CreateL( KSmallBuffer );

   141     iState = EIdle;    

   142     MSRPStrings::OpenL();

   143     MSRPLOG( "CMSRPMessageHandler::ConstructL exit" )

   144     }

   145 

   146 

   147 // -----------------------------------------------------------------------------

   148 // Constructor

   149 // -----------------------------------------------------------------------------

   150 //

   151 CMSRPMessageHandler::CMSRPMessageHandler( MMSRPMessageObserver* aMessageObserver )

   152     {

   153     iMSRPMessageObserver = aMessageObserver;

   154     }

   155 

   156 CMSRPMessageHandler::CMSRPMessageHandler( )

   157     {

   158     

   159     }

   160 

   161 // -----------------------------------------------------------------------------

   162 // Destructor

   163 // -----------------------------------------------------------------------------

   164 //

   165 CMSRPMessageHandler::~CMSRPMessageHandler( )

   166     {

   167     delete iMessage;

   168     delete iResponse;

   169     delete iFileBuffer;

   170     iBuffer.Close();

   171     MSRPStrings::Close();

   172     iChunkList.ResetAndDestroy();

   173     iChunkList.Close();

   174     //iFile.Flush();

   175     iFile.Close();

   176     }

   177 

   178 

   179 void CMSRPMessageHandler::AddHeaderL( TMsrpHeaderType aHeaderType, TPtrC8& aHeaderValue, TPtrC8& /*aHeaderTypeAndValue*/ )

   180     {

   181     MSRPLOG( "CMSRPMessageHandler::AddHeaderL enter" )

   182     CMSRPMessageBase* messageBase = NULL;

   183     if( iResponse )

   184         {

   185         messageBase = iResponse;

   186         }

   187     else

   188         {

   189         messageBase = iMessage;

   190         }

   191         

   192     TInt err = KErrNone;

   193     switch( aHeaderType )

   194         {

   195         case EToPath:        

   196             {

   197             messageBase->SetToPathHeader( CMSRPToPathHeader::DecodeL( aHeaderValue ) );

   198             break;

   199             }

   200         case EFromPath:      

   201             {

   202             messageBase->SetFromPathHeader( CMSRPFromPathHeader::DecodeL( aHeaderValue ) );

   203             break;

   204             }

   205         case EMessageId:     

   206             {

   207             messageBase->SetMessageIdHeader( CMSRPMessageIdHeader::NewL( aHeaderValue ) );

   208             break;

   209             }

   210         case EByteRange:     

   211             {

   212             TInt startPos(0);

   213             TInt endPos(0);

   214             TInt total(0); 

   215             err =  ExtractByteRangeParams( aHeaderValue, startPos, endPos, total );

   216             messageBase->SetByteRangeHeader( CMSRPByteRangeHeader::NewL( startPos, endPos, total ));

   217             break;

   218             }

   219         case ESuccessReport: 

   220             {

   221             if( aHeaderValue == MSRPStrings::StringF( MSRPStrConsts::EYes ).DesC())

   222                 {

   223                 messageBase->SetSuccessReportHeader( 

   224                         CMSRPSuccessReportHeader::NewL( MSRPStrings::StringF( MSRPStrConsts::EYes ) ) );

   225                 }

   226             else if( aHeaderValue == MSRPStrings::StringF( MSRPStrConsts::ENo ).DesC())

   227                 {

   228                 messageBase->SetSuccessReportHeader( 

   229                         CMSRPSuccessReportHeader::NewL( MSRPStrings::StringF( MSRPStrConsts::ENo ) ) );

   230                 }  

   231             else

   232                 {

   233                 err = KErrArgument;

   234                 }

   235             break;

   236             }                

   237         case EFailureReport: 

   238             {

   239             if( aHeaderValue == MSRPStrings::StringF( MSRPStrConsts::EYes ).DesC())

   240                 {

   241                 messageBase->SetFailureReportHeader( 

   242                         CMSRPFailureReportHeader::NewL( MSRPStrings::StringF( MSRPStrConsts::EYes ) ) );

   243                 }

   244             else if( aHeaderValue == MSRPStrings::StringF( MSRPStrConsts::ENo ).DesC())

   245                 {

   246                 messageBase->SetFailureReportHeader( 

   247                         CMSRPFailureReportHeader::NewL( MSRPStrings::StringF( MSRPStrConsts::ENo ) ) );

   248                 }

   249             else if( aHeaderValue == MSRPStrings::StringF( MSRPStrConsts::EPartial ).DesC())

   250                 {

   251                 messageBase->SetFailureReportHeader( 

   252                         CMSRPFailureReportHeader::NewL( MSRPStrings::StringF( MSRPStrConsts::EPartial ) ) );

   253                 }

   254             else

   255                 {

   256                 err = KErrArgument;

   257                 }

   258             break;

   259             }                

   260         case EContentType:   

   261             {

   262             messageBase->SetContentTypeHeader( CMSRPContentTypeHeader::NewL( aHeaderValue ) );

   263             break;

   264             }                

   265         case EStatus:        

   266             {

   267             break; // required for reports only. Not handled now

   268             }              

   269         default:             

   270             {

   271             break;

   272             }                   

   273         }

   274     User::LeaveIfError(err);

   275     

   276     MSRPLOG( "CMSRPMessageHandler::AddHeaderL exit" )

   277     }

   278 

   279     

   280 void CMSRPMessageHandler::AddContentL( TPtrC8& aContent )

   281     {

   282     MSRPLOG( "CMSRPMessageHandler::AddContentL enter" )

   283     if( iMessage )

   284         {

   285         if( iBuffer.Length() + aContent.Length() > iBuffer.MaxLength() )

   286             {

   287             iBuffer.ReAllocL(iBuffer.Length() + aContent.Length());

   288             iBuffer.Append(aContent);

   289             }

   290         else

   291             {

   292             iBuffer.Append(aContent);

   293             }

   294         }    

   295     MSRPLOG( "CMSRPMessageHandler::AddContentL exit" )

   296     }

   297 

   298 

   299 void CMSRPMessageHandler::SetTransactionId( TPtrC8& aTransactionId )

   300     {

   301     MSRPLOG( "CMSRPMessageHandler::SetTransactionId enter" )    

   302     iTransactionId = aTransactionId;    

   303     MSRPLOG( "CMSRPMessageHandler::SetTransactionId exit" )

   304     }

   305 

   306 

   307 void CMSRPMessageHandler::SetStatusOfResponseL( TPtrC8& aStatusCode, TPtrC8& /*aStatusMessage*/ )

   308     {

   309     MSRPLOG( "CMSRPMessageHandler::SetStatusOfResponseL enter" )

   310     if( iResponse )

   311         {

   312         TUint statusCodeVal = TMSRPUtil::ConvertToNumber( aStatusCode );

   313         RStringF statusString = GetStatusStringL( statusCodeVal );                        

   314         iResponse->SetStatusCodeL( statusCodeVal );

   315         iResponse->SetReasonPhrase( statusString );

   316         }    

   317     MSRPLOG( "CMSRPMessageHandler::SetStatusOfResponseL exit" )

   318     }

   319 

   320 

   321 void CMSRPMessageHandler::EndOfMessageL( TMsrpMsgEndStatus aStatus )

   322     {

   323     MSRPLOG( "CMSRPMessageHandler::EndOfMessageL enter" )  

   324     if( iMessage && iBuffer.Length() )

   325         {

   326         HBufC8* contentOfMessage = HBufC8::NewL( iBuffer.Length() );

   327         *contentOfMessage = iBuffer;

   328         iMessage->SetContent( contentOfMessage );

   329         iBuffer.Zero();

   330         }

   331     iMsgEndStatus = aStatus;    

   332     MSRPLOG( "CMSRPMessageHandler::EndOfMessageL exit" )

   333     }

   334 

   335 

   336 MMSRPIncomingMessage::TMSRPMessageType CMSRPMessageHandler::MessageType( )

   337     {

   338     MSRPLOG( "CMSRPMessageHandler::MessageType enter" )

   339     MSRPLOG2("Message Type = %d", iActiveMsgType ); 

   340     return iActiveMsgType;

   341     }

   342 

   343 

   344 CMSRPMessage* CMSRPMessageHandler::GetIncomingMessage( )

   345     {

   346     MSRPLOG( "CMSRPMessageHandler::GetIncomingMessage enter" )  

   347     if( iMessage )

   348         {

   349         return iMessage;

   350         }

   351     return NULL;

   352     }

   353 

   354 

   355 void CMSRPMessageHandler::UpdateResponseStateL(CMSRPMessageHandler *incomingMsgHandler)

   356     {

   357     MSRPLOG( "CMSRPMessageHandler::UpdateResponseState enter" )

   358     TBuf8<100> iTransactionId = incomingMsgHandler->TransactionId();

   359     for(TInt i=0;i<iChunkList.Count();i++)

   360        {

   361         if(iTransactionId == iChunkList[i]->GetTransactionId())

   362             {

   363              iChunkList[i]->SetResponseSent(ETrue);

   364              ReceiveFileStateL(iChunkList[i]->GetEndPos()- iChunkList[i]->GetStartPos() + 1);                    

   365             }

   366        }

   367     MSRPLOG( "CMSRPMessageHandler::UpdateResponseState exit" )

   368     }

   369 

   370 

   371 void CMSRPMessageHandler::ReceiveFileStateL( TInt aBytesTransferred )

   372     {

   373     MSRPLOG( "CMSRPMessageHandler::ReceiveFileState enter" )

   374     MSRPLOG2( "CMSRPMessageHandler::ReceiveFileState Notify %d", iProgress )

   375     MSRPLOG2( "CMSRPMessageHandler::ReceiveFileState iFileNotified %d", iNotifiedBytes )    

   376     MSRPLOG2( "CMSRPMessageHandler::ReceiveFileState iunnotified %d", iPendingBytes )

   377     MSRPLOG2( "CMSRPMessageHandler::ReceiveFileState aBytesTransferred %d", aBytesTransferred )

   378     MSRPLOG2( "CMSRPMessageHandler::ReceiveFileState iFileSize %d", iFileSize )

   379     

   380     iPendingBytes += aBytesTransferred;

   381     

   382     if(iNotifiedBytes + iPendingBytes == iFileSize)

   383         {

   384         iFileTransferComplete = ETrue;

   385         }

   386     

   387     if(iPendingBytes >= KMaxChunkReadSize)

   388         {

   389         MSRPLOG( "CMSRPMessageHandler::ReceiveFileState unnotified exceeds threshold" )

   390         MSRPLOG2( "CMSRPMessageHandler::ReceiveFileState iFileReceiveComplete: %d", iFileTransferComplete )                

   391             

   392         iNotifiedBytes += iPendingBytes;

   393         iPendingBytes = 0;

   394         //notify client of progress

   395         if(iProgress && !iFileTransferComplete)

   396             iMSRPMessageObserver->MessageReceiveProgressL(iNotifiedBytes, iFileSize);

   397         }

   398  

   399      MSRPLOG( "CMSRPMessageHandler::ReceiveFileState exit" )   

   400      }

   401     

   402 

   403 TBool CMSRPMessageHandler::SendResponseL( MMSRPMessageObserver* aMessageObserver, 

   404                                             MMSRPConnection& aConnection, TUint aResponseCode )

   405     {

   406     MSRPLOG( "CMSRPMessageHandler::SendResponseL enter" )

   407         

   408     iMSRPMessageObserver = aMessageObserver;

   409     

   410     if( !aResponseCode )

   411         {

   412         aResponseCode = CheckValidityOfMessage( EMSRPMessage, iMessage );

   413         }

   414     

   415     TBool sendResponse = ETrue;

   416     if( iMessage->FailureReportHeader() )

   417         {

   418         HBufC8* frHeaderValue = iMessage->FailureReportHeader()->ToTextValueLC();

   419         if( frHeaderValue->Des() == MSRPStrings::StringF( MSRPStrConsts::ENo ).DesC() )

   420             {

   421             sendResponse = EFalse;

   422             }

   423         else if( (frHeaderValue->Des() == MSRPStrings::StringF( MSRPStrConsts::EPartial ).DesC()) 

   424                 && (aResponseCode == CMSRPResponse::EAllOk) )

   425             {

   426             sendResponse = EFalse;

   427             }

   428         CleanupStack::PopAndDestroy(frHeaderValue);

   429         }

   430     

   431     if( !iMessage->ToPathHeader() || !iMessage->FromPathHeader() )

   432         {

   433         aResponseCode = CMSRPResponse::EUnknownCode;

   434         sendResponse = EFalse;

   435         }

   436     

   437     if(sendResponse)

   438         {

   439         RStringF statusString = GetStatusStringL( aResponseCode );

   440         iResponse = new ( ELeave ) CMSRPResponse( aResponseCode, statusString ) ;

   441         

   442         HBufC8* fromPathValue = iMessage->FromPathHeader()->ToTextValueLC();

   443         iResponse->SetToPathHeader( CMSRPToPathHeader::DecodeL( *fromPathValue ) );

   444         CleanupStack::PopAndDestroy(fromPathValue);

   445         

   446         HBufC8* toPathValue = iMessage->ToPathHeader()->ToTextValueLC();

   447         iResponse->SetFromPathHeader( CMSRPFromPathHeader::DecodeL( *toPathValue ) );

   448         CleanupStack::PopAndDestroy(toPathValue);

   449         

   450         iActiveMsgType = EMSRPResponse;

   451         aConnection.SendL( *this );

   452         }

   453   

   454     MSRPLOG( "CMSRPMessageHandler::SendResponseL exit" )

   455 	

   456 	if( aResponseCode == CMSRPResponse::EAllOk )

   457         return ETrue;

   458     else

   459         return EFalse;

   460     }

   461 

   462 

   463 TBool CMSRPMessageHandler::IfResponseReqL()

   464     {

   465     TBool responseReq = ETrue;

   466     if( iMessage->FailureReportHeader() )

   467         {

   468         HBufC8* frHeaderValue = iMessage->FailureReportHeader()->ToTextValueLC();

   469         if( frHeaderValue->Des() == MSRPStrings::StringF( MSRPStrConsts::ENo ).DesC() )

   470             {

   471              responseReq = EFalse;

   472             }

   473         else if( (frHeaderValue->Des() == MSRPStrings::StringF( MSRPStrConsts::EPartial ).DesC()))

   474             {

   475             responseReq = EFalse;

   476             }

   477         CleanupStack::PopAndDestroy(frHeaderValue);     

   478         }

   479     return responseReq;

   480     }

   481 

   482 

   483 TDesC8& CMSRPMessageHandler::TransactionId( )

   484     {

   485     MSRPLOG( "CMSRPMessageHandler::TransactionId enter" )

   486     return iTransactionId;

   487     }

   488 

   489 

   490 CMSRPResponse* CMSRPMessageHandler::GetIncomingResponse( )

   491     {

   492     MSRPLOG( "CMSRPMessageHandler::GetIncomingResponse enter" )

   493     if( iResponse )

   494         {

   495         return iResponse;

   496         }

   497     return NULL;

   498     }

   499 

   500 

   501 void CMSRPMessageHandler::SendMessageL( MMSRPConnection& aConnection )

   502     {

   503     MSRPLOG( "CMSRPMessageHandler::SendMessageL enter" )    

   504     iActiveMsgType = EMSRPMessage;

   505     aConnection.SendL( *this );

   506     MSRPLOG( "CMSRPMessageHandler::SendMessageL exit" )

   507     }

   508 

   509 

   510 void CMSRPMessageHandler::SendFileL(MMSRPConnection& aConnection)

   511     {

   512     MSRPLOG( "CMSRPMessageHandler::SendFileL enter" ) 

   513     /* Flags  */

   514     isFile = ETrue;    

   515     iProgress = iMessage->GetNotifyProgress();

   516     

   517     User::LeaveIfError(iFs.Connect());

   518     User::LeaveIfError(iFile.Open(iFs, iMessage->GetFileName(), EFileShareReadersOrWriters)); 

   519     iFile.Size(iFileSize);

   520     iFileBuffer = HBufC8::NewL(KMaxChunkReadSize);            

   521     FillFileBufferL();

   522     iActiveMsgType = EMSRPMessage;

   523     aConnection.SendL( *this );

   524     

   525     MSRPLOG( "CMSRPMessageHandler::SendFileL exit" )     

   526     }

   527 

   528 

   529 TInt CMSRPMessageHandler::FillFileBufferL()

   530     {    

   531     MSRPLOG( "CMSRPMessageHandler::FillFileBufferL enter" )

   532     iStartPosInBuffer = 0;

   533     iEndPosInBuffer = 0;

   534     iBufPosInFile+=iFileBuffer->Length();

   535     iFileBuffer->Des().Zero();

   536     TPtr8 ptr(iFileBuffer->Des());

   537     User::LeaveIfError(iFile.Read(iBufPosInFile, ptr, KMaxChunkReadSize));

   538     MSRPLOG2( "CMSRPMessageHandler::FillFileBufferL File Buffer Length %d", iFileBuffer->Length());

   539     MSRPLOG( "CMSRPMessageHandler::FillFileBufferL exit" )     

   540 	return iFileBuffer->Length();

   541     }

   542 

   543 

   544 void CMSRPMessageHandler::ReceiveFileL( )

   545     {

   546     MSRPLOG( "CMSRPMessageHandler::ReceiveFileL enter" )

   547     isFile = ETrue;

   548     iProgress = iMessage->GetNotifyProgress();

   549     

   550     User::LeaveIfError(iFs.Connect());

   551     User::LeaveIfError(iFile.Replace(iFs,iMessage->GetFileName(),EFileWrite));

   552     iFileSize = iMessage->GetFileSize();

   553     iFileBuffer = HBufC8::NewL(KMaxChunkReadSize);

   554     

   555     MSRPLOG( "CMSRPMessageHandler::ReceiveFileL exit" )

   556     }

   557 

   558 

   559 void CMSRPMessageHandler::WritetoFileL(CMSRPMessageHandler *incomingMsgHandler )

   560     {

   561     MSRPLOG( "CMSRPMessageHandler::WriteToFile enter" )

   562     CMSRPMessage* inFileChunk = incomingMsgHandler->GetIncomingMessage();

   563     HBufC8* messageContent = NULL;

   564     if(inFileChunk->IsContent())

   565         {

   566         messageContent = HBufC8::NewL(inFileChunk->Content().Length());

   567         *messageContent = inFileChunk->Content();        

   568         WriteChunkToFileL(*messageContent,incomingMsgHandler->TransactionId());

   569        

   570         if (!incomingMsgHandler->IfResponseReqL())

   571             ReceiveFileStateL(messageContent->Length());

   572         }

   573     delete messageContent;

   574     MSRPLOG( "CMSRPMessageHandler::WriteToFile exit" )          

   575     }               

   576     

   577     

   578 void CMSRPMessageHandler::WriteChunkToFileL(const TDesC8& aFileChunk ,TDesC8& aTransactionId)  

   579     {    

   580     MSRPLOG( "CMSRPMessageHandler::WriteChunktoFile enter" )      

   581      if(iBufPosInFile<(iFileSize-1))

   582        {

   583        iFile.Write(iBufPosInFile,aFileChunk);

   584        

   585        /* Create and update the structure */

   586        CMSRPMessageChunkState* iChunk = CMSRPMessageChunkState::NewL( ); 

   587        iChunk->SetStartPos(iBufPosInFile);

   588        iBufPosInFile += aFileChunk.Length();

   589        iChunk->SetEndPos(iBufPosInFile-1);

   590        iChunk->SetTransactionId(aTransactionId);

   591        iChunkList.Append(iChunk);

   592         }

   593        else

   594            {

   595             //Receive Bytes greater than file Size

   596             User::Leave( KErrArgument );

   597            }

   598   

   599        MSRPLOG( "CMSRPMessageHandler::WriteChunktoFile exit" )

   600      

   601     }

   602 

   603 

   604 TBool CMSRPMessageHandler::IsOwnerOfResponse( MMSRPIncomingMessage& aIncomingMessage )

   605     {

   606     MSRPLOG( "CMSRPMessageHandler::IsOwnerOfResponse enter" )

   607     if(isFile)

   608         {

   609          /*  compare for transaction id  */

   610         for(TInt i=0;i<iChunkList.Count();i++)

   611            {

   612             if(aIncomingMessage.TransactionId() == iChunkList[i]->GetTransactionId())

   613              {

   614              if( iState == EWaitingForResponse || ( iState == EMessageSent && iResponseNeeded ))

   615                  {

   616                    if (i == iChunkList.Count()-1)

   617                      {

   618                       iResponseNeeded = EFalse;

   619                       iState = EMessageDone;

   620                      }

   621                  }

   622                return ETrue;

   623              }

   624            }

   625         }

   626     if( aIncomingMessage.TransactionId() == iTransactionId )

   627         {

   628         if( iState == EWaitingForResponse || ( iState == EMessageSent && iResponseNeeded ))

   629             {

   630             iResponseNeeded = EFalse;

   631             return ETrue;

   632             }

   633         }  

   634               

   635     MSRPLOG( "CMSRPMessageHandler::IsOwnerOfResponse exit" )

   636     return EFalse;

   637     }

   638 

   639 

   640 void CMSRPMessageHandler::ConsumeFileResponseL(MMSRPIncomingMessage& aIncomingMessage )

   641     {

   642     MSRPLOG( "CMSRPMessageHandler::ConsumeFileResponseL enter" )

   643     CMSRPResponse* response = aIncomingMessage.GetIncomingResponse();

   644     TUint statusCode = response->StatusCode();

   645     

   646     for(TInt i=0;i<iChunkList.Count();i++)

   647        {

   648         if(aIncomingMessage.TransactionId()== iChunkList[i]->GetTransactionId())

   649             {

   650             iChunkList[i]->SetResponseReceived(ETrue);

   651             SendFileStateL(iChunkList[i]->GetEndPos()- iChunkList[i]->GetStartPos() + 1 ) ;

   652             }                     

   653        }          

   654       

   655     MSRPLOG( "CMSRPMessageHandler::ConsumeFileResponseL exit" )     

   656     } 

   657 

   658 

   659 void CMSRPMessageHandler::SendFileStateL(TInt aBytesTransferred )

   660     {

   661     MSRPLOG( "CMSRPMessageHandler::SendFileStateL enter" )

   662     MSRPLOG2( "CMSRPMessageHandler::SendFileStateL granularity %d", iProgress )

   663     MSRPLOG2( "CMSRPMessageHandler::SendFileStateL iFileNotified %d", iNotifiedBytes )    

   664     MSRPLOG2( "CMSRPMessageHandler::SendFileStateL iunnotified %d", iPendingBytes )

   665     MSRPLOG2( "CMSRPMessageHandler::SendFileStateL aBytesTransferred %d", aBytesTransferred )

   666     MSRPLOG2( "CMSRPMessageHandler::SendFileStateL iFileSize %d", iFileSize )

   667 

   668     iPendingBytes += aBytesTransferred;

   669     

   670     if(iNotifiedBytes + iPendingBytes == iFileSize)

   671         {

   672         iFileTransferComplete = ETrue;      

   673         } 

   674     

   675     if(iPendingBytes  >= KMaxChunkReadSize)

   676         {

   677         MSRPLOG( "CMSRPMessageHandler::SendFileStateL unnotified exceeds threshold" )

   678         MSRPLOG2( "CMSRPMessageHandler::SendFileStateL iFileSendComplete: %d", iFileTransferComplete )                

   679         iNotifiedBytes += iPendingBytes;

   680         iPendingBytes = 0;

   681 

   682         //notify client of progress

   683         if( iProgress && !iFileTransferComplete )//send progress requested and avoid double notifn. as send complete not handled in waitfor clientstate

   684             iMSRPMessageObserver->MessageSendProgressL(iNotifiedBytes, iFileSize);//iByteinPos

   685 

   686         }

   687     MSRPLOG( "CMSRPMessageHandler::SendFileStateL exit" )

   688     }

   689 

   690 

   691 TBool CMSRPMessageHandler::FileTransferComplete( )

   692     {

   693     if(iFileTransferComplete)

   694         return ETrue;

   695     else

   696         return EFalse;

   697     }

   698 

   699 

   700 TBool CMSRPMessageHandler::IsInFile()

   701     {

   702     if(isFile)

   703       {

   704        return ETrue;

   705       }

   706     return EFalse;

   707     }

   708 

   709 

   710 TBool CMSRPMessageHandler::ConsumeResponseL( MMSRPIncomingMessage& aIncomingMessage )

   711     {

   712     MSRPLOG( "CMSRPMessageHandler::ConsumeResponseL enter" )

   713     

   714     TBool ret;

   715     CMSRPResponse* response = aIncomingMessage.GetIncomingResponse();

   716     TUint statusCode = response->StatusCode();

   717        

   718     if( iMessage->FailureReportHeader() &&  

   719             (iMessage->FailureReportHeader()->ToTextValueLC()->Des() == 

   720             MSRPStrings::StringF( MSRPStrConsts::EPartial ).DesC()) &&

   721                 statusCode == CMSRPResponse::EAllOk )                

   722         {

   723         iState = EMessageDone;

   724         ret = EFalse;

   725         }

   726     else

   727         {        

   728         RStringF statusString = response->ReasonPhrase();

   729         iResponse = new (ELeave) CMSRPResponse( statusCode, statusString );

   730         HBufC8* toPathValue = response->ToPathHeader()->ToTextValueLC();

   731         HBufC8* fromPathValue = response->FromPathHeader()->ToTextValueLC();

   732         iResponse->SetToPathHeader( CMSRPToPathHeader::DecodeL( toPathValue->Des() ) );

   733         iResponse->SetFromPathHeader( CMSRPFromPathHeader::DecodeL( fromPathValue->Des() ) );

   734         CleanupStack::PopAndDestroy(fromPathValue);

   735         CleanupStack::PopAndDestroy(toPathValue);

   736         iState = EMessageDone;

   737         ret = ETrue;

   738         }

   739     

   740     if( iMessage->FailureReportHeader() )

   741         {

   742         CleanupStack::PopAndDestroy(); // FR header value from above

   743         }

   744          

   745     MSRPLOG( "CMSRPMessageHandler::ConsumeResponseL exit" )

   746     return ret;

   747     }

   748 

   749 

   750 TBool CMSRPMessageHandler::IsMessageComplete()

   751     {

   752     MSRPLOG( "CMSRPMessageHandler::IsMessageComplete enter" )

   753     if( iState == EMessageDone )

   754         return ETrue;

   755     else

   756         return EFalse;

   757     }

   758 

   759 

   760 TBool CMSRPMessageHandler::GetSendResultL( TUint &aErrorCode, HBufC8* &aMessageId )

   761     {

   762     MSRPLOG( "CMSRPMessageHandler::GetSendResult enter" )

   763     if( iState == EMessageDone )

   764         {

   765         aMessageId = iMessage->MessageIdHeader()->ToTextValueLC();

   766         CleanupStack::Pop(aMessageId);

   767         if(iResponse)

   768             {

   769             TUint code = iResponse->StatusCode();

   770             if( code == CMSRPResponse::EAllOk )

   771                 {

   772                 aErrorCode = ENoError;

   773                 }

   774             else if ( code == CMSRPResponse::ETimeout )

   775                 {

   776                 aErrorCode = ENetworkTimeout;

   777                 }

   778             else

   779                 {

   780                 aErrorCode = EUnrecoverableError;

   781                 }            

   782             }

   783         else

   784             {

   785             aErrorCode = ENoError;

   786             }

   787         }    

   788     MSRPLOG( "CMSRPMessageHandler::GetSendResult exit" )

   789     if( aErrorCode == EUnrecoverableError )

   790         {

   791         return ETrue;

   792         }

   793     else

   794         {

   795         return EFalse;

   796         }

   797     }

   798 

   799 

   800 MMSRPWriterObserver::TWriteStatus CMSRPMessageHandler::GetSendBufferL( TPtrC8& aData, TBool aInterrupt )

   801     {

   802     MSRPLOG( "CMSRPMessageHandler::GetSendBufferL enter" )

   803     iInterrupt = aInterrupt;

   804     iWriteDone = EFalse;

   805     iBuffer.Zero();

   806     

   807     while( !iWriteDone )

   808         {

   809         if( iState == EIdle )

   810             {

   811             if( iActiveMsgType == EMSRPMessage )

   812                 {

   813                 CreateByteRangeHeaderL();

   814                 }

   815             WriteInitialLineToBufferL();

   816             WriteHeadersToBufferL();

   817             }

   818             

   819         else if( iState == EInProgress )

   820             {

   821             if( iMessage->IsFile())

   822                 {

   823                 if (iActiveMsgType == EMSRPMessage)

   824                     WriteFileContentToBufferL();

   825                 else

   826                     WriteEndLineToBuffer();

   827                 }            

   828             else

   829                 {

   830                 if( iContentPtr.Length() )

   831                     WriteContentToBuffer();

   832                 else

   833                     WriteEndLineToBuffer();

   834                 }

   835             }

   836         else

   837             {

   838              User::LeaveIfError(KErrArgument);

   839             }

   840         }

   841     

   842     aData.Set(iBuffer);        

   843     MSRPLOG( "CMSRPMessageHandler::GetSendBufferL exit" )

   844     return EMsrpSocketWrite;

   845     }

   846 

   847 

   848 MMSRPWriterObserver::TMsgStatus CMSRPMessageHandler::WriteDoneL( TInt aStatus )

   849     {

   850     MSRPLOG( "CMSRPMessageHandler::WriteDoneL enter" )

   851     MMSRPWriterObserver::TMsgStatus retStatus = EUndefined;

   852 

   853     if( !aStatus )

   854         {

   855         /*if file send and message and response not needed, update progress*/

   856         if (isFile && iActiveMsgType == EMSRPMessage && iResponseNeeded == FALSE)

   857             {

   858             if (iFileBytesSent > 0)

   859                 SendFileStateL(iFileBytesSent);

   860             }

   861         

   862         if( iState == EMessageSent )

   863             {

   864             switch( iActiveMsgType )

   865                 {

   866                 case EMSRPMessage:

   867                     {

   868                     if( iResponseNeeded )

   869                         {

   870                         iState = EWaitingForResponse;

   871                         }

   872                     else

   873                         {

   874                         iState = EMessageDone;

   875                         }  

   876                     iMSRPMessageObserver->MessageSendCompleteL();

   877                     break;                    

   878                     }

   879                 case EMSRPResponse:

   880                     {

   881                     iState = EMessageDone;

   882                     iMSRPMessageObserver->MessageResponseSendCompleteL(*this);

   883                     break;

   884                     }

   885                 }

   886             //iActiveMsgType = EMSRPNotDefined;

   887             retStatus = MMSRPWriterObserver::EComplete;

   888             }        

   889         else if( iState ==  EInProgress )

   890             {

   891             retStatus = MMSRPWriterObserver::EPending;

   892             }            

   893         else if(iState == EChunkSent)

   894             {

   895             retStatus = MMSRPWriterObserver::EInterrupted;

   896             iState = EIdle;

   897             }        

   898         else

   899            {

   900            iMSRPMessageObserver->WriterError();

   901            }

   902         }

   903     MSRPLOG( "CMSRPMessageHandler::WriteDone exit" )

   904     return retStatus;

   905     }

   906 

   907 

   908 void CMSRPMessageHandler::CreateByteRangeHeaderL()

   909     {

   910     MSRPLOG( "CMSRPMessageHandler::CreateByteRangeHeaderL enter" )

   911     CMSRPByteRangeHeader* byteRange = NULL;

   912        

   913     if ( iMessage->IsFile())

   914         {                

   915         byteRange = CMSRPByteRangeHeader::NewL( iBufPosInFile+iStartPosInBuffer+1,KUnknownRange,iFileSize);

   916       

   917         CleanupStack::PushL(byteRange);

   918         iMessage->SetByteRangeHeader( byteRange );

   919         CleanupStack::Pop(byteRange);

   920         }

   921     else

   922         {

   923         if( !iMessage->ByteRangeHeader() )

   924             {

   925              if ( iMessage->IsContent() )

   926                  {

   927                  byteRange = CMSRPByteRangeHeader::NewL( 1,

   928                  iMessage->Content().Length(), iMessage->Content().Length() );

   929                  CleanupStack::PushL(byteRange);

   930                  }

   931              else

   932                  {

   933                  byteRange = CMSRPByteRangeHeader::NewL( 1, 0, 0 );

   934                  CleanupStack::PushL(byteRange);

   935                  }

   936             iMessage->SetByteRangeHeader( byteRange );

   937             CleanupStack::Pop(byteRange);

   938             }

   939         }

   940     MSRPLOG( "CMSRPMessageHandler::CreateByteRangeHeaderL exit" )

   941     }

   942 

   943 

   944 void CMSRPMessageHandler::CreateTransactionId()

   945     {

   946     MSRPLOG( "CMSRPMessageHandler::CreateTransactionId enter" )

   947     

   948     TTime now;

   949     now.HomeTime();

   950     TInt64 seed = now.Int64();

   951     TInt random = Math::Rand( seed );

   952     iTransactionId.NumUC( random );

   953     

   954     MSRPLOG( "CMSRPMessageHandler::CreateTransactionId exit" )

   955     }

   956 

   957 

   958 void CMSRPMessageHandler::WriteInitialLineToBufferL()

   959     {

   960     MSRPLOG( "CMSRPMessageHandler::WriteInitialLineToBufferL enter" )

   961     

   962     iBuffer.Append( MSRPStrings::StringF( MSRPStrConsts::EMSRP ).DesC() );

   963 

   964     iBuffer.Append( KSpaceChar );

   965     

   966     if (! (iActiveMsgType == EMSRPResponse) )

   967          {

   968          CreateTransactionId();

   969          }

   970    

   971     iBuffer.Append( iTransactionId );

   972 

   973     iBuffer.Append( KSpaceChar );

   974     

   975     if ( iActiveMsgType == EMSRPMessage )

   976         {

   977         iBuffer.Append( MSRPStrings::StringF( MSRPStrConsts::ESend ).DesC() );

   978         }

   979     else if ( iActiveMsgType == EMSRPResponse )

   980         {

   981         TBuf8< KMaxLengthOfStatusCode > statusCode;

   982         statusCode.NumUC( iResponse->StatusCode() );

   983         iBuffer.Append( statusCode );

   984         iBuffer.Append( KSpaceChar );

   985         iBuffer.Append( iResponse->ReasonPhrase().DesC() );

   986         }

   987     else

   988         {

   989         User::Leave( KErrArgument );

   990         }

   991 

   992     iBuffer.Append( KCRAndLF );

   993     

   994     iState = EInProgress;

   995     MSRPLOG( "CMSRPMessageHandler::WriteInitialLineToBufferL exit" )    

   996     }

   997 

   998 

   999 void CMSRPMessageHandler::WriteHeadersToBufferL()

  1000     {

  1001     MSRPLOG( "CMSRPMessageHandler::WriteHeadersToBufferL enter" )

  1002     CMSRPMessageBase* messageBase = NULL;

  1003     if( iActiveMsgType == EMSRPMessage )

  1004         {

  1005         messageBase = iMessage;

  1006         }

  1007     else if ( iActiveMsgType == EMSRPResponse )

  1008         {

  1009         messageBase = iResponse;

  1010         }

  1011     else

  1012         {

  1013         User::Leave( KErrArgument );

  1014         }

  1015             

  1016     // Check if appending headers will exceed max size

  1017     

  1018     __ASSERT_ALWAYS( messageBase->ToPathHeader(), User::Leave( KErrNotFound ) );

  1019     iBuffer.Append( messageBase->ToPathHeader()->ToTextLC()->Des() );

  1020     CleanupStack::PopAndDestroy(); // above

  1021     iBuffer.Append( KCRAndLF );

  1022 

  1023     __ASSERT_ALWAYS( messageBase->FromPathHeader(), User::Leave( KErrNotFound ) );

  1024     iBuffer.Append( messageBase->FromPathHeader()->ToTextLC()->Des() );

  1025     CleanupStack::PopAndDestroy(); // above

  1026     iBuffer.Append( KCRAndLF );

  1027     

  1028     if( iActiveMsgType != EMSRPResponse )

  1029         {

  1030         __ASSERT_ALWAYS( messageBase->MessageIdHeader(), User::Leave( KErrNotFound ) );

  1031         iBuffer.Append( messageBase->MessageIdHeader()->ToTextLC()->Des() );

  1032         CleanupStack::PopAndDestroy(); // above

  1033         iBuffer.Append( KCRAndLF );

  1034         }

  1035     

  1036     if( iActiveMsgType == EMSRPMessage )

  1037         {

  1038         if ( messageBase->SuccessReportHeader() )

  1039             {

  1040             iBuffer.Append( messageBase->SuccessReportHeader()->ToTextLC()->Des() );

  1041             CleanupStack::PopAndDestroy(); // above 

  1042             iBuffer.Append( KCRAndLF );

  1043             }

  1044 

  1045         if ( messageBase->FailureReportHeader() )

  1046             {

  1047             HBufC8* valueString = messageBase->FailureReportHeader()->ToTextValueLC();

  1048             if ( valueString->Des() == MSRPStrings::StringF( MSRPStrConsts::EYes ).DesC() ||

  1049                 valueString->Des() == MSRPStrings::StringF( MSRPStrConsts::EPartial ).DesC() )

  1050                 {

  1051                 iResponseNeeded = ETrue;

  1052                 }

  1053             CleanupStack::PopAndDestroy(valueString);

  1054 

  1055             iBuffer.Append( messageBase->FailureReportHeader()->ToTextLC()->Des() );

  1056             CleanupStack::PopAndDestroy(); // above

  1057             iBuffer.Append( KCRAndLF );

  1058             }

  1059         else

  1060             {

  1061             iResponseNeeded = ETrue;

  1062             }

  1063         }

  1064     

  1065     if( iActiveMsgType != EMSRPResponse )

  1066         {

  1067         iBuffer.Append( messageBase->ByteRangeHeader()->ToTextLC()->Des() );

  1068         CleanupStack::PopAndDestroy(); // above 

  1069         iBuffer.Append( KCRAndLF );

  1070         }

  1071     

  1072     if( iActiveMsgType == EMSRPMessage )

  1073         {

  1074         if ( messageBase->ContentTypeHeader() )

  1075             {

  1076             iBuffer.Append( messageBase->ContentTypeHeader()->ToTextLC()->Des() );

  1077             CleanupStack::PopAndDestroy(); // above 

  1078             iBuffer.Append( KCRAndLF );

  1079             iBuffer.Append( KCRAndLF );

  1080             

  1081             if(!iMessage->IsFile() && !iMessage->IsContent()) 

  1082                 {

  1083                 iBuffer.Append( KCRAndLF );

  1084                 }            

  1085             }

  1086         }

  1087         

  1088     MSRPLOG( "CMSRPMessageHandler::WriteHeadersToBufferL exit" )

  1089     }

  1090 

  1091 

  1092 void CMSRPMessageHandler::WriteFileContentToBufferL()

  1093     {

  1094     MSRPLOG( "CMSRPMessageHandler::WriteFileContentToBuffer enter" )

  1095     TInt endlineSize = iTransactionId.Length() + KEndlineConstLength;

  1096     TInt remBufferSize = iBuffer.MaxLength() - iBuffer.Length() - endlineSize - KCRAndLF().Length();

  1097     TInt chunkLength = iFileBuffer->Length() - iEndPosInBuffer;

  1098     

  1099     /*if(remBufferSize<0) TODO*/

  1100     if(chunkLength > remBufferSize)

  1101         {

  1102         iFileBytesSent = remBufferSize;

  1103         iBuffer.Append(iFileBuffer->Mid(iEndPosInBuffer, iFileBytesSent));

  1104         iEndPosInBuffer += iFileBytesSent;

  1105         if(iInterrupt)

  1106             {

  1107             WriteEndLineToBuffer(EMessageContinues);

  1108             //add chunk entry

  1109             CMSRPMessageChunkState* iChunk = CMSRPMessageChunkState::NewL( ); 

  1110             iChunk->SetStartPos(iBufPosInFile+iStartPosInBuffer);           

  1111             iChunk->SetEndPos(iBufPosInFile+iEndPosInBuffer-1);//since endpos is pointing to next start pos 

  1112             iChunk->SetTransactionId(iTransactionId);

  1113             iChunkList.Append(iChunk);

  1114 

  1115             iStartPosInBuffer = iEndPosInBuffer;

  1116             iState = EChunkSent;

  1117             }

  1118        /* else

  1119             {

  1120             //msg state remains InProgress (in write done return pending)

  1121             }*/

  1122         }

  1123     else //bytes completed in current file buffer

  1124         {

  1125         iFileBytesSent = chunkLength;

  1126         iBuffer.Append(iFileBuffer->Mid(iEndPosInBuffer, iFileBytesSent));

  1127         iEndPosInBuffer += iFileBytesSent;

  1128         iBuffer.Append(KCRAndLF());

  1129         

  1130         //add chunk entry

  1131         CMSRPMessageChunkState* iChunk = CMSRPMessageChunkState::NewL( ); 

  1132         iChunk->SetStartPos(iBufPosInFile+iStartPosInBuffer);           

  1133         iChunk->SetEndPos(iBufPosInFile+iEndPosInBuffer-1); 

  1134         iChunk->SetTransactionId(iTransactionId);